aop注解日志系统

最新推荐文章于 2023-06-07 17:14:06 发布
最新推荐文章于 2023-06-07 17:14:06 发布
阅读量792 收藏 3
点赞数 1
分类专栏： springboot 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangbiao007/article/details/121884401
版权

背景

本项目主要是利用apo注解实现了一个简单日志操作记录功能,
主要是为了圆自己一个心愿吧，因为记得2017年老大让我做一个日志记录系统，当时没有做出来， 现在利用aop注解实现了一个简单的日志记录系统，这个用在微小型项目上还行，一般项目都用es来做日志存储了。

代码

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>aoplog</groupId>
    <artifactId>aoplog</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <version>2.3.4.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.3.1.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
            <version>2.3.1.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.74</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-annotation</artifactId>
            <version>3.4.2</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>

        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-core</artifactId>
            <version>3.4.2</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.2</version>
        </dependency>

        <!-- MYSQL驱动，不可缺少 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.23</version>
        </dependency>
        <!-- Spring Boot JDBC -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

    </dependencies>


    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>

            <!--将resources目录下的配置文件编译进classes文件  -->
            <resource>
                <directory>src/main/resources</directory>
            </resource>
        </resources>


    </build>
</project>
spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/user0?useUnicode=true&characterEncoding=utf8
    username: root
    password: root
    driver-class-name: com.mysql.jdbc.Driver


mybatis:
  mapper-locations: classpath*:mapper/*.xml
  type-aliases-package: com.huilongguan.entity  #对应实体类路径




package com.huilongguan.entity;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.io.Serializable;
import java.util.Date;

/**
 * 日志实体
 * @Author wangbiao
 * @Date 12/11/21 9:13 PM
 * @Decripition：
 **/
@TableName("log_info")
@ApiModel(value = "日志对象", description = "")
@Data
public class LogInfoEntity implements Serializable {
    private static final long serialVersionUID = 1L;

    @TableId("id")
    @ApiModelProperty("id")
    private Long id;

    @TableField("url")
    @ApiModelProperty("请求地址")
    private String url;

    @TableField("class_name")
    @ApiModelProperty("请求类")
    private String className;

    @TableField("method")
    @ApiModelProperty("请求方法")
    private String method;

    @TableField("params")
    @ApiModelProperty("请求参数")
    private String params;

    @TableField("method_description")
    @ApiModelProperty("方法描叙")
    private String methodDescription;

    @TableField("result")
    @ApiModelProperty("请求结果")
    private Boolean result;

    @TableField("message")
    @ApiModelProperty("请求返回描叙")
    private String message;

    @TableField("code")
    @ApiModelProperty("请求返回code")
    private Integer code;

    @TableField("user_name")
    @ApiModelProperty("执行请求的用户人名")
    private String userName;

    @TableField("create_time")
    @ApiModelProperty("请求时间")
    private Date createTime;
}

package com.huilongguan.entity;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.util.Date;

/**
 * @Author wangbiao
 * @Date 12/11/21 9:43 PM
 * @Decripition：
 **/
@Data
@ApiModel("用户信息对象")
@TableName("user0")
public class UserInfoEntity {

    @TableId
    @ApiModelProperty("id")
    private Long id;

    @TableField("name")
    @ApiModelProperty("用户名")
    private String name;

    @TableField("phone")
    @ApiModelProperty("电话号码")
    private String phone;

    @TableField("email")
    @ApiModelProperty("邮箱")
    private String email;

    @TableField("password")
    private String password;

    @TableField("sex")
    private Integer sex;

    @TableField("create_time")
    private Date createTime;

}

