java之动态代理

1.由于静态代理产生的代理类过多，造成代码量急剧增加，所以在实际开发中，通常使用动态代理来实现代理功能。

2.在java中实现动态代理的方式有很多。Jdk中通过接口来实现动态代理，如果要实现类的动态代理可以使用 cglib。目前也可以通过 javassit 来实现代理。

3.Jdk的动态代理实现是通过一个类和一个接口来实现的。

InvocationHandler 是代理实例 的调用处理程序 实现的接口。

Object invoke(Object proxy,

              Method method,

              Object[] args)

              throws Throwable

在代理实例上处理方法调用并返回结果。在与方法关联的代理实例上调用方法时，将在调用处理程序上调用此方法。

参数： 

proxy - 在其上调用方法的代理实例

method - 对应于在代理实例上调用的接口方法的 Method 实例。Method 对象的声明类将是在其中声明方法的接口，该接口可以是代理类赖以继承方法的代理接口的超接口。

args - 包含传入代理实例上方法调用的参数值的对象数组，如果接口方法不使用参数，则为 null。基本类型的参数被包装在适当基本包装器类（如 java.lang.Integer 或 java.lang.Boolean）的实例中。

返回： 

从代理实例的方法调用返回的值。如果接口方法的声明返回类型是基本类型，则此方法返回的值一定是相应基本包装对象类的实例；否则，它一定是可分配到声明返回类型的类型。如果此方法返回的值为 null 并且接口方法的返回类型是基本类型，则代理实例上的方法调用将抛出 NullPointerException。否则，如果此方法返回的值与上述接口方法的声明返回类型不兼容，则代理实例上的方法调用将抛出 ClassCastException。

抛出： 

Throwable - 从代理实例上的方法调用抛出的异常。该异常的类型必须可以分配到在接口方法的 throws 子句中声明的任一异常类型或未经检查的异常类型 java.lang.RuntimeException 或 java.lang.Error。如果此方法抛出经过检查的异常，该异常不可分配到在接口方法的 throws 子句中声明的任一异常类型，代理实例的方法调用将抛出包含此方法曾抛出的异常的 UndeclaredThrowableException。

Proxy 提供用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有动态代理类的超类。

public static Object newProxyInstance(ClassLoader loader,

                                      Class<?>[] interfaces,

                                      InvocationHandler h)

                               throws IllegalArgumentException

返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。此方法相当于：

     Proxy.getProxyClass(loader, interfaces).

         getConstructor(new Class[] { InvocationHandler.class }).

         newInstance(new Object[] { handler });

Proxy.newProxyInstance 抛出 IllegalArgumentException，原因与 Proxy.getProxyClass 相同。

参数： 

loader - 定义代理类的类加载器

interfaces - 代理类要实现的接口列表

h - 指派方法调用的调用处理程序

返回： 

一个带有代理类的指定调用处理程序的代理实例，它由指定的类加载器定义，并实现指定的接口

抛出： 

IllegalArgumentException - 如果违反传递到 getProxyClass 的参数上的任何限制

NullPointerException - 如果 interfaces 数组参数或其任何元素为 null，或如果调用处理程序 h 为 null

4.通过动态代理实现租房

MyInvocationHandler.java

public class MyInvocationHandler implements InvocationHandler{
    //目标对象 ---真实对象
    private Object target;
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        fare();    
        //调用真实对象 执行其方法
        return method.invoke(target, args);
    }
    private void fare(){
        System.out.println("中介收费");
    }
    public void setTarget(Object target) {
        this.target = target;
    }
}

Rent.java

public interface Rent {
    //租房
    public void rent();
}

Host.java

public class Host implements Rent{
    @Override
    public void rent() {
        System.out.println("========将房屋出租=======");
    }
}

Client.java

public class Client {
    public static void main(String[] args) {
        Host host = new Host();
        MyInvocationHandler handler = new MyInvocationHandler();
        handler.setTarget(host);
        Rent proxy=(Rent)Proxy.newProxyInstance(Client.class.getClassLoader(),
                host.getClass().getInterfaces(), handler);
        proxy.rent();
    }
}

5.封装为一个类

public class DynamicProxy implements InvocationHandler{
    private Object target;
    public void setTarget(Object target) {
        this.target = target;
    }
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(), 
                this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        //result方法执行的返回值
        Object result = method.invoke(target, args);
        after();
        return result;
    }
    private void before(){
        System.out.println("在真实方法执行前 添加新的功能");
    }
    private void after(){
        System.out.println("在真实方法执行后 添加新的功能");
    }
}

总结：动态代理解决了静态代理的缺点；一个类可以代理多个真实对象。