របៀបដែល Quarkus រួមបញ្ចូលគ្នារវាង MicroProfile និង Spring

ជំរាបសួរអ្នកទាំងអស់គ្នា នេះជាប្រកាសទីបីនៅក្នុងស៊េរី Quarkus!

នៅពេលអភិវឌ្ឍ Java microservices វាត្រូវបានគេជឿថាជាញឹកញាប់ ពងក្រពើមីក្រូហ្វីត и ស្បែកជើងនិទាឃរដូវ គឺជា APIs ដាច់ដោយឡែក និងឯករាជ្យ។ តាមលំនាំដើម អ្នកសរសេរកម្មវិធីមានទំនោរប្រើ APIs ដែលពួកគេធ្លាប់ប្រើរួចហើយ ចាប់តាំងពីការរៀនក្របខ័ណ្ឌថ្មី និងសមាសធាតុពេលដំណើរការត្រូវចំណាយពេលច្រើន។ ថ្ងៃនេះយើងនឹងព្យាយាមសម្រួលដល់ការអភិវឌ្ឍន៍នៃការពេញនិយមមួយចំនួន MicroProfile API សម្រាប់អ្នកអភិវឌ្ឍន៍ Spring ហើយបង្ហាញអ្នកពីរបៀបប្រើ Spring API និងមុខងារមានប្រយោជន៍ថ្មីៗក្នុងពេលដំណាលគ្នា។ ឃឺក.

នៅក្នុងព័ត៌មានលម្អិតបន្តិច យើងនឹងពិនិត្យមើលវិសាលភាព និងព័ត៌មានលម្អិតអំពីរបៀបដែល Quarkus គាំទ្រ Spring APIs ដើម្បីបង្ហាញអ្នកអភិវឌ្ឍន៍ Spring ពីរបៀបប្រើប្រាស់ MicroProfile API នៅក្នុងការងារប្រចាំថ្ងៃរបស់ពួកគេ។ បន្ទាប់មក យើងនឹងគ្របដណ្តប់ MicroProfile APIs ដែលមានប្រយោជន៍សម្រាប់អ្នកអភិវឌ្ឍន៍ Spring នៅពេលបង្កើត microservices។

ហេតុអ្វីបានជា Quarkus? ទីមួយ នេះគឺជាការសរសេរកូដបន្តផ្ទាល់ ពោលគឺការផ្ទុកឡើងវិញដោយស្វ័យប្រវត្តិនូវការផ្លាស់ប្តូរណាមួយនៅក្នុង MicroProfile API, Spring API និង Java APIs ផ្សេងទៀត ដែលត្រូវបានអនុវត្តដោយប្រើពាក្យបញ្ជាតែមួយប៉ុណ្ណោះ៖ mvn quarkus:dev ។ ទីពីរពិចារណានៅក្នុង នៅក្នុងឧទាហរណ៍របស់យើង។ សេវាកម្មបុគ្គល (ដែលចងក្រងពី Spring, MicroProfile, និង JPA APIs ទៅជាប្រព័ន្ធគោលពីរដោយប្រើរូបភាព GraalVM ដើម) ចាប់ផ្តើមក្នុងរយៈពេលត្រឹមតែ 0.055 វិនាទី និងប្រើប្រាស់ RAM ប្រហែល 90 MB (RSS) នៅលើចំណុចបញ្ចប់កម្មវិធី RESTful ។ លើសពីនេះទៅទៀតការចងក្រងរបស់វាត្រូវបានអនុវត្តដោយពាក្យបញ្ជាតែមួយប៉ុណ្ណោះ: កញ្ចប់ mvn -Pnative ។

យើងនឹងមិនលម្អិតអំពី MicroProfile ទេ ក្រៅពីជួយអ្នកអភិវឌ្ឍន៍ Spring ឱ្យយល់ពីរបៀបដែលពួកគេអាចប្រើ Spring APIs ជាមួយ MicroProfile APIs នៅក្នុង Quarkus ។

កុងតឺន័រ និង Kubernetes

