2. 程式人生 > >Spring--AOP 例子

Spring--AOP 例子

阿新 • • 發佈：2017-07-14
結束 oaf signature 日誌 類加載器 lis 能說 ssi system

先用代碼講一下什麽是傳統的AOP(面向切面編程)編程

需求：實現一個簡單的計算器，在每一步的運算前添加日誌。最傳統的方式如下：

Calculator.Java

[java] view plain copy print?
  1. package cn.limbo.spring.aop.calculator;
  3. /**
  4. * Created by Limbo on 16/7/14.
  5. */
  6. public interface Calculator {
  7. int add(int i , int j);
  8. int sub(int i , int j);
  9. int mul(int i , int j);
  10. int div(int i , int j);
  11. }

CalculatorImpl.java

[java] view plain copy print?
  1. package cn.limbo.spring.aop.calculator;
  3. /**
  4. * Created by Limbo on 16/7/14.
  5. */
  6. public class CalculatorImpl implements Calculator {
  7. @Override
  8. public int add(int i, int j) {
  9. System.out.println("The method add begin with [ "+ i +"," + j+" ]");
  10. System.out.println("The method add end with [ "+ i +"," + j+"]");
  11. return i + j;
  12. }
  14. @Override
  15. public int sub(int i, int j) {
  16. System.out.println("The method sub begin with [ "+ i +"," + j+" ]");
  17. System.out.println("The method sub end with [ "+ i +"," + j+" ]");
  18. return i - j;
  19. }
  21. @Override
  22. public int mul(int i, int j) {
  23. System.out.println("The method mul begin with [ "+ i +"," + j+" ]");
  24. System.out.println("The method mul end with [ "+ i +"," + j+" ]");
  25. return i * j;
  26. }
  28. @Override
  29. public int div(int i, int j) {
  30. System.out.println("The method div begin with [ "+ i +"," + j+" ]");
  31. System.out.println("The method div end with [ "+ i +"," + j+" ]");
  32. return i / j;
  33. }
  34. }

這樣就完成了需求，但是我們發現，倘若是要修改日誌的信息，那麽就需要在具體方法裏面改，這樣做很麻煩，而且把原本清爽的方法改的十分混亂，方法應該表現的是核心功能，而不是這些無關緊要的關註點，下面用原生的java的方式實現在執行方法時，動態添加輸出日誌方法

CalculatorImpl.java

[java] view plain copy print?
  1. package cn.limbo.spring.aop.calculator;
  3. /**
  4. * Created by Limbo on 16/7/14.
  5. */
  6. public class CalculatorImpl implements Calculator {
  7. @Override
  8. public int add(int i, int j) {
  9. return i + j;
  10. }
  12. @Override
  13. public int sub(int i, int j) {
  14. return i - j;
  15. }
  17. @Override
  18. public int mul(int i, int j) {
  19. return i * j;
  20. }
  22. @Override
  23. public int div(int i, int j) {
  24. return i / j;
  25. }
  26. }


CalculatorLoggingProxy.java

[java] view plain copy print?
  1. package cn.limbo.spring.aop.calculator;
  4. import java.lang.reflect.InvocationHandler;
  5. import java.lang.reflect.Method;
  6. import java.lang.reflect.Proxy;
  7. import java.util.Arrays;
  8. import java.util.Objects;
  10. /**
  11. * Created by Limbo on 16/7/14.
  12. */
  13. public class CalculatorLoggingProxy {
  15. //要代理的對象
  16. private Calculator target;
  18. public CalculatorLoggingProxy(Calculator target) {
  19. this.target = target;
  20. }
  22. public Calculator getLoggingProxy(){
  24. //代理對象由哪一個類加載器負責加載
  25. ClassLoader loader = target.getClass().getClassLoader();
  26. //代理對象的類型,即其中有哪些方法
  27. Class[] interfaces = new Class[]{Calculator.class};
  28. // 當調用代理對象其中的方法時,執行改代碼
  29. InvocationHandler handler = new InvocationHandler() {
  30. @Override
  31. /**
  32. * proxy:正在返回的那個對象的代理,一般情況下,在invoke方法中不使用該對象
  33. * method:正在被調用的方法
  34. * args:調用方法時,傳入的參數
  35. */
  36. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  37. String methodName = method.getName();
  38. System.out.println("The method " + methodName + " begins with " + Arrays.asList(args));
  39. //日誌
  40. Object result = method.invoke(target,args);
  41. System.out.println("The method " + methodName + " ends with " + result);
  43. return result;
  44. }
  45. };
  46. Calculator proxy = (Calculator) Proxy.newProxyInstance(loader,interfaces,handler);
  48. return proxy;
  49. }
  51. }


