ક્વાર્કસ એ સુપરસોનિક સબએટોમિક જાવા છે. ફ્રેમવર્કની સંક્ષિપ્ત ઝાંખી

પરિચય

XNUMXમી માર્ચે, RedHat (ટૂંક સમયમાં IBM) પ્રસ્તુત નવું માળખું - ક્વાર્કસ. વિકાસકર્તાઓના મતે, આ ફ્રેમવર્ક GraalVM અને OpenJDK HotSpot પર આધારિત છે અને કુબરનેટ્સ માટે રચાયેલ છે. ક્વાર્કસ સ્ટેકમાં નીચેનાનો સમાવેશ થાય છે: JPA/Hibernate, JAX-RS/RESTEasy, Eclipse Vert.x, Netty, Apache Camel, Kafka, Prometheus અને અન્ય.

ધ્યેય જાવાને કુબરનેટ્સ જમાવટ અને સર્વરલેસ એપ્લિકેશન ડેવલપમેન્ટ માટે અગ્રણી પ્લેટફોર્મ બનાવવાનો છે, જે વિકાસકર્તાઓને પ્રતિક્રિયાશીલ અને અનિવાર્ય બંને શૈલીમાં વિકાસ માટે એકીકૃત અભિગમ પ્રદાન કરે છે.

જો તમે જુઓ આ ફ્રેમવર્કનું વર્ગીકરણ, પછી ક્વાર્કસ ક્યાંક “એગ્રીગેટર્સ/કોડ જનરેટર્સ” અને “હાઈ-લેવલ ફુલસ્ટેક ફ્રેમવર્ક” વચ્ચે છે. આ પહેલેથી જ એક એગ્રીગેટર કરતાં વધુ છે, પરંતુ તે પૂર્ણ-સ્ટૅક સુધી પણ પહોંચતું નથી, કારણ કે... બેકએન્ડ વિકાસ માટે તૈયાર.

એપ્લિકેશન લોંચની ખૂબ જ ઊંચી ઝડપ અને ઓછી મેમરી વપરાશનું વચન આપવામાં આવ્યું છે. અહીં વિકાસકર્તાની વેબસાઇટનો ડેટા છે:

શરૂઆતથી પ્રથમ પ્રતિસાદ (ઓ) સુધીનો સમય:

રૂપરેખાંકન
REST
REST+JPA

ક્વાર્કસ+ગ્રાલવીએમ
0.014
0.055

ક્વાર્કસ+ઓપનજેડીકે
0.75
2.5

પરંપરાગત ક્લાઉડ નેટિવ સ્ટેક*
4.3
9.5

મેમરી વપરાશ (Mb):

રૂપરેખાંકન
REST
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 એક્સ્ટેન્શન્સ, જે વિવિધ કાર્યક્ષમતા ઉમેરે છે - સપોર્ટથી વસંત DI કન્ટેનર и અપાચે ઊંટ સેવાઓ ચલાવવા માટે મેટ્રિક્સ લોગિંગ અને પ્રકાશિત કરતા પહેલા. અને જાવા ઉપરાંત કોટલિનમાં લેખન એપ્લિકેશનને સપોર્ટ કરવા માટે પહેલેથી જ એક વિસ્તરણ છે.

નિષ્કર્ષ

મારા મતે, ક્વાર્કસ તે સમયના વલણો સાથે એકદમ સુસંગત છે. બેકએન્ડ કોડ ડેવલપમેન્ટ વધુ સરળ અને સરળ બની રહ્યું છે, અને આ ફ્રેમવર્ક ડોકર અને કુબરનેટ્સ માટે મૂળ આધાર ઉમેરીને સેવાના વિકાસને વધુ સરળ અને ઝડપી બનાવે છે. એક વિશાળ વત્તા એ GraalVM માટે બિલ્ટ-ઇન સપોર્ટ અને પ્લેટફોર્મ-આધારિત ઈમેજીસની પેઢી છે, જે સેવાઓને ખરેખર ઝડપથી શરૂ કરવા અને થોડી મેમરી સ્પેસ લેવા દે છે. અને માઇક્રોસર્વિસિસ અને સર્વરલેસ આર્કિટેક્ચર માટેના અમારા સામૂહિક જુસ્સાના સમયમાં આ ખૂબ જ મહત્વપૂર્ણ છે.

સત્તાવાર સાઇટ - quarkus.io. ઝડપી શરૂઆત માટેના પ્રોજેક્ટના ઉદાહરણો પહેલેથી જ ઉપલબ્ધ છે GitHub.

સોર્સ: www.habr.com