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

XZXHSCQ

已于 2023-06-14 18:02:48 修改

阅读量111

点赞数

文章标签： java 前端单元测试

于 2023-06-14 15:29:42 首次发布

本文链接：https://blog.csdn.net/jjjhju/article/details/131208939

版权

西蒙购物网
一、网站功能需求
二、网站设计思路
(一)、设计模式
(二)、网站前台
（三）网站后台
1、用户管理
2、类别管理
3、商品管理
4、订单管理
（四）购物流程图
三、网站实现步骤
（一）创建数据库与表
1、创建数据库
2、创建用户表
3、创建类别表
4、创建商品表
5、创建订单表
（二）创建Web项目
1、创建Web项目
2、修改Artifact名称
3、重新部署项目
4、编辑首页
5、启动应用，查看效果
（三）创建实体类
1、创建用户实体类
2、创建类别实体类
3、创建商品实体类
4、创建订单实体类
（四）创建数据库工具类
1、添加数据库驱动程序包
2、创建数据库连接管理类
3、测试数据库连接是否成功
（五）创建数据访问接口
1、创建用户数据访问接口
2、创建类别数据访问接口
3、创建商品数据访问接口
4、创建订单数据访问接口
（六）创建数据访问接口实现类
1、创建用户数据访问接口实现类
（1）编写插入用户方法
（2）编写按标识符删除用户方法
（3）编写更新用户方法
（4）编写按标识符查询用户方法
（5）编写按用户名查询用户方法
（6）编写查询全部用户方法
（7）编写登录方法
1_、对用户数据访问接口实现类做单元测试
（1）编写测试登录方法
（2）编写按标识符查询用户方法
（3）编写按用户名查询用户方法
（4）编写查询全部用户方法
（5）编写测试插入用户方法
（6）编写测试更新用户方法
（7）编写测试按标识符删除用户方法
2、创建类别数据访问接口实现类
3、编写商品数据访问接口实现类
4、创建订单数据访问接口实现类
（七）创建数据访问服务类
一、网站功能需求
1、只有注册用户成功登录后才可查看商品类别，查看商品，选购商品，生成订单、查看订单
2、只有管理员才有权限进入购物网后台管理（用户管理 + 类别管理 + 商品管理 + 订单管理）

二、网站设计思路
(一)、设计模式
分层架构：展现层（JSP）<——>控制层（Controller）<——>业务层（Service）<——>数据访问层（Dao）<——>数据库（DB
(二)、网站前台
登录——显示商品类别——显示某类商品信息——查看购物车——生成订单——支付
注册<——>登录
（三）网站后台
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;

1
2
3
4
5
6
7
8
9
10
在用户表里插入记录

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’);

1
2
3
4
5
查看用户表

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;

1
2
3
4
5
6
在类别表里插入记录

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

1
2
3
4
5
查看类别表记录

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;

1
2
3
4
5
6
7
8
9
在商品表里插入记录

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’);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
查看商品表记录

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;

1
2
3
4
5
6
7
8
9
10
在订单表里插入记录

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’);

1
2
3
查看订单表记录

（二）创建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” %>

首页

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

<%= new Date()%>

跳转到登录页面

1
2
3
4
5
6
7
8
9
10
11
12
13
5、启动应用，查看效果
启动服务器，显示首页

（三）创建实体类
创建四个实体类：User、Category、Product与Order，与四张表t_user、t_category、t_product与t_order一一对应。ORM（Object Relation Mapping）——对象关系映射。
1、创建用户实体类
创建net.zwq.shop.bean包，在包里创建User类

package net.zwq.shop.bean;

import java.util.Date;

/**

功能：用户实体类
作者：zwq
日期：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 +
‘}’;
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
2、创建类别实体类
在net.huawei.shop.bean包里创建Category类

package net.zwq.shop.bean;

/**

功能：类别实体类
作者：zwq
日期：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 + ‘’’ +
‘}’;
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
3、创建商品实体类
在net.huawei.shop.bean包里创建Product类

package net.zwq.shop.bean;

import java.util.Date;

/**

功能：商品实体类
作者：zwq
日期：2023年05月029日
*/
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 +
‘}’;
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
4、创建订单实体类
在net.huawei.shop.bean包里创建Order类

package net.zwq.shop.bean;

import java.util.Date;

