​

本项目采用MVC模式进行开发，整合JSP + Servlet + DB（DAO），同学们可以通过本次实战，了解Web开发的一般流程。

一、网站功能需求

1、只有注册用户成功登录后才可查看商品类别，查看商品，选购商品，生成订单、查看订单
2、只有管理员才有权限进入购物网后台管理（用户管理 + 类别管理 + 商品管理 + 订单管理）

二、网站设计思路

（一）设计模式

• 分层架构：展现层（JSP）<——>控制层（Controller）<——>业务层（Service）<——>数据映射层（Mapper）<——>数据库（DB）
  

（二）网站前台

1. 登录——显示商品类别——显示某类商品信息——查看购物车——生成订单——支付
2. 注册<——>登录

（三）网站后台

1、用户管理

• 查看用户
• 添加用户
• 修改用户
• 删除用户

2、类别管理

• 查看类别
• 添加类别
• 修改类别
• 删除类别

3、商品管理

• 查看商品
• 添加商品
• 修改商品
• 删除商品

4、订单管理

• 查看订单
• 删除订单

（四）购物流程图

• 管理员登录成功，进入后台管理
• 普通用户登录成功，进入前台购物
  

三、网站运行效果

• 操作演示录屏
  

四、网站实现步骤

（一）创建数据库与表

1、创建数据库

• 数据库 - simonshop
  

2、创建用户表

• 创建用户表结构 - t_user
  

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;

• 在用户表里插入记录
  

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
  

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;

• 在类别表里插入记录
  

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
  

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;

• 在商品表里插入记录
  

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
  

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;

• 在订单表里插入记录
  

INSERT INTO `t_order` VALUES ('1', '郑晓红', '13956567889', '2000', '泸职院大数据学院', '2023-05-25 17:12:36');
INSERT INTO `t_order` VALUES ('2', '温志军', '13956678907', '1000', '泸职院机械工程学院', '2023-05-26 17:12:17');

• 查看订单表记录
  

（二）创建Web项目

1、创建Web项目

• 创建Java Enterprise项目，添加Web Application功能
  
• 设置项目名称与保存位置
  
• 单击【Finish】按钮
  

2、修改Artifact名称

• 将Artifact名称改为simonshop
  

3、重新部署项目

• 先移除，后添加，重新部署项目
  
• 切换到【Server】选项卡

4、编辑首页

• 首页 - index.jsp
  

<%@ page import="java.util.Date" %>
<%@ 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、启动应用，查看效果

• 启动服务器，显示首页
  

（三）创建实体类

• 创建四个实体类：User、Category、Product与Order，与四张表t_user、t_category、t_product与t_order一一对应。ORM（Object Relation Mapping）——对象关系映射。

1、创建用户实体类

• 创建net.huawei.shop.bean包，在包里创建User类
  

package net.huawei.shop.bean;

import java.util.Date;

/**
 * 功能：用户实体类
 * 作者：华卫
 * 日期：2023年05月29日
 */
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 +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", telephone='" + telephone + '\'' +
                ", registerTime=" + registerTime +
                ", popedom=" + popedom +
                '}';
    }
}

2、创建类别实体类

• 在net.huawei.shop.bean包里创建Category类
  

package net.huawei.shop.bean;

/**
 * 功能：类别实体类
 * 作者：华卫
 * 日期：2023年05月29日
 */
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、创建商品实体类

• 在net.huawei.shop.bean包里创建Product类
  

package net.huawei.shop.bean;

import java.util.Date;

/**
 * 功能：商品实体类
 * 作者：华卫
 * 日期：2023年05月29日
 */
public class Product {
    private int id; // 商品标识符
    private String name; // 商品名称
    private double price; // 商品价格
    private Date addTime; // 商品上架时间
    private int categoryId; // 类别标识符

    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 getCategoryId() {
        return categoryId;
    }

    public void setCategoryId(int categoryId) {
        this.categoryId = categoryId;
    }

    @Override
    public String toString() {
        return "Product{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", price=" + price +
                ", addTime=" + addTime +
                ", categoryId=" + categoryId +
                '}';
    }
}

4、创建订单实体类

• 在net.huawei.shop.bean包里创建Order类
  

package net.huawei.shop.bean;

import java.util.Date;

/**
 * 功能：订单实体类
 * 作者：华卫
 * 日期：2023年05月29日
 */
