Spring面向切面程式設計的三種方式以及常用相關案例總結
Spring面向切面程式設計
==================================================
spring面向切面程式設計的方法之一：實現介面方式
1.執行前增強：MethodBeforeAdvice介面
標示方法：public void before(Method arg0, Object[] arg1, Object arg2){}
Method arg0----目標方法, Object[] arg1----方法中的引數, Object arg2----目標物件
2.執行後增強：AfterReturningAdvice介面
標示方法：public void afterReturning(Object arg0, Method arg1, Object[] arg2,Object arg3) throws Throwable {}
Object arg0-----返回值, Method arg1----目標方法, Object[] arg2----方法中的引數,Object arg3----目標物件
3.異常丟擲時增強：ThrowAdvice介面
標示方法：public void afterThrowing(Method method, Object[] args, Object target,SQLException ex) {}
Method method----目標方法, Object[] args----方法中的引數, Object target----目標物件,SQLException ex------特定的異常物件，即該異常時才會使用增強方法
4.環繞增強：MethodInterceptor
標示方法：public Object invoke(MethodInvocation arg0) throws Throwable {}
Object target = arg0.getThis(); // 獲取被代理物件
Method method = arg0.getMethod(); // 獲取被代理方法
Object[] args = arg0.getArguments(); // 獲取方法引數
Object result = arg0.proceed(); // 呼叫目標方法，獲取目標方法返回值--------注意丟擲異常，用來定義異常是的輸出。
5.使用的是
<bean id="beforeAdvice" class="com.yunhe.aspect.BeforeAdvice"></bean>
<aop:config>
<aop:pointcut expression="execution(* com.yunhe.biz.*.*(..))" id="pc1"/>
<aop:advisor advice-ref="beforeAdvice" pointcut-ref="pc1"/>
</aop:config>
==================================================
spring面向切面程式設計的方法之二：註解方式
1.使用@Aspect標示類，表明該類是使用註解是實現增強
2.執行前增強：@Before("execution(* biz.IUserBiz.*(..))")
標示方法：public void before() {}
3.執行後增強：@AfterReturning("execution(* biz.IUserBiz.*(..))")
標示方法：public void afterReturning() {}
4.異常丟擲時增強：@AfterThrowing(pointcut = "execution(* biz.IUserBiz.*(..))", throwing = "e")
標示方法：public void afterThrowing(JoinPoint jp, RuntimeException e) {}
5.環繞增強：@Around("execution(* biz.IUserBiz.*(..))")
標示方法：public Object aroundLogger(ProceedingJoinPoint jp) throws Throwable {}
6.最終增強：@After("execution(* biz.IUserBiz.*(..))")
標示方法：public void afterLogger(JoinPoint jp) {}
7.spring容器標示類的存在，使用aop標籤在容器中表明使用註解方式進行增強
<bean class="aop.UserBizLogger"></bean>
<aop:aspectj-autoproxy />
8.JoinPoint jp的方法：
Object target = jp.getTarget(); // 獲取被代理物件
Method method = jp.getSignature(); // 獲取被代理方法
Object[] args = jp.getArgs(); // 獲取方法引數，通常Arrays.toString(jp.getArgs())轉化後用來輸出引數表列
Object result = jp.proceed(); // 呼叫目標方法，獲取目標方法返回值--------注意丟擲異常，用來定義異常是的輸出。
==================================================
spring面向切面程式設計的方法之三：Schema方式：普通JavaBean使用aop標籤在容器中定義
1.前置增強：<aop:after>
標示方法：public void before(JoinPoint jp) {}
2.後置增強：<aop:after-returning>
標示方法：public void afterReturning(JoinPoint jp, Object result) {}
3.異常丟擲時增強：<aop:after-throwing>
標示方法：public void afterThrowing(JoinPoint jp, RuntimeException e) {}
4.環繞增強：<aop:around>
標示方法： public Object aroundLogger(ProceedingJoinPoint jp) throws Throwable {}
5.最終增強：<aop:aspect>
標示方法：public void afterLogger(JoinPoint jp) {}
6.定義增強類，織入（定義切點，織入）
<bean id="theLogger" class="aop. AfterLogger"></bean>
<aop:config>
<aop:pointcut id="pointcut" expression="execution(* biz.IUserBiz.*(..))" />
<aop:aspect ref="theLogger">
<aop:after method="afterLogger" pointcut-ref="pointcut" />
</aop:aspect>
</aop:config>
Aop切面程式設計的幾個例子
==================================================
例一：log4j實現記錄日誌---介面
1.實現方式：利用實現介面的Aop方法給特定方法執行後置增強
2.步驟：新增log4j.properties在src下，以及log4j-1.2.17.jar新增lib下
3.實現類實現介面用來定義
public class AfterAdvice implements AfterReturningAdvice {
Logger logger = Logger.getLogger(AfterAdvice.class);
public void afterReturning(Object arg0, Method arg1, Object[] arg2,
Object arg3) throws Throwable {
// TODO Auto-generated method stub
logger.debug("後置：執行物件：" + arg3 + "的方法為：" + arg1.getName() );
}
}
4.Spring容器中定義切入方式（一個點多個面，一個面多個點均可）
<bean id="beforeAdvice" class="com.yunhe.aspect.BeforeAdvice"></bean>
<bean id="afterAdvice" class="com.yunhe.aspect.AfterAdvice"></bean>
<aop:config>
<aop:pointcut expression="execution(* com.yunhe.biz.*.*(..))" id="pc1"/>
<aop:advisor advice-ref="beforeAdvice" pointcut-ref="pc1"/>
<aop:advisor advice-ref="afterAdvice" pointcut-ref="pc1"/>
</aop:config>
5.log4j.properties的配置檔案資訊
1. ### ÉèÖÃLoggerÊä³ö¼¶±ðºÍÊä³öÄ¿µÄµØ ###
2. log4j.rootLogger=debug, stdout,logfile
3.
4. ### °ÑÈÕÖ¾ÐÅÏ¢Êä³öµ½¿ØÖÆ̨ ###
5. log4j.appender.stdout=org.apache.log4j.ConsoleAppender
6. log4j.appender.stdout.Target=System.err
7. log4j.appender.stdout.layout=org.apache.log4j.SimpleLayout
8.
9. ### °ÑÈÕÖ¾ÐÅÏ¢Êä³öµ½Îļþ£ºjbit.log ###
10. log4j.appender.logfile=org.apache.log4j.FileAppender
11. log4j.appender.logfile.File=jbit.log
12. log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
13. log4j.appender.logfile.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %l %F %p %m%n
6.
==================================================
例二：環繞增強---介面
1.實現方式：利用實現介面的Aop方法給特定方法執行環繞增強，並在產生異常的情況下進行提示
2.步驟：新增log4j.properties在src下，以及log4j-1.2.17.jar新增lib下
3.實現類實現介面用來定義
1. public class AroundLogger implements MethodInterceptor {
2. private static final Logger log = Logger.getLogger(AroundLogger.class);
3.
4. public Object invoke(MethodInvocation arg0) throws Throwable {
5. Object target = arg0.getThis(); // 獲取被代理物件
6. Method method = arg0.getMethod(); // 獲取被代理方法
7. Object[] args = arg0.getArguments(); // 獲取方法引數
8. log.info("呼叫 " + target + " 的 " + method.getName() + " 方法。方法入參："
9. + Arrays.toString(args));
10. try {
11. Object result = arg0.proceed(); // 呼叫目標方法，獲取目標方法返回值
12. log.info("呼叫 " + target + " 的 " + method.getName() + " 方法。方法返回值："
13. + result);
14. return result;
15. } catch (Throwable e) {
16. log.error(method.getName() + " 方法發生異常：" + e);
17. throw e;
18. }
19. }
20. }
4.Spring容器配置
1. <bean id="aroundLogger" class="aop.AroundLogger"></bean>
2. <aop:config>
3. <aop:pointcut id="pointcut" expression="execution(* biz.IUserBiz.*(..))" />
4. <aop:advisor pointcut-ref="pointcut" advice-ref="aroundLogger" />
5. </aop:config>
==================================================
例三：特定異常增強---註解
1.使用註解的Aop方式實現異常增強
2.方法中
1. @Aspect
2. public class ErrorLogger {
3. private static final Logger log = Logger.getLogger(ErrorLogger.class);
4. @AfterThrowing(pointcut = "execution(* biz.IUserBiz.*(..))", throwing = "e")
5. public void afterThrowing(JoinPoint jp, RuntimeException e) {
6. log.error(jp.getSignature().getName() + " 方法發生異常：" + e);
7. }
8. }
3.Spring容器配置
<bean class="aop.ErrorLogger"></bean>
<aop:aspectj-autoproxy />
==================================================
例四：環繞增強---註解
1.使用註解方式實現環繞增強
2.
1. @Aspect
2. public class AroundLogger {
3. private static final Logger log = Logger.getLogger(AroundLogger.class);
4. @Around("execution(* biz.IUserBiz.*(..))")
5. public Object aroundLogger(ProceedingJoinPoint jp) throws Throwable {
6. log.info("呼叫 " + jp.getTarget() + " 的 " + jp.getSignature().getName()
7. + " 方法。方法入參：" + Arrays.toString(jp.getArgs()));
8. try { Object result = jp.proceed();
9. log.info("呼叫 " + jp.getTarget() + " 的 "
10. + jp.getSignature().getName() + " 方法。方法返回值：" + result);
11. return result;
12. } catch (Throwable e) {
13. log.error(jp.getSignature().getName() + " 方法發生異常：" + e);
14. throw e; }
15. } }
3.註解方式的前置後置以及最終增強型別
1. @Aspect
2. public class AfterLogger {
3. private static final Logger log = Logger.getLogger(AfterLogger.class);
4. @After("execution(* biz.IUserBiz.*(..))")
5. public void afterLogger(JoinPoint jp) {
6. log.info(jp.getSignature().getName() + " 方法結束執行。");
7. }
8. }
1. @Aspect
2. public class UserBizLogger {
3. private static final Logger log = Logger.getLogger(UserBizLogger.class);
4.
5. @Before("execution(* biz.IUserBiz.*(..))")
6. public void before() {
7. log.info("即將呼叫業務方法");
8. }
9.
10. @AfterReturning("execution(* biz.IUserBiz.*(..))")
11. public void afterReturning() {
12. log.info("業務方法呼叫完畢");
13. }
14.
15. }
==================================================
例五：環繞增強-----schema方式
1.使用註解方式實現環繞增強
1. public class AroundLogger {
2. public Object aroundLogger(ProceedingJoinPoint jp) throws Throwable { … }
3. }
1. <bean id="theLogger" class="aop. AroundLogger"></bean>
2. <aop:config>
3. <aop:pointcut id="pointcut" expression="execution(* biz.IUserBiz.*(..))" />
4. <aop:aspect ref="theLogger">
5. <aop:around method="aroundLogger" pointcut-ref="pointcut" />
6. </aop:aspect>
7. </aop:config>
==================================================
例六：最終增強-----schema方式
1. public class AfterLogger {
2. public void afterLogger(JoinPoint jp) { … }
3. }
1. <bean id="theLogger" class="aop. AfterLogger"></bean>
2. <aop:config>
3. <aop:pointcut id="pointcut" expression="execution(* biz.IUserBiz.*(..))" />
4. <aop:aspect ref="theLogger">
5. <aop:after method="afterLogger" pointcut-ref="pointcut" />
6. </aop:aspect>
7. </aop:config>
相關推薦
Spring面向切面程式設計的三種方式以及常用相關案例總結
Spring面向切面程式設計 ================================================== spring面向切面程式設計的方法之一：實現介面方式 1.執行前增強：MethodBeforeAdvice介面 標示方法：public vo
詳解Spring面向切面程式設計（AOP)三種實現
一、什麼是AOP AOP（Aspect Oriented Programming），即面向切面程式設計，可以說是OOP（Object Oriented Programming，面向物件程式設計）的補充和完善。OOP引入封裝、繼承、多型等概念來建立一種物件層次結構，用於模擬公共行為的一個集合。不過OOP允許開
Spring-Boot專案執行的三種方式以及簡單的構建
我來學習Spring-Boot的方法是，首先通過看視訊進行構造這個專案，然後慢慢擴充套件這個專案，在動手的操作中進行一些領悟，同時看一些書籍進行理論的基礎性系統學習。 本篇章的最後會記錄下Spring-Boot來構造maven專案的過程 1、用Spring-Boot來執行
Spring靜態注入的三種方式
Spring靜態注入的三種方式： (說明：MongoFileOperationUtil是自己封裝的一個Mongodb檔案讀寫工具類，裡面需要依賴AdvancedDatastore物件例項，dsForRW用來獲取Mongodb資料來源) 在springframework裡，我們不能@Autowir
Spring 面向切面程式設計
AOP 代理設定模式 概述： 所謂代理，就是一個人或某機構代表一個人或某機構採取行動。在一些情況下，客戶不想或不能直接引用一個物件，而代理物件可以在客戶端和目標物件之間起到中間的作用。 通俗講： - 經紀人和藝人的關係，經紀人便是代理，藝人就是目標使用者，藝人不想做的（
spring注入bean的三種方式
1、自動化裝配bean 元件裝配：Spring會自動發現應用上下文所建立的bean。 自動裝配：Spring自動滿足bean之間的依賴 在類上加入@Component註解,告訴spring為這個類建立bean 使用@Autowired註解實現自動裝配，也可以使用java規範的@Inj
Spring——面向切面程式設計
本文主要依據《Spring實戰》第四章內容進行總結 1、面向切面程式設計術語 1.1、橫切關注點 散佈於應用中多處的功能被稱為橫切關注點，通常來講，這些橫切關注點從概念上是與應用的業務邏輯相分離的（但是往往會直接嵌入到應用的業務邏輯中），把這些橫切關注點與業務邏
java多執行緒（二）:建立執行緒的三種方式以及優缺點總結
一、Java中建立執行緒主要有三種方式： 1、繼承Thread類建立執行緒類 步驟： （1）定義Thread類的子類，並重寫該類的run方法，該run方法的方法體就代表了執行緒要完成的任務。因此把run()方法稱為執行體。 （2）建立Thread子類的例項，即建立了執行緒物件。
Spring-02 -Spring 建立物件的三種方式 :1.通過構造方法建立/2.例項工廠/3.靜態工廠
通過構造方法建立 1.1 無參構造建立:預設情況. 1.2 有參構造建立:需要明確配置 1.2.1 需要在類中提供有參構造方法 1.2.2 在 applicationContext.x
Spring生成bean的三種方式(xml)
1.普通的配置bean物件，呼叫的是其無參構造方法。 <bean id="userDao" class="com.icbc.spring.study1.UserDaoImpl"></bean> 即：該userDao 的例項 是通過
spring配置資料來源的4種方式以及Druid連線池
第一種：使用spring自帶的DriverManagerDataSource（無連線池的作用） <bean id="dataSource" class="org.springframework
spring容器啟動的三種方式
一、在Web專案中，啟動Spring容器的方式有三種，ContextLoaderListener、ContextLoadServlet、ContextLoaderPlugin。 1.1、監聽器方式： web.xml <context-param> &
Java建立執行緒的三種方式以及優劣對比
Java使用Thread類代表執行緒，所有的執行緒物件都必須是Thread類或者其子類例項。每個執行緒的作用是完成一定的任務，實際上是執行一段程式流 #1. 繼承Thread類建立執行緒類 通過繼承Thread類來建立並啟動多執行緒的步驟如下： 定
脫離文件流的三種方式以及清除浮動
固定定位(position:fixed) 脫離文件流後的元素有四個特性： 1.不再區分行和快； 2.如果本元素未設定寬度，脫離後的寬度將由其子元素撐開，高度也是； 3.字圍效果； 4.貼靠現象 ； 清除浮動： 1.給浮動元素的父元素設定寬高，這樣就不會影響到後面的元素了（不建議用，不使用）； 2.給浮動元素新
Spring建立物件的三種方式
1.建立物件的三種方式和bean的生命週期的驗證： Animal介面程式碼： package cn.pb.dao; /** * 動物介面 */ public interface Animal { //吃飯 String eat(); //睡覺
Spring面向切面程式設計（AOP）原理一之使用JDK實現動態代理
什麼是面向切面程式設計？ AOP為Aspect Oriented Programming的縮寫，意為：面向切面程式設計，通過預編譯方式和執行期動態代理實現程式功能的統一維護的一種技術。AOP是OOP（面向物件程式設計）的延續，是軟體開發中的一個熱點，也是Spr
JavaScript嵌入的三種方式以及變數的命名規則：
一、JavaScript嵌入的三種方式： 1、行間JavaScript <input type="button" name="" onclick="alert('ok！');"> 2、內嵌JavaScript： 可以寫入body，也可以寫入head
spring 面向切面程式設計，在執行SQL時列印類名及方法名
需求：在所有列印SQL語句前，加上SQL所在的類名及方法名。 解決方法：使用spring面向切面程式設計。 具體程式碼： package com.hys.qiantai.struts.action.
AndroidStudio中新增依賴的三種方式以及如何引入so檔案和arr檔案
轉載自：http://blog.csdn.net/zxc514257857/article/details/56534863 前言 AndroidStudio中新增依賴的三個選項，如圖： 分別為：庫依賴（Library dependency）、檔案依賴（
Spring——面向切面程式設計（AOP）
一.AOP概念： 面向切面程式設計，指擴充套件功能的同時不修改原始碼，將功能程式碼聰業務邏輯中分離出來。 主要功能：日誌記錄、效能統計、事務處理、安全控制、異常處理等。 主要意圖：將日誌記錄，效能統計，安全控制，事務處理，異常處理等程式碼從業務邏輯程式碼中劃分出來，通過對這些行為的分