自定义注解

影࿐ེ

已于 2023-09-27 10:55:42 修改

阅读量3k

点赞数 1

分类专栏： Java 文章标签： java spring

于 2022-09-06 18:38:59 首次发布

本文链接：https://blog.csdn.net/u014365523/article/details/126730735

版权

Java 专栏收录该内容

62 篇文章 5 订阅

订阅专栏

一、如何自定义注解实现功能
创建自定义注解和创建一个接口相似，但是注解的 interface 关键字需要以 @ 符号开头。
注解方法不能带有参数；
注解方法返回值类型限定为：基本类型、String、Enums、Annotation 或者是这些类型的数组；
注解方法可以有默认值；
注解本身能够包含元注解，元注解被用来注解其它注解。

二、什么是注解？
对于很多初次接触的开发者来说应该都有这个疑问？_Annontation_是Java5开始引入的新特征，中文名称叫注解。它提供了一种安全的类似注释的机制，用来将任何的信息或元数据（metadata）与程序元素（类、方法、成员变量等）进行关联。为程序的元素（类、方法、成员变量）加上更直观更明了的说明，这些说明信息是与程序的业务逻辑无关，并且供指定的工具或框架使用。Annontation像一种修饰符一样，应用于包、类型、构造方法、方法、成员变量、参数及本地变量的声明语句中。
　　Java注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。包含在 java.lang.annotation 包中。

三、注解的用处：
1、生成文档。这是最常见的，也是java 最早提供的注解。常用的有@param @return 等
2、跟踪代码依赖性，实现替代配置文件功能。比如Dagger 2 依赖注入，未来java 开发，将大量注解配置，具有很大用处;
3、在编译时进行格式检查。如@override 放在方法前，如果你这个方法并不是覆盖了超类方法，则编译时就能检查出。

四、注解的原理：
注解本质是一个继承了Annotation 的特殊接口，其具体实现类是Java 运行时生成的动态代理类。而我们通过反射获取注解时，返回的是Java 运行时生成的动态代理对象$Proxy1。通过代理对象调用自定义注解（接口）的方法，会最终调用AnnotationInvocationHandler 的invoke 方法。该方法会从memberValues 这个Map 中索引出对应的值。而memberValues 的来源是Java 常量池。

五、元注解：
java.lang.annotation 提供了四种元注解，专门注解其他的注解（在自定义注解的时候，需要使用到元注解）：
@Documented – 注解是否将包含在JavaDoc中
@Retention – 什么时候使用该注解
@Target – 注解用于什么地方
@Inherited – 是否允许子类继承该注解

1.）@Retention – 定义该注解的生命周期
● RetentionPolicy.SOURCE : 在编译阶段丢弃。这些注解在编译结束之后就不再有任何意义，所以它们不会写入字节码。@Override, @SuppressWarnings都属于这类注解。
● RetentionPolicy.CLASS : 在类加载的时候丢弃。在字节码文件的处理中有用。注解默认使用这种方式
● RetentionPolicy.RUNTIME : 始终不会丢弃，运行期也保留该注解，因此可以使用反射机制读取该注解的信息。我们自定义的注解通常使用这种方式。

2.）Target – 表示该注解用于什么地方。默认值为任何元素，表示该注解用于什么地方。可用的ElementType 参数包括
● ElementType.CONSTRUCTOR: 用于描述构造器
● ElementType.FIELD: 成员变量、对象、属性（包括enum实例）
● ElementType.LOCAL_VARIABLE: 用于描述局部变量
● ElementType.METHOD: 用于描述方法
● ElementType.PACKAGE: 用于描述包
● ElementType.PARAMETER: 用于描述参数
● ElementType.TYPE: 用于描述类、接口(包括注解类型) 或enum声明

3.)@Documented – 一个简单的Annotations 标记注解，表示是否将注解信息添加在java 文档中。

4.)@Inherited – 定义该注释和子类的关系
@Inherited 元注解是一个标记注解，@Inherited 阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited 修饰的annotation 类型被用于一个class，则这个annotation 将被用于该class 的子类。

六、常见标准的Annotation：
1.）Override
java.lang.Override 是一个标记类型注解，它被用作标注方法。它说明了被标注的方法重载了父类的方法，起到了断言的作用。如果我们使用了这种注解在一个没有覆盖父类方法的方法时，java 编译器将以一个编译错误来警示。
2.）Deprecated
Deprecated 也是一种标记类型注解。当一个类型或者类型成员使用@Deprecated 修饰的话，编译器将不鼓励使用这个被标注的程序元素。所以使用这种修饰具有一定的“延续性”：如果我们在代码中通过继承或者覆盖的方式使用了这个过时的类型或者成员，虽然继承或者覆盖后的类型或者成员并不是被声明为@Deprecated，但编译器仍然要报警。
3.）SuppressWarnings
SuppressWarning 不是一个标记类型注解。它有一个类型为String[] 的成员，这个成员的值为被禁止的警告名。对于javac 编译器来讲，被-Xlint 选项有效的警告名也同样对@SuppressWarings 有效，同时编译器忽略掉无法识别的警告名。
　　@SuppressWarnings(“unchecked”)

