设计模式

1. 工厂模式

 

1. 解决的问题：

解耦和

 

    例子：从前有一个暴发户，家里有三辆汽车——Benz 奔驰、Bmw 宝马、Audi 奥迪，还雇了司机为他开车。不过，暴发户坐车时总是怪怪的：

上 Benz 车后跟司机说"开奔驰车！"，坐上 Bmw 后他说"开宝马车！"，坐上 Audi 说"开奥迪车！"。你一定说：这人有病！直接说开车不就行了？！

 

工厂模式就可以解决这个问题，让他直接说开车就行

 

Spring就用了工厂模式和反射技术来实现托管类

1. 工厂模式的分类及介绍

   1. 简单工厂模式

      1. 简单工厂模式简介

   简单工厂根据传过来的参数判断要制造什么样的车

   例子：各种各样的车的类 实现 车这个借口 工厂里边有方法，根据方法的参数来判断你要的是什么车，之后帮你造（New）出来，

        用户直接调用工厂的方法,传进自己想要的车的参数，就可以获得想要的车，用车的接口来接受

   1. 简单实现的代码

   Car接口：

       //车的接口

   public interface Car {

       //每个车都有的启动功能

       public void drive();

   }

            具体的车系：

                //奥迪车

public class Audi implements Car {

    @Override

    public void drive() {

        System.out.println("奥迪开了");

    }

}

//奔驰车

public class Benz implements Car{

    @Override

    public void drive() {

        System.out.println("奔驰开车了");

    }

}

车的工厂类：

//车的工厂类

public class GongChang {

    public static Car driverCar(String s)throws Exception{

        //进行参数的判断

        if(s.equalsIgnoreCase("Benz"))

            return new Benz();

        else if(s.equalsIgnoreCase("Audi"))

            return new Audi();

        else throw new Exception();

    }

}

用户使用类：

//简单工厂的使用类

public class EasyUser {

    public static void main(String[] args) throws Exception {

        Car car =GongChang.driverCar("audi");

        car.drive();

    }

}

 

1. 优缺点

优点;

    第一，更加符合现实中的情况，运行程序的时候，不用说运行哪个车，直接开车就行，

    第二，用户不用直接创建产品对象，而仅仅是使用对象（就像spring的控制反转）

缺点：

    每增加一辆车，都要在工厂类中增加相应的业务逻辑或者判断逻辑, 对于新产品的加入，工厂类是很被动的，而且在现实中产品多数都是分多个层次树状结构，而简单工厂只有一个工厂类（因为是静态的），所以便捷性和适用性不强，所以工厂方法模式出现了

1. 工厂方法模式

   1. 工厂方法模式简介

工厂方法模式就是，接口工厂提供所有工厂制造车的方法，工厂的具体实现类，负责造每种车，用的时候，直接调用工厂接口获取指定车系的工厂，再由工厂制造车，用户开车

1. 简单实现的代码

车的类一样

    略

工厂接口

    //工厂接口

public interface MethodGongChang {

    public Car driverCar();

}

            工厂实现类

                //奥迪车的工厂实现类

public class AodiGC implements MethodGongChang{

    @Override

    public Car driverCar() {

        return new Audi();

    }

}

用户类

    public static void main(String[] args) {

        //提供指定的车工厂

        MethodGongChang gongChang=new AodiGC();

        //获取车

        Car car=gongChang.driverCar();

        //开车

        car.drive();

    }

}

 

1. 优缺点

优点：

第一：工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法

上的压力可以由工厂方法模式里不同的工厂子类来分担。

第二：结构变得灵活起来——当有新的产品（即暴发户的汽车）产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，

那么就可以被客户使用，而不必去修改任何已有的代码。

        缺点：

            工厂方法的加入，使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。因

为如果不能避免这种情况，可以考虑使用简单工厂模式与工厂方法模式相结合的方式来减少工厂类：即对于产品树上类似的种类（一般是树的叶子中互为兄弟的）使用简单工厂模式来实现。

 

 

简单工厂模式与工厂方法模式真正的避免了代码的改动了？没有。在简单工厂模式中，新产品的加入要修改工厂角色中的判断语句；而在工厂方法模式中，要么将判断逻辑留在抽象工厂角色中，要么在客户程序中将具体工厂角色写死（就象上面的例子一样）。而且产品对象创建条件的改变必然会引起工厂角色的修改。面对这种情况，Java 的反射机制与配置文件的巧妙结合突破了限制——这在 Spring 中完美的体现了出来。

 

1. 抽象工厂模式

   1. 抽象工厂模式简介

