java 设计模式—2

设计模式介绍：

• 创建型：简单工厂模式（并不是23种设计模式之一）、工厂方法、抽象工厂模式、单例模式、生成器模式和原型模式
• 结构型：适配器模式adapter、桥接模式bridge、组合器模式component、装饰器模式decorator、门面模式、亨元模式flyweight和代理模式proxy
• 行为型：命令模式command、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式state、策略模式、模板模式和访问者模式

常用的几种设计模式介绍

1、单例模式

如果一个类始终只能创建一个实例，则这个类被称为单例类，这种模式就被称为单例模式。一般建议单例模式的方法命名为：getInstance()，这个方法的返回类型肯定是单例类的类型了。getInstance方法可以有参数，这些参数可能是创建类实例所需要的参数，当然，大多数情况下是不需要的。实现单例模式的简单例子：

[cpp] view plain copy

1. public class Singleton {  
2.     public static void main(String[] args)  
3.     {  
4.        //创建Singleton对象不能通过构造器，只能通过getInstance方法  
5.        Singleton s1 = Singleton.getInstance();  
6.        Singleton s2 = Singleton.getInstance();  
7.        //将输出true  
8.        System.out.println(s1 == s2);  
9.     }  
10.     //使用一个变量来缓存曾经创建的实例  
11.     private static Singleton instance;  
12.     //将构造器使用private修饰，隐藏该构造器  
13.     private Singleton(){  
14.        System.out.println("Singleton被构造！");  
15.     }   
16.     //提供一个静态方法，用于返回Singleton实例  
17.     //该方法可以加入自定义的控制，保证只产生一个Singleton对象  
18.     public static Singleton getInstance()  
19.     {  
20.        //如果instance为null，表明还不曾创建Singleton对象  
21.        //如果instance不为null，则表明已经创建了Singleton对象，将不会执行该方法  
22.        if (instance == null)  
23.        {  
24.            //创建一个Singleton对象，并将其缓存起来  
25.            instance = new Singleton();  
26.        }  
27.        return instance;  
28.     }  
29. }  

2、工厂模式

简单工厂模式的核心思想就是：有一个专门的类来负责创建实例的过程。 具体来说，把产品看着是一系列的类的集合，这些类是由某个抽象类或者接口派生出来的一个对象树。而工厂类用来产生一个合适的对象来满足客户的要求。如果简单工厂模式所涉及到的具体产品之间没有共同的逻辑，那么我们就可以使用接口来扮演抽象产品的角色；如果具体产品之间有功能的逻辑或，我们就必须把这些共同的东西提取出来，放在一个抽象类中，然后让具体产品继承抽象类。为实现更好复用的目的，共同的东西总是应该抽象出来的。

[java] view plain copy

1. /* 
2.  * 产品的抽象接口 
3.  */  
4. public interface Food {  
5.     /* 
6.      * 获得相应的食物 
7.      */  
8.     public void get();  
9. }  

[java] view plain copy

1. /* 
2.  * 麦香鸡对抽象产品接口的实现 
3.  */  
4. public class McChicken implements Food{  
5.     /* 
6.      * 获取一份麦香鸡 
7.      */  
8.     public void get(){  
9.         System.out.println("我要一份麦香鸡");  
10.     }  
11. }  

[java] view plain copy

1. public class FoodFactory {  
2.    
3.     public static Food getFood(String type) throws InstantiationException, IllegalAccessException, ClassNotFoundException {  
4.         if(type.equalsIgnoreCase("mcchicken")) {  
5.             return McChicken.class.newInstance();  
6.    
7.         } else if(type.equalsIgnoreCase("chips")) {  
8.             return Chips.class.newInstance();  
9.         } else {  
10.             System.out.println("哎呀！找不到相应的实例化类啦！");  
11.             return null;  
12.         }  
13.    
14.    
15.     }  
16. }  

[java] view plain copy

1. /* 
2.  * 测试客户端 
3.  */  
4. public class SimpleFactoryTest {  
5.     public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {  
6.    
7.         //实例化各种食物  
8.         Food mcChicken = FoodFactory.getFood("McChicken");  
9.         Food chips = FoodFactory.getFood("Chips");  
10.         Food eggs = FoodFactory.getFood("Eggs");  
11.    
12.         //获取食物  
13.         if(mcChicken!=null){  
14.             mcChicken.get();  
15.         }  
16.         if(chips!=null){  
17.             chips.get();  
18.         }  
19.         if(eggs!=null){  
20.             eggs.get();  
21.         }  
22.    
23.    
24.     }  
25. }  

输出的结果如下：

哎呀！找不到相应的实例化类啦！

我要一份麦香鸡

我要一份薯条

3、代理模式

代理模式是一种应用非常广泛的设计模式，当客户端代码需要调用某个对象时，客户端实际上不关心是否准确得到该对象，它只要一个能提供该功能的对象即可，此时我们就可返回该对象的代理（Proxy）。

代理就是一个Java对象代表另一个Java对象来采取行动。如：

[java] view plain copy

