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

目录

一、功能需求

1、普通用户

2、管理员用户

二、设计思路

（一）采用MVC设计模式

（二）前台购物

1、购物流程

2、用户注册

（三）后台管理

1、用户管理

2、类别管理

3、商品管理

4、订单管理

（四）西蒙购物网业务流程图

三、运行效果

（一）前台操作

（二）后台操作

四、创建数据库

1、用户表结构及记录

2、类别表结构及记录

3、商品表结构及记录

4、订单表结构及记录

五、项目结构图

六、系统实现

（一）实体类（net.hw.bean）

1、用户实体（User）

2、类别实体（Category）

3、商品实体（Product）

4、订单实体（Order）

（二）数据库工具类（net.hw.dbutil）

1、在META-INF目录里创建context.xml

2、在部署描述文件里声明数据源

3、修改数据库连接管理类

（三）数据访问层接口（XXXDao）

1、用户数据访问接口（UserDao）

2、类别数据访问接口（CategoryDao）

3、商品数据访问接口（ProductDao）

4、订单数据访问接口（OrderDao）

（四）数据访问层实现类（XXXDaoImpl）

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

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

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

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

（五）数据服务层接口（XXXService）

1、用户服务接口（UserService）

2、类别服务接口（CategoryService）

3、商品服务接口（ProductService）

4、订单服务接口（OrderService）

（六）数据服务实现类（XXXServiceImpl）

1、用户服务实现类（UserServiceImpl）

2、类别服务实现类（CategoryServiceImpl）

3、商品服务实现类（ProductServiceImpl）

4、订单服务实现类（OrderServiceImpl）

（七）控制层（XXXServlet）

1、登录处理类（LoginServlet）

2、注销处理类（LogoutServlet）

3、注册处理类（RegisterServlet）

4、显示类别处理类（ShowCategoryServlet）

5、显示商品处理类（ShowProductServlet）

6、显示购物车处理类（ShowCartServlet）

7、操作购物车处理类（OperateCartServlet）

8、生成订单处理类（MakeOrderServlet）

9、支付处理类（PayServlet）

10、显示用户处理类（ShowUserServlet）

（八）部署描述文件web.xml

（九）图片资源（/images/XXX.jpg或XXX.png）

（十）CSS文件（/css/main.css）

（十一）JavaScript文件（/scripts/check.js）

（十二）展现层页面（JSP）

1、登录页面（/login.jsp）

2、前台页面（/frontend/XXX.jsp）

（1）注册页面register.jsp

（2）显示类别页面showCategory.jsp

（3）显示商品页面showProduct.jsp

（4）显示购物车页面showCart.jsp

（5）生成订单页面makeOrder.jsp

（6）显示订单页面showOrder.jsp

3、后台页面（/backend/XXX.jsp）

（1）后台管理左边面板页面left.jsp

（2）主页面main.html

（3）顶部页面top.html

（4）后台管理页面management.jsp

（5）显示用户页面showUser.jsp

---

一、功能需求

1、普通用户

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

2、管理员用户

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

二、设计思路

（一）采用MVC设计模式

分层架构：展现层（JSP）<——>控制层（Servlet）<——>业务层（Service）<——>模型层（Dao）<——>数据库（DB）

（二）前台购物

1、购物流程

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

2、用户注册

系统只有一个管理员，在注册页面注册的都是普通用户。

（三）后台管理

1、用户管理

用户的增删改查

2、类别管理

商品类别的增删改查

3、商品管理

商品的增删改查

4、订单管理

订单的查看与删除

（四）西蒙购物网业务流程图

三、运行效果

（一）前台操作

1、进入登录页面

2、不输入用户名和密码，单击登录按钮，弹出消息框：

3、输入用户名和密码，单击登录按钮，如果错误，就会弹出消息框：

4、输入用户名和密码，单击登录按钮，如果正确，并且是普通用户，跳转到显示商品类别页面：

5、选择一个类别，比如【床上用品】，跳转到显示商品页面：

6、选购商品，加入购物车：

7、在购物车里删除已选购的商品：

8、单击生成订单超链接，跳转到生成订单页面：

9、输入联系电话和送货地址

10、单击【生成订单】按钮，跳转到显示订单页面：

11、单击支付超链接，弹出消息框，显示支付成功，跳转到登录页面：

（二）后台操作

以管理员身份登录，进入后台：

单击用户管理下的查看用户超链接：

四、创建数据库

创建MySQL数据库simonshop，包含四张表：用户表（t_user）、类别表（t_category）、商品表（t_product）和订单表（t_order）。

1、用户表结构及记录

2、类别表结构及记录

3、商品表结构及记录

4、订单表结构及记录

五、项目结构图

六、系统实现

（一）实体类（net.hw.bean）

1、用户实体（User）

/**
 * 功能：用户实体类
 * 作者：华卫
 * 日期：2016年12月2日
 */
package net.hw.bean;

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）