public class Order {
    private int id; // 订单标识符
    private String username; // 用户名
    private String telephone; // 联系电话
    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 getTelephone() {
        return telephone;
    }

    public void setTelephone(String telephone) {
        this.telephone = telephone;
    }

    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 + '\'' +
                ", telephone='" + telephone + '\'' +
                ", totalPrice=" + totalPrice +
                ", deliveryAddress='" + deliveryAddress + '\'' +
                ", orderTime=" + orderTime +
                '}';
    }
}

（四）创建数据库工具类

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

• 在\WEB-INF里创建lib子目录，添加MySQL驱动程序的jar包
  
• 将数据库驱动程序包作为库添加到项目
  
  
  

2、在src下创建net.hw.shop.dbutil包，在里面创建ConnectionManager类

package net.hw.shop.dbutil;

/**

• 功能：数据库连接管理类
• 作者：华卫
• 日期：2019年12月2日
  */

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

import javax.swing.JOptionPane;

public class ConnectionManager {
/**
* 数据库驱动程序
/
private static final String DRIVER = “com.mysql.jdbc.Driver”;
/*
* 数据库统一资源标识符
/
private static final String URL = “jdbc:mysql://localhost:3306/simonshop”;
/*
* 数据库用户名
/
private static final String USERNAME = “root”;
/*
* 数据库密码
*/
private static final String PASSWORD = “P@ssw0rd”;

/**
 * 私有化构造方法，拒绝实例化
 */
private ConnectionManager() {
}

/**
 * 获取数据库连接静态方法
 *
 * @return 数据库连接对象
 */
public static Connection getConnection() {
    // 定义数据库连接
    Connection conn = null;
    try {
        // 安装数据库驱动程序
        Class.forName(DRIVER);
        // 获得数据库连接
        conn = DriverManager.getConnection(URL
                + "?useUnicode=true&characterEncoding=UTF8", USERNAME, PASSWORD);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (SQLException e) {
        e.printStackTrace();
    }
    // 返回数据库连接
    return conn;
}

/**
 * 关闭数据库连接静态方法
 *
 * @param conn
 */
public static void closeConnection(Connection conn) {
    // 判断数据库连接是否为空
    if (conn != null) {
        // 判断数据库连接是否关闭
        try {
            if (!conn.isClosed()) {
                // 关闭数据库连接
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

/**
 * 测试数据库连接是否成功
 *
 * @param args
 */
public static void main(String[] args) {
    // 获得数据库连接
    Connection conn = getConnection();
    // 判断是否连接成功
    if (conn != null) {
        JOptionPane.showMessageDialog(null, "恭喜，数据库连接成功！");
    } else {
        JOptionPane.showMessageDialog(null, "遗憾，数据库连接失败！");
    }

    // 关闭数据库连接
    closeConnection(conn);
}

}
3、运行程序，查看结果

采用数据库连接池，效率更高，建议大家使用数据源方式来获取数据库连接。大家可以参看：Java Web学习笔记07：数据源和JavaBean

4、常见错误解析
（1）连接异常

启动MySQL服务即可解决此问题。

（2）密码错误异常

（3）时区异常

错误原因：这个异常是由于本地时区和MySQL服务器设置的时区不一致造成的。

解决办法：在数据库链接配置后添加?serverTimezone=UTC参数，告知服务器采用UTC时间格式。

（五）数据访问接口（XXXDao）
在src里创建net.hw.shop.dao包，在里面创建UserDao、CategoryDao、ProductDao与OrderDao。

1、用户数据访问接口UserDao

package net.hw.shop.dao;

/**

• 功能：用户数据访问接口
• 作者：华卫
• 日期：2019年12月2日
  */
  import java.util.List;

import net.hw.shop.bean.User;

public interface UserDao {
// 插入用户
int insert(User user);
// 按标识符删除用户
int deleteById(int id);
// 更新用户
int update(User user);
// 按标识符查询用户
User findById(int id);
// 按用户名查询用户
List findByUsername(String username);
// 查询全部用户
List findAll();
// 用户登录
User login(String username, String password);
}
2、类别数据访问接口CategoryDao

package net.hw.shop.dao;

/**

• 功能：类别数据访问接口
• 作者：华卫
• 日期：2019年12月2日
  */
  import java.util.List;

import net.hw.shop.bean.Category;

public interface CategoryDao {
// 插入类别
int insert(Category category);
// 按标识符删除类别
int deleteById(int id);
// 更新类别
int update(Category category);
// 按标识符查询类别
Category findById(int id);
// 查询全部类别
List findAll();
}
3、商品数据访问接口ProductDao

package net.hw.shop.dao;

/**

• 功能：商品数据访问接口
• 作者：华卫
• 日期：2019年12月2日
  */
  import java.util.List;

import net.hw.shop.bean.Product;

public interface ProductDao {
// 插入商品
int insert(Product product);
// 按标识符删除商品
int deleteById(int id);
// 更新商品
int update(Product product);
// 按标识符查询商品
Product findById(int id);
// 按类别查询商品
List findByCategoryId(int categoryId);
// 查询全部商品
List findAll();
}
4、订单数据访问接口OrderDao

package net.hw.shop.dao;

/**

• 功能：订单数据访问接口
• 作者：华卫
• 日期：2019年12月2日
  */
  import java.util.List;

import net.hw.shop.bean.Order;

public interface OrderDao {
// 插入订单
int insert(Order order);
// 按标识符删除订单
int deleteById(int id);
// 更新订单
int update(Order order);
// 按标识符查询订单
Order findById(int id);
// 查询最后一个订单
Order findLast();
// 查询全部订单
List findAll();
}
（六）数据访问接口实现类XXXDaoImpl
在src下创建net.hw.shop.dao.impl包，在里面创建UserDaoImpl、CategoryDaoImpl、ProductDaoImpl与OrderDaoImpl。

1、用户数据访问接口实现类UserDaoImpl

package net.hw.shop.dao.impl;

/**

• 功能：用户数据访问接口实现类
• 作者：华卫
• 日期：2019年12月2日
  */
  import java.sql.Connection;
  import java.sql.PreparedStatement;
  import java.sql.ResultSet;
  import java.sql.SQLException;
  import java.sql.Statement;
  import java.sql.Timestamp;
  import java.util.ArrayList;
  import java.util.List;

import net.hw.shop.bean.User;
import net.hw.shop.dao.UserDao;
import net.hw.shop.dbutil.ConnectionManager;

public class UserDaoImpl implements UserDao {
/**
* 插入用户
*/
@Override
public int insert(User user) {
// 定义插入记录数
int count = 0;

    // 获得数据库连接
    Connection conn = ConnectionManager.getConnection();
    // 定义SQL字符串
    String strSQL = "INSERT INTO t_user (username, password, telephone, register_time, popedom)"
            + " VALUES (?, ?, ?, ?, ?)";
    try {
        // 创建预备语句对象
        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 e) {
        e.printStackTrace();
    } 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_user WHERE id = ?";
    try {
        // 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 设置占位符的值
        pstmt.setInt(1, id);
        // 执行更新操作，删除记录
        count = pstmt.executeUpdate();
        // 关闭预备语句对象
        pstmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        ConnectionManager.closeConnection(conn);
    }

    // 返回删除记录数
    return count;
}

/**
 * 更新用户
 */
@Override
public int update(User user) {
    // 定义更新记录数
    int count = 0;

    // 获得数据库连接
    Connection conn = ConnectionManager.getConnection();
    // 定义SQL字符串
    String strSQL = "UPDATE t_user SET username = ?, password = ?, telephone = ?,"
            + " register_time = ?, popedom = ? WHERE id = ?";
    try {
        // 创建预备语句对象
        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) {
        e.printStackTrace();
    } finally {
        ConnectionManager.closeConnection(conn);
    }

    // 返回更新记录数
    return count;
}

/**
 * 按标识符查询用户
 */
@Override
public User findById(int id) {
    // 声明用户
    User user = null;

    // 获取数据库连接对象
    Connection conn = ConnectionManager.getConnection();
    // 定义SQL字符串
    String strSQL = "SELECT * FROM t_user WHERE id = ?";
    try {
        // 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 设置占位符的值
        pstmt.setInt(1, id);
        // 执行SQL查询，返回结果集
        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"));
        }
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        ConnectionManager.closeConnection(conn);
    }

    // 返回用户
    return user;
}

@Override
public List<User> findByUsername(String username) {
    // 声明用户列表
    List<User> users = new ArrayList<User>();
    // 获取数据库连接对象
    Connection conn = ConnectionManager.getConnection();
    // 定义SQL字符串
    String strSQL = "SELECT * FROM t_user WHERE username = ?";
    try {
        // 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 设置占位符的值
        pstmt.setString(1, username);
        // 执行SQL查询，返回结果集
        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);
        }
        // 关闭结果集
        rs.close();
        // 关闭语句对象
        pstmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }
    // 返回用户列表
    return users;
}

@Override
public List<User> findAll() {
    // 声明用户列表
    List<User> users = new ArrayList<User>();
    // 获取数据库连接对象
    Connection conn = ConnectionManager.getConnection();
    // 定义SQL字符串
    String strSQL = "SELECT * FROM t_user";
    try {
        // 创建语句对象
        Statement stmt = conn.createStatement();
        // 执行SQL，返回结果集
        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);
        }
        // 关闭结果集
        rs.close();
        // 关闭语句对象
        stmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }
    // 返回用户列表
    return users;
}

/**
 * 登录方法
 */
@Override
public User login(String username, String password) {
    // 定义用户对象
    User user = null;
    // 获取数据库连接
    Connection conn = ConnectionManager.getConnection();
    // 定义SQL字符串
    String strSQL = "SELECT * FROM t_user WHERE username = ? AND password = ?";
    try {
        // 创建预备语句对象
        PreparedStatement psmt = conn.prepareStatement(strSQL);
        // 设置占位符的值
        psmt.setString(1, username);
        psmt.setString(2, password);
        // 执行查询，返回结果集
        ResultSet rs = psmt.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.getDate("register_time"));
            user.setPopedom(rs.getInt("popedom"));
        }
        // 关闭结果集
        rs.close();
        // 关闭预备语句
        psmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }

    // 返回用户对象
    return user;
}

}
我们需要对用户数据访问接口实现类的各个方法进行单元测试，采用JUnit来进行单元测试。

