2. 程式人生 > >spring 框架之Aop

spring 框架之Aop

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

Spring對AOP的支援

  • 基於代理的經典AOP；

  • @AspectJ註解驅動的切面；

  • 純POJO切面；

  • 注入式AspectJ切面（適合Spring個版本）；

Spring是在執行期將切面織入到所管理的Bean中的，如圖所示，代理類封裝了目標類，當攔截到方法呼叫時，在呼叫目標Bean的方法之前，代理會執行切面邏輯。真正應用需要被代理的Bean時，Spring才會建立代理物件。Spring的切面由包裹了目標物件的代理類實現，代理類處理方法的呼叫，執行額外的切面邏輯，並呼叫目標方法。

image

Spring的切面由包裹了目標物件的代理類實現，代理類處理方法的呼叫，執行額外的切面邏輯，並呼叫目標方法。

Spring只支援方法連線點，缺少對欄位連線點的支援，例如攔截物件欄位的修改。也不支援構造器連線點，也就無法在Bean建立時應用通知。

使用切點選擇連線點

Spring AOP中，需要使用AspectJ的切點表示式來定義切點。

AspectJ指示器 描述
arg() 限制連線點匹配引數為指定型別的執行方法
@args() 限制連線點匹配引數由指定註解標註的執行方法
execution() 用於匹配是連線點的執行方法
this() 限制連線點匹配AOP代理的Bean引用為指定型別的類
target() 限制連線點匹配目標物件為執行型別的類
@target() 限制連線點匹配特定的執行物件，這些物件對應的類要具備指定型別的註解
within() 限制連線點匹配指定的型別
@within() 限制連線點匹配指定註解所標註的型別
@annotation() 限制匹配帶有指定註解連線點

編寫切點

image

使用AspectJ切點表示式來定位

這裡使用了execution()指示器來選擇Instrument的play()方法。表示式以*開頭表示不關心返回值的型別，然後指定了全限定類名和方法名，使用..作為方法的引數列表，表示可以是任意的入參。

使用&&將execution()和within()進行連線，那麼也就可以使用||（或）和!（非）。

image

使用within()指示器限制切點範圍

使用Spring的bean()指示器

bean()使用Bean id來作為引數，從而限制切點只匹配特定的Bean，如：

execution(* com.springinaction.springidol.Instrument.play()) and bean(eddie)

這裡，表示在執行Instrument的play()方法時應用通知，但限定Bean的id為eddie。

在XML中宣告切面

AOP配置元素 描述
<aop:advisor> 定義AOP通知器
<aop:after> 定義AOP後置通知（不管該方法是否執行成功）
<aop:after-returning> 在方法成功執行後呼叫通知
<aop:after-throwing> 在方法丟擲異常後呼叫通知
<aop:around> 定義AOP環繞通知
<aop:aspect> 定義切面
<aop:aspect-autoproxy> 定義@AspectJ註解驅動的切面
<aop:before> 定義AOP前置通知
<aop:config> 頂層的AOP配置元素，大多數的<aop:*>包含在<aop:config>元素內
<aop:declare-parent> 為被通知的物件引入額外的介面，並透明的實現
<aop:pointcut> 定義切點

所需jar包:

無標題.png

表演者介面：

public interface Performer {

    void perform();

}

歌唱家類：

public class Instrumentalist implements Performer {

    private String song;

    private Instrument instrument;

    public Instrumentalist() {

    }

    public void perform() {

        System.out.print("Playing " + song + " : ");

        instrument.play();

    }

    public void setSong(String song) { // 注入歌曲

        this.song = song;

    }

    public String getSong() {

        return song;

    }

    public String screamSong() {

        return song;

    }

    public void setInstrument(Instrument instrument) { // 注入樂器

        this.instrument = instrument;

    }

}

樂器介面：

public interface Instrument {

    public void play();

}

吉他類：

public class Guitar implements Instrument {

    public void play() {

        System.out.println("Strum strum strum");

    }

}

下面定義一個觀眾類：

