2. 程式人生 > >aop詳解和基於spring-aop xml的簡單程式設計

aop詳解和基於spring-aop xml的簡單程式設計

阿新 • • 發佈：2019-01-07

文章目錄


AOP（Aspect Oriented Programming），即面向切面程式設計，可以說是OOP（Object Oriented Programming，面向物件程式設計）的補充和完善。 OOP引入封裝、繼承、多型等概念來建立一種物件層次結構，用於模擬公共行為的一個集合。

不過OOP允許開發者定義縱向的關係，但並不適合定義橫向的關係，例如日誌功能。日誌程式碼往往橫向地散步在所有物件層次中，而與它對應的物件的核心功能毫無關係對於其他型別的程式碼，如安全性、異常處理和透明的持續性也都是如此，這種散步在各處的無關程式碼被稱為橫切（cross cutting），在OOP設計中，它導致了大量程式碼的重複，而不利於各個模組的重用。

AOP技術恰恰相反，它利用一種稱為“橫切”的技術，剖解開封裝的物件內部，並將那些影響了多個類的公共行為封裝到一個可重用的模組，並將其命名為“Aspect”，即切面。

所謂“切面”，簡單說就是那些與業務無關，卻為業務模組所共同呼叫的邏輯或責任封裝起來，便於減少系統的重複程式碼，降低模組之間的耦合度，並有利於未來的可操作性和可維護性。

使用“橫切”技術，AOP把軟體系統分為兩個部分：核心關注點 和 橫切關注點。業務處理的主要流程是核心關注點，與之關係不大的就是橫切關注點。

橫切關注點的一個特點是，他們經常發生在核心關注點的多處，而各處基本相似，比如許可權認證、日誌、事務。AOP的作用在於分離系統中的各種關注點，將核心關注點和橫切關注點分離出來。

AOP核心概念

1、橫切關注點

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

2、切面(Aspect)

類是對物體特徵的抽象，切面就是對橫切關注點的抽象。 一個面向切面的模組，這個模組可以有多個切面。（字面意思，一個AOP的完成模組，它的出現就預示著AOP，就好比你看見Application能想到一個應用）。

3、連線點（joinpoint）

被攔截到的點，**因為Spring 只支援方法型別的連線點，所以在Spring中連線點指的就是被攔截到的方法。**實際上連線點還可以是欄位或者構造器。

4、切入點（pointcut）

對連線點進行攔截的定義。

5、通知（advice）

所以通知指的就是攔截到連線點之後要執行的程式碼，通知分為前置、後置、異常、最終、環繞通知五類。

6、目標物件（Target Object）

被一個或者多個切面所通知的物件，也被稱作被通知物件。通俗的理解就是被切入物件。

7、織入（weave）

將切面應用到目標物件並導致代理物件建立的過程。

8、引入（introduction）

在不修改程式碼的前提下，可以在執行期為類動態的新增一些方法或欄位。

Spring對AOP的支援

Spring中AOP代理由Spring的IOC容器負責生成、管理，其依賴關係也由IOC容器負責管理。
因此，AOP代理可以直接使用容器中其他bean例項作為目標，這種關係可由IOC容器的依賴注入提供。
Spring 建立代理的規則為：
1、預設使用java中的JDK動態代理來建立AOP代理，這樣就可以為任何介面例項建立代理了。
2、當需要代理的類不是代理介面的時候，Spring會切換為使用CGLB代理，也可強制使用CGLB代理。

基於Spring的xml的aop程式設計

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

1)定義普通業務元件
2）定義切入點，一個切入點可能橫切多個元件
3)定義增強處理，增強處理就是在AOP框架為普通業務元件織入的處理動作。

所以進行AOP程式設計的關鍵就是定義切入點和定義增強處理，一旦定義了合適的切入點和增強處理，AOP框架將自動生成AOP代理，即 代理物件的方法 = 增強處理 + 被代理物件方法。

一、基於Spring的AOP簡單實現

1、定義一個介面

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

2、定義兩個介面實現類：

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

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

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