首先介绍一下产品族的概念

    所谓的产品族，是指位于不同产品等级结构中功能相关联的产品组成的家族

例：

    

在上面的类图中，两厢车和三厢车称为两个不同的等级结构；而2.0排量车和2.4排量车则称为两个不同的产品族。再具体一点，2.0排量两厢车和2.4排量两厢车属于同一个等级结构，2.0排量三厢车和2.4排量三厢车属于另一个等级结构；而2.0排量两厢车和2.0排量三厢车属于同一个产品族，2.4排量两厢车和2.4排量三厢车属于另一个产品族。

        明白了等级结构和产品族的概念，就理解工厂方法模式和抽象工厂模式的区别了，如果工厂的产品全部属于同一个等级结构，则属于工厂方法模式；如果工厂的产品来自多个等级结构，则属于抽象工厂模式。在本例中，如果一个工厂模式提供2.0排量两厢车和2.4排量两厢车，那么他属于工厂方法模式；如果一个工厂模式是提供2.4排量两厢车和2.4排量三厢车两个产品，那么这个工厂模式就是抽象工厂模式，因为他提供的产品是分属两个不同的等级结构。当然，如果一个工厂提供全部四种车型的产品，因为产品分属两个等级结构，他当然也属于抽象工厂模式了。

1. 简单实现的代码

1. interface IProduct1 {  
2.     public void show();  
3. }  
4. interface IProduct2 {  
5.     public void show();  
6. }  
7.     
8. class Product1 implements IProduct1 {  
9.     public void show() {  
10.         System.out.println("这是1型产品");  
11.     }  
12. }  
13. class Product2 implements IProduct2 {  
14.     public void show() {  
15.         System.out.println("这是2型产品");  
16.     }  
17. }  
18.     
19. interface IFactory {  
20.     public IProduct1 createProduct1();  
21.     public IProduct2 createProduct2();  
22. }  
23. class Factory implements IFactory{  
24.     public IProduct1 createProduct1() {  
25.         return new Product1();  
26.     }  
27.     public IProduct2 createProduct2() {  
28.         return new Product2();  
29.     }  
30. }  
31.     
32. public class Client {  
33.     public static void main(String[] args){  
34.         IFactory factory = new Factory();  
35.         factory.createProduct1().show();  
36.         factory.createProduct2().show();  
37.     }  
38. }  

    1. 优缺点

优点：

抽象工厂模式除了具有工厂方法模式的优点外，最主要的优点就是可以在类的内部对产品族进行约束。所谓的产品族，一般或多或少的都存在一定的关联，抽象工厂模式就可以在类内部对产品族的关联关系进行定义和描述，而不必专门引入一个新的类来进行管理。

缺点：

产品族的扩展将是一件十分费力的事情，假如产品族中需要增加一个新的产品，则几乎所有的工厂类都需要进行修改。所以使用抽象工厂模式时，对产品等级结构的划分是非常重要的。

1. 总结：

无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。

    所以，在使用工厂模式时，只需要关心降低耦合度的目的是否达到了。

 

1. 单例模式

 

1. 单例模式的介绍：

单例模式又叫做单态模式或者单件模式。他要保证一个类仅有一个实例，并提供一个访问它的全局访问点。也就是说在运行中，只会存在一个实例。

单例模式可分为有状态的和无状态的。有状态的单例对象一般也是可变的单例对象，多个单态对象在一起就可以作为一个状态仓库一样向外提供服务。没有状态的单例对象也就是不变单例对象，仅用做提供工具函数。

1. 单例模式的实现

一个类的对象的产生是由类构造函数来完成的，如果想限制对象的产生，一个办法就是将构造函数变为私有的（至少是受保护的），使得外面的类不能通过引用来产生对象；同时为了保证类的可用性，就必须提供一个自己的对象以及访问这个对象的静态方法。

1.     单例模式——饿汉式

public class Singleton {

//在自己内部定义自己一个实例

//注意这是 private 只供内部调用

private static Singleton instance = new Singleton();

//如上面所述，将构造函数设置为私有

private Singleton(){

}

//静态工厂方法，提供了一个供外部访问得到对象的静态方法

public static Singleton getInstance() {

return instance;

}

}

1. 单例模式——懒汉式

public class Singleton {

private static Singleton instance = null;

//设置为私有的构造函数

private Singleton(){

}

//静态工厂方法

public static synchronized Singleton getInstance() {

//这个方法比上面有所改进

if (instance==null)

instance＝new Singleton();

return instance;

}

}

1. 两种方式的差异

