Vergleich von Versionszeichenfolgen, wenn Sie die Verarbeitung zwischen zwei Versionen verzweigen möchten (Java-Implementierung)

Ich wollte die Systemverarbeitung abhängig von der Version des Task-Management-Service ändern, daher habe ich eine Implementierung implementiert, die die beiden Versionszeichenfolgen vergleicht. Es ist eine Methode, die Version als Zeichenfolge zu behandeln, durch einen Punkt zu teilen und dann jeden Teil in eine Ganzzahl umzuwandeln und zu vergleichen.

Was du machen willst

• Zum Beispiel möchten Sie den Prozess verzweigen, je nachdem, ob die Version eines Dienstes 2.5 oder höher und weniger als 2.5 ist. --Die Version muss die drei durch die x.y.z-Periode getrennten Teile berücksichtigen, z. B. 2.5.0.
• Es gibt einige Möglichkeiten, Versionen wie 1.3-SNAPSHOT, 1.3a zu schreiben, aber diesmal werden wir sie nicht berücksichtigen.
• Die Version, die zum Verzweigungspunkt wird, ist fest und die Zeichenfolge der Dienstversion wird aus der Einstellungsdatei gelesen.

Implementierung

Die Implementierung wurde unter Bezugnahme auf [diese Site] geschrieben (https://stackoverflow.com/questions/198431/how-do-you-compare-two-version-strings-in-java). Für ausführlichere Diskussionen wenden Sie sich bitte an Interessenten.

Ich habe die HashCode-Berechnung selbst implementiert. (Ich weiß nicht, ob das in Ordnung ist)

Version.java

package com.example;

import java.util.Arrays;
import java.util.ArrayList;

public class Version implements Comparable<Version> {
    
        private String version;
    
        private String[] parts;
    
        public final String getVersion() {
            return this.version;
        }
    
        public String[] getParts() {
            return this.parts;
        }
    
        public Version(String version) {
            if(version == null)
                throw new IllegalArgumentException("Version can not be null");
            if(!version.matches("[0-9]+(\\.[0-9]+)*"))
                throw new IllegalArgumentException("Invalid version format");
            this.version = version;
            this.parts = this.getVersion().split("\\.");
        }
    
        @Override public int compareTo(Version that) {
            if(that == null)
                return 1;
            String[] thisParts = this.getParts();
            String[] thatParts = that.getParts();
            int length = Math.max(thisParts.length, thatParts.length);
            for(int i = 0; i < length; i++) {
                int thisPart = i < thisParts.length ?
                        Integer.parseInt(thisParts[i]) : 0;
                int thatPart = i < thatParts.length ?
                        Integer.parseInt(thatParts[i]) : 0;
                if(thisPart < thatPart)
                    return -1;
                if(thisPart > thatPart)
                    return 1;
            }
            return 0;
        }
    
        @Override public boolean equals(Object that) {
            if(this == that)
                return true;
            if(that == null)
                return false;
            if(this.getClass() != that.getClass())
                return false;
            return this.compareTo((Version) that) == 0;
        }
    
        @Override public final int hashCode() {
            ArrayList<Integer> intParts = new ArrayList();
            String[] thisParts = this.getParts();
            for(int i = 0; i < thisParts.length; i++) {
                intParts.add(Integer.parseInt(thisParts[i]));
            }
            Integer[] list = intParts.toArray(new Integer[intParts.size()]);
            return Arrays.hashCode(list);
        }
    }

Ich habe versucht, die Hauptfunktion wie folgt zu verschieben.

Main.java

package com.example;

import com.example.Version;

public class Main {

    public static void main(String[] args) {
        Version a = new Version("1.1");
        Version b = new Version("1.1.1");
        System.out.println(a.compareTo(b)); // return -1 (a<b)
        System.out.println(a.equals(b));    // return false
        System.out.println(a.hashCode());
        System.out.println(b.hashCode());

        Version c = new Version("2.0");
        Version d = new Version("1.9.9");
        System.out.println(c.compareTo(d)); // return 1 (c>d)
        System.out.println(c.equals(d));   // return false
        System.out.println(c.hashCode());
        System.out.println(d.hashCode());

        Version e = new Version("2.06");
        Version f = new Version("2.060");
        System.out.println(e.compareTo(f));  // return -1 (e<f)
        System.out.println(e.equals(f));  // return false

        Version g = new Version("3.3.0");
        Version h = new Version("3.3.0");
        System.out.println(g.compareTo(h));  // return 0 (g==h)
        System.out.println(g.equals(h));  // return true
        System.out.println(g.hashCode());
        System.out.println(h.hashCode());
    }
}

Output

-1
false
993
30784
1
false
1023
31040
-1
false
0
true
32767
32767

Vorläufig dachte ich, es wäre okay, weil es auf diese Weise überleben kann. Eigentlich wollte ich es auch dann verwenden können, wenn es eine Version wie 1.3-SNAPSHOT, 1.3a enthält. .. ..

Referenz / Zitat

• How do you compare two version Strings in Java?