איך Quarkus משלב MicroProfile ו-Spring

שלום לכולם, הנה הפוסט השלישי בסדרת Quarkus!

כאשר מפתחים שירותי מיקרו של Java, מאמינים כי Eclipse MicroProfile и מגף אביב הם ממשקי API נפרדים ועצמאיים. כברירת מחדל, מתכנתים נוטים להשתמש בממשקי ה-API שהם כבר רגילים אליהם, שכן לימוד מסגרות חדשות ורכיבי זמן ריצה לוקח הרבה זמן. היום ננסה לפשט את הפיתוח של כמה פופולרי MicroProfile API למפתחי Spring ולהראות לך כיצד להשתמש בו-זמנית ב-Spring API ובתכונות שימושיות חדשות קוורקוס.

בפירוט קטן יותר, תחילה נבחן את ההיקף והפרטים של האופן שבו Quarkus תומך בממשקי API של Spring כדי להראות למפתחי Spring כיצד להשתמש ב-MicroProfile API בעבודה היומיומית שלהם. לאחר מכן נסקור את ממשקי ה-API של MicroProfile, שימושיים עבור מפתחי Spring בעת יצירת מיקרו-שירותים.

למה קווקוס? ראשית, זהו קידוד חי, כלומר, טעינה מחדש אוטומטית של כל שינוי ב-MicroProfile API, Spring API וממשקי API אחרים של Java, שמתבצעת בפקודה אחת בלבד: mvn quarkus:dev. שנית, נחשב ב בדוגמה שלנו שירות Person (הקומפילציה מממשקי API של Spring, MicroProfile ו-JPA לבינארי באמצעות תמונת GraalVM המקורית) מתחיל תוך 0.055 שניות בלבד ותופס כ-90 MB של זיכרון RAM (RSS) בנקודת הקצה של היישום RESTful. יתרה מכך, הקומפילציה שלו עצמה מתבצעת בפקודה אחת בלבד: חבילת mvn -Pnative.

לא נפרט על MicroProfile, מלבד לעזור למפתחי Spring להבין כיצד הם יכולים להשתמש בממשקי Spring API עם ממשקי API של MicroProfile ב-Quarkus.

מכולות ו-Kubernetes

כדי לשמור על מאמר זה פשוט, נסקור כאן רק את ההיבטים הגבוהים של תמיכה. קוברנט, כי חשוב להבין. Quarkus ממוקמת כמחסנית Java עבור Kubernetes, היא נועדה למזער את צריכת הזיכרון ואת זמן האתחול של יישומי ושירותי Java, וכתוצאה מכך להגדיל את הצפיפות שלהם במארח ולהפחית את העלויות הכוללות.

גם קווקוס תומך בייצור אוטומטי משאבים והצעות של Kubernetes מַנהִיגוּת לפריסה בפלטפורמות Kubernetes ו-Red Hat OpenShift. בנוסף, Quarkus מייצר אוטומטית את הקבצים Dockerfile.jvm (אריזה JVM) ו- Dockerfile.native (אריזה בינארית מקורית) הדרושים ליצירת קונטיינרים.

לבסוף, על ידי התמקדות ב-Kubernetes כסביבת פריסת היעד, Quarkus אינו משתמש במסגרות Java במקרים בהם מיושמת פונקציונליות דומה ברמת פלטפורמת Kubernetes עצמה. טבלה 1 מספקת מפה של ההתאמה הפונקציונלית בין Kubernetes לבין מסגרות Java טיפוסיות המשמשות מפתחי Spring.

טבלה 1. מפה של התאמה פונקציונלית בין מסגרות Java ו-Kubernetes.

פונקציונלי
מגף אביב מסורתי
קוברנט

גילוי שירות
יוריקה
DNS

תְצוּרָה
תצורת ענן אביב
הגדרת מפות/סודות

איזון עומסים
סרט (צד הלקוח)
שירות, בקר שכפול (צד השרת)

קומפילציה והרצה של הקוד מהדוגמה

