aop+自定义注解实现操作日志记录

记录日志的自定义注解

 

[java] view plaincopy

1. package com.apabi.leopard.annotation;  
2.   
3. import java.lang.annotation.Retention;  
4. import java.lang.annotation.Target;  
5. import java.lang.annotation.RetentionPolicy;  
6. import java.lang.annotation.ElementType;  
7.   
8. /** 
9.  * @author pengjin 
10.  * @version 2.1 
11.  * @since 2.1 
12.  */  
13. @Retention(RetentionPolicy.RUNTIME)  
14. @Target(ElementType.METHOD)  
15. public @interface LogAnnotation {  
16.     String operateModelNm();  
17.     String operateFuncNm();  
18.     String operateDescribe();  
19. }  

 

aop切面处理方法：

 

[java] view plaincopy

1. package com.apabi.leopard.annotation;  
2.   
3. import java.lang.reflect.Array;  
4. import java.lang.reflect.Method;  
5. import java.util.ArrayList;  
6. import java.util.Arrays;  
7. import java.util.Date;  
8. import java.util.List;  
9.   
10. import javax.servlet.http.HttpServletRequest;  
11.   
12. import javacommon.base.BaseSpringController;  
13. import javacommon.security.springsecurity.SpringSecurityUtils;  
14.   
15. import org.aspectj.lang.JoinPoint;  
16. import org.springframework.beans.factory.annotation.Autowired;  
17.   
18. import com.apabi.leopard.model.Admin;  
19. import com.apabi.leopard.model.OperateLog;  
20. import com.apabi.leopard.service.OperateLogManager;  
21. import com.apabi.leopard.sso.SsoService;  
22. import com.apabi.leopard.sso.User;  
23.   
24. /** 
25.  * @author pengjin 
26.  * @version 2.1 
27.  * @since 2.1 
28.  */  
29. public class WriteOperateLog {  
30.     @Autowired  
31.     private OperateLogManager operateLogManager;  
32.   
33.     public void writeLogInfo(JoinPoint joinPoint) throws Exception,  
34.             IllegalAccessException {  
35.         String temp = joinPoint.getStaticPart().toShortString();  
36.         String longTemp = joinPoint.getStaticPart().toLongString();  
37.         joinPoint.getStaticPart().toString();  
38.         String classType = joinPoint.getTarget().getClass().getName();  
39.         String methodName = temp.substring(10, temp.length() - 1);  
40.         Class<?> className = Class.forName(classType);  
41.         // 日志动作  
42.         @SuppressWarnings("rawtypes")  
43.         Class[] args = new Class[joinPoint.getArgs().length];  
44.         String[] sArgs = (longTemp.substring(longTemp.lastIndexOf("(") + 1,  
45.                 longTemp.length() - 2)).split(",");  
46.         for (int i = 0; i < args.length; i++) {  
47.             if (sArgs[i].endsWith("String[]")) {  
48.                 args[i] = Array.newInstance(Class.forName("java.lang.String"),  
49.                         1).getClass();  
50.             } else if (sArgs[i].endsWith("Long[]")) {  
51.                 args[i] = Array.newInstance(Class.forName("java.lang.Long"), 1)  
52.                         .getClass();  
53.             } else if (sArgs[i].indexOf(".") == -1) {  
54.                 if (sArgs[i].equals("int")) {  
55.                     args[i] = int.class;  
56.                 } else if (sArgs[i].equals("char")) {  
57.                     args[i] = char.class;  
58.                 } else if (sArgs[i].equals("float")) {  
59.                     args[i] = float.class;  
60.                 } else if (sArgs[i].equals("long")) {  
61.                     args[i] = long.class;  
62.                 }  
63.             } else {  
64.                 args[i] = Class.forName(sArgs[i]);  
65.             }  
66.         }  
67.         Method method = className.getMethod(  
68.                 methodName.substring(methodName.indexOf(".") + 1,  
69.                         methodName.indexOf("(")), args);  
70.         BaseSpringController thisController = (BaseSpringController) joinPoint  
71.                 .getTarget();  
72.         // 如果该方法写了注解才做操作  
73.         if (method.isAnnotationPresent(LogAnnotation.class)) {  
74.             LogAnnotation logAnnotation = method  
75.                     .getAnnotation(LogAnnotation.class);  
76.             String operateModelNm = logAnnotation.operateModelNm();  
77.             String operateFuncNm = logAnnotation.operateFuncNm();  
78.             String operateDescribe = logAnnotation.operateDescribe();  
79.             List<String> logArgs = null;  
80.             if (operateDescribe.indexOf("#") != -1) {  
81.                 logArgs = new ArrayList<String>();  
82.                 int startIndex = operateDescribe.indexOf("#", 0);  
83.                 int endIndex = operateDescribe.indexOf("#", startIndex + 1);  
84.                 while (startIndex != -1) {  
85.                     String tempArg = operateDescribe.substring(startIndex + 1,  
86.                             endIndex);  
87.                     startIndex = operateDescribe.indexOf("#", endIndex + 1);  
88.                     endIndex = operateDescribe.indexOf("#", startIndex + 1);  
89.                     logArgs.add(tempArg);  
90.                 }  
91.             }  
92.   
93.             // 获取被注解方法的参数，实现动态注解  
94.             String logArg = null;  
95.             // 被注解方法只有一个参数的情况可用%替代要传入的参数  
96.             if (args.length == 1) {  
97.                 if (args[0].getName().equals("java.lang.Long")  
98.                         || args[0].getName().equals("java.lang.Integer")  
99.                         || args[0].getName().equals("java.lang.String")) {  
100.                     logArg = String.valueOf((joinPoint.getArgs())[0]);  
101.                 } else if (args[0] == String[].class) {  
102.                     String[] arrayArg = (String[]) (joinPoint.getArgs())[0];  
103.                     logArg = Arrays.toString(arrayArg);  
104.                 } else if (args[0].getName().startsWith(  
105.                         "com.apabi.leopard.model")) {  
106.                     Method m = args[0].getMethod("getId");  
107.                     logArg = String.valueOf(m.invoke(joinPoint.getArgs()[0]));  
108.                     // 包含了两个操作的日志内容如save方法中包含了增加和修改操作，根据是否存在参数来判断是什么操作  
109.                     if (operateDescribe.indexOf("|") != -1) {  
110.                         if (!logArg.equals("null")) {  
111.                             operateDescribe = operateDescribe  
112.                                     .substring(operateDescribe.indexOf("|") + 1);  
113.                         } else {  
114.                             operateDescribe = operateDescribe.substring(0,  
115.                                     operateDescribe.indexOf("|"));  
116.                         }  
117.                     }  
118.                 }  
119.                 // 将注解中%转换为被拦截方法参数中的id  
120.                 if (!logArg.equals("null")) {  
121.                     operateDescribe = operateDescribe.indexOf("%") != -1 ? operateDescribe  
122.                             .replace("%", logArg) : operateDescribe;  
123.                 }  
124.             } else {  
125.                 Object obj[] = joinPoint.getArgs();  
126.                 for (int k = 0; k < logArgs.size(); k++) {  
127.                     for (int j = k; j < obj.length; j++) {  
128.                         // 如果是实体  
129.                         if (logArgs.get(k).startsWith("@")) {  
130.                             if (args[j].getName().startsWith(  
131.                                     "com.apabi.leopard.model")) {  
132.                                 Method m = args[j].getMethod("getId");  
133.                                 logArg = String.valueOf(m.invoke(joinPoint  
134.                                         .getArgs()[j]));  
135.                                 // 包含了两个操作的日志内容如save方法中包含了增加和修改操作，根据是否存在参数来判断是什么操作  
136.                                 if (!logArg.equals("null")) {  
137.                                     operateDescribe = operateDescribe  
138.                                             .substring(operateDescribe  
139.                                                     .indexOf("|") + 1);  
140.                                 } else {  
141.                                     operateDescribe = operateDescribe  
142.                                             .substring(0, operateDescribe  
143.                                                     .indexOf("|"));  
144.                                 }  
145.                             } else {  
146.                                 continue;  
147.                             }  
148.                             // 数组  
149.                         } else if (logArgs.get(k).startsWith("{1}quot;)) {  
150.                             String[] arrayArg = thisController.request  
151.                                     .getParameterValues(logArgs.get(k)  
152.                                             .substring(1));  
153.                             logArg = Arrays.toString(arrayArg);  
154.                             // String  
155.                         } else {  
156.                             logArg = thisController.request  
157.                                     .getParameter(logArgs.get(k));  
158.   
159.                             if (logArgs.get(k).equals("bsId") && logArg == null) {  
160.                                 logArg = SpringSecurityUtils.getCurrentAdmin()  
161.                                         .getNwOfficeId().toString();  
162.                             }  
163.                             if (operateDescribe.indexOf("|") != -1) {  
164.                                 if (!logArg.equals("null")) {  
165.                                     operateDescribe = operateDescribe  
166.                                             .substring(operateDescribe  
167.                                                     .indexOf("|") + 1);  
168.                                 } else {  
169.                                     operateDescribe = operateDescribe  
170.                                             .substring(0, operateDescribe  
171.                                                     .indexOf("|"));  
172.                                 }  
173.                             }  
174.                         }  
175.                         if (logArg == null || logArg.equals("null")) {  
176.                             logArg = "";  
177.                         }  
178.                         operateDescribe = operateDescribe.replace(  
179.                                 "#" + logArgs.get(k) + "#", logArg);  
180.                         break;  
181.                     }  
182.                 }  
183.             }  
184.             OperateLog log = null;  
185.             Admin admin = SpringSecurityUtils.getCurrentAdmin();  
186.             if (admin != null) {  
187.                 log = new OperateLog(admin.getNwOfficeId(),  
188.                         admin.getLoginName(), operateModelNm, operateFuncNm,  
189.                         operateDescribe, new Date(),  
190.                         getIpAddr(thisController.request));  
191.             } else {  
192.                 final User user = (User) thisController.request.getSession()  
193.                         .getAttribute(SsoService.SESSION_USER);  
194.                 log = new OperateLog(user.getNwOfficeId(), user.getUsername(),  
195.                         operateModelNm, operateFuncNm, operateDescribe,  
196.                         new Date(), user.getIpAddress());  
197.             }  
198.   
199.             operateLogManager.saveOrUpdate(log);  
200.         }  
201.     }  
202.   
203.     public static String getIpAddr(HttpServletRequest request) {  
204.         String ip = request.getHeader("x-forwarded-for");  
205.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {  
206.             ip = request.getHeader("Proxy-Client-IP");  
207.         }  
208.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {  
209.             ip = request.getHeader("WL-Proxy-Client-IP");  
210.         }  
211.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {  
212.             ip = request.getRemoteAddr();  
213.         }  
214.         return ip;  
215.     }  
216. }  

配置文件springmvc-servlet.xml增加

<aop:config proxy-target-class="true">
  <aop:aspect id="goLogAspect" ref="AfterReturningAdvice">
   <aop:pointcut id="actionPointcut" expression="execution(* com.*..*.web.*Controller.*(..))" />
   <aop:before pointcut-ref="actionPointcut"
    method="writeLogInfo" />
  </aop:aspect>
 </aop:config>
 <bean id="AfterReturningAdvice" class="com.xxx.leopard.annotation.AfterReturningAdvice"></bean>

 

例：

/**
  * 保存对象.
  **/
 @RequestMapping
 @LogAnnotation(operateDescribe="公开策略")
 public String save(final IssuePolicy issuePolicy, final String limitIpRange) throws Exception {

//

}

/**
  * 开放公开策略.
  */
 @RequestMapping
 @LogAnnotation(operateDescribe="开放了id为%的公开策略")
 public void open(final String[] ids) {

}

 

添加日志的方法：在需要添加日志的controller方法上面添加         
        传一个参数的情况用%
 @LogAnnotation(operateModelNm = "模块名",operateFuncNm = "功能名",operateDescribe = "修好了id=%的套餐")
 传多个参数的情况用#参数名#，实体类型前面加@ 数组类型前面加$，其他类型不加 例如#$参数名# 
 @LogAnnotation(operateModelNm = "模块名",operateFuncNm = "功能名",operateDescribe = "修好了id=#@role#，nwOfficeId=#nwOfficeId#的角色")

由于以上代码不能适应所有的情况，所以实际使用时还需要根据情况进行修改

利用spring实现AOP有两种方式：注解和xml文件定义。前者比较灵活，利于维护。一个小例子：

一、接口PersonService

package com.aoptest.service;

public interface PersonService

{

public void save(String name);

public void update(String name,Integer id);

public String getPersonName();

}

二、接口的实现类PersonServiceBean 

package com.aoptest.service.impl;

import com.aoptest.service.PersonService;

public class PersonServiceBean implements PersonService

{

@Override

public String getPersonName()

{

System.out.println("我是getPersonName()方法。。。");

return "返回结果";

}

 

@Override

public void save(String name)

{

System.out.println("我是save()方法。。。");

throw new RuntimeException("异常了。。");

}

 

@Override

public void update(String name, Integer id)

{

System.out.println("我是update()方法。。。");

}

}

三、spring配置文件applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans

xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:aop="http://www.springframework.org/schema/aop"

xmlns:p="http://www.springframework.org/schema/p"

xsi:schemaLocation="http://www.springframework.org/schema/beans 

http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

<aop:aspectj-autoproxy />

<bean id="myInterceptor" class="com.aoptest.service.MyInterceptor" />

<bean id="personService" class="com.aoptest.service.impl.PersonServiceBean"></bean>

</beans>

ps:

1、红色部分是引入springAOP的命名空间

2、绿色部分必须要有，声明需要AOP操作

3、蓝色部分是做测试时用

四、切面部分MyInterceptor

/**

 * 切面

 */

@Aspect //声明此类为一个切面

public class MyInterceptor

{

@Pointcut("execution(* com.aoptest.service..*.*(..))")//声明一个切入点，可以拦截具体到某个方法，即在执行此方法之前、之后、最终、异常……时可以执行的其他业务方法（通知advice）；括号内的意思是：拦截某个方法，返回值是所有类型（第一个*），com.aoptest.service包及其子包下的所有类（..*），类下所有的方法（第三个.*），返回值任意（内部嵌套括号(..)）

//@Pointcut("execution(* com.aoptest.service.impl.PersonServiceBean.*(..))")//同上，两种都可以

private void anyMethod(){}//声明一个切入点

@Before("anyMethod() && args(name)")//声明前置通知

public void doBefore(String name){

System.out.println("前置通知");

System.out.println("---"+name+"---");//可以得到参数值，此时args(name)限制条件限定了"execution(* com.aoptest.service..*.*(..))"中只拦截参数个数只有1个且类型为String的方法，而不是所有方法（该属性在当前拦截中适用，即前置通知适用）

}

@AfterReturning(pointcut="anyMethod()",returning="result")//声明后置通知

public void doAfterReturning(String result){

System.out.println("后置通知");

System.out.println("---"+result+"---");//返回结果，同上

}

@AfterThrowing(pointcut="anyMethod()",throwing="e")//声明例外通知

public void doAfterThrowing(Exception e){

System.out.println("例外通知");

System.out.println(e.getMessage());//获取异常信息，同上

}

@After("anyMethod()")//声明最终通知

public void doAfter(){

System.out.println("最终通知");

}

@Around("anyMethod()")//声明环绕通知

public Object doAround(ProceedingJoinPoint pjp)throws Throwable

{

System.out.println("进入方法---环绕通知");

Object o =  pjp.proceed();

System.out.println("退出方法---环绕通知");

return o;

}

}

五、测试部分

public class SpringAopTest

{

@Test public void interceptorTest()

{

ApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");

PersonService personService = (PersonService)cxt.getBean("personService");

personService.save("xx");

String result=personService.getPersonName();

System.out.println(result);

}

}

http://xiaojinge-ok-163-com.iteye.com/blog/908190

最近项目组长分配给我一个任务，让我完成一个操作日志的管理功能。需求是这样的：项目很大，有好几个子系统，而且这些子系统已经都在开发过程中了，都进行了大半了。现在要实现的操作日志管理是要将用户在登录系统后所做的重要操作记录下来并查询。记录的内容包括操作人的相关信息（比如：用户ID，用户名，用户IP地址，所属机构等）和所执行的操作的相关信息（比如：所属模块名称、类名、方法名、参数、是否操作成功、描述信息和错误信息）。操作日志查询功能没有什么可说的，难点是在于操作日志的记录，首先要考虑到的是日志的记录不能或要尽量少地让其他人改动自己的代码；其次要考虑到日志记录的灵活性。因此我采用了注解的方式来实现，只要将注解添加到想要记录日志的方法体上就可以实现操作日志的记录。

实现步骤如下：

 

第一步：启用@AspectJ支持。

在你的工程lib目录下添加aspectjweaver.jar和aspectjrt.jar并在spring 的配置文件中添加如下代码：

 

 

 

Xml代码  

1. <aop:aspectj-autoproxy/>  

 这一步就完成了@AspectJ的支持，从而可以实现通过注解方式将通知编织到非公共方法中。

 

第二步：编写自定义注解。实现对方法所实现的功能进行描述，以便在通知中获取描述信息，代码非常简单，如下：

Java代码  

1. package com.abchina.rmpf.logmng.ann;  
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. @Target({ElementType.METHOD})  
10. @Retention(RetentionPolicy.RUNTIME)  
11. @Documented  
12. public @interface rmpfLog {  
13.     String desc() default "无描述信息";  
14. }  

 

第三步：编写操作日志切面通知实现类。

在编写切面通知实现类之前，我们需要搞清楚我们需要哪些通知类型，是前置通知、后置通知、环绕通知或异常通知？根据我的需求，我们知道我们记录的操作日志有两种情况，一种是操作成功，一种是操作失败。操作成功时则方法肯定已经执行完成，顾我们需要实现一个后置通知；操作失败时则说明方法出现异常无法正常执行完成，顾还需要一个异常通知。因此我们就需要实现这两个通知即可。代码如下：

Java代码  

1. package com.abchina.rmpf.logmng.aop;  
2.   
3. import java.io.File;  
4. import java.lang.reflect.Array;  
5. import java.util.Collection;  
6. import java.util.Iterator;  
7.   
8. import net.sf.json.JSONArray;  
9. import net.sf.json.JSONObject;  
10.   
11. import org.aspectj.lang.JoinPoint;  
12. import org.aspectj.lang.annotation.After;  
13. import org.aspectj.lang.annotation.AfterReturning;  
14. import org.aspectj.lang.annotation.AfterThrowing;  
15. import org.aspectj.lang.annotation.Aspect;  
16. import org.dom4j.Document;  
17. import org.dom4j.Element;  
18. import org.dom4j.io.SAXReader;  
19. import org.springframework.util.ResourceUtils;  
20.   
21. import plantix.core.business.exception.BusinessException;  
22. import plantix.core.context.ThreadContext;  
23.   
24. import com.abchina.rmpf.privmng.web.vo.ActorVO;  
25. import com.abchina.rmpf.common.Constant;  
26. import com.abchina.rmpf.common.DateTool;  
27. import com.abchina.rmpf.logmng.ann.rmpfLog;  
28. import com.abchina.rmpf.logmng.service.ILogService;  
29. import com.abchina.rmpf.logmng.web.vo.LogVO;  
30. import com.opensymphony.xwork2.ActionContext;  
31.   
32. @Aspect //该注解标示该类为切面类  
33. public class LogAspect {  
34.       
35.     /** 
36.      * LogService 
37.      * @generated 
38.      */  
39.     private ILogService logService;  
40.       
41.     //标注该方法体为后置通知，当目标方法执行成功后执行该方法体  
42.     @AfterReturning("within(com.abchina.irms..*) && @annotation(rl)")  
43.     public void addLogSuccess(JoinPoint jp, rmpfLog rl){  
44.         Object[] parames = jp.getArgs();//获取目标方法体参数  
45.         String params = parseParames(parames); //解析目标方法体的参数  
46.         String className = jp.getTarget().getClass().toString();//获取目标类名  
47.         className = className.substring(className.indexOf("com"));  
48.         String signature = jp.getSignature().toString();//获取目标方法签名  
49.         String methodName = signature.substring(signature.lastIndexOf(".")+1, signature.indexOf("("));  
50.         String modelName = getModelName(className); //根据类名获取所属的模块  
51.           
52.         String ip = (String)ActionContext.getContext().getSession().get(Constant.THREAD_APP_IP_KEY); //用户IP  
53.         ActorVO actor = ((ActorVO)ActionContext.getContext().getSession().get(Constant.SESSION_ACTOR_KEY));  
54.         LogVO logvo = new LogVO();  
55.         logvo.setId(java.util.UUID.randomUUID().toString());  
56.         logvo.setClassname(className);  
57.         logvo.setMethodname(methodName);  
58.         logvo.setArgument(params);  
59.         logvo.setMemo(rl.desc());  
60.         logvo.setModelname(modelName);  
61.         logvo.setIp(ip);  
62.         logvo.setOperationtime(DateTool.getDateTime4());  
63. //      logvo.setErr("");  
64.         logvo.setFlag("1");  
65.           
66.         if(actor!=null){  
67.             logvo.setOrgid(actor.getOrgcode());  
68.             logvo.setUserid(actor.getUserid());  
69.             logvo.setUsername(actor.getUsername());  
70.         }  
71.           
72.         logService.insertLog(logvo);  
73.     }  
74.   
75.     //标注该方法体为异常通知，当目标方法出现异常时，执行该方法体  
76.     @AfterThrowing(pointcut="within(com.abchina.irms..*) && @annotation(rl)", throwing="ex")  
77.     public void addLog(JoinPoint jp, rmpfLog rl, BusinessException ex){  
78.         Object[] parames = jp.getArgs();  
79.         String params = parseParames(parames);  
80.         String className = jp.getTarget().getClass().toString();  
81.         className = className.substring(className.indexOf("com"));  
82.         String signature = jp.getSignature().toString();  
83.         String methodName = signature.substring(signature.lastIndexOf(".")+1, signature.indexOf("("));  
84.         String modelName = getModelName(className);  
85.           
86.         String ip = (String)ActionContext.getContext().getSession().get(Constant.THREAD_APP_IP_KEY);  
87.         ActorVO actor = ((ActorVO)ActionContext.getContext().getSession().get(Constant.SESSION_ACTOR_KEY));  
88.         LogVO logvo = new LogVO();  
89.         logvo.setId(java.util.UUID.randomUUID().toString());  
90.         logvo.setClassname(className);  
91.         logvo.setMethodname(methodName);  
92.         logvo.setArgument(params);  
93.         logvo.setMemo(rl.desc());  
94.         logvo.setModelname(modelName);  
95.         logvo.setIp(ip);  
96.         logvo.setOperationtime(DateTool.getDateTime4());  
97.         logvo.setErr(ex.toString());//记录异常信息  
98.         logvo.setFlag("0");  
99.           
100.         if(actor!=null){  
101.             logvo.setOrgid(actor.getOrgcode());  
102.             logvo.setUserid(actor.getUserid());  
103.             logvo.setUsername(actor.getUsername());  
104.         }  
105.           
106.         logService.insertLog(logvo);  
107.     }  
108.       
109.     /** 
110.      * 根据包名查询检索其所属的模块 
111.      * @param packageName 包名 
112.      * @return 模块名称 
113.      */  
114.     private String getModelName(String packageName){  
115.         String modelName = "";  
116.         SAXReader reader = new SAXReader();  
117.         try {  
118.             //读取project.xml模块信息描述xml文档  
119.             File proj = ResourceUtils.getFile("classpath:project.xml");  
120.             Document doc = reader.read(proj);  
121.             //获取文档根节点  
122.             Element root = doc.getRootElement();  
123.             //查询模块名称  
124.             modelName = searchModelName(root, packageName);  
125.         } catch (Exception e) {  
126.             e.printStackTrace();  
127.         }  
128.         return modelName;  
129.     }  
130.       
131.     /** 
132.      * 采用递归方式根据包名逐级检索所属模块 
133.      * @param element 元素节点 
134.      * @param packageName 包名 
135.      * @return 模块名称 
136.      */  
137.     private String searchModelName(Element element, String packageName){  
138.         String modelName = searchModelNodes(element, packageName);  
139.         //若将包名解析到最后的根目录后仍未检索到模块名称，则返回空  
140.         if(packageName.lastIndexOf(".")==-1){  
141.             return modelName;  
142.         }  
143.         //逐级检索模块名称  
144.         if(modelName.equals("")){  
145.             packageName = packageName.substring(0, packageName.lastIndexOf("."));  
146.             modelName = searchModelName(element, packageName);  
147.         }  
148.         return modelName;  
149.     }  
150.       
151.       
152.     /** 
153.      * 根据xml文档逐个节点检索模块名称 
154.      * @param element 节点元素 
155.      * @param packageName 包名 
156.      * @return 模块名称 
157.      */  
158.     @SuppressWarnings("unchecked")  
159.     private String searchModelNodes(Element element, String packageName){  
160.           
161.         String modelName = "";  
162.         Element modules = element.element("modules");  
163.         Iterator it = modules.elementIterator();  
164.         if(!it.hasNext()){  
165.             return modelName;  
166.         }  
167.         while (it.hasNext()) {  
168.             Element model = (Element) it.next();  
169.             String pack = model.attributeValue("packageName");  
170.             String name = model.elementText("moduleCHPath");  
171.             if(packageName.equals(pack)){  
172.                 modelName = name;  
173.                 return modelName;  
174.             }  
175.             if(modelName!=null && !modelName.equals("")){  
176.                 break;  
177.             }  
178.             modelName = searchModelNodes(model, packageName);  
179.         }  
180.           
181.         return modelName;  
182.     }  
183.       
184.     /** 
185.      * 解析方法参数 
186.      * @param parames 方法参数 
187.      * @return 解析后的方法参数 
188.      */  
189.     private String parseParames(Object[] parames) {  
190.         StringBuffer sb = new StringBuffer();  
191.         for(int i=0; i<parames.length; i++){  
192.             if(parames[i] instanceof Object[] || parames[i] instanceof Collection){  
193.                 JSONArray json = JSONArray.fromObject(parames[i]);  
194.                 if(i==parames.length-1){  
195.                     sb.append(json.toString());  
196.                 }else{  
197.                     sb.append(json.toString() + ",");  
198.                 }  
199.             }else{  
200.                 JSONObject json = JSONObject.fromObject(parames[i]);  
201.                 if(i==parames.length-1){  
202.                     sb.append(json.toString());  
203.                 }else{  
204.                     sb.append(json.toString() + ",");  
205.                 }  
206.             }  
207.         }  
208.         String params = sb.toString();  
209.         params = params.replaceAll("(\"\\w+\":\"\",)", "");  
210.         params = params.replaceAll("(,\"\\w+\":\"\")", "");  
211.         return params;  
212.     }  
213.   
214.     public ILogService getLogService() {  
215.         return logService;  
216.     }  
217.   
218.     public void setLogService(ILogService logService) {  
219.         this.logService = logService;  
220.     }  
221.       
222.       
223. }  

 

大家看上面的代码会发现这两个方法体：

 

Java代码  

1. @AfterReturning("within(com.abchina.irms..*) && @annotation(rl)")  
2. public void addLogSuccess(JoinPoint jp, rmpfLog rl){…}  

 

Java代码  

1. @AfterThrowing(pointcut="within(com.abchina.irms..*) && @annotation(rl)", throwing="ex")  
2. public void addLog(JoinPoint jp, rmpfLog rl, BusinessException ex){…}  

 

这两个方法体分别是后置通知和异常通知的实现。它们有两个相同的参数jp和rl，jp是切点对象，通过该对象可以获取切点所切入方法所在的类，方法名、参数等信息，具体方法可以看方法体的实现；rl则是我们的自定义注解的对象，通过该对象我们可以获取注解中参数值，从而获取方法的描述信息。在异常通知中多出了一个ex参数，该参数是方法执行时所抛出的异常，从而可以获取相应的异常信息。此处为我写的自定义异常。注意：如果指定异常参数，则异常对象必须与通知所切入的方法体抛出的异常保持一致，否则该通知不会执行。

 

addLogSuccess方法签名上的@AfterReturning("within(com.abchina.irms..*) && @annotation(rl)")注解，是指定该方法体为后置通知，其有一个表达式参数，用来检索符合条件的切点。该表达式指定com/abchina/irms目录下及其所有子目录下的所有带有@rmpfLog注解的方法体为切点。

addLog方法签名上的@AfterThrowing(pointcut="within(com.abchina.irms..*) && @annotation(rl)", throwing="ex")注解，是指定方法体为异常通知，其有一个表达式参数和一个抛出异常参数。表达式参数与后置通知的表达式参数含义相同，而抛出异常参数，则表示如果com/abchina/irms目录下及其所有子目录下的所有带有@rmpfLog注解的方法体在执行时抛出BusinessException异常时该通知便会执行。

注意：切面通知实现类是一个普通的pojo对象，如果要想指定其为通知对象，则需在其类名上添加@Aspect注解

 

第四步：在spring配置文件中创建通知bean对象。

Xml代码  

1. <bean id="logAspect" class="com.abchina.rmpf.logmng.aop.LogAspect">  
2.     <property name="logService">  
3.       <ref local="com.abchina.rmpf.logmng.service.impl.LogServiceImpl"/>  
4.     </property>  
5.   </bean>  

 

第五步：使用操作日志记录注解。

通过以上四步操作后，操作日志的记录功能就算完成了，那我们该如何使用呢？很简单！在com/abchina/irms目录下及其所有子目录下任意找到一个service层的某个类的方法，在其方法体上添加@rmpfLog(desc=”描述信息”)即可。代码如下：

Java代码  

1.                @rmpfLog(desc="创建关联交易合同")  
2. @Transactional  
3. public void insertRtcont(RtcontVO rtcontVO) throws BusinessException {  
4.     rtcontAL.insertRtcont(toRtcontDomain(rtcontVO));  
5. }