spring-aop筆記

阿新 • • 發佈：2020-08-08

2、Spring-AOP

2.1、代理【Proxy】

動態代理：
- 特點：位元組碼誰用誰建立，誰用誰載入
- 作用：不修改原始碼的基礎上對方法增強
- 分類：
  - 基於介面的動態代理
  - 基於子類的動態代理
- 基於介面的動態代理
  - 涉及的類：Proxy
  - 提供者：JDK官方
- 如何建立代理物件:
  - 使用Proxy類中的newProxyInstance方法
- 建立代理物件的要求:
  - 被代理類最少實現一個介面,如果沒有則不能使用
- newProxyInstance方法的引數:
  - ClassLoader：類載入器
    - 它是用於載入代理物件位元組碼的.和被代理物件使用相同的類載入器。固定寫法。
  - Class[]
    - 它是用於讓代理物件和被代理物件有相同方法。固定寫法。
  - InvocationHandler
    - 它是讓我們寫如何代理。我們一般都是寫一個該介面的實現類，通常情況下都是匿名內部類，但不是必須的。
    - 此介面的實現類都是誰用誰寫

來測試一下：

2.1.1、未使用代理

1.定義一個介面，要被代理的介面：Producer【提供者】

//生產者
public interface Producer {
  //銷售
  public void saleProduct(float money);
  //售後
  public void afterService(float money);
 
}

2.定義一個類，ProducerImpl【提供者】（要被代理的角色）

//生產者
public class ProducerImpl implements Producer {
  //銷售
  public void saleProduct(float money){
    System.out.println("銷售產品，拿到錢：" + money);
   }
  //售後
  public void afterService(float money){
    System.out.println("售後服務，拿到錢：" + money);
   }
}

3.定義一個類，Client【消費者】（未使用代理，直接面向廠家）

//模擬一個消費者(未使用代理)
public class Client {
  public static void main(String[] args){
    IProducer producer = new Producer();
    producer.saleProduct(1000f);

   }
}

結果：

2.1.2、使用了代理

1.定義一個類，ProxyMan【代理人】（不收中介費的時候）

public class ProxyMan implements InvocationHandler {

  private Object target;

  public void setTarget(Object target) {
    this.target = target;
   }

  public Object getProxy(){
    return Proxy.newProxyInstance(this.getClass().getClassLoader() ,target.getClass().getInterfaces() ,this);
   }

  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    return method.invoke(target ,args);
   }
}

2.定義一個類，Client【消費者】（使用了代理）

//模擬一個消費者
public class Client {

  public static void main(String[] args){
    IProducer producer = new Producer();
//     producer.saleProduct(1000f);
    //代理模式
    ProxyMan pm = new ProxyMan();
    pm.setTarget(producer);
    IProducer producerPoxy = (IProducer)pm.getProxy();
    producerPoxy.afterService(1000f);

   }
}

結果：

3.當代理人收代理費時（抽取兩成）：

public class ProxyMan implements InvocationHandler {

  private Object target;

  public void setTarget(Object target) {
    this.target = target;
   }

  public Object getProxy(){
    return Proxy.newProxyInstance(this.getClass().getClassLoader() ,target.getClass().getInterfaces() ,this);
   }

  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    Object value = null;
    Float money = (Float) args[0];
    if("saleProduct".equals(method.getName())) {
      value = method.invoke(target, money * 0.8f);
     }
    if("afterService".equals(method.getName())){
      value = method.invoke(target ,args);
     }
    return value;
   }
}

結果：

被成功抽取兩成！

在不改變原有程式碼的時候，改變傳輸的資訊。不僅僅可以改變值，還可以增加其他東西，代理模式大多數情況用在增加日誌等功能。

2.2、Spring中的AOP

2.2.1、AOP相關術語：

Joinpoint（連線點）：
- 所謂連線點是指那些被攔截到的點。在spring中，這些點指的是方法，因為spring只支援方法型別的連線點。
Pointout（切入點）：
- 所謂切入點是指我們要對那些Joinpoint進行攔截的定義。
Advice（通知/增強）
- 所謂通知是指攔截到Joinpoint之後所要做的事情就是通知。
- 通知型別：前置通知，後置通知，異常通知，環繞通知。
Introduction（引介）：
- 引介是一種特殊的通知，在不修改類程式碼的前提下，Introduction可以在執行期為類動態的新增一些方法或Field。
Target（目標物件）
- 代理的目標物件（也就是說被代理的物件）
Weaving（織入）：
- 是指把增強應用到目標物件來建立新的代理物件的過程。
- spring採用動態代理織入，而AspectJ採用編譯期織入和類裝載期織入。
Proxy（代理）：
- 一個類被AOP織入增強後，就產生一個結果代理類。
Aspect（切面）：
- 是切入點和通知（引介）的結合。

