SpringBoot自定义注解实现操作日志记录

最新推荐文章于 2024-04-03 01:48:42 发布
最新推荐文章于 2024-04-03 01:48:42 发布
阅读量6.1k 收藏 32
点赞数 14
分类专栏： Java 文章标签： aop java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44209274/article/details/116267856
版权

SpringBoot自定义日志注解实现方法日志记录和参数获取

前言

我们在日常业务操作中需要记录很多日志，可以在我们需要的方法中对日志进行保存操作，但是对业务代码入侵性大。使用切面针对控制类进行处理灵活度不高，因此我们可以使用自定义注解来针对方法进行日志记录

一、定义注解

1.注解

定义一个 @LogMethod 注解，作用于方法上

  • title：记录标题

  • operatorType：操作类别，这里使用了枚举类

  • isSaveRequestData：默认为true，是否获取请求参数

/**
 * 自定义方法日志记录注解
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface LogMethod {

    /**
     * 记录标题
     */
    public String title() default "";

    /**
     * 操作类别
     */
    public UserStatusCode operatorType() default UserStatusCode.OTHER;

    /**
     * 是否保存请求参数
     */
    public boolean isSaveRequestData() default true;
}

2.枚举类

接口定义了两个方法，一个获取 code 编码，一个获取 desc 描述

public interface ResultStandard {

    int getCode();

    String getDesc();

}

自定义用户操作枚举类，可向数据库存储 描述信息 或者 编码值

public enum UserStatusCode implements ResultStandard {

    OTHER("其他操作", 10),
    USER_QUERY("用户查询", 11),
    USER_EXPORT("用户导出", 12),
    WEA_QUERY("天气查询", 13)
    ;

    private String desc;

    private int code;

    private UserStatusCode(String desc, int code) {
        this.desc = desc;
        this.code = code;
    }

    public String getDesc() {
        return desc;
    }

    public int getCode() {
        return code;
    }
}

二、AOP处理

1.配置织入点

这里使用了后置通知 AfterReturning，在处理完方法后获取到结果数据然后进行处理

/**
 * 方法操作日志记录处理
 */
@Aspect
@Component
public class LogMethodAspect {

    private static final Logger log = LoggerFactory.getLogger(LogMethodAspect.class);

    /**
     * 配置织入点
     */
    @Pointcut("@annotation(com.angel.annotation.LogMethod)")
    public void logMethodPointCut() { }

    /**
     * 处理完请求后执行
     */
    @AfterReturning(pointcut = "logMethodPointCut()", returning = "jsonResult")
    public void doAfterReturning(JoinPoint joinPoint, Object jsonResult) {
        handleLog(joinPoint, null, jsonResult);
    }

    /**
     * 拦截异常操作
     */
    @AfterThrowing(value = "logMethodPointCut()", throwing = "e")
    public void doAfterThrowing(JoinPoint joinPoint, Exception e) {
        handleLog(joinPoint, e, null);
    }

	// 代码在下面...
}

2.处理注解方法

  • 根据 JoinPoint 目标对象，利用反射获取方法名称，方法路径
  • 使用 getAnnotationLog() 方法获取 LogMethod 注解
  • 使用 IP工具类和 Security 可以获取到用户数据和访问的IP
