🥇ಕ್ವಾರ್ಕಸ್: JBoss EAP ಕ್ವಿಕ್‌ಸ್ಟಾರ್ಟ್‌ನಿಂದ ಹೆಲೋವರ್ಲ್ಡ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಅಪ್ಲಿಕೇಶನ್ ಆಧುನೀಕರಣವನ್ನು ಉದಾಹರಣೆಯಾಗಿ

ಈ ಬ್ಲಾಗ್‌ನಲ್ಲಿರುವ ಎಲ್ಲರಿಗೂ ನಮಸ್ಕಾರ, ಕ್ವಾರ್ಕಸ್ ಸರಣಿಯ ನಾಲ್ಕನೇ ಪೋಸ್ಟ್ ಇಲ್ಲಿದೆ!

ಹಿಂದಿನ ಪೋಸ್ಟ್ ಕ್ವಾರ್ಕಸ್ ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ ಮತ್ತು ಸ್ಪ್ರಿಂಗ್ ಅನ್ನು ಹೇಗೆ ಸಂಯೋಜಿಸುತ್ತದೆ ಎಂಬುದರ ಕುರಿತು. ಅದನ್ನು ನಿಮಗೆ ನೆನಪಿಸೋಣ ಕ್ವಾರ್ಕಸ್ "ಅಲ್ಟ್ರಾ-ಫಾಸ್ಟ್ ಸಬ್‌ಟಾಮಿಕ್ ಜಾವಾ", ಅಕಾ "ಕುಬರ್ನೆಟ್ಸ್-ಆಧಾರಿತ ಜಾವಾ ಸ್ಟಾಕ್, GraalVM ಮತ್ತು OpenJDK ಹಾಟ್‌ಸ್ಪಾಟ್‌ಗೆ ಅನುಗುಣವಾಗಿ ಮತ್ತು ಅತ್ಯುತ್ತಮ ಲೈಬ್ರರಿಗಳು ಮತ್ತು ಮಾನದಂಡಗಳಿಂದ ಜೋಡಿಸಲಾಗಿದೆ." ಉದಾಹರಣೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಕ್ವಾರ್ಕಸ್‌ನ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಜಾವಾ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಹೇಗೆ ಆಧುನೀಕರಿಸುವುದು ಎಂದು ಇಂದು ನಾವು ತೋರಿಸುತ್ತೇವೆ Red Hat JBoss ಎಂಟರ್‌ಪ್ರೈಸ್ ಅಪ್ಲಿಕೇಶನ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ (JBoss EAP) ಕ್ವಿಕ್‌ಸ್ಟಾರ್ಟ್ ರೆಪೊಸಿಟರಿಯಿಂದ helloworld ಅಪ್ಲಿಕೇಶನ್‌ಗಳು, ಇದು CDI ಮತ್ತು ಸರ್ವ್ಲೆಟ್ 3 ತಂತ್ರಜ್ಞಾನಗಳನ್ನು ಕ್ವಾರ್ಕಸ್ ಬೆಂಬಲಿಸುತ್ತದೆ.

ಕ್ವಾರ್ಕಸ್ ಮತ್ತು JBoss EAP ಎರಡೂ ಸಾಧ್ಯವಾದಷ್ಟು ಗುಣಮಟ್ಟದ-ಆಧಾರಿತ ಸಾಧನಗಳನ್ನು ಬಳಸುವುದನ್ನು ಒತ್ತಿಹೇಳುತ್ತವೆ ಎಂಬುದನ್ನು ಇಲ್ಲಿ ಗಮನಿಸುವುದು ಮುಖ್ಯವಾಗಿದೆ. JBoss EAP ನಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್ ಚಾಲನೆಯಲ್ಲಿಲ್ಲವೇ? ಪರವಾಗಿಲ್ಲ, ಇದನ್ನು ನಿಮ್ಮ ಪ್ರಸ್ತುತ ಅಪ್ಲಿಕೇಶನ್ ಸರ್ವರ್‌ನಿಂದ JBoss EAP ಗೆ ಸುಲಭವಾಗಿ ಸ್ಥಳಾಂತರಿಸಬಹುದು Red Hat ಅಪ್ಲಿಕೇಶನ್ ಮೈಗ್ರೇಶನ್ ಟೂಲ್ಕಿಟ್. ಅದರ ನಂತರ ಆಧುನೀಕರಿಸಿದ ಕೋಡ್‌ನ ಅಂತಿಮ ಮತ್ತು ಕೆಲಸದ ಆವೃತ್ತಿಯು ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಲಭ್ಯವಿರುತ್ತದೆ github.com/mrizzi/jboss-eap-quickstarts/tree/quarkus, ಮಾಡ್ಯೂಲ್ನಲ್ಲಿ ಹೆಲೋವರ್ಲ್ಡ್.

ಈ ಪೋಸ್ಟ್ ಅನ್ನು ಬರೆಯುವಾಗ ನಾವು ಬಳಸಿದ್ದೇವೆ ಕ್ವಾರ್ಕಸ್ ಕೈಪಿಡಿಗಳು, ಹೆಚ್ಚಾಗಿ ನಿಮ್ಮ ಮೊದಲ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರಚಿಸಲಾಗುತ್ತಿದೆ ಮತ್ತು ಕಟ್ಟಡ ಎ ಸ್ಥಳೀಯ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ.

ಕೋಡ್ ಪಡೆಯೋಣ

ಮೊದಲನೆಯದಾಗಿ, ರೆಪೊಸಿಟರಿಯ ಸ್ಥಳೀಯ ಕ್ಲೋನ್ ಅನ್ನು ರಚಿಸೋಣ JBoss EAP ಕ್ವಿಕ್‌ಸ್ಟಾರ್ಟ್ಸ್:

$ git clone https://github.com/jboss-developer/jboss-eap-quickstarts.git
Cloning into 'jboss-eap-quickstarts'...
remote: Enumerating objects: 148133, done.
remote: Total 148133 (delta 0), reused 0 (delta 0), pack-reused 148133
Receiving objects: 100% (148133/148133), 59.90 MiB | 7.62 MiB/s, done.
Resolving deltas: 100% (66476/66476), done.
$ cd jboss-eap-quickstarts/helloworld/