ដើម្បីរក្សាអត្ថបទនេះឱ្យសាមញ្ញ យើងនឹងគ្របដណ្តប់តែទិដ្ឋភាពកម្រិតខ្ពស់នៃការគាំទ្រនៅទីនេះ។ Kubernetesព្រោះវាសំខាន់ក្នុងការយល់ដឹង។ Quarkus ត្រូវបានដាក់ជាជង់ Java សម្រាប់ Kubernetes វាត្រូវបានរចនាឡើងដើម្បីកាត់បន្ថយការប្រើប្រាស់អង្គចងចាំ និងពេលវេលាចាប់ផ្តើមនៃកម្មវិធី និងសេវាកម្ម Java ហើយជាលទ្ធផល បង្កើនដង់ស៊ីតេរបស់ពួកគេនៅលើម៉ាស៊ីន និងកាត់បន្ថយការចំណាយសរុប។

Quarkus ផងដែរ។ គាំទ្រការបង្កើតដោយស្វ័យប្រវត្តិ ធនធាន និងការផ្តល់ជូន Kubernetes មគ្គុទេសក៍ សម្រាប់ការដាក់ពង្រាយនៅលើវេទិកា Kubernetes និង Red Hat OpenShift ។ លើសពីនេះ Quarkus បង្កើតដោយស្វ័យប្រវត្តិនូវឯកសារ Dockerfile.jvm (JVM packaging) និង Dockerfile.native (native binary packaging) ដែលត្រូវការដើម្បីបង្កើតធុង។

ជាចុងក្រោយ ដោយផ្តោតលើ Kubernetes ជាបរិយាកាសដាក់ពង្រាយគោលដៅ Quarkus មិនប្រើក្របខ័ណ្ឌ Java ក្នុងករណីដែលមុខងារស្រដៀងគ្នានេះត្រូវបានអនុវត្តនៅកម្រិតនៃវេទិកា Kubernetes ខ្លួនឯង។ តារាងទី 1 ផ្តល់នូវផែនទីនៃការឆ្លើយឆ្លងមុខងាររវាង Kubernetes និងក្របខ័ណ្ឌ Java ធម្មតាដែលប្រើដោយអ្នកអភិវឌ្ឍន៍ Spring ។

តារាងទី 1. ផែនទីនៃការឆ្លើយឆ្លងមុខងាររវាង Java frameworks និង Kubernetes ។

មុខងារ។
ស្បែកជើងនិទាឃរដូវប្រពៃណី
Kubernetes

ការរកឃើញសេវាកម្ម
អ៊ូរី
ឈ្មោះ DNS

ការកំណត់​រចនាសម្ព័ន្ធ
ការកំណត់រចនាសម្ព័ន្ធពពកនិទាឃរដូវ
កំណត់រចនាសម្ព័ន្ធផែនទី/អាថ៌កំបាំង

ផ្ទុកតុល្យភាព
ខ្សែបូ (ខាងអតិថិជន)
សេវាកម្ម, ឧបករណ៍ត្រួតពិនិត្យការចម្លង (ផ្នែកខាងម៉ាស៊ីនមេ)

ការចងក្រង និងដំណើរការកូដពីឧទាហរណ៍

នៅក្នុងអត្ថបទនេះយើងសំដៅទៅលើ គម្រោងឧទាហរណ៍ដែលជាកន្លែងដែល Spring និង MicroProfile APIs និងសូម្បីតែថ្នាក់ Java ដូចគ្នាត្រូវបានប្រើជាមួយគ្នា។ កូដក្នុងឧទាហរណ៍នេះអាចត្រូវបានចងក្រង និងដំណើរការពីបន្ទាត់ពាក្យបញ្ជា សូមមើលឯកសារ README.md សម្រាប់ព័ត៌មានលម្អិត។

Spring Framework APIs

ការចាក់បញ្ចូលភាពអាស្រ័យ

Quarkus គាំទ្រជួរនៃ បរិបទ និង​ការ​ចាក់​អាស្រ័យ (CDI) APIs និង Spring Dependency Injection (Spring DI) APIs ។ ប្រសិនបើអ្នកកំពុងធ្វើការជាមួយ MicroProfile, Java EE និង Jakarta EEបន្ទាប់មកអ្នកបានស្គាល់ CDI រួចហើយ។ ម្យ៉ាងវិញទៀត អ្នកអភិវឌ្ឍន៍ Spring អាចប្រើផ្នែកបន្ថែម Quarkus សម្រាប់ Spring DI API ដើម្បីសម្រេចបាននូវភាពឆបគ្នាជាមួយ Spring DI ។ ឧទាហរណ៍នៃការប្រើប្រាស់ Spring DI APIs ដែលគាំទ្រត្រូវបានផ្តល់ឱ្យក្នុងតារាងទី 2 ។

