代理模式

Proxy Pattern

为其他对象提供一个代理以控制对这个对象的访问

可以详细控制访问某个（某类）对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理。

静态代理

直接写死的代码的代理逻辑

在这里插入图片描述

动态代理

动态的生成代理类。有JDK动态代理，CGLIB代理

在这里插入图片描述

JDK自带的动态代理 :

java.lang.reflect.Proxy , 作用：动态生成代理类和对象
java.lang.reflect.InvocationHandler(处理器接口) , 可以通过invoke方法实现对真实角色的代理访问。每次通过Proxy生成代理类对象时都要指定对应的处理器对象

动态代理相比于静态代理的优点
抽象角色中(接口)声明的所以方法都被转移到调用处理器一个集中的方
法中处理，这样，我们可以更加灵活和统一的处理众多的方法。

应用场景：

安全代理：屏蔽对真实角色的直接访问。
远程代理：通过代理类处理远程方法调用(RMI)。
延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象。( 比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有100MB，在打开文件时不可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用proxy来进行大图片的打开。)

开发框架中应用场景：

实际上，随便选择一个技术框架都会用到代理模式！

struts2中拦截器的实现;
数据库连接池关闭处理;
Hibernate中延时加载的实现;
AspectJ的实现 , spring中AOP的实现;
mybatis中实现拦截器插件;
日志拦截;
声明式事务处理;
web service;
RMI远程方法调用

核心角色：

抽象角色：定义代理角色和真实角色的公共对外方法；
真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用，– 关注真正的业务逻辑！；
代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。将统一的流程控制放到代理角色中处理！

静态代理

需要定义接口或父类，被代理对象和代理对象一起实现相同的接口或继承相同的父类

定义接口:IUserDao.java

public interface IUserDao {void save();
}

定义目标对象

package com.ung.designMode.proxy;/*** @author: wenyi* @create: 2022/9/19* @Description:*/
public class UserDao implements IUserDao {@Overridepublic void save() {System.out.println("。。。。保存好了数据。。。。");}
}

定义代理对象，都实现相同的接口

可以在调用目标方法前后来进行代理操作，什么开启事务，提交事务等

