diff --git a/src/main/java/cn/ppdxzz/controller/VisitorController.java b/src/main/java/cn/ppdxzz/controller/VisitorController.java
index fc0f8b6..b11d985 100644
--- a/src/main/java/cn/ppdxzz/controller/VisitorController.java
+++ b/src/main/java/cn/ppdxzz/controller/VisitorController.java
@@ -24,195 +24,216 @@ import java.util.List;
 import java.util.UUID;
 
 /**
- * Description:
+ * Description: 该类是访客相关功能的控制器，处理与访客相关的各种请求，例如来访登记、注销、查询、导出等操作。
  *
  * @Date: 2020/2/18 16:26
  * @Author: PeiChen
  */
-// 声明这是一个控制器
+// 声明这是一个Spring框架中的控制器，表明该类可以处理HTTP请求并返回相应的视图或数据
 @Controller
-// 映射访问路径为/visitor
+// 映射访问路径为/visitor，意味着所有以/visitor开头的请求都会被该控制器处理
 @RequestMapping("/visitor")
 public class VisitorController {
 
-    // 自动注入VisitorService服务类
+    // 自动注入VisitorService服务类，通过依赖注入的方式获取VisitorService的实例，以便调用其中的业务逻辑方法
     private VisitorService visitorService;
 
-    // 通过Autowired注解自动注入VisitorService
+    // 通过Autowired注解自动注入VisitorService，这里是设置属性注入的方法，Spring会自动找到VisitorService的实现类并注入进来
     @Autowired
     public void setVisitorService(VisitorService visitorService) {
         this.visitorService = visitorService;
     }
 
-    // 访问路径为/visitor/login的请求处理方法，返回注册页面
+    // 访问路径为/visitor/login的请求处理方法，该方法返回注册页面的视图名称，通常Spring会根据这个名称去查找对应的视图文件进行渲染展示
     @RequestMapping("/login")
     public String register() {
         return "regist_visitor";
-    } // 返回regist_visitor视图
+    } // 返回regist_visitor视图，此视图应该是用于展示访客注册相关页面内容的，具体的页面解析和渲染由Spring的视图解析器根据配置来完成
 
     /**
      * 来访登记实现（C操作）
-     * @param visitor 访客对象
-     * @return ModelAndView 视图模型对象
-     * @throws Exception 异常
+     * 该方法用于处理访客的来访登记功能，接收一个Visitor对象作为参数，将访客信息保存到数据库中，并根据操作结果返回相应的视图。
+     *
+     * @param visitor 访客对象，包含了访客的各种信息，如姓名、学号、电话、访问地点等，这些信息将被保存到数据库中。
+     * @return ModelAndView 视图模型对象，用于携带数据并指定要返回的视图名称，以便Spring进行视图渲染和数据展示。
+     * @throws Exception 异常，方法可能会抛出各种异常，比如数据库操作异常等，由调用者进行处理。
      */
     @RequestMapping("/addLogin")
     public ModelAndView addVisitor(Visitor visitor) throws Exception {
         ModelAndView mv = new ModelAndView();
-        // 参数校验，如果访客信息不完整，则返回错误信息
+        // 参数校验，如果访客信息不完整（访客对象为空或者关键属性如姓名、学号、电话、访问地点等为空），则返回错误信息页面
         if (visitor == null || visitor.getName() == null || visitor.getSno() == null || visitor.getPhone() == null || visitor.getPlace() == null) {
-            mv.addObject("error_msg","来访登记失败，请重新登记！");
+            mv.addObject("error_msg", "来访登记失败，请重新登记！");
             mv.setViewName("regist_visitor");
             return mv;
         }
-        // 生成访客ID
+        // 生成访客ID，使用UUID（通用唯一识别码）来生成一个唯一的标识符作为访客的ID，如果原访客对象中的ID为空或者是空白字符串，则进行生成操作
         if (visitor.getId() == null || "".trim().equals(visitor.getId())) {
             String uuid = UUID.randomUUID().toString().replace("-", "");
             visitor.setId(uuid);
         }
-        // 设置来访时间为当前系统时间
+        // 设置来访时间为当前系统时间，通过SimpleDateFormat格式化当前的日期和时间（格式为"yyyy-MM-dd HH:mm:ss"），并设置到访客对象的来访时间属性中
         String date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
         visitor.setBegin_date(date);//设置来访时间为提交来访登记时间
-        //先设置离开时间为空串，后续注销时再修改为注销时系统时间
+        // 先设置离开时间为空串，后续注销时再修改为注销时系统时间，初始化访客的离开时间为空字符串，表示访客尚未离开
         if (visitor.getEnd_date() == null || "".trim().equals(visitor.getEnd_date())) {
             visitor.setEnd_date("");
         }
-        // 添加访客信息到数据库
+        // 添加访客信息到数据库，调用VisitorService中的add方法将完整的访客信息保存到数据库中
         visitorService.add(visitor);
-        // 添加访客ID到模型，用于页面显示
-        mv.addObject("id",visitor.getId());
-        mv.setViewName("visitor-success"); // 设置成功页面视图
+        // 添加访客ID到模型，用于页面显示，将生成的访客ID添加到ModelAndView对象中，以便在后续的视图中可以获取并展示给用户
+        mv.addObject("id", visitor.getId());
+        mv.setViewName("visitor-success"); // 设置成功页面视图，指定成功登记后要展示的视图名称，通常会显示登记成功的相关提示信息
         return mv;
     }
 
     /**
      * 访客记录注销
-     * @param request HttpServletRequest对象
-     * @return ModelAndView 视图模型对象
-     * @throws Exception 异常
+     * 该方法用于处理访客记录的注销功能，接收一个HttpServletRequest对象，从请求中获取访客ID，然后调用业务逻辑进行注销操作，并根据操作结果返回相应的视图。
+     *
+     * @param request HttpServletRequest对象，用于获取请求中的参数，如访客ID等信息。
+     * @return ModelAndView 视图模型对象，携带注销操作的相关提示信息并指定要返回的视图名称。
+     * @throws Exception 异常，可能会抛出如数据库操作异常等各种异常情况，由调用者进行处理。
      */
     @RequestMapping("/login_out")
     public ModelAndView logout(HttpServletRequest request) throws Exception {
         ModelAndView mv = new ModelAndView();
-        // 获取访客ID
+        // 获取访客ID，从HttpServletRequest对象中获取名为"id"的参数值，该参数值代表要注销的访客的唯一标识
         String id = request.getParameter("id");
-        // 如果ID为空，则返回错误信息
+        // 如果ID为空，则返回错误信息页面，提示系统繁忙，让用户稍后再试
         if (id == null || "".trim().equals(id)) {
-            mv.addObject("logout_msg","系统繁忙，请稍后再试！");
+            mv.addObject("logout_msg", "系统繁忙，请稍后再试！");
             mv.setViewName("regist_visitor");
         }
-        // 获取当前系统时间
+        // 获取当前系统时间，通过SimpleDateFormat格式化当前的日期和时间（格式为"yyyy-MM-dd HH:mm:ss"），用于更新访客记录的注销时间
         String date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
-        // 注销访客记录
-        visitorService.logout(id,date);
-        mv.addObject("logout_msg","注销成功");
+        // 注销访客记录，调用VisitorService中的logout方法，传入访客ID和当前时间，完成在数据库中对访客记录的注销操作（可能是更新离开时间等相关操作）
+        visitorService.logout(id, date);
+        mv.addObject("logout_msg", "注销成功");
         mv.setViewName("regist_visitor");
         return mv;
     }
 
     /**
      * 管理员手动注销来访状态
-     * @param request HttpServletRequest对象
-     * @param response HttpServletResponse对象
-     * @throws Exception 异常
+     * 该方法用于管理员手动注销来访状态，接收HttpServletRequest和HttpServletResponse对象，从请求中获取访客ID，进行注销操作，并向响应中写入操作结果（true或false）。
+     *
+     * @param request HttpServletRequest对象，用于获取请求中的访客ID等参数信息。
+     * @param response HttpServletResponse对象，用于设置响应的字符编码、向客户端发送操作结果等信息。
+     * @throws Exception 异常，可能出现如数据库操作异常、编码设置异常等情况，由调用者进行处理。
      */
     @RequestMapping("/updateStatus")