В គម្រោងពីឧទាហរណ៍របស់យើង។ ប្រើទាំង CDI និង Spring Dependency Injection។ សម្រាប់ព័ត៌មានបន្ថែម និងឧទាហរណ៍លើប្រធានបទនេះ សូមមើលការណែនាំ Quarkus ដែលហៅថា ការណែនាំអំពីនិទាឃរដូវ DI.

តារាង 2. ឧទាហរណ៍នៃការប្រើប្រាស់ Spring DI APIs ដែលគាំទ្រ។

លក្ខណៈពិសេស Spring DI ដែលគាំទ្រ
ឧទហរណ៍

ការចាក់បញ្ចូលសំណង់

public PersonSpringController(
   PersonSpringRepository personRepository,  // injected      
   PersonSpringMPService personService) {    // injected
      this.personRepository = personRepository;
      this.personService = personService;
}

ការចាក់តាមវាល
មានខ្សែស្វ័យប្រវត្តិ
តម្លៃ

@Autowired
@RestClient
SalutationRestClient salutationRestClient;

@Value("${fallbackSalutation}")
String fallbackSalutation;

សណ្តែក
@ការកំណត់​រចនាសម្ព័ន្ធ

@Configuration
public class AppConfiguration {
   @Bean(name = "capitalizeFunction")
   public StringFunction capitalizer() {
      return String::toUpperCase;
   }
}

សមាសភាគ

@Component("noopFunction")
public class NoOpSingleStringFunction implements StringFunction {
   @Override
   public String apply(String s) {
      return s;
   }
}

សេវាកម្ម

@Service
public class MessageProducer {
   @Value("${greeting.message}")
   String message;

   public String getPrefix() {
      return message;
   }
}

គ្រោងការណ៍បណ្តាញ

អ្នកប្រើប្រាស់ MicroProfile នឹងចូលចិត្តថា Quarkus គាំទ្រ JAX-RS, MicroProfile Rest Client, JSON-P និង JSON-B ជាគំរូកម្មវិធីគេហទំព័រចម្បង។ អ្នកអភិវឌ្ឍន៍ Spring នឹងពេញចិត្តជាមួយនឹងការគាំទ្រថ្មីៗរបស់ Quarkus សម្រាប់ Spring Web API ជាពិសេស REST interfaces។ ស្រដៀងទៅនឹង Spring DI ដែរ គោលដៅចម្បងនៃការគាំទ្រ Spring Web API គឺដើម្បីឱ្យអ្នកអភិវឌ្ឍន៍ Spring ប្រើ Spring Web APIs ដោយភ្ជាប់ជាមួយ MicroProfile APIs។ ឧទាហរណ៍នៃរបៀបប្រើ Spring Web APIs ដែលគាំទ្រត្រូវបានផ្តល់ជូននៅក្នុងតារាងទី 3 ហើយព័ត៌មានបន្ថែម និងឧទាហរណ៍អំពីប្រធានបទនេះអាចត្រូវបានរកឃើញនៅក្នុងការបង្រៀន Quarkus ដែលហៅថា មគ្គុទ្ទេសក៍គេហទំព័រនិទាឃរដូវ.

តារាងទី 3. ឧទាហរណ៍នៃការប្រើប្រាស់ Spring Web APIs ដែលគាំទ្រ។

លក្ខណៈពិសេសគេហទំព័រនិទាឃរដូវដែលគាំទ្រ
ឧទហរណ៍

@អ្នកត្រួតពិនិត្យសម្រាក
@RequestMapping

@RestController
@RequestMapping("/person")
public class PersonSpringController {
   ...
   ...
   ...
}

@GetMapping
@PostMapping
@PutMapping
@ លុបផែនទី
@PatchMapping
@RequestParam
@RequestHeader
@MatrixVariable
@PathVariable
@CookieValue
@ស្នើសុំរាងកាយ
@ស្ថានភាពឆ្លើយតប
@ExceptionHandler
@RestControllerAdvice (ផ្នែក)

@GetMapping(path = "/greet/{id}",
   produces = "text/plain")
   public String greetPerson(
   @PathVariable(name = "id") long id) {
   ...
   ...
   ...
}

ទិន្នន័យនិទាឃរដូវ JPA

