Spring AOP詳解

AOP

AOP（Aspect Oriented Programming），即面向切面程式設計，它利用一種稱為"橫切"的技術，剖解開封裝的對象内部，并将那些影響了多個類的公共行為封裝到一個可重用子產品，并将其命名為"Aspect"，即切面。所謂"切面"，簡單說就是那些與業務無關，卻為業務子產品所共同調用的邏輯或責任封裝起來，便于減少系統的重複代碼，降低子產品之間的耦合度，并有利于未來的可操作性和可維護性。

使用"橫切"技術，AOP把軟體系統分為兩個部分：核心關注點和橫切關注點。業務處理的主要流程是核心關注點，與之關系不大的部分是橫切關注點。橫切關注點的一個特點是，他們經常發生在核心關注點的多處，而各處基本相似，比如權限認證、日志、事物。AOP的作用在于分離系統中的各種關注點，将核心關注點和橫切關注點分離開來。

AOP核心概念

1、橫切關注點

對哪些方法進行攔截，攔截後怎麼處理，這些關注點稱之為橫切關注點

2、切面（aspect）

類是對物體特征的抽象，切面就是對橫切關注點的抽象

3、連接配接點（joinpoint）

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

4、切入點（pointcut）

對連接配接點進行攔截的定義

5、通知（advice）

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

6、目标對象

代理的目标對象

7、織入（weave）

将切面應用到目标對象并導緻代理對象建立的過程

8、引入（introduction）

在不修改代碼的前提下，引入可以在運作期為類動态地添加一些方法或字段

Spring對AOP的支援

Spring中AOP代理由Spring的IOC容器負責生成、管理，其依賴關系也由IOC容器負責管理。是以，AOP代理可以直接使用容器中的其它bean執行個體作為目标，這種關系可由IOC容器的依賴注入提供。Spring建立代理的規則為：

1、預設使用Java動态代理來建立AOP代理，這樣就可以為任何接口執行個體建立代理了

2、當需要代理的類是接口的時候，spring aop 将預設通過jdk 動态代理來實作代理類,當需要代理的類是繼承的方式則spring aop 将通過cglib 來實作代理類

AOP程式設計其實是很簡單的事情，縱觀AOP程式設計，程式員隻需要參與三個部分：

1、定義普通業務元件

2、定義切入點，一個切入點可能橫切多個業務元件

3、定義增強處理，增強處理就是在AOP架構為普通業務元件織入的處理動作

是以進行AOP程式設計的關鍵就是定義切入點和定義增強處理，一旦定義了合适的切入點和增強處理，AOP架構将自動生成AOP代理，即：代理對象的方法=增強處理+被代理對象的方法。

下面給出一個Spring AOP的.xml檔案模闆，名字叫做aop.xml，之後的内容都在aop.xml上進行擴充：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">        
</beans>

基于Spring的AOP簡單實作

注意一下，在講解之前，說明一點：使用Spring AOP，要成功運作起代碼，隻用Spring提供給開發者的jar包是不夠的，請額外上網下載下傳兩個jar包：

1、aopalliance.jar

2、aspectjweaver.jar

3、asm.jar

4、cglib.jar 。

開始講解用Spring AOP的XML實作方式，先定義一個接口：

public interface HelloWorld{ 
void printHelloWorld(); 
void doPrint();
}

定義兩個接口實作類：

public class HelloWorldImpl1 implements HelloWorld{ 
public void printHelloWorld()
    {
        System.out.println("Enter HelloWorldImpl1.printHelloWorld()");
    }

 public void doPrint()
    {
        System.out.println("Enter HelloWorldImpl1.doPrint()"); return ;
    }
}

public class HelloWorldImpl2 implements HelloWorld{
 public void printHelloWorld()
    {
        System.out.println("Enter HelloWorldImpl2.printHelloWorld()");
    } public void doPrint()
    {
        System.out.println("Enter HelloWorldImpl2.doPrint()");
 return ;
    }
}

橫切關注點，這裡是列印時間：

