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

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

@@ -10,26 +10,52 @@ import com.alibaba.fastjson.serializer.SerializerFeature;
 import com.alibaba.fastjson.support.config.FastJsonConfig;
 import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
 
+// @SpringBootApplication是一个组合注解，它整合了多个Spring Boot相关的注解，包括@Configuration（表明这个类是一个配置类，可用于定义Bean等配置信息）、
+// @EnableAutoConfiguration（开启Spring Boot的自动配置功能，会根据项目依赖等情况自动配置很多默认的组件和行为）、@ComponentScan（用于扫描指定包及其子包下的所有Spring组件，如@Component、@Service、@Controller等注解标记的类，使得这些类能够被Spring容器管理），
+// 这个注解标记在类上，表示这是一个Spring Boot的主应用类，启动类所在的包及其子包下的相关组件会被自动扫描并纳入Spring容器管理，同时开启自动配置等功能，整个Spring Boot应用从这个类开始启动。
 @SpringBootApplication
 public class Application {
 
+	// 应用程序的入口方法，是Java应用程序开始执行的地方，在这个方法中通过SpringApplicationBuilder来构建并启动Spring Boot应用，传入当前类（Application.class）作为参数，
+	// 告诉Spring Boot框架这个类是应用的主配置类，同时将命令行参数（args）传递给它，用于处理一些启动时可配置的相关信息（例如配置不同的运行环境等情况，具体取决于参数如何定义和使用），启动整个Spring Boot应用，初始化Spring容器、加载配置、启动相关服务等操作都会在这里开始执行。
 	public static void main(String[] args) {
 		new SpringApplicationBuilder(Application.class).run(args);
 	}
-	
+
 	/**
 	 * FastJson替代Jackson
-	 * @return
+	 * 这个方法定义了一个Spring的Bean，用于将FastJson配置为Spring Boot应用中处理HTTP消息转换（主要是将Java对象转换为JSON格式数据发送给客户端，以及将接收到的JSON格式数据转换为Java对象）的工具，
+	 * 替代默认的JSON处理框架（通常是Jackson），通过配置FastJson的相关属性（如日期格式、序列化特性等），来满足应用对于JSON数据处理的特定需求，然后将配置好的FastJsonHttpMessageConverter封装在HttpMessageConverters对象中返回，供Spring Boot应用使用。
+	 *
+	 * @return 返回一个HttpMessageConverters对象，其中包含了配置好的FastJsonHttpMessageConverter，这个对象会被Spring容器管理，在处理HTTP请求和响应的消息转换时会根据配置进行相应的JSON数据处理操作。
 	 */
 	@Bean
 	public HttpMessageConverters fastJsonHttpMessageConverters() {
+		// 创建一个FastJsonHttpMessageConverter对象，它是Spring框架中用于处理HTTP消息转换并且基于FastJson库来实现JSON数据序列化和反序列化的一个转换器，
+		// 后续会对它进行配置，设置FastJson相关的参数，使其按照应用的需求来正确地处理JSON数据，比如设置日期格式、避免循环引用等序列化特性。
 		FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter();
+
+		// 创建一个FastJsonConfig对象，用于配置FastJson的各种参数和特性，通过这个对象可以设置如日期格式、序列化相关的特性选项等内容，以定制FastJson在处理JSON数据时的行为，满足应用在不同场景下对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数据结构更符合预期，不会出现一些由于循环引用导致的不合理结构，按照设定的规则进行序列化处理。
 		fastJsonConfig.setSerializerFeatures(SerializerFeature.DisableCircularReferenceDetect);
+
+		// 将配置好的FastJsonConfig对象设置到FastJsonHttpMessageConverter中，使得FastJsonHttpMessageConverter在进行JSON数据的序列化和反序列化操作时，会按照FastJsonConfig中设定的参数和特性来执行，
+		// 这样就完成了对FastJson在Spring Boot应用中处理HTTP消息转换时的相关配置工作，使其能够按照应用需求来正确地转换JSON数据。
 		fastConverter.setFastJsonConfig(fastJsonConfig);
+
+		// 将配置好的FastJsonHttpMessageConverter对象赋值给converter变量（这里其实可以直接使用fastConverter，这个赋值操作略显多余，但可能是出于代码逻辑清晰性或者后续可能有其他修改的考虑等情况），
+		// 后续会将这个配置好的转换器封装在HttpMessageConverters对象中返回给Spring容器管理并使用。
 		FastJsonHttpMessageConverter converter = fastConverter;
+
+		// 创建一个HttpMessageConverters对象，并将配置好的FastJsonHttpMessageConverter作为参数传入构造函数，将其封装在HttpMessageConverters中，
+		// HttpMessageConverters是Spring框架用于管理多个HTTP消息转换器的一个类，在这里将FastJson相关的转换器添加进去后，Spring Boot应用在处理HTTP消息转换时，就会使用这个配置好的基于FastJson的转换器来处理JSON数据，实现了用FastJson替代默认的JSON处理框架（如Jackson）的功能，
+		// 最后返回这个HttpMessageConverters对象，供Spring容器管理使用，使得在整个Spring Boot应用中，涉及HTTP请求和响应的JSON数据处理都按照配置好的FastJson相关特性来执行。
 		return new HttpMessageConverters(converter);
 	}
-	
+}
-}

tamguo-tms/src/main/java/com/tamguo/config/dao/MyMetaObjectHandler.java

@@ -5,19 +5,41 @@ import org.apache.ibatis.reflection.MetaObject;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-/**
+// 以下这行被注释掉的@Component注解，如果取消注释，Spring会将这个类作为一个组件扫描并注册到Spring容器中，
- *  注入公共字段自动填充,任选注入方式即可
+// 这样就可以自动应用它所实现的功能（在这里就是公共字段自动填充功能），不过当前代码中只是定义了类的结构和基本方法，可能并不想让Spring直接管理它，所以暂时注释掉了。
- */
 //@Component
+// 这个类继承自MetaObjectHandler类，在MyBatis Plus框架中，MetaObjectHandler用于实现对实体对象的公共字段进行自动填充的功能，
+// 比如在插入或更新数据库记录时，自动设置创建时间、更新时间、创建人、更新人等公共字段的值，通过继承该类并重写相应的方法，
+// 可以自定义这些公共字段的填充逻辑，以满足具体业务需求。这里定义的MyMetaObjectHandler类就是用于此目的，不过当前代码中尚未实现具体的填充逻辑，只是搭建了基本的方法框架。
 public class MyMetaObjectHandler extends MetaObjectHandler {
 
+    // 创建一个静态的日志记录器对象，使用SLF4J框架的LoggerFactory来获取与当前类（MyMetaObjectHandler）对应的Logger实例，
+    // 通过这个日志记录器，可以在代码中方便地记录各种级别的日志信息（如DEBUG、INFO、WARN、ERROR等），便于在实现公共字段自动填充逻辑过程中进行调试、监控以及问题排查等操作。
     protected final static Logger logger = LoggerFactory.getLogger(MyMetaObjectHandler.class);
-    
+
+    /**
+     * 重写了父类MetaObjectHandler中的insertFill方法，该方法在MyBatis Plus执行插入操作（例如向数据库插入一条新记录时）时会被调用，
+     * 目的是在这里实现对插入操作时相关公共字段的自动填充逻辑。当前方法体为空，意味着还没有定义具体的填充逻辑，
+     * 实际应用中可以根据业务需求，从MetaObject参数中获取要插入的实体对象，然后设置诸如创建时间、创建人等公共字段的值，
+     * 例如可以使用Java的日期时间类获取当前时间设置为创建时间字段，从当前登录用户信息中获取用户名设置为创建人字段等操作（具体取决于业务设计）。
+     *
+     * @param metaObject MetaObject类型的参数，它是MyBatis框架中用于封装实体对象以及相关元数据的对象，通过它可以获取和操作实体对象的属性值等信息，
+     *                   在这个方法中，主要通过它来获取要插入的实体对象，以便对其公共字段进行填充操作。
+     */
     @Override
     public void insertFill(MetaObject metaObject) {
     }
 
+    /**
+     * 重写了父类MetaObjectHandler中的updateFill方法，该方法在MyBatis Plus执行更新操作（例如更新数据库中已存在的一条记录时）时会被调用，
+     * 用于实现对更新操作时相关公共字段的自动填充逻辑。当前方法体同样为空，尚未定义具体的填充逻辑，
+     * 在实际使用时，可以从MetaObject参数中获取要更新的实体对象，然后设置像更新时间、更新人等公共字段的值，
+     * 比如使用当前时间更新更新时间字段，根据当前登录用户信息更新更新人字段等（具体依据业务要求来定）。
+     *
+     * @param metaObject MetaObject类型的参数，通过它可以获取要更新的实体对象，进而对该对象的相关公共字段进行填充操作，
+     *                   确保在更新记录时，公共字段能按照业务规则被正确地更新赋值。
+     */
     @Override
     public void updateFill(MetaObject metaObject) {
     }
-}
+}

tamguo-tms/src/main/java/com/tamguo/config/dao/MybatisPlusConfig.java

@@ -19,40 +19,85 @@ import com.baomidou.mybatisplus.plugins.parser.tenant.TenantSqlParser;
 import net.sf.jsqlparser.expression.Expression;
 import net.sf.jsqlparser.expression.LongValue;
 
+// @Configuration注解表明这个类是一个Spring的配置类，用于定义各种Bean以及相关的配置信息，Spring容器会在启动时读取这个类中的配置，
+// 将其中定义的Bean创建并管理起来，供其他组件进行依赖注入和使用，从而实现整个应用的各种功能配置。
 @Configuration
+// @MapperScan注解用于指定MyBatis Plus的Mapper接口所在的包路径，它会自动扫描该路径下的所有Mapper接口，并创建对应的代理实现类，
+// 使得这些Mapper接口能够与数据库进行交互，这里指定扫描"com.tamguo.modules.*.dao*"路径下的Mapper接口，方便对不同模块下的数据库操作进行统一管理。
 @MapperScan("com.tamguo.modules.*.dao*")
 public class MybatisPlusConfig {
 
+    /**
+     * 创建并返回一个PerformanceInterceptor实例，将其注册为Spring容器中的一个Bean。
+     * PerformanceInterceptor是MyBatis Plus提供的一个性能分析拦截器，它可以用于统计SQL语句的执行时间等性能相关的数据，
+     * 在开发和调试阶段，有助于发现执行效率较低的SQL查询，以便进行优化。
+     *
+     * @return 返回一个新创建的PerformanceInterceptor对象，供Spring容器管理并在合适的时机应用到MyBatis Plus的SQL执行链路中进行性能分析。
+     */
     @Bean
     public PerformanceInterceptor performanceInterceptor() {
         return new PerformanceInterceptor();
     }
 
     /**
-     * mybatis-plus分页插件<br>
+     * 创建并配置一个PaginationInterceptor实例，将其注册为Spring容器中的一个Bean，用于实现MyBatis Plus的分页功能，并配置相关的多租户解析逻辑等额外功能。
-     * 文档：http://mp.baomidou.com<br>
+     *
+     * @return 返回配置好的PaginationInterceptor对象，该对象在MyBatis Plus处理数据库查询时，会自动处理分页相关的逻辑，并根据配置进行多租户SQL解析等操作。
      */
     @Bean
     public PaginationInterceptor paginationInterceptor() {
+        // 创建一个PaginationInterceptor实例，它是MyBatis Plus中用于实现分页功能的核心拦截器，
+        // 通过拦截SQL语句，自动添加分页相关的语法（如 LIMIT 等，具体取决于数据库类型），实现对查询结果的分页处理。
         PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
-        paginationInterceptor.setLocalPage(true);// 开启 PageHelper 的支持
+
+        // 设置开启PageHelper的支持，这里的PageHelper可能是指与其他分页插件兼容的一种模式或者相关功能（具体取决于项目中对分页的整体应用情况），
+        // 通过设置为true，使得PaginationInterceptor能够更好地与可能存在的PageHelper相关功能协同工作，确保分页功能的正常实现。
+        paginationInterceptor.setLocalPage(true);
+
         /*
          * 【测试多租户】 SQL 解析处理拦截器<br>
          * 这里固定写成住户 1 实际情况你可以从cookie读取，因此数据看不到 【 麻花藤 】 这条记录（ 注意观察 SQL ）<br>
+         * 以下代码块用于配置多租户相关的SQL解析逻辑，在多租户应用场景下，不同租户的数据需要进行隔离，通过SQL解析拦截器来动态修改SQL语句，添加租户相关的筛选条件等操作，实现数据隔离。
          */
         List<ISqlParser> sqlParserList = new ArrayList<>();
+
+        // 创建一个TenantSqlParser实例，它是基于MyBatis Plus的SQL解析器，专门用于处理多租户场景下的SQL语句解析和修改，
+        // 通过与TenantHandler配合，能够根据租户信息动态地在SQL中添加相应的条件，确保每个租户只能访问自己的数据。
         TenantSqlParser tenantSqlParser = new TenantSqlParser();
+
+        // 为TenantSqlParser设置TenantHandler，TenantHandler用于定义获取租户ID、租户ID对应的数据库列名以及判断是否对某个表进行租户过滤等逻辑，
+        // 在这里通过匿名内部类的方式实现了TenantHandler接口，具体配置了多租户相关的核心逻辑。
         tenantSqlParser.setTenantHandler(new TenantHandler() {
+            /**
+             * 获取表示租户ID的表达式，在这里返回一个LongValue类型的表达式，表示租户ID的值为1L，
+             * 在实际应用中，通常应该从更合适的地方获取（如从请求头、Cookie等中根据业务规则提取租户ID），这里只是为了测试示例固定写死为1。
+             *
+             * @return 返回表示租户ID的表达式，用于在SQL解析时添加到查询条件中，实现根据租户ID筛选数据的功能。
+             */
             @Override
             public Expression getTenantId() {
                 return new LongValue(1L);
             }
 
+            /**
+             * 获取存储租户ID的数据库列名，在这里返回"course_id"，意味着在SQL语句中，会通过这个列名来添加租户筛选条件，
+             * 例如在查询语句中添加类似"WHERE course_id = 1"（这里的1就是通过getTenantId方法获取的租户ID值）这样的条件，实现数据隔离。
+             *
+             * @return 返回存储租户ID的数据库列名，用于构建多租户相关的SQL筛选条件。
+             */
             @Override
             public String getTenantIdColumn() {
                 return "course_id";
             }
 
+            /**
+             * 判断是否对指定的表名进行租户过滤，这里返回true，表示对所有表都应用租户过滤逻辑（具体根据业务需求，可能需要对某些表不进行租户过滤，
+             * 可以在这个方法内根据表名进行条件判断来决定是否返回true或false），
+             * 通过这个方法可以灵活控制多租户逻辑对不同表的应用情况，确保数据隔离的准确性和合理性。
+             *
+             * @param tableName 要判断的表名，根据表名来决定是否对该表应用租户过滤逻辑。
+             * @return 返回true表示对该表应用租户过滤逻辑，返回false则表示不应用，即该表的数据不受租户条件限制（所有租户都能访问该表全部数据）。
+             */
             @Override
             public boolean doTableFilter(String tableName) {
                 // 这里可以判断是否过滤表
@@ -60,9 +105,14 @@ public class MybatisPlusConfig {
             }
         });
 
-
+        // 将配置好的TenantSqlParser添加到sqlParserList中，这个列表用于存储所有需要应用的SQL解析器，
+        // 后续会将这个列表设置到PaginationInterceptor中，使得在处理分页相关的SQL语句时，同时也能应用这些解析器进行多租户相关的SQL修改等操作。
         sqlParserList.add(tenantSqlParser);
+
+        // 将包含TenantSqlParser的sqlParserList设置到PaginationInterceptor中，这样在执行SQL语句时，
+        // PaginationInterceptor不仅会处理分页逻辑，还会调用列表中的各个SQL解析器对SQL进行额外的解析和修改（如添加多租户筛选条件等）。
         paginationInterceptor.setSqlParserList(sqlParserList);
+
         // 以下过滤方式与 @SqlParser(filter = true) 注解等效
 //        paginationInterceptor.setSqlParserFilter(new ISqlParserFilter() {
 //            @Override
@@ -75,19 +125,31 @@ public class MybatisPlusConfig {
 //                return false;
 //            }
 //        });
+
         return paginationInterceptor;
     }
 
+    /**
+     * 创建并返回一个MetaObjectHandler实例，将其注册为Spring容器中的一个Bean。
+     * MetaObjectHandler在MyBatis Plus中用于在插入或更新操作时，自动填充一些公共字段（如创建时间、更新时间、创建人、更新人等）的值，
+     * 通过实现该接口并自定义相关逻辑，可以方便地对实体对象的公共字段进行统一赋值，减少重复代码，提高代码的可维护性。
+     *
+     * @return 返回一个自定义的MetaObjectHandler实现类（这里返回的是MyMetaObjectHandler，应该是用户自定义的一个类，继承自MetaObjectHandler并实现了相应的填充逻辑）的实例，
+     * 供Spring容器管理并在MyBatis Plus的数据库操作中应用自动填充逻辑。
+     */
     @Bean
-    public MetaObjectHandler metaObjectHandler(){
+    public MetaObjectHandler metaObjectHandler() {
         return new MyMetaObjectHandler();
     }
 
     /**
-     * 注入sql注入器
+     * 创建并返回一个ISqlInjector实例，将其注册为Spring容器中的一个Bean，这里使用LogicSqlInjector来实现逻辑删除相关的功能注入。
+     * 在MyBatis Plus中，通过注入特定的SqlInjector，可以扩展默认的SQL注入逻辑，例如实现逻辑删除（不是真正从数据库中删除数据，而是通过更新某个字段标记数据为已删除状态）等功能。
+     *
+     * @return 返回一个LogicSqlInjector对象，用于向MyBatis Plus框架注入逻辑删除等相关的SQL生成逻辑，使得在进行数据删除操作时，按照逻辑删除的规则来生成对应的SQL语句。
      */
     @Bean
-    public ISqlInjector sqlInjector(){
+    public ISqlInjector sqlInjector() {
         return new LogicSqlInjector();
     }
-}
+}

tamguo-tms/src/main/java/com/tamguo/config/shiro/MemberRealm.java

@@ -18,55 +18,95 @@ import org.springframework.beans.factory.annotation.Autowired;
 import com.tamguo.modules.member.model.MemberEntity;
 import com.tamguo.modules.member.service.IMemberService;
 
-/**
+// 该类继承自AuthorizingRealm类，在Apache Shiro框架中，AuthorizingRealm是一个用于实现认证（authentication）和授权（authorization）功能的抽象基类，
- * 认证
+// 自定义的Realm需要继承它并实现相关抽象方法来定义具体的认证和授权逻辑，这里的MemberRealm类就是针对会员（Member）相关业务定制的Realm，用于处理会员的认证和授权操作。
- * 
- */
 public class MemberRealm extends AuthorizingRealm {
-	
+
+	// 通过@Autowired注解自动注入IMemberService接口的实现类实例，IMemberService用于处理与会员相关的业务逻辑，
+	// 例如根据用户名查询会员信息、获取会员登录失败次数、更新会员登录失败次数以及更新会员最后登录时间等操作，
+	// 在本类的认证和授权逻辑中，需要借助这些业务方法来获取会员相关数据以及更新会员状态等信息。
 	@Autowired
 	private IMemberService iMemberService;
-	
+
-    /**
+	/**
-     * 授权(验证权限时调用)
+	 * 授权方法，在Shiro框架中，当需要验证用户是否具有特定权限时（例如访问某个受权限控制的资源时），会调用这个方法来获取用户的授权信息。
-     */
+	 * 该方法是从父类AuthorizingRealm中继承而来的抽象方法，必须在子类中实现具体逻辑。
+	 * 当前实现只是简单地创建了一个SimpleAuthorizationInfo对象，并设置了权限集合（虽然当前设置为空集合，实际应用中应该根据业务规则查询并设置用户所拥有的具体权限），然后返回该对象，
+	 * 后续可以根据业务需求扩展这个方法，从数据库等数据源中查询出当前用户（通过PrincipalCollection参数可获取用户相关信息）所拥有的权限信息，并添加到SimpleAuthorizationInfo对象中，以便Shiro进行权限验证。
+	 *
+	 * @param principals PrincipalCollection对象，它包含了当前已认证用户的主体信息（比如用户对象、用户名等关键信息，具体取决于认证时设置的主体内容），
+	 *                   通过它可以获取到与当前用户相关的信息，进而根据这些信息去查询并构建该用户对应的授权信息，不过当前代码暂未充分利用它来查询权限信息，只是简单返回了一个基础的授权信息对象。
+	 * @return 返回一个AuthorizationInfo接口的实现类对象（这里返回的是SimpleAuthorizationInfo实例），该对象包含了用户的授权信息，例如用户拥有的权限列表等，供Shiro框架进行权限验证使用。
+	 */
 	@Override
 	protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
-		Set<String > permsSet = null;
+		// 初始化一个用于存储权限字符串的集合变量，当前设置为null，实际应用中应该从数据库等数据源查询出当前用户所拥有的权限字符串，并添加到这个集合中，
+		// 权限字符串通常是一些具有特定格式的字符串，用于标识不同的操作权限（比如"user:add"表示用户添加权限，"order:delete"表示订单删除权限等，具体格式根据业务设计而定）。
+		Set<String> permsSet = null;
+
+		// 创建一个SimpleAuthorizationInfo对象，它是Shiro框架中用于表示用户授权信息的一个简单实现类，通过调用其相关方法可以设置用户的角色、权限等信息。
 		SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
+
+		// 将当前为空的权限集合设置到SimpleAuthorizationInfo对象中，实际业务中应该在此处添加从数据库查询到的用户实际拥有的权限，
+		// 使得Shiro框架后续能基于这些权限信息来判断用户是否有权限访问特定资源。
 		info.setStringPermissions(permsSet);
-		
+
 		return info;
 	}
 
 	/**
-	 * 认证(登录时调用)
+	 * 认证方法，在Shiro框架中，当用户进行登录操作时，会调用这个方法来验证用户提供的身份信息（如用户名和密码）是否正确，以及账号是否处于可用状态等。
+	 * 该方法同样是从父类AuthorizingRealm中继承而来的抽象方法，需要在子类中实现具体的认证逻辑，这里实现了根据用户名查询会员信息、验证密码、处理登录失败次数以及更新登录时间等逻辑，来完成会员登录的认证过程。
+	 *
+	 * @param token AuthenticationToken对象，它封装了用户在登录时提交的身份验证信息，通常包含用户名和密码（以不同的形式存储，具体取决于使用的Token实现类），
+	 *              通过这个对象可以获取到用户输入的用户名和密码信息，用于与数据库中存储的用户信息进行比对验证。
+	 * @return 返回一个AuthenticationInfo接口的实现类对象（这里返回的是SimpleAuthenticationInfo实例），该对象包含了已认证成功的用户相关信息（如用户对象、密码等），
+	 * 告知Shiro框架认证成功，并将这些信息保存起来，以便后续在整个请求处理过程中可以获取到已认证用户的相关内容，同时也可以供其他需要验证用户身份的地方使用。
+	 * @throws AuthenticationException 如果认证过程中出现异常情况（如用户名不存在、密码错误、账号被锁定等），会抛出相应的AuthenticationException及其子类异常，
+	 *                                  Shiro框架会根据抛出的异常类型进行相应的处理，比如向客户端返回对应的错误提示信息等操作。
 	 */
 	@Override
 	protected AuthenticationInfo doGetAuthenticationInfo(
 			AuthenticationToken token) throws AuthenticationException {
+		// 从AuthenticationToken对象中获取用户输入的用户名信息，由于在通常情况下，Shiro默认的Token实现类会将用户名存储在Principal位置，所以通过强制类型转换获取用户名的字符串表示形式。
 		String username = (String) token.getPrincipal();
-        String password = new String((char[]) token.getCredentials());
+
-        
+		// 从AuthenticationToken对象中获取用户输入的密码信息，Shiro默认的Token实现类会将密码以字符数组的形式存储在Credentials位置，这里通过将字符数组转换为字符串来获取密码内容。
-        MemberEntity member = iMemberService.findByUsername(username);
+		String password = new String((char[]) token.getCredentials());
-        if(member == null) {
+
-        	throw new UnknownAccountException("用户名或密码有误，请重新输入或找回密码");
+		// 调用iMemberService的findByUsername方法，根据获取到的用户名去数据库等数据源中查询对应的会员实体对象，用于后续验证密码以及判断账号状态等操作。
-        }
+		MemberEntity member = iMemberService.findByUsername(username);
-        Integer loginFailureCount = iMemberService.getLoginFailureCount(member);
+
-        if(loginFailureCount > 10) {
+		// 如果查询到的会员对象为null，说明用户名不存在，抛出UnknownAccountException异常，Shiro框架会捕获这个异常并根据配置向客户端返回相应的错误提示信息（如提示用户名或密码有误等）。
-        	throw new LockedAccountException("账号被锁定");
+		if (member == null) {
-        }
+			throw new UnknownAccountException("用户名或密码有误，请重新输入或找回密码");
-		
+		}
-		if(!new Sha256Hash(password).toHex().equals(member.getPassword())){
+
+		// 调用iMemberService的getLoginFailureCount方法，获取当前会员的登录失败次数，用于判断账号是否因为多次登录失败而被锁定。
+		Integer loginFailureCount = iMemberService.getLoginFailureCount(member);
+
+		// 如果登录失败次数大于10次，说明账号存在异常登录情况，可能被恶意攻击等，为了保证账号安全，抛出LockedAccountException异常，Shiro框架会处理这个异常并告知客户端账号被锁定，禁止登录。
+		if (loginFailureCount > 10) {
+			throw new LockedAccountException("账号被锁定");
+		}
+
+		// 使用Sha256Hash对用户输入的密码进行哈希处理（将密码转换为不可逆的哈希值形式），并与数据库中存储的会员密码（通常也是经过哈希处理后存储的）进行比对，
+		// 如果两者不一致，说明用户输入的密码错误，此时增加登录失败次数，调用iMemberService的updateLoginFailureCount方法将更新后的登录失败次数保存到数据库中，
+		// 然后抛出IncorrectCredentialsException异常，Shiro框架会根据此异常向客户端返回密码错误的提示信息，要求用户重新输入密码。
+		if (!new Sha256Hash(password).toHex().equals(member.getPassword())) {
 			loginFailureCount++;
-			iMemberService.updateLoginFailureCount(member , loginFailureCount);
+			iMemberService.updateLoginFailureCount(member, loginFailureCount);
 			throw new IncorrectCredentialsException("用户名或密码有误，请重新输入或找回密码");
 		}
+
+		// 如果密码验证通过，说明登录认证成功，调用iMemberService的updateLastLoginTime方法，根据会员的唯一标识（member.getId()）更新会员的最后登录时间，记录会员此次登录的时间信息，方便后续业务分析等使用。
 		// 更新登录时间
 		iMemberService.updateLastLoginTime(member.getId());
-		
-        SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(member, password, getName());
-        return info;
-	}
 
-}
+		// 创建一个SimpleAuthenticationInfo对象，将查询到的会员对象（作为已认证的主体信息）、用户输入的密码（虽然密码在实际验证后通常不再需要，但在这里按照Shiro的要求传入，Shiro内部有相应的处理机制确保安全）以及当前Realm的名称（通过getName方法获取）传入，
+		// 这个对象会告知Shiro框架认证成功，并将相关信息保存起来，供后续使用，例如在整个请求处理过程中判断用户是否已经认证等操作。
+		SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(member, password, getName());
+
+		return info;
+	}
+}

tamguo-tms/src/main/java/com/tamguo/config/shiro/ShiroConfiguration.java

@@ -12,15 +12,35 @@ import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreato
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
+// @Configuration注解表明这个类是一个Spring的配置类，用于定义各种与Shiro框架相关的Bean以及相关的配置信息，
+// Spring容器会在启动时读取这个类中的配置，将其中定义的Bean创建并管理起来，从而实现Shiro框架在Spring应用中的集成和功能配置。
 @Configuration
 public class ShiroConfiguration {
+
+    // 创建一个静态的LinkedHashMap，用于存储URL路径与对应的Shiro过滤器链定义，
+    // 其中键（String类型）表示URL路径的匹配模式，值（也是String类型）表示对应的Shiro过滤器链的定义（例如需要进行什么类型的认证、授权等操作），
+    // 后续会将这个映射关系配置到ShiroFilterFactoryBean中，以实现对不同URL请求的访问控制。
     private static Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>();
 
+    /**
+     * 创建并返回一个MemberRealm实例，将其注册为Spring容器中的一个Bean，名称为"shiroRealm"。
+     * MemberRealm是自定义的继承自Shiro的AuthorizingRealm的类，用于实现具体的用户认证和授权逻辑（如根据用户名密码验证用户身份、查询用户权限等操作），
+     * 在这里作为Shiro安全管理器（DefaultWebSecurityManager）的核心组件，提供认证和授权相关的具体实现，供Shiro框架调用。
+     *
+     * @return 返回一个新创建的MemberRealm对象，作为Shiro框架中用于处理认证和授权的关键组件，由Spring容器管理并注入到其他相关的Shiro组件中使用。
+     */
     @Bean(name = "shiroRealm")
     public MemberRealm getShiroRealm() {
         return new MemberRealm();
     }
 
+    /**
+     * 创建并返回一个EhCacheManager实例，将其注册为Spring容器中的一个Bean，名称为"shiroEhcacheManager"。
+     * EhCacheManager是Shiro框架用于缓存管理的一个实现类，它可以与Ehcache缓存框架集成，在这里通过设置缓存配置文件（ehcache-shiro.xml）来配置缓存相关的参数，
+     * 例如缓存的存活时间、最大缓存对象数量等，用于缓存Shiro框架运行过程中的一些数据（如用户的认证信息、授权信息等），提高系统性能，减少重复查询数据库等操作的开销。
+     *
+     * @return 返回一个配置好的EhCacheManager对象，供Shiro框架在需要进行缓存管理时使用，例如缓存用户权限信息，下次访问相同权限验证时可以直接从缓存中获取，加快验证速度。
+     */
     @Bean(name = "shiroEhcacheManager")
     public EhCacheManager getEhCacheManager() {
         EhCacheManager em = new EhCacheManager();
@@ -28,11 +48,25 @@ public class ShiroConfiguration {
         return em;
     }
 
+    /**
+     * 创建并返回一个LifecycleBeanPostProcessor实例，将其注册为Spring容器中的一个Bean，名称为"lifecycleBeanPostProcessor"。
+     * LifecycleBeanPostProcessor是Shiro与Spring集成时用于管理Shiro组件生命周期的一个后置处理器，它可以确保Shiro的各种Bean（如Realm、SecurityManager等）在Spring容器中的生命周期方法（如初始化、销毁等方法）能够被正确调用，
+     * 保证Shiro框架相关组件能按照预期的生命周期流程进行初始化和资源释放等操作，使整个Shiro框架在Spring应用中稳定运行。
+     *
+     * @return 返回一个新创建的LifecycleBeanPostProcessor对象，用于处理Shiro组件在Spring容器中的生命周期相关逻辑。
+     */
     @Bean(name = "lifecycleBeanPostProcessor")
     public LifecycleBeanPostProcessor getLifecycleBeanPostProcessor() {
         return new LifecycleBeanPostProcessor();
     }
 
+    /**
+     * 创建并返回一个DefaultAdvisorAutoProxyCreator实例，用于在Spring应用中开启基于AOP（Aspect-Oriented Programming，面向切面编程）的自动代理功能，
+     * 以便能够正确地处理Shiro框架中的切面相关逻辑（如权限验证切面等），通过设置proxyTargetClass为true，强制使用基于类的代理方式（而不是基于接口的代理方式），
+     * 确保Shiro的各种通知（如权限验证的拦截逻辑等）能够准确地应用到对应的目标对象上，实现对业务方法的权限控制等功能。
+     *
+     * @return 返回一个配置好的DefaultAdvisorAutoProxyCreator对象，使得Spring能够自动创建代理对象来应用Shiro相关的切面逻辑，实现权限控制等功能。
+     */
     @Bean
     public DefaultAdvisorAutoProxyCreator getDefaultAdvisorAutoProxyCreator() {
         DefaultAdvisorAutoProxyCreator daap = new DefaultAdvisorAutoProxyCreator();
@@ -40,6 +74,14 @@ public class ShiroConfiguration {
         return daap;
     }
 
+    /**
+     * 创建并返回一个DefaultWebSecurityManager实例，将其注册为Spring容器中的一个Bean，名称为"securityManager"。
+     * DefaultWebSecurityManager是Shiro在Web应用环境下的核心安全管理器，它负责协调Shiro的各个组件（如Realm、缓存管理器等）来完成用户认证、授权以及会话管理等安全相关的功能，
+     * 在这里将自定义的MemberRealm（通过调用getShiroRealm方法获取）和EhCacheManager（通过调用getEhCacheManager方法获取）设置到DefaultWebSecurityManager中，
+     * 使其能够使用自定义的认证授权逻辑以及缓存机制来保障系统的安全性和性能。
+     *
+     * @return 返回一个配置好的DefaultWebSecurityManager对象，作为Shiro框架在Web应用中的核心安全管理组件，供其他Shiro相关组件（如ShiroFilterFactoryBean）使用，来实现整个应用的安全控制。
+     */
     @Bean(name = "securityManager")
     public DefaultWebSecurityManager getDefaultWebSecurityManager() {
         DefaultWebSecurityManager dwsm = new DefaultWebSecurityManager();
@@ -48,6 +90,13 @@ public class ShiroConfiguration {
         return dwsm;
     }
 
+    /**
+     * 创建并返回一个AuthorizationAttributeSourceAdvisor实例，用于为Shiro的权限验证提供基于AOP的切面配置，
+     * 它将与Spring的AOP机制结合，通过设置安全管理器（DefaultWebSecurityManager，通过调用getDefaultWebSecurityManager方法获取），
+     * 可以在业务方法执行前自动进行权限验证，拦截不符合权限要求的请求，确保只有具有相应权限的用户能够访问受保护的资源，实现基于注解或配置的权限控制功能。
+     *
+     * @return 返回一个配置好的AuthorizationAttributeSourceAdvisor对象，用于在Spring应用中基于AOP实现Shiro的权限验证切面逻辑，增强系统的权限控制能力。
+     */
     @Bean
     public AuthorizationAttributeSourceAdvisor getAuthorizationAttributeSourceAdvisor() {
         AuthorizationAttributeSourceAdvisor aasa = new AuthorizationAttributeSourceAdvisor();
@@ -55,15 +104,30 @@ public class ShiroConfiguration {
         return new AuthorizationAttributeSourceAdvisor();
     }
 
+    /**
+     * 创建并返回一个ShiroFilterFactoryBean实例，将其注册为Spring容器中的一个Bean，名称为"shiroFilter"。
+     * ShiroFilterFactoryBean是Shiro与Spring集成用于配置Web应用中Shiro过滤器链的核心组件，它通过设置安全管理器（通过调用getDefaultWebSecurityManager方法获取）来关联整个Shiro的安全管理体系，
+     * 同时设置登录页面的URL（通过setLoginUrl方法设置为"/login"，当用户未认证访问受保护资源时，会被重定向到这个登录页面进行登录操作）、登录成功后的跳转页面URL（通过setSuccessUrl方法设置为"/index"，用户认证成功后会自动跳转到这个页面），
+     * 并且将之前定义的filterChainDefinitionMap（包含了URL路径与对应的Shiro过滤器链定义的映射关系）设置进去，以此来配置不同URL路径对应的访问控制规则，例如哪些路径需要进行认证（"authc"表示需要认证），哪些路径可以匿名访问（"anon"表示匿名访问，不需要认证）等，
+     * 最终实现对整个Web应用的URL级别的安全访问控制。
+     *
+     * @return 返回一个配置好的ShiroFilterFactoryBean对象，用于定义Web应用中Shiro的过滤器链以及相关的访问控制配置，使得Shiro框架能够根据这些配置对不同的URL请求进行相应的安全处理。
+     */
     @Bean(name = "shiroFilter")
     public ShiroFilterFactoryBean getShiroFilterFactoryBean() {
         ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
         shiroFilterFactoryBean.setSecurityManager(getDefaultWebSecurityManager());
         shiroFilterFactoryBean.setLoginUrl("/login");
         shiroFilterFactoryBean.setSuccessUrl("/index");
+
+        // 配置URL路径与Shiro过滤器链的映射关系，例如：
+        // "/member/**"路径下的请求都需要进行认证（"authc"表示需要进行身份认证才能访问），这里的"/member/**"是一种Ant风格的路径匹配表达式，表示以"/member/"开头的所有路径。
+        // "/**"路径下的请求都允许匿名访问（"anon"表示任何人都可以直接访问，不需要进行身份认证），这里的"/**"表示匹配所有的URL路径，通常用于配置一些公开的资源（如静态资源、登录页面等）可以直接访问。
         filterChainDefinitionMap.put("/member/**", "authc");
         filterChainDefinitionMap.put("/**", "anon");
+
         shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
+
         return shiroFilterFactoryBean;
     }
 }

tamguo-tms/src/main/java/com/tamguo/config/web/ErrorConfigurar.java

@@ -6,16 +6,36 @@ import org.springframework.boot.web.server.ErrorPageRegistry;
 import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Component;
 
+// @Component注解用于将这个类标记为Spring框架中的一个组件，意味着Spring容器会在启动时扫描到这个类，并将其作为一个Bean进行管理，
+// 使得这个类可以参与到Spring应用的依赖注入以及各种组件协作的流程中，在这里它主要用于配置应用的错误页面相关逻辑。
 @Component
+// 这个类实现了ErrorPageRegistrar接口，该接口用于在Spring Boot应用中注册自定义的错误页面，
+// 通过实现接口中的registerErrorPages方法，可以定义不同HTTP状态码对应的错误页面路径，当应用出现相应的错误时，会自动重定向到配置好的错误页面进行展示。
 public class ErrorConfigurar implements ErrorPageRegistrar {
 
+	/**
+	 * 实现ErrorPageRegistrar接口中定义的方法，用于向Spring Boot应用的Web服务器注册自定义的错误页面配置信息。
+	 * 该方法接收一个ErrorPageRegistry类型的参数，通过这个参数可以添加不同状态码对应的错误页面映射关系，使得应用在出现对应错误时能正确地跳转到指定的错误页面进行展示，提升用户体验以及便于错误排查等操作。
+	 *
+	 * @param registry ErrorPageRegistry对象，它是Spring Boot提供的用于注册错误页面的接口实现类对象，通过调用其相关方法可以添加各种HTTP状态码与错误页面路径的映射关系，
+	 *                 从而实现对不同错误情况的页面展示配置。
+	 */
 	@Override
 	public void registerErrorPages(ErrorPageRegistry registry) {
-		ErrorPage[] errorPages=new ErrorPage[2];
+		// 创建一个ErrorPage类型的数组，用于存储要配置的不同错误页面信息，这里数组长度为2，表示要配置两种不同HTTP状态码对应的错误页面，
-        errorPages[0]=new ErrorPage(HttpStatus.NOT_FOUND,"/error404");
+		// 可以根据实际需求增加数组长度来配置更多的错误页面映射关系。
-        errorPages[1]=new ErrorPage(HttpStatus.INTERNAL_SERVER_ERROR,"/error500");
+		ErrorPage[] errorPages = new ErrorPage[2];
 
-        registry.addErrorPages(errorPages);
+		// 配置第一个错误页面信息，对应HTTP状态码为HttpStatus.NOT_FOUND（即404状态码，表示请求的资源未找到），
+		// 当应用中出现资源未找到的错误时，会将用户重定向到"/error404"这个路径对应的页面进行展示，这里的"/error404"应该是项目中事先定义好的用于展示404错误信息的页面路径（通常是一个HTML页面等）。
+		errorPages[0] = new ErrorPage(HttpStatus.NOT_FOUND, "/error404");
+
+		// 配置第二个错误页面信息，对应HTTP状态码为HttpStatus.INTERNAL_SERVER_ERROR（即500状态码，表示服务器内部错误），
+		// 当应用在执行过程中出现服务器内部错误（比如代码抛出未捕获的异常等情况）时，会将用户重定向到"/error500"这个路径对应的页面进行展示，同样，"/error500"也是项目中用于展示500错误信息的特定页面路径。
+		errorPages[1] = new ErrorPage(HttpStatus.INTERNAL_SERVER_ERROR, "/error500");
+
+		// 通过调用ErrorPageRegistry对象的addErrorPages方法，将配置好的包含错误页面映射关系的errorPages数组添加进去，
+		// 这样Spring Boot应用的Web服务器就会根据这些配置，在相应错误发生时重定向到对应的错误页面进行展示了。
+		registry.addErrorPages(errorPages);
 	}
-	
+}
-}

tamguo-tms/src/main/java/com/tamguo/config/web/ThymeleafConfig.java

@@ -11,31 +11,82 @@ import org.thymeleaf.spring5.view.ThymeleafViewResolver;
 
 import com.tamguo.common.utils.SystemConstant;
 
+// @Component注解用于将这个类标记为Spring框架中的一个组件，意味着Spring容器在启动时会扫描到这个类，并将其作为一个Bean进行管理，
+// 使得该类能够参与到Spring应用的依赖注入以及整个应用的配置流程中，在这里它主要负责对Thymeleaf相关的配置进行定制化设置。
 @Component
-public class ThymeleafConfig implements EnvironmentAware{
+// 这个类实现了EnvironmentAware接口，通过实现该接口的setEnvironment方法，可以获取到Spring应用的运行环境配置信息（如配置文件中的各种属性值等），
+// 进而基于这些环境配置来进行相关的业务配置操作，在本类中就是利用环境配置来设置Thymeleaf视图解析器中的一些静态变量。
+public class ThymeleafConfig implements EnvironmentAware {
 
+	// 通过@Resource注解进行依赖注入，将Spring的Environment对象注入到当前类中。Environment对象提供了访问应用配置属性的接口，
+	// 可以通过它获取到配置文件（如application.properties或application.yml等）中定义的各种属性值，以便在代码中使用这些配置信息进行相应的逻辑处理，
+	// 例如获取服务器域名、不同模块的域名等配置信息用于后续设置到Thymeleaf的静态变量中。
 	@Resource
-    private Environment env;
+	private Environment env;
 
+	/**
+	 * 这个方法使用了@Resource注解，表明它是一个依赖注入相关的方法，它的参数类型是ThymeleafViewResolver，Spring会自动将对应的ThymeleafViewResolver实例注入进来。
+	 * 该方法的主要功能是配置Thymeleaf视图解析器的静态变量，通过从Environment对象中获取相关的配置属性值以及从SystemConstant类中获取一些常量值，
+	 * 将它们封装到一个Map中，然后设置到ThymeleafViewResolver对象里，使得在Thymeleaf模板页面中可以直接使用这些变量，方便进行页面渲染等操作，例如动态生成页面链接时使用域名变量等情况。
+	 *
+	 * @param viewResolver ThymeleafViewResolver类型的对象，它是Spring中用于解析Thymeleaf模板视图的核心组件，通过它可以配置视图解析相关的各种参数和属性，
+	 *                     在这里主要是为其设置静态变量，以便在Thymeleaf模板中能够方便地访问和使用这些变量进行页面渲染。
+	 */
 	@Resource
 	private void configureThymeleafStaticVars(ThymeleafViewResolver viewResolver) {
-	    if(viewResolver != null) {
+		// 判断传入的ThymeleafViewResolver对象是否为空，如果不为空，则进行后续的静态变量配置操作，避免空指针异常等情况。
-	        Map<String, Object> vars = new HashMap<>();
+		if (viewResolver!= null) {
-	        vars.put("domainName", env.getProperty("domain.name"));
+			// 创建一个HashMap对象，用于存储要设置到ThymeleafViewResolver中的静态变量，键为变量名（在Thymeleaf模板中使用的名称），值为对应的变量值，
-	        vars.put("adminDomain", env.getProperty("admin.domain.name"));
+			// 这些变量值可以是从配置文件中获取的属性值或者是代码中定义的常量值等，通过设置静态变量，方便在Thymeleaf模板中直接引用这些变量进行页面逻辑处理。
-	        vars.put("memberDomain", env.getProperty("member.domain.name"));
+			Map<String, Object> vars = new HashMap<>();
-	        vars.put("PAPER_TYPE_ZHENTI", SystemConstant.ZHENGTI_PAPER_ID);
+
-	        vars.put("PAPER_TYPE_MONI", SystemConstant.MONI_PAPER_ID);
+			// 从Environment对象中获取名为"domain.name"的配置属性值，并将其作为"domainName"变量添加到vars集合中，
-	        vars.put("PAPER_TYPE_YATI", SystemConstant.YATI_PAPER_ID);
+			// 在Thymeleaf模板中可以通过${domainName}的方式来引用这个变量，可能用于生成完整的域名相关链接等操作，具体用途取决于业务需求。
-	        vars.put("PAPER_TYPE_MINGXIAO", SystemConstant.MINGXIAO_PAPER_ID);
+			vars.put("domainName", env.getProperty("domain.name"));
-	        vars.put("BEIJING_AREA_ID", SystemConstant.BEIJING_AREA_ID);
+
-	        viewResolver.setStaticVariables(vars);
+			// 从Environment对象中获取名为"admin.domain.name"的配置属性值，将其作为"adminDomain"变量添加到vars集合中，
-	    }
+			// 这样在Thymeleaf模板中如果涉及到与管理员相关模块的域名使用场景时，可以方便地通过${adminDomain}获取并使用这个变量，例如构建管理员模块的页面链接等情况。
+			vars.put("adminDomain", env.getProperty("admin.domain.name"));
+
+			// 类似地，从Environment对象中获取名为"member.domain.name"的配置属性值，将其作为"memberDomain"变量添加到vars集合中，
+			// 便于在Thymeleaf模板中针对会员相关模块的页面处理时，通过${memberDomain}引用这个变量来构建相关的链接或者进行其他与域名相关的操作。
+			vars.put("memberDomain", env.getProperty("member.domain.name"));
+
+			// 从SystemConstant类中获取名为ZHENGTI_PAPER_ID的常量值，并将其作为"PAPER_TYPE_ZHENTI"变量添加到vars集合中，
+			// 在Thymeleaf模板中可以通过这个变量来表示某种试卷类型（具体试卷类型含义由业务中SystemConstant类里的定义决定），例如用于页面上试卷类型的展示或者根据试卷类型进行不同的页面逻辑处理等情况。
+			vars.put("PAPER_TYPE_ZHENTI", SystemConstant.ZHENGTI_PAPER_ID);
+
+			// 从SystemConstant类中获取名为MONI_PAPER_ID的常量值，将其作为"PAPER_TYPE_MONI"变量添加到vars集合中，
+			// 同样用于在Thymeleaf模板中处理与模拟试卷类型相关的页面逻辑，比如根据模拟试卷类型展示特定的页面元素或者进行不同的交互操作等，具体取决于业务设计。
+			vars.put("PAPER_TYPE_MONI", SystemConstant.MONI_PAPER_ID);
+
+			// 从SystemConstant类中获取名为YATI_PAPER_ID的常量值，作为"PAPER_TYPE_YATI"变量添加到vars集合中，
+			// 以便在Thymeleaf模板中针对押题试卷类型相关的页面渲染和逻辑处理时能够方便地引用这个变量，例如根据是否是押题试卷类型来展示不同的提示信息等操作。
+			vars.put("PAPER_TYPE_YATI", SystemConstant.YATI_PAPER_ID);
+
+			// 从SystemConstant类中获取名为MINGXIAO_PAPER_ID的常量值，将其作为"PAPER_TYPE_MINGXIAO"变量添加到vars集合中，
+			// 在Thymeleaf模板中可以利用这个变量进行与名校试卷类型相关的页面展示和逻辑处理，比如根据名校试卷类型来展示对应的学校标识或者试卷特色等信息（具体由业务需求决定）。
+			vars.put("PAPER_TYPE_MINGXIAO", SystemConstant.MINGXIAO_PAPER_ID);
+
+			// 从SystemConstant类中获取名为BEIJING_AREA_ID的常量值，将其作为"BEIJING_AREA_ID"变量添加到vars集合中，
+			// 在Thymeleaf模板中可能用于涉及北京地区相关的页面逻辑处理，例如判断是否是北京地区试卷、展示北京地区相关的特色内容等情况（具体根据业务中对北京地区的定义和使用场景而定）。
+			vars.put("BEIJING_AREA_ID", SystemConstant.BEIJING_AREA_ID);
+
+			// 将包含了所有要设置的静态变量的vars集合，通过调用ThymeleafViewResolver的setStaticVariables方法，设置到ThymeleafViewResolver对象中，
+			// 这样在后续使用Thymeleaf解析模板进行页面渲染时，模板中就可以直接使用这些设置好的变量了，方便进行各种页面逻辑的实现以及动态内容的展示等操作。
+			viewResolver.setStaticVariables(vars);
+		}
 	}
 
+	/**
+	 * 实现EnvironmentAware接口中定义的方法，该方法会在Spring容器初始化时被自动调用，用于接收Spring应用的运行环境配置信息（以Environment对象的形式传入），
+	 * 在这里将传入的Environment对象赋值给类中的env成员变量，使得在类的其他方法（如configureThymeleafStaticVars方法）中可以通过这个env变量来访问和获取各种配置属性值。
+	 *
+	 * @param environment Spring应用的运行环境配置对象，包含了从配置文件（如application.properties、application.yml等）中读取的所有配置属性信息，
+	 *                    通过这个参数将环境配置信息传递到当前类中，方便后续基于这些配置进行相关的业务配置操作。
+	 */
 	@Override
 	public void setEnvironment(Environment environment) {
 		env = environment;
 	}
-
+}
-}

tamguo-tms/src/main/java/com/tamguo/config/web/WebConfig.java

@@ -13,37 +13,93 @@ import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 import com.tamguo.web.interceptor.MemberInterceptor;
 import com.tamguo.web.interceptor.MenuInterceptor;
 
-
+// @Configuration注解表明这个类是Spring框架中的一个配置类，用于定义各种Bean以及配置Spring Web MVC相关的功能，
+// Spring容器会在启动时读取这个类中的配置信息，将其中定义的Bean创建并管理起来，同时应用配置的相关规则，例如注册拦截器、配置资源处理等，来定制Web应用的行为。
 @Configuration
+// 这个类实现了WebMvcConfigurer接口，该接口提供了一系列用于定制Spring Web MVC功能的方法，通过重写这些方法，
+// 可以添加拦截器、配置资源处理器、处理跨域等操作，这里重写了部分方法来实现特定的业务需求，比如添加自定义拦截器以及配置文件资源的访问路径、设置Cookie序列化相关参数等。
 public class WebConfig implements WebMvcConfigurer {
-	
+
+	// 通过@Value注解从配置文件（例如application.properties或application.yml等）中获取名为"file.storage.path"的属性值，并注入到当前类的fileStoragePath变量中，
+	// 这个属性值通常表示文件存储的路径，在后续配置文件资源访问时会用到，用于指定服务器上文件实际存放的位置，以便能正确地对外提供文件访问服务。
 	@Value("${file.storage.path}")
 	private String fileStoragePath;
+
+	// 同样使用@Value注解从配置文件中获取名为"cookie.domian.name"的属性值，注入到cookieDomianName变量中，
+	// 该属性值一般是Cookie的域名设置，用于确定Cookie在哪些域名下有效，在配置Cookie序列化相关参数时会用到这个值，确保Cookie的作用范围符合业务需求。
 	@Value("${cookie.domian.name}")
 	private String cookieDomianName;
+
+	// 通过@Autowired注解自动注入MemberInterceptor类型的实例，MemberInterceptor应该是一个自定义的拦截器类，
+	// 用于拦截特定路径下的请求，可能在这些请求处理前进行一些与会员相关的逻辑验证、权限判断或者预处理操作，比如检查会员是否登录等情况，在后续配置拦截器时会将其添加到拦截器链中。
 	@Autowired
 	private MemberInterceptor memberInterceptor;
+
+	// 与上面类似，通过@Autowired注解注入MenuInterceptor类型的实例，MenuInterceptor也是自定义的拦截器，
+	// 可能用于拦截所有请求（从后续添加拦截器的配置来看），并针对菜单相关的业务逻辑进行处理，例如根据用户权限动态生成菜单、验证菜单访问权限等操作，同样会在后面配置到拦截器链中发挥作用。
 	@Autowired
 	private MenuInterceptor menuInterceptor;
-	
+
+	/**
+	 * 重写WebMvcConfigurer接口中的addInterceptors方法，用于向Spring Web MVC的拦截器链中添加自定义的拦截器，
+	 * 通过InterceptorRegistry对象可以注册多个拦截器，并指定每个拦截器要拦截的请求路径模式，从而实现对不同请求的拦截处理，满足业务中各种权限控制、前置处理等需求。
+	 *
+	 * @param registry InterceptorRegistry对象，它提供了添加拦截器以及配置拦截器相关参数（如拦截的路径模式）的方法，
+	 *                 通过调用其相关方法可以将自定义的拦截器添加到Spring Web MVC的拦截器链中，使其生效并对符合条件的请求进行拦截处理。
+	 */
 	@Override
 	public void addInterceptors(InterceptorRegistry registry) {
+		// 将menuInterceptor添加到拦截器链中，并指定其拦截的路径模式为"/**"，这是一种Ant风格的路径匹配表达式，表示拦截所有的请求路径，
+		// 意味着所有进入应用的请求都会先经过menuInterceptor拦截器进行处理，具体的处理逻辑在MenuInterceptor类中实现，可能涉及菜单相关的各种业务逻辑操作，比如权限验证、菜单数据准备等。
 		registry.addInterceptor(menuInterceptor).addPathPatterns("/**");
+
+		// 将memberInterceptor添加到拦截器链中，并设置其拦截的路径模式为"/member/**"，表示拦截以"/member/"开头的所有请求路径，
+		// 通常用于处理与会员相关模块的请求，在这些请求被处理前，memberInterceptor会执行相应的会员相关逻辑，例如检查会员登录状态、会员权限验证等操作，确保只有符合条件的会员请求才能继续往下执行。
 		registry.addInterceptor(memberInterceptor).addPathPatterns("/member/**");
 	}
-	
+
-    @Override
+	/**
-    public void addResourceHandlers(ResourceHandlerRegistry registry) {
+	 * 重写WebMvcConfigurer接口中的addResourceHandlers方法，用于配置Spring Web MVC中资源处理器，
-	   registry.addResourceHandler("/files/**").addResourceLocations("file:"+fileStoragePath);
+	 * 可以指定对外暴露的资源路径（如图片、文件等资源的访问路径）以及对应的资源实际在服务器上的存放位置，使得客户端能够通过配置好的路径访问到相应的资源，方便应用中对静态资源或文件资源的管理和访问。
-    }
+	 *
-    
+	 * @param registry ResourceHandlerRegistry对象，它提供了添加资源处理器相关配置的方法，通过调用其相关方法可以将资源的访问路径与实际存放位置进行映射配置，
-    @Bean
+	 *                 让Spring Web MVC知道如何处理不同资源路径的请求，将请求正确地转发到对应的资源文件上。
-    public CookieSerializer defaultCookieSerializer(){
+	 */
-        DefaultCookieSerializer defaultCookieSerializer = new DefaultCookieSerializer();
+	@Override
-        defaultCookieSerializer.setCookieName("sessionId");
+	public void addResourceHandlers(ResourceHandlerRegistry registry) {
-        defaultCookieSerializer.setDomainName(cookieDomianName);
+		// 配置一个资源处理器，指定对外暴露的资源访问路径为"/files/**"，这也是一种Ant风格的路径匹配表达式，表示以"/files/"开头的所有路径都将被映射到对应的资源位置，
-        defaultCookieSerializer.setCookiePath("/");
+		// 例如客户端访问"/files/image.jpg"就会去查找实际对应的资源文件（具体查找位置由后面配置的实际存放位置决定）。
-        return defaultCookieSerializer;
+		// 同时通过addResourceLocations方法指定资源实际存放的位置，使用"file:"前缀加上之前注入的fileStoragePath变量（表示文件存储的实际路径），
-    }
+		// 这样Spring Web MVC就能根据这个配置，将对"/files/**"路径的请求转发到服务器上fileStoragePath指定的实际文件存储位置去查找并返回对应的资源文件了。
-    
+		registry.addResourceHandler("/files/**").addResourceLocations("file:" + fileStoragePath);
-}
+	}
+
+	/**
+	 * 定义一个名为defaultCookieSerializer的方法，并使用@Bean注解将其返回的对象注册为Spring容器中的一个Bean，
+	 * 该方法用于创建并配置一个DefaultCookieSerializer实例，用于对Cookie进行序列化相关的设置，比如设置Cookie的名称、域名、路径等属性，
+	 * 使得在应用中使用Spring Session管理会话时，生成的Cookie能够按照配置的要求进行正确的设置和传递，保证会话相关的功能正常实现。
+	 *
+	 * @return 返回一个配置好的DefaultCookieSerializer对象，该对象会被Spring容器管理，在需要对Cookie进行序列化操作（例如创建、更新会话相关的Cookie）时被使用，
+	 * 按照配置的参数来生成符合要求的Cookie信息，确保在客户端和服务器之间正确传递会话相关的数据。
+	 */
+	@Bean
+	public CookieSerializer defaultCookieSerializer() {
+		// 创建一个DefaultCookieSerializer实例，它是Spring Session中用于对Cookie进行序列化处理的默认实现类，
+		// 通过对其属性进行设置，可以定制Cookie的各种参数，如名称、域名、路径等，以满足应用在不同环境下的需求。
+		DefaultCookieSerializer defaultCookieSerializer = new DefaultCookieSerializer();
+
+		// 设置Cookie的名称为"sessionId"，在客户端浏览器中看到的Cookie的键名就会是"sessionId"，用于标识会话相关的信息，
+		// 服务器通过这个名称来识别和获取对应的Cookie值，从而获取会话相关的数据，例如判断用户是否登录、获取用户会话中的其他属性等操作。
+		defaultCookieSerializer.setCookieName("sessionId");
+
+		// 设置Cookie的域名，使用之前注入的cookieDomianName变量作为域名值，确定Cookie在哪些域名下有效，
+		// 这样可以根据业务需求限制Cookie的作用范围，比如只在特定的子域名或者主域名下有效，确保会话相关的信息在合适的域名范围内传递和使用。
+		defaultCookieSerializer.setDomainName(cookieDomianName);
+
+		// 设置Cookie的路径为"/"，表示这个Cookie在整个应用的所有路径下都有效，客户端在访问应用的任何页面时都会带上这个Cookie，
+		// 方便服务器根据Cookie中的会话信息来处理不同路径下的请求，维持用户的会话状态，实现诸如登录状态保持等功能。
+		defaultCookieSerializer.setCookiePath("/");
+
+		return defaultCookieSerializer;
+	}
+}

tamguo-tms/src/main/java/com/tamguo/utils/BrowserUtils.java

@@ -2,33 +2,65 @@ package com.tamguo.utils;
 
 import java.util.regex.Pattern;
 
+// 这个类主要用于判断访问设备的类型，通过分析浏览器标识（User-Agent）字符串，利用正则表达式来检测是否是移动设备（包括手机和平板）进行访问，
+// 提供了一个静态方法方便外部调用，在Web应用开发中可用于根据不同的访问设备来提供适配的页面展示或者功能逻辑等情况。
 public class BrowserUtils {
 
-    // \b 是单词边界(连着的两个(字母字符 与 非字母字符) 之间的逻辑上的间隔),    
+    // 定义一个表示手机设备的正则表达式字符串常量，用于匹配各种常见的手机操作系统、手机品牌及相关设备标识等信息，
-    // 字符串在编译时会被转码一次,所以是 "\\b"    
+    // 通过这个正则表达式可以判断浏览器标识（User-Agent）中是否包含手机相关的特征字符串，从而确定是否是手机设备访问。
-    // \B 是单词内部逻辑间隔(连着的两个字母字符之间的逻辑上的间隔)    
+    // 以下是对正则表达式各部分的详细说明：
-   private static final String phoneReg = "\\b(ip(hone|od)|android|opera m(ob|in)i"    
+    // \b 是单词边界（连着的两个（字母字符 与 非字母字符）之间的逻辑上的间隔），在Java字符串中，由于反斜杠本身需要转义，所以表示为 "\\b"。
-            +"|windows (phone|ce)|blackberry"    
+    // 正则表达式中的 "ip(hone|od)" 用于匹配 "iphone" 或者 "ipod"，表示苹果的手机或类似移动设备。
-            +"|s(ymbian|eries60|amsung)|p(laybook|alm|rofile/midp"    
+    // "android" 用于匹配安卓操作系统相关的设备标识，常见于安卓手机等移动设备的浏览器标识中。
-            +"|laystation portable)|nokia|fennec|htc[-_]"    
+    // "opera m(ob|in)i" 用于匹配 Opera 浏览器的移动版本相关标识，比如 Opera Mobile 或者 Opera Mini，也是常见的移动设备浏览器情况。
-            +"|mobile|up.browser|[1-4][0-9]{2}x[1-4][0-9]{2})\\b";    
+    // "windows (phone|ce)" 用于匹配微软的 Windows Phone 或者 Windows CE 系统相关的移动设备标识，过去常用于一些微软系的手机等设备。
+    // "blackberry" 用于匹配黑莓手机的相关标识，黑莓曾经是很知名的手机品牌，有其独特的浏览器标识特征可以通过这个来匹配。
+    // "s(ymbian|eries60|amsung)" 这里可以匹配塞班系统（"symbian"）、诺基亚塞班 S60 系列（"series60"）以及三星（"samsung"）部分旧的移动设备相关标识，这些都是曾经在手机领域常见的系统或品牌标识情况。
+    // "p(laybook|alm|rofile/midp" 等部分用于匹配黑莓的 PlayBook、Palm 设备以及一些基于 Java ME（通过 "profile/midp" 匹配相关的配置和规范标识）的移动设备等情况，涵盖了多种不同类型的旧有移动设备特征。
+    // "laystation portable" 用于匹配索尼的 PlayStation Portable 设备，虽然它主要是游戏机，但也具备一定的浏览器功能，属于可移动使用的设备，所以也在匹配范围内。
+    // "nokia" 简单直接地匹配诺基亚手机相关标识，诺基亚曾经是全球最大的手机制造商之一，有很多不同型号手机的浏览器标识可以通过这个来识别是否是诺基亚手机访问。
+    // "fennec" 用于匹配火狐浏览器针对移动设备推出的 Fennec 版本相关标识，是移动版火狐浏览器的特征字符串。
+    // "htc[-_]" 用于匹配 HTC 品牌手机相关标识，HTC 也是知名的手机制造商，其设备在浏览器标识中通常有特定的字符串特征，这里通过包含 "htc" 以及可能的连接字符（"-" 或者 "_"）来匹配。
+    // "mobile" 是一个比较通用的表示移动设备的标识字符串，很多移动设备的浏览器标识中都会包含这个单词来表明其是移动设备。
+    // "up.browser" 用于匹配某些特定的移动浏览器相关标识，可能是一些不太常见但存在的移动设备浏览器情况。
+    // "[1-4][0-9]{2}x[1-4][0-9]{2}" 这部分用于匹配一些特定分辨率格式的设备标识，常见于一些较老的移动设备通过分辨率相关信息来辅助判断是否是移动设备访问，不过这种方式相对比较模糊，只是作为一种补充的匹配特征。
+    private static final String phoneReg = "\\b(ip(hone|od)|android|opera m(ob|in)i"
+            + "|windows (phone|ce)|blackberry"
+            + "|s(ymbian|eries60|amsung)|p(laybook|alm|rofile/midp"
+            + "|laystation portable)|nokia|fennec|htc[-_]"
+            + "|mobile|up.browser|[1-4][0-9]{2}x[1-4][0-9]{2})\\b";
 
-   private static final String tabletReg = "\\b(ipad|tablet|(Nexus 7)|up.browser|[1-4][0-9]{2}x[1-4][0-9]{2})\\b";    
+    // 定义一个表示平板设备的正则表达式字符串常量，用于匹配常见的平板电脑相关标识信息，
+    // 同样通过分析浏览器标识（User-Agent）中是否包含这些特征字符串来判断是否是平板设备访问，其原理和手机设备的正则表达式类似，只是匹配的具体字符串不同，更侧重于平板相关的标识。
+    // 其中 "ipad" 用于匹配苹果的 iPad 平板电脑，这是市场占有率很高的平板设备，有其独特的浏览器标识特征。
+    // "tablet" 是一个比较通用的表示平板电脑的标识字符串，很多平板设备的浏览器标识中会包含它来表明自身是平板类型的设备。
+    // "(Nexus 7)" 用于匹配谷歌的 Nexus 7 平板电脑相关标识，Nexus 系列平板曾经也比较受欢迎，有其特定的标识可以用于识别。
+    // "up.browser" 和 "[1-4][0-9]{2}x[1-4][0-9]{2}" 的含义与手机设备正则表达式中的类似，同样是作为辅助匹配一些特定情况的平板设备标识情况。
+    private static final String tabletReg = "\\b(ipad|tablet|(Nexus 7)|up.browser|[1-4][0-9]{2}x[1-4][0-9]{2})\\b";
 
-  //移动设备正则匹配：手机端、平板  
+    // 使用Pattern类对phoneReg正则表达式进行编译，创建一个Pattern对象（phonePat），用于后续在匹配手机设备相关标识时使用，
-   private static Pattern phonePat = Pattern.compile(phoneReg, Pattern.CASE_INSENSITIVE);    
+    // 通过编译后的Pattern对象可以更高效地进行正则匹配操作，并且可以设置匹配的相关参数（如这里通过第二个参数设置为 Pattern.CASE_INSENSITIVE 表示忽略大小写进行匹配），
-   private static Pattern tabletPat = Pattern.compile(tabletReg, Pattern.CASE_INSENSITIVE);    
+    // 这样在判断浏览器标识中是否包含手机设备相关特征时，就可以直接使用这个编译好的对象进行匹配操作了。
+    private static Pattern phonePat = Pattern.compile(phoneReg, Pattern.CASE_INSENSITIVE);
 
-    /** 
+    // 同样地，对tabletReg正则表达式进行编译，创建一个Pattern对象（tabletPat），用于匹配平板设备相关标识，
-     * 检测是否是移动设备访问 
+    // 设置匹配参数为忽略大小写（Pattern.CASE_INSENSITIVE），方便后续在分析浏览器标识时判断是否存在平板设备相关的特征字符串，进而确定是否是平板设备访问。
-     * 
+    private static Pattern tabletPat = Pattern.compile(tabletReg, Pattern.CASE_INSENSITIVE);
-     * @param userAgent 浏览器标识 
+
-     * @return true:移动设备接入，false:pc端接入 
+    /**
-     */  
+     * 这个静态方法用于检测传入的浏览器标识（User-Agent）对应的访问设备是否是移动设备（包括手机和平板），
-    public static boolean isMobile(String userAgent){    
+     * 通过使用之前编译好的手机设备正则匹配对象（phonePat）和平板设备正则匹配对象（tabletPat）分别对浏览器标识进行正则匹配操作，
-        if(null == userAgent){    
+     * 只要其中一个匹配成功（即找到了对应的手机或平板设备相关特征字符串），就返回 true，表示是移动设备接入；如果都匹配失败，则返回 false，表示是 PC 端接入。
-            userAgent = "";    
+     *
-        }   
+     * @param userAgent 浏览器标识字符串，通常是从 HTTP 请求头中的 "User-Agent" 字段获取到的值，它包含了访问设备、浏览器等相关的特征信息，
-        return phonePat.matcher(userAgent).find() || tabletPat.matcher(userAgent).find(); 
+     *                  通过分析这个字符串可以判断访问来源的设备类型，以便应用可以根据不同设备类型进行相应的页面适配或者功能调整等操作。
-    }  
+     * @return 返回一个布尔值，如果检测到浏览器标识中包含手机或平板设备相关的特征字符串（即通过正则匹配成功），返回 true，表示是移动设备接入；
+     * 若没有匹配到相关特征字符串，则返回 false，表示是 PC 端接入，供调用者根据返回值来进行后续不同的业务逻辑处理，比如返回不同的页面视图等情况。
+     */
+    public static boolean isMobile(String userAgent) {
+        if (null == userAgent) {
+            userAgent = "";
+        }
+        return phonePat.matcher(userAgent).find() || tabletPat.matcher(userAgent).find();
+    }
 }

tamguo-tms/src/main/java/com/tamguo/utils/PageUtils.java

@@ -5,85 +5,138 @@ import java.util.List;
 
 import com.baomidou.mybatisplus.plugins.Page;
 
+// 这个类主要用于对分页数据进行进一步的处理和包装，以便生成更适合前端展示分页相关交互元素（如下一页、上一页按钮显示控制以及页码列表展示等）的对象，
+// 它基于MyBatis Plus的Page对象进行相关计算和属性设置，提供了一种方便的方式将分页数据转换为前端易于处理和展示的格式。
 public class PageUtils {
-    
+
-	// 是否下一页按钮
+	// 用于标识是否显示下一页按钮，初始化为false，表示默认不显示下一页按钮，后续会根据当前页码与总页数的关系来动态设置其值，
+	// 如果当前页小于总页数，就会将其设置为true，表示需要显示下一页按钮，方便用户点击跳转到下一页查看更多数据。
 	private Boolean isShowNextBtn = false;
-	
+
-	// 是否上一页按钮
+	// 用于标识是否显示上一页按钮，同样初始化为false，默认不显示上一页按钮，根据当前页码与总页数等情况来确定是否要显示，
+	// 当当前页码大于1时，说明不是第一页，此时会将该属性设置为true，以在前端展示上一页按钮，供用户点击返回上一页查看数据。
 	private Boolean isShowPreBtn = false;
-	
+
-	// 当前页
+	// 记录当前所在的页码，用于在生成页码列表以及判断上下页按钮显示情况等操作时作为重要依据，其值会从传入的Page对象中获取并设置。
 	private Integer currPageNum;
-	
+
-	// 页码列表
+	// 用于存储要展示给用户的页码列表，例如可能是一个包含了连续页码数字以及省略号（用于表示中间省略部分页码）的字符串列表，
+	// 通过一定的逻辑计算生成，方便在前端展示分页导航栏，让用户可以直观地点击相应页码进行页面跳转，查看不同页的数据。
 	private List<String> pageNums;
-	
+
-	// 总页数
+	// 表示分页数据的总页数，从传入的Page对象中获取该值，用于判断是否需要生成多页的页码列表以及确定上下页按钮的显示逻辑等操作，
+	// 是整个分页逻辑处理中的一个关键数据指标。
 	private Integer totalPage;
-	
+
-	// 总数量
+	// 用于记录数据的总数量，同样从Page对象中获取，它反映了符合查询条件的所有数据的总数，有助于前端展示一些相关提示信息（如共多少条数据等）以及辅助分页相关的逻辑判断。
 	private Integer total;
-	
+
-	// 数据
+	// 存储当前页的数据列表，从Page对象中获取对应页码的数据记录，这是最终要展示给用户的数据内容，会传递给前端进行列表展示等操作。
 	private List<?> list;
-	
+
-	public static PageUtils getPage(Page<?> page){
+	/**
+	 * 这是一个静态方法，用于根据传入的MyBatis Plus的Page对象创建并返回一个PageUtils对象，在这个方法中会对PageUtils对象的各个属性进行设置，
+	 * 包括上下页按钮的显示控制、页码列表的生成以及将Page对象中的相关分页数据（如当前页数据、总数量、总页数等）赋值到PageUtils对象的对应属性上，
+	 * 从而生成一个适合前端展示分页相关信息的对象。
+	 *
+	 * @param page MyBatis Plus的Page对象，它包含了分页查询的相关数据，如当前页码、每页记录数、总记录数、总页数以及当前页的数据列表等信息，
+	 *             通过对这个对象进行解析和处理，来构建PageUtils对象，以便为前端提供更友好的分页展示相关数据。
+	 * @return 返回一个配置好各个属性的PageUtils对象，该对象可以传递给前端，前端可以根据其属性值来展示分页导航栏（包含上下页按钮、页码列表等）以及对应页的数据列表等内容。
+	 */
+	public static PageUtils getPage(Page<?> page) {
 		PageUtils pg = new PageUtils();
-		if(page.getCurrent() > 1){
+
+		// 判断当前页码是否大于1，如果大于1，说明不是第一页，此时需要显示上一页按钮，将PageUtils对象的isShowPreBtn属性设置为true，
+		// 这样前端在展示分页导航栏时就会显示上一页按钮，方便用户点击返回上一页查看数据。
+		if (page.getCurrent() > 1) {
 			pg.setIsShowPreBtn(true);
 		}
-		if(page.getCurrent() < page.getPages()){
+
+		// 判断当前页码是否小于总页数，如果小于总页数，意味着还有下一页数据，需要显示下一页按钮，将PageUtils对象的isShowNextBtn属性设置为true，
+		// 以便前端展示下一页按钮，供用户点击跳转到下一页查看更多数据。
+		if (page.getCurrent() < page.getPages()) {
 			pg.setIsShowNextBtn(true);
 		}
+
 		List<String> pgNums = new ArrayList<>();
-		if(page.getPages() > 1){
+
-			if(page.getPages() > 10){
+		// 判断总页数是否大于1，如果大于1，说明有多页数据，需要生成相应的页码列表进行展示，进入下面不同情况的页码列表生成逻辑；
+		// 如果总页数等于1，说明只有一页数据，页码列表就只包含一个页码（通常就是1），后续会在循环中进行相应处理。
+		if (page.getPages() > 1) {
+			// 如果总页数大于10，说明页码较多，采用一种简化展示的方式生成页码列表，通常会显示首页、前几页、中间用省略号表示、当前页及其前后几页、尾页等关键页码信息，
+			// 方便用户在较多页码情况下能快速定位到想要查看的页面附近进行跳转操作。
+			if (page.getPages() > 10) {
+				// 添加页码1，表示首页，一般在分页导航栏中会作为第一个可点击的页码展示，方便用户快速回到第一页查看数据。
 				pgNums.add("1");
+				// 添加页码2，作为前面几页中的一个页码展示，让用户可以较方便地查看前面几页的数据情况。
 				pgNums.add("2");
+				// 添加页码3，同样是作为前面几页的页码展示，丰富前面部分页码的展示内容，便于用户操作。
 				pgNums.add("3");
+				// 添加省略号，表示中间省略了部分页码，因为总页数较多，全部展示会显得很冗长，通过省略号提示用户中间还有其他页码存在。
 				pgNums.add("...");
-				if(page.getCurrent() == page.getPages()){
+
-					pgNums.add(((Integer)(page.getCurrent() - 2)).toString());
+				// 判断当前页码是否等于总页数，如果等于总页数，说明当前是最后一页，页码列表的生成逻辑稍有不同，
-					pgNums.add(((Integer)(page.getCurrent() - 1)).toString());
+				// 需要展示当前页（最后一页）及其前面紧邻的两页页码，方便用户查看临近的页面情况或者进行前后页跳转等操作。
-					pgNums.add(((Integer)page.getCurrent()).toString());
+				if (page.getCurrent() == page.getPages()) {
+					pgNums.add(((Integer) (page.getCurrent() - 2)).toString());
+					pgNums.add(((Integer) (page.getCurrent() - 1)).toString());
+					pgNums.add(((Integer) page.getCurrent()).toString());
 				} else {
-					pgNums.add(((Integer)(page.getCurrent() - 1)).toString());
+					// 如果当前页码不是总页数，说明在中间页面，此时展示当前页及其前后各一页的页码，方便用户在当前页附近进行页码跳转查看数据。
-					pgNums.add(((Integer)(page.getCurrent())).toString());
+					pgNums.add(((Integer) (page.getCurrent() - 1)).toString());
-					pgNums.add(((Integer)(page.getCurrent() + 1)).toString());
+					pgNums.add(((Integer) (page.getCurrent())).toString());
+					pgNums.add(((Integer) (page.getCurrent() + 1)).toString());
 				}
-			}else{
+			} else {
+				// 如果总页数小于等于10，说明页码较少，可以完整地展示所有页码，通过循环依次将页码数字转换为字符串并添加到页码列表中，
+				// 方便前端展示所有可点击的页码，让用户能方便地在各页之间进行跳转查看数据。
 				Integer n = 1;
-				if(page.getTotal() > 0){
+				if (page.getTotal() > 0) {
-					while(true){
+					while (true) {
 						pgNums.add(n.toString());
-						if(n  >= page.getPages()){
+						if (n >= page.getPages()) {
 							break;
 						}
-						n ++;
+						n++;
 					}
 				}
 			}
 		} else {
+			// 如果总页数等于1，同样通过循环添加唯一的页码（就是1）到页码列表中，虽然只有一页数据，但前端展示时也需要展示对应的页码信息，保持分页展示逻辑的一致性。
 			Integer n = 1;
-			if(page.getTotal() > 0){
+			if (page.getTotal() > 0) {
-				while(true){
+				while (true) {
 					pgNums.add(n.toString());
-					if(n  >= page.getPages()){
+					if (n >= page.getPages()) {
 						break;
 					}
-					n ++;
+					n++;
 				}
 			}
 		}
+
+		// 将生成好的页码列表设置到PageUtils对象的pageNums属性中，以便前端可以获取并展示这个页码列表，实现分页导航栏中页码部分的展示功能。
 		pg.setPageNums(pgNums);
+
+		// 将Page对象中的当前页数据列表设置到PageUtils对象的list属性中，这些数据就是要展示给用户查看的具体内容，
+		// 前端可以根据这个属性获取数据并进行列表展示等操作，呈现当前页的详细数据信息。
 		pg.setList(page.getRecords());
-		pg.setCurrPageNum(((Integer)page.getCurrent()));
+
-		pg.setTotal(((Integer)page.getTotal()));
+		// 将Page对象中的当前页码赋值给PageUtils对象的currPageNum属性，用于前端展示当前所在页码以及在一些分页相关逻辑判断（如下一页、上一页按钮显示等）中作为依据。
-		pg.setTotalPage(((Integer)page.getPages()));
+		pg.setCurrPageNum(((Integer) page.getCurrent()));
+
+		// 将Page对象中的总数据数量赋值给PageUtils对象的total属性，方便前端展示数据总量相关提示信息（如共多少条数据等），让用户对数据整体情况有直观了解。
+		pg.setTotal(((Integer) page.getTotal()));
+
+		// 将Page对象中的总页数赋值给PageUtils对象的totalPage属性，在前端分页展示逻辑中，例如判断是否显示上下页按钮、生成页码列表等操作时，会用到这个总页数信息，
+		// 确保分页相关的展示和操作符合实际的总页数情况。
+		pg.setTotalPage(((Integer) page.getPages()));
+
 		return pg;
 	}
 
+	// 以下是各个属性的Getter和Setter方法，用于获取和设置PageUtils对象的各个属性值，
+	// 遵循JavaBean的规范，方便在其他地方对PageUtils对象的属性进行访问和修改操作，例如在前端获取相关属性进行展示，或者在其他业务逻辑中根据需要设置属性值等情况。
 
 	public Boolean getIsShowNextBtn() {
 		return isShowNextBtn;
@@ -109,42 +162,34 @@ public class PageUtils {
 		this.list = list;
 	}
 
-
 	public Boolean getIsShowPreBtn() {
 		return isShowPreBtn;
 	}
 
-
 	public void setIsShowPreBtn(Boolean isShowPreBtn) {
 		this.isShowPreBtn = isShowPreBtn;
 	}
 
-
 	public Integer getCurrPageNum() {
 		return currPageNum;
 	}
 
-
 	public void setCurrPageNum(Integer currPageNum) {
 		this.currPageNum = currPageNum;
 	}
 
-
 	public Integer getTotalPage() {
 		return totalPage;
 	}
 
-
 	public void setTotalPage(Integer totalPage) {
 		this.totalPage = totalPage;
 	}
 
-
 	public Integer getTotal() {
 		return total;
 	}
 
-
 	public void setTotal(Integer total) {
 		this.total = total;
 	}

tamguo-tms/src/main/java/com/tamguo/utils/ShiroUtils.java

@@ -6,38 +6,91 @@ import org.apache.shiro.subject.Subject;
 
 import com.tamguo.modules.member.model.MemberEntity;
 
+// 这个类是一个工具类，主要提供了一系列基于Apache Shiro框架的便捷方法，用于获取与当前用户相关的各种信息（如用户实体对象、用户ID等）、操作会话（设置和获取会话属性）以及判断用户登录状态、执行登出操作等，
+// 通过这些静态方法，可以在项目的不同地方方便地与Shiro框架进行交互，减少重复代码，使得对用户相关功能的处理更加简洁和统一。
 public class ShiroUtils {
 
+	/**
+	 * 获取当前用户的Shiro会话对象（Session）。
+	 * 在Shiro框架中，会话（Session）用于在用户与服务器交互过程中保存用户相关的状态信息等，例如登录后的用户身份信息、一些临时的业务数据等，
+	 * 通过调用SecurityUtils.getSubject()先获取当前的Subject对象（代表当前用户的安全主体），再调用其getSession()方法获取对应的会话对象，方便后续在会话中进行属性操作等。
+	 *
+	 * @return 返回当前用户的Shiro会话对象，供调用者在需要操作会话相关信息（如存储、获取会话中的属性值等）时使用。
+	 */
 	public static Session getSession() {
 		return SecurityUtils.getSubject().getSession();
 	}
 
+	/**
+	 * 获取当前的Subject对象，在Shiro框架中，Subject代表了当前与系统进行交互的“主体”，通常就是指当前登录的用户或者一个匿名的访问者（未登录时），
+	 * 通过SecurityUtils.getSubject()方法可以获取到这个代表当前主体的对象，后续可以基于这个对象进行很多与用户安全相关的操作，比如获取用户身份信息、判断登录状态、执行认证授权相关操作等。
+	 *
+	 * @return 返回代表当前用户（或访问主体）的Subject对象，以便在其他地方基于这个对象进一步调用Shiro框架提供的各种方法来实现不同的功能。
+	 */
 	public static Subject getSubject() {
 		return SecurityUtils.getSubject();
 	}
 
+	/**
+	 * 获取当前登录用户对应的MemberEntity对象，在Shiro框架中，认证成功后会将代表用户的主体信息（通常是用户实体对象或者包含用户关键信息的对象）设置到Subject的Principal位置，
+	 * 这里假设认证时将MemberEntity类型的用户对象设置为了Principal，通过调用SecurityUtils.getSubject().getPrincipal()获取到这个Principal对象，然后强制类型转换为MemberEntity类型返回，
+	 * 从而获取到当前登录的会员用户的详细信息对象，方便在业务逻辑中使用会员的各种属性进行相关操作，比如获取会员的用户名、会员等级等信息。
+	 *
+	 * @return 返回当前登录用户对应的MemberEntity对象，如果当前用户未登录（即Principal为null），则会抛出ClassCastException异常，所以在调用该方法前通常需要先判断用户是否登录（可以使用isLogin方法判断）。
+	 */
 	public static MemberEntity getMember() {
-		return (MemberEntity)SecurityUtils.getSubject().getPrincipal();
+		return (MemberEntity) SecurityUtils.getSubject().getPrincipal();
 	}
 
+	/**
+	 * 获取当前登录用户的唯一标识（ID），通过先调用getMember()方法获取到当前登录用户对应的MemberEntity对象，再调用其getId()方法获取用户的ID值，
+	 * 这个ID可以用于在数据库查询、业务逻辑判断等场景中作为区分不同用户的关键依据，例如根据用户ID查询该用户的相关业务数据、判断权限等操作。
+	 *
+	 * @return 返回当前登录用户的ID值（以字符串形式），前提是用户已登录且MemberEntity对象中有对应的ID属性以及相应的getId()方法实现，否则可能出现空指针等异常情况（如果用户未登录，getMember方法会返回null），
+	 * 所以在调用此方法前一般要先确保用户已登录（可结合isLogin方法进行判断）。
+	 */
 	public static String getMemberId() {
 		return getMember().getId();
 	}
-	
+
+	/**
+	 * 在当前用户的Shiro会话中设置属性，通过先调用getSession()方法获取到当前用户的会话对象，然后调用其setAttribute方法将要存储的属性键（key）和对应的值（value）设置到会话中，
+	 * 可以利用会话来临时保存一些与当前用户交互过程相关的数据，例如在一次业务操作流程中传递中间状态的数据、保存用户在某个页面的临时选择等信息，方便在后续的请求处理中获取使用。
+	 *
+	 * @param key 要设置的会话属性的键，通常是一个字符串或者其他可作为Map键的对象类型，用于唯一标识要存储的属性，方便后续通过相同的键来获取对应的属性值。
+	 * @param value 要设置的会话属性的值，可以是任意类型的对象，它就是实际要存储到会话中的业务数据，后续通过对应的键可以获取到这个值进行相应的业务逻辑处理。
+	 */
 	public static void setSessionAttribute(Object key, Object value) {
 		getSession().setAttribute(key, value);
 	}
 
+	/**
+	 * 从当前用户的Shiro会话中获取指定键对应的属性值，先获取当前用户的会话对象（通过getSession方法），再调用其getAttribute方法并传入属性键（key），
+	 * 可以获取到之前在会话中通过setSessionAttribute方法设置的对应属性值，方便在不同的请求处理阶段获取之前临时保存的与当前用户相关的数据，用于业务逻辑的延续和处理。
+	 *
+	 * @param key 要获取的会话属性的键，与设置属性时的键相对应，通过这个键来查找并获取之前存储在会话中的值，如果键不存在，会返回null，可根据业务需求进行相应的处理（如判断是否为null来决定后续操作）。
+	 * @return 返回会话中指定键对应的属性值对象，如果不存在对应的属性（即键不存在），则返回null，由调用者根据返回值进行后续的业务逻辑判断和处理。
+	 */
 	public static Object getSessionAttribute(Object key) {
 		return getSession().getAttribute(key);
 	}
 
+	/**
+	 * 判断当前用户是否已经登录，通过获取当前用户的Subject对象，然后检查其Principal是否为null来确定用户是否登录，
+	 * 如果Principal不为null，说明已经通过认证，有对应的用户主体信息存在，即用户已登录；如果Principal为null，则表示当前是匿名访问或者未进行认证操作，用户未登录。
+	 * 这个方法可以在很多业务逻辑中用于前置判断，例如在需要用户登录后才能访问的功能模块入口处进行判断，根据返回值决定是否允许用户继续访问或者提示用户先登录等操作。
+	 *
+	 * @return 返回一个布尔值，如果用户已登录（即Subject的Principal不为null），返回true；如果用户未登录（Principal为null），则返回false，供调用者根据返回值进行相应的业务逻辑处理。
+	 */
 	public static boolean isLogin() {
-		return SecurityUtils.getSubject().getPrincipal() != null;
+		return SecurityUtils.getSubject().getPrincipal()!= null;
 	}
 
+	/**
+	 * 执行用户登出操作，通过调用SecurityUtils.getSubject().logout()方法，通知Shiro框架清除当前用户的认证状态、会话信息等相关数据，
+	 * 将用户的登录状态置为未登录，释放与登录相关的资源，例如清除会话中存储的临时数据、撤销权限缓存等操作，确保用户登出后系统的安全状态以及数据的一致性。
+	 */
 	public static void logout() {
 		SecurityUtils.getSubject().logout();
 	}
-
+}
-}

tamguo-tms/src/main/java/com/tamguo/web/interceptor/MemberInterceptor.java

@@ -8,53 +8,79 @@ import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Component;
 import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
 
+// @Component注解用于将这个类标记为Spring框架中的一个组件，意味着Spring容器会在启动时扫描到这个类，并将其作为一个Bean进行管理，
+// 使其能够参与到Spring应用的依赖注入以及整个应用的请求处理流程中，在这里它作为一个拦截器，用于拦截特定路径下的请求并进行会员相关的验证逻辑处理。
 @Component
-public class MemberInterceptor extends HandlerInterceptorAdapter{
+// 这个类继承自HandlerInterceptorAdapter类，HandlerInterceptorAdapter是Spring Web MVC中提供的一个用于方便实现拦截器功能的抽象类，
+// 通过重写其中的方法，可以在请求处理的不同阶段（如请求前、请求处理后、视图渲染后等）进行拦截并添加自定义的逻辑，这里主要重写了preHandle方法，用于在请求处理前进行会员登录状态的验证等操作。
+public class MemberInterceptor extends HandlerInterceptorAdapter {
 
-	/** "重定向URL"参数名称 */
+	// 定义一个表示重定向URL参数名称的常量字符串，用于在重定向到登录页面时，将当前请求的URL作为参数传递过去，以便用户登录成功后可以回到原本要访问的页面，
+	// 在后续构建重定向URL的逻辑中会使用这个参数名称来添加对应的参数信息。
 	private static final String REDIRECT_URL_PARAMETER_NAME = "redirectUrl";
 
-	/** 默认登录URL */
+	// 定义一个表示默认登录URL的常量字符串，初始化为"/login.html"，如果没有通过配置文件指定具体的登录URL，就会使用这个默认值作为登录页面的路径，
+	// 在后续处理用户未登录需要重定向到登录页面的情况时，会参考这个默认值或者配置后的登录Url值来构建重定向的目标URL。
 	private static final String DEFAULT_LOGIN_URL = "/login.html";
 
-	/** 登录URL */
+	// 用于存储登录URL的变量，初始化为默认登录URL（DEFAULT_LOGIN_URL），后续可以通过配置文件注入具体的值来覆盖默认值，
+	// 确定实际应用中用户登录页面的具体访问路径，以便在需要引导未登录用户去登录时，能够准确地重定向到正确的登录页面。
 	private String loginUrl = DEFAULT_LOGIN_URL;
-	
+
+	// 通过@Value注解从配置文件（例如application.properties或application.yml等）中获取名为"member.domain.name"的属性值，并注入到memberDomainName变量中，
+	// 这个属性值通常表示会员相关模块所在的域名，在构建重定向到登录页面等相关的URL时会用到，用于确保重定向的URL是在正确的域名下，符合业务的域名配置要求。
 	@Value("${member.domain.name}")
 	private String memberDomainName;
-	
+
 	/**
-	 * 请求前处理
+	 * 重写了父类HandlerInterceptorAdapter中的preHandle方法，该方法会在请求处理之前被调用，用于在请求进入实际的业务处理器之前进行拦截并执行一些前置验证逻辑，
-	 * 
+	 * 在这里主要是验证用户是否登录（通过检查会话中是否存在"currMember"属性来判断），如果已登录则允许请求继续执行；如果未登录，则根据不同的请求情况（如是否是Ajax请求、请求方法是GET还是其他等）进行相应的重定向或错误响应处理，
-	 * @param request
+	 * 以此实现对会员相关请求的登录验证功能，确保只有登录后的会员才能访问受保护的会员相关资源。
-	 *            HttpServletRequest
+	 *
-	 * @param response
+	 * @param request HttpServletRequest对象，它包含了客户端发送过来的请求相关的所有信息，如请求头、请求参数、请求路径等，
-	 *            HttpServletResponse
+	 *                通过这个对象可以获取到判断用户登录状态所需的信息（如从会话中获取用户信息）以及构建重定向URL等操作时需要的请求相关数据。
-	 * @param handler
+	 * @param response HttpServletResponse对象，用于向客户端发送响应信息，在这个方法中根据不同的验证情况，通过这个对象可以进行重定向操作、设置响应头、发送错误响应等，告知客户端相应的处理结果，
-	 *            处理器
+	 *                例如将未登录的用户重定向到登录页面或者给Ajax请求返回禁止访问的提示信息等操作。
-	 * @return 是否继续执行
+	 * @param handler 处理器对象，它代表了即将要处理当前请求的实际业务处理器（如某个Controller中的方法等），不过在这个方法中通常不需要直接操作这个对象，主要关注请求和响应的处理逻辑，
+	 *                只有在决定是否允许请求继续执行时会间接影响到这个处理器是否会被调用（如果返回true则会调用，返回false则不会调用）。
+	 * @return 返回一个布尔值，如果返回true，表示允许请求继续执行，会调用后续的业务处理器进行实际的请求处理；如果返回false，则表示拦截请求，不会调用业务处理器，直接结束当前请求的处理流程，
+	 * 根据不同的业务逻辑判断情况来决定返回值，例如用户已登录就返回true，未登录且不符合其他条件时返回false等情况。
+	 * @throws Exception 如果在处理过程中出现异常（如重定向过程中出现I/O异常等情况），会抛出相应的异常，Spring Web MVC框架会根据异常情况进行相应的处理，例如返回默认的错误页面等操作。
 	 */
 	@Override
 	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
-		Object currMember =  request.getSession().getAttribute("currMember");
+		// 从HttpServletRequest对象的会话（Session）中获取名为"currMember"的属性值，通常假设在用户登录成功后，会将登录的会员相关信息（比如会员对象等）存储在这个会话属性中，
-		if (currMember != null) {
+		// 通过判断这个属性是否为null来确定用户是否已经登录，如果不为null，则说明用户已登录，允许请求继续执行，返回true。
+		Object currMember = request.getSession().getAttribute("currMember");
+		if (currMember!= null) {
 			return true;
 		} else {
+			// 获取请求头中名为"X-Requested-With"的字段值，这个字段常用于判断请求是否是Ajax请求（很多JavaScript框架在发送Ajax请求时会设置这个请求头），
+			// 如果该字段值不为null且等于"XMLHttpRequest"（不区分大小写），说明当前请求是Ajax请求，对于Ajax请求的处理逻辑与普通页面请求稍有不同，如下所述。
 			String requestType = request.getHeader("X-Requested-With");
-			if (requestType != null && requestType.equalsIgnoreCase("XMLHttpRequest")) {
+			if (requestType!= null && requestType.equalsIgnoreCase("XMLHttpRequest")) {
+				// 如果是Ajax请求且用户未登录，向响应头中添加一个名为"loginStatus"的字段，值为"accessDenied"，用于告知前端（JavaScript代码等）用户未登录，禁止访问，
+				// 然后通过response.sendError方法发送一个HTTP状态码为HttpServletResponse.SC_FORBIDDEN（即403状态码，表示禁止访问）的错误响应，
+				// 前端接收到这个响应后可以根据响应头中的信息以及状态码进行相应的提示或者处理（比如弹出提示框告知用户需要登录等操作），最后返回false，拦截该请求，不让其继续执行后续的业务处理器。
 				response.addHeader("loginStatus", "accessDenied");
 				response.sendError(HttpServletResponse.SC_FORBIDDEN);
 				return false;
 			} else {
+				// 如果不是Ajax请求，再根据请求的方法（如GET、POST等）进行不同的重定向处理，这里先判断请求方法是否是GET请求。
 				if (request.getMethod().equalsIgnoreCase("GET")) {
-					String redirectUrl = request.getQueryString() != null ? request.getRequestURI() + "?" + request.getQueryString() : request.getRequestURI();
+					// 如果是GET请求，构建一个重定向的URL，用于将未登录的用户重定向到登录页面，并传递当前请求的URL作为参数（以便用户登录成功后能回到原本要访问的页面），具体构建逻辑如下：
+					// 首先判断请求中是否有查询字符串（即URL中?后面的部分），如果有，则将请求的完整路径（包括请求URI和查询字符串）作为重定向URL的一部分；
+					// 如果没有查询字符串，就只使用请求的URI作为重定向URL的一部分，然后通过URLEncoder将这个重定向URL进行UTF-8编码（防止中文等特殊字符出现编码问题），
+					// 最后将编码后的重定向URL作为参数（参数名为之前定义的REDIRECT_URL_PARAMETER_NAME）添加到登录URL后面，构建出完整的重定向URL，格式类似：memberDomainName + loginUrl + "?" + REDIRECT_URL_PARAMETER_NAME + "=" + 编码后的重定向URL。
+					String redirectUrl = request.getQueryString()!= null? request.getRequestURI() + "?" + request.getQueryString() : request.getRequestURI();
 					response.sendRedirect(memberDomainName + loginUrl + "?" + REDIRECT_URL_PARAMETER_NAME + "=" + URLEncoder.encode(redirectUrl, "UTF-8"));
 				} else {
+					// 如果请求方法不是GET请求（比如是POST等其他请求方法），则直接重定向到登录页面（不传递当前请求的URL作为参数了，因为非GET请求通常不适合这样处理，具体根据业务需求而定），
+					// 重定向的URL格式为memberDomainName + request.getContextPath() + loginUrl，其中request.getContextPath()获取的是当前应用在服务器上的上下文路径，确保重定向的登录URL是在正确的应用路径下。
 					response.sendRedirect(memberDomainName + request.getContextPath() + loginUrl);
 				}
 				return false;
 			}
 		}
 	}
-
+}
-}

tamguo-tms/src/main/java/com/tamguo/web/interceptor/MenuInterceptor.java

@@ -19,82 +19,149 @@ import com.tamguo.modules.tiku.service.IMenuService;
 import com.tamguo.modules.tiku.service.IPaperService;
 import com.tamguo.modules.tiku.service.ISchoolService;
 
-/**
+// @Component注解用于将这个类标记为Spring框架中的一个组件，意味着Spring容器会在启动时扫描到这个类，并将其作为一个Bean进行管理，
- * 菜单拦截
+// 使其能够参与到Spring应用的依赖注入以及整个Web应用的请求处理流程中，在这里它作为一个拦截器组件，用于拦截请求并处理与菜单相关的数据加载等操作。
- *
- */
 @Component
+// 这个类实现了HandlerInterceptor接口，HandlerInterceptor接口用于在Spring Web MVC中定义拦截器，
+// 通过实现该接口的三个方法（preHandle、postHandle、afterCompletion），可以在请求处理的不同阶段（请求前、请求处理后但视图渲染前、整个请求结束后）进行拦截并执行自定义的逻辑，
+// 比如进行权限验证、数据准备、资源清理等操作，此处主要用于在请求处理过程中准备菜单相关以及其他页面展示需要的数据，并设置到请求属性中供视图渲染使用。
 public class MenuInterceptor implements HandlerInterceptor {
-	
+
+	// 通过@Resource注解进行依赖注入，将IMenuService接口的实现类实例注入到当前类中，IMenuService用于处理与菜单相关的业务逻辑，
+	// 例如查询不同类型的菜单数据（全部菜单、左侧菜单、底部菜单等），在后续的拦截器方法中会调用其相关方法来获取菜单数据并设置到请求属性中，方便视图渲染时展示菜单信息。
 	@Resource
 	private IMenuService iMenuService;
+
+	// 同样通过@Resource注解注入IPaperService接口的实现类实例，IPaperService用于处理与试卷相关的业务逻辑，
+	// 比如查询不同类型的试卷数据（历史试卷、模拟试卷、热门试卷等），后续会调用其方法获取试卷数据并设置到请求属性，供页面展示试卷相关内容使用。
 	@Resource
 	private IPaperService iPaperService;
+
+	// 使用@Resource注解注入ISchoolService接口的实现类实例，ISchoolService用于处理与学校相关的业务逻辑，
+	// 像查询名校试卷、名校列表等数据，在拦截器的业务逻辑中会利用它获取相应的数据并添加到请求属性里，便于在页面上展示学校相关信息。
 	@Resource
 	private ISchoolService iSchoolService;
+
+	// 通过@Resource注解注入IAdService接口的实现类实例，IAdService用于处理与广告相关的业务逻辑，
+	// 在这里用于获取所有广告数据，然后将广告数据设置到请求属性中，使得页面能够展示相应的广告内容，实现广告投放等功能。
 	@Resource
 	private IAdService iAdService;
 
-    @Override
+	/**
-    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
+	 * 这个方法是HandlerInterceptor接口中的一个方法，会在请求处理之前被调用（在具体的Controller方法被调用之前），
-            throws Exception {
+	 * 可以在这里进行一些前置的验证、权限判断等操作，决定是否允许请求继续执行下去。当前实现直接返回true，表示允许所有请求继续执行，
-        //在请求处理之前进行调用（Controller方法调用之前）
+	 * 如果有特定的前置验证逻辑（比如判断用户是否登录、是否有访问权限等），可以在这里添加相应的代码进行判断，根据判断结果返回true或者false来控制请求流程。
-        return true;
+	 *
-    }
+	 * @param request HttpServletRequest对象，它包含了客户端发送过来的请求相关的所有信息，如请求头、请求参数、请求路径等，
-
+	 *                通过这个对象可以获取到进行前置验证等操作所需的信息，例如获取用户的登录凭证等信息来判断权限情况。
-    @Override
+	 * @param response HttpServletResponse对象，用于向客户端发送响应信息，虽然在这个方法中通常不需要直接操作它进行响应相关的操作，但在后续根据验证结果决定是否允许请求继续执行时，
-    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
+	 *                可以通过它来发送相应的错误响应等信息（比如返回403禁止访问等状态码及对应提示信息）给客户端。
-            ModelAndView modelAndView) throws Exception {
+	 * @param handler 处理器对象，它代表了即将要处理当前请求的实际业务处理器（如某个Controller中的方法等），不过在这个方法中通常不需要直接操作这个对象，主要关注请求是否允许继续执行的判断逻辑，
-        //请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）
+	 *                如果返回true，则后续会调用这个处理器进行实际的请求处理；如果返回false，则直接拦截请求，不会调用该处理器。
-    	List<MenuEntity> result = iMenuService.findMenus();
+	 * @return 返回一个布尔值，如果返回true，表示允许请求继续执行，会调用后续的业务处理器进行实际的请求处理；如果返回false，则表示拦截请求，不会调用业务处理器，直接结束当前请求的处理流程。
-    	request.setAttribute("menuList", result);
+	 * @throws Exception 如果在处理过程中出现异常（比如在获取验证相关数据时出现数据库连接异常等情况），会抛出相应的异常，Spring Web MVC框架会根据异常情况进行相应的处理，例如返回默认的错误页面等操作。
-    	
+	 */
-    	// 获取全部菜单
+	@Override
-    	List<MenuEntity> allMenuList = iMenuService.findAllMenus();
+	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
-    	request.setAttribute("allMenuList", allMenuList);
+			throws Exception {
-    	
+		//在请求处理之前进行调用（Controller方法调用之前）
-    	// 获取左侧菜单
+		return true;
-    	List<MenuEntity> leftMenuList = iMenuService.findLeftMenus();
+	}
-    	request.setAttribute("leftMenuList", leftMenuList);
+
-
+	/**
-    	// 获取底部菜单
+	 * 这个方法是HandlerInterceptor接口中的一个方法，会在请求处理之后、视图被渲染之前被调用（也就是在Controller方法执行完之后，但在返回的视图进行渲染展示给客户端之前），
-    	List<MenuEntity> footerMenuList = iMenuService.findFooterMenus();
+	 * 可以在这里对请求处理后的结果进行一些补充操作，比如向请求属性中添加一些额外的数据，方便视图渲染时使用这些数据来展示更丰富的页面内容，
-    	request.setAttribute("footerMenuList", footerMenuList);
+	 * 在这里主要是从各个业务服务层（通过注入的相关服务实例）获取不同类型的数据（菜单数据、试卷数据、学校数据、广告数据等），然后将这些数据设置到请求属性中，使得视图能够获取并展示这些信息。
-    	
+	 *
-    	// 获取首页专区
+	 * @param request HttpServletRequest对象，通过它可以获取请求相关的信息以及设置请求属性，在这里主要是利用它来设置各种数据到请求属性中，方便后续视图渲染时使用这些数据进行页面展示。
-    	List<MenuEntity> chapterMenuList = iMenuService.findChapterMenus();
+	 * @param response HttpServletResponse对象，一般在这个阶段如果需要根据请求处理结果对响应进行一些调整（比如设置响应头、添加额外的响应信息等）可以操作这个对象，不过当前代码中暂未涉及这方面操作，主要侧重于设置请求属性的操作。
-    	request.setAttribute("chapterMenuList", chapterMenuList);
+	 * @param handler 处理器对象，代表了刚刚执行完的业务处理器（Controller方法等），在这里通常不需要对其进行直接操作，重点在于对请求属性的设置以及和视图渲染相关的数据准备工作。
-    	
+	 * @param modelAndView ModelAndView对象，它是Spring Web MVC中用于传递数据到视图以及指定视图名称等的一个对象，虽然在这里可以通过它来操作视图相关的数据和名称等信息，
-    	// 获取首页历年真题试卷
+	 *                    但当前代码主要是通过设置请求属性的方式来传递数据，所以并没有直接对这个对象进行过多操作，不过在一些其他场景下可以利用它来更灵活地控制视图渲染相关的内容。
-    	List<PaperEntity> historyPaperList = iPaperService.findHistoryPaper();
+	 * @throws Exception 如果在获取数据或者设置请求属性等过程中出现异常（比如数据库查询异常、设置属性时出现类型不匹配等异常情况），会抛出相应的异常，Spring Web MVC框架会根据异常情况进行相应的处理，例如返回错误页面等操作。
-    	request.setAttribute("historyPaperList", historyPaperList);
+	 */
-    	
+	@Override
-    	// 获取首页模拟试卷
+	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
-    	List<PaperEntity> simulationPaperList = iPaperService.findSimulationPaper();
+						   ModelAndView modelAndView) throws Exception {
-    	request.setAttribute("simulationPaperList", simulationPaperList);
+		//请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）
-    	
+
-    	// 获取热门试卷
+		// 调用iMenuService的findMenus方法，从数据库等数据源中查询出需要展示的菜单数据（具体查询逻辑由IMenuService的实现类决定），
-    	List<PaperEntity> hotPaperList = iPaperService.findHotPaper(SystemConstant.BEIJING_AREA_ID);
+		// 将查询到的菜单数据（以List<MenuEntity>形式返回）设置到请求的属性中，属性名为"menuList"，这样在视图（如JSP、Thymeleaf等模板页面）中就可以通过这个属性名获取到菜单数据进行展示，
-    	request.setAttribute("hotPaperList", hotPaperList);
+		// 例如在页面上循环展示菜单列表等操作，方便用户进行页面导航等功能。
-    	
+		List<MenuEntity> result = iMenuService.findMenus();
-    	// 获取首页名校试卷
+		request.setAttribute("menuList", result);
-    	List<SchoolEntity> eliteSchoolPaperList = iSchoolService.findEliteSchoolPaper(SystemConstant.BEIJING_AREA_ID);
+
-    	request.setAttribute("eliteSchoolPaperList", eliteSchoolPaperList);
+		// 调用iMenuService的findAllMenus方法，获取全部的菜单数据（与上面的findMenus方法可能查询条件等有所不同，这里是获取所有菜单信息），
-    	
+		// 将查询到的全部菜单数据以List<MenuEntity>形式设置到请求的属性中，属性名为"allMenuList"，便于在页面上根据不同需求展示全部菜单内容，比如用于管理后台查看所有菜单情况等操作。
-    	// 获取首页名校列表
+		List<MenuEntity> allMenuList = iMenuService.findAllMenus();
-    	List<SchoolEntity> eliteSchoolList = iSchoolService.findEliteSchool();
+		request.setAttribute("allMenuList", allMenuList);
-    	request.setAttribute("eliteSchoolList", eliteSchoolList);
+
-    	
+		// 调用iMenuService的findLeftMenus方法，查询出要展示在页面左侧的菜单数据（通常是用于构建页面左侧导航栏等功能的菜单列表），
-    	// 获取所有广告
+		// 把查询到的左侧菜单数据以List<MenuEntity>形式添加到请求属性中，属性名为"leftMenuList"，使得页面在渲染左侧导航栏时能够获取并展示这些菜单信息，方便用户进行页面操作和导航。
-    	List<AdEntity> adList = iAdService.findAll();
+		List<MenuEntity> leftMenuList = iMenuService.findLeftMenus();
-    	request.setAttribute("adList", adList);
+		request.setAttribute("leftMenuList", leftMenuList);
-    	
+
-    }
+		// 调用iMenuService的findFooterMenus方法，获取要展示在页面底部的菜单数据（用于构建页面底部的菜单部分，比如一些友情链接、版权信息等相关的菜单展示），
-
+		// 将获取到的底部菜单数据以List<MenuEntity>形式设置到请求属性中，属性名为"footerMenuList"，以便页面在渲染底部部分时能够展示这些菜单内容，完善页面的整体布局和功能。
-    @Override
+		List<MenuEntity> footerMenuList = iMenuService.findFooterMenus();
-    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
+		request.setAttribute("footerMenuList", footerMenuList);
-            throws Exception {
+
-    	//在整个请求结束之后被调用，也就是在DispatcherServlet 渲染了对应的视图之后执行（主要是用于进行资源清理工作）
+		// 调用iMenuService的findChapterMenus方法，查询出用于首页专区展示的菜单数据（可能是首页中某个特定区域的菜单，具体功能和展示形式由业务需求决定），
-    }
+		// 将查询到的这些菜单数据以List<MenuEntity>形式添加到请求属性中，属性名为"chapterMenuList"，使得首页在渲染对应专区时能够获取并展示这些菜单信息，丰富首页的展示内容和功能。
+		List<MenuEntity> chapterMenuList = iMenuService.findChapterMenus();
+		request.setAttribute("chapterMenuList", chapterMenuList);
+
+		// 调用iPaperService的findHistoryPaper方法，从数据库等数据源中查询出首页要展示的历年真题试卷数据（具体的查询逻辑根据业务中对历年真题试卷的定义和筛选条件而定），
+		// 将查询到的历年真题试卷数据（以List<PaperEntity>形式返回）设置到请求属性中，属性名为"historyPaperList"，方便首页在展示试卷相关内容时获取并渲染这些真题试卷信息，供用户查看和选择。
+		List<PaperEntity> historyPaperList = iPaperService.findHistoryPaper();
+		request.setAttribute("historyPaperList", historyPaperList);
+
+		// 调用iPaperService的findSimulationPaper方法，获取首页要展示的模拟试卷数据（同样根据业务对模拟试卷的定义和筛选条件进行查询），
+		// 将查询到的模拟试卷数据以List<PaperEntity>形式设置到请求属性中，属性名为"simulationPaperList"，使得首页能够展示模拟试卷相关内容，满足用户查看和练习模拟试卷的需求。
+		List<PaperEntity> simulationPaperList = iPaperService.findSimulationPaper();
+		request.setAttribute("simulationPaperList", simulationPaperList);
+
+		// 调用iPaperService的findHotPaper方法，传入SystemConstant.BEIJING_AREA_ID（可能是表示北京地区的一个常量标识，具体由业务中SystemConstant类定义），
+		// 查询出对应地区（这里是北京地区）的热门试卷数据（根据业务规则确定热门试卷的筛选条件等），将查询到的热门试卷数据以List<PaperEntity>形式设置到请求属性中，属性名为"hotPaperList"，
+		// 方便在页面上展示热门试卷相关内容，吸引用户关注和选择相应的试卷进行练习等操作。
+		List<PaperEntity> hotPaperList = iPaperService.findHotPaper(SystemConstant.BEIJING_AREA_ID);
+		request.setAttribute("hotPaperList", hotPaperList);
+
+		// 调用iSchoolService的findEliteSchoolPaper方法，传入SystemConstant.BEIJING_AREA_ID，查询出北京地区的名校试卷数据（按照业务中对名校试卷的定义和筛选条件进行查询），
+		// 将查询到的名校试卷数据（以List<SchoolEntity>形式返回，这里可能SchoolEntity中包含了名校以及对应的试卷相关信息，具体由业务实体类定义决定）设置到请求属性中，属性名为"eliteSchoolPaperList"，
+		// 以便在首页等页面展示名校试卷相关内容，体现名校特色试卷，供用户查看和选择练习。
+		List<SchoolEntity> eliteSchoolPaperList = iSchoolService.findEliteSchoolPaper(SystemConstant.BEIJING_AREA_ID);
+		request.setAttribute("eliteSchoolPaperList", eliteSchoolPaperList);
+
+		// 调用iSchoolService的findEliteSchool方法，查询出所有的名校列表数据（根据业务中对名校的定义和筛选条件从数据库等数据源获取），
+		// 将查询到的名校列表数据以List<SchoolEntity>形式设置到请求属性中，属性名为"eliteSchoolList"，方便在页面上展示名校相关信息，比如在选择学校的下拉框、名校推荐列表等地方展示这些名校信息。
+		List<SchoolEntity> eliteSchoolList = iSchoolService.findEliteSchool();
+		request.setAttribute("eliteSchoolList", eliteSchoolList);
+
+		// 调用iAdService的findAll方法，获取所有的广告数据（具体的广告数据来源和查询逻辑由IAdService的实现类决定），
+		// 将获取到的广告数据以List<AdEntity>形式设置到请求属性中，属性名为"adList"，使得页面能够展示相应的广告内容，实现广告投放功能，提升业务宣传等效果。
+		List<AdEntity> adList = iAdService.findAll();
+		request.setAttribute("adList", adList);
+
+	}
 
+	/**
+	 * 这个方法是HandlerInterceptor接口中的一个方法，会在整个请求结束之后被调用，也就是在DispatcherServlet渲染了对应的视图之后执行，
+	 * 主要用于进行一些资源清理工作，比如关闭数据库连接、释放一些占用的资源等操作，不过当前代码中并没有具体的资源清理相关逻辑实现，只是保留了这个方法的空实现，
+	 * 如果后续有相关的资源管理需求，可以在这里添加相应的代码来进行资源清理操作，确保系统资源的合理利用和性能优化。
+	 *
+	 * @param request HttpServletRequest对象，虽然在这个阶段请求相关的处理基本都已完成，但通过这个对象可以获取一些请求相关的上下文信息，不过当前代码暂未利用它进行操作，
+	 *                如果有需要根据请求情况进行资源清理等操作时可以考虑使用这个对象获取相关信息辅助操作。
+	 * @param response HttpServletResponse对象，同样在这个阶段响应相关的操作也基本结束了，但如果有针对响应相关的资源清理（比如关闭响应相关的一些流等情况，不过比较少见）可以操作这个对象，
+	 *                当前代码也没有涉及这方面操作，只是保留了这个参数位置。
+	 * @param handler 处理器对象，代表了整个请求处理过程中涉及的业务处理器，在这里通常不需要对其进行直接操作，重点在于资源清理方面的操作，不过当前代码没有具体的清理逻辑实现，所以暂未涉及对这个对象的使用。
+	 * @param ex Exception对象，表示在整个请求处理过程中出现的异常情况，如果在前面的处理阶段（如preHandle、postHandle或者Controller方法执行过程中）出现了异常，会将异常对象传递到这里，
+	 *           可以在这里根据异常情况进行一些额外的处理（比如记录异常日志、进行一些补偿操作等），不过当前代码也没有这方面的具体实现，只是保留了这个参数接收异常情况。
+	 * @throws Exception 如果在进行资源清理或者根据异常情况进行额外处理等操作过程中又出现了新的异常，会再次抛出相应的异常，Spring Web MVC框架会根据最终的异常情况进行相应的处理，例如返回错误页面等操作。
+	 */
+	@Override
+	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
+			throws Exception {
+		//在整个请求结束之后被调用，也就是在DispatcherServlet 渲染了对应的视图之后执行（主要是用于进行资源清理工作）
+	}
 }

tamguo-tms/src/main/java/com/tamguo/web/member/AccountController.java

@@ -34,116 +34,203 @@ import com.tamguo.modules.member.model.MemberEntity;
 import com.tamguo.modules.member.service.IMemberService;
 import com.tamguo.utils.ShiroUtils;
 
+// @Controller注解用于将这个类标记为Spring MVC框架中的一个控制器组件，意味着Spring容器会在启动时扫描到这个类，并将其管理起来，
+// 使得这个类中的方法能够处理对应的HTTP请求，根据请求的映射关系（通过@RequestMapping等注解定义）调用相应的业务逻辑方法，然后返回视图或者数据响应给客户端。
 @Controller
 public class AccountController {
-	
+
+	// 通过@Autowired注解自动注入IMemberService接口的实现类实例，IMemberService用于处理与会员相关的各种业务逻辑，
+	// 比如查询会员信息、更新会员信息、修改会员密码等操作，在这个控制器的多个方法中会调用其相关方法来实现具体的会员业务功能。
 	@Autowired
 	public IMemberService memberService;
+
+	// 通过@Value注解从配置文件（例如application.properties或application.yml等）中获取名为"file.storage.path"的属性值，并注入到fileStoragePath变量中，
+	// 这个属性值通常表示文件存储的路径，在文件上传相关的业务逻辑中会用到，用于确定上传文件在服务器端实际保存的位置。
 	@Value("${file.storage.path}")
 	private String fileStoragePath;
+
+	// 同样使用@Value注解从配置文件中获取名为"domain.name"的属性值，注入到domainName变量中，
+	// 该属性值一般是域名相关的配置，在文件上传成功后返回文件的访问路径等场景中会用到，用于构建完整的文件访问URL，使得客户端能够通过正确的域名访问到上传的文件。
 	@Value("${domain.name}")
 	private String domainName;
+
+	// 通过@Autowired注解注入CacheService实例，CacheService应该是用于与缓存相关的操作（比如操作Redis缓存等），
+	// 在生成头像编号等逻辑中会使用它来对某个缓存键进行自增操作，以此来生成唯一的头像编号，确保头像文件命名的唯一性等情况。
 	@Autowired
 	private CacheService cacheService;
 
+	// 定义一个表示头像编号的无格式字符串常量，这里格式为"00000"，用于在格式化生成头像编号时作为一种占位格式，
+	// 通过结合日期信息以及自增的序号等内容，生成具有特定格式的头像编号，方便对会员头像文件进行命名管理等操作。
 	private static final String AVATOR_NO_FORMAT = "00000";
+
+	// 定义一个头像文件名称的前缀常量，设置为"MTX"，在生成头像文件完整名称时，会将这个前缀添加到前面，再结合日期、自增序号等信息，组成完整的头像文件名，便于识别和管理头像文件。
 	private static final String AVATOR_PREFIX = "MTX";
-	
+
+	// 创建一个Logger对象，用于记录日志信息，通过LoggerFactory获取与当前类对应的Logger实例，
+	// 在代码的关键位置（如文件上传成功或出现异常等情况）可以使用这个Logger记录相应的日志，方便后续查看系统运行情况、排查问题等操作。
 	public Logger logger = LoggerFactory.getLogger(getClass());
 
+	/**
+	 * 处理会员账户页面的GET请求，用于展示会员账户相关信息。
+	 * 通过ModelAndView对象设置要返回的视图名称，并从会话（HttpSession）中获取当前登录会员的信息，再通过memberService查询更详细的会员信息，添加到ModelAndView对象中，
+	 * 最终返回ModelAndView对象，Spring MVC框架会根据视图名称渲染对应的视图页面，并将添加的数据传递给视图进行展示，实现会员账户信息在页面上的呈现。
+	 *
+	 * @param model ModelAndView对象，用于设置视图名称以及向视图传递数据，在这里设置视图名称为"member/account"，表示要返回的是位于"member"目录下的"account"视图页面，
+	 *              同时可以通过其addObject方法向视图传递数据，方便在视图中展示会员相关信息等内容。
+	 * @param session HttpSession对象，用于获取当前用户的会话信息，在这里主要是从会话中获取名为"currMember"的属性值（通常是登录会员的基本信息对象），作为后续查询详细会员信息的依据。
+	 * @return 返回配置好视图名称和会员信息数据的ModelAndView对象，供Spring MVC框架进行视图渲染并展示会员账户页面内容给客户端。
+	 */
 	@RequestMapping(value = "member/account.html", method = RequestMethod.GET)
-	public ModelAndView index(ModelAndView model , HttpSession session){
+	public ModelAndView index(ModelAndView model, HttpSession session) {
 		model.setViewName("member/account");
 		MemberEntity member = (MemberEntity) session.getAttribute("currMember");
-		model.addObject("member" , memberService.findByUid(member.getId()));
+		model.addObject("member", memberService.findByUid(member.getId()));
 		return model;
 	}
-	
+
+	/**
+	 * 处理会员信息更新的POST请求，用于接收前端传来的更新后的会员信息（以JSON格式通过请求体传递，通过@RequestBody注解解析为MemberEntity对象），
+	 * 先设置会员的ID（通过ShiroUtils获取当前登录会员的ID），然后调用memberService的updateMember方法将更新后的会员信息保存到数据库等数据源中，
+	 * 最后返回一个表示成功的Result对象（包含更新后的会员信息）给前端，告知前端会员信息更新成功以及更新后的具体数据情况，方便前端进行相应的提示和后续处理。
+	 *
+	 * @param member MemberEntity对象，通过@RequestBody注解从请求体中解析得到的包含更新后会员信息的对象，其属性值由前端传递过来的JSON数据填充，
+	 *               在方法中会进一步完善其ID属性并传递给服务层进行更新操作。
+	 * @return 返回一个Result对象，通过Result.successResult方法创建，表示会员信息更新成功，并携带更新后的会员信息，供前端根据返回结果进行相应的提示和页面数据更新等操作。
+	 */
 	@RequestMapping(value = "member/account/update.html", method = RequestMethod.POST)
 	@ResponseBody
-	public Result updateMember(@RequestBody MemberEntity member){
+	public Result updateMember(@RequestBody MemberEntity member) {
 		member.setId(ShiroUtils.getMemberId());
 		memberService.updateMember(member);
 		return Result.successResult(member);
 	}
-	
+
+	/**
+	 * 处理会员修改密码页面的GET请求，主要用于设置要返回的视图名称，使得Spring MVC框架能够渲染对应的修改密码页面展示给客户端，
+	 * 在这里只是简单地将视图名称设置为"member/password"，表示返回位于"member"目录下的"password"视图页面，供用户进行密码修改相关的操作。
+	 *
+	 * @param model ModelAndView对象，用于设置视图名称，在这里将视图名称设置为"member/password"，指定要返回的页面视图，方便Spring MVC框架进行后续的视图渲染操作。
+	 * @return 返回配置好视图名称的ModelAndView对象，供Spring MVC框架根据视图名称渲染并展示会员修改密码页面给客户端。
+	 */
 	@RequestMapping(value = "member/password.html", method = RequestMethod.GET)
-	public ModelAndView password(ModelAndView model){
+	public ModelAndView password(ModelAndView model) {
 		model.setViewName("member/password");
 		return model;
 	}
-	
+
+	/**
+	 * 处理会员修改密码的POST请求，接收前端传来的包含新密码等信息的会员对象（以JSON格式通过请求体传递，通过@RequestBody注解解析为MemberEntity对象），
+	 * 先设置会员的ID（通过ShiroUtils获取当前登录会员的ID），然后调用memberService的updatePwd方法进行密码修改相关的业务逻辑处理（比如验证旧密码、更新密码到数据库等操作），
+	 * 最后将memberService方法返回的Result对象直接返回给前端，Result对象中包含了密码修改是否成功等相关信息，供前端根据返回结果进行相应的提示和后续处理。
+	 *
+	 * @param member MemberEntity对象，通过@RequestBody注解从请求体中解析得到的包含会员密码修改相关信息的对象，其属性值由前端传递过来的JSON数据填充，
+	 *               在方法中会完善其ID属性后传递给服务层进行密码修改操作。
+	 * @return 返回memberService.updatePwd方法返回的Result对象，该对象包含了密码修改的结果信息（如是否成功、相关提示信息等），供前端根据结果进行相应的处理，比如提示用户密码修改成功或失败等情况。
+	 */
 	@RequestMapping(value = "member/password/update.html", method = RequestMethod.POST)
 	@ResponseBody
-	public Result updatePwd(@RequestBody MemberEntity member){
+	public Result updatePwd(@RequestBody MemberEntity member) {
 		member.setId(ShiroUtils.getMemberId());
 		return memberService.updatePwd(member);
 	}
-	
+
+	/**
+	 * 处理会员上传文件的POST请求，用于接收前端上传的文件（通过@RequestParam注解指定接收名为"file"的文件参数，类型为MultipartFile），
+	 * 如果文件不为空，则进行文件保存相关的操作，包括创建文件存储目录、生成文件名、将文件流写入到服务器磁盘文件中，成功后返回一个包含文件上传成功信息及文件访问路径等内容的UploaderMessage对象给前端；
+	 * 如果文件为空，则返回一个表示文件为空的错误信息的UploaderMessage对象给前端，告知前端文件上传失败的原因，整个过程通过日志记录关键操作信息以及进行输入输出流的正确关闭等资源管理操作。
+	 *
+	 * @param file MultipartFile类型的文件对象，通过@RequestParam注解从请求中获取前端上传的文件，包含了文件的内容、原始文件名等信息，用于后续的文件保存等操作。
+	 * @param request HttpServletRequest对象，包含了请求相关的所有信息，在这里虽然当前代码没有直接利用它进行过多操作，但在一些扩展场景下（比如获取请求的一些其他参数、上下文信息等）可以使用这个对象，
+	 *                例如根据请求中的某些参数来决定文件存储的一些额外规则等情况（不过当前代码暂未涉及这些）。
+	 * @return 返回一个UploaderMessage对象，根据文件上传的情况（成功或失败以及相应的原因）设置对象的属性，包含了文件上传状态、提示信息、文件访问路径、文件所在域名等内容，供前端根据返回结果进行相应的提示和后续处理，
+	 * 比如在页面上提示用户文件上传成功并展示文件访问链接，或者提示文件上传失败及失败原因等情况。
+	 * @throws IOException 如果在文件流操作（如读取文件流、写入文件到磁盘等过程）中出现I/O异常情况，会抛出该异常，Spring MVC框架会根据异常情况进行相应的处理，例如返回默认的错误页面等操作。
+	 */
 	@RequestMapping(value = "/member/uploadFile.html", method = RequestMethod.POST)
 	@ResponseBody
-	public UploaderMessage uploadFileHandler(@RequestParam("file") MultipartFile file,HttpServletRequest request) throws IOException {
+	public UploaderMessage uploadFileHandler(@RequestParam("file") MultipartFile file, HttpServletRequest request) throws IOException {
 
+		// 判断上传的文件是否为空，如果不为空，说明有文件需要进行上传保存操作，进入后续的文件保存逻辑；如果为空，则直接返回表示文件为空的错误信息的UploaderMessage对象给前端。
 		if (!file.isEmpty()) {
 			InputStream in = null;
 			OutputStream out = null;
-			
+
 			try {
+				// 根据文件存储路径（fileStoragePath）和当前日期（格式化为"yyyyMMdd"）构建文件存储的完整目录路径，例如：fileStoragePath可能是"/data/uploads/"，结合日期后可能就是"/data/uploads/20241215"，
+				// 这样可以按照日期对上传文件进行分类存储，方便管理和查找文件。
 				String path = fileStoragePath + DateUtils.format(new Date(), "yyyyMMdd");
 				File dir = new File(path);
+				// 判断文件存储目录是否存在，如果不存在，则通过mkdirs方法创建多级目录（确保父目录不存在时也能创建成功），保证后续能够将文件保存到正确的目录下。
 				if (!dir.exists()) {
 					dir.mkdirs();
 				}
+
+				// 调用getAvatorNo方法生成一个头像编号（文件名的一部分），结合文件的原始文件名（获取后缀名部分）组成完整的头像文件名，例如生成的头像编号可能是"MTX20241200001"，
+				// 如果原始文件名为"avatar.jpg"，则最终的文件名就是"MTX20241200001.jpg"，以此来保证文件名的唯一性以及便于识别和管理头像文件等情况。
 				String avatorName = this.getAvatorNo() + file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf("."));
+
+				// 获取上传文件的输入流，用于后续读取文件内容并写入到服务器磁盘文件中，准备进行文件内容的复制操作。
 				in = file.getInputStream();
+				// 创建一个指向服务器磁盘文件的输出流，通过构建的文件存储路径和文件名确定要写入的目标文件位置，例如"/data/uploads/20241215/MTX20241200001.jpg"，
+				// 使得后续可以将上传文件的内容通过输出流写入到这个目标文件中，完成文件的保存操作。
 				out = new FileOutputStream(path + "/" + avatorName);
+
+				// 创建一个字节数组作为缓冲区，大小为1024字节，用于在读取文件流和写入文件到磁盘过程中，以一定的缓冲区大小进行数据传输，提高文件读写效率，避免一次性读取或写入大量数据导致内存占用过大等问题。
 				byte[] b = new byte[1024];
 				int len = 0;
+				// 通过循环，不断从输入流中读取数据到缓冲区（每次最多读取缓冲区大小的数据量），直到读取到文件末尾（即read方法返回 -1），
+				// 然后将缓冲区中的数据通过输出流写入到服务器磁盘文件中，实现文件内容的完整复制，完成文件上传保存操作。
 				while ((len = in.read(b)) > 0) {
 					out.write(b, 0, len);
 				}
+
+				// 关闭输出流，释放相关的资源，确保文件写入操作完成后正确关闭流，避免资源泄露等问题，虽然在try-with-resources语句块中可以自动关闭流，但这里按照传统的方式先手动关闭，确保操作的准确性。
 				out.close();
+				// 关闭输入流，同样是为了释放资源，完成文件读取操作后的资源清理工作，保证整个文件上传过程中资源的合理使用和正确管理。
 				in.close();
+
+				// 使用Logger记录文件在服务器端保存的完整位置信息，方便后续查看文件存储情况、排查文件相关问题等操作，例如在出现文件丢失、访问异常等情况时可以通过日志查看文件实际保存的位置是否正确等信息。
 				logger.info("Server File Location=" + path + avatorName);
 
+				// 创建一个UploaderMessage对象，用于封装文件上传成功的相关信息，准备返回给前端告知文件上传成功以及提供文件的访问路径等信息，方便前端进行相应的提示和后续处理。
 				UploaderMessage msg = new UploaderMessage();
 				msg.setStatus(Status.SUCCESS);
 				msg.setStatusMsg("File upload success");
+				// 设置文件的访问路径，通过构建相对路径（以"/files/"开头，结合日期和文件名）的方式，方便前端根据域名（后续通过设置的fileDomain属性告知前端域名信息）来构建完整的文件访问URL，
+				// 例如前端可以根据返回的fileDomain（如"www.example.com"）和filePath（如"/files/20241215/MTX20241200001.jpg"）拼接出完整的文件访问链接"http://www.example.com/files/20241215/MTX20241200001.jpg"。
 				msg.setFilePath("/files/" + DateUtils.format(new Date(), "yyyyMMdd") + "/" + avatorName);
 				msg.setFileDomain(domainName);
 				return msg;
 			} catch (Exception e) {
+				// 如果在文件上传保存过程中出现异常（比如创建目录失败、文件流读写异常等情况），创建一个UploaderMessage对象，设置其状态为表示错误的Status.ERROR，
+				// 并设置错误信息为"File upload file"（这里可能是代码笔误，应该是更具体准确的错误描述会更好，不过当前就是简单设置这个通用的错误提示），然后将这个表示错误信息的对象返回给前端，告知前端文件上传失败及原因。
 				UploaderMessage msg = new UploaderMessage();
 				msg.setStatus(Status.ERROR);
 				msg.setError("File upload file");
 				return msg;
-			} finally {
-				if (out != null) {
-					out.close();
-					out = null;
-				}
 
-				if (in != null) {
+				private String getAvatorNo() {
-					in.close();
+					// 创建一个SimpleDateFormat对象，用于将日期格式化为指定的格式，这里指定的格式是"yyyyMM"，即按照四位年份和两位月份的形式来格式化日期，
-					in = null;
+					// 例如当前日期是2024年12月，格式化后得到的字符串就是"202412"，后续会基于这个格式化后的日期字符串来生成头像编号，以便在一定程度上通过日期来区分不同时间段生成的头像文件等情况。
+					SimpleDateFormat sdf = new SimpleDateFormat("yyyyMM");
+					// 使用创建好的SimpleDateFormat对象对当前日期（通过new Date()获取当前系统时间对应的Date对象）进行格式化操作，得到一个表示当前年月的字符串，
+					// 并将这个格式化后的字符串赋值给format变量，用于后续构建缓存键以及生成头像编号的相关操作，它体现了时间维度上的标识信息，方便对头像文件进行归类和管理等操作。
+					String format = sdf.format(new Date());
+
+					// 创建一个DecimalFormat对象，使用之前定义的常量AVATOR_NO_FORMAT（值为"00000"）作为格式化模式，
+					// 这个DecimalFormat对象主要用于将后续生成的自增序号（数字类型）按照指定的格式进行格式化，例如将数字1格式化为"00001"，保证生成的头像编号在格式上的一致性和规范性，便于识别和管理。
+					DecimalFormat df = new DecimalFormat(AVATOR_NO_FORMAT);
+
+					// 构建一个缓存键（key）字符串，通过将常量AVATOR_PREFIX（值为"MTX"）和前面格式化得到的表示年月的format字符串进行拼接，
+					// 例如拼接后得到的字符串可能是"MTX202412"，这个缓存键会用于在缓存中进行相关操作（这里主要是对其对应的值进行自增操作，用于生成头像编号的序号部分），通过缓存可以方便地在不同请求间对头像编号进行统一管理和递增生成，避免重复等问题。
+					String key = AVATOR_PREFIX + format;
+
+					// 调用cacheService的incr方法，传入前面构建的缓存键（key），这个incr方法应该是用于对缓存中指定键对应的值进行自增操作（假设底层使用的是类似Redis等支持自增操作的缓存实现），
+					// 例如第一次调用时，如果缓存中该键不存在，会初始化为0然后自增为1，后续每次调用都会在之前的值基础上自增1，返回自增后的结果（以Long类型返回），这个结果就作为头像编号中的序号部分，用于区分同一时间段内不同的头像文件。
+					Long incr = cacheService.incr(key);
+
+					// 使用之前创建的DecimalFormat对象（df）对自增后的序号（incr）进行格式化操作，将其格式化为符合要求的字符串形式（按照"00000"的格式进行填充，如数字1会格式化为"00001"等），
+					// 然后将常量AVATOR_PREFIX（"MTX"）与格式化后的序号字符串进行拼接，组成完整的头像编号字符串，例如得到的头像编号可能是"MTX20241200001"，最终返回这个生成的头像编号，供其他方法使用来命名头像文件等操作。
+					String avatorNo = AVATOR_PREFIX + df.format(incr);
+					return avatorNo;
 				}
-			}
-		} else {
-			UploaderMessage msg = new UploaderMessage();
-			msg.setStatus(Status.ERROR);
-			msg.setError("File is empty");
-			return msg;
-		}
-	}
-	
-
-	private String getAvatorNo() {
-		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMM");
-		String format = sdf.format(new Date());
-		DecimalFormat df = new DecimalFormat(AVATOR_NO_FORMAT);
-		String key = AVATOR_PREFIX + format;
-		Long incr = cacheService.incr(key);
-		String avatorNo = AVATOR_PREFIX + df.format(incr);
-		return avatorNo;
-	}
-}

tamguo-tms/src/main/java/com/tamguo/web/member/LoginController.java

@@ -22,94 +22,158 @@ import com.tamguo.common.utils.Result;
 import com.tamguo.common.utils.SystemConstant;
 import com.tamguo.utils.ShiroUtils;
 
+// @Controller注解用于将这个类标记为Spring MVC框架中的一个控制器组件，意味着Spring容器会在启动时扫描到这个类，并将其管理起来，
+// 使得这个类中的方法能够处理对应的HTTP请求，根据请求的映射关系（通过@RequestMapping等注解定义）调用相应的业务逻辑方法，然后返回视图或者数据响应给客户端，
+// 在这里主要用于处理与用户登录相关的各种请求，如生成验证码、登录验证、判断登录状态等操作。
 @Controller
 public class LoginController {
 
+	/**
+	 * 处理生成验证码图片的请求，请求路径为"captcha.jpg"，当客户端访问这个路径时，会生成一张验证码图片并返回给客户端，同时将验证码的值存储到HttpSession中，
+	 * 以便后续登录等操作时进行验证码的验证对比。通过设置响应头信息来控制缓存相关行为，确保每次请求都能获取到新的验证码图片，并且设置响应的内容类型为"image/jpeg"，表示返回的是JPEG格式的图片数据。
+	 *
+	 * @param response HttpServletResponse对象，用于设置响应的相关信息，如响应头、响应内容类型以及输出验证码图片的流等操作，通过它向客户端返回验证码图片以及控制响应的一些属性。
+	 * @param session HttpSession对象，用于在服务器端存储验证码的值，通过将生成的验证码字符串以特定的键（SystemConstant.KAPTCHA_SESSION_KEY）存储到会话中，方便后续在登录验证等过程中获取并对比验证码是否正确。
+	 * @throws ServletException 如果在处理Servlet相关逻辑（比如生成验证码图片过程中涉及到Servlet规范相关的操作出现问题）时出现异常，会抛出该异常，通常需要在调用该方法的上层进行相应的异常处理，比如返回错误页面等操作。
+	 * @throws IOException 如果在向响应输出流写入验证码图片数据或者操作与输入输出流相关的其他环节出现I/O异常情况，会抛出该异常，同样需要在合适的地方进行异常处理，确保系统的稳定性和友好的错误提示给客户端。
+	 */
 	@RequestMapping("captcha.jpg")
-	public void captcha(HttpServletResponse response , HttpSession session) throws ServletException, IOException {
+	public void captcha(HttpServletResponse response, HttpSession session) throws ServletException, IOException {
+		// 设置响应头的"Cache-Control"字段，值为"no-store, no-cache"，表示禁止浏览器缓存响应内容，这样每次客户端请求这个验证码图片时，都会获取到新生成的验证码图片，
+		// 避免因缓存导致验证码重复使用等安全问题，确保验证码的时效性和安全性。
 		response.setHeader("Cache-Control", "no-store, no-cache");
+		// 设置响应的内容类型为"image/jpeg"，告知客户端返回的数据是JPEG格式的图片，使得客户端能够正确识别并展示接收到的验证码图片内容。
 		response.setContentType("image/jpeg");
-		
+
+		// 调用CaptchaUtils工具类的generateCaptcha方法，传入响应的输出流（response.getOutputStream()），用于生成验证码图片并将图片数据写入到输出流中，返回生成的验证码字符串，
+		// 这个方法内部可能使用了一些图形处理库等实现了验证码图片的生成以及将验证码文本以图片形式输出到流中的功能，具体实现取决于CaptchaUtils类的代码逻辑。
 		String a = CaptchaUtils.generateCaptcha(response.getOutputStream());
+		// 将生成的验证码字符串存储到HttpSession中，使用SystemConstant.KAPTCHA_SESSION_KEY作为键，方便后续在登录验证等操作中从会话中获取该验证码字符串进行对比验证，确保用户输入的验证码是否正确。
 		session.setAttribute(SystemConstant.KAPTCHA_SESSION_KEY, a);
 	}
-	
+
+	/**
+	 * 处理登录页面的GET请求，主要用于设置要返回的视图名称以及向视图传递一些初始化的数据，使得Spring MVC框架能够渲染对应的登录页面展示给客户端，
+	 * 在这里将视图名称设置为"login"，表示返回名为"login"的视图页面，同时向视图添加一个名为"isVerifyCode"的属性，值为"0"，具体含义可能根据前端页面的逻辑来决定，
+	 * 也许是用于前端判断是否需要显示验证码输入框等相关的页面逻辑控制情况。
+	 *
+	 * @param model ModelAndView对象，用于设置视图名称以及向视图传递数据，在这里设置视图名称为"login"，并添加了一个名为"isVerifyCode"的属性及对应的值，方便前端页面进行相应的展示和逻辑处理。
+	 * @return 返回配置好视图名称和相关属性数据的ModelAndView对象，供Spring MVC框架根据视图名称渲染并展示登录页面给客户端，同时将数据传递给视图进行相应的页面逻辑处理。
+	 */
 	@RequestMapping(value = "/login.html", method = RequestMethod.GET)
-	public ModelAndView login(ModelAndView model){
+	public ModelAndView login(ModelAndView model) {
 		model.setViewName("login");
-		model.addObject("isVerifyCode" , "0");
+		model.addObject("isVerifyCode", "0");
 		return model;
 	}
-	
+
+	/**
+	 * 处理用户提交登录信息的POST请求，用于验证用户输入的登录信息（用户名、密码、验证码）是否正确，根据验证结果进行不同的处理，
+	 * 如果验证码错误或者用户不存在、密码错误、账号被锁定等情况，会设置相应的错误提示信息到Result对象中，并返回登录页面展示错误提示给用户；
+	 * 如果登录验证通过，则将登录用户的相关信息存储到HttpSession中，并进行重定向到会员相关的首页等操作，整个过程通过Shiro框架进行用户认证相关的操作，结合自定义的Result对象来封装和返回验证结果信息。
+	 *
+	 * @param username 用户名，从请求参数中获取用户输入的用户名信息，用于后续在Shiro认证以及数据库验证等环节判断用户是否存在以及密码是否匹配等操作。
+	 * @param password 密码，同样从请求参数中获取用户输入的密码信息，作为登录验证的关键信息之一，传递给Shiro框架进行密码验证等相关操作。
+	 * @param verifyCode 验证码，从请求参数中获取用户输入的验证码信息，用于与之前生成并存储在HttpSession中的验证码进行对比验证，确保用户输入的验证码是正确的。
+	 * @param model ModelAndView对象，用于根据验证结果设置要返回的视图名称以及向视图传递相关的提示信息等数据，方便在登录页面展示相应的提示内容给用户，告知登录验证的结果情况（成功或失败以及失败原因等）。
+	 * @param session HttpSession对象，用于获取之前存储的验证码以及在登录成功后存储登录用户的相关信息（如将会员对象存储到"currMember"属性下），方便后续在其他请求处理中获取当前登录用户的信息进行相关业务操作。
+	 * @param response HttpServletResponse对象，在登录验证通过后，用于进行重定向操作，将用户重定向到会员相关的首页（如"member/index.html"），实现登录成功后的页面跳转功能。
+	 * @return 返回配置好视图名称和相关提示信息数据的ModelAndView对象，供Spring MVC框架根据视图名称渲染并展示登录页面给客户端，展示相应的提示内容给用户，或者在登录成功时直接返回null（因为已经进行了重定向操作）。
+	 * @throws IOException 如果在重定向操作（通过response.sendRedirect方法）过程中出现I/O异常情况，比如网络问题导致无法发送重定向响应等，会抛出该异常，需要在合适的地方进行异常处理，确保系统的稳定性和友好的错误提示给客户端。
+	 */
 	@RequestMapping(value = "/submitLogin.html", method = RequestMethod.POST)
-	public ModelAndView submitLogin(String  username , String password , String verifyCode , ModelAndView model , HttpSession session , HttpServletResponse response) throws IOException{
+	public ModelAndView submitLogin(String username, String password, String verifyCode, ModelAndView model, HttpSession session, HttpServletResponse response) throws IOException {
+		// 创建一个表示成功的Result对象，初始化为成功状态（这里虽然初始化为成功状态，但后续会根据实际验证情况进行修改），用于封装登录验证的结果信息，方便返回给前端展示相应的提示内容，
+		// 一开始假设登录验证是成功的，后续根据具体的验证逻辑来更新这个Result对象的状态、提示信息等属性。
 		Result result = Result.successResult(null);
-		if(StringUtils.isEmpty(verifyCode)) {
+
+		// 判断用户输入的验证码是否为空，如果为空，则表示用户没有输入验证码，设置Result对象的状态码、提示信息等属性，
+		// 表示验证失败，提示用户需要输入验证码，然后将这个包含错误提示信息的Result对象相关信息设置到ModelAndView中，最终返回登录页面展示错误提示给用户。
+		if (StringUtils.isEmpty(verifyCode)) {
 			result = Result.result(202, null, "请输入验证码");
-		} else if(StringUtils.isNotEmpty(verifyCode)){
+		} else if (StringUtils.isNotEmpty(verifyCode)) {
+			// 如果用户输入的验证码不为空，则从HttpSession中获取之前生成并存储的验证码字符串（通过SystemConstant.KAPTCHA_SESSION_KEY作为键获取），
+			// 然后将获取到的验证码字符串与用户输入的验证码进行不区分大小写的对比验证，判断验证码是否正确。
 			String kaptcha = session.getAttribute(SystemConstant.KAPTCHA_SESSION_KEY).toString();
 			if (!verifyCode.equalsIgnoreCase(kaptcha)) {
 				result = Result.result(205, null, "验证码错误");
 			} else {
+				// 如果验证码验证通过，通过ShiroUtils工具类获取当前的Subject对象，在Shiro框架中，Subject代表了当前与系统进行交互的“主体”，通常就是指当前登录的用户或者一个匿名的访问者（未登录时），
+				// 获取到Subject对象后，用于后续进行用户认证相关的操作，比如传递用户名和密码进行登录验证等操作。
 				Subject subject = ShiroUtils.getSubject();
+				// 创建一个UsernamePasswordToken对象，用于传递用户名和密码信息给Shiro框架进行认证操作，将用户输入的用户名和密码作为参数传入构造方法，
+				// 这个对象会作为参数传递给Subject的login方法，触发Shiro框架的认证流程，去验证用户名和密码是否匹配以及用户是否合法等情况。
 				UsernamePasswordToken token = new UsernamePasswordToken(username, password);
 				try {
+					// 调用Subject的login方法，传入前面创建的UsernamePasswordToken对象，触发Shiro框架的用户认证流程，
+					// 如果认证成功（即用户名和密码正确，且用户状态正常等情况），则继续执行后续的操作；如果认证失败，会抛出相应的异常（如UnknownAccountException、IncorrectCredentialsException等），进入对应的catch块进行相应的错误处理。
 					subject.login(token);
-					
+
+					// 如果登录认证通过，通过ShiroUtils工具类获取当前登录用户对应的MemberEntity对象（假设认证时将MemberEntity类型的用户对象设置为了Principal），
+					// 然后将这个会员对象存储到HttpSession的"currMember"属性下，方便后续在其他请求处理中获取当前登录用户的信息进行相关业务操作，例如在页面上展示用户相关信息等情况。
 					session.setAttribute("currMember", ShiroUtils.getMember());
+					// 使用HttpServletResponse进行重定向操作，将用户重定向到会员相关的首页（这里是"member/index.html"），实现登录成功后的页面跳转，使得用户登录后能够进入到对应的会员页面进行操作，
+					// 重定向后方法直接返回null，因为已经完成了页面跳转操作，不需要再返回ModelAndView对象让Spring MVC进行视图渲染了（后续的请求会根据新的页面路径重新进行相应的请求处理）。
 					response.sendRedirect("member/index.html");
 					return null;
 				} catch (UnknownAccountException e) {
+					// 如果在Shiro认证过程中抛出UnknownAccountException异常，说明用户名不存在或者没有找到对应的用户信息，设置Result对象的状态码、提示信息等属性，
+					// 表示验证失败，提示用户用户名或密码有误，让用户重新输入或找回密码，然后将这个包含错误提示信息的Result对象相关信息设置到ModelAndView中，最终返回登录页面展示错误提示给用户。
 					result = Result.result(201, null, "用户名或密码有误，请重新输入或找回密码");
 				} catch (IncorrectCredentialsException e) {
+					// 如果抛出IncorrectCredentialsException异常，意味着密码不正确，同样设置Result对象的相应属性，提示用户用户名或密码有误，让用户重新输入或找回密码，
+					// 并将包含错误提示信息的Result对象信息设置到ModelAndView中，返回登录页面展示错误提示给用户。
 					result = Result.result(202, null, "用户名或密码有误，请重新输入或找回密码");
 				} catch (LockedAccountException e) {
+					// 如果出现LockedAccountException异常，表示用户账号被锁定了，设置Result对象的属性，提示用户账号被锁定的错误信息，
+					// 再将包含该提示信息的Result对象相关内容设置到ModelAndView中，返回登录页面展示错误提示给用户。
 					result = Result.result(203, null, "账号被锁定");
-				} 
+				}
 			}
-		} 
+		}
-		model.setViewName("login");	
+
+		// 如果登录验证没有通过（由于验证码错误、用户名或密码错误、账号被锁定等原因），设置ModelAndView的视图名称为"login"，表示返回登录页面展示错误提示信息给用户，
+		// 然后将Result对象中的状态码、提示信息以及用户输入的用户名等信息添加到ModelAndView对象中，方便在登录页面上展示相应的提示内容以及回显用户输入的用户名等情况，方便用户重新输入登录信息进行再次尝试。
+		model.setViewName("login");
 		model.addObject("code", result.getCode());
-		model.addObject("msg" , result.getMessage());
+		model.addObject("msg", result.getMessage());
 		model.addObject("username", username);
 		return model;
 	}
-	
-	@RequestMapping(value = "/miniLogin.html", method = RequestMethod.GET)
-	@ResponseBody
-    public Result miniLogin(String username , String password , String captcha, ModelAndView model , HttpSession session) {
-		Result result = null;
-		if(StringUtils.isEmpty(captcha)) {
-			result = Result.result(204, null, "请输入验证码");
-		} else if(StringUtils.isNotEmpty(captcha)){
-			String kaptcha = session.getAttribute(SystemConstant.KAPTCHA_SESSION_KEY).toString();
-			if (!captcha.equalsIgnoreCase(kaptcha)) {
-				result = Result.result(205, null, "验证码错误");
-			}else {
-				Subject subject = ShiroUtils.getSubject();
-				UsernamePasswordToken token = new UsernamePasswordToken(username, password);
-				try {
-					subject.login(token);
-					session.setAttribute("currMember", ShiroUtils.getMember());
-					result = Result.successResult(ShiroUtils.getMember());
-				} catch (UnknownAccountException e) {
-					result = Result.result(201, null, "用户名或密码有误，请重新输入或找回密码");
-				} catch (IncorrectCredentialsException e) {
-					result = Result.result(202, null, "用户名或密码有误，请重新输入或找回密码");
-				} catch (LockedAccountException e) {
-					result = Result.result(203, null, "账号被锁定");
-				} 
-			}
-		}
-		return result;
-    }
 
+	/**
+	 * 处理一种可能的小型登录（也许是用于移动端或者特定场景下的登录方式，具体根据业务而定）的GET请求，与submitLogin方法类似，也是用于验证用户输入的登录信息（用户名、密码、验证码）是否正确，
+	 * 根据验证结果封装成Result对象返回给前端，不同之处在于这个方法通过@ResponseBody注解直接将Result对象转换为JSON格式返回给前端（用于前端通过Ajax等方式进行异步请求登录验证的场景），
+	 * 而不是像submitLogin方法那样返回视图相关的ModelAndView对象进行页面渲染展示提示信息，整体的验证逻辑（如验证码验证、Shiro认证以及不同异常情况的处理等）基本是一致的。
+	 *
+	 * @param username 用户名，从请求参数中获取用户输入的用户名信息，用于后续在Shiro认证以及数据库验证等环节判断用户是否存在以及密码是否匹配等操作。
+	 * @param password 密码，同样从请求参数中获取用户输入的密码信息，作为登录验证的关键信息之一，传递给Shiro框架进行密码验证等相关操作。
+	 * @param captcha 验证码，从请求参数中获取用户输入的验证码信息，用于与之前生成并存储在HttpSession中的验证码进行对比验证，确保用户输入的验证码是正确的。
+	 * @param model ModelAndView对象，虽然在这个方法中并没有直接对其进行过多操作（因为主要是通过@ResponseBody直接返回数据），但保留了这个参数，在一些可能的扩展场景下可以利用它来进行视图相关的操作（不过当前代码暂未涉及）。
+	 * @param session HttpSession对象，用于获取之前存储的验证码以及在登录成功后存储登录用户的相关信息（如将会员对象存储到"currMember"属性下），方便后续在其他请求处理中获取当前登录用户的信息进行相关业务操作。
+	 * @return 返回一个Result对象，根据登录验证的结果（成功或失败以及不同的失败原因等情况）封装了相应的状态码、提示信息以及登录成功时的用户信息等内容，通过@ResponseBody注解会将这个Result对象转换为JSON格式返回给前端，
+	 * 供前端根据返回结果进行相应的提示和后续处理，比如根据返回的错误提示信息展示给用户，或者在登录成功时获取用户信息进行页面局部刷新等操作。
+	 */
+
+	/**
+	 * 处理判断用户是否登录的GET请求，请求路径为"/isLogin.html"。
+	 * 通过调用ShiroUtils工具类中的isLogin方法来检查当前用户是否处于登录状态，然后根据判断结果返回对应的Result对象给前端，
+	 * 前端可以根据返回的结果（状态码及提示信息）来进行相应的页面展示或逻辑处理，例如根据是否登录来决定显示登录按钮还是用户信息等情况。
+	 *
+	 * @return 返回一个Result对象，若用户已登录，返回的Result对象中状态码为1，提示信息为"已经登录"；若用户未登录，返回的Result对象中状态码为0，提示信息为"未登录"，
+	 * 通过@ResponseBody注解，该Result对象会被转换为合适的格式（如JSON格式等，具体取决于项目中的配置）返回给前端，方便前端进行后续处理。
+	 */
 	@RequestMapping(value = "/isLogin.html", method = RequestMethod.GET)
 	@ResponseBody
 	public Result isLogin() {
-		if(ShiroUtils.isLogin()) {
+		// 调用ShiroUtils工具类的isLogin方法，该方法会检查当前用户对应的Subject对象中的Principal是否为null，
-			return Result.result(1, null , "已经登录");
+		// 如果不为null，则表示用户已经登录（即已通过认证，有对应的用户主体信息存在）；如果为null，则表示当前是匿名访问或者未进行认证操作，用户未登录。
+		if (ShiroUtils.isLogin()) {
+			// 如果用户已登录，调用Result类的result方法创建一个Result对象，传入状态码1、提示信息"已经登录"，表示登录状态为已登录，
+			// 后续这个Result对象会被返回给前端，告知前端用户当前已登录的情况，以便前端进行相应的页面展示或逻辑处理。
+			return Result.result(1, null, "已经登录");
 		}
+		// 如果用户未登录，同样调用Result类的result方法创建一个Result对象，传入状态码0、提示信息"未登录"，表示登录状态为未登录，
+		// 最后将这个表示未登录的Result对象返回给前端，方便前端根据该结果进行相应的处理，比如显示登录按钮引导用户进行登录操作等情况。
 		return Result.result(0, null, "未登录");
 	}
-}

tamguo-tms/src/main/java/com/tamguo/web/member/LogoutController.java

@@ -10,19 +10,38 @@ import org.springframework.web.bind.annotation.RequestMethod;
 
 import com.tamguo.utils.ShiroUtils;
 
+// @Controller注解用于将这个类标记为Spring MVC框架中的一个控制器组件，意味着Spring容器会在启动时扫描到这个类，并将其管理起来，
+// 使得这个类中的方法能够处理对应的HTTP请求，在这里这个控制器主要用于处理用户注销相关的请求操作，实现用户登出的功能。
 @Controller
 public class LogoutController {
 
 	/**
-	 * 注销
+	 * 处理用户注销的GET请求，请求路径为"logout.html"，当用户访问这个路径时，会执行用户注销相关的操作，
+	 * 包括清除存储在HttpSession中的当前会员相关信息（通过移除"currMember"属性），然后调用ShiroUtils工具类的logout方法执行Shiro框架下的用户登出操作，
+	 * 最后进行页面重定向，将用户重定向到网站的根路径（"/"），使得用户注销后回到网站首页等相关页面，完成注销流程以及页面跳转操作。
+	 *
+	 * @param request HttpServletRequest对象，虽然在当前这个方法中没有直接对其进行过多操作，但它包含了客户端发送过来的请求相关的所有信息，
+	 *                在一些扩展场景下（比如根据请求中的某些参数进行额外的注销相关逻辑判断等情况，不过当前代码暂未涉及）可以使用这个对象获取相关信息辅助操作。
+	 * @param response HttpServletResponse对象，用于向客户端发送响应信息，在这里主要用于进行重定向操作，通过设置响应的相关属性，将用户重定向到网站根路径，实现注销后的页面跳转功能。
+	 * @param session HttpSession对象，用于获取和操作当前用户的会话信息，在这里主要是先判断会话中是否存在名为"currMember"的属性（通常存储着当前登录会员的相关信息），
+	 *                如果存在，则将其移除，清除当前会员在会话中的相关数据，然后再配合ShiroUtils进行Shiro框架下的登出操作，完成整个注销过程中与会话相关的清理工作。
+	 * @return 返回一个字符串"redirect:/"，通过Spring MVC的视图解析机制以及响应处理逻辑，这个字符串会被识别为一个重定向的指令，将用户重定向到网站的根路径（通常是网站首页等相关页面），
+	 * 实现用户注销后页面跳转的功能，使得用户回到网站的初始页面或者相应的公共页面等情况，方便用户继续浏览网站或者进行其他操作（如重新登录等）。
 	 */
 	@RequestMapping(value = "logout.html", method = RequestMethod.GET)
 	public String logout(HttpServletRequest request, HttpServletResponse response, HttpSession session) {
-		if (session.getAttribute("currMember") != null) {
+		// 判断HttpSession中是否存在名为"currMember"的属性，通常在用户登录成功后，会将会员相关信息存储在这个属性下，
+		// 如果该属性不为null，说明用户当前处于登录状态，需要进行注销相关的操作，进入下面的注销逻辑处理；如果为null，则可能用户已经处于未登录状态或者其他异常情况，不过当前代码暂不做额外处理，直接返回重定向指令。
+		if (session.getAttribute("currMember")!= null) {
+			// 从HttpSession中移除名为"currMember"的属性，清除存储在会话中的当前会员相关信息，例如清除会员对象本身以及一些基于会员登录状态存储的临时业务数据等，
+			// 完成会话层面上与当前会员相关的数据清理工作，确保注销后会话中不再保留会员相关的痕迹，保障数据的安全性和系统状态的一致性。
 			session.removeAttribute("currMember");
+			// 调用ShiroUtils工具类的logout方法，该方法会通知Shiro框架执行用户登出操作，清除Shiro框架中与当前用户相关的认证状态、会话信息等相关数据，
+			// 例如撤销权限缓存、清除Shiro会话中的相关属性等操作，将用户的登录状态置为未登录，释放与登录相关的资源，确保在Shiro框架层面完成用户的注销流程，保证系统的安全性和稳定性。
 			ShiroUtils.logout();
 		}
+		// 返回"redirect:/"字符串，这个字符串在Spring MVC中会被解析为一个重定向的指令，会使得客户端收到一个重定向响应，跳转到网站的根路径（"/"），
+		// 一般情况下根路径对应的是网站的首页或者其他公共的起始页面，通过这样的重定向操作，让用户在注销后回到相应的页面，方便后续的浏览或者重新登录等操作。
 		return "redirect:/";
 	}
-	
+}
-}

tamguo-tms/src/main/java/com/tamguo/web/member/MemberController.java

@@ -11,22 +11,44 @@ import com.tamguo.common.utils.Result;
 import com.tamguo.modules.member.service.IMemberService;
 import com.tamguo.utils.ShiroUtils;
 
+// @Controller注解用于将这个类标记为Spring MVC框架中的一个控制器组件，意味着Spring容器会在启动时扫描到这个类，并将其管理起来，
+// 使得这个类中的方法能够处理对应的HTTP请求，根据请求的映射关系（通过@RequestMapping等注解定义）调用相应的业务逻辑方法，然后返回视图或者数据响应给客户端，
+// 在这里主要用于处理与会员相关的页面展示及信息查询等操作。
 @Controller
 public class MemberController {
-	
+
+	// 通过@Autowired注解自动注入IMemberService接口的实现类实例，IMemberService用于处理与会员相关的各种业务逻辑，
+	// 比如根据会员ID查询会员详细信息等操作，在这个控制器的多个方法中会调用其相关方法来实现具体的会员业务功能。
 	@Autowired
 	IMemberService iMemberService;
 
+	/**
+	 * 处理会员首页（"/member/index.html"）的GET请求，用于展示会员相关的首页内容。
+	 * 通过ModelAndView对象设置要返回的视图名称，并调用iMemberService的findByUid方法查询当前登录会员的详细信息（通过ShiroUtils获取当前登录会员的ID作为查询依据），
+	 * 将查询到的会员信息添加到ModelAndView对象中，最终返回ModelAndView对象，Spring MVC框架会根据视图名称渲染对应的视图页面，并将添加的数据传递给视图进行展示，实现会员首页相关信息的呈现。
+	 *
+	 * @param model ModelAndView对象，用于设置视图名称以及向视图传递数据，在这里设置视图名称为"member/index"，表示要返回的是位于"member"目录下的"index"视图页面，
+	 *              同时可以通过其addObject方法向视图传递会员相关信息数据，方便在视图中展示会员的详细信息等内容。
+	 * @return 返回配置好视图名称和会员信息数据的ModelAndView对象，供Spring MVC框架进行视图渲染并展示会员首页页面内容给客户端。
+	 */
 	@RequestMapping(value = "/member/index.html", method = RequestMethod.GET)
-	public ModelAndView index(ModelAndView model){
+	public ModelAndView index(ModelAndView model) {
 		model.setViewName("member/index");
-		model.addObject("member" , iMemberService.findByUid(ShiroUtils.getMember().getId()));
+		model.addObject("member", iMemberService.findByUid(ShiroUtils.getMember().getId()));
 		return model;
 	}
-	
+
+	/**
+	 * 处理查询当前会员信息的GET请求，请求路径为"/member/findCurrMember.html"，用于获取当前登录会员的详细信息，并将查询结果封装到Result对象中返回给前端。
+	 * 通过调用iMemberService的findCurrMember方法，传入通过ShiroUtils获取的当前登录会员的ID作为参数，查询当前会员的详细信息，然后使用Result.successResult方法将查询到的会员信息封装到Result对象中，
+	 * 最后通过@ResponseBody注解将Result对象转换为合适的格式（如JSON格式等，具体取决于项目配置）返回给前端，方便前端获取并展示当前会员的详细信息，或者根据返回结果进行相应的后续处理。
+	 *
+	 * @return 返回一个Result对象，通过Result.successResult方法创建，其中包含了通过iMemberService查询到的当前登录会员的详细信息，供前端根据返回结果进行相应的展示和后续处理操作，
+	 * 比如在页面上展示会员的各项信息、根据会员信息进行权限判断等相关业务逻辑处理。
+	 */
 	@RequestMapping(value = "/member/findCurrMember.html", method = RequestMethod.GET)
 	@ResponseBody
 	public Result findCurrMember() {
 		return Result.successResult(iMemberService.findCurrMember(ShiroUtils.getMemberId()));
 	}
-}
+}

tamguo-tms/src/main/java/com/tamguo/web/member/MemberPaperController.java

@@ -21,107 +21,157 @@ import org.springframework.web.servlet.ModelAndView;
 import javax.servlet.http.HttpSession;
 import java.util.Map;
 
+// @Controller注解用于将这个类标记为Spring MVC框架中的一个控制器组件，意味着Spring容器会在启动时扫描到这个类，并将其管理起来，
+// 使得这个类中的方法能够处理对应的HTTP请求，根据请求的映射关系（通过@RequestMapping等注解定义）调用相应的业务逻辑方法，然后返回视图或者数据响应给客户端，
+// 在这里主要用于处理会员相关试卷的各种操作，如试卷列表展示、试卷信息查询、试卷及试卷题目信息的增删改等业务功能。
 @Controller
 public class MemberPaperController {
-	
+
+	// 通过@Autowired注解自动注入IPaperService接口的实现类实例，IPaperService用于处理与试卷相关的各种业务逻辑，
+	// 比如查询试卷信息、添加试卷、修改试卷、删除试卷以及处理试卷题目相关信息等操作，在这个控制器的各个方法中会调用其相关方法来实现具体的试卷业务功能。
 	@Autowired
 	private IPaperService iPaperService;
-	
 
+	/**
+	 * 处理会员试卷页面（"/member/paper.html"）的GET请求，主要用于设置要返回的视图名称，使得Spring MVC框架能够渲染对应的试卷列表页面展示给客户端，
+	 * 在这里将视图名称设置为"member/paperList"，表示返回位于"member"目录下的"paperList"视图页面，供用户查看试卷相关信息等操作，该方法只是简单地进行视图名称的设置，暂未涉及其他复杂的数据传递等操作。
+	 *
+	 * @param model ModelAndView对象，用于设置视图名称，在这里将视图名称设置为"member/paperList"，指定要返回的页面视图，方便Spring MVC框架进行后续的视图渲染操作。
+	 * @return 返回配置好视图名称的ModelAndView对象，供Spring MVC框架根据视图名称渲染并展示会员试卷列表页面给客户端。
+	 */
 	@RequestMapping(value = "/member/paper.html", method = RequestMethod.GET)
-	public ModelAndView paper(ModelAndView model){
+	public ModelAndView paper(ModelAndView model) {
 		model.setViewName("member/paperList");
 		return model;
 	}
-	
+
+	/**
+	 * 处理查询单个试卷信息的GET请求，根据传入的试卷ID（paperId）查询对应的试卷详细信息，并将查询结果封装到Result对象中返回给前端。
+	 * 通过调用iPaperService的selectById方法，传入试卷ID作为参数，从数据库等数据源中获取对应的试卷实体对象信息，然后使用Result.successResult方法将查询到的试卷信息封装到Result对象中，
+	 * 最后通过@ResponseBody注解将Result对象转换为合适的格式（如JSON格式等，具体取决于项目配置）返回给前端，方便前端获取并展示该试卷的详细信息，或者根据返回结果进行相应的后续处理（如在页面上展示试卷详情等操作）。
+	 *
+	 * @param paperId 试卷的唯一标识字符串，从请求参数中获取，用于指定要查询的试卷对象，传递给iPaperService的selectById方法作为查询依据，获取对应的试卷详细信息。
+	 * @return 返回一个Result对象，通过Result.successResult方法创建，其中包含了通过iPaperService查询到的指定试卷ID对应的试卷详细信息，供前端根据返回结果进行相应的展示和后续处理操作。
+	 */
 	@RequestMapping(value = "/member/findPaper.html", method = RequestMethod.GET)
 	@ResponseBody
 	public Result findPaper(String paperId) {
 		return Result.successResult(iPaperService.selectById(paperId));
 	}
-	
+
-	@SuppressWarnings({ "unchecked"})
+	/**
-	@RequestMapping(value = "member/paper/list.html" , method = RequestMethod.GET)
+	 * 处理获取会员试卷列表的GET请求，根据传入的筛选条件（试卷名称、页码、每页数量等）查询符合条件的试卷列表信息，并将查询结果按照特定格式封装到Map中返回给前端，
+	 * 用于在页面上展示试卷列表数据，支持分页功能，通过从HttpSession中获取当前登录会员的信息，作为查询条件之一（筛选出当前会员创建的试卷）来获取相应的试卷列表。
+	 *
+	 * @param name 试卷名称，作为筛选条件的一部分，用于模糊查询包含该名称的试卷（通过MyBatis Plus的Condition进行like查询），从请求参数中获取，传递给查询条件构建逻辑，查找匹配的试卷信息。
+	 * @param page 当前页码，从请求参数中获取，用于指定要查询的页码信息，传递给Page对象来确定查询的分页情况，获取对应页码的数据记录，方便实现分页展示试卷列表的功能。
+	 * @param limit 每页显示的记录数量，从请求参数中获取，同样传递给Page对象来设置每页显示的试卷数量，结合page参数实现分页查询和展示试卷列表的功能。
+	 * @param session HttpSession对象，用于获取当前登录会员的信息，通过从会话中获取名为"currMember"的属性（通常是MemberEntity类型的会员对象），获取会员的ID作为查询条件之一，
+	 *                构建查询条件，筛选出当前会员创建的试卷列表信息，确保返回的试卷列表是与当前登录会员相关的试卷数据。
+	 * @return 返回一个Map<String, Object>类型的结果，其中包含了符合条件的试卷列表数据（通过Result.jqGridResult方法按照特定格式封装了试卷记录、总记录数、每页记录数、当前页码、总页数等信息），
+	 * 供前端根据这个Map中的数据进行试卷列表的展示以及分页相关的操作处理，例如在页面上循环展示试卷列表信息，并根据总页数等信息实现分页导航等功能。
+	 */
+	@SuppressWarnings({ "unchecked" })
+	@RequestMapping(value = "member/paper/list.html", method = RequestMethod.GET)
 	@ResponseBody
-	public Map<String, Object> paperList(String name , Integer page , Integer limit , HttpSession session){
+	public Map<String, Object> paperList(String name, Integer page, Integer limit, HttpSession session) {
-		MemberEntity member = ((MemberEntity)session.getAttribute("currMember"));
+		// 从HttpSession中获取当前登录会员的信息，通过将名为"currMember"的属性强制转换为MemberEntity类型获取会员对象，用于后续获取会员ID作为查询条件，
-		Page<PaperEntity> list = iPaperService.selectPage(new Page<PaperEntity>(page , limit) , Condition.create().like("name", name).eq("creater_id", member.getId()));
+		// 筛选出当前会员创建的试卷列表信息，确保数据的关联性和权限控制（只展示当前会员创建的试卷）。
+		MemberEntity member = ((MemberEntity) session.getAttribute("currMember"));
+		// 创建一个Page对象，用于进行分页查询操作，传入当前页码（page）和每页显示的记录数量（limit）作为分页参数，指定要查询的分页情况，
+		// 同时通过Condition.create().like("name", name).eq("creater_id", member.getId())构建查询条件，使用MyBatis Plus的条件构造器，
+		// like("name", name)表示按照试卷名称进行模糊查询，包含传入的name参数值的试卷；eq("creater_id", member.getId())表示筛选出创建者ID等于当前会员ID的试卷，
+		// 最终通过iPaperService的selectPage方法进行分页查询，获取符合条件的试卷列表信息（以Page<PaperEntity>形式返回，包含了分页相关的数据以及试卷记录列表等内容）。
+		Page<PaperEntity> list = iPaperService.selectPage(new Page<PaperEntity>(page, limit),
+				Condition.create().like("name", name).eq("creater_id", member.getId()));
+		// 使用Result.jqGridResult方法将分页查询得到的试卷列表相关信息（试卷记录、总记录数、每页记录数、当前页码、总页数等）按照特定格式封装到一个Map中返回给前端，
+		// 方便前端根据这个Map中的数据进行试卷列表的展示以及分页相关的操作处理，例如在页面上循环展示试卷列表信息，并根据总页数等信息实现分页导航等功能。
 		return Result.jqGridResult(list.getRecords(), list.getTotal(), limit, page, list.getPages());
 	}
-	
+
-	@RequestMapping(value="member/paperList/addPaperQuestionInfo.html",method=RequestMethod.POST)
+	/**
+	 * 处理添加试卷题目信息的POST请求，接收前端传来的包含试卷题目相关信息的JSON数据（通过@RequestBody注解解析为JSONObject对象），
+	 * 从JSON数据中提取出关键信息（试卷ID、题目标题、题目类型等），根据题目类型获取对应的描述信息，然后调用iPaperService的addPaperQuestionInfo方法将题目信息添加到对应的试卷中，
+	 * 如果操作成功，返回表示成功的Result对象；如果出现异常，通过ExceptionSupport工具类处理异常并返回相应的包含错误信息的Result对象给前端，告知前端添加操作的结果情况。
+	 *
+	 * @param data JSONObject对象，通过@RequestBody注解从请求体中解析得到的包含试卷题目相关信息的JSON数据对象，其包含了如试卷ID、题目标题、题目类型等关键信息，
+	 *             需要从这个对象中提取出相应的属性值传递给服务层进行添加题目信息的操作。
+	 * @return 返回一个Result对象，如果添加试卷题目信息操作成功，返回的Result对象中状态码为0，提示信息为"修改成功"（这里可能表述不太准确，应该是"添加成功"更合适，不过按代码原文来注释）；
+	 * 如果在操作过程中出现异常，通过ExceptionSupport工具类的resolverResult方法处理异常并返回相应的包含错误信息的Result对象给前端，供前端根据返回结果进行相应的提示和后续处理操作。
+	 */
+	@RequestMapping(value = "member/paperList/addPaperQuestionInfo.html", method = RequestMethod.POST)
 	@ResponseBody
-	public Result addPaperQuestionInfo(@RequestBody JSONObject data){
+	public Result addPaperQuestionInfo(@RequestBody JSONObject data) {
 		try {
-			String paperId ; String title ; String name ;String type;
+			// 从传入的JSONObject数据中获取试卷ID字符串，用于指定要添加题目信息的目标试卷，该ID对应数据库中试卷表的唯一标识字段，确保题目信息添加到正确的试卷上。
+			String paperId;
+			String title;
+			String name;
+			String type;
 			paperId = data.getString("id");
+			// 获取题目标题字符串，作为题目信息的关键内容之一，传递给服务层用于添加到试卷题目相关的表中，展示题目的具体内容。
 			title = data.getString("title");
+			// 获取题目类型字符串，用于后续根据题目类型获取对应的描述信息以及区分不同类型的题目进行不同的处理逻辑（比如不同类型题目可能在数据库中的存储结构等有所不同）。
 			type = data.getString("type");
+			// 根据获取到的题目类型（type），通过QuestionTypeEnum枚举类的getQuestionType方法获取对应的枚举实例，再调用其getDesc方法获取该类型题目的描述信息，
+			// 例如将题目类型代码转换为对应的中文描述等情况，方便在试卷题目展示等方面提供更友好的信息，然后将这个描述信息赋值给name变量，用于后续添加题目信息操作中传递给服务层。
 			name = QuestionTypeEnum.getQuestionType(type).getDesc();
-			iPaperService.addPaperQuestionInfo(paperId , title , name , type);
+			// 调用iPaperService的addPaperQuestionInfo方法，传入试卷ID、题目标题、题目描述信息、题目类型等参数，将题目信息添加到对应的试卷中，实现添加试卷题目信息的业务逻辑操作。
+			iPaperService.addPaperQuestionInfo(paperId, title, name, type);
 			return Result.result(0, null, "修改成功");
 		} catch (Exception e) {
+			// 如果在添加试卷题目信息过程中出现异常，通过ExceptionSupport工具类的resolverResult方法处理异常，传入操作名称（"添加questionInfo"，用于在异常信息中标识是哪个操作出现了问题）、
+			// 当前类的Class对象（用于定位异常出现的位置等信息）以及捕获到的异常对象（e），该方法会根据异常情况生成一个包含相应错误信息的Result对象返回给前端，告知前端添加操作失败及失败原因等情况，方便前端进行相应的提示和后续处理操作。
 			return ExceptionSupport.resolverResult("添加questionInfo", this.getClass(), e);
 		}
 	}
-	
+
+	/**
+	 * 处理修改试卷题目信息的POST请求，与addPaperQuestionInfo方法类似，接收前端传来的包含试卷题目修改相关信息的JSON数据（通过@RequestBody注解解析为JSONObject对象），
+	 * 从中提取关键信息（试卷ID、题目标题、题目类型、题目信息的唯一标识等），根据题目类型获取描述信息，然后调用iPaperService的updatePaperQuestionInfo方法更新对应的试卷题目信息，
+	 * 如果操作成功，返回表示成功的Result对象；若出现异常，借助ExceptionSupport工具类处理异常并返回相应的包含错误信息的Result对象给前端，告知前端修改操作的结果情况。
+	 *
+	 * @param data JSONObject对象，通过@RequestBody注解从请求体中解析得到的包含试卷题目修改相关信息的JSON数据对象，包含了如试卷ID、题目标题、题目类型、题目信息唯一标识等关键信息，
+	 *             从中提取相应的值传递给服务层进行题目信息更新操作。
+	 * @return 返回一个Result对象，若修改试卷题目信息操作成功，返回的Result对象中状态码为0，提示信息为"修改成功"；
+	 * 如果在操作过程中出现异常，通过ExceptionSupport工具类的resolverResult方法处理异常并返回相应的包含错误信息的Result对象给前端，供前端根据返回结果进行相应的提示和后续处理操作。
+	 */
 	@RequestMapping("member/paperList/updatePaperQuestionInfo.html")
 	@ResponseBody
-	public Result updatePaperQuestionInfo(@RequestBody JSONObject data){
+	public Result updatePaperQuestionInfo(@RequestBody JSONObject data) {
 		try {
-			String paperId ; String title ; String name ; String type ; String uid;
+			// 从传入的JSONObject数据中获取试卷ID字符串，用于指定要修改题目信息的目标试卷，确保更新操作作用在正确的试卷对应的题目上。
+			String paperId;
+			String title;
+			String name;
+			String type;
+			String uid;
 			paperId = data.getString("uid");
+			// 获取题目标题字符串，作为要修改的题目关键内容之一，传递给服务层用于更新数据库中对应的题目记录的标题字段等内容。
 			title = data.getString("title");
+			// 获取题目类型字符串，用于后续根据题目类型获取对应的描述信息以及按照不同类型题目进行相应的更新逻辑处理（比如不同类型题目可能更新的字段等有所不同）。
 			type = data.getString("type");
+			// 根据获取到的题目类型（type），通过QuestionTypeEnum枚举类的getQuestionType方法获取对应的枚举实例，再调用其getDesc方法获取该类型题目的描述信息，
+			// 以便在更新题目信息时使用更友好的描述内容替换原有的信息等情况，然后将这个描述信息赋值给name变量，传递给服务层进行更新操作。
 			name = QuestionTypeEnum.getQuestionType(type).getDesc();
+			// 获取题目信息的唯一标识字符串（可能用于在数据库中精准定位要更新的具体题目记录，比如是数据库表中的主键等唯一标识字段），传递给服务层在更新操作中确定具体要修改的题目记录。
 			uid = data.getString("infoUid");
-			iPaperService.updatePaperQuestionInfo(paperId , title , name , type , uid);
+			// 调用iPaperService的updatePaperQuestionInfo方法，传入试卷ID、题目标题、题目描述信息、题目类型、题目信息唯一标识等参数，更新对应的试卷题目信息，实现修改试卷题目信息的业务逻辑操作。
+			iPaperService.updatePaperQuestionInfo(paperId, title, name, type, uid);
 			return Result.result(0, null, "修改成功");
 		} catch (Exception e) {
+			// 如果在修改试卷题目信息过程中出现异常，通过ExceptionSupport工具类的resolverResult方法处理异常，传入操作名称（"修改questionInfo"，用于在异常信息中标识是哪个操作出现了问题）、
+			// 当前类的Class对象（用于定位异常出现的位置等信息）以及捕获到的异常对象（e），该方法会根据异常情况生成一个包含相应错误信息的Result对象返回给前端，告知前端修改操作失败及失败原因等情况，方便前端进行相应的提示和后续处理操作。
 			return ExceptionSupport.resolverResult("修改questionInfo", this.getClass(), e);
 		}
 	}
-	
+
-	@RequestMapping("member/paperList/deletePaper")
+	/**
-	@ResponseBody
+	 * 处理删除试卷的请求，根据传入的试卷ID（paperId）以及当前登录会员的ID（通过ShiroUtils获取）调用iPaperService的deletePaper方法来删除对应的试卷信息，
-	public Result deletePaper(String paperId){
+	 * 如果操作成功，直接返回iPaperService方法返回的Result对象给前端（其中包含了删除操作的结果信息，如是否成功等情况）；若出现异常，通过ExceptionSupport工具类处理异常并返回相应的Result对象给前端，告知前端删除操作的结果情况。
-		try {
+	 *
-			return iPaperService.deletePaper(ShiroUtils.getMemberId() , paperId);
+	 * @param paperId 试卷的唯一标识字符串，从请求参数中获取，用于指定要删除的试卷对象，传递给iPaperService的deletePaper方法作为删除操作的依据，确定要从数据库等数据源中删除的试卷记录。
-		} catch (Exception e) {
+	 * @return 返回一个Result对象，如果删除试卷操作成功，返回的就是iPaperService.deletePaper方法返回的Result对象，其中包含了删除操作是否成功等相关信息；
-			return ExceptionSupport.resolverResult("删除试卷", this.getClass(), e);
+	 * 如果在操作过程中出现异常，通过ExceptionSupport工具类的resolverResult方法处理异常并返回相应的包含错误信息的Result对象给前端，供前端根据返回结果进行相应的提示和后续处理操作。
-		}
+	 */
-	}
+	@RequestMapping("member/paperList/deletePaper
-	
-	@RequestMapping("member/paperList/deletePaperQuestionInfoBtn.html")
-	@ResponseBody
-	public Result deletePaperQuestionInfoBtn(String paperId , String uid){
-		try {
-			return iPaperService.deletePaperQuestionInfoBtn(ShiroUtils.getMemberId() , paperId , uid);
-		} catch (Exception e) {
-			return ExceptionSupport.resolverResult("删除子卷", this.getClass(), e);
-		}
-	}
-	
-	@RequestMapping(value="member/paperList/addPaper.html",method=RequestMethod.POST)
-	@ResponseBody
-	public Result addPaper(@RequestBody PaperEntity paper,HttpSession session){
-		try {
-			MemberEntity member = (MemberEntity) session.getAttribute("currMember");
-			paper.setCreaterId(member.getId());
-			iPaperService.addPaper(paper);
-			return  Result.result(Result.SUCCESS_CODE, paper, "添加成功");
-		} catch (Exception e) {
-			return ExceptionSupport.resolverResult("添加试卷", this.getClass(), e);
-		}
-	}
-	
-	@RequestMapping(value="member/paperList/updatePaper.html",method=RequestMethod.POST)
-	@ResponseBody
-	public Result updatePaper(@RequestBody PaperEntity paper){
-		try {
-			return iPaperService.updatePaper(paper , ShiroUtils.getMemberId());
-		} catch (Exception e) {
-			return ExceptionSupport.resolverResult("修改试卷", this.getClass(), e);
-		}
-	}
-}

tamguo-tms/src/main/java/com/tamguo/web/member/PasswordController.java

@@ -12,70 +12,146 @@ import com.tamguo.common.utils.Result;
 import com.tamguo.common.utils.SystemConstant;
 import com.tamguo.modules.member.service.IMemberService;
 
+// @Controller注解用于将这个类标记为Spring MVC框架中的一个控制器组件，意味着Spring容器会在启动时扫描到这个类，并将其管理起来，
+// 使得这个类中的方法能够处理对应的HTTP请求，根据请求的映射关系（通过@RequestMapping等注解定义）调用相应的业务逻辑方法，然后返回视图或者数据响应给客户端，
+// 在这里主要用于处理与用户密码相关的各种操作，比如密码找回过程中涉及的账户确认、安全验证、密码重置等业务功能对应的页面请求及处理逻辑。
 @Controller
 public class PasswordController {
-	
+
+	// 通过@Autowired注解自动注入IMemberService接口的实现类实例，IMemberService用于处理与会员相关的各种业务逻辑，
+	// 在密码相关操作中，比如确认账户是否存在、进行安全验证、重置密码等操作时，会调用其相关方法来实现具体的业务功能，根据不同的业务逻辑返回相应的Result对象来表示操作结果情况。
 	@Autowired
 	private IMemberService iMemberService;
-	
+
+	/**
+	 * 处理密码找回中确认账户页面（"password/find.html"）的GET请求，主要用于设置要返回的视图名称，使得Spring MVC框架能够渲染对应的确认账户页面展示给客户端，
+	 * 在这里将视图名称设置为"password/confirmAccount"，表示返回位于"password"目录下的"confirmAccount"视图页面，供用户输入账户信息等操作，该方法只是简单地进行视图名称的设置，暂未涉及其他复杂的数据传递等操作。
+	 *
+	 * @param model ModelAndView对象，用于设置视图名称，在这里将视图名称设置为"password/confirmAccount"，指定要返回的页面视图，方便Spring MVC框架进行后续的视图渲染操作。
+	 * @return 返回配置好视图名称的ModelAndView对象，供Spring MVC框架根据视图名称渲染并展示密码找回的确认账户页面给客户端。
+	 */
 	@RequestMapping(value = "password/find.html", method = RequestMethod.GET)
-	public ModelAndView confirmAccount(ModelAndView model){
+	public ModelAndView confirmAccount(ModelAndView model) {
 		model.setViewName("password/confirmAccount");
 		return model;
 	}
-	
+
+	/**
+	 * 处理提交确认账户信息的POST请求，用于验证用户输入的账户（username）和验证码（veritycode）信息是否有效，根据验证结果进行不同的页面跳转和数据传递操作。
+	 * 首先调用iMemberService的confirmAccount方法验证账户信息，然后对比用户输入的验证码与存储在HttpSession中的验证码是否一致，根据这些验证情况设置ModelAndView对象的视图名称以及向其添加相应的数据，
+	 * 最终返回ModelAndView对象，Spring MVC框架会根据视图名称渲染对应的视图页面，并将添加的数据传递给视图进行展示，实现根据验证结果展示不同页面及提示信息给用户的功能。
+	 *
+	 * @param username 用户输入的账户信息（可能是用户名或者邮箱等用于标识用户的信息），从请求参数中获取，传递给iMemberService的confirmAccount方法用于验证账户是否存在以及是否符合相关规则等情况。
+	 * @param veritycode 用户输入的验证码信息，同样从请求参数中获取，一方面用于与服务层验证账户时返回的验证码进行对比（如果服务层有相应验证逻辑），另一方面与存储在HttpSession中的验证码进行对比，确保验证码的正确性。
+	 * @param model ModelAndView对象，用于根据验证结果设置要返回的视图名称以及向视图传递相关的数据，比如验证结果信息、用户输入的账户信息等，方便在不同页面展示相应的提示内容给用户，告知验证的结果情况（成功或失败以及失败原因等）。
+	 * @param session HttpSession对象，用于获取之前存储的验证码（通过SystemConstant.KAPTCHA_SESSION_KEY作为键获取），与用户输入的验证码进行对比验证，确保用户输入的验证码是正确的，保证验证流程的完整性和安全性。
+	 * @return 返回配置好视图名称和相关数据的ModelAndView对象，供Spring MVC框架根据视图名称渲染并展示相应的页面给客户端，展示相应的提示内容给用户，例如在验证成功时跳转到安全验证页面，失败时返回确认账户页面并展示错误提示信息等情况。
+	 */
 	@RequestMapping(value = "password/confirmAccount.html", method = RequestMethod.POST)
-	public ModelAndView submitConfirmAccount(String username , String veritycode , ModelAndView model , HttpSession session){
+	public ModelAndView submitConfirmAccount(String username, String veritycode, ModelAndView model, HttpSession session) {
+		// 调用iMemberService的confirmAccount方法，传入用户输入的用户名和验证码信息，该方法会根据业务逻辑验证账户是否存在、验证码是否匹配等情况（具体验证逻辑由IMemberService的实现类决定），
+		// 返回一个Result对象，其中包含了验证结果的相关信息，如状态码（表示验证是否成功等情况）、提示信息等内容，后续会根据这个Result对象以及验证码的对比情况来进一步处理页面跳转和数据传递等操作。
 		Result result = iMemberService.confirmAccount(username, veritycode);
+
+		// 从HttpSession中获取之前存储的验证码字符串（通过SystemConstant.KAPTCHA_SESSION_KEY作为键获取），将获取到的验证码字符串与用户输入的验证码进行不区分大小写的对比验证，判断验证码是否正确。
 		String kaptcha = session.getAttribute(SystemConstant.KAPTCHA_SESSION_KEY).toString();
 		if (!veritycode.equalsIgnoreCase(kaptcha)) {
+			// 如果验证码对比不一致，说明验证码错误，创建一个Result对象并设置其状态码为202，提示信息为"验证码错误"，表示验证失败，
+			// 后续会根据这个表示验证码错误的Result对象来设置ModelAndView相关信息，最终返回确认账户页面展示错误提示给用户。
 			result = Result.result(202, null, "验证码错误");
 		}
-		if(result.getCode() == 200){
+
+		// 判断Result对象中的状态码是否为200（通常表示验证成功等情况，具体含义由业务中Result类的定义以及服务层返回逻辑决定），
+		// 如果状态码为200，说明账户验证通过（包括验证码也正确等情况），则设置ModelAndView的视图名称为"password/securityCheck"，表示要跳转到密码找回的安全验证页面，
+		// 同时将Result对象以及根据用户名判断是否为邮箱得到的标识信息（"1"表示是邮箱，"0"表示不是邮箱）添加到ModelAndView对象中，方便在安全验证页面展示相应的验证结果以及相关提示信息给用户。
+		if (result.getCode() == 200) {
 			model.setViewName("password/securityCheck");
 			model.addObject("result", result);
-			model.addObject("isEmail", username.contains("@") ? "1" : "0");
+			model.addObject("isEmail", username.contains("@")? "1" : "0");
-		}else{
+		} else {
+			// 如果Result对象的状态码不是200，说明账户验证失败（可能是账户不存在、其他验证规则不满足等原因），设置ModelAndView的视图名称为"password/confirmAccount"，表示返回确认账户页面展示错误提示信息给用户，
+			// 然后将用户输入的账户信息、用户名、验证码以及Result对象中的状态码等相关信息添加到ModelAndView对象中，方便在确认账户页面上展示相应的提示内容以及回显用户输入的信息等情况，方便用户重新输入进行再次尝试。
 			model.setViewName("password/confirmAccount");
 			model.addObject("account", username);
-			model.addObject("username",username);
+			model.addObject("username", username);
 			model.addObject("veritycode", veritycode);
 			model.addObject("code", result.getCode());
 		}
+
 		return model;
 	}
-	
+
+	/**
+	 * 处理密码找回中安全验证页面（"password/securityCheck.html"）的POST请求，用于进一步验证用户的安全信息（如通过手机验证码等方式，具体根据业务逻辑而定），根据验证结果进行不同的页面跳转和数据传递操作。
+	 * 调用iMemberService的securityCheck方法进行安全验证，根据返回的Result对象中的状态码判断验证是否成功，若成功则跳转到密码重置页面并传递相关数据，若失败则返回安全验证页面展示错误提示信息等情况。
+	 *
+	 * @param username 用户输入的账户信息（通常是前面确认账户步骤中验证通过的用户名或者邮箱等），从请求参数中获取，传递给iMemberService的securityCheck方法用于进一步的安全验证操作，结合其他参数（如手机验证码等）判断用户是否通过安全验证。
+	 * @param isEmail 表示账户是否为邮箱的标识信息（"1"表示是邮箱，"0"表示不是邮箱），从请求参数中获取，传递给iMemberService的securityCheck方法以及用于在页面展示等环节根据是否为邮箱进行不同的逻辑处理（比如邮箱验证和手机号验证可能有不同的提示信息等情况）。
+	 * @param mobileVcode 用户输入的手机验证码信息（如果安全验证涉及手机验证码的情况），从请求参数中获取，作为安全验证的关键信息之一传递给iMemberService的securityCheck方法，与其他信息一起判断用户是否通过安全验证流程。
+	 * @param model ModelAndView对象，用于根据安全验证结果设置要返回的视图名称以及向视图传递相关的数据，比如验证结果信息、用户名等，方便在不同页面展示相应的提示内容给用户，告知验证的结果情况（成功或失败以及失败原因等）。
+	 * @return 返回配置好视图名称和相关数据的ModelAndView对象，供Spring MVC框架根据视图名称渲染并展示相应的页面给客户端，展示相应的提示内容给用户，例如在验证成功时跳转到密码重置页面，失败时返回安全验证页面并展示错误提示信息等情况。
+	 */
 	@RequestMapping(value = "password/securityCheck.html", method = RequestMethod.POST)
-	public ModelAndView securityCheck(String username , String isEmail , String mobileVcode , ModelAndView model){
+	public ModelAndView securityCheck(String username, String isEmail, String mobileVcode, ModelAndView model) {
-		Result result = iMemberService.securityCheck(username , isEmail , mobileVcode);
+		// 调用iMemberService的securityCheck方法，传入用户名、是否为邮箱标识信息以及手机验证码等参数，该方法会根据业务逻辑进行安全验证操作（比如验证手机验证码是否正确、结合账户信息判断是否符合安全要求等情况），
-		if(result.getCode() == 200){
+		// 返回一个Result对象，其中包含了安全验证结果的相关信息，如状态码（表示验证是否成功等情况）、提示信息以及可能的其他验证相关结果数据等内容，后续会根据这个Result对象来进一步处理页面跳转和数据传递等操作。
+		Result result = iMemberService.securityCheck(username, isEmail, mobileVcode);
+
+		// 判断Result对象中的状态码是否为200（通常表示安全验证成功等情况，具体含义由业务中Result类的定义以及服务层返回逻辑决定），
+		// 如果状态码为200，说明安全验证通过，将用户名以及iMemberService的securityCheck方法返回的用于密码重置的关键信息（通过result.getResult()获取，可能是一个重置密码的令牌等关键数据）添加到ModelAndView对象中，
+		// 同时设置ModelAndView的视图名称为"password/resetPassword"，表示要跳转到密码重置页面，方便用户在该页面进行密码重置操作，使用获取到的关键信息来完成重置流程。
+		if (result.getCode() == 200) {
 			model.addObject("username", username);
-			model.addObject("resetPasswordKey" , result.getResult());
+			model.addObject("resetPasswordKey", result.getResult());
 			model.setViewName("password/resetPassword");
-		}else{
+		} else {
+			// 如果Result对象的状态码不是200，说明安全验证失败，将Result对象、是否为邮箱标识信息以及一个表示验证码错误的标识（"1"，这里可能根据具体业务逻辑有更准确的含义，比如表示验证失败相关情况）添加到ModelAndView对象中，
+			// 同时设置ModelAndView的视图名称为"password/securityCheck"，表示返回安全验证页面展示错误提示信息给用户，方便用户查看错误原因并重新进行安全验证操作等情况。
 			model.addObject("result", result);
 			model.addObject("isEmail", isEmail);
 			model.addObject("codeError", "1");
 			model.setViewName("password/securityCheck");
 		}
+
 		return model;
 	}
-	
+
+	/**
+	 * 处理密码重置页面（"password/resetPassword.html"）的POST请求，用于接收用户输入的新密码以及相关验证信息，调用iMemberService的resetPassword方法进行密码重置操作，根据返回的Result对象中的状态码判断重置是否成功，
+	 * 若成功则跳转到密码重置成功页面，若失败则返回密码重置页面，方便用户根据提示信息重新进行密码重置操作。
+	 *
+	 * @param resetPasswordKey 用于密码重置的关键信息（可能是前面安全验证通过后获取到的重置密码令牌等），从请求参数中获取，传递给iMemberService的resetPassword方法作为密码重置操作的重要依据，确保只有通过安全验证的用户才能进行密码重置。
+	 * @param username 用户输入的账户信息（通常是经过前面确认账户、安全验证等步骤的用户名或者邮箱等），从请求参数中获取，传递给iMemberService的resetPassword方法用于确定要重置密码的具体用户账户，保证密码重置操作对应正确的用户。
+	 * @param password 用户输入的新密码信息，作为密码重置的关键内容之一，从请求参数中获取，传递给iMemberService的resetPassword方法用于更新用户账户对应的密码信息，设置新的密码值。
+	 * @param verifypwd 用户输入的用于验证新密码的信息（比如再次输入新密码进行一致性验证等情况），从请求参数中获取，同样传递给iMemberService的resetPassword方法，用于验证新密码输入的一致性等情况，确保密码重置操作的准确性和安全性。
+	 * @param model ModelAndView对象，用于根据密码重置结果设置要返回的视图名称，比如重置成功跳转到密码重置成功页面，失败则返回密码重置页面，方便用户根据页面展示的提示信息进行相应的后续操作。
+	 * @return 返回配置好视图名称的ModelAndView对象，供Spring MVC框架根据视图名称渲染并展示相应的页面给客户端，展示相应的提示内容给用户，例如在密码重置成功时展示成功提示页面，失败时返回密码重置页面并可能展示错误提示信息等情况。
+	 */
 	@RequestMapping(value = "password/resetPassword.html", method = RequestMethod.POST)
-	public ModelAndView resetPassword(String resetPasswordKey , String username , String password , String verifypwd , ModelAndView model){
+	public ModelAndView resetPassword(String resetPasswordKey, String username, String password, String verifypwd, ModelAndView model) {
-		Result result = iMemberService.resetPassword(resetPasswordKey , username , password , verifypwd);
+		// 调用iMemberService的resetPassword方法，传入重置密码关键信息、用户名、新密码以及验证新密码的信息等参数，该方法会根据业务逻辑进行密码重置操作（比如验证关键信息是否有效、新密码格式是否正确、两次输入密码是否一致等情况），
-		if(result.getCode() == 200){
+		// 返回一个Result对象，其中包含了密码重置结果的相关信息，如状态码（表示重置是否成功等情况）、提示信息等内容，后续会根据这个Result对象来进一步处理页面跳转和数据传递等操作。
+		Result result = iMemberService.resetPassword(resetPasswordKey, username, password, verifypwd);
+
+		// 判断Result对象中的状态码是否为200（通常表示密码重置成功等情况，具体含义由业务中Result类的定义以及服务层返回逻辑决定），
+		// 如果状态码为200，说明密码重置成功，设置ModelAndView的视图名称为"password/resetPwSuccess"，表示要跳转到密码重置成功页面，展示相应的成功提示信息给用户，告知用户密码重置操作已顺利完成。
+		if (result.getCode() == 200) {
 			model.setViewName("password/resetPwSuccess");
-		}else{
+		} else {
+			// 如果Result对象的状态码不是200，说明密码重置失败，设置ModelAndView的视图名称为"password/resetPassword"，表示返回密码重置页面，方便用户查看可能的错误提示信息（由服务层返回的Result对象中的提示信息决定），
+			// 然后重新输入密码等信息进行再次尝试密码重置操作。
 			model.setViewName("password/resetPassword");
 		}
+
 		return model;
 	}
-	
+
-	@RequestMapping(value = "password/checkAccount.html", method = RequestMethod.GET)
+	/**
-	@ResponseBody
+	 * 处理检查账户是否存在的GET请求，请求路径为"password/checkAccount.html"，用于验证输入的账户（account）是否存在，通过调用iMemberService的checkAccount方法进行验证，
-	public Result checkAccount(String account){
+	 * 并将验证结果（以Result对象形式返回）直接返回给前端，前端可以根据返回的Result对象中的状态码、提示信息等内容来进行相应的提示和后续处理，比如提示用户账户不存在或者已存在等情况。
-		return iMemberService.checkAccount(account);
+	 *
-	}
+	 * @param account 用户输入的账户信息（可能是用户名或者邮箱等用于标识用户的信息），从请求参数中获取，传递给iMemberService的checkAccount方法用于验证账户是否存在，该方法会根据业务逻辑进行相应的查询和判断操作，返回对应的Result对象表示验证结果。
-	
+	 * @return 返回一个Result对象，即iMemberService的checkAccount方法返回的Result对象，其中包含了账户是否存在的验证结果相关信息（如状态码、提示信息等内容），通过@ResponseBody注解将Result对象转换为合适的格式（如JSON格式等，具体取决于项目配置）返回给前端，
-}
+	 * 供前端根据返回结果进行相应的提示和后续处理操作，比如根据状态码判断账户是否存在，然后在页面上展示相应的提示信息给用户。
+	 */
+	@RequestMapping(value = "password/checkAccount.html", method = RequestMethod

tamguo-tms/src/main/java/com/tamguo/web/member/QuestionAnswerController.java

@@ -11,20 +11,46 @@ import com.tamguo.modules.tiku.model.QuestionAnswerEntity;
 import com.tamguo.modules.tiku.service.IQuestionAnswerService;
 import com.tamguo.utils.ShiroUtils;
 
+// @Controller注解用于将这个类标记为Spring MVC框架中的一个控制器组件，意味着Spring容器会在启动时扫描到这个类，并将其管理起来，
+// 使得这个类中的方法能够处理对应的HTTP请求，根据请求的映射关系（通过@RequestMapping等注解定义）调用相应的业务逻辑方法，然后返回视图或者数据响应给客户端，
+// 在这里主要用于处理与会员答题相关的业务操作，具体为保存会员答题信息的功能。
 @Controller
 public class QuestionAnswerController {
-	
+
+	// 通过@Autowired注解自动注入IQuestionAnswerService接口的实现类实例，IQuestionAnswerService用于处理与题目答案相关的各种业务逻辑，
+	// 比如保存用户提交的答题信息到数据库等操作，在这个控制器的sendAnswer方法中会调用其相关方法来实现具体的保存答题信息的业务功能。
 	@Autowired
 	private IQuestionAnswerService iQuestionAnswerService;
 
+	/**
+	 * 处理会员发送答题信息的POST请求，请求路径为"member/sendAnswer.html"，用于接收前端传来的包含答题信息的QuestionAnswerEntity对象（通过@RequestBody注解解析请求体中的JSON数据为实体对象），
+	 * 在将答题信息保存到数据库等数据源之前，先设置答题信息对应的会员相关属性（头像、会员ID、会员昵称），通过ShiroUtils工具类获取当前登录会员的相关信息进行赋值，然后调用iQuestionAnswerService的sendAnswer方法保存答题信息，
+	 * 最后返回一个表示保存成功的Result对象给前端，告知前端答题信息保存成功的情况，方便前端进行相应的提示和后续处理。
+	 *
+	 * @param entity QuestionAnswerEntity对象，通过@RequestBody注解从请求体中解析得到的包含答题信息的实体对象，其属性包含了题目答案相关的各种内容（如答案内容、题目ID等，具体取决于QuestionAnswerEntity类的定义），
+	 *               在方法中会进一步完善其会员相关的属性（头像、会员ID、会员昵称）后传递给服务层进行保存操作。
+	 * @return 返回一个Result对象，通过Result.result方法创建，其中状态码设置为0，表示操作成功，提示信息为"保存成功"，用于告知前端答题信息已经成功保存到后端，供前端根据返回结果进行相应的提示和后续处理操作，
+	 * 比如在页面上提示用户答题已成功提交等情况。
+	 */
 	@RequestMapping(value = "member/sendAnswer.html", method = RequestMethod.POST)
 	@ResponseBody
-	public Result sendAnswer(@RequestBody QuestionAnswerEntity entity){
+	public Result sendAnswer(@RequestBody QuestionAnswerEntity entity) {
+		// 通过ShiroUtils工具类获取当前登录会员对应的实体对象，并从中获取会员头像信息，赋值给传入的QuestionAnswerEntity对象的memberAvatar属性，
+		// 这样在保存答题信息时，能够关联上当前答题会员的头像信息，方便后续在展示答题记录等场景中显示答题会员的头像情况。
 		entity.setMemberAvatar(ShiroUtils.getMember().getAvatar());
+		// 通过ShiroUtils工具类获取当前登录会员的ID，并赋值给QuestionAnswerEntity对象的memberId属性，用于明确答题信息所属的会员，
+		// 使得数据库等数据源中能够准确记录是哪个会员提交的该答题信息，方便进行数据关联查询以及权限管理等相关业务操作（例如只有会员本人或特定权限角色才能查看、修改其答题信息等情况）。
 		entity.setMemberId(ShiroUtils.getMemberId());
+		// 通过ShiroUtils工具类获取当前登录会员对应的实体对象，并从中获取会员昵称信息，赋值给QuestionAnswerEntity对象的memberName属性，
+		// 同样在保存答题信息时关联上会员昵称，便于后续展示答题记录等场景中更友好地显示答题会员的相关信息，提高信息展示的可读性和用户体验。
 		entity.setMemberName(ShiroUtils.getMember().getNickName());
+
+		// 调用iQuestionAnswerService的sendAnswer方法，传入完善了会员相关属性的QuestionAnswerEntity对象，将答题信息保存到数据库等数据源中，执行具体的答题信息保存业务逻辑操作，
+		// 比如将答题信息插入到对应的答题记录表中，同时可能还涉及到一些关联表的更新操作（如更新会员答题次数统计等相关表，具体取决于业务逻辑设计）。
 		iQuestionAnswerService.sendAnswer(entity);
+
+		// 返回一个Result对象，通过Result.result方法创建，传入状态码0、提示信息"保存成功"以及null（表示无其他额外返回数据，不过这里可根据业务需求调整），
+		// 告知前端答题信息保存操作已成功完成，方便前端根据这个返回结果进行相应的提示和后续处理，例如在页面上显示答题成功的提示信息给用户，或者根据业务逻辑进行页面跳转等操作。
 		return Result.result(0, null, "保存成功");
 	}
-	
+}
-}

tamguo-tms/src/main/java/com/tamguo/web/member/QuestionController.java

@@ -18,80 +18,164 @@ import com.tamguo.modules.tiku.service.IPaperService;
 import com.tamguo.modules.tiku.service.IQuestionService;
 import com.tamguo.utils.ShiroUtils;
 
-@Controller(value="memberQuestionController")
+// @Controller注解用于将这个类标记为Spring MVC框架中的一个控制器组件，并且指定了组件的名称为"memberQuestionController"，
+// Spring容器会在启动时扫描到这个类并进行管理，使得类中的方法能够处理对应的HTTP请求，根据请求的映射关系调用相应的业务逻辑方法，然后返回视图或者数据响应给客户端，
+// 在这里主要用于处理会员相关试题的各种操作，例如添加试题、查询试题列表、编辑和更新试题以及删除试题等业务功能对应的页面请求及处理逻辑。
+@Controller(value = "memberQuestionController")
 public class QuestionController {
-	
+
+	// 通过@Autowired注解自动注入IQuestionService接口的实现类实例，IQuestionService用于处理与试题相关的各种业务逻辑，
+	// 比如添加试题、查询试题、更新试题、删除试题等具体操作，在这个控制器的多个方法中会调用其相关方法来实现具体的试题业务功能。
 	@Autowired
 	private IQuestionService iQuestionService;
+
+	// 通过@Autowired注解自动注入IPaperService接口的实现类实例，IPaperService主要用于处理与试卷相关的业务逻辑，
+	// 在涉及试题与试卷关联的操作中（例如根据试卷ID查询试卷信息、获取属于某个试卷的试题列表等情况）会调用其相关方法来获取试卷相关的数据，辅助试题相关业务操作的完成。
 	@Autowired
 	private IPaperService iPaperService;
-	
+
+	/**
+	 * 处理会员添加试题页面（"/member/addQuestion.html"）的GET请求，用于展示添加试题的页面，并根据传入的试卷ID（paperId）查询对应的试卷信息，添加到ModelAndView对象中传递给页面进行展示，
+	 * 使得用户在添加试题时能够知晓该试题所属的试卷情况，方便后续关联操作，最后返回配置好的ModelAndView对象供Spring MVC框架渲染并展示添加试题页面给客户端。
+	 *
+	 * @param paperId 试卷的唯一标识字符串，从请求参数中获取，用于指定要添加试题所属的试卷，通过调用iPaperService的selectById方法查询该试卷的详细信息，传递给页面展示相关信息，
+	 *                例如试卷名称、试卷其他属性等内容，方便用户在添加试题时了解其所属试卷的情况。
+	 * @param model ModelAndView对象，用于设置视图名称以及向视图传递数据，在这里设置视图名称为"member/addQuestion"，表示要返回的是位于"member"目录下的"addQuestion"视图页面，
+	 *              同时将查询到的试卷信息添加到该对象中，方便在视图中展示试卷相关信息，辅助用户进行试题添加操作。
+	 * @return 返回配置好视图名称和试卷信息数据的ModelAndView对象，供Spring MVC框架进行视图渲染并展示会员添加试题页面内容给客户端，使得用户能看到添加试题的页面以及对应的试卷相关信息。
+	 */
 	@RequestMapping(value = "/member/addQuestion.html", method = RequestMethod.GET)
-	public ModelAndView index(String paperId , ModelAndView model){
+	public ModelAndView index(String paperId, ModelAndView model) {
 		model.setViewName("member/addQuestion");
 		model.addObject("paper", iPaperService.selectById(paperId));
 		return model;
 	}
-	
+
+	/**
+	 * 处理会员提交试题的POST请求，接收前端传来的包含试题信息的QuestionEntity对象，尝试调用iQuestionService的addQuestion方法将试题信息添加到数据库等数据源中，
+	 * 如果操作成功，直接返回iQuestionService方法返回的Result对象给前端（其中包含了添加操作的结果信息，如是否成功等情况）；若出现异常，通过ExceptionSupport工具类处理异常并返回相应的Result对象给前端，告知前端添加操作的结果情况。
+	 *
+	 * @param question QuestionEntity对象，从请求参数中获取，包含了前端传来的试题相关信息（如题目内容、题目类型等，具体取决于QuestionEntity类的定义），传递给iQuestionService的addQuestion方法作为要添加的试题数据，
+	 *                 在添加过程中会关联当前登录会员的ID（通过ShiroUtils获取），以确定试题的创建者等相关信息，确保数据的完整性和关联性。
+	 * @return 返回一个Result对象，如果添加试题操作成功，返回的就是iQuestionService.addQuestion方法返回的Result对象，其中包含了添加操作是否成功等相关信息；
+	 * 如果在操作过程中出现异常，通过ExceptionSupport工具类的resolverResult方法处理异常并返回相应的包含错误信息的Result对象给前端，供前端根据返回结果进行相应的提示和后续处理操作。
+	 */
 	@RequestMapping(value = "/member/submitQuestion.html", method = RequestMethod.POST)
 	@ResponseBody
-	public Result submitQuestion(QuestionEntity question){
+	public Result submitQuestion(QuestionEntity question) {
 		try {
-			return iQuestionService.addQuestion(question , ShiroUtils.getMemberId());
+			return iQuestionService.addQuestion(question, ShiroUtils.getMemberId());
 		} catch (Exception e) {
 			return ExceptionSupport.resolverResult("添加试题", this.getClass(), e);
 		}
 	}
-	
+
+	/**
+	 * 处理会员试题列表页面（"/member/questionList.html"）的GET请求，根据传入的试卷ID（paperId）查询对应的试卷信息，添加到ModelAndView对象中，然后设置要返回的视图名称为"member/questionList"，
+	 * 使得Spring MVC框架能够渲染对应的试题列表页面展示给客户端，在页面上展示该试卷对应的试题列表相关信息（虽然当前代码只是传递了试卷信息，可能后续在页面渲染时会进一步获取试题列表数据进行展示，具体取决于页面的逻辑），
+	 * 最后返回配置好的ModelAndView对象供框架进行视图渲染并展示页面给客户端。
+	 *
+	 * @param paperId 试卷的唯一标识字符串，从请求参数中获取，用于指定要展示试题列表所属的试卷，通过调用iPaperService的selectById方法查询该试卷的详细信息，传递给ModelAndView对象，
+	 *                方便在试题列表页面展示试卷相关信息（例如试卷名称等），让用户知晓当前展示的试题是属于哪个试卷的情况。
+	 * @param model ModelAndView对象，用于设置视图名称以及向视图传递数据，在这里先将查询到的试卷信息添加到该对象中，然后设置视图名称为"member/questionList"，指定要返回的页面视图，
+	 *              方便Spring MVC框架进行后续的视图渲染操作，使得页面能够展示试卷信息以及后续可能的试题列表等相关内容。
+	 * @return 返回配置好视图名称和试卷信息数据的ModelAndView对象，供Spring MVC框架根据视图名称渲染并展示会员试题列表页面内容给客户端，方便用户查看特定试卷下的试题相关情况。
+	 */
 	@RequestMapping(value = "/member/questionList.html", method = RequestMethod.GET)
-	public ModelAndView questionList(String paperId , ModelAndView model){
+	public ModelAndView questionList(String paperId, ModelAndView model) {
 		model.addObject("paper", iPaperService.selectById(paperId));
 		model.setViewName("member/questionList");
 		return model;
 	}
-	
+
-	@RequestMapping(value = "/member/queryQuestionList.html" , method=RequestMethod.POST)
+	/**
+	 * 处理会员查询试题列表的POST请求，接收前端传来的包含查询条件的JSONObject对象（通过@RequestBody注解解析请求体中的JSON数据），从JSON数据中提取出试题类型、试题唯一标识、试题内容、试卷ID、页码、每页数量等关键信息，
+	 * 根据这些信息构建分页查询条件，调用iQuestionService的queryQuestionList方法进行分页查询符合条件的试题列表信息，将查询结果按照特定格式封装到Map中返回给前端，用于在页面上展示试题列表数据，支持分页功能。
+	 *
+	 * @param data JSONObject对象，通过@RequestBody注解从请求体中解析得到的包含试题列表查询条件的JSON数据对象，其包含了如试题类型、试题唯一标识、试题内容、试卷ID、页码、每页数量等关键信息，
+	 *             需要从这个对象中提取出相应的属性值传递给服务层进行查询操作。
+	 * @return 返回一个Map<String, Object>类型的结果，其中包含了符合条件的试题列表数据（通过Result.jqGridResult方法按照特定格式封装了试题记录、总记录数、每页记录数、当前页码、总页数等信息），
+	 * 供前端根据这个Map中的数据进行试题列表的展示以及分页相关的操作处理，例如在页面上循环展示试题列表信息，并根据总页数等信息实现分页导航等功能。
+	 */
+	@RequestMapping(value = "/member/queryQuestionList.html", method = RequestMethod.POST)
 	@ResponseBody
-	public Map<String, Object> queryQuestionList(@RequestBody JSONObject data){
+	public Map<String, Object> queryQuestionList(@RequestBody JSONObject data) {
-		String questionType ; String uid ; String content ; String paperId ;
+		// 从传入的JSONObject数据中获取试题类型字符串，用于筛选特定类型的试题，作为查询条件之一传递给iQuestionService的queryQuestionList方法，
-			Integer page ; Integer limit;
+		// 以便获取符合该类型要求的试题列表信息，例如只查询选择题、填空题等不同类型的试题，具体取决于业务中对试题类型的分类和使用方式。
+		String questionType;
+		String uid;
+		String content;
+		String paperId;
+		Integer page;
+		Integer limit;
 		questionType = data.getString("questionType");
+		// 获取试题的唯一标识字符串，可用于精准定位特定的试题（比如在更新、删除或者更精确的查询场景下作为筛选条件），传递给查询方法用于在查询过程中进一步筛选或关联特定试题记录。
 		uid = data.getString("uid");
-		content = data.getString("content");
+		// 获取试题内容字符串，作为模糊查询的条件之一，用于查找包含该内容的试题（例如通过题目中包含的关键字进行搜索等情况），传递给服务层在查询操作中进行相应的模糊查询逻辑处理。
+		content = data.getString("questionType");
+		// 获取试卷ID字符串，用于筛选属于该试卷的试题，确保查询到的试题列表是与指定试卷相关的，传递给服务层结合其他条件进行试题的筛选查询操作，获取对应试卷下的试题信息。
 		paperId = data.getString("paperId");
+		// 获取当前页码整数，用于指定要查询的页码信息，传递给Page对象来确定查询的分页情况，获取对应页码的数据记录，方便实现分页展示试题列表的功能。
 		page = data.getInteger("page");
+		// 获取每页显示的记录数量整数，同样传递给Page对象来设置每页显示的试题数量，结合page参数实现分页查询和展示试题列表的功能。
 		limit = data.getInteger("limit");
+
+		// 创建一个Page对象，用于进行分页查询操作，通过设置当前页码（page）和每页显示的记录数量（limit）来确定分页情况，
+		// 后续将这个Page对象以及其他查询条件一起传递给iQuestionService的queryQuestionList方法进行分页查询符合条件的试题列表信息。
 		Page<QuestionEntity> p = new Page<>();
 		p.setCurrent(page);
 		p.setSize(limit);
-		Page<QuestionEntity> list = iQuestionService.queryQuestionList(questionType , uid , content , paperId , ShiroUtils.getMemberId() , p);
+
+		// 调用iQuestionService的queryQuestionList方法，传入试题类型、试题唯一标识、试题内容、试卷ID、当前登录会员的ID（通过ShiroUtils获取，可能用于权限控制等情况，确保会员只能查询自己有权限查看的试题）以及构建好的Page对象作为参数，
+		// 进行分页查询操作，获取符合条件的试题列表信息（以Page<QuestionEntity>形式返回，包含了分页相关的数据以及试题记录列表等内容）。
+		Page<QuestionEntity> list = iQuestionService.queryQuestionList(questionType, uid, content, paperId, ShiroUtils.getMemberId(), p);
+
+		// 使用Result.jqGridResult方法将分页查询得到的试题列表相关信息（试题记录、总记录数、每页记录数、当前页码、总页数等）按照特定格式封装到一个Map中返回给前端，
+		// 方便前端根据这个Map中的数据进行试题列表的展示以及分页相关的操作处理，例如在页面上循环展示试题列表信息，并根据总页数等信息实现分页导航等功能。
 		return Result.jqGridResult(list.getRecords(), list.getTotal(), limit, page, list.getPages());
 	}
-	
+
+	/**
+	 * 处理会员编辑试题页面（"/member/editQuestion.html"）的GET请求，用于展示编辑试题的页面，根据传入的试卷ID（paperId）和试题ID（questionId）分别查询对应的试卷信息和设置试题ID相关属性，添加到ModelAndView对象中传递给页面进行展示，
+	 * 使得用户在编辑试题时能够知晓该试题所属的试卷情况以及明确要编辑的是哪个试题，最后返回配置好的ModelAndView对象供Spring MVC框架渲染并展示编辑试题页面给客户端。
+	 *
+	 * @param paperId 试卷的唯一标识字符串，从请求参数中获取，用于指定要编辑试题所属的试卷，通过调用iPaperService的selectById方法查询该试卷的详细信息，传递给页面展示相关信息，
+	 *                例如试卷名称、试卷其他属性等内容，方便用户在编辑试题时了解其所属试卷的情况。
+	 * @param questionId 试题的唯一标识字符串，从请求参数中获取，用于明确要编辑的具体试题，添加到ModelAndView对象中传递给页面，方便页面在渲染时能够确定要展示和编辑的是哪个试题记录，
+	 *                   例如通过该ID从数据库获取试题的原始内容等信息展示在编辑页面上供用户修改。
+	 * @param model ModelAndView对象，用于设置视图名称以及向视图传递数据，在这里设置视图名称为"member/editQuestion"，表示要返回的是位于"member"目录下的"editQuestion"视图页面，
+	 *              同时将查询到的试卷信息和试题ID相关属性添加到该对象中，方便在视图中展示试卷及试题相关信息，辅助用户进行试题编辑操作。
+	 * @return 返回配置好视图名称、试卷信息和试题ID相关属性数据的ModelAndView对象，供Spring MVC框架进行视图渲染并展示会员编辑试题页面内容给客户端，使得用户能看到编辑试题的页面以及对应的试卷和试题相关信息。
+	 */
 	@RequestMapping(value = "/member/editQuestion.html", method = RequestMethod.GET)
-	public ModelAndView editQuestion(String paperId , String questionId , ModelAndView model){
+	public ModelAndView editQuestion(String paperId, String questionId, ModelAndView model) {
 		model.setViewName("member/editQuestion");
 		model.addObject("paper", iPaperService.selectById(paperId));
-		model.addObject("questionId" , questionId);
+		model.addObject("questionId", questionId);
 		return model;
 	}
-	
+
+	/**
+	 * 处理获取单个试题信息的GET请求，根据传入的试题ID（questionId）查询对应的试题详细信息，并将查询结果封装到Result对象中返回给前端，
+	 * 通过调用iQuestionService的selectById方法，传入试题ID作为参数，从数据库等数据源中获取对应的试题实体对象信息，然后使用Result.successResult方法将查询到的试题信息封装到Result对象中，
+	 * 最后通过@ResponseBody注解将Result对象转换为合适的格式（如JSON格式等，具体取决于项目配置）返回给前端，方便前端获取并展示该试题的详细信息，或者根据返回结果进行相应的后续处理（如在页面上展示试题详情等操作）。
+	 *
+	 * @param questionId 试题的唯一标识字符串，从请求参数中获取，用于指定要查询的试题对象，传递给iQuestionService的selectById方法作为查询依据，获取对应的试题详细信息。
+	 * @return 返回一个Result对象，通过Result.successResult方法创建，其中包含了通过iQuestionService查询到的指定试题ID对应的试题详细信息，供前端根据返回结果进行相应的展示和后续处理操作。
+	 */
 	@RequestMapping(value = "/member/getQuestion.html", method = RequestMethod.GET)
 	@ResponseBody
 	public Result getQuestion(String questionId) {
 		return Result.successResult(iQuestionService.selectById(questionId));
 	}
-	
+
-	@RequestMapping(value = "/member/updateQuestion.html", method = RequestMethod.POST)
+	/**
-	@ResponseBody
+	 * 处理会员更新试题信息的POST请求，接收前端传来的包含更新后试题信息的QuestionEntity对象，调用iQuestionService的updateQuestion方法更新对应的试题信息，
-	public Result updateQuestion(QuestionEntity question) {
+	 * 直接返回iQuestionService方法返回的Result对象给前端（其中包含了更新操作的结果信息，如是否成功等情况），前端可以根据返回结果进行相应的提示和后续处理（比如提示用户试题更新成功或失败等情况）。
-		return iQuestionService.updateQuestion(question , ShiroUtils.getMemberId());
+	 *
-	}
+	 * @param question QuestionEntity对象，从请求参数中获取，包含了前端传来的更新后的试题相关信息（如修改后的题目内容、题目类型等），传递给iQuestionService的updateQuestion方法作为要更新的试题数据，
-	
+	 *                 在更新过程中会关联当前登录会员的ID（通过ShiroUtils获取），以确定试题的更新者等相关信息，确保数据的完整性和关联性，同时进行相应的权限控制等业务逻辑操作（例如只有创建者或特定权限角色才能更新试题等情况）。
-	
+	 * @return 返回一个Result对象，即iQuestionService.updateQuestion方法返回的Result对象，其中包含了试题更新操作是否成功等相关信息，供前端根据返回结果进行相应的提示和后续处理操作，
-	@RequestMapping(value = "/member/deleteQuestion.html", method = RequestMethod.GET)
+	 * 比如根据返回的状态码判断更新是否成功，然后在页面上展示相应的提示信息给用户，告知试题更新的结果情况。
-	@ResponseBody
+	 */
-	public Result deleteQuestion(@RequestBody String uid) {
+	@RequestMapping(value = "/member/updateQuestion.html", method = RequestMethod.POST)
-		return iQuestionService.delete(uid , ShiroUtils.getMemberId());
-	}
-}

tamguo-tms/src/main/java/com/tamguo/web/member/RegisterController.java

@@ -19,51 +19,116 @@ import com.tamguo.modules.member.model.MemberEntity;
 import com.tamguo.modules.member.service.IMemberService;
 import com.tamguo.utils.ShiroUtils;
 
+// @Controller注解用于将这个类标记为Spring MVC框架中的一个控制器组件，意味着Spring容器会在启动时扫描到这个类，并将其管理起来，
+// 使得这个类中的方法能够处理对应的HTTP请求，根据请求的映射关系（通过@RequestMapping等注解定义）调用相应的业务逻辑方法，然后返回视图或者数据响应给客户端，
+// 在这里主要用于处理与用户注册相关的各种操作，比如注册页面展示、注册信息验证以及实际的用户注册和注册后尝试登录等业务功能。
 @Controller
 public class RegisterController {
-	
+
+	// 通过@Autowired注解自动注入IMemberService接口的实现类实例，IMemberService用于处理与会员相关的各种业务逻辑，
+	// 在注册相关操作中，比如验证用户名是否可用、验证手机号是否可用、进行用户注册等操作时，会调用其相关方法来实现具体的业务功能，根据不同的业务逻辑返回相应的Result对象来表示操作结果情况。
 	@Autowired
 	private IMemberService iMemberService;
 
+	/**
+	 * 处理用户注册页面（"/register.html"）的GET请求，主要用于设置要返回的视图名称，使得Spring MVC框架能够渲染对应的注册页面展示给客户端，
+	 * 在这里将视图名称设置为"register"，表示返回名为"register"的视图页面，供用户填写注册信息等操作，该方法只是简单地进行视图名称的设置，暂未涉及其他复杂的数据传递等操作。
+	 *
+	 * @param model ModelAndView对象，用于设置视图名称，在这里将视图名称设置为"register"，指定要返回的页面视图，方便Spring MVC框架进行后续的视图渲染操作。
+	 * @param session HttpSession对象，虽然在当前这个方法中没有直接对其进行过多操作，但在后续的注册相关逻辑（比如注册成功后存储用户信息到会话等情况，不过当前代码暂未体现完整逻辑）中可能会用到，
+	 *                它可以用于在服务器端存储与当前用户会话相关的数据，辅助完成注册以及后续的业务流程操作。
+	 * @return 返回配置好视图名称的ModelAndView对象，供Spring MVC框架根据视图名称渲染并展示用户注册页面给客户端。
+	 */
 	@RequestMapping(value = "/register.html", method = RequestMethod.GET)
-    public ModelAndView register(ModelAndView model , HttpSession session) {
+	public ModelAndView register(ModelAndView model, HttpSession session) {
 		model.setViewName("register");
 		return model;
-    }
+	}
-	
+
+	/**
+	 * 处理检查用户名是否可用的GET请求，请求路径为"/checkUsername.html"，用于验证输入的用户名（username）是否已经被其他用户使用，通过调用iMemberService的checkUsername方法进行验证，
+	 * 并将验证结果（以Result对象形式返回）直接返回给前端，前端可以根据返回的Result对象中的状态码、提示信息等内容来进行相应的提示和后续处理，比如提示用户用户名可用或者已被占用等情况。
+	 *
+	 * @param username 用户输入的用户名信息，从请求参数中获取，传递给iMemberService的checkUsername方法用于验证用户名是否存在（通常是在数据库中查询是否有相同用户名的记录），该方法会根据业务逻辑进行相应的查询和判断操作，返回对应的Result对象表示验证结果。
+	 * @return 返回一个Result对象，即iMemberService的checkUsername方法返回的Result对象，其中包含了用户名是否可用的验证结果相关信息（如状态码、提示信息等内容），通过@ResponseBody注解将Result对象转换为合适的格式（如JSON格式等，具体取决于项目配置）返回给前端，
+	 * 供前端根据返回结果进行相应的提示和后续处理操作，比如根据状态码判断用户名是否可用，然后在页面上展示相应的提示信息给用户。
+	 */
 	@RequestMapping(value = "/checkUsername.html", method = RequestMethod.GET)
 	@ResponseBody
-	public Result checkUsername(String username){
+	public Result checkUsername(String username) {
 		return iMemberService.checkUsername(username);
 	}
-	
+
+	/**
+	 * 处理检查手机号是否可用的GET请求，请求路径为"/checkMobile.html"，用于验证输入的手机号（mobile）是否已经被其他用户绑定，通过调用iMemberService的checkMobile方法进行验证，
+	 * 并将验证结果（以Result对象形式返回）直接返回给前端，前端可以根据返回的Result对象中的状态码、提示信息等内容来进行相应的提示和后续处理，比如提示用户手机号可用或者已被绑定等情况。
+	 *
+	 * @param mobile 用户输入的手机号信息，从请求参数中获取，传递给iMemberService的checkMobile方法用于验证手机号是否存在绑定记录（通常是在数据库中查询是否有相同手机号的记录），该方法会根据业务逻辑进行相应的查询和判断操作，返回对应的Result对象表示验证结果。
+	 * @return 返回一个Result对象，即iMemberService的checkMobile方法返回的Result对象，其中包含了手机号是否可用的验证结果相关信息（如状态码、提示信息等内容），通过@ResponseBody注解将Result对象转换为合适的格式（如JSON格式等，具体取决于项目配置）返回给前端，
+	 * 供前端根据返回结果进行相应的提示和后续处理操作，比如根据状态码判断手机号是否可用，然后在页面上展示相应的提示信息给用户。
+	 */
 	@RequestMapping(value = "/checkMobile.html", method = RequestMethod.GET)
 	@ResponseBody
-	public Result checkMobile(String mobile){
+	public Result checkMobile(String mobile) {
 		return iMemberService.checkMobile(mobile);
 	}
-	
+
+	/**
+	 * 处理用户提交注册信息的POST请求，接收前端传来的包含用户注册信息的MemberEntity对象（通过@RequestBody注解解析请求体中的JSON数据为实体对象），
+	 * 首先调用iMemberService的register方法进行用户注册操作，若注册成功（返回的Result对象状态码为200），则尝试使用注册时填写的用户名和密码进行登录操作（通过Shiro框架实现），
+	 * 根据登录过程中可能出现的异常情况（如用户名不存在、密码错误、账号被锁定等）返回相应的Result对象告知前端；若注册不成功（返回的Result对象状态码不为200），则直接将注册操作返回的Result对象返回给前端，告知前端注册失败及失败原因等情况。
+	 *
+	 * @param member MemberEntity对象，通过@RequestBody注解从请求体中解析得到的包含用户注册信息的实体对象，其属性包含了用户名、密码、手机号、邮箱等各种注册相关的信息（具体取决于MemberEntity类的定义），
+	 *               传递给iMemberService的register方法用于将用户信息保存到数据库等数据源中，完成用户注册的业务逻辑操作。
+	 * @param session HttpSession对象，用于在注册成功且登录成功后，存储当前登录用户的相关信息（通过将用户信息存储到"currMember"属性下），方便后续在其他请求处理中获取当前登录用户的信息进行相关业务操作，例如在页面上展示用户相关信息等情况。
+	 * @return 返回一个Result对象，如果注册操作成功且登录操作也成功，最终返回的Result对象中包含了注册成功以及登录成功的相关信息（具体由iMemberService的register方法以及登录成功后的相关逻辑决定）；
+	 * 如果注册操作不成功，直接返回iMemberService的register方法返回的Result对象，其中包含了注册失败的原因等相关信息；如果注册成功但登录过程中出现异常（如用户名或密码错误、账号被锁定等情况），
+	 * 则根据不同的异常情况返回相应的Result对象，告知前端登录失败及失败原因等情况，方便前端根据返回结果进行相应的提示和后续处理操作。
+	 */
 	@RequestMapping(value = "/subRegister.html", method = RequestMethod.POST)
 	@ResponseBody
-	public Result subRegister(@RequestBody MemberEntity member , HttpSession session){
+	public Result subRegister(@RequestBody MemberEntity member, HttpSession session) {
+		// 调用iMemberService的register方法，传入包含用户注册信息的MemberEntity对象，该方法会根据业务逻辑进行用户注册操作，比如将用户信息插入到数据库的用户表中，进行合法性验证、唯一性验证等相关操作，
+		// 返回一个Result对象，其中包含了注册操作的结果相关信息，如状态码（表示注册是否成功等情况）、提示信息以及可能的注册成功后返回的用户相关数据等内容，后续会根据这个Result对象的状态码来进一步处理登录相关逻辑以及最终返回结果给前端的操作。
 		Result result = iMemberService.register(member);
-		if(result.getCode() == 200) {
+
+		// 判断Result对象中的状态码是否为200（通常表示注册成功等情况，具体含义由业务中Result类的定义以及服务层返回逻辑决定），
+		// 如果状态码为200，说明注册成功，接下来尝试进行登录操作，以下是登录相关的逻辑处理。
+		if (result.getCode() == 200) {
+			// 通过ShiroUtils工具类获取当前的Subject对象，在Shiro框架中，Subject代表了当前与系统进行交互的“主体”，通常就是指当前登录的用户或者一个匿名的访问者（未登录时），
+			// 获取到Subject对象后，用于后续进行用户认证相关的操作，也就是使用刚注册的用户信息进行登录验证操作。
 			Subject subject = ShiroUtils.getSubject();
+			// 从注册操作返回的Result对象中获取注册成功后的用户实体对象（通过强制转换为MemberEntity类型获取，假设注册成功时会将创建的用户对象作为结果返回在Result中），
+			// 用于后续创建UsernamePasswordToken对象传递用户名和密码信息进行登录操作。
 			MemberEntity memberEntity = (MemberEntity) result.getResult();
+			// 创建一个UsernamePasswordToken对象，用于传递用户名和密码信息给Shiro框架进行认证操作，将注册成功的用户的用户名（memberEntity.getUsername()）和注册时填写的密码（member.getPassword()）作为参数传入构造方法，
+			// 这个对象会作为参数传递给Subject的login方法，触发Shiro框架的认证流程，去验证用户名和密码是否匹配以及用户是否合法等情况。
 			UsernamePasswordToken token = new UsernamePasswordToken(memberEntity.getUsername(), member.getPassword());
 			try {
+				// 调用Subject的login方法，传入前面创建的UsernamePasswordToken对象，触发Shiro框架的用户认证流程，
+				// 如果认证成功（即用户名和密码正确，且用户状态正常等情况），则继续执行后续的操作；如果认证失败，会抛出相应的异常（如UnknownAccountException、IncorrectCredentialsException等），进入对应的catch块进行相应的错误处理。
 				subject.login(token);
-				
+
+				// 如果登录认证通过，通过ShiroUtils工具类获取当前登录用户对应的MemberEntity对象（假设认证时将MemberEntity类型的用户对象设置为了Principal），
+				// 然后将这个会员对象存储到HttpSession的"currMember"属性下，方便后续在其他请求处理中获取当前登录用户的信息进行相关业务操作，例如在页面上展示用户相关信息等情况。
 				session.setAttribute("currMember", ShiroUtils.getMember());
 			} catch (UnknownAccountException e) {
+				// 如果在Shiro认证过程中抛出UnknownAccountException异常，说明用户名不存在或者没有找到对应的用户信息，返回一个Result对象，设置其状态码为201，提示信息为"用户名或密码有误，请重新输入或找回密码"，
+				// 表示登录失败，将这个Result对象返回给前端，告知前端登录失败的原因，方便前端进行相应的提示和后续处理操作。
 				return Result.result(201, null, "用户名或密码有误，请重新输入或找回密码");
 			} catch (IncorrectCredentialsException e) {
+				// 如果抛出IncorrectCredentialsException异常，意味着密码不正确，返回一个Result对象，设置其状态码为202，提示信息为"用户名或密码有误，请重新输入或找回密码"，
+				// 同样将这个Result对象返回给前端，告知前端登录失败是因为密码错误，方便前端进行相应的提示和后续处理操作。
 				return Result.result(202, null, "用户名或密码有误，请重新输入或找回密码");
 			} catch (LockedAccountException e) {
+				// 如果出现LockedAccountException异常，表示用户账号被锁定了，返回一个Result对象，设置其状态码为203，提示信息为"账号被锁定"，
+				// 并将这个Result对象返回给前端，告知前端登录失败是因为账号被锁定的原因，方便前端进行相应的提示和后续处理操作。
 				return Result.result(203, null, "账号被锁定");
-			} 
+			}
 		}
+
+		// 如果注册操作不成功（Result对象的状态码不为200），或者注册成功但登录过程中出现异常（在对应的catch块中已经返回相应的Result对象），直接将最初注册操作返回的Result对象返回给前端，
+		// 这个Result对象中包含了注册失败的原因等相关信息，方便前端根据返回结果进行相应的提示和后续处理操作，比如提示用户注册失败的具体原因（如用户名已存在、手机号格式错误等情况）。
 		return result;
 	}
-	
+}
-}

tamguo-tms/src/main/java/com/tamguo/web/sys/JoinusController.java

@@ -15,31 +15,77 @@ import com.tamguo.common.utils.Result;
 import com.tamguo.modules.sys.model.TeacherEntity;
 import com.tamguo.modules.sys.service.ITeacherService;
 
+// @Controller注解用于将这个类标记为Spring MVC框架中的一个控制器组件，意味着Spring容器会在启动时扫描到这个类，并将其管理起来，
+// 使得这个类中的方法能够处理对应的HTTP请求，根据请求的映射关系（通过@RequestMapping等注解定义）调用相应的业务逻辑方法，然后返回视图或者数据响应给客户端，
+// 在这里主要用于处理与教师应聘相关的各种操作，比如应聘页面展示、获取教师信息以及提交教师应聘信息等业务功能。
 @Controller
 public class JoinusController {
-	
+
+	// 通过@Autowired注解自动注入ITeacherService接口的实现类实例，ITeacherService用于处理与教师相关的各种业务逻辑，
+	// 在教师应聘相关操作中，比如根据手机号获取教师信息、保存教师应聘信息等操作时，会调用其相关方法来实现具体的业务功能，根据不同的业务逻辑返回相应的Result对象来表示操作结果情况。
 	@Autowired
 	private ITeacherService iTeacherService;
 
+	/**
+	 * 处理教师应聘页面（"teacher/joinus.html"）的GET请求，主要用于设置要返回的视图名称，使得Spring MVC框架能够渲染对应的应聘页面展示给客户端，
+	 * 在这里将视图名称设置为"teacher/joinus"，表示返回位于"teacher"目录下的"joinus"视图页面，供教师填写应聘信息等操作，该方法只是简单地进行视图名称的设置，暂未涉及其他复杂的数据传递等操作。
+	 *
+	 * @param model ModelAndView对象，用于设置视图名称，在这里将视图名称设置为"teacher/joinus"，指定要返回的页面视图，方便Spring MVC框架进行后续的视图渲染操作。
+	 * @param session HttpSession对象，虽然在当前这个方法中没有直接对其进行过多操作，但在一些扩展的业务逻辑中（比如记录应聘教师的访问会话信息等情况，不过当前代码暂未体现相关完整逻辑）可能会用到，
+	 *                它可以用于在服务器端存储与当前用户会话相关的数据，辅助完成教师应聘以及后续可能的业务流程操作。
+	 * @return 返回配置好视图名称的ModelAndView对象，供Spring MVC框架根据视图名称渲染并展示教师应聘页面给客户端。
+	 */
 	@RequestMapping(value = "teacher/joinus.html", method = RequestMethod.GET)
-    public ModelAndView register(ModelAndView model , HttpSession session) {
+	public ModelAndView register(ModelAndView model, HttpSession session) {
 		model.setViewName("teacher/joinus");
 		return model;
-    }
+	}
-	
+
+	/**
+	 * 处理获取教师信息的POST请求，请求路径为"teacher/info.html"，接收前端传来的包含查询条件的Map对象（通过@RequestBody注解解析请求体中的JSON数据为Map类型，假设数据格式为JSON格式且能转换为Map），
+	 * 从Map中获取手机号（mobile）和验证码（verifyCode）信息，调用iTeacherService的getTeacherByMobile方法根据手机号和验证码获取对应的教师信息，然后将获取到的结果（以Result对象形式返回）直接返回给前端，
+	 * 前端可以根据返回的Result对象中的状态码、提示信息等内容来进行相应的提示和后续处理，比如提示教师信息获取成功或者验证失败等情况。
+	 *
+	 * @param param Map<String, Object>对象，通过@RequestBody注解从请求体中解析得到的包含查询教师信息相关条件的Map类型数据对象，其键值对包含了如手机号、验证码等关键信息（具体键名由前端传递的数据格式决定），
+	 *              需要从这个Map中提取出相应的信息传递给服务层进行教师信息查询操作。
+	 * @return 返回一个Result对象，即iTeacherService的getTeacherByMobile方法返回的Result对象，其中包含了根据手机号和验证码查询教师信息的结果相关信息（如状态码、提示信息等内容），通过@ResponseBody注解将Result对象转换为合适的格式（如JSON格式等，具体取决于项目配置）返回给前端，
+	 * 供前端根据返回结果进行相应的提示和后续处理操作，比如根据状态码判断教师信息是否获取成功，然后在页面上展示相应的提示信息给教师。
+	 */
 	@RequestMapping(value = "teacher/info.html", method = RequestMethod.POST)
 	@ResponseBody
 	public Result getTeacher(@RequestBody Map<String, Object> param) {
+		// 从传入的Map参数中获取手机号字符串，作为查询教师信息的关键条件之一，传递给iTeacherService的getTeacherByMobile方法用于在数据库等数据源中查找对应的教师记录，
+		// 例如通过手机号来精准定位特定教师的相关信息，判断是否存在该手机号对应的教师以及验证手机号与验证码是否匹配等情况（具体逻辑由ITeacherService的实现类决定）。
 		String mobile = (String) param.get("mobile");
+		// 从Map参数中获取验证码字符串，同样作为重要的查询验证条件，与手机号一起传递给iTeacherService的getTeacherByMobile方法，用于验证教师的合法性或者确认当前操作的有效性等情况，
+		// 确保只有输入正确验证码的情况下才能获取相应教师的信息，保证信息获取的安全性和准确性。
 		String verifyCode = (String) param.get("verifyCode");
+
+		// 调用iTeacherService的getTeacherByMobile方法，传入手机号和验证码作为参数，该方法会根据业务逻辑进行教师信息查询以及相关验证操作，返回一个Result对象，
+		// 其中包含了查询及验证结果的相关信息，如状态码（表示是否查询到教师信息、验证是否通过等情况）、提示信息以及可能的查询到的教师实体对象等内容，后续会将这个Result对象直接返回给前端，告知前端教师信息获取的结果情况。
 		Result result = iTeacherService.getTeacherByMobile(mobile, verifyCode);
+
 		return result;
 	}
-	
+
+	/**
+	 * 处理教师应聘提交信息的POST请求，接收前端传来的包含教师应聘信息的TeacherEntity对象（通过@RequestBody注解解析请求体中的JSON数据为实体对象），
+	 * 调用iTeacherService的joinus方法将教师应聘信息保存到数据库等数据源中，然后返回一个表示操作成功的Result对象（通过Result.successResult方法创建）给前端，告知前端应聘信息提交成功的情况，方便前端进行相应的提示和后续处理。
+	 *
+	 * @param teacher TeacherEntity对象，通过@RequestBody注解从请求体中解析得到的包含教师应聘信息的实体对象，其属性包含了教师的个人基本信息（如姓名、学历、教学经验等，具体取决于TeacherEntity类的定义）、应聘岗位相关信息等各种应聘相关的内容，
+	 *                传递给iTeacherService的joinus方法用于将教师应聘信息保存到数据库等数据源中，完成教师应聘信息提交的业务逻辑操作。
+	 * @return 返回一个Result对象，通过Result.successResult方法创建，其中传入null表示无其他额外返回数据（不过这里可根据业务需求调整），用于告知前端教师应聘信息已经成功提交到后端，供前端根据返回结果进行相应的提示和后续处理操作，
+	 * 比如在页面上提示教师应聘已成功提交等情况。
+	 */
 	@RequestMapping(value = "teacher/joinus.html", method = RequestMethod.POST)
 	@ResponseBody
 	public Result teacherJoinus(@RequestBody TeacherEntity teacher) {
+		// 调用iTeacherService的joinus方法，传入包含教师应聘信息的TeacherEntity对象，该方法会根据业务逻辑进行教师应聘信息的保存操作，比如将教师信息插入到数据库的教师应聘表或者相关关联表中，进行合法性验证等相关操作，
+		// 完成将教师应聘信息持久化的业务逻辑，确保信息被正确保存到后端存储中，方便后续的审核等业务流程处理。
 		iTeacherService.joinus(teacher);
+
+		// 返回一个Result对象，通过Result.successResult方法创建，传入null参数（表示无额外需要返回的数据，不过可以根据实际业务需求进行调整，比如返回保存后的教师信息ID等内容），
+		// 告知前端教师应聘信息提交操作已成功完成，方便前端根据这个返回结果进行相应的提示和后续处理，例如在页面上显示应聘成功提交的提示信息给教师，或者根据业务逻辑进行页面跳转等操作。
 		return Result.successResult(null);
 	}
-}
+}

tamguo-tms/src/main/java/com/tamguo/web/tiku/AreaController.java

@@ -9,17 +9,28 @@ import org.springframework.web.bind.annotation.ResponseBody;
 import com.tamguo.common.utils.Result;
 import com.tamguo.modules.sys.service.ISysAreaService;
 
+// @Controller注解用于将这个类标记为Spring MVC框架中的一个控制器组件，意味着Spring容器会在启动时扫描到这个类，并将其管理起来，
+// 使得这个类中的方法能够处理对应的HTTP请求，根据请求的映射关系（通过@RequestMapping等注解定义）调用相应的业务逻辑方法，然后返回视图或者数据响应给客户端，
+// 在这里主要用于处理与区域相关的业务操作，当前类中仅实现了查询区域树信息这一功能对应的请求处理逻辑。
 @Controller
 public class AreaController {
 
+	// 通过@Autowired注解自动注入ISysAreaService接口的实现类实例，ISysAreaService用于处理与系统区域相关的各种业务逻辑，
+	// 比如查询区域树结构数据等操作，在这个控制器的findAreaTree方法中会调用其相关方法来实现具体的查询区域树信息的业务功能。
 	@Autowired
 	private ISysAreaService iSysAreaService;
 
+	/**
+	 * 处理查询区域树信息的GET请求，请求路径为"area/findAreaTree.html"，用于获取区域的树形结构数据（通常用于在前端页面以树状结构展示区域的层级关系等情况），
+	 * 通过调用iSysAreaService的findAreaTree方法进行查询操作，然后将查询结果（以Result对象形式返回）直接返回给前端，前端可以根据返回的Result对象中的数据、状态码、提示信息等内容来进行相应的展示和后续处理，
+	 * 比如在页面上展示区域树结构，或者根据返回的状态码判断查询是否成功等情况。
+	 *
+	 * @return 返回一个Result对象，即iSysAreaService的findAreaTree方法返回的Result对象，其中包含了查询区域树信息的结果相关信息（如状态码、提示信息以及查询到的区域树结构数据等内容），通过@ResponseBody注解将Result对象转换为合适的格式（如JSON格式等，具体取决于项目配置）返回给前端，
+	 * 供前端根据返回结果进行相应的展示和后续处理操作，比如根据状态码判断查询是否成功，然后利用返回的数据在页面上渲染展示区域树结构给用户查看。
+	 */
 	@RequestMapping(value = {"area/findAreaTree.html"}, method = RequestMethod.GET)
 	@ResponseBody
 	public Result findAreaTree() {
 		return iSysAreaService.findAreaTree();
 	}
-	
+}
-	
-}

tamguo-tms/src/main/java/com/tamguo/web/tiku/CourseController.java

@@ -27,57 +27,129 @@ import com.tamguo.utils.BrowserUtils;
 
 /**
  * Controller - 科目
- * 
+ * 这个类主要作为Spring MVC的控制器，用于处理与课程相关的各种HTTP请求，
+ * 通过调用不同的业务服务层接口来获取相应的数据，并根据请求的情况返回视图或者数据响应给客户端，
+ * 例如展示课程相关页面以及查询课程对应的章节信息等功能。
+ *
  * @author tamguo
  *
  */
 @Controller
 public class CourseController {
-	
+
+	// 创建一个日志记录器对象，用于记录在这个控制器类中发生的一些关键操作、调试信息或者错误信息等，
+	// 通过LoggerFactory根据当前类的Class对象获取对应的Logger实例，方便后续在代码中进行日志输出操作，便于调试和查看运行情况。
 	private Logger logger = LoggerFactory.getLogger(getClass());
+
+	// 通过@Autowired注解自动注入IChapterService接口的实现类实例，IChapterService用于处理与章节相关的各种业务逻辑，
+	// 比如查询章节树结构、根据课程ID获取章节信息等操作，在这个控制器的相关方法中会调用其相关方法来实现具体的章节相关业务功能。
 	@Autowired
 	IChapterService iChapterService;
+
+	// 自动注入ICourseService接口的实现类实例，ICourseService主要负责处理与课程相关的业务逻辑，
+	// 像根据课程ID查询课程信息、获取某个学科下的课程列表等操作都会调用它的相应方法来完成。
 	@Autowired
 	ICourseService iCourseService;
+
+	// 注入ISubjectService接口的实现类实例，ISubjectService用于处理与学科（科目）相关的业务逻辑，
+	// 例如根据学科ID查询学科详细信息等操作，在课程相关操作中，可能需要获取所属学科的相关信息来完善页面展示等功能，会用到该服务层接口的方法。
 	@Autowired
 	ISubjectService iSubjectService;
+
+	// 注入IKnowPointService接口的实现类实例，IKnowPointService用于处理知识点相关的业务逻辑，
+	// 比如根据课程ID查询对应的知识点列表等操作，在构建课程相关页面数据时，会涉及到知识点相关信息的获取与处理，会调用其相应方法。
 	@Autowired
 	IKnowPointService knowPointService;
 
+	/**
+	 * 处理课程详情页面的GET请求，请求路径为"course/{uid}.html"，其中{uid}是一个路径变量，表示课程的唯一标识，
+	 * 该方法用于获取课程相关的详细信息以及与之关联的其他数据（如知识点列表、章节列表、所属学科信息、同学科下的课程列表等），
+	 * 根据请求头中用户代理信息判断是否是移动端访问，来设置不同的视图名称，最后将获取到的数据添加到ModelAndView对象中返回，供Spring MVC框架渲染相应的视图展示给客户端。
+	 *
+	 * @param request HttpServletRequest对象，用于获取请求相关的各种信息，在这里主要是获取请求的URI（通过request.getRequestURI()方法）记录日志，
+	 *                以及获取请求头中的"user-agent"信息传递给BrowserUtils工具类判断是否是移动端访问，从而决定返回的视图名称等操作。
+	 * @param uid 课程的唯一标识字符串，通过@PathVariable注解从请求路径中获取，用于指定要查询详细信息的具体课程，传递给相关服务层方法作为查询依据，获取课程及其关联的数据信息。
+	 * @param model ModelAndView对象，用于设置视图名称以及向视图传递数据，在这里会将查询到的课程相关的各种数据（章节列表、课程列表、课程本身、所属学科、知识点列表、知识点等）添加到该对象中，
+	 *              然后根据设备类型设置合适的视图名称，最后返回该对象供Spring MVC框架进行视图渲染并展示课程详情页面给客户端。
+	 * @return 返回配置好视图名称和课程相关数据的ModelAndView对象，供Spring MVC框架根据视图名称渲染并展示课程详情页面给客户端，展示相应的课程信息以及关联数据给用户查看。
+	 */
 	@SuppressWarnings("unchecked")
 	@RequestMapping(value = {"course/{uid}.html"}, method = RequestMethod.GET)
-	public ModelAndView index(HttpServletRequest request , @PathVariable String uid , ModelAndView model) {
+	public ModelAndView index(HttpServletRequest request, @PathVariable String uid, ModelAndView model) {
-		// request url 
+		// 使用日志记录器记录请求的URL信息，方便后续查看请求访问情况以及进行调试等操作，通过格式化输出的方式将请求的URI信息记录到日志中，
-		logger.info("request url :{}" , request.getRequestURI());
+		// 输出的日志级别为INFO，通常用于记录一些重要的运行时信息，方便运维人员或者开发人员了解系统的访问情况。
+		logger.info("request url :{}", request.getRequestURI());
+
+		// 调用iCourseService的selectById方法，传入课程的唯一标识（uid）作为参数，从数据库等数据源中查询对应的课程详细信息（以CourseEntity对象形式返回），
+		// 获取到的课程信息后续会添加到ModelAndView对象中传递给视图进行展示，例如展示课程名称、课程简介等相关内容。
 		CourseEntity course = iCourseService.selectById(uid);
+
+		// 调用knowPointService的selectList方法，通过MyBatis Plus的条件构造器Condition创建查询条件，
+		// 使用eq("course_id", uid)表示筛选出课程ID等于当前传入课程唯一标识（uid）的知识点列表，获取与该课程相关的所有知识点信息（以List<KnowPointEntity>形式返回），
+		// 这些知识点信息同样会添加到ModelAndView对象中，方便在视图中展示课程包含的知识点情况，比如在页面上列出知识点名称等相关内容。
 		List<KnowPointEntity> knowPointList = knowPointService.selectList(Condition.create().eq("course_id", uid));
+
+		// 初始化章节列表为null，后续会根据知识点情况来确定章节列表的值，如果有对应的知识点存在，会进一步查询相关章节信息进行赋值。
 		List<ChapterEntity> chapterList = null;
 		KnowPointEntity knowPoint = null;
-		if(knowPointList.size() > 0) {
+
+		// 判断知识点列表的大小是否大于0，即是否存在与当前课程相关的知识点，
+		// 如果存在知识点，说明可以基于知识点进一步获取与之关联的章节信息等内容，进行后续的数据准备操作。
+		if (knowPointList.size() > 0) {
+			// 从知识点列表中获取第一个知识点对象（这里假设可以基于第一个知识点来获取相关章节信息，具体业务逻辑可能根据实际情况而定），
+			// 获取这个知识点对象主要是为了获取其ID，作为查询章节树结构的依据，获取与该知识点相关联的章节信息。
 			knowPoint = knowPointList.get(0);
+			// 调用iChapterService的findChapterTree方法，传入获取到的知识点的ID作为参数，查询与该知识点相关的章节树结构信息（以List<ChapterEntity>形式返回），
+			// 章节树结构信息可能是一种层级嵌套的数据结构，方便在页面上以树状形式展示章节的层级关系等情况，获取到的章节列表信息会赋值给chapterList变量，后续添加到ModelAndView对象中用于视图展示。
 			chapterList = iChapterService.findChapterTree(knowPoint.getId());
 		}
+
+		// 调用iSubjectService的selectById方法，传入课程对象中的学科ID（course.getSubjectId()）作为参数，从数据库等数据源中查询对应的学科详细信息（以SubjectEntity对象形式返回），
+		// 获取学科信息是为了在课程详情页面展示该课程所属的学科相关情况，例如学科名称等内容，将学科信息添加到ModelAndView对象中传递给视图进行展示。
 		SubjectEntity subject = iSubjectService.selectById(course.getSubjectId());
+
+		// 调用iCourseService的selectList方法，通过MyBatis Plus的条件构造器构建查询条件，
+		// 使用eq("subject_id", course.getSubjectId())表示筛选出学科ID等于当前课程所属学科ID的课程列表，再通过orderAsc(Arrays.asList("sort"))按照"sort"字段升序排序课程列表，
+		// 获取与当前课程同属一个学科的其他课程列表信息（以List<CourseEntity>形式返回），用于在课程详情页面展示同学科下的其他课程情况，比如在页面上提供相关课程的导航链接等情况，将课程列表信息添加到ModelAndView对象中。
 		List<CourseEntity> courseList = iCourseService.selectList(Condition.create().eq("subject_id", course.getSubjectId()).orderAsc(Arrays.asList("sort")));
-		
+
+		// 将查询到的章节列表信息添加到ModelAndView对象中，设置属性名为"chapterList"，方便在视图中通过这个属性名获取章节列表数据进行展示，例如循环展示章节名称等相关内容。
 		model.addObject("chapterList", chapterList);
+		// 同样将同学科下的课程列表信息添加到ModelAndView对象中，属性名为"courseList"，以便在视图中展示相关课程信息，为用户提供更多课程相关的导航或参考信息。
 		model.addObject("courseList", courseList);
+		// 将查询到的当前课程的详细信息添加到ModelAndView对象中，属性名为"course"，方便在视图中展示课程的各种详细内容，如课程名称、简介等信息。
 		model.addObject("course", course);
+		// 把查询到的课程所属学科的详细信息添加到ModelAndView对象中，属性名为"subject"，用于在视图中展示学科相关情况，例如学科名称等内容，让用户了解课程所属的学科背景。
 		model.addObject("subject", subject);
+		// 将获取到的与当前课程相关的知识点列表信息添加到ModelAndView对象中，属性名为"knowPointList"，方便在视图中展示课程包含的知识点情况，例如列出知识点名称等内容。
 		model.addObject("knowPointList", knowPointList);
-		model.addObject("knowPoint" , knowPoint);
+		// 把前面获取到的知识点对象（如果存在的话）添加到ModelAndView对象中，属性名为"knowPoint"，在视图中可能用于展示某个特定知识点相关的详细信息或者作为关联其他数据的依据等情况（具体取决于视图的业务逻辑设计）。
-		if(BrowserUtils.isMobile(request.getHeader("user-agent"))) {
+		model.addObject("knowPoint", knowPoint);
-    		model.setViewName("mobile/chapter");
+
-    	}else {
+		// 通过BrowserUtils工具类的isMobile方法判断请求头中的"user-agent"信息是否表示当前访问是来自移动端设备，
-    		model.setViewName("chapter");
+		// 如果是移动端访问，设置ModelAndView的视图名称为"mobile/chapter"，表示返回移动端对应的章节相关视图页面（具体视图页面的内容和样式由对应的前端页面模板决定）；
-    	}
+		// 如果不是移动端访问，设置视图名称为"chapter"，表示返回普通桌面端等设备对应的章节相关视图页面，根据不同设备类型展示合适的页面给用户查看。
+		if (BrowserUtils.isMobile(request.getHeader("user-agent"))) {
+			model.setViewName("mobile/chapter");
+		} else {
+			model.setViewName("chapter");
+		}
+
 		return model;
 	}
-	
+
+	/**
+	 * 处理根据课程ID查询章节信息的GET请求，请求路径为"course/findChapter.html"，用于获取指定课程下的章节信息，
+	 * 通过调用iChapterService的findCourseChapter方法，传入课程ID（courseId）作为参数进行查询操作，然后将查询到的章节信息（以List<ChapterEntity>形式返回）直接返回给前端，
+	 * 前端可以根据返回的章节列表数据进行相应的展示和后续处理，比如在页面上展示课程章节列表等情况。
+	 *
+	 * @param courseId 课程的唯一标识字符串，从请求参数中获取，用于指定要查询章节信息所属的课程，传递给iChapterService的findCourseChapter方法作为查询依据，获取对应的章节信息。
+	 * @return 返回一个List<ChapterEntity>类型的结果，即iChapterService的findCourseChapter方法返回的章节信息列表，包含了指定课程下的所有章节实体对象，
+	 * 通过@ResponseBody注解将这个列表转换为合适的格式（如JSON格式等，具体取决于项目配置）返回给前端，供前端根据返回结果进行相应的展示和后续处理操作，例如在页面上循环展示章节名称等相关内容。
+	 */
 	@RequestMapping(value = {"course/findChapter.html"}, method = RequestMethod.GET)
 	@ResponseBody
-	public List<ChapterEntity> findChapterByCourseId(String courseId){
+	public List<ChapterEntity> findChapterByCourseId(String courseId) {
 		return iChapterService.findCourseChapter(courseId);
 	}
-	
+}
-}

tamguo-tms/src/main/java/com/tamguo/web/tiku/IndexController.java

@@ -11,57 +11,117 @@ import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.servlet.ModelAndView;
 
 import com.tamguo.modules.tiku.model.ChapterEntity;
-
 import com.tamguo.modules.tiku.model.queue.LearnChapterQueue;
 import com.tamguo.utils.BrowserUtils;
 
+// @Controller注解用于将这个类标记为Spring MVC框架中的一个控制器组件，意味着Spring容器会在启动时扫描到这个类，并将其管理起来，
+// 使得这个类中的方法能够处理对应的HTTP请求，根据请求的映射关系（通过@RequestMapping等注解定义）调用相应的业务逻辑方法，然后返回视图或者数据响应给客户端，
+// 在这里主要用于处理多个不同页面相关的请求，包括首页、第三方验证页面以及错误页面等的展示逻辑。
 @Controller
 public class IndexController {
-	
+
-	private Logger logger = LoggerFactory.getLogger(getClass());
+    // 创建一个日志记录器对象，用于记录在这个控制器类中发生的一些关键操作、调试信息或者错误信息等，
-	
+    // 通过LoggerFactory根据当前类的Class对象获取对应的Logger实例，方便后续在代码中进行日志输出操作，便于调试和查看运行情况。
-	@RequestMapping(value = {"/","index"}, method = RequestMethod.GET)
+    private Logger logger = LoggerFactory.getLogger(getClass());
-    public ModelAndView indexAction(ModelAndView model , HttpServletRequest request) {
+
-		// request url 
+    /**
-		logger.info("request url :{}" , request.getRequestURI());
+     * 处理网站首页（根路径"/"或者"index"）的GET请求，用于展示网站的首页内容，
-		BlockingQueue<ChapterEntity> chapterQueue = LearnChapterQueue.getChapterQueue();
+     * 该方法会获取一个章节队列（BlockingQueue<ChapterEntity>）中的数据，添加到ModelAndView对象中作为页面展示的数据，
-		model.addObject("chapterList", chapterQueue.toArray());
+     * 同时根据请求头中用户代理信息判断是否是移动端访问，来设置不同的视图名称，最后返回ModelAndView对象供Spring MVC框架渲染相应的视图展示给客户端。
-    	if(BrowserUtils.isMobile(request.getHeader("user-agent"))) {
+     *
-    		model.setViewName("mobile/index");
+     * @param model ModelAndView对象，用于设置视图名称以及向视图传递数据，在这里会将章节队列中的数据添加到该对象中，然后根据设备类型设置合适的视图名称，最后返回该对象供Spring MVC框架进行视图渲染并展示首页给客户端。
-    	}else {
+     * @param request HttpServletRequest对象，用于获取请求相关的各种信息，在这里主要是获取请求的URI（通过request.getRequestURI()方法）记录日志，
-    		model.setViewName("index");
+     *                以及获取请求头中的"user-agent"信息传递给BrowserUtils工具类判断是否是移动端访问，从而决定返回的视图名称等操作。
-    	}
+     * @return 返回配置好视图名称和章节队列数据（转换为数组形式）的ModelAndView对象，供Spring MVC框架根据视图名称渲染并展示首页给客户端，展示相应的章节相关信息（具体展示内容取决于前端页面如何处理该数据）给用户查看。
+     */
+    @RequestMapping(value = {"/", "index"}, method = RequestMethod.GET)
+    public ModelAndView indexAction(ModelAndView model, HttpServletRequest request) {
+        // 使用日志记录器记录请求的URL信息，方便后续查看请求访问情况以及进行调试等操作，通过格式化输出的方式将请求的URI信息记录到日志中，
+        // 输出的日志级别为INFO，通常用于记录一些重要的运行时信息，方便运维人员或者开发人员了解系统的访问情况。
+        logger.info("request url :{}", request.getRequestURI());
+
+        // 从LearnChapterQueue类中获取章节队列对象（BlockingQueue<ChapterEntity>），这个队列可能是用于存储学习相关章节信息的一种数据结构，
+        // 后续会将队列中的数据添加到ModelAndView对象中传递给视图进行展示，具体展示方式取决于前端页面如何处理这些章节数据（例如可能展示章节列表等情况）。
+        BlockingQueue<ChapterEntity> chapterQueue = LearnChapterQueue.getChapterQueue();
+
+        // 将章节队列中的数据转换为数组形式，添加到ModelAndView对象中，设置属性名为"chapterList"，方便在视图中通过这个属性名获取章节相关数据进行展示，
+        // 例如在首页上循环展示章节名称等相关内容（具体展示逻辑由前端页面模板决定）。
+        model.addObject("chapterList", chapterQueue.toArray());
+
+        // 通过BrowserUtils工具类的isMobile方法判断请求头中的"user-agent"信息是否表示当前访问是来自移动端设备，
+        // 如果是移动端访问，设置ModelAndView的视图名称为"mobile/index"，表示返回移动端对应的首页视图页面（具体视图页面的内容和样式由对应的前端页面模板决定）；
+        // 如果不是移动端访问，设置视图名称为"index"，表示返回普通桌面端等设备对应的首页视图页面，根据不同设备类型展示合适的首页内容给用户查看。
+        if (BrowserUtils.isMobile(request.getHeader("user-agent"))) {
+            model.setViewName("mobile/index");
+        } else {
+            model.setViewName("index");
+        }
+
         return model;
     }
-    
+
+    /**
+     * 处理百度验证页面（"baidu_verify_5agfTbCO3Q"）的GET请求，该页面可能是用于百度搜索引擎对网站进行验证等相关操作的特定页面，
+     * 此方法仅简单地设置要返回的视图名称为"thirdparty/baidu_verify_5agfTbCO3Q"，使得Spring MVC框架能够渲染对应的验证页面展示给客户端，暂未涉及其他复杂的数据传递等操作。
+     *
+     * @param model ModelAndView对象，用于设置视图名称，在这里将视图名称设置为"thirdparty/baidu_verify_5agfTbCO3Q"，指定要返回的页面视图，方便Spring MVC框架进行后续的视图渲染操作。
+     * @return 返回配置好视图名称的ModelAndView对象，供Spring MVC框架根据视图名称渲染并展示百度验证页面（"baidu_verify_5agfTbCO3Q"）给客户端。
+     */
     @RequestMapping(value = "/baidu_verify_5agfTbCO3Q", method = RequestMethod.GET)
     public ModelAndView baidu_verify_5agfTbCO3Q(ModelAndView model) {
-    	model.setViewName("thirdparty/baidu_verify_5agfTbCO3Q");
+        model.setViewName("thirdparty/baidu_verify_5agfTbCO3Q");
         return model;
     }
-    
+
+    /**
+     * 处理另一个百度验证页面（"baidu_verify_iAm7387J0l"）的GET请求，与上一个百度验证页面类似，也是用于百度搜索引擎相关验证操作的特定页面，
+     * 同样只是设置视图名称为"thirdparty/baidu_verify_iAm7387J0l"，以便Spring MVC框架渲染对应的页面展示给客户端，没有其他复杂的数据处理逻辑。
+     *
+     * @param model ModelAndView对象，用于设置视图名称，在这里将视图名称设置为"thirdparty/baidu_verify_iAm7387J0l"，指定要返回的页面视图，方便Spring MVC框架进行后续的视图渲染操作。
+     * @return 返回配置好视图名称的ModelAndView对象，供Spring MVC框架根据视图名称渲染并展示百度验证页面（"baidu_verify_iAm7387J0l"）给客户端。
+     */
     @RequestMapping(value = "/baidu_verify_iAm7387J0l", method = RequestMethod.GET)
     public ModelAndView baidu_verify_iAm7387J0l(ModelAndView model) {
-    	model.setViewName("thirdparty/baidu_verify_iAm7387J0l");
+        model.setViewName("thirdparty/baidu_verify_iAm7387J0l");
         return model;
     }
-    
+
+    /**
+     * 处理搜狗网站验证页面（"sogousiteverification"）的GET请求，该页面大概率是用于搜狗搜索引擎对网站进行验证等相关操作的特定页面，
+     * 方法中仅设置视图名称为"thirdparty/sogousiteverification"，供Spring MVC框架渲染对应的页面展示给客户端，不涉及复杂的数据传递与处理操作。
+     *
+     * @param model ModelAndView对象，用于设置视图名称，在这里将视图名称设置为"thirdparty/sogousiteverification"，指定要返回的页面视图，方便Spring MVC框架进行后续的视图渲染操作。
+     * @return 返回配置好视图名称的ModelAndView对象，供Spring MVC框架根据视图名称渲染并展示搜狗网站验证页面给客户端。
+     */
     @RequestMapping(value = "/sogousiteverification", method = RequestMethod.GET)
     public ModelAndView sogousiteverification(ModelAndView model) {
-    	model.setViewName("thirdparty/sogousiteverification");
+        model.setViewName("thirdparty/sogousiteverification");
         return model;
     }
-	
+
-	@RequestMapping(value = "error404", method = RequestMethod.GET)
+    /**
+     * 处理404错误页面的GET请求，用于展示当用户访问不存在的页面等情况时的404错误提示页面，
+     * 此方法简单地设置要返回的视图名称为"404"，使得Spring MVC框架能够渲染对应的错误页面展示给客户端，告知用户请求的页面不存在。
+     *
+     * @param model ModelAndView对象，用于设置视图名称，在这里将视图名称设置为"404"，指定要返回的页面视图，方便Spring MVC框架进行后续的视图渲染操作。
+     * @return 返回配置好视图名称的ModelAndView对象，供Spring MVC框架根据视图名称渲染并展示404错误页面给客户端，提示用户所访问的页面不存在。
+     */
+    @RequestMapping(value = "error404", method = RequestMethod.GET)
     public ModelAndView error404(ModelAndView model) {
-    	model.setViewName("404");
+        model.setViewName("404");
         return model;
     }
 
-	@RequestMapping(value = "error500", method = RequestMethod.GET)
+    /**
+     * 处理500错误页面的GET请求，用于展示当服务器内部出现错误等情况时的500错误提示页面，
+     * 该方法仅仅设置视图名称为"500"，让Spring MVC框架渲染对应的错误页面展示给客户端，告知用户服务器出现了内部错误情况。
+     *
+     * @param model ModelAndView对象，用于设置视图名称，在这里将视图名称设置为"500"，指定要返回的页面视图，方便Spring MVC框架进行后续的视图渲染操作。
+     * @return 返回配置好视图名称的ModelAndView对象，供Spring MVC框架根据视图名称渲染并展示500错误页面给客户端，提示用户服务器发生了内部错误。
+     */
+    @RequestMapping(value = "error500", method = RequestMethod.GET)
     public ModelAndView error500(ModelAndView model) {
-    	model.setViewName("500");
+        model.setViewName("500");
         return model;
     }
-	
+}
-}

tamguo-tms/src/main/java/com/tamguo/web/tiku/KnowPointController.java

@@ -24,38 +24,96 @@ import com.tamguo.modules.tiku.service.IChapterService;
 import com.tamguo.modules.tiku.service.ICourseService;
 import com.tamguo.modules.tiku.service.ISubjectService;
 
+// @Controller注解用于将这个类标记为Spring MVC框架中的一个控制器组件，意味着Spring容器会在启动时扫描到这个类，并将其管理起来，
+// 使得这个类中的方法能够处理对应的HTTP请求，根据请求的映射关系（通过@RequestMapping等注解定义）调用相应的业务逻辑方法，然后返回视图或者数据响应给客户端，
+// 在这里主要用于处理与知识点相关的业务操作，具体为展示知识点详情页面以及获取相关联的数据信息等功能对应的请求处理逻辑。
 @Controller
 public class KnowPointController {
 
+	// 创建一个日志记录器对象，用于记录在这个控制器类中发生的一些关键操作、调试信息或者错误信息等，
+	// 通过LoggerFactory根据当前类的Class对象获取对应的Logger实例，方便后续在代码中进行日志输出操作，便于调试和查看运行情况。
 	private Logger logger = LoggerFactory.getLogger(getClass());
+
+	// 通过@Autowired注解自动注入IKnowPointService接口的实现类实例，IKnowPointService用于处理与知识点相关的各种业务逻辑，
+	// 比如根据知识点ID查询知识点详细信息、获取某个课程下的知识点列表等操作，在这个控制器的index方法中会调用其相关方法来实现具体的知识点相关业务功能。
 	@Autowired
 	IKnowPointService iKnowPointService;
+
+	// 自动注入IChapterService接口的实现类实例，IChapterService用于处理与章节相关的各种业务逻辑，
+	// 例如查询章节树结构等操作，在知识点详情页面展示时，可能需要获取与知识点相关联的章节信息进行展示，会调用其相应方法来获取相关章节数据。
 	@Autowired
 	IChapterService iChapterService;
+
+	// 注入ISubjectService接口的实现类实例，ISubjectService用于处理与学科（科目）相关的业务逻辑，
+	// 像根据学科ID查询学科详细信息等操作，在知识点详情页面展示时，会获取知识点所属学科的相关信息进行展示，需要调用该服务层接口的方法来获取学科数据。
 	@Autowired
 	ISubjectService iSubjectService;
+
+	// 注入ICourseService接口的实现类实例，ICourseService主要负责处理与课程相关的业务逻辑，
+	// 比如根据课程ID查询课程信息、获取某个学科下的课程列表等操作，在知识点详情页面展示相关数据时，也会涉及到课程相关信息的获取与展示，会调用它的相应方法来完成。
 	@Autowired
 	ICourseService iCourseService;
-	
+
+	/**
+	 * 处理知识点详情页面的GET请求，请求路径为"knowpoint/{uid}.html"，其中{uid}是一个路径变量，表示知识点的唯一标识，
+	 * 该方法用于获取知识点相关的详细信息以及与之关联的其他数据（如所属学科、相关课程、同课程下的其他知识点、相关章节等），
+	 * 将获取到的数据添加到ModelAndView对象中，并设置相应的视图名称为"knowpoint"，最后返回ModelAndView对象供Spring MVC框架渲染视图展示给客户端，展示知识点详情及其关联数据给用户查看。
+	 *
+	 * @param uid 知识点的唯一标识字符串，通过@PathVariable注解从请求路径中获取，用于指定要查询详细信息的具体知识点，传递给相关服务层方法作为查询依据，获取知识点及其关联的数据信息。
+	 * @param model ModelAndView对象，用于设置视图名称以及向视图传递数据，在这里会将查询到的知识点相关的各种数据（知识点本身、所属学科、相关课程、章节列表、同课程下的知识点列表等）添加到该对象中，
+	 *              然后设置视图名称为"knowpoint"，最后返回该对象供Spring MVC框架进行视图渲染并展示知识点详情页面给客户端。
+	 * @param request HttpServletRequest对象，用于获取请求相关的各种信息，在这里主要是获取请求的URI（通过request.getRequestURI()方法）记录日志，方便后续查看请求访问情况以及进行调试等操作。
+	 * @return 返回配置好视图名称和知识点相关数据的ModelAndView对象，供Spring MVC框架根据视图名称渲染并展示知识点详情页面给客户端，展示相应的知识点信息以及关联数据给用户查看。
+	 */
 	@SuppressWarnings("unchecked")
 	@RequestMapping(value = {"knowpoint/{uid}.html"}, method = RequestMethod.GET)
-	public ModelAndView index(@PathVariable String uid , ModelAndView model , HttpServletRequest request) {
+	public ModelAndView index(@PathVariable String uid, ModelAndView model, HttpServletRequest request) {
-		// request url 
+		// 使用日志记录器记录请求的URL信息，方便后续查看请求访问情况以及进行调试等操作，通过格式化输出的方式将请求的URI信息记录到日志中，
-		logger.info("request url :{} " , request.getRequestURI());
+		// 输出的日志级别为INFO，通常用于记录一些重要的运行时信息，方便运维人员或者开发人员了解系统的访问情况。
+		logger.info("request url :{} ", request.getRequestURI());
+
+		// 调用iKnowPointService的selectById方法，传入知识点的唯一标识（uid）作为参数，从数据库等数据源中查询对应的知识点详细信息（以KnowPointEntity对象形式返回），
+		// 获取到的知识点信息后续会添加到ModelAndView对象中传递给视图进行展示，例如展示知识点名称、描述等相关内容。
 		KnowPointEntity knowpoint = iKnowPointService.selectById(uid);
+
+		// 调用iSubjectService的selectById方法，传入知识点对象中的学科ID（knowpoint.getSubjectId()）作为参数，从数据库等数据源中查询对应的学科详细信息（以SubjectEntity对象形式返回），
+		// 获取学科信息是为了在知识点详情页面展示该知识点所属的学科相关情况，例如学科名称等内容，将学科信息添加到ModelAndView对象中传递给视图进行展示。
 		SubjectEntity subject = iSubjectService.selectById(knowpoint.getSubjectId());
+
+		// 调用iCourseService的selectList方法，通过MyBatis Plus的条件构造器Condition创建查询条件，
+		// 使用eq("subject_id", subject.getId())表示筛选出学科ID等于当前知识点所属学科ID的课程列表，再通过orderAsc(Arrays.asList("sort"))按照"sort"字段升序排序课程列表，
+		// 获取与该知识点所属学科相关的课程列表信息（以List<CourseEntity>形式返回），用于在知识点详情页面展示同属一个学科下的其他课程情况，比如在页面上提供相关课程的导航链接等情况，将课程列表信息添加到ModelAndView对象中。
 		List<CourseEntity> courseList = iCourseService.selectList(Condition.create().eq("subject_id", subject.getId()).orderAsc(Arrays.asList("sort")));
+
+		// 调用iKnowPointService的selectList方法，通过条件构造器构建查询条件，
+		// 使用eq("course_id", knowpoint.getCourseId())表示筛选出课程ID等于当前知识点所属课程ID的知识点列表，获取与该知识点同属一个课程的其他知识点信息（以List<KnowPointEntity>形式返回），
+		// 这些知识点信息会添加到ModelAndView对象中，方便在知识点详情页面展示同课程下的其他知识点情况，例如在页面上列出其他知识点名称等相关内容。
 		List<KnowPointEntity> knowPointList = iKnowPointService.selectList(Condition.create().eq("course_id", knowpoint.getCourseId()));
+
+		// 调用iCourseService的selectById方法，传入知识点对象中的课程ID（knowpoint.getCourseId()）作为参数，从数据库等数据源中查询对应的课程详细信息（以CourseEntity对象形式返回），
+		// 获取课程信息是为了在知识点详情页面展示该知识点所属的课程相关情况，例如课程名称等内容，将课程信息添加到ModelAndView对象中传递给视图进行展示。
 		CourseEntity course = iCourseService.selectById(knowpoint.getCourseId());
+
+		// 调用iChapterService的findChapterTree方法，传入知识点的ID（knowpoint.getId()）作为参数，查询与该知识点相关的章节树结构信息（以List<ChapterEntity>形式返回），
+		// 章节树结构信息可能是一种层级嵌套的数据结构，方便在页面上以树状形式展示章节的层级关系等情况，获取到的章节列表信息会添加到ModelAndView对象中用于视图展示。
 		List<ChapterEntity> chapterList = iChapterService.findChapterTree(knowpoint.getId());
+
+		// 将查询到的知识点详细信息添加到ModelAndView对象中，设置属性名为"knowpoint"，方便在视图中通过这个属性名获取知识点的各种详细内容进行展示，如知识点名称、描述等信息。
 		model.addObject("knowpoint", knowpoint);
+		// 把查询到的知识点所属学科的详细信息添加到ModelAndView对象中，属性名为"subject"，用于在视图中展示学科相关情况，例如学科名称等内容，让用户了解知识点所属的学科背景。
 		model.addObject("subject", subject);
+		// 将获取到的知识点所属课程的详细信息添加到ModelAndView对象中，属性名为"course"，方便在视图中展示课程相关情况，例如课程名称等信息。
 		model.addObject("course", course);
-		model.addObject("chapterList" , chapterList);
+		// 把查询到的与知识点相关的章节列表信息添加到ModelAndView对象中，属性名为"chapterList"，方便在视图中展示章节相关信息，例如以树状结构展示章节层级关系等情况。
+		model.addObject("chapterList", chapterList);
+		// 将同属一个学科下的课程列表信息添加到ModelAndView对象中，属性名为"courseList"，以便在视图中展示相关课程信息，为用户提供更多课程相关的导航或参考信息。
 		model.addObject("courseList", courseList);
+		// 把获取到的同课程下的其他知识点列表信息添加到ModelAndView对象中，属性名为"knowPointList"，方便在视图中展示其他知识点情况，例如列出知识点名称等内容。
 		model.addObject("knowPointList", knowPointList);
+
+		// 设置ModelAndView的视图名称为"knowpoint"，表示返回名为"knowpoint"的视图页面，供Spring MVC框架根据这个视图名称进行视图渲染并展示知识点详情页面给客户端，展示相应的知识点及其关联数据给用户查看。
 		model.setViewName("knowpoint");
+
 		return model;
 	}
-	
+}
-}

tamguo-tms/src/main/java/com/tamguo/web/tiku/PaperController.java

@@ -30,113 +30,156 @@ import java.util.List;
 
 /**
  * Controller - 试卷
- * 
+ * 这个类主要作为Spring MVC的控制器，用于处理与试卷相关的各种HTTP请求，
+ * 通过调用不同的业务服务层接口来获取相应的数据，进行分页处理、条件筛选等操作，
+ * 并根据请求的情况返回视图或者数据响应给客户端，例如展示试卷列表页面以及试卷详情页面等功能。
+ *
  * @author candy.tam
  *
  */
 @Controller
 public class PaperController {
-	
+
+	// 创建一个日志记录器对象，用于记录在这个控制器类中发生的一些关键操作、调试信息或者错误信息等，
+	// 通过LoggerFactory根据当前类的Class对象获取对应的Logger实例，方便后续在代码中进行日志输出操作，便于调试和查看运行情况。
 	private Logger logger = LoggerFactory.getLogger(getClass());
-	
+
+	// 通过@Autowired注解自动注入ICourseService接口的实现类实例，ICourseService用于处理与课程相关的各种业务逻辑，
+	// 比如根据课程ID查询课程信息、获取某个学科下的课程列表等操作，在试卷相关操作中（如试卷列表页面展示时关联课程信息等情况）会调用其相关方法来实现具体的课程相关业务功能。
 	@Autowired
 	private ICourseService iCourseService;
+
+	// 注入ISysAreaService接口的实现类实例，ISysAreaService用于处理与系统区域相关的业务逻辑，
+	// 例如根据区域ID查询区域信息、获取特定层级的区域列表等操作，在试卷相关业务中（可能涉及按区域筛选试卷等情况）会用到该服务层接口的方法来获取区域相关数据。
 	@Autowired
 	private ISysAreaService iSysAreaService;
+
+	// 自动注入IPaperService接口的实现类实例，IPaperService主要负责处理与试卷相关的业务逻辑，
+	// 像根据试卷ID查询试卷信息、获取符合特定条件的试卷列表（分页查询并结合各种筛选条件）、查找试卷包含的题目信息等操作都会调用它的相应方法来完成。
 	@Autowired
 	private IPaperService iPaperService;
+
+	// 注入IQuestionService接口的实现类实例，IQuestionService用于处理与题目相关的业务逻辑，
+	// 在试卷详情页面展示时，需要获取试卷包含的题目列表进行展示，会调用其相关方法来获取题目相关数据。
 	@Autowired
 	private IQuestionService iQuestionService;
+
+	// 注入ISubjectService接口的实现类实例，ISubjectService用于处理与学科（科目）相关的业务逻辑，
+	// 例如根据学科ID查询学科详细信息等操作，在试卷相关操作中（如试卷列表页面展示所属学科信息、试卷详情页面关联学科信息等情况）会调用该服务层接口的方法来获取学科数据。
 	@Autowired
 	private ISubjectService iSubjectService;
 
+	/**
+	 * 处理试卷列表页面的GET请求，请求路径格式为"paperlist/{subjectId}-{courseId}-{paperType}-{year}-{area}-{pageNum}.html"，
+	 * 其中各个{ }内的参数是路径变量，分别代表学科ID、课程ID、试卷类型、年份、区域、页码，
+	 * 该方法用于获取试卷列表相关的各种数据（如课程信息、区域信息、学科信息、符合条件的试卷分页数据等），
+	 * 根据请求头中用户代理信息判断是否是移动端访问，来设置不同的视图名称，最后将获取到的数据添加到ModelAndView对象中返回，供Spring MVC框架渲染相应的视图展示给客户端。
+	 *
+	 * @param request HttpServletRequest对象，用于获取请求相关的各种信息，在这里主要是获取请求的URI（通过request.getRequestURI()方法）记录日志，
+	 *                以及获取请求头中的"user-agent"信息传递给BrowserUtils工具类判断是否是移动端访问，从而决定返回的视图名称等操作。
+	 * @param subjectId 学科的唯一标识字符串，通过@PathVariable注解从请求路径中获取，用于指定要查询试卷列表所属的学科，传递给相关服务层方法作为查询依据，获取学科及其关联的数据信息，例如筛选该学科下的试卷等操作。
+	 * @param courseId 课程的唯一标识字符串，同样是路径变量，用于指定要查询试卷列表相关的课程，传递给服务层方法查询课程信息以及筛选该课程相关的试卷等操作，获取相应的课程数据以及符合课程关联条件的试卷信息。
+	 * @param paperType 试卷类型的标识字符串，从请求路径中获取，用于筛选特定类型的试卷，传递给条件构造器来构建查询条件，获取符合该类型要求的试卷列表信息，例如只查询真题、模拟题等不同类型的试卷，具体取决于业务中对试卷类型的分类和使用方式。
+	 * @param year 年份字符串，用于筛选特定年份的试卷，作为查询条件之一传递给服务层构建查询条件，以便获取对应年份的试卷列表信息，例如查询2023年的试卷等情况。
+	 * @param area 区域的标识字符串，从请求路径中获取，用于指定区域相关的筛选条件，传递给服务层方法查询对应区域信息以及筛选该区域相关的试卷等操作，获取相应的区域数据以及符合区域关联条件的试卷信息。
+	 * @param pageNum 页码整数，通过路径变量获取，表示要查询的试卷列表的页码信息，用于创建Page对象来确定分页查询情况，获取对应页码的数据记录，方便实现试卷列表的分页展示功能。
+	 * @param model ModelAndView对象，用于设置视图名称以及向视图传递数据，在这里会将查询到的课程列表、学科信息、当前课程、区域列表、试卷分页数据、试卷总数等各种试卷相关的数据添加到该对象中，
+	 *              然后根据设备类型设置合适的视图名称，最后返回该对象供Spring MVC框架进行视图渲染并展示试卷列表页面给客户端。
+	 * @return 返回配置好视图名称和试卷相关数据的ModelAndView对象，供Spring MVC框架根据视图名称渲染并展示试卷列表页面给客户端，展示相应的试卷信息以及关联数据给用户查看。
+	 */
 	@SuppressWarnings("unchecked")
 	@RequestMapping(value = {"paperlist/{subjectId}-{courseId}-{paperType}-{year}-{area}-{pageNum}.html"}, method = RequestMethod.GET)
-    public ModelAndView indexAction(HttpServletRequest request , @PathVariable String subjectId , @PathVariable String courseId , @PathVariable String paperType,
+	public ModelAndView indexAction(HttpServletRequest request, @PathVariable String subjectId, @PathVariable String courseId, @PathVariable String paperType,
-    		@PathVariable String year , @PathVariable String area , @PathVariable Integer pageNum, ModelAndView model) {
+									@PathVariable String year, @PathVariable String area, @PathVariable Integer pageNum, ModelAndView model) {
-		// request url 
+		// 使用日志记录器记录请求的URL信息，方便后续查看请求访问情况以及进行调试等操作，通过格式化输出的方式将请求的URI信息记录到日志中，
-		logger.info("request url :{}" , request.getRequestURI());
+		// 输出的日志级别为INFO，通常用于记录一些重要的运行时信息，方便运维人员或者开发人员了解系统的访问情况。
-    	CourseEntity course = iCourseService.selectById(courseId);
+		logger.info("request url :{}", request.getRequestURI());
-    	SysAreaEntity currArea = iSysAreaService.selectById(area);
+
+		// 调用iCourseService的selectById方法，传入课程的唯一标识（courseId）作为参数，从数据库等数据源中查询对应的课程详细信息（以CourseEntity对象形式返回），
+		// 获取到的课程信息后续会添加到ModelAndView对象中传递给视图进行展示，例如展示课程名称、课程简介等相关内容，同时也可能用于其他关联查询或筛选操作（如筛选该课程下的试卷等情况）。
+		CourseEntity course = iCourseService.selectById(courseId);
+
+		// 调用iSysAreaService的selectById方法，传入区域的标识（area）作为参数，从数据库等数据源中查询对应的区域详细信息（以SysAreaEntity对象形式返回），
+		// 获取到的区域信息（在这里命名为currArea，表示当前筛选的区域）会添加到ModelAndView对象中，方便在试卷列表页面展示区域相关情况，例如区域名称等内容，也可能用于后续的筛选或关联操作。
+		SysAreaEntity currArea = iSysAreaService.selectById(area);
+
+		// 调用iCourseService的selectList方法，通过MyBatis Plus的条件构造器Condition创建查询条件，
+		// 使用eq("subject_id", subjectId)表示筛选出学科ID等于当前传入学科ID（subjectId）的课程列表，再通过orderBy("sort", true)按照"sort"字段升序排序课程列表，
+		// 获取与该学科相关的课程列表信息（以List<CourseEntity>形式返回），用于在试卷列表页面展示同属一个学科下的其他课程情况，比如在页面上提供相关课程的导航链接等情况，将课程列表信息添加到ModelAndView对象中。
 		List<CourseEntity> courseList = iCourseService.selectList(Condition.create().eq("subject_id", subjectId).orderBy("sort", true));
-    	SubjectEntity subject = iSubjectService.selectById(subjectId);
+
-    	List<SysAreaEntity> areaList = iSysAreaService.selectList(Condition.create().eq("tree_level", "0"));
+		// 调用iSubjectService的selectById方法，传入学科的唯一标识（subjectId）作为参数，从数据库等数据源中查询对应的学科详细信息（以SubjectEntity对象形式返回），
-    	
+		// 获取学科信息是为了在试卷列表页面展示该试卷列表所属的学科相关情况，例如学科名称等内容，将学科信息添加到ModelAndView对象中传递给视图进行展示。
-    	Page<PaperEntity> page = new Page<>(pageNum , 10);
+		SubjectEntity subject = iSubjectService.selectById(subjectId);
-    	Condition condition = Condition.create();
+
-    	if(!StringUtils.isEmpty(subjectId) && !"0".equals(subjectId)) {
+		// 调用iSysAreaService的selectList方法，通过条件构造器构建查询条件，
-    		condition.eq("subject_id", subjectId);
+		// 使用eq("tree_level", "0")表示筛选出层级为0的区域列表（可能表示顶级区域或者根区域等情况，具体含义由业务中区域层级的定义决定），获取区域列表信息（以List<SysAreaEntity>形式返回），
-    	}
+		// 这些区域列表信息会添加到ModelAndView对象中，方便在试卷列表页面展示可筛选的区域情况，例如提供区域下拉框供用户选择等情况。
-    	if(!StringUtils.isEmpty(paperType) && !"0".equals(paperType)) {
+		List<SysAreaEntity> areaList = iSysAreaService.selectList(Condition.create().eq("tree_level", "0"));
-    		condition.eq("type", paperType);
+
-    	}
+		// 创建一个Page对象，用于进行分页查询操作，传入当前页码（pageNum）和每页显示的记录数量（这里固定为10）来确定分页情况，
-    	if(!StringUtils.isEmpty(courseId) && !"0".equals(courseId)) {
+		// 后续将这个Page对象以及其他构建的查询条件一起传递给iPaperService的selectPage方法进行分页查询符合条件的试卷列表信息。
-    		condition.eq("course_id", courseId);
+		Page<PaperEntity> page = new Page<>(pageNum, 10);
-    	}
+
-    	if(!StringUtils.isEmpty(year) && !"0".equals(year)) {
+		// 创建一个Condition对象，用于构建MyBatis Plus的查询条件，后续根据传入的各个参数情况，往这个条件对象中添加相应的条件，用于筛选符合要求的试卷列表信息。
-    		condition.eq("year", year);
+		Condition condition = Condition.create();
-    	}
+
-    	if(!StringUtils.isEmpty(area) && !"0".equals(area)) {
+		// 判断学科ID是否不为空且不等于"0"（可能"0"表示不进行学科筛选等特殊情况，具体由业务逻辑决定），
-    		condition.eq("area_id", area);
+		// 如果满足条件，使用eq("subject_id", subjectId)向条件对象中添加学科ID的筛选条件，即筛选出学科ID等于传入学科ID的试卷列表信息。
-    	}
+		if (!StringUtils.isEmpty(subjectId) &&!"0".equals(subjectId)) {
-    	PageUtils result = PageUtils.getPage(iPaperService.selectPage(page , condition));
+			condition.eq("subject_id", subjectId);
-    	if(courseList.size() > 0 && course == null) {
+		}
-    		course = courseList.get(0);
+
-    	}
+		// 类似地，判断试卷类型是否不为空且不等于"0"，如果是，则添加试卷类型的筛选条件，筛选出符合该类型要求的试卷列表信息，例如只查询真题、模拟题等不同类型的试卷。
-    	Integer total = iPaperService.selectCount(Condition.EMPTY);
+		if (!StringUtils.isEmpty(paperType) &&!"0".equals(paperType)) {
-    	model.addObject("courseList", courseList);
+			condition.eq("type", paperType);
-    	model.addObject("subject", subject);
+		}
-    	model.addObject("course", course);
+
-    	model.addObject("areaList", areaList);
+		// 判断课程ID是否满足相应条件，若满足则添加课程ID的筛选条件，用于获取该课程相关的试卷信息，例如筛选出属于某个具体课程的试卷列表。
-    	model.addObject("paperPage" , result);
+		if (!StringUtils.isEmpty(courseId) &&!"0".equals(courseId)) {
-    	model.addObject("total" , total);
+			condition.eq("course_id", courseId);
-    	model.addObject("courseId", courseId);
+		}
-    	model.addObject("paperType", paperType);
+
-    	model.addObject("year", year);
+		// 对年份参数进行类似的判断和条件添加操作，筛选出对应年份的试卷列表信息，比如只展示2023年的试卷等情况。
-    	model.addObject("area", area);
+		if (!StringUtils.isEmpty(year) &&!"0".equals(year)) {
-    	model.addObject("currArea", currArea);
+			condition.eq("year", year);
-    	
-
-		if(BrowserUtils.isMobile(request.getHeader("user-agent"))) {
-    		model.setViewName("mobile/paperlist");
-    	}else {
-    		model.setViewName("paperlist");
-    	}
-        return model;
-    }
-	
-	@SuppressWarnings("unchecked")
-	@RequestMapping(value = {"/paper/{paperId}.html"}, method = RequestMethod.GET)
-	public ModelAndView indexAction(HttpServletRequest request , @PathVariable String paperId , ModelAndView model){
-		try {
-			// request url 
-    		logger.info("request url :{}" , request.getRequestURI());
-			model.setViewName("paper");
-			PaperEntity paper = iPaperService.selectById(paperId);
-			model.addObject("paper", paper);
-			model.addObject("subject", StringUtils.isEmpty(paper.getSubjectId()) ? null : iSubjectService.selectById(paper.getSubjectId()));
-			model.addObject("course", StringUtils.isEmpty(paper.getCourseId()) ? null : iCourseService.selectById(paper.getCourseId()));
-
-			// 查询试卷题目
-			model.addObject("questionList", iPaperService.findQuestionList(paperId));
-	    	// 获取推荐试卷
-			model.addObject("zhentiPaperList", iPaperService.selectPage(new Page<PaperEntity>(1, 5) , Condition.create().eq("subject_id", paper.getSubjectId()).eq("type",SystemConstant.ZHENGTI_PAPER_ID)).getRecords());
-			model.addObject("moniPaperList", iPaperService.selectPage(new Page<PaperEntity>(1, 5) , Condition.create().eq("subject_id", paper.getSubjectId()).eq("type",SystemConstant.MONI_PAPER_ID)).getRecords());
-			model.addObject("yatiPaperList", iPaperService.selectPage(new Page<PaperEntity>(1, 5) , Condition.create().eq("subject_id", paper.getSubjectId()).eq("type",SystemConstant.YATI_PAPER_ID)).getRecords());
-			model.addObject("hotPaperList", iPaperService.selectPage(new Page<PaperEntity>(1, 5) , Condition.create().eq("subject_id", paper.getSubjectId()).eq("course_id", paper.getCourseId())).getRecords());
-			
-
-			if(BrowserUtils.isMobile(request.getHeader("user-agent"))) {
-				model.setViewName("mobile/paper");
-			}else {
-				model.setViewName("paper");
-			}
-			return model;
-		} catch (Exception e) {
-			model.setViewName("404");
-			return model;
 		}
-		
+
-	}
+		// 根据区域ID参数情况添加区域筛选条件，获取该区域相关的试卷信息，确保查询到的试卷列表是与指定区域相关的。
-	
+		if (!StringUtils.isEmpty(area) &&!"0".equals(area)) {
-}
+			condition.eq("area_id", area);
+		}
+
+		// 调用PageUtils工具类的getPage方法，传入iPaperService的selectPage方法返回的结果（即分页查询到的试卷列表信息），进行一些分页相关的处理（具体处理逻辑由PageUtils类决定），
+		// 获取处理后的分页数据结果（以PageUtils对象形式返回），包含了分页相关的数据（如总记录数、当前页码、每页记录数等信息以及试卷记录列表等内容），将其添加到ModelAndView对象中，用于在视图中展示试卷列表以及分页相关的情况。
+		PageUtils result = PageUtils.getPage(iPaperService.selectPage(page, condition));
+
+		// 判断课程列表的大小是否大于0且当前课程对象为null（可能存在传入的课程ID对应的课程不存在，但有同学科下的其他课程情况），
+		// 如果满足条件，说明可以从课程列表中取第一个课程作为默认展示的课程（具体业务逻辑可能根据实际情况而定），将其赋值给course变量，后续添加到ModelAndView对象中用于视图展示。
+		if (courseList.size() > 0 && course == null) {
+			course = courseList.get(0);
+		}
+
+		// 调用iPaperService的selectCount方法，传入空的Condition对象（表示不添加额外筛选条件，可能用于获取全部试卷的总数等情况，具体取决于业务逻辑），
+		// 查询试卷的总数量（以整数形式返回），将试卷总数添加到ModelAndView对象中，方便在页面上展示试卷的总数量等相关信息，例如提示用户共有多少份试卷等情况。
+		Integer total = iPaperService.selectCount(Condition.EMPTY);
+
+		// 将查询到的课程列表信息添加到ModelAndView对象中，设置属性名为"courseList"，方便在视图中通过这个属性名获取课程列表数据进行展示，例如循环展示课程名称等相关内容。
+		model.addObject("courseList", courseList);
+		// 把学科信息添加到ModelAndView对象中，属性名为"subject"，用于在视图中展示学科相关情况，例如学科名称等内容，让用户了解试卷所属的学科背景。
+		model.addObject("subject", subject);
+		// 将当前课程的详细信息添加到ModelAndView对象中，属性名为"course"，方便在视图中展示课程的各种详细内容，如课程名称、简介等信息。
+		model.addObject("course", course);
+		// 把区域列表信息添加到ModelAndView对象中，属性名为"areaList"，以便在视图中展示可筛选的区域情况，例如以下拉框形式展示区域选项等情况。
+		model.addObject("areaList", areaList);
+		// 将处理后的试卷分页数据添加到ModelAndView对象中，属性名为"paperPage"，方便在视图中展示试卷列表以及分页相关的信息，例如展示试卷标题、分页导航条等内容。
+		model.addObject("paperPage", result);
+		// 把试卷总数添加到ModelAndView对象中，属性名为"total"，用于在视图中展示试卷的总数量相关信息，给用户一个整体的试卷数量提示。
+		model.addObject("total", total);
+		// 将课程ID添加到ModelAndView对象中，属性名为"courseId"，可能在页面上用于一些与课程相关的操作或者链接生成等情况（具体取决于前端页面的业务逻辑设计）。
+		model.addObject("courseId", courseId);
+		// 同样把试卷类型添加到ModelAndView对象中，属性名为"paperType"，方便在页面上展示当前筛选的试卷类型情况，或者用于根据类型进行其他相关操作等情况。
+		model.addObject("paperType", paperType);
+		// 将年份信息添加到ModelAndView对象中，属性名为"year"，用于在视图中展示当前筛选的年份情况，例如提示用户当前展示的是哪一年的试卷等情况。
+		model.addObject("year", year);
+		// 把区域标识添加到ModelAndView对象中，属性名为"area"，可能在页面上用于显示当前筛选的区域情况或者进行区域相关的操作等情况。

tamguo-tms/src/main/java/com/tamguo/web/tiku/QuestionContrller.java

@@ -26,95 +26,157 @@ import com.tamguo.modules.tiku.model.enums.QuestionTypeEnum;
 import com.tamguo.modules.tiku.model.queue.LearnChapterQueue;
 import com.tamguo.utils.BrowserUtils;
 
+// @Controller注解用于将这个类标记为Spring MVC框架中的一个控制器组件，意味着Spring容器会在启动时扫描到这个类，并将其管理起来，
+// 使得这个类中的方法能够处理对应的HTTP请求，根据请求的映射关系（通过@RequestMapping等注解定义）调用相应的业务逻辑方法，然后返回视图或者数据响应给客户端，
+// 在这里主要用于处理与题目相关的各种业务操作，例如展示题目列表页面、单个题目详情页面以及提供获取题目信息的接口等功能。
 @Controller
 public class QuestionContrller {
-	
+
+	// 创建一个日志记录器对象，用于记录在这个控制器类中发生的一些关键操作、调试信息或者错误信息等，
+	// 通过LoggerFactory根据当前类的Class对象获取对应的Logger实例，方便后续在代码中进行日志输出操作，便于调试和查看运行情况。
 	private Logger logger = LoggerFactory.getLogger(getClass());
 
+	// 通过@Autowired注解自动注入IQuestionService接口的实现类实例，IQuestionService用于处理与题目相关的各种业务逻辑，
+	// 比如根据题目ID查询题目详细信息、进行题目列表的分页查询等操作，在这个控制器的各个方法中会调用其相关方法来实现具体的题目相关业务功能。
 	@Autowired
 	private IQuestionService iQuestionService;
+
+	// 自动注入IChapterService接口的实现类实例，IChapterService用于处理与章节相关的各种业务逻辑，
+	// 例如根据章节ID查询章节信息、获取章节相关的下一章信息等操作，在题目相关操作中（如题目列表按章节筛选、题目关联所属章节等情况）会调用其相关方法来获取章节相关数据。
 	@Autowired
 	private IChapterService iChapterService;
+
+	// 注入ISubjectService接口的实现类实例，ISubjectService用于处理与学科（科目）相关的业务逻辑，
+	// 像根据学科ID查询学科详细信息等操作，在题目相关操作中（如题目列表展示所属学科信息、题目关联所属学科等情况）会调用该服务层接口的方法来获取学科数据。
 	@Autowired
 	private ISubjectService iSubjectService;
+
+	// 注入ICourseService接口的实现类实例，ICourseService主要负责处理与课程相关的业务逻辑，
+	// 比如根据课程ID查询课程信息、题目关联所属课程等操作，在题目相关业务中会调用它的相应方法来获取课程相关数据以及进行关联查询等操作。
 	@Autowired
 	private ICourseService iCourseService;
+
+	// 注入IQuestionAnswerService接口的实现类实例，IQuestionAnswerService用于处理与题目答案相关的业务逻辑，
+	// 在展示题目详情页面时，需要获取题目对应的答案列表进行展示，会调用其相关方法来获取答案相关数据。
 	@Autowired
 	private IQuestionAnswerService iQuestionAnswerService;
+
+	// 注入IQuestionOptionsService接口的实现类实例，IQuestionOptionsService用于处理与题目选项相关的业务逻辑，
+	// 例如获取题目包含的选项列表等操作，在展示题目详情以及题目列表时，需要为题目设置对应的选项信息，会调用其相关方法来获取选项数据并进行相应设置。
 	@Autowired
 	private IQuestionOptionsService iQuestionOptionsService;
 
-	// 章节
+	// 创建一个阻塞队列（BlockingQueue）用于存储章节实体对象（ChapterEntity），队列容量设置为10，
+	// 可能用于在某些业务逻辑中对章节信息进行缓存、排队处理或者传递章节相关数据（从当前代码来看，在questionList方法中有向这个队列添加章节信息的操作），具体作用取决于整体业务需求。
 	BlockingQueue<ChapterEntity> chapterQueue = new LinkedBlockingQueue<ChapterEntity>(10);
-	
+
+	/**
+	 * 处理题目列表页面的GET请求，请求路径格式为"questionlist/{chapterId}-{current}-{size}.html"，
+	 * 其中{chapterId}是章节的唯一标识、{current}表示当前页码、{size}表示每页显示的题目数量，这些都是路径变量，
+	 * 该方法用于获取题目列表相关的各种数据（如所属章节、课程、学科信息、题目分页数据以及为题目设置选项和类型描述等），
+	 * 根据请求头中用户代理信息判断是否是移动端访问，来设置不同的视图名称，最后将获取到的数据添加到ModelAndView对象中返回，供Spring MVC框架渲染相应的视图展示给客户端，同时还会将章节信息添加到特定的队列中。
+	 *
+	 * @param chapterId 章节的唯一标识字符串，通过@PathVariable注解从请求路径中获取，用于指定要查询题目列表所属的章节，传递给相关服务层方法作为查询依据，获取章节及其关联的数据信息，例如筛选该章节下的题目等操作。
+	 * @param current 表示当前页码的整数，通过路径变量获取，用于创建Page对象来确定分页查询情况，获取对应页码的数据记录，方便实现题目列表的分页展示功能，告诉服务层要获取第几页的题目数据。
+	 * @param size 表示每页显示题目数量的整数，同样是路径变量，用于设置Page对象中每页的记录数，确定分页查询时每页显示的题目数量，以便获取符合要求的题目分页列表信息。
+	 * @param model ModelAndView对象，用于设置视图名称以及向视图传递数据，在这里会将查询到的学科信息、课程信息、章节信息、父章节信息、下一章信息、题目分页列表等各种题目相关的数据添加到该对象中，
+	 *              然后根据设备类型设置合适的视图名称，最后返回该对象供Spring MVC框架进行视图渲染并展示题目列表页面给客户端，同时还会向章节队列中添加章节信息。
+	 * @param request HttpServletRequest对象，用于获取请求相关的各种信息，在这里主要是获取请求的URI（通过request.getRequestURI()方法）记录日志，
+	 *                以及获取请求头中的"user-agent"信息传递给BrowserUtils工具类判断是否是移动端访问，从而决定返回的视图名称等操作。
+	 * @return 返回配置好视图名称和题目相关数据的ModelAndView对象，供Spring MVC框架根据视图名称渲染并展示题目列表页面给客户端，展示相应的题目信息以及关联数据给用户查看，同时章节信息会被添加到章节队列中用于可能的后续业务处理。
+	 * @throws InterruptedException 因为使用了阻塞队列（BlockingQueue），在向队列添加元素（LearnChapterQueue.add(chapter)操作）时可能会抛出此异常，需要在调用该方法的地方进行处理，
+	 *                                例如在当前方法签名中声明抛出该异常，由上层调用者决定如何处理这种线程被中断的情况（通常在多线程环境下可能出现）。
+	 */
 	@SuppressWarnings("unchecked")
 	@RequestMapping(value = {"questionlist/{chapterId}-{current}-{size}.html"}, method = RequestMethod.GET)
-	public ModelAndView questionList(@PathVariable String chapterId , @PathVariable Integer current , 
+	public ModelAndView questionList(@PathVariable String chapterId, @PathVariable Integer current,
-			@PathVariable Integer size , ModelAndView model , HttpServletRequest request) throws InterruptedException{
+									 @PathVariable Integer size, ModelAndView model, HttpServletRequest request) throws InterruptedException {
-		// request url 
+		// 使用日志记录器记录请求的URL信息，方便后续查看请求访问情况以及进行调试等操作，通过格式化输出的方式将请求的URI信息记录到日志中，
-		logger.info("request url :{} " , request.getRequestURI());
+		// 输出的日志级别为INFO，通常用于记录一些重要的运行时信息，方便运维人员或者开发人员了解系统的访问情况。
+		logger.info("request url :{} ", request.getRequestURI());
 
+		// 调用iChapterService的selectById方法，传入章节的唯一标识（chapterId）作为参数，从数据库等数据源中查询对应的章节详细信息（以ChapterEntity对象形式返回），
+		// 获取到的章节信息后续会用于关联查询其他相关数据（如所属课程等情况），也会添加到ModelAndView对象中传递给视图进行展示，例如展示章节名称等相关内容。
 		ChapterEntity chapter = iChapterService.selectById(chapterId);
+
+		// 调用iCourseService的selectById方法，传入章节对象中的课程ID（chapter.getCourseId()）作为参数，从数据库等数据源中查询对应的课程详细信息（以CourseEntity对象形式返回），
+		// 获取课程信息是为了在题目列表页面展示题目所属的课程相关情况，例如课程名称等内容，将课程信息添加到ModelAndView对象中传递给视图进行展示，同时也用于后续关联查询所属学科信息等操作。
 		CourseEntity course = iCourseService.selectById(chapter.getCourseId());
+
+		// 调用iSubjectService的selectById方法，传入课程对象中的学科ID（course.getSubjectId()）作为参数，从数据库等数据源中查询对应的学科详细信息（以SubjectEntity对象形式返回），
+		// 获取学科信息用于在题目列表页面展示该题目列表所属的学科相关情况，例如学科名称等内容，将学科信息添加到ModelAndView对象中传递给视图进行展示。
 		SubjectEntity subject = iSubjectService.selectById(course.getSubjectId());
+
+		// 调用iChapterService的selectById方法，传入章节对象中的父章节代码（chapter.getParentCode()）作为参数，从数据库等数据源中查询对应的父章节详细信息（以ChapterEntity对象形式返回），
+		// 获取父章节信息可能用于在题目列表页面展示章节的层级关系等情况，例如显示当前章节的上级章节名称等内容，将父章节信息添加到ModelAndView对象中传递给视图进行展示。
 		ChapterEntity parentChapter = iChapterService.selectById(chapter.getParentCode());
-		ChapterEntity nextChapter = iChapterService.selectNextChapter(chapter.getParentCode() , chapter.getId());
+
-		
+		// 调用iChapterService的selectNextChapter方法，传入章节的父章节代码（chapter.getParentCode()）和当前章节的ID（chapter.getId()）作为参数，查询当前章节的下一章信息（以ChapterEntity对象形式返回），
+		// 获取下一章信息可以用于在题目列表页面提供章节导航功能等情况，例如提示用户下一章的相关信息或者提供跳转到下一章的链接等，将下一章信息添加到ModelAndView对象中传递给视图进行展示。
+		ChapterEntity nextChapter = iChapterService.selectNextChapter(chapter.getParentCode(), chapter.getId());
+
+		// 创建一个Page对象，用于进行分页查询操作，先实例化一个空的Page对象，后续会设置当前页码和每页记录数等属性来确定具体的分页情况。
 		Page<QuestionEntity> page = new Page<>();
+		// 设置Page对象的当前页码属性，传入从请求路径中获取的当前页码（current）参数，告诉服务层要获取第几页的题目数据，以便进行分页查询操作。
 		page.setCurrent(current);
+		// 设置Page对象的每页记录数属性，传入从请求路径中获取的每页题目数量（size）参数，确定分页查询时每页显示的题目数量，使得查询返回符合要求的题目分页列表信息。
 		page.setSize(size);
-		Page<QuestionEntity> questionList = iQuestionService.selectPage(page , Condition.create().eq("chapter_id", chapterId).orderDesc(Arrays.asList("id")));
+
-		for(int i=0 ;i<questionList.getRecords().size() ; i++) {
+		// 调用iQuestionService的selectPage方法，传入创建好的Page对象和通过MyBatis Plus的条件构造器Condition创建的查询条件，
+		// 使用eq("chapter_id", chapterId)表示筛选出章节ID等于当前传入章节ID（chapterId）的题目列表，再通过orderDesc(Arrays.asList("id"))按照题目ID降序排序题目列表，
+		// 进行分页查询操作，获取符合章节筛选条件且按要求排序的题目分页数据（以Page<QuestionEntity>对象形式返回），其中包含了题目记录列表以及分页相关的信息（如总记录数、当前页码、每页记录数等）。
+		Page<QuestionEntity> questionList = iQuestionService.selectPage(page, Condition.create().eq("chapter_id", chapterId).orderDesc(Arrays.asList("id")));
+
+		// 循环遍历题目分页列表中的每一条题目记录，对每个题目进行相关数据设置操作，主要是设置题目选项和题目类型描述信息。
+		for (int i = 0; i < questionList.getRecords().size(); i++) {
+			// 从题目分页列表中获取当前遍历到的题目实体对象，用于后续设置其选项和类型描述等相关信息。
 			QuestionEntity question = questionList.getRecords().get(i);
-			List<QuestionOptionsEntity> questionOptions = iQuestionOptionsService.selectList(Condition.create().eq("question_id" , question.getId()));
+			// 调用iQuestionOptionsService的selectList方法，通过条件构造器构建查询条件，
+			// 使用eq("question_id", question.getId())表示筛选出题目ID等于当前题目ID的选项列表，获取该题目包含的所有选项信息（以List<QuestionOptionsEntity>形式返回），
+			// 然后将获取到的选项列表设置到题目对象的questionOptions属性中，方便在视图中展示题目对应的选项内容，例如选择题的各个选项等情况。
+			List<QuestionOptionsEntity> questionOptions = iQuestionOptionsService.selectList(Condition.create().eq("question_id", question.getId()));
 			question.setQuestionOptions(questionOptions);
+			// 通过QuestionTypeEnum枚举类的getQuestionType方法，传入题目对象中的题目类型字段（question.getQuestionType()）获取对应的题目类型枚举对象，
+			// 再调用该枚举对象的getDesc方法获取题目类型的描述信息（例如将题目类型代码转换为具体的文字描述，如"单选题"、"多选题"等情况），将题目类型描述设置到题目对象的questionType属性中，
+			// 以便在视图中展示题目类型的详细描述信息，让用户更清晰地了解题目的类型情况。
 			question.setQuestionType(QuestionTypeEnum.getQuestionType(question.getQuestionType()).getDesc());
 		}
+
+		// 将查询到的学科信息添加到ModelAndView对象中，设置属性名为"subject"，方便在视图中通过这个属性名获取学科列表数据进行展示，例如展示学科名称等相关内容，让用户了解题目所属的学科背景。
 		model.addObject("subject", subject);
+		// 把课程信息添加到ModelAndView对象中，属性名为"course"，用于在视图中展示课程相关情况，例如课程名称等内容，让用户知道题目所属的课程信息。
 		model.addObject("course", course);
+		// 将章节信息添加到ModelAndView对象中，属性名为"chapter"，方便在视图中展示章节相关情况，例如章节名称、章节顺序等内容，让用户明确题目所属的章节情况。
 		model.addObject("chapter", chapter);
-		model.addObject("parentChapter" , parentChapter);
+		// 把父章节信息添加到ModelAndView对象中，属性名为"parentChapter"，用于在视图中展示章节的层级关系情况，例如显示当前章节的上级章节名称等内容。
-		model.addObject("nextChapter" , nextChapter);
+		model.addObject("parentChapter", parentChapter);
+		// 将下一章信息添加到ModelAndView对象中，属性名为"nextChapter"，方便在视图中展示章节导航相关情况，例如提示用户下一章的相关信息或者提供跳转到下一章的链接等。
+		model.addObject("nextChapter", nextChapter);
+		// 把处理好的题目分页列表信息添加到ModelAndView对象中，属性名为"questionList"，以便在视图中展示题目列表以及分页相关的信息，例如展示题目标题、分页导航条等内容。
 		model.addObject("questionList", questionList);
+		// 将课程的学科ID添加到ModelAndView对象中，属性名为"subjectId"，可能在页面上用于一些与学科相关的操作或者链接生成等情况（具体取决于前端页面的业务逻辑设计）。
 		model.addObject("subjectId", course.getSubjectId());
+		// 同样把课程的唯一标识添加到ModelAndView对象中，属性名为"courseId"，方便在页面上进行一些与课程相关的操作，例如根据课程ID查询其他课程相关信息等情况。
 		model.addObject("courseId", course.getId());
-		
+
+		// 将当前章节信息添加到LearnChapterQueue队列中（假设LearnChapterQueue是一个用于管理章节信息的自定义队列类），
+		// 具体作用可能是用于缓存章节信息、后续进行章节相关的统计或其他业务逻辑处理等情况，这里将章节添加到队列中，方便在其他地方使用该章节数据（具体取决于LearnChapterQueue类的具体实现和业务用途）。
 		LearnChapterQueue.add(chapter);
-		
+
-		if(BrowserUtils.isMobile(request.getHeader("user-agent"))) {
+		// 通过BrowserUtils工具类的isMobile方法判断请求头中的"user-agent"信息是否表示当前访问是来自移动端设备，
-    		model.setViewName("mobile/questionList");
+		// 如果是移动端访问，设置ModelAndView的视图名称为"mobile/questionList"，表示返回移动端对应的题目列表视图页面（具体视图页面的内容和样式由对应的前端页面模板决定）；
-    	}else {
+		// 如果不是移动端访问，设置视图名称为"questionList"，表示返回普通桌面端等设备对应的题目列表视图页面，根据不同设备类型展示合适的题目列表内容给用户查看。
-    		model.setViewName("questionList");
+		if (BrowserUtils.isMobile(request.getHeader("user-agent"))) {
-    	}
+			model.setViewName("mobile/questionList");
-		return model;
+		} else {
-	}
+			model.setViewName("questionList");
-	
+		}
-	/**
+
-	 * 直接访问题目
-	 * @param uid
-	 * @param model
-	 * @return
-	 */
-	@SuppressWarnings("unchecked")
-	@RequestMapping(value = {"/question/{uid}.html"}, method = RequestMethod.GET)
-	public ModelAndView question(@PathVariable String uid , ModelAndView model , HttpServletRequest request){
-		// request url 
-		logger.info("request url :{}" , request.getRequestURI());
-		model.setViewName("question");
-		QuestionEntity question = iQuestionService.selectById(uid);
-		List<QuestionOptionsEntity> questionOptions = iQuestionOptionsService.selectList(Condition.create().eq("question_id" , question.getId()));
-		question.setQuestionOptions(questionOptions);
-		question.setQuestionType(QuestionTypeEnum.getQuestionType(question.getQuestionType()).getDesc());
-		model.addObject("question", question);
-		model.addObject("course", iCourseService.selectById(question.getCourseId()));
-		model.addObject("answerList", iQuestionAnswerService.selectList(Condition.create().eq("question_id", uid).orderDesc(Arrays.asList("create_date"))));
-		if(BrowserUtils.isMobile(request.getHeader("user-agent"))) {
-    		model.setViewName("mobile/question");
-    	}else {
-    		model.setViewName("question");
-    	}
 		return model;
 	}
+
+/**
+ * 处理直接访问题目详情页面的GET请求
 	
 	@RequestMapping(value = {"question/getQuestion/{uid}.html"}, method = RequestMethod.GET)
 	@ResponseBody

tamguo-tms/src/main/java/com/tamguo/web/tiku/SmsController.java

@@ -10,21 +10,38 @@ import com.aliyuncs.exceptions.ClientException;
 import com.tamguo.common.utils.Result;
 import com.tamguo.modules.sys.service.ISmsService;
 
+// @Controller注解用于将这个类标记为Spring MVC框架中的一个控制器组件，意味着Spring容器会在启动时扫描到这个类，并将其管理起来，
+// 使得这个类中的方法能够处理对应的HTTP请求，根据请求的映射关系（通过@RequestMapping等注解定义）调用相应的业务逻辑方法，然后返回视图或者数据响应给客户端，
+// 在这里主要用于处理与短信发送（具体为发送找回密码相关短信）的业务操作，即接收前端请求并调用相关服务层方法来尝试发送短信，然后将结果返回给前端。
 @Controller
 public class SmsController {
-	
+
+	// 通过@Autowired注解自动注入ISmsService接口的实现类实例，ISmsService用于处理与短信发送相关的各种业务逻辑，
+	// 比如在这里具体用于发送找回密码的短信，在sendFindPasswordSms方法中会调用其对应的发送短信方法来实现具体的短信发送功能。
 	@Autowired
 	ISmsService iSmsService;
 
+	/**
+	 * 处理发送找回密码短信的GET请求，请求路径为"sms/sendFindPasswordSms.html"，该方法接收一个手机号码（mobile）作为参数，
+	 * 用于调用iSmsService的sendFindPasswordSms方法来尝试发送找回密码相关的短信，若发送成功则将服务层返回的结果（以Result对象形式）直接返回给前端，
+	 * 若发送过程中出现异常（具体为阿里云客户端异常ClientException，可能是短信服务配置问题、网络问题等导致与阿里云短信服务通信异常等情况），则打印异常堆栈信息，并返回一个表示失败的Result对象（状态码为500）给前端告知发送失败。
+	 *
+	 * @param mobile 表示要接收找回密码短信的手机号码的字符串参数，从请求中获取，传递给iSmsService的sendFindPasswordSms方法作为短信发送的目标手机号，确定短信要发送到哪个手机号上。
+	 * @return 返回一个Result对象，正常情况下返回iSmsService的sendFindPasswordSms方法返回的Result对象，其中包含了短信发送的结果相关信息（如状态码表示发送是否成功、提示信息等内容），通过@ResponseBody注解将Result对象转换为合适的格式（如JSON格式等，具体取决于项目配置）返回给前端，
+	 * 供前端根据返回结果进行相应的提示和后续处理操作，比如提示用户短信已发送成功或者发送失败等情况；若发送过程中出现异常，则返回一个表示失败的Result对象（状态码为500，无具体数据，提示信息为空字符串）告知前端短信发送出现问题。
+	 */
 	@RequestMapping(value = {"sms/sendFindPasswordSms.html"}, method = RequestMethod.GET)
 	@ResponseBody
-	public Result sendFindPasswordSms(String mobile){
+	public Result sendFindPasswordSms(String mobile) {
 		try {
+			// 调用iSmsService的sendFindPasswordSms方法，传入要接收短信的手机号码（mobile）作为参数，尝试发送找回密码相关的短信，该方法会根据业务逻辑与短信服务提供商（如阿里云短信服务等，具体取决于ISmsService的实现）进行交互，
+			// 进行短信内容组装、发送等操作，并返回一个Result对象，其中包含了短信发送的结果相关信息（如状态码表示发送是否成功、提示信息等内容），后续会将这个Result对象返回给前端，告知前端短信发送的情况。
 			return iSmsService.sendFindPasswordSms(mobile);
 		} catch (ClientException e) {
+			// 若在调用iSmsService的sendFindPasswordSms方法发送短信过程中出现ClientException异常（可能是短信服务配置问题、网络问题等导致与阿里云短信服务通信异常等情况），
+			// 则通过e.printStackTrace()打印异常的堆栈信息，方便开发人员进行调试和定位问题所在，然后返回一个表示失败的Result对象（状态码为500，无具体数据，提示信息为空字符串）给前端，告知前端短信发送出现了问题，发送失败。
 			e.printStackTrace();
 		}
 		return Result.result(500, null, "");
 	}
-	
+}
-}

tamguo-tms/src/main/java/com/tamguo/web/tiku/SubjectController.java

@@ -24,74 +24,168 @@ import java.util.List;
 
 /**
  * Controller - 考试（高考，建造师，医药师）
- * 
+ * 这个类作为Spring MVC的控制器，主要用于处理与各类考试（像高考、建造师考试、医药师考试等）相关的不同业务操作对应的HTTP请求，
+ * 通过调用相应的业务服务层接口来获取数据，进行数据组装、分页处理等操作，然后根据请求情况返回视图或者数据响应给客户端，例如展示考试科目相关页面以及提供课程、学科相关树形结构数据获取的接口等功能。
+ *
  * @author candy.tam
  *
  */
 @Controller
 public class SubjectController {
-	
+
+	// 创建一个日志记录器对象，用于记录在这个控制器类中发生的一些关键操作、调试信息或者错误信息等，
+	// 通过LoggerFactory根据当前类的Class对象获取对应的Logger实例，方便后续在代码中进行日志输出操作，便于调试和查看运行情况。
 	private Logger logger = LoggerFactory.getLogger(getClass());
-	
+
+	// 通过@Autowired注解自动注入IChapterService接口的实现类实例，IChapterService用于处理与章节相关的各种业务逻辑，
+	// 比如根据章节相关条件查询章节列表、通过书籍ID获取章节列表等操作，在考试科目相关页面展示中，可能需要获取章节信息进行展示，会调用其相关方法来获取章节数据。
 	@Autowired
 	private IChapterService iChapterService;
+
+	// 注入ISysAreaService接口的实现类实例，ISysAreaService用于处理与系统区域相关的业务逻辑，
+	// 例如获取特定层级（如层级为0的顶级区域等情况）的区域列表等操作，在考试科目相关页面展示时，可能会展示区域相关信息（比如用于筛选试卷等情况，虽然当前代码中未明确体现完整相关逻辑），会用到该服务层接口的方法来获取区域数据。
 	@Autowired
 	private ISysAreaService iSysAreaService;
+
+	// 自动注入ISubjectService接口的实现类实例，ISubjectService主要负责处理与学科（科目）相关的业务逻辑，
+	// 像根据学科ID查询学科详细信息、获取课程级联树数据、获取学科树数据等操作都会调用它的相应方法来完成，是处理考试科目相关业务的核心服务层接口之一。
 	@Autowired
 	private ISubjectService iSubjectService;
+
+	// 注入ICourseService接口的实现类实例，ICourseService用于处理与课程相关的业务逻辑，
+	// 例如根据学科ID查询该学科下的课程列表、获取课程相关信息等操作，在考试科目相关页面展示以及其他业务逻辑中（如获取课程级联树数据等情况）会调用其相应方法来获取课程相关数据。
 	@Autowired
 	private ICourseService iCourseService;
+
+	// 注入IKnowPointService接口的实现类实例，IKnowPointService用于处理知识点相关的业务逻辑（在这里代码中变量命名为iBookService，可能知识点与书籍有一定关联或者从业务角度将知识点当作书籍看待等情况，具体取决于业务含义），
+	// 比如根据课程ID查询对应的知识点列表等操作，在构建考试科目相关页面数据时，会涉及到知识点（书籍）相关信息的获取与处理，会调用其相应方法。
 	@Autowired
 	private IKnowPointService iBookService;
+
+	// 注入IPaperService接口的实现类实例，IPaperService用于处理与试卷相关的业务逻辑，
+	// 例如根据学科ID分页查询最新的试卷列表等操作，在考试科目相关页面展示时，会获取该学科相关的试卷信息进行展示，需要调用它的相应方法来获取试卷数据。
 	@Autowired
 	private IPaperService iPaperService;
 
+	/**
+	 * 处理考试科目详情页面的GET请求，请求路径为"subject/{subjectId}.html"，其中{subjectId}是一个路径变量，表示考试科目的唯一标识，
+	 * 该方法用于获取考试科目相关的详细信息以及与之关联的其他数据（如所属课程列表、课程对应的知识点相关章节列表、区域列表、最新试卷列表等），
+	 * 根据请求头中用户代理信息判断是否是移动端访问，来设置不同的视图名称，最后将获取到的数据添加到ModelAndView对象中返回，供Spring MVC框架渲染相应的视图展示给客户端。
+	 *
+	 * @param subjectId 考试科目的唯一标识字符串，通过@PathVariable注解从请求路径中获取，用于指定要查询详细信息的具体考试科目，传递给相关服务层方法作为查询依据，获取科目及其关联的数据信息。
+	 * @param request HttpServletRequest对象，用于获取请求相关的各种信息，在这里主要是获取请求的URI（通过request.getRequestURI()方法）记录日志，
+	 *                以及获取请求头中的"user-agent"信息传递给BrowserUtils工具类判断是否是移动端访问，从而决定返回的视图名称等操作。
+	 * @param model ModelAndView对象，用于设置视图名称以及向视图传递数据，在这里会将查询到的考试科目相关的各种数据（科目本身、课程列表、章节列表、区域列表、试卷列表等）添加到该对象中，
+	 *              然后根据设备类型设置合适的视图名称，最后返回该对象供Spring MVC框架进行视图渲染并展示考试科目详情页面给客户端。
+	 * @return 返回配置好视图名称和考试科目相关数据的ModelAndView对象，供Spring MVC框架根据视图名称渲染并展示考试科目详情页面给客户端，展示相应的考试科目信息以及关联数据给用户查看。
+	 */
 	@SuppressWarnings("unchecked")
 	@RequestMapping(value = {"subject/{subjectId}.html"}, method = RequestMethod.GET)
-    public ModelAndView indexAction(@PathVariable String subjectId , HttpServletRequest request , ModelAndView model) {
+	public ModelAndView indexAction(@PathVariable String subjectId, HttpServletRequest request, ModelAndView model) {
-		// request url 
+		// 使用日志记录器记录请求的URL信息，方便后续查看请求访问情况以及进行调试等操作，通过格式化输出的方式将请求的URI信息记录到日志中，
-		logger.info("request url :{} " , request.getRequestURI() );
+		// 输出的日志级别为INFO，通常用于记录一些重要的运行时信息，方便运维人员或者开发人员了解系统的访问情况。
+		logger.info("request url :{} ", request.getRequestURI());
+
+		// 调用iSubjectService的selectById方法，传入考试科目的唯一标识（subjectId）作为参数，从数据库等数据源中查询对应的考试科目详细信息（以SubjectEntity对象形式返回），
+		// 获取到的考试科目信息后续会添加到ModelAndView对象中传递给视图进行展示，例如展示科目名称、科目简介等相关内容。
 		SubjectEntity subject = iSubjectService.selectById(subjectId);
+
+		// 调用iCourseService的selectList方法，通过MyBatis Plus的条件构造器Condition创建查询条件，
+		// 使用eq("subject_id", subjectId)表示筛选出学科ID等于当前传入考试科目ID（subjectId）的课程列表，再通过orderAsc(Arrays.asList("sort"))按照"sort"字段升序排序课程列表，
+		// 获取与该考试科目相关的课程列表信息（以List<CourseEntity>形式返回），用于在考试科目详情页面展示同属一个科目的课程情况，比如在页面上列出课程名称等相关内容，将课程列表信息添加到ModelAndView对象中。
 		List<CourseEntity> courseList = iCourseService.selectList(Condition.create().eq("subject_id", subjectId).orderAsc(Arrays.asList("sort")));
-		// 获取第一个科目
+
+		// 从获取到的课程列表中获取第一个课程对象（这里假设可以基于第一个课程来获取相关知识点、章节等信息，具体业务逻辑可能根据实际情况而定），
+		// 获取这个课程对象主要是为了后续基于它来获取相关的知识点、章节等数据，进行页面数据的进一步组装和展示操作。
 		CourseEntity course = courseList.get(0);
-		// 获取第一本书
+
+		// 调用iBookService（实际为IKnowPointService）的selectList方法，通过条件构造器构建查询条件，
+		// 使用eq("course_id", course.getId())表示筛选出课程ID等于当前获取到的课程ID（course.getId()）的知识点列表（这里看作书籍列表，具体取决于业务含义），获取与该课程相关的所有知识点（书籍）信息（以List<KnowPointEntity>形式返回），
+		// 这些知识点（书籍）信息后续可能用于获取与之关联的章节信息等操作，也会添加到ModelAndView对象中（虽然当前代码中未明确在视图中如何展示，可能根据业务需求有相应的处理逻辑）。
 		List<KnowPointEntity> bookList = iBookService.selectList(Condition.create().eq("course_id", course.getId()));
+
+		// 初始化章节列表为null，后续会根据知识点（书籍）情况来确定章节列表的值，如果有对应的知识点（书籍）存在，会进一步查询相关章节信息进行赋值。
 		List<ChapterEntity> chapterList = null;
-		if(bookList.size() > 0) {
+
+		// 判断知识点（书籍）列表的大小是否大于0，即是否存在与当前课程相关的知识点（书籍），
+		// 如果存在知识点（书籍），说明可以基于它们进一步获取与之关联的章节信息等内容，进行后续的数据准备操作。
+		if (bookList.size() > 0) {
+			// 从知识点（书籍）列表中获取第一个知识点（书籍）对象（同样假设基于第一个对象来获取章节信息，具体业务逻辑依实际情况而定），
+			// 获取这个知识点（书籍）对象主要是为了获取其ID，作为查询章节列表的依据，获取与该知识点（书籍）相关联的章节信息。
 			KnowPointEntity book = bookList.get(0);
+			// 调用iChapterService的selectList方法，传入通过条件构造器构建的查询条件，
+			// 使用eq("book_id", book.getId())表示筛选出书籍ID等于当前获取到的知识点（书籍）ID（book.getId()）的章节列表，获取与该知识点（书籍）相关的章节列表信息（以List<ChapterEntity>形式返回），
+			// 章节列表信息可能用于在考试科目详情页面展示课程对应的章节情况（例如章节名称等内容，具体展示逻辑由前端页面模板决定），获取到的章节列表信息会赋值给chapterList变量，后续添加到ModelAndView对象中用于视图展示。
 			chapterList = iChapterService.selectList(Condition.create().eq("book_id", book.getId()));
 		}
-		// 获取最新的试卷
+
-		Page<PaperEntity> paperPage = iPaperService.selectPage(new Page<PaperEntity>(1, 15) , Condition.create().eq("subject_id", subjectId).orderDesc(Arrays.asList("id")));
+		// 调用iPaperService的selectPage方法，创建一个Page对象用于分页查询，传入当前页码为1和每页显示记录数为15，表示获取第一页且每页显示15条记录，
-    	model.addObject("subject", subject);
+		// 通过条件构造器构建查询条件，使用eq("subject_id", subjectId)表示筛选出学科ID等于当前考试科目ID（subjectId）的试卷列表，再通过orderDesc(Arrays.asList("id"))按照试卷ID降序排序试卷列表，
-    	model.addObject("course" , course);
+		// 进行分页查询操作，获取符合学科筛选条件且按要求排序的试卷分页数据（以Page<PaperEntity>对象形式返回），这里只取第一页的试卷记录（即最新的试卷列表，假设ID越大越新等情况，具体取决于业务中试卷ID的定义和排序规则），
-    	model.addObject("courseList", courseList);
+		// 获取到的试卷列表信息会添加到ModelAndView对象中，用于在考试科目详情页面展示该科目相关的试卷情况，例如展示试卷标题等相关内容。
-    	model.addObject("chapterList" , chapterList);
+		Page<PaperEntity> paperPage = iPaperService.selectPage(new Page<PaperEntity>(1, 15), Condition.create().eq("subject_id", subjectId).orderDesc(Arrays.asList("id")));
-    	model.addObject("areaList", iSysAreaService.selectList(Condition.create().eq("tree_level", "0")));
+
-    	model.addObject("paperList", paperPage.getRecords());
+		// 将查询到的考试科目详细信息添加到ModelAndView对象中，设置属性名为"subject"，方便在视图中通过这个属性名获取科目详细内容进行展示，如科目名称、简介等信息。
-    	if(BrowserUtils.isMobile(request.getHeader("user-agent"))) {
+		model.addObject("subject", subject);
-    		model.setViewName("mobile/subject");
+		// 把获取到的当前课程信息添加到ModelAndView对象中，属性名为"course"，用于在视图中展示课程相关情况，例如课程名称等内容，让用户了解考试科目下的具体课程情况。
-    	}else {
+		model.addObject("course", course);
-    		model.setViewName("subject");
+		// 将同属一个科目的课程列表信息添加到ModelAndView对象中，属性名为"courseList"，以便在视图中展示课程列表相关信息，例如循环展示课程名称等情况，为用户提供更多课程相关的参考信息。
-    	}
+		model.addObject("courseList", courseList);
-        return model;
+		// 把获取到的章节列表信息添加到ModelAndView对象中，属性名为"chapterList"，方便在视图中展示章节相关信息，例如展示章节名称等内容，体现课程对应的章节情况。
-    }
+		model.addObject("chapterList", chapterList);
-	
+		// 将区域列表信息添加到ModelAndView对象中，属性名为"areaList"，通过调用iSysAreaService的selectList方法获取层级为0的区域列表（可能表示顶级区域等情况，具体含义由业务中区域层级的定义决定），
-	// [{"value":"11","label":"北京市","children":[{"value":"1101","label":"市辖区"}]}]
+		// 方便在视图中展示可筛选的区域情况（虽然当前代码未明确体现完整筛选逻辑，可能后续有相关扩展功能），例如以下拉框形式展示区域选项等情况。
+		model.addObject("areaList", iSysAreaService.selectList(Condition.create().eq("tree_level", "0")));
+		// 把获取到的试卷列表信息（具体为第一页的试卷记录）添加到ModelAndView对象中，属性名为"paperList"，以便在视图中展示试卷相关信息，例如展示试卷标题等内容，让用户了解该科目相关的试卷情况。
+		model.addObject("paperList", paperPage.getRecords());
+
+		// 通过BrowserUtils工具类的isMobile方法判断请求头中的"user-agent"信息是否表示当前访问是来自移动端设备，
+		// 如果是移动端访问，设置ModelAndView的视图名称为"mobile/subject"，表示返回移动端对应的考试科目详情视图页面（具体视图页面的内容和样式由对应的前端页面模板决定）；
+		// 如果不是移动端访问，设置视图名称为"subject"，表示返回普通桌面端等设备对应的考试科目详情视图页面，根据不同设备类型展示合适的考试科目详情内容给用户查看。
+		if (BrowserUtils.isMobile(request.getHeader("user-agent"))) {
+			model.setViewName("mobile/subject");
+		} else {
+			model.setViewName("subject");
+		}
+
+		return model;
+	}
+
+	/**
+	 * 处理获取课程级联树数据的GET请求，请求路径为"subject/getCourseCascaderTree.html"，
+	 * 该方法用于调用iSubjectService的getCourseCascaderTree方法获取课程级联树数据（以JSONArray形式返回，可能是一种树形结构的数据，用于前端以级联选择等形式展示课程相关的层级关系等情况），
+	 * 将获取到的数据包装在Result对象中（通过Result.successResult方法），然后返回给前端，前端可以根据返回的Result对象中的数据进行相应的展示和后续处理，比如展示课程的层级选择框等情况。
+	 *
+	 * @return 返回一个Result对象，通过调用Result.successResult方法将iSubjectService的getCourseCascaderTree方法返回的JSONArray数据（课程级联树数据）包装起来，其中包含了表示成功的状态码以及课程级联树相关的数据信息，
+	 * 通过@ResponseBody注解将Result对象转换为合适的格式（如JSON格式等，具体取决于项目配置）返回给前端，供前端根据返回结果进行相应的展示和后续处理操作，例如在页面上展示课程的层级选择框等情况，方便用户选择课程。
+	 */
 	@RequestMapping(value = {"subject/getCourseCascaderTree.html"}, method = RequestMethod.GET)
 	@ResponseBody
 	public Result getCourseCascaderTree() {
 		JSONArray list = iSubjectService.getCourseCascaderTree();
 		return Result.successResult(list);
 	}
-	
+
-	// [{"value":"11","label":"北京市"}]
+	/**
+	 * 处理获取学科树数据的GET请求，请求路径为"subject/getSubjectTree.html"，
+	 * 该方法调用iSubjectService的getSubjectTree方法获取学科树数据（同样以JSONArray形式返回，是一种树形结构的数据，用于前端展示学科的层级关系等情况），
+	 * 将获取到的数据包装在Result对象中（通过Result.successResult方法），再返回给前端，供前端根据返回的数据进行相应的展示和后续处理，比如展示学科的层级结构等情况。
+	 *
+	 * @return 返回一个Result对象，通过调用Result.successResult方法将iSubjectService的getSubjectTree方法返回的JSONArray数据（学科树数据）包装起来，其中包含了表示成功的状态码以及学科树相关的数据信息，
+	 * 通过@ResponseBody注解将Result对象转换为合适的格式（如JSON格式等，具体取决于项目配置）返回给前端，供前端根据返回结果进行相应的展示和后续处理操作，例如在页面上展示学科的层级结构等情况，方便用户查看学科的分类和层级关系。
+	 */
+// 处理获取学科树数据的GET请求，请求路径为"subject/getSubjectTree.html"，意味着当客户端发起一个GET请求到该路径时，此方法会被触发执行。
+// 通过这个方法可以获取学科相关的树形结构数据，一般用于在前端页面以树形结构展示学科的层级关系等情况，方便用户直观地查看和操作学科分类信息。
 	@RequestMapping(value = {"subject/getSubjectTree.html"}, method = RequestMethod.GET)
+// @ResponseBody注解用于将方法的返回值直接作为响应体返回给客户端，而不是去寻找对应的视图进行渲染。
+// 在这里，会将获取到的学科树数据（以JSONArray形式）包装在Result对象中，然后以合适的格式（如JSON格式，取决于项目配置）返回给前端，供前端进行后续处理和展示。
 	@ResponseBody
 	public Result getSubjectTree() {
+		// 调用iSubjectService（应该是注入的处理学科相关业务逻辑的服务层接口实现类）的getSubjectTree方法，
+		// 该方法的作用是从数据源（如数据库等）中获取学科的树形结构数据，返回的数据格式为JSONArray，它可以方便地表示具有层级关系的数据结构，适合用于前端展示树形结构的场景。
 		JSONArray list = iSubjectService.getSubjectTree();
+		// 将获取到的JSONArray格式的学科树数据list，通过Result.successResult方法进行包装，Result对象通常用于统一封装返回给前端的数据格式，
+		// 它里面包含了表示请求是否成功的状态码（这里调用successResult方法表示成功状态）以及实际的数据内容（即学科树数据list），然后将这个包装好的Result对象返回给前端，
+		// 前端可以根据Result对象中的状态码判断请求是否成功，并提取其中的学科树数据进行相应的展示和处理，比如在页面上以树形菜单等形式展示学科的层级结构等情况。
 		return Result.successResult(list);
 	}
-
-}