国产一级a片免费看高清,亚洲熟女中文字幕在线视频,黄三级高清在线播放,免费黄色视频在线看

打開APP
userphoto
未登錄

開通VIP，暢享免費電子書等14項超值服

開通VIP

首頁

好書

留言交流

下載APP

聯(lián)系客服
SpringAOP注解方式記錄操作日志(操作模塊,操作功能,調用方法,主鍵信息等)支持多筆操作時記錄

開源項目地址: github開源鏈接

使用AOP切入的方式記錄操作日志,本代碼主要采用枚舉作為記錄方式,具體代碼如下.

首先先定義先關枚舉:

  1. /** 
  2.  * 枚舉公共接口 
  3.  * @author LeiYong 
  4.  * 
  5.  */  
  6. public interface EnumSuper {  
  7.     /** 
  8.      * 獲取值 
  9.      * @return 
  10.      */  
  11.     public String getValue();  
  12.     /** 
  13.      * 獲取描述信息 
  14.      * @return 
  15.      */  
  16.     public String getDiscription();  
  17. }  

  1. public enum LogOperateEnum implements EnumSuper{  
  2.     Select("0","查詢"),Save("1","新增"),Update("2","修改"),Delete("3","刪除");  
  3.     private String value;  
  4.     private String discription;  
  5.       
  6.     LogOperateEnum(String value, String discription) {  
  7.         this.value = value;  
  8.         this.discription = discription;  
  9.     }  
  10.   
  11.     @Override  
  12.     public String getValue() {  
  13.         return value;  
  14.     }  
  15.   
  16.     @Override  
  17.     public String getDiscription() {  
  18.         return discription;  
  19.     }  
  20.   
  21.       
  22. }  

  1. public enum LogEnum implements EnumSuper{  
  2.     Sys("系統(tǒng)",""),  
  3.     Activity("活動",""),  
  4.     Shop("商城",""),  
  5.     Usr("用戶",""),  
  6.     Scd("預約","")  
  7.     ;  
  8.     private String value;  
  9.     private String discription;  
  10.       
  11.     LogEnum(String value, String discription) {  
  12.         this.value = value;  
  13.         this.discription = discription;  
  14.     }  
  15.   
  16.     @Override  
  17.     public String getValue() {  
  18.         return value;  
  19.     }  
  20.   
  21.     @Override  
  22.     public String getDiscription() {  
  23.         return discription;  
  24.     }  
  25.   
  26.       
  27. }  

接下來定義注解Logger

  1. @Retention(RetentionPolicy.RUNTIME)  
  2. @Target(ElementType.METHOD)  
  3. @Documented  
  4. public @interface Logger {  
  5.     /** 
  6.      * 操作類型 0-查詢 1-新增 2-修改 3-刪除 
  7.      * @return 
  8.      */  
  9.     LogOperateEnum type();  
  10.     /** 
  11.      * 所屬模塊 
  12.      * @return 
  13.      */  
  14.     LogEnum model();  
  15.     /** 
  16.      * 業(yè)務主鍵 
  17.      * @return 
  18.      */  
  19.     String title() default "#pk";  
  20. }  

最后LoggerAspect切面類

此處keyGenerate為主鍵生成,參考另一篇博文,使用redis生成數(shù)據(jù)庫主鍵自增