package com.huilongguan.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @Author wangbiao
 * @Date 12/11/21 8:59 PM
 * @Decripition：
 **/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Result<T> {
    private Integer code;

    private Boolean isSuccess;

    private String message;

    private T data;



    public static Result success(){
        Result result = new Result(1000,true,null,null);
        return result;
    }

    public static <T> Result<T> success(T t){
        Result result = new Result(1000,true,null,t);
        return result;
    }

    public static Result fail(){
        Result result = new Result(5000,false,null,null);
        return result;
    }

    public static Result fail(String message){
        Result result = new Result(5000,false,message,null);
        return result;
    }

    public static Result fail(Integer code){
        Result result = new Result(5000,false,null,code);
        return result;
    }

    public static Result fail(Integer code,String message){
        Result result = new Result(5000,false,message,code);
        return result;
    }
}

package com.huilongguan.dao;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.huilongguan.entity.LogInfoEntity;
import org.springframework.stereotype.Repository;

@Repository
public interface LogInfoMapper extends BaseMapper<LogInfoEntity> {
}

package com.huilongguan.dao;


import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.huilongguan.entity.UserInfoEntity;
import org.springframework.stereotype.Repository;

/**
 * @Author wangbiao
 * @Date 12/11/21 10:03 PM
 * @Decripition：
 **/
@Repository
public interface UserInfoMapper extends BaseMapper<UserInfoEntity> {
}

package com.huilongguan.service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.huilongguan.dao.UserInfoMapper;
import com.huilongguan.entity.UserInfoEntity;
import org.springframework.stereotype.Service;

/**
 * @Author wangbiao
 * @Date 12/11/21 10:18 PM
 * @Decripition：
 **/
@Service
public class UserInfoService extends ServiceImpl<UserInfoMapper, UserInfoEntity> {
}

package com.huilongguan.controller;

import com.huilongguan.aspect.LogAnnotation;
import com.huilongguan.entity.Result;
import com.huilongguan.entity.UserInfoEntity;
import com.huilongguan.service.UserInfoService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @Author wangbiao
 * @Date 12/11/21 10:25 PM
 * @Decripition：
 **/
@RestController
@RequestMapping("/user")
@Api(tags = "用户管理")
public class UserInfoController {
    @Autowired
    private UserInfoService userInfoService;

    @ApiOperation("查询用户信息")
    @LogAnnotation(operateDescripetion = "查询用户信息")
    @PostMapping("/getUserInfoList")
    public Result<List<UserInfoEntity>> getUserInfoList(){
        int a = 1/0;
        List<UserInfoEntity> userInfoEntityList = userInfoService.list();
        return Result.success(userInfoEntityList);
    }


    @ApiOperation("新增用户")
    @LogAnnotation(operateDescripetion = "新增用户")
    @PostMapping("/addUserInfo")
    public Result addUserInfo(@RequestBody UserInfoEntity userInfoEntity){
        userInfoService.save(userInfoEntity);
        return Result.success();
    }


    @ApiOperation("删除用户")
    @LogAnnotation(operateDescripetion = "删除用户")
    @PostMapping("/deleteById")
    public Result deleteById(@RequestParam Long id){
        userInfoService.removeById(id);
        return Result.success();
    }
}

package com.huilongguan.aspect;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 自定义日志注解
 * @Author wangbiao
 * @Date 12/8/21 4:43 PM
 * @Decripition：
 **/
@Target(ElementType.METHOD) // 方法注解
@Retention(RetentionPolicy.RUNTIME) // 运行时可见
public @interface LogAnnotation {
    String operateDescripetion();// 记录日志的操作描叙
}

package com.huilongguan.aspect;

import com.alibaba.fastjson.JSONArray;
import com.huilongguan.dao.LogInfoMapper;
import com.huilongguan.entity.LogInfoEntity;
import com.huilongguan.entity.Result;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.Date;

/**
 * 日志切面
 * @Author wangbiao
 * @Date 12/8/21 4:41 PM
 * @Decripition：
 **/
@Component
@Aspect
@Slf4j
public class LogAspect {
    @Autowired
    private LogInfoMapper logInfoMapper;

    @Pointcut("@annotation(com.huilongguan.aspect.LogAnnotation)")
    public void pointCut(){};