public class TimeHandler
{ public void printTime()
    {
        System.out.println("CurrentTime = " + System.currentTimeMillis());
    }
}

有這三個類就可以實作一個簡單的Spring AOP了，看一下aop.xml的配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">

        <bean id="helloWorldImpl1" class="com.xrq.aop.HelloWorldImpl1" />
        <bean id="helloWorldImpl2" class="com.xrq.aop.HelloWorldImpl2" />
        <bean id="timeHandler" class="com.xrq.aop.TimeHandler" />

        <aop:config>
            <aop:aspect id="time" ref="timeHandler">
                <aop:pointcut id="addAllMethod" expression="execution(* com.xrq.aop.HelloWorld.*(..))" />
                <aop:before method="printTime" pointcut-ref="addAllMethod" />
                <aop:after method="printTime" pointcut-ref="addAllMethod" />
            </aop:aspect>
        </aop:config>
</beans>

寫一個main函數調用一下：

public static void main(String[] args)
{
    ApplicationContext ctx = 
            new ClassPathXmlApplicationContext("aop.xml");

    HelloWorld hw1 = (HelloWorld)ctx.getBean("helloWorldImpl1");
    HelloWorld hw2 = (HelloWorld)ctx.getBean("helloWorldImpl2");
    hw1.printHelloWorld();
    System.out.println();
    hw1.doPrint();

    System.out.println();
    hw2.printHelloWorld();
    System.out.println();
    hw2.doPrint();
}

運作結果為：

CurrentTime = 1446129611993 Enter HelloWorldImpl1.printHelloWorld()

CurrentTime = 1446129611993 CurrentTime = 1446129611994 Enter HelloWorldImpl1.doPrint()

CurrentTime = 1446129611994 CurrentTime = 1446129611994 Enter HelloWorldImpl2.printHelloWorld()

CurrentTime = 1446129611994 CurrentTime = 1446129611994 Enter HelloWorldImpl2.doPrint()

CurrentTime = 1446129611994</pre>

看到給HelloWorld接口的兩個實作類的所有方法都加上了代理，代理内容就是列印時間

基于Spring的AOP使用其他細節

1、增加一個橫切關注點，列印日志，Java類為：

