JavaWeb实例：西蒙购物网

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

（二）创建Web项目simonshop

（三）创建实体类

在src里创建net.ls.shop.bean包，创建四个实体类：User、Category、Product与Order

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

1、在web\WEB-INF目录下创建lib子目录，添加MySQL驱动程序的jar包

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

package net.ls.shop.dbutil;

/**
 * 功能：数据库连接管理类
 * 作者：罗帅
 * 日期：2019年12月4日
 */

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_final";
    /**
     * 数据库用户名
     */
    private static final String USERNAME = "root";
    /**
     * 数据库密码
     */
    private static final String PASSWORD = "1";

    /**
     * 私有化构造方法，拒绝实例化
     */
    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.ls.shop.dao包，在里面创建UserDao、CategoryDao、ProductDao与OrderDao。

（六）数据访问接口实现类XXXDaoImpl

在src下创建net.ls.shop.dao.impl包，在里面创建UserDaoImpl、CategoryDaoImpl、ProductDaoImpl与OrderDaoImpl。

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

在test文件夹里创建net.ls.shop.dao.impl包，在里面创建测试类TestUserDaoImpl,TestProductDaoImpl,TestCategoryDaoImpl,TestOrderDaoImpl

TestUserDaoImpl

package net.ls.shop.dao.impl;

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


import java.sql.Timestamp;
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("18121978354");

        //更新涂文艳用户
        int count = userDao.update(user);
        //判断更新用户是否成功
        if (count>0){
            System.out.println("恭喜，用户更新成功！");
        }else{
            System.out.println("遗憾，用户更新失败！");
        }

        //再次查询涂文艳用户
        user = userDao.findById(4);
        //查看涂文艳信息
        System.out.println(user);
    }

    //插入用户信息测试
    @Test
    public void testInsert(){
        // 创建用户数据访问对象
        UserDao userDao = new UserDaoImpl();
        // 创建用户
        User user = new User();
        user.setUsername("沐风执鸢");
        user.setPassword("124123");
        user.setTelephone("18789453211");
        //Timestamp time = new Timestamp(new Date().getTime());
        String time = "2016-05-12 20:12:12";
        Timestamp t = Timestamp.valueOf(time);
        user.setRegisterTime(t);
        user.setPopedom(1);
        // 判断用户名是否存在
        List list = userDao.findByUsername(user.getUsername());
        if (list.size() > 0){
            System.out.println("遗憾，用户名已存在，插入用户失败！");
        }else {
            // 插入用户
            int count = userDao.insert(user);
            // 查询是否插入成功
            if (count > 0){
                System.out.println("恭喜，插入用户成功！");
            }else {
                System.out.println("遗憾，插入用户失败！");
            }
        }
    }

    @Test
    //测试按标识符删除用户
    //删除用户记录涂文艳
    public void TestDeleteById(){
        UserDao dao = new UserDaoImpl();
        int count = dao.deleteById(4);
        if (count > 0) {
            System.out.println("恭喜，用户记录删除成功！");
        } else {
            System.out.println("遗憾，用户记录删除失败！");
        }
    }

    @Test
    //测试按标识符查询用户
    //查询用户记录温志军
    public void TestFindById(){
        UserDao dao = new UserDaoImpl();
        User user = dao.findById(3);
        System.out.println(user);
    }

    @Test
    //测试按用户名查询用户
    //查询用户记录温志军
    public void FindByUsername() {
        UserDao userDao = new UserDaoImpl();
        List<User> users = userDao.findByUsername("温志军");
        //判断是否有用户
        if (users.size() > 0) {
            for (User user : users) {
                System.out.println(user);
            }
        } else {
            System.out.println("没有此用户！");
        }
    }

    @Test
    //测试查询所有用户
    public void findAll(){
        UserDao userDao = new UserDaoImpl();
        List<User> users = userDao.findAll();
        //判断是否有用户
        if (users.size() > 0){
            for (User user: users){
                System.out.println(user);
            }
        }else {
            System.out.println("没有用户！");
        }
    }
}

TestProductDaoImpl

package net.ls.shop.dao.impl;

import net.ls.shop.bean.Product;
import net.ls.shop.dao.CategoryDao;
import net.ls.shop.dao.ProductDao;
import org.junit.Test;

import java.util.Date;
import java.sql.Timestamp;
import java.util.List;

