Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# AOP mit Spring und dem X-Ray SDK for Java
**Anmerkung**
X-Ray SDK/Daemon Wartungshinweis — Am 25. Februar 2026 wechselt AWS X-Ray SDKs/Daemon sie in den Wartungsmodus, in dem X-Ray SDK- und Daemon-Versionen auf Sicherheitsprobleme beschränkt AWS werden. Weitere Informationen zum Zeitplan für den Support finden Sie unter. [Zeitplan für die Support von X-Ray SDK und Daemon](xray-sdk-daemon-timeline.md) Wir empfehlen die Migration zu OpenTelemetry. Weitere Informationen zur Migration zu OpenTelemetry finden Sie unter [Migration von X-Ray Instrumentation zu OpenTelemetry Instrumentation](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-migration.html).
In diesem Thema wird beschrieben, wie Sie das X-Ray SDK und das Spring Framework verwenden können, um Ihre Anwendung zu instrumentieren, ohne die Kernlogik zu ändern. Das bedeutet, dass es jetzt eine nichtinvasive Methode zur Instrumentierung Ihrer Anwendungen gibt, die remote ausgeführt werden. AWS
**So aktivieren Sie AOP in Spring**
1. [Konfigurieren von Spring](#xray-sdk-java-aop-spring-configuration)
1. [Fügen Sie Ihrer Anwendung einen Tracing-Filter hinzu](#xray-sdk-java-aop-filters-spring)
1. [Kommentieren Ihres Codes oder implementieren einer Schnittstelle](#xray-sdk-java-aop-annotate-or-implement)
1. [Aktivieren Sie X-Ray ihn in Ihrer Anwendung](#xray-sdk-java-aop-activate-xray)
## Konfigurieren von Spring
Sie können Maven oder Gradle verwenden, um Spring zu konfigurieren, um AOP für die Instrumentierung Ihrer Anwendung verwenden zu können.
Wenn Sie Ihre Anwendung mit Maven erstellen, fügen Sie die folgende Abhängigkeit in Ihrer `pom.xml`-Datei hinzu.
```
com.amazonaws
aws-xray-recorder-sdk-spring
2.11.0
```
Für Gradle fügen Sie die folgende Abhängigkeit in Ihre `build.gradle`-Datei ein.
```
compile 'com.amazonaws:aws-xray-recorder-sdk-spring:2.11.0'
```
## Spring Boot konfigurieren
Wenn Sie Spring Boot verwenden, fügen Sie zusätzlich zu der im vorherigen Abschnitt beschriebenen Spring-Abhängigkeit die folgende Abhängigkeit hinzu, sofern sie nicht bereits in Ihrem Klassenpfad enthalten ist.
Maven:
```
org.springframework.boot
spring-boot-starter-aop
2.5.2
```
Gradle:
```
compile 'org.springframework.boot:spring-boot-starter-aop:2.5.2'
```
## Hinzufügen eines Tracing-Filters zu Ihrer Anwendung
Fügen Sie Ihrer `WebConfig` Klasse eine `Filter` hinzu. Übermitteln Sie den Segmentnamen als Zeichenfolge an den [https://docs.aws.amazon.com/xray-sdk-for-java/latest/javadoc/com/amazonaws/xray/javax/servlet/AWSXRayServletFilter.html](https://docs.aws.amazon.com/xray-sdk-for-java/latest/javadoc/com/amazonaws/xray/javax/servlet/AWSXRayServletFilter.html)-Konstruktor. Weitere Informationen zur Verfolgung von Filtern und zur Instrumentierung eingehender Anfragen finden Sie unter. [Nachverfolgung eingehender Anfragen mit dem X-Ray SDK for Java](xray-sdk-java-filters.md)
**Example src/main/java/myapp/WebConfig.java - Frühling**
```
package {{myapp}};
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Bean;
import javax.servlet.Filter;
import [com.amazonaws.xray.javax.servlet.AWSXRayServletFilter](https://docs.aws.amazon.com/xray-sdk-for-java/latest/javadoc/com/amazonaws/xray/javax/servlet/AWSXRayServletFilter.html);
@Configuration
public class WebConfig {
@Bean
public Filter TracingFilter() {
return new AWSXRayServletFilter("{{Scorekeep}}");
}
}
```
## Jakarta-Unterstützung
Spring 6 verwendet [Jakarta](https://spring.io/blog/2022/11/16/spring-framework-6-0-goes-ga) anstelle von Javax für seine Enterprise Edition. Um diesen neuen Namespace zu unterstützen, X-Ray hat es einen parallel Satz von Klassen erstellt, die in ihrem eigenen Jakarta-Namespace leben.
Ersetzen Sie für die Filterklassen durch. `javax` `jakarta` Wenn Sie eine Segmentbenennungsstrategie konfigurieren, fügen Sie `jakarta` vor der Benennungsstrategie den Klassennamen hinzu, wie im folgenden Beispiel:
```
package myapp;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Bean;
import jakarta.servlet.Filter;
import com.amazonaws.xray.jakarta.servlet.AWSXRayServletFilter;
import com.amazonaws.xray.strategy.jakarta.SegmentNamingStrategy;
@Configuration
public class WebConfig {
@Bean
public Filter TracingFilter() {
return new AWSXRayServletFilter(SegmentNamingStrategy.dynamic("Scorekeep"));
}
}
```
## Kommentieren Ihres Codes oder Implementieren einer Schnittstelle
Ihre Klassen müssen entweder mit der `@XRayEnabled` Anmerkung versehen sein oder die `XRayTraced` Schnittstelle implementieren. Dadurch wird das AOP-System angewiesen, die Funktionen der betroffenen Klasse für X-Ray die Instrumentierung zu verpacken.
## Aktivierung X-Ray in Ihrer Anwendung
Um die X-Ray Ablaufverfolgung in Ihrer Anwendung zu aktivieren, muss Ihr Code die abstrakte Klasse erweitern, `BaseAbstractXRayInterceptor` indem er die folgenden Methoden überschreibt.
+ `generateMetadata`— Diese Funktion ermöglicht die Anpassung der Metadaten, die an den Trace der aktuellen Funktion angehängt sind. Standardmäßig wird der Klassenname der ausgeführten Funktion in den Metadaten aufgezeichnet. Sie können weitere Daten hinzufügen, wenn Sie zusätzliche Informationen benötigen.
+ `xrayEnabledClasses`— Diese Funktion ist leer und sollte es auch bleiben. Sie dient als Host für ein Pointcut, das den Interceptor anweist, welche Methoden gekapselt werden sollen. Definieren Sie das Pointcut, indem Sie angeben, welche der Klassen mit `@XRayEnabled` kommentiert sind, um ein Tracing durchzuführen. Die folgende pointcut-Anweisung weist den Interceptor an, alle Controller-Beans einzukapseln, die mit dem Kommentar `@XRayEnabled` gekennzeichnet sind.
```
@Pointcut(“@within(com.amazonaws.xray.spring.aop.XRayEnabled) && bean(*Controller)”)
```
Wenn Ihr Projekt Spring Data JPA verwendet, sollten Sie eine Erweiterung von `AbstractXRayInterceptor` anstelle von in Betracht ziehen. `BaseAbstractXRayInterceptor`
## Beispiel
Der folgende Code erweitert die abstrakte Klasse`BaseAbstractXRayInterceptor`.
```
@Aspect
@Component
public class XRayInspector extends BaseAbstractXRayInterceptor {
@Override
protected Map> generateMetadata(ProceedingJoinPoint proceedingJoinPoint, Subsegment subsegment) throws Exception {
return super.generateMetadata(proceedingJoinPoint, subsegment);
}
@Override
@Pointcut("@within(com.amazonaws.xray.spring.aop.XRayEnabled) && bean(*Controller)")
public void xrayEnabledClasses() {}
}
```
Der folgende Code ist eine Klasse, von X-Ray der instrumentiert wird.
```
@Service
@XRayEnabled
public class MyServiceImpl implements MyService {
private final MyEntityRepository myEntityRepository;
@Autowired
public MyServiceImpl(MyEntityRepository myEntityRepository) {
this.myEntityRepository = myEntityRepository;
}
@Transactional(readOnly = true)
public List getMyEntities(){
try(Stream entityStream = this.myEntityRepository.streamAll()){
return entityStream.sorted().collect(Collectors.toList());
}
}
}
```
Wenn Sie Ihre Anwendung ordnungsgemäß konfiguriert haben, sollten Sie den vollständigen Aufruf-Stack der Anwendung sehen, vom Controller bis zu den Service-Aufrufe, wie im folgenden Screenshot der Konsole gezeigt.
