购物小网站(上)

最新推荐文章于 2023-08-18 08:54:54 发布
最新推荐文章于 2023-08-18 08:54:54 发布
阅读量403 收藏 3
点赞数
分类专栏： java web学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/for_syq/article/details/103396116
版权

购物小网站

结构
在这里插入图片描述

在这里插入图片描述

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


}

在这里插入图片描述

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

在这里插入图片描述

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


}

在这里插入图片描述

package 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(String yanghua) {
        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 + "]";
    }

}

在这里插入图片描述

package dao.impl;

import bean.Category;
import dao.CategoryDao;
import dbutil.ConnectionManager;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public class CategoryDaoImpl implements CategoryDao {
    /**
     * 插入类别
     */
    @Override
    public int insert(Category category) {
        // 定义插入记录数
        int count = 0;

        // 获得数据库连接
        Connection conn = ConnectionManager.getConnection();
        // 定义SQL字符串
        String strSQL = "INSERT INTO t_category (name) VALUES (?)";
        try {
            // 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 设置占位符的值
            pstmt.setString(1, category.getName());
            // 执行更新操作，插入新录
            count = pstmt.executeUpdate();
            // 关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            ConnectionManager.closeConnection(conn);
        }

        // 返回插入记录数
        return count;
    }

    /**
     * 删除类别
     */
    @Override
    public int deleteById(int id) {
        // 定义删除记录数
        int count = 0;

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

        // 返回删除记录数
        return count;
    }

    /**
     * 更新类别
     */
    @Override
    public int update(Category category) {
        // 定义更新记录数
        int count = 0;

        // 获得数据库连接
        Connection conn = ConnectionManager.getConnection();
        // 定义SQL字符串
        String strSQL = "UPDATE t_category SET name = ? WHERE id = ?";
        try {
            // 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 设置占位符的值
            pstmt.setString(1, category.getName());
            pstmt.setInt(2, category.getId());
            // 执行更新操作，更新记录
            count = pstmt.executeUpdate();
            // 关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            ConnectionManager.closeConnection(conn);
        }

        // 返回更新记录数
        return count;
    }

    /**
     * 按标识符查询类别
     */
    @Override
    public Category findById(int id) {
        // 声明商品类别
        Category category = null;

        // 获取数据库连接对象
        Connection conn = ConnectionManager.getConnection();
        // 定义SQL字符串
        String strSQL = "SELECT * FROM t_category WHERE id = ?";
        try {
            // 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 设置占位符的值
            pstmt.setInt(1, id);
            // 执行SQL查询，返回结果集
            ResultSet rs = pstmt.executeQuery();
            // 判断结果集是否有记录
            if (rs.next()) {
                // 实例化商品类别
                category = new Category();
                // 利用当前记录字段值去设置商品类别的属性
                category.setId(rs.getInt("id"));
                category.setName(rs.getString("name"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            ConnectionManager.closeConnection(conn);
        }

        // 返回商品类别
        return category;
    }

    /**
     * 查询全部类别
     */
    @Override
    public List<Category> findAll() {
        // 声明类别列表
        List<Category> categories = new ArrayList<Category>();
        // 获取数据库连接对象
        Connection conn = ConnectionManager.getConnection();
        // 定义SQL字符串
        String strSQL = "SELECT * FROM t_category";
        try {
            // 创建语句对象
            Statement stmt = conn.createStatement();
            // 执行SQL，返回结果集
            ResultSet rs = stmt.executeQuery(strSQL);
            // 遍历结果集
            while (rs.next()) {
                // 创建类别实体
                Category category = new Category();
                // 设置实体属性
                category.setId(rs.getInt("id"));
                category.setName(rs.getString("name"));
                // 将实体添加到类别列表
                categories.add(category);
            }
            // 关闭结果集
            rs.close();
            // 关闭语句对象
            stmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }
        // 返回类别列表
        return categories;
    }

}

在这里插入图片描述

package dao.impl;

import bean.Order;
import dao.OrderDao;
import dbutil.ConnectionManager;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public class OrderDaoImpl implements OrderDao {
    /**
     * 插入订单
     */
    @Override
    public int insert(Order order) {
        // 定义插入记录数
        int count = 0;

        // 获得数据库连接
        Connection conn = ConnectionManager.getConnection();
        // 定义SQL字符串
        String strSQL = "INSERT INTO t_order (username, telephone, total_price, delivery_address, order_time)"
                + " VALUES (?, ?, ?, ?, ?)";
        try {
            // 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 设置占位符的值
            pstmt.setString(1, order.getUsername());
            pstmt.setString(2, order.getTelephone());
            pstmt.setDouble(3, order.getTotalPrice());
            pstmt.setString(4, order.getDeliveryAddress());
            pstmt.setTimestamp(5, new Timestamp(order.getOrderTime().getTime()));
            // 执行更新操作，插入记录
            count = pstmt.executeUpdate();
            // 关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            ConnectionManager.closeConnection(conn);
        }

        // 返回插入记录数
        return count;
    }

    /**
     * 删除订单
     */
    @Override
    public int deleteById(int id) {
        // 定义删除记录数
        int count = 0;

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

        // 返回删除记录数
        return count;
    }

    /**
     * 更新订单
     */
    @Override
    public int update(Order order) {
        // 定义更新记录数
        int count = 0;

        // 获得数据库连接
        Connection conn = ConnectionManager.getConnection();
        // 定义SQL字符串
        String strSQL = "UPDATE t_order SET username = ?, telephone = ?, total_price = ?,"
                + " delivery_address = ?, order_time = ? WHERE id = ?";
        try {
            // 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 设置占位符的值
            pstmt.setString(1, order.getUsername());
            pstmt.setString(2, order.getTelephone());
            pstmt.setDouble(3, order.getTotalPrice());
            pstmt.setString(4, order.getDeliveryAddress());
            pstmt.setTimestamp(5, new Timestamp(order.getOrderTime().getTime()));
            pstmt.setInt(6, order.getId());
            // 执行更新操作，更新记录
            count = pstmt.executeUpdate();
            // 关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            ConnectionManager.closeConnection(conn);
        }

        // 返回更新记录数
        return count;
    }

    /**
     * 查询最后一个订单
     */
    @Override
    public Order findLast() {
        // 声明订单
        Order order = null;
        // 获取数据库连接对象
        Connection conn = ConnectionManager.getConnection();
        // 定义SQL字符串
        String strSQL = "SELECT * FROM t_order";
        try {
            // 创建语句对象
            Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
            // 执行SQL，返回结果集
            ResultSet rs = stmt.executeQuery(strSQL);
            // 定位到最后一条记录
            if (rs.last()) {
                // 创建订单实体
                order = new Order();
                // 设置实体属性
                order.setId(rs.getInt("id"));
                order.setUsername(rs.getString("username"));
                order.setTelephone(rs.getString("telephone"));
                order.setTotalPrice(rs.getDouble("total_price"));
                order.setDeliveryAddress(rs.getString("delivery_address"));
                order.setOrderTime(rs.getTimestamp("order_time"));
            }
            // 关闭结果集
            rs.close();
            // 关闭语句对象
            stmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }
        // 返回订单对象
        return order;
    }

    /**
     * 按标识符查询订单
     */
    @Override
    public Order findById(int id) {
        // 声明订单
        Order order = null;

        // 获取数据库连接对象
        Connection conn = ConnectionManager.getConnection();
        // 定义SQL字符串
        String strSQL = "SELECT * FROM t_order WHERE id = ?";
        try {
            // 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 设置占位符的值
            pstmt.setInt(1, id);
            // 执行SQL查询，返回结果集
            ResultSet rs = pstmt.executeQuery();
            // 判断结果集是否有记录
            if (rs.next()) {
                // 实例化订单
                order = new Order();
                // 利用当前记录字段值去设置订单的属性
                order.setId(rs.getInt("id"));
                order.setUsername(rs.getString("username"));
                order.setTelephone(rs.getString("telephone"));
                order.setDeliveryAddress(rs.getString("delivery_address"));
                order.setOrderTime(rs.getTimestamp("order_time"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            ConnectionManager.closeConnection(conn);
        }

        // 返回订单
        return order;
    }

    /**
     * 查询全部订单
     */
    @Override
    public List<Order> findAll() {
        // 声明订单列表
        List<Order> orders = new ArrayList<Order>();
        // 获取数据库连接对象
        Connection conn = ConnectionManager.getConnection();
        // 定义SQL字符串
        String strSQL = "SELECT * FROM t_order";
        try {
            // 创建语句对象
            Statement stmt = conn.createStatement();
            // 执行SQL，返回结果集
            ResultSet rs = stmt.executeQuery(strSQL);
            // 遍历结果集
            while (rs.next()) {
                // 创建订单实体
                Order order = new Order();
                // 设置实体属性
                order.setId(rs.getInt("id"));
                order.setUsername(rs.getString("username"));
                order.setTelephone(rs.getString("telephone"));
                order.setDeliveryAddress(rs.getString("delivery_address"));
                order.setOrderTime(rs.getTimestamp("order_time"));
                // 将实体添加到订单列表
                orders.add(order);
            }
            // 关闭结果集
            rs.close();
            // 关闭语句对象
            stmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }
        // 返回用户列表
        return orders;
    }

}

在这里插入图片描述

package dao.impl;

import bean.Product;
import dao.ProductDao;
import dbutil.ConnectionManager;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;


public class ProductDaoimpl implements ProductDao {
    /**
     * 插入商品
     */
    @Override
    public int insert(Product product) {
        // 定义插入记录数
        int count = 0;

        // 获得数据库连接
        Connection conn = ConnectionManager.getConnection();
        // 定义SQL字符串
        String strSQL = "INSERT INTO t_product (name, price, add_time, category_id)" + " VALUES (?, ?, ?, ?)";
        try {
            // 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 设置占位符的值
            pstmt.setString(1, product.getName());
            pstmt.setDouble(2, product.getPrice());
            pstmt.setTimestamp(3, new Timestamp(product.getAddTime().getTime()));
            pstmt.setInt(4, product.getCategoryId());
            // 执行更新操作，插入新记录
            count = pstmt.executeUpdate();
            // 关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            ConnectionManager.closeConnection(conn);
        }

        // 返回插入记录数
        return count;
    }

    /**
     * 删除商品
     */
    @Override
    public int deleteById(int id) {
        // 定义删除记录数
        int count = 0;

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

        // 返回删除记录数
        return count;
    }

    /**
     * 更新商品
     */
    @Override
    public int update(Product product) {
        // 定义更新记录数
        int count = 0;

        // 获得数据库连接
        Connection conn = ConnectionManager.getConnection();
        // 定义SQL字符串
        String strSQL = "UPDATE t_product SET name = ?, price = ?, add_time = ?,"
                + " category_id = ? WHERE id = ?";
        try {
            // 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 设置占位符的值
            pstmt.setString(1, product.getName());
            pstmt.setDouble(2, product.getPrice());
            pstmt.setTimestamp(3, new Timestamp(product.getAddTime().getTime()));
            pstmt.setInt(4, product.getCategoryId());
            pstmt.setInt(5, product.getId());
            // 执行更新操作，更新记录
            count = pstmt.executeUpdate();
            // 关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            ConnectionManager.closeConnection(conn);
        }

        // 返回更新记录数
        return count;
    }

    /**
     * 按标识符查找商品
     */
    @Override
    public Product findById(int id) {
        // 声明商品
        Product product = null;
        // 获取数据库连接对象
        Connection conn = ConnectionManager.getConnection();
        // 定义SQL字符串
        String strSQL = "SELECT * FROM t_product WHERE id = ?";
        try {
            // 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 设置占位符的值
            pstmt.setInt(1, id);
            // 执行SQL查询，返回结果集
            ResultSet rs = pstmt.executeQuery();
            // 判断结果集是否有记录
            if (rs.next()) {
                // 实例化商品
                product = new Product();
                // 利用当前记录字段值去设置商品类别的属性
                product.setId(rs.getInt("id"));
                product.setName(rs.getString("name"));
                product.setPrice(rs.getDouble("price"));
                product.setAddTime(rs.getTimestamp("add_time"));
                product.setCategoryId(rs.getInt("category_id"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            ConnectionManager.closeConnection(conn);
        }

        // 返回商品
        return product;
    }

    /**
     * 按类别查询商品
     */
    @Override
    public List<Product> findByCategoryId(int categoryId) {
        // 定义商品列表
        List<Product> products = new ArrayList<Product>();

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

    /**
     * 查询全部商品
     */
    @Override
    public List<Product> findAll() {
        // 声明商品列表
        List<Product> products = new ArrayList<Product>();
        // 获取数据库连接对象
        Connection conn = ConnectionManager.getConnection();
        // 定义SQL字符串
        String strSQL = "SELECT * FROM t_product";
        try {
            // 创建语句对象
            Statement stmt = conn.createStatement();
            // 执行SQL，返回结果集
            ResultSet rs = stmt.executeQuery(strSQL);
            // 遍历结果集
            while (rs.next()) {
                // 创建商品实体
                Product product = new Product();
                // 设置实体属性
                product.setId(rs.getInt("id"));
                product.setName(rs.getString("name"));
                product.setPrice(rs.getDouble("price"));
                product.setAddTime(rs.getTimestamp("add_time"));
                product.setCategoryId(rs.getInt("category_id"));
                // 将实体添加到商品列表
                products.add(product);
            }
            // 关闭结果集
            rs.close();
            // 关闭语句对象
            stmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }
        // 返回商品列表
        return products;
    }

}

在这里插入图片描述

package dao.impl;

import bean.User;
import dao.UserDao;
import dbutil.ConnectionManager;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

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("yanghua"));
            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("yanghua"));
            pstmt.setString(2, user.getPassword());
            pstmt.setString(3, user.getTelephone());
            pstmt.setTimestamp(4, new Timestamp(user.getRegisterTime().getTime()));
            pstmt.setInt(5, user.getPopedom());
            pstmt.setInt(6, user.getId());
            // 执行更新操作，更新记录
            count = pstmt.executeUpdate();
            // 关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            ConnectionManager.closeConnection(conn);
        }

        // 返回更新记录数
        return count;
    }

    /**
     * 按标识符查询用户
     */
    @Override
    public User findById(int id) {
        // 声明用户
        User user = null;

        // 获取数据库连接对象
        Connection conn = ConnectionManager.getConnection();
        // 定义SQL字符串
        String strSQL = "SELECT * FROM t_user WHERE id = ?";
        try {
            // 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 设置占位符的值
            pstmt.setInt(1, id);
            // 执行SQL查询，返回结果集
            ResultSet rs = pstmt.executeQuery();
            // 判断结果集是否有记录
            if (rs.next()) {
                // 实例化用户
                user = new User();
                // 利用当前记录字段值去设置商品类别的属性
                user.setId(rs.getInt("id"));
                user.setUsername(rs.getString("username"));
                user.setPassword(rs.getString("password"));
                user.setTelephone(rs.getString("telephone"));
                user.setRegisterTime(rs.getTimestamp("register_time"));
                user.setPopedom(rs.getInt("popedom"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            ConnectionManager.closeConnection(conn);
        }

        // 返回用户
        return user;
    }

    @Override
    public List<User> findByUsername(String username) {
        // 声明用户列表
        List<User> users = new ArrayList<User>();
        // 获取数据库连接对象
        Connection conn = ConnectionManager.getConnection();
        // 定义SQL字符串
        String strSQL = "SELECT * FROM t_user WHERE username = ?";
        try {
            // 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 设置占位符的值
            pstmt.setString(1, username);
            // 执行SQL查询，返回结果集
            ResultSet rs = pstmt.executeQuery();
            // 遍历结果集
            while (rs.next()) {
                // 创建类别实体
                User user = new User();
                // 设置实体属性
                user.setId(rs.getInt("id"));
                user.setUsername(rs.getString("username"));
                user.setPassword(rs.getString("password"));
                user.setTelephone(rs.getString("telephone"));
                user.setRegisterTime(rs.getTimestamp("register_time"));
                user.setPopedom(rs.getInt("popedom"));
                // 将实体添加到用户列表
                users.add(user);
            }
            // 关闭结果集
            rs.close();
            // 关闭语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }
        // 返回用户列表
        return users;
    }

    @Override
    public List<User> findAll() {
        // 声明用户列表
        List<User> users = new ArrayList<User>();
        // 获取数据库连接对象
        Connection conn = ConnectionManager.getConnection();
        // 定义SQL字符串
        String strSQL = "SELECT * FROM t_user";
        try {
            // 创建语句对象
            Statement stmt = conn.createStatement();
            // 执行SQL，返回结果集
            ResultSet rs = stmt.executeQuery(strSQL);
            // 遍历结果集
            while (rs.next()) {
                // 创建用户实体
                User user = new User();
                // 设置实体属性
                user.setId(rs.getInt("id"));
                user.setUsername(rs.getString("username"));
                user.setPassword(rs.getString("password"));
                user.setTelephone(rs.getString("telephone"));
                user.setRegisterTime(rs.getTimestamp("register_time"));
                user.setPopedom(rs.getInt("popedom"));
                // 将实体添加到用户列表
                users.add(user);
            }
            // 关闭结果集
            rs.close();
            // 关闭语句对象
            stmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }
        // 返回用户列表
        return users;
    }

    /**
     * 登录方法
     */
    @Override
    public User login(String username, String password) {
        // 定义用户对象
        User user = null;
        // 获取数据库连接
        Connection conn = ConnectionManager.getConnection();
        // 定义SQL字符串
        String strSQL = "SELECT * FROM t_user WHERE username = ? AND password = ?";
        try {
            // 创建预备语句对象
            PreparedStatement psmt = conn.prepareStatement(strSQL);
            // 设置占位符的值
            psmt.setString(1, username);
            psmt.setString(2, password);
            // 执行查询，返回结果集
            ResultSet rs = psmt.executeQuery();
            // 判断结果集是否有记录
            if (rs.next()) {
                // 实例化用户对象
                user = new User();
                // 用记录值设置用户属性
                user.setId(rs.getInt("id"));
                user.setUsername(rs.getString("username"));
                user.setPassword(rs.getString("password"));
                user.setTelephone(rs.getString("telephone"));
                user.setRegisterTime(rs.getDate("register_time"));
                user.setPopedom(rs.getInt("popedom"));
            }
            // 关闭结果集
            rs.close();
            // 关闭预备语句
            psmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }

        // 返回用户对象
        return user;
    }
}

在这里插入图片描述

package dao;

import bean.Category;

import java.util.List;

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

在这里插入图片描述

package dao;

import bean.Order;

import java.util.List;

public interface OrderDao {
    // 插入订单
    int insert(Order order);

    // 按标识符删除订单
    int deleteById(int id);

    // 更新订单
    int update(Order order);

    // 按标识符查询订单
    Order findById(int id);

    // 查询最后一个订单
    Order findLast();

    // 查询全部订单
    List<Order> findAll();

}

在这里插入图片描述

package dao;


import bean.Product;

import java.util.List;

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

在这里插入图片描述

package dao;

import bean.User;

import java.util.List;


public interface UserDao {
    // 插入用户
    int insert(User user);

    // 按标识符删除用户
    int deleteById(int id);

    // 更新用户
    int update(User user);

    // 按标识符查询用户
    User findById(int id);

    // 按用户名查询用户
    List<User> findByUsername(String username);

    // 查询全部用户
    List<User> findAll();

    // 用户登录
    User login(String username, String password);
}

在这里插入图片描述

package dbutil;

import javax.swing.*;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

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

}}

在这里插入图片描述

package Service.ServiceImpl;


import Service.CategoryService;
import bean.Category;
import dao.CategoryDao;
import dao.impl.CategoryDaoImpl;

import java.util.List;

public class CategoryServiceImpl implements CategoryService {
    /**
     * 声明类别数据访问对象
     */
    private CategoryDao 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<Category> findAllCategories() {
        return categoryDao.findAll();
    }

}

在这里插入图片描述

package Service.ServiceImpl;

import Service.OrderService;
import bean.Order;
import dao.OrderDao;
import dao.impl.OrderDaoImpl;

import java.util.List;


    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<Order> findAllOrders() {
            return orderDao.findAll();
        }
    }

在这里插入图片描述

package Service.ServiceImpl;


import Service.ProductService;
import bean.Product;
import dao.ProductDao;
import dao.impl.ProductDaoimpl;

import java.util.List;

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<Product> findProductsByCategoryId(int categoryId) {
        return productDao.findByCategoryId(categoryId);
    }

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

}

在这里插入图片描述

package Service.ServiceImpl;


import Service.UserService;
import bean.User;
import dao.UserDao;
import dao.impl.UserDaoImpl;

import java.util.List;

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<User> findUsersByUsername(String username) {
        return userDao.findByUsername(username);
    }

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

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

}

在这里插入图片描述

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


}

在这里插入图片描述

package Service;


import bean.Order;

import java.util.List;

public interface OrderService {
    // 添加订单
    int addOrder(Order order);

    // 按标识符删除订单
    int deleteOrderById(int id);

    // 更新订单
    int updateOrder(Order order);

    // 查询最后一个订单
    Order findLastOrder();

    // 按标识符查询订单
    Order findOrderById(int id);

    // 查询全部订单
    List<Order> findAllOrders();

}

在这里插入图片描述

package Service;

import bean.Product;

import java.util.List;

public interface ProductService {
    // 添加商品
    int addProduct(Product product);

    // 按标识符删除商品
    int deleteProductById(int id);

    // 更新商品
    int updateProduct(Product product);

    // 按标识符查询商品
    Product findProductById(int id);

    // 按类别查询商品
    List<Product> findProductsByCategoryId(int categoryId);

    // 查询全部商品
    List<Product> findAllProducts();

}

在这里插入图片描述

package Service;

import bean.User;

import java.util.List;

public interface UserService {
    // 添加用户
    int addUser(User user);

    // 按标识符删除用户
    int deleteUserById(int id);

    // 更新用户
    int updateUser(User user);

    // 按标识符查询用户
    User findUserById(int id);

    // 按用户名查询用户
    List<User> findUsersByUsername(String username);

    // 查询全部用户
    List<User> findAllUsers();

    // 用户登录
    User login(String username, String password);
}

测试

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

package test.dao;

import bean.Category;
import dao.CategoryDao;
import dao.impl.CategoryDaoImpl;
import org.junit.Test;

import java.util.List;

public class TestCategoryDaoImpl {
    @Test
    public void testdeleteById(){
        CategoryDao dao=new CategoryDaoImpl();
        int user=dao.deleteById(1);
        System.out.println(user);
    }
    @Test
    public void testFindById(){
        CategoryDao dao =new CategoryDaoImpl();
        Category category=dao.findById(2);
        System.out.println(category);
    }
    @Test
    public void testFindAll(){
        CategoryDao dao=new CategoryDaoImpl();
        List<Category>category=dao.findAll();
        System.out.println(category);

    }
    @Test
    public void testInsert(){
        Category category=new Category();
        CategoryDao categoryDao=new CategoryDaoImpl();

        category.setId(1);
        category.setName("jslfjls");
        int count=categoryDao.insert(category);
         if (count>0){
             System.out.println("插入成功");
         }else {
             System.out.println("插入失败");
         }
    }
    @Test
    public void testUpdate(){
        CategoryDao dao=new CategoryDaoImpl();
        Category category=dao.findById(3);

        category.setName("wew");
        int count=dao.update(category);
        if(count>0){
            System.out.println("更新成功");
        }else {
            System.out.println("更新失败");
        }
    }


}

在这里插入图片描述

package test.dao;

import bean.Order;
import dao.OrderDao;
import dao.impl.OrderDaoImpl;
import org.junit.Test;

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

public class TestOrderImpl {
    @Test
    public void testInsert(){
        Order order=new Order();
        OrderDao orderDao=new OrderDaoImpl();

        order.setUsername("aaa");
        order.setTotalPrice(123);
        order.setTelephone("2312312312");
        order.setOrderTime(new Date());
        order.setDeliveryAddress("home");
        int count=orderDao.insert(order);
        if (count>0){
            System.out.println("插入成功");
        }else {
            System.out.println("插入失败");
        }
    }
    @Test
    public void testdeletByid(){
        OrderDao dao=new OrderDaoImpl();
        int order=dao.deleteById(1);
        System.out.println(order);
    }
    @Test
    public void testUpdate(){
        OrderDao dao=new OrderDaoImpl();
        Order order=dao.findById(2);

        order.setUsername("bbbb");
        order.setTelephone("3021830");
        order.setTotalPrice(123);
        order.setOrderTime(new Date());
        order.setDeliveryAddress("live");
        order.setTotalPrice(333);

        int count=dao.update(order);
        if(count>0){
            System.out.println("更新成功");
        }else {
            System.out.println("更新失败");
        }

    }
    @Test
    public void testFindLast(){
        OrderDao dao = new OrderDaoImpl();
        Order order=dao.findLast();
        System.out.println(order);
    }
    @Test
    public void testFindById(){
        OrderDao dao =new OrderDaoImpl();
        Order order=dao.findById(3);
        System.out.println(order);
    }
    @Test
    public void testFindAll(){
        OrderDao dao =new OrderDaoImpl();
        List<Order>orders=dao.findAll();
        System.out.println(orders);
    }
}

在这里插入图片描述

package test.dao;

import bean.Product;
import dao.ProductDao;
import dao.impl.ProductDaoimpl;
import org.junit.Test;

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

public class TestProductDaoimpl {
    @Test
    public void testDeleteById(){
        ProductDao dao=new ProductDaoimpl();
        int user=dao.deleteById(1);
        System.out.println(user);
    }
    @Test
    public void testFindByname(){
        ProductDao dao=new ProductDaoimpl();
        List<Product>product=dao.findAll();
        System.out.println(product);
    }
    @Test
    public void testFindByid(){
        ProductDao dao =new ProductDaoimpl();
        Product product=dao.findById(2);
        System.out.println(product);
    }
    @Test
    public void testFindAll(){
        ProductDao dao =new ProductDaoimpl();
        List<Product>products=dao.findAll();
        System.out.println(products);
    }
    @Test
    public void testFindByCategoryId(){
        ProductDao dao=new ProductDaoimpl();
        List<Product>products=dao.findByCategoryId(4);
        System.out.println(products);
    }
    @Test
    public void testUpdate(){
        ProductDao dao=new ProductDaoimpl();
        Product product=dao.findById(2);

        product.setName("小王");
        product.setPrice(12345);
        product.setCategoryId(3);
        int count=dao.update(product);
        if(count>0){
            System.out.println("更新成功");
        }else {
            System.out.println("更新失败");
        }
    }
    @Test
    public void testInsert(){
        Product product=new Product();
        ProductDao productDao=new ProductDaoimpl();
        product.setName("我也不知道");
        product.setCategoryId(1);
        product.setPrice(333);
        product.setAddTime(new Date());
        product.setId(1);

        int count=productDao.insert(product);
        if (count>0){
            System.out.println("插入成功");

        }else {
            System.out.println("插入失败");
        }
    }



}

在这里插入图片描述

package test.dao;

import bean.User;
import dao.UserDao;
import dao.impl.UserDaoImpl;
import org.junit.Test;

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

public class TestUserDaoImpl {
    @Test
    public void testLogin(){
        UserDao dao=new UserDaoImpl();
        String username, password;

        username = "admin";
        password = "12345";
        User user = dao.login(username, password);
        if (user != null) {
            System.out.println("恭喜，用户名与密码正确，登录成功");

        } else {
            System.out.println("遗憾，用户名或密码错误，登录失败");
        }
    }
    @Test
    public void testFindById() {
        UserDao dao = new UserDaoImpl();
        User user = dao.findById(1);
        System.out.println(user);
    }
    @Test
    public void testDeletById() {
        UserDao dao = new UserDaoImpl();
        int user = dao.deleteById(4);
        System.out.println(user);
    }
    @Test
    public void testFindByName(){
        UserDao dao=new UserDaoImpl();
        List<User> user=dao.findByUsername("温志军");
        System.out.println(user);
    }
    @Test
    public void testFindAll(){
        UserDao dao=new UserDaoImpl();
        List<User> user=dao.findAll();
        System.out.println(user);
    }

    @Test
    public void testInsert(){
        //定义用户对象
        User user = new User();
        //定义用户数据访问对象
        UserDao userDao = new UserDaoImpl();
        //设置用户属性
        user.setUsername("李晓东");
        user.setPassword("124578");
        user.setTelephone("15478951235");
        user.setRegisterTime(new Date());
        user.setPopedom(1);
        //调用用户数据访问对象的插入方式
        int count = userDao.insert(user);
        //判断用户记录是否插入成功
        if (count>0){
            System.out.println("恭喜用户插入成功");
            System.out.println(userDao.findById(userDao.findAll().size()));
            System.out.println(user);
        }else {
            System.out.println("用户插入失败");
        }
    }
    @Test
    public void testUpdate(){
        //定义用户数据访问对象
        UserDao userDao = new UserDaoImpl();

        //找到涂文艳用户，其id是4
        User user = userDao.findById(2);
        //修改其密码与电话
        user.setPassword("903213");
        user.setTelephone("13945457890");
        //更新涂文艳用户
        int count = userDao.update(user);
        //判断更新用户是否成功
        if(count >0){
            System.out.println("恭喜，用户更新成功");
        }else {
            System.out.println("遗憾，用户更新失败");
        }

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

    }

}

在这里插入图片描述

package test.service;

import Service.CategoryService;
import Service.ServiceImpl.CategoryServiceImpl;
import bean.Category;
import org.junit.Test;

import java.util.List;

public class TestCategoryServiceImpl {
    @Test
    public void testfindAllCategories(){
        CategoryService service = new CategoryServiceImpl();
        List<Category> categories = service.findAllCategories();
        if (((List) categories).size()>0){
            for (Category category: categories){
                System.out.println(category);
            }
        }else {
            System.out.println("没有商品类别！");
        }
    }
    @Test
    public void testfindCategoryById(){
        CategoryService service = new CategoryServiceImpl();
        Category categories = service.findCategoryById(2);
        System.out.println(categories);
    }
    @Test
    public void testupdateCategory(){
        CategoryService service = new CategoryServiceImpl();
        Category categories = service.findCategoryById(2);
        categories.setName("好吃美食");
        int count = service.updateCategory(categories);
        if(count >0){
            System.out.println("恭喜，商品类别更新成功");
        }else {
            System.out.println("遗憾，商品类别更新失败");
        }
        //再次查询好吃美食商品类别
        categories = service.findCategoryById(2);
        //查看好吃美食商品类别
        System.out.println(categories);
    }
    @Test
    public void testdeleteCategoryById(){
//      定义商品类别数据访问对象
        CategoryService service = new CategoryServiceImpl();
        int count = service.deleteCategoryById(3);
        if (count>0){
            System.out.println("恭喜，商品类别删除成功");
        }else {
            System.out.println("商品类别记录删除失败");
        }
    }
    @Test
    public void testaddCategory(){
//      定义商品类别对象
        Category category = new Category();
        //定义商品类别数据访问对象
        CategoryService service = new CategoryServiceImpl();
        //设置商品类别属性
        category.setId(1);
        category.setName("经典美食");
        //调用商品类别数据访问对象的插入方式
        int count = service.addCategory(category);
        //判断商品类别记录是否插入成功
        if (count>0){
            System.out.println("恭喜商品类别插入成功");
            System.out.println(category);
        }else {
            System.out.println("商品类别插入失败");
        }
    }
}

在这里插入图片描述

package test.service;

import Service.OrderService;
import Service.ServiceImpl.OrderServiceImpl;
import bean.Order;
import org.junit.Test;

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

public class TestOrderServiceImpl {
    @Test
    public void testaddOrder(){
        OrderService service=new OrderServiceImpl();
        Order order=new Order();

        order.setUsername("jjjjjj");
        order.setTelephone("48304823408");
        order.setTotalPrice(840239);
        order.setDeliveryAddress("sjflsd");
        order.setOrderTime(new Date());
        int count=service.addOrder(order);
        if(count>0){
            System.out.println("插入成功");
        }else {
            System.out.println("插入失败");
        }
    }
    @Test
    public void testeleteOrderById(){
        OrderService service=new OrderServiceImpl();
        int count=service.deleteOrderById(2);
        if (count>0){
            System.out.println("恭喜，用户记录删除成功");
        }else {
            System.out.println("用户记录删除失败");
        }
    }
    @Test
    public void testupdateOrder(){
        OrderService  service=new OrderServiceImpl();
        Order order=new Order();

        order.setOrderTime(new Date());
        order.setUsername("dlkfjl");
        order.setTotalPrice(4324);
        order.setDeliveryAddress("erue");
        int count=service.updateOrder(order);
        if(count >0){
            System.out.println("恭喜，用户更新成功");
        }else {
            System.out.println("遗憾，用户更新失败");
        }
    }
    @Test
    public void testfindOrderById(){
        OrderService service=new OrderServiceImpl();
        Order orders=service.findOrderById(3);
        System.out.println(orders);
    }
    @Test
    public void testfindAll(){
        OrderService service=new OrderServiceImpl();
        List<Order>orders=service.findAllOrders();
        System.out.println(orders);
    }


}

在这里插入图片描述

package test.service;

import Service.ProductService;
import Service.ServiceImpl.ProductServiceImpl;
import bean.Product;
import org.junit.Test;

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

public class TestProductServiceImpl {
    @Test
    public void testaddProduct(){
        Product product=new Product();
        ProductService service=new ProductServiceImpl();
        product.setName("ssss");
        product.setCategoryId(12);
        product.setAddTime(new Date());

        int count=service.addProduct(product);
        if(count>0){
            System.out.println("插入成功");
        }else {
            System.out.println("插入失败");
        }
    }
    @Test
    public void testDeleteProductById(){
        ProductService service=new ProductServiceImpl();
        int count=service.deleteProductById(2);
        if(count>0){
            System.out.println("删除成功");
        }else {
            System.out.println("删除失败");
        }

    }
    @Test
    public void testupdateProduct(){
        ProductService service=new ProductServiceImpl();
        Product product=service.findProductById(4);

        product.setName("sjfl");
        product.setAddTime(new Date());
        product.setCategoryId(3);
        int count=service.updateProduct(product);
        if(count>0){
            System.out.println("更新成功");
        }else {
            System.out.println("更新失败");
        }

    }
    @Test
    public void testfindProductById(){
        ProductService service=new ProductServiceImpl();
        Product product=service.findProductById(3);
        System.out.println(product);
    }
    @Test
    public void testfindProductsByCategoryId(){
        ProductService service=new ProductServiceImpl();
        List<Product>products=service.findProductsByCategoryId(2);
        System.out.println(products);
    }
    @Test
    public void testfindAllProducts(){
        ProductService service=new ProductServiceImpl();
        List<Product>products=service.findAllProducts();
        System.out.println(products);
    }
}

在这里插入图片描述

package test.service;

import Service.ServiceImpl.UserServiceImpl;
import Service.UserService;
import bean.User;
import org.junit.Test;

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

public class TestUserServiceImpl {
    @Test
    public void testLogin(){
        String username, password;

        username = "admin";
        password = "12345";

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

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

    }
    @Test
    public void testUpdate(){
        //定义用户数据访问对象
        UserService service = new UserServiceImpl();

        //找到涂文艳用户，其id是4
        User user = service.findUserById(4);
        //修改其密码与电话
        user.setPassword("903214");
        user.setTelephone("13945457890");
        //更新涂文艳用户
        int count = service.updateUser(user);
        //判断更新用户是否成功
        if(count >0){
            System.out.println("恭喜，用户更新成功");
        }else {
            System.out.println("遗憾，用户更新失败");
        }

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

    }
    @Test
    public void testAddUser(){
        //定义用户对象
        User user = new User();
        //定义用户数据访问对象
        UserService service = new UserServiceImpl();
        //设置用户属性
        user.setUsername("李晓东");
        user.setPassword("124578");
        user.setTelephone("15478951235");
        user.setRegisterTime(new Date());
        user.setPopedom(1);
        //调用用户数据访问对象的插入方式
        int count = service.addUser(user);
        //判断用户记录是否插入成功
        if (count>0){
            System.out.println("恭喜用户插入成功");
            System.out.println(user);
        }else {
            System.out.println("用户插入失败");
        }
    }
    @Test
    public void findAllUsers(){
        //定义用户数据访问对象
        UserService service = new UserServiceImpl();
        List<User> users = service.findAllUsers();
        //通过增强for循环遍历列表
        for (User user : users){
            System.out.println(user);
        }

    }
    @Test
    public void testFindUserById(){
        //定义用户数据访问对象
        UserService service = new UserServiceImpl();
        //调用用户数据访问对象的操作方法
        User user = service.findUserById(1);
        //输出用户对象
        System.out.println(user);
    }
    @Test
    public void testDeleteUserById(){
        //定义用户数据访问对象
        UserService service = new UserServiceImpl();
        int count = service.deleteUserById(12);
        if (count>0){
            System.out.println("恭喜，用户记录删除成功");
        }else {
            System.out.println("用户记录删除失败");
        }
    }
    @Test
    public void findUsersByUsername(){
//      定义用户数据访问对象
        UserService service = new UserServiceImpl();
//      调用用户数据访问对象方法
        List<User> user = service.findUsersByUsername("涂文艳");
        System.out.println(user);
    }
}

**

## 百度网盘提取
链接：https://pan.baidu.com/s/1i-Yv3nAi8_1Ao-VlPDTAjA 
提取码：l0n3 

**
for_syq
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
推荐6个我经常逛的“小网站”，嘿嘿嘿！！！
JNPF 专注低代码开发
05-06 1万+
每次发现优质的内容都会第一时间给大家分享出来，不管是软件，插件，脚本还是网站，今天给大家分享6个小网站，小伙伴们，收藏永不停止！大家没事儿的时候就去逛一逛，有事儿的时候也可以去逛一逛，说不定会有意想不到的收获。
别再错过！这些隐藏版小网站，让你大呼过瘾！
yang的博客
12-14 3852
今天给大家分享一些摸鱼小网站，再忙也别忘记摸鱼呀~~~
常用小网站
zmzsoftware的专栏
04-29 2945
中文编码查询 http://bm.kdd.cc/index.asp 谷歌apk 免登录下载 http://apps.evozi.com/apk-downloader/
【 慎入：6个神奇小网站！】
朱雀随云记的博客
08-18 1174
今天给大家带来4个好玩的网站！
我的小网站建好了！欢迎大家访问7黄石
kmnzpozrlglu的博客
05-05 657
我的小网站建好了！欢迎大家访问   http://www.huagongzhan.cn
微信小程序-购物商城网站
06-09
微信小程序-购物商城网站
小型购物网站
10-09
为了明确该系统的功能需求,方便开发人员及测试人员在开发和测试之初了解该系统的整体概要,把握整个系统的精髓所在,提高系统开发与测试的效率.
网展小型购物网站源码 v6.3
10-06
网展购物系统是用asp+access开发的购物网站。它包含了首页管理、商品管理、信息管理、新闻管理、用户管理和统计信息等模块。 网展购物系统详细功能： 1、管理首页 2、商品管理模块
基于PHP+MySQL的小型购物系统网站.zip
10-15
资源包含文件：课程论文word+源码及...由于实现了两种用户模式(管理员和普通顾客会员)，页面上的安排肯定要随着不同的登录身份而做出不同的改变。详细介绍参考：https://blog.csdn.net/newlw/article/details/124829033
嘿嘿嘿，10个我经常逛的“小网站”，不骗人
设计“1+2”，摹客就够了！
12-09 5938
在我们日常开发的过程中，会遇到一些简单CSS动画的需求，如果为了一两个动画引入库可能会感觉得不偿失，若每次在网上搜相关的代码又显得太过费时费力，因此，CSS3的价值就体现出来了！最有意思的是，插画的颜色可以根据你页面的主题色进行统一修改，系统预设了6种配色方案，你也可以自定义颜色，下载支持PNG和SVG两种格式，支持免费商用，用户体验超好der！
一个小型的购物网站（购物网站）
05-09
JSP+STRUT+HIBERNATE=购物网，是一个实现购物的网站，可以在浏览器中看各种商品，完成购物交易。
国外国内各类小网站（属于给人作品的比较多）
03-27
国外国内各类小网站（属于给人作品的比较多）
B2C小型购物商城系统
06-22
B2C小型购物商城系统的设计与实现 B2C 小型购物商城
JSP购物网站
02-22
这是一个小型的JSP购物网站，比较适合学生毕设参考.................
一些实用的小网站、小工具、软件
想握住此生辽阔
07-10 1万+
免费在线画图工具：https://www.draw.io/ 在线听音乐：http://tool.liumingye.cn/music/?page=homePage
小网站
heren_321的博客
07-05 4654
网站前端搭建具体方案 1.1 架构选择 由于初步学习网站搭建和对产品中稳定性要求，选择HTML5+CSS3+jQuery为基础架构。该套架构较为成熟，指导文档较多，社区较为活跃，可以及时寻找到问题解决方案。同时采用该前端架构的网站多，包括了京东、天猫等，甚至吉利官网都是在此架构上衍生。可以形象的将前端搭建比作跳舞，那么HTML5则是骨架而CSS3为血肉，而JavaScript则是这两个基础上人...
分享5个宝藏小网站，工作学习都能用到
波尼老师的博客
06-30 1792
今天波老师给大家分享的是5个精选的宝藏小网站，工作、学习都能用到！我猜，总有一个网站，会让你马上收藏！ Rainy Mood 链接：www.rainymood.com/ 模拟下雨的声音，帮你集中注意力，放松心情。工作时，一些小伙伴喜欢戴着耳机听歌，避免周围纷杂的环境，打扰到自己。但，当你打开听歌软件，切换另一首时，老板正好出现在你背后，上班摸鱼石锤！可能还会被点名批评！其实，可以听一些白噪音，不会打断自己工作的思路，还省去了切歌的麻烦！ 背景生成器 链接：bggenerator.com/ 生
来看看别人都私藏了哪些“小网站”！
热门推荐
科技毒瘤君
08-15 1万+
小伙伴们注意：公众号的推送机制不再按照时间前后推送了，微信公众号信息流乱序。君哥建议大家把科技毒瘤君公众号置顶（设为星标⭐），以便第一时间看到推送，非常感谢~，方法如下图：对于长期浪迹于...
jsp+servlet小型购物网站
最新发布
12-26
我们可以利用JSP（Java服务器页面）和Servlet来开发一个小型的购物网站。首先，我们可以使用JSP来设计网站的页面，包括主页、商品列表页、购物车页面和订单页面等。在这些页面中，我们可以使用JSP标签来动态生成网页...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值