This is a simple library for creating config files for your plugins. It uses reflection to get and set values from the config file. You can also create your own serializers for your classes and add your own file formats.
- Primitives
- Objects
- Enums
- Maps
- Collections
- ItemStacks
- Locations
- Adventure Text Components
After you added the library as a dependency, you have 2 choices:
- Add the library as a plugin to your server
depends: [Configs]
- Shade the library into your code
repositories {
maven {
url 'https://jitpack.io'
}
}
dependencies {
compileOnly 'com.github.goldfinchx:configs:1.1.4'
}
<repositories>
<repository>
<id>jitpack.io</id>
<url>https://jitpack.io</url>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>com.github.goldfinchx</groupId>
<artifactId>configs</artifactId>
<version>1.1.4</version>
</dependency>
</dependencies>
It is super easy to create a new config class, just extend the Config class, add your fields, and provide a default no-args constructor. That's it.
@Getter
@NoArgsConstructor // you MUST add no-args constructor
public class TestConfig extends Config {
private String value = "This is String value!";
private Material enumValue = Material.DIAMOND;
private ItemStack itemStackValue = new ItemStack(Material.STONE, 1);
private Map<Integer, Material> mapValue = Map.of(1, Material.STONE);
private final String ignoredValue;
private transient int ignoredValue2;
public TestConfig(JavaPlugin plugin) {
// Formats available: JSON and YAML (change the type of the file to x.json or x.yaml/x.yml)
super("fileName.yml", plugin.getDataFolder().getPath());
// you MUST add this command to get updated values from the file and use this in your reload command
this.reload();
}
}
public class MyFormat implements Format {
@Override
public void writeFile(File file, Map<String, Object> map) {
// write the map into 'file'
}
@Override
public Map<String, Object> readFile(File file) {
// Please note that you should not deserialize
// values from a file (using serializers). You
// just have to return a map of the original
// values from the file
Map<String, Object> result = new HashMap<>();
return result;
}
}
- Find out the MIME type of your format (or make one up if it's your own)
(f.e.: for
JSON
isapplication/json
, forYAML
isapplication/yaml
) - Prepare a list of file formats of your format
(f.e.: for
JSON
is only.json
, forYAML
is.yaml
and.yml
) Please note! The type must be registered before using configs, otherwise it will not be applied to them.
@Override
public void onEnable() {
this.getLogger().info("Plugin has been enabled!");
// The number of file types is unlimited (1-∞)
// You can specify file formats with or without a dot at the beginning - it doesn’t matter
FormatFactory.getFactory().register(MyFormat.class, "mime", "fileFormat1", "fileFormat2" /* ... */);
// initialize configs
}
Let's imagine that you need to store one number in a YAML config file. So you have TestConfig.java
:
public class TestConfig extends Config {
private MyStoreValue myValue = new MyStoreValue(3);
public TestConfig(JavaPlugin plugin) {
super("fileName.yml", plugin.getDataFolder().getPath());
}
}
And MyStoreValue.java
:
public class MyStoreValue {
public int myInt = 4;
public MyStoreValue() {} // it is important
public MyStoreValue(int myInt){
this.myInt = myInt;
}
}
When we run our plugin, we will see the following in the config:
---
myValue:
myInt: 3
But why create an extra line for myInt
?
Let's create a serializer:
class MyValueSerializer
/*
Serializer<
The class we want to process,
The type that will be stored in the config
>
*/
implements Serializer<MyStoreValue, Integer> {
@Override
public MyStoreValue deserialize(TypeReference type, Integer serialized) {
return new MyStoreValue(serialized); // create our value
}
@Override
public Integer serialize(TypeReference type, MyStoreValue object) {
return object.myInt; // get and return value
}
}
Now we need to register, but! We must do this before using the config. This is what our main plugin class will look like:
public class MyPlugin extends JavaPlugin {
@Override
public void onEnable() {
this.getLogger().info("Plugin has been enabled!");
SerializerFactory.getFactory().register(new MyValueSerializer());
TestConfig config = new TestConfig(this);
}
}
Now, when we run our plugin, we will see the following in the config:
---
myValue: 3