!172 修复简陋的锁定图标

Merge pull request !172 from Sky/release-v1.1.14

.gitee/ISSUE_TEMPLATE/bug.yml

@@ -1,13 +1,13 @@
 name: Bug 反馈
 description: 当你在代码中发现了一个 Bug，导致应用崩溃或抛出异常，或者有一个组件存在问题，或者某些地方看起来不对劲。
 title: "[Bug]: "
-labels: ["bug"]
+labels: [ "bug" ]
 body:
   - type: markdown
     attributes:
       value: |
         感谢对项目的支持与关注。在提出问题之前，请确保你已查看相关开发或使用文档：
-        - https://gitee.com/jcnc-org/docs
+        - https://gitee.com/jcnc-org/docs/blob/master/zh-cn/doc/doc-jnotepad/doc-jnotepad.md
   - type: checkboxes
     attributes:
       label: 这个问题是否已经存在？
@@ -19,6 +19,8 @@ body:
       label: 如何复现
       description: 请详细告诉我们如何复现你遇到的问题，如涉及代码，可提供一个最小代码示例，并使用反引号```附上它
       placeholder: |
+        操作系统：
+        复现步骤：
         1. ...
         2. ...
         3. ...
@@ -48,7 +50,7 @@ body:
       label: 版本
       description: 你当前正在使用我们软件的哪个版本/分支？
       options:
-        - (默认)
-        - (最新)
+        - V1.1.14(最新开发版)
+        - V1.1.13(最新发行版)
     validations:
       required: true

.gitee/ISSUE_TEMPLATE/feature.yml

@@ -1,7 +1,7 @@
 name: 功能建议
 description: 对本项目提出一个功能建议
 title: "[功能建议]: "
-labels: ["enhancement"]
+labels: [ "feature" ]
 body:
   - type: markdown
     attributes:

.gitee/ISSUE_TEMPLATE/refactor.yml

@@ -0,0 +1,12 @@
+name: 重构
+description: 对本项目提出一个功能建议
+title: "[重构]: "
+labels: [ "refactor" ]
+body:
+  - type: textarea
+    id: related-problem
+    attributes:
+      label: 重构目的是什么？
+      description: 清晰并简洁地描述重构是什么，例如，减少文件选择器重复创建代码。
+    validations:
+      required: false

.gitignore

@@ -11,6 +11,13 @@ test/
 ### 此处忽略了json与xml后缀
 *.xml
 *.json
+
+### 此处排除证书目录
+certificate/
+
+### 此处排除项目文件
+.jnotepad/
+
 ### Eclipse ###
 .apt_generated
 .classpath
@@ -47,4 +54,5 @@ logs/
 /en_language_pack.txt
 /jnotepadConfig.json
 /qodana.yaml
-.mvn/
+.mvn/
+/main.c

README.md

@@ -1,11 +1,50 @@
-# JNotepad
+<p align="center">
+  <img src="src/main/resources/jcnc/app/svg/icon.svg" alt="JNotepad Icon">
+<h1 align="center" style="margin: 30px 0 30px; font-weight: bold;">JNotepad</h1>
+<h4 align="center" style="margin: 30px 0 30px; font-weight: bold;">JavaFX开发，插件驱动，创造无限可能</h4>
 
-![](https://img.shields.io/badge/Windows-Passing-49%2C198%2C84.svg?style=falt&logo=Windows)
-![](https://img.shields.io/badge/Ubuntu-Passing-49%2C198%2C84.svg?style=falt&logo=Ubuntu)
-![](https://img.shields.io/badge/MacOS-Passing-49%2C198%2C84.svg?style=falt&logo=Apple)
+<p align="center">
+    <a href='https://gitee.com/jcnc-org/JNotepad/stargazers'><img
+            src='https://gitee.com/jcnc-org/JNotepad/badge/star.svg?theme=dark' alt='star'>
+    </a>
+    <a href='https://gitee.com/jcnc-org/JNotepad/members'><img 
+            src='https://gitee.com/jcnc-org/JNotepad/badge/fork.svg?theme=dark' alt='fork'>
+    </a>
+</p>
+<p align="center">
+    <a href="https://gitee.com/jcnc-org/JNotepad/blob/master/LICENSE">
+        <img src="https://img.shields.io/badge/%20license-GPL--3.0%20-blue" alt="">
+    </a>
+    <a href="https://gitee.com/jcnc-org/JNotepad/blob/master/LICENSE">
+        <img src="https://img.shields.io/badge/version-v1.1.13-blue" alt="">
+    </a>
+</p>
+<p align="center">
+    <a href="https://gitee.com/jcnc-org/JNotepad/releases">
+        <img src="https://img.shields.io/badge/Windows-Passing-49%2C198%2C84.svg?style=falt&logo=Windows" alt="">
+    </a>
+    <a href="https://gitee.com/jcnc-org/JNotepad/releases">
+        <img src="https://img.shields.io/badge/Ubuntu-Passing-49%2C198%2C84.svg?style=falt&logo=Ubuntu" alt="">
+    </a>
+    <a href="https://gitee.com/jcnc-org/JNotepad/releases">
+        <img src="https://img.shields.io/badge/MacOS-Passing-49%2C198%2C84.svg?style=falt&logo=Apple" alt="">
+    </a>
+</p>
 
 
-JNotepad(Java Notepad)是一款简约而强大的跨平台文本编辑器，旨在提供用户友好的界面和丰富的功能。无论你是在Linux、Windows还是macOS系统上使用，JNotepad都能满足你对文本编辑和查看的需求。 JNotepad使用Java语言编写，并基于JavaFX框架开发，具有良好的可扩展性和稳定性。
+[jnotepad-official-plugins]:https://gitee.com/jcnc-org/jnotepad-official-plugins
+[jcnc-docs]:https://gitee.com/jcnc-org/docs
+
+
+| 序号  | 相关仓库          |  链接地址                              |
+|:---: | :---------------: |  :-----------------------------------:|
+|1     | JNotepad插件仓库   | [点击访问][jnotepad-official-plugins]  |
+|2     | JCNC文档仓库       | [点击访问][jcnc-docs]                  |
+
+JNotepad(Java Notepad)
+是一款简约而强大的跨平台文本编辑器，旨在提供用户友好的界面和丰富的功能以及插件化使用。无论你是在Linux、Windows还是macOS系统上使用，JNotepad都能满足你对文本编辑和查看的需求。
+JNotepad使用Java语言编写，并基于JavaFX框架开发，具有良好的可扩展性和稳定性。
+
 ## 功能介绍
 
 - 文本编辑和查看：JNotepad提供了完善的文本编辑和查看功能，使你能够轻松创建、编辑和浏览各种类型的文本文件。
@@ -16,65 +55,86 @@ JNotepad(Java Notepad)是一款简约而强大的跨平台文本编辑器，旨
 
 - 基于Java：JNotepad使用Java语言编写，并基于JavaFX框架开发，具有良好的可扩展性和稳定性。
 
-
 ## 安装教程
 
-1.  Windows 平台，可以直接使用我编译好的可执行程序或自己编译
+1. Windows 平台，可以直接使用编译的可执行程序或自己编译
 
 [gitee-download]: https://gitee.com/jcnc-org/JNotepad/releases
+
 [java-download]: https://www.oracle.com/cn/java/technologies/downloads/
-[qq-url]: http://qm.qq.com/cgi-bin/qm/qr?_wv=1027&k=zOfwWb1lcle68cbEdJCjSIp3Itx0nEC0&authKey=bOsZFT9OVYZpZQbS6IYO4onBQoeBorF5nanMEi1G%2FgPbzmUkOweXBo9qB0G34R5K&noverify=0&group_code=386279455
-
 
+[docs-url]: https://gitee.com/jcnc-org/docs
 
 - [下载][gitee-download]
 
 2. Linux/MacOS 平台，查看入门指南
 
-
 ## 入门指南
 
 要使用 JNotepad，请按照以下步骤进行:
 
 1. 下载并安装 Java（如果尚未安装）。
+
 - [下载][gitee-download]
 
 2. 克隆或下载 JNotepad 项目。
+
 <pre><code>git clone https://gitee.com/jcnc-org/JNotepad.git</code></pre>
+
 3. 在您偏好的 Java IDE 中打开项目。
 
 ## 使用方法
 
 1. 运行 `JNotepad` 类以启动应用程序。
-2. 主窗口将显示菜单栏、标签区域和状态栏。
+2. 主窗口将显示菜单栏、标签区域和状态栏等。
 3. 使用菜单栏执行各种操作：
-  - `文件 > 新建`：创建一个带有空白文本区域的新标签。
-  - `文件 > 打开`：打开现有文本文件进行编辑。
-  - `文件 > 保存`：将当前活动标签的内容保存到关联文件中。
-  - `文件 > 另存为`：将当前活动标签的内容保存为新文件。
-4. 在每个标签的文本区域中编辑内容。
-5. 状态栏将显示有关光标位置和文本统计信息的信息。
+
+- `文件 > 新建`：创建一个带有空白文本区域的新标签。
+- `文件 > 打开`：打开现有文本文件进行编辑。
+- `文件 > 保存`：将当前活动标签的内容保存到关联文件中。
+- `文件 > 另存为`：将当前活动标签的内容保存为新文件。
+- `文件 > 重命名`：将当前活动标签的内容重命名。
+
+
+- `设置 > 自动换行`：打开当前文本自动换行。
+- `设置 > 打开配置文件`：打开JNotepad的配置文件实现配置快捷键和其他功能。
+- `设置 > 窗口置顶`：将程序主仓库置顶。
+- `设置 > 语言`：切换语言。
+
+
+- `插件 > 增加插件`：管理插件系统。
 
 ## 依赖项
 
-    <dependencies>
-        <dependency>
-            <groupId>org.openjfx</groupId>
-            <artifactId>javafx-controls</artifactId>
-            <version>17.0.1</version>
-        </dependency>
-    <dependencies>
- ## 软件运行截图
+POM文件中的全部依赖项：
+
+| 组ID                        | 工件ID                       | 版本     | 功能描述                                                         |
+|----------------------------|----------------------------|--------|--------------------------------------------------------------|
+| org.kordamp.ikonli         | ikonli-javafx              | 12.3.1 | 提供JavaFX应用程序中的图标集成。                                          |
+| org.kordamp.ikonli         | ikonli-antdesignicons-pack | 12.3.1 | 包含Ant Design图标集的Ikonli图标包。                                   |
+| io.github.mkpaz            | atlantafx-base             | 2.0.1  | 提供Atlantafx库的基本功能。                                           |
+| org.openjfx                | javafx-fxml                | 20.0.2 | JavaFX的FXML模块，用于构建用户界面。                                      |
+| org.junit.jupiter          | junit-jupiter-api          | 5.9.2  | 用于JUnit 5测试框架的API。                                           |
+| com.fasterxml.jackson.core | jackson-databind           | 2.15.2 | 用于JSON数据的序列化和反序列化。                                           |
+| org.slf4j                  | slf4j-api                  | 2.0.7  | 简单日志门面，用于处理日志记录。                                             |
+| ch.qos.logback             | logback-core               | 1.4.11 | Logback的核心组件，用于日志记录。                                         |
+| ch.qos.logback             | logback-classic            | 1.4.11 | Logback的经典模块，提供日志记录功能。                                       |
+| com.ibm.icu                | icu4j                      | 73.2   | ICU（International Components for Unicode）库，用于处理Unicode字符和文本。 |
+
+## 软件运行截图
+
 - Windows 平台
   ![Windows](screenshot/windows-1.png)
-- MacOS 平台   
-  ![MacOS](screenshot/Mac0S-1.png)
 
-### 参与贡献
+- MacOS 平台
+  ![MacOS](screenshot/MacOS-1.png)
+
+- Linux 平台   
+  ![Linux](screenshot/Linux-1.png)
+
+# 参与贡献
 
-1. Fork 本仓库
 1. 加入JCNC社区
-1. [加入QQ群:386279455][qq-url]
-1. 新建分支
-1. 提交代码
-1. 新建 Pull Request
+2. [阅读JCNC开发者文档][docs-url]
+3. 加入QQ群:386279455
+4. 联系微信:xuxiaolankaka 加入群聊

docs/开发指南.md

@@ -1,19 +1,31 @@
 # 1. 开发流程
+
 基于**AoneFlow**开发流程，具体请阅读：[在阿里，我们如何管理代码分支？](https://developer.aliyun.com/article/573549)
+
 ## 1.1 IDEA IDE版
-###  步骤一 Fork JCNC/JNotepad或同步JCNC/JNotepad到个人仓库
+
+### 步骤一 Fork JCNC/JNotepad或同步JCNC/JNotepad到个人仓库
+
 #### 首次开发，进行Fork操作
+
 ![输入图片说明](https://foruda.gitee.com/images/1693230738686081312/d1f9178e_341872.png "屏幕截图")
+
 #### 非首次开发，进行同步操作
+
 ![输入图片说明](https://foruda.gitee.com/images/1693230711005054075/9d8adb17_341872.png "屏幕截图")
 
 ### 步骤二 clone个人仓库或fetch
+
 #### 首次开发，clone个人仓库
+
 ![输入图片说明](https://foruda.gitee.com/images/1693230809903750175/da0d73b5_341872.png "屏幕截图")
+
 #### 非首次开发，执行fetch
+
 ![输入图片说明](https://foruda.gitee.com/images/1693231554501661630/308a9783_341872.png "屏幕截图")
 
 ### 步骤三 从remote下的master分支创建本地开发分支。
+
 **特殊情况：开发依赖release分支已提交内容，或是对已提交内容进行修改，那么需要从release分支上进行拉取。**
 ![输入图片说明](https://foruda.gitee.com/images/1693231016998001511/7a6a6f3d_341872.png "屏幕截图")
 ![输入图片说明](https://foruda.gitee.com/images/1693231347247142683/17ff5fd4_341872.png "屏幕截图")
@@ -23,12 +35,15 @@
 ### 步骤四 推送本地分支到远程
 
 ### 步骤五 发起Pull Request（PR）
+
 ![输入图片说明](https://foruda.gitee.com/images/1693232191273920333/65665291_341872.png "屏幕截图")
 
 **注意：目标分支选择预期要发布的release分支**
 
 ## 1.2 GIT命令行版本
+
 步骤一、步骤二、步骤五同1.1操作
+
 ```shell
 # 步骤三
 git fetch
@@ -38,24 +53,28 @@ git push origin feature-demo
 ```
 
 ## 1.3 分支命名规则
-|issue类别|分支名格式|示例|
-|--------|--------|----|
-|功能/优化/文档修改|feature-issue编号|feature-I7W9LX|
-|bug fix| fix-issue编号| fix-I7W9LX|
-|代码重构|refactor-issue编号|refactor-I7W9LX|
+
+| issue类别    | 分支名格式            | 示例              |
+|------------|------------------|-----------------|
+| 功能/优化/文档修改 | feature-issue编号  | feature-I7W9LX  |
+| bug fix    | fix-issue编号      | fix-I7W9LX      |
+| 代码重构       | refactor-issue编号 | refactor-I7W9LX |
 
 # 2. IDEA插件配置
+
 * 安装Resource Bundle插件
   ![输入图片说明](https://foruda.gitee.com/images/1693125995274955090/9efa2d4c_341872.png "屏幕截图")
 * 安装成功后，打开i18n.properties，可以看到Resource Bundle tab
   ![输入图片说明](https://foruda.gitee.com/images/1693126057242554469/10667419_341872.png "屏幕截图")
 
 # Q&A
+
 Q: 本地开发时，主仓库合并了新代码，如何处理？    
 A: 继续完成本地开发，发起PR时再解决冲突。
 
 Q: 解决冲突步骤是什么？    
 A: 一般按如下步骤。
+
 1. 先同步主仓库
 2. 本地仓库进行fetch
 3. 本地开发分支merge/pull/rebase更新的release分支

libs/README.md

@@ -40,4 +40,5 @@ jar uf libs/icu4j-73.2.jar -C libs/tmpOut/com.ibm.icu module-info.class
 ```
 
 ## Reference
