spring mvc +spring aop结合注解的 用户操作日志记录

记录 spring mvc controller层操作记录 

Java代码  

1. package com.wssys.framework;  
2.   
3. import java.lang.reflect.Method;  
4. import java.text.SimpleDateFormat;  
5. import java.util.Calendar;  
6.   
7. import javax.servlet.http.HttpServletRequest;  
8. import org.apache.shiro.SecurityUtils;  
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.wssys.bean.BolBean;  
19. import com.wssys.bean.ComPanyForm;  
20. import com.wssys.bean.DeliverBean;  
21. import com.wssys.bean.GoodsForm;  
22. import com.wssys.dao.SyslogDao;  
23. import com.wssys.entity.Companycontacts;  
24. import com.wssys.entity.PusFrontUser;  
25. import com.wssys.entity.PusMenu;  
26. import com.wssys.entity.PusRole;  
27. import com.wssys.entity.PusSysUser;  
28. import com.wssys.entity.Syslog;  
29. import com.wssys.utils.StringUtil;  
30. import com.wssys.utils.TCPIPUtil;  
31.   
32. /** 
33.  * @Aspect 实现spring aop 切面（Aspect）： 
34.  *  一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子。 在Spring AOP中，切面可以使用通用类（基于模式的风格）或者在普通类中以 @Aspect注解（@AspectJ风格）来实现。  
35.  *  AOP代理（AOP Proxy）： AOP框架创建的对象，用来实现切面契约（aspect contract）（包括通知方法执行等功能）。 在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。 注意：Spring 2.0最新引入的基于模式（schema-based ）风格和@AspectJ注解风格的切面声明，对于使用这些风格的用户来说，代理的创建是透明的。  
36.  */  
37. 
    
