文章详情

短信预约-IT技能 免费直播动态提醒

请输入下面的图形验证码

提交验证

短信预约提醒成功

Java 自定义注解的魅力

2024-04-02 19:55

关注

注解是什么?

①、引用自维基百科的内容:
Java注解又称Java标注,是JDK5.0版本开始支持加入源代码的特殊语法 元数据 。

Java语言中的类、方法、变量、参数和包等都可以被标注。和Javadoc不同,Java标注可以通过反射获取标注内容。在编译器生成类文件时,标注可以被嵌入到字节码中。Java虚拟机可以保留标注内容,在运行时可以获取到标注内容。 当然它也支持自定义Java标注。

②、引用自网络的内容:
Java 注解是在 JDK5 时引入的新特性,注解(也被称为 元数据 )为我们在代码中添加信息提供了一种形式化的方法,使我们可以在稍后某个时刻非常方便地使用这些数据。

元注解是什么?

元注解 的作用就是负责注解其他注解。Java5.0定义了4个标准的meta-annotation(元注解)类型,它们被用来提供对其它 annotation类型作说明。

标准的元注解:

@Target
@Retention
@Documented
@Inherited
在详细说这四个元数据的含义之前,先来看一个在工作中会经常使用到的 @Autowired 注解,进入这个注解里面瞧瞧: 此注解中使用到了@Target、@Retention、@Documented 这三个元注解 。


@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
    boolean required() default true;
}

@Target元注解:

@Target注解,是专门用来限定某个自定义注解能够被应用在哪些Java元素上面的,标明作用范围;取值在java.lang.annotation.ElementType 进行定义的。


public enum ElementType {
    
    TYPE,

    
    FIELD,

    
    METHOD,

    
    PARAMETER,

    
    CONSTRUCTOR,

    
    LOCAL_VARIABLE,

    
    ANNOTATION_TYPE,

    
    PACKAGE
}

根据此处可以知道 @Autowired 注解的作用范围:


// 可以作用在 构造方法、方法、方法形参、属性、注解类型 上
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})

@Retention元注解:

@Retention注解,翻译为持久力、保持力。即用来修饰自定义注解的生命周期。

注解的生命周期有三个阶段:

同样使用了RetentionPolicy 枚举类型对这三个阶段进行了定义:


public enum RetentionPolicy {
    
    SOURCE,

    
    CLASS,

    
    RUNTIME
}

再详细描述下这三个阶段:

①、如果被定义为 RetentionPolicy.SOURCE,则它将被限定在Java源文件中,那么这个注解即不会参与编译也不会在运行期起任何作用,这个注解就和一个注释是一样的效果,只能被阅读Java文件的人看到;

②、如果被定义为 RetentionPolicy.CLASS,则它将被编译到Class文件中,那么编译器可以在编译时根据注解做一些处理动作,但是运行时JVM(Java虚拟机)会忽略它,并且在运行期也不能读取到;

③、如果被定义为 RetentionPolicy.RUNTIME,那么这个注解可以在运行期的加载阶段被加载到Class对象中。那么在程序运行阶段,可以通过反射得到这个注解,并通过判断是否有这个注解或这个注解中属性的值,从而执行不同的程序代码段。

注意:实际开发中的自定义注解几乎都是使用的 RetentionPolicy.RUNTIME 。

@Documented元注解:

@Documented注解,是被用来指定自定义注解是否能随着被定义的java文件生成到JavaDoc文档当中。

@Inherited元注解:

@Inherited注解,是指定某个自定义注解如果写在了父类的声明部分,那么子类的声明部分也能自动拥有该注解。

@Inherited注解只对那些@Target被定义为 ElementType.TYPE 的自定义注解起作用。

自定义注解实现:

在了解了上面的内容后,我们来尝试实现一个自定义注解:

根据上面自定义注解中使用到的元注解得知:

①、此注解的作用范围,可以使用在类(接口、枚举)、方法上;

②、此注解的生命周期,被编译器保存在class文件中,而且在运行时会被JVM保留,可以通过反射读取;

自定义注解的简单使用:

上面已经创建了一个自定义的注解,那该怎么使用呢?下面首先描述下它简单的用法,后面将会使用其结合拦截器和AOP切面编程进行实战应用;

应用场景实现