    @Around(value = "pointCut()")
    public Object methodAround(ProceedingJoinPoint pjp)throws Throwable{
        LogInfoEntity logInfoEntity = new LogInfoEntity();

        //获取方法签名
        MethodSignature methodSignature = (MethodSignature) pjp.getSignature();
        //获取方法
        Method method = methodSignature.getMethod();

        String className = methodSignature.getClass().getName();

        String methodName = method.getName();

        LogAnnotation logAnnotation = method.getAnnotation(LogAnnotation.class);

        String methodDescription = logAnnotation.operateDescripetion();//方法的描叙


        String url = getUrl(method);  //方法的url

        // 获取参数值
        Object[] args = pjp.getArgs();
        String paramers = args!=null&&args.length>0? JSONArray.toJSONString(args):null;

        //获取操作的用户
        String userName = "张三";

        //返回结果
        Boolean resultBool = false;
        String message = null;
        Integer code = null;

        logInfoEntity.setUrl(url);
        logInfoEntity.setClassName(className);
        logInfoEntity.setMethod(methodName);
        logInfoEntity.setParams(paramers);
        logInfoEntity.setUserName(userName);
        logInfoEntity.setCreateTime(new Date());
        logInfoEntity.setMethodDescription(methodDescription);
        try{
            Result result = (Result)pjp.proceed();
            resultBool = result.getIsSuccess();
            message = result.getMessage();
            code = result.getCode();
            logInfoEntity.setResult(resultBool);
            logInfoEntity.setMessage(message);
            logInfoEntity.setCode(code);

            logInfoMapper.insert(logInfoEntity);

            return result;
        }catch (Exception e){
            log.error("程序报错:"+e.getMessage(),e);
            code = 5000;
            message = e.getMessage();
            resultBool = false;
            logInfoEntity.setResult(resultBool);
            logInfoEntity.setMessage(message);
            logInfoEntity.setCode(code);

            logInfoMapper.insert(logInfoEntity);

            return Result.fail(e.getMessage());
        }

    }



    public static String getUrl(Method method){
        String url = null;
        Annotation[] annotations = method.getAnnotations();
        if(annotations!=null&&annotations.length>0){
           for(Annotation annotation:annotations){
              if(annotation instanceof PostMapping){
                  String[] values = ((PostMapping) annotation).value();
                  if(values!=null&&values.length>0){
                      url = values[0];
                  }
              }else if(annotation instanceof GetMapping){
                   String[] values = ((GetMapping) annotation).value();
                   if(values!=null&&values.length>0){
                       url = values[0];
                   }
               }else if(annotation instanceof DeleteMapping){
                   String[] values = ((DeleteMapping) annotation).value();
                   if(values!=null&&values.length>0){
                       url = values[0];
                   }
               }
           }
        }
        return url;

    }
}

package com.huilongguan;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

/**
 * 本项目主要是利用apo注解实现了一个简单日志操作记录功能,
 * 主要是为了圆自己一个心愿吧，因为记得2017年老大让我做一个日志记录系统，当时没有做出来，
 * 现在利用aop注解实现了一个简单的日志记录系统，这个用在微小型项目上还行，一般项目都用es来做日志存储了。
 * @Author wangbiao
 * @Date 12/8/21 4:33 PM
 * @Decripition：
 **/
@SpringBootApplication
@MapperScan("com.huilongguan.dao")
@EnableSwagger2
public class SpringBootApplocationStarter {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootApplocationStarter.class,args);
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.huilongguan.dao.LogInfoMapper">

</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.huilongguan.dao.UserInfoMapper">

