2. 程式人生 > >Spring（三）--AOP【面向切面編程】、通知類型及使用、切入點表達式

Spring（三）--AOP【面向切面編程】、通知類型及使用、切入點表達式

阿新 • • 發佈：2017-08-29
1.3 一聲 重復 信息 術語 臃腫 lib pac fin

1.概念：Aspect Oriented Programming 面向切面編程 在方法的前後添加方法 2.作用：本質上來說是一種簡化代碼的方式
繼承機制
封裝方法
動態代理
……

3.情景舉例
　　①數學計算器接口[MathCalculator]
int add(int i,int j);
int sub(int i,int j);
int mul(int i, int j); int div(int i,int j); 因為後面的通知方法需要返回值，所以在這裏類型聲明為 int 類型
public interface MathCaculator {
      public int add(int i,int j);
      public int sub(int i,int j);
      public int mul(int i,int j);
      public int div(int i,int j);
}
　　 ②提供簡單實現[EasyImpl] 　　 一定要在類上寫註解，否則在 IOC容器中找不到 
@Component
public class CacultorEasyImpl implements MathCaculator{
      @Override
      public void add(int i, int j) {
            System.out.println("[日誌]，【參數：】"+i+","+j);
            int result = i + j;
            System.out.println("[日誌]，【參數：】"+i+","+j+"--"+result);
      }

      @Override
      public void sub(int i, int j) {
            System.out.println("[日誌]，【參數：】"+i+","+j);
            int result = i - j;
            System.out.println("[日誌]，【參數：】"+i+","+j+"--"+result);
      }

      @Override
      public void mul(int i, int j) {
            System.out.println("[日誌]，【參數：】"+i+","+j);
            int result = i * j;
            System.out.println("[日誌]，【參數：】"+i+","+j+"--"+result);
      }

      @Override
      public void div(int i, int j) {
            System.out.println("[日誌]，【參數：】"+i+","+j);
            int result = i / j;
            System.out.println("[日誌]，【參數：】"+i+","+j+"--"+result);
      }
}


<context:component-scan base-package="com.neuedu.aop"></context:component-scan>

　　③在簡單實現的基礎上讓每一個計算方法都能夠打印日誌[LoginImpl]

private ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
@Test
public void test() {
      CacultorEasyImpl bean = ioc.getBean(CacultorEasyImpl.class);
      bean.add(10, 2);
      bean.sub(10, 2);
      bean.mul(10, 2);
      bean.div(10, 2);
}

　　④缺陷
[1]手動添加日誌繁瑣，重復
[2]統一修改不便
[3]對目標方法本來要實現的核心功能有幹擾，使程序代碼很臃腫，不易於開發維護

⑤使用動態代理實現
[1]創建一個類，讓這個類能夠提供一個目標對象的代理對象
[2]在代理對象中打印日誌

4.AOP術語！[參見圖例和doc文檔]
AOP概述
●AOP(Aspect-Oriented Programming，面向切面編程)：是一種新的方法論 是對傳統 OOP(Object-Oriented Programming，面向對象編程)的補充。 ●參見圖例和doc文檔解釋AOP的各個術語！
●Spring的AOP既可以使用xml配置的方式實現，也可以使用註解的方式來實現！ 技術分享

5.在Spring中使用AOP實現日誌功能
　　①Spring中可以使用註解或XML文件配置的方式實現AOP。
　　②導入jar包
com.springsource.net.sf.cglib -2.2.0.jar
com.springsource.org.aopalliance-1.0.0 .jar
com.springsource.org.aspectj.weaver-1.6.8 .RELEASE.jar
commons-logging-1.1.3. jar
spring-aop-4.0.0.RELEASE.jar
spring-aspects-4.0.0.RELEASE.jar
spring-beans-4.0.0.RELEASE.jar
spring-context-4.0.0.RELEASE.jar
spring-core-4.0.0.RELEASE.jar
spring-expression-4.0.0.RELEASE. jar

　　③開啟基於註解的AOP功能 < aop:aspectj-autoproxy /> 

<context:component-scan base-package="com.neuedu.aop"></context:component-scan>
<aop:aspectj-autoproxy/>

　　④聲明一個切面類，並把這個切面類加入到 IOC容器中

　　　在類上加以下兩個註解
@Aspect ：表示這是一個切面類
@Component ：加入IOC容器

　　⑤在切面類中聲明通知方法
[1] 前置通知：@Before
[2] 返回通知：@AfterReturning
[3] 異常通知：@AfterThrowing
[4] 後置通知：@After
[5] 環繞通知：@Around :環繞通知是前面四個通知的集合體！