/**

功能：订单实体类
作者：zwq
日期：2023年05月029日
*/
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
（四）创建数据库工具类
1、添加数据库驱动程序包
在\WEB-INF里创建lib子目录，添加MySQL驱动程序的jar包

将数据库驱动程序包作为库添加到项目

2、创建数据库连接管理类
创建net.huawei.shop.dbutil包，在里面创建ConnectionManager类
package net.zwq.shop.dbutil;

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

/**

功能：数据库连接管理类
作者：zwq
日期：2023年05月19日
*/
public class ConnectionManager {
private static final String DRIVER = “com.mysql.jdbc.Driver”; // 数据库驱动程序
private static final String URL = “jdbc:mysql://localhost:3306/simonshop?useSSL=false&useUnicode=true&characterEncoding=utf8”; // 数据库统一资源标识符
private static final String USER = “root”; // 数据库用户
private static final String PASSWORD = “903213”; // 数据库密码（记住改成自己的数据库密码）

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

// 获取数据库连接静态方法
public static Connection getConnection() {
// 定义数据库连接
Connection conn = null;
```
 try {
     // 安装数据库驱动程序
     Class.forName(DRIVER);
     // 获取数据库连接
     conn = DriverManager.getConnection(URL, USER, PASSWORD);
 } catch (ClassNotFoundException e) {
     System.err.println(e.getMessage());
 } catch (SQLException e) {
     System.err.println(e.getMessage());
 }

 // 返回数据库连接
 return conn;
```
}

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

public static void main(String[] args) {
// 获取数据库连接
Connection conn = getConnection();
// 判断数据库连接是否成功
if (conn != null) {
System.out.println(“恭喜，数据库连接成功~”);
} else {
System.out.println(“遗憾，数据库连接失败~”);
}
// 关闭数据库连接
closeConnection(conn);
System.out.println(“数据库连接已经关闭~”);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
3、测试数据库连接是否成功
运行程序，查看结果

（五）创建数据访问接口
1、创建用户数据访问接口
在net.zwqi.shop根包里创建dao子包，在子包里创建UserDao接口

package net.zwq.shop.dao;

import net.zwq.shop.bean.User;

import java.util.List;

/**

功能：用户数据访问接口
作者：zwq
日期：2023年05月29日
*/
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); // 用户登录
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2、创建类别数据访问接口
在net.huawei.shop.dao包里创建CategoryDao接口

package net.zwq.shop.dao;

import net.zwq.shop.bean.Category;

import java.util.List;

/**

功能：类别数据访问接口
作者：zwq
日期：2023年05月29日
*/
public interface CategoryDao {
int insert(Category category); // 插入类别
int deleteById(int id); // 按标识符删除类别
int update(Category category); // 更新类别
Category findById(int id); // 按标识符查询类别
List findAll(); // 查询全部类别
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
3、创建商品数据访问接口
在net.zwq.shop.dao包里创建ProductDao接口

package net.zwq.shop.dao;

import net.zwq.shop.bean.Product;

import java.util.List;

/**

功能：商品数据访问接口
作者：zwq
日期：2023年05月29日
*/
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(); // 查询全部商品
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
4、创建订单数据访问接口
在net.zwq.shop.dao包里创建OrderDao接口

package net.huawei.shop.dao;

import net.huawei.shop.bean.Order;

import java.util.List;

/**

功能：订单数据访问接口
作者：华卫
日期：2023年05月29日
*/
public interface OrderDao {
int insert(Order order); // 插入订单
int deleteById(int id); // 按标识符删除订单
int update(Order order); // 更新订单
Order findById(int id); // 按标识符查询订单
Order findLast(); // 查询最后一个订单
List findAll(); // 查询全部订单
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
（六）创建数据访问接口实现类
1、创建用户数据访问接口实现类
在net.zwq.shop.dao包里创建impl子包，在子包里创建UserDaoImpl类

实现UserDao接口

（1）编写插入用户方法
@Override // 插入用户
public int insert(User user) {
// 定义插入记录数
int count = 0;

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

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
（2）编写按标识符删除用户方法
@Override // 按标识符删除用户
public int deleteById(int id) {
// 定义删除记录数
int count = 0;

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

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
（3）编写更新用户方法
@Override // 更新用户
public int update(User user) {
// 定义更新记录数
int count = 0;

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

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
（4）编写按标识符查询用户方法
@Override // 按标识符查询用户
public User findById(int id) {
// 定义查询用户
User user = null;

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

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
（5）编写按用户名查询用户方法
@Override // 按用户名查询用户
public List findByUsername(String username) {
// 定义用户列表
List users = new ArrayList<>();

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

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
（6）编写查询全部用户方法
@Override // 查询全部用户
public List findAll() {
// 定义用户列表
List users = new ArrayList<>();

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

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
（7）编写登录方法
@Override // 登录方法
public User login(String username, String password) {
// 定义查询用户
User user = null;

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

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
按 + + <-> 收拢代码
1_、对用户数据访问接口实现类做单元测试
我们需要对用户数据访问接口实现类的各个方法进行单元测试，采用JUnit来进行单元测试。
在项目根目录创建一个test文件夹，然后在项目结构窗口里将其标记为"Tests"，这样文件夹颜色变成绿色。

于是项目里有了一个绿色的测试文件夹 - test

在test文件夹里创建net.zwq.shop.dao.impl包，在里面创建TestUserDaoImpl类

（1）编写测试登录方法
给测试方法添加@Test注解，会报错

添加单元测试JUnit到项目，将光标移到@Test注解上，按 Alt + Enter组合键

单击【Add ‘JUnit4’ to classpath】

单击【OK】按钮

package net.zwq.shop.dao.impl;

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

/**

功能：测试用户数据访问接口实现类
作者：华卫
日期：2023年06月01日
*/
public class TestUserDaoImpl {
@Test // 测试登录方法
public void testLogin() {
// 定义用户名和密码
String username = “admin”;
String password = “12345”;
// 创建用户数据访问接口对象
UserDao userDao = new UserDaoImpl(); // 用父接口变量指向子类对象
// 调用用户数据访问接口对象的登录方法
User user = userDao.login(username, password);
// 判断用户是否登录成功
if (user != null) { // 成功
System.out.println(“恭喜，” + username + “，登录成功~”);
} else { // 失败
System.out.println(“遗憾，” + username + “，登录失败~”);
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
z运行testLogin()方法，查看结果

修改登录密码，再进行单元测试，会显示登录失败

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
运行testFindById()方法，查看结果

修改标识符变量，再运行测试方法，查看结果

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
运行testFindByUsername()方法，查看结果
-修改待查用户名，再运行测试方法，查看结果

（4）编写查询全部用户方法
@Test // 测试查询全部用户
public void testFindAll() {
// 创建用户数据访问接口对象
UserDao userDao = new UserDaoImpl();
// 调用用户数据访问接口对象的查询全部用户方法
List users = userDao.findAll();
// 判断是否有用户
if (users.size() > 0) { // 有用户
users.forEach(user -> System.out.println(user));
} else { // 没有用户
System.out.println(“用户表里没有记录~”);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
运行testFindAll()方法，查看结果
（5）编写测试插入用户方法
@Test // 测试插入用户
public void testInsert() {
// 创建用户对象
User user = new User();
// 设置用户对象属性
user.setUsername(“萌萌哒”);
user.setPassword(“444444”);
user.setTelephone(“15890456780”);
user.setRegisterTime(new Date());
user.setPopedom(1);
// 创建用户数据访问接口对象
UserDao userDao = new UserDaoImpl();
// 调用用户数据访问接口对象的插入用户方法
int count = userDao.insert(user);
// 判断是否成功插入用户
if (count > 0) { // 成功
System.out.println(“恭喜，插入用户记录成功~”);
} else { // 失败
System.out.println(“遗憾，插入用户记录失败~”);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
在Navitcat里查看用户表

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
在Navicat里查看用户表

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
在Navicat里查看用户表，看还有没有id = 5的用户记录

2、创建类别数据访问接口实现类
3、编写商品数据访问接口实现类
4、创建订单数据访问接口实现类
（七）创建数据访问服务类

XZXHSCQ

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java Web实训项目：西蒙购物网

VALUES (‘2’, ‘郑晓红’, ‘11111’, ‘13956567889’, ‘2022-12-20 09:51:43’, ‘1’);VALUES (‘3’, ‘温志军’, ‘22222’, ‘13956678907’, ‘2022-12-20 09:52:36’, ‘1’);分层架构：展现层（JSP）控制层（Controller）业务层（Service）数据访问层（Dao）数据库（DB。// 数据库驱动程序。// 数据库密码（记住改成自己的数据库密码）
复制链接

扫一扫