38. @Component  
39. @Aspect  
40. public class LogService {  
41.   
42.     @Autowired  
43.     private SyslogDao syslogDao;  
44.   
45.     public LogService() {  
46.         System.out.println("Aop");  
47.     }  
48.   
49.     /** 
50.      * 在Spring2.0中，Pointcut的定义包括两个部分：Pointcut表示式(expression)和Pointcut签名(signature)。让我们先看看execution表示式的格式： 
51.      * 括号中各个pattern分别表示修饰符匹配（modifier-pattern?）、返回值匹配（ret-type-patten）、类路径匹配（declaring-type-pattern?）、方法名匹配（name-pattern）、参数匹配（(param-pattern)）、异常类型匹配（throws-pattern?），其中后面跟着“?”的是可选项。 
52.      * @param point 
53.      * @throws Throwable 
54.      */  
55.     @Pointcut("@annotation(com.wssys.framework.MethodLog)")  
56.     public void methodCachePointcut() {  
57.   
58.     }  
59.   
60.     // // @Before("execution(* com.wssys.controller.*(..))")  
61.     // public void logAll(JoinPoint point) throws Throwable {  
62.     // System.out.println("打印========================");  
63.     // }  
64.     //  
65.     // // @After("execution(* com.wssys.controller.*(..))")  
66.     // public void after() {  
67.     // System.out.println("after");  
68.     // }  
69.   
70.     // 方法执行的前后调用  
71.     // @Around("execution(* com.wssys.controller.*(..))||execution(* com.bpm.*.web.account.*.*(..))")  
72.     // @Around("execution(* com.wssys.controller.*(..))")  
73.     // @Around("execution(* org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter.handle(..))")  
74.     @Around("methodCachePointcut()")  
75.     public Object around(ProceedingJoinPoint point) throws Throwable {  
76.         HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder  
77.                 .getRequestAttributes()).getRequest();  
78.         SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss E");  
79.         Calendar ca = Calendar.getInstance();  
80.         String operDate = df.format(ca.getTime());  
81.         String ip = TCPIPUtil.getIpAddr(request);  
82.         PusSysUser user = (PusSysUser) SecurityUtils.getSubject()  
83.                 .getPrincipal();  
84.         String loginName;  
85.         String name;  
86.         if (user != null) {  
87.             loginName = user.getAccount();  
88.             // name = user.name;  
89.         } else {  
90.             loginName = "匿名用户";  
91.             // name = "匿名用户";  
92.         }  
93.   
94.         String monthRemark = getMthodRemark(point);  
95.         String monthName = point.getSignature().getName();  
96.         String packages = point.getThis().getClass().getName();  
97.         if (packages.indexOf("$$EnhancerByCGLIB$$") > -1) { // 如果是CGLIB动态生成的类  
98.             try {  
99.                 packages = packages.substring(0, packages.indexOf("$$"));  
100.             } catch (Exception ex) {  
101.                 ex.printStackTrace();  
102.             }  
103.         }  
104.   
105.         String operatingcontent = "";  
106.         Object[] method_param = null;  
107.   
108.         Object object;  
109.         try {  
110.             method_param = point.getArgs(); //获取方法参数   
111.             // String param=(String) point.proceed(point.getArgs());  
112.             object = point.proceed();  
113.         } catch (Exception e) {  
114.             // 异常处理记录日志..log.error(e);  
115.             throw e;  
116.         }  
117.         Syslog sysLog = new Syslog();  
118.         sysLog.setIpAddress(ip);  
119.         sysLog.setLoginName(loginName);  
120.         sysLog.setMethodName(packages + "." + monthName);  
121.         sysLog.setMethodRemark(monthRemark);  
122.         //这里有点纠结 就是不好判断第一个object元素的类型 只好通过  方法描述来 做一一  转型感觉 这里 有点麻烦 可能是我对 aop不太了解  希望懂的高手在回复评论里给予我指点  
123.         //有没有更好的办法来记录操作参数  因为参数会有 实体类 或者javabean这种参数怎么把它里面的数据都解析出来?  
124.         if (StringUtil.stringIsNull(monthRemark).equals("会员新增")) {  
125.             PusFrontUser pfu = (PusFrontUser) method_param[0];  
126.             sysLog.setOperatingcontent("新增会员:" + pfu.getAccount());  
127.         } else if (StringUtil.stringIsNull(monthRemark).equals("新增角色")) {  
128.             PusRole pr = (PusRole) method_param[0];  
129.             sysLog.setOperatingcontent("新增角色:" + pr.getName());  
130.         } else if (StringUtil.stringIsNull(monthRemark).equals("用户登录")) {  
131.             PusSysUser currUser = (PusSysUser) method_param[0];  
132.             sysLog.setOperatingcontent("登录帐号:" + currUser.getAccount());  
133.         } else if (StringUtil.stringIsNull(monthRemark).equals("用户退出")) {  
134.             sysLog.setOperatingcontent("具体请查看用户登录日志");  
135.         } else if (StringUtil.stringIsNull(monthRemark).equals("角色名称修改")) {  
136.             PusRole pr = (PusRole) method_param[0];  
137.             sysLog.setOperatingcontent("修改角色:" + pr.getName());  
138.         } else if (StringUtil.stringIsNull(monthRemark).equals("新增后台用户")) {  
139.             PusSysUser psu = (PusSysUser) method_param[0];  
140.             sysLog.setOperatingcontent("新增后台用户:" + psu.getAccount());  
141.         } else if (StringUtil.stringIsNull(monthRemark).equals("更新菜单")) {  
142.             PusMenu pm = (PusMenu) method_param[0];  
143.             sysLog.setOperatingcontent("更新菜单:" + pm.getName());  
144.         } else if (StringUtil.stringIsNull(monthRemark).equals("保存菜单")) {  
145.             PusMenu pm = (PusMenu) method_param[0];  
146.             sysLog.setOperatingcontent("保存菜单:" + pm.getName());  
147.         } else if (StringUtil.stringIsNull(monthRemark).equals("修改公司")) {  
148.             ComPanyForm ciform = (ComPanyForm) method_param[0];  
149.             sysLog.setOperatingcontent("修改公司:" + ciform.getName());  
150.         } else if (StringUtil.stringIsNull(monthRemark).equals("联系人更新")) {  
151.             Companycontacts ct = (Companycontacts) method_param[0];  
152.             sysLog.setOperatingcontent("联系人更新:" + ct.getName());  
153.         } else if (StringUtil.stringIsNull(monthRemark).equals("修改货物")) {  
154.             GoodsForm goodsForm = (GoodsForm) method_param[0];  
155.             sysLog.setOperatingcontent("修改货物（货物id/编号）:" + goodsForm.getId());  
156.         } else if (StringUtil.stringIsNull(monthRemark).equals("打印出库单")) {  
157.             DeliverBean owh= (DeliverBean) method_param[0];  
158.             sysLog.setOperatingcontent("出库单单号:" + owh.getCknum());  
159.         } else if (StringUtil.stringIsNull(monthRemark).equals("打印提单")) {  
160.             BolBean bol= (BolBean) method_param[0];  
161.             sysLog.setOperatingcontent("提货单号:" + bol.getBolnum());  
162.         } else if (StringUtil.stringIsNull(monthRemark).equals("系统左侧菜单查询")) {  
163.             sysLog.setOperatingcontent("无");  
164.         } else {  
165.             sysLog.setOperatingcontent("操作参数:" + method_param[0]);  
166.         }  
167.   
168.         syslogDao.save(sysLog);  
169.         return object;  
170.     }  
171.   
172.     // 方法运行出现异常时调用    
173.     // @AfterThrowing(pointcut = "execution(* com.wssys.controller.*(..))",  
174.     // throwing = "ex")  
175.     public void afterThrowing(Exception ex) {  
176.         System.out.println("afterThrowing");  
177.         System.out.println(ex);  
178.     }  
179.   
180.     // 获取方法的中文备注____用于记录用户的操作日志描述  
181.     public static String getMthodRemark(ProceedingJoinPoint joinPoint)  
182.             throws Exception {  
183.         String targetName = joinPoint.getTarget().getClass().getName();  
184.         String methodName = joinPoint.getSignature().getName();  
185.         Object[] arguments = joinPoint.getArgs();  
186.   
187.         Class targetClass = Class.forName(targetName);  
188.         Method[] method = targetClass.getMethods();  
189.         String methode = "";  
190.         for (Method m : method) {  
191.             if (m.getName().equals(methodName)) {  
192.                 Class[] tmpCs = m.getParameterTypes();  
193.                 if (tmpCs.length == arguments.length) {  
194.                     MethodLog methodCache = m.getAnnotation(MethodLog.class);  
195.                     if (methodCache != null) {  
196.                         methode = methodCache.remark();  
197.                     }  
198.                     break;  
199.                 }  
200.             }  
201.         }  
202.         return methode;  
203.     }  
204.   
205.   
206. }  

