单例模式

一、什么是单例模式：
单例模式确保某一个类只有一个实例，而且向这个系统提供这个实例。
二、单例模式的要点：
    1、某个类只能有一个实例
    2、它必须自行创建这个实例
    3、必须自行向这个系统提供这个实例
三、单例模式的结构及实现：
1、饿汉式单例类：
类图：

代码：
public class EagerSingleton {
private static final EagerSingleton m_instance = new EagerSingleton();
private EagerSingleton() {
} public static EagerSingleton getInstance()
{ return m_instance;
} }
当类被加载的时候，static 类型的m_instance就会被事例化，保证的单利模式的自动创建条件，他是常量，保证了值不变，即保证了对象的唯一；事例的创建调用了私有的构造方法，构造方法私有保证了外界不能直接调用。
2、懒汉式单利类：
类图：
代码：
public class LazySingleton {
private static LazySingleton m_instance = null;
private LazySingleton() {
} synchronized public static LazySingleton getInstance()
{ if(m_instance == null)
{ m_instance = new LazySingleton();
} return m_instance;
}
}
3、注册式单例类
类图
代码
import java.util.HashMap;
public class RegSingleton
{ static private HashMap m_registy = new HashMap();
static
{ RegSingleton sl = new RegSingleton();
m_registy.put(sl.getClass().getName , x);
} protected RegSingleton()
{ }
public static RegSingleton getInstance(String name) { if(name==null) {
name = "easyworld.pattern.RegSingleton"; }
} if(m_registy.get(name)==null)
{ try { m_registy.put(name,Class.forName(name).newInstance());
} catch (Exception e) {
System.out.println("Erorr"); } }
return (RegSingleton)(m_registry.get(name)); }

                           工厂模式

看了这么多关于工厂模式的讲解，还是觉得这篇文章讲的好理解，贴出来和大家分享分享。
一、引子
             话说十年前，有一个暴发户，他家有三辆汽车——Benz奔驰、Bmw宝马、Audi奥迪，还雇了司机为他开车。不过，暴发户坐车时总是怪怪的：上Benz车后跟司机说“开奔驰车！”，坐上Bmw后他说“开宝马车！”，坐上Audi说“开奥迪车！”。你一定说：这人有病！直接说开车不就行了？！
             而当把这个暴发户的行为放到我们程序设计中来时，会发现这是一个普遍存在的现象。幸运的是，这种有病的现象在OO（面向对象）语言中可以避免了。下面就以Java语言为基础来引入我们本文的主题：工厂模式。
二、分类
            工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。
工厂模式在《Java与模式》中分为三类：
1）简单工厂模式（Simple Factory）
2）工厂方法模式（Factory Method）
3）抽象工厂模式（Abstract Factory）
             这三种模式从上到下逐步抽象，并且更具一般性。
             GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。
两者皆可，在本文使用《Java与模式》的分类方法。下面来看看这些工厂模式是怎么来“治病”的。
三、简单工厂模式
简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。
       先来看看它的组成：
         1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。
         2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。
         3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。
那么简单工厂模式怎么来使用呢？我们就以简单工厂模式来改造暴发户坐车的方式——现在暴发户只需要坐在车里对司机说句：“开车”就可以了。
代码： //抽象产品角色
public interface Car{
      public void drive();
}

//具体产品角色
public class Benz implements Car{
      public void drive() {
         System.out.println("Driving Benz ");
      }
}

public class Bmw implements Car{
      public void drive() {
       System.out.println("Driving Bmw ");
      }
}
。。。（奥迪我就不写了:P）

