Spring中的AOP（五）——在Advice方法中获取目标方法的参数

摘要: 本文介绍使用Spring AOP编程中，在增强处理方法中获取目标方法的参数，定义切点表达式时使用args来快速获取目标方法的参数。

获取目标方法的信息

访问目标方法最简单的做法是定义增强处理方法时，将第一个参数定义为JoinPoint类型，当该增强处理方法被调用时，该JoinPoint参数就代表了织入增强处理的连接点。JoinPoint里包含了如下几个常用的方法：

  • Object[] getArgs：返回目标方法的参数
  • Signature getSignature：返回目标方法的签名
  • Object getTarget：返回被织入增强处理的目标对象
  • Object getThis：返回AOP框架为目标对象生成的代理对象

注意：当使用@Around处理时，我们需要将第一个参数定义为ProceedingJoinPoint类型，该类是JoinPoint的子类。

下面的切面类（依然放在com.abc.advice包中）中定义了Before、Around、AfterReturning和After 4中增强处理，并分别在4种增强处理中访问被织入增强处理的目标方法、目标方法的参数和被织入增强处理的目标对象等：

package com.abc.advice;

import java.util.Arrays;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class AdviceTest {
    @Around("execution(* com.abc.service.*.many*(..))")
    public Object process(ProceedingJoinPoint point) throws Throwable {
        System.out.println("@Around：执行目标方法之前...");
        //访问目标方法的参数：
        Object[] args = point.getArgs();
        if (args != null && args.length > 0 && args[0].getClass() == String.class) {
            args[0] = "改变后的参数1";
        }
        //用改变后的参数执行目标方法
        Object returnValue = point.proceed(args);
        System.out.println("@Around：执行目标方法之后...");
        System.out.println("@Around：被织入的目标对象为：" + point.getTarget());
        return "原返回值：" + returnValue + "，这是返回结果的后缀";
    }
    
    @Before("execution(* com.abc.service.*.many*(..))")
    public void permissionCheck(JoinPoint point) {
        System.out.println("@Before：模拟权限检查...");
        System.out.println("@Before：目标方法为：" + 
                point.getSignature().getDeclaringTypeName() + 
                "." + point.getSignature().getName());
        System.out.println("@Before：参数为：" + Arrays.toString(point.getArgs()));
        System.out.println("@Before：被织入的目标对象为：" + point.getTarget());
    }
    
    @AfterReturning(pointcut="execution(* com.abc.service.*.many*(..))", 
        returning="returnValue")
    public void log(JoinPoint point, Object returnValue) {
        System.out.println("@AfterReturning：模拟日志记录功能...");
        System.out.println("@AfterReturning：目标方法为：" + 
                point.getSignature().getDeclaringTypeName() + 
                "." + point.getSignature().getName());
        System.out.println("@AfterReturning：参数为：" + 
                Arrays.toString(point.getArgs()));
        System.out.println("@AfterReturning：返回值为：" + returnValue);
        System.out.println("@AfterReturning：被织入的目标对象为：" + point.getTarget());
        
    }
    
    @After("execution(* com.abc.service.*.many*(..))")
    public void releaseResource(JoinPoint point) {
        System.out.println("@After：模拟释放资源...");
        System.out.println("@After：目标方法为：" + 
                point.getSignature().getDeclaringTypeName() + 
                "." + point.getSignature().getName());
        System.out.println("@After：参数为：" + Arrays.toString(point.getArgs()));
        System.out.println("@After：被织入的目标对象为：" + point.getTarget());
    }
}

在AdviceManager类中增加以下内容：

//将被AdviceTest的各种方法匹配
public String manyAdvices(String param1, String param2) {
    System.out.println("方法：manyAdvices");
    return param1 + " 、" + param2;
}

在com.abc.main.AOPTest中加入方法的调用，触发切点：

String result = manager.manyAdvices("aa", "bb");
System.out.println("Test方法中调用切点方法的返回值：" + result);

下面是执行结果：

