原型模式和單例模式的區別

原型模式和單例模式的區別

1.   定義上的區別

1.1.  原型模式

用原型模式是在已指定對象的基礎上，而後經過拷貝這些原型對象建立新的對象。

當要實例化的類是在運行時刻指定或者爲了不建立一個與產品類層次平行的工廠類層次時或者當一個類的實例只能有幾個不一樣狀態組合中的一種時 —— 創建相應數目的原型並克隆它們可能比每次用合適的狀態手工實例化該類更方便一些。 

1.2.  單例模式

單態設計模式的核心就是：將類的構造方法私有化，以後在類的內部產生實例化對象，並經過靜態方法返回實例化對象的應用。

若是不但願一個類產生更多對象的狀況下，必須使用單態模式，所謂單態就是在對象的入口處（構造方法）限制了對象的實例化操做。

2.   JAVA實現上的區別

2.1.  原型模式

import java.util.ArrayList;

class ConcretePrototype implements Cloneable {

    private String name;
    private ArrayList<String> nameList = new ArrayList<String>();

    public ConcretePrototype(String name) {
        this.name = name;
        this.nameList.add(this.name);
    }

    // 添加nameList中的對象
    public void setName(String name) {
        this.nameList.add(name);
    }

    public ArrayList<String> getNameList() {
        return this.nameList;
    }

    // 覆蓋Object基類中的clone()方法，並擴大該方法的訪問權限，具體化返回本類型
    public ConcretePrototype clone() {
        try {
            return (ConcretePrototype) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return null;
    }
}

public class TestConcretePrototype {
    public static void main(String args[]) {
        try {
            ConcretePrototype prototype = new ConcretePrototype("調用原型方法");
            // 經過clone獲取一個拷貝
            System.out.println(prototype.getNameList());
            ConcretePrototype fromClone = prototype.clone();
            fromClone.setName("調用克隆方法");
            System.out.println(fromClone.getNameList());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2.2.  單例模式

2.2.1. 單利模式的通用代碼

class Singleton {

    private Singleton() {
        // 將構造方法進行封裝，私有化
        // 定義爲private的，是爲了避免讓Singleton在外部生成對象，這才能體現單例模式
    }

    // 在內部產生本類的實例化對象
    // 注意這是private只供內部調用
    private static Singleton instance = new Singleton();

    public static Singleton getInstance() {
        // 經過靜態方法取得instance對象
        // 這裏提供了一個供外部訪問本class的靜態方法，能夠直接訪問
        return instance;
    }

    public static void setInstance(Singleton instance) {
        Singleton.instance = instance;
    }
}

public class TestSingleton {
    public static void main(String args[]) {
        // 初始化
        Singleton s1 = null;
        Singleton s2 = null;
        // 實例化對象
        s1 = Singleton.getInstance();
        s2 = Singleton.getInstance();
        // 若相等則表示生成的對象是惟一的
        System.out.println(s1 == s2);
    }
}

2.2.2. 懶漢似的單例模式

class SingletonLazy {
 // 在內部產生本類的實例化對象
 private static SingletonLazy instance = null;

 private SingletonLazy() {
 }

 // 線程安全，確保內存中只有一個實例
 public static synchronized SingletonLazy getInstance() {
 // 這個方法比上邊有所改進，不用每次都進行生成對象，只是第一次使用時生成實例
 if (instance == null) {
 instance = new SingletonLazy();
 }
 return instance;
 }

}

public class TestSingletonLazy {
 public static void main(String args[]) {
 // TODO Auto-generated method stub
 // 初始化
 SingletonLazy s1 = null;
 SingletonLazy s2 = null;
 // 實例化對象
 s1 = SingletonLazy.getInstance();
 s2 = SingletonLazy.getInstance();
 // 若相等則表示生成的對象是惟一的
 System.out.println(s1 == s2);
 }

}

3.   Spring源碼學習

3.1.  Spring的原型模式

abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
 implements BeanDefinition, Cloneable {

 private String scope = SCOPE_DEFAULT;
 private boolean singleton = true;
 private boolean prototype = false;

 public void setScope(String scope) {
 this.scope = scope;
 this.singleton = SCOPE_SINGLETON.equals(scope)
 || SCOPE_DEFAULT.equals(scope);
 this.prototype = SCOPE_PROTOTYPE.equals(scope);
 }

 public String getScope() {
 return this.scope;
 }

 @Override
 public Object clone() {
 return cloneBeanDefinition();
 }

 public abstract AbstractBeanDefinition cloneBeanDefinition();
}

public class SpringAbstractBeanDefinition {

}

3.2.  Spring的單例模式

 

 

 

import java.util.HashMap;
import java.util.Map;

class SingletonBeanFactoryLocator implements BeanFactoryLocator {

 private static final Map<String, BeanFactoryLocator> instances = new HashMap<String, BeanFactoryLocator>();

 public SingletonBeanFactoryLocator(String resourceLocation) {
 }

 public static BeanFactoryLocator getInstance(String selector)
 throws BeansException {
 String resourceLocation = selector;
 // 線程安全，確保內存中只有一個實例
 synchronized (instances) {
 BeanFactoryLocator bfl = instances.get(resourceLocation);
 if (bfl == null) {
 bfl = new SingletonBeanFactoryLocator(resourceLocation);
 instances.put(resourceLocation, bfl);
 }
 }
 return getInstance(null);
 }
}

public class SpringSingletonBeanFactoryLocator {

}