在项目根目录创建一个test文件夹，然后在项目结构窗口里将其标记为"Tests"，这样文件夹颜色变成绿色。

在test文件夹里创建net.hw.shop.dao.impl包，在里面创建测试类TestUserDaoImpl：

（1）编写测试登录方法testLogin()

将光标定位到@Test注解符，按组合键Alt + Enter：

package net.hw.shop.dao.impl;

import net.hw.shop.bean.User;
import net.hw.shop.dao.UserDao;
import org.junit.Test;

public class TestUserDaoImpl {
@Test
public void testLogin() {
String username, password;

    username = "admin";
    password = "12345";
    
    // 父接口指向子类对象
    UserDao userDao = new UserDaoImpl();
    User user = userDao.login(username, password);

    // 判断用户登录是否成功
    if (user != null) {
        System.out.println("恭喜，登录成功！");
    } else {
        System.out.println("遗憾，登录失败！");
    }
}

}
运行单元测试方法testLogin()：

查看单元测试结果：

修改一下登录密码，再进行单元测试，看结果如何：

（2）编写测试方法testUpdate()

将用户【涂文艳】的密码改为“903213"，电话改为“13945457890”。涂文艳用户的id是4。

运行单元测试方法testUpdate()，结果如下：

修改一下测试代码再测试，结果如下：

