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

最新推荐文章于 2025-05-29 18:47:24 发布

原创最新推荐文章于 2025-05-29 18:47:24 发布 · 3.8k 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#AOP日志管理

ssh 专栏收录该内容

22 篇文章

订阅专栏

本文展示了如何使用Spring AOP通过自定义注解的方式实现对Controller和服务层的方法进行日志管理。详细介绍了如何定义切点、注解、切面，并提供了拦截Controller和Service的方法，记录用户的操作日志和异常信息。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

 
  package com.wssys.framework;  
   
 import java.lang.reflect.Method;  
 import java.text.SimpleDateFormat;  
 import java.util.Calendar;  
   
 import javax.servlet.http.HttpServletRequest;  
 import org.apache.shiro.SecurityUtils;  
 import org.aspectj.lang.ProceedingJoinPoint;  
 import org.aspectj.lang.annotation.Around;  
 import org.aspectj.lang.annotation.Aspect;  
 import org.aspectj.lang.annotation.Pointcut;  
 import org.springframework.beans.factory.annotation.Autowired;  
 import org.springframework.stereotype.Component;  
 import org.springframework.web.context.request.RequestContextHolder;  
 import org.springframework.web.context.request.ServletRequestAttributes;  
   
 import com.wssys.bean.BolBean;  
 import com.wssys.bean.ComPanyForm;  
 import com.wssys.bean.DeliverBean;  
 import com.wssys.bean.GoodsForm;  
 import com.wssys.dao.SyslogDao;  
 import com.wssys.entity.Companycontacts;  
 import com.wssys.entity.PusFrontUser;  
 import com.wssys.entity.PusMenu;  
 import com.wssys.entity.PusRole;  
 import com.wssys.entity.PusSysUser;  
 import com.wssys.entity.Syslog;  
 import com.wssys.utils.StringUtil;  
 import com.wssys.utils.TCPIPUtil;  
   
 /** 
  * \ 
  *  
  * @Aspect 实现spring aop 切面（Aspect）： 
  *         一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子。 在Spring 
  *         AOP中，切面可以使用通用类（基于模式的风格） 或者在普通类中以 @Aspect 注解（@AspectJ风格）来实现。 
  *  
  *         AOP代理（AOP Proxy）： AOP框架创建的对象，用来实现切面契约（aspect contract）（包括通知方法执行等功能）。 
  *         在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。 注意：Spring 
  *         2.0最新引入的基于模式（schema-based 
  *         ）风格和@AspectJ注解风格的切面声明，对于使用这些风格的用户来说，代理的创建是透明的。 
  * @author q 
  *  
  */  
 @Component  
 @Aspect  
 public class LogService {  
   
     @Autowired  
     private SyslogDao syslogDao;  
   
     public LogService() {  
         System.out.println("Aop");  
     }  
   
     /** 
      * 在Spring 
      * 2.0中，Pointcut的定义包括两个部分：Pointcut表示式(expression)和Pointcut签名(signature 
      * )。让我们先看看execution表示式的格式： 
      * 括号中各个pattern分别表示修饰符匹配（modifier-pattern?）、返回值匹配（ret 
      * -type-pattern）、类路径匹配（declaring 
      * -type-pattern?）、方法名匹配（name-pattern）、参数匹配（(param 
      * -pattern)）、异常类型匹配（throws-pattern?），其中后面跟着“?”的是可选项。 
      *  
      * @param point 
      * @throws Throwable 
      */  
   
     @Pointcut("@annotation(com.wssys.framework.MethodLog)")  
     public void methodCachePointcut() {  
   
     }  
   
     // // @Before("execution(* com.wssys.controller.*(..))")  
     // public void logAll(JoinPoint point) throws Throwable {  
     // System.out.println("打印========================");  
     // }  
     //  
     // // @After("execution(* com.wssys.controller.*(..))")  
     // public void after() {  
     // System.out.println("after");  
     // }  
   
     // 方法执行的前后调用  
     // @Around("execution(* com.wssys.controller.*(..))||execution(* com.bpm.*.web.account.*.*(..))")  
     // @Around("execution(* com.wssys.controller.*(..))")  
     // @Around("execution(* org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter.handle(..))")  
     @Around("methodCachePointcut()")  
     public Object around(ProceedingJoinPoint point) throws Throwable {  
         HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder  
                 .getRequestAttributes()).getRequest();  
         SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss E");  
         Calendar ca = Calendar.getInstance();  
         String operDate = df.format(ca.getTime());  
         String ip = TCPIPUtil.getIpAddr(request);  
         PusSysUser user = (PusSysUser) SecurityUtils.getSubject()  
                 .getPrincipal();  
         String loginName;  
         String name;  
         if (user != null) {  
             loginName = user.getAccount();  
             // name = user.name;  
         } else {  
             loginName = "匿名用户";  
             // name = "匿名用户";  
         }  
   
         String monthRemark = getMthodRemark(point);  
         String monthName = point.getSignature().getName();  
         String packages = point.getThis().getClass().getName();  
         if (packages.indexOf("$$EnhancerByCGLIB$$") > -1) { // 如果是CGLIB动态生成的类  
             try {  
                 packages = packages.substring(0, packages.indexOf("$$"));  
             } catch (Exception ex) {  
                 ex.printStackTrace();  
             }  
         }  
   
         String operatingcontent = "";  
         Object[] method_param = null;  
   
         Object object;  
         try {  
             method_param = point.getArgs(); //获取方法参数   
             // String param=(String) point.proceed(point.getArgs());  
             object = point.proceed();  
         } catch (Exception e) {  
             // 异常处理记录日志..log.error(e);  
             throw e;  
         }  
         Syslog sysLog = new Syslog();  
         sysLog.setIpAddress(ip);  
         sysLog.setLoginName(loginName);  
         sysLog.setMethodName(packages + "." + monthName);  
         sysLog.setMethodRemark(monthRemark);  
         //这里有点纠结 就是不好判断第一个object元素的类型 只好通过  方法描述来 做一一  转型感觉 这里 有点麻烦 可能是我对 aop不太了解  希望懂的高手在回复评论里给予我指点  
         //有没有更好的办法来记录操作参数  因为参数会有 实体类 或者javabean这种参数怎么把它里面的数据都解析出来?  
         if (StringUtil.stringIsNull(monthRemark).equals("会员新增")) {  
             PusFrontUser pfu = (PusFrontUser) method_param[0];  
             sysLog.setOperatingcontent("新增会员:" + pfu.getAccount());  
         } else if (StringUtil.stringIsNull(monthRemark).equals("新增角色")) {  
             PusRole pr = (PusRole) method_param[0];  
             sysLog.setOperatingcontent("新增角色:" + pr.getName());  
         } else if (StringUtil.stringIsNull(monthRemark).equals("用户登录")) {  
             PusSysUser currUser = (PusSysUser) method_param[0];  
             sysLog.setOperatingcontent("登录帐号:" + currUser.getAccount());  
         } else if (StringUtil.stringIsNull(monthRemark).equals("用户退出")) {  
             sysLog.setOperatingcontent("具体请查看用户登录日志");  
         } else if (StringUtil.stringIsNull(monthRemark).equals("角色名称修改")) {  
             PusRole pr = (PusRole) method_param[0];  
             sysLog.setOperatingcontent("修改角色:" + pr.getName());  
         } else if (StringUtil.stringIsNull(monthRemark).equals("新增后台用户")) {  
             PusSysUser psu = (PusSysUser) method_param[0];  
             sysLog.setOperatingcontent("新增后台用户:" + psu.getAccount());  
         } else if (StringUtil.stringIsNull(monthRemark).equals("更新菜单")) {  
             PusMenu pm = (PusMenu) method_param[0];  
             sysLog.setOperatingcontent("更新菜单:" + pm.getName());  
         } else if (StringUtil.stringIsNull(monthRemark).equals("保存菜单")) {  
             PusMenu pm = (PusMenu) method_param[0];  
             sysLog.setOperatingcontent("保存菜单:" + pm.getName());  
         } else if (StringUtil.stringIsNull(monthRemark).equals("修改公司")) {  
             ComPanyForm ciform = (ComPanyForm) method_param[0];  
             sysLog.setOperatingcontent("修改公司:" + ciform.getName());  
         } else if (StringUtil.stringIsNull(monthRemark).equals("联系人更新")) {  
             Companycontacts ct = (Companycontacts) method_param[0];  
             sysLog.setOperatingcontent("联系人更新:" + ct.getName());  
         } else if (StringUtil.stringIsNull(monthRemark).equals("修改货物")) {  
             GoodsForm goodsForm = (GoodsForm) method_param[0];  
             sysLog.setOperatingcontent("修改货物（货物id/编号）:" + goodsForm.getId());  
         } else if (StringUtil.stringIsNull(monthRemark).equals("打印出库单")) {  
             DeliverBean owh= (DeliverBean) method_param[0];  
             sysLog.setOperatingcontent("出库单单号:" + owh.getCknum());  
         } else if (StringUtil.stringIsNull(monthRemark).equals("打印提单")) {  
             BolBean bol= (BolBean) method_param[0];  
             sysLog.setOperatingcontent("提货单号:" + bol.getBolnum());  
         } else if (StringUtil.stringIsNull(monthRemark).equals("系统左侧菜单查询")) {  
             sysLog.setOperatingcontent("无");  
         } else {  
             sysLog.setOperatingcontent("操作参数:" + method_param[0]);  
         }  
   
         syslogDao.save(sysLog);  
         return object;  
     }  
   
     // 方法运行出现异常时调用    
     // @AfterThrowing(pointcut = "execution(* com.wssys.controller.*(..))",  
     // throwing = "ex")  
     public void afterThrowing(Exception ex) {  
         System.out.println("afterThrowing");  
         System.out.println(ex);  
     }  
   
     // 获取方法的中文备注____用于记录用户的操作日志描述  
     public static String getMthodRemark(ProceedingJoinPoint joinPoint)  
             throws Exception {  
         String targetName = joinPoint.getTarget().getClass().getName();  
         String methodName = joinPoint.getSignature().getName();  
         Object[] arguments = joinPoint.getArgs();  
   
         Class targetClass = Class.forName(targetName);  
         Method[] method = targetClass.getMethods();  
         String methode = "";  
         for (Method m : method) {  
             if (m.getName().equals(methodName)) {  
                 Class[] tmpCs = m.getParameterTypes();  
                 if (tmpCs.length == arguments.length) {  
                     MethodLog methodCache = m.getAnnotation(MethodLog.class);  
                     if (methodCache != null) {  
                         methode = methodCache.remark();  
                     }  
                     break;  
                 }  
             }  
         }  
         return methode;  
     }  
   
   
 }  
 