//工厂类角色
public class Driver{
            //工厂方法.注意 返回类型为抽象产品角色
             public static Car driverCar(String s)throws Exception{
                   //判断逻辑，返回具体的产品角色给Client
                   if(s.equalsIgnoreCase("Benz"))
                        return new Benz();
                   else if(s.equalsIgnoreCase("Bmw"))
                            return new Bmw();
                                 ......   
                           else throw new Exception();
             。。。
//欢迎暴发户出场......
public class Magnate{
             public static void main(String[] args){
                        try{
                              //告诉司机我今天坐奔驰                    
                                  Car car = Driver.driverCar("benz");
                              //下命令：开车                           
                                  car.drive();
                        。。。
         将本程序空缺的其他信息填充完整后即可运行。如果你将所有的类放在一个文件中，请不要忘记只能有一个类被声明为public。本程序在jdk1.4 下运行通过。
这便是简单工厂模式了。怎么样，使用起来很简单吧？那么它带来了什么好处呢？
            首先，使用了简单工厂模式后，我们的程序不在“有病”，更加符合现实中的情况；而且客户端免除了直接创建产品对象的责任，而仅仅负责“消费”产品（正如暴发户所为）。

            下面我们从开闭原则（对扩展开放；对修改封闭）上来分析下简单工厂模式。当暴发户增加了一辆车的时候，只要符合抽象产品制定的合同，那么只要通知工厂类知道就可以被客户使用了。所以对产品部分来说，它是符合开闭原则的；但是工厂部分好像不太理想，因为每增加一辆车，都要在工厂类中增加相应的业务逻辑或者判断逻辑，这显然是违背开闭原则的。可想而知对于新产品的加入，工厂类是很被动的。对于这样的工厂类（在我们的例子中是为司机师傅），我们称它为全能类或者上帝类。
             我们举的例子是最简单的情况，而在实际应用中，很可能产品是一个多层次的树状结构。由于简单工厂模式中只有一个工厂类来对应这些产品，所以这可能会把我们的上帝累坏了，也累坏了我们这些程序员:(
            于是工厂方法模式作为救世主出现了。

四、工厂方法模式
             工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。
你应该大致猜出了工厂方法模式的结构，来看下它的组成：
       1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
       2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
       3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
       4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。
       工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；而且这样使得结构变得灵活起来——当有新的产品（即暴发户的汽车）产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有的代码。可以看出工厂角色的结构也是符合开闭原则的！

       我们还是老规矩，使用一个完整的例子来看看工厂模式各个角色之间是如何来协调的。话说暴发户生意越做越大，自己的爱车也越来越多。这可苦了那位司机师傅了，什么车它都要记得，维护，都要经过他来使用！于是暴发户同情他说：看你跟我这么多年的份上，以后你不用这么辛苦了，我给你分配几个人手，你只管管好他们就行了！于是，工厂方法模式的管理出现了。代码如下：

代码：

//抽象产品角色，具体产品角色与简单工厂模式类似，只是变得复杂了些，这里略。
//抽象工厂角色
public interface Driver{
       public Car driverCar();
}
public class BenzDriver implements Driver{
         public Car driverCar(){
                return new Benz();
         }
}
public class BmwDriver implements Driver{
         public Car driverCar(){
            return new Bmw();
         }
}

//应该和具体产品形成对应关系...
//有请暴发户先生
public class Magnate{
          public static void main(String[] args){
                     try{
                        Driver driver = new BenzDriver();
                        Car car = driver.driverCar();
                        car.drive();
                     }           ……
}
可以看出工厂方法的加入，使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。因为如果不能避免这种情况，可以考虑使用简单工厂模式与工厂方法模式相结合的方式来减少工厂类：即对于产品树上类似的种类（一般是树的叶子中互为兄弟的）使用简单工厂模式来实现。
五、小结
工厂方法模式仿佛已经很完美的对对象的创建进行了包装，使得客户程序中仅仅处理抽象产品角色提供的接口。那我们是否一定要在代码中遍布工厂呢？大可不必。也许在下面情况下你可以考虑使用工厂方法模式：
     1)当客户程序不需要知道要使用对象的创建过程。
      2)客户程序使用的对象存在变动的可能，或者根本就不知道使用哪一个具体的对象。
简单工厂模式与工厂方法模式真正的避免了代码的改动了？没有。在简单工厂模式中，新产品的加入要修改工厂角色中的判断语句；而在工厂方法模式中，要么将判断逻辑留在抽象工厂角色中，要么在客户程序中将具体工厂角色写死（就象上面的例子一样）。而且产品对象创建条件的改变必然会引起工厂角色的修改。
       面对这种情况，Java的反射机制与配置文件的巧妙结合突破了限制——这在Spring中完美的体现了出来。
六、抽象工厂模式

           先来认识下什么是产品族： 位于不同产品等级结构中，功能相关联的产品组成的家族。还是让我们用一个例子来形象地说明一下吧。
回到抽象工厂模式的话题上。
可以说，抽象工厂模式和工厂方法模式的区别就在于需要创建对象的复杂程度上。而且抽象工厂模式是三个里面最为抽象、最具一般性的。
抽象工厂模式的用意为：给客户端提供一个接口，可以创建多个产品族中的产品对象

而且使用抽象工厂模式还要满足一下条件：
     1)系统中有多个产品族，而系统一次只可能消费其中一族产品。
     2)同属于同一个产品族的产品以其使用。
来看看抽象工厂模式的各个角色（和工厂方法的如出一辙）：
     1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。

     2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。
     3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
   4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。
看过了前两个模式，对这个模式各个角色之间的协调情况应该心里有个数了，我就不举具体的例子了。只是一定要注意满足使用抽象工厂模式的条件哦。
//
工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。

                         代理模式

代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。
代理模式一般涉及到的角色有：
抽象角色：声明真实对象和代理对象的共同接口；
代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。
真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。
以下以《Java与模式》中的示例为例：
代码： //抽象角色：
abstract public class Subject{     
        abstract public void request();
}
//真实角色：实现了Subject的request()方法。
public class RealSubject extends Subject{
        public RealSubject(){
        }         public void request(){
              System.out.println("From real subject.");         } }

//代理角色：
public class ProxySubject extends Subject{
        private RealSubject realSubject; //以真实角色作为代理角色的属性
         public ProxySubject(){
         }
        public void request(){ //该方法封装了真实对象的request方法
            preRequest();
            if( realSubject == null ){
                  realSubject = new RealSubject();
            }
            realSubject.request(); //此处执行真实对象的request方法
              postRequest();
         }
        private void preRequest(){
         //something you want to do before requesting
        }
        private void postRequest(){
        //something you want to do after requesting
        } }
//客户端调用：
Subject sub=new ProxySubject();
Sub.request();
由以上代码可以看出，客户实际需要调用的是RealSubject类的request()方法，现在用ProxySubject来代理RealSubject类，同样达到目的，同时还封装了其他方法(preRequest(),postRequest())，可以处理一些其他问题。

另外，如果要按照上述的方法使用代理模式，那么真实角色必须是事先已经存在的，并将其作为代理对象的内部属性。但是实际使用时，一个真实角色必须对应一个代理角色，如果大量使用会导致类的急剧膨胀；此外，如果事先并不知道真实角色，该如何使用代理呢？这个问题可以通过Java的动态代理类来解决。
2.动态代理
Java动态代理类位于Java.lang.reflect包下，一般主要涉及到以下两个类：
(1). Interface InvocationHandler：该接口中仅定义了一个方法Object：invoke(Object obj,Method method, Object[] args)。在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，如上例中的request()，args为该方法的参数数组。这个抽象方法在代理类中动态实现。
(2).Proxy：该类即为动态代理类，作用类似于上例中的ProxySubject，其中主要包含以下内容：
Protected Proxy(InvocationHandler h)：构造函数，估计用于给内部的h赋值。
Static Class getProxyClass (ClassLoader loader, Class[] interfaces)：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。
Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)。
所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然啦，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。(参见文献3)

在使用动态代理类时，我们必须实现InvocationHandler接口，以第一节中的示例为例：

代码： //抽象角色(之前是抽象类，此处应改为接口)：

public interface Subject{
        public void request();
}

//具体角色RealSubject：实现了Subject接口的request()方法。
public class RealSubject implements Subject{
        public RealSubject(){
    }        public void request(){
              System.out.println("From real subject.");
        } } //代理角色：
import java.lang.reflect.Method;
import java.lang.reflect.InvocationHandler;
public class DynamicSubject implements InvocationHandler{
        private Object sub;
        public DynamicSubject(Object sub){           
              this.sub = sub;
        }
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("before calling " + method);
            method.invoke(sub,args);
            System.out.println("after calling " + method);
            return null;
        }
}

该代理类的内部属性为Object类，实际使用时通过该类的构造函数DynamicSubject(Object sub)对其赋值；此外，在该类还实现了invoke方法，该方法中的"method.invoke(sub,args)" 其实就是调用被代理对象的将要被执行的方法，方法参数sub是实际的被代理对象，args为执行被代理对象相应操作所需的参数。通过动态代理类，我们可以在调用之前或之后执行一些相关操作。
客户端：
代码： import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class Client{
     static public void main(String[] args) throws Throwable{
     RealSubject rs = new RealSubject(); //在这里指定被代理类
     InvocationHandler ds = new DynamicSubject(rs); //初始化代理类
     Class cls = rs.getClass();
     //以下是分解步骤
     /*
     Class c = Proxy.getProxyClass(cls.getClassLoader(),cls.getInterfaces());
     Constructor ct=c.getConstructor(new Class[]{InvocationHandler.class});
     Subject subject =(Subject) ct.newInstance(new Object[]{ds});
*/

//以下是一次性生成

     Subject subject = (Subject) Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(),ds);
     subject.request();
}

通过这种方式，被代理的对象(RealSubject)可以在运行时动态改变，需要控制的接口(Subject接口)可以在运行时改变，控制的方式(DynamicSubject类)也可以动态改变，从而实现了非常灵活的动态代理关系。

3.代理模式使用原因和应用方面

（1）授权机制 不同级别的用户对同一对象拥有不同的访问权利,如Jive论坛系统中,就使用Proxy进行授权机制控制,访问论坛有两种人:注册用户和游客(未注册用户),Jive中就通过类似ForumProxy这样的代理来控制这两种用户对论坛的访问权限.

（2）某个客户端不能直接操作到某个对象,但又必须和那个对象有所互动.
        举例两个具体情况:
        如果那个对象是一个是很大的图片,需要花费很长时间才能显示出来,那么当这个图片包含在文档中时,使用编辑器或浏览器打开这个文档,打开文档必须很迅速,不能等待大图片处理完成,这时需要做个图片Proxy来代替真正的图片.
    
        如果那个对象在Internet的某个远端服务器上,直接操作这个对象因为网络速度原因可能比较慢,那我们可以先用Proxy来代替那个对象.
    
        总之原则是,对于开销很大的对象,只有在使用它时才创建,这个原则可以为我们节省很多宝贵的Java内存. 所以,有些人认为Java耗费资源内存,我以为这和程序编制思路也有一定的关系.

（3）现实中，Proxy应用范围很广,现在流行的分布计算方式RMI和Corba等都是Proxy模式的应用

                          原型模式

原型模式(Prototype): 用原型实例指定创建对象的种类，并且通过拷贝原型来创建新的实例对象。它允许一个对象再创建另外一个可定制的对象，根本无需知道任何创建细节，工作原理，通过将一个原型对象传给那个要发动创建的对象，这个发动创建对象通过请求原型对象拷贝它们自己来创建。

通俗点，就是通过拷贝来进行创建实例。

Java代码

1.   import java.util.HashMap;   

  interface Prototype extends Cloneable {   

2.