public class Audience {    // 表演之前
    public void takeSeats() {
        System.out.println("The audience is taking their seats.");
    }    // 表演之前
    public void turnOffCellPhones() {
        System.out.println("The audience is turning off their cellphones");
    }    // 表演之後
    public void applaud() {
        System.out.println("CLAP CLAP CLAP CLAP CLAP");
    }    // 表演失敗之後
    public void demandRefund() {
        System.out.println("Boo! We want our money back!");
    }
}

宣告前置和後置通知

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

    <bean id="eddie" class="com.springinaction.springidol.Instrumentalist">
        <property name="instrument">
            <bean class="com.springinaction.springidol.Guitar" />
        </property>
        <property name="song" value="my love" />
    </bean>

    <bean id="audience" class="com.springinaction.springidol.Audience" />

    <aop:config>
        <aop:aspect ref="audience"><!-- 引用audience Bean -->
            <!-- 宣告切入點 -->
            <aop:pointcut id="performance"
                expression="execution(* com.springinaction.springidol.Performer.perform(..))" />
            <!-- 表演之前 -->
            <aop:before pointcut-ref="performance" method="takeSeats" />
            <aop:before pointcut-ref="performance" method="turnOffCellPhones" />
            <!-- 表演之後 -->
            <aop:after-returning pointcut-ref="performance"
                method="applaud" />
            <!-- 表演失敗之後 -->
            <aop:after-throwing pointcut-ref="performance"
                method="demandRefund" />
        </aop:aspect>
    </aop:config></beans>

在<aop:config>中，可以宣告一個或多個通知器、切面或者切點。pointcut屬性定義了通知所引用的切點。最終的通知邏輯如何織入到業務邏輯中：

image

Audience切面包含4中通知，這些通知把通知=邏輯織入到匹配的切面的切點方法中

測試程式碼：

@Test
    public void testBeforeAndAfter() throws PerformanceException{
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-idol.xml");
        Performer performer = (Performer) context.getBean("eddie");
        performer.perform();
    }

測試結果：

The audience is taking their seats.
The audience is turning off their cellphones
Playing my love : Guitar Guitar Guitar
CLAP CLAP CLAP CLAP CLAP

宣告環繞通知

前置通知和後置通知之間共享訊息需要使用成員變數，而Audience是單例，使用成員變數有可能存線上程安全問題。使用環繞通知可以完成之前前置和後置所實現的相同功能，而且只需一個方法。

package com.springinaction.springidol;
import org.aspectj.lang.ProceedingJoinPoint;
public class AroundAudience {    
public void watchPerformance(ProceedingJoinPoint joinpoint) {        
try {            // 表演之前
            System.out.println("The audience is taking their seats.");
            System.out.println("The audience is turning off their cellphones");            
            long start = System.currentTimeMillis();            // 執行被通知的方法
            joinpoint.proceed();            // 表演之後
            long end = System.currentTimeMillis();
            System.out.println("CLAP CLAP CLAP CLAP CLAP");
            System.out.println("The performance took " + (end - start) + " milliseconds.");
        } catch (Throwable t) {            // 表演失敗之後
            System.out.println("Boo! We want our money back!");
        }
    }
}

ProceedingJoinPoint作為入參，從而可以在通知裡呼叫被通知的方法。

XML配置：

<bean id="audience" class="com.springinaction.springidol.AroundAudience" />
<aop:config>
    <aop:aspect ref="audience"><!-- 引用audience Bean -->
        <!-- 宣告切入點 -->
        <aop:pointcut id="performance"
            expression="execution(* com.springinaction.springidol.Performer.perform(..))" />
        <aop:around method="watchPerformance" pointcut-ref="performance" />
    </aop:aspect>
    </aop:config></pre>

一個實際例子---日誌記錄

AspectJ使用org.aspectj.lang.JoinPoint介面表示目標類連線點物件，如果是環繞增強時，使用org.aspectj.lang.ProceedingJoinPoint表示連線點物件，該類是JoinPoint的子介面。任何一個增強方法都可以通過將第一個入參宣告為JoinPoint訪問到連線點上下文的資訊。我們先來了解一下這兩個介面的主要方法：
1)JoinPoint
 java.lang.Object[] getArgs()：獲取連線點方法執行時的入參列表；
 Signature getSignature() ：獲取連線點的方法簽名物件；
 java.lang.Object getTarget() ：獲取連線點所在的目標物件；
 java.lang.Object getThis() ：獲取代理物件本身；
