`
langgufu
  • 浏览: 2306861 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

SpringAOP拦截Controller,Service实现日志管理(自定义注解的方式)(转载)

阅读更多

         首先我们为什么需要做日志管理,在现实的上线中我们经常会遇到系统出现异常或者问题。这个时候就马上打开CRT或者SSH连上服务器拿日子来分析。受网络的各种限制。于是我们就想为什么不能直接在管理后台查看报错的信息呢。于是日志管理就出现了。

         其次个人觉得做日志管理最好的是Aop,有的人也喜欢用拦截器。都可以,在此我重点介绍我的实现方式。

         Aop有的人说拦截不到Controller。有的人说想拦AnnotationMethodHandlerAdapter截到Controller必须得拦截org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter。

首先Aop可以拦截到Controller的,这个是毋容置疑的其次须拦截AnnotationMethodHandlerAdapter也不是必须的。最起码我没有验证成功过这个。我的Spring版本是4.0.3。

         Aop之所以有的人说拦截不到Controller是因为Controller被jdk代理了。我们只要把它交给cglib代理就可以了。

第一步定义两个注解:

 

Java代码 复制代码
  1. package com.annotation;  
  2.   
  3. import java.lang.annotation.*;  
  4.   
  5. /** 
  6.  *自定义注解 拦截Controller 
  7.  */  
  8.   
  9. @Target({ElementType.PARAMETER, ElementType.METHOD})  
  10. @Retention(RetentionPolicy.RUNTIME)  
  11. @Documented  
  12. public  @interface SystemControllerLog {  
  13.   
  14.     String description()  default "";  
  15.   
  16.   
  17. }  
  18.   
  19. package com.annotation;  
  20.   
  21. import java.lang.annotation.*;  
  22.   
  23. /** 
  24.  *自定义注解 拦截service 
  25.  */  
  26.   
  27. @Target({ElementType.PARAMETER, ElementType.METHOD})  
  28. @Retention(RetentionPolicy.RUNTIME)  
  29. @Documented  
  30. public  @interface SystemServiceLog {  
  31.   
  32.     String description()  default "";  
  33.   
  34.   
  35. }  

第二步创建一个切点类:

 

 

Java代码 复制代码
  1. package com.annotation;  
  2.   
  3. import com.model.Log;  
  4. import com.model.User;  
  5. import com.service.LogService;  
  6. import com.util.DateUtil;  
  7. import com.util.JSONUtil;  
  8. import com.util.SpringContextHolder;  
  9. import com.util.WebConstants;  
  10. import org.aspectj.lang.JoinPoint;  
  11. import org.aspectj.lang.annotation.*;  
  12. import org.slf4j.Logger;  
  13. import org.slf4j.LoggerFactory;  
  14. import org.springframework.stereotype.Component;  
  15. import org.springframework.web.context.request.RequestContextHolder;  
  16. import org.springframework.web.context.request.ServletRequestAttributes;  
  17. import javax.annotation.Resource;  
  18. import javax.servlet.http.HttpServletRequest;  
  19. import javax.servlet.http.HttpSession;  
  20. import java.lang.reflect.Method;  
  21.   
  22. /** 
  23.  * 切点类 
  24.  * @author tiangai 
  25.  * @since 2014-08-05 Pm 20:35 
  26.  * @version 1.0 
  27.  */  
  28. @Aspect  
  29. @Component  
  30. public  class SystemLogAspect {  
  31.     //注入Service用于把日志保存数据库  
  32.     @Resource  
  33.      private LogService logService;  
  34.     //本地异常日志记录对象  
  35.      private  static  final Logger logger = LoggerFactory.getLogger(SystemLogAspect. class);  
  36.   
  37.     //Service层切点  
  38.     @Pointcut("@annotation(com.annotation.SystemServiceLog)")  
  39.      public  void serviceAspect() {  
  40.     }  
  41.   
  42.     //Controller层切点  
  43.     @Pointcut("@annotation(com.annotation.SystemControllerLog)")  
  44.      public  void controllerAspect() {  
  45.     }  
  46.   
  47.     /** 
  48.      * 前置通知 用于拦截Controller层记录用户的操作 
  49.      * 
  50.      * @param joinPoint 切点 
  51.      */  
  52.     @Before("controllerAspect()")  
  53.      public  void doBefore(JoinPoint joinPoint) {  
  54.   
  55.         HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();  
  56.         HttpSession session = request.getSession();  
  57.         //读取session中的用户  
  58.         User user = (User) session.getAttribute(WebConstants.CURRENT_USER);  
  59.         //请求的IP  
  60.         String ip = request.getRemoteAddr();  
  61.          try {  
  62.             //*========控制台输出=========*//  
  63.             System.out.println("=====前置通知开始=====");  
  64.             System.out.println("请求方法:" + (joinPoint.getTarget().getClass().getName() + "." + joinPoint.getSignature().getName() + "()"));  
  65.             System.out.println("方法描述:" + getControllerMethodDescription(joinPoint));  
  66.             System.out.println("请求人:" + user.getName());  
  67.             System.out.println("请求IP:" + ip);  
  68.             //*========数据库日志=========*//  
  69.             Log log = SpringContextHolder.getBean("logxx");  
  70.             log.setDescription(getControllerMethodDescription(joinPoint));  
  71.             log.setMethod((joinPoint.getTarget().getClass().getName() + "." + joinPoint.getSignature().getName() + "()"));  
  72.             log.setType("0");  
  73.             log.setRequestIp(ip);  
  74.             log.setExceptionCode( null);  
  75.             log.setExceptionDetail( null);  
  76.             log.setParams( null);  
  77.             log.setCreateBy(user);  
  78.             log.setCreateDate(DateUtil.getCurrentDate());  
  79.             //保存数据库  
  80.             logService.add(log);  
  81.             System.out.println("=====前置通知结束=====");  
  82.         }  catch (Exception e) {  
  83.             //记录本地异常日志  
  84.             logger.error("==前置通知异常==");  
  85.             logger.error("异常信息:{}", e.getMessage());  
  86.         }  
  87.     }  
  88.   
  89.     /** 
  90.      * 异常通知 用于拦截service层记录异常日志 
  91.      * 
  92.      * @param joinPoint 
  93.      * @param e 
  94.      */  
  95.     @AfterThrowing(pointcut = "serviceAspect()", throwing = "e")  
  96.      public  void doAfterThrowing(JoinPoint joinPoint, Throwable e) {  
  97.         HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();  
  98.         HttpSession session = request.getSession();  
  99.         //读取session中的用户  
  100.         User user = (User) session.getAttribute(WebConstants.CURRENT_USER);  
  101.         //获取请求ip  
  102.         String ip = request.getRemoteAddr();  
  103.         //获取用户请求方法的参数并序列化为JSON格式字符串  
  104.         String params = "";  
  105.          if (joinPoint.getArgs() !=  null && joinPoint.getArgs().length > 0) {  
  106.              for ( int i = 0; i < joinPoint.getArgs().length; i++) {  
  107.                 params += JSONUtil.toJsonString(joinPoint.getArgs()[i]) + ";";  
  108.             }  
  109.         }  
  110.          try {  
  111.               /*========控制台输出=========*/  
  112.             System.out.println("=====异常通知开始=====");  
  113.             System.out.println("异常代码:" + e.getClass().getName());  
  114.             System.out.println("异常信息:" + e.getMessage());  
  115.             System.out.println("异常方法:" + (joinPoint.getTarget().getClass().getName() + "." + joinPoint.getSignature().getName() + "()"));  
  116.             System.out.println("方法描述:" + getServiceMthodDescription(joinPoint));  
  117.             System.out.println("请求人:" + user.getName());  
  118.             System.out.println("请求IP:" + ip);  
  119.             System.out.println("请求参数:" + params);  
  120.                /*==========数据库日志=========*/  
  121.             Log log = SpringContextHolder.getBean("logxx");  
  122.             log.setDescription(getServiceMthodDescription(joinPoint));  
  123.             log.setExceptionCode(e.getClass().getName());  
  124.             log.setType("1");  
  125.             log.setExceptionDetail(e.getMessage());  
  126.             log.setMethod((joinPoint.getTarget().getClass().getName() + "." + joinPoint.getSignature().getName() + "()"));  
  127.             log.setParams(params);  
  128.             log.setCreateBy(user);  
  129.             log.setCreateDate(DateUtil.getCurrentDate());  
  130.             log.setRequestIp(ip);  
  131.             //保存数据库  
  132.             logService.add(log);  
  133.             System.out.println("=====异常通知结束=====");  
  134.         }  catch (Exception ex) {  
  135.             //记录本地异常日志  
  136.             logger.error("==异常通知异常==");  
  137.             logger.error("异常信息:{}", ex.getMessage());  
  138.         }  
  139.          /*==========记录本地异常日志==========*/  
  140.         logger.error("异常方法:{}异常代码:{}异常信息:{}参数:{}", joinPoint.getTarget().getClass().getName() + joinPoint.getSignature().getName(), e.getClass().getName(), e.getMessage(), params);  
  141.   
  142.     }  
  143.   
  144.   
  145.     /** 
  146.      * 获取注解中对方法的描述信息 用于service层注解 
  147.      * 
  148.      * @param joinPoint 切点 
  149.      * @return 方法描述 
  150.      * @throws Exception 
  151.      */  
  152.      public  static String getServiceMthodDescription(JoinPoint joinPoint)  
  153.              throws Exception {  
  154.         String targetName = joinPoint.getTarget().getClass().getName();  
  155.         String methodName = joinPoint.getSignature().getName();  
  156.         Object[] arguments = joinPoint.getArgs();  
  157.         Class targetClass = Class.forName(targetName);  
  158.         Method[] methods = targetClass.getMethods();  
  159.         String description = "";  
  160.          for (Method method : methods) {  
  161.              if (method.getName().equals(methodName)) {  
  162.                 Class[] clazzs = method.getParameterTypes();  
  163.                  if (clazzs.length == arguments.length) {  
  164.                     description = method.getAnnotation(SystemServiceLog. class).description();  
  165.                      break;  
  166.                 }  
  167.             }  
  168.         }  
  169.          return description;  
  170.     }  
  171.   
  172.     /** 
  173.      * 获取注解中对方法的描述信息 用于Controller层注解 
  174.      * 
  175.      * @param joinPoint 切点 
  176.      * @return 方法描述 
  177.      * @throws Exception 
  178.      */  
  179.      public  static String getControllerMethodDescription(JoinPoint joinPoint)  throws Exception {  
  180.         String targetName = joinPoint.getTarget().getClass().getName();  
  181.         String methodName = joinPoint.getSignature().getName();  
  182.         Object[] arguments = joinPoint.getArgs();  
  183.         Class targetClass = Class.forName(targetName);  
  184.         Method[] methods = targetClass.getMethods();  
  185.         String description = "";  
  186.          for (Method method : methods) {  
  187.              if (method.getName().equals(methodName)) {  
  188.                 Class[] clazzs = method.getParameterTypes();  
  189.                  if (clazzs.length == arguments.length) {  
  190.                     description = method.getAnnotation(SystemControllerLog. class).description();  
  191.                      break;  
  192.                 }  
  193.             }  
  194.         }  
  195.          return description;  
  196.     }  
  197. }  

 第三步把Controller的代理权交给cglib

 

在实例化ApplicationContext的时候需要加上

 

Xml代码 复制代码
  1. <!-- 启动对@AspectJ注解的支持 -->  
  2. <aop:aspectj-autoproxy/>  

 在调用Controller的时候AOP发挥作用所以在SpringMVC的配置文件里加上

 

 

Xml代码 复制代码
  1. <!--通知spring使用cglib而不是jdk的来生成代理方法 AOP可以拦截到Controller- >  
  2. <aop:aspectj-autoproxy proxy-target-class="true" />  

 第四步使用

 

Controller层的使用

 

Java代码 复制代码
  1. /** 
  2.     * 删除用户 
  3.     * 
  4.     * @param criteria 条件 
  5.     * @param id       id 
  6.     * @param model    模型 
  7.     * @return 数据列表 
  8.     */  
  9.    @RequestMapping(value = "/delete")  
  10.    //此处为记录AOP拦截Controller记录用户操作  
  11.    @SystemControllerLog(description = "删除用户")  
  12.     public String del(Criteria criteria, String id, Model model, HttpSession session) {  
  13.         try {  
  14.            User user = (User) session.getAttribute(WebConstants.CURRENT_USER);  
  15.             if ( null != user) {  
  16.                 if (user.getId().equals(id)) {  
  17.                    msg = "您不可以删除自己!";  
  18.                    criteria = userService.selectByCriteriaPagination(criteria);  
  19.                }  else {  
  20.                    //删除数据并查询出数据  
  21.                    criteria = userService.delete(id, criteria);  
  22.                    msg = "删除成功!";  
  23.                }  
  24.            }  
  25.        }  catch (Exception e) {  
  26.            msg = "删除失败!";  
  27.        }  finally {  
  28.            model.addAttribute("msg", msg);  
  29.            model.addAttribute("criteria", criteria);  
  30.        }  
  31.        //跳转列表页  
  32.         return "user/list";  
  33.    }  

 Service层的使用

 

 

Java代码 复制代码
  1. /** 
  2.     * 按照分页查询 
  3.     * @param criteria 
  4.     * @return 
  5.     */  
  6.    //此处为AOP拦截Service记录异常信息。方法不需要加try-catch  
  7.    @SystemServiceLog(description = "查询用户")  
  8.     public Criteria<User> selectByCriteriaPagination(Criteria<User> criteria)  
  9.    {  
  10.        criteria.getList().get(0).getAccount();  
  11.        //查询总数  
  12.         long total=userMapper.countByCriteria(criteria);  
  13.        //设置总数  
  14.        criteria.setRowCount(total);  
  15.        criteria.setList(userMapper.selectByCriteriaPagination(criteria));  
  16.         return  criteria;  
  17.    }  

效果图

 

用户操作:


 
 异常


 

分享到:
评论
2 楼 lizhenlzlz 2017-06-05  
我的也是拦截不了service层
1 楼 xiewen3410 2016-08-10  
能提供源码吗?aop拦截不了service层啊

相关推荐

    springMVC AOP拦截拦截Controller等实现日志管理

    通过这种方式,我们可以在Spring MVC中利用AOP实现对Controller方法的透明日志管理,不仅记录正常流程,也能捕获和记录异常,提升系统的可维护性和问题排查效率。 在实际项目中,我们可以根据需求进一步定制日志...

    Spring Mvc AOP通过注解方式拦截controller等实现日志管理

    本教程将详细介绍如何利用注解来配置和使用AOP来拦截Controller层的方法,以便记录执行过程中的相关信息,实现日志管理。 一、Spring AOP基础 AOP是Spring框架的核心组件之一,它允许程序员定义“切面”,这些切面...

    springaop拦截controller日志

    "springaop拦截controller日志"这个主题旨在讲解如何使用Spring AOP来拦截Controller层的方法调用,并在方法执行前后记录相关日志。 首先,了解Spring AOP的基本概念。AOP是一种编程范式,它允许程序员定义“切面”...

    Spring MVC AOP通过注解方式拦截Controller等实现日志管理demo版本2

    本项目"Spring MVC AOP通过注解方式拦截Controller等实现日志管理demo版本2"是基于注解的AOP实践,旨在帮助开发者了解如何利用AOP来记录应用程序中的关键操作日志。以下是关于这个主题的详细解释: 1. **Spring AOP...

    springboot spring aop 拦截器注解方式实现脱敏

    总结一下,通过上述步骤,我们已经在Spring Boot应用中利用Spring AOP和注解方式实现了数据脱敏。这个拦截器可以在不修改原有业务代码的情况下,确保敏感信息在响应给客户端之前得到处理,提高了应用的安全性。同时...

    spring MVC AOP注解方式如何拦截controller 例子

    本文将详细介绍如何使用AspectJ注解在Spring MVC中实现AOP拦截Controller方法,并提供一个具体的例子。 首先,我们需要了解Spring AOP的基础概念。AOP允许我们定义“切面”,这些切面包含了业务逻辑中横切关注点的...

    spring aop切面拦截指定类和方法实现流程日志跟踪

    本节将详细介绍如何使用Spring AOP实现流程日志跟踪,主要关注于如何通过AOP拦截特定的类和方法来进行日志记录。 ##### 3.1 配置Spring AOP 在Spring配置文件中定义切面和切入点表达式是非常关键的一步。一般来说...

    spring aop日志拦截

    在Spring MVC框架中,AOP(面向切面编程)是一种强大的工具,用于实现日志拦截,特别是对于controller层的操作。AOP允许我们定义横切关注点,这些关注点可以是如日志记录、事务管理、权限检查等通用功能,它们在程序...

    spring aop 拦截日志示例

    通过以上步骤,我们就完成了使用Spring AOP拦截并记录系统操作日志和异常日志的过程。在实际项目中,可以根据需求调整切点表达式,优化日志格式,以及对日志进行分类和分级存储。这样的设计使得日志管理变得灵活且...

    对spring aop 各个组件进行实现

    自定义注解是Spring AOP中实现切面逻辑的一种方式。例如,我们可以创建一个名为`@LogExecutionTime`的注解,用来记录方法的执行时间。首先,定义注解: ```java @Retention(RetentionPolicy.RUNTIME) @Target...

    springboot工程自定义response注解、自定义规范化返回数据结构

    本主题将深入探讨如何在Spring Boot工程中通过自定义response注解、利用Java反射机制、设置自定义拦截器以及实现WebMvcConfigurer接口来实现这一目标。 首先,我们来看自定义response注解。在Spring Boot中,可以...

    AOP拦截日志JAVA

    Java AOP(面向切面编程)是一种编程范式,它允许程序员定义“切面”,这些切面封装了特定关注点的代码,如日志...这就是"AOP拦截日志JAVA"的核心内容,它利用了Spring AOP的强大功能,让日志管理变得更加简单和高效。

    spring自定义注解实现拦截器的实现方法

    在Spring框架中,自定义注解结合AOP(面向切面编程)是实现业务逻辑与非业务逻辑分离的一种有效方式。通过自定义注解,可以针对不同的业务场景灵活地添加功能,比如权限控制、日志记录、事务管理等。本文将详细讨论...

    Spring AOP实例

    9. **自动代理(Auto-proxying)**:Spring可以在扫描bean定义时自动检测带有特定注解的类并创建对应的代理对象,如`@Component`、`@Service`、`@Repository`和`@Controller`。 在`Spring052`这个压缩包中,可能...

    Spring注解和扫包自定义注解和自动扫包.rar

    Spring还提供了AOP(面向切面编程)的支持,使得可以通过`@Aspect`、`@Pointcut`、`@Before`、`@After`等注解来关联自定义注解和切面处理逻辑,实现类似注解触发的方法拦截。 关于Mybatis,虽然它主要关注SQL映射和...

    详解SpringBoot AOP 拦截器(Aspect注解方式)

    在 SpringBoot 项目中,AspectJ 是一种常用的 AOP 实现方式,通过使用 AspectJ 注解,可以轻松地实现方法拦截和增强。下面将详细介绍 SpringBoot AOP 拦截器的实现方式。 一、 Filter、HandlerInterceptor 和 ...

    Spring Boot Aspect 切面 AOP 拦截器 Interceptor 监控control请求耗时

    在Spring Boot应用中,面向切面编程(AOP)是一种强大的设计模式,它允许我们以声明式的方式插入代码,比如日志记录、事务管理或权限检查。Aspect是AOP的核心概念,它封装了关注点,使得我们可以将这些关注点与业务...

    struts2+spring aop demo

    在"struts2+spring aop demo"这个项目中,我们将探讨如何结合这两个框架,利用Spring的AOP功能来记录操作日志,特别是涉及自定义参数的AOP例子。 首先,让我们了解AOP的概念。面向切面编程(Aspect Oriented ...

    spring中注解的实现原理

    总结来说,Spring中注解的实现原理涉及到元注解的定义、注解处理器的运行、BeanDefinition的生成以及AOP和事务管理的注解处理。这些机制使得Spring能够在不依赖XML的情况下,提供灵活、高效且易于维护的框架功能。...

    springmvc log4j2 logback 注解 jackson 日志脱敏实现源码

    本资源包含的是关于`SpringMVC`、`Log4j2`、`Logback`以及`Jackson`的日志脱敏实现源码,提供了多种实现方式,旨在帮助开发者在保障信息安全的同时,充分利用日志进行系统分析。 1. **基于正则表达式的日志脱敏实现...

Global site tag (gtag.js) - Google Analytics