Spring中的AOP相关说明及使用

红太狼 2021-03-12 14:20 578阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2NDk2NA_size_16_color_FFFFFF_t_70]  
**SpringAOP概念**：我们的程序中因为某种需要往往存在很多通用的相关代码，用于解决各种问题，这此代码散落的程序的各个组件中，不利于维护，不利于扩展。比如，事务问题，日志问题，安全问题等这些都是每个系统所需要的，其实这此功能 都可以进行有效的封装，不必写在各个方法中，封装后形成的独立的组件，通过spring进行无缝的织入，可以大大提高程序的灵活和可扩展。它不是一种新的编程思想，而是一种设计模式，或者说是对OOP的一种补充。

**作用及优势**：在程序运行期间不修改源码对方法进行增强，AOP的优势是提高了代码的复用性，提升了开发的效率，降低维护成本。

**相关术语介绍**：  
Joinpoint(连接点) ：指被拦截到的方法；  
Pointcut(切入点) ：指要被增强的方法；  
Advice(通知/增强)：对方法进行增强的具体实现（怎样增强）；  
Introduction(引介)：是一种特殊的通知，可以在运行期不修改类代码的前提  
下，为类增加一些方法或字段；  
Target(目标对象)：被代理的对象；  
Weaving(织入)：把增强应用到目标对象来创建新的代理对象的过程，  
Spring采用动态代理织；  
Proxy（代理）：被增强后的目标类产生的代理类（与目标类是兄弟类）；  
Aspect(切面) ：切入点和通知的结合称之为切面；

**通知：**  
前置通知：在方法执行前执行的通知；  
后置通知：在方法执行后执行的通知；  
异常通知：发生异常时执行的通知；  
最终通知：无论是否发生异常都会执行的通知；  
环绕通知：围绕着整个目标对象方法执行的通知（可以包含以上任意以及 所有通知）；

**入门**：  
用以模拟的业务层类：

package cn.itcast.service.impl;
    import cn.itcast.service.AccountService;
    import org.springframework.stereotype.Service;
    /**
     * 感谢詹姆斯.高斯林!
     * 有志者,事竟成!
     * 少壮不努力,老大徒伤悲!
     */
    /**
     * 用以测试业务层accountService
     */
    public class AccountServiceImpl implements AccountService{
        @Override
        public void saveAccount() {
            // int a = 1/0;
            System.out.println("执行了保存");
        }
    }

通知类：

public class Logger {
    
        /**
         * 前置通知
         */
        public void beforeAdvice(){
            System.out.println("before:开始记录日志...");
        }
        /**
         * 后置通知
         */
        public void afterAdvice(){
            System.out.println("afterAdvice......");
        }
        /**
         * 最终通知
         */
        public void finallyAdvice(){
            System.out.println("finallyAdvice.........");
        }
        /**
         * 异常通知
         */
        public void exceptionAdvice(){
            System.out.println("exceptionAdvice....");
        }
        /**
         * 环绕通知
         * @param pjp
         */
        public Object aroundPringLog(ProceedingJoinPoint pjp){
            Object obj = null;
            try {
                Object[] args = pjp.getArgs();// 得到方法所需的参数
                System.out.println("环绕通知:前置...");
                //明确调用业务层方法
                obj = pjp.proceed(args);
                System.out.println("环绕通知:后置...");
                return obj;
            } catch (Throwable throwable) {
                System.out.println("环绕通知:异常...");
                throw new RuntimeException(throwable);
            }finally {
                System.out.println("环绕通知:最终...");
            }
        }
    }

配置文件:

<?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="accountService" class="cn.itcast.service.impl.AccountServiceImpl"/>
        
        <bean id="logger" class="cn.itcast.utils.Logger"></bean>
        
        <aop:config>
            
            <aop:pointcut id="p1" expression="execution(* cn.itcast.service.impl.*.*(..))"/>
            <aop:aspect id="logAdvice" ref="logger">
                
                <aop:before method="beforeAdvice" pointcut-ref="p1"/>
                
                <aop:after-returning method="afterAdvice" pointcut-ref="p1"/>
                
                <aop:after-throwing method="exceptionAdvice" pointcut-ref="p1"/>
                
                <aop:after method="finallyAdvice" pointcut-ref="p1"/>
                
                <aop:around method="aroundPringLog" pointcut-ref="p1"/>
            </aop:aspect>
        </aop:config>
    </beans>

测试:

package cn.itcast.test;
    
    import cn.itcast.service.AccountService;
    import org.junit.runner.RunWith;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.test.context.ContextConfiguration;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    
    /**
     * 感谢詹姆斯.高斯林!
     * 有志者,事竟成!
     * 少壮不努力,老大徒伤悲!
     */
    public class AopTest {
        public static void main(String[] args) {
            // 加载配置类,获取ac
            ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:bean.xml");
            //得到AccountService对象
            AccountService accountService = ac.getBean(AccountService.class, "accountService");
            //执行方法
            accountService.saveAccount();
        }
    }

运行结果:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2NDk2NA_size_16_color_FFFFFF_t_70 1]  
这里自己测试一下就可以明白AOP的作用以及使用方式了。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2NDk2NA_size_16_color_FFFFFF_t_70]: /images/1615558803854.jpg
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2NDk2NA_size_16_color_FFFFFF_t_70 1]: /images/1615558771679.png