2. 程式人生 > >spring之AspectJ實現AOP

spring之AspectJ實現AOP

阿新 • • 發佈：2017-10-14
添加 result exe 包名 inter string ring service odin

一、基於註解的AspectJ

1、要在spring應用中使用AspectJ註解，必須在classpath下包含AspectJ類庫：

com.springsource.org.aopalliance.jar 和 com.springsource.org.aspectj.weaver.jar；將aop schema添加到 <beans> 根元素中；在Spring IoC 容器中啟用 AspectJ直接支持，只要在 bean 配置文件中定義一個空的XML元素 <aop:aspectj-autoproxy>；當Spring IoC 容器檢測到 bean 配置文件中的 <aop:aspectj-autoproxy>

元素時，就會自動為與 AspectJ 切面匹配的 bean 創建代理。

2、通知是標有某種註解的簡單的java方法，AspectJ支持5種類型的通知註解：

1）@Before：前置通知，在方法執行之前執行

2）@After：最終增強

3）@AfterReturning：後置通知，在方法返回結果之後執行

4）@AfterThrowing：異常通知，在方法拋出異常後執行

5）@Around：環繞通知，圍繞著方法的執行

3. 典型的切點表達式是根據方法的簽名來匹配各種方法：

-execution（* *.*（..））：第一個*代表匹配任意修飾符和返回值，第二個*代表任意類的對象，第三個*代表任意方法，參數列表中..匹配任意數量的參數。

- execution (* com.bupt.springtest.aop.ArithmeticCalculator.*(..))：匹配 ArithmeticCalculator 中聲明的所有方法，第一個 * 代表任意修飾符及任意返回值；第二個 * 　 代表任一方法； .. 匹配任意數量的參數。若目標類或接口與該切面在同一個包中，可以省略包名。

- execution (public * ArithmeticCalculator.*(..))：匹配ArithmeticCalculator 類中的所有公有方法。 - execution (public double ArithmeticCalculator.*(..))：匹配ArithmeticCalculator 中返回double類型數值的方法

- execution (public double ArithmeticCalculator.*(double, ..))：匹配第一個參數為double類型的方法， .. 匹配任意數量任意類型的參數

- execution (public double ArithmeticCalculator.*(double, double))：匹配參數類型為double, double類型的方法

4、案例

1、創建一個接口

package cn.happy.service;

public interface ISomeService {
    public void doSome();
    public String add();

    public void insert();
    public void update();
    public void delete();
    public void select();
}

2、實現接口類

package cn.happy.service;

public class SomeService implements ISomeService {
    public void doSome() {
        System.out.println("code  ok");
    }

    public String add() {
        System.out.println("=========log日誌===============");
        //int i = 5/0;
        return "add";
    }

    public void insert() {
        System.out.println("insert");
    }

    public void update() {
        System.out.println("update");
    }

    public void delete() {
        System.out.println("delete");
    }

    public void select() {
        int i = 5/0;
        System.out.println("select");
    }
}

3、編寫增強類

package cn.happy.service;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

@Aspect
public class MyAspect {
    @Before(value="execution(* *..service.*.*(..))")
    public void myAspectj(){
        System.out.println("---我是前置增強---");
    }
 
    @AfterReturning(value="execution(* *..service.*.*(..))")
    public void myAspectjAfter(){
        System.out.println("---我是後置增強---");
    }

   @Around(value="execution(* *..service.*.*(..))")
    public Object myAspectjAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("---我是環繞前增強---");
        Object result = proceedingJoinPoint.proceed();
        System.out.println("---我是環繞後增強---");
        if (result!= null) {
            String str = (String)result;  //可以改變返回值
            return  str.toUpperCase();
        } else {
            return null;
        }
    }


   異常增強
    @Pointcut("execution(* *..service.*.*(..))")  表達式註解
    public void myPoincut(){}
      @AfterThrowing("myPoincut()")
    public void throwing(){
        System.out.println("---error---");
    }

     //切點表達式
     @Pointcut("execution(* *..service.*.insert(..))")
    public void insert(){}



     @Pointcut("execution(* *..service.*.update(..))")
    public void update(){}
     @Pointcut("execution(* *..service.*.delete(..))")
    public void delete(){}

    @Before("insert()||update()||delete()")
    public void myAspectj(){
        System.out.println("---我是前置增強開啟事物---");
    }


    //最終增強
    @After("execution(* *..service.*.*(..))")
    public void after(){
        System.out.println("我是最終增強");
    }
}

　　

