Moien alleguer, hei den drëtten Post an der Quarkus-Serie!
Wann Dir Java Mikroservicer entwéckelt, gëtt et dacks gegleeft datt и sinn separat an onofhängeg APIen. Par défaut tendéieren d'Programméierer d'APIs ze benotzen, un déi se scho gewinnt sinn, well d'Léieren vun neie Kaderen a Runtime Komponenten vill Zäit hëlt. Haut wäerte mir probéieren d'Entwécklung vun e puer populär ze vereinfachen a weisen Iech wéi Dir gläichzäiteg de Spring API an nei nëtzlech Funktiounen benotzt .
An e bësse méi Detail wäerte mir als éischt den Ëmfang an d'Detailer kucken wéi Quarkus Spring APIs ënnerstëtzt fir Fréijoer Entwéckler ze weisen wéi d'MicroProfile API an hirer alldeeglecher Aarbecht benotzen. Da wäerte mir d'MicroProfile APIs ofdecken, déi nëtzlech si fir Fréijoer Entwéckler wann Dir Mikroservicer erstellt.
Firwat Quarkus? Als éischt ass dëst Live Kodéierung, dat heescht automatesch Neiluede vun all Ännerungen an der MicroProfile API, Spring API an aner Java APIs, déi mat just engem Kommando ausgefouert gëtt: mvn quarkus:dev. Zweetens, betruecht an de Person Service (deen aus Spring, MicroProfile, a JPA APIs an e Binär kompiléiert mat dem gebiertege GraalVM Bild) fänkt an just 0.055 Sekonnen un an hëlt ongeféier 90 MB RAM (RSS) um RESTful Applikatioun Endpunkt. Ausserdeem gëtt seng Kompiléierung selwer mat just engem Kommando ausgefouert: mvn Package -Pnative.
Mir ginn net an den Detail iwwer MicroProfile, ausser fir Spring Entwéckler ze hëllefen ze verstoen wéi se Spring APIs mat MicroProfile APIs am Quarkus benotze kënnen.
Container a Kubernetes
Fir dësen Artikel einfach ze halen, wäerte mir nëmmen déi héich-Niveau Aspekter vun der Ënnerstëtzung hei ofdecken. , well et wichteg ass ze verstoen. Quarkus ass als Java-Stack fir Kubernetes positionéiert, et ass entwéckelt fir de Gedächtnisverbrauch an d'Startzäit vun Java Uwendungen a Servicer ze minimiséieren, an als Resultat hir Dicht um Host erhéijen an d'Gesamtkäschte reduzéieren.
Quarkus och Kubernetes Ressourcen an Offeren fir Deployment op Kubernetes a Red Hat OpenShift Plattformen. Zousätzlech generéiert Quarkus automatesch d'Dockerfile.jvm (JVM Packaging) an Dockerfile.native (native binäre Verpackungen) Dateien déi néideg sinn fir Container ze kreéieren.
Schlussendlech, andeems Dir op Kubernetes als Zil-Deployment Ëmfeld fokusséiert, benotzt Quarkus keng Java Frameworks a Fäll wou ähnlech Funktionalitéit um Niveau vun der Kubernetes Plattform selwer implementéiert gëtt. Table 1 bitt eng Kaart vun der funktioneller Korrespondenz tëscht Kubernetes an typesche Java Frameworks, déi vu Spring Entwéckler benotzt ginn.
Dësch 1. Kaart vun funktionell Korrespondenz tëscht Java Kaderen an Kubernetes.
Funktionell
Traditionell Fréijoer Boot
Kubernetes
Service Entdeckung
Eureka
DNS
Configuratioun
Fréijoer Cloud Config
Config Kaarten / Geheimnisser
Lueden ausgeglach
Ribbon (Client Säit)
Service, Replikatiounscontroller (Server Säit)
De Code aus dem Beispill kompiléieren a lafen
An dësem Artikel bezéie mir op , wou d'Spring- a MicroProfile APIen a souguer déiselwecht Java-Klass zesumme benotzt ginn. De Code an dësem Beispill ka kompiléiert a lafen aus der Kommandozeil, kuckt d'README.md Datei fir Detailer.
Fréijoer Framework APIen
Ofhängegkeet Injektioun
Quarkus ënnerstëtzt eng Rei vun a Fréijoer Ofhängegkeet Injektioun (Fréijoer DI) APIen. Wann Dir mat MicroProfile schafft, , da kennt Dir scho ganz gutt mam CDI. Op der anerer Säit kënnen Spring Entwéckler d'Quarkus Extension fir Spring DI API benotzen fir Kompatibilitéit mat Spring DI z'erreechen. Beispiller fir déi ënnerstëtzte Spring DI APIs ze benotzen ginn an der Tabell 2 uginn.
В Benotzt souwuel CDI a Fréijoer Ofhängegkeet Injektioun. Fir méi Informatiounen a Beispiller iwwer dëst Thema, kuckt de Quarkus Guide genannt .
Dësch 2. Beispiller vun engem benotzen der ënnerstëtzt Fréijoer DI APIen.
Ënnerstëtzt Fréijoer DI Fonctiounen
Beispiller
Constructor Injektioun
public PersonSpringController(
PersonSpringRepository personRepository, // injected
PersonSpringMPService personService) { // injected
this.personRepository = personRepository;
this.personService = personService;
}
Feld Injektioun
@Autowired
@RestClient
SalutationRestClient salutationRestClient;
@Value("${fallbackSalutation}")
String fallbackSalutation;
@ Konfiguratioun
@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 Kader
MicroProfile Benotzer wäerte gär hunn datt Quarkus JAX-RS, MicroProfile Rest Client, JSON-P, an JSON-B als primäre Webprogramméierungsmodell ënnerstëtzt. Fréijoer Entwéckler wäerten zefridde mat Quarkus 'rezent Ënnerstëtzung fir de Spring Web API, besonnesch REST Interfaces. Ähnlech wéi Spring DI, ass d'Haaptziel vun der Spring Web API Ënnerstëtzung Spring Entwéckler z'erméiglechen Spring Web APIs a Verbindung mat MicroProfile APIs ze benotzen. Beispiller vu wéi Dir déi ënnerstëtzt Spring Web APIs benotzt gëtt an der Tabell 3 geliwwert, a méi Informatioun a Beispiller iwwer dëst Thema kënnen am Quarkus Tutorial fonnt ginn. .
Dësch 3. Beispiller vun engem benotzen der ënnerstëtzt Fréijoer Web APIen.
Ënnerstëtzt Fréijoer Web Fonctiounen
Beispiller
@RestController
@RequestMapping
@RestController
@RequestMapping("/person")
public class PersonSpringController {
...
...
...
}
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
@RequestParam
@RequestHeader
@MatrixVariable
@PathVariable
@CookieValue
@RequestBody
@ResponseStatus
@ExceptionHandler
@RestControllerAdvice (deelweis)
@GetMapping(path = "/greet/{id}",
produces = "text/plain")
public String greetPerson(
@PathVariable(name = "id") long id) {
...
...
...
}
Fréijoersdaten JPA
MicroProfile Benotzer wäerten och schätzen datt Quarkus JPA ënnerstëtzt mat der Hibernate ORM. Et gëtt och gutt Neiegkeet fir Fréijoer Entwéckler: Quarkus ënnerstëtzt gemeinsam Spring Data JPA Annotatiounen an Typen. Beispiller fir déi ënnerstëtzte Spring Data JPA APIs ze benotzen ginn an der Tabell 4 uginn.
В Spring Data JPA APIs gi benotzt a méi Informatioun ass verfügbar am Quarkus Tutorial genannt .
Dësch 4. Beispiller vun engem benotzen ënnerstëtzt Fréijoer Data JPA APIen.
Ënnerstëtzt Fréijoer Data JPA Fonctiounen
Beispiller
CrudRepository
public interface PersonRepository
extends JpaRepository,
PersonFragment {
...
}
Repository
JpaRepository
PagingAndSortingRepository
public class PersonRepository extends
Repository {
Person save(Person entity);
Optional findById(Person entity);
}
Repository Fragmenter
public interface PersonRepository
extends JpaRepository,
PersonFragment {
...
}
Ofgeleet Ufromethoden
public interface PersonRepository extends CrudRepository {
List findByName(String name);
Person findByNameBySsn(String ssn);
Optional
findByNameBySsnIgnoreCase(String ssn);
Boolean existsBookByYearOfBirthBetween(
Integer start, Integer end);
}
Benotzerdefinéiert Ufroen
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 APIen
Feeler Toleranz
Feeler Toleranzkonstruktioune si ganz wichteg fir Kaskadfehler ze vermeiden an zouverlässeg Mikroservicearchitekturen ze kreéieren. Fréijoer Entwéckler hunn Circuit-breakers fir Feeler Toleranz fir vill Joren benotzt. . Wéi och ëmmer, Hystrix ass net laang aktualiséiert ginn, awer MicroProfile's Fault Tolerance ass elo aktiv entwéckelt an huet e puer Joer Produktiounsnotzung hannert sech. Dofir, fir d'Zouverlässegkeet vun de Servicer am Quarkus ze verbesseren, ass et recommandéiert d'MicroProfile Fault Tolerance APIs ze benotzen, Beispiller vun deenen an der Tabell benotzt ginn 5. Fir méi Informatiounen iwwer dëst, kuckt d'Quarkus Handbuch .
Dësch 5. Beispiller vun engem benotzen ënnerstëtzt MicroProfile Feeler Toleranz APIen.
MicroProfile Feeler Toleranz Fonctiounen
Beschreiwung
Beispiller
@Asynchron
Logik ausféieren an engem getrennten Fuedem
@Asynchronous
@Retry
public Future<String> getSalutation() {
...
return future;
}
@Schlass
Limitéiert d'Zuel vun de simultan Ufroen
@Bulkhead(5)
public void fiveConcurrent() {
makeRemoteCall(); //...
}
@CircuitBreaker
Smart Feeler Ëmgank an Erhuelung vu Feeler
@CircuitBreaker(delay=500 // milliseconds
failureRatio = .75,
requestVolumeThreshold = 20,
successThreshold = 5)
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
makeRemoteCall(); //...
}
@Zréckfalen
Opruff alternativ Logik am Fall vun Echec
@Timeout(500) // milliseconds
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
makeRemoteCall(); //...
}
public String fallback() {
return "hello";
}
Reprobéieren op Ufro Feeler
@Retry(maxRetries=3)
public String getSalutation() {
makeRemoteCall(); //...
}
Feeler Kontroll Timeout
@Timeout(value = 500 ) // milliseconds
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
makeRemoteCall(); //...
}
Kontroll Servicer (Service Gesondheet)
Kubernetes Plattformen iwwerwaachen d'Gesondheet vu Container mat spezielle Servicer. Fir déi ënnerierdesch Plattform z'erméiglechen Servicer ze iwwerwaachen, benotzen Fréijoer Entwéckler typesch e personaliséierte HealthIndicator a Spring Boot Actuator. Am Quarkus kann dëst mat MicroProfile Health gemaach ginn, deen par défaut e Livenesscheck ausféiert, awer ka konfiguréiert ginn fir gläichzäiteg d'Liveness a Bereetschaft ze kontrolléieren. Beispiller vu wéi Dir déi ënnerstëtzte MicroProfile Health APIs benotzt gëtt an der Tabell 6 geliwwert, an zousätzlech Informatioun gëtt am Quarkus Handbuch geliwwert .
Dësch 6: Benotzungsbeispiller vun ënnerstëtzte MicroProfile Health APIs.
MicroProfile Gesondheet Fonctiounen
Beschreiwung
Beispiller
@Liveness
D'Plattform reboots gescheitert containeriséierter Uwendungen
Endpunkt:
Host: 8080 / Gesondheet / liewen
@Liveness
public class MyHC implements HealthCheck {
public HealthCheckResponse call() {
...
return HealthCheckResponse
.named("myHCProbe")
.status(ready ? true:false)
.withData("mydata", data)
.build();
}
@ Bereetschaft
D'Plattform wäert kee Traffic op containeriséierte Applikatiounen schécken wann et net fäerdeg ass
Endpunkt:
Host: 8080 / Gesondheet / prett
@Readiness
public class MyHC implements HealthCheck {
public HealthCheckResponse call() {
...
return HealthCheckResponse
.named("myHCProbe")
.status(live ? true:false)
.withData("mydata", data)
.build();
}
Metriken
D'Applikatioune bidden Metriken fir entweder operationell Zwecker (fir Performance SLAs ze iwwerwaachen) oder net operationell Zwecker (Business SLAs). Fréijoer Entwéckler bidden Metriken mam Spring Boot Actuator a Micrometer. Am Tour benotzt Quarkus MicroProfile Metrics fir Baseline Metriken (JVM a Betribssystem), Vendor Metrics (Quarkus) an Applikatiounsmetriken ze bidden. MicroProfile Metrics erfuerdert datt d'Implementatioun JSON an OpenMetrics (Prometheus) Outputformater ënnerstëtzt. Beispiller fir d'Benotzung vun der MicroProfile Metrics API ginn an Table 7 uginn.
В MicroProfile Metriken gi benotzt fir Applikatiounsmetriken ze bidden. Fir méi Informatiounen, kuckt de Quarkus Handbuch .
Dësch 7. Beispiller vun benotzen MicroProfile Metrik APIen.
MicroProfile Metric Features
Beschreiwung
Beispiller
@Gezielt
Bezeechnet e Konterzähler deen d'Zuel vun Mol zielt en annotéierten Objet genannt gouf
@Counted(name = "fallbackCounter",
displayName = "Fallback Counter",
description = "Fallback Counter")
public String salutationFallback() {
return fallbackSalutation;
}
@ConcurrentGauge
Bedeit e Jauge deen d'Zuel vun de concurrenten Uruff un en annotéierten Objet zielt
@ConcurrentGuage(
name = "fallbackConcurrentGauge",
displayName="Fallback Concurrent",
description="Fallback Concurrent")
public String salutationFallback() {
return fallbackSalutation;
}
@Gesiicht
Bedeit e Jauge Sensor deen de Wäert vun engem annotéierten Objet moosst
@Metered(name = "FallbackGauge",
displayName="Fallback Gauge",
description="Fallback frequency")
public String salutationFallback() {
return fallbackSalutation;
}
@Meter
Bedeit e Metersensor deen d'Urufffrequenz vun engem annotéierten Objet iwwerwaacht
@Metered(name = "MeteredFallback",
displayName="Metered Fallback",
description="Fallback frequency")
public String salutationFallback() {
return fallbackSalutation;
}
Eng Annotatioun mat Informatioun iwwer Metadaten wann eng Ufro kritt gëtt fir eng Metrik anzeginn oder ze produzéieren
@Metric
@Metered(name = "MeteredFallback",
displayName="Metered Fallback",
description="Fallback frequency")
public String salutationFallback() {
return fallbackSalutation;
}
Gëtt en Timer un, deen d'Dauer vun engem annotéierten Objet verfollegt
@Timed(name = "TimedFallback",
displayName="Timed Fallback",
description="Fallback delay")
public String salutationFallback() {
return fallbackSalutation;
}
Metrik Endpunkter
Applikatioun Metriken :8080 / Metrik / Applikatioun
Basis Metriken : 8080/Metrics/Basis
Verkeefer Metriken : 8080 / Metrik / Verkeefer
All Metriken : 8080/Meth
MicroProfile Rescht Client
Mikroservicer bidden dacks RESTful Endpunkter déi entspriechend Client APIe erfuerderen fir mat ze schaffen. Fir RESTful Endpunkter ze benotzen, benotzen Fréijoer Entwéckler typesch RestTemplate. Quarkus bitt MicroProfile Rest Client APIs fir dëse Problem ze léisen, Beispiller fir d'Benotzung vun deenen an der Tabell 8 uginn.
В d'Benotzung vu RESTful Endpunkte gëtt mam MicroProfile Rest Client gemaach. Méi Informatioun an Beispiller zu dësem Thema kënnen am Quarkus Handbuch fonnt ginn .
Dësch 8. Beispiller vun benotzen MicroProfile Rescht Client APIen.
MicroProfile Rescht Client Fonctiounen
Beschreiwung
Beispiller
@RegisterRestClient
Registréiert eng getippten Java Interface als REST Client
@RegisterRestClient
@Path("/")
public interface MyRestClient {
@GET
@Produces(MediaType.TEXT_PLAIN)
public String getSalutation();
}
@RestClient
Markéiert d'Ëmsetzung vun enger Instanz vun engem getippten REST Client Interface
@Autowired // or @Inject
@RestClient
MyRestClient restClient;
Invokéieren
Rufft e REST Endpunkt
System.out.println(
restClient.getSalutation());
mp-rest/url
Spezifizéiert de REST Endpunkt
application.properties:
org.example.MyRestClient/mp-rest/url=
http://localhost:8081/myendpoint
Resultater
An dësem Blog, riicht haaptsächlech op Spring Entwéckler, hu mir e séiere Bléck op d'Fréijoer APIs mat de MicroProfile APIs zu Quarkus benotzt fir Java Mikroservicer z'entwéckelen an dann an native binäre Code ze kompiléieren deen Honnerte vu Megabytes RAM spuert a lancéiert an eng Saach vu Millisekonnen.
Wéi Dir scho verstanen hutt, méi Informatioun iwwer Ënnerstëtzung fir d'Spring- a MicroProfile APIs, wéi och vill aner nëtzlech Informatioun, fannt Dir an .
Source: will.com