fix(init): 添加文件初始化测试 #40

* 修复路径截取错误导致无法拥有内部object类型的问题

* 移除测试输出

.documentation/JAVADOC-README.md

@@ -0,0 +1,9 @@
+# EasyConfiguration Javadoc
+
+基于 [Github Pages](https://pages.github.com/) 搭建，请访问 [JavaDoc](https://carmjos.github.io/EasyConfiguration) 。
+
+## 如何实现？
+
+若您也想通过 [Github Actions](https://docs.github.com/en/actions/learn-github-actions)
+自动部署项目的Javadoc到 [Github Pages](https://pages.github.com/) ，
+可以参考我的文章 [《自动部署Javadoc到Github Pages》](https://pages.carm.cc/doc/javadoc-in-github.html) 。

.documentation/README.md

@@ -0,0 +1,3 @@
+# 欢迎使用 EasyConfiguration ！
+
+这个项目刚刚创建，详细的Javadoc与开发指南还在补充，请给我一点时间~

.github/workflows/deploy.yml

@@ -1,7 +1,7 @@
 # This workflow will build a Java project with Maven, and cache/restore any dependencies to improve the workflow execution time
 # For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-maven
 
-name: "Project Deploy"
+name: "Deploy & Publish"
 
 on:
   # 支持手动触发构建
@@ -72,7 +72,7 @@ jobs:
         run: |
           cd docs
           git init
-          git remote add origin git@github.com:CarmJos/EasySQL.git
+          git remote add origin git@github.com:CarmJos/EasyConfiguration.git
           git checkout -b gh-pages
           git add -A
           git commit -m "API Document generated."

.github/workflows/maven.yml

@@ -1,7 +1,7 @@
 # This workflow will build a Java project with Maven, and cache/restore any dependencies to improve the workflow execution time
 # For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-maven
 
-name: Project Build & Tests
+name: Build & Tests
 
 on:
   # 支持手动触发构建

LICENSE

@@ -1,21 +1,165 @@
-MIT License
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
 
-Copyright (c) 2022 Carm
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

README.md

@@ -9,9 +9,9 @@
 # EasyConfiguration
 
 [![version](https://img.shields.io/github/v/release/CarmJos/EasyConfiguration)](https://github.com/CarmJos/EasyConfiguration/releases)
-[![License](https://img.shields.io/github/license/CarmJos/EasyConfiguration)](https://opensource.org/licenses/MIT)
+[![License](https://img.shields.io/github/license/CarmJos/EasyConfiguration)](https://www.gnu.org/licenses/lgpl-3.0.html)
 [![workflow](https://github.com/CarmJos/EasyConfiguration/actions/workflows/maven.yml/badge.svg?branch=master)](https://github.com/CarmJos/EasyConfiguration/actions/workflows/maven.yml)
-[![CodeFactor](https://www.codefactor.io/repository/github/carmjos/easysql/badge)](https://www.codefactor.io/repository/github/carmjos/easysql)
+[![CodeFactor](https://www.codefactor.io/repository/github/carmjos/easyconfiguration/badge)](https://www.codefactor.io/repository/github/carmjos/easyconfiguration)
 ![CodeSize](https://img.shields.io/github/languages/code-size/CarmJos/EasyConfiguration)
 ![](https://visitor-badge.glitch.me/badge?page_id=EasyConfiguration.readme)
 
@@ -20,14 +20,17 @@
 ## 优势
 
 - 基于类的配置文件初始化、加载、获取与更新机制，方便快捷。
+- 支持复杂配置的手动序列化、反序列化。
+- 提供多种builder形式，快速构建 `ConfigValue<?>` 对象。
+- 支持通过注解规定配置对应的路径、注释等信息。
 
 ## 开发
 
-详细开发介绍请 [点击这里](.documentation/README.md) , JavaDoc(最新Release) 请 [点击这里](https://carmjos.github.io/EasyConfiguration) 。
+详细开发介绍请 [点击这里](.documentation/README.md) , JavaDoc(最新Release) 请 [点击这里](https://CarmJos.github.io/EasyConfiguration) 。
 
 ### 示例代码
 
-您可以 [点击这里](impl/yaml/src/test/java/config/source/TestConfiguration.java) 查看部分代码演示，更多演示详见 [开发介绍](.documentation/README.md) 。
+您可以 [点击这里](demo/src/main/java/cc/carm/lib/configuration/demo/DatabaseConfiguration.java) 查看部分代码演示，更多演示详见 [开发介绍](.documentation/README.md) 。
 
 ### 依赖方式
 
@@ -91,40 +94,15 @@
             <scope>compile</scope>
         </dependency>
 
-    </dependencies>
-</project>
-```
-
-</details>
-
-**基于Spigot实现的版本**
-
-```xml
-
-<project>
-    <dependencies>
+        <!--基于JSON文件的实现版本，可用于全部Java环境。-->
+        <!--需要注意的是，JSON不支持文件注释。-->
         <dependency>
             <groupId>cc.carm.lib</groupId>
-            <artifactId>easyconfiguration-spigot</artifactId>
+            <artifactId>easyconfiguration-json</artifactId>
             <version>[LATEST RELEASE]</version>
             <scope>compile</scope>
         </dependency>
-    </dependencies>
-</project>
-```
 
-**基于Bungee实现的版本 (不支持自动注释)**
-
-```xml
-
-<project>
-    <dependencies>
-        <dependency>
-            <groupId>cc.carm.lib</groupId>
-            <artifactId>easyconfiguration-bungee</artifactId>
-            <version>[LATEST RELEASE]</version>
-            <scope>compile</scope>
-        </dependency>
     </dependencies>
 </project>
 ```
@@ -165,30 +143,24 @@ dependencies {
     //基于YAML文件的实现版本，可用于全部Java环境。
     api "cc.carm.lib:easyconfiguration-yaml:[LATEST RELEASE]"
 
-}
-```
-
-</details>
-
-<details>
-<summary>平台依赖版本</summary>
-
-```groovy
-
-dependencies {
-
-    // 用于Spigot服务端的版本
-    api "cc.carm.lib:easyconfiguration-spigot:[LATEST RELEASE]"
-
-    // 用于BungeeCord服务端的版本，不支持注解。
-    // 如需注解，可选择使用 `easyconfiguration-yaml` 并打包。
-    api "cc.carm.lib:easyconfiguration-bungee:[LATEST RELEASE]"
+     //基于JSON文件的实现版本，可用于全部Java环境。
+    //需要注意的是，JSON不支持文件注释。
+    api "cc.carm.lib:easyconfiguration-json:[LATEST RELEASE]"
 
 }
 ```
 
 </details>
 
+## 衍生项目
+
+### [**MineConfiguration**](https://github.com/CarmJos/MineConfiguration) (by @CarmJos )
+
+EasyConfiguration for MineCraft!
+开始在 MineCraft 相关服务器平台上轻松(做)配置吧！
+
+目前支持 BungeeCord, Bukkit(Spigot) 服务端，后续将支持更多平台。
+
 ## 支持与捐赠
 
 若您觉得本插件做的不错，您可以通过捐赠支持我！
@@ -199,23 +171,4 @@ dependencies {
 
 ## 开源协议
 
-本项目源码采用 [The MIT License](https://opensource.org/licenses/MIT) 开源协议。
-
-<details>
-<summary>关于 MIT 协议</summary>
-
-> MIT 协议可能是几大开源协议中最宽松的一个，核心条款是：
->
-> 该软件及其相关文档对所有人免费，可以任意处置，包括使用，复制，修改，合并，发表，分发，再授权，或者销售。唯一的限制是，软件中必须包含上述版 权和许可提示。
->
-> 这意味着：
->
-> - 你可以自由使用，复制，修改，可以用于自己的项目。
-> - 可以免费分发或用来盈利。
-> - 唯一的限制是必须包含许可声明。
->
-> MIT 协议是所有开源许可中最宽松的一个，除了必须包含许可声明外，再无任何限制。
->
-> *以上文字来自 [五种开源协议GPL,LGPL,BSD,MIT,Apache](https://www.oschina.net/question/54100_9455) 。*
-
-</details>
+本项目源码采用 [GNU LESSER GENERAL PUBLIC LICENSE](https://www.gnu.org/licenses/lgpl-3.0.html) 开源协议。

core/pom.xml

@@ -5,12 +5,14 @@
     <parent>
         <artifactId>easyconfiguration-parent</artifactId>
         <groupId>cc.carm.lib</groupId>
-        <version>1.0.1</version>
+        <version>3.8.0</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
     <properties>
-        <maven.compiler.source>${java.version}</maven.compiler.source>
-        <maven.compiler.target>${java.version}</maven.compiler.target>
+        <maven.compiler.source>${project.jdk.version}</maven.compiler.source>
+        <maven.compiler.target>${project.jdk.version}</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
     </properties>
 
     <artifactId>easyconfiguration-core</artifactId>

core/src/main/java/cc/carm/lib/configuration/core/ConfigInitializer.java

@@ -1,99 +1,274 @@
 package cc.carm.lib.configuration.core;
 
-import cc.carm.lib.configuration.core.annotation.ConfigComment;
 import cc.carm.lib.configuration.core.annotation.ConfigPath;
+import cc.carm.lib.configuration.core.annotation.HeaderComment;
+import cc.carm.lib.configuration.core.annotation.InlineComment;
 import cc.carm.lib.configuration.core.source.ConfigurationProvider;
 import cc.carm.lib.configuration.core.value.ConfigValue;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
-import java.util.Optional;
+import java.util.Arrays;
+import java.util.List;
 
-public class ConfigInitializer {
+/**
+ * 配置文件类初始化方法
+ * 用于初始化 {@link ConfigurationRoot} 中的每个 {@link ConfigValue} 对象
+ *
+ * @param <T> {@link ConfigurationProvider} 配置文件的数据来源
+ * @author CarmJos
+ */
+public class ConfigInitializer<T extends ConfigurationProvider<?>> {
 
-    public static void initialize(ConfigurationProvider source, Class<? extends ConfigurationRoot> rootClazz) {
-        initialize(source, rootClazz, true);
+    protected final @NotNull T provider;
+
+    public ConfigInitializer(@NotNull T provider) {
+        this.provider = provider;
     }
 
-    public static void initialize(ConfigurationProvider provider, Class<? extends ConfigurationRoot> rootClazz, boolean saveDefault) {
-        ConfigPath sectionAnnotation = rootClazz.getAnnotation(ConfigPath.class);
+    /**
+     * 初始化指定类以及其子类的所有 {@link ConfigValue} 对象。
+     *
+     * @param clazz        配置文件类，须继承于 {@link ConfigurationRoot} 。
+     * @param saveDefaults 是否写入默认值(默认为 true)。
+     */
+    public void initialize(@NotNull Class<? extends ConfigurationRoot> clazz, boolean saveDefaults) {
+        initialize(clazz, saveDefaults, true);
+    }
 
-        String rootSection = null;
-        if (sectionAnnotation != null && sectionAnnotation.value().length() > 1) {
-            rootSection = sectionAnnotation.value();
-        }
-
-        for (Class<?> innerClass : rootClazz.getDeclaredClasses()) {
-            initSection(provider, rootSection, innerClass, saveDefault);
-        }
-
-        for (Field field : rootClazz.getFields()) {
-            initValue(provider, rootSection, rootClazz, field, saveDefault);
-        }
-
-        if (saveDefault) {
+    /**
+     * 初始化指定类的所有 {@link ConfigValue} 对象。
+     *
+     * @param clazz          配置文件类，须继承于 {@link ConfigurationRoot} 。
+     * @param saveDefaults   是否写入默认值(默认为 true)。
+     * @param loadSubClasses 是否加载内部子类(默认为 true)。
+     */
+    public void initialize(@NotNull Class<? extends ConfigurationRoot> clazz,
+                           boolean saveDefaults, boolean loadSubClasses) {
+        initializeStaticClass(
+                clazz, null, null,
+                null, null, null,
+                saveDefaults, loadSubClasses
+        );
+        if (saveDefaults) {
             try {
                 provider.save();
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
-
     }
 
-    private static void initSection(ConfigurationProvider provider, String parentSection, Class<?> clazz, boolean saveDefault) {
-        if (!Modifier.isStatic(clazz.getModifiers()) || !Modifier.isPublic(clazz.getModifiers())) return;
+    /**
+     * 初始化指定实例的所有 {@link ConfigValue} 与内部 {@link ConfigurationRoot} 对象。
+     *
+     * @param config 配置文件实例类，须实现 {@link ConfigurationRoot} 。
+     */
+    public void initialize(@NotNull ConfigurationRoot config) {
+        initialize(config, true);
+    }
 
-        String section = getSectionPath(clazz.getSimpleName(), parentSection, clazz.getAnnotation(ConfigPath.class));
-        ConfigComment comments = clazz.getAnnotation(ConfigComment.class);
-        if (comments != null && comments.value().length > 0) {
-            provider.setComments(parentSection, comments.value());
+    /**
+     * 初始化指定实例的所有 {@link ConfigValue} 与内部 {@link ConfigurationRoot} 对象。
+     *
+     * @param config       配置文件实例类，须实现 {@link ConfigurationRoot} 。
+     * @param saveDefaults 是否写入默认值(默认为 true)。
+     */
+    public void initialize(@NotNull ConfigurationRoot config, boolean saveDefaults) {
+        initializeInstance(
+                config, null, null,
+                null, null, null,
+                saveDefaults
+        );
+        if (saveDefaults) {
+            try {
+                provider.save();
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+
+    // 针对实例类的初始化方法
+    private void initializeInstance(@NotNull ConfigurationRoot root,
+                                    @Nullable String parentPath, @Nullable String fieldName,
+                                    @Nullable ConfigPath fieldPath,
+                                    @Nullable HeaderComment fieldHeaderComments,
+                                    @Nullable InlineComment fieldInlineComments,
+                                    boolean saveDefaults) {
+        String path = getClassPath(root.getClass(), parentPath, fieldName, fieldPath);
+        this.provider.setHeaderComment(path, getClassHeaderComments(root.getClass(), fieldHeaderComments));
+        if (path != null) this.provider.setInlineComment(path, readInlineComments(fieldInlineComments));
+
+        for (Field field : root.getClass().getDeclaredFields()) {
+            initializeField(root, field, path, saveDefaults, false);
+        }
+    }
+
+    // 针对静态类的初始化方法
+    private void initializeStaticClass(@NotNull Class<?> clazz,
+                                       @Nullable String parentPath, @Nullable String fieldName,
+                                       @Nullable ConfigPath fieldPath,
+                                       @Nullable HeaderComment fieldHeaderComments,
+                                       @Nullable InlineComment fieldInlineComments,
+                                       boolean saveDefaults, boolean loadSubClasses) {
+        if (!ConfigurationRoot.class.isAssignableFrom(clazz)) return; // 只解析继承了 ConfigurationRoot 的类
+        String path = getClassPath(clazz, parentPath, fieldName, fieldPath);
+        this.provider.setHeaderComment(path, getClassHeaderComments(clazz, fieldHeaderComments));
+        if (path != null) this.provider.setInlineComment(path, readInlineComments(fieldInlineComments));
+
+        for (Field field : clazz.getDeclaredFields()) {
+            initializeField(clazz, field, path, saveDefaults, loadSubClasses);
         }
 
-        for (Field field : clazz.getFields()) initValue(provider, section, clazz, field, saveDefault);
-        for (Class<?> innerClass : clazz.getDeclaredClasses()) initSection(provider, section, innerClass, saveDefault);
-
+        if (!loadSubClasses) return;
+        Class<?>[] classes = clazz.getDeclaredClasses();
+        for (int i = classes.length - 1; i >= 0; i--) {   // 逆向加载，保持顺序。
+            initializeStaticClass(
+                    classes[i], path, classes[i].getSimpleName(),
+                    null, null, null,
+                    saveDefaults, true
+            );
+        }
     }
 
-    private static void initValue(ConfigurationProvider provider, String parentSection, Class<?> clazz, Field field, boolean saveDefault) {
+    private void initializeField(@NotNull Object source, @NotNull Field field,
+                                 @Nullable String parent, boolean saveDefaults, boolean loadSubClasses) {
         try {
-            Object object = field.get(clazz);
+            field.setAccessible(true);
+            Object object = field.get(source);
+
             if (object instanceof ConfigValue<?>) {
                 initializeValue(
-                        provider, (ConfigValue<?>) object,
-                        getSectionPath(field.getName(), parentSection, field.getAnnotation(ConfigPath.class)),
-                        Optional.ofNullable(field.getAnnotation(ConfigComment.class))
-                                .map(ConfigComment::value).orElse(new String[0]),
-                        saveDefault);
+                        (ConfigValue<?>) object, getFieldPath(field, parent),
+                        field.getAnnotation(HeaderComment.class),
+                        field.getAnnotation(InlineComment.class),
+                        saveDefaults
+                );
+            } else if (source instanceof ConfigurationRoot && object instanceof ConfigurationRoot) {
+                // 当且仅当 源字段与字段 均为ConfigurationRoot实例时，才对目标字段进行下一步初始化加载。
+                initializeInstance(
+                        (ConfigurationRoot) object, parent, field.getName(),
+                        field.getAnnotation(ConfigPath.class),
+                        field.getAnnotation(HeaderComment.class),
+                        field.getAnnotation(InlineComment.class),
+                        saveDefaults
+                );
+            } else if (source instanceof Class<?> && object instanceof Class<?>) {
+                // 当且仅当 源字段与字段 均为静态类时，才对目标字段进行下一步初始化加载。
+                initializeStaticClass(
+                        (Class<?>) object, parent, field.getName(),
+                        field.getAnnotation(ConfigPath.class),
+                        field.getAnnotation(HeaderComment.class),
+                        field.getAnnotation(InlineComment.class),
+                        saveDefaults, loadSubClasses
+                );
             }
+
+            // 以上判断实现以下规范：
+            // - 实例类中仅加载 ConfigValue实例 与 ConfigurationRoot实例
+            // - 静态类中仅加载 静态ConfigValue实例 与 静态ConfigurationRoot类
+
         } catch (IllegalAccessException ignored) {
         }
     }
 
-
-    public static void initializeValue(@NotNull ConfigurationProvider provider, @NotNull ConfigValue<?> value,
-                                       @NotNull String path, @NotNull String[] comments, boolean saveDefault) {
-        value.initialize(provider, path, comments);
-        if (saveDefault && value.getDefaultValue() != null && !provider.getConfiguration().contains(path)) {
-            value.setDefault();
-        }
+    protected void initializeValue(@NotNull ConfigValue<?> value, @NotNull String path,
+                                   @Nullable HeaderComment fieldHeaderComment,
+                                   @Nullable InlineComment fieldInlineComment,
+                                   boolean saveDefaults) {
+        value.initialize(
+                provider, saveDefaults, path,
+                readHeaderComments(fieldHeaderComment),
+                readInlineComments(fieldInlineComment)
+        );
     }
 
-    public static String getSectionPath(@NotNull String name,
-                                        @Nullable String parentSection,
-                                        @Nullable ConfigPath pathAnnotation) {
-        String parent = parentSection != null ? parentSection + "." : "";
-        if (pathAnnotation != null && pathAnnotation.value().length() > 0) {
-            return parent + pathAnnotation.value();
-        } else {
-            return parent + getSectionName(name);
-        }
+    protected static @Nullable List<String> getClassHeaderComments(@NotNull Class<?> clazz,
+                                                                   @Nullable HeaderComment fieldAnnotation) {
+        List<String> classComments = readHeaderComments(clazz.getAnnotation(HeaderComment.class));
+        if (classComments != null) return classComments;
+        else return readHeaderComments(fieldAnnotation);
     }
 
-    public static String getSectionName(String codeName) {
-        return codeName.toLowerCase().replace("_", "-");
+
+    protected static List<String> readHeaderComments(@Nullable HeaderComment annotation) {
+        if (annotation == null) return null;
+        String[] value = annotation.value();
+        return value.length > 0 ? Arrays.asList(value) : null;
+    }
+
+
+    protected static @Nullable String readInlineComments(@Nullable InlineComment annotation) {
+        if (annotation == null) return null;
+        String value = annotation.value();
+        return value.length() > 0 ? value : null;
+    }
+
+    protected static @Nullable String getClassPath(@Nullable Class<?> clazz,
+                                                   @Nullable String parentPath,
+                                                   @Nullable String filedName,
+                                                   @Nullable ConfigPath fieldAnnotation) {
+        @NotNull String parent = parentPath != null ? parentPath + "." : "";
+        boolean fromRoot = false;
+
+        // 先获取 Class 对应的路径注解 其优先度最高。
+        if (clazz != null) {
+            ConfigPath clazzAnnotation = clazz.getAnnotation(ConfigPath.class);
+            if (clazzAnnotation != null) {
+                fromRoot = clazzAnnotation.root();
+                if (clazzAnnotation.value().length() > 0) {
+                    return (fromRoot ? "" : parent) + clazzAnnotation.value();
+                }
+            }
+        }
+
+        if (fieldAnnotation != null) {
+            fromRoot = fromRoot || fieldAnnotation.root();
+            if (fieldAnnotation.value().length() > 0) {
+                return (fromRoot ? "" : parent) + fieldAnnotation.value();
+            }
+        }
+
+        // 再由 fieldName 获取路径
+        if (filedName != null) return (fromRoot ? "" : parent) + getPathFromName(filedName);
+        else return null; // 不满足上述条件 且 无 fieldName，则说明是根路径。
+    }
+
+    protected static @NotNull String getFieldPath(@NotNull Field field, @Nullable String parentPath) {
+        @NotNull String parent = parentPath != null ? parentPath + "." : "";
+        boolean fromRoot = false;
+
+        // 先获取 Field 对应的路径注解 其优先度最高。
+        ConfigPath pathAnnotation = field.getAnnotation(ConfigPath.class);
+        if (pathAnnotation != null) {
+            fromRoot = pathAnnotation.root();
+            if (pathAnnotation.value().length() > 0) {
+                return (fromRoot ? "" : parent) + pathAnnotation.value();
+            }
+        }
+
+        // 最后再通过 fieldName 自动生成路径
+        return (fromRoot ? "" : parent) + getPathFromName(field.getName());
+    }
+
+    /**
+     * 得到指定元素的配置名称。
+     * 采用 全小写，以“-”链接 的命名规则。
+     *
+     * @param name 源名称
+     * @return 全小写，以“-”链接 的 路径名称
+     */
+    public static String getPathFromName(String name) {
+        return name.replaceAll("[A-Z]", "-$0") // 将驼峰转换为蛇形;
+                .replaceAll("-(.*)", "$1") // 若首字母也为大写，则也会被转换，需要去掉第一个横线
+                .replaceAll("_-([A-Z])", "_$1") // 因为命名中可能包含 _，因此需要被特殊处理一下
+                .replaceAll("([a-z])-([A-Z])", "$1_$2") // 然后将非全大写命名的内容进行转换
+                .replace("-", "") // 移除掉多余的横线
+                .replace("_", "-") // 将下划线替换为横线
+                .toLowerCase(); // 最后转为全小写
     }
 
 

core/src/main/java/cc/carm/lib/configuration/core/ConfigurationRoot.java

@@ -1,4 +1,7 @@
 package cc.carm.lib.configuration.core;
 
+/**
+ * 配置文件类的根节点，用于标注该类用于记录配置文件中的配置信息。
+ */
 public abstract class ConfigurationRoot {
 }

core/src/main/java/cc/carm/lib/configuration/core/annotation/ConfigComment.java

@@ -1,17 +0,0 @@
-package cc.carm.lib.configuration.core.annotation;
-
-import org.jetbrains.annotations.NotNull;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-@Target({ElementType.TYPE, ElementType.FIELD})
-@Retention(RetentionPolicy.RUNTIME)
-public @interface ConfigComment {
-
-    @NotNull
-    String[] value() default "";
-
-}

core/src/main/java/cc/carm/lib/configuration/core/annotation/ConfigPath.java

@@ -1,14 +1,34 @@
 package cc.carm.lib.configuration.core.annotation;
 
+import cc.carm.lib.configuration.core.ConfigInitializer;
+
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+/**
+ * 用于标记对应类或参数的配置路径
+ */
 @Target({ElementType.TYPE, ElementType.FIELD})
 @Retention(RetentionPolicy.RUNTIME)
 public @interface ConfigPath {
 
-    String value();
+    /**
+     * 指定路径的值。
+     * 若不指定，则会通过 {@link ConfigInitializer#getPathFromName(String)} 自动生成当前路径的值。
+     *
+     * @return 路径的值
+     */
+    String value() default "";
+
+    /**
+     * 是否从根节点开始。
+     * <br>若为 false，则会自动添加上一个路径(如果有)到本节点的路径。
+     * <br>若为 true，则会从根节点开始直接设置本路径。
+     *
+     * @return 是否不继承上一路径，直接从根路径为开始
+     */
+    boolean root() default false;
 
 }

core/src/main/java/cc/carm/lib/configuration/core/annotation/HeaderComment.java

@@ -0,0 +1,39 @@
+package cc.carm.lib.configuration.core.annotation;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * 顶部注释，用于给对应配置的顶部添加注释，便于使用者阅读查看。
+ * <p>如：
+ * <blockquote><pre>
+ * # 注释第一行
+ * # 注释第二行
+ * foo: "bar"
+ * </pre></blockquote>
+ */
+@Target({ElementType.TYPE, ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface HeaderComment {
+
+    /**
+     * 注释内容，若内容长度为0则会视为一个空行。
+     * <p> 如 <b>{"foo","","bar"}</b>
+     * 会被添加为
+     * <blockquote><pre>
+     * # foo
+     *
+     * # bar
+     * foo: "bar"
+     * </pre></blockquote>
+     *
+     * @return 注释内容
+     */
+    @NotNull
+    String[] value() default "";
+
+}

core/src/main/java/cc/carm/lib/configuration/core/annotation/InlineComment.java

@@ -0,0 +1,33 @@
+package cc.carm.lib.configuration.core.annotation;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * 行内注释，用于给对应配置的所在行添加注释，便于使用者阅读查看。
+ * 如：
+ * <blockquote><pre>
+ * foo: "bar" # 注释内容
+ * </pre></blockquote>
+ */
+@Target({ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface InlineComment {
+
+    /**
+     * 注释内容，若内容长度为0则不会添加注释
+     * <p> 如 <b>"foobar"</b> 将被设定为
+     * <blockquote><pre>
+     * foo: "bar" # foobar
+     * </pre></blockquote>
+     *
+     * @return 注释内容
+     */
+    @NotNull
+    String value() default "";
+
+}

core/src/main/java/cc/carm/lib/configuration/core/builder/AbstractConfigBuilder.java

@@ -1,24 +1,36 @@
 package cc.carm.lib.configuration.core.builder;
 
 import cc.carm.lib.configuration.core.source.ConfigurationProvider;
+import cc.carm.lib.configuration.core.value.ValueManifest;
 import cc.carm.lib.configuration.core.value.ConfigValue;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-public abstract class AbstractConfigBuilder<B extends AbstractConfigBuilder<B, T>, T> {
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Supplier;
 
+public abstract class AbstractConfigBuilder<T, B extends AbstractConfigBuilder<T, B, P>, P extends ConfigurationProvider<?>> {
 
-    protected @Nullable ConfigurationProvider provider;
+    protected final Class<? super P> providerClass;
+
+    protected @Nullable P provider;
     protected @Nullable String path;
 
-    protected @NotNull String[] comments = new String[0];
+    protected @Nullable List<String> headerComments;
+    protected @Nullable String inlineComment;
+
     protected @Nullable T defaultValue;
 
+    public AbstractConfigBuilder(Class<? super P> providerClass) {
+        this.providerClass = providerClass;
+    }
+
     protected abstract @NotNull B getThis();
 
     public abstract @NotNull ConfigValue<?> build();
 
-    public @NotNull B from(@Nullable ConfigurationProvider provider) {
+    public @NotNull B from(@Nullable P provider) {
         this.provider = provider;
         return getThis();
     }
@@ -29,7 +41,20 @@ public abstract class AbstractConfigBuilder<B extends AbstractConfigBuilder<B, T
     }
 
     public @NotNull B comments(@NotNull String... comments) {
-        this.comments = comments;
+        return headerComments(comments);
+    }
+
+    public @NotNull B headerComments(@NotNull String... comments) {
+        return headerComments(Arrays.asList(comments));
+    }
+
+    public @NotNull B headerComments(@NotNull List<String> comments) {
+        this.headerComments = comments;
+        return getThis();
+    }
+
+    public @NotNull B inlineComment(@NotNull String comment) {
+        this.inlineComment = comment;
         return getThis();
     }
 
@@ -38,5 +63,15 @@ public abstract class AbstractConfigBuilder<B extends AbstractConfigBuilder<B, T
         return getThis();
     }
 
+    public @NotNull B defaults(@NotNull Supplier<@Nullable T> defaultValueSupplier) {
+        return defaults(defaultValueSupplier.get());
+    }
+
+    protected @NotNull ValueManifest<T> buildManifest() {
+        return ValueManifest.of(
+                this.provider, this.path,
+                this.headerComments, this.inlineComment, this.defaultValue
+        );
+    }
 
 }

core/src/main/java/cc/carm/lib/configuration/core/builder/CommonConfigBuilder.java

@@ -0,0 +1,12 @@
+package cc.carm.lib.configuration.core.builder;
+
+import cc.carm.lib.configuration.core.source.ConfigurationProvider;
+
+public abstract class CommonConfigBuilder<T, B extends CommonConfigBuilder<T, B>>
+        extends AbstractConfigBuilder<T, B, ConfigurationProvider<?>> {
+
+    public CommonConfigBuilder() {
+        super(ConfigurationProvider.class);
+    }
+
+}

core/src/main/java/cc/carm/lib/configuration/core/builder/ConfigBuilder.java

@@ -2,6 +2,7 @@ package cc.carm.lib.configuration.core.builder;
 
 import cc.carm.lib.configuration.core.builder.list.ConfigListBuilder;
 import cc.carm.lib.configuration.core.builder.map.ConfigMapBuilder;
+import cc.carm.lib.configuration.core.builder.map.ConfigMapCreator;
 import cc.carm.lib.configuration.core.builder.value.ConfigValueBuilder;
 import org.jetbrains.annotations.NotNull;
 
@@ -11,32 +12,32 @@ import java.util.TreeMap;
 
 public class ConfigBuilder {
 
-    public static <V> @NotNull ConfigValueBuilder<V> asValue(@NotNull Class<V> valueClass) {
+    public <V> @NotNull ConfigValueBuilder<V> asValue(@NotNull Class<V> valueClass) {
         return new ConfigValueBuilder<>(valueClass);
     }
 
-    public static <V> @NotNull ConfigListBuilder<V> asList(@NotNull Class<V> valueClass) {
+    public <V> @NotNull ConfigListBuilder<V> asList(@NotNull Class<V> valueClass) {
         return new ConfigListBuilder<>(valueClass);
     }
 
-    public static <K, V> @NotNull ConfigMapBuilder<LinkedHashMap<K, V>, K, V> asMap(@NotNull Class<K> keyClass,
-                                                                                    @NotNull Class<V> valueClass) {
-        return new ConfigMapBuilder<>(LinkedHashMap::new, keyClass, valueClass);
+    public <K, V> @NotNull ConfigMapCreator<K, V> asMap(@NotNull Class<K> keyClass,
+                                                        @NotNull Class<V> valueClass) {
+        return new ConfigMapCreator<>(keyClass, valueClass);
     }
 
-    public static <K, V> @NotNull ConfigMapBuilder<HashMap<K, V>, K, V> asHashMap(@NotNull Class<K> keyClass,
-                                                                                  @NotNull Class<V> valueClass) {
-        return asMap(keyClass, valueClass).supplier(HashMap::new);
+    public <K, V> @NotNull ConfigMapBuilder<HashMap<K, V>, K, V> asHashMap(@NotNull Class<K> keyClass,
+                                                                           @NotNull Class<V> valueClass) {
+        return asMap(keyClass, valueClass).asHashMap();
     }
 
-    public static <K, V> @NotNull ConfigMapBuilder<LinkedHashMap<K, V>, K, V> asLinkedMap(@NotNull Class<K> keyClass,
-                                                                                          @NotNull Class<V> valueClass) {
-        return asMap(keyClass, valueClass);
+    public <K, V> @NotNull ConfigMapBuilder<LinkedHashMap<K, V>, K, V> asLinkedMap(@NotNull Class<K> keyClass,
+                                                                                   @NotNull Class<V> valueClass) {
+        return asMap(keyClass, valueClass).asLinkedMap();
     }
 
-    public static <K extends Comparable<K>, V> @NotNull ConfigMapBuilder<TreeMap<K, V>, K, V> asTreeMap(@NotNull Class<K> keyClass,
-                                                                                                        @NotNull Class<V> valueClass) {
-        return asMap(keyClass, valueClass).supplier(TreeMap::new);
+    public <K extends Comparable<K>, V> @NotNull ConfigMapBuilder<TreeMap<K, V>, K, V> asTreeMap(@NotNull Class<K> keyClass,
+                                                                                                 @NotNull Class<V> valueClass) {
+        return asMap(keyClass, valueClass).asTreeMap();
     }
 
 }

core/src/main/java/cc/carm/lib/configuration/core/builder/list/ConfigListBuilder.java

@@ -3,6 +3,9 @@ package cc.carm.lib.configuration.core.builder.list;
 import cc.carm.lib.configuration.core.function.ConfigDataFunction;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.Map;
+
+
 public class ConfigListBuilder<V> {
 
     protected final @NotNull Class<V> valueClass;
@@ -11,7 +14,7 @@ public class ConfigListBuilder<V> {
         this.valueClass = valueClass;
     }
 
-    public @NotNull <S> SourceListBuilder<S, V> from(@NotNull Class<S> sourceClass,
+    public @NotNull <S> SourceListBuilder<S, V> from(@NotNull Class<? super S> sourceClass,
                                                      @NotNull ConfigDataFunction<Object, S> sourceParser,
                                                      @NotNull ConfigDataFunction<S, V> valueParser,
                                                      @NotNull ConfigDataFunction<V, S> valueSerializer,
@@ -31,7 +34,7 @@ public class ConfigListBuilder<V> {
         return from(
                 Object.class, ConfigDataFunction.identity(),
                 ConfigDataFunction.castObject(valueClass),
-                ConfigDataFunction.identity(), ConfigDataFunction.toObject()
+                ConfigDataFunction.toObject(), ConfigDataFunction.toObject()
         );
     }
 
@@ -43,4 +46,13 @@ public class ConfigListBuilder<V> {
         );
     }
 
+    public @NotNull SourceListBuilder<Map<String, Object>, V> fromMap() {
+        return from(
+                Map.class, obj -> (Map<String, Object>) obj,
+                ConfigDataFunction.required(),
+                ConfigDataFunction.required(),
+                ConfigDataFunction.toObject()
+        );
+    }
+
 }

core/src/main/java/cc/carm/lib/configuration/core/builder/list/SourceListBuilder.java

@@ -1,16 +1,18 @@
 package cc.carm.lib.configuration.core.builder.list;
 
-import cc.carm.lib.configuration.core.builder.AbstractConfigBuilder;
+import cc.carm.lib.configuration.core.builder.CommonConfigBuilder;
 import cc.carm.lib.configuration.core.function.ConfigDataFunction;
 import cc.carm.lib.configuration.core.value.type.ConfiguredList;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
 
-public class SourceListBuilder<S, V>
-        extends AbstractConfigBuilder<SourceListBuilder<S, V>, List<V>> {
+public class SourceListBuilder<S, V> extends CommonConfigBuilder<List<V>, SourceListBuilder<S, V>> {
 
-    protected final @NotNull Class<S> sourceClass;
+    protected final @NotNull Class<? super S> sourceClass;
     protected @NotNull ConfigDataFunction<Object, S> sourceParser;
 
     protected final @NotNull Class<V> valueClass;
@@ -19,7 +21,7 @@ public class SourceListBuilder<S, V>
     protected @NotNull ConfigDataFunction<V, S> valueSerializer;
     protected @NotNull ConfigDataFunction<S, Object> sourceSerializer;
 
-    public SourceListBuilder(@NotNull Class<S> sourceClass, @NotNull ConfigDataFunction<Object, S> sourceParser,
+    public SourceListBuilder(@NotNull Class<? super S> sourceClass, @NotNull ConfigDataFunction<Object, S> sourceParser,
                              @NotNull Class<V> valueClass, @NotNull ConfigDataFunction<S, V> valueParser,
                              @NotNull ConfigDataFunction<V, S> valueSerializer,
                              @NotNull ConfigDataFunction<S, Object> sourceSerializer) {
@@ -31,6 +33,15 @@ public class SourceListBuilder<S, V>
         this.valueSerializer = valueSerializer;
     }
 
+    @SafeVarargs
+    public final @NotNull SourceListBuilder<S, V> defaults(@NotNull V... values) {
+        return defaults(new ArrayList<>(Arrays.asList(values)));
+    }
+
+    public final @NotNull SourceListBuilder<S, V> defaults(@NotNull Collection<V> values) {
+        return defaults(new ArrayList<>(values));
+    }
+
     public @NotNull SourceListBuilder<S, V> parseSource(ConfigDataFunction<Object, S> sourceParser) {
         this.sourceParser = sourceParser;
         return this;
@@ -59,8 +70,7 @@ public class SourceListBuilder<S, V>
     @Override
     public @NotNull ConfiguredList<V> build() {
         return new ConfiguredList<>(
-                this.provider, this.path, this.comments,
-                this.valueClass, this.defaultValue,
+                buildManifest(), this.valueClass,
                 this.sourceParser.andThen(this.valueParser),
                 this.valueSerializer.andThen(sourceSerializer)
         );

core/src/main/java/cc/carm/lib/configuration/core/builder/map/ConfigMapBuilder.java

@@ -48,6 +48,14 @@ public class ConfigMapBuilder<M extends Map<K, V>, K, V> {
         return fromString(ConfigDataFunction.castFromString(this.valueClass));
     }
 
+    public SectionMapBuilder<M, K, V> fromSection() {
+        return new SectionMapBuilder<>(
+                supplier,
+                keyClass, ConfigDataFunction.castFromString(keyClass),
+                valueClass, ConfigDataFunction.required(),
+                ConfigDataFunction.castToString(), ConfigDataFunction.required());
+    }
+
     public SourceMapBuilder<M, Object, K, V> fromObject(@NotNull ConfigDataFunction<Object, V> valueParser) {
         return from(Object.class, valueParser, ConfigDataFunction.toObject());
     }

core/src/main/java/cc/carm/lib/configuration/core/builder/map/ConfigMapCreator.java

@@ -0,0 +1,37 @@
+package cc.carm.lib.configuration.core.builder.map;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.function.Supplier;
+
+public class ConfigMapCreator<K, V> {
+
+    protected final @NotNull Class<K> keyClass;
+    protected final @NotNull Class<V> valueClass;
+
+    public ConfigMapCreator(@NotNull Class<K> keyClass, @NotNull Class<V> valueClass) {
+        this.keyClass = keyClass;
+        this.valueClass = valueClass;
+    }
+
+    public <M extends Map<K, V>> @NotNull ConfigMapBuilder<M, K, V> asMap(Supplier<M> mapSuppler) {
+        return new ConfigMapBuilder<>(mapSuppler, keyClass, valueClass);
+    }
+
+    public @NotNull ConfigMapBuilder<HashMap<K, V>, K, V> asHashMap() {
+        return asMap(HashMap::new);
+    }
+
+    public @NotNull ConfigMapBuilder<LinkedHashMap<K, V>, K, V> asLinkedMap() {
+        return asMap(LinkedHashMap::new);
+    }
+
+    public @NotNull ConfigMapBuilder<TreeMap<K, V>, K, V> asTreeMap() {
+        return asMap(TreeMap::new);
+    }
+
+}

core/src/main/java/cc/carm/lib/configuration/core/builder/map/SectionMapBuilder.java

@@ -0,0 +1,99 @@
+package cc.carm.lib.configuration.core.builder.map;
+
+import cc.carm.lib.configuration.core.builder.CommonConfigBuilder;
+import cc.carm.lib.configuration.core.function.ConfigDataFunction;
+import cc.carm.lib.configuration.core.source.ConfigurationWrapper;
+import cc.carm.lib.configuration.core.value.ValueManifest;
+import cc.carm.lib.configuration.core.value.type.ConfiguredSectionMap;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class SectionMapBuilder<M extends Map<K, V>, K, V> extends CommonConfigBuilder<M, SectionMapBuilder<M, K, V>> {
+
+    protected final @NotNull Supplier<@NotNull M> supplier;
+
+    protected final @NotNull Class<K> keyClass;
+    protected @NotNull ConfigDataFunction<String, K> keyParser;
+
+    protected final @NotNull Class<V> valueClass;
+    protected @NotNull ConfigDataFunction<ConfigurationWrapper<?>, V> valueParser;
+
+    protected @NotNull ConfigDataFunction<K, String> keySerializer;
+    protected @NotNull ConfigDataFunction<V, ? extends Map<String, Object>> valueSerializer;
+
+    public SectionMapBuilder(@NotNull Supplier<@NotNull M> supplier,
+                             @NotNull Class<K> keyClass, @NotNull ConfigDataFunction<String, K> keyParser,
+                             @NotNull Class<V> valueClass, @NotNull ConfigDataFunction<ConfigurationWrapper<?>, V> valueParser,
+                             @NotNull ConfigDataFunction<K, String> keySerializer,
+                             @NotNull ConfigDataFunction<V, ? extends Map<String, Object>> valueSerializer) {
+        this.supplier = supplier;
+        this.keyClass = keyClass;
+        this.keyParser = keyParser;
+        this.valueClass = valueClass;
+        this.valueParser = valueParser;
+        this.keySerializer = keySerializer;
+        this.valueSerializer = valueSerializer;
+    }
+
+    public <MAP extends Map<K, V>> SectionMapBuilder<MAP, K, V> supplier(@NotNull Supplier<MAP> supplier) {
+        return new SectionMapBuilder<>(supplier,
+                keyClass, keyParser, valueClass, valueParser, keySerializer, valueSerializer
+        );
+    }
+
+    public @NotNull SectionMapBuilder<M, K, V> defaults(@NotNull Consumer<M> factory) {
+        M map = supplier.get();
+        factory.accept(map);
+        return defaults(map);
+    }
+
+    public @NotNull SectionMapBuilder<M, K, V> parseKey(@NotNull ConfigDataFunction<String, K> parser) {
+        this.keyParser = parser;
+        return this;
+    }
+
+    public @NotNull SectionMapBuilder<M, K, V> parseValue(@NotNull ConfigDataFunction<ConfigurationWrapper<?>, V> parser) {
+        this.valueParser = parser;
+        return this;
+    }
+
+    public @NotNull SectionMapBuilder<M, K, V> serializeKey(@NotNull ConfigDataFunction<K, String> serializer) {
+        this.keySerializer = serializer;
+        return this;
+    }
+
+    public @NotNull SectionMapBuilder<M, K, V> serializeValue(@NotNull ConfigDataFunction<V, ? extends Map<String, Object>> serializer) {
+        this.valueSerializer = serializer;
+        return this;
+    }
+
+    public @NotNull SectionMapBuilder<M, K, V> serializeValue(@NotNull BiConsumer<V, Map<String, Object>> serializer) {
+        return serializeValue(v -> {
+            Map<String, Object> map = new LinkedHashMap<>();
+            serializer.accept(v, map);
+            return map;
+        });
+    }
+
+
+    @Override
+    protected @NotNull SectionMapBuilder<M, K, V> getThis() {
+        return this;
+    }
+
+    @Override
+    public @NotNull ConfiguredSectionMap<K, V> build() {
+        return new ConfiguredSectionMap<>(
+                new ValueManifest<>(provider, path, headerComments, inlineComment, defaultValue),
+                this.supplier, this.keyClass, this.keyParser,
+                this.valueClass, this.valueParser,
+                this.keySerializer, this.valueSerializer
+        );
+    }
+
+}

core/src/main/java/cc/carm/lib/configuration/core/builder/map/SourceMapBuilder.java

@@ -1,15 +1,16 @@
 package cc.carm.lib.configuration.core.builder.map;
 
-import cc.carm.lib.configuration.core.builder.AbstractConfigBuilder;
+import cc.carm.lib.configuration.core.builder.CommonConfigBuilder;
 import cc.carm.lib.configuration.core.function.ConfigDataFunction;
+import cc.carm.lib.configuration.core.value.ValueManifest;
 import cc.carm.lib.configuration.core.value.type.ConfiguredMap;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Map;
+import java.util.function.Consumer;
 import java.util.function.Supplier;
 
-public class SourceMapBuilder<M extends Map<K, V>, S, K, V>
-        extends AbstractConfigBuilder<SourceMapBuilder<M, S, K, V>, M> {
+public class SourceMapBuilder<M extends Map<K, V>, S, K, V> extends CommonConfigBuilder<M, SourceMapBuilder<M, S, K, V>> {
 
     protected final @NotNull Supplier<@NotNull M> supplier;
 
@@ -52,6 +53,12 @@ public class SourceMapBuilder<M extends Map<K, V>, S, K, V>
         );
     }
 
+    public @NotNull SourceMapBuilder<M, S, K, V> defaults(@NotNull Consumer<M> factory) {
+        M map = supplier.get();
+        factory.accept(map);
+        return defaults(map);
+    }
+
     public @NotNull SourceMapBuilder<M, S, K, V> parseKey(@NotNull ConfigDataFunction<String, K> parser) {
         this.keyParser = parser;
         return this;
@@ -90,9 +97,8 @@ public class SourceMapBuilder<M extends Map<K, V>, S, K, V>
     @Override
     public @NotNull ConfiguredMap<K, V> build() {
         return new ConfiguredMap<>(
-                this.provider, this.path, this.comments,
-                this.defaultValue, this.supplier,
-                this.keyClass, this.keyParser,
+                new ValueManifest<>(provider, path, headerComments, inlineComment, defaultValue),
+                this.supplier, this.keyClass, this.keyParser,
                 this.valueClass, this.sourceParser.andThen(this.valueParser),
                 this.keySerializer, this.valueSerializer.andThen(this.sourceSerializer)
         );

core/src/main/java/cc/carm/lib/configuration/core/builder/value/ConfigValueBuilder.java

@@ -19,7 +19,7 @@ public class ConfigValueBuilder<V> {
         return fromSection(ConfigValueParser.required(), ConfigDataFunction.required());
     }
 
-    public @NotNull SectionValueBuilder<V> fromSection(@NotNull ConfigValueParser<ConfigurationWrapper, V> valueParser,
+    public @NotNull SectionValueBuilder<V> fromSection(@NotNull ConfigValueParser<ConfigurationWrapper<?>, V> valueParser,
                                                        @NotNull ConfigDataFunction<V, ? extends Map<String, Object>> valueSerializer) {
         return new SectionValueBuilder<>(this.valueClass, valueParser, valueSerializer);
     }
@@ -46,7 +46,10 @@ public class ConfigValueBuilder<V> {
         return from(
                 Object.class, ConfigDataFunction.identity(),
                 ConfigValueParser.castObject(valueClass),
-                ConfigDataFunction.identity(), ConfigDataFunction.toObject()
+                s -> {
+                    if (s instanceof Enum<?>) return ((Enum<?>) s).name();
+                    else return s;
+                }, ConfigDataFunction.toObject()
         );
     }
 

core/src/main/java/cc/carm/lib/configuration/core/builder/value/SectionValueBuilder.java

@@ -1,6 +1,6 @@
 package cc.carm.lib.configuration.core.builder.value;
 
-import cc.carm.lib.configuration.core.builder.AbstractConfigBuilder;
+import cc.carm.lib.configuration.core.builder.CommonConfigBuilder;
 import cc.carm.lib.configuration.core.function.ConfigDataFunction;
 import cc.carm.lib.configuration.core.function.ConfigValueParser;
 import cc.carm.lib.configuration.core.source.ConfigurationWrapper;
@@ -10,16 +10,16 @@ import org.jetbrains.annotations.NotNull;
 import java.util.Map;
 
 public class SectionValueBuilder<V>
-        extends AbstractConfigBuilder<SectionValueBuilder<V>, V> {
+        extends CommonConfigBuilder<V, SectionValueBuilder<V>> {
 
 
     protected final @NotNull Class<V> valueClass;
 
-    protected @NotNull ConfigValueParser<ConfigurationWrapper, V> parser;
+    protected @NotNull ConfigValueParser<ConfigurationWrapper<?>, V> parser;
     protected @NotNull ConfigDataFunction<V, ? extends Map<String, Object>> serializer;
 
     public SectionValueBuilder(@NotNull Class<V> valueClass,
-                               @NotNull ConfigValueParser<ConfigurationWrapper, V> parser,
+                               @NotNull ConfigValueParser<ConfigurationWrapper<?>, V> parser,
                                @NotNull ConfigDataFunction<V, ? extends Map<String, Object>> serializer) {
         this.valueClass = valueClass;
         this.parser = parser;
@@ -32,7 +32,11 @@ public class SectionValueBuilder<V>
         return this;
     }
 
-    public @NotNull SectionValueBuilder<V> parseValue(ConfigValueParser<ConfigurationWrapper, V> valueParser) {
+    public @NotNull SectionValueBuilder<V> parseValue(ConfigDataFunction<ConfigurationWrapper<?>, V> valueParser) {
+        return parseValue((section, path) -> valueParser.parse(section));
+    }
+
+    public @NotNull SectionValueBuilder<V> parseValue(ConfigValueParser<ConfigurationWrapper<?>, V> valueParser) {
         this.parser = valueParser;
         return this;
     }
@@ -44,11 +48,7 @@ public class SectionValueBuilder<V>
 
     @Override
     public @NotNull ConfiguredSection<V> build() {
-        return new ConfiguredSection<>(
-                this.provider, this.path, this.comments,
-                this.valueClass, this.defaultValue,
-                this.parser, this.serializer
-        );
+        return new ConfiguredSection<>(buildManifest(), this.valueClass, this.parser, this.serializer);
     }
 
 }

core/src/main/java/cc/carm/lib/configuration/core/builder/value/SourceValueBuilder.java

@@ -1,12 +1,12 @@
 package cc.carm.lib.configuration.core.builder.value;
 
-import cc.carm.lib.configuration.core.builder.AbstractConfigBuilder;
+import cc.carm.lib.configuration.core.builder.CommonConfigBuilder;
 import cc.carm.lib.configuration.core.function.ConfigDataFunction;
 import cc.carm.lib.configuration.core.function.ConfigValueParser;
 import cc.carm.lib.configuration.core.value.type.ConfiguredValue;
 import org.jetbrains.annotations.NotNull;
 
-public class SourceValueBuilder<S, V> extends AbstractConfigBuilder<SourceValueBuilder<S, V>, V> {
+public class SourceValueBuilder<S, V> extends CommonConfigBuilder<V, SourceValueBuilder<S, V>> {
 
     protected final @NotNull Class<S> sourceClass;
     protected @NotNull ConfigDataFunction<Object, S> sourceParser;
@@ -39,6 +39,10 @@ public class SourceValueBuilder<S, V> extends AbstractConfigBuilder<SourceValueB
         return this;
     }
 
+    public @NotNull SourceValueBuilder<S, V> parseValue(ConfigDataFunction<S, V> valueParser) {
+        return parseValue((section, path) -> valueParser.parse(section));
+    }
+
     public @NotNull SourceValueBuilder<S, V> parseValue(@NotNull ConfigValueParser<S, V> valueParser) {
         this.valueParser = valueParser;
         return this;
@@ -57,8 +61,7 @@ public class SourceValueBuilder<S, V> extends AbstractConfigBuilder<SourceValueB
     @Override
     public @NotNull ConfiguredValue<V> build() {
         return new ConfiguredValue<>(
-                this.provider, this.path, this.comments,
-                this.valueClass, this.defaultValue,
+                buildManifest(), this.valueClass,
                 this.valueParser.compose(this.sourceParser),
                 this.valueSerializer.andThen(sourceSerializer)
         );

core/src/main/java/cc/carm/lib/configuration/core/function/ConfigDataFunction.java

@@ -13,30 +13,34 @@ public interface ConfigDataFunction<T, R> {
 
     default <V> @NotNull ConfigDataFunction<T, V> andThen(@NotNull ConfigDataFunction<? super R, V> after) {
         Objects.requireNonNull(after);
-        return ((data) -> after.parse(parse(data)));
+        return data -> after.parse(parse(data));
     }
 
     @Contract(pure = true)
-    static <T> @NotNull ConfigDataFunction<T, ? super T> identity() {
-        return (input) -> input;
+    static <T> @NotNull ConfigDataFunction<T, T> identity() {
+        return input -> input;
+    }
+
+    @Contract(pure = true)
+    static <T> @NotNull ConfigDataFunction<T, T> identity(Class<T> type) {
+        return input -> input;
     }
 
     @Contract(pure = true)
     static <T, V> @NotNull ConfigDataFunction<T, V> required() {
-        return (input) -> {
+        return input -> {
             throw new IllegalArgumentException("Please specify the value parser.");
         };
     }
 
     @Contract(pure = true)
     static <T> @NotNull ConfigDataFunction<T, Object> toObject() {
-        return (input) -> input;
+        return input -> input;
     }
 
-
     @Contract(pure = true)
     static <V> @NotNull ConfigDataFunction<Object, V> castObject(Class<V> valueClass) {
-        return (input) -> {
+        return input -> {
             if (valueClass.isInstance(input)) return valueClass.cast(input);
             else throw new IllegalArgumentException("Cannot cast value to " + valueClass.getName());
         };
@@ -44,7 +48,7 @@ public interface ConfigDataFunction<T, R> {
 
     @Contract(pure = true)
     static <V> @NotNull ConfigDataFunction<String, V> castFromString(Class<V> valueClass) {
-        return (input) -> {
+        return input -> {
             if (valueClass.isInstance(input)) return valueClass.cast(input);
             else throw new IllegalArgumentException("Cannot cast string to " + valueClass.getName());
         };
@@ -52,12 +56,101 @@ public interface ConfigDataFunction<T, R> {
 
     @Contract(pure = true)
     static <T> @NotNull ConfigDataFunction<T, String> castToString() {
-        return (input) -> {
+        return input -> {
             if (input instanceof String) return (String) input;
+            else if (input instanceof Enum<?>) return ((Enum<?>) input).name();
             else return input.toString();
         };
     }
 
+    @Contract(pure = true)
+    static <V> @NotNull ConfigDataFunction<String, V> parseString(Class<V> valueClass) {
+        return input -> {
+            if (valueClass.isInstance(input)) return valueClass.cast(input);
+            else throw new IllegalArgumentException("Cannot cast string to " + valueClass.getName());
+        };
+    }
+
+    @Contract(pure = true)
+    static @NotNull ConfigDataFunction<Object, Integer> intValue() {
+        return input -> {
+            if (input instanceof Integer) {
+                return (Integer) input;
+            } else if (input instanceof Number) {
+                return ((Number) input).intValue();
+            } else throw new IllegalArgumentException("Cannot cast value to " + Integer.class.getName());
+        };
+    }
+
+    @Contract(pure = true)
+    static @NotNull ConfigDataFunction<Object, Short> shortValue() {
+        return input -> {
+            if (input instanceof Short) {
+                return (Short) input;
+            } else if (input instanceof Number) {
+                return ((Number) input).shortValue();
+            } else throw new IllegalArgumentException("Cannot cast value to " + Short.class.getName());
+        };
+    }
+
+    @Contract(pure = true)
+    static @NotNull ConfigDataFunction<Object, Double> doubleValue() {
+        return input -> {
+            if (input instanceof Double) {
+                return (Double) input;
+            } else if (input instanceof Number) {
+                return ((Number) input).doubleValue();
+            } else throw new IllegalArgumentException("Cannot cast value to " + Double.class.getName());
+        };
+    }
+
+    @Contract(pure = true)
+    static @NotNull ConfigDataFunction<Object, Byte> byteValue() {
+        return input -> {
+            if (input instanceof Byte) {
+                return (Byte) input;
+            } else if (input instanceof Number) {
+                return ((Number) input).byteValue();
+            } else throw new IllegalArgumentException("Cannot cast value to " + Byte.class.getName());
+        };
+    }
+
+    @Contract(pure = true)
+    static @NotNull ConfigDataFunction<Object, Float> floatValue() {
+        return input -> {
+            if (input instanceof Float) {
+                return (Float) input;
+            } else if (input instanceof Number) {
+                return ((Number) input).floatValue();
+            } else throw new IllegalArgumentException("Cannot cast value to " + Float.class.getName());
+        };
+    }
+
+    @Contract(pure = true)
+    static @NotNull ConfigDataFunction<Object, Long> longValue() {
+        return input -> {
+            if (input instanceof Long) {
+                return (Long) input;
+            } else if (input instanceof Number) {
+                return ((Number) input).longValue();
+            } else throw new IllegalArgumentException("Cannot cast value to " + Long.class.getName());
+        };
+    }
+
+    @Contract(pure = true)
+    static @NotNull ConfigDataFunction<Object, Boolean> booleanValue() {
+        return input -> {
+            if (input instanceof Boolean) {
+                return (Boolean) input;
+            } else if (input instanceof String) {
+                String s = (String) input;
+                return Boolean.parseBoolean(s) || "yes".equalsIgnoreCase(s);
+            } else if (input instanceof Integer) {
+                return (Integer) input == 1;
+            } else throw new IllegalArgumentException("Cannot cast value to " + Boolean.class.getName());
+        };
+    }
+
 
 }
 

core/src/main/java/cc/carm/lib/configuration/core/function/ConfigValueParser.java

@@ -50,6 +50,28 @@ public interface ConfigValueParser<T, R> {
     @Contract(pure = true)
     static <V> @NotNull ConfigValueParser<Object, V> castObject(Class<V> valueClass) {
         return (input, defaultValue) -> {
+
+            if (Number.class.isAssignableFrom(valueClass)) {
+                if (Long.class.isAssignableFrom(valueClass)) {
+                    input = longValue().parse(input, (Long) defaultValue);
+                } else if (Integer.class.isAssignableFrom(valueClass)) {
+                    input = intValue().parse(input, (Integer) defaultValue);
+                } else if (Float.class.isAssignableFrom(valueClass)) {
+                    input = floatValue().parse(input, (Float) defaultValue);
+                } else if (Double.class.isAssignableFrom(valueClass)) {
+                    input = doubleValue().parse(input, (Double) defaultValue);
+                } else if (Byte.class.isAssignableFrom(valueClass)) {
+                    input = byteValue().parse(input, (Byte) defaultValue);
+                } else if (Short.class.isAssignableFrom(valueClass)) {
+                    input = shortValue().parse(input, (Short) defaultValue);
+                }
+            } else if (Boolean.class.isAssignableFrom(valueClass)) {
+                input = booleanValue().parse(input, (Boolean) defaultValue);
+            } else if (Enum.class.isAssignableFrom(valueClass) && input instanceof String) {
+                String enumName = (String) input;
+                input = valueClass.getDeclaredMethod("valueOf", String.class).invoke(null, enumName);
+            }
+
             if (valueClass.isInstance(input)) return valueClass.cast(input);
             else throw new IllegalArgumentException("Cannot cast value to " + valueClass.getName());
         };
@@ -71,91 +93,53 @@ public interface ConfigValueParser<T, R> {
         };
     }
 
-    @Contract(pure = true)
-    static @NotNull <T> ConfigValueParser<T, String> castToString(Class<T> clazz) {
-        return (input, defaultValue) -> {
-            if (input instanceof String) return (String) input;
-            else return input.toString();
-        };
-    }
-
     @Contract(pure = true)
     static @NotNull ConfigValueParser<Object, Integer> intValue() {
-        return (input, defaultValue) -> {
-            if (input instanceof Integer) {
-                return (Integer) input;
-            } else if (input instanceof Number) {
-                return ((Number) input).intValue();
-            } else throw new IllegalArgumentException("Cannot cast value to " + Integer.class.getName());
-        };
+        return (input, defaultValue) -> ConfigDataFunction.intValue().parse(input);
     }
 
     @Contract(pure = true)
     static @NotNull ConfigValueParser<Object, Short> shortValue() {
-        return (input, defaultValue) -> {
-            if (input instanceof Short) {
-                return (Short) input;
-            } else if (input instanceof Number) {
-                return ((Number) input).shortValue();
-            } else throw new IllegalArgumentException("Cannot cast value to " + Short.class.getName());
-        };
+        return (input, defaultValue) -> ConfigDataFunction.shortValue().parse(input);
     }
 
     @Contract(pure = true)
     static @NotNull ConfigValueParser<Object, Double> doubleValue() {
-        return (input, defaultValue) -> {
-            if (input instanceof Double) {
-                return (Double) input;
-            } else if (input instanceof Number) {
-                return ((Number) input).doubleValue();
-            } else throw new IllegalArgumentException("Cannot cast value to " + Double.class.getName());
-        };
+        return (input, defaultValue) -> ConfigDataFunction.doubleValue().parse(input);
     }
 
     @Contract(pure = true)
     static @NotNull ConfigValueParser<Object, Byte> byteValue() {
-        return (input, defaultValue) -> {
-            if (input instanceof Byte) {
-                return (Byte) input;
-            } else if (input instanceof Number) {
-                return ((Number) input).byteValue();
-            } else throw new IllegalArgumentException("Cannot cast value to " + Byte.class.getName());
-        };
+        return (input, defaultValue) -> ConfigDataFunction.byteValue().parse(input);
     }
 
     @Contract(pure = true)
     static @NotNull ConfigValueParser<Object, Float> floatValue() {
-        return (input, defaultValue) -> {
-            if (input instanceof Float) {
-                return (Float) input;
-            } else if (input instanceof Number) {
-                return ((Number) input).floatValue();
-            } else throw new IllegalArgumentException("Cannot cast value to " + Float.class.getName());
-        };
+        return (input, defaultValue) -> ConfigDataFunction.floatValue().parse(input);
     }
 
     @Contract(pure = true)
     static @NotNull ConfigValueParser<Object, Long> longValue() {
-        return (input, defaultValue) -> {
-            if (input instanceof Long) {
-                return (Long) input;
-            } else if (input instanceof Number) {
-                return ((Number) input).longValue();
-            } else throw new IllegalArgumentException("Cannot cast value to " + Long.class.getName());
-        };
+        return (input, defaultValue) -> ConfigDataFunction.longValue().parse(input);
     }
 
     @Contract(pure = true)
     static @NotNull ConfigValueParser<Object, Boolean> booleanValue() {
+        return (input, defaultValue) -> ConfigDataFunction.booleanValue().parse(input);
+    }
+
+    @Contract(pure = true)
+    static @NotNull <E extends Enum<E>> ConfigValueParser<Object, E> enumValue(Class<E> enumClass) {
         return (input, defaultValue) -> {
-            if (input instanceof Boolean) {
-                return (Boolean) input;
+            if (input instanceof Enum) {
+                return enumClass.cast(input);
             } else if (input instanceof String) {
-                String s = (String) input;
-                return Boolean.parseBoolean(s) || "yes".equalsIgnoreCase(s);
-            } else if (input instanceof Integer) {
-                return ((Integer) input) == 1;
-            } else throw new IllegalArgumentException("Cannot cast value to " + Boolean.class.getName());
+                return Enum.valueOf(enumClass, (String) input);
+            } else if (input instanceof Number) {
+                return enumClass.getEnumConstants()[((Number) input).intValue()];
+            } else {
+                throw new IllegalArgumentException("Cannot cast value to " + enumClass.getName());
+            }
         };
     }
 

core/src/main/java/cc/carm/lib/configuration/core/source/ConfigurationComments.java

@@ -0,0 +1,51 @@
+package cc.carm.lib.configuration.core.source;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.Unmodifiable;
+
+import java.util.*;
+
+public class ConfigurationComments {
+
+    protected final @NotNull Map<String, List<String>> headerComments = new HashMap<>();
+    protected final @NotNull Map<String, String> inlineComments = new HashMap<>();
+
+    protected @NotNull Map<String, List<String>> getHeaderComments() {
+        return headerComments;
+    }
+
+    protected @NotNull Map<String, String> getInlineComments() {
+        return inlineComments;
+    }
+
+    public void setHeaderComments(@Nullable String path, @Nullable List<String> comments) {
+
+        if (comments == null) {
+            getHeaderComments().remove(path);
+        } else {
+            getHeaderComments().put(path, comments);
+        }
+    }
+
+
+    public void setInlineComment(@NotNull String path, @Nullable String comment) {
+        if (comment == null) {
+            getInlineComments().remove(path);
+        } else {
+            getInlineComments().put(path, comment);
+        }
+    }
+
+    @Nullable
+    @Unmodifiable
+    public List<String> getHeaderComment(@Nullable String path) {
+        return Optional.ofNullable(getHeaderComments().get(path)).map(Collections::unmodifiableList).orElse(null);
+    }
+
+    public @Nullable String getInlineComment(@NotNull String path) {
+        return getInlineComments().get(path);
+    }
+
+
+}

core/src/main/java/cc/carm/lib/configuration/core/source/ConfigurationProvider.java

@@ -2,37 +2,149 @@ package cc.carm.lib.configuration.core.source;
 
 import cc.carm.lib.configuration.core.ConfigInitializer;
 import cc.carm.lib.configuration.core.ConfigurationRoot;
+import cc.carm.lib.configuration.core.value.ConfigValue;
+import cc.carm.lib.configuration.core.value.impl.CachedConfigValue;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.Unmodifiable;
 
-public abstract class ConfigurationProvider {
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * 配置文件提供者，用于为 {@link ConfigValue} 提供配置文件的源，以便实现读取、保存等操作。
+ *
+ * @param <W> 配置文件的原生功能类
+ */
+public abstract class ConfigurationProvider<W extends ConfigurationWrapper<?>> {
 
     protected long updateTime;
 
-    public ConfigurationProvider() {
+    protected ConfigurationProvider() {
         this.updateTime = System.currentTimeMillis();
     }
 
+    /**
+     * 得到配置文件的更新(最后加载)时间。
+     *
+     * @return 更新时间
+     */
     public long getUpdateTime() {
         return updateTime;
     }
 
+    /**
+     * 用于 {@link CachedConfigValue} 判断缓存值是否过期(即缓存的时间早于配置文件的最后加载时间)。
+     *
+     * @param time 缓存值时的时间戳
+     * @return 缓存值是否过期
+     */
     public boolean isExpired(long time) {
-        return this.updateTime > time;
+        return getUpdateTime() > time;
     }
 
-    public abstract @NotNull ConfigurationWrapper getConfiguration();
+    /**
+     * 得到配置文件的原生功能类。
+     *
+     * @return 原生类
+     */
+    public abstract @NotNull W getConfiguration();
 
-    public abstract void reload() throws Exception;
+    /**
+     * 重载当前配置文件。(将不会保存已修改的内容)
+     *
+     * @throws Exception 当重载出现错误时抛出
+     */
+    public void reload() throws Exception {
+        onReload(); // 调用重写的Reload方法
+        this.updateTime = System.currentTimeMillis();
+    }
 
+    /**
+     * 将当前对配置文件的更改进行保存。
+     *
+     * @throws Exception 当保存出现错误时抛出
+     */
     public abstract void save() throws Exception;
 
-    public abstract void setComments(@NotNull String path, @NotNull String... comments);
+    /**
+     * 针对于不同配置文件类型所执行的重载操作。
+     *
+     * @throws Exception 当操作出现错误时抛出。
+     */
+    protected abstract void onReload() throws Exception;
 
-    public abstract @Nullable String[] getComments(@NotNull String path);
+    public abstract @Nullable ConfigurationComments getComments();
 
+    public void setHeaderComment(@Nullable String path, @Nullable List<String> comments) {
+        if (getComments() == null) return;
+        getComments().setHeaderComments(path, comments);
+    }
+
+    public void setInlineComment(@NotNull String path, @Nullable String comment) {
+        if (getComments() == null) return;
+        getComments().setInlineComment(path, comment);
+    }
+
+    @Nullable
+    @Unmodifiable
+    public List<String> getHeaderComment(@Nullable String path) {
+        return Optional.ofNullable(getComments()).map(c -> c.getHeaderComment(path)).orElse(null);
+    }
+
+    public @Nullable String getInlineComment(@NotNull String path) {
+        return Optional.ofNullable(getComments()).map(c -> c.getInlineComment(path)).orElse(null);
+    }
+
+    public abstract @NotNull ConfigInitializer<? extends ConfigurationProvider<W>> getInitializer();
+
+    /**
+     * 初始化指定类以及其子类的所有 {@link ConfigValue} 对象。
+     *
+     * @param configClazz 配置文件类，须继承于 {@link ConfigurationRoot} 。
+     */
     public void initialize(Class<? extends ConfigurationRoot> configClazz) {
-        ConfigInitializer.initialize(this, configClazz, true);
+        initialize(configClazz, true);
+    }
+
+    /**
+     * 初始化指定类以及其子类的所有 {@link ConfigValue} 对象。
+     *
+     * @param configClazz  配置文件类，须继承于 {@link ConfigurationRoot} 。
+     * @param saveDefaults 是否写入默认值(默认为 true)。
+     */
+    public void initialize(Class<? extends ConfigurationRoot> configClazz, boolean saveDefaults) {
+        this.getInitializer().initialize(configClazz, saveDefaults);
+    }
+
+    /**
+     * 初始化指定类的所有 {@link ConfigValue} 对象。
+     *
+     * @param configClazz    配置文件类，须继承于 {@link ConfigurationRoot} 。
+     * @param saveDefaults   是否写入默认值(默认为 true)。
+     * @param loadSubClasses 是否加载内部子类(默认为 true)。
+     */
+    public void initialize(Class<? extends ConfigurationRoot> configClazz, boolean saveDefaults, boolean loadSubClasses) {
+        this.getInitializer().initialize(configClazz, saveDefaults, loadSubClasses);
+    }
+
+    /**
+     * 初始化指定实例的所有 {@link ConfigValue} 与内部 {@link ConfigurationRoot} 对象。
+     *
+     * @param config 配置文件实例类，须实现 {@link ConfigurationRoot} 。
+     */
+    public void initialize(@NotNull ConfigurationRoot config) {
+        this.getInitializer().initialize(config, true);
+    }
+
+    /**
+     * 初始化指定实例的所有 {@link ConfigValue} 与内部 {@link ConfigurationRoot} 对象。
+     *
+     * @param config       配置文件实例类，须实现 {@link ConfigurationRoot} 。
+     * @param saveDefaults 是否写入默认值(默认为 true)。
+     */
+    public void initialize(@NotNull ConfigurationRoot config, boolean saveDefaults) {
+        this.getInitializer().initialize(config, saveDefaults);
     }
 
 }

core/src/main/java/cc/carm/lib/configuration/core/source/ConfigurationReader.java

@@ -4,10 +4,15 @@ import cc.carm.lib.configuration.core.function.ConfigValueParser;
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.Unmodifiable;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
 
 interface ConfigurationReader {
 
-    ConfigurationWrapper getWrapper();
+    ConfigurationWrapper<?> getWrapper();
 
     default boolean isBoolean(@NotNull String path) {
         return getWrapper().isType(path, Boolean.class);
@@ -26,7 +31,6 @@ interface ConfigurationReader {
         return getWrapper().isType(path, Byte.class);
     }
 
-
     default @Nullable Byte getByte(@NotNull String path) {
         return getByte(path, (byte) 0);
     }
@@ -36,12 +40,10 @@ interface ConfigurationReader {
         return getWrapper().get(path, def, ConfigValueParser.byteValue());
     }
 
-
     default boolean isShort(@NotNull String path) {
         return getWrapper().isType(path, Short.class);
     }
 
-
     default @Nullable Short getShort(@NotNull String path) {
         return getShort(path, (short) 0);
     }
@@ -56,7 +58,6 @@ interface ConfigurationReader {
         return getWrapper().isType(path, Integer.class);
     }
 
-
     default @Nullable Integer getInt(@NotNull String path) {
         return getInt(path, 0);
     }
@@ -71,7 +72,6 @@ interface ConfigurationReader {
         return getWrapper().isType(path, Long.class);
     }
 
-
     default @Nullable Long getLong(@NotNull String path) {
         return getLong(path, 0L);
     }
@@ -86,7 +86,6 @@ interface ConfigurationReader {
         return getWrapper().isType(path, Float.class);
     }
 
-
     default @Nullable Float getFloat(@NotNull String path) {
         return getFloat(path, 0.0F);
     }
@@ -101,7 +100,6 @@ interface ConfigurationReader {
         return getWrapper().isType(path, Double.class);
     }
 
-
     default @Nullable Double getDouble(@NotNull String path) {
         return getDouble(path, 0.0D);
     }
@@ -116,7 +114,6 @@ interface ConfigurationReader {
         return getWrapper().isType(path, Boolean.class);
     }
 
-
     default @Nullable Character getChar(@NotNull String path) {
         return getChar(path, null);
     }
@@ -140,5 +137,54 @@ interface ConfigurationReader {
         return getWrapper().get(path, def, String.class);
     }
 
+    @Unmodifiable
+    default @NotNull List<String> getStringList(@NotNull String path) {
+        return parseList(getWrapper().getList(path), ConfigValueParser.castToString());
+    }
+
+    @Unmodifiable
+    default @NotNull List<Integer> getIntegerList(@NotNull String path) {
+        return parseList(getWrapper().getList(path), ConfigValueParser.intValue());
+    }
+
+    @Unmodifiable
+    default @NotNull List<Long> getLongList(@NotNull String path) {
+        return parseList(getWrapper().getList(path), ConfigValueParser.longValue());
+    }
+
+    @Unmodifiable
+    default @NotNull List<Double> getDoubleList(@NotNull String path) {
+        return parseList(getWrapper().getList(path), ConfigValueParser.doubleValue());
+    }
+
+    @Unmodifiable
+    default @NotNull List<Float> getFloatList(@NotNull String path) {
+        return parseList(getWrapper().getList(path), ConfigValueParser.floatValue());
+    }
+
+    @Unmodifiable
+    default @NotNull List<Byte> getByteList(@NotNull String path) {
+        return parseList(getWrapper().getList(path), ConfigValueParser.byteValue());
+    }
+
+    @Unmodifiable
+    default @NotNull List<Character> getCharList(@NotNull String path) {
+        return parseList(getWrapper().getList(path), ConfigValueParser.castObject(Character.class));
+    }
+
+    @Unmodifiable
+    static <T> @NotNull List<T> parseList(@Nullable List<?> list, ConfigValueParser<Object, T> parser) {
+        if (list == null) return Collections.emptyList();
+        List<T> values = new ArrayList<>();
+        for (Object o : list) {
+            try {
+                T parsed = parser.parse(o, null);
+                if (parsed != null) values.add(parsed);
+            } catch (Exception ignored) {
+            }
+        }
+        return values;
+    }
+
 
 }

core/src/main/java/cc/carm/lib/configuration/core/source/ConfigurationWrapper.java

@@ -9,13 +9,15 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
-public interface ConfigurationWrapper extends ConfigurationReader{
+public interface ConfigurationWrapper<S> extends ConfigurationReader {
 
     @Override
-    default ConfigurationWrapper getWrapper() {
+    default ConfigurationWrapper<S> getWrapper() {
         return this;
     }
 
+    @NotNull S getSource();
+
     @NotNull
     Set<String> getKeys(boolean deep);
 
@@ -66,7 +68,6 @@ public interface ConfigurationWrapper extends ConfigurationReader{
     boolean isConfigurationSection(@NotNull String path);
 
     @Nullable
-    ConfigurationWrapper getConfigurationSection(@NotNull String path);
-
+    ConfigurationWrapper<S> getConfigurationSection(@NotNull String path);
 
 }

core/src/main/java/cc/carm/lib/configuration/core/source/impl/FileConfigProvider.java

@@ -1,19 +1,24 @@
 package cc.carm.lib.configuration.core.source.impl;
 
 import cc.carm.lib.configuration.core.source.ConfigurationProvider;
+import cc.carm.lib.configuration.core.source.ConfigurationWrapper;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.io.*;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
 import java.net.URL;
 import java.net.URLConnection;
+import java.nio.file.Files;
 import java.util.Objects;
 
-public abstract class FileConfigProvider extends ConfigurationProvider {
+public abstract class FileConfigProvider<W extends ConfigurationWrapper<?>> extends ConfigurationProvider<W> {
 
     protected final @NotNull File file;
 
-    public FileConfigProvider(@NotNull File file) {
+    protected FileConfigProvider(@NotNull File file) {
         this.file = file;
     }
 
@@ -22,48 +27,49 @@ public abstract class FileConfigProvider extends ConfigurationProvider {
     }
 
     public void initializeFile(@Nullable String sourcePath) throws IOException {
-        if (getFile().exists()) return;
-        if (!getFile().getParentFile().exists() && !getFile().getParentFile().mkdirs()) {
+        if (this.file.exists()) return;
+
+        File parent = this.file.getParentFile();
+        if (parent != null && !parent.exists() && !parent.mkdirs()) {
             throw new IOException("Failed to create directory " + file.getParentFile().getAbsolutePath());
         }
-        if (!getFile().createNewFile()) {
+
+        if (!this.file.createNewFile()) {
             throw new IOException("Failed to create file " + file.getAbsolutePath());
         }
-        if (sourcePath == null) return;
-        try {
-            saveResource(sourcePath, true);
-        } catch (Exception ignored) {
+
+        if (sourcePath != null) {
+            try {
+                saveResource(sourcePath, true);
+            } catch (IllegalArgumentException ignored) {
+            }
         }
     }
 
     public void saveResource(@NotNull String resourcePath, boolean replace)
-            throws NullPointerException, IOException, IllegalArgumentException {
+            throws IOException, IllegalArgumentException {
         Objects.requireNonNull(resourcePath, "ResourcePath cannot be null");
-        if (resourcePath.equals("")) throw new IllegalArgumentException("ResourcePath cannot be empty");
+        if (resourcePath.isEmpty()) throw new IllegalArgumentException("ResourcePath cannot be empty");
 
         resourcePath = resourcePath.replace('\\', '/');
-        InputStream in = getResource(resourcePath);
-        if (in == null) throw new IllegalArgumentException("The resource '" + resourcePath + "' not exists");
 
+        URL url = this.getClass().getClassLoader().getResource(resourcePath);
+        if (url == null) throw new IllegalArgumentException("The resource '" + resourcePath + "' not exists");
 
-        int lastIndex = resourcePath.lastIndexOf('/');
-        File outDir = new File(file, resourcePath.substring(0, Math.max(lastIndex, 0)));
-
+        File outDir = file.getParentFile();
+        
         if (!outDir.exists() && !outDir.mkdirs()) throw new IOException("Failed to create directory " + outDir);
         if (!file.exists() || replace) {
-            try {
-
-                OutputStream out = new FileOutputStream(file);
-                byte[] buf = new byte[1024];
-                int len;
-                while ((len = in.read(buf)) > 0) {
-                    out.write(buf, 0, len);
+            try (OutputStream out = Files.newOutputStream(file.toPath())) {
+                URLConnection connection = url.openConnection();
+                connection.setUseCaches(false);
+                try (InputStream in = connection.getInputStream()) {
+                    byte[] buf = new byte[1024];
+                    int len;
+                    while ((len = in.read(buf)) > 0) {
+                        out.write(buf, 0, len);
+                    }
                 }
-                out.close();
-                in.close();
-
-            } catch (IOException ex) {
-                ex.printStackTrace();
             }
         }
     }

core/src/main/java/cc/carm/lib/configuration/core/value/CachedConfigValue.java

@@ -1,40 +0,0 @@
-package cc.carm.lib.configuration.core.value;
-
-import cc.carm.lib.configuration.core.source.ConfigurationProvider;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-public abstract class CachedConfigValue<T> extends ConfigValue<T> {
-
-
-    protected @Nullable T cachedValue;
-    protected long parsedTime = -1;
-
-    public CachedConfigValue(@Nullable ConfigurationProvider provider, @Nullable String sectionPath,
-                             @NotNull String[] comments, @Nullable T defaultValue) {
-        super(provider, sectionPath, comments, defaultValue);
-    }
-
-    protected T updateCache(T value) {
-        this.parsedTime = System.currentTimeMillis();
-        this.cachedValue = value;
-        return getCachedValue();
-    }
-
-    public @Nullable T getCachedValue() {
-        return cachedValue;
-    }
-
-    public boolean isExpired() {
-        return this.parsedTime <= 0 || getProvider().isExpired(this.parsedTime);
-    }
-
-    protected final T useDefault() {
-        return useOrDefault(null);
-    }
-
-    protected final T useOrDefault(@Nullable T value) {
-        return updateCache(this.defaultValue == null ? value : this.defaultValue);
-    }
-
-}

core/src/main/java/cc/carm/lib/configuration/core/value/ConfigValue.java

@@ -1,64 +1,68 @@
 package cc.carm.lib.configuration.core.value;
 
 import cc.carm.lib.configuration.core.builder.ConfigBuilder;
-import cc.carm.lib.configuration.core.builder.value.ConfigValueBuilder;
 import cc.carm.lib.configuration.core.source.ConfigurationProvider;
-import cc.carm.lib.configuration.core.source.ConfigurationWrapper;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 
-public abstract class ConfigValue<T> {
+public abstract class ConfigValue<T> extends ValueManifest<T> {
 
-    public static <V> ConfigValueBuilder<V> builder(Class<V> valueClass) {
-        return ConfigBuilder.asValue(valueClass);
+    public static @NotNull ConfigBuilder builder() {
+        return new ConfigBuilder();
     }
 
-    public static <V> ConfigValue<V> of(Class<V> valueClass) {
-        return builder(valueClass).fromObject().build();
+    protected ConfigValue(@NotNull ValueManifest<T> manifest) {
+        super(manifest.provider, manifest.configPath, manifest.headerComments, manifest.inlineComment, manifest.defaultValue);
     }
 
-    protected @Nullable T defaultValue;
-
-    protected @Nullable ConfigurationProvider provider;
-    protected @Nullable String configPath;
-    protected @NotNull String[] comments;
-
-    public ConfigValue(@Nullable ConfigurationProvider provider, @Nullable String configPath,
-                       @NotNull String[] comments, @Nullable T defaultValue) {
-        this.provider = provider;
-        this.configPath = configPath;
-        this.comments = comments;
-
-        this.defaultValue = defaultValue;
+    /**
+     * @param provider       配置文件提供者
+     * @param configPath     配置路径
+     * @param headerComments 头部注释内容
+     * @param inlineComments 行内注释内容
+     * @param defaultValue   默认参数值
+     * @deprecated 请使用 {@link #ConfigValue(ValueManifest)} 构造器。
+     */
+    @Deprecated
+    protected ConfigValue(@Nullable ConfigurationProvider<?> provider, @Nullable String configPath,
+                          @Nullable List<String> headerComments, @Nullable String inlineComments,
+                          @Nullable T defaultValue) {
+        super(provider, configPath, headerComments, inlineComments, defaultValue);
     }
 
-    public void initialize(@NotNull ConfigurationProvider provider, @NotNull String configPath,
-                           @NotNull String... comments) {
-        if (this.provider == null) this.provider = provider;
-        if (this.configPath == null) this.configPath = configPath;
-        if (this.comments.length == 0) this.comments = comments;
-
-        this.provider.setComments(this.configPath, this.comments);
-        get();
-    }
-
-    public @Nullable T getDefaultValue() {
-        return defaultValue;
-    }
-
-    public void setDefaultValue(@Nullable T defaultValue) {
-        this.defaultValue = defaultValue;
+    public void initialize(@NotNull ConfigurationProvider<?> provider, boolean saveDefault, @NotNull String configPath,
+                           @Nullable List<String> headerComments, @Nullable String inlineComments) {
+        this.initialize(provider, configPath, headerComments, inlineComments);
+        if (saveDefault) setDefault();
     }
 
+    /**
+     * 得到该配置的设定值(即读取到的值)。
+     * <br> 若初始化时未写入默认值，则可以通过 {@link #getOrDefault()} 方法在该设定值为空时获取默认值。
+     *
+     * @return 设定值
+     */
     public abstract @Nullable T get();
 
+    /**
+     * 得到该配置的设定值，若不存在，则返回默认值。
+     *
+     * @return 设定值或默认值
+     */
     public @Nullable T getOrDefault() {
-        return Optional.ofNullable(get()).orElse(getDefaultValue());
+        return getOptional().orElse(getDefaultValue());
     }
 
+    /**
+     * 得到该配置的非空值。
+     *
+     * @return 非空值
+     * @throws NullPointerException 对应数据为空时抛出
+     */
     public @NotNull T getNotNull() {
         return Objects.requireNonNull(getOrDefault(), "Value(" + configPath + ") is null.");
     }
@@ -67,44 +71,44 @@ public abstract class ConfigValue<T> {
         return Optional.ofNullable(get());
     }
 
+    /**
+     * 设定该配置的值。
+     * <br> 设定后，不会自动保存配置文件；若需要保存，请调用 {@link ConfigurationProvider#save()} 方法。
+     *
+     * @param value 配置的值
+     */
     public abstract void set(@Nullable T value);
 
+    /**
+     * 初始化该配置的默认值。
+     * <br> 设定后，不会自动保存配置文件；若需要保存，请调用 {@link ConfigurationProvider#save()} 方法。
+     */
     public void setDefault() {
+        setDefault(false);
+    }
+
+    /**
+     * 将该配置的值设置为默认值。
+     * <br> 设定后，不会自动保存配置文件；若需要保存，请调用 {@link ConfigurationProvider#save()} 方法。
+     *
+     * @param override 是否覆盖已设定的值
+     */
+    public void setDefault(boolean override) {
+        if (!override && getConfiguration().contains(getConfigPath())) return;
         Optional.ofNullable(getDefaultValue()).ifPresent(this::set);
     }
 
-    public @NotNull ConfigurationProvider getProvider() {
-        return Optional.ofNullable(this.provider)
-                .orElseThrow(() -> new IllegalStateException("Value(" + configPath + ") does not have a provider."));
-    }
-
-    public final @NotNull ConfigurationWrapper getConfiguration() {
-        try {
-            return getProvider().getConfiguration();
-        } catch (Exception ex) {
-            throw new IllegalStateException("Value(" + configPath + ") has not been initialized", ex);
-        }
-    }
-
-    public @NotNull String getConfigPath() {
-        return Optional.ofNullable(this.configPath)
-                .orElseThrow(() -> new IllegalStateException("No section path provided."));
-    }
-
-    protected Object getValue() {
-        return getConfiguration().get(getConfigPath());
-    }
-
-    protected void setValue(@Nullable Object value) {
-        getConfiguration().set(getConfigPath(), value);
-    }
-
-    public String[] getComments() {
-        return comments;
-    }
-
-    public void setComments(String[] comments) {
-        this.comments = comments;
+    /**
+     * 判断加载的配置是否与默认值相同。
+     *
+     * @return 获取当前值是否为默认值。
+     */
+    public boolean isDefault() {
+        T defaultValue = getDefaultValue();
+        T value = get();
+        if (defaultValue == null && value == null) return true;
+        else if (defaultValue != null && value != null) return defaultValue.equals(value);
+        else return false;
     }
 
 }

core/src/main/java/cc/carm/lib/configuration/core/value/ValueManifest.java

@@ -0,0 +1,125 @@
+package cc.carm.lib.configuration.core.value;
+
+import cc.carm.lib.configuration.core.ConfigInitializer;
+import cc.carm.lib.configuration.core.source.ConfigurationProvider;
+import cc.carm.lib.configuration.core.source.ConfigurationWrapper;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.Unmodifiable;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * 配置值描述清单。用于描述一个配置值的相关基础信息。
+ *
+ * @param <T> 配置值类型
+ * @author CarmJos
+ */
+public class ValueManifest<T> {
+
+    public static <V> ValueManifest<V> of(@Nullable ConfigurationProvider<?> provider, @Nullable String configPath,
+                                          @Nullable List<String> headerComments, @Nullable String inlineComments) {
+        return new ValueManifest<>(provider, configPath, headerComments, inlineComments, null);
+    }
+
+    public static <V> ValueManifest<V> of(@Nullable ConfigurationProvider<?> provider, @Nullable String configPath,
+                                          @Nullable List<String> headerComments, @Nullable String inlineComments,
+                                          @Nullable V defaultValue) {
+        return new ValueManifest<>(provider, configPath, headerComments, inlineComments, defaultValue);
+    }
+
+    protected @Nullable ConfigurationProvider<?> provider;
+    protected @Nullable String configPath;
+
+    protected @Nullable List<String> headerComments;
+    protected @Nullable String inlineComment;
+
+    protected @Nullable T defaultValue;
+
+    /**
+     * @param provider       配置文件提供者
+     * @param configPath     配置路径
+     * @param headerComments 头部注释内容
+     * @param inlineComment  行内注释内容
+     * @param defaultValue   默认参数值
+     */
+    public ValueManifest(@Nullable ConfigurationProvider<?> provider, @Nullable String configPath,
+                         @Nullable List<String> headerComments, @Nullable String inlineComment,
+                         @Nullable T defaultValue) {
+        this.provider = provider;
+        this.configPath = configPath;
+        this.headerComments = headerComments;
+        this.inlineComment = inlineComment;
+        this.defaultValue = defaultValue;
+    }
+
+    /**
+     * 此方法提供给 {@link ConfigInitializer}，以便对配置值的相关信息进行统一初始化操作。
+     *
+     * @param provider       配置文件提供者
+     * @param configPath     配置路径
+     * @param headerComments 头部注释内容
+     * @param inlineComment  行内注释内容
+     */
+    protected void initialize(@NotNull ConfigurationProvider<?> provider, @NotNull String configPath,
+                              @Nullable List<String> headerComments, @Nullable String inlineComment) {
+        if (this.provider == null) this.provider = provider;
+        if (this.configPath == null) this.configPath = configPath;
+        if (this.headerComments == null) this.headerComments = headerComments;
+        if (this.inlineComment == null) this.inlineComment = inlineComment;
+
+        if (getHeaderComments() != null) {
+            this.provider.setHeaderComment(getConfigPath(), getHeaderComments());
+        }
+        if (getInlineComment() != null) {
+            this.provider.setInlineComment(getConfigPath(), getInlineComment());
+        }
+    }
+
+    public @Nullable T getDefaultValue() {
+        return this.defaultValue;
+    }
+
+    public void setDefaultValue(@Nullable T defaultValue) {
+        this.defaultValue = defaultValue;
+    }
+
+    public @NotNull ConfigurationProvider<?> getProvider() {
+        return Optional.ofNullable(this.provider)
+                .orElseThrow(() -> new IllegalStateException("Value(" + configPath + ") does not have a provider."));
+    }
+
+    public final @NotNull ConfigurationWrapper<?> getConfiguration() {
+        try {
+            return getProvider().getConfiguration();
+        } catch (Exception ex) {
+            throw new IllegalStateException("Value(" + configPath + ") has not been initialized", ex);
+        }
+    }
+
+    public @NotNull String getConfigPath() {
+        return Optional.ofNullable(this.configPath)
+                .orElseThrow(() -> new IllegalStateException("No section path provided."));
+    }
+
+    protected Object getValue() {
+        String path = getConfigPath(); // 当未指定路径时，优先抛出异常
+        return getConfiguration().get(path);
+    }
+
+    protected void setValue(@Nullable Object value) {
+        getConfiguration().set(getConfigPath(), value);
+    }
+
+    public @Nullable String getInlineComment() {
+        return inlineComment;
+    }
+
+    @Unmodifiable
+    public @Nullable List<String> getHeaderComments() {
+        return headerComments;
+    }
+
+
+}

core/src/main/java/cc/carm/lib/configuration/core/value/impl/CachedConfigValue.java

@@ -0,0 +1,48 @@
+package cc.carm.lib.configuration.core.value.impl;
+
+import cc.carm.lib.configuration.core.value.ConfigValue;
+import cc.carm.lib.configuration.core.value.ValueManifest;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public abstract class CachedConfigValue<T> extends ConfigValue<T> {
+
+
+    protected @Nullable T cachedValue;
+    protected long parsedTime = -1;
+
+    protected CachedConfigValue(@NotNull ValueManifest<T> manifest) {
+        super(manifest);
+    }
+
+    protected T updateCache(T value) {
+        this.parsedTime = System.currentTimeMillis();
+        this.cachedValue = value;
+        return getCachedValue();
+    }
+
+    public @Nullable T getCachedValue() {
+        return cachedValue;
+    }
+
+    public boolean isExpired() {
+        return this.parsedTime <= 0 || getProvider().isExpired(this.parsedTime);
+    }
+
+    protected final T getDefaultFirst(@Nullable T value) {
+        return updateCache(this.defaultValue == null ? value : this.defaultValue);
+    }
+
+    protected @Nullable T getCachedOrDefault() {
+        return getCachedOrDefault(null);
+    }
+
+    @Contract("!null->!null")
+    protected T getCachedOrDefault(@Nullable T emptyValue) {
+        if (getCachedValue() != null) return getCachedValue();
+        else if (getDefaultValue() != null) return getDefaultValue();
+        else return emptyValue;
+    }
+
+}

core/src/main/java/cc/carm/lib/configuration/core/value/impl/ConfigValueMap.java

@@ -0,0 +1,214 @@
+package cc.carm.lib.configuration.core.value.impl;
+
+import cc.carm.lib.configuration.core.builder.map.ConfigMapCreator;
+import cc.carm.lib.configuration.core.function.ConfigDataFunction;
+import cc.carm.lib.configuration.core.source.ConfigurationWrapper;
+import cc.carm.lib.configuration.core.value.ValueManifest;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.Unmodifiable;
+
+import java.util.*;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+public abstract class ConfigValueMap<K, V, S> extends CachedConfigValue<Map<K, V>> implements Map<K, V> {
+
+    public static <K, V> @NotNull ConfigMapCreator<K, V> builderOf(@NotNull Class<K> keyClass,
+                                                                   @NotNull Class<V> valueClass) {
+        return builder().asMap(keyClass, valueClass);
+    }
+
+    protected final @NotNull Supplier<? extends Map<K, V>> supplier;
+
+    protected final @NotNull Class<? super S> sourceClass;
+    protected final @NotNull Class<K> keyClass;
+    protected final @NotNull Class<V> valueClass;
+
+    protected final @NotNull ConfigDataFunction<String, K> keyParser;
+    protected final @NotNull ConfigDataFunction<S, V> valueParser;
+
+    protected final @NotNull ConfigDataFunction<K, String> keySerializer;
+    protected final @NotNull ConfigDataFunction<V, Object> valueSerializer;
+
+
+    protected ConfigValueMap(@NotNull ValueManifest<Map<K, V>> manifest, @NotNull Class<? super S> sourceClass,
+                             @NotNull Supplier<? extends Map<K, V>> mapObjSupplier,
+                             @NotNull Class<K> keyClass, @NotNull ConfigDataFunction<String, K> keyParser,
+                             @NotNull Class<V> valueClass, @NotNull ConfigDataFunction<S, V> valueParser,
+                             @NotNull ConfigDataFunction<K, String> keySerializer,
+                             @NotNull ConfigDataFunction<V, Object> valueSerializer) {
+        super(manifest);
+        this.supplier = mapObjSupplier;
+        this.sourceClass = sourceClass;
+        this.keyClass = keyClass;
+        this.valueClass = valueClass;
+        this.keyParser = keyParser;
+        this.valueParser = valueParser;
+        this.keySerializer = keySerializer;
+        this.valueSerializer = valueSerializer;
+    }
+
+    public @NotNull Class<? super S> getSourceClass() {
+        return sourceClass;
+    }
+
+    public @NotNull Class<K> getKeyClass() {
+        return keyClass;
+    }
+
+    public @NotNull Class<V> getValueClass() {
+        return valueClass;
+    }
+
+    public @NotNull ConfigDataFunction<String, K> getKeyParser() {
+        return keyParser;
+    }
+
+    public @NotNull ConfigDataFunction<S, V> getValueParser() {
+        return valueParser;
+    }
+
+    public @NotNull ConfigDataFunction<K, String> getKeySerializer() {
+        return keySerializer;
+    }
+
+    public @NotNull ConfigDataFunction<V, Object> getValueSerializer() {
+        return valueSerializer;
+    }
+
+    public abstract S getSource(ConfigurationWrapper<?> section, String dataKey);
+
+    @Override
+    public @NotNull Map<K, V> get() {
+        if (!isExpired()) return getCachedOrDefault(supplier.get());
+
+        // 已过时的数据，需要重新解析一次。
+        Map<K, V> map = supplier.get();
+
+        ConfigurationWrapper<?> section = getConfiguration().getConfigurationSection(getConfigPath());
+        if (section == null) return getDefaultFirst(map);
+
+        Set<String> keys = section.getKeys(false);
+        if (keys.isEmpty()) return getDefaultFirst(map);
+
+        for (String dataKey : keys) {
+            S dataVal = getSource(section, dataKey);
+            if (dataVal == null) continue;
+            try {
+                K key = keyParser.parse(dataKey);
+                V value = valueParser.parse(dataVal);
+                map.put(key, value);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+
+        return updateCache(map);
+    }
+
+    @Override
+    public V get(Object key) {
+        return get().get(key);
+    }
+
+    public V getNotNull(Object key) {
+        return Objects.requireNonNull(get(key));
+    }
+
+    @Override
+    public void set(@Nullable Map<K, V> value) {
+        updateCache(value);
+        if (value == null) setValue(null);
+        else {
+            Map<String, Object> data = new LinkedHashMap<>();
+            for (Map.Entry<K, V> entry : value.entrySet()) {
+                try {
+                    data.put(
+                            keySerializer.parse(entry.getKey()),
+                            valueSerializer.parse(entry.getValue())
+                    );
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+            setValue(data);
+        }
+    }
+
+    public <T> @NotNull T modifyValue(Function<Map<K, V>, T> function) {
+        Map<K, V> m = get();
+        T result = function.apply(m);
+        set(m);
+        return result;
+    }
+
+    public @NotNull Map<K, V> modifyMap(Consumer<Map<K, V>> consumer) {
+        Map<K, V> m = get();
+        consumer.accept(m);
+        set(m);
+        return m;
+    }
+
+    @Override
+    public int size() {
+        return get().size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return get().isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return get().containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return get().containsValue(value);
+    }
+
+    @Nullable
+    @Override
+    public V put(K key, V value) {
+        return modifyValue(m -> m.put(key, value));
+    }
+
+    @Override
+    public V remove(Object key) {
+        return modifyValue(m -> m.remove(key));
+    }
+
+    @Override
+    public void putAll(@NotNull Map<? extends K, ? extends V> m) {
+        modifyMap(map -> map.putAll(m));
+    }
+
+    @Override
+    public void clear() {
+        modifyMap(Map::clear);
+    }
+
+    @NotNull
+    @Override
+    public Set<K> keySet() {
+        return get().keySet();
+    }
+
+    @NotNull
+    @Override
+    public Collection<V> values() {
+        return get().values();
+    }
+
+    @NotNull
+    @Override
+    @Unmodifiable
+    public Set<Entry<K, V>> entrySet() {
+        return get().entrySet();
+    }
+
+}

core/src/main/java/cc/carm/lib/configuration/core/value/type/ConfiguredList.java

@@ -1,27 +1,40 @@
 package cc.carm.lib.configuration.core.value.type;
 
+import cc.carm.lib.configuration.core.builder.list.ConfigListBuilder;
 import cc.carm.lib.configuration.core.function.ConfigDataFunction;
-import cc.carm.lib.configuration.core.source.ConfigurationProvider;
-import cc.carm.lib.configuration.core.value.CachedConfigValue;
+import cc.carm.lib.configuration.core.value.ValueManifest;
+import cc.carm.lib.configuration.core.value.impl.CachedConfigValue;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.ArrayList;
-import java.util.List;
+import java.util.*;
+import java.util.function.Consumer;
+import java.util.function.Function;
 
-public class ConfiguredList<V> extends CachedConfigValue<List<V>> {
+public class ConfiguredList<V> extends CachedConfigValue<List<V>> implements List<V> {
+
+    public static <V> @NotNull ConfigListBuilder<V> builderOf(@NotNull Class<V> valueClass) {
+        return builder().asList(valueClass);
+    }
+
+    public static <V> @NotNull ConfiguredList<V> of(@NotNull Class<V> valueClass, @NotNull Collection<V> defaults) {
+        return builderOf(valueClass).fromObject().defaults(defaults).build();
+    }
+
+    @SafeVarargs
+    public static <V> @NotNull ConfiguredList<V> of(@NotNull Class<V> valueClass, @NotNull V... defaults) {
+        return builderOf(valueClass).fromObject().defaults(defaults).build();
+    }
 
     protected final @NotNull Class<V> valueClass;
 
     protected final @NotNull ConfigDataFunction<Object, V> parser;
     protected final @NotNull ConfigDataFunction<V, Object> serializer;
 
-    public ConfiguredList(@Nullable ConfigurationProvider provider,
-                          @Nullable String sectionPath, @NotNull String[] comments,
-                          @NotNull Class<V> valueClass, @Nullable List<V> defaultValue,
+    public ConfiguredList(@NotNull ValueManifest<List<V>> manifest, @NotNull Class<V> valueClass,
                           @NotNull ConfigDataFunction<Object, V> parser,
                           @NotNull ConfigDataFunction<V, Object> serializer) {
-        super(provider, sectionPath, comments, defaultValue);
+        super(manifest);
         this.valueClass = valueClass;
         this.parser = parser;
         this.serializer = serializer;
@@ -29,25 +42,45 @@ public class ConfiguredList<V> extends CachedConfigValue<List<V>> {
 
     @Override
     public @NotNull List<V> get() {
-        if (isExpired()) { // 已过时的数据，需要重新解析一次。
-            List<V> list = new ArrayList<>();
+        if (!isExpired()) return getCachedOrDefault(new ArrayList<>());
 
-            List<?> data = getConfiguration().getList(getConfigPath());
-            if (data == null || data.isEmpty()) return useOrDefault(list);
-
-            for (Object dataVal : data) {
-                if (dataVal == null) continue;
-                try {
-                    list.add(parser.parse(dataVal));
-                } catch (Exception e) {
-                    e.printStackTrace();
-                }
+        // 已过时的数据，需要重新解析一次。
+        List<V> list = new ArrayList<>();
+        List<?> data = getConfiguration().contains(getConfigPath()) ?
+                getConfiguration().getList(getConfigPath()) : null;
+        if (data == null) return getDefaultFirst(list);
+        for (Object dataVal : data) {
+            if (dataVal == null) continue;
+            try {
+                list.add(parser.parse(dataVal));
+            } catch (Exception e) {
+                e.printStackTrace();
             }
+        }
+        return updateCache(list);
+    }
 
-            return updateCache(list);
-        } else if (getCachedValue() != null) return getCachedValue();
-        else if (getDefaultValue() != null) return getDefaultValue();
-        else return new ArrayList<>();
+    @Override
+    public V get(int index) {
+        return get().get(index);
+    }
+
+    public @NotNull List<V> copy() {
+        return new ArrayList<>(get());
+    }
+
+    public <T> @NotNull T handle(Function<List<V>, T> function) {
+        List<V> list = get();
+        T result = function.apply(list);
+        set(list);
+        return result;
+    }
+
+    public @NotNull List<V> modify(Consumer<List<V>> consumer) {
+        List<V> list = get();
+        consumer.accept(list);
+        set(list);
+        return list;
     }
 
     @Override
@@ -68,5 +101,121 @@ public class ConfiguredList<V> extends CachedConfigValue<List<V>> {
         }
     }
 
+    @Override
+    public V set(int index, V element) {
+        return handle(list -> list.set(index, element));
+    }
+
+    @Override
+    public int size() {
+        return get().size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return get().isEmpty();
+    }
+
+    @Override
+    public boolean contains(Object o) {
+        return get().contains(o);
+    }
+
+    @NotNull
+    @Override
+    public Iterator<V> iterator() {
+        return get().iterator();
+    }
+
+    @NotNull
+    @Override
+    public Object @NotNull [] toArray() {
+        return get().toArray();
+    }
+
+    @NotNull
+    @Override
+    public <T> T @NotNull [] toArray(@NotNull T[] a) {
+        return get().toArray(a);
+    }
+
+    @Override
+    public boolean containsAll(@NotNull Collection<?> c) {
+        return new HashSet<>(get()).containsAll(c);
+    }
+
+    @Override
+    public boolean add(V v) {
+        handle(list -> list.add(v));
+        return true;
+    }
+
+    @Override
+    public void add(int index, V element) {
+        modify(list -> list.add(index, element));
+    }
+
+    @Override
+    public boolean addAll(@NotNull Collection<? extends V> c) {
+        return handle(list -> list.addAll(c));
+    }
+
+    @Override
+    public boolean addAll(int index, @NotNull Collection<? extends V> c) {
+        return handle(list -> list.addAll(index, c));
+    }
+
+    @Override
+    public boolean remove(Object o) {
+        return handle(list -> list.remove(o));
+    }
+
+    @Override
+    public V remove(int index) {
+        return handle(list -> list.remove(index));
+    }
+
+    @Override
+    public boolean removeAll(@NotNull Collection<?> c) {
+        return handle(list -> list.removeAll(c));
+    }
+
+    @Override
+    public boolean retainAll(@NotNull Collection<?> c) {
+        return handle(list -> list.retainAll(c));
+    }
+
+    @Override
+    public void clear() {
+        modify(List::clear);
+    }
+
+    @Override
+    public int indexOf(Object o) {
+        return get().indexOf(o);
+    }
+
+    @Override
+    public int lastIndexOf(Object o) {
+        return get().lastIndexOf(o);
+    }
+
+    @NotNull
+    @Override
+    public ListIterator<V> listIterator() {
+        return get().listIterator();
+    }
+
+    @NotNull
+    @Override
+    public ListIterator<V> listIterator(int index) {
+        return get().listIterator(index);
+    }
+
+    @NotNull
+    @Override
+    public List<V> subList(int fromIndex, int toIndex) {
+        return get().subList(fromIndex, toIndex);
+    }
 
 }

core/src/main/java/cc/carm/lib/configuration/core/value/type/ConfiguredMap.java

@@ -1,125 +1,28 @@
 package cc.carm.lib.configuration.core.value.type;
 
-import cc.carm.lib.configuration.core.builder.ConfigBuilder;
-import cc.carm.lib.configuration.core.builder.map.ConfigMapBuilder;
 import cc.carm.lib.configuration.core.function.ConfigDataFunction;
-import cc.carm.lib.configuration.core.source.ConfigurationProvider;
 import cc.carm.lib.configuration.core.source.ConfigurationWrapper;
-import cc.carm.lib.configuration.core.value.CachedConfigValue;
+import cc.carm.lib.configuration.core.value.ValueManifest;
+import cc.carm.lib.configuration.core.value.impl.ConfigValueMap;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 
-import java.util.LinkedHashMap;
 import java.util.Map;
-import java.util.Set;
 import java.util.function.Supplier;
 
-public class ConfiguredMap<K, V> extends CachedConfigValue<Map<K, V>> {
+public class ConfiguredMap<K, V> extends ConfigValueMap<K, V, Object> {
 
-    public static <K, V> @NotNull ConfigMapBuilder<LinkedHashMap<K, V>, K, V> builder(@NotNull Class<K> keyClass,
-                                                                                      @NotNull Class<V> valueClass) {
-        return ConfigBuilder.asMap(keyClass, valueClass);
-    }
-
-    protected final @NotNull Supplier<? extends Map<K, V>> supplier;
-
-    protected final @NotNull Class<K> keyClass;
-    protected final @NotNull Class<V> valueClass;
-
-    protected final @NotNull ConfigDataFunction<String, K> keyParser;
-    protected final @NotNull ConfigDataFunction<Object, V> valueParser;
-
-    protected final @NotNull ConfigDataFunction<K, String> keySerializer;
-    protected final @NotNull ConfigDataFunction<V, Object> valueSerializer;
-
-    public ConfiguredMap(@Nullable ConfigurationProvider provider,
-                         @Nullable String sectionPath, @NotNull String[] comments,
-                         @Nullable Map<K, V> defaultValue, @NotNull Supplier<? extends Map<K, V>> supplier,
+    public ConfiguredMap(@NotNull ValueManifest<Map<K, V>> manifest,
+                         @NotNull Supplier<? extends Map<K, V>> mapObjSupplier,
                          @NotNull Class<K> keyClass, @NotNull ConfigDataFunction<String, K> keyParser,
                          @NotNull Class<V> valueClass, @NotNull ConfigDataFunction<Object, V> valueParser,
                          @NotNull ConfigDataFunction<K, String> keySerializer,
                          @NotNull ConfigDataFunction<V, Object> valueSerializer) {
-        super(provider, sectionPath, comments, defaultValue);
-        this.supplier = supplier;
-        this.keyClass = keyClass;
-        this.valueClass = valueClass;
-        this.keyParser = keyParser;
-        this.valueParser = valueParser;
-        this.keySerializer = keySerializer;
-        this.valueSerializer = valueSerializer;
-    }
-
-    public @NotNull Class<K> getKeyClass() {
-        return keyClass;
-    }
-
-    public @NotNull Class<V> getValueClass() {
-        return valueClass;
-    }
-
-    public @NotNull ConfigDataFunction<String, K> getKeyParser() {
-        return keyParser;
-    }
-
-    public @NotNull ConfigDataFunction<Object, V> getValueParser() {
-        return valueParser;
-    }
-
-    public @NotNull ConfigDataFunction<K, String> getKeySerializer() {
-        return keySerializer;
-    }
-
-    public @NotNull ConfigDataFunction<V, Object> getValueSerializer() {
-        return valueSerializer;
+        super(manifest, Object.class, mapObjSupplier, keyClass, keyParser, valueClass, valueParser, keySerializer, valueSerializer);
     }
 
     @Override
-    public @NotNull Map<K, V> get() {
-        if (isExpired()) { // 已过时的数据，需要重新解析一次。
-            Map<K, V> map = supplier.get();
-
-            ConfigurationWrapper section = getConfiguration().getConfigurationSection(getConfigPath());
-            if (section == null) return useOrDefault(map);
-
-            Set<String> keys = section.getKeys(false);
-            if (keys.isEmpty()) return useOrDefault(map);
-
-            for (String dataKey : keys) {
-                Object dataVal = section.get(dataKey);
-                if (dataVal == null) continue;
-                try {
-                    K key = keyParser.parse(dataKey);
-                    V value = valueParser.parse(dataVal);
-                    map.put(key, value);
-                } catch (Exception e) {
-                    e.printStackTrace();
-                }
-            }
-
-            return updateCache(map);
-        } else if (getCachedValue() != null) return getCachedValue();
-        else if (getDefaultValue() != null) return getDefaultValue();
-        else return supplier.get();
+    public Object getSource(ConfigurationWrapper<?> section, String dataKey) {
+        return section.get(dataKey);
     }
 
-    @Override
-    public void set(Map<K, V> value) {
-        updateCache(value);
-        if (value == null) setValue(null);
-        else {
-            Map<String, Object> data = new LinkedHashMap<>();
-            for (Map.Entry<K, V> entry : value.entrySet()) {
-                try {
-                    String key = keySerializer.parse(entry.getKey());
-                    Object val = valueSerializer.parse(entry.getValue());
-                    data.put(key, val);
-                } catch (Exception e) {
-                    e.printStackTrace();
-                }
-            }
-            setValue(data);
-        }
-    }
-
-
 }

core/src/main/java/cc/carm/lib/configuration/core/value/type/ConfiguredSection.java

@@ -1,29 +1,31 @@
 package cc.carm.lib.configuration.core.value.type;
 
+import cc.carm.lib.configuration.core.builder.value.SectionValueBuilder;
 import cc.carm.lib.configuration.core.function.ConfigDataFunction;
 import cc.carm.lib.configuration.core.function.ConfigValueParser;
-import cc.carm.lib.configuration.core.source.ConfigurationProvider;
 import cc.carm.lib.configuration.core.source.ConfigurationWrapper;
-import cc.carm.lib.configuration.core.value.CachedConfigValue;
+import cc.carm.lib.configuration.core.value.ValueManifest;
+import cc.carm.lib.configuration.core.value.impl.CachedConfigValue;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.Map;
-import java.util.Optional;
 
 public class ConfiguredSection<V> extends CachedConfigValue<V> {
 
+    public static <V> @NotNull SectionValueBuilder<V> builderOf(@NotNull Class<V> valueClass) {
+        return builder().asValue(valueClass).fromSection();
+    }
+
     protected final @NotNull Class<V> valueClass;
 
-    protected final @NotNull ConfigValueParser<ConfigurationWrapper, V> parser;
+    protected final @NotNull ConfigValueParser<ConfigurationWrapper<?>, V> parser;
     protected final @NotNull ConfigDataFunction<V, ? extends Map<String, Object>> serializer;
 
-    public ConfiguredSection(@Nullable ConfigurationProvider provider,
-                             @Nullable String sectionPath, @NotNull String[] comments,
-                             @NotNull Class<V> valueClass, @Nullable V defaultValue,
-                             @NotNull ConfigValueParser<ConfigurationWrapper, V> parser,
+    public ConfiguredSection(@NotNull ValueManifest<V> manifest, @NotNull Class<V> valueClass,
+                             @NotNull ConfigValueParser<ConfigurationWrapper<?>, V> parser,
                              @NotNull ConfigDataFunction<V, ? extends Map<String, Object>> serializer) {
-        super(provider, sectionPath, comments, defaultValue);
+        super(manifest);
         this.valueClass = valueClass;
         this.parser = parser;
         this.serializer = serializer;
@@ -33,7 +35,7 @@ public class ConfiguredSection<V> extends CachedConfigValue<V> {
         return valueClass;
     }
 
-    public @NotNull ConfigValueParser<ConfigurationWrapper, V> getParser() {
+    public @NotNull ConfigValueParser<ConfigurationWrapper<?>, V> getParser() {
         return parser;
     }
 
@@ -43,18 +45,21 @@ public class ConfiguredSection<V> extends CachedConfigValue<V> {
 
     @Override
     public @Nullable V get() {
-        if (isExpired()) { // 已过时的数据，需要重新解析一次。
-            ConfigurationWrapper section = getConfiguration().getConfigurationSection(getConfigPath());
-            if (section == null) return useDefault();
-            try {
-                // 若未出现错误，则直接更新缓存并返回。
-                return updateCache(this.parser.parse(section, this.defaultValue));
-            } catch (Exception e) {
-                // 出现了解析错误，提示并返回默认值。
-                e.printStackTrace();
-                return useDefault();
-            }
-        } else return Optional.ofNullable(getCachedValue()).orElse(defaultValue);
+        if (!isExpired()) return getCachedOrDefault();
+        // 已过时的数据，需要重新解析一次。
+
+        ConfigurationWrapper<?> section = getConfiguration().getConfigurationSection(getConfigPath());
+        if (section == null) return getDefaultValue();
+
+        try {
+            // 若未出现错误，则直接更新缓存并返回。
+            return updateCache(this.parser.parse(section, this.defaultValue));
+        } catch (Exception e) {
+            // 出现了解析错误，提示并返回默认值。
+            e.printStackTrace();
+            return getDefaultValue();
+        }
+
     }
 
     @Override
@@ -64,7 +69,6 @@ public class ConfiguredSection<V> extends CachedConfigValue<V> {
         else {
             try {
                 setValue(serializer.parse(value));
-//                getConfiguration().createSection(getSectionPath(), serializer.parse(value));
             } catch (Exception e) {
                 e.printStackTrace();
             }

core/src/main/java/cc/carm/lib/configuration/core/value/type/ConfiguredSectionMap.java

@@ -0,0 +1,32 @@
+package cc.carm.lib.configuration.core.value.type;
+
+import cc.carm.lib.configuration.core.function.ConfigDataFunction;
+import cc.carm.lib.configuration.core.source.ConfigurationWrapper;
+import cc.carm.lib.configuration.core.value.ValueManifest;
+import cc.carm.lib.configuration.core.value.impl.ConfigValueMap;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Map;
+import java.util.function.Supplier;
+
+public class ConfiguredSectionMap<K, V> extends ConfigValueMap<K, V, ConfigurationWrapper<?>> {
+
+    public ConfiguredSectionMap(@NotNull ValueManifest<Map<K, V>> manifest,
+                                @NotNull Supplier<? extends Map<K, V>> mapObjSupplier,
+                                @NotNull Class<K> keyClass, @NotNull ConfigDataFunction<String, K> keyParser,
+                                @NotNull Class<V> valueClass, @NotNull ConfigDataFunction<ConfigurationWrapper<?>, V> valueParser,
+                                @NotNull ConfigDataFunction<K, String> keySerializer,
+                                @NotNull ConfigDataFunction<V, ? extends Map<String, Object>> valueSerializer) {
+        super(
+                manifest, ConfigurationWrapper.class, mapObjSupplier,
+                keyClass, keyParser, valueClass, valueParser,
+                keySerializer, valueSerializer.andThen(s -> (Object) s)
+        );
+    }
+
+    @Override
+    public ConfigurationWrapper<?> getSource(ConfigurationWrapper<?> section, String dataKey) {
+        return section.getConfigurationSection(dataKey);
+    }
+
+}

core/src/main/java/cc/carm/lib/configuration/core/value/type/ConfiguredValue.java

@@ -1,28 +1,36 @@
 package cc.carm.lib.configuration.core.value.type;
 
+import cc.carm.lib.configuration.core.builder.value.ConfigValueBuilder;
 import cc.carm.lib.configuration.core.function.ConfigDataFunction;
 import cc.carm.lib.configuration.core.function.ConfigValueParser;
-import cc.carm.lib.configuration.core.source.ConfigurationProvider;
-import cc.carm.lib.configuration.core.value.CachedConfigValue;
+import cc.carm.lib.configuration.core.value.ValueManifest;
+import cc.carm.lib.configuration.core.value.impl.CachedConfigValue;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.Optional;
-
 public class ConfiguredValue<V> extends CachedConfigValue<V> {
 
+    public static <V> ConfigValueBuilder<V> builderOf(Class<V> valueClass) {
+        return builder().asValue(valueClass);
+    }
+
+    public static <V> ConfiguredValue<V> of(Class<V> valueClass) {
+        return of(valueClass, null);
+    }
+
+    public static <V> ConfiguredValue<V> of(Class<V> valueClass, @Nullable V defaultValue) {
+        return builderOf(valueClass).fromObject().defaults(defaultValue).build();
+    }
+
     protected final @NotNull Class<V> valueClass;
 
     protected final @NotNull ConfigValueParser<Object, V> parser;
     protected final @NotNull ConfigDataFunction<V, Object> serializer;
 
-    public ConfiguredValue(@Nullable ConfigurationProvider provider,
-                           @Nullable String sectionPath, @NotNull String[] comments,
-                           @NotNull Class<V> valueClass, @Nullable V defaultValue,
+    public ConfiguredValue(@NotNull ValueManifest<V> manifest, @NotNull Class<V> valueClass,
                            @NotNull ConfigValueParser<Object, V> parser,
                            @NotNull ConfigDataFunction<V, Object> serializer) {
-
-        super(provider, sectionPath, comments, defaultValue);
+        super(manifest);
         this.valueClass = valueClass;
         this.parser = parser;
         this.serializer = serializer;
@@ -38,18 +46,20 @@ public class ConfiguredValue<V> extends CachedConfigValue<V> {
 
     @Override
     public V get() {
-        if (isExpired()) { // 已过时的数据，需要重新解析一次。
-            Object value = getConfiguration().get(getConfigPath());
-            if (value == null) return useDefault(); // 获取的值不存在，直接使用默认值。
-            try {
-                // 若未出现错误，则直接更新缓存并返回。
-                return updateCache(this.parser.parse(value, this.defaultValue));
-            } catch (Exception e) {
-                // 出现了解析错误，提示并返回默认值。
-                e.printStackTrace();
-                return useDefault();
-            }
-        } else return Optional.ofNullable(getCachedValue()).orElse(defaultValue);
+        if (!isExpired()) return getCachedOrDefault();
+        // 已过时的数据，需要重新解析一次。
+
+        Object value = getValue();
+        if (value == null) return getDefaultValue(); // 获取的值不存在，直接使用默认值。
+        try {
+            // 若未出现错误，则直接更新缓存并返回。
+            return updateCache(this.parser.parse(value, this.defaultValue));
+        } catch (Exception e) {
+            // 出现了解析错误，提示并返回默认值。
+            e.printStackTrace();
+            return getDefaultValue();
+        }
+
     }
 
     @Override

core/src/test/java/NameTest.java

@@ -0,0 +1,18 @@
+import cc.carm.lib.configuration.core.ConfigInitializer;
+import org.junit.Test;
+
+public class NameTest {
+
+
+    @Test
+    public void onTest() {
+
+        System.out.println(ConfigInitializer.getPathFromName("LoveGames")); // -> love-games
+        System.out.println(ConfigInitializer.getPathFromName("EASY_GAME")); // -> easy-game
+        System.out.println(ConfigInitializer.getPathFromName("F")); //-? f
+        System.out.println(ConfigInitializer.getPathFromName("Test123123")); // -? test123123123
+
+    }
+
+
+}

core/src/test/java/cc/carm/test/config/offset/FieldOffset.java

@@ -0,0 +1,64 @@
+package cc.carm.test.config.offset;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.reflect.Field;
+import java.util.List;
+
+/**
+ * @author Chris2018998
+ */
+public class FieldOffset implements Comparable<FieldOffset> {
+    private final Field field;
+    private Long offsetValue;
+    private List<FieldOffset> subFieldOffsetList;
+
+    public FieldOffset(Field field) {
+        this.field = field;
+    }
+
+    public Long getOffsetValue() {
+        return offsetValue;
+    }
+
+    public void setOffsetValue(Long offsetValue) {
+        this.offsetValue = offsetValue;
+    }
+
+    public String toString() {
+        if (subFieldOffsetList == null)
+            return field.getName();
+        else {
+
+            StringBuilder builder = new StringBuilder();
+            builder.append("[");
+
+            for (int i = 0; i < subFieldOffsetList.size(); i++) {
+                FieldOffset offset = subFieldOffsetList.get(i);
+                if (i > 0) builder.append(",");
+                builder.append(field.getName()).append(".").append(offset.toString());
+            }
+            builder.append("]");
+            return builder.toString();
+        }
+    }
+
+    public List<FieldOffset> getSubFieldOffsetList() {
+        return subFieldOffsetList;
+    }
+
+    public void setSubFieldOffsetList(List<FieldOffset> subFieldOffsetList) {
+        this.subFieldOffsetList = subFieldOffsetList;
+    }
+
+    public Field getField() {
+        return field;
+    }
+
+    @Override
+    public int compareTo(@NotNull FieldOffset that) {
+        return this.offsetValue.compareTo(that.offsetValue);
+    }
+
+
+}

core/src/test/java/cc/carm/test/config/offset/OffsetUtil.java

@@ -0,0 +1,63 @@
+//package config.offset;
+//
+//
+//import sun.misc.Unsafe;
+//
+//import java.lang.reflect.Field;
+//import java.lang.reflect.Modifier;
+//import java.util.Collections;
+//import java.util.LinkedList;
+//import java.util.List;
+//
+///**
+// * @author Chris2018998
+// */
+//public class OffsetUtil {
+//    private static Unsafe unsafe;
+//
+//    static {
+//        try {
+//            // 获取 Unsafe 内部的私有的实例化单例对象
+//            Field field = Unsafe.class.getDeclaredField("theUnsafe");
+//            // 无视权限
+//            field.setAccessible(true);
+//            unsafe = (Unsafe) field.get(null);
+//        } catch (NoSuchFieldException | IllegalAccessException e) {
+//            e.printStackTrace();
+//        }
+////        try {
+////            unsafe = AccessController.doPrivileged((PrivilegedExceptionAction<Unsafe>) () -> {
+////                Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
+////                theUnsafe.setAccessible(true);
+////                return (Unsafe) theUnsafe.get(null);
+////            });
+////        } catch (Throwable e) {
+////            System.err.println("Unable to load unsafe");
+////        }
+//    }
+//
+//    public static List<FieldOffset> getClassMemberOffset(Class<?> beanClass) {
+//        List<FieldOffset> offsetsList = new LinkedList<>();
+//        for (Field field : beanClass.getDeclaredFields()) {
+//            FieldOffset fieldOffset = new FieldOffset(field);
+//            offsetsList.add(fieldOffset);
+//            if (Modifier.isStatic(field.getModifiers()))
+//                fieldOffset.setOffsetValue(unsafe.staticFieldOffset(field));
+//            else
+//                fieldOffset.setOffsetValue(unsafe.objectFieldOffset(field));
+//            Class<?> fieldType = field.getType();
+//            if (!fieldType.getName().startsWith("java")) {
+//                Field[] subfields = fieldType.getDeclaredFields();
+//                if (subfields.length > 0) {
+//                    fieldOffset.setSubFieldOffsetList(getClassMemberOffset(fieldType));
+//                }
+//            }
+//        }
+//
+//        Collections.sort(offsetsList);
+//        return offsetsList;
+//    }
+//
+//
+//}
+//

demo/pom.xml

@@ -5,16 +5,16 @@
     <parent>
         <artifactId>easyconfiguration-parent</artifactId>
         <groupId>cc.carm.lib</groupId>
-        <version>1.0.1</version>
-        <relativePath>../../pom.xml</relativePath>
+        <version>3.8.0</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
     <properties>
-        <maven.compiler.source>${java.version}</maven.compiler.source>
-        <maven.compiler.target>${java.version}</maven.compiler.target>
+        <maven.compiler.source>${project.jdk.version}</maven.compiler.source>
+        <maven.compiler.target>${project.jdk.version}</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
     </properties>
-
-    <artifactId>easyconfiguration-spigot</artifactId>
+    <artifactId>easyconfiguration-demo</artifactId>
     <packaging>jar</packaging>
 
     <dependencies>
@@ -26,13 +26,6 @@
             <scope>compile</scope>
         </dependency>
 
-        <dependency>
-            <groupId>org.spigotmc</groupId>
-            <artifactId>spigot-api</artifactId>
-            <version>1.18.2-R0.1-SNAPSHOT</version>
-            <scope>provided</scope>
-        </dependency>
-
     </dependencies>
 
     <build>
@@ -56,5 +49,4 @@
         </plugins>
     </build>
 
-
 </project>

demo/src/main/java/cc/carm/lib/configuration/demo/DatabaseConfiguration.java

@@ -0,0 +1,34 @@
+package cc.carm.lib.configuration.demo;
+
+import cc.carm.lib.configuration.core.ConfigurationRoot;
+import cc.carm.lib.configuration.core.annotation.ConfigPath;
+import cc.carm.lib.configuration.core.annotation.HeaderComment;
+import cc.carm.lib.configuration.core.value.ConfigValue;
+import cc.carm.lib.configuration.core.value.type.ConfiguredValue;
+
+@HeaderComment({"", "数据库配置", "  用于提供数据库连接，进行数据库操作。"})
+public class DatabaseConfiguration extends ConfigurationRoot {
+
+    @ConfigPath("driver")
+    @HeaderComment({
+            "数据库驱动配置，请根据数据库类型设置。",
+            "- MySQL(旧): com.mysql.jdbc.Driver",
+            "- MySQL(新): com.mysql.cj.jdbc.Driver",
+            "- MariaDB(推荐): org.mariadb.jdbc.Driver",
+    })
+    protected static final ConfigValue<String> DRIVER_NAME = ConfiguredValue.of(
+            String.class, "com.mysql.cj.jdbc.Driver"
+    );
+
+    protected static final ConfigValue<String> HOST = ConfiguredValue.of(String.class, "127.0.0.1");
+    protected static final ConfigValue<Integer> PORT = ConfiguredValue.of(Integer.class, 3306);
+    protected static final ConfigValue<String> DATABASE = ConfiguredValue.of(String.class, "minecraft");
+    protected static final ConfigValue<String> USERNAME = ConfiguredValue.of(String.class, "root");
+    protected static final ConfigValue<String> PASSWORD = ConfiguredValue.of(String.class, "password");
+    protected static final ConfigValue<String> EXTRA = ConfiguredValue.of(String.class, "?useSSL=false");
+
+    protected static String buildJDBC() {
+        return String.format("jdbc:mysql://%s:%s/%s%s", HOST.get(), PORT.get(), DATABASE.get(), EXTRA.get());
+    }
+
+}

demo/src/main/java/cc/carm/lib/configuration/demo/tests/ConfigurationTest.java

@@ -0,0 +1,89 @@
+package cc.carm.lib.configuration.demo.tests;
+
+import cc.carm.lib.configuration.core.source.ConfigurationProvider;
+import cc.carm.lib.configuration.demo.tests.conf.DemoConfiguration;
+import cc.carm.lib.configuration.demo.tests.conf.TestConfiguration;
+import cc.carm.lib.configuration.demo.tests.model.TestModel;
+import org.jetbrains.annotations.TestOnly;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.UUID;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class ConfigurationTest {
+
+    @TestOnly
+    public static void testDemo(ConfigurationProvider<?> provider) {
+        provider.initialize(DemoConfiguration.class);
+
+        System.out.println("----------------------------------------------------");
+
+        System.out.println("Test Number: ");
+
+        System.out.println("before: " + DemoConfiguration.TEST_NUMBER.get());
+        DemoConfiguration.TEST_NUMBER.set((long) (Long.MAX_VALUE * Math.random()));
+        System.out.println("after: " + DemoConfiguration.TEST_NUMBER.get());
+
+        System.out.println("> Test Value:");
+        System.out.println("before: " + DemoConfiguration.Sub.UUID_CONFIG_VALUE.get());
+        DemoConfiguration.Sub.UUID_CONFIG_VALUE.set(UUID.randomUUID());
+        System.out.println("after: " + DemoConfiguration.Sub.UUID_CONFIG_VALUE.get());
+
+        System.out.println("> Test List:");
+
+        System.out.println(" Before:");
+        DemoConfiguration.Sub.That.OPERATORS.forEach(System.out::println);
+        List<UUID> operators = IntStream.range(0, 5).mapToObj(i -> UUID.randomUUID()).collect(Collectors.toList());
+        DemoConfiguration.Sub.That.OPERATORS.set(operators);
+        System.out.println(" After:");
+        DemoConfiguration.Sub.That.OPERATORS.forEach(System.out::println);
+
+        System.out.println("> Clear List:");
+        System.out.println(" Before: size :" + DemoConfiguration.Sub.That.OPERATORS.size());
+        DemoConfiguration.Sub.That.OPERATORS.modify(List::clear);
+        System.out.println(" After size :" + DemoConfiguration.Sub.That.OPERATORS.size());
+
+        System.out.println("> Test Section:");
+        System.out.println(DemoConfiguration.MODEL_TEST.get());
+        DemoConfiguration.MODEL_TEST.set(TestModel.random());
+
+        System.out.println("> Test Maps:");
+        DemoConfiguration.USERS.forEach((k, v) -> System.out.println(k + ": " + v));
+        LinkedHashMap<Integer, UUID> data = new LinkedHashMap<>();
+        for (int i = 1; i <= 5; i++) {
+            data.put(i, UUID.randomUUID());
+        }
+        DemoConfiguration.USERS.set(data);
+        System.out.println("----------------------------------------------------");
+    }
+
+    public static void testInner(ConfigurationProvider<?> provider) {
+
+        TestConfiguration TEST = new TestConfiguration();
+
+        provider.initialize(TEST, true);
+
+        System.out.println("> Test Inner value before:");
+        System.out.println(TEST.INNER.INNER_VALUE.getNotNull());
+
+        double after = Math.random() * 200D;
+        System.out.println("> Test Inner value -> " + after);
+        TEST.INNER.INNER_VALUE.set(after);
+
+        System.out.println("> Test Inner value after:");
+        System.out.println(TEST.INNER.INNER_VALUE.getNotNull());
+
+    }
+
+    public static void save(ConfigurationProvider<?> provider) {
+        try {
+            provider.save();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+
+}

demo/src/main/java/cc/carm/lib/configuration/demo/tests/conf/DemoConfiguration.java

@@ -0,0 +1,80 @@
+package cc.carm.lib.configuration.demo.tests.conf;
+
+import cc.carm.lib.configuration.core.ConfigInitializer;
+import cc.carm.lib.configuration.core.ConfigurationRoot;
+import cc.carm.lib.configuration.core.annotation.ConfigPath;
+import cc.carm.lib.configuration.core.annotation.HeaderComment;
+import cc.carm.lib.configuration.core.annotation.InlineComment;
+import cc.carm.lib.configuration.core.value.ConfigValue;
+import cc.carm.lib.configuration.core.value.type.ConfiguredList;
+import cc.carm.lib.configuration.core.value.type.ConfiguredMap;
+import cc.carm.lib.configuration.core.value.type.ConfiguredSection;
+import cc.carm.lib.configuration.core.value.type.ConfiguredValue;
+import cc.carm.lib.configuration.demo.tests.model.TestModel;
+
+import java.time.temporal.ChronoUnit;
+import java.util.Objects;
+import java.util.UUID;
+
+
+@HeaderComment({"此处内容将显示在配置文件的最上方"})
+public class DemoConfiguration extends ConfigurationRoot {
+
+    @ConfigPath(root = true)
+    protected static final ConfigValue<Double> VERSION = ConfiguredValue.of(Double.class, 1.0D);
+
+    @ConfigPath(root = true)
+    public static final ConfigValue<Long> TEST_NUMBER = ConfiguredValue.of(Long.class, 1000000L);
+
+    public static final ConfigValue<ChronoUnit> TEST_ENUM = ConfiguredValue.of(ChronoUnit.class, ChronoUnit.DAYS);
+
+    // 支持通过 Class<?> 变量标注子配置，一并注册。
+    // 注意： 若对应类也有注解，则优先使用类的注解。
+    @ConfigPath("other-class-config") //支持通过注解修改子配置的主路径，若不修改则以变量名自动生成。
+    @HeaderComment({"", "Something..."}) // 支持给子路径直接打注释
+    @InlineComment("InlineComments for class path")
+    public static final Class<?> OTHER = OtherConfiguration.class;
+
+    @ConfigPath("user") // 通过注解规定配置文件中的路径，若不进行注解则以变量名自动生成。
+    @HeaderComment({"Section类型数据测试"}) // 通过注解给配置添加注释。
+    @InlineComment("Section数据也支持InlineComment注释")
+    public static final ConfigValue<TestModel> MODEL_TEST = ConfiguredSection
+            .builderOf(TestModel.class)
+            .defaults(new TestModel("Carm", UUID.randomUUID()))
+            .parseValue((section, defaultValue) -> TestModel.deserialize(section))
+            .serializeValue(TestModel::serialize).build();
+
+    @HeaderComment({"[ID - UUID]对照表", "", "用于测试Map类型的解析与序列化保存"})
+    public static final ConfiguredMap<Integer, UUID> USERS = ConfiguredMap
+            .builderOf(Integer.class, UUID.class)
+            .asLinkedMap().fromString()
+            .parseKey(Integer::parseInt)
+            .parseValue(v -> Objects.requireNonNull(UUID.fromString(v)))
+            .build();
+
+
+    /**
+     * 支持内部类的直接注册。
+     * 注意，需要使用 {@link ConfigInitializer#initialize(Class, boolean, boolean)} 方法，并设定第三个参数为 true。
+     */
+    public static class Sub extends ConfigurationRoot {
+
+        @ConfigPath(value = "uuid-value", root = true)
+        @InlineComment("This is an inline comment")
+        public static final ConfigValue<UUID> UUID_CONFIG_VALUE = ConfiguredValue
+                .builderOf(UUID.class).fromString()
+                .parseValue((data, defaultValue) -> UUID.fromString(data))
+                .build();
+
+        public static class That extends ConfigurationRoot {
+
+            public static final ConfiguredList<UUID> OPERATORS = ConfiguredList
+                    .builderOf(UUID.class).fromString()
+                    .parseValue(s -> Objects.requireNonNull(UUID.fromString(s)))
+                    .build();
+
+        }
+    }
+
+
+}

demo/src/main/java/cc/carm/lib/configuration/demo/tests/conf/OtherConfiguration.java

@@ -0,0 +1,4 @@
+package cc.carm.lib.configuration.demo.tests.conf;
+
+public class OtherConfiguration {
+}

demo/src/main/java/cc/carm/lib/configuration/demo/tests/conf/TestConfiguration.java

@@ -0,0 +1,30 @@
+package cc.carm.lib.configuration.demo.tests.conf;
+
+import cc.carm.lib.configuration.core.ConfigurationRoot;
+import cc.carm.lib.configuration.core.annotation.ConfigPath;
+import cc.carm.lib.configuration.core.annotation.HeaderComment;
+import cc.carm.lib.configuration.core.annotation.InlineComment;
+import cc.carm.lib.configuration.core.value.ConfigValue;
+import cc.carm.lib.configuration.core.value.type.ConfiguredSection;
+import cc.carm.lib.configuration.core.value.type.ConfiguredValue;
+import cc.carm.lib.configuration.demo.tests.model.TestModel;
+
+import java.util.UUID;
+
+public class TestConfiguration extends ConfigurationRoot {
+
+    public final TestInnerConfiguration INNER = new TestInnerConfiguration();
+
+    public final ConfigValue<Double> CLASS_VALUE = ConfiguredValue.of(Double.class, 1.0D);
+
+    @ConfigPath("test.user") // 通过注解规定配置文件中的路径，若不进行注解则以变量名自动生成。
+    @HeaderComment({"Section类型数据测试"}) // 通过注解给配置添加注释。
+    @InlineComment("Section数据也支持InlineComment注释")
+    public final ConfigValue<TestModel> TEST_MODEL = ConfiguredSection
+            .builderOf(TestModel.class)
+            .defaults(new TestModel("Carm", UUID.randomUUID()))
+            .parseValue((section, defaultValue) -> TestModel.deserialize(section))
+            .serializeValue(TestModel::serialize).build();
+
+
+}

demo/src/main/java/cc/carm/lib/configuration/demo/tests/conf/TestInnerConfiguration.java

@@ -0,0 +1,13 @@
+package cc.carm.lib.configuration.demo.tests.conf;
+
+import cc.carm.lib.configuration.core.ConfigurationRoot;
+import cc.carm.lib.configuration.core.annotation.HeaderComment;
+import cc.carm.lib.configuration.core.value.ConfigValue;
+import cc.carm.lib.configuration.core.value.type.ConfiguredValue;
+
+@HeaderComment("Inner Test")
+public class TestInnerConfiguration extends ConfigurationRoot {
+
+    public final ConfigValue<Double> INNER_VALUE = ConfiguredValue.of(Double.class, 1.0D);
+
+}

demo/src/main/java/cc/carm/lib/configuration/demo/tests/model/AbstractModel.java

@@ -0,0 +1,16 @@
+package cc.carm.lib.configuration.demo.tests.model;
+
+import org.jetbrains.annotations.NotNull;
+
+public abstract class AbstractModel {
+
+    protected final @NotNull String name;
+
+    public AbstractModel(@NotNull String name) {
+        this.name = name;
+    }
+
+    public @NotNull String getName() {
+        return name;
+    }
+}

demo/src/main/java/cc/carm/lib/configuration/demo/tests/model/TestModel.java

@@ -0,0 +1,56 @@
+package cc.carm.lib.configuration.demo.tests.model;
+
+import cc.carm.lib.configuration.core.source.ConfigurationWrapper;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+public class TestModel extends AbstractModel {
+
+    public UUID uuid;
+
+    public TestModel(String name, UUID uuid) {
+        super(name);
+        this.uuid = uuid;
+    }
+
+    public void setUuid(UUID uuid) {
+        this.uuid = uuid;
+    }
+
+    public UUID getUuid() {
+        return uuid;
+    }
+
+    public @NotNull Map<String, Object> serialize() {
+        Map<String, Object> map = new HashMap<>();
+        map.put("name", name);
+        Map<String, Object> map2 = new HashMap<>();
+        map2.put("uuid", uuid.toString());
+        map.put("info", map2);
+        return map;
+    }
+
+    public static TestModel deserialize(ConfigurationWrapper<?> section) {
+        String name = section.getString("name");
+        if (name == null) throw new NullPointerException("name is null");
+        String uuidString = section.getString("info.uuid");
+        if (uuidString == null) throw new NullPointerException("uuid is null");
+        return new TestModel(name, UUID.fromString(uuidString));
+    }
+
+    public static TestModel random() {
+        return new TestModel(UUID.randomUUID().toString().substring(0, 5), UUID.randomUUID());
+    }
+
+
+    @Override
+    public String toString() {
+        return "TestUser{" +
+                "name='" + name + '\'' +
+                ", uuid=" + uuid +
+                '}';
+    }
+}

impl/hocon/pom.xml

@@ -2,23 +2,23 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
     <parent>
-        <artifactId>easyconfiguration-parent</artifactId>
         <groupId>cc.carm.lib</groupId>
-        <version>1.0.1</version>
+        <artifactId>easyconfiguration-parent</artifactId>
+        <version>3.8.0</version>
         <relativePath>../../pom.xml</relativePath>
     </parent>
-    <modelVersion>4.0.0</modelVersion>
     <properties>
-        <maven.compiler.source>${java.version}</maven.compiler.source>
-        <maven.compiler.target>${java.version}</maven.compiler.target>
+        <maven.compiler.source>${project.jdk.version}</maven.compiler.source>
+        <maven.compiler.target>${project.jdk.version}</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
     </properties>
-
-    <artifactId>easyconfiguration-bungee</artifactId>
+    <artifactId>easyconfiguration-hocon</artifactId>
     <packaging>jar</packaging>
 
     <dependencies>
-
         <dependency>
             <groupId>${project.parent.groupId}</groupId>
             <artifactId>easyconfiguration-core</artifactId>
@@ -27,21 +27,18 @@
         </dependency>
 
         <dependency>
-            <groupId>net.md-5</groupId>
-            <artifactId>bungeecord-api</artifactId>
-            <version>1.18-R0.1-SNAPSHOT</version>
-            <type>jar</type>
-            <scope>provided</scope>
+            <groupId>${project.parent.groupId}</groupId>
+            <artifactId>easyconfiguration-demo</artifactId>
+            <version>${project.parent.version}</version>
+            <scope>test</scope>
         </dependency>
 
         <dependency>
-            <groupId>net.md-5</groupId>
-            <artifactId>bungeecord-api</artifactId>
-            <version>1.18-R0.1-SNAPSHOT</version>
-            <type>javadoc</type>
-            <scope>provided</scope>
+            <groupId>com.typesafe</groupId>
+            <artifactId>config</artifactId>
+            <version>1.4.2</version>
+            <scope>compile</scope>
         </dependency>
-
     </dependencies>
 
     <build>
@@ -65,4 +62,5 @@
         </plugins>
     </build>
 
+
 </project>

impl/hocon/src/main/java/cc/carm/lib/configuration/EasyConfiguration.java

@@ -0,0 +1,36 @@
+package cc.carm.lib.configuration;
+
+import cc.carm.lib.configuration.hocon.HOCONFileConfigProvider;
+
+import java.io.File;
+import java.io.IOException;
+
+public class EasyConfiguration {
+
+    private EasyConfiguration() {
+    }
+
+    public static HOCONFileConfigProvider from(File file, String source) {
+        HOCONFileConfigProvider provider = new HOCONFileConfigProvider(file);
+        try {
+            provider.initializeFile(source);
+            provider.initializeConfig();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return provider;
+    }
+
+    public static HOCONFileConfigProvider from(File file) {
+        return from(file, file.getName());
+    }
+
+    public static HOCONFileConfigProvider from(String fileName) {
+        return from(fileName, fileName);
+    }
+
+    public static HOCONFileConfigProvider from(String fileName, String source) {
+        return from(new File(fileName), source);
+    }
+
+}

impl/hocon/src/main/java/cc/carm/lib/configuration/hocon/HOCONConfigWrapper.java

@@ -0,0 +1,117 @@
+package cc.carm.lib.configuration.hocon;
+
+import cc.carm.lib.configuration.core.source.ConfigurationWrapper;
+import cc.carm.lib.configuration.hocon.util.HOCONUtils;
+import com.typesafe.config.*;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.*;
+
+public class HOCONConfigWrapper implements ConfigurationWrapper<Map<String, Object>> {
+    private static final char SEPARATOR = '.';
+    protected final Map<String, Object> data;
+
+    public HOCONConfigWrapper(ConfigObject config) {
+        this.data = new LinkedHashMap<>();
+
+        config.forEach((key, value) -> {
+            Config cfg = config.toConfig();
+            ConfigValue cv = cfg.getValue(key);
+            if (cv.valueType() == ConfigValueType.OBJECT) {
+                HOCONConfigWrapper.this.data.put(key, new HOCONConfigWrapper((ConfigObject) cv));
+            } else {
+                HOCONConfigWrapper.this.data.put(key, value.unwrapped());
+            }
+        });
+    }
+
+    @Override
+    public @NotNull Map<String, Object> getSource() {
+        return this.data;
+    }
+
+    @Override
+    public @NotNull Set<String> getKeys(boolean deep) {
+        return this.getValues(deep).keySet();
+    }
+
+    @Override
+    public @NotNull Map<String, Object> getValues(boolean deep) {
+        return HOCONUtils.getKeysFromObject(this, deep, "").stream().collect(
+                LinkedHashMap::new,
+                (map, key) -> map.put(key, get(key)),
+                LinkedHashMap::putAll
+        );
+    }
+
+    @Override
+    public void set(@NotNull String path, @Nullable Object value) {
+        if (value instanceof Map) {
+            //noinspection unchecked
+            value = new HOCONConfigWrapper(ConfigFactory.parseMap((Map<String, ?>) value).root());
+        }
+
+        HOCONConfigWrapper section = HOCONUtils.getObjectOn(this, path, SEPARATOR);
+        String simplePath = HOCONUtils.getSimplePath(path, SEPARATOR);
+
+        if (value == null) {
+            section.data.remove(simplePath);
+        } else {
+            section.setDirect(simplePath, value);
+        }
+    }
+
+    /**
+     * 只能设置当前路径下的内容
+     * 避免环回
+     *
+     * @param path 路径
+     */
+    public void setDirect(@NotNull String path, @Nullable Object value) {
+        this.data.put(path, value);
+    }
+
+    @Override
+    public boolean contains(@NotNull String path) {
+        return this.get(path) != null;
+    }
+
+    @Override
+    public @Nullable Object get(@NotNull String path) {
+        HOCONConfigWrapper section = HOCONUtils.getObjectOn(this, path, SEPARATOR);
+        return section.getDirect(HOCONUtils.getSimplePath(path, SEPARATOR));
+    }
+
+    /**
+     * 只能获取当前路径下的内容
+     * 避免环回
+     *
+     * @param path 路径
+     */
+    public Object getDirect(@NotNull String path) {
+        return this.data.get(path);
+    }
+
+    @Override
+    public boolean isList(@NotNull String path) {
+        return this.get(path) instanceof List<?>;
+    }
+
+    @Override
+    public @Nullable List<?> getList(@NotNull String path) {
+        Object val = this.get(path);
+        return (val instanceof List<?>) ? (List<?>) val : null;
+    }
+
+    @Override
+    public boolean isConfigurationSection(@NotNull String path) {
+        return this.get(path) instanceof HOCONConfigWrapper;
+    }
+
+    @Override
+    public @Nullable ConfigurationWrapper<Map<String, Object>> getConfigurationSection(@NotNull String path) {
+        Object val = get(path);
+        return (val instanceof HOCONConfigWrapper) ? (HOCONConfigWrapper) val : null;
+    }
+}

impl/hocon/src/main/java/cc/carm/lib/configuration/hocon/HOCONFileConfigProvider.java

@@ -0,0 +1,106 @@
+package cc.carm.lib.configuration.hocon;
+
+import cc.carm.lib.configuration.core.ConfigInitializer;
+import cc.carm.lib.configuration.core.source.ConfigurationComments;
+import cc.carm.lib.configuration.core.source.impl.FileConfigProvider;
+import cc.carm.lib.configuration.hocon.exception.HOCONGetValueException;
+import cc.carm.lib.configuration.hocon.util.HOCONUtils;
+import com.typesafe.config.*;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.List;
+import java.util.Set;
+
+public class HOCONFileConfigProvider extends FileConfigProvider<HOCONConfigWrapper> {
+    protected final @NotNull ConfigurationComments comments = new ConfigurationComments();
+    protected HOCONConfigWrapper configuration;
+    protected ConfigInitializer<HOCONFileConfigProvider> initializer;
+
+    public HOCONFileConfigProvider(@NotNull File file) {
+        super(file);
+        this.initializer = new ConfigInitializer<>(this);
+    }
+
+    public void initializeConfig() {
+        try {
+            this.configuration = new HOCONConfigWrapper(ConfigFactory.parseFile(this.file, ConfigParseOptions.defaults()
+                    .setSyntax(ConfigSyntax.CONF)
+                    .setAllowMissing(false)).root());
+        } catch (ConfigException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public @NotNull HOCONConfigWrapper getConfiguration() {
+        return this.configuration;
+    }
+
+    @Override
+    public void save() throws IOException {
+        Files.write(this.file.toPath(), HOCONUtils.renderWithComment(configuration, comments::getHeaderComment).getBytes(StandardCharsets.UTF_8));
+    }
+
+    @Override
+    protected void onReload() throws ConfigException {
+        ConfigObject conf = ConfigFactory.parseFile(this.file, ConfigParseOptions.defaults()
+                .setSyntax(ConfigSyntax.CONF)
+                .setAllowMissing(false)).root();
+        this.configuration = new HOCONConfigWrapper(conf);
+    }
+
+    @Override
+    public @NotNull ConfigurationComments getComments() {
+        return this.comments;
+    }
+
+    @Override
+    public @NotNull ConfigInitializer<HOCONFileConfigProvider> getInitializer() {
+        return this.initializer;
+    }
+
+    public String serializeValue(@NotNull String key, @NotNull Object value) {
+        // 带有 key=value 的新空对象
+        return ConfigFactory.empty()
+                .withValue(key, ConfigValueFactory.fromAnyRef(value))
+                .root().render();
+    }
+
+    public @NotNull Set<String> getKeys() {
+        return getKeys(null, true);
+    }
+
+    @Contract("null,_->!null")
+    public @Nullable Set<String> getKeys(@Nullable String sectionKey, boolean deep) {
+        if (sectionKey == null) { // 当前路径
+            return HOCONUtils.getKeysFromObject(this.configuration, deep, "");
+        }
+
+        HOCONConfigWrapper section;
+        try {
+            // 获取目标字段所在路径
+            section = (HOCONConfigWrapper) this.configuration.get(sectionKey);
+        } catch (ClassCastException e) {
+            // 值和类型不匹配
+            throw new HOCONGetValueException(e);
+        }
+        if (section == null) {
+            return null;
+        }
+        return HOCONUtils.getKeysFromObject(section, deep, "");
+    }
+
+    public @Nullable Object getValue(@NotNull String key) {
+        return this.configuration.get(key);
+    }
+
+    public @Nullable List<String> getHeaderComments(@Nullable String key) {
+        return this.comments.getHeaderComment(key);
+    }
+}

impl/hocon/src/main/java/cc/carm/lib/configuration/hocon/exception/HOCONGetValueException.java

@@ -0,0 +1,19 @@
+package cc.carm.lib.configuration.hocon.exception;
+
+public class HOCONGetValueException extends RuntimeException {
+    public HOCONGetValueException() {
+        super();
+    }
+
+    public HOCONGetValueException(String message) {
+        super(message);
+    }
+
+    public HOCONGetValueException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public HOCONGetValueException(Throwable cause) {
+        super(cause);
+    }
+}

impl/hocon/src/main/java/cc/carm/lib/configuration/hocon/util/HOCONUtils.java

@@ -0,0 +1,110 @@
+package cc.carm.lib.configuration.hocon.util;
+
+import cc.carm.lib.configuration.hocon.HOCONConfigWrapper;
+import cc.carm.lib.configuration.hocon.exception.HOCONGetValueException;
+import com.typesafe.config.*;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+
+public class HOCONUtils {
+
+    private HOCONUtils() {
+    }
+
+    public static String getSimplePath(String path, char separator) {
+        int index = path.lastIndexOf(separator);
+        return (index == -1) ? path : path.substring(index + 1);
+    }
+
+    public static HOCONConfigWrapper getObjectOn(@NotNull HOCONConfigWrapper parent, @NotNull String path, char separator) {
+        String currentPath = path;
+        HOCONConfigWrapper currentObject = parent;
+        int index;
+        while ((index = currentPath.indexOf(separator)) != -1) {
+            HOCONConfigWrapper previousObject = currentObject;
+            String pathName = currentPath.substring(0, index);
+            try {
+                currentObject = (HOCONConfigWrapper) previousObject.getDirect(pathName);
+            } catch (ClassCastException e) {
+                throw new HOCONGetValueException(e);
+            }
+            if (currentObject == null) {
+                currentObject = new HOCONConfigWrapper(ConfigFactory.empty().root());
+                previousObject.setDirect(pathName, currentObject);
+            }
+            currentPath = currentPath.substring(index + 1);
+        }
+
+        return currentObject;
+    }
+
+    /**
+     * 在 Object 中获取所有键
+     * 思路：在第一次执行时 prefix 应该是 ""
+     * 后续找到了更深层的键，将会变为 "deep."
+     * 下一次键名就是 "deep.key"
+     *
+     * @param parent Object
+     * @param deep   是否更深层获取
+     * @param prefix 当前 Object 键名前缀
+     * @return Object 中的所有键
+     */
+    public static Set<String> getKeysFromObject(HOCONConfigWrapper parent, boolean deep, String prefix) {
+        return parent.getSource().entrySet().stream().collect(
+                LinkedHashSet::new,
+                (set, entry) -> {
+                    Object value = entry.getValue();
+                    if (value instanceof HOCONConfigWrapper && deep) {
+                        set.addAll(HOCONUtils.getKeysFromObject((HOCONConfigWrapper) value, true, prefix + entry.getKey() + "."));
+                    } else {
+                        set.add(prefix + entry.getKey());
+                    }
+                },
+                LinkedHashSet::addAll
+        );
+    }
+
+    /**
+     * 将 Object 保存为字符串
+     * 并使用注释器打上注释
+     *
+     * @param object    Object
+     * @param commenter 注释器
+     * @return 保存的字符串
+     */
+    public static @NotNull String renderWithComment(@NotNull HOCONConfigWrapper object, @NotNull Function<String, List<String>> commenter) {
+        return HOCONUtils.makeConfigWithComment(object, "", commenter).root().render(
+                ConfigRenderOptions.defaults()
+                        .setJson(false)
+                        .setOriginComments(false)
+        );
+    }
+
+    public static @NotNull Config makeConfigWithComment(@NotNull HOCONConfigWrapper object, @NotNull String prefix, @NotNull Function<String, List<String>> commenter) {
+        Config config = ConfigFactory.empty();
+        for (Map.Entry<String, Object> entry : object.getSource().entrySet()) {
+            String key = entry.getKey();
+            String fullKey = prefix + key;
+            Object value = entry.getValue();
+            ConfigValue result;
+            if (value instanceof Iterable) {
+                result = ConfigValueFactory.fromIterable((Iterable<?>) value);
+            } else if (value instanceof HOCONConfigWrapper) {
+                result = makeConfigWithComment((HOCONConfigWrapper) value, fullKey + ".", commenter).root();
+            } else {
+                result = ConfigValueFactory.fromAnyRef(value);
+            }
+            result = result.withOrigin(
+                    ConfigOriginFactory.newSimple()
+                            .withComments(commenter.apply(fullKey))
+            );
+            config = config.withValue(key, result);
+        }
+        return config;
+    }
+}

impl/hocon/src/test/java/online/flowerinsnow/test/easyconfiguration/HOCONTest.java

@@ -0,0 +1,24 @@
+package online.flowerinsnow.test.easyconfiguration;
+
+import cc.carm.lib.configuration.EasyConfiguration;
+//import cc.carm.lib.configuration.demo.DatabaseConfiguration;
+//import cc.carm.lib.configuration.demo.tests.conf.DemoConfiguration;
+import cc.carm.lib.configuration.hocon.HOCONFileConfigProvider;
+import online.flowerinsnow.test.easyconfiguration.config.Config;
+import org.junit.Test;
+
+import java.io.File;
+
+public class HOCONTest {
+    @Test
+    public void onTest() {
+        HOCONFileConfigProvider provider = EasyConfiguration.from(new File("target/hocon.conf"));
+        provider.initialize(Config.class);
+//        provider.initialize(DatabaseConfiguration.class);
+        try {
+            provider.reload();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}

impl/hocon/src/test/java/online/flowerinsnow/test/easyconfiguration/config/Config.java

@@ -0,0 +1,25 @@
+package online.flowerinsnow.test.easyconfiguration.config;
+
+import cc.carm.lib.configuration.core.ConfigurationRoot;
+import cc.carm.lib.configuration.core.annotation.HeaderComment;
+import cc.carm.lib.configuration.core.value.type.ConfiguredList;
+import cc.carm.lib.configuration.core.value.type.ConfiguredValue;
+
+public class Config extends ConfigurationRoot {
+    @HeaderComment("测试字段 int")
+    public static final ConfiguredValue<Integer> TEST_INT = ConfiguredValue.of(Integer.class, 15);
+
+    @HeaderComment("测试字段 List<String>")
+    public static final ConfiguredList<String> TEST_LIST_STRING = ConfiguredList.of(String.class, "li", "li", "li1");
+
+    @HeaderComment("测试对象")
+    public static class TestObject extends ConfigurationRoot {
+        @HeaderComment("测试字段 Boolean")
+        public static final ConfiguredValue<Boolean> TEST_BOOLEAN = ConfiguredValue.of(Boolean.class, true);
+        @HeaderComment("inner")
+        public static class InnerObject extends ConfigurationRoot {
+            @HeaderComment("测试字段")
+            public static final ConfiguredValue<Boolean> TEST_BOOLEAN_1 = ConfiguredValue.of(Boolean.class, true);
+        }
+    }
+}

impl/json/pom.xml

@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>easyconfiguration-parent</artifactId>
+        <groupId>cc.carm.lib</groupId>
+        <version>3.8.0</version>
+        <relativePath>../../pom.xml</relativePath>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+    <properties>
+        <maven.compiler.source>${project.jdk.version}</maven.compiler.source>
+        <maven.compiler.target>${project.jdk.version}</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
+    </properties>
+    <artifactId>easyconfiguration-json</artifactId>
+    <packaging>jar</packaging>
+
+    <dependencies>
+
+        <dependency>
+            <groupId>${project.parent.groupId}</groupId>
+            <artifactId>easyconfiguration-core</artifactId>
+            <version>${project.parent.version}</version>
+            <scope>compile</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>${project.parent.groupId}</groupId>
+            <artifactId>easyconfiguration-demo</artifactId>
+            <version>${project.parent.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <version>2.10.1</version>
+            <scope>compile</scope>
+        </dependency>
+
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-source-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-javadoc-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>

impl/json/src/main/java/cc/carm/lib/configuration/EasyConfiguration.java

@@ -0,0 +1,36 @@
+package cc.carm.lib.configuration;
+
+import cc.carm.lib.configuration.json.JSONConfigProvider;
+
+import java.io.File;
+import java.io.IOException;
+
+public class EasyConfiguration {
+
+    private EasyConfiguration() {
+    }
+
+    public static JSONConfigProvider from(File file, String source) {
+        JSONConfigProvider provider = new JSONConfigProvider(file);
+        try {
+            provider.initializeFile(source);
+            provider.initializeConfig();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return provider;
+    }
+
+    public static JSONConfigProvider from(File file) {
+        return from(file, file.getName());
+    }
+
+    public static JSONConfigProvider from(String fileName) {
+        return from(fileName, fileName);
+    }
+
+    public static JSONConfigProvider from(String fileName, String source) {
+        return from(new File(fileName), source);
+    }
+
+}

impl/json/src/main/java/cc/carm/lib/configuration/json/JSONConfigProvider.java

@@ -0,0 +1,81 @@
+package cc.carm.lib.configuration.json;
+
+import cc.carm.lib.configuration.core.ConfigInitializer;
+import cc.carm.lib.configuration.core.source.ConfigurationComments;
+import cc.carm.lib.configuration.core.source.ConfigurationProvider;
+import cc.carm.lib.configuration.core.source.impl.FileConfigProvider;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonSerializer;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+import java.util.LinkedHashMap;
+
+/**
+ * Some code comes from BungeeCord's implementation of the JsonConfiguration.
+ *
+ * @author md_5, CarmJos
+ */
+public class JSONConfigProvider extends FileConfigProvider<JSONConfigWrapper> {
+
+    protected final Gson gson = new GsonBuilder()
+            .serializeNulls().disableHtmlEscaping().setPrettyPrinting()
+            .registerTypeAdapter(
+                    JSONConfigWrapper.class,
+                    (JsonSerializer<JSONConfigWrapper>) (src, typeOfSrc, context) -> context.serialize(src.data)
+            ).create();
+
+    protected JSONConfigWrapper configuration;
+    protected ConfigInitializer<JSONConfigProvider> initializer;
+
+    public JSONConfigProvider(@NotNull File file) {
+        super(file);
+        this.initializer = new ConfigInitializer<>(this);
+    }
+
+    public void initializeConfig() {
+        LinkedHashMap<?, ?> map = null;
+
+        try (FileInputStream is = new FileInputStream(file)) {
+            map = gson.fromJson(new InputStreamReader(is, StandardCharsets.UTF_8), LinkedHashMap.class);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        if (map == null) map = new LinkedHashMap<>();
+
+        this.configuration = new JSONConfigWrapper(map);
+    }
+
+    @Override
+    public @NotNull JSONConfigWrapper getConfiguration() {
+        return this.configuration;
+    }
+
+    @Override
+    protected void onReload() throws Exception {
+        super.reload();
+        initializeConfig();
+    }
+
+    @Override
+    public @Nullable ConfigurationComments getComments() {
+        return null;
+    }
+
+    @Override
+    public void save() throws Exception {
+        try (Writer writer = new OutputStreamWriter(new FileOutputStream(file), StandardCharsets.UTF_8)) {
+            gson.toJson(configuration.data, writer);
+        }
+    }
+
+    @Override
+    public @NotNull ConfigInitializer<? extends ConfigurationProvider<JSONConfigWrapper>> getInitializer() {
+        return this.initializer;
+    }
+
+}

impl/json/src/main/java/cc/carm/lib/configuration/json/JSONConfigWrapper.java

@@ -0,0 +1,137 @@
+package cc.carm.lib.configuration.json;
+
+import cc.carm.lib.configuration.core.source.ConfigurationWrapper;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Some code comes from BungeeCord's implementation of the JsonConfiguration.
+ *
+ * @author md_5, CarmJos
+ */
+public class JSONConfigWrapper implements ConfigurationWrapper<Map<String, Object>> {
+
+    private static final char SEPARATOR = '.';
+    protected final Map<String, Object> data;
+
+    JSONConfigWrapper(Map<?, ?> map) {
+        this.data = new LinkedHashMap<>();
+
+        for (Map.Entry<?, ?> entry : map.entrySet()) {
+            String key = (entry.getKey() == null) ? "null" : entry.getKey().toString();
+
+            if (entry.getValue() instanceof Map) {
+                this.data.put(key, new JSONConfigWrapper((Map<?, ?>) entry.getValue()));
+            } else {
+                this.data.put(key, entry.getValue());
+            }
+        }
+    }
+
+    @Override
+    public @NotNull Map<String, Object> getSource() {
+        return this.data;
+    }
+
+    @Override
+    public @NotNull Set<String> getKeys(boolean deep) {
+        return getValues(deep).keySet();
+    }
+
+    @Override
+    public @NotNull Map<String, Object> getValues(boolean deep) {
+        if (deep) {
+            Map<String, Object> values = new LinkedHashMap<>();
+            mapChildrenValues(values, this, null, true);
+            return values;
+        } else return new LinkedHashMap<>(this.data);
+    }
+
+    @Override
+    public void set(@NotNull String path, @Nullable Object value) {
+        if (value instanceof Map) {
+            value = new JSONConfigWrapper((Map<?, ?>) value);
+        }
+
+        JSONConfigWrapper section = getSectionFor(path);
+        if (section == this) {
+            if (value == null) {
+                this.data.remove(path);
+            } else {
+                this.data.put(path, value);
+            }
+        } else {
+            section.set(getChild(path), value);
+        }
+    }
+
+    @Override
+    public boolean contains(@NotNull String path) {
+        return get(path) != null;
+    }
+
+    @Override
+    public @Nullable Object get(@NotNull String path) {
+        JSONConfigWrapper section = getSectionFor(path);
+        return section == this ? data.get(path) : section.get(getChild(path));
+    }
+
+    @Override
+    public boolean isList(@NotNull String path) {
+        return get(path) instanceof List<?>;
+    }
+
+    @Override
+    public @Nullable List<?> getList(@NotNull String path) {
+        Object val = get(path);
+        return (val instanceof List<?>) ? (List<?>) val : null;
+    }
+
+    @Override
+    public boolean isConfigurationSection(@NotNull String path) {
+        return get(path) instanceof JSONConfigWrapper;
+    }
+
+    @Override
+    public @Nullable JSONConfigWrapper getConfigurationSection(@NotNull String path) {
+        Object val = get(path);
+        return (val instanceof JSONConfigWrapper) ? (JSONConfigWrapper) val : null;
+    }
+
+    private JSONConfigWrapper getSectionFor(String path) {
+        int index = path.indexOf(SEPARATOR);
+        if (index == -1) return this;
+
+        String root = path.substring(0, index);
+        Object section = this.data.get(root);
+        if (section == null) {
+            section = new JSONConfigWrapper(new LinkedHashMap<>());
+            this.data.put(root, section);
+        }
+
+        return (JSONConfigWrapper) section;
+    }
+
+    private String getChild(String path) {
+        int index = path.indexOf(SEPARATOR);
+        return (index == -1) ? path : path.substring(index + 1);
+    }
+
+
+    protected void mapChildrenValues(@NotNull Map<String, Object> output, @NotNull JSONConfigWrapper section,
+                                     @Nullable String parent, boolean deep) {
+        for (Map.Entry<String, Object> entry : section.data.entrySet()) {
+            String path = (parent == null ? "" : parent + ".") + entry.getKey();
+            output.remove(path);
+            output.put(path, entry.getValue());
+            if (deep && entry.getValue() instanceof JSONConfigWrapper) {
+                this.mapChildrenValues(output, (JSONConfigWrapper) entry.getValue(), path, true);
+            }
+        }
+    }
+}

impl/json/src/test/java/config/JSONConfigTest.java

@@ -0,0 +1,29 @@
+package config;
+
+import cc.carm.lib.configuration.EasyConfiguration;
+import cc.carm.lib.configuration.demo.tests.ConfigurationTest;
+import cc.carm.lib.configuration.json.JSONConfigProvider;
+import org.junit.Test;
+
+public class JSONConfigTest {
+
+    protected final JSONConfigProvider provider = EasyConfiguration.from("target/config.json", "config.json");
+
+
+    @Test
+    public void onTest() {
+
+        ConfigurationTest.testDemo(this.provider);
+        ConfigurationTest.testInner(this.provider);
+
+        System.out.println("----------------------------------------------------");
+        provider.getConfiguration().getValues(true).forEach((k, v) -> System.out.println(k + ": " + v));
+        System.out.println("----------------------------------------------------");
+        provider.getConfiguration().getValues(false).forEach((k, v) -> System.out.println(k + ": " + v));
+        System.out.println("----------------------------------------------------");
+        
+        ConfigurationTest.save(this.provider);
+    }
+
+
+}

impl/sql/pom.xml

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>easyconfiguration-parent</artifactId>
+        <groupId>cc.carm.lib</groupId>
+        <version>3.8.0</version>
+        <relativePath>../../pom.xml</relativePath>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+    <properties>
+        <maven.compiler.source>${project.jdk.version}</maven.compiler.source>
+        <maven.compiler.target>${project.jdk.version}</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
+
+        <maven.deploy.skip>true</maven.deploy.skip>
+    </properties>
+    <artifactId>easyconfiguration-sql</artifactId>
+
+    <dependencies>
+
+        <dependency>
+            <groupId>${project.parent.groupId}</groupId>
+            <artifactId>easyconfiguration-core</artifactId>
+            <version>${project.parent.version}</version>
+            <scope>compile</scope>
+        </dependency>
+
+    </dependencies>
+
+</project>

impl/sql/src/main/java/cc/carm/lib/configuration/EasyConfiguration.java

@@ -0,0 +1,8 @@
+package cc.carm.lib.configuration;
+
+public class EasyConfiguration {
+    
+    private EasyConfiguration() {
+    }
+
+}

impl/sql/src/main/java/cc/carm/lib/configuration/sql/SQLConfigProvider.java

@@ -0,0 +1,38 @@
+package cc.carm.lib.configuration.sql;
+
+import cc.carm.lib.configuration.core.ConfigInitializer;
+import cc.carm.lib.configuration.core.source.ConfigurationComments;
+import cc.carm.lib.configuration.core.source.ConfigurationProvider;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class SQLConfigProvider extends ConfigurationProvider<SQLSectionWrapper> {
+
+
+    @Override
+    public @NotNull SQLSectionWrapper getConfiguration() {
+        return null;
+    }
+
+    @Override
+    public void save() throws Exception {
+
+    }
+
+    @Override
+    protected void onReload() throws Exception {
+
+    }
+
+    @Override
+    public @Nullable ConfigurationComments getComments() {
+        return null;
+    }
+
+    @Override
+    public @NotNull ConfigInitializer<? extends ConfigurationProvider<SQLSectionWrapper>> getInitializer() {
+        return null;
+    }
+
+
+}

impl/sql/src/main/java/cc/carm/lib/configuration/sql/SQLSectionWrapper.java

@@ -0,0 +1,63 @@
+package cc.carm.lib.configuration.sql;
+
+import cc.carm.lib.configuration.core.source.ConfigurationWrapper;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class SQLSectionWrapper implements ConfigurationWrapper<Map<String, Object>> {
+
+    @Override
+    public @NotNull Map<String, Object> getSource() {
+        return null;
+    }
+
+    @Override
+    public @NotNull Set<String> getKeys(boolean deep) {
+        return null;
+    }
+
+    @Override
+    public @NotNull Map<String, Object> getValues(boolean deep) {
+        return null;
+    }
+
+    @Override
+    public void set(@NotNull String path, @Nullable Object value) {
+
+    }
+
+    @Override
+    public boolean contains(@NotNull String path) {
+        return false;
+    }
+
+    @Override
+    public @Nullable Object get(@NotNull String path) {
+        return null;
+    }
+
+    @Override
+    public boolean isList(@NotNull String path) {
+        return false;
+    }
+
+    @Override
+    public @Nullable List<?> getList(@NotNull String path) {
+        return null;
+    }
+
+    @Override
+    public boolean isConfigurationSection(@NotNull String path) {
+        return false;
+    }
+
+    @Override
+    public @Nullable SQLSectionWrapper getConfigurationSection(@NotNull String path) {
+        return null;
+    }
+
+}

impl/sql/src/main/java/cc/carm/lib/configuration/sql/SQLValueParser.java

@@ -0,0 +1,7 @@
+package cc.carm.lib.configuration.sql;
+
+public class SQLValueParser {
+
+
+
+}

impl/sql/table_schem.sql

@@ -0,0 +1,14 @@
+CREATE TABLE IF NOT EXISTS conf
+(
+    `namespace`       VARCHAR(255)     NOT NULL,                           # 命名空间
+    `path`            VARCHAR(255)     NOT NULL,                           # 配置路径 (ConfigPath)
+    `type`            TINYINT UNSIGNED NOT NULL DEFAULT 0,                 # 数据类型 (Integer/Byte/List/Map/...)
+    `value`           MEDIUMTEXT,                                          # 配置项的值 (可能为JSON格式)
+    `inline_comments` TEXT,                                                # 行内注释
+    `header_comments` MEDIUMTEXT,                                          # 顶部注释
+    `create_time`     DATETIME         NOT NULL DEFAULT CURRENT_TIMESTAMP, # 创建时间
+    `update_time`     DATETIME         NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    PRIMARY KEY (`namespace`, `path`)
+) ENGINE = InnoDB
+  DEFAULT CHARSET = utf8mb4;
+

impl/yaml/pom.xml

@@ -5,13 +5,15 @@
     <parent>
         <artifactId>easyconfiguration-parent</artifactId>
         <groupId>cc.carm.lib</groupId>
-        <version>1.0.1</version>
+        <version>3.8.0</version>
         <relativePath>../../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
     <properties>
-        <maven.compiler.source>${java.version}</maven.compiler.source>
-        <maven.compiler.target>${java.version}</maven.compiler.target>
+        <maven.compiler.source>${project.jdk.version}</maven.compiler.source>
+        <maven.compiler.target>${project.jdk.version}</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
     </properties>
 
     <artifactId>easyconfiguration-yaml</artifactId>
@@ -28,8 +30,21 @@
 
         <dependency>
             <groupId>cc.carm.lib</groupId>
-            <artifactId>yamlconfiguration-commented</artifactId>
-            <version>2.0.2</version>
+            <artifactId>yamlcommentwriter</artifactId>
+            <version>1.0.1</version>
+            <scope>compile</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>${project.parent.groupId}</groupId>
+            <artifactId>easyconfiguration-demo</artifactId>
+            <version>${project.parent.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.bspfsystems</groupId>
+            <artifactId>yamlconfiguration</artifactId>
+            <version>1.3.3</version>
             <scope>compile</scope>
         </dependency>
 

impl/yaml/src/main/java/cc/carm/lib/configuration/EasyConfiguration.java

@@ -1,34 +1,36 @@
 package cc.carm.lib.configuration;
 
-import cc.carm.lib.configuration.yaml.YamlConfigProvider;
+import cc.carm.lib.configuration.yaml.YAMLConfigProvider;
 
 import java.io.File;
 import java.io.IOException;
 
 public class EasyConfiguration {
+    
+    private EasyConfiguration() {
+    }
 
-    public static YamlConfigProvider from(File file, String source) {
-        YamlConfigProvider provider = new YamlConfigProvider(file);
+    public static YAMLConfigProvider from(File file, String source) {
+        YAMLConfigProvider provider = new YAMLConfigProvider(file);
         try {
             provider.initializeFile(source);
-            provider.initialize();
+            provider.initializeConfig();
         } catch (IOException e) {
             e.printStackTrace();
         }
         return provider;
     }
 
-    public static YamlConfigProvider from(File file) {
+    public static YAMLConfigProvider from(File file) {
         return from(file, file.getName());
     }
 
-    public static YamlConfigProvider from(String fileName) {
+    public static YAMLConfigProvider from(String fileName) {
         return from(fileName, fileName);
     }
 
-    public static YamlConfigProvider from(String fileName, String source) {
+    public static YAMLConfigProvider from(String fileName, String source) {
         return from(new File(fileName), source);
     }
 
-
 }

impl/yaml/src/main/java/cc/carm/lib/configuration/yaml/YAMLConfigProvider.java

@@ -0,0 +1,90 @@
+package cc.carm.lib.configuration.yaml;
+
+import cc.carm.lib.configuration.core.ConfigInitializer;
+import cc.carm.lib.configuration.core.source.ConfigurationComments;
+import cc.carm.lib.configuration.core.source.impl.FileConfigProvider;
+import cc.carm.lib.yamlcommentupdater.CommentedYAML;
+import cc.carm.lib.yamlcommentupdater.CommentedYAMLWriter;
+import org.bspfsystems.yamlconfiguration.configuration.ConfigurationSection;
+import org.bspfsystems.yamlconfiguration.file.FileConfiguration;
+import org.bspfsystems.yamlconfiguration.file.YamlConfiguration;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.File;
+import java.util.List;
+import java.util.Set;
+
+public class YAMLConfigProvider extends FileConfigProvider<YAMLSectionWrapper> implements CommentedYAML {
+
+    protected final @NotNull ConfigurationComments comments = new ConfigurationComments();
+    protected YamlConfiguration configuration;
+    protected ConfigInitializer<YAMLConfigProvider> initializer;
+
+    public YAMLConfigProvider(@NotNull File file) {
+        super(file);
+    }
+
+    public void initializeConfig() {
+        this.configuration = YamlConfiguration.loadConfiguration(file);
+        this.initializer = new ConfigInitializer<>(this);
+    }
+
+    @Override
+    public @NotNull YAMLSectionWrapper getConfiguration() {
+        return YAMLSectionWrapper.of(configuration);
+    }
+
+    @Override
+    protected void onReload() throws Exception {
+        configuration.load(getFile());
+    }
+
+    @Override
+    public @NotNull ConfigurationComments getComments() {
+        return this.comments;
+    }
+
+    @Override
+    public void save() throws Exception {
+        try {
+            CommentedYAMLWriter.writeWithComments(this, this.file);
+        } catch (Exception ex) {
+            configuration.save(file);
+            throw ex;
+        }
+    }
+
+    @Override
+    public @NotNull ConfigInitializer<YAMLConfigProvider> getInitializer() {
+        return this.initializer;
+    }
+
+    @Override
+    public String serializeValue(@NotNull String key, @NotNull Object value) {
+        FileConfiguration temp = new YamlConfiguration();
+        temp.set(key, value);
+        return temp.saveToString();
+    }
+
+    @Override
+    public Set<String> getKeys(@Nullable String sectionKey, boolean deep) {
+        if (sectionKey == null) return configuration.getKeys(deep);
+
+        ConfigurationSection section = configuration.getConfigurationSection(sectionKey);
+        if (section == null) return null;
+
+        return section.getKeys(deep);
+    }
+
+    @Override
+    public @Nullable Object getValue(@NotNull String key) {
+        return configuration.get(key);
+    }
+
+    @Override
+    public @Nullable List<String> getHeaderComments(@Nullable String key) {
+        return comments.getHeaderComment(key);
+    }
+
+}

impl/yaml/src/main/java/cc/carm/lib/configuration/yaml/YAMLSectionWrapper.java

@@ -2,6 +2,7 @@ package cc.carm.lib.configuration.yaml;
 
 import cc.carm.lib.configuration.core.source.ConfigurationWrapper;
 import org.bspfsystems.yamlconfiguration.configuration.ConfigurationSection;
+import org.bspfsystems.yamlconfiguration.serialization.ConfigurationSerializable;
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -11,17 +12,22 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
-public class YamlSectionWrapper implements ConfigurationWrapper {
+public class YAMLSectionWrapper implements ConfigurationWrapper<ConfigurationSection> {
 
     private final ConfigurationSection section;
 
-    private YamlSectionWrapper(ConfigurationSection section) {
+    private YAMLSectionWrapper(ConfigurationSection section) {
         this.section = section;
     }
 
     @Contract("!null->!null")
-    public static @Nullable YamlSectionWrapper of(@Nullable ConfigurationSection section) {
-        return section == null ? null : new YamlSectionWrapper(section);
+    public static @Nullable YAMLSectionWrapper of(@Nullable ConfigurationSection section) {
+        return section == null ? null : new YAMLSectionWrapper(section);
+    }
+
+    @Override
+    public @NotNull ConfigurationSection getSource() {
+        return this.section;
     }
 
     @Override
@@ -65,7 +71,19 @@ public class YamlSectionWrapper implements ConfigurationWrapper {
     }
 
     @Override
-    public @Nullable ConfigurationWrapper getConfigurationSection(@NotNull String path) {
+    public @Nullable YAMLSectionWrapper getConfigurationSection(@NotNull String path) {
         return of(this.section.getConfigurationSection(path));
     }
+
+    @Nullable
+    public <T extends ConfigurationSerializable> T getSerializable(@NotNull String path, @NotNull Class<T> clazz) {
+        return getSerializable(path, clazz, null);
+    }
+
+    @Nullable
+    @Contract("_, _, !null -> !null")
+    public <T extends ConfigurationSerializable> T getSerializable(@NotNull String path, @NotNull Class<T> clazz, @Nullable T defaultValue) {
+        return this.section.getSerializable(path, clazz, defaultValue);
+    }
+
 }

impl/yaml/src/main/java/cc/carm/lib/configuration/yaml/YAMLValue.java

@@ -0,0 +1,29 @@
+package cc.carm.lib.configuration.yaml;
+
+import cc.carm.lib.configuration.core.source.ConfigurationProvider;
+import cc.carm.lib.configuration.core.value.ValueManifest;
+import cc.carm.lib.configuration.core.value.impl.CachedConfigValue;
+import cc.carm.lib.configuration.yaml.builder.YAMLConfigBuilder;
+import org.jetbrains.annotations.NotNull;
+
+public abstract class YAMLValue<T> extends CachedConfigValue<T> {
+
+    public static @NotNull YAMLConfigBuilder builder() {
+        return new YAMLConfigBuilder();
+    }
+
+    public YAMLValue(@NotNull ValueManifest<T> manifest) {
+        super(manifest);
+    }
+
+    public YAMLConfigProvider getYAMLProvider() {
+        ConfigurationProvider<?> provider = getProvider();
+        if (provider instanceof YAMLConfigProvider) return (YAMLConfigProvider) getProvider();
+        else throw new IllegalStateException("Provider is not a YamlConfigProvider");
+    }
+
+    public YAMLSectionWrapper getYAMLConfig() {
+        return getYAMLProvider().getConfiguration();
+    }
+
+}

impl/yaml/src/main/java/cc/carm/lib/configuration/yaml/YamlComments.java

@@ -1,35 +0,0 @@
-package cc.carm.lib.configuration.yaml;
-
-import org.bspfsystems.yamlconfiguration.commented.CommentsProvider;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.HashMap;
-import java.util.Map;
-
-public class YamlComments implements CommentsProvider {
-
-    Map<String, String[]> comments = new HashMap<>();
-
-    protected Map<String, String[]> getComments() {
-        return comments;
-    }
-
-    public void set(@NotNull String path, @NotNull String... comments) {
-        if (comments.length == 0) {
-            getComments().remove(path);
-        } else {
-            getComments().put(path, comments);
-        }
-    }
-
-    public @Nullable String[] get(@NotNull String path) {
-        return getComments().get(path);
-    }
-
-    @Override
-    public String[] apply(String s) {
-        return get(s);
-    }
-
-}

impl/yaml/src/main/java/cc/carm/lib/configuration/yaml/YamlConfigProvider.java

@@ -1,49 +0,0 @@
-package cc.carm.lib.configuration.yaml;
-
-import cc.carm.lib.configuration.core.source.ConfigurationWrapper;
-import cc.carm.lib.configuration.core.source.impl.FileConfigProvider;
-import org.bspfsystems.yamlconfiguration.commented.CommentedYamlConfiguration;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.io.File;
-
-public class YamlConfigProvider extends FileConfigProvider {
-
-    YamlComments comments = new YamlComments();
-    CommentedYamlConfiguration configuration;
-
-    public YamlConfigProvider(@NotNull File file) {
-        super(file);
-    }
-
-    public void initialize() {
-        this.configuration = CommentedYamlConfiguration.loadConfiguration(comments, file);
-    }
-
-    @Override
-    public @NotNull ConfigurationWrapper getConfiguration() {
-        return YamlSectionWrapper.of(configuration);
-    }
-
-    @Override
-    public void reload() throws Exception {
-        configuration.load(getFile());
-    }
-
-    @Override
-    public void save() throws Exception {
-        configuration.save(getFile());
-    }
-
-    @Override
-    public void setComments(@NotNull String path, @NotNull String... comments) {
-        this.comments.set(path, comments);
-    }
-
-    @Override
-    public @Nullable String[] getComments(@NotNull String path) {
-        return this.comments.get(path);
-    }
-
-}

impl/yaml/src/main/java/cc/carm/lib/configuration/yaml/builder/AbstractYAMLBuilder.java

@@ -0,0 +1,13 @@
+package cc.carm.lib.configuration.yaml.builder;
+
+import cc.carm.lib.configuration.core.builder.AbstractConfigBuilder;
+import cc.carm.lib.configuration.yaml.YAMLConfigProvider;
+
+public abstract class AbstractYAMLBuilder<T, B extends AbstractYAMLBuilder<T, B>>
+        extends AbstractConfigBuilder<T, B, YAMLConfigProvider> {
+
+    public AbstractYAMLBuilder() {
+        super(YAMLConfigProvider.class);
+    }
+
+}

impl/yaml/src/main/java/cc/carm/lib/configuration/yaml/builder/YAMLConfigBuilder.java

@@ -0,0 +1,14 @@
+package cc.carm.lib.configuration.yaml.builder;
+
+import cc.carm.lib.configuration.core.builder.ConfigBuilder;
+import cc.carm.lib.configuration.yaml.builder.serializable.SerializableBuilder;
+import org.bspfsystems.yamlconfiguration.serialization.ConfigurationSerializable;
+import org.jetbrains.annotations.NotNull;
+
+public class YAMLConfigBuilder extends ConfigBuilder {
+
+    public <V extends ConfigurationSerializable> @NotNull SerializableBuilder<V> ofSerializable(@NotNull Class<V> valueClass) {
+        return new SerializableBuilder<>(valueClass);
+    }
+
+}

impl/yaml/src/main/java/cc/carm/lib/configuration/yaml/builder/serializable/SerializableBuilder.java

@@ -0,0 +1,29 @@
+package cc.carm.lib.configuration.yaml.builder.serializable;
+
+import cc.carm.lib.configuration.yaml.builder.AbstractYAMLBuilder;
+import cc.carm.lib.configuration.yaml.value.ConfiguredSerializable;
+import org.bspfsystems.yamlconfiguration.serialization.ConfigurationSerializable;
+import org.jetbrains.annotations.NotNull;
+
+public class SerializableBuilder<T extends ConfigurationSerializable>
+        extends AbstractYAMLBuilder<T, SerializableBuilder<T>> {
+
+    protected final @NotNull Class<T> valueClass;
+
+    public SerializableBuilder(@NotNull Class<T> valueClass) {
+        this.valueClass = valueClass;
+    }
+
+    @Override
+    protected @NotNull SerializableBuilder<T> getThis() {
+        return this;
+    }
+
+    @Override
+    public @NotNull ConfiguredSerializable<T> build() {
+        return new ConfiguredSerializable<>(buildManifest(), this.valueClass);
+    }
+
+
+}
+

impl/yaml/src/main/java/cc/carm/lib/configuration/yaml/value/ConfiguredSerializable.java

@@ -0,0 +1,49 @@
+package cc.carm.lib.configuration.yaml.value;
+
+import cc.carm.lib.configuration.core.value.ValueManifest;
+import cc.carm.lib.configuration.yaml.YAMLValue;
+import org.bspfsystems.yamlconfiguration.serialization.ConfigurationSerializable;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class ConfiguredSerializable<T extends ConfigurationSerializable> extends YAMLValue<T> {
+
+    public static <V extends ConfigurationSerializable> ConfiguredSerializable<V> of(@NotNull Class<V> valueClass) {
+        return of(valueClass, null);
+    }
+
+    public static <V extends ConfigurationSerializable> ConfiguredSerializable<V> of(@NotNull Class<V> valueClass,
+                                                                                     @Nullable V defaultValue) {
+        return builder().ofSerializable(valueClass).defaults(defaultValue).build();
+    }
+
+    protected final @NotNull Class<T> valueClass;
+
+    public ConfiguredSerializable(@NotNull ValueManifest<T> manifest, @NotNull Class<T> valueClass) {
+        super(manifest);
+        this.valueClass = valueClass;
+    }
+
+    @Override
+    public @Nullable T get() {
+        if (!isExpired()) return getCachedOrDefault();
+
+        try {
+            // 若未出现错误，则直接更新缓存并返回。
+            return updateCache(getYAMLConfig().getSerializable(getConfigPath(), valueClass, getDefaultValue()));
+        } catch (Exception e) {
+            // 出现了解析错误，提示并返回默认值。
+            e.printStackTrace();
+            return getDefaultValue();
+        }
+
+    }
+
+    @Override
+    public void set(@Nullable T value) {
+        updateCache(value);
+        setValue(value);
+    }
+
+
+}

impl/yaml/src/test/java/config/ConfigTester.java

@@ -1,53 +0,0 @@
-package config;
-
-import cc.carm.lib.configuration.EasyConfiguration;
-import cc.carm.lib.configuration.core.ConfigInitializer;
-import cc.carm.lib.configuration.yaml.YamlConfigProvider;
-import config.misc.TestUser;
-import config.source.TestConfiguration;
-import org.junit.Test;
-
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.UUID;
-import java.util.stream.Collectors;
-import java.util.stream.IntStream;
-
-public class ConfigTester {
-
-    @Test
-    public void onTest() {
-
-        YamlConfigProvider provider = EasyConfiguration.from("target/config.yml", "config.yml");
-        ConfigInitializer.initialize(provider, TestConfiguration.class, true);
-
-        System.out.println("before: " + TestConfiguration.Sub.UUID_CONFIG_VALUE.get());
-        TestConfiguration.Sub.UUID_CONFIG_VALUE.set(UUID.randomUUID());
-        System.out.println("after: " + TestConfiguration.Sub.UUID_CONFIG_VALUE.get());
-
-
-        TestConfiguration.Sub.That.Operators.getNotNull().forEach(System.out::println);
-        List<UUID> operators = IntStream.range(0, 5).mapToObj(i -> UUID.randomUUID()).collect(Collectors.toList());
-        TestConfiguration.Sub.That.Operators.set(operators);
-
-        System.out.println(TestConfiguration.USER.get());
-        TestUser b = new TestUser(UUID.randomUUID().toString().substring(0, 3), UUID.randomUUID());
-        TestConfiguration.USER.set(b);
-
-        TestConfiguration.USERS.getNotNull().forEach((k, v) -> System.out.println(k + ": " + v));
-        LinkedHashMap<Integer, UUID> data = new LinkedHashMap<>();
-        for (int i = 0; i < 5; i++) {
-            data.put((int) (1000 * Math.random()), UUID.randomUUID());
-        }
-        TestConfiguration.USERS.set(data);
-
-        try {
-            provider.save();
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-
-    }
-
-
-}

impl/yaml/src/test/java/config/DemoConfigTest.java

@@ -0,0 +1,54 @@
+package config;
+
+import cc.carm.lib.configuration.EasyConfiguration;
+import cc.carm.lib.configuration.demo.tests.ConfigurationTest;
+import cc.carm.lib.configuration.demo.tests.model.AbstractModel;
+import cc.carm.lib.configuration.yaml.YAMLConfigProvider;
+import config.model.AnyModel;
+import config.model.SomeModel;
+import config.source.ModelConfiguration;
+import org.bspfsystems.yamlconfiguration.serialization.ConfigurationSerialization;
+import org.junit.Test;
+
+import java.io.IOException;
+
+public class DemoConfigTest {
+
+    static {
+        ConfigurationSerialization.registerClass(SomeModel.class);
+        ConfigurationSerialization.registerClass(AnyModel.class);
+    }
+
+    protected final YAMLConfigProvider provider = EasyConfiguration.from("target/config.yml", "test/test2/config.yml");
+
+    @Test
+    public void onTest() {
+
+        ConfigurationTest.testDemo(this.provider);
+        ConfigurationTest.testInner(this.provider);
+
+        testSerialization(this.provider);
+
+        ConfigurationTest.save(this.provider);
+    }
+
+
+    public static void testSerialization(YAMLConfigProvider provider) {
+        provider.initialize(ModelConfiguration.class);
+        System.out.println("----------------------------------------------------");
+
+        AbstractModel someModel = ModelConfiguration.SOME_MODEL.get();
+        if (someModel != null) System.out.println(someModel.getName());
+
+        AbstractModel anyModel = ModelConfiguration.ANY_MODEL.get();
+        if (anyModel != null) System.out.println(anyModel.getName());
+
+        ModelConfiguration.MODELS.forEach(System.out::println);
+        ModelConfiguration.MODEL_MAP.forEach((v, anyModel1) -> System.out.println(v + " -> " + anyModel1.toString()));
+
+
+        System.out.println("----------------------------------------------------");
+    }
+
+
+}

impl/yaml/src/test/java/config/misc/TestUser.java

@@ -1,38 +0,0 @@
-package config.misc;
-
-import java.util.UUID;
-
-public class TestUser {
-
-    public String name;
-    public UUID uuid;
-
-    public TestUser(String name, UUID uuid) {
-        this.name = name;
-        this.uuid = uuid;
-    }
-
-    public void setName(String name) {
-        this.name = name;
-    }
-
-    public void setUuid(UUID uuid) {
-        this.uuid = uuid;
-    }
-
-    public String getName() {
-        return name;
-    }
-
-    public UUID getUuid() {
-        return uuid;
-    }
-
-    @Override
-    public String toString() {
-        return "TestUser{" +
-                "name='" + name + '\'' +
-                ", uuid=" + uuid +
-                '}';
-    }
-}

impl/yaml/src/test/java/config/model/AnyModel.java

@@ -0,0 +1,50 @@
+package config.model;
+
+import cc.carm.lib.configuration.demo.tests.model.AbstractModel;
+import org.bspfsystems.yamlconfiguration.serialization.ConfigurationSerializable;
+import org.bspfsystems.yamlconfiguration.serialization.SerializableAs;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.TestOnly;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+@SerializableAs("AnyModel")
+public class AnyModel extends AbstractModel implements ConfigurationSerializable {
+
+    public final boolean bool;
+
+    public AnyModel(@NotNull String name, boolean bool) {
+        super(name);
+        this.bool = bool;
+    }
+
+    @Override
+    public String toString() {
+        return "AnyModel{" +
+                "name='" + name + '\'' +
+                ", bool=" + bool +
+                '}';
+    }
+
+    @Override
+    public @NotNull Map<String, Object> serialize() {
+        Map<String, Object> map = new HashMap<>();
+        map.put("name", name);
+        map.put("state", bool);
+        return map;
+    }
+
+    public static AnyModel random() {
+        return new AnyModel(UUID.randomUUID().toString().substring(0, 5), Math.random() > 0.5);
+    }
+
+
+    @TestOnly
+    public static AnyModel deserialize(Map<String, ?> args) {
+        return new AnyModel((String) args.get("name"), (Boolean) args.get("state"));
+    }
+
+
+}

impl/yaml/src/test/java/config/model/SomeModel.java

@@ -0,0 +1,50 @@
+package config.model;
+
+import cc.carm.lib.configuration.demo.tests.model.AbstractModel;
+import org.bspfsystems.yamlconfiguration.serialization.ConfigurationSerializable;
+import org.bspfsystems.yamlconfiguration.serialization.SerializableAs;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.TestOnly;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+@SerializableAs("SomeModel")
+public class SomeModel extends AbstractModel implements ConfigurationSerializable {
+
+    public final int num;
+
+    public SomeModel(@NotNull String name, int num) {
+        super(name);
+        this.num = num;
+    }
+
+    @Override
+    public String toString() {
+        return "SomeModel{" +
+                "name='" + name + '\'' +
+                ", num=" + num +
+                '}';
+    }
+
+    @Override
+    public @NotNull Map<String, Object> serialize() {
+        Map<String, Object> map = new HashMap<>();
+        map.put("name", name);
+        map.put("num", num);
+        return map;
+    }
+
+    public static SomeModel random() {
+        return new SomeModel(UUID.randomUUID().toString().substring(0, 5), (int) (Math.random() * 1000));
+    }
+
+
+    @TestOnly
+    public static SomeModel deserialize(Map<String, ?> args) {
+        return new SomeModel((String) args.get("name"), (Integer) args.get("num"));
+    }
+
+
+}

impl/yaml/src/test/java/config/source/ModelConfiguration.java

@@ -0,0 +1,43 @@
+package config.source;
+
+import cc.carm.lib.configuration.core.ConfigurationRoot;
+import cc.carm.lib.configuration.core.annotation.ConfigPath;
+import cc.carm.lib.configuration.core.annotation.HeaderComment;
+import cc.carm.lib.configuration.core.value.ConfigValue;
+import cc.carm.lib.configuration.core.value.type.ConfiguredList;
+import cc.carm.lib.configuration.core.value.type.ConfiguredMap;
+import cc.carm.lib.configuration.core.value.type.ConfiguredSectionMap;
+import cc.carm.lib.configuration.demo.tests.model.AbstractModel;
+import cc.carm.lib.configuration.yaml.value.ConfiguredSerializable;
+import config.model.AnyModel;
+import config.model.SomeModel;
+
+@HeaderComment("以下内容用于测试序列化")
+@ConfigPath("model-test")
+public class ModelConfiguration extends ConfigurationRoot {
+
+    public static final ConfigValue<? extends AbstractModel> SOME_MODEL = ConfiguredSerializable.of(
+            SomeModel.class, SomeModel.random()
+    );
+
+    public static final ConfigValue<? extends AbstractModel> ANY_MODEL = ConfiguredSerializable.of(
+            AnyModel.class, AnyModel.random()
+    );
+
+    public static final ConfiguredList<AnyModel> MODELS = ConfiguredList.builderOf(AnyModel.class)
+            .fromMap()
+            .parseValue(AnyModel::deserialize).serializeValue(AnyModel::serialize)
+            .defaults(AnyModel.random(), AnyModel.random(), AnyModel.random())
+            .build();
+
+    public static final ConfiguredSectionMap<String, AnyModel> MODEL_MAP = ConfiguredMap.builderOf(String.class, AnyModel.class)
+            .asLinkedMap().fromSection()
+            .parseValue(v -> new AnyModel(v.getString("name", "EMPTY"), v.getBoolean("state", false)))
+            .serializeValue(AnyModel::serialize)
+            .defaults(m -> {
+                m.put("a", AnyModel.random());
+                m.put("b", AnyModel.random());
+            })
+            .build();
+
+}

impl/yaml/src/test/java/config/source/TestConfiguration.java

@@ -1,58 +0,0 @@
-package config.source;
-
-import cc.carm.lib.configuration.core.ConfigurationRoot;
-import cc.carm.lib.configuration.core.annotation.ConfigComment;
-import cc.carm.lib.configuration.core.annotation.ConfigPath;
-import cc.carm.lib.configuration.core.builder.ConfigBuilder;
-import cc.carm.lib.configuration.core.util.MapFactory;
-import cc.carm.lib.configuration.core.value.ConfigValue;
-import config.misc.TestUser;
-
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.UUID;
-
-public class TestConfiguration extends ConfigurationRoot {
-
-    @ConfigComment({"User测试"})
-    public static final ConfigValue<TestUser> USER = ConfigBuilder
-            .asValue(TestUser.class).fromSection()
-            .defaults(new TestUser("Carm", UUID.randomUUID()))
-            .parseValue((section, defaultValue) -> new TestUser(
-                    section.getString("name"),
-                    UUID.fromString(section.getString("user.uuid", UUID.randomUUID().toString()))
-            )).serializeValue(user -> MapFactory.<String, Object>linkedMap()
-                    .put("name", user.getName())
-                    .put("user.uuid", user.getUuid().toString())
-                    .build()
-            ).build();
-
-    @ConfigComment({"[ID-UUID] 对照表", "", "用于测试Map类型的解析与序列化保存"})
-    public static final ConfigValue<Map<Integer, UUID>> USERS = ConfigBuilder
-            .asMap(Integer.class, UUID.class).fromString()
-            .parseKey(Integer::parseInt)
-            .parseValue(v -> Objects.requireNonNull(UUID.fromString(v)))
-            .build();
-
-    public static class Sub {
-
-        @ConfigPath("uuid")
-        public static final ConfigValue<UUID> UUID_CONFIG_VALUE = ConfigBuilder
-                .asValue(UUID.class).fromString()
-                .parseValue((data, defaultValue) -> UUID.fromString(data))
-                .build();
-
-        @ConfigPath("nothing")
-        public static class That {
-
-            public static final ConfigValue<List<UUID>> Operators = ConfigBuilder.asList(UUID.class).fromString()
-                    .parseValue(s -> Objects.requireNonNull(UUID.fromString(s))).build();
-
-        }
-
-
-    }
-
-
-}

impl/yaml/src/test/resources/config.yml

@@ -1 +0,0 @@
-something: 123123

impl/yaml/src/test/resources/test/test2/config.yml

@@ -0,0 +1,2 @@
+version: 1.0
+test-save: false

platform/bungee/src/main/java/cc/carm/lib/configuration/EasyConfiguration.java

@@ -1,34 +0,0 @@
-package cc.carm.lib.configuration;
-
-import cc.carm.lib.configuration.bungee.BungeeConfigProvider;
-
-import java.io.File;
-import java.io.IOException;
-
-public class EasyConfiguration {
-
-    public static BungeeConfigProvider from(File file, String source) {
-        BungeeConfigProvider provider = new BungeeConfigProvider(file);
-        try {
-            provider.initializeFile(source);
-            provider.initialize();
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-        return provider;
-    }
-
-    public static BungeeConfigProvider from(File file) {
-        return from(file, file.getName());
-    }
-
-    public static BungeeConfigProvider from(String fileName) {
-        return from(fileName, fileName);
-    }
-
-    public static BungeeConfigProvider from(String fileName, String source) {
-        return from(new File(fileName), source);
-    }
-
-
-}

platform/bungee/src/main/java/cc/carm/lib/configuration/bungee/BungeeConfigProvider.java

@@ -1,54 +0,0 @@
-package cc.carm.lib.configuration.bungee;
-
-import cc.carm.lib.configuration.core.source.ConfigurationWrapper;
-import cc.carm.lib.configuration.core.source.impl.FileConfigProvider;
-import net.md_5.bungee.config.Configuration;
-import net.md_5.bungee.config.ConfigurationProvider;
-import net.md_5.bungee.config.YamlConfiguration;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.io.File;
-import java.io.IOException;
-
-public class BungeeConfigProvider extends FileConfigProvider {
-
-    Configuration configuration;
-
-    public BungeeConfigProvider(@NotNull File file) {
-        super(file);
-    }
-
-    public void initialize() throws IOException {
-        this.configuration = getLoader().load(file);
-    }
-
-    @Override
-    public @NotNull ConfigurationWrapper getConfiguration() {
-        return BungeeSectionWrapper.of(configuration);
-    }
-
-    @Override
-    public void reload() throws Exception {
-        this.configuration = getLoader().load(file);
-    }
-
-    @Override
-    public void save() throws Exception {
-        getLoader().save(configuration, file);
-    }
-
-    @Override
-    public void setComments(@NotNull String path, @NotNull String... comments) {
-    }
-
-    @Override
-    public @Nullable String[] getComments(@NotNull String path) {
-        return null;
-    }
-
-    public static ConfigurationProvider getLoader() {
-        return ConfigurationProvider.getProvider(YamlConfiguration.class);
-    }
-
-}

platform/bungee/src/main/java/cc/carm/lib/configuration/bungee/BungeeSectionWrapper.java

@@ -1,70 +0,0 @@
-package cc.carm.lib.configuration.bungee;
-
-import cc.carm.lib.configuration.core.source.ConfigurationWrapper;
-import net.md_5.bungee.config.Configuration;
-import org.jetbrains.annotations.Contract;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.*;
-import java.util.stream.Collectors;
-
-public class BungeeSectionWrapper implements ConfigurationWrapper {
-
-    private final Configuration section;
-
-    private BungeeSectionWrapper(Configuration section) {
-        this.section = section;
-    }
-
-    @Contract("!null->!null")
-    public static @Nullable BungeeSectionWrapper of(@Nullable Configuration section) {
-        return section == null ? null : new BungeeSectionWrapper(section);
-    }
-
-    @Override
-    public @NotNull Set<String> getKeys(boolean deep) {
-        return new LinkedHashSet<>(section.getKeys());
-    }
-
-    @Override
-    public @NotNull Map<String, Object> getValues(boolean deep) {
-        return section.getKeys().stream()
-                .collect(Collectors.toMap(key -> key, section::get, (a, b) -> b, LinkedHashMap::new));
-    }
-
-    @Override
-    public void set(@NotNull String path, @Nullable Object value) {
-        this.section.set(path, value);
-    }
-
-    @Override
-    public boolean contains(@NotNull String path) {
-        return this.section.contains(path);
-    }
-
-    @Override
-    public @Nullable Object get(@NotNull String path) {
-        return this.section.get(path);
-    }
-
-    @Override
-    public boolean isList(@NotNull String path) {
-        return get(path) instanceof List<?>;
-    }
-
-    @Override
-    public @Nullable List<?> getList(@NotNull String path) {
-        return this.section.getList(path);
-    }
-
-    @Override
-    public boolean isConfigurationSection(@NotNull String path) {
-        return true; // No provided functions :( SRY
-    }
-
-    @Override
-    public @Nullable ConfigurationWrapper getConfigurationSection(@NotNull String path) {
-        return of(this.section.getSection(path));
-    }
-}

platform/spigot/src/main/java/cc/carm/lib/configuration/EasyConfiguration.java

@@ -1,35 +0,0 @@
-package cc.carm.lib.configuration;
-
-import cc.carm.lib.configuration.spigot.SpigotConfigProvider;
-
-import java.io.File;
-import java.io.IOException;
-
-public class EasyConfiguration {
-
-
-    public static SpigotConfigProvider from(File file, String source) {
-        SpigotConfigProvider provider = new SpigotConfigProvider(file);
-        try {
-            provider.initializeFile(source);
-            provider.initialize();
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-        return provider;
-    }
-
-    public static SpigotConfigProvider from(File file) {
-        return from(file, file.getName());
-    }
-
-    public static SpigotConfigProvider from(String fileName) {
-        return from(fileName, fileName);
-    }
-
-    public static SpigotConfigProvider from(String fileName, String source) {
-        return from(new File(fileName), source);
-    }
-
-
-}

platform/spigot/src/main/java/cc/carm/lib/configuration/commented/CommentedYaml.java

@@ -1,73 +0,0 @@
-package cc.carm.lib.configuration.commented;
-
-import org.yaml.snakeyaml.DumperOptions;
-import org.yaml.snakeyaml.Yaml;
-import org.yaml.snakeyaml.constructor.BaseConstructor;
-import org.yaml.snakeyaml.error.YAMLException;
-import org.yaml.snakeyaml.nodes.Node;
-import org.yaml.snakeyaml.nodes.Tag;
-import org.yaml.snakeyaml.representer.Representer;
-import org.yaml.snakeyaml.serializer.Serializer;
-
-import java.io.IOException;
-import java.io.StringWriter;
-import java.io.Writer;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-
-/**
- * An hacky extension of {@link Yaml} that allows to write comments when dumping.
- */
-public class CommentedYaml extends Yaml {
-
-    private final CommentsProvider commentsProvider;
-
-    public CommentedYaml(BaseConstructor constructor, Representer representer, DumperOptions dumperOptions, CommentsProvider commentsProvider) {
-        super(constructor, representer, dumperOptions);
-        this.commentsProvider = commentsProvider;
-    }
-
-    @Override
-    public String dump(Object data) {
-        List<Object> list = new ArrayList<>(1);
-        list.add(data);
-        return this.dumpAll(list.iterator());
-    }
-
-    @Override
-    public void dump(Object data, Writer output) {
-        List<Object> list = new ArrayList<>(1);
-        list.add(data);
-        this.dumpAll(list.iterator(), output, null);
-    }
-
-    @Override
-    public String dumpAll(Iterator<?> data) {
-        StringWriter buffer = new StringWriter();
-        this.dumpAll(data, buffer, null);
-        return buffer.toString();
-    }
-
-    @Override
-    public void dumpAll(Iterator<?> data, Writer output) {
-        this.dumpAll(data, output, null);
-    }
-
-    private void dumpAll(Iterator<?> data, Writer output, Tag rootTag) {
-        Serializer serializer = new Serializer(new CommentedEmitter(output, this.dumperOptions, this.commentsProvider), this.resolver, this.dumperOptions, rootTag);
-
-        try {
-            serializer.open();
-
-            while (data.hasNext()) {
-                Node node = this.representer.represent(data.next());
-                serializer.serialize(node);
-            }
-
-            serializer.close();
-        } catch (IOException var6) {
-            throw new YAMLException(var6);
-        }
-    }
-}

platform/spigot/src/main/java/cc/carm/lib/configuration/commented/CommentedYamlConfiguration.java

@@ -1,69 +0,0 @@
-package cc.carm.lib.configuration.commented;
-
-import org.bukkit.configuration.InvalidConfigurationException;
-import org.bukkit.configuration.file.YamlConfiguration;
-import org.bukkit.configuration.file.YamlConstructor;
-import org.bukkit.configuration.file.YamlRepresenter;
-import org.jetbrains.annotations.NotNull;
-import org.yaml.snakeyaml.DumperOptions;
-import org.yaml.snakeyaml.representer.Representer;
-
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.io.Reader;
-
-/**
- * A yaml file with comments on certain properties, as returned by the given {@link CommentsProvider}.
- * Unlike {@link YamlConfiguration}, this class does not provide a header support.
- */
-public class CommentedYamlConfiguration extends YamlConfiguration {
-
-    private final DumperOptions yamlOptions = new DumperOptions();
-    private final Representer yamlRepresenter = new YamlRepresenter();
-    private final CommentedYaml yaml;
-
-    public CommentedYamlConfiguration(CommentsProvider commentsProvider) {
-        this.yaml = new CommentedYaml(new YamlConstructor(), this.yamlRepresenter, this.yamlOptions, commentsProvider);
-    }
-
-    public static CommentedYamlConfiguration loadConfiguration(CommentsProvider commentsProvider, File file) {
-        CommentedYamlConfiguration config = new CommentedYamlConfiguration(commentsProvider);
-
-        try {
-            config.load(file);
-        } catch (FileNotFoundException ignored) {
-        } catch (IOException | InvalidConfigurationException var4) {
-            var4.printStackTrace();
-        }
-
-        return config;
-    }
-
-    public static CommentedYamlConfiguration loadConfiguration(CommentsProvider commentsProvider, Reader reader) {
-        CommentedYamlConfiguration config = new CommentedYamlConfiguration(commentsProvider);
-
-        try {
-            config.load(reader);
-        } catch (IOException | InvalidConfigurationException ex) {
-            ex.printStackTrace();
-        }
-
-        return config;
-    }
-
-    @Override
-    public @NotNull String saveToString() {
-        this.yamlOptions.setIndent(this.options().indent());
-        this.yamlOptions.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
-        this.yamlRepresenter.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
-        String dump = this.yaml.dump(this.getValues(false));
-        if (dump.equals("{}\n")) {
-            dump = "";
-        }
-
-        // No header support.
-
-        return dump;
-    }
-}