1. 代理模式

• Proxy Pattern,又称为委托模式，为设计模式的一种

• 为目标对象提供了一个代理，这个代理可以控制对目标对对象的访问
  • 外界不用直接访问目标对象，而是访问代理对象，由代理对象再调用目标对象
  • 代理对象中可以添加监控和审查处理

2. 静态代理

• 代理对象持有目标对象的句柄，成员变量

• 所有调用目标对象的方法，都调用代理对象的方法

• 对每个方法都需要静态编码

public interface Subject{
    public void request();
}

//原对象
class SubjectImpl implements Subject{
  public void request(){
      System.out.println("I am dealing the request.");
  }
}

//代理对象
class StaticProxy implements Subject{
    //实际目标对象
    private Subject subject;
    public StaticProxy(Subject subject){
        this.subject = subject;
    }
    public void request(){
        System.out.println("PreProcess");
        subject.request();
        System.out.println("PostProcess");
    }
    public static void main(String args[]){
        //创建实际对象
        SubjectImpl subject = new SubjectImpl();
        //把实际对象封装到代理对象中
        StaticProxy p = new StaticProxy(subject);
        p.request();
    }
}

3. 动态代理

• 代理处理器持有目标对象的句柄

• 代理处理器实现InvocationHandler接口
  • 实现invoke方法
  • 所有的代理对象方法调用，都会转发到invoke方法来
  • invoke的形参method，就是指代理对象方法的调用
  • 在invoke内部，可以根据method，使用目标对象不同的方法来响应请求

public interface Subject{
    public void request();
}

//目标对象
class SubjectImpl implements Subject{
  public void request(){
      System.out.println("I am dealing the request.");
  }
}

/**
 * 代理类的调用处理器
 */
class ProxyHandler implements InvocationHandler{
    private Subject subject;
    public ProxyHandler(Subject subject){
        this.subject = subject;
    }
    
    //此函数在代理对象调用任何一个方法时都会被调用。
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println(proxy.getClass().getName());
        //定义预处理的工作，当然你也可以根据 method 的不同进行不同的预处理工作
        System.out.println("====before====");
        Object result = method.invoke(subject, args);
        System.out.println("====after====");
        return result;
    }
}

//动态代理模式
public class DynamicProxyDemo {
    public static void main(String[] args) {
        //1.创建目标对象
        SubjectImpl realSubject = new SubjectImpl();    
        
        //2.创建调用处理器对象
        ProxyHandler handler = new ProxyHandler(realSubject); 
        
        //3.动态生成代理对象
        Subject proxySubject = 
                (Subject)Proxy.newProxyInstance
                  (SubjectImpl.class.getClassLoader(),
                   SubjectImpl.class.getInterfaces(), handler); 
        //proxySubject真实类型com.sun.proxy.$Proxy0
        //proxySubject继承Proxy类，实现Subject接口
        //newProxyInstance的第二个参数，就是指定代理对象的接口
        
        //4.客户端通过代理对象调用方法
        //本次调用将自动被代理处理器的invoke方法接收
        proxySubject.request();    
        
        System.out.println(proxySubject.getClass().getName());
        System.out.println(proxySubject.getClass().getSuperclass().getName());
    }
}
/*result:
com.sun.proxy.$Proxy0
====before====
I am dealing the request.
====after====
com.sun.proxy.$Proxy0
java.lang.reflect.Proxy
*/

动态代理是怎样调用invoke()方法?

1. 通过Proxy.newProxyInstance()动态代理生成对象，com.sun.proxy.$Proxy0代理类由JDK自己生成，生成一个继承Proxy和实现subject接口的代理类。

2. 然后把得到的$Proxy0实例强制转型为Subject，并将引用赋给subject。
3. 接着$Proxy0调用父类Proxy的构造器,为h赋值。
4. 当执行subject.request()方法时，就调用了$Proxy0类中的request()方法，进而调用父类Proxy中的h的invoke()方法.即InvocationHandler.invoke()。

public final class $Proxy0 extends Proxy implements subject { 

    //....
    public final void request() {  
        try {  
            super.h.invoke(this, m3, null);  
            return;  
        } catch (Error e) {  
        } catch (Throwable throwable) {  
            throw new UndeclaredThrowableException(throwable);  
        }  
    } 
    //.....
}

JDK动态代理文件$Proxy0.class的生成和查看

invoke()调用问题

代理对象：

1. 通常和目标对象实现同样的接口(可另实现其他的接口)
2. 实现多个接口
   1. 接口的排序非常重要
   2. 当多个接口里面有方法同名，则默认以第一个接口的方法调用
3. 根据给定的接口，由Proxy类自动生成的对象
4. 类型 com.sun.proxy.$Proxy0，继承自java.lang.reflect.Proxy