2)ProceedingJoinPoint
ProceedingJoinPoint繼承JoinPoint子介面，它新增了個用於執行連線點方法的方法：
 java.lang.Object proceed() throws java.lang.Throwable：通過反射執行目標物件的連線點處的方法；

二、程式碼演示。

SecurityHandler.java

package com.tgb.spring;  

import org.aspectj.lang.JoinPoint;  

public class SecurityHandler{  

    private void checkSecurity(JoinPoint joinPoint){  

        for (int i = 0; i < joinPoint.getArgs().length; i++) {  

            System.out.println(joinPoint.getArgs()[i]);  

        }  

        System.out.println(joinPoint.getSignature().getName());  
        System.out.println("=====checkSecurity====");  
    }  
}

Client.java

package com.tgb.spring;  

  

import org.springframework.beans.factory.BeanFactory;  

import org.springframework.context.support.ClassPathXmlApplicationContext;  

  

import com.tgb.spring.UserManager;  

  

  

  

public class Client {  

  

    public static void main(String[] args) {  

    BeanFactory factory=new ClassPathXmlApplicationContext("applicationContext.xml");  

        UserManager userManager=(UserManager) factory.getBean("userManager");  

        userManager.addUser("張三", "123");  

        //userManager.delUser(1);  

          

    }  

}

UserManager.java

package com.tgb.spring;  

  

public interface UserManager {  

      

    public void addUser(String username,String password);  

      

    public void delUser(int userId);  

      

    public String findUserById(int userId);  

      

    public void modifyUser(int userId,String username,String password);  

      

}

UserManagerImpl.java

package com.tgb.spring;  

  

public class UserManagerImpl implements UserManager {  

  

    public void addUser(String username, String password) {  

        //checkSecurity();  

            System.out.println("===UserManager.addUser===");  

  

    }  

  

    public void delUser(int userId) {  

        //checkSecurity();  

        System.out.println("===UserManager.delUser===");  

  

    }  

  

    public String findUserById(int userId) {  

        //checkSecurity();  

        System.out.println("===UserManager.findUserById===");  

    return  "張三";  

    }  

  

    public void modifyUser(int userId, String username, String password) {  

        //checkSecurity();  

        System.out.println("===UserManager.modifyUser===");  

  

    }  

      

//  private void checkSecurity(){  

//      System.out.println("checkSecurity");  

//  

//  }  

  

}

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: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-2.0.xsd  

           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd  

           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">  

  

  

<bean id="userManager" class="com.tgb.spring.UserManagerImpl" />  

<bean id="securityHandler" class="com.tgb.spring.SecurityHandler"/>  

<aop:config>  

    <aop:aspect id="securityAspect" ref="securityHandler">  

  

         <aop:pointcut id="addAddMethod" expression="execution(* com.tgb.spring.*.*(..))" />  

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

    </aop:aspect>  

</aop:config>  

</beans>

 

相關推薦

Spring框架之AOP面向切面程式設計

package com.jredu.aop.aspect; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.After; im

spring 框架之Aop

Spring對AOP的支援 基於代理的經典AOP； @AspectJ註解驅動的切面； 純POJO切面； 注入式AspectJ切面（適合Spring個版本）； Spring是在執行期將切面織入到所管理的Bean中的，如圖所示，代理類封裝了目標類，當攔

4-Spring框架 之 AOP

AOP簡介 AOP(Aspect Orient Programming),面向切面程式設計，是面向物件程式設計（OOP）的一種補充，面向物件程式設計是從靜態角度考慮程式的結構，而面向切面程式設計是從動態角度考慮程式執行過程。 AOP底層，就是採用動態代理模式實現

Spring框架之AOP原始碼完全解析

Spring框架之AOP原始碼完全解析         Spring可以說是Java企業開發裡最重要的技術。Spring兩大核心IOC（Inversion of Control控制反轉）和AOP（Aspect Oriented Programming面向切面程式設計）。

Spring框架之Spring AOP

權限 保持 eth before app spring win 應該 ctc 一、基於註解管理的AOP 1、Spring配置文件 <!-- 配置自動掃描包,自動掃描Bean組件,切面類 --> <context:component-scan