2.2.2、AOP的配置內容

spring中基於XML的AOP配置步驟：

把通知Bean也較給spring來管理

<!-- 配置Logger類 -->
<bean id="logger" class="com.gzk.utils.Logger"></bean>

使用aop:config標籤表明開始AOP的配置
使用aop:aspect標籤表明配置切面
- id屬性：是給切面提供一個唯一標識
- ref屬性：是指定通知類bean的ID
在aop:aspect標籤的內部使用對應標籤來配置通知的型別
- 我們現在示例是讓pringLog方法在切入點方法執行之前：所以是前置通知
- aop:before：表示配置前置通知
  - method屬性：用於指定Logger類中哪個方法是前置通知
  - pointcut屬性：用於指定切入點表示式，該表示式的含義指的是對業務層中哪些方法增強
- aop:after-returning：表示配置後置通知
  - method屬性：用於指定Logger類中哪個方法是後置通知
  - pointcut屬性：用於指定切入點表示式，該表示式的含義指的是對業務層中哪些方法增強
- aop:after-throwing：表示配置異常通知
  - method屬性：用於指定Logger類中哪個方法是異常通知
  - pointcut屬性：用於指定切入點表示式，該表示式的含義指的是對業務層中哪些方法增強
- aop:after：表示配置最終通知
  - method屬性：用於指定Logger類中哪個方法是最終通知
  - pointcut屬性：用於指定切入點表示式，該表示式的含義指的是對業務層中哪些方法增強
- 切入點表示式的寫法：
  - 關鍵字：execution（表示式）
  - 表示式：
    - 訪問修飾符返回值包名.包名...類名.方法名（引數列表）
  - 標準表示式寫法（例）：
    - public void com.gzk.servicce.UserServiceImpl.test()
  - 訪問修飾符可以省略
    - void com.gzk.servicce.UserServiceImpl.test()
  - 返回值可以使用萬用字元，表示任意返回值
    - * com.gzk.servicce.UserServiceImpl.test()
  - 包名可以使用萬用字元，表示任意包。但是有幾級包，就需要寫幾個*。
    - * *.*.*.UserServiceImpl.test()
  - 包名可以使用..表示當前包及其子包
    - * *..UserServiceImpl.test()
  - 類名和方法名都可以使用*來實現通配
    - * *..*.*()
  - 引數列表：
    - 可以直接寫資料型別：
      - 基本型別直接寫名稱：int（例）
        
        * *..*.*(int)
      - 引用型別寫包名.類名的方式：java.lang.String（例）
        
        * *..*.*(java.lang.String)
    - 可以使用萬用字元*表示任意型別，但是必須有引數
      - * *..*.*(*)
    - 可以使用..表示有無引數均可，有引數可以使任意型別
      - * *..*.*(..)
  - 全通配寫法：
    - * *..*.*(..)
  - 實際開發中，很少用全通配寫法，因為會全部被代理，切入點表示式的通常寫法：
    - 切到業務層或者要被代理的層（或包）實現類下的所有方法：
      - * com.gzk.service.*.*(..)

2.2.3、測試（非註解）

測試四種常用通知型別【前置通知，後置通知，異常通知，最終通知】

1.隨意配置mapper和service包下的類，用作測試

public interface UserMapper {
  void test();
}

public class UserMapperImpl implements UserMapper {
  public void test() {
    System.out.println("測試中。。。");
   }
}

public interface UserService {
  void test();
}

public class UserServiceImpl implements UserService {

  private UserMapper userMapper;

  public void setUserMapper(UserMapper userMapper) {
    this.userMapper = userMapper;
   }

  public void test() {
    int i = 1/0;
    userMapper.test();
   }
}

2.將UserServiceImpl設為被代理的類

3.新建一個utils包，建立一個Logger類【代理類】

public class Logger {

  public void beforeLogger(){
    System.out.println("前置通知");
   }

