2. 程式人生 > 實用技巧 >Spring(3)：AOP面向切面程式設計

Spring(3)：AOP面向切面程式設計

阿新 • • 發佈：2020-07-20

一，AOP介紹

AOP為Aspect Oriented Programming的縮寫，意為：面向切面程式設計，通過預編譯方式和執行期動態代理實現程式功能的統一維護的一種技術。AOP是OOP的延續，是軟體開發中的一個熱點，也是Spring框架中的一個重要內容，是函數語言程式設計的一種衍生範型。利用AOP可以對業務邏輯的各個部分進行隔離，從而使得業務邏輯各部分之間的耦合度降低，提高程式的可重用性，同時提高了開發的效率

1，主要功能

日誌記錄，效能統計，安全控制，事務處理，異常處理等等

2，主要意圖

將日誌記錄，效能統計，安全控制，事務處理，異常處理等程式碼從業務邏輯程式碼中劃分出來，通過對這些行為的分離，我們希望可以將它們獨立到非指導業務邏輯的方法中，進而改變這些行為的時候不影響業務邏輯的程式碼

3，AOP在Spring中的作用

提供宣告式事務；允許使用者自定義切面
橫切關注點：跨越應用程式多個模組的方法或功能。即是，與我們業務邏輯無關的，但是我們需要關注的部分，就是橫切關注點。如日誌 , 安全 , 快取 , 事務等等 ....

切面（ASPECT） 橫切關注點 被模組化 的特殊物件，即，它是一個類
通知（Advice） 切面必須要完成的工作。即，它是類中的一個方法
目標（Target） 被通知物件
代理（Proxy） 向目標物件應用通知之後建立的物件
切入點（PointCut） 切面通知 執行的 “地點”的定義
連線點（JointPoint） 與切入點匹配的執行點





二，使用SpringAPI實現AOP

1，介面(User)

1 //抽象角色
2 public interface User {
3 
4 public void show();
5 
6 }

2，實現類(UserImpl)

1 //真實角色
2 public class UserImpl implements User{
3 
4 public void show() {
5 System.out.println("這是一個show方法");
6 }
7 
8 }

3，定義日誌增加類實現

1.Log

 1 import org.springframework.aop.MethodBeforeAdvice;

 
 2 import java.lang.reflect.Method;
 3 
 4 public class Log implements MethodBeforeAdvice {
 5 
 6 //method:被呼叫目標物件的方法
 7 //args：要被呼叫的方法的引數
 8 //target：被呼叫的目標物件
 9 public void before(Method method, Object[] args, Object target) throws Throwable {
10 System.out.println("目標物件："+target.getClass().getName()+"的"
11 +method.getName()+"方法被執行了");
12 }
13 }

2.AfterLog

 1 import org.springframework.aop.AfterReturningAdvice;
 2 import java.lang.reflect.Method;
 3 
 4 public class AfterLog implements AfterReturningAdvice {
 5 
 6 //returnValue ： 返回值
 7 //method : 被呼叫目標物件的方法
 8 //args ： 要被呼叫的方法的引數
 9 //target : 被呼叫的目標物件
10 
11 public void afterReturning(Object returnValue, Method method, 
12 Object[] args, Object target) throws Throwable {
13 System.out.println("執行了目標物件:"+target.getClass().getName()+"的"
14 +method.getName()+"方法，返回值："+returnValue);
15 }
16 
17 }

4，編寫Spring核心配置檔案(logbeans.xml)

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4 xmlns:aop="http://www.springframework.org/schema/aop"
 5 xsi:schemaLocation="http://www.springframework.org/schema/beans
 6 http://www.springframework.org/schema/beans/spring-beans.xsd
 7 http://www.springframework.org/schema/aop
 8 http://www.springframework.org/schema/aop/spring-aop.xsd">
 9 
10 <!--註冊bean-->
11 <bean id="User" class="service.UserImpl"/>
12 
13 <!--註冊日誌的bean-->
14 <bean id="Log" class="log.Log"/>
15 <bean id="AfterLog" class="log.AfterLog"/>
16 
17 <!--使用spring的AOP切入-->
18 <aop:config>
19 <!--切入點-->
20 <aop:pointcut id="pointcut" expression="execution(* service.UserImpl.*(..))"/>
21 <!--執行通知,增強-->
22 <aop:advisor advice-ref="Log" pointcut-ref="pointcut"/>
23 <aop:advisor advice-ref="AfterLog" pointcut-ref="pointcut"/>
24 </aop:config>
25 
26 </beans>

【注意點】

5，編寫測試類(AopTest)

 1 public class AopTest {
 2 @Test
 3 public void Test01(){
 4 ClassPathXmlApplicationContext context = 
 5 new ClassPathXmlApplicationContext("logbeans.xml");
 6 User user = (User) context.getBean("User");
 7 
 8 user.show();
 9 }
10 }

