ਕੁਆਰਕਸ ਇੱਕ ਸੁਪਰਸੋਨਿਕ ਉਪ-ਪਰਮਾਣੂ ਜਾਵਾ ਹੈ। ਫਰੇਮਵਰਕ ਦੀ ਸੰਖੇਪ ਜਾਣਕਾਰੀ

ਜਾਣ ਪਛਾਣ

XNUMX ਮਾਰਚ ਨੂੰ, RedHat (ਛੇਤੀ ਹੀ IBM) представила ਨਵਾਂ ਫਰੇਮਵਰਕ - ਕਵਾਕਰਸ. ਡਿਵੈਲਪਰਾਂ ਦੇ ਅਨੁਸਾਰ, ਇਹ ਫਰੇਮਵਰਕ GraalVM ਅਤੇ OpenJDK HotSpot 'ਤੇ ਅਧਾਰਤ ਹੈ ਅਤੇ Kubernetes ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ। ਕੁਆਰਕਸ ਸਟੈਕ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ: JPA/Hibernate, JAX-RS/RESTEasy, Eclipse Vert.x, Netty, Apache Camel, Kafka, Prometheus ਅਤੇ ਹੋਰ।

ਟੀਚਾ ਜਾਵਾ ਨੂੰ ਕੁਬਰਨੇਟਸ ਤੈਨਾਤੀ ਅਤੇ ਸਰਵਰ ਰਹਿਤ ਐਪਲੀਕੇਸ਼ਨ ਡਿਵੈਲਪਮੈਂਟ ਲਈ ਮੋਹਰੀ ਪਲੇਟਫਾਰਮ ਬਣਾਉਣਾ ਹੈ, ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਅਤੇ ਲਾਜ਼ਮੀ ਸ਼ੈਲੀਆਂ ਵਿੱਚ ਵਿਕਾਸ ਲਈ ਇੱਕ ਏਕੀਕ੍ਰਿਤ ਪਹੁੰਚ ਪ੍ਰਦਾਨ ਕਰਨਾ ਹੈ।

ਜੇ ਤੁਸੀਂ ਦੇਖਦੇ ਹੋ ਇਹ ਫਰੇਮਵਰਕ ਦਾ ਵਰਗੀਕਰਨ, ਫਿਰ ਕੁਆਰਕਸ ਕਿਤੇ “ਐਗਰੀਗੇਟਰ/ਕੋਡ ਜਨਰੇਟਰ” ਅਤੇ “ਉੱਚ-ਪੱਧਰੀ ਫੁੱਲਸਟੈਕ ਫਰੇਮਵਰਕ” ਦੇ ਵਿਚਕਾਰ ਹੈ। ਇਹ ਪਹਿਲਾਂ ਹੀ ਇੱਕ ਐਗਰੀਗੇਟਰ ਤੋਂ ਵੱਧ ਹੈ, ਪਰ ਇਹ ਪੂਰੇ-ਸਟੈਕ ਤੱਕ ਵੀ ਨਹੀਂ ਪਹੁੰਚਦਾ, ਕਿਉਂਕਿ... ਬੈਕਐਂਡ ਵਿਕਾਸ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ।

ਐਪਲੀਕੇਸ਼ਨ ਲਾਂਚ ਦੀ ਬਹੁਤ ਤੇਜ਼ ਗਤੀ ਅਤੇ ਘੱਟ ਮੈਮੋਰੀ ਖਪਤ ਦਾ ਵਾਅਦਾ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਹ ਡਿਵੈਲਪਰ ਦੀ ਵੈੱਬਸਾਈਟ ਤੋਂ ਡੇਟਾ ਹੈ:

ਸ਼ੁਰੂਆਤ ਤੋਂ ਲੈ ਕੇ ਪਹਿਲੇ ਜਵਾਬ ਤੱਕ ਦਾ ਸਮਾਂ:

ਕੌਨਫਿਗਰੇਸ਼ਨ
ਆਰਾਮ
REST+JPA

ਕੁਆਰਕਸ+ਗ੍ਰੇਲਵੀਐਮ
0.014
0.055

ਕੁਆਰਕਸ+ਓਪਨਜੇਡੀਕੇ
0.75
2.5

