2. 程式人生 > >SpringBoot 通過自定義註解實現AOP切面程式設計例項

SpringBoot 通過自定義註解實現AOP切面程式設計例項

阿新 • • 發佈：2018-11-11

一直心心念的想寫一篇關於AOP切面例項的博文，拖更了許久之後，今天終於著手下筆將其完成。

基礎概念

1、切面(Aspect)

首先要理解‘切’字，需要把物件想象成一個立方體，傳統的面向物件變成思維，類定義完成之後（封裝）。每次例項化一個物件，對類定義中的成員變數賦值，就相當於對這個立方體進行了一個定義，定義完成之後，那個物件就在那裡，不卑不亢，不悲不喜，等著被使用，等著被回收。

面向切面程式設計則是指，對於一個我們已經封裝好的類，我們可以在編譯期間或在執行期間，對其進行切割，把立方體切開，在原有的方法裡面新增（織入）一些新的程式碼，對原有的方法程式碼進行一次增強處理。而那些增強部分的程式碼，就被稱之為切面，如下面程式碼例項中的通用日誌處理程式碼，常見的還有事務處理、許可權認證等等。

2、切入點(PointCut)

要對哪些類中的哪些方法進行增強，進行切割，指的是被增強的方法。即要切哪些東西。

3、連線點(JoinPoint)

我們知道了要切哪些方法後，剩下的就是什麼時候切，在原方法的哪一個執行階段加入增加程式碼，這個就是連線點。如方法呼叫前，方法呼叫後，發生異常時等等。

4、通知(Advice)

通知被織入方法，改如何被增強。定義切面的具體實現。那麼這裡面就涉及到一個問題，空間（切哪裡）和時間（什麼時候切，在何時加入增加程式碼），空間我們已經知道了就是切入點中定義的方法，而什麼時候切，則是連線點的概念，如下面例項中，通用日誌處理（切面），@Pointcut規則中指明的方法即為切入點，@Before、@After是連線點，而下面的程式碼就是對應通知。

@Before("cutMethod()")
public void begin() {
    System.out.println("[email protected]== lingyejun blog logger : begin");
}

5、目標物件(Target Object)

被一個或多個切面所通知的物件，即為目標物件。

6、AOP代理物件(AOP Proxy Object)

AOP代理是AOP框架所生成的物件，該物件是目標物件的代理物件。代理物件能夠在目標物件的基礎上，在相應的連線點上呼叫通知。

7、織入(Weaving)

將切面切入到目標方法之中，使目標方法得到增強的過程被稱之為織入。

例項程式碼

相關依賴包

<dependencies>
        <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>1.8.6</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.6</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.3.6.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-autoconfigure</artifactId>
        <version>1.3.8.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>4.2.8.RELEASE</version>
        <scope>test</scope>
    </dependency>
</dependencies>

定義和實現日誌切面

package com.lingyejun.annotation;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * @Author: Lingye
 * @Date: 2018/11/11
 * @Describe:
 * 定義日誌切面
 * @Lazy 註解:容器一般都會在啟動的時候例項化所有單例項 bean，如果我們想要 Spring 在啟動的時候延遲載入 bean，需要用到這個註解
 * value為true、false 預設為true,即延遲載入，@Lazy(false)表示物件會在初始化的時候建立
 *
 * @Modified By:
 */
@Aspect
@Component
@Lazy(false)
public class LoggerAspect {

    /**
     * 定義切入點：對要攔截的方法進行定義與限制，如包、類
     *
     * 1、execution(public * *(..)) 任意的公共方法
     * 2、execution（* set*（..）） 以set開頭的所有的方法
     * 3、execution（* com.lingyejun.annotation.LoggerApply.*（..））com.lingyejun.annotation.LoggerApply這個類裡的所有的方法
     * 4、execution（* com.lingyejun.annotation.*.*（..））com.lingyejun.annotation包下的所有的類的所有的方法
     * 5、execution（* com.lingyejun.annotation..*.*（..））com.lingyejun.annotation包及子包下所有的類的所有的方法
     * 6、execution(* com.lingyejun.annotation..*.*(String,?,Long)) com.lingyejun.annotation包及子包下所有的類的有三個引數，第一個引數為String型別，第二個引數為任意型別，第三個引數為Long型別的方法
     * 7、execution(@annotation(com.lingyejun.annotation.Lingyejun))
     */
    @Pointcut("@annotation(com.lingyejun.annotation.Lingyejun)")
    private void cutMethod() {

    }

    /**
     * 前置通知：在目標方法執行前呼叫
     */
    @Before("cutMethod()")
    public void begin() {
        System.out.println("[email protected]== lingyejun blog logger : begin");
    }

    /**
     * 後置通知：在目標方法執行後呼叫，若目標方法出現異常，則不執行
     */
    @AfterReturning("cutMethod()")
    public void afterReturning() {
        System.out.println("[email protected]== lingyejun blog logger : after returning");
    }

