2. 程式人生 > >6.spring:AOP(註解）

6.spring:AOP(註解）

阿新 • • 發佈：2018-12-09

 spring Aop

 AOP面向切面程式設計，與OOP面向物件程式設計相輔相成

AOP中最基本的單元是切面

 

問題：
程式碼混亂：越來越多的業務需求（日誌&驗證）加入後，原有的業務方法急劇膨脹，每個方法在處理核心程式碼的同時還必須兼顧其他的多個關注點
程式碼分散，以日誌為例，知識為了滿足這一單一的需求，就不得不在程式碼塊中裡多次呼叫重複的日誌程式碼，如果日誌發生變化，必須修改所有的模組

簡介：
AOP:面向切面程式設計，是一種新的方法，式傳統OOP面向物件程式設計的補充
AOP主要程式設計物件是切面，而切面模組化橫切的關注點

在應用AOP程式設計時，仍需要定義公共的功能，但可以明確定義的功能在哪，以什麼方式應用，並且不必修改影響的類，這樣橫切關注點就被模組化到特殊的
物件（切面）裡

AOP的好處：
->每個事物邏輯位於一個位置，程式碼不分散，便於維護
->業務模組化更簡潔，只包含核心的業務程式碼

AOP術語：
切面（Aspect）：橫切關注點被模組化的特殊物件
通知（Advice）：切換必須完成的工作
目標（Target）：被通知的物件
代理（Proxy）：向目標物件應用的通知之後建立的物件
連線點（Joinpoint）：程式執行的特定位置
切點（pointcut）：每個類都有若干個連線點，
AOP即使通過定位到特定的連線點

 

每次做方法的時候，都在執行之前和之後都有相關的列印操作！
AtithmeticCalculator.java
public interface AtithmeticCalculator {
    int add(int i,int j);
    int sub(int i,int j);
    int mul(int i,int j);
    int div(int i,int j);
}

 AtithmeticCalculatorImp.java

介面中方法的實現。

@Component
public class AtithmeticCalculatorImp implements AtithmeticCalculator{
    
 
public int add(int i, int j) {
        int res = i + j;
        return res;
    }
    public int sub(int i, int j) {
        int res = i - j;
        return res;
    }
    public int mul(int i, int j) {
        int res = i * j;
        return res;
    }
    public int div(int i, int j) {
        int
 
 res = i / j;
        return res;
    }
}
LoggionAspect.java
切面類
//把這個類升級稱為一個切面：返給到IOC容器中---->在宣告為一個註解

@Order(2)
@Aspect
@Component
public class LoggionAspect {

    @Before("execution(public * com.MrChengsc.AOP.AtithmeticCalculator.*(..))")
    public void beforeMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        Object [] args = joinPoint.getArgs();
        
        System.out.println("The method " + methodName + " begins with " + Arrays.asList(args));
    }
    
    /**
     * 在方法執行之後執行的程式碼. 無論該方法是否出現異常
     */
    @After("execution(public * com.MrChengsc.AOP.AtithmeticCalculator.*(..))")
    public void afterMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("The method " + methodName + " ends");
    }
    
    /**
     * 在方法法正常結束受執行的程式碼
     * 返回通知是可以訪問到方法的返回值的!
     */
    @AfterReturning(value="execution(public * com.MrChengsc.AOP.AtithmeticCalculator.*(..))",
            returning="result")
    public void afterReturning(JoinPoint joinPoint, Object result){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("The method " + methodName + " ends with " + result);
    }
    
    /**
     * 在目標方法出現異常時會執行的程式碼.
     * 可以訪問到異常物件; 且可以指定在出現特定異常時在執行通知程式碼
     */
    @AfterThrowing(value="execution(public * com.MrChengsc.AOP.AtithmeticCalculator.*(..))",throwing="e")
    public void afterThrowing(JoinPoint joinPoint, Exception e){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("The method " + methodName + " occurs excetion:" + e);
    }
    
    //環繞通知
        //需要攜帶ProceedingJoinPoint這個型別的引數
        //環繞通知類似動態代理的全類名：ProceedingJoinPoint可以絕對是否執行目標方法
        //必須要有返回值，返回值即為目標方法的返回值
//        @Around("execution(public * com.MrChengsc.AOP.AtithmeticCalculator.*(..))")
//        public Object aroundMethod(ProceedingJoinPoint proceedingJoinPoint){
//            System.out.println("@Around");
//            //返回值
//            Object result =  null;
//            //前置通知
//            String methodName = proceedingJoinPoint.getSignature().getName();
//            try {
//                //前置通知
//                System.out.println("The methodName:" + methodName + "   _The args :" + Arrays.asList(proceedingJoinPoint.getArgs()));
//                //執行目標方法
//                result = proceedingJoinPoint.proceed();
//                //後置通知
//                System.out.println("End result:" + result);
//            } catch (Throwable e) {
//                //e.printStackTrace();
//                //異常通知
//                System.out.println("Exception:" + e);
//            }
//            //後置通知
//            System.out.println("End...");
//            //返回值
//            return result;
//        }
}
LoggionAspect2.java
切面類2//把這個類升級稱為一個切面：返給到IOC容器中---->在宣告為一個註解
@Order(1)
@Aspect
@Component
public class LoggionAspect2 {
    
