Eine einfache Möglichkeit, die Einstellungen einer Java-Anwendung beizubehalten, ist eine Textdatei mit der Erweiterung ".properties", die die Kennung jeder Einstellung enthält, die einem bestimmten Wert zugeordnet ist (dieser Wert kann eine Zahl, eine Zeichenfolge, ein Datum usw. sein). . C # verwendet einen ähnlichen Ansatz, aber die Textdatei muss den Namen "App.config" haben. In beiden Fällen müssen Sie im Quellcode eine bestimmte Klasse zum Lesen von Einstellungen initialisieren: Diese Klasse verfügt über eine Methode, die den Wert (als Zeichenfolge) zurückgibt, der dem angegebenen Einstellungsbezeichner zugeordnet ist.
// Java example
Properties config = new Properties();
config.load(...);
String valueStr = config.getProperty("listening-port");
// ...
// C# example
NameValueCollection setting = ConfigurationManager.AppSettings;
string valueStr = setting["listening-port"];
// ...
In beiden Fällen sollten wir die aus der Konfigurationsdatei geladenen Zeichenfolgen analysieren und die konvertierten Werte den zugehörigen typisierten Objekten zuweisen (während dieser Phase können Analysefehler auftreten). Nach dem Analyseschritt müssen wir überprüfen, ob die Einstellungswerte zu einem bestimmten Gültigkeitsbereich gehören. Beispielsweise sollte die maximale Größe einer Warteschlange ein positiver Wert sein. Einige Werte können in Beziehung stehen (Beispiel: min <max ), und so weiter.
Angenommen, die Anwendung sollte die Einstellungen sofort nach dem Start laden. Mit anderen Worten, der erste Vorgang, den die Anwendung ausführt, ist das Laden der Einstellungen. Ungültige Werte für die Einstellungen müssen automatisch durch Standardwerte ersetzt werden. Wenn dies bei einer Gruppe von verwandten Einstellungen der Fall ist, werden diese Einstellungen alle mit Standardwerten festgelegt.
Am einfachsten können Sie diese Vorgänge ausführen, indem Sie eine Methode erstellen, die zuerst alle Einstellungen analysiert, dann die geladenen Werte überprüft und schließlich die Standardwerte festlegt. Bei dieser Vorgehensweise ist die Wartung jedoch schwierig: Da die Anzahl der Einstellungen während der Entwicklung der Anwendung zunimmt, wird es immer schwieriger, den Code zu aktualisieren.
Um dieses Problem zu lösen, hatte ich mir überlegt, das Muster der Template-Methode wie folgt zu verwenden.
public abstract class Setting
{
protected abstract bool TryParseValues();
protected abstract bool CheckValues();
public abstract void SetDefaultValues();
/// <summary>
/// Template Method
/// </summary>
public bool TrySetValuesOrDefault()
{
if (!TryParseValues() || !CheckValues())
{
// parsing error or domain error
SetDefaultValues();
return false;
}
return true;
}
}
public class RangeSetting : Setting
{
private string minStr, maxStr;
private byte min, max;
public RangeSetting(string minStr, maxStr)
{
this.minStr = minStr;
this.maxStr = maxStr;
}
protected override bool TryParseValues()
{
return (byte.TryParse(minStr, out min)
&& byte.TryParse(maxStr, out max));
}
protected override bool CheckValues()
{
return (0 < min && min < max);
}
public override void SetDefaultValues()
{
min = 5;
max = 10;
}
}
Das Problem ist, dass wir auf diese Weise für jede Einstellung eine neue Klasse erstellen müssen, auch für einen einzelnen Wert. Gibt es andere Lösungen für diese Art von Problem?
Zusammenfassend:
- Einfache Wartung: Zum Beispiel durch Hinzufügen eines oder mehrerer Parameter.
- Erweiterbarkeit: Eine erste Version der Anwendung kann eine einzelne Konfigurationsdatei lesen, spätere Versionen bieten jedoch möglicherweise die Möglichkeit eines Mehrbenutzer-Setups (der Administrator richtet eine Grundkonfiguration ein, Benutzer können nur bestimmte Einstellungen vornehmen usw.).
- Objektorientiertes Design.