精华内容
下载资源
问答
  • Web开发 实训项目 网上书店 Web开发 实训项目 网上书店
  • Java Web实训项目:西蒙购物网(下)

    千次阅读 2019-12-14 16:57:16
  • web目录里创建images目录,存放项目所需图片文件: 二、创建CSS样式文件: 在web目录里常见css子目录,在里面创建main.css文件: 三、创建JavaScript脚本文件: 在web目录里创建scripts子目录,在里面创建...

    一、准备图片资源

    web目录里创建images目录,存放项目所需图片文件:

    二、创建CSS样式文件:

    web目录里常见css子目录,在里面创建main.css文件:

    三、创建JavaScript脚本文件:

    web目录里创建scripts子目录,在里面创建check.js文件:

    四、添加JSTL的jar包

    WEB-INF\lib目录里添加支持jstljar包:

    五、展现层页面

    1、登录页面login.jsp

    web.xml文件里将login.jsp设置为首页文件:

    重启服务器:

    不输入用户名与密码,单击【登录】按钮:

    输入用户名,但不输入密码,单击【登录】按钮:

     

    输入管理员用户名与密码:admin12345:

    我们去服务器端控制台查看输出信息:

    重启服务器,再以普通用户登录:冯天豪,666666然后登陆

    去服务器端控制台查看输出信息:

    重启服务器,输入错误的用户名或密码:李文丽12340

    单击【登录】按钮,弹出消息框:用户名或密码错误!

    单击【确定】按钮,返回登录页面:

    2、注册页面register.jsp

    启动服务器:

     

    什么也不输入,单击【注册】按钮:

    输入用户名,单击【注册】按钮:

    输入用户名、密码和电话,单击【注册】按钮

    单击【确定】按钮,跳转到登录页面:

    打开用户表,查看新添加的用户:

    3、显示商品类别页面showCategory.jsp

    启动服务器,显示登录页面,输入普通用户:冯天豪,666666

    单击【登录】按钮,跳转到显示商品类别页面:

    单击【家用电器】超链接:

    去服务器端控制台查看输出信息:

    返回到刚才显示商品类别页面,单击【注销】超链接,返回登录页面:

    4、显示购物车页面showCart.jsp

    这个页面要包含在显示商品页面里,因此没有导入CSS样式文件。
    重启服务器,以普通用户登录后,访问http://localhost:8080/simonshop/frontend/showCart.jsp

    5、显示商品页面showProduct.jsp

    启动服务器,显示登录页面,输入普通用户:冯天豪,666666

    单击【登录】按钮,跳转到显示商品类别页面:

    单击【家用电器】超链接:

    如果类别名没有显示出来,页面跳转了,但是类别名没有传递成功。
    修改ShowProductServlet,将类别名放在session里,而不是通过url传递参数。

    重启服务器,登录成功后,选择【家用电器】类别:

    下面测试加入购物车操作:

    同一件商品可以多次加入购物车,也可以从购物车删除掉选购的商品。如果一件商品加入购物车的数量大于1,那么执行一次删除操作就是让购物车该商品数量减少1,直到减为0,即购物车里删除掉该商品。

    6、生成订单页面makeOrder.jsp

    7、显示订单页面showOrder.jsp

    下面我们来测试生成订单与显示订单页面。
    重启服务器,以普通用户登录,选择【家用电器】类商品,在显示商品页面,将一些商品加入购物车,查看购物车情况:

    单击【生成订单】超链接,跳转到【生成订单】页面:

    单击【确定】按钮,返回登录页面:

    8、后台管理主页面management.jsp

    9、后台管理主页面左面板页面left.jsp

    10、后台管理主页面顶面板页面top.jsp

    11、后台管理主页面主面板页面main.jsp

    重启服务器,以管理员身份登录(admin12345)进入后台管理页面:

     

    11、查看用户页面showUser.jsp

    重启服务器,以管理员身份登录,进入后台管理页面,查看用户:

    13、待做页面todo.jsp

    重启服务器,以管理员身份登录,单击【添加用户】:

    展开全文
  • Java Web实训项目:西蒙购物园

    千次阅读 2019-12-05 20:22:30
    (二)创建Web项目simonshop web项目创建过程 (三)创建实体类 在src里创建net.gongjing.shop.bean包,创建四个实体类:User、Category、Product与Order,与四张表t_user、t_category、t_product与t_order...

    一、功能需求

    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

    表结构,表记录

    在这里插入图片描述
    在这里插入图片描述

    2、类别表t_category

    表结构,表记录

    在这里插入图片描述
    在这里插入图片描述

    3、商品表t_product

    表结构,表记录

    在这里插入图片描述
    在这里插入图片描述

    4、订单表t_order

    表结构,表记录

    在这里插入图片描述
    在这里插入图片描述

    ps:数据库命令文件

    数据库命令文件

    (二)创建Web项目simonshop

    在这里插入图片描述
    web项目创建过程

    (三)创建实体类

    在src里创建net.gongjing.shop.bean包,创建四个实体类:User、Category、Product与Order,与四张表t_user、t_category、t_product与t_order一一对应。
    在这里插入图片描述

    1、用户实体类User

    package net.gongjing.shop.bean;
    
    /**
     * 功能:用户实体类
     * 作者:gongjing
     * 日期:2019年12月5日
     */
    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.gongjing.shop.bean;
    
    /**
     * 功能:商品类别实体类
     * 作者:gongjing
     * 日期:2019年12月5日
     */
    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.gongjing.shop.bean;
    
    /**
     * 功能:商品实体类
     * 作者:gongjing
     * 日期:2019年12月5日
     */
    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.gongjing.shop.bean;
    
    /**
     * 功能:订单实体类
     * 作者:gongjing
     * 日期:2019年12月5日
     */
    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包

    在这里插入图片描述
    MySQL驱动程序的jar包

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

    在这里插入图片描述

    package net.gongjing.shop.dbutil;
    
    /**
     * 功能:数据库连接管理类
     * 作者:gongjing
     * 日期:2019年12月5日
     */
    
    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 = "gongjing";
    
        /**
         * 私有化构造方法,拒绝实例化
         */
        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);
        }
    }
    

    运行结果如下
    在这里插入图片描述

    (五)数据访问接口(XXXDao)

    在src里创建net.hw.shop.dao包,在里面创建UserDao、CategoryDao、ProductDao与OrderDao。

    1、用户数据访问接口UserDao

    package net.gongjing.shop.dao;
    
    /**
     * 功能:用户数据访问接口
     * 作者:gongjing
     * 日期:2019年12月5日
     */
    import java.util.List;
    
    import net.gongjing.shop.bean.User;
    
    public interface UserDao {
        // 插入用户
        int insert(User user);
        // 按标识符删除用户
        int deleteById(int id);
        // 更新用户
        int update(User user);
        // 按标识符查询用户
        User findById(int id);
        // 按用户名查询用户
        List<User> findByUsername(String username);
        // 查询全部用户
        List<User> findAll();
        // 用户登录
        User login(String username, String password);
    }
    

    2、类别数据访问接口CategoryDao

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

    3、商品数据访问接口ProductDao

    package net.gongjing.shop.dao;
    
    /**
     * 功能:商品数据访问接口
     * 作者:gongjing
     * 日期:2019年12月5日
     */
    import java.util.List;
    
    import net.gongjing.shop.bean.Product;
    
    public interface ProductDao {
        // 插入商品
        int insert(Product product);
        // 按标识符删除商品
        int deleteById(int id);
        // 更新商品
        int update(Product product);
        // 按标识符查询商品
        Product findById(int id);
        // 按类别查询商品
        List<Product> findByCategoryId(int categoryId);
        // 查询全部商品
        List<Product> findAll();
    }
    

    4、订单数据访问接口OrderDao

    package net.gongjing.shop.dao;
    
    /**
     * 功能:订单数据访问接口
     * 作者:华卫
     * 日期:2019年12月2日
     */
    import java.util.List;
    
    import net.gongjing.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<Order> findAll();
    }
    

    (六)数据访问接口实现类XXXDaoImpl

    在src下创建net.hw.shop.dao.impl包,在里面创建UserDaoImpl、CategoryDaoImpl、ProductDaoImpl与OrderDaoImpl。
    在这里插入图片描述

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

    package net.gongjing.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.gongjing.shop.bean.User;
    import net.gongjing.shop.dao.UserDao;
    import net.gongjing.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",这样文件夹颜色变成绿色。
    在这里插入图片描述
    在这里插入图片描述

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

    package test.net.gongjing.shop.dao.impl;
    
    import net.gongjing.shop.bean.User;
    import net.gongjing.shop.dao.UserDao;
    import net.gongjing.shop.dao.impl.UserDaoImpl;
    import org.junit.Test;
    
    import java.util.Date;
    import java.util.List;
    
    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("遗憾,登录失败!");
            }
        }
        @Test
        public void testUpdate() {
            //定义用户数据访问对象
            UserDao userDao = new UserDaoImpl();
            //找到id为4的用户[涂文艳]
            User user = userDao. findById(4);
            //修改用户密码与电话
            user. setPassword( "903213");
            user. setTelephone( "13945457890");
            //利用用户数据访问对象的更新方法更新用户
            int count = userDao . update(user);
            //判断更新用户是否成功
            if (count > 0) {
                System. out . println("恭喜,用户更新成功! ");
            } else {
                System. out . println("遗憾,用户更新失败! ");
            }
            // 再次查询id为4的用户
            user = userDao. findById(4);
            //输出该用户的信息
            System. out . println(user);
        }
        //插入
        @Test
        public void testInsert(){
            UserDao userDao = new UserDaoImpl();
            User user = new User();
    
            user.setUsername("ZJY");
            user.setPassword("123456");
            user.setTelephone("13378323305");
            user.setRegisterTime(new Date());
            user.setPopedom(1);
    
            int count = userDao.insert(user);
            if (count > 0){
                System.out.println("恭喜,用户插入成功");
            }else {
                System.out.println("遗憾,用户插入失败");
            }
        }
    
        //删除
    
        @Test
        public void testDeleteById(){
            UserDao userDao = new UserDaoImpl();
    
            int count = userDao.deleteById(2);
            if (count > 0){
                System.out.println("恭喜,用户删除成功");
            }else {
                System.out.println("遗憾,用户删除失败");
            }
        }
        //按用户名查询
        @Test
        public void testFindByUsername(){
            String username;
            username = "123456";
    
            UserDao userDao = new UserDaoImpl();
            List<User> user = userDao.findByUsername(username);
            if (user != null){
                System.out.println("查询成功");
                System.out.println(user);
    
            }else {
                System.out.println("查询失败");
            }
        }
        //查询全部
        @Test
        public void testFindAll(){
            UserDao userDao = new UserDaoImpl();
            List<User> users = userDao.findAll();
            if (!users.isEmpty()){
                System.out.println("查询成功");
            }else {
                System.out.println("查询失败");
            }
        }
    
        @Test
        public void testFindById(){
            UserDao userDao = new UserDaoImpl();
            User user = userDao.findById(10);
            if (user == null){
                System.out.println("查询失败");
            }else {
                System.out.println("查询成功");
                System.out.println(user);
            }
        }
    
    }
    

    各自运行结果
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

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

    package net.gongjing.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.gongjing.shop.bean.Category;
    import net.gongjing.shop.dao.CategoryDao;
    import net.gongjing.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;
        }
    }
    
    

    测试代码

    package test.net.gongjing.shop.dao.impl;
    
    import net.gongjing.shop.bean.Category;
    import net.gongjing.shop.dao.CategoryDao;
    import net.gongjing.shop.dao.impl.CategoryDaoImpl;
    import org.junit.Test;
    
    import java.util.List;
    
    public class TestCategoryDaoImpl {
        @Test
        public void testFindAll(){
            CategoryDao categoryDao = new CategoryDaoImpl();
            List<Category> categories = categoryDao.findAll();
            //判断是否有类别
            //判断集合是否为空有两种方式  size()>0    isEmpty()
            if(!categories.isEmpty()){
                for (Category category: categories){
                    System.out.println(category);
                }
            }else {
                System.out.println("没有商品类别!");
            }
        }
    
        @Test
        public void testFindById(){
            CategoryDao categoryDao = new CategoryDaoImpl();
            Category category = categoryDao.findById(3);
            if (category == null){
                System.out.println("查询失败");
            }else {
                System.out.println("查询成功");
                System.out.println(category);
            }
    
        }
    
        @Test
        public void testUpdate(){
            CategoryDao categoryDao = new CategoryDaoImpl();
            Category category = categoryDao.findById(3);
    
            category.setName("不实用电器");
            int count = categoryDao.update(category);
            if (count > 0){
                System.out.println("更新成功");
                System.out.println(category);
            }else {
                System.out.println("更新失败");
            }
    
    
        }
    
        @Test
        public void testDelete(){
            CategoryDao categoryDao = new CategoryDaoImpl();
            int count  = categoryDao.deleteById(2);
            if (count > 0){
                System.out.println("删除成功");
            }else {
                System.out.println("删除失败");
            }
        }
    
        @Test
        public void testInsert(){
            CategoryDao categoryDao = new CategoryDaoImpl();
            Category category = new Category();
    
            category.setName("实用工具");
            int count = categoryDao.insert(category);
            if (count > 0){
                System.out.println("插入成功");
            }else {
                System.out.println("插入失败");
            }
        }
    }
    

    测试结果不予展示,自行测试

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

    package net.gongjing.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.gongjing.shop.bean.Product;
    import net.gongjing.shop.dao.ProductDao;
    import net.gongjing.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;
        }
    }
    
    

    测试代码

    package test.net.gongjing.shop.dao.impl;
    
    import net.gongjing.shop.bean.Category;
    import net.gongjing.shop.bean.Product;
    import net.gongjing.shop.bean.User;
    import net.gongjing.shop.dao.CategoryDao;
    import net.gongjing.shop.dao.ProductDao;
    import net.gongjing.shop.dao.UserDao;
    import net.gongjing.shop.dao.impl.CategoryDaoImpl;
    import net.gongjing.shop.dao.impl.ProductDaoImpl;
    import org.junit.Test;
    
    import java.util.Date;
    import java.util.List;
    
    public class TestProductDaoImpl {
        @Test
        public void testUpdate(){
            ProductDao productDao = new ProductDaoImpl();
    
            Product product = productDao.findById(3);
           product.setName("Yaa");
            int count = productDao.update(product);
            if (count > 0){
                System.out.println("恭喜,用户更新成功");
            }else {
                System.out.println("遗憾,用户更新失败");
            }
    
        }
        //按类别
        @Test
        public void testFindByCategoryId(){
            //创建商品数据访问对象
            ProductDao productDao = new ProductDaoImpl();
    
            int categoryId = 5;
            CategoryDao categoryDao = new CategoryDaoImpl();
    
            if (categoryDao.findById(categoryId) != null){
                String categoryName = categoryDao.findById(categoryId).getName();
                List<Product> products = productDao.findByCategoryId(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 testFindAll(){
            ProductDao productDao = new ProductDaoImpl();
            List<Product> products = productDao.findAll();
            //判断是否有类别
            //判断集合是否为空有两种方式  size()>0    isEmpty()
            if(!products.isEmpty()){
                for (Product product: products){
                    System.out.println(product);
                }
            }else {
                System.out.println("没有商品类别!");
            }
        }
        @Test
        public void testInsert(){
            ProductDao productDao = new ProductDaoImpl();
            Product product =  new Product();
    
            product.setName("学习办公123");
            product.setAddTime(new Date());
            product.setCategoryId(1);
            product.setPrice(200);
            int count = productDao.insert(product);
            if (count > 0){
                System.out.println("插入成功");
            }else {
                System.out.println("插入失败");
            }
        }
        @Test
        public void testFindById(){
            ProductDao productDao = new ProductDaoImpl();
            Product product = productDao.findById(1);
                if (product == null){
                System.out.println("查询失败");
            }else {
                System.out.println("查询成功");
                    System.out.println(product);
            }
    
        }
    
        @Test
        public void testDelete(){
            ProductDao productDao = new ProductDaoImpl();
            int count  = productDao.deleteById(100);
            if (count > 0){
                System.out.println("删除成功");
            }else {
                System.out.println("删除失败");
    

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

    package net.gongjing.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.gongjing.shop.bean.Order;
    import net.gongjing.shop.dao.OrderDao;
    import net.gongjing.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;
        }
    }
    
    

    测试代码

    package test.net.gongjing.shop.dao.impl;
    
    import com.sun.org.apache.xpath.internal.operations.Or;
    import net.gongjing.shop.bean.Order;
    import net.gongjing.shop.dao.OrderDao;
    import net.gongjing.shop.dao.impl.OrderDaoImpl;
    import org.junit.Test;
    
    import java.util.Date;
    import java.util.List;
    
    public class TestOrderService {
        @Test
        public void testFindAll(){
            OrderDao orderDao = new OrderDaoImpl();
    
            List<Order> orders = orderDao.findAll();
            if (orders.size() > 0 ){
                for (Order order: orders){
                    System.out.println(order);
                }
            }else {
                System.out.println("没有订单!");
            }
        }
    
        @Test
        public void testUpdate(){
            OrderDao orderDao = new OrderDaoImpl();
    
            Order order = orderDao.findById(3);
            order.setUsername("ZZJJYY");
    
            int count = orderDao.update(order);
            if (count > 0){
                System.out.println("恭喜,用户更新成功");
            }else {
                System.out.println("遗憾,用户更新失败");
            }
    
        }
        //插入
        @Test
        public void testInsert(){
            OrderDao orderDao = new OrderDaoImpl();
            Order order = new Order();
    
            order.setUsername("YUK");
            order.setDeliveryAddress("China");
            order.setOrderTime(new Date());
            order.setTelephone("123336333");
    
            int count = orderDao.insert(order);
            if (count > 0){
                System.out.println("恭喜,订单插入成功");
            }else {
                System.out.println("遗憾,订单插入失败");
            }
        }
    
        //删除
    
        @Test
        public void testDeleteById(){
            OrderDao orderDao = new OrderDaoImpl();
            Order order = new OrderDaoImpl().findById(4);
            int count = orderDao.deleteById(4);
            if (count > 0){
                System.out.println("恭喜,订单删除成功");
                System.out.println(order);
            }else {
                System.out.println("遗憾,订单删除失败");
            }
    
    
        }
        //按id查询
        @Test
        public void testFindById(){
            OrderDao orderDao = new OrderDaoImpl();
            Order order  = orderDao.findById(9);
            if (order== null){
                System.out.println("查询失败");
            }else {
                System.out.println("查询成功");
                System.out.println(order);
            }
    
        }
    
        @Test
        public void testFindLast(){
            OrderDao orderDao = new OrderDaoImpl();
            Order order = orderDao.findLast();
            if (order== null){
                System.out.println("查询失败");
            }else {
                System.out.println("查询成功");
                System.out.println(order);
            }
    
        }
        }
    

    (七)数据访问服务类XXXService

    在src里创建net.hw.shop.service包,在里面创建四个服务类:UserService、CategoryService、ProductService与OrderService。
    在这里插入图片描述

    1、用户服务类UserService

    package net.gongjing.shop.service;
    
    /**
     * 功能:用户服务类
     * 作者:gongjing
     * 日期:2019年12月5日
     */
    
    import java.util.List;
    
    import net.gongjing.shop.bean.User;
    import net.gongjing.shop.dao.UserDao;
    import net.gongjing.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);
        }
    }
    

    测试代码

    package test.net.gongjing.shop.service;
    
    import net.gongjing.shop.bean.User;
    import net.gongjing.shop.dao.UserDao;
    import net.gongjing.shop.dao.impl.UserDaoImpl;
    import org.junit.Test;
    
    import java.util.Date;
    import java.util.List;
    
    public class TestUserService {
        @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("遗憾登陆失败");
            }
        }
        @Test
        public void testUpdateUser(){
            UserDao userDao = new UserDaoImpl();
    
            User user = userDao.findById(3);
            user.setPassword("123");
            user.setTelephone("133909");
    
    
            if (user == null){
                System.out.println("恭喜,用户更新成功");
                System.out.println(user);
            }else {
                System.out.println("遗憾,用户更新失败");
            }
    
    
        }
        //插入
        @Test
        public void testAddUser(){
            UserDao userDao = new UserDaoImpl();
            User user = new User();
    
            user.setUsername("ZJY");
            user.setPassword("123456");
            user.setTelephone("13378323305");
            user.setRegisterTime(new Date());
            user.setPopedom(1);
    
            int count = userDao.insert(user);
            if (count > 0 ){
                System.out.println("恭喜,用户插入成功");
            }else {
                System.out.println("遗憾,用户插入失败");
            }
        }
    
        //删除
    
        @Test
        public void testDeleteUserById(){
            UserDao userDao = new UserDaoImpl();
    
            int count = userDao.deleteById(2);
            if (count > 0){
                System.out.println("恭喜,用户删除成功");
            }else {
                System.out.println("遗憾,用户删除失败");
            }
        }
        //按用户名查询
        @Test
        public void testFindUserByUsername(){
            String username;
            username = "admin";
    
            UserDao userDao = new UserDaoImpl();
            List<User> user = userDao.findByUsername(username);
            if (!user.isEmpty()){
                System.out.println("查询成功");
                System.out.println(user);
            }else {
                System.out.println("查询失败");
            }
    
    
        }
    
        //查询全部
        @Test
        public void testFindAllUser(){
            UserDao userDao = new UserDaoImpl();
            List<User> user = userDao.findAll();
            if (!user.isEmpty()){
                System.out.println("查询成功");
                System.out.println(user);
            }else {
                System.out.println("查询失败");
            }
    
        }
    
        @Test
        public void testFindUserById(){
            UserDao userDao = new UserDaoImpl();
            User user = userDao.findById(1);
            if (user == null){
                System.out.println("查询失败");
            }else {
                System.out.println("查询成功");
                System.out.println(user);
            }
    
        }
    
    }
    
    

    2、类别服务类CategoryService

    package net.gongjing.shop.service;
    
    /**
     * 功能:类别服务类
     * 作者:gongjing
     * 日期:2019年12月2日
     */
    
    import java.util.List;
    
    import net.gongjing.shop.bean.Category;
    import net.gongjing.shop.dao.CategoryDao;
    import net.gongjing.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();
        }
    }
    

    测试代码

    package test.net.gongjing.shop.service;
    
    import net.gongjing.shop.bean.Category;
    import net.gongjing.shop.dao.CategoryDao;
    import net.gongjing.shop.dao.impl.CategoryDaoImpl;
    import org.junit.Test;
    
    import java.util.List;
    
    public class TestCategoryService {
        @Test
        public void testAddCategory(){
            CategoryDao categoryDao = new CategoryDaoImpl();
            Category category = new Category();
    
           category.setName("实用工具");
            int count = categoryDao.insert(category);
            if (count > 0){
                System.out.println("插入成功");
            }else {
                System.out.println("插入失败");
            }
        }
    
        @Test
        public void testDeleteCategoryById(){
            CategoryDao categoryDao = new CategoryDaoImpl();
            int count  = categoryDao.deleteById(2);
            if (count > 0){
                System.out.println("删除成功");
            }else {
                System.out.println("删除失败");
            }
        }
    
        @Test
        public void testUpdateCategory(){
            CategoryDao categoryDao = new CategoryDaoImpl();
            Category category = categoryDao.findById(3);
    
      //     category.setName("不实用电器");
    //        int count = categoryDao.update(category);
            if (category == null){
                System.out.println("更新成功");
            }else {
                System.out.println("更新失败");
            }
        }
    
        @Test
        public void testFindCategoryById(){
            CategoryDao categoryDao = new CategoryDaoImpl();
            Category category = categoryDao.findById(2);
            if (category == null){
                System.out.println("查询失败");
            }else {
                System.out.println("查询成功");
            }
            System.out.println(category);
        }
    
        @Test
        public void testFindAllCategories(){
            CategoryDao categoryDao = new CategoryDaoImpl();
            List<Category> categories = categoryDao.findAll();
            //判断是否有类别
            //判断集合是否为空有两种方式  size()>0    isEmpty()
            if(!categories.isEmpty()){
                for (Category category: categories){
                    System.out.println(category);
                }
            }else {
                System.out.println("没有商品类别!");
            }
        }
    }
    
    

    3、商品服务类ProductService

    package net.gongjing.shop.service;
    
    /**
     * 功能:商品服务类
     * 作者:gongjing
     * 日期:2019年12月5日
     */
    
    import java.util.List;
    
    import net.gongjing.shop.bean.Product;
    import net.gongjing.shop.dao.ProductDao;
    import net.gongjing.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();
        }
    }
    
    

    测试代码

    package test.net.gongjing.shop.service;
    
    import net.gongjing.shop.bean.Product;
    import net.gongjing.shop.dao.CategoryDao;
    import net.gongjing.shop.dao.ProductDao;
    import net.gongjing.shop.dao.impl.CategoryDaoImpl;
    import net.gongjing.shop.dao.impl.ProductDaoImpl;
    import org.junit.Test;
    
    import java.util.Date;
    import java.util.List;
    
    public class TestProductService {
        @Test
        public void testUpdateProduct(){
            ProductDao productDao = new ProductDaoImpl();
            Product product = productDao.findById(2);
    
    
            //product.setName("Yss");
    
            if (product == null){
                System.out.println("恭喜,用户更新成功");
            }else {
                System.out.println("遗憾,用户更新失败");
            }
    
        }
    
        //按类别
        @Test
        public void testFindProductsByCategoryId(){
            //创建商品数据访问对象
            ProductDao productDao = new ProductDaoImpl();
    
            int categoryId = 2;
            CategoryDao categoryDao = new CategoryDaoImpl();
    
            if (categoryDao.findById(categoryId) != null){
                String categoryName = categoryDao.findById(categoryId).getName();
                List<Product> products = productDao.findByCategoryId(categoryId);
                if (!products.isEmpty()){
                    for (Product product: products){
                        System.out.println(product);
                    }
                }else {
                    System.out.println("该类别下面没商品");
                }
            }else {
                System.out.println("类别编号[" + categoryId + "]不存在");
            }
            ;
        }
        @Test
        public void testFindAllProduct(){
            ProductDao productDao = new ProductDaoImpl();
            List<Product> products = productDao.findAll();
            //判断是否有类别
            //判断集合是否为空有两种方式  size()>0    isEmpty()
            if(!products.isEmpty()){
                for (Product product: products){
                    System.out.println(product);
                }
            }else {
                System.out.println("没有商品类别!");
            }
        }
        @Test
        public void testAddProduct(){
            ProductDao productDao = new ProductDaoImpl();
            Product product =  new Product();
    
            product.setName("学习办公123");
            product.setAddTime(new Date());
            product.setCategoryId(1);
            product.setPrice(200);
            int count = productDao.insert(product);
            if (count > 0){
                System.out.println("插入成功");
            }else {
                System.out.println("插入失败");
            }
        }
        @Test
        public void testFindProductById(){
            ProductDao productDao = new ProductDaoImpl();
            Product product = productDao.findById(200);
            if (product == null){
                System.out.println("查询失败");
            }else {
                System.out.println("查询成功");
            }
            System.out.println(product);
        }
    
        @Test
        public void testDeleteProductById(){
            ProductDao productDao = new ProductDaoImpl();
            int count  = productDao.deleteById(1);
            if (count > 0){
                System.out.println("删除成功");
            }else {
                System.out.println("删除失败");
            }
        }
    }
    
    

    4、订单服务类OrderService

    package net.gongjing.shop.service;
    
    /**
     * 功能:订单服务类
     * 作者:gongjing
     * 日期:2019年12月2日
     */
    
    import java.util.List;
    
    import net.gongjing.shop.bean.Order;
    import net.gongjing.shop.dao.OrderDao;
    import net.gongjing.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();
        }
    }
    

    测试代码

    package test.net.gongjing.shop.service;
    
    import net.gongjing.shop.bean.Order;
    import net.gongjing.shop.dao.OrderDao;
    import net.gongjing.shop.dao.impl.OrderDaoImpl;
    import org.junit.Test;
    
    import java.util.Date;
    import java.util.List;
    
    public class TestOrderService {
        @Test
        public void testFindAllOrders(){
            OrderDao orderDao = new OrderDaoImpl();
    
            List<Order> orders = orderDao.findAll();
            if (orders.size() > 0 ){
                for (Order order: orders){
                    System.out.println(order);
                }
            }else {
                System.out.println("没有订单!");
            }
        }
    
        @Test
        public void testUpdateOrder(){
            OrderDao orderDao = new OrderDaoImpl();
            Order order = orderDao.findById(1);
    
    
    //       order.setUsername("ZZJJYY");
    //
            if (order == null){
                System.out.println("恭喜,用户更新成功");
            }else {
                System.out.println("遗憾,用户更新失败");
            }
    
        }
        //插入
        @Test
        public void testAddOrder(){
            OrderDao orderDao = new OrderDaoImpl();
            Order order = new Order();
    
            order.setUsername("YUK");
            order.setDeliveryAddress("China");
            order.setOrderTime(new Date());
            order.setTelephone("123336333");
    
            int count = orderDao.insert(order);
            if (count > 0){
                System.out.println("恭喜,订单插入成功");
            }else {
                System.out.println("遗憾,订单插入失败");
            }
        }
    
        //删除
    
        @Test
        public void testDeleteOrderById(){
            OrderDao orderDao = new OrderDaoImpl();
    
            int count = orderDao.deleteById(2);
            if (count > 0){
                System.out.println("恭喜,订单删除成功");
            }else {
                System.out.println("遗憾,订单删除失败");
            }
    
        }
        //按id查询
        @Test
        public void testFindOrderById(){
            OrderDao orderDao = new OrderDaoImpl();
            Order order  = orderDao.findById(1);
            if (order== null){
                System.out.println("查询失败");
            }else {
                System.out.println("查询成功");
                System.out.println(order);
            }
    
        }
    
        @Test
        public void testFindLastOrder(){
            OrderDao orderDao = new OrderDaoImpl();
            Order order = orderDao.findLast();
            if (order== null){
                System.out.println("查询失败");
            }else {
                System.out.println("查询成功");
                System.out.println(order);
            }
    
        }
    }
    
    

    四、实现步骤

    (八)控制层(XXXServlet)

    在src里创建net.hw.shop.servlet包,在里面创建各种控制处理类。
    在这里插入图片描述

    1、登录处理类LoginServlet

    package net.gongjing.shop.servlet;
    /**
     * 功能:登录处理类
     * 作者:gongjing
     * 日期:2019年12月9日
     */
    
    import java.io.IOException;
    
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;
    
    import net.gongjing.shop.bean.User;
    import net.gongjing.shop.service.UserService;
    
    @WebServlet("/login")
    public class LoginServlet extends HttpServlet {
        private static final long serialVersionUID = 1L;
    
        protected void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            // 设置请求对象的字符编码
            request.setCharacterEncoding("utf-8");
            // 获取会话对象
            HttpSession session = request.getSession();
            // 获取用户名
            String username = request.getParameter("username");
            // 获取密码
            String password = request.getParameter("password");
            // 定义用户服务对象
            UserService userService = new UserService();
            // 执行登录方法,返回用户实体
            User user = userService.login(username, password);
            // 判断用户登录是否成功
            if (user != null) {
                // 设置session属性
                session.setMaxInactiveInterval(5 * 60);
                session.setAttribute("username", username);
                session.removeAttribute("loginMsg");
                // 根据用户权限跳转到不同页面
                if (user.getPopedom() == 0) {
                    System.out.println("用户登录成功,进入后台管理!");
                    response.sendRedirect(request.getContextPath() + "/backend/management.jsp");
                } else if (user.getPopedom() == 1) {
                    System.out.println("用户登录成功,进入前台显示类别!");
                    response.sendRedirect(request.getContextPath() + "/showCategory");
                }
            } else {
                System.out.println("用户名或密码错误,用户登录失败!");
                // 设置session属性loginMsg
                session.setAttribute("loginMsg", "用户名或密码错误!");
                response.sendRedirect(request.getContextPath() + "/login.jsp");
            }
        }
    
        protected void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            doGet(request, response);
        }
    }
    
    
    

    测试如下
    在地址栏里localhost:8080/simonshop/之后输入login?username=admin&password=12345之后敲回车:
    在这里插入图片描述
    在这里插入图片描述
    登录失败
    在这里插入图片描述

    2、注销处理类LogoutServlet

    package net.gongjing.shop.servlet;
    /**
     * 功能:注销处理类
     * 作者:龚敬
     * 日期:2019年12月9日
     */
    
    import java.io.IOException;
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    @WebServlet("/logout")
    public class LogoutServlet extends HttpServlet {
        private static final long serialVersionUID = 1L;
    
        protected void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            // 让session失效
            request.getSession().invalidate();
            // 重定向到登录页面
            response.sendRedirect(request.getContextPath() + "/login.jsp");
            System.out.println("用户注销成功!");
        }
    
        protected void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            doGet(request, response);
        }
    }
    
    
    下面我们来进行测试。启动服务器,先要登录成功,然后再测试注销功能。

    先以普通用户身份登录成功登录系统
    login?username=gongjing&password=88888888
    在这里插入图片描述
    在这里插入图片描述
    重启服务器,再测试一下:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    此时,测试用户注销功能:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    3、注册处理类RegisterServlet

    package net.gongjing.shop.servlet;
    /**
     * 功能:处理用户注册
     * 作者:gongjing
     * 日期:2019年12月9日
     */
    
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.net.URLEncoder;
    import java.sql.Timestamp;
    
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;
    
    import net.gongjing.shop.bean.User;
    import net.gongjing.shop.service.UserService;
    
    @WebServlet("/register")
    public class RegisterServlet extends HttpServlet {
        private static final long serialVersionUID = 1L;
    
        protected void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            // 设置请求对象的字符编码
            request.setCharacterEncoding("utf-8");
            // 获取session对象
            HttpSession session = request.getSession();
    
            // 获取用户名
            String username = request.getParameter("username");
            // 获取密码
            String password = request.getParameter("password");
            // 获取电话号码
            String telephone = request.getParameter("telephone");
            // 设置注册时间(时间戳对象)
            Timestamp registerTime = new Timestamp(System.currentTimeMillis());
            // 设置用户为普通用户
            int popedom = 1;
    
            // 创建用户对象
            User user = new User();
            // 设置用户对象信息
            user.setUsername(username);
            user.setPassword(password);
            user.setTelephone(telephone);
            user.setRegisterTime(registerTime);
            user.setPopedom(popedom);
    
            // 创建UserService对象
            UserService userService = new UserService();
            // 调用UserService对象的添加用户方法
            int count = userService.addUser(user);
    
            // 判断是否注册成功
            if (count > 0) {
                // 设置session属性
                session.setAttribute("registerMsg", "恭喜,注册成功!");
                // 重定向到登录页面
                response.sendRedirect(request.getContextPath() + "/login.jsp");
                // 在控制台输出测试信息
                System.out.println("恭喜,注册成功,跳转到登录页面!");
            } else {
                // 设置session属性
                session.setAttribute("registerMsg", "遗憾,注册失败!");
                // 重定向到注册页面
                response.sendRedirect(request.getContextPath() + "/frontend/register.jsp");
                // 在控制台输出测试信息
                System.out.println("遗憾,注册失败,跳转到注册页面!");
            }
        }
    
        protected void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            doGet(request, response);
        }
    }
    
    

    下面我们来进行测试。启动服务器,访问http://localhost:8080/simonshop/register?username=萌萌哒&password=55555&telephone=15896961234,敲回车,查看结果:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    此时,我们去NaviCat查看用户表,看看是否插入了新的用户记录?
    在这里插入图片描述
    大家可以看到telephone字段长度为11,那么我们重启服务器再测试,让telephone的值超过11位,看看结果如何。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    我们去服务器端控制台查看信息:
    在这里插入图片描述
    确实在控制台输出了“遗憾,注册失败,跳转到注册页面!”信息,但是还抛出了一个异常:com.mysql.jdbc.MysqlDataTruncation: Data truncation: Data too long for column ‘telephone’ at row 1,显示方式不是我们喜欢的,当然问题出在模型层,大家去修改UserDaoImpl里的insert方法。
    很简单,只需要将catch字句里的e.printStackTrace();改成System.err.println(“SQL异常:” + e.getMessage());:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    4、显示类别处理类ShowCategoryServlet

    package net.gongjing.shop.servlet; 
    /**
     * 功能:显示类别控制程序
     * 作者:gongjing
     * 日期:2019年12月9日
     */
    
    import java.io.IOException;
    import java.util.List;
    
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;
    
    import net.gongjing.shop.bean.Category;
    import net.gongjing.shop.service.CategoryService;
    
    @WebServlet("/showCategory")
    public class ShowCategoryServlet extends HttpServlet {
        private static final long serialVersionUID = 1L;
    
        protected void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            // 创建类别服务对象
            CategoryService categoryService = new CategoryService();
            // 获取全部商品类别
            List<Category> categories = categoryService.findAllCategories();
            // 获取session对象
            HttpSession session = request.getSession();
            // 把商品类别列表以属性的方式保存到session里
            session.setAttribute("categories", categories);
            // 重定向到显示商品类别页面(showCategory.jsp)
            response.sendRedirect(request.getContextPath() + "/frontend/showCategory.jsp");
            // 在服务器控制台输出测试信息
            for (Category category: categories) {
                System.out.println(category);
            }        
        }
    
        protected void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            doGet(request, response);
        }
    }
    
    

    下面我们来进行测试。
    重启服务器,访问http://localhost:8080/simonshop/showCategory:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    5、显示商品处理类ShowProductServlet

    在这里插入图片描述

    package net.gongjing.shop.servlet;
    /**
     * 功能:显示商品列表的控制程序
     *     通过业务层访问后台数据,
     *     然后将数据返回给前台页面
     * 作者:gongjing
     * 日期:2019年12月9日
     */
    
    import java.io.IOException;
    import java.util.List;
    
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;
    
    import net.gongjing.shop.bean.Product;
    import net.gongjing.shop.service.CategoryService;
    import net.gongjing.shop.service.ProductService;
    
    @WebServlet("/showProduct")
    public class ShowProductServlet extends HttpServlet {
        private static final long serialVersionUID = 1L;
    
        protected void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            // 获取类别标识符
            int categoryId = Integer.parseInt(request.getParameter("categoryId"));
            // 创建商品类别服务对象
            CategoryService categoryService = new CategoryService();
            // 由类别标识符获取类别名
            String categoryName = categoryService.findCategoryById(categoryId).getName();
            // 创建商品服务对象
            ProductService productService = new ProductService();
            // 获取指定商品类别的商品列表
            List<Product> products = productService.findProductsByCategoryId(categoryId);
            // 获取session对象
            HttpSession session = request.getSession();
            // 把商品列表对象以属性的方式保存到session里
            session.setAttribute("products", products);
            // 重定向到显示商品信息页面
            response.sendRedirect(request.getContextPath() + "/frontend/showProduct.jsp?categoryName=" + categoryName);
            // 在服务器端控制台输出测试信息
            for (int i = 0; i < products.size(); i++) {
                System.out.println(products.get(i));
            }
        }
    
        protected void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            doGet(request, response);
        }
    }
    

    下面我们来进行测试。
    重启服务器,访问http://localhost:8080/simonshop/showProduct?categoryId=1:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    没有类别会报错

    在这里插入图片描述

    ps:数据库版本不同虽然也可以连接成功,但是控制台依旧会报错,这是jdbc驱动和当前数据库版本不匹配所造成的,解决方法就是去官网下载当前数据库版本所匹配的jdbc文件

    修改之后的代码

    package net.gongjing.shop.servlet;
    /**
     * 功能:显示商品列表的控制程序
     *     通过业务层访问后台数据,
     *     然后将数据返回给前台页面
     * 作者:gongjing
     * 日期:2019年12月9日
     */
    
    import java.io.IOException;
    import java.util.List;
    
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;
    
    import net.gongjing.shop.bean.Product;
    import net.gongjing.shop.service.CategoryService;
    import net.gongjing.shop.service.ProductService;
    
    @WebServlet("/showProduct")
    public class ShowProductServlet extends HttpServlet {
        private static final long serialVersionUID = 1L;
    
        protected void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            // 获取类别标识符
            int categoryId = Integer.parseInt(request.getParameter("categoryId"));
            // 创建商品类别服务对象
            CategoryService categoryService = new CategoryService();
            if (categoryService.findCategoryById(categoryId) != null) {
                // 由类别标识符获取类别名
                String categoryName = categoryService.findCategoryById(categoryId).getName();
                // 创建商品服务对象
                ProductService productService = new ProductService();
                // 获取指定商品类别的商品列表
                List<Product> products = productService.findProductsByCategoryId(categoryId);
                // 获取session对象
                HttpSession session = request.getSession();
                // 把商品列表对象以属性的方式保存到session里
                session.setAttribute("products", products);
                // 重定向到显示商品信息页面
                response.sendRedirect(request.getContextPath() + "/frontend/showProduct.jsp?categoryName=" + categoryName);
                // 在服务器端控制台输出测试信息
                for (int i = 0; i < products.size(); i++) {
                    System.out.println(products.get(i));
                }
            } else {
                System.out.println("类别表里没有id为" + categoryId + "的记录!");
            }
        }
        protected void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            doGet(request, response);
        }
    }
    

    完整servlet代码

    四,实现步骤

    (九)准备图片资源

    在web目录里创建images目录,存放项目所需图片文件:
    在这里插入图片描述
    图片素材下载链接:https://pan.baidu.com/s/1XH4Z7iQ01uZCS1LEmADZAw
    提取码:v7rx

    (十)CSS样式文件

    在web目录里常见css子目录,在里面创建main.css文件:
    在这里插入图片描述

    /* 样式 */
    body {
        margin: 0px;
        text-align: center;
        background: url("../images/frontBack.jpg") no-repeat;
        background-size: 100%
    }
    
    table {
        margin: 0 auto;
        font-size: 14px;
        color: #333333;
        border-width: 1px;
        border-color: khaki;
        border-collapse: collapse;
    }
    
    table th {
        border-width: 1px;
        padding: 8px;
        border-style: solid;
        border-color: gainsboro;
        background-color: honeydew;
    }
    
    table td {
        border-width: 1px;
        padding: 8px;
        border-style: solid;
        border-color: gainsboro;
        background-color: #ffffff;
    }
    
    /*登录页面样式*/
    .login {
        width: 400px;
        height: 340px;
        background-color: honeydew;
        border: solid 2px darkgrey;
        left: 50%;
        top: 50%;
        position: absolute;
        margin: -170px 0 0 -200px;
    }
    
    .login .websiteTitle, .title {
        border: solid 1px floralwhite;
    }
    
    /*注册页面样式*/
    .register {
        width: 400px;
        height: 350px;
        background-color: honeydew;
        border: solid 2px darkgrey;
        left: 50%;
        top: 50%;
        position: absolute;
        margin: -175px 0 0 -200px;
    }
    
    /*显示类别页面样式*/
    .showCategory {
        width: 400px;
        height: 350px;
        background-color: honeydew;
        border: solid 2px darkgrey;
        left: 50%;
        top: 50%;
        position: absolute;
        margin: -150px 0 0 -200px;
    }
    
    /*生成订单页面样式*/
    .makeOrder {
        width: 400px;
        height: 400px;
        background-color: honeydew;
        border: solid 2px darkgrey;
        left: 50%;
        top: 50%;
        position: absolute;
        margin: -200px 0 0 -200px;
    }
    
    /*显示订单页面样式*/
    .showOrder {
        width: 400px;
        height: 400px;
        background-color: honeydew;
        border: solid 2px darkgrey;
        left: 50%;
        top: 50%;
        position: absolute;
        margin: -200px 0 0 -200px;
    }
    
    

    (十一)JavaScript脚本文件

    在web目录里创建scripts子目录,在里面创建check.js文件:
    在这里插入图片描述

    /**
     * 检验登录表单
     *
     * @returns {Boolean}
     */
    function checkLoginForm() {
        var username = document.getElementById("username");
        var password = document.getElementById("password");
        if (username.value == "") {
            alert("用户名不能为空!");
            username.focus();
            return false;
        }
        if (password.value == "") {
            alert("密码不能为空!");
            password.focus();
            return false;
        }
        return true;
    }
    
    /**
     * 检验注册表单
     *
     * @returns {Boolean}
     */
    function checkRegisterForm() {
        var username = document.getElementById("username");
        var password = document.getElementById("password");
        var telephone = document.getElementById("telephone");
        if (username.value == "") {
            alert("用户名不能为空!");
            username.focus();
            return false;
        }
        if (password.value == "") {
            alert("密码不能为空!");
            password.focus();
            return false;
        }
    
        var pattern = "/^(13[0-9]|14[0-9]|15[0-9]|18[0-9])\d{8}$/";
        if (!pattern.exec(telephone)) {
            alert("非法手机号!");
            telephone.focus();
            return false;
        }
        return true;
    }
    
    

    (十二)添加JSTL的jar包

    在WEB-INF\lib目录里添加支持jstl的jar包:
    jar包下载地址:http://tomcat.apache.org/taglibs/standard/
    在这里插入图片描述

    (十三)展现层页面(XXX.jsp)

    1、登录页面login.jsp

    在这里插入图片描述

    <%@ page language="java" contentType="text/html; charset=UTF-8"
             pageEncoding="UTF-8" %>
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    
    <c:set var="path" value="${pageContext.request.contextPath}"/>
    <c:set var="basePath"
           value="${pageContext.request.scheme}://${pageContext.request.serverName}:${pageContext.request.serverPort}${path}/"/>
    <!DOCTYPE html>
    <html>
    <head>
        <title>用户登录</title>
        <base href="${basePath}">
        <script src="scripts/check.js" type="text/javascript"></script>
        <link href="css/main.css" rel="stylesheet" type="text/css"/>
    </head>
    <body>
    
    <div class="login">
        <div class="websiteTitle">
            <h1>西蒙购物网</h1>
        </div>
        <div class="title">
            <h3>用户登录</h3>
        </div>
        <div class="main">
            <form id="frmLogin" action="login" method="post">
                <table>
                    <tr>
                        <td align="center">账号</td>
                        <td><input id="username" type="text" name="username"/></td>
                    </tr>
                    <tr>
                        <td align="center">密码</td>
                        <td><input id="password" type="password" name="password"/></td>
                    </tr>
                    <tr align="center">
                        <td colspan="2">
                            <input type="submit" value="登录" οnclick="return checkLoginForm();"/>
                            <input type="reset" value="重置"/>
                        </td>
                    </tr>
                </table>
            </form>
        </div>
        <div class="footer">
            <p>如果你不是本站用户,单击<a href="frontend/register.jsp">此处</a>注册。</p>
        </div>
    </div>
    
    <c:if test="${registerMsg!=null}">
        <script type="text/javascript">alert("${registerMsg}")</script>
        <c:remove var="registerMsg"/>
    </c:if>
    
    <c:if test="${loginMsg!=null}">
        <script type="text/javascript">alert("${loginMsg}")</script>
        <c:remove var="loginMsg"/>
    </c:if>
    </body>
    </html>
    
    
    

    在web.xml文件里将login.jsp设置为首页文件:

    在这里插入图片描述
    重启服务器:
    在这里插入图片描述
    不输入用户名与密码,单击【登录】按钮:
    在这里插入图片描述
    输入用户名,但不输入密码,单击【登录】按钮:
    在这里插入图片描述
    输入管理员用户名与密码:admin,12345
    在这里插入图片描述
    在这里插入图片描述
    重启服务器,再以普通用户登录:郑晓红,11111
    在这里插入图片描述
    重启服务器,输入错误的用户名或密码:李文丽,12340
    在这里插入图片描述
    在这里插入图片描述
    单击【确定】按钮,返回登录页面:
    在这里插入图片描述

    2、注册页面register.jsp

    在这里插入图片描述

    <%@ page language="java" contentType="text/html; charset=UTF-8"
             pageEncoding="UTF-8" %>
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    
    <c:set var="path" value="${pageContext.request.contextPath}"/>
    <c:set var="basePath"
           value="${pageContext.request.scheme}://${pageContext.request.serverName}:${pageContext.request.serverPort}${path}/"/>
    <!DOCTYPE html>
    <html>
    <head>
        <title>用户注册</title>
        <base href="${basePath}">
        <link href="css/main.css" rel="stylesheet" type="text/css"/>
        <script src="scripts/check.js" type="text/javascript"></script>
    </head>
    <body>
    
    <div class="register">
        <div class="websiteTitle">
            <h1>西蒙购物网</h1>
        </div>
        <div class="title">
            <h3>用户注册</h3>
        </div>
        <div class="main">
            <form action="register" method="post">
                <table>
                    <tr>
                        <td>账号</td>
                        <td><input id="username" type="text" name="username"/></td>
                    </tr>
                    <tr>
                        <td>密码</td>
                        <td><input id="password" type="password" name="password"/></td>
                    </tr>
                    <tr>
                        <td align="center">电话</td>
                        <td><input id="telephone" type="text" name="telephone"/></td>
                    </tr>
                    <tr align="center">
                        <td colspan="2">
                            <input type="submit" value="注册" onclick="return checkRegisterForm();"/>
                            <input type="reset" value="重置"/></td>
                    </tr>
                </table>
            </form>
        </div>
        <div class="footer">
            <p><a href="login.jsp">切换到登录页面</a></p>
        </div>
    </div>
    
    <c:if test="${registerMsg!=null}">
        <script type="text/javascript">alert("${registerMsg}")</script>
        <c:set var="registerMsg" value=""/>
    </c:if>
    </body>
    </html>
    
    

    启动服务器:
    在这里插入图片描述
    在这里插入图片描述
    什么也不输入,单击【注册】按钮:
    在这里插入图片描述
    输入用户名,单击【注册】按钮
    在这里插入图片描述
    输入用户名、密码和电话,单击【注册】按钮:
    在这里插入图片描述
    打开用户表,查看新添加的用户:
    在这里插入图片描述

    3、显示商品类别页面showCategory.jsp

    在这里插入图片描述

    <%@ page language="java" contentType="text/html; charset=UTF-8"
             pageEncoding="UTF-8" %>
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    
    <c:set var="path" value="${pageContext.request.contextPath}"/>
    <c:set var="basePath"
           value="${pageContext.request.scheme}://${pageContext.request.serverName}:${pageContext.request.serverPort}${path}/"/>
    <!DOCTYPE html>
    <html>
    <head>
        <title>显示商品类别</title>
        <base href="${basePath}">
        <link href="css/main.css" rel="stylesheet" type="text/css"/>
    </head>
    <body>
    
    <div class="showCategory">
        <div class="websiteTitle">
            <h1>西蒙购物网</h1>
        </div>
        <div>
            登录用户:<span style="color: red;">${username}</span>
            <c:forEach var="i" begin="1" end="5">             
            </c:forEach>
            <a href="logout">注销</a>
        </div>
        <div class="title">
            <h3>商品类别</h3>
        </div>
        <div class="main">
            <table>
                <tr>
                    <th>类别编号</th>
                    <th>商品类别</th>
                </tr>
                <c:forEach var="category" items="${categories}">
                    <tr align='center'>
                        <td>${category.id}</td>
                        <td width="150">
                            <a href="showProduct?categoryId=${category.id}">${category.name}</a>
                        </td>
                    </tr>
                </c:forEach>
            </table>
        </div>
    </div>
    </body>
    </html>
    
    

    启动服务器,显示登录页面,输入普通用户:郑晓红,11111
    在这里插入图片描述
    在这里插入图片描述
    单击【家用电器】超链接:
    在这里插入图片描述
    我们去服务器端控制台查看输出信息:
    在这里插入图片描述
    返回到刚才显示商品类别页面
    在这里插入图片描述
    单击【注销】超链接,返回登录页面:
    在这里插入图片描述

    4、显示购物车页面showCart.jsp

    <%@ page language="java" contentType="text/html; charset=UTF-8"
             pageEncoding="UTF-8" %>
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    <%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
    
    <c:set var="path" value="${pageContext.request.contextPath}"/>
    <c:set var="basePath"
           value="${pageContext.request.scheme}://${pageContext.request.serverName}:${pageContext.request.serverPort}${path}/"/>
    <!DOCTYPE html>
    <html>
    <head>
        <title>显示购物车</title>
        <base href="${basePath}">
    </head>
    <body>
    <h3>${username}的购物车</h3>
    <table>
        <tr>
            <th>商品编号</th>
            <th>商品名称</th>
            <th>销售价格</th>
            <th>购买数量</th>
            <th>合计金额</th>
            <th>用户操作</th>
        </tr>
        <c:forEach var="shoppingItem" items="${shoppingTable}">
            <tr>
                <td>${shoppingItem.id}</td>
                <td>${shoppingItem.name}</td>
                <td>¥${shoppingItem.price}</td>
                <td>${shoppingItem.amount}</td>
                <td>¥${shoppingItem.sum}</td>
                <td><a href="operateCart?id=${shoppingItem.id}&operation=delete">删除</a></td>
            </tr>
        </c:forEach>
        <tr>
            <th>总金额</th>
            <td></td>
            <td></td>
            <td></td>
            <c:choose>
                <c:when test="${totalPrice==null}">
                    <th style="color: red">0.00</th>
                </c:when>
                <c:otherwise>
                    <th style="color: red">¥${totalPrice}</th>
                </c:otherwise>
            </c:choose>
            <td></td>
        </tr>
    </table>
    <hr width="800px">
    <c:choose>
        <c:when test="${totalPrice==null}">
            <a href="frontend/makeOrder.jsp?totalPrice=0.00">生成订单</a>
        </c:when>
        <c:otherwise>
            <a href="frontend/makeOrder.jsp?totalPrice=${totalPrice}">生成订单</a>
        </c:otherwise>
    </c:choose>
    <c:if test="${orderMsg!=null}">
        <script type="text/javascript">alert("${orderMsg}")</script>
        <c:remove var="orderMsg"/>
    </c:if>
    </body>
    </html>
    
    

    这个页面要包含在显示商品页面里,因此没有导入CSS样式文件。
    重启服务器,以普通用户登录后,访问http://localhost:8080/simonshop/frontend/showCart.jsp:
    在这里插入图片描述

    5、显示商品页面showProduct.jsp

    在这里插入图片描述

    <%@ page language="java" contentType="text/html; charset=UTF-8"
             pageEncoding="UTF-8" %>
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    <%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
    
    <c:set var="path" value="${pageContext.request.contextPath}"/>
    <c:set var="basePath"
           value="${pageContext.request.scheme}://${pageContext.request.serverName}:${pageContext.request.serverPort}${path}/"/>
    <!DOCTYPE html>
    <html>
    <head>
        <title>显示商品信息</title>
        <base href="${basePath}">
        <link href="css/main.css" rel="stylesheet" type="text/css"/>
    </head>
    <body>
    <h1>西蒙购物网</h1>
    <hr width="700px">
    登录用户:<span style="color: red;">${username}</span>
    <c:forEach var="i" begin="1" end="5">     
    </c:forEach>
    <a href="logout">注销</a></td>
    <hr width="700px">
    欢迎选购【<span style="color: blue; font-weight: bold;">${categoryName}</span>】类商品
    <hr width="700px">
    <table border="0">
        <c:forEach varStatus="status" var="product" items="${products}">
            <c:if test="${status.count%5==0}">
                <tr>
            </c:if>
            <td>
                <table border="0">
                    <tr><img src="images/product${product.id}.jpg" width="60px" height="60px"></tr>
                    <tr>
                        <td><b>商品编号:</b></td>
                        <td>${product.id}</td>
                    </tr>
                    <tr>
                        <td><b>商品名称:</b></td>
                        <td>${product.name}</td>
                    </tr>
                    <tr>
                        <td><b>销售价格:</b></td>
                        <td>${product.price}</td>
                    </tr>
                    <tr>
                        <td><b>上架时间:</b></td>
                        <td><fmt:formatDate value="${product.addTime}" pattern="yyyy-MM-dd"/></td>
                    </tr>
                    <tr>
                        <td><b>用户操作:</b></td>
                        <td><a href="operateCart?id=${product.id}&operation=add">加入购物车</a></td>
                    </tr>
                </table>
            </td>
            <c:if test="${status.count%4==0}">
                </tr>
            </c:if>
        </c:forEach>
    </table>
    <hr width="700px">
    <a href="showCategory">返回商品类别页面</a>
    <hr width="700px">
    <jsp:include page="showCart.jsp"/>
    </body>
    </html>
    
    

    启动服务器,显示登录页面,输入普通用户:郑晓红,11111
    在这里插入图片描述
    单击【家用电器】超链接:
    在这里插入图片描述
    有点小问题,类别名没有显示出来,页面跳转了,但是类别名没有传递成功。
    修改ShowProductServlet,将类别名放在session里,而不是通过url传递参数。
    在这里插入图片描述
    重启服务器,登录成功后,选择【家用电器】类别:
    在这里插入图片描述
    下面测试加入购物车操作:
    在这里插入图片描述
    同一件商品可以多次加入购物车,也可以从购物车删除掉选购的商品。如果一件商品加入购物车的数量大于1,那么执行一次删除操作就是让购物车该商品数量减少1,直到减为0,即购物车里删除掉该商品。
    在这里插入图片描述

    6、生成订单页面makeOrder.jsp

    在这里插入图片描述

    <%@ page language="java" contentType="text/html; charset=UTF-8"
             pageEncoding="UTF-8" %>
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    
    <c:set var="path" value="${pageContext.request.contextPath}"/>
    <c:set var="basePath"
           value="${pageContext.request.scheme}://${pageContext.request.serverName}:${pageContext.request.serverPort}${path}/"/>
    <!DOCTYPE html>
    <html>
    <head>
        <title>生成订单</title>
        <base href="${basePath}">
        <link href="css/main.css" rel="stylesheet" type="text/css"/>
    </head>
    <body>
    <div class="makeOrder">
        <div class="websiteTitle">
            <h1>西蒙购物网</h1>
        </div>
        <div>
            登录用户:<span style="color: red;">${username}</span>
            <c:forEach var="i" begin="1" end="5">
                 
            </c:forEach>
            <a href="logout">注销</a>
        </div>
        <div class="title">
            <h3>生成订单</h3>
        </div>
        <div class="main">
            <form action="makeOrder" method="post">
                <table>
                    <tr>
                        <td>用户名</td>
                        <td><input type="text" name="username" readonly="readonly"
                                   value="${username}"/></td>
                    </tr>
                    <tr>
                        <td>联系电话</td>
                        <td><input type="text" name="telephone"/></td>
                    </tr>
                    <tr>
                        <td>总金额</td>
                        <td><input type="text" name="totalPrice" readonly="readonly"
                                   value="${totalPrice}"/></td>
                    </tr>
                    <tr>
                        <td>送货地址</td>
                        <td><input type="text" name="deliveryAddress"/></td>
                    </tr>
                    <tr align="center">
                        <td colspan="2"><input type="submit" value="生成订单"/> <input
                                type="reset" value="重置"/></td>
                    </tr>
                </table>
            </form>
        </div>
        <div class="footer">
            <p><a href="showCategory">返回商品类别页面</a></p>
        </div>
    </div>
    </body>
    </html>
    
    

    7、显示订单页面showOrder.jsp

    在这里插入图片描述

    <%@ page language="java" contentType="text/html; charset=UTF-8"
             pageEncoding="UTF-8" %>
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    
    <c:set var="path" value="${pageContext.request.contextPath}"/>
    <c:set var="basePath"
           value="${pageContext.request.scheme}://${pageContext.request.serverName}:${pageContext.request.serverPort}${path}/"/>
    <!DOCTYPE html>
    <html>
    <head>
        <title>显示订单</title>
        <base href="${basePath}">
        <link href="css/main.css" rel="stylesheet" type="text/css"/>
    </head>
    <body>
    <div class="showOrder">
        <div class="websiteTitle">
            <h1>西蒙购物网</h1>
        </div>
        <div>
            登录用户:<span style="color: red;">${username}</span>
            <c:forEach var="i" begin="1" end="5">             
            </c:forEach>
            <a href="logout">注销</a>
        </div>
        <div class="title">
            <h3>生成订单</h3>
        </div>
        <div class="main">
            <table border="1" cellspacing="0">
                <tr>
                    <th>订单编号</th>
                    <td>${lastOrder.id}</td>
                </tr>
                <tr>
                    <th>用户名</th>
                    <td>${lastOrder.username}</td>
                </tr>
                <tr>
                    <th>联系电话</th>
                    <td>${lastOrder.telephone}</td>
                </tr>
                <tr>
                    <th>总金额</th>
                    <td>${lastOrder.totalPrice}</td>
                </tr>
                <tr>
                    <th>送货地址</th>
                    <td>${lastOrder.deliveryAddress}</td>
                </tr>
            </table>
        </div>
        <div class="footer">
            <p><a href="pay" οnclick="alert('${lastOrder.username},支付成功!');">支付</a></p>
        </div>
    </div>
    </body>
    </html>
    
    

    下面我们来测试生成订单与显示订单页面。
    重启服务器,以普通用户登录,选择【家用电器】类商品,在显示商品页面,将一些商品加入购物车,查看购物车情况
    在这里插入图片描述
    单击【生成订单】超链接,跳转到【生成订单】页面
    在这里插入图片描述
    输入联系电话与送货地址:
    在这里插入图片描述
    单击【生成订单】按钮,跳转到【显示订单】页面:
    在这里插入图片描述
    单击【支付】按钮,提示支付成功
    在这里插入图片描述
    单击【确定】按钮,返回登录页面:
    在这里插入图片描述

    8、后台管理主页面management.jsp

    在这里插入图片描述

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    
    <c:set var="path" value="${pageContext.request.contextPath}"/>
    <c:set var="basePath"
           value="${pageContext.request.scheme}://${pageContext.request.serverName}:${pageContext.request.serverPort}${path}/"/>
    <!DOCTYPE html>
    <html>
    <head>
        <title>西蒙购物网站后台管理</title>
        <base href="${basePath}">
    </head>
    <frameset rows="30%,70%" cols="*">
        <frame src="backend/top.jsp" name="top_frame" scrolling="no">
        <frameset rows="*" cols="25%,75%">
            <frame src="backend/left.jsp" name="left_frame" scrolling="yes">
            <frame src="backend/main.jsp" name="main_frame" scrolling="yes">
        </frameset>
    </frameset>
    </html>
    
    

    9、后台管理主页面左面板页面left.jsp

    在这里插入图片描述

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    <%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
    
    <c:set var="path" value="${pageContext.request.contextPath}"/>
    <c:set var="basePath"
           value="${pageContext.request.scheme}://${pageContext.request.serverName}:${pageContext.request.serverPort}${path}/"/>
    <!DOCTYPE html>
    <html>
    <head>
        <title>后台管理左面板</title>
        <base href="${basePath}">
        <link rel="stylesheet" type="text/css">
        <script type="text/javascript">
            function show(id) {
                var obj = document.getElementById('c_' + id);
                if (obj.style.display == 'block') {
                    obj.style.display = 'none';
                } else {
                    obj.style.display = 'block';
                }
            }
        </script>
    </head>
    
    <body>
    <table cellSpacing=0 cellPadding=0 width='100%' border=0>
        <tbody>
        <tr>
            <td class=catemenu> <a
                    style='CURSOR: pointer' οnclick=show(1)><img src="images/folder.png">用户管理</a>
            </td>
        </tr>
        <tbody id=c_1>
        <tr>
            <td class=bar2 height=20>  <img src="images/file.png"> <a href="showUser" target="main_frame">查看用户</a></td>
        </tr>
        <tr>
            <td class=bar2 height=20>  <img src="images/file.png"> <a href="backend/todo.jsp" target="main_frame">添加用户</a>
            </td>
        </tr>
        <tr>
            <td class=bar2 height=20>  <img src="images/file.png"> <a href="backend/todo.jsp" target="main_frame">更新用户</a>
            </td>
        </tr>
        <tr>
            <td class=bar2 height=20>  <img src="images/file.png"> <a href="backend/todo.jsp" target="main_frame">删除用户</a>
            </td>
        </tr>
        </tbody>
    
        <tbody>
        <tr>
            <td class=catemenu> <a
                    style='CURSOR: pointer' οnclick=show(2)><img src="images/folder.png">
                类别管理</a></td>
        </tr>
        <tbody id=c_2 style='DISPLAY: none'>
        <tr>
            <td class=bar2 height=20>  <img src="images/file.png"> <a href="backend/todo.jsp" target="main_frame">查看类别</a>
            </td>
        </tr>
        <tr>
            <td class=bar2 height=20>  <img src="images/file.png"> <a href="backend/todo.jsp" target="main_frame">添加类别</a>
            </td>
        </tr>
        <tr>
            <td class=bar2 height=20>  <img src="images/file.png"> <a href="backend/todo.jsp" target="main_frame">更新类别</a>
            </td>
        </tr>
        <tr>
            <td class=bar2 height=20>  <img src="images/file.png"> <a href="backend/todo.jsp" target="main_frame">删除类别</a>
            </td>
        </tr>
        </tbody>
    
        <tbody>
        <tr>
            <td class=catemenu> <a
                    style='CURSOR: pointer' οnclick=show(3)><img src="images/folder.png">
                商品管理</a></td>
        </tr>
        <tbody id=c_3 style='DISPLAY: none'>
        <tr>
            <td class=bar2 height=20>  <img src="images/file.png"> <a href="backend/todo.jsp" target="main_frame">查看商品</a>
            </td>
        </tr>
        <tr>
            <td class=bar2 height=20>  <img src="images/file.png"> <a href="backend/todo.jsp" target="main_frame">添加商品</a>
            </td>
        </tr>
        <tr>
            <td class=bar2 height=20>  <img src="images/file.png"> <a href="backend/todo.jsp" target="main_frame">更新商品</a>
            </td>
        </tr>
        <tr>
            <td class=bar2 height=20>  <img src="images/file.png"> <a href="backend/todo.jsp" target="main_frame">删除商品</a>
            </td>
        </tr>
        </tbody>
    
        <tbody>
        <tr>
            <td class=catemenu> <a
                    style='CURSOR: pointer' οnclick=show(4)><img src="images/folder.png">
                订单管理</a></td>
        </tr>
        <tbody id=c_4 style='DISPLAY: none'>
        <tr>
            <td class=bar2 height=20>  <img src="images/file.png"> <a href="backend/todo.jsp" target="main_frame">查看订单</a>
            </td>
        </tr>
        <tr>
            <td class=bar2 height=20>  <img src="images/file.png"> <a href="backend/todo.jsp" target="main_frame">删除订单</a>
            </td>
        </tr>
        </tbody>
    </table>
    </body>
    </html>
    
    
    

    10、后台管理主页面顶面板页面top.jsp

    在这里插入图片描述

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    
    <c:set var="path" value="${pageContext.request.contextPath}"/>
    <c:set var="basePath"
           value="${pageContext.request.scheme}://${pageContext.request.serverName}:${pageContext.request.serverPort}${path}/"/>
    <!DOCTYPE html>
    <html>
    <head>
        <title>后台管理顶面板</title>
        <base href="${basePath}">
    </head>
    <body style="margin:0px">
    <img src="images/title.png" width="100%" height="100%">
    </body>
    </html>
    
    

    11、后台管理主页面主面板页面main.jsp在这里插入图片描述

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    
    <c:set var="path" value="${pageContext.request.contextPath}"/>
    <c:set var="basePath"
           value="${pageContext.request.scheme}://${pageContext.request.serverName}:${pageContext.request.serverPort}${path}/"/>
    <!DOCTYPE html>
    <html>
    <head>
        <title>后台管理主面板</title>
        <base href="${basePath}">
    </head>
    <body>
    <img src="images/mainBack.gif" width="100%" height="100%"/>
    </body>
    </html>
    
    

    重启服务器,以管理员身份登录(admin:12345)进入后台管理页面:
    在这里插入图片描述

    12、查看用户页面showUser.jsp

    <%@ page language="java" contentType="text/html; charset=UTF-8"
             pageEncoding="UTF-8" %>
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    <%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
    
    <c:set var="path" value="${pageContext.request.contextPath}"/>
    <c:set var="basePath"
           value="${pageContext.request.scheme}://${pageContext.request.serverName}:${pageContext.request.serverPort}${path}/"/>
    <!DOCTYPE html>
    <html>
    <head>
        <title>显示用户信息</title>
        <base href="${basePath}">
        <link href="css/main.css" rel="stylesheet" type="text/css"/>
    </head>
    <body>
    <hr>
    <table width="90%" border="0px">
        <tr>
            <td align="left">登录用户:<span style="color: red;">${username}</span></td>
            <td align="right"><a href="user/logout" target="_parent">注销</a></td>
        </tr>
    </table>
    <hr>
    <h3>用户列表</h3>
    <hr>
    <table border="1" width="90%" cellspacing="0">
        <tr>
            <th>编号</th>
            <th>用户名</th>
            <th>密码</th>
            <th>电话</th>
            <th>注册时间</th>
            <th>权限</th>
        </tr>
        <c:forEach var="user" items="${users}">
            <tr align="center">
                <td>${user.id}</td>
                <td>${user.username}</td>
                <td>${user.password}</td>
                <td>${user.telephone}</td>
                <td><fmt:formatDate value="${user.registerTime}" pattern="yyyy-MM-dd hh:mm:ss"/></td>
                <td>
                    <c:choose>
                        <c:when test="${user.popedom==0}">
                            管理员
                        </c:when>
                        <c:otherwise>
                            普通用户
                        </c:otherwise>
                    </c:choose>
                </td>
            </tr>
        </c:forEach>
    </table>
    <hr>
    </body>
    </html>
    
    

    重启服务器,以管理员身份登录,进入后台管理页面,查看用户:
    在这里插入图片描述

    13、待做页面todo.jsp

    在这里插入图片描述
    重启服务器,以管理员身份登录,单击【添加用户】:
    在这里插入图片描述

    五、实训总结

    本项目采用MVC模式,视图层采用JSP页面(使用了核心标签库JSTL,2016年的没有采用核心标签库,采用纯粹的JSP脚本<% … %>,同学们可以做个对比),控制层采用Servlet(获取页面提交数据,连接后台数据库进行处理,根据处理结果进行页面跳转),模型层采用JDBC操作后台数据库(建议采用数据源方式获取数据库连接)。

    后台管理只完成了用户管理的【查看用户】功能,其余的,类别管理、商品管理与订单管理,留待同学们自行完成,通过实战提高代码编写能力。

    展开全文
  • 用bootstrap做的一个校园前端实训项目,有很强的参考价值。
  • Java Web实训项目:西蒙购物网(中)

    千次阅读 2019-12-05 11:10:06
  • HTML中有个font-size属性 默认是16px 此时 进行移动端开发时 1rem(em)=16px 若对HTML的font-size属性进行更改 如: <style type="text/css"> html{ font-size: 10px; } </style>...
  • web前端结业期末实训项目.zip
  • 图书书屋-实训项目 20级Java Web实训项目
  • 控制层 在src里创建net.hw.shop.servlet包,在里面创建各种控制处理类。 1、登录处理类Loginservlet 修改登录页面信息 运行一下首页 运行Tomcat到网页输入login?...当我们使用用户登...
  • web基础实训青软实训 漫步时尚广场项目源代码以及图片从第一章到第十二章全,包括图片代码,每一章节一个文件夹。从前端到后端界面,从显示产品到注册、登录、发布、审核产品的静态页面都有。 非常不错的实训资源
  • 项目4 WEB服务器配置与管理一、 实训目的1、掌握Linux系统中Apache服务器的安装与配置 2、掌握虚拟主机的搭建方法。 二、 实训内容安装Web服务器; 配置虚拟主机; 三、 任务情境某企业打算自己维护Web服务器,在...
  • package net.lfh.shop.bean; /** * 功能:商品类别实体类 * 作者:李福华 * 日期:2019年12月5日 */ public class Category { /** * 类别标识符 */ private int id; /** * 类别名称 ...}
  • Java Web实训项目:西蒙购物网(上)

    千次阅读 2019-12-02 08:59:32
    三、实现步骤 (一)创建数据库 1、用户表t_user 2、类别表t_category 3、商品表t_product 4、订单表t_order (二)创建Web项目 1、创建Web项目simonshop 2、在项目结构窗口里设置Artifacts名称:simonshop 3、配置...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,170
精华内容 4,068
关键字:

web实训项目介绍