课堂练习：完成UserDaoImpl其余方法的单元测试。

思考题：

（1）如何避免插入同名用户？插入同名用户时，提示用户名已存在。

（2）如何避免更新用户记录时注册时间在当前时间之后的问题？

2、类别数据访问接口实现类CategoryDaoImpl

package net.hw.shop.dao.impl;

/**

• 功能：类别数据访问接口实现类
• 作者：华卫
• 日期：2019年12月10日
  */
  import java.sql.Connection;
  import java.sql.PreparedStatement;
  import java.sql.ResultSet;
  import java.sql.SQLException;
  import java.sql.Statement;
  import java.util.ArrayList;
  import java.util.List;

import net.hw.shop.bean.Category;
import net.hw.shop.dao.CategoryDao;
import net.hw.shop.dbutil.ConnectionManager;

public class CategoryDaoImpl implements CategoryDao {
/**
* 插入类别
*/
@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) {
        e.printStackTrace();
    } 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) {
        e.printStackTrace();
    } 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) {
        e.printStackTrace();
    } 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) {
        e.printStackTrace();
    } 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) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }
    // 返回类别列表
    return categories;
}

}
创建测试类TestCategoryDaoImpl，编写测试方法testFindAll()：

运行测试方法testFindAll()，结果如下：

此时，再运行测试方法testFindAll()，结果如下：

运行simonshop.sql数据库脚本，恢复数据库：

