Hallo allemaal, en welkom bij de derde post in de serie over Quarkus!
Bij de ontwikkeling van Java-microservices wordt vaak gedacht dat en ā dit zijn aparte en onafhankelijke API's. In de praktijk gebruiken programmeurs meestal de API's die ze al gewend zijn, omdat het leren van nieuwe frameworks en runtime-componenten veel tijd kost. Vandaag zullen we proberen het leren van enkele populaire te vereenvoudigen en laten zien hoe je zowel Spring API's als nieuwe nuttige functionaliteiten tegelijk kunt gebruiken. .
Als we iets dieper ingaan op de details, bekijken we eerst het toepassingsgebied en details van hoe Quarkus de Spring API's ondersteunt, om Spring-ontwikkelaars te laten zien hoe ze MicroProfile API's in hun dagelijkse werk kunnen toepassen. Daarna zullen we de MicroProfile API's bespreken die nuttig zijn voor Spring-ontwikkelaars bij het maken van microservices.
Waarom juist Quarkus? Ten eerste, het is live coding, wat betekent dat wijzigingen in de MicroProfile API, Spring API en andere Java API's automatisch worden herladen met slechts Ć©Ć©n opdracht: mvn quarkus:dev. Ten tweede, de toepassing die we bekijken in de Person-service (die wordt samengesteld uit de Spring, MicroProfile en JPA API's in een binaire uitvoerbare bestand met behulp van de GraalVM native image) start in slechts 0,055 seconden en verbruikt ongeveer 90 MB aan RAM (RSS) op het eindpunt van de RESTful applicatie. De compilatie zelf gebeurt met slechts Ć©Ć©n opdracht: mvn package -Pnative.
We zullen niet dieper ingaan op de details van MicroProfile, maar we willen Spring-ontwikkelaars helpen begrijpen hoe ze in Quarkus de Spring API's samen met de MicroProfile API's kunnen gebruiken.
Containers en Kubernetes
Om deze post niet te overladen, zullen we hier alleen de hoog-niveau aspecten van de ondersteuning bekijken , omdat het belangrijk is om te begrijpen. Quarkus positioneert zich als de Java-stack voor Kubernetes, gericht op het minimaliseren van geheugengebruik en opstarttijd van Java-applicaties en -services, wat resulteert in een hogere dichtheid van implementatie op de host en lagere totale kosten.
Quarkus ondersteunt ook van Kubernetes-resources en biedt begeleiding voor implementatie op Kubernetes- en Red Hat OpenShift-platforms. Bovendien genereert Quarkus automatisch de Dockerfile.jvm (JVM packaging) en Dockerfile.native (native binary packaging) bestanden die nodig zijn voor het creƫren van containers.
En tot slot, met Kubernetes als de doelomgeving voor implementatie, gebruikt Quarkus geen Java-frameworks wanneer een vergelijkbare functionaliteit op het niveau van het Kubernetes-platform zelf is geĆÆmplementeerd. Tabel 1 toont een kaart van functionele overeenkomsten tussen Kubernetes en de standaard Java-frameworks die door Spring-ontwikkelaars worden gebruikt.
Tabel 1. Kaart van de functionele overeenkomsten tussen Java-frameworks en Kubernetes.
Functionaliteit
Traditionele Spring Boot
Kubernetes
Service discovery
Eureka
DNS
Configuratie
Spring Cloud Config
Config Maps / Secrets
Load balancing
Ribbon (aan de clientzijde)
Service, Replication Controller (aan de serverzijde)
Compilatie en uitvoering van de code uit het voorbeeld
In dit artikel verwijzen we naar , waarin zowel de API's van Spring als MicroProfile worden gebruikt, en zelfs die specifieke Java-klasse. De code uit dit voorbeeld kan vanaf de commandoregel worden gecompileerd en uitgevoerd; zie README.md voor meer informatie.
API's van Spring Framework
Dependency Injection
Quarkus ondersteunt een breed scala aan en API's van Spring Dependency Injection (Spring DI). Als je met MicroProfile werkt, , ben je al goed bekend met CDI. Aan de andere kant kunnen Spring-ontwikkelaars de Quarkus Extension for Spring DI API gebruiken om compatibiliteit met Spring DI te waarborgen. Voorbeelden van het gebruik van de ondersteunde Spring DI API's worden gegeven in tabel 2.
In maakt gebruik van zowel CDI als Spring Dependency Injection. Verdere informatie en voorbeelden hierover vind je in de handleiding van Quarkus, genaamd .
Tabel 2. Voorbeelden van het gebruik van ondersteunde Spring DI API's.
Ondersteunde functies van Spring DI
Voorbeelden
Constructor Injection
public PersonSpringController(
PersonSpringRepository personRepository, // geĆÆnjecteerd
PersonSpringMPService personService) { // geĆÆnjecteerd
this.personRepository = personRepository;
this.personService = personService;
}
Field Injection
@Autowired
@RestClient
SalutationRestClient salutationRestClient;
@Value("${fallbackSalutation}")
String fallbackSalutation;
@Configuration
@Configuration
public class AppConfiguration {
@Bean(name = "capitalizeFunction")
public StringFunction capitalizer() {
return String::toUpperCase;
}
}
@Component("noopFunction")
public class NoOpSingleStringFunction implements StringFunction {
@Override
public String apply(String s) {
return s;
}
}
@Service
public class MessageProducer {
@Value("${greeting.message}")
String message;
public String getPrefix() {
return message;
}
}
Web Framework
MicroProfile-gebruikers zullen blij zijn dat Quarkus JAX-RS, MicroProfile Rest Client, JSON-P en JSON-B ondersteunt als de belangrijkste webprogrammeer-modellen. Spring-ontwikkelaars zullen verheugd zijn over de onlangs toegevoegde ondersteuning voor de Spring Web API in Quarkus, met name de interfaces die verantwoordelijk zijn voor REST. Net als bij Spring DI is het belangrijkste doel van de ondersteuning voor Spring Web API dat Spring-ontwikkelaars de Spring Web API-interfaces samen met de MicroProfile API-interfaces kunnen gebruiken. Voorbeelden van het gebruik van de ondersteunde Spring Web API worden gegeven in tabel 3, en extra informatie en voorbeelden hierover zijn te vinden in de Quarkus-handleiding met de titel .
Tabel 3. Voorbeelden van het gebruik van de ondersteunde Spring Web API-interfaces.
Ondersteunde functies van Spring Web
Voorbeelden
@RestController
@RequestMapping
@RestController
@RequestMapping("/person")
public class PersonSpringController {
...
...
...
}
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
@RequestParam
@RequestHeader
@MatrixVariable
@PathVariable
@CookieValue
@RequestBody
@ResponseStatus
@ExceptionHandler
@RestControllerAdvice (gedeeltelijk)
@GetMapping(path = "/greet/{id}",
produces = "text/plain")
public String greetPerson(
@PathVariable(name = "id") long id) {
...
...
...
}
Spring Data JPA
MicroProfile-gebruikers zullen ook blij zijn dat Quarkus JPA ondersteunt met Hibernate ORM. Voor Spring-ontwikkelaars is er ook goed nieuws: Quarkus ondersteunt de veelgebruikte annotaties en types van Spring Data JPA. Voorbeelden van het gebruik van de ondersteunde Spring Data JPA API worden gegeven in tabel 4.
In gebruikte Spring Data JPA API-interfaces, en extra informatie is beschikbaar in de Quarkus-handleiding met de titel .
Tabel 4. Voorbeelden van het gebruik van de ondersteunde Spring Data JPA API-interfaces.
Ondersteunde functies van Spring Data JPA
Voorbeelden
CrudRepository
public interface PersonRepository
extends JpaRepository,
PersonFragment {
...
}
Repository
JpaRepository
PagingAndSortingRepository
public class PersonRepository extends
Repository {
Person save(Person entity);
Optional findById(Person entity);
}
Repository Fragmenten
public interface PersonRepository
extends JpaRepository,
PersonFragment {
...
}
Afgeleide querymethoden
public interface PersonRepository extends CrudRepository {
List findByName(String name);
Person findByNameBySsn(String ssn);
Optional
findByNameBySsnIgnoreCase(String ssn);
Boolean existsBookByYearOfBirthBetween(
Integer start, Integer end);
}
Door de gebruiker gedefinieerde queries
public interface MovieRepository
extends CrudRepository {
Movie findFirstByOrderByDurationDesc();
@Query("select m from Movie m where m.rating = ?1")
Iterator findByRating(String rating);
@Query("from Movie where title = ?1")
Movie findByTitle(String title);
}
MicroProfile API-interfaces
Fouttolerantie
Fouttolerantieconstructies zijn cruciaal om cascadering van storingen te voorkomen en robuuste microservices-architecturen te creƫren. Spring-ontwikkelaars maken al jarenlang gebruik van circuit-breakers voor fouttolerantie. . Hystrix is echter al een tijd niet meer bijgewerkt, terwijl de MicroProfile Fault Tolerance momenteel actief wordt ontwikkeld en al enkele jaren in productie gebruikt wordt. Daarom wordt aanbevolen om de API's van MicroProfile Fault Tolerance toe te passen in Quarkus om de betrouwbaarheid van diensten te verhogen. Voorbeelden van gebruik worden gegeven in tabel 5. Verdere informatie hierover is te vinden in de Quarkus-handleiding. .
Tabel 5. Voorbeelden van het gebruik van ondersteunde MicroProfile Fault Tolerance API's.
Functies van MicroProfile Fault Tolerance
Omschrijving
Voorbeelden
@Asynchronous
Logica uitvoeren in een aparte thread
@Asynchronous
@Retry
public Future getSalutation() {
...
return future;
}
@Bulkhead
Beperking van het aantal gelijktijdige aanvragen
@Bulkhead(5)
public void fiveConcurrent() {
makeRemoteCall(); //...
}
@CircuitBreaker
Slimme foutafhandeling en herstel na een storing
@CircuitBreaker(delay=500 // milliseconden
failureRatio = .75,
requestVolumeThreshold = 20,
successThreshold = 5)
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
makeRemoteCall(); //...
}
@Fallback
Alternatieve logica aanroepen in geval van een storing
@Timeout(500) // milliseconden
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
makeRemoteCall(); //...
}
public String fallback() {
return "hello";
}
Herhalen bij een mislukte aanvraag
@Retry(maxRetries=3)
public String getSalutation() {
makeRemoteCall(); //...
}
Tijdslimiet bij een mislukking
@Timeout(value = 500 ) // milliseconden
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
makeRemoteCall(); //...
}
Service Gezondheid (Service Health)
Kubernetes-platforms volgen de gezondheidsstatus van containers met speciale diensten. Om ervoor te zorgen dat het onderliggende platform de diensten kan monitoren, gebruiken Spring-ontwikkelaars doorgaans configureerbare HealthIndicator en Spring Boot Actuator. In Quarkus kan dit gedaan worden met behulp van MicroProfile Health, die standaard een werkbaarheidscontrole (liveness check) uitvoeren, maar ook kunnen worden ingesteld voor zowel liveness als readiness (gereedheid) controle. Voorbeelden van het gebruik van de ondersteunde MicroProfile Health API's worden gegeven in tabel 6, en aanvullende informatie is te vinden in de Quarkus-handleiding. .
Tabel 6. Voorbeelden van het gebruik van ondersteunde MicroProfile Health API's.
Functies van MicroProfile Health
Omschrijving
Voorbeelden
@Liveness
Het platform herstart defecte container-applicaties.
Eindpunt:
host:8080/health/live
@Liveness
public class MyHC implements HealthCheck {
public HealthCheckResponse call() {
...
return HealthCheckResponse
.named("myHCProbe")
.status(ready ? true:false)
.withData("mydata", data)
.build();
}
@Readiness
Het platform zal geen verkeer naar de containerapplicaties sturen als deze niet gereed zijn.
Eindpunt:
host:8080/health/ready
@Readiness
public class MyHC implements HealthCheck {
public HealthCheckResponse call() {
...
return HealthCheckResponse
.named("myHCProbe")
.status(live ? true:false)
.withData("mydata", data)
.build();
}
Statistieken
Applicaties bieden statistieken aan of voor operationele doeleinden (ter controle van SLA-prestatienormen) of voor niet-operationele doeleinden (SLA-bedrijfsstatistieken). Spring-ontwikkelaars bieden statistieken aan met behulp van Spring Boot Actuator en Micrometer. Quarkus gebruikt MicroProfile Metrics voor het bieden van basisstatistieken (JVM en besturingssysteem), vendor-statistieken (Quarkus) en applicatiestatistieken. MicroProfile Metrics vereist dat de implementatie uitvoerformaten JSON en OpenMetrics (Prometheus) ondersteunt. Voorbeelden van het gebruik van de MicroProfile Metrics API zijn te vinden in tabel 7.
In MicroProfile Metrics worden gebruikt voor het bieden van applicatiestatistieken. Meer informatie is te vinden in de Quarkus-handleiding. .
Tabel 7. Voorbeelden van het gebruik van MicroProfile Metrics-API's.
Functies van MicroProfile Metrics
Omschrijving
Voorbeelden
@Counted
Geeft een counter aan die het aantal aanroepingen van het geannoteerde object telt.
@Counted(name = "fallbackCounter",
displayName = "Fallback Counter",
description = "Fallback Counter")
public String salutationFallback() {
return fallbackSalutation;
}
@ConcurrentGauge
Geeft een gauge aan die het aantal gelijktijdige aanroepingen van het geannoteerde object telt.
@ConcurrentGuage(
name = "fallbackConcurrentGauge",
displayName="Fallback Concurrent",
description="Fallback Concurrent")
public String salutationFallback() {
return fallbackSalutation;
}
@Gauge
Geeft een gauge aan die de waarde van het geannoteerde object meet.
@Metered(name = "FallbackGauge",
displayName="Fallback Gauge",
description="Fallback frequency")
public String salutationFallback() {
return fallbackSalutation;
}
@Metered
Geeft een meter aan die de frequentie van het aanroepen van het geannoteerde object bijhoudt.
@Metered(name = "MeteredFallback",
displayName="Metered Fallback",
description="Fallback frequency")
public String salutationFallback() {
return fallbackSalutation;
}
Annotatie die informatie over metadata bevat, wanneer het verzoek om invoer of productie van een metriek komt.
@Metric
@Metered(name = "MeteredFallback",
displayName="Metered Fallback",
description="Fallback frequency")
public String salutationFallback() {
return fallbackSalutation;
}
Geeft een timer aan die de duur van het geannoteerde object bijhoudt.
@Timed(name = "TimedFallback",
displayName="Timed Fallback",
description="Fallback delay")
public String salutationFallback() {
return fallbackSalutation;
}
Metrics Endpoints
Toepassingen Metrics :8080/metrics/application
Basis Metrics :8080/metrics/base
Leverancier Metrics :8080/metrics/vendor
Alle Metrics :8080/metrics
MicroProfile Rest Client
Microservices bieden vaak RESTful eindpunten waarvoor overeenkomstige client-API's nodig zijn. Voor het werken met RESTful eindpunten gebruiken Spring-ontwikkelaars doorgaans RestTemplate. Quarkus biedt hiervoor de MicroProfile Rest Client API-interfaces, waarvan voorbeelden in tabel 8 worden gegeven.
In Het gebruik van RESTful eindpunten gebeurt met behulp van de MicroProfile Rest Client. Verdere informatie en voorbeelden hierover zijn te vinden in de Quarkus handleiding. .
Tabel 8. Voorbeelden van het gebruik van de MicroProfile Rest Client API-interfaces.
Functies van MicroProfile Rest Client
Omschrijving
Voorbeelden
@RegisterRestClient
Registratie van een getypeerde Java-interface als REST client
@RegisterRestClient
@Path("/")
public interface MyRestClient {
@GET
@Produces(MediaType.TEXT_PLAIN)
public String getSalutation();
}
@RestClient
Markeert de injectie van een exemplaar van de getypeerde REST client interface
@Autowired // of @Inject
@RestClient
MyRestClient restClient;
Aanroep
Roept het REST eindpunt aan
System.out.println(
restClient.getSalutation());
mp-rest/url
Stelt het REST eindpunt in
application.properties:
org.example.MyRestClient/mp-rest/url=
http://localhost:8081/myendpoint
Conclusies
In deze blog, die vooral nuttig is voor Spring-ontwikkelaars, hebben we kort bekeken hoe Quarkus API-interfaces van Spring kan gebruiken samen met de API-interfaces van MicroProfile om Java-microservices te ontwikkelen en deze vervolgens te compileren naar native binaire code, wat honderden megabytes RAM bespaart en in een paar milliseconden opstart.
Zoals je al hebt begrepen, zijn verdere informatie over de ondersteuning van Spring en MicroProfile API-interfaces, evenals veel andere nuttige informatie te vinden in .
Bron: habr.com
