JPrime 2024 erfolgreich abgeschlossen!!

Die Organisatoren von JPrime 2024 haben sich erneut große Mühe gegeben, ein vielfältiges Themenspektrum anzubieten, sodass für jeden etwas dabei ist.

Der heutige Artikel wird jedoch nicht durch einen von Michael Simons‘ Vorträgen zum Thema „Die Entwicklung des Integrationstests in Spring und Quarkus“ ausgelöst, obwohl er sehr aufschlussreich war. Er erforschte Integrationsteststrategien und konzentrierte sich dabei auf das Setup in Spring Boot.

Der Autor betonte deutlich, dass die von ihm hervorgehobenen Probleme in Quarkus durch die Nutzung von Dev Services effektiv angegangen werden (Abbildung 1). Dies unterstreicht einen weiteren Grund, warum ich Spring Boot bei bestimmten Anwendungen mit Skepsis betrachte – seine Komplexität steht im krassen Gegensatz zu den optimierten Lösungen in Quarkus, insbesondere bei der Verwendung von Dev Services.

Abbildung 1 – JPrime 2024

Es war bemerkenswert zu sehen, welches Erstaunen Dev Services unter den neuen Teilnehmern hervorrief. Es ist jedoch wichtig zu beachten, dass Dev Services keine neue Funktion in Quarkus ist; Es ist seit geraumer Zeit ein integraler Bestandteil des Frameworks. Lassen Sie uns tiefer in die Quarkus Dev Services eintauchen und ihre dauerhaften Vorteile erkunden.

Quarkus Dev Services

In Quarkus erleichtern Dev Services die automatische Bereitstellung unkonfigurierter Dienste sowohl im Entwicklungs- als auch im Testmodus. Wenn Sie eine Erweiterung hinzufügen, ohne sie zu konfigurieren, initiiert Quarkus im Wesentlichen automatisch den entsprechenden Dienst – häufig unter Verwendung von Testcontainern im Hintergrund – und konfiguriert Ihre Anwendung so, dass dieser Dienst effizient genutzt wird.

1. Automatische Serviceerkennung und -einführung
   
   Quarkus Dev Services automatisiert die Erkennung und den Start notwendiger Dienste wie Datenbanken, Nachrichtenbroker und anderer Backend-Dienste. Diese Funktion greift auf die in pom.xml oder build.gradle angegebenen Abhängigkeiten der Anwendung zu. Wenn Sie beispielsweise einen Datenbanktreiber hinzufügen, veranlasst Dev Services automatisch, eine entsprechende Containerinstanz dieser Datenbank zu starten, sofern diese noch nicht ausgeführt wird. Bei der hier verwendeten Technologie handelt es sich in erster Linie um Testcontainer, die die Erstellung leichter, wegwerfbarer Instanzen gängiger Datenbanken, Selenium-Webbrowser oder allem anderen ermöglichen, das in einem Docker-Container ausgeführt werden kann.

2. Dynamische Konfigurationsinjektion
   
   Sobald die erforderlichen Dienste instanziiert sind, fügt Quarkus Dev Services die relevanten Dienstverbindungsdetails zur Laufzeit dynamisch in die Konfiguration der Anwendung ein. Dies erfolgt ohne manuellen Eingriff mithilfe einer Funktion namens „Continuous Testing“, die die Standarddatenbank oder andere Dienst-URLs an die automatisch bereitgestellten Testcontainer umleitet. Konfigurationseigenschaften wie URLs, Benutzeranmeldeinformationen und andere Betriebsparameter werden nahtlos festgelegt, sodass die Anwendung mit diesen Diensten interagieren kann, als wären sie manuell konfiguriert.