    /**
     * 後置/最終通知：無論目標方法在執行過程中出現一場都會在它之後呼叫
     */
    @After("cutMethod()")
    public void after() {
        System.out.println("[email protected]== lingyejun blog logger : finally returning");
    }

    /**
     * 異常通知：目標方法丟擲異常時執行
     */
    @AfterThrowing("cutMethod()")
    public void afterThrowing() {
        System.out.println("[email protected]== lingyejun blog logger : after throwing");
    }

    /**
     * 環繞通知：靈活自由的在目標方法中切入程式碼
     */
    @Around("cutMethod()")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        // 獲取目標方法的名稱
        String methodName = joinPoint.getSignature().getName();
        // 獲取方法傳入引數
        Object[] params = joinPoint.getArgs();
        Lingyejun lingyejun = getDeclaredAnnotation(joinPoint);
        System.out.println("[email protected]== lingyejun blog logger --》 method name " + methodName + " args " + params[0]);
        // 執行源方法
        joinPoint.proceed();
        // 模擬進行驗證
        if (params != null && params.length > 0 && params[0].equals("Blog Home")) {
            System.out.println("[email protected]== lingyejun blog logger --》 " + lingyejun.module() + " auth success");
        } else {
            System.out.println("[email protected]== lingyejun blog logger --》 " + lingyejun.module() + " auth failed");
        }
    }

    /**
     * 獲取方法中宣告的註解
     *
     * @param joinPoint
     * @return
     * @throws NoSuchMethodException
     */
    public Lingyejun getDeclaredAnnotation(ProceedingJoinPoint joinPoint) throws NoSuchMethodException {
        // 獲取方法名
        String methodName = joinPoint.getSignature().getName();
        // 反射獲取目標類
        Class<?> targetClass = joinPoint.getTarget().getClass();
        // 拿到方法對應的引數型別
        Class<?>[] parameterTypes = ((MethodSignature) joinPoint.getSignature()).getParameterTypes();
        // 根據類、方法、引數型別（過載）獲取到方法的具體資訊
        Method objMethod = targetClass.getMethod(methodName, parameterTypes);
        // 拿到方法定義的註解資訊
        Lingyejun annotation = objMethod.getDeclaredAnnotation(Lingyejun.class);
        // 返回
        return annotation;
    }
}

自定義一個註解

package com.lingyejun.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @Author: Lingye
 * @Date: 2018/11/11
 * @Describe: 
 * @Modified By:
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Lingyejun {

    /**
     * 何種場景下的通用日誌列印
     *
     * @return
     */
    String module();
}　　

呼叫切面類

package com.lingyejun.annotation;

import org.springframework.stereotype.Component;

/**
 * @Author: Lingye
 * @Date: 2018/11/11
 * @Describe:
 * @Modified By:
 */
@Component
public class LoggerApply {

    @Lingyejun(module = "http://www.cnblogs.com/lingyejun/")
    public void lingLogger(String event) throws Exception {
        System.out.println("lingLogger(String event) : lingyejun will auth by blog address");
        throw new Exception();
    }
}　　

測試程式碼

package com.lingyejun.annotation;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.SpringApplicationConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = Application.class)
public class AnnotationTest {

    @Autowired
    private LoggerApply loggerApply;

    @Test
    public void testAnnotationLogger() {
        try {
            loggerApply.lingLogger("Blog Home");
        } catch (Exception e) {
            System.out.println("a exception be there");
        }
    }
}

效果展示

 

相關推薦

SpringBoot 通過自定義註解實現AOP切面程式設計例項

一直心心念的想寫一篇關於AOP切面例項的博文，拖更了許久之後，今天終於著手下筆將其完成。 基礎概念 1、切面(Aspect) 首先要理解‘切’字，需要把物件想象成一個立方體，傳統的面向物件變成思維，類定義完成之後（封裝）。每次例項化一個物件，對類定義中的成員變數賦值，就相當於對這個立方體進行了一個定義，

基於springboot通過自定義註解和AOP實現許可權驗證

這篇文章主要介紹自定義註解配合AOP的使用來完成一個簡單的許可權驗證的功能。 一、移入依賴 <parent> <groupId>org.springframework.boot</groupId> <artifactId>sprin

使用SpringBoot通過自定義註解+AOP+全域性異常處理實現引數統一非空校驗

一、前言         在我們寫後臺介面時，難免對引數進行非空校驗，如果一兩個還好，但如果需要寫大量的介面，及必填引數太多的時候，會給我們開發帶來大量的重複工作，及很多相似程式碼。而sping自帶的@RequestParam註解並不能完全滿足我們的需求，因為

java/springboot自定義註解實現AOP

  java註解 即是註釋了，百度解釋：也叫元資料。一種程式碼級別的說明。 個人理解：就是內容可以被程式碼理解的註釋，一般是一個類。 元資料 也叫元註解，是放在被定義的一個註解類的前面 ，是對註解一種限制。 談下這兩個： @Retention 和 @Target  

使用Redisson通過自定義註解實現分散式鎖，使用Spring AOP簡化分散式鎖