במאמר זה אנו מתייחסים פרויקט לדוגמה, שבו משתמשים בממשקי ה-API של Spring ו-MicroProfile ואפילו באותה מחלקת Java ביחד. הקוד בדוגמה זו ניתן להידור ולהפעיל משורת הפקודה, עיין בקובץ README.md לפרטים.

ממשקי API של Spring Framework

הזרקת תלות

Quarkus תומך במגוון של ממשקי API של הקשרים והזרקת תלות (CDI). ו-Spring Dependency Injection (Spring DI) APIs. אם אתה עובד עם MicroProfile, Java EE וג'קרטה EE, אז אתה כבר מכיר היטב את CDI. מצד שני, מפתחי Spring יכולים להשתמש ב-Quarkus Extension for Spring DI API כדי להשיג תאימות עם Spring DI. דוגמאות לשימוש בממשקי ה-API של Spring DI נתמכים בטבלה 2.

В פרויקט מהדוגמה שלנו משתמש גם ב-CDI וגם בהזרקת קפיצים. למידע נוסף ודוגמאות בנושא זה, עיין במדריך Quarkus הנקרא מדריך אביב DI.

טבלה 2. דוגמאות לשימוש בממשקי API נתמכים של Spring DI.

תכונות 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. בדומה ל-Spring DI, המטרה העיקרית של תמיכת Spring Web API היא לאפשר למפתחי Spring להשתמש בממשקי Spring Web בשילוב עם ממשקי API של MicroProfile. דוגמאות לשימוש בממשקי ה-API הנתמכים של Spring Web מסופקות בטבלה 3, וניתן למצוא מידע ודוגמאות נוספות בנושא זה במדריך של Quarkus הנקרא מדריך אינטרנט של אביב.

טבלה 3. דוגמאות לשימוש ב-Spring Web APIs הנתמכים.

תכונות אינטרנט נתמכות של אביב
דוגמאות

@ RestController
@בקשת מיפוי

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

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@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 באמצעות ORM Hibernate. יש גם חדשות טובות למפתחי Spring: Quarkus תומך בהערות ובסוגים נפוצים של Spring Data JPA. דוגמאות לשימוש בממשקי API של Spring Data JPA נתמכים בטבלה 4.
В פרויקט מהדוגמה שלנו נעשה שימוש בממשקי API של Spring Data JPA ומידע נוסף זמין במדריך Quarkus שנקרא Spring Data JPA Guide.

טבלה 4. דוגמאות לשימוש בממשקי API נתמכים של Spring Data JPA.

תכונות Spring Data JPA נתמכות
דוגמאות

CrudRository

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

Repository
מאגר Jpa
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);
}

ממשקי API של MicroProfile

סובלנות לתקלות

מבנים לסובלנות תקלות חשובים מאוד למניעת כשלים מדורגים וליצירת ארכיטקטורות מיקרו-שירות אמינות. מפתחי קפיצים משתמשים במפסקים לסבילות תקלות כבר שנים רבות. היסטריקס. עם זאת, Hystrix לא עודכנה במשך זמן רב, אך ה-Fault Tolerance של MicroProfile מתפתחת כעת באופן פעיל ומאחוריה מספר שנים של שימוש בייצור. לכן, כדי לשפר את מהימנות השירותים ב-Quarkus, מומלץ להשתמש בממשקי ה-API של MicroProfile Fault Tolerance, שדוגמאות שלהם נמצאות בשימוש בטבלה 5. למידע נוסף על כך, עיין במדריך של Quarkus מדריך סובלנות תקלות.

טבלה 5. דוגמאות לשימוש בממשקי API נתמכים של MicroProfile Fault Tolerance.

תכונות סובלנות תקלות של MicroProfile
תיאור
דוגמאות

@אסינכרוני

ביצוע היגיון בשרשור נפרד

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

@מחיצה

הגבל את מספר הבקשות בו-זמנית

@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(); //...
}

שירותי בדיקה (שירות בריאות)