@Around：执行目标方法之前...
@Before：模拟权限检查...
@Before：目标方法为：com.abc.service.AdviceManager.manyAdvices
@Before：参数为：[改变后的参数1, bb]
@Before：被织入的目标对象为：com.abc.service.AdviceManager@1dfc617e
方法：manyAdvices
@Around：执行目标方法之后...
@Around：被织入的目标对象为：com.abc.service.AdviceManager@1dfc617e
@After：模拟释放资源...
@After：目标方法为：com.abc.service.AdviceManager.manyAdvices
@After：参数为：[改变后的参数1, bb]
@After：被织入的目标对象为：com.abc.service.AdviceManager@1dfc617e
@AfterReturning：模拟日志记录功能...
@AfterReturning：目标方法为：com.abc.service.AdviceManager.manyAdvices
@AfterReturning：参数为：[改变后的参数1, bb]
@AfterReturning：返回值为：原返回值：改变后的参数1 、 bb，这是返回结果的后缀
@AfterReturning：被织入的目标对象为：com.abc.service.AdviceManager@1dfc617e
Test方法中调用切点方法的返回值：原返回值：改变后的参数1 、bb，这是返回结果的后缀

从结果中可以看出：在任何一个织入的增强处理中，都可以获取目标方法的信息。另外，Spring AOP采用和AspectJ一样的有限顺序来织入增强处理：在“进入”连接点时，最高优先级的增强处理将先被织入（所以给定的两个Before增强处理中，优先级高的那个会先执行）；在“退出”连接点时，最高优先级的增强处理会最后被织入（所以给定的两个After增强处理中，优先级高的那个会后执行）。当不同的切面中的多个增强处理需要在同一个连接点被织入时，Spring AOP将以随机的顺序来织入这些增强处理。如果应用需要指定不同切面类里的增强处理的优先级，Spring提供了如下两种解决方案：

  • 让切面类实现org.springframework.core.Ordered接口：实现该接口只需要实现一个int getOrder()方法，该方法返回值越小，优先级越高
  • 直接使用@Order注解来修饰一个切面类：使用这个注解时可以配置一个int类型的value属性，该属性值越小，优先级越高

优先级高的切面类里的增强处理的优先级总是比优先级低的切面类中的增强处理的优先级高。例如：优先级为1的切面类Bean1包含了@Before，优先级为2的切面类Bean2包含了@Around，虽然@Around优先级高于@Before，但由于Bean1的优先级高于Bean2的优先级，因此Bean1中的@Before先被织入。

同一个切面类里的两个相同类型的增强处理在同一个连接点被织入时，Spring AOP将以随机的顺序来织入这两个增强处理，没有办法指定它们的织入顺序。如果确实需要保证它们以固有的顺序被织入，则可以考虑将多个增强处理压缩为一个增强处理；或者将不同增强处理重构到不同切面中，通过在切面级别上定义顺序。

如果只要访问目标方法的参数，Spring还提供了一种更加简洁的方法：我们可以在程序中使用args来绑定目标方法的参数。如果在一个args表达式中指定了一个或多个参数，该切入点将只匹配具有对应形参的方法，且目标方法的参数值将被传入增强处理方法。下面辅以例子说明：

package com.abc.advice;

import java.util.Date;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;

@Aspect
public class AccessArgAdviceTest {
    @AfterReturning(
            pointcut="execution(* com.abc.service.*.access*(..)) && args(time, name)",
            returning="returnValue")
    public void access(Date time, Object returnValue, String name) {
        System.out.println("目标方法中的参数String = " + name);
        System.out.println("目标方法中的参数Date = " + time);
        System.out.println("目标方法的返回结果returnValue = " + returnValue);
    }
}

上面的程序中，定义pointcut时，表达式中增加了args(time, name)部分，意味着可以在增强处理方法（access方法）中定义time和name两个属性——这两个形参的类型可以随意指定，但一旦指定了这两个参数的类型，则这两个形参类型将用于限制该切入点只匹配第一个参数类型为Date，第二个参数类型为name的方法（方法参数个数和类型若有不同均不匹配）。