/**
 * 功能：商品类别实体类
 * 作者：华卫
 * 日期：2016年12月2日
 */
package net.hw.bean;

public class Category {
    /**
    * 类别标识符
    */
    private int id;
    /**
    * 类别名称
    */
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Category [id=" + id + ", name=" + name + "]";
    }
}

3、商品实体（Product）

/**
 * 功能：商品实体类
 * 作者：华卫
 * 日期：2016年12月2日
 */
package net.hw.bean;

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）

/**
 * 功能：订单实体类
 * 作者：华卫
 * 日期：2016年12月2日
 */
package net.hw.bean;

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 + "]";
    }   
}

（二）数据库工具类（net.hw.dbutil）

/**
 * 功能：数据库连接管理类
 * 作者：华卫
 * 日期：2016年12月2日
 */
package net.hw.dbutil;

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 = "root";
    
    /**
    * 私有化构造方法，拒绝实例化
    */
    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);
    }
}

采用数据库连接池，效率更高，建议大家使用这种方式来获取数据库连接。

1、在META-INF目录里创建context.xml

2、在部署描述文件里声明数据源

3、修改数据库连接管理类

/**
 * 功能：数据库连接管理类
 * 作者：华卫
 * 日期：2016年12月2日
 */
package net.hw.dbutil;

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

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;

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

    // 获得数据库连接的静态方法
    public static Connection getConnection() {
        // 声明数据库连接
        Connection conn = null;
        
        try {
            // 初始化环境
            Context ctx = new InitialContext();
            // 从数据库连接池里寻找数据源
            DataSource ds = (DataSource) ctx.lookup("java:comp/env/jdbc/simonshop");
            // 从数据源得到数据库连接
            conn = ds.getConnection();
        } catch (NamingException 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();
            }
        }
    }
}

（三）数据访问层接口（XXXDao）

1、用户数据访问接口（UserDao）

/**
 * 功能：用户数据访问接口
 * 作者：华卫
 * 日期：2016年12月2日
 */
package net.hw.dao;

import java.util.List;

import net.hw.bean.User;

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

2、类别数据访问接口（CategoryDao）

/**
 * 功能：类别数据访问接口
 * 作者：华卫
 * 日期：2016年12月10日
 */
package net.hw.dao;

import java.util.List;

import net.hw.bean.Category;

public interface CategoryDao {
    // 插入类别
    int insert(Category category);
    // 按标识符删除类别
    int deleteById(int id);
    // 更新类别
    int update(Category category);
    // 按标识符查询类别
    Category findById(int id);
    // 查询全部类别
    List findAll();
}

3、商品数据访问接口（ProductDao）

/**
 * 功能：商品数据访问接口
 * 作者：华卫
 * 日期：2016年12月16日
 */
package net.hw.dao;

import java.util.List;

import net.hw.bean.Product;

public interface ProductDao {   
    // 插入商品
    int insert(Product product);
    // 按标识符删除商品
    int deleteById(int id);
    // 更新商品
    int update(Product product);
    // 按标识符查询商品
    Product findById(int id);
    // 按类别查询商品
    List findByCategoryId(int categoryId);
    // 查询全部商品
    List findAll();
}

4、订单数据访问接口（OrderDao）

/**
 * 功能：订单数据访问接口
 * 作者：华卫
 * 日期：2016年12月25日
 */
package net.hw.dao;

import java.util.List;

import net.hw.bean.Order;

public interface OrderDao {
    // 插入订单
    int insert(Order order);
    // 按标识符删除订单
    int deleteById(int id);
    // 更新订单
    int update(Order order);
    // 按标识符查询订单
    Order findById(int id);
    // 查询最后一个订单
    Order findLast();
    // 查询全部订单
    List findAll();
}

（四）数据访问层实现类（XXXDaoImpl）

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

/**
 * 功能：用户数据访问接口实现类
 * 作者：华卫
 * 日期：2016年12月2日
 */
package net.hw.dao.impl;

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

import net.hw.bean.Category;
import net.hw.bean.User;
import net.hw.dao.UserDao;
import net.hw.dbutil.ConnectionManager;
import sun.awt.image.PixelConverter.Rgba;

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 findByUsername(String username) {
        // 声明用户列表
        List users = new ArrayList();
        // 获取数据库连接对象
        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 findAll() {
        // 声明用户列表
        List users = new ArrayList();
        // 获取数据库连接对象
        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;
    }
}

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

/**
 * 功能：类别数据访问接口实现类
 * 作者：华卫
 * 日期：2016年12月10日
 */
package net.hw.dao.impl;

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