在了解了上面注解的知识后,我们乘胜追击,看看它的实际应用场景是肿么样的,以此加深下我们的理解;

实现的 Demo 项目是以 SpringBoot 实现的,项目工程结构图如下:

场景一:自定义注解 + 拦截器 = 实现接口响应的包装

使用自定义注解 结合 拦截器 优雅的实现对API接口响应的包装。

在介绍自定义实现的方式之前,先简单介绍下普遍的实现方式,通过两者的对比,才能更加明显的发现谁最优雅。

普通的接口响应包装方式:
现在项目绝大部分都采用的前后端分离方式,所以需要前端和后端通过接口进行交互;目前在接口交互中使用最多的数据格式是 json,然后后端返回给前端的最为常见的响应格式如下:


{
    #返回状态码
    code:integer,       
    #返回信息描述
    message:string,
    #返回数据值
    data:object
}

项目中经常使用枚举类定义状态码和消息,代码如下:



public enum ResponseCode {

    SUCCESS(1200, "请求成功"),

    ERROR(1400, "请求失败");


    private Integer code;

    private String message;

    private ResponseCode(Integer code, String message) {
        this.code = code;
        this.message = message;
    }

    public Integer code() {
        return this.code;
    }

    public String message() {
        return this.message;
    }

}

同时项目中也会设计一个返回响应包装类,代码如下:


import com.alibaba.fastjson.JSONObject;
import java.io.Serializable;


@SuppressWarnings("serial")
public class Response<T> implements Serializable {

    
    private T date;

    
    private Integer code;

    
    private String message;

    public Response(T date, Integer code, String message) {
        super();
        this.date = date;
        this.code = code;
        this.message = message;
    }


    public T getDate() {
        return date;
    }

    public void setDate(T date) {
        this.date = date;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }


    @Override
    public String toString() {
        return JSONObject.toJSONString(this);
    }
}

最后就是使用响应包装类和状态码枚举类 来实现返回响应的包装了:


@GetMapping("/user/findAllUser")
public Response<List<User>> findAllUser() {
    logger.info("开始查询所有数据...");

    List<User> findAllUser = new ArrayList<>();
    findAllUser.add(new User("木子雷", 26));
    findAllUser.add(new User("公众号", 28));

    // 返回响应进行包装
    Response response = new Response(findAllUser, ResponseCode.SUCCESS.code(), ResponseCode.SUCCESS.message());

    logger.info("response: {} \n", response.toString());
    return response;
}

在浏览器中输入网址: http://127.0.0.1:8080/v1/api/user/findAllUser 然后点击回车,得到如下数据:


{
    "code": 1200,
    "date": [
        {
            "age": 26,
            "name": "木子雷"
        },
        {
            "age": 28,
            "name": "公众号"
        }
    ],
    "message": "请求成功"
}

通过看这中实现响应包装的方式,我们能发现什么问题吗?

答:代码很冗余,需要在每个接口方法中都进行响应的包装;使得接口方法包含了很多非业务逻辑代码;

有没有版本进行优化下呢? en en 思考中。。。。。 啊,自定义注解 + 拦截器可以实现呀!

自定义注解实现接口响应包装:
①、首先创建一个进行响应包装的自定义注解:



@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ResponseResult {

}

②、创建一个拦截器,实现对请求的拦截,看看请求的方法或类上是否使用了自定义的注解:



@Component
public class ResponseResultInterceptor implements HandlerInterceptor {

    
    public static final String RESPONSE_ANNOTATION = "RESPONSE_ANNOTATION";

    
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        // 请求的接口方法
        if (handler instanceof HandlerMethod) {
            final HandlerMethod handlerMethod = (HandlerMethod) handler;
            final Class<?> clazz = handlerMethod.getBeanType();
            final Method method = handlerMethod.getMethod();
            // 判断是否在类对象上加了注解
            if (clazz.isAnnotationPresent(ResponseResult.class)) {
                // 在请求中设置需要进行响应包装的属性标志,在下面的ResponseBodyAdvice增强中进行处理
                request.setAttribute(RESPONSE_ANNOTATION, clazz.getAnnotation(ResponseResult.class));
            } else if (method.isAnnotationPresent(ResponseResult.class)) {
                // 在请求中设置需要进行响应包装的属性标志,在下面的ResponseBodyAdvice增强中进行处理
                request.setAttribute(RESPONSE_ANNOTATION, method.getAnnotation(ResponseResult.class));
            }
        }
        return true;
    }
}