注意，在定义returning的时候，这个值（即上面的returning="returnValue"中的returnValue）作为增强处理方法的形参时，位置可以随意，即：如果上面access方法的签名可以为

public void access(Date time, Object returnValue, String name)

也可以为

public void access(Object returnValue, Date time, String name)

还可以为

public void access(Date time, String name, Object returnValue)

只需要满足另外的参数名的顺序和pointcut中args(param1, param2)的顺序相同即可。我们在AdviceManager中定义一个方法，该方法的第一个参数为Date类型，第二个参数为String类型，该方法的执行将触发上面的access方法，如下：

//将被AccessArgAdviceTest的access方法匹配
public String accessAdvice(Date d, String n) {
    System.out.println("方法：accessAdvice");
    return "aa";
}

在AOPTest中增加调用这个accessAdvice方法并执行，下面是输出结果：

从执行结果可以看出，使用args表达式有如下两个作用：

  • 提供了一种简单的方式来访问目标方法的参数
  • 可用于对切入点表达式作额外的限制

除此之外，使用args表达式时，还可以使用如下形式：args(param1, param2, ..)，注意args参数中后面的两个点，它表示可以匹配更多参数。在例子args(param1, param2, ..)中，表示目标方法只需匹配前面param1和param2的类型即可。

《Spring中的AOP系列三、四、五》的代码在这里：点击下载，欢迎留言提意见。

https://my.oschina.net/itblog/blog/211693

1.自定义注解，记录操作日志

1.自定义注解

[java] view plain copy

  1. package com.jay.demo3.aop1.myannotation;
  2. import java.lang.annotation.Documented;
  3. import java.lang.annotation.ElementType;
  4. import java.lang.annotation.Retention;
  5. import java.lang.annotation.RetentionPolicy;
  6. import java.lang.annotation.Target;
  7. //业务注释类  -- 定义 ： 运行期间基于方法的注解    参考http://my.oschina.net/yangzg/blog/343945
  8. /*
  9. * 常用注解说明：
  10. * 1. RetentionPolicy(保留策略)是一个enum类型，有三个值
  11. * SOURCE        --  这个Annotation类型的信息只会保留在程序源码里，源码如果经过了编译后，Annotation的数据就会消失，并不会保留在编译好的.class文件里
  12. * CLASS         --  这个Annotation类型的信息保留在程序源码中，同时也会保留在编译好的.class文件里面,在执行的时候，并不会把这一些信息加载到虚拟 机(JVM)中去.注意一下，当你没有设定一个Annotation类型的Retention值时，系统默认值是CLASS。
  13. * RUNTIME       --  在源码、编译好的.class文件中保留信息，在执行的时候会把这一些信息加载到JVM中去的。
  14. *
  15. * 2.ElementType @Target中的ElementType用来指定Annotation类型可以用在哪些元素上
  16. * TYPE(类型)    -- 在Class，Interface，Enum和Annotation类型上
  17. * FIELD        -- 属性上
  18. * METHOD       -- 方法上
  19. * PARAMETER    -- 参数上
  20. * CONSTRUCTOR  -- 构造函数上
  21. * LOCAL_VARIABLE -- 局部变量
  22. * ANNOTATION_TYPE   -- Annotation类型上
  23. * PACKAGE           -- 包上
  24. *
  25. * 3.Documented    -- 让这个Annotation类型的信息能够显示在API说明文档上；没有添加的话，使用javadoc生成的API文件找不到这个类型生成的信息
  26. */
  27. @Retention(RetentionPolicy.RUNTIME)
  28. @Target({ElementType.METHOD})
  29. @Documented
  30. public @interface BussAnnotation {
  31. //模块名
  32. String moduleName() default "";
  33. //操作内容
  34. String option() default "";
  35. }

2.业务逻辑和接口

1.接口

[java] view plain copy

  1. public interface UserManagerApplogic {
  2. public void addUser(String name);
  3. public void addOne(int type,int parentid);
  4. }

2.接口实现