-    public void updateStatus(HttpServletRequest request,HttpServletResponse response) throws Exception {
+    public void updateStatus(HttpServletRequest request, HttpServletResponse response) throws Exception {
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为UTF-8，确保能正确接收和处理包含中文等特殊字符的请求参数
         response.setCharacterEncoding("utf-8");
+        // 设置响应的字符编码为UTF-8，保证返回给客户端的数据能正确显示，避免出现乱码问题
         PrintWriter writer = response.getWriter();
-        // 获取访客ID
+        // 获取响应的输出流的PrintWriter对象，用于向客户端发送文本数据（这里用于写入操作结果）
+        // 获取访客ID，从HttpServletRequest对象中获取名为"id"的参数值，该参数值是要注销的访客记录的标识
         String id = request.getParameter("id");
-        // 如果ID为空，则返回错误信息
+        // 如果ID为空，则返回错误信息，向客户端写入"false"表示注销操作失败
         if (id == null || "".trim().equals(id)) {
             writer.write("false");
             return;
         }
-        // 获取当前系统时间
+        // 获取当前系统时间，通过SimpleDateFormat格式化当前的日期和时间（格式为"yyyy-MM-dd HH:mm:ss"），用于更新访客记录的注销时间
         String date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
-        // 注销访客记录
-        visitorService.logout(id,date);
+        // 注销访客记录，调用VisitorService中的logout方法，传入访客ID和当前时间，在数据库中执行注销操作（比如更新离开时间等相关字段）
+        visitorService.logout(id, date);
         writer.write("true");
+        // 向客户端写入"true"表示注销操作成功，客户端可以根据接收到的这个结果进行相应的提示或后续处理
     }
 
     /**
      * 查询所有访客记录
-     * @param page 当前页码
-     * @param size 每页显示数量
-     * @param request HttpServletRequest对象
-     * @param response HttpServletResponse对象
-     * @return ModelAndView 视图模型对象
-     * @throws Exception 异常
+     * 该方法用于查询所有访客记录，支持分页查询以及根据关键词搜索查询，接收当前页码、每页显示数量以及HttpServletRequest和HttpServletResponse对象，返回包含查询结果和分页信息的视图模型对象。
+     *
+     * @param page 当前页码，用于指定要获取第几页的数据，从请求参数中获取，默认值为1，如果请求中没有传递该参数则使用默认值。
+     * @param size 每页显示数量，用于指定每页展示多少条访客记录，从请求参数中获取，默认值为5，如果请求中没有传递该参数则使用默认值。
+     * @param request HttpServletRequest对象，用于获取请求中的参数，如关键词等信息，以及设置请求的字符编码。
+     * @param response HttpServletResponse对象，用于设置响应的字符编码等操作。
+     * @return ModelAndView 视图模型对象，携带查询到的访客记录列表以及分页信息，并指定要返回的视图名称，方便Spring进行视图渲染和数据展示。
+     * @throws Exception 异常，可能出现数据库查询异常、编码设置异常等情况，由调用者进行处理。
      */
     @RequestMapping("/findAll")
-    public ModelAndView findAll(@RequestParam(name = "page", required = true, defaultValue = "1") int page, @RequestParam(name = "size", required = true, defaultValue = "5") int size,HttpServletRequest request,HttpServletResponse response) throws Exception {
-        // 设置请求和响应的字符编码为UTF-8
+    public ModelAndView findAll(@RequestParam(name = "page", required = true, defaultValue = "1") int page,
+                                @RequestParam(name = "page", required = true, defaultValue = "5") int size,
+                                HttpServletRequest request, HttpServletResponse response) throws Exception {
+        // 设置请求的字符编码为UTF-8，确保能正确处理包含中文等特殊字符的请求参数
         request.setCharacterEncoding("utf-8");
+        // 设置响应的字符编码为UTF-8，保证返回给客户端的数据能正确显示，避免出现乱码情况
         response.setCharacterEncoding("utf-8");
 
-        // 创建ModelAndView对象用于返回视图和数据
+        // 创建ModelAndView对象用于返回视图和数据，该对象可以携带数据并指定要展示的视图名称，方便Spring进行后续的视图渲染操作
         ModelAndView mv = new ModelAndView();
         List<Visitor> visitors = null;
 
-        // 获取请求中的keyword参数
+        // 获取请求中的keyword参数，该参数用于根据关键词进行访客记录的搜索，如果没有该参数则查询所有记录
         String keyword = request.getParameter("keyword");
 
-        // 如果keyword为空或为空字符串，则查询所有访客记录
+        // 如果keyword为空或为空字符串，或者长度为0（进一步确保为空的情况），则查询所有访客记录，调用VisitorService的findAll方法获取所有访客信息（分页查询）
         if (keyword == null || "".trim().equals(keyword) || keyword.length() == 0) {
-            visitors = visitorService.findAll(page,size);
-        }else {
-            // 否则根据keyword进行搜索
-            visitors = visitorService.search(page,size,keyword);
+            visitors = visitorService.findAll(page, size);
+        } else {
+            // 否则根据keyword进行搜索，调用VisitorService的search方法，传入当前页码、每页显示数量以及关键词，进行带关键词的分页搜索操作
+            visitors = visitorService.search(page, size, keyword);
         }
 
-        // 创建分页信息对象
+        // 创建分页信息对象，通过PageInfo对查询到的访客列表进行分页相关信息的封装，如总页数、总记录数等信息都会被自动计算并封装在该对象中
         PageInfo pageInfo = new PageInfo(visitors);
-        // 将分页信息添加到ModelAndView对象中
-        mv.addObject("pageInfo",pageInfo);
-        // 设置视图名称为"visitor-list"
+        // 将分页信息添加到ModelAndView对象中，这样在视图中就可以获取并展示分页相关的信息，如页码导航、总记录数等内容
+        mv.addObject("pageInfo", pageInfo);
+        // 设置视图名称为"visitor-list"，指定要返回的视图名称，Spring会根据配置找到对应的视图文件进行渲染展示，该视图可能用于展示访客记录列表信息
         mv.setViewName("visitor-list");
-        // 返回ModelAndView对象
+        // 返回ModelAndView对象，将携带数据的视图模型返回给Spring框架，由框架进行后续的视图渲染和响应返回操作
         return mv;
     }
 
     /**
-     * 访客日志`
-     * @return ModelAndView 视图模型对象，包含访客日志列表和分页信息
-     * @throws Exception 抛出可能的异常
+     * 访客日志
+     * 该方法用于获取访客日志信息，支持分页查询，返回包含访客日志列表和分页信息的视图模型对象。
+     *
+     * @return ModelAndView 视图模型对象，包含访客日志列表和分页信息，用于指定要返回的视图以及携带相应的数据供视图展示。
+     * @throws Exception 抛出可能的异常，如数据库查询异常等情况，由调用者进行处理。
      */
     @RequestMapping("/log")
-    public ModelAndView log(@RequestParam(name = "page", required = true, defaultValue = "1") int page, @RequestParam(name = "size", required = true, defaultValue = "10") int size) throws Exception {
-        // 创建ModelAndView对象用于返回视图和数据
+    public ModelAndView log(@RequestParam(name = "page", required = true, defaultValue = "1") int page,
+                            @RequestParam(name = "size", required = true, defaultValue = "10") int size) throws Exception {
+        // 创建ModelAndView对象用于返回视图和数据，该对象可以携带数据并指定要展示的视图名称，方便Spring进行后续的视图渲染操作
         ModelAndView mv = new ModelAndView();
-        // 获取访客日志列表
-        List<Visitor> logs = visitorService.log(page,size);
-        // 创建分页信息对象
+        // 获取访客日志列表，调用VisitorService的log方法，传入当前页码和每页显示数量，获取相应分页的访客日志信息
+        List<Visitor> logs = visitorService.log(page, size);
+        // 创建分页信息对象，通过PageInfo对获取到的访客日志列表进行分页相关信息的封装，方便在视图中展示分页相关的内容
         PageInfo pageInfo = new PageInfo(logs);
-        // 将分页信息添加到ModelAndView对象中
-        mv.addObject("pageInfo",pageInfo);
-        // 设置视图名称为"visitor-log"
+        // 将分页信息添加到ModelAndView对象中，使得视图可以获取并展示如总页数、当前页码等分页相关信息
+        mv.addObject("pageInfo", pageInfo);
+        // 设置视图名称为"visitor-log"，指定要返回的视图名称，Spring会根据配置找到对应的视图文件进行渲染展示，该视图用于展示访客日志相关信息
         mv.setViewName("visitor-log");
-        // 返回ModelAndView对象
+        // 返回ModelAndView对象，将携带访客日志数据和分页信息的视图模型返回给Spring框架，由框架进行后续的视图渲染和响应返回操作
         return mv;
     }
+
     /**
      * 导出访客信息
-     * @param response HttpServletResponse对象，用于发送Excel文件作为响应
-     * @throws Exception 抛出可能的异常
+     * 该方法用于将访客信息导出为Excel文件格式，接收一个HttpServletResponse对象，用于设置响应头信息以及将Excel文件内容通过响应流发送给客户端。
+     *
+     * @param response HttpServletResponse对象，用于发送Excel文件作为响应，设置响应的相关属性（如内容类型、文件头信息等）以及输出文件内容。
+     * @throws Exception 抛出可能的异常，如文件读取异常、流操作异常等情况，由调用者进行处理。
      */
     @RequestMapping("/visitorInfo")
     public void export(HttpServletResponse response) throws Exception {
-        // 获取Excel文件的输入流
+        // 获取Excel文件的输入流，调用VisitorService的getInputStream方法获取访客信息对应的Excel文件的输入流，以便后续将文件内容发送给客户端
         InputStream is = visitorService.getInputStream();
 
-        // 设置响应的内容类型为Excel文件
+        // 设置响应的内容类型为Excel文件，指定响应的内容类型为"application/vnd.ms-excel"，告诉客户端返回的数据是Excel格式的文件，以便客户端进行正确的处理（如下载或打开操作）
         response.setContentType("application/vnd.ms-excel");
-        // 设置响应头，指示浏览器以附件形式下载文件，并设置文件名为visitorInfo.xls
-        response.setHeader("contentDisposition","attachment;filename=visitorInfo.xls");
-        // 获取响应的输出流
+        // 设置响应头，指示浏览器以附件形式下载文件，并设置文件名为visitorInfo.xls，通过设置"contentDisposition"头信息，让浏览器以附件形式下载文件，并指定文件名，方便用户保存文件
+        response.setHeader("contentDisposition", "attachment;filename=visitorInfo.xls");
+        // 获取响应的输出流，用于将Excel文件的内容写入到响应中，发送给客户端
         ServletOutputStream outputStream = response.getOutputStream();
-        // 使用IOUtils工具类将输入流的内容复制到输出流
-        IOUtils.copy(is,outputStream);
+        // 使用IOUtils工具类将输入流的内容复制到输出流，借助Apache Commons IO库提供的IOUtils工具类，方便地将Excel文件的输入流内容复制到响应的输出流中，实现文件的发送
+        IOUtils.copy(is, outputStream);
 
     }
-}
+}
\ No newline at end of file
diff --git a/src/main/java/cn/ppdxzz/dao/VisitorDao.java b/src/main/java/cn/ppdxzz/dao/VisitorDao.java
index b129544..26643b5 100644
--- a/src/main/java/cn/ppdxzz/dao/VisitorDao.java
+++ b/src/main/java/cn/ppdxzz/dao/VisitorDao.java
@@ -11,46 +11,62 @@ import java.util.List;
 
 /**
  * Description:访客持久层
+ * 该接口定义了与访客数据访问相关的操作方法，通过MyBatis的注解方式来声明SQL语句，
+ * 用于实现对数据库中访客信息表（visitors）的增、查、改等操作，每个方法对应不同的业务需求。
  *
  * @Date: 2020/2/18 16:27
  * @Author: PeiChen
  */
-// 声明这是一个数据访问对象接口
+// 声明这是一个数据访问对象接口，在Spring框架中，使用 @Repository 注解标记该接口为数据访问层组件，便于进行依赖注入和管理
 @Repository
 public interface VisitorDao {
 
     /**
      * 登记到访信息
-     * @param visitor 访客对象，包含访客的所有信息
-     * @throws Exception 抛出可能的异常
+     * 该方法用于向数据库中插入访客的到访信息，通过MyBatis的 @Insert 注解定义插入操作的SQL语句，
+     * 将访客对象中的各个属性值插入到对应的数据库表字段中。
+     *
+     * @param visitor 访客对象，包含访客的所有信息，如ID、姓名、学号、电话、访问地点、来访时间、离开时间、到访原因等，
+     *                这些属性值将按照SQL语句中的占位符对应插入到数据库的visitors表中相应字段。
+     * @throws Exception 抛出可能的异常，例如数据库连接异常、SQL执行异常等情况，由调用该方法的上层代码进行处理。
      */
     @Insert("insert into visitors(id,name,sno,phone,place,begin_date,end_date,visit_result) values(#{id},#{name},#{sno},#{phone},#{place},#{begin_date},#{end_date},#{visit_result})")
     void add(Visitor visitor) throws Exception;
 
     /**
      * 按时间晚的优先显示查询所有访客记录
-     * @return 返回访客记录列表
-     * @throws Exception 抛出可能的异常
+     * 该方法用于从数据库中查询所有访客记录，并按照来访时间（begin_date）降序排列，即时间晚的访客记录优先显示，
+     * 通过MyBatis的 @Select 注解定义查询操作的SQL语句，返回一个包含所有访客信息的列表。
+     *
+     * @return 返回访客记录列表，列表中的每个元素是一个Visitor对象，包含了从数据库中查询到的访客的各项详细信息。
+     * @throws Exception 抛出可能的异常，如数据库查询出现问题、数据转换异常等，由调用者负责处理。
      */
     @Select("select * from visitors order by begin_date desc")
     List<Visitor> findAll() throws Exception;
 
     /**
      * 访客离开后修改离开时间（访客记录注销）
-     * @param id 访客的唯一标识
-     * @param end_date 访客离开的时间
-     * @throws Exception 抛出可能的异常
+     * 该方法用于在访客离开后，更新数据库中对应访客记录的离开时间字段，通过MyBatis的 @Update 注解定义更新操作的SQL语句，
+     * 根据访客的唯一标识（ID）找到对应的记录，并将离开时间（end_date）字段更新为指定的值。
+     *
+     * @param id 访客的唯一标识，用于在数据库中定位要更新的具体访客记录，对应visitors表中的id字段。
+     * @param end_date 访客离开的时间，要更新到数据库中对应访客记录的end_date字段的值，该值通常是当前的系统时间。
+     * @throws Exception 抛出可能的异常，比如数据库更新失败、参数传递错误等情况，由调用该方法的代码进行处理。
      */
     @Update("update visitors set end_date = #{end_date} where id = #{id}")
-    void logout(@Param(value = "id") String id,@Param(value = "end_date") String end_date) throws Exception;
+    void logout(@Param(value = "id") String id, @Param(value = "end_date") String end_date) throws Exception;
 
     /**
      * 根据关键字模糊查询访客记录，并按时间倒序排列
-     * @param keyword 查询关键字
-     * @return 返回匹配关键字的访客记录列表
-     * @throws Exception 抛出可能的异常
+     * 该方法用于根据给定的关键字在数据库中对访客记录进行模糊查询，查询条件涵盖访客的多个字段（姓名、学号、电话等），
+     * 只要这些字段中包含关键字的内容就会被匹配到，并且查询结果按照来访时间（begin_date）降序排列，
+     * 通过MyBatis的 @Select 注解定义复杂的模糊查询操作的SQL语句，返回匹配关键字的访客记录列表。
+     *
+     * @param keyword 查询关键字，是一个字符串类型的值，用于在多个字段中进行模糊匹配查找符合条件的访客记录。
+     * @return 返回匹配关键字的访客记录列表，列表中的元素为Visitor对象，包含了符合模糊查询条件的访客的详细信息。
+     * @throws Exception 抛出可能的异常，像数据库查询语法错误、数据解析异常等情况，由调用者来处理这些异常情况。
      */
     @Select("select * from visitors where name like '%${keyword}%' or sno like '%${keyword}%' or phone like '%${keyword}%' or place like '%${keyword}%' or begin_date like '%${keyword}%' or end_date like '%${keyword}%' or visit_result like '%${keyword}%' order by begin_date desc ")
     List<Visitor> search(@Param(value = "keyword") String keyword) throws Exception;
 
-}
+}
\ No newline at end of file
diff --git a/src/main/java/cn/ppdxzz/domain/Visitor.java b/src/main/java/cn/ppdxzz/domain/Visitor.java
index be38320..f1f61d3 100644
--- a/src/main/java/cn/ppdxzz/domain/Visitor.java
+++ b/src/main/java/cn/ppdxzz/domain/Visitor.java
@@ -4,37 +4,48 @@ import java.io.Serializable;
 
 /**
  * Description:访客实体类
- * 用于表示访客信息，并实现Serializable接口以便于序列化
+ * 用于表示访客信息，并实现Serializable接口以便于序列化，这样该类的对象就可以在网络传输、保存到文件等场景下进行序列化和反序列化操作。
  * @Date: 2020/2/18 16:29
  * @Author: PeiChen
  */
 public class Visitor implements Serializable {
-    private String id;//uuid 全球唯一id
-    private String name;//访客姓名
-    private String sno;//访客学号
-    private String phone;//联系方式
-    private String place;//访问地址
-    private String begin_date;//来访时间
-    private String end_date;//离开时间
-    private String visit_result;//到访原因
+    // uuid 全球唯一id，用于唯一标识每个访客记录，在数据库操作等场景中可作为主键来区分不同访客
+    private String id;
+    // 访客姓名，用于记录访客的具体称呼，方便后续识别和查询访客相关信息
+    private String name;
+    // 访客学号，若访客是学生等有学号标识的群体，可通过该字段存储学号信息，便于按学号进行相关业务操作（如查询、统计等）
+    private String sno;
+    // 联系方式，存储访客的电话号码等联系信息，方便在需要时与访客进行沟通联系
+    private String phone;
+    // 访问地址，记录访客访问的具体地点，例如访问的具体校区、办公楼、房间号等信息
+    private String place;
+    // 来访时间，用于记录访客到达访问地点的具体时间，格式通常遵循一定的日期时间格式（如 yyyy-MM-dd HH:mm:ss）
+    private String begin_date;
+    // 离开时间，记录访客离开访问地点的时间，初始可能为空字符串，在访客离开时更新为实际离开时间，同样一般遵循日期时间格式
+    private String end_date;
+    // 到访原因，用于描述访客前来访问的事由，例如参加会议、拜访某人等具体原因说明
+    private String visit_result;
 
     /**
      * 默认构造函数
+     * 无参构造函数，当创建Visitor对象时若没有传入具体参数，会调用此构造函数创建一个默认的对象实例，
+     * 常用于一些框架在初始化对象或者反射创建对象等场景下。
      */
     public Visitor() {
     }
 
-
     /**
      * 带参数的构造函数，用于创建一个完整的访客对象
-     * @param id 访客的ID
-     * @param name 访客的姓名
-     * @param sno 访客的学号
-     * @param phone 访客的联系方式
-     * @param place 访客访问的地址
-     * @param begin_date 访客的来访时间
-     * @param end_date 访客的离开时间
-     * @param visit_result 访客到访的原因或结果
+     * 通过传入各个属性的值，一次性初始化访客对象的所有属性，方便在已知所有访客信息的情况下快速创建对象实例。
+     *
+     * @param id 访客的ID，传入唯一标识访客的ID值，赋值给对象的id属性，确保每个访客对象具有唯一的标识。
+     * @param name 访客的姓名，传入访客的具体姓名信息，赋值给对象的name属性，用于后续对访客姓名相关的操作。
+     * @param sno 访客的学号，传入访客对应的学号信息，赋值给对象的sno属性，便于按学号进行数据处理等操作。
+     * @param phone 访客的联系方式，传入访客的联系电话等联系方式信息，赋值给对象的phone属性，方便后续沟通联系。
+     * @param place 访客访问的地址，传入访客访问的具体地点信息，赋值给对象的place属性，用于记录访问位置相关操作。
+     * @param begin_date 访客的来访时间，传入访客到达的具体时间信息，赋值给对象的begin_date属性，记录来访时间情况。
+     * @param end_date 访客的离开时间，传入访客离开的时间信息（初始可能为空，后续更新），赋值给对象的end_date属性，记录离开时间情况。
+     * @param visit_result 访客到访的原因或结果，传入访客前来访问的具体事由等信息，赋值给对象的visit_result属性，便于知晓访问目的。
      */
     public Visitor(String id, String name, String sno, String phone, String place, String begin_date, String end_date, String visit_result) {
         this.id = id;
@@ -47,75 +58,158 @@ public class Visitor implements Serializable {
         this.visit_result = visit_result;
     }
 
-    // 以下是属性的getter和setter方法、
+    // 以下是属性的getter和setter方法，用于获取和设置对象的各个属性值，遵循JavaBean规范，方便外部类对对象属性进行访问和修改操作。
 
+    /**
+     * 获取访客的ID
+     *
+     * @return 返回访客对象的ID属性值，供外部类获取该访客的唯一标识信息。
+     */
     public String getId() {
         return id;
     }
 
+    /**
+     * 设置访客的ID
+     *
+     * @param id 传入要设置的访客ID值，用于更新访客对象的id属性，改变其唯一标识信息。
+     */
     public void setId(String id) {
         this.id = id;
     }
 
+    /**
+     * 获取访客的姓名
+     *
+     * @return 返回访客对象的姓名属性值，供外部类获取该访客的姓名信息。
+     */
     public String getName() {
         return name;
     }
 
+    /**
+     * 设置访客的姓名
+     *
+     * @param name 传入要设置的访客姓名值，用于更新访客对象的name属性，改变其姓名信息。
+     */
     public void setName(String name) {
         this.name = name;
     }
 
+    /**
+     * 获取访客的学号
+     *
+     * @return 返回访客对象的学号属性值，供外部类获取该访客的学号信息。
+     */
     public String getSno() {
         return sno;
     }
 
+    /**
+     * 设置访客的学号
+     *
+     * @param sno 传入要设置的访客学号值，用于更新访客对象的sno属性，改变其学号信息。
+     */
     public void setSno(String sno) {
         this.sno = sno;
     }
 
+    /**
+     * 获取访客的联系方式
+     *
+     * @return 返回访客对象的联系方式属性值，供外部类获取该访客的联系方式信息。
+     */
     public String getPhone() {
         return phone;
     }
 
+    /**
+     * 设置访客的联系方式
+     *
+     * @param phone 传入要设置的访客联系方式值，用于更新访客对象的phone属性，改变其联系方式信息。
+     */
     public void setPhone(String phone) {
         this.phone = phone;
     }
 
+    /**
+     * 获取访客的访问地址
+     *
+     * @return 返回访客对象的访问地址属性值，供外部类获取该访客的访问地址信息。
+     */
     public String getPlace() {
         return place;
     }
 
+    /**
+     * 设置访客的访问地址
+     *
+     * @param place 传入要设置的访客访问地址值，用于更新访客对象的place属性，改变其访问地址信息。
+     */
     public void setPlace(String place) {
         this.place = place;
     }
 
+    /**
+     * 获取访客的来访时间
+     *
+     * @return 返回访客对象的来访时间属性值，供外部类获取该访客的来访时间信息。
+     */
     public String getBegin_date() {
         return begin_date;
     }
 
+    /**
+     * 设置访客的来访时间
+     *
+     * @param begin_date 传入要设置的访客来访时间值，用于更新访客对象的begin_date属性，改变其来访时间信息。
+     */
     public void setBegin_date(String begin_date) {
         this.begin_date = begin_date;
     }
 
+    /**
+     * 获取访客的离开时间
+     *
+     * @return 返回访客对象的离开时间属性值，供外部类获取该访客的离开时间信息。
+     */
     public String getEnd_date() {
         return end_date;
     }
 
+    /**
+     * 设置访客的离开时间
+     *
+     * @param end_date 传入要设置的访客离开时间值，用于更新访客对象的end_date属性，改变其离开时间信息。
+     */
     public void setEnd_date(String end_date) {
         this.end_date = end_date;
     }
 
+    /**
+     * 获取访客的到访原因
+     *
+     * @return 返回访客对象的到访原因属性值，供外部类获取该访客的到访原因信息。
+     */
     public String getVisit_result() {
         return visit_result;
     }
 
+    /**
+     * 设置访客的到访原因
+     *
+     * @param visit_result 传入要设置的访客到访原因值，用于更新访客对象的visit_result属性，改变其到访原因信息。
+     */
     public void setVisit_result(String visit_result) {
         this.visit_result = visit_result;
     }
 
     /**
      * 重写toString方法，返回访客对象的字符串表示形式
-     * @return 访客对象的字符串表示
+     * 当使用System.out.println等方式输出访客对象或者在需要以字符串形式展示访客对象信息的场景下，会调用此方法，
+     * 方便查看访客对象各属性的具体值情况，按照指定格式返回包含所有属性值的字符串内容。
+     *
+     * @return 访客对象的字符串表示，格式为 "Visitor{" + 各属性名及对应值的字符串拼接 + '}'，清晰展示访客对象的详细信息。
      */
     @Override
     public String toString() {
@@ -130,4 +224,4 @@ public class Visitor implements Serializable {
                 ", visit_result='" + visit_result + '\'' +
                 '}';
     }
-}
+}
\ No newline at end of file
diff --git a/src/main/java/cn/ppdxzz/service/VisitorService.java b/src/main/java/cn/ppdxzz/service/VisitorService.java
index d31cf6d..cf84cc9 100644
--- a/src/main/java/cn/ppdxzz/service/VisitorService.java
+++ b/src/main/java/cn/ppdxzz/service/VisitorService.java
@@ -7,6 +7,9 @@ import java.util.List;
 
 /**
  * Description:访客服务接口，定义了访客管理相关的服务方法
+ * 该接口作为业务逻辑层与外部交互的契约，规定了一系列用于访客信息管理的方法签名，
+ * 具体的实现类需要按照这些方法定义来实现相应的业务逻辑，实现类通常会调用数据访问层的方法来完成具体操作，
+ * 并且可以被更上层的控制器层等调用，以实现对访客相关功能的处理。
  *
  * @Date: 2020/2/18 18:27
  * @Author: PeiChen
@@ -15,52 +18,91 @@ public interface VisitorService {
 
     /**
      * 添加新的访客记录
-     * @param visitor 访客对象，包含访客的详细信息
-     * @throws Exception 如果添加过程中发生错误，则抛出异常
+     * 该方法用于向系统中添加新的访客信息，接收一个包含访客详细信息的Visitor对象作为参数，
+     * 若在添加过程中出现如数据库插入失败、数据验证不通过等错误情况，则抛出异常，由调用者进行相应处理。
+     *
+     * @param visitor 访客对象，包含访客的详细信息，例如访客的姓名、学号、联系方式、访问地址、来访时间、离开时间、来访原因等属性，
+     *                这些信息将被保存到对应的存储介质（通常是数据库）中，形成一条新的访客记录。
+     * @throws Exception 如果添加过程中发生错误，比如数据库连接异常、插入操作违反数据库约束等情况，则抛出异常，
+     *                   以便调用该方法的上层代码（如控制器层）能够捕获并进行适当的错误处理，例如给用户返回错误提示信息等。
      */
     void add(Visitor visitor) throws Exception;
 
     /**
      * 查找所有访客记录，并分页显示
-     * @param page 当前页码
-     * @param size 每页显示的记录数
-     * @return 包含访客记录的列表
-     * @throws Exception 如果查询过程中发生错误，则抛出异常
+     * 该方法用于查询所有的访客记录，并按照指定的分页参数进行分页展示，返回包含访客记录的列表，
+     * 如果在查询过程中出现如数据库查询语句执行错误、分页插件配置问题等错误情况，则抛出异常。
+     *
+     * @param page 当前页码，用于指定要获取第几页的数据，是一个正整数，通过该参数结合每页显示的记录数可以确定具体的分页查询范围，
+     *             例如，page为1表示获取第一页的数据。
+     * @param size 每页显示的记录数，用于控制每页展示多少条访客记录，同样是一个正整数，例如，size为10表示每页展示10条访客记录，
+     *             它与当前页码配合实现对大量访客记录的分页查询功能。
+     * @return 包含访客记录的列表，返回的列表中的元素为Visitor对象，每个对象代表一条访客记录，包含了访客的各项详细信息，
+     *         例如访客的个人基本信息以及访问相关的时间、地点、原因等信息，这些记录是按照分页要求从所有访客记录中筛选出来的。
+     * @throws Exception 如果查询过程中发生错误，比如数据库查询失败、分页相关的逻辑出现问题等情况，则抛出异常，
+     *                   由调用该方法的上层代码（如控制器层）进行异常处理，例如给用户展示相应的错误提示页面等。
      */
-    List<Visitor> findAll(int page,int size) throws Exception;
+    List<Visitor> findAll(int page, int size) throws Exception;
 
     /**
      * 根据关键字进行搜索，并分页显示搜索结果
-     * @param page 当前页码
-     * @param size 每页显示的记录数
-     * @param keyword 搜索关键字
-     * @return 包含搜索结果的访客记录列表
-     * @throws Exception 如果搜索过程中发生错误，则抛出异常
+     * 该方法用于根据给定的关键字在所有访客记录中进行模糊搜索，并按照指定的分页参数展示搜索结果，返回符合条件的访客记录列表，
+     * 在搜索或分页过程中若出现错误情况，例如数据库查询语法错误、关键字格式不符合要求等，则抛出异常。
+     *
+     * @param page 当前页码，用于确定要获取第几页的搜索结果，通过与每页显示记录数配合来定位具体的分页数据范围，
+     *             其取值通常为正整数，代表相应的页码数。
+     * @param size 每页显示的记录数，用于限定每页展示的符合搜索条件的访客记录数量，也是正整数，与当前页码共同作用实现分页搜索功能，
+     *             比如设置为20表示每页最多展示20条符合关键字搜索的访客记录。
+     * @param keyword 搜索关键字，是一个字符串类型的值，用于在访客记录的多个字段（如姓名、学号、联系方式、访问地址等）中进行模糊匹配查找，
+     *                只要访客记录的相应字段中包含该关键字内容，就会被作为符合条件的记录筛选出来，例如，关键字为"张三"，则会查找出姓名包含"张三"的所有访客记录。
+     * @return 包含搜索结果的访客记录列表，返回的列表中的元素为Visitor对象，每个对象对应一条满足关键字模糊搜索条件的访客记录，
+     *         这些记录包含了访客完整的详细信息，并且是按照分页要求进行展示的，方便用户查看和浏览搜索到的访客信息。
+     * @throws Exception 如果搜索过程中发生错误，比如数据库查询出现语法错误、根据关键字构造查询语句时出现问题、分页设置不合理等情况，
+     *                   则抛出异常，由调用该方法的上层代码（如控制器层）进行相应的异常处理，例如给用户提示搜索失败等信息。
      */
-    List<Visitor> search(int page,int size,String keyword) throws Exception;
+    List<Visitor> search(int page, int size, String keyword) throws Exception;
 
     /**
      * 更新访客的离开时间
-     * @param id 访客的唯一标识符
-     * @param end_date 访客的离开时间
-     * @throws Exception 如果更新过程中发生错误，则抛出异常
+     * 该方法用于更新访客记录中的离开时间信息，接收访客的唯一标识符和离开时间作为参数，
+     * 在更新操作过程中若遇到如数据库更新失败、参数不合法等错误情况，则抛出异常进行相应处理。
+     *
+     * @param id 访客的唯一标识符，用于在存储访客记录的介质（通常是数据库）中准确找到对应的访客记录，
+     *           一般是一个具有唯一性的字符串值（例如使用UUID生成的唯一标识），与数据库表中的主键字段相对应，通过该标识可以唯一确定一条访客记录。
+     * @param end_date 访客的离开时间，是一个表示日期时间的字符串，其格式通常需要与数据库中存储时间的格式保持一致（如常见的 "yyyy-MM-dd HH:mm:ss" 格式），
+     *                 该值将被更新到数据库中对应访客记录的离开时间字段，用于准确记录访客离开的时间点，实现访客记录状态的更新。
+     * @throws Exception 如果更新过程中发生错误，比如数据库连接异常、更新语句执行失败、传入的参数不符合要求等情况，则抛出异常，
+     *                   由调用该方法的上层代码（如控制器层）进行异常处理，例如给用户提示更新失败等信息，并可以根据具体的业务需求进行相应的后续操作。
      */
-    void logout(String id,String end_date) throws Exception;
+    void logout(String id, String end_date) throws Exception;
 
     /**
      * 获取访客记录的输入流，通常用于导出数据
-     * @return 访客记录的输入流
-     * @throws Exception 如果获取输入流过程中发生错误，则抛出异常
+     * 该方法用于获取包含访客记录数据的输入流，一般是为了将访客记录导出到外部文件（如Excel文件等）而准备的，
+     * 在获取输入流过程中若出现如文件读取失败、数据转换错误等情况，则抛出异常进行处理。
+     *
+     * @return 访客记录的输入流，返回的输入流指向包含访客记录数据的数据源（例如内存中的数据缓冲区或者实际的文件内容等），
+     *         通过该输入流可以将访客记录数据传输到其他地方进行处理，比如在控制器层将其作为响应流发送给客户端，实现访客记录的导出功能，
+     *         客户端接收到输入流后可以将其保存为本地文件或者进行其他相应的数据展示操作。
+     * @throws Exception 如果获取输入流过程中发生错误，比如无法正确生成包含访客记录数据的流对象、读取相关数据资源时出现问题等情况，
+     *                   则抛出异常，由调用该方法的上层代码（如实现类或者控制器层等）进行异常处理，例如给用户提示导出失败等信息。
      */
     InputStream getInputStream() throws Exception;
 
     /**
      * 获取访客日志记录，并分页显示
-     * @param page 当前页码
-     * @param size 每页显示的记录数
-     * @return 包含访客日志记录的列表
-     * @throws Exception 如果获取日志记录过程中发生错误，则抛出异常
+     * 该方法用于获取访客的日志记录信息，并按照指定的分页参数进行分页展示，返回包含访客日志记录的列表，
+     * 如果在获取日志记录或者分页过程中出现错误情况，例如数据库查询错误、分页配置不当等，则抛出异常进行处理。
+     *
+     * @param page 当前页码，用于指定要获取第几页的访客日志记录数据，通过与每页显示记录数配合来确定具体的分页查询范围，
+     *             其取值应为正整数，代表相应的页码位置，例如page为2表示获取第二页的访客日志记录。
+     * @param size 每页显示的记录数，用于控制每页展示多少条访客日志记录，是一个正整数，与当前页码共同作用实现对访客日志记录的分页查询功能，
+     *             例如设置size为15表示每页展示15条访客日志记录。
+     * @return 包含访客日志记录的列表，返回的列表中的元素为Visitor对象，每个对象代表一条访客日志记录，包含了访客访问相关的详细信息，
+     *         如来访时间、离开时间、来访原因等日志信息，这些记录是按照分页要求从所有访客日志记录中筛选出来的，方便用户查看和分析访客的访问历史情况。
+     * @throws Exception 如果获取日志记录过程中发生错误，比如数据库查询语句执行失败、分页逻辑出现问题等情况，则抛出异常，
+     *                   由调用该方法的上层代码（如控制器层）进行异常处理，例如给用户展示相应的错误提示页面等。
      */
-    List<Visitor> log(int page,int size) throws Exception;
+    List<Visitor> log(int page, int size) throws Exception;
 
-}
+}
\ No newline at end of file
diff --git a/src/main/java/cn/ppdxzz/service/impl/VisitorServiceImpl.java b/src/main/java/cn/ppdxzz/service/impl/VisitorServiceImpl.java
index 9415aa3..3823ba7 100644
--- a/src/main/java/cn/ppdxzz/service/impl/VisitorServiceImpl.java
+++ b/src/main/java/cn/ppdxzz/service/impl/VisitorServiceImpl.java
@@ -14,18 +14,24 @@ import java.util.List;
 
 /**
  * Description:访客服务实现类，实现了VisitorService接口定义的方法
+ * 该类作为业务逻辑层的具体实现，负责调用数据访问层（VisitorDao）的方法来完成与访客相关的各项业务操作，
+ * 同时利用一些工具类（如PageHelper进行分页，WriteExcel进行Excel文件导出等）来处理更复杂的业务逻辑。
  *
  * @Date: 2020/2/18 18:50
  * @Author: PeiChen
  */
