代理模式
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 {
@Override
public 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;
}
@Override
public 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 {
@Test
public 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() {
@Override
public 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 {
@Test
public 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:代理对象中的代理方法对象
@Override
public 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 {
@Test
public 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会再两者之间转换