使用redis生成數(shù)據(jù)庫主鍵自增

  1. package com.cykj.base.core.aop;  
  2.   
  3. import java.lang.reflect.Method;  
  4. import java.util.Date;  
  5.   
  6. import javax.servlet.http.HttpServletRequest;  
  7.   
  8. import org.apache.commons.lang3.StringUtils;  
  9. import org.aspectj.lang.ProceedingJoinPoint;  
  10. import org.aspectj.lang.annotation.Around;  
  11. import org.aspectj.lang.annotation.Aspect;  
  12. import org.aspectj.lang.annotation.Pointcut;  
  13. import org.springframework.beans.factory.annotation.Autowired;  
  14. import org.springframework.stereotype.Component;  
  15. import org.springframework.web.context.request.RequestContextHolder;  
  16. import org.springframework.web.context.request.ServletRequestAttributes;  
  17.   
  18. import com.cykj.base.common.annotation.Logger;  
  19. import com.cykj.base.common.system.SystemConfig;  
  20. import com.cykj.base.common.system.properties.AdminPropertiesConfig;  
  21. import com.cykj.base.common.util.PropertiesCacheUtil;  
  22. import com.cykj.base.common.util.StringUtil;  
  23. import com.cykj.base.core.model.log.LogOperater;  
  24. import com.cykj.base.core.model.sys.SysUser;  
  25. import com.cykj.base.core.model.usr.UsrUser;  
  26. import com.cykj.base.core.model.usr.UsrUserSlave;  
  27. import com.cykj.base.core.provide.log.LogOperaterService;  
  28. import com.cykj.base.core.util.AopUtil;  
  29. import com.cykj.base.core.util.WebUtils;  
  30.   
  31. /** 
  32.  * 操作日志 
  33.  * @author LeiYong 
  34.  * 
  35.  */  
  36. @Aspect  
  37. @Component  
  38. public class LoggerAspect {  
  39.       
  40.     @Autowired  
  41.     private LogOperaterService logOperaterService;  
  42.     @Pointcut("@annotation(com.cykj.base.common.annotation.Logger)")    
  43.     private void loggerMethod(){}//定義一個切入點,此處Logger為Logger類全路徑    
  44.     /** 
  45.      * 記錄操作日志 
  46.      *  
  47.      * @param jp 
  48.      * @return 
  49.      * @throws Throwable 
  50.      */  
  51.     @Around("loggerMethod()")  
  52.     public Object logger(ProceedingJoinPoint jp) throws Throwable {  
  53.           
  54.         Object result = null;  
  55.         Boolean logEnable = SystemConfig.LOG_ENABLE;  
  56.         result = AopUtil.executeJoinPointMethod(jp, jp.getArgs());  
  57.         if (logEnable&&result!=null) {  
  58.             LogOperater lo = null;  
  59.             SysUser su = getLoginSysUser();  
  60.             if (su!=null) {  
  61.                 lo = getLogBySysUser(su, jp);  
  62.             }else {  
  63.                 UsrUserSlave uu = getLoginUsrUser();  
  64.                 lo = getLogByUsrUser(uu, jp);  
  65.             }  
  66.             if (lo!=null) {  
  67.                 logOperaterService.insertSelective(lo);  
  68.             }  
  69.         }  
  70.         return result;  
  71.     }  
  72.   
  73.     /** 
  74.      * 記錄系統(tǒng)用戶操作日志 
  75.      * @param user 
  76.      * @param jp 
  77.      * @return 
  78.      */  
  79.     private LogOperater getLogBySysUser(SysUser user,ProceedingJoinPoint jp){  
  80.         LogOperater logOperater = getLogger(jp);  
  81.         if (logOperater!=null) {  
  82.             logOperater.setCreateBy(user.getPk());  
  83.             logOperater.setFrom("0");  
  84.             logOperater.setOrgPk(user.getOrgPk());  
  85.         }  
  86.         return logOperater;  
  87.     }  
  88.     /** 
  89.      * 記錄微信用戶操作日志 
  90.      * @param user 
  91.      * @param jp 
  92.      * @return 
  93.      */  
  94.     private LogOperater getLogByUsrUser(UsrUser user,ProceedingJoinPoint jp){  
  95.         LogOperater logOperater = getLogger(jp);  
  96.         if (logOperater!=null) {  
  97.             logOperater.setCreateBy(user.getPk());  
  98.             logOperater.setFrom("1");  
  99. //          logOperater.setOrgPk(user.getOrgPk());  
  100.         }  
  101.         return logOperater;  
  102.     }  
  103.   
  104.     private LogOperater getLogger(ProceedingJoinPoint jp){  
  105.         //獲取切入點方法及參數(shù)  
  106.         Method method = AopUtil.getMethod(jp);  
  107.         Logger t = AopUtil.getMethodAnnotation(method, Logger.class);  
  108.         try {  
  109.             Boolean flag = PropertiesCacheUtil.loadProjectProperties(AdminPropertiesConfig.LOGGER_CONFIG).getBoolean(t.type().toString());  
  110.             //未配置或true都記錄日志,僅為false時不記錄  
  111.             if (flag!=null&&!flag) {  
  112.                 return null;  
  113.             }  
  114.         } catch (Exception e) {  
  115.             // TODO Auto-generated catch block  
  116.             e.printStackTrace();  
  117.         }  
  118.         String[] paramNames = AopUtil.getMethodParamNames(method);  
  119.         String pk = AopUtil.parseKeyByParam(t.title(),paramNames, jp.getArgs());  
  120.         //主鍵,機構pk,創(chuàng)建人,創(chuàng)建時間,操作類型,模塊,處理方法,主鍵,操作內容  
  121.         //自增長主鍵  
  122.         LogOperater logOperater = new LogOperater();  
  123.         logOperater.setCreateTime(new Date());  
  124.         logOperater.setType(t.type().getValue());  
  125.         logOperater.setModel(t.model().getValue());  
  126.         logOperater.setFunc(t.model().getDiscription());  
  127.         logOperater.setMethod(method.getName());  
  128.         if (StringUtils.isNotBlank(pk)) {  
  129.             int index = pk.indexOf(",");  
  130.             if (index<0) {  
  131.                 logOperater.setTitle(pk);  
  132.             }else{  
  133.                 logOperater.setTitle(StringUtil.subString(pk, 0, index));  
  134.                 int count = StringUtils.countMatches(pk, ",");  
  135.                 String content = SystemConfig.LOG_CONTENT_LENGTH>pk.length()?pk:StringUtil.subString(pk, 0, SystemConfig.LOG_CONTENT_LENGTH)+"...";  
  136.                 logOperater.setContent(count+"筆:"+content);  
  137.             }  
  138.         }  
  139.         return logOperater;  
  140.     }  
  141.     /** 
  142.      * 獲取系統(tǒng)登錄用戶 
  143.      * @return 
  144.      */  
  145.     private SysUser getLoginSysUser(){  
  146.         HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();      
  147.         return WebUtils.getLoginUser(request);  
  148.     }  
  149.     /** 
  150.      * 獲取微信登錄用戶(未實現(xiàn)) 
  151.      * @return 
  152.      */  
  153.     private UsrUserSlave getLoginUsrUser(){  
  154.         return null;  
  155.     }  
  156.       
  157. }  


