初识设计模式

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 ----百科

今天记录下最近遇到的几个设计模式：

1.观察者（observer）模式

在java中gui的实现使用了观察者模式，观察者模式中几个关键的角色是：事件源、事件 、观察者。用windows窗口关闭这个最简单例子简单描述下三者之间的关系：

 

public class Observer {
     public static void main(String[] args) {
         Frame f = new Frame("test");
         f.setBounds(300, 300, 303, 100);
         f.setVisible(true);
         f.addWindowListener(new myWindowListener());
     }
 
 }
 class myWindowListener implements WindowListener {
     @Override
     public void windowOpened(WindowEvent e) {System.out.println("opened");    }
     @Override
     public void windowClosing(WindowEvent e) {System.exit(0);}
     @Override
     public void windowClosed(WindowEvent e) {System.out.println("closed");    }
     @Override
     public void windowIconified(WindowEvent e) {System.out.println("iconified");    }
     @Override
     public void windowDeiconified(WindowEvent e) {System.out.println("deiconified");    }
     @Override
     public void windowActivated(WindowEvent e) {System.out.println("activated");    }
     @Override
     public void windowDeactivated(WindowEvent e) {System.out.println("deactivated");    }
 
 }

在这个例子中，frame是事件源；对frame的各种操作产生不同的事件；而通过frame的addXXXListener绑定对不同的事件的不同处理。在这里，我们只绑定了关于对window操作的一个监听器，用来监听如接口中的那些事件，具体事件是怎么发生的呢？是系统底层实现的，当Listener关注的事件在绑定的对象上发生的时候，就会自动“唤醒”监听器，并传入发生的时间的信息，比如WindowEvevt，封装了发生点的信息，而且会自动调用发生点的函数。比如我们关闭窗口的时候，会调用closing函数。当让这时候就会有新的不方便了，有时候我只关心某些事件，但是接口提供了所有的事件，我们每个都去实现的话会很麻烦，还好，JDK提供了对所有接口空实现的一个类adapter类，我们一般用的时候只要重写我们关心的那个adapter的对应的函数就行了。

  

2.工厂（factory）模式 

 

一般来说我们会将类的共有特性抽象为一个接口，所有有这个特性的类去继承这个方法。如：

interface Pet {
     void feed();
 }
 
 class Dog implements Pet{
     @Override
     public void feed() {
         System.out.println("feed meat");
     }
 }
 
 class Cat implements Pet{
     @Override
     public void feed() {
         System.out.println("feed fish");
     }
 }

当我们要“生产”具体的某个宠物的时候，可以直接通过new产生新的对象，这样我们就无法避免不同的类产生不同的对象，因此我们就需要在创建一个类，这个类专门用来生产宠物，即工厂，要产生实例，必须通过工厂，不能私自产生，而具体产生一个（单例）还是多个，则由工厂说了算。

abstract class Factory {
     abstract Pet creat();
 }
 
 class DogFactory extends Factory{
     Dog d = new Dog();
     Pet creat(){
         return d;
     }
 }
 
 class CatFactory extends Factory{
     Cat c = new Cat();
     Pet creat(){
         return c;
     }
 }

这样我们将pet的生产抽象为一个抽象的工厂类，具体的pet生产则有自己特定的工厂生产，这样我们使用的时候就可以尽少修改的实现对具体的类的生产：

 

public static void main(String[] args) {
         Factory factory = new CatFactory();//只需具体的生产工厂即可
         Pet p1 = factory.creat();
         p1.feed();
         Pet p2 = factory.creat();
         p2.feed();
         System.out.println(p1 == p2);
     }

这样，我们可以将具体的factory比如CatFactory写到配置文件中，通过反射直接实现“生产”。

public static void main(String[] args) throws Exception{
         Properties pro = new Properties();
         try {
             //通过classloader获得classpath得到配置文件，配置文件中类名为全称
             pro.load(TestFactory.class.getClassLoader().getResourceAsStream("in.txt"));
         } catch (IOException e) {
             e.printStackTrace();
         }
         String factoryStr = pro.getProperty("factory");
         System.out.println(factoryStr);
         Factory factory = null;
         try {
             factory = (Factory) Class.forName(factoryStr).newInstance();
         }  catch (Exception e) {
             e.printStackTrace();
         }//只需具体的生产工厂即可
         Pet p1 = factory.creat();
         p1.feed();
         Pet p2 = factory.creat();
         p2.feed();
         System.out.println(p1 == p2);
     }

3.代理（proxy）模式

假设这样一种情况，我们有一个方法method，现在我们需要在不修改method源码的情况下，对在method的前后增加一些代码功能，比如打印，计时，检测等。这样我们在不修改代码的同时增加了自己的功能，就叫代理，我们实现功能的时候用代理类的方法就可以在原方法的基础上添加了自己的功能。同时，从另外一个维度上来说一个功能，如打印或计时，我们需要在不同的方法上都实现。java提供了proxy类实现代理操作。

public class testProxy {
     public static void main(String[] args) throws Exception {
         /*Class class1 = Proxy.getProxyClass(Pet.class.getClassLoader(), Pet.class);
         //class只有一个形参为InvocationHandler的构造方法
         Constructor constructor = class1.getConstructor(InvocationHandler.class);
         Pet p = (Pet)constructor.newInstance(new InvocationHandler1());*/
         
         Pet p = (Pet) Proxy.newProxyInstance(Pet.class.getClassLoader(),
                 new Class[]{Pet.class}, new InvocationHandler1());
         p.feed();//调用feed的时候调用了代理
         System.out.println(p.getIntro(100));
     }
 }
 class InvocationHandler1 implements InvocationHandler{
     Pet pet = new Cat();
     @Override
     /*这里的形参proxy是调用的object，比如此例中是pet p。
     因为p的所有方法都经过了代理，所以如果在invoke中调用外部方法(toString hashcode equals)，则会死循环导致堆栈溢出。*/
     public Object invoke(Object proxy, Method method, Object[] args)
             throws Throwable {
         System.out.println(method.getName());
         if(args != null){
             for(Object o : args){
                 if(o.equals(100)){
                     o = 3000;
                 }
             }
         }
         Object object = method.invoke(pet, args);
         System.out.println("-------------");
         return object;
     }
 }
 interface Pet {
     void feed();
     String getIntro(int test);//测试有返回值有形参的函数
 }
 class Dog implements Pet{
     @Override
     public void feed() {
         System.out.println("feed meat");
     }
     @Override
     public String getIntro(int test) {
         return "i am dog:" + test;
     }
 }
 class Cat implements Pet{
     @Override
     public void feed() {
         System.out.println("feed fish");
     }
     @Override
     public String getIntro(int test) {
         return "i am cat:" + test;
     }
 }

这里我们invoke函数前后的处理代码还是静态代码，以后实现配置文件动态添加代码后，就有更大的灵活性了。