文档章节

用aspectJ 做了一次日志

r
 rgixb586
发布于 2016/11/18 10:06
字数 841
阅读 12
收藏 0

1、

Java代码 

 收藏代码

  1. <aspectj.version>1.7.4.RELEASE</aspectj.version>  
  2.   
  3.     <dependency>  
  4.             <groupId>org.aspectj</groupId>  
  5.             <artifactId>aspectjweaver</artifactId>  
  6.             <version>${aspectj.version}</version>  
  7.         </dependency>  
  8.           
  9.         <dependency>  
  10.             <groupId>org.aspectj</groupId>  
  11.             <artifactId>aspectjrt</artifactId>  
  12.             <version>${aspectj.version}</version>  
  13.         </dependency>  

 注意:如果JDK1.7的 必须这里也是1.7+

 

 

2、

Java代码 

 收藏代码

  1. <aop:config proxy-target-class="true"></aop:config>  
  2.     <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">  
  3.         <property name="securityManager" ref="securityManager"/>  
  4.     </bean>  
  5.       
  6.     <aop:aspectj-autoproxy proxy-target-class="true"/>  

 注意:下载 必须在spring-mvc.xml里面,且有两个aop配置,下面那个是必须的,上面那个可能不是必须的(上面那个应该是spring aop的,如果有aspectJ了,可以不需要)

 

3、AOP类

 