再在spring的xml中配置掃描到LoggerAspect所在package目錄,大功告成

使用起來也非常方便,在需要加操作日志的方法上加個注解就OK了,如此則記錄為系統(tǒng)模塊,執(zhí)行查詢,主鍵為參數(shù)pk(此處使用springSpel表達式解析)

  1. @Logger(model=LogEnum.Sys,type=LogOperateEnum.Select,title="#pk")  
  2.     public Json get(String orgPk,String pk) {}  

最后附上AOPUtil代碼

  1. package com.cykj.base.core.util;  
  2.   
  3. import java.lang.annotation.Annotation;  
  4. import java.lang.reflect.Method;  
  5.   
  6. import org.apache.commons.lang3.StringUtils;  
  7. import org.aspectj.lang.ProceedingJoinPoint;  
  8. import org.aspectj.lang.reflect.MethodSignature;  
  9. import org.springframework.core.LocalVariableTableParameterNameDiscoverer;  
  10. import org.springframework.expression.ExpressionParser;  
  11. import org.springframework.expression.spel.standard.SpelExpressionParser;  
  12. import org.springframework.expression.spel.support.StandardEvaluationContext;  
  13.   
  14. public class AopUtil {  
  15.     private static ExpressionParser parser;  
  16.     /** 
  17.      * 獲取被攔截方法對象 
  18.      *  
  19.      * MethodSignature.getMethod() 獲取的是頂層接口或者父類的方法對象 而緩存的注解在實現(xiàn)類的方法上 
  20.      * 所以應該使用反射獲取當前對象的方法對象 
  21.      */  
  22.     public static Method getMethod(ProceedingJoinPoint pjp) {  
  23.         // 獲取參數(shù)的類型  
  24.         Class<?>[] parameterTypes = ((MethodSignature)pjp.getSignature()).getMethod().getParameterTypes();  
  25.         //此方法當參數(shù)傳遞null時會報錯,故而改為采用上述方式  
  26.         // Object[] args = pjp.getArgs();  
  27.         // Class[] argTypes = new Class[pjp.getArgs().length];  
  28.         // for (int i = 0; i < args.length; i++) {  
  29.         // if (args[i]!=null) {  
  30.         // argTypes[i] = args[i].getClass();  
  31.         // }  
  32.         // }  
  33.         Method method = null;  
  34.         try {  
  35.             method = pjp.getTarget().getClass().getMethod(pjp.getSignature().getName(), parameterTypes);  
  36.         } catch (NoSuchMethodException e) {  
  37.             e.printStackTrace();  
  38.         } catch (SecurityException e) {  
  39.             e.printStackTrace();  
  40.         }  
  41.         return method;  
  42.     }  
  43.     /** 
  44.      * 通過spring spel解析參數(shù)獲取redis緩存key 
  45.      *  
  46.      * @param keys 
  47.      *            緩存keys 
  48.      * @param paramNames 
  49.      *            參數(shù)名 
  50.      * @param args 
  51.      *            參數(shù)列表 
  52.      * @return 
  53.      */  
  54.     public static String parseKeyByParam(String keys, String[] paramNames, Object[] args) {  
  55.         if (StringUtils.isBlank(keys)) {  
  56.             return "";  
  57.         }  
  58.         ExpressionParser parser = getParser();  
  59.         StandardEvaluationContext context = new StandardEvaluationContext();  
  60.         // 把方法參數(shù)放入SPEL上下文中  
  61.         for (int i = 0; i < paramNames.length; i++) {  
  62.             context.setVariable(paramNames[i], args[i]);  
  63.         }  
  64.         // 獲取參數(shù)key  
  65.         StringBuffer sb = new StringBuffer();  
  66.         // for (int i = 0; i < keys.length; i++) {  
  67.         sb.append(parser.parseExpression(keys).getValue(context, String.class));  
  68.         // }  
  69.         return sb.toString();  
  70.     }  
  71.   
  72.     /** 
  73.      * 獲取參數(shù)名列表 
  74.      *  
  75.      * @param method 
  76.      * @return 
  77.      */  
  78.     public static String[] getMethodParamNames(Method method) {  
  79.         // 獲取被攔截方法參數(shù)名列表(使用Spring支持類庫)  
  80.         LocalVariableTableParameterNameDiscoverer u = new LocalVariableTableParameterNameDiscoverer();  
  81.         String[] paraNameArr = u.getParameterNames(method);  
  82.         return paraNameArr;  
  83.     }  
  84.   
  85.     /** 
  86.      * 獲取緩存主鍵 
  87.      * @param jp 
  88.      * @param clazz  
  89.      * @return 
  90.      * @throws SecurityException  
  91.      * @throws NoSuchFieldException  
  92.      */  
  93. //  public static <T extends Annotation> String[] getCachedKey(T t,String[] paramNames, Class<T> clazz) throws NoSuchFieldException, SecurityException {  
  94. ////        Method method = getMethod(jp);  
  95. ////        T t = getMethodAnnotation(method, clazz);  
  96. //      // String fieldKey = null;  
  97. //      // if (cache.isParam()) {  
  98. //      String fieldKey = parseKeyByParam(ReflectionUtil.getField(t.getClass().getField("cachekey"), t).toString(), paramNames, jp.getArgs());  
  99. //      // }  
  100. //      return fieldKey.split(",");  
  101. //  }  
  102.       
  103.     /** 
  104.      * 獲取方法注解 
  105.      * @param method 
  106.      * @param clazz 注解類型 
  107.      * @return 
  108.      */  
  109.     public static <T extends Annotation> T getMethodAnnotation(Method method,Class<T> clazz){  
  110.         T t = method.getAnnotation(clazz);  
  111.         return t;  
  112.     }  
  113.     /** 
  114.      * 獲取redis緩存key通過集合參數(shù) 
  115.      *  
  116.      * @param keys 
  117.      *            緩存keys 
  118.      * @param params 
  119.      *            參數(shù)名 
  120.      * @param returnObj 
  121.      *            參數(shù)列表 
  122.      * @return 
  123.      */  
  124.     private String parseKeyByReturn(String keys, Object returnObj) {  
  125.         ExpressionParser parser = getParser();  
  126.         StandardEvaluationContext context = new StandardEvaluationContext();  
  127.         // 把方法參數(shù)放入SPEL上下文中  
  128.         context.setVariable("obj", returnObj);  
  129.         // 獲取參數(shù)key  
  130.         StringBuffer sb = new StringBuffer();  
  131.         sb.append(parser.parseExpression(keys).getValue(context, String.class));  
  132.         return sb.toString();  
  133.     }  
  134.     /** 
  135.      * 使用SPEL進行key的解析 
  136.      *  
  137.      * @return 
  138.      */  
  139.     public synchronized static ExpressionParser getParser() {  
  140.         if (parser == null) {  
  141.             parser = new SpelExpressionParser();  
  142.         }  
  143.         return parser;  
  144.     }  
  145.     /** 
  146.      * 執(zhí)行切入點方法 
  147.      * @param jp 
  148.      * @param params 方法參數(shù) 
  149.      * @return 
  150.      */  
  151.     public static Object executeJoinPointMethod(ProceedingJoinPoint jp,Object[] params){  
  152.         Object obj = null;  
  153.         try {  
  154.             if (params==null||params.length==0) {  
  155.                 obj = jp.proceed();  
  156.             }else{  
  157.                 obj = jp.proceed(params);  
  158.             }  
  159.         } catch (Throwable e) {  
  160.             e.printStackTrace();  
  161.         }  
  162.         return obj;  
  163.     }  
  164. }  



本站僅提供存儲服務，所有內容均由用戶發(fā)布，如發(fā)現(xiàn)有害或侵權內容，請點擊舉報。
打開APP，閱讀全文并永久保存 查看更多類似文章
猜你喜歡
類似文章
通過java的反射機制實現(xiàn)Map、JavaBean、JSON的相互轉換工具類
java如何生成word文檔_使用Java生成word文檔（附源碼）
Java追加文件內容的三種方法
很有用的反射工具類
支付寶登錄接口解析
C# 應用 - 使用 HttpWebRequest 發(fā)起 Http 請求
更多類似文章 >>
生活服務
分享 收藏 導長圖 關注 下載文章
綁定賬號成功
后續(xù)可登錄賬號暢享VIP特權！
如果VIP功能使用有故障，
可點擊這里聯(lián)系客服！

聯(lián)系客服