简单的aop实现日志打印（切入点表达式）

Spring中可以使用注解或XML文件配置的方式实现AOP。
1、导入jar包

• com.springsource.net.sf.cglib -2.2.0.jar
• com.springsource.org.aopalliance-1.0.0 .jar
• com.springsource.org.aspectj.weaver-1.6.8 .RELEASE.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

aspectaop相关jar包 ---> 资源目录--->jar包资源--->AOP日志打印相关jar包（切面类） 

Spring相关jar包 ---> 资源目录--->jar包资源--->Spring相关jar包 

2、开启基于注解的AOP功能

在Spring的配置文件中加入

<context:component-scan base-package="com.bwlu.aop"></context:component-scan>
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

3、声明一个切面类，并把这个切面类加入到IOC容器中

@Component//加入IOC容器
@Aspect//表示这是一个切面类
public class LogAspect{
    //value中为切入点表达式
    @Before(value="execution(public void com.bwlu.common.MathCalculatorImpl.*(..))")//前置通知
    public void showBeginLog(){
        System.out.println("AOP日志开始");
    }
    @After(value="execution(public void com.bwlu.common.MathCalculatorImpl.*(..))")//后置通知
    public void showReturnLog(){
        System.out.println("AOP方法结束");
    }
    @AfterThrowing(value="execution(public void com.bwlu.common.MathCalculatorImpl.*(..))")//异常通知
    public void showExceptionLog(){
        System.out.println("AOP方法异常");
    }
    @AfterReturning(value="execution(public void com.bwlu.common.MathCalculatorImpl.*(..))")//返回通知
    public void showAfterLog(){
        System.out.println("AOP方法最终返回");
    }
}

4、被代理的对象也需要加入IOC容器

@Component
public class MathCalculator {
    public void add(int i, int j) {
        int result=i+j;
        System.out.println("目标方法add(int)执行了");
    }
    public void sub(int i, int j) {
        int result=i-j;
        System.out.println("目标方法sub执行了");
    }
    public void mult(int i, int j) {
        int result=i*j;
        System.out.println("目标方法mult执行了");
    }
    public void div(int i, int j) {
        int result=i/j;
        System.out.println("目标方法div执行了");
    }
}

5、新建Junit测试类进行测试

ApplicationContext ioc=new ClassPathXmlApplicationContext("applicationContext.xml");
@Test
public void test() {
    //需要进行强转，如果该类实现了一个接口（并且切入点表达式指向这个类），那么获取到的将不是该类的对象，需要强转
    //MathCalculatorImpl实现了MathCalculator接口，则
    //MathCalculator bean = (MathCalculator)ioc.getBean("mathCalculatorImpl");
    MathCalculator bean = (MathCalculator)ioc.getBean("mathCalculator");
    bean.add(10, 5);
    System.out.println();
    bean.add(10.0, 5);
    System.out.println();
    bean.sub(10, 5);
    System.out.println();
    bean.mult(10, 5);
    System.out.println();
    bean.div(10, 0);
}

6、切入点表达式

• 切入点表达式的语法格式

execution([权限修饰符] [返回值类型] [简单类名/全类名] [方法名]([参数列表]))

• 切入点表达式支持通配符
• 两种切入表达式
  • 最详细的切入点表达式：

 

execution(public void com.bwlu.aop.MathCalculator.add(int, int))

 

• • 最模糊的切入点表达式：

execution (* *.*(..))

execution(public void com.bwlu.aop.MathCalculator.add(int, int))：只有add方法加入了4个通知，

execution(public void com.bwlu.aop.MathCalculator.*(int, int))：任意方法，参数为int，int

execution(public void com.bwlu.aop.MathCalculator.*(..))：MathCalculator中的任意方法,任意参数列表

execution(public * com.bwlu.aop.MathCalculator.*(..))：MathCalculator中的任意方法,任意参数列表，任意返回值

execution( * com.bwlu.aop.MathCalculator.*(..))：MathCalculator中的任意方法,任意参数列表，任意返回值，任意访问修饰符

execution (* *.*(..))：任意匹配

需要注意的是：权限是不支持写通配符的，当然你可以写一个*表示所有权限所有返回值！

7、优化

用@PointCut注解统一声明,然后在其它通知中引用该统一声明即可！