  public void afterReturningLogger(){
    System.out.println("後置通知");
   }

  public void afterThrowingLogger(){
    System.out.println("異常通知");
   }

  public void afterLogger(){
    System.out.println("最終通知");
   }

}

4.配置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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

  <bean id="userMapper" class="com.gzk.mapper.UserMapperImpl"/>
  
  <!-- 配置被代理類UserServiceImpl -->
  <bean id="userService" class="com.gzk.service.UserServiceImpl">
    <property name="userMapper" ref="userMapper"/>
  </bean>

  <!-- 配置代理類Logger -->
  <bean id="logger" class="com.gzk.utils.Logger"/>

  <!-- 配置AOP -->
  <aop:config>
    <!-- 配置切面 -->
    <aop:aspect id="aspectLogger" ref="logger">
      <!-- 配置通知型別，並且建立通知方法和切入點方法的關聯 -->
      <!-- 配置前置通知 -->
      <aop:before method="beforeLogger" pointcut="execution(* com.gzk.service.*.*(..))"/>
      <!-- 配置後置通知 -->
      <aop:after-returning method="afterReturningLogger" pointcut="execution(public void com.gzk.service.UserServiceImpl.test())"/>
      <!-- 配置異常通知 -->
      <aop:after-throwing method="afterThrowingLogger" pointcut="execution(* com.gzk.service.*.*(..))"/>
      <!-- 配置最終通知 -->
      <aop:after method="afterLogger" pointcut="execution(public void com.gzk.service.UserServiceImpl.test())"/>

    </aop:aspect>
  </aop:config>

</beans>

5.測試：

public class UserTest {

  @Test
  public void test(){
    ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
    UserService userService = context.getBean("userService", UserService.class);
    userService.test();
   }

}

6.結果

當發生異常時：

2.2.4、通用化切入點配置

<?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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

  <bean id="userMapper" class="com.gzk.mapper.UserMapperImpl"/>
  <bean id="userService" class="com.gzk.service.UserServiceImpl">
    <property name="userMapper" ref="userMapper"/>
  </bean>

  <!-- 配置Logger類 -->
  <bean id="logger" class="com.gzk.utils.Logger"/>

  <!-- 配置AOP -->
  <aop:config>
    <!-- 配置切面 -->
    <aop:aspect id="aspectLogger" ref="logger">
      <!-- 配置通知型別，並且建立通知方法和切入點方法的關聯 -->
      <!-- 配置前置通知 -->
      <aop:before method="beforeLogger" pointcut-ref="point-cut"/>
      <!-- 配置後置通知 -->
      <aop:after-returning method="afterReturningLogger" pointcut-ref="point-cut"/>
      <!-- 配置異常通知 -->
      <aop:after-throwing method="afterThrowingLogger" pointcut-ref="point-cut"/>
      <!-- 配置最終通知 -->
      <aop:after method="afterLogger" pointcut-ref="point-cut"/>

      <!-- 配置切入點表示式 -->
      <!--
        注意：
          此標籤寫在aop:aspect標籤內部只能當前標籤使用
          它還可以寫在aop:aspect標籤外面，則所有切面都可以使用它
          若是寫在aop:aspect標籤外面，這必須按照aop的規則和順序約束，要把<aop:poincut>寫在最前面，也就是aop:config下面
      -->
      <aop:pointcut id="point-cut" expression="execution(* com.gzk.service.*.*(..))"/>

    </aop:aspect>
  </aop:config>

</beans>

2.2.5、環繞通知

1.將其他通知註釋掉，寫一個環繞通知：

<aop:around method="aroundLogger" pointcut-ref="point-cut"/>

2.在Logger類中加入環繞方法：

public void aroundLogger(){
  System.out.println("環繞通知");
}

3.結果：

很明顯出問題了，被代理類中的方法沒了，是什麼問題呢？

問題：
- 當我們配置了環繞通知之後，切入點方法沒有執行，而通知方法執行了。
分析：
- 通過對比動態代理中的環繞通知程式碼，發現動態代理的環繞通知有明確的切入點方法呼叫，而我們的程式碼沒有。
解決：
- spring框架為我們提供了一個介面，ProceedingJoinPoint。該介面有一個方法proceed()，此方法就相當於明確呼叫切入點方法。
- 該介面可以作為環繞通知的方法引數，在程式執行時，spring框架會為我們提供介面的實現類供我們呼叫。

