13.2、代理模式
13.2.1、简介
代理模式就是面向切面编程（AOP）的底层，它是常用的java设计模式之一，他的特征是代理类与委托类有同样的接口，通过代理类来为委托类提供：预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等功能。在代理模式中，不会直接访问实际对象，而是访问代理对象，正是这种间接的特性，为我们增加了更多的处理方式。
比如现实中代理也是很常见的，比如我们常见的明星，他们都会有一个专门的经纪人，很多合约等等前期都是由经济人先去洽谈，谈妥后明星签字，然后履行合约即可，很多事情都不需要明星自己去完成，而经纪人这个角色就是一个代理对象。
我们通过代理模式可以对某些方法进行添加新功能，即增强处理，这些增强处理，既可以添加到方法前面，也可以添加到方法后面。
代理模式中主要包含以下几个角色：
-
角色
- 抽象接口：接口或抽象类，表明要做什么？
- 真实角色(被代理的类)：继承接口或实现抽象类，具体去实现某类功能。
- 代理角色(代理类)：去代理真实的角色，并增加一些公共的方法，管理真实角色
- 客户：访问代理角色，通过代理角色，我们即可完成所需功能，不需要去专门的寻找相应的真实角色。
-
优点
- 真实角色可以独立出来只做自己相关的功能，不需要去重复写一些公共的功能代码
- 公共的功能只要交给代理角色去实现，通过代理角色去管理真实角色，可以统一的实现公共部分的功能
- 公共的功能扩展时，只需要找代理角色即可
-
缺点：当项目复杂时，会使代理角色大量增加，导致开发效率变低
13.2.2、静态代理
比方说在 UserService 中有增删改查四个方法，我们想在其中增加日志的功能，在原有的类中增加代码显然不合适，这个时候我们可以增加一个代理层，在代理层中添加日志的功能。
-
通过@Bean设置一个保存User对象的List，模拟从数据库取数据
@Bean("userList") public List<User> getUserList(){ List<User> userList = new ArrayList<>(); userList.add(new User(1,"用户1","123456",false)); userList.add(new User(2,"用户2","234567",false)); userList.add(new User(3,"用户3","345678",false)); userList.add(new User(4,"用户4","456789",false)); userList.add(new User(5,"用户5","567890",false)); return userList; } -
创建DAO操作userList
@Repository public class ProxyTestUserDao { @Resource private List<User> userList; //改 public void update(User user) { boolean exists = true; for (int i=0; i<userList.size(); i++){ if(user.getUserId().equals(userList.get(i).getUserId())){ exists = false; userList.set(i,user); break; } } if(exists){ System.out.println("没有此用户"); } } //删 public void delete(int id) { boolean exists = false; for (int i=0; i<userList.size(); i++){ if(id == userList.get(i).getUserId()){ exists = true; userList.remove(i); break; } } if(!exists){ System.out.println("没有此用户"); }else { System.out.println("删除成功"); } } //查 public User select(int id) { for (User user : userList) { if (id == user.getUserId()) { return user; } } return null; } public List<User> selectAll() { return userList; } //增加 public void insert(User user) { int id = userList.get(userList.size()-1).getUserId(); id += 1; user.setUserId(id); userList.add(user); System.out.println("增加成功"); } } -
创建service层
@Service public class ProxyTestUserServiceImpl implements ProxyTestUserService { @Autowired private ProxyTestUserDao proxyTestUserDao; @Override public void update(User user) { proxyTestUserDao.update(user); } @Override public void delete(int id) { proxyTestUserDao.delete(id); } @Override public User select(int id) { return proxyTestUserDao.select(id); } @Override public List<User> selectAll() { return proxyTestUserDao.selectAll(); } @Override public void insert(User user) { proxyTestUserDao.insert(user); } } -
测试一下
现在我想在上面的service中的几个操作中添加一些日志的功能，能打印出来我在做什么操作，首先要符合 开闭原则，不能直接修改源代码，那我们可以通过添加一个代理层来实现。
-
添加代理角色
public class ProxyTestUserServiceProxyImpl implements ProxyTestUserService { @Resource(name = "proxyTestUserServiceImpl") private ProxyTestUserService userService; @Override public void update(User user) { System.out.println("修改id为"+user.getUserId()+"的用户信息"); userService.update(user); System.out.println("操作完成"); } @Override public void delete(int id) { System.out.println("删除id为"+id+"的用户信息"); userService.delete(id); System.out.println("操作完成"); } @Override public User select(int id) { System.out.println("获取id为"+id+"的用户信息"); User user = userService.select(id); System.out.println("操作完成"); return user; } @Override public List<User> selectAll() { System.out.println("查询所有用户"); return userService.selectAll(); } @Override public void insert(User user) { System.out.println("新增用户"); userService.insert(user); System.out.println("操作完成"); } } -
再测试一下
这样就通过添加了一层代理，在不改变原有service的基础上，添加了一些其他的信息。但是这种代理在service很多时，每一个service都需要添加一个代理类，实际使用起来还是挺麻烦的。
13.2.3、JDK动态代理
在测试了静态代理后，我们这种方式需要手动添加一个代理对象，当被代理对象很多时，就需要添加很多代理对象，使代码量大大增加。
所以Java提供了一种JDK动态代理，它使用的反射机制，在 java.lang.reflect 包下提供了一个 Proxy 类和一个InvocationHandler接口，通过一个类和一个接口就可以实现动态代理。
-
InvocationHandler接口：通过实现这个接口，定义横切逻辑，然后通过invoke方法调用目标类的代码。可以添加一些前置后置等处理。
-
Proxy 类：提利用InvocationHandler动态创建一个符合目标类实现的接口的实例，生成目标类的代理对象。
-
newProxyInstance：用于创建一个代理实例。
@CallerSensitive public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) { Objects.requireNonNull(h); final Class<?> caller = System.getSecurityManager() == null? null: Reflection.getCallerClass(); /* * 查找或生成指定的代理类及其构造函数。 */ Constructor<?> cons = getProxyConstructor(caller, loader, interfaces); return newProxyInstance(caller, cons, h); } -
getProxyClass：用于获取代理类的Class对象，再通过调用构造函数创建代理实例。
-
通过 Proxy 类 newProxyInstance方法创建了一个动态代理对象，它生成了一个叫 $Proxy0（0是编号，多个代理类会进行递增）的代理类，这个类文件时放在内存中的，我们在创建代理对象时，就是通过反射获得这个类的构造方法，然后创建的代理实例。
InvocationHandler接口的实现类就像是一个中介，它持有被代理对象，被我们调用代理对象自身方法时，它会跳转到 invoke方法，并将方法传递进来，在invoke 中调用了被代理对象的相应方法，而在调用前后均可以进行其他的处理。
我们将上面的静态代理通过JDK动态代理实现一下：
-
User类、dao类、service类不变
-
自定义一个拦截器，用于织入一些前置、后置通知
public interface Interceptor { public void before(Object obj); public void after(Object obj); public void afterReturning(Object obj); public void afterThrowing(Object obj); } public class UserServiceInterceptor implements Interceptor{ @Override public void before(Object obj) { System.out.println("方法前置处理"); } @Override public void after(Object obj) { System.out.println("方法后置处理"); } @Override public void afterReturning(Object obj) { System.out.println("操作成功！！！"); } @Override public void afterThrowing(Object obj) { System.out.println("出现了异常"); } -
创建态代理工厂 ProxyFactory
public class ProxyFactory implements InvocationHandler{ // 传递一个真实的对象 private Object target; //拦截器（前置、后置通知） private Interceptor interceptor; //传递一个拦截器，传递一个被代理的对象，自动生成代理对象 public static <T> Object getBean(T target, Interceptor interceptor) { ProxyFactory proxyFactory = new ProxyFactory(); proxyFactory.target = target; proxyFactory.interceptor = interceptor; //生成代理对象。newProxyInstance方法参数 //参数：被代理类类加载器、被代理对象实现的接口、ProxyBeanUtilHandler对象 return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),proxyFactory); } //被代理对象执行方法时，都会跳转到这里进行过统一的处理，添加了处理前，处理后等一些操作 @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("代理执行" +method.getName() + "方法"); Object retobj = null; //调用方法前的处理（可以设置一个拦截器，在此处调用） interceptor.before(target); //是否有异常 boolean exceptionFlag = false; try { retobj = method.invoke(target,args); } catch (IllegalAccessException e) { exceptionFlag = true; } finally { //调用方法前的处理（可以设置一个拦截器，在此处调用） interceptor.after(target); } //判断是否有异常 if(exceptionFlag){ interceptor.afterThrowing(target); }else { interceptor.afterReturning(target); } return retobj; } } -
创建一个工厂，用来返回生成的代理对象
public class ProxyBeanFactory { public static <T>T getBean(T obj, Interceptor interceptor){ //通过代理类添加以上逻辑所需要实现的方法 return (T)ProxyFactory.getBean(obj,interceptor); } } -
测试
13.2.4、CGLIB代理
使用JDK技术必须要在接口环境中（被代理对象实现某个接口），如果某些环境中无法提供接口，那么JDK动态代理是不能使用的。这时候可以借助第三方技术，而CGLIB动态代理就是第三方提供的技术。
添加cglib的依赖
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.3.0</version>
</dependency>
CGLIB不需要提供接口，只需要一个非抽象类就可以实现代理。它是一个接口：org.springframework.cglib.proxy.MethodInterceptor，除此之外需要创建一个 org.springframework.cglib.proxy.Enhancer 的工具类，此类用来生成代理对象。
-
创建一个类（不实现接口），作为被代理对象
public class ClgbTest { public void test(){ System.out.println("测试CLGB动态代理"); } } -
创建CglbProxy 实现 org.springframework.cglib.proxy.MethodInterceptor（不要导错包）
public class CglbProxy implements MethodInterceptor { //为目标对象生成代理对象 public static <T> Object getBean(Class<T> obj) { //Cglb的enhancer增强对象 Enhancer enhancer = new Enhancer(); //增强类型 enhancer.setSuperclass(obj); //设置代理逻辑对象为CglbProxy类的实例 enhancer.setCallback(new CglbProxy()); return enhancer.create(); } @Override public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { Object retobj = null; System.out.println("代理执行" +method.getName() + "方法"); //调用方法前的处理（可以设置一个拦截器，在此处调用） System.out.println("方法前置处理"); retobj = methodProxy.invokeSuper(o,objects); //调用方法前的处理（可以设置一个拦截器，在此处调用） System.out.println("方法后置处理"); return retobj; } } -
创建一个工厂，用来返回生成的代理对象
public class ProxyBeanFactory { public static <T>T getClibBean(Class<T> obj){ //通过代理类添加以上逻辑所需要实现的方法 return (T)CglbProxy.getBean(obj); } } -
测试
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
