Merge remote-tracking branch 'origin/书籍中心zgj' into 书籍中心zgj

tamguo-oms/src/main/java/com/tamguo/Application.java

@@ -10,26 +10,58 @@ import com.alibaba.fastjson.serializer.SerializerFeature;
 import com.alibaba.fastjson.support.config.FastJsonConfig;
 import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
 
+// @SpringBootApplication是一个组合注解，它整合了多个Spring相关的注解，例如：
+// @Configuration：表明这个类可以作为一个配置类，用于定义Spring容器中的Bean等配置信息。
+// @EnableAutoConfiguration：启用Spring Boot的自动配置功能，会根据项目依赖等情况自动配置很多默认的组件，比如数据源、Web相关配置等，大大简化了项目的配置过程。
+// @ComponentScan：用于指定Spring要扫描的组件所在的包路径，默认会扫描当前类所在的包及其子包下的所有标注了Spring相关组件注解（如@Component、@Service、@Controller等）的类，并将它们注册到Spring容器中，以便进行依赖注入等操作。
+// 这个注解标注在类上，意味着这是一个Spring Boot应用的主启动类，整个应用从这里开始启动并加载相关配置。
 @SpringBootApplication
 public class Application {
 
+	/**
+	 * 这是Java应用程序的入口方法，在Spring Boot应用中，通过调用SpringApplicationBuilder来构建并启动Spring Boot应用。
+	 * SpringApplicationBuilder允许以编程方式对Spring Boot应用的启动过程进行更多的定制化配置（虽然这里只是简单传入Application类本身作为参数启动应用），
+	 * 它会根据配置类（这里就是标注了@SpringBootApplication注解的Application类）以及相关依赖、配置等信息，初始化Spring容器，加载各种自动配置的组件，最终启动整个应用程序。
+	 *
+	 * @param args 命令行参数，可以在启动应用时传入一些自定义的参数，在应用中可以通过相应的方式获取并使用这些参数来进行一些初始化操作或者配置调整等，不过这里暂时没有对传入的参数进行额外处理。
+	 */
 	public static void main(String[] args) {
 		new SpringApplicationBuilder(Application.class).run(args);
 	}
-	
+
 	/**
-	 * FastJson替代Jackson
-	 * @return
+	 * 自定义方法，用于创建并配置一个基于FastJSON的HttpMessageConverter，目的是让Spring Boot应用在处理HTTP消息（比如请求和响应的JSON数据转换）时，使用FastJSON替代默认的Jackson进行JSON序列化和反序列化操作。
+	 * 通过将这个方法标记为@Bean注解，Spring会将该方法返回的对象作为一个Bean注册到Spring容器中，以便在需要进行HTTP消息转换时能够自动使用它。
+	 *
+	 * @return 返回一个HttpMessageConverters对象，其中包含了配置好的FastJsonHttpMessageConverter，用于在Spring Boot应用的Web相关处理中进行JSON格式的数据转换。
 	 */
 	@Bean
 	public HttpMessageConverters fastJsonHttpMessageConverters() {
+		// 创建一个FastJsonHttpMessageConverter实例，它是Spring中用于将对象转换为JSON格式以及将JSON数据反序列化为对象的一个实现类，
+		// 这里我们要使用FastJSON的功能，所以创建它的实例来进行后续配置，使其能按照我们期望的方式处理JSON数据转换。
 		FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter();
+
+		// 创建一个FastJsonConfig对象，用于配置FastJSON的各种序列化和反序列化相关的参数、特性等，以便让FastJSON按照我们的业务需求来处理JSON数据。
 		FastJsonConfig fastJsonConfig = new FastJsonConfig();
+
+		// 设置FastJSON序列化日期类型数据时的日期格式，这里指定为"yyyy-MM-dd HH:mm:ss"，这样在将包含日期属性的Java对象序列化为JSON字符串时，日期字段会按照这个格式进行展示，
+		// 使得前端或者其他调用方接收到的日期格式更加规范和统一，便于处理和展示。
 		fastJsonConfig.setDateFormat("yyyy-MM-dd HH:mm:ss");
+
+		// 设置FastJSON的序列化特性，SerializerFeature.DisableCircularReferenceDetect表示禁用循环引用检测，
+		// 当Java对象之间存在复杂的相互引用关系时，如果不进行处理，在序列化过程中可能会陷入死循环或者生成不符合预期的JSON结构，
+		// 通过禁用这个检测（具体根据业务场景，如果确定不会出现循环引用问题或者有其他处理方式时可以这样设置），可以按照一定的规则来处理这种引用关系，生成期望的JSON数据。
 		fastJsonConfig.setSerializerFeatures(SerializerFeature.DisableCircularReferenceDetect);
+
+		// 将配置好的FastJsonConfig对象设置到FastJsonHttpMessageConverter中，这样FastJsonHttpMessageConverter在进行JSON序列化和反序列化操作时，
+		// 就会按照我们配置好的FastJsonConfig中的参数和特性来进行处理了。
 		fastConverter.setFastJsonConfig(fastJsonConfig);
+
+		// 这里再次将fastConverter赋值给converter变量，其实是多余的操作，因为前面已经完成了配置，可以直接使用fastConverter变量，不过这并不影响整体功能，只是代码上有些冗余。
 		FastJsonHttpMessageConverter converter = fastConverter;
+
+		// 创建并返回一个HttpMessageConverters对象，将配置好的FastJsonHttpMessageConverter作为参数传入，
+		// 这样Spring Boot在处理HTTP消息时，就会识别到这个自定义的消息转换器，并使用它来进行JSON相关的数据转换了。
 		return new HttpMessageConverters(converter);
 	}
-	
-}
+}

tamguo-oms/src/main/java/com/tamguo/modules/tiku/web/ChapterController.java

@@ -15,69 +15,154 @@ import com.tamguo.modules.tiku.model.ChapterEntity;
 import com.tamguo.modules.tiku.model.condition.ChapterCondition;
 import com.tamguo.modules.tiku.service.IChapterService;
 
+// 使用 @Controller 注解将该类标记为 Spring MVC 中的控制器类，表明它主要负责处理与题库章节相关的 Web 请求，
+// 通过调用对应的业务逻辑层（IChapterService）的方法，实现诸如章节信息的查询、添加、修改、删除以及以不同格式返回章节相关数据（如列表、树形结构数据等）等操作，
+// 是系统中题库章节功能模块在 Web 层面交互的核心组件。
 @Controller