ಮೂಲ ಹೆಲೋವರ್ಲ್ಡ್ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೋಡೋಣ

ವಾಸ್ತವವಾಗಿ, ಈ ಅಪ್ಲಿಕೇಶನ್‌ನ ಸಾರವು ಹೆಸರಿನಿಂದ ಸ್ಪಷ್ಟವಾಗಿದೆ, ಆದರೆ ನಾವು ಅದರ ಕೋಡ್ ಅನ್ನು ಕಟ್ಟುನಿಟ್ಟಾಗಿ ವೈಜ್ಞಾನಿಕವಾಗಿ ಆಧುನೀಕರಿಸುತ್ತೇವೆ. ಆದ್ದರಿಂದ, ಮೊದಲು, ಈ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಅದರ ಮೂಲ ರೂಪದಲ್ಲಿ ನೋಡೋಣ.

ಹೆಲೋವರ್ಲ್ಡ್ ಅನ್ನು ನಿಯೋಜಿಸಲಾಗುತ್ತಿದೆ

1. ಟರ್ಮಿನಲ್ ತೆರೆಯಿರಿ ಮತ್ತು JBoss EAP ಫೋಲ್ಡರ್‌ನ ಮೂಲಕ್ಕೆ ಹೋಗಿ (ನೀವು ಅದನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಬಹುದು ಇಲ್ಲಿ), ಅಂದರೆ, EAP_HOME ಫೋಲ್ಡರ್‌ಗೆ.

2. ಡೀಫಾಲ್ಟ್ ಪ್ರೊಫೈಲ್‌ನೊಂದಿಗೆ JBoss EAP ಸರ್ವರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ:

$ EAP_HOME/bin/standalone.sh

ಗಮನಿಸಿ: ವಿಂಡೋಸ್‌ನಲ್ಲಿ, ಅದನ್ನು ಪ್ರಾರಂಭಿಸಲು EAP_HOMEbinstandalone.bat ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ಒಂದೆರಡು ಸೆಕೆಂಡುಗಳ ನಂತರ, ಲಾಗ್‌ನಲ್ಲಿ ಈ ರೀತಿಯ ಏನಾದರೂ ಗೋಚರಿಸಬೇಕು:

[org.jboss.as] (Controller Boot Thread) WFLYSRV0025: JBoss EAP 7.2.0.GA (WildFly Core 6.0.11.Final-redhat-00001) started in 3315ms - Started 306 of 527 services (321 services are lazy, passive or on-demand)

3. ಬ್ರೌಸರ್‌ನಲ್ಲಿ ತೆರೆಯಿರಿ 127.0.0.1:8080 ಮತ್ತು ನಾವು ಇದನ್ನು ನೋಡುತ್ತೇವೆ:

ಅಕ್ಕಿ. 1. JBoss EAP ಮುಖಪುಟ.

4. ಕೈಪಿಡಿಯಲ್ಲಿನ ಸೂಚನೆಗಳನ್ನು ಅನುಸರಿಸಿ ಕ್ವಿಕ್‌ಸ್ಟಾರ್ಟ್ ಅನ್ನು ನಿರ್ಮಿಸಿ ಮತ್ತು ನಿಯೋಜಿಸಿ: ಹೆಲೋವರ್ಲ್ಡ್ ಅನ್ನು ವಿಸ್ತರಿಸಿ ಮತ್ತು (ಪ್ರಾಜೆಕ್ಟ್ ರೂಟ್ ಫೋಲ್ಡರ್‌ನಿಂದ) ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿ:

$ mvn clean install wildfly:deploy

ಈ ಆಜ್ಞೆಯನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಿದ ನಂತರ, ನಾವು ಲಾಗ್‌ನಲ್ಲಿ ಈ ಕೆಳಗಿನವುಗಳನ್ನು ನೋಡುತ್ತೇವೆ:

[INFO] ------------------------------------------------------------------------ 
[INFO] BUILD SUCCESS 
[INFO] ------------------------------------------------------------------------ 
[INFO] Total time: 8.224 s

ಆದ್ದರಿಂದ, JBoss EAP ನಲ್ಲಿ ಹೆಲೋವರ್ಲ್ಡ್ ಅಪ್ಲಿಕೇಶನ್‌ನ ಮೊದಲ ನಿಯೋಜನೆಯು ಕೇವಲ 8 ಸೆಕೆಂಡುಗಳನ್ನು ತೆಗೆದುಕೊಂಡಿತು.

ಹೆಲೋವರ್ಲ್ಡ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲಾಗುತ್ತಿದೆ

ಸೂಚನೆಗಳ ಪ್ರಕಾರ ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ರವೇಶಿಸಿ, ಬ್ರೌಸರ್‌ನಲ್ಲಿ ತೆರೆಯಿರಿ 127.0.0.1:8080/helloworld ಮತ್ತು ನಾವು ಇದನ್ನು ನೋಡುತ್ತೇವೆ:

ಅಕ್ಕಿ. 2. JBoss EAP ನಿಂದ ಮೂಲ ಹಲೋ ವರ್ಲ್ಡ್.

ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡುವುದು

ಇನ್‌ಪುಟ್ ಪ್ಯಾರಾಮೀಟರ್ createHelloMessage (ಸ್ಟ್ರಿಂಗ್ ಹೆಸರು) ಅನ್ನು ವರ್ಲ್ಡ್‌ನಿಂದ ಮಾರ್ಕೊಗೆ ಬದಲಾಯಿಸಿ:

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

ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಮತ್ತೆ ಚಲಾಯಿಸಿ:

$ mvn clean install wildfly:deploy

ನಂತರ ನಾವು ಬ್ರೌಸರ್‌ನಲ್ಲಿ ಪುಟವನ್ನು ರಿಫ್ರೆಶ್ ಮಾಡುತ್ತೇವೆ ಮತ್ತು ಪಠ್ಯವು ಬದಲಾಗಿದೆ ಎಂದು ನೋಡಿ:

ಅಕ್ಕಿ. 3. JBoss EAP ನಲ್ಲಿ ಹಲೋ ಮಾರ್ಕೊ.

ಹೆಲೋವರ್ಲ್ಡ್ ನಿಯೋಜನೆಯನ್ನು ಹಿಂತಿರುಗಿಸಿ ಮತ್ತು JBoss EAP ಅನ್ನು ಸ್ಥಗಿತಗೊಳಿಸಿ

ಇದು ಐಚ್ಛಿಕವಾಗಿದೆ, ಆದರೆ ನೀವು ನಿಯೋಜನೆಯನ್ನು ರದ್ದುಗೊಳಿಸಲು ಬಯಸಿದರೆ, ನೀವು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯೊಂದಿಗೆ ಹಾಗೆ ಮಾಡಬಹುದು:

$ mvn clean install wildfly:undeploy

ನಿಮ್ಮ JBoss EAP ನಿದರ್ಶನವನ್ನು ಮುಚ್ಚಲು, ಟರ್ಮಿನಲ್ ವಿಂಡೋದಲ್ಲಿ Ctrl+C ಒತ್ತಿರಿ.

ಹೆಲೋವರ್ಲ್ಡ್ ಅನ್ನು ನವೀಕರಿಸಲಾಗುತ್ತಿದೆ

ಈಗ ಮೂಲ ಹೆಲೋವರ್ಲ್ಡ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಆಧುನೀಕರಿಸೋಣ.

ಹೊಸ ಶಾಖೆಯನ್ನು ರಚಿಸಿ

ಕ್ವಿಕ್‌ಸ್ಟಾರ್ಟ್ ಪ್ರಾಜೆಕ್ಟ್ ಪೂರ್ಣಗೊಂಡ ನಂತರ ನಾವು ಹೊಸ ಕಾರ್ಯ ಶಾಖೆಯನ್ನು ರಚಿಸುತ್ತೇವೆ:

$ git checkout -b quarkus 7.2.0.GA

pom.xml ಫೈಲ್ ಅನ್ನು ಬದಲಾಯಿಸಲಾಗುತ್ತಿದೆ

ನಾವು pom.xml ಫೈಲ್‌ನಿಂದ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಬದಲಾಯಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ. ಕ್ವಾರ್ಕಸ್‌ಗೆ XML ಬ್ಲಾಕ್‌ಗಳನ್ನು ಸೇರಿಸಲು ಅನುಮತಿಸಲು, helloworld ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿ:

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

ಈ ಲೇಖನವನ್ನು ಬರೆಯುವಾಗ, ಆವೃತ್ತಿ 0.23.2 ಅನ್ನು ಬಳಸಲಾಗಿದೆ. ಕ್ವಾರ್ಕಸ್ ಆಗಾಗ್ಗೆ ಹೊಸ ಆವೃತ್ತಿಗಳನ್ನು ಬಿಡುಗಡೆ ಮಾಡುತ್ತದೆ, ವೆಬ್‌ಸೈಟ್‌ನಲ್ಲಿ ಯಾವ ಆವೃತ್ತಿಯು ಇತ್ತೀಚಿನದು ಎಂಬುದನ್ನು ನೀವು ಕಂಡುಹಿಡಿಯಬಹುದು github.com/quarkusio/quarkus/releases/latest.

ಮೇಲಿನ ಆಜ್ಞೆಯು ಈ ಕೆಳಗಿನ ಅಂಶಗಳನ್ನು pom.xml ಗೆ ಸೇರಿಸುತ್ತದೆ:

ಆಸ್ತಿ , ಇದು ಬಳಸಲು ಕ್ವಾರ್ಕಸ್‌ನ ಆವೃತ್ತಿಯನ್ನು ಸೂಚಿಸುತ್ತದೆ.
ನಿರ್ಬಂಧಿಸಿ ಕ್ವಾರ್ಕಸ್ BOM ಅನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳಲು (ವಸ್ತುಗಳ ಬಿಲ್), ಆದ್ದರಿಂದ ಪ್ರತಿ ಕ್ವಾರ್ಕಸ್ ಅವಲಂಬನೆಗೆ ಆವೃತ್ತಿಯನ್ನು ಸೇರಿಸುವುದಿಲ್ಲ.
ಕ್ವಾರ್ಕಸ್-ಮಾವೆನ್-ಪ್ಲಗಿನ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ಯಾಕೇಜಿಂಗ್ ಮಾಡಲು ಮತ್ತು ಅಭಿವೃದ್ಧಿ ಮೋಡ್ ಅನ್ನು ಒದಗಿಸಲು ಕಾರಣವಾಗಿದೆ.
ಅಪ್ಲಿಕೇಶನ್ ಎಕ್ಸಿಕ್ಯೂಟಬಲ್‌ಗಳನ್ನು ರಚಿಸಲು ಸ್ಥಳೀಯ ಪ್ರೊಫೈಲ್.

ಹೆಚ್ಚುವರಿಯಾಗಿ, ನಾವು ಈ ಕೆಳಗಿನ ಬದಲಾವಣೆಗಳನ್ನು pom.xml ಗೆ ಹಸ್ತಚಾಲಿತವಾಗಿ ಮಾಡುತ್ತೇವೆ:

