AOP切面通知

需要用的基本的jar包：

aopalliance-1.0.jar
aspectj-1.6.8.jar
aspectjweaver-1.6.8.jar
commons-logging-1.1.3.jar
spring-aop-4.0.0.RELEASE.jar
spring-aspects-4.0.0.RELEASE.jar
spring-beans-4.0.0.RELEASE.jar
spring-context-4.0.0.RELEASE.jar
spring-core-4.0.0.RELEASE.jar
spring-expression-4.0.0.RELEASE.jar

1：基于注解的日志通知和验证通知：

定义接口：

package com.yinfu.spring.aop.impl;

public interface ArithmeticCalculator {

    public int add(int i,int j);
    public int sub(int i,int j);
    public int mul(int i,int j);
    public int div(int i,int j);
}

定义实现类：

package com.yinfu.spring.aop.impl;

import org.springframework.stereotype.Component;

@Component("arithmeticCalculator")
public class ArithmeticCalculatorImpl implements ArithmeticCalculator {

    @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的配置文件：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:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

<!--     <bean id="helloWorld" class="com.yinfu.spring.beans.HelloWorld">
        <property name="name" value="fuck"></property>
    </bean> -->
    <!-- 配置自动扫描包 -->
    <context:component-scan base-package="com.yinfu.spring.aop.impl"></context:component-scan>
    
    <!-- 使AspectJ注解起作用:自动为匹配的类生成代理对象 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    
</beans>

定义切面类：

package com.yinfu.spring.aop.impl;

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.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * 把此类声明为一个切面
 * 首相把该类放到IOC容器中，然后在声明为切面
 * @Aspect声明此类是一个切面
 * @Order声明切面的优先级,值越小优先级越高
 * @author lusong
 *
 */
@Order(1)
@Aspect
@Component 
public class LoggingAspect {
    
    
    //定义一个方法用于声明切入点表达式，因为表达式都相同，可以进行封装不过方法内不需要添加其他代码
    //使用@Pointcut声明切入点表达式
    /**
     * 此时下面的通知注解都可以将value值写成此方法名 如：@Before("declareJoinPointException()")即可
     */
    @Pointcut("execution(public int com.yinfu.spring.aop.impl.ArithmeticCalculatorImpl.*(int, int))")
    public void declareJoinPointException(){}

    //1.前置通知：声明该方法是一个前置方法，在指定目标方法之前执行
    /**
     * before中写的是aspectj的表达式
     * public int可以用*代替，代表：任意修饰符和任意返回值
     * com.yinfu.spring.aop.impl代表包名
     * ArithmeticCalculatorImpl代表类名，可以用*代替，代表该包下的任意类
     * add代表方法名，可以用*好代替，代表该类下的任意方法
     * (int,int)参数类型，可以用..代替
     * @param joinPoint 链接点利用此链接点可以得到代理对象中的方法名称和参数等细节
     */
    @Before("execution(public int com.yinfu.spring.aop.impl.ArithmeticCalculatorImpl.*(int, int))")
    public void beforeMethod(JoinPoint joinPoint ){
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("this method "+methodName+" begin"+args);
    }
    //2.后置通知：在目标方法执行后(无论是否发生异常)，执行的通知
    //后置通知中还不能访问目标方法执行的结果
    @After("execution(public int com.yinfu.spring.aop.impl.ArithmeticCalculatorImpl.*(int, int))")
    public void afterMethod(JoinPoint joinPoint ){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("this method "+methodName+" end");
    }
    
    //3返回通知：在目标方法正常执行后，执行的通知
    //返回通知是可以访问到方法的返回值的
    @AfterReturning(value="execution(public int com.yinfu.spring.aop.impl.ArithmeticCalculatorImpl.*(int, int))",returning="result")
    public void afterReturning(JoinPoint joinPoint ,Object result){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("this method "+methodName+" end with "+result);
    }
    
    //4.异常通知:在目标方法出现异常时会执行代码
    //可以访问异常对象，指定异常类型，当出现指定的异常时才会执行代码
    //也就是Exception可以换成NullPoinException异常，当出现空指针异常的时候才会执行异常通知，其他异常不执行
    @AfterThrowing(value="execution(public int com.yinfu.spring.aop.impl.ArithmeticCalculatorImpl.*(int, int))",throwing="ex")
    public void afterThrowing(JoinPoint joinPoint ,Exception ex){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("this method "+methodName+" throw with "+ex);
    }
    
    //5.环绕通知
    //环绕通知携带ProceedingJoinPoint类型的参数
    //环绕通知类似于动态代理的全过程，ProceedingJoinPoint类型的参数可以决定是否执行目标方法
    //环绕通知必须有返回值，返回值即为目标方法的返回值
    @Around("execution(public int com.yinfu.spring.aop.impl.ArithmeticCalculatorImpl.*(int, int))")
    public Object aroundMethod(ProceedingJoinPoint pjp){
        Object result = null;
        String methodName = pjp.getSignature().getName();
        Object[] args = pjp.getArgs();
        //执行目标方法
        try {
            //前置通知
            System.out.println("this aroundMethod "+methodName+" begin with "+Arrays.asList(args));
            result = pjp.proceed();
            //返回通知
            System.out.println("this aroundMethod "+methodName+" resutn with "+result);
        } catch (Throwable e) {
            //异常通知
            System.out.println("this aroundMethod "+methodName+" throw with "+e);
        }
        //后置通知
        System.out.println("this aroundMethod "+methodName+" end ");
        return result;
    }
    
    
}

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

    <!-- 配置方法对象bean -->
    <bean id="arithmeticCalculator" class="com.yinfu.spring.aop.impl.ArithmeticCalculatorImpl"></bean>
    <!-- 配置切面bean -->
    <bean id="loggingAspect" class="com.yinfu.spring.aop.impl.LoggingAspect"></bean>
    <!-- 配置AOP切面 -->
    <aop:config>
        <!-- 配置切点表达式 -->
        <aop:pointcut expression="execution(public int com.yinfu.spring.aop.impl.ArithmeticCalculatorImpl.*(int, int))" id="pointcut"/>
        <!-- 配置切点及通知 -->
        <aop:aspect ref="loggingAspect" order="1">
            <aop:before method="beforeMethod" pointcut-ref="pointcut"/>
            <aop:after method="afterMethod" pointcut-ref="pointcut"/>
            <!-- 这里的returning值必须与切面类中定义的值是一样的 -->
            <aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="result"/>
            <!-- 这里的throwing值必须与切面类中定义的值是一样的 -->
            <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="ex"/>
            <aop:around method="aroundMethod" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>
    
</beans>