פלטפורמות Kubernetes עוקבות אחר תקינות המכולות באמצעות שירותים מיוחדים. כדי לאפשר לפלטפורמה הבסיסית לנטר שירותים, מפתחי Spring משתמשים בדרך כלל ב-HealthIndicator מותאם אישית וב-Spring Boot Actuator. ב-Quarkus, ניתן לעשות זאת באמצעות MicroProfile Health, אשר כברירת מחדל מבצעת בדיקת חיוניות, אך ניתן להגדיר זאת כך שתבדוק בו-זמנית את הפעילות והמוכנות. דוגמאות לשימוש בממשקי ה-API הנתמכים של MicroProfile Health מסופקות בטבלה 6, ומידע נוסף מסופק במדריך של Quarkus מדריך בריאות.

טבלה 6: דוגמאות לשימוש בממשקי API נתמכים של MicroProfile Health.

תכונות MicroProfile Health
תיאור
דוגמאות

@חיות

אתחול מחדש של הפלטפורמה נכשל יישומי מכולות
נקודת סיום:
מארח:8080/health/live

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

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

@נְכוֹנוּת

הפלטפורמה לא תשלח תעבורה ליישומים המכילים אם היא לא מוכנה
נקודת סיום:
מארח:8080/health/ready

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

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

מדדים

יישומים מספקים מדדים למטרות תפעוליות (כדי לפקח על SLAs ביצועים) או למטרות לא תפעוליות (SLAs עסקיות). מפתחי Spring מספקים מדדים באמצעות Spring Boot Actuator ומיקרומטר. בתורו, Quarkus משתמש ב-MicroProfile Metrics כדי לספק מדדי בסיס (JVM ומערכת הפעלה), מדדי ספקים (Quarkus) ומדדי יישומים. MicroProfile Metrics דורש שהיישום תומך בתבניות פלט של JSON ו-OpenMetrics (Prometheus). דוגמאות לשימוש ב-MicroProfile Metrics API ניתנות בטבלה 7.

В פרויקט מהדוגמה שלנו מדדי MicroProfile משמשים כדי לספק מדדי יישומים. למידע נוסף, עיין במדריך של Quarkus מדריך מדדים.

טבלה 7. דוגמאות לשימוש בממשקי API של MicroProfile Metrics.

תכונות מדדי MicroProfile
תיאור
דוגמאות

@נספור

מציין מונה מונה שסופר את מספר הפעמים שנקרא אובייקט מוער

@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/metrics/base
מדדי ספקים localhost:8080/מטרים/ספק
כל המדדים localhost:8080/מטרים

MicroProfile Rest Client

שירותי מיקרו מספקים לעתים קרובות נקודות קצה RESTful שדורשות ממשקי API תואמים של לקוח לעבוד איתם. כדי להשתמש בנקודות קצה של RESTful, מפתחי Spring משתמשים בדרך כלל ב-RestTemplate. Quarkus מציעה ממשקי API של MicroProfile Rest Client כדי לפתור בעיה זו, ודוגמאות לשימוש בהן ניתנות בטבלה 8.

В פרויקט מהדוגמה שלנו השימוש בנקודות קצה RESTful נעשה באמצעות MicroProfile Rest Client. מידע נוסף ודוגמאות בנושא זה ניתן למצוא במדריך של Quarkus מדריך לקוח מנוחה.

טבלה 8. דוגמאות לשימוש בממשקי API של MicroProfile Rest Client.

תכונות לקוח MicroProfile Rest
תיאור
דוגמאות

@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 API עם ממשקי API של MicroProfile ב-Quarkus כדי לפתח שירותי מיקרו של Java ולאחר מכן לקמפל אותם לקוד בינארי מקורי שחוסך מאות מגה-בייט של זיכרון RAM ומשיק ב- עניין של אלפיות שניות.

כפי שכבר הבנת, מידע נוסף על תמיכה בממשקי ה-Spring ו-MicroProfile, כמו גם מידע שימושי רב אחר, ניתן למצוא ב- מדריכים של Quarkus.

מקור: www.habr.com