Java代码 

 收藏代码

  1. package com.kingen.aop;  
  2.   
  3. import java.lang.reflect.Method;  
  4.   
  5. import javax.servlet.http.HttpServletRequest;  
  6. import javax.transaction.Transactional;  
  7.   
  8. import org.aspectj.lang.JoinPoint;  
  9. import org.aspectj.lang.annotation.AfterReturning;  
  10. import org.aspectj.lang.annotation.AfterThrowing;  
  11. import org.aspectj.lang.annotation.Aspect;  
  12. import org.aspectj.lang.annotation.Pointcut;  
  13. import org.slf4j.Logger;  
  14. import org.slf4j.LoggerFactory;  
  15. import org.springframework.stereotype.Component;  
  16. import org.springframework.util.Assert;  
  17. import org.springframework.web.context.request.RequestContextHolder;  
  18. import org.springframework.web.context.request.ServletRequestAttributes;  
  19.   
  20. import com.kingen.bean.Log;  
  21. import com.kingen.bean.User;  
  22. import com.kingen.service.log.LogService;  
  23. import com.kingen.util.Constants;  
  24. import com.kingen.util.DateUtils;  
  25. import com.kingen.util.SpringContextHolder;  
  26. import com.kingen.util.StringUtils;  
  27. import com.kingen.util.UserUtils;  
  28.   
  29. /** 
  30.  * 日志AOP 
  31.  *  
  32.  *  wj 
  33.  *  2016-11-16 
  34.  * 
  35.  */  
  36.   
  37.  
  38. public class LogAOP {  
  39.   
  40.     private static LogService logService = SpringContextHolder.getBean(LogService.class);  
  41.   
  42.     // 本地异常日志记录对象  
  43.     private Logger logger = LoggerFactory.getLogger(getClass());  
  44.   
  45.     /** 
  46.      * 在所有标注@LogAnnotation的地方切入 
  47.      *  
  48.      * @param joinPoint 
  49.      */  
  50.     @Pointcut("@annotation(com.kingen.aop.LogAnnotation)")  
  51.     public void logAspect() {  
  52.     }  
  53.   
  54.     // @Around(value = "aApplogic() && @annotation(annotation) &&args(object,..)  
  55.     // ", argNames = "annotation,object")  
  56.     // public Object around(ProceedingJoinPoint pj,  
  57.     // LogAnnotation annotation, Object object) throws Throwable {  
  58.     // System.out.println("moduleName:"+annotation.moduleName());  
  59.     // System.out.println("option:"+annotation.option());  
  60.     // pj.proceed();  
  61.     // return object;  
  62.     // }  
  63.   下载 
  64.     /** 
  65.      * 前置通知 用于拦截Controller层记录用户的操作 
  66.      *  
  67.      * @param joinPoint 
  68.      *            切点 
  69.      * @throws Exception 
  70.      */  
  71. //  @Around(value = "logAspect() && @annotation(annotation) &&args(object,..) ", argNames = "annotation,object")  
  72. //  public void doAround(ProceedingJoinPoint joinPoint, LogAnnotation annotation, Object object) {  
  73.     //用@Around 会导致controller不执行,不返回页面  
  74.       
  75. //   @After(value = "logAspect() && @annotation(annotation) &&args(object,..) ", argNames = "annotation,object")  
  76. //   public void doAfter(JoinPoint joinPoint, LogAnnotation annotation, Object object) {  
  77.       
  78.      @AfterReturning(value = "logAspect() && @annotation(annotation) &&args(object,..) ", argNames = "", returning = "retVal")  
  79.      public void doAfterReturning(JoinPoint joinPoint, LogAnnotation annotation, Object object,  String retVal) {  
  80.   
  81.         HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())  
  82.                 .getRequest();  
  83.         try {  
  84.             // String title = getAnnotationValue(joinPoint);  
  85.             String title = getAnnotationValue(annotation);  
  86.             saveLog(request, title);  
  87.         } catch (Exception e) {  
  88.             e.printStackTrace();  
  89.             // 记录本地异常日志  
  90.             logger.error("==异常通知异常==");  
  91.             logger.error("异常信息:{}", e.getMessage());  
  92.         }  
  93.     }  
  94.   
  95.     /** 
  96.      * 异常通知 用于拦截service层记录异常日志 
  97.      *  
  98.      * @param joinPoint 
  99.      * @param e 
  100.      */  
  101.     // 方法  catch住异常的话,这里执行不到  
  102. //  @AfterThrowing(pointcut = "logAspect()", throwing = "e")  
  103.     @AfterThrowing(value = "logAspect() && @annotation(annotation) &&args(..) " , throwing = "e")  
  104.     public void doAfterThrowing(JoinPoint joinPoint,  LogAnnotation annotation, Exception e) {  
  105.         HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())  
  106.                 .getRequest();  
  107.   
  108.         try {  
  109.   
  110. //          String title = getAnnotationValue(joinPoint);  
  111.             String title = getAnnotationValue(annotation);  
  112.             saveLog(request, title, e);  
  113.         } catch (Exception ex) {  
  114.             // 记录本地异常日志  
  115.             logger.error("==异常通知异常==");  
  116.             logger.error("异常信息:{}", ex.getMessage());  
  117.         }  
  118.   
  119.     }  
  120.   
  121.     public static void saveLog(HttpServletRequest request, String title) {  
  122.         saveLog(request, title, null);  
  123.     }  下载 
  124.   
  125.     /** 
  126.      * 保存日志 
  127.      */  
  128.     @Transactional  
  129.     public static void saveLog(HttpServletRequest request, String title, Exception ex) {  
  130.         User user = UserUtils.getCurrentUser();  
  131.         if (user != null && user.getUserId() != null) {  
  132.             Log log = new Log();  
  133.             log.setCreateDate(DateUtils.getDateTime());  
  134.             log.setTitle(title);  
  135.             log.setType(ex == null ? Log.TYPE_ACCESS : Log.TYPE_EXCEPTION);  
  136.             log.setRemoteAddr(StringUtils.getRemoteAddr(request));  
  137.             log.setUserAgent(user.getUsername());  
  138.             // log.setUserAgent(request.getHeader("user-agent"));  
  139.             log.setRequestUri(request.getRequestURI());  
  140.             log.setParams(request.getParameterMap());  
  141.             // 如果有异常,设置异常信息  
  142.             log.setException(ex == null ? null : ex.getMessage());  
  143. //          log.setException(ex == null ? null : Exceptions.getStackTraceAsString(ex));  
  144.             log.setStatus(ex == null ? Constants.StatusEnum.Success.getIndex() : Constants.StatusEnum.Fail.getIndex());  
  145.             // log.setMethod(request.getMethod());  
  146.             // 异步保存日志  
  147.             // new SaveLogThread(log, handler, ex).start();  
  148.             logService.saveLog(log);  
  149.         }  
  150.     }  
  151.   
  152.     /** 
  153.      * 获取注解中对方法的描述信息 用于Controller层注解 
  154.      *  
  155.      * @param joinPoint 
  156.      *            切点 
  157.      * @return 方法描述 
  158.      * @throws Exception 
  159.      */  
  160.     @Deprecated  
  161.     public static String getAnnotationValue(JoinPoint joinPoint) throws Exception {  
  162.         String targetName = joinPoint.getTarget().getClass().getName();  
  163.         String methodName = joinPoint.getSignature().getName();  
  164.         Object[] arguments = joinPoint.getArgs();  
  165.         Class targetClass = Class.forName(targetName);  
  166.         Method[] methods = targetClass.getMethods();  
  167.         String description = "";  
  168.         for (Method method : methods) {  
  169.             if (method.getName().equals(methodName)) {  
  170.                 Class[] clazzs = method.getParameterTypes();  
  171.                 if (clazzs.length == arguments.length) {  
  172.                     String moduleName = method.getAnnotation(LogAnnotation.class).moduleName();  
  173.                     String option = method.getAnnotation(LogAnnotation.class).option();  
  174.                     Assert.hasText(moduleName, "模块名字不应为空");  
  175.                     Assert.hasText(option, "操作名字不应为空");  
  176.                     description = moduleName + "-" + option;  
  177.                     break;  
  178.                 }  
  179.             }  
  180.         }  
  181.         return description;  
  182.     }  
  183.   
  184.     public static String getAnnotationValue(LogAnnotation anno) throws Exception {  
  185.         String moduleName = anno.moduleName();  
  186.         String option = anno.option();  
  187.         Assert.hasText(moduleName, "模块名字不应为空");  
  188.         Assert.hasText(option, "操作名字不应为空");  
  189.         String description = moduleName + "-" + option;  
  190.         return description;  
  191.     }  
  192. }  

 注意这里 @After和 @AfterReturning的区别,总的来说,就是 @After 是无论如何都会执行的,不管有没有异常抛出(这样会导致,在有异常的时候,记录两次日志,after一次、throwing一次);@AfterReturning 在有异常的情况下,不会执行到,因为没有renturn,在retrun之前就throw了。