4、編寫xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
">
    <!--註解實現-->
    <!--目標對象-->
    <bean id="SomeService" class="cn.happy.serviceXML.SomeService"></bean>

      <!--增強  通知–&gt   -->
    <bean id="beforeAdvice" class="cn.happy.service.MyAspect"></bean>

    <aop:aspectj-autoproxy></aop:aspectj-autoproxy> 

    

   
</beans>

5、編寫測試類

package cn.happy;



import cn.happy.service.ISomeService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class test {
    @Test
    public  void  testAspect(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        ISomeService someService = (ISomeService)context.getBean("SomeService");

        someService.insert();
        someService.update();
        someService.delete();
        someService.select();
    }
}

　　

二、基於xml的AspectJ實現

1、基於xml的實現需要在xml配置文件中加入<aop>節點。

2、案例

1）創建接口類

package cn.happy.serviceXML;

public interface ISomeService {
    public void doSome();
    public String add();


}

2）實現接口類

package cn.happy.serviceXML;


public class SomeService implements ISomeService {
    public void doSome() {
        System.out.println("code  ok");
    }

    public String add() {
        System.out.println("log------");
        //int i = 5/0;
        return "add";
    }


}

3）編寫增強類

package cn.happy.serviceXML;

import org.aspectj.lang.ProceedingJoinPoint;

public class MyAspect {
    public void myBefore(){
        System.out.println("=========before============");
    }

    public void after(){
        System.out.println("============after===============");
    }

    public Object myArround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("我是環繞前增強");
        Object result = proceedingJoinPoint.proceed();
        System.out.println("我是環繞後增強");
        if (result!= null) {
            String str = (String)result;  //可以改變返回值
            return  str.toUpperCase();
        } else {
            return null;
        }
    } 
}

4）.編寫xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
">
    <!--目標對象-->
    <bean id="SomeService" class="cn.happy.serviceXML.SomeService"></bean>

   

    <!--增強類-->
    <bean id="aspect" class="cn.happy.serviceXML.MyAspect"></bean>

    <!--aop-->
    <aop:config>
        <!--設置一個切點-->
        <aop:pointcut id="mycut" expression="execution(* *..serviceXML.*.*(..))"></aop:pointcut>
       <aop:aspect ref="aspect">
           <aop:before method="myBefore" pointcut-ref="mycut"></aop:before>
           <!--<aop:after-returning method="after" pointcut-ref="mycut"></aop:after-returning>-->
           <!--<aop:around method="myArround" pointcut-ref="mycut"></aop:around>-->
       </aop:aspect>
    </aop:config>
</beans>

5）編寫測試類

package cn.happy;


import cn.happy.serviceXML.ISomeService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class test01 {
    // AspectJ XML
    @Test
    public void testAspectXML(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        ISomeService someService= (ISomeService)context.getBean("SomeService");
        someService.add();
        someService.doSome();
    }
}

　　

　　

　　

　　

　　

spring之AspectJ實現AOP

相關推薦

spring之AspectJ實現AOP

添加 result exe 包名 inter string ring service odin 一、基於註解的AspectJ 1、要在spring應用中使用AspectJ註解，必須在classpath下包含AspectJ類庫： com.springsource.org

Spring之註解實現aop(面向切面程式設計)

1:Aop(aspect object programming)面向切面程式設計，名詞解釋:     1.1:功能:讓關注點程式碼與業務邏輯程式碼分離     1.2:關注點       

Spring（2）之 （2.2 使用 AspectJ實現 AOP）

在Spring AOP程式設計中： 分離了重複程式碼：關注點 關注點程式碼：產生類即切面類   一、使用 AspectJ實現 AOP（註解方式）： 導包 spring-aop spring-core aspectjrt aspectjweaver aopalli

spring之AspectJ AOP編程

.html 支持 實現 spec .com 使用 lis 類型 href 一、引言： 　　AspectJ框架不僅實現了面向切面編程，而且還支持註解，spring將它引入自己的規範之中。 二、需要了解： AspectJ是基於java語言的AOP框架 spring2.0之

[Spring框架]Spring AOP基礎入門總結二:Spring基於AspectJ的AOP的開發.

work 復制代碼 配置文件 exec dao tool ont pda nbsp 前言: 在上一篇中: [Spring框架]Spring AOP基礎入門總結一. 中 我們已經知道了一個Spring AOP程序是如何開發的, 在這裏呢我們將基於AspectJ來進行AOP

Spring的AspectJ的AOP，基於註解(9.1)重點掌握

Spring註釋方式自動代理什麽是AspectJ AspectJ是一個面向切面的框架，它擴展了Java語言。AspectJ定義了AOP語法所以它有一個專門的編譯器用來生成遵守Java字節編碼規範的Class文件。AspectJ是一個基於Java語言的AOP框架Spring2.0以後新增了對AspectJ切點表