ਰਵਾਇਤੀ ਕਲਾਉਡ ਨੇਟਿਵ ਸਟੈਕ*
4.3
9.5

ਮੈਮੋਰੀ ਦੀ ਖਪਤ (Mb):

ਕੌਨਫਿਗਰੇਸ਼ਨ
ਆਰਾਮ
REST+JPA

ਕੁਆਰਕਸ+ਗ੍ਰੇਲਵੀਐਮ
13
35

ਕੁਆਰਕਸ+ਓਪਨਜੇਡੀਕੇ
74
130

ਰਵਾਇਤੀ ਕਲਾਉਡ ਨੇਟਿਵ ਸਟੈਕ*
140
218

ਪ੍ਰਭਾਵਸ਼ਾਲੀ, ਹੈ ਨਾ?

*ਮੈਨੂੰ ਇਸ ਟੈਕਨਾਲੋਜੀ ਸਟੈਕ ਬਾਰੇ ਕੋਈ ਜਾਣਕਾਰੀ ਨਹੀਂ ਮਿਲੀ, ਅਸੀਂ ਇਹ ਮੰਨ ਸਕਦੇ ਹਾਂ ਕਿ ਇਹ ਇੱਕ ਵਾਧੂ ਬਾਡੀ ਕਿੱਟ ਵਾਲਾ ਸਪਰਿੰਗ ਬੂਟ ਹੈ.

ਸਤਿ ਸ੍ਰੀ ਅਕਾਲ ਦੁਨਿਆ!

ਕੁਆਰਕਸ ਵਿੱਚ ਲਿਖੀ ਸਭ ਤੋਂ ਸਰਲ ਐਪਲੀਕੇਸ਼ਨ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗੀ:

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

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

ਇਹ ਸ਼ਾਬਦਿਕ ਇੱਕ ਕਲਾਸ ਹੈ ਅਤੇ ਇਹ ਕਾਫ਼ੀ ਹੈ! ਤੁਸੀਂ ਵਿਕਾਸ ਮੋਡ ਵਿੱਚ ਮਾਵੇਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਐਪਲੀਕੇਸ਼ਨ ਚਲਾ ਸਕਦੇ ਹੋ:

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

ਇੱਕ ਨਿਯਮਤ ਐਪਲੀਕੇਸ਼ਨ ਤੋਂ ਫਰਕ ਇਹ ਹੈ ਕਿ ਇੱਥੇ ਕੋਈ ਐਪਲੀਕੇਸ਼ਨ ਕਲਾਸ ਨਹੀਂ ਹੈ! ਕੁਆਰਕਸ ਹੌਟ ਰੀਲੋਡ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ, ਇਸਲਈ ਤੁਸੀਂ ਆਪਣੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਰੀਸਟਾਰਟ ਕੀਤੇ ਬਿਨਾਂ ਬਦਲ ਸਕਦੇ ਹੋ, ਜਿਸ ਨਾਲ ਵਿਕਾਸ ਹੋਰ ਵੀ ਤੇਜ਼ ਹੋ ਜਾਂਦਾ ਹੈ।

ਅੱਗੇ ਕੀ ਹੈ? ਤੁਸੀਂ ਇੱਕ ਐਨੋਟੇਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਕੰਟਰੋਲਰ ਵਿੱਚ ਇੱਕ ਸੇਵਾ ਸ਼ਾਮਲ ਕਰ ਸਕਦੇ ਹੋ ਟੀਕਾ ਲਗਾਓ. ਸੇਵਾ ਕੋਡ:

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

ਨੋਟ ਕਰੋ ਕਿ ਕੁਆਰਕਸ ਜਾਣੇ-ਪਛਾਣੇ ਫਰੇਮਵਰਕ - CDI ਅਤੇ JAX-RS ਤੋਂ ਮਿਆਰੀ ਐਨੋਟੇਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਜੇ ਤੁਸੀਂ ਪਹਿਲਾਂ CDI ਅਤੇ JAX-RS ਨਾਲ ਕੰਮ ਕੀਤਾ ਹੈ, ਤਾਂ ਕੁਝ ਨਵਾਂ ਸਿੱਖਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਬੇਸ਼ੱਕ।

ਡਾਟਾਬੇਸ ਨਾਲ ਕੰਮ ਕਰਨਾ

