public @interface MyAnnotation { }

@Retention(RetentionPolicy.SOURCE)

@Target(ElementType.Field)

//注解用于字段上
@Target(ElementType.FIELD)
//運行時使用
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String message() default  "aaa";
}

@Data
public class Student {
    @JSONField(ordinal =0)
    @MyAnnotation(message = "AAAAAAAAA")
    public String name;
    @MyAnnotation(message = "AAAAAAAAA")
    public Integer score;
}

    public static void main(String[] args) {
        Class<?> studentClass = Student.class;
        Field[] fields = studentClass.getDeclaredFields();//獲取所有的類成員變量字段
        for (Field field : fields) {
            String fieldName = field.getName(); //獲取該類成員變量的名字
            System.out.println("成員變量名是：" + fieldName);
            Annotation[] annotations = field.getAnnotations(); //獲取該類成員變量上所有聲明周期是運行時的注解
            for (Annotation annotation : annotations) {
                Class<? extends Annotation> annotationType = annotation.annotationType();
                String annotationName = annotationType.getSimpleName();//注解的簡短名稱
                System.out.println(" 使用的注解是：" + annotationName);
                //判斷該注解是不是 MyAnnotation 注解，是的話打印其 id 和 describe 屬性
                if (annotationType.equals(MyAnnotation.class)) {
                    MyAnnotation myAnnotation = field.getAnnotation(MyAnnotation.class);
                    String message = myAnnotation.message();
                    System.out.println("    MyAnnotation注解中的message是：" + message);

                }
            }
            System.out.println();
        }
    }

//注解用于方法
@Target(ElementType.METHOD)
//運行時使用
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {

    String message() default  "aaa";

}

@Component
@Aspect
@Slf4j
public class MyAnnotationAspect {
    /*
     * 這是一個切入點
     * */
    @Pointcut("@annotation(com.demo.aaa.annotation.MyAnnotation)")
    public void cutMethod(){
    }
    /**
     * 切點之前
     */
    @Before("cutMethod()")
    public void before(JoinPoint joinPoint) throws Throwable {
        log.info("============ before ==========");
    }
    /**
     * 切點之后
     */
    @After("cutMethod()")
    public void after() throws Throwable {
        log.info("============ after ==========");
    }
    /**
     * 切點返回內(nèi)容后
     */
    @AfterReturning("cutMethod()")
    public void afterReturning() throws Throwable {
        log.info("============ afterReturning ==========");
    }
    /**
     * 切點拋出異常后
     */
    @AfterThrowing("cutMethod()")
    public void afterThrowing() throws Throwable {
        log.info("============ afterThrowing ==========");
    }
    @Around("cutMethod() && @annotation(myAnnotation)")
    public Object around(ProceedingJoinPoint point, MyAnnotation myAnnotation) throws Throwable {
        log.info("============ around1 ==========");
        Object  obj= point.proceed(point.getArgs());
        log.info("============ around2 ==========");
        return obj;
    }
}

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>

    @GetMapping("/aaa")
    @MyAnnotation(message = "成功拉！?。。。。。。。。。?！")
    public void test() {
        System.out.println("執(zhí)行代碼邏輯");
    }

@Pointcut("args(java.lang.String)")  //這樣就是錯的，不能單獨使用要匹配到某些類

@Pointcut("within(com.example.demo.service.impl.UserServiceImpl) && args(java.lang.String,java.lang.String)") //要像這樣使用 within 先匹配到某個具體的類，在使用args匹配到某個類型參數(shù)的方法

@Pointcut("within(com.demo.RedisTest) && @args(com.demo.aaa.annotation.MyAnnotation)")

//within表達式的粒度為類，其參數(shù)為全路徑的類名（可使用通配符），表示匹配當前表達式的所有類都將被當前方法環(huán)繞。如下是within表達式的語法：
@Pointcut(within(declaring-type-pattern))

//within表達式只能指定到類級別，如下示例表示匹配com.spring.service.BusinessObject中的所有方法：
@Pointcut(within(com.spring.service.BusinessObject))
      
//within表達式路徑和類名都可以使用通配符進行匹配，比如如下表達式將匹配com.spring.service包下的所有類，不包括子包中的類：
@Pointcut(within(com.spring.service.*))

//如下表達式表示匹配com.spring.service包及子包下的所有類：
@Pointcut(within(com.spring.service..*))

//如下所示示例表示匹配使用com.spring.annotation.BusinessAspect注解標注的類：
@within(com.spring.annotation.BusinessAspect)

@Pointcut("@annotation(com.test.annotations.LogAuto)")

modifiers-pattern：方法的可見性修飾符，如 public，protected，private；
ret-type-pattern：方法的返回值類型，如 int，void 等；
declaring-type-pattern：方法所在類的全路徑名，如 com.spring.Aspect；
name-pattern：方法名，如 getOrderDetail()；
param-pattern：方法的參數(shù)類型，如 java.lang.String；
throws-pattern：方法拋出的異常類型，如 java.lang.Exception；
示例：

// 匹配目標類的所有 public 方法，第一個 * 代表返回類型，第二個 * 代表方法名，..代表方法的參數(shù)
execution(public * *(..))

// 匹配目標類所有以 User 為后綴的方法。第一個 * 代表返回類型，*User 代表以 User 為后綴的方法
execution(* *User(..))

// 匹配 User 類里的所有方法
execution(* com.test.demo.User.*(..))

// 匹配 User 類及其子類的所有方法
execution(* com.test.demo.User+.*(..)) :

// 匹配 com.test 包下的所有類的所有方法
execution(* com.test.*.*(..))

// 匹配 com.test 包下及其子孫包下所有類的所有方法
execution(* com.test..*.*(..)) :

// 匹配 getOrderDetail 方法，且第一個參數(shù)類型是 Long，第二個參數(shù)類型是 String
execution(* getOrderDetail(Long, String))

   @Around(value = "@annotation(basisLogAnnotation)")
    public Object demoAop(ProceedingJoinPoint proceedingJoinPoint, final BasisLogAnnotation basisLogAnnotation) throws Throwable {
 
        logger.debug("執(zhí)行前：");
 
        Object object = proceedingJoinPoint.proceed();  //執(zhí)行連接點方法，object：方法返回值
 
        logger.debug("執(zhí)行后：");
 
 
        // 類名
        String className = proceedingJoinPoint.getTarget().getClass().getName();
        //方法名
        String methodName = proceedingJoinPoint.getSignature().getName();
        //參數(shù)（我這里是對象，具體根據(jù)個人的參數(shù)類型來強轉）
        BasisUser basisUser = (BasisUser)proceedingJoinPoint.getArgs()[0];
        return object;
    }