🥇Quarkus: modernisering av applikationer med exemplet helloworld från JBoss EAP Quickstart

Hej alla i den här bloggen, och här är det fjärde inlägget i serien om Quarkus!

Det föregående inlägget handlade om hur Quarkus förenar MicroProfile och Spring. Låt oss påminna om att Quarkus det positioneras som "super snabb subatomär Java", även kallad "Kubernetes-orienterad Java-stack, optimerad för GraalVM och OpenJDK HotSpot och byggd med de bästa biblioteken och standarderna". Idag ska vi visa hur man moderniserar befintliga Java-applikationer med Quarkus möjligheter, genom exemplet helloworld-applikationen från Red Hat JBoss Enterprise Application Platform (JBoss EAP) Quickstart-repositoriet, där vi använder teknologier i Quarkus som CDI och Servlet 3.

Det är viktigt att notera att både Quarkus och JBoss EAP fokuserar på att använda verktyg som i största möjliga mån är byggda på standarder. Har du ingen applikation som kör på JBoss EAP? Inga problem, den kan enkelt flyttas från din nuvarande applikationsserver till JBoss EAP med hjälp av Red Hat Application Migration Toolkit. Den slutliga och fungerande versionen av den moderniserade koden kommer att finnas tillgänglig i repositoriet github.com/mrizzi/jboss-eap-quickstarts/tree/quarkus, i modulen helloworld.

Vid skrivandet av det här inlägget användes guider för Quarkus, mestadels Creating Your First Application och Building a Native Executable.

Hämta koden

Först skapar vi en lokal klon av repositoriet JBoss EAP quickstarts:

$ git clone https://github.com/jboss-developer/jboss-eap-quickstarts.git
Klonar in i 'jboss-eap-quickstarts'...
remote: Enumrerar objekt: 148133, klart.
remote: Totalt 148133 (delta 0), återanvänds 0 (delta 0), pack återanvänds 148133
Mottar objekt: 100% (148133/148133), 59.90 MiB | 7.62 MiB/s, klart.
Löser deltar: 100% (66476/66476), klart.
$ cd jboss-eap-quickstarts/helloworld/

Tittar på hur den ursprungliga helloworld fungerar

I grunden är syftet med denna applikation tydligt utifrån namnet, men vi kommer att modernisera dess kod strikt vetenskapligt. Så låt oss först titta på denna applikation i sin ursprungliga form.

Starta helloworld

1. Öppna terminalen och gå till roten av JBoss EAP-mappen (du kan ladda ner den här), det vill säga i mappen EAP_HOME.

2. Starta JBoss EAP-servern med standardprofilen:

$ EAP_HOME/bin/standalone.sh

Anmärkning: för Windows används skriptet EAP_HOMEbinstandalone.bat för att starta.

Efter några sekunder bör loggen visa ungefär följande:

[org.jboss.as] (Controller Boot Thread) WFLYSRV0025: JBoss EAP 7.2.0.GA (WildFly Core 6.0.11.Final-redhat-00001) startad på 3315 ms - Startade 306 av 527 tjänster (321 tjänster är lata, passiva eller på begäran)

3. Öppna i webbläsaren 127.0.0.1:8080 och vi ser detta:

Fig. 1. Startsidan för JBoss EAP.

4. Följ instruktionerna i guiden Build and Deploy the Quickstart: vi kör igång helloworld och kör följande kommando (från projektets rotmapp):

$ mvn clean install wildfly:deploy

Efter att kommandot har körts framgångsrikt ser vi ungefär följande i loggen:

[INFO] ------------------------------------------------------------------------ 
[INFO] BYGG SUCCÉ 
[INFO] ------------------------------------------------------------------------ 
[INFO] Total tid: 8.224 s

Så första distributionen av helloworld-applikationen på JBoss EAP tog lite mer än 8 sekunder.

Testar helloworld

Följ noggrant guiden Access the Application, öppnar i webbläsaren 127.0.0.1:8080/helloworld och ser detta:

Fig. 2. Ursprungligt Hello World från JBoss EAP.

Gör ändringar

Ändrar inparametern createHelloMessage(String name) från World till Marco:

writer.println("<h1>" + helloService.createHelloMessage("Marco") + "</h1>");

Kör återigen följande kommando:

$ mvn clean install wildfly:deploy

Uppdaterar sedan sidan i webbläsaren och ser att texten har ändrats:

Fig. 3. Hello Marco i JBoss EAP.

Återställer distributionen av helloworld och avslutar JBoss EAP

Detta är valfritt, men om du vill återställa distributionen kan du göra det med följande kommando:

$ mvn clean install wildfly:undeploy

För att avsluta JBoss EAP-instansen, tryck bara Ctrl+C i terminalfönstret.

Uppgraderar helloworld

Nu ska vi modernisera den ursprungliga helloworld-applikationen.

Skapar en ny gren

Skapar en ny arbetsgren efter att projektet quickstart har slutförts:

$ git checkout -b quarkus 7.2.0.GA

Ändrar filen pom.xml

Vi börjar ändra applikationen med filen pom.xml. För att Quarkus ska kunna infoga XML-block i den, kör vi följande kommando i helloworld-mappen:

$ mvn io.quarkus:quarkus-maven-plugin:0.23.2:create

Vid tiden för att skriva denna artikel användes version 0.23.2. Quarkus uppdateras ofta med nya versioner, för att se vilken version som är den senaste kan du besöka github.com/quarkusio/quarkus/releases/latest.

Ovanstående kommando kommer att infoga följande element i pom.xml:

Egenskapen , som anger den version av Quarkus som används.
Blocket för att importera Quarkus BOM (bill of materials), så att du inte behöver lägga till versionen för varje Quarkus-beroende.
Plugin quarkus-maven-plugin, som ansvarar för att paketera applikationen och erbjuder utvecklingsläge.
Profilen native för att skapa körbara filer av applikationen.

Dessutom gör vi manuellt följande ändringar i pom.xml:

Flyttar taggen från blocket och placerar den över taggen . Eftersom vi i nästa steg kommer att ta bort blocket , måste vi spara .
Tar bort blocket , eftersom den här applikationen inte längre behöver en föräldra-pom från JBoss när man arbetar med Quarkus.
Lägg till taggen och placera den under taggen . Versionsnumret kan anges som du vill.
Ta bort taggen , eftersom denna applikation inte längre är en WAR, utan en vanlig JAR.
Modifiera följande beroenden:
1. Byt ut beroendet javax.enterprise:cdi-api mot io.quarkus:quarkus-arc, ta bort provided, eftersom (enligt dokumentationen) detta Quarkus-tillägg tillhandahåller CDI-beroendeinjektion.
2. Byt ut beroendet org.jboss.spec.javax.servlet:jboss-servlet-api_4.0_spec mot io.quarkus:quarkus-undertow, ta bort provided, eftersom (enligt dokumentationen) detta Quarkus-tillägg ger stöd för servlets.
3. Ta bort beroendet org.jboss.spec.javax.annotation:jboss-annotations-api_1.3_spec, eftersom det ingår i de beroenden vi just har ändrat.

Versionen av filen pom.xml med alla förändringar finns på adressen github.com/mrizzi/jboss-eap-quickstarts/blob/quarkus/helloworld/pom.xml.

Observera att det ovanstående kommandot mvn io.quarkus:quarkus-maven-plugin:0.23.2:create inte bara ändrar filen pom.xml, utan även lägger till en rad komponenter i projektet, nämligen följande filer och mappar:

Filen mvnw och mvnw.cmd samt mappen .mvn: Maven Wrapper gör det möjligt att köra Maven-projekt i en viss version av Maven utan att installera den versionen.
Mappen docker (i katalogen src/main/): här finns exempel på Dockerfile-filer för lägena native och jvm (tillsammans med filen .dockerignore).
Mappen resources (i katalogen src/main/): här finns en tom fil application.properties och ett exempel på startsidan Quarkus index.html (se mer i avsnittet Kör den moderniserade helloworld).

Kör helloworld
För att testa applikationen använder vi quarkus:dev, som startar Quarkus i utvecklingsläge (se mer i detta avsnitt i handboken för Utvecklingsläge).

Anmärkning: detta steg kommer förväntat att leda till ett fel, eftersom vi inte har gjort alla nödvändiga ändringar än.

Nu kör vi kommandot för att se hur det fungerar:

$ .\/mvnw compile quarkus:dev
[INFO] Skanning av projekt...
[INFO]
[INFO] ----------------< org.jboss.eap.quickstarts:helloworld >----------------
[INFO] Bygger Quickstart: helloworld quarkus
[INFO] --------------------------------[ war ]---------------------------------
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (standard-resurser) @ helloworld ---
[INFO] Använder 'UTF-8' kodning för att kopiera filtrerade resurser.
[INFO] Kopierar 2 resurser
[INFO]
[INFO] --- maven-compiler-plugin:3.1:compile (standard-kompilering) @ helloworld ---
[INFO] Ingenting att kompilera - alla klasser är uppdaterade
[INFO]
[INFO] --- quarkus-maven-plugin:0.23.2:dev (standard-cli) @ helloworld ---
Lyssnar för transport dt_socket på adress: 5005
INFO  [io.qua.dep.QuarkusAugmentor] Börjar quarkus-augmentering
INFO  [org.jbo.threads] JBoss Threads version 3.0.0.Final
ERROR [io.qua.dev.DevModeMain] Kunde inte starta quarkus: java.lang.RuntimeException: io.quarkus.builder.BuildException: Byggfel: Byggningen misslyckades på grund av fel
	[error]: Byggsteget io.quarkus.arc.deployment.ArcProcessor#validate kastade ett undantag: javax.enterprise.inject.spi.DeploymentException: javax.enterprise.inject.UnsatisfiedResolutionException: Otillfredsställd beroende för typ org.jboss.as.quickstarts.helloworld.HelloService och kvalificerare [@Default]
	- java-medlem: org.jboss.as.quickstarts.helloworld.HelloWorldServlet#helloService
	- deklarerat på CLASS-bean [typer=[javax.servlet.ServletConfig, java.io.Serializable, org.jboss.as.quickstarts.helloworld.HelloWorldServlet, javax.servlet.GenericServlet, javax.servlet.Servlet, java.lang.Object, javax.servlet.http.HttpServlet], kvalificerare=[@Default, @Any], mål=org.jboss.as.quickstarts.helloworld.HelloWorldServlet]
	at io.quarkus.arc.processor.BeanDeployment.processErrors(BeanDeployment.java:841)
	at io.quarkus.arc.processor.BeanDeployment.init(BeanDeployment.java:214)
	at io.quarkus.arc.processor.BeanProcessor.initialize(BeanProcessor.java:106)
	at io.quarkus.arc.deployment.ArcProcessor.validate(ArcProcessor.java:249)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at io.quarkus.deployment.ExtensionLoader$1.execute(ExtensionLoader.java:780)
	at io.quarkus.builder.BuildContext.run(BuildContext.java:415)
	at org.jboss.threads.ContextClassLoaderSavingRunnable.run(ContextClassLoaderSavingRunnable.java:35)
	at org.jboss.threads.EnhancedQueueExecutor.safeRun(EnhancedQueueExecutor.java:2011)
	at org.jboss.threads.EnhancedQueueExecutor$ThreadBody.doRunTask(EnhancedQueueExecutor.java:1535)
	at org.jboss.threads.EnhancedQueueExecutor$ThreadBody.run(EnhancedQueueExecutor.java:1426)
	at java.lang.Thread.run(Thread.java:748)
	at org.jboss.threads.JBossThread.run(JBossThread.java:479)
Orsakat av: javax.enterprise.inject.UnsatisfiedResolutionException: Otillfredsställd beroende för typ org.jboss.as.quickstarts.helloworld.HelloService och kvalificerare [@Default]
	- java-medlem: org.jboss.as.quickstarts.helloworld.HelloWorldServlet#helloService
	- deklarerat på CLASS-bean [typer=[javax.servlet.ServletConfig, java.io.Serializable, org.jboss.as.quickstarts.helloworld.HelloWorldServlet, javax.servlet.GenericServlet, javax.servlet.Servlet, java.lang.Object, javax.servlet.http.HttpServlet], kvalificerare=[@Default, @Any], mål=org.jboss.as.quickstarts.helloworld.HelloWorldServlet]
	at io.quarkus.arc.processor.Beans.resolveInjectionPoint(Beans.java:428)
	at io.quarkus.arc.processor.BeanInfo.init(BeanInfo.java:371)
	at io.quarkus.arc.processor.BeanDeployment.init(BeanDeployment.java:206)
	... 14 mer

Så, det fungerar inte… Varför?