[java] view plain copy

  1. package com.jay.demo3.aop1.impl;
  2. import org.springframework.stereotype.Component;
  3. import com.jay.demo3.aop1.UserManagerApplogic;
  4. import com.jay.demo3.aop1.myannotation.BussAnnotation;
  5. //用户管理业务逻辑实现类
  6. @Component("userManager")
  7. public class UserManagerApplogicImpl implements UserManagerApplogic {
  8. @BussAnnotation(moduleName="人员管理",option="添加用户")
  9. @Override
  10. public void addUser(String name) {
  11. System.out.println("add a User name is "+name);
  12. }
  13. @BussAnnotation(moduleName="人员管理",option="添加新人")
  14. @Override
  15. public void addOne(int type, int parentid) {
  16. System.out.println("add a new one type : "+type+" \t perentid : "+parentid);
  17. }
  18. }

3.日志拦截器 切面处理类

[java] view plain copy

  1. package com.jay.demo3.aop1.interceptor;
  2. import java.lang.reflect.Method;
  3. import org.aspectj.lang.ProceedingJoinPoint;
  4. import org.aspectj.lang.annotation.Around;
  5. import org.aspectj.lang.annotation.Aspect;
  6. import org.aspectj.lang.annotation.Pointcut;
  7. import org.springframework.stereotype.Component;
  8. import com.jay.demo3.aop1.myannotation.BussAnnotation;
  9. //切面类  http://my.oschina.net/yangzg/blog/343945
  10. /*
  11. * 特别注意： Spring的配置文件中添加：
  12. *
  13. * <aop:aspectj-autoproxy />
  14. * spring-mvc-dispatcher.xml中天机
  15. * <!--通知spring使用cglib而不是jdk的来生成代理方法 AOP可以拦截到Controller-->
  16. * <aop:aspectj-autoproxy proxy-target-class="true"/>
  17. *
  18. * <aop:config>节点中proxy-target-class="true"不为true时。
  19. * 当登录的时候会报这个异常java.lang.NoSuchMethodException: $Proxy54.login()，
  20. */
  21. @Aspect
  22. @Component
  23. public class LogInterceptor {
  24. // 定义切入点  @Pointcut("execution(public * com.jay..*.*(..))")  -- 表示对com.jay 包下的所有方法都可添加切入点
  25. @Pointcut("execution(public * com.jay..*.addUser(..))")
  26. public void aApplogic() {
  27. }
  28. //定义切入点  -- 拦截指定的方法  这里拦截 com.jay.demo3.aop1.impl.UserManagerApplogicImpl 的addOne()方法
  29. @Pointcut("execution(public * com.jay..*.addOne(..))")
  30. public void joinPointForAddOne(){
  31. }
  32. /**
  33. * 环绕通知 用于拦截指定内容，记录用户的操作
  34. */
  35. @Around(value = "aApplogic() && @annotation(annotation) &&args(object,..) ", argNames = "annotation,object")
  36. public Object interceptorApplogic(ProceedingJoinPoint pj,
  37. BussAnnotation annotation, Object object) throws Throwable {
  38. System.out.println("moduleName:" + annotation.moduleName());
  39. System.out.println("option:" + annotation.option());
  40. pj.proceed();
  41. System.out.println(pj.getSignature().getName());
  42. for(Object obj : pj.getArgs()){
  43. System.out.println(obj.toString());
  44. }
  45. return object;
  46. }
  47. /**
  48. * 环绕通知   拦截指定的切点，这里拦截joinPointForAddOne切入点所指定的addOne()方法
  49. *
  50. */
  51. @Around("joinPointForAddOne()")
  52. public Object interceptorAddOne(ProceedingJoinPoint joinPoint) throws Throwable {
  53. System.out.println("Aop start");
  54. String methodRemark = getMthodRemark(joinPoint);
  55. Object result = null;
  56. try {
  57. // 记录操作日志...谁..在什么时间..做了什么事情..
  58. result = joinPoint.proceed();
  59. } catch (Exception e) {
  60. // 异常处理记录日志..log.error(e);
  61. throw e;
  62. }
  63. System.out.println(methodRemark);
  64. System.out.println("Aop end");
  65. return result;
  66. }
  67. // 获取方法的中文备注____用于记录用户的操作日志描述
  68. public static String getMthodRemark(ProceedingJoinPoint joinPoint)
  69. throws Exception {
  70. String targetName = joinPoint.getTarget().getClass().getName();
  71. String methodName = joinPoint.getSignature().getName();
  72. System. out.println("====调用" +methodName+"方法-开始！");
  73. Object[] arguments = joinPoint.getArgs();   //获得参数列表
  74. System.out.println("打印出方法调用时传入的参数，可以在这里通过添加参数的类型，进行一些简易逻辑处理和判断");
  75. if(arguments.length<=0){
  76. System.out.println("=== "+methodName+" 方法没有参数");
  77. }else{
  78. for(int i=0;i<arguments.length;i++){
  79. System.out.println("==== 参数   "+(i+1)+" : "+arguments[i]);
  80. }
  81. }
  82. Class targetClass = Class.forName(targetName);
  83. Method[] method = targetClass.getMethods();
  84. String methode = "";
  85. for (Method m : method) {
  86. if (m.getName().equals(methodName)) {
  87. Class[] tmpCs = m.getParameterTypes();
  88. if (tmpCs.length == arguments.length) {
  89. BussAnnotation methodCache = m.getAnnotation(BussAnnotation.class);
  90. methode = methodCache.moduleName();
  91. break;
  92. }
  93. }
  94. }
  95. return methode;
  96. }
  97. }

