Spring的AOP与动态代理

我就是我 2022-01-16 17:45 233阅读 0赞

*  AOP  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjUxMjY3_size_16_color_FFFFFF_t_70]  
    Aspect Oriented Programming（AOP） “面向切面编程”。  
    在Spring中提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务  
    （例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。  
    主要功能  
    日志记录，性能统计，安全控制，事务处理，异常处理等等  
    通过动态代理，可以在不修改源码的前提下，实现功能的注入

# AOP概念和7个专业术语 #

*  1.增强（Advice）  
    　　　　增强就很好理解了，AOP（切面编程）是用来给某一类特殊的连接点，添加一些特殊的功能，那么我们添加的功能也就是增强啦~  
    　　　　比如：添加日志、管理事务。  
    　　　　不过增强不仅仅包含需要增加的功能代码而已，它还包含了方位信息。  
    　　　　那什么是方位信息呢？  
    　　　　方位信息就是相对于方法的位置信息，如：方法前、方法后、方法环绕  
    　　　　为什么要方位信息呢？切点不是确定了需要增强的位置了吗？  
    　　　　切点定位的是“在什么类的什么方法上”，也就是说，切点只是定位到了方法本身（也叫执行点，特殊的连接点），但是我们增强的内容是放在该方法的前面呢、后面呢？还是前后都要呢？这些切点却没有告诉我们，那么我们该如何确定具体位置呢？  
    　　　　所以，我们才需要用到方位信息，进一步的定位到具体的增强代码放置的位置。  
    　　　　咦？增强即包含了【功能】又包含了【方位】，那我是不是不用切点就可以匹配哪些方法，并添加功能了呢？  
    　　　　恩，确实如此，因为通过方位信息，虽然只是简单的描述了【功能】需要放在方法前、后、还是前后都要等信息，但是我们还是可以通过方位定位到位置。只不过，是匹配到所有类的所有方法！因为方位只是说明在方法前还是方法后，并没有要求是哪些类？哪　　　　些方法？ — So，我们可以直接使用增强来生成一个切面，而不需要切点，但这并不怎么推荐，因为它是匹配所有方法的。所以，我们才需要用切点来进一步确认位置。
 *  2.切点（Pointcut）  
    　　　　一个项目中有很多的类，一个类有很多个连接点，当我们需要在某个方法前插入一段增强（advice）代码时，我们就需要使用切点信息来确定，要在哪些连接点上添加增强。  
    　　　　那么切点是什么？  
    　　　　如果把连接点当做数据库中的记录，那么切点就是查找该记录的查询条件。  
    　　　　所以，一般我们要实现一个切点时，那么我们需要判断哪些连接点是符合我们的条件的，如：方法名是否匹配、类是否是某个类、以及子类等。
 *  3.连接点(Joinpoint)  
    　　　　连接点就是程序执行的某个特定的位置，如：类开始初始化前、类初始化后、类的某个方法调用前、类的某个方法调用后、方法抛出异常后等。Spring 只支持类的方法前、后、抛出异常后的连接点。
 *  4.切面(Aspect)  
    　　　　切面由切点和增强(或引介)组成，或者只由增强（或引介）实现。
 *  5.目标对象（Target）  
    　　　　目标对象就是我们需要对它进行增强的业务类~  
    　　　　如果没有AOP，那么该业务类就得自己实现需要的功能。
 *  6.AOP代理(AOP proxy)  
    　　　　一个类被AOP织入后生成出了一个结果类，它是融合了原类和增强逻辑的代理类。
 *  7.织入(Weaving)  
    　　　　织入就是将增强添加到目标类具体连接点上的过程。  
    　　　　 编译期织入，这要求使用特殊java编译器  
    　　　　类装载期织入，这要求使用特殊的类装载器  
    　　　　动态代理织入，在运行期为目标类添加增强生成子类的方式  
    　　　　Spring采用的是动态代理织入，而AspectJ采用编译期织入和类装载期织入。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjUxMjY3_size_16_color_FFFFFF_t_70 1]

# 原生的动态代理 #

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>groupId</groupId>
        <artifactId>dome03</artifactId>
        <version>1.0-SNAPSHOT</version>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.1.5.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>commons-logging</groupId>
                <artifactId>commons-logging</artifactId>
                <version>1.2</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>5.1.5.RELEASE</version>
            </dependency>
            
            
            <dependency>
                <groupId>cglib</groupId>
                <artifactId>cglib</artifactId>
                <version>3.1</version>
            </dependency>
        </dependencies>
        
    </project>