import net.hw.bean.Category;
import net.hw.dao.CategoryDao;
import net.hw.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 findAll() {
        // 声明类别列表
        List categories = new ArrayList();
        // 获取数据库连接对象
        Connection conn = ConnectionManager.getConnection();
        // 定义SQL字符串
        String strSQL = "SELECT * FROM t_category";
        try {
            // 创建语句对象
            Statement stmt = conn.createStatement();
            // 执行SQL，返回结果集
            ResultSet rs = stmt.executeQuery(strSQL);
            // 遍历结果集
            while (rs.next()) {
                // 创建类别实体
                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;
    }   
}

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

/**
 * 功能：产品数据访问接口实现类
 * 作者：华卫
 * 日期：2016年12月16日
 */
package net.hw.dao.impl;

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

import net.hw.bean.Product;
import net.hw.bean.User;
import net.hw.dao.ProductDao;
import net.hw.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 findByCategoryId(int categoryId) {
        // 定义商品列表
        List products = new ArrayList();

        // 获取数据库连接
        Connection conn = ConnectionManager.getConnection();
        // 定义SQL字符串
        String strSQL = "SELECT * FROM t_product WHERE category_id = ?";
        try {
            // 创建预备语句
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 设置占位符的值
            pstmt.setInt(1, categoryId);
            // 执行SQL语句，返回结果集
            ResultSet rs = pstmt.executeQuery();
            // 遍历结果集，将其中的每条记录生成商品对象，添加到商品列表
            while (rs.next()) {
                // 实例化商品对象
                Product product = new Product();
                // 利用当前记录字段值设置实体对应属性
                product.setId(rs.getInt("id"));
                product.setName(rs.getString("name"));
                product.setPrice(rs.getDouble("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 findAll() {
        // 声明商品列表
        List products = new ArrayList();
        // 获取数据库连接对象
        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;
    }
}

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

/**
 * 功能：订单数据访问接口实现类
 * 作者：华卫
 * 日期：2016年12月25日
 */
package net.hw.dao.impl;

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

import net.hw.bean.Category;
import net.hw.bean.Order;
import net.hw.bean.User;
import net.hw.dao.OrderDao;
import net.hw.dbutil.ConnectionManager;
import sun.awt.image.PixelConverter.Rgba;

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 findAll() {
        // 声明订单列表
        List orders = new ArrayList();
        // 获取数据库连接对象
        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;
    }
}

（五）数据服务层接口（XXXService）

1、用户服务接口（UserService）

/**
 * 功能：用户服务接口
 * 作者：华卫
 * 日期：2016年12月2日
 */
package net.hw.service;

import java.util.List;

import net.hw.bean.User;

public interface UserService {
    // 添加用户
    int addUser(User user);
    // 按标识符删除用户
    int deleteUserById(int id);
    // 更新用户
    int updateUser(User user);
    // 按标识符查询用户
    User findUserById(int id);
    // 按用户名查询用户
    List findUsersByUsername(String username);
    // 查询全部用户
    List findAllUsers();
    // 用户登录
    User login(String username, String password);
}

2、类别服务接口（CategoryService）

/**
 * 功能：类别服务接口
 * 作者：华卫
 * 日期：2016年12月10日
 */
package net.hw.service;

import java.util.List;

import net.hw.bean.Category;

public interface CategoryService {
    // 添加类别
    int addCategory(Category category);
    // 按标识符删除类别
    int deleteCategoryById(int id);
    // 更新类别
    int updateCategory(Category category);
    // 按标识符查询类别
    Category findCategoryById(int id);
    // 查询全部类别
    List findAllCategories();
}

3、商品服务接口（ProductService）

/**
 * 功能：商品服务接口
 * 作者：华卫
 * 日期：2016年12月16日
 */
package net.hw.service;

import java.util.List;

import net.hw.bean.Product;

public interface ProductService {
    // 添加商品
    int addProduct(Product product);
    // 按标识符删除商品
    int deleteProductById(int id);
    // 更新商品
    int updateProduct(Product product);
    // 按标识符查询商品
    Product findProductById(int id);
    // 按类别查询商品
    List findProductsByCategoryId(int categoryId);
    // 查询全部商品
    List findAllProducts();
}

4、订单服务接口（OrderService）

/**
 * 功能：订单服务接口
 * 作者：华卫
 * 日期：2016年12月25日
 */
package net.hw.service;

import java.util.List;

import net.hw.bean.Order;

public interface OrderService {
    // 添加订单
    int addOrder(Order order);
    // 按标识符删除订单
    int deleteOrderById(int id);
    // 更新订单
    int updateOrder(Order order);
    // 查询最后一个订单
    Order findLastOrder();
    // 按标识符查询订单
    Order findOrderById(int id);
    // 查询全部订单
    List findAllOrders();
}

（六）数据服务实现类（XXXServiceImpl）

1、用户服务实现类（UserServiceImpl）

/**
 * 功能：用户服务实现类
 * 作者：华卫
 * 日期：2016年12月2日
 */
package net.hw.service.impl;

import java.util.List;

import net.hw.bean.User;
import net.hw.dao.UserDao;
import net.hw.dao.impl.UserDaoImpl;
import net.hw.service.UserService;

public class UserServiceImpl implements UserService{    
    /**
    * 声明用户访问对象
    */
    private UserDao userDao = new UserDaoImpl();
    
    @Override
    public int addUser(User user) {
        return userDao.insert(user);
    }

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

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

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

    @Override
    public List findUsersByUsername(String username) {
        return userDao.findByUsername(username);
    }

    @Override
    public List findAllUsers() {
        return userDao.findAll();
    }

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

2、类别服务实现类（CategoryServiceImpl）

/**
 * 功能：类别服务实现类
 * 作者：华卫
 * 日期：2016年12月10日
 */
package net.hw.service.impl;

import java.util.List;

import net.hw.bean.Category;
import net.hw.dao.CategoryDao;
import net.hw.dao.impl.CategoryDaoImpl;
import net.hw.service.CategoryService;

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

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

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

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

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

    @Override
    public List findAllCategories() {
        return categoryDao.findAll();
    }
}

3、商品服务实现类（ProductServiceImpl）

/**
 * 功能：商品服务实现类
 * 作者：华卫
 * 日期：2016年12月16日
 */
package net.hw.service.impl;

import java.util.List;

import net.hw.bean.Product;
import net.hw.dao.ProductDao;
import net.hw.dao.impl.ProductDaoImpl;
import net.hw.service.ProductService;

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

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

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

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

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

    @Override
    public List findProductsByCategoryId(int categoryId) {
        return productDao.findByCategoryId(categoryId);
    }

    @Override
    public List findAllProducts() {
        return productDao.findAll();
    }
}

4、订单服务实现类（OrderServiceImpl）

/**
 * 功能：订单服务实现类
 * 作者：华卫
 * 日期：2016年12月19日
 */
package net.hw.service.impl;

import java.util.List;

import net.hw.bean.Order;
import net.hw.dao.OrderDao;
import net.hw.dao.impl.OrderDaoImpl;
import net.hw.service.OrderService;

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

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

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

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

    @Override
    public Order findOrderById(int id) {
        return orderDao.findById(id);
    }
    
    @Override
    public Order findLastOrder() {
        return orderDao.findLast();
    }

    @Override
    public List findAllOrders() {
        return orderDao.findAll();
    }
}

（七）控制层（XXXServlet）

1、登录处理类（LoginServlet）

/**
 * 功能：登录处理类
 * 作者：华卫
 * 日期：2016年12月2日
 */
package net.hw.servlet;

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.hw.bean.User;
import net.hw.service.UserService;
import net.hw.service.impl.UserServiceImpl;

@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 UserServiceImpl();
        // 执行登录方法，返回用户实体
        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) {
                response.sendRedirect(request.getContextPath() + "/backend/management.jsp");
            } else if (user.getPopedom() == 1) {
                response.sendRedirect(request.getContextPath() + "/showCategory");
            }
        } else {
            // 设置session属性
            session.setAttribute("loginMsg", "用户名或密码错误！");
            response.sendRedirect(request.getContextPath() + "/login.jsp");
        }
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doGet(request, response);
    }
}

