.idea/gradle.xml

@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="GradleMigrationSettings" migrationVersion="1" />
   <component name="GradleSettings">
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

app/src/main/java/com/monke/monkeybook/model/IEasouBookModel.java

@@ -8,24 +8,47 @@ import com.monke.monkeybook.listener.OnGetChapterListListener;
 import java.util.List;
 import io.reactivex.Observable;
 
+// 定义了一个名为IEasouBookModel的接口，用于规范与书籍相关的各种数据获取操作的方法签名
+// 该接口可能会有不同的实现类来具体处理对应的业务逻辑，例如与不同数据源交互获取书籍信息等
 public interface IEasouBookModel {
+
     /**
-     * 搜索书籍
+     * 搜索书籍的方法
+     *
+     * @param content 搜索的内容，通常是书籍的名称、作者等相关关键字，用于筛选符合条件的书籍
+     * @param page 页码，用于分页获取搜索结果，指定要获取第几页的搜索数据
+     * @param rankKind 排序类型相关的参数，可能用于指定按照何种规则对搜索结果进行排序，例如按照热度、发布时间等
+     * @return 返回一个Observable对象，其泛型类型为List<SearchBookBean>，用于异步地获取搜索到的书籍信息列表，
+     *         外部可以通过订阅这个Observable来处理返回的搜索结果数据
      */
     Observable<List<SearchBookBean>> searchBook(String content, int page, int rankKind);
 
     /**
-     * 网络请求并解析书籍信息
+     * 网络请求并解析书籍信息的方法
+     *
+     * @param bookShelfBean 传入的BookShelfBean对象，可能包含了书籍的部分初始信息（比如书籍的唯一标识等），
+     *                      基于这些信息去网络请求获取更详细完整的书籍信息，并进行解析
+     * @return 返回一个Observable对象，其泛型类型为BookShelfBean，用于异步地获取经过网络请求和解析后的完整书籍信息，
+     *         外部通过订阅这个Observable来获取最终的书籍详情数据
      */
     Observable<BookShelfBean> getBookInfo(final BookShelfBean bookShelfBean);
 
     /**
-     * 网络解析图书目录
+     * 网络解析图书目录的方法
+     *
+     * @param bookShelfBean 传入的BookShelfBean对象，同样可能包含了书籍的相关标识等必要信息，基于这些信息去网络获取对应的图书目录数据
+     * @param getChapterListListener 一个监听器对象，用于在获取图书目录的过程中或者获取完成后进行回调通知，
+     *                                外部可以通过实现这个监听器的相关方法来处理获取目录过程中的进度、成功或失败等情况
      */
     void getChapterList(final BookShelfBean bookShelfBean, OnGetChapterListListener getChapterListListener);
 
     /**
-     * 章节缓存
+     * 章节缓存相关的方法
+     *
+     * @param durChapterUrl 章节对应的URL地址，通过这个URL可以定位到具体要获取缓存内容的章节资源
+     * @param durChapterIndex 章节的索引值，用于更准确地标识章节顺序等信息，方便在缓存操作中定位具体章节
+     * @return 返回一个Observable对象，其泛型类型为BookContentBean，用于异步地获取章节缓存内容对应的Bean对象，
+     *         外部通过订阅这个Observable来获取章节的缓存数据（比如章节的文本内容等）
      */
     Observable<BookContentBean> getBookContent(final String durChapterUrl, final int durChapterIndex);
-}
+}

app/src/main/java/com/monke/monkeybook/model/IGxwztvBookModel.java

@@ -3,21 +3,42 @@ package com.monke.monkeybook.model;
 
 import com.monke.monkeybook.bean.LibraryBean;
 import com.monke.monkeybook.bean.SearchBookBean;
-import com.monke.monkeybook.cache.ACache;
+import // 导入缓存相关的类，可能用于缓存一些数据，提高数据获取效率等操作
+        com.monke.monkeybook.cache.ACache;
 import java.util.List;
 import io.reactivex.Observable;
 
+// IGxwztvBookModel接口继承自IStationBookModel接口，意味着它会继承IStationBookModel中定义的方法，
+// 同时在此接口中又额外定义了一些与特定业务（可能和gxwztv相关）相关的书籍数据获取等操作的方法规范
 public interface IGxwztvBookModel extends IStationBookModel {
 
+    /**
+     * 获取分类书籍信息的方法
+     *
+     * @param url 对应获取分类书籍数据的请求地址，通过这个URL可以向相应的服务器端发起请求，获取指定分类下的书籍信息
+     * @param page 页码参数，用于指定要获取第几页的分类书籍数据，实现分页获取，方便展示大量数据时进行分批加载
+     * @return 返回一个Observable对象，其泛型类型为List<SearchBookBean>，用于异步地获取指定分类下对应页面的书籍信息列表，
+     *         外部可通过订阅该Observable来处理获取到的书籍数据，例如展示在界面上或者进行进一步的筛选、排序等操作
+     */
     Observable<List<SearchBookBean>> getKindBook(String url, int page);
 
     /**
-     * 获取主页信息
+     * 获取主页信息的方法
+     *
+     * @param aCache 传入的ACache对象，用于缓存相关操作，可能会先从缓存中尝试获取主页信息，若缓存不存在或已过期等情况，
+     *              再去进行网络请求等操作来获取最新的主页信息，并可以将新获取到的主页信息存入缓存，方便下次快速获取
+     * @return 返回一个Observable对象，其泛型类型为LibraryBean，用于异步地获取主页相关的数据，以LibraryBean对象的形式返回，
+     *         外部通过订阅这个Observable来获取主页信息并进行后续处理，比如将主页数据展示在对应的页面上
      */
     Observable<LibraryBean> getLibraryData(ACache aCache);
 
     /**
-     * 解析主页数据
+     * 解析主页数据的方法
+     *
+     * @param data 传入的需要解析的数据字符串，通常可能是从网络请求获取到的原始主页数据内容，该方法会按照一定的规则和逻辑，
+     *             对传入的字符串数据进行解析，提取出有用的信息，并封装成LibraryBean对象返回
+     * @return 返回一个Observable对象，其泛型类型为LibraryBean，用于异步地返回解析后得到的主页数据对应的LibraryBean对象，
+     *         外部订阅此Observable来获取解析好的主页数据，以便后续进行展示、处理等操作
      */
     Observable<LibraryBean> analyLibraryData(String data);
-}
+}

app/src/main/java/com/monke/monkeybook/model/IImportBookModel.java

@@ -2,10 +2,21 @@
 package com.monke.monkeybook.model;
 
 import com.monke.monkeybook.bean.LocBookShelfBean;
+// 导入Java中用于操作文件的类，意味着该接口相关操作可能涉及对本地文件的处理，比如导入本地书籍文件等
 import java.io.File;
 import io.reactivex.Observable;
 
+// 定义了IImportBookModel接口，该接口主要规范了导入书籍相关操作的方法签名，
+// 具体的导入书籍逻辑可由实现该接口的类来完成
 public interface IImportBookModel {
 
+    /**
+     * 导入书籍的方法
+     *
+     * @param book 传入的File对象，表示要导入的书籍文件，这个文件可以是本地存储的各种格式的书籍文件（例如txt、epub等），
+     *             通过该方法会对传入的书籍文件进行相应处理，比如解析文件内容、提取书籍相关信息等，最终生成对应的书籍信息对象
+     * @return 返回一个Observable对象，其泛型类型为LocBookShelfBean，用于异步地返回导入书籍操作后生成的书籍信息对象，
+     *         外部可以通过订阅这个Observable来获取导入书籍后的结果信息，比如将书籍信息添加到书架等后续操作
+     */
     Observable<LocBookShelfBean> importBook(File book);
-}
+}

app/src/main/java/com/monke/monkeybook/model/IStationBookModel.java

@@ -8,25 +8,53 @@ import com.monke.monkeybook.listener.OnGetChapterListListener;
 import java.util.List;
 import io.reactivex.Observable;
 
+// IStationBookModel接口定义了一系列与书籍相关操作的方法规范，这些操作可能是围绕某个站点（Station）展开的，
+// 比如从特定的网络站点获取书籍数据等，具体实现类会按照这些规范来实现对应的业务逻辑
 public interface IStationBookModel {
 
     /**
-     * 搜索书籍
+     * 搜索书籍的方法
+     *
+     * @param content 用于指定搜索的关键字内容，一般来说可以是书籍的名称、作者名或者相关的关键词等，
+     *                通过这些关键字去查找匹配的书籍信息
+     * @param page 表示页码，用于分页获取搜索结果。当搜索结果较多时，通过指定不同的页码可以获取到相应页面的书籍列表，
+     *             便于分批展示和处理搜索到的书籍数据
+     * @return 返回一个Observable对象，其泛型类型为List<SearchBookBean>，用于异步地返回根据关键字和页码搜索到的书籍信息列表，
+     *         外部可以通过订阅这个Observable来接收和处理搜索结果，例如在界面上展示搜索到的书籍列表等操作
      */
     Observable<List<SearchBookBean>> searchBook(String content, int page);
 
     /**
-     * 网络请求并解析书籍信息
+     * 网络请求并解析书籍信息的方法
+     *
+     * @param bookShelfBean 传入的BookShelfBean对象，它可能包含了部分初始的书籍相关信息，例如书籍的唯一标识符等，
+     *                      基于这些已有信息向相应的网络资源（可能是某个书籍站点）发起请求，获取更详细完整的书籍信息，
+     *                      并对获取到的数据进行解析，最终封装成完整的BookShelfBean对象返回
+     * @return 返回一个Observable对象，其泛型类型为BookShelfBean，用于异步地返回经过网络请求和解析后的完整书籍信息对象，
+     *         外部通过订阅这个Observable来获取最终的书籍详情数据，进而可以进行如更新书架等后续操作
      */
     Observable<BookShelfBean> getBookInfo(final BookShelfBean bookShelfBean);
 
     /**
-     * 网络解析图书目录
+     * 网络解析图书目录的方法
+     *
+     * @param bookShelfBean 同样，这里的BookShelfBean对象包含了用于定位特定书籍的相关信息，
+     *                      依据这些信息向网络资源请求该书籍对应的目录数据，
+     *                      然后在获取过程中或者获取完成后通过传入的OnGetChapterListListener监听器来通知外部相关情况
+     * @param getChapterListListener 一个监听器对象，用于监听获取图书目录的进度、成功获取或者获取失败等情况，
+     *                                外部可以通过实现该监听器的相应方法来处理这些不同的事件，例如更新界面展示目录进度等
      */
     void getChapterList(final BookShelfBean bookShelfBean, OnGetChapterListListener getChapterListListener);
 
     /**
-     * 章节缓存
+     * 章节缓存的方法
+     *
+     * @param durChapterUrl 表示具体章节对应的URL地址，通过这个URL可以准确地定位到需要获取缓存内容的章节资源所在位置，
+     *                     一般是从网络上获取该章节原始数据的链接地址
+     * @param durChapterIndex 章节的索引值，用于标识章节在整本书中的顺序位置等信息，方便在缓存操作以及后续使用中准确区分不同章节，
+     *                        比如按照章节顺序来展示章节内容等情况就会用到这个索引
+     * @return 返回一个Observable对象，其泛型类型为BookContentBean，用于异步地返回章节缓存内容对应的Bean对象，
+     *         外部通过订阅这个Observable来获取章节的缓存数据，例如章节的具体文本内容等，方便后续展示或处理章节内容的操作
      */
     Observable<BookContentBean> getBookContent(final String durChapterUrl, final int durChapterIndex);
-}
+}

app/src/main/java/com/monke/monkeybook/model/IWebBookModel.java

@@ -8,28 +8,70 @@ import com.monke.monkeybook.listener.OnGetChapterListListener;
 import java.util.List;
 import io.reactivex.Observable;
 
+// IWebBookModel接口定义了一系列与网络书籍相关操作的方法规范，
+// 主要涉及从网络获取书籍各种信息（如书籍详情、目录、章节内容等）以及搜索不同类型书籍的功能，
+// 具体的实现类会按照这些方法签名去实现对应的网络交互逻辑
 public interface IWebBookModel {
+
     /**
-     * 网络请求并解析书籍信息
+     * 网络请求并解析书籍信息的方法
+     *
+     * @param bookShelfBean 传入的BookShelfBean对象，它可能包含了部分初始的书籍相关标识信息等，
+     *                      基于这些已有信息向网络发起请求，比如向某个网络书籍平台请求对应书籍的详细信息，
+     *                      然后对获取到的数据进行解析处理，最终封装成完整的BookShelfBean对象返回
+     * @return 返回一个Observable对象，其泛型类型为BookShelfBean，用于异步地返回经过网络请求和解析后完整的书籍信息对象，
+     *         外部通过订阅这个Observable来获取书籍的详细信息，进而可用于展示、更新书架等后续操作
      */
     Observable<BookShelfBean> getBookInfo(final BookShelfBean bookShelfBean);
 
     /**
-     * 网络解析图书目录
+     * 网络解析图书目录的方法
+     *
+     * @param bookShelfBean 传入的BookShelfBean对象包含了用于定位特定书籍的必要信息，
+     *                      依据这些信息向网络资源（比如对应的书籍网站服务器）请求该书籍的目录数据，
+     *                      在获取目录的过程中或者获取完成后，通过传入的OnGetChapterListListener监听器来通知外部相关情况，
+     *                      例如目录获取进度、成功获取目录或者获取失败等信息
+     * @param getChapterListListener 一个监听器对象，用于监听获取图书目录的各种情况，
+     *                                外部可以通过实现该监听器的相应方法来处理这些不同事件，
+     *                                比如在界面上展示目录获取进度条，或者将获取到的目录数据进行展示等操作
      */
     void getChapterList(final BookShelfBean bookShelfBean,OnGetChapterListListener getChapterListListener);
 
     /**
-     * 章节缓存
+     * 章节缓存的方法
+     *
+     * @param durChapterUrl 表示具体章节对应的URL地址，通过这个URL可以准确地定位到需要获取缓存内容的章节资源所在网络位置，
+     *                     它是从网络上获取该章节原始数据的链接地址，用于准确获取相应章节内容
+     * @param durChapterIndex 章节的索引值，用于标识章节在整本书中的顺序位置等信息，方便在缓存操作以及后续展示、使用章节内容时，
+     *                        准确区分不同章节，例如按照章节顺序展示阅读内容时就依赖这个索引值来确定先后顺序
+     * @param tag 额外的标识字符串，可能用于区分不同类型的缓存场景、不同来源的章节数据或者在缓存管理中起其他辅助标识作用等
+     * @return 返回一个Observable对象，其泛型类型为BookContentBean，用于异步地返回章节缓存内容对应的Bean对象，
+     *         外部通过订阅这个Observable来获取章节的缓存数据，比如章节的具体文本内容等，方便后续展示、阅读章节内容的操作
      */
     Observable<BookContentBean> getBookContent(final String durChapterUrl, final int durChapterIndex, String tag);
 
     /**
-     * 获取分类书籍
+     * 获取分类书籍的方法
+     *
+     * @param url 对应获取分类书籍数据的请求地址，通过这个URL向相应的网络资源（可能是某个书籍分类页面所在的网络地址）发起请求，
+     *            以获取指定分类下的书籍信息，比如向小说网站的玄幻分类页面地址发起请求获取玄幻类书籍列表
+     * @param page 页码参数，用于指定要获取第几页的分类书籍数据，实现分页获取，便于在书籍数量较多时进行分批展示和处理，
+     *             例如只获取分类书籍列表中的第2页数据等情况就通过这个参数指定
+     * @return 返回一个Observable对象，其泛型类型为List<SearchBookBean>，用于异步地返回获取到的指定分类下对应页面的书籍信息列表，
+     *         外部可通过订阅该Observable来处理获取到的书籍数据，例如在界面上展示分类书籍列表、进行筛选排序等操作
      */
     Observable<List<SearchBookBean>> getKindBook(String url,int page);
+
     /**
-     * 其他站点资源整合搜索
+     * 其他站点资源整合搜索的方法
+     *
+     * @param content 用于指定搜索的关键字内容，一般可以是书籍的名称、作者名或者相关的关键词等，
+     *                通过这些关键字去多个其他相关的网络书籍站点进行搜索，查找匹配的书籍信息
+     * @param page 页码参数，用于分页获取搜索结果，当搜索到的结果较多时，通过指定不同的页码可以获取到相应页面的书籍列表，
+     *             便于分批展示和处理搜索到的书籍数据，比如获取搜索结果的第3页数据等情况就通过该参数指定
+     * @param tag 额外的标识字符串，可能用于区分不同的搜索场景、不同的站点范围或者在搜索结果整合处理中起其他辅助标识作用等
+     * @return 返回一个Observable对象，其泛型类型为List<SearchBookBean>，用于异步地返回根据关键字和页码在其他站点搜索到的书籍信息列表，
+     *         外部可以通过订阅这个Observable来接收和处理搜索结果，例如在界面上展示整合后的搜索书籍列表等操作
      */
     Observable<List<SearchBookBean>> searchOtherBook(String content,int page,String tag);
-}
+}

app/src/main/java/com/monke/monkeybook/model/IWebContentModel.java

@@ -1,7 +1,22 @@
 //Copyright (c) 2017. 章钦豪. All rights reserved.
 package com.monke.monkeybook.model;
 
+// IWebContentModel接口定义了一个用于分析书籍内容的方法规范，
+// 具体的实现类需要按照此规范来实现对书籍内容相关的解析操作，
+// 可能是从网络获取到的书籍文本内容等进行特定的分析处理。
 public interface IWebContentModel {
 
+    /**
+     * 分析书籍内容的方法
+     *
+     * @param s 传入的字符串参数，通常代表需要分析处理的书籍内容相关的数据，
+     *          比如从网络上获取到的某个章节的原始文本内容，或者经过初步处理的包含书籍内容信息的字符串等
+     * @param realUrl 表示实际的URL地址，这个地址可能与获取书籍内容相关，比如是该书籍内容来源的网络链接地址，
+     *                可以用于验证内容来源、辅助解析内容（例如依据URL对应的网页格式特点来解析内容等情况）等操作
+     * @return 返回一个字符串，该字符串应该是经过分析处理后的结果，例如提取出了书籍内容中的关键信息、对内容进行了格式化后的文本等，
+     *         具体返回内容取决于具体的分析逻辑实现
+     * @throws Exception 此方法声明会抛出异常，意味着在分析书籍内容的过程中，如果出现了诸如网络连接问题（若涉及网络交互）、
+     *                   数据格式错误（不符合预期的书籍内容格式）等情况时，会抛出相应的异常，需要外部调用者进行适当处理
+     */
     String analyBookcontent(String s,String realUrl) throws Exception;
 }

app/src/main/java/com/monke/monkeybook/model/impl/Content17duxsModelImpl.java

@@ -7,31 +7,48 @@ import org.jsoup.nodes.Document;
 import org.jsoup.nodes.TextNode;
 import java.util.List;
 