អ្នកប្រើប្រាស់ MicroProfile ក៏នឹងដឹងគុណផងដែរដែល Quarkus គាំទ្រ JPA ដោយប្រើ Hibernate ORM ។ វាក៏មានដំណឹងល្អសម្រាប់អ្នកអភិវឌ្ឍន៍ Spring៖ Quarkus គាំទ្រការចំណារពន្យល់ និងប្រភេទ Spring Data JPA ទូទៅ។ ឧទាហរណ៍នៃការប្រើប្រាស់ Spring Data JPA APIs ត្រូវបានផ្តល់ឱ្យក្នុងតារាងទី 4 ។
В គម្រោងពីឧទាហរណ៍របស់យើង។ Spring Data JPA APIs ត្រូវបានប្រើ ហើយព័ត៌មានបន្ថែមមាននៅក្នុងការបង្រៀន Quarkus ដែលហៅថា មគ្គុទ្ទេសក៍ JPA ទិន្នន័យនិទាឃរដូវ.

តារាង 4. ឧទាហរណ៍នៃការប្រើប្រាស់ Spring Data JPA APIs ។

លក្ខណៈពិសេស JPA ទិន្នន័យនិទាឃរដូវដែលបានគាំទ្រ
ឧទហរណ៍

ឃ្លាំង Crud

public interface PersonRepository
         extends JpaRepository,
                 PersonFragment {
   ...
}

ឃ្លាំង
JpaRepository
PagingAndSortingRepository

public class PersonRepository extends 

    Repository {

    Person save(Person entity);

    Optional findById(Person entity);
}

បំណែកនៃឃ្លាំង

public interface PersonRepository
         extends JpaRepository,
                 PersonFragment {
   ...
}

វិធីសាស្រ្តសំណួរដែលបានមកពី

public interface PersonRepository extends CrudRepository {

    List findByName(String name);
    
    Person findByNameBySsn(String ssn);
    
    Optional 
       findByNameBySsnIgnoreCase(String ssn);

    Boolean existsBookByYearOfBirthBetween(
            Integer start, Integer end);
}

សំណួរកំណត់ដោយអ្នកប្រើប្រាស់

public interface MovieRepository
         extends CrudRepository {

    Movie findFirstByOrderByDurationDesc();

    @Query("select m from Movie m where m.rating = ?1")
    Iterator findByRating(String rating);

    @Query("from Movie where title = ?1")
    Movie findByTitle(String title);
}

MicroProfile APIs

ការអត់ឱនចំពោះកំហុស

ការសាងសង់ការអត់ឱនចំពោះកំហុសមានសារៈសំខាន់ខ្លាំងណាស់សម្រាប់ការទប់ស្កាត់ការបរាជ័យជាបណ្តើរៗ និងបង្កើតស្ថាបត្យកម្មមីក្រូសេវាកម្មដែលអាចទុកចិត្តបាន។ អ្នកអភិវឌ្ឍន៍និទាឃរដូវបានប្រើឧបករណ៍បំលែងសៀគ្វីសម្រាប់ការអត់ឱនកំហុសអស់រយៈពេលជាច្រើនឆ្នាំ។ ហ៊ីស្ទ្រីក. ទោះជាយ៉ាងណាក៏ដោយ Hystrix មិនត្រូវបានអាប់ដេតយូរមកហើយ ប៉ុន្តែ Fault Tolerance របស់ MicroProfile ឥឡូវនេះកំពុងអភិវឌ្ឍយ៉ាងសកម្ម និងមានការប្រើប្រាស់ផលិតកម្មជាច្រើនឆ្នាំនៅពីក្រោយវា។ ដូច្នេះ ដើម្បីបង្កើនភាពជឿជាក់នៃសេវាកម្មនៅក្នុង Quarkus វាត្រូវបានណែនាំឱ្យប្រើ MicroProfile Fault Tolerance APIs ដែលជាឧទាហរណ៍ដែលត្រូវបានប្រើក្នុងតារាងទី 5 ។ សម្រាប់ព័ត៌មានបន្ថែមអំពីបញ្ហានេះ សូមមើលសៀវភៅដៃ Quarkus ការណែនាំអំពីការអត់ឱនកំហុស.

តារាង 5. ឧទាហរណ៍នៃការប្រើប្រាស់ MicroProfile Fault Tolerance APIs ដែលគាំទ្រ។

