Exemple d'application réactive à ressort (version du 14/01/2020)

Bonne année tardive, communauté de printemps!

Alors que la prochaine année incroyable de développement et d'amélioration de l'écosystème Spring commence, je veux partager avec vous un exemple mis à jour d'une application qui démontre une partie des progrès réalisés dans le portefeuille de projets Spring en ce qui concerne la prise en charge du modèle de programmation réactive.

L'exemple d'application BookStore Service Broker a été mis à jour pour démontrer l'intégration de plusieurs projets Spring différents, notamment Spring Cloud Open Service Broker, Spring Data, Spring Security, Spring HATEOAS et, bien sûr, Spring WebFlux et Spring Boot. Tous ces projets ont des versions de GA, y compris un support réactif et sont prêts à être produits dans vos propres applications et services.

Traduit par @middle_java

Par souci de simplicité, l'application elle-même fonctionne à la fois comme courtier et comme instance de service. Bien que les courtiers eux-mêmes adhèrent à l'API Open Service Broker, les services qu'ils fournissent sont définis de manière plus abstraite. Les services peuvent faire ou être presque n'importe quoi. Dans le cas de notre application, un nouvel ensemble d'informations d'identification est créé pour chaque instance du service. Ces informations d'identification sont utilisées dans les demandes à l'instance de service. L'URL de la nouvelle instance de service est identique à la route vers le courtier. Ainsi, les informations d'identification sont utilisées pour séparer les demandes adressées à différentes instances de service. L'objectif était de développer un exemple entièrement équipé qui illustre de nombreuses parties du portefeuille de projets Spring.

Spring Cloud Open Service Broker 3.1

Spring Cloud Open Service Broker est une plate-forme de création d'applications Spring Boot qui implémentent l'API Open Service Broker et permet aux développeurs de fournir des services aux applications s'exécutant sur des plateformes cloud telles que Cloud Foundry, Kubernetes et OpenShift. À partir de la version 3.0, Spring Cloud Open Service Broker prend en charge les frameworks Web Spring WebFlux et Spring MVC en utilisant des types réactifs dans les interfaces de contrôleur et de service.

Pour commencer avec Spring Cloud Open Service Broker, incluez le démarreur Spring Boot dans votre application:

implementation('org.springframework.cloud:spring-cloud-starter-open-service-broker:3.1.0.RELEASE') 

Ensuite, nous implémentons ServiceInstateService et ServiceInstateBindingService . Le code suivant illustre l'API requise. Voir l'exemple d'application pour plus de détails.

 @Service public class BookStoreServiceInstanceService implements ServiceInstanceService { @Override public Mono < CreateServiceInstanceResponse > createServiceInstance( CreateServiceInstanceRequest request) { ... } @Override public Mono < GetServiceInstanceResponse > getServiceInstance( GetServiceInstanceRequest request) { ... } @Override public Mono < DeleteServiceInstanceResponse > deleteServiceInstance( DeleteServiceInstanceRequest request) { ... } } 

Données de printemps moore

Dans la famille de projets Spring Data , le support réactif a été initialement introduit dans Spring Data Kay . Spring Data R2DBC a récemment annoncé une version GA, mais Spring Boot n'a pas encore de version GA intégrant Spring Spring R2DBC. Cet exemple utilise MongoDB comme magasin de données de sauvegarde.

Pour commencer avec Reactive MongoDB, incluez le démarreur Spring Boot dans votre application:

 implementation('org.springframework.boot:spring-boot-starter-data-mongodb-reactive') 

Pour démontrer, ajoutez le serveur MongoDB intégré:

 implementation('de.flapdoodle.embed:de.flapdoodle.embed.mongo') 

Ensuite, configurez le référentiel Jet:

 @Configuration @EnableReactiveMongoRepositories(basePackageClasses = { ServiceBrokerRepositoryPackageMarker.class, WebRepositoryPackageMarker.class }) public class ApplicationRepositoryConfiguration { } 

Enfin, définissez ReactiveCrudRepository . L'interface suivante est un exemple d'un exemple d'application:

 public interface ServiceInstanceRepository extends ReactiveCrudRepository < ServiceInstance, String > { } 

Sécurité Spring 5.2

La prise en charge réactive était initialement incluse dans Spring Security 5, et l'intégration avec Spring Boot et Spring Framework continue d'évoluer.

Pour utiliser Spring Security, ajoutez le démarreur Spring Boot:

 implementation('org.springframework.boot:spring-boot-starter-security') 

Ensuite, définissez la configuration de sécurité à l'aide de @EnableWebCardingSecurity . Ce code illustre comment une application protège les points de terminaison de courtier /v2 et /bookstars , qui répondent aux demandes des instances de service:

 @Configuration @EnableWebFluxSecurity public class SecurityConfiguration { @Bean public SecurityWebFilterChain securityWebFilterChain( ServerHttpSecurity http) { return http .csrf().disable() .httpBasic() .and().authorizeExchange() .pathMatchers("/bookstores/**").authenticated() .pathMatchers("/v2/**").hasAuthority( SecurityAuthorities.ADMIN) .matchers(EndpointRequest.to("info", "health")).permitAll() .matchers(EndpointRequest.toAnyEndpoint()).hasAuthority( SecurityAuthorities.ADMIN) .and().build(); } @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } } 