ਇਕਾਈਆਂ ਲਈ ਹਾਈਬਰਨੇਟ ਅਤੇ ਮਿਆਰੀ JPA ਐਨੋਟੇਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਜਿਵੇਂ ਕਿ REST ਕੰਟਰੋਲਰਾਂ ਨਾਲ, ਤੁਹਾਨੂੰ ਘੱਟੋ-ਘੱਟ ਕੋਡ ਲਿਖਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਅਸੈਂਬਲੀ ਫਾਈਲ ਵਿੱਚ ਨਿਰਭਰਤਾ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਇਹ ਕਾਫ਼ੀ ਹੈ, ਐਨੋਟੇਸ਼ਨ ਸ਼ਾਮਲ ਕਰੋ @Entity ਅਤੇ application.properties ਵਿੱਚ ਡੇਟਾਸੋਰਸ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰੋ।

ਸਾਰੇ। ਕੋਈ sessionFactory, persistence.xml ਜਾਂ ਹੋਰ ਸੇਵਾ ਫਾਈਲਾਂ ਨਹੀਂ ਹਨ। ਅਸੀਂ ਸਿਰਫ਼ ਉਹੀ ਕੋਡ ਲਿਖਦੇ ਹਾਂ ਜਿਸਦੀ ਲੋੜ ਹੈ। ਹਾਲਾਂਕਿ, ਜੇਕਰ ਲੋੜ ਹੋਵੇ, ਤਾਂ ਤੁਸੀਂ persistence.xml ਫਾਈਲ ਬਣਾ ਸਕਦੇ ਹੋ ਅਤੇ ORM ਲੇਅਰ ਨੂੰ ਹੋਰ ਬਾਰੀਕ ਰੂਪ ਵਿੱਚ ਕੌਂਫਿਗਰ ਕਰ ਸਕਦੇ ਹੋ।

ਕੁਆਰਕਸ ਇਕਾਈਆਂ ਦੀ ਕੈਸ਼ਿੰਗ, ਇਕ-ਤੋਂ-ਕਈ ਸਬੰਧਾਂ ਲਈ ਸੰਗ੍ਰਹਿ, ਅਤੇ ਸਵਾਲਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ। ਪਹਿਲੀ ਨਜ਼ਰ 'ਤੇ ਇਹ ਬਹੁਤ ਵਧੀਆ ਲੱਗ ਰਿਹਾ ਹੈ, ਪਰ ਇਹ ਹੈ ਸਥਾਨਕ ਕੈਸ਼ਿੰਗ, ਇੱਕ ਕੁਬਰਨੇਟਸ ਨੋਡ ਲਈ। ਉਹ. ਵੱਖ-ਵੱਖ ਨੋਡਾਂ ਦੇ ਕੈਚ ਇੱਕ ਦੂਜੇ ਨਾਲ ਸਮਕਾਲੀ ਨਹੀਂ ਹੁੰਦੇ ਹਨ। ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਇਹ ਅਸਥਾਈ ਹੈ।

ਅਸਿੰਕ੍ਰੋਨਸ ਕੋਡ ਐਗਜ਼ੀਕਿਊਸ਼ਨ

ਜਿਵੇਂ ਕਿ ਉੱਪਰ ਦੱਸਿਆ ਗਿਆ ਹੈ, ਕੁਆਰਕਸ ਰਿਐਕਟਿਵ ਪ੍ਰੋਗਰਾਮਿੰਗ ਸ਼ੈਲੀ ਦਾ ਵੀ ਸਮਰਥਨ ਕਰਦਾ ਹੈ। ਪਿਛਲੀ ਅਰਜ਼ੀ ਦਾ ਕੋਡ ਇੱਕ ਵੱਖਰੇ ਰੂਪ ਵਿੱਚ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ।

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

ਅਸਿੰਕ੍ਰੋਨਸ ਕੋਡ ਨੂੰ ਵੀ ਸੇਵਾ ਵਿੱਚ ਤਬਦੀਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਨਤੀਜਾ ਉਹੀ ਹੋਵੇਗਾ।

ਟੈਸਟਿੰਗ

