chore: Remove wip modules

# Conflicts:
#	providers/yaml/pom.xml

.doc/README.md

@@ -0,0 +1,16 @@
+# 欢迎使用 EasyConfiguration ！
+
+这个项目刚刚创建，详细的Javadoc与开发指南还在补充，请给我一点时间~
+
+
+## 基本定义
+
+Value: 实际配置的单例值。
+
+Manifest: 用于描述值基本配置的对象。
+
+Provider: 用于提供配置文件的接口。
+
+Wrapper: 用于包装配置文件的接口。
+
+Initializer: 用于初始化的接口

.github/workflows/codacy-analysis.yml

@@ -29,11 +29,11 @@ jobs:
     steps:
       # Checkout the repository to the GitHub Actions runner
       - name: Checkout code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       # Execute Codacy Analysis CLI and generate a SARIF output with the security issues identified during the analysis
       - name: Run Codacy Analysis CLI
-        uses: codacy/codacy-analysis-cli-action@d840f886c4bd4edc059706d09c6a1586111c540b
+        uses: codacy/codacy-analysis-cli-action@09916000460adeeedc96b9704f86deba53e2ad5d
         with:
           # Check https://github.com/codacy/codacy-analysis-cli#project-token to get your project token from your Codacy repository
           # You can also omit the token and run the tools that support default configurations
@@ -49,6 +49,6 @@ jobs:
 
       # Upload the SARIF file generated in the previous step
       - name: Upload SARIF results file
-        uses: github/codeql-action/upload-sarif@v1
+        uses: github/codeql-action/upload-sarif@v3
         with:
           sarif_file: results.sarif

.github/workflows/codeql-analysis.yml

@@ -38,11 +38,11 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v1
+        uses: github/codeql-action/init@v3
         with:
           languages: ${{ matrix.language }}
           # If you wish to specify custom queries, you can do so here or in a config file.
@@ -53,7 +53,7 @@ jobs:
       # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
       # If this step fails, then you should remove it and run the build manually (see below)
       - name: Autobuild
-        uses: github/codeql-action/autobuild@v1
+        uses: github/codeql-action/autobuild@v3
 
       # ℹ️ Command-line programs to run using the OS shell.
       # 📚 https://git.io/JvXDl
@@ -67,4 +67,4 @@ jobs:
       #   make release
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v1
+        uses: github/codeql-action/analyze@v3

.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:
   # 支持手动触发构建
@@ -16,9 +16,9 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
       - name: "Set up JDK"
-        uses: actions/setup-java@v2
+        uses: actions/setup-java@v4
         with:
           java-version: '11'
           distribution: 'adopt'
@@ -41,7 +41,7 @@ jobs:
           rm -rf docs
           mkdir -vp docs
           cp -vrf core/target/apidocs/* docs/
-          cp -vrf .documentation/JAVADOC-README.md docs/README.md
+          cp -vrf .doc/JAVADOC-README.md docs/README.md
 
       - name: "Generate the Javadoc sitemap"
         id: sitemap
@@ -87,21 +87,21 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
       - name: "Set up JDK"
-        uses: actions/setup-java@v2
+        uses: actions/setup-java@v4
         with:
           java-version: '11'
           distribution: 'adopt'
           cache: maven
-          server-id: ossrh
+          server-id: central
           server-username: MAVEN_USERNAME
           server-password: MAVEN_PASSWORD
           gpg-private-key: ${{ secrets.MAVEN_GPG_PRIVATE_KEY }} # Value of the GPG private key to import
           gpg-passphrase: MAVEN_GPG_PASSPHRASE # env variable for GPG private key passphrase
 
       - name: "Central Deploy"
-        run: mvn -B -Possrh deploy --file pom.xml -DskipTests
+        run: mvn -B -Pcentral deploy --file pom.xml -DskipTests
         env:
           MAVEN_USERNAME: ${{ secrets.OSSRH_USER }}
           MAVEN_PASSWORD: ${{ secrets.OSSRH_PASS }}

.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:
   # 支持手动触发构建
@@ -15,9 +15,9 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
       - name: "Set up JDK"
-        uses: actions/setup-java@v2
+        uses: actions/setup-java@v4
         with:
           java-version: '11'
           distribution: 'adopt'
@@ -26,7 +26,7 @@ jobs:
       - name: "Target Stage"
         run: mkdir staging && cp */target/*.jar staging
       - name: "Upload artifact"
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v4
         with:
           name: Artifact
           path: staging

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

@@ -6,35 +6,110 @@
              /___/                      /___/
 ```
 
+README LANGUAGES [ [**English**](README.md) | [中文](README_CN.md)  ]
+
 # 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/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)
 
-轻松(做)配置，简单便捷的通用配置文件加载、读取与更新工具，可自定义配置格式。
+**Easy _(to make)_ Configurations!**
 
-## 优势
+A simple, easy-to-use and universal solution for managing configuration files.
+Enjoy the ease of use with customizable formats for loading, reading, and updating your configuration files.
 
-- 基于类的配置文件初始化、加载、获取与更新机制，方便快捷。
+## Features & Advantages
 
-## 开发
+Supported [YAML](impl/yaml), [JSON](impl/json), [HOCON](impl/hocon) and [SQL](impl/sql) based configuration files
+format.
 
-详细开发介绍请 [点击这里](.documentation/README.md) , JavaDoc(最新Release) 请 [点击这里](https://carmjos.github.io/EasyConfiguration) 。
+- Class-based mechanism for initializing, loading, retrieving, and updating configuration files, ensuring convenience
+  and efficiency.
+- Supports manual serialization and deserialization of complex configurations.
+- Offers multiple builder forms for rapid construction of `ConfigValue<?>` objects.
+- Enables specification of configuration paths, comments, and more via annotations.
 
-### 示例代码
+## Development
 
-您可以 [点击这里](impl/yaml/src/test/java/config/source/TestConfiguration.java) 查看部分代码演示，更多演示详见 [开发介绍](.documentation/README.md) 。
+For the latest JavaDoc release, [CLICK HERE](https://CarmJos.github.io/EasyConfiguration).
 
-### 依赖方式
+For a detailed development guide, [CLICK HERE](.doc/README.md).
 
-#### Maven 依赖
+### Code Samples
+
+To quickly demonstrate the applicability of the project, here are a few practical demonstrations:
+- [Database configuration.](demo/src/main/java/cc/carm/lib/configuration/demo/DatabaseConfiguration.java)
+- [Demonstration of all types of configuration instance classes.](demo/src/main/java/cc/carm/lib/configuration/demo/tests/conf/DemoConfiguration.java)
+
+Check out all code demonstrations [HERE](demo/src/main/java/cc/carm/lib/configuration/demo/DatabaseConfiguration.java).
+For more examples, see the [Development Guide](.doc/README.md).
+
+```java
+@HeaderComment("Configurations for sample")
+interface SampleConfig extends Configuration {
+
+    @InlineComment("Enabled?") // Inline comment
+    ConfiguredValue<Boolean> ENABLED = ConfiguredValue.of(true);
+
+    ConfiguredList<UUID> UUIDS = ConfiguredList.builderOf(UUID.class).fromString()
+            .parseValue(UUID::fromString).serializeValue(UUID::toString)
+            .defaults(
+                    UUID.fromString("00000000-0000-0000-0000-000000000000"),
+                    UUID.fromString("00000000-0000-0000-0000-000000000001")
+            ).build();
+
+    interface INFO extends Configuration {
+        
+        @HeaderComment("Configure your name!") // Header comment
+        ConfiguredValue<String> NAME = ConfiguredValue.of("Joker");
+
+        @ConfigPath("year") // Custom path
+        ConfiguredValue<Integer> AGE = ConfiguredValue.of(24);
+    
+    }
+}
+```
+
+```java
+public class Sample {
+  public static void main(String[] args) {
+    // 1. Make a configuration provider from a file.
+    ConfigurationProvider<?> provider = EasyConfiguration.from("config.yml");
+    // 2. Initialize the configuration classes or instances.
+    provider.initialize(SampleConfig.class);
+    // 3. Enjoy using the configuration!
+    SampleConfig.ENABLED.set(false);
+    System.out.println("Your name is " + SampleConfig.INFO.NAME.getNotNull() + " !");
+  }
+}
+
+```
+
+```yaml
+# Configurations for sample
+
+enabled: true # Enabled?
+
+uuids:
+  - 00000000-0000-0000-0000-000000000000
+  - 00000000-0000-0000-0000-000000000001
+
+info:
+  # Configure your name!
+  name: Joker
+  year: 24
+```
+
+### Dependencies
+
+#### Maven Dependency
 
 <details>
-<summary>远程库配置</summary>
+<summary>Remote Repository Configuration</summary>
 
 ```xml
 
@@ -42,26 +117,19 @@
     <repositories>
 
         <repository>
-            <!--采用Maven中心库，安全稳定，但版本更新需要等待同步-->
+            <!-- Using Maven Central Repository for secure and stable updates, though synchronization might be needed. -->
             <id>maven</id>
             <name>Maven Central</name>
             <url>https://repo1.maven.org/maven2</url>
         </repository>
-  
+
         <repository>
-            <!--采用github依赖库，实时更新，但需要配置 (推荐) -->
+            <!-- Using GitHub dependencies for real-time updates, configuration required (recommended). -->
             <id>EasyConfiguration</id>
             <name>GitHub Packages</name>
             <url>https://maven.pkg.github.com/CarmJos/EasyConfiguration</url>
         </repository>
 
-        <repository>
-            <!--采用我的私人依赖库，简单方便，但可能因为变故而无法使用-->
-            <id>carm-repo</id>
-            <name>Carm's Repo</name>
-            <url>https://repo.carm.cc/repository/maven-public/</url>
-        </repository>
-
     </repositories>
 </project>
 ```
@@ -69,13 +137,13 @@
 </details>
 
 <details>
-<summary>通用原生依赖</summary>
+<summary>Generic Native Dependency</summary>
 
 ```xml
 
 <project>
     <dependencies>
-        <!--基础实现部分，需要自行实现“Provider”与“Wrapper”。-->
+        <!-- Basic implementation part, requiring custom implementation of “Provider” and “Wrapper”. -->
         <dependency>
             <groupId>cc.carm.lib</groupId>
             <artifactId>easyconfiguration-core</artifactId>
@@ -83,7 +151,7 @@
             <scope>compile</scope>
         </dependency>
 
-        <!--基于YAML文件的实现版本，可用于全部Java环境。-->
+        <!-- YAML file-based implementation, compatible with all Java environments. -->
         <dependency>
             <groupId>cc.carm.lib</groupId>
             <artifactId>easyconfiguration-yaml</artifactId>
@@ -91,88 +159,80 @@
             <scope>compile</scope>
         </dependency>
 
+        <!-- JSON file-based implementation, compatible with all Java environments. Note: JSON does not support file comments. -->
+        <dependency>
+            <groupId>cc.carm.lib</groupId>
+            <artifactId>easyconfiguration-json</artifactId>
+            <version>[LATEST RELEASE]</version>
+            <scope>compile</scope>
+        </dependency>
+
     </dependencies>
 </project>
 ```
 
 </details>
 
-#### Gradle 依赖
+#### Gradle Dependency
 
 <details>
-<summary>远程库配置</summary>
+<summary>Remote Repository Configuration</summary>
 
 ```groovy
 repositories {
 
-    // 采用Maven中心库，安全稳定，但版本更新需要等待同步 
+    // Using Maven Central Repository for secure and stable updates, though synchronization might be needed.
     mavenCentral()
-  
-    // 采用github依赖库，实时更新，但需要配置 (推荐)
+
+    // Using GitHub dependencies for real-time updates, configuration required (recommended).
     maven { url 'https://maven.pkg.github.com/CarmJos/EasyConfiguration' }
 
-    // 采用我的私人依赖库，简单方便，但可能因为变故而无法使用
-    maven { url 'https://repo.carm.cc/repository/maven-public/' }
 }
 ```
 
 </details>
 
 <details>
-<summary>通用原生依赖</summary>
+<summary>Generic Native Dependency</summary>
 
 ```groovy
 
 dependencies {
 
-    //基础实现部分，需要自行实现“Provider”与“Wrapper”。
+    // Basic implementation part, requiring custom implementation of “Provider” and “Wrapper”.
     api "cc.carm.lib:easyconfiguration-core:[LATEST RELEASE]"
 
-    //基于YAML文件的实现版本，可用于全部Java环境。
+    // YAML file-based implementation, compatible with all Java environments.
     api "cc.carm.lib:easyconfiguration-yaml:[LATEST RELEASE]"
 
+    // JSON file-based implementation, compatible with all Java environments. Note: JSON does not support file comments.
+    api "cc.carm.lib:easyconfiguration-json:[LATEST RELEASE]"
+
 }
 ```
 
 </details>
 
-## 衍生项目
+## Derived Projects
 
-### [**MineConfiguration**](https://github.com/CarmJos/MineConfiguration) (by @CarmJos )
+### [**MineConfiguration**](https://github.com/CarmJos/MineConfiguration) (by @CarmJos)
 
 EasyConfiguration for MineCraft!
-开始在 MineCraft 相关服务器平台上轻松(做)配置吧！
+Easily manage configurations on MineCraft-related server platforms.
 
-目前支持 BungeeCord, Bukkit(Spigot) 服务端，后续将支持更多平台。
+Currently supports BungeeCord, Bukkit (Spigot) servers, with more platforms to be supported soon.
 
+## Support and Donation
 
-## 支持与捐赠
+If you appreciate this plugin, consider supporting me with a donation!
 
-若您觉得本插件做的不错，您可以通过捐赠支持我！
+Thank you for supporting open-source projects!
 
-感谢您对开源项目的支持！
+Many thanks to Jetbrains for kindly providing a license for us to work on this and other open-source projects.
 
-<img height=25% width=25% src="https://raw.githubusercontent.com/CarmJos/CarmJos/main/img/donate-code.jpg"  alt=""/>
+[![](https://resources.jetbrains.com/storage/products/company/brand/logos/jb_beam.svg)](https://www.jetbrains.com/?from=https://github.com/CarmJos/EasyConfiguration)
 
-## 开源协议
+## Open Source License
 
-本项目源码采用 [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>
+This project's source code is licensed under
+the [GNU LESSER GENERAL PUBLIC LICENSE](https://www.gnu.org/licenses/lgpl-3.0.html).

README_CN.md

@@ -0,0 +1,260 @@
+```text
+   ____                _____          ____                    __  _
+  / __/__ ____ __ __  / ___/__  ___  / _(_)__ ___ _________ _/ /_(_)__  ___
+ / _// _ `(_-</ // / / /__/ _ \/ _ \/ _/ / _ `/ // / __/ _ `/ __/ / _ \/ _ \
+/___/\_,_/___/\_, /  \___/\___/_//_/_//_/\_, /\_,_/_/  \_,_/\__/_/\___/_//_/
+             /___/                      /___/
+```
+
+README LANGUAGES [ [English](README.md) | [**中文**](README_CN.md)  ]
+
+# 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://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/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)
+
+**轻松(做)配置！**
+
+一款简单便捷的通用配置文件加载、读取与更新工具，可自定义配置的格式。
+
+## 特性 & 优势
+
+支持 [YAML](impl/yaml), [JSON](impl/json), [HOCON](impl/hocon) 和 [SQL](impl/sql) 等多种配置文件格式。
+
+- 基于类的配置文件初始化、加载、获取与更新机制，方便快捷。
+- 支持复杂配置的手动序列化、反序列化。
+- 提供多种builder形式，快速构建 `ConfigValue<?>` 对象。
+- 支持通过注解规定配置对应的路径、注释等信息。
+
+## 开发
+
+详细开发介绍请 [点击这里](.doc/README.md) , JavaDoc(最新Release) 请 [点击这里](https://CarmJos.github.io/EasyConfiguration) 。
+
+### 示例代码
+
+为快速的展示该项目的适用性，这里有几个实际演示：
+- [数据库配置文件实例](demo/src/main/java/cc/carm/lib/configuration/demo/DatabaseConfiguration.java)
+- [全种类配置实例类演示](demo/src/main/java/cc/carm/lib/configuration/demo/tests/conf/DemoConfiguration.java)
+
+您可以 [点击这里](demo/src/main/java/cc/carm/lib/configuration/demo) 直接查看现有的代码演示，更多复杂情况演示详见 [开发介绍](.doc/README.md) 。
+
+
+```java
+@HeaderComment("Configurations for sample")
+interface SampleConfig extends Configuration {
+
+    @InlineComment("Enabled?") // 行内注释
+    ConfiguredValue<Boolean> ENABLED = ConfiguredValue.of(true);
+
+    ConfiguredList<UUID> UUIDS = ConfiguredList.builderOf(UUID.class).fromString()
+            .parseValue(UUID::fromString).serializeValue(UUID::toString)
+            .defaults(
+                    UUID.fromString("00000000-0000-0000-0000-000000000000"),
+                    UUID.fromString("00000000-0000-0000-0000-000000000001")
+            ).build();
+
+    interface INFO extends Configuration {
+        
+        @HeaderComment("Configure your name!") // 头部注释
+        ConfiguredValue<String> NAME = ConfiguredValue.of("Joker");
+
+        @ConfigPath("year") // 自定义配置路径，若不定义，则按照默认规则生成
+        ConfiguredValue<Integer> AGE = ConfiguredValue.of(24);
+    
+    }
+}
+```
+
+```java
+public class Sample {
+    public static void main(String[] args) {
+        // 1. 生成一个 “Provider” 用于给配置类提供源配置的文件。
+        ConfigurationProvider<?> provider = EasyConfiguration.from("config.yml");
+        // 2. 通过 “Provider” 初始化配置类或配置实例。
+        provider.initialize(SampleConfig.class);
+        // 3. 现在可以享受快捷方便的配置文件使用方式了~
+        SampleConfig.ENABLED.set(false);
+        System.out.println("Your name is " + SampleConfig.INFO.NAME.getNotNull() + " !");
+    }
+}
+```
+
+```yaml
+# Configurations for sample
+
+enabled: true # Enabled?
+
+uuids:
+  - 00000000-0000-0000-0000-000000000000
+  - 00000000-0000-0000-0000-000000000001
+
+info:
+  # Configure your name!
+  name: Joker
+  year: 24
+```
+
+### 依赖方式
+
+#### Maven 依赖
+
+<details>
+<summary>远程库配置</summary>
+
+```xml
+
+<project>
+    <repositories>
+
+        <repository>
+            <!--采用Maven中心库，安全稳定，但版本更新需要等待同步-->
+            <id>maven</id>
+            <name>Maven Central</name>
+            <url>https://repo1.maven.org/maven2</url>
+        </repository>
+  
+        <repository>
+            <!--采用github依赖库，实时更新，但需要配置 (推荐) -->
+            <id>EasyConfiguration</id>
+            <name>GitHub Packages</name>
+            <url>https://maven.pkg.github.com/CarmJos/EasyConfiguration</url>
+        </repository>
+
+        <repository>
+            <!--采用我的私人依赖库，简单方便，但可能因为变故而无法使用-->
+            <id>carm-repo</id>
+            <name>Carm's Repo</name>
+            <url>https://repo.carm.cc/repository/maven-public/</url>
+        </repository>
+
+    </repositories>
+</project>
+```
+
+</details>
+
+<details>
+<summary>通用原生依赖</summary>
+
+```xml
+
+<project>
+    <dependencies>
+        <!--基础实现部分，需要自行实现“Provider”与“Wrapper”。-->
+        <dependency>
+            <groupId>cc.carm.lib</groupId>
+            <artifactId>easyconfiguration-core</artifactId>
+            <version>[LATEST RELEASE]</version>
+            <scope>compile</scope>
+        </dependency>
+
+        <!--基于YAML文件的实现版本，可用于全部Java环境。-->
+        <dependency>
+            <groupId>cc.carm.lib</groupId>
+            <artifactId>easyconfiguration-yaml</artifactId>
+            <version>[LATEST RELEASE]</version>
+            <scope>compile</scope>
+        </dependency>
+
+        <!--基于JSON文件的实现版本，可用于全部Java环境。-->
+        <!--需要注意的是，JSON不支持文件注释。-->
+        <dependency>
+            <groupId>cc.carm.lib</groupId>
+            <artifactId>easyconfiguration-json</artifactId>
+            <version>[LATEST RELEASE]</version>
+            <scope>compile</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>cc.carm.lib</groupId>
+            <artifactId>easyconfiguration-hocon</artifactId>
+            <version>[LATEST RELEASE]</version>
+            <scope>compile</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>cc.carm.lib</groupId>
+            <artifactId>easyconfiguration-sql</artifactId>
+            <version>[LATEST RELEASE]</version>
+            <scope>compile</scope>
+        </dependency>
+        
+    </dependencies>
+</project>
+```
+
+</details>
+
+#### Gradle 依赖
+
+<details>
+<summary>远程库配置</summary>
+
+```groovy
+repositories {
+
+    // 采用Maven中心库，安全稳定，但版本更新需要等待同步 
+    mavenCentral()
+  
+    // 采用github依赖库，实时更新，但需要配置 (推荐)
+    maven { url 'https://maven.pkg.github.com/CarmJos/EasyConfiguration' }
+
+    // 采用我的私人依赖库，简单方便，但可能因为变故而无法使用
+    maven { url 'https://repo.carm.cc/repository/maven-public/' }
+}
+```
+
+</details>
+
+<details>
+<summary>通用原生依赖</summary>
+
+```groovy
+
+dependencies {
+
+    //基础实现部分，需要自行实现“Provider”与“Wrapper”。
+    api "cc.carm.lib:easyconfiguration-core:[LATEST RELEASE]"
+
+    //基于YAML文件的实现版本，可用于全部Java环境。
+    api "cc.carm.lib:easyconfiguration-yaml:[LATEST RELEASE]"
+
+     //基于JSON文件的实现版本，可用于全部Java环境。
+    //需要注意的是，JSON不支持文件注释。
+    api "cc.carm.lib:easyconfiguration-json:[LATEST RELEASE]"
+    
+    api "cc.carm.lib:easyconfiguration-hocon:[LATEST RELEASE]"
+    
+    api "cc.carm.lib:easyconfiguration-sql:[LATEST RELEASE]"
+
+}
+```
+
+</details>
+
+## 衍生项目
+
+### [**MineConfiguration**](https://github.com/CarmJos/MineConfiguration) (by @CarmJos )
+
+EasyConfiguration for MineCraft!
+开始在 MineCraft 相关服务器平台上轻松(做)配置吧！
+
+目前支持 BungeeCord, Bukkit(Spigot) 服务端，后续将支持更多平台。
+
+## 支持与捐赠
+
+若您觉得本插件做的不错，您可以通过捐赠支持我！
+
+感谢您对开源项目的支持！
+
+万分感谢 Jetbrains 为我们提供了从事此项目和其他开源项目的许可！
+
+[![](https://resources.jetbrains.com/storage/products/company/brand/logos/jb_beam.svg)](https://www.jetbrains.com/?from=https://github.com/CarmJos/EasyConfiguration)
+
+## 开源协议
+
+本项目源码采用 [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>2.0.0</version>
+        <version>4.0.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/Configuration.java

@@ -0,0 +1,7 @@
+package cc.carm.lib.configuration;
+
+/**
+ * The root interface of the configuration file interfaces,
+ * which is used to label a class as a configuration.
+ */
+public interface Configuration { }

core/src/main/java/cc/carm/lib/configuration/adapter/ValueAdapter.java

@@ -0,0 +1,79 @@
+package cc.carm.lib.configuration.adapter;
+
+import cc.carm.lib.configuration.source.ConfigurationHolder;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+
+/**
+ * Value adapter, used to convert the value of the configuration file into the objects.
+ *
+ * @param <TYPE> The type of the target value
+ */
+public class ValueAdapter<TYPE>
+        implements ValueSerializer<TYPE>, ValueParser<TYPE> {
+
+    protected final @NotNull ValueType<TYPE> type;
+    protected @Nullable ValueSerializer<TYPE> serializer;
+    protected @Nullable ValueParser<TYPE> deserializer;
+
+    public ValueAdapter(@NotNull ValueType<TYPE> type) {
+        this(type, null, null);
+    }
+
+    public ValueAdapter(@NotNull ValueType<TYPE> type,
+                        @Nullable ValueSerializer<TYPE> serializer,
+                        @Nullable ValueParser<TYPE> parser) {
+        this.type = type;
+        this.serializer = serializer;
+        this.deserializer = parser;
+    }
+
+    public @NotNull ValueType<TYPE> type() {
+        return type;
+    }
+
+    public @Nullable ValueSerializer<TYPE> serializer() {
+        return serializer;
+    }
+
+    public @Nullable ValueParser<TYPE> parser() {
+        return deserializer;
+    }
+
+    public ValueAdapter<TYPE> serializer(@Nullable ValueSerializer<TYPE> serializer) {
+        this.serializer = serializer;
+        return this;
+    }
+
+    public ValueAdapter<TYPE> parser(@Nullable ValueParser<TYPE> deserializer) {
+        this.deserializer = deserializer;
+        return this;
+    }
+
+    @Override
+    public Object serialize(@NotNull ConfigurationHolder<?> holder, @NotNull ValueType<? super TYPE> type, @NotNull TYPE value) throws Exception {
+        if (serializer == null) throw new UnsupportedOperationException("Serializer is not supported");
+        return serializer.serialize(holder, type, value);
+    }
+
+    @Override
+    public TYPE parse(@NotNull ConfigurationHolder<?> holder, @NotNull ValueType<? super TYPE> type, @NotNull Object value) throws Exception {
+        if (deserializer == null) throw new UnsupportedOperationException("Deserializer is not supported");
+        return deserializer.parse(holder, type, value);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof ValueAdapter)) return false;
+        ValueAdapter<?> that = (ValueAdapter<?>) o;
+        return Objects.equals(type, that.type);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(type);
+    }
+}
+

core/src/main/java/cc/carm/lib/configuration/adapter/ValueAdapterRegistry.java