@Component
@Aspect
public class CaculatorAspect {

      @Before(value="execution(public void com.neuedu.aop.RawCaculatorImpl.add(int, int))")
      public void showBeginLog(){
            System.out.println("日誌開始");
      }

      @After(value="execution(public void com.neuedu.aop.RawCaculatorImpl.add(int, int))")
      public void showReturnLog(){
            System.out.println("日誌正常返回");
      }

      @AfterThrowing(value="execution(public void com.neuedu.aop.RawCaculatorImpl.add(int, int))")
      public void showExceptionLog(){
            System.out.println("日誌有錯");
      }

      @AfterReturning(value="execution(public void com.neuedu.aop.RawCaculatorImpl.add(int, int))")
      public void showAfterLog(){
            System.out.println("日誌最終結束");
      }
}

　　⑥被代理的對象也需要加入IOC容器

@Component
public class RawCaculatorImpl implements MathCaculator{

      @Override
      public void add(int i, int j) {
            int result = i + j;
            System.out.println(i+"+"+j+"="+result);
      }

      @Override
      public void sub(int i, int j) {
            int result = i - j;
            System.out.println(i+"-"+j+"="+result);
      }

      @Override
      public void mul(int i, int j) {
            int result = i * j;
            System.out.println(i+"*"+j+"="+result);
      }

      @Override
      public void div(int i, int j) {
            int result = i / j;
            System.out.println(i+"/"+j+"="+result);
      }
}

　　Test 中 用 id 查找，通過強轉，調用加減乘除四個方法

private ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
@Test
public void test() {
      MathCaculator bean = (MathCaculator) ioc.getBean("rawCaculatorImpl");
      bean.add(10, 2);
      bean.sub(10, 2);
      bean.mul(10, 2);
      bean.div(10, 2);
}

6.切入點表達式： （1）上述案例通過junit測試，會發現，我們調用目標類的四個方法只有add方法被加入了4個通知 如果想所有的方法都加上這些通知，可以在切入點表達式處： 將execution(public int com.neuedu.aop.target.MathCalculatorImpl.add(int, int)) 換成： execution(public int com.neuedu.aop.target.MathCalculatorImpl.*(int, int)) 這樣只要是有兩個參數，且參數類型為int的方法在執行的時候都會執行其相應的通知方法！ 　　 
@Component
@Aspect
public class CaculatorAspect {

      @Before(value="execution(public void com.neuedu.aop.RawCaculatorImpl.*(int, int))")
      public void showBeginLog(){
            System.out.println("日誌開始");
      }

      @After(value="execution(public void com.neuedu.aop.RawCaculatorImpl.*(int, int))")
      public void showReturnLog(){
            System.out.println("日誌正常返回");
      }

      @AfterThrowing(value="execution(public void com.neuedu.aop.RawCaculatorImpl.*(int, int))")
      public void showExceptionLog(){
            System.out.println("日誌有錯");
      }

      @AfterReturning(value="execution(public void com.neuedu.aop.RawCaculatorImpl.*(int, int))")
      public void showAfterLog(){
            System.out.println("日誌最終結束");
      }

}

　　如果方法中的參數類型不一致，可以用 (..) 代替 (int,int)

@Component
@Aspect
public class CaculatorAspect {

     @Pointcut(value="execution(* com.neuedu.aop.RawCaculatorImpl.*(..))")
     public void showLog(){}

      @Before(value="showLog()")
      public void showBeginLog(JoinPoint point){
            Object[] args = point.getArgs();//獲取參數
            List<Object> asList = Arrays.asList(args);//轉為list類型
            Signature signature = point.getSignature();//獲取簽名
            String name = signature.getName();//獲取方法名字
            System.out.println("【前置通知】目標方法名："+name+"，參數為："+asList);
      }

      @After(value="showLog()")
      public void showReturnLog(){
            System.out.println("【後置通知】日誌最終返回");
      }

      @AfterThrowing(value="showLog()",throwing="ex")
      public void showExceptionLog(JoinPoint point,Exception ex){
            System.out.println("【異常通知】異常信息為："+ex.getMessage());
      }

      @AfterReturning(value="showLog()",returning="result")
      public void showAfterLog(JoinPoint point,Object result){
            System.out.println("【返回通知】方法的返回值："+result);
            System.out.println();
      }
}

（2）①切入點表達式的語法格式[參見第5章AOP細節] execution([權限修飾符] [返回值類型] [簡單類名/全類名] [方法名]([參數列表]))