+// 使用 @Service 注解将该类标记为Spring框架中的服务层组件，并指定了组件的名称为 "visitorService"，方便在依赖注入时使用
 @Service("visitorService")
 public class VisitorServiceImpl implements VisitorService {
 
+    // 定义一个VisitorDao类型的成员变量，用于后续调用数据访问层的方法来操作数据库中的访客数据
     private VisitorDao visitorDao;
 
     /**
      * 通过Autowired注解自动注入VisitorDao
-     * @param visitorDao 访客数据访问对象
+     * @Autowired注解用于告诉Spring框架自动装配VisitorDao的实例到该成员变量中，
+     * 通过类型匹配找到对应的实现类并注入，使得本类可以方便地调用数据访问层的方法。
+     * @param visitorDao 访客数据访问对象，该参数接收Spring框架注入的VisitorDao的实例。
      */
     @Autowired
     public void setVisitorDao(VisitorDao visitorDao) {
@@ -34,63 +40,95 @@ public class VisitorServiceImpl implements VisitorService {
 
     /**
      * 登记到访信息
-     * @param visitor 访客对象，包含访客的详细信息
-     * @throws Exception 如果添加过程中发生错误，则抛出异常
+     * 实现VisitorService接口中定义的添加访客信息的方法，该方法接收一个Visitor对象作为参数，
+     * 通过调用VisitorDao的对应方法将访客信息持久化存储到数据库中。
+     *
+     * @param visitor 访客对象，包含访客的详细信息，如姓名、学号、联系方式、访问地址等，这些信息将被保存到数据库中对应的访客记录里。
+     * @throws Exception 如果添加过程中发生错误，例如数据库连接异常、插入数据违反约束等情况，则抛出异常，由调用该方法的上层代码进行处理。
      */
     @Override
     public void add(Visitor visitor) throws Exception {
+        // 调用VisitorDao的add方法，将传入的访客对象visitor的信息插入到数据库中，实现来访登记功能，将访客信息持久化
         visitorDao.add(visitor);
     }
 
     /**
      * 按时间晚的优先显示查询所有访客记录，并分页显示
-     * @return 包含访客记录的列表
-     * @throws Exception 如果查询过程中发生错误，则抛出异常
+     * 实现VisitorService接口中定义的查询所有访客记录的方法，该方法支持分页功能，按照来访时间降序排列查询结果，
+     * 先利用PageHelper插件设置分页参数，然后调用VisitorDao的方法从数据库中获取访客记录列表。
+     *
+     * @return 包含访客记录的列表，返回的列表中的元素为Visitor对象，每个对象代表一条访客记录，包含了访客的各项详细信息。
+     * @throws Exception 如果查询过程中发生错误，比如数据库查询语句执行失败、分页设置出现问题等，则抛出异常，由调用者负责处理。
      */
     @Override
     public List<Visitor> findAll(int page, int size) throws Exception {
-        // 使用PageHelper插件进行分页
-        PageHelper.startPage(page,size);
+        // 使用PageHelper插件进行分页，传入当前页码page和每页显示的记录数size参数，该插件会自动拦截后续的数据库查询操作，
+        // 根据设置的分页参数对查询结果进行分页处理，使得返回的结果是符合分页要求的访客记录列表
+        PageHelper.startPage(page, size);
+        // 调用VisitorDao的findAll方法，从数据库中查询所有访客记录，由于前面已经设置了分页，这里返回的结果将是分页后的访客记录列表，
+        // 按照来访时间降序排列（由VisitorDao的findAll方法中的SQL语句决定排序方式）
         return visitorDao.findAll();
     }
 
     /**
      * 根据关键字模糊查询访客记录，并按时间倒序排列，然后分页显示
-     * @param page 当前页码
-     * @param size 每页显示的记录数
-     * @param keyword 搜索关键字
-     * @return 包含搜索结果的访客记录列表
-     * @throws Exception 如果搜索过程中发生错误，则抛出异常
+     * 实现VisitorService接口中定义的根据关键字进行模糊查询访客记录的方法，支持分页功能，按照来访时间降序排列查询结果，
+     * 先利用PageHelper插件设置分页参数，然后调用VisitorDao的对应方法从数据库中获取符合关键字模糊匹配的访客记录列表。
+     *
+     * @param page 当前页码，用于指定要获取第几页的数据，通过该参数结合每页显示记录数可以确定具体的分页查询范围。
+     * @param size 每页显示的记录数，用于控制每页展示多少条符合条件的访客记录，通过和当前页码配合实现分页查询功能。
+     * @param keyword 搜索关键字，是一个字符串类型的值，用于在访客记录的多个字段（如姓名、学号等）中进行模糊匹配查找符合条件的记录。
+     * @return 包含搜索结果的访客记录列表，返回的列表中的元素为Visitor对象，每个对象代表一条符合模糊查询条件的访客记录，包含了访客的各项详细信息。
+     * @throws Exception 如果搜索过程中发生错误，例如数据库查询语法错误、分页参数设置不合理等情况，则抛出异常，由调用该方法的上层代码进行处理。
      */
     @Override
     public List<Visitor> search(int page, int size, String keyword) throws Exception {
-        // 使用PageHelper插件进行分页
-        PageHelper.startPage(page,size);
+        // 使用PageHelper插件进行分页，传入当前页码page和每页显示的记录数size参数，让插件为后续的数据库查询操作添加分页逻辑，
+        // 确保返回符合分页要求的查询结果
+        PageHelper.startPage(page, size);
+        // 调用VisitorDao的search方法，传入搜索关键字keyword，从数据库中查询所有符合关键字模糊匹配条件的访客记录，
+        // 并且按照来访时间降序排列（由VisitorDao的search方法中的SQL语句决定排序方式），最终返回分页后的符合条件的访客记录列表
         return visitorDao.search(keyword);
     }
 
     /**
      * 访客离开后修改离开时间（访客注销）
-     * @param id 访客的唯一标识符
-     * @param end_date 访客的离开时间
-     * @throws Exception 如果更新过程中发生错误，则抛出异常
+     * 实现VisitorService接口中定义的用于注销访客记录的方法，该方法接收访客的唯一标识符和离开时间作为参数，
+     * 通过调用VisitorDao的对应方法更新数据库中访客记录的离开时间字段，完成访客注销的业务逻辑。
+     *
+     * @param id 访客的唯一标识符，用于在数据库中准确找到对应的访客记录，一般是一个唯一的字符串值（如UUID），与数据库表中的主键对应。
+     * @param end_date 访客的离开时间，是一个表示日期时间的字符串，格式通常与数据库中存储时间的格式一致（如 yyyy-MM-dd HH:mm:ss），
+     *                 该值将被更新到数据库中对应访客记录的离开时间字段，用于记录访客离开的时间点。
+     * @throws Exception 如果更新过程中发生错误，比如数据库连接异常、更新语句执行失败等情况，则抛出异常，由调用该方法的上层代码进行处理。
      */
     @Override
     public void logout(String id, String end_date) throws Exception {
-        visitorDao.logout(id,end_date);
+        // 调用VisitorDao的logout方法，传入访客的唯一标识符id和离开时间end_date，在数据库中执行更新操作，
+        // 将对应访客记录的离开时间字段更新为传入的end_date值，实现访客记录的注销功能，即标记访客已经离开
+        visitorDao.logout(id, end_date);
     }
 
     /**
      * 导出访客记录到Excel文件
-     * @return 访客记录的输入流
-     * @throws Exception 如果导出过程中发生错误，则抛出异常
+     * 实现VisitorService接口中定义的导出访客记录为Excel文件的方法，该方法通过从数据库中获取所有访客记录，
+     * 整理数据格式后利用WriteExcel类将数据写入Excel文件，并返回该Excel文件对应的输入流，以便后续在控制器中通过响应流发送给客户端进行下载。
+     *
+     * @return 访客记录的输入流，返回的输入流指向包含访客记录数据的Excel文件内容，可通过该输入流将Excel文件发送给客户端，
+     *         实现访客记录的导出功能，客户端可以将接收到的输入流保存为本地的Excel文件进行查看和分析。
+     * @throws Exception 如果导出过程中发生错误，例如读取数据库数据失败、写入Excel文件出现问题、生成输入流异常等情况，则抛出异常，
+     *                   由调用该方法的上层代码（如控制器层）进行处理。
      */
     @Override
     public InputStream getInputStream() throws Exception {
-        //Excel中的每列列名，依次对应数据库的字段
-        String[] title = new String[]{"ID","姓名","学号","联系方式","访问地址","来访时间","离开时间","来访原因"};
+        // Excel中的每列列名，依次对应数据库的字段，定义一个字符串数组，用于指定要导出到Excel文件中的列标题，
+        // 这些标题与数据库中访客表的字段名相对应，方便在Excel文件中清晰展示访客记录的各项信息
+        String[] title = new String[]{"ID", "姓名", "学号", "联系方式", "访问地址", "来访时间", "离开时间", "来访原因"};
+        // 调用VisitorDao的findAll方法，从数据库中获取所有访客记录，得到一个包含所有访客信息的列表，后续将基于这些数据来填充Excel文件内容
         List<Visitor> visitors = visitorDao.findAll();
+        // 创建一个List<Object[]>类型的列表，用于存储整理后的访客数据，每个Object[]数组代表一行数据，
+        // 数组中的元素依次对应Excel文件中的每列数据（与前面定义的title列名顺序对应），方便后续将数据批量写入Excel文件
         List<Object[]> datalist = new ArrayList<>();
+        // 遍历从数据库中获取到的所有访客记录列表visitors，将每条访客记录的数据按照指定顺序整理到Object[]数组中，并添加到datalist列表中
         for (int i = 0; i < visitors.size(); i++) {
             Object[] obj = new Object[8];
             obj[0] = visitors.get(i).getId();
@@ -103,22 +141,32 @@ public class VisitorServiceImpl implements VisitorService {
             obj[7] = visitors.get(i).getVisit_result();
             datalist.add(obj);
         }
-        // 使用WriteExcel类将数据写入Excel文件
-        WriteExcel excel = new WriteExcel(title,datalist);
+        // 使用WriteExcel类将数据写入Excel文件，创建一个WriteExcel类的实例，传入列标题title和整理好的数据列表datalist，
+        // 该类内部会实现将数据按照指定格式写入到Excel文件的逻辑，并返回该Excel文件对应的输入流
+        WriteExcel excel = new WriteExcel(title, datalist);
+        // 调用WriteExcel类实例的export方法，获取包含访客记录数据的Excel文件的输入流，以便后续在控制器层将该输入流通过响应流发送给客户端，
+        // 实现访客记录的导出功能，客户端可以将接收到的输入流保存为本地的Excel文件进行查看和分析
         return excel.export();
     }
 
     /**
      * 获取访客日志记录，并分页显示
-     * @param page 当前页码
-     * @param size 每页显示的记录数
-     * @return 包含访客日志记录的列表
-     * @throws Exception 如果获取日志记录过程中发生错误，则抛出异常
+     * 实现VisitorService接口中定义的获取访客日志记录的方法，该方法支持分页功能，按照来访时间降序排列查询结果，
+     * 先利用PageHelper插件设置分页参数，然后调用VisitorDao的方法从数据库中获取访客日志记录列表。
+     *
+     * @param page 当前页码，用于指定要获取第几页的访客日志记录数据，通过该参数结合每页显示记录数可以确定具体的分页查询范围。
+     * @param size 每页显示的记录数，用于控制每页展示多少条访客日志记录，通过和当前页码配合实现分页查询功能。
+     * @return 包含访客日志记录的列表，返回的列表中的元素为Visitor对象，每个对象代表一条访客日志记录，包含了访客的各项详细信息，
+     *         例如来访时间、离开时间、来访原因等，用于展示访客的访问历史记录情况。
+     * @throws Exception 如果获取日志记录过程中发生错误，比如数据库查询语句执行失败、分页设置出现问题等情况，则抛出异常，由调用该方法的上层代码进行处理。
      */
     @Override
-    public List<Visitor> log(int page,int size) throws Exception {
-        // 使用PageHelper插件进行分页
-        PageHelper.startPage(page,size);
+    public List<Visitor> log(int page, int size) throws Exception {
+        // 使用PageHelper插件进行分页，传入当前页码page和每页显示的记录数size参数，该插件会自动拦截后续的数据库查询操作，
+        // 根据设置的分页参数对查询结果进行分页处理，使得返回的结果是符合分页要求的访客日志记录列表
+        PageHelper.startPage(page, size);
+        // 调用VisitorDao的findAll方法，从数据库中查询所有访客日志记录，由于前面已经设置了分页，这里返回的结果将是分页后的访客日志记录列表，
+        // 按照来访时间降序排列（由VisitorDao的findAll方法中的SQL语句决定排序方式）
         return visitorDao.findAll();
     }
-}
+}
\ No newline at end of file
diff --git a/src/main/webapp/WEB-INF/jsp/visitor-list.jsp b/src/main/webapp/WEB-INF/jsp/visitor-list.jsp
index 8903391..1584988 100644
--- a/src/main/webapp/WEB-INF/jsp/visitor-list.jsp
+++ b/src/main/webapp/WEB-INF/jsp/visitor-list.jsp
@@ -6,98 +6,135 @@
   To change this template use File | Settings | File Templates.
 --%>
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
+<!-- 声明该JSP页面的内容类型是HTML格式，字符编码采用UTF-8，表明页面中使用Java语言编写服务器端逻辑 -->
+
 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"  %>
+<!-- 引入JSTL（JavaServer Pages Standard Tag Library）的核心标签库，设置前缀为“c”，方便后续在JSP页面中使用其提供的各种标签进行逻辑判断、循环遍历等操作 -->
+
 <html class="x-admin-sm">
 <head>
-    <!-- 设置页面字符编码为UTF-8 -->
+    <!-- 设置页面的字符编码为UTF-8，确保页面在浏览器中能正确显示各种字符，避免出现乱码情况 -->
     <meta charset="UTF-8">
     <title></title>
-    <!-- 设置页面渲染引擎为webkit -->
+    <!-- 设置页面渲染所使用的引擎为webkit，它能让页面在支持webkit的浏览器中以相应的渲染方式呈现，提供较好的页面展示效果 -->
     <meta name="renderer" content="webkit">
-    <!-- 确保在IE浏览器中使用最新版本的渲染模式，并优先使用Chrome框架 -->
+    <!-- 声明页面在IE浏览器中的兼容模式，使页面在IE浏览器中以其最高版本的模式进行渲染，若安装了Chrome Frame，则优先使用Chrome Frame来渲染，以增强兼容性和展示效果 -->
     <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
 
-    <!-- 引入CSS文件，设置页面样式 -->
+    <!-- 引入自定义的字体样式表，路径通过EL表达式结合pageContext对象获取项目相对路径，用于设置页面中文字的字体、字号、颜色等样式相关属性 -->
     <link rel="stylesheet" href="${pageContext.request.contextPath}/css/font.css">
+    <!-- 引入自定义的xadmin样式表，通过EL表达式结合pageContext获取相对路径，用于构建页面整体的xadmin风格布局与样式，比如页面的整体色调、各组件的样式等 -->
     <link rel="stylesheet" href="${pageContext.request.contextPath}/css/xadmin.css">
+    <!-- 引入Bootstrap框架的样式表，同样借助EL表达式结合pageContext获取路径，Bootstrap可以帮助快速搭建页面的响应式布局以及提供各种常用的UI组件样式 -->
     <link rel="stylesheet" href="${pageContext.request.contextPath}/css/bootstrap.css">
-    <!-- 引入JavaScript文件，为页面添加交互功能 -->
+
+    <!-- 引入jQuery库，其路径通过EL表达式结合pageContext获取项目相对路径，jQuery是一个常用的JavaScript库，方便在页面中操作DOM元素、处理事件、发起AJAX请求等 -->
     <script type="text/javascript" src="${pageContext.request.contextPath}/js/jquery-3.1.1.js"></script>
+    <!-- 引入layui框架的JavaScript文件，指定字符编码为utf-8，layui用于构建页面交互效果，提供了丰富的UI组件和交互功能，便于开发者打造具有良好用户体验的页面 -->
     <script src="${pageContext.request.contextPath}/lib/layui/layui.js" charset="utf-8"></script>
+    <!-- 引入自定义的xadmin相关的JavaScript文件，通过EL表达式结合pageContext获取路径，这个文件可能包含了针对xadmin页面特有的交互逻辑和功能实现 -->
     <script type="text/javascript" src="${pageContext.request.contextPath}/js/xadmin.js"></script>
+    <!-- 引入Bootstrap的JavaScript文件，通过EL表达式结合pageContext获取路径，用于实现Bootstrap框架相关的交互功能，例如一些组件的动态效果等 -->
     <script type="text/javascript" src="${pageContext.request.contextPath}/js/bootstrap.js"></script>
+    <!-- 引入layer弹窗插件的JavaScript文件，通过EL表达式结合pageContext获取路径，layer插件常用于在页面中弹出提示框、确认框、加载层等交互效果，增强用户与页面的交互性 -->
     <script type="text/javascript" src="${pageContext.request.contextPath}/layer/layer.js"></script>
 
-    <!-- 对于IE9以下版本的浏览器，引入兼容性脚本 -->
-    <!--[if lt IE 9]>
+    <!--[if lt IE 9] -->
+    <!-- 条件注释，针对IE浏览器版本小于9的情况，引入html5shiv库，其作用是让旧版本的IE浏览器能够支持HTML5的新标签，使得页面在这些旧浏览器中能正常解析HTML5相关的结构 -->
     <script src="https://cdn.staticfile.org/html5shiv/r29/html5.min.js"></script>
+    <!-- 引入respond.js库，用于让旧版本IE浏览器支持CSS3媒体查询，确保页面在不同设备尺寸下的样式适配能在旧IE浏览器中正常工作 -->
     <script src="https://cdn.staticfile.org/respond.js/1.4.2/respond.min.js"></script>
     <![endif]-->
 
-    <!-- 定义JavaScript函数，用于改变每页显示的数据条数 -->
     <script>
         function changePageSize() {
-            //获取下拉框的值
+            // 获取id为changePageSize的下拉框元素的值，这个值代表了用户期望设置的每页显示数据的条数，
+            // 通过jQuery选择器$("#changePageSize")选中该下拉框元素，再使用.val()方法获取其当前选中的值
             var pageSize = $("#changePageSize").val();
-            //向服务器发送请求，改变每页显示条数，并重置页码为1
+            // 通过修改浏览器地址栏的URL向服务器发送请求，请求的路径是/visitor/findAll，传递参数page=1表示显示第一页，
+            // size为获取到的下拉框的值，以此改变每页显示的条数，实现用户切换每页显示数据量的功能，
+            // 这里利用了location.href属性来重定向页面到指定的URL
             location.href = "${pageContext.request.contextPath}/visitor/findAll?page=1&size="+ pageSize;
         }
+
         $("#serarch_btn").click(function () {
+            // 获取id为keyword的输入框元素的值，通常这个值是用户输入的用于搜索的关键词，例如访客姓名、学号等，
+            // 通过jQuery选择器$("#keyword")选中该输入框元素，再使用.val()方法获取其当前输入的值
             var keyword = $("#keyword").val();
-            // 根据关键词搜索，重置页码为1，每页显示5条记录
+            // 通过修改浏览器地址栏的URL向服务器发送请求，请求的路径是/visitor/findAll，传递参数page=1表示显示第一页，
+            // size=5表示每页显示5条记录，keyword为获取到的搜索关键词，用于根据用户输入的关键词进行搜索并展示相应的访客信息，
+            // 同样利用location.href属性来重定向页面到指定的带有搜索参数的URL
             location.href="${pageContext.request.contextPath}/visitor/findAll?page=1&size=5&keyword="+keyword;
         });
+
         $("#refresh").click(function () {
+            // 尝试重置id为myform的表单元素（此处重置方式可能不准确，更准确的写法可能是$("#myform")[0].reset(); ），目的是将表单内的输入框等元素的值重置为初始状态，
+            // 例如清空用户输入的搜索关键词等内容，不过当前写法依赖于具体的表单库是否支持这样直接调用reset方法，可能存在兼容性问题
             $("#myform").reset();
-            // 重置表单，并请求第一页的数据，每页显示5条记录
+            // 通过修改浏览器地址栏的URL向服务器发送请求，请求的路径是/visitor/findAll，传递参数page=1表示显示第一页，
+            // size=5表示每页显示5条记录，达到刷新页面数据的效果，即将页面恢复到初始的显示状态，展示第一页且每页显示5条记录的数据情况，
+            // 借助location.href属性来实现页面重定向到相应的URL
             location.href="${pageContext.request.contextPath}/visitor/findAll?page=1&size=5";
         });
     </script>
 </head>
 <body>
+<%-- 以下这部分代码被注释掉了，原本可能是用于展示页面导航相关元素，包含面包屑导航以及一个刷新按钮，点击按钮可刷新页面，但当前处于注释状态，不会在页面中显示生效 --%>
 <%--<div class="x-nav">
-          <span class="layui-breadcrumb">
-            <a href="">首页</a>
-            <a href="">演示</a>
-            <a>
-              <cite>导航元素</cite></a>
-          </span>
-    <a class="layui-btn layui-btn-small" style="line-height:1.6em;margin-top:3px;float:right" onclick="location.reload()" title="刷新">
-        <i class="layui-icon layui-icon-refresh" style="line-height:30px"></i></a>
+      <span class="layui-breadcrumb">
+        <a href="">首页</a>
+        <a href="">演示</a>
+        <a>
+          <cite>导航元素</cite></a>
+      </span>
+<a class="layui-btn layui-btn-small" style="line-height:1.6em;margin-top:3px;float:right" onclick="location.reload()" title="刷新">
+    <i class="layui-icon layui-icon-refresh" style="line-height:30px"></i></a>
 </div>--%>
 
-<%-- 页面主体部分，使用LayUI流体布局 --%>
+<!-- 使用layui-fluid类创建一个流体布局容器，使得内部的元素可以根据页面宽度自适应排列，常用于实现响应式布局 -->
 <div class="layui-fluid">
+    <!-- 创建一个layui的行元素，layui-col-space15表示设置列间距为15像素，用于对内部的列元素进行布局管理 -->
     <div class="layui-row layui-col-space15">
+        <!-- 创建一个占12列的layui列元素，在layui的栅格系统中，一行默认分为12列，这里表示占满一整行 -->
         <div class="layui-col-md12">
+            <!-- 创建一个layui卡片组件，用于将内部的内容以卡片的形式展示，通常有边框、阴影等样式效果，使页面结构更清晰美观 -->
             <div class="layui-card">
-                <%-- 表单区域，用于搜索 --%>
+                <!-- 创建卡片的主体内容区域，用于放置表单相关元素 -->
                 <div class="layui-card-body ">
+                    <!-- 创建一个id为myform的表单，应用layui的表单样式类layui-form，并且设置列间距为5像素，用于布局表单内的各个元素 -->
                     <form id="myform" class="layui-form layui-col-space5">
-                        <%-- 搜索框 --%>
+                        <!-- 创建一个行内块元素，layui-show-xs-block表示在小屏幕（如手机端）下显示该元素，方便在不同屏幕尺寸下进行布局控制 -->
                         <div class="layui-inline layui-show-xs-block">
+                            <!-- 创建一个文本输入框，设置自动补全关闭（autocomplete="off"），添加提示占位文本“请输入关键字”，指定name和id属性，
+                            并且其值通过EL表达式从请求参数中获取名为keyword的值（如果有的话），方便实现根据用户输入的关键字进行搜索功能 -->
                             <input class="layui-input" type="text" autocomplete="off" placeholder="请输入关键字" name="keyword" id="keyword" value="${param.keyword}">
                         </div>
-                        <%-- 搜索按钮 --%>
+                        <!-- 创建一个按钮，应用layui的按钮样式类layui-btn，指定id为serarch_btn（此处可能有拼写错误，正确应为search_btn），
+                        并设置了layui表单相关的提交和过滤属性（lay-submit和lay-filter），按钮内包含一个layui图标，点击该按钮可能触发表单提交或者搜索操作 -->
                         <div class="layui-inline layui-show-xs-block">
                             <button class="layui-btn"  id="serarch_btn" lay-submit="" lay-filter="sreach"><i class="layui-icon">&#xe615;</i></button>
                         </div>
-                        <%-- 重置按钮（回到第一页） --%>
+                        <!-- 创建一个链接样式的按钮，应用layui的正常样式类layui-btn-normal，点击后跳转到指定路径（路径通过EL表达式结合pageContext生成，
+                        用于获取所有访客信息并设置每页显示5条数据），按钮内包含一个layui图标，可能用于实现回到第一页且每页显示固定条数数据的功能，通常作为重置按钮的一种体现 -->
                         <div class="layui-inline layui-show-xs-block x-right">
                             <a class="layui-btn layui-btn-normal" href="${pageContext.request.contextPath}/visitor/findAll?page=1&size=5"><i class="layui-icon">&#xe669;</i></a>
                         </div>
                     </form>
                 </div>
-                <%-- 导出按钮和总数据条数显示 --%>
+                <!-- 自定义的<xblock>标签，具体功能可能由相关的CSS或JavaScript根据业务逻辑来定义，在这里用于包裹导出按钮和总数据条数显示相关的元素 -->
                 <xblock>
-                        <a onclick="exportInfo(${sessionScope.adminInfo.power})" class="layui-btn layui-btn-warm" href="javascript:;"><i class="layui-icon">&#xe67c;</i>导出</a>
+                    <!-- 创建一个链接样式按钮，点击时调用exportInfo函数并传入管理员权限值（从会话中获取），按钮显示为“导出”，包含一个layui图标，用于触发导出访客数据的相关操作 -->
+                    <a onclick="exportInfo(${sessionScope.adminInfo.power})" class="layui-btn layui-btn-warm" href="javascript:;"><i class="layui-icon">&#xe67c;</i>导出</a>
+                    <!-- 显示总的访客数据条数信息，设置了行高为40px的样式，靠右对齐（通过x-right类实现），用于向用户展示当前访客数据的总量情况 -->
                     <span class="x-right" style="line-height:40px">共有数据：${pageInfo.total} 条</span>
                 </xblock>
-                <%-- 数据表格区域 --%>
+                <!-- 创建另一个卡片主体内容区域，可能用于展示不同部分的内容，这里用于放置访客信息表格 -->
                 <div class="layui-card-body">
+                    <!-- 创建一个使用layui样式的表格，同时应用layui的表单样式，方便后续可能的表单相关交互操作（比如行内编辑等） -->
                     <table class="layui-table layui-form">
                         <thead>
                         <tr style="text-align: center">
+                            <!-- 创建表格的表头行，设置文本居中显示 -->
                             <th style="text-align: center">ID</th>
                             <th style="text-align: center">姓名</th>
                             <th style="text-align: center">学号</th>
@@ -106,34 +143,41 @@
                             <th style="text-align: center">来访时间</th>
                             <th style="text-align: center">离开时间</th>
                             <th style="text-align: center">到访原因</th>
-                            <!-- 如果管理员权限大于2，则显示操作列 -->
+                            <!-- 通过JSTL的条件判断，如果管理员权限大于2，则显示操作列，用于放置针对访客记录的操作按钮（比如删除、修改等操作） -->
                             <c:if test="${sessionScope.adminInfo.power > 2}">
-                            <th style="text-align: center">操作</th>
+                                <th style="text-align: center">操作</th>
                             </c:if>
+                        </tr>
                         </thead>
                         <tbody>
-                        <%-- 使用JSP脚本循环遍历访客列表 --%>
                         <%
-                            int j = 1; // 初始化计数器，用于行编号
+                            // 在JSP脚本片段中定义一个局部变量j并初始化为1，用于给表格中的数据行编号，混合使用了JSP脚本片段和JSTL标签库来构建表格数据展示
+                            int j = 1;
                         %>
-                        <!-- 遍历分页后的访客列表 -->
+                        <!-- 使用JSTL的forEach标签循环遍历pageInfo.list中的数据（通常是分页后的访客列表集合），每次循环将当前元素赋值给visitor变量，方便在表格中展示各个访客的详细信息 -->
                         <c:forEach items="${pageInfo.list}" var="visitor">
                         <tr id="light" style="text-align: center">
+                            <!-- 在表格行数据中，第一列显示行号，通过JSP脚本片段输出变量j的值，并在每次循环后自增1，实现逐行编号的效果 -->
                             <td><%=j++%></td>
+                            <!-- 通过EL表达式从名为visitor的对象中获取姓名属性值，展示访客的姓名信息 -->
                             <td>${visitor.name}</td>
+                            <!-- 通过EL表达式从名为visitor的对象中获取学号属性值，展示访客的学号信息 -->
                             <td>${visitor.sno}</td>
-                            <td>${visitor.phone}</td>
+                            <!-- 通过EL表达式从名为visitor的对象中获取联系方式属性值，展示访客的联系方式信息 -->
                             <td>${visitor.place}</td>
+                            <!-- 通过EL表达式从名为visitor的对象中获取来访时间属性值，展示访客的来访时间信息 -->
                             <td>${visitor.begin_date}</td>
-                            <%-- 判断访客是否已离开 --%>
+                            <!-- 通过JSTL的条件判断访客的离开时间是否为空，如果为空则显示“尚未离开”，用于提示访客当前是否还在访问中 -->
                             <c:if test="${visitor.end_date == null || visitor.end_date == ''}">
                                 <td>尚未离开</td>
                             </c:if>
-                            <c:if test="${visitor.end_date != ''}">
+                            <!-- 如果离开时间不为空，则通过EL表达式获取并显示具体的离开时间 -->
+                            <c:if test="${visitor.end_date!= ''}">
                                 <td>${visitor.end_date}</td>
                             </c:if>
                             <td>${visitor.visit_result}</td>
-                            <!-- 如果管理员权限大于2，则显示注销按钮 -->
+                            <!-- 通过JSTL的条件判断，如果管理员权限大于2，则显示操作列中的具体操作按钮，这里定义一个链接，点击时调用toUpdate函数并传入访客的id，
+                            按钮显示为一个图标，提示文本为“注销访客”，用于触发注销访客记录的相关操作 -->
                             <c:if test="${sessionScope.adminInfo.power > 2}">
                                 <td class="td-manage">
                                     <a title="注销访客" onclick="toUpdate('${visitor.id}');"  href="javascript:;">
@@ -146,114 +190,283 @@
                         </tbody>
                     </table>
                 </div>
-                <%-- 分页控制区域 --%>
+                <!-- 设置该元素向左浮动，常用于布局排版，使其在页面中向左对齐排列 -->
                 <div class="pull-left">
+                    <!-- 创建一个表单组，设置为行内表单样式，方便在一行内展示多个表单相关元素 -->
                     <div class="form-group form-inline">
+                        <!-- 显示分页相关信息，如总页数、当前页码等，告知用户当前的分页情况 -->
                         共&nbsp;${pageInfo.pages}&nbsp;页&emsp;当前页：${pageInfo.pageNum}&nbsp;/&nbsp;${pageInfo.pages}&emsp; 每页
-                        <!-- 下拉菜单选择每页显示条数 -->
+                        <!-- 创建一个下拉菜单，应用表单控件的样式类form-control，绑定了id为changePageSize，当下拉框选项改变时会调用changePageSize函数来改变每页显示条数 -->
                         <select class="form-control" id="changePageSize" onchange="changePageSize()">
+                            <!-- 为下拉菜单添加各个选项，每个<option>标签代表一个可选择的每页显示条数的值，
+                            初始显示的值通过EL表达式从pageInfo对象中获取相关属性值，用户可选择不同的选项来改变每页显示的数据量 -->
                             <option value="1">${pageInfo.size}</option>
                             <option value="5">5</option>
                             <option value="10">10</option>
+                            // 这是一个下拉菜单中的选项（<option>）标签，表示当用户选择该项时，
+                            // 对应的值为10，意味着每页显示10条数据，用于设置每页显示数据量的可选项之一
+
                             <option value="15">15</option>
+                            // 同样是下拉菜单中的选项标签，选择该项则表示每页显示15条数据，是提供给用户选择每页数据条数的一个选项
+
                             <option value="20">20</option>
+                            // 下拉菜单中的选项标签，若用户选择此项，每页将显示20条数据，作为可配置每页显示数量的一个选项
+
                         </select> 条
+                            <!-- 结束下拉菜单标签，“条”字可能是用于在页面上更友好地提示用户该下拉菜单是用于选择每页显示数据的条数 -->
                     </div>
+                    // 结束一个外层的div容器，这个div可能用于布局，包裹与每页显示条数选择相关的元素等
+
                 </div>
-                <%-- 分页按钮逻辑控制 --%>
+                // 结束另一个外层的div容器，可能在页面布局层级中处于更上层，具体作用需结合整体页面结构来看
+
+                <!-- 分页按钮逻辑控制 -->
+                // 这是一个HTML注释，用于说明下面的代码块主要是用于控制分页按钮的显示逻辑，方便后续阅读和维护代码
+
                 <c:choose>
+                    // 使用JSTL（JavaServer Pages Standard Tag Library）的标签，开始一个条件选择结构，
+                    // 类似于Java中的switch语句，用于根据不同条件执行不同的逻辑分支
+
                     <c:when test="${pageInfo.pages < 5}">
+                    // 标签表示一个具体的条件分支，这里的条件是判断pageInfo对象中的pages属性（通常表示总页数）是否小于5，
+                        // 如果满足该条件，则执行此分支内的代码
+
                         <c:set var="begin" value="1">
+                        // 使用标签在JSP页面中设置一个名为“begin”的变量，值设置为1，
+                            // 这个变量可能后续用于确定分页页码显示的起始范围等相关逻辑
+
                         </c:set>
                         <c:set var="end" value="${pageInfo.pages}">
+                        // 同样使用标签设置一个名为“end”的变量，其值设置为pageInfo对象中的pages属性值（即总页数），
+                            // 用于配合“begin”变量来确定分页页码显示的范围
+
                         </c:set>
                     </c:when>
                     <c:when test="${pageInfo.pageNum <= 3}">
+                    // 另一个条件分支，判断pageInfo对象中的pageNum属性（通常表示当前页码）是否小于等于3，
+                        // 如果满足该条件，则执行此分支内的代码，用于设置不同情况下分页页码显示的范围
+
                         <c:set var="begin" value="1">
+                            // 设置名为“begin”的变量值为1，为后续确定分页页码显示范围做准备
+
                         </c:set>
                         <c:set var="end" value="5">
+                            // 设置名为“end”的变量值为5，结合“begin”变量来确定在当前页码小于等于3这种情况下分页页码显示的范围
+
                         </c:set>
                     </c:when>
-                    <c:when test="${pageInfo.pageNum > 3 and pageInfo.pageNum <= pageInfo.pages-2}">
+                    <c:when test="${pageInfo.pageNum > 3 and pageInfo.pageNum <= pageInfo.pages - 2}">
+                    // 又一个条件分支，判断当前页码（pageInfo.pageNum）大于3并且小于等于总页数减2时执行此分支内的代码，
+                        // 用于根据当前页码在特定区间时设置分页页码显示的范围
+
                         <c:set var="begin" value="${pageInfo.pageNum - 2}">
+                            // 根据当前页码动态计算“begin”变量的值，将其设置为当前页码减2，以此来确定合适的分页页码显示起始范围
+
                         </c:set>
                         <c:set var="end" value="${pageInfo.pageNum + 2}">
+                            // 根据当前页码动态计算“end”变量的值，设置为当前页码加2，与“begin”变量配合确定分页页码显示的范围
+
                         </c:set>
                     </c:when>
                     <c:otherwise>
+                    // otherwise标签表示当上述所有条件都不满足时执行的代码分支，相当于Java中switch语句的default分支
+
                         <c:set var="begin" value="${pageInfo.pages - 4}">
+                            // 设置名为“begin”的变量值为总页数减4，用于确定在其他情况之外的分页页码显示起始范围
+
                         </c:set>
                         <c:set var="end" value="${pageInfo.pages}">
+                            // 设置名为“end”的变量值为总页数，与“begin”变量配合确定分页页码显示的范围
+
                         </c:set>
                     </c:otherwise>
                 </c:choose>
-                <div class="layui-card-body x-right" style="height: min-content">
-                    <div class="page">
-                        <div>
-                            <a class="next" href="${pageContext.request.contextPath}/visitor/findAll?page=1&size=${pageInfo.pageSize}&keyword=${param.keyword}">首页</a>
-                            <c:if test="${pageInfo.pageNum > 1}">
-                                <a class="prev" href="${pageContext.request.contextPath}/visitor/findAll?page=${pageInfo.pageNum-1}&size=${pageInfo.pageSize}&keyword=${param.keyword}">上一页</a>
-                            </c:if>
-                            <c:forEach var="i" begin="${begin}" end="${end}" step="1">
-                                <c:if test="${pageInfo.pageNum == i}">
-                                    <span class="current">${i}</span>
-                                </c:if>
-                                <c:if test="${pageInfo.pageNum != i}">
-                                    <a class="num" href="${pageContext.request.contextPath}/visitor/findAll?page=${i}&size=${pageInfo.pageSize}&keyword=${param.keyword}">${i}</a>
-                                </c:if>
-                            </c:forEach>
-                            <!-- 下一页链接，当不是最后一页时显示 -->
-                            <c:if test="${pageInfo.pageNum < pageInfo.pages}">
-                                <a class="next" href="${pageContext.request.contextPath}/visitor/findAll?page=${pageInfo.pageNum+1}&size=${pageInfo.pageSize}&keyword=${param.keyword}">下一页</a>
-                            </c:if>
-                            <!-- 尾页链接 -->
-                            <a class="next" href="${pageContext.request.contextPath}/visitor/findAll?page=${pageInfo.pages}&size=${pageInfo.pageSize}&keyword=${param.keyword}">尾页</a>
-                        </div>
-                    </div>
+    <div class="layui-card-body x-right" style="height: min-content">
+    // 创建一个使用layui样式的卡片主体内容区域（layui-card-body），并应用了x-right类（可能用于控制布局靠右显示等），
+    // 设置了高度样式为min-content，使该区域的高度根据其内部内容自适应，最小化高度占用
+
+    <div class="page">
+    // 创建一个自定义类名为“page”的<div>容器，可能用于专门放置分页相关的按钮等元素，进行布局分组
+
+    <div>
+    // 再创建一个内层的<div>容器，用于进一步细化分页按钮等元素的布局
+
+    <a class="next" href="${pageContext.request.contextPath}/visitor/findAll?page=1&size=${pageInfo.pageSize}&keyword=${param.keyword}">首页</a>
+    // 创建一个链接，应用了名为“next”的类（可能有对应的CSS样式用于外观控制），
+    // href属性通过EL表达式拼接出具体的URL路径，用于跳转到访客信息列表的第一页，同时传递了每页显示条数（pageInfo.pageSize）和搜索关键词（param.keyword）等参数，
+    // 链接显示的文本为“首页”，方便用户点击回到第一页
+
+    <c:if test="${pageInfo.pageNum > 1}">
+        // 使用JSTL的条件判断标签，判断pageInfo对象中的pageNum属性（当前页码）是否大于1，
+        // 如果满足该条件，则执行此标签内包含的代码，用于判断是否显示上一页按钮
+
+        <a class="prev" href="${pageContext.request.contextPath}/visitor/findAll?page=${pageInfo.pageNum - 1}&size=${pageInfo.pageSize}&keyword=${param.keyword}">上一页</a>
+        // 创建一个链接，应用“prev”类（可能对应特定样式），href属性通过EL表达式拼接出URL路径，
+        // 用于跳转到上一页（当前页码减1），同时传递每页显示条数和搜索关键词等参数，链接显示文本为“上一页”，方便用户进行翻页操作
+
+    </c:if>
+        <c:forEach var="i" begin="${begin}" end="${end}" step="1">
+            // 使用JSTL的forEach循环标签，开始一个循环，循环变量为“i”，循环的起始值为之前设置的“begin”变量的值，
+            // 结束值为“end”变量的值，步长为1，即依次遍历从“begin”到“end”范围的每一个值，用于生成分页页码链接
+
+            <c:if test="${pageInfo.pageNum == i}">
+            // 在循环内部，再次使用条件判断标签，判断当前页码（pageInfo.pageNum）是否等于循环变量“i”的值，
+                // 如果相等，则执行此标签内的代码，用于对当前页码进行特殊样式显示等处理
+
+                <span class="current">${i}</span>
+                // 创建一个span标签，应用了“current”类（可能有对应的突出显示当前页码的样式），并通过EL表达式显示循环变量“i”的值，
+                // 用于将当前页码以特定样式展示出来，与其他页码区分开
+
+            </c:if>
+            <c:if test="${pageInfo.pageNum!= i}">
+            // 另一个条件判断标签，判断当前页码是否不等于循环变量“i”的值，如果不相等，则执行此标签内的代码，
+                // 用于生成普通的页码链接（非当前页码的情况）
+
+                <a class="num" href="${pageContext.request.contextPath}/visitor/findAll?page=${i}&size=${pageInfo.pageSize}&keyword=${param.keyword}">${i}</a>
+                // 创建一个链接，应用“num”类（可能对应普通页码链接的样式），href属性通过EL表达式拼接出URL路径，
+                // 用于跳转到对应页码（循环变量“i”表示的页码），同时传递每页显示条数和搜索关键词等参数，链接内通过EL表达式显示循环变量“i”的值作为页码显示内容，方便用户点击跳转到相应页码
+
+            </c:if>
+        </c:forEach>
+            <!-- 下一页链接，当不是最后一页时显示 -->
+            // 这是一个HTML注释，说明下面的代码是用于在不是最后一页的情况下显示下一页的链接
+
+            <c:if test="${pageInfo.pageNum < pageInfo.pages}">
+                // 使用JSTL的条件判断标签，判断当前页码（pageInfo.pageNum）是否小于总页数（pageInfo.pages），
+                // 如果满足该条件，则执行此标签内的代码，用于判断是否显示下一页链接
+
+                <a class="next" href="${pageContext.request.contextPath}/visitor/findAll?page=${pageInfo.pageNum + 1}&size=${pageInfo.pageSize}&keyword=${param.keyword}">下一页</a>
+                // 创建一个链接（<a>标签），应用“next”类，href属性通过EL表达式拼接出URL路径，用于跳转到下一页（当前页码加1），
+                // 同时传递每页显示条数和搜索关键词等参数，链接显示文本为“下一页”，方便用户进行翻页操作
+
+            </c:if>
+                <!-- 尾页链接 -->
+                // 这是一个HTML注释，说明下面的代码是用于显示尾页的链接
+
+                <a class="next" href="${pageContext.request.contextPath}/visitor/findAll?page=${pageInfo.pages}&size=${pageInfo.pageSize}&keyword=${param.keyword}">尾页</a>
+                // 创建一个链接，应用“next”类，href属性通过EL表达式拼接出URL路径，用于跳转到最后一页（总页数对应的页码），
+                // 同时传递每页显示条数和搜索关键词等参数，链接显示文本为“尾页”，方便用户直接跳转到最后一页
+
                 </div>
-            </div>
-        </div>
-    </div>
-</div>
-
-<script>
-    //导出Excel操作
-    function exportInfo(power) {
-        // 检查当前用户的权限等级，如果权限小于3，则没有导出权限
-        if (power < 3) {
-            // 使用layer插件显示提示信息，告知用户没有权限
-            layer.msg('对不起，您没有权限导出访客记录');
-            return false;
-        }
-        // 弹出确认框询问用户是否确定要导出所有访客数据
-        layer.confirm('确定导出所有访客数据吗？',function (index) {
-            // 当用户点击确定时，重定向到导出访客信息的URL
-            location.href="${pageContext.request.contextPath}/visitor/visitorInfo";
-            layer.close(index); // 关闭确认框
-        });
+                // 结束内层的<div>容器，该容器用于放置分页相关的各个链接按钮等元素
+
+                </div>
+                // 结束类名为“page”的<div>容器，其整体用于对分页相关元素进行布局分组
+
+                </div>
+                // 结束应用了layui样式和特定布局类（x-right等）的卡片主体内容区域的<div>容器
+
+                </div>
+                // 结束外层的一个<div>容器，其在页面布局层级中有相应的位置和作用（结合整体结构确定）
+
+                </div>
+                // 结束另一个外层的<div>容器，同样在页面布局中处于一定层级，与整体页面结构相关
+
+                </div>
+                // 结束可能是更外层的一个<div>容器，是页面布局中的一部分
+
+                </div>
+                // 结束最外层的一个div容器，完成整个页面主体部分的布局结构
+
+                </div>
+                // 结束包含页面主体流体布局（layui-fluid）的div容器，该容器实现了页面的整体流体布局效果
+
+                </div>
+                // 结束包含页面主体行布局（layui-row）的div容器，该行布局内设置了列间距等用于管理列元素的布局
+
+                </div>
+                // 结束包含页面主体列布局（layui-col-md12）的div容器，该列布局占满中等屏幕及以上尺寸下的一行
+
+                </div>
+                // 结束layui卡片（layui-card）组件的div容器，卡片组件用于以卡片形式展示内部内容，使页面结构更清晰美观
+
+                </body>
+                // 结束HTML页面的body部分，body内包含了页面实际展示的所有内容元素
+
+                <script>
+                // 开始JavaScript代码块，用于定义在页面中可执行的客户端脚本逻辑
+                //导出Excel操作
+                // 这是一个JavaScript函数的注释，说明下面定义的函数主要用于处理导出Excel相关的操作
+
+function exportInfo(power) {
+// 定义一个名为exportInfo的JavaScript函数，接收一个名为power的参数，该参数可能用于表示用户权限等相关信息，
+// 用于在函数内部根据权限判断是否允许执行导出操作
+
+// 检查当前用户的权限等级，如果权限小于3，则没有导出权限
+    if (power < 3) {
+        // 使用if条件语句判断传入的权限值（power）是否小于3，如果小于3则表示用户没有导出权限，执行下面的代码块
+
+        // 使用layer插件显示提示信息，告知用户没有权限
+        layer.msg('对不起，您没有权限导出访客记录');
+        // 调用layer插件提供的msg方法，弹出一个提示框，显示“对不起，您没有权限导出访客记录”的提示信息，告知用户当前操作权限不足
+
+        return false;
+        // 函数执行到此处直接返回false，表示导出操作不被允许，终止函数后续的执行
+
     }
+    // 弹出确认框询问用户是否确定要导出所有访客数据
+    layer.confirm('确定导出所有访客数据吗？',function (index) {
+        // 调用layer插件提供的confirm方法，弹出一个确认框，显示“确定导出所有访客数据吗？”的提示信息，
+        // 同时传入一个回调函数，当用户点击确认框上的按钮时会执行该回调函数，回调函数接收一个参数index，用于后续操作确认框（如关闭等）
+
+        // 当用户点击确定时，重定向到导出访客信息的URL
+        location.href="${pageContext.request.contextPath}/visitor/visitorInfo";
+        // 当用户在确认框中点击确定按钮后，通过修改浏览器的location.href属性，重定向到指定的URL路径，
+        // 该路径通过EL表达式拼接出用于导出访客信息的具体地址，触发实际的导出操作（具体由服务器端逻辑处理）
 
-    // 注销访客记录
-    function toUpdate(id) {
-        // 使用layer组件的confirm方法弹出确认框，询问用户是否确定要注销此访客记录
-        layer.confirm('确定要注销此访客记录吗',function (index) {
-            // 用户点击确定后关闭确认框
-            layer.close(index);
-            // 发送异步请求到服务器端更新访客状态
-            $.get("${pageContext.request.contextPath}/visitor/updateStatus",{"id":id},function (data) {
-                // 根据服务器返回的数据判断操作是否成功
-                if (data) {
-                    // 成功时显示成功消息，并在2秒后刷新页面
-                    layer.msg('注销成功');
-                    setTimeout(function () {window.location.href='${pageContext.request.contextPath}/visitor/findAll';},2000);
-                }else {
-                    // 失败时显示错误消息，并在2秒后刷新页面
-                    layer.msg('系统繁忙，请联系系统管理员');
-                    setTimeout(function () {window.location.href='${pageContext.request.contextPath}/visitor/findAll';},2000);
-                }
-            });
+        layer.close(index); // 关闭确认框
+        // 调用layer插件提供的close方法，传入之前接收的index参数，用于关闭弹出的确认框，完成导出操作相关的交互流程
+
+    });
+}
+
+// 注销访客记录
+// 这是一个JavaScript函数的注释，说明下面定义的函数主要用于处理注销访客记录相关的操作
+function toUpdate(id) {
+// 定义一个名为toUpdate的JavaScript函数，接收一个名为id的参数，该参数通常用于表示要注销的访客记录的唯一标识，
+// 用于在函数内部向服务器发送请求来更新对应访客记录的状态
+
+    // 使用layer组件的confirm方法弹出确认框，询问用户是否确定要注销此访客记录
+    layer.confirm('确定要注销此访客记录吗',function (index) {
+        // 调用layer插件提供的confirm方法，弹出一个确认框，显示“确定要注销此访客记录吗”的提示信息，
+        // 同时传入一个回调函数，当用户点击确认框上的按钮时会执行该回调函数，回调函数接收一个参数index，用于后续操作确认框（如关闭等）
+
+        // 用户点击确定后关闭确认框
+        layer.close(index);
+        // 当用户在确认框中点击确定按钮后，调用layer插件提供的close方法，传入之前接收的index参数，关闭弹出的确认框
+
+         // 发送异步请求到服务器端更新访客状态
+        $.get("${pageContext.request.contextPath}/visitor/updateStatus",{"id":id},function (data) {
+            // 使用jQuery库提供的$.get方法发送一个GET类型的异步请求，请求的URL地址通过EL表达式拼接出，指向用于更新访客状态的服务器端接口（/visitor/updateStatus），
+            // 同时传递一个名为“id”的参数，其值为传入函数的id参数，表示要更新状态的访客记录的标识，
+            // 并传入一个回调函数，当服务器端返回响应数据后会执行该回调函数，回调函数接收一个参数data，代表服务器返回的数据
+            // 根据服务器返回的数据判断操作是否成功
+            if (data) {
+                // 使用if条件语句判断服务器返回的数据（data）是否为真值（具体真值的判断依据由服务器端返回的数据格式和逻辑决定），
+                // 如果为真值，则表示更新操作成功，执行下面的代码块
+                // 成功时显示成功消息，并在2秒后刷新页面
+                layer.msg('注销成功');
+                // 调用layer插件提供的msg方法，弹出一个提示框，显示“注销成功”的提示信息，告知用户操作已成功
+
+                setTimeout(function () {window.location.href='${pageContext.request.contextPath}/visitor/findAll';},2000);
+                // 使用JavaScript的setTimeout函数设置一个定时器，在2000毫秒（2秒）后执行传入的回调函数，
+                // 回调函数内通过修改浏览器的window.location.href属性，重定向到指定的URL路径（/visitor/findAll），实现刷新页面的效果，
+                // 重新加载访客信息列表页面，展示更新后的访客数据情况
+
+            }else {
+                // 如果服务器返回的数据为假值（不符合成功的判断条件），则表示更新操作失败，执行下面的代码块
+
+                // 失败时显示错误消息，并在2秒后刷新页面
+                layer.msg('系统繁忙，请联系系统管理员');
+                // 调用layer插件提供的msg方法，弹出一个提示框，显示“系统繁忙，请联系系统管理员”的提示信息，告知用户操作失败及相应的解决建议
+
+                setTimeout(function () {window.location.href='${pageContext.request.contextPath}/visitor/findAll';},2000);
+                // 同样使用setTimeout函数设置定时器，在2秒后重定向到访客信息列表页面（/visitor/findAll），刷新页面，
+                // 以便用户可以查看操作失败后的当前访客数据情况，或者再次尝试操作
+            }
         });
-    }
+    });
+}
 </script>
 </body>
 </html>
diff --git a/src/main/webapp/WEB-INF/jsp/visitor-log.jsp b/src/main/webapp/WEB-INF/jsp/visitor-log.jsp
index 42143ee..63fede2 100644
--- a/src/main/webapp/WEB-INF/jsp/visitor-log.jsp
+++ b/src/main/webapp/WEB-INF/jsp/visitor-log.jsp
@@ -6,89 +6,108 @@
   To change this template use File | Settings | File Templates.
 --%>
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
+<!-- 声明该JSP页面的内容类型为text/html（即HTML格式），字符编码采用UTF-8，表明页面将以HTML格式展示并且在服务器端使用Java语言编写相关逻辑 -->
+
 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
+<!-- 引入JSTL（JavaServer Pages Standard Tag Library）的核心标签库，设置前缀为“c”，方便后续在JSP页面中使用其提供的各种标签进行如条件判断、循环遍历等操作 -->
+
 <html>
 <head>
-    <%-- 设置页面的字符编码为UTF-8 --%>
+    <!-- 设置页面的字符编码为utf-8，确保浏览器能正确解析并显示页面中的各种字符，防止出现乱码现象 -->
     <meta charset="utf-8">
-    <%-- 设置页面渲染引擎为webkit --%>
+    <!-- 设置页面渲染所使用的引擎为webkit，让页面在支持webkit的浏览器中按照该引擎的规则进行渲染，有助于呈现出期望的页面样式和交互效果 -->
     <meta name="renderer" content="webkit">
-    <!-- 确保在IE浏览器中使用最新版本的渲染模式，并优先使用Chrome框架 -->
+    <!-- 声明页面在IE浏览器中的兼容模式，使页面在IE浏览器中以其最高可用版本的模式来渲染，如果安装了Chrome Frame插件，则优先使用该插件进行渲染，以此增强页面在IE浏览器中的兼容性和显示效果 -->
     <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
-    <!-- 设置响应式布局，使页面适应不同尺寸的设备 -->
+    <!-- 设置页面的视口（viewport）属性，width=device-width表示页面宽度跟随设备宽度自适应，initial-scale=1设置初始缩放比例为1，
+    maximum-scale=1限制最大缩放比例为1，用于确保页面在移动设备等不同屏幕尺寸下能有合适的展示效果 -->
     <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
-    <!-- 页面标题 -->
     <title>Title</title>
-
-    <!-- 引入layui框架的CSS样式文件 -->
+    <!-- 引入layui框架的CSS样式表，路径通过EL表达式结合pageContext对象获取项目相对路径，用于为页面应用layui框架提供的各种样式，构建页面的外观布局 -->
     <link rel="stylesheet" href="${pageContext.request.contextPath}/lib/layui/css/layui.css">
+    <!-- 引入layui框架中layer模块的默认CSS样式表，用于为layer弹出层等相关组件设置特定的样式，使其展示效果符合预期 -->
     <link rel="stylesheet" href="${pageContext.request.contextPath}/lib/layui/css/modules/layer/default/layer.css">
-    <!-- 引入jQuery库，用于DOM操作和事件处理 -->
+    <!-- 引入jQuery库，其路径通过EL表达式结合pageContext获取项目相对路径，jQuery是常用的JavaScript库，方便在页面中操作DOM元素、处理页面事件、发起AJAX异步请求等操作 -->
     <script type="text/javascript" src="${pageContext.request.contextPath}/js/jquery-3.1.1.js"></script>
 </head>
 <body>
-<!-- 使用layui框架定义一个字段集，作为访客时间线的标题部分 -->
+<!-- 创建一个fieldset（字段集）元素，应用layui的相关样式类layui-elem-field和layui-field-title，用于对页面中的相关内容进行分组和标题显示，
+设置了顶部外边距为30px，使其在页面中有一定的间距，看起来更美观 -->
 <fieldset class="layui-elem-field layui-field-title" style="margin-top: 30px;">
+    <!-- 在字段集中创建一个legend（图例）元素，用于显示该组内容的标题，这里显示的标题是“访客时间线” -->
     <legend>访客时间线</legend>
 </fieldset>
-<!-- 定义时间线组件 -->
+<!-- 创建一个无序列表（ul）元素，应用layui的时间线样式类layui-timeline，用于以时间线的形式展示访客相关的信息 -->
 <ul class="layui-timeline">
-    <!-- 单个时间线项，代表当前的时间点 -->
+    <!-- 创建一个列表项（li）元素，作为时间线中的一个节点，应用layui的时间线项目样式类layui-timeline-item -->
     <li class="layui-timeline-item">
+        <!-- 创建一个图标（i）元素，应用layui的图标样式类layui-icon以及时间轴样式类layui-timeline-axis，显示特定的图标（这里图标对应的字符编码为“”，具体图标样式由layui框架定义），用于表示时间线的节点标记 -->
         <i class="layui-icon layui-timeline-axis"></i>
+        <!-- 创建一个div元素，用于包裹时间线节点的具体内容，应用layui的文本样式类layui-text，使内部文本能按照layui框架的默认文本样式显示 -->
         <div class="layui-timeline-content layui-text">
-            <!-- 动态显示当前日期 -->
+            <!-- 创建一个标题（h3）元素，应用layui的时间线标题样式类layui-timeline-title，并设置了id为“mytime”，用于后续通过JavaScript操作来动态更新显示的时间内容 -->
             <h3 class="layui-timeline-title" id="mytime"></h3>
-            <!-- 显示访客日志统计信息 -->
             <p>
+                <!-- 显示访客日志的统计信息，先是显示“访客日志共计：”字样，然后通过EL表达式展示pageInfo对象中total属性的值（通常表示总日志条数），接着显示“条”以及其他相关的日志显示数量等信息，
+                例如当前显示的条数（通过pageInfo对象的size属性获取），用于让用户对访客日志的整体情况和当前展示情况有清晰的了解 -->
                 访客日志共计：&nbsp;${pageInfo.total}&nbsp;条&emsp;当前显示：${pageInfo.size}&nbsp;条&emsp;&emsp;
-                <!-- 如果不是第一页，则显示上一页链接 -->
+                <!-- 通过JSTL的if条件判断标签，判断pageInfo对象中的pageNum属性（通常表示当前页码）是否大于1，如果大于1则表示不是第一页，执行标签内的代码，显示“上一页”的链接 -->
                 <c:if test="${pageInfo.pageNum > 1}">
+                    <!-- 创建一个超链接（a）元素，href属性通过EL表达式拼接出具体的URL路径，用于跳转到上一页（当前页码减1），每页显示10条数据（size=10），链接显示的文本为“上一页”，方便用户进行翻页操作 -->
                     <a href="${pageContext.request.contextPath}/visitor/log?page=${pageInfo.pageNum - 1}&size=10">上一页</a>&emsp;&emsp;
                 </c:if>
-                <!-- 如果不是最后一页，则显示下一页链接 -->
+                <!-- 通过JSTL的if条件判断标签，判断pageInfo对象中的pageNum属性是否小于总页数（pageInfo.pages），如果小于总页数则表示不是最后一页，执行标签内的代码，显示“下一页”的链接 -->
                 <c:if test="${pageInfo.pageNum < pageInfo.pages}">
+                    <!-- 创建一个超链接（a）元素，href属性通过EL表达式拼接出具体的URL路径，用于跳转到下一页（当前页码加1），每页显示10条数据（size=10），链接显示的文本为“下一页”，方便用户进行翻页操作 -->
                     <a href="${pageContext.request.contextPath}/visitor/log?page=${pageInfo.pageNum + 1}&size=10">下一页</a>
                 </c:if>
             </p>
-            <!-- 遍历分页后的访客日志列表 -->
             <ul>
+                <!-- 使用JSTL的forEach循环标签，开始循环遍历pageInfo.list中的数据（通常是分页后的访客日志列表集合），每次循环将当前元素赋值给log变量，方便在列表中展示各个访客日志的详细信息 -->
                 <c:forEach items="${pageInfo.list}" var="log">
-                    <!-- 判断是否有离开时间，如果无则显示“尚未离开” -->
+                    <!-- 通过JSTL的if条件判断标签，判断访客日志对象（log）中的end_date属性是否为空字符串，如果为空字符串则表示访客尚未离开，执行标签内的代码，显示相应的访客日志信息 -->
                     <c:if test="${log.end_date == ''}">
+                        <!-- 创建一个列表项（li）元素，用于展示访客的具体日志信息，按照指定格式显示访客姓名、访问时间、访问地点、访问事因以及尚未离开的提示信息 -->
                         <li>【${log.name}】于&nbsp;${log.begin_date}&nbsp;访问了${log.place}，事因${log.visit_result}，目前尚未离开</li>
                     </c:if>
-                    <!-- 如果有离开时间，则正常显示来访和离开时间 -->
-                    <c:if test="${log.end_date != ''}">
+                    <!-- 通过JSTL的if条件判断标签，判断访客日志对象（log）中的end_date属性是否不为空字符串，如果不为空字符串则表示访客已经离开，执行标签内的代码，显示相应的访客日志信息 -->
+                    <c:if test="${log.end_date!= ''}">
+                        <!-- 创建一个列表项（li）元素，用于展示访客的具体日志信息，按照指定格式显示访客姓名、访问时间、访问地点、访问事因以及离开时间等信息 -->
                         <li>【${log.name}】于&nbsp;${log.begin_date}&nbsp;访问了${log.place}，事因${log.visit_result}，并与${log.end_date}离开</li>
                     </c:if>
                 </c:forEach>
             </ul>
         </div>
     </li>
-    <!-- 另一个时间线项，表示日志开启的时间点 -->
+    <!-- 创建另一个列表项（li）元素，作为时间线中的另一个节点，同样应用layui的时间线项目样式类layui-timeline-item -->
     <li class="layui-timeline-item">
+        <!-- 创建一个图标（i）元素，应用layui的图标样式类layui-icon以及时间轴样式类layui-timeline-axis，显示特定的图标（这里图标对应的字符编码为“”，具体图标样式由layui框架定义），用于表示时间线的节点标记 -->
         <i class="layui-icon layui-timeline-axis"></i>
+        <!-- 创建一个div元素，用于包裹时间线节点的具体内容，应用layui的文本样式类layui-text，使内部文本能按照layui框架的默认文本样式显示 -->
         <div class="layui-timeline-content layui-text">
+            <!-- 创建一个标题（div）元素，应用layui的时间线标题样式类layui-timeline-title，显示固定的文本“2020.02.21日志开启”，用于标记日志开始的时间点等相关信息 -->
             <div class="layui-timeline-title">2020.02.21日志开启</div>
         </div>
     </li>
 </ul>
-
-<!-- JavaScript脚本，用于动态更新页面上的当前时间 -->
 <script>
-    // 定义showTime函数，用于获取并显示当前日期
     function showTime(){
-        var nowtime =new Date(); // 获取当前时间
-        var year=nowtime.getFullYear(); // 获取年份
-        var month=nowtime.getMonth()+1; // 获取月份（注意月份从0开始）
-        var date=nowtime.getDate(); // 获取日
-        // 将日期格式化后设置到页面中的元素中
-        document.getElementById("mytime").innerText=year+"年"+month+"月"+date+"日";
+        // 创建一个Date对象，用于获取当前的日期和时间信息
+        var nowtime =new Date();
+        // 通过Date对象的getFullYear方法获取当前的年份信息
+        var year=nowtime.getFullYear();
+        // 通过Date对象的getMonth方法获取当前的月份信息（注意：返回值是0 - 11，所以需要加1才是实际的月份）
+        var month=nowtime.getMonth()+1;
+        // 通过Date对象的getDate方法获取当前的日期信息（即一个月中的第几天）
+        var date=nowtime.getDate();
+        // 通过JavaScript的DOM操作，获取id为“mytime”的元素（对应页面中的h3标题元素），并设置其内部文本内容为按照指定格式拼接的当前日期信息，
+        // 用于在页面上动态显示当前的时间（年、月、日）
+        document.getElementById("mytime").innerText=year+"年"+month+"日"+date+"日";
     }
-    // 每隔一分钟调用一次showTime函数更新时间
+    // 使用JavaScript的setInterval函数，每隔一段时间（这里是1000 * 60毫秒，即60秒）执行一次传入的函数（这里是showTime函数），
+    // 实现每隔60秒更新一次页面上显示的时间（通过调用showTime函数来更新id为“mytime”的元素显示的日期内容）
     setInterval("showTime()",1000*60);
 
 </script>
 </body>
-</html>
+</html>
\ No newline at end of file
diff --git a/src/main/webapp/WEB-INF/jsp/visitor-success.jsp b/src/main/webapp/WEB-INF/jsp/visitor-success.jsp
index 8fd3376..f363681 100644
--- a/src/main/webapp/WEB-INF/jsp/visitor-success.jsp
+++ b/src/main/webapp/WEB-INF/jsp/visitor-success.jsp
@@ -8,32 +8,34 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <!--
 指令标签，用于设置页面的内容类型、字符编码和编程语言。
-contentType: 设置响应的MIME类型和字符编码为UTF-8。
-language: 声明页面使用的编程语言是Java。
+contentType: 设置响应的MIME类型为"text/html"（表示这是一个HTML格式的页面内容），同时设置字符编码为UTF-8，确保页面中的中文等特殊字符能正确显示，避免出现乱码情况。
+language: 声明页面使用的编程语言是Java，意味着在这个JSP页面中可以嵌入Java代码片段或者使用基于Java的各种标签库等功能来实现动态页面内容生成等操作。
 -->
 <html>
 <head>
     <!--
-       定义页面标题，当用户访问此页面时，浏览器标签页会显示“登记成功”。
-   -->
+       定义页面标题，当用户访问此页面时，浏览器标签页会显示“登记成功”，这个标题简洁明了地告知用户当前页面所对应的操作结果状态。
+    -->
     <title>登记成功</title>
-
 </head>
 <body>
 <!--
-    使用HTML的<h4>标签显示一条消息给用户，告知他们来访登记已经成功。
-    样式属性text-align: center; 使文本居中显示。
+    使用HTML的<h4>标签显示一条消息给用户，<h4>标签表示四级标题，在这里用于突出显示重要的提示信息，告知他们来访登记已经成功，
+    style="text-align: center;" 是内联样式属性设置，通过设置"text-align"为"center"，使得该标题文本在水平方向上居中显示，提升页面的美观度和可读性。
 -->
 <h4 style="text-align: center;">恭喜您，来访登记成功！</h4>
 <!--
-    HTML换行标签，用于在“恭喜您，来访登记成功！”消息后添加一个空行，以增加视觉上的间隔。
+    HTML换行标签，用于在“恭喜您，来访登记成功！”消息后添加一个空行，它是一个单标签，作用就是在页面布局中产生一个换行效果，
+    以增加视觉上的间隔，使得页面内容看起来更加清晰、有条理，避免不同内容之间过于紧凑。
 -->
 <br>
 <!--
-    创建一个超链接，允许用户点击以执行注销登记操作。
-    href属性指定了链接的目标URL，其中包含了注销登记的操作路径和当前用户的ID作为参数。
-    样式属性text-align: center; 使链接文本居中显示。
--->
+        创建一个超链接，使用HTML的<a>标签来实现，允许用户点击以执行注销登记操作，
+        href属性指定了链接的目标URL，通过EL表达式 "${pageContext.request.contextPath}/visitor/login_out?id=${id}" 动态生成链接地址，
+        其中 "${pageContext.request.contextPath}" 用于获取当前应用的上下文路径（通常是项目部署后的根路径部分），"/visitor/login_out" 是具体指向执行注销登记操作的后端接口路径，
+        "id=${id}" 表示将当前用户对应的ID作为参数传递给注销登记的接口（这里的${id}应该是在页面渲染前通过相应的模型数据或者请求属性等方式设置好具体的值），
+        样式属性text-align: center; 同样是内联样式设置，使链接文本在水平方向上居中显示，保持页面整体的布局风格统一，方便用户查看和操作。
+    -->
 <a href="${pageContext.request.contextPath}/visitor/login_out?id=${id}" style="text-align: center;">注销登记</a>
 </body>
-</html>
+</html>
\ No newline at end of file