Der ultimative Leitfaden zum Erstellen benutzerdefinierter Anmerkungen in Spring Boot

Solche Anmerkungen füllen das gesamte Projekt in Spring Boot.

Aber wissen Sie, welche Probleme diese Anmerkungen lösen?

Warum wurden überhaupt benutzerdefinierte Anmerkungen eingeführt?

Wie erstelle ich benutzerdefinierte Anmerkungen?

Heute werde ich Folgendes behandeln:

• Warum benutzerdefinierte Anmerkungen erstellen?
• Was sind die Hauptvorteile der Verwendung dieser Anmerkungen?
• Wie erstelle ich benutzerdefinierte Anmerkungen?
• Wie wird die annotierte Methode aufgerufen?
• Wann sollten benutzerdefinierte Anmerkungen verwendet werden?
• Wann sollten benutzerdefinierte Anmerkungen nicht verwendet werden?
• Welche Nachteile hat die Verwendung benutzerdefinierter Anmerkungen?

? Warum benutzerdefinierte Anmerkungen erstellen?

In Spring Boot sind Anmerkungen mehr als nur eine Möglichkeit, Metadaten hinzuzufügen. Sie

• Komplexe Aufgaben vereinfachen
• Boiler-Plate-Code reduzieren
• Verbessern Sie die Lesbarkeit des Codes

Bevor Spring benutzerdefinierte Anmerkungen einführte, mussten Entwickler Konfigurationen wie die E-Mail-Validierung mithilfe von XML-Konfigurationsdateien verwalten.

Die XML-Konfiguration würde Beans, Validatoren und andere notwendige Komponenten definieren, um Aufgaben wie die Validierung von E-Mail-Adressen auszuführen.

Hier ist ein Beispiel dafür, wie die E-Mail-Validierung mithilfe von XML in einer Spring-Anwendung konfiguriert werden könnte:

Wie Sie sehen, kann dies leicht zu einem Albtraum werden, wenn es Hunderte von Klassen gibt, von denen viele aufeinander angewiesen sind.

Es bedeutete auch, dass ein Entwickler dieses XML jedes Mal nachschlagen musste, wenn er eine neue Abhängigkeit hinzufügen musste.

Hauptvorteile benutzerdefinierter Anmerkungen

Vereinfachung der Konfiguration

Spring hat benutzerdefinierte Annotationen eingeführt, um die Konfiguration zu vereinfachen, indem es Entwicklern ermöglicht wird, Annotationen direkt in ihrem Code zu verwenden.

Dadurch wurde der Bedarf an umfangreicher XML-Konfiguration reduziert, wodurch die Codebasis sauberer und einfacher zu warten war.

Unterstützung für deklarative Programmierung

Benutzerdefinierte Annotationen in Spring ermöglichen einen deklarativen Ansatz.

Entwickler können Annotationen wie @Transactional, @Cacheable oder @Scheduled verwenden, um gewünschte Verhaltensweisen zu deklarieren, ohne die zugrunde liegende Logik zu schreiben.

Dies führt zu besser lesbarem und wartbarem Code.

Umgang mit Querschnittsthemen

Die benutzerdefinierten Annotationen von Spring, die oft mit aspektorientierter Programmierung (AOP) verwendet werden, ermöglichen es Entwicklern, übergreifende Anliegen zentral zu bearbeiten.

Zum Beispiel verwaltet die @Transactional-Annotation Transaktionen über mehrere Methoden oder Klassen hinweg, ohne die Transaktionsverwaltungslogik über den gesamten Code zu verteilen.

Reduzierung des Boilerplate-Codes

Es reduziert den Bedarf an Boilerplate-Code durch die Kapselung allgemeiner Verhaltensweisen.

Zum Beispiel vereinfacht die @Autowired-Annotation die Abhängigkeitsinjektion, sodass Spring Abhängigkeiten automatisch injizieren kann, anstatt explizite Konstruktor- oder Setter-Methoden zu erfordern

Es ist eine andere Diskussion, ob Sie @Autowired verwenden sollten oder nicht.

Verbesserung der Lesbarkeit und Konsistenz des Codes

Durch die Abstraktion von Konfigurations- und Querschnittsthemen in Anmerkungen verbessert Spring die Lesbarkeit des Codes.

Sie und Ihre Kollegen können den Zweck einer Methode oder Klasse schnell verstehen, indem Sie sich deren Annotationen ansehen. Annotationen tragen dazu bei, die Konsistenz in der gesamten Codebasis sicherzustellen.

Framework-Flexibilität und Erweiterbarkeit