參見第5章AOP細節:演示驗證
1.任意參數，任意類型
2.任意返回值
3.用@PointCut註解統一聲明,然後在其它通知中引用該統一聲明即可！
需要註意的是：權限是不支持寫通配符的，當然你可以寫一個*表示所有權限所有返回值！


最詳細的切入點表達式：
execution(public int com.neuedu.aop.target.MathCalculatorImpl.add(int, int))
最模糊的切入點表達式： execution (* *.*(..)) 第一個 * 代表 權限和返回類型 但是不可以 無權限卻有返回類型 例如： execution(* int com.neuedu.aop.target.MathCalculatorImpl.add(int, int)) 7.統一聲明切入點表達式
@Pointcut(value= "execution(public int com.atguigu.aop.target.EazyImpl.add(int,int))")
public void myPointCut(){}


8.通知方法的細節
　①在通知中獲取目標方法的方法名和參數列表 [1]在通知方法中聲明一個JoinPoint類型的形參 JointPoint 是切入點， [2]調用JoinPoint對象的getSignature()方法獲取目標方法的簽名
[3]調用JoinPoint對象的getArgs()方法獲取目標方法的實際參數列表 
@Before(value="showLog()")
public void showBeginLog(JoinPoint point){
      Object[] args = point.getArgs();//獲取參數
      List<Object> asList = Arrays.asList(args);//轉為list類型
      Signature signature = point.getSignature();//獲取簽名
      String name = signature.getName();//獲取方法名字
      System.out.println("目標方法名："+name+"，參數為："+asList);
      System.out.println("日誌開始");
}
　　 　 ②在返回通知中獲取方法的返回值 [1]在 @AfterReturning 註解中添加returning屬性 [2]在返回通知的通知方法中聲明一個形參，形參名和returning屬性的值一致 不知道返回什麽類型，所以用 Object 類型 
@AfterReturning(value="showLog()",returning="result")
public void showAfterLog(JoinPoint point,Object result){
      System.out.println("方法的返回值："+result);
      System.out.println("日誌正常結束");
      System.out.println();
}
　 　 ③在異常通知中獲取異常對象 [1]在 @AfterThrowing 註解中添加 throwing 屬性 [2]在異常通知的通知方法中聲明一個形參，形參名和throwing屬性值一致 
@AfterThrowing(value="showLog()",throwing="ex")
public void showExceptionLog(JoinPoint point,Exception ex){
      System.out.println("異常信息為："+ex.getMessage());
      System.out.println("日誌有錯");
}

9.根據接口類型獲取target對象時，實際上真正放在IOC容器中的對象是代理對象，而並不是目標對象本身!


10.環繞通知:@Around
1.環繞通知需要在方法的參數中指定JoinPoint的子接口類型ProceedingJoinPoint為參數
@Around(value="pointCut()")
public void around(ProceedingJoinPoint joinPoint){
}
2.環繞通知會將其他4個通知能幹的，自己都給幹了！ 註意:@Around修飾的方法一定要將方法的返回值返回！本身相當於代理！ 但是不知道返回值的類型 ，所以用 Object 
@Around(value="execution(public * com.neuedu.aop.RawCaculatorImpl.*(..))")
public Object showLog(ProceedingJoinPoint point){
      Object[] args = point.getArgs();
      List<Object> asList = Arrays.asList(args);
      Signature signature = point.getSignature();//獲取簽名
      String name = signature.getName();
      Object result=null;
      try {     
            try{
                  System.out.println("【前置通知】目標方法名："+name+"，參數為："+asList);
                  result = point.proceed(args);
             }finally{
                  System.out.println("【後置通知】日誌最終返回");
             }
             System.out.println("【返回通知】方法的返回值："+result);
       } catch (Throwable e) {
             System.out.println("【異常通知】異常信息為："+e.getMessage());
       }
       System.out.println();
       return result;
}
11.切面的優先級
對於同一個代理對象，可以同時有多個切面共同對它進行代理。 可以在切面類上通過@Order (value=50)註解來進行設置，值越小優先級越高! 沒有 @Order 註解默認最大 
@Component
@Aspect
@Order(value=20)
public class BAspect {

      @Around(value="execution(* com.neuedu.aop.RawCaculatorImpl.*(..))")
      public Object showLog(ProceedingJoinPoint point){
            Object[] args = point.getArgs();
            List<Object> asList = Arrays.asList(args);
            Signature signature = point.getSignature();//獲取簽名
            String name = signature.getName();
            Object result=null;
            try {
                  try{
                        System.out.println("【前置】目標方法名："+name+"，參數為："+asList);
                        result = point.proceed(args);
                  }finally{
                        System.out.println("【後置】日誌最終返回");
                  }
                  System.out.println("【返回】方法的返回值："+result);
            } catch (Throwable e) {
                  System.out.println("【異常】異常信息為："+e.getMessage());
            }
            System.out.println();
            return result;
      }
}