protected void handleLog(final JoinPoint joinPoint, final Exception e, Object jsonResult) {
    try {
        // 获得注解
        LogMethod controllerLog = getAnnotationLog(joinPoint);
        if (controllerLog == null) {
            return;
        }

        Map<String, Object> logMap = new HashMap<String, Object>();

        // 获取当前的用户
        // ...

        // 获取请求IP，网上IP工具类多的ya批
        // ...

        // 获取返回参数
        JSONObject j = JSON.parseObject(JSON.toJSONString(jsonResult));
        String msg = j.getString("message");
        String code = j.getString("status");
        String methodResult = "{\"msg\":\""+msg+"\",\"code\":"+code+"}";
        logMap.put("requestResult", methodResult);

        // 获取请求URL
        logMap.put("requestUrl", ServletUtils.getRequest().getRequestURI());

        // 获取异常信息
        if (e != null) {
            logMap.put("requestError", StringUtils.substring(e.getMessage(), 0, 2000));
        }

        // 获取方法名称
        String className = joinPoint.getTarget().getClass().getName();
        String methodName = joinPoint.getSignature().getName();
        String methodStr = className + "." + methodName + "()";
        logMap.put("method", methodStr);

        // 获取请求方式
        logMap.put("requestMethod",ServletUtils.getRequest().getMethod());

        // 处理设置注解上的参数
        getControllerMethodDescription(joinPoint, controllerLog, logMap);

        // 保存至数据库操作
        System.out.println(logMap);

    } catch (Exception exp) {
        log.error("异常信息:{}", exp.getMessage());
        exp.printStackTrace();
    }
}

/**
 *获取存在的注解
 */
private LogMethod getAnnotationLog(JoinPoint joinPoint) throws Exception {
    Signature signature = joinPoint.getSignature();
    MethodSignature methodSignature = (MethodSignature) signature;
    Method method = methodSignature.getMethod();
    if (method != null) {
        return method.getAnnotation(LogMethod.class);
    }
    return null;
}

3.获取参数

  • 由上一步获取到的注解类，获取到注解的参数以及是否保存请求参数
  • 可以根据 HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE 来得到 REST 风格的参数
/**
 * 获取注解中对方法的描述信息 用于Controller层注解
 */
public void getControllerMethodDescription(JoinPoint joinPoint, LogMethod log, Map<String, Object> logMap) throws Exception {
    // 操作类型
    logMap.put("operatorType", log.operatorType().getDesc());
    // 标题
    logMap.put("title", log.title());
    // 是否需要保存request，参数和值
    if (log.isSaveRequestData()) {
        // 获取参数的信息
        if ("PUT".equals(logMap.get("requestMethod")) || "POST".equals(logMap.get("requestMethod"))) {
            String params = argsArrayToString(joinPoint.getArgs());
            logMap.put("requestParams", StringUtils.substring(params, 0, 2000));
        } else {
            Map<?, ?> paramsMap = (Map<?, ?>) ServletUtils.getRequest().getAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE);
            logMap.put("requestParams", StringUtils.substring(paramsMap.toString(), 0, 2000));
        }
    }
}

/**
 * 参数拼装
 */
private String argsArrayToString(Object[] paramsArray) {
    String params = "";
    if (paramsArray != null && paramsArray.length > 0) {
        for (int i = 0; i < paramsArray.length; i++) {
            if (!isFilterObject(paramsArray[i])) {
                Object jsonObj = JSON.toJSON(paramsArray[i]);
                params += jsonObj.toString() + " ";
            }
        }
    }
    return params.trim();
}

4.完整切面处理代码

完整代码如下，需要用到 ServletUtils 工具类

package com.angel.aspect;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.angel.annotation.LogMethod;
import com.angel.util.ServletUtils;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.HandlerMapping;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

/**
 * 方法操作日志记录处理
 */
@Aspect
@Component
public class LogMethodAspect {

    private static final Logger log = LoggerFactory.getLogger(LogMethodAspect.class);

    /**
     * 配置织入点
     */
    @Pointcut("@annotation(com.angel.annotation.LogMethod)")
    public void logMethodPointCut() { }

    /**
     * 处理完请求后执行
     */
    @AfterReturning(pointcut = "logMethodPointCut()", returning = "jsonResult")
    public void doAfterReturning(JoinPoint joinPoint, Object jsonResult) {
        handleLog(joinPoint, null, jsonResult);
    }

    /**
     * 拦截异常操作
     */
    @AfterThrowing(value = "logMethodPointCut()", throwing = "e")
    public void doAfterThrowing(JoinPoint joinPoint, Exception e) {
        handleLog(joinPoint, e, null);
    }