    //定義一個方法用於切點表示式
    //一般的該方法不需要填入其他的程式碼
    @Pointcut("execution(public * com.MrChengsc.AOP.AtithmeticCalculator.*(..))")
    public void declareJointPointExpression(){    }
    

    @Before("declareJointPointExpression()")
    public void beforeMethod1(JoinPoint joinPoint){
      System.out.println("--->beforeMethod1");
      String methodName = joinPoint.getSignature().getName();
      Object [] args = joinPoint.getArgs();
      System.out.println("The method " + methodName + " begins with " + Arrays.asList(args));
      System.out.println("--->beforeMethod1");
    }
    
    /**
     * 在方法執行之後執行的程式碼. 無論該方法是否出現異常
     */
    @After("declareJointPointExpression()")
    public void afterMethod1(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("The method " + methodName + " ends");
    }
    
    /**
     * 在方法法正常結束受執行的程式碼
     * 返回通知是可以訪問到方法的返回值的!
     */
    @AfterReturning(value="declareJointPointExpression())",
            returning="result")
    public void afterReturning1(JoinPoint joinPoint, Object result){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("The method " + methodName + " ends with " + result);
    }
    
    /**
     * 在目標方法出現異常時會執行的程式碼.
     * 可以訪問到異常物件; 且可以指定在出現特定異常時在執行通知程式碼
     */
    @AfterThrowing(value="declareJointPointExpression()",throwing="e")
    public void afterThrowing1(JoinPoint joinPoint, Exception e){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("The method " + methodName + " occurs excetion:" + e);
    }
    
      //環繞通知
        //需要攜帶ProceedingJoinPoint這個型別的引數
        //環繞通知類似動態代理的全類名：ProceedingJoinPoint可以絕對是否執行目標方法
        //必須要有返回值，返回值即為目標方法的返回值
//        @Around("execution(public * com.MrChengsc.AOP.AtithmeticCalculator.*(..))")
//        public Object aroundMethod(ProceedingJoinPoint proceedingJoinPoint){
//            System.out.println("@Around");
//            //返回值
//            Object result =  null;
//            //前置通知
//            String methodName = proceedingJoinPoint.getSignature().getName();
//            try {
//                //前置通知
//                System.out.println("The methodName:" + methodName + "   _The args :" + Arrays.asList(proceedingJoinPoint.getArgs()));
//                //執行目標方法
//                result = proceedingJoinPoint.proceed();
//                //後置通知
//                System.out.println("End result:" + result);
//            } catch (Throwable e) {
//                //e.printStackTrace();
//                //異常通知
//                System.out.println("Exception:" + e);
//            }
//            //後置通知
//            System.out.println("End...");
//            //返回值
//            return result;
//        }
}

 applicationContext.xml

