Hallo allegear, hjir is it tredde berjocht yn 'e Quarkus-searje!
By it ûntwikkeljen fan Java-mikrotsjinsten wurdt it faaks leaud dat и binne aparte en ûnôfhinklike APIs. Standert hawwe programmeurs de neiging om de API's te brûken wêr't se al oan wend binne, om't it learen fan nije kaders en runtime-komponinten in protte tiid nimt. Hjoed sille wy besykje te ferienfâldigjen de ûntwikkeling fan guon populêre en lit jo sjen hoe't jo tagelyk de Spring API en nije nuttige funksjes kinne brûke .
Yn in bytsje mear detail sille wy earst de omfang en details sjen fan hoe't Quarkus Spring API's stipet om Spring-ûntwikkelders sjen te litten hoe't se de MicroProfile API kinne brûke yn har deistich wurk. Dan sille wy de MicroProfile API's dekke, dy't nuttich binne foar Spring-ûntwikkelders by it meitsjen fan mikrotsjinsten.
Wêrom Quarkus? As earste is dit live kodearring, dat is, automatysk opnij laden fan alle wizigingen yn 'e MicroProfile API, Spring API en oare Java API's, dy't wurdt útfierd mei mar ien kommando: mvn quarkus:dev. Twads, besprutsen yn de Person-tsjinst (dy't kompilearret fan Spring, MicroProfile, en JPA API's yn in binêr mei it native GraalVM-ôfbylding) begjint yn just 0.055 sekonden en nimt sawat 90 MB RAM (RSS) op op it RESTful-applikaasje-einpunt. Boppedat wurdt de kompilaasje sels útfierd mei mar ien kommando: mvn-pakket -Pnative.
Wy sille net yn detail gean oer MicroProfile, oars dan om Spring-ûntwikkelders te helpen te begripen hoe't se Spring API's kinne brûke mei MicroProfile API's yn Quarkus.
Containers en Kubernetes
Om dit artikel ienfâldich te hâlden, sille wy hjir allinich de aspekten fan stipe op hege nivo dekke. , om't it wichtich is om te begripen. Quarkus is gepositioneerd as in Java-stapel foar Kubernetes, it is ûntworpen om ûnthâldferbrûk en opstarttiid fan Java-applikaasjes en tsjinsten te minimalisearjen, en, as gefolch, har tichtens op 'e host te fergrutsjen en totale kosten te ferminderjen.
Quarkus ek Kubernetes boarnen en oanbiedingen foar ynset op Kubernetes en Red Hat OpenShift platfoarms. Derneist genereart Quarkus automatysk de Dockerfile.jvm (JVM-ferpakking) en Dockerfile.native (native binêre ferpakking) bestannen dy't nedich binne om konteners te meitsjen.
Uteinlik, troch te fokusjen op Kubernetes as de omjouwing foar doelynset, brûkt Quarkus gjin Java-frameworks yn gefallen dêr't ferlykbere funksjonaliteit wurdt ymplementearre op it nivo fan it Kubernetes-platfoarm sels. Tabel 1 jout in kaart fan 'e funksjonele korrespondinsje tusken Kubernetes en typyske Java-ramten brûkt troch Spring-ûntwikkelders.
Tabel 1. Kaart fan funksjonele korrespondinsje tusken Java kaders en Kubernetes.
Funksjoneel
Tradisjoneel Spring Boot
Kubernetes
Service ûntdekking
Eureka
DNS
konfiguraasje
Spring Cloud Config
Konfigurearje kaarten / geheimen
Loadbalansearring
Lint (client side)
Tsjinst, replikaasjecontroller (serverside)
De koade kompilearje en útfiere út it foarbyld
Yn dit artikel ferwize wy nei , wêr't de Spring- en MicroProfile API's en sels deselde Java-klasse tegearre wurde brûkt. De koade yn dit foarbyld kin wurde kompilearre en rinne út de kommandorigel, sjoch de README.md triem foar details.
Spring Framework APIs
Ofhinklikens ynjeksje
Quarkus stipet in berik fan en Spring Dependency Injection (Spring DI) APIs. As jo wurkje mei MicroProfile, , dan binne jo al tige bekend mei CDI. Oan 'e oare kant kinne Spring-ûntwikkelders de Quarkus-útwreiding foar Spring DI API brûke om kompatibiliteit te berikken mei Spring DI. Foarbylden fan it brûken fan de stipe Spring DI API's wurde jûn yn Tabel 2.
В Brûkt sawol CDI as Spring Dependency Injection. Mear ynformaasje en foarbylden oer dit ûnderwerp is te finen yn 'e Quarkus-gids neamd .
tabel 2. Foarbylden fan it brûken fan de stipe Spring DI APIs.
Stipe Spring DI Features
foarbylden
Constructor Ynjeksje
public PersonSpringController(
PersonSpringRepository personRepository, // injected
PersonSpringMPService personService) { // injected
this.personRepository = personRepository;
this.personService = personService;
}
Field Ynjeksje
@Autowired
@RestClient
SalutationRestClient salutationRestClient;
@Value("${fallbackSalutation}")
String fallbackSalutation;
@ Konfiguraasje
@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-brûkers sille leuk fine dat Quarkus JAX-RS, MicroProfile Rest Client, JSON-P, en JSON-B stipet as it primêre webprogrammearringsmodel. Spring-ûntwikkelders sille bliid wêze mei de resinte stipe fan Quarkus foar de Spring Web API, benammen REST-ynterfaces. Fergelykber mei Spring DI is it haaddoel fan Spring Web API-stipe om Spring-ûntwikkelders yn te skeakeljen Spring Web API's te brûken yn kombinaasje mei MicroProfile API's. Foarbylden fan hoe't jo de stipe Spring Web API's brûke kinne wurde jûn yn Tabel 3, en mear ynformaasje en foarbylden oer dit ûnderwerp kinne fûn wurde yn 'e Quarkus tutorial neamd .
tabel 3. Foarbylden fan it brûken fan de stipe Spring Web APIs.
Stipe Spring Web Features
foarbylden
@RestController
@RequestMapping
@RestController
@RequestMapping("/person")
public class PersonSpringController {
...
...
...
}
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
@RequestParam
@RequestHeader
@MatrixVariable
@PathVariable
@CookieValue
@RequestBody
@ResponseStatus
@ExceptionHandler
@RestControllerAdvice (diel)
@GetMapping(path = "/greet/{id}",
produces = "text/plain")
public String greetPerson(
@PathVariable(name = "id") long id) {
...
...
...
}
Spring DataJPA
MicroProfile-brûkers sille ek wurdearje dat Quarkus JPA stipet mei de Hibernate ORM. D'r is ek goed nijs foar Spring-ûntwikkelders: Quarkus stipet mienskiplike Spring Data JPA-annotaasjes en -typen. Foarbylden fan it brûken fan de stipe Spring Data JPA API's wurde jûn yn Tabel 4.
В Spring Data JPA APIs wurde brûkt en mear ynformaasje is beskikber yn de Quarkus tutorial neamd .
tabel 4. Foarbylden fan in gebrûk stipe Spring Data JPA APIs.
Stipe Spring Data JPA Features
foarbylden
CrudRepository
public interface PersonRepository
extends JpaRepository,
PersonFragment {
...
}
Repository
JpaRepository
PagingAndSortingRepository
public class PersonRepository extends
Repository {
Person save(Person entity);
Optional findById(Person entity);
}
Repository Fragminten
public interface PersonRepository
extends JpaRepository,
PersonFragment {
...
}
Oflaat query metoaden
public interface PersonRepository extends CrudRepository {
List findByName(String name);
Person findByNameBySsn(String ssn);
Optional
findByNameBySsnIgnoreCase(String ssn);
Boolean existsBookByYearOfBirthBetween(
Integer start, Integer end);
}
Meidogger-definieare 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 APIs
Marzje foar flaters
Konstruksjes foar fouttolerânsje binne heul wichtich foar it foarkommen fan cascadearjende flaters en it meitsjen fan betroubere mikroservicearsjitektueren. Spring-ûntwikkelders hawwe in protte jierren circuit-breakers brûkt foar fouttolerânsje. . Hystrix is lykwols net in lange tiid bywurke, mar MicroProfile's Fault Tolerance is no aktyf ûntwikkele en hat ferskate jierren produksjegebrûk efter it. Dêrom, om de betrouberens fan tsjinsten yn Quarkus te ferbetterjen, is it oan te rieden om de MicroProfile Fault Tolerance API's te brûken, foarbylden dêrfan wurde brûkt yn Tabel 5. Sjoch foar mear ynformaasje oer dit Quarkus-hantlieding .
tabel 5. Foarbylden fan in gebrûk stipe MicroProfile Fault Tolerance APIs.
MicroProfile Fault Tolerance Features
beskriuwing
foarbylden
@Asynchronous
It útfieren fan logika yn in aparte tried
@Asynchronous
@Retry
public Future<String> getSalutation() {
...
return future;
}
@Boppeslach
Beheine it oantal simultane oanfragen
@Bulkhead(5)
public void fiveConcurrent() {
makeRemoteCall(); //...
}
@Sekering
Slimme ôfhanneling fan mislearring en herstel fan mislearrings
@CircuitBreaker(delay=500 // milliseconds
failureRatio = .75,
requestVolumeThreshold = 20,
successThreshold = 5)
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
makeRemoteCall(); //...
}
@Weromfalle
Oprop alternative logika yn gefal fan mislearring
@Timeout(500) // milliseconds
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
makeRemoteCall(); //...
}
public String fallback() {
return "hello";
}
Opnij besykje op fersyk mislearre
@Retry(maxRetries=3)
public String getSalutation() {
makeRemoteCall(); //...
}
Timeout foar mislearringskontrôle
@Timeout(value = 500 ) // milliseconds
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
makeRemoteCall(); //...
}
Kontrolearje tsjinsten (Service Health)
Kubernetes-platfoarms kontrolearje de sûnens fan konteners mei spesjale tsjinsten. Om it ûnderlizzende platfoarm de tsjinsten te kontrolearjen, brûke Spring-ûntwikkelders typysk in oanpaste HealthIndicator en Spring Boot Actuator. Yn Quarkus kin dit dien wurde mei MicroProfile Health, dy't standert in liveness-kontrôle útfiert, mar kin wurde konfigureare om tagelyk libbenens en reewilligens te kontrolearjen. Foarbylden fan hoe't jo de stipe MicroProfile Health API's brûke kinne wurde jûn yn Tabel 6, en oanfoljende ynformaasje wurdt jûn yn 'e Quarkus-hantlieding .
Tabel 6: Gebrûksfoarbylden fan stipe MicroProfile Health API's.
MicroProfile Health funksjes
beskriuwing
foarbylden
@Liveness
It platfoarm herstart mislearre kontenerisearre applikaasjes
Einpunt:
host: 8080 / sûnens / libje
@Liveness
public class MyHC implements HealthCheck {
public HealthCheckResponse call() {
...
return HealthCheckResponse
.named("myHCProbe")
.status(ready ? true:false)
.withData("mydata", data)
.build();
}
@Reedens
It platfoarm sil gjin ferkear stjoere nei containerisearre applikaasjes as it net klear is
Einpunt:
host: 8080 / sûnens / klear
@Readiness
public class MyHC implements HealthCheck {
public HealthCheckResponse call() {
...
return HealthCheckResponse
.named("myHCProbe")
.status(live ? true:false)
.withData("mydata", data)
.build();
}
Metrics
Applikaasjes leverje metriken foar sawol operasjonele doelen (om prestaasjes SLA's te kontrolearjen) as net-operasjonele doelen (saaklike SLA's). Spring-ûntwikkelders leverje metriken mei Spring Boot Actuator en Micrometer. Op syn beurt brûkt Quarkus MicroProfile Metrics om baseline-metriken (JVM en bestjoeringssysteem), ferkeapermetriken (Quarkus) en applikaasjemetriken te leverjen. MicroProfile Metrics fereasket dat de ymplemintaasje stipet JSON en OpenMetrics (Prometheus) útfierformaten. Foarbylden fan it brûken fan de MicroProfile Metrics API wurde jûn yn Tabel 7.
В MicroProfile Metrics wurde brûkt om tapassingsmetriken te leverjen. Foar mear ynformaasje, sjoch de Quarkus hantlieding .
tabel 7. Foarbylden fan in gebrûk MicroProfile Metrics APIs.
MicroProfile Metrics Features
beskriuwing
foarbylden
@Teld
Jout in teller oan dy't it oantal kearen telt dat in annotearre foarwerp oanroppen is
@Counted(name = "fallbackCounter",
displayName = "Fallback Counter",
description = "Fallback Counter")
public String salutationFallback() {
return fallbackSalutation;
}
@ConcurrentGauge
Jout in meter oan dy't it oantal tagelyk oproppen telt nei in annotearre objekt
@ConcurrentGuage(
name = "fallbackConcurrentGauge",
displayName="Fallback Concurrent",
description="Fallback Concurrent")
public String salutationFallback() {
return fallbackSalutation;
}
@Meitsje
Jout in gauge sensor oan dy't de wearde fan in annotearre objekt mjit
@Metered(name = "FallbackGauge",
displayName="Fallback Gauge",
description="Fallback frequency")
public String salutationFallback() {
return fallbackSalutation;
}
@Meter
Jout in metersensor oan dy't de opropfrekwinsje fan in annotearre objekt kontrolearret
@Metered(name = "MeteredFallback",
displayName="Metered Fallback",
description="Fallback frequency")
public String salutationFallback() {
return fallbackSalutation;
}
In annotaasje mei ynformaasje oer metadata as in fersyk wurdt ûntfongen om in metrik yn te fieren of te produsearjen
@Metric
@Metered(name = "MeteredFallback",
displayName="Metered Fallback",
description="Fallback frequency")
public String salutationFallback() {
return fallbackSalutation;
}
Jout in timer oan dy't de doer fan in annotearre foarwerp folget
@Timed(name = "TimedFallback",
displayName="Timed Fallback",
description="Fallback delay")
public String salutationFallback() {
return fallbackSalutation;
}
Metriken einpunten
Applikaasje metriken :8080/metrics/applikaasje
Basis metriken :8080/metrics/base
Ferkeaper metrics :8080/metrics/leverandor
Alle metriken :8080/metrics
MicroProfile Rest Client
Mikrotsjinsten leverje faak RESTful einpunten dy't korrespondearjende client API's fereaskje om mei te wurkjen. Om RESTful einpunten te brûken, brûke Spring-ûntwikkelders gewoanlik RestTemplate. Quarkus biedt MicroProfile Rest Client API's om dit probleem op te lossen, foarbylden fan gebrûk wurde jûn yn Tabel 8.
В it brûken fan RESTful einpunten wurdt dien mei help fan de MicroProfile Rest Client. Mear ynformaasje en foarbylden oer dit ûnderwerp kinne jo fine yn 'e Quarkus-hantlieding .
tabel 8. Foarbylden fan in gebrûk MicroProfile Rest Client APIs.
MicroProfile Rest Client Features
beskriuwing
foarbylden
@RegisterRestClient
Registrearret in typte Java-ynterface as in REST-kliïnt
@RegisterRestClient
@Path("/")
public interface MyRestClient {
@GET
@Produces(MediaType.TEXT_PLAIN)
public String getSalutation();
}
@RestClient
Markearret de ymplemintaasje fan in eksimplaar fan in typearre REST client ynterface
@Autowired // or @Inject
@RestClient
MyRestClient restClient;
Opnij
Ropt in REST einpunt
System.out.println(
restClient.getSalutation());
mp-rest/url
Spesifisearret it REST-einpunt
application.properties:
org.example.MyRestClient/mp-rest/url=
http://localhost:8081/myendpoint
Resultaten
Yn dit blog, foaral rjochte op Spring-ûntwikkelders, hawwe wy rap sjoen hoe't jo de Spring API's kinne brûke mei de MicroProfile API's yn Quarkus om Java-mikrotsjinsten te ûntwikkeljen en se dan te kompilearjen yn native binêre koade dy't hûnderten megabytes RAM besparret en lanseart yn in kwestje fan millisekonden.
Lykas jo al begrepen hawwe, is mear ynformaasje oer stipe foar de Spring- en MicroProfile API's, lykas ek in protte oare nuttige ynformaasje, te finen yn .
Boarne: www.habr.com