Benutzerdefinierte Annotationen ermöglichen es Entwicklern, ihre Annotationen auf spezifische Bedürfnisse zugeschnitten zu erstellen und so die Funktionalität des Frameworks auf standardisierte Weise zu erweitern.

Diese Flexibilität hat dazu beigetragen, dass Spring über mehrere Anwendungen und Architekturen hinweg relevant und leistungsstark bleibt.

? So erstellen Sie eine benutzerdefinierte Anmerkung

Schritt 1: Definieren Sie die Anmerkung

• Erstellen Sie eine neue Anmerkung, indem Sie eine Schnittstelle definieren.
• Verwenden Sie @interface, um es zu deklarieren.
• Fügen Sie Meta-Anmerkungen hinzu, um anzugeben, wie sich die Anmerkung verhalten soll.

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: Gibt an, wo die Annotation verwendet werden kann (z. B. Methoden, Klassen).
• @Retention: Gibt an, wie lange die Anmerkung aufbewahrt wird (z. B. Laufzeit, Kompilierzeit).

Schritt 2: Erstellen Sie einen Aspekt zur Verarbeitung der Anmerkung

Sie können eine benutzerdefinierte Logik zum Verarbeiten der Annotation mithilfe von Springs BeanPostProcessor, Aspect oder einer benutzerdefinierten Annotationsverarbeitungslogik erstellen.

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;
    }
}

Schritt 3: Anwenden der Anmerkung

Wenden Sie Ihre benutzerdefinierte Annotation wie definiert auf Methoden, Felder oder Klassen an.

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.

---

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.

Use Cases Where Custom Annotations Are a Good Approach

Cross-Cutting Concerns

Custom annotations are ideal for handling cross-cutting concerns like logging, security, transaction management, and caching.

These are concerns that affect multiple parts of an application but are not related to the core business logic.

Die obige Annotation @LogExecutionTime ist ein gutes Beispiel, da sie für alle Methoden verwendet werden kann und über keine Geschäftslogik verfügt.

Deklarative Programmierung

Wenn Sie angeben möchten, was passieren soll, und nicht, wie es passieren soll, bieten benutzerdefinierte Anmerkungen eine saubere und ausdrucksstarke Möglichkeit, dies zu tun.

Annotationen wie @Cacheable oder @Retry ermöglichen es Entwicklern, Caching zu aktivieren oder Logik deklarativ erneut zu versuchen, ohne den Implementierungscode manuell schreiben zu müssen.

Framework- oder Bibliotheksintegration

Benutzerdefinierte Annotationen können die Integration von Frameworks oder Bibliotheken vereinfachen, indem sie die Komplexität hinter einer benutzerfreundlichen Annotation verbergen.

Annotationen wie @Autowired in Spring helfen beim Einfügen von Abhängigkeiten, ohne dass diese manuell instanziiert werden müssen.

Kapselung komplexer Logik

Wenn komplexe Logik auf wiederverwendbare Weise gekapselt werden muss, können benutzerdefinierte Anmerkungen eine saubere API für die Anwendung dieser Logik bereitstellen.

Eine Annotation wie @RateLimit könnte Logik kapseln, um die Anzahl der Aufrufe einer Methode zu begrenzen, ohne den Methodenkörper mit dieser Logik zu überladen.

Anwendungsfälle, in denen benutzerdefinierte Anmerkungen nicht verwendet werden sollten

Einfache oder einmalige Logik

Wenn die Logik einfach ist oder nur an einer einzigen Stelle angewendet werden muss, ist das Erstellen einer benutzerdefinierten Anmerkung übertrieben und kann den Code unnötig komplizieren.

Logik, die dynamisches Verhalten erfordert

Annotationen werden zur Kompilierungszeit statisch definiert, was sie für Szenarien ungeeignet macht, in denen das Verhalten zur Laufzeit dynamisch bestimmt werden muss.

Wenn sich das Verhalten einer Methode aufgrund von Benutzereingaben oder externer Konfiguration ändern sollte, kann der Umgang mit benutzerdefinierten Annotationen zu komplexen Lösungen führen.

Geschäftslogik

Kerngeschäftslogik sollte nicht in benutzerdefinierte Anmerkungen abstrahiert werden, da dies die Logik weniger transparent und schwieriger zu warten machen kann.

Die Verwendung einer Annotation zur Kapselung eines Geschäftsprozesses wie @ProcessOrder kann dazu führen, dass wichtige Geschäftsregeln ausgeblendet werden, wodurch der Code schwieriger zu verstehen und zu verwalten ist.

Komplexe Interaktionen zwischen Anmerkungen