2、注销处理类（LogoutServlet）

/**
 * 功能：注销处理类
 * 作者：华卫
 * 日期：2016年12月25日
 */
package net.hw.servlet;

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");
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        doGet(request, response);
    }
}

3、注册处理类（RegisterServlet）

/**
 * 功能：处理用户注册
 * 作者：华卫
 * 日期：
 */
package net.hw.servlet;

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.hw.bean.User;
import net.hw.service.UserService;
import net.hw.service.impl.UserServiceImpl;

@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 UserServiceImpl();        
        // 调用UserService对象的注册方法
        int count = userService.addUser(user);  
        
        // 判断是否注册成功
        if (count > 0) {            
            // 设置session属性
            session.setAttribute("registerMsg", "恭喜，注册成功！");
            // 重定向到登录页面
            response.sendRedirect(request.getContextPath() + "/login.jsp");
        } else {        
            // 设置session属性
            session.setAttribute("registerMsg", "遗憾，注册失败！");
            // 重定向到注册页面
            response.sendRedirect(request.getContextPath() + "/frontend/register.jsp");
        }
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doGet(request, response);
    }
}

4、显示类别处理类（ShowCategoryServlet）

/**
 * 功能：显示类别控制程序
 * 作者：华卫
 * 日期：2016年12月16日
 */
package net.hw.servlet;

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.hw.bean.Category;
import net.hw.service.CategoryService;
import net.hw.service.impl.CategoryServiceImpl;

@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 CategoryServiceImpl();
        // 获取全部商品类别
        List categories = categoryService.findAllCategories();
        // 获取session对象
        HttpSession session = request.getSession();
        // 把商品类别列表以属性的方式保存到session里
        session.setAttribute("categories", categories);     
        // 重定向到显示商品类别页面（showCategory.jsp）
        response.sendRedirect(request.getContextPath() + "/frontend/showCategory.jsp");
    }
    
    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        doGet(request, response);
    }
}

5、显示商品处理类（ShowProductServlet）