    protected void handleLog(final JoinPoint joinPoint, final Exception e, Object jsonResult) {
        try {
            // 获得注解
            LogMethod controllerLog = getAnnotationLog(joinPoint);
            if (controllerLog == null) {
                return;
            }

            Map<String, Object> logMap = new HashMap<String, Object>();

            // 获取当前的用户
            // ...

            // 获取请求IP，网上IP工具类多的ya批
            // ...

            // 获取返回参数
            JSONObject j = JSON.parseObject(JSON.toJSONString(jsonResult));
            String msg = j.getString("message");
            String code = j.getString("status");
            String methodResult = "{\"msg\":\""+msg+"\",\"code\":"+code+"}";
            logMap.put("requestResult", methodResult);

            // 获取请求URL
            logMap.put("requestUrl", ServletUtils.getRequest().getRequestURI());

            // 获取异常信息
            if (e != null) {
                logMap.put("requestError", StringUtils.substring(e.getMessage(), 0, 2000));
            }

            // 获取方法名称
            String className = joinPoint.getTarget().getClass().getName();
            String methodName = joinPoint.getSignature().getName();
            String methodStr = className + "." + methodName + "()";
            logMap.put("method", methodStr);

            // 获取请求方式
            logMap.put("requestMethod",ServletUtils.getRequest().getMethod());

            // 处理设置注解上的参数
            getControllerMethodDescription(joinPoint, controllerLog, logMap);

            // 保存至数据库操作
            System.out.println(logMap);

        } catch (Exception exp) {
            log.error("异常信息:{}", exp.getMessage());
            exp.printStackTrace();
        }
    }

    /**
     * 获取注解中对方法的描述信息 用于Controller层注解
     */
    public void getControllerMethodDescription(JoinPoint joinPoint, LogMethod log, Map<String, Object> logMap) throws Exception {
        // 操作类型
        logMap.put("operatorType", log.operatorType().getDesc());
        // 标题
        logMap.put("title", log.title());
        // 是否需要保存request，参数和值
        if (log.isSaveRequestData()) {
            // 获取参数的信息
            if ("PUT".equals(logMap.get("requestMethod")) || "POST".equals(logMap.get("requestMethod"))) {
                String params = argsArrayToString(joinPoint.getArgs());
                logMap.put("requestParams", StringUtils.substring(params, 0, 2000));
            } else {
                Map<?, ?> paramsMap = (Map<?, ?>) ServletUtils.getRequest().getAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE);
                logMap.put("requestParams", StringUtils.substring(paramsMap.toString(), 0, 2000));
            }
        }
    }

    /**
     * 获取存在的注解
     */
    private LogMethod getAnnotationLog(JoinPoint joinPoint) throws Exception {
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method method = methodSignature.getMethod();
        if (method != null) {
            return method.getAnnotation(LogMethod.class);
        }
        return null;
    }

    /**
     * 参数拼装
     */
    private String argsArrayToString(Object[] paramsArray) {
        String params = "";
        if (paramsArray != null && paramsArray.length > 0) {
            for (int i = 0; i < paramsArray.length; i++) {
                if (!isFilterObject(paramsArray[i])) {
                    Object jsonObj = JSON.toJSON(paramsArray[i]);
                    params += jsonObj.toString() + " ";
                }
            }
        }
        return params.trim();
    }

    /**
     * 判断是否需要过滤的对象。
     */
    @SuppressWarnings("rawtypes")
    public boolean isFilterObject(final Object o) {
        Class<?> clazz = o.getClass();
        if (clazz.isArray()) {
            return clazz.getComponentType().isAssignableFrom(MultipartFile.class);
        } else if (Collection.class.isAssignableFrom(clazz)) {
            Collection collection = (Collection) o;
            for (Iterator iter = collection.iterator(); iter.hasNext(); ) {
                return iter.next() instanceof MultipartFile;
            }
        } else if (Map.class.isAssignableFrom(clazz)) {
            Map map = (Map) o;
            for (Iterator iter = map.entrySet().iterator(); iter.hasNext(); ) {
                Map.Entry entry = (Map.Entry) iter.next();
                return entry.getValue() instanceof MultipartFile;
            }
        }
        return o instanceof MultipartFile || o instanceof HttpServletRequest || o instanceof HttpServletResponse;
    }
}

