pattern study

动态代理模式
可以在运行时期动态的创建代理类。
需要：被代理类，被代理类接口，织入器和InvocationHandler
通过织入器使用接口反射成代理类。
我们调用动态代理

package proxy;

import java.lang.reflect.Proxy;

/**
 *
 * @author liuquan
 */
public class Test {
    
    public static void main(String args[]){
        HelloHandler handler = new HelloHandler(new HelloImpl());
        ClassLoader classLoader = Hello.class.getClassLoader();
        Class[] proxyInterface = new Class[]{Hello.class};
        Hello hello = (Hello) Proxy.newProxyInstance(classLoader, proxyInterface, handler);
        hello.sayHello();
    }
}

ClassLoader当前工程的，所以你用Hello.class.getClassLoader()，还是用Test.class.getClassLoader()都一样。

模拟代理类

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package proxy;

import java.lang.reflect.Method;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author liuquan
 */
public class ProxyTest implements Hello {

    private HelloHandler handler;

    public ProxyTest(HelloHandler handler) {
        this.handler = handler;
    }

    @Override
    public void sayHello() {
        try {
            Method method = (handler.hello).getClass().getMethod("sayHello", null);
            handler.invoke(this, method, null);
        } catch (Throwable ex) {
            Logger.getLogger(ProxyTest.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    
    public static void main(String args[]){
        HelloHandler helloHandler = new HelloHandler(new HelloImpl());
        new ProxyTest(helloHandler).sayHello();
    }
}

Proxy就是织入器，通过newProxyInstance构建代理类。看传的三个参数ClassLoader，Interface，InvocationHandler。ClassLoader检测当前类加载器的缓存里面是否有代理类，没有则生成代理类并缓存到本地的JVM，所以要用到ClassLoader将字节码加载到内存中，Interface是代理类要实现的，而Handler在代理类里面要调用的。通过模拟的代理类，很清楚的知道动态代理的调用了。
以前说动态代理必须是对接口操作的，不明白为什么，现在看到代理类就明白了。


Adapter适配器模式，把一个类的接口，变成客户端所期待的另一种接口，使得因为不匹配而无法在一起工作的二个类能够在一起工作。简单点来说，源类中有一个方法，客户要加一个方法。于是adapter类，既有源类的方法，也有客户端要加的方法。
主要的类：目标接口一个，客户所期望的接口（源的方法和客户要加的方法）。
          源类一个
          adapter类一个：有2种实现，一种继承源类，实现目标接口。第二种实现目标接口，持有源类引用，重写方法。

package pattern.adaptor;

/**
 *
 * @author liuquan
 */
public interface Target {
    
    public void openDoor();
    
    public void openWindow();
    
}

package pattern.adaptor;

/**
 *
 * @author liuquan
 */
public class Adaptee {
    
    public void openDoor(){
        System.out.println("open the Door");
    }
    
}

package pattern.adaptor;

/**
 *
 * @author liuquan
 */
public class Adaptor extends Adaptee implements Target{

    @Override
    public void openWindow() {
        System.out.println("open the window");
    }
    
}


or

package pattern.adaptor;

/**
 *
 * @author liuquan
 */
public class Adaptor2 implements Target{
    
    private Adaptee adaptee;
    
    public Adaptor2(Adaptee adaptee){
        this.adaptee = adaptee;
    }

    @Override
    public void openDoor() {
       adaptee.openDoor();
    }

    @Override
    public void openWindow() {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    
}

适配器感觉就是把多个动能糅合在一个类里面，如变压器，既可以转压成110V，也可以转压成220V。