Spring自定义注解AOP，进行记录用户操作日志

最新推荐文章于 2024-09-10 13:53:03 发布
最新推荐文章于 2024-09-10 13:53:03 发布
阅读量2.8k 收藏 8
点赞数 1
分类专栏： Spring 文章标签： spring aop 系统日志 日志管理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21454973/article/details/80347302
版权

数据库设计：


数据库名：log

结构：


generator生成的Log以及LogWithBLOBs修改：

public class Log implements Serializable {
	private String logId;			//日志主键	
	private String type;			//日志类型
	private Date operateDate;			//开始时间

    private static final long serialVersionUID = 1L;

    public String getLogId() {
        return StringUtils.isBlank(logId) ? logId : logId.trim();
    }
    public void setLogId(String logId) {
        this.logId = logId;
    }
    
    
    public String getType() {
        return StringUtils.isBlank(type) ? type : type.trim();
    }
    public void setType(String type) {
        this.type = type;
    }

    public Date getOperateDate() {
        return operateDate;
    }
    public void setOperateDate(Date operateDate) {
        this.operateDate = operateDate;
    }
}
public class LogWithBLOBs extends Log implements Serializable {
	private String title;			//日志标题	
	private String remoteAddr;			//请求地址	
	private String requestUri;			//URI	
	private String method;			//请求方式	
	private String params;			//提交参数	
	private String exception;			//异常	
	private String timeout;			//结束时间	
	private String userId;			//用户ID	

    private static final long serialVersionUID = 1L;

    public String getTitle() {
        return StringUtils.isBlank(title) ? title : title.trim();
    }
    public void setTitle(String title) {
        this.title = title;
    }
    
    
    public String getRemoteAddr() {
        return StringUtils.isBlank(remoteAddr) ? remoteAddr : remoteAddr.trim();
    }
    public void setRemoteAddr(String remoteAddr) {
        this.remoteAddr = remoteAddr;
    }
    
    
    public String getRequestUri() {
        return StringUtils.isBlank(requestUri) ? requestUri : requestUri.trim();
    }
    public void setRequestUri(String requestUri) {
        this.requestUri = requestUri;
    }
    
    
    public String getMethod() {
        return StringUtils.isBlank(method) ? method : method.trim();
    }
    public void setMethod(String method) {
        this.method = method;
    }
    
    
    public String getParams() {
        return StringUtils.isBlank(params) ? params : params.trim();
    }
    public void setParams(String params) {
        this.params = params;
    }
    
	/**
	 * 设置请求参数
	 * @param paramMap
	 */
	public void setMapToParams(Map<String, String[]> paramMap) {
		if (paramMap == null){
			return;
		}
		StringBuilder params = new StringBuilder();
		for (Map.Entry<String, String[]> param : ((Map<String, String[]>)paramMap).entrySet()){
			params.append(("".equals(params.toString()) ? "" : "&") + param.getKey() + "=");
			String paramValue = (param.getValue() != null && param.getValue().length > 0 ? param.getValue()[0] : "");
			params.append(StringUtils.abbr(StringUtils.endsWithIgnoreCase(param.getKey(), "password") ? "" : paramValue, 100));
		}
		this.params = params.toString();
	}
    
    
    public String getException() {
        return StringUtils.isBlank(exception) ? exception : exception.trim();
    }
    public void setException(String exception) {
        this.exception = exception;
    }
    
    

    
    public String getTimeout() {
        return StringUtils.isBlank(timeout) ? timeout : timeout.trim();
    }
    public void setTimeout(String timeout) {
        this.timeout = timeout;
    }
    
    
    public String getUserId() {
        return StringUtils.isBlank(userId) ? userId : userId.trim();
    }
    public void setUserId(String userId) {
        this.userId = userId;
    }
	
}

service以及impl：

public interface LogService {
    long countByExample(LogExample example);

    int deleteByExample(LogExample example);

    int deleteByPrimaryKey(String logid);

    int insert(LogWithBLOBs record);

    int insertSelective(LogWithBLOBs record);

    List<LogWithBLOBs> selectByExampleWithBLOBs(LogExample example);

    List<Log> selectByExample(LogExample example);

    LogWithBLOBs selectByPrimaryKey(String logid);

    int updateByExampleSelective(@Param("record") LogWithBLOBs record, @Param("example") LogExample example);