</mapper>
CREATE TABLE `log_info` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `url` varchar(200) COLLATE utf8mb4_bin DEFAULT NULL,
  `class_name` varchar(200) COLLATE utf8mb4_bin DEFAULT NULL,
  `method` varchar(50) COLLATE utf8mb4_bin DEFAULT NULL,
  `params` varchar(500) COLLATE utf8mb4_bin DEFAULT NULL,
  `result` tinyint(1) DEFAULT NULL,
  `message` longtext COLLATE utf8mb4_bin,
  `code` int(11) DEFAULT NULL,
  `user_name` varchar(20) COLLATE utf8mb4_bin DEFAULT NULL,
  `create_time` datetime DEFAULT NULL,
  `method_description` varchar(200) COLLATE utf8mb4_bin DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1469858491801583618 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin
CREATE TABLE `user0` (
  `id` bigint(20) NOT NULL,
  `name` varchar(30) DEFAULT NULL COMMENT '名称',
  `sex` tinyint(2) DEFAULT NULL COMMENT '性别 0-男，1-女',
  `phone` varchar(15) DEFAULT NULL COMMENT '电话',
  `email` varchar(30) DEFAULT NULL COMMENT '邮箱',
  `password` varchar(20) DEFAULT NULL COMMENT '密码',
  `create_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '创建时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8

 

 

wangbiao007
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA 中Spring aop 实现日志记载
01-28
该压缩包中包含了一个myeclipse6.5下开发的JAVA基于spring实现的日志记载例子，该例子提供了接受切点参数，解析切点返回值，并且都打印出来了，有详细的文档介绍。
自定义注解实现操作日志
zhanghailang1的博客
10-16 610
​ 冷静 专注 集中 努力 自定义注解实现操作日志 ​ 在梳理保全中心逻辑的过程中，有业务场景需要记录过程中某些保全的操作日志，打算使用注解加切面的方式实现，此处先做个测试Demo 1.定义操作日志注解@Log @Retention 表示这是一个运行时注解，即运行起来之后，才获取注解中的相关信息，而不像基本注解@Override 那种不用运行，在编译时eclipse就可以进行相关工作的编译.
Spring使用 AOP 实现 日志功能
mufeng
05-18 6743
因为有人问我 AOP 应该怎么实现日志功能，故写一个简单版本。 在写Aop 实现日志功能时，如果对AOP 一些内置属性不清楚的，可结合此博客： 代码环境 SSM ： 1.首先 写一个 日志类 Logtable @Entity @Table(name = "logtable") @Setter @Getter public class Logtable { private Integer id...
org.aspectj.lang.JoinPoint-中文简要API
热门推荐
12-01 4万+
AspectJ使用org.aspectj.lang.JoinPoint接口表示目标类连接点对象，如果是环绕增强时，使用org.aspectj.lang.ProceedingJoinPoint表示连接点对象，该类是JoinPoint的子接口。任何一个增强方法都可以通过将第一个入参声明为JoinPoint访问到连接点上下文的信息。我们先来了解一下这两个接口的主要方法：  1)JoinPoint
什么是AOP和简单的使用AOP注解来实现日志功能
小明的博客
11-29 273
AOP代表的是一个横向的关系，将“对象”比作一个空心的圆柱体，其中封装的是对象的属性和行为；实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术.AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。
aop注解方式实现全局日志管理方法
08-28
下面小编就为大家分享一篇aop注解方式实现全局日志管理方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Spring Aop之AspectJ注解配置实现日志管理的方法
08-28
下面小编就为大家分享一篇Spring Aop之AspectJ注解配置实现日志管理的方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
spring aop 自定义注解保存操作日志到mysql数据库 源码
11-25
4、想看spring aop 注解实现记录系统日志并入库等 二、能学到什么 1、收获可用源码 2、能够清楚的知道如何用spring aop实现自定义注解以及注解的逻辑实现 （需要知道原理的请看spring aop源码，此处不做赘述） 3、...
spring AOP自定义注解方式实现日志管理的实例讲解
08-28
下面小编就为大家分享一篇spring AOP自定义注解方式实现日志管理的实例讲解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
springBoot+aop+自定义注解+本地线程实现统一接口日志及接口响应时长
02-01
springboot+拦截器+aop+自定义注解+本地线程实现统一接口日志记录，记录下接口所在模块、接口描述、接口请求参数、接口返回参数、接口请求时间以及接口耗时用于接口优化，接口记录参数以及操作人防止使用人员误操作...
Spring Boot高级用法 AOP 自定义注解实现日志
最新发布
qq_34874784的博客
06-07 1310
首先，我们需要定义一个注解@Log，我们可以在需要监控的方法上添加这个注解，来标记这个方法需要对其进行记录日志操作。/*** 日志描述信息*/在@Log所在的目录下，我们定义一个切面类LogAspect，当在方法上添加了@Log注解时，切面就会自动织入。切面中的逻辑依然是在方法之前和方法之后打印一行文本信息。@Aspect@Component@Slf4j"未知方法" : logAnnotation.value();
AOP注解日志处理简单理解
YHC
08-28 1444
由于公司不能上外网,只能看快照,所以不能记录原文地址理解注解：1、首先注解是在JDK5.0及以后版本中引入的。他可以用于创建文档，跟踪代码中的依赖性，甚至执行基本的编译时检查，而且还可以作为在spring框架中进行注解试注入Bean属性，用来减少写配置文件。注解是以@+注解名在代码中存在的，根据注解参数的个数，我们可以将注解分为：标记注解，单值注解、完整注解三类。他们都不会直接影响到程序的语义，只
Spring AOP 实现日志记录功能
Just Do It!
02-12 2万+
最近项目中需要记录日志，跟大家想的一样 ，利用spring aop去实现，之前也参考了一些代码，自己实现了一套设计，供大家参考。之前看到网上很多是基于切面类Aspect去实现了，在切面类中定义before after around等逻辑以及要拦截等方法。本文利用注解实现了一套可以扩展等日志记录模块。1. 定义注解@Target(ElementType.METHOD) @Retention(Rete...
使用Aop的方式实现自动日志记录
weixin_55076626的博客
03-20 1325
允许注解在方法和类上添加： 以下注解在接口上添加： 2.1、先编写一个pt方法，此方法结合了上面自定义的注解：2.2、然后编写log方法，对加了LogAnnotation注解的类或者方法实现环绕通知： 2.3、最后完善redcordlog方法来记录日志，并在控制台输出相关记录的日志：完整代码： redcordlog方法包含了两个工具类（用来获取当前接口ip地址的），如下： 3、使用接口，查看控制台输出信息
SpringAOP + 注解实现日志管理
程序员小明1024
09-24 426
.markdown-body { line-height: 1.75; font-weight: 400; font-size: 16px; overflow-x: hidden; color: rgba(51, 51, 51, 1) } .markdown-body h1, .markdown-body h2, .markdown-body h3, .markdown-body h4, .ma...
Aop+自定义注解实现查看操作日志
单俞浩的博客
06-19 1010
Aop+自定义注解实现操作日志查看
技术分享一 怎么用AOP去实现操作日志（注解方式）
qq_44199772的博客
03-10 313
AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。本文章带大家怎么用AOP自定义注解来实现操作日志记录
SpringBoot+AOP+自定义注解，优雅实现日志记录
小学生波波
12-21 8726
AOP切面编程+自定义注解，优雅记录系统日志
AOP日志系统
weixin_40540744的博客
07-06 1033
自定义一个注解 用于拦截控制层操作@Target({ ElementType.PARAMETER, ElementType.METHOD }) @Retention(RetentionPolicy.RUNTIME) public @interface SystemControllerLogApp { /** * 描述业务操作 例:登录设备 * @return */ ...
aop 记录日志 异常拦截
05-25
AOP（面向切面编程）可以帮助我们在程序运行时动态地添加一些...例如，我们可以在需要记录日志的 service 方法上添加 @Before、@AfterReturning 和 @AfterThrowing 注解，或在需要拦截异常的方法上添加 @Around 注解。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值