日志Aop切面配置笔记

最新推荐文章于 2023-10-26 21:00:00 发布
最新推荐文章于 2023-10-26 21:00:00 发布
阅读量773 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40496191/article/details/115901399
版权

最近在学习搭建框架，在这里分享下一些技术搭建，当做自己笔记，不好勿喷。
直接进入主题，对于系统的一些敏感操作，如修改、删除用户等需要增加日志模块，记录用户的操作。但是我们不可能每个模块都写原生代码，构建对象保存到数据库，所以这里就开始用到了aop日志切面，下面是我配置的简单例子。

  1. 日志类

import cn.ffcs.base.MyBaseModel;
import com.baomidou.mybatisplus.annotation.IdType;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.baomidou.mybatisplus.annotation.*;

/**
 * <p>
 * 用户操作日志
 * </p>
 *
 * @author 86188
 * @since 2021-04-16
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("t_sm_userlog")
public class TSmUserlog extends MyBaseModel implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 主键
     */
    @TableId(value = "ID", type = IdType.AUTO)
    private Long id;

    /**
     * 操作人id
     */
    @TableField("OPERATE_USER_ID")
    private Long operateUserId;

    /**
     * 操作人
     */
    @TableField("OPERATE_USER_NAME")
    private String operateUserName;

    /**
     * 操作模块
     */
    @TableField("OPERATE_MODULE")
    private String operateModule;

    /**
     * 操作类
     */
    @TableField("OPERATE_CLASS")
    private String operateClass;

    /**
     * 操作方法
     */
    @TableField("OPERATE_METHOD")
    private String operateMethod;

    /**
     * 操作类型
     */
    @TableField("OPERATE_NAME")
    private String operateName;

    /**
     * 操作内容
     */
    @TableField("OPERATE_CONTENT")
    private String operateContent;

    /**
     * 操作时间
     */
    @TableField("OPERATE_TIME")
    private Date operateTime;

    /**
     * 请求数据
     */
    @TableField("REQUEST_DATA")
    private String requestData;

    /**
     * 响应数据
     */
    @TableField("RESPONSE_DATA")
    private String responseData;

    /**
     * 响应code
     */
    @TableField("RESPONSE_CODE")
    private String responseCode;

    /**
     * 响应信息
     */
    @TableField("RESPONSE_MESSAGE")
    private String responseMessage;

    /**
     * 删除状态
     */
    @TableField(value="STATUS", fill = FieldFill.INSERT)
    @TableLogic
    private String status;


}
  1. 响应类
/**
 * 访问结果Response
 */
@Data
public class Result<T> {

    // http 状态码
    private int code;

    // 返回信息
    private String msg;

    // 返回的数据
    private T data;

    //返回失败或者成功
    private boolean success;

  

}
  1. 定义操作模块
/**
 * 定义模块名称枚举
 *
 * @author 天真热
 * @create 2021-04-15 9:43
 * @desc
 **/
public enum OperateModule {
    T_LOGIN("登录"),
    T_SM_USER("用户管理"),
    T_SM_ROLE("角色管理"),
    T_SM_AUTHORITY("权限管理");

    private String moudoleName;

    private OperateModule(String moudoleName) {
        this.moudoleName = moudoleName;
    }


    /**
     * 返回模块名称
     *
     * @return
     */
    public String getMoudoleName() {
        return moudoleName;
    }

}
  1. 定义操作行为
/**
 * 定义操作类型枚举
 *
 * @author 天真热
 * @create 2021-04-15 9:44
 * @desc
 **/
public enum OperateType {
    LOGIN("登录"),
    CREATE("新增"),
    MODIFY("修改"),
    DELETE("删除"),
    SHOW("查看");

    private String typeName;

    private OperateType(String typeName) {
        this.typeName = typeName;
    }


    /**
     * 返回模块名称
     *
     * @return
     */
    public String getTypeName() {
        return typeName;
    }

}
  1. 自定义日志注解
/**
 * 自定义注解@UserActionLog
 *
 * @author 天真热
 * @create 2021-04-15 9:42
 * @desc
 **/

