[JAVA] Ein Beispiel für kleine Arbeiten, bei denen Sie den Definitionswert nach der Umgebung aufteilen möchten, sich dessen jedoch nicht bewusst sein möchten

Einführung

Ich denke, dass es sehr häufig vorkommt, unterschiedliche Werte für Verbindungszielinformationen und Authentifizierungsinformationen für Datenbanken, externe Server usw., für die Entwicklung und für den Produktionsbetrieb zu haben. Zu diesem Zeitpunkt in derselben Definitionsdatei

conf.properties

 #Produktionsverbindungsziel
 #url=http://example.com/
 #Verbindungsziel testen
 url=http://test.example.com/

Ich sehe manchmal Leute, die so etwas wie ... schreiben und damit umgehen, indem sie Kommentare ersetzen, aber es gibt verschiedene Dinge wie das Schreiben eines soliden konstanten Werts auf der Quellcodeseite (obwohl es keinen klaren Grund dafür gibt). Obwohl es weitaus besser ist als das unglückliche, ist es keine sehr gute Methode. Der Hauptgrund ist, dass Sie wissen müssen, für welche Seite der Inhalt der aktuellen Definitionsdatei bestimmt ist. Niemand möchte sich einen Unfall vorstellen, bei dem er versehentlich vergessen hat, eine Definitionsdatei erneut zu empfehlen, und offengelegt hat, was mit der Testverbindung für die Produktion verbunden war. Wenn es sich um ein gut gemachtes Framework von heute handelt, gibt es einige, die angemessen auf die Anforderungen dieses Bereichs reagieren, aber dieses Mal möchte ich ein Beispiel schreiben, das nicht vom Framework abhängt und nicht viel Zeit und Mühe kostet. Ich werde.

Code

Configures.java

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.util.Properties;

/**
 *Definierter Wertecontainer
 */
public class Configures {
    /**Name des Systemeigenschaftsschlüssels*/
    public static final String PropKey = "Config";

    private static final Properties config = new Properties();

    /**
     *Initialisieren
     * @param filePath Pfad zur Definitionsdatei
     */
    synchronized public static void initialize(String filePath) {
        try {
            load(new FileInputStream(filePath));
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     *Initialisieren
     * @param in Stream zur Definitionsdatei
     */
    synchronized public static void initialize(InputStream in) {
        load(in);
    }

    private static void load(InputStream in) {
        try {
            config.load(in);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     *Definitionswert lesen
     * @param key key item
     * @Definitionswert zurückgeben
     */
    public static String get(Environment key) {
        return get(key, null);
    }

    /**
     *Definitionswert lesen
     * @param key key item
     * @param defaultValue Anfangswert
     * @Definitionswert zurückgeben
     */
    public static String get(Environment key, String defaultValue) {
        if (key == null) {
            throw new IllegalArgumentException("Environment is null");
        }
        return config.getProperty(key.getPropertyKey(), defaultValue);
    }

    private Configures() {
    }
}

Environment.java

/**
 *Schlüsselelemente in der Definitionsdatei
 */
public enum Environment {

    /**Verbindungsziel-URL*/
    ConnectUrl("url"),;

    private final String key;

    /**
     *Konstrukteur
     * @param key Schlüsselname in der Definitionsdatei
     */
    private Environment(String key) {
        this.key = key;
    }

    /**
     *Eigenschaftsschlüssel abrufen
     * @Name des Rückkehrschlüssels
     */
    public String getPropertyKey() {
        return getPropertyKey(System.getProperty(Configures.PropKey));
    }

    /**
     *Eigenschaftsschlüssel abrufen
     * @param envName Umgebungsname
     * @Name des Rückkehrschlüssels
     */
    public String getPropertyKey(String envName) {
        if (envName == null || "".equals(envName)) {
            return key;
        }
        return String.format("%s.%s", key, envName);
    }
}

Wie benutzt man

Nach dem Vorbereiten der Definitionsdatei wie folgt

conf.properties

 url=http://localhost/
 url.Test=http://test.example.com/
 url.Release=http://example.com/

Definieren Sie die Systemeigenschaft "Config" mit dem Wert "Release" in der Produktionsumgebung. (* Ich denke, es ist am einfachsten, "-DConfig = Release" zu den Laufzeitumgebungsvariablen hinzuzufügen.)

Im realen Code zu Beginn des Prozesses

 Configures.initialize(....)

(Für Webanwendungen ist es besser, ServletContextListener zu verwenden.)

 String url = Configures.get(Environment.ConnectUrl);

In der Umgebung, in der die Systemeigenschaft nicht definiert ist, wird der Wert "http: // localhost /" und in der Produktionsumgebung "http://example.com/" zurückgegeben.

In der Testfallklasse etc., in der Methode zur Einrichtung

 System.setProperty(Configures.PropKey, "Test");

In diesem Fall wird der Wert "http://test.example.com/" übergeben.