當前位置：首頁 > 前端技术 > javascript >内容正文

javascript

Spring AOP学习

發布時間：2025/6/15 javascript 15 豆豆

生活随笔收集整理的這篇文章主要介紹了 Spring AOP学习小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

什么是AOP

?Spring AOP 面向切面編程，采取橫向抽取機制，取代了傳統縱向繼承體系重復性代碼（性能監視、事務管理、安全檢查、緩存）

?使用純Java實現，不需要專門的編譯過程和類加載器，在運行期通過JDK動態代理或者CGLIB動態代理的方式向目標類織入增強代碼

?AspectJ ?[??spekt]?是一個基于Java語言的AOP框架，擴展了Java語言，提供了一個專門的編譯器，在編譯時提供橫向代碼的織入。

在決定使用哪種框架實現你的項目之前，有幾個要點（同樣適用于其他框架）。https://www.oschina.net/translate/comparative_analysis_between_spring_aop_and_aspectj

明確你在應用橫切關注點(cross-cutting concern)時（例如事物管理、日志或性能評估），需要處理的是Spring beans還是POJO。

如果正在開發新的應用，則選擇Spring AOP就沒有什么阻力。但是如果你正在維護一個現有的應用（該應用并沒有使用Spring框架），AspectJ就將是一個自然的選擇了。

為了詳細說明這一點，假如你正在使用Spring AOP，當你想將日志功能作為一個通知(advice)加入到你的應用中，用于追蹤程序流程，那么該通知(Advice)就只能應用在Spring beans的連接點(Joinpoint)之上。

另一個需要考慮的因素是，你是希望在編譯期間進行織入(weaving)，還是編譯后(post-compile)或是運行時(run-time)。Spring只支持運行時織入。如果你有多個團隊分別開發多個使用Spring編寫的模塊（導致生成多個jar文件，例如每個模塊一個jar文件），并且其中一個團隊想要在整個項目中的所有Spring bean（例如，包括已經被其他團隊打包了的jar文件）上應用日志通知（在這里日志只是用于加入橫切關注點的舉例），那么通過配置該團隊自己的Spring配置文件就可以輕松做到這一點。之所以可以這樣做，就是因為Spring使用的是運行時織入。如果你使用AspectJ想要做到同樣的事情，你也許就需要使用acj（AspectJ編譯器）重新編譯所有的代碼并且進行重新打包。否則，你也可以選擇使用AspectJ編譯后(post-compile)或載入時(load-time)織入。

Advisor和Aspect的區別：

Advisor：Spring傳統意義上的切面，支持一個切點和一個通知的組合

Aspect：支持多個切點和多個通知的組合，真實開發中常用。

為什么要用AOP

在傳統的面向對象編程時，難免有很多重復的代碼。我們可以把重復的代碼提出來，放到一個類中，然后統一使用，這樣將來修改起來也會很是方便。

AOP底層原理

就是代理機制:

* 動態代理:(JDK中使用)

* JDK的動態代理,對實現了接口的類生成代理.

Spring的AOP代理

JDK動態代理:對實現了接口的類生成代理。沒有實現接口的類，就無法生成代理對象了。

CGLib代理機制:對類生成代理

代理實例：

一個接口：

package com.js.demo10;public interface Greeting {void sayHello(String name); }

一個實現類：

package com.js.demo10;

public class GreetingImpl implements Greeting {@Overridepublic void sayHello(String name) {before();System.out.println("Hello! " + name);after();}private void before() {System.out.println("Before");}private void after() {System.out.println("After");} }

靜態代理實現實例：

由程序員創建或由特定工具自動生成源代碼，再對其編譯。在程序運行前，代理類的.class文件就已經存在了。

package com.js.demo10;

public class GreetingProxy implements Greeting {private GreetingImpl greetingImpl;public GreetingProxy(GreetingImpl greetingImpl) {this.greetingImpl = greetingImpl;}@Overridepublic void sayHello(String name) {before();greetingImpl.sayHello(name);after();}private void before() {System.out.println("Before");}private void after() {System.out.println("After");} }

客戶端來調用：

public class GreetingProxyClient {public static void main(String[] args) { Greeting greetingProxy = new GreetingProxy(new GreetingImpl());greetingProxy.sayHello("Jack");} }

問題：XxxProxy 這樣的類會越來越多，如何才能將這些代理類盡可能減少呢？最好只有一個代理類。