/**
 * 功能：显示商品列表的控制程序
 *     通过业务层访问后台数据，
 *     然后将数据返回给前台页面
 * 作者：华卫
 * 日期：2016年12月16日
 */
package net.hw.servlet;

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.hw.bean.Product;
import net.hw.service.CategoryService;
import net.hw.service.ProductService;
import net.hw.service.impl.CategoryServiceImpl;
import net.hw.service.impl.ProductServiceImpl;

@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 CategoryServiceImpl();
        // 由类别标识符获取类别名
        String categoryName = categoryService.findCategoryById(categoryId).getName();       
        // 创建商品服务对象
        ProductService productService = new ProductServiceImpl();
        // 获取指定商品类别的商品列表
        List products = productService.findProductsByCategoryId(categoryId);
        // 获取session对象
        HttpSession session = request.getSession();
        // 把商品列表对象以属性的方式保存到session里
        session.setAttribute("products", products);
        // 重定向到显示商品信息页面
        response.sendRedirect(request.getContextPath() + "/frontend/showProduct.jsp?categoryName=" + categoryName);
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        doGet(request, response);
    }
}

6、显示购物车处理类（ShowCartServlet）

/**
 * 功能：显示购物车控制程序
 * 作者：华卫
 * 日期：2016年12月23日。
 */
package net.hw.servlet;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
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.hw.bean.Product;
import net.hw.service.ProductService;
import net.hw.service.impl.ProductServiceImpl;

@WebServlet("/showCart")
public class ShowCartServlet 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"));
        // 获取session对象
        HttpSession session = request.getSession();
        // 获取购物车
        LinkedHashMap cart = (LinkedHashMap) session.getAttribute("cart");

        // 判断购物车是否为空
        if (cart != null) {
            // 定义购物表
            List> shoppingTable = new ArrayList>();
            // 创建商品服务对象
            ProductService productService = new ProductServiceImpl();
            // 购物总金额
            double totalPrice = 0.0;
            // 遍历购物车
            for (Integer id : cart.keySet()) {
                // 获取商品对象
                Product product = productService.findProductById(id);
                // 生成购物表记录
                HashMap shoppingItem = new HashMap();
                shoppingItem.put("id", product.getId());
                shoppingItem.put("name", product.getName());
                shoppingItem.put("price", product.getPrice());
                shoppingItem.put("amount", cart.get(id));
                shoppingItem.put("sum", product.getPrice() * cart.get(id));
                // 将购物表记录添加到购物表中
                shoppingTable.add(shoppingItem);
                // 累加购买总金额
                totalPrice = totalPrice + (Double) shoppingItem.get("sum");
            }

            // 将购物表和购买总金额保存到session里
            session.setAttribute("shoppingTable", shoppingTable);
            session.setAttribute("totalPrice", totalPrice);

            // 重定向到显示商品控制程序
            response.sendRedirect(request.getContextPath() + "/showProduct?categoryId=" + categoryId);
        }
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doGet(request, response);
    }
}

7、操作购物车处理类（OperateCartServlet）

/**
 * 功能：操作购物车控制程序
 * 作者：华卫
 * 日期：2016年12月23日
 */
package net.hw.servlet;

import java.io.IOException;
import java.util.LinkedHashMap;

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 net.hw.service.ProductService;
import net.hw.service.impl.ProductServiceImpl;

@WebServlet("/operateCart")
public class OperateCartServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        // 获取商品标识符
        int id = Integer.parseInt(request.getParameter("id"));
        // 获取商品操作
        String operation = request.getParameter("operation");

        // 从session里获取购物车（键：商品标识符；值：购买数量）
        LinkedHashMap cart = (LinkedHashMap) request.getSession()
                .getAttribute("cart");
        // 判断购物车是否为空
        if (cart == null) {
            // 创建购物车
            cart = new LinkedHashMap();
            // 将购物车保存到session里，便于用户在不同页面访问购物车
            request.getSession().setAttribute("cart", cart);
        }

        if (operation.equals("add")) {
            // 将商品添加到购物车
            if (cart.containsKey(id)) { // 该商品已购买过
                // 购买数量增加1
                cart.put(id, cart.get(id) + 1);
            } else { // 该商品未曾购买
                // 购买数量设置为1
                cart.put(id, 1);
            }
        } else if (operation.equals("delete")){
            // 将商品从购物车删除
            if (cart.get(id) > 1) {
                // 购买数量减少1
                cart.put(id, cart.get(id) - 1);
            } else {
                // 从购物车里删除该商品
                cart.remove(id);
            }
        }

        // 创建商品服务对象
        ProductService productService = new ProductServiceImpl();
        // 获取该商品类别标识符
        int categoryId = productService.findProductById(id).getCategoryId();
        // 重定向到显示购物车控制程序
        response.sendRedirect(request.getContextPath() + "/showCart?categoryId=" + categoryId);
    }
}

8、生成订单处理类（MakeOrderServlet）

/**
 * 功能：生成订单控制程序
 * 作者：华卫
 * 日期：2016年12月16日
 */