Main.java

[java] view plain copy print?
  1. package cn.limbo.spring.aop.calculator;
  3. /**
  4. * Created by Limbo on 16/7/14.
  5. */
  6. public class Main {
  7. public static void main(String[] args) {
  8. Calculator calculator = new CalculatorImpl();
  9. Calculator proxy = new CalculatorLoggingProxy(calculator).getLoggingProxy();
  11. int result = proxy.add(1,2);
  12. System.out.println("--->" + result);
  14. result = proxy.sub(1,2);
  15. System.out.println("--->" + result);
  17. result = proxy.mul(3,2);
  18. System.out.println("--->" + result);
  20. result = proxy.div(14,2);
  21. System.out.println("--->" + result);
  22. }
  23. }


這樣寫雖然已經簡化了代碼，而且可以任意修改日誌信息代碼，但是寫起來還是很麻煩！！！

下面我們使用spring自帶的aop包實現但是要加入

com.springsource.org.aopalliance-1.0.0.jar
com.springsource.org.aspectj.weaver-1.8.5.RELEASE.jar

這兩個額外的包

下面看代碼，要點全部卸載代碼裏面了

Calculator.java

[java] view plain copy print?
  1. package cn.limbo.spring.aop.impl;
  3. /**
  4. * Created by Limbo on 16/7/14.
  5. */
  6. public interface Calculator {
  7. int add(int i, int j);
  8. int sub(int i, int j);
  9. int mul(int i, int j);
  10. int div(int i, int j);
  11. }

CalculatorImpl.java

[java] view plain copy print?
  1. package cn.limbo.spring.aop.impl;
  3. import org.springframework.stereotype.Component;
  5. /**
  6. * Created by Limbo on 16/7/14.
  7. */
  8. @Component("calculatorImpl")
  9. public class CalculatorImpl implements Calculator {
  10. @Override
  11. public int add(int i, int j) {
  12. return i + j;
  13. }
  15. @Override
  16. public int sub(int i, int j) {
  17. return i - j;
  18. }
  20. @Override
  21. public int mul(int i, int j) {
  22. return i * j;
  23. }
  25. @Override
  26. public int div(int i, int j) {
  27. return i / j;
  28. }
  29. }

LoggingAspect.java