4、有這三個類就可以實現一個簡單的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>

5、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();
}

6、執行結果為：

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

看到給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");
    }
}

2、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" />
        <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>

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

CurrentTime = 1446130273734
Log before method
Enter HelloWorldImpl1.printHelloWorld()
Log after method
CurrentTime = 1446130273735

CurrentTime = 1446130273736
Log before method
Enter HelloWorldImpl1.doPrint()
Log after method
CurrentTime = 1446130273736

CurrentTime = 1446130273736
Log before method
Enter HelloWorldImpl2.printHelloWorld()
Log after method
CurrentTime = 1446130273736

CurrentTime = 1446130273737
Log before method
Enter HelloWorldImpl2.doPrint()
Log after method
CurrentTime = 1446130273737

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

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

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

三、我只想織入介面中的某些方法

修改一下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開頭的方法.

強制使用CGLIB生成代理

前面說過Spring使用動態代理或是CGLIB生成代理是有規則的，高版本的Spring會自動選擇是使用動態代理還是CGLIB生成代理內容。

當然我們也可以強制使用CGLIB生成代理，那就是aop:config裡面有一個"proxy-target-class"屬性，這個屬性值如果被設定為true，那麼基於類的代理將起作用，如果proxy-target-class被設定為false或者這個屬性被省略，那麼基於介面的代理將起作用。

相關推薦

aop詳解和基於spring-aop xml的簡單程式設計

文章目錄 AOP核心概念 1、橫切關注點 2、切面(Aspect) 3、連線點（joinpoint） 4、切入點（pointcut） 5、通知（advice） 6、

Spring框架 之IOC容器 和AOP詳解

href set delet manage 進程 reads spa actor https 主要分析點： 一、Spring開源框架的簡介 二、Spring下IOC容器和DI(依賴註入Dependency injection) 三、Spring下面向切面編程(AOP)和事

Spring AOP詳解

開發 blank 關註 proxy 系統 frame main函數 lns 功能 一.前言 在以前的項目中，很少去關註spring aop的具體實現與理論，只是簡單了解了一下什麽是aop具體怎麽用，看到了一篇博文寫得還不錯，就轉載來學習一下，博文地址：htt

Spring詳解（五）------AOP

利用 未來 bject ted r.java -c cti throw 位置 　　這章我們接著講 Spring 的核心概念---AOP，這也是 Spring 框架中最為核心的一個概念。 　　PS：本篇博客源碼下載鏈接：http://pan.baidu.com/s/1skZ

【轉載】Spring AOP詳解 、 JDK動態代理、CGLib動態代理

rto 工廠 第一個 lec 僅支持 sel clas sleep gpo 原文地址：https://www.cnblogs.com/kukudelaomao/p/5897893.html AOP是Aspect Oriented Programing的簡稱，面向切面

Spring框架Aop詳解

urn 項目 aop mil execution 有一個 dal 例如 cati 一.前言 在以前的項目中，很少去關註spring aop的具體實現與理論，只是簡單了解了一下什麽是aop具體怎麽用，看到了一篇博文寫得還不錯，就轉載來學習一下，博文地址：http://

Spring Aop 詳解

RR 透明 IT obj owin target 面向切面編程 阻止 責任 一、AOP 簡介 AOP（Aspect Oriented Programming），即面向切面編程，可以說是OOP（Object Oriented Programming，面向對象編程）的補充和完

Spring 使用介紹（六）—— AOP詳解

表示 att 通配符 except cat execution 詳解 有一個 字符 一、切入點語法 1）通配符 AOP支持的通配符： *：匹配任何數量字符 ..：匹配任何數量字符的重復，在類型模式中匹配任何數量子包，在方法參數模式中匹配任何數量參數 +：匹配指定類型的子類型

Spring boot中使用aop詳解

array () bind intercept 通知 不同的 單獨使用 run arr 版權聲明：本文為博主武偉峰原創文章，轉載請註明地址http://blog.csdn.net/tianyaleixiaowu。 aop是spring的兩大功能模塊之一，功

Spring全家桶系列–SpringBoot之AOP詳解