@Target({ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface UserActionLog {
    /**
     * 操作描述 业务名称business
     *
     * @return
     */
    String description() default "";

    /**
     * 操作模块
     *
     * @return
     */
    OperateModule module();

    /**
     * 操作类型 create modify delete
     *
     * @return
     */
    OperateType opType();




}
  1. 自定义日志操作
/**
 * 切面
 *
 * @author 天真热
 * @create 2021-04-15 9:45
 * @desc
 **/
@Aspect
@Component
public class WebLogAspect {
    @Resource
    private ITSmUserlogService userlogService;
    @Resource
    private ITSmUserService userService;

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


    /**
     * 获取@UserActionLog 注解上信息
     *
     * @param joinPoint
     * @return map
     * @throws Exception
     */
    public static Map<String, Object> getControllerAnnotationValue(JoinPoint joinPoint) throws Exception {
        Map<String, Object> map = new HashMap<>();
        //获取切入点类名
        String targetName = joinPoint.getTarget().getClass().getName();
        map.put("targetName", targetName);
        //获取切入点方法名
        String methodName = joinPoint.getSignature().getName();
        map.put("methodName", methodName);
        //获取切入点参数列表
        Object[] arguments = joinPoint.getArgs();
        //获取切入点类对象
        Class targetClass = Class.forName(targetName);
        //获取切入点类对象的所有方法
        Method[] methods = targetClass.getMethods();

        //遍历类方法
        for (Method method : methods) {
            if (method.getName().equals(methodName)) {
                //返回Class对象数组
                Class[] classes = method.getParameterTypes();
                if (classes.length == arguments.length) {
                    //操作描述
                    String description = method.getAnnotation(UserActionLog.class).description();
                    //模块名
                    String module = method.getAnnotation(UserActionLog.class).module().name();
                    //操作类型
                    String opType = method.getAnnotation(UserActionLog.class).opType().name();
                    map.put("module", module);
                    map.put("opType", opType);
                    map.put("business", description);
                    break;
                }
            }
        }
        return map;
    }

    /**
     * 定义一个切入点.
     * 第一个 * 代表任意修饰符及任意返回值.
     * 第二个 * 任意包名
     * 第三个 * 定义在web包或者子包
     * 第四个 * 任意方法
     * .. 匹配任意数量的参数.
     */
    @Pointcut("execution(public * cn.tzr..*.controller..*.*(..))  && @annotation(cn.ffcs.config.aop.userlog.UserActionLog)")
    public void webLog() {
    }

    @Around("webLog()")
    public Object round(ProceedingJoinPoint joinPoint) throws Throwable {
//        logger.info("环绕通知开始........");
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();

        //获取token
        String shortToken = request.getHeader(Constant.SHORT_TOKEN);
        if (CommonStringUtils.isEmpty(shortToken)) {
            //前后端不分离的情况下，需要考虑地址栏带token的情况
            if (Constant.IS_URL_TOKEN) {
                shortToken = request.getParameter(Constant.SHORT_TOKEN);
            }
        }

        //解析token获取用户
        String username = JWTUtil.getUsername(shortToken);
        if(username==null){
            //没登录
            return null;
        }
        TSmUserDTO userDTO = userService.getByUsername(username);
        String nickname = userDTO.getNickname();
        //获取切入点的参数列表
        Object[] args = joinPoint.getArgs();
        //获取切入点的入参名称列表
        String[] paramNames = ((CodeSignature) joinPoint.getSignature()).getParameterNames();
        Map<String, Object> params = new HashMap<>();
        //获取所有参数对象
        for (int i = 0; i < args.length; i++) {
            if (null != args[i]) {
                if (args[i] instanceof BindingResult) {
                    params.put(paramNames[i], "bindingResult");
                } else {
                    params.put(paramNames[i], args[i]);
                }
            } else {
                params.put(paramNames[i], "无");
            }
        }


        //获取@controllerLog 注解上信息
        Map<String, Object> values = getControllerAnnotationValue(joinPoint);
        String opType = values.get("opType").toString();//操作类型
        String module = values.get("module").toString();//操作模块
        String business = values.get("business").toString();//业务

        //切面获取返回值
        Object returnValue = joinPoint.proceed();
        Result result = new Result();
        if (returnValue instanceof Result) {
            result = (Result) returnValue;
        }

        TSmUserlogDTO userlogDTO = new TSmUserlogDTO();

        userlogDTO.setOperateModule(OperateModule.valueOf(module).getMoudoleName());//操作模块
        userlogDTO.setOperateName(OperateType.valueOf(opType).getTypeName());//操作类型
        userlogDTO.setOperateContent(business);//操作内容
        userlogDTO.setRequestData(JSONObject.fromObject(params).toString());//数据
        userlogDTO.setOperateUserId(userDTO.getId());//操作人id
        userlogDTO.setOperateUserName(userDTO.getNickname());//操作人名称
        userlogDTO.setOperateTime(new Date());//操作时间
        userlogDTO.setResponseCode(CommonStringUtils.toString(result.getCode()));//响应码
        userlogDTO.setResponseMessage(result.getMsg());//响应信息
        String responseData = null;
        try {
            responseData = CommonStringUtils.toString(JSONObject.fromObject(result.getData()));//响应数据
        } catch (Exception e) {
            responseData = CommonStringUtils.toString(result.getData());//响应数据
        }
        if (responseData.length() > 450) {
            responseData = responseData.substring(0, 450)+"......";
        }
        userlogDTO.setResponseData(responseData);//响应数据

        userlogDTO.setOperateClass(CommonStringUtils.toString(values.get("targetName")));
        userlogDTO.setOperateMethod(CommonStringUtils.toString(values.get("methodName")));

        userlogService.save(userlogDTO);
        return returnValue;
    }

    @AfterReturning("webLog()")
    public void doAfterReturning(JoinPoint joinPoint) {
        // 处理完请求，返回内容
        logger.info("WebLogAspect.doAfterReturning()");
    }

}
  1. 需要记录日志的地方加上 @UserActionLog即可，如下
/**
     * 保存用户
     *
     * @return
     */
    @PostMapping("/user/save")
    @UserActionLog(description = "保存用户", module = OperateModule.T_SM_USER, opType = OperateType.CREATE)
    public Result save(@RequestBody JSONObject data) {
        return null;
    }

基本能直接套用、亲测有效！！！

懒惰の天真热
关注
java使用AOP切面获取请求日志并记录
2301_79055083的博客
05-03 943
在面试前我整理归纳了一些面试学习资料，文中结合我的朋友同学面试美团滴滴这类大厂的资料及案例由于篇幅限制，文档的详解资料太全面，细节内容太多，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！大家看完有什么不懂的可以在下方留言讨论也可以关注。《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门，即可获取！try {在面试前我整理归纳了一些面试学习资料，文中结合我的朋友同学面试美团滴滴这类大厂的资料及案例。
Spring AOP切面使用详细解析
Jarvis.y的博客
10-11 1153
相关文章： SpringBoot AOP 使用 一步一步手绘Spring AOP运行时序图（Spring AOP 源码分析） 架构师系列内容：架构师学习笔记（持续更新）） Spring AOP 应用场景 AOP 是 OOP 的延续，是 Aspect Oriented Programming 的缩写，意思是面向切面编程。可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP 可以说也是这种目标的一种实现.
spring AOP 切面日志 分层打日志
12-04
spring AOP 切面日志 分层打日志
AOP日志切面
xinpz的博客
04-29 1424
AOP日志切面 AOP(Aspect-OrientedProgramming)其实是OOP(Object-OrientedPrograming)思想的补充和完善。我们知道，OOP引进"抽象"、"封装"、"继承"、"多态"等概念,对万事万物进行抽象和封装，来建立一种对象的层次结构，它强调了一种完整事物的自上而下的关系。但是具体细粒度到每个事物内部的情况，OOP就显得无能为力了。比如日志功能。日志代码往往水平地散布在所有对象层次当中，却与它所散布到的对象的核心功能毫无关系。对于其他很多类似功能，如事务管...
切面 AOP操作日志
u011271164的博客
09-22 334
亲自实践AOP，遇到的问题：（请把图一与图二进行对比，会发现环切代码的意义是什么） 一、直接看下图，类中的方法1与方法2； 方法1：首先创建连接点； 方法2：对已创建的环切点进行环切； @Pointcut("execution(* com.zrar..*BLH.*(..))") public void pointCut2(){} @Around("pointCut2()") public Object businessLog(ProceedingJoinPoint pjp) ..
日志切面的配置使用
有脑子的搬砖工的博客
11-22 740
使用配置文件 applicationContext.xml(spring.xml)配置文件 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSch...
AOP切面记录日志
我认不到你的博客
06-19 886
/
Spring AOP+Annotation切面式注解实现自定义系统日志
一位葛先生
03-18 912
写在前面：此实现感谢我大杰哥 后期我大杰哥会有针对此日志实现的优化，包括注入LogUserService 的懒加载问题 切面编程和自定义注解的技术博客自行研究 【SpringBoot笔记8】Spring AOP 面向切面编程（应用篇） 自定义注解详细介绍 目标： 实现用户操作、操作方法、执行结果的一站式记录 思路： 1. 使用切面编程的方式处理用户操作中系统调用方法的环绕通知式记录，包括调用前获得...
AOP实现日志切面
python_mopagunda的博客
01-30 434
aop实现日志管理
spring aop 切面添加日志
06-22
此工程为使用eclipse创建java project，使用jdk1.8，项目中包含完整的代码和jar包，导入eclipse即可运行
【log】AOP配置日志
weixin_34405354的博客
04-13 105
直接代码 QueryService.java接口 public interface QueryService { TbDiseases getTbDiseasesById(int id) throws ServerException; } QueryServiceImpl实现 public class QueryServiceImpl implements ...
Spring Boot 日志切面配置
xzh_blog
11-29 321
依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency>...
Spring Aop - 切面日志
空明的博客
05-09 526
SpringAop 切面日志
使用AOP切面实现日志记录功能
最新发布
心态的博客
10-26 4884
说到AOP大家都可以想到他是面向切面的编程，它通过将横切关注点（例如日志记录、事务管理、权限控制等）从主要业务逻辑中分离出来，以模块化的方式进行管理。在AOP中，通过定义切面（Aspect）来捕获和处理横切关注点，然后将其应用于特定的目标对象或方法。官方的解释有点抽象，我们举个例子说明：假设我们需要在多个方法中添加日志记录功能。传统的方式是在每个方法中都添加日志代码，但这样会导致代码重复，并且当我们需要修改日志记录逻辑时，需要逐个修改所有方法。
基于AOP实现日志切面功能
知易行难
07-11 1427
基础概念： Target（目标对象)：代理的目标对象。 Proxy（代理）：一个类被AOP织入增强后，就产生一个结果代理类。 Joinpoint（连接点）：所谓的连接点是指那些被拦截到的点。在spring中，这些点指的就是方法。通俗来讲就是可以被增强的方法叫做连接点。 Pointcut（切入点）：所谓切入点就是指我们要对拿些连接点进行拦截的定义。切点只是连接的一部分，真正被增强的方法 。 Advice（通知/增强）：所谓通知是指拦截到Joinpoint只后所要做的事情就是通知。封装增强业务逻辑的方法 As
注解实现spring AOP 示例
weixin_34088583的博客
05-10 91
2019独角兽企业重金招聘Python工程师标准>>> ...
springaop切面抽取日志
weixin_67283973的博客
12-19 132
springaop中切面抽取
aop切面配置
09-07 392
<!--切面配置--><aop:config> <aop:advisor advice-ref="txAdvice" pointcut="execution(* cn.gxkj.service.impl.*.*(..)"</aop:config> 转载于:https://www.cnblogs.com/dingyi-boss/p/1147...
理解Spring AOP：面向切面编程实战解析
"这篇Spring学习笔记主要探讨了AOP（面向切面编程）的概念和应用场景，通过一个简单的计算示例，介绍了如何在Spring框架中实现AOP代理，包括定义接口、实现类以及测试过程。" 在软件开发中，面向切面编程（Aspect-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值