2. 程式人生 > >Spring AOP的用法

Spring AOP的用法

阿新 • • 發佈：2017-10-20
val around 技術 pac factor 日常 三種方式 viso 可復用

AOP在事務處理、日誌、安全等方面用的很多，在日常軟件定制開發中，用好AOP可以進一步解耦，增強代碼的可復用性。平時用的最多的還是Spring AOP動態代理，其用法如下：

第一種實現的方式：通過Spring的API實現AOP。

第一步：
  1. public interface UserService {
  2. public void add();
  3. public void update(int a);
  4. public void delete();
  5. public void search();
  6. }
第二步：
  1. public class UserServiceImpl implements UserService {
  3. @Override
  4. public void add() {
  5. System.out.println("增加用戶");
  6. }
  8. @Override
  9. public void update(int a) {
  10. System.out.println("修改用戶");
  11. }
  13. @Override
  14. public void delete() {
  15. System.out.println("刪除用戶");
  16. }
  18. @Override
  19. public void search() {
  20. System.out.println("查詢用戶");
  21. }
第三步：實現MethodBeforeAdvice的接口，Spring框架當中為我們提供了很多中通知。
  1. public class Log implements MethodBeforeAdvice{
  2. /**
  3. * @param method 被調用方法對象
  4. * @param args 被調用的方法的參數
  5. * @param target 被調用的方法的目標對象
  6. * */
  7. @Override
  8. public void before(Method method, Object[] args, Object target)
  9. throws Throwable {
  10. System.out.println(target.getClass().getName()+"的"+method.getName()+"方法被執行");
  11. }
  12. }
第四步：配置beans.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. <bean id="userService" class="com.spring.service.impl.UserServiceImpl"/>
  10. <!-- 這個切面也要配置成bean-->
  11. <bean id="log" class="com.spring.advice.Log"/>
  12. <aop:config>
  13. <!--切入點，需要告訴方法在什麽去執行
  14. expression="execution(* com.spring.service.impl.*.*(..))"
  15. 第一個* 表示所有的返回值，然後就是包名
  16. 第二個*表示所有的類對象
  17. 第三個*表示類對象所有的方法
  18. 第四個*表示所有方法下面的帶參數的方法或者是不帶參數的方法
  19. -->
  20. <aop:pointcut expression="execution(* com.spring.service.impl.*.*(..))" id="pointcut"/>
  21. <!-- 在所有的方法中都切入前置通知-->
  22. <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
  23. </aop:config>
  24. </beans>
第五步：測試：
  1. package com.spring.test;
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;
  6. import com.spring.service.UserService;
  8. public class Test {
  9. public static void main(String[] args) {
  10. ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
  11. UserService userService = (UserService)ac.getBean("userService");
  12. userService.update(2);
  13. userService.add();
  14. }
  15. }
運行結果：
  1. 三月 12, 2017 2:22:44 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
  2. 信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@439f5b3d: startup date [Sun Mar 12 14:22:44 GMT+08:00 2017]; root of context hierarchy
  3. 三月 12, 2017 2:22:44 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
  4. 信息: Loading XML bean definitions from class path resource [beans.xml]
  5. com.spring.service.impl.UserServiceImpl的update方法被執行
  6. 修改用戶
  7. com.spring.service.impl.UserServiceImpl的add方法被執行
  8. 增加用戶
故前置通知可以在spring當中被執行，接下可以完善通知;
  1. public class AfterLog implements AfterReturningAdvice{
  2. /**
  3. * 目標方法執行後執行的通知
  4. * returnValue--返回值
  5. * method 被調用的方法對象
  6. * args 被調用的方法對象的參數
  7. * target 被調用的方法對象的目標對象
  8. * */
  9. @Override
  10. public void afterReturning(Object returnValue, Method method,
  11. Object[] args, Object target) throws Throwable {
  12. System.out.println(target.getClass().getName()+"的"+method.getName()+"被成功執行，返回值是："+returnValue);
  13. }
  14. }
  2. import java.lang.reflect.Method;
  4. import org.springframework.aop.ThrowsAdvice;
  6. public class ExceptionLog implements ThrowsAdvice {
  7. public void afterThrowing(Method method,Exception ex) throws Throwable {
  8. }
  10. }
重新配置：
  1. <!-- 這個切面也要配置成bean-->
  2. <bean id="log" class="com.spring.advice.Log"/>
  3. <bean id="afterLog" class="com.spring.advice.AfterLog"></bean>
  4. <aop:config>
  5. <!--切入點，需要告訴方法在什麽去執行
  6. expression="execution(* com.spring.service.impl.*.*(..))"
  7. 第一個* 表示所有的返回值，然後就是包名
  8. 第二個*表示所有的類對象
  9. 第三個*表示類對象所有的方法
  10. 第四個*表示所有方法下面的帶參數的方法或者是不帶參數的方法
  11. -->
  12. <aop:pointcut expression="execution(* com.spring.service.impl.*.*(..))" id="pointcut"/>
  13. <!-- 在所有的方法中都切入前置通知-->
  14. <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
  15. <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
  16. </aop:config>
測試運行結果：
  1. 三月 12, 2017 2:28:19 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
  2. 信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@439f5b3d: startup date [Sun Mar 12 14:28:19 GMT+08:00 2017]; root of context hierarchy
  3. 三月 12, 2017 2:28:19 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
  4. 信息: Loading XML bean definitions from class path resource [beans.xml]
  5. com.spring.service.impl.UserServiceImpl的update方法被執行
  6. 修改用戶
  7. com.spring.service.impl.UserServiceImpl的update被成功執行，返回值是：null
  8. com.spring.service.impl.UserServiceImpl的add方法被執行
  9. 增加用戶
  10. com.spring.service.impl.UserServiceImpl的add被成功執行，返回值是：null
總結：AOP的重要性，非常重要 Spring的AOP就是將公共的業務（如日誌，安全等）和業務類結合。當執行業務的時候將會把公共業務加進來。實現公共業務的重復利用。我們自己的業務就會變得更加的純粹，我們就可以關註我們的自己的業務，本質就是動態代理。 第二種方式：自定義類來實現AOP，不實現spring的自帶的通知 第一步：重新通知：
  1. public class Log {
  3. public void before(){
  4. System.out.println("方法執行前");
  5. }
  6. public void after(){
  7. System.out.println("方法執行後");
  8. }
  9. }
第二步：重新寫配置文件
  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. <bean id="userService" class="com.spring.service.impl.UserServiceImpl"/>
  10. <!-- 這個切面也要配置成bean-->
  11. <bean id="log" class="com.spring.advice.Log"/>
  12. <aop:config>
  13. <!--切入點，需要告訴方法在什麽去執行
  14. expression="execution(* com.spring.service.impl.*.*(..))"
  15. 第一個* 表示所有的返回值，然後就是包名
  16. 第二個*表示所有的類對象
  17. 第三個*表示類對象所有的方法
  18. 第四個*表示所有方法下面的帶參數的方法或者是不帶參數的方法
  19. -->
  20. <aop:aspect ref="log">
  21. <aop:pointcut expression="execution(* com.spring.service.impl.*.*(..))" id="pointcut"/>
  22. <aop:before method="before" pointcut-ref="pointcut"/>
  23. <aop:after method="after" pointcut-ref="pointcut"/>
  24. </aop:aspect>
  25. </aop:config>
  26. </beans>
第三種方式：通過註解實現AOP 第一步：修改log
  1. package com.spring.advice;
  3. import java.lang.reflect.Method;
  5. import org.aspectj.lang.ProceedingJoinPoint;
  6. import org.aspectj.lang.annotation.After;
  7. import org.aspectj.lang.annotation.Around;
  8. import org.aspectj.lang.annotation.Aspect;
  9. import org.aspectj.lang.annotation.Before;
  10. import org.springframework.aop.MethodBeforeAdvice;
  12. @Aspect
  13. public class Log {
  15. @Before("execution(* com.spring.service.impl.*.*(..))")
  16. public void before(){
  17. System.out.println("方法執行前");
  18. }
  19. @After("execution(* com.spring.service.impl.*.*(..))")
  20. public void after(){
  21. System.out.println("方法執行後");
  22. }
  23. @Around("execution(* com.spring.service.impl.*.*(..))")
  24. public Object around(ProceedingJoinPoint jp) throws Throwable{
  26. System.out.println("環繞前");
  27. System.out.println("方法"+jp.getSignature());
  28. Object result=jp.proceed();
  29. System.out.println("環繞後");
  30. return result;
  31. }
  32. }
第二步：修改beans.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. <bean id="userService" class="com.spring.service.impl.UserServiceImpl"/>
  10. <!-- 這個切面也要配置成bean-->
  11. <bean id="log" class="com.spring.advice.Log"/>
  12. <aop:aspectj-autoproxy/>
  13. </beans>
第三步：運行：
  1. 三月 12, 2017 3:00:02 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
  2. 信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@439f5b3d: startup date [Sun Mar 12 15:00:02 GMT+08:00 2017]; root of context hierarchy
  3. 三月 12, 2017 3:00:02 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
  4. 信息: Loading XML bean definitions from class path resource [beans.xml]
  5. 環繞前
  6. 方法void com.spring.service.UserService.update(int)
  7. 方法執行前
  8. 修改用戶
  9. 環繞後
  10. 方法執行後

Spring總結（五）--Spring中使用AOP三種方式

裏面最關鍵的切面配置如下：

技術分享

Spring AOP的用法

相關推薦

Java Spring AOP用法

切面 itl joinpoint edi long 定位 後置 spa -m spring提供了兩個核心功能，一個是IoC(控制反轉)，另外一個便是Aop(面向切面編程)，IoC有助於應用對象之間的解耦，AOP則可以實現橫切關註點（如日誌、安全、緩存和事務管理）與他們所影響

Spring AOP用法詳解

trace 方法名 java 範式 advice work 配對 中文翻譯 roc 什麽是AOP AOP：Aspect Oriented Programming，中文翻譯為”面向切面編程“。面向切面編程是一種編程範式，它作為OOP面向對象編程的一種補充，用於處理系統中分布於

Spring AOP的用法

val around 技術 pac factor 日常 三種方式 viso 可復用 AOP在事務處理、日誌、安全等方面用的很多，在日常軟件定制開發中，用好AOP可以進一步解耦，增強代碼的可復用性。平時用的最多的還是Spring AOP動態代理，其用法如下： 第一種實現

Spring AOP切點表達式用法總結

情況 cut 需要 xml文件 表示 標註 blog 封裝 HR 1. 簡介 面向對象編程，也稱為OOP（即Object Oriented Programming）最大的優點在於能夠將業務模塊進行封裝，從而達到功能復用的目的。通過面向對象編程，不同的模板可以相

說一說 Spring AOP 中 @Aspect 的高階用法

1 切點複合運算 支援在切點定義中加入以下運算子進行復合運算： 運算子 說明 && 與運算。 ! 非運算。 || 或運算。 2 切點命名 一般情況下，切點是直接宣告在需要增強方法處，這種切點的宣告方式稱為匿名切點，匿名切點只能在宣告處被使用 。

《Spring 5官方文件》37. Spring AOP的經典用法

原文連結 在本附錄中，我們會討論一些初級的Spring AOP介面，以及在Spring 1.2應用中所使用的AOP支援。 對於新的應用，我們推薦使用 Spring AOP 2.0來支援，在AOP章節有介紹。但在已有的專案中，或者閱讀資料或者文章時，可能會遇到Spring AOP 1.2風格的示

spring AOP獲取切面方法資訊 JoinPoint的用法

JoinPoint 物件 封裝了SpringAop中切面方法的資訊,在切面方法中新增JoinPoint引數,就可以獲取到封裝該方法資訊的物件 常用api ; 方法名 功能 Signature getSignature();

談談Spring AOP中@Aspect的高階用法示例

前言 本文主要跟大家分享介紹了關於Spring AOP中@Aspect的高階用法，下面話不多說了，來隨著小編一起看看詳細的介紹吧。 1 切點複合運算 支援在切點定義中加入以下運算子進行復合運算： 運算子 說明 && 與運算。 !

Spring -- AOP入門基礎&基於Aspect的AOP通知用法

動態代理 我們在日常開發過程中是否會遇到下圖中的這種狀況 紅框中的是我們要輸出的日誌，你是否發現，日誌中大部分資訊都是相同的，並且如果我們要修改一個地方，所有的地方都需要改，而且程式碼看起來還比較冗餘 下面我們就可以通過動態代理的方式解決這個問題 看

說說 Spring AOP 中 @Aspect 的高階用法

1 切點複合運算 支援在切點定義中加入以下運算子進行復合運算： 運算子 說明 && 與運算。 ! 非運算。 || 或運算。 2 切點命名 一般情況下，切點是直接宣告在需要增強方

spring AOP pointcut 詳細用法

1.首先這是我幾天來對切面的程式設計的理解，之前有稍微學了下 spring切面的程式設計，spring中事物處理常常與pointcut相結合。 pointcut的註解型別 表示式 我就不多說了 。具體可以看spring文件的第199頁~200頁，都比較簡單。 大體上是這樣

Spring AOP 實現原理

pri ack more .net style 實現原理 cor http details Spring AOP 實現原理Spring AOP 實現原理

Spring Aop Annotation

ava rgs implement star nco pos over value resource 實體: 1 package com.bxw.aop.vo; 2 3 public class User { 4 private String logi

Spring AOP實驗之靜態代理

註入 ans 執行 軟件開發 動態代理 sin modified 實現 編譯 1 AOP的概念和原理 1.1 AOP原理 　　AOP(Aspect Oriented Programming)，也就是面向方面編程的技術。AOP基於IoC基礎，是對OOP的有益補充。 　　

深入理解Spring AOP之二代理對象生成

gets code 網上 none work class als post 產生 深入理解Spring AOP之二代理對象生成 spring代理對象 上一篇博客中講到了Spring的一些基本概念和初步講了實現方

Spring AOP之 動態代理實例

delete 日誌 實現類 imp exc print cati user ins 1.項目結構圖如下3.3.3.1: 圖3.3.3.1 2.IUserServ接口代碼與UserServImpl實現類代碼和上述代碼相同 3.LogHandler類代碼

Spring Aop總結

join spring容器 其他 新的 conf 註解 基於 prop 參數 一.Spring介紹 Spring它是一個一站式的分層輕量級框架1.Spring體系結構 1.core container a) beans與core他們提供sping框架最基本的功能，它包含i

spring---aop（3）---Spring AOP的攔截器鏈

ati handler 攔截器 odi hand zab chain 記載 封裝 寫在前面 　　時間斷斷續續，這次寫一點關於spring aop攔截器鏈的記載。至於如何獲取spring的攔截器，前一篇博客已經寫的很清楚（spring---aop（2）---Spring AO

Spring AOP詳解

開發 blank 關註 proxy 系統 frame main函數 lns 功能 一.前言 在以前的項目中，很少去關註spring aop的具體實現與理論，只是簡單了解了一下什麽是aop具體怎麽用，看到了一篇博文寫得還不錯，就轉載來學習一下，博文地址：htt

Spring--AOP 例子

結束 oaf signature 日誌 類加載器 lis 能說 ssi system 先用代碼講一下什麽是傳統的AOP(面向切面編程)編程 需求：實現一個簡單的計算器，在每一步的運算前添加日誌。最傳統的方式如下： Calculator.Java [java] vie