លក្ខណៈពិសេសការអត់ឱនកំហុសរបស់ MicroProfile
បរិយាយ
ឧទហរណ៍

@Asynchronous

ការប្រតិបត្តិតក្កវិជ្ជានៅក្នុងខ្សែស្រឡាយដាច់ដោយឡែក

@Asynchronous
@Retry
public Future<String> getSalutation() {
   ...
   return future;
}

@Bulkhead

កំណត់ចំនួនសំណើក្នុងពេលដំណាលគ្នា។

@Bulkhead(5)
public void fiveConcurrent() {
   makeRemoteCall(); //...
}

@CircuitBreaker

ការគ្រប់គ្រងការបរាជ័យដ៏ឆ្លាតវៃ និងការងើបឡើងវិញពីការបរាជ័យ

@CircuitBreaker(delay=500   // milliseconds
   failureRatio = .75,
   requestVolumeThreshold = 20,
   successThreshold = 5)
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
   makeRemoteCall(); //...
}

@ធ្លាក់​ចុះ​មក​វិញ

ហៅតក្កវិជ្ជាជំនួសក្នុងករណីបរាជ័យ

@Timeout(500) // milliseconds
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
   makeRemoteCall(); //...
}

public String fallback() {
   return "hello";
}

ព្យាយាមម្តងទៀត

ព្យាយាមម្តងទៀតនៅពេលសំណើបរាជ័យ

@Retry(maxRetries=3)
public String getSalutation() {
   makeRemoteCall(); //...
}

អស់​ពេល

អស់ពេលគ្រប់គ្រងការបរាជ័យ

@Timeout(value = 500 )   // milliseconds
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
   makeRemoteCall(); //...
}

សេវាពិនិត្យសុខភាព (Service Health)

វេទិកា Kubernetes ត្រួតពិនិត្យសុខភាពរបស់ធុងដោយប្រើប្រាស់សេវាកម្មពិសេស។ ដើម្បីអនុញ្ញាតឱ្យវេទិកាមូលដ្ឋានត្រួតពិនិត្យសេវាកម្ម អ្នកអភិវឌ្ឍន៍ Spring ជាធម្មតាប្រើ HealthIndicator និង Spring Boot Actuator ផ្ទាល់ខ្លួន។ នៅក្នុង Quarkus នេះអាចត្រូវបានធ្វើដោយប្រើ MicroProfile Health ដែលតាមលំនាំដើមធ្វើការពិនិត្យភាពរស់រវើក ប៉ុន្តែអាចត្រូវបានកំណត់រចនាសម្ព័ន្ធដើម្បីពិនិត្យមើលភាពរស់រវើក និងការត្រៀមខ្លួនក្នុងពេលដំណាលគ្នា។ ឧទាហរណ៍នៃរបៀបប្រើប្រាស់ MicroProfile Health APIs ដែលគាំទ្រត្រូវបានផ្តល់ជូននៅក្នុងតារាងទី 6 ហើយព័ត៌មានបន្ថែមត្រូវបានផ្តល់ជូននៅក្នុងសៀវភៅដៃ Quarkus ការណែនាំអំពីសុខភាព.

តារាងទី 6៖ ការប្រើប្រាស់ឧទាហរណ៍នៃ MicroProfile Health APIs ដែលគាំទ្រ។

មុខងារសុខភាព MicroProfile
បរិយាយ
ឧទហរណ៍

@ភាពរស់រវើក

វេទិកាចាប់ផ្ដើមឡើងវិញនូវកម្មវិធីដែលមិនបានផ្ទុក
ចំណុចបញ្ចប់៖
ម៉ាស៊ីន៖ 8080/សុខភាព/បន្តផ្ទាល់

