Quarkus არის ზებგერითი სუბატომიური ჯავა. ჩარჩოს მოკლე მიმოხილვა

შესავალი

XNUMX მარტს RedHat (მალე IBM) წარმოდგენილი ახალი ჩარჩო - კვარკუსი. დეველოპერების თქმით, ეს ფრეიმერი დაფუძნებულია GraalVM-ზე და OpenJDK HotSpot-ზე და შექმნილია Kubernetes-ისთვის. Quarkus სტეკში შედის: JPA/Hibernate, JAX-RS/RESTEasy, Eclipse Vert.x, Netty, Apache Camel, Kafka, Prometheus და სხვები.

მიზანია ჯავა გახდეს წამყვან პლატფორმა Kubernetes-ის განლაგებისა და უსერვერო აპლიკაციების განვითარებისთვის, რაც უზრუნველყოფს დეველოპერებს განვითარების ერთიან მიდგომას როგორც რეაქტიულ, ისე იმპერატიულ სტილში.

Ყურება ეს ჩარჩოების კლასიფიკაცია, მაშინ Quarkus არის სადღაც "Aggregators/Code Generators" და "High Level Fullstack Frameworks" შორის. ეს უკვე აგრეგატორზე მეტია, მაგრამ სრულ სტეკსაც კი არ აღწევს, რადგან... მორგებული backend განვითარებისთვის.

დაპირებულია აპლიკაციის გაშვების ძალიან მაღალი სიჩქარე და მეხსიერების დაბალი მოხმარება. აქ არის მონაცემები დეველოპერის ვებსაიტიდან:

დრო დასაწყისიდან პირველ პასუხამდე:

კონფიგურაცია
დასვენება
დასვენება + JPA

Quarkus+GraalVM
0.014
0.055

Quarkus + OpenJDK
0.75
2.5

ტრადიციული Cloud Native Stack*
4.3
9.5

მეხსიერების მოხმარება (მბ):

კონფიგურაცია
დასვენება
დასვენება + JPA

Quarkus+GraalVM
13
35

Quarkus + OpenJDK
74
130

ტრადიციული Cloud Native Stack*
140
218

შთამბეჭდავია, არა?

*მე ვერ ვიპოვე ინფორმაცია ამ ტექნოლოგიის დასტაზე, შეგვიძლია ვივარაუდოთ, რომ ეს არის ერთგვარი საგაზაფხულო ჩექმა დამატებითი სხეულის ნაკრებით.

გამარჯობა მსოფლიო!

Quarkus-ში დაწერილი უმარტივესი აპლიკაცია ასე გამოიყურება:

@Path("/hello")
public class GreetingResource {

   @GET
   @Produces(MediaType.TEXT_PLAIN)
   public String hello() {
       return "hello";
   }
}

ფაქტიურად ერთი კლასია და საკმარისია! შეგიძლიათ აპლიკაციის გაშვება Maven-ის გამოყენებით განვითარების რეჟიმში:

mvn compile quarkus:dev
…
$ curl http://localhost:8080/hello
hello

განსხვავება ჩვეულებრივი აპლიკაციისგან არის ის, რომ არ არსებობს აპლიკაციის კლასი! Quarkus მხარს უჭერს ცხელ გადატვირთვას, ასე რომ თქვენ შეგიძლიათ შეცვალოთ თქვენი აპლიკაცია მისი გადატვირთვის გარეშე, რაც კიდევ უფრო აჩქარებს განვითარებას.

Რა არის შემდეგი? თქვენ შეგიძლიათ დაამატოთ სერვისი კონტროლერს ანოტაციის გამოყენებით ინექცია. სერვისის კოდი:

@ApplicationScoped
public class GreetingService {

   public String greeting(String name) {
       return "Hello " + name + "!";
   }
}

კონტროლერი:

@Path("/hello")
public class GreetingResource {

   @Inject
   GreetingService service;

   @GET
   @Produces(MediaType.TEXT_PLAIN)
   @Path("/{name}")
   public String greeting(@PathParam("name") String name) {
       return service.greeting(name);
   }
}

$ curl http://localhost:8080/hello/developer
Hello developer!

გაითვალისწინეთ, რომ Quarkus იყენებს სტანდარტულ ანოტაციებს ნაცნობი ჩარჩოებიდან - CDI და JAX-RS. არაფრის ახლის სწავლა არ არის საჭირო, თუ ადრე, რა თქმა უნდა, გიმუშავიათ CDI-თან და JAX-RS-თან.

მონაცემთა ბაზასთან მუშაობა

Hibernate და სტანდარტული JPA ანოტაციები ერთეულებისთვის გამოიყენება. როგორც REST კონტროლერებთან, თქვენ უნდა დაწეროთ მინიმალური კოდი. საკმარისია მიუთითოთ დამოკიდებულებები ასამბლეის ფაილში, დაამატეთ ანოტაციები @Entity და დააკონფიგურიროთ მონაცემთა წყარო application.properties-ში.

ყველა. არ არის sessionFactory, persistence.xml ან სხვა სერვისის ფაილები. ჩვენ ვწერთ მხოლოდ საჭირო კოდს. თუმცა, საჭიროების შემთხვევაში, შეგიძლიათ შექმნათ persistence.xml ფაილი და დააკონფიგურიროთ ORM ფენა უფრო დეტალურად.