    int updateByExampleWithBLOBs(@Param("record") LogWithBLOBs record, @Param("example") LogExample example);

    int updateByExample(@Param("record") Log record, @Param("example") LogExample example);

    int updateByPrimaryKeySelective(LogWithBLOBs record);

    int updateByPrimaryKeyWithBLOBs(LogWithBLOBs record);

    int updateByPrimaryKey(Log record);
}
@Service("logService")
public class LogServiceImpl  implements LogService{
	

	@Autowired
	private LogMapper dao;

	@Override
	public long countByExample(LogExample example) {
		// TODO Auto-generated method stub
		return dao.countByExample(example);
	}

	@Override
	public int deleteByExample(LogExample example) {
		// TODO Auto-generated method stub
		return dao.deleteByExample(example);
	}

	@Override
	public int deleteByPrimaryKey(String logid) {
		// TODO Auto-generated method stub
		return dao.deleteByPrimaryKey(logid);
	}

	@Override
	public int insert(LogWithBLOBs record) {
		// TODO Auto-generated method stub
		return dao.insert(record);
	}

	@Override
	public int insertSelective(LogWithBLOBs record) {
		// TODO Auto-generated method stub
		return dao.insertSelective(record);
	}

	@Override
	public List<LogWithBLOBs> selectByExampleWithBLOBs(LogExample example) {
		// TODO Auto-generated method stub
		return dao.selectByExampleWithBLOBs(example);
	}

	@Override
	public List<Log> selectByExample(LogExample example) {
		// TODO Auto-generated method stub
		return dao.selectByExample(example);
	}

	@Override
	public LogWithBLOBs selectByPrimaryKey(String logid) {
		// TODO Auto-generated method stub
		return dao.selectByPrimaryKey(logid);
	}

	@Override
	public int updateByExampleSelective(LogWithBLOBs record, LogExample example) {
		// TODO Auto-generated method stub
		return dao.updateByExampleSelective(record, example);
	}

	@Override
	public int updateByExampleWithBLOBs(LogWithBLOBs record, LogExample example) {
		// TODO Auto-generated method stub
		return dao.updateByExampleWithBLOBs(record, example);
	}

	@Override
	public int updateByExample(Log record, LogExample example) {
		// TODO Auto-generated method stub
		return dao.updateByExample(record, example);
	}

	@Override
	public int updateByPrimaryKeySelective(LogWithBLOBs record) {
		// TODO Auto-generated method stub
		return dao.updateByPrimaryKeySelective(record);
	}

	@Override
	public int updateByPrimaryKeyWithBLOBs(LogWithBLOBs record) {
		// TODO Auto-generated method stub
		return dao.updateByPrimaryKeyWithBLOBs(record);
	}

	@Override
	public int updateByPrimaryKey(Log record) {
		// TODO Auto-generated method stub
		return dao.updateByPrimaryKey(record);
	}

}


然后就是注解的接口：

/**
 * 
 * 自定义注解，用于Controller层
 *
 */