@Liveness
public class MyHC implements HealthCheck {
  public HealthCheckResponse call() {

   ...
   return HealthCheckResponse
     .named("myHCProbe")
     .status(ready ? true:false)
     .withData("mydata", data)
     .build();  
}

@ការត្រៀមខ្លួន

វេទិកានេះនឹងមិនបញ្ជូនចរាចរណ៍ទៅកាន់កម្មវិធីដែលមានកុងតឺន័រទេ ប្រសិនបើវាមិនរួចរាល់
ចំណុចបញ្ចប់៖
ម៉ាស៊ីន: 8080 / សុខភាព / រួចរាល់

@Readiness
public class MyHC implements HealthCheck {
  public HealthCheckResponse call() {

   ...
   return HealthCheckResponse
     .named("myHCProbe")
     .status(live ? true:false)
     .withData("mydata", data)
     .build();  
}

ម៉ែត្រ

កម្មវិធីផ្តល់ម៉ែត្រសម្រាប់គោលបំណងប្រតិបត្តិការ (ដើម្បីតាមដានការអនុវត្ត SLAs) ឬគោលបំណងមិនដំណើរការ (SLAs អាជីវកម្ម)។ អ្នកអភិវឌ្ឍន៍និទាឃរដូវផ្តល់នូវម៉ែត្រដោយប្រើ Spring Boot Actuator និង Micrometer ។ នៅក្នុងវេន Quarkus ប្រើ MicroProfile Metrics ដើម្បីផ្តល់នូវការវាស់វែងមូលដ្ឋាន (JVM និងប្រព័ន្ធប្រតិបត្តិការ) រង្វាស់អ្នកលក់ (Quarkus) និងម៉ែត្រកម្មវិធី។ MicroProfile Metrics តម្រូវឱ្យការអនុវត្តគាំទ្រទ្រង់ទ្រាយលទ្ធផល JSON និង OpenMetrics (Prometheus) ។ ឧទាហរណ៍នៃការប្រើប្រាស់ MicroProfile Metrics API ត្រូវបានផ្តល់ឱ្យក្នុងតារាងទី 7 ។

В គម្រោងពីឧទាហរណ៍របស់យើង។ MicroProfile Metrics ត្រូវបានប្រើដើម្បីផ្តល់ការវាស់វែងកម្មវិធី។ សម្រាប់ព័ត៌មានបន្ថែម សូមមើលសៀវភៅដៃ Quarkus មគ្គុទ្ទេសក៍ម៉ែត្រ.

តារាងទី 7. ឧទាហរណ៍នៃការប្រើប្រាស់ MicroProfile Metrics APIs ។

លក្ខណៈ​ពិសេស MicroProfile Metrics
បរិយាយ
ឧទហរណ៍

@ រាប់

តំណាង​អ្នក​រាប់​រាប់​ចំនួន​ដង​ដែល​វត្ថុ​ចំណារ​មួយ​ត្រូវ​បាន​ហៅ

@Counted(name = "fallbackCounter", 
  displayName = "Fallback Counter", 
  description = "Fallback Counter")
public String salutationFallback() {
   return fallbackSalutation;
}

@ConcurrentGauge

តំណាង​ឱ្យ​រង្វាស់​ដែល​រាប់​ចំនួន​នៃ​ការ​ហៅ​ស្រប​គ្នា​ទៅ​កាន់​វត្ថុ​ដែល​បាន​កត់​សម្គាល់

@ConcurrentGuage(
  name = "fallbackConcurrentGauge", 
  displayName="Fallback Concurrent", 
  description="Fallback Concurrent")
public String salutationFallback() {
   return fallbackSalutation;
}

@ រង្វាស់

សម្គាល់ឧបករណ៍ចាប់សញ្ញារង្វាស់ដែលវាស់តម្លៃនៃវត្ថុដែលបានកំណត់ចំណាំ

@Metered(name = "FallbackGauge",
   displayName="Fallback Gauge",
   description="Fallback frequency")
public String salutationFallback() {
   return fallbackSalutation;
}

@ម៉ែត្រ

សម្គាល់ឧបករណ៍ចាប់សញ្ញាម៉ែត្រដែលត្រួតពិនិត្យប្រេកង់ហៅទូរសព្ទរបស់វត្ថុដែលបានកំណត់ចំណាំ

@Metered(name = "MeteredFallback",
   displayName="Metered Fallback",
   description="Fallback frequency")
public String salutationFallback() {
   return fallbackSalutation;
}

កាល

ចំណារពន្យល់ដែលមានព័ត៌មានអំពីទិន្នន័យមេតា នៅពេលសំណើត្រូវបានទទួលដើម្បីបញ្ចូល ឬផលិតម៉ែត្រ

@Metric
@Metered(name = "MeteredFallback",
   displayName="Metered Fallback",
   description="Fallback frequency")
public String salutationFallback() {
   return fallbackSalutation;
}

កំណត់ពេល

ចង្អុលបង្ហាញកម្មវិធីកំណត់ម៉ោងដែលតាមដានរយៈពេលនៃវត្ថុដែលបានកំណត់ចំណាំ

@Timed(name = "TimedFallback",
   displayName="Timed Fallback",
   description="Fallback delay")
public String salutationFallback() {
   return fallbackSalutation;
}

ចំណុចបញ្ចប់នៃម៉ែត្រ

រង្វាស់នៃការដាក់ពាក្យ localhost៖ 8080/ម៉ែត្រ/កម្មវិធី
រង្វាស់មូលដ្ឋាន localhost៖ 8080/ម៉ែត្រ/មូលដ្ឋាន
រង្វាស់នៃអ្នកលក់ localhost៖ 8080/ម៉ែត្រ/អ្នកលក់
រង្វាស់ទាំងអស់។ localhost៖ 8080/ម៉ែត្រ

អតិថិជនសម្រាក MicroProfile

Microservices ជាញឹកញាប់ផ្តល់នូវ RESTful endpoints ដែលត្រូវការ APIs អតិថិជនដែលត្រូវគ្នាដើម្បីធ្វើការជាមួយ។ ដើម្បីប្រើ RESTful endpoints អ្នកអភិវឌ្ឍន៍ Spring ជាធម្មតាប្រើ RestTemplate។ Quarkus ផ្តល់ជូន MicroProfile Rest Client APIs ដើម្បីដោះស្រាយបញ្ហានេះ ឧទាហរណ៍នៃការប្រើប្រាស់ដែលត្រូវបានផ្តល់ឱ្យក្នុងតារាងទី 8 ។

В គម្រោងពីឧទាហរណ៍របស់យើង។ ការប្រើប្រាស់ RESTful endpoints ត្រូវបានធ្វើដោយប្រើ MicroProfile Rest Client ។ ព័ត៌មានបន្ថែម និងឧទាហរណ៍លើប្រធានបទនេះអាចត្រូវបានរកឃើញនៅក្នុងសៀវភៅណែនាំ Quarkus ការណែនាំអតិថិជនសម្រាក.

តារាងទី 8. ឧទាហរណ៍នៃការប្រើប្រាស់ MicroProfile Rest Client APIs ។

លក្ខណៈពិសេសរបស់អតិថិជនសម្រាក MicroProfile
បរិយាយ
ឧទហរណ៍

@RegisterRestClient

ចុះឈ្មោះចំណុចប្រទាក់ Java ដែលបានវាយបញ្ចូលជាម៉ាស៊ីនភ្ញៀវ REST

@RegisterRestClient
@Path("/")
public interface MyRestClient {
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String getSalutation();
}

@RestClient

សម្គាល់ការអនុវត្តនៃចំណុចប្រទាក់ម៉ាស៊ីនភ្ញៀវ REST ដែលបានវាយបញ្ចូល

@Autowired // or @Inject
@RestClient
MyRestClient restClient;

ការហៅ

ហៅទៅចំណុចបញ្ចប់ REST

System.out.println(
   restClient.getSalutation());

mp-rest/url

បញ្ជាក់​ចំណុច​បញ្ចប់ REST

application.properties:
org.example.MyRestClient/mp-rest/url=
   http://localhost:8081/myendpoint

លទ្ធផល

នៅក្នុងប្លក់នេះដែលមានគោលបំណងជាចម្បងទៅលើអ្នកអភិវឌ្ឍន៍ Spring យើងបានមើលយ៉ាងរហ័សអំពីរបៀបប្រើ Spring APIs ជាមួយ MicroProfile APIs ក្នុង Quarkus ដើម្បីបង្កើត microservices Java ហើយបន្ទាប់មកចងក្រងវាទៅជាកូដគោលពីរដើមដែលរក្សាទុក RAM រាប់រយមេហ្គាបៃ ហើយចាប់ផ្តើមនៅក្នុង បញ្ហានៃមីលីវិនាទី។

ដូចដែលអ្នកបានយល់រួចហើយ ព័ត៌មានបន្ថែមអំពីការគាំទ្រសម្រាប់ Spring និង MicroProfile APIs ក៏ដូចជាព័ត៌មានមានប្រយោជន៍ជាច្រើនទៀតអាចត្រូវបានរកឃើញនៅក្នុង សៀវភៅណែនាំ Quarkus.

ប្រភព: www.habr.com