Should YamlConfiguration objects be closed?

Question

I've been working on a plugin that requires a fair amount of data being stored. I have it being stored in a custom config file I found online that works basically the same as the default config.

The problem I'm having is that I am not sure how to actually close the file or if I even need to, as I know little about yaml configurations. The code for the template I used is below.

I'm also curious as to advice on how I should store larger amounts of data in the future.

public class CustomConfig {
    //store name of file to load/edit
    private final String fileName;
    //store plugin, to get file directory
    private final JavaPlugin plugin;

    //store actual hard disk file location
    private File configFile;
    //store ram file copy location
    private FileConfiguration fileConfiguration;


    //constructor taking a plugin and filename
    public CustomConfig(JavaPlugin plugin, String fileName) {
        //ensure plugin exists to get folder path
        if (plugin == null)
            throw new IllegalArgumentException("plugin cannot be null");
        //set this classes plugin variable to the one passed to this method
        this.plugin = plugin;
        //get name of file to load/edit
        this.fileName = fileName;
        //get directory/folder of file to load/edit
        File dataFolder = plugin.getDataFolder();
        if (dataFolder == null)
            throw new IllegalStateException();
        //load config file from hard disk

        this.configFile = new File(plugin.getDataFolder(), fileName);

        reloadConfig();
    }

    public void reloadConfig() {
        //load memory file from the hard copy
        fileConfiguration = YamlConfiguration.loadConfiguration(configFile);

        // Look for defaults in the jar
        File configFile = new File(plugin.getDataFolder(), fileName);
        if (configFile != null) {
            YamlConfiguration defConfig = YamlConfiguration.loadConfiguration(configFile);
            fileConfiguration.setDefaults(defConfig);
        }
    }

    public FileConfiguration getConfig() {
        if (fileConfiguration == null) {
            this.reloadConfig();
        }
        return fileConfiguration;
    }

    public void saveConfig() {
        if (fileConfiguration == null || configFile == null) {
            return;
        } else {
            try {
                getConfig().save(configFile);
            } catch (IOException ex) {
                plugin.getLogger().log(Level.SEVERE, "Could not save config to " + configFile, ex);
            }
        }
    }

    public void saveDefaultConfig() {
        if (!configFile.exists()) {            
            this.plugin.saveResource(fileName, false);
        }
    }
}

Answer 1

No. You do not have to close YamlConfiguration objects.

While the default config (JavaPlugin.getConfig()) is bound to the lifecycle of the plugin, custom ones are disposed when any other Java object is, i.e. when the garbage collector determines that there are no more references pointing to them in the code.

Answer 2

You don't need to close the config. It's not a BufferedWriter. The config keeps all of the data in the memory until the server shuts down. This means that if you change something in the config during the time your plugin is enabled, you will need to use your reloadConfig() method. The only clean up you need to do after using the FileConfiguration#set(String, Object) method is to use FileConfiguration#saveConfig() to tell Bukkit to take the current state of your config and copy it into your config file.