<!-- 配置自動掃描的包 -->
<context:component-scan base-package="com.MrChengsc.AOP"></context:component-scan>
<!-- 前置通知，使切面裡的註解起作用 -->
<!-- 使AspectJ註解起作用：自動為匹配的類生成代理效果 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

 main:

    public static void main(String[] args) {
//        AtithmeticCalculator atithmeticCalculator = null;
//        atithmeticCalculator = new AtithmeticCalculatorImp();
//        
//        atithmeticCalculator.add(1, 3);
//        System.out.println("---");
//        atithmeticCalculator.sub(3, 1);
//        System.out.println("---");
//        atithmeticCalculator.mul(1, 3);
//        System.out.println("---");
//        atithmeticCalculator.div(10, 2);
//        System.out.println("---");
        
        
        ApplicationContext ctx = new 
                ClassPathXmlApplicationContext("AOPContext.xml");
        //強制的型別使用介面的型別
        AtithmeticCalculator atithmeticCalculator = (AtithmeticCalculator) ctx.getBean(AtithmeticCalculator.class);
        
        int res = atithmeticCalculator.add(3, 6);
        System.out.println("res:" + res);
        System.out.println("-----");
//        int res1 = atithmeticCalculator.mul(2, 3);
//        System.out.println("res1:" + res1);
        
        //異常程式碼的測試
//        int res2 = atithmeticCalculator.div(10, 0);
//        System.out.println("res2:" + res2);
        
        
    }

 

執行的順序以及結果：

--->beforeMethod1
The method add begins with [3, 6]
--->beforeMethod1
The method add begins with [3, 6]
The method add ends
The method add ends with 9
The method add ends
The method add ends with 9
res:9
-----

 

注：

1.首先需要在xml檔案中進行包的掃描<context:component-scan>

2.使切面的註解起作用：<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

3.使用@Component在要進行處理的類、切面類上

4.使用@Aspect進行標註切面類

5.使用 @Before()在方法上作為前置通知

6. 使用@After()在方法上作為後置通知，無論該方法是否出現異常

7. 使用@AfterReturning（value="",returning=""）,正常結束後那倒返回值

8.使用 @AfterThrowing（value="",throwing=""）,在執行發生異常時，那倒異常資訊

9.使用@Around（）作為環繞通知，使用比較少

10.使用@Pointcut（）放在空方法上，作為切點表示式，引用切點直接使用方法名

11.使用@Order(1)放在類上指定切面的優先順序，數值越小優先順序越高

12.@After("execution(public * com.MrChengsc.AOP.AtithmeticCalculator.*(..))")

 　　*：代表所有，任意的

　　..：代表任意的形參

 

 

AOP的實現都有這個符號！

 

相關推薦

