Spring中的AOP

快来打我* 2023-10-01 19:04 5阅读 0赞

### Spring中的AOP ###

#### AOP在Spring中的作用 ####

> 提供声明式事务，允许用户自定义切面

*  横切关注点:跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志,安全,缓存,事务等等…
 *  切面(ASPECT) :横切关注点被模块化的特殊对象。即，它是-一个类。
 *  通知(Advice) :切面必须要完成的工作。即，它是类中的一个方法。
 *  目标(Target) :被通知对象。
 *  代理(Proxy) :向目标对象应用通知之后创建的对象。
 *  切入点(PointCut) :切面通知执行的“地点”的定义。
 *  连接点（jointPoint) :与切入点匹配的执行点。

#### 使用Spring的API实现Aop ####

代码步骤：

1.  导入依赖
    
        
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.7</version>
        </dependency>
2.  接口
    
        public interface UserService {
              
            public void add();
            public void delete();
            public void update();
            public void select();
        }
3.  实现类
    
        public class UserServiceImpl implements UserService{
              
            @Override
            public void add() {
              
                System.out.println("增加了一个用户");
            }
        
            @Override
            public void delete() {
              
                System.out.println("删除了一个用户");
            }
        
            @Override
            public void update() {
              
                System.out.println("更新了一个用户");
            }
        
            @Override
            public void select() {
              
                System.out.println("查询了一个用户");
            }
        }
4.  前置日志
    
        public class Log implements MethodBeforeAdvice {
              
            //method:要执行的目标对象的方法
            //args：参数
            //target：目标对象
            @Override
            public void before(Method method, Object[] args, Object target) throws Throwable {
              
                System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
            }
        }
5.  后置日志
    
        public class AfterLog implements AfterReturningAdvice {
              
            //returnValue:返回值
            @Override
            public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
              
                System.out.println("执行了"+method.getName()+"返回的结果为："+returnValue);
            }
        }
6.  xml配置
    
    > 需要在前面导入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:aop="http://www.springframework.org/schema/aop"
               xsi:schemaLocation="http://www.springframework.org/schema/beans
               http://www.springframework.org/schema/beans/spring-beans.xsd
                http://www.springframework.org/schema/aop
               http://www.springframework.org/schema/aop/spring-aop.xsd">
        
        
            <bean id="userservice" class="com.lzj.service.UserServiceImpl"></bean>
            <bean id="log" class="com.lzj.log.Log"></bean>
            <bean id="afterlog" class="com.lzj.log.AfterLog"></bean>
        
            <aop:config>
        
                <aop:pointcut id="pointcut" expression="execution(* com.lzj.service.UserServiceImpl.*(..))"/>
        
                <aop:advisor advice-ref="log" pointcut-ref="pointcut"></aop:advisor>
                <aop:advisor advice-ref="afterlog" pointcut-ref="pointcut"></aop:advisor>
            </aop:config>
        </beans>
7.  测试
    
        public class MyTest {
              
            public static void main(String[] args) {
              
                ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
                //动态代理代理的是接口
                UserService userservice = (UserService) context.getBean("userservice");
                userservice.add();
            }
        }

![在这里插入图片描述][94d4cb42e4fb46ddb5913cc426fd7143.png_pic_center]

#### 自定义实现AOP ####

> 相比于使用Spring的API实现Aop修改了xml配置文件和将前置日志和后置日志替换成了自定义类

代码步骤：

1.  导入依赖
    
        
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.7</version>
        </dependency>
2.  接口
    
        public interface UserService {
              
            public void add();
            public void delete();
            public void update();
            public void select();
        }
3.  实现类
    
        public class UserServiceImpl implements UserService{
              
            @Override
            public void add() {
              
                System.out.println("增加了一个用户");
            }
        
            @Override
            public void delete() {
              
                System.out.println("删除了一个用户");
            }
        
            @Override
            public void update() {
              
                System.out.println("更新了一个用户");
            }
        
            @Override
            public void select() {
              
                System.out.println("查询了一个用户");
            }
        }
4.  自定义类
    
        public class DiyPointCut {
              
            public void before(){
              
                System.out.println("=========方法执行前=========");
            }
            public void after(){
              
                System.out.println("=========方法执行后=========");
            }
        
        }
5.  xml配置
    
    > 需要在前面导入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:aop="http://www.springframework.org/schema/aop"
               xsi:schemaLocation="http://www.springframework.org/schema/beans
               http://www.springframework.org/schema/beans/spring-beans.xsd
                http://www.springframework.org/schema/aop
               http://www.springframework.org/schema/aop/spring-aop.xsd">
        
        
            <bean id="userservice" class="com.lzj.service.UserServiceImpl"></bean>
            <bean id="log" class="com.lzj.log.Log"></bean>
            <bean id="afterlog" class="com.lzj.log.AfterLog"></bean>
        
            <bean id="diy" class="com.lzj.diy.DiyPointCut"></bean>
            <aop:config>
        
                <aop:aspect ref="diy">
        
                    <aop:pointcut id="pointcut" expression="execution(* com.lzj.service.UserServiceImpl.*(..))"/>
        
                    <aop:before method="before" pointcut-ref="pointcut"/>
                    <aop:after method="after" pointcut-ref="pointcut"/>
                </aop:aspect>
            </aop:config>
        </beans>