ਕੁਆਰਕਸ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਟੈਸਟ 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 ਐਨੋਟੇਸ਼ਨ ਤੁਹਾਨੂੰ ਟੈਸਟ ਚਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਐਪਲੀਕੇਸ਼ਨ ਚਲਾਉਣ ਲਈ ਨਿਰਦੇਸ਼ ਦਿੰਦੀ ਹੈ। ਬਾਕੀ ਸਾਰੇ ਡਿਵੈਲਪਰਾਂ ਲਈ ਜਾਣੂ ਕੋਡ ਹੈ।

ਪਲੇਟਫਾਰਮ-ਵਿਸ਼ੇਸ਼ ਐਪਲੀਕੇਸ਼ਨ

ਕਿਉਂਕਿ ਕੁਆਰਕਸ GraalVM ਨਾਲ ਪੂਰੀ ਤਰ੍ਹਾਂ ਨਾਲ ਏਕੀਕ੍ਰਿਤ ਹੈ, ਬੇਸ਼ਕ ਪਲੇਟਫਾਰਮ-ਵਿਸ਼ੇਸ਼ ਕੋਡ ਬਣਾਉਣਾ ਸੰਭਵ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ GraalVM ਨੂੰ ਇੰਸਟਾਲ ਕਰਨ ਅਤੇ GRAALVM_HOME ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਅੱਗੇ ਅਸੈਂਬਲੀ ਲਈ ਇੱਕ ਪ੍ਰੋਫਾਈਲ ਰਜਿਸਟਰ ਕਰੋ ਅਤੇ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਂਦੇ ਸਮੇਂ ਇਸਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰੋ:

mvn package -Pnative

ਦਿਲਚਸਪ ਗੱਲ ਇਹ ਹੈ ਕਿ, ਤਿਆਰ ਕੀਤੀ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਜਾਂਚ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ. ਅਤੇ ਇਹ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿਉਂਕਿ ਮੂਲ ਕੋਡ ਦਾ ਐਗਜ਼ੀਕਿਊਸ਼ਨ JVM 'ਤੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਤੋਂ ਵੱਖਰਾ ਹੋ ਸਕਦਾ ਹੈ। @SubstrateTest ਐਨੋਟੇਸ਼ਨ ਪਲੇਟਫਾਰਮ-ਵਿਸ਼ੇਸ਼ ਐਪਲੀਕੇਸ਼ਨ ਕੋਡ ਨੂੰ ਚਲਾਉਂਦੀ ਹੈ। ਮੌਜੂਦਾ ਟੈਸਟ ਕੋਡ ਦੀ ਮੁੜ ਵਰਤੋਂ ਵਿਰਾਸਤ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ; ਨਤੀਜੇ ਵਜੋਂ, ਪਲੇਟਫਾਰਮ-ਨਿਰਭਰ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਕੋਡ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗਾ:

@SubstrateTest
public class GreetingResourceIT extends GreetingResourceTest {

}

ਤਿਆਰ ਚਿੱਤਰ ਨੂੰ ਡੌਕਰ ਵਿੱਚ ਪੈਕ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਕੁਬਰਨੇਟਸ ਜਾਂ ਓਪਨਸ਼ਿਫਟ ਵਿੱਚ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਵਿਸਥਾਰ ਵਿੱਚ ਦੱਸਿਆ ਗਿਆ ਹੈ ਹਦਾਇਤਾਂ.

ਸੰਦ

ਕੁਆਰਕਸ ਫਰੇਮਵਰਕ ਨੂੰ Maven ਅਤੇ Gradle ਨਾਲ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਗ੍ਰੇਡਲ ਦੇ ਉਲਟ, ਮਾਵੇਨ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਮਰਥਿਤ ਹੈ। ਬਦਕਿਸਮਤੀ ਨਾਲ, ਇਸ ਸਮੇਂ ਗ੍ਰੇਡਲ ਇੱਕ ਖਾਲੀ ਪ੍ਰੋਜੈਕਟ ਬਣਾਉਣ ਦਾ ਸਮਰਥਨ ਨਹੀਂ ਕਰਦਾ ਹੈ; ਵੈਬਸਾਈਟ 'ਤੇ ਵਿਸਤ੍ਰਿਤ ਜਾਣਕਾਰੀ ਹੈ ਪਾਠ ਪੁਸਤਕ.