Ensuite, nous implémentons ReactiveUserDetailsService :

 @Service public class RepositoryUserDetailsService implements ReactiveUserDetailsService { private final UserRepository userRepository; public RepositoryUserDetailsService(UserRepository userRepository) { this.userRepository = userRepository; } } 

Enfin, les évaluateurs d'autorisations ne sont pas pris en charge dans les contrôleurs WebFlux, mais nous pouvons obtenir des fonctionnalités similaires en appelant le bean dans l'expression SpEL et en passant l'objet Authentication:

 @GetMapping("/{bookStoreId}") @PreAuthorize("hasAnyRole('ROLE_FULL_ACCESS','ROLE_READ_ONLY') and @bookStoreIdEvaluator.canAccessBookstore(authentication, #bookStoreId)") public Mono<ResponseEntity<BookStoreResource>> getBooks( @PathVariable String bookStoreId) { return bookStoreService.getBookStore(bookStoreId) .flatMap(this::createResponse); } 

Cet exemple analyse les autorisations pour déterminer si un identifiant de librairie existe:

 public boolean canAccessBookstore(Authentication authentication, String bookStoreId) { return authentication.getAuthorities().stream() .filter(authority - > authority.getAuthority() .startsWith(BOOK_STORE_ID_PREFIX)) .map(authority - > { String serviceInstanceId = authority.getAuthority() .substring(BOOK_STORE_ID_PREFIX.length()); return serviceInstanceId.equals(bookStoreId); }) .findFirst() .orElse(true); } 

Spring HATEOAS 1.0

Spring HATEOAS 1.0 GA a été récemment publié et inclut un support réactif pour la liaison et la modélisation des vues.

Ajoutez un Starter Spring HATEOAS pour activer la configuration automatique de Spring Boot. Puisque nous créons l'application réactive Spring WebFlux, nous devons exclure le démarreur Web Spring:

 implementation('org.springframework.boot:spring-boot-starter-hateoas') { exclude group: 'org.springframework.boot', module: 'spring-boot-starter-web' } 

Ensuite, vous pouvez utiliser WebFluxLinkBuilder pour créer des ressources WebFluxLinkBuilder :

 public Mono < BookResource > toModel(Book book, String bookStoreId) { return Mono.just(new BookResource(book)) .flatMap(bookResource - > linkTo(methodOn( BookController.class).getBook(bookStoreId, book.getId())) .withSelfRel() .toMono() .flatMap(link - > Mono.just(bookResource.add(link))) .thenReturn(bookResource)); } 

Ensuite, vous pouvez utiliser cette ressource dans le corps de la réponse du contrôleur:

 return new BookStoreResourceAssembler().toModel(bookStore) .flatMap(bookStoreResource - > Mono.just(new ResponseEntity < > (bookStoreResource, HttpStatus.OK))); 

Framework Spring 5.2

Spring Framework 5 proposait à l'origine un support réactif dans le nouveau Spring WebFlux Web Framework. De plus, les nouveaux WebClient et WebTestClient incluent la prise en charge de l'utilisation et du test des applications Spring WebFlux.

Pour les utiliser, ajoutez simplement des démarreurs Spring Boot:

 implementation('org.springframework.boot:spring-boot-starter-webflux') testImplementation('org.springframework.boot:spring-boot-starter-test') { exclude group: 'org.junit.vintage', module: 'junit-vintage-engine' } 

Par exemple, utilisez WebTestClient pour tester la fonctionnalité du contrôleur:

 this.client.get().uri("/bookstores/{bookStoreId}", bookStoreId) .accept(MediaType.APPLICATION_JSON) .exchange() .expectStatus().isEqualTo(HttpStatus.OK); 

Spring boot 2.2

Spring Boot rassemble tous ces projets, offrant la configuration automatique du support réactif dans Spring WebFlux, Spring Data, Spring Security, Spring HATEOAS, ainsi que dans des outils de test. Dans de nombreux cas, l'implémentation ne nécessite que l'ajout de démarreurs Spring Boot spécifiques ou de dépendances associées pour activer la fonctionnalité.

Conclusion

Ce message comprend une brève introduction au support réactif dans certains projets Spring. À mesure que davantage de projets Spring adapteront et prendront en charge les API réactives, les développeurs auront plus de choix pour utiliser la programmation impérative ou réactive dans leurs applications. En outre, cet exemple d'application ne montre que certains des projets Spring qui proposent actuellement un support réactif. Cherchez plus à l'avenir! Si vous avez des questions ou des préoccupations concernant un projet Spring spécifique, veuillez contacter les responsables du projet sur la page GitHub correspondante.

Traduit par @middle_java