购物网站测试

最新推荐文章于 2024-05-29 12:24:20 发布
最新推荐文章于 2024-05-29 12:24:20 发布
阅读量2.1k 收藏 14
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IT_tan/article/details/103391913
版权

一、功能需求
1、只有注册用户成功登录之后才可查看商品类别，查看商品，选购商品，生成订单、查看订单。

2、只有管理员才有权限进入购物网后台管理，进行用户管理、类别管理、商品管理与订单管理。

二、设计思路
1、采用MVC设计模式
在这里插入图片描述
分层架构：展现层（JSP）<——>控制层（Servlet）<——>业务层（Service）<——>模型层（Dao）<——>数据库（DB）

2、前台

（1）登录——显示商品类别——显示某类商品信息——查看购物车——生成订单——支付

（2）注册<——>登录

3、后台

（1）用户管理：用户的增删改查

（2）类别管理：商品类别的增删改查

（3）商品管理：商品的增删改查

（4）订单管理：订单的查看与删除

说明：只完成了用户管理中的查看用户功能。其他功能，有兴趣的不妨拿来操练一下。

4、西蒙购物网业务流程图
在这里插入图片描述

三、实现步骤
在这里插入图片描述

（一）创建数据库
在这里插入图片描述
创建MySQL数据库simonshop，包含四张表：用户表（t_user）、类别表（t_category）、商品表（t_product）和订单表（t_order）。

1、用户表t_user

（1）表结构
在这里插入图片描述

（2）表记录

在这里插入图片描述

2、类别表t_category

（1）表结构
在这里插入图片描述

（2）表记录
在这里插入图片描述

3、商品表t_product

（1）表结构

在这里插入图片描述

（2）表记录

在这里插入图片描述

4、订单表t_order

（1）表结构
在这里插入图片描述

（2）表记录
在这里插入图片描述

（二）创建Web项目simonshop

1、创建Web项目simonshop
在这里插入图片描述

2、在项目结构窗口里设置Artifacts名称：simonshop

在这里插入图片描述

3、配置服务器（Server）

在这里插入图片描述

4、设置部署（Deployment）
在这里插入图片描述
（三）创建实体类

在src里创建net.hw.shop.bean包，创建四个实体类：User、Category、Product与Order，与四张表t_user、t_category、t_product与t_order一一对应。

1、用户实体类User
在这里插入图片描述
package net.hw.shop.bean;

/**

  • 功能：用户实体类
  • 作者：谭琮建
  • 日期：2019年12月2日
    */
    import java.util.Date;

public class User {
/**
* 用户标识符
/
private int id;
/*
* 用户名
/
private String username;
/*
* 密码
/
private String password;
/*
* 电话号码
/
private String telephone;
/*
* 注册时间
/
private Date registerTime;
/*
* 权限（0：管理员；1：普通用户）
*/
private int popedom;

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、类别实体类Category

在这里插入图片描述

package net.hw.shop.bean;

/**

  • 功能：商品类别实体类

  • 作者：谭琮建

  • 日期：2019年12月2日
    /
    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、商品实体类Product

在这里插入图片描述

package net.hw.shop.bean;

/**

  • 功能：商品实体类
  • 作者：谭琮建
  • 日期：2019年12月2日
    */
    import java.util.Date;

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、订单实体类Order
在这里插入图片描述

package net.hw.shop.bean;

/**

  • 功能：订单实体类
  • 作者：谭琮建
  • 日期：2019年12月2日
    */
    import java.util.Date;

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 +
            '}';
}

}
（四）创建数据库工具类ConnectionManager

1、在web\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);
}

}
运行程序，查看结果：
在这里插入图片描述

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

（五）数据访问接口（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月10日
    */
    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月25日
    */
    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()，结果如下：
在这里插入图片描述
测试删除testDeleteById（）
在这里插入图片描述
测试testFindByUsername（）
在这里插入图片描述
修改为没有的用户名
在这里插入图片描述
测试testFindById()
在这里插入图片描述
换一个数据库没有的ID
在这里插入图片描述
思考题：

