Java web实训项目：西蒙购物网

末蓝、 2024-03-16 16:19 34阅读 0赞

#### 文章目录 ####

*  一、创建数据库和表
 *   *  1、创建数据库
     *  2、创建用户表
     *  3、创建类别表
     *  4、创建商品表
     *  5、创建订单表
 *  二、创建Simonshop项目
 *   *  1、创建web项目
     *  2、修改Artifacts名称：simonshop
     *  3、重新部署项目
     *  4、编辑首页
     *  5、启动应用，查看效果
 *  三、创建实体类
 *   *  1、用户实体类
     *  2、创建类别实体类
     *  3、创建商品实体类
 *  三、创建数据库工具类
 *   *  1、添加数据库驱动程序包
     *  2、创建数据库连接管理类
     *  3、测试数据库连接是否成功
     *  4、数据库连接的常见错误
     *   *  (1)、数据库驱动程序名称写错误
         *  (2)、数据库没找到
     *  5、创建数据访问接口
     *   *  (1)、创建用户数据访问接口
         *  (2)、类别数据访问接口CaregoryDao
         *  (3)、创建商品数据访问接口ProductDao
         *  (4)、订单数据访问接口OrderDao
     *  6、数据访问接口实现类DaoImpl
     *   *  (1）、创建用户数据访问接口实现类
         *   *  ① 编写插入用户方法
             *  ②边界删除用户方法
             *  ③编写更新用户方法
             *  ④编写按标识符查询用户方法
             *  ⑤编写按用户名查询用户的方法
             *  ⑥编写查询全部用户方法
             *  ⑦编写登录方法
         *  （2）、对用户数据访问接口实现类做单元测试
         *   *  ①编写测试登录方法
             *  ②编写按标识符查询用户方法
             *  ③编写按用户名查询用户方法
             *  ④编写查询全部用户方法
             *  ⑤编写测试插入用户方法
             *  ⑥编写测试更新用户方法
             *  ⑦编写测试删除用户方法
         *  （3）、创建类别数据访问接口实现类
         *   *  ①编写插入类别方法
             *  ②编写按标识符插入类别方法
             *  ③编写更新类别方法
             *  ④编写按标识符查询方法
             *  ⑤编写查询全部方法
         *  （4）、 对类别数据访问接口对象做单元测试
         *   *  ①编写测试按标识符查询类别方法
             *  ②编写测试查询全部类别方法
             *  ③编写 测试查询全部类别
             *  ④编写测试更新类别方法
             *  ⑤编写测试删除类别方法
         *  5、编写商品数据访问接口实现类
         *   *  ①编写插入商品方法
             *  ②编写按标识符删除商品方法
             *  ③编写按标识符更新商品方法
             *  ④编写按标识符查询商品方法
             *  ⑤编写按类别标识符查询商品方法
             *  ⑥编写查询全部商品方法
         *  6、编写测试商品数据访问接口实现类
         *   *  ①编写按标识符查询商品方法
             *  ②编写测试按类别标识符查询商品方法
             *  ③编写测试查询全部商品方法
             *  ④编写测试插入商品方法
             *  ⑤编写测试更新商品
             *  ⑥编写测试删除商品方法
         *  7、创建订单数据访问接口类OrderDaoImpl

## 一、创建数据库和表 ##

### 1、创建数据库 ###

*  数据库 - `simonshop`  
    ![在这里插入图片描述][0bc060e013b94f15b63510b6259f0adf.png]

### 2、创建用户表 ###

创建用户表结构 - `t_user`  
![在这里插入图片描述][a20477dbaca54455949c2389bdface2a.png]

CREATE TABLE `t_user` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `username` varchar(20) NOT NULL,
      `password` varchar(20) DEFAULT NULL,
      `telephone` varchar(11) DEFAULT NULL,
      `register_time` timestamp NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP,
      `popedom` int(11) DEFAULT NULL COMMENT '0：管理员；1：普通用户',
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

*  在用户表里插入记录  
    ![在这里插入图片描述][6c570fddd20249948f986b5c95bc2c94.png]

INSERT INTO `t_user` VALUES ('1', 'admin', '12345', '15734345678', '2021-12-02 08:40:35', '0');
    INSERT INTO `t_user` VALUES ('2', '郑晓红', '11111', '13956567889', '2022-12-20 09:51:43', '1');
    INSERT INTO `t_user` VALUES ('3', '温志军', '22222', '13956678907', '2022-12-20 09:52:36', '1');
    INSERT INTO `t_user` VALUES ('4', '涂文艳', '33333', '15890905678', '2022-12-05 09:52:56', '1');

### 3、创建类别表 ###

*  创建类别表结构 - `t_category`

![在这里插入图片描述][9c79480e1a964c59a48ad9e24a029ecf.png]

CREATE TABLE `t_category` (
      `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '商品类别标识符',
      `name` varchar(100) NOT NULL COMMENT '商品类别名称',
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

*  在类别表里插入记录  
    ![在这里插入图片描述][51b230729d534460b3c5e1b6f83433b9.png]

INSERT INTO `t_category` VALUES ('1', '家用电器');
    INSERT INTO `t_category` VALUES ('2', '床上用品');
    INSERT INTO `t_category` VALUES ('3', '文具用品');
    INSERT INTO `t_category` VALUES ('4', '休闲食品');

### 4、创建商品表 ###

*  创建商品表结构 - `t_product`  
    ![在这里插入图片描述][2689877c5f4f410e88cbbda64cb21cbb.png]

CREATE TABLE `t_product` (
      `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '商品标识符',
      `name` varchar(200) NOT NULL COMMENT '商品名称',
      `price` double DEFAULT NULL COMMENT '商品单价',
      `add_time` timestamp NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP,
      `category_id` int(11) DEFAULT NULL COMMENT '商品类别标识符',
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=16 DEFAULT CHARSET=utf8;

*  在商品表里插入记录  
    ![在这里插入图片描述][8723a00ae1a04c5a8825180a93af0bbf.png]

INSERT INTO `t_product` VALUES ('1', '容声电冰箱', '2000', '2016-12-20 09:54:41', '1');
    INSERT INTO `t_product` VALUES ('2', '松下电视', '5000', '2016-12-20 09:54:35', '1');
    INSERT INTO `t_product` VALUES ('3', '红岩墨水', '3', '2016-12-20 09:56:05', '3');
    INSERT INTO `t_product` VALUES ('4', '海尔洗衣机', '1000', '2016-11-30 08:58:09', '1');
    INSERT INTO `t_product` VALUES ('5', '新宇电饭煲', '1200', '2016-12-20 09:55:11', '1');
    INSERT INTO `t_product` VALUES ('6', '英雄微波炉', '600', '2016-12-20 09:55:39', '1');
    INSERT INTO `t_product` VALUES ('7', '红双喜席梦思', '700', '2016-11-28 08:59:38', '2');
    INSERT INTO `t_product` VALUES ('8', '旺仔牛奶糖', '24.4', '2016-12-20 10:00:11', '4');
    INSERT INTO `t_product` VALUES ('9', '西蒙枕头', '100', '2016-12-20 09:56:57', '2');
    INSERT INTO `t_product` VALUES ('10', '甜甜毛毯', '400', '2016-12-20 09:57:26', '2');
    INSERT INTO `t_product` VALUES ('11', '永久钢笔', '50', '2016-12-20 09:57:30', '3');
    INSERT INTO `t_product` VALUES ('12', '硬面抄笔记本', '5', '2016-12-20 09:57:53', '3');
    INSERT INTO `t_product` VALUES ('13', '晨光橡皮擦', '0.5', '2016-11-30 09:02:40', '3');
    INSERT INTO `t_product` VALUES ('14', '美的空调', '3000', '2016-11-03 09:03:02', '1');
    INSERT INTO `t_product` VALUES ('15', '迷你深海鱼肠', '14.4', '2016-12-02 10:01:14', '4');

### 5、创建订单表 ###

创建订单表结构 - `t_order`  
![在这里插入图片描述][08bbc689efff4f9b8efd276cdfec21ed.png]

CREATE TABLE `t_order` (
      `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '订单标识符',
      `username` varchar(20) DEFAULT NULL COMMENT '用户名',
      `telephone` varchar(11) DEFAULT NULL COMMENT '电话号码',
      `total_price` double DEFAULT NULL COMMENT '总金额',
      `delivery_address` varchar(50) DEFAULT NULL COMMENT '送货地址',
      `order_time` timestamp NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT '下单时间',
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

*  在订单表里插入记录  
    ![在这里插入图片描述][b1a5c0977f0e4652b9c6ca71328bf64d.png]

INSERT INTO `t_order` VALUES ('1', '郑晓红', '13956567889', '2000', '泸职院信息工程系', '2016-12-25 17:12:36');
    INSERT INTO `t_order` VALUES ('2', '温志军', '13956678907', '1000', '泸职院机械工程系', '2016-12-02 17:12:17');

## 二、创建Simonshop项目 ##

### 1、创建web项目 ###

![在这里插入图片描述][e224163af8e04a7491f6a14b37c1b64e.png]

*  创建项目名称与保存位置  
    ![在这里插入图片描述][d5be1434e6604e9280e23c617327e2d6.png]
 *  单机【finsh】  
    ![在这里插入图片描述][6eba4d2d0bb74b29bf3febda16235771.png]

### 2、修改Artifacts名称：simonshop ###

*  将Artifact名称改为`simonshiop`  
    ![在这里插入图片描述][57c348250b2c4a18b7cbccae941f0fb5.png]

### 3、重新部署项目 ###

![在这里插入图片描述][dcabef1b10b3435382d4438b34059366.png]

*  切换到【server】选项卡  
    ![在这里插入图片描述][d1fe9dea58b0401fb4b80f3fc7509cad.png]

### 4、编辑首页 ###

*  首页 - `index.jsp`

<%@ page import="java.util.Date" %><%--
      Created by IntelliJ IDEA.
      User: HW
      Date: 2023/5/29
      Time: 15:38
      To change this template use File | Settings | File Templates.
    --%>
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
      <head>
        <title>首页</title>
      </head>
      <body>
      <h1 style="color: blue; text-align:center">Java Web实训项目：西蒙购物网</h1>
      <h3 style="text-align: center"><%= new Date()%></h3>
      <p style="text-align: center"><a href="login.jsp">跳转到登录界面</a> </p>
      </body>
    </html>

### 5、启动应用，查看效果 ###

![在这里插入图片描述][5e06258987d9437d931f55ac1b625bac.png]

## 三、创建实体类 ##

*  创建四个实体类：`User`、`Category`、`Product`与`Order`

### 1、用户实体类 ###

*  创建`ner.xyx.shop.bean`包，在包里创建用户实体类 - `User`  
    ![在这里插入图片描述][636114668f0944c4b74525b0aa148bf9.png]

package net.xyx.shop.bean;
    
    import java.util.Date;
    
    public class User {
        private int id;//用户标识符
        private String username;//用户名
        private String password;//密码
        private String telephone;//电话
        private Date registerTime;//注册时间
        private int popedom;//权限（0：管理员；1：普通用户）
    
        public int getId() {
            return id;
        }
    
        public void setId(int 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 getTelephone() {
            return telephone;
        }
    
        public void setTelephone(String telephone) {
            this.telephone = telephone;
        }
    
        public Date getRegisterTime() {
            return registerTime;
        }
    
        public void setRegisterTime(Date registerTime) {
            this.registerTime = registerTime;
        }
    
        public int getPopedom() {
            return popedom;
        }
    
        public void setPopedom(int popedom) {
            this.popedom = popedom;
        }
    
        @Override
        public String toString(){
            return "User{" +
                    "id=" + id +
                    ",password=" + password +
                    ",telephone= " + telephone +
                    ",registerTime=" + registerTime +
                    ",popedom=" + popedom + '\'' +
                    '}';
        }
    }

### 2、创建类别实体类 ###

*  创建`ner.xyx.shop.bean`包，在包里创建订单实体类 - `Category`  
    ![在这里插入图片描述][349c3bff41dc4091976b7d61a7fa41c6.png]

package net.xyx.shop.bean;
    
    public class Category {
        private int id;
        private String name;
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
        @Override
        public  String toString(){
            return "Category{" +
                    "id=" + id +
                    ",name=" + name + '\'' +
                    '}';
        }
    }

### 3、创建商品实体类 ###

*  创建`ner.xyx.shop.bean`包，在包里创建订单实体类 - `Category`  
    ![在这里插入图片描述][706981c24db14b87a3d9a9ff0cfffb60.png]

package net.xyx.shop.bean;
    
    import java.util.Date;
    
    public class Product {
        private int id;
        private String name;
        private double price;
        private Date addTime;
        private int categotyId;
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public double getPrice() {
            return price;
        }
    
        public void setPrice(double price) {
            this.price = price;
        }
    
        public Date getAddTime() {
            return addTime;
        }
    
        public void setAddTime(Date addTime) {
            this.addTime = addTime;
        }
    
        public int getCategotyId() {
            return categotyId;
        }
    
        public void setCategotyId(int categotyId) {
            this.categotyId = categotyId;
        }
    
        @Override
        public String toString() {
            return "Product{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", price=" + price +
                    ", addTime=" + addTime +
                    ", categotyId=" + categotyId +
                    '}';
        }
    }
    
    ``
    ## 4、创建订单实体类
    - 创建`ner.xyx.shop.bean`包，在包里创建订单实体类 - `Order`
    ![在这里插入图片描述](https://img-blog.csdnimg.cn/b878bc1b6af54665b8004a45058e69d7.png)
    - 代码如下
    ```xml
    package net.xyx.shop.bean;
    
    import java.util.Date;
    
    public class Order {
        private int id;
        private String username;
        private String telehpone;
        private double totalPrice;
        private String deliveryAddress;
        private Date orderTime;
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public String getTelehpone() {
            return telehpone;
        }
    
        public void setTelehpone(String telehpone) {
            this.telehpone = telehpone;
        }
    
        public double getTotalPrice() {
            return totalPrice;
        }
    
        public void setTotalPrice(double totalPrice) {
            this.totalPrice = totalPrice;
        }
    
        public String getDeliveryAddress() {
            return deliveryAddress;
        }
    
        public void setDeliveryAddress(String deliveryAddress) {
            this.deliveryAddress = deliveryAddress;
        }
    
        public Date getOrderTime() {
            return orderTime;
        }
    
        public void setOrderTime(Date orderTime) {
            this.orderTime = orderTime;
        }
    
        @Override
        public String toString() {
            return "Order{" +
                    "id=" + id +
                    ", username='" + username + '\'' +
                    ", telehpone='" + telehpone + '\'' +
                    ", totalPrice=" + totalPrice +
                    ", deliveryAddress='" + deliveryAddress + '\'' +
                    ", orderTime=" + orderTime +
                    '}';
        }
    }

## 三、创建数据库工具类 ##

### 1、添加数据库驱动程序包 ###

*  在\\WEB-INF里创建`lib`子目录，添加MySQL驱动程序的  
    ![在这里插入图片描述][16fe22e9b1da48b9853d8961c07b9260.png]
 *  将数据库驱动程序包作为库添加到项目

### 2、创建数据库连接管理类 ###

*  创建`net.xyx.shop.dbutil`包，在里面创建`ConnectionManager`类  
    ![在这里插入图片描述][569077a3f8934d14970dbe1875a1db7f.png]
 *  原代码

### 3、测试数据库连接是否成功 ###

### 4、数据库连接的常见错误 ###

#### (1)、数据库驱动程序名称写错误 ####

#### (2)、数据库没找到 ####

### 5、创建数据访问接口 ###

#### (1)、创建用户数据访问接口 ####

*  在`net.xyx.shop`根包里创建`dao`子包，在子包里创建`UserDao`接口

![在这里插入图片描述][21e82de6bdd9442181b96f18314f2228.png]

package net.xyx.shop.dao;
    
    import net.xyx.shop.bean.User;
    
    import java.util.List;
    
    public interface UserDao {
        int insert(User user);//插入用户
        int deleteById(int id);//按标识符删除用户
        int update(User user);//更新用户
        User findById(int id);//按标识符查询用户
        List<User> findByUsername(String username);//按用户名查找用户
        List<User> findAll();//查询全部用户
        User login (String username,String password);//用户登录
    }

#### (2)、类别数据访问接口CaregoryDao ####

*  在`net.xyx.shop`根包里创建`dao`子包，在子包里创建`CaregoryDao`接口

![在这里插入图片描述][e6fc7a01d42a4a04b3c228492d3daf28.png]

package net.xyx.shop.dao;
    
    import net.xyx.shop.bean.Category;
    
    import java.util.List;
    
    /**
     * 功能：类别数据访问接口
     * 作者：XYX
     */
    
    public interface CategoryDao {
        int insert(Category category);//插入类别
        int deleteById(int id);//按标识符删除类别
        int update(Category category);//更新类别
        Category findById(int id);//按标识符查询类别
        List<Category>findAll();//查询全部类别
    }

#### (3)、创建商品数据访问接口ProductDao ####

*  在`net.xyx.shop`根包里创建`dao`子包，在子包里创建`ProductDao`接口  
    ![在这里插入图片描述][8dde3b417c8b47a2af8962ff6c760398.png]

package net.xyx.shop.dao;
    
    import net.xyx.shop.bean.Product;
    
    import java.util.List;
    
    public interface ProductDao {
        int insert(Product product);//插入商品
        int deleteById(int id);//按标识符删除商品
        int update(Product product);//更新商品
        Product findById(int id);//按标识符查询商品
        List<Product> findByCategoryId (int categoryId);//按类别标识符查询商品
        List<Product> findAll();//查询全部商品
    }

#### (4)、订单数据访问接口OrderDao ####

*  在`net.xyx.shop`根包里创建`dao`子包，在子包里创建`OrderDao`接口  
    ![在这里插入图片描述][d715b38ef41d447782a812ff09d17c96.png]

package net.xyx.shop.dao;
    
    import net.xyx.shop.bean.Order;
    
    import java.util.List;
    
    public interface OrderDao {
        int insert(Order order);//插入订单
        int deleteById(int id);//按标识符删除订单
        int update(Order order);//更新订单
        Order findById(int id);//按标识符查询订单
        Order findLast();//查询左后一个订单
        List<Order>findAll();//查询全部订单
    }

### 6、数据访问接口实现类DaoImpl ###

#### (1）、创建用户数据访问接口实现类 ####

*  在`net.xyx.shop.dao`包里创建`impl`子包，在子包里创建`UserDaoImpl`类  
    ![在这里插入图片描述][9ae4da638b11461fb66500c85686afda.png]
 *  实现`UserDao`接口

![在这里插入图片描述][4373bf3c8d7442bf9ecbc087e9c704e4.png]

##### ① 编写插入用户方法 #####

@Override//插入用户方法
        public int insert(User user) {
        
            //定义插入记录数
            int count = 0;
    
            //获取数据库连接
            Connection conn = ConnectionManager.getConnection();
            try {
        
                //定义SQL字符串
                String strSQL = "INSERT INTO t_user (username,password, telephone, register_time, popedom) VALUES(?,?,?,?,?)";
                //创建预备语句对象
                PreparedStatement pstmt = conn.prepareStatement(strSQL);
                //设置占位符的值
                pstmt.setString(1,user.getUsername());
                pstmt.setString(2,user.getPassword());
                pstmt.setString(3,user.getTelephone());
                pstmt.setTimestamp(4,new Timestamp(user.getRegisterTime().getTime()));
                pstmt.setInt(5,user.getPopedom());
                //执行更新操作，插入新记录
                count = pstmt.executeUpdate();
                //关闭预备语句对象
                pstmt.close();
            } catch (SQLException throwables) {
        
                throwables.printStackTrace();
            } finally {
        
                ConnectionManager.closeConnection(conn);//关闭数据库连接
            }
    
            //返回插入记录
            return count;
        }

##### ②边界删除用户方法 #####

@Override//按标识删除用户
        public int deleteById(int id) {
        
            //定义删除记录数
            int count = 0;
    
            //获取数据库连接
            Connection conn = ConnectionManager.getConnection();
            try {
        
                //定义SQL字符串
                String strSQL = "DELETE FROM t_user WHERE id=?";
                //创建预备语句对象
                PreparedStatement pstmt = conn.prepareStatement(strSQL);
                //设置占位符的值
                pstmt.setInt(1,id);
                //执行更新操作，插入新记录
                count = pstmt.executeUpdate();
                //关闭预备语句对象
                pstmt.close();
            }catch (SQLException e) {
        
               System.err.println(e.getMessage());
            } finally {
        
                ConnectionManager.closeConnection(conn);//关闭数据库连接
            }
    
            //返回删除记录数
            return count;
        }

##### ③编写更新用户方法 #####

@Override//按标识符更新用户
        public int update(User user) {
        
            //定义更新用户记录数
            int count = 0;
    
            //获取数据库连接
            Connection conn = ConnectionManager.getConnection();
            try {
        
                //定义SQL字符串
                String strSQL = "UPDATE t_user SET username=?,password=?, telephone=?, register_time = ?, popedom=?," +
                        "WHERE id = ?";
                //创建预备语句对象
                PreparedStatement pstmt = conn.prepareStatement(strSQL);
                //设置占位符的值
                pstmt.setString(1,user.getUsername());
                pstmt.setString(2,user.getPassword());
                pstmt.setString(3,user.getTelephone());
                pstmt.setTimestamp(4,new Timestamp(user.getRegisterTime().getTime()));
                pstmt.setInt(5,user.getPopedom());
                pstmt.setInt(6,user.getId());
                //执行更新操作，更新记录
                count = pstmt.executeUpdate();
                //关闭预备语句对象
                pstmt.close();
            }catch (SQLException e) {
        
               System.err.println(e.getMessage());
            } finally {
        
                ConnectionManager.closeConnection(conn);//关闭数据库连接
            }
    
    
            //返回更新记录数
            return count;
        }

##### ④编写按标识符查询用户方法 #####

@Override//按标识符查询用户方法
        public User findById(int id) {
        
            // 定义查询用户
            User user = null;
    
            //获取数据库连接
            Connection conn = ConnectionManager.getConnection();
            try {
        
                //定义SQL字符串
                String strSQL = "SELECT * FROM t_user WHERE id=?";
                //创建预备语句对象
                PreparedStatement pstmt = conn.prepareStatement(strSQL);
                //设置占位符的值
                pstmt.setInt(1,id);
                //执行查询操作，返回结果集
                ResultSet rs = pstmt.executeQuery();
                //判断结果集是否为空
                if (rs.next()){
        
                    //创建用户对象
                    user = new User();
                    //设置用户对象属性
                    user.setId(rs.getInt("id"));
                    user.setUsername(rs.getString("username"));
                    user.setPassword(rs.getString("password"));
                    user.setTelephone(rs.getString("telephone"));
                    user.setRegisterTime(rs.getTimestamp("register_time"));
                    user.setPopedom(rs.getInt("popedom"));
                }
                //关闭预备语句对象
                pstmt.close();
            }catch (SQLException e) {
        
               System.err.println(e.getMessage());
            } finally {
        
                ConnectionManager.closeConnection(conn);//关闭数据库连接
            }
    
            //返回查询用户
            return user;
        }

##### ⑤编写按用户名查询用户的方法 #####

@Override//按用户名查询用户
        public List<User> findByUsername(String username) {
        
            //定义用户列表
            List<User> users = new ArrayList<>();
    
            //获取数据库连接
            Connection conn = ConnectionManager.getConnection();
            try {
        
                //定义SQL字符串
                String strSQL = "SELECT * FROM t_user WHERE username=?";
                //创建预备语句对象
                PreparedStatement pstmt = conn.prepareStatement(strSQL);
                //设置占位符的值
                pstmt.setString(1,username);
                //执行查询操作，返回结果集
                ResultSet rs = pstmt.executeQuery();
                //判断结果集是否为空
                while (rs.next()){
        
                    //创建用户对象
                     User user = new User();
                    //设置用户对象属性
                    user.setId(rs.getInt("id"));
                    user.setUsername(rs.getString("username"));
                    user.setPassword(rs.getString("password"));
                    user.setTelephone(rs.getString("telephone"));
                    user.setRegisterTime(rs.getTimestamp("register_time"));
                    user.setPopedom(rs.getInt("popedom"));
                    //将用户对象添加到用户列表
                    users.add(user);
                }
                //关闭预备语句对象
                pstmt.close();
            }catch (SQLException e) {
        
               System.err.println(e.getMessage());
            } finally {
        
                ConnectionManager.closeConnection(conn);//关闭数据库连接
            }
            
            //返回用户列表
            return users;
        }

##### ⑥编写查询全部用户方法 #####

@Override//查询所有用户
        public List<User> findAll() {
        
    
            //定义用户列表
            List<User> users = new ArrayList<>();
    
            //获取数据库连接
            Connection conn = ConnectionManager.getConnection();
            try {
        
                //定义SQL字符串
                String strSQL = "SELECT * FROM t_user";
                //创建语句对象
                Statement stmt = conn.createStatement();
                //执行查询操作，返回结果集
                ResultSet rs = stmt.executeQuery(strSQL);
                //判断结果集是否为空
                while (rs.next()){
        
                    //创建用户对象
                    User user = new User();
                    //设置用户对象属性
                    user.setId(rs.getInt("id"));
                    user.setUsername(rs.getString("username"));
                    user.setPassword(rs.getString("password"));
                    user.setTelephone(rs.getString("telephone"));
                    user.setRegisterTime(rs.getTimestamp("register_time"));
                    user.setPopedom(rs.getInt("popedom"));
                    //将用户对象添加到用户列表
                    users.add(user);
                }
                //关闭语句对象
                stmt.close();
            } catch (SQLException e) {
        
                System.err.println(e.getMessage());
            } finally {
        
                ConnectionManager.closeConnection(conn);//关闭数据库连接
            }
    
            //返回用户列表
            return users;
        }

##### ⑦编写登录方法 #####

@Override//登录方法
        public User login(String username, String password) {
        
            //定义查询用户
            User user = null;
    
            //获取数据库连接
            Connection conn = ConnectionManager.getConnection();
            try {
        
                //定义SQL字符串
                String strSQL = "SELECT * FROM t_user WHERE username = ? and password = ?";
                //创建预备语句对象
                PreparedStatement pstmt = conn.prepareStatement(strSQL);
                //设置占位符的值
                pstmt.setString(1,username);
                pstmt.setString(1,password);
                //执行查询操作，返回结果集
                ResultSet rs = pstmt.executeQuery();
                //判断结果集是否为空
                if (rs.next()){
        
                    //创建用户对象
                    user = new User();
                    //设置用户对象属性
                    user.setId(rs.getInt("id"));
                    user.setUsername(rs.getString("username"));
                    user.setPassword(rs.getString("password"));
                    user.setTelephone(rs.getString("telephone"));
                    user.setRegisterTime(rs.getTimestamp("register_time"));
                    user.setPopedom(rs.getInt("popedom"));
                }
                //关闭预备语句对象
                pstmt.close();
            } catch (SQLException throwables) {
        
                throwables.printStackTrace();
            } finally {
        
                ConnectionManager.closeConnection(conn);//关闭数据库连接
            }
    
            //返回查询用户
            return user;
        }

![在这里插入图片描述][ff964e447c4c4325910fa7538027b03e.png]

#### （2）、对用户数据访问接口实现类做单元测试 ####

![在这里插入图片描述][24122155994647f99fa5775d9cd8d0aa.png]

*  于是项目里有了一个绿色的测试文件夹 - `test`  
    ![在这里插入图片描述][61eae6e6acfa442591258b91212fea44.png]
 *  在`test`文件夹里创建`net.xyx.shop.dao.impl`包，在里面创建`TestUserDaoImpl`  
    ![在这里插入图片描述][31810d89f6d844dc9a93dbdf21303f95.png]

##### ①编写测试登录方法 #####

*  给测试方法添加@Test注解，会报错  
    ![在这里插入图片描述][d4ba32a8ec184287942e574684676aa9.png]
 *  添加单元测试JUnit项目，将光标移到@test注解上，按Alter+Enter键

![在这里插入图片描述][d1568c831fc1447989a3bc184b164469.png]

*  单击【Add ‘JUnit4’ to classpath】  
    ![在这里插入图片描述][41ee0803917a421bbf6f4a2994ed2d69.png]
 *  单击【OK】按钮  
    ![在这里插入图片描述][1a37f79882454dac84262b26277ca3a3.png]
 *  运行testLogin()方法，查看效果

package net.xyx.shop.dao.impl;
    
    import net.xyx.shop.bean.User;
    import net.xyx.shop.dao.UserDao;
    import org.junit.Test;
    
    /**
     * 测试用户数据访问接口实现类
     */
    public class TestUserDaoImpl {
        
        @Test
        public void testLogin(){
        
            String username = "admin";
            String password = "12345";
    
            //创建用户数据访问接口对象
            UserDao userDao = new UserDaoImpl();//用父接口变量指向子类对象
            //调用用户数据访问接口对象的登录方法
            User user = userDao.login(username,password);
            //判断用户是否登录成功
            if (user != null) {
        //成功
                System.out.println("恭喜，" + username + "，登录成功~");
            }else{
        //失败
                System.out.println("遗憾，" + username + "，登录失败~");
            }
        }
    }

##### ②编写按标识符查询用户方法 #####

@Test //测试按标识符查询用户方法
        public void testFindById(){
        
            //定义从标识符变量
            int id = 2;
            //创建用户数据访问接口对象
            UserDao userDao = new UserDaoImpl();
            //调用用户数据访问接口对昂的按标识符查询用户方法
            User user = userDao.findById(id);
            //判断是否找到指定用户
            if (user != null){
        //找到
                System.out.println(user);
            }else{
        //未找到
                System.out.println("编号为【" + id + "】的用户为找到~");
            }

*  运行`testFindById()`方法，查看结果  
    ![在这里插入图片描述][d623dfd013bf47e884bbe3f9df5da8e0.png]

##### ③编写按用户名查询用户方法 #####

@Test //测试按用户名查询用户
        public void testFindByUsername(){
        
            //定义用户名变量
            String username = "郑晓红";
            //创建用户数据访问接口对象
            UserDao userDao = new UserDaoImpl();
            //调用用户数据访问接口对象的按用户名查询用户方法
            List<User> users = userDao.findByUsername(username);
            //判断是否找到
            if(users.size() > 0){
        //找到
                users.forEach(user -> System.out.println(user));
            }else{
        //未找到
                System.out.println("没有找到名为[" + username + "]的用户");
            }
        }

*  运行`testFindByUsername()`方法，查看结果
 *  修改待查用户名，在运行测试方法，查看结果  
    ![在这里插入图片描述][b7b0d639e60e48a1a6980648bd3ce03b.png]

##### ④编写查询全部用户方法 #####

*  testFindAll()

@Test//测试查询全部用户
        public void testFindAll(){
        
            //创建用户数据访问接口对象
            UserDao userDao=new UserDaoImpl();
            //调用用户数据访问接口对象查询全部用户方法
            List<User> users=userDao.findAll();
            if(users.size()>0){
        
                users.forEach(user -> System.out.println(user));
            }else {
        
                System.out.println("用户表里面没有记录");
            }
        }

##### ⑤编写测试插入用户方法 #####

@Test //测试插入用户
        public void testInsert(){
        
            //创建用户对象
            User user = new User();
            //设置用户对象属性
            user.setUsername("易烊千玺");
            user.setPassword("1128");
            user.setTelephone("12345678342");
            user.setRegisterTime(new Date());
            user.setPopedom(1);
            //创建用户数据访问接口对象
            UserDao userDao = new UserDaoImpl();
            //调用用户数据访问接口对象的插入用户方法
            int count = userDao.insert(user);
            //判断是否成功插入用户
            if (count>0) {
        //成功
                System.out.println("恭喜，插入用户记录成功~");
            }else{
        //失败
                System.out.println("遗憾，插入用户失败~");
            }
        }

*  运行`testInsert()`方法，查看结果  
    ![在这里插入图片描述][924d73f662764a06864605063ca8c12c.png]
 *  在Navitcaat里查看用户表  
    ![在这里插入图片描述][868e51e0aac04ea297a825f56bde16f1.png]

##### ⑥编写测试更新用户方法 #####

@Test//测试更新用户
        public void testUpdate(){
        
            //创建用户对象
            User user = new User();
            //设置用户对象属性
            user.setId(5);
            user.setUsername("刘艳芬");
            user.setPassword("1343");
            user.setTelephone("13728678342");
            user.setRegisterTime(new Date());
            user.setPopedom(1);
            //创建用户数据访问接口对象
            UserDao userDao = new UserDaoImpl();
            //调用用户数据访问接口对象的更新用户方法
            int count = userDao.update(user);
            //判断是否成功更新用户
            if(count > 0){
        //成功
                System.out.println("恭喜，更新用户记录成功~");
            }else{
        
                System.out.println("遗憾，更新用户失败~");
            }
        }

*  运行`testUpdate()` 方法，查看结果

##### ⑦编写测试删除用户方法 #####

@Test//测试删除用户
        public void testDelete(){
        
            //定义标识符变量
            int id = 6;
            //创建用户数据访问接口对象
            UserDao userDao = new UserDaoImpl();
            //调用用户数据访问接口对象的删除用户方法
            int count = userDao.deleteById(id);
            //判断是否成功删除用户
            if(count > 0){
        //成功
                System.out.println("恭喜，删除用户成功~");
            }else{
        
                System.out.println("遗憾，删除用户失败~");
            }
        }

*  运行`testDelete()`方法，查看结果  
    ![在这里插入图片描述][d65cb7246c1a459d8389ffb7192c84be.png]
 *  在Navicat里查看记录，id为6的记录没有了  
    ![在这里插入图片描述][7dfcf311e6f940aeb6fe714bc0275179.png]
 *  若想再次插入记录下一次生成的是id为7的记录

#### （3）、创建类别数据访问接口实现类 ####

*  在`net.xyx.shop.dao.impl`包里创建`CategoryDaoImpl`类

##### ①编写插入类别方法 #####

@Override // 插入类别                                                        
    public int insert(Category category) {
                                           
        // 定义插入记录数                                                           
        int count = 0;                                                       
                                                                             
        // 获得数据库连接                                                           
        Connection conn = ConnectionManager.getConnection();                 
        // 定义SQL字符串                                                          
        String strSQL = "INSERT INTO t_category (name) VALUES (?)";          
        try {
                                                                        
            // 创建预备语句对象                                                      
            PreparedStatement pstmt = conn.prepareStatement(strSQL);         
            // 设置占位符的值                                                       
            pstmt.setString(1, category.getName());                          
            // 执行更新操作，插入新录                                                   
            count = pstmt.executeUpdate();                                   
            // 关闭预备语句对象                                                      
            pstmt.close();                                                   
        } catch (SQLException e) {
                                                   
            System.err.println(e.getMessage());                              
        } finally {
                                                                  
            ConnectionManager.closeConnection(conn); // 关闭数据库连接              
        }                                                                    
                                                                             
        // 返回插入记录数                                                           
        return count;                                                        
    }

##### ②编写按标识符插入类别方法 #####

@Override // 按标识符删除类别                                              
    public int deleteById(int id) {
                                            
        // 定义删除记录数                                                     
        int count = 0;                                                 
                                                                       
        // 获得数据库连接                                                     
        Connection conn = ConnectionManager.getConnection();           
        // 定义SQL字符串                                                    
        String strSQL = "DELETE FROM t_category WHERE id = ?";         
        try {
                                                                  
            // 创建预备语句对象                                                
            PreparedStatement pstmt = conn.prepareStatement(strSQL);   
            // 设置占位符的值                                                 
            pstmt.setInt(1, id);                                       
            // 执行更新操作，删除记录                                             
            count = pstmt.executeUpdate();                             
            // 关闭预备语句对象                                                
            pstmt.close();                                             
        } catch (SQLException e) {
                                             
            System.err.println(e.getMessage());                        
        } finally {
                                                            
            ConnectionManager.closeConnection(conn); // 关闭数据库连接        
        }                                                              
                                                                       
        // 返回删除记录数                                                     
        return count;                                                  
    }

##### ③编写更新类别方法 #####

@Override // 更新类别                                                     
    public int update(Category category) {
                                        
        // 定义更新记录数                                                        
        int count = 0;                                                    
                                                                          
        // 获得数据库连接                                                        
        Connection conn = ConnectionManager.getConnection();              
        // 定义SQL字符串                                                       
        String strSQL = "UPDATE t_category SET name = ? WHERE id = ?";    
        try {
                                                                     
            // 创建预备语句对象                                                   
            PreparedStatement pstmt = conn.prepareStatement(strSQL);      
            // 设置占位符的值                                                    
            pstmt.setString(1, category.getName());                       
            pstmt.setInt(2, category.getId());                            
            // 执行更新操作，更新记录                                                
            count = pstmt.executeUpdate();                                
            // 关闭预备语句对象                                                   
            pstmt.close();                                                
        } catch (SQLException e) {
                                                
            System.err.println(e.getMessage());                           
        } finally {
                                                               
            ConnectionManager.closeConnection(conn); // 关闭数据库连接           
        }                                                                 
                                                                          
        // 返回更新记录数                                                        
        return count;                                                     
    }

##### ④编写按标识符查询方法 #####

@Override // 按标识符查询类别                                                   
    public Category findById(int id) {
                                              
        // 声明类别                                                             
        Category category = null;                                           
                                                                            
        // 获取数据库连接对象                                                        
        Connection conn = ConnectionManager.getConnection();                
        // 定义SQL字符串                                                         
        String strSQL = "SELECT * FROM t_category WHERE id = ?";            
        try {
                                                                       
            // 创建预备语句对象                                                     
            PreparedStatement pstmt = conn.prepareStatement(strSQL);        
            // 设置占位符的值                                                      
            pstmt.setInt(1, id);                                            
            // 执行SQL查询，返回结果集                                                
            ResultSet rs = pstmt.executeQuery();                            
            // 判断结果集是否有记录                                                   
            if (rs.next()) {
                                                        
                // 实例化商品类别                                                  
                category = new Category();                                  
                // 利用当前记录字段值去设置商品类别的属性                                      
                category.setId(rs.getInt("id"));                            
                category.setName(rs.getString("name"));                     
            }                                                               
        } catch (SQLException e) {
                                                  
            System.err.println(e.getMessage());                             
        } finally {
                                                                 
            ConnectionManager.closeConnection(conn); // 关闭数据库连接             
        }                                                                   
                                                                            
        // 返回类别                                                             
        return category;                                                    
    }

##### ⑤编写查询全部方法 #####

@Override // 查询全部类别                                                           
    public List<Category> findAll() {
                                                     
        // 声明类别列表                                                                 
        List<Category> categories = new ArrayList<Category>();                    
                                                                                  
        // 获取数据库连接对象                                                              
        Connection conn = ConnectionManager.getConnection();                      
        // 定义SQL字符串                                                               
        String strSQL = "SELECT * FROM t_category";                               
        try {
                                                                             
            // 创建语句对象                                                             
            Statement stmt = conn.createStatement();                              
            // 执行SQL，返回结果集                                                        
            ResultSet rs = stmt.executeQuery(strSQL);                             
            // 遍历结果集                                                              
            while (rs.next()) {
                                                           
                // 创建类别实体                                                         
                Category category = new Category();                               
                // 设置实体属性                                                         
                category.setId(rs.getInt("id"));                                  
                category.setName(rs.getString("name"));                           
                // 将实体添加到类别列表                                                     
                categories.add(category);                                         
            }                                                                     
            // 关闭结果集                                                              
            rs.close();                                                           
            // 关闭语句对象                                                             
            stmt.close();                                                         
        } catch (SQLException e) {
                                                        
            System.err.println(e.getMessage());                                   
        } finally {
                                                                       
            ConnectionManager.closeConnection(conn); // 关闭数据库连接                   
        }                                                                         
                                                                                  
        // 返回类别列表                                                                 
        return categories;                                                        
    }

#### （4）、 对类别数据访问接口对象做单元测试 ####

*  在测试文件夹的`net.xyx.shop.dao.impl`包里创建`TestCategoryDaoImpl`类

##### ①编写测试按标识符查询类别方法 #####

@Test // 测试按标识符查询类别
        public void testFindById() {
        
            // 定义标识符变量
            int id = 1;
            // 创建类别数据访问接口对象
            CategoryDao categoryDao = new CategoryDaoImpl();
            // 调用类别数据访问接口对象的按标识符查询类别方法
            Category category = categoryDao.findById(id);
            // 判断是否找到指定类别
            if (category != null) {
         // 找到
                System.out.println(category);
            } else {
         // 未找到
                System.out.println("编号为[" + id + "]的类别未找到~");
            }
        }

##### ②编写测试查询全部类别方法 #####

@Test // 测试查询全部类别                                                         
    public void testFindAll() {
                                                       
        // 创建类别数据访问接口对象                                                       
        CategoryDao categoryDao = new CategoryDaoImpl();                      
        // 调用类别数据访问接口对象的查询全部类别方法                                              
        List<Category> categories = categoryDao.findAll();                    
        // 判断是否有类别                                                            
        if (categories.size() > 0) {
         // 有类别                                   
            categories.forEach(category -> System.out.println(category));     
        } else {
         // 没有用户                                                      
            System.out.println("类别表里没有记录~");                                  
        }                                                                     
    }

##### ③编写 测试查询全部类别 #####

@Test // 测试插入类别                                                                 
    public void testInsert() {
                                                    
        // 定义类别对象                                                         
        Category category = new Category();                               
        // 设置类别对象属性                                                       
        category.setName("厨房用具");                                         
        // 创建类别数据访问接口对象                                                   
        CategoryDao categoryDao = new CategoryDaoImpl();                  
        // 调用类别数据访问接口对象的插入类别方法                                            
        int count = categoryDao.insert(category);                         
        // 判断类别是否插入成功                                                     
        if (count > 0) {
         // 成功                                            
            System.out.println("恭喜，类别插入成功~");                             
        } else {
         // 失败                                                    
            System.out.println("遗憾，类别插入失败~");                             
        }                                                                 
    }

##### ④编写测试更新类别方法 #####

@Test // 测试更新类别                                         
    public void testUpdate() {
                                      
        // 定义类别对象                                           
        Category category = new Category();                 
        // 设置类别对象属性                                         
        category.setId(5);                                  
        category.setName("健身器械");                           
        // 创建类别数据访问接口对象                                     
        CategoryDao categoryDao = new CategoryDaoImpl();    
        // 调用类别数据访问接口对象的更新类别方法                              
        int count = categoryDao.update(category);           
        // 判断类别是否更新成功                                       
        if (count > 0) {
                                            
            System.out.println("恭喜，类别更新成功~");               
        } else {
                                                    
            System.out.println("遗憾，类别更新失败~");               
        }                                                   
    }

##### ⑤编写测试删除类别方法 #####

@Test // 测试按标识符删除类别                                   
    public void testDeleteById() {
                                
        // 定义标识符变量                                        
        int id = 5;                                       
        // 创建类别数据访问接口对象                                   
        CategoryDao categoryDao = new CategoryDaoImpl();  
        // 调用类别数据访问接口对象的按标识符删除类别方法                        
        int count = categoryDao.deleteById(id);           
        // 判断类别是否删除成功                                     
        if (count > 0) {
                                          
            System.out.println("恭喜，类别删除成功~");             
        } else {
                                                  
            System.out.println("遗憾，类别删除失败~");             
        }                                                 
    }

#### 5、编写商品数据访问接口实现类 ####

*  在`net.xyx.shop.dao.impl`包里创建`ProductDaoImpl`类  
    ![在这里插入图片描述][591ffb20faab4fab80e88b25c914193f.png]
 *  实现`ProductDaoImpl`接口

##### ①编写插入商品方法 #####

@Override
        public int insert(Product product) {
        
            int count = 0;
    
            // 获得数据库连接
            Connection conn = ConnectionManager.getConnection();
            // 定义SQL字符串
            String strSQL = "INSERT INTO t_product (name,price,add_time, category_id) VALUES (?,?,?,?)";
            try {
        
                //创建预备语句对象
                PreparedStatement pstmt = conn.prepareStatement(strSQL);
                //设置占位符的值
                pstmt.setString(1,product.getName());
                pstmt.setDouble(2,product.getPrice());
                pstmt.setTimestamp(3,new Timestamp(product.getAddTime().getTime()));
                pstmt.setInt(4,product.getCategotyId());
                //执行更新操作，返回插入记录数
                count = pstmt.executeUpdate();
                //关闭预备语句对象
                pstmt.close();
            } catch (SQLException e) {
        
                System.err.println(e.getMessage());
            } finally {
        
                ConnectionManager.closeConnection(conn);
            }
    
    
            return count;
        }

##### ②编写按标识符删除商品方法 #####

@Override//按标识符删除商品
        public int deleteById(int id) {
        
            //定义删除记录数
            int count = 0;
    
            // 获得数据库连接
            Connection conn = ConnectionManager.getConnection();
            // 定义SQL字符串
            String strSQL = "DELETE FROM t_product WHERE id = ?";
            try {
        
                // 创建预备语句对象
                PreparedStatement pstmt = conn.prepareStatement(strSQL);
                // 设置占位符的值
                pstmt.setInt(1, id);
                // 执行更新操作，删除记录
                count = pstmt.executeUpdate();
                // 关闭预备语句对象
                pstmt.close();
            } catch (SQLException e) {
        
                System.err.println(e.getMessage());
            } finally {
        
                ConnectionManager.closeConnection(conn); // 关闭数据库连接
            }
    
            //返回删除记录数
            return count;
        }

##### ③编写按标识符更新商品方法 #####

@Override
        public int update(Product product) {
        
                // 定义更新记录数
                int count = 0;
    
                // 获得数据库连接
                Connection conn = ConnectionManager.getConnection();
                // 定义SQL字符串
                String strSQL = "UPDATE t_product SET name = ?,price = !,add_time = ?, category_id = ? WHERE id = ?";
                try {
        
                    // 创建预备语句对象
                    PreparedStatement pstmt = conn.prepareStatement(strSQL);
                    // 设置占位符的值
                    pstmt.setString(1, product.getName());
                    pstmt.setDouble(2, product.getPrice());
                    pstmt.setTimestamp(3,new Timestamp(product.getAddTime().getTime()));
                    pstmt.setInt(4, product.getCategotyId());
                    pstmt.setInt(5,product.getId());
                    // 执行更新操作，更新记录
                    count = pstmt.executeUpdate();
                    // 关闭预备语句对象
                    pstmt.close();
                } catch (SQLException e) {
        
                    System.err.println(e.getMessage());
                } finally {
        
                    ConnectionManager.closeConnection(conn); // 关闭数据库连接
                }
    
                // 返回更新记录数
                return count;
        }

##### ④编写按标识符查询商品方法 #####

@Override
        public Product findById(int id) {
        
            // 声明类别
            Product product = null;
    
            // 获取数据库连接对象
            Connection conn = ConnectionManager.getConnection();
            // 定义SQL字符串
            String strSQL = "SELECT * FROM t_product WHERE id = ?";
            try {
        
                // 创建预备语句对象
                PreparedStatement pstmt = conn.prepareStatement(strSQL);
                // 设置占位符的值
                pstmt.setInt(1, id);
                // 执行SQL查询，返回结果集
                ResultSet rs = pstmt.executeQuery();
                // 判断结果集是否有记录
                if (rs.next()) {
        
                    // 实例化商品
                    product = new Product();
                    // 利用当前记录字段值去设置商品类别的属性
                    product.setId(rs.getInt("id"));
                    product.setName(rs.getString("name"));
                    product.setPrice(rs.getDouble("privce"));
                    product.setAddTime(rs.getTimestamp("add_time"));
                    product.setCategotyId(rs.getInt("category_id"));
                }
            } catch (SQLException e) {
        
                System.err.println(e.getMessage());
            } finally {
        
                ConnectionManager.closeConnection(conn); // 关闭数据库连接
            }
    
            // 返回类别
            return product;
        }

##### ⑤编写按类别标识符查询商品方法 #####

@Override//按类别标识符查询商品
        public List<Product> findByCategoryId(int categoryId) {
        
            //定义商品列表
            List<Product> products = new ArrayList<>();
    
            // 获取数据库连接对象
            Connection conn = ConnectionManager.getConnection();
            // 定义SQL字符串
            String strSQL = "SELECT * FROM t_product WHERE category_id = ?";
            try {
        
                // 创建预备语句对象
                PreparedStatement pstmt = conn.prepareStatement(strSQL);
                //设置占位符的值
                pstmt.setInt(1,categoryId);
                // 执行SQL查询，返回结果集
                ResultSet rs = pstmt.executeQuery();
                //遍历结果集
                while (rs.next()){
        
                    // 实例化商品
                    Product product = new Product();
                    // 利用当前记录字段值去设置商品类别的属性
                    product.setId(rs.getInt("id"));
                    product.setName(rs.getString("name"));
                    product.setPrice(rs.getDouble("privce"));
                    product.setAddTime(rs.getTimestamp("add_time"));
                    product.setCategotyId(rs.getInt("category_id"));
                    //将商品对象添加到商品列表
                    products.add(product);
                }
                //关闭预备语句对象
                pstmt.close();
            } catch (SQLException e) {
        
                System.err.println(e.getMessage());
            } finally {
        
                ConnectionManager.closeConnection(conn);
            }
    
            //返回商品列表
            return products;
        }

##### ⑥编写查询全部商品方法 #####

@Override//查询全部商品方法
        public List<Product> findAll() {
        
            // 声明类别列表
            List<Product> products = new ArrayList<>();
    
            // 获取数据库连接对象
            Connection conn = ConnectionManager.getConnection();
            // 定义SQL字符串
            String strSQL = "SELECT * FROM t_category";
            try {
        
                // 创建语句对象
                Statement stmt = conn.createStatement();
                // 执行SQL，返回结果集
                ResultSet rs = stmt.executeQuery(strSQL);
                // 遍历结果集
                while (rs.next()) {
        
                    // 创建商品实体
                    Product product = new Product();
                    // 设置实体属性
                    product.setId(rs.getInt("id"));
                    product.setName(rs.getString("name"));
                    product.setPrice(rs.getDouble("price"));
                    product.setAddTime(rs.getTimestamp("add_time"));
                    product.setCategotyId(rs.getInt("category_id"));
                    // 将实体添加到类别列表
                    products.add(product);
                }
                // 关闭结果集
                rs.close();
                // 关闭语句对象
                stmt.close();
            } catch (SQLException e) {
        
                System.err.println(e.getMessage());
            } finally {
        
                ConnectionManager.closeConnection(conn); // 关闭数据库连接
            }
    
            // 返回类别列表
            return products;
        }

#### 6、编写测试商品数据访问接口实现类 ####

*  创建测试类`TestProductDaoImpl`，编写测试方法`testFindByCategoryId()`

##### ①编写按标识符查询商品方法 #####

@Test
        public void testFindById(){
        
            int id = 1;
            ProductDao productDao = new ProductDaoImpl();
            //调用商品数据访问接口对象的按标识符查询商品方法
            Product product = productDao.findById(id);
            //判断是否找到商品
            if (product != null){
        
                System.out.println(product);
            }else{
        
                System.out.println("编号为【" + id + "】的商品未找到~");
            }
        }

*  运行`testFindById()`方法，查看结果  
    ![在这里插入图片描述][a3f700cd7ad44679b15ae1c1046a3582.png]
 *  修改标识符变量值，再运行

##### ②编写测试按类别标识符查询商品方法 #####

@Test//按类比标识符查询商品
        public void testFindByCategoryId(){
        
            //定义类别标识符变量
            int categoryId = 2;
            //创建商品数据访问接口对象
            ProductDao productDao = new ProductDaoImpl();
            //调用商品数据访问接口对象的按类别标识符查询商品方法
            List<Product> products = productDao.findByCategoryId(categoryId);
            //判断指定类别里是否有商品
            if (products.size() > 0){
        
                products.forEach(product -> System.out.println(product));
            }else{
        
                System.out.println("类别编号为[" + categoryId + "]的商品未找到~");
            }
        }

*  运行`testFindByCategoryId()`查看结果  
    ![在这里插入图片描述][bcbb1009ed7e42fc88f7d650ee02a418.png]

##### ③编写测试查询全部商品方法 #####

@Test//测试查询全部商品
        public void testFindAll(){
        
            //创建类别数据访问接口对象
            ProductDao productDao = new ProductDaoImpl();
            //调用类别数据访问接口对象的按标识符查询类别方法
            List<Product>products = productDao.findAll();
            if (products.size() >0){
        
                products.forEach(product -> System.out.println(product));
            }else{
        
                System.out.println("商品表里没有记录~");
            }
        }

*  运行`testFindAll()` 方法，查看结果  
    ![在这里插入图片描述][e315a5f4010f4ecc89381aab3cab0ad7.png]

##### ④编写测试插入商品方法 #####

@Test//测试插入商品
        public void testInsert(){
        
            //创建商品对象
            Product product = new Product();
            //设置商品对象属性
            product.setName("晨光签字笔");
            product.setPrice(3.0);
            product.setAddTime(new Date());
            product.setCategotyId(3);
            //创建类别数据访问接口对象
            ProductDao productDao = new ProductDaoImpl();
            //调用类别数据访问接口对象的插入商品方法
            int count = productDao.insert(product);
            //判断商品是否插入成功
            if (count > 0){
        
                System.out.println("恭喜，商品插入成功~");
            }else{
        
                System.out.println("抱歉，商品插入失败~");
            }
        }

*  运行`testInsert()`方法，查看结果  
    ![在这里插入图片描述][fe30e34ff4a84d02a4ee53f69a5550d7.png]
 *  在Navicat里面去查看  
    ![在这里插入图片描述][b6d08a00deca4df496e37be4a6ca4db0.png]

##### ⑤编写测试更新商品 #####

@Test//测试更新商品
        public  void testUpdate(){
        
            //定义类别对象
            Product product = new Product();
            //设置类别对象属性
            product.setId(5);
            product.setName("萌萌哒薯片");
            product.setPrice(10.0);
            product.setAddTime(new Date());
            product.setCategotyId(4);
            //创建类别数据访问接口对象
            ProductDao productDao = new ProductDaoImpl();
            //调用类别数据访问接口对象的更新类别方法
            int count = productDao.update(product);
            if(count>0){
        
                System.out.println("恭喜，商品更新成功~");
            }else{
        
                System.out.println("遗憾，商品更新失败~");
            }
        }

##### ⑥编写测试删除商品方法 #####

@Test//测试删除商品
        public void testDeleteById(){
        
            int id = 20;
            ProductDao productDao = new ProductDaoImpl();
            int count = productDao.deleteById(id);
            if(count>0){
        
                System.out.println("恭喜，商品删除成功~");
            }else{
        
                System.out.println("遗憾，商品删除失败~");
            }
        }

*  查看运行结果  
    ![在这里插入图片描述][6a51dba7a80d4f759231af50ec6bef33.png]

#### 7、创建订单数据访问接口类OrderDaoImpl ####

[0bc060e013b94f15b63510b6259f0adf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/362dda2bc16f47a0b2535b76c4c85437.png
[a20477dbaca54455949c2389bdface2a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/7869c980fc7e4d4bb1549e442fd5bc20.png
[6c570fddd20249948f986b5c95bc2c94.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/80a9f2a436e84e87b3b7df7a3fb70874.png
[9c79480e1a964c59a48ad9e24a029ecf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/8b4e023bda43444297b7996a2ae8240c.png
[51b230729d534460b3c5e1b6f83433b9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/be6ad75d3cdf4e00a5c314c5fc24beb1.png
[2689877c5f4f410e88cbbda64cb21cbb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/00861b7863ce46d5aa8065464c15b618.png
[8723a00ae1a04c5a8825180a93af0bbf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/2a15ec2a1933445aa49d7c89eca82e81.png
[08bbc689efff4f9b8efd276cdfec21ed.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/ba157295c28348ddb31565a952859744.png
[b1a5c0977f0e4652b9c6ca71328bf64d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/5cf3a7283c5d4b958a0b967ff4eb6498.png
[e224163af8e04a7491f6a14b37c1b64e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/136cfe43112046c4bba0453eb9e4a4f6.png
[d5be1434e6604e9280e23c617327e2d6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/3b89bcee20ce455ab6d3d18b3a4b21ad.png
[6eba4d2d0bb74b29bf3febda16235771.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/0f0e7d1486924bb1af1bcca3b1b63736.png
[57c348250b2c4a18b7cbccae941f0fb5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/a7620c612bcd4bf7b38b13cf46a0bbcb.png
[dcabef1b10b3435382d4438b34059366.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/91a277dbaa0646fd821d0c36a43cfe81.png
[d1fe9dea58b0401fb4b80f3fc7509cad.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/8d195d6f1b9448d5b6a0a57ff0b9c22b.png
[5e06258987d9437d931f55ac1b625bac.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/c88685ce9714448b93d3bd95d4fc27d4.png
[636114668f0944c4b74525b0aa148bf9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/60143582baad4b88835bc066204574a5.png
[349c3bff41dc4091976b7d61a7fa41c6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/eb980aeea2aa4c738d69096b7b078891.png
[706981c24db14b87a3d9a9ff0cfffb60.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/44c4475c5d114b81b856215ef3a4e17c.png
[16fe22e9b1da48b9853d8961c07b9260.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/da72a6d28fbe4315932d4d58b7c6a555.png
[569077a3f8934d14970dbe1875a1db7f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/d1a5c2101db544e7bdd9cf983e60b53a.png
[21e82de6bdd9442181b96f18314f2228.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/dd93996bd85f4ae68ad8c21d00315db2.png
[e6fc7a01d42a4a04b3c228492d3daf28.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/e9d4e62e400745b799870e51b44730f1.png
[8dde3b417c8b47a2af8962ff6c760398.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/a5173812b21b4092bc6ea42b7d44de12.png
[d715b38ef41d447782a812ff09d17c96.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/b056dad08b414ca983cf7e91bf0ef6c3.png
[9ae4da638b11461fb66500c85686afda.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/cea19e3897b34fd0a9ff1f2d944cf11d.png
[4373bf3c8d7442bf9ecbc087e9c704e4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/061abf7c95f04f7492b9357aa16c0c1d.png
[ff964e447c4c4325910fa7538027b03e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/513584590a5f41dc8d7c788a210b176e.png
[24122155994647f99fa5775d9cd8d0aa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/17e6658ec9e8446e9302bcd1d9c1eb57.png
[61eae6e6acfa442591258b91212fea44.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/1b7e2e4658b4427bb273fe04cb472e85.png
[31810d89f6d844dc9a93dbdf21303f95.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/a3a05a038c654288a5dab306924c5c67.png
[d4ba32a8ec184287942e574684676aa9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/94d6d79eb3e340cfabbdf912ecc4cf54.png
[d1568c831fc1447989a3bc184b164469.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/25b8dfbe93e44a21a955933d9a3d9760.png
[41ee0803917a421bbf6f4a2994ed2d69.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/26ad8097156f40dbbe6841e7c4dcc88a.png
[1a37f79882454dac84262b26277ca3a3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/97df052f15724f13aa9d8a2477d0811b.png
[d623dfd013bf47e884bbe3f9df5da8e0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/59dff5f3b69e4602a5a843eebe2921b7.png
[b7b0d639e60e48a1a6980648bd3ce03b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/b48f22ae27c742388049bc234878f37f.png
[924d73f662764a06864605063ca8c12c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/99a8ca4a3e7e4e4a8c6f1b9c5c8823f0.png
[868e51e0aac04ea297a825f56bde16f1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/3bce3a63e5e34048871438b852843c54.png
[d65cb7246c1a459d8389ffb7192c84be.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/22b24872c29046a0ab29edf5b1fbcd5a.png
[7dfcf311e6f940aeb6fe714bc0275179.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/57dc33b09765447cb81fe6bce6a29aca.png
[591ffb20faab4fab80e88b25c914193f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/f99de367edf641df83da25c9e9a78dbb.png
[a3f700cd7ad44679b15ae1c1046a3582.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/87844387db00429a9a924f955770c6f2.png
[bcbb1009ed7e42fc88f7d650ee02a418.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/4a10d949cc1944ce9c44f81f059bd462.png
[e315a5f4010f4ecc89381aab3cab0ad7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/f206a88e7db3487e92fb7880dec20172.png
[fe30e34ff4a84d02a4ee53f69a5550d7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/bb3883bd47254f2d84a85fb9a714b5f4.png
[b6d08a00deca4df496e37be4a6ca4db0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/c0197291501447e4a71225afcae45781.png
[6a51dba7a80d4f759231af50ec6bef33.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/5549328020a442f8880d997a73c6bf6f.png