1. public class ImageProxy implements Image  
2. {  
3.     //组合一个image实例，作为被代理的对象  
4.     private Image image;  
5.     //使用抽象实体来初始化代理对象  
6.     public ImageProxy(Image image)  
7.     {  
8.        this.image = image;  
9.     }  
10.     /** 
11.      * 重写Image接口的show()方法 
12.      * 该方法用于控制对被代理对象的访问， 
13.      * 并根据需要负责创建和删除被代理对象 
14.      */  
15.     public void show()  
16.     {  
17.        //只有当真正需要调用image的show方法时才创建被代理对象  
18.        if (image == null)  
19.        {  
20.            image = new BigImage();  
21.        }  
22.        image.show();  
23.     }  
24. }  

调用时，先不创建：

Image image = new ImageProxy(null);

Hibernate默认启用延迟加载，当系统加载A实体时，A实体关联的B实体并未被加载出来，A实体所关联的B实体全部是代理对象——只有等到A实体真正需要访问B实体时，系统才会去数据库里抓取B实体所对应的记录。

借助于Java提供的Proxy和InvocationHandler，可以实现在运行时生成动态代理的功能，而动态代理对象就可以作为目标对象使用，而且增强了目标对象的功能。如：

[java] view plain copy

1. public interface Panther  
2. {  
3.     //info方法声明  
4.     public void info();  
5.     //run方法声明  
6.     public void run();  
7. }  

[java] view plain copy

1. public class GunPanther implements Panther  
2. {  
3.     //info方法实现，仅仅打印一个字符串  
4.     public void info()  
5.     {  
6.        System.out.println("我是一只猎豹！");  
7.     }  
8.     //run方法实现，仅仅打印一个字符串  
9.     public void run()  
10.     {  
11.        System.out.println("我奔跑迅速");  
12.     }  
13. }  

[java] view plain copy

1. public class MyProxyFactory  
2. {  
3.     //为指定target生成动态代理对象  
4.     public static Object getProxy(Object target)  
5.        throws Exception  
6.     {  
7.        //创建一个MyInvokationHandler对象  
8.        MyInvokationHandler handler =  
9.            new MyInvokationHandler();  
10.        //为MyInvokationHandler设置target对象  
11.        handler.setTarget(target);  
12.        //创建、并返回一个动态代理  
13.        return Proxy.newProxyInstance(target.getClass().getClassLoader()  
14.            , target.getClass().getInterfaces(), handler);  
15.     }  
16. }  

[java] view plain copy

1. public class MyInvokationHandler implements InvocationHandler  
2. {  
3.     //需要被代理的对象  
4.     private Object target;  
5.     public void setTarget(Object target)  
6.     {  
7.        this.target = target;  
8.     }  
9.     //执行动态代理对象的所有方法时，都会被替换成执行如下的invoke方法  
10.     public Object invoke(Object proxy, Method method, Object[] args)  
11.        throws Exception  
12.     {  
13.        TxUtil tx = new TxUtil();  
14.        //执行TxUtil对象中的beginTx。  
15.        tx.beginTx();  
16.        //以target作为主调来执行method方法  
17.        Object result = method.invoke(target , args);  
18.        //执行TxUtil对象中的endTx。  
19.        tx.endTx();  
20.        return result;  
21.     }  
22. }  

[java] view plain copy

1. public class TxUtil  
2. {  
3.     //第一个拦截器方法:模拟事务开始  
4.     public void beginTx()  
5.     {  
6.        System.out.println("=====模拟开始事务=====");  
7.     }  
8.     //第二个拦截器方法:模拟事务结束  
9.     public void endTx()  
10.     {  
11.        System.out.println("=====模拟结束事务=====");  
12.     }  
13. }  

测试：

[java] view plain copy

1. public static void main(String[] args)  
2.        throws Exception  
3.     {  
4.        //创建一个原始的GunDog对象，作为target  
5.        Panther target = new GunPanther();  
6.        //以指定的target来创建动态代理  
7.        Panther panther = (Panther)MyProxyFactory.getProxy(target);  
8.        //调用代理对象的info()和run()方法  
9.        panther.info();  
10.        panther.run();  
11.     }  

4、观测者模式

观察者模式结构中包括四种角色：

　　一、主题：主题是一个接口，该接口规定了具体主题需要实现的方法，比如添加、删除观察者以及通知观察者更新数据的方法。

　　二、观察者：观察者也是一个接口，该接口规定了具体观察者用来更新数据的方法。

　　三、具体主题：具体主题是一个实现主题接口的类，该类包含了会经常发生变化的数据。而且还有一个集合，该集合存放的是观察者的引用。

　　四：具体观察者：具体观察者是实现了观察者接口的一个类。具体观察者包含有可以存放具体主题引用的主题接口变量，以便具体观察者让具体主题将自己的引用添加到具体主题的集合中，让自己成为它的观察者，或者让这个具体主题将自己从具体主题的集合中删除，使自己不在时它的观察者。

 

观察者模式定义了对象间的一对多依赖关系，让一个或多个观察者对象观察一个主题对象。当主题对象的状态发生变化时，系统能通知所有的依赖于此对象的观察者对象，从而使得观察者对象能够自动更新。