Undantaget UnsatisfiedResolutionException pekar på klassen HelloService, som är en medlem av klassen HelloWorldServlet (java medlem: org.jboss.as.quickstarts.helloworld.HelloWorldServlet#helloService). Problemet är att HelloWorldServlet behöver en injicerad instans av HelloService, men den går inte att hitta (även om båda dessa klasser finns i samma paket).

Det är dags att återvända till dokumentationen och läsa om hur Inject, och därmed Contexts and Dependency Injection (CDI). Så vi öppnar manualen för Contexts and Dependency Injection och läser i avsnittet Bean Discovery att: "En bean-klass som inte har någon definierande bean-annotering söks inte."

Tittar på klassen HelloService – den har faktiskt ingen sådan annotering. Därför måste vi lägga till den så att Quarkus kan söka och hitta bean. Eftersom detta är ett stateless-objekt kan vi helt enkelt lägga till annoteringen @ApplicationScoped på följande sätt:

@ApplicationScoped
public class HelloService {

Anmärkning: här kan utvecklingsmiljön be om att du lägger till den erforderliga paketet (se raden nedan), och detta måste göras manuellt, så här:

import javax.enterprise.context.ApplicationScoped;

Om du är osäker på vilken scope du ska använda när den ursprungliga bean'en inte alls har definierats, studera dokumentationen JSR 365: Contexts and Dependency Injection for Java 2.0—Standard scope.

Nu försöker vi igen att köra applikationen med kommandot .\/mvnw compile quarkus:dev:

$ .\/mvnw compile quarkus:dev
[INFO] Scanning for projects...
[INFO]
[INFO] ----------------< org.jboss.eap.quickstarts:helloworld >----------------
[INFO] Building Quickstart: helloworld quarkus
[INFO] --------------------------------[ war ]---------------------------------
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ helloworld ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] Copying 2 resources
[INFO]
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ helloworld ---
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 2 source files to \/home\/mrizzi\/git\/forked\/jboss-eap-quickstarts\/helloworld\/target\/classes
[INFO]
[INFO] --- quarkus-maven-plugin:0.23.2:dev (default-cli) @ helloworld ---
Listening for transport dt_socket at address: 5005
INFO  [io.qua.dep.QuarkusAugmentor] (main) Beginning quarkus augmentation
INFO  [io.qua.dep.QuarkusAugmentor] (main) Quarkus augmentation completed in 576ms
INFO  [io.quarkus] (main) Quarkus 0.23.2 started in 1.083s. Listening on: http:\/\/0.0.0.0:8080
INFO  [io.quarkus] (main) Profile dev activated. Live Coding activated.
INFO  [io.quarkus] (main) Installed features: [cdi]

Nu går allt utan fel.

Vi kör den uppgraderade helloworld
Som angivet i loggen, öppnar vi i webbläsaren 0.0.0.0:8080 (standard Quarkus start sida) och ser detta:

Fig. 4. Quarkus dev start sida.

I annoteringen WebServlet för denna applikation finns följande kontextdefinition:

@WebServlet("\/HelloWorld")
public class HelloWorldServlet extends HttpServlet {

Därför går vi i webbläsaren till 0.0.0.0:8080/HelloWorld och ser följande:

Fig. 5: The Quarkus dev-sidan för Hello World-applikationen.

Och så här, allt fungerar.

Nu gör vi ändringar i koden. Observera att kommandot ./mvnw compile quarkus:dev fortfarande fungerar, och vi tänker inte stoppa det. Nu ska vi försöka tillämpa samma – mycket triviala – ändringar på själva koden och se hur Quarkus underlättar livet för utvecklaren:

writer.println("<h1>" + helloService.createHelloMessage("Marco") + "</h1>");

Vi sparar filen och uppdaterar sedan webbsidan för att se meddelandet Hello Marco, som visas på skärmdumpen nedan:

Fig. 6. Sidan Hello Marco i Quarkus dev.

Nu kontrollerar vi utskriften i terminalen:

INFO  [io.qua.dev] (vert.x-worker-thread-3) Ändrade källfiler upptäckta, kompilera om [/home/mrizzi/git/forked/jboss-eap-quickstarts/helloworld/src/main/java/org/jboss/as/quickstarts/helloworld/HelloWorldServlet.java]
INFO  [io.quarkus] (vert.x-worker-thread-3) Quarkus stoppades på 0.003s
INFO  [io.qua.dep.QuarkusAugmentor] (vert.x-worker-thread-3) Påbörjar quarkus-augmentation
INFO  [io.qua.dep.QuarkusAugmentor] (vert.x-worker-thread-3) Quarkus-augmentation slutförd på 232ms
INFO  [io.quarkus] (vert.x-worker-thread-3) Quarkus 0.23.2 startade på 0.257s. Lyssnar på: http://0.0.0.0:8080
INFO  [io.quarkus] (vert.x-worker-thread-3) Profil dev aktiverad. Live Coding aktiverad.
INFO  [io.quarkus] (vert.x-worker-thread-3) Installerade funktioner: [cdi]
INFO  [io.qua.dev] (vert.x-worker-thread-3) Total tid för varm ersättning: 0.371s

Uppdateringen av sidan utlöste upptäckten av ändringar i källkoden, och Quarkus utförde automatiskt proceduren "stop-start". Och allt det här utfördes på endast 0.371 sekunder (där har ni, den "super-snabba subatomära Java").

Bygger helloworld till JAR-paket
Nu när koden fungerar som den ska, paketerar vi den med följande kommando:

$ ./mvnw clean package

Detta kommando skapar två JAR-filer i mappen /target: filen helloworld-.jar, som är den standard artefakten som skapats av Maven-kommandot tillsammans med klasser och resurser från projektet. Och filen helloworld—runner.jar, som är en körbar JAR.

Observera att detta inte är en uber-jar, eftersom alla beroenden bara kopieras till mappen /target/lib (och inte packas in i JAR-filen). Därför, för att köra denna JAR från en annan mapp eller på en annan värd, måste både JAR-filen och mappen /lib kopieras dit, med tanke på att Class-Path-elementet i filen MANIFEST.MF i JAR-paketet innehåller en explicit lista över JAR-filerna från lib-mappen.
För att lära dig hur man skapar uber-jars, se guiden Uber-Jar Creation.

Kör helloworld paketerat i JAR

Nu kan vi köra vår JAR med det standardkommandot java:

$ java -jar ./target/helloworld--runner.jar
INFO  [io.quarkus] (main) Quarkus 0.23.2 startade på 0.673s. Lyssnar på: http://0.0.0.0:8080
INFO  [io.quarkus] (main) Profil prod aktiverad.
INFO  [io.quarkus] (main) Installerade funktioner: [cdi]

När allt detta har slutförts, gå in i din webbläsare på 0.0.0.0:8080 och kolla att allt fungerar som det ska.

Vi bygger helloworld till en inbyggd körbar fil

Så, vår helloworld fungerar som en fristående Java-applikation, med Quarkus beroenden. Men vi kan gå längre och omvandla den till en inbyggd körbar fil.

Vi installerar GraalVM
Först måste vi installera de nödvändiga verktygen:

1. Ladda ner GraalVM 19.2.0.1 från github.com/oracle/graal/releases/tag/vm-19.2.0.1.

2. Packa upp den nedladdade arkivet:

$ tar xvzf graalvm-ce-linux-amd64-19.2.0.1.tar.gz

3. Gå till untar-mappen.

4. Kör kommandot nedan för att ladda ner och lägga till den inbyggda bilden:

$ ./bin/gu install native-image

5. Skriv mappen som skapades i steg 2 i miljövariabeln GRAALVM_HOME:

$ export GRAALVM_HOME={untar-folder}/graalvm-ce-19.2.0.1)

Ytterligare information och installationsinstruktioner för andra OS kan hittas i guiden Bygga en inbyggd körbar fil - Förutsättningar.

Vi bygger helloworld till en inbyggd körbar fil
Läs guiden Bygga en inbyggd körbar fil - Producera en inbyggd körbar fil: "Och nu ska vi skapa en inbyggd körbar fil för vår applikation, för att minska uppstartstiden och storleken på disken. Den körbara filen kommer att ha allt som behövs för att köra applikationen, inklusive JVM-maskinen (snarare dess nedskurna version som endast innehåller det som krävs för att köra applikationen) och själva vår applikation."

För att skapa en inbyggd körbar fil måste vi aktivera native-profilen i Maven:

$ ./mvnw package -Pnative

Vår byggning tog en minut och 10 sekunder, och den slutgiltiga filen helloworld-runner skapades i mappen /target.

Vi kör den inbyggda körbara filen helloworld

I det föregående steget fick vi den körbara filen /target/helloworld-runner. Nu kör vi den:

$ ./target/helloworld--runner
INFO  [io.quarkus] (main) Quarkus 0.23.2 startade på 0.006s. Lyssnar på: http://0.0.0.0:8080
INFO  [io.quarkus] (main) Profil prod aktiverad.
INFO  [io.quarkus] (main) Installerade funktioner: [cdi]

Öppna igen i webbläsaren 0.0.0.0:8080 och kontrollera att allt fungerar som det ska.

Fortsättning följer!

Vi anser att metoden för att modernisera Java-applikationer med hjälp av Quarkus, som diskuterats i detta inlägg (även om den är baserad på ett enkelt exempel), bör tillämpas aktivt i verkliga livet. Du kommer troligtvis att stöta på en rad problem, vars lösningar vi delvis kommer att ta upp i nästa inlägg, där vi kommer att diskutera hur man mäter minnesanvändningen för att utvärdera prestandaförbättringar, en viktig del av hela moderniseringsprocessen för applikationer.

Källa: habr.com

Quarkus: modernisering av applikationer med exempel på helloworld från JBoss EAP Quickstart

Hämta koden

Tittar på hur den ursprungliga helloworld fungerar

Uppgraderar helloworld