Ang Quarkus ay isang supersonic subatomic Java. Maikling pangkalahatang-ideya ng balangkas

Pagpapakilala

Noong ika-XNUMX ng Marso, RedHat (sa lalong madaling panahon IBM) ipinakita bagong balangkas - quarkus. Ayon sa mga developer, ang balangkas na ito ay batay sa GraalVM at OpenJDK HotSpot at idinisenyo para sa Kubernetes. Kasama sa Quarkus stack ang: JPA/Hibernate, JAX-RS/RESTEasy, Eclipse Vert.x, Netty, Apache Camel, Kafka, Prometheus at iba pa.

Ang layunin ay gawin ang Java na nangungunang platform para sa pag-deploy ng Kubernetes at walang server na pag-unlad ng application, na nagbibigay sa mga developer ng isang pinag-isang diskarte sa pag-unlad sa parehong reaktibo at imperative na mga istilo.

Kung titingnan mo ito pag-uuri ng mga balangkas, pagkatapos ang Quarkus ay nasa pagitan ng "Mga Aggregator/Mga Tagabuo ng Code" at "Mga high-level na fullstack na framework". Ito ay higit pa sa isang aggregator, ngunit hindi ito umabot sa buong stack, dahil... iniakma para sa backend development.

Ipinangako ang napakataas na bilis ng paglulunsad ng application at mababang pagkonsumo ng memorya. Narito ang data mula sa website ng developer:

Oras mula simula hanggang sa unang (mga) tugon:

Configuration
REST
REST+JPA

Quarkus+GraalVM
0.014
0.055

Quarkus+OpenJDK
0.75
2.5

Tradisyunal na Cloud Native Stack*
4.3
9.5

Pagkonsumo ng memorya (Mb):

Configuration
REST
REST+JPA

Quarkus+GraalVM
13
35

Quarkus+OpenJDK
74
130

Tradisyunal na Cloud Native Stack*
140
218

Kahanga-hanga, hindi ba?

*Wala akong nakitang anumang impormasyon tungkol sa stack ng teknolohiyang ito, maaari nating ipagpalagay na ito ay isang uri ng Spring Boot na may karagdagang body kit..

Hello World!

Ang pinakasimpleng application na nakasulat sa Quarkus ay magiging ganito:

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

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

Ito ay literal na isang klase at iyon ay sapat na! Maaari mong patakbuhin ang application gamit ang Maven sa development mode:

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

Ang pagkakaiba sa isang regular na aplikasyon ay walang klase ng Application! Sinusuportahan ng Quarkus ang mainit na pag-reload, kaya maaari mong baguhin ang iyong application nang hindi ito nire-restart, na ginagawang mas mabilis ang pag-unlad.

Anong susunod? Maaari kang magdagdag ng isang serbisyo sa isang controller gamit ang isang anotasyon Iniksyon. Code ng serbisyo:

@ApplicationScoped
public class GreetingService {

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

Controller:

@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!

Tandaan na ang Quarkus ay gumagamit ng mga karaniwang anotasyon mula sa mga pamilyar na frameworks - CDI at JAX-RS. Hindi na kailangang matuto ng bago kung nagtrabaho ka na sa CDI at JAX-RS dati, siyempre.

Makipagtulungan sa database

Ang hibernate at karaniwang JPA annotation para sa mga entity ay ginagamit. Tulad ng REST controllers, kailangan mong magsulat ng isang minimum na code. Ito ay sapat na upang ipahiwatig ang mga dependencies sa assembly file, magdagdag ng mga anotasyon @Entity at i-configure ang datasource sa application.properties.

Lahat. Walang sessionFactory, persistence.xml o iba pang mga file ng serbisyo. Sinusulat lang namin ang code na kailangan. Gayunpaman, kung kinakailangan, maaari kang lumikha ng isang persistence.xml file at i-configure ang ORM layer nang mas pinong.

Sinusuportahan ng Quarkus ang pag-cache ng mga entity, mga koleksyon para sa isa-sa-maraming relasyon, at mga query. Sa unang sulyap ito ay mukhang mahusay, ngunit ito ay lokal pag-cache, para sa isang Kubernetes node. Yung. Ang mga cache ng iba't ibang mga node ay hindi naka-synchronize sa isa't isa. Sana pansamantala lang ito.

Asynchronous na pagpapatupad ng code

Tulad ng nabanggit sa itaas, sinusuportahan din ng Quarkus ang reaktibong istilo ng programming. Ang code ng nakaraang aplikasyon ay maaaring isulat sa ibang anyo.

@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 + "!";
       });
   }
}