@Component
@Aspect
public class LogAspect{
    @Pointcut(value="execution(* *.*(..))")
    public void showLog(){}
    @Before(value="showLog()")
    public void showBeginLog(){
        System.out.println("AOP日志开始");
    }
    @After(value="showLog()")
    public void showReturnLog(){
        System.out.println("AOP方法结束");
    }
    @AfterThrowing(value="showLog()")
    public void showExceptionLog(){
        System.out.println("AOP方法异常");
    }
    @AfterReturning(value="showLog()")
    public void showAfterLog(){
        System.out.println("AOP方法最终返回");
    }
}

8、通知方法的细节

（1）在通知中获取目标方法的方法名和参数列表

• 在通知方法中声明一个JoinPoint类型的形参
• 调用JoinPoint对象的getSignature()方法获取目标方法的签名
• 调用JoinPoint对象的getArgs()方法获取目标方法的实际参数列表

（2）在返回通知中获取方法的返回值

• 在@AfterReturning注解中添加returning属性：@AfterReturning (value="showLog()", returning= "result")
• 在返回通知的通知方法中声明一个形参，形参名和returning属性的值一致：showReturnLog(JoinPoint joinPoint, Object result)

（3）在异常通知中获取异常对象

• 在@ AfterThrowing注解中添加throwing属性：@AfterThrowing (value="showLog()",throwing= "throwable" )
• 在异常通知的通知方法中声明一个形参，形参名和throwing属性值一致：showExceptinLog(JoinPoint joinPoint, Throwable throwable)

@Component
@Aspect
public class LogAspect{
    @Pointcut(value="execution(* *.*(..))")
    public void showLog(){}
    @Before(value="showLog()")
    public void showBeginLog(JoinPoint jPoint){
        Object[] args = jPoint.getArgs();
        List<Object> asList = Arrays.asList(args);
        Signature signature = jPoint.getSignature();
        String name = signature.getName();
        System.out.println("AOP日志开始");
        System.out.println("目标方法名："+name+"，参数列表："+asList);
    }
    @After(value="showLog()")
    public void showReturnLog(){
        System.out.println("AOP方法结束");
    }
    @AfterThrowing(value="showLog()",throwing="ex")
    public void showExceptionLog(Exception ex){
        System.out.println("AOP方法异常");
        System.out.println("异常信息:"+ex.getMessage());
    }
    @AfterReturning(value="showLog()",returning="result")
    public void showAfterLog(Object result){
        System.out.println("方法返回值:"+result);
        System.out.println("AOP方法最终返回");
    }
}

9、环绕通知@Around

环绕通知需要在方法的参数中指定JoinPoint的子接口类型ProceedingJoinPoint为参数：

public void around(ProceedingJoinPoint joinPoint){}

环绕通知能够替代其他4个通知。
注意:@Around修饰的方法一定要将方法的返回值返回！本身相当于代理！

@Component
@Aspect
public class LogAspect{
    @Around(value="execution(* *.*(..))")
    public Object showLog(ProceedingJoinPoint point){
        Object[] args = point.getArgs();
        List<Object> asList = Arrays.asList(args);
        Signature signature = point.getSignature();
        String name = signature.getName();
        Object result = null;
        try {
            try {
                //目标方法之前要执行的操作,相当于@before
                System.out.println("[环绕日志]"+name+"开始了，参数为:"+asList);
                //调用目标方法
                result = point.proceed(args);
            } finally {
                //方法最终结束时执行的操作，相当于@after
                System.out.println("[环绕日志]"+name+"结束了!");
            }
            //目标方法正常执行之后的操作，相当于@AfterReturning
            System.out.println("[环绕日志]"+name+"返回了，返回值为:"+result);
        } catch (Throwable e) {
            //目标方法抛出异常信息之后的操作，相当于@AfterThrowing
            System.out.println("[环绕日志]"+name+"出异常了，异常对象为:"+e);
            throw new RuntimeException(e.getMessage());
        }
        return result;
    }
}

 10、切面的优先级

对于同一个代理对象，可以同时有多个切面共同对它进行代理。
可以在切面类上通过@Order (value=50)注解来进行设置，值越小优先级越高!

@Aspect

@Component

@Order(value=40)

public class LogAspect {}