判断集合categories是否为空，可以有两种处理方式：

categories.size() > 0
!categories.isEmpty()
课堂练习：编写方法测试CatetoryDaoImpl其余的方法。

3、商品数据访问接口实现类ProductDaoImpl

package net.hw.shop.dao.impl;

/**

• 功能：产品数据访问接口实现类
• 作者：华卫
• 日期：2019年12月2日
  */

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.List;

import net.hw.shop.bean.Product;
import net.hw.shop.dao.ProductDao;
import net.hw.shop.dbutil.ConnectionManager;

public class ProductDaoImpl implements ProductDao {
/**
* 插入商品
*/
@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.getCategoryId());
        // 执行更新操作，插入新记录
        count = pstmt.executeUpdate();
        // 关闭预备语句对象
        pstmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } 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) {
        e.printStackTrace();
    } 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.getCategoryId());
        pstmt.setInt(5, product.getId());
        // 执行更新操作，更新记录
        count = pstmt.executeUpdate();
        // 关闭预备语句对象
        pstmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } 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("price"));
            product.setAddTime(rs.getTimestamp("add_time"));
            product.setCategoryId(rs.getInt("category_id"));
        }
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        ConnectionManager.closeConnection(conn);
    }

    // 返回商品
    return product;
}

/**
 * 按类别查询商品
 */
@Override
public List<Product> findByCategoryId(int categoryId) {
    // 定义商品列表
    List<Product> products = new ArrayList<Product>();

    // 获取数据库连接
    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("price"));
            product.setAddTime(rs.getTimestamp("add_time"));
            product.setCategoryId(rs.getInt("category_id"));
            // 将商品添加到商品列表
            products.add(product);
        }
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        ConnectionManager.closeConnection(conn);
    }
    // 返回商品列表
    return products;
}

/**
 * 查询全部商品
 */
@Override
public List<Product> findAll() {
    // 声明商品列表
    List<Product> products = new ArrayList<Product>();
    // 获取数据库连接对象
    Connection conn = ConnectionManager.getConnection();
    // 定义SQL字符串
    String strSQL = "SELECT * FROM t_product";
    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.setCategoryId(rs.getInt("category_id"));
            // 将实体添加到商品列表
            products.add(product);
        }
        // 关闭结果集
        rs.close();
        // 关闭语句对象
        stmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }
    // 返回商品列表
    return products;
}

}

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

运行测试方法testFindByCategoryId()，结果如下：

修改一下查询的类别id，比如改成5，再运行测试方法testFindByCategoryId()，结果如下：

我们打开t_category表，添加一条新记录：

此时，再运行测试方法testFindByCategoryId()，结果如下：

为了不影响后面的操作，我们还是将【时尚服装】类别删除。

课堂练习：编写方法测试ProductDaoImpl其余方法。

4、订单数据访问接口实现类OrderDaoImpl

package net.hw.shop.dao.impl;
/**

• 功能：订单数据访问接口实现类
• 作者：华卫
• 日期：2019年12月2日
  */

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.List;

import net.hw.shop.bean.Order;
import net.hw.shop.dao.OrderDao;
import net.hw.shop.dbutil.ConnectionManager;