ਐਕਸਟੈਂਸ਼ਨਾਂ

ਕੁਆਰਕਸ ਇੱਕ ਵਿਸਤ੍ਰਿਤ ਢਾਂਚਾ ਹੈ। ਵਰਤਮਾਨ ਵਿੱਚ ਇੱਕ ਆਰਡਰ ਹੈ 40 ਐਕਸਟੈਂਸ਼ਨਾਂ, ਜੋ ਵੱਖ-ਵੱਖ ਕਾਰਜਕੁਸ਼ਲਤਾਵਾਂ ਨੂੰ ਜੋੜਦਾ ਹੈ - ਸਮਰਥਨ ਤੋਂ ਸਪਰਿੰਗ ਡੀਆਈ ਕੰਟੇਨਰ и ਅਪਾਚੇ ਊਠ ਸੇਵਾਵਾਂ ਨੂੰ ਚਲਾਉਣ ਲਈ ਲੌਗਿੰਗ ਅਤੇ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ। ਅਤੇ ਜਾਵਾ ਤੋਂ ਇਲਾਵਾ, ਕੋਟਲਿਨ ਵਿੱਚ ਲਿਖਤੀ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦਾ ਸਮਰਥਨ ਕਰਨ ਲਈ ਪਹਿਲਾਂ ਹੀ ਇੱਕ ਐਕਸਟੈਂਸ਼ਨ ਹੈ।

ਸਿੱਟਾ

ਮੇਰੀ ਰਾਏ ਵਿੱਚ, ਕੁਆਰਕਸ ਉਸ ਸਮੇਂ ਦੇ ਰੁਝਾਨਾਂ ਦੇ ਨਾਲ ਕਾਫ਼ੀ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਬੈਕਐਂਡ ਕੋਡ ਵਿਕਾਸ ਆਸਾਨ ਅਤੇ ਆਸਾਨ ਹੁੰਦਾ ਜਾ ਰਿਹਾ ਹੈ, ਅਤੇ ਇਹ ਫਰੇਮਵਰਕ ਡੌਕਰ ਅਤੇ ਕੁਬਰਨੇਟਸ ਲਈ ਮੂਲ ਸਹਾਇਤਾ ਜੋੜ ਕੇ ਸੇਵਾ ਵਿਕਾਸ ਨੂੰ ਹੋਰ ਸਰਲ ਅਤੇ ਤੇਜ਼ ਕਰਦਾ ਹੈ। ਇੱਕ ਵੱਡਾ ਪਲੱਸ GraalVM ਅਤੇ ਪਲੇਟਫਾਰਮ-ਨਿਰਭਰ ਚਿੱਤਰਾਂ ਦੀ ਪੀੜ੍ਹੀ ਲਈ ਬਿਲਟ-ਇਨ ਸਮਰਥਨ ਹੈ, ਜੋ ਸੇਵਾਵਾਂ ਨੂੰ ਅਸਲ ਵਿੱਚ ਤੇਜ਼ੀ ਨਾਲ ਸ਼ੁਰੂ ਕਰਨ ਅਤੇ ਬਹੁਤ ਘੱਟ ਮੈਮੋਰੀ ਸਪੇਸ ਲੈਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਅਤੇ ਇਹ ਮਾਈਕ੍ਰੋਸੇਵਾਵਾਂ ਅਤੇ ਸਰਵਰ ਰਹਿਤ ਆਰਕੀਟੈਕਚਰ ਲਈ ਸਾਡੇ ਵੱਡੇ ਜਨੂੰਨ ਦੇ ਸਮੇਂ ਵਿੱਚ ਬਹੁਤ ਮਹੱਤਵਪੂਰਨ ਹੈ।

ਅਧਿਕਾਰਤ ਸਾਈਟ - quarkus.io. ਇੱਕ ਤੇਜ਼ ਸ਼ੁਰੂਆਤ ਲਈ ਪ੍ਰੋਜੈਕਟਾਂ ਦੀਆਂ ਉਦਾਹਰਨਾਂ ਪਹਿਲਾਂ ਹੀ ਉਪਲਬਧ ਹਨ GitHub.

ਸਰੋਤ: www.habr.com