UserDao.java

package com.xbj.dao;
    
    /** * @Author:晓宇码匠 * @Date：2019/6/15 0015 */
     public interface UserDao { 
        void addUser();
        void delUser();
    }

UserDaoImpl.java

package com.xbj.dao.impl;
    
    import com.xbj.dao.UserDao;
    
    /** * @Author:晓宇码匠 * @Date：2019/6/15 0015 */
    public class UserDAOImpl implements UserDao { 
        public void addUser() { 
            System.out.println("addUser");
        }
    
        public void delUser() { 
            System.out.println("delUser");
        }
    
        //定义初始化方法
        public void myInit(){ 
            System.out.println("init...");
    
        }
        //定义销毁方法
        public void dest(){ 
            System.out.println("dest...");
        }
    
    }

MyAdvice.java

package com.xbj;
    
    /** * @Author:晓宇码匠 * @Date：2019/6/15 0015 */
    public class MyAdvice { //通知
            public void before(){ 
                System.out.println("开启事务");
            }
    
            public void after(){ 
                System.out.println("关闭事务");
            }
    
    }

test测试类：

import com.xbj.MyAdvice;
    import com.xbj.dao.UserDao;
    import com.xbj.dao.impl.UserDAOImpl;
    import org.junit.Test;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /** * @Author:晓宇码匠 * @Date：2019/6/15 0015 */
    public class test { 
        @Test
        public void  t1(){ 
            //目标类
            final UserDAOImpl userDAO = new UserDAOImpl();
            //通知（植入的功能）
            final MyAdvice advice = new MyAdvice();
    
            InvocationHandler handler = new InvocationHandler() { 
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
                    if (method.equals("delUser")){ 
                        advice.before();
                    }
                    Object object=method.invoke(userDAO,args);
    
                    if (method.getName().equals("addUser")){ 
                        advice.after();
                    }
                    return object;
                }
            };
            //Proxy.newProxyInstance(类加载器, 接口ming.,回调函数;
            UserDao proxyClass = (UserDao) Proxy.newProxyInstance(userDAO.getClass().getClassLoader(), userDAO.getClass().getInterfaces(),handler);
            proxyClass.addUser();
            System.out.println("------------------");
            proxyClass.delUser();
    
        }
    }

控制台输出：

addUser
    关闭事务
    ------------------
    delUser

# 基于子类的动态代理 #

代码同上  
test测试类添加了t2测试方法：

import com.xbj.MyAdvice;
    import com.xbj.dao.UserDao;
    import com.xbj.dao.impl.UserDAOImpl;
    import net.sf.cglib.proxy.Callback;
    import net.sf.cglib.proxy.Enhancer;
    import net.sf.cglib.proxy.MethodInterceptor;
    import net.sf.cglib.proxy.MethodProxy;
    import org.junit.Test;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /** * @Author:晓宇码匠 * @Date：2019/6/15 0015 */
    public class test { 
        @Test
        public void  t1(){ 
            //目标类
            final UserDAOImpl userDAO = new UserDAOImpl();
            //通知（植入的功能）
            final MyAdvice advice = new MyAdvice();
    
            InvocationHandler handler = new InvocationHandler() { 
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
                    if (method.equals("delUser")){ 
                        advice.before();
                    }
                    Object object=method.invoke(userDAO,args);
    
                    if (method.getName().equals("addUser")){ 
                        advice.after();
                    }
                    return object;
                }
            };
            //Proxy.newProxyInstance(类加载器, 接口ming.,回调函数;
            UserDao proxyClass = (UserDao) Proxy.newProxyInstance(userDAO.getClass().getClassLoader(), userDAO.getClass().getInterfaces(),handler);
            proxyClass.addUser();
            System.out.println("------------------");
            proxyClass.delUser();
    
        }
        @Test
        public void t2(){ 
            //目标类
            final UserDAOImpl userDAOimpl=new UserDAOImpl();
            //通知(植入的功能)
            final MyAdvice advice=new MyAdvice();
            Callback callback=new MethodInterceptor() { 
                public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { 
                    advice.before();
                    Object obj=method.invoke(userDAOimpl,objects);
                    advice.after();
                    return obj;
                }
            };
            //superclass callback
            UserDao proxyClass= (UserDao) Enhancer.create(userDAOimpl.getClass(),callback);
            proxyClass.delUser();
        }
    }

运行t2测试方法，控制台输出：

开启事务
    delUser
    关闭事务