12.註意:上面的AOP都是通過註解實現的，AOP實際上也可以通過xml配置的方式實現！ 將註解全刪掉 
<!-- 將需要加載到IOC容器中的bean配置好 -->
<bean id="caculatorAspect" class="com.neuedu.aop.CaculatorAspect"></bean>
<bean id="bAspect" class="com.neuedu.aop.BAspect"></bean>
<bean id="rawCaculatorImpl" class="com.neuedu.aop.RawCaculatorImpl"></bean>

<!-- 配置AOP,需要導入AOP名稱空間 -->
<aop:config>
      <!-- 聲明切入點表達式 -->
      <aop:pointcut expression="execution(* com.neuedu.aop.RawCaculatorImpl.*(..))" id="myPointCut"/>
      <!-- 配置日誌切面類,引用前面的類 ,通過order屬性控制優先級-->
      <aop:aspect ref="caculatorAspect" order="20">
      <!-- 通過method屬性指定切面類的切面方法，通過pointcut-ref指定切入點表達式 -->
             <aop:before method="showBeginLog" pointcut-ref="myPointCut"/>
             <aop:after method="showAfterLog" pointcut-ref="myPointCut"/>
             <aop:after-returning method="showReturnLog" pointcut-ref="myPointCut" returning="result"/>
             <aop:after-throwing method="showExceptionLog" pointcut-ref="myPointCut" throwing="ex"/>
      </aop:aspect>
      <!-- 配置事務切面類,引用前面的類 -->
      <aop:aspect ref="bAspect" order="25">
            <aop:around method="showLog" pointcut-ref="myPointCut"/>
      </aop:aspect>

</aop:config>

需要知道的是：事務的管理是和AOP是有很大關系的,即聲明式事務的底層是用AOP實現的！

Spring（三）--AOP【面向切面編程】、通知類型及使用、切入點表達式

相關推薦

Spring（三）--AOP【面向切面編程】、通知類型及使用、切入點表達式

1.3 一聲 重復 信息 術語 臃腫 lib pac fin 1.概念：Aspect Oriented Programming 面向切面編程 在方法的前後添加方法 2.作用：本質上來說是一種簡化代碼的方式 繼承機制 封裝方法 動態代理

AOP思想(面向切面編程)

動態 用戶 配置 完全 會有 化繁為簡 校驗 bsp 圖片 本文旨在幫助還沒有理解AOP的童鞋看透弄懂AOP，也歡迎高手批評指正。 先說一個Spring是什麽吧，大家都是它是一個框架，但框架這個詞對新手有點抽象，以致於越解釋越模糊，不過它確實是個框架的，但那是從功能的角度來

深入學習Spring框架（三）- AOP面向切面

　　 1.什麼是AOP？ 　　AOP為 Aspect Oriented Programming 的縮寫,即面向切面程式設計, 通過預編譯方式和執行期動態代理實現程式功能的統一維護的一種技術.。AOP是OOP的延續, 是函數語言程式設計的一種衍生範型。利用AOP可以對業務邏輯的各個部分進行隔離, 從而使得業

Spring框架——AOP（面向切面編程）詳解

通過 cts ssi 沒有 object 引入 集中 method 可能 1 AOP概述 ●AOP(Aspect-Oriented Programming，面向切面編程)：是一種新的方法論，是對傳統 OOP(Object-Oriented Programming，面向對象

Spring框架（四）AOP面向切面編程

維護 ng- mem 需要 函數 cti oop classpath 實現 一.前言 在以前的項目中，很少去關註spring aop的具體實現與理論，只是簡單了解了一下什麽是aop具體怎麽用，看到了一篇博文寫得還不錯，就轉載來學習一下，博文地址：http://w

Spring總結六：AOP（面向切面編程）

版本 int run 傳統 代碼 tid contex except unit 概述： 　　AOP（Aspect-Oriented Programming，面向切面的編程），它是可以通過預編譯方式和運行期動態代理實現在不修改源代碼的情況下給程序動態統一添加功能的一種技術。

詳解Spring面向切面編程（AOP)三種實現

安全 認證 基本 -s oop 掃描 編程 data 異常 一、什麽是AOP AOP（Aspect Oriented Programming），即面向切面編程，可以說是OOP（Object Oriented Programming，面向對象編程）的補充和完善。OOP引入封裝