ಟ್ಯಾಗ್ ಅನ್ನು ಎಳೆಯುವುದು ಬ್ಲಾಕ್ನಿಂದ ಮತ್ತು ಅದನ್ನು ಟ್ಯಾಗ್ ಮೇಲೆ ಇರಿಸಿ . ಏಕೆಂದರೆ ಮುಂದಿನ ಹಂತದಲ್ಲಿ ನಾವು ಬ್ಲಾಕ್ ಅನ್ನು ತೆಗೆದುಹಾಕುತ್ತೇವೆ , ನಂತರ ನೀವು ಉಳಿಸಬೇಕಾಗಿದೆ .
ಒಂದು ಬ್ಲಾಕ್ ಅನ್ನು ತೆಗೆದುಹಾಕಲಾಗುತ್ತಿದೆ , ಏಕೆಂದರೆ ಕ್ವಾರ್ಕಸ್‌ನೊಂದಿಗೆ ಚಾಲನೆಯಲ್ಲಿರುವಾಗ, ಈ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಇನ್ನು ಮುಂದೆ JBoss ನಿಂದ ಪೋಷಕ ಪೋಮ್ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ.
ಟ್ಯಾಗ್ ಸೇರಿಸಿ ಮತ್ತು ಅದನ್ನು ಟ್ಯಾಗ್ ಅಡಿಯಲ್ಲಿ ಇರಿಸಿ . ನಿಮಗೆ ಬೇಕಾದ ಆವೃತ್ತಿ ಸಂಖ್ಯೆಯನ್ನು ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು.
ಟ್ಯಾಗ್ ಅನ್ನು ತೆಗೆದುಹಾಕಲಾಗುತ್ತಿದೆ , ಈ ಅಪ್ಲಿಕೇಶನ್ ಇನ್ನು ಮುಂದೆ ಯುದ್ಧವಲ್ಲ, ಆದರೆ ಸಾಮಾನ್ಯ JAR ಆಗಿರುವುದರಿಂದ.
ನಾವು ಈ ಕೆಳಗಿನ ಅವಲಂಬನೆಗಳನ್ನು ಮಾರ್ಪಡಿಸುತ್ತೇವೆ:
1. ಅವಲಂಬನೆಯನ್ನು javax.enterprise:cdi-api ಅನ್ನು io.quarkus:quarkus-arc ಗೆ ಬದಲಾಯಿಸಿ, ತೆಗೆದುಹಾಕುವುದು ಒದಗಿಸಲಾಗಿದೆ , ರಿಂದ (ಡಾಕ್ಸ್ ಪ್ರಕಾರ) ಈ ಕ್ವಾರ್ಕಸ್ ವಿಸ್ತರಣೆಯು CDI ಅವಲಂಬನೆಗಳ ಇಂಜೆಕ್ಷನ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ.
2. ಅವಲಂಬನೆಯನ್ನು org.jboss.spec.javax.servlet:jboss-servlet-api_4.0_spec ಗೆ io.quarkus:quarkus-undertow, ತೆಗೆದುಹಾಕುವುದು ಬದಲಾಯಿಸಿ ಒದಗಿಸಲಾಗಿದೆ , ಏಕೆಂದರೆ (ಡಾಕ್ಸ್ ಪ್ರಕಾರ) ಈ ಕ್ವಾರ್ಕಸ್ ವಿಸ್ತರಣೆಯು ಸರ್ವ್ಲೆಟ್‌ಗಳಿಗೆ ಬೆಂಬಲವನ್ನು ಒದಗಿಸುತ್ತದೆ.
3. ನಾವು org.jboss.spec.javax.annotation:jboss-annotations-api_1.3_spec ಅವಲಂಬನೆಯನ್ನು ತೆಗೆದುಹಾಕುತ್ತೇವೆ ಏಕೆಂದರೆ ಅದು ನಾವು ಬದಲಾಯಿಸಿದ ಅವಲಂಬನೆಗಳೊಂದಿಗೆ ಬರುತ್ತದೆ.

ಎಲ್ಲಾ ಬದಲಾವಣೆಗಳೊಂದಿಗೆ pom.xml ಫೈಲ್‌ನ ಆವೃತ್ತಿ ಇದೆ github.com/mrizzi/jboss-eap-quickstarts/blob/quarkus/helloworld/pom.xml.

mvn io.quarkus:quarkus-maven-plugin:0.23.2:create ಮೇಲಿನ ಆಜ್ಞೆಯು pom.xml ಫೈಲ್ ಅನ್ನು ಬದಲಾಯಿಸುವುದಲ್ಲದೆ, ಯೋಜನೆಗೆ ಹಲವಾರು ಘಟಕಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ, ಅವುಗಳೆಂದರೆ ಕೆಳಗಿನ ಫೈಲ್‌ಗಳು ಮತ್ತು ಫೋಲ್ಡರ್‌ಗಳು:

mvnw ಮತ್ತು mvnw.cmd ಫೈಲ್ ಮತ್ತು .mvn ಫೋಲ್ಡರ್: ಮಾವೆನ್ ವ್ರ್ಯಾಪರ್ ಆ ಆವೃತ್ತಿಯನ್ನು ಸ್ಥಾಪಿಸದೆಯೇ ನೀಡಲಾದ ಮಾವೆನ್ ಆವೃತ್ತಿಯ ಮಾವೆನ್ ಯೋಜನೆಗಳನ್ನು ಚಲಾಯಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
ಡಾಕರ್ ಫೋಲ್ಡರ್ (src/main/ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ): ಇದು ಸ್ಥಳೀಯ ಮತ್ತು jvm ಮೋಡ್‌ಗಳಿಗಾಗಿ (.dockerignore ಫೈಲ್ ಜೊತೆಗೆ) ಉದಾಹರಣೆ ಡಾಕರ್‌ಫೈಲ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.
ಸಂಪನ್ಮೂಲಗಳ ಫೋಲ್ಡರ್ (src/main/ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ): ಇದು ಖಾಲಿ ಅಪ್ಲಿಕೇಶನ್.ಪ್ರಾಪರ್ಟೀಸ್ ಫೈಲ್ ಮತ್ತು ಮಾದರಿ Quarkus index.html ಪ್ರಾರಂಭ ಪುಟವನ್ನು ಒಳಗೊಂಡಿದೆ (ಹೆಚ್ಚಿನ ವಿವರಗಳಿಗಾಗಿ ಆಧುನೀಕರಿಸಿದ ಹೆಲೋವರ್ಲ್ಡ್ ಅನ್ನು ರನ್ ಮಾಡಿ).

