SpringBoot实践之（十五）---自定义注解Annotation的使用

最新推荐文章于 2024-05-28 14:12:04 发布

luckykapok918

最新推荐文章于 2024-05-28 14:12:04 发布

阅读量6.1k

点赞数 1

分类专栏： Springboot

本文链接：https://blog.csdn.net/luckykapok918/article/details/79290109

版权

Springboot 专栏收录该内容

57 篇文章 1 订阅

订阅专栏

首先导入相关包

在build.gradle中添加

dependencies {
    //支持AOP
    compile('org.springframework.boot:spring-boot-starter-aop')
}

然后创建Aspect测试类 TestAspect：

import com.great.annotation.OperateLogAnnotation;
import com.great.annotation.TestAnnotation;
//import javassist.bytecode.SignatureAttribute;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

@Aspect // FOR AOP
@Order(-99) // 控制多个Aspect的执行顺序，越小越先执行
@Component
public class TestAspect {

    @Before("@annotation(test)")// 拦截被TestAnnotation注解的方法；如果你需要拦截指定package指定规则名称的方法，可以使用表达式execution(...)，具体百度一下资料一大堆
    public void beforeTest(JoinPoint point, TestAnnotation test) throws Throwable {
        System.out.println("beforeTest:" + test.name());
    }

    @After("@annotation(test)")
    public void afterTest(JoinPoint point, TestAnnotation test) {
        System.out.println("afterTest:" + test.name());
    }


/*    @Pointcut("@annotation(com.great.annotation.OperateLogAnnotation)")
    public void annotationPointCut() {
    }

   @Before("annotationPointCut()")
    public void before(JoinPoint joinPoint) {
        MethodSignature sign = (MethodSignature) joinPoint.getSignature();
        Method method = sign.getMethod();
        OperateLogAnnotation annotation = method.getAnnotation(OperateLogAnnotation.class);
        System.out.println("打印：" + annotation.value() + " 前置日志1");
    }

    @After("annotationPointCut()")
    public void afterTTT(JoinPoint point) {
        MethodSignature sign = (MethodSignature) point.getSignature();
        Method method = sign.getMethod();
        OperateLogAnnotation annotation = method.getAnnotation(OperateLogAnnotation.class);
        System.out.println("打印自带参数：" + annotation.value() + " 后置日志1");
    }*/

    @Before("@annotation(operateLogAnnotation)")
    public void before(JoinPoint joinPoint,OperateLogAnnotation operateLogAnnotation) {
        System.out.println("打印：" + operateLogAnnotation.value() + " 前置日志2");
    }

    @After("@annotation(operateLogAnnotation)")
    public void afterTTT(JoinPoint point,OperateLogAnnotation operateLogAnnotation) {
        System.out.println("打印自带参数：" + operateLogAnnotation.value() + " 后置日志2");
    }
}

再添加一个自定义的注解类OperateLogAnnotation：

import java.lang.annotation.*;

@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface OperateLogAnnotation {
    String value();
}

然后创建一个TestAOPController 验证一下：

import com.great.annotation.OperateLogAnnotation;
import com.great.annotation.TestAnnotation;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/test")
public class TestAOPController {

    @TestAnnotation(name="abc")
    @RequestMapping("/show")
    public String show() {
        return "OK";
    }

    @RequestMapping("/show2")
    public String show2() {
        return "OK2";
    }

    @RequestMapping("/show3")
    @ResponseBody
    @OperateLogAnnotation("测试")
    public String getById() {
        return "hello";
    }

}

此时我们访问请求show3则会触发切面被拦截。
这里写图片描述

注解基本概念：

java注解：附在代码中的一些元信息，用于在编译、运行时起到说明、配置的功能。

一、元注解

java提供了4种元注解用于注解其他注解，所有的注解都是基于这四种注解来定义的。

@Target注解：用于描述注解的使用范围，超出范围时编译失败。

取值类型（ElementType）：

1.CONSTRUCTOR:用于描述构造器

2.FIELD:用于描述域（成员变量）

3.LOCAL_VARIABLE:用于描述局部变量

4.METHOD:用于描述方法

5.PACKAGE:用于描述包

6.PARAMETER:用于描述参数