//本文作者：cuifuan //本文將收錄到選單欄：《Spring全家桶》專欄中 面向方面程式設計（AOP）通過提供另一種思考程式結構的方式來補充面向物件程式設計（OOP）。 OOP中模組化的關鍵單元是類，而在AOP中，模組化單元是方面。 準備工作 首先，使用AOP要在bu

轉：Spring AOP詳解

一.前言 博文地址：http://www.cnblogs.com/xrq730/p/4919025.html AOP AOP（Aspect Oriented Programming），即面向切面程式設計，可以說是OOP（Object Oriented Programming，面向物件

Spring Aop底層原理詳解（利用spring後置處理器實現AOP）

寫在前面：對於一個java程式設計師來說，相信絕大多數都有這樣的面試經歷，面試官問：你知道什麼是aop嗎？談談你是怎麼理解aop的？等等諸如此類關於aop的問題。當然對於一些小白可能會一臉懵逼；對於一些工作一兩年的，可能知道，哦！aop就是面向切面變成，列印日誌啊，什麼什麼的，要是有點學

logback的使用和logback.xml詳解，在Spring專案中使用log列印日誌

一、logback的介紹 　　Logback是由log4j創始人設計的另一個開源日誌元件,官方網站： http://logback.qos.ch。它當前分為下面下個模組：　　logback-core：其它兩個模組的基礎模組　　logback-classic：它是log4j的一個改良版本，同時它完整實現了sl

Spring 詳解（一）------- AOP

1. AOP 簡介 ​ AOP（Aspect Oriented Programming），通常稱為面向切面程式設計。它利用一種稱為"橫切"的技術，剖解開封裝的物件內部，並將那些影響了多個類的公共行為封裝到一個可重用模組，並將其命名為"Aspect"，即切面。所謂"切面"，簡單說就是那些與業務無關，卻為業務模

Spring 詳解（二）------- AOP關鍵概念以及兩種實現方式

目錄 1. AOP 關鍵詞 2. AOP 的作用 3. AOP 的通知型別 4. 基於 xml 的配置方式 5. 基於註解的配置方式 6. 切面的優先順序 7. 重用切點表示式 8. 兩種方式的比較（摘自 spring 官方文件） 1. AOP 關鍵詞

基於spring註解方式配置和使用spring AOP

spring AOP，面向切面程式設計，通常應用於系統的日誌，事物資訊輸出部分，如下圖中所示，當A呼叫B的f2方法時，如果我們想要讓系統在f2呼叫前輸出一些呼叫前的資訊，在f2呼叫結束後輸出一些呼叫結束後的資訊，一般的想法就是在呼叫f2前去呼叫C的f3，然後在呼

基於Spring AOP和Groovy日誌模板配置的日誌記錄框架的二次實現與使用案例

一、專案地址 說明：本框架是基於koala-project（專案地址：http://git.oschina.net/openkoala/koala）中的koala-businesslog二次開發，因為koala-project已經很久沒有維護，對於一些

Spring 詳解（二）------- AOP概念以及兩種實現方式

　　target：目標類，需要被代理的類。例如：ArithmeticCalculator 　　 　　Joinpoint(連線點)：所謂連線點是指那些可能被攔截到的方法。例如：所有的方法 　　 　　PointCut 切入點：已經被增強的連線點。例如：add() 　　 　　advice：通知/增強，增強

Spring AOP詳解面向切面程式設計

       Spring中的AOP代理還是離不開Spring的IOC容器，代理的生成，管理及其依賴關係都是由IOC容器負責，Spring預設使用JDK動態代理，在需要代理類而不是代理介面的時候，Spring會自動切換為使用CGLIB代理，不過現在的專案都是面向介面程式設計

Spring學習筆記（四）：Spring AOP詳解

一.前言 二、什麼是 AOP？ AOP（Aspect Oriented Programming），即面向切面程式設計，可以說是OOP（Object Oriented Programming，面向物件程式設計）的補充和完善。OOP引入封裝、繼承、多型等概念來建立一種