Spring框架 之IOC容器 和AOP詳解

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

Spring框架的AOP技術之通知型別

1. 通知型別 * @Before -- 前置通知 * @AfterReturing -- 後置通知 * @Around -- 環繞通知（目標物件方法預設不執行的，需要手動執行） * @After

Spring系列之AOP

-a cte implement 結合 動態擴展 分離 可操作性 技術 其中 一、什麽是AOPAOP（Aspect-OrientedProgramming，面向方面編程），可以說是OOP（Object-Oriented Programing，面向對象編程）的補充和完善。OO

Spring系列之AOP實現的兩種方式

部分 靜態常量 cep value conf tar import enc ble AOP常用的實現方式有兩種，一種是采用聲明的方式來實現（基於XML），一種是采用註解的方式來實現（基於AspectJ）。 首先復習下AOP中一些比較重要的概念： Joinpoint（連接點）

Spring框架 之@Valid註解的使用（嵌套類型的效驗）

Springboot 之@Valid註解@Valid註解可以實現數據的驗證，你可以定義實體，在實體的屬性上添加校驗規則，而在API接收數據時添加@valid關鍵字，這時你的實體將會開啟一個校驗的功能。@Valid 註解類型的使用:@Null限制只能為null@NotNull限制必須不為null@AssertF

Spring 框架的AOP概述

1.AOP概述 AOP：面向切面（方面）程式設計，它提供另一種角度（橫向抽取）來思考程式結構，通過這種方式彌補了面向物件程式設計（OOP）的不足。 AOP是Spring框架的核心，也是一個關鍵元件，我們可以自由選對是否使用AOP。 AOP不是多高深的思想，它只是為OOP填了些坑。 1

spring框架之 IoC和DI（二）

九、依賴注入 9、1  屬性依賴注入 依賴注入方式：手動裝配 和 自動裝配 手動裝配：一般進行配置資訊都採用手動            ① 基於xml裝配：構造方法、setter方法 、 p標籤注入            ②  基於註解裝配：@autowrired 

Spring框架(二)————AOP使用擴充套件

一.AOP 1.簡介;AOP（Aspect Oriented Programming 面向切面程式設計），可以通過預編譯方式和執行期動態代理實現在不修改原始碼的情況下給程式動態統一新增功能的一種技術。AOP實際是GoF設計模式的延續，設計模式孜孜不倦追求的是呼叫

spring框架之AspectJ基於xml和基於註解

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

spring框架之陣列，集合(List,Set,Map)，Properties等的注入

先編寫User類： package com.huida.demo4; import java.util.Arrays; import java.util.List; import java.util.Map; import java.util.Properties; public class

Spring框架的AOP技術（註解方式）

1. 步驟一：建立JavaWEB專案，引入具體的開發的jar包 * 先引入Spring框架開發的基本開發包 * 再引入Spring框架的AOP的開發包 * spring的傳統AOP的開發的包 * spring-aop-4.2.4.RELEASE.jar

Spring框架：AOP程式設計

實現方法：動態代理設計模式 JDK 的動態代理：針對實現了介面的類產生代理。InvocationHandler介面 CGlib 的動態代理：針對沒有實現介面的類產生代理，應用的是底層的位元組碼增強的技

spring框架之

spring框架 用途 整合其他框架，讓他們協同工作 提供了宣告式的事務管理 – 通過配置(xml, 註解)來管理事務 兩大核心思想：IOC，AOP 1. IOC簡介（控制反轉） 在web專案，一個servlet class servlet extends

10 Spring框架的AOP技術（註解方式）

引入Spring框架開發的基本開發包,spring的傳統AOP的開發的包與aspectJ的開發包 建立spring配置檔案 applicationContext.xml <beans xmlns="http://www.springfra

Spring系列之AOP的原理及手動實現

目錄 Spring系列之IOC的原理及手動實現 Spring系列之DI的原理及手動實現 引入 到目前為止，我們已經完成了簡易的IOC和DI的功能，雖然相比如Spring來說肯定是非常簡陋的，但是畢竟我們是為了理解原理的，也沒必要一定要做一個和Spring一樣的東西。到了現在並不能讓我們鬆一