ಹೆಲೋವರ್ಲ್ಡ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ
ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲು, ನಾವು ಕ್ವಾರ್ಕಸ್: 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] Nothing to compile - all classes are up to date
[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] Beginning quarkus augmentation
INFO  [org.jbo.threads] JBoss Threads version 3.0.0.Final
ERROR [io.qua.dev.DevModeMain] Failed to start quarkus: java.lang.RuntimeException: io.quarkus.builder.BuildException: Build failure: Build failed due to errors
	[error]: Build step io.quarkus.arc.deployment.ArcProcessor#validate threw an exception: javax.enterprise.inject.spi.DeploymentException: javax.enterprise.inject.UnsatisfiedResolutionException: Unsatisfied dependency for type org.jboss.as.quickstarts.helloworld.HelloService and qualifiers [@Default]
	- java member: org.jboss.as.quickstarts.helloworld.HelloWorldServlet#helloService
	- declared on CLASS bean [types=[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], qualifiers=[@Default, @Any], target=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)
Caused by: javax.enterprise.inject.UnsatisfiedResolutionException: Unsatisfied dependency for type org.jboss.as.quickstarts.helloworld.HelloService and qualifiers [@Default]
	- java member: org.jboss.as.quickstarts.helloworld.HelloWorldServlet#helloService
	- declared on CLASS bean [types=[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], qualifiers=[@Default, @Any], target=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 more

ಆದ್ದರಿಂದ, ಇದು ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ ... ಏಕೆ?

UnsatisfiedResolutionException HelloService ವರ್ಗವನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಇದು HelloWorldServlet ವರ್ಗದ ಸದಸ್ಯವಾಗಿದೆ (java ಸದಸ್ಯ: org.jboss.as.quickstarts.helloworld.HelloWorldServlet#helloService). ಸಮಸ್ಯೆ ಏನೆಂದರೆ HelloWorldServlet ಗೆ HelloService ನ ಚುಚ್ಚುಮದ್ದಿನ ನಿದರ್ಶನದ ಅಗತ್ಯವಿದೆ ಮತ್ತು ಅದನ್ನು ಕಂಡುಹಿಡಿಯಲಾಗುವುದಿಲ್ಲ (ಈ ಎರಡೂ ವರ್ಗಗಳು ಒಂದೇ ಪ್ಯಾಕೇಜ್‌ನಲ್ಲಿದ್ದರೂ ಸಹ).

ಇದು ಹಿಂತಿರುಗುವ ಸಮಯ ದಸ್ತಾವೇಜನ್ನು ಮತ್ತು ಕ್ವಾರ್ಕಸ್‌ನಲ್ಲಿ ಅದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ಓದಿ ಚುಚ್ಚುಮದ್ದು, ಆದ್ದರಿಂದ ಸಂದರ್ಭಗಳು ಮತ್ತು ಅವಲಂಬನೆ ಇಂಜೆಕ್ಷನ್ (CDI). ಆದ್ದರಿಂದ, ಸನ್ನಿವೇಶಗಳು ಮತ್ತು ಅವಲಂಬನೆ ಇಂಜೆಕ್ಷನ್ ಮಾರ್ಗದರ್ಶಿ ಮತ್ತು ವಿಭಾಗದಲ್ಲಿ ತೆರೆಯಿರಿ ಬೀನ್ ಡಿಸ್ಕವರಿ ನಾವು ಓದುತ್ತೇವೆ: "ಬೀನ್-ವ್ಯಾಖ್ಯಾನಿಸುವ ಟಿಪ್ಪಣಿಯನ್ನು ಹೊಂದಿರದ ಬೀನ್ ವರ್ಗವನ್ನು ಹುಡುಕಲಾಗುವುದಿಲ್ಲ."

HelloService ವರ್ಗವನ್ನು ನೋಡೋಣ - ಇದು ನಿಜವಾಗಿಯೂ ಅಂತಹ ಟಿಪ್ಪಣಿಯನ್ನು ಹೊಂದಿಲ್ಲ. ಆದ್ದರಿಂದ, ಅದನ್ನು ಸೇರಿಸಬೇಕು ಇದರಿಂದ ಕ್ವಾರ್ಕಸ್ ಹುರುಳಿಯನ್ನು ಹುಡುಕಬಹುದು ಮತ್ತು ಕಂಡುಹಿಡಿಯಬಹುದು. ಮತ್ತು ಇದು ಸ್ಥಿತಿಯಿಲ್ಲದ ವಸ್ತುವಾಗಿರುವುದರಿಂದ, ನಾವು ಈ ರೀತಿಯ @ApplicationScoped ಟಿಪ್ಪಣಿಯನ್ನು ಸುಲಭವಾಗಿ ಸೇರಿಸಬಹುದು:

@ApplicationScoped
public class HelloService {

ಗಮನಿಸಿ: ಇಲ್ಲಿ ಅಭಿವೃದ್ಧಿ ಪರಿಸರವು ಅಗತ್ಯವಿರುವ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಸೇರಿಸಲು ನಿಮ್ಮನ್ನು ಕೇಳಬಹುದು (ಕೆಳಗಿನ ಸಾಲನ್ನು ನೋಡಿ), ಮತ್ತು ನೀವು ಇದನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಮಾಡಬೇಕು, ಈ ರೀತಿ:

import javax.enterprise.context.ApplicationScoped;

ಮೂಲ ಬೀನ್‌ಗೆ ನಿರ್ದಿಷ್ಟಪಡಿಸದಿದ್ದಲ್ಲಿ ಯಾವ ಸ್ಕೋಪ್ ಅನ್ನು ಬಳಸಬೇಕು ಎಂಬುದರ ಕುರಿತು ನಿಮಗೆ ಸಂದೇಹವಿದ್ದರೆ, ದಸ್ತಾವೇಜನ್ನು ಓದಿ JSR 365: Java 2.0-ಡೀಫಾಲ್ಟ್ ಸ್ಕೋಪ್‌ಗಾಗಿ ಸಂದರ್ಭಗಳು ಮತ್ತು ಅವಲಂಬನೆ ಇಂಜೆಕ್ಷನ್.

ಈಗ ನಾವು ಮತ್ತೆ ./mvnw ಕಂಪೈಲ್ 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]

ಈಗ ಎಲ್ಲವೂ ದೋಷಗಳಿಲ್ಲದೆ ಹೋಗುತ್ತದೆ.

ಆಧುನೀಕರಿಸಿದ ಹೆಲೋವರ್ಲ್ಡ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತಿದೆ
ಲಾಗ್‌ನಲ್ಲಿ ಬರೆದಂತೆ, ಅದನ್ನು ಬ್ರೌಸರ್‌ನಲ್ಲಿ ತೆರೆಯಿರಿ 0.0.0.0:8080 (ಡೀಫಾಲ್ಟ್ ಕ್ವಾರ್ಕಸ್ ಪ್ರಾರಂಭ ಪುಟ) ಮತ್ತು ನಾವು ಇದನ್ನು ನೋಡುತ್ತೇವೆ:

ಅಕ್ಕಿ. 4. ಕ್ವಾರ್ಕಸ್ ದೇವ್ ಪ್ರಾರಂಭ ಪುಟ.

ಈ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ WebServlet ಟಿಪ್ಪಣಿಯು ಈ ಕೆಳಗಿನ ಸಂದರ್ಭ ವ್ಯಾಖ್ಯಾನವನ್ನು ಒಳಗೊಂಡಿದೆ:

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

ಆದ್ದರಿಂದ, ನಾವು ಬ್ರೌಸರ್ಗೆ ಹೋಗುತ್ತೇವೆ 0.0.0.0:8080/HelloWorld ಮತ್ತು ನಾವು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ನೋಡುತ್ತೇವೆ:

ಅಕ್ಕಿ. 5: ಹಲೋ ವರ್ಲ್ಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಕ್ವಾರ್ಕಸ್ ದೇವ್ ಪುಟ.

ಸರಿ, ಎಲ್ಲವೂ ಕೆಲಸ ಮಾಡುತ್ತದೆ.

ಈಗ ಕೋಡ್‌ಗೆ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡೋಣ. ./mvnw ಕಂಪೈಲ್ quarkus:dev ಆಜ್ಞೆಯು ಇನ್ನೂ ಚಾಲನೆಯಲ್ಲಿದೆ ಮತ್ತು ಅದನ್ನು ನಿಲ್ಲಿಸುವ ಉದ್ದೇಶ ನಮಗಿಲ್ಲ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ಈಗ ಕೋಡ್‌ಗೆ ಅದೇ ಬದಲಾವಣೆಗಳನ್ನು ಅನ್ವಯಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ - ಅತ್ಯಂತ ಕ್ಷುಲ್ಲಕ - ಮತ್ತು ಕ್ವಾರ್ಕಸ್ ಡೆವಲಪರ್‌ಗೆ ಜೀವನವನ್ನು ಹೇಗೆ ಸುಲಭಗೊಳಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೋಡೋಣ:

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

ಕೆಳಗಿನ ಸ್ಕ್ರೀನ್‌ಶಾಟ್‌ನಲ್ಲಿ ತೋರಿಸಿರುವಂತೆ ಹಲೋ ಮಾರ್ಕೊ ನೋಡಲು ಫೈಲ್ ಅನ್ನು ಉಳಿಸಿ ಮತ್ತು ನಂತರ ವೆಬ್ ಪುಟವನ್ನು ರಿಫ್ರೆಶ್ ಮಾಡಿ:

ಅಕ್ಕಿ. 6. ಕ್ವಾರ್ಕಸ್ ದೇವ್‌ನಲ್ಲಿ ಹಲೋ ಮಾರ್ಕೊ ಪುಟ.

ಈಗ ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಪರಿಶೀಲಿಸೋಣ:

INFO  [io.qua.dev] (vert.x-worker-thread-3) Changed source files detected, recompiling [/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 stopped in 0.003s
INFO  [io.qua.dep.QuarkusAugmentor] (vert.x-worker-thread-3) Beginning quarkus augmentation
INFO  [io.qua.dep.QuarkusAugmentor] (vert.x-worker-thread-3) Quarkus augmentation completed in 232ms
INFO  [io.quarkus] (vert.x-worker-thread-3) Quarkus 0.23.2 started in 0.257s. Listening on: http://0.0.0.0:8080
INFO  [io.quarkus] (vert.x-worker-thread-3) Profile dev activated. Live Coding activated.
INFO  [io.quarkus] (vert.x-worker-thread-3) Installed features: [cdi]
INFO  [io.qua.dev] (vert.x-worker-thread-3) Hot replace total time: 0.371s

ಪುಟ ರಿಫ್ರೆಶ್ ಮೂಲ ಕೋಡ್‌ನಲ್ಲಿನ ಬದಲಾವಣೆಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಪ್ರಚೋದಿಸಿತು ಮತ್ತು ಕ್ವಾರ್ಕಸ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸ್ಟಾಪ್-ಸ್ಟಾರ್ಟ್ ಕಾರ್ಯವಿಧಾನವನ್ನು ನಿರ್ವಹಿಸಿತು. ಮತ್ತು ಇದೆಲ್ಲವೂ ಕೇವಲ 0.371 ಸೆಕೆಂಡುಗಳಲ್ಲಿ ಪೂರ್ಣಗೊಂಡಿತು (ಇಲ್ಲಿ ಅದು "ಅಲ್ಟ್ರಾ-ಫಾಸ್ಟ್ ಸಬ್ಟಾಮಿಕ್ ಜಾವಾ").

ಹೆಲೋವರ್ಲ್ಡ್ ಅನ್ನು JAR ಪ್ಯಾಕೇಜ್ ಆಗಿ ನಿರ್ಮಿಸಲಾಗುತ್ತಿದೆ
ಈಗ ಕೋಡ್ ಅದರಂತೆಯೇ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯೊಂದಿಗೆ ಅದನ್ನು ಪ್ಯಾಕೇಜ್ ಮಾಡೋಣ:

$ ./mvnw clean package

ಈ ಆಜ್ಞೆಯು /ಟಾರ್ಗೆಟ್ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಎರಡು JAR ಫೈಲ್‌ಗಳನ್ನು ರಚಿಸುತ್ತದೆ: helloworld-.jar ಫೈಲ್, ಇದು ಪ್ರಾಜೆಕ್ಟ್‌ನ ತರಗತಿಗಳು ಮತ್ತು ಸಂಪನ್ಮೂಲಗಳೊಂದಿಗೆ ಮಾವೆನ್ ತಂಡದಿಂದ ಜೋಡಿಸಲಾದ ಪ್ರಮಾಣಿತ ಕಲಾಕೃತಿಯಾಗಿದೆ. ಮತ್ತು helloworld-runner.jar ಫೈಲ್, ಇದು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ JAR ಆಗಿದೆ.

ಇದು uber-jar ಅಲ್ಲ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ, ಏಕೆಂದರೆ ಎಲ್ಲಾ ಅವಲಂಬನೆಗಳನ್ನು ಸರಳವಾಗಿ /target/lib ಫೋಲ್ಡರ್‌ಗೆ ನಕಲಿಸಲಾಗುತ್ತದೆ (JAR ಫೈಲ್‌ಗೆ ಪ್ಯಾಕ್ ಮಾಡಲಾಗಿಲ್ಲ). ಆದ್ದರಿಂದ, ಈ JAR ಅನ್ನು ಮತ್ತೊಂದು ಫೋಲ್ಡರ್‌ನಿಂದ ಅಥವಾ ಇನ್ನೊಂದು ಹೋಸ್ಟ್‌ನಲ್ಲಿ ರನ್ ಮಾಡಲು, ನೀವು JAR ಫೈಲ್ ಅನ್ನು ಸ್ವತಃ ಮತ್ತು ಅಲ್ಲಿ /lib ಫೋಲ್ಡರ್ ಎರಡನ್ನೂ ನಕಲಿಸಬೇಕಾಗುತ್ತದೆ, JAR ಪ್ಯಾಕೇಜ್‌ನಲ್ಲಿರುವ MANIFEST.MF ಫೈಲ್‌ನಲ್ಲಿರುವ Class-Path ಅಂಶವು ಒಳಗೊಂಡಿದೆ ಲಿಬ್ ಫೋಲ್ಡರ್‌ಗಳಿಂದ JAR ಗಳ ಸ್ಪಷ್ಟ ಪಟ್ಟಿ
uber-jar ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂಬುದನ್ನು ತಿಳಿಯಲು, ದಯವಿಟ್ಟು ಟ್ಯುಟೋರಿಯಲ್ ಅನ್ನು ಉಲ್ಲೇಖಿಸಿ ಉಬರ್-ಜಾರ್ ಸೃಷ್ಟಿ.

JAR ನಲ್ಲಿ ಪ್ಯಾಕ್ ಮಾಡಲಾದ ಹೆಲೋವರ್ಲ್ಡ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ

ಈಗ ನಾವು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಜಾವಾ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ನಮ್ಮ JAR ಅನ್ನು ಚಲಾಯಿಸಬಹುದು:

$ java -jar ./target/helloworld-<version>-runner.jar
INFO  [io.quarkus] (main) Quarkus 0.23.2 started in 0.673s. Listening on: http://0.0.0.0:8080
INFO  [io.quarkus] (main) Profile prod activated.
INFO  [io.quarkus] (main) Installed features: [cdi]

ಇದೆಲ್ಲವನ್ನೂ ಮಾಡಿದ ನಂತರ, ನಿಮ್ಮ ಬ್ರೌಸರ್‌ಗೆ ಹೋಗಿ 0.0.0.0:8080 ಮತ್ತು ಎಲ್ಲವೂ ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ.

ಹೆಲೋವರ್ಲ್ಡ್ ಅನ್ನು ಸ್ಥಳೀಯ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಫೈಲ್‌ಗೆ ಕಂಪೈಲ್ ಮಾಡಲಾಗುತ್ತಿದೆ

ಆದ್ದರಿಂದ ನಮ್ಮ ಹೆಲೋವರ್ಲ್ಡ್ ಕ್ವಾರ್ಕಸ್ ಅವಲಂಬನೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ವತಂತ್ರ ಜಾವಾ ಅಪ್ಲಿಕೇಶನ್‌ನಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಆದರೆ ನೀವು ಮುಂದೆ ಹೋಗಿ ಅದನ್ನು ಸ್ಥಳೀಯ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಫೈಲ್ ಆಗಿ ಪರಿವರ್ತಿಸಬಹುದು.

GraalVM ಅನ್ನು ಸ್ಥಾಪಿಸಲಾಗುತ್ತಿದೆ
ಮೊದಲನೆಯದಾಗಿ, ಇದಕ್ಕಾಗಿ ನೀವು ಅಗತ್ಯ ಸಾಧನಗಳನ್ನು ಸ್ಥಾಪಿಸಬೇಕಾಗಿದೆ:

1. GraalVM 19.2.0.1 ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ github.com/oracle/graal/releases/tag/vm-19.2.0.1.

2. ಡೌನ್‌ಲೋಡ್ ಮಾಡಿದ ಆರ್ಕೈವ್ ಅನ್ನು ವಿಸ್ತರಿಸಿ:

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

3. ಅನ್ಟಾರ್ ಫೋಲ್ಡರ್ಗೆ ಹೋಗಿ.

4. ಸ್ಥಳೀಯ ಚಿತ್ರವನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಲು ಮತ್ತು ಸೇರಿಸಲು ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿ:

$ ./bin/gu install native-image

5. ಹಂತ 2 ರಲ್ಲಿ ರಚಿಸಲಾದ ಫೋಲ್ಡರ್ ಅನ್ನು GRAALVM_HOME ಪರಿಸರ ವೇರಿಯಬಲ್‌ಗೆ ನೋಂದಾಯಿಸಿ:

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

ಇತರ OS ಗಳಲ್ಲಿ ಹೆಚ್ಚಿನ ಮಾಹಿತಿ ಮತ್ತು ಅನುಸ್ಥಾಪನಾ ಸೂಚನೆಗಳಿಗಾಗಿ, ಕೈಪಿಡಿಯನ್ನು ನೋಡಿ ಸ್ಥಳೀಯ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ-ಪೂರ್ವಾಪೇಕ್ಷಿತಗಳನ್ನು ನಿರ್ಮಿಸುವುದು.

ಹೆಲೋವರ್ಲ್ಡ್ ಅನ್ನು ಸ್ಥಳೀಯ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಫೈಲ್ ಆಗಿ ನಿರ್ಮಿಸುವುದು
ಕೈಪಿಡಿಯನ್ನು ಓದುವುದು ಸ್ಥಳೀಯ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ನಿರ್ಮಿಸುವುದು - ಸ್ಥಳೀಯ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಉತ್ಪಾದಿಸುವುದು: “ಈಗ ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಅದರ ಉಡಾವಣಾ ಸಮಯ ಮತ್ತು ಡಿಸ್ಕ್ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಸ್ಥಳೀಯ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಫೈಲ್ ಅನ್ನು ರಚಿಸೋಣ. ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಫೈಲ್ JVM (ಅಥವಾ ಬದಲಿಗೆ, ಅದರ ಮೊಟಕುಗೊಳಿಸಿದ ಆವೃತ್ತಿ, ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಚಲಾಯಿಸಲು ಅಗತ್ಯವಿರುವದನ್ನು ಮಾತ್ರ ಒಳಗೊಂಡಿರುತ್ತದೆ) ಮತ್ತು ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಒಳಗೊಂಡಂತೆ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರನ್ ಮಾಡಲು ಅಗತ್ಯವಿರುವ ಎಲ್ಲವನ್ನೂ ಹೊಂದಿರುತ್ತದೆ.

ಸ್ಥಳೀಯ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಫೈಲ್ ಅನ್ನು ರಚಿಸಲು, ನೀವು ಸ್ಥಳೀಯ ಮಾವೆನ್ ಪ್ರೊಫೈಲ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಬೇಕು:

$ ./mvnw package -Pnative

ನಮ್ಮ ನಿರ್ಮಾಣವು ಒಂದು ನಿಮಿಷ ಮತ್ತು 10 ಸೆಕೆಂಡುಗಳನ್ನು ತೆಗೆದುಕೊಂಡಿತು ಮತ್ತು ಅಂತಿಮ ಹೆಲೋವರ್ಲ್ಡ್-ರನ್ನರ್ ಎಫ್ ಫೈಲ್ ಅನ್ನು / ಟಾರ್ಗೆಟ್ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ರಚಿಸಲಾಗಿದೆ.

ಸ್ಥಳೀಯ ಹೆಲೋವರ್ಲ್ಡ್ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ರನ್ ಮಾಡಿ

ಹಿಂದಿನ ಹಂತದಲ್ಲಿ, ನಾವು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಫೈಲ್ /ಟಾರ್ಗೆಟ್/ಹೆಲೋವರ್ಲ್ಡ್-ರನ್ನರ್ ಅನ್ನು ಸ್ವೀಕರಿಸಿದ್ದೇವೆ. ಈಗ ಅದನ್ನು ಚಲಾಯಿಸೋಣ:

$ ./target/helloworld-<version>-runner
INFO  [io.quarkus] (main) Quarkus 0.23.2 started in 0.006s. Listening on: http://0.0.0.0:8080
INFO  [io.quarkus] (main) Profile prod activated.
INFO  [io.quarkus] (main) Installed features: [cdi]

ಅದನ್ನು ಮತ್ತೊಮ್ಮೆ ಬ್ರೌಸರ್‌ನಲ್ಲಿ ತೆರೆಯಿರಿ 0.0.0.0:8080 ಮತ್ತು ಎಲ್ಲವೂ ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ.

ಈ ಪೋಸ್ಟ್‌ನಲ್ಲಿ ಚರ್ಚಿಸಲಾದ ಕ್ವಾರ್ಕಸ್ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಜಾವಾ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಆಧುನೀಕರಿಸುವ ವಿಧಾನವನ್ನು ನಿಜ ಜೀವನದಲ್ಲಿ ಸಕ್ರಿಯವಾಗಿ ಬಳಸಬೇಕೆಂದು ನಾವು ನಂಬುತ್ತೇವೆ (ಸರಳ ಉದಾಹರಣೆಯನ್ನು ಬಳಸುತ್ತಿದ್ದರೂ). ಹಾಗೆ ಮಾಡುವಾಗ, ನೀವು ಹಲವಾರು ಸಮಸ್ಯೆಗಳನ್ನು ಎದುರಿಸಬಹುದು, ಅದನ್ನು ನಾವು ಮುಂದಿನ ಪೋಸ್ಟ್‌ನಲ್ಲಿ ಭಾಗಶಃ ಪರಿಹರಿಸುತ್ತೇವೆ, ಅಲ್ಲಿ ನಾವು ಕಾರ್ಯಕ್ಷಮತೆ ಸುಧಾರಣೆಗಳನ್ನು ನಿರ್ಣಯಿಸಲು ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಹೇಗೆ ಅಳೆಯುವುದು ಎಂಬುದರ ಕುರಿತು ಮಾತನಾಡುತ್ತೇವೆ, ಇದು ಸಂಪೂರ್ಣ ಅಪ್ಲಿಕೇಶನ್ ಆಧುನೀಕರಣ ಪ್ರಕ್ರಿಯೆಯ ಪ್ರಮುಖ ಭಾಗವಾಗಿದೆ.

ಮೂಲ: www.habr.com

ಕ್ವಾರ್ಕಸ್: JBoss EAP ಕ್ವಿಕ್‌ಸ್ಟಾರ್ಟ್‌ನಿಂದ ಹೆಲೋವರ್ಲ್ಡ್ ಅನ್ನು ಉದಾಹರಣೆಯಾಗಿ ಬಳಸಿಕೊಂಡು ಅಪ್ಲಿಕೇಶನ್ ಆಧುನೀಕರಣ

ಕೋಡ್ ಪಡೆಯೋಣ

ಮೂಲ ಹೆಲೋವರ್ಲ್ಡ್ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೋಡೋಣ

ಹೆಲೋವರ್ಲ್ಡ್ ಅನ್ನು ನವೀಕರಿಸಲಾಗುತ್ತಿದೆ

ಕಾಮೆಂಟ್ ಅನ್ನು ಸೇರಿಸಿ Отменить ответ