代理模式（JDK和CGLIB）

代理模式

静态代理

• 代理类只能够为特定的类产生代理对象，不能代理任意类
• 静态代理只能代理实现通用接口的类

动态代理

• 几乎可以为所有的类产生代理对象

JDK动态代理

• 特点是被代理对象一定实现了某个接口，因为JDK动态代理是基于接口创建的代理对象

//基于JDK的动态代理类，首先要实现InvocationHandler接口，以便执行被代理类的方法
public class JDKDynamicProxy implements InvocationHandler{
    //接收被代理类
    private Object obj;
    //绑定被代理类，必须是实现了某个接口的类的对象
    public JDKDynamicProxy(Object obj){
        this.obj = obj;
    }
    
    //生成动态代理类
    //产生的代理对象,可以强转为被代理对象实现的接口的类型
    public Object getProxy(){
        //Proxy.newProxyInstance()方法接受3个参数
        //1.被代理类的类加载器
        //2.被代理类实现的接口
        //3.InvocationHandler的对象，通过反射机制找到被代理类，执行被代理类的方法
        ClassLoader classLoader = obj.getClass().getClassLoader();
        Class<?>[] interfaces = obj.getClass().getInterfaces();
        Object proxy = Proxy.newProxyInstance(classLoader,interfaces,this);
		return proxy;        
    }
    
    //在invoke()方法里面实现业务逻辑
    //使用代理对象调用方法，不会直接用被代理对象的方法，而是会被拦截
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
        //通过反射调用被代理类的方法
        Object result = method.invoke(obj, args);
        return result;
    }
}

//模拟房子出租
public interface Rent {
    void rent();
}

//具体要出租的人的类
public class Host implements Rent{
    private String name;
    private String address;
    public Host() {
    }
    public Host(String name, String address) {
        this.name = name;
        this.address = address;
    }
    @Override
    public void rent() {
        System.out.println(name + "出租的位置是：" + address);
    }
}

public static void main(String[] args) {
    //具体要出租的人
    Host host = new Host("张三","北京");
    //生成动态代理对象
    Rent proxy = (Rent) new JDKDynamicProxy(host).getProxy();
    //代理对象执行rent()方法，实际上是执行代理对象的invoke()方法，将方法名
    //传递给invoke的参数method中，进而通过反射调用被代理对象的rent()方法
    proxy.rent();
}

CGLib动态代理

• 被代理类可以不用实现接口，通过被代理类的子类创建代理对象
• 需要添加CGLib依赖

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

public class CGLibDynamicProxy implements MethodInterceptor {
	//被代理的对象
    private Object obj;
	//通过构造器绑定被代理的对象
    public CGLibDynamicProxy(Object obj) {
        this.obj = obj;
    }
	//根据被代理类的子类生成代理对象
    public Object getProxy(){
        //Enhancer动态的创建给定类的子类并且拦截代理类的所有的方法
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(obj.getClass());
        enhancer.setCallback(this);
        Object proxy = enhancer.create();
        return proxy;
    }
    //调用代理对象的相应方法，会被拦截到这个方法中，执行intercept()方法
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        //通过反射调用被代理类的对应方法，并将参数传递过去
        Object result = method.invoke(obj, objects);
        return result;
    }
}

//具体要出租的人的类，不需要实现接口
public class Host{
    private String name;
    private String address;
    public Host() {
    }
    public Host(String name, String address) {
        this.name = name;
        this.address = address;
    }
    public void rent(){
        System.out.println(name + "出租的位置是：" + address);
    }
}

public static void main(String[] args) {
        Host host = new Host("李四", "上海");
        //CGLib产生的代理对象是由Host的子类创建的，可以用父类Host来接收
        //多态：父类的引用指向子类的对象
        Host proxy = (Host) new CGLibDynamicProxy(host).getProxy();
    	//调用的是代理对象的intercept()方法，会把rent()方法名当作参数传递给intercept()方法
        proxy.rent();
    }