3. Dienstspezifisches Verhalten
   
   Dev Services ist auf verschiedene Arten von Diensten zugeschnitten:

   • Datenbanken: Stellt automatisch eine laufende Datenbank bereit, die auf die Anforderungen Ihrer Anwendung zugeschnitten ist, unabhängig davon, ob es sich um PostgreSQL, MySQL, MongoDB oder eine andere unterstützte Datenbank handelt. Dev Services sorgt dafür, dass während der Entwicklung ein entsprechender Testcontainer zur Verfügung steht.
   • Messaging-Systeme: Für Anwendungen, die Messaging-Systeme wie Kafka oder AMQP verwenden, startet Quarkus Dev Services die erforderlichen Broker mithilfe von Docker und verbindet sie mit der Anwendung.
   • Benutzerdefinierte Dev Services: Entwickler können die Funktionalität erweitern, indem sie benutzerdefinierte Quarkus-Erweiterungen erstellen, die das Dev Services-Framework nutzen. Dies ermöglicht maßgeschneiderte, projektspezifische Setups und bietet noch mehr Flexibilität und Kontrolle.

4. Netzwerkhandhabung und Dienstisolierung
   
   Jeder von Quarkus Dev Services eingerichtete Dienst läuft in seiner isolierten Umgebung. Dies ist entscheidend, um sicherzustellen, dass es zwischen verschiedenen Entwicklungstests keine Portkonflikte, Datenrückstände oder Sicherheitsprobleme gibt. Trotz dieser Isolation werden Dienste mithilfe von Docker angemessen vernetzt, sodass sie bei Bedarf miteinander kommunizieren können und eine reale Bereitstellungsatmosphäre nachgeahmt wird.

5. Lebenszyklusmanagement
   
   Quarkus verwaltet den gesamten Lebenszyklus dieser dynamisch bereitgestellten Dienste. Wenn Sie Ihre Anwendung im Entwicklungsmodus starten, werden die erforderlichen Dienste automatisch gestartet. Wenn Sie die Quarkus-Anwendung beenden, werden auch diese Dienste beendet. Diese Verwaltung umfasst die Handhabung der Datenpersistenz nach Bedarf, sodass Entwickler ohne Verzögerungen bei der Einrichtung genau dort weitermachen können, wo sie aufgehört haben.

Beispielverwendung

Stellen Sie sich vor, Sie verwenden eine PostgreSQL-Datenbank mit Quarkus. Wenn keine vorhandene PostgreSQL-Konfiguration erkannt wird, startet Quarkus einen PostgreSQL-Docker-Container und verbindet Ihre Anwendung automatisch.

Diese Dienste sind im Entwicklungs- und Testmodus standardmäßig aktiviert, können aber bei Bedarf über die application.properties deaktiviert werden:

quarkus.datasource.devservices.enabled=false

Erläutern wir das Szenario, in dem Quarkus eine PostgreSQL-Datenbank verwendet, und wie die Dev Services dies mit minimalem Aufwand ermöglichen.

Wenn Quarkus erkennt, dass keine PostgreSQL-Konfiguration aktiv ist (nicht ausgeführt oder nicht explizit konfiguriert), startet es automatisch einen PostgreSQL-Container mit Docker. Dies wird hinter den Kulissen durch Dev Services eingerichtet.

Um mit der Datenbank über eine ORM-Ebene zu interagieren, sollten Sie die Verwendung von Quarkus Panache in Betracht ziehen, das die ORM-Vorgänge im Ruhezustand vereinfacht. So richten Sie Ihre Umgebung ein:

1. Abhängigkeiten hinzufügen

   Fügen Sie zunächst die erforderlichen Abhängigkeiten in Ihre pom.xml ein:
   

   io.quarkusquarkus-hibernate-orm-panacheio.quarkusquarkus-jdbc-postgresql

2. Entität definieren

   Als nächstes definieren Sie Ihre Entität, z. B. CityEntity:
   

   @Entity
   @Table(name = "cities")
   public class CityEntity {
   
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long id;
   
   private String name;
   
   @Column(name = "public_id")
   private String publicId;
   
   @OneToOne
   private StateEntity state;
   
   @Column(nullable = false, name = "created_at")
   private Instant createdAt;
   
   @Column(nullable = false, name = "last_modified")
   private Instant lastModified;
   
   @PrePersist
   protected void onCreate() {
    createdAt = Instant.now();
    lastModified = createdAt;
   }
   
   @PreUpdate
   protected void onUpdate() {
    lastModified = Instant.now();
   }
   }
   