[java] view plain copy print?
  1. package cn.limbo.spring.aop.impl;
  3. import org.aspectj.lang.JoinPoint;
  4. import org.aspectj.lang.ProceedingJoinPoint;
  5. import org.aspectj.lang.annotation.*;
  6. import org.springframework.core.annotation.Order;
  7. import org.springframework.stereotype.Component;
  9. import java.util.Arrays;
  10. import java.util.List;
  11. import java.util.Objects;
  13. /**
  14. * Created by Limbo on 16/7/14.
  15. */
  16. //把這個類聲明為切面:需要該類放入IOC容器中,再聲明為一個切面
  17. @Order(0)//指定切面優先級,只越小優先級越高
  18. @Aspect
  19. @Component
  20. public class LoggingAspect {
  22. /**
  23. * 定義一個方法,用於聲明切入點表達式,一般的,該方法中再不需要添加其他代碼
  24. * 主要是為了重用路徑,[email protected]
  25. * 後面的其他通知直接使用方法名來引用當前的切入點表達式
  26. */
  27. @Pointcut("execution(* cn.limbo.spring.aop.impl.Calculator.*(..))")
  28. public void declareJointPointExpression()
  29. {
  31. }
  34. //聲明該方法是一個前置通知:在目標方法之前執行
  35. @Before("declareJointPointExpression()")
  36. // @Before("execution(* cn.limbo.spring.aop.impl.*.*(..))") 該包下任意返回值,任意類,任意方法,任意參數類型
  37. public void beforeMethod(JoinPoint joinPoint)
  38. {
  39. String methodName = joinPoint.getSignature().getName();
  40. List<Object> args = Arrays.asList(joinPoint.getArgs());
  41. System.out.println("The Method "+ methodName+" Begins With " + args);
  42. }
  43. //在目標方法執行之後執行,無論這個方法是否出錯
  44. //在後置通知中還不能訪問目標方法的返回值,只能通過返回通知訪問
  45. @After("execution(* cn.limbo.spring.aop.impl.Calculator.*(int,int))")
  46. public void afterMethod(JoinPoint joinPoint)
  47. {
  48. String methodName = joinPoint.getSignature().getName();
  49. System.out.println("The Method "+ methodName+" Ends ");
  50. }
  52. /**
  53. * 在方法正常結束後執行的代碼
  54. * 返回通知是可以訪問到方法的返回值
  55. */
  56. @AfterReturning(value = "execution(* cn.limbo.spring.aop.impl.Calculator.*(..))",returning = "result")
  57. public void afterReturning(JoinPoint joinPoint , Object result)
  58. {
  59. String methodName = joinPoint.getSignature().getName();
  60. System.out.println("The Method " + methodName + " Ends With " + result);
  61. }
  64. /**
  65. *在目標方法出現異常的時候執行代碼
  66. * 可以訪問異常對象,且可以指定出現特定異常時再執行通知
  67. */
  68. @AfterThrowing(value = "execution(* cn.limbo.spring.aop.impl.Calculator.*(..))",throwing = "ex")
  69. public void afterThrowing(JoinPoint joinPoint,Exception ex)//Exception 可以改成 NullPointerException等特定異常
  70. {
  71. String methodName = joinPoint.getSignature().getName();
  72. System.out.println("The Method " + methodName + " Occurs With " + ex);
  73. }
  75. /**
  76. * 環繞通知需要ProceedingJoinPoint 類型參數 功能最強大
  77. * 環繞通知類似於動態代理的全過程:ProceedingJoinPoint 類型的參數可以決定是否執行目標方法
  78. * 且環繞通知必須有返回值,返回值即為目標方法的返回值
  79. */
  80. @Around("execution(* cn.limbo.spring.aop.impl.Calculator.*(..))")
  81. public Object aroundMethod(ProceedingJoinPoint proceedingJoinPoint)
  82. {
  83. Object result =null;
  84. String methodName = proceedingJoinPoint.getSignature().getName();
  85. try {
  86. //前置通知
  87. System.out.println("The Method " + methodName + " Begins With " + Arrays.asList(proceedingJoinPoint.getArgs()));
  88. result = proceedingJoinPoint.proceed();
  89. // 返回通知
  90. System.out.println("The Method " + methodName + " Ends With " + result);
  91. } catch (Throwable throwable) {
  92. //異常通知
  93. throwable.printStackTrace();
  94. }
  95. System.out.println("The Method " + methodName + " Ends ");
  96. return result;
  97. }
  98. }



applicationContext.xml

[html] view plain copy print?
  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:context="http://www.springframework.org/schema/context"
  5. xmlns:aop="http://www.springframework.org/schema/aop"
  6. 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/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
  7. <!--配置自動掃描的包-->
  8. <context:component-scan base-package="cn.limbo.spring.aop.impl"></context:component-scan>
  10. <!--使Aspect註解起作用,自動為匹配的類生成代理對象-->
  11. <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
  14. </beans>

用xml來配置aop

application-config.xml

[html] view plain copy print?
  1. <?xml version="1.0" encoding="UTF-8"?>
  3. <beans xmlns="http://www.springframework.org/schema/beans"
  4. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5. xmlns:aop="http://www.springframework.org/schema/aop"
  6. xmlns:tx="http://www.springframework.org/schema/tx"
  7. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
  8. http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
  9. http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
  12. <bean id="userManager" class="com.tgb.aop.UserManagerImpl"/>
  14. <!--<bean id="aspcejHandler" class="com.tgb.aop.AspceJAdvice"/>-->
  15. <bean id="xmlHandler" class="com.tgb.aop.XMLAdvice" />
  16. <aop:config>
  17. <aop:aspect id="aspect" ref="xmlHandler">
  18. <aop:pointcut id="pointUserMgr" expression="execution(* com.tgb.aop.*.find*(..))"/>
  20. <aop:before method="doBefore" pointcut-ref="pointUserMgr"/>
  21. <aop:after method="doAfter" pointcut-ref="pointUserMgr"/>
  22. <aop:around method="doAround" pointcut-ref="pointUserMgr"/>
  23. <aop:after-returning method="doReturn" pointcut-ref="pointUserMgr"/>
  24. <aop:after-throwing method="doThrowing" throwing="ex" pointcut-ref="pointUserMgr"/>
  26. </aop:aspect>
  27. </aop:config>
  28. </beans>



