Configuration

Le système de configuration permet de lire automatiquement un fichier de config en fonction d'une classe donné

Les différents composants

TypeReader

Les TypeReader transforme une valeur en une classe donné
Ex. Transformer n'importe quel objet en String

public class StringReader implements ConfigurationTypeReader {

    @Override
    public <T> T read(Class<T> clazz, Object instance) {
        // clazz.cast pour éviter un warning
        return clazz.cast(String.valueOf(instance));
    }
}

ConfigurationReader

Cet classe gère l'entièreté de la transformation config -> objet
Elle stock aussi les typereaders disponible

Les annotations

Le système de config utilise les annotations pour permettre de changer le comportement de certain field

CfgClass

Cette annotation permet de dire au système de configuration que cette classe peut être transformer automatiquement et ne nécessite pas de TypeReader

CfgOptions

Cette annotation permet de modifier comment un field ou class devrait être interprété

inline (par défaut: false) -> si oui ou non le reader devrait utiliser le même objet que la class
optional (par défaut: false) -> défini si le field est nécessaire
isKey (par défaut: false) -> défini si le field représente juste la clé utilisé pour accéder a la classe (ex. field id)
name (par défaut: "") -> défini le nom à utiliser pour trouver l'objet avec lequel la classe ou field doit être rempli

Transformation

3 "type de transformation" sont supportés par le reader:

Créer et remplir une class (& record)
Remplir les fields statics d'une class
Remplir une enum (nécessite d'extends une interface)

Remplir une classe/record

L'exemple sera montré avec les classes suivante:

@CfgClass
public record Test(@CfgOptions(isKey = true) String id, int value){};

@CfgClass
@CfgOptions(inline = true)
public record TestOptions(String defaultTest, String weirdTest){};

@CfgClass
@CfgOptions(inline = true)
public record TestInformation(@CfgOptions(name = "test-version") int version,
                        @CfgOptions(optional = true) boolean isLastVersion){}; 

@CfgClass
public record PluginSettings(Test test, TestOptions options,
                            TestInformation info){};

Exemple de config

test:
  value: 3
  
default-test: "oh hey!"
weird-test: "hey again?!"

test-version: 1

Maintenant au démarrage de notre plugin nous allons lire via la config notre PluginSettings

public void onEnable() {
    saveDefaultConfig();

    PluginSettings settings = 
        getReader().populateClassInstance(getConfig(), PluginSettings.class);
        
    System.out.println(settings.test().id()); // "test"
    System.out.println(settings.test().value()); // 3
    System.out.println(settings.options().defaultTest()); // "oh hey!"
    System.out.println(settings.options().weirdTest()); // "hey again?!"
    System.out.println(settings.info().version()); // 1
    System.out.println(settings.info().isLastVersion()); // false, valeur par défaut d'un boolean
}

Remplir une classe avec des fields static

Prenons la classe suivante:

@CfgClass
public class TestSettings {
    // pour empêcher d'avoir des warnings
    // nous allons leur donner une valeur par défaut
    public static String CURRENT_TEST = "";
    public static String NEXT_TEST = "";
    
    // Le système de configuration invoquera cette méthode automatiquement
    public static void postInit() {
        for (Field declaredField : IslandSettings.class.getDeclaredFields()) {
            if (!declaredField.getType().equals(String.class)) continue;
            
            try {
                System.out.println(declaredField.get(null));            
            } catch(Throwable ignored){
                // TODO handle this!
            }
        }
    }
}

La configuration:

current-test: "alpha-3"
next-test: "alpha-4"

Au démarrage du plugin nous allons maintenant demander au système de remplir les fields

public void onEnable() {
    saveDefaultConfig();
    
    getPlatformLogger().info("Starting...");
    getReader().populateStaticFields(getConfig(), TestSettings.class);
    // postInit est appelé ici
    getPlatformLogger().info("Started!");
    
    getPlatformLogger().info("The next test is: " + TestSettings.NEXT_TEST);
}

Si nous démarrons maintenant un serveur de test cela nous mettrait donc dans la console

[Test] Starting...
[SOUT] alpha-3
[SOUT] alpha-4
[Test] Started
[Test] The next test is alpha-4

Remplir une Enum

Prenons l'enum suivante:

@CfgClass
public enum Messages implements ConfigurationEnum {
    ERROR_OCCURRED,
    
    private String wrapper;
    
    @Override
    public Class<?> getType() {
        return String.class;
    }

    @Override
    public String getValue() {
        return this.wrapper;
    }

    @Override
    public void setValue(Object value) {
        this.wrapper = (String) value;
    }
}

ConfigurationEnum est importante pour avoir getType(), getValue() et setValue et que le système de configuration peut donc intéragir avec votre enum

Avec la configuration suivante:

error-occured: "oh no something happened!"

Maintenant dans notre onEnable

public void onEnable() {
    saveDefaultConfig();
    
    getPlatformLogger().info("Starting...");
    getReader().populateEnum(getConfig(), Messages.class);
    
    getPlatformLogger().error(Messages.ERROR_OCCURED.getValue());
}

Dans la console nous verrons donc

[Test] Starting...
[Test] oh no something happened!

Le PostInit

Le système de configuration offre la possibilité d'exécuter du code après la transformation

Classe/record/enum

implémenter l'interface ConfigurationClass et implémenter la méthode postInit

@CfgClass
public record Test(String test) implements ConfigurationClass {

    @Override
    public void postInit(){
        System.out.println(test);
    }
}

Classe avec des fields static

Définissez une méthode static postInit

@CfgClass
public class Test {
    public static String TEST_FIELD = "";
    
    public static void postInit(){
        System.out.println(TEST_FIELD);
    }
}

Last modified: 17 septembre 2024