利用AOP做一个完善的日志LogAspect切入以SpringBoot为框架基础

最新推荐文章于 2023-02-15 09:59:16 发布
最新推荐文章于 2023-02-15 09:59:16 发布
阅读量1k 收藏 5
点赞数
分类专栏： SpringBoot 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42477252/article/details/109682816
版权

利用AOP做一个完善的日志LogAspect切入以SpringBoot为框架基础

 

日常的记录日志，不会还有人还在每个方法都重复书写log.info log....，还有些更初级的sout 哈哈哈，我们要学会用Spring中的利器，那就是AOP思想，替我们把这些重复的工作做了。AOP思想其实我们接触得很多了，像日志记录，权限控制，事务管理啊，基本都用过，里面运用的核心就是AOP。具体AOP详细的介绍和使用我这里就不赘述了，网上有很多资料。

今天我想学做个比较细致些的日志记录方式

以SpringBoot为基础

1.先导入需要使用到包

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.70</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

2.准备好需要使用到工具类，CommonUtil,GetUserUtils,RequestHolder,StringUtil,ThrowableUtil

CommonUtil

import javax.servlet.http.HttpServletRequest;
import java.net.InetAddress;
import java.net.UnknownHostException;


public class CommonUtil {



        private static final String UNKNOWN = "unknown";


        /**
         * 获取ip地址
         */
        public static String getIp(HttpServletRequest request) {
            String ip = request.getHeader("x-forwarded-for");
            if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
                ip = request.getHeader("Proxy-Client-IP");
            }
            if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
                ip = request.getHeader("WL-Proxy-Client-IP");
            }
            if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
                ip = request.getRemoteAddr();
            }
            String comma = ",";
            String localhost = "127.0.0.1";
            if (ip.contains(comma)) {
                ip = ip.split(",")[0];
            }
            if  (localhost.equals(ip))  {
                // 获取本机真正的ip地址
                try {
                    ip = InetAddress.getLocalHost().getHostAddress();
                } catch (UnknownHostException e) {
                    e.printStackTrace();
                }
            }
            return ip;
        }


        public static String getUserAgent(HttpServletRequest request){

            return request.getHeader("User-Agent");
        }

}

GetUserUtils

public class GetUserUtils {

    public static User getCurrentUser(){
        return new User("123","admin");
    }
}

RequestHolder

public class RequestHolder {

    public static HttpServletRequest getHttpServletRequest(){
        return ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getRequest();
    }
}

StringUtil

public class StringUtil {
    /** 空字符串 */
    private static final String NULLSTR = "";

    /**
     * 截取字符串
     *
     * @param str 字符串
     * @param start 开始
     * @param end 结束
     * @return 结果
     */
    public static String substring(final String str, int start, int end)
    {
        if (str == null)
        {
            return NULLSTR;
        }

        if (end < 0)
        {
            end = str.length() + end;
        }
        if (start < 0)
        {
            start = str.length() + start;
        }

        if (end > str.length())
        {
            end = str.length();
        }

        if (start > end)
        {
            return NULLSTR;
        }

        if (start < 0)
        {
            start = 0;
        }
        if (end < 0)
        {
            end = 0;
        }

        return str.substring(start, end);
    }


}

ThrowableUtil

public class ThrowableUtil {

    /**log.setExceptionDetail(ThrowableUtil.getStackTrace(e).getBytes());
     * 获取堆栈信息
     */
    public static String getStackTrace(Throwable throwable){
        StringWriter sw = new StringWriter();
        try (PrintWriter pw = new PrintWriter(sw)) {
            throwable.printStackTrace(pw);
            return sw.toString();
        }
    }
}

3.准备实体类