Quarkus მხარს უჭერს ერთეულების ქეშირებას, კოლექციებს ერთიდან ბევრთან ურთიერთობისთვის და მოთხოვნებისთვის. ერთი შეხედვით მშვენივრად გამოიყურება, მაგრამ ასეა ადგილობრივი ქეშირება, ერთი კუბერნეტის კვანძისთვის. იმათ. სხვადასხვა კვანძების ქეში არ არის სინქრონიზებული ერთმანეთთან. იმედი მაქვს, რომ ეს დროებითია.

ასინქრონული კოდის შესრულება

როგორც ზემოთ აღინიშნა, Quarkus ასევე მხარს უჭერს რეაქტიული პროგრამირების სტილს. წინა განაცხადის კოდი შეიძლება დაიწეროს სხვა ფორმით.

@Path("/hello")
public class GreetingResource {

   @GET
   @Produces(MediaType.TEXT_PLAIN)
   @Path("/{name}")
   public CompletionStage<String> greeting(@PathParam("name") String name) {
       return CompletableFuture.supplyAsync(() -> {
           return "Hello " + name + "!";
       });
   }
}

ასინქრონული კოდის გადატანა შესაძლებელია სერვისზეც, შედეგი იგივე იქნება.

ტესტირება

Quarkus აპლიკაციების ტესტები შეიძლება დაიწეროს JUnit4 ან JUnit5. ქვემოთ მოცემულია საბოლოო წერტილის ტესტის მაგალითი, ის დაწერილია RestAssured-ის გამოყენებით, მაგრამ შეიძლება გამოყენებულ იქნას სხვა ჩარჩო:

@QuarkusTest
public class GreetingResourceTest {

   @Test
   public void testGreetingEndpoint() {
       String uuid = UUID.randomUUID().toString();
       given()
         .pathParam("name", uuid)
         .when().get("/hello/{name}")
         .then()
           .statusCode(200)
           .body(is("Hello " + uuid + "!"));
   }
}

@QuarkusTest ანოტაცია გაძლევთ აპლიკაციის გაშვებას ტესტების გაშვებამდე. დანარჩენი ყველა დეველოპერისთვის ნაცნობი კოდია.

პლატფორმის სპეციფიკური აპლიკაცია

ვინაიდან Quarkus მჭიდროდ არის ინტეგრირებული GraalVM-თან, რა თქმა უნდა, შესაძლებელია პლატფორმის სპეციფიკური კოდის გენერირება. ამისათვის თქვენ უნდა დააინსტალიროთ GraalVM და მიუთითოთ GRAALVM_HOME გარემოს ცვლადი. Უფრო დაარეგისტრირეთ პროფილი შეკრებისთვის და მიუთითეთ იგი განაცხადის შექმნისას:

mvn package -Pnative

საინტერესოა, რომ გენერირებული აპლიკაციის ტესტირება შესაძლებელია. და ეს მნიშვნელოვანია, რადგან მშობლიური კოდის შესრულება შეიძლება განსხვავდებოდეს JVM-ზე შესრულებისგან. @SubstrateTest ანოტაცია გადის პლატფორმის სპეციფიკურ აპლიკაციის კოდს. არსებული სატესტო კოდის ხელახლა გამოყენება შეიძლება განხორციელდეს მემკვიდრეობის გამოყენებით; შედეგად, პლატფორმაზე დამოკიდებული აპლიკაციის ტესტირების კოდი ასე გამოიყურება:

@SubstrateTest
public class GreetingResourceIT extends GreetingResourceTest {

}

გენერირებული სურათი შეიძლება შეფუთული იყოს Docker-ში და გაშვებული Kubernetes-ში ან OpenShift-ში, დეტალურად აღწერილი ინსტრუქციები.

ინსტრუმენტები

Quarkus-ის ჩარჩო შეიძლება გამოყენებულ იქნას Maven-თან და Gradle-თან ერთად. Maven სრულად არის მხარდაჭერილი, განსხვავებით Gradle. სამწუხაროდ, ამ მომენტში Gradle არ უჭერს მხარს ცარიელი პროექტის გენერირებას; საიტზე არის დეტალური ინფორმაცია სახელმძღვანელო.

გაგრძელება

Quarkus არის გაფართოებადი ჩარჩო. ამჟამად არის შეკვეთა 40 გაფართოება, რომელიც ამატებს სხვადასხვა ფუნქციონირებას - მხარდაჭერიდან Spring DI კონტეინერი и აპაჩის აქლემი შესვლამდე და გაშვებული სერვისების მეტრიკის გამოქვეყნებამდე. და უკვე არსებობს გაფართოება, რომ მხარი დაუჭიროს აპლიკაციების წერას კოტლინში, Java-ს გარდა.

დასკვნა

ჩემი აზრით, Quarkus საკმაოდ შეესაბამება იმდროინდელ ტენდენციებს. Backend კოდის შემუშავება უფრო და უფრო ადვილი ხდება და ეს ჩარჩო კიდევ უფრო ამარტივებს და აჩქარებს სერვისის განვითარებას Docker-ისა და Kubernetes-ის მშობლიური მხარდაჭერის დამატებით. უზარმაზარი პლუსია GraalVM-ის ჩაშენებული მხარდაჭერა და პლატფორმაზე დამოკიდებული სურათების გენერაცია, რაც საშუალებას აძლევს სერვისებს სწრაფად დაიწყოს და დაიკავოს მეხსიერების მცირე ადგილი. და ეს ძალიან მნიშვნელოვანია მიკროსერვისებითა და უსერვერო არქიტექტურით მასობრივი გატაცების ჩვენს დროში.

Ოფიციალური გვერდი - quarkus.io. სწრაფი დაწყების პროექტების მაგალითები უკვე ხელმისაწვდომია GitHub.

წყარო: www.habr.com