什麽叫AOP（面向切面編程）？

增強 單點 調用 改變 spring 開發 手動 aop思想 生成 spring的AOP面向切面編程，實現在不改變代碼的情況下完成對方法的增強。比較常用的就是spring的聲明式事務管理，底層通過AOP實現，避免了我們每次都要手動開啟事物，提交事務的重復性代碼，使得開發邏輯

面向切面編程（AOP）的理解

bottom 實現原理 cell strong ora max images 處理 style AOP是什麽(Aspect Oriented Programming) AOP是一種編程範式，提供從還有一個角度來考慮程序結構以完好面向對象編程（OOP）。AO

面向切面編程（AOP）

edi public throwable 預編譯 業務 action cati pro eth 1.AOP的簡單理解 　　AOP全稱：Aspect Oriented Programming； 　　面向切面編程是通過預編譯方式和運行期動態代理的方式實現程序功能的統一維護的一種

【spring源碼學習】spring的AOP面向切面編程的實現解析

內部 遠程調用 關註 add aps 文件 uem 連接 row 一：Advice(通知)（1）定義在連接點做什麽，為切面增強提供織入接口。在spring aop中主要描述圍繞方法調用而註入的切面行為。（2）spring定義了幾個時刻織入增強行為的接口??=>org.

JavaScript實現AOP（面向切面編程）

body 原本 實現 bsp pro 出發點 log doc 帶來 什麽是AOP？ 　　AOP(面向切面編程)的主要作用是把一些跟核心業務邏輯模塊無關的功能抽離出來，這些跟業務邏輯無關的功能通常包括日誌統計、安全控制、異常處理等。把這些功能抽離出來之後， 再通過“動態織入”

Spring入門（三）— AOP註解、jdbc模板、事務

list() 規範 行數 get attribute 樂觀鎖 過濾 callback 賬號 一、AOP註解開發 導入jar包 aop聯盟包、 aspectJ實現包 、 spring-aop-xxx.jar 、 spring-aspect-xxx.jar 導入約束 a

理解AOP思想（面向切面編程）

通用 理解 load 配置 裏的 oschina 什麽 ram .cn AOP：面向切面編程，相信很多剛接觸這個詞的同行都不是很明白什麽，百度一下看到下面這幾句話： 在軟件業，AOP為Aspect Oriented Programming的縮寫，意為：面向切面編程，通過預編

面試題思考：解釋一下什麽叫AOP（面向切面編程）

一起 enable npoi rec creating ESS cor fault RoCE 這種在運行時，動態地將代碼切入到類的指定方法、指定位置上的編程思想就是面向切面的編程。 AOP是Spring提供的關鍵特性之一。AOP即面向切面編程，是OOP編程的有效補充。 使用

spring面向切面編程示例（xml配置形式vs@註解形式）

org .com frame 當前 分享圖片 tro wired 示例 img 一、xml配置形式 1、在Spring配置文件中增加面向切面配置當調用com.activemq.service.impl.ConsumerServiceImpl接口實現類的任意方法時執行切面類中

spring基礎（3：面向切面編程）

我們 流程 無需 word 圖片 ESS 做的 type 容器 一.面向切面編程 ??Spring的基礎是IOC和AOP，前面兩節對IOC和DI做了簡單總結，這裏再對AOP進行一個學習總結，Spring基礎就算有一個初步了解了。 ??在軟件開發中，我們可能需要一些跟業務無關

Spring框架（三）AOP

 AOP為了解決動態代理的繁瑣，而產生的一種方便實現動態代理的簡單框架 動態代理簡單的來說就是將經常要用，重複的程式碼放到一個代理類裡，在其他類裡面呼叫就行，不用再每次重複寫。 1.將要下載的包放到pom.xml裡面 <?xml version="1.0"?> &l

【Spring】每個程式設計師都使用Spring（四）——Aop+自定義註解做日誌攔截

一、前言       上一篇部落格向大家介紹了Aop的概念，對切面=切點+通知 、連線點、織入、目標物件、代理（jdk動態代理和CGLIB代理）有所瞭解了。理論很強，實用就在這篇部落格介紹。       這篇部落格中，小編向大家介紹springAop很常見的

Spring原始碼學習筆記（三）AOP實現

Spring-AOP入口 <aop:aspectj-autoproxy /> 這一段程式碼，是實現AOP的具體入口，發現不是bean標籤則會使用不同的類進行解析，http\：//www.springframework.org/sc