Spring中的AOP 专题

Caused by: java.lang.IllegalArgumentException: ProceedingJoinPoint is only supported for around advice
    at org.springframework.aop.aspectj.AbstractAspectJAdvice.maybeBindProceedingJoinPoint(AbstractAspectJAdvice.java:405)
    at org.springframework.aop.aspectj.AbstractAspectJAdvice.calculateArgumentBindings(AbstractAspectJAdvice.java:377)
    at org.springframework.aop.aspectj.annotation.ReflectiveAspectJAdvisorFactory.getAdvice(ReflectiveAspectJAdvisorFactory.java:277)
    at org.springframework.aop.aspectj.annotation.InstantiationModelAwarePointcutAdvisorImpl.instantiateAdvice(InstantiationModelAwarePointcutAdvisorImpl.java:160)
    at org.springframework.aop.aspectj.annotation.InstantiationModelAwarePointcutAdvisorImpl.<init>(InstantiationModelAwarePointcutAdvisorImpl.java:106)
    at org.springframework.aop.aspectj.annotation.ReflectiveAspectJAdvisorFactory.getAdvisor(ReflectiveAspectJAdvisorFactory.java:186)
    at org.springframework.aop.aspectj.annotation.ReflectiveAspectJAdvisorFactory.getAdvisors(ReflectiveAspectJAdvisorFactory.java:111)
    at org.springframework.aop.aspectj.annotation.BeanFactoryAspectJAdvisorsBuilder.buildAspectJAdvisors(BeanFactoryAspectJAdvisorsBuilder.java:109)
    at org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator.findCandidateAdvisors(AnnotationAwareAspectJAutoProxyCreator.java:87)
    at org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator.shouldSkip(AspectJAwareAdvisorAutoProxyCreator.java:103)
    at org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator.postProcessBeforeInstantiation(AbstractAutoProxyCreator.java:249)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsBeforeInstantiation(AbstractAutowireCapableBeanFactory.java:988)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.resolveBeforeInstantiation(AbstractAutowireCapableBeanFactory.java:959)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:472)

切面执行顺序
一个方法只被一个Aspect类拦截
正常：
@Around是在最外层，@AfterReturning/@AfterThrowing是在最外层。
@After一定在@Around后面执行

异常：

同一个方法被多个Aspect类拦截
优先级高的切面类里的增强处理的优先级总是比优先级低的切面类中的增强处理的优先级高。
在“进入”连接点时，最高优先级的增强处理将先被织入（eg.给定的两个不同切面类Before增强处理中，优先级高的那个会先执行）；在“退出”连接点时，最高优先级的增强处理会最后被织入（eg.给定的两个不同切面类After增强处理中，优先级高的那个会后执行）。eg.优先级为1的切面类Bean1包含了@Before，优先级为2的切面类Bean2包含了@Around，虽然@Around优先级高于@Before，但由于Bean1的优先级高于Bean2的优先级，因此Bean1中的@Before先被织入。
Spring提供了如下两种解决方案指定不同切面类里的增强处理的优先级：

让切面类实现org.springframework.core.Ordered接口：实现该接口的int getOrder()方法，该方法返回值越小，优先级越高
直接使用@Order注解来修饰一个切面类：使用这个注解时可以配置一个int类型的value属性，该属性值越小，优先级越高
同一个切面类里的两个相同类型的增强处理在同一个连接点被织入时，Spring AOP将以随机的顺序来织入这两个增强处理，没有办法指定它们的织入顺序。即使给这两个 advice 添加了 @Order 这个注解，也不行！

https://my.oschina.net/u/3434392/blog/1625493

摘要: 本文介绍使用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.自定义注解

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

2.业务逻辑和接口

1.接口

public interface UserManagerApplogic {  
    public void addUser(String name);  
    public void addOne(int type,int parentid);  
}

2.接口实现

package com.jay.demo3.aop1.impl;  
  
import org.springframework.stereotype.Component;  
  
import com.jay.demo3.aop1.UserManagerApplogic;  
import com.jay.demo3.aop1.myannotation.BussAnnotation;  
//用户管理业务逻辑实现类     
@Component("userManager")  
public class UserManagerApplogicImpl implements UserManagerApplogic {  
  
    @BussAnnotation(moduleName="人员管理",option="添加用户")  
    @Override  
    public void addUser(String name) {  
        System.out.println("add a User name is "+name);  
    }  
  
    @BussAnnotation(moduleName="人员管理",option="添加新人")  
    @Override  
    public void addOne(int type, int parentid) {  
        System.out.println("add a new one type : "+type+" 	 perentid : "+parentid);  
    }  
  
}

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

