streamalism.org

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

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

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

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

2. שימוש חפץ-חפץ

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

2.1. תלות של Maven

ראשית, נוסיף את האחרונה חפץ-maven תלות Maven שלנו pom.xml:

 org.apache.maven maven-artifact 3.6.3 

2.2. ComparableVersion

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

הוא מכיל א בהשוואה ל השיטה, ותוצאת ההשוואה תהיה גדולה מ- 0 או פחות כאשר גרסה אחת גדולה או פחות מהשנייה, בהתאמה:

ComparableVersion version1_1 = ComparableVersion חדש ("1.1"); ComparableVersion version1_2 = ComparableVersion חדש ("1.2"); ComparableVersion version1_3 = ComparableVersion חדש ("1.3"); assertTrue (version1_1.compareTo (version1_2) 0);

כאן נוכל לאשר שגרסת 1.1 פחותה מגרסת 1.2, וגרסת 1.3 גדולה מגרסת 1.2.

עם זאת, נקבל 0 כתוצאה בהשוואה בין אותן גרסאות:

ComparableVersion version1_1_0 = ComparableVersion חדש ("1.1.0"); assertEquals (0, version1_1.compareTo (version1_1_0));

2.3. מפרידי גרסאות ומוקדמות

בנוסף, ה- ComparableVersion class מכבד את הנקודה (.) ואת המקף (-) כמפרידים, כאשר ה- נקודה מפרידה בין גרסאות עיקריות ומשניות, והמקף מגדיר את המוקדמות:

ComparableVersion version1_1_alpha = ComparableVersion חדש ("1.1-alpha"); assertTrue (version1_1.compareTo (version1_1_alpha)> 0);

כאן נוכל לאשר שגרסת 1.1 גדולה מגרסת 1.1-alpha.

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

ComparableVersion version1_1_beta = ComparableVersion חדש ("1.1-בטא"); ComparableVersion version1_1_milestone = ComparableVersion חדש ("1.1-milestone"); ComparableVersion version1_1_rc = ComparableVersion חדש ("1.1-rc"); ComparableVersion version1_1_snapshot = ComparableVersion חדש ("1.1-snapshot"); assertTrue (version1_1_alpha.compareTo (version1_1_beta) <0); assertTrue (version1_1_beta.compareTo (version1_1_milestone) <0); assertTrue (version1_1_rc.compareTo (version1_1_snapshot) <0); assertTrue (version1_1_snapshot.compareTo (version1_1) <0);

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

ComparableVersion version1_1_c = ComparableVersion חדש ("1.1-c"); ComparableVersion version1_1_z = ComparableVersion חדש ("1.1-z"); ComparableVersion version1_1_1 = ComparableVersion חדש ("1.1.1"); assertTrue (version1_1_c.compareTo (version1_1_z) <0); assertTrue (version1_1_z.compareTo (version1_1_1) <0);

3. שימוש דרגת הליבה

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

3.1. תלות של Maven

ראשית, בואו נוסיף את האחרונה דרגת הליבה תלות Maven מהריפו של Gradle Releases:

 org.gradle-core-core 6.1.1 

3.2. גרסת מספר

ה גרסת מספר בכיתה המסופקת על ידי גרדל משווה שתי גרסאות, בדומה לזו של מייבן ComparableVersion מעמד:

VersionNumber version1_1 = VersionNumber.parse ("1.1"); VersionNumber version1_2 = VersionNumber.parse ("1.2"); VersionNumber version1_3 = VersionNumber.parse ("1.3"); assertTrue (version1_1.compareTo (version1_2) 0); VersionNumber version1_1_0 = VersionNumber.parse ("1.1.0"); assertEquals (0, version1_1.compareTo (version1_1_0)); 

3.3. רכיבי גרסה

לא כמו ה ComparableVersion הכיתה, ה גרסת מספר מחלקה תומכת בחמישה רכיבי גרסה בלבד - גדול, קַטִין, מיקרו, תיקון, ו מַגְדִיר:

VersionNumber version1_1_1_1_alpha = VersionNumber.parse ("1.1.1.1-alpha"); assertTrue (version1_1.compareTo (version1_1_1_1_alpha) <0); VersionNumber version1_1_beta = VersionNumber.parse ("1.1.0.0-beta"); assertTrue (version1_1_beta.compareTo (version1_1_1_1_alpha) <0);

3.4. תוכניות גרסאות

גַם, גרסת מספר תומך בכמה תוכניות גרסאות שונות כמו מייג'ור.Minor.Micro-Qualifier ו מייג'ור.Minor.Micro.Patch-Qualifier:

VersionNumber version1_1_1_snapshot = VersionNumber.parse ("1.1.1-snapshot"); assertTrue (version1_1_1_1_alpha.compareTo (version1_1_1_snapshot) <0);

4. שימוש ג'קסון-ליבה

4.1. תלות של Maven

בדומה לתלות אחרות, בואו נוסיף את האחרונה ג'קסון-ליבה תלות Maven שלנו pom.xml:

 com.fasterxml.jackson.core jackson-core 2.11.1 

4.2. גִרְסָה

ואז נוכל לבחון את ג'קסון גִרְסָה בכיתה, שיכולה להחזיק מידע על גרסאות של רכיב יחד עם האופציונלי groupId ו artifactId ערכים.

