我們有這樣子的需求,需要記錄用戶操作某個方法的信息並記錄到日誌裏面,例如,用戶在保存和更新任務的時候,我們需要記錄下用戶的ip,具體是保存還是更新,調用的是哪個方法,保存和更新的任務名稱以及操作是否成功。
這裏最好的技術就是spring aop + annotation,首先我來定義個註解類
/**
* 參數命名好麻煩,我就隨便了,只是演示下用法
* @author liuxg
* @date 2016年4月13日 上午7:53:52
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Logger {
String param1() default "";
String param2() default "" ;
String param3() default "" ;
String param4() default "" ;
}
然後我們在controller中定義一個方法,即用戶具體調用的保存或者更新的方法
@RequestMapping("/mvc24")
@Logger(param1 = "#{task.project.projectName}",param2 = "#{task.taskName}",param3 = "#{name}",param4 = "常量")
public void mvc24(Task task ,String name){
//...
}
在這裏我們就可以把參數中的task或者name的相關信息綁定到註解類中
然後我們再定義一個切面,我們就可以動態的獲取和處理註解類的一些信息了
/**
* 日誌切面
* @author liuxg
* @date 2015年10月13日 下午5:55:44
*/
@Component
@Aspect
public class LoggerAspect {
@Around("@annotation(com.liuxg.logger.annotation.Logger)")
public Object around(JoinPoint joinPoint) {
MethodSignature methodSignature = (MethodSignature)joinPoint.getSignature();
Method method = methodSignature.getMethod();
Logger logger = (Logger) method.getAnnotation(Logger.class);
Object value1 = AnnotationResolver.newInstance().resolver(joinPoint, logger.param1());
Object value2 = AnnotationResolver.newInstance().resolver(joinPoint, logger.param1());
Object value3 = AnnotationResolver.newInstance().resolver(joinPoint, logger.param1());
Object value4 = AnnotationResolver.newInstance().resolver(joinPoint, logger.param1());
return null ;
}
}
AnnotationResolver是我這邊寫的一個解析註解類語法的一個解析器,利用該解析器,可以把註解類中這樣子的語法直接解析#{方法變量名}
該解析器只有唯一的一個方法
import java.lang.reflect.Method;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.reflect.MethodSignature;
/**
* 該類的作用可以把方法上的參數綁定到註解的變量中,註解的語法#{變量名}
* 能解析類似#{task}或者#{task.taskName}或者{task.project.projectName}
*/
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;
}
}
總結:
使用aop註解方式實現日誌記錄可以減少代碼冗餘,降低維護成本。相比於傳統的aop取固定入參,動態註解方式可以降低代碼侵入,使用簡單、取值方便。