一、背景
项目中需要对用户的各种操作做详细的操作日志记录,需要记录用户操作的操作模块、具体操作以及操作的数据记录ID等。
若写一个方法去保存操作,则需要每次手动去调用。由于是非业务性的操作,并且大量的重复操作,Spring AOP就能很好的解决这个问题。
由于用户操作的实现方法并不在同一个类中,而且每个操作的说明也不一样,所以用自定义注解作为切入点,来记录用户不同操作及其操作说明。
二、配置
2.1、导入jar包
- spring-aop.jar
- aspectjrt.jar
- aspectjweaver.jar
- aopalliance-1.0.jar
2.2、Spring的ApplicationContext.xml配置文件
2.2.1 配置头文件
xmlns:aop="http://www.springframework.org/schema/aop"
<!-- 在xsi:schemaLocation中添加 -->
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"
注:若没添加则会报 ==》
java错误-The prefix "aop" for element "aop:aspectj-autoproxy" is not bound.
2.2.2 配置注解扫描和AOP自动代理
<!-- 配置组件扫描功能 -->
<context:component-scan base-package="com.test"/>
<!-- 配置自动代理功能 -->
<aop:aspectj-autoproxy />
<aop:config proxy-target-class="true"></aop:config>
三、创建自定义注解
package com.test.common.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 品目操作日志注解
* @author zhoujin
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface OperationLogAnno {
/** 模块 */
String module();
/** 具体操作 */
String operate();
/** 品目编号 */
String pmbh();
/** 备注说明 */
String remarks() default "";
}
注:注解中定义的方法若没有给默认值,则写该注解的时候必须给该方法赋值!
四、Spring AOP切面类
package com.test.common.aop;
import java.lang.reflect.Method;
import java.util.Date;
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.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.test.common.annotation.OperationLogAnno;
import com.test.modules.sys.entity.User;
import com.test.modules.sys.utils.UserUtils;
import com.test.modules.zxztb.entity.operationLog.OperationLog;
import com.test.modules.zxztb.service.operationLog.OperationLogService;
/**
* 品目操作日志切面类
* @author zhoujin
* @date 2018-10-23
*/
@Aspect
@Component("operationLogAspect")
public class OperationLogAspect {
private static final Logger log = LoggerFactory.getLogger(OperationLogAspect.class);
@Autowired
private OperationLogService operationLogService;
// 配置织入点(以OperationLog注解为标志)
@Pointcut("@annotation(com.test.common.annotation.OperationLogAnno)")
public void logPointCut() {
}
/**
* 后置通知 用于拦截操作,在方法返回后执行
* @param joinPoint 切点
*/
@AfterReturning(pointcut = "logPointCut()")
public void doAfterReturn(JoinPoint joinPoint) {
handleLog(joinPoint, null);
}
/**
* 拦截异常操作,有异常时执行
* @param joinPoint
* @param e
*/
@AfterThrowing(value = "logPointCut()", throwing = "e")
public void doAfterThrow(JoinPoint joinPoint, Exception e) {
handleLog(joinPoint, e);
}
private void handleLog(JoinPoint joinPoint, Exception e) {
try {
// 获得注解
OperationLogAnno controllerLog = getAnnotationLog(joinPoint);
if (controllerLog == null) {
return;
}
// 品目编号
Object pmbh = controllerLog.pmbh();
// 模块详情
Object module = controllerLog.module();
// 具体操作
Object operate = controllerLog.operate();
// 备注说明
Object remarks = controllerLog.remarks();
// 操作用户信息
User currentUser = UserUtils.getUser();
// 访问类名
String className = joinPoint.getTarget().getClass().getName();
// 访问方法名
String methodName = joinPoint.getSignature().getName();
// 保存日志
log.info("\n====================================== 保存操作日志 ======================================");
OperationLog operationLog = new OperationLog();
operationLog.setPmbh(pmbh.toString());
operationLog.setModule(module.toString());
operationLog.setOperate(operate.toString());
operationLog.setOperate(remarks.toString());
operationLog.setOperatorLoginname(currentUser.getLoginName());
operationLog.setOperatorName(currentUser.getName());
operationLog.setOperateDate(new Date());
operationLog.setClassname(className);
operationLog.setMethodname(methodName);
operationLogService.save(operationLog);
log.info("\n=====================================================================================\n");
} catch (Exception exp) {
// 记录本地异常日志
log.error("\n====================================== 异常信息通知 ======================================");
log.error("异常信息:{}", exp.getMessage());
log.error("\n====================================================================================\n");
exp.printStackTrace();
}
}
/**
* 是否存在注解,如果存在就获取
*/
private static OperationLogAnno getAnnotationLog(JoinPoint joinPoint) throws Exception {
Signature signature = joinPoint.getSignature();
MethodSignature methodSignature = (MethodSignature) signature;
Method method = methodSignature.getMethod();
if (method != null) {
return method.getAnnotation(OperationLogAnno.class);
}
return null;
}
}
五、Controller上使用
@ResponseBody
@RequestMapping(value = "kaiQicb")
@RequiresPermissions("zxztb:dljgKbkzt:kqcb")
@OperationLogAnno(module="控制台", operate="开启流程", pmbh="1111111")
public AjaxJson kaiQicb(String id) {
AjaxJson j = new AjaxJson();
String message = "开启流程成功";
Zfcgpmbxm zfcgpmbxm = zfcgpmbxmService.get(id);
try {
zfcgpmbxm.setFlowstatus("7");
zfcgpmbxmService.save(zfcgpmbxm);
} catch (Exception e) {
e.printStackTrace();
j.setSuccess(false);
message = "开启流程失败";
}
j.setMsg(message);
return j;
}
注:此处注解上的pmbh是写死的,没有什么作用。但实际情况是,此处pmbh应取前端页面传来的参数id的值,那么怎么才能使注解中能获取到参数的值呢?
六、下载上面node2017博客中的AnnotationResolver,便可获取前端页面传来的参数值
6.1 Controller中
@OperationLogAnno(module="控制台", operate="开启流程", pmbh="#{id}")
public AjaxJson kaiQiKaiBiao(String id){
...
}
// 这样也可以
@OperationLogAnno(module="控制台", operate="开启流程", pmbh="#{pmxx.id}")
public AjaxJson kaiQiKaiBiao(Pmxx pmxx){
...
}
6.2 Spring AOP切面类中
private void handleLog(JoinPoint joinPoint, Exception e) {
try {
// 获得注解
OperationLogAnno controllerLog = getAnnotationLog(joinPoint);
if (controllerLog == null) {
return;
}
AnnotationResolver annotationResolver = AnnotationResolver.newInstance();
// 品目编号
Object pmbh = annotationResolver.resolver(joinPoint, controllerLog.pmbh());
// 模块详情
Object module = annotationResolver.resolver(joinPoint, controllerLog.module());
// 具体操作
Object operate = annotationResolver.resolver(joinPoint, controllerLog.operate());
// 备注说明
Object remarks = annotationResolver.resolver(joinPoint, controllerLog.remarks());
// 操作用户信息
User currentUser = UserUtils.getUser();
// 访问类名
String className = joinPoint.getTarget().getClass().getName();
// 访问方法名
String methodName = joinPoint.getSignature().getName();
// 保存日志
...
} catch (Exception exp) {
exp.printStackTrace();
}
6.4 AnnotationResolver代码(来自:node2017 ==》java在注解中绑定方法参数的解决方案)
package com.jeeplus.common.annotation;
import java.lang.reflect.Method;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.reflect.MethodSignature;
/**
* 该类的作用可以把方法上的参数绑定到注解的变量中,注解的语法#{变量名}
* 能解析类似#{user}或者#{user.id}或者{user.createBy.id}
*/
public class AnnotationResolver {
private static AnnotationResolver resolver ;
public static AnnotationResolver newInstance(){
if (resolver == null) {
return resolver = new AnnotationResolver();
}else{
return resolver;
}
}
/**
* 解析注解上的值
* @param joinPoint
* @param str 需要解析的字符串
* @return
*/
public Object resolver(JoinPoint joinPoint, String str) {
if (str == null) return null ;
Object value = null;
if (str.matches("#\\{\\D*\\}")) {// 如果name匹配上了#{},则把内容当作变量
String newStr = str.replaceAll("#\\{", "").replaceAll("\\}", "");
if (newStr.contains(".")) { // 复杂类型
try {
value = complexResolver(joinPoint, newStr);
} catch (Exception e) {
e.printStackTrace();
}
} else {
value = simpleResolver(joinPoint, newStr);
}
} else { //非变量
value = str;
}
return value;
}
private Object complexResolver(JoinPoint joinPoint, String str) throws Exception {
MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
String[] names = methodSignature.getParameterNames();
Object[] args = joinPoint.getArgs();
String[] strs = str.split("\\.");
for (int i = 0; i < names.length; i++) {
if (strs[0].equals(names[i])) {
Object obj = args[i];
Method dmethod = obj.getClass().getDeclaredMethod(getMethodName(strs[1]), null);
Object value = dmethod.invoke(args[i]);
return getValue(value, 1, strs);
}
}
return null;
}
private Object getValue(Object obj, int index, String[] strs) {
try {
if (obj != null && index < strs.length - 1) {
Method method = obj.getClass().getDeclaredMethod(getMethodName(strs[index + 1]), null);
obj = method.invoke(obj);
getValue(obj, index + 1, strs);
}
return obj;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
private String getMethodName(String name) {
return "get" + name.replaceFirst(name.substring(0, 1), name.substring(0, 1).toUpperCase());
}
private Object simpleResolver(JoinPoint joinPoint, String str) {
MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
String[] names = methodSignature.getParameterNames();
Object[] args = joinPoint.getArgs();
for (int i = 0; i < names.length; i++) {
if (str.equals(names[i])) {
return args[i];
}
}
return null;
}
}