public class LogHandler{
 public void LogBefore()
    {
        System.out.println("Log before method");
    } public void LogAfter()
    {
        System.out.println("Log after method");
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">

        <bean id="helloWorldImpl1" class="com.xrq.aop.HelloWorldImpl1" />
        <bean id="helloWorldImpl2" class="com.xrq.aop.HelloWorldImpl2" />
        <bean id="timeHandler" class="com.xrq.aop.TimeHandler" />
        <bean id="logHandler" class="com.xrq.aop.LogHandler" />

        <aop:config>
            <aop:aspect id="time" ref="timeHandler" order="1">
                <aop:pointcut id="addTime" expression="execution(* com.xrq.aop.HelloWorld.*(..))" />
                <aop:before method="printTime" pointcut-ref="addTime" />
                <aop:after method="printTime" pointcut-ref="addTime" />
            </aop:aspect>
            <aop:aspect id="log" ref="logHandler" order="2">
                <aop:pointcut id="printLog" expression="execution(* com.xrq.aop.HelloWorld.*(..))" />
                <aop:before method="LogBefore" pointcut-ref="printLog" />
                <aop:after method="LogAfter" pointcut-ref="printLog" />
            </aop:aspect>
        </aop:config>
</beans>

測試類不變，列印結果為：

CurrentTime = 1446130273734

Log before method

Enter HelloWorldImpl1.printHelloWorld()

Log after method

CurrentTime = 1446130273735

========================

CurrentTime = 1446130273736

Enter HelloWorldImpl1.doPrint()

======================

Enter HelloWorldImpl2.printHelloWorld()

=========================

CurrentTime = 1446130273737

Enter HelloWorldImpl2.doPrint()

CurrentTime = 1446130273737</pre>

要想讓logHandler在timeHandler前使用有兩個辦法：

（1）aspect裡面有一個order屬性，order屬性的數字就是橫切關注點的順序

（2）把logHandler定義在timeHandler前面，Spring預設以aspect的定義順序作為織入順序

2、我隻想織入接口中的某些方法

修改一下pointcut的expression就好了：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">

        <bean id="helloWorldImpl1" class="com.xrq.aop.HelloWorldImpl1" />
        <bean id="helloWorldImpl2" class="com.xrq.aop.HelloWorldImpl2" />
        <bean id="timeHandler" class="com.xrq.aop.TimeHandler" />
        <bean id="logHandler" class="com.xrq.aop.LogHandler" />

        <aop:config>
            <aop:aspect id="time" ref="timeHandler" order="1">
                <aop:pointcut id="addTime" expression="execution(* com.xrq.aop.HelloWorld.print*(..))" />
                <aop:before method="printTime" pointcut-ref="addTime" />
                <aop:after method="printTime" pointcut-ref="addTime" />
            </aop:aspect>
            <aop:aspect id="log" ref="logHandler" order="2">
                <aop:pointcut id="printLog" expression="execution(* com.xrq.aop.HelloWorld.do*(..))" />
                <aop:before method="LogBefore" pointcut-ref="printLog" />
                <aop:after method="LogAfter" pointcut-ref="printLog" />
            </aop:aspect>
        </aop:config>
</beans>

表示timeHandler隻會織入HelloWorld接口print開頭的方法，logHandler隻會織入HelloWorld接口do開頭的方法

3、強制使用CGLIB生成代理

前面說過Spring使用動态代理或是CGLIB生成代理是有規則的，高版本的Spring會自動選擇是使用動态代理還是CGLIB生成代理内容，當然我們也可以強制使用CGLIB生成代理，那就是<aop:config>裡面有一個"proxy-target-class"屬性，這個屬性值如果被設定為true，那麼基于類的代理将起作用，如果proxy-target-class被設定為false或者這個屬性被省略，那麼基于接口的代理将起作用

使用注解方式實作AOP

/**
 * 業務類
 */
@Component
public class Business {
}

b、切面類：

@Aspect : 标記為切面類

@Pointcut : 指定比對切點

@Before : 指定前置通知，value中指定切入點比對

@AfterReturning ：後置通知，具有可以指定傳回值

@AfterThrowing ：異常通知

/**
 * 定義切面
 */
@Component
@Aspect
public class AspectAdvice {

    /**
     * 指定切入點比對表達式，注意它是以方法的形式進行聲明的。
     */
    @Pointcut("execution(* aop.annotation.*.*(..))")
    public void anyMethod() {
    }

    /**
     * 前置通知
     */
    @Before(value = "execution(* aop.annotation.*.*(..))")
    public void doBefore() {
        System.out.println("===========進入before advice============ \n");
    }

    /**
     * 後置通知
     */
    @AfterReturning(value = "anyMethod()", returning = "result")
    public void doAfter() {
        System.out.println("==========進入after advice========");
  
    }

    /**
     * 環繞通知
     */
    @Around(value = "execution(* aop.annotation.*.*(..))")
    public void doAround() throws Throwable {
        System.out.println("===========進入around環繞方法");

    }

    /**
     * 異常通知
     */
    @AfterThrowing(value = "execution(* aop.annotation.*.*(..))", throwing = "e")
    public void doThrow() {
        System.out.println("=====================");
    }

}

c、配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="     
          http://www.springframework.org/schema/beans     
          http://www.springframework.org/schema/beans/spring-beans-3.0.xsd     
          http://www.springframework.org/schema/context     
          http://www.springframework.org/schema/context/spring-context-3.0.xsd 
          http://www.springframework.org/schema/aop     
          http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"
    default-autowire="byName">

    <context:component-scan base-package="aop.annotation" />
    <!-- 打開aop 注解 -->
    <aop:aspect-autoproxy />
</beans>

Spring AOP詳解

使用注解方式實作AOP

繼續閱讀

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

面試題解析：你接口測試是怎麼做的？

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method