package net.hw.servlet;

import java.io.IOException;
import java.sql.Timestamp;
import java.util.Date;
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.hw.bean.Order;
import net.hw.bean.User;
import net.hw.service.OrderService;
import net.hw.service.UserService;
import net.hw.service.impl.OrderServiceImpl;
import net.hw.service.impl.UserServiceImpl;
import sun.org.mozilla.javascript.internal.ast.NewExpression;

@WebServlet("/makeOrder")
public class MakeOrderServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    protected void doGet(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        // 设置请求对象的字符编码
        request.setCharacterEncoding("utf-8");
        // 获取表单提交数据
        String username = request.getParameter("username");
        String telephone = request.getParameter("telephone");
        Double totalPrice = Double.parseDouble(request.getParameter("totalPrice"));
        String deliveryAddress = request.getParameter("deliveryAddress");
        // 创建订单对象
        Order order = new Order();
        // 设置订单属性
        order.setUsername(username);
        order.setTotalPrice(totalPrice);
        order.setTelephone(telephone);
        order.setDeliveryAddress(deliveryAddress);
        order.setOrderTime(new Date());
        // 创建订单服务
        OrderService orderService = new OrderServiceImpl();
        // 添加订单
        orderService.addOrder(order);
        // 获取最后一个订单
        Order lastOrder = orderService.findLastOrder();     
        // 保存到session里
        request.getSession().setAttribute("lastOrder", lastOrder);      
        // 重定向到显示订单页面
        response.sendRedirect(request.getContextPath() + "/frontend/showOrder.jsp");
    }
    
    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        doGet(request, response);
    }
}

9、支付处理类（PayServlet）

/**
 * 功能：支付处理程序
 * 作者：华卫
 * 日期：2016年12月25日
 */
package net.hw.servlet;

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 net.hw.bean.User;
import net.hw.service.UserService;
import net.hw.service.impl.UserServiceImpl;

@WebServlet("/pay")
public class PayServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        // 设置请求对象的字符编码
        request.setCharacterEncoding("utf-8");
        ///
        // 待做部分
        // 设置session失效
        request.getSession().invalidate();
        // 重定向到登录页面
        response.sendRedirect(request.getContextPath() + "/login.jsp");
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doGet(request, response);
    }
}

10、显示用户处理类（ShowUserServlet）

/**
 * 功能：显示用户控制程序
 * 作者：华卫
 * 日期：2016年12月16日
 */
package net.hw.servlet;

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.hw.bean.User;
import net.hw.service.UserService;
import net.hw.service.impl.UserServiceImpl;

@WebServlet("/showUser")
public class ShowUserServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    protected void doGet(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        // 创建用户服务对象
        UserService userService = new UserServiceImpl();
        // 获取全部用户
        List users = userService.findAllUsers();
        // 获取session对象
        HttpSession session = request.getSession();
        // 把用户列表以属性的方式保存到session里
        session.setAttribute("users", users);       
        // 重定向到显示用户页面（showUser.jsp）
        response.sendRedirect(request.getContextPath() + "/backend/showUser.jsp");
    }
    
    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        doGet(request, response);
    }
}

（八）部署描述文件web.xml

    simonshop
    
        login.jsp
    

    
        jdbc/simonshop
        javax.sql.DataSource
        Container
    

（九）图片资源（/images/XXX.jpg或XXX.png）

（十）CSS文件（/css/main.css）

/* 样式 */
body {
    margin:0px;
    text-align:center;
    background:url("../images/background.jpg") no-repeat;   
    background-size:100%
}

table{
    margin: 0 auto;
}

（十一）JavaScript文件（/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 patrn = "/^(13[0-9]|14[0-9]|15[0-9]|18[0-9])\d{8}$/";
    if (!patrn.exec(telephone)) {
        alert("非法手机号！");
        // 让手机号码文本框获得焦点
        telephone.focus();
        return false;
    }
        
    return true; // 表明可以提交数据到服务器端
}

（十二）展现层页面（JSP）

1、登录页面（/login.jsp）

<%@page import="java.net.URLEncoder"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>











西蒙购物网

用户登录


    

        

            
账号
            

        
        

            
密码
            

        
        

            

                
                
            
           
        
    
    
    
如果你不是本站用户，单击此处注册。

<%
    // 获取注册信息
    String registerMsg = (String) session.getAttribute("registerMsg");
    // 判断注册信息是否为空
    if (registerMsg != null) {          
%>
    
    
<%
    }
%>

<%
    // 获取登录信息
    String loginMsg = (String) session.getAttribute("loginMsg");
    // 判断登录信息是否为空
    if (loginMsg != null) {         
%>
    
    
<%
    }
%>

<%
    // 获取非法用户信息
    String illegalUser = (String) session.getAttribute("illegalUser");
    // 判断非法用户信息是否为空
    if (illegalUser != null) {          
%>
    
    
<%
    }
%>

2、前台页面（/frontend/XXX.jsp）

