האם אי פעם תהיתם אם יש דרך טובה יותר למשוך נתונים עבור האפליקציות שלכם מאשר REST APIs? בפיתוח צד השרת, GraphQL הפך להיות חלופה חזקה, המציעה גישה גמישה ויעילה יותר למשיכת נתונים. עבור מפתחים המוכרים את Java, שילוב GraphQL ב-backend מודרני פותח דלת ל-APIs בקנה מידה גבוה וביצועים גבוהים המותאמים למגוון רחב של מקרים שימוש.
בלוג זה יחקור את ההבדלים המרכזיים בין GraphQL ל-REST, ידגיש את היתרונות הייחודיים של השימוש ב-GraphQL למשיכת נתונים, וינחה אתכם כיצד ליישם GraphQL API ב-Java עם דוגמה מהעולם האמיתי.
מה זה GraphQL?
GraphQL היא שפת שאילתות עבור APIs וריצה לה执行 את השאילתות הללו. בניגוד ל-REST, שבו נקודות קצה קבועות מחזירות נתונים מוגדרים מראש, GraphQL מאפשר ללקוחות לבקש בדיוק את הנתונים שהם צריכים. רמת הפירוט הזו עושה את GraphQL ליעיל במיוחד, במיוחד עבור אפליקציות מורכבות או עתירות נתונים.
יתרונות גישת GraphQL:
- משיכת נתונים מפורטת: הלקוח יכול לשאול רק את השם והתפקיד מבלי למשוך שדות מיותרים כמו מחלקה.
- שאילתות מקוננות: משוך את פרטי המנהל יחד עם מידע על העובד בשאילתה אחת.
- פיתוח מונחה סכימה: הסכימה פועלת כחוזה, מה שמקל על אבולוציה של ה-API.
מה זה REST API?
Representational State Transfer (REST) היא סגנון ארכיטקטורה לבניית APIים. היא משתמשת בשיטות סטנדרטיות של HTTP כמו GET, POST, PUT, ו-DELETE כדי לבצע פעולות CRUD. REST מכונה על פשטותה וקיבוץ רחב.
המגבלות של REST:
- על-פרק או תת-פרק של נתונים.
- דורשת רבים נקודות קצה וגרסאות כדי להתאים לשינויים.
- אין יכולות מובנות בזמן אמת.
GraphQL vs. REST API: מה ההבדל?
GraphQL ו-REST הן שתי גישות פופולריות לבניית APIים, כל אחת עם נקודות חוזק משלה. בעוד ש-REST הייתה התקן לשנים רבות, GraphQL מציעה גמישות ויעילות יותר, במיוחד באחזור נתונים ובשיתוף פעולה בין צוותי הפרונט-אנד והבק-אנד.
ההבדלים המרכזיים
- בשוני מ-REST, שמשתמשת ברבות נקודות קצה ודורשת גרסאות לשינויים, GraphQL מקושרת אחזור נתונים לשאילתה יחידה ומפחיתה את הצורך בגרסאות מאחר שלקוחות צורפים דרישות נתונים.
- בעוד ש-REST משתמשת בקודי מצב HTTP כדי לציין הצלחה או שגיאות, GraphQL תמיד מחזירה קוד 200 OK ומעבירה שגיאות בגוף המענה.
- GraphQL גם תומכת בעדכונים בזמן אמת דרך מינויים, להבדל מ-REST שחסרת תמיכה מובנית בזמן אמת.
- למרות ש-REST מקובל באופן נרחב עם כלי רבים, הסביבה של GraphQL צמחה במהירות, ומציעה כלים רבי עוצמה כמו GraphiQL לפיתוח קל יותר.
- לבסוף, בעוד ש-REST משתמש בכותרות לאחסון מטמון, GraphQL דורש טכניקות מתקדמות יותר בשל שאילתות דינמיות אך מציע אפשרויות כמו שאילתות מתמשכות לאחסון מטמון יעיל.
מונחים מרכזיים ב-GraphQL
1. שפת הגדרת סכימה (SDL)
ל-GraphQL יש מערכת סוגים משלה שמשמשת להגדרת הסכימה של API. הסינטקס לכתיבת סכימות נקרא שפת הגדרת סכימה (SDL).
2. שאילתות מול שינויים מול מנויים
- שאילתות משמשות לשליפת נתונים מהשרת. בניגוד ל-REST, שמשתמש בנקודות קצה קבועות מרובות, GraphQL משתמש בנקודת קצה אחת, והלקוח מפרט את הנתונים הנדרשים בשאילתה, מה שמציע גמישות.
- שינויים משמשים לשינוי נתונים על השרת, כמו יצירה, עדכון או מחיקת נתונים. הם מאפשרים ללקוחות לשלוח שינויים לשרת האחורי והם חיוניים ליישומים שצריכים לכתוב נתונים.
- מנויים מאפשרים עדכונים בזמן אמת על ידי שמירה על חיבור יציב בין הלקוח לשרת. כאשר מתרחשת אירוע המנוי, השרת דוחף עדכונים ללקוח, ומספק זרמי נתונים רציפים, בניגוד לשאילתות ולשינויים, שעוקבות אחרי מחזור בקשה-תגובה.
3. סכימת GraphQL
זה מגדיר את מבנה הנתונים שניתן לשאול או לשנות, פועל כחוזה בין השרת ללקוח. זה מפרט את סוגי הנתונים, השדות והקשרים הזמינים ללקוחות לגישה. הסכמה כוללת כללים שורש מיוחדים: שאילתה לאיחזור נתונים, מוטציה לשינוי נתונים, ומינוי לעדכונים בזמן אמת. סוגי אלה מגדירים ביחד את יכולות ה- API ואיך לקוחות יכולים להתקשר איתו.
4. מטפלים: מיפוי שאילתות GraphQL לנתונים
מטפלים הם פונקציות שמטפלות בלוגיקה לאיחוז נתונים בשרת GraphQL. כל שדה בסכמה מקושר למטפל, שקובע איך לאחזר או לחשב את הנתונים לשדה זה. כאשר שאילתה מבוצעת, השרת מפעיל את המטפלים המתאימים לשדות שביקשו. מטפלים יכולים להחזיר סקלרים או אובייקטים, עם הרצת הביצוע ממשיכה לשדות ילד אם אובייקט מוחזר וסיום אם סקלר מוחזר. אם נמצא שהוחזר ערך ריק, הביצוע מפסיק. מטפלים הם חיוניים למיפוי שאילתות GraphQL למקורות הנתונים האמיתיים.
יתרונות של שימוש ב- GraphQL ב-Java
- איחזור נתונים מדויק: שאילת רק את הנתונים שאתה צריך, ולא יותר, מבטיח תוצאות צפויות ויעילות.
- בקשת יחידה למקורות מרובים: איחוז נתונים קשורים בשאילתה אחת, ממתן שיחות API מרובות.
- מערכת סוגים: מארגנת APIs לפי סוגים ושדות, מבטיחה ששאילות חוקיות ושגיאות ברורות.
- כלי פיתוח: משפר יעילות עם כלים כמו GraphiQL, שמשתמשים בהגדרות סוג לבניית שאילתות טובה יותר ותיקוני באגים.
- אבולוציה ללא גרסאות: הוספת או הפסקת שדות בלי לשבור שאילתות קיימות, משמרת את קיימות ה- API.
- אינטגרציה גמישה של נתונים: יצירת API אחיד מעל נתונים וקוד קיימים המתאים למנועי אחסון ושפות שונות.
הגדרת API של GraphQL ב-Java
דוגמה ממשיות: משתמשים והזמנות
תיאור הסצנריו: אתה בונה API לספריית עובדים עבור ארגון גדול. המטרה היא לאפשר ללקוחות לשאול פרטים כמו שם העובד, תפקיד, מחלקה ואפילו את היררכיית הדיווחים שלהם.
1. הגדרת הפרויקט
צור פרויקט Spring Boot חדש באמצעות Spring Tool Suite או על ידי מעבר ל- Spring Initialiser. לאחר מכן, הוסף את התלות הבאות לקובץ pom.xml:
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-graphql</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webflux</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.graphql</groupId>
<artifactId>spring-graphql-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
2. יצירת הישויות שלך
צור ישויות Java (לדוגמה, User ו- Order) כדי לייצג את הנתונים שיש לשאול או לשנות דרך GraphQL. לדוגמה:
public class User {
(strategy = GenerationType.IDENTITY)
private Long userId;
private String name;
private String email;
private String password;
// Getters and setters...
}
public class Order {
(strategy = GenerationType.IDENTITY)
private Long orderId;
private String orderDetails;
private String address;
private int price;
private User user;
// Getters and setters...
}
3. יצירת מאגרים
צור מאגרים לפעול עם בסיס הנתונים:
public interface UserRepository extends JpaRepository<User, Long> {}
public interface OrderRepository extends JpaRepository<Order, Long> {}
4. יצירת מחלקות שירות
צור מחלקות שירות לטיפול בלוגיקת עסקית:
public class UserService {
private final UserRepository userRepository;
public UserService(UserRepository userRepository) {
this.userRepository = userRepository;
}
public User createUser(User user) {
return userRepository.save(user);
}
public User getUser(Long userId) {
return userRepository.findById(userId).orElseThrow(() -> new RuntimeException("User not found"));
}
public List<User> getAllUsers() {
return userRepository.findAll();
}
public boolean deleteUser(Long userId) {
userRepository.deleteById(userId);
return true;
}
}
5. צור בקרי GraphQL
הגדר בקרי GraphQL לטיפול בשאילתות ומוטציות:
public class UserController {
private final UserService userService;
public UserController(UserService userService) {
this.userService = userService;
}
public List<User> getUsers() {
return userService.getAllUsers();
}
public User getUser( Long userId) {
return userService.getUser(userId);
}
public User createUser( String name, String email, String password) {
User user = new User();
user.setName(name);
user.setEmail(email);
user.setPassword(password);
return userService.createUser(user);
}
public boolean deleteUser( Long userId) {
return userService.deleteUser(userId);
}
}
6. הגדר את סכמת ה-GraphQL שלך
צור קובץ schema.graphqls בתיקיית src/main/resources:
type User {
userId: ID!
name: String
email: String
password: String
}
type Query {
getUsers: [User]
getUser(userId: ID!): User
}
type Mutation {
createUser(name: String, email: String, password: String): User
deleteUser(userId: ID!): Boolean
}
7. הגדר את GraphQL ב- application.properties
אופציונלית, הגדר הגדרות GraphQL ב- scr/main/resources/application.properties:
spring.graphql.graphiql.enabled=true
8. הרץ את האפליקציה שלך
הרץ את אפליקציית SpringBoot באמצעות mvn spring-boot:run או מה-IDE שלך. פעם שהאפליקציה רצה, תוכל לגשת לנקודת הכניסה של GraphAL בכתובת /graphiql.
9. בדוק בעזרת שאילתות GraphQL
בדוק את ה-API של GraphQL בעזרת כלי כמו GraphiQL או Postman.
למוטציה:
mutation {
createUser(
name:"swetha",
email:"[email protected]",
password:"23sde4dfg43"
){
name,
userId
}
}
פלט:
{
"data": {
"createUser": {
"name": "swetha",
"userId": "3"
}
}
}
לשאילתה:
query{
getUsers{
name
}
}
פלט:
{
"data": {
"getUsers": [
{
"name": "Medha"
},
{
"name": "Riya"
},
{
"name": "swetha"
}
]
}
}
תכונות מתקדמות של GraphQL
1. שיפור השימושיות עם פרגמנטים
פרגמנט הוא בסיסית סט של שדות שניתן להשתמש בהם לסוג מסוים. זהו יכולת שעוזרת לשפר את מבנה ואת היכולת לשימוש של קוד ה-GraphQL שלך.
2. פרמטריזציה של שדות עם ארגומנטים
ב-GraphQL, שדות יכולים לקבל ארגומנטים כדי להפוך את השאילתות לדינמיות וגמישות יותר. ארגומנטים אלו מאפשרים לך לסנן או להתאים את הנתונים המוחזרים מה-API.
3. עימוד ומיון עם GraphQL
עימוד
עימוד הוא נושא מורכב בעיצוב API. ברמה גבוהה, ישנן שתי גישות עיקריות כיצד ניתן להתמודד עם זה.
- מגבלה-סטייה: בקש קטע ספציפי של הרשימה על ידי מתן האינדקסים של הפריטים שברצונך לשחזר (בעצם, אתה בעיקר מספק את האינדקס ההתחלתי (סטייה) כמו גם את מספר הפריטים שברצונך לשחזר (מגבלה)).
- מבוסס קורסור: מודל העימוד הזה הוא קצת יותר מתקדם. כל אלמנט ברשימה משויך למזהה ייחודי (הקורסור). לקוחות המעמדים דרך הרשימה מספקים לאחר מכן את הקורסור של האלמנט ההתחלתי כמו גם את מספר הפריטים שברצונך לשחזר.
מיון
עם עיצוב API של GraphQL, אפשר להחזיר רשימות של אלמנטים הממוינים (ממוקד) בהתאם לקריטריונים ספציפיים.
אתגרים ושיקולים בשימוש ב-GraphQL
- מורכבות: ניהול סכמות ושאילתות של GraphQL יכול להיות אתגרי עבור מודלים פשוטים או צוותים חסרי ניסיון.
- בעיות ביצועים: שאילתות מקוננות לעמק עשויות להעמיס על משאבי ה-backend אם לא אופטימליות.
- אתגרים בזיכרון מטמון: אסטרטגיות זיכרון מטמון מבוססות REST סטנדרטיות אינן חלות ודורשות פתרונות מותאמים אישית.
- חששות אבטחה: קבלת נתונים מיותרת ושאילתות זדוניות מחייבות מגבלות על שאילתות ואמצעי הגנה אחרים.
- שימוש היברידי: מתאים ביותר לצרכי נתונים מורכבים, לעיתים בשילוב עם REST לפעולות פשוטות יותר.
סיכום
GraphQL מציע גישה גמישה ויעילה לבניית APIs מודרניים ב-Java, מה שהופך אותו לבחירה אידיאלית עבור יישומים דינמיים ועתירי נתונים. הארכיטקטורה החד-נקודתית שלו וההקלדה החזקה מפשטים את עיצוב ה-API תוך הבטחת ביצועים חזקים. בין אם אתה יוצר מדריך עובדים פשוט או פלטפורמת אנליטיקה מורכבת, GraphQL מאפשר למפתחים לספק פתרונות ניתנים להרחבה בקלות. התחילו לחקור את GraphQL היום עם כלים כמו Spring Boot ו-graphql-java כדי לנעול את מלוא הפוטנציאל שלו בפרויקט הבא שלכם.
קוד מקור
אתה יכול למצוא את קוד המקור המלא של מדריך זה ב-Github.
Source:
https://dzone.com/articles/design-scalable-java-apis-with-graphql