@Data
public class OperationLog {
    private String operId;//主键
    private String module;//功能模块
    private String type;//操作类型
    private String requestMethod;//请求方式
    private String operDesc;//操作描述
    private String operUserAgent;//操作描述
    private String operRequstParam;//请求参数
    private String operResponseParam;//返回参数
    private String operUserId;//操作员id
    private String operUsername;//操作员名称
    private String operLocation;//操作地点
    private Integer status;//操作状态
    private String operMethod;//操作方法
    private String operURL;//请求URL
    private String operIp;//请求ID
    private String excName;//异常名称
    private String errorMsg;//错误信息
    private Date createTime;//操作时间
    private Long costTime;//耗时


}
@Data
public class User {
    private String userId;
    private String username;

    public User(String userId, String username) {
        this.userId = userId;
        this.username = username;
    }
}

4.准备注解 用于 标注需要 切入的点

@Target(ElementType.METHOD) //注解放置的目标位置,METHOD是可注解在方法级别上
@Retention(RetentionPolicy.RUNTIME) //注解在哪个阶段执行
public @interface Log {
    String operModule() default ""; // 操作模块
    OperType operType() default OperType.ADD;  // 操作类型
    String operDesc() default "";  // 操作说明

}
public enum OperType {

    //操作类型
    TEST("测试"),
    ADD("新增"),DELETE("删除"),QUERY("查询")
    ;

    private String type;