4.测试类：

[java] view plain copy

  1. package com.jay.demo3.aop1.test;
  2. import org.junit.Test;
  3. import org.junit.runner.RunWith;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.test.context.ContextConfiguration;
  6. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  7. import com.jay.demo3.aop1.UserManagerApplogic;
  8. @RunWith(SpringJUnit4ClassRunner.class)
  9. @ContextConfiguration(locations = "classpath:*.xml")
  10. public class AopTest1 {
  11. @Autowired
  12. private UserManagerApplogic userManager;
  13. @Test
  14. public void testAopAddUser(){
  15. userManager.addUser("You you ");
  16. }
  17. @Test
  18. public void testAopAddOne(){
  19. userManager.addOne(1, 1);
  20. }
  21. }

5.Spring的配置文件 添加以下内容

[html] view plain copy

  1. <context:annotation-config/>
  2. <aop:aspectj-autoproxy />
  3. <context:component-scan base-package="com.jay" />

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

参考了网上的一些 文章 但是他们写的不是很全  自己也是经过了一些摸索  可以实现 记录 spring mvc controller层操作记录

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配置:

<!– aop –>
<bean id=”logService”></bean>

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

spring mvc controller层action的
设置 例如:

	@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;
	}
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 "";
}

日志 数据效果:

基本可以实现监控用户的数据操作

aop 太吊了
改变了传统 的 每个日志必须去一个个的方法里写的 方式
直接通过 反射 得到所有数据 一个 类解决
开发不是一般的快

这个过程中为了 做这个功能对spring aop 只是匆匆的看了一遍  接下来的时间有空就得好好研究下该技术 的原理以及实现

http://blog.csdn.net/he90227/article/details/44175365

时间： 2024-10-25 08:53:09

Spring中的AOP（五）——在Advice方法中获取目标方法的参数的相关文章

Spring中的AOP——在Advice方法中获取目标方法的参数（转）

获取目标方法的信息 访问目标方法最简单的做法是定义增强处理方法时,将第一个参数定义为JoinPoint类型,当该增强处理方法被调用时,该JoinPoint参数就代表了织入增强处理的连接点.JoinPoint里包含了如下几个常用的方法: Object[] getArgs:返回目标方法的参数 Signature getSignature:返回目标方法的签名 Object getTarget:返回被织入增强处理的目标对象 Object getThis:返回AOP框架为目标对象生成的代理对象 注意:当使