public class OrderDaoImpl implements OrderDao {
/**
* 插入订单
*/
@Override
public int insert(Order order) {
// 定义插入记录数
int count = 0;

    // 获得数据库连接
    Connection conn = ConnectionManager.getConnection();
    // 定义SQL字符串
    String strSQL = "INSERT INTO t_order (username, telephone, total_price, delivery_address, order_time)"
            + " VALUES (?, ?, ?, ?, ?)";
    try {
        // 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 设置占位符的值
        pstmt.setString(1, order.getUsername());
        pstmt.setString(2, order.getTelephone());
        pstmt.setDouble(3, order.getTotalPrice());
        pstmt.setString(4, order.getDeliveryAddress());
        pstmt.setTimestamp(5, new Timestamp(order.getOrderTime().getTime()));
        // 执行更新操作，插入记录
        count = pstmt.executeUpdate();
        // 关闭预备语句对象
        pstmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } 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_order WHERE id = ?";
    try {
        // 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 设置占位符的值
        pstmt.setInt(1, id);
        // 执行更新操作，删除记录
        count = pstmt.executeUpdate();
        // 关闭预备语句对象
        pstmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        ConnectionManager.closeConnection(conn);
    }

    // 返回删除记录数
    return count;
}

/**
 * 更新订单
 */
@Override
public int update(Order order) {
    // 定义更新记录数
    int count = 0;

    // 获得数据库连接
    Connection conn = ConnectionManager.getConnection();
    // 定义SQL字符串
    String strSQL = "UPDATE t_order SET username = ?, telephone = ?, total_price = ?,"
            + " delivery_address = ?, order_time = ? WHERE id = ?";
    try {
        // 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 设置占位符的值
        pstmt.setString(1, order.getUsername());
        pstmt.setString(2, order.getTelephone());
        pstmt.setDouble(3, order.getTotalPrice());
        pstmt.setString(4, order.getDeliveryAddress());
        pstmt.setTimestamp(5, new Timestamp(order.getOrderTime().getTime()));
        pstmt.setInt(6, order.getId());
        // 执行更新操作，更新记录
        count = pstmt.executeUpdate();
        // 关闭预备语句对象
        pstmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        ConnectionManager.closeConnection(conn);
    }

    // 返回更新记录数
    return count;
}

/**
 * 查询最后一个订单
 */
@Override
public Order findLast() {
    // 声明订单
    Order order = null;
    // 获取数据库连接对象
    Connection conn = ConnectionManager.getConnection();
    // 定义SQL字符串
    String strSQL = "SELECT * FROM t_order";
    try {
        // 创建语句对象
        Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
        // 执行SQL，返回结果集
        ResultSet rs = stmt.executeQuery(strSQL);
        // 定位到最后一条记录
        if (rs.last()) {
            // 创建订单实体
            order = new Order();
            // 设置实体属性
            order.setId(rs.getInt("id"));
            order.setUsername(rs.getString("username"));
            order.setTelephone(rs.getString("telephone"));
            order.setTotalPrice(rs.getDouble("total_price"));
            order.setDeliveryAddress(rs.getString("delivery_address"));
            order.setOrderTime(rs.getTimestamp("order_time"));
        }
        // 关闭结果集
        rs.close();
        // 关闭语句对象
        stmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }
    // 返回订单对象
    return order;
}

/**
 * 按标识符查询订单
 */
@Override
public Order findById(int id) {
    // 声明订单
    Order order = null;

    // 获取数据库连接对象
    Connection conn = ConnectionManager.getConnection();
    // 定义SQL字符串
    String strSQL = "SELECT * FROM t_order WHERE id = ?";
    try {
        // 创建预备语句对象
        PreparedStatement pstmt = conn.prepareStatement(strSQL);
        // 设置占位符的值
        pstmt.setInt(1, id);
        // 执行SQL查询，返回结果集
        ResultSet rs = pstmt.executeQuery();
        // 判断结果集是否有记录
        if (rs.next()) {
            // 实例化订单
            order = new Order();
            // 利用当前记录字段值去设置订单的属性
            order.setId(rs.getInt("id"));
            order.setUsername(rs.getString("username"));
            order.setTelephone(rs.getString("telephone"));
            order.setDeliveryAddress(rs.getString("delivery_address"));
            order.setOrderTime(rs.getTimestamp("order_time"));
        }
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        ConnectionManager.closeConnection(conn);
    }

    // 返回订单
    return order;
}

/**
 * 查询全部订单
 */
@Override
public List<Order> findAll() {
    // 声明订单列表
    List<Order> orders = new ArrayList<Order>();
    // 获取数据库连接对象
    Connection conn = ConnectionManager.getConnection();
    // 定义SQL字符串
    String strSQL = "SELECT * FROM t_order";
    try {
        // 创建语句对象
        Statement stmt = conn.createStatement();
        // 执行SQL，返回结果集
        ResultSet rs = stmt.executeQuery(strSQL);
        // 遍历结果集
        while (rs.next()) {
            // 创建订单实体
            Order order = new Order();
            // 设置实体属性
            order.setId(rs.getInt("id"));
            order.setUsername(rs.getString("username"));
            order.setTelephone(rs.getString("telephone"));
            order.setDeliveryAddress(rs.getString("delivery_address"));
            order.setOrderTime(rs.getTimestamp("order_time"));
            // 将实体添加到订单列表
            orders.add(order);
        }
        // 关闭结果集
        rs.close();
        // 关闭语句对象
        stmt.close();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        // 关闭数据库连接
        ConnectionManager.closeConnection(conn);
    }
    // 返回用户列表
    return orders;
}

}
创建测试类TestOrderDaoImpl，编写测试方法testFinAll()：

