AOP的核心：代理模式（静态代理、动态代理）

﹏ヽ暗。殇╰゛Y 2024-04-05 07:14 93阅读 0赞

> [Java知识点总结：想看的可以从这里进入][Java]

#### 目录 ####

*   *   *  13.2、代理模式
         *   *  13.2.1、简介
             *  13.2.2、静态代理
             *  13.2.3、JDK动态代理
             *  13.2.4、CGLIB代理

#### 13.2、代理模式 ####

##### 13.2.1、简介 #####

代理模式就是面向切面编程（AOP）的底层，它是常用的java设计模式之一，他的特征是代理类与委托类有同样的接口，通过代理类来为委托类提供：预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等功能。在代理模式中，不会直接访问实际对象，而是访问代理对象，正是这种间接的特性，为我们增加了更多的处理方式。

![image-20220912102800653][]

比如现实中代理也是很常见的，比如我们常见的明星，他们都会有一个专门的经纪人，很多合约等等前期都是由经济人先去洽谈，谈妥后明星签字，然后履行合约即可，很多事情都不需要明星自己去完成，而经纪人这个角色就是一个代理对象。

我们通过代理模式可以对某些方法进行添加新功能，即增强处理，这些增强处理，既可以添加到方法前面，也可以添加到方法后面。

代理模式中主要包含以下几个角色：

*  角色
    
    ![image-20220912104110209][]
    
     *  抽象接口：接口或抽象类，表明要做什么？
     *  真实角色(被代理的类)：继承接口或实现抽象类，具体去实现某类功能。
     *  代理角色(代理类)：去代理真实的角色，并增加一些公共的方法，管理真实角色
     *  客户：访问代理角色，通过代理角色，我们即可完成所需功能，不需要去专门的寻找相应的真实角色。
 *  优点
    
     *  真实角色可以独立出来只做自己相关的功能，不需要去重复写一些公共的功能代码
     *  公共的功能只要交给代理角色去实现，通过代理角色去管理真实角色，可以统一的实现公共部分的功能
     *  公共的功能扩展时，只需要找代理角色即可
 *  缺点：当项目复杂时，会使代理角色大量增加，导致开发效率变低

##### 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);
            }
        }
 *  测试一下
    
    ![image-20230330095607480][]

现在我想在上面的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("操作完成");
            }
        }
 *  再测试一下
    
    ![image-20230330100157000][]

这样就通过添加了一层代理，在不改变原有service的基础上，添加了一些其他的信息。但是这种代理在service很多时，每一个service都需要添加一个代理类，实际使用起来还是挺麻烦的。

##### 13.2.3、JDK动态代理 #####

在测试了静态代理后，我们这种方式需要手动添加一个代理对象，当被代理对象很多时，就需要添加很多代理对象，使代码量大大增加。

所以Java提供了一种**JDK动态代理**，它使用的反射机制，在 java.lang.reflect 包下提供了一个 Proxy 类和一个InvocationHandler接口，通过一个类和一个接口就可以实现动态代理。

1.  InvocationHandler接口：通过实现这个接口，定义横切逻辑，然后通过invoke方法调用目标类的代码。可以添加一些前置后置等处理。
2.  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);
            }
        }
 *  测试
    
    ![image-20230330101108556][]

##### 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);
            }
        }
 *  测试
    
    ![image-20230330102655606][]

[Java]: https://blog.csdn.net/yuandfeng/article/details/114333525
[image-20220912102800653]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/04/2df8ad884fd448e1bc53b158a58d0396.png
[image-20220912104110209]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/04/e2f511c4172547089a99a0e96e9d153c.png
[image-20230330095607480]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/04/72eab513ebcb4005b7c278f015c6a40a.png
[image-20230330100157000]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/04/9b2107dfa5e04477b39165d2bc612082.png
[image-20230330101108556]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/04/b038ff82ae6342b092b24bc7bca5c5a2.png
[image-20230330102655606]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/04/f390bc4b321247e6a4da9f49632945f8.png