© 著作权归作者所有

共有 人打赏支持
r
粉丝 0
博文 2
码字总数 971
作品 0
济南
Spring中的AOP(一)——AspectJ的基本使用

AOP(Aspect Orient Programming),也就是面向切面编程,作为面向对象编程的一种补充,当前已经成为一种比较成熟的编程思想,其实AOP问世的时间并不长,甚至在国内的翻译还不太统一(另有人...

摆渡者
2014/03/13
0
1
2014-03-11 Spring的学习(3)------面向切面编程(AOP)

AOP概念 首先让我们从一些重要的AOP概念和术语开始。这些术语不是Spring特有的。不过AOP术语并不是特别的直观,如果Spring使用自己的术语,将会变得更加令人困惑。 切面(Aspect):一个关注...

查封炉台
2014/03/11
0
0
Spring AOP 实现原理与 CGLIB 应用

AOP(Aspect Orient Programming),作为面向对象编程的一种补充,广泛应用于处理一些具有横切性质的系统级服务,如事务管理、安全检查、缓存、对象池管理等。AOP 实现的关键就在于 AOP 框架...

ihaolin
2014/03/31
0
0
spring 学习(三):aop 学习

spring 学习(三):aop 学习 aop 概念 1 aop:面向切面(方面)编程,扩展功能不修改源代码实现 2 AOP采取横向抽取机制,取代了传统纵向继承体系重复性代码 3 aop底层使用动态代理实现 (1...

希希里之海
前天
0
0
《Spring Recipes》第三章笔记1:Enabling AspectJ Annotation

《Spring Recipes》第三章笔记:Enabling AspectJ Annotation 问题 如何开启Spring容器对AspectJ注解的支持。 解决方案 在配置文件中引入aop schema,添加<aop:aspectj-autoproxy />配置。 ...

LiJIaming
2012/05/20
0
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

阿里云API网关使用教程

API 网关(API Gateway)提供高性能、高可用的 API 托管服务,帮助用户对外开放其部署在 ECS、容器服务等阿里云产品上的应用,提供完整的 API 发布、管理、维护生命周期管理。用户只需进行简...

mcy0425
27分钟前
4
0
解决远程登陆误按ctrl+s锁屏假死恢复

使用putty时,偶尔发生屏幕假死,不能输入等情况。 后来发现,只要数据ctrl+s,就会假死;输入ctrl+q就可以恢复过来。 很多刚从windows转移到linux上来工作的朋友,在用vi/vim编辑文件时,常常...

HJCui
31分钟前
0
0
@Transactional

事务管理是应用系统开发中必不可少的一部分。Spring 为事务管理提供了丰富的功能支持。Spring 事务管理分为编程式和声明式的两种方式。编程式事务指的是通过编码方式实现事务;声明式事务基于...

asdf08442a
35分钟前
2
0
widows下强制解除8080端口占用问题

使用win+R打开命令窗口 输入以下命令查看哪个任务占用了8080端口 netstat -ano |findstr "8080" 然后通过任务id强制关闭占用该端口的进程 tskill 10044 // 自己的试情况而定,这个ID是LISTE...

_Artisan
44分钟前
2
0
productFlavors简单实用

最近项目中,不同环境需要配置的参数越来越多,为了减少修改代码次数。研究了一下productFlavors的使用方式,总结如下 1. as3.0以上版本使用productFlavors时需要指定一个flavorDimensions,...

火云
46分钟前
1
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部