spring application.xml配置: 

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

   <!-- 启动对@AspectJ注解的支持  --> 
   <aop:aspectj-autoproxy proxy-target-class="true" /> 


spring mvc controller层action的 
设置 例如: 

Java代码  

1. @RequestMapping(value = "/addFrontUser", method = RequestMethod.POST)  
2. @MethodLog(remark = "会员新增")  
3. public String saveFrontUserAction(@ModelAttribute("psu") PusFrontUser pfu,  
4.         BindingResult result, SessionStatus status,  
5.         HttpServletResponse response) {  
6.     if (pusFrontUserDao.checkAccount(pfu.getAccount()) > 0) {  
7.         PrintWriter out = null;  
8.         try {  
9.             out = response.getWriter();  
10.         } catch (IOException e) {  
11.             // TODO Auto-generated catch block  
12.             e.printStackTrace();  
13.         }  
14.   
15.         out.write("保存失败,会员帐号已经存在");  
16.   
17.         out.flush();  
18.         return null;  
19.     }  
20.     // Timestamp now = new Timestamp(System.currentTimeMillis());// 获取系统当前时间  
21.   
22.     int saverec = 0;  
23.   
24.     pfu.setPwd(new Sha384Hash(pfu.getPwd()).toBase64());  
25.     saverec = pusFrontUserDao.save(pfu);  
26.   
27.     PrintWriter out = null;  
28.     try {  
29.         out = response.getWriter();  
30.     } catch (IOException e) {  
31.         // TODO Auto-generated catch block  
32.         e.printStackTrace();  
33.     }  
34.     if (saverec > 0) {  
35.         out.write("保存成功,您可以继续保存或者关闭当前页面");  
36.     } else {  
37.         out.write("保存失败");  
38.     }  
39.   
40.     out.flush();  
41.     return null;  
42. }  

Java代码  

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

日志 数据效果: 

基本可以实现监控用户的数据操作，aop改变了传统的每个日志必须去一个个的方法里写的方式，直接通过反射得到所有数据一个类解决 ，

开发不是一般的快 。