3. Erstellen Sie das Repository

   Implementieren Sie das Repository, das direkt mit der Datenbank interagiert:
   

   @ApplicationScoped
   public class CityRepository implements 
   PanacheRepository {
   }
   

4. Serviceschicht

   Definieren Sie die Serviceschicht, die das Repository nutzt:
   

   @ApplicationScoped
   public class CityServiceImpl implements CityService {
   
     @Inject
     CityRepository cityRepository;
   
     @Override
     public long countCities() {
      return cityRepository.count();
     }
   }
   
   public interface CityService {
    long countCities();
   }
   

5. Ressourcenendpunkt
   

   @Path("/cities")
   @Tag(name = "City Resource", description = "City APIs")
   public class CityResource {
   
     @Inject
     CityService cityService;
   
     @GET
     @Path("/count")
     @Operation(summary = "Get the total number of cities", 
      description = "Returns the total count of cities in the 
      system.")
     @APIResponse(responseCode = "200", description = "Successful 
     response", content = @Content(mediaType = "application/json", 
     schema = @Schema(implementation = Long.class)))
     public long count() {
      return cityService.countCities();
     }
    }
   

Beobachten Sie beim Ausführen Ihrer Quarkus-Anwendung (mvn quarkus:dev) den automatischen Start des PostgreSQL-Containers (Abbildung 2). Diese nahtlose Integration verdeutlicht die Leistungsfähigkeit von Quarkus Dev Services und vereinfacht die Entwicklung und das Testen erheblich, indem die Konfiguration und der Verbindungsaufbau zu externen Diensten automatisiert werden, die für Ihre Anwendung erforderlich sind.

Abbildung 2 – Anwendungsprotokolle

Plattform-Entwicklungsdienste

Quarkus Dev Services rationalisieren die Entwicklungs- und Testphasen, indem sie die Konfiguration und Verwaltung verschiedener Dienste übernehmen, sodass sich Entwickler mehr auf die eigentliche Anwendung konzentrieren können. Quarkus unterstützt eine breite Palette von Entwicklungsdiensten, darunter:

• AMQP
• Apicurio-Registrierung
• Datenbanken
• Kafka
• Schlüsselumhang
• Kubernetes
• MongoDB
• RabbitMQ
• Pulsar
• Redis
• Gewölbe
• Infinispan
• Elasticsearch
• Beobachtbarkeit
• Neo4j
• WireMock
• Mikrocks
• Schlüsselumhang
• und viele weitere, die alle darauf ausgelegt sind, Ihre Entwicklungsumgebung nahtlos zu erweitern

Abschluss

Quarkus Dev Services stellt einen Paradigmenwechsel in der Art und Weise dar, wie Entwickler während der Entwicklungs- und Testphase an die Einrichtung und Integration externer Dienste herangehen. Die Automatisierung der Umgebungseinrichtung beschleunigt nicht nur den Entwicklungsprozess, sondern verringert auch das Potenzial für Konfigurationsfehler, sodass sich Teams leichter auf die Erstellung robuster, funktionsreicher Anwendungen konzentrieren können.

Einer der herausragenden Vorteile von Quarkus Dev Services ist die Betonung der Entwicklerproduktivität. Da die manuelle Verwaltung von Dienstabhängigkeiten entfällt, können Entwickler sofort mit der Arbeit an Geschäftslogik und Anwendungsfunktionen beginnen. Dieser optimierte Arbeitsablauf ist besonders vorteilhaft in Microservices-Architekturen, in denen mehrere Services möglicherweise gleichzeitige Entwicklung und Integration erfordern

Zusammenfassend lässt sich sagen, dass die Nutzung von Quarkus Dev Services die Effektivität und Projektergebnisse Ihres Entwicklungsteams erheblich beeinflussen könnte. Die Einfachheit und Kraft von Quarkus regen zum Experimentieren an,
schnellere Iterationen und letztendlich ein schnellerer Entwicklungszyklus. Diese Art von technologischer Hebelwirkung ist es, was moderne Unternehmen brauchen, um im digitalen Zeitalter erfolgreich zu sein.