+
 1. [java_jlink_automatic_module_cannot_be_used_with_jlink](https://tacosteemers.com/articles/java_jlink_automatic_module_cannot_be_used_with_jlink.html)

pom.xml

@@ -1,21 +1,59 @@
 <?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"
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns="http://maven.apache.org/POM/4.0.0"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
     <groupId>org.jcnc</groupId>
     <artifactId>JNotepad</artifactId>
-    <version>1.0-SNAPSHOT</version>
+    <version>1.0.14-alpha</version>
     <name>JNotepad</name>
+    <packaging>jar</packaging>
 
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <junit.version>5.9.2</junit.version>
+        <javafx.version>20.0.2</javafx.version>
     </properties>
-
-
     <dependencies>
+        <!-- https://mvnrepository.com/artifact/org.fxmisc.richtext/richtextfx -->
+        <!--JavaFX 的富文本区域-->
+        <dependency>
+            <groupId>org.fxmisc.richtext</groupId>
+            <artifactId>richtextfx</artifactId>
+            <version>0.11.1</version>
+            <scope>system</scope>
+            <systemPath>${project.basedir}/libs/richtextfx-fat-0.11.1.jar</systemPath>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/org.commonmark/commonmark -->
+        <dependency>
+            <groupId>org.commonmark</groupId>
+            <artifactId>commonmark</artifactId>
+            <version>0.21.0</version>
+            <scope>system</scope>
+            <systemPath>${project.basedir}/libs/commonmark-0.21.0.jar</systemPath>
+        </dependency>
+
+        <dependency>
+            <groupId>org.openjfx</groupId>
+            <artifactId>javafx-web</artifactId>
+            <version>${javafx.version}</version>
+        </dependency>
+
+
+        <!--图标库主依赖-->
+        <dependency>
+            <groupId>org.kordamp.ikonli</groupId>
+            <artifactId>ikonli-javafx</artifactId>
+            <version>12.3.1</version>
+        </dependency>
+        <!--蚂蚁图标库-->
+        <dependency>
+            <groupId>org.kordamp.ikonli</groupId>
+            <artifactId>ikonli-antdesignicons-pack</artifactId>
+            <version>12.3.1</version>
+        </dependency>
+        <!--亚特兰大fx主题-->
         <dependency>
             <groupId>io.github.mkpaz</groupId>
             <artifactId>atlantafx-base</artifactId>
@@ -24,7 +62,12 @@
         <dependency>
             <groupId>org.openjfx</groupId>
             <artifactId>javafx-fxml</artifactId>
-            <version>17.0.1</version>
+            <version>${javafx.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjfx</groupId>
+            <artifactId>javafx-controls</artifactId>
+            <version>${javafx.version}</version>
         </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
@@ -36,7 +79,7 @@
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
-            <version>2.12.7.1</version>
+            <version>2.15.2</version>
         </dependency>
         <!--log-->
         <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
@@ -56,6 +99,7 @@
             <artifactId>logback-classic</artifactId>
             <version>1.4.11</version>
         </dependency>
+        <!--国际化依赖-->
         <dependency>
             <groupId>com.ibm.icu</groupId>
             <artifactId>icu4j</artifactId>
@@ -85,9 +129,8 @@
                         <!-- Default configuration for running with: mvn clean javafx:run -->
                         <id>default-cli</id>
                         <configuration>
-                            <mainClass>org.jcnc.jnotepad/org.jcnc.jnotepad.LunchApp</mainClass>
+                            <mainClass>org.jcnc.jnotepad/org.jcnc.jnotepad.JnotepadApp</mainClass>
                             <launcher>JNotepad</launcher>
-                            <jlinkZipName>JNotepad</jlinkZipName>
                             <jlinkImageName>JNotepad</jlinkImageName>
                             <noManPages>true</noManPages>
                             <stripDebug>true</stripDebug>
@@ -97,6 +140,41 @@
                     </execution>
                 </executions>
             </plugin>
+            <plugin>
+                <groupId>com.gluonhq</groupId>
+                <artifactId>gluonfx-maven-plugin</artifactId>
+                <version>1.0.19</version>
+                <configuration>
+                    <mainClass>org.jcnc.jnotepad/org.jcnc.jnotepad.JnotepadApp</mainClass>
+                    <reflectionList>
+                        org.jcnc.jnotepad.app.config.UserConfig,org.jcnc.jnotepad.app.config.UserConfig$ShortcutKey
+                    </reflectionList>
+                    <bundlesList>
+                        i18n/i18n
+                    </bundlesList>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.2.4</version>
+                <configuration>
+                    <transformers>
+                        <transformer
+                                implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
+                    </transformers>
+                </configuration>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
         </plugins>
     </build>
+
+
 </project>

src/main/java/module-info.java

@@ -12,15 +12,42 @@ module org.jcnc.jnotepad {
     requires ch.qos.logback.core;
     requires ch.qos.logback.classic;
     requires com.ibm.icu;
-    exports org.jcnc.jnotepad.app.config;
+    requires org.kordamp.ikonli.core;
+    requires org.kordamp.ikonli.javafx;
+    requires org.kordamp.ikonli.antdesignicons;
+    requires richtextfx.fat;
+    requires java.desktop;
+    requires org.commonmark;
+    requires javafx.web;
+
     exports org.jcnc.jnotepad;
-    exports org.jcnc.jnotepad.tool;
-    exports org.jcnc.jnotepad.Interface;
-    exports org.jcnc.jnotepad.controller.event.handler;
+    exports org.jcnc.jnotepad.model.enums;
+    exports org.jcnc.jnotepad.app.config;
+    exports org.jcnc.jnotepad.app.i18n;
+    exports org.jcnc.jnotepad.app.common.constants;
+    exports org.jcnc.jnotepad.controller.config;
     exports org.jcnc.jnotepad.controller.manager;
-    exports org.jcnc.jnotepad.view.manager;
-    exports org.jcnc.jnotepad.constants;
-    exports org.jcnc.jnotepad.ui;
     exports org.jcnc.jnotepad.controller.i18n;
+    exports org.jcnc.jnotepad.controller.event.handler.toolbar;
+    exports org.jcnc.jnotepad.controller.event.handler.menuitem;
+    exports org.jcnc.jnotepad.ui.component.module.interfaces;
     opens org.jcnc.jnotepad.app.config;
+    exports org.jcnc.jnotepad.controller.plugin.interfaces;
+    exports org.jcnc.jnotepad.ui.views.root.bottom.function;
+
+    exports org.jcnc.jnotepad.ui.component.module;
+    exports org.jcnc.jnotepad.model.entity;
+    exports org.jcnc.jnotepad.ui.views.root.bottom;
+    exports org.jcnc.jnotepad.ui.views.root.bottom.status;
+    exports org.jcnc.jnotepad.api.core.views.sidebar.bottom;
+    exports org.jcnc.jnotepad.api.core.controller.config;
+    exports org.jcnc.jnotepad.ui.component.module.base;
+    exports org.jcnc.jnotepad.ui.component.stage.setting;
+    exports org.jcnc.jnotepad.ui.component.module.vbox;
+    exports org.jcnc.jnotepad.ui.component.module.hbox;
+    exports org.jcnc.jnotepad.ui.component.stage.topmenu.help;
+    exports org.jcnc.jnotepad.ui.component.stage.topmenu.plugin;
+    exports org.jcnc.jnotepad.ui.component.module.vbox.components;
+    exports org.jcnc.jnotepad.ui.views.root.center.main.center.tab;
+
 }

src/main/java/org/jcnc/jnotepad/Interface/ControllerInterface.java

@@ -1,30 +0,0 @@
-package org.jcnc.jnotepad.Interface;
-
-import org.jcnc.jnotepad.ui.LineNumberTextArea;
-
-import java.io.File;
-import java.util.List;
-
-/**
- * 控制器接口类
- *
- * @author 许轲
- */
-public interface ControllerInterface {
-
-    /**
-     * 打开关联文件并创建 TextArea
-     *
-     * @param rawParameters 原始参数列表
-     * @return 创建的 TextArea
-     */
-    void openAssociatedFileAndCreateTextArea(List<String> rawParameters);
-
-    /**
-     * 打开关联文件
-     *
-     * @param filePath 文件路径
-     */
-    void openAssociatedFile(String filePath);
-
-}

src/main/java/org/jcnc/jnotepad/JnotepadApp.java

@@ -0,0 +1,55 @@
+package org.jcnc.jnotepad;
+
+import javafx.application.Application;
+import javafx.stage.Stage;
+import org.jcnc.jnotepad.app.manager.ApplicationManager;
+import org.jcnc.jnotepad.app.utils.LoggerUtil;
+
+
+/**
+ * 启动程序类
+ *
+ * <p>该类用于启动 JNotepad 记事本应用程序。</p>
+ *
+ * @author 许轲
+ */
+public class JnotepadApp extends Application {
+    private static final ApplicationManager APPLICATION_MANAGER = ApplicationManager.getInstance();
+
+    /**
+     * 应用程序的入口点，启动 JavaFX 应用程序。
+     *
+     * @param args 命令行参数
+     */
+    public static void main(String[] args) {
+        launch(args);
+    }
+
+    @Override
+    public void init() {
+        // 获取当前启动位置a
+        String currentWorkingDirectory = System.getProperty("user.dir");
+        LoggerUtil.getLogger(this.getClass()).info("当前启动位置：{}", currentWorkingDirectory);
+        // 设置参数
+        APPLICATION_MANAGER.setApplication(this);
+    }
+
+    @Override
+    public void start(Stage primaryStage) {
+        APPLICATION_MANAGER.setPrimaryStage(primaryStage);
+        // 加载应用程序资源
+        APPLICATION_MANAGER.loadAppResources();
+        // 加载应用程序缓存
+        APPLICATION_MANAGER.loadAppCache();
+        // 初始化应用程序
+        APPLICATION_MANAGER.initializeApp();
+        // 初始化默认操作
+        APPLICATION_MANAGER.executeDefaultAction();
+        primaryStage.show();
+    }
+
+    @Override
+    public void stop() {
+        APPLICATION_MANAGER.operationBeforeStopping();
+    }
+}

src/main/java/org/jcnc/jnotepad/LunchApp.java

@@ -1,80 +0,0 @@
-package org.jcnc.jnotepad;
-
-
-import atlantafx.base.theme.PrimerLight;
-import javafx.application.Application;
-import javafx.scene.Scene;
-import javafx.scene.image.Image;
-import javafx.scene.layout.Pane;
-import javafx.stage.Stage;
-import org.jcnc.jnotepad.app.i18n.UIResourceBundle;
-import org.jcnc.jnotepad.constants.AppConstants;
-import org.jcnc.jnotepad.constants.TextConstants;
-import org.jcnc.jnotepad.controller.i18n.LocalizationController;
-import org.jcnc.jnotepad.controller.manager.Controller;
-import org.jcnc.jnotepad.manager.ThreadPoolManager;
-import org.jcnc.jnotepad.view.manager.ViewManager;
-
-import java.util.List;
-import java.util.Objects;
-import java.util.concurrent.ExecutorService;
-
-
-/**
- * 启动程序
- *
- * @author 许轲
- */
-public class LunchApp extends Application {
-    /**
-     * 线程池
-     */
-    private final ExecutorService threadPool = ThreadPoolManager.getThreadPool();
-    Controller controller = Controller.getInstance();
-    Scene scene;
-
-    @Override
-    public void start(Stage primaryStage) {
-        Pane root = new Pane();
-        double width = AppConstants.SCREEN_WIDTH;
-        double length = AppConstants.SCREEN_LENGTH;
-        String icon = AppConstants.APP_ICON;
-        scene = new Scene(root, width, length);
-        Application.setUserAgentStylesheet(new PrimerLight().getUserAgentStylesheet());
-        scene.getStylesheets().add(Objects.requireNonNull(getClass().getResource("/css/styles.css")).toExternalForm());
-        initUIComponents();
-
-
-        UIResourceBundle.bindStringProperty(primaryStage.titleProperty(), TextConstants.TITLE);
-        primaryStage.setWidth(width);
-        primaryStage.setHeight(length);
-        primaryStage.setScene(scene);
-        primaryStage.getIcons().add(new Image(Objects.requireNonNull(getClass().getResource(icon)).toString()));
-        primaryStage.show();
-    }
-
-    private void initUIComponents() {
-
-        //1. 加载语言
-        LocalizationController.initLocal();
-
-        //2. 加载组件
-        ViewManager viewManager = ViewManager.getInstance(scene);
-        viewManager.initScreen(scene);
-
-        // 使用线程池加载关联文件并创建文本区域
-        List<String> rawParameters = getParameters().getRaw();
-        controller.openAssociatedFileAndCreateTextArea(rawParameters);
-    }
-
-    @Override
-    public void stop() {
-        // 关闭线程池
-        threadPool.shutdownNow();
-    }
-
-    public static void main(String[] args) {
-        launch(args);
-    }
-
-}

src/main/java/org/jcnc/jnotepad/api/core/component/stage/AbstractPaneStage.java

@@ -0,0 +1,70 @@
+package org.jcnc.jnotepad.api.core.component.stage;
+
+import javafx.scene.Scene;
+import javafx.scene.image.Image;
+import javafx.scene.layout.BorderPane;
+import javafx.stage.Modality;
+import javafx.stage.Stage;
+
+/**
+ * 抽象窗格舞台。
+ * <p>
+ * 该类是一个抽象的窗格舞台，用于创建自定义的JavaFX窗口。
+ * </p>
+ *
+ * @author gewuyou
+ */
+public abstract class AbstractPaneStage extends BorderPane {
+    private final Stage stage = new Stage();
+
+    /**
+     * 获取舞台图标。
+     *
+     * @return 舞台图标
+     */
+    protected abstract Image getStageIcon();
+
+    /**
+     * 获取舞台标题。
+     *
+     * @return 舞台标题
+     */
+    protected abstract String getStageTitle();
+
+    /**
+     * 获取自定义舞台场景。
+     *
+     * @return 舞台场景
+     */
+    protected abstract Scene getCustomizationScene();
+
+    /**
+     * 初始化方法。
+     * <p>
+     * 在此方法中，您可以进行与窗口相关的初始化操作。
+     * </p>
+     */
+    protected abstract void initialize();
+
+    /**
+     * 自定义启动方法。
+     *
+     * @param stage 自定义舞台
+     */
+    public abstract void run(Stage stage);
+
+    /**
+     * 启动方法。
+     * <p>
+     * 该方法设置窗口的图标、标题、场景，并将窗口设置为模态对话框，然后显示窗口。
+     * </p>
+     */
+    public void run() {
+        stage.getIcons().add(getStageIcon());
+        stage.setTitle(getStageTitle());
+        stage.setScene(getCustomizationScene());
+        // 设置为模态
+        stage.initModality(Modality.APPLICATION_MODAL);
+        stage.show();
+    }
+}

src/main/java/org/jcnc/jnotepad/api/core/controller/config/BaseConfigController.java

@@ -0,0 +1,135 @@
+package org.jcnc.jnotepad.api.core.controller.config;
+
+import org.jcnc.jnotepad.api.core.controller.interfaces.ConfigController;
+import org.jcnc.jnotepad.app.utils.JsonUtil;
+import org.jcnc.jnotepad.app.utils.LoggerUtil;
+import org.jcnc.jnotepad.app.utils.PopUpUtil;
+import org.jcnc.jnotepad.controller.exception.AppException;
+import org.slf4j.Logger;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+/**
+ * 抽象基本配置文件控制器类。
+ * <p>
+ * 该类是基本配置文件控制器的抽象实现，提供了加载、持久化配置文件以及其他相关方法。
+ * </p>
+ *
+ * @param <T> 配置文件类型
+ * @author gewuyou
+ */
+public abstract class BaseConfigController<T> implements ConfigController<T> {
+
+    protected static final String ROOT_CONFIG_DIR = "config";
+
+    protected static final String SYSTEM_CONFIG_DIR = "system";
+    private final Logger logger = LoggerUtil.getLogger(getClass());
+    protected T config;
+
+    /**
+     * 获取配置文件Class类。
+     *
+     * @return 配置文件Class类
+     */
+    protected abstract Class<T> getConfigClass();
+
+    /**
+     * 获取配置文件名称。
+     *
+     * @return 配置文件名称
+     */
+    protected abstract String getConfigName();
+
+    /**
+     * 获取配置文件文件夹路径。
+     *
+     * @return 配置文件夹路径
+     */
+    protected abstract String getConfigDir();
+
+    /**
+     * 获取配置文件对象。
+     *
+     * @return 配置文件对象
+     */
+    public T getConfig() {
+        return config;
+    }
+
+    /**
+     * 加载配置文件内容。
+     */
+    @Override
+    public void loadConfig() {
+        createConfigIfNotExists();
+        // 存在则加载
+        try {
+            logger.info("正在加载配置文件: {}...", getConfigClass());
+            String configContent = Files.readString(getConfigPath());
+            config = JsonUtil.OBJECT_MAPPER.readValue(configContent, getConfigClass());
+        } catch (IOException e) {
+            logger.error("加载配置文件错误", e);
+            PopUpUtil.errorAlert("错误", "读写错误", "加载配置文件错误!", null, null);
+            throw new AppException(e);
+        }
+    }
+
+    /**
+     * 配置文件持久化。
+     */
+    @Override
+    public void writeConfig() {
+        createConfigIfNotExists();
+        writeConfig(getConfig());
+    }
+
+    /**
+     * 配置文件持久化。
+     *
+     * @param config 配置文件对象
+     */
+    @Override
+    public void writeConfig(T config) {
+        try (BufferedWriter writer = new BufferedWriter(new FileWriter(getConfigPath().toString()))) {
+            if (config == null) {
+                config = generateDefaultConfig();
+            }
+            writer.write(JsonUtil.toJsonString(config));
+        } catch (Exception e) {
+            logger.error("", e);
+            PopUpUtil.errorAlert("错误", "读写错误", "配置文件读写错误!", null, null);
+        }
+    }
+
+    /**
+     * 如果配置文件不存在则创建。
+     */
+    @Override
+    public void createConfigIfNotExists() {
+        Path configPath = getConfigPath();
+        if (configPath.toFile().exists()) {
+            return;
+        }
+        File directory = new File(getConfigDir());
+        if (!directory.exists()) {
+            directory.mkdirs();
+        }
+        writeConfig(null);
+    }
+
+    /**
+     * 获取配置文件路径。
+     *
+     * @return 配置文件路径
+     */
+    @Override
+    public Path getConfigPath() {
+        return Paths.get(getConfigDir(), getConfigName());
+    }
+}

src/main/java/org/jcnc/jnotepad/api/core/controller/interfaces/ConfigController.java

@@ -0,0 +1,69 @@
+package org.jcnc.jnotepad.api.core.controller.interfaces;
+
+import java.nio.file.Path;
+
+/**
+ * 配置文件控制器接口
+ * <p>
+ * 该接口定义了配置文件相关的操作，包括加载、持久化、创建和获取配置文件路径等。
+ * </p>
+ *
+ * @param <T> 配置文件类型
+ * @author gewuyou
+ */
+public interface ConfigController<T> {
+    /**
+     * 加载配置文件内容
+     * <p>
+     * 从配置文件中加载配置信息。
+     * </p>
+     */
+    void loadConfig();
+
+    /**
+     * 配置文件持久化
+     * <p>
+     * 将配置信息持久化到配置文件中。
+     * </p>
+     */
+    void writeConfig();
+
+    /**
+     * 配置文件持久化
+     * <p>
+     * 将指定的配置对象持久化到配置文件中。
+     * </p>
+     *
+     * @param config 配置文件对象
+     */
+    void writeConfig(T config);
+
+    /**
+     * 如果配置文件不存在则创建
+     * <p>
+     * 在需要的情况下创建配置文件，如果配置文件已存在，则不执行任何操作。
+     * </p>
+     */
+    void createConfigIfNotExists();
+
+    /**
+     * 创建配置文件实体
+     * <p>
+     * 生成默认的配置文件实体对象，用于后续的序列化操作。
+     * </p>
+     *
+     * @return 默认的配置文件实体
+     * @apiNote 返回默认的配置文件实体用于序列化 JSON 数据。
+     */
+    T generateDefaultConfig();
+
+    /**
+     * 获取配置文件路径
+     * <p>
+     * 返回配置文件的路径。
+     * </p>
+     *
+     * @return 配置文件路径
+     */
+    Path getConfigPath();
+}

src/main/java/org/jcnc/jnotepad/api/core/manager/AbstractCacheManager.java

@@ -0,0 +1,118 @@
+package org.jcnc.jnotepad.api.core.manager;
+
+import org.jcnc.jnotepad.model.entity.Cache;
+
+import java.util.Map;
+
+/**
+ * 抽象缓存管理类
+ *
+ * <p>
+ * 该类是缓存管理的抽象基类，用于管理不同类型的缓存。
+ * </p>
+ *
+ * @author gewuyou
+ */
+public abstract class AbstractCacheManager {
+    /**
+     * 缓存集合
+     */
+    protected Map<String, Cache> caches;
+
+    /**
+     * 获取全局命名空间
+     *
+     * @return 全局命名空间
+     */
+    public abstract String getGlobalNamespace();
+
+    /**
+     * 创建缓存类
+     *
+     * @param group          缓存组
+     * @param name           缓存名称
+     * @param cacheData      缓存数据
+     * @param expirationTime 过期时间
+     * @return 缓存类
+     * @apiNote 这个方法，只需通过自定义的缓存管理类调用此方法，无需每次指定相同地命名空间
+     */
+    public Cache createCache(String group, String name, Object cacheData, Long expirationTime) {
+        return new Cache(getGlobalNamespace(), group, name, cacheData, expirationTime);
+    }
+
+    /**
+     * 获取缓存集合
+     *
+     * @return 缓存集合
+     */
+    public Map<String, Cache> getCaches() {
+        return caches;
+    }
+
+    /**
+     * 设置缓存集合
+     *
+     * @param caches 缓存集合
+     */
+    public void setCaches(Map<String, Cache> caches) {
+        this.caches = caches;
+    }
+
+    /**
+     * 添加缓存
+     *
+     * @param cache 缓存
+     */
+    public void addCache(Cache cache) {
+        String cacheKey = cache.getCacheKey();
+        // 如果集合中已存在该缓存，则更新读写时间
+        if (caches.containsKey(cacheKey)) {
+            cache.setLastReadOrWriteTime(System.currentTimeMillis());
+        }
+        caches.put(cacheKey, cache);
+    }
+
+    /**
+     * 获取缓存类
+     *
+     * @param cacheKey 缓存key
+     * @return 缓存类
+     */
+    public Cache getCache(String cacheKey) {
+        if (caches == null || caches.isEmpty()) {
+            return null;
+        }
+        if (caches.containsKey(cacheKey)) {
+            Cache cache = caches.get(cacheKey);
+            cache.setLastReadOrWriteTime(System.currentTimeMillis());
+            return cache;
+        }
+        return null;
+    }
+
+    /**
+     * 获取缓存类
+     *
+     * @param group 组
+     * @param name  缓存名
+     * @return 缓存类
+     */
+    public Cache getCache(String group, String name) {
+        return getCache(Cache.getCacheKey(getGlobalNamespace(), group, name));
+    }
+
+    /**
+     * 获取缓存数据
+     *
+     * @param group 组
+     * @param name  缓存名
+     * @return 缓存类
+     */
+    public Object getCacheData(String group, String name) {
+        Cache cache = getCache(group, name);
+        if (cache == null) {
+            return null;
+        }
+        return cache.getCacheData();
+    }
+}

src/main/java/org/jcnc/jnotepad/api/core/views/manager/AbstractManager.java

@@ -0,0 +1,22 @@
+package org.jcnc.jnotepad.api.core.views.manager;
+
+import java.util.List;
+
+/**
+ * 抽象管理类
+ *
+ * @author gewuyou
+ */
+public abstract class AbstractManager<T> {
+
+    /**
+     * 获取节点列表
+     *
+     * @return 节点列表
+     */
+    public abstract List<T> getNodeList();
+
+    public void registerNode(T node) {
+        getNodeList().add(node);
+    }
+}

src/main/java/org/jcnc/jnotepad/api/core/views/manager/builder/BottomStatusBoxButtonBuilder.java

@@ -0,0 +1,46 @@
+package org.jcnc.jnotepad.api.core.views.manager.builder;
+
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.scene.control.Button;
+import org.kordamp.ikonli.javafx.FontIcon;
+
+import java.util.Optional;
+
+/**
+ * 下方状态栏按钮建造者
+ *
+ * @author gewuyou
+ */
+public class BottomStatusBoxButtonBuilder {
+    private Button button;
+
+    private FontIcon fontIcon;
+
+    private EventHandler<ActionEvent> eventHandler;
+
+    public BottomStatusBoxButtonBuilder() {
+    }
+
+    public BottomStatusBoxButtonBuilder(Button button) {
+        this.button = button;
+    }
+
+    public BottomStatusBoxButtonBuilder setFontIcon(FontIcon fontIcon) {
+        this.fontIcon = fontIcon;
+        return this;
+    }
+
+    public BottomStatusBoxButtonBuilder setEventHandler(EventHandler<ActionEvent> eventHandler) {
+        this.eventHandler = eventHandler;
+        return this;
+    }
+
+    public Button build() {
+        Optional<Button> container = Optional.ofNullable(button);
+        button = container.orElseGet(Button::new);
+        button.setGraphic(fontIcon);
+        button.setOnAction(eventHandler);
+        return button;
+    }
+}

src/main/java/org/jcnc/jnotepad/api/core/views/manager/builder/SideBarButtonBuilder.java

@@ -0,0 +1,74 @@
+package org.jcnc.jnotepad.api.core.views.manager.builder;
+
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.scene.control.Button;
+import javafx.scene.image.ImageView;
+
+import java.util.Optional;
+
+/**
+ * 侧边栏按钮建造者
+ *
+ * @author gewuyou
+ */
+public class SideBarButtonBuilder {
+    private Button button;
+    private ImageView imageView;
+    private EventHandler<ActionEvent> eventHandler;
+
+    public Button build() {
+        Optional<Button> container = Optional.ofNullable(button);
+        button = container.orElseGet(Button::new);
+        button.setGraphic(imageView);
+        button.setOnAction(eventHandler);
+        return button;
+    }
+
+    public SideBarButtonBuilder setImageView(ImageView imageView) {
+        this.imageView = imageView;
+        return this;
+    }
+
+    public SideBarButtonBuilder setButtonEssentialAttribute(Double relativelyPrefWidth, Double relativelyPrefHeight) {
+        Optional<Double> container = Optional.ofNullable(relativelyPrefHeight);
+        button.setPrefWidth(imageView.getFitWidth() + container.orElse(20D));
+        container = Optional.ofNullable(relativelyPrefWidth);
+        button.setPrefHeight(imageView.getFitHeight() + container.orElse(20D));
+        return this;
+    }
+
+    /**
+     * 设置ImageView属性
+     *
+     * @param fitWidth      适合宽度
+     * @param fitHeight     适合高度
+     * @param preserveRatio 保持比例
+     * @param scaleX        X轴比例
+     * @param scaleY        Y轴比例
+     * @return 建造者对象
+     */
+    public SideBarButtonBuilder setImageViewEssentialAttribute(Double fitWidth, Double fitHeight, boolean preserveRatio, Double scaleX, Double scaleY) {
+        Optional<Double> container = Optional.ofNullable(fitWidth);
+        imageView.setFitWidth(container.orElse(10D));
+        container = Optional.ofNullable(fitHeight);
+        imageView.setFitHeight(container.orElse(10D));
+        imageView.setPreserveRatio(preserveRatio);
+        container = Optional.ofNullable(scaleX);
+        imageView.setScaleX(container.orElse(2.5));
+        container = Optional.ofNullable(scaleY);
+        imageView.setScaleY(container.orElse(2.5));
+        return this;
+    }
+
+
+    public SideBarButtonBuilder setEventHandler(EventHandler<ActionEvent> eventHandler) {
+        this.eventHandler = eventHandler;
+        return this;
+    }
+
+    public SideBarButtonBuilder setButton(Button button) {
+        this.button = button;
+        return this;
+    }
+}

src/main/java/org/jcnc/jnotepad/api/core/views/menu/AbstractBaseMenu.java

@@ -0,0 +1,50 @@
+package org.jcnc.jnotepad.api.core.views.menu;
+
+import javafx.collections.ObservableList;
+import javafx.scene.control.Menu;
+import javafx.scene.control.MenuItem;
+import org.jcnc.jnotepad.app.i18n.UiResourceBundle;
+import org.jcnc.jnotepad.ui.views.root.top.menubar.TopMenuBar;
+
+/**
+ * 抽象基础菜单类
+ *
+ * <p>
+ * 此抽象类用于创建基础菜单，包括菜单项的注册和初始化。
+ * </p>
+ *
+ * @author gewuyou
+ */
+public abstract class AbstractBaseMenu extends AbstractMenu<Menu> {
+    protected final TopMenuBar topMenuBar = TopMenuBar.getInstance();
+
+    /**
+     * 获取菜单名称
+     *
+     * @return 菜单名称
+     */
+    public abstract String getMenuName();
+
+    /**
+     * 获取菜单项
+     *
+     * @return 菜单项集合
+     */
+    @Override
+    protected ObservableList<MenuItem> getItems() {
+        return getMenu().getItems();
+    }
+
+    /**
+     * 初始化菜单栏
+     */
+    @Override
+    public void initMenu() {
+        registerMenu();
+        Menu menu = getMenu();
+        // 菜单名称国际化
+        UiResourceBundle.bindStringProperty(menu.textProperty(), getMenuName());
+        // 初始化菜单项
+        initMenuItems(getMenuItems());
+    }
+}

src/main/java/org/jcnc/jnotepad/api/core/views/menu/AbstractMenu.java

@@ -0,0 +1,119 @@
+package org.jcnc.jnotepad.api.core.views.menu;
+
+import javafx.beans.value.ChangeListener;
+import javafx.collections.ObservableList;
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.scene.control.CheckMenuItem;
+import javafx.scene.control.MenuItem;
+import javafx.scene.control.RadioMenuItem;
+import org.jcnc.jnotepad.app.i18n.UiResourceBundle;
+import org.jcnc.jnotepad.app.utils.LoggerUtil;
+import org.jcnc.jnotepad.controller.config.UserConfigController;
+import org.slf4j.Logger;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 抽象菜单类
+ *
+ * @author gewuyou
+ */
+public abstract class AbstractMenu<T> {
+    protected Logger logger = LoggerUtil.getLogger(this.getClass());
+    UserConfigController userConfigController = UserConfigController.getInstance();
+
+    /**
+     * 获取菜单
+     *
+     * @return 菜单
+     */
+    public abstract T getMenu();
+
+    /**
+     * 获取菜单项集合
+     *
+     * @return 菜单项集合
+     */
+    public abstract Map<String, MenuItem> getMenuItems();
+
+    /**
+     * 注册菜单
+     */
+    protected abstract void registerMenu();
+
+    /**
+     * 初始化菜单
+     */
+    protected abstract void initMenu();
+
+    /**
+     * 获取菜单项
+     *
+     * @return 菜单项集合
+     */
+    protected abstract ObservableList<MenuItem> getItems();
+
+
+    /**
+     * 注册菜单项
+     *
+     * @param menuItem     菜单项
+     * @param menuItemName 菜单项名称
+     * @param userData     用户数据，用来存放必要的数据，比如按钮菜单项名称
+     * @param eventHandler 事件处理器
+     */
+    public void registerMenuItem(MenuItem menuItem, String menuItemName, Object userData, EventHandler<ActionEvent> eventHandler) {
+        getMenuItems().put(menuItemName, menuItem);
+        menuItem.setUserData(userData);
+        menuItem.setOnAction(eventHandler);
+    }
+
+    /**
+     * 注册检查菜单项
+     *
+     * @param checkMenuItem 检查菜单项
+     * @param menuItemName  菜单项名称
+     * @param userData      用户数据，用来存放必要的数据，比如按钮菜单项名称
+     * @param listener      监听器
+     */
+    public void registerMenuItem(CheckMenuItem checkMenuItem, String menuItemName, Object userData, ChangeListener<Boolean> listener) {
+        getMenuItems().put(menuItemName, checkMenuItem);
+        checkMenuItem.setUserData(userData);
+        checkMenuItem.selectedProperty().addListener(listener);
+    }
+
+    /**
+     * 注册单选菜单项
+     *
+     * @param radioMenuItem 单选菜单项
+     * @param menuItemName  菜单项名称
+     * @param userData      用户数据，用来存放必要的数据
+     * @param eventHandler  事件处理器
+     */
+    public void registerRadioMenuItem(Map<String, RadioMenuItem> radioMenuItems, RadioMenuItem radioMenuItem, String menuItemName, Object userData, EventHandler<ActionEvent> eventHandler) {
+        radioMenuItems.put(menuItemName, radioMenuItem);
+        radioMenuItem.setUserData(userData);
+        radioMenuItem.setOnAction(eventHandler);
+    }
+
+
+    /**
+     * 初始化菜单项
+     *
+     * @param menuItems 菜单项集合
+     */
+    protected void initMenuItems(Map<String, MenuItem> menuItems) {
+        logger.info("初始化菜单项!");
+        Map<String, MenuItem> menuItemMap = new HashMap<>(16);
+        menuItems.forEach((key, value) -> {
+            UiResourceBundle.bindStringProperty(value.textProperty(), key);
+            menuItemMap.put((String) value.getUserData(), value);
+            getItems().add(value);
+        });
+        userConfigController.getMenuItems().add(menuItemMap);
+        userConfigController.initShortcutKeys(menuItemMap);
+    }
+
+}

src/main/java/org/jcnc/jnotepad/api/core/views/menu/builder/AbstractMenuBuilder.java

@@ -0,0 +1,230 @@
+package org.jcnc.jnotepad.api.core.views.menu.builder;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.collections.ObservableList;
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.scene.control.*;
+import org.jcnc.jnotepad.app.i18n.UiResourceBundle;
+import org.jcnc.jnotepad.controller.config.UserConfigController;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 抽象菜单建造者类
+ *
+ * @author gewuyou
+ */
+public abstract class AbstractMenuBuilder<B, T> {
+    /**
+     * 上下文菜单项
+     */
+    protected final Map<String, MenuItem> menuItems = new HashMap<>();
+
+    /**
+     * Get subclass builder
+     *
+     * @return builder
+     */
+    protected abstract B getBuilder();
+
+    /**
+     * 获取菜单
+     *
+     * @return 菜单
+     */
+    protected abstract T getMenu();
+
+    /**
+     * Retrieves the items of the menu.
+     *
+     * @return an ObservableList of MenuItems
+     */
+    protected abstract ObservableList<MenuItem> getItems();
+
+    /**
+     * 添加菜单项
+     *
+     * @param label        菜单项名称
+     * @param eventHandler 事件
+     * @return 建造者
+     */
+    public B addMenuItem(String label, EventHandler<ActionEvent> eventHandler) {
+        MenuItem menuItem = new MenuItem(label);
+        menuItem.setOnAction(eventHandler);
+        menuItems.put(label, menuItem);
+        getItems().add(menuItem);
+        return getBuilder();
+    }
+
+    /**
+     * 添加菜单项
+     *
+     * @param label        菜单项名称
+     * @param eventHandler 事件
+     * @param visible      是否可见
+     * @return 建造者
+     */
+    public B addMenuItem(String label, EventHandler<ActionEvent> eventHandler, BooleanProperty visible) {
+        MenuItem menuItem = new MenuItem(label);
+        menuItem.setOnAction(eventHandler);
+        menuItem.setVisible(visible.get());
+        visible.addListener((observable, oldValue, newValue) -> menuItem.setVisible(Boolean.TRUE.equals(newValue)));
+        menuItems.put(label, menuItem);
+        getItems().add(menuItem);
+        return getBuilder();
+    }
+
+    /**
+     * 添加菜单项
+     *
+     * @param label        菜单项名称
+     * @param eventHandler 事件
+     * @param visible      是否可见
+     * @return 建造者
+     */
+    public B addMenuItem(String label, EventHandler<ActionEvent> eventHandler, boolean visible) {
+        MenuItem menuItem = new MenuItem(label);
+        menuItem.setOnAction(eventHandler);
+        menuItem.setVisible(visible);
+        menuItems.put(label, menuItem);
+        getItems().add(menuItem);
+        return getBuilder();
+    }
+
+    /**
+     * 添加单选菜单项
+     *
+     * @param label        菜单项名称
+     * @param eventHandler 事件
+     * @return 建造者
+     */
+    public B addRadioMenuItem(String label, EventHandler<ActionEvent> eventHandler) {
+        RadioMenuItem menuItem = new RadioMenuItem(label);
+        menuItem.setOnAction(eventHandler);
+        menuItems.put(label, menuItem);
+        getItems().add(menuItem);
+        return getBuilder();
+    }
+
+    /**
+     * 添加复选菜单项
+     *
+     * @param label        菜单项名称
+     * @param eventHandler 事件
+     * @return 建造者
+     */
+    public B addCheckMenuItem(String label, EventHandler<ActionEvent> eventHandler) {
+        CheckMenuItem menuItem = new CheckMenuItem(label);
+        menuItem.setOnAction(eventHandler);
+        menuItems.put(label, menuItem);
+        getItems().add(menuItem);
+        return getBuilder();
+    }
+
+
+    public B addCheckMenuItem(CheckMenuItem checkMenuItem, EventHandler<ActionEvent> eventHandler) {
+        checkMenuItem.setOnAction(eventHandler);
+        menuItems.put(checkMenuItem.getText(), checkMenuItem);
+        getItems().add(checkMenuItem);
+        return getBuilder();
+    }
+
+    /**
+     * 添加菜单
+     *
+     * @param menu 菜单
+     * @return 建造者
+     */
+    public B addMenu(Menu menu) {
+        menuItems.put(menu.getText(), menu);
+        getItems().add(menu);
+        return getBuilder();
+    }
+
+    /**
+     * 添加菜单
+     *
+     * @param menu    菜单
+     * @param visible 是否隐藏
+     * @return 建造者
+     */
+    public B addMenu(Menu menu, BooleanProperty visible) {
+        menu.setVisible(visible.get());
+        visible.addListener((observable, oldValue, newValue) -> menu.setVisible(Boolean.TRUE.equals(newValue)));
+        menuItems.put(menu.getText(), menu);
+        getItems().add(menu);
+        return getBuilder();
+    }
+
+    /**
+     * 添加菜单
+     *
+     * @param menu    菜单
+     * @param visible 是否隐藏
+     * @return 建造者
+     */
+    public B addMenu(Menu menu, boolean visible) {
+        menu.setVisible(visible);
+        menuItems.put(menu.getText(), menu);
+        getItems().add(menu);
+        return getBuilder();
+    }
+
+
+    /**
+     * 添加分割线
+     *
+     * @return 建造者
+     */
+    public B addSeparatorMenuItem() {
+        getItems().add(new SeparatorMenuItem());
+        return getBuilder();
+    }
+
+    /**
+     * 添加分割线
+     *
+     * @param visible 是否可见
+     * @return 建造者
+     */
+    public B addSeparatorMenuItem(BooleanProperty visible) {
+        SeparatorMenuItem separatorMenuItem = new SeparatorMenuItem();
+        separatorMenuItem.setVisible(visible.get());
+        visible.addListener((observable, oldValue, newValue) -> separatorMenuItem.setVisible(Boolean.TRUE.equals(newValue)));
+        getItems().add(separatorMenuItem);
+        return getBuilder();
+    }
+
+    /**
+     * 添加分割线
+     *
+     * @param visible 是否可见
+     * @return 建造者
+     */
+    public B addSeparatorMenuItem(boolean visible) {
+        SeparatorMenuItem separatorMenuItem = new SeparatorMenuItem();
+        separatorMenuItem.setVisible(visible);
+        getItems().add(separatorMenuItem);
+        return getBuilder();
+    }
+
+    /**
+     * Build menu
+     *
+     * @return menu
+     */
+    public T build() {
+        UserConfigController userConfigController = UserConfigController.getInstance();
+        Map<String, MenuItem> menuItemMap = new HashMap<>(16);
+        menuItems.forEach((key, value) -> {
+            UiResourceBundle.bindStringProperty(value.textProperty(), key);
+            menuItemMap.put((String) value.getUserData(), value);
+        });
+        userConfigController.getMenuItems().add(menuItemMap);
+        userConfigController.initShortcutKeys(menuItemMap);
+        return getMenu();
+    }
+
+}

src/main/java/org/jcnc/jnotepad/api/core/views/menu/builder/ContextMenuBuilder.java

@@ -0,0 +1,53 @@
+package org.jcnc.jnotepad.api.core.views.menu.builder;
+
+import javafx.collections.ObservableList;
+import javafx.scene.control.ContextMenu;
+import javafx.scene.control.MenuItem;
+
+/**
+ * 上下文菜单建造者类
+ *
+ * <p>
+ * 此类用于构建上下文菜单对象，可以添加菜单项、单选菜单项、复选菜单项以及分割线等。
+ * </p>
+ *
+ * @author gewuyou
+ */
+public class ContextMenuBuilder extends AbstractMenuBuilder<ContextMenuBuilder, ContextMenu> {
+
+    private final ContextMenu contextMenu;
+
+    public ContextMenuBuilder() {
+        contextMenu = new ContextMenu();
+    }
+
+    /**
+     * 获取子类的建造者实例
+     *
+     * @return 建造者实例
+     */
+    @Override
+    protected ContextMenuBuilder getBuilder() {
+        return this;
+    }
+
+    /**
+     * 获取菜单
+     *
+     * @return 菜单
+     */
+    @Override
+    protected ContextMenu getMenu() {
+        return contextMenu;
+    }
+
+    /**
+     * 获取上下文菜单的菜单项列表
+     *
+     * @return 菜单项列表
+     */
+    @Override
+    protected ObservableList<MenuItem> getItems() {
+        return contextMenu.getItems();
+    }
+}

src/main/java/org/jcnc/jnotepad/api/core/views/menu/builder/MenuBuilder.java

@@ -0,0 +1,60 @@
+package org.jcnc.jnotepad.api.core.views.menu.builder;
+
+import javafx.collections.ObservableList;
+import javafx.scene.control.Menu;
+import javafx.scene.control.MenuItem;
+
+/**
+ * 菜单建造者类
+ *
+ * <p>
+ * 此类用于构建菜单对象，可以添加菜单项、单选菜单项、复选菜单项以及分割线等。
+ * </p>
+ *
+ * @author gewuyou
+ */
+public class MenuBuilder extends AbstractMenuBuilder<MenuBuilder, Menu> {
+
+    private final Menu menu;
+
+
+    /**
+     * 构造菜单建造者
+     *
+     * @param label 菜单的标签
+     */
+    public MenuBuilder(String label) {
+        menu = new Menu(label);
+    }
+
+    /**
+     * 获取子类的建造者实例
+     *
+     * @return 建造者实例
+     */
+    @Override
+    protected MenuBuilder getBuilder() {
+        return this;
+    }
+
+    /**
+     * 获取菜单
+     *
+     * @return 菜单
+     */
+    @Override
+    protected Menu getMenu() {
+        return menu;
+    }
+
+    /**
+     * 获取菜单的菜单项列表
+     *
+     * @return 菜单项列表
+     */
+    @Override
+    protected ObservableList<MenuItem> getItems() {
+        return menu.getItems();
+    }
+
+}

src/main/java/org/jcnc/jnotepad/api/core/views/sidebar/bottom/AbstractFunctionChildrenBox.java

@@ -0,0 +1,48 @@
+package org.jcnc.jnotepad.api.core.views.sidebar.bottom;
+
+import javafx.scene.control.Label;
+import javafx.scene.control.Menu;
+import javafx.scene.control.MenuBar;
+import org.jcnc.jnotepad.ui.views.root.bottom.function.FunctionBox;
+
+/**
+ * 子功能栏抽象类
+ *
+ * <p>
+ * 此抽象类用于构建一个基本的子功能栏，包括功能按钮的初始化和添加到功能栏中。
+ * </p>
+ *
+ * @author gewuyou
+ */
+public abstract class AbstractFunctionChildrenBox {
+    protected final FunctionBox functionBox;
+
+    protected final MenuBar menuBar;
+
+    protected final Label label = new Label(getFunctionName());
+
+    protected Menu menu = new Menu();
+
+    /**
+     * 构造子功能栏抽象类
+     */
+    protected AbstractFunctionChildrenBox() {
+        functionBox = FunctionBox.getInstance();
+        menuBar = FunctionBox.getMenuBar();
+    }
+
+    /**
+     * 初始化子功能栏，包括将功能按钮添加到菜单栏中
+     */
+    public void initialize() {
+        menu.setGraphic(label);
+        menuBar.getMenus().add(menu);
+    }
+
+    /**
+     * 获取功能按钮名称
+     *
+     * @return 功能按钮名称
+     */
+    protected abstract String getFunctionName();
+}

src/main/java/org/jcnc/jnotepad/app/aReadme.md

@@ -0,0 +1 @@
+app 目录存放应用程序配置、应用程序缓存、通用常量和国际化文件。

src/main/java/org/jcnc/jnotepad/app/common/aReadme.md

@@ -0,0 +1 @@
+common 目录存放应用程序的通用组卷

src/main/java/org/jcnc/jnotepad/app/common/constants/AppConstants.java

@@ -0,0 +1,69 @@
+package org.jcnc.jnotepad.app.common.constants;
+
+import org.jcnc.jnotepad.app.i18n.UiResourceBundle;
+
+import java.util.regex.Pattern;
+
+/**
+ * 应用常量类，用于存放应用程序中的常量值。
+ *
+ * <p>
+ * 该类包含了应用程序的一些常用常量，如版本号、作者、软件名称、初始宽度和高度、Logo地址等。
+ * </p>
+ *
+ * <p>
+ * 还包括了与标签页相关的正则表达式模式，以及默认的属性和程序文件目录等常量。
+ * </p>
+ *
+ * @author luke
+ */
+public class AppConstants {
+    /**
+     * 版本号
+     */
+    public static final String VERSION = "1.0.14-alpha";
+    /**
+     * 作者
+     */
+    public static final String AUTHOR = "JCNC";
+    /**
+     * 软件名称
+     */
+    public static final String APP_NAME = "JNotepad";
+    /**
+     * 初始宽度
+     */
+    public static final double SCREEN_WIDTH = 1050;
+    /**
+     * 初始高度
+     */
+    public static final double SCREEN_LENGTH = 750;
+    /**
+     * logo地址
+     */
+    public static final String APP_ICON = "/jcnc/app/images/appIcons/icon.png";
+
+    /**
+     * 默认标签页的正则
+     *
+     * <p>
+     * 用于匹配默认标签页名称的正则表达式，格式为"New File"后跟数字。
+     * </p>
+     */
+    public static final Pattern TABNAME_PATTERN = Pattern.compile("^" + Pattern.quote(UiResourceBundle.getContent(TextConstants.NEW_FILE)) + "\\d+$");
+
+    /**
+     * 默认属性
+     */
+    public static final String DEFAULT_PROPERTY = "user.home";
+    /**
+     * 程序文件目录
+     */
+    public static final String PROGRAM_FILE_DIRECTORY = ".jnotepad";
+
+    /**
+     * 私有构造函数，防止该类被实例化。
+     */
+    private AppConstants() {
+    }
+}

src/main/java/org/jcnc/jnotepad/app/common/constants/SplitPaneItemConstants.java

@@ -0,0 +1,32 @@
+package org.jcnc.jnotepad.app.common.constants;
+
+/**
+ * SplitPane常量类
+ *
+ * <p>用于记录SplitPane中子组件的索引</p>
+ *
+ * @author cccqyu
+ */
+public class SplitPaneItemConstants {
+
+    /**
+     * rootSplitPane中的上部分隔栏索引。
+     */
+    public static final int ROOT_SPLIT_PANE_TOP_SPLIT_PANE = 0;
+
+    /**
+     * rootSplitPane中的底部指令框索引。
+     */
+    public static final int ROOT_SPLIT_PANE_CMD_BOX = 1;
+
+    /**
+     * rootSplitPane中的上部面板的左侧索引。
+     */
+    public static final int TOP_SPLIT_PANE_DIRECTORY_SIDEBAR_PANE = 0;
+
+    /**
+     * rootSplitPane中的上部面板的右侧索引。
+     */
+    public static final int TOP_SPLIT_PANE_CENTER_TAB_PANE = 1;
+
+}

src/main/java/org/jcnc/jnotepad/app/common/constants/TextConstants.java

@@ -0,0 +1,264 @@
+package org.jcnc.jnotepad.app.common.constants;
+
+/**
+ * 文本常量类，包含多处使用的文本常量。
+ *
+ * <p>如果只有一个类使用常量，请在该类中使用 <code>private static final</code> 声明。</p>
+ *
+ * @author gewuyou
+ */
+public class TextConstants {
+
+    /**
+     * 标题文本常量
+     */
+    public static final String TITLE = "title";
+
+    /**
+     * 保存文本常量
+     */
+    public static final String SAVE = "SAVE";
+
+    /**
+     * 文件文本常量
+     */
+    public static final String FILE = "FILE";
+    /**
+     * 文件夹
+     */
+    public static final String FOLDER = "FOLDER";
+
+    /**
+     * 构建文本常量
+     */
+    public static final String BUILD = "BUILD";
+
+    /**
+     * 终端文本常量
+     */
+    public static final String TERMINAL = "TERMINAL";
+
+    /**
+     * 运行文本常量
+     */
+    public static final String RUN = "RUN";
+
+    /**
+     * 调试文本常量
+     */
+    public static final String DE_BUG = "DE_BUG";
+
+    /**
+     * 新建文本常量
+     */
+    public static final String NEW = "NEW";
+
+    /**
+     * 打开文本常量
+     */
+    public static final String OPEN = "OPEN";
+
+    /**
+     * 打开目录文本常量
+     */
+    public static final String OPEN_DIRECTORY = "OPEN_DIRECTORY";
+
+    /**
+     * 另存为文本常量
+     */
+    public static final String SAVE_AS = "SAVE_AS";
+
+    /**
+     * 重命名文本常量
+     */
+    public static final String RENAME = "RENAME";
+
+    /**
+     * 设置文本常量
+     */
+    public static final String SET = "SET";
+
+    /**
+     * 帮助文本常量
+     */
+    public static final String HELP = "HELP";
+
+    /**
+     * 自动换行文本常量
+     */
+    public static final String WORD_WRAP = "WORD_WRAP";
+
+    /**
+     * 插件文本常量
+     */
+    public static final String PLUGIN = "PLUGIN";
+
+    /**
+     * 管理插件文本常量
+     */
+    public static final String MANAGER_PLUGIN = "MANAGER_PLUGIN";
+
+    /**
+     * 关于文本常量
+     */
+    public static final String ABOUT = "ABOUT";
+
+    /**
+     * 开发者文本常量
+     */
+    public static final String DEVELOPER = "DEVELOPER";
+
+    /**
+     * 统计文本常量
+     */
+    public static final String STATISTICS = "STATISTICS";
+
+    /**
+     * 打开配置文件文本常量
+     */
+    public static final String OPEN_CONFIGURATION_FILE = "OPEN_CONFIGURATION_FILE";
+
+    /**
+     * 顶部文本常量
+     */
+    public static final String TOP = "TOP";
+
+    /**
+     * 语言文本常量
+     */
+    public static final String LANGUAGE = "LANGUAGE";
+
+    /**
+     * 中文文本常量
+     */
+    public static final String UPPER_CHINESE = "CHINESE";
+
+    /**
+     * 英文文本常量
+     */
+    public static final String UPPER_ENGLISH = "ENGLISH";
+
+    /**
+     * 新建文件文本常量
+     */
+    public static final String NEW_FILE = "NEW_FILE";
+
+    /**
+     * 新建文件夹
+     */
+    public static final String NEW_DIRECTORY = "NEW_DIRECTORY";
+
+    /**
+     * 删除
+     */
+    public static final String DELETE = "DELETE";
+
+    /**
+     * 行文本常量
+     */
+    public static final String ROW = "ROW";
+
+    /**
+     * 列文本常量
+     */
+    public static final String COLUMN = "COLUMN";
+
+    /**
+     * 字数统计文本常量
+     */
+    public static final String WORD_COUNT = "WORD_COUNT";
+
+    /**
+     * 编码文本常量
+     */
+    public static final String ENCODE = "ENCODE";
+
+    /**
+     * 英文小写文本常量
+     */
+    public static final String ENGLISH = "english";
+
+    /**
+     * 中文小写文本常量
+     */
+    public static final String CHINESE = "chinese";
+
+    /**
+     * 关闭
+     */
+    public static final String CLOSE = "CLOSE";
+
+    /**
+     * 关闭其他标签页
+     */
+    public static final String CLOSE_OTHER_TABS = "CLOSE_OTHER_TABS";
+
+    /**
+     * 关闭所有标签页
+     */
+    public static final String CLOSE_ALL_TABS = "CLOSE_ALL_TABS";
+
+    /**
+     * 关闭左侧标签
+     */
+    public static final String CLOSE_LEFT_TABS = "CLOSE_LEFT_TABS";
+
+    /**
+     * 关闭右侧标签
+     */
+    public static final String CLOSE_RIGHT_TABS = "CLOSE_RIGHT_TABS";
+
+    /**
+     * 复制
+     */
+    public static final String COPY = "COPY";
+
+    /**
+     * 粘贴
+     */
+    public static final String PASTE = "PASTE";
+
+    /**
+     * 剪切
+     */
+    public static final String SHEAR = "SHEAR";
+
+    /**
+     * 文件名
+     */
+    public static final String FILE_NAME = "FILE_NAME";
+
+    /**
+     * 文件路径
+     */
+    public static final String FILE_PATH = "FILE_PATH";
+
+
+    /**
+     * 所在文件夹
+     */
+    public static final String FOLDER_PATH = "FOLDER_PATH";
+    /**
+     * 固定标签页
+     */
+    public static final String FIXED_TAB = "FIXED_TAB";
+    /**
+     * 只读
+     */
+    public static final String READ_ONLY = "READ_ONLY";
+
+    public static final String SEPARATOR = "separator";
+
+    /**
+     * 打开于
+     */
+    public static final String OPEN_ON = "OPEN_ON";
+    /**
+     * 资源管理器
+     */
+    public static final String EXPLORER = "EXPLORER";
+
+    private TextConstants() {
+    }
+
+}

src/main/java/org/jcnc/jnotepad/app/common/manager/ApplicationCacheManager.java

@@ -0,0 +1,39 @@
+package org.jcnc.jnotepad.app.common.manager;
+
+import org.jcnc.jnotepad.api.core.manager.AbstractCacheManager;
+
+/**
+ * 应用程序缓存管理类。
+ * <p>
+ * 该类用于管理应用程序中的缓存数据。
+ * </p>
+ *
+ * @author gewuyou
+ */
+public class ApplicationCacheManager extends AbstractCacheManager {
+
+    private static final ApplicationCacheManager INSTANCE = new ApplicationCacheManager();
+
+    private ApplicationCacheManager() {
+
+    }
+
+    /**
+     * 获取 ApplicationCacheManager 的实例。
+     *
+     * @return ApplicationCacheManager 实例
+     */
+    public static ApplicationCacheManager getInstance() {
+        return INSTANCE;
+    }
+
+    /**
+     * 获取全局命名空间。
+     *
+     * @return 全局命名空间字符串
+     */
+    @Override
+    public String getGlobalNamespace() {
+        return "jcnc";
+    }
+}

src/main/java/org/jcnc/jnotepad/app/common/manager/ThreadPoolManager.java

@@ -1,22 +1,21 @@
-package org.jcnc.jnotepad.manager;
+package org.jcnc.jnotepad.app.common.manager;
 
-import org.jcnc.jnotepad.tool.LogUtil;
+import org.jcnc.jnotepad.app.utils.LoggerUtil;
 import org.slf4j.Logger;
 
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicInteger;
 
 /**
- * 线程池管理类<br>
- * 项目中所有异步操作建议使用该类进行获取线程执行异步操作
+ * 线程池管理类。
+ * <p>
+ * 该类用于管理应用程序中的线程池，提供了异步操作的执行环境。
+ * </p>
  *
  * @author gewuyou
  */
 public class ThreadPoolManager {
-    private ThreadPoolManager() {
-    }
-
-    private static final Logger logger = LogUtil.getLogger(ThreadPoolManager.class);
+    private static final Logger logger = LoggerUtil.getLogger(ThreadPoolManager.class);
     /**
      * 核心线程数
      */
@@ -45,18 +44,6 @@ public class ThreadPoolManager {
      * 当前运行线程数
      */
     private static final AtomicInteger THREAD_COUNT = new AtomicInteger(1);
-
-    /**
-     * 当前运行线程数自减
-     *
-     * @apiNote 当你创建任务时，务必在最后执行一次该方法
-     * @see ThreadPoolManager
-     * @since 2023/8/26 22:00
-     */
-    public static void threadContSelfSubtracting() {
-        THREAD_COUNT.decrementAndGet();
-    }
-
     /**
      * 线程工厂
      */
@@ -78,6 +65,26 @@ public class ThreadPoolManager {
     private static final ThreadPoolExecutor THREAD_POOL = new ThreadPoolExecutor(
             CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_TIME, TIME_UNIT, BLOCKING_QUEUE, THREAD_FACTORY, HANDLER);
 
+    private ThreadPoolManager() {
+    }
+
+    /**
+     * 当前运行线程数自减。
+     * <p>
+     * 当你创建任务时，务必在最后执行一次该方法。
+     * </p>
+     *
+     * @see ThreadPoolManager
+     */
+    public static void threadContSelfSubtracting() {
+        THREAD_COUNT.decrementAndGet();
+    }
+
+    /**
+     * 获取线程池实例。
+     *
+     * @return 线程池实例
+     */
     public static ExecutorService getThreadPool() {
         return THREAD_POOL;
     }

src/main/java/org/jcnc/jnotepad/app/config/AppConfig.java

@@ -2,111 +2,107 @@ package org.jcnc.jnotepad.app.config;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
 
-import java.util.ArrayList;
-import java.util.List;
+import java.io.File;
+import java.nio.file.Paths;
+import java.util.Collections;
+import java.util.Optional;
+import java.util.Set;
+
+import static org.jcnc.jnotepad.app.common.constants.AppConstants.DEFAULT_PROPERTY;
+import static org.jcnc.jnotepad.app.common.constants.AppConstants.PROGRAM_FILE_DIRECTORY;
 
 /**
- * 数据模型类，用于表示 MyData 对象的数据结构。
+ * 应用程序配置文件
  *
- * @author 许轲
+ * <p>
+ * 此类用于存储应用程序的配置信息，包括程序根路径、排除的文件夹和文件等。
+ * </p>
+ *
+ * @author gewuyou
  */
 public class AppConfig {
-    private String language;
-
+    /**
+     * 排除的文件夹
+     */
     @JsonIgnore
-    private boolean textWrap;
-
-    private List<ShortcutKey> shortcutKey;
-
+    private final Set<File> ignoreFolder;
     /**
-     * ShortcutKey 类，用于表示快捷键信息。
+     * 排除的文件
      */
-    public static class ShortcutKey {
-        private String buttonName;
-        private String shortcutKeyValue;
-
-        public String getButtonName() {
-            return buttonName;
-        }
-
-        public void setButtonName(String buttonName) {
-            this.buttonName = buttonName;
-        }
-
-        public String getShortcutKeyValue() {
-            return shortcutKeyValue;
-        }
-
-        public void setShortcutKeyValue(String shortcutKeyValue) {
-            this.shortcutKeyValue = shortcutKeyValue;
-        }
-    }
-
-    public String getLanguage() {
-        return language;
-    }
-
-    public void setLanguage(String language) {
-        this.language = language;
-    }
-
-    public List<ShortcutKey> getShortcutKey() {
-        return shortcutKey;
-    }
-
-    public void setShortcutKey(List<ShortcutKey> shortcutKey) {
-        this.shortcutKey = shortcutKey;
-    }
-
-    private static final String CTRL_N = "ctrl+n";
-    private static final String CTRL_O = "ctrl+o";
-    private static final String CTRL_S = "ctrl+s";
-    private static final String CTRL_ALT_S = "ctrl+alt+s";
-    private static final String ALT_S = "alt+s";
+    @JsonIgnore
+    private final Set<File> ignoreFile;
+    /**
+     * 程序根路径
+     */
+    private String rootPath;
+    /**
+     * 上次的程序根路径
+     */
+    @JsonIgnore
+    private String lastRootPath;
 
     /**
-     * 生成默认应用配置对象。
+     * 构造应用程序配置对象
+     */
+    public AppConfig() {
+        ignoreFolder = Set.of(
+                new File(Paths.get(System.getProperty(DEFAULT_PROPERTY), PROGRAM_FILE_DIRECTORY, "system").toString()),
+                new File(Paths.get(System.getProperty(DEFAULT_PROPERTY), PROGRAM_FILE_DIRECTORY, "logs").toString())
+        );
+        ignoreFile = Collections.emptySet();
+    }
+
+    /**
+     * 获取程序根路径
      *
-     * @return 默认应用配置对象
+     * @return 程序根路径
      */
-    public static AppConfig generateDefaultAppConfig() {
-        AppConfig myData = new AppConfig();
-        myData.setLanguage("chinese");
-        myData.setTextWrap(false);
-
-        List<AppConfig.ShortcutKey> shortcutKeys = new ArrayList<>();
-        shortcutKeys.add(createShortcutKey("newItem", CTRL_N));
-        shortcutKeys.add(createShortcutKey("openItem", CTRL_O));
-        shortcutKeys.add(createShortcutKey("saveItem", CTRL_S));
-        shortcutKeys.add(createShortcutKey("saveAsItem", CTRL_ALT_S));
-        shortcutKeys.add(createShortcutKey("lineFeedItem", ""));
-        shortcutKeys.add(createShortcutKey("openConfigItem", ALT_S));
-        shortcutKeys.add(createShortcutKey("addItem", ""));
-        shortcutKeys.add(createShortcutKey("countItem", ""));
-
-        myData.setShortcutKey(shortcutKeys);
-        return myData;
+    public String getRootPath() {
+        return Optional.ofNullable(rootPath).orElse(System.getProperty(DEFAULT_PROPERTY));
     }
 
     /**
-     * 创建 ShortcutKey 对象。
+     * 设置程序根路径
      *
-     * @param buttonName       按钮名称
-     * @param shortcutKeyValue 快捷键值
-     * @return ShortcutKey 对象
+     * @param rootPath 程序根路径
      */
-    private static AppConfig.ShortcutKey createShortcutKey(String buttonName, String shortcutKeyValue) {
-        AppConfig.ShortcutKey shortcutKey = new AppConfig.ShortcutKey();
-        shortcutKey.setButtonName(buttonName);
-        shortcutKey.setShortcutKeyValue(shortcutKeyValue);
-        return shortcutKey;
+    public void setRootPath(String rootPath) {
+        this.rootPath = rootPath;
     }
 
-    public boolean isTextWrap() {
-        return textWrap;
+    /**
+     * 获取上次的程序根路径
+     *
+     * @return 上次的程序根路径
+     */
+    public String getLastRootPath() {
+        return lastRootPath;
     }
 
-    public void setTextWrap(boolean textWrap) {
-        this.textWrap = textWrap;
+    /**
+     * 设置上次的程序根路径
+     *
+     * @param lastRootPath 上次的程序根路径
+     */
+    public void setLastRootPath(String lastRootPath) {
+        this.lastRootPath = lastRootPath;
+    }
+
+    /**
+     * 获取排除的文件夹集合
+     *
+     * @return 排除的文件夹集合
+     */
+    public Set<File> getIgnoreFolder() {
+        return ignoreFolder;
+    }
+
+    /**
+     * 获取排除的文件集合
+     *
+     * @return 排除的文件集合
+     */
+    public Set<File> getIgnoreFile() {
+        return ignoreFile;
     }
 }

src/main/java/org/jcnc/jnotepad/app/config/PluginConfig.java

@@ -0,0 +1,36 @@
+package org.jcnc.jnotepad.app.config;
+
+import org.jcnc.jnotepad.model.entity.PluginDescriptor;
+
+import java.util.List;
+
+/**
+ * 插件配置文件
+ *
+ * <p>
+ * 此类用于存储插件的配置信息，包括插件描述符的列表。
+ * </p>
+ *
+ * @author gewuyou
+ */
+public class PluginConfig {
+    private List<PluginDescriptor> plugins;
+
+    /**
+     * 获取插件描述符列表
+     *
+     * @return 插件描述符列表
+     */
+    public List<PluginDescriptor> getPlugins() {
+        return plugins;
+    }
+
+    /**
+     * 设置插件描述符列表
+     *
+     * @param plugins 插件描述符列表
+     */
+    public void setPlugins(List<PluginDescriptor> plugins) {
+        this.plugins = plugins;
+    }
+}

src/main/java/org/jcnc/jnotepad/app/config/UserConfig.java

@@ -0,0 +1,77 @@
+package org.jcnc.jnotepad.app.config;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import org.jcnc.jnotepad.model.entity.ShortcutKey;
+
+import java.util.List;
+
+/**
+ * 用户配置文件类
+ *
+ * <p>
+ * 此类用于存储用户的配置信息，包括语言设置、文本自动换行设置和快捷键配置。
+ * </p>
+ *
+ * @author luke
+ */
+public class UserConfig {
+
+    private String language;
+    @JsonIgnore
+    private boolean textWrap;
+    private List<ShortcutKey> shortcutKey;
+
+    /**
+     * 获取语言设置
+     *
+     * @return 语言设置
+     */
+    public String getLanguage() {
+        return language;
+    }
+
+    /**
+     * 设置语言设置
+     *
+     * @param language 语言设置
+     */
+    public void setLanguage(String language) {
+        this.language = language;
+    }
+
+    /**
+     * 获取快捷键配置列表
+     *
+     * @return 快捷键配置列表
+     */
+    public List<ShortcutKey> getShortcutKey() {
+        return shortcutKey;
+    }
+
+    /**
+     * 设置快捷键配置列表
+     *
+     * @param shortcutKey 快捷键配置列表
+     */
+    public void setShortcutKey(List<ShortcutKey> shortcutKey) {
+        this.shortcutKey = shortcutKey;
+    }
+
+    /**
+     * 获取文本自动换行设置
+     *
+     * @return 是否启用文本自动换行
+     */
+    public boolean isTextWrap() {
+        return textWrap;
+    }
+
+    /**
+     * 设置文本自动换行设置
+     *
+     * @param textWrap 是否启用文本自动换行
+     */
+    public void setTextWrap(boolean textWrap) {
+        this.textWrap = textWrap;
+    }
+}

src/main/java/org/jcnc/jnotepad/app/i18n/UiResourceBundle.java

@@ -13,74 +13,53 @@ import java.util.ResourceBundle;
 /**
  * UI资源绑定，用于加载语言文件。
  *
+ * <p>
+ * 此类用于加载和管理UI资源文件，支持国际化和多语言功能。可以通过绑定StringProperty和键值对应的内容，以及获取当前资源文件的内容。
+ * </p>
+ *
+ * <p>
+ * 该类是一个单例类，通过getInstance方法获取实例。
+ * </p>
+ *
+ * <p>
+ * 使用方法示例：
+ * <code>
+ * UiResourceBundle.bindStringProperty(stringProperty, "key");
+ * String content = UiResourceBundle.getContent("key");
+ * </code>
+ * </p>
+ *
  * @author songdragon
  */
-public class UIResourceBundle {
+public class UiResourceBundle {
 
-    private static final UIResourceBundle INSTANCE = new UIResourceBundle();
+    private static final UiResourceBundle INSTANCE = new UiResourceBundle();
     /**
      * resource目录下的i18n/i18nXXX.properties
      */
-    private static final String BASENAME = "i18n/i18n";
-
+    private static final String BASENAME = "jcnc/app/i18n/i18n";
+    /**
+     * 资源文件的观察者绑定。
+     */
+    private final ObjectProperty<ResourceBundle> resources = new SimpleObjectProperty<>();
     /**
      * 当前语言
      */
     private Locale currentLocale;
 
-    public static UIResourceBundle getInstance() {
+    private UiResourceBundle() {
+
+    }
+
+    /**
+     * 获取UiResourceBundle的单例实例
+     *
+     * @return UiResourceBundle的单例实例
+     */
+    public static UiResourceBundle getInstance() {
         return INSTANCE;
     }
 
-    private UIResourceBundle() {
-
-    }
-
-    /**
-     * 资源文件的观察者绑定。
-     */
-    private final ObjectProperty<ResourceBundle> resources = new SimpleObjectProperty<>();
-
-    /**
-     * 获取当前资源文件
-     *
-     * @return 资源文件
-     */
-    public ObjectProperty<ResourceBundle> resourcesProperty() {
-        return resources;
-    }
-
-    public final ResourceBundle getResources() {
-        return resourcesProperty().get();
-    }
-
-    public final void setResources(ResourceBundle resources) {
-        resourcesProperty().set(resources);
-    }
-
-    /**
-     * 重置当前local
-     */
-    public final void resetLocal(Locale toLocal) {
-        if (this.currentLocale == toLocal) {
-            return;
-        }
-        this.currentLocale = toLocal;
-        ResourceBundle resourceBundle = ResourceBundle.getBundle(BASENAME, currentLocale);
-        this.setResources(resourceBundle);
-
-    }
-
-    /**
-     * 获取key对应的绑定属性内容
-     *
-     * @param key key
-     * @return key对应的内容
-     */
-    public StringBinding getStringBinding(String key) {
-        return Bindings.createStringBinding(() -> getResources().getString(key), resourcesProperty());
-    }
-
     /**
      * 工具方法：绑定StringProperty和Key对应的内容
      *
@@ -104,6 +83,48 @@ public class UIResourceBundle {
         return INSTANCE.getResources().getString(key);
     }
 
+    /**
+     * 获取当前资源文件
+     *
+     * @return 资源文件
+     */
+    public ObjectProperty<ResourceBundle> resourcesProperty() {
+        return resources;
+    }
+
+    public final ResourceBundle getResources() {
+        return resourcesProperty().get();
+    }
+
+    public final void setResources(ResourceBundle resources) {
+        resourcesProperty().set(resources);
+    }
+
+    /**
+     * 重置当前local
+     *
+     * @param toLocal 要设置的新的Locale
+     */
+    public final void resetLocal(Locale toLocal) {
+        if (this.currentLocale == toLocal) {
+            return;
+        }
+        this.currentLocale = toLocal;
+        ResourceBundle resourceBundle = ResourceBundle.getBundle(BASENAME, currentLocale);
+        this.setResources(resourceBundle);
+
+    }
+
+    /**
+     * 获取key对应的绑定属性内容
+     *
+     * @param key key
+     * @return key对应的内容
+     */
+    public StringBinding getStringBinding(String key) {
+        return Bindings.createStringBinding(() -> getResources().getString(key), resourcesProperty());
+    }
+
     /**
      * 注册资源变更监听器
      *

src/main/java/org/jcnc/jnotepad/app/manager/ApplicationManager.java

@@ -0,0 +1,328 @@
+package org.jcnc.jnotepad.app.manager;
+
+import atlantafx.base.theme.PrimerLight;
+import javafx.application.Application;
+import javafx.application.Platform;
+import javafx.scene.Scene;
+import javafx.scene.layout.Pane;
+import javafx.stage.Stage;
+import javafx.stage.Window;
+import org.jcnc.jnotepad.JnotepadApp;
+import org.jcnc.jnotepad.app.common.constants.AppConstants;
+import org.jcnc.jnotepad.app.common.constants.TextConstants;
+import org.jcnc.jnotepad.app.common.manager.ThreadPoolManager;
+import org.jcnc.jnotepad.app.config.AppConfig;
+import org.jcnc.jnotepad.app.i18n.UiResourceBundle;
+import org.jcnc.jnotepad.app.utils.FileUtil;
+import org.jcnc.jnotepad.app.utils.LoggerUtil;
+import org.jcnc.jnotepad.app.utils.UiUtil;
+import org.jcnc.jnotepad.controller.ResourceController;
+import org.jcnc.jnotepad.controller.cache.CacheController;
+import org.jcnc.jnotepad.controller.config.AppConfigController;
+import org.jcnc.jnotepad.controller.config.PluginConfigController;
+import org.jcnc.jnotepad.controller.exception.AppException;
+import org.jcnc.jnotepad.controller.manager.Controller;
+import org.jcnc.jnotepad.controller.plugin.manager.PluginManager;
+import org.jcnc.jnotepad.ui.views.manager.*;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.ExecutorService;
+
+import static org.jcnc.jnotepad.app.common.constants.AppConstants.DEFAULT_PROPERTY;
+import static org.jcnc.jnotepad.app.common.constants.AppConstants.PROGRAM_FILE_DIRECTORY;
+
+/**
+ * 应用程序管理类
+ *
+ * <p>
+ * 此类负责管理应用程序的生命周期和操作。它包括初始化应用程序、执行默认操作、加载缓存、加载资源、迁移程序根文件夹、停止前操作等功能。
+ * </p>
+ *
+ * <p>
+ * 该类是一个单例类，通过getInstance方法获取实例。
+ * </p>
+ *
+ * @author gewuyou
+ */
+public class ApplicationManager {
+    private static final ApplicationManager INSTANCE = new ApplicationManager();
+    /**
+     * 线程池
+     */
+    private final ExecutorService threadPool = ThreadPoolManager.getThreadPool();
+    private Pane root = new Pane();
+    private Scene scene;
+    private Stage primaryStage;
+    private Application application;
+
+    private ApplicationManager() {
+    }
+
+    /**
+     * 获取ApplicationManager的单例实例
+     *
+     * @return ApplicationManager的单例实例
+     */
+    public static ApplicationManager getInstance() {
+        return INSTANCE;
+    }
+
+    /**
+     * 初始化应用程序
+     *
+     * <p>
+     * 此方法用于初始化应用程序的各个组件，包括设置应用程序主题、初始化UI组件、初始化插件、初始化顶部菜单栏、初始化侧边工具栏、初始化下方状态栏、初始化标签页布局等。
+     * </p>
+     */
+    public void initializeApp() {
+        // 设置应用程序主题
+        Application.setUserAgentStylesheet(new PrimerLight().getUserAgentStylesheet());
+        // 初始化scene
+        initScene();
+        // 初始化插件
+        PluginManager.getInstance().initPlugins();
+        // 初始化顶部菜单栏
+        TopMenuBarManager.getInstance().initTopMenuBar();
+        // 初始化侧边工具栏
+        SidebarToolBarManager.getInstance().initSidebarToolBar();
+        // 初始化下方状态栏
+        BottomStatusBoxManager.getInstance().initStatusBox();
+        // 初始标签页布局组件
+        CenterTabPaneManager.getInstance().initCenterTabPane();
+        // 初始化应用布局
+        initAppLayout();
+        // 初始化primaryStage
+        initPrimaryStage();
+    }
+
+    /**
+     * 执行默认操作
+     *
+     * <p>
+     * 此方法用于执行应用程序的默认操作，例如根据参数打开关联文件并创建文本区域，加载已打开的文件夹等。
+     * </p>
+     */
+    public void executeDefaultAction() {
+        // 使用加载关联文件并创建文本区域
+        List<String> rawParameters = application.getParameters().getRaw();
+        Controller.getInstance().openAssociatedFileAndCreateTextArea(rawParameters);
+        // 加载已打开的文件夹
+        DirectorySidebarManager.getInstance().expandTheOpenFileTree();
+    }
+
+    private void initScene() {
+        // 初始化scene
+        double width = AppConstants.SCREEN_WIDTH;
+        double length = AppConstants.SCREEN_LENGTH;
+        scene = new Scene(root, width, length);
+        scene.getStylesheets().add(Objects.requireNonNull(application.getClass().getResource("/jcnc/app/css/styles.css")).toExternalForm());
+    }
+
+    private void initPrimaryStage() {
+        primaryStage.setScene(scene);
+        primaryStage.setWidth(scene.getWidth());
+        primaryStage.setHeight(scene.getHeight());
+        primaryStage.getIcons().add(UiUtil.getAppIcon());
+        primaryStage.focusedProperty().addListener((observable, oldValue, newValue) -> {
+            if (Boolean.TRUE.equals(newValue)) {
+                CenterTabPaneManager instance = CenterTabPaneManager.getInstance();
+                instance.checkFileTabStatus(instance.getSelected());
+            }
+        });
+    }
+
+    /**
+     * 加载缓存
+     *
+     * <p>
+     * 此方法用于加载应用程序的缓存。
+     * </p>
+     */
+    public void loadAppCache() {
+        // 加载缓存
+        CacheController.getInstance().loadCaches();
+    }
+
+    /**
+     * 加载资源
+     *
+     * <p>
+     * 此方法用于加载应用程序的资源，包括加载资源文件和绑定快捷键。
+     * </p>
+     */
+    public void loadAppResources() {
+        // 加载资源
+        ResourceController.getInstance().loadResources();
+        // 绑定快捷键
+        UiResourceBundle.bindStringProperty(primaryStage.titleProperty(), TextConstants.TITLE);
+    }
+
+    /**
+     * 迁移程序根文件夹
+     *
+     * <p>
+     * 此方法用于迁移应用程序的根文件夹，将根文件夹从之前的位置迁移到新的位置。
+     * </p>
+     */
+    public void migrateFileRootFolder() {
+        AppConfig config = AppConfigController.getInstance().getConfig();
+        String lastRootPath = config.getLastRootPath();
+        if (lastRootPath == null) {
+            return;
+        }
+        // 获取源文件夹
+        File sourceFolder = new File(lastRootPath, PROGRAM_FILE_DIRECTORY);
+        // 获取目标文件夹
+        File targetFolder = new File(config.getRootPath(), PROGRAM_FILE_DIRECTORY);
+        // 设置忽略文件夹
+        Set<File> ignoredFolders = config.getIgnoreFolder();
+        // 设置忽略文件
+        Set<File> ignoredFiles = config.getIgnoreFile();
+        // 移动文件夹
+        FileUtil.migrateFolder(sourceFolder, targetFolder, ignoredFolders, ignoredFiles);
+        // 删除.jnotepad
+        if (!sourceFolder.equals(new File(Paths.get(System.getProperty(DEFAULT_PROPERTY), PROGRAM_FILE_DIRECTORY).toString()))) {
+            try {
+                Files.delete(sourceFolder.toPath());
+            } catch (IOException e) {
+                throw new AppException(e);
+            }
+        }
+        // 保存新配置
+        AppConfigController.getInstance().writeConfig();
+    }
+
+    /**
+     * 停止前操作
+     *
+     * <p>
+     * 在停止应用程序之前，执行一系列操作，包括刷新插件配置、销毁插件、保存已打开的文件标签页、将缓存写入本地、迁移程序根文件夹、关闭线程池等。
+     * </p>
+     */
+    public void operationBeforeStopping() {
+        PluginConfigController pluginConfigController = PluginConfigController.getInstance();
+        // 刷新插件配置文件
+        pluginConfigController.getConfig().setPlugins(PluginManager.getInstance().getPluginDescriptors());
+        pluginConfigController.writeConfig();
+
+        // 销毁插件可能申请的资源
+        PluginManager.getInstance().destroyPlugins();
+        // 保存已打开的文件标签页
+        CenterTabPaneManager.getInstance().saveOpenFileTabs();
+        // 将缓存写入本地
+        CacheController.getInstance().writeCaches();
+        // 迁移文件夹
+        migrateFileRootFolder();
+        // 关闭线程池
+        threadPool.shutdownNow();
+    }
+
+    /**
+     * 获取当前窗口
+     *
+     * @return 当前窗口
+     */
+    public Window getWindow() {
+        return scene.getWindow();
+    }
+
+    /**
+     * 获取当前窗口的场景
+     *
+     * @return 当前窗口的场景
+     */
+    public Scene getScene() {
+        return scene;
+    }
+
+    public void setScene(Scene scene) {
+        this.scene = scene;
+    }
+
+    /**
+     * 加载程序布局
+     *
+     * <p>
+     * 此方法用于加载应用程序的布局，包括根布局容器、底部根侧边栏垂直布局、主界面边界布局、顶部边界面板、右侧边栏垂直布局、根布局等组件。
+     * </p>
+     */
+    public void initAppLayout() {
+        // 加载根布局容器
+        RootManager rootManager = RootManager.getInstance(scene);
+        rootManager.initScreen(scene);
+        // 初始化底部根侧边栏垂直布局
+        RootBottomSideBarVerticalBoxManager.getInstance().initSidebarVerticalBox();
+        // 初始化主界面边界布局
+        MainBorderPaneManager.getInstance().initMainBorderPane();
+        // 初始化顶部边界面板
+        RootTopBorderPaneManager.getInstance().initRootBorderPane();
+        // 初始化右侧边栏垂直布局
+        RootRightSideBarVerticalBoxManager.getInstance().initRootRightSideBarVerticalBox();
+        // 初始化根布局
+        RootBorderPaneManager.getInstance().initRootBorderPane();
+    }
+
+    /**
+     * 重启应用程序
+     *
+     * <p>
+     * 此方法用于重启当前的Java应用程序。
+     * </p>
+     */
+    public void restart() {
+        try {
+            // 获取当前Java应用程序的命令
+            String javaCommand = System.getProperty("java.home") + "/bin/java";
+            String mainClass = JnotepadApp.class.getName();
+
+            // 构建新进程来重新启动应用程序
+            ProcessBuilder builder = new ProcessBuilder(javaCommand, "-cp", System.getProperty("java.class.path"), mainClass);
+            builder.start();
+            // 关闭当前应用程序
+            stop();
+        } catch (IOException e) {
+            LoggerUtil.getLogger("正在重启当前应用程序".getClass());
+        }
+    }
+
+    public Pane getRoot() {
+        return root;
+    }
+
+    public void setRoot(Pane root) {
+        this.root = root;
+    }
+
+    public Application getApplication() {
+        return application;
+    }
+
+    public void setApplication(Application application) {
+        this.application = application;
+    }
+
+    public Stage getPrimaryStage() {
+        return primaryStage;
+    }
+
+    public void setPrimaryStage(Stage primaryStage) {
+        this.primaryStage = primaryStage;
+    }
+
+    /**
+     * 停止应用程序
+     *
+     * <p>
+     * 此方法用于停止应用程序。
+     * </p>
+     */
+    public void stop() {
+        Platform.exit();
+    }
+}

src/main/java/org/jcnc/jnotepad/app/utils/ClipboardUtil.java

@@ -0,0 +1,42 @@
+package org.jcnc.jnotepad.app.utils;
+
+import javafx.scene.input.Clipboard;
+import javafx.scene.input.ClipboardContent;
+
+/**
+ * 剪切板工具
+ *
+ * @author gewuyou
+ */
+public class ClipboardUtil {
+    /**
+     * 系统剪切板对象
+     */
+    private static final Clipboard CLIPBOARD = Clipboard.getSystemClipboard();
+
+    private ClipboardUtil() {
+    }
+
+    /**
+     * Writes the provided text to the system clipboard.
+     *
+     * @param text the text to be written to the clipboard
+     */
+    public static void writeTextToClipboard(String text) {
+        ClipboardContent content = new ClipboardContent();
+        content.putString(text);
+        CLIPBOARD.setContent(content);
+    }
+
+    /**
+     * Reads text from the clipboard.
+     *
+     * @return the text read from the clipboard
+     */
+    public static String readTextFromClipboard() {
+        String text = CLIPBOARD.getString();
+        LoggerUtil.getLogger(ClipboardUtil.class).info("剪切板内容:{}", text);
+        return text;
+    }
+
+}

src/main/java/org/jcnc/jnotepad/app/utils/EncodingDetector.java

@@ -1,5 +1,4 @@
-package org.jcnc.jnotepad.tool;
-
+package org.jcnc.jnotepad.app.utils;
 
 import com.ibm.icu.text.CharsetDetector;
 import com.ibm.icu.text.CharsetMatch;
@@ -10,25 +9,25 @@ import java.io.File;
 import java.io.FileInputStream;
 import java.nio.charset.Charset;
 
-
 /**
  * 编码检测工具类
  *
+ * <p>该工具类用于检测文本文件的编码类型。</p>
+ *
  * @author 许轲
  */
 public class EncodingDetector {
-    private static final Logger LOG = LogUtil.getLogger(EncodingDetector.class);
     /**
-     * 编码侦测概率，阈值：50%
+     * 编码侦测概率阈值，50%
      */
     public static final int THRESHOLD_CONFIDENCE = 50;
-
+    private static final Logger LOG = LoggerUtil.getLogger(EncodingDetector.class);
 
     private EncodingDetector() {
     }
 
     /**
-     * 检测文本编码
+     * 检测文本编码。
      *
      * @param file 要检测的文件
      * @return 字符串表示的编码，如果检测失败则返回 "UNKNOWN"
@@ -61,7 +60,7 @@ public class EncodingDetector {
     }
 
     /**
-     * 检测文本编码
+     * 检测文本编码。
      *
      * @param file 文件
      * @return Charset编码
@@ -76,4 +75,4 @@ public class EncodingDetector {
             return Charset.defaultCharset();
         }
     }
-}
+}

src/main/java/org/jcnc/jnotepad/app/utils/FileUtil.java

@@ -0,0 +1,434 @@
+package org.jcnc.jnotepad.app.utils;
+
+import javafx.scene.Node;
+import javafx.scene.image.ImageView;
+import org.jcnc.jnotepad.controller.event.handler.menuitem.OpenFile;
+import org.jcnc.jnotepad.controller.exception.AppException;
+import org.jcnc.jnotepad.model.entity.DirFileModel;
+import org.kordamp.ikonli.javafx.FontIcon;
+import org.slf4j.Logger;
+
+import java.awt.*;
+import java.io.*;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.List;
+import java.util.*;
+
+import static org.kordamp.ikonli.antdesignicons.AntDesignIconsFilled.*;
+
+/**
+ * 文件工具
+ *
+ * @author gewuyou
+ */
+public class FileUtil {
+    private static final MessageDigest MESSAGE_DIGEST_SHA_256;
+    private static final int BUFFER_SIZE = 8192;
+    private static final Logger logger = LoggerUtil.getLogger(FileUtil.class);
+
+    private static final String WINDOWS = "win";
+
+    private static final String MAC = "mac";
+
+    private static final String PATH = "path";
+
+    static {
+        try {
+            MESSAGE_DIGEST_SHA_256 = MessageDigest.getInstance("SHA-256");
+        } catch (NoSuchAlgorithmException e) {
+            throw new AppException(e);
+        }
+    }
+
+    private FileUtil() {
+
+    }
+
+    /**
+     * 将字节数组转换为String类型哈希值
+     *
+     * @param bytes 字节数组
+     * @return 哈希值
+     */
+    private static String bytes2HashCode(byte[] bytes) {
+        StringBuilder hashString = new StringBuilder();
+        for (byte b : bytes) {
+            hashString.append(String.format("%02x", b));
+        }
+        return hashString.toString();
+    }
+
+
+    /**
+     * 获取本地文件Sha256哈希值字符串
+     *
+     * @param file 本地文件
+     * @return 本地文件Sha256哈希值
+     */
+    public static String getLocalFileSha256HashString(File file) {
+        try (
+                // 获取文件输入流
+                FileInputStream fileInputStream = new FileInputStream(file);
+                // 获取字节流通道
+                FileChannel channel = fileInputStream.getChannel()
+        ) {
+            // 设置8k缓冲区
+            ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
+            while (channel.read(buffer) != -1) {
+                buffer.flip();
+                MESSAGE_DIGEST_SHA_256.update(buffer);
+                buffer.clear();
+            }
+        } catch (IOException e) {
+            throw new AppException(e);
+        }
+        return bytes2HashCode(MESSAGE_DIGEST_SHA_256.digest());
+    }
+
+    /**
+     * 获取本地文件Sha256哈希值字符串
+     *
+     * @param pathStr 本地文件路径字符串
+     * @return 本地文件Sha256哈希值
+     */
+    public static String getLocalFileSha256HashString(String pathStr) {
+        return getLocalFileSha256HashString(new File(pathStr));
+    }
+
+    /**
+     * 获取本地文件Sha256哈希值字符串
+     *
+     * @param path 本地文件路径
+     * @return 本地文件Sha256哈希值
+     */
+    public static String getLocalFileSha256HashString(Path path) {
+        return getLocalFileSha256HashString(path.toFile());
+    }
+
+    /**
+     * 获取文件中的文本内容。
+     *
+     * @param file 文件对象
+     * @return 文本内容
+     */
+    public static String getFileText(File file) {
+        return getFileText(file, EncodingDetector.detectEncodingCharset(file));
+    }
+
+
+    /**
+     * 获取文件中的文本内容。
+     *
+     * @param file     文件对象
+     * @param encoding 文件编码
+     * @return 文本内容
+     */
+    public static String getFileText(File file, Charset encoding) {
+        StringBuilder stringBuilder = new StringBuilder();
+        try (BufferedReader reader = new BufferedReader(new FileReader(file, encoding))) {
+            String line;
+            while ((line = reader.readLine()) != null) {
+                if (!stringBuilder.isEmpty()) {
+                    stringBuilder.append("\n");
+                }
+                stringBuilder.append(line);
+            }
+        } catch (IOException ignored) {
+            LoggerUtil.getLogger(OpenFile.class).info("已忽视IO异常!");
+        }
+        return stringBuilder.toString();
+    }
+
+    /**
+     * 将文件夹转为DirFileModel
+     *
+     * @param file 文件
+     * @return DirFileModel 存储文件夹与文件关系的实体类
+     */
+    public static DirFileModel getDirFileModel(File file) {
+        if (!file.exists()) {
+            return null;
+        }
+
+        DirFileModel dirFileModel = new DirFileModel(
+                file.getAbsolutePath(),
+                file.getName(), new ArrayList<>(),
+                new FontIcon(FOLDER),
+                new FontIcon(FOLDER_OPEN));
+
+        File[] files = file.listFiles();
+        if (files != null) {
+            for (File f : files) {
+                if (f.isDirectory()) {
+                    DirFileModel childDirFileModel = getDirFileModel(f);
+                    dirFileModel.getChildFile().add(childDirFileModel);
+                } else {
+                    // 在此监测文件后缀，设置对应的图标
+                    dirFileModel.getChildFile().add(new DirFileModel(
+                            f.getAbsolutePath(), f.getName(), null,
+                            getIconCorrespondingToFileName(f.getName()),
+                            null));
+                }
+            }
+        }
+        return dirFileModel;
+    }
+
+    /**
+     * Retrieves a DirFileModel object based on the given dirFileModels map.
+     *
+     * @param dirFileModels a map containing the dirFileModels data
+     * @return the DirFileModel object
+     */
+    public static DirFileModel getDirFileModel(Map<String, Object> dirFileModels) {
+        if (Objects.isNull(dirFileModels) || dirFileModels.isEmpty()) {
+            return null;
+        }
+        File rootDir = new File((String) dirFileModels.get(PATH));
+        DirFileModel dirFileModel = new DirFileModel(
+                rootDir.getAbsolutePath(),
+                rootDir.getName(), new ArrayList<>(),
+                new FontIcon(FOLDER),
+                new FontIcon(FOLDER_OPEN), (Boolean) dirFileModels.get("open"));
+        Optional<Object> o = Optional.ofNullable(dirFileModels.get("childFile"));
+        if (o.isEmpty()) {
+            return null;
+        }
+        List<Map<String, Object>> childFile = (List<Map<String, Object>>) o.get();
+        File[] files = rootDir.listFiles();
+        if (files == null) {
+            return null;
+        }
+
+        for (File f : files) {
+            if (f.isDirectory()) {
+                Optional<Map<String, Object>> first = childFile
+                        .stream()
+                        .filter(map -> map.get(PATH).equals(f.getAbsolutePath())).findFirst();
+                DirFileModel childDirFileModel;
+                if (first.isPresent()) {
+                    childDirFileModel = getDirFileModel(first.get());
+                } else {
+                    childDirFileModel = getDirFileModel(f);
+                }
+                dirFileModel.getChildFile().add(childDirFileModel);
+            } else {
+                // 在此监测文件后缀，设置对应的图标
+                dirFileModel.getChildFile().add(new DirFileModel(
+                        f.getAbsolutePath(), f.getName(), null,
+                        getIconCorrespondingToFileName(f.getName()),
+                        null));
+            }
+        }
+        return dirFileModel;
+    }
+
+
+    /**
+     * 文件夹迁移
+     *
+     * @param sourceFolder 源文件夹
+     * @param targetFolder 目标文件夹
+     * @since 2023/10/5 12:18
+     */
+
+    public static void migrateFolder(File sourceFolder, File targetFolder) {
+        // 创建目标文件夹
+        targetFolder.mkdirs();
+
+        // 获取源文件夹中的所有文件和文件夹
+        File[] files = sourceFolder.listFiles();
+
+        if (files != null) {
+            // 遍历源文件夹中的每个文件和文件夹
+            for (File file : files) {
+                if (file.isDirectory()) {
+                    // 如果是文件夹，递归调用自身进行迁移
+                    migrateFolder(file, new File(targetFolder, file.getName()));
+                } else {
+                    // 如果是文件，将文件复制到目标文件夹中
+                    Path sourceFilePath = file.toPath();
+                    Path targetFilePath = new File(targetFolder, file.getName()).toPath();
+                    try {
+                        Files.copy(sourceFilePath, targetFilePath, StandardCopyOption.REPLACE_EXISTING);
+                    } catch (IOException e) {
+                        throw new AppException(e);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * 迁移文件夹
+     *
+     * @param sourceFolder   源文件夹
+     * @param targetFolder   目标文件夹
+     * @param ignoredFolders 忽略的文件夹集合
+     * @param ignoredFiles   忽略的文件集合
+     * @since 2023/10/5 13:58
+     */
+    public static void migrateFolder(File sourceFolder, File targetFolder, Set<File> ignoredFolders, Set<File> ignoredFiles) {
+        // 创建目标文件夹
+        targetFolder.mkdir();
+        // 获取源文件夹中的所有文件和文件夹
+        File[] files = sourceFolder.listFiles();
+        if (files != null) {
+            // 遍历源文件夹中的每个文件和文件夹
+            for (File file : files) {
+                // 如果是文件夹且不是忽略的文件夹，递归调用自身进行迁移
+                if (file.isDirectory() && !ignoredFolders.contains(file)) {
+                    migrateFolder(targetFolder, ignoredFolders, ignoredFiles, file);
+                    continue;
+                }
+                // 如果是文件且不是忽略的文件，将文件复制到目标文件夹中
+                if (!file.isDirectory() && !ignoredFiles.contains(file)) {
+                    migrateFile(targetFolder, file);
+                }
+            }
+        }
+    }
+
+    /**
+     * 迁移文件
+     *
+     * @param targetFolder 目标文件夹
+     * @param file         文件
+     */
+    public static void migrateFile(File targetFolder, File file) {
+        Path sourceFilePath = file.toPath();
+        Path targetFilePath = new File(targetFolder, file.getName()).toPath();
+        try {
+            Files.copy(sourceFilePath, targetFilePath, StandardCopyOption.REPLACE_EXISTING);
+        } catch (IOException e) {
+            throw new AppException(e);
+        }
+        // 删除源文件
+        try {
+            Files.delete(file.toPath());
+        } catch (IOException e) {
+            throw new AppException(e);
+        }
+    }
+
+    /**
+     * 迁移文件夹
+     *
+     * @param targetFolder   目标文件夹
+     * @param ignoredFolders 忽略的文件夹集合
+     * @param ignoredFiles   忽略的文件集合
+     * @param file           文件
+     */
+    private static void migrateFolder(File targetFolder, Set<File> ignoredFolders, Set<File> ignoredFiles, File file) {
+        migrateFolder(file, new File(targetFolder, file.getName()), ignoredFolders, ignoredFiles);
+        // 调用完毕删除当前目录
+        try {
+            Files.deleteIfExists(file.toPath());
+        } catch (IOException e) {
+            throw new AppException(e);
+        }
+    }
+
+    /**
+     * Opens the file explorer to the specified file or its parent directory.
+     *
+     * @param file the file or directory to open in the file explorer
+     */
+    public static void openExplorer(File file) {
+        try { // 判断传入的是文件还是文件夹
+            if (file.isDirectory()) {
+                Desktop.getDesktop().open(file);
+            }
+            // 如果是文件则打开所在文件夹
+            else {
+                Desktop.getDesktop().open(file.getParentFile());
+            }
+        } catch (IOException e) {
+            throw new AppException(e);
+        }
+    }
+
+
+    /**
+     * Retrieves the icon corresponding to the given file name.
+     *
+     * @param fileName the file name
+     * @return the corresponding icon for the file extension
+     */
+    public static Node getIconCorrespondingToFileName(String fileName) {
+        // 在此根据文件缀名获取对应的图标
+        String fileExtension = fileName.substring(fileName.lastIndexOf(".") + 1);
+        Node orDefault = UiUtil.getIconMap().getOrDefault(fileExtension, FontIcon.of(FILE_UNKNOWN));
+        if (orDefault instanceof FontIcon fontIcon) {
+            return new FontIcon(fontIcon.getIconLiteral());
+        }
+        if (orDefault instanceof ImageView imageView) {
+            return new ImageView(imageView.getImage());
+        }
+        return orDefault;
+    }
+
+    /**
+     * Opens a terminal in the specified folder.
+     *
+     * @param folder the folder in which to open the terminal
+     */
+    public static void openTerminal(File folder) {
+        if (!folder.exists()) {
+            return;
+        }
+        if (folder.isFile()) {
+            folder = folder.getParentFile();
+        }
+        String os = System.getProperty("os.name").toLowerCase();
+        ProcessBuilder processBuilder = getProcessBuilder(folder, os);
+        try {
+            processBuilder.start();
+        } catch (IOException e) {
+            PopUpUtil.errorAlert("打开失败", "打开于终端失败", "错误原因:" + e.getMessage(), null, null);
+        }
+    }
+
+    /**
+     * Returns a ProcessBuilder object based on the provided folder and operating system.
+     *
+     * @param folder the folder to set as the working directory for the ProcessBuilder object
+     * @param os     the operating system to determine the appropriate command for the ProcessBuilder object
+     * @return a ProcessBuilder object with the correct command for the specified operating system
+     */
+    private static ProcessBuilder getProcessBuilder(File folder, String os) {
+        ProcessBuilder processBuilder;
+        if (os.contains(WINDOWS)) {
+            // Windows系统
+            processBuilder = new ProcessBuilder("cmd.exe", "/c", "start", "cmd.exe", "/k", "cd", folder.getAbsolutePath());
+        } else if (os.contains(MAC)) {
+            // macOS系统
+            processBuilder = new ProcessBuilder("open", "-a", "Terminal", folder.getAbsolutePath());
+        } else {
+            // Linux或其他系统
+            processBuilder = new ProcessBuilder("xdg-open", folder.getAbsolutePath());
+        }
+        return processBuilder;
+    }
+
+    /**
+     * Creates a file at the specified path.
+     *
+     * @param path The path to the file to be created.
+     */
+    public static void createFile(Path path) {
+        try {
+            Files.createFile(path);
+        } catch (IOException e) {
+            logger.error("创建文件失败", e);
+        }
+    }
+}
+

src/main/java/org/jcnc/jnotepad/app/utils/JsonUtil.java

@@ -0,0 +1,81 @@
+package org.jcnc.jnotepad.app.utils;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.core.util.DefaultIndenter;
+import com.fasterxml.jackson.core.util.DefaultPrettyPrinter;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import org.jcnc.jnotepad.controller.exception.AppException;
+
+import static com.fasterxml.jackson.core.util.DefaultIndenter.SYS_LF;
+
+/**
+ * Jackson 解析器的外观类，主要提供 ObjectMapper 对象。
+ *
+ * <p>该类用于封装 Jackson 对象映射工具的配置和操作。</p>
+ *
+ * @author songdragon
+ */
+public class JsonUtil {
+    public static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
+
+    static {
+        OBJECT_MAPPER.enable(SerializationFeature.INDENT_OUTPUT);
+        DefaultPrettyPrinter prettyPrinter = new DefaultPrettyPrinter();
+        DefaultIndenter di = new DefaultIndenter("    ", SYS_LF);
+        prettyPrinter.indentArraysWith(di);
+        prettyPrinter.indentObjectsWith(di);
+        OBJECT_MAPPER.setDefaultPrettyPrinter(prettyPrinter);
+    }
+
+    private JsonUtil() {
+    }
+
+    /**
+     * 将对象转换为 JSON 字符串。
+     *
+     * @param o 要转换的对象
+     * @return 对象的 JSON 表示
+     * @throws AppException 如果转换失败
+     */
+    public static String toJsonString(Object o) {
+        try {
+            return OBJECT_MAPPER.writeValueAsString(o);
+        } catch (JsonProcessingException e) {
+            throw new AppException(e);
+        }
+    }
+
+    /**
+     * 将json字符串解析成对象
+     *
+     * @param json  json字符串
+     * @param clazz 对象类型
+     * @return 对象
+     * @throws AppException 如果解析失败
+     */
+    public static <T> T fromJsonString(String json, Class<T> clazz) {
+        try {
+            return OBJECT_MAPPER.readValue(json, clazz);
+        } catch (JsonProcessingException e) {
+            throw new AppException(e);
+        }
+    }
+
+    /**
+     * 将json字符串解析成对象
+     *
+     * @param json         json字符串
+     * @param valueTypeRef 值 类型 引用
+     * @return 对象
+     * @throws AppException 如果解析失败
+     */
+    public static <T> T fromJsonString(String json, TypeReference<T> valueTypeRef) {
+        try {
+            return OBJECT_MAPPER.readValue(json, valueTypeRef);
+        } catch (JsonProcessingException e) {
+            throw new AppException(e);
+        }
+    }
+}

src/main/java/org/jcnc/jnotepad/app/utils/LoggerUtil.java

@@ -0,0 +1,29 @@
+package org.jcnc.jnotepad.app.utils;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * 日志工具
+ *
+ * <p>注意：如果在JavaFX项目中需要调用日志，请使用Platform.runLater()来调用。</p>
+ *
+ * @author gewuyou
+ */
+public class LoggerUtil {
+    private LoggerUtil() {
+    }
+
+    /**
+     * 获取日志类。
+     *
+     * @param currentClass 所要记录的类
+     * @return org.slf4j.Logger 日志对象
+     *
+     * <p>传入当前需要记录的类，返回记录该类的日志类。</p>
+     * <p>建议一个类调用超过两次这个方法时，应当将该日志类变成成员对象，而不是多次调用。</p>
+     */
+    public static Logger getLogger(Class<?> currentClass) {
+        return LoggerFactory.getLogger(currentClass);
+    }
+}

src/main/java/org/jcnc/jnotepad/app/utils/NotificationUtil.java

@@ -0,0 +1,102 @@
+package org.jcnc.jnotepad.app.utils;
+
+import atlantafx.base.controls.Notification;
+import atlantafx.base.theme.Styles;
+import javafx.scene.layout.StackPane;
+import org.jcnc.jnotepad.ui.views.manager.RootManager;
+import org.kordamp.ikonli.javafx.FontIcon;
+
+import java.util.Collections;
+
+/**
+ * 通知实用程序
+ *
+ * @author gewuyou
+ */
+public class NotificationUtil {
+    private static final RootManager ROOT_MANAGER = RootManager.getInstance();
+    private static final StackPane ROOT_STACK_PANE = ROOT_MANAGER.getRootStackPane();
+
+    private NotificationUtil() {
+
+    }
+
+    /**
+     * Generates a custom notification with the given message and icon, applying the specified styles.
+     *
+     * @param message the message to display in the notification
+     * @param icon    the icon to display in the notification
+     * @param styles  additional styles to apply to the notification
+     */
+    public static void customNotification(String message, FontIcon icon, String... styles) {
+        Notification notification = new Notification(message, icon);
+        Collections.addAll(notification.getStyleClass(), styles);
+        RootManager.addNotificationToStackPane(ROOT_STACK_PANE, notification, true);
+    }
+
+    /**
+     * Displays a success notification with the given message.
+     *
+     * @param message the message to be displayed in the notification
+     */
+    public static void successNotification(String message) {
+        Notification notification = new Notification(message, UiUtil.getSuccessIcon());
+        setStyleClass(notification, Styles.SUCCESS);
+        RootManager.addNotificationToStackPane(ROOT_STACK_PANE, notification, true);
+    }
+
+    /**
+     * Generates an info notification with the given message.
+     *
+     * @param message the message to display in the notification
+     */
+    public static void infoNotification(String message) {
+        Notification notification = new Notification(message, UiUtil.getInfoIcon());
+        setStyleClass(notification, Styles.ACCENT);
+        RootManager.addNotificationToStackPane(ROOT_STACK_PANE, notification, true);
+    }
+
+    /**
+     * Generates an error notification with the given message and displays it on the root stack pane.
+     *
+     * @param message the error message to be displayed
+     */
+    public static void errorNotification(String message) {
+        Notification notification = new Notification(message, UiUtil.getErrorIcon());
+        setStyleClass(notification, Styles.DANGER);
+        RootManager.addNotificationToStackPane(ROOT_STACK_PANE, notification, true);
+    }
+
+    /**
+     * Generates a warning notification with the given message and displays it on the root stack pane.
+     *
+     * @param message the warning message to be displayed
+     */
+    public static void warningNotification(String message) {
+        Notification notification = new Notification(message, UiUtil.getWarningIcon());
+        setStyleClass(notification, Styles.WARNING);
+        RootManager.addNotificationToStackPane(ROOT_STACK_PANE, notification, true);
+    }
+
+    /**
+     * Generates a question notification with the given message and displays it on the root stack pane.
+     *
+     * @param message the question message to be displayed
+     */
+    public static void questionNotification(String message) {
+        Notification notification = new Notification(message, UiUtil.getQuestionIcon());
+        setStyleClass(notification, Styles.ACCENT);
+        RootManager.addNotificationToStackPane(ROOT_STACK_PANE, notification, true);
+    }
+
+    /**
+     * Sets the style class of the given notification.
+     *
+     * @param notification The notification object to set the style class for.
+     * @param styleClass   The style class to add to the notification.
+     */
+    private static void setStyleClass(Notification notification, String styleClass) {
+        notification.getStyleClass().add(Styles.ELEVATED_1);
+        notification.getStyleClass().add(styleClass);
+    }
+}

src/main/java/org/jcnc/jnotepad/app/utils/PopUpUtil.java

@@ -0,0 +1,162 @@
+package org.jcnc.jnotepad.app.utils;
+
+import org.jcnc.jnotepad.model.enums.DialogType;
+import org.jcnc.jnotepad.ui.component.stage.dialog.AppDialogBuilder;
+import org.jcnc.jnotepad.ui.component.stage.dialog.interfaces.DialogButtonAction;
+
+/**
+ * 弹窗工具类
+ *
+ * @author gewuyou
+ */
+public class PopUpUtil {
+
+    private PopUpUtil() {
+    }
+
+    /**
+     * 设置错误弹窗
+     *
+     * @param title          弹窗标题
+     * @param headerText     头文本
+     * @param message        消息文本
+     * @param leftBtnAction  左侧按钮点击事件
+     * @param rightBtnAction 右侧按钮点击事件
+     * @apiNote
+     * @since 2023/9/3 11:54
+     */
+    public static void errorAlert(
+            String title, String headerText, String message,
+            DialogButtonAction leftBtnAction, DialogButtonAction rightBtnAction) {
+        getCustomDialog()
+                .setDialogType(DialogType.ERROR)
+                .setTitle(title)
+                .setHeaderText(headerText)
+                .setCustomText(message)
+                .setLeftBtnAction(leftBtnAction)
+                .setRightBtnAction(rightBtnAction)
+                .build().showAndWait();
+    }
+
+    /**
+     * 设置信息弹窗
+     *
+     * @param title          弹窗标题
+     * @param headerText     头文本
+     * @param message        消息文本
+     * @param leftBtnAction  左侧按钮点击事件
+     * @param rightBtnAction 右侧按钮点击事件
+     * @apiNote
+     * @since 2023/9/3 11:54
+     */
+    public static void infoAlert(
+            String title, String headerText, String message,
+            DialogButtonAction leftBtnAction, DialogButtonAction rightBtnAction) {
+        getCustomDialog()
+                .setDialogType(DialogType.INFO)
+                .setTitle(title)
+                .setHeaderText(headerText)
+                .setCustomText(message)
+                .setLeftBtnAction(leftBtnAction)
+                .setRightBtnAction(rightBtnAction)
+                .build().showAndWait();
+    }
+
+    /**
+     * 设置警告弹窗
+     *
+     * @param title          弹窗标题
+     * @param headerText     头文本
+     * @param message        消息文本
+     * @param leftBtnAction  左侧按钮点击事件
+     * @param rightBtnAction 右侧按钮点击事件
+     * @apiNote
+     * @since 2023/9/3 11:54
+     */
+    public static void warningAlert(
+            String title, String headerText, String message,
+            DialogButtonAction leftBtnAction, DialogButtonAction rightBtnAction) {
+        getCustomDialog()
+                .setDialogType(DialogType.WARNING)
+                .setTitle(title)
+                .setHeaderText(headerText)
+                .setCustomText(message)
+                .setLeftBtnAction(leftBtnAction)
+                .setRightBtnAction(rightBtnAction)
+                .build().showAndWait();
+    }
+
+    /**
+     * 设置疑问弹窗
+     *
+     * @param title          弹窗标题
+     * @param headerText     头文本
+     * @param message        消息文本
+     * @param leftBtnAction  左侧按钮点击事件
+     * @param rightBtnAction 右侧按钮点击事件
+     * @apiNote
+     * @since 2023/9/3 11:54
+     */
+    public static void questionAlert(
+            String title, String headerText, String message,
+            DialogButtonAction leftBtnAction, DialogButtonAction rightBtnAction) {
+        getCustomDialog()
+                .setDialogType(DialogType.QUESTION)
+                .setTitle(title)
+                .setHeaderText(headerText)
+                .setCustomText(message)
+                .setLeftBtnAction(leftBtnAction)
+                .setRightBtnAction(rightBtnAction)
+                .build().showAndWait();
+    }
+
+    /**
+     * 设置疑问弹窗
+     *
+     * @param title          弹窗标题
+     * @param headerText     头文本
+     * @param message        消息文本
+     * @param leftBtnAction  左侧按钮点击事件
+     * @param rightBtnAction 右侧按钮点击事件
+     * @apiNote
+     * @since 2023/9/3 11:54
+     */
+    public static void questionAlert(
+            String title, String headerText, String message,
+            DialogButtonAction leftBtnAction, DialogButtonAction rightBtnAction, String leftBtnText, String rightBtnText) {
+        getCustomDialog()
+                .setDialogType(DialogType.QUESTION)
+                .setTitle(title)
+                .setHeaderText(headerText)
+                .setCustomText(message)
+                .setLeftBtnAction(leftBtnAction)
+                .setRightBtnAction(rightBtnAction)
+                .setLeftBtnText(leftBtnText)
+                .setRightBtnText(rightBtnText)
+                .build().showAndWait();
+    }
+
+    public static void successAlert(
+            String title, String headerText, String message,
+            DialogButtonAction leftBtnAction, DialogButtonAction rightBtnAction) {
+        getCustomDialog()
+                .setDialogType(DialogType.SUCCESS)
+                .setTitle(title)
+                .setHeaderText(headerText)
+                .setCustomText(message)
+                .setLeftBtnAction(leftBtnAction)
+                .setRightBtnAction(rightBtnAction)
+                .build().showAndWait();
+
+    }
+
+    /**
+     * 获取自定义弹窗
+     *
+     * @apiNote 使用此方法会返回原始的应用对话框建造者类，以实现自定义弹窗
+     * @since 2023/9/3 11:54
+     */
+    public static AppDialogBuilder getCustomDialog() {
+        return new AppDialogBuilder();
+    }
+}

src/main/java/org/jcnc/jnotepad/app/utils/ResourceUtil.java

@@ -0,0 +1,70 @@
+package org.jcnc.jnotepad.app.utils;
+
+import org.jcnc.jnotepad.JnotepadApp;
+
+import java.io.InputStream;
+import java.net.URI;
+import java.net.URL;
+import java.util.Objects;
+
+/**
+ * 资源工具
+ *
+ * @author gewuyou
+ */
+public class ResourceUtil {
+    public static final String MODULE_DIR = "/jcnc/app/";
+
+    private ResourceUtil() {
+    }
+
+    /**
+     * Retrieves an input stream for the specified resource.
+     *
+     * @param resource the path to the resource
+     * @return the input stream for the resource
+     */
+    public static InputStream getResourceAsStream(String resource) {
+        String path = resolve(resource);
+        return Objects.requireNonNull(
+                JnotepadApp.class.getResourceAsStream(resolve(path)),
+                "Resource not found: " + path
+        );
+    }
+
+    /**
+     * Retrieves the resource with the specified path.
+     *
+     * @param resource the path of the resource to retrieve
+     * @return the URI of the retrieved resource
+     */
+    public static URI getResource(String resource) {
+        String path = resolve(resource);
+        URL url = Objects.requireNonNull(JnotepadApp.class.getResource(resolve(path)), "Resource not found: " + path);
+        return URI.create(url.toExternalForm());
+    }
+
+    /**
+     * Resolves a resource path by checking if it starts with a "/". If it does,
+     * the resource path is returned as is. If it doesn't, the resource path is
+     * concatenated with the module directory path.
+     *
+     * @param resource  the resource path to be resolved
+     * @param moduleDir the module directory path
+     * @return the resolved resource path
+     */
+    public static String resolve(String resource, String moduleDir) {
+        Objects.requireNonNull(resource);
+        return resource.startsWith("/") ? resource : moduleDir + resource;
+    }
+
+    /**
+     * Resolve the given resource using the default module directory.
+     *
+     * @param resource the resource to resolve
+     * @return the resolved resource
+     */
+    public static String resolve(String resource) {
+        return resolve(resource, MODULE_DIR);
+    }
+}

src/main/java/org/jcnc/jnotepad/app/utils/TabUtil.java

@@ -0,0 +1,338 @@
+package org.jcnc.jnotepad.app.utils;
+
+import javafx.scene.control.Tab;
+import javafx.scene.control.TextField;
+import javafx.scene.input.KeyCode;
+import javafx.stage.FileChooser;
+import org.jcnc.jnotepad.app.common.constants.AppConstants;
+import org.jcnc.jnotepad.app.common.constants.TextConstants;
+import org.jcnc.jnotepad.app.common.manager.ApplicationCacheManager;
+import org.jcnc.jnotepad.app.i18n.UiResourceBundle;
+import org.jcnc.jnotepad.controller.config.UserConfigController;
+import org.jcnc.jnotepad.controller.event.handler.menuitem.OpenFile;
+import org.jcnc.jnotepad.controller.i18n.LocalizationController;
+import org.jcnc.jnotepad.model.entity.Cache;
+import org.jcnc.jnotepad.model.enums.CacheExpirationTime;
+import org.jcnc.jnotepad.ui.component.module.TextCodeArea;
+import org.jcnc.jnotepad.ui.component.stage.dialog.factory.impl.BasicFileChooserFactory;
+import org.jcnc.jnotepad.ui.views.manager.BottomStatusBoxManager;
+import org.jcnc.jnotepad.ui.views.manager.CenterTabPaneManager;
+import org.jcnc.jnotepad.ui.views.root.center.main.center.tab.CenterTab;
+import org.jcnc.jnotepad.ui.views.root.center.main.center.tab.CenterTabPane;
+import org.slf4j.Logger;
+
+import java.io.File;
+import java.nio.charset.Charset;
+import java.util.Comparator;
+import java.util.List;
+
+import static org.jcnc.jnotepad.app.common.constants.TextConstants.NEW_FILE;
+import static org.jcnc.jnotepad.app.utils.FileUtil.getFileText;
+import static org.jcnc.jnotepad.controller.config.UserConfigController.CONFIG_NAME;
+
+/**
+ * 标签页工具
+ *
+ * @author gewuyou
+ */
+public class TabUtil {
+    private static final ApplicationCacheManager CACHE_MANAGER = ApplicationCacheManager.getInstance();
+    private static final Logger logger = LoggerUtil.getLogger(TabUtil.class);
+
+    private TabUtil() {
+    }
+
+    /**
+     * 保存文件标签页
+     */
+    public static void saveFile(CenterTab tab) {
+        if (tab == null) {
+            return;
+        }
+        // 如果打开的是非关联文件，则调用另存为方法
+        if (!tab.getRelevanceProperty()) {
+            logger.info("当前保存文件为非关联打开文件，调用另存为方法");
+            saveAsFile(tab);
+        } else {
+            logger.info("当前保存文件为关联打开文件，调用自动保存方法");
+            // 调用tab保存方法
+            tab.saveSelectedFileTab();
+            // 如果该文件是配置文件，则刷新快捷键
+            if (CONFIG_NAME.equals(tab.getText())) {
+                // 重新加载语言包和快捷键
+                UserConfigController.getInstance().loadConfig();
+                UserConfigController.getInstance().initAllShortcutKeys();
+                LocalizationController.initLocal();
+                logger.info("已刷新语言包！");
+                logger.info("已刷新快捷键！");
+            }
+        }
+    }
+
+    /**
+     * 另存为
+     *
+     * @apiNote 将当前选中的标签页进行另存为弹出窗口式的保存。
+     * @see LoggerUtil
+     */
+    public static void saveAsFile(CenterTab tab) {
+        if (tab == null) {
+            return;
+        }
+        Cache cache = CACHE_MANAGER.getCache("folder", "saveFile");
+        File file = BasicFileChooserFactory.getInstance().createFileChooser(
+                        UiResourceBundle.getContent(TextConstants.SAVE_AS),
+                        tab.getText(),
+                        cache == null ? null : new File((String) cache.getCacheData()),
+                        new FileChooser.ExtensionFilter("All types", "*.*"))
+                .showSaveDialog(UiUtil.getAppWindow());
+        if (file != null) {
+            if (cache == null) {
+                CACHE_MANAGER.addCache(
+                        CACHE_MANAGER.createCache("folder", "saveFile", file.getParent(),
+                                CacheExpirationTime.NEVER_EXPIRES.getValue()));
+            } else {
+                cache.setCacheData(file.getParent());
+                CACHE_MANAGER.addCache(cache);
+            }
+            logger.info("正在保存文件: {}", file.getName());
+            tab.save(file);
+            // 将保存后的文件设置为关联文件
+            tab.setRelevanceProperty(true);
+            // 更新标签页上的文件名
+            tab.setText(file.getName());
+        }
+    }
+
+    /**
+     * 重命名
+     */
+    public static void rename(CenterTab tab) {
+        if (tab == null || tab.getText().isEmpty()) {
+            return;
+        }
+        // 判断当前是否为关联文件
+        if (tab.getRelevanceProperty()) {
+            // 重命名关联文件
+            handleRenameRelevanceFile(tab);
+        }
+        // 如果当前不是关联文件则重命名标签页
+        else {
+            handleRenameTab(tab);
+        }
+    }
+
+    /**
+     * 重命名标签页。
+     *
+     * @param tab 标签页组件
+     */
+    private static void handleRenameTab(CenterTab tab) {
+        // 临时记录标签页名称
+        String tempName = tab.getText();
+        TextField textField = new TextField(tempName);
+        textField.getStyleClass().add("tab-title-editable");
+        // 清空标签页名称
+        tab.setText("");
+        // 监听 Enter 键，完成编辑
+        textField.setOnKeyPressed(event -> {
+            if (event.getCode() == KeyCode.ENTER) {
+                String newTabName = textField.getText();
+                // 检查是否存在相同名称的标签页
+                if (tabNameExists(newTabName)) {
+
+                    // 显示弹窗并提示用户更换名称
+                    showDuplicateNameAlert(newTabName);
+
+                    // 恢复原始名称
+                    tab.setText(tempName);
+
+                } else {
+                    tab.setText(newTabName);
+                    // 可选：移除 TextField 的图形
+                    tab.setGraphic(null);
+                    // 可选：恢复标签页的关闭按钮
+                    tab.setClosable(true);
+                }
+            }
+        });
+
+        // 监听失去焦点事件，完成编辑
+        textField.focusedProperty().addListener((observable, oldValue, newValue) -> {
+            String newTabName = textField.getText();
+            // 检查是否存在相同名称的标签页
+            if (tabNameExists(newTabName)) {
+                // 恢复原始名称
+                tab.setText(tempName);
+
+            }
+            if (Boolean.FALSE.equals(newValue)) {
+                tab.setText(newTabName);
+                // 可选：移除 TextField 的图形
+                tab.setGraphic(null);
+                // 可选：恢复标签页的关闭按钮
+                tab.setClosable(true);
+
+            }
+        });
+
+        tab.setClosable(false);
+        // 设置 TextField 作为标签页的图形
+        tab.setGraphic(textField);
+        // 默认获取焦点并选中所有文字
+        textField.requestFocus();
+        textField.selectAll();
+    }
+
+    /**
+     * 判断是否存在具有相同名称的标签页。
+     *
+     * @param newTabName 要检查的新标签页名称
+     * @return 如果存在具有相同名称的标签页，则返回 true；否则返回 false
+     */
+    private static boolean tabNameExists(String newTabName) {
+        CenterTabPane tabPane = CenterTabPane.getInstance();
+        return tabPane.getTabs().stream()
+                .anyMatch(tab -> tab.getText().equals(newTabName));
+    }
+
+    /**
+     * 显示警告弹窗，提示用户更换重复的名称。
+     */
+    private static void showDuplicateNameAlert(String newTabName) {
+        PopUpUtil.errorAlert(
+                "重命名错误",
+                "\" " + newTabName + "\" 和已有标签页名字重复",
+                "请再次重命名",
+                null,
+                null);
+    }
+
+    /**
+     * 重命名关联文件。
+     *
+     * @param tab 标签页组件
+     */
+    private static void handleRenameRelevanceFile(CenterTab tab) {
+        // 获取原始文件对象
+        File file = (File) tab.getUserData();
+
+        // 获取应用窗口并绑定
+        File newFile = BasicFileChooserFactory.getInstance()
+                .createFileChooser(
+                        UiResourceBundle.getContent(TextConstants.RENAME),
+                        tab.getText(),
+                        new File(file.getParent()),
+                        new FileChooser.ExtensionFilter("All types", "*.*"))
+                .showSaveDialog(UiUtil.getAppWindow());
+        if (newFile != null) {
+            boolean rename = file.renameTo(newFile);
+            // 设置文件数据
+            tab.setUserData(newFile);
+            if (rename) {
+                tab.setText(newFile.getName());
+                logger.info("文件重命名成功");
+            } else {
+                logger.debug("文件重命名失败");
+            }
+        }
+    }
+
+    /**
+     * 添加新的文件标签页。
+     */
+    public static void addNewFileTab() {
+        // 创建一个新的文本编辑区
+        TextCodeArea textArea = new TextCodeArea();
+        // 创建标签页
+        CenterTab centerTab = new CenterTab(
+                generateDefaultName(),
+                textArea);
+        // 将Tab页添加到TabPane中
+        CenterTabPaneManager.getInstance().addNewTab(centerTab);
+        // 更新编码信息
+        BottomStatusBoxManager.getInstance().updateEncodingLabel();
+    }
+
+    /**
+     * Generate the default name for a new tab.
+     *
+     * @return The default name for a new tab.
+     */
+    private static String generateDefaultName() {
+        // 设定初始索引
+        int index = 1;
+        StringBuilder tabTitle = new StringBuilder();
+        String content = UiResourceBundle.getContent(NEW_FILE);
+        // 获取当前默认创建标签页集合
+        List<Tab> tabs = CenterTabPane.getInstance()
+                .getTabs()
+                .stream()
+                // 排除不属于默认创建的标签页
+                .filter(tab -> AppConstants.TABNAME_PATTERN.matcher(tab.getText()).matches())
+                // 对默认创建的标签页进行排序
+                .sorted(Comparator.comparing(tab -> {
+                    String tabText = tab.getText();
+                    // 提取数字部分
+                    String numberPart = tabText.substring(content.length());
+                    // 解析为数字
+                    return Integer.parseInt(numberPart);
+                }))
+                // 转为List集合
+                .toList();
+        // 构建初始标签页名称
+        tabTitle.append(content).append(index);
+        for (Tab tab : tabs) {
+            if (tab.getText().contentEquals(tabTitle)) {
+                tabTitle.setLength(0);
+                tabTitle.append(content).append(++index);
+            } else {
+                break;
+            }
+        }
+        return tabTitle.toString();
+    }
+
+    /**
+     * 打开文件到选项卡
+     *
+     * @param file 文件对象
+     */
+    public static void openFileToTab(File file) {
+        // 获取标签页集合
+        CenterTabPane centerTabPane = CenterTabPane.getInstance();
+        // 遍历标签页，查找匹配的标签页
+        for (Tab tab : centerTabPane.getTabs()) {
+            // 获取绑定的文件
+            File tabFile = (File) tab.getUserData();
+            if (tabFile == null) {
+                continue;
+            }
+            if (file.getPath().equals((tabFile).getPath())) {
+                // 找到匹配的标签页，设置为选中状态并跳转
+                centerTabPane.getSelectionModel().select(tab);
+                return;
+            }
+        }
+        getText(file);
+    }
+
+    /**
+     * 读取文本文件的内容。
+     *
+     * @param file 文件对象
+     */
+    public static void getText(File file) {
+        TextCodeArea textCodeArea = new TextCodeArea();
+        // 检测文件编码
+        Charset encoding = EncodingDetector.detectEncodingCharset(file);
+        String fileText = getFileText(file, encoding);
+        LoggerUtil.getLogger(OpenFile.class).info("已调用读取文件功能");
+        textCodeArea.appendText(fileText);
+        // 设置当前标签页关联本地文件 设置标签页关联文件
+        CenterTab tab = new CenterTab(file.getName(), textCodeArea, encoding, file, true);
+        // 设置关联文件最后的修改时间
+        tab.setLastModifiedTimeOfAssociatedFile(file.lastModified());
+        CenterTabPaneManager.getInstance().addNewTab(tab);
+    }
+}

src/main/java/org/jcnc/jnotepad/app/utils/UiUtil.java

@@ -0,0 +1,222 @@
+package org.jcnc.jnotepad.app.utils;
+
+import atlantafx.base.theme.Styles;
+import javafx.scene.Node;
+import javafx.scene.image.Image;
+import javafx.scene.image.ImageView;
+import javafx.stage.Window;
+import org.jcnc.jnotepad.app.common.constants.AppConstants;
+import org.jcnc.jnotepad.app.manager.ApplicationManager;
+import org.kordamp.ikonli.javafx.FontIcon;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+import static org.kordamp.ikonli.antdesignicons.AntDesignIconsFilled.*;
+
+/**
+ * UI工具
+ *
+ * <p>封装了项目中需要引入的UI组件</p>
+ *
+ * @author gewuyou
+ */
+public class UiUtil {
+    /**
+     * 应用程序图标
+     */
+    private static final Image APP_ICON = new Image(Objects.requireNonNull(UiUtil.class.getResource(AppConstants.APP_ICON)).toString());
+
+    /**
+     * 错误图标
+     */
+    private static final FontIcon ERROR_ICON = FontIcon.of(EXCLAMATION_CIRCLE);
+
+    /**
+     * 信息图标
+     */
+    private static final FontIcon INFO_ICON = FontIcon.of(INFO_CIRCLE);
+    /**
+     * 警告图标
+     */
+    private static final FontIcon WARNING_ICON = FontIcon.of(WARNING);
+    /**
+     * 问题图标
+     */
+    private static final FontIcon QUESTION_ICON = FontIcon.of(QUESTION_CIRCLE);
+
+    private static final FontIcon SUCCESS_ICON = FontIcon.of(CHECK_CIRCLE);
+    /**
+     * 图标集合
+     */
+    private static final Map<String, Node> ICON_MAP = new HashMap<>(32);
+
+    static {
+        // 暂时设置颜色
+        ERROR_ICON.getStyleClass().addAll(Styles.DANGER);
+        INFO_ICON.getStyleClass().addAll(Styles.ACCENT);
+        QUESTION_ICON.getStyleClass().addAll(Styles.ACCENT);
+        WARNING_ICON.getStyleClass().addAll(Styles.WARNING);
+        SUCCESS_ICON.getStyleClass().addAll(Styles.SUCCESS);
+        ICON_MAP.put("css", fileIconByPng("css"));
+        ICON_MAP.put("doc", fileIconByPng("doc"));
+        ICON_MAP.put("dll", fileIconByPng("dll"));
+        ICON_MAP.put("exe", fileIconByPng("exe"));
+        ICON_MAP.put("gif", fileIconByPng("gif"));
+        ICON_MAP.put("gitignore", fileIconByPng("git"));
+        ICON_MAP.put("html", fileIconByPng("html"));
+        ICON_MAP.put("json", fileIconByPng("json"));
+        ICON_MAP.put("md", fileIconByPng("markdown"));
+        ICON_MAP.put("pdf", FontIcon.of(FILE_PDF));
+        ICON_MAP.put("ppt", FontIcon.of(FILE_PPT));
+        ICON_MAP.put("png", fileIconByPng("png"));
+        ICON_MAP.put("sql", fileIconByPng("database"));
+        ICON_MAP.put("svg", fileIconByPng("svg"));
+        ICON_MAP.put("txt", FontIcon.of(FILE_TEXT));
+        ICON_MAP.put("xls", FontIcon.of(FILE_EXCEL));
+        ICON_MAP.put("xml", fileIconByPng("xml"));
+        // 编程语言
+        ICON_MAP.put("bat", fileIconByPng("bat"));
+        ICON_MAP.put("c", fileIconByPng("c"));
+        ICON_MAP.put("cs", fileIconByPng("csharp"));
+        ICON_MAP.put("cpp", fileIconByPng("cplusplus"));
+        ICON_MAP.put("go", fileIconByPng("golang"));
+        ICON_MAP.put("js", fileIconByPng("js"));
+        ICON_MAP.put("java", fileIconByPng("java"));
+        ICON_MAP.put("kt", fileIconByPng("kotlin"));
+        ICON_MAP.put("lua", fileIconByPng("lua"));
+        ICON_MAP.put("py", fileIconByPng("python"));
+        ICON_MAP.put("php", fileIconByPng("php"));
+        ICON_MAP.put("rb", fileIconByPng("ruby"));
+        ICON_MAP.put("sh", fileIconByPng("sh"));
+
+
+    }
+
+    private UiUtil() {
+    }
+
+    /**
+     * 获取应用程序图标。
+     *
+     * @return javafx.scene.image.Image 应用程序图标对象
+     */
+    public static Image getAppIcon() {
+        return APP_ICON;
+    }
+
+    /**
+     * Retrieves the information icon.
+     *
+     * @return the information icon
+     */
+
+    public static FontIcon getInfoIcon() {
+        return INFO_ICON;
+    }
+
+    /**
+     * Returns the error icon.
+     *
+     * @return the error icon
+     */
+    public static FontIcon getErrorIcon() {
+        return ERROR_ICON;
+    }
+
+    /**
+     * Retrieves the warning icon.
+     *
+     * @return the warning icon
+     */
+    public static FontIcon getWarningIcon() {
+        return WARNING_ICON;
+    }
+
+    /**
+     * Retrieves the question icon.
+     *
+     * @return the question icon
+     */
+    public static FontIcon getQuestionIcon() {
+        return QUESTION_ICON;
+    }
+
+    /**
+     * Retrieves the success icon.
+     *
+     * @return the success icon as a FontIcon object
+     */
+    public static FontIcon getSuccessIcon() {
+        return SUCCESS_ICON;
+    }
+
+    /**
+     * 获取应用窗口。
+     *
+     * @return javafx.stage.Window 应用窗口对象
+     * @apiNote JnotepadApp.getWindow()
+     */
+    public static Window getAppWindow() {
+        return ApplicationManager.getInstance().getWindow();
+    }
+
+    /**
+     * Generates an ImageView with the specified module directory, name, and format.
+     *
+     * @param moduleDir the directory where the module is located
+     * @param name      the name of the icon
+     * @param format    the format of the icon
+     * @return the generated ImageView
+     */
+    public static ImageView icon(String moduleDir, String name, String format) {
+        return icon(moduleDir + name + format);
+    }
+
+    /**
+     * Generates an ImageView object with the image specified by the given path.
+     *
+     * @param path the path to the image file
+     * @return the ImageView object with the specified image
+     */
+    public static ImageView icon(String path) {
+        var img = new Image(ResourceUtil.getResourceAsStream(path));
+        return new ImageView(img);
+    }
+
+    /**
+     * Generates an ImageView based on a PNG file.
+     *
+     * @param moduleDir the directory of the module
+     * @param name      the name of the PNG file
+     * @return the generated ImageView
+     */
+    public static ImageView iconByPng(String moduleDir, String name) {
+        return icon(moduleDir + name + ".png");
+    }
+
+    /**
+     * Generates an ImageView object for a file icon based on the given PNG name.
+     *
+     * @param name the name of the PNG file for the file icon
+     * @return the ImageView object representing the file icon
+     */
+    public static ImageView fileIconByPng(String name) {
+        return iconByPng("images/fileIcons/", name);
+    }
+
+    /**
+     * Generates an ImageView object for a file icon based on the given PNG name.
+     *
+     * @param name the name of the PNG file for the file icon
+     * @return the ImageView object representing the file icon
+     */
+    public static ImageView sidebarIconByPng(String name) {
+        return iconByPng("images/sidebarIcons/", name);
+    }
+
+    public static Map<String, Node> getIconMap() {
+        return ICON_MAP;
+    }
+}

src/main/java/org/jcnc/jnotepad/app/utils/aReadme.md

@@ -0,0 +1 @@
+util 存放通用的实用工具代码。

src/main/java/org/jcnc/jnotepad/constants/AppConstants.java

@@ -1,26 +0,0 @@
-package org.jcnc.jnotepad.constants;
-
-/**
- * 应用常量
- *
- * @author 许轲
- */
-
-public class AppConstants {
-    private AppConstants() {
-    }
-
-    /**
-     * 初始宽度
-     */
-    public static final double SCREEN_WIDTH = 800;
-    /**
-     * 初始高度
-     */
-    public static final double SCREEN_LENGTH = 600;
-    /**
-     * logo地址
-     */
-    public static final String APP_ICON = "/img/icon.png";
-
-}

src/main/java/org/jcnc/jnotepad/constants/TextConstants.java

@@ -1,44 +0,0 @@
-package org.jcnc.jnotepad.constants;
-
-
-/**
- * 文本常量，被多处使用的常量放到此处。如果只有一个class使用，在class中使用private static final声明。
- *
- * @author gewuyou
- */
-public class TextConstants {
-
-    private TextConstants() {
-    }
-
-
-    /// GlobalConfig文本常量
-
-    public static final String TITLE = "title";
-    public static final String SAVE = "SAVE";
-    public static final String FILE = "FILE";
-    public static final String NEW = "NEW";
-    public static final String OPEN = "OPEN";
-    public static final String SAVE_AS = "SAVE_AS";
-    public static final String SET = "SET";
-    public static final String WORD_WRAP = "WORD_WRAP";
-    public static final String PLUGIN = "PLUGIN";
-    public static final String ADD_PLUGIN = "ADD_PLUGIN";
-    public static final String STATISTICS = "STATISTICS";
-    public static final String OPEN_CONFIGURATION_FILE = "OPEN_CONFIGURATION_FILE";
-    public static final String TOP = "TOP";
-    public static final String LANGUAGE = "LANGUAGE";
-    public static final String UPPER_CHINESE = "CHINESE";
-    public static final String UPPER_ENGLISH = "ENGLISH";
-    public static final String NEW_FILE = "NEW_FILE";
-    public static final String ROW = "ROW";
-    public static final String COLUMN = "COLUMN";
-    public static final String WORD_COUNT = "WORD_COUNT";
-    public static final String ENCODE = "ENCODE";
-
-    /// Config 文本常量
-    public static final String ENGLISH = "english";
-
-    public static final String CHINESE = "chinese";
-
-}

src/main/java/org/jcnc/jnotepad/controller/ResourceController.java

@@ -0,0 +1,28 @@
+package org.jcnc.jnotepad.controller;
+
+import org.jcnc.jnotepad.controller.i18n.LocalizationController;
+import org.jcnc.jnotepad.controller.plugin.PluginLoader;
+
+/**
+ * 资源控制器
+ *
+ * @author gewuyou
+ */
+public class ResourceController {
+    private static final ResourceController INSTANCE = new ResourceController();
+
+    private ResourceController() {
+    }
+
+
+    public static ResourceController getInstance() {
+        return INSTANCE;
+    }
+
+    public void loadResources() {
+        // 1. 加载语言
+        LocalizationController.initLocal();
+        // 2. 加载插件
+        PluginLoader.getInstance().loadPlugins();
+    }
+}

src/main/java/org/jcnc/jnotepad/controller/aReadme.md

@@ -0,0 +1 @@
+controller 存放控制器相关的代码，包括事件处理、异常处理等。

src/main/java/org/jcnc/jnotepad/controller/cache/CacheController.java

@@ -0,0 +1,243 @@
+package org.jcnc.jnotepad.controller.cache;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import org.jcnc.jnotepad.app.common.manager.ApplicationCacheManager;
+import org.jcnc.jnotepad.app.utils.JsonUtil;
+import org.jcnc.jnotepad.app.utils.LoggerUtil;
+import org.jcnc.jnotepad.controller.config.AppConfigController;
+import org.jcnc.jnotepad.model.entity.Cache;
+import org.slf4j.Logger;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+/**
+ * 缓存控制器
+ *
+ * @author gewuyou
+ */
+public class CacheController {
+
+    private static final ApplicationCacheManager APPLICATION_CACHE_MANAGER = ApplicationCacheManager.getInstance();
+    private static final CacheController INSTANCE = new CacheController();
+    Logger logger = LoggerUtil.getLogger(this.getClass());
+    private String cacheDir;
+
+    private CacheController() {
+        cacheDir = Paths.get(AppConfigController.getInstance().getConfig().getRootPath(), ".jnotepad", "caches").toString();
+    }
+
+    public static CacheController getInstance() {
+        return INSTANCE;
+    }
+
+    public void loadCaches() {
+        // 如果本地没有缓存的话，就创建缓存
+        if (createCachesIfNotExists()) {
+            return;
+        }
+        // 检查并获取缓存根目录
+        File cacheFileDir = createCacheRootIfNotExist();
+        // 获取缓存命名空间
+        String[] namespaces = cacheFileDir.list();
+        // 如果缓存根目录下为空，则创建缓存
+        if (Objects.requireNonNull(namespaces).length == 0) {
+            APPLICATION_CACHE_MANAGER.setCaches(new HashMap<>(16));
+            return;
+        }
+        Map<String, Cache> caches = new HashMap<>(16);
+        setCaches(namespaces, cacheFileDir, caches);
+
+    }
+
+    /**
+     * Sets the caches for the given namespaces.
+     *
+     * @param namespaces   an array of namespace names
+     * @param cacheFileDir the directory where the cache files are stored
+     * @param caches       a map of caches to be set
+     */
+    private void setCaches(String[] namespaces, File cacheFileDir, Map<String, Cache> caches) {
+        for (String namespace : namespaces) {
+            // 获取命名空间对应的文件夹
+            File namespaceDir = new File(cacheFileDir, namespace);
+            // 获取缓存组对应的文件名称列表
+            String[] groupNames = namespaceDir.list();
+            // 如果命名空间文件夹下没有文件则删除该文件夹
+            if (cleanEmptyFileOrFolder(namespaceDir)) {
+                continue;
+            }
+            for (String groupName : Objects.requireNonNull(groupNames)) {
+                // 获取缓存组对应的文件
+                File groupFile = new File(namespaceDir, groupName);
+                // 清理空文件
+                if (cleanEmptyFileOrFolder(groupFile)) {
+                    continue;
+                }
+                // 获取缓存
+                try {
+                    String cacheJson = Files.readString(groupFile.toPath());
+                    // 获取缓存集合
+                    Map<String, Cache> cacheMap = JsonUtil.fromJsonString(cacheJson, new TypeReference<>() {
+                    });
+                    // 设置缓存
+                    cacheMap.forEach((k, v) -> setUpCache(namespace, groupName, k, v, caches));
+                } catch (IOException e) {
+                    logger.error("读取缓存文件出错!", e);
+                    try {
+                        Files.delete(cacheFileDir.toPath());
+                    } catch (IOException ignore) {
+                        logger.error("删除失败");
+                    }
+                }
+            }
+            // 设置缓存
+            APPLICATION_CACHE_MANAGER.setCaches(caches);
+        }
+    }
+
+    /**
+     * 设置缓存
+     *
+     * @param namespace 命名空间
+     * @param groupName 缓存组
+     * @param k         缓存名称
+     * @param v         缓存类
+     * @param caches    缓存集合
+     */
+    private void setUpCache(String namespace, String groupName, String k, Cache v, Map<String, Cache> caches) {
+        // 判断缓存是否过期,没有过期才加载进内存
+        if (v.getLastReadOrWriteTime() + v.getExpirationTime() > System.currentTimeMillis() || v.getExpirationTime() < 0) {
+            v.setNamespace(namespace);
+            v.setGroup(groupName);
+            v.setName(k);
+            caches.put(v.getCacheKey(), v);
+        }
+    }
+
+    /**
+     * 清理空文件或空文件夹并返回结果
+     *
+     * @param fileOrFolder 文件或文件夹
+     * @return 是否清理
+     */
+    private boolean cleanEmptyFileOrFolder(File fileOrFolder) {
+        try {
+            if (fileOrFolder.isFile() && fileOrFolder.length() == 0) {
+                Files.delete(fileOrFolder.toPath());
+                logger.info("删除缓存文件:{}", fileOrFolder);
+                return true;
+            }
+
+            if (fileOrFolder.isDirectory() && Objects.requireNonNull(fileOrFolder.list()).length == 0) {
+                Files.delete(fileOrFolder.toPath());
+                logger.info("删除缓存文件夹:{}", fileOrFolder);
+                return true;
+            }
+        } catch (IOException e) {
+            logger.error("清理缓存文件或文件夹出错!", e);
+        }
+        return false;
+    }
+
+    /**
+     * 写缓存(writeCache)
+     */
+    public void writeCaches() {
+        writeCaches(APPLICATION_CACHE_MANAGER.getCaches());
+    }
+
+    /**
+     * 写缓存
+     *
+     * @param caches 缓存集合
+     */
+    public void writeCaches(Map<String, Cache> caches) {
+        // 检查并获取缓存根目录
+        File cacheFileDir = createCacheRootIfNotExist();
+        Map<File, Map<String, Cache>> fileMap = new HashMap<>(16);
+        // 生成缓存
+        caches.forEach((key, value) -> {
+            // 判断当前命名空间对应目录是否创建
+            File namespaceDir = new File(cacheFileDir, value.getNamespace());
+            if (!namespaceDir.exists()) {
+                namespaceDir.mkdirs();
+            }
+            // 判断当前组文件是否创建
+            File groupFile = new File(namespaceDir, value.getGroup());
+            if (!groupFile.exists()) {
+                try {
+                    boolean flag = groupFile.createNewFile();
+                    if (!flag) {
+                        logger.error("创建缓存文件失败:{}", groupFile);
+                    }
+                } catch (IOException e) {
+                    logger.error("创建缓存文件失败!", e);
+                }
+            }
+            fileMap.computeIfAbsent(groupFile, k -> new HashMap<>(16));
+            // 设置需要写入的数据
+            fileMap.get(groupFile).put(value.getName(), value);
+        });
+        Set<File> fileSet = fileMap.keySet();
+        // 清空原来的缓存
+        fileSet.forEach(file -> {
+            try (FileOutputStream fileOutputStream = new FileOutputStream(file)) {
+                fileOutputStream.write(new byte[0]);
+            } catch (IOException e) {
+                logger.error("清空缓存文件失败!", e);
+            }
+        });
+        // 写入缓存
+        for (Map.Entry<File, Map<String, Cache>> entry : fileMap.entrySet()) {
+            try (FileWriter writer = new FileWriter(entry.getKey(), true)) {
+                writer.write(JsonUtil.toJsonString(entry.getValue()));
+            } catch (IOException e) {
+                logger.error("写入缓存文件失败!", e);
+            }
+        }
+    }
+
+    /**
+     * 如果不存在，则创建缓存根目录
+     *
+     * @return 缓存根目录
+     */
+    private File createCacheRootIfNotExist() {
+        File cacheFileDir = new File(cacheDir);
+        if (!cacheFileDir.exists()) {
+            cacheFileDir.mkdirs();
+        }
+        return cacheFileDir;
+    }
+
+    /**
+     * 如果本地没有缓存则创建缓存
+     *
+     * @return 是否创建成功
+     */
+    private boolean createCachesIfNotExists() {
+        File cacheFileDir = createCacheRootIfNotExist();
+        if (Objects.requireNonNull(cacheFileDir.list()).length == 0) {
+            APPLICATION_CACHE_MANAGER.setCaches(new HashMap<>(16));
+            return true;
+        }
+        return false;
+    }
+
+    public String getCacheDir() {
+        return cacheDir;
+    }
+
+    public void setCacheDir(String cacheDir) {
+        this.cacheDir = cacheDir;
+    }
+}

src/main/java/org/jcnc/jnotepad/controller/config/AppConfigController.java

@@ -1,154 +1,77 @@
 package org.jcnc.jnotepad.controller.config;
 
+import org.jcnc.jnotepad.api.core.controller.config.BaseConfigController;
 import org.jcnc.jnotepad.app.config.AppConfig;
-import org.jcnc.jnotepad.exception.AppException;
-import org.jcnc.jnotepad.tool.JsonUtil;
-import org.jcnc.jnotepad.tool.LogUtil;
-import org.jcnc.jnotepad.tool.PopUpUtil;
-import org.slf4j.Logger;
 
-import java.io.BufferedWriter;
-import java.io.File;
-import java.io.FileWriter;
-import java.nio.file.Files;
-import java.nio.file.Path;
 import java.nio.file.Paths;
-import java.util.List;
 
-public class AppConfigController {
+import static org.jcnc.jnotepad.app.common.constants.AppConstants.DEFAULT_PROPERTY;
+import static org.jcnc.jnotepad.app.common.constants.AppConstants.PROGRAM_FILE_DIRECTORY;
 
-    private static final Logger logger = LogUtil.getLogger(AppConfigController.class);
+/**
+ * 应用程序配置文件控制器
+ *
+ * @author gewuyou
+ */
+public class AppConfigController extends BaseConfigController<AppConfig> {
 
+    /**
+     * 配置文件名
+     */
+    public static final String CONFIG_NAME = "JNotepadConfig.json";
     private static final AppConfigController INSTANCE = new AppConfigController();
+    private final String configDir;
+
+    public AppConfigController() {
+        configDir = Paths.get(System.getProperty(DEFAULT_PROPERTY), PROGRAM_FILE_DIRECTORY, SYSTEM_CONFIG_DIR).toString();
+        loadConfig();
+    }
 
     public static AppConfigController getInstance() {
         return INSTANCE;
     }
 
     /**
-     * 配置文件名
-     */
-    public static final String CONFIG_NAME = "jnotepadConfig.json";
-
-    private AppConfig appConfig;
-    private String dir;
-
-    private AppConfigController() {
-        setDir(Paths.get(System.getProperty("user.home"), ".jnotepad").toString());
-        loadConfig();
-    }
-
-    /**
-     * 加载配置文件内容
-     */
-    public void loadConfig() {
-        createConfigIfNotExists();
-        Path configPath = getConfigPath();
-
-        try {
-            logger.info("正在加载配置文件...");
-            // 存在则加载
-            String configContent = Files.readString(configPath);
-            appConfig = JsonUtil.OBJECT_MAPPER.readValue(configContent, AppConfig.class);
-        } catch (Exception e) {
-            logger.error("加载配置文件错误", e);
-            throw new AppException(e);
-        }
-    }
-
-    /**
-     * 配置文件持久化
-     */
-    public void writeAppConfig() {
-        createConfigIfNotExists();
-        writeAppConfig(this.appConfig);
-    }
-
-    /**
-     * 将appConfig对象持久化到配置文件中
+     * 获取配置文件Class类
      *
-     * @param appConfig 应用配置对象
+     * @return 配置文件Class类
      */
-    private void writeAppConfig(AppConfig appConfig) {
-        try (BufferedWriter writer = new BufferedWriter(new FileWriter(getConfigPath().toString()))) {
-            if (appConfig == null) {
-                appConfig = createShortcutKeyJson();
-            }
-            writer.write(JsonUtil.toJsonString(appConfig));
-        } catch (Exception e) {
-            logger.error("", e);
-            PopUpUtil.errorAlert("错误", "读写错误", "配置文件读写错误!");
-        }
+    @Override
+    protected Class<AppConfig> getConfigClass() {
+        return AppConfig.class;
     }
 
-    public void createConfigIfNotExists() {
-        Path configPath = getConfigPath();
-        if (configPath.toFile().exists()) {
-            return;
-        }
-        File directory = new File(dir);
-        if (!directory.exists()) {
-            directory.mkdirs();
-        }
-        writeAppConfig(null);
-    }
 
-    public Path getConfigPath() {
-        return Paths.get(getDir(), CONFIG_NAME);
-    }
-
-    private AppConfig createShortcutKeyJson() {
-        return AppConfig.generateDefaultAppConfig();
+    /**
+     * 获取配置文件名称
+     *
+     * @return 配置文件名称
+     */
+    @Override
+    protected String getConfigName() {
+        return CONFIG_NAME;
     }
 
     /**
-     * 获取当前配置文件所在目录
+     * 获取配置文件文件夹路径
      *
-     * @return
+     * @return 配置文件夹路径
      */
-    public String getDir() {
-        return dir;
-    }
-
-    public void setDir(String dir) {
-        this.dir = dir;
-    }
-
-    private AppConfig getAppConfig() {
-        return appConfig;
+    @Override
+    protected String getConfigDir() {
+        return configDir;
     }
 
     /**
-     * 获取自动换行设置，默认自动换行
+     * 创建配置文件实体
      *
-     * @return true, 自动换行；false，不自动换行
+     * @return 默认的配置文件实体
+     * @apiNote 返回默认的配置文件实体用于序列化json
      */
-    public boolean getAutoLineConfig() {
-        return getAppConfig().isTextWrap();
-    }
-
-    public void setAutoLineConfig(boolean isAutoLine) {
-        getAppConfig().setTextWrap(isAutoLine);
-    }
-
-    /**
-     * 更新配置文件中的语言设置
-     *
-     * @param language 更新后的语言设置
-     */
-    public void updateLanguage(String language) {
-        if (getLanguage().equals(language)) {
-            return;
-        }
-        this.appConfig.setLanguage(language);
-        writeAppConfig();
-    }
-
-    public String getLanguage() {
-        return this.appConfig.getLanguage();
-    }
-
-    public List<AppConfig.ShortcutKey> getShortcutKey() {
-        return this.appConfig.getShortcutKey();
+    @Override
+    public AppConfig generateDefaultConfig() {
+        AppConfig config = new AppConfig();
+        config.setRootPath(System.getProperty(DEFAULT_PROPERTY));
+        return config;
     }
 }

src/main/java/org/jcnc/jnotepad/controller/config/PluginConfigController.java

@@ -0,0 +1,102 @@
+package org.jcnc.jnotepad.controller.config;
+
+import org.jcnc.jnotepad.api.core.controller.config.BaseConfigController;
+import org.jcnc.jnotepad.app.config.PluginConfig;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+
+import static org.jcnc.jnotepad.app.common.constants.AppConstants.PROGRAM_FILE_DIRECTORY;
+
+/**
+ * 插件控制器
+ *
+ * @author gewuyou
+ */
+public class PluginConfigController extends BaseConfigController<PluginConfig> {
+    /**
+     * 插件配置文件
+     */
+    public static final String CONFIG_NAME = "pluginConfig.json";
+    private static final PluginConfigController INSTANCE = new PluginConfigController();
+
+    private String configDir;
+    private String pluginsDir;
+
+    private PluginConfigController() {
+        String rootPath = AppConfigController.getInstance().getConfig().getRootPath();
+        configDir = Paths.get(rootPath, PROGRAM_FILE_DIRECTORY, ROOT_CONFIG_DIR).toString();
+        setPluginsDir(Paths.get(rootPath, PROGRAM_FILE_DIRECTORY, "plugins").toString());
+        loadConfig();
+    }
+
+    public static PluginConfigController getInstance() {
+        return INSTANCE;
+    }
+
+    /**
+     * 获取配置文件Class类
+     *
+     * @return 配置文件Class类
+     */
+    @Override
+    protected Class<PluginConfig> getConfigClass() {
+        return PluginConfig.class;
+    }
+
+
+    /**
+     * 获取配置文件名称
+     *
+     * @return 配置文件名称
+     */
+    @Override
+    protected String getConfigName() {
+        return CONFIG_NAME;
+    }
+
+    /**
+     * 获取配置文件文件夹路径
+     *
+     * @return 配置文件夹路径
+     */
+    @Override
+    protected String getConfigDir() {
+        return configDir;
+    }
+
+    public void setConfigDir(String configDir) {
+        this.configDir = configDir;
+    }
+
+    /**
+     * 创建配置文件实体
+     *
+     * @return 默认的配置文件实体
+     * @apiNote 返回默认的配置文件实体用于序列化json
+     */
+    @Override
+    public PluginConfig generateDefaultConfig() {
+        PluginConfig pluginConfig = new PluginConfig();
+        pluginConfig.setPlugins(new ArrayList<>());
+        return pluginConfig;
+    }
+
+    /**
+     * 获取插件路径
+     *
+     * @return 插件路径
+     */
+    public Path getPlungsPath() {
+        return Paths.get(getPluginsDir());
+    }
+
+    public String getPluginsDir() {
+        return pluginsDir;
+    }
+
+    public void setPluginsDir(String pluginsDir) {
+        this.pluginsDir = pluginsDir;
+    }
+}

src/main/java/org/jcnc/jnotepad/controller/config/UserConfigController.java

@@ -0,0 +1,206 @@
+package org.jcnc.jnotepad.controller.config;
+
+import javafx.scene.control.MenuItem;
+import javafx.scene.input.KeyCombination;
+import org.jcnc.jnotepad.api.core.controller.config.BaseConfigController;
+import org.jcnc.jnotepad.app.config.UserConfig;
+import org.jcnc.jnotepad.app.utils.LoggerUtil;
+import org.jcnc.jnotepad.model.entity.ShortcutKey;
+import org.slf4j.Logger;
+
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import static org.jcnc.jnotepad.app.common.constants.AppConstants.PROGRAM_FILE_DIRECTORY;
+import static org.jcnc.jnotepad.app.common.constants.TextConstants.CHINESE;
+
+/**
+ * 应用程序配置控制器
+ *
+ * <p>该类负责管理应用程序的配置文件，包括加载、持久化和更新配置信息等操作。</p>
+ *
+ * @author songdragon
+ */
+public class UserConfigController extends BaseConfigController<UserConfig> {
+    /**
+     * 配置文件名
+     */
+    public static final String CONFIG_NAME = "userConfig.json";
+    private static final String CTRL_N = "ctrl+n";
+    private static final String CTRL_O = "ctrl+o";
+    private static final String CTRL_S = "ctrl+s";
+    private static final String CTRL_ALT_S = "ctrl+alt+s";
+    private static final String ALT_S = "alt+s";
+    private static final UserConfigController INSTANCE = new UserConfigController();
+    private final List<Map<String, MenuItem>> menuItems = new ArrayList<>();
+    Logger logger = LoggerUtil.getLogger(this.getClass());
+    private String configDir;
+
+    private UserConfigController() {
+        configDir = Paths.get(AppConfigController.getInstance().getConfig().getRootPath(), PROGRAM_FILE_DIRECTORY, ROOT_CONFIG_DIR).toString();
+        loadConfig();
+    }
+
+
+    /**
+     * 获取 UserConfigController 的实例。
+     *
+     * @return UserConfigController 的实例
+     */
+    public static UserConfigController getInstance() {
+        return INSTANCE;
+    }
+
+    /**
+     * 创建 ShortcutKey 对象。
+     *
+     * @param buttonName       按钮名称
+     * @param shortcutKeyValue 快捷键值
+     * @return ShortcutKey 对象
+     */
+    private static ShortcutKey createShortcutKey(String buttonName, String shortcutKeyValue) {
+        ShortcutKey shortcutKey = new ShortcutKey();
+        shortcutKey.setButtonName(buttonName);
+        shortcutKey.setShortcutKeyValue(shortcutKeyValue);
+        return shortcutKey;
+    }
+
+    /**
+     * 获取配置文件Class类
+     *
+     * @return 配置文件Class类
+     */
+    @Override
+    protected Class<UserConfig> getConfigClass() {
+        return UserConfig.class;
+    }
+
+    /**
+     * 获取配置文件名称
+     *
+     * @return 配置文件名称
+     */
+    @Override
+    protected String getConfigName() {
+        return CONFIG_NAME;
+    }
+
+    /**
+     * 获取配置文件文件夹路径
+     *
+     * @return 配置文件夹路径
+     */
+    @Override
+    protected String getConfigDir() {
+        return configDir;
+    }
+
+    public void setConfigDir(String configDir) {
+        this.configDir = configDir;
+    }
+
+    /**
+     * 创建配置文件实体
+     *
+     * @return 默认的配置文件实体
+     * @apiNote 返回默认的配置文件实体用于序列化json
+     */
+    @Override
+    public UserConfig generateDefaultConfig() {
+        UserConfig config = new UserConfig();
+        config.setLanguage(CHINESE);
+        config.setTextWrap(false);
+
+        List<ShortcutKey> shortcutKeys = new ArrayList<>();
+        shortcutKeys.add(createShortcutKey("newItem", CTRL_N));
+        shortcutKeys.add(createShortcutKey("openItem", CTRL_O));
+        shortcutKeys.add(createShortcutKey("saveItem", CTRL_S));
+        shortcutKeys.add(createShortcutKey("saveAsItem", CTRL_ALT_S));
+        shortcutKeys.add(createShortcutKey("lineFeedItem", ""));
+        shortcutKeys.add(createShortcutKey("openConfigItem", ALT_S));
+        shortcutKeys.add(createShortcutKey("pluginManager", ""));
+        shortcutKeys.add(createShortcutKey("countItem", ""));
+        shortcutKeys.add(createShortcutKey("aboutItem", ""));
+
+        config.setShortcutKey(shortcutKeys);
+        return config;
+    }
+
+    /**
+     * 获取自动换行设置，默认自动换行。
+     *
+     * @return true，自动换行；false，不自动换行
+     */
+    public boolean getAutoLineConfig() {
+        return getConfig().isTextWrap();
+    }
+
+    public void setAutoLineConfig(boolean isAutoLine) {
+        getConfig().setTextWrap(isAutoLine);
+    }
+
+    /**
+     * 更新配置文件中的语言设置。
+     *
+     * @param language 更新后的语言设置
+     */
+    public void updateLanguage(String language) {
+        if (getLanguage().equals(language)) {
+            return;
+        }
+        getConfig().setLanguage(language);
+        writeConfig();
+    }
+
+    /**
+     * 获取当前的语言设置。
+     *
+     * @return 语言设置
+     */
+    public String getLanguage() {
+        return getConfig().getLanguage();
+    }
+
+    /**
+     * 获取快捷键设置。
+     *
+     * @return 快捷键设置列表
+     */
+    public List<ShortcutKey> getShortcutKey() {
+        return getConfig().getShortcutKey();
+    }
+
+    public void initAllShortcutKeys() {
+        menuItems.forEach(this::initShortcutKeys);
+    }
+
+    /**
+     * 初始化快捷键
+     */
+    public void initShortcutKeys(Map<String, MenuItem> menuItemMap) {
+        List<MenuItem> itemsToUnbind = new ArrayList<>();
+        List<ShortcutKey> shortcutKeyConfigs = getShortcutKey();
+        for (ShortcutKey shortcutKey : shortcutKeyConfigs) {
+            // 保证json的key必须和变量名一致
+            MenuItem menuItem = menuItemMap.get(shortcutKey.getButtonName());
+            String shortKeyValue = shortcutKey.getShortcutKeyValue();
+            if ("".equals(shortKeyValue) && menuItem != null) {
+                itemsToUnbind.add(menuItem);
+                continue;
+            }
+            if (menuItem != null) {
+                logger.info("功能名称：{}->快捷键:{}", menuItem.getText(), shortKeyValue);
+                // 动态添加快捷键
+                menuItem.setAccelerator(KeyCombination.keyCombination(shortKeyValue));
+            }
+        }
+        // 解绑需要解绑的快捷键
+        itemsToUnbind.forEach(menuItem -> menuItem.setAccelerator(null));
+    }
+
+    public List<Map<String, MenuItem>> getMenuItems() {
+        return menuItems;
+    }
+}

src/main/java/org/jcnc/jnotepad/controller/event/handler/NewFile.java

@@ -1,49 +0,0 @@
-package org.jcnc.jnotepad.controller.event.handler;
-
-import javafx.event.ActionEvent;
-import javafx.event.EventHandler;
-import org.jcnc.jnotepad.app.i18n.UIResourceBundle;
-import org.jcnc.jnotepad.constants.TextConstants;
-import org.jcnc.jnotepad.ui.LineNumberTextArea;
-import org.jcnc.jnotepad.ui.status.JNotepadStatusBox;
-import org.jcnc.jnotepad.ui.tab.JNotepadTab;
-import org.jcnc.jnotepad.ui.tab.JNotepadTabPane;
-import org.jcnc.jnotepad.view.manager.ViewManager;
-
-
-/**
- * 新建文件事件的事件处理程序。
- * <p>
- * 当用户选择新建文件时候,将创建一个新的文本编辑区，并在Tab页中显示。
- *
- * @author 许轲
- */
-public class NewFile implements EventHandler<ActionEvent> {
-
-    /**
-     * 处理新建文件事件。
-     *
-     * @param event 事件对象
-     */
-    @Override
-    public void handle(ActionEvent event) {
-        addNewFileTab();
-
-    }
-
-    public void addNewFileTab() {
-        // 创建一个新的文本编辑区
-        LineNumberTextArea textArea = new LineNumberTextArea();
-        // 设置当前标签页与本地文件无关联
-        textArea.setRelevance(false);
-        // TODO: refactor：统一TextArea新建、绑定监听器入口
-        ViewManager viewManager = ViewManager.getInstance();
-        // 将Tab页添加到TabPane中
-        JNotepadTabPane.getInstance().addNewTab(new JNotepadTab(UIResourceBundle.getContent(TextConstants.NEW_FILE)
-                + viewManager.selfIncreaseAndGetTabIndex(),
-                textArea));
-
-        // 更新编码信息
-        JNotepadStatusBox.getInstance().updateEncodingLabel();
-    }
-}

src/main/java/org/jcnc/jnotepad/controller/event/handler/OpenConfig.java

@@ -1,24 +0,0 @@
-package org.jcnc.jnotepad.controller.event.handler;
-
-import javafx.event.ActionEvent;
-import org.jcnc.jnotepad.controller.config.AppConfigController;
-import org.jcnc.jnotepad.tool.LogUtil;
-
-import java.io.File;
-
-/**
- * 打开配置文件事件
- *
- * @author gewuyou
- */
-public class OpenConfig extends OpenFile {
-
-    @Override
-    public void handle(ActionEvent actionEvent) {
-        // 显示文件选择对话框，并获取配置文件
-        File file = AppConfigController.getInstance().getConfigPath().toFile();
-        LogUtil.getLogger(this.getClass()).info("已调用打开配置文件功能,{}", file);
-        // 创建打开文件的任务并启动线程执行任务
-        openFile(file);
-    }
-}

src/main/java/org/jcnc/jnotepad/controller/event/handler/OpenFile.java

@@ -1,131 +0,0 @@
-package org.jcnc.jnotepad.controller.event.handler;
-
-import javafx.application.Platform;
-import javafx.concurrent.Task;
-import javafx.event.ActionEvent;
-import javafx.event.EventHandler;
-import javafx.stage.FileChooser;
-import org.jcnc.jnotepad.manager.ThreadPoolManager;
-import org.jcnc.jnotepad.tool.EncodingDetector;
-import org.jcnc.jnotepad.tool.LogUtil;
-import org.jcnc.jnotepad.ui.LineNumberTextArea;
-import org.jcnc.jnotepad.ui.tab.JNotepadTab;
-import org.jcnc.jnotepad.ui.tab.JNotepadTabPane;
-
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileReader;
-import java.io.IOException;
-import java.nio.charset.Charset;
-
-import static org.jcnc.jnotepad.manager.ThreadPoolManager.threadContSelfSubtracting;
-
-
-/**
- * 打开文件的事件处理程序。
- * <p>
- * 当用户选择打开文件时，将创建一个新的文本编辑区，并在Tab页中显示。
- *
- * @author 许轲
- */
-public class OpenFile implements EventHandler<ActionEvent> {
-    /**
-     * 处理打开文件事件。
-     *
-     * @param event 事件对象
-     */
-    @Override
-    public void handle(ActionEvent event) {
-
-        // 创建文件选择器
-        FileChooser fileChooser = new FileChooser();
-        // 显示文件选择对话框，并获取选中的文件
-        File file = fileChooser.showOpenDialog(null);
-        if (file != null) {
-            openFile(file);
-        }
-    }
-
-    /**
-     * 创建打开文件的任务。
-     *
-     * @param file 文件对象
-     * @return 打开文件的任务
-     */
-    public Task<Void> createOpenFileTask(File file) {
-        Task<Void> openFileTask = new Task<>() {
-            @Override
-            protected Void call() {
-                getText(file);
-                return null;
-            }
-
-        };
-        // 设置任务成功完成时的处理逻辑
-        openFileTask.setOnSucceeded(e -> threadContSelfSubtracting());
-
-        // 设置任务失败时的处理逻辑
-        openFileTask.setOnFailed(e -> threadContSelfSubtracting());
-        return openFileTask;
-    }
-
-    /**
-     * 打开文件。
-     *
-     * @param file 文件对象
-     */
-    protected void openFile(File file) {
-        ThreadPoolManager.getThreadPool().submit(createOpenFileTask(file));
-    }
-
-    /**
-     * 读取文本文件的内容。
-     *
-     * @param file 文件对象
-     */
-    public void getText(File file) {
-        LineNumberTextArea textArea = createNewTextArea();
-        // 设置当前标签页关联本地文件
-        textArea.setRelevance(true);
-        // 检测文件编码
-        Charset encoding = EncodingDetector.detectEncodingCharset(file);
-        try (BufferedReader reader = new BufferedReader(new FileReader(file, encoding))) {
-            StringBuilder textBuilder = new StringBuilder();
-            String line;
-            while ((line = reader.readLine()) != null) {
-                textBuilder.append(line).append("\n");
-            }
-            String text = textBuilder.toString();
-            LogUtil.getLogger(this.getClass()).info("已调用读取文件功能");
-            Platform.runLater(() -> {
-                textArea.getMainTextArea().setText(text);
-                JNotepadTab tab = createNewTab(file.getName(), textArea, encoding);
-                tab.setUserData(file);
-                JNotepadTabPane.getInstance().addNewTab(tab);
-            });
-
-        } catch (IOException ignored) {
-            LogUtil.getLogger(this.getClass()).info("已忽视IO异常!");
-        }
-    }
-
-    /**
-     * 创建新的文本区域。
-     *
-     * @return 新的文本区域
-     */
-    private LineNumberTextArea createNewTextArea() {
-        return new LineNumberTextArea();
-    }
-
-    /**
-     * 创建新的标签页。
-     *
-     * @param tabName  标签名
-     * @param textArea 文本区域
-     * @return 新的标签页
-     */
-    private JNotepadTab createNewTab(String tabName, LineNumberTextArea textArea, Charset charset) {
-        return new JNotepadTab(tabName, textArea, charset);
-    }
-}

src/main/java/org/jcnc/jnotepad/controller/event/handler/SaveFile.java

@@ -1,91 +0,0 @@
-package org.jcnc.jnotepad.controller.event.handler;
-
-import javafx.event.ActionEvent;
-import javafx.event.EventHandler;
-import javafx.stage.FileChooser;
-import org.jcnc.jnotepad.controller.config.AppConfigController;
-import org.jcnc.jnotepad.controller.i18n.LocalizationController;
-import org.jcnc.jnotepad.tool.LogUtil;
-import org.jcnc.jnotepad.ui.LineNumberTextArea;
-import org.jcnc.jnotepad.ui.menu.JNotepadMenuBar;
-import org.jcnc.jnotepad.ui.tab.JNotepadTab;
-import org.jcnc.jnotepad.ui.tab.JNotepadTabPane;
-import org.slf4j.Logger;
-
-import java.io.File;
-
-import static org.jcnc.jnotepad.controller.config.AppConfigController.CONFIG_NAME;
-
-/**
- * 保存文件
- *
- * @author gewuyou
- */
-public class SaveFile implements EventHandler<ActionEvent> {
-    Logger logger = LogUtil.getLogger(this.getClass());
-
-    /**
-     * 保存文件
-     *
-     * @param actionEvent 事件对象
-     * @apiNote
-     */
-    @Override
-    public void handle(ActionEvent actionEvent) {
-        // 获取当前tab页
-        JNotepadTab selectedTab = JNotepadTabPane.getInstance().getSelected();
-        if (selectedTab == null) {
-            return;
-        }
-        // 获取当前Tab页的文本编辑区
-        LineNumberTextArea textArea = (LineNumberTextArea) selectedTab.getContent();
-        // 打开的是非关联文件，则调用另存为api
-        if (!textArea.isRelevance()) {
-            logger.info("当前保存文件为非关联打开文件，调用另存为方法");
-            saveTab(this.getClass());
-        } else {
-            logger.info("当前保存文件为关联打开文件，调用自动保存方法");
-            // 调用tab保存
-            selectedTab.save();
-            // 如果该文件是配置文件则刷新快捷键
-            if (CONFIG_NAME.equals(selectedTab.getText())) {
-                // 重新加载语言包和快捷键
-                AppConfigController.getInstance().loadConfig();
-                JNotepadMenuBar.getMenuBar().initShortcutKeys();
-                LocalizationController.initLocal();
-                logger.info("已刷新语言包!");
-                logger.info("已刷新快捷键!");
-            }
-        }
-    }
-
-    /**
-     * 保存页面方法
-     *
-     * @param currentClass 调用该方法的类
-     * @apiNote 将当前选中的标签页进行弹出窗口式的保存
-     * @see LogUtil
-     */
-    protected void saveTab(Class<?> currentClass) {
-        JNotepadTab selectedTab = JNotepadTabPane.getInstance().getSelected();
-        if (selectedTab != null) {
-            // 创建一个文件窗口
-            FileChooser fileChooser = new FileChooser();
-            // 设置保存文件名称
-            fileChooser.setInitialFileName(selectedTab.getText());
-            // 设置保存文件类型
-            fileChooser.getExtensionFilters().add(new FileChooser.ExtensionFilter("文本文档", "*.txt"));
-            File file = fileChooser.showSaveDialog(null);
-            if (file != null) {
-                LogUtil.getLogger(currentClass).info("正在保存文件:{}", file.getName());
-                selectedTab.save();
-                // 将保存后的文件设置为已关联
-                selectedTab.getLineNumberTextArea().setRelevance(true);
-                // 更新Tab页标签上的文件名
-                selectedTab.setText(file.getName());
-                // 将文件对象保存到Tab页的UserData中
-                selectedTab.setUserData(file);
-            }
-        }
-    }
-}

src/main/java/org/jcnc/jnotepad/controller/event/handler/menuitem/NewFile.java

@@ -0,0 +1,25 @@
+package org.jcnc.jnotepad.controller.event.handler.menuitem;
+
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+
+import static org.jcnc.jnotepad.app.utils.TabUtil.addNewFileTab;
+
+/**
+ * 新建文件事件的事件处理程序。
+ *
+ * <p>当用户选择新建文件时，将创建一个新的文本编辑区，并在Tab页中显示。</p>
+ *
+ * @author 许轲
+ */
+public class NewFile implements EventHandler<ActionEvent> {
+    /**
+     * 处理新建文件事件。
+     *
+     * @param event 事件对象
+     */
+    @Override
+    public void handle(ActionEvent event) {
+        addNewFileTab();
+    }
+}

src/main/java/org/jcnc/jnotepad/controller/event/handler/menuitem/OpenConfig.java

@@ -0,0 +1,33 @@
+package org.jcnc.jnotepad.controller.event.handler.menuitem;
+
+import javafx.event.ActionEvent;
+import org.jcnc.jnotepad.app.utils.LoggerUtil;
+import org.jcnc.jnotepad.controller.config.UserConfigController;
+
+import java.io.File;
+
+import static org.jcnc.jnotepad.app.utils.TabUtil.openFileToTab;
+
+/**
+ * 打开配置文件事件处理程序。
+ *
+ * <p>该事件处理程序用于打开配置文件。</p>
+ *
+ * @author gewuyou
+ */
+public class OpenConfig extends OpenFile {
+
+    /**
+     * 处理打开配置文件事件。
+     *
+     * @param actionEvent 事件对象
+     */
+    @Override
+    public void handle(ActionEvent actionEvent) {
+        // 显示文件选择对话框，并获取配置文件
+        File file = UserConfigController.getInstance().getConfigPath().toFile();
+        LoggerUtil.getLogger(this.getClass()).info("已调用打开配置文件功能, {}", file);
+        // 创建打开文件的任务并启动线程执行任务
+        openFileToTab(file);
+    }
+}

src/main/java/org/jcnc/jnotepad/controller/event/handler/menuitem/OpenFile.java

@@ -0,0 +1,57 @@
+package org.jcnc.jnotepad.controller.event.handler.menuitem;
+
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.stage.FileChooser;
+import org.jcnc.jnotepad.app.common.constants.TextConstants;
+import org.jcnc.jnotepad.app.common.manager.ApplicationCacheManager;
+import org.jcnc.jnotepad.app.i18n.UiResourceBundle;
+import org.jcnc.jnotepad.app.utils.UiUtil;
+import org.jcnc.jnotepad.model.entity.Cache;
+import org.jcnc.jnotepad.model.enums.CacheExpirationTime;
+import org.jcnc.jnotepad.ui.component.stage.dialog.factory.impl.BasicFileChooserFactory;
+
+import java.io.File;
+
+import static org.jcnc.jnotepad.app.utils.TabUtil.openFileToTab;
+
+
+/**
+ * 打开文件的事件处理程序。
+ * <p>
+ * 当用户选择打开文件时，将创建一个新的文本编辑区，并在Tab页中显示。
+ *
+ * @author 许轲
+ */
+public class OpenFile implements EventHandler<ActionEvent> {
+    private static final ApplicationCacheManager CACHE_MANAGER = ApplicationCacheManager.getInstance();
+
+    /**
+     * 处理打开文件事件。
+     *
+     * @param event 事件对象
+     */
+    @Override
+    public void handle(ActionEvent event) {
+        // 获取缓存
+        Cache cache = CACHE_MANAGER.getCache("folder", "openFile");
+        // 显示文件选择对话框，并获取选中的文件
+        File file = BasicFileChooserFactory.getInstance().createFileChooser(
+                        UiResourceBundle.getContent(TextConstants.OPEN),
+                        null,
+                        cache == null ? null : new File((String) cache.getCacheData()),
+                        new FileChooser.ExtensionFilter("All types", "*.*"))
+                .showOpenDialog(UiUtil.getAppWindow());
+        if (file == null) {
+            return;
+        }
+        // 设置缓存
+        if (cache == null) {
+            CACHE_MANAGER.addCache(CACHE_MANAGER.createCache("folder", "openFile", file.getParent(), CacheExpirationTime.NEVER_EXPIRES.getValue()));
+        } else {
+            cache.setCacheData(file.getParent());
+            CACHE_MANAGER.addCache(cache);
+        }
+        openFileToTab(file);
+    }
+}

src/main/java/org/jcnc/jnotepad/controller/event/handler/menuitem/RenameFile.java

@@ -0,0 +1,22 @@
+package org.jcnc.jnotepad.controller.event.handler.menuitem;
+
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import org.jcnc.jnotepad.ui.views.manager.CenterTabPaneManager;
+
+import static org.jcnc.jnotepad.app.utils.TabUtil.rename;
+
+/**
+ * 重命名文件事件处理器。
+ * <p>
+ * 当用户选择重命名文件时，如果当前标签页关联文件，则重命名关联文件；
+ * 否则，重命名标签页。
+ *
+ * @author gewuyou
+ */
+public class RenameFile implements EventHandler<ActionEvent> {
+    @Override
+    public void handle(ActionEvent actionEvent) {
+        rename(CenterTabPaneManager.getInstance().getSelected());
+    }
+}

src/main/java/org/jcnc/jnotepad/controller/event/handler/menuitem/SaveAsFile.java

@@ -1,8 +1,10 @@
-package org.jcnc.jnotepad.controller.event.handler;
+package org.jcnc.jnotepad.controller.event.handler.menuitem;
 
 import javafx.event.ActionEvent;
-import org.jcnc.jnotepad.tool.LogUtil;
+import org.jcnc.jnotepad.app.utils.LoggerUtil;
+import org.jcnc.jnotepad.ui.views.manager.CenterTabPaneManager;
 
+import static org.jcnc.jnotepad.app.utils.TabUtil.saveAsFile;
 
 /**
  * 保存文件事件处理器。
@@ -22,7 +24,7 @@ public class SaveAsFile extends SaveFile {
      */
     @Override
     public void handle(ActionEvent event) {
-        LogUtil.getLogger(SaveAsFile.class).info("已调用另存为功能");
-        saveTab(this.getClass());
+        LoggerUtil.getLogger(SaveAsFile.class).info("已调用另存为功能");
+        saveAsFile(CenterTabPaneManager.getInstance().getSelected());
     }
 }

src/main/java/org/jcnc/jnotepad/controller/event/handler/menuitem/SaveFile.java

@@ -0,0 +1,31 @@
+package org.jcnc.jnotepad.controller.event.handler.menuitem;
+
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import org.jcnc.jnotepad.ui.views.manager.CenterTabPaneManager;
+
+import static org.jcnc.jnotepad.app.utils.TabUtil.saveFile;
+
+/**
+ * 保存文件事件处理程序。
+ * <p>
+ * 当用户选择保存文件时，如果当前标签页是关联文件，则自动保存；
+ * 否则，调用另存为方法。
+ *
+ * @author gewuyou
+ */
+public class SaveFile implements EventHandler<ActionEvent> {
+
+    /**
+     * 处理保存文件事件。
+     *
+     * @param actionEvent 事件对象
+     * @apiNote 当用户选择保存文件时，如果当前标签页是关联文件，则自动保存；
+     * 否则，调用另存为方法。
+     */
+    @Override
+    public void handle(ActionEvent actionEvent) {
+        // 保存当前选中的标签页
+        saveFile(CenterTabPaneManager.getInstance().getSelected());
+    }
+}

src/main/java/org/jcnc/jnotepad/controller/event/handler/toolbar/DirTreeBtn.java

@@ -0,0 +1,23 @@
+package org.jcnc.jnotepad.controller.event.handler.toolbar;
+
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import org.jcnc.jnotepad.ui.views.manager.DirectorySidebarManager;
+
+
+/**
+ * 文件树按钮
+ *
+ * <p>文件树按钮事件的事件处理程序。</p>
+ *
+ * @author cccqyu
+ */
+public class DirTreeBtn implements EventHandler<ActionEvent> {
+
+    private static final DirectorySidebarManager DIRECTORY_SIDEBAR_MANAGER = DirectorySidebarManager.getInstance();
+
+    @Override
+    public void handle(ActionEvent actionEvent) {
+        DIRECTORY_SIDEBAR_MANAGER.controlShow();
+    }
+}

src/main/java/org/jcnc/jnotepad/controller/event/handler/toolbar/OpenDirectory.java

@@ -0,0 +1,71 @@
+package org.jcnc.jnotepad.controller.event.handler.toolbar;
+
+
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import org.jcnc.jnotepad.app.common.constants.TextConstants;
+import org.jcnc.jnotepad.app.common.manager.ApplicationCacheManager;
+import org.jcnc.jnotepad.app.i18n.UiResourceBundle;
+import org.jcnc.jnotepad.app.utils.FileUtil;
+import org.jcnc.jnotepad.app.utils.UiUtil;
+import org.jcnc.jnotepad.model.entity.Cache;
+import org.jcnc.jnotepad.model.entity.DirFileModel;
+import org.jcnc.jnotepad.model.enums.CacheExpirationTime;
+import org.jcnc.jnotepad.ui.component.stage.dialog.factory.impl.BasicDirectoryChooserFactory;
+import org.jcnc.jnotepad.ui.views.manager.DirectorySidebarManager;
+
+import java.io.File;
+
+/**
+ * 打开文件夹處理器
+ *
+ * <p>当用户选择打开文件夹时，将创建一个左侧树型结构目录。</p>
+ *
+ * @author cccqyu
+ */
+public class OpenDirectory implements EventHandler<ActionEvent> {
+
+    public static final String GROUP = "directory";
+    private static final ApplicationCacheManager CACHE_MANAGER = ApplicationCacheManager.getInstance();
+    private static final DirectorySidebarManager DIRECTORY_SIDEBAR_MANAGER = DirectorySidebarManager.getInstance();
+
+    @Override
+    public void handle(ActionEvent actionEvent) {
+        // 获取缓存
+        Cache cache = CACHE_MANAGER.getCache(GROUP, "openDirectory");
+
+        // 显示文件选择对话框，并获取选中的文件
+        File file = BasicDirectoryChooserFactory.getInstance().createDirectoryChooser(
+                        UiResourceBundle.getContent(TextConstants.OPEN),
+                        cache == null ? null : new File((String) cache.getCacheData())
+                )
+                .showDialog(UiUtil.getAppWindow());
+        if (file == null) {
+            return;
+        }
+        // 设置缓存
+        if (cache == null) {
+            CACHE_MANAGER.addCache(CACHE_MANAGER.createCache(GROUP, "openDirectory", file.getAbsolutePath(), CacheExpirationTime.NEVER_EXPIRES.getValue()));
+        } else {
+            cache.setCacheData(file.getParent());
+            CACHE_MANAGER.addCache(cache);
+        }
+        flushDirSidebar(file);
+    }
+
+    /**
+     * Flushes the directory sidebar with the given file.
+     *
+     * @param file the file to be converted into an entity class
+     */
+    public void flushDirSidebar(File file) {
+        // 将文件转为实体类
+        DirFileModel dirFileModel = FileUtil.getDirFileModel(file);
+        // 打开侧边栏
+        DIRECTORY_SIDEBAR_MANAGER.controlShow(true);
+        // 设置文件树功能
+        DIRECTORY_SIDEBAR_MANAGER.setTreeView(dirFileModel);
+        // 缓存已打开的文件夹
+        CACHE_MANAGER.addCache(CACHE_MANAGER.createCache(GROUP, "folderThatWasOpened", dirFileModel, CacheExpirationTime.NEVER_EXPIRES.getValue()));
+    }
+}

src/main/java/org/jcnc/jnotepad/controller/event/handler/toolbar/RunBtn.java

@@ -0,0 +1,21 @@
+package org.jcnc.jnotepad.controller.event.handler.toolbar;
+
+
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import org.jcnc.jnotepad.ui.views.manager.BuildPanelManager;
+
+/**
+ * 终端处理器
+ *
+ * @author cccqyu
+ */
+public class RunBtn implements EventHandler<ActionEvent> {
+
+    private static final BuildPanelManager BUILD_PANEL_MANAGER = BuildPanelManager.getInstance();
+
+    @Override
+    public void handle(ActionEvent event) {
+        BUILD_PANEL_MANAGER.controlShow();
+    }
+}

src/main/java/org/jcnc/jnotepad/controller/event/handler/toolbar/SetBtn.java

@@ -0,0 +1,34 @@
+package org.jcnc.jnotepad.controller.event.handler.toolbar;
+
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import org.jcnc.jnotepad.ui.component.stage.setting.SetStage;
+
+/**
+ * 设置按钮事件的事件处理程序。
+ *
+ * <p>当用户点击设置按钮时，将打开设置窗口。</p>
+ *
+ * @author 许轲
+ */
+public class SetBtn implements EventHandler<ActionEvent> {
+    /**
+     * 标志变量，跟踪Stage是否已创建
+     */
+    private boolean isStageCreated = false;
+
+    /**
+     * 打开设置窗口处理事件。
+     *
+     * @param event 事件对象
+     */
+    @Override
+    public void handle(ActionEvent event) {
+        if (!isStageCreated) {
+            SetStage.getInstance().openSetStage();
+            // 设置标志变量为true，表示Stage已创建
+            isStageCreated = true;
+        }
+    }
+}
+

src/main/java/org/jcnc/jnotepad/controller/exception/AppException.java

@@ -0,0 +1,29 @@
+package org.jcnc.jnotepad.controller.exception;
+
+/**
+ * 应用异常类，用于处理应用程序中的异常情况。
+ *
+ * <p>应用异常是一个运行时异常，通常用于捕获和处理应用程序中的不可预料的错误和异常情况。</p>
+ *
+ * @author gewuyou
+ */
+public class AppException extends RuntimeException {
+
+    /**
+     * 构造一个应用异常对象。
+     *
+     * @param message 异常消息
+     */
+    public AppException(String message) {
+        super(message);
+    }
+
+    /**
+     * 构造一个应用异常对象。
+     *
+     * @param cause 异常的原因
+     */
+    public AppException(Throwable cause) {
+        super(cause);
+    }
+}

src/main/java/org/jcnc/jnotepad/controller/i18n/LocalizationController.java

@@ -1,23 +1,24 @@
 package org.jcnc.jnotepad.controller.i18n;
 
-import org.jcnc.jnotepad.LunchApp;
-import org.jcnc.jnotepad.app.i18n.UIResourceBundle;
-import org.jcnc.jnotepad.controller.config.AppConfigController;
+import org.jcnc.jnotepad.JnotepadApp;
+import org.jcnc.jnotepad.app.i18n.UiResourceBundle;
+import org.jcnc.jnotepad.controller.config.UserConfigController;
 
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.Locale;
 import java.util.Map;
 
-import static org.jcnc.jnotepad.constants.TextConstants.CHINESE;
-import static org.jcnc.jnotepad.constants.TextConstants.ENGLISH;
+import static org.jcnc.jnotepad.app.common.constants.TextConstants.CHINESE;
+import static org.jcnc.jnotepad.app.common.constants.TextConstants.ENGLISH;
 
 /**
- * 本地化配置文件<br>
- * 注意：该配置文件必须先于快捷键配置文件加载
+ * 本地化控制器
+ *
+ * <p>该类负责处理应用程序的本地化配置，包括语言和区域设置。</p>
  *
  * @author gewuyou
- * @see LunchApp
+ * @see JnotepadApp
  */
 public class LocalizationController {
     private static final LocalizationController LOCALIZATION_CONFIG = new LocalizationController();
@@ -36,21 +37,25 @@ public class LocalizationController {
         SUPPORT_LANGUAGES.put(Locale.ENGLISH, ENGLISH);
     }
 
+    private final UserConfigController userConfigController;
+
+    private LocalizationController() {
+        this.userConfigController = UserConfigController.getInstance();
+    }
+
+    /**
+     * 获取当前语言配置
+     *
+     * @return 当前语言的Locale对象
+     */
     public static Locale getCurrentLocal() {
         return Locale.getDefault();
     }
 
-    /**
-     * 初始化语言配置
-     */
-    public static void initLocal() {
-        setCurrentLocal(null);
-    }
-
     /**
      * 设置当前语言配置
      *
-     * @param locale 当前语言Local对象
+     * @param locale 当前语言的Locale对象
      */
     public static void setCurrentLocal(Locale locale) {
         if (locale != null && locale.equals(getCurrentLocal())) {
@@ -65,19 +70,15 @@ public class LocalizationController {
         }
         Locale.setDefault(locale);
 
-        UIResourceBundle.getInstance().resetLocal(getCurrentLocal());
+        UiResourceBundle.getInstance().resetLocal(getCurrentLocal());
         LOCALIZATION_CONFIG.setLanguage(SUPPORT_LANGUAGES.get(locale));
     }
 
-    private LocalizationController() {
-        this.appConfigController = AppConfigController.getInstance();
-    }
-
-    private final AppConfigController appConfigController;
-
-
-    private void setLanguage(String language) {
-        appConfigController.updateLanguage(language);
+    /**
+     * 初始化语言配置
+     */
+    public static void initLocal() {
+        setCurrentLocal(null);
     }
 
     /**
@@ -86,6 +87,10 @@ public class LocalizationController {
      * @return appConfig中的当前语言配置
      */
     public String getLanguage() {
-        return appConfigController.getLanguage();
+        return userConfigController.getLanguage();
+    }
+
+    private void setLanguage(String language) {
+        userConfigController.updateLanguage(language);
     }
 }

src/main/java/org/jcnc/jnotepad/controller/manager/Controller.java

@@ -1,25 +1,34 @@
 package org.jcnc.jnotepad.controller.manager;
 
-import org.jcnc.jnotepad.Interface.ControllerInterface;
-import org.jcnc.jnotepad.controller.event.handler.NewFile;
-import org.jcnc.jnotepad.controller.event.handler.OpenFile;
+import org.jcnc.jnotepad.app.common.manager.ApplicationCacheManager;
+import org.jcnc.jnotepad.ui.component.module.interfaces.ControllerAble;
 
 import java.io.File;
+import java.util.Collections;
 import java.util.List;
+import java.util.Optional;
+
+import static org.jcnc.jnotepad.app.utils.TabUtil.addNewFileTab;
+import static org.jcnc.jnotepad.app.utils.TabUtil.openFileToTab;
 
 /**
- * 控制器类，实现ControllerInterface接口，用于管理文本编辑器的各种操作和事件处理。
- * 包括打开关联文件、创建文本区域、处理行分隔、新建文件、打开文件、自动保存等功能。
+ * 控制器类，实现 ControllerAble 接口，用于管理文本编辑器的各种操作和事件处理。
  *
  * @author 许轲
  */
-public class Controller implements ControllerInterface {
+public class Controller implements ControllerAble<List<String>> {
+    private static final ApplicationCacheManager CACHE_MANAGER = ApplicationCacheManager.getInstance();
 
     private static final Controller INSTANCE = new Controller();
 
     private Controller() {
     }
 
+    /**
+     * 获取 Controller 的唯一实例。
+     *
+     * @return Controller 的实例
+     */
     public static Controller getInstance() {
         return INSTANCE;
     }
@@ -28,15 +37,22 @@ public class Controller implements ControllerInterface {
      * 打开关联文件并创建文本区域。
      *
      * @param rawParameters 原始参数列表
-     * @return 创建的文本区域
      */
     @Override
     public void openAssociatedFileAndCreateTextArea(List<String> rawParameters) {
+        // 获取上次打开的页面
+        Optional<Object> cacheData = Optional.ofNullable(CACHE_MANAGER.getCacheData("tabs", "centerTabs"));
+        // 判空
+        List<String> fileTab = (List<String>) cacheData.orElse(Collections.emptyList());
+        // 打开上次打开的标签页
+        fileTab.forEach(filePath -> openFileToTab(new File(filePath)));
         if (!rawParameters.isEmpty()) {
             String filePath = rawParameters.get(0);
             openAssociatedFile(filePath);
-        } else {
-            new NewFile().addNewFileTab();
+            return;
+        }
+        if (fileTab.isEmpty()) {
+            addNewFileTab();
         }
     }
 
@@ -49,7 +65,7 @@ public class Controller implements ControllerInterface {
     public void openAssociatedFile(String filePath) {
         File file = new File(filePath);
         if (file.exists() && file.isFile()) {
-            new OpenFile().createOpenFileTask(file);
+            openFileToTab(file);
         }
     }
 }

src/main/java/org/jcnc/jnotepad/controller/plugin/PluginLoader.java

@@ -0,0 +1,285 @@
+package org.jcnc.jnotepad.controller.plugin;
+
+import org.jcnc.jnotepad.app.common.manager.ThreadPoolManager;
+import org.jcnc.jnotepad.app.utils.JsonUtil;
+import org.jcnc.jnotepad.app.utils.LoggerUtil;
+import org.jcnc.jnotepad.controller.config.PluginConfigController;
+import org.jcnc.jnotepad.controller.exception.AppException;
+import org.jcnc.jnotepad.controller.plugin.interfaces.Plugin;
+import org.jcnc.jnotepad.controller.plugin.manager.PluginManager;
+import org.jcnc.jnotepad.model.entity.PluginDescriptor;
+import org.slf4j.Logger;
+
+import java.io.*;
+import java.lang.reflect.InvocationTargetException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.*;
+import java.util.concurrent.ExecutorService;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.stream.Stream;
+import java.util.zip.ZipEntry;
+
+/**
+ * 插件加载类
+ *
+ * @author gewuyou
+ */
+public class PluginLoader {
+    private static final PluginLoader INSTANCE = new PluginLoader();
+
+    private static final ExecutorService THREAD_POOL = ThreadPoolManager.getThreadPool();
+    Logger logger = LoggerUtil.getLogger(this.getClass());
+
+    /**
+     * 从插件jar包中读取 json 文件到 PluginDescriptor 类
+     *
+     * @param pluginJar jar 包
+     */
+    public static PluginDescriptor readPlugin(File pluginJar) throws IOException {
+        InputStream is;
+        StringBuilder sb;
+        try (JarFile jarFile = new JarFile(pluginJar)) {
+            ZipEntry zipEntry = jarFile.getEntry("META-INF/plugin.json");
+            is = jarFile.getInputStream(zipEntry);
+
+            try (BufferedReader br = new BufferedReader(new InputStreamReader(is))) {
+                String temp;
+                sb = new StringBuilder();
+                while ((temp = br.readLine()) != null) {
+                    sb.append(temp);
+                }
+            }
+        }
+        return JsonUtil.OBJECT_MAPPER.readValue(sb.toString(), PluginDescriptor.class);
+    }
+
+    public static PluginLoader getInstance() {
+        return INSTANCE;
+    }
+
+    /**
+     * 检查插件
+     *
+     * @param configPluginDescriptors 配置文件插件信息
+     * @param pluginDescriptor        插件信息类
+     * @param pluginDescriptors       插件信息集合
+     * @return boolean 是否检查通过
+     * @apiNote
+     * @since 2023/9/16 14:04
+     */
+    private static boolean checkPlugin(List<PluginDescriptor> configPluginDescriptors, PluginDescriptor pluginDescriptor, List<PluginDescriptor> pluginDescriptors) {
+        // 如果应用程序配置文件中没有该插件则默认禁用
+        if (pluginDoesNotExist(pluginDescriptor, configPluginDescriptors)) {
+            disabledByDefault(configPluginDescriptors, pluginDescriptor, pluginDescriptors);
+            THREAD_POOL.submit(() -> {
+                PluginConfigController.getInstance().writeConfig();
+                ThreadPoolManager.threadContSelfSubtracting();
+            });
+            return true;
+        }
+        // 如果应用程序配置文件中该插件禁用则不加载
+        for (PluginDescriptor configPluginDescriptor : configPluginDescriptors) {
+            if (disableDoNotLoad(pluginDescriptor, pluginDescriptors, configPluginDescriptor)) {
+                return true;
+            }
+        }
+        // 判断该插件是否已经加载
+        return loaded(pluginDescriptor, pluginDescriptors);
+    }
+
+    /**
+     * 插件不存在
+     *
+     * @param pluginDescriptor        插件描述类
+     * @param configPluginDescriptors 配置文件插件信息集合
+     * @return boolean 插件不存在
+     * @apiNote
+     * @since 2023/9/19 19:16
+     */
+    private static boolean pluginDoesNotExist(PluginDescriptor pluginDescriptor, List<PluginDescriptor> configPluginDescriptors) {
+        for (PluginDescriptor configPluginDescriptor : configPluginDescriptors) {
+            if (configPluginDescriptor.getId().equals(pluginDescriptor.getId())) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static boolean loaded(PluginDescriptor pluginDescriptor, List<PluginDescriptor> pluginDescriptors) {
+        Iterator<PluginDescriptor> iterator = pluginDescriptors.iterator();
+        while (iterator.hasNext()) {
+            PluginDescriptor plugin = iterator.next();
+            if (plugin.getId().equals(pluginDescriptor.getId())) {
+                if (plugin.getVersion().equals(pluginDescriptor.getVersion())) {
+                    return true;
+                }
+                // 如果当前插件版本更低则更新
+                if (plugin.getVersion().compareTo(pluginDescriptor.getVersion()) < 0) {
+                    // 删除当前的插件
+                    iterator.remove();
+                } else {
+                    throw new AppException("当前加载的插件版本低于本地版本!");
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * 如果插件被禁用则不加载
+     *
+     * @param pluginDescriptor       插件描述类
+     * @param pluginDescriptors      插件描述类集合
+     * @param configPluginDescriptor 配置文件插件信息
+     * @return boolean
+     * @apiNote
+     * @since 2023/9/19 18:45
+     */
+    private static boolean disableDoNotLoad(PluginDescriptor pluginDescriptor, List<PluginDescriptor> pluginDescriptors, PluginDescriptor configPluginDescriptor) {
+        if (configPluginDescriptor.getId().equals(pluginDescriptor.getId()) && !configPluginDescriptor.isEnabled()) {
+            pluginDescriptor.setEnabled(false);
+            pluginDescriptors.add(pluginDescriptor);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * 默认禁用
+     *
+     * @param configPluginDescriptors 配置文件插件信息
+     * @param pluginDescriptor        插件描述类
+     * @param pluginDescriptors       插件描述类集合
+     * @apiNote
+     * @since 2023/9/19 18:48
+     */
+    private static void disabledByDefault(List<PluginDescriptor> configPluginDescriptors, PluginDescriptor pluginDescriptor, List<PluginDescriptor> pluginDescriptors) {
+        pluginDescriptor.setEnabled(false);
+        pluginDescriptors.add(pluginDescriptor);
+        configPluginDescriptors.add(pluginDescriptor);
+    }
+
+    /**
+     * 加载插件
+     *
+     * @param pluginFilePath 插件文件的路径
+     */
+    public void loadPluginByPath(String pluginFilePath) {
+        File file = new File(pluginFilePath);
+        loadPluginByFile(file, PluginConfigController.getInstance().getConfig().getPlugins());
+    }
+
+    /**
+     * 根据文件加载插件
+     *
+     * @param pluginJar               插件jar包
+     * @param configPluginDescriptors 配置文件插件信息集合
+     * @apiNote
+     * @since 2023/9/16 14:05
+     */
+    public void loadPluginByFile(File pluginJar, List<PluginDescriptor> configPluginDescriptors) {
+        PluginManager pluginManager = PluginManager.getInstance();
+        Map<String, List<String>> categories = pluginManager.getLoadedPluginsByCategory();
+        List<PluginDescriptor> pluginDescriptors = pluginManager.getPluginDescriptors();
+        if (pluginJar.exists() && pluginJar.isFile()) {
+            try {
+                PluginDescriptor pluginDescriptor = readPlugin(pluginJar);
+                // 检查插件状态
+                if (checkPlugin(configPluginDescriptors, pluginDescriptor, pluginDescriptors)) {
+                    return;
+                }
+                pluginDescriptor.setEnabled(true);
+                pluginDescriptors.add(pluginDescriptor);
+                // 创建URLClassLoader以加载Jar文件中的类
+                Class<?> pluginClass = loaderJarFileClass(pluginJar, pluginDescriptor);
+                if (pluginClass == null) {
+                    return;
+                }
+                Plugin plugin;
+                plugin = (Plugin) pluginClass.getDeclaredConstructor().newInstance();
+                pluginDescriptor.setPlugin(plugin);
+                categories.computeIfAbsent(pluginDescriptor.getCategory(), k -> new ArrayList<>()).add(pluginDescriptor.getName());
+            } catch (IOException | InvocationTargetException | InstantiationException | IllegalAccessException e) {
+                throw new AppException(e);
+            } catch (ClassNotFoundException e) {
+                logger.error("无法找到对应的插件类!", e);
+            } catch (NoSuchMethodException e) {
+                logger.error("插件类中没有找到指定方法!", e);
+            }
+
+        } else {
+            logger.info("PluginDescriptor file not found");
+        }
+    }
+
+    /**
+     * 加载类中的class文件并返回插件主类
+     *
+     * @param pluginJar        插件jar包
+     * @param pluginDescriptor 插件描述
+     * @return java.lang.Class<?> 插件主类
+     * @apiNote
+     * @since 2023/9/19 14:00
+     */
+    private Class<?> loaderJarFileClass(File pluginJar, PluginDescriptor pluginDescriptor) throws IOException, ClassNotFoundException {
+        Class<?> pluginClass;
+        try (
+                URLClassLoader classLoader = new URLClassLoader(new URL[]{pluginJar.toURI().toURL()});
+                JarFile jar = new JarFile(pluginJar)
+        ) {
+            // 加载插件所需的依赖类
+            Enumeration<JarEntry> entries = jar.entries();
+            while (entries.hasMoreElements()) {
+                JarEntry entry = entries.nextElement();
+                if (entry.getName().endsWith(".class")) {
+                    String className = entry.getName().replace("/", ".").replace(".class", "");
+                    if (!pluginDescriptor.getMainClass().equals(className) && !"module-info".equals(className)) {
+                        classLoader.loadClass(className);
+                    }
+                }
+            }
+            pluginClass = classLoader.loadClass(pluginDescriptor.getMainClass());
+        }
+        logger.info("已加载插件：{}", pluginDescriptor.getName());
+        return pluginClass;
+    }
+
+    /**
+     * 装载插件
+     *
+     * @since 2023/9/15 21:39
+     */
+    public void loadPlugins() {
+        // 扫描并装载插件
+        scanLoadPlugins(PluginConfigController.getInstance().getPlungsPath());
+    }
+
+    /**
+     * 扫描插件
+     *
+     * @param pluginsPath 插件路径
+     * @apiNote 扫描所有插件，更新配置文件中的插件信息
+     * @since 2023/9/16 0:21
+     */
+
+    private void scanLoadPlugins(Path pluginsPath) {
+        if (!Files.isDirectory(pluginsPath)) {
+            try {
+                Files.createDirectory(pluginsPath);
+            } catch (IOException e) {
+                throw new AppException("这不是一个有效的路径!");
+            }
+        }
+        // 获取插件加载器
+        PluginLoader pluginLoader = PluginLoader.getInstance();
+        try (Stream<Path> pathStream = Files.walk(pluginsPath)) {
+            pathStream.filter(path -> path.toString().endsWith(".jar")).forEach(path -> pluginLoader.loadPluginByPath(path.toString()));
+        } catch (Exception e) {
+            logger.error(e.getMessage(), e);
+        }
+    }
+}

src/main/java/org/jcnc/jnotepad/controller/plugin/PluginManagerInterface.java

@@ -0,0 +1,118 @@
+package org.jcnc.jnotepad.controller.plugin;
+
+import javafx.scene.Scene;
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+import javafx.scene.layout.VBox;
+import javafx.stage.FileChooser;
+import javafx.stage.Stage;
+import org.jcnc.jnotepad.app.utils.LoggerUtil;
+import org.jcnc.jnotepad.app.utils.PopUpUtil;
+import org.jcnc.jnotepad.app.utils.UiUtil;
+import org.jcnc.jnotepad.controller.plugin.manager.PluginManager;
+import org.jcnc.jnotepad.ui.component.stage.dialog.factory.impl.BasicFileChooserFactory;
+import org.slf4j.Logger;
+
+import java.io.File;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 插件管理界面
+ * <p>
+ * 用于演示插件加载和执行的界面。
+ *
+ * @author luke gewuyou
+ */
+public class PluginManagerInterface {
+    private static final PluginManagerInterface INSTANCE = new PluginManagerInterface();
+    Logger logger = LoggerUtil.getLogger(this.getClass());
+
+    public static PluginManagerInterface getInstance() {
+        return INSTANCE;
+    }
+
+    /**
+     * 启动插件演示界面
+     *
+     * @param primaryStage JavaFX的主舞台
+     */
+    public void start(Stage primaryStage) {
+        PluginManager pluginManager = PluginManager.getInstance();
+
+        FileChooser fileChooser = BasicFileChooserFactory.getInstance().createFileChooser(
+                "选择插件",
+                null,
+                null,
+                new FileChooser.ExtensionFilter("JAR Files", "*.jar")
+        );
+        Button loadButton = createLoadButton(primaryStage, fileChooser, pluginManager);
+
+        Button executeButton = new Button("执行插件");
+        executeButton.setOnAction(event -> pluginManager.executePlugins());
+
+        VBox root = new VBox(10, loadButton, executeButton);
+        Scene scene = new Scene(root, 300, 200);
+        primaryStage.getIcons().add(UiUtil.getAppIcon());
+        primaryStage.setScene(scene);
+        primaryStage.setTitle("插件演示");
+        primaryStage.show();
+    }
+
+    /**
+     * 显示已加载插件的信息
+     *
+     * @param primaryStage  JavaFX的主舞台
+     * @param pluginManager 插件管理器
+     */
+    private void displayPluginInfo(Stage primaryStage, PluginManager pluginManager) {
+        Map<String, List<String>> loadedPluginsByCategory = pluginManager.getLoadedPluginsByCategory();
+        VBox infoBox = new VBox();
+
+        loadedPluginsByCategory.forEach((key, pluginNames) -> {
+            Label categoryLabel = new Label("类别: " + key);
+            VBox categoryInfoBox = new VBox();
+            for (String pluginName : pluginNames) {
+                Label pluginLabel = new Label("插件名称: " + pluginName);
+                categoryInfoBox.getChildren().add(pluginLabel);
+            }
+            infoBox.getChildren().addAll(categoryLabel, categoryInfoBox);
+        });
+        Scene infoScene = new Scene(infoBox, 400, 300);
+        Stage infoStage = new Stage();
+        infoStage.setScene(infoScene);
+        infoStage.setTitle("已加载的插件");
+        infoStage.initOwner(primaryStage);
+        infoStage.show();
+    }
+
+    /**
+     * 创建加载插件的按钮
+     *
+     * @param primaryStage  JavaFX的主舞台
+     * @param fileChooser   文件选择器
+     * @param pluginManager 插件管理器
+     * @return 加载插件的按钮
+     */
+    private Button createLoadButton(Stage primaryStage, FileChooser fileChooser, PluginManager pluginManager) {
+        Button loadButton = new Button("加载插件");
+        loadButton.setOnAction(event -> {
+            try {
+                File selectedFile = fileChooser.showOpenDialog(primaryStage);
+                if (selectedFile != null) {
+                    String pluginFilePath = selectedFile.getAbsolutePath();
+                    PluginLoader.getInstance().loadPluginByPath(pluginFilePath);
+
+                    // 更新插件信息显示
+                    displayPluginInfo(primaryStage, pluginManager);
+                } else {
+                    PopUpUtil.infoAlert(null, null, "未找到插件!", null, null);
+                    logger.info("未找到插件!");
+                }
+            } catch (Exception e) {
+                logger.error("加载插件失败!", e);
+            }
+        });
+        return loadButton;
+    }
+}

src/main/java/org/jcnc/jnotepad/controller/plugin/aReadme.md

@@ -0,0 +1 @@
+plugin 存放插件相关的代码，包括插件接口和管理器。

src/main/java/org/jcnc/jnotepad/controller/plugin/interfaces/Plugin.java

@@ -0,0 +1,27 @@
+package org.jcnc.jnotepad.controller.plugin.interfaces;
+
+
+/**
+ * 插件接口
+ * <p>
+ * 描述插件的基本功能。
+ *
+ * @author luke gewuyou
+ */
+public interface Plugin {
+
+    /**
+     * 初始化插件
+     */
+    void initialize();
+
+    /**
+     * 执行插件的逻辑
+     */
+    void execute();
+
+    /**
+     * 销毁资源
+     */
+    void destroyed();
+}

src/main/java/org/jcnc/jnotepad/controller/plugin/manager/PluginManager.java

@@ -0,0 +1,222 @@
+package org.jcnc.jnotepad.controller.plugin.manager;
+
+import org.jcnc.jnotepad.app.common.manager.ThreadPoolManager;
+import org.jcnc.jnotepad.app.manager.ApplicationManager;
+import org.jcnc.jnotepad.app.utils.LoggerUtil;
+import org.jcnc.jnotepad.app.utils.PopUpUtil;
+import org.jcnc.jnotepad.controller.config.PluginConfigController;
+import org.jcnc.jnotepad.model.entity.PluginDescriptor;
+import org.slf4j.Logger;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Stream;
+
+import static org.jcnc.jnotepad.controller.plugin.PluginLoader.readPlugin;
+
+/**
+ * 插件管理器
+ * <p>
+ * 该类用于管理插件的加载和执行。
+ * 插件可以通过加载外部JAR文件中的类来扩展应用程序的功能。
+ *
+ * @author luke
+ */
+public class PluginManager {
+    private static final PluginManager INSTANCE = new PluginManager();
+    /**
+     * 插件类别
+     */
+    private final Map<String, List<String>> categories = new HashMap<>();
+    Logger logger = LoggerUtil.getLogger(this.getClass());
+    /**
+     * 插件信息
+     */
+    private List<PluginDescriptor> pluginDescriptors = new ArrayList<>();
+    /**
+     * 插件信息临时集合
+     */
+    private List<PluginDescriptor> temporaryPluginDescriptors;
+
+    private PluginManager() {
+
+    }
+
+    public static PluginManager getInstance() {
+        return INSTANCE;
+    }
+
+    /**
+     * 初始化插件临时集合
+     */
+    public void initializeTemporaryPluginDescriptors() {
+        temporaryPluginDescriptors = new ArrayList<>(pluginDescriptors.size());
+        pluginDescriptors.forEach(pluginDescriptor -> temporaryPluginDescriptors.add(new PluginDescriptor(pluginDescriptor)));
+    }
+
+    /**
+     * 卸载插件
+     *
+     * @param pluginDescriptor 插件信息类
+     * @since 2023/9/11 12:28
+     */
+    public void unloadPlugin(PluginDescriptor pluginDescriptor) {
+        // 删除集合中的插件信息
+        ThreadPoolManager.getThreadPool().submit(() -> {
+            // 移除插件管理类中的插件描述类
+            pluginDescriptors.remove(pluginDescriptor);
+            // 移除插件配置文件类中的插件描述类
+            PluginConfigController instance = PluginConfigController.getInstance();
+            instance.getConfig().getPlugins().remove(pluginDescriptor);
+
+            // 刷新配置
+            instance.writeConfig();
+            // 删除本地插件jar包
+            Path plungsPath = instance.getPlungsPath();
+            try (Stream<Path> pathStream = Files.walk(plungsPath)) {
+                pathStream.filter(path -> path.toString().endsWith(".jar")).forEach(path -> {
+                    try {
+                        File pluginJar = new File(path.toString());
+                        PluginDescriptor temp = readPlugin(pluginJar);
+                        if (temp.getId().equals(pluginDescriptor.getId())) {
+                            Files.delete(pluginJar.toPath());
+                        }
+                    } catch (IOException e) {
+                        logger.error(e.getMessage(), e);
+                    }
+                });
+            } catch (Exception e) {
+                logger.error(e.getMessage(), e);
+            }
+            ThreadPoolManager.threadContSelfSubtracting();
+        });
+    }
+
+    /**
+     * 禁用插件
+     *
+     * @param pluginDescriptor 需要禁用的某个插件的插件类
+     * @apiNote
+     * @since 2023/9/11 12:34
+     */
+    public void disablePlugIn(PluginDescriptor pluginDescriptor) {
+        pluginDescriptor.setEnabled(false);
+    }
+
+    /**
+     * 初始化所有启用的插件
+     */
+    public void initPlugins() {
+        for (PluginDescriptor pluginDescriptor : pluginDescriptors) {
+            if (pluginDescriptor.isEnabled()) {
+                pluginDescriptor.getPlugin().initialize();
+            }
+        }
+    }
+
+    /**
+     * 执行插件
+     *
+     * @param pluginDescriptor 需要执行的插件的信息类
+     * @apiNote
+     * @since 2023/9/16 14:58
+     */
+    public void executePlugin(PluginDescriptor pluginDescriptor) {
+        pluginDescriptor.getPlugin().execute();
+    }
+
+    /**
+     * 执行加载的插件
+     *
+     * @deprecated 待删除
+     */
+    public void executePlugins() {
+        for (PluginDescriptor pluginDescriptor : pluginDescriptors) {
+            if (pluginDescriptor.isEnabled()) {
+                pluginDescriptor.getPlugin().execute();
+            }
+        }
+    }
+
+    /**
+     * 销毁插件可能申请的资源
+     */
+    public void destroyPlugins() {
+        for (PluginDescriptor pluginDescriptor : pluginDescriptors) {
+            if (pluginDescriptor.isEnabled() && pluginDescriptor.getPlugin() != null) {
+                pluginDescriptor.getPlugin().destroyed();
+            }
+        }
+    }
+
+    /**
+     * 获取按类别分类的已加载插件
+     *
+     * @return 插件类别映射
+     */
+    public Map<String, List<String>> getLoadedPluginsByCategory() {
+        return categories;
+    }
+
+    public List<PluginDescriptor> getPluginDescriptors() {
+        return pluginDescriptors;
+    }
+
+
+    public List<PluginDescriptor> getTemporaryPluginDescriptors() {
+        return temporaryPluginDescriptors;
+    }
+
+    /**
+     * 启用插件
+     *
+     * @param pluginDescriptor 插件信息类
+     */
+    public void enablePlugIn(PluginDescriptor pluginDescriptor) {
+        pluginDescriptor.setEnabled(true);
+    }
+
+    /**
+     * 保存插件设置并退出
+     */
+    public void saveAndExitSettings() {
+        settingsChange();
+        clearTemporarySettings();
+    }
+
+    /**
+     * 设置更改
+     */
+    private void settingsChange() {
+        boolean equals = temporaryPluginDescriptors.equals(pluginDescriptors);
+        if (!equals) {
+            pluginDescriptors = temporaryPluginDescriptors;
+            PopUpUtil.questionAlert("更改", "程序与插件更新", "请重启程序以应用插件中的更改!",
+                    appDialog -> {
+                        appDialog.close();
+                        // 执行重启操作
+                        ApplicationManager.getInstance().restart();
+                    }, null, "重启", "以后再说");
+        }
+    }
+
+    /**
+     * 保存插件设置但不退出
+     */
+    public void saveNotExitSettings() {
+        settingsChange();
+    }
+
+    /**
+     * 清除插件临时设置
+     */
+    public void clearTemporarySettings() {
+        temporaryPluginDescriptors = null;
+    }
+}

src/main/java/org/jcnc/jnotepad/exception/AppException.java

@@ -1,17 +0,0 @@
-package org.jcnc.jnotepad.exception;
-
-/**
- * 应用异常类
- *
- * @author gewuyou
- */
-public class AppException extends RuntimeException {
-    public AppException(String message) {
-        super(message);
-    }
-
-    public AppException(Throwable cause) {
-        super(cause);
-    }
-
-}

src/main/java/org/jcnc/jnotepad/model/aReadme.md

@@ -0,0 +1 @@
+model 存放模型相关的代码，包括实体类和枚举。

src/main/java/org/jcnc/jnotepad/model/entity/Cache.java

@@ -0,0 +1,123 @@
+package org.jcnc.jnotepad.model.entity;
+
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+
+/**
+ * 缓存类
+ *
+ * @author gewuyou
+ */
+public class Cache {
+    /**
+     * 命名空间
+     */
+    @JsonIgnore
+    private String namespace;
+    /**
+     * 组
+     */
+    @JsonIgnore
+    private String group;
+    /**
+     * 缓存名称
+     */
+    @JsonIgnore
+    private String name;
+
+    /**
+     * 缓存数据
+     */
+    private Object cacheData;
+    /**
+     * 过期时间<br/>如果过期时间为负数则永不过期
+     */
+    private Long expirationTime;
+    /**
+     * 上次读或写时间
+     */
+    private Long lastReadOrWriteTime;
+
+    public Cache() {
+
+    }
+
+    public Cache(String namespace, String group, String name, Object cacheData, Long expirationTime) {
+        this.namespace = namespace;
+        this.group = group;
+        this.name = name;
+        this.cacheData = cacheData;
+        this.expirationTime = expirationTime;
+        this.lastReadOrWriteTime = System.currentTimeMillis();
+    }
+
+    /**
+     * 生成缓存key
+     *
+     * @param namespace 命名空间
+     * @param group     组
+     * @param name      缓存名称
+     * @return 缓存key
+     */
+    public static String getCacheKey(String namespace, String group, String name) {
+        return namespace + "." + group + "." + name;
+    }
+
+    /**
+     * 获取缓存key
+     *
+     * @return key
+     */
+    @JsonIgnore
+    public String getCacheKey() {
+        return getCacheKey(namespace, group, name);
+    }
+
+    public String getNamespace() {
+        return namespace;
+    }
+
+    public void setNamespace(String namespace) {
+        this.namespace = namespace;
+    }
+
+    public String getGroup() {
+        return group;
+    }
+
+    public void setGroup(String group) {
+        this.group = group;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Object getCacheData() {
+        return cacheData;
+    }
+
+    public void setCacheData(Object cacheData) {
+        this.cacheData = cacheData;
+    }
+
+    public Long getExpirationTime() {
+        return expirationTime;
+    }
+
+    public void setExpirationTime(Long expirationTime) {
+        this.expirationTime = expirationTime;
+    }
+
+    public Long getLastReadOrWriteTime() {
+        return lastReadOrWriteTime;
+    }
+
+    public void setLastReadOrWriteTime(Long lastReadOrWriteTime) {
+        this.lastReadOrWriteTime = lastReadOrWriteTime;
+    }
+}

src/main/java/org/jcnc/jnotepad/model/entity/DefaultContextMenu.java

@@ -0,0 +1,56 @@
+package org.jcnc.jnotepad.model.entity;
+
+import javafx.scene.control.ContextMenu;
+import javafx.scene.control.MenuItem;
+
+/**
+ * 默认上下文菜单
+ *
+ * @author gewuyou
+ */
+public class DefaultContextMenu extends ContextMenu {
+    private final MenuItem fold;
+    private final MenuItem unfold;
+    private final MenuItem print;
+
+    public DefaultContextMenu() {
+        fold = new MenuItem("折叠所选文本");
+        fold.setOnAction(aE -> {
+            hide();
+            fold();
+        });
+
+        unfold = new MenuItem("从光标处展开");
+        unfold.setOnAction(aE -> {
+            hide();
+            unfold();
+        });
+
+        print = new MenuItem("打印");
+        print.setOnAction(aE -> {
+            hide();
+            print();
+        });
+
+        getItems().addAll(fold, unfold, print);
+    }
+
+    /**
+     * 折叠多行所选文本，仅显示第一行并隐藏其余部分。
+     */
+    private void fold() {
+        ((org.fxmisc.richtext.CodeArea) getOwnerNode()).foldSelectedParagraphs();
+    }
+
+    /**
+     * 展开当前行/段落（如果有折叠）。
+     */
+    private void unfold() {
+        org.fxmisc.richtext.CodeArea area = (org.fxmisc.richtext.CodeArea) getOwnerNode();
+        area.unfoldParagraphs(area.getCurrentParagraph());
+    }
+
+    private void print() {
+        System.out.println(((org.fxmisc.richtext.CodeArea) getOwnerNode()).getText());
+    }
+}

src/main/java/org/jcnc/jnotepad/model/entity/DirFileModel.java

@@ -0,0 +1,133 @@
+package org.jcnc.jnotepad.model.entity;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import javafx.scene.Node;
+
+import java.io.File;
+import java.util.List;
+
+
+/**
+ * 文件夹实体类
+ *
+ * <p>用于存储文件夹结构</p>
+ *
+ * @author cccqyu
+ */
+public class DirFileModel {
+    /**
+     * 路径
+     */
+    private String path;
+
+    /**
+     * 文件名
+     */
+    @JsonIgnore
+    private String name;
+
+    /**
+     * 未选中时的图标
+     */
+    @JsonIgnore
+    private Node iconIsNotSelected;
+    /**
+     * 选中时的图标
+     */
+    @JsonIgnore
+    private Node iconIsSelected;
+    /**
+     * 子文件
+     */
+    private List<DirFileModel> childFile;
+
+    /**
+     * 是否打开
+     */
+    private boolean isOpen;
+
+    public DirFileModel(String path, String name, List<DirFileModel> childFile, Node iconIsNotSelected, Node iconIsSelected) {
+        this.path = path;
+        this.name = name;
+        this.childFile = childFile;
+        this.iconIsNotSelected = iconIsNotSelected;
+        this.iconIsSelected = iconIsSelected;
+        this.isOpen = false;
+    }
+
+    public DirFileModel(String path, String name, List<DirFileModel> childFile, Node iconIsNotSelected, Node iconIsSelected, boolean isOpen) {
+        this.path = path;
+        this.name = name;
+        this.childFile = childFile;
+        this.iconIsNotSelected = iconIsNotSelected;
+        this.iconIsSelected = iconIsSelected;
+        this.isOpen = isOpen;
+    }
+
+    public DirFileModel() {
+    }
+
+    /**
+     * Check if the given `DirFileModel` represents a directory.
+     *
+     * @param childFile the `DirFileModel` to check
+     * @return `true` if the `childFile` represents a directory, `false` otherwise
+     */
+    public static boolean isDirectoryByDirFileModel(DirFileModel childFile) {
+        return new File(childFile.getPath()).isDirectory();
+    }
+
+    public boolean isOpen() {
+        return isOpen;
+    }
+
+    public List<DirFileModel> getChildFile() {
+        return childFile;
+    }
+
+    public void setChildFile(List<DirFileModel> childFile) {
+        this.childFile = childFile;
+    }
+
+    public String getPath() {
+        return path;
+    }
+
+    public void setPath(String path) {
+        this.path = path;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    @Override
+    public String toString() {
+        return name;
+    }
+
+    public Node getIconIsNotSelected() {
+        return iconIsNotSelected;
+    }
+
+    public void setIconIsNotSelected(Node iconIsNotSelected) {
+        this.iconIsNotSelected = iconIsNotSelected;
+    }
+
+    public Node getIconIsSelected() {
+        return iconIsSelected;
+    }
+
+    public void setIconIsSelected(Node iconIsSelected) {
+        this.iconIsSelected = iconIsSelected;
+    }
+
+    public void setOpen(boolean open) {
+        isOpen = open;
+    }
+
+}

src/main/java/org/jcnc/jnotepad/model/entity/PluginDescriptor.java

@@ -0,0 +1,279 @@
+package org.jcnc.jnotepad.model.entity;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import org.jcnc.jnotepad.controller.plugin.interfaces.Plugin;
+
+import java.util.Objects;
+
+/**
+ * 插件信息
+ *
+ * @author gewuyou
+ */
+public class PluginDescriptor {
+    /**
+     * 插件id
+     */
+    private String id;
+    /**
+     * 插件名称
+     */
+    private String name;
+    /**
+     * 插件版本
+     */
+    private String version;
+    /**
+     * 启用状态
+     */
+    private boolean enabled;
+    /**
+     * 作者名称
+     */
+    private String author;
+    /**
+     * 类别
+     */
+    private String category;
+    /**
+     * 图标
+     */
+    private String icon;
+
+    /**
+     * 插件大小
+     */
+    private Integer size;
+    /**
+     * 描述
+     */
+    private String description;
+    /**
+     * 详细介绍
+     */
+    private String detailedIntroduction;
+    /**
+     * 插件日志
+     */
+    private String log;
+    /**
+     * 插件网址
+     */
+    private String pluginUrl;
+    /**
+     * 主类名称
+     */
+    private String mainClass;
+    /**
+     * 资源文件夹
+     */
+    private String assetFolder;
+    /**
+     * ReadMe
+     */
+    private String readMe;
+
+    /**
+     * 插件评分
+     */
+    @JsonIgnore
+    private Float score;
+
+    /**
+     * 插件类
+     */
+    @JsonIgnore
+    private Plugin plugin;
+
+    public PluginDescriptor() {
+    }
+
+    public PluginDescriptor(PluginDescriptor pluginDescriptor) {
+        this.id = pluginDescriptor.getId();
+        this.name = pluginDescriptor.getName();
+        this.version = pluginDescriptor.getVersion();
+        this.enabled = pluginDescriptor.isEnabled();
+        this.author = pluginDescriptor.getAuthor();
+        this.category = pluginDescriptor.getCategory();
+        this.icon = pluginDescriptor.getIcon();
+        this.size = pluginDescriptor.getSize();
+        this.description = pluginDescriptor.getDescription();
+        this.detailedIntroduction = pluginDescriptor.getDetailedIntroduction();
+        this.log = pluginDescriptor.getLog();
+        this.pluginUrl = pluginDescriptor.getPluginUrl();
+        this.mainClass = pluginDescriptor.getMainClass();
+        this.assetFolder = pluginDescriptor.getAssetFolder();
+        this.readMe = pluginDescriptor.getReadMe();
+        this.score = pluginDescriptor.getScore();
+        this.plugin = pluginDescriptor.getPlugin();
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getVersion() {
+        return version;
+    }
+
+    public void setVersion(String version) {
+        this.version = version;
+    }
+
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    public void setEnabled(boolean enabled) {
+        this.enabled = enabled;
+    }
+
+    public String getMainClass() {
+        return mainClass;
+    }
+
+    public void setMainClass(String mainClass) {
+        this.mainClass = mainClass;
+    }
+
+    public String getAuthor() {
+        return author;
+    }
+
+    public void setAuthor(String author) {
+        this.author = author;
+    }
+
+    public String getCategory() {
+        return category;
+    }
+
+    public void setCategory(String category) {
+        this.category = category;
+    }
+
+    public Plugin getPlugin() {
+        return plugin;
+    }
+
+    public void setPlugin(Plugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public String getIcon() {
+        return icon;
+    }
+
+    public void setIcon(String icon) {
+        this.icon = icon;
+    }
+
+    public Integer getSize() {
+        return size;
+    }
+
+    public void setSize(Integer size) {
+        this.size = size;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public String getDetailedIntroduction() {
+        return detailedIntroduction;
+    }
+
+    public void setDetailedIntroduction(String detailedIntroduction) {
+        this.detailedIntroduction = detailedIntroduction;
+    }
+
+    public String getLog() {
+        return log;
+    }
+
+    public void setLog(String log) {
+        this.log = log;
+    }
+
+    public String getPluginUrl() {
+        return pluginUrl;
+    }
+
+    public void setPluginUrl(String pluginUrl) {
+        this.pluginUrl = pluginUrl;
+    }
+
+    public String getAssetFolder() {
+        return assetFolder;
+    }
+
+    public void setAssetFolder(String assetFolder) {
+        this.assetFolder = assetFolder;
+    }
+
+    public String getReadMe() {
+        return readMe;
+    }
+
+    public void setReadMe(String readMe) {
+        this.readMe = readMe;
+    }
+
+    public Float getScore() {
+        return score;
+    }
+
+    public void setScore(Float score) {
+        this.score = score;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, name, version, enabled, author, category, icon, size, description, detailedIntroduction, log, pluginUrl, mainClass, assetFolder, readMe, score, plugin);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || getClass() != obj.getClass()) {
+            return false;
+        }
+        PluginDescriptor other = (PluginDescriptor) obj;
+        return Objects.equals(id, other.id) &&
+                Objects.equals(name, other.name) &&
+                Objects.equals(version, other.version) &&
+                enabled == other.enabled &&
+                Objects.equals(author, other.author) &&
+                Objects.equals(category, other.category) &&
+                Objects.equals(icon, other.icon) &&
+                Objects.equals(size, other.size) &&
+                Objects.equals(description, other.description) &&
+                Objects.equals(detailedIntroduction, other.detailedIntroduction) &&
+                Objects.equals(log, other.log) &&
+                Objects.equals(pluginUrl, other.pluginUrl) &&
+                Objects.equals(mainClass, other.mainClass) &&
+                Objects.equals(assetFolder, other.assetFolder) &&
+                Objects.equals(readMe, other.readMe) &&
+                Objects.equals(score, other.score) &&
+                Objects.equals(plugin, other.plugin);
+    }
+}

src/main/java/org/jcnc/jnotepad/model/entity/ShortcutKey.java

@@ -0,0 +1,34 @@
+package org.jcnc.jnotepad.model.entity;
+
+
+/**
+ * 快捷键信息类
+ *
+ * @author gewuyou
+ */
+public class ShortcutKey {
+    /**
+     * 按钮名称
+     */
+    private String buttonName;
+    /**
+     * 快捷键值
+     */
+    private String shortcutKeyValue;
+
+    public String getButtonName() {
+        return buttonName;
+    }
+
+    public void setButtonName(String buttonName) {
+        this.buttonName = buttonName;
+    }
+
+    public String getShortcutKeyValue() {
+        return shortcutKeyValue;
+    }
+
+    public void setShortcutKeyValue(String shortcutKeyValue) {
+        this.shortcutKeyValue = shortcutKeyValue;
+    }
+}

src/main/java/org/jcnc/jnotepad/model/entity/VisibleParagraphStyler.java

@@ -0,0 +1,47 @@
+package org.jcnc.jnotepad.model.entity;
+
+import javafx.application.Platform;
+import org.fxmisc.richtext.GenericStyledArea;
+import org.fxmisc.richtext.model.Paragraph;
+import org.fxmisc.richtext.model.StyleSpans;
+import org.reactfx.collection.ListModification;
+
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+/**
+ * 可见段落样式器
+ *
+ * @author gewuyou
+ */
+public class VisibleParagraphStyler<PS, SEG, S> implements Consumer<ListModification<? extends Paragraph<PS, SEG, S>>> {
+    private final GenericStyledArea<PS, SEG, S> area;
+    private final Function<String, StyleSpans<S>> computeStyles;
+    private int prevParagraph;
+    private int prevTextLength;
+
+    public VisibleParagraphStyler(GenericStyledArea<PS, SEG, S> area, Function<String, StyleSpans<S>> computeStyles) {
+        this.computeStyles = computeStyles;
+        this.area = area;
+    }
+
+    @Override
+    public void accept(ListModification<? extends Paragraph<PS, SEG, S>> lm) {
+        if (lm.getAddedSize() > 0) {
+            Platform.runLater(() -> {
+                int paragraph = Math.min(area.firstVisibleParToAllParIndex() + lm.getFrom(), area.getParagraphs().size() - 1);
+                String text = area.getText(paragraph, 0, paragraph, area.getParagraphLength(paragraph));
+
+                if (paragraph != prevParagraph || text.length() != prevTextLength) {
+                    if (paragraph < area.getParagraphs().size() - 1) {
+                        int startPos = area.getAbsolutePosition(paragraph, 0);
+                        area.setStyleSpans(startPos, computeStyles.apply(text));
+                    }
+                    prevTextLength = text.length();
+                    prevParagraph = paragraph;
+                }
+            });
+        }
+
+    }
+}

src/main/java/org/jcnc/jnotepad/model/enums/CacheExpirationTime.java

@@ -0,0 +1,44 @@
+package org.jcnc.jnotepad.model.enums;
+
+/**
+ * 缓存过期时间枚举
+ *
+ * @author gewuyou
+ */
+public enum CacheExpirationTime {
+    /**
+     * 一小时
+     */
+    ONE_HOUR(60 * 60 * 1000L),
+    /**
+     * 一天
+     */
+    ONE_DAY(24 * ONE_HOUR.value),
+    /**
+     * 一周
+     */
+    ONE_WEEK(7 * ONE_DAY.value),
+    /**
+     * 一月
+     */
+    ONE_MONTH(30 * ONE_DAY.value),
+    /**
+     * 一年
+     */
+    ONE_YEAR(365 * ONE_DAY.value),
+
+    /**
+     * 永不过期
+     */
+    NEVER_EXPIRES(-1L);
+    private final Long value;
+
+    CacheExpirationTime(Long value) {
+        this.value = value;
+    }
+
+    public Long getValue() {
+        return value;
+    }
+
+}

src/main/java/org/jcnc/jnotepad/model/enums/DialogType.java

@@ -0,0 +1,29 @@
+package org.jcnc.jnotepad.model.enums;
+
+/**
+ * 对话框类型
+ *
+ * @author gewuyou
+ */
+public enum DialogType {
+    /**
+     * 信息
+     */
+    INFO,
+    /**
+     * 警告
+     */
+    WARNING,
+    /**
+     * 错误
+     */
+    ERROR,
+    /**
+     * 成功
+     */
+    SUCCESS,
+    /**
+     * 疑问
+     */
+    QUESTION
+}

src/main/java/org/jcnc/jnotepad/tool/JsonUtil.java

@@ -1,40 +0,0 @@
-package org.jcnc.jnotepad.tool;
-
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.core.PrettyPrinter;
-import com.fasterxml.jackson.core.util.DefaultIndenter;
-import com.fasterxml.jackson.core.util.DefaultPrettyPrinter;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.SerializationFeature;
-import org.jcnc.jnotepad.exception.AppException;
-
-import static com.fasterxml.jackson.core.util.DefaultIndenter.SYS_LF;
-
-/**
- * jackson解析器的facade类，主要提供objectMapper对象
- *
- * @author songdragon
- */
-public class JsonUtil {
-    private JsonUtil() {
-    }
-
-    public static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
-
-    static {
-        OBJECT_MAPPER.enable(SerializationFeature.INDENT_OUTPUT);
-        DefaultPrettyPrinter prettyPrinter = new DefaultPrettyPrinter();
-        DefaultIndenter di = new DefaultIndenter("    ", SYS_LF);
-        prettyPrinter.indentArraysWith(di);
-        prettyPrinter.indentObjectsWith(di);
-        OBJECT_MAPPER.setDefaultPrettyPrinter(prettyPrinter);
-    }
-
-    public static String toJsonString(Object o) {
-        try {
-            return OBJECT_MAPPER.writeValueAsString(o);
-        } catch (JsonProcessingException e) {
-            throw new AppException(e);
-        }
-    }
-}

src/main/java/org/jcnc/jnotepad/tool/LogUtil.java

@@ -1,26 +0,0 @@
-package org.jcnc.jnotepad.tool;
-
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * 日志工具<br>注意，使用该工具的方法时，如果需要在JavaFx项目中调用日志请使用Platform.runLater()调用
- *
- * @author gewuyou
- */
-public class LogUtil {
-    private LogUtil() {
-    }
-
-    /**
-     * 获取日志类
-     *
-     * @param currentClass 所要记录的类
-     * @return org.apache.logging.log4j.Logger 日志对象
-     * @apiNote 传入当前需要记录的类，返回记录该类的日志类 <br>建议一个类调用超过两次这个方法时，应当将该日志类变成成员对象，而不是多次调用
-     */
-    public static Logger getLogger(Class<?> currentClass) {
-        return LoggerFactory.getLogger(currentClass);
-    }
-}

src/main/java/org/jcnc/jnotepad/tool/PopUpUtil.java

@@ -1,32 +0,0 @@
-package org.jcnc.jnotepad.tool;
-
-import javafx.scene.control.Alert;
-
-/**
- * 弹窗工具类
- *
- * @author gewuyou
- */
-public class PopUpUtil {
-
-    private static final ThreadLocal<Alert> ERROR_ALERTS = ThreadLocal.withInitial(() -> new Alert(Alert.AlertType.ERROR));
-
-    private PopUpUtil() {
-    }
-
-    /**
-     * 获取错误弹窗
-     *
-     * @param title      弹窗标题
-     * @param headerText 头文本
-     * @param message    信息
-     */
-    public static void errorAlert(String title, String headerText, String message) {
-        Alert alert = ERROR_ALERTS.get();
-        alert.setTitle(title);
-        alert.setHeaderText(headerText);
-        alert.setContentText(message);
-        alert.showAndWait();
-        ERROR_ALERTS.remove();
-    }
-}

src/main/java/org/jcnc/jnotepad/ui/LineNumberTextArea.java

@@ -1,151 +0,0 @@
-package org.jcnc.jnotepad.ui;
-
-import javafx.beans.property.StringProperty;
-import javafx.scene.control.TextArea;
-import javafx.scene.layout.BorderPane;
-import org.jcnc.jnotepad.app.config.AppConfig;
-import org.jcnc.jnotepad.controller.config.AppConfigController;
-import org.jcnc.jnotepad.tool.LogUtil;
-import org.jcnc.jnotepad.ui.menu.JNotepadMenuBar;
-import org.jcnc.jnotepad.ui.status.JNotepadStatusBox;
-import org.jcnc.jnotepad.ui.tab.JNotepadTab;
-import org.jcnc.jnotepad.ui.tab.JNotepadTabPane;
-
-import java.io.BufferedWriter;
-import java.io.File;
-import java.io.FileWriter;
-import java.io.IOException;
-
-/**
- * @author 许轲
- */
-public class LineNumberTextArea extends BorderPane {
-    /**
-     * 是否与本地文件关联
-     */
-    private boolean isRelevance = false;
-    private final TextArea mainTextArea;
-    private final TextArea lineNumberArea;
-
-    static final int[] SIZE_TABLE = {9, 99, 999, 9999, 99999, 999999, 9999999,
-            99999999, 999999999, Integer.MAX_VALUE};
-    private static final int MIN_LINE_NUMBER_WIDTH = 30;
-
-    public LineNumberTextArea() {
-        mainTextArea = new TextArea();
-        mainTextArea.setWrapText(AppConfigController.getInstance().getAutoLineConfig());
-
-        lineNumberArea = new TextArea();
-        lineNumberArea.setEditable(false);
-        lineNumberArea.setPrefWidth(MIN_LINE_NUMBER_WIDTH);
-        lineNumberArea.setMinWidth(MIN_LINE_NUMBER_WIDTH);
-        // 设定自定义样式
-        lineNumberArea.getStyleClass().add("text-line-number");
-        mainTextArea.getStyleClass().add("main-text-area");
-        this.setStyle(
-                "-fx-border-color:white;" +
-                        "-fx-background-color:white"
-        );
-
-        initListeners();
-
-        setCenter(mainTextArea);
-        setLeft(lineNumberArea);
-
-
-    }
-
-    private void initListeners() {
-        // 当主要文本区域的垂直滚动位置发生变化时，使行号文本区域的滚动位置保持一致
-        mainTextArea.scrollTopProperty().addListener((observable, oldValue, newValue) -> lineNumberArea.setScrollTop(mainTextArea.getScrollTop()));
-
-        // 当行号文本区域的垂直滚动位置发生变化时，使主要文本区域的滚动位置保持一致
-        lineNumberArea.scrollTopProperty().addListener((observable, oldValue, newValue) -> mainTextArea.setScrollTop(lineNumberArea.getScrollTop()));
-
-        lineNumberArea.textProperty().addListener((observable, oldValue, newValue) -> updateLineNumberWidth());
-
-        this.mainTextArea.caretPositionProperty().addListener((caretObservable, oldPosition, newPosition) -> JNotepadStatusBox.getInstance().updateWordCountStatusLabel());
-        this.textProperty().addListener((observable, oldValue, newValue) -> {
-            // 更新行号
-            updateLineNumberArea();
-            // 更新状态栏
-            JNotepadStatusBox.getInstance().updateWordCountStatusLabel();
-            // 自动保存
-            save();
-        });
-    }
-
-    /**
-     * 以原文件编码格式写回文件
-     */
-    public void save() {
-        JNotepadTab tab = JNotepadTabPane.getInstance().getSelected();
-        if (tab != null) {
-            File file = (File) tab.getUserData();
-            String newValue = this.mainTextArea.getText();
-            if (file != null) {
-                try (BufferedWriter writer = new BufferedWriter(new FileWriter(file, tab.getCharset()))) {
-                    writer.write(newValue);
-                    LogUtil.getLogger(this.getClass()).info("正在自动保存---");
-                } catch (IOException ignored) {
-                    LogUtil.getLogger(this.getClass()).info("已忽视IO异常!");
-                }
-            }
-        }
-    }
-
-    public boolean isRelevance() {
-        return isRelevance;
-    }
-
-    public void setRelevance(boolean relevance) {
-        isRelevance = relevance;
-    }
-
-    private void updateLineNumberWidth() {
-        int numOfLines = mainTextArea.getParagraphs().size();
-        int count = 1;
-        for (int i = 0; i < SIZE_TABLE.length; i++) {
-            if (numOfLines <= SIZE_TABLE[i]) {
-                count = i + 1;
-                break;
-            }
-        }
-        // 单数字宽度10像素，4为padding=左3+右1
-        int actualWidth = Math.max(count * 10 + 11, MIN_LINE_NUMBER_WIDTH);
-        if (actualWidth != lineNumberArea.getWidth()) {
-            lineNumberArea.setPrefWidth(actualWidth);
-        }
-    }
-
-    public StringProperty textProperty() {
-        return mainTextArea.textProperty();
-    }
-
-
-    private void updateLineNumberArea() {
-        // 保存当前的滚动位置
-        /*
-          更新行号文本区域的内容，根据主要文本区域的段落数生成行号。
-         */
-        double mainTextAreaScrollTop = mainTextArea.getScrollTop();
-        double lineNumberAreaScrollTop = lineNumberArea.getScrollTop();
-
-        int numOfLines = mainTextArea.getParagraphs().size();
-        StringBuilder lineNumberText = new StringBuilder();
-        for (int i = 1; i <= numOfLines; i++) {
-            lineNumberText.append(i).append("\n");
-        }
-        lineNumberArea.setText(lineNumberText.toString());
-
-        // 恢复之前的滚动位置
-        mainTextArea.setScrollTop(mainTextAreaScrollTop);
-        lineNumberArea.setScrollTop(lineNumberAreaScrollTop);
-    }
-
-    public TextArea getMainTextArea() {
-        return mainTextArea;
-    }
-
-}
-

src/main/java/org/jcnc/jnotepad/ui/component/aReadme.md

@@ -0,0 +1 @@
+component 目录包含可复用的UI组件，如自定义模块。

src/main/java/org/jcnc/jnotepad/ui/component/module/TextCodeArea.java

@@ -0,0 +1,143 @@
+package org.jcnc.jnotepad.ui.component.module;
+
+import javafx.application.Platform;
+import javafx.geometry.Insets;
+import javafx.scene.input.KeyCode;
+import javafx.scene.input.KeyEvent;
+import org.fxmisc.richtext.CodeArea;
+import org.fxmisc.richtext.LineNumberFactory;
+import org.fxmisc.richtext.model.StyleSpans;
+import org.fxmisc.richtext.model.StyleSpansBuilder;
+import org.jcnc.jnotepad.model.entity.DefaultContextMenu;
+import org.jcnc.jnotepad.model.entity.VisibleParagraphStyler;
+import org.reactfx.Subscription;
+
+import java.time.Duration;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * 文本代码域
+ * </p>
+ *
+ * @author luke
+ */
+public class TextCodeArea extends CodeArea {
+
+    private static final String[] KEYWORDS = new String[]{
+            "abstract", "assert", "boolean", "break", "byte",
+            "case", "catch", "char", "class", "const",
+            "continue", "default", "do", "double", "else",
+            "enum", "extends", "final", "finally", "float",
+            "for", "goto", "if", "implements", "import",
+            "instanceof", "int", "interface", "long", "native",
+            "new", "package", "private", "protected", "public",
+            "return", "short", "static", "strictfp", "super",
+            "switch", "synchronized", "this", "throw", "throws",
+            "transient", "try", "void", "volatile", "while"
+    };
+
+    /**
+     * 定义用于匹配关键字、括号、分号、字符串和注释的正则表达式模式
+     */
+    private static final String KEYWORD_PATTERN = "\\b(" + String.join("|", KEYWORDS) + ")\\b";
+    private static final String PAREN_PATTERN = "[()]";
+    private static final String BRACE_PATTERN = "[{}]";
+    private static final String BRACKET_PATTERN = "[\\[\\]]";
+    private static final String SEMICOLON_PATTERN = ";";
+    private static final String STRING_PATTERN = "\"([^\"\\\\]|\\\\.)*\"";
+    private static final String COMMENT_PATTERN =
+            // 用于整体文本处理（文本块）
+            "//[^\n]*" + "|" + "/\\*(.|\\R)*?\\*/"
+                    // 用于可见段落处理（逐行）
+                    + "|" + "/\\*\\V*" + "|" + "^\\h*\\*(\\V*|/)";
+    /**
+     * 使用正则表达式将关键字、括号、分号、字符串和注释的模式组合成一个复合模式
+     */
+    private static final Pattern PATTERN = Pattern.compile(
+            "(?<KEYWORD>" + KEYWORD_PATTERN + ")"
+                    + "|(?<PAREN>" + PAREN_PATTERN + ")"
+                    + "|(?<BRACE>" + BRACE_PATTERN + ")"
+                    + "|(?<BRACKET>" + BRACKET_PATTERN + ")"
+                    + "|(?<SEMICOLON>" + SEMICOLON_PATTERN + ")"
+                    + "|(?<STRING>" + STRING_PATTERN + ")"
+                    + "|(?<COMMENT>" + COMMENT_PATTERN + ")"
+    );
+
+    /**
+     * 构造函数
+     * <p>
+     * 用于创建 TextCodeArea 对象
+     */
+    public TextCodeArea() {
+        // 上、右、下、左
+        this.setPadding(new Insets(8, 0, 0, 0));
+
+        // 在区域左侧添加行号
+        this.setParagraphGraphicFactory(LineNumberFactory.get(this));
+        this.setContextMenu(new DefaultContextMenu());
+
+        /*
+          重新计算所有文本的语法高亮，用户停止编辑区域后的500毫秒内
+          fixme 这个代码没有作用
+         */
+        Subscription cleanupWhenNoLongerNeedIt = this
+                .multiPlainChanges()
+                .successionEnds(Duration.ofMillis(500))
+                .subscribe(ignore -> this.setStyleSpans(0, computeHighlighting(this.getText())));
+
+        this.getVisibleParagraphs().addModificationObserver
+                (
+                        new VisibleParagraphStyler<>(this, this::computeHighlighting)
+                );
+
+        // 自动缩进：在按下回车键时插入上一行的缩进
+        final Pattern whiteSpace = Pattern.compile("^\\s+");
+        this.addEventHandler(KeyEvent.KEY_PRESSED, kE ->
+        {
+            if (kE.getCode() == KeyCode.ENTER) {
+                int caretPosition = this.getCaretPosition();
+                int currentParagraph = this.getCurrentParagraph();
+                Matcher m0 = whiteSpace.matcher(this.getParagraph(currentParagraph - 1).getSegments().get(0));
+                if (m0.find()) {
+                    Platform.runLater(() -> this.insertText(caretPosition, m0.group()));
+                }
+            }
+        });
+        this.getStylesheets().add(Objects.requireNonNull(getClass().getResource("/jcnc/app/css/java_code_styles.css")).toString());
+    }
+
+    private static String getStyleClass(Matcher matcher) {
+        Map<String, String> patternToStyleClass = new HashMap<>(16);
+        patternToStyleClass.put("keyword", matcher.group("KEYWORD"));
+        patternToStyleClass.put("paren", matcher.group("PAREN"));
+        patternToStyleClass.put("brace", matcher.group("BRACE"));
+        patternToStyleClass.put("bracket", matcher.group("BRACKET"));
+        patternToStyleClass.put("semicolon", matcher.group("SEMICOLON"));
+        patternToStyleClass.put("string", matcher.group("STRING"));
+        patternToStyleClass.put("comment", matcher.group("COMMENT"));
+        for (Map.Entry<String, String> entry : patternToStyleClass.entrySet()) {
+            if (entry.getValue() != null) {
+                return entry.getKey();
+            }
+        }
+        // 永不发生
+        return null;
+    }
+
+    private StyleSpans<Collection<String>> computeHighlighting(String text) {
+        Matcher matcher = PATTERN.matcher(text);
+        int lastKwEnd = 0;
+        StyleSpansBuilder<Collection<String>> spansBuilder
+                = new StyleSpansBuilder<>();
+        while (matcher.find()) {
+            String styleClass = getStyleClass(matcher);
+            spansBuilder.add(Collections.emptyList(), matcher.start() - lastKwEnd);
+            spansBuilder.add(Collections.singleton(styleClass), matcher.end() - matcher.start());
+            lastKwEnd = matcher.end();
+        }
+        spansBuilder.add(Collections.emptyList(), text.length() - lastKwEnd);
+        return spansBuilder.create();
+    }
+}