三(二)、AOP配置

一、AOP的配置（注解）

步骤一、导入jar包：

处理那5个jar包之外，还需要导入：

• aopalliance
• aspectjweaver
• spring-aop
• spring-aspects

步骤二、在配置文件中加入aop、context的命名空间

步骤三分为基于注解方式配置AOP和xml方式配置aop;

基于注解方式（本篇）

①在配置文件中加入如下配置；

<!-- 使AspjectJ注释起作用，自动匹配的类生成代理对象 -->
 <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

②把横切关注点的代码都加入到切面的类中，

③切面首先是一个IOC中的bean，即加@Conponent注释

④切面需要加入@Aspect注释

⑤在类中声明各种通知：

• @Before：前置通知，在方法执行前执行；
• @After：后置通知，在方法执行后执行

• @AfterRunning：返回通知，在方法返回结果后执行

• @Afterthrowing：异常通知之后

• @Around：环绕通知

回到顶部

二、AOP常用通知：

• @Before：前置通知，在方法执行前执行；

    @Before("execution(public int lixiuming.spring.aop.impl.ArithmeticCaculator.*(int, int) )") // 作用于接口中的所有方法
    public void beforeMethod(JoinPoint joinPoint) {
        String method = joinPoint.getSignature().getName();// 方法的签名
        List<Object> args = Arrays.asList(joinPoint.getArgs());// 方法的参数
        System.out.println("the method " + method + " begins with" + args);
    }

• @After：后置通知，在方法执行后执行,在后置通知中，不能访问目标方法执行的结果,如果有异常也执行，通知在异常之前；

    @After("execution(public int lixiuming.spring.aop.impl.ArithmeticCaculator.*(int, int) )")
    public void afterMethod(JoinPoint joinPoint) {
        String method = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("the method " + method + " is end to " + args);
    }

• @AfterRunning：返回通知，在方法返回结果后执行，可以访问到返回值；

    @AfterReturning(value = "execution(public int lixiuming.spring.aop.impl.ArithmeticCaculator.add(int, int) )", returning = "result")
    public void afterReturn(JoinPoint joinPoint, Object result) {
        String method = joinPoint.getSignature().getName();
        System.out.println("the method " + method + " is end with " + result);
    }

• @Afterthrowing：异常通知之后，可以访问到异常，并且可以指定异常类型，只有符合该异常类型时才被执行

    @AfterThrowing(value = "execution(public int lixiuming.spring.aop.impl.ArithmeticCaculator.add(int, int) )", throwing = "ex")
    public void afterThrowing(JoinPoint joinPoint, Object ex) {
        String method = joinPoint.getSignature().getName();
        System.out.println("the method " + method + " occured exception: " + ex);
    }

 

• @Around：环绕通知；

  环绕通知类似动态代理的全过程：ProceedingJoinPoint类型的参数可以决定是否执行日志方法 且必须有返回值，返回值是目标方法的返回值

    @Around("execution(public int lixiuming.spring.aop.impl.ArithmeticCaculator.add(int, int) )")
    public Object aroundMethod(ProceedingJoinPoint point) {
        Object result = null;
        String method = point.getSignature().getName();
        // 执行目标方法
        try {
            // 前置通知
            System.out.println("the method " + method + " is begin with " + Arrays.asList(point.getArgs()));
            result = point.proceed();
            // 返回通知
            System.out.println("the method " + method + " is end to " + result);
        } catch (Throwable e) {
            // TODO Auto-generated catch block
            System.out.println("the method " + method + " occured exception: " + e);
            throw new RuntimeException(e);
        }
        System.out.println("the method " + method + " ends");

        return 100;
    }

 

回到顶部

三、切点表达式

表达式

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?)

这里问号表示当前项可以有也可以没有，其中各项的语义如下：

• modifiers-pattern：方法的可见性，如public，protected；
• ret-type-pattern：方法的返回值类型，如int，void等；
• declaring-type-pattern：方法所在类的全路径名，如com.spring.Aspect；
• name-pattern：方法名类型，如buisinessService()；
• param-pattern：方法的参数类型，如java.lang.String；
• throws-pattern：方法抛出的异常类型，如java.lang.Exception；

举例说明：

//    @Before("execution(public int lixiuming.spring.aop.impl.ArithmeticCaculator.add(int, int) )")// 作用于接口中的add方法
//     @Before("execution(public int lixiuming.spring.aop.impl.ArithmeticCaculator.*(int, int) )") // 作用于接口中的所有方法 （所有方法是指public int类型的）
//    @Before("execution(* ixiuming.spring.aop.impl.ArithmeticCaculator.*(int, int) )") // 第一个* 表示：任意修饰符和任意返回值，第二个*代码任意参数为（int,int）方法
//    @Before("execution( public * ixiuming.spring.aop.impl.ArithmeticCaculator.*(..) )") // 第二个*代表任意方法；..代表任意个数的参数，即所有公有方法
//    @Before("execution( public double ixiuming.spring.aop.impl.ArithmeticCaculator.*(double.) )") // 返回所有double的第一个参数为double的public的方法

 @Pointcut