三、工具类

需要用到的Servlet工具 ServletUtils 类如下，也可以在任意请求处理方法内调用该类，例如

  • getRequest：获取请求对象

  • renderString：渲染给客户端数据

  • getParameter：获取参数

package com.angel.util;

import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

/**
 * 客户端工具类
 */
public class ServletUtils {
    /**
     * 获取String参数
     */
    public static String getParameter(String name) {
        return getRequest().getParameter(name);
    }

    /**
     * 获取String参数
     */
    public static String getParameter(String name, String defaultValue) {
        Object value = getRequest().getParameter(name);
        return value == null ? defaultValue : (String) value;
    }

    /**
     * 获取Integer参数
     */
    public static Integer getParameterToInt(String name) {
        return getParameterToInt(name, null);
    }

    /**
     * 获取Integer参数
     */
    public static Integer getParameterToInt(String name, Integer defaultValue) {
        Object value = getRequest().getParameter(name);
        if (value == null) {
            return defaultValue;
        }
        try {
            return Integer.parseInt(value.toString());
        } catch (Exception e) {
            return defaultValue;
        }

    }

    /**
     * 获取request
     */
    public static HttpServletRequest getRequest() {
        return getRequestAttributes().getRequest();
    }

    /**
     * 获取response
     */
    public static HttpServletResponse getResponse() {
        return getRequestAttributes().getResponse();
    }

    /**
     * 获取session
     */
    public static HttpSession getSession() {
        return getRequest().getSession();
    }

    public static ServletRequestAttributes getRequestAttributes() {
        RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
        return (ServletRequestAttributes) attributes;
    }

