静态代理和动态代理

1、代理

代理就好比我们现实生活中的中介，我们平时买房租房都是找中介，并不是直接找的房东或业主，因为中介手中的资源比较多。简而言之，代理体现的是一种中间商赚差价的味道。

2、代理模式

代理模式是面向对象编程中比较常见的设计模式。

• 用户只关心接口功能，而不在乎谁提供了功能
• 接口真正实现者是上图的 RealSubject，但是它不与客户直接接触，而是通过代理。
• 代理就是上图中的 Proxy，由于它实现了 Subject 接口，所以它能够直接与用户接触。
• 客户调用 Proxy 的时候，Proxy 内部调用了 RealSubject。所以，Proxy 是中介者。

3、静态代理

由程序员创建或工具生成代理类的源码，再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。

现在用代码模拟现实生活中找中介出租房屋的实例。

1. 首先得创建一个包含出租房子方法的接口Rent，代表有出租房子的能力。

package com.wust.test;

public interface Rent {
    void rent();
}

2. 接着，房东是拥有出租权力的角色，是真正出租房子的角色，需要实现Rent接口。

package com.wust.test;
//包租婆
public class LandLaydy implements Rent{
    public void rent() {
        System.out.println("包租婆出租房子！！！");
    }
}

2. 接着需要创建一个中介，代理出租婆出租房子，中介不仅能出租房子，还能干其它的一些事情，比如收中介费，签合同，带人看房子等。

package com.wust.test;

public class Intermediary implements Rent {
    private Rent rent;
    public Intermediary(Rent rent){
        this.rent = rent;
    }
    public void rent() {
        seeHouse();
        
        signContract();
        
        rent.rent();
        
        getFare();
    }
    public void seeHouse(){
        System.out.println("带客户看房子！！！");
    }
    public void signContract(){
        System.out.println("签租赁合同！！！");
    }
    public void getFare(){
        System.out.println("收中介费！！！");
    }
}

3. 最后创建一个客户类，模拟找中介租房子的过程。

package com.wust.demo;

public class Client {
    public static void main(String[] args) {
        LandLaydy laydy = new LandLaydy();
        Intermediary intermediary = new Intermediary(laydy);
        intermediary.rent();
    }
}

4. 最后结果。

带客户看房子！！！
签租赁合同！！！
包租婆出租房子！！！
收中介费！！！

• 优点：业务类只需要关注业务逻辑本身，保证了业务类的重用性。这是代理的共有优点。
• 缺点：
  1）代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理，静态代理在程序规模稍大时就无法胜任了。
  2）如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度

4、动态代理

既然是代理，那么它与静态代理的功能与目的是没有区别的，唯一有区别的就是动态与静态的差别。上一节代码中 Intermediary类是代理，我们需要手动编写代码让 Intermediary 实现Rent接口，而在动态代理中，我们可以让程序在运行的时候自动在内存中创建一个实现 Rent接口的代理，而不需要去定义 Intermediary 这个类。这就是它被称为动态的原因。

另外动态代理需要使用java反射包里的两个类，Proxy代理类以及InvocationHandler类，下面同样用上面的例子用动态代理进行代码模拟。

1. 首先同样需要创建Rent接口以及实现Rent接口的LandLaydy类
2. 接着创建ProxyHandler类实现InvacationHandler类

package com.wust.demo;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyHandler implements InvocationHandler {
    private Object rent;

    public ProxyHandler(Object rent){
        this.rent = rent;
    }

    public Object getProxy(){
        return Proxy.newProxyInstance(rent.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
    }

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

        signContract();

        Object res = method.invoke(rent,args);

        getFare();

        return res;
    }

    public void seeHouse(){
        System.out.println("带客户看房子！！！");
    }
    public void signContract(){
        System.out.println("签租赁合同！！！");
    }
    public void getFare(){
        System.out.println("收中介费！！！");
    }
}

3. 最后创建Client2类模拟租房过程

package com.wust.demo;

import java.lang.reflect.Proxy;

public class Client2 {
    public static void main(String[] args) {
        LandLaydy laydy = new LandLaydy();
        ProxyHandler handler = new ProxyHandler(laydy);
        //动态生成代理
        Rent rent = (Rent) handler.getProxy();
        rent.rent();
    }
}

综合上面的两个例子，动态代理和静态代理最直接的区别是：静态代理的代理类需要程序编译运行前就写好，而动态代理事先不需要写具体的代理类，只需要创建实现InvocationHandler 的类，最后通过反射机制在程序运行期间动态地创建代理