Wie Quarkus MicroProfile und Spring integriert

Hallo an alle, und mit euch den dritten Beitrag aus der Quarkus-Serie! (Registrieren Sie sich übrigens und besuchen Sie unser Webinar „ Dies ist das native Java-Framework von Quarkus - Kubernetes “, das am 27. Mai stattfinden wird. Wir werden zeigen, wie Sie bei Null anfangen oder vorgefertigte Lösungen übertragen können.)



Bei der Entwicklung von Java-Mikrodiensten wird häufig angenommen, dass Eclipse MicroProfile und Spring Boot sind separate und unabhängige APIs. Standardmäßig verwenden Programmierer normalerweise die APIs, an die sie gewöhnt sind, da das Erlernen neuer Frameworks und Laufzeitkomponenten viel Zeit in Anspruch nimmt. Heute werden wir versuchen, die Entwicklung einiger beliebter MicroProfile-APIs für Spring-Entwickler zu vereinfachen .und zeigen Sie, wie Sie die Spring-API und die neuen nützlichen Funktionen von Quarkus gleichzeitig verwenden .

Wenn etwas detaillierter, werden wir uns zunächst den Umfang und die Details der Unterstützung von Spring-APIs durch Quarkus ansehen, um Spring-Entwicklern zu zeigen, wie sie die MicroProfile-API in ihrer täglichen Arbeit verwenden können. Anschließend werden wir über die MicroProfile-API sprechen, die für Spring-Entwickler beim Erstellen von Microservices hilfreich sein wird.

Warum Quarkus? Erstens handelt es sich um Live-Codierung, dh das automatische Neuladen von Änderungen an der MicroProfile-API, der Spring-API und anderen Java-APIs, das mit nur einem Befehl ausgeführt wird: mvn quarkus: dev. Zweitens in unserem Beispiel betrachtetDer Person-Service (er wird aus den Spring-, MicroProfile- und JPA-APIs unter Verwendung des nativen GraalVM-Images in eine Binärdatei kompiliert) startet in nur 0,055 Sekunden und benötigt am Endpunkt der RESTful-Anwendung etwa 90 MB RAM (RSS). Darüber hinaus wird die Kompilierung selbst mit nur einem Befehl ausgeführt: mvn package -Pnative.

Wir werden nicht auf die Details von MicroProfile eingehen, sondern nur versuchen, Spring-Entwicklern zu helfen, zu verstehen, wie Sie in Quarkus Spring-APIs zusammen mit MicroProfile-APIs verwenden können.

Container und Kubernetes


Um diesen Artikel nicht zu überladen, werden wir uns hier nur mit den allgemeinen Aspekten des Kubernetes- Supports befassen , da dies wichtig ist, um dies zu verstehen. Quarkus ist als Java-Stack für Kubernetes positioniert. Es wurde entwickelt, um den Speicherverbrauch und die Startzeit von Java-Anwendungen und -Diensten zu minimieren und dadurch die Dichte ihrer Platzierung auf dem Host zu erhöhen und die Gesamtkosten zu senken.

Quarkus auch unterstützt Kubernetes auto- Generation von Ressourcen und Angebote Bereitstellung Führer auf Kubernetes und Red Hat Openshift - Plattformen. Darüber hinaus generiert Quarkus automatisch die Dateien Dockerfile.jvm (JVM-Verpackung) und Dockerfile.native (native Binärverpackung), die zum Erstellen von Containern erforderlich sind.

Schließlich konzentriert sich Quarkus auf Kubernetes als Zielbereitstellungsumgebung und verwendet keine Java-Frameworks in Fällen, in denen ähnliche Funktionen auf der Ebene der Kubernetes-Plattform selbst implementiert sind. Tabelle 1 zeigt eine Karte der funktionalen Entsprechung von Kubernetes und der typischen Java-Frameworks, die von Spring-Entwicklern verwendet werden.

Tabelle 1. Funktionale Zuordnungszuordnung für Java-Frameworks und Kubernetes.
FunktionellTraditioneller FrühlingsstiefelKubernetes
ServiceerkennungEurekaDNS
AufbauSpring Cloud KonfigurationConfig Maps / Secrets
LastverteilungMultifunktionsleiste (clientseitig)Service, Replication Controller (Serverseite)

Kompilieren und Ausführen des Codes aus dem Beispiel


