脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → SpringBoot自定义注解

SpringBoot自定义注解开发指南

 更新时间：2022年06月02日 16:20:15   作者：爱嘤斯塔  
在开发SpringBoot程序的过程中,有可能与其他业务系统进行对接开发,获取封装公共的API接口等等,下面这篇文章主要给大家介绍了关于SpringBoot自定义注解的相关资料,需要的朋友可以参考下

一、Java注解(Annotation)

含义：Java注解是附加在代码中的一些元信息，用于一些工具在编译、 运行时进行解析和使用，起到说明、配置的功能。

1、JDK基本注解

@Override ——》重写

@Deprecated ——》已过时

@SuppressWarnings(value = "unchecked")  ——》压制编辑器警告

2、JDK元注解

含义：元注解用于修饰其他的注解(纪委：管干部的干部)

①、@Retention ——》定义注解的保留策略

@Retention(RetentionPolicy.SOURCE) //注解仅存在于源码中，在class字节码文件中不包含
@Retention(RetentionPolicy.CLASS)//默认的保留策略，注解会在class字节码文件中存在，但运行时无法获得，
@Retention(RetentionPolicy.RUNTIME)//注解会在class字节码文件中存在，在运行时可以通过反射获取到

②、@Target ——》指定被修饰的Annotation可以放置的位置(被修饰的目标)

      @Target(ElementType.TYPE)  ——》接口、类
      @Target(ElementType.FIELD)   ——》属性
      @Target(ElementType.METHOD)   ——》方法
      @Target(ElementType.PARAMETER)   ——》方法参数
      @Target(ElementType.CONSTRUCTOR)  ——》构造函数
      @Target(ElementType.LOCAL_VARIABLE)  ——》局部变量
      @Target(ElementType.ANNOTATION_TYPE)  ——》注解
      @Target(ElementType.PACKAGE)   ——》包 

 注：可以指定多个位置，如：

@Target({ElementType.METHOD, ElementType.TYPE})，也就是此注解可以在方法和类上面使用

③、@Inherited：指定被修饰的Annotation将具有继承性 

④、@Documented：指定被修饰的该Annotation可以被javadoc工具提取成文档.

二、自定义注解开发

1、含义

使用@interface关键字, 其定义过程与定义接口非常类似, 需要注意的是:

Annotation的成员变量在Annotation定义中是以无参的方法形式来声明的, 其方法名和返回值类型定义了该成员变量的名字和类型, 而且我们还可以使用default关键字为这个成员变量设定默认值

2、演示

①、枚举类：enum，指的是常量的集合

②、注解类

Ⅰ、演示@Retention(RetentionPolicy.SOURCE)注解：MyAnnotation.java

package com.lv.annotation;
import org.springframework.beans.factory.annotation.Autowired;
import java.lang.annotation.*;
/**
 * @author T440s
 */
 
 
//生成一个注释
@Documented
//表示当前注解可以打在什么东西上面,此处可以放在类上与方法上
@Target({ElementType.TYPE,ElementType.METHOD})
//指定被修饰的Annotation将具有继承性
@Inherited
//注解仅存在于源码中，在class字节码文件中不包含
@Retention(RetentionPolicy.SOURCE)
public @interface MyAnnotation {
 
    String value() default "";
}

TestController.java:注意这引用了MyAnnotation注解

package com.lv.controller;
 
import com.lv.annotation.MyAnnotation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
 
@MyAnnotation
@Controller
public class TestController {
 
    @Autowired
    private String name;
 
    @MyAnnotation
    public void aa(){
 
    }
 
}

运行后target层注解消失：注解仅存在于源码中，在class字节码文件中不包含

Ⅱ、MyAnnotation注解为@Retention(RetentionPolicy.RUNTIME)时

        ——注解会在class字节码文件中存在，在运行时可以通过反射获取到

运行test.java:

package com.lv.controller;
 
import java.lang.annotation.Annotation;
 
public class Test {
    public static void main(String[] args) {
//    反射
        for(Annotation a:TestController.class.getAnnotations()){
            System.out.println(a);
        }
 
    }
}

Ⅲ、取注解里的属性值

 注解：MyAnnotation.java

String message() default "aaa";

拿值：

package com.lv.controller;
import com.lv.annotation.MyAnnotation;
import java.lang.annotation.Annotation;
public class Test {
    public static void main(String[] args) {
//    反射
        for(Annotation a:TestController.class.getAnnotations()){
            if(a instanceof MyAnnotation){
                System.out.println(((MyAnnotation) a).message());
            }
        }

    }
}

Ⅳ、判断在该类有无该注解

 测试：

package com.lv.controller;
import com.lv.annotation.MyAnnotation;
import java.lang.annotation.Annotation;
public class Test {
    public static void main(String[] args) {
//        直接将MyAnnotation这注解取出
        MyAnnotation myAnnotation=TestController.class.getAnnotation(MyAnnotation.class);
        if(myAnnotation !=null){
            System.out.println(myAnnotation.message());
        }
 
    }
}