7.TYPE:用于描述类、接口(包括注解类型) 或enum声明

例如：

@Target(ElementType.TYPE)  
public @interface MyAnnotation {  
    //类名注解，默认即为当前类名  
    String name() default "className";  
}

import java.lang.annotation.ElementType;  
import java.lang.annotation.Target;  

//字段注解  
@Target(ElementType.FIELD)  
public @interface MyAnnotation1 {  
    String name() default "fieldName";            
    String getFieldValue() default "getField";    
    String setFieldValue() default "setField";   
}

@Retention：描述注解的生命周期，即注解的生效范围。

取值范围（RetentionPolicy）：

1.SOURCE：在源文件中生效，仅存在java文件中，class文件将会去除注解。

2.CLASS：在class文件中生效，仅保留在class文件中，运行时无法获取注解。

3.RUNTIME:在运行时生效，保留在class文件中且运行时可通过反射机制获取。

例如：

@Target(ElementType.FIELD) //字段注解  
@Retention(RetentionPolicy.RUNTIME) //在运行期保留注解信息  
public @interface MyAnnotation1 {  
    String name() default "fieldName";            
    String getFieldValue() default "getField";    
    String setFieldValue() default "setField";   
}

@Documented：用于指定javac生成API时显示该注解信息。

例如：

@Target(ElementType.FIELD) //字段注解  
@Retention(RetentionPolicy.RUNTIME) //在运行期保留注解信息  
@Documented     //在生成javac时显示该注解的信息  
public @interface MyAnnotation1 {  
    String name() default "fieldName";            
    String getFieldValue() default "getField";    
    String setFieldValue() default "setField";   
}

@Inherited：标明该注解可以由子类继承，及子类可以继承父类的注解。而默认情况下，子类是不继承父类注解的。

例如：

@Target(ElementType.FIELD) //字段注解  
@Retention(RetentionPolicy.RUNTIME) //在运行期保留注解信息  
@Documented     //在生成javac时显示该注解的信息  
@Inherited      //标明MyAnnotation1注解可以被使用它的子类继承  
public @interface MyAnnotation1 {  
    String name() default "fieldName";            
    String getFieldValue() default "getField";    
    String setFieldValue() default "setField";   
    public enum FieldValue{MYTEST,MYFIELD,MYVALUE};  
    FieldValue  realVale() default FieldValue.MYFIELD;  
}

读取注解

通过反射机制我们可以读取注解信息
java在java.lang.reflect包下新增了AnnotatedElement接口，该接口定义了可以接受注解的元素
为：Class(类)、Constructor(构造器)、Field(字段)、Method(方法)、Package(包)。

AnnotatedElement是所有注解元素的父接口，所有的注解元素都可以通过某个类反射获取该对象，
该对象有一下4个方法来访问Annotation信息。

（1） T getAnnotation(Class annotationClass)
返回该程序元素上存在的、指定类型的注解，如果该类型注解不存在，则返回null。

（2）Annotation[] getAnnotations():返回该程序元素上存在的所有注解。

