2. 程式人生 > >Spring AOP學習

Spring AOP學習

阿新 • • 發佈：2018-08-16
[] .com -s tca demo1 ng- cep pattern pre

什麽是AOP

AOP 面向切面編程

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

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

AspecJ是一個基於Java語言的AOP框架，Spring2.0開始，Spring AOP引入對Aspect的支持，AspectJ擴展了Java語言，提供了一個專門的編譯器，在編譯時提供橫向代碼的織入

AOP底層原理

就是代理機制:

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

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

Spring的AOP代理

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

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

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

AOP的術語

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

Pointcut(切入點)：所謂切入點是指我們要對哪些Joinpoint進行攔截的定義.

Advice(通知/增強)：所謂通知是指攔截到Joinpoint之後所要做的事情就是通知.通知分為前置通知,後置通知,異常通知,最終通知,環繞通知

(切面要完成的功能)

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

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

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

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

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

Aspect(切面)：是切入點和通知（引介）的結合

技術分享圖片

不帶有切點的切面

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 {
 
    @Override
    public void add() {    
        System.out.println("添加客戶...");
    }
 
    @Override
    public void delete() {    
        System.out.println("刪除客戶...");
    }
 
    @Override
    public void update() {    
        System.out.println("修改客戶...");
    }
 
    @Override
    public 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：目標對象
     */
    @Override
    public 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>
 <!-- Spring支持配置來生成代理，基於ProxyFactoryBean類，底層自動選擇使用JDK的動態代理還是CGLIB的代理 -->
 <bean id="customerDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
 <!-- 設置目標對象 -->
     <property name="target" ref="customerDao"></property>
     <!-- 設置實現的接口,value中寫接口的全路徑 -->
     <property name="proxyInterfaces" value="com.js.aopStu.CustomerDao"></property>
     <!-- 配置需要攔截的,一定是value，此處對customerDao中的所有方法攔截 -->
     <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;
    
    //不使用增強的情況下
    @Test
    public 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{
 
    @Override
    public 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="pattern" value=".*"/> -->
    <!-- <property name="pattern" value="cn\.itcast\.spring3\.demo4\.OrderDao\.add.*"/> -->
    <!-- <property name="pattern" value=".*add.*"></property> -->
    <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;

    @Test
    public void demo1(){
        orderDao.add();
        orderDao.delete();
        orderDao.find();
        orderDao.update();
    }
}

Spring AOP學習

相關推薦

Spring aop學習整理(spring in action)（一）：了解AOP

進入 一起 table return 問題 匹配 核心 before cti 　　切面能幫助我們模塊化橫切關註點。簡而言之，橫切關註點可以被描述為影響應用多處的功能。例如，安全就是一個橫切關註點，應用中的許多方法都會涉及到安全規則。圖4.1直觀呈現了橫切關註點的概念。　　

Spring AOP學習

[] .com -s tca demo1 ng- cep pattern pre 什麽是AOP AOP 面向切面編程 采取橫向抽取機制，取代了傳統縱向繼承體系重復性代碼（性能監視、事務管理、安全檢查、緩存） Spring AOP使用純Java實現，不需要專門的編譯

Spring AOP 學習筆記

1、Spring AOP中的動態代理主要有兩種方式，JDK動態代理和CGLIB動態代理。JDK動態代理通過反射來接收被代理的類，並且要求被代理的類必須實現一個介面。JDK動態代理的核心是InvocationHandler介面和Proxy類。如果目標類沒有實現介面，那麼Spring AOP會選擇使

Spring AOP學習筆記（一）：基礎概念

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

Spring-Aop學習的前提——cglib代理

這裡我們就簡單寫一個例子來看一下cglib代理： 首先先匯入cglib的jar包，cglib-nodep.jar，大家可以自行去官網下載即可。 首先建立一個介面：PersonDao public interface PersonDao { publ

Spring AOP學習筆記（1）：AOP基礎知識

一、 使用AOP前的經驗 在接觸AOP這種程式設計思想之前，我也有好多的編碼經歷，將業務邏輯和日誌、測試和驗證等其他需求放在一起的，這簡直是痛苦死了，每寫一個方法都得重複好多程式碼，而且這些程式碼有好多是類似的，但是不得不重寫，因為當時還是菜鳥（現在也是菜鳥），比如之前同組

[Spring]Spring AOP學習筆記（2）---5種切入方式、AOP優先順序及切面表示式的重用

Spring AOP學習筆記（2）---5種切入方式、AOP優先順序及切面表示式的重用 一、5種切入方式 學習了下Spring的AOP的五種切入方式，分別是： （1）Before ---在所攔截方法執行前執行； （2）After ---在所攔截方法執行後執行； （3）Aft

基於Springboot的Spring AOP學習記錄

前段時間各種面試，aop問到就蒙逼，所以結合新學的springboot重新理一下這玩意兒，很重要啊 一、AOP概述 AOP(面對切面程式設計)是對OOP(面向物件程式設計)的補充，總體來說，程式設計正規化包含：面向過程程式設計、面向物件程式設計、函數語言

Spring AOP學習筆記(一)-AOP相關概念和基於註解方式實現AOP的規則

一、 Spring AOP 概念 其實AOP就是要將我們Aspect中的Pointcut和Target Object中的JointPoint動態的連線起來，同時我們通過Advice指明Pointcut執行的一個時機。這是個人理解 AOP相關名詞解釋

spring aop學習9:Aop的鏈式呼叫(責任鏈模式)

一.責任鏈模式 1.基本的責任鏈模式 ◆主體父類:abstract class Subject.java package com.tiglle.responsibility.chain.model; //主體 public abstract class

AOP和spring AOP學習記錄

### AOP基本概念的理解 面向切面AOP主要是在編譯期或執行時，對程式進行織入，實現代理， 對原始碼毫無侵入性，不破壞主要業務邏輯，減少程式的耦合度。 - 主要應用範圍： 日誌記錄，效能統計，安全控制，事務處理，異常處理等等 #### 名詞性概念 - **切面（Aspect）**

Spring AOP學習筆記01：AOP概述

1. AOP概述 　　軟體開發一直在尋求更加高效、更易維護甚至更易擴充套件的方式。為了提高開發效率，我們對開發使用的語言進行抽象，走過了從彙編時代到現在各種高階語言繁盛之時期；為了便於維護和擴充套件，我們對某些相同的功能進行歸類並使之模組化，衝出了最初的"原始部落"，走過了從過程化程式設計到面向物件程式設計(

Spring AOP學習筆記02：如何開啟AOP

　　上文簡要總結了一些AOP的基本概念，並在此基礎上敘述了Spring AOP的基本原理，並且輔以一個簡單例子幫助理解。從本文開始，我們要開始深入到原始碼層面來一探Spring AOP魔法的原理了。 　　要使用Spring AOP，第一步是要將這一功能開啟，一般有兩種方式： 通過xml配置檔案的方式； 通過

Spring AOP學習筆記03：AOP的核心實現之獲取增強器

　　上文講了spring是如何開啟AOP的，簡單點說就是將AnnotationAwareAspectJAutoProxyCreator這個類註冊到容器中，因為這個類最終實現了BeanPostProcessor介面，並且在其postProcessAfterInitialization()方法中完成了AOP代理物

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

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

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

　　前面的文章中我們介紹了Spring AOP的簡單使用，並從原始碼的角度學習了其底層的實現原理，有了這些基礎之後，本文來討論一下Spring AOP失效的問題，這個問題可能我們在平時工作中或多或少也會碰到。這個話題應該從同一個物件內的巢狀方法呼叫攔截失效說起。 1. 問題的現象 　　假設我們有如下物件類定義

Spring Boot學習——AOP編程的簡單實現

col .com tsig 訪問 pan -s ping 編程範式 lan 首先應該明白一點，AOP是一種編程範式，是一種程序設計思想，與具體的計算機編程語言無關，所以不止是Java，像.Net等其他編程語言也有AOP的實現方式。AOP的思想理念就是將通用邏輯

Java動態代理學習【Spring AOP基礎之一】

tor -1 我們 null exception 文件 cat static 一個 　　Spring AOP使用的其中一個底層技術就是Java的動態代理技術。Java的動態代理技術主要圍繞兩個類進行的　 　　java.lang.reflect.InvocationHan

CgLib動態代理學習【Spring AOP基礎之一】

div 目前 .get 不知道 ctu get() 內容 想要 外部依賴 　　如果不了解JDK中proxy動態代理機制的可以先查看上篇文章的內容：Java動態代理學習【Spring AOP基礎之一】 　　由於Java動態代理Proxy.newProxyInstance()的

Spring學習(十六)----- Spring AOP實例(Pointcut(切點),Advisor)

dao new ide on() inter exc def row 再次 在上一個Spring AOP通知的例子，一個類的整個方法被自動攔截。但在大多數情況下，可能只需要一種方式來攔截一個或兩個方法，這就是為什麽引入‘切入點‘的原因。它允許你通過它的方法名來攔截方法。另