（1）注册页面register.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>











    
西蒙购物网
    

        

            
登录
        
    
    

    
用户注册
    

    

        

            

                
账号
                

            
            

                
密码
                

            
            

                
电话
                

            
            

                
 
            
        
    
    

    <%
        // 获取注册信息
        String registerMsg = (String) session.getAttribute("registerMsg");
        // 判断注册信息是否为空
        if (registerMsg != null) {
    %>
    
    
    <%
        }
    %>

（2）显示类别页面showCategory.jsp

<%@page import="net.hw.service.impl.CategoryServiceImpl"%>
<%@page import="net.hw.dao.impl.CategoryDaoImpl"%>
<%@page import="net.hw.service.CategoryService"%>
<%@page import="net.hw.bean.Category"%>
<%@page import="java.util.List"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>









    
西蒙购物网
    

    

        

            
登录用户： <%=session.getAttribute("username")%>
            
            
注销
        
    
    

    
商品类别
    

    <%
        // 判断是否是登录用户
        String username = (String) session.getAttribute("username");
        if (username == null || username.equals("")) {
            session.setAttribute("illegalUser", "请先登录！");
            response.sendRedirect(request.getContextPath() + "/login.jsp");
            return;
        } else {
            session.removeAttribute("illegalUser");
        }
        // 获取商品类别列表
        List categories = (List) session.getAttribute("categories");
        //以表格形式来输出商品信息 
        out.println("");
        out.println("");
        // 遍历商品类别列表
        for (int i = 0; i < categories.size(); i++) {
            // 获取商品类别
            Category category = categories.get(i);
            // 显示商品类别，设置超链接
            out.println("" + "" + "" + "");
        }
        out.println("
类别编号
商品类别
" + categories.get(i).getId() + "
"
                    + ""
                    + category.getName() + "
" + "
");
    %>
    

（3）显示商品页面showProduct.jsp

<%@page import="java.text.SimpleDateFormat"%>
<%@page import="net.hw.bean.Product"%>
<%@page import="java.util.List"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>









    
西蒙购物网
    

    

        

            
登录用户：<%=session.getAttribute("username")%>
            
注销
        
    
    

    欢迎选购【
    <%=request.getParameter("categoryName")%>】类商品
    

    <%
        // 判断是否是登录用户
        String username = (String) session.getAttribute("username");
        if (username == null || username.equals("")) {
            session.setAttribute("illegalUser", "请先登录！");
            response.sendRedirect(request.getContextPath() + "/login.jsp");
            return;
        } else {
            session.removeAttribute("illegalUser");
        }
        // 获取指定类别的商品列表
        List products = (List) session.getAttribute("products");
        int TOTAL_COLUMNS = 4;
        int TOTAL_ROW = products.size() % TOTAL_COLUMNS == 0 ? products.size() / TOTAL_COLUMNS
                : products.size() / TOTAL_COLUMNS + 1;
        // 以表格形式来输出商品信息 
        out.println("");
        for (int row = 1; row <= TOTAL_ROW; row++) {
            out.println("");
            for (int col = 1; col <= TOTAL_COLUMNS; col++) {
                out.println("");
            }
            out.println("");
        }
        out.println("
");
                int index = (row - 1) * TOTAL_COLUMNS + col - 1;
                if (index < products.size()) {
                    out.println("");
                    out.println("");
                    out.println("");
                    out.println("");
                    out.println("");
                    out.println("");
                    out.println("");
                    out.println("
商品编号：" + products.get(index).getId() + "
商品名称：" + products.get(index).getName() + "
销售价格：" + products.get(index).getPrice() + "元
上架时间："
                            + new SimpleDateFormat("yyyy年MM月dd日").format(products.get(index).getAddTime())
                            + "
用户操作：" + "加入购物车" + "
");
                }
                out.println("
");
    %>

    

    

（4）显示购物车页面showCart.jsp

<%@page import="java.util.HashMap"%>
<%@page import="java.util.List"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>







    
<%=session.getAttribute("username")%>的购物车
    
    <%
        // 判断是否是登录用户
        String username = (String) session.getAttribute("username");
        if (username == null || username.equals("")) {
            session.setAttribute("illegalUser", "请先登录！");
            response.sendRedirect(request.getContextPath() + "/login.jsp");
            return;
        } else {
            session.removeAttribute("illegalUser");
        }
        // 获取购物表
        List> shoppingTable = (List>) session
                .getAttribute("shoppingTable");
        // 判断购物表是否为空
        if (shoppingTable != null) {
            // 获取购物总金额
            double totalPrice = (double) session.getAttribute("totalPrice");
            // 以表格形式来输出购物表信息 
            out.println("");
            out.println("");
            // 遍历购物表
            for (int i = 0; i < shoppingTable.size(); i++) {
                out.println("" + "" + "" + "" + "" + ""
                        + "");
            }
            out.println("" + ""
                    + "" + "" + "");
            out.println("
商品编号
商品名称
销售价格
购买数量
合计金额
操作
" + shoppingTable.get(i).get("id") + "
"
                        + shoppingTable.get(i).get("name") + "
￥" + shoppingTable.get(i).get("price")
                        + "
" + shoppingTable.get(i).get("amount") + "
￥"
                        + shoppingTable.get(i).get("sum") + "
" + "删除" + "
总金额" + "
" + "
" + "
￥" + totalPrice + "
");
        } else {
            out.println("");
            out.println("");
            out.println("" + "" + "" + "" + ""
                    + "" + "" + "");
            out.println("
商品编号
商品名称
销售价格
购买数量
合计金额
操作
总金额
￥0.00
");
        }
    %>
    

    生成订单

（5）生成订单页面makeOrder.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>









    
西蒙购物网
    

    

        

            
登录用户：<%=session.getAttribute("username")%>
            
注销
        
    
    

    
生成订单
    

    

        

            

                
用户名
                
" />
            
            

                
联系电话
                

            
            

                
总金额
                
" />
            
            

                
送货地址
                

            
            

                
 
            
        
    
    

    <%
        // 判断是否是登录用户
        String username = (String) session.getAttribute("username");
        if (username == null || username.equals("")) {
            session.setAttribute("illegalUser", "请先登录！");
            response.sendRedirect(request.getContextPath() + "/login.jsp");
            return;
        } else {
            session.removeAttribute("illegalUser");
        }
    %>

（6）显示订单页面showOrder.jsp

<%@page import="net.hw.bean.Order"%>
<%@page import="java.util.HashMap"%>
<%@page import="java.util.List"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>









    
西蒙购物网
    

    

        

            
登录用户：<%=session.getAttribute("username")%>
            
注销
        
    
    

    
<%=session.getAttribute("username")%>的订单
    
    <%
        // 判断是否是登录用户
        String username = (String) session.getAttribute("username");
        if (username == null || username.equals("")) {
            session.setAttribute("illegalUser", "请先登录！");
            response.sendRedirect(request.getContextPath() + "/login.jsp");
            return;
        } else {
            session.removeAttribute("illegalUser");
        }
        // 获取订单
        Order lastOrder = (Order) session.getAttribute("lastOrder");
        // 以表格形式来输出订单信息 
        out.println("");
        out.println("");
        out.println("");
        out.println("");
        out.println("");
        out.println("");
        out.println("
订单编号
" + lastOrder.getId() + "
用户名
" + lastOrder.getUsername() + "
联系电话
" + lastOrder.getTelephone() + "
总金额
" + lastOrder.getTotalPrice() + "元
送货地址
" + lastOrder.getDeliveryAddress() + "
");
    %>
    

    支付

3、后台页面（/backend/XXX.jsp）

（1）后台管理左边面板页面left.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>






   




    

        

            

                
 用户管理??
                
            
        

            

                
   查看用户
            
            

                
   添加用户
            
            

                
   更新用户
            
            

                
   删除用户
            
        
        
        

            

                
 
                        类别管理??
            
        

            

                
   查看类别
            
            

                
   添加类别
            
            

                
   更新类别
            
            

                
   删除类别
            
        
        
        

            

                
 
                        商品管理??
            
        

            

                
   查看商品
            
            

                
   添加商品??
            
            

                
   更新商品??
            
            

                
   删除商品
            
        
        
        

            

                
 
                        订单管理??
            
        

            

                
   查看订单
            
           
            

                
   删除订单
            
                   
        
    

（2）主页面main.html

（3）顶部页面top.html

（4）后台管理页面management.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>


   
        
    
   
        
        
            
            
             
    

（5）显示用户页面showUser.jsp

<%@page import="net.hw.service.impl.UserServiceImpl"%>
<%@page import="net.hw.dao.impl.UserDaoImpl"%>
<%@page import="net.hw.service.UserService"%>
<%@page import="net.hw.bean.User"%>
<%@page import="java.util.List"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>









    

    

        

            
登录用户：<%=session.getAttribute("username")%>
            
注销
        
    
    

    
用户列表
    

    <%
        // 获取用户列表
        List users = (List) session.getAttribute("users");
        //以表格形式来输出用户信息 
        out.println("");
        out.println("");
        // 遍历商品类别列表
        for (int i = 0; i < users.size(); i++) {
            // 获取用户 
            User User = users.get(i);
            // 根据权限值显示角色名
            String role = null;
            if (users.get(i).getPopedom() == 0) {
                role = "管理员";
            } else {
                role = "普通用户";
            }
            // 显示用户信息
            out.println("" + "" + "" + "" + "" + ""
                    + "" + "");
        }
        out.println("
编号
用户名
密码
电话
注册时间
权限
" + users.get(i).getId() + "
"
                    + users.get(i).getUsername() + "
" + users.get(i).getPassword() + "
"
                    + users.get(i).getTelephone() + "
" + users.get(i).getRegisterTime() + "
" + role + "
");
    %>