package com.ung.designMode.proxy;/*** @author: wenyi* @create: 2022/9/19* @Description:*/
public class UserDaoProxy implements IUserDao {private IUserDao iUserDao;public UserDaoProxy(IUserDao iUserDao) {this.iUserDao = iUserDao;}@Overridepublic void save() {//在这里可以定义调用前的执行操作System.out.println("调用前的操作代理");iUserDao.save();//在这里可以定义调用后的执行操作System.out.println("调用后的操作代理");}
}

测试

package com.ung.designMode.proxy;import org.junit.Test;import static org.junit.Assert.*;public class UserDaoTest {@Testpublic void save() {//目标对象UserDao userDao = new UserDao();//代理对象，将目标对象传给代理对象，建立代理关系UserDaoProxy userDaoProxy = new UserDaoProxy(userDao);//执行的也是代理的方法userDaoProxy.save();}
}

在这里插入图片描述

这样的代理，可以实现不修改目标对象的功能，来进行功能的扩展增强；

但是这样有缺陷，都需要实现相同的接口，导致代理类很多，

如果接口的方法修改，呐需要变动的就很多，不易维护

可以使用动态代理，也叫 JDK代理，接口代理

JDK动态代理

代理对象可以不用实现接口
利用jdk的api来生成代理对象，动态的在内存中构建代理对象

需要我们指定一个创建代理对象和目标对象实现的接口

在这里插入图片描述

总结：代理对象可以不用实现接口，但是目标对象要实现接口，否则不能使用动态代理

对之前的案例，相同的基础上，新建一个ProxyFactory的代理工厂类，在测试类中建立目标对象和代理对象的联系，最后调用代理对象的方法就可以

新建 ProxyFactory 代理类

package com.ung.designMode.proxy;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;/*** @author: wenyi* @create: 2022/9/19* @Description: 代理类工厂*/
public class ProxyFactory {//    维护一个目标对象private Object target;public ProxyFactory(Object target) {this.target = target;}public Object getProxyInstance() {return Proxy.newProxyInstance(target.getClass().getClassLoader(),//类加载器target.getClass().getInterfaces(),//目标类实现的接口new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("调用前的开启事务");Object returnValue = method.invoke(target, args);System.out.println("调用后的提交事务");return returnValue;}});}
}

测试

package com.ung.designMode.proxy;import org.junit.Test;import static org.junit.Assert.*;public class UserDaoTest {@Testpublic void save() {//目标对象UserDao userDao = new UserDao();
//        //代理对象，将目标对象传给代理对象，建立代理关系
//        UserDaoProxy userDaoProxy = new UserDaoProxy(userDao);
//        //执行的也是代理的方法
//        userDaoProxy.save();System.out.println("原始的目标对象"+userDao.getClass());//代理对象IUserDao proxy = (IUserDao) new ProxyFactory(userDao).getProxyInstance();System.out.println("代理对象"+proxy.getClass());proxy.save();}
}

在这里插入图片描述

idea中通过配置VM参数可以将动态生成的代理类的字节码文件保存到本地，方便观察分析代理类的结构。

JDK8及以前版本：-Dsun.misc.ProxyGenerator.saveGeneratedFiles=true
JDK8以后版本：-Djdk.proxy.ProxyGenerator.saveGeneratedFiles=true

在这里插入图片描述

可以看到由JDK代理实现的代理类是通过实现接口，继承Proxy的单继承，默认继承了Proxy就不可以再继承其他类了

实现被代理类实现的接口方法，如果被代理的目标类有私有方法，那这样生成的代理类就不能对私有方法进行代理

CGLIB 动态代理

对类进行代理，code generator library 代码生成库，动态生成字节码对象；

创建代理拦截器

package com.ung.designMode.proxy;import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;import java.lang.reflect.Method;/*** @author: wenyi* @create: 2022/9/19* @Description:*/
public class LycCglibProxyInterceptor implements MethodInterceptor {// proxy:代理对象 method:目标对象中的方法 args:目标对象中的方法 methodProxy:代理对象中的代理方法对象@Overridepublic Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {System.out.println("执行前");Object rtnObj = methodProxy.invokeSuper(o, objects);System.out.println("执行后");return rtnObj;}
}

测试

package com.ung.designMode.proxy;import org.junit.Test;
import org.springframework.cglib.proxy.Callback;
import org.springframework.cglib.proxy.Enhancer;public class LycCglibProxyInterceptorTest {@Testpublic void intercept() {//创建空的字节码对象Enhancer enhancer = new Enhancer();//设置字节码对象的父类就是目标类enhancer.setSuperclass(UserDao.class);//回调对象Callback callback =new LycCglibProxyInterceptor();//设置字节码对象的回调enhancer.setCallback(callback);//代理对象UserDao userDaoProxy = (UserDao) enhancer.create();//调用方法userDaoProxy.save();}
}

可以看到也成功代理

//保存生成的字节码文件
byte[] generate = enhancer.getStrategy().generate(enhancer);
FileOutputStream fileOutputStream = new FileOutputStream(
new File("C:\\个人文档\\learing\\lyccglibtest.class"));
fileOutputStream.write(generate);
fileOutputStream.flush();
fileOutputStream.close();

在这里插入图片描述

（queryCost 是被代理的方法）

可以看到通过CGLIB动态代理生成的代理类，是创建一个新的类继承被代理类，在重写了父类的方法，

在重写的方法里面调用的接口的intercept方法，就是queryCost 被代理的方法,在这里可以进行目标方法的增强；

这样通过子类重写父类的方式的代理，要求被代理的方法不能是final方法修改，否则子类无法重写进行代理；

总结：

如果目标对象实现了接口，默认会使用JDK的动态代理实现AOP

底层依赖 java 反射实现增强，生成一个实现代理接口的代理类

只能代理实现接口的目标类，代理类和目标类都要实现相同的接口
如果目标对象没有实现接口，那就必须用CGLIB动态代理

通过生成一个目标类的子类，来重写目标方法实现代理增强，有拦截器拦截父类的方法调用，目标类不能用final修改方法和类，否则不能继承和重写方法；

Spring会再两者之间转换