好了，問題找到且分析了，那我們開始寫程式碼吧

xml配置檔案不用變，但Logger代理類中的aroundLogger()方法就要改變。

//環繞通知
public Object aroundLogger(ProceedingJoinPoint point){
  Object[] args = point.getArgs();
  Object proceed;
  try {
    //前置通知
    System.out.println("前置通知");
    proceed = point.proceed(args);
    //後置通知
    System.out.println("後置通知");
    return proceed;
   }catch (Throwable e){
    //異常通知
    System.out.println("異常通知");
    throw new RuntimeException(e);

   }finally {
    //最終通知
    System.out.println("最終通知");
   }

}

結果：

2.2.6、測試（註解）

1.通過註解方式隨意配置mapper和service包下的類，用作測試

public interface UserMapper {
  void test();
}

@Repository("userMapper")
public class UserMapperImpl implements UserMapper {
  public void test() {
    System.out.println("測試中。。。");
   }
}

public interface UserService {
  void test();
}

@Service("userService")
public class UserServiceImpl implements UserService {

  @Autowired
  private UserMapper userMapper;

  public void test() {
    userMapper.test();
   }
}

2.將UserServiceImpl設為被代理的類

3.新建一個utils包，建立一個Logger類【代理類】（使用註解）

@Component("logger")
@Aspect
public class Logger {

  @Pointcut("execution(* com.gzk.service.*.*(..))")
  public void pointcut(){}

  @Before("pointcut()")
  public void beforeLogger(){
    System.out.println("前置通知");
   }

  @AfterReturning("pointcut()")
  public void afterReturningLogger(){
    System.out.println("後置通知");
   }

  @AfterThrowing("pointcut()")
  public void afterThrowingLogger(){
    System.out.println("異常通知");
   }

  @After("pointcut()")
  public void afterLogger(){
    System.out.println("最終通知");
   }

  //環繞通知
  @Around("pointcut()")
  public Object aroundLogger(ProceedingJoinPoint point){
    Object[] args = point.getArgs();
    Object proceed;
    try {
      //前置通知
      System.out.println("環繞-前置通知");
      proceed = point.proceed(args);
      //後置通知
      System.out.println("環繞-後置通知");
      return proceed;
     }catch (Throwable e){
      //異常通知
      System.out.println("環繞-異常通知");
      throw new RuntimeException(e);
     }finally {
      //最終通知
      System.out.println("環繞-最終通知");
     }

   }

}

4.此時有兩種方式來配置 xml 檔案，一種是xml，一種是java

4.1、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:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

  <!-- 配置要掃描的包 -->
  <context:component-scan base-package="com.gzk"/>

  <!-- 開啟aop自動註解 -->
  <aop:aspectj-autoproxy/>

</beans>

4.2、java為配置檔案，建立一個config包，在下面新建一個類

@Configuration
@ComponentScan(basePackages = "com.gzk")
@EnableAspectJAutoProxy
public class ApplicationConfig {
}

5.測試

5.1、使用xml為配置類測試：

public class UserTest {

  @Test
  public void test(){
    ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
    UserService userService = context.getBean("userService", UserService.class);
    userService.test();
   }

}

5.2、使用java為配置類測試

public class UserTest {

  @Test
  public void test(){
    ApplicationContext context = new AnnotationConfigApplicationContext(ApplicationConfig.class);
    UserService userService = context.getBean("userService", UserService.class);
    userService.test();
   }

}

6.結果：

spring-aop筆記

2、Spring-AOP 2.1、代理【Proxy】動態代理：特點：位元組碼誰用誰建立，誰用誰載入

Spring AOP學習筆記04：AOP核心實現之建立代理

　　上文中，我們分析了對所有增強器的獲取以及獲取匹配的增強器，在本文中我們就來分析一下Spring AOP中另一部分核心邏輯--代理的建立。這部分邏輯的入口是在wrapIfNecessary()方法中緊接著增強器的獲取之後的creat

Spring AOP學習筆記05：AOP失效的罪因

　　前面的文章中我們介紹了Spring AOP的簡單使用，並從原始碼的角度學習了其底層的實現原理，有了這些基礎之後，本文來討論一下Spring AOP失效的問題，這個問題可能我們在平時工作中或多或少也會碰到。這個話題應該