（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()：
在这里插入图片描述
判断集合categories是否为空，可以有两种处理方式：
categories.size() > 0
!categories.isEmpty()
测试testInsert()方法
在这里插入图片描述
在这里插入图片描述
测试testDeleteById()方法
在这里插入图片描述
测试testUpdate(）方法
在这里插入图片描述
测试testFindById()方法
在这里插入图片描述
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()：
在这里插入图片描述
测试testInsert()方法
在这里插入图片描述
测试testDeleteById()方法
在这里插入图片描述
测试testUpdate()方法
在这里插入图片描述
测试testFindLast()方法
在这里插入图片描述
（七）数据访问服务类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，编写测试方法测试四个服务类里的各个方法。
在这里插入图片描述
1、创建TestUserService

package net.hw.shop.service;

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

import java.util.Date;
import java.util.List;

public class TestUserService {
    @Test
    public void addUser(){
        UserService service = new UserService();
        User user = new User();
        user.setUsername("谭琮建");
        user.setPassword("123456");
        user.setTelephone("13388456688");
        user.setRegisterTime(new Date());
        int count = service.addUser(user);
        if (count>0){
            System.out.println("恭喜，用户插入成功！");
            System.out.println(service.findUserById(service.findAllUsers().size()));
        }else {
            System.out.println("遗憾用户插入失败！");
        }
    }
    @Test
    public void deleteUserById(){
        UserService service = new UserService();
        int count =service.deleteUserById(1);
        if (count>0){
            System.out.println("恭喜，学生记录删除成功");
        }else {
            System.out.println("遗憾，学生记录删除失败");
        }
    }
    @Test
    public void  updateUser(){
        UserService service = new UserService();
        User user = service.findUserById(4);
        user.setPassword("903213");
        user.setTelephone("13945457890");
        int count = service.updateUser(user);
        if (count > 0){
            System.out.println("恭喜，用户更新成功");

        }else{
            System.out.println("遗憾，用户更新失败");
        }
        user = service.findUserById(4);
        System.out.println(user);
    }
    @Test
    public void  findUserById(){
        UserService service = new UserService();
        User user = service.findUserById(3);
        System.out.println(user);
    }

    @Test
    public void findUsersByUsername(){
        UserService service = new UserService();
        String name = "李三";
        List<User> users = service.findUsersByUsername(name);
        if (users.size()>0){
            for (User user :users){
                System.out.println(user);
            }
        }else {
            System.out.println("温馨提示：查询无此人");
        }
    }
    @Test
    public void findAllUsers(){
        UserService service = new UserService();
        List<User> users = service.findAllUsers();
        for (User user:users){
            System.out.println(user);
        }
    }
    @Test
    public void login() {
        String username, password;
        username = "admin";
        password = "12345";

        // 父接口指向子类对象
        UserService service = new UserService();
        User user = service.login(username, password);

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

测试addUser()
在这里插入图片描述
测试 deleteUserById()
在这里插入图片描述
测试updateUser()
在这里插入图片描述
测试findUserById()
在这里插入图片描述
换一个没有的id
在这里插入图片描述
测试findUsersByUsername()
在这里插入图片描述
这里我们更换一个名字
在这里插入图片描述
查询结果
在这里插入图片描述
测试findAllUsers()方法
在这里插入图片描述
测试login()方法
在这里插入图片描述
这里我们将用户名修改为ss后：
结果
在这里插入图片描述
2、创建TestCategoryService

package net.hw.shop.service;

import net.hw.shop.bean.Category;
import org.junit.Test;

import java.util.List;

public class TestCategoryService {
    @Test
    public void addCategory(){
        CategoryService categoryDao = new CategoryService();
        Category category = new Category();
        category.setId(5);
        category.setName("化妆用品");
        int count = categoryDao.addCategory(category);
        if (count>0){
            System.out.println("恭喜，商品类插入成功！");
        }else {
            System.out.println("遗憾,商品类插入失败！");
        }
    }

    @Test
    public void deleteCategoryById( ){
        CategoryService categoryDao = new CategoryService();
        int count =categoryDao.deleteCategoryById(5);
        if (count>0){
            System.out.println("恭喜，商品类删除成功");
        }else {
            System.out.println("遗憾，商品类删除失败");
        }
    }

    @Test
    public void updateCategory(){
        CategoryService categoryDao = new CategoryService();
        Category category = categoryDao.findCategoryById(1);
        category.setName("男士服装");
        int count = categoryDao.updateCategory(category);
        if (count > 0){
            System.out.println("恭喜，用户更新成功");

        }else{
            System.out.println("遗憾，用户更新失败");
        }
        category = categoryDao.findCategoryById(1);
        System.out.println(category);
    }
    @Test
    public void findCategoryById(){
        CategoryService categoryDao = new CategoryService();
        Category category = categoryDao.findCategoryById(3);
        System.out.println(category);
    }

    @Test
    public void findAllCategories(){
        CategoryService categoryDao = new CategoryService();
        List<Category> categories = categoryDao.findAllCategories();
        if (categories.size()>0){
            for (Category category: categories){
                System.out.println(category);
            }
        }else {
            System.out.println("没有商品类别！");
        }
    }
}

3、创建TestProductService

package net.hw.shop.service;

import net.hw.shop.bean.Product;
import net.hw.shop.dao.CategoryDao;
import net.hw.shop.dao.impl.CategoryDaoImpl;
import org.junit.Test;

import java.util.Date;
import java.util.List;

public class TestProductService {
    @Test
    public void testInsert(){
        ProductService service = new ProductService();
        Product product = new Product();
        product.setId(15);
        product.setName("苹果电脑");
        product.setPrice(8888.0);
        product.setAddTime(new Date());
        product.setCategoryId(1);
        int count = service.addProduct(product);
        if (count>0){
            System.out.println("恭喜，商品插入成功！");
            System.out.println(service.findProductById(service.findAllProducts().size()));
        }else {
            System.out.println("遗憾,商品类插入失败！");
        }
    }

    @Test
    public void testDeleteById(){
        ProductService service = new ProductService();
        int count =service.deleteProductById(1);
        if (count>0){
            System.out.println("恭喜，商品类删除成功");
        }else {
            System.out.println("遗憾，商品类删除失败");
        }
    }
    @Test
    public void updateProduct(){
        ProductService service = new ProductService();
        Product product =service.findProductById(1);
        product.setName("小米电视");
        product.setPrice(6666.0);
        int count = service.updateProduct(product);
        if (count > 0){
            System.out.println("恭喜，商品更新成功");

        }else{
            System.out.println("遗憾，商品更新失败");
        }
        product = service.findProductById(1);
        System.out.println(product);
    }

    @Test
    public void findProductById(){
        ProductService service = new ProductService();
        Product product = service.findProductById(3);
        System.out.println(product);
    }

    @Test
    public void findProductsByCategoryId(){
        ProductService service = new ProductService();
        int categoryId = 5;
        CategoryDao categoryDao = new CategoryDaoImpl();
        if (categoryDao.findById(categoryId)!=null) {
            String categoryName = categoryDao.findById(categoryId).getName();
            List<Product> products = service.findProductsByCategoryId(categoryId);
            if(!products.isEmpty()){
                for (Product product : products){
                    System.out.println(product);
                }
            }else {
                System.out.println("["+categoryName+"]类别没有商品！");
            }
        }else {
            System.out.println("["+categoryId+"]不存在！");
        }
    }

    @Test
    public void findAllProducts(){
        ProductService service = new ProductService();
        List<Product> products = service.findAllProducts();
        if (products.size()>0){
            for (Product product:products ){
                System.out.println(product);
            }
        }else {
            System.out.println("类别没有商品！");
        }
    }
}

4、创建TestOrderService

package net.hw.shop.service;

import net.hw.shop.bean.Order;
import org.junit.Test;

import java.util.Date;
import java.util.List;

public class TestOrderService {
    @Test
    public void addOrder(){
        OrderService service = new OrderService();
        Order order = new Order();
        order.setId(3);
        order.setUsername("李明");
        order.setTelephone("13419854562");
        order.setTotalPrice(0.0);
        order.setDeliveryAddress("泸职院信息工程系");
        order.setOrderTime(new Date());
        int count = service.addOrder(order);
        if (count>0){
            System.out.println("恭喜，订单插入成功！");
            System.out.println(service.findOrderById(service.findAllOrders().size()));
        }else {
            System.out.println("遗憾,订单插入失败！");
        }
    }
    @Test
    public void deleteOrderById(int id){
        OrderService service = new OrderService();
        int count =service.deleteOrderById(3);
        if (count>0){
            System.out.println("恭喜，订单删除成功");
        }else {
            System.out.println("遗憾，订单删除失败");
        }
    }

    @Test
    public void updateOrder( ){
        OrderService service = new OrderService();
        Order order = service.findOrderById(1);
        order.setUsername("王二");
        int count = service.updateOrder(order);
        if (count > 0){
            System.out.println("恭喜，用户更新成功");

        }else{
            System.out.println("遗憾，用户更新失败");
        }
        order = service.findOrderById(1);
        System.out.println(order);
    }
    @Test
    public void findOrderById(){
        OrderService service = new OrderService();
        Order order = service.findOrderById(3);
        System.out.println(order);
    }

    @Test
    public void findLastOrder(){
        OrderService service = new OrderService();
        Order order = service.findLastOrder();
        System.out.println(order);
    }

    @Test
    public void findAllOrders(){
        OrderService service = new OrderService();
        List<Order> orders=service.findAllOrders();
        if (orders.size()>0){
            for (Order order:orders){
                System.out.println(order);
            }
        }else {
            System.out.println("没有订单!");
        }
    }
}
IT_tan
关注
Java Web实训项目：西蒙购物网（上）
howard2005的专栏
12-02 3977
文章目录 一、功能需求 1、普通用户 2、管理员用户 二、设计思路 （一）采用MVC设计模式 （二）前台购物 1、购物流程 2、用户注册 （三）后台管理 1、用户管理 2、类别管理 3、商品管理 4、订单管理 （四）西蒙购物网业务流程图 三、实现步骤 （一）创建数据库 1、用户表t_user 2、类别表t_category 3、商品表t_product ...
购物网站（测试+步骤+代码）
xuyandics的博客
12-28 5329
一、功能需求 1、只有注册用户成功登录之后才可查看商品类别，查看商品，选购商品，生成订单、查看订单。 2、只有管理员才有权限进入购物网后台管理，进行用户管理、类别管理、商品管理与订单管理。 二、设计思路 1、采用MVC设计模式 分层架构：展现层（JSP）<——>控制层（Servlet）<——>业务层（Service）<——>模型层（Dao）<——>数据库（DB） 2、前台 （1）登录——显示商品类别——显示某类商品信息——查看购物车——生成订单——支付
软件测试——购物网站毕业设计，性能测试
02-22
毕业设计，关于自己开发的购物网站进行的软件测试，其中包括界面测试、功能测试、性能测试（Jmeter Badboy）、安全性测试（safewvs3）。文件中包含网站程序源码和数据库脚本，还有Jmeter测试的脚本。以及本人的呕心沥血之作——毕业论文 里面有使用文档，如果下载之后打不开，可以加QQ：1765311383 （请下载之后的人有问题的人，再加，闲人勿扰。很忙）
购物网站测试（二）
IT_tan的博客
12-11 1170
（八）控制层（XXXServlet） 1、登录处理类LoginServlet package net.hw.shop.servlet; /** 功能：登录处理类 日期：2019年12月11日 */ import java.io.IOException; import javax.servlet.ServletException; import javax.servlet.annotation...
购物网站测试实例（含代码）
01-05
一个购物网站的测试实例。里面含有代码。希望多下载。
网上购物系统 测试用例
weixin_52558677的博客
02-06 3157
2.输入正确的用户名和密码后，检查登录成功跳转到新页面的时间是否在需求要求的时间内。1.打开登录页面，需要的时间是否在需求要求的时间内。注册功能测试用例设计：（Xmind图形式）登录功能测试用例设计：（Xmind图形式）1.输入任意信息点击搜索跳转到搜索结果界面。2.对输入的邮箱和手机号进行验证是否可用。2.判断输入的邮箱和手机号是否规范。2.在搜索结果界面可以进行全站搜索。2.不输入信息点击搜索页面不跳转。5.账号密码都为空时点击登录。3.账号为空时点击登录。4.账号错误时点击登录。
网上购物系统测试总结报告.pdf
05-07
网上购物系统测试总结报告.pdf网上购物系统测试总结报告.pdf网上购物系统测试总结报告.pdf网上购物系统测试总结报告.pdf网上购物系统测试总结报告.pdf
软件测试 网上购物系统测试.pdf
06-17
网上购物系统测试是软件开发过程中不可或缺的一环，其目的是确保系统的功能正确性、性能稳定性以及用户友好性。在测试过程中，我们需要关注多个方面，包括需求分析、测试策略、测试用例设计、缺陷管理以及安全性和...
商城购物系统软件测试,网上商城购物系统黑盒测试
weixin_34081203的博客
07-22 6103
《网上商城购物系统黑盒测试》由会员分享，可在线阅读，更多相关《网上商城购物系统黑盒测试(7页珍藏版)》请在人人文库网上搜索。1、网上商城购物系统黑盒测试一、目的和意义软件测试是软件工程中非常重要的环节，是软件质量的保证。该课程是培养训练学生软件质量保证能力的重要实践性教学环节，与软件测试技术课程的教学内容紧密配合，同步进行。通过软件测试的实践训练，深刻理解和掌握软件测试和软件测试过程的基本方法和基...
网上购物系统测试计划书
04-19
网上购物系统软件测试的计划书，不是特别详细，但可以参考
购物网站代码
05-17
jsp+mysql+tomcat写的购物网站，此代码可直接运行，包含数据库SQL文件
购物网站全部代码
11-14
简单购物网站的源代码，有基本的功能，学习网站开发可以下载参考
购物网站源码
04-01
本源码是一个三层购物网站源码，功能齐全，界面美观简洁，非常适合二次开发和学习，欢迎下载
网上购物软件的测试计划,网上购物平台购物测试计划书
weixin_28813803的博客
07-22 881
这是在学习软件测试自己写的软件测试计划书,可以让大家参考一下。目录(一)简介....................................................................................................................................... 3 1. 目的 .....................
PHP购物网站（含购物车、全部源码、数据库设计表及其源码）
热门推荐
ninnyyan的博客
04-24 6万+
声明！留下邮箱号即可，回复不及时声明！最近几个月，不断地有站友向我索要完整的代码，其实之前我是全部粘贴到博客里供大家参考交流的。之所以删掉一部分，是因为有一些网站全盘照抄并标明为原创，以抄袭获取流量甚至盈利，违背了我的初衷。如果还有站友想要源代码，请在这篇博客下留下自己的联系方式。但是再次声明，之前和今后私下从我这里以任何方式要走的代码，都不能用作商业用途！请勿转载！这是我在研究生期间，老师要求做的一个类似原始淘宝网的购物网站，因为不会PHP，为了写这个作业而新学的。
商城测试项目流程
最新发布
weixin_57138664的博客
05-29 441
商城测试项目流程
购物网站测试用例性能测试
05-27
购物网站测试用例性能测试一般包括以下几个方面： 1. 压力测试：通过模拟多个用户同时访问购物网站，并逐步增加并发用户数，测试购物网站的承载能力和稳定性，确保在高并发情况下，购物网站仍能正常运行。 2. 负载...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值