public class TestProductDaoImpl {
    @Test
    //按类别查询商品
    public void testFindByCategoryId() {
        // 创建商品数据访问对象
        ProductDao productDao = new ProductDaoImpl();
        // 定义商品类别编号
        int categoryId = 4;
        // 创建商品类别数据访问对象
        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 TestByInsert() {
        //创建商品数据访问对象
        ProductDao productDao = new ProductDaoImpl();
        //创建商品
        Product product = new Product();
        product.setName("海尔空调");
        product.setPrice(16666);
        Timestamp time = new Timestamp(new Date().getTime());
        product.setAddTime(time);
        product.setCategoryId(1);
        //插入类别
        int count = productDao.insert(product);
        // 查询是否插入成功
        if (count > 0) {
            System.out.println("恭喜，商品类别插入成功!");
        } else {
            System.out.println("遗憾，商品类别插入成功!");
        }
    }

    @Test
    // 按标识符删除商品
    public void TestDeleteById() {
        //创建商品数据访问对象
        ProductDao productDao = new ProductDaoImpl();
        int count = productDao.deleteById(16);
        if (count > 0) {
            System.out.println("恭喜，商品信息删除成功！");
        } else {
            System.out.println("遗憾，商品信息删除失败！");
        }
    }

    @Test
    // 更新商品
    public void TestUpdate() {
        //创建商品数据访问对象
        ProductDao productDao = new ProductDaoImpl();
        //找到id=5的商品
        Product product = productDao.findById(5);
        //修改商品信息
        product.setName("九阳电饭煲");
        product.setPrice(888);
        Timestamp time = new Timestamp(new Date().getTime());
        product.setAddTime(time);
        product.setCategoryId(1);
        //更新商品信息
        int count = productDao.update(product);
        if (count > 0) {
            System.out.println("恭喜，商品信息更新成功！");
        } else {
            System.out.println("遗憾，商品信息更新失败！");
        }
    }
    @Test
    // 按标识符查询商品
    public void TestFindById(){
        //创建商品数据访问对象
        ProductDao productDao = new ProductDaoImpl();
        Product product = productDao.findById(1);
        System.out.println(product);
    }

    @Test
    // 查询全部商品
    public void TestFindAll() {
        //创建商品数据访问对象
        ProductDao productDao = new ProductDaoImpl();
        // 获取全部商品
        List<Product> products = productDao.findAll();
        //判断是否有商品
        if (products.size() > 0){
            for (Product product : products){
                System.out.println(product);
            }
        }else {
            System.out.println("没有商品信息");
        }
    }

}

TestCategoryDaoImpl

package net.ls.shop.dao.impl;

import net.ls.shop.bean.Category;
import net.ls.shop.dao.CategoryDao;
import org.junit.Test;

import java.util.List;

public class TestCategoryDaoImpl {
    @Test
    public void testFindAll() {
        // 创建类别数据访问对象
        CategoryDao categoryDao = new CategoryDaoImpl();
        // 获取全部商品类别
        List<Category> categories = categoryDao.findAll();
        // 判断是否有类别
        if (!categories.isEmpty()) {
            for (Category category: categories) {
                System.out.println(category);
            }
        } else {
            System.out.println("没有商品类别！");
        }
    }


    @Test
    //插入类别
    public void TestByInsert() {
        //创建类别数据访问对象
        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 TestDeleteById() {
        //创建类别数据访问对象
        CategoryDao categoryDao = new CategoryDaoImpl();
        int count = categoryDao.deleteById(5);
        if (count > 0) {
            System.out.println("恭喜，商品类别删除成功！");
        } else {
            System.out.println("遗憾，商品类别删除失败！");
        }
    }

    @Test
    // 更新类别
    public void TestUpdate() {
        //创建类别数据访问对象
        CategoryDao categoryDao = new CategoryDaoImpl();
        //找到id=5的商品类别
        Category category = categoryDao.findById(3);
        //修改商品类别
        category.setName("日常用品");
        //更新商品类别
        int count = categoryDao.update(category);
        if (count > 0) {
            System.out.println("恭喜，商品类别更新成功！");
        } else {
            System.out.println("遗憾，商品类别更新失败！");
        }
    }

    @Test
    // 按标识符查询类别
    public void TestFindById(){
        //创建类别数据访问对象
        CategoryDao categoryDao = new CategoryDaoImpl();
        Category category = categoryDao.findById(1);
        System.out.println(category);
    }

}

TestOrderDaoImpl

package net.ls.shop.dao.impl;

import net.ls.shop.bean.Order;
import net.ls.shop.dao.OrderDao;
import org.junit.Test;

import java.sql.Timestamp;
import java.util.Date;
import java.util.List;

public class TestOrderDaoImpl {
    @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 TestByInsert() {
        //创建订单对象访问数据
        OrderDao orderDao = new OrderDaoImpl();
        //创建订单
        Order order = new Order();
        order.setUsername("罗泽");
        order.setTelephone("18121978354");
        order.setTotalPrice(18886);
        order.setDeliveryAddress("泸职院信息工程学院");
        Timestamp time = new Timestamp(new Date().getTime());
        order.setOrderTime(time);
        //插入订单信息
        int count = orderDao.insert(order);
        // 查询是否插入成功
        if (count > 0) {
            System.out.println("恭喜，订单信息插入成功!");
        } else {
            System.out.println("遗憾，订单信息插入成功!");
        }
    }