spring application.xml配置:


<bean id="logService" class="com.wssys.framework.LogService"></bean>


<aop:aspectj-autoproxy proxy-target-class="true" />

spring mvc controller层action的
设置例如:

   Java代码  
   
  
 @RequestMapping(value = "/addFrontUser", method = RequestMethod.POST)  
 @MethodLog(remark = "会员新增")  
 public String saveFrontUserAction(@ModelAttribute("psu") PusFrontUser pfu,  
         BindingResult result, SessionStatus status,  
         HttpServletResponse response) {  
     if (pusFrontUserDao.checkAccount(pfu.getAccount()) > 0) {  
         PrintWriter out = null;  
         try {  
             out = response.getWriter();  
         } catch (IOException e) {  
             // TODO Auto-generated catch block  
             e.printStackTrace();  
         }  
   
         out.write("保存失败,会员帐号已经存在");  
   
         out.flush();  
         return null;  
     }  
     // Timestamp now = new Timestamp(System.currentTimeMillis());// 获取系统当前时间  
   
     int saverec = 0;  
   
     pfu.setPwd(new Sha384Hash(pfu.getPwd()).toBase64());  
     saverec = pusFrontUserDao.save(pfu);  
   
     PrintWriter out = null;  
     try {  
         out = response.getWriter();  
     } catch (IOException e) {  
         // TODO Auto-generated catch block  
         e.printStackTrace();  
     }  
     if (saverec > 0) {  
         out.write("保存成功,您可以继续保存或者关闭当前页面");  
     } else {  
         out.write("保存失败");  
     }  
   
     out.flush();  
     return null;  
 }  

   Java代码  
   
  
 package com.wssys.framework;  
   
 import java.lang.annotation.Documented;  
 import java.lang.annotation.ElementType;  
 import java.lang.annotation.Retention;  
 import java.lang.annotation.RetentionPolicy;  
 import java.lang.annotation.Target;  
   
 /** 
  * 表示对标记有xxx注解的类,做代理 注解@Retention可以用来修饰注解，是注解的注解，称为元注解。 
  * Retention注解有一个属性value，是RetentionPolicy类型的，Enum RetentionPolicy是一个枚举类型， 
  * 这个枚举决定了Retention注解应该如何去保持，也可理解为Rentention 搭配 
  * RententionPolicy使用。RetentionPolicy有3个值：CLASS RUNTIME SOURCE 
  * 用@Retention(RetentionPolicy 
  * .CLASS)修饰的注解，表示注解的信息被保留在class文件(字节码文件)中当程序编译时，但不会被虚拟机读取在运行的时候； 
  * 用@Retention(RetentionPolicy.SOURCE 
  * )修饰的注解,表示注解的信息会被编译器抛弃，不会留在class文件中，注解的信息只会留在源文件中； 
  * 用@Retention(RetentionPolicy.RUNTIME 
  * )修饰的注解，表示注解的信息被保留在class文件(字节码文件)中当程序编译时，会被虚拟机保留在运行时， 
  * 所以他们可以用反射的方式读取。RetentionPolicy.RUNTIME 
  * 可以让你从JVM中读取Annotation注解的信息，以便在分析程序的时候使用. 
  *  
  * 类和方法的annotation缺省情况下是不出现在javadoc中的，为了加入这个性质我们用@Documented 
  *  java用  @interface Annotation{ } 定义一个注解 @Annotation，一个注解是一个类。 
  *  @interface是一个关键字，在设计annotations的时候必须把一个类型定义为@interface，而不能用class或interface关键字  
  *  
  * @author q 
  *  
  */  
   
 @Target({ ElementType.METHOD, ElementType.TYPE })  
 @Retention(RetentionPolicy.RUNTIME)  
 @Documented  
 public @interface MethodLog {  
 String remark() default "";  
     String operType() default "0";     
    // String desc() default "";  
 }  