In diesem Artikel beziehen wir uns auf ein Beispielprojekt, in dem die Spring- und MicroProfile-APIs und sogar dieselbe Java-Klasse gemeinsam genutzt werden. Der Code aus diesem Beispiel kann kompiliert und über die Befehlszeile ausgeführt werden. Weitere Informationen finden Sie in der Datei README.md.

Spring Framework-APIs


Abhängigkeitsspritze


Quarkus unterstützt eine Vielzahl von CDI- APIs (Contexts and Dependency Injection) und Spring DI-APIs (Spring Dependency Injection). Wenn Sie mit MicroProfile, Java EE und Jakarta EE arbeiten , sind Sie bereits mit CDI vertraut. Auf der anderen Seite können Spring-Entwickler die Quarkus Extension für Spring DI-API verwenden, um die Kompatibilität mit Spring DI sicherzustellen. Beispiele für die Verwendung der unterstützten Spring DI-APIs sind in Tabelle 2 aufgeführt.

Das Projekt aus unserem Beispiel verwendet sowohl CDI- als auch Spring Dependency Injection. Weitere Informationen und Beispiele zu diesem Thema finden Sie im Quarkus-Handbuch, dem so genannten Spring DI-Handbuch .

Tabelle 2. Beispiele für die Verwendung der unterstützten Spring DI-APIs.
Unterstützte Spring DI-Funktionen
Constructor Injection
public PersonSpringController(
   PersonSpringRepository personRepository,  // injected      
   PersonSpringMPService personService) {    // injected
      this.personRepository = personRepository;
      this.personService = personService;
}
Field Injection
Autowired
Value
@Autowired
@RestClient
SalutationRestClient salutationRestClient;

@Value("${fallbackSalutation}")
String fallbackSalutation;
Bean
@Configuration
@Configuration
public class AppConfiguration {
   @Bean(name = "capitalizeFunction")
   public StringFunction capitalizer() {
      return String::toUpperCase;
   }
}
Component
@Component("noopFunction")
public class NoOpSingleStringFunction implements StringFunction {
   @Override
   public String apply(String s) {
      return s;
   }
}
Service
@Service
public class MessageProducer {
   @Value("${greeting.message}")
   String message;

   public String getPrefix() {
      return message;
   }
}

-


Benutzer von MicroProfile werden Quarkus genießen, der JAX-RS, MicroProfile Rest Client, JSON-P und JSON-B als primäres Webprogrammiermodell unterstützt. Spring-Entwickler werden mit der jüngsten Unterstützung der Spring Web API in Quarkus, insbesondere der REST-Schnittstellen, zufrieden sein. Ähnlich wie bei Spring DI besteht das Hauptziel der Unterstützung der Spring Web-API darin, dass Spring-Entwickler die Spring Web-APIs zusammen mit den MicroProfile-APIs verwenden. Beispiele für die Verwendung der unterstützten Spring Web-APIs finden Sie in Tabelle 3. Weitere Informationen und Beispiele zu diesem Thema finden Sie im Quarkus-Handbuch, dem so genannten Spring Web Guide .

Tabelle 3. Beispiele für die Verwendung der unterstützten Spring Web-APIs.
Unterstützte Spring Web-FunktionenBeispiele
@RestController
@RequestMapping
@RestController
@RequestMapping("/person")
public class PersonSpringController {
   ...
   ...
   ...
}
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
@RequestParam
@RequestHeader
@MatrixVariable
@PathVariable
@CookieValue
@RequestBody
@ResponseStatus
@ExceptionHandler
@RestControllerAdvice (partial)
@GetMapping(path = "/greet/{id}",
   produces = "text/plain")
   public String greetPerson(
   @PathVariable(name = "id") long id) {
   ...
   ...
   ...
}

Spring Data JPA


MicroProfile-Benutzer möchten auch, dass Quarkus JPA mit Hibernate ORM unterstützt. Auch für Spring-Entwickler gibt es gute Nachrichten: Quarkus unterstützt die allgemeinen Anmerkungen und Spring Data JPA-Typen. Beispiele für die Verwendung der unterstützten Spring Data JPA-APIs sind in Tabelle 4 aufgeführt.
In dem Projekt aus unserem Beispiel werden die Spring Data JPA-APIs verwendet, und zusätzliche Informationen finden Sie im Quarkus-Handbuch namens Spring Data JPA Guide .

