一、动态代理和静态代理区别

静态代理四大要素（以房东和中介为例） 1、接口，即要实现的功能，如出租房屋； 2、真实对象，即被代理对象，如房东； 3、代理对象，如中介； 4、代理对象实现相关功能；

动态代理和静态代理的被代理对象是一样性质的，但是动态代理的代理对象是动态生成的，底层依赖反射实现；而静态代理的代理对象是程序编译之前就需要写好的，针对不同的被代理对象，需要编写不同的静态代理类，比较繁琐。

二、动态代理核心

1、InvocationHandler接口

代码如下（示例）：

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

//利用这个类，自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {
          
   

    //1、创建被代理的接口
    private Object work;

	//2、设置被代理的对象
    public void setWork(Object work) {
          
   
        this.work = work;
    }

    //2、通过Proxy类生成代理类对象
    public Object getProxy(){
          
   
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), work.getClass().getInterfaces(),this);
    }

    //4、代理对象调用接口方法，并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
          
   
        log(method.getName());
        Object result = method.invoke(work, args);
        return result;
    }

    public void log(String msg){
          
   
        System.out.println("执行了" + msg + "操作");
    }
}

invoke方法中的三个参数的含义如下： proxy：生成的代理类对象； method：代理类对象执行的方法； args：代理对象方法传递的参数。

2、Proxy类

Proxy类是用来创建代理对象的类，主要实现方法是通过静态方法newProxyInstance实现，如下图

代码如下（示例）：

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

方法需要传递三个参数： ClassLoader：代表加载当前类的类加载器，直接传入 this.getClass().getClassLoader()即可； Class<?>[] interfaces：代表被代理对象所实现的接口，传入 接口.getClass().getInterfaces()； InvocationHandler：当前类对象。

三、动态代理实现

构建一个Rent接口：

public interface Rent {
          
   
    void rent();
}

构建被代理对象类Host：

public class Host implements Rent{
          
   

    @Override
    public void rent() {
          
   
        System.out.println("我要把我的房子租出去");
    }
}

代理对象调用被代理对象的方法：

public class Client {
          
   
    public static void main(String[] args) {
          
   

        //1、要代理的真实对象
        Host host = new Host();
        //2、代理对象的调用处理程序
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //3、通过代理对象的调用处理程序设置要代理的真实对象
        pih.setWork(host);
        //4、通过调用处理程序的getProxy函数生成代理类对象
        Rent proxy = (Rent) pih.getProxy();
        //5、使用代理类对象调用真实对象的方法，方法调用被编码分派到调用处理程序的invoke方法执行并输出
        proxy.rent();


    }
}