-@RequestMapping(path="tiku/chapter")
-public class  {
-	
+// 通过 @RequestMapping 注解为该控制器类下的所有请求路径设置一个公共的前缀，意味着此类中定义的所有请求处理方法对应的路径都是以 "tiku/chapter" 开头，
+// 便于对题库章节相关的众多请求进行统一管理和分类，使代码结构更加清晰有条理。
+@RequestMapping(path = "tiku/chapter")
+public class ChapterController { // 这里类名缺失，推测应该是ChapterController，补上使其完整
+
+	// 定义新增章节页面的视图名称，按照 Spring MVC 视图解析机制，这个字符串对应着实际存放新增章节相关展示内容的模板文件路径（比如可能是 JSP、Thymeleaf 等模板文件所在的路径），
+	// 用于在添加新章节时向用户展示相应的操作界面，引导用户输入章节相关信息。
 	private final String ADD_CHAPTER_PAGE = "modules/tiku/chapter/add";
+	// 定义修改章节页面的视图名称，对应展示修改章节已有信息相关内容的模板文件路径，
+	// 在这个页面上，用户可以对已存在的章节记录进行编辑修改操作，比如更新章节名称、所属上级章节等信息。
 	private final String UPDATE_CHAPTER_PAGE = "modules/tiku/chapter/update";
-	
+
+	// 通过 @Autowired 注解自动注入 IChapterService 接口的实现类实例，IChapterService 接口应该定义了一系列用于处理题库章节相关业务逻辑的方法，
+	// 例如查询章节详细信息、保存新章节、更新章节已有信息、删除章节以及获取章节的树形结构数据等功能，
+	// 借助这个注入的实例，本控制器类可以方便地与业务逻辑层交互，调用相应方法来完成各种题库章节相关的业务操作。
 	@Autowired
 	private IChapterService iChapterService;
-	
-	@RequestMapping(path="add",method=RequestMethod.GET)
-	public ModelAndView add(String parentChapterId , ModelAndView model) {
-	 	ChapterEntity parentChapter = iChapterService.selectById(parentChapterId);
-	 	model.addObject("parentChapter", parentChapter);
+
+	/**
+	 * 处理路径为 "tiku/chapter/add"（且请求方法限定为 GET）的请求方法，主要用于准备并返回新增章节页面相关的数据和视图，使得客户端能够进入新增章节的操作界面进行新章节信息的录入操作。
+	 *
+	 * @param parentChapterId 从请求中传递过来的字符串参数，用于指定新增章节的上级章节的唯一标识（例如章节编号等，具体取决于业务中章节实体类的设计），
+	 *                        通过这个标识去查询上级章节的详细信息，以便在新增章节页面展示相关的上级章节信息，可能用于体现章节的层级关系等情况。
+	 * @param model           ModelAndView 对象，用于设置视图名称以及添加要传递给视图的数据（在这里就是上级章节对象信息），实现数据与视图的整合，
+	 *                        确保视图层能获取到完整信息用于新增章节页面的展示和操作，方便用户进行新章节信息的填写，并参考上级章节情况。
+	 * @return 返回包含了设置好的视图名称（ADD_CHAPTER_PAGE）以及添加了上级章节对象数据的 ModelAndView 对象，供 Spring MVC 进行视图渲染展示，将新增章节页面展示给客户端。
+	 */
+	@RequestMapping(path = "add", method = RequestMethod.GET)
+	public ModelAndView add(String parentChapterId, ModelAndView model) {
+		// 通过调用 iChapterService 的 selectById 方法，依据传入的 parentChapterId 参数，从数据库等数据源中查询出对应的上级章节对象，
+		// 目的是在新增章节页面上展示新增章节所属的上级章节信息，方便用户知晓章节层级关系以及可能进行一些关联设置（比如继承上级章节的部分属性等情况，具体取决于业务需求）。
+		ChapterEntity parentChapter = iChapterService.selectById(parentChapterId);
+		model.addObject("parentChapter", parentChapter);
+		// 设置返回的视图名称为新增章节页面的视图名称（ADD_CHAPTER_PAGE），以便 Spring MVC 依据此名称找到对应的模板文件进行页面渲染展示，
+		// 从而向客户端呈现新增章节的操作界面。
 		model.setViewName(ADD_CHAPTER_PAGE);
 		return model;
 	}
-	
-	@RequestMapping(path="update" , method=RequestMethod.GET)
-	public ModelAndView update(String id , ModelAndView model) {
+
+	/**
+	 * 处理路径为 "tiku/chapter/update"（且请求方法限定为 GET）的请求方法，其功能是准备并返回修改章节信息页面相关的数据和视图，以便用户能够在页面上看到要修改的章节的详细信息，并进行相应的编辑修改操作。
+	 *
+	 * @param id    从请求中传递过来的字符串参数，用于唯一标识要修改的章节（例如章节编号等，具体由业务中章节实体类的设计决定），
+	 *              通过这个标识去查询要修改的章节对象以及其上级章节对象的详细信息，用于在修改页面展示相关内容，方便用户进行编辑操作。
+	 * @param model ModelAndView 对象，用于设置视图名称以及添加要传递给视图的章节对象和上级章节对象数据，实现数据与视图的整合，
+	 *              确保视图层能获取到完整信息用于修改章节信息页面的展示和操作，使得页面能够准确呈现要修改的章节及其关联的上级章节情况，便于用户进行修改操作。
+	 * @return 返回包含了设置好的视图名称（UPDATE_CHAPTER_PAGE）以及添加了章节对象和上级章节对象数据的 ModelAndView 对象，供 Spring MVC 进行视图渲染展示，将修改章节信息页面展示给客户端。
+	 */
+	@RequestMapping(path = "update", method = RequestMethod.GET)
+	public ModelAndView update(String id, ModelAndView model) {
+		// 通过调用 iChapterService 的 selectById 方法，依据传入的 id 参数，从数据库等数据源中查询出要修改的章节对象，
+		// 以便在修改页面上展示该章节的当前信息，供用户查看并确定要修改的具体内容。
 		ChapterEntity chapter = iChapterService.selectById(id);
+		// 接着再次调用 iChapterService 的 selectById 方法，依据查询到的章节对象中存储的上级章节编号（chapter.getParentCode()），查询出对应的上级章节对象，
+		// 这么做是为了在修改章节页面上同时展示出该章节所属的上级章节信息，方便用户参考上级章节情况来进行合理的章节信息修改，比如章节层级调整等操作（具体取决于业务需求）。
 		ChapterEntity parentChapter = iChapterService.selectById(chapter.getParentCode());
 		model.addObject("chapter", chapter);
 		model.addObject("parentChapter", parentChapter);
+		// 设置要返回的视图名称为修改章节页面的视图名称（UPDATE_CHAPTER_PAGE），使得 Spring MVC 能根据这个名称找到对应的模板文件进行渲染展示，
+		// 进而向客户端呈现修改章节信息的操作页面。
 		model.setViewName(UPDATE_CHAPTER_PAGE);
 		return model;
 	}
 
-	@RequestMapping(path="listData",method=RequestMethod.POST)
+	/**
+	 * 处理路径为 "tiku/chapter/listData"（且请求方法限定为 POST）的请求方法，主要用于查询并返回符合特定条件的章节列表数据。
+	 *
+	 * @param condition ChapterCondition 对象，用于封装查询章节列表时的各种条件，比如查询关键字、章节所属课程筛选条件、分页信息（如果有分页需求的话，虽然当前代码未体现分页相关操作）等，
+	 *                  根据这些条件去数据库等数据源中查询章节列表数据，满足不同业务场景下对章节数据查询的需求。
+	 * @return 返回一个包含符合条件的 ChapterEntity 类型对象的 List 集合，即查询到的章节列表数据，供客户端（可能是前端页面进行列表展示等操作）使用，
+	 * 这里直接返回查询结果，依赖于业务逻辑层（iChapterService）内部实现了按照条件查询章节列表的逻辑并返回正确的数据格式。
+	 */
+	@RequestMapping(path = "listData", method = RequestMethod.POST)
 	@ResponseBody
 	public List<ChapterEntity> listData(ChapterCondition condition) {
 		return iChapterService.listData(condition);
 	}
-	
-	@RequestMapping(path="treeData")
+
+	/**
+	 * 处理路径为 "tiku/chapter/treeData" 的请求方法，用于查询并返回以树形结构表示的章节数据，方便在前端以树形展示章节的层级关系等情况，返回的数据格式为 JSONArray（通常用于方便地转换为 JSON 格式并传递给前端）。
+	 *
+	 * @param courseId  从请求中传递过来的字符串参数，用于指定课程的唯一标识（例如课程编号等，具体取决于业务中课程实体类的设计），
+	 *                  通过这个标识去筛选出属于该课程下的所有章节，并构建成树形结构数据，用于在前端展示某一课程下的章节层级关系。
+	 * @param excludeId 从请求中传递过来的字符串参数，用于指定要排除的章节的唯一标识（例如章节编号等），在构建树形结构数据时，不包含这个指定的章节及其子章节（如果有子章节的话），
+	 *                  可能用于一些特殊业务场景，比如某个章节暂时不展示或者不参与某些操作时的情况，具体用途取决于业务需求。
+	 * @return 返回一个 JSONArray 类型的数据，其中包含了以树形结构组织的章节数据（具体的数据结构形式应该是符合前端树形组件能够解析和展示的格式，由业务逻辑层 iChapterService 的 treeData 方法构建生成），
+	 * 供前端接收并展示章节的树形结构，方便用户直观地查看章节的层级和包含关系等信息。
+	 */
+	@RequestMapping(path = "treeData")
 	@ResponseBody
-	public JSONArray treeData(String courseId , String excludeId) {
-		return iChapterService.treeData(courseId , excludeId);
+	public JSONArray treeData(String courseId, String excludeId) {
+		return iChapterService.treeData(courseId, excludeId);
 	}
-	
-	@RequestMapping(path="save")
+
+	/**
+	 * 处理路径为 "tiku/chapter/save" 的请求方法，用于保存新的章节信息，将客户端提交的章节相关数据保存到数据库等存储介质中，
+	 * 并返回保存操作的结果给客户端，结果以 JSON 格式响应，告知客户端保存是否成功以及相应提示信息。
+	 *
+	 * @param chapter 包含了新章节相关信息的 ChapterEntity 对象，从客户端提交的数据中获取，其中包含了如章节名称、上级章节编号、所属课程等必要的章节属性信息，
+	 *                通过调用业务逻辑层的保存方法，将这些信息持久化存储到数据库，完成新章节的添加操作。
+	 * @return 返回一个 Result 对象，若保存操作成功，通过 Result 类的 result 方法构建一个包含成功状态码（0 表示成功）、提示信息（表明章节【章节名称】添加成功，方便客户端展示友好的提示内容告知用户操作结果，其中章节名称通过 chapter.getName() 获取）以及空的数据部分（因为添加成功后通常不需要返回额外的数据）的 Result 对象返回给客户端；
+	 * 若保存过程中出现异常，调用 ExceptionSupport 的 resolverResult 方法处理异常，并将处理后的结果（同样包装在 Result 对象中）返回给客户端，客户端可以根据返回的 Result 对象判断保存操作是否成功以及获取相应的提示信息等。
+	 */
+	@RequestMapping(path = "save")
 	@ResponseBody
 	public Result save(ChapterEntity chapter) {
 		try {
 			iChapterService.save(chapter);
-			return Result.result(0, null, "章节【"+chapter.getName()+"】添加成功！");
+			return Result.result(0, null, "章节【" + chapter.getName() + "】添加成功！");
 		} catch (Exception e) {
 			return ExceptionSupport.resolverResult("保存章节", this.getClass(), e);
 		}
 	}
-	
-	@RequestMapping(path="update")
+
+	/**
+	 * 处理路径为 "tiku/chapter/update" 的请求方法（此路径下有两个方法，一个用于处理 GET 请求展示修改页面，一个用于处理 POST 请求提交修改内容并执行更新操作，这里是处理 POST 请求执行更新操作的情况），
+	 * 用于更新已存在的章节信息，将客户端提交的修改后的章节数据更新到数据库等存储介质中，
+	 * 并返回更新操作的结果给客户端，结果以 JSON 格式响应，告知客户端更新是否成功以及相应提示信息。
+	 *
+	 * @param chapter 包含了修改后章节相关信息的 ChapterEntity 对象，从客户端提交的数据中获取，其中包含了如章节名称、上级章节编号、所属课程等章节属性信息的更新后内容，
+	 *                通过调用业务逻辑层的更新方法，将这些修改后的数据更新到数据库中对应的章节记录上，完成章节信息的修改操作。
+	 * @return 返回一个 Result 对象，若更新操作成功，通过 Result 类的 result 方法构建一个包含成功状态码（0 表示成功）、提示信息（表明章节【章节名称】修改成功，便于客户端展示友好的提示告知用户操作结果，其中章节名称通过 chapter.getName() 获取）以及空的数据部分（因为更新成功后通常不需要返回额外的数据）的 Result 对象返回给客户端；
+	 * 若更新过程中出现异常，调用 ExceptionSupport 的 resolverResult 方法处理异常，并将处理后的结果（同样包装在 Result 对象中）返回给客户端，客户端可以根据返回的 Result 对象判断更新操作是否成功以及获取相应的提示信息等。
+	 */
+	@RequestMapping(path = "update", method = RequestMethod.POST)
 	@ResponseBody
 	public Result update(ChapterEntity chapter) {
 		try {
 			iChapterService.update(chapter);
-			return Result.result(0, null, "章节【"+chapter.getName()+"】修改成功！");
+			return Result.result(0, null, "章节【" + chapter.getName() + "】修改成功！");
 		} catch (Exception e) {
 			return ExceptionSupport.resolverResult("修改章节", this.getClass(), e);
 		}
 	}
-	
-	@RequestMapping(path="delete" , method=RequestMethod.POST)
+
+	/**
+	 * 处理路径为 "tiku/chapter/delete"（且请求方法限定为 POST）的请求方法，用于删除指定的章节信息，根据传入的章节唯一标识（id）从数据库等存储介质中删除对应的章节记录，
+	 * 并返回删除操作的结果给客户端，结果以 JSON 格式响应，告知客户端删除是否成功以及相应提示信息。
+	 *
+	 * @param id 从请求中传递过来的字符串参数，用于唯一标识要删除的章节（例如章节编号等，具体取决于业务中章节实体类的设计），通过这个标识定位到数据库中对应的章节记录进行删除操作。
+	 * @return 返回一个 Result 对象，若删除操作成功，通过 Result 类的 result 方法构建一个包含成功状态码（0 表示成功）、提示信息（表明章节删除成功，用于客户端展示简单明了的提示告知用户操作结果）以及空的数据部分（因为删除成功后通常不需要返回额外的数据）的 Result 对象返回给客户端；
+	 * 若删除过程中出现异常，调用 ExceptionSupport 的 resolverResult 方法处理异常，并将处理后的结果（同样包装在 Result 对象中）返回给客户端，客户端可以根据返回的 Result 对象判断删除操作是否成功以及获取相应的提示信息等。
+	 */
+	@RequestMapping(path = "delete", method = RequestMethod.POST)
 	@ResponseBody
 	public Result delete(String id) {
 		try {
@@ -87,4 +172,4 @@ public class  {
 			return ExceptionSupport.resolverResult("删除章节", this.getClass(), e);
 		}
 	}
-}
+}

tamguo-oms/src/main/java/com/tamguo/modules/tiku/web/CourseController.java

@@ -19,38 +19,93 @@ import com.tamguo.modules.tiku.model.enums.SubjectStatusEnum;
 import com.tamguo.modules.tiku.service.ICourseService;
 import com.tamguo.modules.tiku.service.ISubjectService;
 
+// @Controller注解表明这个类是Spring MVC框架中的控制器类，主要负责处理与题库课程相关的Web请求，
+// 通过调用相关的业务服务层（ICourseService、ISubjectService）方法来实现诸如展示课程相关页面、处理课程数据查询、进行课程信息的增删改等操作，
+// 是整个系统中题库课程业务模块在Web层面交互的核心控制部分。
 @Controller
-@RequestMapping(path="tiku/course")
+// @RequestMapping注解为这个控制器类下的所有请求路径设置一个公共前缀，即该控制器主要处理以"tiku/course"开头的请求路径，
+// 便于对题库课程相关的众多不同类型请求进行统一的分类管理，使代码结构更加清晰，便于维护和扩展。
+@RequestMapping(path = "tiku/course")
 public class CourseController {
 
+	// 以下定义了多个常量字符串，分别代表不同课程相关页面的视图名称，按照Spring MVC的视图解析规则，这些字符串对应着实际存放课程相关展示内容的模板文件路径（比如可能是JSP、Thymeleaf等不同类型模板文件的具体路径），
+	// 用于在不同业务场景下展示相应的课程页面内容。
+
 	/** 科目*/
 	private final String COURSE_INDEX_PAGE = "modules/tiku/course/list";
 	private final String COURSE_ADD_PAGE = "modules/tiku/course/add";
 	private final String COURSE_UPDATE_PAGE = "modules/tiku/course/update";
-	
+
+	// 通过@Autowired注解自动注入ICourseService接口的实现类实例，ICourseService接口中定义了一系列与题库课程核心业务相关的方法，
+	// 比如查询课程详细信息、保存新的课程数据、更新课程已有记录等操作，借助这个注入的实例，本控制器类能够方便地调用这些业务逻辑方法，实现与业务逻辑层的交互，从而完成系统课程相关业务的具体处理。
 	@Autowired
 	private ICourseService iCourseService;
+
+	// 通过@Autowired注解自动注入ISubjectService接口的实现类实例，ISubjectService主要用于处理与科目相关的业务逻辑，
+	// 例如可以查询处于特定状态（如正常状态）的科目列表等操作，在系统课程相关业务中，科目信息往往和课程存在关联关系（比如课程属于某个科目范畴等情况），
+	// 所以注入该实例辅助完成涉及科目相关的课程业务处理，使整个课程业务逻辑更加完善。
 	@Autowired
 	private ISubjectService iSubjectService;
-	
+
+	/**
+	 * 处理路径为"tiku/course/list"的请求的方法，其主要功能是准备并返回课程列表页面相关的数据和视图信息。
+	 * 当客户端发起该请求时，此方法会被调用，首先通过调用model.setViewName(COURSE_INDEX_PAGE)将返回的视图名称设置为课程列表页面对应的视图名称（COURSE_INDEX_PAGE），
+	 * 接着利用注入的ISubjectService实例，通过其selectList方法结合MyBatis Plus的条件构造器（Condition.create().eq("status", SubjectStatusEnum.NORMAL.getValue())）查询状态为正常的科目列表，
+	 * 并将查询得到的科目列表数据添加到ModelAndView对象中，ModelAndView对象在Spring MVC中用于承载视图名称以及要传递给视图的数据，
+	 * 最后将这个包含了视图名称和科目列表数据的ModelAndView对象返回，Spring MVC框架会依据这些信息去正确地渲染展示课程列表页面，
+	 * 使得用户在访问该页面时，不仅能看到课程信息列表，还能看到相关的科目信息，方便进行一些关联查看等操作。
+	 * 此处使用了@SuppressWarnings("unchecked")注解来抑制编译器可能产生的unchecked类型警告，
+	 * 因为在将科目列表数据添加到ModelAndView对象时，编译器可能无法准确判断添加的数据类型是否完全符合预期（但在实际业务逻辑中确保了类型的正确性），使用该注解可以避免不必要的警告提示。
+	 *
+	 * @param model ModelAndView对象，用于在方法内部设置视图名称以及添加要传递给视图的数据（在这里就是科目列表数据），
+	 *              通过它实现了数据与视图的整合，确保视图层能够获取到正确的数据进行页面展示，满足课程列表页面展示科目相关信息的业务需求。
+	 * @return 返回包含了设置好的视图名称（COURSE_INDEX_PAGE）以及添加了科目列表数据的ModelAndView对象，供Spring MVC框架进行视图渲染展示，从而向客户端呈现课程列表页面。
+	 */
 	@SuppressWarnings("unchecked")
-	@RequestMapping(path="list")
+	@RequestMapping(path = "list")
 	public ModelAndView index(ModelAndView model) {
 		model.setViewName(COURSE_INDEX_PAGE);
 		model.addObject("subjectList", iSubjectService.selectList(Condition.create().eq("status", SubjectStatusEnum.NORMAL.getValue())));
 		return model;
 	}
-	
+
+	/**
+	 * 处理路径为"tiku/course/add"的请求的方法，作用是准备并返回新增课程页面相关的数据和视图。
+	 * 当客户端发起对应请求时，该方法会被执行，首先将返回的视图名称设置为新增课程页面的视图名称（COURSE_ADD_PAGE），
+	 * 然后同样借助ISubjectService的selectList方法与条件构造器查询状态为正常的科目列表，并把该科目列表数据添加到ModelAndView对象中，
+	 * 最后返回包含了视图名称和科目列表数据的ModelAndView对象，Spring MVC依据这些信息进行视图渲染展示，向客户端呈现新增课程页面，方便用户在页面上填写新课程的各项信息，
+	 * 同时参考科目列表来确定课程所属的科目等相关操作。
+	 * 同样使用了@SuppressWarnings("unchecked")注解来抑制类型未检查的警告，原因与上述index方法类似，即避免编译器对添加科目列表数据时可能出现的类型警告提示。
+	 *
+	 * @param model ModelAndView对象，用于设置视图名称以及添加要传递给视图的数据（在这里就是科目列表数据），实现数据与视图的整合，
+	 *              确保视图层能获取到完整信息用于新增课程页面的展示和操作，方便用户进行新课程信息的录入。
+	 * @return 返回包含了设置好的视图名称（COURSE_ADD_PAGE）以及添加了科目列表数据的ModelAndView对象，供Spring MVC进行视图渲染展示，展示新增课程页面给客户端。
+	 */
 	@SuppressWarnings("unchecked")
-	@RequestMapping(path="add")
+	@RequestMapping(path = "add")
 	public ModelAndView add(ModelAndView model) {
 		model.setViewName(COURSE_ADD_PAGE);
 		model.addObject("subjectList", iSubjectService.selectList(Condition.create().eq("status", SubjectStatusEnum.NORMAL.getValue())));
 		return model;
 	}
-	
+
+	/**
+	 * 处理路径为"tiku/course/update"的请求的方法，负责准备并返回修改课程信息页面相关的数据和视图。
+	 * 当客户端发起此请求时，方法首先设置要返回的视图名称为修改课程信息页面的视图名称（COURSE_UPDATE_PAGE），
+	 * 接着借助ISubjectService的selectList方法与条件构造器查询状态为正常的科目列表，并将科目列表数据添加到ModelAndView对象中，
+	 * 然后通过调用iCourseService.selectById(id)方法，依据传入的id参数（该参数用于指定要查询并修改的课程的唯一标识，比如课程编号等，具体由业务中课程实体类的设计决定）查询对应的课程信息，
+	 * 并把查询到的课程对象添加到ModelAndView对象中，最后返回包含了视图名称、科目列表数据以及课程对象数据的ModelAndView对象，
+	 * Spring MVC会根据这些信息正确地渲染展示修改课程信息页面，方便用户查看并编辑课程的各项信息以及参考相关科目信息。
+	 * 同样使用了@SuppressWarnings("unchecked")注解来抑制类型未检查的警告，原因与前面类似，即避免编译器对添加数据时可能出现的类型警告提示。
+	 *
+	 * @param id    从请求中传递过来的字符串参数，用于明确要查询并修改的课程的唯一标识，通过这个标识去数据库获取课程的现有信息以及相关的科目列表信息，
+	 *              以便在修改页面完整地展示相关内容，供用户进行课程信息的修改操作。
+	 * @param model ModelAndView对象，用于设置视图名称以及添加要传递给视图的科目列表数据和课程对象数据，实现数据与视图的整合，
+	 *              确保视图层能获取到完整信息用于修改课程信息页面的展示和操作，使得页面能够准确呈现课程及科目相关情况，便于课程信息修改操作的进行。
+	 * @return 返回包含了设置好的视图名称（COURSE_UPDATE_PAGE）以及添加了科目列表数据和课程对象数据的ModelAndView对象，供Spring MVC进行视图渲染展示，呈现修改课程信息页面给客户端。
+	 */
 	@SuppressWarnings("unchecked")
-	@RequestMapping(path="update")
+	@RequestMapping(path = "update")
 	public ModelAndView update(String id, ModelAndView model) {
 		model.setViewName(COURSE_UPDATE_PAGE);
 		model.addObject("subjectList", iSubjectService.selectList(Condition.create().eq("status", SubjectStatusEnum.NORMAL.getValue())));
@@ -58,72 +113,150 @@ public class CourseController {
 		return model;
 	}
 
-	@RequestMapping(path="listData",method=RequestMethod.POST)
+	/**
+	 * 处理路径为"tiku/course/listData"（且请求方法为POST的请求）的请求方法，用于查询并返回符合条件的课程列表数据，
+	 * 返回结果会以适合前端表格组件（如jqGrid等）使用的格式包装在Map中，并以JSON格式响应给客户端，方便前端进行数据展示和分页等操作。
+	 *
+	 * @param condition CourseCondition对象，用于封装查询课程列表的各种条件，比如查询关键字、分页信息、课程所属科目筛选等条件，根据这些条件去数据库等存储介质中查询课程列表，
+	 *                  满足不同业务场景下对课程数据查询的需求，其具体的条件设置和使用方式由业务逻辑层（iCourseService）的实现来决定。
+	 * @return 返回一个Map<String, Object>类型的对象，该对象通过调用Result.jqGridResult方法，将从分页查询结果（Page<CourseEntity>对象中获取的课程记录数据、总记录数、每页记录数、当前页码、总页数等信息）进行整合包装，
+	 * 形成符合前端表格组件期望格式的数据，方便前端能够方便地解析并展示课程列表数据以及进行分页等相关操作。
+	 */
+	@RequestMapping(path = "listData", method = RequestMethod.POST)
 	@ResponseBody
 	public Map<String, Object> listData(CourseCondition condition) {
 		Page<CourseEntity> page = iCourseService.listData(condition);
 		return Result.jqGridResult(page.getRecords(), page.getTotal(), page.getSize(), page.getCurrent(), page.getPages());
 	}
-	
-	@RequestMapping(path="save",method=RequestMethod.POST)
+
+	/**
+	 * 处理路径为"tiku/course/save"（且请求方法为POST的请求）的请求方法，用于保存新的课程信息，将客户端提交的课程相关数据保存到数据库等存储介质中，
+	 * 并返回保存操作的结果给客户端，结果以JSON格式响应，告知客户端保存是否成功以及相关提示信息等内容。
+	 *
+	 * @param course CourseEntity对象，包含了新的课程相关信息，比如课程名称、所属科目、课程描述等属性信息，这些信息从客户端提交的数据中获取，
+	 *               通过调用iCourseService的save方法，将该课程对象的信息持久化存储到数据库中，完成新的课程信息保存操作。
+	 * @return 返回一个Result对象，若保存操作成功，通过Result类的result方法构建一个包含成功状态码（0表示成功）、提示信息（表明保存科目【课程名称】成功，方便客户端展示友好的提示告知用户操作结果，其中课程名称通过course.getName()获取）以及空的数据部分（因为保存成功后通常不需要返回额外的数据）的Result对象返回给客户端；
+	 * 若保存过程中出现异常，调用ExceptionSupport的resolverResult方法处理异常，并将处理后的结果（同样包装在Result对象中）返回给客户端，客户端可以根据返回的Result对象判断保存操作是否成功以及获取相应的提示信息等。
+	 */
+	@RequestMapping(path = "save", method = RequestMethod.POST)
 	@ResponseBody
 	public Result save(CourseEntity course) {
 		try {
 			iCourseService.save(course);
-			return Result.result(0, null, "保存科目【"+course.getName()+"】成功");
+			return Result.result(0, null, "保存科目【" + course.getName() + "】成功");
 		} catch (Exception e) {
 			return ExceptionSupport.resolverResult("保存科目", this.getClass(), e);
 		}
 	}
-	
-	@RequestMapping(path="update",method=RequestMethod.POST)
+
+	/**
+	 * 处理路径为"tiku/course/update"（且请求方法为POST的请求）的请求方法，用于更新已存在的课程信息，将客户端提交的修改后的课程数据更新到数据库等存储介质中，
+	 * 并返回更新操作的结果给客户端，结果以JSON格式响应，告知客户端更新是否成功以及相应提示信息等内容。
+	 *
+	 * @param course CourseEntity对象，包含了修改后的课程相关信息，例如课程名称、所属科目、课程描述等属性信息的更新后内容，这些信息从客户端提交的数据中获取，
+	 *               通过调用iCourseService的update方法，将该课程对象中修改后的信息更新到数据库中对应的课程记录上，完成课程信息的修改操作。
+	 * @return 返回一个Result对象，若更新操作成功，通过Result类的result方法构建一个包含成功状态码（0表示成功）、提示信息（表明修改科目【课程名称】成功，便于客户端展示友好的提示告知用户操作结果，其中课程名称通过course.getName()获取）以及空的数据部分（因为更新成功后通常不需要返回额外的数据）的Result对象返回给客户端；
+	 * 若更新过程中出现异常，调用ExceptionSupport的resolverResult方法处理异常，并将处理后的结果（同样包装在Result对象中）返回给客户端，客户端可以根据返回的Result对象判断更新操作是否成功以及获取相应的提示信息等。
+	 */
+	@RequestMapping(path = "update", method = RequestMethod.POST)
 	@ResponseBody
 	public Result update(CourseEntity course) {
 		try {
 			iCourseService.update(course);
-			return Result.result(0, null, "修改科目【"+course.getName()+"】成功");
+			return Result.result(0, null, "修改科目【" + course.getName() + "】成功");
 		} catch (Exception e) {
 			return ExceptionSupport.resolverResult("修改科目", this.getClass(), e);
 		}
 	}
-	
-	@RequestMapping(path="delete",method=RequestMethod.POST)
-	@ResponseBody
-	public Result delete(String id) {
-		try {
-			iCourseService.delete(id);
-			return Result.result(0, null, "删除科目成功");
-		} catch (Exception e) {
-			return ExceptionSupport.resolverResult("删除科目", this.getClass(), e);
+}
+
+		/**
+		 * 处理路径为 "tiku/course/delete"（且请求方法限定为 POST）的请求方法，用于删除指定的课程信息，根据传入的课程唯一标识（id）从数据库等存储介质中删除对应的课程记录，
+		 * 并返回删除操作的结果给客户端，结果以 JSON 格式响应，告知客户端删除是否成功以及相应提示信息。
+		 *
+		 * @param id 从请求中传递过来的字符串参数，用于唯一标识要删除的课程（例如课程编号等，具体取决于业务中课程实体类的设计），通过这个标识定位到数据库中对应的课程记录进行删除操作。
+		 * @return 返回一个 Result 对象，若删除操作成功，通过 Result 类的 result 方法构建一个包含成功状态码（0 表示成功）、提示信息（表明删除科目成功，用于客户端展示简单明了的提示告知用户操作结果）以及空的数据部分（因为删除成功后通常不需要返回额外的数据）的 Result 对象返回给客户端；
+		 * 若删除过程中出现异常，调用 ExceptionSupport 的 resolverResult 方法处理异常，并将处理后的结果（同样包装在 Result 对象中）返回给客户端，客户端可以根据返回的 Result 对象判断删除操作是否成功以及获取相应的提示信息等。
+		 */
+		@RequestMapping(path = "delete", method = RequestMethod.POST)
+		@ResponseBody
+		public Result delete(String id) {
+			try {
+				// 调用 iCourseService 的 delete 方法，传入表示要删除课程的唯一标识（id），
+				// 由业务逻辑层去执行具体的删除课程的逻辑，例如从数据库中删除该课程的相关记录等操作，以完成删除课程的业务需求。
+				iCourseService.delete(id);
+				return Result.result(0, null, "删除科目成功");
+			} catch (Exception e) {
+				// 如果在删除课程操作过程中出现异常，调用 ExceptionSupport 的 resolverResult 方法来处理异常情况。
+				// 该方法可能会记录异常详情到日志、返回合适的错误提示等操作，并返回处理后的结果（同样包装在 Result 对象中），
+				// 客户端可以根据接收到的返回值判断删除操作是否成功以及是否出现异常情况，进而进行相应的处理（如向用户展示错误提示等）。
+				return ExceptionSupport.resolverResult("删除科目", this.getClass(), e);
+			}
 		}
-	}
-	
-	@RequestMapping(path="enable",method=RequestMethod.POST)
-	@ResponseBody
-	public Result enable(String id) {
-		try {
-			iCourseService.enable(id);
-			return Result.result(0, null, "激活科目成功");
-		} catch (Exception e) {
-			return ExceptionSupport.resolverResult("激活科目", this.getClass(), e);
+
+		/**
+		 * 处理路径为 "tiku/course/enable"（且请求方法限定为 POST）的请求方法，用于激活指定的课程，依据传入的课程编号（id）找到对应的课程，
+		 * 通过调用业务逻辑层相应方法来执行激活操作，并根据操作结果返回对应信息给客户端，告知激活操作是否成功。
+		 * 结果以 JSON 格式返回给客户端，便于客户端解析和后续的展示提示信息等处理，告知用户激活课程的操作结果。
+		 *
+		 * @param id 从请求中传递过来的字符串参数，用于唯一标识要激活的课程（例如课程编号等，具体取决于业务中课程实体类的设计），
+		 *           通过这个标识去数据库等存储介质中定位到对应的课程记录，以便执行激活操作，将课程的状态修改为激活状态（具体的状态修改逻辑由业务逻辑层 iCourseService 的 enable 方法实现）。
+		 * @return 返回一个 Result 对象，若激活操作成功，通过 Result 类的 result 方法构建一个包含成功状态码（0 表示成功）、提示信息（表明激活科目成功，便于客户端向用户展示清晰的操作成功提示）以及空的数据部分（通常激活成功后不需要额外返回其他数据）的 Result 对象返回给客户端；
+		 * 若激活过程中出现异常，调用 ExceptionSupport 的 resolverResult 方法来处理异常情况，该方法会进行记录异常信息、返回合适的错误提示等操作，然后返回处理后的结果（返回的也是包装在 Result 对象中），
+		 * 客户端可根据接收到的返回值判断激活操作是否成功以及是否有异常发生，进而进行后续处理（例如向用户展示错误提示等）。
+		 */
+		@RequestMapping(path = "enable", method = RequestMethod.POST)
+		@ResponseBody
+		public Result enable(String id) {
+			try {
+				// 调用 iCourseService 的 enable 方法，传入代表要激活课程的唯一标识（id），
+				// 由业务逻辑层去执行具体的激活课程的逻辑，比如在数据库中将课程的状态修改为激活状态等操作，以此实现激活课程的业务要求。
+				iCourseService.enable(id);
+				return Result.result(0, null, "激活科目成功");
+			} catch (Exception e) {
+				// 当激活课程操作出现异常时，调用 ExceptionSupport 的 resolverResult 方法来处理异常情况。
+				// 此方法会进行记录异常信息、返回合适的错误提示等操作，然后返回处理后的结果（返回 null 表示操作失败，出现异常），
+				// 客户端可根据接收到的返回值判断激活操作是否成功以及是否有异常发生，进而进行后续处理（例如向用户展示错误提示等）。
+				return ExceptionSupport.resolverResult("激活科目", this.getClass(), e);
+			}
 		}
-	}
-	
-	@RequestMapping(path="disabled",method=RequestMethod.POST)
-	@ResponseBody
-	public Result disabled(String id) {
-		try {
-			iCourseService.disabled(id);
-			return Result.result(0, null, "停用科目成功");
-		} catch (Exception e) {
-			return ExceptionSupport.resolverResult("停用科目", this.getClass(), e);
+
+		/**
+		 * 处理路径为 "tiku/course/disabled"（且请求方法限定为 POST）的请求方法，用于停用指定的课程，按照传入的课程编号（id）来定位要停用的课程，
+		 * 通过调用业务逻辑层相关方法执行停用操作，并依据操作结果返回相应信息给客户端，告知停用操作是否成功。
+		 * 结果以 JSON 格式返回给客户端，方便客户端解析并展示相应的提示信息，告知用户停用课程的操作结果。
+		 *
+		 * @param id 从请求中传递过来的字符串参数，用于唯一标识要停用的课程（例如课程编号等，具体取决于业务中课程实体类的设计），
+		 *           通过这个标识去数据库等存储介质中找到对应的课程记录，以便执行停用操作，将课程的状态修改为停用状态（具体的状态修改逻辑由业务逻辑层 iCourseService 的 disabled 方法实现）。
+		 * @return 返回一个 Result 对象，若停用操作成功，通过 Result 类的 result 方法构建一个包含成功状态码（0 表示成功）、提示信息（表明停用科目成功，方便客户端向用户展示清晰的操作成功提示）以及空的数据部分（通常停用成功后不需要额外返回其他数据）的 Result 对象返回给客户端；
+		 * 若停用过程中出现异常，调用 ExceptionSupport 的 resolverResult 方法来处理异常情况，该方法会进行记录异常信息、返回合适的错误提示等操作，然后返回处理后的结果（返回的也是包装在 Result 对象中），
+		 * 客户端可根据接收到的返回值判断停用操作是否成功以及是否有异常发生，进而进行后续处理（例如向用户展示错误提示等）。
+		 */
+		@RequestMapping(path = "disabled", method = RequestMethod.POST)
+		@ResponseBody
+		public Result disabled(String id) {
+			try {
+				// 调用 iCourseService 的 disabled 方法，传入用于标识要停用课程的课程编号（id），
+				// 由业务逻辑层去执行具体的停用课程的逻辑，例如在数据库中将课程的状态标记为停用状态等操作，以实现停用课程的业务需求。
+				iCourseService.disabled(id);
+				return Result.result(0, null, "停用科目成功");
+			} catch (Exception e) {
+				// 若在停用课程操作过程中出现异常，调用 ExceptionSupport 的 resolverResult 方法来处理异常情况。
+				// 此方法会进行记录异常信息、返回合适的错误提示等操作，然后返回处理后的结果（返回 null 表示操作失败，出现异常），
+				// 客户端可以根据接收到的返回值判断停用操作是否成功以及是否出现异常情况，进而进行相应的处理（如向用户展示错误提示等）。
+				return ExceptionSupport.resolverResult("停用科目", this.getClass(), e);
+			}
 		}
-	}
-	
-	@RequestMapping(path="treeData",method=RequestMethod.GET)
-	@ResponseBody
-	public JSONArray treeData() {
-		return iCourseService.treeData();
-	}
-	
-}
+
+		/**
+		 * 处理路径为 "tiku/course/treeData"（且请求方法限定为 GET）的请求方法，用于查询并返回以树形结构表示的课程数据，方便在前端以树形展示课程的层级关系等情况，返回的数据格式为 JSONArray（通常用于方便地转换为 JSON 格式并传递给前端）。
+		 * 此方法无参数传入，由业务逻辑层（iCourseService）内部根据既定的业务规则和数据关联关系来构建课程的树形结构数据，例如可能根据课程的分类、所属科目等层级关系构建树形结构。
+		 *
+		 * @return 返回一个 JSONArray 类型的数据，其中包含了以树形结构组织的课程数据（具体的数据结构形式应该是符合前端树形组件能够解析和展示的格式，由业务逻辑层 iCourseService 的 treeData 方法构建生成），
+		 * 供前端接收并展示课程的树形结构，方便用户直观地查看课程的层级和包含关系等信息。
+		 */
+		@RequestMapping(path = "treeData", method = RequestMethod.GET)
+		@ResponseBody
+		public JSONArray treeData() {
+			return iCourseService.treeData();
+		}

tamguo-oms/src/main/java/com/tamguo/modules/tiku/web/KnowPointController.java

@@ -18,66 +18,138 @@ import com.tamguo.modules.tiku.model.condition.BookCondition;
 import com.tamguo.modules.tiku.service.IKnowPointService;
 import com.tamguo.modules.tiku.service.ICourseService;
 
+// 使用 @Controller 注解将该类标记为 Spring MVC 中的控制器类，意味着它主要负责处理与题库知识点（KnowPoint）相关的 Web 请求，
+// 通过调用对应的业务逻辑层（IKnowPointService、ICourseService）的方法，实现诸如展示知识点相关页面、处理知识点数据查询、进行知识点信息的增删改以及获取知识点树形结构数据等操作，
+// 是系统中题库知识点功能模块在 Web 层面交互的核心组件。
 @Controller
-@RequestMapping(path="tiku/knowpoint")
+// 通过 @RequestMapping 注解为该控制器类下的所有请求路径设置一个公共的前缀，表明此类中定义的所有请求处理方法对应的路径都是以 "tiku/knowpoint" 开头，
+// 便于对题库知识点相关的众多请求进行统一管理和分类，使代码结构更加清晰有条理。
+@RequestMapping(path = "tiku/knowpoint")
 public class KnowPointController {
 
-	/** 书籍*/
+	// 以下定义了多个字符串常量，分别对应不同知识点相关操作页面的视图名称，在 Spring MVC 的视图解析机制下，
+	// 这些常量值会指向具体的页面模板文件（比如 JSP、Thymeleaf 等模板文件）所在的路径，用于在相应业务场景下展示对应的页面内容。
+
+	/** 书籍 */
 	private final String KNOWPOINT_LIST_PAGE = "modules/tiku/knowpoint/list";
 	private final String KNOWPOINT_UPDATE_PAGE = "modules/tiku/knowpoint/update";
-	
+
+	// 通过 @Autowired 注解自动注入 IKnowPointService 接口的实现类实例，IKnowPointService 接口应该定义了一系列用于处理题库知识点相关业务逻辑的方法，
+	// 例如查询知识点详细信息、保存新的知识点、更新知识点已有信息、删除知识点以及获取知识点的树形结构数据等功能，
+	// 借助这个注入的实例，本控制器类可以方便地与业务逻辑层交互，调用相应方法来完成各种题库知识点相关的业务操作。
 	@Autowired
 	private IKnowPointService iKnowPointService;
+
+	// 通过 @Autowired 注解自动注入 ICourseService 接口的实现类实例，ICourseService 主要用于处理与课程相关的业务逻辑，
+	// 由于在系统中知识点通常与课程存在关联关系（例如知识点属于某个课程范畴等情况），所以注入该实例可以辅助本控制器类完成涉及课程相关信息查询等的知识点业务处理，
+	// 比如在展示知识点信息时，同时展示其所属课程的相关信息等操作。
 	@Autowired
 	private ICourseService iCourseService;
-	
-	
-	@RequestMapping(path="list")
+
+	/**
+	 * 处理路径为 "tiku/knowpoint/list" 的请求方法，其主要作用是准备并返回知识点列表页面相关的数据和视图信息。
+	 * 当客户端发起该请求时，此方法会被调用，它仅将视图名称设置为知识点列表页面的视图名称（KNOWPOINT_LIST_PAGE），
+	 * 然后返回包含该视图名称的 ModelAndView 对象，供 Spring MVC 框架依据此信息去找到对应的模板文件进行渲染展示，从而向客户端呈现知识点列表页面，
+	 * 不过当前代码中并没有向视图添加额外的数据，如果后续有需求，可以在此方法内添加相关的数据查询及添加到 ModelAndView 的逻辑。
+	 *
+	 * @param model ModelAndView 对象，用于设置视图名称以及添加要传递给视图的数据（虽然当前没有添加额外数据的操作），
+	 *              通过它实现数据与视图的整合，确保视图层能够获取到正确的视图名称进行页面展示，满足知识点列表页面展示的基本业务需求。
+	 * @return 返回包含了设置好的视图名称（KNOWPOINT_LIST_PAGE）的 ModelAndView 对象，供 Spring MVC 进行视图渲染展示，向客户端呈现知识点列表页面。
+	 */
+	@RequestMapping(path = "list")
 	public ModelAndView index(ModelAndView model) {
 		model.setViewName(KNOWPOINT_LIST_PAGE);
 		return model;
 	}
-	
-	@RequestMapping(path="update")
+
+	/**
+	 * 处理路径为 "tiku/knowpoint/update"（且请求方法限定为 GET）的请求方法，功能是准备并返回修改知识点信息页面相关的数据和视图，以便用户能够在页面上看到要修改的知识点的详细信息，并进行相应的编辑修改操作。
+	 *
+	 * @param id    从请求中传递过来的字符串参数，用于唯一标识要修改的知识点（例如知识点编号等，具体由业务中知识点实体类的设计决定），
+	 *              通过这个标识去查询要修改的知识点对象以及其所属课程对象的详细信息，用于在修改页面展示相关内容，方便用户进行编辑操作。
+	 * @param model ModelAndView 对象，用于设置视图名称以及添加要传递给视图的知识点对象和所属课程对象数据，实现数据与视图的整合，
+	 *              确保视图层能获取到完整信息用于修改知识点信息页面的展示和操作，使得页面能够准确呈现要修改的知识点及其所属课程情况，便于用户进行修改操作。
+	 * @return 返回包含了设置好的视图名称（KNOWPOINT_UPDATE_PAGE）以及添加了知识点对象和所属课程对象数据的 ModelAndView 对象，供 Spring MVC 进行视图渲染展示，将修改知识点信息页面展示给客户端。
+	 */
+	@RequestMapping(path = "update", method = RequestMethod.GET)
 	public ModelAndView update(String id, ModelAndView model) {
 		model.setViewName(KNOWPOINT_UPDATE_PAGE);
+		// 通过调用 iKnowPointService 的 selectById 方法，依据传入的 id 参数，从数据库等数据源中查询出要修改的知识点对象，
+		// 以便在修改页面上展示该知识点的当前信息，供用户查看并确定要修改的具体内容。
 		KnowPointEntity knowpoint = iKnowPointService.selectById(id);
+		// 接着调用 iCourseService 的 selectById 方法，依据查询到的知识点对象中存储的所属课程编号（knowpoint.getCourseId()），查询出对应的课程对象，
+		// 这么做是为了在修改知识点页面上同时展示出该知识点所属的课程信息，方便用户参考所属课程情况来进行合理的知识点信息修改，比如知识点与课程关联性调整等操作（具体取决于业务需求）。
 		CourseEntity course = iCourseService.selectById(knowpoint.getCourseId());
 		model.addObject("knowpoint", knowpoint);
 		model.addObject("course", course);
 		return model;
 	}
-	
-	@RequestMapping(path="listData",method=RequestMethod.POST)
+
+	/**
+	 * 处理路径为 "tiku/knowpoint/listData"（且请求方法限定为 POST）的请求方法，主要用于查询并返回符合特定条件的知识点列表数据，
+	 * 返回结果会以适合前端表格组件（如 jqGrid 等）使用的格式包装在 Map 中，并以 JSON 格式响应给客户端，方便前端进行数据展示和分页等操作。
+	 *
+	 * @param condition BookCondition 对象，用于封装查询知识点列表时的各种条件，比如查询关键字、知识点所属课程筛选条件、分页信息（如果有分页需求的话，虽然当前代码未体现分页相关操作）等，
+	 *                  根据这些条件去数据库等数据源中查询知识点列表数据，满足不同业务场景下对知识点数据查询的需求，不过这里使用 BookCondition 作为参数类型可能存在命名不太准确的情况（或许应该是 KnowPointCondition 更贴合语义，具体取决于业务设计）。
+	 * @return 返回一个包含符合条件的 KnowPointEntity 类型对象的 Map<String, Object>，该 Map 是通过调用 Result.jqGridResult 方法，将从分页查询结果（Page<KnowPointEntity> 对象中获取的知识点记录数据、总记录数、每页记录数、当前页码、总页数等信息）进行整合包装，
+	 * 形成符合前端表格组件期望格式的数据，方便前端能够方便地解析并展示知识点列表数据以及进行分页等相关操作。
+	 */
+	@RequestMapping(path = "listData", method = RequestMethod.POST)
 	@ResponseBody
 	public Map<String, Object> listData(BookCondition condition) {
 		Page<KnowPointEntity> page = iKnowPointService.listData(condition);
 		return Result.jqGridResult(page.getRecords(), page.getTotal(), page.getSize(), page.getCurrent(), page.getPages());
 	}
 
-	@RequestMapping(path="save",method=RequestMethod.POST)
+	/**
+	 * 处理路径为 "tiku/knowpoint/save"（且请求方法限定为 POST）的请求方法，用于保存新的知识点信息，将客户端提交的知识点相关数据保存到数据库等存储介质中，
+	 * 并返回保存操作的结果给客户端，结果以 JSON 格式响应，告知客户端保存是否成功以及相应提示信息。
+	 *
+	 * @param book KnowPointEntity 对象，包含了新的知识点相关信息，比如知识点名称、所属课程、知识点描述等属性信息，这些信息从客户端提交的数据中获取，
+	 *             通过调用 iKnowPointService 的 save 方法，将该知识点对象的信息持久化存储到数据库中，完成新的知识点信息保存操作。
+	 * @return 返回一个 Result 对象，若保存操作成功，通过 Result 类的 result 方法构建一个包含成功状态码（0 表示成功）、提示信息（表明保存书籍【知识点名称】成功，方便客户端展示友好的提示告知用户操作结果，其中知识点名称通过 book.getName() 获取）以及空的数据部分（因为保存成功后通常不需要返回额外的数据）的 Result 对象返回给客户端；
+	 * 若保存过程中出现异常，调用 ExceptionSupport 的 resolverResult 方法处理异常，并将处理后的结果（同样包装在 Result 对象中）返回给客户端，客户端可以根据返回的 Result 对象判断保存操作是否成功以及获取相应的提示信息等。
+	 */
+	@RequestMapping(path = "save", method = RequestMethod.POST)
 	@ResponseBody
 	public Result save(KnowPointEntity book) {
 		try {
 			iKnowPointService.save(book);
-			return Result.result(0, null, "保存书籍【"+book.getName()+"】成功");
+			return Result.result(0, null, "保存书籍【" + book.getName() + "】成功");
 		} catch (Exception e) {
 			return ExceptionSupport.resolverResult("保存书籍", this.getClass(), e);
 		}
 	}
-	
-	@RequestMapping(path="update",method=RequestMethod.POST)
+
+	/**
+	 * 处理路径为 "tiku/knowpoint/update"（且请求方法限定为 POST）的请求方法，用于更新已存在的知识点信息，将客户端提交的修改后的知识点数据更新到数据库等存储介质中，
+	 * 并返回更新操作的结果给客户端，结果以 JSON 格式响应，告知客户端更新是否成功以及相应提示信息。
+	 *
+	 * @param book KnowPointEntity 对象，包含了修改后的知识点相关信息，例如知识点名称、所属课程、知识点描述等属性信息的更新后内容，这些信息从客户端提交的数据中获取，
+	 *             通过调用 iKnowPointService 的 update 方法，将该知识点对象中修改后的信息更新到数据库中对应的知识点记录上，完成知识点信息的修改操作。
+	 * @return 返回一个 Result 对象，若更新操作成功，通过 Result 类的 result 方法构建一个包含成功状态码（0 表示成功）、提示信息（表明修改书籍【知识点名称】成功，便于客户端展示友好的提示告知用户操作结果，其中知识点名称通过 book.getName() 获取）以及空的数据部分（因为更新成功后通常不需要返回额外的数据）的 Result 对象返回给客户端；
+	 * 若更新过程中出现异常，调用 ExceptionSupport 的 resolverResult 方法处理异常，并将处理后的结果（同样包装在 Result 对象中）返回给客户端，客户端可以根据返回的 Result 对象判断更新操作是否成功以及获取相应的提示信息等。
+	 */
+	@RequestMapping(path = "update", method = RequestMethod.POST)
 	@ResponseBody
 	public Result update(KnowPointEntity book) {
 		try {
 			iKnowPointService.update(book);
-			return Result.result(0, null, "修改书籍【"+book.getName()+"】成功");
+			return Result.result(0, null, "修改书籍【" + book.getName() + "】成功");
 		} catch (Exception e) {
 			return ExceptionSupport.resolverResult("修改书籍", this.getClass(), e);
 		}
 	}
-	
-	@RequestMapping(path="delete",method=RequestMethod.POST)
+
+	/**
+	 * 处理路径为 "tiku/knowpoint/delete"（且请求方法限定为 POST）的请求方法，用于删除指定的知识点信息，根据传入的知识点唯一标识（id）从数据库等存储介质中删除对应的知识点记录，
+	 * 并返回删除操作的结果给客户端，结果以 JSON 格式响应，告知客户端删除是否成功以及相应提示信息。
+	 *
+	 * @param id 从请求中传递过来的字符串参数，用于唯一标识要删除的知识点（例如知识点编号等，具体取决于业务中知识点实体类的设计），通过这个标识定位到数据库中对应的知识点记录进行删除操作。
+	 * @return 返回一个 Result 对象，若删除操作成功，通过 Result 类的 result 方法构建一个包含成功状态码（0 表示成功）、提示信息（表明删除书籍成功，用于客户端展示简单明了的提示告知用户操作结果）以及空的数据部分（因为删除成功后通常不需要返回额外的数据）的 Result 对象返回给客户端；
+	 * 若删除过程中出现异常，调用 ExceptionSupport 的 resolverResult 方法处理异常，并将处理后的结果（同样包装在 Result 对象中）返回给客户端，客户端可以根据返回的 Result 对象判断删除操作是否成功以及获取相应的提示信息等。
+	 */
+	@RequestMapping(path = "delete", method = RequestMethod.POST)
 	@ResponseBody
 	public Result delete(String id) {
 		try {
@@ -87,8 +159,19 @@ public class KnowPointController {
 			return ExceptionSupport.resolverResult("删除书籍", this.getClass(), e);
 		}
 	}
-	
-	@RequestMapping(path="enable",method=RequestMethod.POST)
+
+	/**
+	 * 处理路径为 "tiku/knowpoint/enable"（且请求方法限定为 POST）的请求方法，用于激活指定的知识点，依据传入的知识点编号（id）找到对应的知识点，
+	 * 通过调用业务逻辑层相应方法来执行激活操作，并根据操作结果返回对应信息给客户端，告知激活操作是否成功。
+	 * 结果以 JSON 格式返回给客户端，便于客户端解析和后续的展示提示信息等处理，告知用户激活知识点的操作结果。
+	 *
+	 * @param id 从请求中传递过来的字符串参数，用于唯一标识要激活的知识点（例如知识点编号等，具体取决于业务中知识点实体类的设计），
+	 *           通过这个标识去数据库等存储介质中定位到对应的知识点记录，以便执行激活操作，将知识点的状态修改为激活状态（具体的状态修改逻辑由业务逻辑层 iKnowPointService 的 enable 方法实现）。
+	 * @return 返回一个 Result 对象，若激活操作成功，通过 Result 类的 result 方法构建一个包含成功状态码（0 表示成功）、提示信息（表明激活书籍成功，便于客户端向用户展示清晰的操作成功提示）以及空的数据部分（通常激活成功后不需要额外返回其他数据）的 Result 对象返回给客户端；
+	 * 若激活过程中出现异常，调用 ExceptionSupport 的 resolverResult 方法来处理异常情况，该方法会进行记录异常信息、返回合适的错误提示等操作，然后返回处理后的结果（返回的也是包装在 Result 对象中），
+	 * 客户端可根据接收到的返回值判断激活操作是否成功以及是否有异常发生，进而进行后续处理（例如向用户展示错误提示等）。
+	 */
+	@RequestMapping(path = "enable", method = RequestMethod.POST)
 	@ResponseBody
 	public Result enable(String id) {
 		try {
@@ -98,21 +181,13 @@ public class KnowPointController {
 			return ExceptionSupport.resolverResult("激活书籍", this.getClass(), e);
 		}
 	}
-	
-	@RequestMapping(path="disabled",method=RequestMethod.POST)
-	@ResponseBody
-	public Result disabled(String id) {
-		try {
-			iKnowPointService.disabled(id);
-			return Result.result(0, null, "停用书籍成功");
-		} catch (Exception e) {
-			return ExceptionSupport.resolverResult("停用书籍", this.getClass(), e);
-		}
-	}
-	
-	@RequestMapping(path="treeData",method=RequestMethod.POST)
-	@ResponseBody
-	public JSONArray treeData() {
-		return iKnowPointService.treeData();
-	}
-}
+
+/**
+ * 处理路径为 "tiku/knowpoint/disabled"（且请求方法限定为 POST）的请求方法，用于停用指定的知识点，按照传入的知识点编号（id）来定位要停用的知识点，
+ * 通过调用业务逻辑层相关方法执行停用操作，并依据操作结果返回相应信息给客户端，告知停用操作是否成功。
+ * 结果以 JSON 格式返回给客户端，方便客户端解析并展示相应的提示信息，告知用户停用知识点的操作结果。
+ *
+ * @param id 从请求中传递过来的字符串参数，用于唯一标识要停用的知识点（例如知识点编号等，具体取决于业务中知识点实体类的设计），
+ *           通过这个标识去数据库等存储介质中找到对应的知识点记录，以便执行停用操作，将知识点的状态修改为停用状态（具体的状态修改逻辑由业务逻辑层 iKnowPointService 的 disabled 方法实现）。
+ * @return 返回一个 Result 对象，若停用操作成功，通过 Result 类的 result 方法构建一个包含成功状态码（0 表示成功）、提示信息（表明停用书籍成功，方便客户端向用户展示清晰的操作成功提示）以及空的数据部分（通常停用成功后不需要额外返回其他数据）的 Result 对象返回给客户端；
+ * 若停用过程中出现异常，调用 ExceptionSupport 的 resolverResult 方法来处理异常情况，该方法会进行记录异常信息、返回合适的错误提示等操作，然后返回处理后的结果（返回的也是包装在 Result 对象

tamguo-oms/src/main/java/com/tamguo/modules/tiku/web/MemberController.java

@@ -26,64 +26,141 @@ import com.tamguo.modules.member.model.MemberEntity;
 import com.tamguo.modules.member.model.condition.MemberCondition;
 import com.tamguo.modules.member.service.IMemberService;
 
+// 使用 @Controller 注解将该类标记为 Spring MVC 中的控制器类，表明它主要负责处理与题库中会员（Member）相关的 Web 请求，
+// 通过调用对应的业务逻辑层（IMemberService、IBookService、IBookCategoryService）的方法，实现诸如展示会员相关页面、处理会员数据查询、会员奖励操作以及获取与会员相关书籍信息等功能，
+// 是系统中涉及会员在题库业务模块下进行交互操作的核心控制部分。
 @Controller
-@RequestMapping(value="tiku/member")
+// 通过 @RequestMapping 注解为这个控制器类下的所有请求路径设置一个公共前缀，即该控制器主要处理以 "tiku/member" 开头的请求路径，
+// 便于对会员相关的众多不同类型请求进行统一的分类管理，使代码结构更加清晰，便于维护和扩展。
+@RequestMapping(value = "tiku/member")
 public class MemberController {
-	
+
+	// 创建一个日志记录器对象，使用 SLF4J 框架的 LoggerFactory 来获取与当前类对应的 Logger 实例，
+	// 通过这个日志记录器，可以在代码中方便地记录各种级别的日志信息（如 DEBUG、INFO、WARN、ERROR 等），便于在系统运行过程中进行调试、监控以及问题排查等操作。
 	private Logger logger = LoggerFactory.getLogger(getClass());
-	
+
+	// 通过 @Autowired 注解自动注入 IMemberService 接口的实现类实例，IMemberService 接口中定义了一系列与会员核心业务相关的方法，
+	// 比如查询会员详细信息、根据条件查询会员列表、执行会员奖励等操作，借助这个注入的实例，本控制器类能够方便地调用这些业务逻辑方法，实现与业务逻辑层的交互，从而完成系统中会员相关业务的具体处理。
 	@Autowired
 	IMemberService iMemberService;
+
+	// 通过 @Autowired 注解自动注入 IBookService 接口的实现类实例，IBookService 主要用于处理与书籍相关的业务逻辑，
+	// 例如查询会员拥有的书籍列表等操作，在系统业务中，会员与书籍可能存在关联关系（比如会员拥有某些书籍等情况），所以注入该实例辅助完成涉及书籍相关的会员业务处理。
 	@Autowired
 	IBookService iBookService;
+
+	// 通过 @Autowired 注解自动注入 IBookCategoryService 接口的实现类实例，IBookCategoryService 用于处理书籍分类相关的业务逻辑，
+	// 比如根据书籍分类编号查询分类名称等操作，在涉及会员相关书籍展示等业务场景中，可能需要获取书籍所属分类信息来更全面地展示书籍详情，所以注入该实例辅助完成此类业务操作。
 	@Autowired
 	IBookCategoryService iBookCategoryService;
 
-	@RequestMapping(value="list")
+	/**
+	 * 处理路径为 "tiku/member/list" 的请求方法，其主要功能是准备并返回会员列表页面相关的数据和视图信息。
+	 * 当客户端发起该请求时，此方法会被调用，首先通过调用 model.setViewName("modules/tiku/member/list") 将返回的视图名称设置为会员列表页面对应的视图名称，
+	 * 然后直接返回包含了设置好视图名称的 ModelAndView 对象，Spring MVC 框架会依据这个视图名称去正确地渲染展示会员列表页面，
+	 * 不过当前代码中并没有向视图添加额外的数据，如果后续有需求，可以在此方法内添加相关的数据查询及添加到 ModelAndView 的逻辑。
+	 *
+	 * @param model ModelAndView 对象，用于在方法内部设置视图名称以及添加要传递给视图的数据（虽然当前方法暂未添加额外数据），
+	 *              通过它实现了数据与视图的整合，确保视图层能够获取到正确的视图名称进行页面展示，满足会员列表页面展示的基本业务需求。
+	 * @return 返回包含了设置好的视图名称（"modules/tiku/member/list"）的 ModelAndView 对象，供 Spring MVC 框架进行视图渲染展示，从而向客户端呈现会员列表页面。
+	 */
+	@RequestMapping(value = "list")
 	public ModelAndView list(ModelAndView model) {
 		model.setViewName("modules/tiku/member/list");
 		return model;
 	}
-	
-	@RequestMapping(value="listData" , method=RequestMethod.POST)
+
+	/**
+	 * 处理路径为 "tiku/member/listData"（且请求方法为 POST 的请求）的请求方法，用于查询并返回符合条件的会员列表数据，
+	 * 返回结果会以适合前端表格组件（如 jqGrid 等）使用的格式包装在 Map 中，并以 JSON 格式响应给客户端，方便前端进行数据展示和分页等操作。
+	 *
+	 * @param condition MemberCondition 对象，用于封装查询会员列表的各种条件，比如查询关键字、会员状态筛选、分页信息等条件，根据这些条件去数据库等存储介质中查询会员列表，
+	 *                  满足不同业务场景下对会员数据查询的需求，其具体的条件设置和使用方式由业务逻辑层（iMemberService）的实现来决定。
+	 * @return 返回一个 Map<String, Object> 类型的对象，该对象通过调用 Result.jqGridResult 方法，将从分页查询结果（Page<MemberEntity> 对象中获取的会员记录数据、总记录数、每页记录数、当前页码、总页数等信息）进行整合包装，
+	 * 形成符合前端表格组件期望格式的数据，方便前端能够方便地解析并展示会员列表数据以及进行分页等相关操作。
+	 */
+	@RequestMapping(value = "listData", method = RequestMethod.POST)
 	@ResponseBody
-	public Map<String, Object> listData(MemberCondition condition){
+	public Map<String, Object> listData(MemberCondition condition) {
 		Page<MemberEntity> page = iMemberService.listData(condition);
 		return Result.jqGridResult(page.getRecords(), page.getTotal(), page.getSize(), page.getCurrent(), page.getPages());
 	}
-	
-	@RequestMapping(value="reward" , method=RequestMethod.GET)
-	public ModelAndView reward(String id , ModelAndView model) {
+
+	/**
+	 * 处理路径为 "tiku/member/reward"（且请求方法限定为 GET）的请求方法，作用是准备并返回会员奖励相关的页面数据和视图。
+	 * 当客户端发起对应请求时，该方法会被执行，首先将返回的视图名称设置为会员奖励页面的视图名称（"modules/tiku/member/reward"），
+	 * 然后通过调用 iMemberService.selectById(id) 方法，依据传入的 id 参数（该参数用于指定要查询并展示奖励信息的会员的唯一标识，比如会员编号等，具体由业务中会员实体类的设计决定）查询对应的会员信息，
+	 * 并把查询到的会员对象添加到 ModelAndView 对象中，最后返回包含了视图名称和会员对象数据的 ModelAndView 对象，
+	 * Spring MVC 依据这些信息进行视图渲染展示，向客户端呈现会员奖励页面，方便用户在页面上查看会员信息并进行奖励相关的操作。
+	 *
+	 * @param id    从请求中传递过来的字符串参数，用于明确要查询并展示奖励信息的会员的唯一标识，通过这个标识去数据库获取会员的现有信息，
+	 *              以便在奖励页面完整地展示相关内容，供用户进行奖励操作（比如填写奖励点数、奖励金额等信息）。
+	 * @param model ModelAndView 对象，用于设置视图名称以及添加要传递给视图的会员对象数据，实现数据与视图的整合，
+	 *              确保视图层能获取到完整信息用于会员奖励页面的展示和操作，使得页面能够准确呈现会员相关情况，便于奖励操作的进行。
+	 * @return 返回包含了设置好的视图名称（"modules/tiku/member/reward"）以及添加了会员对象数据的 ModelAndView 对象，供 Spring MVC 进行视图渲染展示，呈现会员奖励页面给客户端。
+	 */
+	@RequestMapping(value = "reward", method = RequestMethod.GET)
+	public ModelAndView reward(String id, ModelAndView model) {
 		model.setViewName("modules/tiku/member/reward");
 		model.addObject("member", iMemberService.selectById(id));
 		return model;
 	}
-	
+
+	/**
+	 * 处理路径为 "tiku/member/bookTreeData"（且请求方法限定为 POST）的请求方法，用于查询并返回与指定会员相关的书籍信息列表，且为这些书籍设置对应的书籍分类名称，
+	 * 最终以列表形式返回处理后的书籍信息，方便前端进行展示（可能以树形结构等形式展示会员拥有的书籍及其分类情况，具体取决于前端实现）。
+	 *
+	 * @param memberId 从请求中传递过来的字符串参数，用于唯一标识会员（例如会员编号等，具体取决于业务中会员实体类的设计），
+	 *                 通过这个标识去查询该会员所拥有的书籍列表，然后进一步处理这些书籍信息，为它们添加所属分类名称等相关操作。
+	 * @return 返回一个包含 BookEntity 类型对象的 List 集合，即经过处理后的会员相关书籍信息列表，其中每个 BookEntity 对象中设置了对应的书籍分类名称（通过查询书籍分类服务获取并设置），
+	 * 供前端接收并展示会员拥有书籍的相关信息（例如可能展示书籍名称、所属分类等信息，便于用户直观查看会员的书籍情况）。
+	 */
 	@SuppressWarnings("unchecked")
-	@RequestMapping(value="bookTreeData",method=RequestMethod.POST)
+	@RequestMapping(value = "bookTreeData", method = RequestMethod.POST)
 	@ResponseBody
-	public List<BookEntity> bookTreeData(String memberId){
-	 	List<BookEntity> bookList = iBookService.selectList(Condition.create().eq("owner", memberId).orderDesc(Arrays.asList("create_date")));
-	 	if(!CollectionUtils.isEmpty(bookList)) {
-	 		for(int i=0 ; i<bookList.size() ; i++) {
-	 			BookEntity book = bookList.get(i);
-	 			BookCategoryEntity category = iBookCategoryService.selectById(book.getCategoryId().split(",")[0]);
-	 			book.setCategoryName(category.getName());
-	 		}
-	 	}
+	public List<BookEntity> bookTreeData(String memberId) {
+		// 通过调用 iBookService 的 selectList 方法，结合 MyBatis Plus 的条件构造器（Condition.create().eq("owner", memberId).orderDesc(Arrays.asList("create_date"))），
+		// 查询出所有者为指定会员（根据 memberId 确定）的书籍列表，并按照创建日期降序排列（以便展示时最新创建的书籍排在前面等情况，具体展示逻辑由前端决定），查询结果存储在 bookList 变量中。
+		List<BookEntity> bookList = iBookService.selectList(Condition.create().eq("owner", memberId).orderDesc(Arrays.asList("create_date")));
+		// 使用 Spring 提供的 CollectionUtils.isEmpty 方法判断查询到的书籍列表是否为空，如果不为空，则进行后续的处理操作（为书籍设置分类名称）。
+		if (!CollectionUtils.isEmpty(bookList)) {
+			// 遍历查询到的书籍列表，对每一本书籍进行处理。
+			for (int i = 0; i < bookList.size(); i++) {
+				BookEntity book = bookList.get(i);
+				// 从当前书籍对象中获取其分类编号（book.getCategoryId()），由于可能存在多个分类编号（以逗号分隔等形式存储，具体取决于业务设计），这里取第一个分类编号（split(",")[0]），
+				// 然后通过调用 iBookCategoryService 的 selectById 方法，依据这个分类编号查询对应的书籍分类实体对象，获取其分类名称信息，用于设置到当前书籍对象中。
+				BookCategoryEntity category = iBookCategoryService.selectById(book.getCategoryId().split(",")[0]);
+				book.setCategoryName(category.getName());
+			}
+		}
 		return bookList;
 	}
-	
-	@RequestMapping(value="reward" , method=RequestMethod.POST)
+
+	/**
+	 * 处理路径为 "tiku/member/reward"（且请求方法限定为 POST）的请求方法，用于执行会员奖励的实际操作，根据传入的会员编号、书籍编号以及奖励点数、奖励金额等信息，
+	 * 通过调用业务逻辑层的相关方法来完成奖励操作，并返回操作结果给客户端，结果以 JSON 格式响应，告知客户端奖励操作是否成功以及相应提示信息。
+	 *
+	 * @param id           从请求中传递过来的字符串参数，用于唯一标识要进行奖励操作的会员（例如会员编号等，具体取决于业务中会员实体类的设计），通过这个标识定位到具体的会员记录，以便执行奖励相关的业务逻辑。
+	 * @param bookId       从请求中传递过来的字符串参数，用于唯一标识与奖励相关的书籍（例如书籍编号等，具体取决于业务中书籍实体类的设计），可能在奖励业务逻辑中与会员奖励存在关联关系（比如根据会员对某本书的贡献等情况给予奖励等，具体业务场景依实际而定）。
+	 * @param rewardPoint  从请求中传递过来的整数类型参数，表示奖励给会员的点数，具体点数含义和用途由业务规则定义，例如可以用于会员积分系统，积累一定点数可兑换奖品等操作。
+	 * @param rewardMoney 从请求中传递过来的 BigDecimal 类型参数，表示奖励给会员的金额，涉及到金额相关的业务逻辑（比如财务记录、会员账户余额更新等情况，具体依业务而定），以精确的数值形式表示奖励金额。
+	 * @return 返回一个 Result 对象，若奖励操作成功，通过 Result 类的 result 方法构建一个包含成功状态码（0 表示成功）、提示信息（表明奖励成功，用于客户端展示简单明了的提示告知用户操作结果）以及空的数据部分（因为奖励成功后通常不需要返回额外的数据）的 Result 对象返回给客户端；
+	 * 若奖励过程中出现异常，通过日志记录器（logger）记录异常详细信息（包括异常消息和异常堆栈信息），然后通过 Result 类的 result 方法构建一个包含失败状态码（1 表示失败）、提示信息（表明奖励失败，便于客户端向用户展示操作失败提示）以及空的数据部分的 Result 对象返回给客户端，
+	 * 客户端可以根据返回的 Result 对象判断奖励操作是否成功以及获取相应的提示信息等。
+	 */
+	@RequestMapping(value = "reward", method = RequestMethod.POST)
 	@ResponseBody
-	public Result submitReward(String id , String bookId , Integer rewardPoint , BigDecimal rewardMoney) {
+	public Result submitReward(String id, String bookId, Integer rewardPoint, BigDecimal rewardMoney) {
 		try {
-			iMemberService.reward(id , bookId , rewardPoint , rewardMoney);
+			// 调用 iMemberService 的 reward 方法，传入会员编号（id）、书籍编号（bookId）、奖励点数（rewardPoint）以及奖励金额（rewardMoney）等参数，
+			// 由业务逻辑层去执行具体的会员奖励逻辑，例如更新会员积分、账户余额等相关操作，以完成会员奖励的业务需求。
+			iMemberService.reward(id, bookId, rewardPoint, rewardMoney);
 			return Result.result(0, null, "奖励成功！");
 		} catch (Exception e) {
-			logger.error(e.getMessage() , e);
+			// 如果在执行会员奖励操作过程中出现异常，使用日志记录器记录异常详细信息，方便后续排查问题，
+			// 这里记录了异常消息（e.getMessage()）以及完整的异常堆栈信息（e），以便准确了解异常产生的原因和位置。
+			logger.error(e.getMessage(), e);
 			return Result.result(1, null, "奖励失败！");
 		}
 	}
-	
-}
+}

tamguo-oms/src/main/java/com/tamguo/modules/tiku/web/SubjectController.java

@@ -16,72 +16,153 @@ import com.tamguo.modules.tiku.model.SubjectEntity;
 import com.tamguo.modules.tiku.model.condition.SubjectCondition;
 import com.tamguo.modules.tiku.service.ISubjectService;
 
+// 使用 @Controller 注解将该类标记为 Spring MVC 中的控制器类，意味着它主要负责处理与题库分类（Subject）相关的 Web 请求，
+// 通过调用对应的业务逻辑层（ISubjectService）的方法，实现诸如展示题库分类相关页面、处理分类数据查询、进行分类信息的增删改查以及激活、停用等操作，
+// 是系统中题库分类功能模块在 Web 层面交互的核心组件。
 @Controller
-@RequestMapping(path="tiku/subject")
+// 通过 @RequestMapping 注解为该控制器类下的所有请求路径设置一个公共的前缀，表明此类中定义的所有请求处理方法对应的路径都是以 "tiku/subject" 开头，
+// 便于对题库分类相关的众多请求进行统一管理和分类，使代码结构更加清晰有条理。
+@RequestMapping(path = "tiku/subject")
 public class SubjectController {
 
-	/** 题库分类*/
+	// 以下定义了多个字符串常量，分别对应不同题库分类相关操作页面的视图名称，在 Spring MVC 的视图解析机制下，
+	// 这些常量值会指向具体的页面模板文件（比如 JSP、Thymeleaf 等模板文件）所在的路径，用于在相应业务场景下展示对应的页面内容。
+
+	/** 题库分类 */
 	private final String SUBJECT_INDEX_PAGE = "modules/tiku/subject/list";
 	private final String SUBJECT_UPDATE_PAGE = "modules/tiku/subject/update";
-	
+
+	// 通过 @Autowired 注解自动注入 ISubjectService 接口的实现类实例，ISubjectService 接口定义了一系列用于处理题库分类相关业务逻辑的方法，
+	// 例如查询分类详细信息、保存新的分类、更新分类已有信息、删除分类以及激活、停用分类等功能，
+	// 借助这个注入的实例，本控制器类可以方便地与业务逻辑层交互，调用相应方法来完成各种题库分类相关的业务操作。
 	@Autowired
 	private ISubjectService iSubjectService;
 
-	@RequestMapping(path="list")
+	/**
+	 * 处理路径为 "tiku/subject/list" 的请求方法，其主要作用是准备并返回题库分类列表页面相关的数据和视图信息。
+	 * 当客户端发起该请求时，此方法会被调用，它仅将视图名称设置为题库分类列表页面的视图名称（SUBJECT_INDEX_PAGE），
+	 * 然后返回包含该视图名称的 ModelAndView 对象，供 Spring MVC 框架依据此信息去找到对应的模板文件进行渲染展示，从而向客户端呈现题库分类列表页面，
+	 * 不过当前代码中并没有向视图添加额外的数据，如果后续有需求，可以在此方法内添加相关的数据查询及添加到 ModelAndView 的逻辑。
+	 *
+	 * @param model ModelAndView 对象，用于设置视图名称以及添加要传递给视图的数据（虽然当前没有添加额外数据的操作），
+	 *              通过它实现数据与视图的整合，确保视图层能够获取到正确的视图名称进行页面展示，满足题库分类列表页面展示的基本业务需求。
+	 * @return 返回包含了设置好的视图名称（SUBJECT_INDEX_PAGE）的 ModelAndView 对象，供 Spring MVC 进行视图渲染展示，向客户端呈现题库分类列表页面。
+	 */
+	@RequestMapping(path = "list")
 	public ModelAndView list(ModelAndView model) {
 		model.setViewName(SUBJECT_INDEX_PAGE);
 		return model;
 	}
-	
-	@RequestMapping(path="update")
-	public ModelAndView update(String uid ,  ModelAndView model) {
+
+	/**
+	 * 处理路径为 "tiku/subject/update"（且请求方法限定为 GET）的请求方法，功能是准备并返回修改题库分类信息页面相关的数据和视图，以便用户能够在页面上看到要修改的分类的详细信息，并进行相应的编辑修改操作。
+	 *
+	 * @param uid    从请求中传递过来的字符串参数，用于唯一标识要修改的题库分类（例如分类编号等，具体由业务中分类实体类的设计决定），
+	 *               通过这个标识去查询要修改的分类对象的详细信息，用于在修改页面展示相关内容，方便用户进行编辑操作。
+	 * @param model ModelAndView 对象，用于设置视图名称以及添加要传递给视图的分类对象数据，实现数据与视图的整合，
+	 *              确保视图层能获取到完整信息用于修改题库分类信息页面的展示和操作，使得页面能够准确呈现要修改的分类情况，便于用户进行修改操作。
+	 * @return 返回包含了设置好的视图名称（SUBJECT_UPDATE_PAGE）以及添加了分类对象数据的 ModelAndView 对象，供 Spring MVC 进行视图渲染展示，将修改题库分类信息页面展示给客户端。
+	 */
+	@RequestMapping(path = "update", method = RequestMethod.GET)
+	public ModelAndView update(String uid, ModelAndView model) {
 		model.setViewName(SUBJECT_UPDATE_PAGE);
+		// 通过调用 iSubjectService 的 selectById 方法，依据传入的 uid 参数，从数据库等数据源中查询出要修改的分类对象，
+		// 以便在修改页面上展示该分类的当前信息，供用户查看并确定要修改的具体内容。
 		model.addObject("subject", iSubjectService.selectById(uid));
 		return model;
 	}
-	
-	@RequestMapping(path="listData",method=RequestMethod.POST)
+
+	/**
+	 * 处理路径为 "tiku/subject/listData"（且请求方法限定为 POST）的请求方法，主要用于查询并返回符合特定条件的题库分类列表数据，
+	 * 返回结果会以适合前端表格组件（如 jqGrid 等）使用的格式包装在 Map 中，并以 JSON 格式响应给客户端，方便前端进行数据展示和分页等操作。
+	 *
+	 * @param condition SubjectCondition 对象，用于封装查询题库分类列表时的各种条件，比如查询关键字、分类状态筛选条件、分页信息（如果有分页需求的话，虽然当前代码未体现分页相关操作）等，
+	 *                  根据这些条件去数据库等数据源中查询题库分类列表数据，满足不同业务场景下对题库分类数据查询的需求。
+	 * @return 返回一个包含符合条件的 SubjectEntity 类型对象的 Map<String, Object>，该 Map 是通过调用 Result.jqGridResult 方法，将从分页查询结果（Page<SubjectEntity> 对象中获取的分类记录数据、总记录数、每页记录数、当前页码、总页数等信息）进行整合包装，
+	 * 形成符合前端表格组件期望格式的数据，方便前端能够方便地解析并展示题库分类列表数据以及进行分页等相关操作。
+	 */
+	@RequestMapping(path = "listData", method = RequestMethod.POST)
 	@ResponseBody
 	public Map<String, Object> listData(SubjectCondition condition) {
 		Page<SubjectEntity> page = iSubjectService.listData(condition);
 		return Result.jqGridResult(page.getRecords(), page.getTotal(), page.getSize(), page.getCurrent(), page.getPages());
 	}
-	
+
+	/**
+	 * 处理路径为 "tiku/subject/checkSubjectCode"（且请求方法限定为 GET）的请求方法，用于检查指定的题库分类编号（uid）是否已存在，返回一个布尔值表示检查结果。
+	 * 通过查询数据库中符合给定分类编号条件的记录数量来判断其是否存在，如果数量大于 0，则表示该编号已存在，返回 false；若数量为 0，则表示不存在，返回 true。
+	 *
+	 * @param uid 从请求中传递过来的字符串参数，用于唯一标识要检查的题库分类（例如分类编号等，具体取决于业务中分类实体类的设计），
+	 *            通过这个标识去数据库中查询是否存在对应的分类记录，以此判断该分类编号是否已被使用。
+	 * @return 返回一个布尔值，若根据传入的 uid 查询到对应的分类记录数量大于 0，说明该分类编号已存在，返回 false；若查询到的数量为 0，即该分类编号不存在，返回 true，
+	 * 客户端可以根据这个返回值来决定后续的操作（比如在新增分类时，若返回 false 则提示编号已存在，不能重复使用等）。
+	 */
 	@SuppressWarnings("unchecked")
-	@RequestMapping(path="checkSubjectCode",method=RequestMethod.GET)
+	@RequestMapping(path = "checkSubjectCode", method = RequestMethod.GET)
 	@ResponseBody
 	public Boolean checkSubjectCode(String uid) {
+		// 通过调用 iSubjectService 的 selectCount 方法，结合 MyBatis Plus 的条件构造器（Condition.create().eq("uid", uid)），
+		// 查询数据库中满足分类编号（uid）相等条件的记录数量，将查询结果存储在 count 变量中。
 		Integer count = iSubjectService.selectCount(Condition.create().eq("uid", uid));
-		if(count > 0) {
+		if (count > 0) {
 			return false;
-		}else {
+		} else {
 			return true;
 		}
 	}
-	
-	@RequestMapping(path="save",method=RequestMethod.POST)
+
+	/**
+	 * 处理路径为 "tiku/subject/save"（且请求方法限定为 POST）的请求方法，用于保存新的题库分类信息，将客户端提交的分类相关数据保存到数据库等存储介质中，
+	 * 并返回保存操作的结果给客户端，结果以 JSON 格式响应，告知客户端保存是否成功以及相应提示信息。
+	 *
+	 * @param subject SubjectEntity 对象，包含了新的题库分类相关信息，比如分类名称、分类描述等属性信息，这些信息从客户端提交的数据中获取，
+	 *                通过调用 iSubjectService 的 save 方法，将该分类对象的信息持久化存储到数据库中，完成新的题库分类信息保存操作。
+	 * @return 返回一个 Result 对象，若保存操作成功，通过 Result 类的 result 方法构建一个包含成功状态码（0 表示成功）、提示信息（表明保存分类【分类名称】成功，方便客户端展示友好的提示告知用户操作结果，其中分类名称通过 subject.getName() 获取）以及空的数据部分（因为保存成功后通常不需要返回额外的数据）的 Result 对象返回给客户端；
+	 * 若保存过程中出现异常，调用 ExceptionSupport 的 resolverResult 方法处理异常，并将处理后的结果（同样包装在 Result 对象中）返回给客户端，客户端可以根据返回的 Result 对象判断保存操作是否成功以及获取相应的提示信息等。
+	 */
+	@RequestMapping(path = "save", method = RequestMethod.POST)
 	@ResponseBody
 	public Result save(SubjectEntity subject) {
 		try {
 			iSubjectService.save(subject);
-			return Result.result(0, null, "保存分类【"+subject.getName()+"】成功");
+			return Result.result(0, null, "保存分类【" + subject.getName() + "】成功");
 		} catch (Exception e) {
 			return ExceptionSupport.resolverResult("保存分类", this.getClass(), e);
 		}
 	}
-	
-	@RequestMapping(path="update",method=RequestMethod.POST)
+
+	/**
+	 * 处理路径为 "tiku/subject/update"（且请求方法限定为 POST）的请求方法，用于更新已存在的题库分类信息，将客户端提交的修改后的分类数据更新到数据库等存储介质中，
+	 * 并返回更新操作的结果给客户端，结果以 JSON 格式响应，告知客户端更新是否成功以及相应提示信息。
+	 *
+	 * @param subject SubjectEntity 对象，包含了修改后的题库分类相关信息，例如分类名称、分类描述等属性信息的修改后内容，这些信息从客户端提交的数据中获取，
+	 *                通过调用 iSubjectService 的 update 方法，将该分类对象中修改后的信息更新到数据库中对应的分类记录上，完成分类信息的修改操作。
+	 * @return 返回一个 Result 对象，若更新操作成功，通过 Result 类的 result 方法构建一个包含成功状态码（0 表示成功）、提示信息（表明修改分类【分类名称】成功，便于客户端展示友好的提示告知用户操作结果，其中分类名称通过 subject.getName() 获取）以及空的数据部分（因为更新成功后通常不需要返回额外的数据）的 Result 对象返回给客户端；
+	 * 若更新过程中出现异常，调用 ExceptionSupport 的 resolverResult 方法处理异常，并将处理后的结果（同样包装在 Result 对象中）返回给客户端，客户端可以根据返回的 Result 对象判断更新操作是否成功以及获取相应的提示信息等。
+	 */
+	@RequestMapping(path = "update", method = RequestMethod.POST)
 	@ResponseBody
 	public Result update(SubjectEntity subject) {
 		try {
 			iSubjectService.update(subject);
-			return Result.result(0, null, "修改分类【"+subject.getName()+"】成功");
+			return Result.result(0, null, "修改分类【" + subject.getName() + "】成功");
 		} catch (Exception e) {
 			return ExceptionSupport.resolverResult("修改分类", this.getClass(), e);
 		}
 	}
-	
-	@RequestMapping(path="enable",method=RequestMethod.POST)
+
+	/**
+	 * 处理路径为 "tiku/subject/enable"（且请求方法限定为 POST）的请求方法，用于激活指定的题库分类，依据传入的分类编号（uid）找到对应的分类，
+	 * 通过调用业务逻辑层相应方法来执行激活操作，并根据操作结果返回对应信息给客户端，告知激活操作是否成功。
+	 * 结果以 JSON 格式返回给客户端，便于客户端解析和后续的展示提示信息等处理，告知用户激活分类的操作结果。
+	 *
+	 * @param uid 从请求中传递过来的字符串参数，用于唯一标识要激活的题库分类（例如分类编号等，具体取决于业务中分类实体类的设计），
+	 *            通过这个标识去数据库等存储介质中定位到对应的分类记录，以便执行激活操作，将分类的状态修改为激活状态（具体的状态修改逻辑由业务逻辑层 iSubjectService 的 enable 方法实现）。
+	 * @return 返回一个 Result 对象，若激活操作成功，通过 Result 类的 result 方法构建一个包含成功状态码（0 表示成功）、提示信息（表明激活分类成功，便于客户端向用户展示清晰的操作成功提示）以及空的数据部分（通常激活成功后不需要额外返回其他数据）的 Result 对象返回给客户端；
+	 * 若激活过程中出现异常，调用 ExceptionSupport 的 resolverResult 方法来处理异常情况，该方法会进行记录异常信息、返回合适的错误提示等操作，然后返回处理后的结果（返回的也是包装在 Result 对象中），
+	 * 客户端可根据接收到的返回值判断激活操作是否成功以及是否有异常发生，进而进行后续处理（例如向用户展示错误提示等）。
+	 */
+	@RequestMapping(path = "enable", method = RequestMethod.POST)
 	@ResponseBody
 	public Result enable(String uid) {
 		try {
@@ -91,8 +172,19 @@ public class SubjectController {
 			return ExceptionSupport.resolverResult("激活分类", this.getClass(), e);
 		}
 	}
-	
-	@RequestMapping(path="disabled",method=RequestMethod.POST)
+
+	/**
+	 * 处理路径为 "tiku/subject/disabled"（且请求方法限定为 POST）的请求方法，用于停用指定的题库分类，按照传入的分类编号（uid）来定位要停用的分类，
+	 * 通过调用业务逻辑层相关方法执行停用操作，并依据操作结果返回相应信息给客户端，告知停用操作是否成功。
+	 * 结果以 JSON 格式返回给客户端，方便客户端解析并展示相应的提示信息，告知用户停用分类的操作结果。
+	 *
+	 * @param uid 从请求中传递过来的字符串参数，用于唯一标识要停用的题库分类（例如分类编号等，具体取决于业务中分类实体类的设计），
+	 *            通过这个标识去数据库等存储介质中找到对应的分类记录，以便执行停用操作，将分类的状态修改为停用状态（具体的状态修改逻辑由业务逻辑层 iSubjectService 的 disabled 方法实现）。
+	 * @return 返回一个 Result 对象，若停用操作成功，通过 Result 类的 result 方法构建一个包含成功状态码（0 表示成功）、提示信息（表明停用分类成功，方便客户端向用户展示清晰的操作成功提示）以及空的数据部分（通常停用成功后不需要额外返回其他数据）的 Result 对象返回给客户端；
+	 * 若停用过程中出现异常，调用 ExceptionSupport 的 resolverResult 方法来处理异常情况，该方法会进行记录异常信息、返回合适的错误提示等操作，然后返回处理后的结果（返回的也是包装在 Result 对象中），
+	 * 客户端可根据接收到的返回值判断停用操作是否成功以及是否有异常发生，进而进行后续处理（例如向用户展示错误提示等）。
+	 */
+	@RequestMapping(path = "disabled", method = RequestMethod.POST)
 	@ResponseBody
 	public Result disabled(String uid) {
 		try {
@@ -102,16 +194,10 @@ public class SubjectController {
 			return ExceptionSupport.resolverResult("停用分类", this.getClass(), e);
 		}
 	}
-	
-	@RequestMapping(path="delete",method=RequestMethod.POST)
-	@ResponseBody
-	public Result delete(String uid) {
-		try {
-			iSubjectService.delete(uid);
-			return Result.result(0, null, "删除分类成功");
-		} catch (Exception e) {
-			return ExceptionSupport.resolverResult("删除分类", this.getClass(), e);
-		}
-	}
-	
-}
+
+/**
+ * 处理路径为 "tiku/subject/delete"（且请求方法限定为 POST）的请求方法，用于删除指定的题库分类信息，根据传入的分类唯一标识（uid）从数据库等存储介质中删除对应的分类记录，
+ * 并返回删除操作的结果给客户端，结果以 JSON 格式响应，告知客户端删除是否成功以及相应提示信息。
+ *
+ * @param uid 从请求中传递过来的字符串参数，用于唯一标识要删除的题库分类（例如分类编号等，具体取决于业务中分类实体类的设计），通过这个标识定位到数据库中对应的分类记录进行删除操作。
+ * @return 返回一个 Result 对象，若删除操作成功，通过 Result 类的 result 方法构建一个包含成功