Java动态代理

模式的结构

代理模式的主要角色如下。

1. 抽象类：通过接口或抽象类声明真实主题和代理对象实现的业务方法。

2. 真实类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。

3. 代理类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。

静态代理

由程序员创建代理类或特定工具自动生成源代码再对其编译，在程序运行前代理类的 .class 文件就已经存在了

代码实现

Rent . java 即抽象角色

//抽象角色：租房
public interface Rent {
   public void rent();
}

Host . java 即真实角色

//真实角色: 房东，房东要出租房子
public class Host implements Rent{
   public void rent() {
       System.out.println("房屋出租");
  }
}

Proxy . java 即代理角色

//代理角色：中介
public class Proxy implements Rent {

   private Host host;
   public Proxy() { }
   public Proxy(Host host) {
       this.host = host;
  }

   //租房
   public void rent(){
       seeHouse();
       host.rent();
       fare();
  }
   //看房
   public void seeHouse(){
       System.out.println("带房客看房");
  }
   //收中介费
   public void fare(){
       System.out.println("收中介费");
  }
}

Client . java 即客户

//客户类，一般客户都会去找代理！
public class Client {
   public static void main(String[] args) {
       //房东要租房
       Host host = new Host();
       //中介帮助房东
       Proxy proxy = new Proxy(host);

       //你去找中介！
       proxy.rent();
  }
}

分析：在这个过程中，你直接接触的就是中介，就如同现实生活中的样子，你看不到房东，但是你依旧租到了房东的房子通过代理，这就是所谓的代理模式，程序源自于生活，所以学编程的人，一般能够更加抽象的看待生活中发生的事情。

静态代理的好处:

• 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .

• 公共的业务由代理来完成 . 实现了业务的分工 ,

• 公共业务发生扩展时变得更加集中和方便 .

缺点 :

• 类多了 , 多了代理类 , 工作量变大了 . 开发效率降低 .

我们想要静态代理的好处，又不想要静态代理的缺点，所以 , 就有了动态代理 !

代理模式的主要优点有：

• 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用；

• 代理对象可以扩展目标对象的功能；

• 代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度，增加了程序的可扩展性

其主要缺点是：

• 代理模式会造成系统设计中类的数量增加

• 在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢

• 增加了系统的复杂度

动态代理

利用反射机制在运行时创建代理类

动态代理主要涉及两个类：java.lang.reflect.Proxy 和 java.lang.reflect.InvocationHandler

//抽象角色：租房
public interface Rent {
    void rent();
}


//真实角色: 房东，房东要出租房子
public class Host implements Rent{
    @Override
    public void rent() {
        System.out.println("房东出租房子");
    }
}

代理类

public class Proxy {

    private Object object;

    public void setObject(Object object) {
        this.object = object;
    }

    //获取代理类，通过反射动态生成
    public Object getProxy(){
        return java.lang.reflect.Proxy.newProxyInstance(
                this.getClass().getClassLoader(), object.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        // 添加自定义方法
                        before();
                        Object result = method.invoke(object, args);
                        return result;
                    }
                });
    }

    public void before(){
        System.out.println("method before ");
    }
}

动态代理是通过反射来动态生成代理类的，获取动态生成的代理类的对象须借助 Proxy 类的 newProxyInstance 方法

1. 通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类
2. 通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型
3. 通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入

public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,
                                          InvocationHandler h)

//newProxyInstance，方法有三个参数：

//loader: 用哪个类加载器去加载代理对象

//interfaces:动态代理类需要实现的接口

//h:InvocationHandler的实现类,动态代理方法在执行时，会调用h里面的invoke方法去执行

InvocationHandler

package java.lang.reflect;


public interface InvocationHandler {


    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;

    //proxy - 调用该方法的代理实例
    //method -所述方法对应于调用代理实例上的接口方法的实例。方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。
    //args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean 。
}

代理类重写

因为我们代理类的newProxyInstance方法的第三个参数是 InvocationHandler，从上面可知 InvocationHandler是一个接口，那么我们完全可以实现这个接口，这样第三个参数只需要传递 this

public class Proxy implements InvocationHandler {
    private Object object;

    public void setObject(Object object) {
        this.object = object;
    }

    public Object getProxy(){
        return java.lang.reflect.Proxy.newProxyInstance(
                this.getClass().getClassLoader(),object.getClass().getInterfaces(),this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        before();
        Object result = method.invoke(object, args);
        after();
        return result;
    }

    public void before(){
        System.out.println("---");
        System.out.println("method before ");
    }
}

客户端

public class Client {
    public static void main(String[] args) {
        Host host = new Host();
        Proxy proxy = new Proxy();
        proxy.setObject(host);
        Rent rent = (Rent) proxy.getProxy();
        rent.rent();
    }
}

---