③、创建一个增强Controller,实现对返回响应进行包装的增强处理:



@ControllerAdvice
public class ResponseResultHandler implements ResponseBodyAdvice<Object> {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    
    public static final String RESPONSE_ANNOTATION = "RESPONSE_ANNOTATION";

    
    @Override
    public boolean supports(MethodParameter methodParameter, Class<? extends HttpMessageConverter<?>> aClass) {
        ServletRequestAttributes ra = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest sr = (HttpServletRequest) ra.getRequest();
        // 查询是否需要进行响应包装的标志
        ResponseResult responseResult = (ResponseResult) sr.getAttribute(RESPONSE_ANNOTATION);
        return responseResult == null ? false : true;
    }


    
    @Override
    public Object beforeBodyWrite(Object responseBody, MethodParameter methodParameter, MediaType mediaType, Class<? extends HttpMessageConverter<?>> aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
        logger.info("返回响应 包装进行中。。。");
        Response response;
        // boolean类型时判断一些数据库新增、更新、删除的操作是否成功
        if (responseBody instanceof Boolean) {
            if ((Boolean) responseBody) {
                response = new Response(responseBody, ResponseCode.SUCCESS.code(), ResponseCode.SUCCESS.message());
            } else {
                response = new Response(responseBody, ResponseCode.ERROR.code(), ResponseCode.ERROR.message());
            }
        } else {
            // 判断像查询一些返回数据的情况,查询不到数据返回 null;
            if (null != responseBody) {
                response = new Response(responseBody, ResponseCode.SUCCESS.code(), ResponseCode.SUCCESS.message());
            } else {
                response = new Response(responseBody, ResponseCode.ERROR.code(), ResponseCode.ERROR.message());
            }
        }
        return response;
    }
}

④、最后在 Controller 中使用上我们的自定义注解;在 Controller 类上或者 方法上使用@ResponseResult自定义注解即可; 在浏览器中输入网址: http://127.0.0.1:8080/v1/api/user/findAllUserByAnnotation 进行查看:


// 自定义注解用在了方法上
@ResponseResult
@GetMapping("/user/findAllUserByAnnotation")
public List<User> findAllUserByAnnotation() {
    logger.info("开始查询所有数据...");

    List<User> findAllUser = new ArrayList<>();
    findAllUser.add(new User("木子雷", 26));
    findAllUser.add(new User("公众号", 28));

    logger.info("使用 @ResponseResult 自定义注解进行响应的包装,使controller代码更加简介");
    return findAllUser;
}

至此我们的接口返回响应包装自定义注解实现设计完成,看看代码是不是又简洁,又优雅呢。

总结:本文针对此方案只是进行了简单的实现,如果有兴趣的朋友可以进行更好的优化。

场景二:自定义注解 + AOP = 实现优雅的使用分布式锁

分布式锁的最常见的使用流程:

先看看最为常见的分布式锁使用方式的实现,然后再聊聊自定义注解怎么优雅的实现分布式锁的使用。

普通的分布式锁使用方式:

通过上面的代码可以得到一个信息:如果有很多方法中需要使用分布式锁,那么每个方法中都必须有获取分布式锁和释放分布式锁的代码,这样一来就会出现代码冗余;

那有什么好的解决方案吗? 自定义注解使代码变得更加简洁、优雅;

自定义注解优雅的使用分布式锁:
①、首先实现一个标记分布式锁使用的自定义注解:



@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface GetDistributedLock {

    // 分布式锁 key
    String lockKey();

    // 分布式锁 value,默认为 lockValue
    String lockValue() default "lockValue";

    // 过期时间,默认为 300秒
    int expireTime() default 300;

}

②、定义一个切面,在切面中对使用了 @GetDistributedLock 自定义注解的方法进行环绕增强通知:



@Component
@Aspect
public class DistributedLockAspect {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    RedisService redisService;


    
    @Around(value = "@annotation(com.lyl.annotation.GetDistributedLock)")
    public Boolean handlerDistributedLock(ProceedingJoinPoint joinPoint) {
        // 通过反射获取自定义注解对象
        GetDistributedLock getDistributedLock = ((MethodSignature) joinPoint.getSignature())
                .getMethod().getAnnotation(GetDistributedLock.class);

        // 获取自定义注解对象中的属性值
        String lockKey = getDistributedLock.lockKey();
        String LockValue = getDistributedLock.lockValue();
        int expireTime = getDistributedLock.expireTime();

        if (redisService.tryGetDistributedLock(lockKey, LockValue, expireTime)) {
            // 获取分布式锁成功后,继续执行业务逻辑
            try {
                return (boolean) joinPoint.proceed();
            } catch (Throwable throwable) {
                logger.error("业务逻辑执行失败。", throwable);
            } finally {
                // 最终保证分布式锁的释放
                redisService.releaseDistributedLock(lockKey, LockValue);
            }
        }
        return false;
    }

}

③、最后,在 Controller 中的方法上使用 @GetDistributedLock 自定义注解即可;当某个方法上使用了 自定义注解,那么这个方法就相当于一个切点,那么就会对这个方法做环绕(方法执行前和方法执行后)增强处理;

在浏览器中输入网址: http://127.0.0.1:8080/v1/api/user/getDistributedLock 回车后触发方法执行:


// 自定义注解的使用
@GetDistributedLock(lockKey = "userLock")
@GetMapping("/user/getDistributedLock")
public boolean getUserDistributedLock() {
    logger.info("获取分布式锁...");
    // 写具体的业务逻辑

    return true;
}

通过自定义注解的方式,可以看到代码变得更加简洁、优雅。

场景三:自定义注解 + AOP = 实现日志的打印

先看看最为常见的日志打印的方式,然后再聊聊自定义注解怎么优雅的实现日志的打印。

普通日志的打印方式:

通过看上面的代码可以知道,如果每个方法都需要打印下日志,那将会存在大量的冗余代码;

自定义注解实现日志打印:
①、首先创建一个标记日志打印的自定义注解:



@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface PrintLog {

}

②、定义一个切面,在切面中对使用了 @PrintLog 自定义注解的方法进行环绕增强通知:



@Component
@Aspect
public class PrintLogAspect {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    
    @Around(value = "@annotation(com.lyl.annotation.PrintLog)")
    public Object handlerPrintLog(ProceedingJoinPoint joinPoint) {
        // 获取方法的名称
        String methodName = joinPoint.getSignature().getName();
        // 获取方法入参
        Object[] param = joinPoint.getArgs();

        StringBuilder sb = new StringBuilder();
        for (Object o : param) {
            sb.append(o + "; ");
        }
        logger.info("进入《{}》方法, 参数为: {}", methodName, sb.toString());

        Object object = null;
        // 继续执行方法
        try {
            object = joinPoint.proceed();

        } catch (Throwable throwable) {
            logger.error("打印日志处理error。。", throwable);
        }
        logger.info("{} 方法执行结束。。", methodName);
        return object;
    }

}

③、最后,在 Controller 中的方法上使用 @PrintLog 自定义注解即可;当某个方法上使用了 自定义注解,那么这个方法就相当于一个切点,那么就会对这个方法做环绕(方法执行前和方法执行后)增强处理;


@PrintLog
@GetMapping(value = "/user/findUserNameById/{id}", produces = "application/json;charset=utf-8")
public String findUserNameById(@PathVariable("id") int id) {
    // 模拟根据id查询用户名
    String userName = "木子雷 公众号";
    return userName;
}

④、在浏览器中输入网址: http://127.0.0.1:8080/v1/api/user/findUserNameById/66 回车后触发方法执行,发现控制台打印了日志:

进入《findUserNameById》方法, 参数为: 66; 
findUserNameById 方法执行结束。。

使用自定义注解实现是多优雅,代码看起来简介干净,越瞅越喜欢;赶快去你的项目中使用吧, 嘿嘿。。。

以上就是Java 自定义注解的魅力的详细内容,更多关于Java 自定义注解的资料请关注编程网其它相关文章!

阅读原文内容投诉

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题
  • 2024年上半年信息系统项目管理师第二批次真题及答案解析(完整版)

    难度     813人已做
    查看
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看
  • 2024年上半年软考高项第一、二批次真题考点汇总(完整版)

    难度     435人已做
    查看
  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机
位置:首页-资讯-后端开发
咦!没有更多了?去看看其它编程学习网 内容吧
首页课程
资料下载
问答资讯