    /**
     * 将字符串渲染到客户端
     */
    public static String renderString(HttpServletResponse response, String string) {
        try {
            response.setStatus(200);
            response.setContentType("application/json");
            response.setCharacterEncoding("utf-8");
            response.getWriter().print(string);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 是否是Ajax异步请求
     */
    public static boolean isAjaxRequest(HttpServletRequest request) {
        String accept = request.getHeader("accept");
        if (accept != null && accept.indexOf("application/json") != -1) {
            return true;
        }

        String xRequestedWith = request.getHeader("X-Requested-With");
        if (xRequestedWith != null && xRequestedWith.indexOf("XMLHttpRequest") != -1) {
            return true;
        }

        String uri = request.getRequestURI();
        if (inStringIgnoreCase(uri, ".json", ".xml")) {
            return true;
        }

        String ajax = request.getParameter("__ajax");
        if (inStringIgnoreCase(ajax, "json", "xml")) {
            return true;
        }
        return false;
    }

    /**
     * 需要用到的转换方法，是否包含字符串
     */
    public static boolean inStringIgnoreCase(String str, String... strs) {
        if (str != null && strs != null) {
            for (String s : strs) {
                if (str.equalsIgnoreCase(s == null ? "" : s.trim())) {
                    return true;
                }
            }
        }
        return false;
    }
}

总结

来发送个GET请求吧，使用@PathVariable获取参数，参数名为dayCount

@GetMapping("/dayinfo/{dayCount}")
@LogMethod(title = "获取未来天气预报", operatorType = UserStatusCode.WEA_QUERY)
@ApiOperation(value = "获取未来天气预报", notes = "获取未来天气预报", response = Result.class)
// 方法省略...

在这里插入图片描述
来看下 logMap 的内容

在这里插入图片描述
最后把Map对象换成大家自己的操作日志实体类，然后就可以对其进行对心所欲的 插入 操作了，咳咳…
当然要插入到数据库，有瘾的话Redis也可以。实体类在手，日志你有

LauSET
关注
  • 14
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
自定义日志注解（可获取方法名、参数等）
mail_liuxing的专栏
11-11 3288
自定义注解记录日志，可以获取方法名、参数名、参数值等；
大聪明教你学Java | Spring Boot 使用自定义注解实现操作日志的记录
热门推荐
不肯过江东丶
12-22 1万+
大聪明带你学习如何利用自定义注解提升编码效率，提高代码逼格~
SpringBoot+AOP+自定义注解，实现日志记录/权限验证
lianaozhe的博客
12-30 1651
为什么要通过AOP来实现日志记录在业务处理中，我们经常需要将一些用户操作、或系统日志记录到数据库中，并在后台做展示。一般情况下我们需要在每个需要进行记录的业务方法中做sql操作，这样一来日志记录这种非业务层面的代码就会和业务代码耦合，显得非常难看。那么有没有一种优雅记录日志的办法呢？当然是有的，以下介绍一种基于自定义注解的使用AOP来记录日志的办法。描述。
Springboot自定义注解实现操作日志管理，面试篇
2401_83620841的博客
04-02 1086
这份文档从构建一个键值数据库的关键架构入手，不仅带你建立起全局观，还帮你迅速抓住核心主线。除此之外，还会具体讲解数据结构、线程模型、网络框架、持久化、主从同步和切片集群等，帮你搞懂底层原理。相信这对于所有层次的Redis使用者都是一份非常完美的教程了。你的支持，我的动力；祝各位前程似锦，offer不断！！！截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新**如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）
java入参为方法_Springboot自定义注解打印方法入参
weixin_39543655的博客
01-25 406
Springboot自定义注解打印方法入参1. 背景2. maven配置3. 自定义注解4. 配置AOP切面5. 使用自定义注解打印1. 背景 在开发过程中需要对程序进行大量的日志打印，其中就包括对方法入参以及返回值的打印，如果每个方法的入参以及出参都手动打印日志，不仅会有大量重复代码，同时代码会比较丑陋，可读性降低，所以需要一个切面来帮助打印日志，这时候就需要我们自己去定义一个自定义注...
springboot 自定义注解，Log类注解
新一的技术笔记
07-09 7599
1.切面日志注解 最近看别人的自定义注解还是很优秀，再次一边学习一边解析一下 日志服务用的@Slf4j 作为服务支持 1.1 Log自定义注解 @Inherited @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.METHOD}) public @interface AroundLog { AroundLogMe...
spring aop 自定义注解保存操作日志到mysql数据库 源码
11-25
4、想看spring aop 注解实现记录系统日志并入库等 二、能学到什么 1、收获可用源码 2、能够清楚的知道如何用spring aop实现自定义注解以及注解的逻辑实现 （需要知道原理的请看spring aop源码，此处不做赘述） 3、...
springboot 脱敏自定义注解
03-25
springboot 脱敏自定义注解 SpringAOP
springBoot+aop+自定义注解+本地线程实现统一接口日志及接口响应时长
02-01
内容概要：springboot+拦截器+aop+自定义注解+本地线程实现统一接口日志记录，记录下接口所在模块、接口描述、接口请求参数、接口返回参数、接口请求时间以及接口耗时用于接口优化，接口记录参数以及操作人防止使用...
如何优雅地在 Spring Boot 中使用自定义注解，AOP 切面统一打印出入参日志 | 修订版…
01-06
今天主要说说如何通过自定义注解的方式，在 Spring Boot 中来实现 AOP 切面统一打印出入参日志。小伙伴们可以收藏一波。 废话不多说，进入正题 ！ 目录 一、先看看切面日志输出效果 二、添加 AOP Maven
SpringBoot使用AOP+注解实现简单的权限验证的方法
08-25
具体来说，可以使用 SpringAOP 框架来实现环绕通知（around advice），以拦截请求并判断该方法是否有自定义注解。 自定义注解 首先，需要定义一个自定义注解，用于标记需要权限验证的方法。例如： ```java @Target...
springboot高级功能（四）业务实战，自定义注解收集操作日志
小鲍侃java
01-29 767
公司小伙伴写了一个自定义注解，有注解，不进行AOP打印。 注解 @Target({ElementType.PARAMETER, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface ArchivesLog { /** * 要执行的操作名称 */...
SpringBoot实现AOP日志功能（自定义注解的使用）
m0_73311735的博客
09-23 1703
面向切面编程)：是指将那些与业务无关，却被多个业务模块所共同调用逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，提升系统的可维护性。/*** @Description: 自定义系统操作注解*///操作模块//操作方法//操作描述}复制代码/*** @Description: aop日志具体实现*/@Aspect@Component。
Springboot使用@Aspect、自定义注解记录日志
拾一二的博客
01-31 2406
本文主要为直接copy的工具类，开箱即用
SpringBoot通过AOP实现系统日志记录（一）-Controller层日志监控（包括系统日志监控）
最新发布
2401_84010497的博客
04-03 371
学习视频：《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门即可获取！、讲解视频，并且会持续更新！**如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）学习视频：[外链图片转存中…(img-yMCih049-1712080082586)]大厂面试真题：[外链图片转存中…(img-UtJSJPRc-1712080082587)]《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门即可获取！
注解机制
qq_39447324的博客
03-27 161
注解也叫元数据，例如常见的@Override和@Deprecated，注解是JDK1.5版本开始引入的一个特性，用于对代码进行说明 一般注解可以分为三类： 、一类是java自带的标准注解，包括@Override、@Deprecated和@SuppressWarnings，分别用于表明重写某个方法，表明某个方法或类过时、表明要忽略的警告，这些注解标明后编译器会进行检查。 、 一类为元注解，...
SpringBoot 自定义日志注解
daixinmei
07-28 502
@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) @Documented public @interface LogPrint { String description() default ""; } @Slf4j @Aspect @Component public class LogPrintAspect { /** * 以自定义 @LogPrint 注解为切点 */ @Point
Springboot中自定义注解，实现日志记录
qq_42867665的博客
07-28 1万+
Springboot自定义注解分了两个部分1.定义注解，2.Aop实现注解
【Spring】AOP的开发——织入配置
丧心病狂Loli控的博客
03-09 934
相关术语 Target（目标对象） Proxy（代理对象） Advice（通知/增强） Joinpoint（连接点）：可以被增强的方法叫连接点 Pointcut（切入点）：实际被增强的方法叫切入点 Aspect（切面）：切点+通知 Weaving（织入）：切点+通知结合生成代理的过程     开发事项 ▍需要编写/配置的内容？ 编写目标类和目标方法 编写切面类和增强方法 配置织入关系，告诉Spring哪些切点与哪些通知结合 ▍请简述SpringAOP的过程？ Spring会自动监控
springboot 自定义注解
08-11
SpringBoot中可以自定义注解来实现特定的功能。自定义注解的步骤如下： 1. 使用`@interface`关键字来定义注解，可以在注解中设置属性。 2. 可以通过注解的属性来传递参数，比如设置注解中的属性值。 3. 可以通过判断某个类是否有特定注解来进行相应的操作。 在SpringBoot中，自定义注解可以用于实现日志记录、定时器等功能。通过使用注解，可以简化代码，并提高开发效率。同时，自定义注解也是Spring框架中广泛应用的一种方式，可以在SpringMVC框架中使用注解来配置各种功能。而在SpringBoot框架中，更是将注解的使用推向了极致，几乎将传统的XML配置都替换为了注解。因此，对于SpringBoot来说，自定义注解是非常重要的一部分。123 #### 引用[.reference_title] - *1* *3* [springboot 自定义注解（含源码）](https://blog.csdn.net/yb546822612/article/details/88116654)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT0_1"}} ] [.reference_item] - *2* [SpringBoot-自定义注解](https://blog.csdn.net/weixin_44809337/article/details/124366325)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT0_1"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值