Tabelle 4. Beispiele für die Verwendung der unterstützten Spring Data JPA-APIs.
Unterstützte Spring Data JPA-FunktionenBeispiele
Crudrepository
public interface PersonRepository
         extends JpaRepository,
                 PersonFragment {
   ...
}
Repository
JpaRepository
PagingAndSortingRepository
public class PersonRepository extends 

    Repository {

    Person save(Person entity);

    Optional findById(Person entity);
}
Repository-Fragmente
public interface PersonRepository
         extends JpaRepository,
                 PersonFragment {
   ...
}
Abgeleitete Abfragemethoden
public interface PersonRepository extends CrudRepository {

    List findByName(String name);
    
    Person findByNameBySsn(String ssn);
    
    Optional 
       findByNameBySsnIgnoreCase(String ssn);

    Boolean existsBookByYearOfBirthBetween(
            Integer start, Integer end);
}
Benutzerdefinierte Abfragen
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);
}

API- MicroProfile


(Fault tolerance)


Fehlertoleranzdesigns sind entscheidend, um Kaskadenfehler zu vermeiden und robuste Microservice-Architekturen zu erstellen. Federentwickler verwenden seit Jahren Hystrix -Leistungsschalter zur Fehlertoleranz . Hystrix wurde jedoch schon lange nicht mehr aktualisiert, aber die Fehlertoleranz von MicroProfile entwickelt sich jetzt aktiv und wird bereits seit mehreren Jahren in der Produktion eingesetzt. Um die Zuverlässigkeit der Dienste in Quarkus zu erhöhen, wird daher empfohlen, die MicroProfile-Fehlertoleranz-APIs zu verwenden. Beispiele hierfür finden Sie in Tabelle 5. Weitere Informationen hierzu finden Sie im Quarkus- Fehlertoleranzhandbuch .

Tabelle 5. Beispiele für die Verwendung der unterstützten MicroProfile-Fehlertoleranz-APIs.
Fehlertoleranzmerkmale von MicroProfileBeschreibungBeispiele
@Asynchronous

@Asynchronous
@Retry
public Future<String> getSalutation() {
   ...
   return future;
}
@Bulkhead

@Bulkhead(5)
public void fiveConcurrent() {
   makeRemoteCall(); //...
}
@CircuitBreaker

@CircuitBreaker(delay=500   // milliseconds
   failureRatio = .75,
   requestVolumeThreshold = 20,
   successThreshold = 5)
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
   makeRemoteCall(); //...
}
@Fallback

@Timeout(500) // milliseconds
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
   makeRemoteCall(); //...
}

public String fallback() {
   return "hello";
}
Retry

@Retry(maxRetries=3)
public String getSalutation() {
   makeRemoteCall(); //...
}
Timeout

@Timeout(value = 500 )   // milliseconds
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
   makeRemoteCall(); //...
}

(Service Health)


Kubernetes-Plattformen überwachen den Containerzustand mithilfe spezieller Dienste. Damit die zugrunde liegende Plattform Dienste überwachen kann, verwenden Spring-Entwickler normalerweise den benutzerdefinierten HealthIndicator und Spring Boot Actuator. In Quarkus kann dies mit MicroProfile Health erfolgen, das standardmäßig eine Lebendigkeitsprüfung durchführt, aber so konfiguriert werden kann, dass Lebendigkeit und Bereitschaft gleichzeitig geprüft werden. Beispiele für die Verwendung der unterstützten MicroProfile Health-APIs sind in Tabelle 6 aufgeführt. Weitere Informationen finden Sie im Quarkus Health Guide .

Tabelle 6. Beispiele für die Verwendung der unterstützten MicroProfile Health-APIs.
MicroProfile-GesundheitsfunktionenBeschreibungBeispiele
@Liveness

Endpoint:
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

Endpoint:
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();  
}


Anwendungen bieten Metriken entweder für betriebliche Zwecke (zur Steuerung von SLA-Leistungsindikatoren) oder für nicht betriebliche Zwecke (Geschäfts-SLA-Indikatoren). Spring-Entwickler stellen Metriken mithilfe des Spring Boot Actuator und des Mikrometers bereit. Quarkus verwendet wiederum MicroProfile-Metriken, um grundlegende Metriken (JVM und Betriebssystem), Lieferantenmetriken (Quarkus) und Anwendungsmetriken bereitzustellen. Für MicroProfile Metrics muss die Implementierung die Ausgabeformate JSON und OpenMetrics (Prometheus) unterstützen. Beispiele für die Verwendung der MicroProfile Metrics-API sind in Tabelle 7 aufgeführt.

