一文详解Java如何实现自定义注解

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 ==========");
    }
    /**
     * 切点返回内容后
     */
    @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("执行代码逻辑");
    }

@pointcut("args(java.lang.string)")  //这样就是错的，不能单独使用要匹配到某些类

@pointcut("within(com.example.demo.service.impl.userserviceimpl) && args(java.lang.string,java.lang.string)") //要像这样使用 within 先匹配到某个具体的类，在使用args匹配到某个类型参数的方法

@pointcut("within(com.demo.redistest) && @args(com.demo.aaa.annotation.myannotation)")

//within表达式的粒度为类，其参数为全路径的类名（可使用通配符），表示匹配当前表达式的所有类都将被当前方法环绕。如下是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：方法的参数类型，如 java.lang.string；
throws-pattern：方法抛出的异常类型，如 java.lang.exception；
示例：

// 匹配目标类的所有 public 方法，第一个 * 代表返回类型，第二个 * 代表方法名，..代表方法的参数
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 方法，且第一个参数类型是 long，第二个参数类型是 string
execution(* getorderdetail(long, string))

   @around(value = "@annotation(basislogannotation)")
    public object demoaop(proceedingjoinpoint proceedingjoinpoint, final basislogannotation basislogannotation) throws throwable {
 
        logger.debug("执行前：");
 
        object object = proceedingjoinpoint.proceed();  //执行连接点方法，object：方法返回值
 
        logger.debug("执行后：");
 
 
        // 类名
        string classname = proceedingjoinpoint.gettarget().getclass().getname();
        //方法名
        string methodname = proceedingjoinpoint.getsignature().getname();
        //参数（我这里是对象，具体根据个人的参数类型来强转）
        basisuser basisuser = (basisuser)proceedingjoinpoint.getargs()[0];
        return object;
    }