使用@Pointcut 来声明切入点表达式，后面的其他通知直接使用方法名来引用当前的切入点表达式；如下代码，前置通知使用了方法名为declareJoinPointExpress来引用切点表达式；

这样做的好处是，可以统一管理切点表达式；

    @Pointcut("execution(public int lixiuming.spring.aop.impl.ArithmeticCaculator.*(..))")
    public void declareJoinPointExpress() {

    }

//声明该方法是一个前置通知：在目标方法之前执行
    @Before("declareJoinPointExpress()")
    public void beforeMethod(JoinPoint joinPoint) {
        String method = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("the method " + method + " begins with" + args);
    }

 

回到顶部

四、实例说明AOP配置：

以实现三(一)中的 为ArithmeticCaculator添加 各方法 执行前 和计算结果后的日志的AOP方案为实例；

步骤一、为ArithmeticCaculatorImpl类添加@Component 注解 来表示 该组件需要被sping容器管理

package lixiuming.spring.aop.impl;

import org.springframework.stereotype.Component;

@Component
public class ArithmeticCaculatorImpl2 implements ArithmeticCaculator {

    @Override
    public int add(int i, int j) {
        int result = i+j;
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result = i-j;
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result = i*j;
        return result;
    }

    @Override
    public int div(int i, int j) {
        int result = i/j;
        return result;
    }

}

步骤二、需要添加一个切面：

关于切面声明的说明：

• 切面需要放置在spring 容器中；所以首先需要一个@Component注解
• 声明一个切面用注解 @Aspect；

为实现上述实例，需要添加一个前置通知和后置通知；前置通知即，在目标方法执行之前执行；后置通知，即在目标方法执行后执行，无论是否发生异常。

package lixiuming.spring.aop.impl;

import java.util.Arrays;
import java.util.List;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

//把这个类声明为一个切面，需要把该类放入到IOC容器中，再声明为一个切面
@Aspect
@Component
public class LoggingAspect {
    // 声明该方法是一个前置通知：在目标方法之前执行
    @Before("execution(public int lixiuming.spring.aop.impl.ArithmeticCaculator.*(int, int) )") // 作用于接口中的所有方法
    public void beforeMethod(JoinPoint joinPoint) {
        String method = joinPoint.getSignature().getName();// 方法的签名
        List<Object> args = Arrays.asList(joinPoint.getArgs());// 方法的参数
        System.out.println("the method " + method + " begins with" + args);
    }

    // 声明后置通知：在目标方法执行后（无论是否发生异常）执行的通知
    // 在后置通知中，不能访问目标方法执行的结果，需要在返回通知里面访问
    @After("execution(public int lixiuming.spring.aop.impl.ArithmeticCaculator.*(int, int) )")
    public void afterMethod(JoinPoint joinPoint) {
        String method = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("the method " + method + " is end to " + args);
    }

}

 步骤三、配置文件：引入了context和aop的命名空间

<?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"
    xmlns:context="http://www.springframework.org/schema/context"
    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-4.0.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">

<context:component-scan base-package="lixiuming.spring.aop.impl"/>
<!-- 使AspjectJ注释起作用，自动匹配的类生成代理对象 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

使用main方法测试：

public static void main(String[] args) {
        ApplicationContext cxt = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        ArithmeticCaculator arithmeticCaculator = cxt.getBean(ArithmeticCaculator.class);

        int result = arithmeticCaculator.add(1, 2);
        System.out.println("-->" + result);

        int result1 = arithmeticCaculator.div(4, 2);
        System.out.println("-->" + result1);

        int result2 = arithmeticCaculator.mul(4, 2);
        System.out.println("-->" + result2);

        int result3 = arithmeticCaculator.sub(4, 2);
        System.out.println("-->" + result3);

    }

测试运行结果：

the method add begins with[1, 2]

the method add is end to [1, 2]

-->3

the method div begins with[4, 2]

the method div is end to [4, 2]

-->2

the method mul begins with[4, 2]

the method mul is end to [4, 2]

-->8

the method sub begins with[4, 2]

the method sub is end to [4, 2]

-->2

步骤二中除了使用前置和后置通知，还可以使用环绕通知来实现上述功能；

代码如下：

package lixiuming.spring.aop.impl;

import java.util.Arrays;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

//把这个类声明为一个切面，需要把该类放入到IOC容器中
@Aspect
@Component
public class LoggingAspect {

    // 定义一个方法，用于声明切入点表达式，一般该方法中不需要其他的代码
    // 使用@Pointcut 来声明切入点表达式，
    // 后面的其他通知直接使用方法名来引用当前的切入点表达式
    @Pointcut("execution(public int lixiuming.spring.aop.impl.ArithmeticCaculator.*(..))")
    public void declareJoinPointExpress() {

    }

