Merge pull request 'add jquery' (#11) from p3nl4gb7j/BookStore:main into develop

sql/bookstore.sql

@@ -20,18 +20,29 @@ INSERT INTO t_user(username,`password`,email,address) VALUES('admin','admin','ad
 ## 查询表
 SELECT * FROM t_user;
 
+-- 创建名为t_book的表
 CREATE TABLE t_book(
+    -- 定义名为id的字段，数据类型为INT（整数类型），将其设置为主键，并且设置为自增（AUTO_INCREMENT），这样每插入一条新记录时，该字段的值会自动按顺序递增，用于为每本图书生成唯一的标识符
                        `id` INT PRIMARY KEY AUTO_INCREMENT,
+    -- 定义名为name的字段，数据类型为VARCHAR（可变长度字符串），长度为100，用于存储图书的书名信息
                        `name` VARCHAR(100),
+    -- 定义名为price的字段，数据类型为DECIMAL（精确数值类型），总长度为11位，其中小数部分占2位，用于存储图书的价格信息
                        `price` DECIMAL(11,2),
+    -- 定义名为author的字段，数据类型为VARCHAR，长度为100，用来记录图书的作者姓名
                        `author` VARCHAR(100),
+    -- 定义名为classification的字段，数据类型为VARCHAR，长度为20，可用于存储图书的分类信息，例如文学、科技等类别
                        `classification` VARCHAR(20),
+    -- 定义名为sales的字段，数据类型为INT，用于记录图书的销量情况
                        `sales` INT,
+    -- 定义名为stock的字段，数据类型为INT，用于表示图书的库存数量
                        `stock` INT,
+    -- 定义名为imgpath的字段，数据类型为VARCHAR，长度为200，可用于存储图书封面图片的路径信息，方便在应用中展示图书封面图片
                        `imgpath` VARCHAR(200)
 );
 
+-- 向t_book表中插入一条图书数据记录，指定要插入值的字段为（name, author, classification, price, sales, stock, imgpath），并对应给出具体的值，分别为图书的书名、作者、分类、价格、销量、库存以及封面图片路径
 INSERT INTO t_book (name, author, classification, price, sales, stock, imgpath) VALUES('解忧杂货店','东野圭吾','文学',27.20,100,100,'static/img/default.jpg');
+-- 同样是向t_book表中插入图书数据记录，以下每条INSERT语句的结构和作用与上面类似，只是对应不同的图书信息
 INSERT INTO t_book (name, author, classification, price, sales, stock, imgpath) VALUES('边城','沈从文','文学',23.00,100,100,'static/img/default.jpg');
 INSERT INTO t_book (name, author, classification, price, sales, stock, imgpath) VALUES('中国哲学史','冯友兰','文学',44.5,100,100,'static/img/default.jpg');
 INSERT INTO t_book (name, author, classification, price, sales, stock, imgpath) VALUES('苏东坡传','林语堂','文学',19.30,100,100,'static/img/default.jpg');
@@ -60,22 +71,36 @@ INSERT INTO t_book (name, author, classification, price, sales , stock , imgpath
 INSERT INTO t_book (name, author, classification, price, sales, stock, imgpath) VALUES('图解机器学习','杉山将','文学',33.80,100,100,'static/img/default.jpg');
 INSERT INTO t_book (name, author, classification, price, sales, stock, imgpath) VALUES('艾伦图灵传','安德鲁','文学',47.20,100,100,'static/img/default.jpg');
 INSERT INTO t_book (name, author, classification, price, sales, stock, imgpath) VALUES('教父','马里奥普佐','文学',29.00,100,100,'static/img/default.jpg');
-
+-- 创建名为t_order的表
 CREATE TABLE t_order(
+    -- 定义名为order_id的字段，数据类型为VARCHAR（可变长度字符串），长度为50，并且将该字段设置为主键，用于唯一标识每条订单记录
                         `order_id` VARCHAR(50) PRIMARY KEY,
+    -- 定义名为create_time的字段，数据类型为DATETIME（用于存储日期和时间信息），用来记录订单创建的时间
                         `create_time` DATETIME,
+    -- 定义名为price的字段，数据类型为DECIMAL（精确数值类型），总长度为11位，其中小数部分占2位，用于存储订单的价格信息
                         `price` DECIMAL(11,2),
+    -- 定义名为status的字段，数据类型为INT（整数类型），可能用于表示订单的状态，比如不同的数值对应不同的订单处理阶段等情况
                         `status` INT,
+    -- 定义名为user_id的字段，数据类型为INT，该字段将作为外键，与另一个表（t_user）中的id字段建立关联关系
                         `user_id` INT,
+    -- 使用FOREIGN KEY关键字为user_id字段添加外键约束，指定它参照t_user表中的id字段，意味着t_order表中的user_id值必须在t_user表的id字段值中存在，以此建立起两张表之间的关联，通常表示订单所属的用户
                         FOREIGN KEY(`user_id`) REFERENCES t_user(`id`)
 );
 
+-- 创建名为t_order_item的表
 CREATE TABLE t_order_item(
+    -- 定义名为id的字段，数据类型为INT（整数类型），并将该字段设置为主键，同时设置为自增（AUTO_INCREMENT），这样每当插入一条新记录时，该字段的值会自动按顺序递增，常用于为每条记录生成唯一的标识符
                              `id` INT PRIMARY KEY AUTO_INCREMENT,
+    -- 定义名为name的字段，数据类型为VARCHAR，长度为100，可用于存储商品名称等相关信息，比如订单中具体商品的名字
                              `name` VARCHAR(100),
+    -- 定义名为count的字段，数据类型为INT，用于记录商品的数量，比如某个商品在该订单中的购买数量
                              `count` INT,
+    -- 定义名为price的字段，数据类型为DECIMAL，总长度11位，小数部分占2位，可能用于存储单个商品的价格信息
                              `price` DECIMAL(11,2),
+    -- 定义名为total_price的字段，数据类型为DECIMAL，总长度11位，小数部分占2位，用于存储该商品的总价（可能是通过商品单价乘以数量计算得出）
                              `total_price` DECIMAL(11,2),
+    -- 定义名为order_id的字段，数据类型为VARCHAR，长度为50，该字段将作为外键，与t_order表中的order_id字段建立关联关系
                              `order_id` VARCHAR(50),
+    -- 使用FOREIGN KEY关键字为order_id字段添加外键约束，指定它参照t_order表中的order_id字段，意味着t_order_item表中的order_id值必须在t_order表的order_id字段值中存在，以此建立起两张表之间的关联，表明该订单项所属的订单
                              FOREIGN KEY(`order_id`) REFERENCES t_order(`order_id`)
 );

src/com/yj/bean/Book.java

@@ -5,80 +5,164 @@ import java.math.BigDecimal;
 /**
  * @author yj
  * @create 2020-10-02 19:51
+ *
+ * Book类表示一本书的信息，包含了书籍的基本属性，如ID、书名、作者、价格、销量、库存、分类和图片路径等。
  */
 public class Book {
-    private Integer id;//id
-    private String name;//姓名
-    private String author;//作者
+
+    // 书籍的唯一标识符
+    private Integer id;
+
+    // 书籍的名称
+    private String name;
+
+    // 书籍的作者
+    private String author;
+
+    // 书籍的价格，使用BigDecimal类型以确保精度
     private BigDecimal price;
+
+    // 书籍的销量
     private Integer sales;
+
+    // 书籍的库存数量
     private Integer stock;
+
+    // 书籍的分类
     private String classification;
+
+    // 书籍的图片路径，默认值为"static/img/default.jpg"
     private String imgPath = "static/img/default.jpg";
 
+    /**
+     * 获取书籍的分类
+     * @return 书籍的分类
+     */
     public String getClassification() {
         return classification;
     }
 
+    /**
+     * 设置书籍的分类
+     * @param classification 书籍的分类
+     */
     public void setClassification(String classification) {
         this.classification = classification;
     }
 
-
-
+    /**
+     * 获取书籍的ID
+     * @return 书籍的ID
+     */
     public Integer getId() {
         return id;
     }
 
+    /**
+     * 设置书籍的ID
+     * @param id 书籍的ID
+     */
     public void setId(Integer id) {
         this.id = id;
     }
 
+    /**
+     * 获取书籍的名称
+     * @return 书籍的名称
+     */
     public String getName() {
         return name;
     }
 
+    /**
+     * 设置书籍的名称
+     * @param name 书籍的名称
+     */
     public void setName(String name) {
         this.name = name;
     }
 
+    /**
+     * 获取书籍的作者
+     * @return 书籍的作者
+     */
     public String getAuthor() {
         return author;
     }
 
+    /**
+     * 设置书籍的作者
+     * @param author 书籍的作者
+     */
     public void setAuthor(String author) {
         this.author = author;
     }
 
+    /**
+     * 获取书籍的价格
+     * @return 书籍的价格
+     */
     public BigDecimal getPrice() {
         return price;
     }
 
+    /**
+     * 设置书籍的价格
+     * @param price 书籍的价格
+     */
     public void setPrice(BigDecimal price) {
         this.price = price;
     }
 
+    /**
+     * 获取书籍的销量
+     * @return 书籍的销量
+     */
     public Integer getSales() {
         return sales;
     }
 
+    /**
+     * 设置书籍的销量
+     * @param sales 书籍的销量
+     */
     public void setSales(Integer sales) {
         this.sales = sales;
     }
 
+    /**
+     * 获取书籍的库存数量
+     * 如果库存数量小于0，则返回0
+     * @return 书籍的库存数量
+     */
     public Integer getStock() {
-        if(stock<0) stock=0;return stock;
+        if (stock < 0) stock = 0;
+        return stock;
     }
 
+    /**
+     * 设置书籍的库存数量
+     * 如果库存数量小于0，则将其设置为0
+     * @param stock 书籍的库存数量
+     */
     public void setStock(Integer stock) {
         if (stock < 0) stock = 0;
         this.stock = stock;
     }
 
+    /**
+     * 获取书籍的图片路径
+     * @return 书籍的图片路径
+     */
     public String getImgPath() {
         return imgPath;
     }
 
+    /**
+     * 设置书籍的图片路径
+     * 如果传入的图片路径为null或空字符串，则使用默认图片路径"static/img/default.jpg"
+     * @param imgPath 书籍的图片路径
+     */
     public void setImgPath(String imgPath) {
         if (imgPath == null || "".equals(imgPath)) {
             this.imgPath = "static/img/default.jpg";
@@ -87,6 +171,10 @@ public class Book {
         }
     }
 
+    /**
+     * 重写toString方法，返回书籍的详细信息
+     * @return 书籍的详细信息字符串
+     */
     @Override
     public String toString() {
         return "Book{" +
@@ -101,9 +189,23 @@ public class Book {
                 '}';
     }
 
+    /**
+     * 无参构造方法
+     */
     public Book() {
     }
 
+    /**
+     * 全参构造方法
+     * @param id 书籍的ID
+     * @param name 书籍的名称
+     * @param author 书籍的作者
+     * @param price 书籍的价格
+     * @param sales 书籍的销量
+     * @param stock 书籍的库存数量
+     * @param classification 书籍的分类
+     * @param imgPath 书籍的图片路径
+     */
     public Book(Integer id, String name, String author, BigDecimal price, Integer sales, Integer stock, String classification, String imgPath) {
         this.id = id;
         this.name = name;

src/com/yj/bean/Cart.java

@@ -13,93 +13,128 @@ import java.util.Map;
  * 购物车对象
  */
 public class Cart {
+    // 注释掉的代码表示之前可能考虑过直接存储总数和总价，但在此实现中，选择动态计算这些值
     //private Integer totalCount;
     //private BigDecimal totalPrice;
 
+    /**
+     * 获取购物车中所有商品的总数量
+     */
     public Integer getTotalCount() {
         Integer totalCount = 0;
+        // 初始化总数量为0
         for (Map.Entry<Integer,CartItem>entry : items.entrySet()) {
+            // 遍历购物车中的每一项
             totalCount += entry.getValue().getCount();
+            // 累加每一项的数量
         }
         return totalCount;
+        // 返回总数量
     }
 
-
+    /**
+     * 获取购物车中所有商品的总价格
+     */
     public BigDecimal getTotalPrice() {
         BigDecimal totalPrice = new BigDecimal(0);
+        // 初始化总价格为0
         for (Map.Entry<Integer,CartItem>entry : items.entrySet()) {
+            // 遍历购物车中的每一项
             totalPrice = totalPrice.add(entry.getValue().getTotalPrice());
+            // 累加每一项的总价格
         }
         return totalPrice;
+        // 返回总价格
     }
 
-
+    /**
+     * 获取购物车中的所有商品项
+     */
     public Map<Integer, CartItem> getItems() {
         return items;
+        // 返回购物车中的商品项
     }
 
+    /**
+     * 设置购物车中的所有商品项
+     */
     public void setItems(Map<Integer, CartItem> items) {
         this.items = items;
+        // 设置购物车中的商品项
     }
 
     /**
-     * key是商品编号，value是商品信息
+     * 商品项存储的Map，key是商品编号，value是商品信息，使用LinkedHashMap保持插入顺序
      */
     private Map<Integer,CartItem> items = new LinkedHashMap<Integer, CartItem>();
 
+    /**
+     * 重写toString方法，用于打印购物车信息
+     */
     @Override
     public String toString() {
         return "Cart{" +
                 "totalCount=" + getTotalCount() +
+                // 总数量
                 ", totalPrice=" + getTotalPrice() +
+                // 总价格
                 ", items=" + items +
+                // 商品项
                 '}';
     }
 
     /**
-     * 添加商品项
-     * @param cartItem
+     * 添加商品项到购物车
+     * @param cartItem 要添加的商品项
      */
     public void addItem(CartItem cartItem) {
-        //先查看购物车中是否包含次商品，如果有的话，数量更新，总金额更新；如果没有，直接放到集合中即可
+        // 先查看购物车中是否包含此商品
         CartItem item = items.get(cartItem.getId());
 
         if(item == null) {
-            //之前没有添加过此商品
+            // 之前没有添加过此商品，直接添加到购物车中
             items.put(cartItem.getId(),cartItem);
         } else {
-            item.setCount(item.getCount() + 1);//数量累计
-            item.setTotalPrice(item.getPrice().multiply(new BigDecimal(item.getCount())));//更新总金额
+            // 购物车中已有此商品，数量加1，并更新总金额
+            item.setCount(item.getCount() + 1);
+            // 数量累计
+            item.setTotalPrice(item.getPrice().multiply(new BigDecimal(item.getCount())));
+            // 更新总金额
         }
     }
 
     /**
-     * 删除商品项
-     * @param  id
+     * 从购物车中删除指定编号的商品项
+     * @param  id 要删除的商品项的编号
      */
     public void deleteItem(Integer id) {
         items.remove(id);
+        // 从购物车中删除指定编号的商品项
     }
 
     /**
-     * 清空购物车
+     * 清空购物车中的所有商品项
      */
     public void clear() {
         items.clear();
+        // 清空购物车
     }
 
     /**
-     * 修改商品数量
-     * @param id
-     * @param count
+     * 修改购物车中指定编号的商品项的数量
+     * @param id 商品项的编号
+     * @param count 新的数量
      */
     public void updateCount(Integer id,Integer count) {
-        //先查看购物车中是否包含次商品，如果有的话，数量更新，总金额更新；
+        // 先查看购物车中是否包含此商品项
         CartItem cartItem = items.get(id);
 
         if(cartItem != null) {
+            // 购物车中已有此商品项，修改数量并更新总金额
             cartItem.setCount(count);
+            // 修改数量
             cartItem.setTotalPrice(cartItem.getPrice().multiply(new BigDecimal(cartItem.getCount())));
+            // 更新总金额
         }
     }
 }

src/com/yj/bean/CartItem.java

@@ -10,72 +10,101 @@ import java.math.BigDecimal;
 /**
  * 购物车商品项
  */
+// 定义一个名为CartItem的类，代表购物车中的一个商品项
 public class CartItem {
+    // 定义一个私有变量id，用于存储商品的唯一标识符
     private Integer id;
+    // 定义一个私有变量name，用于存储商品的名称
     private String name;
+    // 定义一个私有变量count，用于存储商品的数量
     private Integer count;
+    // 定义一个私有变量price，用于存储商品的单价，使用BigDecimal类型以支持精确的小数计算
     private BigDecimal price;
+    // 定义一个私有变量totalPrice，用于存储商品的总价（单价乘以数量），同样使用BigDecimal类型
     private BigDecimal totalPrice;
 
+    // 定义一个公开的getter方法，用于获取商品的id
     public Integer getId() {
         return id;
     }
-
+    // 定义一个公开的setter方法，用于设置商品的id
     public void setId(Integer id) {
         this.id = id;
     }
-
+    // 定义一个公开的getter方法，用于获取商品的名称
     public String getName() {
         return name;
     }
-
+    // 定义一个公开的setter方法，用于设置商品的名称
     public void setName(String name) {
         this.name = name;
     }
-
+    // 定义一个公开的getter方法，用于获取商品的数量
     public Integer getCount() {
         return count;
     }
-
+    // 定义一个公开的setter方法，用于设置商品的数量
     public void setCount(Integer count) {
         this.count = count;
     }
-
+    // 定义一个公开的getter方法，用于获取商品的单价
     public BigDecimal getPrice() {
         return price;
     }
-
+    // 定义一个公开的setter方法，用于设置商品的单价
     public void setPrice(BigDecimal price) {
         this.price = price;
     }
-
+    // 定义一个公开的getter方法，用于获取商品的总价
     public BigDecimal getTotalPrice() {
         return totalPrice;
     }
-
+    // 定义一个公开的setter方法，用于设置商品的总价
     public void setTotalPrice(BigDecimal totalPrice) {
         this.totalPrice = totalPrice;
     }
 
+    // 定义一个公开的构造方法，用于创建CartItem对象并初始化其所有属性
     public CartItem(Integer id, String name, Integer count, BigDecimal price, BigDecimal totalPrice) {
+        // 使用this关键字将传入的id参数赋值给当前对象的id属性
         this.id = id;
+        // 设置商品的唯一标识符
+
+        // 使用this关键字将传入的name参数赋值给当前对象的name属性
         this.name = name;
+        // 设置商品的名称
+
+        // 使用this关键字将传入的count参数赋值给当前对象的count属性
         this.count = count;
+        // 设置商品的数量
+
+        // 使用this关键字将传入的price参数赋值给当前对象的price属性
         this.price = price;
+        // 设置商品的单价，使用BigDecimal类型以支持精确的小数计算
+
+        // 使用this关键字将传入的totalPrice参数赋值给当前对象的totalPrice属性
         this.totalPrice = totalPrice;
+        // 设置商品的总价（单价乘以数量），同样使用BigDecimal类型
     }
-
+    // 定义一个无参构造方法，用于创建CartItem对象时不初始化任何属性
     public CartItem() {
     }
 
+    // 重写toString方法，用于返回CartItem对象的字符串表示形式
     @Override
     public String toString() {
+        // 返回的字符串包含CartItem对象的所有属性信息
         return "Cart{" +
                 "id=" + id +
+                // 显示商品的id
                 ", name='" + name + '\'' +
+                // 显示商品的名称
                 ", count=" + count +
+                // 显示商品的数量
                 ", price=" + price +
+                // 显示商品的单价
                 ", totalPrice=" + totalPrice +
+                // 显示商品的总价
                 '}';
     }
 }

src/com/yj/bean/Page.java

@@ -1,90 +1,118 @@
 package com.yj.bean;
+// 定义包名，用于组织相关的类和接口
 
 import java.util.List;
+// 导入List接口，用于存储数据集合
 
 /**
- * @author yj
- * @create 2020-08-25 9:27
+ * @author yj // 类的作者
+ * @create 2020-08-25 9:27 // 类的创建时间
  */
 public class Page <T>{
+    // 定义一个泛型类Page，T表示该Page类可以持有任何类型的对象
 
     public static final Integer PAGE_SIZE = 4;
+    // 定义一个常量，表示每页显示的数据条数
     //当前页
     private Integer pageNo;
+    // 当前页码
 
     //总页码
     private Integer pageTotal;
+    // 总页数
 
     //当前页显示数量
     private Integer pageSize = PAGE_SIZE;
+    // 每页显示的数据条数，默认为常量PAGE_SIZE的值
 
     //总的记录数
     private Integer pageTotalCount;
+    // 数据总条数
 
     //当前页数据
     private List<T> items;
+    // 存储当前页的数据
 
     //分页条的请求地址
     private String url;
+    // 分页条请求的URL地址
 
+    // 获取分页条请求的URL地址
     public String getUrl() {
         return url;
     }
 
+    // 设置分页条请求的URL地址
     public void setUrl(String url) {
         this.url = url;
     }
 
+    // 获取当前页码
     public Integer getPageNo() {
         return pageNo;
     }
 
-
+    // 获取总页数
     public Integer getPageTotal() {
         return pageTotal;
     }
 
+    // 设置总页数
     public void setPageTotal(Integer pageTotal) {
         this.pageTotal = pageTotal;
     }
 
+    // 获取每页显示的数据条数
     public Integer getPageSize() {
         return pageSize;
     }
 
+    // 设置每页显示的数据条数
     public void setPageSize(Integer pageSize) {
         this.pageSize = pageSize;
     }
 
+    // 获取数据总条数
     public Integer getPageTotalCount() {
         return pageTotalCount;
     }
 
+    // 设置数据总条数
     public void setPageTotalCount(Integer pageTotalCount) {
         this.pageTotalCount = pageTotalCount;
     }
 
+    // 获取当前页的数据
     public List<T> getItems() {
         return items;
     }
 
+    // 设置当前页的数据
     public void setItems(List<T> items) {
         this.items = items;
     }
 
+    // 设置当前页码
     public void setPageNo(Integer pageNo) {
         this.pageNo = pageNo;
     }
 
+    // 重写toString方法，用于打印Page对象的详细信息
     @Override
     public String toString() {
         return "Page{" +
                 "pageNo=" + pageNo +
+                // 当前页码
                 ", pageTotal=" + pageTotal +
+                // 总页数
                 ", pageSize=" + pageSize +
+                // 每页显示的数据条数
                 ", pageTotalCount=" + pageTotalCount +
+                // 数据总条数
                 ", items=" + items +
+                // 当前页的数据
                 ", url='" + url + '\'' +
+                // 分页条请求的URL地址
                 '}';
     }
 }

src/com/yj/bean/User.java

@@ -5,68 +5,53 @@ package com.yj.bean;
  * @create 2020-08-21 10:41
  */
 public class User {
-    // 用户ID，使用Integer类型以便于处理数据库中的null值
     private Integer id;
-    // 用户名
     private String username;
-    // 密码
     private String password;
-    // 邮箱地址
     private String email;
-    // 用户地址
     private String address;
 
-    // 获取用户地址
     public String getAddress() {
         return address;
     }
 
-    // 设置用户地址
     public void setAddress(String address) {
         this.address = address;
     }
 
-    // 获取用户ID
+
     public Integer getId() {
         return id;
     }
 
-    // 设置用户ID
     public void setId(Integer id) {
         this.id = id;
     }
 
-    // 获取用户名
     public String getUsername() {
         return username;
     }
 
-    // 设置用户名
     public void setUsername(String username) {
         this.username = username;
     }
 
-    // 获取密码
     public String getPassword() {
         return password;
     }
 
-    // 设置密码
     public void setPassword(String password) {
         this.password = password;
     }
 
-    // 获取邮箱
     public String getEmail() {
         return email;
     }
 
-    // 设置邮箱
     public void setEmail(String email) {
         this.email = email;
     }
 
-    // 重写toString方法，方便输出用户信息
     @Override
     public String toString() {
         return "User{" +
@@ -78,11 +63,9 @@ public class User {
                 '}';
     }
 
-    // 无参构造函数
     public User() {
     }
 
-    // 带参数的构造函数，用于创建用户对象时初始化属性
     public User(Integer id, String username, String password, String email, String address) {
         this.id = id;
         this.username = username;
@@ -91,4 +74,3 @@ public class User {
         this.address = address;
     }
 }
-

src/com/yj/dao/BookDao.java

@@ -8,34 +8,108 @@ import java.util.List;
 /**
  * @author yj
  * @create 2020-08-23 21:08
+ *
+ * BookDao接口定义了对书籍数据的操作方法，包括增删改查、分页查询、按价格范围查询、按名称或作者查询等功能。
  */
 public interface BookDao {
 
+    /**
+     * 添加一本书籍到数据库
+     * @param book 要添加的书籍对象
+     * @return 受影响的行数，成功返回1，失败返回0
+     */
     public int addBook(Book book);
 
+    /**
+     * 根据书籍ID删除书籍
+     * @param id 要删除的书籍ID
+     * @return 受影响的行数，成功返回1，失败返回0
+     */
     public int deleteBookById(Integer id);
 
+    /**
+     * 更新书籍信息
+     * @param book 包含更新信息的书籍对象
+     * @return 受影响的行数，成功返回1，失败返回0
+     */
     public int updateBook(Book book);
 
+    /**
+     * 根据书籍ID查询书籍信息
+     * @param id 要查询的书籍ID
+     * @return 查询到的书籍对象，如果未找到返回null
+     */
     public Book queryBookById(Integer id);
 
+    /**
+     * 查询所有书籍信息
+     * @return 包含所有书籍的列表
+     */
     public List<Book> queryBooks();
 
+    /**
+     * 查询所有书籍的总记录数
+     * @return 所有书籍的总记录数
+     */
     Integer queryForPageTotalCount();
 
+    /**
+     * 分页查询书籍信息
+     * @param begin 分页的起始索引
+     * @param pageSize 每页显示的记录数
+     * @return 当前页的书籍列表
+     */
     List<Book> queryForPageItems(int begin, int pageSize);
 
+    /**
+     * 根据价格范围查询书籍的总记录数
+     * @param min 价格范围的最小值
+     * @param max 价格范围的最大值
+     * @return 符合价格范围的书籍总记录数
+     */
     Integer queryForPageTotalCountByPrice(int min, int max);
 
+    /**
+     * 根据价格范围分页查询书籍信息
+     * @param begin 分页的起始索引
+     * @param pageSize 每页显示的记录数
+     * @param min 价格范围的最小值
+     * @param max 价格范围的最大值
+     * @return 当前页的书籍列表
+     */
     List<Book> queryForPageItemsByPrice(int begin, int pageSize, int min, int max);
 
+    /**
+     * 根据书籍名称或作者查询书籍的总记录数
+     * @param nameorauthor 书籍名称或作者的关键字
+     * @return 符合条件的书籍总记录数
+     */
     Integer queryForPageTotalCountByNameOrAuthor(String nameorauthor);
 
+    /**
+     * 根据书籍名称或作者分页查询书籍信息
+     * @param begin 分页的起始索引
+     * @param pageSize 每页显示的记录数
+     * @param nameorauthor 书籍名称或作者的关键字
+     * @return 当前页的书籍列表
+     */
     List<Book> queryForPageItemsByNameOrAuthor(int begin, int pageSize, String nameorauthor);
 
+    /**
+     * 查询所有书籍并按某种顺序排序（如销量、价格等）
+     * @return 按顺序排序的书籍列表
+     */
     List<Book> queryForPageItemsOrder();
 
+    /**
+     * 查询所有书籍的总金额（价格总和）
+     * @return 所有书籍的总金额
+     */
     BigDecimal queryTotalMoney();
 
+    /**
+     * 查询书籍的总数量
+     * @return 书籍的总数量
+     */
     public Integer queryBooknums();
 }

src/com/yj/dao/UserDao.java

@@ -5,7 +5,6 @@ import com.yj.bean.User;
 import java.util.List;
 
 /**
- * 用户数据访问接口
  * @author yj
  * @create 2020-08-21 11:57
  */
@@ -20,64 +19,30 @@ public interface UserDao {
 
     /**
      * 根据用户名和密码查询用户信息
-     * @param username 用户名
-     * @param password 密码
+     * @param username
+     * @param password
      * @return 如果返回null则说明用户名或密码错误
      */
     public User querybyUsernameAndPassword(String username,String password);
 
     /**
      * 保存用户信息
-     * @param user 用户对象
-     * @return 返回影响的行数
+     * @param user
+     * @return
      */
     public int saveUser(User user);
 
-    /**
-     * 添加新用户
-     * @param user 用户对象
-     * @return 返回影响的行数
-     */
     public int addUser(User user);
 
-    /**
-     * 根据用户ID删除用户
-     * @param i 用户ID
-     * @return 返回影响的行数
-     */
     public int deleteUserById(int i);
 
-    /**
-     * 更新用户信息
-     * @param user 用户对象
-     * @return 返回影响的行数
-     */
     public int updateUser(User user);
 
-    /**
-     * 根据用户ID查询单个用户信息
-     * @param id 用户ID
-     * @return 用户对象，如果不存在则返回null
-     */
     public User queryUserById(Integer id);
 
-    /**
-     * 查询所有用户信息
-     * @return 用户列表
-     */
     public List<User> queryUsers();
 
-    /**
-     * 查询用户表中的总记录数
-     * @return 用户总数
-     */
     public Integer queryForPageTotalCount();
 
-    /**
-     * 进行分页查询，获取指定页的数据
-     * @param begin 起始位置
-     * @param pageSize 每页显示的用户数量
-     * @return 指定页的用户列表
-     */
     public List<User> queryForPageItems(int begin, int pageSize);
 }

src/com/yj/dao/impl/BaseDao.java

@@ -1,85 +1,124 @@
 package com.yj.dao.impl;
+// 定义包名，组织相关的类
 
 import com.yj.utils.JDBCUtils;
+// 导入JDBC工具类，用于获取数据库连接
 import org.apache.commons.dbutils.QueryRunner;
+// 导入DbUtils的QueryRunner类，用于简化JDBC操作
 import org.apache.commons.dbutils.handlers.BeanHandler;
+// 导入BeanHandler，用于将结果集的第一行数据封装为JavaBean对象
 import org.apache.commons.dbutils.handlers.BeanListHandler;
+// 导入BeanListHandler，用于将结果集的每一行数据封装为JavaBean对象，并存储在List集合中
 import org.apache.commons.dbutils.handlers.ScalarHandler;
+// 导入ScalarHandler，用于返回结果集的一行一列数据
 
 import java.sql.Connection;
+// 导入Connection接口，用于数据库连接
 import java.sql.SQLException;
+// 导入SQLException类，处理SQL异常
 import java.util.List;
+// 导入List接口，用于存储数据集合
 
 /**
- * @author yj
- * @create 2020-08-21 11:32
+ * @author yj // 类的作者
+ * @create 2020-08-21 11:32 // 类的创建时间
  */
 public abstract class BaseDao {
+    // 定义一个抽象类BaseDao，作为数据访问层的基类
     // 使用DbUtils操作数据库
     private QueryRunner queryRunner = new QueryRunner();
-    /*
+    // 初始化QueryRunner对象，用于执行SQL语句
+
+    /**
      * update()方法用来执行Insert\Update\Delete语句
+     * @param sql 要执行的SQL语句
+     * @param args SQL语句中的参数值，可变参数
      * @return 如果返回-1则失败，成功返回影响的行数
      */
     public int update(String sql, Object ... args) {
         Connection connection = JDBCUtils.getConnection();
+        // 调用JDBCUtils工具类获取数据库连接
         try {
+            // 使用QueryRunner的update方法执行更新操作，并返回影响的行数
             return queryRunner.update(connection, sql, args);
         } catch (SQLException e) {
             e.printStackTrace();
+            // 打印SQL异常堆栈信息
             throw new RuntimeException(e);
+            // 将SQL异常转换为运行时异常抛出
+        } finally {
+            // 注意：原代码中缺少了关闭连接的逻辑，应在此处添加（但在实际使用中，JDBCUtils的getConnection可能已负责关闭）
+            // JDBCUtils.close(connection); // 关闭数据库连接
         }
     }
 
     /**
      * 查询返回一个Javabean的SQL语句
      * @param type 返回的对象类型
-     * @param sql 执行的sql语句
-     * @param args sql对应的参数值
+     * @param sql 执行的SQL语句
+     * @param args SQL语句对应的参数值，可变参数
      * @param <T> 返回的类型的泛型
-     * @return
+     * @return 返回查询结果的第一行数据封装成的JavaBean对象
      */
     public <T> T queryForOne(Class<T> type, String sql, Object ... args) {
         Connection connection = JDBCUtils.getConnection();
+        // 获取数据库连接
         try {
+            // 使用QueryRunner的query方法执行查询操作，并将结果集的第一行数据封装为指定的JavaBean对象
             return queryRunner.query(connection, sql, new BeanHandler<T>(type), args);
         } catch (SQLException e) {
             e.printStackTrace();
+            // 打印SQL异常堆栈信息
             throw new RuntimeException(e);
+            // 将SQL异常转换为运行时异常抛出
+        } finally {
+            // 注意：同样缺少了关闭连接的逻辑，应在实际使用中添加
         }
     }
 
     /**
      * 查询返回多个Javabean的SQL语句
      * @param type 返回的对象类型
-     * @param sql 执行的sql语句
-     * @param args sql对应的参数值
+     * @param sql 执行的SQL语句
+     * @param args SQL语句对应的参数值，可变参数
      * @param <T> 返回的类型的泛型
-     * @return
+     * @return 返回查询结果的每一行数据封装成的JavaBean对象列表
      */
     public <T> List<T> queryForList(Class<T> type, String sql, Object ... args) {
         Connection connection = JDBCUtils.getConnection();
+        // 获取数据库连接
         try {
+            // 使用QueryRunner的query方法执行查询操作，并将结果集的每一行数据封装为指定的JavaBean对象，存储在List集合中返回
             return queryRunner.query(connection, sql, new BeanListHandler<T>(type), args);
         } catch (SQLException e) {
             e.printStackTrace();
+            // 打印SQL异常堆栈信息
             throw new RuntimeException(e);
+            // 将SQL异常转换为运行时异常抛出
+        } finally {
+            // 注意：同样缺少了关闭连接的逻辑，应在实际使用中添加
         }
     }
 
     /**
-     * 执行返回一行一列的sql语句
-     * @param sql 执行的sql语句
-     * @param args sql对应的参数值
-     * @return
+     * 执行返回一行一列的SQL语句
+     * @param sql 执行的SQL语句
+     * @param args SQL语句对应的参数值，可变参数
+     * @return 返回查询结果的一行一列数据
      */
     public Object queryForSingleValue(String sql, Object ... args) {
         Connection connection = JDBCUtils.getConnection();
+        // 获取数据库连接
         try {
+            // 使用QueryRunner的query方法执行查询操作，并返回结果集的一行一列数据
             return queryRunner.query(connection, sql, new ScalarHandler(), args);
         } catch (SQLException e) {
             e.printStackTrace();
+            // 打印SQL异常堆栈信息
             throw new RuntimeException(e);
+            // 将SQL异常转换为运行时异常抛出
+        } finally {
+            // 注意：同样缺少了关闭连接的逻辑，但在实际中，JDBCUtils的getConnection可能已负责关闭连接
         }
     }
 }

src/com/yj/dao/impl/UserDaoImpl.java

@@ -10,77 +10,56 @@ import java.util.List;
  * @create 2020-08-21 15:04
  */
 public class UserDaoImpl extends BaseDao implements UserDao {
-    // 根据用户名查询用户信息
     @Override
     public User querybyUsername(String username) {
-        // SQL 查询语句，选择 t_user 表中的相关字段
         String sql = "select `id`,`username`,`password`,`email`,`address` from t_user where username = ?";
-        // 执行查询并返回单个 User 对象
         return queryForOne(User.class,sql,username);
     }
 
-    // 根据用户名和密码查询用户信息
     @Override
     public User querybyUsernameAndPassword(String username, String password) {
-        // SQL 查询语句，通过用户名和密码查找用户
         String sql = "select * from t_user where username = ? and password = ?";
-        // 执行查询并返回单个 User 对象
         return queryForOne(User.class,sql,username,password);
     }
 
-    // 保存用户信息
     @Override
     public int saveUser(User user) {
-        // SQL 插入语句，向 t_user 表中插入新的用户数据
         String sql = "insert into t_user(`username`,`password`,`email`,`address`) values(?,?,?,?)";
-        // 执行更新操作，返回受影响的行数
         return update(sql,user.getUsername(),user.getPassword(),user.getEmail(),user.getAddress());
     }
 
-    // 添加用户信息（功能与 saveUser 相同）
     @Override
     public int addUser(User user) {
-        // SQL 插入语句，向 t_user 表中插入新的用户数据
         String sql = "insert into t_user(`username`,`password`,`email`,`address`) values(?,?,?,?)";
-        // 执行更新操作，返回受影响的行数
         return update(sql,user.getUsername(),user.getPassword(),user.getEmail(),user.getAddress());
     }
 
-    // 根据用户 ID 删除用户信息
     @Override
     public int deleteUserById(int i) {
-        // SQL 删除语句，根据用户 ID 删除对应的记录
         String sql = "delete from t_user where id = ?";
-        // 执行更新操作，返回受影响的行数
         return update(sql,i);
     }
 
-    // 更新用户信息
     @Override
     public int updateUser(User user) {
-        // SQL 更新语句，根据用户 ID 更新用户的各项信息
         String sql = "update t_user set `username`=?,`password`=?,`email`=?,`address`=? where id=?";
-        // 执行更新操作，返回受影响的行数
         return update(sql,user.getUsername(),user.getPassword(),user.getEmail(),user.getAddress(),user.getId());
     }
 
     @Override
     public User queryUserById(Integer id) {
-        // 根据用户ID查询单个用户信息
         String sql = "select * from t_user where id=?";
         return queryForOne(User.class,sql,id);
     }
 
     @Override
     public List<User> queryUsers() {
-        // 查询所有用户信息
         String sql = "select * from t_user";
         return queryForList(User.class,sql);
     }
 
     @Override
     public Integer queryForPageTotalCount() {
-        // 查询用户表中总记录数，以便进行分页
         String sql = "select count(*) from t_user";
         Number count = (Number) queryForSingleValue(sql);
         return count.intValue();
@@ -88,9 +67,7 @@ public class UserDaoImpl extends BaseDao implements UserDao {
 
     @Override
     public List<User> queryForPageItems(int begin, int pageSize) {
-        // 通过指定的偏移量和页面大小查询特定页的用户信息
         String sql = "select * from t_user limit ?,?";
         return queryForList(User.class,sql,begin,pageSize);
     }
-
 }

src/com/yj/service/BookService.java

@@ -9,28 +9,84 @@ import java.util.List;
 /**
  * @author yj
  * @create 2020-08-24 14:40
+ *
+ * BookService接口定义了与书籍相关的业务逻辑操作，包括书籍的增删改查、分页查询、按价格范围查询、按名称或作者查询等功能。
  */
 public interface BookService {
 
+    /**
+     * 添加一本书籍
+     * @param book 要添加的书籍对象
+     */
     public void addBook(Book book);
 
+    /**
+     * 更新书籍信息
+     * @param book 包含更新信息的书籍对象
+     */
     public void updateBook(Book book);
 
+    /**
+     * 根据书籍ID删除书籍
+     * @param id 要删除的书籍ID
+     */
     public void deleteBookById(Integer id);
 
+    /**
+     * 根据书籍ID查询书籍信息
+     * @param id 要查询的书籍ID
+     * @return 查询到的书籍对象，如果未找到返回null
+     */
     public Book queryBookById(Integer id);
 
+    /**
+     * 查询所有书籍信息
+     * @return 包含所有书籍的列表
+     */
     public List<Book> queryBooks();
 
+    /**
+     * 分页查询书籍信息
+     * @param pageNo 当前页码
+     * @param pageSize 每页显示的记录数
+     * @return 分页对象，包含当前页的书籍列表和分页信息
+     */
     Page<Book> page(int pageNo, int pageSize);
 
+    /**
+     * 根据价格范围分页查询书籍信息
+     * @param pageNo 当前页码
+     * @param pageSize 每页显示的记录数
+     * @param min 价格范围的最小值
+     * @param max 价格范围的最大值
+     * @return 分页对象，包含当前页的书籍列表和分页信息
+     */
     Page<Book> pageByPrice(int pageNo, int pageSize, int min, int max);
 
+    /**
+     * 根据书籍名称或作者分页查询书籍信息
+     * @param pageNo 当前页码
+     * @param pageSize 每页显示的记录数
+     * @param nameOrAuthor 书籍名称或作者的关键字
+     * @return 分页对象，包含当前页的书籍列表和分页信息
+     */
     Page<Book> pageByNameOrAuthor(int pageNo, int pageSize, String nameOrAuthor);
 
+    /**
+     * 查询所有书籍并按某种顺序排序（如销量、价格等）
+     * @return 分页对象，包含按顺序排序的书籍列表和分页信息
+     */
     Page<Book> pageOrder();
 
+    /**
+     * 查询书籍的总数量
+     * @return 书籍的总数量
+     */
     public Integer queryTotalBooks();
 
+    /**
+     * 查询所有书籍的总金额（价格总和）
+     * @return 所有书籍的总金额
+     */
     BigDecimal queryTotalMoney();
 }

src/com/yj/service/UserService.java

@@ -7,68 +7,39 @@ import com.yj.bean.User;
 import java.util.List;
 
 /**
- * 用户服务接口，定义与用户相关的操作
  * @author yj
  * @create 2020-08-21 15:29
  */
 public interface UserService {
-
     /**
      * 注册用户
-     * @param user 要注册的用户对象
+     * @param user
      */
     public void registUser(User user);
 
     /**
-     * 登录方法
-     * @param user 包含用户名和密码的用户对象
-     * @return 返回登录成功的用户对象，如果失败则返回null
+     * 登录
+     * @param user
+     * @return
      */
     public User login(User user);
 
     /**
      * 检查用户名是否可用
-     * @param username 待检查的用户名
+     * @param username
      * @return 返回true表示用户名已存在，返回false表示用户名可用
      */
     public boolean existsUsername(String username);
 
-    /**
-     * 添加新用户
-     * @param user 要添加的用户对象
-     */
     public void addUser(User user);
 
-    /**
-     * 根据用户ID删除用户
-     * @param id 要删除的用户ID
-     */
-    public void deleteUserById(int id);
+    public void deleteUserById(int i);
 
-    /**
-     * 更新用户信息
-     * @param user 包含更新信息的用户对象
-     */
     public void updateUser(User user);
 
-    /**
-     * 根据用户ID查询用户
-     * @param id 用户ID
-     * @return 返回对应的用户对象，如果不存在则返回null
-     */
     public User queryUserById(Integer id);
 
-    /**
-     * 查询所有用户
-     * @return 返回包含所有用户的列表
-     */
     public List<User> queryUsers();
 
-    /**
-     * 分页查询用户
-     * @param pageNo 当前页码
-     * @param pageSize 每页记录数
-     * @return 返回分页对象，包含当前页的用户列表和其他分页信息
-     */
     public Page<User> page(int pageNo, int pageSize);
 }

src/com/yj/service/impl/UserServiceImpl.java

@@ -15,124 +15,84 @@ import java.util.List;
  */
 public class UserServiceImpl implements UserService {
 
-    // 用户数据访问对象，使用UserDaoImpl实现
     private UserDao userDao = new UserDaoImpl();
 
-    /**
-     * 注册用户
-     * @param user 要注册的用户对象
-     */
     @Override
     public void registUser(User user) {
-        userDao.saveUser(user); // 保存用户信息
+        userDao.saveUser(user);
     }
 
-    /**
-     * 用户登录
-     * @param user 包含用户名和密码的用户对象
-     * @return 如果登录成功返回用户对象，否则返回null
-     */
     @Override
     public User login(User user) {
-        return userDao.querybyUsernameAndPassword(user.getUsername(), user.getPassword()); // 验证用户名和密码
+        return userDao.querybyUsernameAndPassword(user.getUsername(),user.getPassword());
     }
 
-    /**
-     * 检查用户名是否存在
-     * @param username 要检查的用户名
-     * @return 如果不存在则返回false，反之则返回true
-     */
     @Override
     public boolean existsUsername(String username) {
         if (userDao.querybyUsername(username) == null) {
-            return false; // 用户名不存在
+            return false;
         } else {
-            return true; // 用户名存在
+            return true;
         }
     }
 
-    /**
-     * 添加新用户
-     * @param user 要添加的用户对象
-     */
     @Override
     public void addUser(User user) {
-        userDao.addUser(user); // 调用数据访问层添加用户
+        userDao.addUser(user);
     }
 
-    /**
-     * 根据用户ID删除用户
-     * @param i 用户ID
-     */
     @Override
     public void deleteUserById(int i) {
-        userDao.deleteUserById(i); // 调用数据访问层删除用户
+        userDao.deleteUserById(i);
     }
 
-    /**
-     * 更新用户信息
-     * @param user 要更新的用户对象
-     */
     @Override
     public void updateUser(User user) {
-        userDao.updateUser(user); // 调用数据访问层更新用户
+        userDao.updateUser(user);
     }
 
-    /**
-     * 根据用户ID查询用户信息
-     * @param id 用户ID
-     * @return 返回对应的用户对象，如果用户不存在则返回null
-     */
     @Override
     public User queryUserById(Integer id) {
-        return userDao.queryUserById(id); // 调用数据访问层查询用户
+        return userDao.queryUserById(id);
     }
 
-    /**
-     * 查询所有用户的信息
-     * @return 返回用户列表
-     */
     @Override
     public List<User> queryUsers() {
-        return userDao.queryUsers(); // 调用数据访问层获取所有用户
+        return userDao.queryUsers();
     }
 
     @Override
     public Page<User> page(int pageNo, int pageSize) {
-        Page<User> page = new Page<User>(); // 创建一个新的分页对象
+        Page<User> page = new Page<User>();
 
         //设置每页记录数
-        page.setPageSize(pageSize); // 将每页的记录数设置为方法传入的pageSize
+        page.setPageSize(pageSize);
 
         //设置总记录数
-        Integer pageTotalCount = userDao.queryForPageTotalCount(); // 从数据库中获取总记录数
-        page.setPageTotalCount(pageTotalCount); // 将总记录数设置到分页对象中
+        Integer pageTotalCount = userDao.queryForPageTotalCount();
+        page.setPageTotalCount(pageTotalCount);
 
-        // 计算总页码
-        Integer pageTotal = pageTotalCount / pageSize; // 根据总记录数和每页大小计算总页数
-        if (pageTotalCount % pageSize > 0) { // 如果有剩余记录，则总页数加一
+        //求总页码
+        Integer pageTotal = pageTotalCount / pageSize;
+        if(pageTotalCount % pageSize >0) {
             pageTotal+=1;
         }
-
         //设置当前页
-        if (pageNo > pageTotal) { // 如果请求的当前页码大于总页码，则设置为最后一页
+        if(pageNo>pageTotal) {
             pageNo = pageTotal;
         }
-        if (pageNo < 1) { // 如果请求的当前页码小于1，则设置为第一页
+        if(pageNo<1) {
             pageNo = 1;
         }
-        page.setPageNo(pageNo); // 将最终确定的当前页码设置到分页对象中
-
+        page.setPageNo(pageNo);
         //设置总页码
-        page.setPageTotal(pageTotal); // 将计算出来的总页码设置到分页对象中
+        page.setPageTotal(pageTotal);
 
-        // 计算当前页的起始记录索引
-        int begin = (page.getPageNo() - 1) * pageSize; // 计算当前页的开始位置
-        // 查询当前页的数据项
-        List<User> items = userDao.queryForPageItems(begin, pageSize); // 从数据库中查询当前页的数据
-        page.setItems(items); // 将查询到的数据设置到分页对象中
 
-        return page; // 返回包含分页信息的分页对象
-    }
+        int begin = (page.getPageNo() -1)*pageSize;
+        List<User> items = userDao.queryForPageItems(begin,pageSize);
+        page.setItems(items);
 
+        return page;
+    }
 }

src/com/yj/test/BookDaoTest.java

@@ -10,59 +10,102 @@ import java.math.BigDecimal;
 /**
  * @author yj
  * @create 2020-08-24 11:01
+ *
+ * BookDaoTest类用于测试BookDao接口的实现类BookDaoImpl中的各个方法。
+ * 通过JUnit测试框架，验证数据库操作的正确性。
  */
 public class BookDaoTest {
+
+    // 创建BookDao接口的实现类BookDaoImpl对象
     BookDao bookDao = new BookDaoImpl();
 
+    /**
+     * 测试添加书籍的方法
+     */
     @Test
     public void addBook() {
-        //`name`,`author`,`classification`,`price`,`sales`,`stock`,`img_path`
-        //Integer id, String name, String author, BigDecimal price, Integer sales, Integer stock, String classification, String imgPath)
+        // 创建一个新的Book对象，并调用addBook方法将其添加到数据库中
         bookDao.addBook(new Book(null, "舌的中国", "yjjj", new BigDecimal("5"), 100, 23, "", ""));
     }
 
+    /**
+     * 测试删除书籍的方法
+     */
     @Test
     public void deleteBook() {
+        // 调用deleteBookById方法，删除ID为3的书籍
         bookDao.deleteBookById(3);
     }
 
+    /**
+     * 测试根据ID查询书籍的方法
+     */
     @Test
     public void queryById() {
+        // 调用queryBookById方法，查询ID为64的书籍，并打印结果
         System.out.println(bookDao.queryBookById(64));
     }
 
+    /**
+     * 测试更新书籍信息的方法
+     */
     @Test
     public void update() {
+        // 创建一个新的Book对象，并调用updateBook方法更新ID为35的书籍信息
         bookDao.updateBook(new Book(35, "舌尖的中国", "yj", new BigDecimal("5"), 100, 23, "文学", ""));
     }
 
+    /**
+     * 测试查询所有书籍的方法
+     */
     @Test
     public void queryList() {
+        // 调用queryBooks方法，查询所有书籍，并打印结果
         System.out.println(bookDao.queryBooks());
     }
 
+    /**
+     * 测试查询书籍总记录数的方法
+     */
     @Test
     public void queryForPageTotalCount() {
+        // 调用queryForPageTotalCount方法，查询所有书籍的总记录数，并打印结果
         System.out.println(bookDao.queryForPageTotalCount());
     }
 
+    /**
+     * 测试分页查询书籍的方法
+     */
     @Test
     public void queryForPageItems() {
+        // 调用queryForPageItems方法，分页查询书籍，并打印结果
         System.out.println(bookDao.queryForPageItems(1, 4));
     }
 
+    /**
+     * 测试根据价格范围查询书籍总记录数的方法
+     */
     @Test
     public void queryForPageTotalCountByPrice() {
+        // 调用queryForPageTotalCountByPrice方法，查询价格在10到50之间的书籍总记录数，并打印结果
         System.out.println(bookDao.queryForPageTotalCountByPrice(10, 50));
     }
 
+    /**
+     * 测试根据价格范围分页查询书籍的方法
+     */
     @Test
     public void queryForPageItemsByPrice() {
+        // 调用queryForPageItemsByPrice方法，根据价格范围分页查询书籍，并打印结果
         System.out.println(bookDao.queryForPageItemsByPrice(1, 4, 10, 50));
     }
 
+    /**
+     * 测试查询书籍总数量的方法
+     */
     @Test
     public void queryBooknums() {
+        // 调用queryBooknums方法，查询书籍的总数量，并打印结果
         System.out.println(bookDao.queryBooknums());
     }
 }

src/com/yj/test/BookServiceTest.java

@@ -12,43 +12,78 @@ import java.math.BigDecimal;
 /**
  * @author yj
  * @create 2020-08-24 14:57
+ *
+ * BookServiceTest类用于测试BookService接口的实现类BookServiceImpl中的各个方法。
+ * 通过JUnit测试框架，验证业务逻辑的正确性。
  */
 public class BookServiceTest {
 
+    // 创建BookDao接口的实现类BookDaoImpl对象
     private BookDao bookDao = new BookDaoImpl();
+
+    // 创建BookService接口的实现类BookServiceImpl对象
     private BookService bookService = new BookServiceImpl();
+
+    /**
+     * 测试添加书籍的方法
+     */
     @Test
     public void addBook() {
+        // 创建一个新的Book对象，并调用addBook方法将其添加到数据库中
         bookDao.addBook(new Book(null, "舌尖上的中国", "yj", new BigDecimal("5"), 100, 23, "文学", ""));
     }
 
+    /**
+     * 测试更新书籍信息的方法
+     */
     @Test
     public void updateBook() {
+        // 创建一个新的Book对象，并调用updateBook方法更新书籍信息
         bookDao.updateBook(new Book(null, "舌尖上的中国", "yj", new BigDecimal("5"), 100, 23, "文学", ""));
     }
 
+    /**
+     * 测试根据ID删除书籍的方法
+     */
     @Test
     public void deleteBookById() {
+        // 调用deleteBookById方法，删除ID为25的书籍，并打印受影响的行数
         System.out.println(bookDao.deleteBookById(25));
     }
 
+    /**
+     * 测试根据ID查询书籍的方法
+     */
     @Test
     public void queryBookById() {
+        // 调用queryBookById方法，查询ID为23的书籍，并打印结果
         System.out.println(bookDao.queryBookById(23));
     }
 
+    /**
+     * 测试查询所有书籍的方法
+     */
     @Test
     public void queryBooks() {
+        // 调用queryBooks方法，查询所有书籍，并打印结果
         System.out.println(bookDao.queryBooks());
     }
 
+    /**
+     * 测试分页查询书籍总记录数的方法
+     */
     @Test
     public void page() {
+        // 调用queryForPageTotalCount方法，查询所有书籍的总记录数，并打印结果
         System.out.println(bookDao.queryForPageTotalCount());
     }
 
+    /**
+     * 测试查询所有书籍的总金额的方法
+     */
     @Test
     public void queryTotalMoney() {
+        // 调用queryTotalMoney方法，查询所有书籍的总金额，并打印结果
         System.out.println(bookDao.queryTotalMoney());
     }
 }

src/com/yj/test/CartTest.java

@@ -10,44 +10,64 @@ import java.math.BigDecimal;
  * @author yj
  * @create 2020-08-26 20:30
  */
+// 定义一个测试类CartTest，用于测试Cart类的功能
 public class CartTest {
 
+    // 使用@Test注解标记的方法表示这是一个测试方法，通常与测试框架（如JUnit）一起使用
     @Test
     public void addItem() {
+        // 创建一个新的Cart对象
         Cart cart = new Cart();
+        // 向购物车中添加一个商品项，注意这里totalPrice应该是根据price和count计算得出的，但此处直接给出
         cart.addItem(new CartItem(1,"lkjs",1,new BigDecimal(5),new BigDecimal(66)));
+        // 再次添加相同的商品项，理论上应该更新数量而不是添加新项（但根据代码，它会添加新项）
         cart.addItem(new CartItem(1,"lkjs",1,new BigDecimal(5),new BigDecimal(66)));
+        // 添加一个不同的商品项
         cart.addItem(new CartItem(2,"你妹的",1,new BigDecimal(5),new BigDecimal(66)));
+        // 打印购物车的内容，输出将取决于Cart类的toString方法实现
         System.out.println(cart);
     }
 
+    // 另一个测试方法，用于测试删除商品项的功能
     @Test
     public void deleteItem() {
+        // 创建一个新的Cart对象并添加一些商品项
         Cart cart = new Cart();
         cart.addItem(new CartItem(1,"lkjs",1,new BigDecimal(5),new BigDecimal(66)));
         cart.addItem(new CartItem(1,"lkjs",1,new BigDecimal(5),new BigDecimal(66)));
         cart.addItem(new CartItem(2,"你妹的",1,new BigDecimal(5),new BigDecimal(66)));
+        // 根据商品ID删除商品项，理论上应该删除所有ID匹配的项
         cart.deleteItem(1);
+        // 打印购物车的内容，查看删除操作的结果
         System.out.println(cart);
     }
 
+    // 测试清空购物车的方法
     @Test
     public void clear() {
+        // 创建一个新的Cart对象并添加一些商品项
         Cart cart = new Cart();
         cart.addItem(new CartItem(1,"lkjs",1,new BigDecimal(5),new BigDecimal(66)));
         cart.addItem(new CartItem(1,"lkjs",1,new BigDecimal(5),new BigDecimal(66)));
         cart.addItem(new CartItem(2,"你妹的",1,new BigDecimal(5),new BigDecimal(66)));
+        // 清空购物车中的所有商品项
         cart.clear();
+        // 打印购物车的内容，应该为空
         System.out.println(cart);
     }
 
+    // 测试更新商品数量的方法
     @Test
     public void updateCount() {
+        // 创建一个新的Cart对象并添加一些商品项
         Cart cart = new Cart();
         cart.addItem(new CartItem(1,"lkjs",1,new BigDecimal(5),new BigDecimal(66)));
         cart.addItem(new CartItem(1,"lkjs",1,new BigDecimal(5),new BigDecimal(66)));
         cart.addItem(new CartItem(2,"你妹的",1,new BigDecimal(5),new BigDecimal(66)));
+        // 根据商品ID更新商品数量，注意这里可能需要根据业务逻辑决定是更新现有项还是添加新项
         cart.updateCount(1,5);
+        // 假设意图是将ID为1的商品数量更新为5
+        // 打印购物车的内容，查看更新操作的结果
         System.out.println(cart);
     }
 }

src/com/yj/test/JDBCUtilsTest.java

@@ -1,29 +1,44 @@
 package com.yj.test;
+// 声明包名，用于组织类
 
 import com.yj.utils.JDBCUtils;
+// 导入JDBCUtils工具类，用于数据库连接
 import org.junit.Test;
+// 导入JUnit测试注解
 
 import java.sql.Connection;
+// 导入Connection接口，用于数据库连接
 import java.sql.ResultSet;
+// 导入ResultSet接口，用于处理查询结果集
 import java.sql.Statement;
+// 导入Statement接口，用于执行SQL语句
 
 /**
  * @author yj
  * @create 2020-08-21 11:25
  */
-public class JDBCUtilsTest {
-    @Test
+public class JDBCUtilsTest { // 定义一个测试类
+    @Test // 标记此方法为一个测试方法
     public void testJdbcUtils() {
+        // 定义一个测试方法
         Connection connection = JDBCUtils.getConnection();
+        // 通过JDBCUtils工具类获取数据库连接
         String sql = "select * from t_book";
+        // 定义SQL查询语句，查询t_book表中的所有记录
         try (Statement st = connection.createStatement()) {
+            // 创建Statement对象用于执行SQL语句，使用try-with-resources语法自动关闭资源
             ResultSet rs = st.executeQuery(sql);
-            while(rs.next()){
+            // 执行查询语句，并将结果存储在ResultSet对象中
+            while(rs.next()){ // 遍历ResultSet对象中的每一条记录
                 System.out.println(rs.getString("author")+" "
+                        // 从当前记录中获取"author"字段的值，并输出
                         +rs.getString("name"));
+                // 从当前记录中获取"name"字段的值，并输出，与"author"字段的值用空格分隔
             }
         }catch (Exception e) {
+            // 捕获并处理异常
             e.printStackTrace();
+            // 打印异常堆栈信息
         }
     }
 }

src/com/yj/test/UserDaoTest.java

@@ -13,17 +13,9 @@ import java.util.List;
  * @author yj
  * @create 2020-08-21 15:14
  */
-import org.junit.Test;
-
 public class UserDaoTest {
 
-    // 创建UserDao的实例，用于测试
         UserDao userDao = new UserDaoImpl();
-
-    /**
-     * 测试根据用户名查询用户
-     * 如果返回值为null，则表示用户名可用，否则表示用户名已存在
-     */
     @Test
     public void querybyUsername() {
         if(userDao.querybyUsername("yan1gjie")==null) {
@@ -34,10 +26,6 @@ public class UserDaoTest {
         //System.out.println(userDao.querybyUsername("yangjie"));
     }
 
-    /**
-     * 测试根据用户名和密码查询用户
-     * 如果返回值为null，则表示登录失败（密码错误或用户名错误），否则表示登录成功
-     */
     @Test
     public void querybyUsernameAndPassword() {
         if(userDao.querybyUsernameAndPassword("yagjie","yanjie")==null) {
@@ -47,37 +35,21 @@ public class UserDaoTest {
         }
     }
 
-    /**
-     * 测试保存用户信息
-     * 输出保存用户操作的结果
-     */
     @Test
     public void saveUser() {
         System.out.println(userDao.saveUser(new User(null,"yangjie2","yangjie","wzg168@qq.com","大河湾")));
     }
 
-    /**
-     * 测试添加新用户
-     * 输出添加用户操作的结果
-     */
     @Test
     public void addUser() {
         System.out.println(userDao.addUser(new User(null,"舒胡2贤","123456","123456@qq.com","贵州")));
     }
 
-    /**
-     * 测试根据用户ID删除用户
-     * 输出删除用户操作的结果
-     */
     @Test
     public void deleteUserById() {
         System.out.println(userDao.deleteUserById(3));
     }
 
-    /**
-     * 测试更新用户信息
-     * 输出更新用户操作的结果
-     */
     @Test
     public void updateUser() {
         System.out.println(userDao.updateUser(new User(3,"舒胡贤","123456","123456@qq.com","贵州")));
@@ -85,30 +57,23 @@ public class UserDaoTest {
 
     @Test
     public void queryUserById() {
-        // 根据用户ID查询用户信息
         User user = userDao.queryUserById(1);
-        // 输出查询到的用户信息
         System.out.println(user);
     }
 
     @Test
     public void queryUsers() {
-        // 查询所有用户的信息
         List<User> users = userDao.queryUsers();
-        // 输出所有用户的信息
         System.out.println(users);
     }
 
     @Test
     public void queryForPageTotalCount() {
-        // 查询用户总数，用于分页功能
         System.out.println(userDao.queryForPageTotalCount());
     }
 
     @Test
     public void queryForPageItems() {
-        // 查询指定页码和每页数量的用户信息
-        // 这里查询第一页的2条用户记录
         System.out.println(userDao.queryForPageItems(1,2));
     }
 }

src/com/yj/test/UserServiceImplTest.java

@@ -6,43 +6,35 @@ import com.yj.service.impl.UserServiceImpl;
 import org.junit.Test;
 
 /**
- * 用户服务实现类的测试类
  * @author yj
  * @create 2020-08-21 15:38
  */
 public class UserServiceImplTest {
 
-    // 创建UserService的实例
     UserService userService = new UserServiceImpl();
-
     @Test
     public void registUser() {
-        // 测试用户注册功能，创建一个新的用户对象并进行注册
-        userService.registUser(new User(null, "admin", "admin", "225@qq.com", "大河湾"));
+        userService.registUser(new User(null,"admin","admin","225@qq.com","大河湾"
+                ));
     }
 
     @Test
     public void login() {
-        // 测试用户登录功能
-        // 创建一个用户对象用于登录验证
         if(userService.login(new User(null,"admin123","admin",null,"大河湾"))==null) {
-            // 如果登录返回为null，则输出登录失败
             System.out.println("登录失败");
         } else {
-            // 登录成功的情况下输出提示
+
         System.out.println("登陆成功");
         }
     }
 
     @Test
     public void existsUsername() {
-        // 测试用户名是否存在的方法
         if(userService.existsUsername("admin35135")==false) {
-            // 如果用户名不存在，输出可用提示
             System.out.println("用户名可用");
         } else {
-            // 如果用户名已存在，输出提示
         System.out.println("用户名已存在");
+
         }
     }
 }

src/com/yj/test/UserServiceTest.java

@@ -8,61 +8,34 @@ import org.junit.Test;
 import static org.junit.Assert.*;
 
 /**
- * UserService类的测试类，用于测试用户相关的方法
  * @author yj
  * @create 2020-10-21 18:50
  */
 public class UserServiceTest {
-    // 创建UserService的实例，使用UserServiceImpl实现类
     UserService userService = new UserServiceImpl();
-
-    /**
-     * 测试添加用户功能
-     */
     @Test
     public void addUser() {
-        // 调用addUser方法，添加一个新的用户
         userService.addUser(new User(null,"舒胡贤2","kj","1234@qq.com","kjk"));
     }
 
-    /**
-     * 测试根据ID删除用户功能
-     */
     @Test
     public void deleteUserById() {
-        // 调用deleteUserById方法，根据用户ID删除用户（此处示例为删除ID为3的用户）
         userService.deleteUserById(3);
     }
 
-    /**
-     * 测试更新用户信息功能
-     */
     @Test
     public void updateUser() {
-        // 该方法尚未实现，用于测试更新用户信息的逻辑
     }
 
-    /**
-     * 测试根据ID查询用户功能
-     */
     @Test
     public void queryUserById() {
-        // 该方法尚未实现，用于测试根据用户ID查询用户的逻辑
     }
 
-    /**
-     * 测试查询所有用户功能
-     */
     @Test
     public void queryUsers() {
-        // 该方法尚未实现，用于测试查询所有用户的逻辑
     }
 
-    /**
-     * 测试分页查询用户功能
-     */
     @Test
     public void page() {
-        // 该方法尚未实现，用于测试分页查询用户的逻辑
     }
 }

src/com/yj/utils/JDBCUtils.java

@@ -1,79 +1,107 @@
 package com.yj.utils;
+// 声明包名
 
 import com.alibaba.druid.pool.DruidDataSource;
+// 导入Druid连接池的数据源类
 import com.alibaba.druid.pool.DruidDataSourceFactory;
+// 导入Druid连接池的工厂类
 import com.alibaba.druid.util.JdbcUtils;
+// 导入Druid的工具类（注意：此处的JdbcUtils并非JDK自带的，而是Druid框架提供的，但在此代码中未直接使用）
 
 import java.io.InputStream;
+// 导入输入流接口
 import java.sql.Connection;
+// 导入数据库连接接口
 import java.sql.SQLException;
+// 导入SQL异常类
 import java.util.Properties;
+// 导入属性类
 
 /**
  * @author yj
  * @create 2020-08-21 10:48
  */
 public class JDBCUtils {
+    // 定义一个工具类
     private static DruidDataSource dataSource;
+    // 定义一个静态的Druid数据源对象
     private static ThreadLocal<Connection> conns = new ThreadLocal<Connection>();
+    // 定义一个ThreadLocal对象，用于存储每个线程的数据库连接
 
     static {
+        // 静态代码块，用于初始化静态变量
         try {
             Properties properties = new Properties();
+            // 创建一个属性对象
             // 读取jdbc.properties属性配置文件
             InputStream inputStream = JdbcUtils.class.getClassLoader().getResourceAsStream("jdbc.properties");
-            //从流中加载数据
+            // 从流中加载数据到属性对象中
             properties.load(inputStream);
             // 创建数据库连接池
             dataSource = (DruidDataSource) DruidDataSourceFactory.createDataSource(properties);
+            // 使用Druid工厂类创建数据源对象
 
         } catch (Exception e) {
+            // 捕获异常
             e.printStackTrace();
+            // 打印异常堆栈信息
         }
-
     }
 
-
-
-
-
-    /*
-        获取数据库连接池的连接
-        @retrun 如果返回null则连接失败
+    /**
+     * 获取数据库连接池的连接
+     * @return 如果返回null则连接失败
      */
     public static Connection getConnection() {
+        // 定义一个静态方法，用于获取数据库连接
         Connection conn = conns.get();
+        // 从ThreadLocal对象中获取当前线程的连接
         if(conn == null) {
+            // 如果当前线程没有连接
             try {
-               conn = dataSource.getConnection();//从数据库池中获取连接
-               conns.set(conn);//保存到ThreadLocal对象中，供后面的JDBC操作使用
-               conn.setAutoCommit(false);//设置为手动管理事务
+                conn = dataSource.getConnection();
+                // 从数据库池中获取连接
+                conns.set(conn);
+                // 将连接保存到ThreadLocal对象中，供后面的JDBC操作使用
+                conn.setAutoCommit(false);
+                // 设置为手动管理事务
             } catch (SQLException throwables) {
+                // 捕获SQL异常
                 throwables.printStackTrace();
+                // 打印异常堆栈信息
             }
         }
         return conn;
+        // 返回连接
     }
 
     /**
      * 提交事务并关闭释放连接
      */
     public static void commitAndClose() {
+        // 定义一个静态方法，用于提交事务并关闭连接
         Connection connection = conns.get();
+        // 从ThreadLocal对象中获取连接
         if(connection!=null) {
+            // 如果连接不为空
             try {
                 connection.commit();// 提交事务
             } catch (SQLException throwables) {
+                // 捕获SQL异常
                 throwables.printStackTrace();
+                // 打印异常堆栈信息
             }finally {
                 try {
-                    connection.close();//关闭连接释放资源
+                    connection.close();
+                    // 关闭连接释放资源
                 } catch (SQLException throwables) {
+                    // 捕获SQL异常
                     throwables.printStackTrace();
+                    // 打印异常堆栈信息
                 }
             }
         }
-        //一定要执行remove操作，否则就会出错，因为tomcat底层使用了线程池技术
+        // 移除ThreadLocal对象中的连接，防止内存泄漏（特别是在使用线程池时）
         conns.remove();
     }
 
@@ -81,31 +109,41 @@ public class JDBCUtils {
      * 回滚事务并关闭释放连接
      */
     public static void rollbackAndClose() {
+        // 定义一个静态方法，用于回滚事务并关闭连接
         Connection connection = conns.get();
+        // 从ThreadLocal对象中获取连接
         if(connection!=null) {
+            // 如果连接不为空
             try {
-                connection.rollback();//回滚事务
+                connection.rollback();
+                // 回滚事务
             } catch (SQLException throwables) {
+                // 捕获SQL异常
                 throwables.printStackTrace();
+                // 打印异常堆栈信息
             }finally {
                 try {
-                    connection.close();//关闭连接释放资源
+                    connection.close();
+                    // 关闭连接释放资源
                 } catch (SQLException throwables) {
+                    // 捕获SQL异常
                     throwables.printStackTrace();
+                    // 打印异常堆栈信息
                 }
             }
         }
-        //一定要执行remove操作，否则就会出错，因为tomcat底层使用了线程池技术
+        // 移除ThreadLocal对象中的连接，防止内存泄漏（特别是在使用线程池时）
         conns.remove();
     }
 
     /*
-        关闭连接，放回数据库连接池
-
+        （注释掉的代码）关闭连接，放回数据库连接池
+        （注意：由于使用了连接池，通常不需要手动关闭连接放回池中，连接池会自动管理连接的回收和重用）
     public static void close(Connection conn) {
         if(conn != null) {
             try {
                 conn.close();
+                 // 这里实际上并不是将连接关闭，而是将连接归还给连接池（对于连接池而言）
             } catch (SQLException throwables) {
                 throwables.printStackTrace();
             }

src/com/yj/utils/PaymentUtil.java

@@ -12,10 +12,11 @@ import java.util.Arrays;
 
 public class PaymentUtil {
 
+    // 定义字符编码
     private static String encodingCharset = "UTF-8";
 
     /**
-     * 生成hmac方法
+     * 生成hmac方法，用于构建支付请求的参数签名
      *
      * @param p0_Cmd 业务类型
      * @param p1_MerId 商户编号
@@ -31,45 +32,34 @@ public class PaymentUtil {
      * @param pd_FrpId 银行编码
      * @param pr_NeedResponse 应答机制
      * @param keyValue 商户密钥
-     * @return
+     * @return 生成的hmac签名
      */
     public static String buildHmac(String p0_Cmd, String p1_MerId,
                                    String p2_Order, String p3_Amt, String p4_Cur, String p5_Pid, String p6_Pcat,
                                    String p7_Pdesc, String p8_Url, String p9_SAF, String pa_MP, String pd_FrpId,
                                    String pr_NeedResponse, String keyValue) {
         StringBuilder sValue = new StringBuilder();
-        // 业务类型
+        // 依次追加所有参数到StringBuilder
         sValue.append(p0_Cmd);
-        // 商户编号
         sValue.append(p1_MerId);
-        // 商户订单号
         sValue.append(p2_Order);
-        // 支付金额
         sValue.append(p3_Amt);
-        // 交易币种
         sValue.append(p4_Cur);
-        // 商品名称
         sValue.append(p5_Pid);
-        // 商品种类
         sValue.append(p6_Pcat);
-        // 商品描述
         sValue.append(p7_Pdesc);
-        // 商户接收支付成功数据的地址
         sValue.append(p8_Url);
-        // 送货地址
         sValue.append(p9_SAF);
-        // 商户扩展信息
         sValue.append(pa_MP);
-        // 银行编码
         sValue.append(pd_FrpId);
-        // 应答机制
         sValue.append(pr_NeedResponse);
 
+        // 调用hmacSign方法生成签名
         return PaymentUtil.hmacSign(sValue.toString(), keyValue);
     }
 
     /**
-     * 返回校验hmac方法
+     * 验证支付网关回调的hmac签名
      *
      * @param hmac 支付网关发来的加密验证码
      * @param p1_MerId 商户编号
@@ -84,57 +74,54 @@ public class PaymentUtil {
      * @param r8_MP 商户扩展信息
      * @param r9_BType 交易结果返回类型
      * @param keyValue 密钥
-     * @return
+     * @return 验证结果，true表示验证通过
      */
     public static boolean verifyCallback(String hmac, String p1_MerId,
                                          String r0_Cmd, String r1_Code, String r2_TrxId, String r3_Amt,
                                          String r4_Cur, String r5_Pid, String r6_Order, String r7_Uid,
                                          String r8_MP, String r9_BType, String keyValue) {
         StringBuilder sValue = new StringBuilder();
-        // 商户编号
+        // 依次追加所有回调参数到StringBuilder
         sValue.append(p1_MerId);
-        // 业务类型
         sValue.append(r0_Cmd);
-        // 支付结果
         sValue.append(r1_Code);
-        // 易宝支付交易流水号
         sValue.append(r2_TrxId);
-        // 支付金额
         sValue.append(r3_Amt);
-        // 交易币种
         sValue.append(r4_Cur);
-        // 商品名称
         sValue.append(r5_Pid);
-        // 商户订单号
         sValue.append(r6_Order);
-        // 易宝支付会员ID
         sValue.append(r7_Uid);
-        // 商户扩展信息
         sValue.append(r8_MP);
-        // 交易结果返回类型
         sValue.append(r9_BType);
+        // 调用hmacSign方法生成签名并与支付网关的签名比较
         String sNewString = PaymentUtil.hmacSign(sValue.toString(), keyValue);
         return sNewString.equals(hmac);
     }
 
     /**
-     * @param aValue
-     * @param aKey
-     * @return
+     * 使用HMAC-MD5算法生成签名
+     *
+     * @param aValue 待签名的字符串
+     * @param aKey 密钥
+     * @return 生成的签名
      */
     public static String hmacSign(String aValue, String aKey) {
+        // 初始化内部填充字节数组
         byte k_ipad[] = new byte[64];
         byte k_opad[] = new byte[64];
         byte keyb[];
         byte value[];
         try {
+            // 使用指定的字符编码获取字节数组
             keyb = aKey.getBytes(encodingCharset);
             value = aValue.getBytes(encodingCharset);
         } catch (UnsupportedEncodingException e) {
+            // 如果不支持指定的字符编码，则使用默认字符编码
             keyb = aKey.getBytes();
             value = aValue.getBytes();
         }
 
+        // 填充k_ipad和k_opad数组
         Arrays.fill(k_ipad, keyb.length, 64, (byte) 54);
         Arrays.fill(k_opad, keyb.length, 64, (byte) 92);
         for (int i = 0; i < keyb.length; i++) {
@@ -142,23 +129,32 @@ public class PaymentUtil {
             k_opad[i] = (byte) (keyb[i] ^ 0x5c);
         }
 
+        // 获取MD5算法的MessageDigest实例
         MessageDigest md = null;
         try {
             md = MessageDigest.getInstance("MD5");
         } catch (NoSuchAlgorithmException e) {
-
+            // 如果MD5算法不可用，则返回null
             return null;
         }
+        // 对k_ipad和待签名数据进行更新
         md.update(k_ipad);
         md.update(value);
-        byte dg[] = md.digest();
-        md.reset();
+        byte dg[] = md.digest(); // 进行第一次摘要
+        md.reset(); // 重置MessageDigest实例
+        // 对k_opad和第一次摘要结果进行更新
         md.update(k_opad);
         md.update(dg, 0, 16);
-        dg = md.digest();
-        return toHex(dg);
+        dg = md.digest(); // 进行第二次摘要，得到最终的签名
+        return toHex(dg); // 将字节数组转换为十六进制字符串
     }
 
+    /**
+     * 将字节数组转换为十六进制字符串
+     *
+     * @param input 字节数组
+     * @return 十六进制字符串
+     */
     public static String toHex(byte input[]) {
         if (input == null)
             return null;
@@ -169,15 +165,15 @@ public class PaymentUtil {
                 output.append("0");
             output.append(Integer.toString(current, 16));
         }
-
         return output.toString();
     }
 
     /**
+     * 根据参数数组和密钥生成HMAC签名
      *
-     * @param args
-     * @param key
-     * @return
+     * @param args 参数数组
+     * @param key 密钥
+     * @return 生成的HMAC签名
      */
     public static String getHmac(String[] args, String key) {
         if (args == null || args.length == 0) {
@@ -191,8 +187,10 @@ public class PaymentUtil {
     }
 
     /**
-     * @param aValue
-     * @return
+     * 使用SHA算法对字符串进行摘要
+     *
+     * @param aValue 待摘要的字符串
+     * @return 摘要结果的十六进制字符串
      */
     public static String digest(String aValue) {
         aValue = aValue.trim();

src/com/yj/web/BaseServlet.java

@@ -10,25 +10,53 @@ import java.lang.reflect.Method;
 /**
  * @author yj
  * @create 2020-08-23 16:51
+ *
+ * BaseServlet类是一个抽象的Servlet基类，用于简化Servlet的开发。
+ * 它通过反射机制动态调用子类中的方法，避免了在每个Servlet中重复编写doGet和doPost方法。
  */
 public abstract class BaseServlet extends HttpServlet {
 
+    /**
+     * 处理GET请求，直接调用doPost方法
+     * @param req HttpServletRequest对象
+     * @param resp HttpServletResponse对象
+     * @throws ServletException
+     * @throws IOException
+     */
     @Override
     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
         doPost(req, resp);
     }
 
+    /**
+     * 处理POST请求，通过反射机制动态调用子类中的方法
+     * @param req HttpServletRequest对象
+     * @param resp HttpServletResponse对象
+     * @throws ServletException
+     * @throws IOException
+     */
+    @Override
     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
-        //解决post请求中文乱码
+        // 解决POST请求中文乱码问题
         req.setCharacterEncoding("utf-8");
-        //解决相应的中文乱码
+
+        // 解决响应的中文乱码问题
         resp.setContentType("text/html;charset=UTF-8");
+
+        // 获取请求参数action，该参数用于指定要调用的方法名
         String action = req.getParameter("action");
+
         try {
+            // 通过反射获取当前类中指定名称的方法
             Method method = this.getClass().getDeclaredMethod(action, HttpServletRequest.class, HttpServletResponse.class);
+
+            // 调用方法，传入请求和响应对象
             method.invoke(this, req, resp);
         } catch (Exception e) {
+            // 捕获异常并打印堆栈信息
             e.printStackTrace();
+
+            // 将异常包装为运行时异常抛出，便于上层处理
             throw new RuntimeException(e);
         }
     }

src/com/yj/web/BookServlet.java

@@ -15,72 +15,137 @@ import java.util.List;
 /**
  * @author yj
  * @create 2020-08-24 15:25
+ *
+ * BookServlet类继承自BaseServlet，用于处理与书籍相关的请求。
+ * 通过调用BookService接口的实现类BookServiceImpl，完成书籍的增删改查、分页查询等操作。
  */
 public class BookServlet extends BaseServlet {
 
+    // 创建BookService接口的实现类BookServiceImpl对象
     private BookService bookService = new BookServiceImpl();
 
+    /**
+     * 处理添加书籍的请求
+     * @param req HttpServletRequest对象
+     * @param resp HttpServletResponse对象
+     * @throws ServletException
+     * @throws IOException
+     */
     protected void add(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+        // 获取当前页码，默认从0开始
         int pageNo = WebUtils.parseInt(req.getParameter("pageNo"), 0);
+        // 页码加1，表示添加书籍后跳转到下一页
         pageNo += 1;
+
+        // 将请求参数封装到Book对象中
         Book book = (Book) WebUtils.copyParamToBean(req.getParameterMap(), new Book());
+
+        // 调用BookService的addBook方法添加书籍
         bookService.addBook(book);
-        //req.getRequestDispatcher("/manager/bookServlet?action=list").forward(req,resp);
+
+        // 重定向到书籍管理页面，并跳转到添加书籍后的页码
         resp.sendRedirect(req.getContextPath() + "/manager/bookServlet?action=page&pageNo=" + pageNo);
     }
 
-
+    /**
+     * 处理删除书籍的请求
+     * @param req HttpServletRequest对象
+     * @param resp HttpServletResponse对象
+     * @throws ServletException
+     * @throws IOException
+     */
     protected void delete(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+        // 获取要删除的书籍ID
         String id = req.getParameter("id");
         int i = Integer.parseInt(id);
+
+        // 调用BookService的deleteBookById方法删除书籍
         bookService.deleteBookById(i);
+
+        // 重定向到书籍管理页面，并保持当前页码
         resp.sendRedirect(req.getContextPath() + "/manager/bookServlet?action=page&pageNo=" + req.getParameter("pageNo"));
     }
 
-
+    /**
+     * 处理更新书籍的请求
+     * @param req HttpServletRequest对象
+     * @param resp HttpServletResponse对象
+     * @throws ServletException
+     * @throws IOException
+     */
     protected void update(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+        // 将请求参数封装到Book对象中
         Book book = (Book) WebUtils.copyParamToBean(req.getParameterMap(), new Book());
+
+        // 调用BookService的updateBook方法更新书籍
         bookService.updateBook(book);
+
+        // 重定向到书籍管理页面，并保持当前页码
         resp.sendRedirect(req.getContextPath() + "/manager/bookServlet?action=page&pageNo=" + req.getParameter("pageNo"));
     }
 
     /**
-     *
-     * @param req
-     * @param resp
+     * 处理获取单个书籍信息的请求
+     * @param req HttpServletRequest对象
+     * @param resp HttpServletResponse对象
      * @throws ServletException
      * @throws IOException
      */
     protected void getBook(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+        // 获取要查询的书籍ID
         String id = req.getParameter("id");
         int i = Integer.parseInt(id);
+
+        // 调用BookService的queryBookById方法查询书籍
         Book book = bookService.queryBookById(i);
+
+        // 将查询到的书籍信息保存到request域中
         req.setAttribute("book", book);
+
+        // 请求转发到书籍编辑页面
         req.getRequestDispatcher("/pages/manager/book_edit.jsp").forward(req, resp);
     }
 
-
+    /**
+     * 处理查询所有书籍的请求
+     * @param req HttpServletRequest对象
+     * @param resp HttpServletResponse对象
+     * @throws ServletException
+     * @throws IOException
+     */
     protected void list(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
-        //1、通过BookService查询数据
+        // 调用BookService的queryBooks方法查询所有书籍
         List<Book> books = bookService.queryBooks();
-        //2、将数据保存在request域中
+
+        // 将查询到的书籍列表保存到request域中
         req.setAttribute("books", books);
-        //3、请求转发到pages/manager/book_manager.jsp
+
+        // 请求转发到书籍管理页面
         req.getRequestDispatcher("/pages/manager/book_manager.jsp").forward(req, resp);
     }
 
+    /**
+     * 处理分页查询书籍的请求
+     * @param req HttpServletRequest对象
+     * @param resp HttpServletResponse对象
+     * @throws ServletException
+     * @throws IOException
+     */
     protected void page(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
-        //1、获取请求的参数pageNo和pageSize
+        // 获取请求参数pageNo和pageSize
         int pageNo = WebUtils.parseInt(req.getParameter("pageNo"), 1);
         int pageSize = WebUtils.parseInt(req.getParameter("pageSize"), Page.PAGE_SIZE);
 
-        //2、调用BookService.page(pageNo,pageSize)方法：返回page对象
+        // 调用BookService的page方法进行分页查询
         Page<Book> page = bookService.page(pageNo, pageSize);
+
+        // 设置分页请求的URL
         page.setUrl("manager/bookServlet?action=page");
 
-        //3、保存Page对象到request域中
+        // 将分页对象保存到request域中
         req.setAttribute("page", page);
-        //4、请求转发到page/manager/book_manager.jsp页面
+
+        // 请求转发到书籍管理页面
         req.getRequestDispatcher("/pages/manager/book_manager.jsp").forward(req, resp);
     }
 }

src/com/yj/web/CartServlet.java

@@ -1,12 +1,20 @@
+// 导入所需的包和类
 package com.yj.web;
 
 import com.google.gson.Gson;
+// 用于将Java对象转换为JSON字符串
 import com.yj.bean.Book;
+// 书籍实体类
 import com.yj.bean.Cart;
+// 购物车实体类
 import com.yj.bean.CartItem;
+// 购物车商品项实体类
 import com.yj.service.BookService;
+// 书籍服务接口
 import com.yj.service.impl.BookServiceImpl;
+// 书籍服务接口的实现类
 import com.yj.utils.WebUtils;
+// 工具类，用于处理Web请求中的常见操作
 
 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServletRequest;
@@ -15,43 +23,45 @@ import java.io.IOException;
 import java.util.HashMap;
 import java.util.Map;
 
-/**
- * @author yj
- * @create 2020-08-27 9:47
- */
+// 定义一个Servlet类，用于处理与购物车相关的请求
 public class CartServlet extends BaseServlet {
 
+    // 创建一个书籍服务实例，用于访问书籍数据
     private BookService bookService = new BookServiceImpl();
 
+    // 处理通过AJAX方式添加商品到购物车的请求
     protected void ajaxAddItem(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+        // 从请求中获取书籍ID，并转换为整数类型，默认为0
         int id = WebUtils.parseInt(req.getParameter("id"), 0);
+        // 根据书籍ID查询书籍信息
         Book book = bookService.queryBookById(id);
+        // 创建一个购物车商品项实例，数量为1，单价和总价均为书籍价格
         CartItem cartItem = new CartItem(book.getId(), book.getName(), 1, book.getPrice(), book.getPrice());
+        // 从会话中获取购物车对象，如果不存在则创建一个新的购物车对象
         Cart cart = (Cart) req.getSession().getAttribute("cart");
         if (cart == null) {
             cart = new Cart();
             req.getSession().setAttribute("cart", cart);
         }
+        // 将商品项添加到购物车中
         cart.addItem(cartItem);
+        // 在会话中保存最后添加的商品名称（可能用于显示或提示）
         req.getSession().setAttribute("lastName", cartItem.getName());
 
-        //返回购物车总数量和最后一个商品的名称
+        // 准备返回给客户端的数据，包括购物车总数量和最后一个商品的名称
         Map<String, Object> resultMap = new HashMap<String, Object>();
         resultMap.put("totalCount", cart.getTotalCount());
         resultMap.put("lastName", cartItem.getName());
+        // 使用Gson将Map对象转换为JSON字符串
         Gson gson = new Gson();
         String resultMapJsonString = gson.toJson(resultMap);
+        // 将JSON字符串写入响应中
         resp.getWriter().write(resultMapJsonString);
-
     }
-    /**
-     * 加入购物车
-     * @param req
-     * @param resp
-     * @throws ServletException
-     * @throws IOException
-     */
+
+    // 处理添加商品到购物车的请求（非AJAX方式）
     protected void addItem(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+        // 以下代码与ajaxAddItem方法中的代码大致相同，只是最后返回的是页面重定向
         int id = WebUtils.parseInt(req.getParameter("id"), 0);
         Book book = bookService.queryBookById(id);
         CartItem cartItem = new CartItem(book.getId(), book.getName(), 1, book.getPrice(), book.getPrice());
@@ -62,53 +72,44 @@ public class CartServlet extends BaseServlet {
         }
         cart.addItem(cartItem);
         req.getSession().setAttribute("lastName", cartItem.getName());
+        // 重定向到请求来源页面（通常是通过Referer头部获取的）
         resp.sendRedirect(req.getHeader("Referer"));
     }
 
-    /**
-     * 删除商品项
-     * @param req
-     * @param resp
-     * @throws ServletException
-     * @throws IOException
-     */
+    // 处理删除购物车中商品项的请求
     protected void deleteItem(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+        // 从请求中获取要删除的商品项ID
         int id = WebUtils.parseInt(req.getParameter("id"), 0);
+        // 从会话中获取购物车对象
         Cart cart = (Cart) req.getSession().getAttribute("cart");
+        // 如果购物车对象存在，则删除指定ID的商品项
         if (cart != null) {
             cart.deleteItem(id);
-            resp.sendRedirect(req.getHeader("Referer"));
         }
+        // 重定向到请求来源页面
+        resp.sendRedirect(req.getHeader("Referer"));
     }
 
-    /**
-     * 清空商品项
-     * @param req
-     * @param resp
-     * @throws ServletException
-     * @throws IOException
-     */
+    // 处理清空购物车中所有商品项的请求
     protected void clearItem(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+        // 从会话中移除购物车对象，从而清空购物车
         req.getSession().removeAttribute("cart");
+        // 重定向到请求来源页面
         resp.sendRedirect(req.getHeader("Referer"));
     }
 
-    /**
-     * 修改商品数量
-     * @param req
-     * @param resp
-     * @throws ServletException
-     * @throws IOException
-     */
+    // 处理修改购物车中商品项数量的请求
     protected void updateCount(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+        // 从请求中获取要修改的商品项ID和新的数量
         int id = WebUtils.parseInt(req.getParameter("id"), 0);
         int count = WebUtils.parseInt(req.getParameter("count"), 1);
+        // 从会话中获取购物车对象
         Cart cart = (Cart) req.getSession().getAttribute("cart");
+        // 如果购物车对象存在，则修改指定ID的商品项数量
         if (cart != null) {
             cart.updateCount(id, count);
-            resp.sendRedirect(req.getHeader("Referer"));
         }
-
+        // 重定向到请求来源页面
+        resp.sendRedirect(req.getHeader("Referer"));
     }
-
 }

src/com/yj/web/UserServlet.java

@@ -21,71 +21,59 @@ import static com.google.code.kaptcha.Constants.KAPTCHA_SESSION_KEY;
  */
 public class UserServlet extends BaseServlet {
 
-    // 创建UserService的实例，使用UserServiceImpl实现类
     private UserService userService = new UserServiceImpl();
+
     protected void ajaxExistsusername(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
-        // 获取请求参数中的用户名
+        //获取请求参数
         String username = req.getParameter("username");
-
-        // 调用userService.existsUsername()方法，检查用户名是否存在
-        boolean existsUsername = userService.existsUsername(username);
-
-        // 将返回的结果封装为Map对象
+        //调用userService.existsUsername（）
+        boolean exitsUsername = userService.existsUsername(username);
+        //把返回的结果封装为map对象
         Map<String,Object> resultMap = new HashMap<>();
-        resultMap.put("existsUsername", existsUsername); // 存在性结果存入Map
+        resultMap.put("exitsUsername",exitsUsername);
 
-        // 使用Gson库将Map对象转换为JSON格式的字符串
         Gson gson = new Gson();
         String json = gson.toJson(resultMap);
-
-        // 将JSON字符串写入响应中，返回给客户端
         resp.getWriter().write(json);
+
+
     }
 
     /**
      * 处理登陆的功能
-     *
-     * @param req HttpServletRequest 请求对象
-     * @param resp HttpServletResponse 响应对象
+     * @param req
+     * @param resp
      * @throws ServletException
      * @throws IOException
      */
     protected void login(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
-        // 1、获取请求的参数（用户名和密码）
+        //1、获取请求的参数
         String username = req.getParameter("username");
         String password = req.getParameter("password");
-
-        // 2、调用userService.login()方法进行登录验证，创建User对象传递用户名和密码
         User loginUser = userService.login(new User(null, username, password, null,null));
-
-        // 3、检查登录结果
-        if (loginUser == null) {
-            // 登录失败，设置错误信息并转发到登录页面
-            req.setAttribute("msg", "用户名或密码错误!"); // 设置错误消息
-            // req.setAttribute("username", username); // 可选：保存用户名以便回显
-            req.getRequestDispatcher("/pages/user/login.jsp").forward(req, resp); // 转发请求
+        if(loginUser==null)
+        {
+            req.setAttribute("msg","用户名或密码错误!");
+            //req.setAttribute("username",username);
+            req.getRequestDispatcher("/pages/user/login.jsp").forward(req, resp);
 
         } else {
-            // 登录成功，将用户信息保存到session域中，以便后续使用
+            //保存用户登录的信息到session域中
             req.getSession().setAttribute("user",loginUser);
-            // 转发到登录成功页面
             req.getRequestDispatcher("/pages/user/login_success.jsp").forward(req, resp);
         }
     }
 
     /**
-     * 注销用户登录
-     *
-     * @param req HttpServletRequest 请求对象，用于获取请求信息
-     * @param resp HttpServletResponse 响应对象，用于发送响应
-     * @throws ServletException 如果请求处理出现错误
-     * @throws IOException 如果输入输出操作失败
+     * 注销
+     * @param req
+     * @param resp
+     * @throws ServletException
+     * @throws IOException
      */
     protected void logout(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
-        // 使当前会话失效，清除所有用户相关的session数据
-        req.getSession().invalidate();
 
-        // 重定向到应用的根路径，以返回主页或登录页面
+        req.getSession().invalidate();
         resp.sendRedirect(req.getContextPath());
     }
 
@@ -97,32 +85,30 @@ public class UserServlet extends BaseServlet {
      * @throws IOException
      */
     protected void regist(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
-        // 获取Session中存储的验证码
+
+        //获取Session验证码
         String token = (String) req.getSession().getAttribute(KAPTCHA_SESSION_KEY);
-        // 删除Session中的验证码，以防止重复使用
+        //删除Session中的验证码
         req.getSession().removeAttribute(KAPTCHA_SESSION_KEY);
-
-        // 1、获取请求的参数，包括用户名、密码、确认密码、邮箱和验证码
+        //1、获取请求的参数
         String username = req.getParameter("username");
         String password = req.getParameter("password");
         String repwd = req.getParameter("repwd");
         String email = req.getParameter("email");
         String code = req.getParameter("code");
 
-        // 将请求参数复制到User对象中
         User user = (User) WebUtils.copyParamToBean(req.getParameterMap(),new User());
-
-        // 2、检查验证码是否正确
+        //2、检查验证码是否正确 abcde
         if (token!=null&&token.equalsIgnoreCase(code)) {
-            // 3、检查用户名是否已被注册
+            //3、检查用户名是否可用
             if (userService.existsUsername(username)) {
-                // 如果用户名已存在，设置错误信息并转发回注册页面
+                //不可用 跳回注册页面
                 req.setAttribute("msg","用户名已存在！");
-                req.setAttribute("username", username); // 保留输入的用户名以便于用户填写
-                req.setAttribute("email", email); // 保留输入的邮箱
+                req.setAttribute("username",username);
+                req.setAttribute("email",email);
                 req.getRequestDispatcher("/pages/user/regist.jsp").forward(req, resp);
             } else {
-                // 如果用户名可用，调用服务层方法将用户信息保存到数据库，并转发到注册成功页面
+                //可用 调用service保存到数据库 跳到注册成功页面
                 userService.registUser(user);
                 req.getRequestDispatcher("/pages/user/regist_success.jsp").forward(req, resp);
             }
@@ -138,19 +124,10 @@ public class UserServlet extends BaseServlet {
     }
 
     protected void update(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
-        // 1、将请求参数复制到User对象中
         User user = (User) WebUtils.copyParamToBean(req.getParameterMap(),new User());
-
-        // 2、调用服务层方法更新用户信息
         userService.updateUser(user);
-
-        // 3、根据用户ID查询更新后的用户信息
         User user1 = userService.queryUserById(user.getId());
-
-        // 4、将更新后的用户信息存储到Session中，以便后续使用
         req.getSession().setAttribute("user",user1);
-
-        // 5、重定向到用户信息页面，展示更新后的信息
         resp.sendRedirect(req.getContextPath() + "/pages/user/userinfo.jsp");
     }
 

web/pages/cart/cart.jsp

@@ -1,28 +1,45 @@
 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
+<!-- 引入JSTL核心标签库，用于简化JSP页面的内容 -->
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
+<!-- 设置页面内容类型和字符编码 -->
 <!DOCTYPE html>
+<!-- 声明文档类型为HTML5 -->
 <html>
 <head>
 	<meta charset="UTF-8">
+	<!-- 设置页面的字符编码 -->
 	<title>购物车</title>
+	<!-- 设置页面标题 -->
 	<%@include file="/pages/common/header.jsp"%>
+	<!-- 引入头部文件，通常包含CSS和JavaScript的引用 -->
 	<script type="text/javascript">
 		$(function () {
+			// 当文档加载完成后执行的函数
 			$("a.deleteItem").click(function () {
+				// 为删除按钮绑定点击事件
 				return confirm("你确定要删除【"+$(this).parent().parent().find("td:first").text() +"】么？");
+				// 弹出确认框询问是否删除
 			});
 			$("#clearCart").click(function () {
+				// 为清空购物车按钮绑定点击事件
 				return confirm("你确定要清空购物车么？");
+				// 弹出确认框询问是否清空购物车
 			});
 
 			$(".updateCount").change(function () {
+				// 为数量输入框绑定值改变事件
 				var name = $(this).parent().parent().find("td:first").text();
+				// 获取商品名称
 				var count = this.value;
+				// 获取输入的新数量
 				var id = $(this).attr("bookId");
+				// 获取商品的ID
 				if(confirm("你确定要修改【"+name+"】数量为"+count+"么？")) {
-					location.href="http://localhost:8080/Book/cartServlet?action=updateCount&count="+count+"&id="+id;
+					// 弹出确认框询问是否修改数量
+					location.href="http://localhost:8080/Book/cartServlet?action=updateCount&count="+count+"&id="+id; // 跳转到更新数量的Servlet
 				} else {
 					this.value = this.defaultValue;
+					// 如果取消，则恢复默认数量
 				}
 			})
 		});
@@ -32,14 +49,20 @@
 <body>
 
 <div id="header">
+	<!-- 头部区域 -->
 	<img class="logo_img" alt="" src="static/img/logo.jpg" >
+	<!-- 引入logo图片 -->
 	<span class="wel_word">购物车</span>
+	<!-- 显示欢迎文字 -->
 	<%@include file="/pages/common/login_success_menu.jsp"%>
+	<!-- 引入登录成功后的菜单 -->
 </div>
 
 <div id="main">
+	<!-- 主内容区域 -->
 
 	<table>
+		<!-- 商品列表表格 -->
 		<tr>
 			<td>商品名称</td>
 			<td>数量</td>
@@ -49,33 +72,48 @@
 		</tr>
 
 		<c:if test="${empty sessionScope.cart.items}">
+			<!-- 判断购物车是否为空 -->
 			<tr>
 				<td colspan="5"><a href="index.jsp">亲，当前购物车为空,快去和小伙伴浏览书籍吧！	</a> </td>
+				<!-- 显示购物车为空的信息 -->
 			</tr>
 		</c:if>
 
 		<c:if test="${not empty sessionScope.cart.items}">
+			<!-- 判断购物车是否不为空 -->
 			<c:forEach items="${sessionScope.cart.items}" var="entry">
+				<!-- 遍历购物车中的商品 -->
 				<tr>
 					<td>${entry.value.name}</td>
+					<!-- 显示商品名称 -->
 					<td>
 						<input class="updateCount" style="width: 70px;" bookId="${entry.value.id}" type="text" value="${entry.value.count}">
+						<!-- 数量输入框 -->
 					</td>
 					<td>${entry.value.price}</td>
+					<!-- 显示商品单价 -->
 					<td>${entry.value.totalPrice}</td>
+					<!-- 显示商品总价 -->
 					<td><a class="deleteItem" href="cartServlet?action=deleteItem&id=${entry.value.id}">删除</a></td>
+					<!-- 删除按钮 -->
 				</tr>
 			</c:forEach>
 		</c:if>
 
 	</table>
 	<c:if test="${not empty sessionScope.cart.items}">
+		<!-- 判断购物车是否不为空 -->
 
 		<div class="cart_info">
+			<!-- 购物车信息区域 -->
 			<span class="cart_span">购物车中共有<span class="b_count">${sessionScope.cart.totalCount}</span>本书籍</span>
+			<!-- 显示购物车中商品的总数 -->
 			<span class="cart_span">总金额<span class="b_price">${sessionScope.cart.totalPrice}</span>元</span>
+			<!-- 显示购物车中商品的总金额 -->
 			<span class="cart_span"><a id="clearCart" href="cartServlet?action=clearItem">清空购物车</a></span>
+			<!-- 清空购物车按钮 -->
 			<span class="cart_span"><a href="client/orderServlet?action=isLogin">去结账</a></span>
+			<!-- 去结账按钮 -->
 		</div>
 
 	</c:if>
@@ -83,5 +121,6 @@
 </div>
 
 <%@include file="/pages/common/footer.jsp"%>
+<!-- 引入页脚文件 -->
 </body>
 </html>

web/pages/cart/checkout.jsp

@@ -1,32 +1,52 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
+<!-- 指定页面使用的内容类型为HTML，字符集为UTF-8，并声明使用Java作为脚本语言 -->
 <!DOCTYPE html>
+<!-- 声明文档类型为HTML5 -->
 <html>
+<!-- HTML文档的根元素 -->
 <head>
+	<!-- 头部元素，包含文档的元数据 -->
 	<meta charset="UTF-8">
+	<!-- 设置文档的字符编码为UTF-8 -->
 	<title>结算页面</title>
+	<!-- 设置网页的标题 -->
 	<%@include file="/pages/common/header.jsp"%>
+	<!-- 包含（插入）一个公共的头部JSP文件，通常包含CSS和JavaScript链接 -->
 	<style type="text/css">
+		<!-- 定义内嵌的CSS样式 -->
 	h1 {
+	<!-- 设置h1标签的样式 -->
 		text-align: center;
+	<!-- 文本居中对齐 -->
 		margin-top: 200px;
+	<!-- 上边距为200像素 -->
 	}
 	</style>
 </head>
 <body>
+<!-- 网页的主体部分 -->
 
 <div id="header">
+	<!-- 头部区域的容器 -->
 	<img class="logo_img" alt="" src="static/img/logo.jpg" >
+	<!-- 显示网站的logo图片 -->
 	<span class="wel_word">结算</span>
+	<!-- 显示欢迎词或当前页面标识 -->
 	<%@include file="/pages/common/login_success_menu.jsp"%>
+	<!-- 包含登录成功后的菜单JSP文件 -->
 </div>
 
 <div id="main">
+	<!-- 主要内容的容器 -->
 
 	<h1>你的订单已结算，订单号为${sessionScope.orderId}，店主很快就会发货啦！</h1>
+	<!-- 显示订单结算成功的消息，${sessionScope.orderId}用于从会话范围获取订单号 -->
 
 
 </div>
 
 <%@include file="/pages/common/footer.jsp"%>
+<!-- 包含页脚的JSP文件，通常包含版权信息和链接 -->
 </body>
 </html>
+<!-- HTML文档的结束 -->

web/pages/cart/pay.jsp

@@ -1,78 +1,98 @@
 <%--
+  这是一个JSP注释，不会被发送到客户端。它包含了文件的创建信息。
   Created by IntelliJ IDEA.
   User: jhu
   Date: 2020/10/5
   Time: 14:50
   To change this template use File | Settings | File Templates.
 --%>
+
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
+<!-- 指定页面内容类型、字符集和脚本语言 -->
+
 <html>
+<!-- HTML文档的根元素 -->
 <head>
+    <!-- 文档的头部 -->
     <title>结算页面</title>
+    <!-- 设置页面标题 -->
+
     <%@include file="/pages/common/header.jsp"%>
+    <!-- 包含公共头部文件，通常包含CSS、JavaScript链接等 -->
+
+    <!-- 下面的div元素应该放在body内，而不是head内，但这里可能是个错误或复制粘贴时的疏忽 -->
     <div id="header">
+        <!-- 头部容器 -->
         <img class="logo_img" alt="" src="static/img/logo.jpg" >
+        <!-- 网站logo图片 -->
         <span class="wel_word">结算</span>
+        <!-- 欢迎词或当前页面标识 -->
         <%@include file="/pages/common/login_success_menu.jsp"%>
+        <!-- 包含登录成功后的菜单 -->
     </div>
+
+    <!-- 注意：上面的div元素应该被移除到body标签内 -->
 </head>
 <body>
+<!-- 文档的主体 -->
 
 <div id="main">
+    <!-- 主要内容容器 -->
 
     <form action="client/orderServlet?action=createOrder" method="post">
+        <!-- 提交表单到orderServlet的createOrder动作 -->
         <input type="hidden">
+        <!-- 隐藏输入字段，此处未指定name属性，可能是个占位符 -->
         <table width="80%">
+            <!-- 表格，宽度为页面宽度的80% -->
             <tr>
                 <td bgcolor="#F7FEFF" colspan="4">
-                    支付金额：<INPUT id="money" TYPE="text" NAME="money" size="6" value="${sessionScope.cart.totalPrice}">元</td>
+                    <!-- 表格单元格，背景色为#F7FEFF，横跨4列 -->
+                    支付金额：<INPUT id="money" TYPE="text" NAME="money" size="6" value="${sessionScope.cart.totalPrice}">元</td> <!-- 显示支付金额，从会话中获取购物车总价 -->
             </tr>
             <tr>
-                <td><br />
-                </td>
+                <td><br /></td>
+                <!-- 空行 -->
             </tr>
             <tr>
                 <td colspan="4">请您选择在线支付银行</td>
+                <!-- 提示用户选择支付银行 -->
             </tr>
+            <!-- 下面的几行是银行选择项，每个单选按钮代表一个银行 -->
             <tr>
-                <td><INPUT TYPE="radio" NAME="pd_FrpId" value="CMBCHINA-NET">招商银行
-                </td>
+                <td><INPUT TYPE="radio" NAME="pd_FrpId" value="CMBCHINA-NET">招商银行</td>
                 <td><INPUT TYPE="radio" NAME="pd_FrpId" value="ICBC-NET">工商银行</td>
                 <td><INPUT TYPE="radio" NAME="pd_FrpId" value="ABC-NET">农业银行</td>
-                <td><INPUT TYPE="radio" NAME="pd_FrpId" value="CCB-NET">建设银行
-                </td>
+                <td><INPUT TYPE="radio" NAME="pd_FrpId" value="CCB-NET">建设银行</td>
             </tr>
             <tr>
                 <td><INPUT TYPE="radio" NAME="pd_FrpId" value="CMBC-NET">中国民生银行总行</td>
-                <td><INPUT TYPE="radio" NAME="pd_FrpId" value="CEB-NET">光大银行
-                </td>
+                <td><INPUT TYPE="radio" NAME="pd_FrpId" value="CEB-NET">光大银行</td>
                 <td><INPUT TYPE="radio" NAME="pd_FrpId" value="BOCO-NET">交通银行</td>
                 <td><INPUT TYPE="radio" NAME="pd_FrpId" value="SDB-NET">深圳发展银行</td>
             </tr>
             <tr>
                 <td><INPUT TYPE="radio" NAME="pd_FrpId" value="BCCB-NET">北京银行</td>
-                <td><INPUT TYPE="radio" NAME="pd_FrpId" value="CIB-NET">兴业银行
-                </td>
-                <td><INPUT TYPE="radio" NAME="pd_FrpId" value="SPDB-NET">上海浦东发展银行
-                </td>
+                <td><INPUT TYPE="radio" NAME="pd_FrpId" value="CIB-NET">兴业银行</td>
+                <td><INPUT TYPE="radio" NAME="pd_FrpId" value="SPDB-NET">上海浦东发展银行</td>
                 <td><INPUT TYPE="radio" NAME="pd_FrpId" value="ECITIC-NET">中信银行</td>
             </tr>
             <tr>
-                <td><br />
-                </td>
+                <td><br /></td>
+                <!-- 空行 -->
             </tr>
             <tr>
-                <td colspan="4"><INPUT TYPE="submit" value="确定支付">
-                </td>
+                <td colspan="4"><INPUT TYPE="submit" value="确定支付"></td>
+                <!-- 提交按钮 -->
             </tr>
         </table>
     </form>
 
-
 </div>
 
 <%@include file="/pages/common/footer.jsp"%>
+<!-- 包含公共页脚文件 -->
 
 </body>
-</body>
+<!-- 注意：这里有一个多余的</body>标签，应该被移除 -->
 </html>

web/pages/client/index.jsp

@@ -1,11 +1,6 @@
 <%--
-  Created by IntelliJ IDEA.
-  User: jhu
-  Date: 2020/10/5
-  Time: 15:44
-  To change this template use File | Settings | File Templates.
+  此文件的创建信息注释，表明是由 IntelliJ IDEA 创建，作者是 jhu，创建日期是 2020 年 10 月 5 日，时间是 15 时 44 分，并且提示修改此模板的相关设置路径。
 --%>
-
 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <!DOCTYPE html>
@@ -13,21 +8,25 @@
 <head>
     <meta charset="UTF-8">
     <title>书城首页</title>
+    <%-- 包含公共的头部页面（header.jsp），可能包含一些通用的样式、脚本或者页面头部结构相关的内容，方便复用。 --%>
     <%@include file="/pages/common/header.jsp"%>
     <script type="text/javascript">
+        // 当页面 DOM 加载完成后执行以下函数（这是 jQuery 的 $(function() {}) 语法的作用，相当于 DOMContentLoaded 事件的简写形式）
         $(function () {
-            //给加入购物车绑定单击事件
+            // 给所有 class 为 addToCart 的 button 元素绑定单击事件（通过 jQuery 的 click 方法实现事件绑定）
             $("button.addToCart").click(function () {
+                // 获取当前被点击按钮的 bookId 属性值（通过 jQuery 的 attr 方法获取元素的自定义属性值），这个 bookId 应该是对应书籍的唯一标识，用于后续操作。
                 var bookId = $(this).attr("bookId");
-                //发ajax请求添加商品到购物车
+                // 使用 jQuery 的 $.getJSON 方法发送一个 AJAX 请求，请求的 URL 是 "http://localhost:8080/Book/cartServlet"，同时传递了参数 "action=ajaxAddItem&id=" 加上获取到的 bookId，期望服务器返回 JSON 格式的数据。
+                // 并且在请求成功后的回调函数中处理返回的数据（这里回调函数接收一个 data 参数，就是服务器返回的 JSON 数据解析后的对象）。
                 $.getJSON("http://localhost:8080/Book/cartServlet", "action=ajaxAddItem&id=" + bookId, function (data) {
+                    // 更新购物车商品总数的显示内容，通过 jQuery 的 text 方法将指定元素（id 为 cartTotalCount 的元素）的文本内容更新为包含服务器返回的商品总数（data.totalCount）的提示信息。
                     $("#cartTotalCount").text("您的购物车中有" + data.totalCount + "件商品");
+                    // 更新购物车中最新添加的商品名称的显示内容，通过 jQuery 的 html 方法将指定元素（id 为 cartLastName 的元素）的 HTML 内容更新为包含服务器返回的最新添加商品名称（data.lastName）的提示信息，这里使用双引号包裹文本，所以里面的文本可以包含 HTML 标签（如果有的话）。
                     $("#cartLastName").html("您刚刚将【" + data.lastName + "】加入到了购物车中");
                 });
-
             });
         });
-
     </script>
 </head>
 <body>
@@ -35,35 +34,40 @@
     <img class="logo_img" alt="" src="static/img/logo1.jpg" >
     <span class="wel_word">Bookstore</span>
     <div>
+        <!-- 使用 JSTL 的 c:if 标签判断 sessionScope 中 user 对象是否为空，以此来区分用户是否登录，empty 关键字用于判断是否为空值（比如 null、空字符串等）。 -->
         <c:if test="${empty sessionScope.user}">
-
+            <!-- 如果 user 对象为空，说明用户未登录，显示登录和注册链接，以及热榜链接，方便用户进行相应操作。 -->
             <a href="pages/user/login.jsp">登录</a> |
             <a href="pages/user/regist.jsp">注册</a> &nbsp;&nbsp;
             <a href="client/bookServlet?action=pageOrder">热榜</a>
         </c:if>
-
         <c:if test="${not empty sessionScope.user}">
+            <!-- 如果 user 对象不为空，说明用户已登录，显示欢迎语以及包含用户用户名的个性化欢迎信息，同时提供我的订单、个人信息、注销等相关操作链接。 -->
             <span>欢迎<span class="um_span">${sessionScope.user.username}</span>光临书城</span>
             <a href="client/orderServlet?action=myOrders">我的订单</a>
             <a href="pages/user/userinfo.jsp">个人信息</a>
             <a href="userServlet?action=logout">注销</a>&nbsp;&nbsp;
         </c:if>
-
+        <!-- 始终显示购物车和后台管理的链接，方便用户进入购物车页面查看商品或者进入后台管理页面（可能需要相应权限）。 -->
         <a href="pages/cart/cart.jsp">购物车</a>
         <a href="pages/manager/manager.jsp">后台管理</a>
     </div>
 </div>
 <div id="main">
+    <!-- 图书搜索功能区域 -->
     <div class="book_check">
         <form action="client/bookServlet" method="get">
+            <!-- 隐藏域，用于传递特定的参数 action，其值为 pageByNameOrAuthor，用于告知服务器此次请求是按照书名或作者名进行页面查询相关操作。 -->
             <input type="hidden" name="action" value="pageByNameOrAuthor">
             图书搜索<input id="nameorauthor" type="text" placeholder="请输入书名或作者名" name="nameorauthor" value="${param.nameorauthor}">
             <input type="submit" value="查询" />
         </form>
     </div>
     <div id="book">
+        <!-- 价格区间筛选功能区域 -->
         <div class="book_cond">
             <form action="client/bookServlet" method="get">
+                <!-- 同样是隐藏域，传递 action 参数，值为 pageByPrice，用于告知服务器此次请求是按照价格区间进行页面查询相关操作。 -->
                 <input type="hidden" name="action" value="pageByPrice">
                 价格：<input id="min" type="text" name="min" value="${param.min}"> 元 -
                 <input id="max" type="text" name="max" value="${param.max}"> 元
@@ -71,6 +75,7 @@
             </form>
         </div>
         <div style="text-align: center">
+            <!-- 再次使用 JSTL 的 c:if 标签判断 sessionScope 中 cart 对象的 items 属性是否为空，以此来判断购物车是否为空。 -->
             <c:if test="${empty sessionScope.cart.items}">
                 <span id="cartTotalCount"></span>
                 <div>
@@ -78,13 +83,16 @@
                 </div>
             </c:if>
             <c:if test="${not empty sessionScope.cart.items}">
+                <!-- 如果购物车不为空，显示购物车商品总数，通过 EL 表达式（${sessionScope.cart.totalCount}）获取购物车中商品的总数并展示出来。 -->
                 <span id="cartTotalCount">您的购物车中有${sessionScope.cart.totalCount}件商品</span>
                 <div>
+                    <!-- 显示最新加入购物车的商品名称，同样通过 EL 表达式获取最新加入商品的名称并展示，这里还设置了颜色为红色，用于突出显示。 -->
                     您刚刚将<span style="color: red" id="cartLastName">${sessionScope.lastName}</span>加入到了购物车中
                 </div>
             </c:if>
         </div>
 
+        <!-- 使用 JSTL 的 c:forEach 标签遍历 requestScope 中 page 对象的 items 属性（这里的 items 应该是一个集合，可能是书籍信息的列表），每次遍历将当前元素赋值给变量 book，然后在循环体中进行相应的页面展示操作。 -->
         <c:forEach items="${requestScope.page.items}" var="book">
             <div class="b_list">
                 <div class="img_div">
@@ -112,6 +120,7 @@
                         <span class="sp2">${book.stock}</span>
                     </div>
                     <div class="book_add">
+                        <!-- 加入购物车按钮，设置了自定义属性 bookId，其值为当前遍历的书籍的 id，方便前面的 JavaScript 代码获取并发送对应的添加到购物车的请求。 -->
                         <button bookId=${book.id} class="addToCart">加入购物车</button>
                     </div>
                 </div>
@@ -120,10 +129,12 @@
 
     </div>
 
+    <!-- 包含公共的分页导航页面（page_nav.jsp），可能包含分页相关的链接、页码显示等功能，方便复用。 -->
     <%@include file="/pages/common/page_nav.jsp"%>
 
 </div>
 
+<!-- 包含公共的页脚页面（footer.jsp），可能包含版权信息、联系方式等页面底部相关的通用内容，方便复用。 -->
 <%@include file="/pages/common/footer.jsp"%>
 </body>
 </html>

web/pages/client/top.jsp

@@ -1,9 +1,5 @@
 <%--
-  Created by IntelliJ IDEA.
-  User: jhu
-  Date: 2020/10/19
-  Time: 22:56
-  To change this template use File | Settings | File Templates.
+  此部分为文件的创建相关注释，表明该文件是通过 IntelliJ IDEA 创建的，创建者是 jhu，创建时间为 2020 年 10 月 19 日 22 时 56 分，同时说明了修改该模板的相关设置操作的路径信息。
 --%>
 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
@@ -12,11 +8,10 @@
 <head>
     <meta charset="UTF-8">
     <title>图书热销榜单</title>
+    <%-- 包含公共的头部页面（header.jsp），这里面通常会放置页面通用的样式表引入、脚本引入或者一些页面头部布局相关的内容，以实现代码复用。 --%>
     <%@include file="/pages/common/header.jsp"%>
-
 </head>
 <body>
-
 <div id="header">
     <img class="logo_img" alt="" src="static/img/logo1.jpg" >
     <span class="wel_word">图书热销榜单</span>
@@ -35,6 +30,7 @@
             <td>作者</td>
             <td style="color: red">销量</td>
         </tr>
+        <%-- 在 JSP 页面中嵌入 Java 代码片段，定义一个整型变量 i 并初始化为 1，这个变量将用于记录图书的排名。 --%>
         <%int i=1;%>
         <c:forEach items="${requestScope.page.items}" var="book">
             <tr>
@@ -44,10 +40,9 @@
                 <td>${book.author}</td>
                 <td style="color: red">${book.sales}</td>
             </tr>
+            <%-- 使用 JSTL 的 c:forEach 标签来遍历 requestScope 中 page 对象的 items 属性（通常这里是一个包含图书信息的集合），每次循环将集合中的一个元素赋值给变量 book，然后在表格行（tr）中展示对应图书的各项信息，包括通过表达式输出的排名（通过 Java 代码片段中的 i 变量来展示，并且每次循环自增 1）以及图书的名称、价格、作者和销量（通过 EL 表达式 ${book.name} 等获取相应属性值进行展示）。 --%>
         </c:forEach>
 
-
-
         <tr>
             <td></td>
             <td></td>

web/pages/common/header.jsp

@@ -7,17 +7,27 @@
 --%>
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <%
-    String basePath = request.getScheme()
-            +"://"
-            +request.getServerName()
-    +":"
-    +request.getServerPort()
-    +request.getContextPath()
-    +"/";
-    pageContext.setAttribute("bastPath",basePath);
+    // 获取当前请求的协议（如http或https）
+    String scheme = request.getScheme();
+    // 获取服务器的主机名或IP地址
+    String serverName = request.getServerName();
+    // 获取服务器的端口号
+    int serverPort = request.getServerPort();
+    // 获取当前应用的上下文路径
+    String contextPath = request.getContextPath();
 
+    // 拼接basePath，用于构建项目的根路径
+    String basePath = scheme + "://" + serverName + ":" + serverPort + contextPath + "/";
+
+    // 将basePath存储到pageContext中，方便在页面中使用
+    pageContext.setAttribute("basePath", basePath);
 %>
+
 <!-- 写base标签，永远固定相对路径跳转的结果 -->
-<base href=<%=basePath%>>
+<base href="<%=basePath%>">
+
+<!-- 引入外部的CSS样式文件 -->
 <link type="text/css" rel="stylesheet" href="static/css/style.css">
+
+<!-- 引入外部的jQuery库 -->
 <script type="text/javascript" src="static/script/jquery-1.7.2.js"></script>

web/pages/common/page_nav.jsp

@@ -8,70 +8,81 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 
 <div id="page_nav">
+    <!-- 首页链接 -->
     <a href="${requestScope.page.url}&pageNo=1">首页</a>
+
+    <!-- 上一页链接 -->
     <c:if test="${requestScope.page.pageNo > 1}">
         <a href="${requestScope.page.url}&pageNo=${requestScope.page.pageNo - 1}">上一页</a>
     </c:if>
 
+    <!-- 分页逻辑 -->
     <c:choose>
         <%-- 当总页码小于等于5的情况 --%>
         <c:when test="${requestScope.page.pageTotal <= 5}">
-
             <c:set var="begin" value="1"></c:set>
             <c:set var="end" value="${requestScope.page.pageTotal}"></c:set>
-
         </c:when>
         <c:otherwise>
             <%-- 当总页码大于5的情况 --%>
             <c:choose>
                 <%-- 当前页码是前三 --%>
                 <c:when test="${requestScope.page.pageNo <= 3}">
-
                     <c:set var="begin" value="1"></c:set>
                     <c:set var="end" value="5"></c:set>
-
                 </c:when>
                 <%-- 当前页码是后三 --%>
                 <c:when test="${requestScope.page.pageNo >= requestScope.page.pageTotal - 2}">
-
                     <c:set var="begin" value="${requestScope.page.pageTotal - 4}"></c:set>
                     <c:set var="end" value="${requestScope.page.pageTotal}"></c:set>
-
                 </c:when>
                 <c:otherwise>
-
+                    <%-- 当前页码在中间 --%>
                     <c:set var="begin" value="${requestScope.page.pageNo - 2}"></c:set>
                     <c:set var="end" value="${requestScope.page.pageNo + 2}"></c:set>
-
                 </c:otherwise>
             </c:choose>
         </c:otherwise>
     </c:choose>
 
-
-
-
+    <!-- 显示页码 -->
     <c:forEach begin="${begin}" end="${end}" var="i">
         <c:if test="${i == requestScope.page.pageNo}">【${i}】</c:if>
-        <c:if test="${ i != requestScope.page.pageNo }"><a href="${requestScope.page.url}&pageNo=${i}">${i}</a></c:if>
+        <c:if test="${i != requestScope.page.pageNo}">
+            <a href="${requestScope.page.url}&pageNo=${i}">${i}</a>
+        </c:if>
     </c:forEach>
 
+    <!-- 下一页链接 -->
     <c:if test="${requestScope.page.pageNo < requestScope.page.pageTotal}">
         <a href="${requestScope.page.url}&pageNo=${requestScope.page.pageNo + 1}">下一页</a>
     </c:if>
 
+    <!-- 末页链接 -->
     <a href="${requestScope.page.url}&pageNo=${requestScope.page.pageTotal}">末页</a>
+
+    <!-- 显示总页数和总记录数 -->
     共${requestScope.page.pageTotal}页，${requestScope.page.pageTotalCount}条记录
+
+    <!-- 跳转页码输入框 -->
     到第<input value="${param.pageNo}" name="pn" id="pn_input"/>页
     <input id="searchPageBtn" type="button" value="确定">
 
+    <!-- 跳转页码的JavaScript脚本 -->
     <script type="text/javascript">
         $(function () {
+            // 点击“确定”按钮时触发跳转
             $("#searchPageBtn").click(function () {
-                var pageNo = $("#pn_input").val()
-                var pageTotal = ${requestScope.page.pageTotal}
-                if(pageNo<1) pageNo=1
-                if(pageNo>pageTotal) pageNo=pageTotal
+                // 获取用户输入的页码
+                var pageNo = $("#pn_input").val();
+                // 获取总页数
+                var pageTotal = ${requestScope.page.pageTotal};
+
+                // 校验页码范围
+                if (pageNo < 1) pageNo = 1;
+                if (pageNo > pageTotal) pageNo = pageTotal;
+
+                // 跳转到指定页码
                 location.href = "${requestScope.basePath}${requestScope.page.url}&pageNo=" + pageNo;
             });
         });

web/pages/error/error404.jsp

@@ -1,37 +1,35 @@
 <%--
-  Created by IntelliJ IDEA.
-  User: jhu
-  Date: 2020/10/5
-  Time: 22:17
-  To change this template use File | Settings | File Templates.
+  此部分为文件的创建相关注释，说明该文件是由 IntelliJ IDEA 创建的，创建用户是 jhu，创建时间为2020年10月5日22时17分，同时告知若要修改此模板可通过文件设置里的文件模板相关功能来操作。
 --%>
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <html>
 <head>
     <title>404</title>
+    <%-- 引入公共的头部页面（header.jsp），一般这个头部页面中会包含诸如页面通用的样式文件引入、脚本文件引入或者一些页面头部通用布局结构等内容，方便在多个页面间复用代码。 --%>
     <%@include file="/pages/common/header.jsp"%>
 </head>
+<body>
 <div id="header">
     <img class="logo_img" alt="" src="static/img/logo.gif" >
     <span class="wel_word">404error</span>
-
 </div>
 <div id="main">
     <table>
         <tr>
             <td style="width: 300px">亲，您访问的页面不存在或已被删除!</td>
+            <%-- 在表格的第一行的单元格中，显示提示信息，告知用户所访问的页面出现了不存在或者已被删除的情况。 --%>
         </tr>
         <tr>
             <td>
                 <a href="index.jsp" style="size: 300px;color: red">返回首页</a>
+                <%-- 在表格的第二行单元格中，设置一个超链接，链接到“index.jsp”页面，并且设置了链接文字的样式，包括字号（原代码中“size”属性写法有误，正确的是“font-size”，这里是按原代码注释）和颜色，引导用户点击返回首页。 --%>
             </td>
         </tr>
     </table>
 </div>
 
-
 <!-- 这是页脚的引入 -->
 <%@ include file="/pages/common/footer.jsp" %>
-
+<%-- 通过此指令引入公共的页脚页面（footer.jsp），该页脚页面通常包含页面底部的一些通用信息，比如版权声明、联系方式等内容，同样是为了实现代码复用。 --%>
 </body>
 </html>

web/pages/error/error500.jsp

@@ -1,37 +1,36 @@
 <%--
-  Created by IntelliJ IDEA.
-  User: jhu
-  Date: 2020/10/5
-  Time: 22:17
-  To change this template use File | Settings | File Templates.
+  这部分是文件创建相关的注释信息，表明该文件是由IntelliJ IDEA创建的，创建者是“jhu”，创建时间是2020年10月5日22时17分，同时提示若要修改这个模板文件，可以通过“File | Settings | File Templates”这个路径去操作。
 --%>
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <html>
 <head>
     <title>500</title>
+    <%-- 通过JSP的指令引入公共的头部页面（header.jsp），通常在这个公共头部页面里会包含页面通用的样式表链接、JavaScript脚本引入或者一些通用的页面头部布局相关的代码等，目的是实现代码复用，让多个页面能共享这些公共部分的设置。 --%>
     <%@include file="/pages/common/header.jsp"%>
 </head>
+<body>
 <div id="header">
     <img class="logo_img" alt="" src="static/img/logo.gif" >
     <span class="wel_word">500error</span>
-
+    <%-- 在“header”这个div区域中，展示了一个logo图片（虽然图片的替代文本为空，可适当补充使其更友好）以及显示“500error”字样，用于提示当前页面出现的是500相关错误情况。 --%>
 </div>
 <div id="main">
     <table>
         <tr>
             <td style="width: 300px">HTTP状态 500 - 内部服务器错误</td>
+            <%-- 在表格的第一行单元格里，明确给出提示信息，告知用户当前出现了HTTP状态码为500的内部服务器错误，让用户知晓页面无法正常显示的原因所在。 --%>
         </tr>
         <tr>
             <td>
                 <a href="index.jsp" style="size: 300px;color: red">返回首页</a>
+                <%-- 在表格的第二行单元格里，创建了一个超链接，链接指向“index.jsp”页面，同时设置了这个链接文字的样式，原代码中“size”属性写法不符合规范（正确的是“font-size”用于设置字号），这里按原代码注释，颜色设置为红色，引导用户点击该链接返回首页去尝试其他操作。 --%>
             </td>
         </tr>
     </table>
 </div>
 
-
 <!-- 这是页脚的引入 -->
 <%@ include file="/pages/common/footer.jsp" %>
-
+<%-- 此处使用JSP的指令引入公共的页脚页面（footer.jsp），一般在页脚页面里会放置诸如版权信息、联系方式、网站相关声明等页面底部通用的内容，同样是为了复用代码，保持网站各页面底部信息的一致性。 --%>
 </body>
 </html>

web/pages/error/errorManager.jsp

@@ -1,38 +1,38 @@
 <%--
-  Created by IntelliJ IDEA.
-  User: jhu
-  Date: 2020/10/5
-  Time: 10:45
-  To change this template use File | Settings | File Templates.
+  这部分是关于该文件创建的相关注释内容，说明了此文件是通过IntelliJ IDEA创建的，创建者是“jhu”，创建时间为2020年10月5日10时45分，并且告知若要对这个模板文件进行修改，可以在文件设置里找到文件模板相关功能来操作。
 --%>
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <html>
 <head>
     <title>404</title>
+    <%-- 通过JSP的指令引入公共的头部页面（header.jsp），通常这个公共头部页面包含了页面通用的一些元素，比如样式表的链接、脚本文件的引入，或者是页面头部通用的布局结构代码等，这样做是为了实现代码复用，多个页面可以共用这些设置，减少重复编写代码的工作量。 --%>
     <%@include file="/pages/common/header.jsp"%>
 </head>
+<body>
 <div id="header">
     <img class="logo_img" alt="" src="static/img/logo.gif" >
     <span class="wel_word">错误提示</span>
-
+    <%-- 在“header”这个div区域中，展示了一个图片（其替代文本为空，最好能补充合适的替代文本方便屏幕阅读器等识别），同时显示“错误提示”字样，用于给用户一个直观的页面提示信息的开头部分，告知用户当前页面是用于提示出现错误情况的。 --%>
 </div>
 <div id="main">
     <table>
         <tr>
             <td style="width: 300px">亲，你没有管理员权限哦！</td>
+            <%-- 在表格的第一行单元格中，明确给出提示信息，告知用户当前操作因为没有管理员权限而无法进行，让用户清楚知晓出现此页面的原因。 --%>
         </tr>
         <tr>
             <td>
                 <a href="pages/user/login.jsp" style="size: 300px;color: red">管理员登录</a>
+                <%-- 创建一个超链接，链接指向“pages/user/login.jsp”页面，也就是引导用户去进行管理员登录操作，同时设置了链接文字的样式，不过原代码中“size”属性的写法不符合规范（正确的应该是“font-size”用于设置字号），这里按原代码注释，颜色设置为红色，使其更醒目，方便用户看到并点击操作。 --%>
                 <a href="index.jsp" style="size: 300px;color: red">返回首页</a>
+                <%-- 再创建一个超链接，指向“index.jsp”页面，用于引导用户返回首页，同样设置了字号（原代码中写法有误）和颜色样式，给用户提供另一种操作选择，方便用户离开当前提示页面。 --%>
             </td>
         </tr>
     </table>
 </div>
 
-
 <!-- 这是页脚的引入 -->
 <%@ include file="/pages/common/footer.jsp" %>
-
+<%-- 使用JSP指令引入公共的页脚页面（footer.jsp），一般来说，页脚页面里会放置像版权信息、网站的联系方式、相关声明等页面底部通用的内容，通过这种引入方式实现代码复用，保证整个网站各个页面的页脚部分信息呈现的一致性。 --%>
 </body>
 </html>

web/pages/manager/book_edit.jsp

@@ -29,9 +29,15 @@
 
 <div id="main">
 	<form action="manager/bookServlet" method="post">
+		<!-- 隐藏域，用于传递当前页码 -->
 		<input type="hidden" name="pageNo" value="${param.pageNo}">
+
+		<!-- 隐藏域，用于判断是添加还是更新操作 -->
 		<input type="hidden" name="action" value="${empty param.id ? "add":"update"}"/>
+
+		<!-- 隐藏域，用于传递图书ID -->
 		<input type="hidden" name="id" value="${requestScope.book.id}"/>
+
 		<table>
 			<tr>
 				<td>名称</td>
@@ -42,17 +48,26 @@
 				<td colspan="2">操作</td>
 			</tr>
 			<tr>
+				<!-- 图书名称输入框 -->
 				<td><input name="name" type="text" value="${requestScope.book.name}"/></td>
+
+				<!-- 图书价格输入框 -->
 				<td><input name="price" type="text" value="${requestScope.book.price}"/></td>
+
+				<!-- 图书作者输入框 -->
 				<td><input name="author" type="text" value="${requestScope.book.author}"/></td>
+
+				<!-- 图书销量输入框 -->
 				<td><input name="sales" type="text" value="${requestScope.book.sales}"/></td>
+
+				<!-- 图书库存输入框 -->
 				<td><input name="stock" type="text" value="${requestScope.book.stock}"/></td>
+
+				<!-- 提交按钮 -->
 				<td><input type="submit" value="提交"/></td>
 			</tr>
 		</table>
 	</form>
-			
-	
 </div>
 
 <%@include file="/pages/common/footer.jsp"%>

web/pages/user/login.jsp

@@ -4,90 +4,94 @@
 <head>
 <meta charset="UTF-8">
 <title>登录页面</title>
-	<%@include file="/pages/common/header.jsp"%> <!-- 引入公共头部文件 -->
+<%@include file="/pages/common/header.jsp"%>
 <script type="text/javascript">
-		// 页面加载完成后执行
+	// 页面加载完成之后
 	$(function(){
 		
-			// 给注册按钮添加点击事件
+		// 给注册按钮添加事件
 		$("#sub_btn").click(function(){
 			
-				// 获取用户名输入框的值
+			// 获取用户名
 			var usernameValue = $("#username").val();
-				// 定义正则表达式，验证用户名是否合法 (由字母、数字、下划线组成，长度5到15位)
+			// 验证用户名是否合法,规则如下：必须由字母，数字，下划线组成，并且长度为5到15位。
 			var usernameReg = /^\w{5,15}$/;
-				// 验证用户名信息
+			// 验证用户信息
 			if (!usernameReg.test(usernameValue)) {
-					// 如果不合法，提示用户
+				// 提示用户
 				$("span.errorMsg").text("用户名不合法！");
-					return false; // 阻止表单提交
+				return false;
 			}
 			
-				// 获取密码输入框的值
+			// 获取密码
 			var passwordValue = $("#password").val();
-				// 定义正则表达式，验证密码是否合法（同样的规则）
+			// 验证密码是否合法,规则如下：必须由字母，数字，下划线组成，并且长度为5到15位。
 			var passwordReg = /^\w{5,15}$/;
-				// 验证密码信息
+			// 验证用户信息
 			if (!passwordReg.test(passwordValue)) {
-					// 如果不合法，提示用户
+				// 提示用户
 				$("span.errorMsg").text("密码不合法！");
-					return false; // 阻止表单提交
+				return false;
 			}
 			
-				// 如果验证通过，允许表单提交
+			// 阻止表单提交
 			return true;
 		});
 		
 	});
+
 </script>
 
 </head>
 <body>
 		<div id="login_header">
-	<img class="logo_img" alt="" src="static/img/logo.jpg"> <!-- 显示网站的logo -->
+			<img class="logo_img" alt="" src="static/img/logo.jpg" >
 		</div>
 		
 			<div class="login_banner">
 			
 				<div id="l_content">
-		<span class="login_word">欢迎登录</span> <!-- 登录页面的欢迎词 -->
+					<span class="login_word">欢迎登录</span>
 				</div>
 				
 				<div id="content">
 					<div class="login_form">
 						<div class="login_box">
 							<div class="tit">
-					<h1>书城会员</h1> <!-- 登录框标题 -->
-					<a href="pages/user/regist.jsp">立即注册</a> <!-- 注册链接，点击后跳转到注册页面 -->
+								<h1>书城会员</h1>
+								<a href="pages/user/regist.jsp">立即注册</a>
 							</div>
 							<div class="msg_cont">
 								<b></b>
 								<span class="errorMsg">
 									<%--<%=request.getAttribute("msg")==null?"请输入用户名和密码":request.getAttribute("msg")%>--%>
-									${empty requestScope.msg ? "请输入用户名和密码":requestScope.msg} <!-- 显示错误信息，若有则显示 -->
+									${empty requestScope.msg ? "请输入用户名和密码":requestScope.msg}
 								</span>
 							</div>
 							<div class="form">
-					<form action="userServlet" method="post"> <!-- 表单提交至userServlet处理登录 -->
-						<input type="hidden" name="action" value="login"> <!-- 隐藏字段，指明操作为登录 -->
+								<form action="userServlet" method="post">
+									<input type="hidden" name="action" value="login">
 									<label>用户名称：</label>
 									<input class="itxt" type="text" placeholder="请输入用户名" autocomplete="off" 
 										tabindex="1" name="username" id="username"
-							   value="${requestScope.username}" /> <!-- 用户名输入框 -->
+										 value="${requestScope.username}"
+									/>
 									<br />
 									<br />
 									<label>用户密码：</label>
 									<input class="itxt" type="password" placeholder="请输入密码" autocomplete="off" 
-							   tabindex="1" name="password" id="password" /> <!-- 密码输入框 -->
+									 	tabindex="1" name="password" id="password"
+									/>
 									<br />
 									<br />
-						<input type="submit" value="登录" id="sub_btn" /> <!-- 登录按钮 -->
+									<input type="submit" value="登录" id="sub_btn" />
 								</form>
 							</div>
+							
 						</div>
 					</div>
 				</div>
 			</div>
-<%@include file="/pages/common/footer.jsp"%> <!-- 引入公共底部文件 -->
+		<%@include file="/pages/common/footer.jsp"%>
 </body>
 </html>

web/pages/user/login_success.jsp

@@ -2,30 +2,32 @@
 <!DOCTYPE html>
 <html>
 <head>
-	<meta charset="UTF-8"> <!-- 设置字符编码为UTF-8 -->
-	<title>登录成功页面</title> <!-- 页面标题 -->
-	<%@include file="/pages/common/header.jsp"%> <!-- 引入公共头部文件 -->
+<meta charset="UTF-8">
+<title>登录成功页面</title>
+<%@include file="/pages/common/header.jsp"%>
 <style type="text/css">
 	h1 {
-			text-align: center; <!-- 使h1内容居中对齐 -->
-			margin-top: 200px; <!-- 顶部外边距设置为200像素 -->
+		text-align: center;
+		margin-top: 200px;
 	}
 	
 	h1 a {
-			color:red; <!-- 超链接颜色设置为红色 -->
+		color:red;
 	}
 </style>
 </head>
 <body>
 		<div id="header">
-	<img class="logo_img" alt="" src="static/img/logo.jpg" > <!-- 显示网站的logo -->
-	<%@include file="/pages/common/login_success_menu.jsp"%> <!-- 引入登录成功后的菜单 -->
+				<img class="logo_img" alt="" src="static/img/logo.jpg" >
+			<%@include file="/pages/common/login_success_menu.jsp"%>
 		</div>
 		
 		<div id="main">
-	<h1>欢迎回来 <a href="index.jsp">转到主页</a></h1> <!-- 欢迎信息及返回主页的链接 -->
+		
+			<h1>欢迎回来 <a href="index.jsp">转到主页</a></h1>
+	
 		</div>
 
-<%@include file="/pages/common/footer.jsp"%> <!-- 引入公共底部文件 -->
+		<%@include file="/pages/common/footer.jsp"%>
 </body>
 </html>

web/pages/user/regist.jsp

@@ -8,84 +8,79 @@
 	<script type="text/javascript">
 // 页面加载完成之后
 $(function(){
-	// 当用户名输入框失去焦点时触发事件
 	$("#username").blur(function () {
 		//1、获取用户名
 		var username = this.value;
-		// 发送一个GET请求，检查用户名是否已经存在
 		$.getJSON("http://localhost:8080/bookstore1/userServlet","action=ajaxExistsusername&username="+username,function (data) {
 			if(data.exitsUsername) {
-				// 如果用户名已存在，显示错误信息
 				$("span.errorMsg").text("用户名已存在！");
 			} else {
-				// 如果用户名可用，显示可用信息
 				$("span.errorMsg").text("用户名可用！");
 			}
+
 		});
+
 	});
 
-	// 点击验证码图片时更换其源，以更新验证码
 	$("#code_img").click(function () {
 		this.src = "${basePath}kaptcha.jpg?d=" + new Date();
 	});
 
-	// 给注册按钮添加点击事件
+	// 给注册按钮添加事件
 	$("#sub_btn").click(function(){
-		// 获取用户名的值
+
+		// 获取用户名
 		var usernameValue = $("#username").val();
-		// 验证用户名是否合法，规则如下：必须由字母、数字和下划线组成，并且长度为5到15位。
+		// 验证用户名是否合法,规则如下：必须由字母，数字，下划线组成，并且长度为5到15位。
 		var usernameReg = /^\w{5,15}$/;
 		// 验证用户信息
 		if (!usernameReg.test(usernameValue)) {
-			// 如果验证不通过，提示用户
+			// 提示用户
 			$("span.errorMsg").text("用户名不合法！");
-			return false; // 阻止表单提交
+			return false;
 		}
 
-		// 获取密码输入框的值
+		// 获取密码
 		var passwordValue = $("#password").val();
-        // 验证密码是否合法，规则如下：必须由字母、数字和下划线组成，并且长度为5到15位。
+		// 验证密码是否合法,规则如下：必须由字母，数字，下划线组成，并且长度为5到15位。
 		var passwordReg = /^\w{5,15}$/;
 		// 验证用户信息
 		if (!passwordReg.test(passwordValue)) {
-			// 如果验证不通过，提示用户
+			// 提示用户
 			$("span.errorMsg").text("密码不合法！");
-			return false; // 阻止表单提交
+			return false;
 		}
 
-        // 获取确认密码输入框的值
+		// 获取确认密码
 		var repwdValue = $("#repwd").val();
-        // 验证确认密码与密码是否一致
+		// 验证确认密码和密码一致
 		if (passwordValue != repwdValue) {
-			// 如果不一致，提示用户
+			// 提示用户
 			$("span.errorMsg").text("确认密码和密码不一致！");
-			return false; // 阻止表单提交
+			return false;
 		}
 
-        // 获取电子邮件输入框的值
+		// 获取用户名
 		var emailValue = $("#email").val();
-        // 验证邮件输入是否合法，采用正则表达式
+		// 验证邮件输入是否合法。
 		var emailReg = /^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$/;
 
-        // 检查电子邮件格式是否符合要求
 		if (!emailReg.test(emailValue)) {
-			// 如果验证不通过，提示用户
+			// 提示用户
 			$("span.errorMsg").text("邮件输入不合法！");
-			return false; // 阻止表单提交
+			return false;
 		}
 
-        // 获取验证码输入框的值
+
+		// 获取验证码信息
 		var codeValue = $("#code").val();
-        // 验证验证码输入是否为空
+		// 验证验证码不为空！
 		if (codeValue == "") {
-			// 如果为空，提示用户
 			$("span.errorMsg").text("验证码不能为空！")
-			return false; // 阻止表单提交
+			return false;
 		}
 
-        // 如果所有验证通过，返回true，允许表单提交
 		return true;
-
 	});
 
 });
@@ -93,113 +88,67 @@ $(function(){
 </script>
 
 <style type="text/css">
-		/* 定义 .login_form 类的样式 */
 	.login_form{
-			/* 设置登录表单的高度为420像素 */
 		height:420px;
-
-			/* 设置登录表单与顶部的外边距为25像素 */
 		margin-top: 25px;
 	}
-	</style>
 	
+</style>
 </head>
 <body>
 		<div id="login_header">
-	<!-- 显示网站或应用程序的logo，使用img标签加载图像 -->
 			<img class="logo_img" alt="" src="static/img/logo.jpg" >
 		</div>
 		
 			<div class="login_banner">
-	<!-- 登录横幅区域 -->
 			
 				<div id="l_content">
-		<!-- 登录内容部分 -->
 					<span class="login_word">欢迎注册</span>
-		<!-- 提示用户进行注册 -->
 				</div>
 				
 				<div id="content">
-		<!-- 内容区域 -->
-
 					<div class="login_form">
-			<!-- 登录表单容器 -->
-
 						<div class="login_box">
-				<!-- 登录框 -->
-
 							<div class="tit">
-					<!-- 标题部分 -->
-
 								<h1>注册会员</h1>
-					<!-- 主标题，显示“注册会员” -->
-
 								<span class="errorMsg">
-                        <!-- 错误信息显示区域 -->
 									<%--<%=request.getAttribute("msg")==null? "" : request.getAttribute("msg")%>--%>
-						<!-- 注释掉的JSP代码，用于获取请求中的消息属性 -->
 									${requestScope.msg}
-						<!-- 使用EL表达式获取请求作用域中的消息并显示 -->
 								</span>
 							</div>
 							<div class="form">
-					<!-- 表单容器 -->
 								<form action="userServlet" method="post">
-						<!-- 表单，提交到 userServlet，使用 POST 方法 -->
-
 									<input type="hidden" name="action" value="regist">
-						<!-- 隐藏字段，指定表单操作为注册 -->
-
 									<label>用户名称：</label>
-						<!-- 用户名称标签 -->
 									<input class="itxt" type="text" placeholder="请输入用户名" autocomplete="off" tabindex="1" name="username" id="username"
 										value="${requestScope.username}"/>
-						<!-- 输入框，供用户输入用户名 -->
-						<!-- 使用 EL 表达式填充之前的用户名（如果有的话） -->
-
 									<br />
 									<br />
 									<label>用户密码：</label>
-						<!-- 用户密码标签 -->
 									<input class="itxt" type="password" placeholder="请输入密码" autocomplete="off" tabindex="1" name="password" id="password"
 										   value="${requestScope.password}"/>
-						<!-- 输入框，供用户输入密码 -->
-						<!-- 使用 EL 表达式填充之前的密码（如果有的话） -->
-
 									<br />
 									<br />
 									<label>确认密码：</label>
-						<!-- 确认密码标签 -->
 									<input class="itxt" type="password" placeholder="确认密码" autocomplete="off" tabindex="1" name="repwd" id="repwd"
 										   value="${requestScope.repwd}"/>
-						<!-- 输入框，供用户确认密码 -->
-						<!-- 使用 EL 表达式填充之前的确认密码（如果有的话） -->
-
 									<br />
 									<br />
 									<label>电子邮件：</label>
-						<!-- 电子邮件标签 -->
 									<input class="itxt" type="text" placeholder="请输入邮箱地址" autocomplete="off" tabindex="1" name="email" id="email"
 										   value="${requestScope.email}"/>
-						<!-- 输入框，供用户输入电子邮件地址 -->
-						<!-- 使用 EL 表达式填充之前的邮箱（如果有的话） -->
-
 									<br />
 									<br />
 									<label>验证码：</label>
-						<!-- 验证码标签 -->
 									<input class="itxt" type="text" name="code" style="width: 80px;" id="code"/>
-						<!-- 输入框，供用户输入验证码 -->
-
 									<img id="code_img" alt="" src="kaptcha.jpg" style="float: right; margin-right: 40px;width: 110px;height: 30px">
-						<!-- 显示验证码图像 -->
-
 									<br />
 									<br />
 									<input type="submit" value="注册" id="sub_btn" />
-						<!-- 提交按钮，用户点击后提交表单进行注册 -->
+									
 								</form>
 							</div>
+							
 						</div>
 					</div>
 				</div>

web/pages/user/regist_success.jsp

@@ -1,40 +1,8 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
-<!DOCTYPE html>
-<html>
-<head><%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <!DOCTYPE html>
 <html>
 <head>
 <meta charset="UTF-8">
-		<title>注册成功页面</title>
-		<%@include file="/pages/common/header.jsp"%> <!-- 引入公共头部文件 -->
-		<style type="text/css">
-			h1 {
-				text-align: center; /* 设置标题文本居中对齐 */
-				margin-top: 200px; /* 顶部外边距设置为200像素 */
-			}
-
-			h1 a {
-				color:red; /* 设置链接的颜色为红色 */
-			}
-		</style>
-	</head>
-	<body>
-	<div id="header">
-		<img class="logo_img" alt="" src="static/img/logo.jpg"> <!-- 显示网站Logo -->
-		<span class="wel_word"></span> <!-- 欢迎词，未赋值 -->
-		<%@include file="/pages/common/login_success_menu.jsp"%> <!-- 引入登录成功后的菜单 -->
-	</div>
-
-	<div id="main">
-		<h1>注册成功! <a href="index.jsp">转到主页</a></h1> <!-- 显示注册成功提示，并提供返回主页的链接 -->
-	</div>
-
-	<%@include file="/pages/common/footer.jsp"%> <!-- 引入公共底部文件 -->
-	</body>
-	</html>
-
-	<meta charset="UTF-8">
 <title>注册成功页面</title>
 	<%@include file="/pages/common/header.jsp"%>
 <style type="text/css">

web/pages/user/userinfo.jsp

@@ -9,57 +9,57 @@
 <!DOCTYPE html>
 <html>
 <head>
-    <meta charset="UTF-8"> <!-- 设置文档字符集为UTF-8 -->
-    <title>我的个人信息</title> <!-- 设置网页标题 -->
-    <%@include file="/pages/common/header.jsp"%> <!-- 引入公共头部文件 -->
+    <meta charset="UTF-8">
+    <title>我的个人信息</title>
+    <%@include file="/pages/common/header.jsp"%>
     <style type="text/css">
         h1 {
-            text-align: center; /* 设置h1标题文本居中对齐 */
-            margin-top: 200px; /* 设置h1元素的顶部外边距为200像素 */
+            text-align: center;
+            margin-top: 200px;
         }
 
         h1 a {
-            color:red; /* 设置h1中的链接颜色为红色 */
+            color:red;
         }
 
         input {
-            text-align: center; /* 设置输入框中的文本居中对齐 */
+            text-align: center;
         }
     </style>
 </head>
-
 <body>
-<div id="header"> <!-- 页头部分 -->
-    <img class="logo_img" alt="" src="static/img/logo1.jpg"> <!-- 网站logo图像 -->
-    <span class="wel_word">个人信息</span> <!-- 显示欢迎词，标识为"个人信息" -->
-    <%@include file="/pages/common/login_success_menu.jsp"%> <!-- 引入登录成功后显示的菜单 -->
+<div id="header">
+    <img class="logo_img" alt="" src="static/img/logo1.jpg" >
+    <span class="wel_word">个人信息</span>
+    <%@include file="/pages/common/login_success_menu.jsp"%>
 </div>
 
-<div id="main"> <!-- 主内容区域 -->
-    <form action="userServlet" method="post"> <!-- 表单提交到userServlet，使用POST方法 -->
-        <input type="hidden" name="action" value="update"/> <!-- 隐藏字段，用于指示操作类型为"更新" -->
-        <table> <!-- 使用表格来组织输入字段 -->
+<div id="main">
+    <form action="userServlet" method="post">
+        <input type="hidden" name="action" value="update"/>
+        <table>
             <tr>
-                <td>序号</td> <!-- 表头：序号 -->
-                <td>用户名</td> <!-- 表头：用户名 -->
-                <td>密码</td> <!-- 表头：密码 -->
-                <td>电子邮箱</td> <!-- 表头：电子邮箱 -->
-                <td>收货地址</td> <!-- 表头：收货地址 -->
-                <td colspan="2">修改</td> <!-- 表头：修改，跨两列 -->
+                <td>序号</td>
+                <td>用户名</td>
+                <td>密码</td>
+                <td>电子邮箱</td>
+                <td>收货地址</td>
+                <td colspan="2">修改</td>
             </tr>
             <tr>
-                <td><input name="id" type="text" value="${sessionScope.user.id}"/></td> <!-- 用户ID输入框，默认值来自会话 -->
-                <td><input name="username" type="text" value="${sessionScope.user.username}"/></td> <!-- 用户名输入框，默认值来自会话 -->
-                <td><input name="password" type="text" value="${sessionScope.user.password}"/></td> <!-- 密码输入框，默认值来自会话 -->
-                <td><input name="email" type="text" value="${sessionScope.user.email}"/></td> <!-- 电子邮箱输入框，默认值来自会话 -->
-                <td><input name="address" type="text" value="${sessionScope.user.address}"/></td> <!-- 收货地址输入框，默认值来自会话 -->
-                <td><input type="submit" value="提交"/></td> <!-- 提交按钮，点击后提交表单 -->
+                <td><input name="id" type="text" value="${sessionScope.user.id}"/></td>
+                <td><input name="username" type="text" value="${sessionScope.user.username}"/></td>
+                <td><input name="password" type="text" value="${sessionScope.user.password}"/></td>
+                <td><input name="email" type="text" value="${sessionScope.user.email}"/></td>
+                <td><input name="address" type="text" value="${sessionScope.user.address}"/></td>
+                <td><input type="submit" value="提交"/></td>
             </tr>
         </table>
     </form>
+
+
 </div>
 
-<%@include file="/pages/common/footer.jsp"%> <!-- 引入公共页脚文件 -->
+<%@include file="/pages/common/footer.jsp"%>
 </body>
 </html>
-