הצהרות טענה באביב

1. סקירה כללית

במדריך זה נתמקד ונתאר את מטרת האביב לִטעוֹן בכיתה והדגימו כיצד להשתמש בה.

2. מטרת ה לִטעוֹן מעמד

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

כל אחד לִטעוֹןניתן להשוות את השיטה עם Java לִטעוֹן הַצהָרָה. ג'אווה לִטעוֹן הצהרה זורקת שְׁגִיאָה בזמן ריצה אם מצבו נכשל. העובדה המעניינת היא שניתן להשבית קביעות אלה.

להלן מספר מאפיינים של האביב לִטעוֹןהשיטות:

  • לִטעוֹןהשיטות של סטטיות
  • גם הם זורקים IllegalArgumentException אוֹ IllegalStateException
  • הפרמטר הראשון הוא בדרך כלל טיעון לאימות או תנאי הגיוני לבדיקה
  • הפרמטר האחרון הוא בדרך כלל הודעת חריג המוצגת אם האימות נכשל
  • ניתן להעביר את ההודעה כ- חוּט פרמטר או כ ספק פָּרָמֶטֶר

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

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

בואו נגדיר א אוטו כיתה בשיטה ציבורית נהיגה():

רכב ממעמד ציבורי {פרטי מחרוזת מדינה = "עצור"; כונן בטל ציבורי (מהירות אינט) {Assert.isTrue (מהירות> 0, "המהירות חייבת להיות חיובית"); this.state = "כונן"; // ...}}

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

אם (! (מהירות> 0)) {זרוק IllegalArgumentException ("המהירות חייבת להיות חיובית"); }

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

אם ננסה להתקשר ל נהיגה() שיטה עם טיעון שלילי, IllegalArgumentException יוצא מן הכלל:

חריג בשרשור "ראשי" java.lang.IllegalArgumentException: המהירות חייבת להיות חיובית

4. קביעות לוגיות

4.1. נכון()

קביעה זו נדונה לעיל. זה מקבל א בוליאני מצב וזורק IllegalArgumentException כשהמצב כוזב.

4.2. מדינה()

ה מדינה() לשיטה יש אותה חתימה כמו נכון() אבל זורק את IllegalStateException.

כפי שהשם מרמז, יש להשתמש בה כאשר אסור להמשיך בשיטה בגלל מצב לא חוקי של האובייקט.

תאר לעצמך שאנחנו לא יכולים להתקשר ל דלק() שיטה אם המכונית פועלת. בואו נשתמש ב- מדינה() קביעה במקרה זה:

דלק ריק ריק () {Assert.state (this.state.equals ("עצור"), "יש לעצור מכונית"); // ...}

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

5. אובייקט וסוג אסרטיוns

5.1. לא ריק()

אנו יכולים להניח שאובייקט אינו כזה ריק באמצעות לא ריק() שיטה:

חלל ציבורי сhangeOil (שמן מחרוזת) {Assert.notNull (שמן, "אסור ששמן יהיה ריק"); // ...}

5.2. isNull ()

מצד שני, אנחנו יכולים לבדוק אם אובייקט הוא ריק משתמש ב isNull () שיטה:

חלל ציבורי להחליףBattery (CarBattery carBattery) {Assert.isNull (carBattery.getCharge (), "להחלפת הסוללה הטעינה חייבת להיות אפס"); // ...}

5.3. isInstanceOf ()

כדי לבדוק אם אובייקט הוא מופע של אובייקט אחר מהסוג הספציפי נוכל להשתמש בו isInstanceOf () שיטה:

חלל ציבורי сhangeEngine (מנוע מנוע) {Assert.isInstanceOf (ToyotaEngine.class, engine); // ...}

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

5.4. isAssignable ()

כדי לבדוק סוגים, אנו יכולים להשתמש Assert.is Assignable ():

תיקון חלל ציבורי מנוע (מנוע מנוע) {Assert.isAssignable (Engine.class, ToyotaEngine.class); // ...}

שתי קביעות אחרונות מייצגות הוא מערכת יחסים.

6. קביעות טקסט

טענות טקסט משמשות לביצוע בדיקות חוּט טיעונים.

6.1. hasLength ()

אנחנו יכולים לבדוק אם א חוּט אינו ריק, כלומר הוא מכיל לפחות מרחב לבן אחד, באמצעות hasLength () שיטה:

public void startWithHasLength (מפתח מחרוזת) {Assert.hasLength (מפתח, "המפתח לא יכול להיות ריק ואסור שהוא יהיה ריק"); // ...}

6.2. hasText ()

אנו יכולים לחזק את המצב ולבדוק אם א חוּט מכיל לפחות תו אחד שאינו רווח, באמצעות hasText () שיטה:

public void startWithHasText (Key String) {Assert.hasText (key, "key must be null והוא חייב להכיל לפחות תו אחד שאינו לבן"); // ...}

6.3. לא מכיל()

אנו יכולים לקבוע אם א חוּט הארגומנט אינו מכיל תשתית ספציפית באמצעות ה- לא מכיל() שיטה:

בטל ציבורי startWithNotContain (מפתח מחרוזת) {Assert.doesNotContain (מפתח, "123", "המפתח לא יכול להכיל 123"); // ...}

7. קביעות אוסף ומפות

7.1. לא ריק() לאוספים

כמו שהשם אומר, ה לא ריק() השיטה טוענת כי אוסף אינו ריק כלומר לא ריק ומכיל לפחות אלמנט אחד:

תיקון חלל ציבורי (Collection repairParts) {Assert.notEmpty (repairParts, "אוסף של repairParts לא יכול להיות ריק"); // ...}

7.2. לא ריק() עבור מפות

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

תיקון חלל ציבורי (Map repairParts) {Assert.notEmpty (repairParts, "map of repairParts אסור להיות ריק"); // ...}

8. טענות מערך

8.1. לא ריק() למערכים

לבסוף, אנו יכולים לבדוק אם מערך אינו ריק ומכיל לפחות אלמנט אחד באמצעות ה- לא ריק() שיטה:

תיקון חלל ציבורי (מחרוזת [] repairParts) {Assert.notEmpty (repairParts, "מערך repairParts לא יכול להיות ריק"); // ...}

8.2. noNullElements ()

אנו יכולים לאמת שמערך אינו מכיל ריק אלמנטים באמצעות noNullElements () שיטה:

public void repairWithNoNull (String [] repairParts) {Assert.noNullElements (repairParts, "array of repairParts אסור להכיל אלמנטים null)"; // ...}

שים לב שבדיקה זו עדיין עוברת אם המערך ריק, כל עוד אין ריק אלמנטים בו.

9. מסקנה

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

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