Wenn das Verhalten von komplexen Interaktionen zwischen mehreren Anmerkungen abhängt, kann es zu unerwarteten Ergebnissen führen und das Verständnis und Debuggen des Codes erschweren.

Das Kombinieren mehrerer benutzerdefinierter Anmerkungen, die sich auf dieselbe Methode auswirken (z. B. @Retry, @Cacheable, @LogExecutionTime), kann zu unvorhersehbarem Verhalten führen und ist schwer zu verwalten

Leistungskritischer Code

Benutzerdefinierte Anmerkungen basieren häufig auf Reflexions- oder Proxy-Mechanismen, was zu Leistungseinbußen führen kann.

Sie sollten nicht in leistungskritischen Codeabschnitten verwendet werden.

Die Verwendung einer benutzerdefinierten Annotation zum Hinzufügen einer Protokollierung zu einer Methode, die millionenfach in einer engen Schleife aufgerufen wird, könnte die Leistung erheblich beeinträchtigen.

? Zusammenfassung - Wann benutzerdefinierte Anmerkungen verwendet werden sollten

Benutzerdefinierte Anmerkungen eignen sich perfekt für die Bearbeitung übergreifender Anliegen wie Protokollierung, Sicherheit und Transaktionsverwaltung.

Sie eignen sich auch hervorragend für Szenarien, in denen Sie dasselbe Verhalten auf mehrere Teile Ihrer Anwendung anwenden müssen.

Für einfache, einmalige Logik oder wenn eine differenzierte Kontrolle und Flexibilität erforderlich sind, sind benutzerdefinierte Anmerkungen jedoch möglicherweise nicht der beste Ansatz.

Berücksichtigen Sie die Kompromisse, bevor Sie sich für deren Umsetzung entscheiden.

? Letzte Gedanken

Benutzerdefinierte Anmerkungen sind ein leistungsstarkes Werkzeug in Ihrem Spring Boot-Arsenal, aber wie jedes Werkzeug sollten sie mit Bedacht eingesetzt werden.

Sie bieten eine saubere, wiederverwendbare Möglichkeit, sich wiederholende Aufgaben zu erledigen und die Konsistenz in Ihrer gesamten Codebasis durchzusetzen.

Bedenken Sie jedoch die potenziellen Nachteile, insbesondere im Hinblick auf Komplexität und Leistung.

---

?? Bekanntmachung

Ich starte einen 10-tägigen kohortenbasierten Kurs für Softwareentwickler und angehende Microservices-Architekten zum Entwerfen und Implementieren von ratenbegrenzenden Diensten mit Spring Boot und Bucket4j.

Du wirst lernen:

✅ So entwerfen und erstellen Sie einen produktionsbereiten Microservice

✅ Vertiefte Kenntnisse über ratenbegrenzende Algorithmen und deren Implementierung

✅ Best Practices für die Entwicklung, das Testen und die Containerisierung von Spring Boot

Aber es geht auch darum

✅ Das Projekt in konkrete Aufgaben aufteilen

✅ Sich selbst gegenüber verantwortlich sein

✅ Das Projekt richtig entwerfen und bauen

Es richtet sich an Softwareentwickler, die einen Microservice entwerfen und entwickeln möchten, der für die meisten Unternehmen ein relevanter Anwendungsfall ist.

Es ist SPEZIELL für diejenigen gedacht, die sich am Anfang ihrer Karriere als Softwareentwickler befinden und möglicherweise keine „Projekterfahrung“, aber jede Menge Leidenschaft und Ehrgeiz haben.

Wenn dies etwas ist, von dem Sie glauben, dass es Ihnen helfen wird, oder wenn Sie einfach nur neugierig sind, mehr zu erfahren:

Melden Sie Ihr Interesse an und ich teile Ihnen die Einzelheiten des Workshops mit.

---

Dies wurde zuerst auf meinem Substack veröffentlicht. Abonnieren Sie meinen Substack - Weekend Developer, um als Erster Updates zu erhalten.

Sind Sie ein Entwickler, der Feedback zu dem von Ihnen geschriebenen Code benötigt?

Oder möchten Sie, dass jemand Ihren Code überprüft, damit Sie die richtigen Dinge tun?

Ich helfe Menschen mit kostenlosen Codeüberprüfungssitzungen, damit sie frühzeitig Feedback erhalten und besseren Code schreiben können

Schreiben Sie mir eine DM auf Twitter (X) oder auf LinkedIn und ich helfe Ihnen mit Ihrem Code.

Das obige ist der detaillierte Inhalt vonDer ultimative Leitfaden zum Erstellen benutzerdefinierter Anmerkungen in Spring Boot. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!