基於aspectj實現AOP操作的兩種方式——xml配置

aop ont 方式 alt 分享圖片 文件 分享 spa 技術分享 1. 要導入的 jar 包： 常用的aspectj表達式： 權限修飾符可以省略，以下表示：返回值類型為任意，com.chy.service包以及其子包下的、任意類的、參數任意的、任意方法 ex

六、AspectJ 實現AOP

bject index 不同 數據處理 override nta owin cat 沒有 1、什麽是 AspectJ? 　　AspectJ是一個面向切面的框架，它擴展了Java語言。AspectJ定義了AOP語法，也可以說 AspectJ 是一個基於 Java 語言的 AO

Spring--基於AspectJ的AOP開發

例如 dot junit4 dba demo1 out 前置 aspect point AspectJ簡介 ·AspectJ是一個基於Java語言的AOP框架 ·Spring2.0以後新增了對AspectJ切點表達式支持 &mid

Spring之IOC和AOP

1.簡單介紹: Spring是一個開源框架,一個輕量級的Java 開發框架,是完全面向介面的設計，降低程式耦合性，主要是事務控制並建立bean例項物件。在整合ssh、ssm框架中主要充當黏合劑的作用。 2.Spring框架的核心1(IOC): 2.1 控制反轉（Inv

基於Spring註解@AspectJ的AOP

新增依賴 <!-- aspectj 方式的AOP，需要加入下面三個包 --> <dependency> <groupId>org.aspectj</groupId> <artif

spring基於aspectj的AOP配置 aop:aspectj-autoproxy proxy-target-class="true"

精通Spring4.x--企業應用開發實戰 [email protected]("@annotation()")切點函式詳解 程式碼實現的目標是為NaugthyWaiter類的greetTo()方法實現後置增強，其中greetTo()方法被@NeedTest

Spring使用@AspectJ開發AOP（註解的方式）

自定義 The @aspectj tro 織入 color span for 開啟 前言： AOP並不是Spring框架特有的。Spring只是支持AOP編程 (面向切面編程) 的框架之一。 概念： 1、切面(Aspect) 　　一系列Advice + Pointcut

Spring入門知識 ———— 實現AOP返回通知、異常通知、環繞通知

一、引言 以你為AOP只有前置通知和後置通知嗎？ 那你就錯啦 在AOP中一共有五種方式： @Befor：前置通知：在方法執行之前執行 @After：後置通知，在方法之後執行 @AfterRet

Spring之註解版AOP的使用

AOP：【動態代理】  *         指在程式執行期間動態的將某段程式碼切入到指定方法指定位置進行執行的程式設計方式；  *   * 1、匯入aop模組；Spring AOP：(spring-aspects包)  * 2、定義一個業務邏輯類（MathCalculator

Spring之Bean實現了ApplicationContextAware等aware介面,對於setApplicationContext方法執行時間點的說明

  在Spring中，如果Bean物件實現了ApplicationContextAware介面,則Spring在完成Bean的初始化後,會將ApplicationContext上下文物件注入至該Bean物件中,注入方法為呼叫Bean的setApplicationContex

spring之IOC實現的其他方式

在上一個部落格中我們講解了spring的物件獲取和成員變數屬性的注入方式；現在我們來講解不適用配置檔案而是直接在java中直接配置，這也是在springBoot流行之後，利用java類配置來取代xml檔案配置的一種方式。 java類取代xml配置的詳解： 第一java配置需要引入的jar包： 第二：

代理模式與aspectJ實現AOP

一、問題1、程式碼混亂：越來越多的非業務需求（日誌和驗證等）加入後，原有的業務方法急劇膨脹。每個方法在處理核心邏輯的同時還必須兼顧其他多個關注點2、程式碼分散：以日誌需求為例，只是為了滿足這個單一需求，就不得不在多個模組方法（方法）裡多次重複相同的日誌程式碼。如果日誌需求發生

Spring之AspectJ面向切面程式設計框架以及SSH整合詳解

Spring AspectJ AspectJ是什麼? 面向切面程式設計框架 它擴充套件了Java語言(它也是一種語言) 支援原生Java程式碼 它有自己的編譯器 將程式碼翻譯成標準的Java位元組碼 為了方便編寫AOP程式碼而出現的 使用AOP思路

Spring之手寫Aop(3)

到了這裡也到了一個很重要的部分了，使用aop本質上是對方法使用之前，或之後新增自己的邏輯，而如何具體實現，有Aop聯盟就抽象出了方法攔截器，用來執行在方法之前或之後的邏輯，而如何來呼叫這些攔截器，攔截器的執行順序如何呢？這有引出了方法呼叫器（我自己取的， 也就是MethodI