In dem Projekt aus unserem Beispiel werden MicroProfile Metrics verwendet, um Anwendungsmetriken bereitzustellen. Weitere Informationen finden Sie im Quarkus Metrics Guide .

7. API- MicroProfile Metrics.
MicroProfile Metrics
@Counted
counter-,
@Counted(name = "fallbackCounter", 
  displayName = "Fallback Counter", 
  description = "Fallback Counter")
public String salutationFallback() {
   return fallbackSalutation;
}
@ConcurrentGauge
gauge-,
@ConcurrentGuage(
  name = "fallbackConcurrentGauge", 
  displayName="Fallback Concurrent", 
  description="Fallback Concurrent")
public String salutationFallback() {
   return fallbackSalutation;
}
@Gauge
gauge-,
@Metered(name = "FallbackGauge",
   displayName="Fallback Gauge",
   description="Fallback frequency")
public String salutationFallback() {
   return fallbackSalutation;
}
@Metered
meter-,
@Metered(name = "MeteredFallback",
   displayName="Metered Fallback",
   description="Fallback frequency")
public String salutationFallback() {
   return fallbackSalutation;
}
Metric
, ,
@Metric
@Metered(name = "MeteredFallback",
   displayName="Metered Fallback",
   description="Fallback frequency")
public String salutationFallback() {
   return fallbackSalutation;
}
Timed
,
@Timed(name = "TimedFallback",
   displayName="Timed Fallback",
   description="Fallback delay")
public String salutationFallback() {
   return fallbackSalutation;
}

Metriken Endpunkte

Metriken für Localhost- Anwendungen : 8080 / Metriken / Anwendung
Grundlegende Metriken für Localhost : 8080 / Metriken / Basis
Herstellermetriken für Localhost : 8080 / Metriken / Hersteller
Alle Metriken für Localhost : 8080 / Metriken

MicroProfile Rest Client


Microservices bieten häufig RESTful-Endpunkte, für die geeignete Client-APIs erforderlich sind. Um RESTful-Endpunkte zu verwenden, verwenden Spring-Entwickler normalerweise eine RestTemplate. Quarkus bietet auch MicroProfile Rest Client-APIs zur Lösung dieses Problems an. Beispiele für deren Verwendung sind in Tabelle 8 aufgeführt.

In dem Projekt aus unserem Beispiel wird die Verwendung von RESTful-Endpunkten mithilfe des MicroProfile Rest Client durchgeführt. Weitere Informationen und Beispiele zu diesem Thema finden Sie im Quarkus Rest Client-Handbuch .

Tabelle 8. Beispiele für die Verwendung der MicroProfile Rest Client-APIs.
Funktionen des MicroProfile Rest-ClientsBeschreibungBeispiele
@RegisterRestClient
Registriert eine typisierte Java-Schnittstelle als REST-Client
@RegisterRestClient
@Path("/")
public interface MyRestClient {
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String getSalutation();
}
@ RestClient
Markiert die Implementierung einer Instanz einer typisierten REST-Client-Schnittstelle
@Autowired // or @Inject
@RestClient
MyRestClient restClient;
Aufruf
Ruft einen REST-Endpunkt auf
System.out.println(
   restClient.getSalutation());
mp-rest / url
Gibt einen REST-Endpunkt an
application.properties:
org.example.MyRestClient/mp-rest/url=
   http://localhost:8081/myendpoint

Zusammenfassung


In diesem Blog, der in erster Linie für Spring-Entwickler nützlich ist, haben wir uns kurz mit der Verwendung von Spring-APIs in Quarkus zusammen mit MicroProfile-APIs befasst, um Java-Microservices zu entwickeln und sie dann in nativen Binärcode zu kompilieren, wodurch Hunderte von Megabyte RAM eingespart werden und beginnt in wenigen Millisekunden.

Wie Sie bereits verstanden haben, finden Sie zusätzliche Informationen zur Unterstützung der Spring- und MicroProfile-APIs sowie eine Reihe weiterer nützlicher Informationen in den Quarkus-Handbüchern .

All Articles