Redisson概述Redisson是一個在Redis的基礎上實現的Java駐記憶體資料網格（In-Memory Data Grid）。它不僅提供了一系列的分散式的Java常用物件，還提供了許多分散式服務。其中包括(BitSet, Set, Multimap, SortedS

通過自定義註解與aop統一存儲操作記錄

只需要 org 一段 連接 tostring 註解 element iso boot 模塊開發完成後，接到通知需要添加操作記錄功能，看著那一堆接口，如果一個方法一個方法的加，那真是太麻煩了。為了偷懶，就百度了一下，發現可以通過自定義註解和aop的形式來統一添加操作記錄，只需

spring boot通過自定義註解和AOP攔截指定的請求

本文主要通過切面類和自定註解的方式，攔截指定的介面（程式碼中已經作了詳細的說明） 目錄 一 準備工作 三 切面類 五 測試結果  一 準備工作 1.1 新增依賴 通過spr

SpringBoot使用自定義註解實現簡單引數加密解密(註解+HandlerMethodArgumentResolver)

# 前言 > 我黃漢三又回來了，快半年沒更新部落格了，這半年來的經歷實屬不易， > 疫情當頭，本人實習的公司沒有跟員工共患難，直接辭掉了很多人。 > 作為一個實習生，本人也被無情開除了。所以本人又得重新準備找工作了。 > 算了，感慨一下，本來想昨天發的，但昨天是清明，哀悼時期，就留到了今天發。 話不多說，

《SpringBoot學習篇》（5）AOP+自定義註解實現日誌管理

用到的AOP註解：@Aspect  @Pointcut  @After 首先看一下如何呼叫自定義註解： @MyLog(module="老師模組", method="查詢全部") @RequestMapping("/all") public List

Spring AOP 自定義註解實現日誌管理

目錄 一、配置檔案 二、新建一個日誌實體類Log 三、編寫 service 層 四、編寫 service 層的實現 serviceimpl 五、自定義註解類 六、編寫切面類 七、spring + aop 需要的 jar 包 部落格的程式碼是基於 SSM 環境編寫的

spring-AOP+自定義註解實現日誌管理（註解方式實現）

一、場景 後臺管理系統中，管理員作業系統時生成日誌儲存在資料庫中。 二、實現 1、jar包依賴 <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop --> <dependency&

自定義註解+Spring AOP實現記錄使用者操作日誌

一、背景     專案中需要對使用者的各種操作做詳細的操作日誌記錄，需要記錄使用者操作的操作模組、具體操作以及操作的資料記錄ID等。     若寫一個方法去儲存操作，則需要每次手動去呼叫。由於是非業務性的操作，並且大量的重複操作，Spring AOP就能很好的解決這個問題。

使用Spring Aop自定義註解實現自動記錄日誌

百度加自己琢磨，以下親測有效，所以寫下來記錄，也方便自己回顧瀏覽加深印象之類，有什麼問題可以評論一起解決，不完整之處也請大佬指正，一起進步哈哈（1）首先配置檔案： <!-- 宣告自動為spring容器中配置@aspectj切面的bean建立代理 ，織入切面 --> <aop:

Spring AOP自定義註解實現許可權控制

1.建立註解類，controller控制層使用該註解進行許可權控制使用 import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang.annotation.R

使用自定義註解+Spring AOP 實現日誌記錄

使用自定義註解+Spring切面 實現日誌記錄 在平常的專案程式設計中,我們會經常使用到日誌,用來記錄各種事件.但是,有些日誌記錄套路實在是太像了,我們不得不要寫很多遍. 比如在Spring中,我們要使用日誌記錄每個controller的訪問和結束時間,該怎

AOP加自定義註解實現redis註解快取

  很早之前學習了redis，在這次畢業設計中使用redis對熱點資料進行快取，其中使用spring-data-redis還有@Cacheable、@CachePut和@CacheEvict這3個註解。註解的方式避免了在業務方法中參雜太多非業務的邏輯程式碼，比如日誌和事務，

通過自定義註解和java反射實現Spring-DI依賴注入

依賴注入的原理就是簡單說就是從頭往下遞迴生成依賴物件的，然後對引用欄位賦值最後返回。 這裡實現通過變數型別來生成相應的物件。 模擬一個使用者的註冊業務，首先是controller層呼叫service層，然後呼叫dao層程式碼實現儲存使用者。 檔案結構： UserC

java 自定義註解 spring aop 實現註解

java自定義註解     1.幾個常用的註解解釋               @Target說明了Annotation所修飾的物件範圍：Annotation可被用於 packages、types（類、介面、列舉、Annotation型別）、型別成員（方法、構造方法、成員

Spring AOP自定義註解實現系統日誌記錄管理

package com.kilomob.powernetwork.managerweb.annotation; import java.lang.reflect.Method; import java.net.InetAddress; import java.util.Arrays; import java

Spring+SpringMVC+Mybatis 利用AOP自定義註解實現可配置日

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 5