@@ -0,0 +1,126 @@
+package cc.carm.lib.configuration.adapter;
+
+import cc.carm.lib.configuration.function.DataFunction;
+import cc.carm.lib.configuration.source.ConfigurationHolder;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class ValueAdapterRegistry {
+
+    protected final Set<ValueAdapter<?>> adapters = new HashSet<>();
+
+    public <FROM, TO> void register(@NotNull Class<FROM> from, @NotNull Class<TO> to,
+                                    @Nullable DataFunction<FROM, TO> parser,
+                                    @Nullable DataFunction<TO, FROM> serializer) {
+        register(ValueType.of(from), ValueType.of(to), parser, serializer);
+    }
+
+    public <FROM, TO> void register(@NotNull ValueType<FROM> from, @NotNull ValueType<TO> to,
+                                    @Nullable DataFunction<FROM, TO> parser,
+                                    @Nullable DataFunction<TO, FROM> serializer) {
+        ValueAdapter<FROM> fromAdapter = adapterOf(from);
+        if (fromAdapter == null) throw new IllegalArgumentException("No adapter for type " + from);
+        register(to,
+                serializer == null ? null : (provider, type, value) -> fromAdapter.serialize(provider, from, serializer.handle(value)),
+                parser == null ? null : (provider, type, data) -> parser.handle(fromAdapter.parse(provider, from, data))
+        );
+    }
+
+    public void register(@NotNull ValueAdapter<?>... adapter) {
+        adapters.addAll(Arrays.asList(adapter));
+    }
+
+    public <T> void register(@NotNull Class<T> type, @NotNull ValueSerializer<T> serializer) {
+        register(ValueType.of(type), serializer);
+    }
+
+    public <T> void register(@NotNull ValueType<T> type, @NotNull ValueSerializer<T> serializer) {
+        ValueAdapter<T> existing = adapterOf(type);
+        if (existing != null) {
+            existing.serializer(serializer);
+        } else {
+            register(new ValueAdapter<>(type, serializer, null));
+        }
+    }
+
+    public <T> void register(@NotNull Class<T> type, @NotNull ValueParser<T> deserializer) {
+        register(ValueType.of(type), deserializer);
+    }
+
+    public <T> void register(@NotNull ValueType<T> type, @NotNull ValueParser<T> deserializer) {
+        ValueAdapter<T> existing = adapterOf(type);
+        if (existing != null) {
+            existing.parser(deserializer);
+        } else {
+            register(new ValueAdapter<>(type, null, deserializer));
+        }
+    }
+
+    public <T> void register(@NotNull ValueType<T> type, @Nullable ValueSerializer<T> serializer, @Nullable ValueParser<T> deserializer) {
+        if (serializer == null && deserializer == null) return;
+        ValueAdapter<T> existing = adapterOf(type);
+        if (existing != null) {
+            if (serializer != null) existing.serializer(serializer);
+            if (deserializer != null) existing.parser(deserializer);
+        } else {
+            register(new ValueAdapter<>(type, serializer, deserializer));
+        }
+    }
+
+    public void unregister(@NotNull Class<?> type) {
+        unregister(ValueType.of(type));
+    }
+
+    public void unregister(@NotNull ValueType<?> type) {
+        adapters.removeIf(adapter -> adapter.type().equals(type));
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T> @Nullable ValueAdapter<T> adapterOf(@NotNull ValueType<T> type) {
+        ValueAdapter<?> matched = adapters.stream().filter(adapter -> adapter.type().equals(type)).findFirst().orElse(null);
+        if (matched != null) return (ValueAdapter<T>) matched;
+
+        // If no adapter found, try to find the adapter for the super type
+        return (ValueAdapter<T>) adapters.stream()
+                .filter(adapter -> adapter.type().isSubtypeOf(type))
+                .findFirst().orElse(null);
+    }
+
+    public <T> ValueAdapter<T> adapterOf(@NotNull T value) {
+        return adapterOf(ValueType.of(value));
+    }
+
+    public <T> ValueAdapter<T> adapterOf(@NotNull Class<T> type) {
+        return adapterOf(ValueType.of(type));
+    }
+
+    @Contract("_,_,null -> null")
+    public <T> T deserialize(@NotNull ConfigurationHolder<?> holder, @NotNull Class<T> type, @Nullable Object source) throws Exception {
+        return deserialize(holder, ValueType.of(type), source);
+    }
+
+    @Contract("_,_,null -> null")
+    public <T> T deserialize(@NotNull ConfigurationHolder<?> holder, @NotNull ValueType<T> type, @Nullable Object source) throws Exception {
+        if (source == null) return null; // Null check
+        if (type.isInstance(source)) return type.cast(source); // Not required to deserialize
+        ValueAdapter<T> adapter = adapterOf(type);
+        if (adapter == null) throw new RuntimeException("No adapter for type " + type);
+        return adapter.parse(holder, type, source);
+    }
+
+    @Contract("_,null -> null")
+    public <T> Object serialize(@NotNull ConfigurationHolder<?> holder, @Nullable T value) throws Exception {
+        if (value == null) return null; // Null check
+        ValueType<T> type = ValueType.of(value);
+        ValueAdapter<T> adapter = adapterOf(type);
+        if (adapter == null) return value; // No adapters, try to return the original value
+        return adapter.serialize(holder, type, value);
+    }
+
+
+}

core/src/main/java/cc/carm/lib/configuration/adapter/ValueParser.java

@@ -0,0 +1,19 @@
+package cc.carm.lib.configuration.adapter;
+
+import cc.carm.lib.configuration.source.ConfigurationHolder;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Value deserializer, convert base data to target value.
+ *
+ * @param <TYPE> The type of target value
+ */
+@FunctionalInterface
+public interface ValueParser<TYPE> {
+
+    TYPE parse(
+            @NotNull ConfigurationHolder<?> holder,
+            @NotNull ValueType<? super TYPE> type, @NotNull Object data
+    ) throws Exception;
+
+}

core/src/main/java/cc/carm/lib/configuration/adapter/ValueSerializer.java

@@ -0,0 +1,19 @@
+package cc.carm.lib.configuration.adapter;
+
+import cc.carm.lib.configuration.source.ConfigurationHolder;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Value serializer, convert target value to base data.
+ *
+ * @param <TYPE> The type of value
+ */
+@FunctionalInterface
+public interface ValueSerializer<TYPE> {
+
+    Object serialize(
+            @NotNull ConfigurationHolder<?> holder,
+            @NotNull ValueType<? super TYPE> type, @NotNull TYPE value
+    ) throws Exception;
+
+}

core/src/main/java/cc/carm/lib/configuration/adapter/ValueType.java

@@ -0,0 +1,191 @@
+package cc.carm.lib.configuration.adapter;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Used to get the generic type.
+ */
+public abstract class ValueType<T> {
+
+    public static final ValueType<String> STRING = ofPrimitiveType(String.class);
+    public static final ValueType<Integer> INTEGER = ofPrimitiveType(Integer.class);
+    public static final ValueType<Integer> INTEGER_TYPE = ofPrimitiveType(int.class);
+    public static final ValueType<Long> LONG = ofPrimitiveType(Long.class);
+    public static final ValueType<Long> LONG_TYPE = ofPrimitiveType(long.class);
+    public static final ValueType<Double> DOUBLE = ofPrimitiveType(Double.class);
+    public static final ValueType<Double> DOUBLE_TYPE = ofPrimitiveType(double.class);
+    public static final ValueType<Float> FLOAT = ofPrimitiveType(Float.class);
+    public static final ValueType<Float> FLOAT_TYPE = ofPrimitiveType(float.class);
+    public static final ValueType<Boolean> BOOLEAN = ofPrimitiveType(Boolean.class);
+    public static final ValueType<Boolean> BOOLEAN_TYPE = ofPrimitiveType(boolean.class);
+    public static final ValueType<Byte> BYTE = ofPrimitiveType(Byte.class);
+    public static final ValueType<Byte> BYTE_TYPE = ofPrimitiveType(byte.class);
+    public static final ValueType<Short> SHORT = ofPrimitiveType(Short.class);
+    public static final ValueType<Short> SHORT_TYPE = ofPrimitiveType(short.class);
+    public static final ValueType<Character> CHAR = ofPrimitiveType(Character.class);
+    public static final ValueType<Character> CHAR_TYPE = ofPrimitiveType(char.class);
+
+    public static final ValueType<?>[] PRIMITIVE_TYPES = {
+            STRING, INTEGER, LONG, DOUBLE, FLOAT, BOOLEAN, BYTE, SHORT, CHAR,
+            INTEGER_TYPE, LONG_TYPE, DOUBLE_TYPE, FLOAT_TYPE, BOOLEAN_TYPE, BYTE_TYPE, SHORT_TYPE, CHAR_TYPE
+    };
+
+    @SuppressWarnings("unchecked")
+    public static <T> ValueType<T> of(@NotNull T value) {
+        return of((Class<T>) value.getClass());
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T> ValueType<T> of(final Type type) {
+        if (type == null) throw new NullPointerException("Type cannot be null");
+        if (type instanceof Class<?>) { // Try handle primitive types
+            Class<?> clazz = (Class<?>) type;
+            for (ValueType<?> valueType : PRIMITIVE_TYPES) {
+                if (valueType.getRawType() == clazz) {
+                    return (ValueType<T>) valueType;
+                }
+            }
+        }
+        return new ValueType<T>(type) {
+        };
+    }
+
+    public static <T> ValueType<T> of(final Class<T> clazz) {
+        return of((Type) clazz);
+    }
+
+    /**
+     * Get the generic type of the complex type.
+     *
+     * @param rawType The raw type
+     * @param types   The type arguments
+     * @param <T>     The type
+     * @return The {@link ValueType}
+     */
+    public static <T> ValueType<T> of(final Class<?> rawType, final Type... types) {
+        ParameterizedType parameterizedType = new ParameterizedType() {
+            @Override
+            public @NotNull Type @NotNull [] getActualTypeArguments() {
+                return types;
+            }
+
+            @Override
+            public @NotNull Type getRawType() {
+                return rawType;
+            }
+
+            @Override
+            public Type getOwnerType() {
+                return null;
+            }
+        };
+        return of(parameterizedType);
+    }
+
+    private static <T> ValueType<T> ofPrimitiveType(Class<T> clazz) {
+        return new ValueType<T>(clazz) {
+        };
+    }
+
+    private final Type type;
+
+    protected ValueType() {
+        this.type = ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
+    }
+
+    private ValueType(Type type) {
+        this.type = type;
+    }
+
+    public Type getType() {
+        return type;
+    }
+
+    public boolean isSubtypeOf(Class<?> target) {
+        Class<?> rawType = getRawType();
+        return target.isAssignableFrom(rawType);
+    }
+
+    public boolean isSubtypeOf(ValueType<?> target) {
+        return target.isSubtypeOf(getRawType());
+    }
+
+    public boolean isInstance(Object obj) {
+        return obj != null && getRawType().isInstance(obj);
+    }
+
+
+    /**
+     * 提取当前 ValueType 的原始类型（Class 对象）。
+     *
+     * @return 对应的 Class 对象
+     * @throws IllegalStateException 如果无法提取出原始类型
+     */
+    public Class<?> getRawType() {
+        if (type instanceof Class<?>) {
+            return (Class<?>) type;
+        }
+        if (type instanceof ParameterizedType) {
+            ParameterizedType pt = (ParameterizedType) type;
+            Type raw = pt.getRawType();
+            if (raw instanceof Class<?>) {
+                return (Class<?>) raw;
+            }
+        }
+        throw new IllegalStateException("Unsupported type: " + type);
+    }
+
+    @SuppressWarnings("unchecked")
+    public T cast(Object obj) {
+        if (!isInstance(obj)) {
+            throw new ClassCastException("Cannot cast object " + obj + " to type " + this);
+        }
+        return (T) obj;
+    }
+
+    @Override
+    public String toString() {
+        if (type instanceof Class<?>) {
+            return ((Class<?>) type).getName();
+        }
+        if (type instanceof ParameterizedType) {
+            ParameterizedType pt = (ParameterizedType) type;
+            Type raw = pt.getRawType();
+            StringBuilder sb = new StringBuilder();
+            sb.append(raw.getTypeName());
+            sb.append('<');
+            Type[] args = pt.getActualTypeArguments();
+            for (int i = 0; i < args.length; i++) {
+                if (i > 0) {
+                    sb.append(", ");
+                }
+                sb.append(args[i].getTypeName());
+            }
+            return sb.toString();
+        }
+        return type.getTypeName();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (obj instanceof ValueType) {
+            return Objects.equals(type, ((ValueType<?>) obj).type);
+        }
+        if (obj instanceof Type) {
+            return Objects.equals(type, obj);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(type);
+    }
+
+}

core/src/main/java/cc/carm/lib/configuration/adapter/strandard/PrimitiveAdapter.java

@@ -0,0 +1,119 @@
+package cc.carm.lib.configuration.adapter.strandard;
+
+import cc.carm.lib.configuration.adapter.ValueAdapter;
+import cc.carm.lib.configuration.adapter.ValueParser;
+import cc.carm.lib.configuration.adapter.ValueType;
+import cc.carm.lib.configuration.function.DataFunction;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+
+public class PrimitiveAdapter<T> extends ValueAdapter<T> {
+
+    public static final String[] TRUE_VALUES = new String[]{
+            "true", "yes", "on", "1", "enabled", "enable", "active"
+    };
+
+    public static final String[] FALSE_VALUES = new String[]{
+            "false", "no", "off", "0", "disabled", "disable", "inactive"
+    };
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    public static ValueAdapter<Enum<?>> ofEnum() {
+        ValueAdapter<Enum<?>> adapter = new ValueAdapter<>(new ValueType<Enum<?>>() {
+        });
+        adapter.parser((provider, type, data) -> Enum.valueOf((Class<Enum>) type.getRawType(), data.toString()));
+        adapter.serializer((provider, type, value) -> value.name());
+        return adapter;
+    }
+
+    public static PrimitiveAdapter<String> ofString() {
+        return of(String.class, o -> o instanceof String ? (String) o : o.toString());
+    }
+
+    public static PrimitiveAdapter<Boolean> ofBoolean() {
+        return of(Boolean.class, data -> {
+            if (data instanceof Boolean) return (Boolean) data;
+            String v = data.toString().trim();
+            if (Arrays.stream(TRUE_VALUES).anyMatch(v::equalsIgnoreCase)) return true;
+            else if (Arrays.stream(FALSE_VALUES).anyMatch(v::equalsIgnoreCase)) return false;
+            else throw new IllegalArgumentException("Cannot parse boolean from " + data);
+        });
+    }
+
+    public static PrimitiveAdapter<Boolean> ofBooleanType() {
+        return of(boolean.class, o -> o instanceof Boolean ? (Boolean) o : Boolean.parseBoolean(o.toString()));
+    }
+
+    public static PrimitiveAdapter<Character> ofCharacter() {
+        return of(Character.class, o -> o instanceof Character ? (Character) o : o.toString().charAt(0));
+    }
+
+    public static PrimitiveAdapter<Character> ofCharacterType() {
+        return of(char.class, o -> o instanceof Character ? (Character) o : o.toString().charAt(0));
+    }
+
+    public static PrimitiveAdapter<Integer> ofInteger() {
+        return ofNumber(Integer.class, Number::intValue, Integer::parseInt);
+    }
+
+    public static PrimitiveAdapter<Integer> ofIntegerType() {
+        return ofNumber(int.class, Number::intValue, Integer::parseInt);
+    }
+
+    public static PrimitiveAdapter<Long> ofLong() {
+        return ofNumber(Long.class, Number::longValue, Long::parseLong);
+    }
+
+    public static PrimitiveAdapter<Long> ofLongType() {
+        return ofNumber(long.class, Number::longValue, Long::parseLong);
+    }
+
+    public static PrimitiveAdapter<Double> ofDouble() {
+        return ofNumber(Double.class, Number::doubleValue, Double::parseDouble);
+    }
+
+    public static PrimitiveAdapter<Double> ofDoubleType() {
+        return ofNumber(double.class, Number::doubleValue, Double::parseDouble);
+    }
+
+    public static PrimitiveAdapter<Float> ofFloat() {
+        return ofNumber(Float.class, Number::floatValue, Float::parseFloat);
+    }
+
+    public static PrimitiveAdapter<Float> ofFloatType() {
+        return ofNumber(float.class, Number::floatValue, Float::parseFloat);
+    }
+
+    public static PrimitiveAdapter<Short> ofShort() {
+        return ofNumber(Short.class, Number::shortValue, Short::parseShort);
+    }
+
+    public static PrimitiveAdapter<Short> ofShortType() {
+        return ofNumber(short.class, Number::shortValue, Short::parseShort);
+    }
+
+    public static PrimitiveAdapter<Byte> ofByte() {
+        return ofNumber(Byte.class, Number::byteValue, Byte::parseByte);
+    }
+
+    public static PrimitiveAdapter<Byte> ofByteType() {
+        return ofNumber(byte.class, Number::byteValue, Byte::parseByte);
+    }
+
+    public static <T> PrimitiveAdapter<T> of(@NotNull Class<T> clazz,
+                                             @NotNull DataFunction<Object, T> function) {
+        return new PrimitiveAdapter<>(clazz, (p, type, data) -> function.handle(data));
+    }
+
+    public static <T extends Number> PrimitiveAdapter<T> ofNumber(@NotNull Class<T> numberClass,
+                                                                  @NotNull DataFunction<Number, T> castFunction,
+                                                                  @NotNull DataFunction<String, T> parseFunction) {
+        return of(numberClass, o -> o instanceof Number ? castFunction.handle((Number) o) : parseFunction.handle(o.toString()));
+    }
+
+    protected PrimitiveAdapter(@NotNull Class<T> valueType, @NotNull ValueParser<T> deserializer) {
+        super(ValueType.of(valueType), (provider, type, value) -> value, deserializer);
+    }
+
+}

core/src/main/java/cc/carm/lib/configuration/adapter/strandard/StandardAdapters.java

@@ -0,0 +1,30 @@
+package cc.carm.lib.configuration.adapter.strandard;
+
+import cc.carm.lib.configuration.adapter.ValueAdapter;
+import cc.carm.lib.configuration.adapter.ValueType;
+import cc.carm.lib.configuration.source.section.ConfigureSection;
+import org.jetbrains.annotations.NotNull;
+
+import static cc.carm.lib.configuration.adapter.strandard.PrimitiveAdapter.*;
+
+public interface StandardAdapters {
+
+    @NotNull PrimitiveAdapter<?>[] PRIMITIVES = new PrimitiveAdapter[]{
+            ofString(), ofBoolean(), ofBooleanType(), ofCharacter(), ofCharacterType(),
+            ofInteger(), ofIntegerType(), ofLong(), ofLongType(), ofDouble(), ofDoubleType(),
+            ofFloat(), ofFloatType(), ofShort(), ofShortType(), ofByte(), ofByteType()
+    };
+
+    @NotNull ValueAdapter<Enum<?>> ENUMS = PrimitiveAdapter.ofEnum();
+
+    @NotNull ValueAdapter<ConfigureSection> SECTIONS = new ValueAdapter<>(
+            ValueType.of(ConfigureSection.class),
+            (provider, type, value) -> value,
+            (provider, type, value) -> {
+                if (value instanceof ConfigureSection) {
+                    return (ConfigureSection) value;
+                } else throw new IllegalArgumentException("Value is not a ConfigurationSection");
+            }
+    );
+
+}

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

@@ -0,0 +1,32 @@
+package cc.carm.lib.configuration.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * The configuration path used to mark the corresponding class or parameter.
+ */
+@Target({ElementType.TYPE, ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ConfigPath {
+
+    /**
+     * The path value of the current configuration.
+     * If not set,will generate the path by {@link cc.carm.lib.configuration.source.loader.PathGenerator}.
+     *
+     * @return The path value of the current configuration
+     */
+    String value() default "";
+
+    /**
+     * Whether to start with the root node.
+     * <br>If false, the previous path (if any) to the node is automatically added.
+     * <br>If true, the path will be set directly from the root node.
+     *
+     * @return Whether to start directly from the root path without inheriting the previous path
+     */
+    boolean root() default false;
+
+}

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

@@ -0,0 +1,91 @@
+package cc.carm.lib.configuration.builder;
+
+import cc.carm.lib.configuration.adapter.ValueType;
+import cc.carm.lib.configuration.source.ConfigurationHolder;
+import cc.carm.lib.configuration.source.meta.ConfigurationMetaHolder;
+import cc.carm.lib.configuration.source.meta.ConfigurationMetadata;
+import cc.carm.lib.configuration.value.ConfigValue;
+import cc.carm.lib.configuration.value.ValueManifest;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public abstract class AbstractConfigBuilder<
+        TYPE, RESULT extends ConfigValue<TYPE>, HOLDER extends ConfigurationHolder<?>,
+        SELF extends AbstractConfigBuilder<TYPE, RESULT, HOLDER, SELF>
+        > {
+
+    protected final Class<? super HOLDER> providerClass;
+    protected final ValueType<TYPE> type;
+
+    protected @Nullable HOLDER holder;
+    protected @Nullable String path;
+
+    protected @NotNull Supplier<@Nullable TYPE> defaultValueSupplier = () -> null;
+    protected @NotNull BiConsumer<ConfigurationHolder<?>, String> initializer = (h, p) -> {
+    };
+
+    protected AbstractConfigBuilder(Class<? super HOLDER> providerClass, ValueType<TYPE> type) {
+        this.providerClass = providerClass;
+        this.type = type;
+    }
+
+    public @NotNull ValueType<TYPE> type() {
+        return type;
+    }
+
+    protected abstract @NotNull SELF self();
+
+    public abstract @NotNull RESULT build();
+
+    public @NotNull SELF holder(@Nullable HOLDER holder) {
+        this.holder = holder;
+        return self();
+    }
+
+    public @NotNull SELF path(@Nullable String path) {
+        this.path = path;
+        return self();
+    }
+
+    public @NotNull SELF initializer(@NotNull BiConsumer<ConfigurationHolder<?>, String> initializer) {
+        this.initializer = initializer;
+        return self();
+    }
+
+    public @NotNull SELF append(@NotNull BiConsumer<ConfigurationHolder<?>, String> initializer) {
+        return initializer(initializer.andThen(initializer));
+    }
+
+    public @NotNull SELF append(@NotNull Consumer<ConfigurationHolder<?>> initializer) {
+        return append((provider, valuePath) -> initializer.accept(provider));
+    }
+
+    public @NotNull SELF defaults(@Nullable TYPE defaultValue) {
+        return defaults(() -> defaultValue);
+    }
+
+    public @NotNull SELF defaults(@NotNull Supplier<@Nullable TYPE> supplier) {
+        this.defaultValueSupplier = supplier;
+        return self();
+    }
+
+    public <M> @NotNull SELF meta(@NotNull Consumer<@NotNull ConfigurationMetaHolder> metaConsumer) {
+        return append((h, p) -> metaConsumer.accept(h.metadata(p)));
+    }
+
+    public <M> @NotNull SELF meta(@NotNull ConfigurationMetadata<M> type, @Nullable M value) {
+        return meta(h -> h.set(type, value));
+    }
+
+    protected @NotNull ValueManifest<TYPE> buildManifest() {
+        return new ValueManifest<>(
+                type(), this.defaultValueSupplier, this.initializer,
+                this.holder, this.path
+        );
+    }
+
+}

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

@@ -0,0 +1,14 @@
+package cc.carm.lib.configuration.builder;
+
+import cc.carm.lib.configuration.adapter.ValueType;
+import cc.carm.lib.configuration.source.ConfigurationHolder;
+import cc.carm.lib.configuration.value.ConfigValue;
+
+public abstract class CommonConfigBuilder<TYPE, RESULT extends ConfigValue<TYPE>, SELF extends CommonConfigBuilder<TYPE, RESULT, SELF>>
+        extends AbstractConfigBuilder<TYPE, RESULT, ConfigurationHolder<?>, SELF> {
+
+    protected CommonConfigBuilder(ValueType<TYPE> type) {
+        super(ConfigurationHolder.class, type);
+    }
+
+}

core/src/main/java/cc/carm/lib/configuration/builder/impl/AbstractSectionBuilder.java

@@ -0,0 +1,76 @@
+package cc.carm.lib.configuration.builder.impl;
+
+import cc.carm.lib.configuration.adapter.ValueAdapter;
+import cc.carm.lib.configuration.adapter.ValueType;
+import cc.carm.lib.configuration.builder.CommonConfigBuilder;
+import cc.carm.lib.configuration.function.DataConsumer;
+import cc.carm.lib.configuration.function.DataFunction;
+import cc.carm.lib.configuration.function.ValueHandler;
+import cc.carm.lib.configuration.source.section.ConfigureSection;
+import cc.carm.lib.configuration.value.ConfigValue;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public abstract class AbstractSectionBuilder<
+        TYPE, PARAM,
+        RESULT extends ConfigValue<TYPE>,
+        SELF extends AbstractSectionBuilder<TYPE, PARAM, RESULT, SELF>
+        > extends CommonConfigBuilder<TYPE, RESULT, SELF> {
+
+
+    protected final @NotNull ValueType<PARAM> paramType;
+
+    protected @NotNull ValueHandler<ConfigureSection, PARAM> parser;
+    protected @NotNull ValueHandler<PARAM, ? extends Map<String, Object>> serializer;
+
+    protected AbstractSectionBuilder(@NotNull ValueType<TYPE> type, @NotNull ValueType<PARAM> paramType,
+                                     @NotNull ValueHandler<ConfigureSection, PARAM> parser,
+                                     @NotNull ValueHandler<PARAM, ? extends Map<String, Object>> serializer) {
+        super(type);
+        this.paramType = paramType;
+        this.parser = parser;
+        this.serializer = serializer;
+    }
+
+    public @NotNull SELF parse(DataFunction<ConfigureSection, PARAM> valueParser) {
+        return parse((p, section) -> valueParser.handle(section));
+    }
+
+    public @NotNull SELF parse(ValueHandler<ConfigureSection, PARAM> valueParser) {
+        this.parser = valueParser;
+        return self();
+    }
+
+    public @NotNull SELF serialize(DataFunction<PARAM, ? extends Map<String, Object>> serializer) {
+        return serialize((p, value) -> serializer.handle(value));
+    }
+
+    public @NotNull SELF serialize(ValueHandler<PARAM, ? extends Map<String, Object>> serializer) {
+        this.serializer = serializer;
+        return self();
+    }
+
+    public @NotNull SELF serialize(DataConsumer<Map<String, Object>> serializer) {
+        return serialize((p, value) -> {
+            Map<String, Object> map = new LinkedHashMap<>();
+            serializer.accept(map);
+            return map;
+        });
+    }
+
+    protected ValueAdapter<PARAM> buildAdapter() {
+        return new ValueAdapter<>(this.paramType)
+                .parser((p, type, data) -> {
+                    ConfigureSection section = p.deserialize(ConfigureSection.class, data);
+                    if (section == null) return null;
+                    return this.parser.handle(p, section);
+                })
+                .serializer((p, type, data) -> {
+                    Map<String, Object> map = this.serializer.handle(p, data);
+                    return map == null || map.isEmpty() ? null : map;
+                });
+    }
+
+}

core/src/main/java/cc/carm/lib/configuration/builder/impl/AbstractSourceBuilder.java

@@ -0,0 +1,63 @@
+package cc.carm.lib.configuration.builder.impl;
+
+import cc.carm.lib.configuration.adapter.ValueAdapter;
+import cc.carm.lib.configuration.adapter.ValueType;
+import cc.carm.lib.configuration.builder.CommonConfigBuilder;
+import cc.carm.lib.configuration.function.DataFunction;
+import cc.carm.lib.configuration.function.ValueHandler;
+import cc.carm.lib.configuration.value.ConfigValue;
+import org.jetbrains.annotations.NotNull;
+
+public abstract class AbstractSourceBuilder<
+        V, SOURCE, PARAM, RESULT extends ConfigValue<V>,
+        SELF extends AbstractSourceBuilder<V, SOURCE, PARAM, RESULT, SELF>
+        > extends CommonConfigBuilder<V, RESULT, SELF> {
+
+    protected final @NotNull ValueType<SOURCE> sourceType;
+    protected final @NotNull ValueType<PARAM> paramType;
+    protected @NotNull ValueHandler<SOURCE, PARAM> valueParser;
+    protected @NotNull ValueHandler<PARAM, SOURCE> valueSerializer;
+
+    protected AbstractSourceBuilder(@NotNull ValueType<V> type,
+                                 @NotNull ValueType<SOURCE> sourceType, @NotNull ValueType<PARAM> paramType,
+                                 @NotNull ValueHandler<SOURCE, PARAM> parser,
+                                 @NotNull ValueHandler<PARAM, SOURCE> serializer) {
+        super(type);
+        this.sourceType = sourceType;
+        this.paramType = paramType;
+        this.valueParser = parser;
+        this.valueSerializer = serializer;
+    }
+
+    public @NotNull SELF parse(DataFunction<SOURCE, PARAM> parser) {
+        return parse((p, source) -> parser.handle(source));
+    }
+
+    public @NotNull SELF parse(@NotNull ValueHandler<SOURCE, PARAM> parser) {
+        this.valueParser = parser;
+        return self();
+    }
+
+    public @NotNull SELF serialize(@NotNull ValueHandler<PARAM, SOURCE> serializer) {
+        this.valueSerializer = serializer;
+        return self();
+    }
+
+    public @NotNull SELF serialize(@NotNull DataFunction<PARAM, SOURCE> serializer) {
+        return serialize((p, value) -> serializer.handle(value));
+    }
+
+    protected ValueAdapter<PARAM> buildAdapter() {
+        return new ValueAdapter<>(this.paramType)
+                .parser((holder, type, data) -> {
+                    SOURCE source = holder.deserialize(this.sourceType, data);
+                    return this.valueParser.handle(holder, source);
+                })
+                .serializer((holder, type, data) -> {
+                    SOURCE source = this.valueSerializer.handle(holder, data);
+                    return holder.serialize(source);
+                });
+    }
+
+
+}

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

@@ -0,0 +1,44 @@
+package cc.carm.lib.configuration.builder.list;
+
+import cc.carm.lib.configuration.adapter.ValueType;
+import cc.carm.lib.configuration.function.ValueHandler;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+
+public class ConfigListBuilder<V> {
+
+    protected final @NotNull ValueType<V> type;
+
+    public ConfigListBuilder(@NotNull ValueType<V> type) {
+        this.type = type;
+    }
+
+    public <S> @NotNull SourceListBuilder<S, V> from(@NotNull Class<S> sourceType) {
+        return from(ValueType.of(sourceType));
+    }
+
+    public <S> @NotNull SourceListBuilder<S, V> from(@NotNull ValueType<S> sourceType) {
+        return new SourceListBuilder<>(
+                ArrayList::new, sourceType, type,
+                ValueHandler.required(type),
+                ValueHandler.required(sourceType)
+        );
+    }
+
+    public @NotNull SourceListBuilder<String, V> fromString() {
+        return new SourceListBuilder<>(
+                ArrayList::new, ValueType.STRING, type,
+                ValueHandler.required(type), ValueHandler.stringValue()
+        );
+    }
+
+    public @NotNull SectionListBuilder<V> fromSection() {
+        return new SectionListBuilder<>(
+                ArrayList::new, type,
+                ValueHandler.required(type), ValueHandler.required()
+        );
+    }
+
+
+}

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

@@ -0,0 +1,53 @@
+package cc.carm.lib.configuration.builder.list;
+
+import cc.carm.lib.configuration.adapter.ValueType;
+import cc.carm.lib.configuration.builder.impl.AbstractSectionBuilder;
+import cc.carm.lib.configuration.function.ValueHandler;
+import cc.carm.lib.configuration.source.section.ConfigureSection;
+import cc.carm.lib.configuration.value.standard.ConfiguredList;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.*;
+import java.util.function.Supplier;
+
+public class SectionListBuilder<V> extends AbstractSectionBuilder<List<V>, V, ConfiguredList<V>, SectionListBuilder<V>> {
+
+    protected @NotNull Supplier<? extends List<V>> constructor;
+
+    public SectionListBuilder(@NotNull Supplier<? extends List<V>> constructor,
+                              @NotNull ValueType<V> paramType,
+                              @NotNull ValueHandler<ConfigureSection, V> parser,
+                              @NotNull ValueHandler<V, ? extends Map<String, Object>> serializer) {
+        super(new ValueType<List<V>>() {
+        }, paramType, parser, serializer);
+        this.constructor = constructor;
+    }
+
+    @SafeVarargs
+    public final @NotNull SectionListBuilder<V> defaults(@NotNull V... values) {
+        return defaults(new ArrayList<>(Arrays.asList(values)));
+    }
+
+    public final @NotNull SectionListBuilder<V> defaults(@NotNull Collection<V> values) {
+        return defaults(new ArrayList<>(values));
+    }
+
+    public SectionListBuilder<V> constructor(@NotNull Supplier<? extends List<V>> constructor) {
+        this.constructor = constructor;
+        return this;
+    }
+
+    public <LIST extends List<V>> SectionListBuilder<V> construct(@NotNull LIST list) {
+        return constructor(() -> list);
+    }
+
+    @Override
+    protected @NotNull SectionListBuilder<V> self() {
+        return this;
+    }
+
+    @Override
+    public @NotNull ConfiguredList<V> build() {
+        return new ConfiguredList<>(buildManifest(), constructor, buildAdapter());
+    }
+}

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

@@ -0,0 +1,47 @@
+package cc.carm.lib.configuration.builder.list;
+
+import cc.carm.lib.configuration.adapter.ValueType;
+import cc.carm.lib.configuration.builder.impl.AbstractSourceBuilder;
+import cc.carm.lib.configuration.function.ValueHandler;
+import cc.carm.lib.configuration.value.standard.ConfiguredList;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Supplier;
+
+public class SourceListBuilder<SOURCE, V>
+        extends AbstractSourceBuilder<List<V>, SOURCE, V, ConfiguredList<V>, SourceListBuilder<SOURCE, V>> {
+
+    protected @NotNull Supplier<? extends List<V>> constructor;
+
+    public SourceListBuilder(@NotNull Supplier<? extends List<V>> constructor,
+                             @NotNull ValueType<SOURCE> sourceType, @NotNull ValueType<V> paramType,
+                             @NotNull ValueHandler<SOURCE, V> parser, @NotNull ValueHandler<V, SOURCE> serializer) {
+        super(new ValueType<List<V>>() {
+        }, sourceType, paramType, parser, serializer);
+        this.constructor = constructor;
+    }
+
+    @SafeVarargs
+    public final @NotNull SourceListBuilder<SOURCE, V> defaults(@NotNull V... values) {
+        return defaults(new ArrayList<>(Arrays.asList(values)));
+    }
+
+    public final @NotNull SourceListBuilder<SOURCE, V> defaults(@NotNull Collection<V> values) {
+        return defaults(new ArrayList<>(values));
+    }
+
+    @Override
+    protected @NotNull SourceListBuilder<SOURCE, V> self() {
+        return this;
+    }
+
+    @Override
+    public @NotNull ConfiguredList<V> build() {
+        return new ConfiguredList<>(buildManifest(), this.constructor, buildAdapter());
+    }
+
+}

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

@@ -0,0 +1,80 @@
+package cc.carm.lib.configuration.builder.map;
+
+import cc.carm.lib.configuration.adapter.ValueType;
+import cc.carm.lib.configuration.function.ValueHandler;
+import cc.carm.lib.configuration.source.section.ConfigureSection;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Map;
+import java.util.function.Supplier;
+
+public class ConfigMapBuilder<M extends Map<K, V>, K, V> {
+
+
+    protected final @NotNull Supplier<@NotNull M> constructor;
+    protected final @NotNull ValueType<K> keyType;
+    protected final @NotNull ValueType<V> valueType;
+
+    public ConfigMapBuilder(@NotNull Supplier<@NotNull M> constructor,
+                            @NotNull ValueType<K> keyType, @NotNull ValueType<V> valueType) {
+        this.constructor = constructor;
+        this.keyType = keyType;
+        this.valueType = valueType;
+    }
+
+    public <W extends Map<K, V>> ConfigMapBuilder<W, K, V> constructor(@NotNull Supplier<W> supplier) {
+        return new ConfigMapBuilder<>(supplier, keyType, valueType);
+    }
+
+    public @NotNull <S> SourceMapBuilder<M, S, K, V> from(@NotNull Class<S> clazz) {
+        return from(ValueType.of(clazz));
+    }
+
+    public @NotNull <S> SourceMapBuilder<M, S, K, V> from(@NotNull ValueType<S> sourceType) {
+        return from(
+                sourceType,
+                ValueHandler.required(keyType), ValueHandler.stringValue(),
+                ValueHandler.required(valueType), ValueHandler.required()
+        );
+    }
+
+    public <S> @NotNull SourceMapBuilder<M, S, K, V> from(@NotNull ValueType<S> sourceType,
+                                                          @NotNull ValueHandler<String, K> keyParser,
+                                                          @NotNull ValueHandler<K, String> keySerializer,
+                                                          @NotNull ValueHandler<S, V> valueParser,
+                                                          @NotNull ValueHandler<V, S> valueSerializer) {
+        return new SourceMapBuilder<>(
+                this.constructor, sourceType, keyType, valueType,
+                keyParser, keySerializer, valueParser, valueSerializer
+        );
+    }
+
+    public @NotNull SourceMapBuilder<M, String, K, V> fromString() {
+        return from(
+                ValueType.STRING,
+                ValueHandler.required(keyType), ValueHandler.stringValue(),
+                ValueHandler.required(valueType), ValueHandler.stringValue()
+        );
+    }
+
+    public @NotNull SectionMapBuilder<M, K, V> fromSection() {
+        return fromSection(
+                ValueHandler.required(keyType), ValueHandler.stringValue(),
+                ValueHandler.required(valueType), ValueHandler.required()
+        );
+    }
+
+    public @NotNull SectionMapBuilder<M, K, V> fromSection(
+            @NotNull ValueHandler<String, K> keyParser,
+            @NotNull ValueHandler<K, String> keySerializer,
+            @NotNull ValueHandler<ConfigureSection, V> valueParser,
+            @NotNull ValueHandler<V, Map<String, Object>> valueSerializer
+    ) {
+        return new SectionMapBuilder<>(
+                this.constructor, keyType, valueType,
+                keyParser, keySerializer, valueParser, valueSerializer
+        );
+    }
+
+
+}

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

@@ -0,0 +1,48 @@
+package cc.carm.lib.configuration.builder.map;
+
+import cc.carm.lib.configuration.adapter.ValueType;
+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 ValueType<K> keyType;
+    protected final @NotNull ValueType<V> valueType;
+
+    public ConfigMapCreator(@NotNull ValueType<K> keyType, @NotNull ValueType<V> valueType) {
+        this.keyType = keyType;
+        this.valueType = valueType;
+    }
+
+    public <M extends Map<K, V>> @NotNull ConfigMapBuilder<M, K, V> constructor(@NotNull Supplier<@NotNull M> mapSuppler) {
+        return new ConfigMapBuilder<>(mapSuppler, keyType, valueType);
+    }
+
+    public <W extends Map<K, V>> @NotNull ConfigMapBuilder<W, K, V> constructor(@NotNull Class<W> type) {
+        return constructor(() -> {
+            try {
+                return type.getDeclaredConstructor().newInstance();
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+        });
+    }
+
+    public @NotNull ConfigMapBuilder<HashMap<K, V>, K, V> asHashMap() {
+        return constructor(HashMap::new);
+    }
+
+    public @NotNull ConfigMapBuilder<LinkedHashMap<K, V>, K, V> asLinkedMap() {
+        return constructor(LinkedHashMap::new);
+    }
+
+    public @NotNull ConfigMapBuilder<TreeMap<K, V>, K, V> asTreeMap() {
+        return constructor(TreeMap::new);
+    }
+
+}

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

@@ -0,0 +1,95 @@
+package cc.carm.lib.configuration.builder.map;
+
+import cc.carm.lib.configuration.adapter.ValueAdapter;
+import cc.carm.lib.configuration.adapter.ValueType;
+import cc.carm.lib.configuration.builder.impl.AbstractSectionBuilder;
+import cc.carm.lib.configuration.function.DataFunction;
+import cc.carm.lib.configuration.function.ValueHandler;
+import cc.carm.lib.configuration.source.section.ConfigureSection;
+import cc.carm.lib.configuration.value.standard.ConfiguredMap;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Map;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class SectionMapBuilder<MAP extends Map<K, V>, K, V>
+        extends AbstractSectionBuilder<
+        Map<K, V>, V, ConfiguredMap<K, V>,
+        SectionMapBuilder<MAP, K, V>
+        > {
+
+    protected final @NotNull ValueType<K> keyType;
+
+    protected @NotNull Supplier<? extends MAP> constructor;
+    protected @NotNull ValueHandler<String, K> keyParser;
+    protected @NotNull ValueHandler<K, String> keySerializer;
+
+    public SectionMapBuilder(@NotNull Supplier<? extends MAP> constructor,
+                             @NotNull ValueType<K> keyType, @NotNull ValueType<V> valueType,
+                             @NotNull ValueHandler<String, K> keyParser,
+                             @NotNull ValueHandler<K, String> keySerializer,
+                             @NotNull ValueHandler<ConfigureSection, V> valueParser,
+                             @NotNull ValueHandler<V, Map<String, Object>> valueSerializer) {
+        super(new ValueType<Map<K, V>>() {
+        }, valueType, valueParser, valueSerializer);
+        this.keyType = keyType;
+        this.constructor = constructor;
+        this.keyParser = keyParser;
+        this.keySerializer = keySerializer;
+    }
+
+    @Override
+    protected @NotNull SectionMapBuilder<MAP, K, V> self() {
+        return this;
+    }
+
+
+    public @NotNull SectionMapBuilder<MAP, K, V> parseKey(@NotNull DataFunction<String, K> keyParser) {
+        return parseKey((holder, data) -> keyParser.handle(data));
+    }
+
+    public @NotNull SectionMapBuilder<MAP, K, V> parseKey(@NotNull ValueHandler<String, K> keyParser) {
+        this.keyParser = keyParser;
+        return this;
+    }
+
+    public @NotNull SectionMapBuilder<MAP, K, V> serializeKey(@NotNull DataFunction<K, String> keySerializer) {
+        return serializeKey((holder, data) -> keySerializer.handle(data));
+    }
+
+    public @NotNull SectionMapBuilder<MAP, K, V> serializeKey(@NotNull ValueHandler<K, String> keySerializer) {
+        this.keySerializer = keySerializer;
+        return this;
+    }
+
+    public @NotNull SectionMapBuilder<MAP, K, V> defaults(@NotNull MAP defaults) {
+        return defaults(() -> defaults);
+    }
+
+    public @NotNull SectionMapBuilder<MAP, K, V> defaults(@NotNull Consumer<MAP> defaults) {
+        return defaults(() -> {
+            MAP map = this.constructor.get();
+            defaults.accept(map);
+            return map;
+        });
+    }
+
+    public @NotNull ValueAdapter<K> buildKeyAdapter() {
+        return new ValueAdapter<>(this.keyType)
+                .parser((holder, type, data) -> {
+                    String source = holder.deserialize(String.class, data);
+                    return this.keyParser.handle(holder, source);
+                })
+                .serializer((holder, type, data) -> {
+                    String source = this.keySerializer.handle(holder, data);
+                    return holder.serialize(source);
+                });
+    }
+
+    @Override
+    public @NotNull ConfiguredMap<K, V> build() {
+        return new ConfiguredMap<>(buildManifest(), this.constructor, buildKeyAdapter(), this.buildAdapter());
+    }
+
+}

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

@@ -0,0 +1,91 @@
+package cc.carm.lib.configuration.builder.map;
+
+import cc.carm.lib.configuration.adapter.ValueAdapter;
+import cc.carm.lib.configuration.adapter.ValueType;
+import cc.carm.lib.configuration.builder.impl.AbstractSourceBuilder;
+import cc.carm.lib.configuration.function.DataFunction;
+import cc.carm.lib.configuration.function.ValueHandler;
+import cc.carm.lib.configuration.value.standard.ConfiguredMap;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Map;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class SourceMapBuilder<MAP extends Map<K, V>, SOURCE, K, V>
+        extends AbstractSourceBuilder<
+        Map<K, V>, SOURCE, V, ConfiguredMap<K, V>,
+        SourceMapBuilder<MAP, SOURCE, K, V>
+        > {
+
+    protected final @NotNull ValueType<K> keyType;
+
+    protected @NotNull Supplier<? extends MAP> constructor;
+    protected @NotNull ValueHandler<String, K> keyParser;
+    protected @NotNull ValueHandler<K, String> keySerializer;
+
+    public SourceMapBuilder(@NotNull Supplier<? extends MAP> constructor, @NotNull ValueType<SOURCE> sourceType,
+                            @NotNull ValueType<K> keyType, @NotNull ValueType<V> valueType,
+                            @NotNull ValueHandler<String, K> keyParser, @NotNull ValueHandler<K, String> keySerializer,
+                            @NotNull ValueHandler<SOURCE, V> valueParser, @NotNull ValueHandler<V, SOURCE> valueSerializer) {
+        super(new ValueType<Map<K, V>>() {
+        }, sourceType, valueType, valueParser, valueSerializer);
+        this.keyType = keyType;
+        this.constructor = constructor;
+        this.keyParser = keyParser;
+        this.keySerializer = keySerializer;
+    }
+
+    @Override
+    protected @NotNull SourceMapBuilder<MAP, SOURCE, K, V> self() {
+        return this;
+    }
+
+    public @NotNull SourceMapBuilder<MAP, SOURCE, K, V> defaults(@NotNull MAP defaults) {
+        return defaults(() -> defaults);
+    }
+
+    public @NotNull SourceMapBuilder<MAP, SOURCE, K, V> defaults(@NotNull Consumer<MAP> defaults) {
+        return defaults(() -> {
+            MAP map = this.constructor.get();
+            defaults.accept(map);
+            return map;
+        });
+    }
+
+    public @NotNull SourceMapBuilder<MAP, SOURCE, K, V> parseKey(@NotNull DataFunction<String, K> keyParser) {
+        return parseKey((holder, data) -> keyParser.handle(data));
+    }
+
+    public @NotNull SourceMapBuilder<MAP, SOURCE, K, V> parseKey(@NotNull ValueHandler<String, K> keyParser) {
+        this.keyParser = keyParser;
+        return this;
+    }
+
+    public @NotNull SourceMapBuilder<MAP, SOURCE, K, V> serializeKey(@NotNull DataFunction<K, String> keySerializer) {
+        return serializeKey((holder, data) -> keySerializer.handle(data));
+    }
+
+    public @NotNull SourceMapBuilder<MAP, SOURCE, K, V> serializeKey(@NotNull ValueHandler<K, String> keySerializer) {
+        this.keySerializer = keySerializer;
+        return this;
+    }
+
+    public @NotNull ValueAdapter<K> buildKeyAdapter() {
+        return new ValueAdapter<>(this.keyType)
+                .parser((holder, type, data) -> {
+                    String source = holder.deserialize(String.class, data);
+                    return this.keyParser.handle(holder, source);
+                })
+                .serializer((holder, type, data) -> {
+                    String source = this.keySerializer.handle(holder, data);
+                    return holder.serialize(source);
+                });
+    }
+
+    @Override
+    public @NotNull ConfiguredMap<K, V> build() {
+        return new ConfiguredMap<>(buildManifest(), this.constructor, buildKeyAdapter(), this.buildAdapter());
+    }
+
+}

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

@@ -0,0 +1,48 @@
+package cc.carm.lib.configuration.builder.value;
+
+import cc.carm.lib.configuration.adapter.ValueType;
+import cc.carm.lib.configuration.builder.impl.AbstractSectionBuilder;
+import cc.carm.lib.configuration.function.ValueHandler;
+import cc.carm.lib.configuration.source.section.ConfigureSection;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Map;
+
+public class ConfigValueBuilder<V> {
+
+    protected final @NotNull ValueType<V> type;
+
+    public ConfigValueBuilder(@NotNull ValueType<V> type) {
+        this.type = type;
+    }
+
+    public @NotNull <S> SourceValueBuilder<S, V> from(@NotNull Class<S> clazz) {
+        return from(ValueType.of(clazz));
+    }
+
+    public @NotNull <S> SourceValueBuilder<S, V> from(@NotNull ValueType<S> sourceType) {
+        return from(sourceType, ValueHandler.required(type), ValueHandler.required(sourceType));
+    }
+
+    public @NotNull <S> SourceValueBuilder<S, V> from(@NotNull ValueType<S> sourceType,
+                                                      @NotNull ValueHandler<S, V> valueParser,
+                                                      @NotNull ValueHandler<V, S> valueSerializer) {
+        return new SourceValueBuilder<>(sourceType, this.type, valueParser, valueSerializer);
+    }
+
+    public @NotNull SourceValueBuilder<String, V> fromString() {
+        return from(ValueType.STRING, ValueHandler.required(type), ValueHandler.stringValue());
+    }
+
+    public @NotNull SectionValueBuilder<V> fromSection() {
+        return fromSection(ValueHandler.required(type), ValueHandler.required());
+    }
+
+    public @NotNull SectionValueBuilder<V> fromSection(
+            @NotNull ValueHandler<ConfigureSection, V> valueParser,
+            @NotNull ValueHandler<V, ? extends Map<String, Object>> valueSerializer
+    ) {
+        return new SectionValueBuilder<>(this.type, valueParser, valueSerializer);
+    }
+
+}

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

@@ -0,0 +1,30 @@
+package cc.carm.lib.configuration.builder.value;
+
+import cc.carm.lib.configuration.adapter.ValueType;
+import cc.carm.lib.configuration.builder.impl.AbstractSectionBuilder;
+import cc.carm.lib.configuration.function.ValueHandler;
+import cc.carm.lib.configuration.source.section.ConfigureSection;
+import cc.carm.lib.configuration.value.standard.ConfiguredValue;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Map;
+
+public class SectionValueBuilder<V> extends AbstractSectionBuilder<V, V, ConfiguredValue<V>, SectionValueBuilder<V>> {
+
+    public SectionValueBuilder(@NotNull ValueType<V> type,
+                               @NotNull ValueHandler<ConfigureSection, V> parser,
+                               @NotNull ValueHandler<V, ? extends Map<String, Object>> serializer) {
+        super(type, type, parser, serializer);
+    }
+
+    @Override
+    protected @NotNull SectionValueBuilder<V> self() {
+        return this;
+    }
+
+    @Override
+    public @NotNull ConfiguredValue<V> build() {
+        return ConfiguredValue.of(buildManifest(), buildAdapter());
+    }
+
+}

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

@@ -0,0 +1,27 @@
+package cc.carm.lib.configuration.builder.value;
+
+import cc.carm.lib.configuration.adapter.ValueType;
+import cc.carm.lib.configuration.builder.impl.AbstractSourceBuilder;
+import cc.carm.lib.configuration.function.ValueHandler;
+import cc.carm.lib.configuration.value.standard.ConfiguredValue;
+import org.jetbrains.annotations.NotNull;
+
+public class SourceValueBuilder<S, V> extends AbstractSourceBuilder<V, S, V, ConfiguredValue<V>, SourceValueBuilder<S, V>> {
+
+
+    public SourceValueBuilder(@NotNull ValueType<S> sourceType, @NotNull ValueType<V> valueType,
+                              @NotNull ValueHandler<S, V> parser, @NotNull ValueHandler<V, S> serializer) {
+        super(valueType, sourceType, valueType, parser, serializer);
+    }
+
+    @Override
+    protected @NotNull SourceValueBuilder<S, V> self() {
+        return this;
+    }
+
+    @Override
+    public @NotNull ConfiguredValue<V> build() {
+        return new ConfiguredValue<>(buildManifest(), buildAdapter());
+    }
+
+}

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

@@ -1,150 +0,0 @@
-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.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;
-
-public class ConfigInitializer<T extends ConfigurationProvider<?>> {
-
-    protected final @NotNull T provider;
-
-    public ConfigInitializer(@NotNull T provider) {
-        this.provider = provider;
-    }
-
-    public void initialize(@NotNull Class<? extends ConfigurationRoot> clazz, boolean saveDefaults) {
-        initializeClass(clazz, null, null, null, null, saveDefaults);
-    }
-
-    protected void initializeClass(@NotNull Class<?> clazz,
-                                   @Nullable String parentPath, @Nullable String fieldName,
-                                   @Nullable ConfigPath fieldPath, @Nullable ConfigComment filedComments,
-                                   boolean saveDefaults) {
-        if (!ConfigurationRoot.class.isAssignableFrom(clazz)) return;
-        String path = getClassPath(clazz, parentPath, fieldName, fieldPath);
-        if (path != null) setComments(path, getClassComments(clazz, filedComments));
-        for (Field field : clazz.getDeclaredFields()) {
-            initializeField(clazz, field, path, saveDefaults);
-        }
-    }
-
-
-    protected void initializeValue(@NotNull ConfigValue<?> value, @NotNull String path,
-                                   @NotNull String[] comments, boolean saveDefaults) {
-        value.initialize(provider, saveDefaults, path, comments);
-    }
-
-    private void initializeField(@NotNull Class<?> source, @NotNull Field field,
-                                 @Nullable String parent, boolean saveDefaults) {
-
-        try {
-            field.setAccessible(true);
-            Object object = field.get(source);
-            if (object instanceof ConfigValue<?>) {
-                String path = getFieldPath(field, parent);
-                String[] comments = readComments(field.getAnnotation(ConfigComment.class));
-                initializeValue((ConfigValue<?>) object, path, comments, saveDefaults);
-                setComments(path, comments);
-            } else if (object instanceof Class<?>) {
-                initializeClass(
-                        (Class<?>) object, parent, field.getName(),
-                        field.getAnnotation(ConfigPath.class),
-                        field.getAnnotation(ConfigComment.class),
-                        saveDefaults
-                );
-            }
-        } catch (IllegalAccessException ignored) {
-        }
-    }
-
-    protected void setComments(@NotNull String path, @Nullable ConfigComment filedComments) {
-        setComments(path, readComments(filedComments));
-    }
-
-    protected void setComments(@NotNull String path, @NotNull String[] comments) {
-        if (comments.length <= 0) return;
-        this.provider.setComments(path, comments);
-    }
-
-    protected static @NotNull String[] readComments(@Nullable ConfigComment filedComments) {
-        if (filedComments == null) return new String[0];
-        if (String.join("", filedComments.value()).length() <= 0) return new String[0];
-        return filedComments.value();
-    }
-
-    protected static @NotNull String[] getClassComments(@NotNull Class<?> clazz,
-                                                        @Nullable ConfigComment fieldAnnotation) {
-        String[] clazzComments = readComments(clazz.getAnnotation(ConfigComment.class));
-        if (clazzComments.length > 0) return clazzComments;
-        else return readComments(fieldAnnotation);
-    }
-
-    protected static @Nullable String getClassPath(@NotNull Class<?> clazz,
-                                                   @Nullable String parentPath,
-                                                   @Nullable String filedName,
-                                                   @Nullable ConfigPath fieldAnnotation) {
-        @NotNull String parent = parentPath != null ? parentPath + "." : "";
-        boolean fromRoot = false;
-
-        // 先获取 Class 对应的路径注解 其优先度最高。
-        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 +0,0 @@
-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,34 +0,0 @@
-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 {
-
-    /**
-     * 指定路径的值。
-     * 若不指定，则会通过 {@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/builder/AbstractConfigBuilder.java

@@ -1,47 +0,0 @@
-package cc.carm.lib.configuration.core.builder;
-
-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;
-
-public abstract class AbstractConfigBuilder<T, B extends AbstractConfigBuilder<T, B, P>, P extends ConfigurationProvider<?>> {
-
-    protected final Class<? super P> providerClass;
-
-    protected @Nullable P provider;
-    protected @Nullable String path;
-
-    protected @NotNull String[] comments = new String[0];
-    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 P provider) {
-        this.provider = provider;
-        return getThis();
-    }
-
-    public @NotNull B path(@Nullable String path) {
-        this.path = path;
-        return getThis();
-    }
-
-    public @NotNull B comments(@NotNull String... comments) {
-        this.comments = comments;
-        return getThis();
-    }
-
-    public @NotNull B defaults(@Nullable T defaultValue) {
-        this.defaultValue = defaultValue;
-        return getThis();
-    }
-
-
-}

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

@@ -1,46 +0,0 @@
-package cc.carm.lib.configuration.core.builder;
-
-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;
-
-public abstract class CommonConfigBuilder<T, B extends CommonConfigBuilder<T, B>>
-        extends AbstractConfigBuilder<T, B, ConfigurationProvider<?>> {
-
-    protected @Nullable ConfigurationProvider<?> provider;
-    protected @Nullable String path;
-
-    protected @NotNull String[] comments = new String[0];
-    protected @Nullable T defaultValue;
-
-    public CommonConfigBuilder() {
-        super(ConfigurationProvider.class);
-    }
-
-    protected abstract @NotNull B getThis();
-
-    public abstract @NotNull ConfigValue<?> build();
-
-    public @NotNull B from(@Nullable ConfigurationProvider<?> provider) {
-        this.provider = provider;
-        return getThis();
-    }
-
-    public @NotNull B path(@Nullable String path) {
-        this.path = path;
-        return getThis();
-    }
-
-    public @NotNull B comments(@NotNull String... comments) {
-        this.comments = comments;
-        return getThis();
-    }
-
-    public @NotNull B defaults(@Nullable T defaultValue) {
-        this.defaultValue = defaultValue;
-        return getThis();
-    }
-
-
-}

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

@@ -1,42 +0,0 @@
-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.value.ConfigValueBuilder;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.TreeMap;
-
-public class ConfigBuilder {
-
-    public <V> @NotNull ConfigValueBuilder<V> asValue(@NotNull Class<V> valueClass) {
-        return new ConfigValueBuilder<>(valueClass);
-    }
-
-    public <V> @NotNull ConfigListBuilder<V> asList(@NotNull Class<V> valueClass) {
-        return new ConfigListBuilder<>(valueClass);
-    }
-
-    public <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 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<LinkedHashMap<K, V>, K, V> asLinkedMap(@NotNull Class<K> keyClass,
-                                                                                          @NotNull Class<V> valueClass) {
-        return asMap(keyClass, valueClass);
-    }
-
-    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).supplier(TreeMap::new);
-    }
-
-}

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

@@ -1,46 +0,0 @@
-package cc.carm.lib.configuration.core.builder.list;
-
-import cc.carm.lib.configuration.core.function.ConfigDataFunction;
-import org.jetbrains.annotations.NotNull;
-
-public class ConfigListBuilder<V> {
-
-    protected final @NotNull Class<V> valueClass;
-
-    public ConfigListBuilder(@NotNull Class<V> valueClass) {
-        this.valueClass = valueClass;
-    }
-
-    public @NotNull <S> SourceListBuilder<S, V> from(@NotNull Class<S> sourceClass,
-                                                     @NotNull ConfigDataFunction<Object, S> sourceParser,
-                                                     @NotNull ConfigDataFunction<S, V> valueParser,
-                                                     @NotNull ConfigDataFunction<V, S> valueSerializer,
-                                                     @NotNull ConfigDataFunction<S, Object> sourceSerializer) {
-        return new SourceListBuilder<>(sourceClass, sourceParser, this.valueClass, valueParser, valueSerializer, sourceSerializer);
-    }
-
-
-    public @NotNull <S> SourceListBuilder<S, V> from(Class<S> sourceClass) {
-        return from(sourceClass,
-                ConfigDataFunction.required(), ConfigDataFunction.required(),
-                ConfigDataFunction.required(), ConfigDataFunction.required()
-        );
-    }
-
-    public @NotNull SourceListBuilder<Object, V> fromObject() {
-        return from(
-                Object.class, ConfigDataFunction.identity(),
-                ConfigDataFunction.castObject(valueClass),
-                ConfigDataFunction.toObject(), ConfigDataFunction.toObject()
-        );
-    }
-
-    public @NotNull SourceListBuilder<String, V> fromString() {
-        return from(
-                String.class, ConfigDataFunction.castToString(),
-                ConfigDataFunction.castFromString(this.valueClass),
-                ConfigDataFunction.castToString(), ConfigDataFunction.toObject()
-        );
-    }
-
-}

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

@@ -1,69 +0,0 @@
-package cc.carm.lib.configuration.core.builder.list;
-
-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.List;
-
-public class SourceListBuilder<S, V> extends CommonConfigBuilder<List<V>, SourceListBuilder<S, V>> {
-
-    protected final @NotNull Class<S> sourceClass;
-    protected @NotNull ConfigDataFunction<Object, S> sourceParser;
-
-    protected final @NotNull Class<V> valueClass;
-    protected @NotNull ConfigDataFunction<S, V> valueParser;
-
-    protected @NotNull ConfigDataFunction<V, S> valueSerializer;
-    protected @NotNull ConfigDataFunction<S, Object> sourceSerializer;
-
-    public SourceListBuilder(@NotNull Class<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) {
-        this.sourceClass = sourceClass;
-        this.sourceParser = sourceParser;
-        this.sourceSerializer = sourceSerializer;
-        this.valueClass = valueClass;
-        this.valueParser = valueParser;
-        this.valueSerializer = valueSerializer;
-    }
-
-    public @NotNull SourceListBuilder<S, V> parseSource(ConfigDataFunction<Object, S> sourceParser) {
-        this.sourceParser = sourceParser;
-        return this;
-    }
-
-    public @NotNull SourceListBuilder<S, V> parseValue(ConfigDataFunction<S, V> valueParser) {
-        this.valueParser = valueParser;
-        return this;
-    }
-
-    public @NotNull SourceListBuilder<S, V> serializeValue(ConfigDataFunction<V, S> serializer) {
-        this.valueSerializer = serializer;
-        return this;
-    }
-
-    public @NotNull SourceListBuilder<S, V> serializeSource(ConfigDataFunction<S, Object> serializer) {
-        this.sourceSerializer = serializer;
-        return this;
-    }
-
-    @Override
-    protected @NotNull SourceListBuilder<S, V> getThis() {
-        return this;
-    }
-
-    @Override
-    public @NotNull ConfiguredList<V> build() {
-        return new ConfiguredList<>(
-                this.provider, this.path, this.comments,
-                this.valueClass, this.defaultValue,
-                this.sourceParser.andThen(this.valueParser),
-                this.valueSerializer.andThen(sourceSerializer)
-        );
-    }
-
-
-}

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

@@ -1,60 +0,0 @@
-package cc.carm.lib.configuration.core.builder.map;
-
-import cc.carm.lib.configuration.core.function.ConfigDataFunction;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Map;
-import java.util.function.Supplier;
-
-public class ConfigMapBuilder<M extends Map<K, V>, K, V> {
-
-    protected final @NotNull Supplier<@NotNull M> supplier;
-
-    protected final @NotNull Class<K> keyClass;
-    protected final @NotNull Class<V> valueClass;
-
-    public ConfigMapBuilder(@NotNull Supplier<@NotNull M> supplier, @NotNull Class<K> keyClass, @NotNull Class<V> valueClass) {
-        this.supplier = supplier;
-        this.keyClass = keyClass;
-        this.valueClass = valueClass;
-    }
-
-    public <MAP extends Map<K, V>> ConfigMapBuilder<MAP, K, V> supplier(@NotNull Supplier<MAP> supplier) {
-        return new ConfigMapBuilder<>(supplier, keyClass, valueClass);
-    }
-
-    public <S> SourceMapBuilder<M, S, K, V> from(@NotNull Class<S> sourceClass,
-                                                 @NotNull ConfigDataFunction<S, V> valueParser,
-                                                 @NotNull ConfigDataFunction<V, S> valueSerializer) {
-        return new SourceMapBuilder<>(supplier,
-                keyClass, ConfigDataFunction.castFromString(this.keyClass), // #String -> key
-                sourceClass, ConfigDataFunction.castObject(sourceClass), // #Object -> source
-                valueClass, valueParser, // source -> value
-                ConfigDataFunction.castToString(), // key -> #String
-                valueSerializer/*value -> source*/,
-                ConfigDataFunction.toObject()/* source -> #Object */
-        );
-    }
-
-    public <S> SourceMapBuilder<M, S, K, V> from(@NotNull Class<S> sourceClass) {
-        return from(sourceClass, ConfigDataFunction.required(), ConfigDataFunction.required());
-    }
-
-    public SourceMapBuilder<M, String, K, V> fromString(@NotNull ConfigDataFunction<String, V> valueParser) {
-        return from(String.class, valueParser, ConfigDataFunction.castToString());
-    }
-
-    public SourceMapBuilder<M, String, K, V> fromString() {
-        return fromString(ConfigDataFunction.castFromString(this.valueClass));
-    }
-
-    public SourceMapBuilder<M, Object, K, V> fromObject(@NotNull ConfigDataFunction<Object, V> valueParser) {
-        return from(Object.class, valueParser, ConfigDataFunction.toObject());
-    }
-
-    public SourceMapBuilder<M, Object, K, V> fromObject() {
-        return fromObject(ConfigDataFunction.required());
-    }
-
-
-}

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

@@ -1,100 +0,0 @@
-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.value.type.ConfiguredMap;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Map;
-import java.util.function.Supplier;
-
-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;
-
-    protected final @NotNull Class<K> keyClass;
-    protected @NotNull ConfigDataFunction<String, K> keyParser;
-
-    protected final @NotNull Class<S> sourceClass;
-    protected @NotNull ConfigDataFunction<Object, S> sourceParser;
-
-    protected final @NotNull Class<V> valueClass;
-    protected @NotNull ConfigDataFunction<S, V> valueParser;
-
-    protected @NotNull ConfigDataFunction<K, String> keySerializer;
-    protected @NotNull ConfigDataFunction<V, S> valueSerializer;
-    protected @NotNull ConfigDataFunction<S, Object> sourceSerializer;
-
-    public SourceMapBuilder(@NotNull Supplier<@NotNull M> supplier,
-                            @NotNull Class<K> keyClass, @NotNull ConfigDataFunction<String, K> keyParser,
-                            @NotNull Class<S> sourceClass, @NotNull ConfigDataFunction<Object, S> sourceParser,
-                            @NotNull Class<V> valueClass, @NotNull ConfigDataFunction<S, V> valueParser,
-                            @NotNull ConfigDataFunction<K, String> keySerializer,
-                            @NotNull ConfigDataFunction<V, S> valueSerializer,
-                            @NotNull ConfigDataFunction<S, Object> sourceSerializer) {
-        this.supplier = supplier;
-        this.keyClass = keyClass;
-        this.keyParser = keyParser;
-        this.valueClass = valueClass;
-        this.valueParser = valueParser;
-        this.sourceClass = sourceClass;
-        this.sourceParser = sourceParser;
-        this.keySerializer = keySerializer;
-        this.valueSerializer = valueSerializer;
-        this.sourceSerializer = sourceSerializer;
-    }
-
-    public <MAP extends Map<K, V>> SourceMapBuilder<MAP, S, K, V> supplier(@NotNull Supplier<MAP> supplier) {
-        return new SourceMapBuilder<>(supplier,
-                keyClass, keyParser, sourceClass, sourceParser, valueClass, valueParser,
-                keySerializer, valueSerializer, sourceSerializer
-        );
-    }
-
-    public @NotNull SourceMapBuilder<M, S, K, V> parseKey(@NotNull ConfigDataFunction<String, K> parser) {
-        this.keyParser = parser;
-        return this;
-    }
-
-    public @NotNull SourceMapBuilder<M, S, K, V> parseSource(@NotNull ConfigDataFunction<Object, S> parser) {
-        this.sourceParser = parser;
-        return this;
-    }
-
-    public @NotNull SourceMapBuilder<M, S, K, V> parseValue(@NotNull ConfigDataFunction<S, V> parser) {
-        this.valueParser = parser;
-        return this;
-    }
-
-    public @NotNull SourceMapBuilder<M, S, K, V> serializeKey(@NotNull ConfigDataFunction<K, String> serializer) {
-        this.keySerializer = serializer;
-        return this;
-    }
-
-    public @NotNull SourceMapBuilder<M, S, K, V> serializeValue(@NotNull ConfigDataFunction<V, S> serializer) {
-        this.valueSerializer = serializer;
-        return this;
-    }
-
-    public @NotNull SourceMapBuilder<M, S, K, V> serializeSource(@NotNull ConfigDataFunction<S, Object> serializer) {
-        this.sourceSerializer = serializer;
-        return this;
-    }
-
-    @Override
-    protected @NotNull SourceMapBuilder<M, S, K, V> getThis() {
-        return this;
-    }
-
-    @Override
-    public @NotNull ConfiguredMap<K, V> build() {
-        return new ConfiguredMap<>(
-                this.provider, this.path, this.comments,
-                this.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

@@ -1,61 +0,0 @@
-package cc.carm.lib.configuration.core.builder.value;
-
-import cc.carm.lib.configuration.core.function.ConfigDataFunction;
-import cc.carm.lib.configuration.core.function.ConfigValueParser;
-import cc.carm.lib.configuration.core.source.ConfigurationWrapper;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Map;
-
-public class ConfigValueBuilder<V> {
-
-    protected final @NotNull Class<V> valueClass;
-
-    public ConfigValueBuilder(@NotNull Class<V> valueClass) {
-        this.valueClass = valueClass;
-    }
-
-    public @NotNull SectionValueBuilder<V> fromSection() {
-        return fromSection(ConfigValueParser.required(), ConfigDataFunction.required());
-    }
-
-    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);
-    }
-
-    public @NotNull <S> SourceValueBuilder<S, V> from(Class<S> sourceClass) {
-        return from(
-                sourceClass, ConfigDataFunction.required(), ConfigValueParser.required(),
-                ConfigDataFunction.required(), ConfigDataFunction.required()
-        );
-    }
-
-    public @NotNull <S> SourceValueBuilder<S, V> from(@NotNull Class<S> sourceClass,
-                                                      @NotNull ConfigDataFunction<Object, S> sourceParser,
-                                                      @NotNull ConfigValueParser<S, V> valueParser,
-                                                      @NotNull ConfigDataFunction<V, S> valueSerializer,
-                                                      @NotNull ConfigDataFunction<S, Object> sourceSerializer) {
-        return new SourceValueBuilder<>(
-                sourceClass, sourceParser, this.valueClass, valueParser,
-                valueSerializer, sourceSerializer
-        );
-    }
-
-    public @NotNull SourceValueBuilder<Object, V> fromObject() {
-        return from(
-                Object.class, ConfigDataFunction.identity(),
-                ConfigValueParser.castObject(valueClass),
-                ConfigDataFunction.toObject(), ConfigDataFunction.toObject()
-        );
-    }
-
-    public @NotNull SourceValueBuilder<String, V> fromString() {
-        return from(
-                String.class, ConfigDataFunction.castToString(),
-                ConfigValueParser.parseString(this.valueClass),
-                ConfigDataFunction.castToString(), ConfigDataFunction.toObject()
-        );
-    }
-
-}

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

@@ -1,54 +0,0 @@
-package cc.carm.lib.configuration.core.builder.value;
-
-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;
-import cc.carm.lib.configuration.core.value.type.ConfiguredSection;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Map;
-
-public class SectionValueBuilder<V>
-        extends CommonConfigBuilder<V, SectionValueBuilder<V>> {
-
-
-    protected final @NotNull Class<V> valueClass;
-
-    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 ConfigDataFunction<V, ? extends Map<String, Object>> serializer) {
-        this.valueClass = valueClass;
-        this.parser = parser;
-        this.serializer = serializer;
-    }
-
-
-    @Override
-    protected @NotNull SectionValueBuilder<V> getThis() {
-        return this;
-    }
-
-    public @NotNull SectionValueBuilder<V> parseValue(ConfigValueParser<ConfigurationWrapper, V> valueParser) {
-        this.parser = valueParser;
-        return this;
-    }
-
-    public @NotNull SectionValueBuilder<V> serializeValue(ConfigDataFunction<V, ? extends Map<String, Object>> serializer) {
-        this.serializer = serializer;
-        return this;
-    }
-
-    @Override
-    public @NotNull ConfiguredSection<V> build() {
-        return new ConfiguredSection<>(
-                this.provider, this.path, this.comments,
-                this.valueClass, this.defaultValue,
-                this.parser, this.serializer
-        );
-    }
-
-}

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

@@ -1,67 +0,0 @@
-package cc.carm.lib.configuration.core.builder.value;
-
-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 CommonConfigBuilder<V, SourceValueBuilder<S, V>> {
-
-    protected final @NotNull Class<S> sourceClass;
-    protected @NotNull ConfigDataFunction<Object, S> sourceParser;
-
-    protected final @NotNull Class<V> valueClass;
-    protected @NotNull ConfigValueParser<S, V> valueParser;
-
-    protected @NotNull ConfigDataFunction<S, Object> sourceSerializer;
-    protected @NotNull ConfigDataFunction<V, S> valueSerializer;
-
-    public SourceValueBuilder(@NotNull Class<S> sourceClass, @NotNull ConfigDataFunction<Object, S> sourceParser,
-                              @NotNull Class<V> valueClass, @NotNull ConfigValueParser<S, V> valueParser,
-                              @NotNull ConfigDataFunction<V, S> valueSerializer,
-                              @NotNull ConfigDataFunction<S, Object> sourceSerializer) {
-        this.sourceClass = sourceClass;
-        this.sourceParser = sourceParser;
-        this.valueClass = valueClass;
-        this.valueParser = valueParser;
-        this.sourceSerializer = sourceSerializer;
-        this.valueSerializer = valueSerializer;
-    }
-
-    @Override
-    protected @NotNull SourceValueBuilder<S, V> getThis() {
-        return this;
-    }
-
-    public @NotNull SourceValueBuilder<S, V> parseSource(@NotNull ConfigDataFunction<Object, S> sourceParser) {
-        this.sourceParser = sourceParser;
-        return this;
-    }
-
-    public @NotNull SourceValueBuilder<S, V> parseValue(@NotNull ConfigValueParser<S, V> valueParser) {
-        this.valueParser = valueParser;
-        return this;
-    }
-
-    public @NotNull SourceValueBuilder<S, V> serializeValue(@NotNull ConfigDataFunction<V, S> serializer) {
-        this.valueSerializer = serializer;
-        return this;
-    }
-
-    public @NotNull SourceValueBuilder<S, V> serializeSource(@NotNull ConfigDataFunction<S, Object> serializer) {
-        this.sourceSerializer = serializer;
-        return this;
-    }
-
-    @Override
-    public @NotNull ConfiguredValue<V> build() {
-        return new ConfiguredValue<>(
-                this.provider, this.path, this.comments,
-                this.valueClass, this.defaultValue,
-                this.valueParser.compose(this.sourceParser),
-                this.valueSerializer.andThen(sourceSerializer)
-        );
-    }
-
-}

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

@@ -1,68 +0,0 @@
-package cc.carm.lib.configuration.core.function;
-
-
-import org.jetbrains.annotations.Contract;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Objects;
-
-@FunctionalInterface
-public interface ConfigDataFunction<T, R> {
-
-    @NotNull R parse(@NotNull T data) throws Exception;
-
-    default <V> @NotNull ConfigDataFunction<T, V> andThen(@NotNull ConfigDataFunction<? super R, V> after) {
-        Objects.requireNonNull(after);
-        return ((data) -> after.parse(parse(data)));
-    }
-
-    @Contract(pure = true)
-    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) -> {
-            throw new IllegalArgumentException("Please specify the value parser.");
-        };
-    }
-
-    @Contract(pure = true)
-    static <T> @NotNull ConfigDataFunction<T, Object> toObject() {
-        return (input) -> input;
-    }
-
-    @Contract(pure = true)
-    static <V> @NotNull ConfigDataFunction<Object, V> castObject(Class<V> valueClass) {
-        return (input) -> {
-            if (valueClass.isInstance(input)) return valueClass.cast(input);
-            else throw new IllegalArgumentException("Cannot cast value to " + valueClass.getName());
-        };
-    }
-
-    @Contract(pure = true)
-    static <V> @NotNull ConfigDataFunction<String, V> castFromString(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 <T> @NotNull ConfigDataFunction<T, String> castToString() {
-        return (input) -> {
-            if (input instanceof String) return (String) input;
-            else return input.toString();
-        };
-    }
-
-
-}
-
-

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

@@ -1,44 +0,0 @@
-package cc.carm.lib.configuration.core.source;
-
-import cc.carm.lib.configuration.core.ConfigInitializer;
-import cc.carm.lib.configuration.core.ConfigurationRoot;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-public abstract class ConfigurationProvider<W extends ConfigurationWrapper> {
-
-    protected long updateTime;
-
-    public ConfigurationProvider() {
-        this.updateTime = System.currentTimeMillis();
-    }
-
-    public long getUpdateTime() {
-        return updateTime;
-    }
-
-    public boolean isExpired(long time) {
-        return this.updateTime > time;
-    }
-
-    public abstract @NotNull W getConfiguration();
-
-    public abstract void reload() throws Exception;
-
-    public abstract void save() throws Exception;
-
-    public abstract void setComments(@NotNull String path, @NotNull String... comments);
-
-    public abstract @Nullable String[] getComments(@NotNull String path);
-
-    public abstract @NotNull ConfigInitializer<? extends ConfigurationProvider<W>> getInitializer();
-
-    public void initialize(Class<? extends ConfigurationRoot> configClazz) {
-        initialize(configClazz, true);
-    }
-
-    public void initialize(Class<? extends ConfigurationRoot> configClazz, boolean saveDefaults) {
-        getInitializer().initialize(configClazz, saveDefaults);
-    }
-
-}

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

@@ -1,144 +0,0 @@
-package cc.carm.lib.configuration.core.source;
-
-import cc.carm.lib.configuration.core.function.ConfigValueParser;
-import org.jetbrains.annotations.Contract;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-interface ConfigurationReader {
-
-    ConfigurationWrapper getWrapper();
-
-    default boolean isBoolean(@NotNull String path) {
-        return getWrapper().isType(path, Boolean.class);
-    }
-
-    default boolean getBoolean(@NotNull String path) {
-        return getBoolean(path, false);
-    }
-
-    @Contract("_, !null -> !null")
-    default @Nullable Boolean getBoolean(@NotNull String path, @Nullable Boolean def) {
-        return getWrapper().get(path, def, ConfigValueParser.booleanValue());
-    }
-
-    default @Nullable Boolean isByte(@NotNull String path) {
-        return getWrapper().isType(path, Byte.class);
-    }
-
-
-    default @Nullable Byte getByte(@NotNull String path) {
-        return getByte(path, (byte) 0);
-    }
-
-    @Contract("_, !null -> !null")
-    default @Nullable Byte getByte(@NotNull String path, @Nullable Byte def) {
-        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);
-    }
-
-    @Contract("_, !null -> !null")
-    default @Nullable Short getShort(@NotNull String path, @Nullable Short def) {
-        return getWrapper().get(path, def, ConfigValueParser.shortValue());
-    }
-
-
-    default boolean isInt(@NotNull String path) {
-        return getWrapper().isType(path, Integer.class);
-    }
-
-
-    default @Nullable Integer getInt(@NotNull String path) {
-        return getInt(path, 0);
-    }
-
-    @Contract("_, !null -> !null")
-    default @Nullable Integer getInt(@NotNull String path, @Nullable Integer def) {
-        return getWrapper().get(path, def, ConfigValueParser.intValue());
-    }
-
-
-    default boolean isLong(@NotNull String path) {
-        return getWrapper().isType(path, Long.class);
-    }
-
-
-    default @Nullable Long getLong(@NotNull String path) {
-        return getLong(path, 0L);
-    }
-
-    @Contract("_, !null -> !null")
-    default @Nullable Long getLong(@NotNull String path, @Nullable Long def) {
-        return getWrapper().get(path, def, ConfigValueParser.longValue());
-    }
-
-
-    default boolean isFloat(@NotNull String path) {
-        return getWrapper().isType(path, Float.class);
-    }
-
-
-    default @Nullable Float getFloat(@NotNull String path) {
-        return getFloat(path, 0.0F);
-    }
-
-    @Contract("_, !null -> !null")
-    default @Nullable Float getFloat(@NotNull String path, @Nullable Float def) {
-        return getWrapper().get(path, def, ConfigValueParser.floatValue());
-    }
-
-
-    default boolean isDouble(@NotNull String path) {
-        return getWrapper().isType(path, Double.class);
-    }
-
-
-    default @Nullable Double getDouble(@NotNull String path) {
-        return getDouble(path, 0.0D);
-    }
-
-    @Contract("_, !null -> !null")
-    default @Nullable Double getDouble(@NotNull String path, @Nullable Double def) {
-        return getWrapper().get(path, def, ConfigValueParser.doubleValue());
-    }
-
-
-    default boolean isChar(@NotNull String path) {
-        return getWrapper().isType(path, Boolean.class);
-    }
-
-
-    default @Nullable Character getChar(@NotNull String path) {
-        return getChar(path, null);
-    }
-
-    @Contract("_, !null -> !null")
-    default @Nullable Character getChar(@NotNull String path, @Nullable Character def) {
-        return getWrapper().get(path, def, Character.class);
-    }
-
-
-    default boolean isString(@NotNull String path) {
-        return getWrapper().isType(path, String.class);
-    }
-
-    default @Nullable String getString(@NotNull String path) {
-        return getString(path, null);
-    }
-
-    @Contract("_, !null -> !null")
-    default @Nullable String getString(@NotNull String path, @Nullable String def) {
-        return getWrapper().get(path, def, String.class);
-    }
-
-
-}

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

@@ -1,71 +0,0 @@
-package cc.carm.lib.configuration.core.source;
-
-import cc.carm.lib.configuration.core.function.ConfigValueParser;
-import org.jetbrains.annotations.Contract;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-public interface ConfigurationWrapper extends ConfigurationReader {
-
-    @Override
-    default ConfigurationWrapper getWrapper() {
-        return this;
-    }
-
-    @NotNull
-    Set<String> getKeys(boolean deep);
-
-    @NotNull
-    Map<String, Object> getValues(boolean deep);
-
-    void set(@NotNull String path, @Nullable Object value);
-
-    boolean contains(@NotNull String path);
-
-    default <T> boolean isType(@NotNull String path, @NotNull Class<T> typeClass) {
-        return typeClass.isInstance(get(path));
-    }
-
-    @Nullable Object get(@NotNull String path);
-
-    default @Nullable <T> T get(@NotNull String path, @NotNull Class<T> clazz) {
-        return get(path, null, clazz);
-    }
-
-    default @Nullable <T> T get(@NotNull String path, @NotNull ConfigValueParser<Object, T> parser) {
-        return get(path, null, parser);
-    }
-
-    @Contract("_,!null,_->!null")
-    default @Nullable <T> T get(@NotNull String path, @Nullable T defaultValue, @NotNull Class<T> clazz) {
-        return get(path, defaultValue, ConfigValueParser.castObject(clazz));
-    }
-
-    @Contract("_,!null,_->!null")
-    default @Nullable <T> T get(@NotNull String path, @Nullable T defaultValue,
-                                @NotNull ConfigValueParser<Object, T> parser) {
-        Object value = get(path);
-        if (value != null) {
-            try {
-                return parser.parse(value, defaultValue);
-            } catch (Exception e) {
-                e.printStackTrace();
-            }
-        }
-        return defaultValue;
-    }
-
-    boolean isList(@NotNull String path);
-
-    @Nullable List<?> getList(@NotNull String path);
-
-    boolean isConfigurationSection(@NotNull String path);
-
-    @Nullable
-    ConfigurationWrapper getConfigurationSection(@NotNull String path);
-
-}

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

@@ -1,89 +0,0 @@
-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.net.URL;
-import java.net.URLConnection;
-import java.util.Objects;
-
-public abstract class FileConfigProvider<W extends ConfigurationWrapper> extends ConfigurationProvider<W> {
-
-    protected final @NotNull File file;
-
-    public FileConfigProvider(@NotNull File file) {
-        this.file = file;
-    }
-
-    public @NotNull File getFile() {
-        return file;
-    }
-
-    public void initializeFile(@Nullable String sourcePath) throws IOException {
-        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 (!this.file.createNewFile()) {
-            throw new IOException("Failed to create file " + file.getAbsolutePath());
-        }
-
-        if (sourcePath != null) {
-            try {
-                saveResource(sourcePath, true);
-            } catch (Exception ignored) {
-            }
-        }
-    }
-
-    public void saveResource(@NotNull String resourcePath, boolean replace)
-            throws NullPointerException, IOException, IllegalArgumentException {
-        Objects.requireNonNull(resourcePath, "ResourcePath cannot be null");
-        if (resourcePath.equals("")) 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");
-
-
-        int lastIndex = resourcePath.lastIndexOf('/');
-        File outDir = new File(file, resourcePath.substring(0, Math.max(lastIndex, 0)));
-
-        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);
-                }
-                out.close();
-                in.close();
-
-            } catch (IOException ex) {
-                ex.printStackTrace();
-            }
-        }
-    }
-
-    @Nullable
-    public InputStream getResource(@NotNull String filename) {
-        try {
-            URL url = this.getClass().getClassLoader().getResource(filename);
-            if (url == null) return null;
-            URLConnection connection = url.openConnection();
-            connection.setUseCaches(false);
-            return connection.getInputStream();
-        } catch (IOException ex) {
-            return null;
-        }
-    }
-}

