Spring AOP 的實現方式（以日志管理為例）

一、AOP的概念

　　AOP(Aspect Oriented Programming)，是面向切面編程的技術。AOP基於IoC基礎，是對OOP的有益補充，流行的AOP框架有Sping AOP、AspectJ

　　AOP技術它利用一種稱為“橫切”的技術，剖解開封裝的對象內部，並將那些影響了多個類的公共行為封裝到一個可重用模塊，並將其命名為”Aspect”，即切面。所謂”切面”，簡單說就是那些與業務無關，卻為業務模塊所共同調用的邏輯或責任封裝起來，便於減少系統的重復代碼，降低模塊之間的耦合度，並有利於未來的可操作性和可維護性

                

二、相關概念：

1、切面（aspect）

散落在系統各處的通用的業務邏輯代碼，如上圖中的日志模塊，權限模塊，事務模塊等，切面用來裝載pointcut和advice

2、通知（advice）

所謂通知指的就是指攔截到連接點之后要執行的代碼，通知分為前置、后置、異常、最終、環繞通知五類

3、連接點（joinpoint）

被攔截到的點，因為Spring只支持方法類型的連接點，所以在Spring中連接點指的就是被攔截到的方法，實際上連接點還可以是字段或者構造器

4、切入點（pointcut）

攔截的方法，連接點攔截后變成切入點

6、目標對象（Target Object）

代理的目標對象，指要織入的對象模塊，如上圖的模塊一、二、三

7、織入（weave）

通過切入點切入，將切面應用到目標對象並導致代理對象創建的過程

8、AOP代理（AOP Proxy）

AOP框架創建的對象，包含通知。在Spring中，AOP代理可以是JDK動態代理或CGLIB代理

 

三、五種類型的通知

1. Before advice：在某連接點（JoinPoint）之前執行的通知，但這個通知不能阻止連接點前的執行。
   < aop:before>

2. After advice：當某連接點退出的時候執行的通知（不論是正常返回還是異常退出）。
   < aop:after>

3. After returnadvice：在某連接點正常完成后執行的通知，不包括拋出異常的情況。
   < aop:after-returning>

4. Around advice：包圍一個連接點的通知，類似Web中Servlet規范中的Filter的doFilter方法。可以在方法執行的前后實現邏輯，也可以選擇不執行方法
   < aop:around>

5. Afterthrowing advice：在方法拋出異常退出時執行的通知。
   < aop:after-throwing>

四、Spring AOP的3種實現方式

配置之前注意配置文件要加上命名空間：xmlns:aop="http://www.springframework.org/schema/aop"

1.基於xml配置的實現

spring-mvc.xml

<!-- 使用xml配置aop -->  
<!-- 強制使用cglib代理，如果不設置，將默認使用jdk的代理，但是jdk的代理是基於接口的 -->  
<aop:config proxy-target-class="true" />    
<aop:config>  
<!--定義切面-->  
    <aop:aspect id="logAspect" ref="logInterceptor">  
    <!-- 定義切入點 (配置在com.gray.user.controller下所有的類在調用之前都會被攔截)-->  
    <aop:pointcut expression="execution(* com.gray.user.controller.*.*(..))" id="logPointCut"/>  
    <!--方法執行之前被調用執行的-->  
    <aop:before method="before" pointcut-ref="logPointCut"/><!--一個切入點的引用-->  
    <aop:after method="after" pointcut-ref="logPointCut"/><!--一個切入點的引用-->  
    </aop:aspect>  
</aop:config> 

LogInterceptor.java

    package com.gray.interceptor;  
      
    import org.springframework.stereotype.Component;  
    import org.slf4j.Logger;  
    import org.slf4j.LoggerFactory;  
      
    @Component  
    public class LogInterceptor {  
        private final Logger logger = LoggerFactory.getLogger(LogInterceptor.class);  
        public void before(){  
            logger.info("login start!");  
        }  
          
        public void after(){  
            logger.info("login end!");  
        }  
    }  

在這里我沒有配bean是因為我在之前的配置文件里面寫了自動掃描組件的配置了

 

要加入日志管理邏輯的地方

@RequestMapping("/dologin.do") //url  
public String dologin(User user, Model model){  
    logger.info("login ....");  
    String info = loginUser(user);  
    if (!"SUCC".equals(info)) {  
        model.addAttribute("failMsg", "用戶不存在或密碼錯誤！");  
        return "/jsp/fail";  
    }else{  
        model.addAttribute("successMsg", "登陸成功！");//返回到頁面說夾帶的參數  
        model.addAttribute("name", user.getUsername());  
        return "/jsp/success";//返回的頁面  
    }  
  }

結果截圖：

 

2.基於注解的實現

spring-mvc.xml

<aop:aspectj-autoproxy proxy-target-class="true">  
</aop:aspectj-autoproxy> 

LogInterceptor.java