（3）boolean isAnnotationPresent(Class

package com.dhcc.iscp.web.annotation;  

import java.lang.annotation.ElementType;  
import java.lang.annotation.Retention;  
import java.lang.annotation.RetentionPolicy;  
import java.lang.annotation.Target;  

@Target(ElementType.TYPE)  
@Retention(RetentionPolicy.RUNTIME) //在运行期保留注解信息  
public @interface MyAnnotation {  
    //类名注解，默认即为当前类名  
    String name() default "className";  
}

package com.dhcc.iscp.web.annotation;  

import java.lang.annotation.Documented;  
import java.lang.annotation.ElementType;  
import java.lang.annotation.Inherited;  
import java.lang.annotation.Retention;  
import java.lang.annotation.RetentionPolicy;  
import java.lang.annotation.Target;  


@Target(ElementType.FIELD) //字段注解  
@Retention(RetentionPolicy.RUNTIME) //在运行期保留注解信息  
@Documented     //在生成javac时显示该注解的信息  
@Inherited      //标明MyAnnotation1注解可以被使用它的子类继承  
public @interface MyAnnotation1 {  
    String name() default "fieldName";            
    String getFieldValue() default "getField";    
    String setFieldValue() default "setField";   
    public enum FieldValue{MYTEST,MYFIELD,MYVALUE};  
    FieldValue  realValue() default FieldValue.MYFIELD;  
}

实体类：

package com.dhcc.iscp.web.annotation;  

import com.dhcc.iscp.web.annotation.MyAnnotation1.FieldValue;  

@MyAnnotation(name="myTest")  
public class MyTest {  

    @MyAnnotation1  
    String myTest;  

    @MyAnnotation1(name="test",getFieldValue="1",setFieldValue="2",realValue=FieldValue.MYVALUE)  
    String testValue;  

    public String getMyTest() {  
        return myTest;  
    }  

    public void setMyTest(String myTest) {  
        this.myTest = myTest;  
    }  

    public String getTestValue() {  
        return testValue;  
    }  

    public void setTestValue(String testValue) {  
        this.testValue = testValue;  
    }  

}

测试类：

package com.dhcc.iscp.web.annotation;  

import java.lang.annotation.Annotation;  
import java.lang.reflect.Field;  
import java.lang.reflect.Method;  

public class TestAnnotation {  
    public static void main(String[] args){  
        MyTest myTest = new MyTest();  

        Annotation[] annotations = myTest.getClass().getAnnotations();  //获取类的所有注解  
        for(Annotation anno:annotations){  
            if(anno instanceof MyAnnotation){  
                MyAnnotation myAnnotation = (MyAnnotation)anno;  
                System.out.println("className:"+myAnnotation.name());  
            }else if(anno instanceof MyAnnotation1){  
                MyAnnotation1 myAnnotation1 = (MyAnnotation1)anno;  
                System.out.println("FiledName:"+myAnnotation1.name());  
                System.out.println("setFieldValue"+myAnnotation1.setFieldValue());  
                System.out.println("getFieldValue"+myAnnotation1.getFieldValue());  
                System.out.println("realValue"+myAnnotation1.realValue());  
            }  
        }  

        Field[] fields = myTest.getClass().getDeclaredFields();//获取所有注解字段  
        for(Field field:fields){  
            if(field.isAnnotationPresent(MyAnnotation1.class)){  
                MyAnnotation1 myAnno = (MyAnnotation1)field.getAnnotation(MyAnnotation1.class);  
                System.out.println(field.getName()+"-name:"+myAnno.name());  
                System.out.println(field.getName()+"-getFieldValue:"+myAnno.getFieldValue());  
                System.out.println(field.getName()+"-setFieldValue:"+myAnno.setFieldValue());  
                System.out.println(field.getName()+"-realValue:"+myAnno.realValue());  
            }  
        }  

        Method[] methods = myTest.getClass().getMethods();//获取所有方法  
        for(Method method:methods){  
            if(method.isAnnotationPresent(MyAnnotation1.class)){  
                MyAnnotation1 myAnno1 = (MyAnnotation1)method.getAnnotation(MyAnnotation1.class);  
                System.out.println(myAnno1.getClass());  
            }  
        }  
    }  
}

测试结果：

这里写图片描述

自定义注解

自定义注解是通过@interface来声明的，其中的每一个方法实际上是声明了一个配置参数，参数名称即为方法名，参数类型即为返回值类型。

自定义注解的格式：

public @interface 注解名｛定义体｝

注解参数可支持的类型：

1.所有基本数据类型（int,float,boolean,byte,double,char,long,short)
2.String类型
3.Class类型
4.enum类型
5.Annotation类型
6.以上所有类型的数组

注解参数的定义规则：

a.只能使用public或默认2种访问修饰，例如：String getName();这里getName()就是使用了默认访问权限。

b.参数类型只能使用上面提到的6种情况

c.如果只有一个参数成员，最好将参数名定义为：value()。

d.注解元素必须有确定值，要么在定义的时候设置默认值，要么在使用注解的时候设置参数值。

luckykapok918

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot实践之（十五）---自定义注解Annotation的使用

首先导入相关包在build.gradle中添加dependencies { //支持AOP compile('org.springframework.boot:spring-boot-starter-aop')}然后创建Aspect测试类 TestAspect：import com.great.annotation.OperateLogAnnotati...
复制链接

扫一扫

专栏目录