core/src/main/java/cc/carm/lib/configuration/core/util/MapFactory.java

@@ -1,67 +0,0 @@
-package cc.carm.lib.configuration.core.util;
-
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.Map;
-import java.util.TreeMap;
-
-public class MapFactory<S extends Map<K, V>, K, V> {
-
-    private final S map;
-
-    protected MapFactory(S map) {
-        this.map = map;
-    }
-
-    public MapFactory<S, K, V> put(K key, V value) {
-        this.map.put(key, value);
-        return this;
-    }
-
-    public MapFactory<S, K, V> remove(K key) {
-        this.map.remove(key);
-        return this;
-    }
-
-    public MapFactory<S, K, V> clear() {
-        this.map.clear();
-        return this;
-    }
-
-    public S build() {
-        return get();
-    }
-
-    public S get() {
-        return map;
-    }
-
-    public static <K, V> MapFactory<HashMap<K, V>, K, V> hashMap() {
-        return new MapFactory<>(new HashMap<>());
-    }
-
-    public static <K, V> MapFactory<HashMap<K, V>, K, V> hashMap(K firstKey, V firstValue) {
-        return MapFactory.<K, V>hashMap().put(firstKey, firstValue);
-    }
-
-    public static <K, V> MapFactory<LinkedHashMap<K, V>, K, V> linkedMap() {
-        return of(new LinkedHashMap<>());
-    }
-
-    public static <K, V> MapFactory<LinkedHashMap<K, V>, K, V> linkedMap(K firstKey, V firstValue) {
-        return MapFactory.<K, V>linkedMap().put(firstKey, firstValue);
-    }
-
-    public static <K extends Comparable<K>, V> MapFactory<TreeMap<K, V>, K, V> treeMap() {
-        return of(new TreeMap<>());
-    }
-
-    public static <K extends Comparable<K>, V> MapFactory<TreeMap<K, V>, K, V> treeMap(K firstKey, V firstValue) {
-        return MapFactory.<K, V>treeMap().put(firstKey, firstValue);
-    }
-
-    public static <M extends Map<K, V>, K, V> MapFactory<M, K, V> of(M map) {
-        return new MapFactory<>(map);
-    }
-
-}

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