运行测试方法testFinAll()，结果如下：

此时，再运行测试方法testFinAll()，结果如下：

课堂练习：编写方法测试OrderDaoImpl其余方法。

（七）数据访问服务类XXXService
在src里创建net.hw.shop.service包，在里面创建四个服务类：UserService、CategoryService、ProductService与OrderService。

1、用户服务类UserService

package net.hw.shop.service;

/**

• 功能：用户服务类
• 作者：华卫
• 日期：2019年12月2日
  */

import java.util.List;

import net.hw.shop.bean.User;
import net.hw.shop.dao.UserDao;
import net.hw.shop.dao.impl.UserDaoImpl;

public class UserService {
/**
* 声明用户访问对象
*/
private UserDao userDao = new UserDaoImpl();

public int addUser(User user) {
    return userDao.insert(user);
}

public int deleteUserById(int id) {
    return userDao.deleteById(id);
}

public int updateUser(User user) {
    return userDao.update(user);
}

public User findUserById(int id) {
    return userDao.findById(id);
}

public List<User> findUsersByUsername(String username) {
    return userDao.findByUsername(username);
}

public List<User> findAllUsers() {
    return userDao.findAll();
}

public User login(String username, String password) {
    return userDao.login(username, password);
}

}
2、类别服务类CategoryService

package net.hw.shop.service;

/**

• 功能：类别服务类
• 作者：华卫
• 日期：2019年12月2日
  */

import java.util.List;

import net.hw.shop.bean.Category;
import net.hw.shop.dao.CategoryDao;
import net.hw.shop.dao.impl.CategoryDaoImpl;

public class CategoryService {
/**
* 声明类别数据访问对象
*/
private CategoryDao categoryDao = new CategoryDaoImpl();

public int addCategory(Category category) {
    return categoryDao.insert(category);
}

public int deleteCategoryById(int id) {
    return categoryDao.deleteById(id);
}

public int updateCategory(Category category) {
    return categoryDao.update(category);
}

public Category findCategoryById(int id) {
    return categoryDao.findById(id);
}

public List<Category> findAllCategories() {
    return categoryDao.findAll();
}

}
3、商品服务类ProductService

package net.hw.shop.service;

/**

• 功能：商品服务类
• 作者：华卫
• 日期：2019年12月2日
  */

import java.util.List;

import net.hw.shop.bean.Product;
import net.hw.shop.dao.ProductDao;
import net.hw.shop.dao.impl.ProductDaoImpl;

public class ProductService {
/**
* 声明商品数据访问对象
*/
private ProductDao productDao = new ProductDaoImpl();

public int addProduct(Product product) {
    return productDao.insert(product);
}

public int deleteProductById(int id) {
    return productDao.deleteById(id);
}

public int updateProduct(Product product) {
    return productDao.update(product);
}

public Product findProductById(int id) {
    return productDao.findById(id);
}

public List<Product> findProductsByCategoryId(int categoryId) {
    return productDao.findByCategoryId(categoryId);
}

public List<Product> findAllProducts() {
    return productDao.findAll();
}

}
4、订单服务类OrderService

package net.hw.shop.service;

/**

• 功能：订单服务类
• 作者：华卫
• 日期：2019年12月2日
  */

import java.util.List;

import net.hw.shop.bean.Order;
import net.hw.shop.dao.OrderDao;
import net.hw.shop.dao.impl.OrderDaoImpl;

public class OrderService {
/**
* 声明订单数据访问对象
*/
OrderDao orderDao = new OrderDaoImpl();

public int addOrder(Order order) {
    return orderDao.insert(order);
}

public int deleteOrderById(int id) {
    return orderDao.deleteById(id);
}

public int updateOrder(Order order) {
    return orderDao.update(order);
}

public Order findOrderById(int id) {
    return orderDao.findById(id);
}

public Order findLastOrder() {
    return orderDao.findLast();
}

public List<Order> findAllOrders() {
    return orderDao.findAll();
}

}
课堂练习：创建四个测试类TestUserService、TestCategoryService、TestProductService与TestOrderService，编写测试方法测试四个服务类里的各个方法。

模型层的工作告一个段落，在【Java Web实训项目：西蒙购物网（中）】里做控制层的工作。

Java Web实训项目：西蒙购物网（中）

​