Spring 學習筆記一 IOC AOP

Spring的核心架構圖什麼是IoC？ IoC Inversion of Control (控制反轉)，注意它是⼀個技術思想，不是⼀個技術實現描述的事情：Java開發領域物件的建立，管理的問題

Spring學習筆記（六）--AOP（JDK動態代理之底層原理）

------------恢復內容開始------------ 終於開始正題了 AOP的底層原理底層動態代理的情況

Spring學習筆記--面向切面程式設計（AOP）

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

Spring---AoP（面向切面程式設計）原理學習筆記【全】

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

學習筆記--Spring AOP

1.什麼是AOP AOP就是Aspect Oritented Programming的縮寫，意思為面向切面程式設計，是通過預編譯和執行期動態代理實現程式功能的統一維護的一種技術。

Spring學習筆記(2) AOP

Spring AOP 第一章、靜態代理設計模式 1. 為什麼需要代理設計模式 1.1 問題在JavaEE分層開發開發中，哪個層次對於我們來講最重要

Spring AOP原始碼實現分步解析

1 概述 1.1 示例最基本的使用，在建立了業務介面和實現類後，通過配置<aop:config>....</aop:config>標籤來指定<aop:pointcut和<aop:advisor。示例如下：

向您圖文並茂生動講解Spring AOP 原始碼（1）

前言在Spring AOP - 註解方式使用介紹（長文詳解）中，作者介紹了Spring AOP 註解方式的使用方式。算是給咱們的Spring AOP 原始碼分析開了個頭，做了一點知識點的鋪墊。

Spring AOP 詳解

情景案例小明辛苦忙了一整年終於完成了包含300個介面的業務系統專案。專案圓滿上線並穩定運行了一段時間了。突然有一天總監說，對於會造成資料變化的所有介面，我們必須記錄使用者的操作日誌。然後小明就吭哧吭哧給

用心整理 | Spring AOP 乾貨文章，圖文並茂，附帶 AOP 示例 ~

Spring AOP 是 Java 面試的必考點，我們需要了解 AOP 的基本概念及原理。那麼 Spring AOP 到底是啥，為什麼面試官這麼喜歡問它呢？本文先介紹 AOP 的基本概念，然後根據 AOP 原理，實現一個介面返回統一格式的小示例

向您生動地講解Spring AOP 原始碼（3）

前言往期文章： Spring IoC - Spring IoC 的設計 Spring IoC - IoC 容器初始化原始碼解析

spring AOP原始碼深度解析

因為springAOP會使用springIOC來管理Bean，所以對springIOC不太瞭解的同學可以參考我前篇springIOC原始碼深度解析。

Spring AOP之坑：完全搞清楚advice的執行順序

AOP的核心概念要完全理解Spring AOP首先要理解AOP的核心概念和術語，這些術語並不是Spring指定的，而且很不幸，這些術語並不能直觀理解，但是，如果Spring使用自己的術語，那將更加令人困惑。

Spring AOP - 註解方式使用介紹（長文詳解）

前言之前的原始碼解析章節，本人講解了Spring IOC 的核心部分的原始碼。如果你熟悉Spring AOP的使用的話，在瞭解Spring IOC的核心原始碼之後，學習Spring AOP 的原始碼，應該可以說是水到渠成，不會有什麼困難。

Spring AOP定義AfterReturning增加例項分析

本文例項講述了Spring AOP定義AfterReturning增加。分享給大家供大家參考，具體如下：

Spring AOP定義Before增加實戰案例詳解

本文例項講述了Spring AOP定義Before增加。分享給大家供大家參考，具體如下：一配置

Spring AOP在web應用中的使用方法例項

前言之前的aop是通過手動建立代理類來進行通知的，但是在日常開發中，我們並不願意在程式碼中硬編碼這些代理類，我們更願意使用DI和IOC來管理aop代理類。Spring為我們提供了以下方式來使用aop框架

spring-aop筆記

2、Spring-AOP

2.1、代理【Proxy】

2.1.1、未使用代理

2.1.2、使用了代理

2.2、Spring中的AOP

2.2.1、AOP相關術語：

2.2.2、AOP的配置內容

2.2.3、測試（非註解）

2.2.4、通用化切入點配置

2.2.5、環繞通知

2.2.6、測試（註解）

相關推薦