七、自定义注解：
自定义注解类编写的一些规则:

Annotation 型定义为@interface, 所有的Annotation 会自动继承java.lang.Annotation这一接口,并且不能再去继承别的类或是接口.
参数成员只能用public 或默认(default) 这两个访问权修饰
参数成员只能用基本类型byte、short、char、int、long、float、double、boolean八种基本数据类型和String、Enum、Class、annotations等数据类型，以及这一些类型的数组.
要获取类方法和字段的注解信息，必须通过Java的反射技术来获取 Annotation 对象，因为你除此之外没有别的获取注解对象的方法
注解也可以没有定义成员,，不过这样注解就没啥用了
PS:自定义注解需要使用到元注解

八、自定义注解
（1）定义注解

package com.example.demo.common;

import java.lang.annotation.*;

@Target({ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Myannotation {

    String description();

    int length();
}

（2）代码中使用

@Myannotation(description = "${zkt.log.operatecode.doLogin}", length = 20) //description的值可以动态获取${zkt.log.operatecode.doLogin}，也可以直接赋值description=“xxx”
    @GetMapping("/myPage")
    @ResponseBody
    public Map<Object, Object> expenseStatement(Object str) throws IOException {
        //TODO
    }

（3）获取注解，解析注解

package com.example.demo.common;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;

/**
 * 系统日志，切面处理类
 * @version 1.0
 */
@Aspect
@Component
public class SysLogAspect{

    @Autowired
    private Environment environment;

    private static final Logger logger = LoggerFactory.getLogger(SysLogAspect.class);

    /**
     * 设置操作日志切入点 记录操作日志 在注解的位置切入代码
     **/
    @Pointcut("@annotation(com.example.demo.common.SysLogAnn)")
    public void operateLogPointCut() {
    }

    @Before(value = "operateLogPointCut()")
    public void before(JoinPoint joinPoint) {

        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        // 当前登陆用户
        Method method = signature.getMethod();
        SysLogAnn logAnn = method.getAnnotation(SysLogAnn.class);
        String operationCode = environment.resolvePlaceholders(logAnn.operationCode());
        System.out.println(operationCode);
        //保存操作
        logger.info("=========SysLogAspect添加到系统日志==========");
    }

    /**
     * 转换 request 请求参数
     *
     * @param paramMap request获取的参数数组
     */
    public Map<String, String> converMap(Map<String, String[]> paramMap) {
        Map<String, String> rtnMap = new HashMap();
        for (String key : paramMap.keySet()) {
            rtnMap.put(key, paramMap.get(key)[0]);
        }
        return rtnMap;
    }
}

上述aspect方式进行拦截，获取注解，解析注解。也可以使用SourceAccessInterceptor（拦截器）进行拦截、解析，如下：

package com.example.demo.common;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * <p>项目名称:  </p>
 * <p>文件名称:  </p>
 * <p>功能描述:  </p>
 * <p>创建时间: 2022/9/6 </p>
 * @author Top
 * @version v1.0
 */
public class SourceAccessInterceptor implements HandlerInterceptor {

    @Autowired
    private Environment environment;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle方法在业务处理器处理请求之前被调用");

        // 反射获取方法上的LoginRequred注解
        HandlerMethod handlerMethod = (HandlerMethod )handler;
        SysLogAnn myannotation = handlerMethod.getMethodAnnotation(SysLogAnn.class);
        String operationCode = environment.resolvePlaceholders(myannotation.operationCode());
        System.out.println(operationCode);

        if (null != myannotation){
            System.out.println(myannotation.operationCode());
            System.out.println(myannotation.operationValue());
            return true;
        }

        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle方法在业务处理器处理请求执行完成后，生成视图之前执行");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion方法在DispatcherServlet完全处理完请求后被调用，可用于清理资源等");
    }
}

将上述拦截器进行配置到容器：

package com.example.demo.common;


import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Configuration
public class LoggerConfiguration extends WebMvcConfigurerAdapter {

    @Bean
    public SourceAccessInterceptor loggerInterceptor(){
        System.out.println("嘻嘻嘻嘻");
        return new SourceAccessInterceptor();
    }
    /**
     * LoggerInterceptor,形成拦截链
     * @param registry 拦截器注册类
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry){
        //在放入拦截器之前调用loggerInterceptor(),触发LocalContainerEntityManagerFactoryBean使得拦截器的在注册之前所有的bean都持久化
        registry.addInterceptor(loggerInterceptor()).addPathPatterns("/**");
        System.out.println("呵呵呵呵");
    }
}