在 Spring Boot 中建立自訂註解的終極指南-java教程-PHP中文網

The Ultimate Guide to Create Custom Annotations in Spring Boot
這樣的註解充滿了 Spring Boot 中的整個專案。

但是你知道這些註解解決了什麼問題嗎？

為什麼要引入自訂註解？

如何建立自訂註解？

今天，我將介紹：

為什麼要建立自訂註解？
使用這些註解的主要好處是什麼？
如何建立自訂註解？
帶註解的方法是如何被呼叫的？
何時使用自訂註解？
什麼時候不應該使用自訂註解？
使用自訂註解有哪些缺點？

？為什麼要建立自訂註解？

在 Spring Boot 中，註解不僅僅是添加元資料的一種方式。他們

簡化複雜的任務
減少樣板代碼
增強程式碼可讀性

在 Spring 引入自訂註解之前，開發人員必須使用 XML 設定檔來管理電子郵件驗證等配置。

XML 設定將定義 bean、驗證器和其他必要的元件來執行驗證電子郵件地址等任務。

以下是如何在 Spring 應用程式中使用 XML 設定電子郵件驗證的範例：

The Ultimate Guide to Create Custom Annotations in Spring Boot

如您所見，這很容易成為一場噩夢，因為有數百個類，其中許多類相互依賴。

這也意味著開發人員每次必須新增新的依賴項時都必須尋找此 XML。

自訂註解的主要優點

簡化配置

Spring 引入了自訂註解來簡化配置，允許開發人員直接在程式碼中使用註解。

這減少了對大量 XML 配置的需求，使程式碼庫更乾淨且更易於維護。

支援聲明式編程

Spring 中的自訂註解啟用了聲明式方法。

開發者可以使用 @Transactional、@Cacheable 或 @Scheduled 等註解來聲明所需的行為，而無需編寫底層邏輯。

這會產生更具可讀性和可維護性的程式碼。

處理跨領域問題

Spring 的自訂註解通常與面向方面程式設計（AOP）一起使用，允許開發人員以集中的方式處理橫切關注點。

例如，@Transactional 註解可以跨多個方法或類別管理事務，而無需將事務管理邏輯分散在整個程式碼中。

減少樣板程式碼

它透過封裝常見行為減少了對樣板程式碼的需求。

例如，@Autowired 註解簡化了依賴注入，允許 Spring 自動注入依賴項，而不需要明確的建構子或 setter 方法

是否應該使用@Autowired 是不同的討論。

提高程式碼可讀性和一致性

透過將配置和橫切關注點抽象化為註解，Spring 提高了程式碼的可讀性。

您和您的同儕開發人員可以透過檢視方法或類別的註解來快速了解方法或類別的用途，並且註解有助於增強整個程式碼庫的一致性。

框架靈活性和可擴展性

自訂註釋可讓開發人員建立適合特定需求的註釋，從而以標準化的方式擴展框架的功能。

這種靈活性可幫助 Spring 在多個應用程式和架構中保持相關性和強大功能。

？如何建立自訂註釋

第 1 步：定義註釋

透過定義介面建立新的註解。
使用@interface來聲明它。
新增元註解以指定註解的行為方式。

package co.officegeek.tokenratelimiter;

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

@Retention(RetentionPolicy.RUNTIME)  // Annotation available at runtime
@Target(ElementType.METHOD)          // Can be applied to methods
public @interface LogExecutionTime {
}

登入後複製

@Target：指示可以使用註解的位置（例如方法、類別）。
@Retention：指示註解保留多久（例如，執行時間、編譯時）。

步驟 2：建立一個面向來處理註釋

您可以使用 Spring 的 BeanPostProcessor、Aspect 或自訂註解處理邏輯來建立自訂邏輯來處理註解。

package co.officegeek.tokenratelimiter;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LogExecutionTimeAspect {

    @Around("@annotation(LogExecutionTime)")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object proceed = joinPoint.proceed();
        long executionTime = System.currentTimeMillis() - start;

        System.out.println(joinPoint.getSignature() + " executed in " + executionTime + "ms");
        return proceed;
    }
}

登入後複製

第 3 步：應用註釋

將自訂註解套用到定義的方法、欄位或類別。

package co.officegeek.tokenratelimiter;

import org.springframework.stereotype.Service;

@Service
public class TestService {

    @LogExecutionTime
    public void serve() throws InterruptedException {
        // Simulate some work
        Thread.sleep(2000);
    }
}

登入後複製

How It Works:

The @LogExecutionTime annotation doesn't cause any method to be called directly.
The Spring AOP framework detects that a method has the @LogExecutionTime annotation using reflection.
The LogExecutionTimeAspect aspect is configured to apply around advice when a method with the @LogExecutionTime annotation is called.
The logExecutionTime method in the aspect is executed before and after the annotated method (serve), logging the execution time.

The Ultimate Guide to Create Custom Annotations in Spring Boot

How does the annotated method get invoked?

When you apply a custom annotation to a method, class, or field, the annotation itself doesn't directly cause any method to be called.

Instead, the logic associated with the annotation is typically implemented using reflection or aspect-oriented programming (AOP) in frameworks like Spring.

Here's a breakdown of how the compiler and runtime environment know what method to call when an annotation is applied:

1. Compile-Time Processing (Annotation Processors)

Some annotations are handled at compile time by annotation processors.

Java's javax.annotation.processing package allows developers to create custom annotation processors that generate code, validate annotations, or even modify the abstract syntax tree (AST) of the code being compiled.

The annotation processor reads the annotations during compilation and executes code based on those annotations.

This can include generating new classes or methods that the code will use later.

The @Override annotation is a compile-time annotation that doesn't invoke a method but instead tells the compiler to check if the method actually overrides a superclass method.

How It Works:

You define a custom annotation processor by extending AbstractProcessor and overriding the process method.
The processor will be invoked by the compiler when it encounters your annotation, allowing you to generate code or perform other tasks.

2. Runtime Processing (Reflection)

Custom annotations can be processed at runtime using reflection.

The runtime system (e.g., a framework like Spring) uses reflection to detect the presence of annotations on methods, classes, or fields, and then applies the corresponding behavior.

A custom annotation like @LogExecutionTime doesn't directly trigger any method call.

Instead, an aspect or some other reflective mechanism checks for the presence of the annotation at runtime and then wraps the method call with additional logic.

How It Works:

At runtime, you use Java's reflection API to check if a method or class has a specific annotation using methods like isAnnotationPresent.
Once detected, you can invoke methods or execute logic associated with that annotation. For example, if a method has a @LogExecutionTime annotation, you might measure the time before and after the method call.

3. Aspect-Oriented Programming (AOP)

In frameworks like Spring, AOP is commonly used to handle custom annotations.

AOP allows you to define "aspects" that can intercept method calls and perform additional processing before or after the method execution.

When the AOP framework (e.g. Spring AOP) detects an annotation, it triggers the execution of an advice method associated with the aspect.

This advice method contains the logic that the AOP framework executes when the annotated method is called.

A @Transactional annotation in Spring doesn't execute any logic by itself.

Instead, the Spring framework's AOP infrastructure intercepts calls to methods annotated with @Transactional and wraps them with transaction management logic.

How It Works:

You define an aspect class with advice methods that are associated with specific pointcuts (join points where you want to apply the advice).
The aspect uses annotations like @Around or @Before to specify when the advice should be executed.
The AOP framework ensures that when a method with a custom annotation is called, the corresponding advice is executed automatically.