Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# AOP con Spring e X-Ray SDK for Java
**Nota**
X-Ray SDK/Daemon Avviso di manutenzione: il 25 febbraio 2026 AWS X-Ray SDKs/Daemon entrerà in modalità manutenzione, in cui AWS verranno limitate le versioni di X-Ray SDK e Daemon per risolvere solo i problemi di sicurezza. Per ulteriori informazioni sulla tempistica del supporto, consulta. [Cronologia di X-Ray SDK e Daemon Support](xray-sdk-daemon-timeline.md) Ti consigliamo di migrare a. OpenTelemetry Per ulteriori informazioni sulla migrazione a OpenTelemetry, consulta [Migrazione da X-Ray strumentazione a strumentazione](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-migration.html). OpenTelemetry
Questo argomento descrive come utilizzare l' X-Ray SDK e lo Spring Framework per strumentare l'applicazione senza modificarne la logica di base. Ciò significa che ora esiste un modo non invasivo per strumentare le applicazioni in esecuzione in remoto. AWS
**Per abilitare AOP in Spring**
1. [Configurare Spring](#xray-sdk-java-aop-spring-configuration)
1. [Aggiungi un filtro di tracciamento alla tua applicazione](#xray-sdk-java-aop-filters-spring)
1. [Annotare il codice o implementare un'interfaccia](#xray-sdk-java-aop-annotate-or-implement)
1. [ X-Ray Attivalo nella tua applicazione](#xray-sdk-java-aop-activate-xray)
## Configurazione di Spring
Per configurare Spring affinché utilizzi AOP per l'analisi della tua applicazione, puoi utilizzare Maven o Gradle.
Se utilizzi Maven per compilare l'applicazione, aggiungi la seguente dipendenza nel file `pom.xml`.
```
com.amazonaws
aws-xray-recorder-sdk-spring
2.11.0
```
Se utilizzi Gradle, aggiungi la seguente dipendenze nel file `build.gradle`.
```
compile 'com.amazonaws:aws-xray-recorder-sdk-spring:2.11.0'
```
## Configurazione di Spring Boot
Oltre alla dipendenza Spring descritta nella sezione precedente, se stai usando Spring Boot, aggiungi la seguente dipendenza se non è già nel tuo classpath.
Maven:
```
org.springframework.boot
spring-boot-starter-aop
2.5.2
```
Gradle:
```
compile 'org.springframework.boot:spring-boot-starter-aop:2.5.2'
```
## Aggiungere un filtro di tracciamento all'applicazione
Aggiungi un `Filter` alla tua `WebConfig` classe. Passare il nome del segmento al costruttore [`AWSXRayServletFilter`](https://docs.aws.amazon.com/xray-sdk-for-java/latest/javadoc/com/amazonaws/xray/javax/servlet/AWSXRayServletFilter.html) come valore di tipo stringa. Per ulteriori informazioni sul tracciamento dei filtri e sulla strumentazione delle richieste in arrivo, consulta. [Tracciamento delle richieste in arrivo con X-Ray SDK for Java](xray-sdk-java-filters.md)
**Example src/main//- primavera java/myapp WebConfig.java**
```
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 Support
Spring 6 utilizza [Jakarta](https://spring.io/blog/2022/11/16/spring-framework-6-0-goes-ga) anziché Javax per la sua Enterprise Edition. Per supportare questo nuovo spazio dei nomi, X-Ray ha creato un set parallelo di classi che vivono nel proprio spazio dei nomi di Jakarta.
Per le classi di filtro, sostituisci con. `javax` `jakarta` Quando configurate una strategia di denominazione dei segmenti, aggiungete `jakarta` prima del nome della classe di strategia di denominazione, come nell'esempio seguente:
```
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"));
}
}
```
## Annotazione del codice o implementazione di un'interfaccia
Le tue classi devono essere annotate con l'`@XRayEnabled`annotazione o implementare l'interfaccia. `XRayTraced` Questo dice al sistema AOP di racchiudere le funzioni della classe interessata per la strumentazione. X-Ray
## X-Ray Attivazione nella tua applicazione
Per attivare il X-Ray tracciamento nell'applicazione, il codice deve estendere la classe astratta `BaseAbstractXRayInterceptor` sovrascrivendo i seguenti metodi.
+ `generateMetadata`—Questa funzione consente la personalizzazione dei metadati allegati alla traccia della funzione corrente. Per impostazione predefinita, il nome della classe della funzione in esecuzione viene registrato nei metadati. Puoi aggiungere altri dati se hai bisogno di informazioni aggiuntive.
+ `xrayEnabledClasses`—Questa funzione è vuota e dovrebbe rimanere tale. Serve come host per un pointcut che indica ai collettori di quali metodi effettuare il wrapping. Definisci il pointcut specificando quali delle classi che annotate con `@XRayEnabled` tracciare. La seguente istruzione pointcut indica al collettore di eseguire il wrapping di tutti i bean controller annotati con l'annotazione `@XRayEnabled`.
```
@Pointcut(“@within(com.amazonaws.xray.spring.aop.XRayEnabled) && bean(*Controller)”)
```
Se il tuo progetto utilizza Spring Data JPA, valuta la possibilità di estendere from `AbstractXRayInterceptor` anziché. `BaseAbstractXRayInterceptor`
## Esempio
Il codice seguente estende la classe astratta. `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() {}
}
```
Il codice seguente è una classe che verrà strumentata da X-Ray.
```
@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());
}
}
}
```
Se hai configurato la tua applicazione correttamente, dovresti vedere l'intero stack di chiamate dell'applicazione, dai controller fino alle chiamate al servizio, come illustrato nella seguente schermata della console.