@@ -1,115 +0,0 @@
-package cc.carm.lib.configuration.core.value;
-
-import cc.carm.lib.configuration.core.builder.ConfigBuilder;
-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.Objects;
-import java.util.Optional;
-
-public abstract class ConfigValue<T> {
-
-    public static @NotNull ConfigBuilder builder() {
-        return new ConfigBuilder();
-    }
-
-    protected @Nullable ConfigurationProvider<?> provider;
-    protected @Nullable String configPath;
-    protected @NotNull String[] comments;
-
-    protected @Nullable T defaultValue;
-
-    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;
-    }
-
-    public void initialize(@NotNull ConfigurationProvider<?> provider, boolean saveDefault,
-                           @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;
-        if (saveDefault) setDefault();
-    }
-
-    public @Nullable T getDefaultValue() {
-        return defaultValue;
-    }
-
-    public void setDefaultValue(@Nullable T defaultValue) {
-        this.defaultValue = defaultValue;
-    }
-
-    public abstract @Nullable T get();
-
-    public @Nullable T getOrDefault() {
-        return Optional.ofNullable(get()).orElse(getDefaultValue());
-    }
-
-    public @NotNull T getNotNull() {
-        return Objects.requireNonNull(getOrDefault(), "Value(" + configPath + ") is null.");
-    }
-
-    public @NotNull Optional<@Nullable T> getOptional() {
-        return Optional.ofNullable(get());
-    }
-
-    public abstract void set(@Nullable T value);
-
-    public void setDefault() {
-        setDefault(false);
-    }
-
-    public void setDefault(boolean override) {
-        if (!override && getConfiguration().contains(getConfigPath())) return;
-        Optional.ofNullable(getDefaultValue()).ifPresent(this::set);
-    }
-
-    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;
-    }
-
-    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;
-    }
-
-}

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