# Spring 自动代理 #

@Component @Controller @Repository @Service 都是将bean放入Ioc容器中，只是为了代码的可读性而去区别开  
@Autowired 是从Ioc容器拿对象  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjUxMjY3_size_16_color_FFFFFF_t_70 2]  
流程：

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation=" http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd">
    
        <context:component-scan base-package="com.xbj"/>
        
        
        <aop:config proxy-target-class="true">
            
            
            <aop:advisor advice-ref="myAspect" pointcut="execution(* com.xbj.service.impl.*.*(..))" />
        </aop:config>
    </beans>

UserController.java

package com.xbj.controller;
    
    import com.xbj.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    
    /** * @Author:晓宇码匠 * @Date：2019/6/15 0015 */
    /* @Controller @Repository @Component @Service 都是将bean放入Ioc容器中，只是为了代码的可读性而去区别开 * @Autowired 是从Ioc容器拿对象 * */
    @Controller
    public class UserController { 
    
        @Autowired
        private UserService userService;
    
        public void addUser(){ 
            userService.addUser();
        }
    }

UserDao.java

package com.xbj.dao;
    
    /** * @Author:晓宇码匠 * @Date：2019/6/15 0015 */
     public interface UserDao { 
        void addUser();
        void delUser();
    }

UserDaoImpl.java

package com.xbj.dao.impl;
    
    import com.xbj.dao.UserDao;
    import org.junit.runner.RunWith;
    import org.springframework.stereotype.Repository;
    import org.springframework.stereotype.Service;
    
    /** * @Author:晓宇码匠 * @Date：2019/6/15 0015 */
    @Repository
    public class UserDaoImpl implements UserDao { 
        public void addUser() { 
            System.out.println("addUser");
        }
    
        public void delUser() { 
            System.out.println("delUser");
        }
    
        //定义初始化方法
        public void myInit(){ 
            System.out.println("init...");
    
        }
        //定义销毁方法
        public void dest(){ 
            System.out.println("dest...");
        }
    
    }

UserService.java

package com.xbj.service;
    
    /** * @Author:晓宇码匠 * @Date：2019/6/15 0015 */
    public interface UserService { 
        void addUser();
        void delUser();
    }

UserServiceImpl.java

package com.xbj.service.impl;
    
    import com.xbj.dao.UserDao;
    import com.xbj.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    /** * @Author:晓宇码匠 * @Date：2019/6/15 0015 */
    @Service
    public class UserServiceImpl implements UserService { 
        @Autowired
        private UserDao userDao;
        public void addUser() { 
           userDao.addUser();
        }
    
        public void delUser() { 
            userDao.delUser();
        }
    }

MyAspect.java

package com.xbj;
    
    import org.aopalliance.intercept.MethodInterceptor;
    import org.aopalliance.intercept.MethodInvocation;
    import org.springframework.stereotype.Component;
    import org.springframework.stereotype.Controller;
    
    /** * @Author:晓宇码匠 * @Date：2019/6/15 0015 */
    /* * 注意包名：org.aopalliance.intercept.MethodInterceptor;MyAspect * */
    //切面
    @Component
    public class MyAspect implements MethodInterceptor { 
        public Object invoke(MethodInvocation invocation) throws Throwable { 
            System.out.println("前置增强");
            Object obj=invocation.proceed();   //invocation 调用
            System.out.println("后置增强");
            return obj;
        }
    
    }

test.java

import com.xbj.controller.UserController;
    import com.xbj.dao.UserDao;
    import net.sf.cglib.proxy.Callback;
    import net.sf.cglib.proxy.Enhancer;
    import net.sf.cglib.proxy.MethodInterceptor;
    import net.sf.cglib.proxy.MethodProxy;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.test.context.ContextConfiguration;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    
    
    /** * @Author:晓宇码匠 * @Date：2019/6/15 0015 */
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(locations = { "classpath:applicationContext.xml"})
    public class test { 
        @Autowired
        private UserController controller;
        @Test
        public void t1() { 
            controller.addUser();
        }
    
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjUxMjY3_size_16_color_FFFFFF_t_70]: /images/20220114/6565e21c7b69499797c91d55e3d5b132.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjUxMjY3_size_16_color_FFFFFF_t_70 1]: /images/20220114/04d21768b1e34182bd00c2061661d9f2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjUxMjY3_size_16_color_FFFFFF_t_70 2]: /images/20220114/deb77071b09e462b86a22a731d6a2a84.png