Spring：使用Spring AOP时，如何获取目标方法上的注解

当使用spring AOP时,判断目标方法上的注解进行相关操作,如缓存,认证权限等 自定义注解 package com.agent.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; import org.

运行时在方法内部获取该方法的名称及参数相关信息

package com.dongjak.scripts.java.反射; import java.lang.reflect.Method; import net.sf.json.JSONObject; import com.dongjak.annotations.LogTarget; /** * * @author dongjak * * */ public class 运行时在方法内部获取该方法的名称及参数相关信息 { public static void main(String[] args

Spring生态研习【五】：Springboot中bean的条件注入

在springboot中,开发的确变的简单了很多,但是,开发者现在希望开发傻瓜式的方便搞定项目中的各种奇怪的需求最好了,不用烧脑,本来程序猿的生活就是枯燥的,不要再给自己添加更多的烦恼. 今天,就为了方便这点,介绍下,如何解决在开发过程中,一些场景下,为了实现一个配置模块中,基于开关量或者选择配置项,实现不同功能,例如,在一个session共享模块当中,解决session是基于header传递还是基于cookie传递这两种应用场景,有些应用中希望基于header传递sessionId,但是有些应

Spring的学习（三、Spring中的AOP）

Spring AOP简介 1. 什么是AOP 官方:在面向对象编程(oop)思想中,我们将事物纵向抽成一个个对象,而在面向切面编程的时候,我们将一个个的对象某些类似的方面横向抽成一个切面,对这个切面进行一些如权限控制,事务管理,记录日志等公用操作处理的过程就是面向切面编程的思想,aop底层是动态代理,如果是接口采用jdk动态代理,如果是类采用cglib方式实现动态代理.利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率.

深入分析JavaWeb Item54 -- Spring中的AOP面向切面编程2

一.在Advice方法中获取目标方法的参数 1.获取目标方法的信息 访问目标方法最简单的做法是定义增强处理方法时,将第一个参数定义为JoinPoint类型,当该增强处理方法被调用时,该JoinPoint参数就代表了织入增强处理的连接点.JoinPoint里包含了如下几个常用的方法: Object[] getArgs:返回目标方法的参数 Signature getSignature:返回目标方法的签名 Object getTarget:返回被织入增强处理的目标对象 Object getThis:返

Spring学习之Aop的各种增强方法

AspectJ允许使用注解用于定义切面.切入点和增强处理,而Spring框架则可以识别并根据这些注解来生成AOP代理.Spring只是使用了和AspectJ 5一样的注解,但并没有使用AspectJ的编译器或者织入器,底层依然使用SpringAOP来实现,依然是在运行时动态生成AOP代理,因此不需要增加额外的编译,也不需要AspectJ的织入器支持.而AspectJ采用编译时增强,所以AspectJ需要使用自己的编译器来编译Java文件,还需要织入器. 为了启用Spring对@AspectJ切面

spring中的AOP 以及各种通知

理解了前面动态代理对象的原理之后,其实还是有很多不足之处,因为如果在项目中有20多个类,每个类有100多个方法都需要判断是不是要开事务,那么方法调用那里会相当麻烦. spring中的AOP很好地解决了这个问题,通过 execution表达式 指定哪些包中的那些类 哪些方法 用到事务 execution(public * *(..))  所有的公共方法 execution(* set*(..))  以set开头的任意方法 execution(* com.xyz.service.AccountSer

Spring详解（五）------AspectJ 实现AOP

上一篇博客我们引出了 AOP 的概念,以及 AOP 的具体实现方式.但是为什么要这样实现?以及提出的切入点表达式到底该怎么理解? 这篇博客我们通过对 AspectJ 框架的介绍来详细了解. 1.什么是 AspectJ? AspectJ是一个面向切面的框架,它扩展了Java语言.AspectJ定义了AOP语法,也可以说 AspectJ 是一个基于 Java 语言的 AOP 框架.通常我们在使用 Spring AOP 的时候,都会导入 AspectJ 的相关 jar 包. 在 spring2.0以后