【注意點：測試時需要匯入AOP的包在你的pom.xml中】

1 <dependency>
2 <groupId>org.aspectj</groupId>
3 <artifactId>aspectjweaver</artifactId>
4 <version>1.8.9</version>
5 </dependency>

6，執行結果

三，自定義類實現AOP

和使用SpringAPI實現AOP一樣，先要建立抽象角色和真實角色，我們這裡的介面與實體類和前面一樣

1，自定一個Aop增強類：也就是所謂的切面

 1 public class Diy {
 2 
 3 public void before(){
 4 System.out.println("show方法執行前");
 5 }
 6 
 7 public void after(){
 8 System.out.println("show方法執行後");
 9 }
10 }

2，配置檔案(diybeans.xml)

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xmlns:aop="http://www.springframework.org/schema/aop"
 5        xsi:schemaLocation="http://www.springframework.org/schema/beans
 6         http://www.springframework.org/schema/beans/spring-beans.xsd
 7         http://www.springframework.org/schema/aop
 8         http://www.springframework.org/schema/aop/spring-aop.xsd">
 9 
10     <!--註冊bean-->
11     <bean id="User" class="service.UserImpl"/>
12 
13     <!--自定義的AOP增強類-->
14     <bean id="Diy" class="diy.Diy"/>
15 
16     <!--編寫aop配置檔案-->
17     <aop:config>
18         
19         <!--切面-->
20         <aop:aspect ref="Diy">
21             <!--切入點-->
22         <aop:pointcut id="diyPointCut" expression="execution(* service.UserImpl.*(..))"/>
23             <aop:before method="before" pointcut-ref="diyPointCut"/>
24             <aop:after method="after" pointcut-ref="diyPointCut"/>
25         </aop:aspect>
26         
27     </aop:config>
28 
29 </beans>

3，測試類

 1 public class AopTest {
 2 @Test
 3 public void Test02(){
 4 ClassPathXmlApplicationContext context = 
 5 new ClassPathXmlApplicationContext("diybeans.xml");
 6 User user = (User) context.getBean("User");
 7 
 8 user.show();
 9 }
10 }

4，執行結果

四，使用註解實現AOP

介面和實體類不變

1，編寫AOP增強類

 1 @Aspect
 2 public class Anno {
 3 
 4 @Before("execution(* service.UserImpl.*(..))")
 5 public void before(){
 6 System.out.println("show方法執行前");
 7 }
 8 
 9 @After("execution(* service.UserImpl.*(..))")
10 public void after(){
11 System.out.println("show方法執行後");
12 }
13 
14 }

【注意點】


2，配置檔案(annobeans.xml)

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4 xmlns:aop="http://www.springframework.org/schema/aop"
 5 xsi:schemaLocation="http://www.springframework.org/schema/beans
 6 http://www.springframework.org/schema/beans/spring-beans.xsd
 7 http://www.springframework.org/schema/aop
 8 http://www.springframework.org/schema/aop/spring-aop.xsd">
 9 
10 <!--註冊bean-->
11 <bean id="User" class="service.UserImpl"/>
12 
13 <!--註冊日誌的bean-->
14 <bean id="Log" class="log.Log"/>
15 <bean id="AfterLog" class="log.AfterLog"/>
16 
17 <!--使用spring的AOP切入-->
18 <aop:config>
19 <!--切入點-->
20 <aop:pointcut id="pointcut" expression="execution(* service.UserImpl.*(..))"/>
21 <!--執行通知,增強-->
22 <aop:advisor advice-ref="Log" pointcut-ref="pointcut"/>
23 <aop:advisor advice-ref="AfterLog" pointcut-ref="pointcut"/>
24 </aop:config>
25 
26 </beans>

3，測試類

 1 public class AopTest {
 2 @Test
 3 public void Test03(){
 4 ClassPathXmlApplicationContext context = 
 5 new ClassPathXmlApplicationContext("annobeans.xml");
 6 User user = (User) context.getBean("User");
 7 
 8 user.show();
 9 }
10 }

4，執行結果

五，AOP小結

  • 本質就是動態代理
  • 需要到一個包,用來進行aop織入的包: aspectjweaver
  • 注意別遺漏了切面
  • 三種實現AOP的方法
  • 使用SpringAPI來實現AOP
  • 使用自定義類來實現AOP
  • 使用註解實現AOP

相關推薦

Spring(3)：AOP面向切面程式設計

一，AOP介紹 AOP為Aspect Oriented Programming的縮寫，意為：面向切面程式設計，通過預編譯方式和執行期動態代理實現程式功能的統一維護的一種技術。AOP是OOP的延續，是軟體開發中的一個熱點，也是Spring框架中的一

3、AOP面向切面程式設計