一共有5類的通知，其中around最為強大，但是不一定最常用，aspect的底層實現都是通過代理來實現的，只能說這個輪子造的不錯

2016.12.09更新

最近在實際項目中配置aop發現了幾個問題，實際的項目配置的的模式是ssh即Spring4+SpringMVC+Hibernate4的模式。

基於註解的方式配置方式有些坑點：

1.發現SpringMVC中aop不起任何作用

經過排查和查找網上的資料，發現問題如下：

Spring MVC啟動時的配置文件，包含組件掃描、url映射以及設置freemarker參數，[email protected]設置？因為springmvc.xml與applicationContext.xml不是同時加載，如果不進行這樣的設置，那麽，[email protected]，等到加載applicationContext.xml的時候，會因為容器已經存在Service類，使得cglib將不對Service進行代理，直接導致的結果就是在applicationContext 中的事務配置不起作用，發生異常時，無法對數據進行回滾。以上就是原因所在。

所以改進後的applicationContext.xml如下（只是更改自動掃描包的那個配置）：

[html] view plain copy print?
  1. <context:component-scan base-package="cn.limbo">
  2. <!--不要將Controller掃進來，否則aop無法使用-->
  3. <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" />
  4. </context:component-scan>


spring-mvc.xml掃描包配置如下：

[html] view plain copy print?
  1. <context:component-scan base-package="cn.limbo">
  2. <!--不要將Service掃進來，否則aop無法使用-->
  3. <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service" />
  4. </context:component-scan>

這樣就可以成功解決ssh配置下不能使用aop的情況。看來掃描包的時候不能暴力直接全部掃描進來啊，真是成也掃描，敗也掃描，手動哭笑不得。

Spring--AOP 例子

相關推薦

Spring--AOP 例子

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

zbb20180824 spring ioc aop 例子

nature release build index bean result method 控制 prope zbb_ioc_aop https://pan.baidu.com/disk/home#/all?vmode=list&path=%2Fcode%2

Spring AOP增強小例子

[java]  view plain  copy public interface ISomeService  { 

Spring AOP動態代理例子

對Oracle資料庫的部門表進行增刪改查： 話不多說； 1.實體類可以不寫.hbm.xml檔案直接寫註解方式： package com.jadeon.entity; import java.io.Serializable; import javax.persisten

Spring Aop 簡單例子

bean.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="htt

一個簡單的Spring的AOP例子

 1<?xml version="1.0" encoding="UTF-8"?> 2<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"&

通過例子全面解析Java中的Aop技術-包括靜態代理，動態代理，Spring Aop(全面解析，附帶全部原始碼，小白看一遍也可以理解)

AOP概述（Aspect Oriented Programming）所謂AOP,就是面向方面(切面)的程式設計，簡單來說，就是通過面向切面，在執行的方法前後加上所需要實現的事情，比如，日誌，計算方法執行的時間，實現事務等。這樣做的目的一方面在於不改變原有程式碼，提高通用性，最

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 @Before @Around @After 等 advice 的執行順序

繼續 case tco ann cto order software clas spec 用過spring框架進行開發的人，多多少少會使用過它的AOP功能，都知道有@Before、@Around和@After等advice。最近，為了實現項目中的輸出日誌和權限控制這兩個需求

spring AOP

切入點 動作 3.1 插入 3.2 implement bject version com 本節要點： 掌握AOP概念 掌握AOP的有關術語 掌握spring AOP框架的實現方式 在文章“spring靜態代理和動態代理”中演示了如何使用jdk動態代理功能實現一個最

Spring技術內幕：Spring AOP的實現原理（三）

dede ide configure ida mini == src min dem 生成SingleTon代理對象在getSingleTonInstance方法中完畢，這種方法時ProxyFactoryBean生成AopProxy對象的入口。代理對象會

spring-aop

private 我們 數據 pri evaluate users ica led 設計 聊spring-aop之前，先來看一下Aspectj的使用 Aspectj 從http://www.eclipse.org/aspectj/downloads.php下載好aspectj

spring-AOP之通知和顧問

多個 targe ges 配置 context color ive 後置 功能 通知和顧問都是切面的實現形式，其中通知可以完成對目標對象方法簡單的織入功能。 而顧問包裝了通知，可以讓我們對通知實現更加精細化的管理，讓我們可以指定具體的切入點。 通知分為前置通知，環繞通知及後