לכן, הקבלן של גִרְסָה הכיתה מאפשרת לנו להגדיר groupId ו artifactId, יחד עם רכיבים כמו גדול, קַטִין, ו תיקון:

גרסה ציבורית (int major, int minor, int patchLevel, String snapshotInfo, String groupId, String artifactId) {// ...}

אז בואו נשווה כמה גרסאות באמצעות גִרְסָה מעמד:

גרסה גרסה 1_1 = גרסה חדשה (1, 1, 0, null, null, null); גרסה version1_2 = גרסה חדשה (1, 2, 0, null, null, null); גרסה version1_3 = גרסה חדשה (1, 3, 0, null, null, null); assertTrue (version1_1.compareTo (version1_2) 0); גרסה גרסה 1_1_1 = גרסה חדשה (1, 1, 1, null, null, null); assertTrue (version1_1.compareTo (version1_1_1) <0);

4.3. ה snapshotInfo רְכִיב

ה snapshotInfo רכיב אינו משמש בעת השוואה בין שתי גרסאות:

גרסה version1_1_snapshot = גרסה חדשה (1, 1, 0, "תמונת מצב", null, null); assertEquals (0, version1_1.compareTo (version1_1_snapshot));

בנוסף, ה- גִרְסָה הכיתה מספקת את isSnapshot שיטה לבדוק אם הגרסה מכילה רכיב של תמונת מצב:

assertTrue (version1_1_snapshot.isSnapshot ());

4.4. ה groupId ו artifactId רכיבים

כמו כן, בכיתה זו משווה את הסדר הלקסיקלי של ה- groupId ו artifactId רכיבי גרסה:

גרסה version1_1_maven = גרסה חדשה (1, 1, 0, null, "org.apache.maven", null); גרסה version1_1_gradle = גרסה חדשה (1, 1, 0, null, "org.gradle", null); assertTrue (version1_1_maven.compareTo (version1_1_gradle) <0);

5. שימוש Semver4J

ה Semver4j הספרייה מאפשרת לנו לעקוב אחר כללי המפרט לגירסא סמנטית ב- Java.

5.1. תלות של Maven

ראשית, נוסיף את האחרונה semver4j תלות במייבון:

 com.vdurmont semver4j 3.1.0 

5.2. סמר

ואז נוכל להשתמש ב- סמר בכיתה להגדרת גרסה:

Semver version1_1 = חדש Semver ("1.1.0"); Semver version1_2 = Semver חדש ("1.2.0"); Semver version1_3 = חדש Semver ("1.3.0"); assertTrue (version1_1.compareTo (version1_2) 0); 

באופן פנימי, הוא מנתח גרסה לרכיבים כמו גדול, קַטִין, ו תיקון.

5.3. השוואת גרסאות

וגם ה סמר class מגיע עם שיטות מובנות שונות כמו גדול מ, isLowerThan, ו שווה ל להשוואת גרסאות:

Semver version1_1_alpha = חדש Semver ("1.1.0-alpha"); assertTrue (version1_1.isGreaterThan (version1_1_alpha)); Semver version1_1_beta = Semver חדש ("1.1.0-בטא"); assertTrue (version1_1_alpha.isLowerThan (version1_1_beta)); assertTrue (version1_1.isEqualTo ("1.1.0"));

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

assertEquals (VersionDiff.MAJOR, version1_1.diff ("2.1.0")); assertEquals (VersionDiff.MINOR, version1_1.diff ("1.2.3")); assertEquals (VersionDiff.PATCH, version1_1.diff ("1.1.1"));

5.4. יציבות גרסה

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

assertTrue (version1_1.isStable ()); assertFalse (version1_1_alpha.isStable ());

6. פיתרון מותאם אישית

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

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

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

int static int comparVersions (מחרוזת גרסה 1, מחרוזת גרסה 2) {int comparisonResult = 0; מחרוזת [] version1Splits = version1.split ("\."); מחרוזת [] version2Splits = version2.split ("\."); int maxLengthOfVersionSplits = Math.max (version1Splits.length, version2Splits.length); עבור (int i = 0; i <maxLengthOfVersionSplits; i ++) {Integer v1 = i <version1Splits.length? Integer.parseInt (version1Splits [i]): 0; מספר שלם v2 = i <version2Splits.length? Integer.parseInt (version2Splits [i]): 0; int השווה = v1.compareTo (v2); אם (השווה! = 0) {comparisonResult = השווה; לשבור; }} להחזיר את השוואת תוצאות; }

בואו נאמת את הפתרון שלנו על ידי השוואה בין כמה גרסאות:

assertTrue (VersionCompare.compareVersions ("1.0.1", "1.1.2") <0); assertTrue (VersionCompare.compareVersions ("1.0.1", "1.10") 0); assertTrue (VersionCompare.compareVersions ("1.1.2", "1.2.0") <0); assertEquals (0, VersionCompare.compareVersions ("1.3.0", "1.3");

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

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

7. מסקנה

במאמר זה בדקנו דרכים שונות להשוות מחרוזות גרסה ב- Java.

בהתחלה בחנו פתרונות מובנים המסופקים על ידי מסגרות בנייה כמו Maven ו- Gradle, באמצעות ה- חפץ-חפץ ו דרגת הליבה תלות, בהתאמה. לאחר מכן בחנו את תכונות השוואת הגרסאות של ג'קסון-ליבה ו semver4j ספריות.

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

כרגיל, כל יישומי הקוד זמינים ב- GitHub.