    @Test
    // 按标识符删除订单
    public void TestDeleteById() {
        //创建订单对象访问数据
        OrderDao orderDao = new OrderDaoImpl();
        int count = orderDao.deleteById(3);
        if (count > 0) {
            System.out.println("恭喜，订单信息删除成功！");
        } else {
            System.out.println("遗憾，订单信息删除失败！");
        }
    }

    @Test
    // 更新订单
    public void TestUpdate() {
        //创建订单对象访问数据
        OrderDao orderDao = new OrderDaoImpl();
        //找到id=2的订单
        Order order = orderDao.findById(2);
        //修改订单信息
        order.setUsername("李白");
        order.setTelephone("18121978064");
        order.setTotalPrice(123234);
        order.setDeliveryAddress("王者荣耀刺客学院");
        Timestamp time = new Timestamp(new Date().getTime());
        order.setOrderTime(time);
        //更新商品信息
        int count = orderDao.update(order);
        if (count > 0) {
            System.out.println("恭喜，订单信息更新成功！");
        } else {
            System.out.println("遗憾，订单信息更新失败！");
        }
    }

    @Test
    // 按标识符查询订单
    public void TestFindById(){
        //创建订单对象访问数据
        OrderDao orderDao = new OrderDaoImpl();
        Order order = orderDao.findById(1);
        System.out.println(order);
    }

    @Test
    //查询最后一个订单
    public void TestFindByLast(){
        //创建订单对象访问数据
        OrderDao orderDao = new OrderDaoImpl();
        Order order = orderDao.findLast();
        System.out.println(order);
    }

}

(七）数据访问服务类XXXService

在src里创建net.hw.shop.service包，在里面创建四个服务类：UserService、CategoryService、ProductService与OrderService

1、用户服务类UserService

package net.ls.shop.service;

/**
 * 功能：用户服务类
 * 作者：罗帅
 * 日期：2019年12月4日
 */

import java.util.List;

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

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

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

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

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

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

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

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

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

2、类别服务类CategoryService

package net.ls.shop.service;

/**
 * 功能：类别服务类
 * 作者：罗帅
 * 日期：2019年12月4日
 */

import java.util.List;

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

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

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

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

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

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

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

3.商品服务类ProductService

package net.ls.shop.service;

/**
 * 功能：商品服务类
 * 作者：罗帅
 * 日期：2019年12月4日
 */

import java.util.List;

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

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

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

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

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

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

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

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

4、订单服务类OrderService

package net.ls.shop.service;

/**
 * 功能：订单服务类
 * 作者：罗帅
 * 日期：2019年12月4日
 */

import java.util.List;

import net.ls.shop.bean.Order;
import net.ls.shop.dao.OrderDao;
import net.ls.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();
    }
}

在test文件夹里创建net.ls.shop.service包，在里面创建测试类
TestUserService, TestCategoryService,
TestProductService,TestOrderService

TestUserService

package net.ls.shop.service;

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

import java.sql.Timestamp;
import java.util.Date;
import java.util.List;

public class TestUserService {
    @Test
    //添加用户测试
    public void TestAddUser() {
        //创建用户数据访问对象
        UserService userService = new UserService();
        //创建用户
        User user = new User();
        user.setUsername("韩信");
        user.setPassword("134134");
        user.setTelephone("15525558989");
        Timestamp time = new Timestamp(new Date().getTime());
        user.setRegisterTime(time);
        //添加信息
        int count = userService.addUser(user);
        // 查询是否添加成功
        if (count > 0) {
            System.out.println("恭喜，用户信息添加成功!");
        } else {
            System.out.println("遗憾，用户信息添加成功!");
        }
    }

    @Test
    //测试按标识符删除用户
    public void TestDele