spring integration

Intégration de printemps

Étend le modèle de programmation Spring pour prendre en charge les modèles d'intégration d'entreprise bien connus. Spring Integration permet une messagerie légère dans les applications basées sur Spring et prend en charge l'intégration avec des systèmes externes via des adaptateurs déclaratifs. Ces adaptateurs offrent un niveau d'abstraction plus élevé que la prise en charge par Spring de la communication à distance, de la messagerie et de la planification. L'objectif principal de Spring Integration est de fournir un modèle simple pour créer des solutions d'intégration d'entreprise tout en maintenant la séparation des préoccupations, essentielle à la production d'un code maintenable et testable.

L'utilisation de Spring Framework encourage les développeurs à coder à l'aide d'interfaces et à utiliser l'injection de dépendances (DI) pour fournir à un objet Plain Old Java (POJO) les dépendances dont il a besoin pour effectuer ses tâches. Spring Integration va encore plus loin dans ce concept, où les POJO sont connectés ensemble à l'aide d'un paradigme de messagerie et où les composants individuels peuvent ne pas connaître les autres composants de l'application. Une telle application est construite en assemblant des composants réutilisables à granularité fine pour former un niveau de fonctionnalité plus élevé. Avec une conception soignée, ces flux peuvent être modularisés et également réutilisés à un niveau encore plus élevé.

En plus de câbler ensemble des composants à granularité fine, Spring Integration fournit une large sélection d'adaptateurs de canal et de passerelles pour communiquer avec des systèmes externes. Les adaptateurs de canal sont utilisés pour une intégration unidirectionnelle (envoi ou réception) ; les passerelles sont utilisées pour les scénarios de demande/réponse (entrants ou sortants).

Installation et mise en route

Tout d'abord, vous avez besoin de dépendances dans votre POM/Gradle :

< dependency >
    < groupId >org.springframework.integration</ groupId >
    < artifactId >spring-integration-core</ artifactId >
</ dependency >

qui est également extrait de manière transitive si vous utilisez des adaptateurs de canal de protocole cible. Par exemple, pour la prise en charge d'Apache Kafka, vous avez besoin de ceci :

< dependency >
    < groupId >org.springframework.integration</ groupId >
    < artifactId >spring-integration-kafka</ artifactId >
</ dependency >

Pour les annotations ou la configuration Java DSL, vous devez activer Spring Integration dans le contexte de l'application :

 @ EnableIntegration
@ Configuration
public class ExampleConfiguration {
    
}

Code de conduite

Veuillez consulter notre Code de conduite.

Signalement des vulnérabilités de sécurité

Veuillez consulter notre politique de sécurité.

Documentation

L'intégration Spring maintient une documentation de référence (publiée et source), des pages wiki GitHub et une référence API. Il existe également des guides et des didacticiels pour les projets Spring.

Vérification et construction

Pour extraire le projet et le construire à partir de la source, procédez comme suit :

 git clone git://github.com/spring-projects/spring-integration.git
cd spring-integration
./gradlew clean test

or

./gradlew clean testAll

Ce dernier exécute des tests supplémentaires (ceux annotés avec @LongRunningIntegrationTest ) ; il s'agit d'un test plus approfondi mais qui prend beaucoup plus de temps à exécuter.

Les résultats des tests sont capturés dans build/reports/tests/test (ou .../testAll ) sous chaque module (au format HTML).

Ajoutez --continue à la commande pour effectuer une construction complète, même si des tests échouent dans certains modules ; sinon, la construction s'arrêtera une fois le ou les modules en cours de construction terminés.

REMARQUE : pendant que Spring Integration s'exécute avec Java SE 17 ou version ultérieure, un compilateur Java 17 est requis pour créer le projet.

Pour créer et installer des fichiers jar dans votre cache Maven local :

 ./gradlew build publishToMavenLocal

Pour construire l'API Javadoc (les résultats seront dans build/api ) :

 ./gradlew api

Pour construire la documentation de référence (les résultats seront dans build/site ) :

 ./gradlew antora

Pour créer une distribution complète comprenant les fichiers zip -dist , -docs et -schema (les résultats seront dans build/distributions ) :

 ./gradlew dist

Utilisation d'Eclipse ou de Spring Tool Suite (avec le plugin BuildShip)

Si vous avez installé le plugin BuildShip,

Fichier -> Importer -> Gradle -> Projet Gradle existant

Utilisation d'Eclipse ou de Spring Tool Suite (lorsque le plugin BuildShip n'est pas installé)

Pour générer des métadonnées Eclipse (fichiers .classpath et .project, etc.), procédez comme suit :

 ./gradlew eclipse

Une fois terminé, vous pouvez ensuite importer les projets dans Eclipse comme d'habitude :

Fichier -> Importer -> Général -> Projets existants dans l'espace de travail

Accédez au répertoire racine 'spring-integration' . Tous les projets doivent être importés sans erreurs.

Utiliser IntelliJ IDEA

Pour importer le projet dans IntelliJ IDEA :

Fichier -> Ouvrir... -> et sélectionnez build.gradle dans le répertoire racine du projet spring-integration

Lignes directrices

Voir également les directives des contributeurs.

Ressources

Pour plus d'informations, veuillez visiter le site Web Spring Integration à l'adresse : https://spring.io/projects/spring-integration