文档章节

用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 和 AspectJ 之间的差别

面向方面的编程(AOP) 是一种编程范式,旨在通过允许横切关注点的分离,提高模块化。AOP提供方面来将跨越对象关注点模块化。虽然现在可以获得许多AOP框架,但在这里我们要区分的只有两个流行...

oschina
2013/10/23
47.8K
21
Spring AOP 实现原理与 CGLIB 应用

AOP(Aspect Orient Programming),也就是面向方面编程,作为面向对象编程的一种补充,专门用于处理系统中分布于各个模块(不同方法)中的交叉关注点的问题,在 Java EE 应用中,常常通过 ...

IBMdW
2012/09/26
1K
2
Spring AOP 实现原理与 CGLIB 应用

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

ihaolin
2014/03/31
0
0

没有更多内容

加载失败,请刷新页面

加载更多

MIT 6.828 main.c文件分析

#include <inc/x86.h>#include <inc/elf.h> /*这是一个简单粗略的boot loader,它唯一的工作就是从硬盘的第一个扇区启动格式为ELF的内核镜像硬盘布局这个程序(包括boot.S和mai...

FeanLau
27分钟前
0
0
SpringBoot 整合 Redis

1. pom.xml 文件中添加 Redis 依赖 <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId><exclusions><exclusio......

北漂的我
35分钟前
1
0
TechDay实录 | 认识PaddlePaddle:更低使用成本、更高开发效率的深度学习框架

导读: 在人工智能时代,各行各业都在尝试利用机器学习/深度学习等前沿技术来解决自身的业务需求,深度学习框架也应运而生。为了继续帮助AI开发者们在深度学习的道路上快速升级,百度PaddleP...

PaddleWeekly
36分钟前
3
0
JAVA AES加解密服务

package com.pasenger.aes;import lombok.Data;import org.apache.commons.codec.binary.Base64;import org.springframework.beans.factory.InitializingBean;import org.springframewo......

Pasenger
47分钟前
0
0
SpringCloud集成 Mybatis分表插件shardbatis 踩坑日志及其原理分析

公司新开发的系统数据量过大,需要进行分表处理,我在网上浏览一圈,选中了Shardbatis,原因有二: 1.公司项目本身集成了Mybatis,而Shardbatis是其插件,引入方便; 2.Sharbatis十分轻便,只...

L墨龙
54分钟前
9
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部