    OperType(String type) {
        this.type = type;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

5.主角上场 operLogAspect

@Aspect
@Component
@Slf4j
public class OperLogAspect {

    ThreadLocal<Long> currentTime = new ThreadLocal<>();
    /**
     * 设置操作日志切入点 记录操作日志 在注解的位置切入代码
     */
    @Pointcut("@annotation(com.example.operlog.annotation.Log)")
    public void operLogPointCut() {
    }

    /**
     * 设置操作异常切入点记录异常日志 扫描所有controller包下操作
     */
    @Pointcut("execution(* com.example.operlog.controller..*.*(..))")
    public void operExceptionLogPointCut() {
    }

    @Around("operLogPointCut()")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        Object result;
        currentTime.set(System.currentTimeMillis());
        //正常处理开始
        result = joinPoint.proceed();
        //正常处理结束
        Long time=System.currentTimeMillis() - currentTime.get();
        currentTime.remove();

        handleLog(joinPoint,null,result,time);

        return result;
    }


    @AfterThrowing(pointcut = "operExceptionLogPointCut()", throwing = "e")
    public void logAfterThrowing(JoinPoint joinPoint, Exception e) {
       handleLog(joinPoint,e,null,null);
    }

    protected void handleLog(final JoinPoint joinPoint, final Exception e, Object jsonResult,Long time){
        try
        {

            // 获取RequestAttributes
   /*         RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
            // 从获取RequestAttributes中获取HttpServletRequest的信息
            HttpServletRequest request = (HttpServletRequest) requestAttributes
                    .resolveReference(RequestAttributes.REFERENCE_REQUEST);*/
            HttpServletRequest request = RequestHolder.getHttpServletRequest();

            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();
            //获取注解
            Log  aopLog = method.getAnnotation(Log.class);


            // 获取当前的用户
            User currentUser = GetUserUtils.getCurrentUser();

            OperationLog operLog = new OperationLog();
            String id = UUID.randomUUID().toString().replaceAll("-", "");
            operLog.setOperId(id);
            operLog.setOperURL(request.getRequestURI());
            operLog.setStatus(1);//成功
            operLog.setCreateTime(new Date());
            operLog.setCostTime(time);
            operLog.setOperUserAgent(CommonUtil.getUserAgent(request));
            // 请求的地址
            operLog.setOperIp(CommonUtil.getIp(request));

            // 返回参数
            operLog.setOperResponseParam(JSON.toJSONString(jsonResult));

            if (currentUser != null)
            {
                operLog.setOperUserId(currentUser.getUserId());
                operLog.setOperUsername(currentUser.getUsername());
            }
            // 设置方法名称
            String className = joinPoint.getTarget().getClass().getName();
            String methodName = joinPoint.getSignature().getName();
            //设置请求方法名
            operLog.setOperMethod(className + "." + methodName + "()");
            // 设置请求方式GET..
            operLog.setRequestMethod(request.getMethod());
            // 处理设置注解上的参数
            getControllerMethodDescription(joinPoint, aopLog, operLog);

            //利用是否有异常定性记录失败信息
            if (e != null)
            {
                operLog.setStatus(0);//失败
                operLog.setExcName(e.getClass().getName());
                operLog.setErrorMsg(ThrowableUtil.getStackTrace(e));

                log.error("耗时:{}  用户id:{}   用户名username: {}  请求ip:{}  User-Agent:{} 方法路径:{} 方法参数:{}",
                        operLog.getCostTime(),
                        operLog.getOperUserId(),
                        operLog.getOperUsername(),
                        operLog.getOperId(),
                        operLog.getOperUserAgent(),
                        methodName,
                        operLog.getOperRequstParam());
                log.error("==控制层方法通知异常==");
                log.error("异常信息:{}", e.getMessage());
                //e.printStackTrace();
                return;
            }
            log.info(JSON.toJSONString(operLog));
            // 保存数据库
            //可以借助异步持久化AsyncManager.me().execute(AsyncFactory.recordOper(operLog));
            log.info("耗时:{}  用户id:{}   用户名username: {}  请求ip:{}  User-Agent:{} 方法路径:{} 方法参数:{}",
                    operLog.getCostTime(),
                    operLog.getOperUserId(),
                    operLog.getOperUsername(),
                    operLog.getOperId(),
                    operLog.getOperUserAgent(),
                    methodName,
                    operLog.getOperRequstParam());
        }
        catch (Exception exp)
        {
            // 记录本地异常日志
            log.error("==前置通知异常==");
            log.error("异常信息:{}", exp.getMessage());
            exp.printStackTrace();
        }

    }

    /**
     * 获取注解中对方法的描述信息 用于Controller层注解
     *
     * @param log 日志
     * @param operLog 操作日志
     * @throws Exception
     */
    public void getControllerMethodDescription(JoinPoint joinPoint, Log log, OperationLog operLog) throws Exception
    {
        if(log!=null){
            operLog.setModule(log.operModule());
            operLog.setType(log.operType().getType());
            operLog.setOperDesc(log.operDesc());
        }else {
            //用于无注解的控制层方法 异常抛出 记录
            operLog.setModule("无默认模块");
            operLog.setType("无默认类别");
            operLog.setOperDesc("无默认描述");
        }

        // 获取参数的信息
        setRequestValue(joinPoint, operLog);
    }

    /**
     * 获取请求的参数，放到log中
     *
     * @param operLog 操作日志
     * @throws Exception 异常
     */
    private void setRequestValue(JoinPoint joinPoint, OperationLog operLog) throws Exception
    {
        String params = argsArrayToString(joinPoint.getArgs());
        //避免过长的无用信息
        operLog.setOperRequstParam(StringUtil.substring(params, 0, 2000));
    }
    /**
     * 参数拼装
     */
    private String argsArrayToString(Object[] paramsArray)
    {
        StringBuilder params = new StringBuilder();
        if (paramsArray != null && paramsArray.length > 0)
        {
            for (int i = 0; i < paramsArray.length; i++)
            {

                //排除不需要记录的参数
                if (!isFilterObject(paramsArray[i])){

                    Object value=paramsArray[i];
                    if (value instanceof MultipartFile) {
                        MultipartFile file = (MultipartFile) value;
                        Object jsonObj = JSON.toJSON(file.getOriginalFilename());
                        params.append(jsonObj.toString()).append(" ");
                    }
                    else if (value instanceof MultipartFile[]) {
                        MultipartFile[] files = (MultipartFile[]) value;
                        for(MultipartFile file:files){
                            Object jsonObj = JSON.toJSON(file.getOriginalFilename());
                            params.append(jsonObj.toString()).append(" ");
                        }
                    }else{
                        Object jsonObj = JSON.toJSON(value);
                        params.append(jsonObj.toString()).append(" ");
                    }
                }
            }
        }
        return params.toString();
    }


    /**
     * 判断是否需要过滤
     * @param o 对象信息。
     * @return 是需要过滤的对象，则返回true；否则返回false。
     */
    public boolean isFilterObject(final Object o)
    {
        return o instanceof HttpServletRequest || o instanceof HttpServletResponse;
    }





/*
    //用于未定义log注解，抛出异常也需要记录耗时情况
    @Before("operExceptionLogPoinCut()")
    public void beforeMethod(JoinPoint joinPoint){
        currentTime.set(System.currentTimeMillis());
    }
    @After("operExceptionLogPoinCut()")
    public void afterMethod(JoinPoint joinPoint){
        currentTime.remove();
    }*/

}

6.用于测试的controller

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