日志数据效果:

=========【参考2】========

从业近二，三年了，第一次写博客，平时做做脚手架或者架构一些基础框架然后给大家使用或者自己总结翻译一些文档。虽然是第一次但是我还是要拿Spring开刀。希望张开涛，涛兄看到的时候不要喷我，给我一点指导。

首先我们为什么需要做日志管理，在现实的上线中我们经常会遇到系统出现异常或者问题。这个时候就马上打开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代码

package com.annotation;
import java.lang.annotation.*;
/**
*自定义注解拦截Controller
*/
@Target({ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface SystemControllerLog {
String description() default "";
}
package com.annotation;
import java.lang.annotation.*;
/**
*自定义注解拦截service
*/
@Target({ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface SystemServiceLog {
String description() default "";
}

第二步创建一个切点类：

Java代码

package com.annotation;
import com.model.Log;
import com.model.User;
import com.service.LogService;
import com.util.DateUtil;
import com.util.JSONUtil;
import com.util.SpringContextHolder;
import com.util.WebConstants;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.lang.reflect.Method;
/**
* 切点类
* @author tiangai
* @since 2014-08-05 Pm 20:35
* @version 1.0
*/
@Aspect
@Component
public class SystemLogAspect {
//注入Service用于把日志保存数据库
@Resource
private LogService logService;
//本地异常日志记录对象
private static final Logger logger = LoggerFactory.getLogger(SystemLogAspect. class);
//Service层切点
@Pointcut("@annotation(com.annotation.SystemServiceLog)")
public void serviceAspect() {
}
//Controller层切点
@Pointcut("@annotation(com.annotation.SystemControllerLog)")
public void controllerAspect() {
}
/**
* 前置通知用于拦截Controller层记录用户的操作
*
* @param joinPoint 切点
*/
@Before("controllerAspect()")
public void doBefore(JoinPoint joinPoint) {
HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
HttpSession session = request.getSession();
//读取session中的用户
User user = (User) session.getAttribute(WebConstants.CURRENT_USER);
//请求的IP
String ip = request.getRemoteAddr();
try {
//*========控制台输出=========*//
System.out.println("=====前置通知开始=====");
System.out.println("请求方法:" + (joinPoint.getTarget().getClass().getName() + "." + joinPoint.getSignature().getName() + "()"));
System.out.println("方法描述:" + getControllerMethodDescription(joinPoint));
System.out.println("请求人:" + user.getName());
System.out.println("请求IP:" + ip);
//*========数据库日志=========*//
Log log = SpringContextHolder.getBean("logxx");
log.setDescription(getControllerMethodDescription(joinPoint));
log.setMethod((joinPoint.getTarget().getClass().getName() + "." + joinPoint.getSignature().getName() + "()"));
log.setType("0");
log.setRequestIp(ip);
log.setExceptionCode( null);
log.setExceptionDetail( null);
log.setParams( null);
log.setCreateBy(user);
log.setCreateDate(DateUtil.getCurrentDate());
//保存数据库
logService.add(log);
System.out.println("=====前置通知结束=====");
} catch (Exception e) {
//记录本地异常日志
logger.error("==前置通知异常==");
logger.error("异常信息:{}", e.getMessage());
}
}
/**
* 异常通知用于拦截service层记录异常日志
*
* @param joinPoint
* @param e
*/
@AfterThrowing(pointcut = "serviceAspect()", throwing = "e")
public void doAfterThrowing(JoinPoint joinPoint, Throwable e) {
HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
HttpSession session = request.getSession();
//读取session中的用户
User user = (User) session.getAttribute(WebConstants.CURRENT_USER);
//获取请求ip
String ip = request.getRemoteAddr();
//获取用户请求方法的参数并序列化为JSON格式字符串
String params = "";
if (joinPoint.getArgs() != null && joinPoint.getArgs().length > 0) {
for ( int i = 0; i < joinPoint.getArgs().length; i++) {
params += JSONUtil.toJsonString(joinPoint.getArgs()[i]) + ";";
}
}
try {
/*========控制台输出=========*/
System.out.println("=====异常通知开始=====");
System.out.println("异常代码:" + e.getClass().getName());
System.out.println("异常信息:" + e.getMessage());
System.out.println("异常方法:" + (joinPoint.getTarget().getClass().getName() + "." + joinPoint.getSignature().getName() + "()"));
System.out.println("方法描述:" + getServiceMthodDescription(joinPoint));
System.out.println("请求人:" + user.getName());
System.out.println("请求IP:" + ip);
System.out.println("请求参数:" + params);
/*==========数据库日志=========*/
Log log = SpringContextHolder.getBean("logxx");
log.setDescription(getServiceMthodDescription(joinPoint));
log.setExceptionCode(e.getClass().getName());
log.setType("1");
log.setExceptionDetail(e.getMessage());
log.setMethod((joinPoint.getTarget().getClass().getName() + "." + joinPoint.getSignature().getName() + "()"));
log.setParams(params);
log.setCreateBy(user);
log.setCreateDate(DateUtil.getCurrentDate());
log.setRequestIp(ip);
//保存数据库
logService.add(log);
System.out.println("=====异常通知结束=====");
} catch (Exception ex) {
//记录本地异常日志
logger.error("==异常通知异常==");
logger.error("异常信息:{}", ex.getMessage());
}
/*==========记录本地异常日志==========*/
logger.error("异常方法:{}异常代码:{}异常信息:{}参数:{}", joinPoint.getTarget().getClass().getName() + joinPoint.getSignature().getName(), e.getClass().getName(), e.getMessage(), params);
}
/**
* 获取注解中对方法的描述信息用于service层注解
*
* @param joinPoint 切点
* @return 方法描述
* @throws Exception
*/
public static String getServiceMthodDescription(JoinPoint joinPoint)
throws Exception {
String targetName = joinPoint.getTarget().getClass().getName();
String methodName = joinPoint.getSignature().getName();
Object[] arguments = joinPoint.getArgs();
Class targetClass = Class.forName(targetName);
Method[] methods = targetClass.getMethods();
String description = "";
for (Method method : methods) {
if (method.getName().equals(methodName)) {
Class[] clazzs = method.getParameterTypes();
if (clazzs.length == arguments.length) {
description = method.getAnnotation(SystemServiceLog. class).description();
break;
}
}
}
return description;
}
/**
* 获取注解中对方法的描述信息用于Controller层注解
*
* @param joinPoint 切点
* @return 方法描述
* @throws Exception
*/
public static String getControllerMethodDescription(JoinPoint joinPoint) throws Exception {
String targetName = joinPoint.getTarget().getClass().getName();
String methodName = joinPoint.getSignature().getName();
Object[] arguments = joinPoint.getArgs();
Class targetClass = Class.forName(targetName);
Method[] methods = targetClass.getMethods();
String description = "";
for (Method method : methods) {
if (method.getName().equals(methodName)) {
Class[] clazzs = method.getParameterTypes();
if (clazzs.length == arguments.length) {
description = method.getAnnotation(SystemControllerLog. class).description();
break;
}
}
}
return description;
}
}

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

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

Xml代码

<aop:aspectj-autoproxy/>

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

Xml代码

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

第四步使用

Controller层的使用

Java代码

/**
* 删除用户
*
* @param criteria 条件
* @param id id
* @param model 模型
* @return 数据列表
*/
@RequestMapping(value = "/delete")
//此处为记录AOP拦截Controller记录用户操作
@SystemControllerLog(description = "删除用户")
public String del(Criteria criteria, String id, Model model, HttpSession session) {
try {
User user = (User) session.getAttribute(WebConstants.CURRENT_USER);
if ( null != user) {
if (user.getId().equals(id)) {
msg = "您不可以删除自己!";
criteria = userService.selectByCriteriaPagination(criteria);
} else {
//删除数据并查询出数据
criteria = userService.delete(id, criteria);
msg = "删除成功!";
}
}
} catch (Exception e) {
msg = "删除失败!";
} finally {
model.addAttribute("msg", msg);
model.addAttribute("criteria", criteria);
}
//跳转列表页
return "user/list";
}