如果項目中有多個類，則需要編寫多個代理類，工作量大，不好修改，不好維護，不能應對變化。

JDK動態代理實現實例：

?JDK內置的Proxy動態代理可以在運行時動態生成字節碼，而沒必要針對每個類編寫代理類。

package com.js.demo10;import java.lang.reflect.Method;import org.springframework.cglib.proxy.InvocationHandler; import org.springframework.cglib.proxy.Proxy;public class JDKDynamicProxy implements InvocationHandler {private Object target;public JDKDynamicProxy(Object target) {this.target = target;}@SuppressWarnings("unchecked")public <T> T getProxy() {return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {before();Object result = method.invoke(target, args);after();return result;}private void before() {System.out.println("Before");}private void after() {System.out.println("After");} }

客戶端來調用：

public class JDKDynamicProxyClient {public static void main(String[] args) {Greeting greeting = new JDKDynamicProxy(new GreetingImpl()).getProxy();greeting.sayHello("Jack");} }

問題：JDK 給我們提供的動態代理只能代理接口，而不能代理沒有接口的類。

CGLIB動態代理實現實例：

CGLIB(Code Generation Library)是一個開源項目,是一個強大的，高性能，高質量的Code生成類庫，它可以在運行期擴展Java類與實現Java接口，通俗說cglib可以在運行時動態生成字節碼。

大概的原理是：使用cglib可以實現動態代理，即使被代理的類沒有實現接口，但被代理的類必須不是final類。cglib繼承被代理的類，重寫方法，織入通知，動態生成字節碼并運行，因為是繼承所以final類是沒有辦法動態代理的。

package com.js.demo10;import java.lang.reflect.Method;import org.springframework.cglib.proxy.Enhancer; import org.springframework.cglib.proxy.MethodInterceptor; import org.springframework.cglib.proxy.MethodProxy;public class CGLibDynamicProxy implements MethodInterceptor {private static CGLibDynamicProxy instance = new CGLibDynamicProxy();private CGLibDynamicProxy() {}public static CGLibDynamicProxy getInstance() {return instance;}@SuppressWarnings("unchecked")public <T> T getProxy(Class<T> cls) {return (T) Enhancer.create(cls, this);}@Overridepublic Object intercept(Object target, Method method, Object[] args, MethodProxy proxy) throws Throwable {before();Object result = proxy.invokeSuper(target, args);after();return result;}private void before() {System.out.println("Before");}private void after() {System.out.println("After");} }

客戶端來調用：

public class CGLibDynamicProxyClient {public static void main(String[] args) { Greeting greeting = CGLibDynamicProxy.getInstance().getProxy(GreetingImpl.class);//?Singleton 模式greeting.sayHello("Jack");} }

結論：Spring框架,如果類實現了接口,就使用JDK的動態代理生成代理對象,如果這個類沒有實現任何接口,使用CGLIB生成代理對象.

如果項目中有些類沒有實現接口，則不應該為了實現動態代理而刻意去抽出一些沒有實例意義的接口，通過cglib可以解決該問題。

AOP的術語

Aspect(切面)：是切入點和通知（引介）的結合，橫切關注點被模塊化的特殊對象。即，它是一個類。

Advice(通知/增強)：所謂通知是指攔截到Joinpoint之后所要做的事情，即攔截邏輯.切面必須要完成的工作。即，它是類中的一個方法。

通知分為前置通知,后置通知,異常通知,最終通知,環繞通知

Target(目標對象)：代理的目標對象

Proxy（代理）：一個類被AOP織入增強后，就產生一個結果代理類

Joinpoint(連接點)：所謂連接點是指那些被攔截到的點。在spring中,這些點指的是方法,因為spring只支持方法類型的連接點.

Pointcut(切入點)：所謂切入點是指我們要對哪些Joinpoint連接點進行攔截的定義，簡單理解如正則表達式.

Weaving(織入)：是指把增強應用到目標對象來創建新的代理對象的過程.

Introduction(引介)：引介是一種特殊的通知在不修改類代碼的前提下, Introduction可以在運行期為類動態地添加一些屬性或方法.

spring采用動態代理織入，而AspectJ采用編譯期織入和類裝在期織入

Spring按照通知Advice在目標方法的連接點位置，通知Advice可分為五類（可以分編程式和聲明式實現）

前置通知：org.springframework.aop.MethodBeforeAdvice，在目標方法執行之前實施增強

后置通知：org.springframework.aop.AfterReturningAdvice，在目標方法執行之后實施增強

環繞通知：org.aopalliance.intercept.MethodInterceptor，在目標方法執行前后實施增強

異常拋出通知：org.springframework.aop.ThrowsAdvice，在方法拋出異常之后實施增強

引介通知：org.springframework.aop.IntroductionInterceptor，在目標類中添加一些新的方法和屬性

Spring中切面的類型：

Advisor：Spring中的傳統切面。

Aspect：都是有一個切點和一個通知的組合

Advisor：多個切點和多個通知的組合

Advisor?:?代表一般切面，Advice本身就是一個切面，對目標類所有方法進行攔截（*不帶有切點的切面）

PointcutAdvisor?:?代表具有切點的切面，可以指定攔截目標類哪些方法帶有切點的切面，針對某個方法進行攔截

?IntroductionAdvisor?:?代表引介切面，針對引介通知而使用切面（不要求掌握）

不帶有切點的切面

不帶切點的切面實例

導入相應的jar包：Spring開發基礎包、spring-aop-4.3.7.RELEASE.jar、aopalliance-1.0.jar（AOP聯盟包）

編寫一個接口Customer：

package com.js.aopStu;public interface CustomerDao {public void add();public void delete();public void update();public void find(); }

編寫實現類CustomerImpl：

package com.js.aopStu;public class CustomerImpl implements CustomerDao {@Overridepublic void add() { System.out.println("添加客戶...");}@Overridepublic void delete() { System.out.println("刪除客戶...");}@Overridepublic void update() { System.out.println("修改客戶...");}@Overridepublic void find() {System.out.println("查詢客戶...");}}

編寫增強的代碼。新建一個類MyBeforeAdvice，以前置增強為例

package com.js.aopStu;import java.lang.reflect.Method;import org.springframework.aop.MethodBeforeAdvice;/*** 前置增強* 實現指定接口* @author hdb**/ public class MyBeforeAdvice implements MethodBeforeAdvice{/*** method：執行的方法* args：參數* target：目標對象*/@Overridepublic void before(Method method, Object[] args, Object target) throws Throwable {System.out.println("前置增強...");}}

配置代理生成代理類，基于ProxyFactoryBean類，底層自動選擇使用JDK的動態代理還是CGLIB的代理。

配置applicationContext.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:context="http://www.springframework.org/schema/context" xmlns:util="http://www.springframework.org/schema/util" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd"> <bean id="customerDao" class="com.js.aopStu.CustomerImpl"></bean>  <bean id="beforeAdice" class="com.js.aopStu.MyBeforeAdvice"></bean><bean id="customerDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean"><property name="target" ref="customerDao"></property><property name="proxyInterfaces" value="com.js.aopStu.CustomerDao"></property><property name="interceptorNames" value="beforeAdice"></property></bean></beans>

我們需要配置一些屬性，不需要都設置。

lProxyFactoryBean常用可配置屬性 ?target : 代理的目標對象 ?proxyInterfaces : 代理要實現的接口 ?如果多個接口可以使用以下格式賦值

<list>

??? <value></value>

??? ....

</list>

?proxyTargetClass : 是否對類代理而不是接口，設置為true時，使用CGLib代理 ?interceptorNames : 需要織入目標的Advice ?singleton : 返回代理是否為單實例，默認為單例 ?optimize : 當設置為true時，強制使用CGLib （proxyInterfaces、proxyTargetClass二者互斥，不能同時存在）

編寫測試類：

package com.js.aopStu;import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:applicationContext.xml") public class TestAOPDemo1 {@Autowired@Qualifier("customerDaoProxy")private CustomerDao customerDao;//不使用增強的情況下 @Testpublic void Demo1(){customerDao.add();customerDao.delete();customerDao.find();customerDao.update();} }

帶有切點的切面（常用）

用PointcutAdvisor實現類，它有兩個接口： 1、DefaultPointcutAdvisor：最常用的切面類型，它可以通過任意Pointcut和Advice 組合定義切面 2、RegexpMethodPointcutAdvisor：構造正則表達式切點切面，一般使用這種。

帶有切點的切面實例

新建一個DAO，創建被代理對象：

package com.js.demo3; /*** 目標對象* @author hdb**/ public class OrderDao {public void add() { System.out.println("添加訂單...");}public void delete() { System.out.println("刪除訂單...");}public void update() { System.out.println("修改訂單...");}public void find() {System.out.println("查詢訂單...");} }

編寫增強類，這次使用環繞增強：

package com.js.demo3;import org.aopalliance.intercept.MethodInterceptor; import org.aopalliance.intercept.MethodInvocation;/*** 增強的類* 使用的是環繞增強* @author hbd**/ public class MyAroundAdvice implements MethodInterceptor{@Overridepublic Object invoke(MethodInvocation methodInvocation) throws Throwable {System.out.println("環繞前增強===");Object object=methodInvocation.proceed();//執行目標對象的方法System.out.println("環繞后增強===");return object;}}

生成代理：通過配置的方式：

<?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:context="http://www.springframework.org/schema/context"xmlns:util="http://www.springframework.org/schema/util"xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">  <bean id="orderDao1" class="com.js.demo3.OrderDao"></bean> <bean id="aroundAdvice" class="com.js.demo3.MyAroundAdvice"></bean> <bean id="myPointcutAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"><property name="patterns" value=".*add.*,.*find.*"></property><property name="advice" ref="aroundAdvice"/> </bean> <bean id="orderDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean"><property name="target" ref="orderDao1"></property><property name="proxyTargetClass" value="true"></property><property name="interceptorNames" value="myPointcutAdvisor"></property> </bean></beans>

編寫測試類：

package com.js.demo3;import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:applicationContext.xml") public class TestAOPDemo1 {
@Autowired@Qualifier("orderDaoProxy")private OrderDao orderDao;
@Testpublic void demo1(){orderDao.add();orderDao.delete();orderDao.find();orderDao.update();} }

自動代理

前面的案例中，每個代理都是通過ProxyFactoryBean織入切面代理，在實際開發中，非常多的Bean每個都配置ProxyFactoryBean開發維護量巨大。

自動創建代理(*****基于后處理Bean.在Bean創建的過程中完成的增強.生成Bean就是代理。)

（1）BeanNameAutoProxyCreator根據Bean名稱創建代理

（2）DefaultAdvisorAutoProxyCreator根據Advisor本身包含信息創建代理

*AnnotationAwareAspectJAutoProxyCreator 基于Bean中的AspectJ 注解進行自動代理

之前我們手動創建代理的時候，注意到一點，都是先創建被代理對象，然后在創建代理的時候，傳入該被代理對象。

而下面要學習的兩種自動代理，是基于后處理bean，在類創建的過程中完成增強，生成的bean，就是代理！

基于Bean名稱的自動代理

先清理配置文件中其他部分，留下最簡潔的四個bean配置：

<?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:context="http://www.springframework.org/schema/context"xmlns:util="http://www.springframework.org/schema/util"xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd"> <bean id="orderDao2" class="com.helloAOP.autoProxy.OrderDao"></bean> <bean id="customerDao2" class="com.helloAOP.autoProxy.CustomerImpl"></bean>  <bean id="aroundAdvice2" class="com.helloAOP.autoProxy.MyAroundAdvice"></bean> <bean id="beforeAdvice2" class="com.helloAOP.autoProxy.MyBeforeAdvice"></bean>
 <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"><property name="beanNames" value="*Dao2"/><property name="interceptorNames" value="beforeAdvice2"/> </beans>

編寫測試類：

package com.helloAOP.autoProxy;import org.junit.Test; import org.springframework.context.support.ClassPathXmlApplicationContext;public class TestAutoProxyByName {@Testpublic void testDemo(){ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");OrderDao orderDao = (OrderDao)applicationContext.getBean("orderDao2");orderDao.add();orderDao.update();orderDao.delete();orderDao.find();applicationContext.close();} }

運行測試：

基于AspectJ注解信息的自動代理

先清理配置文件中其他部分，留下最簡潔的四個bean配置：

<?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:context="http://www.springframework.org/schema/context"xmlns:util="http://www.springframework.org/schema/util"xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd"> <bean id="orderDao3" class="com.helloAOP.autoProxy.OrderDao"></bean> <bean id="customerDao3" class="com.helloAOP.autoProxy.CustomerImpl"></bean>  <bean id="aroundAdvice3" class="com.helloAOP.autoProxy.MyAroundAdvice"></bean> <bean id="beforeAdvice3" class="com.helloAOP.autoProxy.MyBeforeAdvice"></bean>  <bean id="myPointcutAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"><property name="pattern" value=".*add.*"></property><property name="advice" ref="aroundAdvice3"></property></bean>  <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"></bean> </beans>

編寫測試類：

package com.helloAOP.autoProxy;import org.junit.Test; import org.springframework.context.support.ClassPathXmlApplicationContext;public class TestAutoProxyByAspectJ {@Testpublic void testDemo(){ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");OrderDao orderDao = (OrderDao)applicationContext.getBean("orderDao3");orderDao.add();orderDao.delete();applicationContext.close();}}

運行測試：

AspectJ方面

AspectJ [??spekt] 是一個基于Java語言的AOP框架 Spring2.0以后新增了對AspectJ切點表達式支持 @AspectJ是AspectJ1.5新增功能，通過JDK5注解技術，允許直接在Bean類中定義切面 新版本Spring框架，建議使用AspectJ方式來開發AOP 通過配置啟用@AspectJ切面： <?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:context="http://www.springframework.org/schema/context"xmlns:util="http://www.springframework.org/schema/util"xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">  <aop:aspectj-autoproxy/>

AspectJ表達式:

語法:execution(表達式)

execution(<訪問修飾符>?<返回類型><方法名>(<參數>)<異常>)

execution(“* cn.itcast.spring3.demo1.dao.*(..)”)?????? ---只檢索當前包

execution(“* cn.itcast.spring3.demo1.dao..*(..)”)????? ---檢索包及當前包的子包.

execution(* cn.itcast.dao.GenericDAO+.*(..))?????????? ---檢索GenericDAO及子類

AspectJ增強:

@Before 前置通知，相當于BeforeAdvice

@AfterReturning 后置通知，相當于AfterReturningAdvice

@Around 環繞通知，相當于MethodInterceptor

@AfterThrowing 拋出通知，相當于ThrowAdvice

@After 最終final通知，不管是否異常，該通知都會執行

@DeclareParents 引介通知，相當于IntroductionInterceptor (不要求掌握)

下面詳細介紹詳細的使用方法（基于注解、基于XML），并做舉例說明。

基于AspectJ的注解開發

第一步：引入相應jar包

使用AspectJ需要導入SpringAOP和AspectJ相關jar包：

1、spring-aop-3.2.7.RELEASE.jar

2、aopalliance-1.0.jar

3、spring-aspects-3.2.7.RELEASE.jar

4、aspectj.weaver-1.6.8.jar

第二步：編寫被增強的類，即目標類

package com.js.demo8; /*** 目標類* @author hdb**/ public class UserDao {public void add(){System.out.println("add...");}public int update(){System.out.println("update...");return 1;}public void delete(){System.out.println("delete...");}public void find(){System.out.println("find...");int d=1/0; } }

第三步：編寫切面類，即切點和增強的結合

package com.js.demo8;import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.AfterReturning; import org.aspectj.lang.annotation.AfterThrowing; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.aspectj.lang.annotation.Pointcut;/*** 切面類：就是切點與增強的結合* @Aspect：用于定義切面* @Before：用于定義xx增強,只使用其value屬性時，value可以省略，其值為表達式* 表示你想對哪些類進行增強，可精確到某包、某類、某方法，控制靈活* @author hdb**/@Aspect public class MyAspect {@Before(value="execution(* com.js.demo8.UserDao.add(..))")public void before(){System.out.println("前置增強===");}@AfterReturning(value="execution(* com.js.demo8.UserDao.update(..))")public void afterReturnin(){System.out.println("后置增強===");}@Around(value="execution(* com.js.demo8.UserDao.update(..))")public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{System.out.println("環繞前增強===");Object object=proceedingJoinPoint.proceed(); //調用目標方法System.out.println("環繞后增強===");return object;}@AfterThrowing(value="MyAspect.myPointcut()",throwing="e")public void afterThrowing(Throwable e){System.out.println("不好了，出異常了==="+e.getMessage());}@After(value="MyAspect.myPointcut()")public void after(){System.out.println("最終通知===");}@Pointcut("execution(* com.js.demo1.UserDao.find(..))")private void myPointcut(){}}

關于切點的注解，切點是我們的增強最重要應用的方法。為什么要定義一個切點呢？因為我們上述開發中，很多通知的value表達式都是重復的，在實際開發中，每寫一個通知，就要去寫一個表達式，很繁瑣。所以我們可以采用定義切點的方式來解決。例如上面的定義一個myPointcut切點，可以重復調用：

@Pointcut("execution(* com.js.demo1.UserDao.find(..))")private void myPointcut(){}

第四步：在applicationContext.xml中引入約束，配置bean，并開啟自動代理

第五步：編寫測試類

package com.js.demo8;/*** 測試類*/ import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:applicationContext.xml") public class TestAspectDemo {@Autowired@Qualifier("userDao")private UserDao userDao; @Testpublic void demo1(){userDao.add();userDao.delete();userDao.find();userDao.update();} }

第六步：運行測試，查看結果。

基于AspectJ的XML配置方式開發

第一步：引入相應jar包

使用AspectJ需要導入SpringAOP和AspectJ相關jar包：

1、spring-aop-3.2.7.RELEASE.jar

2、aopalliance-1.0.jar

3、spring-aspects-3.2.7.RELEASE.jar

4、aspectj.weaver-1.6.8.jar

第二步：編寫被增強的類，即目標類

package com.js.demo9;public class ProductDao {public void add(){System.out.println("add...");}public void update(){System.out.println("update...");}public void delete(){System.out.println("delete...");
　　　　 int a = 1/0;}public String find(){System.out.println("find...");return "find Success!";} }

第三步：編寫切面類，即切點和增強的結合

package com.js.demo9;import org.aspectj.lang.ProceedingJoinPoint;/*** 切面類* @author hdb**/ public class MyAspectXML {public void before(){System.out.println("前置通知===");}public void after(Object returnVal){System.out.println("后置通知===返回值："+returnVal);}public Object around(ProceedingJoinPoint point) throws Throwable{System.out.println("環繞前通知===");Object object = point.proceed();System.out.println("環繞后通知===");return object;}public void afterthrowing(Throwable e){System.out.println("糟糕，出錯了===錯誤信息："+e.getMessage());}public void afterFinal(){System.out.println("最終通知===");} }

?第四步：在applicationContext.xml中引入約束，配置bean，并開啟自動代理

<?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:context="http://www.springframework.org/schema/context"xmlns:util="http://www.springframework.org/schema/util"xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <bean id="productDao" class="com.js.demo9.ProductDao"> </bean>  <bean id="myAspectXML" class="com.js.demo9.MyAspectXML"></bean>  <aop:config>  <aop:pointcut expression="execution(* com.js.demo9.ProductDao.add(..))" id="myPointcut"/> <aop:pointcut expression="execution(* com.js.demo9.ProductDao.find(..))" id="myAfter"/> <aop:pointcut expression="execution(* com.js.demo9.ProductDao.update(..))" id="myAround"/>
<aop:pointcut expression="execution(* com.js.demo9.ProductDao.delete(..))" id="myafterthrowing"/> <aop:aspect ref="myAspectXML">

<aop:before method="before" pointcut-ref="myPointcut"/>

<aop:after-returning method="after" pointcut-ref="myAfter" returning="returnVal"/>

<aop:around method="around" pointcut-ref="myAround"/>

<aop:after-throwing method="afterthrowing" pointcut-ref="myAfter" throwing="e"/><aop:after method="afterFinal" pointcut-ref="myAfter"/> </aop:aspect> </aop:config></beans>

第五步：編寫測試類

package com.js.demo9;import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:applicationContext.xml") public class TestAspectXML {@Autowired@Qualifier("productDao")private ProductDao productDao;@Testpublic void demo(){productDao.add();productDao.find();productDao.update();productDao.delete();} }

第六步：運行測試，查看結果。

?參考鏈接：https://blog.csdn.net/dove_knowledge/article/category/6818451

　　　　　https://my.oschina.net/pingpangkuangmo/blog/517340

　　　　? ??https://my.oschina.net/huangyong/blog/161338

? ? ? ? ? ? ? ? ??https://www.cnblogs.com/best/p/5736422.html

轉載于:https://www.cnblogs.com/huangdabing/p/9484349.html

總結

以上是生活随笔為你收集整理的Spring AOP学习的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

AOP
Spring