6.  测试
    
        public class MyTest {
              
            public static void main(String[] args) {
              
                ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
                //动态代理代理的是接口
                UserService userservice = (UserService) context.getBean("userservice");
                userservice.add();
            }
        }

#### 使用注解实现AOP ####

> 相比于使用自定义类AOP，修改了自定义类和xml配置文件

代码步骤：

1.  导入依赖
    
        
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.7</version>
        </dependency>
2.  接口
    
        public interface UserService {
              
            public void add();
            public void delete();
            public void update();
            public void select();
        }
3.  实现类
    
        public class UserServiceImpl implements UserService{
              
            @Override
            public void add() {
              
                System.out.println("增加了一个用户");
            }
        
            @Override
            public void delete() {
              
                System.out.println("删除了一个用户");
            }
        
            @Override
            public void update() {
              
                System.out.println("更新了一个用户");
            }
        
            @Override
            public void select() {
              
                System.out.println("查询了一个用户");
            }
        }
4.  自定义类
    
        //使用注解方式实现AOP
            @Aspect
        public class AnnotationPointCut {
              
            @Before("execution(* com.lzj.service.UserServiceImpl.*(..))")
            public void before(){
              
                System.out.println("=========方法执行前=========");
            }
            @After("execution(* com.lzj.service.UserServiceImpl.*(..))")
            public void after(){
              
        
                System.out.println("=========方法执行后=========");
            }
            //在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点
            @Around("execution(* com.lzj.service.UserServiceImpl.*(..))")
            public void around(ProceedingJoinPoint jp) throws Throwable {
              
                System.out.println("环绕前");
                Signature signature = jp.getSignature();//获得签名
                System.out.println("signature"+signature);
                Object proceed = jp.proceed();//执行方法
                System.out.println("环绕后");
        
            }
        }
5.  xml配置
    
    > 需要在前面导入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:aop="http://www.springframework.org/schema/aop"
               xsi:schemaLocation="http://www.springframework.org/schema/beans
               http://www.springframework.org/schema/beans/spring-beans.xsd
                http://www.springframework.org/schema/aop
               http://www.springframework.org/schema/aop/spring-aop.xsd">
        
        
            <bean id="userservice" class="com.lzj.service.UserServiceImpl"></bean>
            <bean id="log" class="com.lzj.log.Log"></bean>
            <bean id="afterlog" class="com.lzj.log.AfterLog"></bean>
        
            <bean id="annotation" class="com.lzj.diy.AnnotationPointCut"/>
        
            <aop:aspectj-autoproxy/>
        </beans>
6.  测试
    
        public class MyTest {
              
            public static void main(String[] args) {
              
                ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
                //动态代理代理的是接口
                UserService userservice = (UserService) context.getBean("userservice");
                userservice.add();
            }
        }

#### aspect和advice的区别 ####

> < aop:aspect>定义切面时，只需要定义一般的bean就行，而定义< aop:advisor>中引用的通知时，通知必须实现Advice接口
> 
> < aop:advisor>和< aop:aspect>其实都是将通知和切面进行了封装，原理基本上是一样的，只是使用的方式不同而已

*  < aop:aspect>：定义切面（切面包括通知和切点）
 *  < aop:aspect>大多用于日志，缓存
 *  < aop:advisor>：定义通知器（通知器跟切面一样，也包括通知和切点）
 *  < aop:advisor>大多用于事务管理

Bean(“userservice”);  
userservice.add();  
\}  
\}

### aspect和advice的区别
    
    > < aop:aspect>定义切面时，只需要定义一般的bean就行，而定义< aop:advisor>中引用的通知时，通知必须实现Advice接口
    >
    > < aop:advisor>和< aop:aspect>其实都是将通知和切面进行了封装，原理基本上是一样的，只是使用的方式不同而已
    
    - < aop:aspect>：定义切面（切面包括通知和切点）
    - < aop:aspect>大多用于日志，缓存
    - < aop:advisor>：定义通知器（通知器跟切面一样，也包括通知和切点）
    - < aop:advisor>大多用于事务管理

[94d4cb42e4fb46ddb5913cc426fd7143.png_pic_center]: https://img-blog.csdnimg.cn/94d4cb42e4fb46ddb5913cc426fd7143.png#pic_center