Ist Ableiten hier sinnvoll

[DaBe1812]

Hi, ich habe eine kleine Klasse für Konfigurationen

public class ReferenceSystemConfig {
    private Map<String,String> fieldMapping;
    private String username;
    private String password;
    private boolean ssl;
    private String server;
    private Integer port;
    private Map<String, Object> misc;

    @SuppressWarnings("unchecked")
    public ReferenceSystemConfig(Map<String, Object> configMap) {
        misc = new HashMap<>();
        for(String parameter : configMap.keySet()) {
            Object value = configMap.get(parameter);
            switch(parameter) {
            case "FIELDMAPPING":
                fieldMapping = (Map<String, String>) value;
                break;
            case "USER":
                username = (String) value;
                break;
            case "PASSWORD":
                password = (String) value;
                break;
            case "SSL":
                ssl = (Boolean) value;
                break;
            case "SERVER":
                server = (String) value;
                break;
            case "PORT":
                port = (Integer) value;
                break;
            default:
                misc.put(parameter, value);
            }
        }

    }

    public Object get(String key) {
        if(misc.containsKey(key)) {
            return misc.get(key);
        }
        return null;
    }
    
    public Map<String,String> getFieldMapping() { return fieldMapping; }
    public String getUsername() { return username; }
    public String getPassword() { return password; }
    public boolean isSsl() { return ssl; }
    public String getServer() { return server; }
    public Integer getPort() { return port; }
    public Map<String, Object> getMisc() { return misc; }
}

In dieser Form speichere ich die Konfiguration für viele verschieden Systeme. Wie man sieht sind ein paar Parameter bei allen Systemen gleich und ein paar kommen nur bei einigen wenigen Systemen vor, z.B. hat ein System eine Datenbank, das würde ich dann über ein get("DATABASE") abrufen.
Aktuell speichere ich aber die Daten in der Datenbank einigermaßen typsicher ab und wollte das auch in der Klasse repräsentieren.

Dabei habe ich mir gedacht, dass es vielleicht Sinn machen würde von der Klasse ab zu leiten und als Kind dann eine Klasse zu haben, die Datenbanken kennt.

Aber macht das Sinn? Dann müsste ich doch in meinem Code immer darauf hinweisen, dass ich jetzt keine ReferenceSystemConfig habe, sondern eine ReferenceSystemConfigWithDatabase oder so. D.h. ich müsste in meinen Methoden dann von ReferenceSystemConfig auf eines ihrer Kinder casten, damit ich dann eine Methode getDatabase verwenden kann. Oder habe ich gerade einen Haken im Kopf und denke falsch?

 

[Robert Zenz]

Ja und Nein, es kommt darauf an was genau und wieviel davon du vorhast.

Zunaechst wuerde ich die lokalen Felder einstampfen und durch einen Zugriff in die Map ersetzen, dann hast du weniger Sonderfaelle zu beachten:

public String getUsername() {
    return getWithCast("USERNAME");
}

private <VALUE_TYPE> VALUE_TYPE getWithCast(String key) {
    if (values.containsKey(key)) {
        return (VALUE_TYPE)values.get(key);
    }
    
    return null;
}

Dann kannst du auch dein groszes switch einstampfen. Pruefungen kannst du dann ja auch in der getWithCast machen wenn du sie willst.

Um zu deiner eigentlichen Frage zurueck zu kommen, wenn du oefters den Fall haben wirst das es eine Datenbank gibt, oder eben auch keine, kann es natuerlich Sinn machen hier eine Klassenstruktur aufzubauen:

public class ReferenceSystemConfig { }
public class DatabaseAwareReferenceSystemConfig extends ReferenceSystemConfig { }

Das hat den Vorteil dass du mit Methoden arbeiten kannst um diese Werte zu holen, aber du musst natuerlich immer pruefen ob diese auch in der initialen Map vorkommen. Man gewinnt aber nur relativ wenig. Ich sage mal wenn du drei Projekte hast ohne Datenbank, und zwei mit, wuerde ich da eine Klasse fuer alle machen. Wenn das alles nur intern ist, spielt das keine Rolle.

Wenn das irgendwie in einer Bibliothek enden soll, dann wuerde ich das sauber auftrennen, ja.

Ein anderer Ansatz, aber etwas komplexer, koennte sein wenn du dir die Konifguration in einzelne Abschnitte aufteilst.

public class ReferenceSystemConfig {
    public DatabaseConfig getDatabaseConfig() {}
    public ServerConfig getServerConfig() {}
    public UserConfig getUserConfig() {}
}

Dann hast du eine Klasse und von dieser kannst du "dynamisch" die einzelnen Konfigurationen holen die du brauchst. Wenn es keine gibt, retourniert mal entweder null oder wirft einen Fehler dass dieser Abschnitt fehlt.

 

[DaBe1812]

Hi,
deine erste Lösung mit VALUE_TYPE finde ich ganz interessant. Die Möglichkeit kannte ich noch gar nicht.
Damit kann ich in den nachgelagerten Klassen schonmal die unchecked und Co umgehen.

Evtl. werde ich für einige Configs Methoden hinzufügen, die über die get hinaus gehen, also z.B. getDatabase(), im schlechtesten Fall liefert die Methode null, aber das ist dann eben so und muss da gehandelt werden, wo ich auf den Parameter zugreifen möchte.

Das Objekt an sich wird nur intern verwendet und schlägt nicht auf's Frontend durch.

Danke für die Hilfe.

 

[temi]

deine erste Lösung mit VALUE_TYPE finde ich ganz interessant. Die Möglichkeit kannte ich noch gar nicht.

Das sind Generics. Du kennst es evtl. in der Art: private <T> T getWithCast(String key)

Beachte, dass ein Cast stattfindet. Der Wert, der hinter dem Key steht muss sich natürlich auch in den gewünschten Typen casten lassen.

 

[DaBe1812]

Hi,
dass der Cast möglich sein muss, ist verständlich.

Kann man das Ganze auch noch weiter treiben?

Ich habe eine Entity, die hängt an einer Tabelle mit Parametern. In einer Spalte habe ich ein Enum für den Datentyp des Parameters und dann jeweils eine Spalte für String, Integer, Double, Date und Boolean.

Jetzt biete ich zwar für jede Spalte einen eigenen getter an, aber Grundsätzlich will ich mit getValue() einfach den Wert in seinem Datentyp erhalten.

Bis jetzt habe ich dafür eine Funktion:

    public Object getValue() {
        switch(datatype) {
        case BOOLEAN:
            return booleanValue;
        case INTEGER:
            return integerValue;
        case PASSWORD:
        case STRING:
            return stringValue;
        case LIST:
            return Arrays.asList(stringValue.split(","));
        case MAP:
            return JsonHelper.toLinkedMap(stringValue);
        default:
            return null;
        }
    }

Aber mit den Generics könnte ich ja grundsätzlich eine Funktion bauen, die sich dann anhand vom geforderten Datentyp das richtige Feld zieht, oder eben null, wenn es den Datentyp nicht gibt. Aber irgendwie bekomme ich das nicht so richtig zum Laufen.

 

[temi]

Wenn ich so "Entity" und "verschiedene Parameter" lese, hast du dir mal das Konzept ECS (Entity Component System) angeschaut? Das wird in der Spieleprogrammierung häufig eingesetzt. Möglicherweise wäre das eine Möglichkeit für dich, ohne jetzt zu wissen, was du überhaupt tust.