@@ -1,41 +0,0 @@
-package cc.carm.lib.configuration.core.value.impl;
-
-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;
-
-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/type/ConfiguredList.java

@@ -1,80 +0,0 @@
-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.impl.CachedConfigValue;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class ConfiguredList<V> extends CachedConfigValue<List<V>> {
-
-    public static <V> @NotNull ConfigListBuilder<V> builder(@NotNull Class<V> valueClass) {
-        return builder().asList(valueClass);
-    }
-
-    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,
-                          @NotNull ConfigDataFunction<Object, V> parser,
-                          @NotNull ConfigDataFunction<V, Object> serializer) {
-        super(provider, sectionPath, comments, defaultValue);
-        this.valueClass = valueClass;
-        this.parser = parser;
-        this.serializer = serializer;
-    }
-
-    @Override
-    public @NotNull List<V> get() {
-
-
-
-        if (isExpired()) { // 已过时的数据，需要重新解析一次。
-            List<V> list = 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();
-                }
-            }
-
-            return updateCache(list);
-        } else if (getCachedValue() != null) return getCachedValue();
-        else if (getDefaultValue() != null) return getDefaultValue();
-        else return new ArrayList<>();
-    }
-
-    @Override
-    public void set(@Nullable List<V> value) {
-        updateCache(value);
-        if (value == null) setValue(null);
-        else {
-            List<Object> data = new ArrayList<>();
-            for (V val : value) {
-                if (val == null) continue;
-                try {
-                    data.add(serializer.parse(val));
-                } catch (Exception ex) {
-                    ex.printStackTrace();
-                }
-            }
-            setValue(data);
-        }
-    }
-
-
-}

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

@@ -1,124 +0,0 @@
-package cc.carm.lib.configuration.core.value.type;
-
-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.impl.CachedConfigValue;
-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 static <K, V> @NotNull ConfigMapBuilder<LinkedHashMap<K, V>, K, V> builder(@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<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,
-                         @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;
-    }
-
-    @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();
-    }
-
-    @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,80 +0,0 @@
-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.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> builder(@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 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,
-                             @NotNull ConfigDataFunction<V, ? extends Map<String, Object>> serializer) {
-        super(provider, sectionPath, comments, defaultValue);
-        this.valueClass = valueClass;
-        this.parser = parser;
-        this.serializer = serializer;
-    }
-
-    public @NotNull Class<V> getValueClass() {
-        return valueClass;
-    }
-
-    public @NotNull ConfigValueParser<ConfigurationWrapper, V> getParser() {
-        return parser;
-    }
-
-    public @NotNull ConfigDataFunction<V, ? extends Map<String, Object>> getSerializer() {
-        return serializer;
-    }
-
-    @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);
-    }
-
-    @Override
-    public void set(V value) {
-        updateCache(value);
-        if (value == null) setValue(null);
-        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/ConfiguredValue.java

@@ -1,82 +0,0 @@
-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.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> builder(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 builder(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,
-                           @NotNull ConfigValueParser<Object, V> parser,
-                           @NotNull ConfigDataFunction<V, Object> serializer) {
-
-        super(provider, sectionPath, comments, defaultValue);
-        this.valueClass = valueClass;
-        this.parser = parser;
-        this.serializer = serializer;
-    }
-
-    public @NotNull Class<V> getValueClass() {
-        return valueClass;
-    }
-
-    public @NotNull ConfigValueParser<Object, V> getParser() {
-        return parser;
-    }
-
-    @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);
-    }
-
-    @Override
-    public void set(V value) {
-        updateCache(value);
-        if (value == null) setValue(null);
-        else {
-            try {
-                setValue(serializer.parse(value));
-            } catch (Exception e) {
-                e.printStackTrace();
-            }
-        }
-    }
-
-}
-

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

@@ -0,0 +1,18 @@
+package cc.carm.lib.configuration.function;
+
+import org.jetbrains.annotations.NotNull;
+
+@FunctionalInterface
+public interface DataConsumer<T> {
+
+    void accept(@NotNull T data) throws Exception;
+
+    default DataConsumer<T> andThen(DataConsumer<? super T> after) {
+        return (T t) -> {
+            accept(t);
+            after.accept(t);
+        };
+    }
+
+
+}

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

@@ -1,87 +1,79 @@
-package cc.carm.lib.configuration.core.function;
+package cc.carm.lib.configuration.function;
 
 
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 
 import java.util.Objects;
 
 @FunctionalInterface
