Java-Spring_AOP_单元测试

一、AOP 面向切面编程

1.1 作用以及优势

1. 作用：在运行期间，不修改源码对已有方法进行增强
2. 优势：

• 减少代码重复率；
• 提高开发效率；
• 维护方便；

  1.2 需要jar包

  

1.3 AOP的相关性质

1. AOP底层通过代理模式实现不修改代码而增强功能。
2. 连接点：被代理的对象中的所有方法/函数（可以被增强的点）都是连接点
3. 切入点：需要/可以被增强的点既是连接点又是切入点。
4. Advice（通知、增强）

• 前置、后置、环绕、通知，增强 目标方法的内容

1. Target（目标对象）
2. Weaving织入：把增强应用到目标对象来创建新的代理对象的过程。
3. Spring通过动态代理的方式进行织入。
4. Proxy（代理）：一个类被AOP织入增强后，就产生了结果代理类。
5. Aspect（切面） ：切入点（要增强的方法）和通知（怎么增强的具体实现）之间的关系称之为切面。

1.4 基于XML的AOP配置

1.4.1 分类

1. aop:conflg: 作用于声明开始aop的配置
2. aop;aspect: 作用:配置切面
3. aop:pointcut: 作用:配置切入点表达式
4. aop:before: 作用:用于配置前置通知
5. aop: after-returnlng:
6. aop:aftre_throwing: 用于配置异常通知
7. aop:after: 用于配置最终通知
8. aop:around : 用于配置环绕通知

1.4.2 测试案例

流程：生成通知类、目标类、配置通知类目标类。

1. 通知类，进行配置一些用于增强的通知方法

   public class AopLoggerManager {
    // 前置通知
    public void beforeAdvice(){
        System.out.println("前置通知开始记录日志了---------");
    }
    //后置通知
    public void afterAdvice(){
        System.out.println("后置通知开始记录日志了---------");
    }
    //异常通知
    public void exceptionAdvice(){
        System.out.println("异常通知开始记录日志了---------");
    }
    //最终通知
    public void endAdvice(){
        System.out.println("最终通知开始记录日志了---------");
    }
   }

2. 生成核心类

   public class modulet1 implements moduleimp{
   public void getmethon1(){
       System.out.println("核心业务1");
   }
   public void getmethon2(){
       System.out.println("核心业务2");
   }
   public void getmethon3(){
       System.out.println("核心业务3");
   }
   }

3. 配置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/beans
                                                     http://www.springframework.org/schema/beans/spring-beans.xsd
                                                     http://www.springframework.org/schema/context
                                                     http://www.springframework.org/schema/context/spring-context.xsd
                                                     http://www.springframework.org/schema/aop
                                                     http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--配置通知类-->
    <bean id="aopLogger" class="com.eagleslab.springaop.logger.AopLoggerManager"></bean>
    <!--配置目标类-->
    <bean id="aopModule" class="com.eagleslab.springaop.module.ModuleImpl"></bean>
    <!--开始配置aop-->
    <aop:config>
        <!--配置切面(切入点和通知之间的关系)-->
        <aop:aspect id = "aspect" ref="aopLogger">
            <!--声明一个切入点表达式(声明/定位所有需要被增强方法的位置)-->
            <aop:pointcut id="pt01" expression="execution(* com.eagleslab.springaop.module.Module.*(..))"/>
            <!--开始配置通知-->
            <!--前置通知-->
            <aop:before method="beforeAdvice" pointcut-ref="pt01"></aop:before>
            <!--后置通知-->
            <aop:after-returning method="afterAdvice" pointcut-ref="pt01"></aop:after-returning>
            <!--异常通知-->
            <aop:after-throwing method="exceptionAdvice" pointcut-ref="pt01"></aop:after-throwing>
            <!--最终通知-->
            <aop:after method="endAdvice" pointcut-ref="pt01"></aop:after>
        </aop:aspect>
    </aop:config>
   </beans>

环绕通知：可以替代所有通知的功能，主要是它可以在器对于的通知类中的对应方法中实现很多功能。

//环绕通知
//注意该通知方法需要传入一个参数。
public void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint){
    //获取调用目标方法的参数
    Object[] args = proceedingJoinPoint.getArgs();
    try {
        System.out.println("前置通知开始记录日志----");
        //调用目标方法
        proceedingJoinPoint.proceed(args);
        System.out.println("后置通知开始记录日志----");
    } catch (Throwable throwable) {
        System.out.println("异常通知开始记录日志----");
        throwable.printStackTrace();
    }finally {
        System.out.println("最终通知开始记录日志---");
    }
    }

1.4.5 基于注解的AOP配置

流程：开启扫描包——>开启AOP注解的支持——>添加注解

@Component("aopLogger")
// 用于声明当前类为通知类
@Aspect
public class AopLoggerManager {
    //声明一个切入点表达式
    @Pointcut("execution(* com.eagleslab.springaop.module.Module.*(..))")
    public void pt01(){};
    //注意书写格式：
    //前置通知
    @AfterReturning("pt01()")
    public void beforeAdvice(){
        System.out.println("前置通知开始记录日志了---------");
    }
     //后置通知
    @Before("pt01()")
    public void afterAdvice(){
        System.out.println("后置通知开始记录日志了---------");
    }
     //异常通知
    @AfterThrowing("pt01()")
    public void exceptionAdvice(){
        System.out.println("异常通知开始记录日志了---------");
    }
    //最终通知
    @After("pt01()")
    public void endAdvice(){
        System.out.println("最终通知开始记录日志了---------");
    }

@Component(“aopModule”)

二、Spring单元测

2.1 需要jar包

2.2 实际测试

通过spring的测试模块整合junit在程序运行期间获取核心容器对象。

//@RunWith 用来替换运行器，替换为spring提供的运行器。
@RunWith(SpringJUnit4ClassRunner.class) 
//指定核心配置文件的位置。
@ContextConfiguration(locations = "classpath:xml/beans.xml")
public class SpringAopDemo01 {
//取出核心配置对象
    @Autowired
    private ApplicationContext applicationContext;
    @Test
    public void test01(){
        Object emp = applicationContext.getBean("emp");
        System.out.println(emp);
    }
}

运行结果