SpringBoot的AOP实战

excution(public * *(...参数...)) //任意声明为public权限的方法
excution(public * set*(...参数...)) //任意一个以set开始的方法
excution(* com.java.* *(...参数...)) //com.java包中的所有类
    
execution(* com.xyz.service..*.*(..))
//指定切入点为：定义在 service 包或者子包里的任意类的任意方法。“..”出现在类名中时，后面必须跟“*”，表示包、子包下的所有类。
execution(* *..service.*.*(..))
//指定所有包下的 serivce 子包下所有类（接口）中所有方法为切入点
execution(* *.service.*.*(..))
//指定只有一级包下的 serivce 子包下所有类（接口）中所有方法为切入点
execution(* *.ISomeService.*(..))
//指定只有一级包下的 ISomeSerivce 接口中所有方法为切入点
execution(* *..ISomeService.*(..))
//指定所有包下的 ISomeSerivce 接口中所有方法为切入点
execution(* com.xyz.service.IAccountService.*(..)) 
//指定切入点为：IAccountService 接口中的任意方法。
execution(* com.xyz.service.IAccountService+.*(..)) 
//指定切入点为：IAccountService 若为接口，则为接口中的任意方法及其所有实现类中的任意方法；若为类，则为该类及其子类中的任意方法。
execution(* joke(String,int)))
//指定切入点为：所有的 joke(String,int)方法，且 joke()方法的第一个参数是 String，第二个参数是 int。如果方法中的参数类型是 java.lang 包下的类，可以直接使用类名，否则必须使用全限定类名，如 joke( java.util.List, int)。
execution(* joke(String,*))) 
//指定切入点为：所有的 joke()方法，该方法第一个参数为 String，第二个参数可以是任意类型，如joke(String s1,String s2)和joke(String s1,double d2)都是，但joke(String s1,double d2,String s3)不是。
execution(* joke(String,..))) 
//指定切入点为：所有的 joke()方法，该方法第一个参数为 String，后面可以有任意个参数且参数类型不限，如 joke(String s1)、joke(String s1,String s2)和 joke(String s1,double d2,String s3)都是。
execution(* joke(Object))
//指定切入点为：所有的 joke()方法，方法拥有一个参数，且参数是 Object 类型。joke(Object ob)是，但，joke(String s)与 joke(User u)均不是。
execution(* joke(Object+))) 
//指定切入点为：所有的 joke()方法，方法拥有一个参数，且参数是 Object 类型或该类的子类。不仅 joke(Object ob)是，joke(String s)和 joke(User u)也是。

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-aop</artifactId>
</dependency>

package com.jeesite.modules.test.service;

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

import java.util.Arrays;

//表明当前类为切面类
@Aspect
//将当前类放到Spring容器中
@Component
public class AopTest {

    private static final Logger log = LoggerFactory.getLogger(AopTest.class);
    /*
    后置切入测试
    */
    //设置要切入的点
    //PointCut表达式
    @Pointcut("execution(public * com.jeesite.modules.sys.service.support.LogServiceSupport.insertLog(..))")
    private void newController1() {
        //PointCut签名方法，没有实际作用，只是用来标记一个Pointcut，作为切入点的标记
    }

    //@After表示在目标方法之后执行下面的方法（afterController()）
    @After("newController1()")
    private void afterController(JoinPoint joinPoint) {
        Object[] args = joinPoint.getArgs();
        //打印被切方法形参
        log.info("insertLog:{}",Arrays.toString(args));
    }

    @Pointcut("execution(public * com.jeesite.modules.sys.web.user.UserController.info(..))")
    private void newController2() {
    }
    
    /*
    环绕切入测试
    */
    @Around(value = "newController2()", argNames = "pjp")
    private String aroundController(ProceedingJoinPoint pjp) {
//        try {
//            //proceed()方法表示执行目标方法，如果不使用proceed()，就不会执行目标方法，只会执行此方法（aroundController()），可以实现目标方法被替换的效果
//            pjp.proceed();
//        } catch (Throwable e) {
//            e.printStackTrace();
//        }

//        User user = new User();
//        user.setUserName("ahzoo");
//        try {
        //使用proceed()，可以用数组形式，传递参数给目标方法，参数个数需与目标方法形参个数一致
//            pjp.proceed(new Object[]{user,"",null});
//        } catch (Throwable e) {
//            e.printStackTrace();
//        }
        Object[] args = pjp.getArgs();
        //打印被切方法形参
        log.info("info:{}",Arrays.toString(args));
        //替换目标方法return语句
        return "modules/sys/user/userSelect";
    }


    /*
    批量（前置）切入测试
    */
    @Pointcut("execution(public String com.jeesite.modules.sys.web.LoginController.switchSkin(..))")
    public void newController12() {
    }
    //可以一次对多个切面进行切入
    @Before("newController12() || newController1()")
    public void beforeController1(JoinPoint joinPoint) {
        log.info("测试切入");
    }

}

@Transactional(readOnly=false)//, propagation=Propagation.NOT_SUPPORTED)
public void insertLog(Log entity) {
	dao.insert(entity);
}

@RequiresPermissions("user")
@RequestMapping(value = "info")
public String info(User user, String op, Model model) {
	if (StringUtils.isBlank(op)){
		op = "base";
	}
	model.addAttribute("op", op);
	model.addAttribute("user", UserUtils.getUser());
       //为了显示环绕通知效果，加了这段打印代码
	logger.info("userInfo:{}","here");
	return "modules/sys/user/userInfo";
}

@Before("execution(* aa.*.*(..))")
public void begin() {
 System.out.println("开始事务");
}
@After("execution(* aa.*.*(..))")
public void close() {
 System.out.println("关闭事务");
}

@Pointcut("execution(* aa.*.*(..))")
public void pt() {
}

@Before("pt()")
public void begin() {
 System.out.println("开始事务");
}
@After("pt()")
public void close() {
 System.out.println("关闭事务");
}