@Aspect  
@Component  
public class LogInterceptor {  
    private final Logger logger = LoggerFactory.getLogger(LogInterceptor.class);  
    @Before(value = "execution(* com.gray.user.controller.*.*(..))")  
    public void before(){  
        logger.info("login start!");  
    }  
    @After(value = "execution(* com.gray.user.controller.*.*(..))")  
    public void after(){  
        logger.info("login end!");  
    }  
} 

要加入邏輯的地方同上。

 結果截圖：

 

3.基於自定義注解的實現

基於注解，所以spring-mvc.xml也是和上面的一樣的。

LogInterceptor.java（這里我只加入前置日志）

 

    package com.gray.interceptor;  
      
    import java.lang.reflect.Method;  
      
    import org.aspectj.lang.JoinPoint;  
    import org.aspectj.lang.annotation.Aspect;  
    import org.aspectj.lang.annotation.Before;  
    import org.aspectj.lang.annotation.Pointcut;  
    import org.aspectj.lang.reflect.MethodSignature;  
    import org.slf4j.Logger;  
    import org.slf4j.LoggerFactory;  
    import org.springframework.stereotype.Component;  
      
    import com.gray.annotation.Log;  
      
    @Aspect  
    @Component  
    public class LogInterceptor {  
        private final Logger logger = LoggerFactory.getLogger(LogInterceptor.class);  
      
        @Pointcut("@annotation(com.gray.annotation.Log)")      
        public void controllerAspect() {  
              
        }  
        @Before("controllerAspect()")  
        public void before(JoinPoint joinPoint){  
            logger.info(getOper(joinPoint));  
        }  
        private String getOper(JoinPoint joinPoint) {  
            MethodSignature methodName = (MethodSignature)joinPoint.getSignature();  
            Method method = methodName.getMethod();  
            return method.getAnnotation(Log.class).oper();  
        }  
    }  

同時，加入邏輯的地方需要加入Log注解

@RequestMapping("/dologin.do") //url  
@Log(oper="user login")  
public String dologin(User user, Model model){  
    logger.info("login ....");  
    String info = loginUser(user);  
    if (!"SUCC".equals(info)) {  
        model.addAttribute("failMsg", "用戶不存在或密碼錯誤！");  
        return "/jsp/fail";  
    }else{  
        model.addAttribute("successMsg", "登陸成功！");//返回到頁面說夾帶的參數  
        model.addAttribute("name", user.getUsername());  
        return "/jsp/success";//返回的頁面  
    }  
  }

結果截圖：

 

 

 五、基於Schema的Spring AOP實例

1、定義具體業務邏輯模塊（目標對象）

兩個業務邏輯模塊都是基於接口

TestAOPDaoImpl .java

public class TestAOPDaoImpl implements TestAOPDao{

    @Override
    public void addUser() {
        System.out.println("添加成功");
    }

}

TestAOPServiceImpl.java

public class TestAOPServiceImpl implements TestAOPService{

    @Autowired
    private TestAOPDao testAOPDao;

    @Override
    public void addUser() {
        testAOPDao.addUser();
    }

}

2、 定義切面（即實現通知邏輯）

JointPoint是連接點，aop創建代理后會返回一個連接點，然后在通知中可以通過該連接點實現我們的切面邏輯

日志切面

public class LogAdivice{

    public void myBeforeAdivice(JoinPoint joinPoint){
        String classname = joinPoint.getTarget().getClass().getSimpleName();
        String methodname = joinPoint.getSignature().getName();
        System.out.println(classname + " ——前置通知——" + methodname);
    }

    public void myAfterAdivice(JoinPoint joinPoint){
        String classname = joinPoint.getTarget().getClass().getSimpleName();
        String methodname = joinPoint.getSignature().getName();
        System.out.println(classname + " ——后置通知——" + methodname);
    }

    /**
     * 環繞通知將決定要不要執行連接點
     * @throws Throwable 
     */
    public void myAroundAdivice(ProceedingJoinPoint point) throws Throwable{
        System.out.println("環繞通知，執行代碼前");
        //選擇執行
        point.proceed();
        System.out.println("環繞通知，執行代碼后");
    }
}

時間切面：

public class TimeAdvice {

    public void timeBefore(){
        System.out.println("beforeTime = " + System.currentTimeMillis());
    }

    public void timeAfter(){
        System.out.println("afterTime = " + System.currentTimeMillis());
    }
}

在applicationContext中配置切面：

