Comparaison des chaînes de version lorsque vous souhaitez brancher le traitement entre deux versions (implémentation Java)

Je voulais changer le traitement du système en fonction de la version du service de gestion des tâches, j'ai donc implémenté une implémentation qui compare les deux chaînes de version. C'est une méthode pour traiter la version comme une chaîne de caractères, la diviser par un point, puis convertir chaque partie en Integer et comparer.

Chose que tu veux faire

--Par exemple, vous souhaitez brancher le processus selon que la version d'un service est 2.5 ou supérieure et inférieure à 2.5.

• La version doit prendre en compte les trois parties séparées par la période x.y.z, par exemple 2.5.0.
• Il y a quelques manières d'écrire des versions telles que 1.3-SNAPSHOT, 1.3a, mais cette fois nous ne les considérerons pas.
• La version qui devient le point de branchement est fixe et la chaîne de caractères de la version du service est lue à partir du fichier de paramètres.

la mise en oeuvre

L'implémentation a été écrite en référence à ce site. Pour des discussions plus détaillées, veuillez vous référer à ceux qui sont intéressés.

J'ai implémenté moi-même le calcul de hashCode. (Je ne sais pas si ça va)

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);
        }
    }

J'ai essayé de déplacer la fonction principale comme suit.

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

Pour le moment, je pensais que ça irait parce qu'il semble pouvoir survivre de cette façon. En fait, je voulais pouvoir l'utiliser même s'il contient une version telle que 1.3-SNAPSHOT, 1.3a. .. ..

Référence / citation

• How do you compare two version Strings in Java?