學習資源：動力節點的2020最新Spring框架教程【IDEA版】-Spring框架從入門到精通

spring學習總結013 --- AOP面向切面程式設計

AOP能夠在應用程式指定位置、指定時機，植入指定功能，並且不影響原程式的功能；

Spring AOP面向切面程式設計實現原理方法詳解

1. 什麼是AOP AOP (Aspect Oriented Programming)意為：面向切面程式設計，通過預編譯方式和執行期動態代理實現在不修改原始碼的情況下，給程式動態統一新增功能的一種技術，可以理解成動態代理。是Spring框架中的一

Spring-11-AOP面向切面程式設計

11.AOP 11.1 什麼是AOP？ AOP，意為面向切面程式設計，通過預編譯和執行時動態代理實現程式功能的統一維護的一種技術。

Spring AOP面向切面程式設計實現及配置詳解

動態代理 特點 位元組碼隨用隨建立，隨用隨載入 作用 不用修改原始碼對方法增強

4-1-2 Spring基礎-Spring AOP面向切面程式設計

什麼是Spring AOP Aspect Oriented Programming 面向切面程式設計 AOP的做法是將通用,與業務無關的功能抽象封裝為切面類

Spring AOP面向切面程式設計

一、AOP面向切面程式設計基本概念 在軟體系統中，有些行為對於絕大多數業務模組都是通用，例如日誌管理、許可權管理、事物管理等，在不同的業務模組中，我們很有可能會編寫相同的程式碼來完成一個共同的功能點，這就

Spring--->aop面向切面程式設計

AOP程式設計 1. AOP概念 AOP (Aspect Oriented Programing) 面向切面程式設計 = Spring動態代理開發

Spring--AOP面向切面程式設計，Java資料結構面試題及答案

專案結構： 在pom.xml中匯入相關依賴： <dependency> <groupId>org.springframework</groupId>

Spring框架（四）AOP面向切面程式設計

一.前言     在以前的專案中，很少去關注spring aop的具體實現與理論，只是簡單瞭解了一下什麼是aop具體怎麼用，看到了一篇博文寫得還不錯，就轉載來學習一下，博文地址：http://www.cnblogs.com/xrq730/p/4919025

spring——AOP面向切面程式設計——代理講解

Spring AOP 是 Spring 框架的核心模組之一，它使用純 Java 實現，因此不需要專門的編譯過程和類載入器，可以在程式執行期通過代理方式向目標類織入增強程式碼。

spring——AOP面向切面程式設計—— 一般切面的 AOP 開發

一般切面的 AOP 開發 當我們在使用 Spring AOP 開發時，若沒有對切面進行具體定義，Spring AOP 會通過 Advisor 為我們定義一個一般切面（不帶切點的切面），然後對目標物件（Target）中的所有方法連線點進行攔截，並

spring——AOP面向切面程式設計—— 基於 PointcutAdvisor 的 AOP 開發

專案依賴： <?xml version=\"1.0\" encoding=\"UTF-8\"?> <project xmlns=\"http://maven.apache.org/POM/4.0.0\"

spring——AOP面向切面程式設計——基於註解的AspectJ AOP開發（轉載）

在 Spring 中，雖然我們可以使用 XML 配置檔案可以實現 AOP 開發，但如果所有的配置都集中在 XML 配置檔案中，就勢必會造成 XML 配置檔案過於臃腫，從而給維護和升級帶來一定困難。為此，AspectJ 框架為 AOP 開發提供

spring——AOP面向切面程式設計——基於XML的AspectJ AOP開發（轉載）

我們可以在 Spring 專案中通過 XML 配置，對切面（Aspect 或 Advisor）、切點（PointCut）以及通知（Advice）進行定義和管理，以實現基於 AspectJ 的 AOP 開發。Spring 提供了基於 XML 的 AOP 支援，並提供了一個名為

SpringBoot整合aop面向切面程式設計過程解析

這篇文章主要介紹了SpringBoot整合aop面向切面程式設計過程解析,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

基於SpringBoot AOP面向切面程式設計實現Redis分散式鎖

基於SpringBoot AOP面向切面程式設計實現Redis分散式鎖 基於SpringBoot AOP面向切面程式設計實現Redis分散式鎖

AOP面向切面程式設計

目錄一、AOP概述1. AOP簡介2. 如何理解AOP二、AOP程式設計術語1. 切面(Aspect)2. 連線點(JoinPoint)3. 切入點(Pointcut)4. 目標物件(Target)5. 通知(Advice)三、Aspectj對AOP的實現1. Aspectj的通知型別2. Aspectj的

AOP面向切面程式設計（一）

本章將主要簡單介紹下AOP面向切面程式設計。首先我們先來看些概念。 POP面向過程程式設計：符合邏輯思維，線性的處理問題-----無法應付複雜的系統。