6.spring:AOP(註解）

 spring Aop  AOP面向切面程式設計，與OOP面向物件程式設計相輔相成 AOP中最基本的單元是切面   問題： 程式碼混亂：越來越多的業務需求（日誌&驗證）加入後，原有的業務方法急劇膨脹，每個方法在處理核心程式碼的同時還必須兼顧其他的多個關注點 程式

日誌異常處理-spring aop註解

get target public ring -s row imp for method spring aop 可以在不破壞我們程序代碼的前提下很好的對程序異常進行打印，網上也有很多這樣的例子，我這裏寫的比較簡單，只是針對程序出異常時進行見到的日誌打印，代碼比較簡單。

（轉）spring aop(下）

pointcut too point stat 小時 size bin arch org 昨天記錄了Spring AOP學習的一部分（http://www.cnblogs.com/yanbincn/archive/2012/08/13/2635413.html），本來是想一

Spring aop 註解參數說明

spring 連接 href 僅支持 blank code exec data aspectj 在spring AOP中，需要使用AspectJ的切點表達式語言來定義切點。 關於Spring AOP的AspectJ切點，最重要的一點是Spring僅支持AspectJ切點指示

Spring AOP 註解形式

github 日誌記錄 throw 異常 動態字節碼 span pack 規則 tor AspectOriented Programing，面向切面編程。   AOP主要用於日誌記錄，性能統計，安全控制（權限控制），事務處理，異常處理等。將日誌記錄，性

Spring---AOP註解開發&jdbc模板&Spring事務管理

use oca update -m spl pub tex com att 一、AOP註解開發 　　此處需要回憶一遍AOP的概念。簡單的來說，AOP就是利用動態代理技術，做到不觸動源代碼但卻擴展了功能。那麽就需要一個被擴展的對象和一個“新的功能”，例如說給某類的saveUs

Spring aop註解失效

led end int pos 調用 cnblogs 問題 lock 查看 問題 在spring 中使用 @Transactional 、 @Cacheable 或 自定義 AOP 註解時,對象內部方法中調用該對象的其他使用aop機制的方法會失效。 @Transa

Spring AOP註解形式簡單實現

之前 [] 依賴註入 .com proxy sta 對象 instance author 實現步驟： 　　1：導入類掃描的註解解析器　　　　命名空間：xmlns:context="http://www.springframework.org/schema/context"　

【學習筆記】Spring AOP註解使用總結

trace -a tid nat 修改 with this throwable pid Spring AOP基本概念 是一種動態編譯期增強性AOP的實現 與IOC進行整合，不是全面的切面框架 與動態代理相輔相成 有兩種實現：基於jdk動態代理、cglib Spring

spring aop註解失效之謎

問題： 在spring 中使用 @Transactional 、 @Cacheable 或 自定義 AOP 註解時，會發現個問題： 在物件內部的方法中呼叫該物件的其他使用aop機制的方法，被呼叫方法的aop註解失效。 這句話可能說的有點拗口，那麼我們來看幾個 aop 失效的例子吧

spring-aop註解程式設計

  今天價紹的是AspectJ的註解開發： 一  AOP術語 要想面向切面程式設計，我們首先得了解一些基本的術語以及幾種不同的通知： 1.target目標類：需要被代理的類，我們可以簡單的理解為需要服務層中需要公共模組能力的類； 2.JoinPoint連線

Spring AOP註解配置demo

https://blog.csdn.net/yhl_jxy/article/details/78815636#commentBox   一 AOP的概念    AOP(Aspect Oriented Programming)，即為面向切面程式設計。在軟體開發中，散佈於應用中多

Spring AOP註解方式實現

簡介 上文已經提到了Spring AOP的概念以及簡單的靜態代理、動態代理簡單示例，連結地址：https://www.cnblogs.com/chenzhaoren/p/9959596.html 本文將介紹Spring AOP的常用註解以及註解形式實現動態代理的簡單示例。 常用註解 @aspect：定

Spring（2）之 （2.1 Spring AOP 開發）

在Spring AOP程式設計中： 如果加入容器中的目標物件有實現介面，用 JDK代理； 如果目標物件沒有實現介面，用 Cglib代理； 手動實現 AOP程式設計： AOP面向切面程式設計： AOP業務程式碼與關注點程式碼分離； 關注點： 重複的程式碼（方法）叫關注點； 切面：

Spring AOP註解通過@Autowired，@Resource，@Qualifier，@PostConstruct，@PreDestroy注入屬性的

本文介紹了使用spring註解注入屬性的方法。 使用註解以前，注入屬性通過類以及配置檔案來實現。現在，注入屬性可以通過引入@Autowired註解，或者@Resource，@Qualifier，@PostConstruct，@PreDestroy等註解來實現。 使用註解以前我們是怎樣注入屬性的 類的實現

程式碼丟擲異常後進行事務回滾的兩種方式（Spring @Transactional註解）

需求 在service層的某個方法中，在執行完一個對資料庫的寫方法後，丟擲異常，再執行另一個對資料庫的寫方法，虛擬碼如下： @Transactional public void func() { dao.write(pojo1); throw new Exception("異常"

Spring AOP註解的學習與實踐

AOP AOP（Aspect Oriented Programming），即面向切面程式設計，可以說是OOP（Object Oriented Programming，面向物件程式設計）的補充和完善。OOP引入封裝、繼承、多型等概念來建立一種物件層次結構，用於模擬公共行為的一個集合。不

用spring aop註解橫切方式模擬快取資料庫資源

spring aop 可以靈活地切入目標層的方法，控制或者攔截目標方法的執行。本次通過這種機制，控制dao層讀取資料庫資源的方法，實現快取。 實現目標： 查詢：先從快取區檢索。若檢索到則返回結果。若檢索不到，則去資料庫中載入資料，並將加載出的資料存入快取區。 刪

Spring Aop 註解方式引數傳遞

參考原文連結: https://my.oschina.net/longfong/blog/805410 包結構:   Spring配置檔案:   Service層檔案   測試類: 切面檔案:     &nbs

idea下用maven建立並搭建dubbox微服務環境專案(四)——整理spring+mybaties(註解）

  目錄 1. jar包依賴 smbms-user-provider模組 2. 編寫dao及service實現類的修改（smbms-user-provider模組） 3. 配置spring（注入mybaties、dao、service） 4. 跨域訪問修改 5. 其