java的aop

需要引入pom 的依赖

			org.aspectj
			aspectjweaver
			true
		

spring 的切面编程有两种：spring AOP 和 AspectJ

在spring2以后就支持AspectJ。

aspect切面执行顺序:

1. 前置通知 before
2. 环绕通知 around
3. 后置通知 after-retruning
4. 异常通知 after-throwing
5. 最终通知 after

前置通知：模拟执行权限检查…
目标类是：com.xyj.bean.UserDaoImpl@72057ecf
被植入增强处理的目标方法为：login
环绕开始：执行目标方法之前，模拟开启事务…
执行-----userDaoImpl->login…
最终通知：模拟方法结束后释放资源…
环绕结束：执行目标方法之后，模拟关闭事务…
后置通知：模拟记录日志…
被植入增强处理的目标方法为：login

两种使用方式：

1. xml配置

   创建的applicationconfig.xml 需要引入：xmlns:aop="http://www.springframework.org/schema/aop";

   http://www.springframework.org/schema/aop
   http://www.springframework.org/schema/aop/spring-aop.xsd

package com.xyj.bean;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;


public class AspectDemo {
    //前置通知 before
    public void myBefore(JoinPoint joinPoint){
        System.out.println("前置通知：模拟执行权限检查....");
        System.out.println("目标类是："+joinPoint.getTarget());
        System.out.println("被植入增强处理的目标方法为："+joinPoint.getSignature().getName());
    }
    //后置通知 afterReturning
    public void myAfterReturning(JoinPoint joinPoint){
        System.out.println("后置通知：模拟记录日志...");
        System.out.println("被植入增强处理的目标方法为："+joinPoint.getSignature().getName());
    }

    

    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        //1、开始
        System.out.println("环绕开始：执行目标方法之前，模拟开启事务....");
        //2、执行当前目标方法
        Object obj = proceedingJoinPoint.proceed();
        //3、结束
        System.out.println("环绕结束：执行目标方法之后，模拟关闭事务....");
        return obj;
    }
    //异常通知 afterThrowing
    public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
        System.out.println("异常通知----：出错了，错误是["+e.getMessage()+"]");
    }
    //最终通知 after()
    public void myAfter(){
        System.out.println("最终通知：模拟方法结束后释放资源...");
    }
}

2. 注解方式

代码：

package com.xyj.bean;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;


@Aspect
@Component("aspectDemo2")
public class AspectDemo2 {
    //定义切入点表达式
    @Pointcut("execution(* com.xyj.bean.*.*(..))")
    //切入点方法
    public void myPointCut(){
        System.out.println("----myPointCut----");
    }
    //前置通知 before
    @Before("myPointCut()")
    public void myBefore(JoinPoint joinPoint){
        System.out.println("前置通知：模拟执行权限检查....");
        System.out.print("目标类是："+joinPoint.getTarget());
        System.out.println("被植入增强处理的目标方法为："+joinPoint.getSignature().getName());
    }
    //后置通知 afterReturning
    @AfterReturning("myPointCut()")
    public void myAfterReturning(JoinPoint joinPoint){
        System.out.print("后置通知：模拟记录日志...");
        System.out.println("被植入增强处理的目标方法为："+joinPoint.getSignature().getName());
    }

    
    @Around("myPointCut()")
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        //1、开始
        System.out.println("环绕开始：执行目标方法之前，模拟开启事务....");
        //2、执行当前目标方法
        Object obj = proceedingJoinPoint.proceed();
        //3、结束
        System.out.println("环绕结束：执行目标方法之后，模拟关闭事务....");
        return obj;
    }
    //异常通知 afterThrowing
    @AfterThrowing(value = "myPointCut()",throwing = "e")
    public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
        System.out.println("异常通知----：出错了，错误是["+e.getMessage()+"]");
    }
    //最终通知 after()
    @After("myPointCut()")
    public void myAfter(){
        System.out.println("最终通知：模拟方法结束后释放资源...");
    }
}