streamalism.org

1. הקדמה

לשאילתות פשוטות, קל להסיק מה צריכה להיות השאילתה רק על ידי התבוננות בשם השיטה המתאים בקוד שלנו.

במדריך זה נחקור כיצד Spring Data JPA ממנף את הרעיון הזה בצורה של מוסכמת למתן שיטות.

2. מבנה של שיטות שאילתות נגזרות באביב

שמות שיטות נגזרים כוללים שני חלקים עיקריים המופרדים על ידי הראשון על ידי מילת מפתח:

רשימה findByName (שם מחרוזת)

החלק הראשון - כמו למצוא - האם ה מציג והשאר - כמו לפי שם - האם ה קריטריונים.

Spring Data JPA תומך למצוא, לקרוא, לשאול, לספור ו לקבל. כך, למשל, יכולנו לעשות זאת queryByName ו- Spring Data היו מתנהגים כך.

אנחנו יכולים גם להשתמש מובחנים, ראשונים, אוֹ חלק עליון כדי להסיר כפילויות או להגביל את קבוצת התוצאות שלנו:

רשימה findTop3ByAge ()

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

3. יישום לדוגמא

ראשית, נצטרך, כמובן, יישום באמצעות Spring Data JPA.

ביישום זה, נגדיר מחלקת ישויות:

@Table (name = "משתמשים") @ כיתת משתמש משתמש {@ Id @ GeneratedValue מזהה פרטי שלם; שם מחרוזת פרטי; גיל שלם פרטי; פרטי ZonedDateTime birthDate; פעיל בוליאני פעיל; // סטרים וקובעים סטנדרטיים}

ובואו נגדיר גם מאגר. זה יתארך מאגר Jpa, אחד מסוגי מאגר הנתונים של Spring:

ממשק UserRepository מרחיב את JpaRepository {}

זה המקום בו נמקם את כל שיטות השאילתה הנגזרות שלנו.

4. מילות מפתח במצב שוויון

שוויון מדויק הוא אחד התנאים הנפוצים ביותר בשאילתות. יש לנו כמה אפשרויות להביע = או מפעילי IS בשאילתה.

אנו יכולים פשוט להוסיף את שם הנכס ללא כל מילת מפתח כדי לקבל תנאי התאמה מדויק:

רשימה findByName (שם מחרוזת);

ואנחנו יכולים להוסיף האם אוֹ שווים לקריאות:

רשימה findByNameIs (שם מחרוזת); רשימה findByNameEquals (שם מחרוזת);

יכולת קריאה נוספת זו שימושית כשאנחנו צריכים להביע אי שוויון במקום:

רשימה findByNameIsNot (שם מחרוזת);

זה לא מעט קריא יותר מ findByNameNot (מחרוזת)!

כפי ש ריק שוויון הוא מקרה מיוחד, אנחנו לא צריכים להשתמש במפעיל =. Spring Data JPA מטפל ריק פרמטרים כברירת מחדל. אז כשאנחנו עוברים א ריק ערך לתנאי שוויון, Spring מפרש את השאילתה כ- NULL ב- SQL שנוצר.

אנחנו יכולים גם להשתמש ב- IsNull מילת מפתח להוספת שאילתות IS NULL לשאילתה:

רשימה findByNameIsNull (); רשימה findByNameIsNotNull ();

שים לב לכך, גם לא IsNull ולא IsNotNull דורש טיעון שיטה.

ישנן גם שתי מילות מפתח נוספות שאינן דורשות ויכוחים. אנחנו יכולים להשתמש נָכוֹן ו שֶׁקֶר מילות מפתח להוסיף תנאי שוויון בוליאני סוגים:

רשימה findByActiveTrue (); רשימה findByActiveFalse ();

כמובן שלפעמים אנחנו רוצים משהו קל יותר משוויון מדויק, בואו נראה מה עוד אנחנו יכולים לעשות.

5. מילות מפתח במצב דמיון

כשאנחנו צריכים לשאול על התוצאות עם תבנית של מאפיין, יש לנו כמה אפשרויות.

אנו יכולים למצוא שמות שמתחילים בערך באמצעות מתחיל עם:

רשימה findByNameStartingWith (קידומת מחרוזת);

בערך, זה מתורגם ל "איפה שֵׁם כמו 'ערך%'“.

אם אנחנו רוצים שמות שמסתיימים בערך, אז מסתיים עם זה מה שאנחנו רוצים:

רשימה findByNameEndingWith (סיומת מחרוזת);

לחלופין, אנו יכולים למצוא עם אילו שמות מכילים ערך מֵכִיל:

רשימה findByNameContaining (טקסט מחרוזת);

שים לב שכל התנאים שלמעלה נקראים ביטויים מוגדרים מראש. כך, אנחנו לא צריכים להוסיף % מפעיל בתוך הוויכוח כאשר קוראים לשיטות אלה.

אבל, נניח שאנחנו עושים משהו מורכב יותר. נגיד שאנחנו צריכים להביא את המשתמשים ששמם מתחיל ב- א, להכיל ב, ולסיים עם ג.

לשם כך, אנו יכולים להוסיף LIKE משלנו עם ה- כמו מילת מפתח:

רשימה findByNameLike (מחרוזת כמו דפוס);

ואז נוכל למסור את דפוס ה- LIKE שלנו כשאנחנו קוראים לשיטה:

מחרוזת likePattern = "a% b% c"; userRepository.findByNameLike (likePattern);

זה מספיק לגבי שמות לעת עתה. בואו ננסה כמה ערכים אחרים ב מִשׁתַמֵשׁ.

6. מילות מפתח במצב השוואה

יתר על כן, אנו יכולים להשתמש פחות מ ו LessThanEqual מילות מפתח להשוואת הרשומות עם הערך הנתון באמצעות < ו <= מפעילים:

רשימה findByAgeLessThan (גיל שלם); רשימה findByAgeLessThanEqual (גיל שלם);

מצד שני, במצב הפוך, אנו יכולים להשתמש גדול מ ו GreaterThanEqual מילות מפתח:

רשימה findByAgeGreaterThan (גיל שלם); רשימה findByAgeGreaterThanEqual (גיל שלם);

לחלופין, אנו יכולים למצוא משתמשים בגילאים בין שני גילאים בֵּין:

רשימה findByAgeBetween (Integer startAge, Integer endAge);

אנו יכולים גם לספק אוסף של גילאים שתואמים לשימוש ב:

רשימה findByAgeIn (גילאי האוסף);

מכיוון שאנו מכירים את תאריכי הלידה של המשתמשים, ייתכן שנרצה לחפש משתמשים שנולדו לפני תאריך מסוים או אחריו. היינו משתמשים לפני ו לאחר בשביל זה:

רשימה findByBirthDateAfter (ZonedDateTime birthDate); רשימה findByBirthDateBefore (ZonedDateTime birthDate);

7. ביטויים מרובים של תנאים

אנחנו יכולים לשלב כמה ביטויים שאנחנו צריכים באמצעות שימוש וגם ו אוֹ מילות מפתח:

רשימה findByNameOrBirthDate (שם מחרוזת, ZonedDateTime birthDate); רשימה findByNameOrBirthDateAndActive (שם מחרוזת, ZonedDateTime birthDate, בוליאני פעיל);

סדר הקדימות הוא וגם לאחר מכן אוֹ, ממש כמו Java.

בעוד ש- Spring Data JPA לא מגביל כמה ביטויים שנוכל להוסיף, אנחנו לא צריכים להשתגע כאן. שמות ארוכים אינם ניתנים לקריאה וקשה לתחזוקה. לשאלות מורכבות, עיין ב ה @שאילתא ביאור במקום זאת.

8. מיון התוצאות

הבא הוא מיון. נוכל לבקש שהמשתמשים ימוינו לפי אלפבית לפי שמם באמצעות מיין לפי:

רשימה findByNameOrderByName (שם מחרוזת); רשימה findByNameOrderByNameAsc (שם מחרוזת);

סדר עולה הוא אפשרות המיון המוגדרת כברירת מחדל, אך אנו יכולים להשתמש בה Desc במקום למיין אותם הפוך:

רשימה findByNameOrderByNameDesc (שם מחרוזת);

9. findOne לעומת findById ב מאגר Crud

צוות האביב עשה כמה שינויים גדולים מאגר Crud עם מגף אביב 2.x. אחד מהם הוא שינוי שם findOne ל findById.

בעבר עם Spring Boot 1.x היינו מתקשרים findOne כשרצינו לאחזר ישות לפי המפתח הראשי שלה:

משתמש משתמש = userRepository.findOne (1);

מאז Spring Boot 2.x אנחנו יכולים לעשות את אותו הדבר גם עם findById:

משתמש משתמש = userRepository.findById (1);

שים לב שה- findById () השיטה כבר מוגדרת ב מאגר Crud בשבילנו. אז אנחנו לא צריכים להגדיר את זה במפורש במאגרים מותאמים אישית המרחיבים מאגר Crud.

10. מסקנה

במאמר זה הסברנו על מנגנון גזירת השאילתות ב- Spring Data JPA. השתמשנו במילות המפתח של תנאי המאפיין כדי לכתוב שיטות שאילתה נגזרות במאגרי Spring Data JPA.

קוד המקור של הדרכה זו זמין בפרויקט Github.