在第二种方式中，对静态工厂方法进行了同步处理，原因很明显——为了防止多线程环境中产生多个实例；而在第一种方式中则不存在这种情况。在第二种方式中将类对自己的实例化延迟到第一次被引用的时候。而在第一种方式中则是在类被加载的时候实例化，这样多次加载会照成多次实例化。但是第二种方式由于使用了同步处理，在反应速度上要比第一种慢一些

1. 单例模式的应用场景

（1）资源共享的情况下，避免由于资源操作时导致的性能或损耗等。如上述中的日志文件，应用配置。

　　（2）控制资源的情况下，方便资源之间的互相通信。如线程池等。

 

例子：

1. Windows的Task Manager（任务管理器）就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manager吗？ 不信你自己试试看~ 

2. windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。

3. 网站的计数器，一般也是采用单例模式实现，否则难以同步。

4. 应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。

5. Web应用的配置对象的读取，一般也应用单例模式，这个是由于配置文件是共享的资源。

6. 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为何用单例模式来维护，就可以大大降低这种损耗。

7. 多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。

8. 操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。

 

 

1. 单例模式的陷阱

   1. 多个虚拟机

当系统中的单例类被拷贝运行在多个虚拟机下的时候，在每一个虚拟机下都可以创建一个实例对象。在使用了 EJB、JINI、RMI 技术的分布式系统中，由于中间件屏蔽掉了分布式系统在物理上的差异，所以对你来说，想知道具体哪个虚拟机下运行着哪个单例对象是很困难的。

因此，在使用以上分布技术的系统中，应该避免使用存在状态的单例模式，因为一个有状态的单例类，在不同虚拟机上，各个单例对象保存的状态很可能是不一样的，问题也就随之产生。而且在 EJB 中不要使用单例模式来控制访问资源，因为这是由 EJB 容器来负责的。在其它的分布式系统中，当每一个虚拟机中的资源是不同的时候，可以考虑使用单例模式来进行管理。

1. 多个类加载器

当存在多个类加载器加载类的时候，即使它们加载的是相同包名，相同类名甚至每个字节都完全相同的类，也会被区别对待的。因为不同的类加载器会使用不同的命名空间（namespace）来区分同一个类。因此，单例类在多加载器的环境下会产生多个单例对象。

也许你认为出现多个类加载器的情况并不是很多。其实多个类加载器存在的情况并不少见。在很多 J2EE 服务器上允许存在多个 servlet 引擎，而每个引擎是采用不同的类加载器的；浏览器中 applet 小程序通过网络加载类的时候，由于安全因素，采用的是特殊的类加载器，等等。这种情况下，由状态的单例模式也会给系统带来隐患。因此除非系统由协调机制，在一般情况下不要使用存在状态的单例模式。

1. 错误的同步处理

在使用上面介绍的懒汉式单例模式时，同步处理的恰当与否也是至关重要的。不然可能会达不到得到单个对象的效果，还可能引发死锁等错误。因此在使用懒汉式单例模式时一定要对同步有所了解。不过使用饿汉式单例模式就可以避免这个问题。

1. 串行化（可序列化）

为了使一个单例类变成可串行化的，仅仅在声明中添加"implements Serializable"是不够的。因为一个串行化的对象在每次返串行化的时候，都会创建一个新的对象，而不仅仅是一个对原有对象的引用。为了防止这种情况，可以在单例类中加入 readResolve 方法。 关于

这个方法的具体情况请参考《Effective Java》一书第 57 条建议。其实对象的串行化并不仅局限于上述方式，还存在基于 XML 格式的对象串行化方式。这种方式也存在上述的问题，所以在使用的时候要格外小心。

。。。。。等等

1. 装饰模式

   1. 装饰模式的介绍：

      装饰模式，把原有的产品，经过包装，添加新的属性和职责，（例如包装后的山寨机）

   2. 装饰模式的实现

   产品类：

       public class productImpl implements product{

       @Override

       public void shouji() {

           System.out.print("山寨机");

       }

   }

包装类：

public class baozhuangImpl implements baozhuang ,product{

    public void s(){

        System.out.print("被包装的");

    }

    public void b(){

        System.out.print("速度很快的");

    }

    

    public void shouji(){

        s();

        b();

        new productImpl().shouji();

    }

}

用户类：

                public static void main(String[] args) {

                    System.out.print("我买了一个");

                    baozhuang baozhuang=new baozhuangImpl();

                    baozhuang.shouji();

    }

 

运行结果：

我买了一个被包装的速度很快的山寨机