Ang asynchronous code ay maaari ding ilipat sa serbisyo, ang resulta ay pareho.

Pagsubok

Ang mga pagsusulit para sa mga aplikasyon ng Quarkus ay maaaring isulat sa JUnit4 o JUnit5. Nasa ibaba ang isang halimbawang pagsubok para sa isang endpoint, ito ay nakasulat gamit ang RestAssured, ngunit isa pang framework ang maaaring gamitin:

@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 + "!"));
   }
}

Ang @QuarkusTest annotation ay nagtuturo sa iyo na patakbuhin ang application bago magpatakbo ng mga pagsubok. Ang natitira ay code na pamilyar sa lahat ng mga developer.

Application na tukoy sa platform

Dahil mahigpit na isinama ang Quarkus sa GraalVM, siyempre posible na bumuo ng code na tukoy sa platform. Upang gawin ito, kailangan mong i-install ang GraalVM at tukuyin ang GRAALVM_HOME environment variable. Dagdag pa magparehistro ng isang profile para sa pagpupulong at tukuyin ito kapag binubuo ang application:

mvn package -Pnative

Kapansin-pansin, ang nabuong aplikasyon ay maaaring masuri. At ito ay mahalaga dahil ang execution ng native code ay maaaring iba sa execution sa JVM. Ang @SubstrateTest annotation ay nagpapatakbo ng code ng application na tukoy sa platform. Ang muling paggamit ng kasalukuyang test code ay maaaring gawin gamit ang inheritance; bilang resulta, ang code para sa pagsubok ng isang application na umaasa sa platform ay magiging ganito:

@SubstrateTest
public class GreetingResourceIT extends GreetingResourceTest {

}

Ang nabuong imahe ay maaaring i-package sa Docker at tumakbo sa Kubernetes o OpenShift, na inilarawan nang detalyado sa tagubilin.

Toolkit

Ang Quarkus framework ay maaaring gamitin sa Maven at Gradle. Ang Maven ay ganap na suportado, hindi tulad ng Gradle. Sa kasamaang palad, sa ngayon ay hindi sinusuportahan ng Gradle ang pagbuo ng isang walang laman na proyekto; mayroong detalyadong impormasyon sa website aklat-aralin.

Mga Extension

Ang Quarkus ay isang napapalawak na balangkas. Sa kasalukuyan ay may isang order 40 extension, na nagdaragdag ng iba't ibang functionality - mula sa suporta Lalagyan ng Spring DI и Apache Camel bago mag-log at mag-publish ng mga sukatan para sa pagpapatakbo ng mga serbisyo. At mayroon nang extension upang suportahan ang pagsusulat ng mga aplikasyon sa Kotlin, bilang karagdagan sa Java.

Konklusyon

Sa aking opinyon, ang Quarkus ay lubos na naaayon sa mga uso ng panahon. Ang pagbuo ng backend code ay nagiging mas madali at mas madali, at ang framework na ito ay higit na pinapasimple at pinapabilis ang pagbuo ng serbisyo sa pamamagitan ng pagdaragdag ng katutubong suporta para sa Docker at Kubernetes. Ang isang malaking plus ay ang built-in na suporta para sa GraalVM at ang pagbuo ng mga imahe na umaasa sa platform, na nagbibigay-daan sa mga serbisyo na magsimula nang napakabilis at kumuha ng maliit na espasyo sa memorya. At ito ay napakahalaga sa ating panahon ng mass passion para sa microservices at serverless architecture.

Opisyal na site - quarkus.io. Ang mga halimbawa ng mga proyekto para sa isang mabilis na pagsisimula ay magagamit na sa GitHub.

Pinagmulan: www.habr.com