@Target({ ElementType.PARAMETER, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
public @interface SystemControllerLog {
	
	String description() default "";
}

切口类：

@Aspect
@Component
public class SystemLogAspect {
	private  static  final Logger logger = LoggerFactory.getLogger(SystemLogAspect. class);
	
	private static final ThreadLocal<Date> beginTimeThreadLocal_controller =
			new NamedThreadLocal<Date>("ThreadLocal beginTime");
	private static final ThreadLocal<LogWithBLOBs> logThreadLocal = 
			new NamedThreadLocal<LogWithBLOBs>("ThreadLocal log");
	
	private static final ThreadLocal<Managers> currentUser=new NamedThreadLocal<>("ThreadLocal user");
	
	@Autowired(required=false)
	private HttpServletRequest request;
	
	@Autowired
	private ThreadPoolTaskExecutor threadPoolTaskExecutor;

	@Autowired
	private LogService logService;

	/**
	 * Controller层切点 注解拦截
	 */
	@Pointcut("@annotation(com.xx.syslog.SystemControllerLog)")
	public void controllerAspect(){}
	
	/**
	 * 方法规则拦截
	 */
	@Pointcut("execution(* com.xx.web.*.*(..))")
	public void controllerPointerCut(){}
	/**
	 * 前置通知 用于拦截Controller层记录用户的操作的开始时间
	 * @param joinPoint 切点
	 * @throws InterruptedException 
	 */
	@Before("controllerAspect()")
	public void doBefore(JoinPoint joinPoint) throws InterruptedException{
		Date beginTime=new Date();
		beginTimeThreadLocal_controller.set(beginTime);
		//读取session中的用户 
		HttpSession session = request.getSession();       
		Managers user = (Managers) session.getAttribute("managers");    
		currentUser.set(user);

	}
	
	/**
	 * 后置通知 用于拦截Controller层记录用户的操作
	 * @param joinPoint 切点
	 */
	@SuppressWarnings("unchecked")
	@After("controllerAspect()")
	public void doAfter(JoinPoint joinPoint) {
		Managers user = currentUser.get();
        //登入login操作 前置通知时用户未校验 所以session中不存在用户信息
        if(user == null){
    		HttpSession session = request.getSession();       
    	    user = (Managers) session.getAttribute("managers");    
    	    if(user==null){
    	    	return;
    	    }
        }
        Object [] args = joinPoint.getArgs();
        
    	String title="";
    	String type="info";						  //日志类型(info:入库,error:错误)
    	String remoteAddr=request.getRemoteAddr();//请求的IP
    	String requestUri=request.getRequestURI();//请求的Uri
    	String method=request.getMethod();		  //请求的方法类型(post/get)
    	Map<String,String[]> params=request.getParameterMap(); //请求提交的参数
    	try {
    		title=getControllerMethodDescription2(joinPoint);
    	} catch (Exception e) {
    		e.printStackTrace();
    	}    
    	// debu模式下打印JVM信息。
    	long beginTime = beginTimeThreadLocal_controller.get().getTime();//得到线程绑定的局部变量（开始时间）  
    	long endTime = System.currentTimeMillis(); 	//2、结束时间  
    	
    	LogWithBLOBs log=new LogWithBLOBs();
    	log.setLogId(UuidUtils.creatUUID());
    	log.setTitle(title);
    	log.setType(type);
    	log.setRemoteAddr(remoteAddr);
    	log.setRequestUri(requestUri);
    	log.setMethod(method);
    	log.setMapToParams(params);
    	log.setUserId(user.getName());
    	Date operateDate=beginTimeThreadLocal_controller.get();
    	log.setOperateDate(operateDate);
    	log.setTimeout(DateUtils.formatDateTime(endTime - beginTime));

    	 //1.直接执行保存操作
        //this.logService.createSystemLog(log);

        //2.优化:异步保存日志
        //new SaveLogThread(log, logService).start();

        //3.再优化:通过线程池来执行日志保存
        threadPoolTaskExecutor.execute(new SaveLogThread(log, logService));
        logThreadLocal.set(log);
       
 
	}
	
	/**
	 *  异常通知 
	 * @param joinPoint
	 * @param e
	 */
	@AfterThrowing(pointcut = "controllerAspect()", throwing = "e")  
	public  void doAfterThrowing(JoinPoint joinPoint, Throwable e) {
		LogWithBLOBs log = logThreadLocal.get();
		if(log != null){
			log.setType("error");
			log.setException(e.toString());
			new UpdateLogThread(log, logService).start();			
		}
	}
	

	/**
	 * 获取注解中对方法的描述信息 用于Controller层注解
	 * 
	 * @param joinPoint 切点
	 * @return 方法描述
	 */
	public static String getControllerMethodDescription2(JoinPoint joinPoint) {
		MethodSignature signature = (MethodSignature) joinPoint.getSignature();
		Method method = signature.getMethod();
		SystemControllerLog controllerLog = method
				.getAnnotation(SystemControllerLog.class);
		String discription = controllerLog.description();
		return discription;
	}

	/**
	 * 保存日志线程
	 * 
	 * @author lin.r.x
	 *
	 */
	private static class SaveLogThread implements Runnable {
		private LogWithBLOBs log;
		private LogService logService;

		public SaveLogThread(LogWithBLOBs log, LogService logService) {
			this.log = log;
			this.logService = logService;
		}

		@Override
		public void run() {
			logService.insertSelective(log);
		}
	}

	/**
	 * 日志更新线程
	 * 
	 * @author lin.r.x
	 *
	 */
	private static class UpdateLogThread extends Thread {
		private LogWithBLOBs log;
		private LogService logService;

		public UpdateLogThread(LogWithBLOBs log, LogService logService) {
			super(UpdateLogThread.class.getSimpleName());
			this.log = log;
			this.logService = logService;
		}

		@Override
		public void run() {
			this.logService.updateByPrimaryKeySelective(log);
		}
	}
}

spring 配置扫描切面，开启@AspectJ注解的支持：

<!-- 启动对@AspectJ注解的支持 -->  
	<aop:aspectj-autoproxy/> 
 <!-- 自定义注解，执行记录系统日志 -->
    <context:component-scan base-package="com.xx.syslog" />
<bean id="taskExecutor"   
		class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">  
		<property name="corePoolSize" value="5" />  
		<property name="maxPoolSize" value="10" />  
	</bean>

使用：



模拟error情况：


然后数据库：


前端显示略；

参考：地址

我惠依旧
关注
专栏目录
Spring AOP + 自定义注解，一行代码实现用户操作日志记录
Java日常笔记精选的博客
11-14 909
Spring AOP + 自定义注解，快速实现日志记录
spring AOP自定义注解方式实现日志管理的实例讲解
08-28
在本文中，我们将探讨如何使用 Spring AOP 实现日志管理，并使用自定义注解方式来记录日志信息。这种方式可以灵活地实现日志管理，提高系统的可维护性和可扩展性。 首先，我们需要在 applicationContext-mvc.xml ...
利用spring AOP记录用户操作日志的方法示例
08-30
主要给大家介绍了关于利用spring AOP记录用户操作日志的相关资料，文中通过示例代码介绍的非常详细，对大家具有一定的参考学习价值，需要的朋友们下面跟着小编一起来学习学习吧。
使用Spring AOP自定义注解方式实现用户操作日志记录
施勇
10-04 2318
1，开发环境 操作系统：Windows 7 JDK：1.8.0_161 Eclipse：Mars.2 Release (4.5.2) 2，自定义注解类UserLog @Target({ElementType.PARAMETER, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented public @inte...
基于自定义注解与 Spring AOP 的通用日志记录实现
天天的博客
08-09 957
在软件开发中，针对用户操作日志的记录是一个普遍且重要的需求，旨在跟踪用户行为、保障系统安全及进行后续的问题追踪与性能分析。传统上，若在每次方法调用时都手动构造日志实体并同步插入数据库，不仅会导致代码冗余且难以维护，还会因同步操作而拖慢系统性能。为了优化这一流程, 可以使用自定义注解和aop的方式进行对日志的记录, 能动态记录指定记录的参数, 如请求参数, 响应参数, 操作时间, 操作用户的用户名, 方法耗时等等, 可以灵活拓展，而无需在每个业务逻辑点中显式编写日志代码。
基于注解的aop实现用户操作日志管理
Erictju的博客
11-30 1056
AOP是spring的核心之一。用AOP来实现用户操作日志管理非常合适。 学东西应该先具体再抽象。
日志 - 01 Spring AOP+自定义注解记录用户操作日志
你今天真好看呀
06-08 614
2. 自定义注解 @OperateLog 3. 日志打印 AOP 切面 4. 工具类 OperationLogUtil 5. 打印日志 IOperationLogService 6. 配置类 OprLogRedisAutoConfiguration 7. 配置类 OperationLogAutoConfiguration 8. spring.factories配置 如果想将日志报存，可以使用ORM框架保存到数据库表中：........................
自定义注解+Spring AOP实现记录用户操作日志
周末未至
11-03 3836
一、背景 项目中需要对用户的各种操作做详细的操作日志记录，需要记录用户操作的操作模块、具体操作以及操作的数据记录ID等。 若写一个方法去保存操作，则需要每次手动去调用。由于是非业务性的操作，并且大量的重复操作，Spring AOP就能很好的解决这个问题。 由于用户操作的实现方法并不在同一个类中，而且每个操作的说明也不一样，所以用自定义注解作为切入点，来记录用户不同操作及...
spring aop 自定义注解保存操作日志到mysql数据库 源码
11-25
4、想看spring aop 注解实现记录系统日志并入库等 二、能学到什么 1、收获可用源码 2、能够清楚的知道如何用spring aop实现自定义注解以及注解的逻辑实现 （需要知道原理的请看spring aop源码，此处不做赘述） 3、...
自定义注解+Spring AOP实现记录用户操作日志-附件资源
03-02
自定义注解+Spring AOP实现记录用户操作日志-附件资源
SpringAop（自定义注解）实现用户操作日志记录
yjt520557的博客
12-19 4338
1.简介 我在使用spring完成项目的时候需要完成记录日志，我开始以为Spring 的AOP功能，就可以轻松解决，半个小时都不用，可是经过一番了解过后，发现一般的日志记录，只能记录一些简单的操作，例如表名、表名称等记录不到。这个时侯就用到了自定义注解，把想要记录的内容放在注解中，通过切入点来获取到注解参数，然后将参数插入数据库记录 2.Spring AOP 对于Spring Aop的基本介...
springAop+自定义注解实现权限管理
09-14
一个简单的采用自定义注解结合SpringAop实现方法执行的权限管理，这个demo中并没有涉及到与数据库的交互和业务代码，用户权限在登陆时采用简单的手动初始化。该demo用的jdk1.7编译，Spring4.0版本，只想通过这个demo熟悉相关技术，如有不足之处还望各位大佬多多包涵并指出。
spring中自定义注解(annotation)与AOP中获取注解
09-24
spring中自定义注解(annotation)与AOP中获取注解.通过实例演示自定义注解。
项目系统复盘，Spring AOP实现用户操作日志功能
duan18888的博客
05-29 507
今天项目完了，复盘了一下系统，发现还是有一些东西值得拿出来和大家分享一下。 需求分析 系统需要对用户的操作进行记录，方便未来溯源 首先想到的就是在每个方法中，去实现记录的逻辑，但是这样做肯定是不现实的，首先工作量大，其次违背了软件工程设计原则（开闭原则） 这种需求显然是对代码进行增强，首先想到的是使用 SpringBoot 提供的 AOP 结合注解的方式来实现 功能实现 1、 需要一张记录日志的 Log 表 导出的 sql 如下： -- mcams.t_log definiti.
自定义注解AOP
yuru974882032的博客
03-12 715
需求： 项目中有些模块需要加入工作流审批流程，并且可以选择是否开启工作流。 于是根据需求就想到了用aop做一个通用的模块开关检验。 如果模块没有开启工作流，就直接放行。如果开启了工作流，就启动该模块的工作流流程。 下面上代码 1、首先创建自定义注解 @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @int...
AOP 自定义注解
最新发布
tianzhiya_ts的专栏
09-10 268
自定义注释实现记录请求耗时和转换返回值格式
自定义注解----AOP
Edwin_Hu的博客
02-03 477
一.注解的作用：            在开发过程中时刻都会用到注解，它能够使得编程更加简洁，代码更加清晰。最近有用到自定义注解，记录一下注解的定义与使用。 二.应用：                    打日志、分析代码执行时间、权限控制、事务处理、访问频率控制、异常处理等 三.自定义注解编写规则: Annotation型定义为@interface, 所有的Annotation会自动...
Java AOP自定义注解
程序员小杨哥的博客
12-24 3577
主要介绍在Springboot中如何实现一个自定义注解，通过自定义注解去实现一些定制化的需求。
自定义注解结合AOP之实战应用
qq_28650671的博客
12-19 8821
自定义注解结合AOP之实战应用背景介绍步骤流程1. 定义注解2.将注解应用于方法和参数3.定义切面4.测试结果致谢 背景介绍 最近在项目中写了一个公共的上传文件接口，项目中有多个业务场景会使用到上传文件，每个场景对上传的文件类型，文件大小有不同的要求。 按常规操作，我们可以在Controller层提供多个接口，然后在每个接口里写if去校验；或者是在一个接口里定义类型去区分不同的业务场景，再分别写if去校验；总而言之，就是要写if去校验。 然后呢，我就不想写if校验，觉得重复代码太多，不够优雅。于是考虑能否通
SpringMVC自定义注解：AOP实现业务操作日志
本文将介绍如何在Spring MVC项目中创建一个自定义注解，利用AOP进行日志记录，以便满足客户对于业务操作日志的需求。 首先，我们需要理解需求背景。在项目接近尾声时，客户要求记录所有的业务操作日志，并包含关键...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值