-public interface ConfigValueParser<T, R> {
+public interface DataFunction<T, R> {
 
-    @Nullable R parse(@NotNull T data, @Nullable R defaultValue) throws Exception;
+    @NotNull R handle(@NotNull T data) throws Exception;
 
-    default <V> ConfigValueParser<T, V> andThen(@NotNull ConfigValueParser<R, V> after) {
+    default <V> @NotNull DataFunction<T, V> andThen(@NotNull DataFunction<? super R, V> after) {
         Objects.requireNonNull(after);
-        return ((data, defaultValue) -> {
-            R result = parse(data, null);
-            if (result == null) return defaultValue;
-            else return after.parse(result, defaultValue);
-        });
-    }
-
-    default <V> ConfigValueParser<V, R> compose(@NotNull ConfigDataFunction<? super V, ? extends T> before) {
-        Objects.requireNonNull(before);
-        return ((data, defaultValue) -> {
-            T result = before.parse(data);
-            return parse(result, defaultValue);
-        });
-    }
-
-
-    @Contract(pure = true)
-    static <T> @NotNull ConfigValueParser<T, T> identity() {
-        return (input, defaultValue) -> input;
+        return data -> after.handle(handle(data));
     }
 
     @Contract(pure = true)
-    static <T> @NotNull ConfigValueParser<T, Object> toObject() {
-        return (input, defaultValue) -> input;
+    static <T> @NotNull DataFunction<T, T> identity() {
+        return input -> input;
     }
 
     @Contract(pure = true)
-    static <T, V> @NotNull ConfigValueParser<T, V> required() {
-        return (input, defaultValue) -> {
+    static <T> @NotNull DataFunction<T, T> identity(Class<T> type) {
+        return input -> input;
+    }
+
+    @Contract(pure = true)
+    static <T, V> @NotNull DataFunction<T, V> required() {
+        return input -> {
             throw new IllegalArgumentException("Please specify the value parser.");
         };
     }
 
     @Contract(pure = true)
-    static <V> @NotNull ConfigValueParser<Object, V> castObject(Class<V> valueClass) {
-        return (input, defaultValue) -> {
+    static <T> @NotNull DataFunction<T, Object> toObject() {
+        return input -> input;
+    }
+
+    @Contract(pure = true)
+    static <V> @NotNull DataFunction<Object, V> castObject(Class<V> valueClass) {
+        return input -> {
             if (valueClass.isInstance(input)) return valueClass.cast(input);
             else throw new IllegalArgumentException("Cannot cast value to " + valueClass.getName());
         };
     }
 
     @Contract(pure = true)
-    static <V> @NotNull ConfigValueParser<String, V> parseString(Class<V> valueClass) {
-        return (input, defaultValue) -> {
+    static <V> @NotNull DataFunction<String, V> castFromString(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 ConfigValueParser<Object, String> castToString() {
-        return (input, defaultValue) -> {
+    static <T> @NotNull DataFunction<T, String> castToString() {
+        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 @NotNull <T> ConfigValueParser<T, String> castToString(Class<T> clazz) {
-        return (input, defaultValue) -> {
-            if (input instanceof String) return (String) input;
-            else return input.toString();
+    static <V> @NotNull DataFunction<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 ConfigValueParser<Object, Integer> intValue() {
-        return (input, defaultValue) -> {
+    static @NotNull DataFunction<Object, Integer> intValue() {
+        return input -> {
             if (input instanceof Integer) {
                 return (Integer) input;
             } else if (input instanceof Number) {
@@ -91,8 +83,8 @@ public interface ConfigValueParser<T, R> {
     }
 
     @Contract(pure = true)
-    static @NotNull ConfigValueParser<Object, Short> shortValue() {
-        return (input, defaultValue) -> {
+    static @NotNull DataFunction<Object, Short> shortValue() {
+        return input -> {
             if (input instanceof Short) {
                 return (Short) input;
             } else if (input instanceof Number) {
@@ -102,8 +94,8 @@ public interface ConfigValueParser<T, R> {
     }
 
     @Contract(pure = true)
-    static @NotNull ConfigValueParser<Object, Double> doubleValue() {
-        return (input, defaultValue) -> {
+    static @NotNull DataFunction<Object, Double> doubleValue() {
+        return input -> {
             if (input instanceof Double) {
                 return (Double) input;
             } else if (input instanceof Number) {
@@ -113,8 +105,8 @@ public interface ConfigValueParser<T, R> {
     }
 
     @Contract(pure = true)
-    static @NotNull ConfigValueParser<Object, Byte> byteValue() {
-        return (input, defaultValue) -> {
+    static @NotNull DataFunction<Object, Byte> byteValue() {
+        return input -> {
             if (input instanceof Byte) {
                 return (Byte) input;
             } else if (input instanceof Number) {
@@ -124,8 +116,8 @@ public interface ConfigValueParser<T, R> {
     }
 
     @Contract(pure = true)
-    static @NotNull ConfigValueParser<Object, Float> floatValue() {
-        return (input, defaultValue) -> {
+    static @NotNull DataFunction<Object, Float> floatValue() {
+        return input -> {
             if (input instanceof Float) {
                 return (Float) input;
             } else if (input instanceof Number) {
@@ -135,8 +127,8 @@ public interface ConfigValueParser<T, R> {
     }
 
     @Contract(pure = true)
-    static @NotNull ConfigValueParser<Object, Long> longValue() {
-        return (input, defaultValue) -> {
+    static @NotNull DataFunction<Object, Long> longValue() {
+        return input -> {
             if (input instanceof Long) {
                 return (Long) input;
             } else if (input instanceof Number) {
@@ -146,19 +138,20 @@ public interface ConfigValueParser<T, R> {
     }
 
     @Contract(pure = true)
-    static @NotNull ConfigValueParser<Object, Boolean> booleanValue() {
-        return (input, defaultValue) -> {
+    static @NotNull DataFunction<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;
+                return (Integer) input == 1;
             } else throw new IllegalArgumentException("Cannot cast value to " + Boolean.class.getName());
         };
     }
 
+
 }
 
 

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

@@ -0,0 +1,79 @@
+package cc.carm.lib.configuration.function;
+
+
+import cc.carm.lib.configuration.adapter.ValueType;
+import cc.carm.lib.configuration.source.ConfigurationHolder;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+
+@FunctionalInterface
+public interface ValueHandler<T, R> {
+
+    @Nullable R handle(@NotNull ConfigurationHolder<?> holder, @NotNull T data) throws Exception;
+
+    default <V> ValueHandler<T, V> andThen(@NotNull ValueHandler<R, V> after) {
+        Objects.requireNonNull(after);
+        return ((provider, data) -> {
+            R result = handle(provider, data);
+            if (result == null) return null;
+            else return after.handle(provider, result);
+        });
+    }
+
+    default <V> ValueHandler<V, R> compose(@NotNull ValueHandler<? super V, ? extends T> before) {
+        Objects.requireNonNull(before);
+        return ((provider, data) -> {
+            T result = before.handle(provider, data);
+            if (result == null) return null;
+            return handle(provider, result);
+        });
+    }
+
+    default <V> ValueHandler<V, R> compose(@NotNull DataFunction<? super V, ? extends T> before) {
+        Objects.requireNonNull(before);
+        return ((provider, data) -> {
+            T result = before.handle(data);
+            return handle(provider, result);
+        });
+    }
+
+    @Contract(pure = true)
+    static <T> @NotNull ValueHandler<T, T> identity() {
+        return (provider, input) -> input;
+    }
+
+    @Contract(pure = true)
+    static <T> @NotNull ValueHandler<T, Object> toObject() {
+        return ConfigurationHolder::serialize;
+    }
+
+    @Contract(pure = true)
+    static <T> @NotNull ValueHandler<T, String> stringValue() {
+        return (provider, input) -> String.valueOf(input);
+    }
+
+    @Contract(pure = true)
+    static <O, T> @NotNull ValueHandler<O, T> deserialize(ValueType<T> to) {
+        return (provider, input) -> provider.deserialize(to, input);
+    }
+
+    @Contract(pure = true)
+    static <T, V> @NotNull ValueHandler<T, V> required() {
+        return (provider, input) -> {
+            throw new IllegalArgumentException("Please specify the value parser.");
+        };
+    }
+
+    @Contract(pure = true)
+    static <T, V> @NotNull ValueHandler<T, V> required(ValueType<V> type) {
+        return (provider, input) -> {
+            if (type.isInstance(input)) return type.cast(input); // Simple cast
+            throw new IllegalArgumentException("Please specify the value parser.");
+        };
+    }
+}
+
+

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

@@ -0,0 +1,156 @@
+package cc.carm.lib.configuration.source;
+
+import cc.carm.lib.configuration.adapter.*;
+import cc.carm.lib.configuration.adapter.strandard.StandardAdapters;
+import cc.carm.lib.configuration.function.DataFunction;
+import cc.carm.lib.configuration.source.loader.ConfigurationInitializer;
+import cc.carm.lib.configuration.source.loader.PathGenerator;
+import cc.carm.lib.configuration.source.meta.ConfigurationMetaHolder;
+import cc.carm.lib.configuration.source.meta.ConfigurationMetadata;
+import cc.carm.lib.configuration.source.option.ConfigurationOption;
+import cc.carm.lib.configuration.source.option.ConfigurationOptionHolder;
+import cc.carm.lib.configuration.source.section.ConfigureSource;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.lang.annotation.Annotation;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+public abstract class ConfigurationFactory<
+        SOURCE extends ConfigureSource<?, ?, SOURCE>,
+        HOLDER extends ConfigurationHolder<SOURCE>,
+        SELF
+        > {
+
+    protected ValueAdapterRegistry adapters = new ValueAdapterRegistry();
+    protected ConfigurationOptionHolder options = new ConfigurationOptionHolder();
+    protected @NotNull Map<String, ConfigurationMetaHolder> metadata = new HashMap<>();
+    protected ConfigurationInitializer initializer = new ConfigurationInitializer();
+
+    public ConfigurationFactory() {
+        this.adapters.register(StandardAdapters.PRIMITIVES);
+        this.adapters.register(StandardAdapters.SECTIONS);
+        this.adapters.register(StandardAdapters.ENUMS);
+    }
+
+    protected abstract SELF self();
+
+    public SELF adapters(ValueAdapterRegistry adapters) {
+        this.adapters = adapters;
+        return self();
+    }
+
+    public SELF adapter(Consumer<ValueAdapterRegistry> adapterRegistryConsumer) {
+        adapterRegistryConsumer.accept(adapters);
+        return self();
+    }
+
+    public <T> SELF adapter(@NotNull ValueAdapter<T> adapter) {
+        return adapter(a -> a.register(adapter));
+    }
+
+    public <T> SELF adapter(@NotNull ValueType<T> type, @NotNull ValueSerializer<T> serializer) {
+        return adapter(a -> a.register(type, serializer));
+    }
+
+    public <T> SELF adapter(@NotNull ValueType<T> type, @NotNull ValueParser<T> parser) {
+        return adapter(a -> a.register(type, parser));
+    }
+
+    public <FROM, TO> SELF adapter(@NotNull Class<FROM> from, @NotNull Class<TO> to,
+                                   @NotNull DataFunction<FROM, TO> parser,
+                                   @NotNull DataFunction<TO, FROM> serializer) {
+        return adapter(a -> a.register(from, to, parser, serializer));
+    }
+
+    public <FROM, TO> SELF adapter(@NotNull ValueType<FROM> from, @NotNull ValueType<TO> to,
+                                   @NotNull DataFunction<FROM, TO> parser,
+                                   @NotNull DataFunction<TO, FROM> serializer) {
+        return adapter(a -> a.register(from, to, parser, serializer));
+    }
+
+    public <T> SELF adapter(@NotNull ValueType<T> type, @NotNull ValueSerializer<T> serializer, @NotNull ValueParser<T> parser) {
+        return adapter(a -> a.register(type, serializer, parser));
+    }
+
+    public <T> SELF adapter(@NotNull Class<T> type, @NotNull ValueSerializer<T> serializer, @NotNull ValueParser<T> parser) {
+        return adapter(ValueType.of(type), serializer, parser);
+    }
+
+    public SELF options(ConfigurationOptionHolder options) {
+        this.options = options;
+        return self();
+    }
+
+    public SELF option(Consumer<ConfigurationOptionHolder> modifier) {
+        modifier.accept(options);
+        return self();
+    }
+
+    public <O> SELF option(ConfigurationOption<O> type, O value) {
+        return option(o -> o.set(type, value));
+    }
+
+    public <O> SELF option(ConfigurationOption<O> type, Supplier<O> value) {
+        return option(type, value.get());
+    }
+
+    public <O> SELF option(ConfigurationOption<O> type, Consumer<O> modifier) {
+        return option(holder -> {
+            O current = holder.get(type);
+            modifier.accept(current);
+            holder.set(type, current);
+        });
+    }
+
+    public SELF metadata(@NotNull Map<String, ConfigurationMetaHolder> metadata) {
+        this.metadata = metadata;
+        return self();
+    }
+
+    public SELF metadata(@NotNull Consumer<Map<String, ConfigurationMetaHolder>> handler) {
+        handler.accept(this.metadata);
+        return self();
+    }
+
+    public SELF metadata(@Nullable String path, @NotNull ConfigurationMetaHolder meta) {
+        return metadata(m -> m.put(path, meta));
+    }
+
+    public SELF metadata(@Nullable String path, @NotNull Consumer<ConfigurationMetaHolder> handler) {
+        return metadata(map -> {
+            ConfigurationMetaHolder meta = map.computeIfAbsent(path, k -> new ConfigurationMetaHolder());
+            handler.accept(meta);
+        });
+    }
+
+
+    public SELF initializer(ConfigurationInitializer initializer) {
+        this.initializer = initializer;
+        return self();
+    }
+
+    public SELF initializer(Consumer<ConfigurationInitializer> initializerConsumer) {
+        initializerConsumer.accept(initializer);
+        return self();
+    }
+
+    public SELF pathGenerator(PathGenerator generator) {
+        return initializer(loader -> {
+            loader.pathGenerator(generator);
+        });
+    }
+
+    public <M, A extends Annotation> SELF metaAnnotation(@NotNull Class<A> annotation,
+                                                         @NotNull ConfigurationMetadata<M> metadata,
+                                                         @NotNull Function<A, M> extractor) {
+        return initializer(loader -> loader.registerAnnotation(annotation, metadata, extractor));
+    }
+
+    public abstract @NotNull HOLDER build();
+
+}

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

@@ -0,0 +1,115 @@
+package cc.carm.lib.configuration.source;
+
+import cc.carm.lib.configuration.Configuration;
+import cc.carm.lib.configuration.adapter.ValueAdapterRegistry;
+import cc.carm.lib.configuration.adapter.ValueType;
+import cc.carm.lib.configuration.source.loader.ConfigurationInitializer;
+import cc.carm.lib.configuration.source.meta.ConfigurationMetaHolder;
+import cc.carm.lib.configuration.source.meta.ConfigurationMetadata;
+import cc.carm.lib.configuration.source.option.ConfigurationOptionHolder;
+import cc.carm.lib.configuration.source.section.ConfigureSource;
+import cc.carm.lib.configuration.value.ValueManifest;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.UnmodifiableView;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public abstract class ConfigurationHolder<SOURCE extends ConfigureSource<?, ?, SOURCE>> {
+
+    protected final @NotNull ValueAdapterRegistry adapters;
+    protected final @NotNull ConfigurationOptionHolder options;
+    protected final @NotNull Map<String, ConfigurationMetaHolder> metadata;
+
+    protected final @NotNull ConfigurationInitializer initializer;
+
+    public ConfigurationHolder(@NotNull ValueAdapterRegistry adapters,
+                               @NotNull ConfigurationOptionHolder options,
+                               @NotNull Map<String, ConfigurationMetaHolder> metadata,
+                               @NotNull ConfigurationInitializer initializer) {
+        this.initializer = initializer;
+        this.adapters = adapters;
+        this.options = options;
+        this.metadata = metadata;
+    }
+
+    public abstract @NotNull SOURCE config();
+
+    public void reload() throws Exception {
+        config().reload();
+    }
+
+    public void save() throws Exception {
+        config().save();
+    }
+
+    public ConfigurationOptionHolder options() {
+        return options;
+    }
+
+    public @NotNull Map<String, ConfigurationMetaHolder> metadata() {
+        return this.metadata;
+    }
+
+    public @NotNull ConfigurationMetaHolder metadata(@Nullable String path) {
+        return metadata().computeIfAbsent(path, k -> new ConfigurationMetaHolder());
+    }
+
+    @NotNull
+    @UnmodifiableView
+    public <M> Map<String, M> extractMetadata(@NotNull ConfigurationMetadata<M> type) {
+        Map<String, M> metas = new LinkedHashMap<>();
+        for (Map.Entry<String, ConfigurationMetaHolder> entry : this.metadata.entrySet()) {
+            M data = entry.getValue().get(type);
+            if (data != null) metas.put(entry.getKey(), data);
+        }
+        return Collections.unmodifiableMap(metas);
+    }
+
+    public ValueAdapterRegistry adapters() {
+        return this.adapters;
+    }
+
+    public ConfigurationInitializer initializer() {
+        return initializer;
+    }
+
+    @Contract("_,null -> null")
+    public <T> T deserialize(@NotNull Class<T> type, @Nullable Object source) throws Exception {
+        return adapters().deserialize(this, type, source);
+    }
+
+    @Contract("_,null -> null")
+    public <T> T deserialize(@NotNull ValueType<T> type, @Nullable Object source) throws Exception {
+        return adapters().deserialize(this, type, source);
+    }
+
+    @Contract("null -> null")
+    public <T> Object serialize(@Nullable T value) throws Exception {
+        return adapters().serialize(this, value);
+    }
+
+    public void initialize(Class<? extends Configuration> configClass) {
+        try {
+            initializer.initialize(this, configClass);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void initialize(@NotNull Configuration config) {
+        try {
+            initializer.initialize(this, config);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void initialize(@NotNull ValueManifest<?> value) {
+        value.holder(this);
+    }
+
+}

core/src/main/java/cc/carm/lib/configuration/source/loader/ConfigInitializeHandler.java

@@ -0,0 +1,32 @@
+package cc.carm.lib.configuration.source.loader;
+
+import cc.carm.lib.configuration.source.ConfigurationHolder;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@FunctionalInterface
+public interface ConfigInitializeHandler<T> {
+
+    static <T> ConfigInitializeHandler<T> start() {
+        return (provider, path, value) -> {
+        };
+    }
+
+    void whenInitialize(@NotNull ConfigurationHolder<?> holder, @Nullable String path, @NotNull T value) throws Exception;
+
+    default ConfigInitializeHandler<T> andThen(ConfigInitializeHandler<T> after) {
+        return (provider, path, value) -> {
+            whenInitialize(provider, path, value);
+            after.whenInitialize(provider, path, value);
+        };
+    }
+
+    default ConfigInitializeHandler<T> compose(ConfigInitializeHandler<T> before) {
+        return (provider, path, value) -> {
+            before.whenInitialize(provider, path, value);
+            whenInitialize(provider, path, value);
+        };
+    }
+
+
+}

core/src/main/java/cc/carm/lib/configuration/source/loader/ConfigurationInitializer.java

@@ -0,0 +1,195 @@
+package cc.carm.lib.configuration.source.loader;
+
+import cc.carm.lib.configuration.Configuration;
+import cc.carm.lib.configuration.source.ConfigurationHolder;
+import cc.carm.lib.configuration.source.meta.ConfigurationMetadata;
+import cc.carm.lib.configuration.source.option.StandardOptions;
+import cc.carm.lib.configuration.value.ConfigValue;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.util.Arrays;
+import java.util.function.Function;
+
+/**
+ * Configuration initializer,
+ * used to initialize {@link ConfigValue}s from {@link Configuration} classes.
+ */
+public class ConfigurationInitializer {
+
+    protected @NotNull PathGenerator pathGenerator;
+    protected @NotNull ConfigInitializeHandler<Field> fieldInitializer;
+    protected @NotNull ConfigInitializeHandler<Class<? extends Configuration>> classInitializer;
+
+    public ConfigurationInitializer() {
+        this(PathGenerator.of(), ConfigInitializeHandler.start(), ConfigInitializeHandler.start());
+    }
+
+    public ConfigurationInitializer(@NotNull PathGenerator pathGenerator,
+                                    @NotNull ConfigInitializeHandler<Field> fieldInitializer,
+                                    @NotNull ConfigInitializeHandler<Class<? extends Configuration>> classInitializer) {
+        this.pathGenerator = pathGenerator;
+        this.fieldInitializer = fieldInitializer;
+        this.classInitializer = classInitializer;
+    }
+
+    public void pathGenerator(@NotNull PathGenerator pathGenerator) {
+        this.pathGenerator = pathGenerator;
+    }
+
+    public @NotNull PathGenerator pathGenerator() {
+        return pathGenerator;
+    }
+
+    public ConfigInitializeHandler<Field> fieldInitializer() {
+        return fieldInitializer;
+    }
+
+    public void fieldInitializer(@NotNull ConfigInitializeHandler<Field> fieldInitializer) {
+        this.fieldInitializer = fieldInitializer;
+    }
+
+    public ConfigInitializeHandler<Class<? extends Configuration>> classInitializer() {
+        return classInitializer;
+    }
+
+    public void classInitializer(@NotNull ConfigInitializeHandler<Class<? extends Configuration>> classInitializer) {
+        this.classInitializer = classInitializer;
+    }
+
+    public void appendFieldInitializer(@NotNull ConfigInitializeHandler<Field> fieldInitializer) {
+        this.fieldInitializer = this.fieldInitializer.andThen(fieldInitializer);
+    }
+
+    public void appendClassInitializer(@NotNull ConfigInitializeHandler<Class<? extends Configuration>> classInitializer) {
+        this.classInitializer = this.classInitializer.andThen(classInitializer);
+    }
+
+    public <T, A extends Annotation> void registerClassAnnotation(@NotNull Class<A> annotation,
+                                                                  @NotNull ConfigurationMetadata<T> metadata,
+                                                                  @NotNull Function<A, T> extractor) {
+        appendClassInitializer((holder, path, clazz) -> {
+            A data = clazz.getAnnotation(annotation);
+            if (data == null) return;
+            holder.metadata(path).setIfAbsent(metadata, extractor.apply(data));
+        });
+    }
+
+    public <T, A extends Annotation> void registerFieldAnnotation(@NotNull Class<A> annotation,
+                                                                  @NotNull ConfigurationMetadata<T> metadata,
+                                                                  @NotNull Function<A, T> extractor) {
+        appendFieldInitializer((holder, path, field) -> {
+            A data = field.getAnnotation(annotation);
+            if (data == null) return;
+            holder.metadata(path).setIfAbsent(metadata, extractor.apply(data));
+        });
+    }
+
+    public <T, A extends Annotation> void registerAnnotation(@NotNull Class<A> annotation,
+                                                             @NotNull ConfigurationMetadata<T> metadata,
+                                                             @NotNull Function<A, T> extractor) {
+        registerClassAnnotation(annotation, metadata, extractor);
+        registerFieldAnnotation(annotation, metadata, extractor);
+    }
+
+
+    public @Nullable String getFieldPath(@NotNull ConfigurationHolder<?> holder, @Nullable String parentPath, @NotNull Field field) {
+        return pathGenerator.getFieldPath(holder, parentPath, field);
+    }
+
+    public @Nullable String getClassPath(@NotNull ConfigurationHolder<?> holder, @Nullable String parentPath,
+                                         @NotNull Class<?> clazz, @Nullable Field clazzField) {
+        return pathGenerator.getClassPath(holder, parentPath, clazz, clazzField);
+    }
+
+    public void initialize(@NotNull ConfigurationHolder<?> holder,
+                           @NotNull Configuration config) throws Exception {
+        initializeInstance(holder, config, null, null);
+        if (holder.options().get(StandardOptions.SET_DEFAULTS)) holder.save();
+    }
+
+    public void initialize(@NotNull ConfigurationHolder<?> holder,
+                           @NotNull Class<? extends Configuration> clazz) throws Exception {
+        initializeStaticClass(holder, clazz, null, null);
+        if (holder.options().get(StandardOptions.SET_DEFAULTS)) holder.save();
+    }
+
+
+    // 针对实例类的初始化方法
+    protected void initializeInstance(@NotNull ConfigurationHolder<?> holder, @NotNull Configuration root,
+                                      @Nullable String parentPath, @Nullable Field configField) {
+        String path = getClassPath(holder, parentPath, root.getClass(), configField);
+        try {
+            this.classInitializer.whenInitialize(holder, path, root.getClass());
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        Arrays.stream(root.getClass().getDeclaredFields()).forEach(field -> initializeField(holder, root, field, path));
+    }
+
+    // 针对静态类的初始化方法
+    @SuppressWarnings("unchecked")
+    protected void initializeStaticClass(@NotNull ConfigurationHolder<?> holder,
+                                         @NotNull Class<?> clazz,
+                                         @Nullable String parentPath, @Nullable Field configField) {
+        if (!Configuration.class.isAssignableFrom(clazz)) return; // Only Configuration class can be initialized.
+
+        String path = getClassPath(holder, parentPath, clazz, configField);
+
+        try {
+            this.classInitializer.whenInitialize(holder, path, (Class<? extends Configuration>) clazz);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        for (Field field : clazz.getDeclaredFields()) {
+            initializeField(holder, clazz, field, path);
+        }
+
+        if (holder.options().get(StandardOptions.LOAD_SUB_CLASSES)) {
+            Class<?>[] classes = clazz.getDeclaredClasses();
+            for (int i = classes.length - 1; i >= 0; i--) {   // 逆向加载，保持顺序。
+                initializeStaticClass(holder, classes[i], path, null);
+            }
+        }
+    }
+
+    protected void initializeField(@NotNull ConfigurationHolder<?> holder,
+                                   @NotNull Object source, @NotNull Field field, @Nullable String parent) {
+        try {
+            field.setAccessible(true);
+            Object object = field.get(source);
+//
+            if (object instanceof ConfigValue<?>) {
+                // 目标是 ConfigValue 实例，进行具体的初始化注入
+                ConfigValue<?> value = (ConfigValue<?>) object;
+                String path = getFieldPath(holder, parent, field);
+                if (path == null) return;
+                value.initialize(holder, path);
+                try {
+                    this.fieldInitializer.whenInitialize(holder, path, field);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                if (holder.options().get(StandardOptions.SET_DEFAULTS)) {
+                    value.setDefault();
+                }
+            } else if (source instanceof Configuration && object instanceof Configuration) {
+                // 当且仅当 源字段与字段 均为Configuration实例时，才对目标字段进行下一步初始化加载。
+                initializeInstance(holder, (Configuration) object, parent, field);
+            } else if (source instanceof Class<?> && object instanceof Class<?>) {
+                // 当且仅当 源字段与字段 均为静态类时，才对目标字段进行下一步初始化加载。
+                initializeStaticClass(holder, (Class<?>) object, parent, field);
+            }
+
+            // 以上判断实现以下规范：
+            // - 实例类中仅加载 ConfigValue实例 与 Configuration实例
+            // - 静态类中仅加载 静态ConfigValue实例 与 静态Configuration类
+
+        } catch (IllegalAccessException ignored) {
+        }
+    }
+
+}

core/src/main/java/cc/carm/lib/configuration/source/loader/PathGenerator.java

@@ -0,0 +1,115 @@
+package cc.carm.lib.configuration.source.loader;
+
+import cc.carm.lib.configuration.annotation.ConfigPath;
+import cc.carm.lib.configuration.source.ConfigurationHolder;
+import cc.carm.lib.configuration.source.option.StandardOptions;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.lang.reflect.Field;
+import java.util.function.UnaryOperator;
+
+public class PathGenerator {
+
+    public static PathGenerator of() {
+        return of(PathGenerator::covertPathName);
+    }
+
+    public static PathGenerator of(UnaryOperator<String> pathConverter) {
+        return new PathGenerator(pathConverter);
+    }
+
+    protected UnaryOperator<String> pathConverter;
+
+    public PathGenerator(UnaryOperator<String> pathConverter) {
+        this.pathConverter = pathConverter;
+    }
+
+    public @NotNull UnaryOperator<String> getPathConverter() {
+        return pathConverter;
+    }
+
+    public void setPathConverter(UnaryOperator<String> pathConverter) {
+        this.pathConverter = pathConverter;
+    }
+
+    public String covertPath(String name) {
+        return pathConverter.apply(name);
+    }
+
+    public @Nullable String getFieldPath(@NotNull ConfigurationHolder<?> holder,
+                                         @Nullable String parentPath, @NotNull Field field) {
+        ConfigPath path = field.getAnnotation(ConfigPath.class);
+        if (path == null)
+            return link(holder, parentPath, false, covertPath(field.getName())); // No annotation, use field name.
+        else return link(holder, parentPath, path.root(), select(path.value(), covertPath(field.getName())));
+    }
+
+    public @Nullable String getClassPath(@NotNull ConfigurationHolder<?> holder,
+                                         @Nullable String parentPath, @NotNull Class<?> clazz, @Nullable Field clazzField) {
+        // For standard path generator, we generate path following by:
+        // 1. Check if the class has a ConfigPath annotation, if so, use the root and value as the path.
+        // 2. If the class defined as a field, check if the field has a ConfigPath annotation,
+        //    and use filed information.
+        ConfigPath clazzPath = clazz.getAnnotation(ConfigPath.class);
+        if (clazzPath != null) return link(holder, parentPath, clazzPath.root(), clazzPath.value());
+
+        if (clazzField != null) {
+            ConfigPath fieldPath = clazzField.getAnnotation(ConfigPath.class);
+            if (fieldPath == null) return link(holder, parentPath, false, covertPath(clazzField.getName()));
+            else return getFieldPath(holder, parentPath, clazzField);
+        }
+
+        return link(holder, parentPath, false, covertPath(clazz.getSimpleName())); // No field, use class name.
+
+    }
+
+    protected String select(String path, String defaultValue) {
+        if (path == null || path.isEmpty()) return defaultValue;
+        else return isBlank(path) ? null : path;
+    }
+
+    protected @Nullable String link(@NotNull ConfigurationHolder<?> holder,
+                                    @Nullable String parent, boolean root, @Nullable String path) {
+        if (path == null || path.isEmpty()) return root ? null : parent;
+        return (root || parent == null) ? path : (parent + pathSeparator(holder) + path);
+    }
+
+    public static boolean isBlank(String path) {
+        return path == null || path.replace(" ", "").isEmpty();
+    }
+
+    public static char pathSeparator(ConfigurationHolder<?> holder) {
+        return holder.options().get(StandardOptions.PATH_SEPARATOR);
+    }
+
+    /**
+     * Get the configuration name of the specified element.
+     * Use the naming convention of all lowercase and "-" links.
+     * <p>
+     * e.g. "SOME_NAME" will be "some-name"
+     *
+     * @param name source name
+     * @return the final path
+     */
+    public static String covertPathName(String name) {
+        return name
+                // Replace all uppercase letters with dashes
+                .replaceAll("[A-Z]", "=$0")
+                // If the first letter is also capitalized,
+                // it will also be converted and the first dash will need to be removed
+                .replaceAll("^=(.*)$", "$1")
+                // Because the name may contain _, it needs to be treated a little differently
+                .replaceAll("_=([A-Z])", "_$1")
+                // The content that is not named in all caps is then converted
+                .replaceAll("([a-z])=([A-Z])", "$1_$2")
+                // Remove any extra horizontal lines
+                .replace("=", "")
+                // Replace the underscore with a dash
+                .replace("_", "-")
+                // Finally, convert it to all lowercase
+                .toLowerCase();
+    }
+
+
+}

core/src/main/java/cc/carm/lib/configuration/source/meta/ConfigurationMetaHolder.java

@@ -0,0 +1,125 @@
+package cc.carm.lib.configuration.source.meta;
+
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Supplier;
+
+public class ConfigurationMetaHolder {
+
+    protected final @NotNull Map<ConfigurationMetadata<?>, Object> values;
+
+    public ConfigurationMetaHolder() {
+        this(new ConcurrentHashMap<>());
+    }
+
+    public ConfigurationMetaHolder(@NotNull Map<ConfigurationMetadata<?>, Object> values) {
+        this.values = values;
+    }
+
+    public @NotNull Map<ConfigurationMetadata<?>, Object> values() {
+        return values;
+    }
+
+    /**
+     * Get the value of option.
+     *
+     * @param type         {@link ConfigurationMetadata}
+     * @param defaultValue Default value if the value of option is not set.
+     * @param <V>          Value type
+     * @return Value of option
+     */
+    @SuppressWarnings("unchecked")
+    @Contract("_,!null -> !null")
+    public <V> @Nullable V get(@NotNull ConfigurationMetadata<V> type, @Nullable V defaultValue) {
+        return (V) values().getOrDefault(type, type.defaultOrSupply(defaultValue));
+    }
+
+    /**
+     * Get the value of option.
+     *
+     * @param type         {@link ConfigurationMetadata}
+     * @param defaultValue Default value if the value of option is not set.
+     * @param <V>          Value type
+     * @return Value of option
+     */
+    @SuppressWarnings("unchecked")
+    @Contract("_,!null -> !null")
+    public <V> @Nullable V get(@NotNull ConfigurationMetadata<V> type, Supplier<@Nullable V> defaultValue) {
+        return (V) values().getOrDefault(type, type.defaultOrSupply(defaultValue));
+    }
+
+    /**
+     * Get the value of option.
+     *
+     * @param type {@link ConfigurationMetadata}
+     * @param <V>  Value type
+     * @return Value of option
+     */
+    public <V> @Nullable V get(@NotNull ConfigurationMetadata<V> type) {
+        return get(type, (V) null);
+    }
+
+    public boolean contains(@NotNull ConfigurationMetadata<?> type) {
+        return values().containsKey(type) || type.hasDefaults();
+    }
+
+    /**
+     * Set the value of meta, if the value is null, the meta will be removed.
+     * <br> Will only be changed in current holder.
+     *
+     * @param type  {@link ConfigurationMetadata}
+     * @param value Value of meta
+     * @param <V>   Value type
+     * @return Previous value of meta
+     */
+    @SuppressWarnings("unchecked")
+    public <V> @Nullable V set(@NotNull ConfigurationMetadata<V> type, @Nullable V value) {
+        if (value == null || type.isDefault(value)) {
+            return (V) values().remove(type);
+        } else {
+            return (V) values().put(type, value);
+        }
+    }
+
+    /**
+     * Set the value of meta, if the value is null, the meta will not be changed.
+     * <br> Will only be changed in current holder.
+     *
+     * @param type  {@link ConfigurationMetadata}
+     * @param value Value of meta
+     * @param <V>   Value type
+     */
+    public <V> void setIfAbsent(@NotNull ConfigurationMetadata<V> type, @Nullable V value) {
+        if (value == null || type.isDefault(value)) {
+            values().remove(type);
+        } else {
+            values().putIfAbsent(type, value);
+        }
+    }
+
+    /**
+     * Set the value of meta, if the value is null, the meta will not be changed.
+     * <br> Will only be changed in current holder.
+     *
+     * @param type  {@link ConfigurationMetadata}
+     * @param value Value of meta
+     * @param <V>   Value type
+     * @return Previous value of meta
+     */
+    @SuppressWarnings("unchecked")
+    public <V> @Nullable V setIfPresent(@NotNull ConfigurationMetadata<V> type, @Nullable V value) {
+        Object exists = values().get(type);
+        if (exists == null) return null;
+
+        if (value == null || type.isDefault(value)) {
+            return (V) values().remove(type);
+        } else {
+            return (V) values().put(type, value);
+        }
+    }
+
+}

core/src/main/java/cc/carm/lib/configuration/source/meta/ConfigurationMetadata.java

@@ -0,0 +1,57 @@
+package cc.carm.lib.configuration.source.meta;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Supplier;
+
+public class ConfigurationMetadata<T> {
+
+    public static <T> ConfigurationMetadata<T> of() {
+        return of(() -> null);
+    }
+
+    public static <T> ConfigurationMetadata<T> of(T defaults) {
+        return of(() -> defaults);
+    }
+
+    public static <T> ConfigurationMetadata<T> of(@NotNull Supplier<@Nullable T> defaults) {
+        return new ConfigurationMetadata<>(defaults);
+    }
+
+    protected Supplier<@Nullable T> defaultsSupplier;
+
+    public ConfigurationMetadata(@NotNull Supplier<@Nullable T> defaults) {
+        this.defaultsSupplier = defaults;
+    }
+
+    public boolean isDefault(@NotNull T value) {
+        return value.equals(defaults());
+    }
+
+    public boolean hasDefaults() {
+        return defaults() != null;
+    }
+
+    public T defaultOrSupply(@Nullable T suppliedValue) {
+        return defaultOrSupply(() -> suppliedValue);
+    }
+
+    public T defaultOrSupply(Supplier<@Nullable T> suppliedValue) {
+        T defaults = defaults();
+        return defaults == null ? suppliedValue.get() : defaults;
+    }
+
+    public @Nullable T defaults() {
+        return defaultsSupplier.get();
+    }
+
+    public void setDefaults(Supplier<T> defaultFunction) {
+        this.defaultsSupplier = defaultFunction;
+    }
+
+    public void setDefaults(T value) {
+        setDefaults(() -> value);
+    }
+
+}

core/src/main/java/cc/carm/lib/configuration/source/option/ConfigurationOption.java

@@ -0,0 +1,52 @@
+package cc.carm.lib.configuration.source.option;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.Supplier;
+
+public class ConfigurationOption<V> {
+
+    @SuppressWarnings("unchecked")
+    public static <T> ConfigurationOption<T> of(@NotNull T defaultValue) {
+        return of((Class<T>) defaultValue.getClass(), defaultValue);
+    }
+
+    public static <T> ConfigurationOption<T> of(@NotNull Class<T> valueClazz, @NotNull T defaultValue) {
+        return new ConfigurationOption<>(valueClazz, defaultValue);
+    }
+
+    public static <T> ConfigurationOption<T> of(@NotNull Supplier<T> defaultValue) {
+        return of(defaultValue.get());
+    }
+
+    private final @NotNull Class<V> valueClazz;
+    private @NotNull V defaultValue;
+
+    public ConfigurationOption(@NotNull Class<V> valueClazz, @NotNull V defaultValue) {
+        this.valueClazz = valueClazz;
+        this.defaultValue = defaultValue;
+    }
+
+    @NotNull
+    public Class<V> valueClass() {
+        return this.valueClazz;
+    }
+
+    public @NotNull V defaults() {
+        return defaultValue;
+    }
+
+    /**
+     * Set the default value of option.
+     *
+     * @param defaultValue Default value
+     */
+    public void defaults(@NotNull V defaultValue) {
+        this.defaultValue = defaultValue;
+    }
+
+    public boolean isDefault(@NotNull V value) {
+        return value.equals(defaultValue);
+    }
+
+}

core/src/main/java/cc/carm/lib/configuration/source/option/ConfigurationOptionHolder.java

@@ -0,0 +1,70 @@
+package cc.carm.lib.configuration.source.option;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class ConfigurationOptionHolder {
+
+    public static @NotNull ConfigurationOptionHolder of(@NotNull Map<ConfigurationOption<?>, Object> options) {
+        return new ConfigurationOptionHolder(new ConcurrentHashMap<>(options));
+    }
+
+    protected final Map<ConfigurationOption<?>, Object> options;
+
+    public ConfigurationOptionHolder() {
+        this(new ConcurrentHashMap<>());
+    }
+
+    public ConfigurationOptionHolder(Map<ConfigurationOption<?>, Object> options) {
+        this.options = options;
+    }
+
+    public @NotNull Map<ConfigurationOption<?>, Object> values() {
+        return options;
+    }
+
+    /**
+     * Get the value of option.
+     *
+     * @param type {@link ConfigurationOption}
+     * @param <V>  Value type
+     * @return Value of option
+     */
+    @SuppressWarnings("unchecked")
+    public <V> @NotNull V get(@NotNull ConfigurationOption<V> type) {
+        return Optional.ofNullable(values().get(type)).map(v -> (V) v).orElseGet(type::defaults);
+    }
+
+    /**
+     * Set the value of option.
+     *
+     * @param type  {@link ConfigurationOption}
+     * @param value Value of option
+     * @param <V>   Value type
+     * @return Previous value of option
+     */
+    @SuppressWarnings("unchecked")
+    public <V> @Nullable V set(@NotNull ConfigurationOption<V> type, @Nullable V value) {
+        if (value == null) {
+            return (V) values().remove(type);
+        } else {
+            return (V) values().put(type, value);
+        }
+    }
+
+    /**
+     * Set the value of option to option's {@link ConfigurationOption#defaults()}.
+     *
+     * @param type {@link ConfigurationOption}
+     * @param <V>  Value type
+     * @return Previous value of option
+     */
+    public <V> @Nullable V clear(@NotNull ConfigurationOption<V> type) {
+        return set(type, null);
+    }
+
+}

core/src/main/java/cc/carm/lib/configuration/source/option/StandardOptions.java

@@ -0,0 +1,34 @@
+package cc.carm.lib.configuration.source.option;
+
+import cc.carm.lib.configuration.Configuration;
+import cc.carm.lib.configuration.source.ConfigurationHolder;
+
+import static cc.carm.lib.configuration.source.option.ConfigurationOption.of;
+
+public interface StandardOptions {
+
+    /**
+     * The configuration path separator.
+     */
+    ConfigurationOption<Character> PATH_SEPARATOR = of('.');
+
+    /**
+     * Whether to set and save default values if offered and not exists in configuration.
+     */
+    ConfigurationOption<Boolean> SET_DEFAULTS = of(true);
+
+    /**
+     * Whether to load subclasses of configuration class.
+     */
+    ConfigurationOption<Boolean> LOAD_SUB_CLASSES = of(true);
+
+    /**
+     * Whether to pre parse the config values.
+     * <br> if false, the values will be parsed when calling
+     * {@link cc.carm.lib.configuration.value.ConfigValue#get()}
+     * <br> if true, the values will be parsed when
+     * {@link ConfigurationHolder#initialize(Configuration)}.
+     */
+    ConfigurationOption<Boolean> PRELOAD = of(false);
+
+}

core/src/main/java/cc/carm/lib/configuration/source/section/ConfigureSection.java

@@ -0,0 +1,330 @@
+package cc.carm.lib.configuration.source.section;
+
+import cc.carm.lib.configuration.function.DataFunction;
+import cc.carm.lib.configuration.source.option.StandardOptions;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.UnmodifiableView;
+
+import java.util.*;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+public interface ConfigureSection {
+
+    @NotNull ConfigureSource<?, ?, ?> source();
+
+    @Nullable ConfigureSection parent();
+
+    default char separator() {
+        return source().holder().options().get(StandardOptions.PATH_SEPARATOR);
+    }
+
+    @NotNull
+    @UnmodifiableView
+    default Set<String> getKeys(boolean deep) {
+        return getValues(deep).keySet();
+    }
+
+    @NotNull
+    @UnmodifiableView
+    Map<String, Object> getValues(boolean deep);
+
+    void set(@NotNull String path, @Nullable Object value);
+
+    boolean contains(@NotNull String path);
+
+    default <T> boolean isType(@NotNull String path, @NotNull Class<T> typeClass) {
+        return typeClass.isInstance(get(path));
+    }
+
+    default boolean isList(@NotNull String path) {
+        return isType(path, List.class);
+    }
+
+    @Nullable List<?> getList(@NotNull String path);
+
+    default boolean isSection(@NotNull String path) {
+        return isType(path, ConfigureSection.class);
+    }
+
+    @Nullable
+    ConfigureSection getSection(@NotNull String path);
+
+    @Nullable Object get(@NotNull String path);
+
+    default @Nullable <T> T get(@NotNull String path, @NotNull Class<T> clazz) {
+        return get(path, null, clazz);
+    }
+
+    default @Nullable <T> T get(@NotNull String path, @NotNull DataFunction<Object, T> parser) {
+        return get(path, null, parser);
+    }
+
+    @Contract("_,!null,_->!null")
+    default @Nullable <T> T get(@NotNull String path, @Nullable T defaultValue, @NotNull Class<T> clazz) {
+        return get(path, defaultValue, DataFunction.castObject(clazz));
+    }
+
+    @Contract("_,!null,_->!null")
+    default @Nullable <T> T get(@NotNull String path, @Nullable T defaultValue,
+                                @NotNull DataFunction<Object, T> parser) {
+        Object value = get(path);
+        if (value != null) {
+            try {
+                return parser.handle(value);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+        return defaultValue;
+    }
+
+
+    default boolean isBoolean(@NotNull String path) {
+        return isType(path, Boolean.class);
+    }
+
+    default boolean getBoolean(@NotNull String path) {
+        return getBoolean(path, false);
+    }
+
+    @Contract("_, !null -> !null")
+    default @Nullable Boolean getBoolean(@NotNull String path, @Nullable Boolean def) {
+        return get(path, def, DataFunction.booleanValue());
+    }
+
+    default @Nullable Boolean isByte(@NotNull String path) {
+        return isType(path, Byte.class);
+    }
+
+    default @Nullable Byte getByte(@NotNull String path) {
+        return getByte(path, (byte) 0);
+    }
+
+    @Contract("_, !null -> !null")
+    default @Nullable Byte getByte(@NotNull String path, @Nullable Byte def) {
+        return get(path, def, DataFunction.byteValue());
+    }
+
+    default boolean isShort(@NotNull String path) {
+        return isType(path, Short.class);
+    }
+
+    default @Nullable Short getShort(@NotNull String path) {
+        return getShort(path, (short) 0);
+    }
+
+    @Contract("_, !null -> !null")
+    default @Nullable Short getShort(@NotNull String path, @Nullable Short def) {
+        return get(path, def, DataFunction.shortValue());
+    }
+
+
+    default boolean isInt(@NotNull String path) {
+        return isType(path, Integer.class);
+    }
+
+    default @Nullable Integer getInt(@NotNull String path) {
+        return getInt(path, 0);
+    }
+
+    @Contract("_, !null -> !null")
+    default @Nullable Integer getInt(@NotNull String path, @Nullable Integer def) {
+        return get(path, def, DataFunction.intValue());
+    }
+
+
+    default boolean isLong(@NotNull String path) {
+        return isType(path, Long.class);
+    }
+
+    default @Nullable Long getLong(@NotNull String path) {
+        return getLong(path, 0L);
+    }
+
+    @Contract("_, !null -> !null")
+    default @Nullable Long getLong(@NotNull String path, @Nullable Long def) {
+        return get(path, def, DataFunction.longValue());
+    }
+
+
+    default boolean isFloat(@NotNull String path) {
+        return isType(path, Float.class);
+    }
+
+    default @Nullable Float getFloat(@NotNull String path) {
+        return getFloat(path, 0.0F);
+    }
+
+    @Contract("_, !null -> !null")
+    default @Nullable Float getFloat(@NotNull String path, @Nullable Float def) {
+        return get(path, def, DataFunction.floatValue());
+    }
+
+
+    default boolean isDouble(@NotNull String path) {
+        return isType(path, Double.class);
+    }
+
+    default @Nullable Double getDouble(@NotNull String path) {
+        return getDouble(path, 0.0D);
+    }
+
+    @Contract("_, !null -> !null")
+    default @Nullable Double getDouble(@NotNull String path, @Nullable Double def) {
+        return get(path, def, DataFunction.doubleValue());
+    }
+
+
+    default boolean isChar(@NotNull String path) {
+        return isType(path, Boolean.class);
+    }
+
+    default @Nullable Character getChar(@NotNull String path) {
+        return getChar(path, null);
+    }
+
+    @Contract("_, !null -> !null")
+    default @Nullable Character getChar(@NotNull String path, @Nullable Character def) {
+        return get(path, def, Character.class);
+    }
+
+
+    default boolean isString(@NotNull String path) {
+        return isType(path, String.class);
+    }
+
+    default @Nullable String getString(@NotNull String path) {
+        return getString(path, null);
+    }
+
+    @Contract("_, !null -> !null")
+    default @Nullable String getString(@NotNull String path, @Nullable String def) {
+        return get(path, def, String.class);
+    }
+
+    /**
+     * Get a list of values from the section
+     * <p>
+     * If the path does not exist, an empty list will be returned
+     * <br>Any changes please use {@link #set(String, Object)} after changes
+     *
+     * @param path   The path to get the list from
+     * @param parser The function to parse the values
+     * @param <V>    The type of the values
+     * @return The list of values
+     */
+    default <V> @NotNull List<V> getList(@NotNull String path, @NotNull DataFunction<Object, V> parser) {
+        return getCollection(path, ArrayList::new, parser);
+    }
+
+    /**
+     * Get a list of strings from the section
+     * <p> Limitations see {@link #getList(String, DataFunction)}
+     *
+     * @param path The path to get the list from
+     * @return The list of strings
+     */
+    default @NotNull List<String> getStringList(@NotNull String path) {
+        return getList(path, DataFunction.castToString());
+    }
+
+    /**
+     * Get a list of integer from the section
+     * <p> Limitations see {@link #getList(String, DataFunction)}
+     *
+     * @param path The path to get the list from
+     * @return The list of int values
+     */
+    default @NotNull List<Integer> getIntegerList(@NotNull String path) {
+        return getList(path, DataFunction.intValue());
+    }
+
+    /**
+     * Get a list of long from the section
+     * <p> Limitations see {@link #getList(String, DataFunction)}
+     *
+     * @param path The path to get the list from
+     * @return The list of long values
+     */
+    default @NotNull List<Long> getLongList(@NotNull String path) {
+        return getList(path, DataFunction.longValue());
+    }
+
+    /**
+     * Get a list of double from the section
+     * <p> Limitations see {@link #getList(String, DataFunction)}
+     *
+     * @param path The path to get the list from
+     * @return The list of doubles
+     */
+    default @NotNull List<Double> getDoubleList(@NotNull String path) {
+        return getList(path, DataFunction.doubleValue());
+    }
+
+    /**
+     * Get a list of floats from the section
+     * <p> Limitations see {@link #getList(String, DataFunction)}
+     *
+     * @param path The path to get the list from
+     * @return The list of floats
+     */
+    default @NotNull List<Float> getFloatList(@NotNull String path) {
+        return getList(path, DataFunction.floatValue());
+    }
+
+    /**
+     * Get a list of bytes from the section
+     * <p> Limitations see {@link #getList(String, DataFunction)}
+     *
+     * @param path The path to get the list from
+     * @return The list of bytes
+     */
+    default @NotNull List<Byte> getByteList(@NotNull String path) {
+        return getList(path, DataFunction.byteValue());
+    }
+
+    /**
+     * Get a list of char from the section
+     * <p> Limitations see {@link #getList(String, DataFunction)}
+     *
+     * @param path The path to get the list from
+     * @return The list of char
+     */
+    default @NotNull List<Character> getCharList(@NotNull String path) {
+        return getList(path, DataFunction.castObject(Character.class));
+    }
+
+    default <T, C extends Collection<T>> @NotNull C getCollection(@NotNull String path,
+                                                                  @NotNull Supplier<C> constructor,
+                                                                  @NotNull DataFunction<Object, T> parser) {
+        return parseCollection(getList(path), constructor, parser);
+    }
+
+    default @NotNull Stream<?> stream(@NotNull String path) {
+        List<?> values = getList(path);
+        return values == null ? Stream.empty() : values.stream();
+    }
+
+    default <T> @NotNull Stream<T> stream(@NotNull String path, @NotNull Function<Object, T> parser) {
+        return stream(path).map(parser);
+    }
+
+    static <T, C extends Collection<T>> @NotNull C parseCollection(
+            @Nullable List<?> data, @NotNull Supplier<C> constructor,
+            @NotNull DataFunction<Object, T> parser
+    ) {
+        C values = constructor.get();
+        if (data == null) return values;
+        for (Object obj : data) {
+            try {
+                values.add(parser.handle(obj));
+            } catch (Exception ignored) {
+            }
+        }
+        return values;
+    }
+}

core/src/main/java/cc/carm/lib/configuration/source/section/ConfigureSource.java

@@ -0,0 +1,107 @@
+package cc.carm.lib.configuration.source.section;
+
+import cc.carm.lib.configuration.source.ConfigurationHolder;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.Map;
+
+public abstract class ConfigureSource<
+        SECTION extends ConfigureSection, ORIGINAL,
+        SELF extends ConfigureSource<SECTION, ORIGINAL, SELF>>
+        implements ConfigureSection {
+
+    protected final @NotNull ConfigurationHolder<? extends SELF> holder;
+    protected long lastUpdateMillis;
+
+    protected ConfigureSource(@NotNull ConfigurationHolder<? extends SELF> holder, long lastUpdateMillis) {
+        this.holder = holder;
+        this.lastUpdateMillis = lastUpdateMillis;
+    }
+
+    public @NotNull ConfigurationHolder<? extends SELF> holder() {
+        return holder;
+    }
+
+
+    public void reload() throws Exception {
+        onReload(); // 调用重写的Reload方法
+        this.lastUpdateMillis = System.currentTimeMillis();
+    }
+
+    protected abstract SELF self();
+
+    /**
+     * @return Original configuration object
+     */
+    public abstract @NotNull ORIGINAL original();
+
+    /**
+     * @return The root {@link ConfigureSection}
+     */
+    public abstract @NotNull SECTION section();
+
+    public abstract void save() throws Exception;
+
+    protected abstract void onReload() throws Exception;
+
+    public long getLastUpdateMillis() {
+        return this.lastUpdateMillis;
+    }
+
+    public boolean isExpired(long parsedTime) {
+        return getLastUpdateMillis() > parsedTime;
+    }
+
+    @Override
+    public @Nullable ConfigureSection parent() {
+        return null; // Source also represents the root section, so it has no parent
+    }
+
+    @Override
+    public @NotNull ConfigureSource<?, ?, ?> source() {
+        return self();
+    }
+
+    @Override
+    public @NotNull Map<String, Object> getValues(boolean deep) {
+        return section().getValues(deep);
+    }
+
+    @Override
+    public void set(@NotNull String path, @Nullable Object value) {
+        section().set(path, value);
+    }
+
+    @Override
+    public boolean contains(@NotNull String path) {
+        return section().contains(path);
+    }
+
+    @Override
+    public boolean isList(@NotNull String path) {
+        return section().isList(path);
+    }
+
+    @Override
+    public @Nullable List<?> getList(@NotNull String path) {
+        return section().getList(path);
+    }
+
+    @Override
+    public boolean isSection(@NotNull String path) {
+        return section().isSection(path);
+    }
+
+    @Override
+    public @Nullable ConfigureSection getSection(@NotNull String path) {
+        return section().getSection(path);
+    }
+
+    @Override
+    public @Nullable Object get(@NotNull String path) {
+        return section().get(path);
+    }
+
+}

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

@@ -0,0 +1,141 @@
+package cc.carm.lib.configuration.value;
+
+import cc.carm.lib.configuration.source.ConfigurationHolder;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+import java.util.Optional;
+
+/**
+ * Represents a configurable value with type safety and null-handling capabilities.
+ * <p>
+ * This abstract class provides core functionalities for managing configuration values,
+ * including value retrieval with fallback defaults, null safety enforcement, and value
+ * persistence controls. It serves as the foundation for type-specific configuration
+ * implementations.
+ * </p>
+ *
+ * <h3>Functions:</h3>
+ * <ul>
+ *   <li>Type-safe value access through {@link #get()} and {@link #optional()}</li>
+ *   <li>Default value fallback via {@link #getOrDefault()}</li>
+ *   <li>Null-safety enforcement with {@link #resolve()} and {@link #getNotNull()}</li>
+ *   <li>Default value initialization through {@link #setDefault()}</li>
+ *   <li>Value comparison with {@link #isDefault()}</li>
+ * </ul>
+ *
+ * <h3>Persistence Behavior:</h3>
+ * Value modifications via {@link #set(Object)} or {@link #setDefault()} methods
+ * <b>do NOT automatically persist</b> to configuration sources. Explicit calls to
+ * {@link ConfigurationHolder#save()} are required for permanent storage.
+ *
+ * @see ValueManifest Base class providing metadata and default value handling
+ * @see ConfigurationHolder Responsible for configuration source persistence
+ */
+public abstract class ConfigValue<T> extends ValueManifest<T> {
+
+    protected ConfigValue(@NotNull ValueManifest<T> manifest) {
+        super(manifest);
+    }
+
+    /**
+     * Gets the configured value (i.e., the value read from the source).
+     * <br> If no default value was written during initialization, you can use
+     * the {@link #getOrDefault()} method to obtain the default value when this value is empty.
+     *
+     * @return Configured value
+     */
+    public abstract @Nullable T get();
+
+    /**
+     * Gets the configured value, or returns the default value if not present.
+     *
+     * @return Configured value or default value
+     */
+    public T getOrDefault() {
+        return optional().orElse(defaults());
+    }
+
+    /**
+     * Gets the non-null value of this configuration.
+     *
+     * @return Non-null value
+     * @throws NullPointerException Thrown when the corresponding data is null
+     */
+    public @NotNull T resolve() {
+        return Objects.requireNonNull(getOrDefault(), "Value(" + type() + ") @[" + path() + "] is null.");
+    }
+
+    /**
+     * Gets the non-null value of this configuration.
+     *
+     * @return Non-null value
+     * @throws NullPointerException Thrown when the corresponding data is null
+     * @see #resolve() for a more descriptive function
+     */
+    public @NotNull T getNotNull() {
+        return resolve();
+    }
+
+    /**
+     * Gets the value of this configuration as an {@link Optional}.
+     *
+     * @return {@link Optional} value
+     */
+    public @NotNull Optional<@Nullable T> optional() {
+        return Optional.ofNullable(get());
+    }
+
+    /**
+     * Sets the value of this configuration.
+     * <br> After setting, the configuration file will NOT be saved automatically.
+     * To save, call {@link ConfigurationHolder#save()}.
+     *
+     * @param value The value to set
+     */
+    public abstract void set(@Nullable T value);
+
+    /**
+     * Initializes the default value for this configuration.
+     * <br> After setting, the configuration file will NOT be saved automatically.
+     * To save, call {@link ConfigurationHolder#save()}.
+     */
+    public void setDefault() {
+        setDefault(false);
+    }
+
+    /**
+     * Sets the configuration value to its default.
+     * <br> After setting, the configuration file will NOT be saved automatically.
+     * To save, call {@link ConfigurationHolder#save()}.
+     *
+     * @param override Whether to overwrite existing configured value
+     */
+    public void setDefault(boolean override) {
+        if (!override && config().contains(path())) return;
+        set(defaults()); // Set the default value
+    }
+
+    /**
+     * Checks if the loaded configuration value matches the default value.
+     *
+     * @return Whether the current value is the default value
+     */
+    public boolean isDefault() {
+        return Objects.equals(defaults(), get());
+    }
+
+    /**
+     * Try to save the configuration.
+     * <br>To save multiple modifications,
+     * it is recommended to call {@link ConfigurationHolder#save()}
+     * after all modifications are completed instead of this.
+     *
+     * @throws Exception Thrown when an error occurs during saving
+     */
+    public void save() throws Exception {
+        holder().save();
+    }
+
+}

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

@@ -0,0 +1,124 @@
+package cc.carm.lib.configuration.value;
+
+import cc.carm.lib.configuration.adapter.ValueType;
+import cc.carm.lib.configuration.source.ConfigurationHolder;
+import cc.carm.lib.configuration.source.meta.ConfigurationMetaHolder;
+import cc.carm.lib.configuration.source.section.ConfigureSource;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.BiConsumer;
+import java.util.function.Supplier;
+
+public class ValueManifest<T> {
+
+    protected final @NotNull ValueType<T> type;
+    protected final @NotNull BiConsumer<@NotNull ConfigurationHolder<?>, @NotNull String> initializer;
+
+    protected @Nullable ConfigurationHolder<?> holder;
+    protected @Nullable String path; // Section path
+
+    protected @NotNull Supplier<@Nullable T> defaultSupplier;
+
+
+    public ValueManifest(@NotNull ValueType<T> type) {
+        this(type, () -> null, EMPTY_INITIALIZER, null, null);
+    }
+
+    public ValueManifest(@NotNull T defaultValue) {
+        this(ValueType.of(defaultValue), () -> defaultValue);
+    }
+
+    public ValueManifest(@NotNull ValueType<T> type, @NotNull Supplier<@Nullable T> defaultSupplier) {
+        this(type, defaultSupplier, EMPTY_INITIALIZER, null, null);
+    }
+
+    public ValueManifest(@NotNull ValueType<T> type, @NotNull Supplier<@Nullable T> defaultSupplier,
+                         @NotNull BiConsumer<@NotNull ConfigurationHolder<?>, @NotNull String> initializer) {
+        this(type, defaultSupplier, initializer, null, null);
+    }
+
+    public ValueManifest(@NotNull ValueType<T> type, @NotNull Supplier<@Nullable T> defaultSupplier,
+                         @NotNull BiConsumer<@NotNull ConfigurationHolder<?>, @NotNull String> initializer,
+                         @Nullable ConfigurationHolder<?> holder, @Nullable String path) {
+        this.type = type;
+        this.initializer = initializer;
+        this.defaultSupplier = defaultSupplier;
+        this.holder = holder;
+        this.path = path;
+        initialize();
+    }
+
+    protected ValueManifest(@NotNull ValueManifest<T> manifest) {
+        this(manifest.type, manifest.defaultSupplier, manifest.initializer, manifest.holder, manifest.path);
+    }
+
+    public void initialize(@NotNull ConfigurationHolder<?> holder, @NotNull String path) {
+        this.holder = holder;
+        this.path = path;
+        initialize();
+    }
+
+    protected void initialize() {
+        if (holder != null && path != null) this.initializer.accept(holder, path);
+    }
+
+    public @NotNull ValueType<T> type() {
+        return this.type;
+    }
+
+    public void holder(@NotNull ConfigurationHolder<?> holder) {
+        this.holder = holder;
+    }
+
+    public void path(@NotNull String path) {
+        this.path = path;
+    }
+
+    public @Nullable T defaults() {
+        return this.defaultSupplier.get();
+    }
+
+    public void defaults(@Nullable T defaultValue) {
+        defaults(() -> defaultValue);
+    }
+
+    public void defaults(@NotNull Supplier<@Nullable T> defaultValue) {
+        this.defaultSupplier = defaultValue;
+    }
+
+    public boolean hasDefaults() {
+        return this.defaultSupplier.get() != null;
+    }
+
+    public @NotNull String path() {
+        if (path != null) return path;
+        else throw new IllegalStateException("No section path provided.");
+    }
+
+    public @NotNull ConfigurationHolder<?> holder() {
+        if (this.holder != null) return this.holder;
+        throw new IllegalStateException("Value does not have a provider.");
+    }
+
+    public @NotNull ConfigureSource<?, ?, ?> config() {
+        return holder().config();
+    }
+
+    public ConfigurationMetaHolder metadata() {
+        return holder().metadata(path());
+    }
+
+    protected Object getData() {
+        return config().get(path());
+    }
+
+    protected void setData(@Nullable Object value) {
+        config().set(path(), value);
+    }
+
+
+    private static final @NotNull BiConsumer<@NotNull ConfigurationHolder<?>, @NotNull String> EMPTY_INITIALIZER = (provider, path) -> {
+    };
+
+}

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

@@ -0,0 +1,85 @@
+package cc.carm.lib.configuration.value.impl;
+
+import cc.carm.lib.configuration.adapter.ValueAdapter;
+import cc.carm.lib.configuration.adapter.ValueParser;
+import cc.carm.lib.configuration.adapter.ValueSerializer;
+import cc.carm.lib.configuration.value.ConfigValue;
+import cc.carm.lib.configuration.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 cacheExpired() {
+        return this.parsedTime <= 0 || config().isExpired(this.parsedTime);
+    }
+
+    protected final T getDefaultFirst(@Nullable T value) {
+        return updateCache(this.defaults() == null ? value : this.defaults());
+    }
+
+    /**
+     * Get the cached value or the default value if the cached value is null
+     *
+     * @return the cached value or the default value
+     */
+    protected @Nullable T getCachedOrDefault() {
+        return getCachedOrDefault(null);
+    }
+
+    /**
+     * Get the cached value or the default value if the cached value is null
+     *
+     * @param emptyValue the value to return if the cached value and the default value are null
+     * @return the cached value or the default value
+     */
+    @Contract("!null->!null")
+    protected T getCachedOrDefault(@Nullable T emptyValue) {
+        if (getCachedValue() != null) return getCachedValue();
+        else if (defaults() != null) return defaults();
+        else return emptyValue;
+    }
+
+    /**
+     * @param adapter Value adapter
+     * @param <O>     Base object type
+     * @return Value's parser, parse base object to value.
+     */
+    protected <O> @Nullable ValueParser<O> parserFor(@NotNull ValueAdapter<O> adapter) {
+        if (adapter.parser() != null) return adapter.parser();
+        ValueAdapter<O> registered = holder().adapters().adapterOf(adapter.type());
+        if (registered == null) return null;
+        return registered.parser();
+    }
+
+    /**
+     * @param adapter Value adapter
+     * @param <O>     Base object type
+     * @return Value's serializer, parse value to base object.
+     */
+    protected <O> @Nullable ValueSerializer<O> serializerFor(@NotNull ValueAdapter<O> adapter) {
+        if (adapter.serializer() != null) return adapter.serializer();
+        ValueAdapter<O> registered = holder().adapters().adapterOf(adapter.type());
+        if (registered == null) return null;
+        return registered.serializer();
+    }
+
+}

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

@@ -0,0 +1,252 @@
+package cc.carm.lib.configuration.value.standard;
+
+import cc.carm.lib.configuration.adapter.ValueAdapter;
+import cc.carm.lib.configuration.adapter.ValueParser;
+import cc.carm.lib.configuration.adapter.ValueSerializer;
+import cc.carm.lib.configuration.adapter.ValueType;
+import cc.carm.lib.configuration.builder.list.ConfigListBuilder;
+import cc.carm.lib.configuration.value.ValueManifest;
+import cc.carm.lib.configuration.value.impl.CachedConfigValue;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.*;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+public class ConfiguredList<V> extends CachedConfigValue<List<V>> implements List<V> {
+
+    public static <T> @NotNull ConfigListBuilder<T> builderOf(@NotNull Class<T> type) {
+        return builderOf(ValueType.of(type));
+    }
+
+    public static <T> @NotNull ConfigListBuilder<T> builderOf(@NotNull ValueType<T> type) {
+        return new ConfigListBuilder<>(type);
+    }
+
+    protected final @NotNull Supplier<? extends List<V>> constructor;
+    protected final @NotNull ValueAdapter<V> paramAdapter;
+
+    public ConfiguredList(@NotNull ValueManifest<List<V>> manifest,
+                          @NotNull Supplier<? extends List<V>> constructor,
+                          @NotNull ValueAdapter<V> paramAdapter) {
+        super(manifest);
+        this.constructor = constructor;
+        this.paramAdapter = paramAdapter;
+    }
+
+    /**
+     * @return Adapter of this value.
+     */
+    public @NotNull ValueAdapter<V> adapter() {
+        return this.paramAdapter;
+    }
+
+    public @NotNull ValueType<V> paramType() {
+        return adapter().type();
+    }
+
+    /**
+     * @return Value's parser, parse base object to value.
+     */
+    public @Nullable ValueParser<V> parser() {
+        return parserFor(adapter());
+    }
+
+    /**
+     * @return Value's serializer, parse value to base object.
+     */
+    public @Nullable ValueSerializer<V> serializer() {
+        return serializerFor(adapter());
+    }
+
+    private @NotNull List<V> createList() {
+        return constructor.get();
+    }
+
+    @Override
+    public @NotNull List<V> get() {
+        if (!cacheExpired()) return getCachedOrDefault(createList());
+        // Data that is outdated and needs to be parsed again.
+        List<V> list = createList();
+        List<?> data = config().contains(path()) ? config().getList(path()) : null;
+        if (data == null) return getDefaultFirst(list);
+
+        ValueParser<V> parser = parser();
+        if (parser == null) return getDefaultFirst(list);
+
+        for (Object dataVal : data) {
+            if (dataVal == null) continue;
+            try {
+                list.add(parser.parse(holder(), paramType(), dataVal));
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+        return updateCache(list);
+    }
+
+    @Override
+    public void set(@Nullable List<V> value) {
+        updateCache(value);
+        if (value == null) {
+            setData(null);
+            return;
+        }
+
+        ValueSerializer<V> serializer = serializer();
+        if (serializer == null) return;
+        List<Object> data = new ArrayList<>();
+        for (V val : value) {
+            if (val == null) continue;
+            try {
+                data.add(serializer.serialize(holder(), paramType(), val));
+            } catch (Exception ex) {
+                ex.printStackTrace();
+            }
+        }
+        setData(data);
+    }
+
+    @Override
+    public V get(int index) {
+        return resolve().get(index);
+    }
+
+    public @NotNull List<V> copy() {
+        return new ArrayList<>(resolve());
+    }
+
+    public <T> @NotNull T handle(Function<List<V>, T> function) {
+        List<V> list = resolve();
+        T result = function.apply(list);
+        set(list);
+        return result;
+    }
+
+    public @NotNull ConfiguredList<V> modify(Consumer<List<V>> consumer) {
+        List<V> list = resolve();
+        consumer.accept(list);
+        set(list);
+        return this;
+    }
+
+    @Override
+    public V set(int index, V element) {
+        return handle(list -> list.set(index, element));
+    }
+
+    @Override
+    public int size() {
+        return resolve().size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return resolve().isEmpty();
+    }
+
+    @Override
+    public boolean contains(Object o) {
+        return resolve().contains(o);
+    }
+
+    @NotNull
+    @Override
+    public Iterator<V> iterator() {
+        return resolve().iterator();
+    }
+
+    @NotNull
+    @Override
+    public Object @NotNull [] toArray() {
+        return resolve().toArray();
+    }
+
+    @NotNull
+    @Override
+    public <T> T @NotNull [] toArray(@NotNull T[] a) {
+        return resolve().toArray(a);
+    }
+
+    @Override
+    public boolean containsAll(@NotNull Collection<?> c) {
+        return new HashSet<>(resolve()).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 resolve().indexOf(o);
+    }
+
+    @Override
+    public int lastIndexOf(Object o) {
+        return resolve().lastIndexOf(o);
+    }
+
+    @NotNull
+    @Override
+    public ListIterator<V> listIterator() {
+        return resolve().listIterator();
+    }
+
+    @NotNull
+    @Override
+    public ListIterator<V> listIterator(int index) {
+        return resolve().listIterator(index);
+    }
+
+    @NotNull
+    @Override
+    public List<V> subList(int fromIndex, int toIndex) {
+        return resolve().subList(fromIndex, toIndex);
+    }
+
+}

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

@@ -0,0 +1,211 @@
+package cc.carm.lib.configuration.value.standard;
+
+import cc.carm.lib.configuration.adapter.ValueAdapter;
+import cc.carm.lib.configuration.adapter.ValueParser;
+import cc.carm.lib.configuration.adapter.ValueSerializer;
+import cc.carm.lib.configuration.adapter.ValueType;
+import cc.carm.lib.configuration.builder.map.ConfigMapCreator;
+import cc.carm.lib.configuration.source.section.ConfigureSection;
+import cc.carm.lib.configuration.value.ValueManifest;
+import cc.carm.lib.configuration.value.impl.CachedConfigValue;
+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 class ConfiguredMap<K, V> extends CachedConfigValue<Map<K, V>> implements Map<K, V> {
+
+    public static <K, V> ConfigMapCreator<K, V> builderOf(@NotNull ValueType<K> keyType, @NotNull ValueType<V> valueType) {
+        return new ConfigMapCreator<>(keyType, valueType);
+    }
+
+    public static <K, V> ConfigMapCreator<K, V> builderOf(@NotNull Class<K> keyType, @NotNull Class<V> valueType) {
+        return new ConfigMapCreator<>(ValueType.of(keyType), ValueType.of(valueType));
+    }
+
+    public static <K, V> ConfiguredMap<K, V> of(@NotNull Supplier<? extends Map<K, V>> constructor,
+                                                @NotNull ValueAdapter<K> keyAdapter, @NotNull ValueAdapter<V> valueAdapter) {
+        return new ConfiguredMap<>(new ValueManifest<>(new ValueType<Map<K, V>>() {
+        }, constructor::get), constructor, keyAdapter, valueAdapter);
+    }
+
+    protected final @NotNull Supplier<? extends Map<K, V>> constructor;
+
+    protected final @NotNull ValueAdapter<K> keyAdapter;
+    protected final @NotNull ValueAdapter<V> valueAdapter;
+
+    public ConfiguredMap(@NotNull ValueManifest<Map<K, V>> manifest,
+                         @NotNull Supplier<? extends Map<K, V>> constructor,
+                         @NotNull ValueAdapter<K> keyAdapter, @NotNull ValueAdapter<V> valueAdapter) {
+        super(manifest);
+        this.constructor = constructor;
+        this.keyAdapter = keyAdapter;
+        this.valueAdapter = valueAdapter;
+    }
+
+    public @NotNull ValueAdapter<K> keyAdapter() {
+        return keyAdapter;
+    }
+
+    public @NotNull ValueType<K> keyType() {
+        return keyAdapter().type();
+    }
+
+    public @NotNull ValueAdapter<V> valueAdapter() {
+        return valueAdapter;
+    }
+
+    public @NotNull ValueType<V> valueType() {
+        return valueAdapter().type();
+    }
+
+    private Map<K, V> createMap() {
+        return this.constructor.get();
+    }
+
+    @Override
+    public @NotNull Map<K, V> get() {
+        if (!cacheExpired()) return getCachedOrDefault(createMap());
+        // If the value is expired, we need to update it
+        Map<K, V> map = createMap();
+
+        ConfigureSection section = config().getSection(path());
+        if (section == null) return getDefaultFirst(map);
+
+        Set<String> keys = section.getKeys(false);
+        if (keys.isEmpty()) return getDefaultFirst(map);
+
+        ValueParser<K> keyParser = parserFor(keyAdapter);
+        ValueParser<V> valueParser = parserFor(valueAdapter);
+        if (keyParser == null || valueParser == null) return getDefaultFirst(map);
+
+        for (String dataKey : keys) {
+            Object dataVal = section.get(dataKey);
+            if (dataVal == null) continue;
+            try {
+                K key = keyParser.parse(holder(), keyType(), dataKey);
+                V value = valueParser.parse(holder(), valueType(), 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(@Nullable K key) {
+        return Objects.requireNonNull(get(key));
+    }
+
+    @Override
+    public void set(@Nullable Map<K, V> value) {
+        updateCache(value);
+        if (value == null) {
+            setData(null);
+            return;
+        }
+
+        ValueSerializer<K> keySerializer = serializerFor(keyAdapter);
+        ValueSerializer<V> valueSerializer = serializerFor(valueAdapter);
+        if (keySerializer == null || valueSerializer == null) return;
+
+        Map<Object, Object> data = new LinkedHashMap<>();
+
+        for (Map.Entry<K, V> entry : value.entrySet()) {
+            try {
+                data.put(
+                        keySerializer.serialize(holder(), keyType(), entry.getKey()),
+                        valueSerializer.serialize(holder(), valueType(), entry.getValue())
+                );
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+        setData(data);
+    }
+
+    public <T> @NotNull T handle(Function<Map<K, V>, T> function) {
+        Map<K, V> m = get();
+        T result = function.apply(m);
+        set(m);
+        return result;
+    }
+
+    public @NotNull ConfiguredMap<K, V> modify(Consumer<Map<K, V>> consumer) {
+        Map<K, V> m = get();
+        consumer.accept(m);
+        set(m);
+        return this;
+    }
+
+    @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 handle(m -> m.put(key, value));
+    }
+
+    @Override
+    public V remove(Object key) {
+        return handle(m -> m.remove(key));
+    }
+
+    @Override
+    public void putAll(@NotNull Map<? extends K, ? extends V> m) {
+        modify(map -> map.putAll(m));
+    }
+
+    @Override
+    public void clear() {
+        modify(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/value/standard/ConfiguredValue.java

@@ -0,0 +1,143 @@
+package cc.carm.lib.configuration.value.standard;
+
+import cc.carm.lib.configuration.adapter.ValueAdapter;
+import cc.carm.lib.configuration.adapter.ValueParser;
+import cc.carm.lib.configuration.adapter.ValueSerializer;
+import cc.carm.lib.configuration.adapter.ValueType;
+import cc.carm.lib.configuration.builder.value.ConfigValueBuilder;
+import cc.carm.lib.configuration.value.ValueManifest;
+import cc.carm.lib.configuration.value.impl.CachedConfigValue;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Supplier;
+
+public class ConfiguredValue<V> extends CachedConfigValue<V> {
+
+    public static <V> ConfigValueBuilder<V> builderOf(@NotNull Class<V> type) {
+        return new ConfigValueBuilder<>(ValueType.of(type));
+    }
+
+    public static <V> ConfigValueBuilder<V> builderOf(@NotNull ValueType<V> type) {
+        return new ConfigValueBuilder<>(type);
+    }
+
+    public static <V> ConfiguredValue<V> of(@NotNull V defaults) {
+        return of(ValueType.of(defaults), () -> defaults);
+    }
+
+    public static <V> ConfiguredValue<V> of(@NotNull Class<V> type) {
+        return of(ValueType.of(type), () -> null);
+    }
+
+    public static <V> ConfiguredValue<V> of(@NotNull Class<V> type, @NotNull V defaults) {
+        return of(ValueType.of(type), () -> defaults);
+    }
+
+
+    public static <V> ConfiguredValue<V> of(@NotNull Class<V> type, @NotNull Supplier<@Nullable V> defaultSupplier) {
+        return of(ValueType.of(type), defaultSupplier);
+    }
+
+    public static <V> ConfiguredValue<V> of(@NotNull ValueType<V> type) {
+        return of(type, () -> null);
+    }
+
+    public static <V> ConfiguredValue<V> of(@NotNull ValueType<V> type, @NotNull Supplier<@Nullable V> defaultSupplier) {
+        return of(
+                new ValueManifest<>(type, defaultSupplier),
+                (provider, t, data) -> provider.deserialize(type, data),
+                (provider, t, value) -> provider.serialize(value)
+        );
+    }
+
+    public static <V> ConfiguredValue<V> of(@NotNull ValueManifest<V> manifest,
+                                            @Nullable ValueParser<V> parser,
+                                            @Nullable ValueSerializer<V> serializer) {
+        ValueAdapter<V> adapter = new ValueAdapter<>(manifest.type());
+        adapter.parser(parser);
+        adapter.serializer(serializer);
+        return of(manifest, adapter);
+    }
+
+    public static <V> ConfiguredValue<V> of(@NotNull ValueManifest<V> manifest, @NotNull ValueAdapter<V> adapter) {
+        return new ConfiguredValue<>(manifest, adapter);
+    }
+
+    protected final @NotNull ValueAdapter<V> adapter;
+
+    public ConfiguredValue(@NotNull ValueManifest<V> manifest, @NotNull ValueAdapter<V> adapter) {
+        super(manifest);
+        this.adapter = adapter;
+    }
+
+    /**
+     * @return Adapter of this value.
+     */
+    public @NotNull ValueAdapter<V> adapter() {
+        return adapter;
+    }
+
+    /**
+     * @return Value's parser, parse base object to value.
+     */
+    public @Nullable ValueParser<V> parser() {
+        return parserFor(adapter());
+    }
+
+    /**
+     * @return Value's serializer, parse value to base object.
+     */
+    public @Nullable ValueSerializer<V> serializer() {
+        return serializerFor(adapter());
+    }
+
+    @Override
+    public V get() {
+        if (!cacheExpired()) return getCachedOrDefault();
+        // Data that is outdated and needs to be parsed again.
+
+        Object data = getData();
+        if (data == null) return defaults();
+
+        ValueParser<V> parser = parser();
+        if (parser == null) return defaults(); // No parser, return default value.
+
+        try {
+            // If there are no errors, update the cache and return.
+            return updateCache(parser.parse(holder(), type(), data));
+        } catch (Exception e) {
+            // There was a parsing error, prompted and returned the default value.
+            e.printStackTrace();
+            return defaults();
+        }
+
+    }
+
+    /**
+     * Set the value of the configuration path.
+     * Will use {@link #serializer()} to serialize the value.
+     *
+     * @param value The value to be set
+     */
+    @Override
+    public void set(V value) {
+        updateCache(value); // Update cache
+        if (value == null) {
+            setData(null);
+            return;
+        }
+
+        ValueSerializer<V> serializer = serializer();
+        if (serializer == null) return; // No serializer, do nothing.
+
+        try {
+            setData(serializer.serialize(holder(), type(), value));
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+}
+

core/src/test/java/NameTest.java

@@ -1,4 +1,4 @@
-import cc.carm.lib.configuration.core.ConfigInitializer;
+import cc.carm.lib.configuration.source.loader.PathGenerator;
 import org.junit.Test;
 
 public class NameTest {
@@ -7,10 +7,10 @@ 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
+        System.out.println(PathGenerator.covertPathName("LoveGames")); // -> love-games
+        System.out.println(PathGenerator.covertPathName("EASY_GAME")); // -> easy-game
+        System.out.println(PathGenerator.covertPathName("F")); //-? f
+        System.out.println(PathGenerator.covertPathName("Test123123")); // -? test123123123
 
     }
 

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

@@ -1,4 +1,4 @@
-package config.offset;
+package cc.carm.test.config.offset;
 
 import org.jetbrains.annotations.NotNull;
 

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>2.0.0</version>
-        <relativePath>../../pom.xml</relativePath>
+        <version>4.0.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-yaml</artifactId>
+    <artifactId>easyconfiguration-demo</artifactId>
     <packaging>jar</packaging>
 
     <dependencies>
@@ -27,9 +27,9 @@
         </dependency>
 
         <dependency>
-            <groupId>cc.carm.lib</groupId>
-            <artifactId>yamlconfiguration-commented</artifactId>
-            <version>2.0.2</version>
+            <groupId>${project.parent.groupId}</groupId>
+            <artifactId>easyconfiguration-feature-commentable</artifactId>
+            <version>${project.parent.version}</version>
             <scope>compile</scope>
         </dependency>
 
@@ -56,5 +56,4 @@
         </plugins>
     </build>
 
-
 </project>

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

@@ -1,18 +1,19 @@
-package config.source;
+package cc.carm.lib.configuration.demo;
 
-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.value.ConfigValue;
-import cc.carm.lib.configuration.core.value.type.ConfiguredValue;
+import cc.carm.lib.configuration.Configuration;
+import cc.carm.lib.configuration.annotation.ConfigPath;
+import cc.carm.lib.configuration.annotation.HeaderComments;
+import cc.carm.lib.configuration.value.ConfigValue;
+import cc.carm.lib.configuration.value.standard.ConfiguredValue;
 
-@ConfigComment({"数据库配置", "  用于提供数据库连接，进行数据库操作。"})
-public class DatabaseConfiguration extends ConfigurationRoot {
+@HeaderComments({"", "数据库配置", "  用于提供数据库连接，进行数据库操作。"})
+public class DatabaseConfiguration implements Configuration {
 
     @ConfigPath("driver")
-    @ConfigComment({
+    @HeaderComments({
             "数据库驱动配置，请根据数据库类型设置。",
-            "- MySQL: com.mysql.cj.jdbc.Driver",
+            "- 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(
@@ -21,11 +22,9 @@ public class DatabaseConfiguration extends ConfigurationRoot {
 
     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() {

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

@@ -0,0 +1,92 @@
+package cc.carm.lib.configuration.demo.tests;
+
+import cc.carm.lib.configuration.demo.tests.conf.DemoConfiguration;
+import cc.carm.lib.configuration.demo.tests.conf.RegistryConfig;
+import cc.carm.lib.configuration.demo.tests.model.UserRecord;
+import cc.carm.lib.configuration.source.ConfigurationHolder;
+import org.jetbrains.annotations.TestOnly;
+
+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(ConfigurationHolder<?> holder) {
+        try {
+            holder.initialize(DemoConfiguration.class);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        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.ALLOWLISTS.get());
+        DemoConfiguration.ALLOWLISTS.add(UserRecord.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(ConfigurationHolder<?> provider) {
+
+        RegistryConfig TEST = new RegistryConfig();
+
+        provider.initialize(TEST);
+
+        System.out.println("> Test Inner value before:");
+        System.out.println(TEST.INSTANCE.INNER_VALUE.resolve());
+
+        double after = Math.random() * 200D;
+        System.out.println("> Test Inner value -> " + after);
+        TEST.INSTANCE.INNER_VALUE.set(after);
+
+        System.out.println("> Test Inner value after:");
+        System.out.println(TEST.INSTANCE.INNER_VALUE.resolve());
+
+    }
+
+    public static void save(ConfigurationHolder<?> 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,95 @@
+package cc.carm.lib.configuration.demo.tests.conf;
+
+import cc.carm.lib.configuration.Configuration;
+import cc.carm.lib.configuration.annotation.ConfigPath;
+import cc.carm.lib.configuration.annotation.FooterComments;
+import cc.carm.lib.configuration.annotation.HeaderComments;
+import cc.carm.lib.configuration.annotation.InlineComment;
+import cc.carm.lib.configuration.demo.DatabaseConfiguration;
+import cc.carm.lib.configuration.demo.tests.model.ItemStack;
+import cc.carm.lib.configuration.demo.tests.model.UserRecord;
+import cc.carm.lib.configuration.value.ConfigValue;
+import cc.carm.lib.configuration.value.standard.ConfiguredList;
+import cc.carm.lib.configuration.value.standard.ConfiguredMap;
+import cc.carm.lib.configuration.value.standard.ConfiguredValue;
+
+import java.time.temporal.ChronoUnit;
+import java.util.Arrays;
+import java.util.Objects;
+import java.util.UUID;
+
+@ConfigPath(root = true)
+@HeaderComments({"此处内容将显示在配置文件的最上方"})
+@FooterComments({
+        "------------------------------------------------",
+        "此处内容将显示在配置文件的最下方",
+        "可用于显示版权信息等",
+        "感谢您使用 https://github.com/CarmJos/EasyConfiguration !"
+})
+public interface DemoConfiguration extends Configuration {
+
+    @ConfigPath(root = true)
+    ConfigValue<Double> VERSION = ConfiguredValue.of(Double.class, 1.0D);
+
+    @ConfigPath(root = true)
+    @FooterComments({"此处内容将显示在配置条目的下方", "可用于补充说明，但一般不建议使用"})
+    ConfigValue<Long> TEST_NUMBER = ConfiguredValue.of(1000000L);
+
+    @HeaderComments({"枚举类型测试"})
+    @FooterComments({"上述的枚举内容本质上是通过STRING解析的"})
+    ConfigValue<ChronoUnit> TEST_ENUM = ConfiguredValue.of(ChronoUnit.class, ChronoUnit.DAYS);
+
+    // 支持通过 Class<?> 变量标注子配置，一并注册。
+    // 注意： 若对应类也有注解，则优先使用类的注解。
+    Class<?> DATABASE = DatabaseConfiguration.class;
+
+    @ConfigPath("registered_users") // 通过注解规定配置文件中的路径，若不进行注解则以变量名自动生成。
+    @HeaderComments({"Section类型数据测试"}) // 通过注解给配置添加注释。
+    @InlineComment("默认地注释会加到Section的首行末尾") // 通过注解给配置添加注释。
+    @InlineComment(value = "用户名(匹配注释)", regex = "name") // 通过注解给配置添加注释。
+    @InlineComment(value = "信息", regex = "info.*") // 通过注解给配置添加注释。
+    ConfiguredList<UserRecord> ALLOWLISTS = ConfiguredList.builderOf(UserRecord.class).fromSection()
+            .parse(UserRecord::deserialize).serialize(UserRecord::serialize)
+            .defaults(UserRecord.CARM).build();
+
+    @HeaderComments({
+            "------------------------------------------------",
+            "[ID - ItemStack]对照表", "", "用于测试Map类型的解析与序列化保存"
+    })
+    @FooterComments("------------------------------------------------")
+    ConfiguredMap<Integer, ItemStack> ITEMS = ConfiguredMap.builderOf(Integer.class, ItemStack.class)
+            .asLinkedMap().fromSection()
+            .parseKey(data -> Integer.parseInt(data))
+            .parse(ItemStack::deserialize).serialize(ItemStack::serialize)
+            .defaults(m -> {
+                m.put(1, new ItemStack("stone", 64));
+                m.put(2, new ItemStack("iron", 64, "铁锭", Arrays.asList("一些铁锭", "可以制造东西")));
+            })
+            .build();
+
+
+    /**
+     * 支持内部类的直接注册。
+     * 注意，需要启用 {@link  cc.carm.lib.configuration.source.option.StandardOptions#LOAD_SUB_CLASSES}
+     */
+    class SUB implements Configuration {
+
+        @ConfigPath(value = "uuid-value", root = true)
+        public static final ConfigValue<UUID> UUID_CONFIG_VALUE = ConfiguredValue
+                .builderOf(UUID.class).fromString()
+                .parse((holder, data) -> UUID.fromString(data))
+                .build();
+
+        @HeaderComments({"内部类的内部类测试", "通过这种方式，您可以轻易实现多层次的配置文件结构"})
+        public interface That extends Configuration {
+
+            ConfiguredList<UUID> OPERATORS = ConfiguredList
+                    .builderOf(UUID.class).fromString()
+                    .parse(s -> Objects.requireNonNull(UUID.fromString(s)))
+                    .build();
+
+        }
+    }
+
+
+}

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

@@ -0,0 +1,13 @@
+package cc.carm.lib.configuration.demo.tests.conf;
+
+import cc.carm.lib.configuration.Configuration;
+import cc.carm.lib.configuration.annotation.HeaderComments;
+import cc.carm.lib.configuration.value.ConfigValue;
+import cc.carm.lib.configuration.value.standard.ConfiguredValue;
+
+@HeaderComments("Inner Test")
+public class InstanceConfig implements Configuration {
+
+    public final ConfigValue<Double> INNER_VALUE = ConfiguredValue.of(1.0D);
+
+}

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

@@ -0,0 +1,27 @@
+package cc.carm.lib.configuration.demo.tests.conf;
+
+import cc.carm.lib.configuration.Configuration;
+import cc.carm.lib.configuration.annotation.ConfigPath;
+import cc.carm.lib.configuration.annotation.FooterComments;
+import cc.carm.lib.configuration.annotation.HeaderComments;
+import cc.carm.lib.configuration.annotation.InlineComment;
+import cc.carm.lib.configuration.demo.tests.model.UserRecord;
+import cc.carm.lib.configuration.value.ConfigValue;
+import cc.carm.lib.configuration.value.standard.ConfiguredValue;
+
+import java.util.UUID;
+
+public class RegistryConfig implements Configuration {
+
+    @HeaderComments("Support for configurations as instances")
+    public final InstanceConfig INSTANCE = new InstanceConfig();
+
+    @ConfigPath("test.user") // 通过注解规定配置文件中的路径，若不进行注解则以变量名自动生成。
+    @FooterComments({"12313213212"})
+    public final ConfigValue<UserRecord> TEST_MODEL = ConfiguredValue.builderOf(UserRecord.class).fromSection()
+            .defaults(new UserRecord("Carm", UUID.randomUUID()))
+            .parse((holder, section) -> UserRecord.deserialize(section))
+            .serialize((holder, data) -> data.serialize()).build();
+
+
+}

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

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

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

@@ -0,0 +1,78 @@
+package cc.carm.lib.configuration.demo.tests.model;
+
+import cc.carm.lib.configuration.source.section.ConfigureSection;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+public class ItemStack {
+
+    protected String material;
+    protected int amount;
+    protected @Nullable String name;
+    protected @Nullable List<String> lore;
+
+    public ItemStack(String material, int amount) {
+        this(material, amount, null, null);
+    }
+
+    public ItemStack(String material, int amount, @Nullable String name, @Nullable List<String> lore) {
+        this.material = material;
+        this.amount = amount;
+        this.name = name;
+        this.lore = lore;
+    }
+
+    public String getMaterial() {
+        return material;
+    }
+
+    public int getAmount() {
+        return amount;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public List<String> getLore() {
+        return lore;
+    }
+
+    public void setMaterial(String material) {
+        this.material = material;
+    }
+
+    public void setAmount(int amount) {
+        this.amount = amount;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void setLore(List<String> lore) {
+        this.lore = lore;
+    }
+
+
+    public Map<String, Object> serialize() {
+        Map<String, Object> map = new LinkedHashMap<>();
+        map.put("material", material);
+        if (amount != 1) map.put("amount", amount);
+        if (name != null) map.put("name", name);
+        if (lore != null) map.put("lore", lore);
+        return map;
+    }
+
+    public static ItemStack deserialize(ConfigureSection section) {
+        return new ItemStack(
+                section.getString("material"),
+                section.getInt("amount", 1),
+                section.getString("name"),
+                section.getStringList("lore")
+        );
+    }
+}

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

@@ -0,0 +1,58 @@
+package cc.carm.lib.configuration.demo.tests.model;
+
+import cc.carm.lib.configuration.source.section.ConfigureSection;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+public class UserRecord extends AbstractRecord {
+
+    public static final UserRecord CARM = new UserRecord("Carm", UUID.fromString("f7b3b3b3-3b3b-3b3b-3b3b-3b3b3b3b3b3b"));
+
+    protected UUID uuid;
+
+    public UserRecord(String name, UUID uuid) {
+        super(name);
+        this.uuid = uuid;
+    }
+
+    public void uuid(UUID uuid) {
+        this.uuid = uuid;
+    }
+
+    public UUID uuid() {
+        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 UserRecord deserialize(ConfigureSection 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 UserRecord(name, UUID.fromString(uuidString));
+    }
+
+    public static UserRecord random() {
+        return new UserRecord(UUID.randomUUID().toString().substring(0, 5), UUID.randomUUID());
+    }
+
+
+    @Override
+    public String toString() {
+        return "TestUser{" +
+                "name='" + name + '\'' +
+                ", uuid=" + uuid +
+                '}';
+    }
+}

features/commentable/pom.xml

@@ -0,0 +1,51 @@
+<?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">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>cc.carm.lib</groupId>
+        <artifactId>easyconfiguration-parent</artifactId>
+        <version>4.0.0</version>
+        <relativePath>../../pom.xml</relativePath>
+    </parent>
+    <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-feature-commentable</artifactId>
+    <packaging>jar</packaging>
+
+    <dependencies>
+        <dependency>
+            <groupId>${project.groupId}</groupId>
+            <artifactId>easyconfiguration-core</artifactId>
+            <version>${project.version}</version>
+        </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>

features/commentable/src/main/java/cc/carm/lib/configuration/annotation/FooterComments.java

@@ -0,0 +1,40 @@
+package cc.carm.lib.configuration.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;
+
+/**
+ * Footer Comments.
+ * Add a comment to the bottom of the corresponding configuration for easy reading and viewing.
+ * <p>e.g.
+ * <blockquote><pre>
+ * foo: "bar"
+ * # The first line of the comment
+ * # The second line of the comment
+ * </pre></blockquote>
+ */
+@Target({ElementType.TYPE, ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface FooterComments {
+
+    /**
+     * If the content of the note is 0, it will be treated as a blank line.
+     * <p> e.g. <b>{"foo","","bar"}</b>
+     * Will be set as
+     * <blockquote><pre>
+     * foo: "bar"
+     * # foo
+     *
+     * # bar
+     * </pre></blockquote>
+     *
+     * @return The content of this comment
+     */
+    @NotNull
+    String[] value() default "";
+
+}

features/commentable/src/main/java/cc/carm/lib/configuration/annotation/HeaderComments.java

@@ -0,0 +1,40 @@
+package cc.carm.lib.configuration.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;
+
+/**
+ * Header Comments.
+ * Add a comment to the top of the corresponding configuration for easy reading and viewing.
+ * <p>e.g.
+ * <blockquote><pre>
+ * # The first line of the comment
+ * # The second line of the comment
+ * foo: "bar"
+ * </pre></blockquote>
+ */
+@Target({ElementType.TYPE, ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface HeaderComments {
+
+    /**
+     * If the content of the note is 0, it will be treated as a blank line.
+     * <p> e.g. <b>{"foo","","bar"}</b>
+     * Will be set as
+     * <blockquote><pre>
+     * # foo
+     *
+     * # bar
+     * foo: "bar"
+     * </pre></blockquote>
+     *
+     * @return The content of this comment
+     */
+    @NotNull
+    String[] value() default "";
+
+}

features/commentable/src/main/java/cc/carm/lib/configuration/annotation/InlineComment.java

@@ -0,0 +1,52 @@
+package cc.carm.lib.configuration.annotation;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.annotation.*;
+
+/**
+ * Inline comments,
+ * add comments to the rows of the corresponding configurations for easy reading and viewing.
+ * e.g.
+ * <blockquote><pre>
+ * foo: "bar" # Comment Contents
+ * </pre></blockquote>
+ */
+@Target({ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+@Repeatable(InlineComments.class)
+public @interface InlineComment {
+
+    /**
+     * If the content length is 0, the comment will not be added.
+     * <p> e.g. <b>"foobar"</b> will be set
+     * <blockquote><pre>
+     * foo: "bar" # foobar
+     * </pre></blockquote>
+     *
+     * @return The content of this comment
+     */
+    @NotNull
+    String value() default "";
+
+    /**
+     * If the regex is not empty, the comment will be added to
+     * all sub paths if the regex matches the value.
+     * If the regex is empty, the comment will be added to the current path.
+     * <p> e.g. for section, set <b>{"^foo", "*", "bar"}</b> will be set like
+     * <blockquote><pre>
+     *   section:
+     *     foo:
+     *       some:
+     *         lover: "bar" <- not matched so no comments
+     *         bar: "foobar" # Comment Contents
+     *       other:
+     *         bar: "foobar" # Comment Contents
+     * </pre></blockquote>
+     *
+     * @return The path regexes of this comment
+     */
+    @NotNull
+    String[] regex() default {};
+
+}

features/commentable/src/main/java/cc/carm/lib/configuration/annotation/InlineComments.java

@@ -0,0 +1,15 @@
+package cc.carm.lib.configuration.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface InlineComments {
+
+
+    InlineComment[] value();
+
+}

features/commentable/src/main/java/cc/carm/lib/configuration/commentable/CommentableMeta.java

@@ -0,0 +1,67 @@
+package cc.carm.lib.configuration.commentable;
+
+import cc.carm.lib.configuration.annotation.FooterComments;
+import cc.carm.lib.configuration.annotation.HeaderComments;
+import cc.carm.lib.configuration.annotation.InlineComment;
+import cc.carm.lib.configuration.annotation.InlineComments;
+import cc.carm.lib.configuration.source.ConfigurationHolder;
+import cc.carm.lib.configuration.source.loader.ConfigurationInitializer;
+import cc.carm.lib.configuration.source.meta.ConfigurationMetadata;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.*;
+
+public interface CommentableMeta {
+
+    /**
+     * Configuration's {@link HeaderComments}
+     *
+     * @see HeaderComments
+     */
+    ConfigurationMetadata<List<String>> HEADER = ConfigurationMetadata.of(Collections.emptyList());
+
+    /**
+     * Configuration's footer comments
+     *
+     * @see FooterComments
+     */
+    ConfigurationMetadata<List<String>> FOOTER = ConfigurationMetadata.of(Collections.emptyList());
+
+    /**
+     * Configuration's {@link InlineComment}
+     * <p> Map< regex, comment > , regex is used to match the key, null for current path.
+     *
+     * @see InlineComment
+     */
+    ConfigurationMetadata<Map<String, String>> INLINE = ConfigurationMetadata.of();
+
+
+    static void register(@NotNull ConfigurationHolder<?> provider) {
+        register(provider.initializer());
+    }
+
+    static void register(@NotNull ConfigurationInitializer initializer) {
+        initializer.registerAnnotation(
+                HeaderComments.class, HEADER,
+                a -> Arrays.asList(a.value())
+        );
+        initializer.registerAnnotation(
+                FooterComments.class, FOOTER,
+                a -> Arrays.asList(a.value())
+        );
+        initializer.registerAnnotation(InlineComments.class, INLINE, a -> {
+            Map<String, String> map = new HashMap<>();
+            for (InlineComment comment : a.value()) {
+                if (comment.regex().length == 0) { // for current path
+                    map.put(null, comment.value());
+                    continue;
+                }
+                for (String regex : comment.regex()) { // for specified path
+                    map.put(regex, comment.value());
+                }
+            }
+            return map;
+        });
+    }
+
+}

features/commentable/src/main/java/cc/carm/lib/configuration/option/CommentableOptions.java

@@ -0,0 +1,35 @@
+package cc.carm.lib.configuration.option;
+
+import cc.carm.lib.configuration.source.option.ConfigurationOption;
+
+public interface CommentableOptions {
+
+//    /**
+//     * Whether to keep modified comments in configuration,
+//     * that means we only set comments for values that are not exists in configuration.
+//     */
+//    ConfigurationOption<Boolean> KEEP_COMMENTS = ConfigurationOption.of(true);
+
+    /**
+     * Whether to comment values name that are not exists in configuration and no default value offered.
+     * <br>If true, a value without default value is not exists in configuration, we will comment its name,
+     * <p>e.g. a value named "foo" without default value will be put as:
+     * <blockquote><pre>
+     * # Value comments
+     * # foo:
+     * </pre></blockquote>
+     */
+    ConfigurationOption<Boolean> COMMENT_EMPTY_VALUE = ConfigurationOption.of(false);
+
+
+//    /**
+//     * The resource path of the comment file.
+//     * <p>
+//     * Use this option to specify the path of the comment file,
+//     * which will be used to load comments for the configuration.
+//     * </p>
+//     */
+//    ConfigurationOption<String> COMMENT_RESOURCE = ConfigurationOption.of(String.class, "config-comments");
+
+
+}

features/file/pom.xml

@@ -0,0 +1,50 @@
+<?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">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>cc.carm.lib</groupId>
+        <artifactId>easyconfiguration-parent</artifactId>
+        <version>4.0.0</version>
+        <relativePath>../../pom.xml</relativePath>
+    </parent>
+    <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-feature-file</artifactId>
+    <packaging>jar</packaging>
+
+    <dependencies>
+        <dependency>
+            <groupId>${project.groupId}</groupId>
+            <artifactId>easyconfiguration-core</artifactId>
+            <version>${project.version}</version>
+        </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>