三、完成切面日志操作

当我们在写增删改的时候，会有很多冗余的代码，后期修改很麻烦，如：

 @RequestMapping("/add")
    public String add(){
        System.out.println("xxx在增加");
        System.out.println("增加成功");
        return "yes";
    }

我们就可以定义aop面向切面，将前面那部分放入前置通知，后面一部分后置通知

新建切面：LogAop.java

package com.lv.aop;
 
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
 
@Aspect
//类不被识别，将类变成一个组件
@Component
@Slf4j
 
public class LogAop {
//    指定切入的规则,".."代表可有参可无参
    @Pointcut("execution(* com.lv.controller.*Controller.*(..))")
    public  void logger(){}
 
//    环绕通知
    @Around("logger()")
    public Object around(ProceedingJoinPoint point){
        //        获得方法名称
        Signature methodName=point.getSignature();
//        日志输出
        log.info(methodName+"进来了");
        Long l1=System.currentTimeMillis();
//        让方法执行
        Object obj=null;
        try {
            obj=point.proceed(point.getArgs());
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        log.info(methodName+"走了"+"\t耗时"+(System.currentTimeMillis()-l1));
        return obj;
 
    }
}

使用jrebel运行：

package com.lv.controller;
 
import com.lv.annotation.MyAnnotation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
@MyAnnotation
//直接返回json数据
@RestController
//返回页面跳转数据
//@Controller
public class TestController {
 
    @RequestMapping("/add")
    public String add(){
        return "yes";
    }
 
    @RequestMapping("/del")
    public String del(){
        return "yes";
    }
 
    @RequestMapping("/upd")
    public String upd(){
        return "yes";
    }
 
 
    @RequestMapping("/list")
    public String list(){
        return "yes";
    }
 
}

使用注解来开发aop日志：

新建注解类：MyLog.java

package com.lv.annotation;
 
import java.lang.annotation.*;
 
@Inherited
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyLog {
 
}

 同样在切面类中，记得改变切入的规则

@Pointcut("@annotation(com.lv.annotation.MyLog)")

需要输出日志的方法就将新建的注解加上

四、完成前端响应反应

传入四个文件：

ResponseParse.java:

package com.lv.response;
 
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
 
/**
 * @author hgh
 */
//响应增强类
@RestControllerAdvice
public class ResponseParse implements ResponseBodyAdvice {
 
    @Override
    public boolean supports(MethodParameter methodParameter, Class aClass) {
        //返回值决定他是否需要进入beforeBodyWrite
        return methodParameter.getMethod().isAnnotationPresent(ResponseResult.class);
    }
 
    @Override
    public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType, Class aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
        //更改返回值
        if (o == null) {
            return Result.success();
        }
        if (o instanceof Integer) {
            return Result.failure(ResultCode.queryCode((Integer) o));
        }
        if (o instanceof ResultCode) {
            return Result.failure((ResultCode) o);
        }
        if (o instanceof Result) {
            return o;
        }
        return null;
    }
}

 ResponseResult.java:

package com.lv.response;
 
import java.lang.annotation.*;
 
/**
 * @author hgh
 */
@Retention(value = RetentionPolicy.RUNTIME)
@Documented
@Target({ElementType.METHOD})
public @interface ResponseResult {
 
}

Result.java:

package com.lv.response;
 
import lombok.Data;
 
import java.io.Serializable;
 
/**
 * 响应对象封装类
 *
 * @author hgh
 */
@Data
public class Result<T> implements Serializable {
 
    private final int code;
    private final String message;
    private final T data;
 
    /**
     * 私有构造, 只允许通过static调用构造
     *
     * @param resultCode 结果枚举
     * @param data       响应数据
     */
    private Result(ResultCode resultCode, T data) {
        this.code = resultCode.getCode();
        this.message = resultCode.getMessage();
        this.data = data;
    }
 
    /**
     * 成功调用返回的结果(无数据携带)
     *
     * @return Result
     */
    public static Result success() {
        return success(null);
    }
 
    /**
     * 成功调用返回的结果(数据携带)
     *
     * @return Result
     */
    public static <T> Result success(T data) {
        return new Result(ResultCode.SUCCESS, data);
    }
 
    /**
     * 失败调用返回的结果(数据携带)
     *
     * @param resultCode 状态枚举
     * @param data       携带的数据
     * @return Result
     */
    public static <T> Result failure(ResultCode resultCode, T data) {
        return new Result(resultCode, data);
    }
 
    /**
     * 失败调用返回的结果(无数据携带)
     *
     * @param resultCode 状态枚举
     * @return Result
     */
    public static Result failure(ResultCode resultCode) {
        return failure(resultCode, null);
    }
 
}

ResultCode.java:

package com.lv.response;
 
import java.io.Serializable;
 
/**
 * 响应结果码枚举
 *
 * @author hgh
 */
 
public enum ResultCode implements Serializable {
 