    //在带注解，抛出异常
    @GetMapping("/1")
    @Log(operModule = "查询",operDesc = "就查查而已",operType = OperType.QUERY)
    public void get(){
        throw new RuntimeException("test");

    }
    //注解，正常执行
    @GetMapping("/2")
    @Log(operModule = "查询",operDesc = "就查查而已222222",operType = OperType.QUERY)
    public void get2(){
        System.out.println("=======get2");

    }
    //不带注解，抛出异常
    @GetMapping("/3")
    public void get3(){
        throw new RuntimeException("get3");

    }
    //不带注解，正常执行与返回数据
    @GetMapping("/4")
    public Object get4(){
        System.out.println("=======get4");
        return new User("123","aaaaaa");
    }
    //带文件参数测试
    @PostMapping("/file")
    @Log
    public void uploadFile(String param,MultipartFile[] file){
        System.out.println("=======upload file");
    }
    @PostMapping("/file1")
    @Log
    public void uploadFile1(@RequestBody User param){
        System.out.println("=======upload file1");
    }
}

测试结果

test/1

2020-11-14 14:19:46.808 ERROR 52588 --- [nio-8080-exec-9] com.example.operlog.aop.OperLogAspect    : 耗时:null  用户id:123   用户名username: admin  请求ip:547985c7451d4aeaa7632f57cf128044  User-Agent:Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36 方法路径:get 方法参数:
2020-11-14 14:19:46.808 ERROR 52588 --- [nio-8080-exec-9] com.example.operlog.aop.OperLogAspect    : ==控制层方法通知异常==
2020-11-14 14:19:46.808 ERROR 52588 --- [nio-8080-exec-9] com.example.operlog.aop.OperLogAspect    : 异常信息:test
2020-11-14 14:19:46.818 ERROR 52588 --- [nio-8080-exec-9] o.a.c.c.C.[.[.[/].[dispatcherServlet]    : Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed; nested exception is java.lang.RuntimeException: test] with root cause

java.lang.RuntimeException: test
	at com.example.operlog.controller.TestController.get(TestController.java:27) ~[classes/:na]

test/2

2020-11-14 14:22:12.976  INFO 52588 --- [nio-8080-exec-2] com.example.operlog.aop.OperLogAspect    : {"costTime":0,"createTime":1605334932952,"module":"查询","operDesc":"就查查而已222222","operId":"ec33d56eb10a442cbb75663034575544","operIp":"0:0:0:0:0:0:0:1","operLocation":"内网IP","operMethod":"com.example.operlog.controller.TestController.get2()","operRequstParam":"","operResponseParam":"null","operURL":"/test/2","operUserAgent":"Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36","operUserId":"123","operUsername":"admin","requestMethod":"GET","status":1,"type":"查询"}
2020-11-14 14:22:12.977  INFO 52588 --- [nio-8080-exec-2] com.example.operlog.aop.OperLogAspect    : 耗时:0  用户id:123   用户名username: admin  请求ip:ec33d56eb10a442cbb75663034575544  User-Agent:Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36 方法路径:get2 方法参数:

test/3

2020-11-14 14:23:09.488 ERROR 52588 --- [nio-8080-exec-5] com.example.operlog.aop.OperLogAspect    : 耗时:null  用户id:123   用户名username: admin  请求ip:eba1a0c0dd1f43ba999416a29202c497  User-Agent:Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36 方法路径:get3 方法参数:
2020-11-14 14:23:09.488 ERROR 52588 --- [nio-8080-exec-5] com.example.operlog.aop.OperLogAspect    : ==控制层方法通知异常==
2020-11-14 14:23:09.488 ERROR 52588 --- [nio-8080-exec-5] com.example.operlog.aop.OperLogAspect    : 异常信息:get3
2020-11-14 14:23:09.489 ERROR 52588 --- [nio-8080-exec-5] o.a.c.c.C.[.[.[/].[dispatcherServlet]    : Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed; nested exception is java.lang.RuntimeException: get3] with root cause

java.lang.RuntimeException: get3

test/file

=======upload file
2020-11-14 14:25:14.444  INFO 52588 --- [nio-8080-exec-5] com.example.operlog.aop.OperLogAspect    : {"costTime":0,"createTime":1605335114443,"module":"","operDesc":"","operId":"372f9bfad79b4938b2424dda659cfc89","operIp":"0:0:0:0:0:0:0:1","operLocation":"内网IP","operMethod":"com.example.operlog.controller.TestController.uploadFile()","operRequstParam":"123 2 (1).png 312312312.png ","operResponseParam":"null","operURL":"/test/file","operUserAgent":"PostmanRuntime/6.1.6","operUserId":"123","operUsername":"admin","requestMethod":"POST","status":1,"type":"新增"}
2020-11-14 14:25:14.444  INFO 52588 --- [nio-8080-exec-5] com.example.operlog.aop.OperLogAspect    : 耗时:0  用户id:123   用户名username: admin  请求ip:372f9bfad79b4938b2424dda659cfc89  User-Agent:PostmanRuntime/6.1.6 方法路径:uploadFile 方法参数:123 2 (1).png 312312312.png

test/file1

=======upload file1
2020-11-14 14:25:53.541  INFO 52588 --- [nio-8080-exec-6] com.example.operlog.aop.OperLogAspect    : {"costTime":0,"createTime":1605335153537,"module":"","operDesc":"","operId":"dd808ebd88a34b83996b72f22e48a351","operIp":"0:0:0:0:0:0:0:1","operLocation":"内网IP","operMethod":"com.example.operlog.controller.TestController.uploadFile1()","operRequstParam":"{\"userId\":\"123\",\"username\":\"222\"} ","operResponseParam":"null","operURL":"/test/file1","operUserAgent":"PostmanRuntime/6.1.6","operUserId":"123","operUsername":"admin","requestMethod":"POST","status":1,"type":"新增"}
2020-11-14 14:25:53.541  INFO 52588 --- [nio-8080-exec-6] com.example.operlog.aop.OperLogAspect    : 耗时:0  用户id:123   用户名username: admin  请求ip:dd808ebd88a34b83996b72f22e48a351  User-Agent:PostmanRuntime/6.1.6 方法路径:uploadFile1 方法参数:{"userId":"123","username":"222"}

 

热水养鲨鱼
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java项目中基于AOP注解方式实现接口日志记录
Jnsone的博客
04-04 2810
日志记录，包括接口调用时间，参数，操作类型，自定义注解的方式去实现，涵盖了AOP的基本用法及常用注解
使用AOP切面实现日志记录功能
最新发布
心态的博客
10-26 3496
说到AOP大家都可以想到他是面向切面的编程，它通过将横切关注点（例如日志记录、事务管理、权限控制等）从主要业务逻辑中分离出来，以模块化的方式进行管理。在AOP中，通过定义切面（Aspect）来捕获和处理横切关注点，然后将其应用于特定的目标对象或方法。官方的解释有点抽象，我们举个例子说明：假设我们需要在多个方法中添加日志记录功能。传统的方式是在每个方法中都添加日志代码，但这样会导致代码重复，并且当我们需要修改日志记录逻辑时，需要逐个修改所有方法。
我用注解实现接口的操作流水日志
wujialv的博客
11-17 3909
在项目中，我们会需要获取接口的操作日志。比如获取接口的接口名、操作人，接口运行时间、所属的服务、接口的类型（增删改查）等等。初级的做法是在接口方法执行完后将这些操作记录存入库中，这段代码写在接口中，但是这样违反了设计原则中的单一职责原则。常用的做法是使用AOP来做，在运行时动态的插入日志记录的代码。这里我是用注解来做。 创建日志记录表 首先我们来创建日志记录表： operation表 当然后编写实体类： 编写日志记录注解 我们先定义一个注解OperationLog 这个注解里面定义
java手写操作日志功能:切面实现及验证(四)
绅士jiejie的博客
08-08 1519
直接贴代码，干脆利落 Aspect @Component public class OperationLogAspect { /** * 修改内容汇总 */ private List<Map<String, List<Map<String, Object>>>> mapArrayList = new ArrayList<>(); /*...
java 日志管理 @Aspect
sugar的博客
03-28 1509
@Aspect Spring 统一日志管理 详见 http://www.cnblogs.com/chihirotan/p/6228337.html 在pom.xml文件中配置 <dependency> <groupId>org.springframework.boot</groupId> ...
spring 使用aop切面实现系统操作日志记录
weixin_43190879的博客
02-15 587
使用aop切面编程实现系统操作日志记录实现
springboot如何使用AOP做访问请求日志
08-25
AOP 的主要思想是将跨越多个类和对象的功能分离出来，形成一个独立的模块，以便于维护和重用。 在 SpringBoot 中，使用 AOP 来实现访问请求日志主要涉及到以下几个方面： 1. 依赖引入：在 pom.xml 文件中引入 ...
SpringBoot中使用AOP打印接口日志的方法
08-27
在这个示例代码中，我们使用了一个名为LogAspect的Aspect类，用于打印接口日志。我们使用了 Pointcut 来指定要拦截的方法，然后使用 Advice 来实现打印日志的功能。 在这个示例代码中，我们还使用了 SpringBoot 的...
Springboot使用@Valid 和AOP做参数校验及日志输出问题
08-25
Springboot使用@Valid 和AOP做参数校验及日志输出问题 Springboot框架中，参数校验和日志输出是两个非常重要的方面。使用@Valid注解可以对实体类进行校验，而AOP（Aspect-Oriented Programming）可以用于记录日志...
使用SpringBoot+AOP实现可插拔式日志的示例代码
08-25
AOP 是 OOP 的延续，是软件开发中的一个热点，也是 Spring 框架中的一个重要内容，是函数式编程的一种衍生范型。 要实现可插拔式日志，首先需要引入依赖项，包括 SpringBoot 的 AOP starter 和 Web starter， 以及...
Springboot接口项目如何使用AOP记录日志
08-19
Springboot 接口项目如何使用 AOP 记录日志 在软件开发中，日志记录是一项非常重要的任务，它可以帮助我们追踪程序的执行过程， debug 错误，优化性能等。但是，传统的日志记录方式通常需要在代码中添加大量的日志...
如何自定义log注解，实现日志操作（切面编程）
qq_42978230的博客
02-04 5256
有的同学在工作学习时常常遇到这样一个需求，就是进行对日志表的增删改查。记录用户的操作。啊，有的小伙伴说：这还不简单，一顿操作猛如虎，在每个方法下面都写上了insert语句。 这种方式确实可行，（我真这样干过）但是作为优秀的程序员，追求的是优雅的代码 今天在这里记录一下如何使用自定义注解实现日志的操作。 1.在你的代码中加入一个类 /** * @description: 自定义log注解 * @author: Daigl * @create: 2021-02-01 21:33 **/ @Target
自定义标签通过AOP实现日志增强
一个保安的自由之路
02-15 150
package com.taimi.aop; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * Description: * Author: taimi 37310 * Version: 1.0 * Create .
Spring&MVC应用----第二章
1augh
11-09 136
Spring AOP 编程 这里写目录标题Spring AOP 编程什么是AOP测验作业 什么是AOP 快速入门： 某手机商店需要购买手机和销售手机，现要求购买和销售手机时记录日志。 需求分析： 本系统有两个业务操作：购买手机和销售手机。我们可以定义一个手机业务接口、一个手机业务接口 实现和一个日志操作类。 任务参考结果 实现步骤： 创建 Web 工程： phone。 创建手机业务接口： PhoneBiz，并定义两个业务操作方法： buyPhone 和 salePhone。代码如下所示： packa
java自定义注解
有个疙叫瘩儿的博客
10-27 1396
注解是一种能被添加到java源代码中的元数据，方法、类、参数和包都可以用注解来修饰。注解可以看作是一种特殊的标记，可以用在方法、类、参数和包上，程序在编译或者运行时可以检测到这些标记而进行一些特殊的处理。 声明一个注解要用到的东西 修饰符：访问修饰符必须为public,不写默认为pubic 关键字：关键字为@interface 注解名称：注解名称为自定义注解的名称，使用时还会用到 注解类型元素：注解类型元素是注解中内容...
想在SSM框架中进行配置AOP日志，进行数据库记录？不妨看看这篇文章
LiangHuan
03-31 722
SSMAOP日志 数据库与表结构 1、日志表信息描述sysLog： 2、sql语句： 3、实体类： 基于AOP日志处理 1、创建切面类处理日志 @Component @Aspect public class LogAop { @Autowired private HttpServletRequest httpServletRequest; //在web.xml中...
java logAspect
weixin_34246551的博客
08-02 285
@Around("execution(* com.iotx.cep.biz.rpc.impl.*.*(..)) " + "&amp;&amp; !execution(* com.iotx.cep.biz.rpc.impl.CepEngineServiceImpl.calcOffsetForSameSource(..))") public Object addRpcLog(Proceeding...
Springboot项目使用aop切面保存详细日志到ELK日志平台
热门推荐
tianyaleixiaowu的专栏
08-08 1万+
上一篇讲过了将Springboot项目中logback日志插入到ELK日志平台，它只是个示例。这一篇来看一下实际使用中，我们应该怎样通过aop切面，拦截所有请求日志插入到ELK日志系统。同时，由于往往我们有很多个服务，都需要记录日志，为每个服务都搭建一个ELK并不现实，所以我们采用集中化管理日志，将所有日志都插到同一个ELK中。这样又会遇到另一个问题，就是ES中的Index如果只有一个，那么所有日
springboot整合AOP,实现log操作日志
liyu121的博客
01-28 6153
添加依赖 &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-aop&lt;/artifactId&gt; &lt;/dependency&g...
为什么要用SpringBoot框架搭建一个SSM框架的应用程序
05-26
SpringBoot框架是一个快速开发框架，可以快速搭建一个Web应用程序。而SSM框架（Spring+SpringMVC+MyBatis）是一种常用的JavaWeb开发框架，可以帮助开发者快速完成项目的搭建和开发。将SpringBoot与SSM框架结合起来使用，可以充分发挥SpringBoot的快速开发特性，同时也可以借助SSM框架的优点，如Spring的IOC和AOP特性、SpringMVC的MVC模式和MyBatis的ORM特性等，使得开发更加高效、灵活、易于维护。因此，使用SpringBoot框架搭建一个SSM框架的应用程序，可以让开发者更加方便快捷地开发出高质量的Web应用程序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值