package com.jay.demo3.aop1.interceptor;  
  
  
import java.lang.reflect.Method;  
  
  
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.stereotype.Component;  
  
  
import com.jay.demo3.aop1.myannotation.BussAnnotation;  
  
  
//切面类  http://my.oschina.net/yangzg/blog/343945  
/* 
 * 特别注意： Spring的配置文件中添加：   
 *  
 * <aop:aspectj-autoproxy /> 
 * spring-mvc-dispatcher.xml中天机 
 * <!--通知spring使用cglib而不是jdk的来生成代理方法 AOP可以拦截到Controller-->   
 * <aop:aspectj-autoproxy proxy-target-class="true"/> 
 * 
 * <aop:config>节点中proxy-target-class="true"不为true时。 
 * 当登录的时候会报这个异常java.lang.NoSuchMethodException: $Proxy54.login()， 
 */  
  
  
@Aspect  
@Component  
public class LogInterceptor {  
  
  
    // 定义切入点  @Pointcut("execution(public * com.jay..*.*(..))")  -- 表示对com.jay 包下的所有方法都可添加切入点  
    @Pointcut("execution(public * com.jay..*.addUser(..))")  
    public void aApplogic() {  
    }  
      
    //定义切入点  -- 拦截指定的方法  这里拦截 com.jay.demo3.aop1.impl.UserManagerApplogicImpl 的addOne()方法  
    @Pointcut("execution(public * com.jay..*.addOne(..))")  
    public void joinPointForAddOne(){  
          
    }  
      
    /** 
     * 环绕通知 用于拦截指定内容，记录用户的操作 
     */  
    @Around(value = "aApplogic() && @annotation(annotation) &&args(object,..) ", argNames = "annotation,object")  
    public Object interceptorApplogic(ProceedingJoinPoint pj,  
            BussAnnotation annotation, Object object) throws Throwable {  
        System.out.println("moduleName:" + annotation.moduleName());  
        System.out.println("option:" + annotation.option());  
        pj.proceed();  
        System.out.println(pj.getSignature().getName());  
        for(Object obj : pj.getArgs()){  
            System.out.println(obj.toString());  
        }  
        return object;  
    }  
      
    /** 
     * 环绕通知   拦截指定的切点，这里拦截joinPointForAddOne切入点所指定的addOne()方法 
     *  
     */  
    @Around("joinPointForAddOne()")  
    public Object interceptorAddOne(ProceedingJoinPoint joinPoint) throws Throwable {  
        System.out.println("Aop start");  
        String methodRemark = getMthodRemark(joinPoint);  
        Object result = null;  
        try {    
            // 记录操作日志...谁..在什么时间..做了什么事情..    
            result = joinPoint.proceed();    
        } catch (Exception e) {    
            // 异常处理记录日志..log.error(e);    
            throw e;    
        }    
        System.out.println(methodRemark);  
        System.out.println("Aop end");  
        return result;  
    }  
  
  
     // 获取方法的中文备注____用于记录用户的操作日志描述    
    public static String getMthodRemark(ProceedingJoinPoint joinPoint)    
            throws Exception {    
        String targetName = joinPoint.getTarget().getClass().getName();    
        String methodName = joinPoint.getSignature().getName();    
        System. out.println("====调用" +methodName+"方法-开始！");  
        Object[] arguments = joinPoint.getArgs();   //获得参数列表  
        System.out.println("打印出方法调用时传入的参数，可以在这里通过添加参数的类型，进行一些简易逻辑处理和判断");  
        if(arguments.length<=0){  
            System.out.println("=== "+methodName+" 方法没有参数");  
        }else{  
        for(int i=0;i<arguments.length;i++){  
            System.out.println("==== 参数   "+(i+1)+" : "+arguments[i]);  
        }  
        }  
    
        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) {    
                    BussAnnotation methodCache = m.getAnnotation(BussAnnotation.class);    
                    methode = methodCache.moduleName();    
                    break;    
                }    
            }    
        }    
        return methode;    
    }    
}

4.测试类：

package com.jay.demo3.aop1.test;  
  
import org.junit.Test;  
import org.junit.runner.RunWith;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.test.context.ContextConfiguration;  
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
  
import com.jay.demo3.aop1.UserManagerApplogic;  
  
@RunWith(SpringJUnit4ClassRunner.class)  
@ContextConfiguration(locations = "classpath:*.xml")  
public class AopTest1 {  
    @Autowired  
    private UserManagerApplogic userManager;  
      
    @Test  
    public void testAopAddUser(){  
        userManager.addUser("You you ");  
    }  
  
    @Test  
    public void testAopAddOne(){  
        userManager.addOne(1, 1);  
    }  
      
}

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

<context:annotation-config/>    
<aop:aspectj-autoproxy />  
<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

Spring中的AOP 专题

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

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

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