    /* 正常状态 */
    SUCCESS(100, "成功"),
    FAILURE(101, "失败"),
    UNKNOWN(102, "未知响应"),
    /**
     * 用户code范围: 200~300;
     */
    USER_ACCOUNT_NOT_FIND(201, "用户名不存在"),
    USER_ACCOUNT_DISABLED(202, "该用户已被禁用"),
    USER_PASSWORD_NOT_MATCH(203, "该用户密码不一致"),
    USER_PERMISSION_ERROR(204, "该用户不具备访问权限"),
    USER_STATE_OFF_LINE(205, "该用户未登录");
 
    private final Integer code;
    private final String message;
 
    ResultCode(Integer code, String message) {
        this.code = code;
        this.message = message;
    }
 
    public Integer getCode() {
        return code;
    }
 
    public String getMessage() {
        return message;
    }
 
    public static ResultCode queryCode(Integer code) {
        for (ResultCode value : values()) {
            if (code.equals(value.code)) {
                return value;
            }
        }
        return UNKNOWN;
    }
 
}

测试：

package com.lv.controller;
 
import com.lv.annotation.MyAnnotation;
import com.lv.annotation.MyLog;
import com.lv.response.ResponseResult;
import com.lv.response.Result;
import com.lv.response.ResultCode;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
@MyAnnotation
//直接返回json数据
@RestController
//返回页面跳转数据
//@Controller
public class TestController {
 
    @MyLog
    @ResponseResult
    @RequestMapping("/add")
    public Result add(){
        return Result.success("yes");
    }
 
    @RequestMapping("/del")
    @ResponseResult
    public Object del(){
        return 201;
    }
 
    @RequestMapping("/upd")
    @ResponseResult
    public Object upd(){
        return ResultCode.USER_ACCOUNT_NOT_FIND;
    }
 
 
    @RequestMapping("/list")
    @ResponseResult
    public Object list(){
        return Result.success("yes");
    }
 
}

增加： 

删除：

总结

到此这篇关于SpringBoot自定义注解的文章就介绍到这了,更多相关SpringBoot自定义注解内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • Java控制台实现猜拳游戏小游戏

    Java控制台实现猜拳游戏小游戏

    这篇文章主要为大家详细介绍了Java控制台实现猜拳游戏小游戏，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2019-11-11
  • 调用Process.waitfor导致的进程挂起问题及解决

    调用Process.waitfor导致的进程挂起问题及解决

    这篇文章主要介绍了调用Process.waitfor导致的进程挂起问题及解决，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2021-12-12
  • Spring boot 运用策略模式实现避免多次使用if

    Spring boot 运用策略模式实现避免多次使用if

    这篇文章主要介绍了Spring boot 运用策略模式实现避免多次使用if，文章围绕主题展开详细的内容介绍，具有一定的参考价值，需要的小伙伴可以参考一下
    2022-09-09
  • spring-kafka使消费者动态订阅新增的topic问题

    spring-kafka使消费者动态订阅新增的topic问题

    这篇文章主要介绍了spring-kafka使消费者动态订阅新增的topic问题，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2022-12-12
  • SpringBoot框架实现切换启动开发环境和测试环境

    SpringBoot框架实现切换启动开发环境和测试环境

    这篇文章主要介绍了SpringBoot框架实现切换启动开发环境和测试环境，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2021-12-12
  • SpringBoot详解如何实现读写分离

    SpringBoot详解如何实现读写分离

    当响应的瓶颈在数据库的时候,就要考虑数据库的读写分离,当然还可以分库分表,那是单表数据量特别大,当单表数据量不是特别大,但是请求量比较大的时候,就要考虑读写分离了.具体的话,还是要看自己的业务...如果还是很慢,那就要分库分表了...我们这篇就简单讲一下读写分离
    2022-05-05
  • Spring Boot集成Redis实战操作功能

    Spring Boot集成Redis实战操作功能

    这篇文章主要介绍了Spring Boot集成Redis实战操作，包括如何集成redis以及redis的一些优点，本文给大家介绍的非常详细，具有一定的参考借鉴价值,需要的朋友可以参考下
    2018-11-11
  • IDEA 2020.2 +Gradle 6.6.1 + Spring Boot 2.3.4 创建多模块项目的超详细教程

    IDEA 2020.2 +Gradle 6.6.1 + Spring Boot 2.3.4 创建多模块项目的超详细教程

    这篇文章主要介绍了IDEA 2020.2 +Gradle 6.6.1 + Spring Boot 2.3.4 创建多模块项目的教程，本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2020-09-09
  • java使用正则抓取网页邮箱

    java使用正则抓取网页邮箱

    这篇文章主要为大家详细介绍了java使用正则抓取网页邮箱的相关资料，感兴趣的小伙伴们可以参考一下
    2016-05-05
  • springboot接口返回数据类型全面解析

    springboot接口返回数据类型全面解析

    这篇文章主要介绍了springboot接口返回数据类型问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2023-12-12

最新评论