1. 装饰模式的应用场景

   1.需要扩展一个类的功能，或给一个类增加附加责任；
   2.需要动态地给一个对象增加功能，这些功能可以再动态地撤销；
   3.需要增加由一些基本功能的排列组合而产生的非常大量的功能，从而使继承关系变得不现实。

    

   java IO 流是典型的装饰模式。

 

1. 观察者模式

   1. 观察者模式的介绍：

      说道观察者模式，让我想到了古代的一个例子，在战国时期，李斯是最强诸侯国的上尉，想一统诸国，因为知己知彼百战不殆，所以安间谍到各国的重要人物身边，获取信息并上报秦始皇。韩非子作为韩国的重量级人物，身边自然没少间谍了，韩非子早饭吃的什么，中午放了几个 P，晚上在做什么娱乐，李斯都了如指掌，那可是相隔千里！怎么做到的呢？间谍呀！

      对于观察者模式，我们就像秦始皇，通过李斯（观察者）来获取韩非子（被观察者）的信息

   2. 观察者模式的实现

   下边我们就从最原始的逐步优化实现观察者模式

   1. 一

    

   1. 二

      1. 首先创建李斯（观察者）

   观察者的职责就是根据被观察者的动作来作出相应的动作

    

   接口：

   public interface LiSiService {

       //一发现别人有动静，自己也要行动起来

       public void update(String context);

   }

   实现类：

   public class LiSi implements LiSiService {

       //首先李斯是个观察者，一旦韩非子有活动，他就知道，他就要向老板汇报

       public void update(String str){

           System.out.println("李斯:观察到韩非子活动，开始向老板汇报了...");

           this.reportToQiShiHuang(str);

           System.out.println("李斯：汇报完毕，秦老板赏给他两个萝卜吃吃...\n");

       }

         

       

       //汇报给秦始皇

       private void reportToQiShiHuang(String reportContext){

           System.out.println("李斯：报告，秦老板！韩非子有活动了--->"+reportContext);

       }

   }

   1. 创建韩非子（被观察者）

   接口：

       public interface HanFeiZiService {

       //韩非子也是人，也要吃早饭的

       public void haveBreakfast();

       //韩非之也是人，是人就要娱乐活动，至于活动时啥，嘿嘿，不说了

       public void haveFun();

   }

   实现类：

       public class HanFeiZi implements HanFeiZiService{

       //把李斯声明出来

       private LiSiService liSi =new LiSi();

    

       //韩非子要吃饭了

       public void haveBreakfast(){

           System.out.println("韩非子:开始吃饭了...");

           this.liSi.update("韩非子在吃饭");

       }

       //韩非子开始娱乐了,古代人没啥娱乐，你能想到的就那么多

       public void haveFun(){

           System.out.println("韩非子:开始娱乐了...");

           this.liSi.update("韩非子在娱乐");

       }

   }

   1. 创建操控者（我们）

   public class Client {

       public static void main(String[] args) throws InterruptedException {

           //定义出韩非子

           HanFeiZi hanFeiZi = new HanFeiZi();

           //然后这里我们看看韩非子在干什么

           hanFeiZi.haveBreakfast();

           //韩非子娱乐了

           hanFeiZi.haveFun();

       }

   }

   1. 运行结果：

   

   1. 三

   上边的方法，运行结果正确，效率也比较高，但是在被观察者中只有一个观察者，而且还是定死的，想想韩非子名望那么高，一定不会就一个人监视，那么每增加一个观察者我们就要修改增加大量的代码，所以我们可以让观察者实现一个通用的接口，被观察者实现一个通用的接口，并实现增加和删除观察者的方法，那么代码我们可以这么改。

    

   1. 创建观察者通用接口

   public interface Observer {

       //一发现别人有动静，自己也要行动起来

       public void update(String context);

   }

   1. 创建具体的观察者实现观察者接口

   public class LiSi implements Observer {

       @Override

       public void update(String str) {

           System.out.println("李斯：观察到李斯活动，开始向老板汇报了...");

           this.reportToQiShiHuang(str);

           System.out.println("李斯：汇报完毕，秦老板赏给他两个萝卜吃吃...\n");

       }

    

       // 汇报给秦始皇

       private void reportToQiShiHuang(String reportContext) {

           System.out.println("李斯：报告，秦老板！韩非子有活动了--->" + reportContext);

       }

   }

    

   public class WangSi implements Observer {

    

       // 王斯，看到韩非子有活动，自己就受不了

       public void update(String str) {

           System.out.println("王斯：观察到韩非子活动，自己也开始活动了...");

           this.cry(str);

           System.out.println("王斯：真真的哭死了...\n");

       }

    

       // 一看李斯有活动，就哭，痛哭

       private void cry(String context) {

           System.out.println("王斯：因为" + context + "，——所以我悲伤呀！");

       }

   }

   1. 创建被观察者通用接口

   public interface Observable {

       //增加一个观察者

       public void addObserver(Observer observer);

       //删除一个观察者，——我不想让你看了

       public void deleteObserver(Observer observer);

       //既然要观察，我发生改变了他也应该用所动作——通知观察者

       public void notifyObservers(String context);

   }

   1. 创建具体的被观察者实现被观察者接口

   public class HanFeiZi implements Observable {

       // 定义个变长数组，存放所有的观察者

       private ArrayList<Observer> observerList = new ArrayList<Observer>();

    

       @Override

       public void addObserver(Observer observer) {

           this.observerList.add(observer);

       }

    

       @Override

       public void deleteObserver(Observer observer) {

           this.observerList.remove(observer);

       }

    

       @Override

       public void notifyObservers(String context) {

           for (Observer observer : observerList) {

               observer.update(context);

           }

       }

    

       // 韩非子要吃饭了

       public void haveBreakfast() {

           System.out.println("韩非子:开始吃饭了...");

           // 通知所有的观察者

           this.notifyObservers("韩非子在吃饭");

       }

    

       // 韩非子开始娱乐了,古代人没啥娱乐，你能想到的就那么多

       public void haveFun() {

           System.out.println("韩非子:开始娱乐了...");

           this.notifyObservers("韩非子在娱乐");

       }

   }

    

   1. 创建操控者

      public class Clinet {

          public static void main(String[] args) {

              //三个观察者产生出来

              Observer liSi = new LiSi();

              Observer wangSi = new WangSi();

              //定义出韩非子

              HanFeiZi hanFeiZi = new HanFeiZi();

              //我们后人根据历史，描述这个场景，有三个人在观察韩非子

              hanFeiZi.addObserver(liSi);

              hanFeiZi.addObserver(wangSi);

              

              //然后这里我们看看韩非子在干什么

              hanFeiZi.haveBreakfast();

          }

   }

   1. 四

   因为JDK的api已经给出现成的接口，所以我们的程序可以这样的简化

   1. 观察者

   import java.util.Observable;

   public class HanFeiZi extends Observable {

       

       //韩非子要吃饭了

       public void haveBreakfast(){

       System.out.println("韩非子:开始吃饭了...");

       //通知所有的观察者

       super.setChanged();

       super.notifyObservers("韩非子在吃饭");

       }

       //韩非子开始娱乐了,古代人没啥娱乐，你能想到的就那么多

       public void haveFun(){

       System.out.println("韩非子:开始娱乐了...");

       super.setChanged();

       this.notifyObservers("韩非子在娱乐");

       }

   }

   1. 被观察者

   import java.util.Observer;

   public class LiSi implements Observer {

       //首先李斯是个观察者，一旦韩非子有活动，他就知道，他就要向老板汇报

       public void update(Observable observable,Object obj){

       System.out.println("李斯：观察到李斯活动，开始向老板汇报了...");

       this.reportToQiShiHuang(obj.toString());

       System.out.println("李斯：汇报完毕，秦老板赏给他两个萝卜吃吃...\n");

       }

       //汇报给秦始皇

       private void reportToQiShiHuang(String reportContext){

       System.out.println("李斯：报告，秦老板！韩非子有活动了--->"+reportContext);

       }

   }

   import java.util.Observer;

   public class WangSi implements Observer {

       //王斯，看到韩非子有活动，自己就受不了

       public void update(Observable observable,Object obj){

       System.out.println("王斯：观察到韩非子活动，自己也开始活动了...");

       this.cry(obj.toString());

       System.out.println("王斯：真真的哭死了...\n");

       }

       //一看李斯有活动，就哭，痛哭

       private void cry(String context){

       System.out.println("王斯：因为"+context+"，——所以我悲伤呀！");

       }

   }

   1. 操控者

       public static void main(String[] args) {

           Observer liSi = new LiSi();

           Observer wangSi = new WangSi();

           //定义出韩非子

           HanFeiZi hanFeiZi = new HanFeiZi();

           //我们后人根据历史，描述这个场景，有三个人在观察韩非子

           hanFeiZi.addObserver(liSi);

           hanFeiZi.addObserver(wangSi);

           //然后这里我们看看韩非子在干什么

           hanFeiZi.haveBreakfast();

       }

   这样我们是不是又简化方法了

 

1. 观察者模式的应用场景