在观察者模式中，被观察的对象常常也被称为目标或主题（Subject），依赖的对象被称为观察者（Observer）。

Observer，观察者接口：

观察者：观察者也是一个接口，该接口规定了具体观察者用来更新数据的方法

[java] view plain copy

1. public interface Observer {  
2.     void update(Observable o, Object arg);  
3. }  

Observable，目标或主题：

主题：主题是一个接口，该接口规定了具体主题需要实现的方法，比如添加、删除观察者以及通知观察者更新数据的方法

[java] view plain copy

1. import java.util.ArrayList;  
2. import java.util.List;  
3. import java.util.Iterator;  
4.    
5. public abstract class Observable {  
6.     // 用一个List来保存该对象上所有绑定的事件监听器  
7.     List<Observer> observers = new ArrayList<Observer>();  
8.    
9.     // 定义一个方法，用于从该主题上注册观察者  
10.     public void registObserver(Observer o) {  
11.        observers.add(o);  
12.     }  
13.    
14.     // 定义一个方法，用于从该主题中删除观察者  
15.     public void removeObserver(Observer o) {  
16.        observers.add(o);  
17.     }  
18.    
19.     // 通知该主题上注册的所有观察者  
20.     public void notifyObservers(Object value) {  
21.        // 遍历注册到该被观察者上的所有观察者  
22.        for (Iterator it = observers.iterator(); it.hasNext();) {  
23.            Observer o = (Observer) it.next();  
24.            // 显式每个观察者的update方法  
25.            o.update(this, value);  
26.        }  
27.     }  
28. }  

Product被观察类：

具体主题：具体主题是一个实现主题接口的类，该类包含了会经常发生变化的数据。而且还有一个集合，该集合存放的是观察者的引用。

[java] view plain copy

1. public class Product extends Observable {  
2.     // 定义两个属性  
3.     private String name;  
4.     private double price;  
5.    
6.     // 无参数的构造器  
7.     public Product() {  
8.     }  
9.    
10.     public Product(String name, double price) {  
11.        this.name = name;  
12.        this.price = price;  
13.     }  
14.    
15.     public String getName() {  
16.        return name;  
17.     }  
18.    
19.     // 当程序调用name的setter方法来修改Product的name属性时  
20.     // 程序自然触发该对象上注册的所有观察者  
21.     public void setName(String name) {  
22.        this.name = name;  
23.        notifyObservers(name);  
24.     }  
25.    
26.     public double getPrice() {  
27.        return price;  
28.     }  
29.    
30.     // 当程序调用price的setter方法来修改Product的price属性时  
31.     // 程序自然触发该对象上注册的所有观察者  
32.     public void setPrice(double price) {  
33.        this.price = price;  
34.        notifyObservers(price);  
35.     }  
36. }  

具体观察者：具体观察者是实现了观察者接口的一个类。具体观察者包含有可以存放具体主题引用的主题接口变量，以便具体观察者让具体主题将自己的引用添加到具体主题的集合中，让自己成为它的观察者，或者让这个具体主题将自己从具体主题的集合中删除，使自己不在时它的观察者。

 

NameObserver名称观察者：

[java] view plain copy

1. import javax.swing.JFrame;  
2. import javax.swing.JLabel;  
3.    
4. public class NameObserver implements Observer {  
5.     // 实现观察者必须实现的update方法  
6.     public void update(Observable o, Object arg) {  
7.        if (arg instanceof String) {  
8.            // 产品名称改变值在name中  
9.            String name = (String) arg;  
10.            // 启动一个JFrame窗口来显示被观察对象的状态改变  
11.            JFrame f = new JFrame("观察者");  
12.            JLabel l = new JLabel("名称改变为：" + name);  
13.            f.add(l);  
14.            f.pack();  
15.            f.setVisible(true);  
16.            System.out.println("名称观察者:" + o + "物品名称已经改变为: " + name);  
17.        }  
18.     }  
19. }  

PriceObserver价格观察者：

[java] view plain copy

1. public class PriceObserver implements Observer {  
2.     // 实现观察者必须实现的update方法  
3.     public void update(Observable o, Object arg) {  
4.        if (arg instanceof Double) {  
5.            System.out.println("价格观察者:" + o + "物品价格已经改变为: " + arg);  
6.        }  
7.     }  
8. }  

测试：

[java] view plain copy

1. public class Test {  
2.     public static void main(String[] args) {  
3.        // 创建一个被观察者对象  
4.        Product p = new Product("电视机", 176);  
5.        // 创建两个观察者对象  
6.        NameObserver no = new NameObserver();  
7.        PriceObserver po = new PriceObserver();  
8.        // 向被观察对象上注册两个观察者对象  
9.        p.registObserver(no);  
10.        p.registObserver(po);  
11.        // 程序调用setter方法来改变Product的name和price属性  
12.        p.setName("书桌");  
13.        p.setPrice(345f);  
14.     }  
15. }  

其中Java工具类提供了被观察者抽象基类：java.util.Observable。观察者接口：java.util.Observe