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:
In Spring Boot sind Anmerkungen mehr als nur eine Möglichkeit, Metadaten hinzuzufügen. Sie
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.
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.
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.
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.
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.
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.
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.
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 {
}
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;
}
}
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);
}
}
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:
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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
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.
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.
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.
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!