<context:annotation-config/>
    <bean id="testAOPDao" class="com.ssh.dao.impl.TestAOPDaoImpl"/>
    <bean id="testAOPService" class="com.ssh.service.impl.TestAOPServiceImpl"/>
    <bean id="logAdivice" class="com.ssh.adivice.LogAdivice"/>
    <bean id="timeAdvice" class="com.ssh.adivice.TimeAdvice"/>

    <aop:config>
       <!-- 配置一個切面 -->
       <aop:aspect id="logaop" ref="logAdivice" order="2">
           <!-- 定義切入點，表示對service的所有方法都進行攔截 -->
           <aop:pointcut expression="execution(* com.ssh.service.TestAOPService.*(..))" id="testpointcut"/>
           <!-- 定義前置通知 -->
           <aop:before method="myBeforeAdivice" pointcut-ref="testpointcut"/>
           <!-- 定義后置通知 -->
           <aop:after-returning method="myAfterAdivice" pointcut-ref="testpointcut"/>
           <!-- 定義環繞通知 -->
           <aop:around method="myAroundAdivice" pointcut-ref="testpointcut"/>
       </aop:aspect>

       <!-- 定義另一個切面 -->
       <aop:aspect id="timeaop" ref="timeAdvice" order="1">
           <!-- 定義切入點，表示對service的所有方法都進行攔截 -->
           <aop:pointcut expression="execution(* com.ssh.service.TestAOPService.*(..))" id="testpointcut"/>
           <!-- 定義前置通知 -->
           <aop:before method="timeBefore" pointcut-ref="testpointcut"/>
           <!-- 定義后置通知 -->
           <aop:after-returning method="timeAfter" pointcut-ref="testpointcut"/>
       </aop:aspect>
    </aop:config>

當有多個切面時，Spring默認是按照切面定義的順序來執行，也可以通過order屬性來配置切面的執行屬性，order=1 早於 order=2執行

測試結果

public class AOPTest {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        TestAOPService service = (TestAOPService) context.getBean("testAOPService");
        service.addUser();
    }

}

 

 六、基於@AspectJ注解的AOP實現

1、定義具體業務邏輯模塊（目標對象）-----同上

2、定義切面（即實現通知邏輯）

重點是定義切入點

 

@Aspect
public class LogAdivice{

    //定義一個方法作為切入點id
    @Pointcut("execution(* com.ssh.service.TestAOPService.*(..))")
    private void allMethod(){}

    @Before("allMethod()")
    public void myBeforeAdivice(JoinPoint joinPoint){
        String classname = joinPoint.getTarget().getClass().getSimpleName();
        String methodname = joinPoint.getSignature().getName();
        System.out.println(classname + " ——前置通知——" + methodname);
    }

    @AfterReturning("allMethod()")
    public void myAfterAdivice(JoinPoint joinPoint){
        String classname = joinPoint.getTarget().getClass().getSimpleName();
        String methodname = joinPoint.getSignature().getName();
        System.out.println(classname + " ——后置通知——" + methodname);
    }

    /**
     * 環繞通知將決定要不要執行連接點
     * @throws Throwable 
     */
    @Around("allMethod()")
    public void myAroundAdivice(ProceedingJoinPoint point) throws Throwable{
        System.out.println("環繞通知，執行代碼前");
        //執行
        point.proceed();
        System.out.println("環繞通知，執行代碼后");
    }
}

 

在applicationContext的配置：

<!-- 打開自動掃描(隱式打開注解管理器） -->
    <!-- <context:component-scan base-package="com.ssh"/> -->
    <context:annotation-config/>
    <bean id="testAOPDao" class="com.ssh.dao.impl.TestAOPDaoImpl"/>
    <bean id="testAOPService" class="com.ssh.service.impl.TestAOPServiceImpl"/>
    <bean id="logAdivice" class="com.ssh.adivice.LogAdivice"/>
    <bean id="timeAdvice" class="com.ssh.adivice.TimeAdvice"/>

    <!-- 打開aop注解管理器 -->
    <aop:aspectj-autoproxy/>

 

七、Java代碼使用AOP

public class TestControlFlowPointcut {

    public static void main(String[] args) {
        //只有TargetCaller中的方法才會被攔截
        ControlFlowPointcut pointcut = new ControlFlowPointcut(TargetCaller.class);
        BeforeAdvice beforeAdvice = new MethodBeforeAdvice() {
            public void before(Method method, Object[] objects, Object o) throws Throwable {
                System.out.println(method.getClass().getSimpleName() + ":" +
                        method.getName() + " - before logic ");
            }
        };

        // Spring 中的 Aspect，裝載pointcut和advice
        PointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, beforeAdvice);

        // Spring 基本織入器weaver
        ProxyFactory weaver = new ProxyFactory();
        weaver.setTarget(new TargetObject());   //指定代理目標對象
        weaver.addAdvisor(advisor);  //指定方面

        Object proxy = weaver.getProxy();

        //直接調用Targetobject的方法不會被攔截
        ((TargetObject)proxy).targetMethod();

        //使用ControlFlowPointcut指定的類中的方法才會被攔截
        TargetCaller caller = new TargetCaller();
        caller.setTarget((TargetObject)proxy);
        caller.callMethod();
    }
}