    /**
     * 环绕通知需要携带ProceedingJoinPoint类型的参数
     * 环绕通知类似动态代理的全过程：ProceedingJoinPoint类型的参数可以决定是否执行日志方法 且必须有返回值，返回值是目标方法的返回值
     */
    @Around("declareJoinPointExpress()")
    public Object aroundMethod(ProceedingJoinPoint point) {
        Object result = null;
        String method = point.getSignature().getName();
        // 执行目标方法
        try {
            // 前置通知
            System.out.println("the method " + method + " is begin with " + Arrays.asList(point.getArgs()));
            result = point.proceed();
            // 后置通知
            System.out.println("the method " + method + " is end to " + Arrays.asList(point.getArgs()));
        } catch (Throwable e) {
            // TODO Auto-generated catch block
            System.out.println("the method " + method + " occured exception: " + e);
            throw new RuntimeException(e);
        }

        return result;
    }
}

回到顶部

 五、切面的优先级

使用@Order(index)指定执行顺序的优先级，index为数字，index越小，优先级越高；@Order位置为放置在@Aspect前面；代码如下：

@Order(1)//执行顺序的优先级
@Aspect
@Component
//验证通知
public class VlidationAspect {
    @Before("LoggingAspect.declareJoinPointExpress()")
    public void validationArgs(JoinPoint jointPoint){
        System.out.println("-->validation:"+Arrays.asList(jointPoint.getArgs()));
    }
    

}

回到顶部

六、xml方式配置AOP

ArithmeticCaculator 不变；ArithmeticCaculatorImpl移除@Component；

LoggingAspect：

package lixiuming.spring.aop.impl2;

import java.util.Arrays;
import java.util.List;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

public class LoggingAspect {

    public void beforeMethod(JoinPoint joinPoint){
        String method = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());    
        System.out.println("the method "+method+" begins with"+args);
    }

    public void afterMethod(JoinPoint joinPoint){
        String method =  joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("the method "+method+" is end to "+args);
    }
    
    /**
     *在方法正常结束后执行的代码
     *返回通知是可以访问到方法的返回值
     */
    public void afterReturn(JoinPoint joinPoint,Object result){
        String method = joinPoint.getSignature().getName();
        System.out.println("the method "+method+" is end with " +result);
    }

    public void afterThrowing(JoinPoint joinPoint,Object ex){
        String method = joinPoint.getSignature().getName();
        System.out.println("the method "+method+" occured exception: " + ex);
    }
    
    public Object aroundMethod(ProceedingJoinPoint point){
        Object result = null;
        String method = point.getSignature().getName();
        //执行目标方法
        try {
            //前置通知
            System.out.println("the method "+method+" is begin with "+Arrays.asList(point.getArgs()));
            result = point.proceed();
            //返回通知
            System.out.println("the method "+method+" is end to "+ result);
        } catch (Throwable e) {
            // TODO Auto-generated catch block
            System.out.println("the method "+method+" occured exception: " + e);
            throw new RuntimeException(e);
        }
        System.out.println("the method "+method+" ends");

        return 100;
    }
}

VlidationAspect：

package lixiuming.spring.aop.impl2;

import java.util.Arrays;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
//验证通知
public class VlidationAspect {
    public void validationArgs(JoinPoint jointPoint){
        System.out.println("-->validation:"+Arrays.asList(jointPoint.getArgs()));
    }
    

}

配置文件：

<?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-4.0.xsd">

<!-- 配置bean -->
<bean id="aop" class="lixiuming.spring.aop.impl2.ArithmeticCaculatorImpl2"></bean>
<!-- 配置切面的bean -->
<bean id="LoggingAspect" class="lixiuming.spring.aop.impl2.LoggingAspect"></bean>
<bean id="VlidationAspect" class="lixiuming.spring.aop.impl2.VlidationAspect"></bean>

<!-- 配置AOP -->
<aop:config>
    <!-- 配置切面表达式 -->
    <aop:pointcut expression="execution(* lixiuming.spring.aop.impl2.ArithmeticCaculator.*(int,int))" id="pointcut"/>
    <!-- 配置切面及通知 -->
    <aop:aspect ref="LoggingAspect" order="2">
        <aop:before method="beforeMethod" pointcut-ref="pointcut"/>
        <aop:after method="afterMethod" pointcut-ref="pointcut"/>
        <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="ex"/>
        <aop:after-returning method="afterReturn" pointcut-ref="pointcut" returning="result"/>
        <aop:around method="aroundMethod" pointcut-ref="pointcut"/>
     </aop:aspect>
     
     <aop:aspect ref="VlidationAspect" order="1">
         <aop:before method="validationArgs" pointcut-ref="pointcut"/>
      </aop:aspect>
</aop:config>
</beans>