-public class Content17duxsModelImpl implements IWebContentModel{
+// 实现IWebContentModel接口的类，用于处理特定网站的网页内容解析
+public class Content17duxsModelImpl implements IWebContentModel {
+    // 定义一个表示特定网站的标签这里的值是网站的网址
     public static final String TAG = "http://www.17duxs.com";
 
+    // 获取Content17duxsModelImpl类的单例实例
     public static Content17duxsModelImpl getInstance() {
         return new Content17duxsModelImpl();
     }
 
+    // 私有构造方法，按照单例模式的常见思路，防止外部直接实例化该类，不过此处并没有严格限制单例唯一性相关逻辑
     private Content17duxsModelImpl() {
 
     }
+
+    // 实现IWebContentModel接口中的方法，用于解析书籍内容
+    // 参数s是待解析的网页内容字符串（通常是通过网络请求获取到的网页源码等），realUrl参数可能是对应的真实网址（也许用于一些后续验证或者相关逻辑）
+    // 该方法可能会抛出异常，调用者需要处理相关异常情况
     @Override
     public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup解析传入的网页内容字符串，得到一个Document对象，方便后续对网页DOM结构进行操作
         Document doc = Jsoup.parse(s);
+        // 通过id为"content"获取对应的文本节点列表
         List<TextNode> contentEs = doc.getElementById("content").textNodes();
         StringBuilder content = new StringBuilder();
+        // 遍历获取到的文本节点列表
         for (int i = 0; i < contentEs.size(); i++) {
+            // 获取当前文本节点的文本内容，并去除前后空白字符（trim方法的作用）
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 将文本中的全角空格（&nbsp;对应的字符）和半角空格都替换为空字符串，进行文本内容的格式化清理
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 如果处理后的文本长度大于0，说明有有效内容
             if (temp.length() > 0) {
+                // 给有效内容添加两个全角空格（"\u3000\u3000" 表示两个全角空格）作为缩进格式
                 content.append("\u3000\u3000" + temp);
+                // 如果不是最后一个文本节点，添加换行符，用于区分不同的文本节点内容，使解析后的内容格式更合理
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+        // 将处理好的内容以字符串形式返回，最终返回的就是解析并格式化后的书籍内容字符串
         return content.toString();
     }
 }

app/src/main/java/com/monke/monkeybook/model/impl/Content17kModelImpl.java

@@ -1,4 +1,4 @@
-//Copyright (c) 2017. 章钦豪. All rights reserved.
+// Copyright (c) 2017. 章钦豪. All rights reserved.
 package com.monke.monkeybook.model.impl;
 
 import com.monke.monkeybook.model.IWebContentModel;
@@ -8,33 +8,48 @@ import org.jsoup.nodes.Element;
 import org.jsoup.nodes.TextNode;
 import java.util.List;
 
+// Content17kModelImpl类实现了IWebContentModel接口，用于处理来自17k网站相关内容的解析逻辑
 public class Content17kModelImpl implements IWebContentModel {
+    // 定义一个表示17k网站的标签字符串，可能用于标识来源等用途
     public static final String TAG = "http://www.17k.com";
 
+    // 采用单例模式，获取Content17kModelImpl类的唯一实例
     public static Content17kModelImpl getInstance() {
         return new Content17kModelImpl();
     }
 
+    // 将构造函数私有化，保证外部不能通过new关键字随意创建实例，符合单例模式的要求
     private Content17kModelImpl() {
 
     }
 
+    // 实现IWebContentModel接口中的analyBookcontent方法，用于解析书籍内容
     @Override
     public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup解析传入的字符串（通常是网页内容的HTML字符串），构建成Document对象，方便后续对HTML文档结构进行操作
         Document doc = Jsoup.parse(s);
+        // 通过id获取HTML文档中id为"chapterContentWapper"的元素，这个元素大概率包含了书籍章节的具体内容
         Element all = doc.getElementById("chapterContentWapper");
+        // 获取该元素下所有子元素中的第一个元素包含的文本节点列表，此处假设这个结构符合17k网站内容的布局特点
         List<TextNode> contentEs = all.getAllElements().get(0).textNodes();
         StringBuilder content = new StringBuilder();
+        // 遍历文本节点列表
         for (int i = 0; i < contentEs.size(); i++) {
+            // 获取当前文本节点的文本内容，并去除首尾空格
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 替换掉文本中的不间断空格（" "）以及普通空格，进一步清理文本内容
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 如果清理后的文本长度大于0，说明有实际内容
             if (temp.length() > 0) {
+                // 给文本添加两个全角空格作为缩进格式（"\u3000\u3000"），使其在展示时有一定的排版效果
                 content.append("\u3000\u3000" + temp);
+                // 如果不是最后一个文本节点，添加换行符，使不同部分的文本内容分行显示
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+        // 将处理好的文本内容以字符串形式返回
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/Content3dllcModelImpl.java

@@ -1,15 +1,21 @@
-//Copyright (c) 2017. 章钦豪. All rights reserved.
+// Copyright (c) 2017. 章钦豪. All rights reserved.
 package com.monke.monkeybook.model.impl;
 
 import com.monke.monkeybook.model.IWebContentModel;
 import org.jsoup.Jsoup;
+// 导入Jsoup库中的Document类，用于表示解析后的HTML文档结构
 import org.jsoup.nodes.Document;
+// 导入Jsoup库中的TextNode类，用于表示文本节点，方便对HTML中的文本内容进行操作
 import org.jsoup.nodes.TextNode;
 import java.util.List;
 
-public class Content3dllcModelImpl implements IWebContentModel{
+// Content3dllcModelImpl类实现了IWebContentModel接口，意味着它需要按照该接口定义的规范来实现相应的方法，
+public class Content3dllcModelImpl implements IWebContentModel {
+    // 定义一个静态的常量字符串TAG，用于标识相关的网址或者某种特定的标记
+    // 可能在后续的代码逻辑中用于判断来源或者做相关的分类等用途
     public static final String TAG = "http://www.3dllc.cc";
 
+    // 它用于获取Content3dllcModelImpl类的实例，方便外部代码调用获取该类对象进行相关操作
     public static Content3dllcModelImpl getInstance() {
         return new Content3dllcModelImpl();
     }
@@ -17,21 +23,41 @@ public class Content3dllcModelImpl implements IWebContentModel{
     private Content3dllcModelImpl() {
 
     }
+
+    // 实现IWebContentModel接口中定义的analyBookcontent方法，用于分析书籍内容。
+    // 参数s表示要解析的包含书籍内容的HTML字符串
+    // realUrl参数表示该内容对应的真实网址
+    // 该方法声明抛出Exception异常，意味着在解析过程中如果出现了比如HTML格式不正确、找不到指定元素等问题时，会将异常抛给调用者处理
     @Override
     public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup的parse方法将传入的HTML字符串解析成一个Document对象，
+        // 这样后续就可以方便地通过Document对象提供的方法来查找、操作HTML文档中的各种元素和内容
         Document doc = Jsoup.parse(s);
+        // 通过Document对象的.getElementById方法，根据元素的id属性值（这里是"content"）来获取对应的元素下的所有文本节点，
+        // 推测这里的"content"元素可能就是包含了书籍正文内容的HTML元素，获取到的是一个TextNode类型的列表，方便后续逐个处理这些文本节点内容
         List<TextNode> contentEs = doc.getElementById("content").textNodes();
+        // 创建一个可变的字符串构建器对象，用于逐步构建最终的书籍内容字符串，相比直接使用普通字符串拼接，这样效率更高，尤其在大量字符串拼接操作时
         StringBuilder content = new StringBuilder();
+        // 遍历获取到的文本节点列表
         for (int i = 0; i < contentEs.size(); i++) {
+            // 获取当前文本节点的文本内容，并去除两端的空白字符（空格、制表符等），得到一个相对比较“纯净”的文本内容字符串
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 将文本内容中的不间断空格（&nbsp;对应的字符）替换为空字符串，同时把普通空格也替换为空字符串，进一步清理文本内容，
+            // 可能是为了保证最终书籍内容格式的一致性或者符合特定的解析要求
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 如果清理后的文本内容长度大于0，说明该文本节点包含有效的文本信息，需要将其添加到最终的书籍内容字符串构建器中
             if (temp.length() > 0) {
+                // 在文本内容前添加两个全角空格（\u3000表示全角空格），可能是为了符合某种排版或者显示格式要求，比如缩进等，
+                // 然后添加到content字符串构建器中
                 content.append("\u3000\u3000" + temp);
+                // 如果当前不是最后一个文本节点，就在后面添加一个换行符（\r\n，在Windows系统下常见的换行表示方式），
+                // 使得最终的书籍内容文本在显示时不同文本节点的内容能分行显示，更符合阅读和排版习惯
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+        // 将构建好的包含书籍内容的字符串构建器对象转换为普通字符串并返回，这个字符串就是经过解析、清理和格式化后的书籍正文内容
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/Content44pqModelImpl.java

@@ -1,4 +1,4 @@
-//Copyright (c) 2017. 章钦豪. All rights reserved.
+// Copyright (c) 2017. 章钦豪. All rights reserved.
 package com.monke.monkeybook.model.impl;
 
 import com.monke.monkeybook.model.IWebContentModel;
@@ -7,31 +7,48 @@ import org.jsoup.nodes.Document;
 import org.jsoup.nodes.TextNode;
 import java.util.List;
 
-public class Content44pqModelImpl implements IWebContentModel{
+// Content44pqModelImpl类实现了IWebContentModel接口，主要用于处理来自http://www.44pq.net网站相关书籍内容的解析操作
+public class Content44pqModelImpl implements IWebContentModel {
+    // 定义一个表示网站来源的标签字符串，这里代表的是http://www.44pq.net，可能用于后续区分不同来源等情况
     public static final String TAG = "http://www.44pq.net";
 
+    // 使用单例模式，获取Content44pqModelImpl类的唯一实例，确保在程序中只有一个该类的实例存在
     public static Content44pqModelImpl getInstance() {
         return new Content44pqModelImpl();
     }
 
+    // 将构造函数私有化，防止外部代码通过new关键字随意创建该类的多个实例，符合单例模式的设计要求
     private Content44pqModelImpl() {
 
     }
+
+    // 重写IWebContentModel接口中的analyBookcontent方法，用于解析书籍内容
     @Override
     public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库的parse方法，将传入的字符串（通常是对应网页的HTML内容字符串）解析为Document对象，
+        // 这样就可以方便地按照HTML文档结构来操作和提取信息了
         Document doc = Jsoup.parse(s);
+        // 通过id获取Document对象中id为"content"的元素包含的所有文本节点，这里假设该"content"元素包含了书籍章节的实际文本内容，
+        // 具体依赖于http://www.44pq.net网站页面的HTML结构布局
         List<TextNode> contentEs = doc.getElementById("content").textNodes();
         StringBuilder content = new StringBuilder();
+        // 遍历获取到的文本节点列表
         for (int i = 0; i < contentEs.size(); i++) {
+            // 获取当前文本节点的文本内容，并去除其首尾的空白字符，使文本更加规整
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 替换掉文本中的不间断空格（" "）以及普通空格，进一步清理文本，去除不必要的空白格式
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 如果经过清理后文本的长度大于0，说明该文本节点包含有实际有效的内容
             if (temp.length() > 0) {
+                // 给有效的文本内容添加两个全角空格（"\u3000\u3000"）作为缩进，以便在最终展示文本时具有更好的排版效果
                 content.append("\u3000\u3000" + temp);
+                // 如果当前文本节点不是列表中的最后一个节点，就在后面添加换行符（"\r\n"），使不同部分的文本内容分行显示，增强可读性
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+        // 将处理好的包含书籍章节内容的文本以字符串形式返回，以便在其他地方使用该解析后的内容
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/Content630bookCCModelImpl.java

@@ -1,4 +1,4 @@
-//Copyright (c) 2017. 章钦豪. All rights reserved.
+// Copyright (c) 2017. 章钦豪. All rights reserved.
 package com.monke.monkeybook.model.impl;
 
 import com.monke.monkeybook.model.IWebContentModel;
@@ -7,31 +7,59 @@ import org.jsoup.nodes.Document;
 import org.jsoup.nodes.TextNode;
 import java.util.List;
 
-public class Content630bookCCModelImpl implements IWebContentModel{
+// Content630bookCCModelImpl类实现了IWebContentModel接口，主要负责对来自网址为http://www.630book.cc的书籍内容进行解析处理
+public class Content630bookCCModelImpl implements IWebContentModel {
+    // 定义一个公共静态的常量字符串TAG，其值为"http://www.630book.cc"，用于标识该类所针对处理内容的来源网站。
+    // 在整个程序架构中，这个标识可能会用于区分不同来源网站的相关逻辑，例如根据不同来源做特定的格式调整或者数据存储等操作
     public static final String TAG = "http://www.630book.cc";
 
+    // 这是一个静态方法，用于获取Content630bookCCModelImpl类的实例，采用的是单例模式。
+    // 通过这种方式确保在整个程序运行过程中，该类只有一个实例存在，有助于节省内存资源，避免因多次创建实例可能导致的资源浪费和数据不一致等问题
     public static Content630bookCCModelImpl getInstance() {
         return new Content630bookCCModelImpl();
     }
 
+    // 将构造函数私有化，这是实现单例模式的关键步骤之一。私有化构造函数后，外部类无法直接通过new关键字来创建该类的实例，
+    // 只能通过上面定义的getInstance方法来获取唯一的实例，以此保证单例模式的正确实现
     private Content630bookCCModelImpl() {
 
     }
+
+    // 重写了IWebContentModel接口中定义的analyBookcontent方法，此方法是整个类的核心功能所在，用于解析书籍内容。
+    // 它接收两个参数，一个是字符串s，通常代表从网页获取到的包含书籍章节内容的HTML格式的字符串；另一个是realUrl，可能表示该内容对应的真实网址，
+    // 虽然在当前代码中暂时未看到对realUrl参数的进一步使用，但在更复杂的场景下可以基于此参数做更多与网址相关的逻辑处理
     @Override
     public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库提供的parse方法，将传入的参数s（即包含书籍内容的HTML字符串）解析为Document对象。
+        // Document对象是Jsoup对HTML文档结构的一种表示形式，通过它可以方便地按照HTML的文档结构（如标签、元素、属性等）来查找、提取和操作相应的内容
         Document doc = Jsoup.parse(s);
+        // 通过Document对象的getElementById方法，根据元素的id属性查找id为"content"的元素，并获取该元素所包含的所有文本节点。
+        // 这里假设在http://www.630book.cc网站的页面结构中，id为"content"的元素存放着需要解析的书籍章节的实际文本内容，
+        // 如果网站页面结构发生变化，这个假设可能就不成立了，相应的代码逻辑可能需要调整
         List<TextNode> contentEs = doc.getElementById("content").textNodes();
         StringBuilder content = new StringBuilder();
+        // 开始遍历获取到的文本节点列表contentEs，对其中的每一个文本节点进行处理
         for (int i = 0; i < contentEs.size(); i++) {
+            // 获取当前文本节点的文本内容，并调用trim方法去除文本前后的空白字符（包括空格、制表符、换行符等），使得获取到的文本更加干净、规范，
+            // 避免多余的空白字符影响后续对文本内容的处理以及最终的展示效果
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 使用replaceAll方法替换文本中的不间断空格（" "）以及普通空格，进一步清理文本内容，确保文本格式的一致性和简洁性，
+            // 这样在后续拼接和展示文本时不会出现因空格格式不一致而导致的排版问题
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 判断经过清理后的文本长度是否大于0，如果大于0，说明该文本节点包含有实际有意义的文本内容，需要将其添加到最终的解析结果中进行拼接处理
             if (temp.length() > 0) {
+                // 给有效的文本内容添加两个全角空格（"\u3000\u3000"）作为缩进，使解析后的文本在展示时（比如在阅读软件或者文本编辑工具中）具有更好的排版效果，
+                // 更符合一般阅读的视觉习惯，方便读者阅读和区分不同段落的内容
                 content.append("\u3000\u3000" + temp);
+                // 如果当前文本节点不是列表中的最后一个节点，也就是后面还有其他文本节点需要处理，就在当前文本后面添加换行符（"\r\n"），
+                // 这样可以让不同部分的文本内容分行显示，清晰地分隔开各段文本，使整个书籍内容的展示更加有条理，易于阅读和理解
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+        // 将经过上述一系列处理、拼接后的文本内容以字符串形式返回，这个返回的字符串就是最终解析好的书籍章节内容，
+        // 可以被其他模块（比如显示模块、存储模块等）获取并进一步使用，以实现完整的书籍阅读或者数据处理等功能
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/Content92zwModelImpl.java

@@ -1,4 +1,4 @@
-//Copyright (c) 2017. 章钦豪. All rights reserved.
+// Copyright (c) 2017. 章钦豪. All rights reserved.
 package com.monke.monkeybook.model.impl;
 
 import com.monke.monkeybook.model.IWebContentModel;
@@ -7,31 +7,54 @@ import org.jsoup.nodes.Document;
 import org.jsoup.nodes.TextNode;
 import java.util.List;
 
-public class Content92zwModelImpl implements IWebContentModel{
+// Content92zwModelImpl类实现了IWebContentModel接口，其主要目的是处理来自网址为http://www.92zw.la相关书籍内容的解析工作
+public class Content92zwModelImpl implements IWebContentModel {
+    // 定义一个静态的常量字符串TAG，用于标识该类所针对处理内容的来源网站，这里是http://www.92zw.la，
+    // 或许在后续的代码中可用于区分不同网站来源的相关逻辑处理等情况
     public static final String TAG = "http://www.92zw.la";
 
+    // 采用单例模式，通过此静态方法获取Content92zwModelImpl类的唯一实例。单例模式可以保证在整个应用程序运行期间，
+    // 该类只有一个实例存在，避免重复创建实例造成资源浪费等问题
     public static Content92zwModelImpl getInstance() {
         return new Content92zwModelImpl();
     }
 
+    // 将构造函数私有化，这是实现单例模式的常见做法，外部代码无法直接通过new关键字来创建该类的多个实例，
+    // 只能通过上面的getInstance方法获取唯一实例
     private Content92zwModelImpl() {
 
     }
+
+    // 重写IWebContentModel接口中的analyBookcontent方法，该方法用于对书籍内容进行具体的解析操作
     @Override
     public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库的parse方法，将传入的参数s（通常是从网页获取到的包含书籍内容的HTML字符串）解析为Document对象。
+        // Document对象可以看作是对整个HTML文档结构的一种抽象表示，方便后续基于文档结构去查找和提取相关元素及内容
         Document doc = Jsoup.parse(s);
+        // 通过id属性查找Document对象中id为"contents"的元素，并获取该元素包含的所有文本节点。这里假设id为"contents"的元素
+        // 存放着需要解析的书籍章节的实际文本内容，这是基于http://www.92zw.la网站页面HTML结构的特定设计，若网站结构改变，此处可能需调整
         List<TextNode> contentEs = doc.getElementById("contents").textNodes();
         StringBuilder content = new StringBuilder();
+        // 遍历获取到的文本节点列表contentEs，对每个文本节点进行相应处理
         for (int i = 0; i < contentEs.size(); i++) {
+            // 获取当前文本节点的文本内容，并调用trim方法去除文本前后的空白字符（空格、制表符、换行符等），使得获取到的文本更干净纯粹
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 替换文本中的不间断空格（" "）以及普通空格，进一步清理文本内容，去除多余的空白，避免影响后续文本展示的格式和可读性
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 判断经过清理后的文本长度是否大于0，如果大于0，说明该文本节点包含有实际有意义的内容，需要进行后续处理和拼接
             if (temp.length() > 0) {
+                // 给有效的文本内容添加两个全角空格（"\u3000\u3000"）作为缩进，使解析后的文本在展示时（比如在文本编辑器或者阅读软件中）
+                // 具有更好的排版效果，看起来更加整齐美观，符合一般阅读的格式习惯
                 content.append("\u3000\u3000" + temp);
+                // 如果当前文本节点不是列表中的最后一个节点，也就是后面还有其他文本节点需要处理，就在当前文本后面添加换行符（"\r\n"），
+                // 这样可以让不同部分的文本内容分行显示，更清晰地分隔开各段文本内容，方便阅读和查看
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+        // 将经过上述一系列处理、拼接后的文本内容以字符串形式返回，这个返回的字符串就是解析好的书籍章节内容，
+        // 可以供其他模块进一步使用，比如显示在阅读界面上等
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/ContentAszwModelImpl.java

@@ -1,4 +1,4 @@
-//Copyright (c) 2017. 章钦豪. All rights reserved.
+// Copyright (c) 2017. 章钦豪. All rights reserved.
 package com.monke.monkeybook.model.impl;
 
 import com.monke.monkeybook.model.IWebContentModel;
@@ -7,31 +7,63 @@ import org.jsoup.nodes.Document;
 import org.jsoup.nodes.TextNode;
 import java.util.List;
 
-public class ContentAszwModelImpl implements IWebContentModel{
+// ContentAszwModelImpl类实现了IWebContentModel接口，其主要职责是对来自网址为http://www.aszw.org的书籍内容进行解析处理操作
+public class ContentAszwModelImpl implements IWebContentModel {
+    // 定义一个公共静态的常量字符串TAG，用于标识该类所处理内容对应的网站来源，此处为"http://www.aszw.org"。
+    // 在整个程序的更宏观层面，这个标识可能会在诸如区分不同网站内容、针对不同来源做差异化处理（比如不同的存储策略、格式转换规则等）等场景中发挥作用
     public static final String TAG = "http://www.aszw.org";
 
+    // 这是一个静态方法，遵循单例模式的设计思路，用于获取ContentAszwModelImpl类的唯一实例。
+    // 单例模式确保在程序运行期间，该类只会存在一个实例对象，这样做有助于避免因频繁创建实例而导致的内存资源浪费，同时保证了数据的一致性等，
+    // 适用于像这种对特定网站内容解析的功能模块，因为通常不需要多个实例来完成同样的解析任务
     public static ContentAszwModelImpl getInstance() {
         return new ContentAszwModelImpl();
     }
 
+    // 将构造函数私有化，这是实现单例模式的重要手段之一。通过私有化构造函数，外部代码就无法直接通过new关键字来创建该类的多个实例了，
+    // 只能按照既定的单例模式规则，通过上面定义的getInstance方法获取唯一可用的实例对象
     private ContentAszwModelImpl() {
 
     }
+
+    // 重写IWebContentModel接口中定义的analyBookcontent方法，此方法是整个类实现书籍内容解析功能的核心所在。
+    // 它接收两个参数：
+    // 参数s通常是一个包含了从网页上获取到的书籍章节内容的HTML格式字符串，也就是要进行解析处理的原始文本数据；
+    // 参数realUrl表示该内容对应的真实网址，不过在当前代码中暂时没有看到针对realUrl的具体使用逻辑，在更复杂的应用场景下，它可以用于例如验证网址合法性、
+    // 根据网址不同进行额外的处理或者记录等操作
     @Override
     public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库提供的功能强大的parse方法，将传入的参数s（也就是前面提到的包含书籍内容的HTML字符串）解析成一个Document对象。
+        // Document对象在Jsoup框架里代表着对整个HTML文档结构的一种抽象表示，借助它可以方便地按照HTML文档固有的结构（像通过标签、元素的id或class属性等方式）
+        // 去查找、提取以及操作相应的内容，为后续解析书籍内容奠定基础
         Document doc = Jsoup.parse(s);
+        // 通过Document对象提供的getElementById方法，依据元素的id属性去查找id为"contents"的元素，并获取这个元素所包含的所有文本节点。
+        // 这里基于对http://www.aszw.org网站页面结构的一种假设，即认为id为"contents"的元素里面存放着需要解析提取的书籍章节的实际文本内容。
+        // 倘若该网站后续对页面结构进行了更改，导致这个元素的位置、作用或者内容存储方式发生变化，那么此处的代码逻辑可能就需要相应地进行调整了
         List<TextNode> contentEs = doc.getElementById("contents").textNodes();
         StringBuilder content = new StringBuilder();
+        // 开启一个循环，对获取到的文本节点列表contentEs进行遍历，依次处理其中的每一个文本节点，目的是将它们整理、拼接成最终期望的书籍内容文本格式
         for (int i = 0; i < contentEs.size(); i++) {
+            // 获取当前正在处理的文本节点的文本内容，并调用trim方法去除该文本前后可能存在的空白字符（例如空格、制表符、换行符等），
+            // 这样做是为了让获取到的文本更加纯粹、规范，避免那些多余的空白字符在后续的文本处理和展示过程中造成不必要的干扰，比如影响排版效果等
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 利用replaceAll方法来替换文本中的不间断空格（" "）以及普通空格，进一步对文本内容进行清理，使得文本的格式更加统一、简洁，
+            // 确保在后续将各个文本节点的内容拼接起来后，文本整体的展示效果更加整齐、美观，不会因为空格格式不一致等问题而显得杂乱无章
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 判断经过上述清理操作后的文本长度是否大于0，如果大于0，就说明这个文本节点包含了实际有意义的内容，值得添加到最终解析好的书籍内容当中去
             if (temp.length() > 0) {
+                // 给有效的文本内容添加两个全角空格（"\u3000\u3000"）作为缩进，这么做是为了让解析后的书籍内容在展示时（比如在阅读类应用程序或者文本编辑工具里呈现时）
+                // 具备更好的排版效果，更符合人们日常阅读书籍时对于段落格式、缩进等方面的视觉习惯，方便读者清晰地阅读和区分不同部分的内容
                 content.append("\u3000\u3000" + temp);
+                // 如果当前正在处理的文本节点不是列表中的最后一个节点，也就是后面还有其他文本节点需要继续处理和拼接，那么就在当前文本内容后面添加一个换行符（"\r\n"），
+                // 这样可以让不同部分的文本内容分行显示，使得整个书籍内容在展示上更加有条理、层次分明，更易于阅读者理解和浏览
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+        // 将经过前面一系列处理、拼接操作后得到的文本内容以字符串的形式返回，这个返回的字符串就是最终解析完成的、符合预期格式的书籍章节内容，
+        // 它可以被程序中的其他模块（例如用于展示书籍内容的界面模块、负责将内容存储起来的存储模块等）获取并进一步加以利用，以实现完整的书籍阅读或者相关的数据处理等功能
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/ContentBaishukuModelImpl.java

@@ -1,4 +1,4 @@
-//Copyright (c) 2017. 章钦豪. All rights reserved.
+// Copyright (c) 2017. 章钦豪. All rights reserved.
 package com.monke.monkeybook.model.impl;
 
 import com.monke.monkeybook.model.IWebContentModel;
@@ -7,31 +7,63 @@ import org.jsoup.nodes.Document;
 import org.jsoup.nodes.TextNode;
 import java.util.List;
 
-public class ContentBaishukuModelImpl implements IWebContentModel{
+// ContentBaishukuModelImpl类实现了IWebContentModel接口，其主要功能是针对来自网址为http://baishuku.com的书籍内容进行解析处理。
+public class ContentBaishukuModelImpl implements IWebContentModel {
+    // 定义一个公共静态的常量字符串TAG，其值为"http://baishuku.com"，用于标识该类所负责处理内容对应的网站来源。
+    // 在整个程序架构中，这个标识有可能会用于区分不同网站的内容，例如根据不同来源网站做差异化的逻辑处理，像内容格式调整、存储方式的不同选择等操作。
     public static final String TAG = "http://baishuku.com";
 
+    // 这是一个静态方法，采用单例模式来获取ContentBaishukuModelImpl类的唯一实例。
+    // 单例模式确保在程序运行期间，该类只会存在一个实例对象，避免了因多次创建实例而可能造成的内存资源浪费，同时保证了在处理相关内容时数据的一致性等情况。
+    // 对于这种针对特定网站内容解析的功能模块来说，通常不需要多个实例来完成同样的解析工作，所以使用单例模式较为合适。
     public static ContentBaishukuModelImpl getInstance() {
         return new ContentBaishukuModelImpl();
     }
 
+    // 将构造函数私有化，这是实现单例模式的关键步骤之一。通过把构造函数设置为私有，外部代码就无法直接通过new关键字来创建该类的多个实例了，
+    // 只能按照单例模式规定的方式，也就是通过上面定义的getInstance方法来获取唯一可用的实例对象，以此保证单例模式的正确实现。
     private ContentBaishukuModelImpl() {
 
     }
+
+    // 重写了IWebContentModel接口中定义的analyBookcontent方法，此方法是整个类实现解析书籍内容这一核心功能的关键所在。
+    // 它接收两个参数：
+    // 参数s是一个字符串，通常代表从http://baishuku.com网站获取到的包含书籍章节内容的HTML格式的字符串，也就是要进行解析处理的原始文本数据；
+    // 参数realUrl表示该内容对应的真实网址，不过在当前代码中暂时未看到针对realUrl参数有进一步的使用逻辑，在更复杂的应用场景下，
+    // 可以基于这个参数做一些额外的操作，比如验证网址的合法性、根据网址不同做不同的处理策略等。
     @Override
     public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库提供的parse方法，将传入的参数s（即包含书籍内容的HTML字符串）解析为一个Document对象。
+        // Document对象在Jsoup框架里是对HTML文档结构的一种抽象表示，通过它可以方便地按照HTML文档的结构特点（例如通过元素的id、class属性等方式）
+        // 去查找、提取和操作相应的内容，这为后续解析书籍内容打下了基础。
         Document doc = Jsoup.parse(s);
+        // 通过Document对象提供的getElementById方法，按照元素的id属性查找id为"content"的元素，并获取这个元素包含的所有文本节点。
+        // 这里基于对http://baishuku.com网站页面结构的一种假设，即认为id为"content"的元素存放着需要解析的书籍章节的实际文本内容。
+        // 如果该网站后续对页面结构进行了改变，导致这个元素的相关情况（如位置、内容存储方式等）发生变化，那么此处的代码逻辑可能就需要相应地调整了。
         List<TextNode> contentEs = doc.getElementById("content").textNodes();
         StringBuilder content = new StringBuilder();
+        // 开始循环遍历获取到的文本节点列表contentEs，目的是对其中的每一个文本节点进行处理，最终将它们整理、拼接成符合要求的书籍内容文本格式。
         for (int i = 0; i < contentEs.size(); i++) {
+            // 获取当前正在处理的文本节点的文本内容，并调用trim方法去除文本前后可能存在的空白字符（比如空格、制表符、换行符等），
+            // 这样做可以让获取到的文本更加纯净、规范，避免多余的空白字符对后续文本处理以及最终展示效果产生不良影响，例如造成排版混乱等问题。
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 使用replaceAll方法替换文本中的不间断空格（" "）以及普通空格，进一步对文本内容进行清理，使得文本格式更加统一、简洁，
+            // 保证在后续拼接各个文本节点内容后，整个书籍内容的展示效果更加整齐、美观，不会出现因空格格式不一致而显得杂乱的情况。
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 判断经过上述清理操作后的文本长度是否大于0，如果大于0，则说明这个文本节点包含了实际有意义的内容，需要将其添加到最终解析好的书籍内容当中。
             if (temp.length() > 0) {
+                // 给有效的文本内容添加两个全角空格（"\u3000\u3000"）作为缩进，这样做可以让解析后的书籍内容在展示时（比如在阅读应用程序或者文本编辑工具中呈现时）
+                // 具有更好的排版效果，更符合人们日常阅读书籍时对段落格式、缩进等方面的视觉习惯，便于读者清晰地阅读和区分不同部分的内容。
                 content.append("\u3000\u3000" + temp);
+                // 如果当前正在处理的文本节点不是列表中的最后一个节点，也就是后面还有其他文本节点需要继续处理和拼接，
+                // 那么就在当前文本内容后面添加一个换行符（"\r\n"），使得不同部分的文本内容能够分行显示，让整个书籍内容在展示上更有条理、层次分明，更易于阅读者理解和浏览。
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+        // 将经过前面一系列处理、拼接操作后得到的文本内容以字符串的形式返回，这个返回的字符串就是最终解析完成的、符合预期格式的书籍章节内容，
+        // 它可以被程序中的其他模块（例如用于展示书籍内容的界面模块、负责存储书籍内容的存储模块等）获取并进一步加以利用，以实现完整的书籍阅读或者相关的数据处理等功能。
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/ContentBxwx9ModelImpl.java

@@ -1,4 +1,4 @@
-//Copyright (c) 2017. 章钦豪. All rights reserved.
+// Copyright (c) 2017. 章钦豪. All rights reserved.
 package com.monke.monkeybook.model.impl;
 
 import com.monke.monkeybook.model.IWebContentModel;
@@ -7,31 +7,70 @@ import org.jsoup.nodes.Document;
 import org.jsoup.nodes.TextNode;
 import java.util.List;
 
-public class ContentBxwx9ModelImpl implements IWebContentModel{
+// ContentBxwx9ModelImpl类实现了IWebContentModel接口，其主要用途是对来自网址为http://www.bxwx9.org的书籍内容进行解析处理操作。
+public class ContentBxwx9ModelImpl implements IWebContentModel {
+    // 定义一个公共静态的常量字符串TAG，其值被设定为"http://www.bxwx9.org"，该TAG用于标识此解析类所对应的内容来源网站。
+    // 在整个程序的更大架构中，这个标识可以用于区分不同来源网站的内容，比如针对不同网站的内容采取不同的后续处理逻辑，像存储格式的调整、展示样式的适配等情况。
     public static final String TAG = "http://www.bxwx9.org";
 
+    // 这是一个遵循单例模式设计的静态方法，用于获取ContentBxwx9ModelImpl类的唯一实例。
+    // 单例模式确保在程序运行期间，此类只会存在一个实例对象，这样做能够避免因重复创建实例而可能导致的内存资源浪费，同时保障在处理相关书籍内容时数据的一致性等方面的要求。
+    // 对于专门针对特定网站书籍内容解析的功能模块而言，通常一个实例就足以完成相应的解析任务，所以采用单例模式是比较合适的选择。
     public static ContentBxwx9ModelImpl getInstance() {
         return new ContentBxwx9ModelImpl();
     }
 
+    // 将构造函数私有化，这是实现单例模式的重要手段之一。通过把构造函数设置为私有属性，外部代码就无法直接通过使用new关键字来创建该类的多个实例了。
+    // 外部只能按照单例模式所规定的方式，也就是通过调用上面定义的getInstance方法来获取唯一可用的实例对象，以此保证单例模式能够正确地得以实现。
     private ContentBxwx9ModelImpl() {
 
     }
+
+    // 重写了IWebContentModel接口中定义的analyBookcontent方法，该方法是整个ContentBxwx9ModelImpl类实现解析书籍内容这一核心功能的关键所在。
+    // 它接收两个参数：
+    // 参数s是一个字符串类型的变量，通常表示从http://www.bxwx9.org网站获取到的包含书籍章节内容的HTML格式的字符串，也就是后续要进行解析处理的原始文本数据；
+    // 参数realUrl同样是字符串类型，它代表该内容对应的真实网址，不过在当前代码的现有逻辑中，暂时没有看到针对这个realUrl参数有进一步的具体使用情况，
+    // 但在更为复杂的应用场景下，这个参数可以被用于诸如验证网址的合法性、根据不同网址执行不同的解析策略或者记录相关网址信息等操作。
     @Override
     public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库提供的功能强大的parse方法，将传入的参数s（即包含书籍内容的HTML字符串）解析成为一个Document对象。
+        // 在Jsoup框架里，Document对象是对HTML文档结构进行抽象表示的一种重要形式，借助它能够方便地依据HTML文档自身的结构特点（例如通过元素的id、class属性等方式），
+        // 去查找、提取以及操作对应的内容，这为后续深入解析书籍内容搭建了良好的基础。
         Document doc = Jsoup.parse(s);
+        // 通过Document对象提供的便捷方法getElementById，按照元素的id属性去查找id为"content"的元素，并获取这个元素所包含的所有文本节点。
+        // 此处基于对http://www.bxwx9.org网站页面结构的一种既有假设，即认为id为"content"的这个元素存放着需要解析的书籍章节的实际文本内容。
+        // 然而，如果该网站后续对自身的页面结构进行了调整修改，导致这个元素在页面中的位置、其所存储内容的方式等方面发生了变化，
+        // 那么此处的代码逻辑就很可能需要相应地做出适应性的调整改变了。
         List<TextNode> contentEs = doc.getElementById("content").textNodes();
         StringBuilder content = new StringBuilder();
+        // 开启一个循环，对获取到的文本节点列表contentEs进行逐一的遍历操作，目的在于对其中每一个文本节点都按照既定的规则进行处理，
+        // 最终将它们合理地整理、拼接成为符合预期格式的书籍内容文本。
         for (int i = 0; i < contentEs.size(); i++) {
+            // 首先获取当前正在处理的文本节点所包含的文本内容，然后调用trim方法去除该文本前后可能存在的空白字符（这些空白字符可能包含空格、制表符、换行符等等），
+            // 通过这样的操作可以使得获取到的文本更加纯净、规范，从而避免多余的空白字符对后续文本的处理流程以及最终的展示效果产生不良的影响，
+            // 例如可能会造成文本排版出现混乱无序的情况等。
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 接着使用Java中的replaceAll方法来对文本中的不间断空格（" "）以及普通空格进行替换操作，进一步对文本内容进行清理优化，
+            // 以此让文本的格式变得更加统一、简洁，进而保证在后续把各个文本节点的内容拼接起来之后，整个书籍内容在展示的时候能够更加整齐、美观，
+            // 不会由于空格格式不一致等问题而显得杂乱无章、影响阅读体验。
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 对经过上述一系列清理操作后的文本进行长度判断，如果其长度大于0，那就意味着这个文本节点中包含了实际有意义的内容，
+            // 这样的文本内容是需要被添加到最终解析好的书籍内容当中去的。
             if (temp.length() > 0) {
+                // 针对有实际意义的文本内容，给它添加两个全角空格（"\u3000\u3000"）作为缩进，这么做的好处是可以让解析后的书籍内容在展示时（比如在阅读类的应用程序或者文本编辑工具中呈现时），
+                // 具备更好的排版效果，更加贴合人们日常阅读书籍时对于段落格式、缩进等方面的视觉习惯，方便读者能够更加清晰地阅读和区分不同部分的文本内容。
                 content.append("\u3000\u3000" + temp);
+                // 如果当前正在处理的文本节点并非是列表中的最后一个节点，也就是说后面还有其他的文本节点需要继续进行处理和拼接操作，
+                // 那么就在当前文本内容的后面添加一个换行符（"\r\n"），通过这样的方式可以使得不同部分的文本内容能够分行显示，
+                // 让整个书籍内容在展示方面更加有条理、层次分明，更有助于阅读者去理解和浏览其中的内容。
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+        // 经过前面循环中对各个文本节点的处理、拼接等一系列操作之后，将最终得到的文本内容以字符串的形式返回。
+        // 这个返回的字符串就是经过完整解析、并且符合预期格式要求的书籍章节内容了，它可以被程序中的其他相关模块（例如用于展示书籍内容的界面模块、
+        // 负责将书籍内容进行存储的存储模块等）获取并进一步加以利用，以此来实现完整的书籍阅读或者其他相关的数据处理等功能。
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/ContentCommendModelImpl.java

@@ -1,4 +1,4 @@
-//Copyright (c) 2017. 章钦豪. All rights reserved.
+// Copyright (c) 2017. 章钦豪. All rights reserved.
 package com.monke.monkeybook.model.impl;
 
 import com.monke.monkeybook.ErrorAnalyContentManager;
@@ -8,37 +8,75 @@ import org.jsoup.nodes.Document;
 import org.jsoup.nodes.TextNode;
 import java.util.List;
 
+// ContentCommendModelImpl类，从命名来看可能是用于通用的内容推荐相关模型实现（但从代码功能上更像是内容解析相关，可能命名不太准确，需结合更完整的业务场景判断）
 public class ContentCommendModelImpl {
 
+    // 采用单例模式，通过此静态方法获取ContentCommendModelImpl类的唯一实例。
+    // 单例模式可以保证在整个应用程序运行期间，该类只有一个实例存在，避免重复创建实例造成资源浪费等问题，适用于一些全局唯一的功能模块场景。
     public static ContentCommendModelImpl getInstance() {
         return new ContentCommendModelImpl();
     }
 
+    // 将构造函数私有化，这是实现单例模式的常见做法，外部代码无法直接通过new关键字来创建该类的多个实例，
+    // 只能通过上面的getInstance方法获取唯一实例，以此确保类实例的唯一性和对其创建过程的控制。
     private ContentCommendModelImpl() {
 
     }
+
+    // analyBookcontent方法用于解析书籍内容，并将解析结果设置到BookContentBean对象中返回，同时处理可能出现的解析异常情况。
+    // 它接收三个参数：
+    // - bookContentBean：一个BookContentBean类型的对象，可能用于承载解析后的书籍内容以及相关状态信息等，最终也会将解析结果设置到这个对象中返回。
+    // - s：一个字符串，通常代表从网页获取到的包含书籍章节内容的HTML格式的字符串，也就是要进行解析处理的原始文本数据。
+    // - realUrl：表示该内容对应的真实网址，可能在记录错误信息、判断网站支持情况等方面会用到这个参数。
     public BookContentBean analyBookcontent(BookContentBean bookContentBean, String s, String realUrl) throws Exception {
+        // 调用ErrorAnalyContentManager的单例实例的writeNewErrorUrl方法，将当前尝试解析的真实网址记录下来，
+        // 可能用于后续统计哪些网址出现过解析问题或者进行错误分析等相关操作，具体功能取决于ErrorAnalyContentManager类的实现逻辑。
         ErrorAnalyContentManager.getInstance().writeNewErrorUrl(realUrl);
-        try{
+
+        try {
+            // 使用Jsoup库的parse方法，将传入的参数s（即包含书籍内容的HTML字符串）解析为Document对象。
+            // Document对象可以看作是对整个HTML文档结构的一种抽象表示，方便后续基于文档结构去查找和提取相关元素及内容，
+            // 例如通过元素的id、class等属性查找特定元素。
             Document doc = Jsoup.parse(s);
+            // 通过id属性查找Document对象中id为"content"的元素，并获取该元素包含的所有文本节点。
+            // 这里假设id为"content"的元素存放着需要解析的书籍章节的实际文本内容，不过这依赖于对应网页的HTML结构设计，
+            // 若网页结构改变，此处获取内容的逻辑可能会失效，需要相应调整。
             List<TextNode> contentEs = doc.getElementById("content").textNodes();
             StringBuilder content = new StringBuilder();
+            // 遍历获取到的文本节点列表contentEs，对每个文本节点进行相应处理，目的是整理并拼接出最终的书籍内容文本。
             for (int i = 0; i < contentEs.size(); i++) {
+                // 获取当前文本节点的文本内容，并调用trim方法去除文本前后的空白字符（空格、制表符、换行符等），使得获取到的文本更干净纯粹，
+                // 避免多余空白字符影响后续文本处理和展示效果，比如排版等方面。
                 String temp = contentEs.get(i).text().trim();
-                temp = temp.replaceAll(" ","").replaceAll(" ","");
+                // 替换文本中的不间断空格（" "）以及普通空格，进一步清理文本内容，去除不必要的空白，使文本格式更统一，便于后续拼接展示。
+                temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+                // 判断经过清理后的文本长度是否大于0，如果大于0，说明该文本节点包含有实际有意义的内容，需要进行后续处理和拼接。
                 if (temp.length() > 0) {
+                    // 给有效的文本内容添加两个全角空格（"\u3000\u3000"）作为缩进，使解析后的文本在展示时（比如在文本编辑器或者阅读软件中）
+                    // 具有更好的排版效果，看起来更加整齐美观，符合一般阅读的格式习惯。
                     content.append("\u3000\u3000" + temp);
+                    // 如果当前文本节点不是列表中的最后一个节点，也就是后面还有其他文本节点需要处理，就在当前文本后面添加换行符（"\r\n"），
+                    // 这样可以让不同部分的文本内容分行显示，更清晰地分隔开各段文本内容，方便阅读和查看。
                     if (i < contentEs.size() - 1) {
                         content.append("\r\n");
                     }
                 }
             }
+            // 将处理好的包含书籍章节内容的文本设置到bookContentBean对象的durCapterContent属性中，
+            // 这样通过这个对象就可以将解析后的内容传递到其他需要使用的地方了。
             bookContentBean.setDurCapterContent(content.toString());
-        }catch (Exception e){
+        } catch (Exception e) {
+            // 如果在解析过程中出现异常，先打印异常的堆栈信息，方便进行调试和排查问题，了解异常发生的具体位置和原因。
             e.printStackTrace();
+            // 设置bookContentBean对象的durCapterContent属性为一段提示信息，告知用户当前站点暂时不支持解析，
+            // 并提供了反馈的QQ联系方式以及承诺解决问题的时效等信息，用于向用户说明情况。
             bookContentBean.setDurCapterContent(realUrl.substring(0, realUrl.indexOf('/', 8)) + "站点暂时不支持解析，请反馈给Monke QQ:1105075896,半小时内解决，超级效率的程序员");
+            // 同时将bookContentBean对象的right属性设置为false，表示解析出现了问题，该内容可能是不正确或者不完全的，
+            // 其他使用这个对象的地方可以根据这个属性来判断解析结果的有效性。
             bookContentBean.setRight(false);
         }
+        // 最后将处理后的bookContentBean对象返回，这个对象中包含了解析后的书籍内容以及相关状态信息，
+        // 可供其他模块进一步使用，比如展示给用户或者进行后续的业务逻辑处理等。
         return bookContentBean;
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/ContentDhzwModelImpl.java

@@ -1,4 +1,4 @@
-//Copyright (c) 2017. 章钦豪. All rights reserved.
+// Copyright (c) 2017. 章钦豪. All rights reserved.
 package com.monke.monkeybook.model.impl;
 
 import com.monke.monkeybook.model.IWebContentModel;
@@ -7,31 +7,73 @@ import org.jsoup.nodes.Document;
 import org.jsoup.nodes.TextNode;
 import java.util.List;
 
-public class ContentDhzwModelImpl implements IWebContentModel{
+// ContentDhzwModelImpl类实现了IWebContentModel接口，其主要功能是针对来自网址为http://www.dhzw.org的书籍内容进行解析处理，以提取出可用的文本内容。
+public class ContentDhzwModelImpl implements IWebContentModel {
+    // 定义一个公共静态的常量字符串TAG，其值设定为"http://www.dhzw.org"，用于标识该类所处理内容对应的网站来源。
+    // 在整个程序架构中，这个标识可用于区分不同网站的内容，例如后续根据不同来源网站采取不同的处理逻辑，像针对特定网站内容进行格式转换、存储策略调整等操作。
     public static final String TAG = "http://www.dhzw.org";
 
+    // 这是一个静态方法，采用单例模式来获取ContentDhzwModelImpl类的唯一实例。
+    // 单例模式能确保在程序运行期间，该类只会存在一个实例对象，避免了因多次创建实例而可能引发的内存资源浪费问题，同时保证了在解析相关书籍内容时数据的一致性等情况。
+    // 对于这种专门针对特定网站内容解析的功能模块而言，通常只需一个实例就能完成相应的解析任务，所以单例模式是比较合适的设计选择。
     public static ContentDhzwModelImpl getInstance() {
         return new ContentDhzwModelImpl();
     }
 
+    // 将构造函数私有化，这是实现单例模式的关键步骤之一。通过把构造函数设置为私有，外部代码就无法直接通过new关键字来创建该类的多个实例了，
+    // 只能按照单例模式规定的方式，也就是通过上面定义的getInstance方法来获取唯一可用的实例对象，以此保障单例模式的正确实现。
     private ContentDhzwModelImpl() {
 
     }
+
+    // 重写IWebContentModel接口中定义的analyBookcontent方法，此方法是整个类实现解析书籍内容这一核心功能的关键所在。
+    // 它接收两个参数：
+    // 参数s是一个字符串，通常代表从http://www.dhzw.org网站获取到的包含书籍章节内容的HTML格式的字符串，也就是要进行解析处理的原始文本数据；
+    // 参数realUrl表示该内容对应的真实网址，不过在当前代码的现有逻辑中，暂时未看到针对realUrl参数有进一步的具体使用情况，
+    // 但在更为复杂的应用场景下，该参数可用于验证网址合法性、根据网址不同执行不同的解析策略或者记录相关网址信息等操作。
     @Override
     public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库提供的parse方法，将传入的参数s（即包含书籍内容的HTML字符串）解析为一个Document对象。
+        // 在Jsoup框架里，Document对象是对HTML文档结构进行抽象表示的一种重要形式，借助它能够方便地依据HTML文档自身的结构特点（例如通过元素的id、class属性等方式），
+        // 去查找、提取以及操作对应的内容，这为后续深入解析书籍内容搭建了良好的基础。
         Document doc = Jsoup.parse(s);
+        // 通过Document对象提供的便捷方法getElementById，按照元素的id属性去查找id为"BookText"的元素，并获取这个元素所包含的所有文本节点。
+        // 此处基于对http://www.dhzw.org网站页面结构的一种既有假设，即认为id为"BookText"的这个元素存放着需要解析的书籍章节的实际文本内容。
+        // 倘若该网站后续对自身的页面结构进行了调整修改，导致这个元素在页面中的位置、其所存储内容的方式等方面发生了变化，
+        // 那么此处的代码逻辑就很可能需要相应地做出适应性的调整改变了。
         List<TextNode> contentEs = doc.getElementById("BookText").textNodes();
         StringBuilder content = new StringBuilder();
+        // 开启一个循环，对获取到的文本节点列表contentEs进行逐一的遍历操作，目的在于对其中每一个文本节点都按照既定的规则进行处理，
+        // 最终将它们合理地整理、拼接成为符合预期格式的书籍内容文本。
         for (int i = 0; i < contentEs.size(); i++) {
+            // 首先获取当前正在处理的文本节点所包含的文本内容，然后调用trim方法去除该文本前后可能存在的空白字符（这些空白字符可能包含空格、制表符、换行符等等），
+            // 通过这样的操作可以使得获取到的文本更加纯净、规范，从而避免多余的空白字符对后续文本的处理流程以及最终的展示效果产生不良的影响，
+            // 例如可能会造成文本排版出现混乱无序的情况等。
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 接着使用Java中的replaceAll方法来对文本中的不间断空格（" "）以及普通空格进行替换操作，进一步对文本内容进行清理优化，
+            // 以此让文本的格式变得更加统一、简洁，进而保证在后续把各个文本节点的内容拼接起来之后，整个书籍内容在展示的时候能够更加整齐、美观，
+            // 不会由于空格格式不一致等问题而显得杂乱无章、影响阅读体验。
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 额外的处理：将文本中的全角空格（“　”）也进行替换去除，进一步清理文本内容，确保文本格式更加规范，此处同样是基于对网站内容格式特点的一种处理需求假设。
+            temp = temp.replaceAll("　", "");
+            // 对经过上述一系列清理操作后的文本进行长度判断，如果其长度大于0，那就意味着这个文本节点中包含了实际有意义的内容，
+            // 这样的文本内容是需要被添加到最终解析好的书籍内容当中去的。
             if (temp.length() > 0) {
-                content.append("\u3000\u3000" + contentEs.get(i).text().trim().replaceAll("　",""));
+                // 针对有实际意义的文本内容，给它添加两个全角空格（"\u3000\u3000"）作为缩进，这么做的好处是可以让解析后的书籍内容在展示时（比如在阅读类的应用程序或者文本编辑工具中呈现时），
+                // 具备更好的排版效果，更加贴合人们日常阅读书籍时对于段落格式、缩进等方面的视觉习惯，方便读者能够更加清晰地阅读和区分不同部分的文本内容。
+                // 这里注意，在添加缩进时，再次获取了当前文本节点处理后的文本内容（调用了一次text().trim().replaceAll("　","")），可能代码存在一些重复逻辑，可考虑优化。
+                content.append("\u3000\u3000" + contentEs.get(i).text().trim().replaceAll("　", ""));
+                // 如果当前正在处理的文本节点并非是列表中的最后一个节点，也就是说后面还有其他的文本节点需要继续进行处理和拼接操作，
+                // 那么就在当前文本内容的后面添加一个换行符（"\r\n"），通过这样的方式可以使得不同部分的文本内容能够分行显示，
+                // 让整个书籍内容在展示方面更加有条理、层次分明，更有助于阅读者去理解和浏览其中的内容。
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+        // 经过前面循环中对各个文本节点的处理、拼接等一系列操作之后，将最终得到的文本内容以字符串的形式返回。
+        // 这个返回的字符串就是经过完整解析、并且符合预期格式要求的书籍章节内容了，它可以被程序中的其他相关模块（例如用于展示书籍内容的界面模块、
+        // 负责将书籍内容进行存储的存储模块等）获取并进一步加以利用，以此来实现完整的书籍阅读或者其他相关的数据处理等功能。
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/ContentEasouModelImpl.java

@@ -1,4 +1,4 @@
-//Copyright (c) 2017. 章钦豪. All rights reserved.
+// Copyright (c) 2017. 章钦豪. All rights reserved.
 package com.monke.monkeybook.model.impl;
 
 import com.monke.monkeybook.model.IWebContentModel;
@@ -7,32 +7,70 @@ import org.jsoup.nodes.Document;
 import org.jsoup.nodes.TextNode;
 import java.util.List;
 
+// ContentEasouModelImpl类实现了IWebContentModel接口，其主要职责是对来自网址为http://book.easou.com的书籍内容进行解析处理操作。
 public class ContentEasouModelImpl implements IWebContentModel {
+    // 定义一个公共静态的常量字符串TAG，其值被设定为"http://book.easou.com"，该TAG用于标识此解析类所对应的内容来源网站。
+    // 在整个程序的更大架构中，这个标识可以用于区分不同来源网站的内容，比如针对不同网站的内容采取不同的后续处理逻辑，像存储格式的调整、展示样式的适配等情况。
     public static final String TAG = "http://book.easou.com";
 
-    public static ContentEasouModelImpl getInstance(){
+    // 这是一个遵循单例模式设计的静态方法，用于获取ContentEasouModelImpl类的唯一实例。
+    // 单例模式确保在程序运行期间，此类只会存在一个实例对象，这样做能够避免因重复创建实例而可能导致的内存资源浪费，同时保障在处理相关书籍内容时数据的一致性等方面的要求。
+    // 对于专门针对特定网站书籍内容解析的功能模块而言，通常一个实例就足以完成相应的解析任务，所以采用单例模式是比较合适的选择。
+    public static ContentEasouModelImpl getInstance() {
         return new ContentEasouModelImpl();
     }
 
-    private ContentEasouModelImpl(){
+    // 将构造函数私有化，这是实现单例模式的重要手段之一。通过把构造函数设置为私有属性，外部代码就无法直接通过使用new关键字来创建该类的多个实例了。
+    // 外部只能按照单例模式所规定的方式，也就是通过调用上面定义的getInstance方法来获取唯一可用的实例对象，以此保证单例模式能够正确地得以实现。
+    private ContentEasouModelImpl() {
 
     }
 
+    // 重写了IWebContentModel接口中定义的analyBookcontent方法，该方法是整个ContentEasouModelImpl类实现解析书籍内容这一核心功能的关键所在。
+    // 它接收两个参数：
+    // 参数s是一个字符串类型的变量，通常表示从http://book.easou.com网站获取到的包含书籍章节内容的HTML格式的字符串，也就是后续要进行解析处理的原始文本数据；
+    // 参数realUrl同样是字符串类型，它代表该内容对应的真实网址，不过在当前代码的现有逻辑中，暂时没有看到针对这个realUrl参数有进一步的具体使用情况，
+    // 但在更为复杂的应用场景下，这个参数可以被用于诸如验证网址的合法性、根据不同网址执行不同的解析策略或者记录相关网址信息等操作。
     @Override
-    public String analyBookcontent(String s, String realUrl) throws Exception{
+    public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库提供的功能强大的parse方法，将传入的参数s（即包含书籍内容的HTML字符串）解析成为一个Document对象。
+        // 在Jsoup框架里，Document对象是对HTML文档结构进行抽象表示的一种重要形式，借助它能够方便地依据HTML文档自身的结构特点（例如通过元素的id、class属性等方式），
+        // 去查找、提取以及操作对应的内容，这为后续深入解析书籍内容搭建了良好的基础。
         Document doc = Jsoup.parse(s);
+        // 通过Document对象提供的便捷方法getElementsByClass，按照元素的class属性去查找class为"show"的元素，并获取查找到的第一个该类元素（通过调用get(0)），
+        // 然后获取这个元素所包含的所有文本节点。这里基于对http://book.easou.com网站页面结构的一种既有假设，即认为class为"show"的这个元素（第一个匹配的）存放着需要解析的书籍章节的实际文本内容。
+        // 然而，如果该网站后续对自身的页面结构进行了调整修改，导致这个元素在页面中的位置、其所存储内容的方式等方面发生了变化，
+        // 那么此处的代码逻辑就很可能需要相应地做出适应性的调整改变了。
         List<TextNode> contentEs = doc.getElementsByClass("show").get(0).textNodes();
         StringBuilder content = new StringBuilder();
+        // 开启一个循环，对获取到的文本节点列表contentEs进行逐一的遍历操作，目的在于对其中每一个文本节点都按照既定的规则进行处理，
+        // 最终将它们合理地整理、拼接成为符合预期格式的书籍内容文本。
         for (int i = 0; i < contentEs.size(); i++) {
+            // 首先获取当前正在处理的文本节点所包含的文本内容，然后调用trim方法去除该文本前后可能存在的空白字符（这些空白字符可能包含空格、制表符、换行符等等），
+            // 通过这样的操作可以使得获取到的文本更加纯净、规范，从而避免多余的空白字符对后续文本的处理流程以及最终的展示效果产生不良的影响，
+            // 例如可能会造成文本排版出现混乱无序的情况等。
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 接着使用Java中的replaceAll方法来对文本中的不间断空格（" "）以及普通空格进行替换操作，进一步对文本内容进行清理优化，
+            // 以此让文本的格式变得更加统一、简洁，进而保证在后续把各个文本节点的内容拼接起来之后，整个书籍内容在展示的时候能够更加整齐、美观，
+            // 不会由于空格格式不一致等问题而显得杂乱无章、影响阅读体验。
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 对经过上述一系列清理操作后的文本进行长度判断，如果其长度大于0，那就意味着这个文本节点中包含了实际有意义的内容，
+            // 这样的文本内容是需要被添加到最终解析好的书籍内容当中去的。
             if (temp.length() > 0) {
+                // 针对有实际意义的文本内容，给它添加两个全角空格（"\u3000\u3000"）作为缩进，这么做的好处是可以让解析后的书籍内容在展示时（比如在阅读类的应用程序或者文本编辑工具中呈现时），
+                // 具备更好的排版效果，更加贴合人们日常阅读书籍时对于段落格式、缩进等方面的视觉习惯，方便读者能够更加清晰地阅读和区分不同部分的文本内容。
                 content.append("\u3000\u3000" + temp);
+                // 如果当前正在处理的文本节点并非是列表中的最后一个节点，也就是说后面还有其他的文本节点需要继续进行处理和拼接操作，
+                // 那么就在当前文本内容的后面添加一个换行符（"\r\n"），通过这样的方式可以使得不同部分的文本内容能够分行显示，
+                // 让整个书籍内容在展示方面更加有条理、层次分明，更有助于阅读者去理解和浏览其中的内容。
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+        // 经过前面循环中对各个文本节点的处理、拼接等一系列操作之后，将最终得到的文本内容以字符串的形式返回。
+        // 这个返回的字符串就是经过完整解析、并且符合预期格式要求的书籍章节内容了，它可以被程序中的其他相关模块（例如用于展示书籍内容的界面模块、
+        // 负责将书籍内容进行存储的存储模块等）获取并进一步加以利用，以此来实现完整的书籍阅读或者其他相关的数据处理等功能。
         return content.toString();
     }
 }

app/src/main/java/com/monke/monkeybook/model/impl/ContentFuheishuModelImpl.java

@@ -8,34 +8,81 @@ import org.jsoup.nodes.TextNode;
 import java.util.List;
 
 /**
- * 站点有问题  未完全解析
+ * ContentFuheishuModelImpl类实现了IWebContentModel接口，用于对特定网站（由TAG标识为http://fuheishu.com）
+ * 的书籍内容进行解析处理。当前已知该站点存在一些问题，导致解析功能未能完全实现，后续可能需要进一步完善相关逻辑。
  */
-public class ContentFuheishuModelImpl implements IWebContentModel{
+public class ContentFuheishuModelImpl implements IWebContentModel {
+
+    // 定义一个静态常量TAG，用于标识该内容解析模型所对应的网站地址，此处为http://fuheishu.com
     public static final String TAG = "http://fuheishu.com";
 
-    public static ContentFuheishuModelImpl getInstance(){
+    /**
+     * 获取ContentFuheishuModelImpl类的单例实例。
+     * 采用单例模式，确保在整个程序运行过程中，只会创建一个该类的实例，方便统一管理与使用其解析功能。
+     *
+     * @return 返回ContentFuheishuModelImpl类的唯一实例对象。
+     */
+    public static ContentFuheishuModelImpl getInstance() {
         return new ContentFuheishuModelImpl();
     }
 
-    private ContentFuheishuModelImpl(){
+    /**
+     * 将构造函数私有化，这是单例模式的常见做法，目的是防止外部代码通过直接调用构造函数来创建多个实例，
+     * 从而保证只能通过getInstance方法获取唯一的实例。
+     */
+    private ContentFuheishuModelImpl() {
 
     }
+
+    /**
+     * 实现IWebContentModel接口中定义的analyBookcontent方法，用于解析书籍内容。
+     * 该方法接收两个参数，一个是包含书籍内容相关信息的原始字符串（通常是从网页获取的HTML内容等），
+     * 另一个是书籍内容对应的真实网址，用于提取关键的标识信息辅助解析。
+     *
+     * @param s      包含书籍内容相关信息的原始字符串，例如从网页请求获取到的HTML文本内容。
+     * @param realUrl 书籍内容对应的真实网址，用于提取必要的标识来定位具体的书籍内容元素等。
+     * @return 返回经过处理后的书籍内容字符串，处理过程包括去除多余空格、空白字符等格式化操作，使其格式更规整。
+     * @throws Exception 如果在解析过程中，例如使用Jsoup解析HTML文档出现错误，或者在字符串处理等环节出现异常情况时抛出。
+     */
     @Override
-    public String analyBookcontent(String s, String realUrl) throws Exception{
+    public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库的parse方法将传入的原始字符串（通常是HTML内容）解析为一个Document对象，
+        // 方便后续通过DOM操作来提取需要的书籍内容相关节点等信息。
         Document doc = Jsoup.parse(s);
-        String bookId = realUrl.substring(realUrl.indexOf("/",21)+1,realUrl.indexOf(".html"));
-        List<TextNode> contentTNs = doc.getElementById("content"+bookId).textNodes();
+
+        // 从realUrl中提取书籍的唯一标识（bookId），这里通过截取网址字符串的方式获取。
+        // 先找到从第21个字符之后（此处假设网址的特定结构，可能需要根据实际网址情况调整）出现的第一个'/'的位置，
+        // 然后从该位置的下一个字符开始，截取到'.html'之前的字符串作为bookId，用于后续定位书籍内容所在的HTML元素。
+        String bookId = realUrl.substring(realUrl.indexOf("/", 21) + 1, realUrl.indexOf(".html"));
+
+        // 通过获取到的bookId，在解析后的Document对象中查找id为"content" + bookId的元素，并获取其包含的所有文本节点（TextNode）列表。
+        // 这些文本节点预计包含了实际的书籍内容信息，后续将对这些节点进行处理以提取出完整的书籍内容。
+        List<TextNode> contentTNs = doc.getElementById("content" + bookId).textNodes();
+
+        // 创建一个StringBuilder对象，用于高效地拼接处理后的书籍内容字符串，避免频繁创建新的字符串对象带来的性能开销。
         StringBuilder stringBuilder = new StringBuilder();
-        for(int i=0;i<contentTNs.size();i++){
+
+        // 遍历获取到的所有文本节点（contentTNs），对每个节点进行处理。
+        for (int i = 0; i < contentTNs.size(); i++) {
+            // 获取当前文本节点的文本内容，并去除两端的空白字符（空格、制表符、换行等），得到较为纯净的文本内容。
             String temp = contentTNs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 进一步去除文本内容中的不间断空格（&nbsp;对应的Unicode字符，这里替换为空字符串）以及普通空格，
+            // 使文本内容的格式更加规整，去除多余的空白间隔。
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 如果处理后的文本内容长度大于0，说明该文本节点包含有效的内容信息，将其添加到stringBuilder中。
             if (temp.length() > 0) {
+                // 在每个有效文本内容前添加两个全角空格（\u3000）作为缩进格式，使书籍内容排版更美观，符合一般的阅读格式要求。
                 stringBuilder.append("\u3000\u3000" + temp);
+                // 如果当前不是最后一个文本节点，就在后面添加一个换行符（\r\n），实现不同文本节点内容之间的换行，
+                // 让书籍内容在显示时更有条理，便于阅读。
                 if (i < contentTNs.size() - 1) {
                     stringBuilder.append("\r\n");
                 }
             }
         }
+
+        // 将处理好的书籍内容字符串通过StringBuilder的toString方法转换为普通字符串，并返回该结果，
+        // 该字符串即为最终解析并格式化后的书籍内容，可以用于后续的展示、存储等操作。
         return stringBuilder.toString();
     }
 }

app/src/main/java/com/monke/monkeybook/model/impl/ContentKewaishuModelImpl.java

@@ -7,31 +7,79 @@ import org.jsoup.nodes.Document;
 import org.jsoup.nodes.TextNode;
 import java.util.List;
 
-public class ContentKewaishuModelImpl implements IWebContentModel{
+/**
+ * ContentKewaishuModelImpl类实现了IWebContentModel接口，主要用于对来自特定网站（由TAG标识为http://www.kewaishu.org）
+ * 的书籍内容进行解析处理，将网页中的相关文本内容提取并整理成合适的格式后返回。
+ */
+public class ContentKewaishuModelImpl implements IWebContentModel {
+
+    // 定义一个静态常量TAG，用于标识该内容解析模型所对应的网站地址，此处为http://www.kewaishu.org
     public static final String TAG = "http://www.kewaishu.org";
 
+    /**
+     * 获取ContentKewaishuModelImpl类的单例实例。
+     * 通过此方法来保证在整个程序运行期间，只会存在一个该类的实例，便于统一管理和使用其解析书籍内容的功能，
+     * 遵循单例模式的设计思路。
+     *
+     * @return 返回ContentKewaishuModelImpl类的唯一实例对象。
+     */
     public static ContentKewaishuModelImpl getInstance() {
         return new ContentKewaishuModelImpl();
     }
 
+    /**
+     * 将构造函数私有化，这是实现单例模式的常规做法，目的是防止外部代码随意通过构造函数创建多个该类的实例，
+     * 确保只有通过getInstance方法能获取到唯一的可用实例。
+     */
     private ContentKewaishuModelImpl() {
 
     }
+
+    /**
+     * 实现IWebContentModel接口中定义的analyBookcontent方法，用于解析书籍内容。
+     * 该方法接收两个参数，一个是包含网页内容（预计包含要解析的书籍内容）的原始字符串，另一个是对应的真实网址（可能用于辅助解析等，不过此处代码里暂时未体现出实际作用）。
+     *
+     * @param s      包含网页内容（大概率包含书籍相关文本等内容）的原始字符串，例如从网络请求获取到的HTML页面文本内容。
+     * @param realUrl 书籍内容对应的真实网址，当前代码里暂时未充分利用其进行更多特定的解析操作，但保留参数以便后续可能的扩展或调整。
+     * @return 返回经过处理后的书籍内容字符串，经过去除多余空格、空白字符等格式化操作，使其呈现更规整、更适合阅读的格式。
+     * @throws Exception 如果在使用Jsoup解析HTML文档，或者后续对文本节点进行操作等过程中出现错误情况时抛出异常，例如找不到预期的HTML元素等情况。
+     */
     @Override
     public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库的parse方法将传入的原始字符串（通常为HTML格式的网页内容）解析为一个Document对象，
+        // 这样后续就能基于DOM（文档对象模型）结构方便地查找和操作网页中的各种元素，提取我们需要的书籍内容相关部分。
         Document doc = Jsoup.parse(s);
+
+        // 首先通过id查找网页中id为"content"的元素，然后在这个元素内查找所有的<p>标签元素，
+        // 这里取第一个<p>标签元素（通过get(0)获取），并获取其包含的所有文本节点（TextNode）列表。
+        // 假设这里认为书籍内容是包含在这个特定的<p>标签元素中的文本节点集合里，通过这样的方式定位到需要解析的文本内容所在位置。
         List<TextNode> contentEs = doc.getElementById("content").getElementsByTag("p").get(0).textNodes();
+
+        // 创建一个StringBuilder对象，用于高效地拼接处理后的书籍内容字符串，相比于直接使用字符串相加操作，
+        // StringBuilder可以减少创建多个临时字符串对象带来的性能开销，更适合用于频繁的字符串拼接场景。
         StringBuilder content = new StringBuilder();
+
+        // 遍历获取到的所有文本节点（contentEs），对每个节点进行处理和拼接操作。
         for (int i = 0; i < contentEs.size(); i++) {
+            // 获取当前文本节点的文本内容，并去除两端的空白字符（如空格、制表符、换行等），得到相对纯净、无多余空白的文本内容。
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 进一步替换文本内容中的不间断空格（Unicode编码为“&nbsp;”对应的字符，这里替换为空字符串）以及普通空格，
+            // 以此进一步清理文本，让文本格式更加规整，避免出现多余的空白间隔影响阅读体验。
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 如果处理后的文本内容长度大于0，说明该文本节点包含有效的信息，将其添加到content这个StringBuilder对象中。
             if (temp.length() > 0) {
+                // 在每个有效文本内容前添加两个全角空格（\u3000）作为缩进格式，使最终呈现的书籍内容排版更美观，符合一般阅读时的段落格式要求。
                 content.append("\u3000\u3000" + temp);
+                // 如果当前不是最后一个文本节点，就在添加的文本内容后面添加一个换行符（\r\n），
+                // 实现不同文本节点内容之间的换行，使书籍内容在展示时更有条理，便于阅读和区分不同的段落内容。
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+
+        // 将经过处理和拼接后存储在StringBuilder中的书籍内容字符串转换为普通字符串，通过调用toString方法来实现，
+        // 并将最终整理好的书籍内容字符串返回，该字符串可用于后续的展示、存储等操作，比如在阅读软件中显示书籍文本内容等。
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/ContentLeduwoModelImpl.java

@@ -7,31 +7,78 @@ import org.jsoup.nodes.Document;
 import org.jsoup.nodes.TextNode;
 import java.util.List;
 
-public class ContentLeduwoModelImpl implements IWebContentModel{
+/**
+ * ContentLeduwoModelImpl类实现了IWebContentModel接口，其主要目的是针对来自特定网站（由TAG标识为http://leduwo.com）
+ * 的书籍内容进行解析处理，将网页中相应的文本内容提取并整理成合适的格式后返回，以便后续进一步使用（如展示、存储等）。
+ */
+public class ContentLeduwoModelImpl implements IWebContentModel {
+
+    // 定义一个静态常量TAG，用于标识该内容解析模型所对应的网站地址，这里对应的是http://leduwo.com，方便知晓该解析逻辑针对的具体站点。
     public static final String TAG = "http://leduwo.com";
 
+    /**
+     * 获取ContentLeduwoModelImpl类的单例实例。
+     * 采用单例模式可以确保在整个程序运行期间，只会创建一个该类的实例，便于统一管理和调用其解析书籍内容的功能，避免出现多个实例可能导致的混乱或资源浪费等情况。
+     *
+     * @return 返回ContentLeduwoModelImpl类的唯一实例对象。
+     */
     public static ContentLeduwoModelImpl getInstance() {
         return new ContentLeduwoModelImpl();
     }
 
+    /**
+     * 将构造函数私有化，这是实现单例模式的常见做法。通过这种方式，可以防止外部代码直接通过构造函数创建多个该类的实例，
+     * 强制只能通过getInstance方法来获取唯一的实例，以此保证单例的特性。
+     */
     private ContentLeduwoModelImpl() {
 
     }
+
+    /**
+     * 实现IWebContentModel接口中定义的analyBookcontent方法，该方法负责解析书籍内容。
+     * 它接收两个参数，其中参数's'表示包含网页内容（期望从中提取出书籍相关文本内容）的原始字符串，通常是从网络请求获取到的HTML页面内容等；
+     * 参数'realUrl'表示书籍内容对应的真实网址，虽然在当前代码中暂时没有看到对它有特别明确的利用逻辑，但保留它可以方便后续根据网址信息进行更复杂的解析扩展或调整。
+     *
+     * @param s 包含网页内容（大概率包含要解析的书籍文本等内容）的原始字符串，例如通过网络请求获取到的HTML格式的页面文本内容。
+     * @param realUrl 书籍内容对应的真实网址，当前代码里尚未深度运用其进行特定解析相关操作，不过具备后续拓展功能的可能性。
+     * @return 返回经过处理后的书籍内容字符串，这个字符串经过了去除多余空格、空白字符等格式化操作，使得呈现的格式更加规整、更符合阅读和展示的要求。
+     * @throws Exception 如果在使用Jsoup解析HTML文档，或者后续对文本节点进行操作等过程中出现异常情况（比如找不到预期的HTML元素等）时，会抛出异常。
+     */
     @Override
     public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库的parse方法将传入的原始字符串（一般是HTML格式的网页内容）解析为一个Document对象。
+        // 通过创建Document对象，后续就能基于DOM（文档对象模型）的结构方便地在网页内容中查找、定位和操作各种元素，从而提取出我们需要的书籍内容相关部分。
         Document doc = Jsoup.parse(s);
+
+        // 通过id查找网页中id为"content"的元素，并获取该元素包含的所有文本节点（TextNode）列表。
+        // 这里假设网页中书籍的具体内容是存放在id为"content"的这个元素内的文本节点当中，以此方式来定位要解析的文本内容所在位置。
         List<TextNode> contentEs = doc.getElementById("content").textNodes();
+
+        // 创建一个StringBuilder对象，用于高效地拼接处理后的书籍内容字符串。
+        // 相比于直接使用字符串相加操作，使用StringBuilder可以避免频繁创建新的字符串对象所带来的性能开销，特别适合在需要多次进行字符串拼接的场景下使用。
         StringBuilder content = new StringBuilder();
+
+        // 遍历获取到的所有文本节点（contentEs），对每个文本节点进行相应的处理和拼接操作。
         for (int i = 0; i < contentEs.size(); i++) {
+            // 获取当前文本节点的文本内容，并去除其两端的空白字符（例如空格、制表符、换行等），得到相对纯净、没有多余空白的文本内容。
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 进一步替换文本内容中的不间断空格（Unicode编码对应的“&nbsp;”字符，这里将其替换为空字符串）以及普通空格，
+            // 以此进一步清理文本内容，使得文本的格式更加规整，避免出现多余的空白间隔影响阅读体验和内容展示的美观性。
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 如果处理后的文本内容长度大于0，说明该文本节点包含有效的信息，此时将其添加到content这个StringBuilder对象中。
             if (temp.length() > 0) {
+                // 在每个有效文本内容前添加两个全角空格（\u3000）作为缩进格式，这样能让最终呈现的书籍内容排版更加美观，符合一般阅读时对于段落格式的要求。
                 content.append("\u3000\u3000" + temp);
+                // 如果当前文本节点不是最后一个文本节点，就在添加的文本内容后面添加一个换行符（\r\n），
+                // 以此实现不同文本节点内容之间的换行，使得书籍内容在展示时更有条理，方便阅读者区分不同的段落内容。
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+
+        // 将经过处理和拼接后存储在StringBuilder中的书籍内容字符串转换为普通字符串，通过调用toString方法来实现这一转换操作，
+        // 最后将整理好的书籍内容字符串返回，这个返回的字符串可以用于后续的各种操作，比如在阅读软件中展示书籍的文本内容、将内容存储到本地文件等。
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/ContentLewen8ModelImpl.java

@@ -7,31 +7,86 @@ import org.jsoup.nodes.Document;
 import org.jsoup.nodes.TextNode;
 import java.util.List;
 
-public class ContentLewen8ModelImpl implements IWebContentModel{
+/**
+ * ContentLewen8ModelImpl类实现了IWebContentModel接口，其主要作用是针对来自特定网站（由TAG标识为http://www.lewen8.com）
+ * 的书籍内容进行解析提取，并将提取到的内容整理成合适的格式后返回，以满足后续诸如展示给用户阅读、存储到本地等相关需求。
+ */
+public class ContentLewen8ModelImpl implements IWebContentModel {
+
+    // 定义一个静态常量TAG，用于明确标识该类所对应的网站地址，这里设定为http://www.lewen8.com，
+    // 方便在整个程序架构中知晓此解析逻辑具体是针对哪个站点的书籍内容进行操作的。
     public static final String TAG = "http://www.lewen8.com";
 
+    /**
+     * 获取ContentLewen8ModelImpl类的单例实例。
+     * 采用单例模式的目的在于确保整个程序运行期间，只会存在一个该类的实例，这样可以更方便地对解析书籍内容这一功能进行统一管理与调用，
+     * 避免因创建多个实例而可能引发的诸如资源浪费、逻辑混乱等问题。
+     *
+     * @return 返回ContentLewen8ModelImpl类的唯一实例对象。
+     */
     public static ContentLewen8ModelImpl getInstance() {
         return new ContentLewen8ModelImpl();
     }
 
+    /**
+     * 将构造函数私有化，这是实现单例模式的常规做法。通过把构造函数设为私有，外部代码就无法直接通过构造函数来创建该类的多个实例了，
+     * 从而保证了只能通过上面定义的getInstance方法获取唯一的实例，以此严格遵循单例模式的设计要求。
+     */
     private ContentLewen8ModelImpl() {
 
     }
+
+    /**
+     * 实现IWebContentModel接口中定义的analyBookcontent方法，该方法是整个类的核心功能所在，负责具体的书籍内容解析工作。
+     * 它接收两个参数，参数's'是包含网页内容（期望从中解析出书籍相关文本内容）的原始字符串，这个字符串通常是通过网络请求获取到的HTML格式的页面内容；
+     * 参数'realUrl'表示书籍内容对应的真实网址，虽然在当前代码中暂时未充分体现出对它的深度利用，但保留该参数可以为后续可能的功能扩展（比如依据网址中的特定信息来更精准地解析内容等）提供便利。
+     *
+     * @param s 包含网页内容（大概率包含要解析的书籍文本等内容）的原始字符串，例如从服务器端请求得到的HTML格式的网页文本，其中应包含了目标书籍的相关文本信息。
+     * @param realUrl 书籍内容对应的真实网址，当前代码里虽未展现出其关键作用，但有着后续进一步拓展解析逻辑、结合网址特征优化解析过程的潜在用途。
+     * @return 返回经过处理后的书籍内容字符串，此字符串经过了一系列的格式化操作，比如去除多余的空格、空白字符等，使其格式更加规整，更符合阅读和展示的常规要求。
+     * @throws Exception 如果在利用Jsoup库解析HTML文档时出现问题（例如传入的HTML字符串格式错误，无法正确解析等情况），
+     * 或者在后续对文本节点进行查找、操作等过程中发生错误（比如找不到预期的HTML元素对应的文本节点等），就会抛出异常。
+     */
     @Override
     public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库提供的parse方法，将传入的原始字符串（一般为HTML格式的网页内容）解析成一个Document对象。
+        // Document对象基于DOM（文档对象模型）的结构来表示HTML文档，通过它可以方便地按照HTML元素的层级关系、标签名称、属性等特征来查找、定位和操作网页中的各种元素，
+        // 进而帮助我们提取出期望的书籍内容相关部分。
         Document doc = Jsoup.parse(s);
+
+        // 通过调用Document对象的getElementById方法，依据元素的id属性查找网页中id为"content"的元素，
+        // 然后获取该元素所包含的所有文本节点（TextNode）列表。这里隐含的假设是网页中书籍的实际内容是存放在id为"content"这个元素内部的文本节点当中，
+        // 通过这种方式来确定要解析的文本内容在整个HTML文档中的具体位置。
         List<TextNode> contentEs = doc.getElementById("content").textNodes();
+
+        // 创建一个StringBuilder对象，用于高效地拼接整理后的书籍内容字符串。
+        // 相较于直接使用字符串相加操作，使用StringBuilder可以显著减少创建多个临时字符串对象所带来的性能开销，
+        // 尤其适用于像这种需要频繁进行字符串拼接的场景，能提升程序的运行效率。
         StringBuilder content = new StringBuilder();
+
+        // 开始遍历获取到的所有文本节点（contentEs），针对每个文本节点依次进行相应的处理和拼接操作，以构建最终的书籍内容字符串。
         for (int i = 0; i < contentEs.size(); i++) {
+            // 首先获取当前文本节点的文本内容，然后调用trim方法去除文本内容两端的空白字符（包括空格、制表符、换行等），
+            // 得到相对纯净、没有多余空白干扰的文本内容，以便后续更清晰地处理和展示。
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 进一步对处理后的文本内容进行清理，将其中的不间断空格（Unicode编码对应的“&nbsp;”字符，在HTML中常用于表示空格占位等情况）以及普通空格都替换为空字符串，
+            // 这样可以让文本的格式更加规整，避免因多余的空白间隔而影响阅读体验以及内容展示的美观性。
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 判断经过上述处理后的文本内容长度是否大于0，如果大于0，则说明该文本节点包含有实际有效的信息，需要将其添加到content这个StringBuilder对象中。
             if (temp.length() > 0) {
+                // 在每个有效的文本内容前面添加两个全角空格（\u3000）作为缩进格式，使得最终呈现出来的书籍内容在排版上更加美观，
+                // 更符合一般阅读时对于段落格式的常规要求，便于读者区分不同的内容段落。
                 content.append("\u3000\u3000" + temp);
+                // 如果当前文本节点不是遍历过程中的最后一个文本节点，那么就在添加的文本内容后面添加一个换行符（\r\n），
+                // 以此实现不同文本节点内容之间的换行，让书籍内容在展示时更有条理，方便读者清晰地阅读和理解。
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+
+        // 最后，通过调用StringBuilder对象的toString方法，将经过一系列处理和拼接后存储在其中的书籍内容字符串转换为普通字符串格式，
+        // 并将这个整理好的书籍内容字符串返回，该返回值可以用于后续的各种操作，比如在阅读应用程序中展示给用户查看、保存到本地文件系统等。
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/ContentPbtxtModelImpl.java

@@ -7,32 +7,90 @@ import org.jsoup.nodes.Document;
 import org.jsoup.nodes.TextNode;
 import java.util.List;
 
-public class ContentPbtxtModelImpl implements IWebContentModel{
+/**
+ * ContentPbtxtModelImpl类实现了IWebContentModel接口，其主要用途是针对来自特定网站（由TAG标识为http://www.pbtxt.com）
+ * 的书籍内容进行解析处理，提取出相应的文本内容，并对文本做格式整理后返回，方便后续在程序中进行展示、存储等相关操作。
+ */
+public class ContentPbtxtModelImpl implements IWebContentModel {
+
+    // 定义一个静态常量TAG，用于标识该内容解析模型所对应的网站地址，此处明确为http://www.pbtxt.com，
+    // 便于在整个程序体系里知晓此解析逻辑是专门针对该站点的书籍内容而设计的。
     public static final String TAG = "http://www.pbtxt.com";
 
-    public static ContentPbtxtModelImpl getInstance(){
+    /**
+     * 获取ContentPbtxtModelImpl类的单例实例。
+     * 通过采用单例模式，确保在整个程序运行期间只有一个该类的实例存在，这样可以更有序地对解析该网站书籍内容这一功能进行统一管理与调用，
+     * 避免因创建多个实例可能导致的资源管理混乱、逻辑不一致等问题。
+     *
+     * @return 返回ContentPbtxtModelImpl类的唯一实例对象。
+     */
+    public static ContentPbtxtModelImpl getInstance() {
         return new ContentPbtxtModelImpl();
     }
 
-    private ContentPbtxtModelImpl(){
+    /**
+     * 将构造函数私有化，这是实现单例模式的常规手段。把构造函数设为私有后，外部代码就无法直接通过构造函数来随意创建该类的多个实例了，
+     * 从而强制只能通过上面定义的getInstance方法来获取唯一的实例，以此保证单例模式的正确实现。
+     */
+    private ContentPbtxtModelImpl() {
 
     }
+
+    /**
+     * 实现IWebContentModel接口中定义的analyBookcontent方法，此方法承担着解析书籍内容的核心功能。
+     * 它接收两个参数，参数's'是包含网页内容的原始字符串，通常是通过网络请求获取到的HTML格式的网页文本；
+     * 参数'realUrl'表示书籍内容对应的真实网址，在本方法中会利用该网址提取关键信息来辅助定位和解析书籍内容所在的具体HTML元素。
+     *
+     * @param s 包含网页内容的原始字符串，例如从网站服务器获取到的HTML页面文本，其中应包含了目标书籍的相关文本信息。
+     * @param realUrl 书籍内容对应的真实网址，在此代码中会基于该网址的特定结构从中提取出用于标识书籍的关键信息，进而准确找到书籍内容对应的HTML元素。
+     * @return 返回经过处理后的书籍内容字符串，这个字符串经过了去除多余空格、空白字符等格式化操作，使其格式更加规整，更符合阅读和展示的常规要求。
+     * @throws Exception 如果在使用Jsoup解析HTML文档过程中出现问题（比如传入的HTML字符串格式不符合要求，导致无法正确解析等情况），
+     * 或者在后续依据网址提取标识信息、查找文本节点以及对文本进行操作等环节出现错误（例如找不到预期的HTML元素对应的文本节点等），就会抛出异常。
+     */
     @Override
-    public String analyBookcontent(String s, String realUrl) throws Exception{
+    public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库提供的parse方法，将传入的原始字符串（一般是HTML格式的网页内容）解析为一个Document对象。
+        // Document对象基于DOM（文档对象模型）结构来表示HTML文档，通过它能够按照HTML元素的标签、属性、层级关系等特征方便地查找、定位和操作网页中的各种元素，
+        // 从而帮助我们准确地提取出与书籍内容相关的部分。
         Document doc = Jsoup.parse(s);
-        String bookId = realUrl.substring(realUrl.indexOf("/",21)+1,realUrl.indexOf(".html"));
-        List<TextNode> contentTNs = doc.getElementById("content"+bookId).textNodes();
+
+        // 从'realUrl'中提取书籍的唯一标识（bookId），此处是通过截取网址字符串的方式来获取。
+        // 先找到从第21个字符之后（这里假设网址具有特定的结构，实际应用中可能需要根据具体网址的格式特点来调整）出现的第一个'/'的位置，
+        // 然后从该位置的下一个字符开始，截取到'.html'之前的字符串作为bookId，后续将利用这个bookId来定位书籍内容所在的具体HTML元素。
+        String bookId = realUrl.substring(realUrl.indexOf("/", 21) + 1, realUrl.indexOf(".html"));
+
+        // 通过获取到的bookId，在解析后的Document对象中查找id为"content" + bookId的元素，并获取该元素包含的所有文本节点（TextNode）列表。
+        // 这里的假设是书籍内容存放在这个特定id的元素内的文本节点当中，通过这样的操作来精准定位到需要解析的书籍内容所在位置。
+        List<TextNode> contentTNs = doc.getElementById("content" + bookId).textNodes();
+
+        // 创建一个StringBuilder对象，用于高效地拼接整理后的书籍内容字符串。
+        // 相比于直接使用字符串相加操作，使用StringBuilder可以避免频繁创建新的字符串对象所带来的性能开销，
+        // 特别适合在需要多次进行字符串拼接的场景下使用，有助于提升程序运行效率。
         StringBuilder stringBuilder = new StringBuilder();
-        for(int i=0;i<contentTNs.size();i++){
+
+        // 开始遍历获取到的所有文本节点（contentTNs），针对每个文本节点进行相应的处理和拼接操作，以构建最终的书籍内容字符串。
+        for (int i = 0; i < contentTNs.size(); i++) {
+            // 获取当前文本节点的文本内容，然后调用trim方法去除文本内容两端的空白字符（包含空格、制表符、换行等），
+            // 得到相对纯净、没有多余空白干扰的文本内容，方便后续进一步处理和展示。
             String temp = contentTNs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 进一步对处理后的文本内容进行清理，将其中的不间断空格（Unicode编码对应的“&nbsp;”字符，常用于HTML中表示空格占位等情况）以及普通空格都替换为空字符串，
+            // 这样可以让文本的格式更加规整，避免因多余的空白间隔而影响阅读体验以及内容展示的美观性。
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 判断经过上述处理后的文本内容长度是否大于0，如果大于0，则说明该文本节点包含有实际有效的信息，需要将其添加到stringBuilder这个StringBuilder对象中。
             if (temp.length() > 0) {
+                // 在每个有效的文本内容前面添加两个全角空格（\u3000）作为缩进格式，使得最终呈现出来的书籍内容在排版上更加美观，
+                // 更符合一般阅读时对于段落格式的要求，便于读者区分不同的内容段落。
                 stringBuilder.append("\u3000\u3000" + temp);
+                // 如果当前文本节点不是遍历过程中的最后一个文本节点，那么就在添加的文本内容后面添加一个换行符（\r\n），
+                // 以此实现不同文本节点内容之间的换行，让书籍内容在展示时更有条理，方便读者清晰地阅读和理解。
                 if (i < contentTNs.size() - 1) {
                     stringBuilder.append("\r\n");
                 }
             }
         }
+
+        // 最后，通过调用StringBuilder对象的toString方法，将经过一系列处理和拼接后存储在其中的书籍内容字符串转换为普通字符串格式，
+        // 并将这个整理好的书籍内容字符串返回，该返回值可以用于后续的各种操作，比如在阅读应用程序中展示给用户查看、保存到本地文件等。
         return stringBuilder.toString();
     }
 }

app/src/main/java/com/monke/monkeybook/model/impl/ContentPpxsModelImpl.java

@@ -7,31 +7,86 @@ import org.jsoup.nodes.Document;
 import org.jsoup.nodes.TextNode;
 import java.util.List;
 
-public class ContentPpxsModelImpl implements IWebContentModel{
+/**
+ * ContentPpxsModelImpl类实现了IWebContentModel接口，主要用于解析来自特定网站（由TAG标识为http://www.ppxs.net）
+ * 的书籍内容相关信息，对网页中的文本内容进行提取、整理后返回，以便后续进行展示、存储等操作，满足应用程序中关于书籍阅读相关的需求。
+ */
+public class ContentPpxsModelImpl implements IWebContentModel {
+
+    // 定义一个静态常量TAG，用于标识该内容解析模型所对应的网站地址，这里明确为http://www.ppxs.net，
+    // 使得在整个程序架构中能够清晰知晓此解析逻辑是专门针对该站点的书籍内容而设置的。
     public static final String TAG = "http://www.ppxs.net";
 
+    /**
+     * 获取ContentPpxsModelImpl类的单例实例。
+     * 通过采用单例模式，保证在整个程序运行期间仅有一个该类的实例存在，方便对解析该网站书籍内容这一功能进行统一管理和调用，
+     * 避免因创建多个实例而可能引发的诸如资源占用混乱、逻辑冲突等问题。
+     *
+     * @return 返回ContentPpxsModelImpl类的唯一实例对象。
+     */
     public static ContentPpxsModelImpl getInstance() {
         return new ContentPpxsModelImpl();
     }
 
+    /**
+     * 将构造函数私有化，这是实现单例模式的常见做法。将构造函数设为私有后，外部代码就无法直接通过构造函数创建该类的多个实例了，
+     * 从而确保只能通过上面定义的getInstance方法来获取唯一的实例，以此维持单例模式的特性。
+     */
     private ContentPpxsModelImpl() {
 
     }
+
+    /**
+     * 实现IWebContentModel接口中定义的analyBookcontent方法，此方法是整个类的核心功能所在，负责解析书籍内容。
+     * 它接收两个参数，参数's'是包含网页内容（期望从中提取出书籍相关文本内容）的原始字符串，一般是通过网络请求获取到的HTML格式的网页内容；
+     * 参数'realUrl'表示书籍内容对应的真实网址，不过在当前代码实现中，暂时未体现出对该网址的深度利用，但其保留着用于后续可能的功能扩展的可能性。
+     *
+     * @param s 包含网页内容（大概率包含要解析的书籍文本等内容）的原始字符串，例如从网站服务器获取的HTML页面文本，其中包含了目标书籍的相关文本信息。
+     * @param realUrl 书籍内容对应的真实网址，当前代码里虽未充分借助其进行关键操作，但可作为后续拓展解析逻辑（比如依据网址特征更精准地定位内容等）的基础。
+     * @return 返回经过处理后的书籍内容字符串，该字符串经过了去除多余空格、空白字符等格式化操作，使得其格式更加规整，更符合阅读和展示的常规要求。
+     * @throws Exception 如果在使用Jsoup解析HTML文档时出现问题（比如传入的HTML字符串格式不正确，无法正确解析等情况），
+     * 或者在后续查找文本节点、对文本内容进行操作等环节出现错误（例如找不到预期的HTML元素对应的文本节点等），则会抛出异常。
+     */
     @Override
     public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库提供的parse方法，将传入的原始字符串（通常为HTML格式的网页内容）解析成一个Document对象。
+        // Document对象基于DOM（文档对象模型）来表示HTML文档，通过它可以依据HTML元素的各种属性（如id、class等）、标签名称以及层级关系等，
+        // 方便地查找、定位并操作网页中的各种元素，进而帮助我们准确地提取出与书籍内容相关的文本部分。
         Document doc = Jsoup.parse(s);
+
+        // 通过调用Document对象的getElementById方法，依据元素的id属性查找网页中id为"booktext"的元素，
+        // 然后获取该元素包含的所有文本节点（TextNode）列表。这里假设书籍内容存放在id为"booktext"的这个元素内的文本节点当中，
+        // 通过这种方式来定位要解析的书籍内容在整个HTML文档中的具体位置。
         List<TextNode> contentEs = doc.getElementById("booktext").textNodes();
+
+        // 创建一个StringBuilder对象，用于高效地拼接整理后的书籍内容字符串。
+        // 与直接使用字符串相加操作相比，使用StringBuilder可以避免频繁创建新的字符串对象所带来的性能开销，
+        // 尤其适用于像这样需要多次进行字符串拼接的场景，有助于提高程序的运行效率。
         StringBuilder content = new StringBuilder();
+
+        // 开始遍历获取到的所有文本节点（contentEs），针对每个文本节点依次进行相应的处理和拼接操作，以构建最终的书籍内容字符串。
         for (int i = 0; i < contentEs.size(); i++) {
+            // 获取当前文本节点的文本内容，然后调用trim方法去除文本内容两端的空白字符（包含空格、制表符、换行等），
+            // 得到相对纯净、没有多余空白干扰的文本内容，以便后续更好地进行处理和展示。
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 进一步对处理后的文本内容进行清理，将其中的不间断空格（Unicode编码对应的“&nbsp;”字符，常用于HTML中表示空格占位等情况）以及普通空格都替换为空字符串，
+            // 这样可以让文本的格式更加规整，避免因多余的空白间隔而影响阅读体验以及内容展示的美观性。
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 判断经过上述处理后的文本内容长度是否大于0，如果大于0，则说明该文本节点包含有实际有效的信息，需要将其添加到content这个StringBuilder对象中。
             if (temp.length() > 0) {
+                // 在每个有效的文本内容前面添加两个全角空格（\u3000）作为缩进格式，使最终呈现的书籍内容在排版上更加美观，
+                // 更符合一般阅读时对于段落格式的要求，便于读者区分不同的内容段落。
                 content.append("\u3000\u3000" + temp);
+                // 如果当前文本节点不是遍历过程中的最后一个文本节点，那么就在添加的文本内容后面添加一个换行符（\r\n），
+                // 以此实现不同文本节点内容之间的换行，让书籍内容在展示时更有条理，方便读者清晰地阅读和理解。
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+
+        // 最后，通过调用StringBuilder对象的toString方法，将经过一系列处理和拼接后存储在其中的书籍内容字符串转换为普通字符串格式，
+        // 并将这个整理好的书籍内容字符串返回，该返回值可以用于后续的各种操作，比如在阅读应用程序中展示给用户查看、保存到本地文件等。
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/ContentQulaModelImpl.java

@@ -7,31 +7,86 @@ import org.jsoup.nodes.Document;
 import org.jsoup.nodes.TextNode;
 import java.util.List;
 
-public class ContentQulaModelImpl implements IWebContentModel{
+/**
+ * ContentQulaModelImpl类实现了IWebContentModel接口，其主要作用是针对来自特定网站（由TAG标识为http://www.qu.la）
+ * 的书籍内容进行解析，将网页中的相关文本内容提取出来，并经过一定的格式整理后返回，以便后续在相关应用（比如阅读软件等）中进行展示、存储等操作。
+ */
+public class ContentQulaModelImpl implements IWebContentModel {
+
+    // 定义一个静态常量TAG，用于标识该类所对应的网站地址，这里明确指定为http://www.qu.la，
+    // 这样在整个程序架构中就能清楚地知道这个解析类是针对该网站的书籍内容进行处理的。
     public static final String TAG = "http://www.qu.la";
 
+    /**
+     * 获取ContentQulaModelImpl类的单例实例。
+     * 采用单例模式可以确保在整个程序运行期间，只会创建一个该类的实例，便于统一管理和调用解析书籍内容的功能，
+     * 避免因创建多个实例而可能引发的诸如资源浪费、逻辑不一致等问题。
+     *
+     * @return 返回ContentQulaModelImpl类的唯一实例对象。
+     */
     public static ContentQulaModelImpl getInstance() {
         return new ContentQulaModelImpl();
     }
 
+    /**
+     * 将构造函数私有化，这是实现单例模式的常规做法。私有化构造函数后，外部代码就无法直接通过构造函数来创建该类的多个实例了，
+     * 只能通过上面定义的getInstance方法来获取唯一的实例，以此保证单例模式的正确实现。
+     */
     private ContentQulaModelImpl() {
 
     }
+
+    /**
+     * 实现IWebContentModel接口中定义的analyBookcontent方法，该方法是这个类的核心功能所在，负责具体解析书籍内容的操作。
+     * 它接收两个参数，参数's'是包含网页内容（期望从中解析出书籍相关文本内容）的原始字符串，通常是通过网络请求获取到的HTML格式的网页文本；
+     * 参数'realUrl'表示书籍内容对应的真实网址，不过在当前代码中暂时没有看到对这个网址进行特别复杂的利用，但其保留着用于后续可能的功能扩展（比如依据网址特征更精准地解析内容等）的可能性。
+     *
+     * @param s 包含网页内容（大概率包含要解析的书籍文本等内容）的原始字符串，例如从网站服务器获取的HTML页面文本，其中包含了目标书籍的相关文本信息。
+     * @param realUrl 书籍内容对应的真实网址，当前虽未深度用于解析逻辑，但可作为后续优化解析过程、结合网址信息进行更精细处理的基础。
+     * @return 返回经过处理后的书籍内容字符串，这个字符串经过了去除多余空格、空白字符等格式化操作，使其格式更加规整，更符合阅读和展示的要求。
+     * @throws Exception 如果在使用Jsoup解析HTML文档时出现问题
+     * 或者在后续查找文本节点、对文本进行操作等环节出现错误（比如找不到预期的HTML元素对应的文本节点等），就会抛出异常。
+     */
     @Override
     public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库提供的parse方法，将传入的原始字符串（一般为HTML格式的网页内容）解析成一个Document对象。
+        // Document对象基于DOM（文档对象模型）结构来表示HTML文档，通过它可以按照HTML元素的标签、属性、层级关系等特征，方便地查找、定位和操作网页中的各种元素，
+        // 从而帮助我们准确地提取出与书籍内容相关的部分。
         Document doc = Jsoup.parse(s);
+
+        // 通过调用Document对象的getElementById方法，依据元素的id属性查找网页中id为"content"的元素，
+        // 然后获取该元素包含的所有文本节点（TextNode）列表。这里假设网页中书籍的实际内容是存放在id为"content"这个元素内的文本节点当中，
+        // 通过这种方式来定位要解析的文本内容在整个HTML文档中的具体位置。
         List<TextNode> contentEs = doc.getElementById("content").textNodes();
+
+        // 创建一个StringBuilder对象，用于高效地拼接整理后的书籍内容字符串。
+        // 相较于直接使用字符串相加操作，使用StringBuilder可以避免频繁创建新的字符串对象所带来的性能开销，
+        // 特别适合在像这样需要多次进行字符串拼接的场景下使用，有助于提升程序运行效率。
         StringBuilder content = new StringBuilder();
+
+        // 开始遍历获取到的所有文本节点（contentEs），针对每个文本节点依次进行相应的处理和拼接操作，以构建最终的书籍内容字符串。
         for (int i = 0; i < contentEs.size(); i++) {
+            // 获取当前文本节点的文本内容，然后调用trim方法去除文本内容两端的空白字符（包含空格、制表符、换行等），
+            // 得到相对纯净、没有多余空白干扰的文本内容，以便后续更好地进行处理和展示。
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 进一步对处理后的文本内容进行清理，将其中的不间断空格（Unicode编码对应的“&nbsp;”字符，常用于HTML中表示空格占位等情况）以及普通空格都替换为空字符串，
+            // 这样可以让文本的格式更加规整，避免因多余的空白间隔而影响阅读体验以及内容展示的美观性。
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 判断经过上述处理后的文本内容长度是否大于0，如果大于0，则说明该文本节点包含有实际有效的信息，需要将其添加到content这个StringBuilder对象中。
             if (temp.length() > 0) {
+                // 在每个有效的文本内容前面添加两个全角空格（\u3000）作为缩进格式，使得最终呈现出来的书籍内容在排版上更加美观，
+                // 更符合一般阅读时对于段落格式的要求，便于读者区分不同的内容段落。
                 content.append("\u3000\u3000" + temp);
+                // 如果当前文本节点不是遍历过程中的最后一个文本节点，那么就在添加的文本内容后面添加一个换行符（\r\n），
+                // 以此实现不同文本节点内容之间的换行，让书籍内容在展示时更有条理，方便读者清晰地阅读和理解。
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+
+        // 最后，通过调用StringBuilder对象的toString方法，将经过一系列处理和拼接后存储在其中的书籍内容字符串转换为普通字符串格式，
+        // 并将这个整理好的书籍内容字符串返回，该返回值可以用于后续的各种操作，比如在阅读应用程序中展示给用户查看、保存到本地文件等。
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/ContentQzreadModelImpl.java

@@ -7,31 +7,88 @@ import org.jsoup.nodes.Document;
 import org.jsoup.nodes.TextNode;
 import java.util.List;
 
-public class ContentQzreadModelImpl implements IWebContentModel{
+/**
+ * ContentQzreadModelImpl类实现了IWebContentModel接口，其主要功能是针对来自特定网站（由TAG标识为http://www.qzread.com）
+ * 的书籍内容进行解析处理，从网页的HTML结构中提取出相应文本内容，并经过格式整理后返回，以满足后续诸如在阅读应用中展示、存储等相关需求。
+ */
+public class ContentQzreadModelImpl implements IWebContentModel {
+
+    // 定义一个静态常量TAG，用于明确标识该类所对应的网站地址，此处设定为http://www.qzread.com，
+    // 这样在整个程序架构中就能清晰知晓此解析逻辑是专门针对该站点的书籍内容进行操作的。
     public static final String TAG = "http://www.qzread.com";
 
+    /**
+     * 获取ContentQzreadModelImpl类的单例实例。
+     * 通过采用单例模式，确保在整个程序运行期间只有一个该类的实例存在，便于对解析该网站书籍内容这一功能进行统一管理与调用，
+     * 避免因创建多个实例而可能引发的资源管理混乱、逻辑不一致等问题。
+     *
+     * @return 返回ContentQzreadModelImpl类的唯一实例对象。
+     */
     public static ContentQzreadModelImpl getInstance() {
         return new ContentQzreadModelImpl();
     }
 
+    /**
+     * 将构造函数私有化，这是实现单例模式的常规做法。把构造函数设为私有后，外部代码就无法直接通过构造函数来创建该类的多个实例了，
+     * 从而强制只能通过上面定义的getInstance方法获取唯一的实例，以此保证单例模式的正确实现。
+     */
     private ContentQzreadModelImpl() {
 
     }
+
+    /**
+     * 实现IWebContentModel接口中定义的analyBookcontent方法，此方法是整个类的核心功能所在，负责具体的书籍内容解析工作。
+     * 它接收两个参数，参数's'是包含网页内容（期望从中解析出书籍相关文本内容）的原始字符串，通常是通过网络请求获取到的HTML格式的网页文本；
+     * 参数'realUrl'表示书籍内容对应的真实网址，虽然在当前代码中暂时未充分体现出对它的深度利用，但保留该参数可为后续可能的功能扩展（比如依据网址中的特定信息来更精准地解析内容等）提供便利。
+     *
+     * @param s 包含网页内容（大概率包含要解析的书籍文本等内容）的原始字符串，例如从网站服务器获取的HTML页面文本，其中应包含了目标书籍的相关文本信息。
+     * @param realUrl 书籍内容对应的真实网址，当前代码里虽未展现出其关键作用，但有着后续进一步拓展解析逻辑、结合网址特征优化解析过程的潜在用途。
+     * @return 返回经过处理后的书籍内容字符串，此字符串经过了一系列的格式化操作，比如去除多余的空格、空白字符等，使其格式更加规整，更符合阅读和展示的常规要求。
+     * @throws Exception 如果在利用Jsoup库解析HTML文档时出现问题（例如传入的HTML字符串格式错误，无法正确解析等情况），
+     * 或者在后续对文本节点进行查找、操作等过程中发生错误（比如找不到预期的HTML元素对应的文本节点等），就会抛出异常。
+     */
     @Override
     public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库提供的parse方法，将传入的原始字符串（一般为HTML格式的网页内容）解析成一个Document对象。
+        // Document对象基于DOM（文档对象模型）的结构来表示HTML文档，通过它可以按照HTML元素的层级关系、标签名称、属性等特征来查找、定位和操作网页中的各种元素，
+        // 进而帮助我们提取出期望的书籍内容相关部分。
         Document doc = Jsoup.parse(s);
+
+        // 首先通过getElementsByClass方法，依据元素的class属性查找网页中class为"txt"的所有元素，
+        // 然后取其中的第一个元素（通过get(0)获取），这是因为假设符合该class的元素中第一个包含了我们要解析的书籍内容相关结构。
+        // 在这个获取到的元素基础上，再通过getElementsByTag方法，依据标签名称查找其中的第一个<p>标签元素（同样通过get(0)获取），
+        // 这里又假设书籍内容在这个特定的<p>标签元素内部。最后获取该<p>标签元素所包含的所有文本节点（TextNode）列表，
+        // 通过这样层层查找的方式来确定要解析的文本内容在整个HTML文档中的具体位置。
         List<TextNode> contentEs = doc.getElementsByClass("txt").get(0).getElementsByTag("p").get(0).textNodes();
+
+        // 创建一个StringBuilder对象，用于高效地拼接整理后的书籍内容字符串。
+        // 相较于直接使用字符串相加操作，使用StringBuilder可以显著减少创建多个临时字符串对象所带来的性能开销，
+        // 尤其适用于像这种需要频繁进行字符串拼接的场景，能提升程序的运行效率。
         StringBuilder content = new StringBuilder();
+
+        // 开始遍历获取到的所有文本节点（contentEs），针对每个文本节点依次进行相应的处理和拼接操作，以构建最终的书籍内容字符串。
         for (int i = 0; i < contentEs.size(); i++) {
+            // 首先获取当前文本节点的文本内容，然后调用trim方法去除文本内容两端的空白字符（包括空格、制表符、换行等），
+            // 得到相对纯净、没有多余空白干扰的文本内容，以便后续更清晰地处理和展示。
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 进一步对处理后的文本内容进行清理，将其中的不间断空格（Unicode编码对应的“&nbsp;”字符，在HTML中常用于表示空格占位等情况）以及普通空格都替换为空字符串，
+            // 这样可以让文本的格式更加规整，避免因多余的空白间隔而影响阅读体验以及内容展示的美观性。
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 判断经过上述处理后的文本内容长度是否大于0，如果大于0，则说明该文本节点包含有实际有效的信息，需要将其添加到content这个StringBuilder对象中。
             if (temp.length() > 0) {
+                // 在每个有效的文本内容前面添加两个全角空格（\u3000）作为缩进格式，使得最终呈现出来的书籍内容在排版上更加美观，
+                // 更符合一般阅读时对于段落格式的要求，便于读者区分不同的内容段落。
                 content.append("\u3000\u3000" + temp);
+                // 如果当前文本节点不是遍历过程中的最后一个文本节点，那么就在添加的文本内容后面添加一个换行符（\r\n），
+                // 以此实现不同文本节点内容之间的换行，让书籍内容在展示时更有条理，方便读者清晰地阅读和理解。
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+
+        // 最后，通过调用StringBuilder对象的toString方法，将经过一系列处理和拼接后存储在其中的书籍内容字符串转换为普通字符串格式，
+        // 并将这个整理好的书籍内容字符串返回，该返回值可以用于后续的各种操作，比如在阅读应用程序中展示给用户查看、保存到本地文件等。
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/ContentRanwenaModelImpl.java

@@ -7,31 +7,86 @@ import org.jsoup.nodes.Document;
 import org.jsoup.nodes.TextNode;
 import java.util.List;
 
-public class ContentRanwenaModelImpl implements IWebContentModel{
+/**
+ * ContentRanwenaModelImpl类实现了IWebContentModel接口，其主要作用是针对来自特定网站（由TAG标识为http://www.ranwena.com）
+ * 的书籍内容进行解析提取、格式整理，进而将处理后的内容以合适的字符串形式返回，以便后续用于展示、存储等相关操作，满足阅读相关的业务需求。
+ */
+public class ContentRanwenaModelImpl implements IWebContentModel {
+
+    // 定义一个静态常量TAG，用于明确标识该内容解析类对应的网站地址，这里设定为http://www.ranwena.com，
+    // 使得在整个程序架构中能够清楚知晓此解析逻辑是专门针对该站点的书籍内容而设计的。
     public static final String TAG = "http://www.ranwena.com";
 
+    /**
+     * 获取ContentRanwenaModelImpl类的单例实例。
+     * 采用单例模式可以确保在整个程序运行期间，只会存在一个该类的实例，便于统一管理和调用其解析书籍内容的功能，
+     * 避免因创建多个实例而可能导致的诸如资源浪费、逻辑混乱等问题。
+     *
+     * @return 返回ContentRanwenaModelImpl类的唯一实例对象。
+     */
     public static ContentRanwenaModelImpl getInstance() {
         return new ContentRanwenaModelImpl();
     }
 
+    /**
+     * 将构造函数私有化，这是实现单例模式的常规做法。通过私有化构造函数，外部代码无法直接通过构造函数来创建该类的多个实例，
+     * 只能按照规定通过getInstance方法获取唯一的实例，以此保证单例模式的正确实现，维持代码逻辑的一致性和资源管理的有序性。
+     */
     private ContentRanwenaModelImpl() {
 
     }
+
+    /**
+     * 实现IWebContentModel接口中定义的analyBookcontent方法，该方法是整个类的核心功能部分，负责具体的书籍内容解析工作。
+     * 它接收两个参数，参数's'表示包含网页内容（期望从中提取出书籍相关文本内容）的原始字符串，通常是通过网络请求获取到的HTML格式的网页文本；
+     * 参数'realUrl'表示书籍内容对应的真实网址，在当前代码实现中暂时未充分体现对其深度利用，但保留该参数可为后续可能的功能扩展（例如依据网址中的特定标识更精准地定位书籍内容等）提供基础。
+     *
+     * @param s 包含网页内容（大概率包含要解析的书籍文本等内容）的原始字符串，例如从网站服务器获取的HTML页面文本，其中包含了目标书籍的相关文本信息。
+     * @param realUrl 书籍内容对应的真实网址，当前代码里虽未深度借助其进行关键操作，但具备后续拓展解析逻辑、结合网址特征优化解析流程的潜在用途。
+     * @return 返回经过处理后的书籍内容字符串，此字符串经过了去除多余空格、空白字符等格式化操作，使其格式更加规整，更符合阅读和展示的常规要求。
+     * @throws Exception 如果在使用Jsoup解析HTML文档过程中出现问题（比如传入的HTML字符串格式不符合要求，导致无法正确解析等情况），
+     * 或者在后续依据id查找元素、获取文本节点以及对文本内容进行操作等环节出现错误（例如找不到预期的HTML元素对应的文本节点等），则会抛出异常。
+     */
     @Override
     public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库提供的parse方法，将传入的原始字符串（一般为HTML格式的网页内容）解析为一个Document对象。
+        // Document对象基于DOM（文档对象模型）结构来表示HTML文档，借助它能够按照HTML元素的各种属性（如id、class等）、标签名称以及元素间的层级关系等，
+        // 方便地查找、定位并操作网页中的各种元素，从而准确提取出与书籍内容相关的文本部分。
         Document doc = Jsoup.parse(s);
+
+        // 通过调用Document对象的getElementById方法，依据元素的id属性查找网页中id为"content"的元素，
+        // 然后获取该元素所包含的所有文本节点（TextNode）列表。这里假设书籍内容存放在id为"content"这个元素内的文本节点当中，
+        // 通过这种方式来定位要解析的书籍内容在整个HTML文档中的具体位置。
         List<TextNode> contentEs = doc.getElementById("content").textNodes();
+
+        // 创建一个StringBuilder对象，用于高效地拼接整理后的书籍内容字符串。
+        // 相比于直接使用字符串相加操作，使用StringBuilder能够避免频繁创建新的字符串对象所带来的性能开销，
+        // 特别适用于像这样需要多次进行字符串拼接的场景，有助于提高程序的运行效率。
         StringBuilder content = new StringBuilder();
+
+        // 开始遍历获取到的所有文本节点（contentEs），针对每个文本节点依次进行相应的处理和拼接操作，以构建最终的书籍内容字符串。
         for (int i = 0; i < contentEs.size(); i++) {
+            // 获取当前文本节点的文本内容，然后调用trim方法去除文本内容两端的空白字符（包含空格、制表符、换行等），
+            // 得到相对纯净、没有多余空白干扰的文本内容，方便后续更好地进行处理和展示。
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 进一步对处理后的文本内容进行清理，将其中的不间断空格（Unicode编码对应的“&nbsp;”字符，常用于HTML中表示空格占位等情况）以及普通空格都替换为空字符串，
+            // 这样可以让文本的格式更加规整，避免因多余的空白间隔而影响阅读体验以及内容展示的美观性。
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 判断经过上述处理后的文本内容长度是否大于0，如果大于0，则说明该文本节点包含有实际有效的信息，需要将其添加到content这个StringBuilder对象中。
             if (temp.length() > 0) {
+                // 在每个有效的文本内容前面添加两个全角空格（\u3000）作为缩进格式，使最终呈现的书籍内容在排版上更加美观，
+                // 更符合一般阅读时对于段落格式的要求，便于读者区分不同的内容段落。
                 content.append("\u3000\u3000" + temp);
+                // 如果当前文本节点不是遍历过程中的最后一个文本节点，那么就在添加的文本内容后面添加一个换行符（\r\n），
+                // 以此实现不同文本节点内容之间的换行，让书籍内容在展示时更有条理，方便读者清晰地阅读和理解。
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+
+        // 最后，通过调用StringBuilder对象的toString方法，将经过一系列处理和拼接后存储在其中的书籍内容字符串转换为普通字符串格式，
+        // 并将这个整理好的书籍内容字符串返回，该返回值可以用于后续的各种操作，比如在阅读应用程序中展示给用户查看、保存到本地文件等。
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/ContentShulouModelImpl.java

@@ -6,23 +6,83 @@ import org.jsoup.Jsoup;
 import org.jsoup.nodes.Document;
 import org.jsoup.nodes.Element;
 
-public class ContentShulouModelImpl implements IWebContentModel{
+/**
+ * ContentShulouModelImpl类实现了IWebContentModel接口，其主要用途是针对来自特定网站（由TAG标识为http://www.shulou.cc）
+ * 的书籍内容进行解析处理，通过一系列的字符串替换操作对提取到的网页内容相关部分进行格式整理，最终返回符合阅读展示要求的书籍内容字符串。
+ */
+public class ContentShulouModelImpl implements IWebContentModel {
+
+    // 定义一个静态常量TAG，用于标识该内容解析模型所对应的网站地址，此处明确为http://www.shulou.cc，
+    // 便于在整个程序体系里知晓此解析逻辑是专门针对该站点的书籍内容而设计的。
     public static final String TAG = "http://www.shulou.cc";
 
-    public static ContentShulouModelImpl getInstance(){
+    /**
+     * 获取ContentShulouModelImpl类的单例实例。
+     * 通过采用单例模式，确保在整个程序运行期间只有一个该类的实例存在，这样可以更有序地对解析该网站书籍内容这一功能进行统一管理与调用，
+     * 避免因创建多个实例可能导致的资源管理混乱、逻辑不一致等问题。
+     *
+     * @return 返回ContentShulouModelImpl类的唯一实例对象。
+     */
+    public static ContentShulouModelImpl getInstance() {
         return new ContentShulouModelImpl();
     }
-    private ContentShulouModelImpl(){
+
+    /**
+     * 将构造函数私有化，这是实现单例模式的常规手段。把构造函数设为私有后，外部代码就无法直接通过构造函数来随意创建该类的多个实例了，
+     * 从而强制只能通过上面定义的getInstance方法来获取唯一的实例，以此保证单例模式的正确实现。
+     */
+    private ContentShulouModelImpl() {
 
     }
 
+    /**
+     * 实现IWebContentModel接口中定义的analyBookcontent方法，此方法承担着解析书籍内容的核心功能。
+     * 它接收两个参数，参数's'是包含网页内容（期望从中解析出书籍相关文本内容）的原始字符串，通常是通过网络请求获取到的HTML格式的网页文本；
+     * 参数'realUrl'表示书籍内容对应的真实网址，不过在当前代码实现中，暂时未体现出对该网址的深度利用，但其保留着用于后续可能的功能扩展的可能性。
+     *
+     * @param s 包含网页内容（大概率包含要解析的书籍文本等内容）的原始字符串，例如从网站服务器获取到的HTML页面文本，其中应包含了目标书籍的相关文本信息。
+     * @param realUrl 书籍内容对应的真实网址，当前代码里虽未充分借助其进行关键操作，但可作为后续拓展解析逻辑（比如依据网址中的特定信息来更精准地解析内容等）的基础。
+     * @return 返回经过处理后的书籍内容字符串，这个字符串经过了去除多余空格、空白字符、特定HTML标签等格式化操作，使其格式更加规整，更符合阅读和展示的常规要求。
+     * @throws Exception 如果在使用Jsoup解析HTML文档过程中出现问题（比如传入的HTML字符串格式不符合要求，导致无法正确解析等情况），
+     * 或者在后续对提取的内容字符串进行替换操作等环节出现错误（例如替换的字符串不存在等导致的异常），就会抛出异常。
+     */
     @Override
-    public String analyBookcontent(String s, String realUrl) throws Exception{
+    public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库提供的parse方法，将传入的原始字符串（一般是HTML格式的网页内容）解析为一个Document对象。
+        // Document对象基于DOM（文档对象模型）结构来表示HTML文档，通过它能够按照HTML元素的标签、属性、层级关系等特征方便地查找、定位和操作网页中的各种元素，
+        // 从而帮助我们准确地提取出与书籍内容相关的部分。
         Document doc = Jsoup.parse(s);
+
+        // 通过调用Document对象的getElementById方法，依据元素的id属性查找网页中id为"content"的元素。
+        // 这里假设网页中书籍的实际内容主要存放在这个id为"content"的元素内，通过这种方式来定位要解析的书籍内容在整个HTML文档中的大致位置。
         Element contentE = doc.getElementById("content");
+
+        // 将获取到的包含书籍内容相关信息的Element对象转换为字符串形式，方便后续进行一系列的文本替换操作来清理和格式化内容。
         String contentString = contentE.toString();
-        contentString = contentString.replaceAll(" ", "").replaceAll("\n", "").replaceAll("&nbsp;", "").replaceAll("<divid=\"content\">", "").replaceAll("</div>", "").replaceAll("<p></p>","").replaceAll("<br><br>", "\r\n\u3000\u3000");
+
+        // 以下是一系列的字符串替换操作，目的是去除内容字符串中不需要的空格、换行符、HTML中的特殊空格占位符（&nbsp;）以及一些不必要的HTML标签等，
+        // 让文本内容更加纯净、格式更加规整，更符合阅读展示的要求。
+
+        // 去除所有普通空格
+        contentString = contentString.replaceAll(" ", "");
+        // 去除所有换行符
+        contentString = contentString.replaceAll("\n", "");
+        // 去除HTML中的不间断空格（&nbsp;）
+        contentString = contentString.replaceAll("&nbsp;", "");
+        // 去除开头的 <div id="content"> 标签，因为已经提取出了其内部的内容，这个标签在最终展示的文本中不需要出现。
+        contentString = contentString.replaceAll("<divid=\"content\">", "");
+        // 去除结尾的 </div> 标签，同理，这也是不需要在最终文本内容里呈现的HTML标签部分。
+        contentString = contentString.replaceAll("</div>", "");
+        // 去除空的 <p> 标签（<p></p>），这类空标签对书籍内容展示没有实际意义，去除可使内容更简洁。
+        contentString = contentString.replaceAll("<p></p>", "");
+        // 将连续的两个 <br> 标签（通常用于HTML中表示换行）替换为 \r\n\u3000\u3000，
+        // 其中 \r\n 表示换行，\u3000\u3000 表示添加两个全角空格作为缩进，使文本排版更美观，符合阅读习惯。
+        contentString = contentString.replaceAll("<br><br>", "\r\n\u3000\u3000");
+
+        // 在整个处理后的内容字符串开头添加两个全角空格（\u3000\u3000）作为缩进，进一步优化排版效果，使书籍内容看起来更整齐、美观。
         contentString = "\u3000\u3000" + contentString;
+
+        // 返回经过上述一系列处理后的书籍内容字符串，该字符串可用于后续在阅读应用等场景中的展示、存储等操作。
         return contentString;
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/ContentSnwx8ModelImpl.java

@@ -7,31 +7,86 @@ import org.jsoup.nodes.Document;
 import org.jsoup.nodes.TextNode;
 import java.util.List;
 
-public class ContentSnwx8ModelImpl implements IWebContentModel{
+/**
+ * ContentSnwx8ModelImpl类实现了IWebContentModel接口，其主要功能是针对来自特定网站（由TAG标识为http://www.snwx8.com）
+ * 的书籍内容进行解析处理，从网页中提取出相应的文本内容，并经过格式整理后返回，以满足后续诸如在阅读应用中展示、存储等相关需求。
+ */
+public class ContentSnwx8ModelImpl implements IWebContentModel {
+
+    // 定义一个静态常量TAG，用于标识该内容解析模型所对应的网站地址，这里明确为http://www.snwx8.com，
+    // 便于在整个程序架构中知晓此解析逻辑是专门针对该站点的书籍内容而设计的。
     public static final String TAG = "http://www.snwx8.com";
 
+    /**
+     * 获取ContentSnwx8ModelImpl类的单例实例。
+     * 通过采用单例模式，确保在整个程序运行期间只会创建一个该类的实例，便于统一管理和调用解析书籍内容的功能，
+     * 避免因创建多个实例而可能引发的诸如资源浪费、逻辑不一致等问题。
+     *
+     * @return 返回ContentSnwx8ModelImpl类的唯一实例对象。
+     */
     public static ContentSnwx8ModelImpl getInstance() {
         return new ContentSnwx8ModelImpl();
     }
 
+    /**
+     * 将构造函数私有化，这是实现单例模式的常规做法。将构造函数设为私有后，外部代码就无法直接通过构造函数来创建该类的多个实例了，
+     * 只能通过上面定义的getInstance方法来获取唯一的实例，以此保证单例模式的正确实现。
+     */
     private ContentSnwx8ModelImpl() {
 
     }
+
+    /**
+     * 实现IWebContentModel接口中定义的analyBookcontent方法，此方法是整个类的核心功能所在，负责具体解析书籍内容的操作。
+     * 它接收两个参数，参数's'是包含网页内容（期望从中解析出书籍相关文本内容）的原始字符串，通常是通过网络请求获取到的HTML格式的网页文本；
+     * 参数'realUrl'表示书籍内容对应的真实网址，不过在当前代码中暂时没有看到对这个网址进行特别复杂的利用，但其保留着用于后续可能的功能扩展（比如依据网址特征更精准地解析内容等）的可能性。
+     *
+     * @param s 包含网页内容（大概率包含要解析的书籍文本等内容）的原始字符串，例如从网站服务器获取的HTML页面文本，其中包含了目标书籍的相关文本信息。
+     * @param realUrl 书籍内容对应的真实网址，当前虽未深度用于解析逻辑，但可作为后续优化解析过程、结合网址信息进行更精细处理的基础。
+     * @return 返回经过处理后的书籍内容字符串，这个字符串经过了去除多余空格、空白字符等格式化操作，使其格式更加规整，更符合阅读和展示的要求。
+     * @throws Exception 如果在使用Jsoup解析HTML文档时出现问题（例如传入的HTML字符串格式不符合要求，无法正确解析等情况），
+     * 或者在后续查找文本节点、对文本进行操作等环节出现错误（比如找不到预期的HTML元素对应的文本节点等），就会抛出异常。
+     */
     @Override
     public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库提供的parse方法，将传入的原始字符串（一般为HTML格式的网页内容）解析成一个Document对象。
+        // Document对象基于DOM（文档对象模型）结构来表示HTML文档，通过它可以按照HTML元素的标签、属性、层级关系等特征，方便地查找、定位和操作网页中的各种元素，
+        // 从而帮助我们准确地提取出与书籍内容相关的部分。
         Document doc = Jsoup.parse(s);
+
+        // 通过调用Document对象的getElementById方法，依据元素的id属性查找网页中id为"BookText"的元素，
+        // 然后获取该元素包含的所有文本节点（TextNode）列表。这里假设网页中书籍的实际内容是存放在id为"BookText"这个元素内的文本节点当中，
+        // 通过这种方式来定位要解析的文本内容在整个HTML文档中的具体位置。
         List<TextNode> contentEs = doc.getElementById("BookText").textNodes();
+
+        // 创建一个StringBuilder对象，用于高效地拼接整理后的书籍内容字符串。
+        // 相较于直接使用字符串相加操作，使用StringBuilder可以避免频繁创建新的字符串对象所带来的性能开销，
+        // 特别适合在像这样需要多次进行字符串拼接的场景下使用，有助于提升程序运行效率。
         StringBuilder content = new StringBuilder();
-        for(int i=0;i<contentEs.size();i++){
+
+        // 开始遍历获取到的所有文本节点（contentEs），针对每个文本节点依次进行相应的处理和拼接操作，以构建最终的书籍内容字符串。
+        for (int i = 0; i < contentEs.size(); i++) {
+            // 获取当前文本节点的文本内容，然后调用trim方法去除文本内容两端的空白字符（包含空格、制表符、换行等），
+            // 得到相对纯净、没有多余空白干扰的文本内容，以便后续更好地进行处理和展示。
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
-            if(temp.length()>0){
+            // 进一步对处理后的文本内容进行清理，将其中的不间断空格（Unicode编码对应的“&nbsp;”字符，常用于HTML中表示空格占位等情况）以及普通空格都替换为空字符串，
+            // 这样可以让文本的格式更加规整，避免因多余的空白间隔而影响阅读体验以及内容展示的美观性。
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 判断经过上述处理后的文本内容长度是否大于0，如果大于0，则说明该文本节点包含有实际有效的信息，需要将其添加到content这个StringBuilder对象中。
+            if (temp.length() > 0) {
+                // 在每个有效的文本内容前面添加两个全角空格（\u3000）作为缩进格式，使得最终呈现出来的书籍内容在排版上更加美观，
+                // 更符合一般阅读时对于段落格式的要求，便于读者区分不同的内容段落。
                 content.append("\u3000\u3000" + temp);
+                // 如果当前文本节点不是遍历过程中的最后一个文本节点，那么就在添加的文本内容后面添加一个换行符（\r\n），
+                // 以此实现不同文本节点内容之间的换行，让书籍内容在展示时更有条理，方便读者清晰地阅读和理解。
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+
+        // 最后，通过调用StringBuilder对象的toString方法，将经过一系列处理和拼接后存储在其中的书籍内容字符串转换为普通字符串格式，
+        // 并将这个整理好的书籍内容字符串返回，该返回值可以用于后续的各种操作，比如在阅读应用程序中展示给用户查看、保存到本地文件等。
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/ContentSuimengModelImpl.java

@@ -7,31 +7,86 @@ import org.jsoup.nodes.Document;
 import org.jsoup.nodes.TextNode;
 import java.util.List;
 
-public class ContentSuimengModelImpl implements IWebContentModel{
+/**
+ * ContentSuimengModelImpl类实现了IWebContentModel接口，其主要作用是针对来自特定网站（由TAG标识为http://www.suimeng.la）
+ * 的书籍内容进行解析处理，将网页中的相关文本内容提取出来，经过一定的格式整理后返回，以便后续应用（如阅读软件等）能更好地展示、存储这些书籍内容。
+ */
+public class ContentSuimengModelImpl implements IWebContentModel {
+
+    // 定义一个静态常量TAG，用于标识该类所对应的网站地址，这里明确指定为http://www.suimeng.la，
+    // 这样在整个程序架构中就能清楚地知道这个解析类是针对该网站的书籍内容进行处理的。
     public static final String TAG = "http://www.suimeng.la";
 
+    /**
+     * 获取ContentSuimengModelImpl类的单例实例。
+     * 采用单例模式可以确保在整个程序运行期间，只会创建一个该类的实例，便于统一管理和调用解析书籍内容的功能，
+     * 避免因创建多个实例而可能引发的诸如资源浪费、逻辑不一致等问题。
+     *
+     * @return 返回ContentSuimengModelImpl类的唯一实例对象。
+     */
     public static ContentSuimengModelImpl getInstance() {
         return new ContentSuimengModelImpl();
     }
 
+    /**
+     * 将构造函数私有化，这是实现单例模式的常规做法。私有化构造函数后，外部代码就无法直接通过构造函数来创建该类的多个实例了，
+     * 只能通过上面定义的getInstance方法来获取唯一的实例，以此保证单例模式的正确实现。
+     */
     private ContentSuimengModelImpl() {
 
     }
+
+    /**
+     * 实现IWebContentModel接口中定义的analyBookcontent方法，该方法是这个类的核心功能所在，负责具体解析书籍内容的操作。
+     * 它接收两个参数，参数's'是包含网页内容（期望从中解析出书籍相关文本内容）的原始字符串，通常是通过网络请求获取到的HTML格式的网页文本；
+     * 参数'realUrl'表示书籍内容对应的真实网址，不过在当前代码中暂时没有看到对这个网址进行特别复杂的利用，但其保留着用于后续可能的功能扩展（比如依据网址特征更精准地解析内容等）的可能性。
+     *
+     * @param s 包含网页内容（大概率包含要解析的书籍文本等内容）的原始字符串，例如从网站服务器获取的HTML页面文本，其中包含了目标书籍的相关文本信息。
+     * @param realUrl 书籍内容对应的真实网址，当前虽未深度用于解析逻辑，但可作为后续优化解析过程、结合网址信息进行更精细处理的基础。
+     * @return 返回经过处理后的书籍内容字符串，这个字符串经过了去除多余空格、空白字符等格式化操作，使其格式更加规整，更符合阅读和展示的要求。
+     * @throws Exception 如果在使用Jsoup解析HTML文档时出现问题（例如传入的HTML字符串格式不符合要求，无法正确解析等情况），
+     * 或者在后续查找文本节点、对文本进行操作等环节出现错误（比如找不到预期的HTML元素对应的文本节点等），就会抛出异常。
+     */
     @Override
     public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库提供的parse方法，将传入的原始字符串（一般为HTML格式的网页内容）解析成一个Document对象。
+        // Document对象基于DOM（文档对象模型）结构来表示HTML文档，通过它可以按照HTML元素的标签、属性、层级关系等特征，方便地查找、定位和操作网页中的各种元素，
+        // 从而帮助我们准确地提取出与书籍内容相关的部分。
         Document doc = Jsoup.parse(s);
+
+        // 通过调用Document对象的getElementById方法，依据元素的id属性查找网页中id为"ccontent"的元素，
+        // 然后获取该元素包含的所有文本节点（TextNode）列表。这里假设网页中书籍的实际内容是存放在id为"ccontent"这个元素内的文本节点当中，
+        // 通过这种方式来定位要解析的文本内容在整个HTML文档中的具体位置。
         List<TextNode> contentEs = doc.getElementById("ccontent").textNodes();
+
+        // 创建一个StringBuilder对象，用于高效地拼接整理后的书籍内容字符串。
+        // 相较于直接使用字符串相加操作，使用StringBuilder可以避免频繁创建新的字符串对象所带来的性能开销，
+        // 特别适合在像这样需要多次进行字符串拼接的场景下使用，有助于提升程序运行效率。
         StringBuilder content = new StringBuilder();
+
+        // 开始遍历获取到的所有文本节点（contentEs），针对每个文本节点依次进行相应的处理和拼接操作，以构建最终的书籍内容字符串。
         for (int i = 0; i < contentEs.size(); i++) {
+            // 获取当前文本节点的文本内容，然后调用trim方法去除文本内容两端的空白字符（包含空格、制表符、换行等），
+            // 得到相对纯净、没有多余空白干扰的文本内容，以便后续更好地进行处理和展示。
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 进一步对处理后的文本内容进行清理，将其中的不间断空格（Unicode编码对应的“&nbsp;”字符，常用于HTML中表示空格占位等情况）以及普通空格都替换为空字符串，
+            // 这样可以让文本的格式更加规整，避免因多余的空白间隔而影响阅读体验以及内容展示的美观性。
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 判断经过上述处理后的文本内容长度是否大于0，如果大于0，则说明该文本节点包含有实际有效的信息，需要将其添加到content这个StringBuilder对象中。
             if (temp.length() > 0) {
+                // 在每个有效的文本内容前面添加两个全角空格（\u3000）作为缩进格式，使得最终呈现出来的书籍内容在排版上更加美观，
+                // 更符合一般阅读时对于段落格式的要求，便于读者区分不同的内容段落。
                 content.append("\u3000\u3000" + temp);
+                // 如果当前文本节点不是遍历过程中的最后一个文本节点，那么就在添加的文本内容后面添加一个换行符（\r\n），
+                // 以此实现不同文本节点内容之间的换行，让书籍内容在展示时更有条理，方便读者清晰地阅读和理解。
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+
+        // 最后，通过调用StringBuilder对象的toString方法，将经过一系列处理和拼接后存储在其中的书籍内容字符串转换为普通字符串格式，
+        // 并将这个整理好的书籍内容字符串返回，该返回值可以用于后续的各种操作，比如在阅读应用程序中展示给用户查看、保存到本地文件等。
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/ContentSyzwwModelImpl.java

@@ -8,33 +8,85 @@ import org.jsoup.nodes.TextNode;
 import java.util.List;
 
 /**
- * 站点有问题  未完全解析
+ * ContentSyzwwModelImpl类实现了IWebContentModel接口，主要用于对来自特定网站（由TAG标识为http://www.syzww.net）
+ * 的书籍内容进行解析处理。不过当前已知该站点存在一些问题，导致解析功能未能完全实现，后续或许需要进一步完善相关逻辑来达到更好的解析效果。
  */
-public class ContentSyzwwModelImpl implements IWebContentModel{
+public class ContentSyzwwModelImpl implements IWebContentModel {
+
+    // 定义一个静态常量TAG，用于标识该内容解析模型所对应的网站地址，此处明确为http://www.syzww.net，
+    // 便于在整个程序体系中知晓此解析逻辑是针对该站点的书籍内容而设计的。
     public static final String TAG = "http://www.syzww.net";
 
+    /**
+     * 获取ContentSyzwwModelImpl类的单例实例。
+     * 通过采用单例模式，确保在整个程序运行期间只有一个该类的实例存在，这样便于对解析该网站书籍内容这一功能进行统一管理与调用，
+     * 避免因创建多个实例可能引发的资源管理混乱、逻辑不一致等问题。
+     *
+     * @return 返回ContentSyzwwModelImpl类的唯一实例对象。
+     */
     public static ContentSyzwwModelImpl getInstance() {
         return new ContentSyzwwModelImpl();
     }
 
+    /**
+     * 将构造函数私有化，这是实现单例模式的常规手段。把构造函数设为私有后，外部代码就无法直接通过构造函数来随意创建该类的多个实例了，
+     * 从而强制只能通过上面定义的getInstance方法来获取唯一的实例，以此保证单例模式的正确实现。
+     */
     private ContentSyzwwModelImpl() {
 
     }
+
+    /**
+     * 实现IWebContentModel接口中定义的analyBookcontent方法，此方法承担着解析书籍内容的核心功能。
+     * 它接收两个参数，参数's'是包含网页内容（期望从中解析出书籍相关文本内容）的原始字符串，通常是通过网络请求获取到的HTML格式的网页文本；
+     * 参数'realUrl'表示书籍内容对应的真实网址，在当前代码实现中，暂时未体现出对该网址的深度利用，但其保留着用于后续可能的功能扩展的可能性。
+     *
+     * @param s 包含网页内容（大概率包含要解析的书籍文本等内容）的原始字符串，例如从网站服务器获取到的HTML页面文本，其中应包含了目标书籍的相关文本信息。
+     * @param realUrl 书籍内容对应的真实网址，当前代码里虽未充分借助其进行关键操作，但可作为后续拓展解析逻辑（比如依据网址中的特定信息来更精准地解析内容等）的基础。
+     * @return 返回经过处理后的书籍内容字符串，这个字符串经过了去除多余空格、空白字符等格式化操作，使其格式更加规整，更符合阅读和展示的常规要求。
+     * @throws Exception 如果在使用Jsoup解析HTML文档过程中出现问题（比如传入的HTML字符串格式不符合要求，导致无法正确解析等情况），
+     * 或者在后续对文本节点进行查找、操作等环节出现错误（例如找不到预期的HTML元素对应的文本节点等），就会抛出异常。
+     */
     @Override
     public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库提供的parse方法，将传入的原始字符串（一般是HTML格式的网页内容）解析为一个Document对象。
+        // Document对象基于DOM（文档对象模型）结构来表示HTML文档，通过它能够按照HTML元素的标签、属性、层级关系等特征方便地查找、定位和操作网页中的各种元素，
+        // 从而帮助我们准确地提取出与书籍内容相关的部分。
         Document doc = Jsoup.parse(s);
+
+        // 通过调用Document对象的getElementById方法，依据元素的id属性查找网页中id为"content"的元素，
+        // 然后获取该元素包含的所有文本节点（TextNode）列表。这里假设网页中书籍的实际内容是存放在id为"content"这个元素内的文本节点当中，
+        // 通过这种方式来定位要解析的文本内容在整个HTML文档中的具体位置。
         List<TextNode> contentEs = doc.getElementById("content").textNodes();
+
+        // 创建一个StringBuilder对象，用于高效地拼接整理后的书籍内容字符串。
+        // 相比于直接使用字符串相加操作，使用StringBuilder可以避免频繁创建新的字符串对象所带来的性能开销，
+        // 特别适合在需要多次进行字符串拼接的场景下使用，有助于提升程序运行效率。
         StringBuilder content = new StringBuilder();
+
+        // 开始遍历获取到的所有文本节点（contentEs），针对每个文本节点依次进行相应的处理和拼接操作，以构建最终的书籍内容字符串。
         for (int i = 0; i < contentEs.size(); i++) {
+            // 获取当前文本节点的文本内容，然后调用trim方法去除文本内容两端的空白字符（包含空格、制表符、换行等），
+            // 得到相对纯净、没有多余空白干扰的文本内容，以便后续更好地进行处理和展示。
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 进一步对处理后的文本内容进行清理，将其中的不间断空格（Unicode编码对应的“&nbsp;”字符，常用于HTML中表示空格占位等情况）以及普通空格都替换为空字符串，
+            // 这样可以让文本的格式更加规整，避免因多余的空白间隔而影响阅读体验以及内容展示的美观性。
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 判断经过上述处理后的文本内容长度是否大于0，如果大于0，则说明该文本节点包含有实际有效的信息，需要将其添加到content这个StringBuilder对象中。
             if (temp.length() > 0) {
+                // 在每个有效的文本内容前面添加两个全角空格（\u3000）作为缩进格式，使得最终呈现出来的书籍内容在排版上更加美观，
+                // 更符合一般阅读时对于段落格式的要求，便于读者区分不同的内容段落。
                 content.append("\u3000\u3000" + temp);
+                // 如果当前文本节点不是遍历过程中的最后一个文本节点，那么就在添加的文本内容后面添加一个换行符（\r\n），
+                // 以此实现不同文本节点内容之间的换行，让书籍内容在展示时更有条理，方便读者清晰地阅读和理解。
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+
+        // 最后，通过调用StringBuilder对象的toString方法，将经过一系列处理和拼接后存储在其中的书籍内容字符串转换为普通字符串格式，
+        // 并将这个整理好的书籍内容字符串返回，该返回值可以用于后续的各种操作，比如在阅读应用程序中展示给用户查看、保存到本地文件等。
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/ContentVodtwModelImpl.java

@@ -7,34 +7,89 @@ import org.jsoup.nodes.Document;
 import org.jsoup.nodes.Element;
 import org.jsoup.select.Elements;
 
+/**
+ * ContentVodtwModelImpl类实现了IWebContentModel接口，其主要功能是针对来自特定网站（由TAG标识为http://www.vodtw.com）
+ * 的书籍内容进行解析处理，从网页中提取出相应的文本内容，并经过格式整理后返回，以便后续用于展示、存储等相关操作，满足阅读相关的业务需求。
+ */
 public class ContentVodtwModelImpl implements IWebContentModel {
+
+    // 定义一个静态常量TAG，用于标识该内容解析模型所对应的网站地址，此处明确为http://www.vodtw.com，
+    // 便于在整个程序体系里知晓此解析逻辑是专门针对该站点的书籍内容而设计的。
     public static final String TAG = "http://www.vodtw.com";
 
+    /**
+     * 获取ContentVodtwModelImpl类的单例实例。
+     * 通过采用单例模式，确保在整个程序运行期间只有一个该类的实例存在，这样可以更有序地对解析该网站书籍内容这一功能进行统一管理与调用，
+     * 避免因创建多个实例可能导致的资源管理混乱、逻辑不一致等问题。
+     *
+     * @return 返回ContentVodtwModelImpl类的唯一实例对象。
+     */
     public static ContentVodtwModelImpl getInstance() {
         return new ContentVodtwModelImpl();
     }
 
+    /**
+     * 将构造函数私有化，这是实现单例模式的常规手段。把构造函数设为私有后，外部代码就无法直接通过构造函数来随意创建该类的多个实例了，
+     * 从而强制只能通过上面定义的getInstance方法来获取唯一的实例，以此保证单例模式的正确实现。
+     */
     private ContentVodtwModelImpl() {
 
     }
 
+    /**
+     * 实现IWebContentModel接口中定义的analyBookcontent方法，此方法承担着解析书籍内容的核心功能。
+     * 它接收两个参数，参数's'是包含网页内容（期望从中解析出书籍相关文本内容）的原始字符串，通常是通过网络请求获取到的HTML格式的网页文本；
+     * 参数'realUrl'表示书籍内容对应的真实网址，不过在当前代码实现中，暂时未体现出对该网址的深度利用，但其保留着用于后续可能的功能扩展的可能性。
+     *
+     * @param s 包含网页内容（大概率包含要解析的书籍文本等内容）的原始字符串，例如从网站服务器获取到的HTML页面文本，其中应包含了目标书籍的相关文本信息。
+     * @param realUrl 书籍内容对应的真实网址，当前代码里虽未充分借助其进行关键操作，但可作为后续拓展解析逻辑（比如依据网址中的特定信息来更精准地解析内容等）的基础。
+     * @return 返回经过处理后的书籍内容字符串，这个字符串经过了去除多余空格、空白字符等格式化操作，使其格式更加规整，更符合阅读和展示的常规要求。
+     * @throws Exception 如果在使用Jsoup解析HTML文档过程中出现问题（比如传入的HTML字符串格式不符合要求，导致无法正确解析等情况），
+     * 或者在后续对提取的内容元素进行操作等环节出现错误（例如找不到预期的HTML元素等），就会抛出异常。
+     */
     @Override
     public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库提供的parse方法，将传入的原始字符串（一般是HTML格式的网页内容）解析为一个Document对象。
+        // Document对象基于DOM（文档对象模型）结构来表示HTML文档，通过它能够按照HTML元素的标签、属性、层级关系等特征方便地查找、定位和操作网页中的各种元素，
+        // 从而帮助我们准确地提取出与书籍内容相关的部分。
         Document doc = Jsoup.parse(s);
+
+        // 通过调用Document对象的getElementById方法，依据元素的id属性查找网页中id为"BookText"的元素。
+        // 这里假设网页中书籍的实际内容主要存放在这个id为"BookText"的元素内，通过这种方式来定位要解析的书籍内容在整个HTML文档中的大致位置。
         Element contentE = doc.getElementById("BookText");
+
+        // 创建一个StringBuilder对象，用于高效地拼接整理后的书籍内容字符串。
+        // 相比于直接使用字符串相加操作，使用StringBuilder能够避免频繁创建新的字符串对象所带来的性能开销，
+        // 特别适合在像这样需要多次进行字符串拼接的场景，有助于提高程序的运行效率。
         StringBuilder content = new StringBuilder();
 
+        // 通过获取到的contentE元素，使用getElementsByTag方法依据标签名称"p"来查找其内部所有的<p>标签元素，
+        // 并将这些元素存储在Elements集合中，这里假设书籍内容是分布在这些<p>标签内的文本信息，后续将从这些<p>标签元素中提取具体文本内容。
         Elements contentEs = contentE.getElementsByTag("p");
+
+        // 开始遍历获取到的所有<p>标签元素（contentEs），针对每个元素依次进行相应的处理和拼接操作，以构建最终的书籍内容字符串。
         for (int i = 0; i < contentEs.size(); i++) {
+            // 获取当前<p>标签元素的文本内容，然后调用trim方法去除文本内容两端的空白字符（包含空格、制表符、换行等），
+            // 得到相对纯净、没有多余空白干扰的文本内容，方便后续更好地进行处理和展示。
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 进一步对处理后的文本内容进行清理，将其中的不间断空格（Unicode编码对应的“&nbsp;”字符，常用于HTML中表示空格占位等情况）以及普通空格都替换为空字符串，
+            // 这样可以让文本的格式更加规整，避免因多余的空白间隔而影响阅读体验以及内容展示的美观性。
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 判断经过上述处理后的文本内容长度是否大于0，如果大于0，则说明该<p>标签元素包含有实际有效的信息，需要将其添加到content这个StringBuilder对象中。
             if (temp.length() > 0) {
+                // 在每个有效的文本内容前面添加两个全角空格（\u3000）作为缩进格式，使得最终呈现出来的书籍内容在排版上更加美观，
+                // 更符合一般阅读时对于段落格式的要求，便于读者区分不同的内容段落。
                 content.append("\u3000\u3000" + temp);
+                // 如果当前<p>标签元素不是遍历过程中的最后一个元素，那么就在添加的文本内容后面添加一个换行符（\r\n），
+                // 以此实现不同<p>标签元素内容之间的换行，让书籍内容在展示时更有条理，方便读者清晰地阅读和理解。
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+
+        // 最后，通过调用StringBuilder对象的toString方法，将经过一系列处理和拼接后存储在其中的书籍内容字符串转换为普通字符串格式，
+        // 并将这个整理好的书籍内容字符串返回，该返回值可以用于后续的各种操作，比如在阅读应用程序中展示给用户查看、保存到本地文件等。
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/ContentWxguanModelImpl.java

@@ -7,31 +7,86 @@ import org.jsoup.nodes.Document;
 import org.jsoup.nodes.TextNode;
 import java.util.List;
 
-public class ContentWxguanModelImpl implements IWebContentModel{
+/**
+ * ContentWxguanModelImpl类实现了IWebContentModel接口，其核心功能是针对来自网站（由TAG标识为http://www.wxguan.com）
+ * 的书籍内容进行解析，将网页中的相关文本内容提取出来并整理成合适的格式后返回，方便后续在阅读相关应用中进行展示、存储等操作。
+ */
+public class ContentWxguanModelImpl implements IWebContentModel {
+
+    // 定义一个静态常量TAG，用于明确标识该内容解析类对应的网站地址，这里设定为http://www.wxguan.com，
+    // 便于在整个程序架构中知晓此解析逻辑是专门针对该站点的书籍内容而设计的。
     public static final String TAG = "http://www.wxguan.com";
 
+    /**
+     * 获取ContentWxguanModelImpl类的单例实例。
+     * 采用单例模式的目的在于确保整个程序运行期间只有一个该类的实例存在，便于统一管理和调用解析书籍内容这一功能，
+     * 避免因创建多个实例可能引发的诸如资源浪费、逻辑混乱等问题。
+     *
+     * @return 返回ContentWxguanModelImpl类的唯一实例对象。
+     */
     public static ContentWxguanModelImpl getInstance() {
         return new ContentWxguanModelImpl();
     }
 
+    /**
+     * 将构造函数私有化，这是实现单例模式的常规做法。通过私有化构造函数，外部代码无法直接通过构造函数创建该类的多个实例，
+     * 只能通过上面定义的getInstance方法获取唯一的实例，以此保证单例模式的正确实现，维持代码逻辑的一致性。
+     */
     private ContentWxguanModelImpl() {
 
     }
+
+    /**
+     * 实现IWebContentModel接口中定义的analyBookcontent方法，该方法是整个类的关键功能所在，负责具体解析书籍内容的操作。
+     * 它接收两个参数，参数's'是包含网页内容（期望从中提取出书籍相关文本内容）的原始字符串，通常是通过网络请求获取到的HTML格式的网页文本；
+     * 参数'realUrl'表示书籍内容对应的真实网址，在当前代码中暂时未对其进行深度利用，不过保留该参数可为后续可能的功能扩展（比如依据网址中的特定信息更精准地解析内容等）提供便利。
+     *
+     * @param s 包含网页内容（大概率包含要解析的书籍文本等内容）的原始字符串，例如从网站服务器获取的HTML页面文本，其中包含了目标书籍的相关文本信息。
+     * @param realUrl 书籍内容对应的真实网址，当前代码里虽未深度借助其进行关键操作，但可作为后续拓展解析逻辑、结合网址特征优化解析过程的潜在基础。
+     * @return 返回经过处理后的书籍内容字符串，此字符串经过了去除多余空格、空白字符等格式化操作，使其格式更加规整，更符合阅读和展示的常规要求。
+     * @throws Exception 如果在使用Jsoup解析HTML文档过程中出现问题（比如传入的HTML字符串格式不正确，无法正确解析等情况），
+     * 或者在后续查找文本节点、对文本内容进行操作等环节出现错误（例如找不到预期的HTML元素对应的文本节点等），会抛出异常。
+     */
     @Override
     public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库提供的parse方法，将传入的原始字符串（一般为HTML格式的网页内容）解析成一个Document对象。
+        // Document对象基于DOM（文档对象模型）结构来表示HTML文档，通过它可以按照HTML元素的标签、属性、层级关系等特征，方便地查找、定位和操作网页中的各种元素，
+        // 进而帮助我们准确地提取出与书籍内容相关的部分。
         Document doc = Jsoup.parse(s);
+
+        // 通过调用Document对象的getElementById方法，依据元素的id属性查找网页中id为"content"的元素，
+        // 然后获取该元素包含的所有文本节点（TextNode）列表。这里假设网页中书籍的实际内容是存放在id为"content"这个元素内的文本节点当中，
+        // 通过这种方式来定位要解析的文本内容在整个HTML文档中的具体位置。
         List<TextNode> contentEs = doc.getElementById("content").textNodes();
+
+        // 创建一个StringBuilder对象，用于高效地拼接整理后的书籍内容字符串。
+        // 相较于直接使用字符串相加操作，使用StringBuilder可以避免频繁创建新的字符串对象所带来的性能开销，
+        // 特别适合在像这样需要多次进行字符串拼接的场景下使用，有助于提升程序运行效率。
         StringBuilder content = new StringBuilder();
+
+        // 开始遍历获取到的所有文本节点（contentEs），针对每个文本节点依次进行相应的处理和拼接操作，以构建最终的书籍内容字符串。
         for (int i = 0; i < contentEs.size(); i++) {
+            // 获取当前文本节点的文本内容，然后调用trim方法去除文本内容两端的空白字符（包含空格、制表符、换行等），
+            // 得到相对纯净、没有多余空白干扰的文本内容，以便后续更好地进行处理和展示。
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 进一步对处理后的文本内容进行清理，将其中的不间断空格（Unicode编码对应的“&nbsp;”字符，常用于HTML中表示空格占位等情况）以及普通空格都替换为空字符串，
+            // 这样可以让文本的格式更加规整，避免因多余的空白间隔而影响阅读体验以及内容展示的美观性。
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 判断经过上述处理后的文本内容长度是否大于0，如果大于0，则说明该文本节点包含有实际有效的信息，需要将其添加到content这个StringBuilder对象中。
             if (temp.length() > 0) {
+                // 在每个有效的文本内容前面添加两个全角空格（\u3000）作为缩进格式，使得最终呈现出来的书籍内容在排版上更加美观，
+                // 更符合一般阅读时对于段落格式的要求，便于读者区分不同的内容段落。
                 content.append("\u3000\u3000" + temp);
+                // 如果当前文本节点不是遍历过程中的最后一个文本节点，那么就在添加的文本内容后面添加一个换行符（\r\n），
+                // 以此实现不同文本节点内容之间的换行，让书籍内容在展示时更有条理，方便读者清晰地阅读和理解。
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+
+        // 最后，通过调用StringBuilder对象的toString方法，将经过一系列处理和拼接后存储在其中的书籍内容字符串转换为普通字符串格式，
+        // 并将这个整理好的书籍内容字符串返回，该返回值可以用于后续的各种操作，比如在阅读应用程序中展示给用户查看、保存到本地文件等。
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/ContentXqingdouCCModelImpl.java

@@ -6,32 +6,87 @@ import org.jsoup.Jsoup;
 import org.jsoup.nodes.Document;
 import org.jsoup.select.Elements;
 
+/**
+ * ContentXqingdouCCModelImpl类实现了IWebContentModel接口，其主要功能是针对来自特定网站（由TAG标识为http://www.xqingdou.cc）
+ * 的书籍内容进行解析处理，提取出网页中对应书籍内容的文本信息，经过格式整理后返回，以便后续用于展示、存储等相关阅读应用的操作场景。
+ */
 public class ContentXqingdouCCModelImpl implements IWebContentModel {
+
+    // 定义一个静态常量TAG，用于标识该内容解析模型所对应的网站地址，此处明确为http://www.xqingdou.cc，
+    // 便于在整个程序体系里知晓此解析逻辑是专门针对该站点的书籍内容而设计的。
     public static final String TAG = "http://www.xqingdou.cc";
 
+    /**
+     * 获取ContentXqingdouCCModelImpl类的单例实例。
+     * 通过采用单例模式，确保在整个程序运行期间只有一个该类的实例存在，这样可以更有序地对解析该网站书籍内容这一功能进行统一管理与调用，
+     * 避免因创建多个实例可能导致的资源管理混乱、逻辑不一致等问题。
+     *
+     * @return 返回ContentXqingdouCCModelImpl类的唯一实例对象。
+     */
     public static ContentXqingdouCCModelImpl getInstance() {
         return new ContentXqingdouCCModelImpl();
     }
 
+    /**
+     * 将构造函数私有化，这是实现单例模式的常规手段。把构造函数设为私有后，外部代码就无法直接通过构造函数来随意创建该类的多个实例了，
+     * 从而强制只能通过上面定义的getInstance方法来获取唯一的实例，以此保证单例模式的正确实现。
+     */
     private ContentXqingdouCCModelImpl() {
 
     }
 
+    /**
+     * 实现IWebContentModel接口中定义的analyBookcontent方法，此方法承担着解析书籍内容的核心功能。
+     * 它接收两个参数，参数's'是包含网页内容（期望从中解析出书籍相关文本内容）的原始字符串，通常是通过网络请求获取到的HTML格式的网页文本；
+     * 参数'realUrl'表示书籍内容对应的真实网址，在当前代码实现中，暂时未体现出对该网址的深度利用，但其保留着用于后续可能的功能扩展的可能性。
+     *
+     * @param s 包含网页内容（大概率包含要解析的书籍文本等内容）的原始字符串，例如从网站服务器获取到的HTML页面文本，其中应包含了目标书籍的相关文本信息。
+     * @param realUrl 书籍内容对应的真实网址，当前代码里虽未充分借助其进行关键操作，但可作为后续拓展解析逻辑（比如依据网址中的特定信息来更精准地解析内容等）的基础。
+     * @return 返回经过处理后的书籍内容字符串，这个字符串经过了去除多余空格、空白字符等格式化操作，使其格式更加规整，更符合阅读和展示的常规要求。
+     * @throws Exception 如果在使用Jsoup解析HTML文档过程中出现问题（比如传入的HTML字符串格式不符合要求，导致无法正确解析等情况），
+     * 或者在后续对提取的内容元素进行操作等环节出现错误（例如找不到预期的HTML元素等），就会抛出异常。
+     */
     @Override
-    public String analyBookcontent(String s, String realUrl) throws Exception{
+    public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库提供的parse方法，将传入的原始字符串（一般是HTML格式的网页内容）解析为一个Document对象。
+        // Document对象基于DOM（文档对象模型）结构来表示HTML文档，通过它能够按照HTML元素的标签、属性、层级关系等特征方便地查找、定位和操作网页中的各种元素，
+        // 从而帮助我们准确地提取出与书籍内容相关的部分。
         Document doc = Jsoup.parse(s);
+
+        // 首先通过调用Document对象的getElementById方法，依据元素的id属性查找网页中id为"chapter_content"的元素，
+        // 这里假设书籍内容所在的区域是在这个id为"chapter_content"的元素内部。
+        // 然后在此元素基础上，再使用getElementsByTag方法依据标签名称"p"来查找其内部所有的<p>标签元素，
+        // 并将这些<p>标签元素存储在Elements集合中，通常会假设书籍的具体文本内容是分布在这些<p>标签当中，后续将从这些元素中提取具体的文本内容。
         Elements contentEs = doc.getElementById("chapter_content").getElementsByTag("p");
+
+        // 创建一个StringBuilder对象，用于高效地拼接整理后的书籍内容字符串。
+        // 相比于直接使用字符串相加操作，使用StringBuilder可以避免频繁创建新的字符串对象所带来的性能开销，
+        // 特别适合在像这样需要多次进行字符串拼接的场景下使用，有助于提升程序运行效率。
         StringBuilder content = new StringBuilder();
+
+        // 开始遍历获取到的所有<p>标签元素（contentEs），针对每个元素依次进行相应的处理和拼接操作，以构建最终的书籍内容字符串。
         for (int i = 0; i < contentEs.size(); i++) {
+            // 获取当前<p>标签元素的文本内容，然后调用trim方法去除文本内容两端的空白字符（包含空格、制表符、换行等），
+            // 得到相对纯净、没有多余空白干扰的文本内容，方便后续更好地进行处理和展示。
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 进一步对处理后的文本内容进行清理，将其中的不间断空格（Unicode编码对应的“&nbsp;”字符，常用于HTML中表示空格占位等情况）以及普通空格都替换为空字符串，
+            // 这样可以让文本的格式更加规整，避免因多余的空白间隔而影响阅读体验以及内容展示的美观性。
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 判断经过上述处理后的文本内容长度是否大于0，如果大于0，则说明该<p>标签元素包含有实际有效的信息，需要将其添加到content这个StringBuilder对象中。
             if (temp.length() > 0) {
+                // 在每个有效的文本内容前面添加两个全角空格（\u3000）作为缩进格式，使得最终呈现出来的书籍内容在排版上更加美观，
+                // 更符合一般阅读时对于段落格式的要求，便于读者区分不同的内容段落。
                 content.append("\u3000\u3000" + temp);
+                // 如果当前<p>标签元素不是遍历过程中的最后一个元素，那么就在添加的文本内容后面添加一个换行符（\r\n），
+                // 以此实现不同<p>标签元素内容之间的换行，让书籍内容在展示时更有条理，方便读者清晰地阅读和理解。
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+
+        // 最后，通过调用StringBuilder对象的toString方法，将经过一系列处理和拼接后存储在其中的书籍内容字符串转换为普通字符串格式，
+        // 并将这个整理好的书籍内容字符串返回，该返回值可以用于后续的各种操作，比如在阅读应用程序中展示给用户查看、保存到本地文件等。
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/ContentXqingdouModelImpl.java

@@ -6,32 +6,87 @@ import org.jsoup.Jsoup;
 import org.jsoup.nodes.Document;
 import org.jsoup.select.Elements;
 
+/**
+ * ContentXqingdouModelImpl类实现了IWebContentModel接口，主要用于解析来自特定网站（由TAG标识为http://www.xqingdou.com）
+ * 的书籍内容，从网页的HTML结构中提取出相应文本信息，并经过一定格式整理后返回，以满足后续诸如在阅读应用中展示、存储等相关需求。
+ */
 public class ContentXqingdouModelImpl implements IWebContentModel {
+
+    // 定义一个静态常量TAG，用于标识该内容解析模型对应的网站地址，这里明确指定为http://www.xqingdou.com，
+    // 便于在整个程序架构中知晓此解析逻辑是专门针对该站点书籍内容而设计的。
     public static final String TAG = "http://www.xqingdou.com";
 
+    /**
+     * 获取ContentXqingdouModelImpl类的单例实例。
+     * 通过采用单例模式，确保在整个程序运行期间仅有一个该类的实例存在，便于统一管理和调用解析该网站书籍内容的功能，
+     * 避免因创建多个实例而可能引发的资源浪费、逻辑不一致等问题。
+     *
+     * @return 返回ContentXqingdouModelImpl类的唯一实例对象。
+     */
     public static ContentXqingdouModelImpl getInstance() {
         return new ContentXqingdouModelImpl();
     }
 
+    /**
+     * 将构造函数私有化，这是实现单例模式的常规做法。私有化构造函数后，外部代码无法直接通过构造函数创建该类的多个实例，
+     * 只能通过上述的getInstance方法获取唯一的实例，以此保证单例模式正确实现，维持代码逻辑的规范性。
+     */
     private ContentXqingdouModelImpl() {
 
     }
 
+    /**
+     * 实现IWebContentModel接口中定义的analyBookcontent方法，此方法是整个类的核心功能所在，负责具体的书籍内容解析工作。
+     * 它接收两个参数，参数's'是包含网页内容（期望从中解析出书籍相关文本内容）的原始字符串，一般是通过网络请求获取到的HTML格式的网页文本；
+     * 参数'realUrl'表示书籍内容对应的真实网址，在当前代码实现中，暂时未充分体现对该网址的深度利用，不过其保留着用于后续可能的功能扩展（比如依据网址特征更精准地解析内容等）的价值。
+     *
+     * @param s 包含网页内容（大概率包含要解析的书籍文本等内容）的原始字符串，例如从网站服务器获取的HTML页面文本，其中包含目标书籍的相关文本信息。
+     * @param realUrl 书籍内容对应的真实网址，当前虽未深度参与解析逻辑，但可作为后续优化解析流程、结合网址特点进行更精细内容提取的基础。
+     * @return 返回经过处理后的书籍内容字符串，该字符串经过了去除多余空格、空白字符等格式化操作，使其格式更加规整，更符合阅读和展示的常规要求。
+     * @throws Exception 如果在使用Jsoup解析HTML文档时出现问题（如传入的HTML字符串格式错误，无法正确解析等情况），
+     * 或者在后续依据元素ID查找、通过标签筛选元素以及对文本内容进行操作等环节出现错误（比如找不到预期的元素或文本节点等），就会抛出异常。
+     */
     @Override
-    public String analyBookcontent(String s, String realUrl) throws Exception{
+    public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库提供的parse方法，将传入的原始字符串（通常为HTML格式的网页内容）解析成一个Document对象。
+        // Document对象基于DOM（文档对象模型）结构来表示HTML文档，借助它可以依据HTML元素的标签、属性、层级关系等特征，方便地查找、定位和操作网页中的各种元素，
+        // 从而帮助我们准确地提取出与书籍内容相关的部分。
         Document doc = Jsoup.parse(s);
+
+        // 首先通过调用Document对象的getElementById方法，依据元素的id属性查找网页中id为"chapter_content"的元素，
+        // 这里假设书籍内容所在的主要区域是在这个id为"chapter_content"的元素内部，这是定位书籍文本内容大致位置的第一步。
+        // 接着，在找到的"chapter_content"元素基础上，调用getElementsByTag方法，依据标签名称"p"来查找该元素内部所有的<p>标签元素，
+        // 并将这些<p>标签元素存储在Elements集合中，通常认为书籍的具体文本内容是分布在这些<p>标签里面的，后续将从这些元素中提取具体文本内容进行整理。
         Elements contentEs = doc.getElementById("chapter_content").getElementsByTag("p");
+
+        // 创建一个StringBuilder对象，用于高效地拼接整理后的书籍内容字符串。
+        // 相较于直接使用字符串相加操作，使用StringBuilder能避免频繁创建新的字符串对象所带来的性能开销，
+        // 特别适合在像这样需要多次进行字符串拼接的场景下使用，有助于提升程序运行效率。
         StringBuilder content = new StringBuilder();
+
+        // 开始遍历获取到的所有<p>标签元素（contentEs），针对每个元素依次进行相应的处理和拼接操作，以构建最终的书籍内容字符串。
         for (int i = 0; i < contentEs.size(); i++) {
+            // 获取当前<p>标签元素的文本内容，然后调用trim方法去除文本内容两端的空白字符（包含空格、制表符、换行等），
+            // 得到相对纯净、没有多余空白干扰的文本内容，以便后续更清晰地处理和展示。
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 进一步对处理后的文本内容进行清理，将其中的不间断空格（Unicode编码对应的“&nbsp;”字符，常用于HTML中表示空格占位等情况）以及普通空格都替换为空字符串，
+            // 这样可以让文本的格式更加规整，避免因多余的空白间隔而影响阅读体验以及内容展示的美观性。
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 判断经过上述处理后的文本内容长度是否大于0，如果大于0，则说明该<p>标签元素包含有实际有效的信息，需要将其添加到content这个StringBuilder对象中。
             if (temp.length() > 0) {
+                // 在每个有效的文本内容前面添加两个全角空格（\u3000）作为缩进格式，使得最终呈现出来的书籍内容在排版上更加美观，
+                // 更符合一般阅读时对于段落格式的要求，便于读者区分不同的内容段落。
                 content.append("\u3000\u3000" + temp);
+                // 如果当前<p>标签元素不是遍历过程中的最后一个元素，那么就在添加的文本内容后面添加一个换行符（\r\n），
+                // 以此实现不同<p>标签元素内容之间的换行，让书籍内容在展示时更有条理，方便读者清晰地阅读和理解。
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+
+        // 最后，通过调用StringBuilder对象的toString方法，将经过一系列处理和拼接后存储在其中的书籍内容字符串转换为普通字符串格式，
+        // 并将这个整理好的书籍内容字符串返回，该返回值可以用于后续的各种操作，比如在阅读应用程序中展示给用户查看、保存到本地文件等。
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/ContentYb3ModelImpl.java

@@ -9,52 +9,125 @@ import org.jsoup.nodes.TextNode;
 import org.jsoup.select.Elements;
 import java.util.List;
 
-public class ContentYb3ModelImpl implements IWebContentModel{
+/**
+ * ContentYb3ModelImpl类实现了IWebContentModel接口，主要用于解析来自特定网站（由TAG标识为http://www.yb3.cc）
+ * 的书籍内容。该类尝试通过不同的方式来提取和整理书籍内容文本，以应对可能出现的不同网页结构情况，最终将整理好的内容以字符串形式返回，
+ * 方便后续在阅读相关应用中进行展示、存储等操作。
+ */
+public class ContentYb3ModelImpl implements IWebContentModel {
+
+    // 定义一个静态常量TAG，用于标识该内容解析模型所对应的网站地址，此处明确为http://www.yb3.cc，
+    // 便于在整个程序体系里知晓此解析逻辑是专门针对该站点的书籍内容而设计的。
     public static final String TAG = "http://www.yb3.cc";
 
+    /**
+     * 获取ContentYb3ModelImpl类的单例实例。
+     * 通过采用单例模式，确保在整个程序运行期间只有一个该类的实例存在，这样可以更有序地对解析该网站书籍内容这一功能进行统一管理与调用，
+     * 避免因创建多个实例可能导致的资源管理混乱、逻辑不一致等问题。
+     *
+     * @return 返回ContentYb3ModelImpl类的唯一实例对象。
+     */
     public static ContentYb3ModelImpl getInstance() {
         return new ContentYb3ModelImpl();
     }
 
+    /**
+     * 将构造函数私有化，这是实现单例模式的常规手段。把构造函数设为私有后，外部代码就无法直接通过构造函数来随意创建该类的多个实例了，
+     * 从而强制只能通过上面定义的getInstance方法来获取唯一的实例，以此保证单例模式的正确实现。
+     */
     private ContentYb3ModelImpl() {
 
     }
+
+    /**
+     * 实现IWebContentModel接口中定义的analyBookcontent方法，此方法承担着解析书籍内容的核心功能，处理逻辑相对复杂一些，
+     * 会根据网页内容的不同结构情况采用不同的提取和整理方式，以尽可能准确地获取书籍内容文本并进行格式化处理。
+     * 它接收两个参数，参数's'是包含网页内容（期望从中解析出书籍相关文本内容）的原始字符串，通常是通过网络请求获取到的HTML格式的网页文本；
+     * 参数'realUrl'表示书籍内容对应的真实网址，在当前代码实现中，暂时未体现出对该网址的深度利用，但其保留着用于后续可能的功能扩展的可能性。
+     *
+     * @param s 包含网页内容（大概率包含要解析的书籍文本等内容）的原始字符串，例如从网站服务器获取到的HTML页面文本，其中应包含了目标书籍的相关文本信息。
+     * @param realUrl 书籍内容对应的真实网址，当前代码里虽未充分借助其进行关键操作，但可作为后续拓展解析逻辑（比如依据网址中的特定信息来更精准地解析内容等）的基础。
+     * @return 返回经过处理后的书籍内容字符串，这个字符串经过了去除多余空格、空白字符等格式化操作，使其格式更加规整，更符合阅读和展示的常规要求。
+     * @throws Exception 如果在使用Jsoup解析HTML文档过程中出现问题（比如传入的HTML字符串格式不符合要求，导致无法正确解析等情况），
+     * 或者在后续对文本节点、元素进行查找、操作等环节出现错误（例如找不到预期的HTML元素对应的文本节点等），就会抛出异常。
+     */
     @Override
     public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库提供的parse方法，将传入的原始字符串（一般是HTML格式的网页内容）解析为一个Document对象。
+        // Document对象基于DOM（文档对象模型）结构来表示HTML文档，通过它能够按照HTML元素的标签、属性、层级关系等特征方便地查找、定位和操作网页中的各种元素，
+        // 从而帮助我们准确地提取出与书籍内容相关的部分。
         Document doc = Jsoup.parse(s);
+
+        // 通过调用Document对象的getElementById方法，依据元素的id属性查找网页中id为"content"的元素，
+        // 这里假设书籍内容所在的主要区域是在这个id为"content"的元素内部，这是定位书籍文本内容大致位置的第一步。
         Element contentE = doc.getElementById("content");
+
+        // 获取id为"content"的元素下包含的所有文本节点（TextNode）列表，尝试第一种提取书籍内容的方式，
+        // 即直接从该元素下的文本节点中获取文本内容，后续会判断这些文本节点是否符合要求来进行相应处理。
         List<TextNode> contentTextNodes = contentE.textNodes();
+
+        // 创建一个StringBuilder对象，用于高效地拼接整理后的书籍内容字符串。
+        // 相比于直接使用字符串相加操作，使用StringBuilder可以避免频繁创建新的字符串对象所带来的性能开销，
+        // 特别适合在像这样需要多次进行字符串拼接的场景下使用，有助于提升程序运行效率。
         StringBuilder content = new StringBuilder();
-        if(contentTextNodes!=null && contentTextNodes.size()>0){
+
+        // 首先判断获取到的文本节点列表是否不为空且包含至少一个文本节点，说明可以尝试从这些文本节点中提取内容。
+        if (contentTextNodes!= null && contentTextNodes.size() > 0) {
+            // 开始遍历获取到的所有文本节点（contentTextNodes），针对每个文本节点依次进行相应的处理和拼接操作，以构建最终的书籍内容字符串。
             for (int i = 0; i < contentTextNodes.size(); i++) {
+                // 获取当前文本节点的文本内容，然后调用trim方法去除文本内容两端的空白字符（包含空格、制表符、换行等），
+                // 再判断处理后的文本内容长度是否大于0，如果大于0，则说明该文本节点包含有实际有效的信息，需要将其添加到content这个StringBuilder对象中。
                 if (contentTextNodes.get(i).text().trim().length() > 0) {
+                    // 在每个有效的文本内容前面添加两个全角空格（\u3000）作为缩进格式，使得最终呈现出来的书籍内容在排版上更加美观，
+                    // 更符合一般阅读时对于段落格式的要求，便于读者区分不同的内容段落。
                     content.append("\u3000\u3000" + contentTextNodes.get(i).text().trim());
+                    // 如果当前文本节点不是遍历过程中的最后一个文本节点，那么就在添加的文本内容后面添加一个换行符（\r\n），
+                    // 以此实现不同文本节点内容之间的换行，让书籍内容在展示时更有条理，方便读者清晰地阅读和理解。
                     if (i < contentTextNodes.size() - 1) {
                         content.append("\r\n");
                     }
                 }
             }
-        }else{
+        } else {
+            // 如果通过第一种方式（直接从文本节点获取内容）没有获取到有效内容，说明网页结构可能不太一样，
+            // 则尝试另一种方式，获取id为"content"的元素的所有子元素（children），通过遍历这些子元素来提取可能存在的书籍内容文本。
             Elements contentEs = contentE.children();
+            // 开始遍历这些子元素（contentEs），尝试从每个子元素中提取和整理书籍内容文本。
             for (int i = 0; i < contentEs.size(); i++) {
-                if (contentEs.get(i).text().toString().trim().replaceAll("　","").length() > 0) {
+                // 获取当前子元素的文本内容，转换为字符串后调用trim方法去除两端空白字符，再将其中的全角空格（Unicode编码对应的“　”字符）替换为空字符串，
+                // 然后判断处理后的文本内容长度是否大于0，如果大于0，则说明该子元素可能包含有实际有效的信息，需要进一步处理来提取其中的书籍内容文本。
+                if (contentEs.get(i).text().toString().trim().replaceAll("　", "").length() > 0) {
+                    // 获取当前子元素下包含的所有文本节点（TextNode）列表，尝试从这些文本节点中提取更细化的书籍内容文本信息。
                     List<TextNode> tempTextNodes = contentEs.get(i).textNodes();
-                    if(tempTextNodes!=null && tempTextNodes.size()>0){
+                    // 判断获取到的文本节点列表是否不为空且包含至少一个文本节点，如果是，则进行相应的文本提取和整理操作。
+                    if (tempTextNodes!= null && tempTextNodes.size() > 0) {
+                        // 开始遍历当前子元素下的所有文本节点（tempTextNodes），针对每个文本节点依次进行相应的处理和拼接操作，以构建最终的书籍内容字符串。
                         for (int j = 0; j < tempTextNodes.size(); j++) {
+                            // 获取当前文本节点的文本内容，然后调用trim方法去除文本内容两端的空白字符（包含空格、制表符、换行等），
                             String temp = tempTextNodes.get(j).text().trim();
-                            temp = temp.replaceAll(" ","").replaceAll(" ","");
+                            // 进一步对处理后的文本内容进行清理，将其中的不间断空格（Unicode编码对应的“&nbsp;”字符，常用于HTML中表示空格占位等情况）以及普通空格都替换为空字符串，
+                            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+                            // 判断经过上述处理后的文本内容长度是否大于0，如果大于0，则说明该文本节点包含有实际有效的信息，需要将其添加到content这个StringBuilder对象中。
                             if (temp.length() > 0) {
+                                // 在每个有效的文本内容前面添加两个全角空格（\u3000）作为缩进格式，使得最终呈现出来的书籍内容在排版上更加美观，
+                                // 更符合一般阅读时对于段落格式的要求，便于读者区分不同的内容段落。
                                 content.append("\u3000\u3000" + temp);
+                                // 添加一个换行符（\r\n），实现不同文本节点内容之间的换行，让书籍内容在展示时更有条理。
                                 content.append("\r\n");
                             }
                         }
-                    }else{
-                        content.append("\u3000\u3000" + contentEs.get(i).text().trim().replaceAll("　",""));
+                    } else {
+                        // 如果当前子元素下没有文本节点（或者文本节点列表为空），但该子元素本身的文本内容经过前面处理后还有效，
+                        // 则直接将其文本内容（去除全角空格后）添加到content这个StringBuilder对象中，并添加一个换行符（\r\n），实现换行效果。
+                        content.append("\u3000\u3000" + contentEs.get(i).text().trim().replaceAll("　", ""));
                         content.append("\r\n");
                     }
                 }
             }
         }
+
+        // 最后，通过调用StringBuilder对象的toString方法，将经过一系列处理和拼接后存储在其中的书籍内容字符串转换为普通字符串格式，
+        // 并将这个整理好的书籍内容字符串返回，该返回值可以用于后续的各种操作，比如在阅读应用程序中展示给用户查看、保存到本地文件等。
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/ContentZhulangModelImpl.java

@@ -6,31 +6,88 @@ import org.jsoup.Jsoup;
 import org.jsoup.nodes.Document;
 import org.jsoup.select.Elements;
 
-public class ContentZhulangModelImpl implements IWebContentModel{
+/**
+ * ContentZhulangModelImpl类实现了IWebContentModel接口，其主要功能是针对来自特定网站（由TAG标识为http://book.zhulang.com）
+ * 的书籍内容进行解析处理，从网页结构中提取出相应文本内容，并经过格式整理后返回，以满足后续诸如在阅读应用中展示、存储等相关需求。
+ */
+public class ContentZhulangModelImpl implements IWebContentModel {
+
+    // 定义一个静态常量TAG，用于标识该内容解析模型所对应的网站地址，此处明确为http://book.zhulang.com，
+    // 便于在整个程序体系里知晓此解析逻辑是专门针对该站点的书籍内容而设计的。
     public static final String TAG = "http://book.zhulang.com";
 
+    /**
+     * 获取ContentZhulangModelImpl类的单例实例。
+     * 通过采用单例模式，确保在整个程序运行期间只有一个该类的实例存在，这样可以更有序地对解析该网站书籍内容这一功能进行统一管理与调用，
+     * 避免因创建多个实例可能导致的资源管理混乱、逻辑不一致等问题。
+     *
+     * @return 返回ContentZhulangModelImpl类的唯一实例对象。
+     */
     public static ContentZhulangModelImpl getInstance() {
         return new ContentZhulangModelImpl();
     }
 
+    /**
+     * 将构造函数私有化，这是实现单例模式的常规手段。把构造函数设为私有后，外部代码就无法直接通过构造函数来随意创建该类的多个实例了，
+     * 从而强制只能通过上面定义的getInstance方法来获取唯一的实例，以此保证单例模式的正确实现。
+     */
     private ContentZhulangModelImpl() {
 
     }
+
+    /**
+     * 实现IWebContentModel接口中定义的analyBookcontent方法，此方法承担着解析书籍内容的核心功能。
+     * 它接收两个参数，参数's'是包含网页内容（期望从中解析出书籍相关文本内容）的原始字符串，通常是通过网络请求获取到的HTML格式的网页文本；
+     * 参数'realUrl'表示书籍内容对应的真实网址，在当前代码实现中，暂时未体现出对该网址的深度利用，但其保留着用于后续可能的功能扩展的可能性。
+     *
+     * @param s 包含网页内容（大概率包含要解析的书籍文本等内容）的原始字符串，例如从网站服务器获取到的HTML页面文本，其中应包含了目标书籍的相关文本信息。
+     * @param realUrl 书籍内容对应的真实网址，当前代码里虽未充分借助其进行关键操作，但可作为后续拓展解析逻辑（比如依据网址中的特定信息来更精准地解析内容等）的基础。
+     * @return 返回经过处理后的书籍内容字符串，这个字符串经过了去除多余空格、空白字符等格式化操作，使其格式更加规整，更符合阅读和展示的常规要求。
+     * @throws Exception 如果在使用Jsoup解析HTML文档过程中出现问题（比如传入的HTML字符串格式不符合要求，导致无法正确解析等情况），
+     * 或者在后续对提取的内容元素进行操作等环节出现错误（例如找不到预期的HTML元素等），就会抛出异常。
+     */
     @Override
     public String analyBookcontent(String s, String realUrl) throws Exception {
+        // 使用Jsoup库提供的parse方法，将传入的原始字符串（一般是HTML格式的网页内容）解析为一个Document对象。
+        // Document对象基于DOM（文档对象模型）结构来表示HTML文档，通过它能够按照HTML元素的标签、属性、层级关系等特征方便地查找、定位和操作网页中的各种元素，
+        // 从而帮助我们准确地提取出与书籍内容相关的部分。
         Document doc = Jsoup.parse(s);
+
+        // 通过调用Document对象的getElementById方法，依据元素的id属性查找网页中id为"read-content"的元素，
+        // 然后获取该元素的所有子元素（children），并将这些子元素存储在Elements集合中，这里假设书籍内容是分布在这些子元素当中，
+        // 通过后续遍历这些子元素来提取具体的文本内容。
         Elements contentEs = doc.getElementById("read-content").children();
+
+        // 创建一个StringBuilder对象，用于高效地拼接整理后的书籍内容字符串。
+        // 相比于直接使用字符串相加操作，使用StringBuilder可以避免频繁创建新的字符串对象所带来的性能开销，
+        // 特别适合在像这样需要多次进行字符串拼接的场景下使用，有助于提升程序运行效率。
         StringBuilder content = new StringBuilder();
-        for (int i = 3; i < contentEs.size()-1; i++) {
+
+        // 开始遍历获取到的子元素（contentEs），不过这里注意起始索引为3，结束索引为contentEs.size() - 1，
+        // 说明可能跳过了前面几个特定的元素（可能是网页中一些非书籍正文内容的元素，比如标题、导航栏之类的相关元素），
+        // 同时也排除了最后一个元素（可能有一些特殊格式或者不属于正文内容的元素），仅对中间认为是书籍正文内容的子元素进行处理。
+        for (int i = 3; i < contentEs.size() - 1; i++) {
+            // 获取当前子元素的文本内容，然后调用trim方法去除文本内容两端的空白字符（包含空格、制表符、换行等），
+            // 得到相对纯净、没有多余空白干扰的文本内容，方便后续更好地进行处理和展示。
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ","").replaceAll(" ","");
+            // 进一步对处理后的文本内容进行清理，将其中的不间断空格（Unicode编码对应的“&nbsp;”字符，常用于HTML中表示空格占位等情况）以及普通空格都替换为空字符串，
+            // 这样可以让文本的格式更加规整，避免因多余的空白间隔而影响阅读体验以及内容展示的美观性。
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            // 判断经过上述处理后的文本内容长度是否大于0，如果大于0，则说明该子元素包含有实际有效的信息，需要将其添加到content这个StringBuilder对象中。
             if (temp.length() > 0) {
+                // 在每个有效的文本内容前面添加两个全角空格（\u3000）作为缩进格式，使得最终呈现出来的书籍内容在排版上更加美观，
+                // 更符合一般阅读时对于段落格式的要求，便于读者区分不同的内容段落。
                 content.append("\u3000\u3000" + temp);
+                // 如果当前子元素不是遍历过程中的最后一个子元素，那么就在添加的文本内容后面添加一个换行符（\r\n），
+                // 以此实现不同子元素内容之间的换行，让书籍内容在展示时更有条理，方便读者清晰地阅读和理解。
                 if (i < contentEs.size() - 1) {
                     content.append("\r\n");
                 }
             }
         }
+
+        // 最后，通过调用StringBuilder对象的toString方法，将经过一系列处理和拼接后存储在其中的书籍内容字符串转换为普通字符串格式，
+        // 并将这个整理好的书籍内容字符串返回，该返回值可以用于后续的各种操作，比如在阅读应用程序中展示给用户查看、保存到本地文件等。
         return content.toString();
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/GxwztvBookModelImpl.java

@@ -33,32 +33,61 @@ import io.reactivex.android.schedulers.AndroidSchedulers;
 import io.reactivex.functions.Function;
 import io.reactivex.schedulers.Schedulers;
 
+/**
+ * GxwztvBookModelImpl类继承自MBaseModelImpl并实现了IGxwztvBookModel接口，主要用于与特定网站（由TAG标识为http://www.gxwztv.com）
+ * 进行交互，实现诸如获取网站主页信息、搜索书籍、获取书籍详情、章节列表以及章节内容等功能，通过解析网页HTML结构提取相关数据，
+ * 并利用RxJava进行异步操作和数据流转处理，最终将处理好的数据以合适的形式返回给调用者，应用于阅读相关的业务场景中。
+ */
 public class GxwztvBookModelImpl extends MBaseModelImpl implements IGxwztvBookModel {
+
+    // 定义一个静态常量TAG，用于标识该模型所对应的网站地址，此处明确为http://www.gxwztv.com，
+    // 便于在整个程序体系里知晓此模型相关的网络操作、数据解析等逻辑是针对该站点而设计的。
     public static final String TAG = "http://www.gxwztv.com";
 
+    /**
+     * 获取GxwztvBookModelImpl类的单例实例。
+     * 通过采用单例模式，确保在整个程序运行期间只有一个该类的实例存在，这样可以更有序地对与该网站交互、解析相关数据等功能进行统一管理与调用，
+     * 避免因创建多个实例可能导致的资源管理混乱、逻辑不一致等问题。
+     *
+     * @return 返回GxwztvBookModelImpl类的唯一实例对象。
+     */
     public static GxwztvBookModelImpl getInstance() {
         return new GxwztvBookModelImpl();
     }
 
-
     /**
      * 获取主页信息
+     * 此方法通过网络请求获取网站主页数据，先尝试将获取到的数据缓存起来（如果数据有效且缓存对象不为空），
+     * 然后调用解析主页数据的方法对获取到的数据进行解析处理，最终返回一个包含解析后主页信息的Observable对象，
+     * 方便后续在RxJava的响应式编程模式下进行订阅和处理。
+     *
+     * @param aCache 用于缓存数据的ACache对象，可将获取到的主页数据缓存起来以便后续快速访问，减少重复网络请求。
+     * @return 返回一个Observable对象，其发射类型为LibraryBean，包含了解析后的网站主页相关信息，例如最新书籍、各类书籍分类列表等。
      */
     @Override
     public Observable<LibraryBean> getLibraryData(final ACache aCache) {
-        return getRetrofitObject(TAG).create(IGxwztvApi.class).getLibraryData("").flatMap(new Function<String, ObservableSource<LibraryBean>>() {
-            @Override
-            public ObservableSource<LibraryBean> apply(String s) throws Exception {
-                if (s != null && s.length() > 0 && aCache != null) {
-                    aCache.put(LibraryPresenterImpl.LIBRARY_CACHE_KEY, s);
-                }
-                return analyLibraryData(s);
-            }
-        });
+        return getRetrofitObject(TAG).create(IGxwztvApi.class).getLibraryData("")
+                // 使用flatMap操作符，将网络请求获取到的字符串数据进行进一步处理，先尝试缓存数据，再进行解析操作
+                .flatMap(new Function<String, ObservableSource<LibraryBean>>() {
+                    @Override
+                    public ObservableSource<LibraryBean> apply(String s) throws Exception {
+                        // 如果获取到的数据不为空且长度大于0，并且缓存对象不为空，则将数据存入缓存，缓存的键由LibraryPresenterImpl.LIBRARY_CACHE_KEY指定
+                        if (s!= null && s.length() > 0 && aCache!= null) {
+                            aCache.put(LibraryPresenterImpl.LIBRARY_CACHE_KEY, s);
+                        }
+                        // 调用解析主页数据的方法，将获取到的数据传入进行解析，并返回解析后的Observable对象
+                        return analyLibraryData(s);
+                    }
+                });
     }
 
     /**
      * 解析主页数据
+     * 此方法在Observable的订阅逻辑中被调用，用于解析从网站主页获取到的HTML格式数据，从中提取出如最新书籍、不同分类书籍等信息，
+     * 并将这些信息封装到LibraryBean对象中，最后通过ObservableEmitter发射出去，供订阅者接收处理。
+     *
+     * @param data 包含网站主页内容的原始字符串数据，通常为HTML格式，是从网络请求获取到的主页信息。
+     * @return 返回一个Observable对象，其发射类型为LibraryBean，包含了解析后的主页相关信息。
      */
     @Override
     public Observable<LibraryBean> analyLibraryData(final String data) {
@@ -66,24 +95,35 @@ public class GxwztvBookModelImpl extends MBaseModelImpl implements IGxwztvBookMo
             @Override
             public void subscribe(ObservableEmitter<LibraryBean> e) throws Exception {
                 LibraryBean result = new LibraryBean();
+                // 使用Jsoup库将传入的HTML格式字符串数据解析为Document对象，以便后续按照DOM结构查找和提取元素及内容
                 Document doc = Jsoup.parse(data);
+                // 通过元素的类名获取名为"container"的元素，这里假设主页的主要内容都在这个元素内部，是后续提取各种信息的基础元素
                 Element contentE = doc.getElementsByClass("container").get(0);
-                //解析最新书籍
+
+                // 解析最新书籍信息
+                // 获取所有类名为"list-group-item text-nowrap modal-open"的元素，这些元素被认为包含了最新书籍的相关信息
                 Elements newBookEs = contentE.getElementsByClass("list-group-item text-nowrap modal-open");
                 List<LibraryNewBookBean> libraryNewBooks = new ArrayList<LibraryNewBookBean>();
                 for (int i = 0; i < newBookEs.size(); i++) {
+                    // 从每个包含最新书籍信息的元素中获取<a>标签元素，通常<a>标签包含了书籍的链接、书名等关键信息
                     Element itemE = newBookEs.get(i).getElementsByTag("a").get(0);
+                    // 创建一个LibraryNewBookBean对象，将书名、书籍链接等信息封装进去，其中链接是在TAG基础上拼接获取到的相对链接
                     LibraryNewBookBean item = new LibraryNewBookBean(itemE.text(), TAG + itemE.attr("href"), TAG, "gxwztv.com");
                     libraryNewBooks.add(item);
                 }
                 result.setLibraryNewBooks(libraryNewBooks);
-                //////////////////////////////////////////////////////////////////////
+
+                // 解析不同分类书籍信息，先初始化一个空的列表用于存放不同分类的书籍列表信息
                 List<LibraryKindBookListBean> kindBooks = new ArrayList<LibraryKindBookListBean>();
-                //解析男频女频
+
+                // 解析男频女频分类书籍信息
+                // 获取所有类名为"col-xs-12"的元素，这里假设这些元素包含了男频女频相关的分类信息
                 Elements hotEs = contentE.getElementsByClass("col-xs-12");
                 for (int i = 1; i < hotEs.size(); i++) {
                     LibraryKindBookListBean kindItem = new LibraryKindBookListBean();
+                    // 获取分类名称，即通过类名为"panel-title"的元素获取其文本内容作为分类名
                     kindItem.setKindName(hotEs.get(i).getElementsByClass("panel-title").get(0).text());
+                    // 获取该分类下的书籍元素列表，通过先获取类名为"panel-body"的元素，再获取其内部的<li>标签元素来定位书籍信息所在元素
                     Elements bookEs = hotEs.get(i).getElementsByClass("panel-body").get(0).getElementsByTag("li");
 
                     List<SearchBookBean> books = new ArrayList<SearchBookBean>();
@@ -91,47 +131,59 @@ public class GxwztvBookModelImpl extends MBaseModelImpl implements IGxwztvBookMo
                         SearchBookBean searchBookBean = new SearchBookBean();
                         searchBookBean.setOrigin("gxwztv.com");
                         searchBookBean.setTag(TAG);
+                        // 获取书籍名称，通过获取<span>标签的文本内容作为书名
                         searchBookBean.setName(bookEs.get(j).getElementsByTag("span").get(0).text());
+                        // 获取书籍详情链接，同样是在TAG基础上拼接相对链接
                         searchBookBean.setNoteUrl(TAG + bookEs.get(j).getElementsByTag("a").get(0).attr("href"));
+                        // 获取书籍封面链接，通过获取<img>标签的src属性值作为封面链接
                         searchBookBean.setCoverUrl(bookEs.get(j).getElementsByTag("img").get(0).attr("src"));
                         books.add(searchBookBean);
                     }
                     kindItem.setBooks(books);
                     kindBooks.add(kindItem);
                 }
-                //解析部分分类推荐
+
+                // 解析部分分类推荐书籍信息
+                // 获取所有类名为"panel panel-info index-category-qk"的元素，这些元素包含了部分分类推荐的相关信息
                 Elements kindEs = contentE.getElementsByClass("panel panel-info index-category-qk");
                 for (int i = 0; i < kindEs.size(); i++) {
                     LibraryKindBookListBean kindItem = new LibraryKindBookListBean();
                     kindItem.setKindName(kindEs.get(i).getElementsByClass("panel-title").get(0).text());
+                    // 获取分类链接，同样是在TAG基础上拼接相对链接
                     kindItem.setKindUrl(TAG + kindEs.get(i).getElementsByClass("listMore").get(0).getElementsByTag("a").get(0).attr("href"));
 
                     List<SearchBookBean> books = new ArrayList<SearchBookBean>();
+                    // 获取第一个推荐书籍的元素，这里通过<dl>标签来定位
                     Element firstBookE = kindEs.get(i).getElementsByTag("dl").get(0);
                     SearchBookBean firstBook = new SearchBookBean();
                     firstBook.setTag(TAG);
                     firstBook.setOrigin("gxwztv.com");
+                    // 获取书籍名称，通过获取<a>标签的文本内容作为书名（这里取第二个<a>标签的文本，可能是根据网页结构来确定的具体书名所在位置）
                     firstBook.setName(firstBookE.getElementsByTag("a").get(1).text());
+                    // 获取书籍详情链接，在TAG基础上拼接相对链接
                     firstBook.setNoteUrl(TAG + firstBookE.getElementsByTag("a").get(0).attr("href"));
+                    // 获取书籍封面链接，通过获取<a>标签下的<img>标签的src属性值作为封面链接
                     firstBook.setCoverUrl(firstBookE.getElementsByTag("a").get(0).getElementsByTag("img").get(0).attr("src"));
                     firstBook.setKind(kindItem.getKindName());
                     books.add(firstBook);
 
+                    // 获取其他推荐书籍的元素列表，通过类名为"book_textList"的元素下的<li>标签来定位
                     Elements otherBookEs = kindEs.get(i).getElementsByClass("book_textList").get(0).getElementsByTag("li");
                     for (int j = 0; j < otherBookEs.size(); j++) {
                         SearchBookBean item = new SearchBookBean();
                         item.setTag(TAG);
                         item.setOrigin("gxwztv.com");
                         item.setKind(kindItem.getKindName());
-                        item.setNoteUrl(TAG+otherBookEs.get(j).getElementsByTag("a").get(0).attr("href"));
+                        item.setNoteUrl(TAG + otherBookEs.get(j).getElementsByTag("a").get(0).attr("href"));
                         item.setName(otherBookEs.get(j).getElementsByTag("a").get(0).text());
                         books.add(item);
                     }
                     kindItem.setBooks(books);
                     kindBooks.add(kindItem);
                 }
-                //////////////
+
                 result.setKindBooks(kindBooks);
+                // 通过ObservableEmitter发射解析好的LibraryBean对象，包含了主页上的各种书籍相关信息
                 e.onNext(result);
                 e.onComplete();
             }
@@ -139,33 +191,58 @@ public class GxwztvBookModelImpl extends MBaseModelImpl implements IGxwztvBookMo
     }
 
     /////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    /**
+     * 搜索书籍功能
+     * 根据传入的搜索内容和页码，向网站发起搜索书籍的网络请求，然后调用解析搜索书籍结果的方法对返回的数据进行解析，
+     * 最终返回一个包含搜索结果（以SearchBookBean列表形式表示）的Observable对象，供订阅者接收处理搜索到的书籍信息。
+     *
+     * @param content 用于搜索书籍的关键字内容，指定要搜索的书籍相关的关键词，比如书名、作者等。
+     * @param page 搜索结果的页码，用于获取指定页码的搜索结果数据，实现分页查询功能。
+     * @return 返回一个Observable对象，其发射类型为List<SearchBookBean>，包含了搜索到的符合条件的书籍信息列表。
+     */
     @Override
     public Observable<List<SearchBookBean>> searchBook(String content, int page) {
-        return getRetrofitObject(TAG).create(IGxwztvApi.class).searchBook(content, page).flatMap(new Function<String, ObservableSource<List<SearchBookBean>>>() {
-            @Override
-            public ObservableSource<List<SearchBookBean>> apply(String s) throws Exception {
-                return analySearchBook(s);
-            }
-        });
+        return getRetrofitObject(TAG).create(IGxwztvApi.class).searchBook(content, page)
+                .flatMap(new Function<String, ObservableSource<List<SearchBookBean>>>() {
+                    @Override
+                    public ObservableSource<List<SearchBookBean>> apply(String s) throws Exception {
+                        return analySearchBook(s);
+                    }
+                });
     }
 
+    /**
+     * 解析搜索书籍结果
+     * 此方法在搜索书籍的网络请求返回数据后被调用，用于解析获取到的HTML格式的搜索结果数据，从中提取出每本搜索到的书籍的相关信息，
+     * 如书名、作者、链接等，并将这些信息封装到SearchBookBean对象中，最后组成列表通过ObservableEmitter发射出去，供订阅者接收处理。
+     *
+     * @param s 包含搜索书籍结果内容的原始字符串数据，通常为HTML格式，是从网络请求获取到的搜索结果信息。
+     * @return 返回一个Observable对象，其发射类型为List<SearchBookBean>，包含了解析后的搜索到的书籍信息列表。
+     */
     public Observable<List<SearchBookBean>> analySearchBook(final String s) {
         return Observable.create(new ObservableOnSubscribe<List<SearchBookBean>>() {
             @Override
             public void subscribe(ObservableEmitter<List<SearchBookBean>> e) throws Exception {
                 try {
                     Document doc = Jsoup.parse(s);
+                    // 获取id为"novel-list"的元素下类名为"list-group-item clearfix"的元素列表，这里假设这些元素包含了搜索到的每本书籍的相关信息
                     Elements booksE = doc.getElementById("novel-list").getElementsByClass("list-group-item clearfix");
-                    if (null != booksE && booksE.size() >= 2) {
+                    if (null!= booksE && booksE.size() >= 2) {
                         List<SearchBookBean> books = new ArrayList<SearchBookBean>();
                         for (int i = 1; i < booksE.size(); i++) {
                             SearchBookBean item = new SearchBookBean();
                             item.setTag(TAG);
+                            // 获取书籍作者信息，通过类名为"col-xs-2"的元素获取其文本内容作为作者名
                             item.setAuthor(booksE.get(i).getElementsByClass("col-xs-2").get(0).text());
+                            // 获取书籍分类信息，通过类名为"col-xs-1"的元素获取其文本内容作为分类名
                             item.setKind(booksE.get(i).getElementsByClass("col-xs-1").get(0).text());
+                            // 获取书籍最后章节信息，通过类名为"col-xs-4"的元素下的<a>标签获取其文本内容作为最后章节名
                             item.setLastChapter(booksE.get(i).getElementsByClass("col-xs-4").get(0).getElementsByTag("a").get(0).text());
                             item.setOrigin("gxwztv.com");
+                            // 获取书籍名称，通过类名为"col-xs-3"的元素下的<a>标签获取其文本内容作为书名
                             item.setName(booksE.get(i).getElementsByClass("col-xs-3").get(0).getElementsByTag("a").get(0).text());
+                            // 获取书籍详情链接，在TAG基础上拼接相对链接
                             item.setNoteUrl(TAG + booksE.get(i).getElementsByClass("col-xs-3").get(0).getElementsByTag("a").get(0).attr("href"));
                             item.setCoverUrl("noimage");
                             books.add(item);
@@ -183,171 +260,8 @@ public class GxwztvBookModelImpl extends MBaseModelImpl implements IGxwztvBookMo
         });
     }
 
-    /////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    @Override
-    public Observable<BookShelfBean> getBookInfo(final BookShelfBean bookShelfBean) {
-        return getRetrofitObject(TAG).create(IGxwztvApi.class).getBookInfo(bookShelfBean.getNoteUrl().replace(TAG, "")).flatMap(new Function<String, ObservableSource<BookShelfBean>>() {
-            @Override
-            public ObservableSource<BookShelfBean> apply(String s) throws Exception {
-                return analyBookInfo(s, bookShelfBean);
-            }
-        });
-    }
-
-    private Observable<BookShelfBean> analyBookInfo(final String s, final BookShelfBean bookShelfBean) {
-        return Observable.create(new ObservableOnSubscribe<BookShelfBean>() {
-            @Override
-            public void subscribe(ObservableEmitter<BookShelfBean> e) throws Exception {
-                bookShelfBean.setTag(TAG);
-                bookShelfBean.setBookInfoBean(analyBookinfo(s, bookShelfBean.getNoteUrl()));
-                e.onNext(bookShelfBean);
-                e.onComplete();
-            }
-        });
-    }
-
-    private BookInfoBean analyBookinfo(String s, String novelUrl) {
-        BookInfoBean bookInfoBean = new BookInfoBean();
-        bookInfoBean.setNoteUrl(novelUrl);   //id
-        bookInfoBean.setTag(TAG);
-        Document doc = Jsoup.parse(s);
-        Element resultE = doc.getElementsByClass("panel panel-warning").get(0);
-        bookInfoBean.setCoverUrl(resultE.getElementsByClass("panel-body").get(0).getElementsByClass("img-thumbnail").get(0).attr("src"));
-        bookInfoBean.setName(resultE.getElementsByClass("active").get(0).text());
-        bookInfoBean.setAuthor(resultE.getElementsByClass("col-xs-12 list-group-item no-border").get(0).getElementsByTag("small").get(0).text());
-        Element introduceE = resultE.getElementsByClass("panel panel-default mt20").get(0);
-        String introduce = "";
-        if (introduceE.getElementById("all") != null) {
-            introduce = introduceE.getElementById("all").text().replace("[收起]", "");
-        } else {
-            introduce = introduceE.getElementById("shot").text();
-        }
-        bookInfoBean.setIntroduce("\u3000\u3000" + introduce);
-        bookInfoBean.setChapterUrl(TAG + resultE.getElementsByClass("list-group-item tac").get(0).getElementsByTag("a").get(0).attr("href"));
-        bookInfoBean.setOrigin("gxwztv.com");
-        return bookInfoBean;
-    }
-
-    /////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    @Override
-    public void getChapterList(final BookShelfBean bookShelfBean, final OnGetChapterListListener getChapterListListener) {
-        getRetrofitObject(TAG).create(IGxwztvApi.class).getChapterList(bookShelfBean.getBookInfoBean().getChapterUrl().replace(TAG, "")).flatMap(new Function<String, ObservableSource<WebChapterBean<BookShelfBean>>>() {
-            @Override
-            public ObservableSource<WebChapterBean<BookShelfBean>> apply(String s) throws Exception {
-                return analyChapterList(s, bookShelfBean);
-            }
-        })
-                .subscribeOn(Schedulers.io())
-                .observeOn(AndroidSchedulers.mainThread())
-                .subscribe(new SimpleObserver<WebChapterBean<BookShelfBean>>() {
-                    @Override
-                    public void onNext(WebChapterBean<BookShelfBean> value) {
-                        if (getChapterListListener != null) {
-                            getChapterListListener.success(value.getData());
-                        }
-                    }
-
-                    @Override
-                    public void onError(Throwable e) {
-                        e.printStackTrace();
-                        if (getChapterListListener != null) {
-                            getChapterListListener.error();
-                        }
-                    }
-                });
-    }
-
-    private Observable<WebChapterBean<BookShelfBean>> analyChapterList(final String s, final BookShelfBean bookShelfBean) {
-        return Observable.create(new ObservableOnSubscribe<WebChapterBean<BookShelfBean>>() {
-            @Override
-            public void subscribe(ObservableEmitter<WebChapterBean<BookShelfBean>> e) throws Exception {
-                bookShelfBean.setTag(TAG);
-                WebChapterBean<List<ChapterListBean>> temp = analyChapterlist(s, bookShelfBean.getNoteUrl());
-                bookShelfBean.getBookInfoBean().setChapterlist(temp.getData());
-                e.onNext(new WebChapterBean<BookShelfBean>(bookShelfBean, temp.getNext()));
-                e.onComplete();
-            }
-        });
-    }
-
-    private WebChapterBean<List<ChapterListBean>> analyChapterlist(String s, String novelUrl) {
-        Document doc = Jsoup.parse(s);
-        Elements chapterlist = doc.getElementById("chapters-list").getElementsByTag("a");
-        List<ChapterListBean> chapterBeans = new ArrayList<ChapterListBean>();
-        for (int i = 0; i < chapterlist.size(); i++) {
-            ChapterListBean temp = new ChapterListBean();
-            temp.setDurChapterUrl(TAG + chapterlist.get(i).attr("href"));   //id
-            temp.setDurChapterIndex(i);
-            temp.setDurChapterName(chapterlist.get(i).text());
-            temp.setNoteUrl(novelUrl);
-            temp.setTag(TAG);
-
-            chapterBeans.add(temp);
-        }
-        Boolean next = false;
-        return new WebChapterBean<List<ChapterListBean>>(chapterBeans, next);
-    }
-
-    /////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    @Override
-    public Observable<BookContentBean> getBookContent(final String durChapterUrl, final int durChapterIndex) {
-        return getRetrofitObject(TAG).create(IGxwztvApi.class).getBookContent(durChapterUrl.replace(TAG, "")).flatMap(new Function<String, ObservableSource<BookContentBean>>() {
-            @Override
-            public ObservableSource<BookContentBean> apply(String s) throws Exception {
-                return analyBookContent(s, durChapterUrl, durChapterIndex);
-            }
-        });
-    }
-
-    private Observable<BookContentBean> analyBookContent(final String s, final String durChapterUrl, final int durChapterIndex) {
-        return Observable.create(new ObservableOnSubscribe<BookContentBean>() {
-            @Override
-            public void subscribe(ObservableEmitter<BookContentBean> e) throws Exception {
-                BookContentBean bookContentBean = new BookContentBean();
-                bookContentBean.setDurChapterIndex(durChapterIndex);
-                bookContentBean.setDurChapterUrl(durChapterUrl);
-                bookContentBean.setTag(TAG);
-                try {
-                    Document doc = Jsoup.parse(s);
-                    List<TextNode> contentEs = doc.getElementById("txtContent").textNodes();
-                    StringBuilder content = new StringBuilder();
-                    for (int i = 0; i < contentEs.size(); i++) {
-                        String temp = contentEs.get(i).text().trim();
-                        temp = temp.replaceAll(" ", "").replaceAll(" ", "");
-                        if (temp.length() > 0) {
-                            content.append("\u3000\u3000" + temp);
-                            if (i < contentEs.size() - 1) {
-                                content.append("\r\n");
-                            }
-                        }
-                    }
-                    bookContentBean.setDurCapterContent(content.toString());
-                    bookContentBean.setRight(true);
-                } catch (Exception ex) {
-                    ex.printStackTrace();
-                    ErrorAnalyContentManager.getInstance().writeNewErrorUrl(durChapterUrl);
-                    bookContentBean.setDurCapterContent(durChapterUrl.substring(0, durChapterUrl.indexOf('/', 8)) + "站点暂时不支持解析，请反馈给Monke QQ:1105075896,半小时内解决，超级效率的程序员");
-                    bookContentBean.setRight(false);
-                }
-                e.onNext(bookContentBean);
-                e.onComplete();
-            }
-        });
-    }
-
-    /////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-    /**
-     * 获取分类书籍
-     */
-    @Override
-    public Observable<List<SearchBookBean>> getKindBook(String url, int page) {
-        url = url + page + ".htm";
-        return getRetrofitObject(GxwztvBookModelImpl.TAG).create(IGxwztvApi.class).getKindBooks(url.replace(GxwztvBookModelImpl.TAG, "")).flatMap(new Function<String, ObservableSource<List<SearchBookBean>>>() {
-            @Override
-            public ObservableSource<List<SearchBookBean>> apply(String s) throws Exception {
-                return analySearchBook(s);
-            }
-        });
-    }
-}
+/**
+ * 获取书籍详情信息
+ * 根据传入的BookShelfBean

app/src/main/java/com/monke/monkeybook/model/impl/ImportBookModelImpl.java

@@ -25,36 +25,68 @@ import io.reactivex.Observable;
 import io.reactivex.ObservableEmitter;
 import io.reactivex.ObservableOnSubscribe;
 
+/**
+ * ImportBookModelImpl类继承自MBaseModelImpl并实现了IImportBookModel接口，主要用于实现导入本地书籍的相关功能。
+ * 它可以对本地书籍文件进行处理，例如计算文件的MD5值来判断书籍是否已存在，解析书籍内容以提取章节信息等，
+ * 并将相关书籍信息存储到数据库中，同时通过RxJava的Observable返回处理后的结果，方便在响应式编程环境下进行后续操作。
+ */
 public class ImportBookModelImpl extends MBaseModelImpl implements IImportBookModel {
 
+    /**
+     * 获取ImportBookModelImpl类的单例实例。
+     * 通过采用单例模式，确保在整个程序运行期间只有一个该类的实例存在，便于统一管理和调用导入本地书籍相关的功能逻辑，
+     * 避免因创建多个实例可能导致的资源管理混乱、逻辑不一致等问题。
+     *
+     * @return 返回ImportBookModelImpl类的唯一实例对象。
+     */
     public static ImportBookModelImpl getInstance() {
         return new ImportBookModelImpl();
     }
 
+    /**
+     * 导入书籍的核心方法，接收一个本地书籍文件对象作为参数，通过一系列操作处理该书籍文件，
+     * 包括计算文件MD5值判断是否为新书籍、提取书籍基本信息、解析章节内容并保存到数据库等，
+     * 最后将处理后的包含书籍相关信息的LocBookShelfBean对象通过Observable发射出去，供订阅者接收处理。
+     *
+     * @param book 代表本地书籍的File对象，指定要导入的本地书籍文件。
+     * @return 返回一个Observable对象，其发射类型为LocBookShelfBean，包含了导入书籍后的相关信息，如是否为新书以及书籍的详细信息等。
+     */
     @Override
     public Observable<LocBookShelfBean> importBook(final File book) {
         return Observable.create(new ObservableOnSubscribe<LocBookShelfBean>() {
             @Override
             public void subscribe(ObservableEmitter<LocBookShelfBean> e) throws Exception {
+                // 创建MessageDigest实例，用于计算文件的MD5值，MD5值可作为书籍文件的唯一标识来判断是否重复导入等情况
                 MessageDigest md = MessageDigest.getInstance("MD5");
+                // 创建文件输入流，用于读取书籍文件内容
                 FileInputStream in = new FileInputStream(book);
                 byte[] buffer = new byte[2048];
                 int len;
-                while ((len = in.read(buffer, 0, 2048)) != -1) {
+                // 循环读取文件内容，每次读取指定长度的数据，并将其更新到MessageDigest中用于计算MD5值
+                while ((len = in.read(buffer, 0, 2048))!= -1) {
                     md.update(buffer, 0, len);
                 }
+                // 关闭文件输入流，释放资源
                 in.close();
                 in = null;
 
+                // 将计算得到的MD5值转换为十六进制字符串形式，方便后续作为标识使用
                 String md5 = new BigInteger(1, md.digest()).toString(16);
                 BookShelfBean bookShelfBean = null;
-                List<BookShelfBean> temp = DbHelper.getInstance().getmDaoSession().getBookShelfBeanDao().queryBuilder().where(BookShelfBeanDao.Properties.NoteUrl.eq(md5)).build().list();
+                // 从数据库中查询是否已存在具有相同MD5值（即相同书籍文件）的记录，通过构建查询条件并执行查询获取结果列表
+                List<BookShelfBean> temp = DbHelper.getInstance().getmDaoSession().getBookShelfBeanDao().queryBuilder()
+                        .where(BookShelfBeanDao.Properties.NoteUrl.eq(md5)).build().list();
+                // 标记书籍是否为新导入的，初始化为true，表示默认是新书
                 Boolean isNew = true;
-                if (temp!=null && temp.size()>0) {
+                // 如果查询到的结果列表不为空且包含至少一个元素，说明书籍已存在，不是新书
+                if (temp!= null && temp.size() > 0) {
                     isNew = false;
                     bookShelfBean = temp.get(0);
-                    bookShelfBean.setBookInfoBean(DbHelper.getInstance().getmDaoSession().getBookInfoBeanDao().queryBuilder().where(BookInfoBeanDao.Properties.NoteUrl.eq(bookShelfBean.getNoteUrl())).build().list().get(0));
+                    // 从数据库中获取对应的书籍详情信息，并设置到bookShelfBean对象中，确保书籍相关信息的完整性
+                    bookShelfBean.setBookInfoBean(DbHelper.getInstance().getmDaoSession().getBookInfoBeanDao().queryBuilder()
+                            .where(BookInfoBeanDao.Properties.NoteUrl.eq(bookShelfBean.getNoteUrl())).build().list().get(0));
                 } else {
+                    // 如果是新书，则创建一个新的BookShelfBean对象，用于存储书籍的基本信息
                     bookShelfBean = new BookShelfBean();
                     bookShelfBean.setFinalDate(System.currentTimeMillis());
                     bookShelfBean.setDurChapter(0);
@@ -62,6 +94,7 @@ public class ImportBookModelImpl extends MBaseModelImpl implements IImportBookMo
                     bookShelfBean.setTag(BookShelfBean.LOCAL_TAG);
                     bookShelfBean.setNoteUrl(md5);
 
+                    // 设置书籍详情信息中的作者、书名等基本信息，书名通过去除文件扩展名来获取，作者暂设为“佚名”
                     bookShelfBean.getBookInfoBean().setAuthor("佚名");
                     bookShelfBean.getBookInfoBean().setName(book.getName().replace(".txt", "").replace(".TXT", ""));
                     bookShelfBean.getBookInfoBean().setFinalRefreshData(System.currentTimeMillis());
@@ -69,17 +102,31 @@ public class ImportBookModelImpl extends MBaseModelImpl implements IImportBookMo
                     bookShelfBean.getBookInfoBean().setNoteUrl(md5);
                     bookShelfBean.getBookInfoBean().setTag(BookShelfBean.LOCAL_TAG);
 
+                    // 调用方法保存书籍的章节信息到数据库中
                     saveChapter(book, md5);
+                    // 将书籍详情信息插入或替换到数据库中（如果已存在相同标识的记录则替换）
                     DbHelper.getInstance().getmDaoSession().getBookInfoBeanDao().insertOrReplace(bookShelfBean.getBookInfoBean());
+                    // 将书籍基本信息插入或替换到数据库中
                     DbHelper.getInstance().getmDaoSession().getBookShelfBeanDao().insertOrReplace(bookShelfBean);
                 }
-                bookShelfBean.getBookInfoBean().setChapterlist(DbHelper.getInstance().getmDaoSession().getChapterListBeanDao().queryBuilder().where(ChapterListBeanDao.Properties.NoteUrl.eq(bookShelfBean.getNoteUrl())).orderAsc(ChapterListBeanDao.Properties.DurChapterIndex).build().list());
-                e.onNext(new LocBookShelfBean(isNew,bookShelfBean));
+                // 从数据库中获取该书籍的章节列表信息，并设置到bookShelfBean对象的对应属性中，确保书籍章节信息的完整性
+                bookShelfBean.getBookInfoBean().setChapterlist(DbHelper.getInstance().getmDaoSession().getChapterListBeanDao().queryBuilder()
+                        .where(ChapterListBeanDao.Properties.NoteUrl.eq(bookShelfBean.getNoteUrl())).orderAsc(ChapterListBeanDao.Properties.DurChapterIndex).build().list());
+                // 通过ObservableEmitter发射包含是否为新书以及完整书籍信息的LocBookShelfBean对象，供订阅者接收处理
+                e.onNext(new LocBookShelfBean(isNew, bookShelfBean));
                 e.onComplete();
             }
         });
     }
 
+    /**
+     * 判断给定的书籍（通过BookShelfBean表示）是否已添加到给定的书籍列表（shelfs）中，
+     * 通过遍历列表对比书籍的标识（NoteUrl）来确定是否已存在，返回布尔值表示是否已添加。
+     *
+     * @param temp 要判断是否已添加的BookShelfBean对象，代表一本书籍。
+     * @param shelfs 书籍列表，以List<BookShelfBean>形式表示，包含了已有的书籍信息。
+     * @return 如果书籍已在列表中则返回true，否则返回false。
+     */
     private Boolean isAdded(BookShelfBean temp, List<BookShelfBean> shelfs) {
         if (shelfs == null || shelfs.size() == 0) {
             return false;
@@ -99,47 +146,68 @@ public class ImportBookModelImpl extends MBaseModelImpl implements IImportBookMo
         }
     }
 
+    /**
+     * 保存书籍章节内容的方法，主要负责读取本地书籍文件内容，解析出章节信息并将其保存到数据库中。
+     * 首先会检测文件的编码格式，然后按照一定的规则（通过正则表达式匹配章节标题等）提取章节内容，
+     * 最后将每个章节的相关信息封装为ChapterListBean对象并插入到数据库中。
+     *
+     * @param book 代表本地书籍的File对象，指定要处理的本地书籍文件。
+     * @param md5 书籍文件的MD5值，作为章节信息在数据库中的关联标识，用于确保数据的一致性和准确性。
+     * @throws IOException 如果在文件读取等操作过程中出现I/O异常则抛出，例如文件不存在、无法读取等情况。
+     */
     private void saveChapter(File book, String md5) throws IOException {
+        // 定义一个正则表达式，用于匹配章节标题的模式，这里假设章节标题一般以“第X章”开头（X表示数字及一些其他可能的字符，长度限制在1到7之间），后面可跟一些其他内容
         String regex = "第.{1,7}章.{0,}";
 
         String encoding;
 
+        // 创建文件输入流，用于读取书籍文件内容，为后续检测编码格式和解析内容做准备
         FileInputStream fis = new FileInputStream(book);
         byte[] buf = new byte[4096];
+        // 创建UniversalDetector实例，用于检测文件的编码格式，它可以自动识别多种常见的编码类型
         UniversalDetector detector = new UniversalDetector(null);
         int nread;
-        while ((nread = fis.read(buf)) > 0 && !detector.isDone()) {
+        // 循环读取文件内容，每次读取一部分数据交给UniversalDetector进行分析，直到检测完成或读取完整个文件
+        while ((nread = fis.read(buf)) > 0 &&!detector.isDone()) {
             detector.handleData(buf, 0, nread);
         }
         detector.dataEnd();
+        // 获取检测到的文件编码格式，如果未检测到则默认为"utf-8"编码
         encoding = detector.getDetectedCharset();
         if (encoding == null || encoding.length() == 0)
             encoding = "utf-8";
         fis.close();
         fis = null;
 
+        // 章节页码索引，用于记录章节的顺序，初始化为0，表示从第一章开始
         int chapterPageIndex = 0;
         String title = null;
         StringBuilder contentBuilder = new StringBuilder();
         fis = new FileInputStream(book);
+        // 根据检测到的编码格式创建InputStreamReader，用于以正确的编码方式读取文件内容
         InputStreamReader inputreader = new InputStreamReader(fis, encoding);
+        // 创建BufferedReader，方便逐行读取文件内容进行解析
         BufferedReader buffreader = new BufferedReader(inputreader);
         String line;
-        while ((line = buffreader.readLine()) != null) {
+        // 逐行读取书籍文件内容，进行章节信息的解析和提取
+        while ((line = buffreader.readLine())!= null) {
             Pattern p = Pattern.compile(regex);
             Matcher m = p.matcher(line);
             if (m.find()) {
-                String temp = line.trim().substring(0,line.trim().indexOf("第"));
-                if(temp!= null && temp.trim().length()>0){
+                // 如果匹配到章节标题，先提取标题前可能存在的内容（如果有），并添加到章节内容的临时存储字符串中（contentBuilder）
+                String temp = line.trim().substring(0, line.trim().indexOf("第"));
+                if (temp!= null && temp.trim().length() > 0) {
                     contentBuilder.append(temp);
                 }
+                // 如果临时存储的章节内容字符串不为空且去除全角空格等空白字符后仍有内容，则将当前章节内容保存到数据库中，并更新相关索引和清空临时存储内容
                 if (contentBuilder.toString().length() > 0) {
-                    if(contentBuilder.toString().replaceAll("　","").trim().length()>0){
+                    if (contentBuilder.toString().replaceAll("　", "").trim().length() > 0) {
                         saveDurChapterContent(md5, chapterPageIndex, title, contentBuilder.toString());
                         chapterPageIndex++;
                     }
                     contentBuilder.delete(0, contentBuilder.length());
                 }
+                // 将匹配到的章节标题提取出来，作为当前章节的标题
                 title = line.trim().substring(line.trim().indexOf("第"));
             } else {
                 if (line.trim().length() == 0) {
@@ -156,6 +224,7 @@ public class ImportBookModelImpl extends MBaseModelImpl implements IImportBookMo
                 }
             }
         }
+        // 处理文件末尾剩余的章节内容（如果有），同样将其保存到数据库中
         if (contentBuilder.length() > 0) {
             saveDurChapterContent(md5, chapterPageIndex, title, contentBuilder.toString());
             contentBuilder.delete(0, contentBuilder.length());
@@ -167,6 +236,16 @@ public class ImportBookModelImpl extends MBaseModelImpl implements IImportBookMo
         fis = null;
     }
 
+    /**
+     * 将单个章节的相关信息保存到数据库中，包括章节的索引、标题、内容以及与书籍的关联标识等，
+     * 通过创建ChapterListBean对象并设置其相关属性，然后将对应的书籍内容信息插入到数据库相应表中，
+     * 同时将章节信息也插入到数据库中，确保章节数据的完整存储。
+     *
+     * @param md5 书籍文件的MD5值，用于关联章节信息与对应的书籍，确保数据的一致性和准确性。
+     * @param chapterPageIndex 章节的页码索引，代表章节的顺序编号。
+     * @param name 章节的标题名称。
+     * @param content 章节的具体内容文本。
+     */
     private void saveDurChapterContent(String md5, int chapterPageIndex, String name, String content) {
         ChapterListBean chapterListBean = new ChapterListBean();
         chapterListBean.setNoteUrl(md5);
@@ -182,4 +261,4 @@ public class ImportBookModelImpl extends MBaseModelImpl implements IImportBookMo
         DbHelper.getInstance().getmDaoSession().getBookContentBeanDao().insertOrReplace(chapterListBean.getBookContentBean());
         DbHelper.getInstance().getmDaoSession().getChapterListBeanDao().insertOrReplace(chapterListBean);
     }
-}
+}

app/src/main/java/com/monke/monkeybook/model/impl/LingdiankanshuStationBookModelImpl.java

@@ -28,42 +28,84 @@ import io.reactivex.android.schedulers.AndroidSchedulers;
 import io.reactivex.functions.Function;
 import io.reactivex.schedulers.Schedulers;
 
+/**
+ * LingdiankanshuStationBookModelImpl类继承自MBaseModelImpl并实现了IStationBookModel接口，
+ * 主要用于与特定网站（由TAG标识为http://www.lingdiankanshu.co）进行交互，实现如搜索书籍、获取书籍详情、章节列表以及章节内容等功能。
+ * 通过解析网页HTML结构提取相关数据，并利用RxJava进行异步操作和数据流转处理，最终将处理好的数据以合适的形式返回给调用者，应用于阅读相关的业务场景中。
+ */
 public class LingdiankanshuStationBookModelImpl extends MBaseModelImpl implements IStationBookModel {
+
+    // 定义一个静态常量TAG，用于标识该模型所对应的网站地址，此处明确为http://www.lingdiankanshu.co，
+    // 便于在整个程序体系里知晓此模型相关的网络操作、数据解析等逻辑是针对该站点而设计的。
     public static final String TAG = "http://www.lingdiankanshu.co";
 
+    /**
+     * 获取LingdiankanshuStationBookModelImpl类的单例实例。
+     * 通过采用单例模式，确保在整个程序运行期间只有一个该类的实例存在，这样可以更有序地对与该网站交互、解析相关数据等功能进行统一管理与调用，
+     * 避免因创建多个实例可能导致的资源管理混乱、逻辑不一致等问题。
+     *
+     * @return 返回LingdiankanshuStationBookModelImpl类的唯一实例对象。
+     */
     public static LingdiankanshuStationBookModelImpl getInstance() {
         return new LingdiankanshuStationBookModelImpl();
     }
 
+    /**
+     * 搜索书籍功能
+     * 根据传入的搜索内容和页码，向指定的百度站内搜索接口（http://zhannei.baidu.com）发起搜索书籍的网络请求（调用对应的API），
+     * 然后调用解析搜索书籍结果的方法对返回的数据进行解析，最终返回一个包含搜索结果（以SearchBookBean列表形式表示）的Observable对象，
+     * 供订阅者接收处理搜索到的书籍信息。
+     *
+     * @param content 用于搜索书籍的关键字内容，指定要搜索的书籍相关的关键词，比如书名、作者等。
+     * @param page 搜索结果的页码，用于获取指定页码的搜索结果数据，实现分页查询功能，这里传入的页码参数会减1后再传递给搜索接口（可能是接口要求的页码处理方式）。
+     * @return 返回一个Observable对象，其发射类型为List<SearchBookBean>，包含了搜索到的符合条件的书籍信息列表。
+     */
     @Override
     public Observable<List<SearchBookBean>> searchBook(String content, int page) {
-        return getRetrofitObject("http://zhannei.baidu.com").create(ILingdiankanshuApi.class).searchBook(content, page - 1, "16865089933227718744").flatMap(new Function<String, ObservableSource<List<SearchBookBean>>>() {
-            @Override
-            public ObservableSource<List<SearchBookBean>> apply(String s) throws Exception {
-                return analySearchBook(s);
-            }
-        });
+        return getRetrofitObject("http://zhannei.baidu.com").create(ILingdiankanshuApi.class).searchBook(content, page - 1, "16865089933227718744")
+                .flatMap(new Function<String, ObservableSource<List<SearchBookBean>>>() {
+                    @Override
+                    public ObservableSource<List<SearchBookBean>> apply(String s) throws Exception {
+                        return analySearchBook(s);
+                    }
+                });
     }
 
+    /**
+     * 解析搜索书籍结果
+     * 此方法在搜索书籍的网络请求返回数据后被调用，用于解析获取到的HTML格式的搜索结果数据，从中提取出每本搜索到的书籍的相关信息，
+     * 如书名、作者、分类、最后章节、链接、封面等，并将这些信息封装到SearchBookBean对象中，最后组成列表通过ObservableEmitter发射出去，供订阅者接收处理。
+     *
+     * @param s 包含搜索书籍结果内容的原始字符串数据，通常为HTML格式，是从网络请求获取到的搜索结果信息。
+     * @return 返回一个Observable对象，其发射类型为List<SearchBookBean>，包含了解析后的搜索到的书籍信息列表。
+     */
     public Observable<List<SearchBookBean>> analySearchBook(final String s) {
         return Observable.create(new ObservableOnSubscribe<List<SearchBookBean>>() {
             @Override
             public void subscribe(ObservableEmitter<List<SearchBookBean>> e) throws Exception {
                 try {
                     Document doc = Jsoup.parse(s);
+                    // 获取类名为"result-list"的元素下，类名为"result-item result-game-item"的元素列表，这里假设这些元素包含了每本搜索到的书籍的相关信息
                     Elements booksE = doc.getElementsByClass("result-list").get(0).getElementsByClass("result-item result-game-item");
-                    if (null != booksE && booksE.size() > 1) {
+                    if (null!= booksE && booksE.size() > 1) {
                         List<SearchBookBean> books = new ArrayList<SearchBookBean>();
                         for (int i = 0; i < booksE.size(); i++) {
                             SearchBookBean item = new SearchBookBean();
                             item.setTag(TAG);
+                            // 获取书籍作者信息，通过层层定位元素，先找到类名为"result-game-item-info"的元素，再找到其内部类名为"result-game-item-info-tag"的元素，
+                            // 然后获取第二个<span>标签的文本内容作为作者名（这里的元素定位方式是根据网页结构来确定的具体作者名所在位置）
                             item.setAuthor(booksE.get(i).getElementsByClass("result-game-item-info").get(0).getElementsByClass("result-game-item-info-tag").get(0).getElementsByTag("span").get(1).text());
+                            // 获取书籍分类信息，同样通过层层定位元素，获取对应位置的<span>标签文本内容作为分类名
                             item.setKind(booksE.get(i).getElementsByClass("result-game-item-info").get(0).getElementsByClass("result-game-item-info-tag").get(1).getElementsByTag("span").get(1).text());
-//                            item.setState();
+//                            item.setState();  // 此处代码似乎未完成对书籍状态的设置相关逻辑，可能需要后续补充
+                            // 获取书籍最后章节信息，通过对应元素下的<a>标签获取其文本内容作为最后章节名
                             item.setLastChapter(booksE.get(i).getElementsByClass("result-game-item-info").get(0).getElementsByClass("result-game-item-info-tag").get(3).getElementsByTag("a").get(0).text());
                             item.setOrigin("lingdiankanshu.co");
+                            // 获取书籍名称，通过类名为"result-item-title result-game-item-title"的元素下的<a>标签获取其文本内容作为书名
                             item.setName(booksE.get(i).getElementsByClass("result-item-title result-game-item-title").get(0).getElementsByTag("a").get(0).text());
+                            // 获取书籍详情链接，通过对应的<a>标签获取其href属性值作为详情链接
                             item.setNoteUrl(booksE.get(i).getElementsByClass("result-item-title result-game-item-title").get(0).getElementsByTag("a").get(0).attr("href"));
+                            // 获取书籍封面链接，通过<img>标签的src属性值作为封面链接
                             item.setCoverUrl(booksE.get(i).getElementsByTag("img").get(0).attr("src"));
                             books.add(item);
                         }
@@ -81,16 +123,35 @@ public class LingdiankanshuStationBookModelImpl extends MBaseModelImpl implement
     }
 
     /////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    /**
+     * 获取书籍详情信息
+     * 根据传入的BookShelfBean对象（包含书籍相关的一些基础信息，比如书籍链接等），向网站发起获取书籍详情的网络请求，
+     * 然后调用解析书籍详情的方法对返回的数据进行解析，最终返回一个包含解析后书籍详情信息（封装在BookShelfBean对象中）的Observable对象，供订阅者接收处理。
+     *
+     * @param bookShelfBean 包含书籍相关基础信息的BookShelfBean对象，例如书籍的原始链接等，用于后续获取详细信息的请求以及关联相关数据。
+     * @return 返回一个Observable对象，其发射类型为BookShelfBean，包含了详细的书籍信息，如书名、作者、封面、简介、章节链接等。
+     */
     @Override
     public Observable<BookShelfBean> getBookInfo(final BookShelfBean bookShelfBean) {
-        return getRetrofitObject(TAG).create(ILingdiankanshuApi.class).getBookInfo(bookShelfBean.getNoteUrl().replace(TAG, "")).flatMap(new Function<String, ObservableSource<BookShelfBean>>() {
-            @Override
-            public ObservableSource<BookShelfBean> apply(String s) throws Exception {
-                return analyBookInfo(s, bookShelfBean);
-            }
-        });
+        return getRetrofitObject(TAG).create(ILingdiankanshuApi.class).getBookInfo(bookShelfBean.getNoteUrl().replace(TAG, ""))
+                .flatMap(new Function<String, ObservableSource<BookShelfBean>>() {
+                    @Override
+                    public ObservableSource<BookShelfBean> apply(String s) throws Exception {
+                        return analyBookInfo(s, bookShelfBean);
+                    }
+                });
     }
 
+    /**
+     * 解析书籍详情信息
+     * 此方法在获取书籍详情的网络请求返回数据后被调用，用于将获取到的HTML格式的数据进行解析，提取出如书名、作者、封面、简介等详细信息，
+     * 并将这些信息设置到传入的BookShelfBean对象的对应属性中（通过调用analyBookinfo方法获取具体信息），最后通过ObservableEmitter发射出去，供订阅者接收处理。
+     *
+     * @param s 包含书籍详情内容的原始字符串数据，通常为HTML格式，是从网络请求获取到的书籍详情信息。
+     * @param bookShelfBean 用于存储解析后的书籍详情信息的BookShelfBean对象，同时其本身也包含了一些与书籍相关的基础信息，用于关联数据等操作。
+     * @return 返回一个Observable对象，其发射类型为BookShelfBean，包含了完整解析后的书籍详情信息。
+     */
     private Observable<BookShelfBean> analyBookInfo(final String s, final BookShelfBean bookShelfBean) {
         return Observable.create(new ObservableOnSubscribe<BookShelfBean>() {
             @Override
@@ -103,23 +164,34 @@ public class LingdiankanshuStationBookModelImpl extends MBaseModelImpl implement
         });
     }
 
+    /**
+     * 具体解析书籍详情中各项信息的方法，从传入的HTML格式字符串数据中提取出书名、作者、封面、简介等信息，封装到BookInfoBean对象中返回。
+     *
+     * @param s 包含书籍详情内容的原始字符串数据，通常为HTML格式，是从网络请求获取到的书籍详情信息。
+     * @param novelUrl 书籍的链接地址，用于设置到BookInfoBean对象中作为标识等用途，同时可能在解析过程中根据其构建其他相关链接（如章节链接等）。
+     * @return 返回一个包含解析后的书籍详情信息（书名、作者、封面、简介、章节链接等）的BookInfoBean对象。
+     */
     private BookInfoBean analyBookinfo(String s, String novelUrl) {
         BookInfoBean bookInfoBean = new BookInfoBean();
         bookInfoBean.setNoteUrl(novelUrl);   //id
         bookInfoBean.setTag(TAG);
         Document doc = Jsoup.parse(s);
+        // 获取类名为"box_con"的元素，这里假设书籍详情的主要信息都在这个元素内部，是后续提取各种信息的基础元素
         Element resultE = doc.getElementsByClass("box_con").get(0);
+        // 获取书籍封面链接，通过定位元素找到对应的<img>标签，并获取其src属性值作为封面链接
         bookInfoBean.setCoverUrl(resultE.getElementById("fmimg").getElementsByTag("img").get(0).attr("src"));
+        // 获取书籍名称，通过定位元素找到对应的<h1>标签，并获取其文本内容作为书名
         bookInfoBean.setName(resultE.getElementById("info").getElementsByTag("h1").get(0).text());
         String author = resultE.getElementById("info").getElementsByTag("p").get(0).text().toString().trim();
-        author = author.replace(" ", "").replace("  ", "").replace("作者：", "");
+        // 对获取到的作者信息字符串进行处理，去除一些多余的空格、特殊空格以及"作者："等前缀内容，得到纯净的作者名
+        author = author.replace(" ", "").replace("  ", "").replace("作者：", "");
         bookInfoBean.setAuthor(author);
 
         List<TextNode> contentEs = resultE.getElementById("intro").textNodes();
         StringBuilder content = new StringBuilder();
         for (int i = 0; i < contentEs.size(); i++) {
             String temp = contentEs.get(i).text().trim();
-            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
+            temp = temp.replaceAll(" ", "").replaceAll(" ", "");
             if (temp.length() > 0) {
                 content.append("\u3000\u3000" + temp);
                 if (i < contentEs.size() - 1) {
@@ -135,20 +207,31 @@ public class LingdiankanshuStationBookModelImpl extends MBaseModelImpl implement
     }
 
     /////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    /**
+     * 获取书籍章节列表信息
+     * 根据传入的BookShelfBean对象（包含书籍相关的一些基础信息，比如书籍链接等），向网站发起获取章节列表的网络请求，
+     * 然后调用解析章节列表的方法对返回的数据进行解析，将解析后的章节信息设置到BookShelfBean对象的对应属性中，
+     * 最后通过RxJava的响应式编程机制，在指定的线程（IO线程发起请求，主线程处理结果）中进行操作，并通过订阅者回调（OnGetChapterListListener）返回处理结果。
+     *
+     * @param bookShelfBean 包含书籍相关基础信息的BookShelfBean对象，例如书籍的原始链接等，用于后续获取章节列表信息的请求以及关联相关数据。
+     * @param getChapterListListener 用于接收获取章节列表操作结果的回调接口，通过实现其success和error方法来处理获取成功或失败的情况。
+     */
     @Override
     public void getChapterList(final BookShelfBean bookShelfBean, final OnGetChapterListListener getChapterListListener) {
-        getRetrofitObject(TAG).create(ILingdiankanshuApi.class).getChapterList(bookShelfBean.getBookInfoBean().getChapterUrl().replace(TAG, "")).flatMap(new Function<String, ObservableSource<WebChapterBean<BookShelfBean>>>() {
-            @Override
-            public ObservableSource<WebChapterBean<BookShelfBean>> apply(String s) throws Exception {
-                return analyChapterList(s, bookShelfBean);
-            }
-        })
+        getRetrofitObject(TAG).create(ILingdiankanshuApi.class).getChapterList(bookShelfBean.getBookInfoBean().getChapterUrl().replace(TAG, ""))
+                .flatMap(new Function<String, ObservableSource<WebChapterBean<BookShelfBean>>>() {
+                    @Override
+                    public ObservableSource<WebChapterBean<BookShelfBean>> apply(String s) throws Exception {
+                        return analyChapterList(s, bookShelfBean);
+                    }
+                })
                 .subscribeOn(Schedulers.io())
                 .observeOn(AndroidSchedulers.mainThread())
                 .subscribe(new SimpleObserver<WebChapterBean<BookShelfBean>>() {
                     @Override
                     public void onNext(WebChapterBean<BookShelfBean> value) {
-                        if (getChapterListListener != null) {
+                        if (getChapterListListener!= null) {
                             getChapterListListener.success(value.getData());
                         }
                     }
@@ -156,90 +239,17 @@ public class LingdiankanshuStationBookModelImpl extends MBaseModelImpl implement
                     @Override
                     public void onError(Throwable e) {
                         e.printStackTrace();
-                        if (getChapterListListener != null) {
+                        if (getChapterListListener!= null) {
                             getChapterListListener.error();
                         }
                     }
                 });
     }
 
-    private Observable<WebChapterBean<BookShelfBean>> analyChapterList(final String s, final BookShelfBean bookShelfBean) {
-        return Observable.create(new ObservableOnSubscribe<WebChapterBean<BookShelfBean>>() {
-            @Override
-            public void subscribe(ObservableEmitter<WebChapterBean<BookShelfBean>> e) throws Exception {
-                bookShelfBean.setTag(TAG);
-                WebChapterBean<List<ChapterListBean>> temp = analyChapterlist(s, bookShelfBean.getNoteUrl());
-                bookShelfBean.getBookInfoBean().setChapterlist(temp.getData());
-                e.onNext(new WebChapterBean<BookShelfBean>(bookShelfBean, temp.getNext()));
-                e.onComplete();
-            }
-        });
-    }
-
-    private WebChapterBean<List<ChapterListBean>> analyChapterlist(String s, String novelUrl) {
-        Document doc = Jsoup.parse(s);
-        Elements chapterlist = doc.getElementById("list").getElementsByTag("dd");
-        List<ChapterListBean> chapterBeans = new ArrayList<ChapterListBean>();
-        for (int i = 0; i < chapterlist.size(); i++) {
-            ChapterListBean temp = new ChapterListBean();
-            temp.setDurChapterUrl(novelUrl + chapterlist.get(i).getElementsByTag("a").get(0).attr("href"));   //id
-            temp.setDurChapterIndex(i);
-            temp.setDurChapterName(chapterlist.get(i).getElementsByTag("a").get(0).text());
-            temp.setNoteUrl(novelUrl);
-            temp.setTag(TAG);
-
-            chapterBeans.add(temp);
-        }
-        Boolean next = false;
-        return new WebChapterBean<List<ChapterListBean>>(chapterBeans, next);
-    }
-
-    /////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    @Override
-    public Observable<BookContentBean> getBookContent(final String durChapterUrl, final int durChapterIndex) {
-        return getRetrofitObject(TAG).create(ILingdiankanshuApi.class).getBookContent(durChapterUrl.replace(TAG, "")).flatMap(new Function<String, ObservableSource<BookContentBean>>() {
-            @Override
-            public ObservableSource<BookContentBean> apply(String s) throws Exception {
-                return analyBookContent(s, durChapterUrl, durChapterIndex);
-            }
-        });
-    }
-
-    private Observable<BookContentBean> analyBookContent(final String s, final String durChapterUrl, final int durChapterIndex) {
-        return Observable.create(new ObservableOnSubscribe<BookContentBean>() {
-            @Override
-            public void subscribe(ObservableEmitter<BookContentBean> e) throws Exception {
-                BookContentBean bookContentBean = new BookContentBean();
-                bookContentBean.setDurChapterIndex(durChapterIndex);
-                bookContentBean.setDurChapterUrl(durChapterUrl);
-                bookContentBean.setTag(TAG);
-                try {
-                    Document doc = Jsoup.parse(s);
-                    List<TextNode> contentEs = doc.getElementById("content").textNodes();
-                    StringBuilder content = new StringBuilder();
-                    for (int i = 0; i < contentEs.size(); i++) {
-                        String temp = contentEs.get(i).text().trim();
-                        temp = temp.replaceAll(" ", "").replaceAll(" ", "");
-                        if (temp.length() > 0) {
-                            content.append("\u3000\u3000" + temp);
-                            if (i < contentEs.size() - 1) {
-                                content.append("\r\n");
-                            }
-                        }
-                    }
-                    bookContentBean.setDurCapterContent(content.toString());
-                    bookContentBean.setRight(true);
-                } catch (Exception ex) {
-                    ex.printStackTrace();
-                    ErrorAnalyContentManager.getInstance().writeNewErrorUrl(durChapterUrl);
-                    bookContentBean.setDurCapterContent(durChapterUrl.substring(0, durChapterUrl.indexOf('/', 8)) + "站点暂时不支持解析，请反馈给Monke QQ:1105075896,半小时内解决，超级效率的程序员");
-                    bookContentBean.setRight(false);
-                }
-                e.onNext(bookContentBean);
-                e.onComplete();
-            }
-        });
-    }
-
-    /////////////////////////////////////////////////////////////////////////////////////////////////////////////
-}
+/**
+ * 解析章节列表信息
+ * 此方法在获取章节列表的网络请求返回数据后被调用，用于解析获取到的HTML格式的章节列表数据，从中提取出每章的相关信息（如章节名、链接、索引等），
+ * 并将这些信息封装到ChapterListBean对象中组成列表，然后将其设置到传入的BookShelfBean对象的对应属性中，最后通过ObservableEmitter发射出去，供后续处理。
+ *
+ * @param s 包含章节列表内容的原始字符串数据，通常为HTML格式，是从网络请求获取到的章节列表信息。
+ * @param bookShelfBean 用于存储解析

app/src/main/java/com/monke/monkeybook/model/impl/WebBookModelImpl.java

@@ -12,8 +12,20 @@ import io.reactivex.Observable;
 import io.reactivex.ObservableEmitter;
 import io.reactivex.ObservableOnSubscribe;
 
+/**
+ * WebBookModelImpl类实现了IWebBookModel接口，其主要作用是作为一个统一的对外接口，
+ * 根据不同的网站标识（tag），将各种与书籍相关的操作（如获取书籍信息、章节列表、章节内容、搜索书籍等）转发到对应的具体实现类中去执行，
+ * 实现了对多个不同来源网站书籍数据操作的整合与统一管理，方便在应用中以统一的方式处理不同网站的书籍资源相关业务逻辑。
+ */
 public class WebBookModelImpl implements IWebBookModel {
 
+    /**
+     * 获取WebBookModelImpl类的单例实例。
+     * 通过采用单例模式，确保在整个程序运行期间只有一个该类的实例存在，便于统一管理和调用与网络书籍相关的各种操作功能，
+     * 避免因创建多个实例可能导致的资源管理混乱、逻辑不一致等问题。
+     *
+     * @return 返回WebBookModelImpl类的唯一实例对象。
+     */
     public static WebBookModelImpl getInstance() {
         return new WebBookModelImpl();
     }
@@ -22,17 +34,22 @@ public class WebBookModelImpl implements IWebBookModel {
 
     /**
      * 网络请求并解析书籍信息
-     * return BookShelfBean
+     * 此方法根据传入的BookShelfBean对象中的网站标识（tag），判断书籍来源网站，
+     * 如果是特定网站（如由GxwztvBookModelImpl.TAG标识的网站），则调用对应网站实现类的方法来获取书籍详细信息；
+     * 如果是另一个特定网站（如由LingdiankanshuStationBookModelImpl.TAG标识的网站），则调用相应网站实现类的方法获取书籍信息；
+     * 如果都不匹配，则返回null，表示无法处理该来源的书籍信息获取请求。
+     * 最终返回一个包含解析后书籍详细信息（封装在BookShelfBean对象中）的Observable对象，供订阅者接收处理相关书籍详情。
+     *
+     * @param bookShelfBean 包含书籍相关基础信息的BookShelfBean对象，例如书籍的原始链接、网站标识（tag）等，用于确定书籍来源以及后续获取详细信息的请求等操作。
+     * @return 返回一个Observable对象，其发射类型为BookShelfBean，包含了详细的书籍信息（若能成功获取），否则返回null。
      */
     @Override
     public Observable<BookShelfBean> getBookInfo(BookShelfBean bookShelfBean) {
-        if(bookShelfBean.getTag().equals(GxwztvBookModelImpl.TAG)){
+        if (bookShelfBean.getTag().equals(GxwztvBookModelImpl.TAG)) {
             return GxwztvBookModelImpl.getInstance().getBookInfo(bookShelfBean);
-        }
-        else if(bookShelfBean.getTag().equals(LingdiankanshuStationBookModelImpl.TAG)){
+        } else if (bookShelfBean.getTag().equals(LingdiankanshuStationBookModelImpl.TAG)) {
             return LingdiankanshuStationBookModelImpl.getInstance().getBookInfo(bookShelfBean);
-        }
-        else {
+        } else {
             return null;
         }
     }
@@ -41,18 +58,23 @@ public class WebBookModelImpl implements IWebBookModel {
 
     /**
      * 网络解析图书目录
-     * return BookShelfBean
+     * 此方法根据传入的BookShelfBean对象中的网站标识（tag），判断书籍来源网站，
+     * 如果是特定网站（如由GxwztvBookModelImpl.TAG标识的网站），则调用对应网站实现类的方法来获取书籍章节列表信息；
+     * 如果是另一个特定网站（如由LingdiankanshuStationBookModelImpl.TAG标识的网站），则调用相应网站实现类的方法获取章节列表信息；
+     * 如果都不匹配，则直接通过回调接口（OnGetChapterListListener）返回传入的BookShelfBean对象，可视为一种默认处理（可能表示无法获取到实际的章节列表信息）。
+     * 通过这种方式实现了根据不同网站来源获取相应书籍章节列表的功能，并通过回调接口通知调用者获取结果的情况（成功或失败）。
+     *
+     * @param bookShelfBean 包含书籍相关基础信息的BookShelfBean对象，例如书籍的原始链接、网站标识（tag）等，用于确定书籍来源以及后续获取章节列表信息的请求等操作。
+     * @param getChapterListListener 用于接收获取章节列表操作结果的回调接口，通过实现其success和error方法来处理获取成功或失败的情况。
      */
     @Override
     public void getChapterList(final BookShelfBean bookShelfBean, OnGetChapterListListener getChapterListListener) {
-        if(bookShelfBean.getTag().equals(GxwztvBookModelImpl.TAG)){
+        if (bookShelfBean.getTag().equals(GxwztvBookModelImpl.TAG)) {
             GxwztvBookModelImpl.getInstance().getChapterList(bookShelfBean, getChapterListListener);
-        }
-        else if(bookShelfBean.getTag().equals(LingdiankanshuStationBookModelImpl.TAG)){
+        } else if (bookShelfBean.getTag().equals(LingdiankanshuStationBookModelImpl.TAG)) {
             LingdiankanshuStationBookModelImpl.getInstance().getChapterList(bookShelfBean, getChapterListListener);
-        }
-        else{
-            if(getChapterListListener!=null)
+        } else {
+            if (getChapterListListener!= null)
                 getChapterListListener.success(bookShelfBean);
         }
     }
@@ -61,16 +83,24 @@ public class WebBookModelImpl implements IWebBookModel {
 
     /**
      * 章节缓存
+     * 此方法根据传入的章节链接（durChapterUrl）对应的网站标识（tag），判断章节所属书籍的来源网站，
+     * 如果是特定网站（如由GxwztvBookModelImpl.TAG标识的网站），则调用对应网站实现类的方法来获取章节内容信息；
+     * 如果是另一个特定网站（如由LingdiankanshuStationBookModelImpl.TAG标识的网站），则调用相应网站实现类的方法获取章节内容信息；
+     * 如果都不匹配，则创建并返回一个简单的Observable对象，其发射一个默认的空的BookContentBean对象，可视为一种兜底处理（表示无法获取到实际的章节内容）。
+     * 最终返回一个包含章节内容信息（封装在BookContentBean对象中）的Observable对象，供订阅者接收处理相关章节内容详情。
+     *
+     * @param durChapterUrl 章节的链接地址，用于确定章节所属书籍以及其来源网站，以便调用对应网站实现类的方法获取内容。
+     * @param durChapterIndex 章节的索引编号，可能用于在获取章节内容时的一些定位、排序等相关操作（具体取决于对应网站实现类的处理逻辑）。
+     * @param tag 章节所属书籍的网站标识，用于判断章节来源网站，以决定调用哪个具体网站实现类的方法来获取章节内容。
+     * @return 返回一个Observable对象，其发射类型为BookContentBean，包含了章节内容信息（若能成功获取），否则返回一个默认的简单Observable发射空的BookContentBean对象。
      */
     @Override
     public Observable<BookContentBean> getBookContent(String durChapterUrl, int durChapterIndex, String tag) {
-        if(tag.equals(GxwztvBookModelImpl.TAG)){
+        if (tag.equals(GxwztvBookModelImpl.TAG)) {
             return GxwztvBookModelImpl.getInstance().getBookContent(durChapterUrl, durChapterIndex);
-        }
-        else if(tag.equals(LingdiankanshuStationBookModelImpl.TAG)){
+        } else if (tag.equals(LingdiankanshuStationBookModelImpl.TAG)) {
             return LingdiankanshuStationBookModelImpl.getInstance().getBookContent(durChapterUrl, durChapterIndex);
-        }
-        else
+        } else
             return Observable.create(new ObservableOnSubscribe<BookContentBean>() {
                 @Override
                 public void subscribe(ObservableEmitter<BookContentBean> e) throws Exception {
@@ -82,16 +112,24 @@ public class WebBookModelImpl implements IWebBookModel {
 
     /**
      * 其他站点集合搜索
+     * 此方法根据传入的网站标识（tag），判断搜索书籍的目标网站，
+     * 如果是特定网站（如由GxwztvBookModelImpl.TAG标识的网站），则调用对应网站实现类的方法来执行搜索书籍操作；
+     * 如果是另一个特定网站（如由LingdiankanshuStationBookModelImpl.TAG标识的网站），则调用相应网站实现类的方法进行搜索；
+     * 如果都不匹配，则创建并返回一个简单的Observable对象，其发射一个空的SearchBookBean列表，可视为一种默认处理（表示无法在对应网站搜索到书籍，返回空结果）。
+     * 最终返回一个包含搜索结果（以SearchBookBean列表形式表示）的Observable对象，供订阅者接收处理搜索到的书籍信息。
+     *
+     * @param content 用于搜索书籍的关键字内容，指定要搜索的书籍相关的关键词，比如书名、作者等。
+     * @param page 搜索结果的页码，用于获取指定页码的搜索结果数据，实现分页查询功能。
+     * @param tag 搜索书籍的目标网站标识，用于判断要调用哪个具体网站实现类的搜索方法来执行搜索操作。
+     * @return 返回一个Observable对象，其发射类型为List<SearchBookBean>，包含了搜索到的符合条件的书籍信息列表（若能成功搜索），否则返回一个空列表的Observable对象。
      */
     @Override
-    public Observable<List<SearchBookBean>> searchOtherBook(String content,int page,String tag){
-        if(tag.equals(GxwztvBookModelImpl.TAG)){
+    public Observable<List<SearchBookBean>> searchOtherBook(String content, int page, String tag) {
+        if (tag.equals(GxwztvBookModelImpl.TAG)) {
             return GxwztvBookModelImpl.getInstance().searchBook(content, page);
-        }
-        else if(tag.equals(LingdiankanshuStationBookModelImpl.TAG)){
+        } else if (tag.equals(LingdiankanshuStationBookModelImpl.TAG)) {
             return LingdiankanshuStationBookModelImpl.getInstance().searchBook(content, page);
-        }
-        else{
+        } else {
             return Observable.create(new ObservableOnSubscribe<List<SearchBookBean>>() {
                 @Override
                 public void subscribe(ObservableEmitter<List<SearchBookBean>> e) throws Exception {
@@ -101,11 +139,19 @@ public class WebBookModelImpl implements IWebBookModel {
             });
         }
     }
+
     /**
      * 获取分类书籍
+     * 此方法直接调用GxwztvBookModelImpl类的对应方法来获取分类书籍信息，目前没有根据不同网站标识进行判断处理，
+     * 意味着可能默认该功能只针对特定的某个网站（由GxwztvBookModelImpl类处理的网站），返回一个包含搜索结果（以SearchBookBean列表形式表示）的Observable对象，
+     * 供订阅者接收处理搜索到的分类书籍信息。
+     *
+     * @param url 可能是分类书籍相关的链接地址或者查询参数等信息，具体取决于GxwztvBookModelImpl类中对应方法的要求，用于获取分类书籍数据。
+     * @param page 搜索结果的页码，用于获取指定页码的分类书籍搜索结果数据，实现分页查询功能。
+     * @return 返回一个Observable对象，其发射类型为List<SearchBookBean>，包含了获取到的符合条件的分类书籍信息列表。
      */
     @Override
-    public Observable<List<SearchBookBean>> getKindBook(String url,int page) {
-        return GxwztvBookModelImpl.getInstance().getKindBook(url,page);
+    public Observable<List<SearchBookBean>> getKindBook(String url, int page) {
+        return GxwztvBookModelImpl.getInstance().getKindBook(url, page);
     }
-}
+}

app/src/main/java/com/monke/monkeybook/service/DownloadService.java

@@ -1,4 +1,3 @@
-//Copyright (c) 2017. 章钦豪. All rights reserved.
 package com.monke.monkeybook.service;
 
 import android.app.NotificationManager;
@@ -12,6 +11,7 @@ import android.os.Looper;
 import android.support.annotation.Nullable;
 import android.support.v4.app.NotificationCompat;
 import android.widget.Toast;
+
 import com.hwangjr.rxbus.RxBus;
 import com.hwangjr.rxbus.annotation.Subscribe;
 import com.hwangjr.rxbus.annotation.Tag;
@@ -30,7 +30,9 @@ import com.monke.monkeybook.dao.DbHelper;
 import com.monke.monkeybook.dao.DownloadChapterBeanDao;
 import com.monke.monkeybook.model.impl.WebBookModelImpl;
 import com.monke.monkeybook.view.impl.MainActivity;
+
 import java.util.List;
+
 import io.reactivex.Observable;
 import io.reactivex.ObservableEmitter;
 import io.reactivex.ObservableOnSubscribe;
@@ -41,18 +43,24 @@ import io.reactivex.disposables.Disposable;
 import io.reactivex.functions.Function;
 import io.reactivex.schedulers.Schedulers;
 
+// DownloadService类，继承自Service，用于处理书籍下载相关的业务逻辑，如启动、暂停、取消下载等操作
 public class DownloadService extends Service {
+    // 用于管理通知的显示和取消等操作
     private NotificationManager notifyManager;
+    // 通知的唯一标识符
     private int notifiId = 19931118;
+    // 标记是否开始下载
     private Boolean isStartDownload = false;
+    // 标记是否已经初始化
     private Boolean isInit = false;
 
+    // 服务创建时调用的方法
     @Override
     public void onCreate() {
         super.onCreate();
-
     }
 
+    // 服务销毁时调用的方法，用于注销RxBus注册以及设置初始化标记为true
     @Override
     public void onDestroy() {
         super.onDestroy();
@@ -60,25 +68,31 @@ public class DownloadService extends Service {
         isInit = true;
     }
 
+    // 服务启动时调用的方法，进行一些初始化操作，如获取通知管理器、注册RxBus等
     @Override
     public int onStartCommand(Intent intent, int flags, int startId) {
         if (!isInit) {
             isInit = true;
+            // 获取系统的通知服务
             notifyManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
+            // 注册RxBus，用于接收相关事件
             RxBus.get().register(this);
         }
         return super.onStartCommand(intent, flags, startId);
     }
 
+    // 用于绑定服务，这里返回null表示不支持绑定
     @Nullable
     @Override
     public IBinder onBind(Intent intent) {
         return null;
     }
 
+    // 添加新的下载任务，将新的下载章节数据插入数据库，并根据下载状态决定是否开始下载
     private void addNewTask(final List<DownloadChapterBean> newData) {
         isStartDownload = true;
         Observable.create(new ObservableOnSubscribe<Boolean>() {
+            // 在这个方法中执行将下载章节数据插入数据库的操作
             @Override
             public void subscribe(ObservableEmitter<Boolean> e) throws Exception {
                 DbHelper.getInstance().getmDaoSession().getDownloadChapterBeanDao().insertOrReplaceInTx(newData);
@@ -86,9 +100,12 @@ public class DownloadService extends Service {
                 e.onComplete();
             }
         })
+                // 指定在主线程观察结果
                 .observeOn(AndroidSchedulers.mainThread())
+                // 指定在IO线程执行插入数据库操作
                 .subscribeOn(Schedulers.io())
                 .subscribe(new SimpleObserver<Boolean>() {
+                    // 插入成功后，如果当前没有正在下载，则调用toDownload方法开始下载
                     @Override
                     public void onNext(Boolean value) {
                         if (!isDownloading) {
@@ -103,30 +120,38 @@ public class DownloadService extends Service {
                 });
     }
 
+    // 标记是否正在下载
     private Boolean isDownloading = false;
+    // 下载失败时的重试次数
     public static final int reTryTimes = 1;
 
+    // 开始下载的主要逻辑方法，查找待下载的章节并进行下载操作
     private void toDownload() {
         isDownloading = true;
         if (isStartDownload) {
             Observable.create(new ObservableOnSubscribe<DownloadChapterBean>() {
                 @Override
                 public void subscribe(ObservableEmitter<DownloadChapterBean> e) throws Exception {
+                    // 获取书架上的书籍列表，按最后更新日期降序排列
                     List<BookShelfBean> bookShelfBeanList = DbHelper.getInstance().getmDaoSession().getBookShelfBeanDao().queryBuilder().orderDesc(BookShelfBeanDao.Properties.FinalDate).list();
-                    if (bookShelfBeanList != null && bookShelfBeanList.size() > 0) {
+                    if (bookShelfBeanList!= null && bookShelfBeanList.size() > 0) {
                         for (BookShelfBean bookItem : bookShelfBeanList) {
+                            // 排除本地标签的书籍（可能表示已经下载好的本地书籍）
                             if (!bookItem.getTag().equals(BookShelfBean.LOCAL_TAG)) {
+                                // 查询该书籍下待下载的章节列表，按章节索引升序排列，取第一个章节（即下一个要下载的章节）
                                 List<DownloadChapterBean> downloadChapterList = DbHelper.getInstance().getmDaoSession().getDownloadChapterBeanDao().queryBuilder().where(DownloadChapterBeanDao.Properties.NoteUrl.eq(bookItem.getNoteUrl())).orderAsc(DownloadChapterBeanDao.Properties.DurChapterIndex).limit(1).list();
-                                if (downloadChapterList != null && downloadChapterList.size() > 0) {
+                                if (downloadChapterList!= null && downloadChapterList.size() > 0) {
                                     e.onNext(downloadChapterList.get(0));
                                     e.onComplete();
                                     return;
                                 }
                             }
                         }
+                        // 如果没有待下载章节，删除所有下载章节记录
                         DbHelper.getInstance().getmDaoSession().getDownloadChapterBeanDao().deleteAll();
                         e.onNext(new DownloadChapterBean());
                     } else {
+                        // 如果书架列表为空，同样删除所有下载章节记录
                         DbHelper.getInstance().getmDaoSession().getDownloadChapterBeanDao().deleteAll();
                         e.onNext(new DownloadChapterBean());
                     }
@@ -138,12 +163,14 @@ public class DownloadService extends Service {
                     .subscribe(new SimpleObserver<DownloadChapterBean>() {
                         @Override
                         public void onNext(DownloadChapterBean value) {
-                            if (value.getNoteUrl() != null && value.getNoteUrl().length() > 0) {
+                            if (value.getNoteUrl()!= null && value.getNoteUrl().length() > 0) {
+                                // 如果章节有有效的URL，开始下载该章节
                                 downloading(value, 0);
                             } else {
                                 Observable.create(new ObservableOnSubscribe<Object>() {
                                     @Override
                                     public void subscribe(ObservableEmitter<Object> e) throws Exception {
+                                        // 如果章节URL为空，删除所有下载章节记录
                                         DbHelper.getInstance().getmDaoSession().getDownloadChapterBeanDao().deleteAll();
                                         e.onNext(new Object());
                                         e.onComplete();
@@ -178,14 +205,17 @@ public class DownloadService extends Service {
         }
     }
 
+    // 具体下载章节的逻辑方法，处理下载过程中的重试、保存数据等操作
     private void downloading(final DownloadChapterBean data, final int durTime) {
         if (durTime < reTryTimes && isStartDownload) {
+            // 发送下载进度相关的事件，并显示通知
             isProgress(data);
             Observable.create(new ObservableOnSubscribe<BookContentBean>() {
                 @Override
                 public void subscribe(ObservableEmitter<BookContentBean> e) throws Exception {
+                    // 查询数据库中是否已经存在该章节的内容
                     List<BookContentBean> result = DbHelper.getInstance().getmDaoSession().getBookContentBeanDao().queryBuilder().where(BookContentBeanDao.Properties.DurChapterUrl.eq(data.getDurChapterUrl())).list();
-                    if (result != null && result.size() > 0) {
+                    if (result!= null && result.size() > 0) {
                         e.onNext(result.get(0));
                     } else {
                         e.onNext(new BookContentBean());
@@ -196,6 +226,7 @@ public class DownloadService extends Service {
                 @Override
                 public ObservableSource<BookContentBean> apply(final BookContentBean bookContentBean) throws Exception {
                     if (bookContentBean.getDurChapterUrl() == null || bookContentBean.getDurChapterUrl().length() <= 0) {
+                        // 如果章节内容不存在，通过WebBookModelImpl获取章节内容，然后进行相关数据库操作（插入内容、更新章节列表等）
                         return WebBookModelImpl.getInstance().getBookContent(data.getDurChapterUrl(), data.getDurChapterIndex(), data.getTag()).map(new Function<BookContentBean, BookContentBean>() {
                             @Override
                             public BookContentBean apply(BookContentBean bookContentBean) throws Exception {
@@ -208,6 +239,7 @@ public class DownloadService extends Service {
                             }
                         });
                     } else {
+                        // 如果章节内容已经存在，直接删除下载章节记录并返回该章节内容
                         return Observable.create(new ObservableOnSubscribe<BookContentBean>() {
                             @Override
                             public void subscribe(ObservableEmitter<BookContentBean> e) throws Exception {
@@ -224,18 +256,18 @@ public class DownloadService extends Service {
                     .subscribe(new SimpleObserver<BookContentBean>() {
                         @Override
                         public void onNext(BookContentBean value) {
-                            if(isStartDownload){
+                            if (isStartDownload) {
                                 new Handler().postDelayed(new Runnable() {
                                     @Override
                                     public void run() {
-                                        if(isStartDownload){
+                                        if (isStartDownload) {
                                             toDownload();
-                                        }else{
+                                        } else {
                                             isPause();
                                         }
                                     }
-                                },800);
-                            }else{
+                                }, 800);
+                            } else {
                                 isPause();
                             }
                         }
@@ -252,6 +284,7 @@ public class DownloadService extends Service {
                 Observable.create(new ObservableOnSubscribe<Boolean>() {
                     @Override
                     public void subscribe(ObservableEmitter<Boolean> e) throws Exception {
+                        // 如果重试次数超过限制或者下载失败，删除该下载章节记录
                         DbHelper.getInstance().getmDaoSession().getDownloadChapterBeanDao().delete(data);
                         e.onNext(true);
                         e.onComplete();
@@ -262,18 +295,18 @@ public class DownloadService extends Service {
                         .subscribe(new SimpleObserver<Boolean>() {
                             @Override
                             public void onNext(Boolean value) {
-                                if(isStartDownload){
+                                if (isStartDownload) {
                                     new Handler().postDelayed(new Runnable() {
                                         @Override
                                         public void run() {
-                                            if(isStartDownload){
+                                            if (isStartDownload) {
                                                 toDownload();
-                                            }else{
+                                            } else {
                                                 isPause();
                                             }
                                         }
-                                    },800);
-                                }else{
+                                    }, 800);
+                                } else {
                                     isPause();
                                 }
                             }
@@ -281,7 +314,7 @@ public class DownloadService extends Service {
                             @Override
                             public void onError(Throwable e) {
                                 e.printStackTrace();
-                                if(!isStartDownload)
+                                if (!isStartDownload)
                                     isPause();
                             }
                         });
@@ -290,16 +323,19 @@ public class DownloadService extends Service {
         }
     }
 
+    // 对外提供的启动下载的方法，设置下载开始标记并调用toDownload方法
     public void startDownload() {
         isStartDownload = true;
         toDownload();
     }
 
+    // 对外提供的暂停下载的方法，设置下载暂停标记并取消所有通知
     public void pauseDownload() {
         isStartDownload = false;
         notifyManager.cancelAll();
     }
 
+    // 对外提供的取消下载的方法，先删除所有下载章节记录，然后暂停下载
     public void cancelDownload() {
         Observable.create(new ObservableOnSubscribe<Object>() {
             @Override
@@ -334,17 +370,18 @@ public class DownloadService extends Service {
                 });
     }
 
+    // 处理下载暂停相关逻辑，判断是否还有待下载章节，根据情况发送相应的RxBus事件
     private void isPause() {
         isDownloading = false;
         Observable.create(new ObservableOnSubscribe<DownloadChapterBean>() {
             @Override
             public void subscribe(ObservableEmitter<DownloadChapterBean> e) throws Exception {
                 List<BookShelfBean> bookShelfBeanList = DbHelper.getInstance().getmDaoSession().getBookShelfBeanDao().queryBuilder().orderDesc(BookShelfBeanDao.Properties.FinalDate).list();
-                if (bookShelfBeanList != null && bookShelfBeanList.size() > 0) {
+                if (bookShelfBeanList!= null && bookShelfBeanList.size() > 0) {
                     for (BookShelfBean bookItem : bookShelfBeanList) {
                         if (!bookItem.getTag().equals(BookShelfBean.LOCAL_TAG)) {
                             List<DownloadChapterBean> downloadChapterList = DbHelper.getInstance().getmDaoSession().getDownloadChapterBeanDao().queryBuilder().where(DownloadChapterBeanDao.Properties.NoteUrl.eq(bookItem.getNoteUrl())).orderAsc(DownloadChapterBeanDao.Properties.DurChapterIndex).limit(1).list();
-                            if (downloadChapterList != null && downloadChapterList.size() > 0) {
+                            if (downloadChapterList!= null && downloadChapterList.size() > 0) {
                                 e.onNext(downloadChapterList.get(0));
                                 e.onComplete();
                                 return;
@@ -364,9 +401,11 @@ public class DownloadService extends Service {
                 .subscribe(new SimpleObserver<DownloadChapterBean>() {
                     @Override
                     public void onNext(DownloadChapterBean value) {
-                        if (value.getNoteUrl() != null && value.getNoteUrl().length() > 0){
+                        if (value.getNoteUrl()!= null && value.getNoteUrl().length() > 0) {
+                            // 如果还有待下载章节，发送暂停下载的监听事件
                             RxBus.get().post(RxBusTag.PAUSE_DOWNLOAD_LISTENER, new Object());
-                        }else{
+                        } else {
+                            // 如果没有待下载章节，发送下载完成的监听事件
                             RxBus.get().post(RxBusTag.FINISH_DOWNLOAD_LISTENER, new Object());
                         }
                     }
@@ -377,27 +416,43 @@ public class DownloadService extends Service {
                     }
                 });
     }
-
+    
+    // 方法作用：处理下载进度相关操作，发送下载进度相关信息到RxBus，并创建和发送通知展示下载进度情况
+// 参数：downloadChapterBean表示下载章节相关的数据对象，包含了如书籍名称、当前章节名称等信息
     private void isProgress(DownloadChapterBean downloadChapterBean) {
+        // 通过RxBus发送下载进度监听器相关的事件，传递下载章节数据对象，以便其他地方能接收到并处理进度信息
         RxBus.get().post(RxBusTag.PROGRESS_DOWNLOAD_LISTENER, downloadChapterBean);
 
+        // 创建一个意图，用于启动主活动（MainActivity），这里的上下文是当前类所在的上下文环境
         Intent mainIntent = new Intent(this, MainActivity.class);
+        // 根据创建的意图创建一个PendingIntent对象，用于后续设置到通知中，使得点击通知可以启动对应的活动
+        // 这里的请求码设置为0，并且设置当有相同请求码的PendingIntent更新时，更新当前的PendingIntent
         PendingIntent mainPendingIntent = PendingIntent.getActivity(this, 0, mainIntent, PendingIntent.FLAG_UPDATE_CURRENT);
-        //创建 Notification.Builder 对象
+
+        // 创建 Notification.Builder 对象，用于构建通知
         NotificationCompat.Builder builder = new NotificationCompat.Builder(this)
+                // 设置通知的小图标，这里使用的是资源文件中定义的ic_launcher图标
                 .setSmallIcon(R.mipmap.ic_launcher)
-                //点击通知后自动清除
+                // 设置点击通知后自动清除该通知
                 .setAutoCancel(true)
-                .setContentTitle("正在下载："+downloadChapterBean.getBookName())
-                .setContentText(downloadChapterBean.getDurChapterName()==null?"  ":downloadChapterBean.getDurChapterName())
+                // 设置通知的标题，展示正在下载的书籍名称
+                .setContentTitle("正在下载：" + downloadChapterBean.getBookName())
+                // 根据当前章节名称是否为空来设置通知的内容文本，如果为空则设置为空格，否则设置为章节名称
+                .setContentText(downloadChapterBean.getDurChapterName() == null? "  " : downloadChapterBean.getDurChapterName())
+                // 将前面创建的PendingIntent设置到通知中，使得点击通知能启动对应的活动
                 .setContentIntent(mainPendingIntent);
-        //发送通知
+
+        // 使用通知管理器发送通知，notifiId应该是预先定义好的通知的唯一标识，用于区分不同的通知
         notifyManager.notify(notifiId, builder.build());
     }
 
+    // 方法作用：完成下载相关的后续操作，发送下载完成的事件到RxBus，取消所有通知，并弹出提示告知用户全部离线章节下载完成
     private void finishDownload() {
+        // 通过RxBus发送下载完成监听器相关的事件，传递一个空的Object对象，作为完成下载的一种通知机制，方便其他地方监听并处理完成下载的情况
         RxBus.get().post(RxBusTag.FINISH_DOWNLOAD_LISTENER, new Object());
+        // 取消所有已发送的通知
         notifyManager.cancelAll();
+        // 在主线程中执行以下代码块，用于弹出一个短暂显示的Toast提示信息，告知用户全部离线章节下载完成
         new Handler(Looper.getMainLooper()).post(new Runnable() {
             @Override
             public void run() {
@@ -406,6 +461,8 @@ public class DownloadService extends Service {
         });
     }
 
+    // 方法作用：响应RxBus中PAUSE_DOWNLOAD事件，调用pauseDownload方法（此处假设pauseDownload方法在别处定义，用于暂停下载任务相关操作）
+// 该方法被标注为订阅RxBus中特定标签的事件，并且在主线程中执行
     @Subscribe(
             thread = EventThread.MAIN_THREAD,
             tags = {
@@ -416,6 +473,8 @@ public class DownloadService extends Service {
         pauseDownload();
     }
 
+    // 方法作用：响应RxBus中START_DOWNLOAD事件，调用startDownload方法（此处假设startDownload方法在别处定义，用于启动下载任务相关操作）
+// 该方法被标注为订阅RxBus中特定标签的事件，并且在主线程中执行
     @Subscribe(
             thread = EventThread.MAIN_THREAD,
             tags = {
@@ -426,6 +485,8 @@ public class DownloadService extends Service {
         startDownload();
     }
 
+    // 方法作用：响应RxBus中CANCEL_DOWNLOAD事件，调用cancelDownload方法（此处假设cancelDownload方法在别处定义，用于取消下载任务相关操作）
+// 该方法被标注为订阅RxBus中特定标签的事件，并且在主线程中执行
     @Subscribe(
             thread = EventThread.MAIN_THREAD,
             tags = {
@@ -436,6 +497,9 @@ public class DownloadService extends Service {
         cancelDownload();
     }
 
+    // 方法作用：响应RxBus中ADD_DOWNLOAD_TASK事件，调用addNewTask方法（此处假设addNewTask方法在别处定义，用于添加新的下载任务相关操作）
+// 该方法接收一个DownloadChapterListBean类型的对象newData，从其中获取具体的数据（假设是下载任务列表数据）传递给addNewTask方法进行处理
+// 该方法被标注为订阅RxBus中特定标签的事件，并且在主线程中执行
     @Subscribe(
             thread = EventThread.MAIN_THREAD,
             tags = {
@@ -444,5 +508,4 @@ public class DownloadService extends Service {
     )
     public void addTask(DownloadChapterListBean newData) {
         addNewTask(newData.getData());
-    }
-}
+    }