原型模式和单例模式的区别

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 {  
 
}