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+" \t 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