diff --git a/Supermarket/lib/dao/BufferService.java b/Supermarket/lib/dao/BufferService.java new file mode 100644 index 0000000..9c643c8 --- /dev/null +++ b/Supermarket/lib/dao/BufferService.java @@ -0,0 +1,37 @@ +package com.lingnan.supermarket.dao; + +import java.util.Vector; + +import com.lingnan.supermarket.dto.Buffer; +import com.lingnan.supermarket.dto.Production; +public interface BufferService { + + /*主要用于更新操作*/ + + /*根据商品id判断delmark是0还是1,即是否是新添加的商品返回2，还是已经添加的商品返回1，还是不存在的商品返回0*/ + public Vector allOutBuffer(); + public Buffer findOutBufferbyId(String id) ; + public boolean addOutBufferNewProd(String id,int sum); + public boolean addOutBufferExeistProd(String id,int sum,Buffer buffer); + /*public Buffer findOutBufferSumAndOutPrice(String id);*/ + public Float OutBufferAllPrice(); + public boolean Account(String number,String time,String id,int sum,Float price); + public boolean InsertOutOrder(String number,Float allPrice,String time,String username); + public boolean DelAllOutBuffer(); + public boolean DelOutBufferById(String id); + public boolean UpdateOutBufferById(String id,int sum); + + + /*进货模块*/ + public Vector allInBuffer(); + public Buffer findInBufferbyId(String id) ; + public boolean addInBufferNewProd(String id,int sum); + public boolean addInBufferExeistProd(String id,int sum,Buffer buffer); + /*public Buffer findInBufferSumAndInPrice(String id);*/ + public Float InBufferAllPrice(); + public boolean Stock(String number,String time,String id,int sum,Float price); + public boolean InsertInOrder(String number,Float allPrice,String time,String username); + public boolean DelAllInBuffer(); + public boolean DelInBufferById(String id); + public boolean UpdateInBufferById(String id,int sum); +} diff --git a/Supermarket/lib/dao/SupplierInfService.java b/Supermarket/lib/dao/SupplierInfService.java new file mode 100644 index 0000000..3b1285b --- /dev/null +++ b/Supermarket/lib/dao/SupplierInfService.java @@ -0,0 +1,32 @@ +package com.lingnan.supermarket.dao; + +import java.util.ArrayList; +import java.util.Vector; + +import com.lingnan.supermarket.dto.SupplierInf; +import com.lingnan.supermarket.dto.User; + +public interface SupplierInfService { + //查询操作 加where default==1 + Vector findAllSupplierInf(); + + Vector findByNameSupplierInf(SupplierInf supplierInf); + // SupplierInf findByNameSupplierInf(String name); + + //根据id增加 + int addSupplierInf(SupplierInf s); + + //根据id删除 + //int deleteSupplierInf(String id); + + //根据id更新 + int updateSupplierInf(SupplierInf supplierInf); + + int deleteSupplierInf(int id); + + //输出所有供应商名字 + ArrayList findNameSupplier(); + + //通过供应商名查找并输出id + int findIdSupplierByName(String name); + } diff --git a/Supermarket/lib/dao/UserService.java b/Supermarket/lib/dao/UserService.java new file mode 100644 index 0000000..50ce43d --- /dev/null +++ b/Supermarket/lib/dao/UserService.java @@ -0,0 +1,27 @@ +package com.lingnan.supermarket.dao; + +import java.util.Vector; + +import com.lingnan.supermarket.dto.User; + +// 用户服务接口，定义了一系列与用户操作相关的方法 +public interface UserService { + + // 查询所有用户的方法，返回一个存储用户对象的Vector数组 + Vector allUser(); + + // 根据用户真实姓名查找用户的方法，返回一个存储匹配用户对象的Vector数组 + Vector findByrnameUser(User user); + + // 用户登录方法，传入用户名、密码和用户级别参数，返回一个User对象（可能表示登录成功的用户信息） + User login(String loginName, String password, int usuper); + + // 添加用户的方法，传入一个User对象，返回一个整数表示添加操作是否成功（1表示成功，0表示失败） + int addUser(User user); + + // 根据用户id删除用户记录的方法，传入用户id，返回一个整数表示删除操作是否成功（1表示成功，0表示失败） + int deleteUser(int id); + + // 根据用户id更新用户信息的方法，传入一个User对象，返回一个整数表示更新操作是否成功（1表示成功，0表示失败） + int updateByIdUser(User user); +} \ No newline at end of file diff --git a/Supermarket/lib/dao/impl/BufferImpl.java b/Supermarket/lib/dao/impl/BufferImpl.java new file mode 100644 index 0000000..6133106 --- /dev/null +++ b/Supermarket/lib/dao/impl/BufferImpl.java @@ -0,0 +1,717 @@ +package com.lingnan.supermarket.dao.impl; + +import com.lingnan.supermarket.dao.BufferService; +import com.lingnan.supermarket.dto.Buffer; +import com.lingnan.supermarket.dto.Production; +import com.lingnan.supermarket.utils.JDBCUtil; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.Vector; + +// 实现BufferService接口的缓冲区操作类 +public class BufferImpl implements BufferService { + + /*------------------------收银出货模块-----------------------*/ + /*返回出货缓冲表所有delmark=1的记录并排序*/ + // 获取所有出货缓冲区的记录 + public Vector allOutBuffer(){ + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement pstmt = null; // 初始化预编译语句对象 + ResultSet resultSet=null; // 初始化结果集对象 + Vector v = new Vector(); // 创建一个向量用于存储Buffer对象 + Buffer Buffer; // 声明一个Buffer对象 + try { + pstmt = conn.prepareStatement("select * from OutBuffer "); // 准备SQL查询语句 + resultSet = pstmt.executeQuery(); // 执行查询 + while(resultSet.next()) { // 遍历结果集 + Buffer = new Buffer(); // 创建一个新的Buffer对象 + Buffer.setId(resultSet.getString("id")); // 设置商品ID + Buffer.setName(resultSet.getString("name")); // 设置商品名称 + Buffer.setInPrice(resultSet.getFloat("inPrice")); // 设置进货价格 + Buffer.setOutPrice(resultSet.getFloat("OutPrice")); // 设置出货价格 + Buffer.setLife(resultSet.getInt("life")); // 设置商品保质期 + Buffer.setSum(resultSet.getInt("sum")); // 设置商品数量 + Buffer.setSupplyId(resultSet.getInt("supplyId")); // 设置供应商ID + Buffer.setId2(resultSet.getString("id2")); // 设置商品类别ID + Buffer.setName2(resultSet.getString("name2")); // 设置商品类别名称 + Buffer.setPrice(resultSet.getFloat("price")); // 设置商品总价 + Buffer.setDelmark(resultSet.getInt("delmark")); // 设置删除标记 + v.add(Buffer); // 将Buffer对象添加到向量中 + } + + + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + }finally { // 无论是否发生异常，都会执行的代码块 + JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接 + } + return v; // 返回存储所有Buffer对象的向量 + } + + /*通过id查找返回boolean*/ + // 根据ID查找出货缓冲区的记录 + public Buffer findOutBufferbyId(String id) + { + boolean flag = false; // 初始化标志为false + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement pstmt = null; // 初始化预编译语句对象 + ResultSet resultSet=null; // 初始化结果集对象 + Buffer buffer = new Buffer(); // 创建一个新的Buffer对象 + try { + pstmt = conn.prepareStatement("select * from OutBuffer where id=? "); // 准备SQL查询语句 + pstmt.setString(1, id); // 设置查询参数 + resultSet = pstmt.executeQuery(); // 执行查询 + + if(resultSet.next()) { // 如果找到对应记录 + buffer.setId(resultSet.getString("id")); // 设置商品ID + buffer.setName(resultSet.getString("name")); // 设置商品名称 + buffer.setInPrice(resultSet.getFloat("inPrice")); // 设置进货价格 + buffer.setOutPrice(resultSet.getFloat("OutPrice")); // 设置出货价格 + buffer.setLife(resultSet.getInt("life")); // 设置商品保质期 + buffer.setSum(resultSet.getInt("sum")); // 设置商品数量 + buffer.setSupplyId(resultSet.getInt("supplyId")); // 设置供应商ID + buffer.setId2(resultSet.getString("id2")); // 设置商品类别ID + buffer.setName2(resultSet.getString("name2")); // 设置商品类别名称 + buffer.setPrice(resultSet.getFloat("price")); // 设置商品总价 + buffer.setDelmark(resultSet.getInt("delmark")); // 设置删除标记 + flag = true; // 设置标志为true + }else { + return null; // 没有找到该商品，返回null + } + + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + }finally { // 无论是否发生异常，都会执行的代码块 + JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接 + } + return buffer; // 返回找到的Buffer对象 + } + + /*如果缓冲区没有那就把整条记录插入插入操作*/ + // 向出货缓冲区添加新商品记录 + public boolean addOutBufferNewProd(String id,int sum) { + boolean flag = false; // 初始化标志为false + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement pstmt = null; // 初始化预编译语句对象 + ResultSet resultSet=null; // 初始化结果集对象 + try { + pstmt = conn.prepareStatement("call InsertOutBuffer(?,?) "); // 准备存储过程调用语句 + pstmt.setString(1, id); // 设置商品ID参数 + pstmt.setInt(2, sum); // 设置商品数量参数 + + + if( pstmt.executeUpdate()==1) { // 执行更新操作 + flag = true; // 如果成功执行插入，设置标志为true + } + + + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + }finally { // 无论是否发生异常，都会执行的代码块 + JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接 + } + return flag; // 返回插入结果标志 + } + + + /*根据商品id获取sum和outprice + public Buffer findOutBufferSumAndOutPrice(String id) { + Buffer Buffer = new Buffer(); + Connection conn = JDBCUtil.getConn(); + PreparedStatement pstmt = null; + ResultSet resultSet=null; + try { + pstmt = conn.prepareStatement("select * from OutBuffer where id=? "); + pstmt.setString(1, id); + resultSet = pstmt.executeQuery(); + + if(resultSet.next()) { + Buffer.setSum(resultSet.getInt("sum")); + Buffer.setOutPrice(resultSet.getFloat("OutPrice")); + } + + + } catch (SQLException e) { + e.printStackTrace(); + }finally { + JDBCUtil.close(resultSet, pstmt, conn); + } + return Buffer; + } + */ + + + /*如果delmark是1，即是已经添加的商品*/ + // 更新已存在商品的出货缓冲区记录 + public boolean addOutBufferExeistProd(String id,int sum,Buffer buffer){ + boolean flag = false; // 初始化标志为false + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement pstmt = null; // 初始化预编译语句对象 + ResultSet resultSet = null;; // 初始化结果集对象 + try { + pstmt = conn.prepareStatement("update OutBuffer set sum=?,price=? where id=? "); // 准备SQL更新语句 + pstmt.setInt(1, sum+buffer.getSum()); // 设置更新后的商品数量 + pstmt.setFloat(2,( sum+buffer.getSum()*buffer.getOutPrice())); // 设置更新后的商品总价 + pstmt.setString(3, id); // 设置商品ID + if(pstmt.executeUpdate()==1) { // 执行更新操作 + flag = true; // 如果成功执行更新，设置标志为true + } + + + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + }finally { // 无论是否发生异常，都会执行的代码块 + + JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接 + } + return flag; // 返回更新结果标志 + } + + /*获得购物车总价*/ + // 计算出货缓冲区所有商品的总价 + public Float OutBufferAllPrice(){ + boolean flag = false; // 初始化标志为false + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement pstmt = null; // 初始化预编译语句对象 + ResultSet resultSet = null;; // 初始化结果集对象 + try { + pstmt = conn.prepareStatement("select sum(price) from OutBuffer "); // 准备SQL查询语句 + resultSet=pstmt.executeQuery(); // 执行查询 + if(resultSet.next()) { // 如果有结果 + return resultSet.getFloat("sum(price)"); // 返回总价 + } + + + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + }finally { // 无论是否发生异常，都会执行的代码块 + + JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接 + } + return null; // 如果没有结果，返回null + } + + + /*结账后对5个表进行操作*/ + // 进行结账操作并更新数据库 + public boolean Account(String number,String time,String id,int sum,Float price){ + boolean flag = false; // 初始化标志为false + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement pstmt = null; // 初始化预编译语句对象 + ResultSet resultSet = null;; // 初始化结果集对象 + try { + pstmt = conn.prepareStatement("call Account(?,?,?,?,?)"); // 准备存储过程调用语句 + pstmt.setString(1,number); // 设置订单号 + pstmt.setString(2,time ); // 设置时间 + pstmt.setString(3,id ); // 设置商品ID + pstmt.setInt(4,sum ); // 设置商品数量 + pstmt.setFloat(5, price); // 设置商品总价 + if(pstmt.execute()) // 执行更新操作 + flag = true; // 如果成功执行更新，设置标志为true + + + + + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + }finally { // 无论是否发生异常，都会执行的代码块 + + JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接 + } + return flag; // 返回更新结果标志 + } + + /*删除所有购物车*/ + // 清空出货缓冲区 + public boolean DelAllOutBuffer(){ + boolean flag = false; // 初始化标志为false + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement pstmt = null; // 初始化预编译语句对象 + ResultSet resultSet = null;; // 初始化结果集对象 + try { + pstmt = conn.prepareStatement("delete from OutBuffer"); // 准备SQL删除语句 + if(pstmt.execute()) // 执行删除操作 + flag = true; // 如果成功执行删除，设置标志为true + + + flag = true; // 如果成功执行删除，设置标志为true + + + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + }finally { // 无论是否发生异常，都会执行的代码块 + + JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接 + } + return flag; // 返回删除结果标志 + } + + /*往订单表插入一条记录*/ + // 向订单表插入一条新记录 + public boolean InsertOutOrder(String number,Float allPrice,String time,String username){ + boolean flag = false; // 初始化标志为false + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement pstmt = null; // 初始化预编译语句对象 + ResultSet resultSet = null;; // 初始化结果集对象 + try { + pstmt = conn.prepareStatement("insert into OutOrder values(?,?,?,?,?)"); // 准备SQL插入语句 + pstmt.setString(1, number); // 设置订单号 + pstmt.setFloat(2, allPrice); // 设置总价 + pstmt.setString(3, time); // 设置时间 + pstmt.setString(4, username); // 设置用户名 + pstmt.setInt(5, 1); // 设置删除标记 + if(pstmt.execute()) // 执行插入操作 + flag = true; // 如果成功执行插入，设置标志为true + + + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + }finally { // 无论是否发生异常，都会执行的代码块 + + JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接 + } + return flag; // 返回插入结果标志 + } + + /*删除缓冲区OutBuffer一条记录通过id*/ + // 根据ID删除出货缓冲区的一条记录 + public boolean DelOutBufferById(String id) { + boolean flag = false; // 初始化标志为false + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement pstmt = null; // 初始化预编译语句对象 + ResultSet resultSet = null; // 初始化结果集对象 + try { + pstmt = conn.prepareStatement("delete from OutBuffer where id=?"); // 准备SQL删除语句 + pstmt.setString(1, id); // 设置商品ID + if(pstmt.executeUpdate()==1) // 执行删除操作 + flag = true; // 如果成功执行删除，设置标志为true + + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + }finally { // 无论是否发生异常，都会执行的代码块 + + JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接 + } + return flag; // 返回删除结果标志 + } + + /*更改记录通过id*/ + // 更新出货缓冲区记录 + public boolean UpdateOutBufferById(String id,int sum) { + boolean flag = false; // 初始化标志为false + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement pstmt = null; // 初始化预编译语句对象 + ResultSet resultSet = null; // 初始化结果集对象 + try { + pstmt = conn.prepareStatement("update OutBuffer set sum=? where id=?"); // 准备SQL更新语句 + pstmt.setInt(1, sum); // 设置更新后的商品数量 + pstmt.setString(2, id); // 设置商品ID + if(pstmt.execute()) // 执行更新操作 + flag = true; // 如果成功执行更新，设置标志为true + + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + }finally { // 无论是否发生异常，都会执行的代码块 + + JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接 + } + return flag; // 返回更新结果标志 + } + + + + + + + + + + /*---------------------------进货模块----------------------------*/ + /*编辑人程文锋2210461197*/ + /*返回出货缓冲表所有delmark=1的记录并排序*/ + // 获取所有进货缓冲区的记录 + /** + * 从数据库中获取所有在库的商品信息，并返回一个包含Production对象的向量。 + * + * @return 包含所有Production对象的向量 + */ + public Vector allInBuffer(){ + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement pstmt = null; // 初始化预编译语句对象 + ResultSet resultSet=null; // 初始化结果集对象 + Vector v = new Vector(); // 创建一个向量用于存储Production对象 + Production production; // 声明一个Production对象 + try { + pstmt = conn.prepareStatement("select * from InBuffer "); // 准备SQL查询语句 + resultSet = pstmt.executeQuery(); // 执行查询 + while(resultSet.next()) { // 遍历结果集 + production = new Production(); // 创建一个新的Production对象 + production.setId(resultSet.getString("id")); // 设置商品ID + production.setName(resultSet.getString("name")); // 设置商品名称 + production.setInPrice(resultSet.getFloat("inPrice")); // 设置进货价格 + production.setOutPrice(resultSet.getFloat("OutPrice")); // 设置出货价格 + production.setLife(resultSet.getInt("life")); // 设置商品保质期 + production.setSum(resultSet.getInt("sum")); // 设置商品数量 + production.setSupplyId(resultSet.getInt("supplyId")); // 设置供应商ID + production.setId2(resultSet.getString("id2")); // 设置商品类别ID + production.setName2(resultSet.getString("name2")); // 设置商品类别名称 + production.setPrice(resultSet.getFloat("price")); // 设置商品总价 + production.setDelmark(resultSet.getInt("delmark")); // 设置删除标记 + v.add(production); // 将Production对象添加到向量中 + } + + + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + }finally { // 无论是否发生异常，都会执行的代码块 + JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接 + } + return v; // 返回存储所有Production对象的向量 + } + + /** + * 根据商品ID在数据库中查找对应的Buffer对象 + * @param id 商品的ID + * @return 找到的Buffer对象，若未找到则返回null + */ + public Buffer findInBufferbyId(String id) + { + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement pstmt = null; // 初始化预编译语句对象 + ResultSet resultSet=null; // 初始化结果集对象 + Buffer buffer = new Buffer(); // 创建一个新的Buffer对象 + try { + pstmt = conn.prepareStatement("select * from InBuffer where id=? "); // 准备SQL查询语句 + pstmt.setString(1, id); // 设置查询参数 + resultSet = pstmt.executeQuery(); // 执行查询 + + if(resultSet.next()) { // 如果找到对应记录 + buffer.setId(resultSet.getString("id")); // 设置商品ID + buffer.setName(resultSet.getString("name")); // 设置商品名称 + buffer.setInPrice(resultSet.getFloat("inPrice")); // 设置进货价格 + buffer.setOutPrice(resultSet.getFloat("OutPrice")); // 设置出货价格 + buffer.setLife(resultSet.getInt("life")); // 设置商品保质期 + buffer.setSum(resultSet.getInt("sum")); // 设置商品数量 + buffer.setSupplyId(resultSet.getInt("supplyId")); // 设置供应商ID + buffer.setId2(resultSet.getString("id2")); // 设置商品类别ID + buffer.setName2(resultSet.getString("name2")); // 设置商品类别名称 + buffer.setPrice(resultSet.getFloat("price")); // 设置商品总价 + buffer.setDelmark(resultSet.getInt("delmark")); // 设置删除标记 + } + else { + return null; // 没有找到该商品，返回null + } + + + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + }finally { // 无论是否发生异常，都会执行的代码块 + JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接 + } + return buffer; // 返回找到的Buffer对象 + } + + + + /*如果缓冲区没有那就把整条记录插入插入操作*/ +// 向进货缓冲区添加新商品记录 + /** + * 添加新商品记录到进货缓冲区 + * + * @param id 商品ID + * @param sum 商品数量 + * @return 返回插入操作是否成功的标志 + */ + public boolean addInBufferNewProd(String id,int sum) { + boolean flag = false; // 初始化标志为false + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement pstmt = null; // 初始化预编译语句对象 + ResultSet resultSet=null; // 初始化结果集对象 + try { + pstmt = conn.prepareStatement("call InsertInBuffer(?,?) "); // 准备存储过程调用语句 + pstmt.setString(1, id); // 设置商品ID参数 + pstmt.setInt(2, sum); // 设置商品数量参数 + + + if( pstmt.executeUpdate()==1) { // 执行更新操作 + flag = true; // 如果成功执行插入，设置标志为true + } + + + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + }finally { // 无论是否发生异常，都会执行的代码块 + JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接 + } + return flag; // 返回插入结果标志 + } + + + + // 向进货缓冲区插入一条记录 + // 此方法负责将一个商品记录插入到进货缓冲区中，并返回插入操作是否成功的标志 + public boolean insertInBuffer(Production p) { + boolean flag = false; // 初始化标志为false + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement pstmt = null; // 初始化预编译语句对象 + ResultSet resultSet=null; // 初始化结果集对象 + try { + pstmt = conn.prepareStatement("insert into InBuffer values(?,?,?,?,?,?,?,?,?,?,?)"); // 准备SQL插入语句 + pstmt.setString(1, p.getId()); // 设置商品ID + pstmt.setString(2, p.getName()); // 设置商品名称 + pstmt.setFloat(3, p.getInPrice()); // 设置进货价格 + pstmt.setFloat(4, p.getOutPrice()); // 设置出货价格 + pstmt.setInt(5, p.getLife()); // 设置商品保质期 + pstmt.setInt(6, p.getSum()); // 设置商品数量 + pstmt.setInt(7, p.getSupplyId()); // 设置供应商ID + pstmt.setString(8, p.getId2()); // 设置商品类别ID + pstmt.setString(9, p.getName2()); // 设置商品类别名称 + pstmt.setFloat(10,p.getPrice()); // 设置商品总价 + pstmt.setInt(11, 1); // 设置删除标记 + pstmt.executeUpdate(); // 执行插入操作 + + + if( pstmt.execute()) { // 如果成功执行插入，设置标志为true + flag = true; + } + + + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + }finally { // 无论是否发生异常，都会执行的代码块 + JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接 + } + return flag; // 返回插入结果标志 + } + + +/* 根据商品id获取sum和outprice + public Buffer findInBufferSumAndInPrice(String id) { + Buffer Buffer = new Buffer(); + Connection conn = JDBCUtil.getConn(); + PreparedStatement pstmt = null; + ResultSet resultSet=null; + try { + pstmt = conn.prepareStatement("select * from InBuffer where id=? "); + pstmt.setString(1, id); + resultSet = pstmt.executeQuery(); + + if(resultSet.next()) { + Buffer.setSum(resultSet.getInt("sum")); + Buffer.setOutPrice(resultSet.getFloat("InPrice")); + } + + + } catch (SQLException e) { + e.printStackTrace(); + }finally { + JDBCUtil.close(resultSet, pstmt, conn); + } + return Buffer; + }*/ + + + /*如果delmark是1，即是已经添加的商品*/ + // 更新已存在商品的进货缓冲区记录 + // 方法名称：addInBufferExeistProd + // 参数： + // id - 商品的唯一标识符 + // sum - 要添加的商品数量 + // buffer - 包含商品信息的缓冲区对象 + // 返回值：布尔值，表示更新操作是否成功 + public boolean addInBufferExeistProd(String id,int sum,Buffer buffer){ + boolean flag = false; // 初始化标志为false + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement pstmt = null; // 初始化预编译语句对象 + ResultSet resultSet = null;; // 初始化结果集对象 + try { + pstmt = conn.prepareStatement("update InBuffer set sum=?,price=? where id=? "); // 准备SQL更新语句 + pstmt.setInt(1, sum+buffer.getSum()); // 设置更新后的商品数量 + pstmt.setFloat(2,( sum+buffer.getSum()*buffer.getInPrice())); // 设置更新后的商品总价 + pstmt.setString(3, id); // 设置商品ID + if(pstmt.executeUpdate()==1) { // 执行更新操作 + flag = true; // 如果成功执行更新，设置标志为true + } + + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + }finally { // 无论是否发生异常，都会执行的代码块 + + JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接 + } + return flag; // 返回更新结果标志 + } + + + /*获得购物车总价*/ +// 计算进货缓冲区所有商品的总价 +// 此方法用于计算数据库中进货缓冲区所有商品的总价，并返回相应的浮点数值。 + public Float InBufferAllPrice(){ + boolean flag = false; // 初始化标志为false + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement pstmt = null; // 初始化预编译语句对象 + ResultSet resultSet = null;; // 初始化结果集对象 + try { + pstmt = conn.prepareStatement("select sum(price) from InBuffer "); // 准备SQL查询语句 + resultSet=pstmt.executeQuery(); // 执行查询 + if(resultSet.next()) { // 如果有结果 + return resultSet.getFloat("sum(price)"); // 返回总价 + } + + + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + }finally { // 无论是否发生异常，都会执行的代码块 + + JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接 + } + return null; // 如果没有结果，返回null + } + + + /*结账后对5个表进行操作*/ +// 进行进货时的记录操作 + /** + * 在库存中记录进货信息的函数 + * + * @param number 订单号 + * @param time 进货时间 + * @param id 商品ID + * @param sum 商品数量 + * @param price 商品总价 + * @return 返回操作是否成功的标志 + */ + public boolean Stock(String number,String time,String id,int sum,Float price){ + boolean flag = false; // 初始化标志为false + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement pstmt = null; // 初始化预编译语句对象 + ResultSet resultSet = null;; // 初始化结果集对象 + try { + pstmt = conn.prepareStatement("call Stock(?,?,?,?,?)"); // 准备存储过程调用语句 + pstmt.setString(1,number); // 设置订单号 + pstmt.setString(2,time ); // 设置时间 + pstmt.setString(3,id ); // 设置商品ID + pstmt.setInt(4,sum ); // 设置商品数量 + pstmt.setFloat(5, price); // 设置商品总价 + if(pstmt.executeUpdate()==1) // 执行更新操作 + flag = true; // 如果成功执行更新，设置标志为true + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + }finally { // 无论是否发生异常，都会执行的代码块 + + JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接 + } + return flag; // 返回更新结果标志 + } + + + /*删除所有购物车*/ + // 清空进货缓冲区 + /** + * 从数据库中删除进货缓冲区中的所有记录 + * + * @return 返回操作是否成功的标志 + */ + public boolean DelAllInBuffer(){ + boolean flag = false; // 初始化标志为false + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement pstmt = null; // 初始化预编译语句对象 + ResultSet resultSet = null;; // 初始化结果集对象 + try { + pstmt = conn.prepareStatement("delete from InBuffer"); // 准备SQL删除语句 + if(pstmt.execute()) // 执行删除操作 + flag = true; // 如果成功执行删除，设置标志为true + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + }finally { // 无论是否发生异常，都会执行的代码块 + + JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接 + } + return flag; // 返回删除结果标志 + } + + + /*删除缓冲区InBuffer一条记录通过id*/ + // 根据ID删除进货缓冲区的一条记录 + /** + * 根据商品ID删除进货缓冲区中的一条记录 + * + * @param id 商品ID + * @return 删除操作是否成功的标志 + */ + public boolean DelInBufferById(String id) { + boolean flag = false; // 初始化标志为false + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement pstmt = null; // 初始化预编译语句对象 + ResultSet resultSet = null;; // 初始化结果集对象 + try { + pstmt = conn.prepareStatement("delete from InBuffer where id=?"); // 准备SQL删除语句 + pstmt.setString(1, id); // 设置商品ID + if(pstmt.executeUpdate()==1) // 执行删除操作 + flag = true; // 如果成功执行删除，设置标志为true + + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + }finally { // 无论是否发生异常，都会执行的代码块 + + JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接 + } + return flag; // 返回删除结果标志 + } + + + + + + /*更改记录通过id*/ + // 更新进货缓冲区记录 + /** + * 更新进货缓冲区中指定商品ID的数量。 + * + * @param id 商品的ID + * @param sum 更新后的商品数量 + * @return 返回更新是否成功的标志 + */ +public boolean UpdateInBufferById(String id,int sum) { + boolean flag = false; // 初始化标志为false + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement pstmt = null; // 初始化预编译语句对象 + ResultSet resultSet = null; // 初始化结果集对象 + try { + pstmt = conn.prepareStatement("update InBuffer set sum=? where id=?"); // 准备SQL更新语句 + pstmt.setInt(1, sum); // 设置更新后的商品数量 + pstmt.setString(2, id); // 设置商品ID + if(pstmt.execute()) // 执行更新操作 + flag = true; // 如果成功执行更新，设置标志为true + + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + }finally { // 无论是否发生异常，都会执行的代码块 + + JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接 + } + return flag; // 返回更新结果标志 + } + + + /** + * 按照顺序插入订单 + * + * @param number 订单编号 + * @param allPrice 总价格 + * @param time 订单时间 + * @param username 用户名 + * @return 返回插入成功与否 + */ + @Override + public boolean InsertInOrder(String number, Float allPrice, String time, String username) { + // TODO Auto-generated method stub + // 插入订单的操作 + return false; + } + + +} diff --git a/Supermarket/lib/dao/impl/SupplierInfImpl.java b/Supermarket/lib/dao/impl/SupplierInfImpl.java new file mode 100644 index 0000000..c35f6b1 --- /dev/null +++ b/Supermarket/lib/dao/impl/SupplierInfImpl.java @@ -0,0 +1,266 @@ +package com.lingnan.supermarket.dao.impl; + +import com.lingnan.supermarket.dao.SupplierInfService; +import com.lingnan.supermarket.dto.SupplierInf; +import com.lingnan.supermarket.utils.JDBCUtil; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.Vector; + + +/** + * 供应商信息服务实现类 + * @cwf 2210461197 2024/12/1 + */ + +// 实现供应商信息服务接口的类 +public class SupplierInfImpl implements SupplierInfService{ + + // 查询所有供应商信息的方法 + @Override + // 该方法用于查找所有未被标记为删除的供应商信息，返回一个供应商信息的向量 + // 此方法连接数据库，执行查询，并将结果封装为供应商信息对象的向量 + public Vector findAllSupplierInf() { + Vector supplierInfs = new Vector(); // 创建一个向量用于存储供应商信息 + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement preparedStatement = null; // 初始化预编译语句对象 + ResultSet resultSet=null; // 初始化结果集对象 + + String SQL = "select * from supplierInf where delmark = 1"; // SQL查询语句，选择未被标记为删除的供应商信息 + + try { + preparedStatement = conn.prepareStatement(SQL); // 准备SQL语句 + resultSet = preparedStatement.executeQuery(); // 执行查询 + while(resultSet.next()) { // 遍历结果集 + SupplierInf supplierInf = new SupplierInf(); // 创建一个新的供应商信息对象 + supplierInf.setId(resultSet.getInt("id")); // 设置供应商ID + supplierInf.setName(resultSet.getString("name")); // 设置供应商名称 + supplierInf.setContact(resultSet.getString("contact")); // 设置供应商联系人 + supplierInf.setEmail(resultSet.getString("email")); // 设置供应商邮箱 + supplierInf.setAddress(resultSet.getString("address")); // 设置供应商地址 + supplierInf.setDelmark(resultSet.getInt("delmark")); // 设置删除标记 + supplierInfs.add(supplierInf); // 将供应商信息对象添加到向量中 + } + + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + } finally { // 无论是否发生异常，都会执行的代码块 + // 关闭数据库连接和相关资源 + JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭结果集、预编译语句和数据库连接 + } + + return supplierInfs; // 返回存储所有供应商信息的向量 + } + + // 根据供应商名称查询供应商信息的方法 + @Override + // 定义一个查找供应商信息的方法，根据传入的供应商对象进行查询 + /** + * 根据供应商名称查找供应商信息 + * @param supplierInf 包含供应商名称的供应商信息对象 + * @return 返回包含查询到的供应商信息的向量 + */ + public Vector findByNameSupplierInf(SupplierInf supplierInf) { + //SupplierInf supplierInf = new SupplierInf(); + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + Vector v = new Vector<>(); // 创建一个向量用于存储供应商信息 + System.out.println(supplierInf.getName()); // 打印供应商名称 + PreparedStatement preparedStatement = null; // 初始化预编译语句对象 + ResultSet resultSet = null; // 初始化结果集对象 + + try { + if(!supplierInf.getName().equals("")){ // 如果供应商名称不为空 + String s='%'+supplierInf.getName()+'%'; // 构建模糊查询字符串 + preparedStatement = conn.prepareStatement("select * from supplierInf where name like ? and delmark = 1"); // 准备SQL查询语句 + preparedStatement.setString(1, s); // 设置查询参数 + }else + preparedStatement = conn.prepareStatement("select * from supplierInf where delmark = 1"); // 准备SQL查询语句，选择未被标记为删除的供应商信息 + + resultSet = preparedStatement.executeQuery(); // 执行查询 + while (resultSet.next()) { // 遍历结果集 + supplierInf = new SupplierInf(); // 创建一个新的供应商信息对象 + supplierInf.setId(resultSet.getInt("id")); // 设置供应商ID + supplierInf.setName(resultSet.getString("name")); // 设置供应商名称 + supplierInf.setAddress(resultSet.getString("address")); // 设置供应商地址 + supplierInf.setContact(resultSet.getString("contact")); // 设置供应商联系人 + supplierInf.setEmail(resultSet.getString("email")); // 设置供应商邮箱 + supplierInf.setDelmark(1); // 设置删除标记 + v.add(supplierInf); // 将供应商信息对象添加到向量中 + } + Iterator it=v.iterator(); // 获取向量的迭代器 + while(it.hasNext()){ // 遍历向量 + supplierInf=it.next(); // 获取下一个供应商信息对象 + System.out.println(supplierInf.getId()+" "+supplierInf.getName()+" "+supplierInf.getAddress()+" "+supplierInf.getContact()+" "+supplierInf.getEmail()+" "+supplierInf.getDelmark()+" "); // 打印供应商信息 + } + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + } finally { // 无论是否发生异常，都会执行的代码块 + JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭结果集、预编译语句和数据库连接 + } + return v; // 返回存储供应商信息的向量 + } +// 添加供应商信息的方法 + /** + * 添加供应商信息 + * + * @param supplierInf 供应商信息对象 + * @return 插入结果标志，1表示成功，0表示失败 + */ + @Override + public int addSupplierInf(SupplierInf supplierInf) { + int flag = 0; // 初始化标志为0 + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement preparedStatement = null; // 初始化预编译语句对象 + + try { + preparedStatement = conn.prepareStatement + ("insert into supplierInf values (null,?,?,?,?,?)"); // 准备SQL插入语句 + //preparedStatement.setInt(1, supplierInf.getId()); + preparedStatement.setString(1, supplierInf.getName()); // 设置供应商名称 + preparedStatement.setString(2, supplierInf.getAddress()); // 设置供应商地址 + preparedStatement.setString(3, supplierInf.getContact()); // 设置供应商联系人 + preparedStatement.setString(4, supplierInf.getEmail()); // 设置供应商邮箱 + preparedStatement.setInt(5, 1); // 设置删除标记 + preparedStatement.executeUpdate(); // 执行插入操作 + flag = 1; // 设置标志为1，表示插入成功 + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + } finally { // 无论是否发生异常，都会执行的代码块 + JDBCUtil.close(null,preparedStatement, conn); // 关闭预编译语句和数据库连接 + } + + return flag; // 返回插入结果标志 + } + // 删除供应商信息的方法 + /** + * 删除指定ID的供应商信息 + * + * @param id 要删除的供应商ID + * @return 删除操作的结果标志，1表示成功，0表示失败 + */ + @Override + public int deleteSupplierInf(int id) { + int flag = 0; // 初始化标志为0 + + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement preparedStatement = null; // 初始化预编译语句对象 + + try { + preparedStatement = conn.prepareStatement + ("delete from supplierInf where id = ?"); // 准备SQL删除语句 + preparedStatement.setInt(1, id); // 设置供应商ID + preparedStatement.executeUpdate(); // 执行删除操作 + flag = 1; // 设置标志为1，表示删除成功 + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + } finally { // 无论是否发生异常，都会执行的代码块 + JDBCUtil.close(null,preparedStatement, conn); // 关闭预编译语句和数据库连接 + } + return flag; // 返回删除结果标志 + } + + // 更新供应商信息的方法 + /** + * 更新供应商信息 + * + * @param supplierInf 供应商信息对象 + * @return 更新结果标志，1表示成功，0表示失败 + */ + @Override + public int updateSupplierInf(SupplierInf supplierInf) { + int flag=0; // 初始化标志为0 + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement preparedStatement = null; // 初始化预编译语句对象 + + try { + preparedStatement = conn.prepareStatement("update supplierInf set name=?,address=?,contact=?,email=?,delmark=? where id = ?"); // 准备SQL更新语句 + preparedStatement.setString(1,supplierInf.getName()); // 设置供应商名称 + preparedStatement.setString(2,supplierInf.getAddress()); // 设置供应商地址 + preparedStatement.setString(3,supplierInf.getContact()); // 设置供应商联系人 + preparedStatement.setString(4, supplierInf.getEmail()); // 设置供应商邮箱 + preparedStatement.setInt(5, supplierInf.getDelmark()); // 设置删除标记 + preparedStatement.setInt(6,supplierInf.getId()); // 设置供应商ID + preparedStatement.executeUpdate(); // 执行更新操作 + flag = 1; // 设置标志为1，表示更新成功 + + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + } finally { // 无论是否发生异常，都会执行的代码块 + JDBCUtil.close(null, preparedStatement, conn); // 关闭预编译语句和数据库连接 + } + return flag; // 返回更新结果标志 + } + + + // 获取所有供应商名称的方法 + // 该方法从数据库中查询所有供应商的名称，并将其存储在一个列表中返回 + @Override + public ArrayList findNameSupplier() { + Connection conn=JDBCUtil.getConn(); // 获取数据库连接 + ArrayList v = new ArrayList(); // 创建一个列表用于存储供应商名称 + SupplierInf supplierInf; // 声明一个供应商信息对象 + PreparedStatement pstmt = null; // 初始化预编译语句对象 + ResultSet resultSet=null; // 初始化结果集对象 + v.add("全部"); // 添加默认选项“全部” + try { + pstmt = conn.prepareStatement("select * from supplierInf"); // 准备SQL查询语句 + resultSet = pstmt.executeQuery(); // 执行查询 + while(resultSet.next()){ // 遍历结果集 + + v.add(resultSet.getString("name")); // 将供应商名称添加到列表中 + } + } catch (SQLException e) { // 捕获SQL异常 + // TODO Auto-generated catch block + e.printStackTrace(); // 打印异常堆栈信息 + }finally{ // 无论是否发生异常，都会执行的代码块 + JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接 + } + + + return v; // 返回存储供应商名称的列表 + } + + // 根据供应商名称查找其ID的方法 + /** + * 根据给定的供应商名称查找对应的供应商ID。 + * 如果名称为“全部”，返回默认ID（0）。 + * 如果未找到对应的供应商，返回-1作为标志。 + * + * @param name 供应商名称 + * @return 供应商ID或标志 + */ + @Override + public int findIdSupplierByName(String name) { + int flag = -1; // 初始化标志为-1 + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement preparedStatement = null; // 初始化预编译语句对象 + ResultSet resultSet= null; // 初始化结果集对象 + int id=0; // 初始化供应商ID为0 + try { + if(name.equals("全部")) // 如果供应商名称为“全部” + return id; // 返回默认ID + preparedStatement = conn.prepareStatement + ("select * from supplierInf where name=?"); // 准备SQL查询语句 + preparedStatement.setString(1, name); // 设置查询参数 + resultSet=preparedStatement.executeQuery(); // 执行查询 + if(resultSet.next()){ // 如果找到对应记录 + return resultSet.getInt("id"); // 返回供应商ID + } + + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + } finally { // 无论是否发生异常，都会执行的代码块 + JDBCUtil.close(null,preparedStatement, conn); // 关闭预编译语句和数据库连接 + } + + return flag; // 返回查询结果标志 + } + + + +} \ No newline at end of file diff --git a/Supermarket/lib/dao/impl/UserServiceImpl.java b/Supermarket/lib/dao/impl/UserServiceImpl.java new file mode 100644 index 0000000..90eb5f9 --- /dev/null +++ b/Supermarket/lib/dao/impl/UserServiceImpl.java @@ -0,0 +1,293 @@ +package com.lingnan.supermarket.dao.impl; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.Iterator; +import java.util.Vector; + +import com.lingnan.supermarket.dao.UserService; +import com.lingnan.supermarket.dto.User; +import com.lingnan.supermarket.utils.JDBCUtil; + +// UserServiceImpl类实现了UserService接口，用于处理与用户相关的数据库操作 +public class UserServiceImpl implements UserService { + + // 实现用户登录功能 + public User login(String Name, String password) { + // 获取数据库连接 + Connection conn = JDBCUtil.getConn(); + // 用于存储查询到的用户信息，初始化为null + User user = null; + PreparedStatement pstmt = null; + ResultSet resultSet = null; + + try { + // 准备SQL语句，用于查询满足条件的用户记录 + // 条件是用户名、密码匹配且delmark为1（可能表示未删除状态） + pstmt = conn.prepareStatement("select * from User where name=? and password=? and delmark = 1"); + pstmt.setString(1, Name); + pstmt.setString(2, password); + + // 执行查询操作并获取结果集 + resultSet = pstmt.executeQuery(); + // 如果结果集中有下一条记录，说明找到了匹配的用户 + if (resultSet.next()) { + // 创建一个新的User对象来存储查询到的用户信息 + user = new User(); + // 输出查询到的用户信息（这里可能是用于调试目的） + System.out.println(resultSet.getInt("id") + " " + resultSet.getString("name") + " " + resultSet.getString("password") + " " + resultSet.getInt("sSuper")); + // 将查询到的用户信息设置到User对象中 + user.setId(resultSet.getInt("id")); + user.setUsername(resultSet.getString("name")); + user.setRname(resultSet.getString("rname")); + user.setPassword(resultSet.getString("password")); + user.setPhone(resultSet.getString("phone")); + user.setUsuper(resultSet.getInt("sSuper")); + user.setImg(resultSet.getString("img")); + user.setDelmark(1); + } + } catch (SQLException e) { + // 捕获SQL异常并打印异常信息（这里可以考虑更完善的异常处理，比如记录日志等） + e.printStackTrace(); + } finally { + // 关闭数据库相关资源，释放连接、语句和结果集 + JDBCUtil.close(resultSet, pstmt, conn); + } + + // 返回查询到的用户对象，如果未找到则返回null + return user; + } + + // 添加用户基本信息到数据库的方法 + public int addUser(User user) { + // 用于标记添加操作是否成功，初始化为0表示失败 + int flag = 0; + // 获取数据库连接 + Connection conn = JDBCUtil.getConn(); + // 设置默认的用户图片路径（这里可能需要根据实际情况进行调整） + String s = "static\\userimg\\u1.png"; + // 准备插入用户信息的SQL语句，注意values中的null是为了让数据库自动生成id（假设id是自增主键） + String SQL = "insert into User values(null,?,?,?,?,?,?,?)"; + + System.out.println(SQL); + + PreparedStatement preparedStatement = null; + ResultSet resultSet = null; + + try { + // 准备SQL语句 + preparedStatement = conn.prepareStatement(SQL); + // 设置SQL语句中的参数，将用户对象的各个属性值传入 + preparedStatement.setString(1, user.getUsername()); + preparedStatement.setString(2, user.getRname()); + preparedStatement.setString(3, user.getPassword()); + preparedStatement.setString(4, user.getPhone()); + preparedStatement.setInt(5, user.getUsuper()); + preparedStatement.setString(6, s); + preparedStatement.setInt(7, 1); + // 执行插入操作 + preparedStatement.executeUpdate(); + // 如果插入成功，将标记设置为1 + flag = 1; + } catch (SQLException e) { + // 捕获SQL异常并打印异常信息 + e.printStackTrace(); + } finally { + // 关闭数据库相关资源 + JDBCUtil.close(resultSet, preparedStatement, conn); + } + + // 返回操作结果标记，1表示成功，0表示失败 + return flag; + } + + // 查询所有用户信息的方法，返回一个存储用户对象的Vector数组 + public Vector allUser() { + // 获取数据库连接 + Connection conn = JDBCUtil.getConn(); + // 创建一个Vector来存储查询到的所有用户对象 + Vector v = new Vector<>(); + User user; + PreparedStatement pstmt = null; + ResultSet resultSet = null; + + try { + // 准备查询所有未删除用户（delmark = 1）的SQL语句 + pstmt = conn.prepareStatement("select * from User where delmark = 1"); + + // 执行查询操作并获取结果集 + resultSet = pstmt.executeQuery(); + // 遍历结果集，将每条记录转换为一个User对象并添加到Vector中 + while (resultSet.next()) { + user = new User(); + user.setId(resultSet.getInt("id")); + user.setUsername(resultSet.getString("name")); + user.setRname(resultSet.getString("rname")); + user.setPassword(resultSet.getString("password")); + user.setPhone(resultSet.getString("phone")); + user.setUsuper(resultSet.getInt("sSuper")); + user.setImg(resultSet.getString("img")); + user.setDelmark(1); + v.add(user); + } + } catch (SQLException e) { + // 捕获SQL异常并打印异常信息 + e.printStackTrace(); + } finally { + // 关闭数据库相关资源 + JDBCUtil.close(resultSet, pstmt, conn); + } + + // 返回存储所有用户对象的Vector + return v; + } + + // 根据用户的真实姓名查找用户信息的方法，返回一个存储匹配用户对象的Vector数组 + public Vector findByrnameUser(User user) { + // 获取数据库连接 + Connection conn = JDBCUtil.getConn(); + // 创建一个Vector来存储查询到的匹配用户对象 + Vector v = new Vector<>(); + // 输出传入的用户真实姓名（可能用于调试目的） + System.out.println(user.getRname()); + PreparedStatement pstmt = null; + ResultSet resultSet = null; + + try { + // 如果传入的用户真实姓名不为空字符串 + if (!user.getRname().equals("")) { + // 构造模糊查询的条件，使用%作为通配符 + String s = "%" + user.getRname() + "%"; + // 准备根据真实姓名模糊查询用户的SQL语句，且只查询未删除的用户（delmark = 1） + pstmt = conn.prepareStatement("select * from user where rname like? and delmark = 1"); + pstmt.setString(1, s); + } else { + // 如果传入的真实姓名为空字符串，则查询所有未删除的用户 + pstmt = conn.prepareStatement("select * from user where delmark = 1"); + } + + // 执行查询操作并获取结果集 + resultSet = pstmt.executeQuery(); + // 遍历结果集，将每条记录转换为一个User对象并添加到Vector中 + while (resultSet.next()) { + user = new User(); + user.setId(resultSet.getInt("id")); + user.setUsername(resultSet.getString("name")); + user.setRname(resultSet.getString("rname")); + user.setPassword(resultSet.getString("password")); + user.setPhone(resultSet.getString("phone")); + user.setUsuper(resultSet.getInt("sSuper")); + user.setImg(resultSet.getString("img")); + user.setDelmark(1); + v.add(user); + } + + // 遍历查询到的用户对象并输出相关信息（可能用于调试目的） + Iterator it = v.iterator(); + while (it.hasNext()) { + user = it.next(); + System.out.println(user.getId() + " " + user.getUsername() + " " + user.getRname() + " " + user.getPassword() + " " + user.getPhone() + " " + user.getUsuper() + " " + user.getImg() + " " + user.getDelmark() + " "); + } + } catch (SQLException e) { + // 捕获SQL异常并打印异常信息 + e.printStackTrace(); + } finally { + // 关闭数据库相关资源 + JDBCUtil.close(resultSet, pstmt, conn); + } + + // 返回存储匹配用户对象的Vector + return v; + } + + // 根据用户id删除用户记录的方法 + @Override + public int deleteUser(int id) { + // 用于标记删除操作是否成功，初始化为0表示失败 + int flag = 0; + // 获取数据库连接 + Connection conn = JDBCUtil.getConn(); + + // 准备删除指定id用户记录的SQL语句 + String SQL = "delete from user where id=?"; + + PreparedStatement preparedStatement = null; + ResultSet resultSet = null; + + try { + // 准备SQL语句并设置要删除的用户id参数 + preparedStatement = conn.prepareStatement(SQL); + preparedStatement.setInt(1, id); + + // 执行删除操作 + preparedStatement.executeUpdate(); + // 如果删除成功，将标记设置为1 + flag = 1; + } catch (SQLException e) { + // 捕获SQL异常并打印异常信息 + e.printStackTrace(); + } finally { + // 关闭数据库相关资源 + JDBCUtil.close(resultSet, preparedStatement, conn); + } + + // 返回操作结果标记，1表示成功，0表示失败 + return flag; + } + + // 此方法在原代码中未实现具体功能，只是按照接口定义返回null + // 可能是需要根据具体业务需求进一步完善的登录方法，传入了用户名、密码和用户级别参数 + @Override + public User login(String loginName, String password, int usuper) { + // TODO Auto-generated method stub + return null; + } + + // 根据用户id更新用户信息的方法 + @Override + public int updateByIdUser(User user) { + // 用于标记更新操作是否成功，初始化为0表示失败 + int flag = 0; + // 获取要更新的用户id + int id = user.getId(); + System.out.println(id); + // 获取数据库连接 + Connection conn = JDBCUtil.getConn(); + // 准备更新用户信息的SQL语句，根据指定的id更新用户的各项信息 + String SQL = "update User set name=?,rname=?,password=?,phone=?,sSuper=?,img=?,delmark=? where id=? "; + + System.out.println(SQL); + + PreparedStatement preparedStatement = null; + ResultSet resultSet = null; + + try { + // 准备SQL语句 + preparedStatement = conn.prepareStatement(SQL); + // 设置SQL语句中的参数，将用户对象的各个属性值传入 + preparedStatement.setString(1, user.getUsername()); + preparedStatement.setString(2, user.getRname()); + preparedStatement.setString(3, user.getPassword()); + preparedStatement.setString(4, user.getPhone()); + preparedStatement.setInt(5, user.getUsuper()); + preparedStatement.setString(6, user.getImg()); + preparedStatement.setInt(7, 1); + preparedStatement.setInt(8, id); + // 执行更新操作 + preparedStatement.executeUpdate(); + // 如果更新成功，将标记设置为1 + flag = 1; + } catch (SQLException e) { + // 捕获SQL异常并打印异常信息 + e.printStackTrace(); + } finally { + // 关闭数据库相关资源 + JDBCUtil.close(resultSet, preparedStatement, conn); + } + + // 返回操作结果标记，1表示成功，0表示失败 + return flag; + } +} \ No newline at end of file diff --git a/Supermarket/lib/dao/impl/inOrderServiceImpl.java b/Supermarket/lib/dao/impl/inOrderServiceImpl.java new file mode 100644 index 0000000..79185f0 --- /dev/null +++ b/Supermarket/lib/dao/impl/inOrderServiceImpl.java @@ -0,0 +1,268 @@ +package com.lingnan.supermarket.dao.impl; + +import com.lingnan.supermarket.dao.inOrderService; +import com.lingnan.supermarket.dto.InOrder; +import com.lingnan.supermarket.utils.JDBCUtil; + +import java.sql.*; +import java.util.Vector; + +public class inOrderServiceImpl implements inOrderService{ + + @Override + public Vector findAllInOrder() { + Vector inOrders = new Vector(); // 创建一个向量用于存储InOrder对象 + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement preparedStatement = null; // 声明预编译语句对象 + ResultSet resultSet = null; // 声明结果集对象 + + // SQL查询语句，选择未删除的订单并按入库日期降序排列 + String SQL = "select * from inOrder where delmark=1 order by inDate desc"; + + try { + preparedStatement = conn.prepareStatement(SQL); // 准备SQL语句 + resultSet = preparedStatement.executeQuery(); // 执行查询 + while (resultSet.next()) { // 遍历结果集 + InOrder inOrder = new InOrder(); // 创建InOrder对象 + // 从结果集中获取属性并设置到inOrder对象 + inOrder.setiNumber(resultSet.getString("iNumber")); + inOrder.setAllInPrice(resultSet.getFloat("allInPrice")); + inOrder.setInDate(resultSet.getString("inDate")); + inOrder.setPrincipal(resultSet.getString("principal")); + inOrder.setStatus(resultSet.getInt("status")); + inOrder.setDelmark(resultSet.getInt("Delmark")); + inOrders.add(inOrder); // 将InOrder对象添加到向量中 + } + + } catch (SQLException e) { + e.printStackTrace(); // 捕获并打印异常堆栈信息 + } finally { + JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭结果集、预编译语句和数据库连接 + } + + return inOrders; // 返回存储所有InOrder对象的向量 + } + + @Override + public InOrder findByIdinOrder(String iNumber) { + InOrder inOrder = new InOrder(); // 创建InOrder对象 + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement preparedStatement = null; // 声明预编译语句对象 + ResultSet resultSet = null; // 声明结果集对象 + + try { + // 准备SQL语句，根据订单号查找特定的订单 + preparedStatement = conn.prepareStatement("select * from inOrder where iNumber = ?"); //根据订单号查询订单 + preparedStatement.setString(1, iNumber); // 设置订单号参数 + resultSet = preparedStatement.executeQuery(); // 执行查询 + // 设置查询到的订单的属性到InOrder对象中 + if (resultSet.next()) { // 如果找到对应记录 + // 从结果集中获取属性并设置到inOrder对象 + inOrder.setiNumber(resultSet.getString("iNumber")); + inOrder.setAllInPrice(resultSet.getFloat("allInPrice")); + inOrder.setInDate(resultSet.getString("inDate")); + inOrder.setPrincipal(resultSet.getString("principal")); + inOrder.setStatus(resultSet.getInt("status")); + } else { + return null; // 没有找到该订单或订单不存在，返回null + } + + } catch (SQLException e) { + e.printStackTrace(); // 捕获并打印异常堆栈信息 + } finally { + JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭结果集、预编译语句和数据库连接 + } + return inOrder; // 返回找到的InOrder对象 + } + + @Override + public int addInOrder(String iNumber, float allInPrice) { + int flag = 0; // 状态标志，初始化为0 + Timestamp inDate = new Timestamp(System.currentTimeMillis()); // 获取当前时间戳 + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement preparedStatement = null; // 声明预编译语句对象 + + try { + // 准备SQL插入语句 + preparedStatement = conn.prepareStatement("insert into inOrder values (?,?,?,?)"); + preparedStatement.setString(1, iNumber); // 设置订单号参数 + preparedStatement.setFloat(2, allInPrice); // 设置总价格参数 + preparedStatement.setTimestamp(3, inDate); // 设置入库日期 + preparedStatement.setString(4, "a1"); // 设置其他固定参数（例如：默认的负责人ID） + preparedStatement.executeUpdate(); // 执行插入操作 + flag = 1; // 标记插入成功 + } catch (SQLException e) { + flag = -1; // 插入失败时标记为-1 + e.printStackTrace(); // 捕获并打印异常堆栈信息 + } finally { + JDBCUtil.close(null, preparedStatement, conn); // 关闭预编译语句和数据库连接 + } + + return flag; // 返回插入结果标志 + } + + @Override + public int deleteInOrder(String iNumber) { + int flag = 0; // 状态标志，初始化为0 + + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement preparedStatement = null; // 声明预编译语句对象 + + try { + // 准备SQL更新语句，将delmark标记为0表示逻辑删除 + preparedStatement = conn.prepareStatement("update inOrder set delmark=0 where iNumber = ?"); + preparedStatement.setString(1, iNumber); // 设置订单号参数 + preparedStatement.executeUpdate(); // 执行更新操作 + flag = 1; // 标记删除成功 + } catch (SQLException e) { + flag = -1; // 删除失败时标记为-1 + e.printStackTrace(); // 捕获并打印异常堆栈信息 + } finally { + JDBCUtil.close(null, preparedStatement, conn); // 关闭预编译语句和数据库连接 + } + return flag; // 返回删除结果标志 + } + + /*往订单表插入一条记录*/ + // 插入新的进货订单 + public boolean InsertInOrder(String number, Float allPrice, String time, String username, int c) { + boolean flag = false; // 初始化标志为false + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement pstmt = null; // 声明预编译语句对象 + ResultSet resultSet = null; // 声明结果集对象 + try { + // 准备SQL插入语句 + pstmt = conn.prepareStatement("insert into InOrder values(?,?,?,?,?,?)"); + pstmt.setString(1, number); // 设置订单号 + pstmt.setFloat(2, allPrice); // 设置总价格 + pstmt.setString(3, time); // 设置入库时间 + pstmt.setString(4, username); // 设置负责人用户名 + pstmt.setInt(5, 2); // 设置状态，假设2代表某个特定状态 + pstmt.setInt(6, 1); // 设置删除标记，假设1表示未删除 + + // 执行插入操作 + if (pstmt.execute()) + flag = true; // 如果成功执行插入，设置标志为true + + } catch (SQLException e) { + e.printStackTrace(); // 捕获并打印异常堆栈信息 + } finally { + JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接 + } + return flag; // 返回插入结果标志 + } + + /* 更新状态 */ + public boolean updateInOrderStatus(String iNumber, int status) { + boolean flag = false; // 初始化标志为false + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement preparedStatement = null; // 声明预编译语句对象 + try { + // 准备SQL更新语句，更新指定订单号的状态 + preparedStatement = conn.prepareStatement("update inOrder set status=? where iNumber=?"); + preparedStatement.setInt(1, status); // 设置状态 + preparedStatement.setString(2, iNumber); // 设置订单号 + // 如果更新操作影响了一行，则设置标志为true + if (preparedStatement.executeUpdate() == 1) + flag = true; + } catch (SQLException e) { + e.printStackTrace(); // 捕获并打印异常堆栈信息 + } finally { + JDBCUtil.close(null, preparedStatement, conn); // 关闭预编译语句和数据库连接 + } + return flag; // 返回更新结果标志 + } + + // 查找所有待入库订单（待确认） + public Vector findUnconfirmInOrder() { + Vector inOrders = new Vector(); // 创建一个向量用于存储InOrder对象 + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement preparedStatement = null; // 声明预编译语句对象 + ResultSet resultSet = null; // 声明结果集对象 + + // SQL查询语句，选择状态为2并且未删除的订单 + String SQL = "select * from inOrder where status=2 and delmark=1"; + + try { + preparedStatement = conn.prepareStatement(SQL); // 准备SQL语句 + resultSet = preparedStatement.executeQuery(); // 执行查询 + while (resultSet.next()) { // 遍历结果集 + InOrder inOrder = new InOrder(); // 创建InOrder对象 + // 从结果集中获取属性并设置到inOrder对象 + inOrder.setiNumber(resultSet.getString("iNumber")); // 设置订单号 + inOrder.setAllInPrice(resultSet.getFloat("allInPrice")); // 设置总价格 + inOrder.setInDate(resultSet.getString("inDate")); // 设置入库日期 + inOrder.setPrincipal(resultSet.getString("principal")); // 设置负责人 + inOrder.setStatus(resultSet.getInt("status")); // 设置订单状态 + inOrder.setDelmark(resultSet.getInt("Delmark")); // 设置删除标记 + inOrders.add(inOrder); // 将InOrder对象添加到向量中 + } + + } catch (SQLException e) { + e.printStackTrace(); // 捕获并打印异常堆栈信息 + } finally { + JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭结果集、预编译语句和数据库连接 + } + + return inOrders; // 返回存储待确认订单的向量 + } + + // 获取今日进货金额 + public Float TodayInPrice(String date) { + InOrder inOrder = new InOrder(); // 创建InOrder对象 + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement preparedStatement = null; // 声明预编译语句对象 + ResultSet resultSet = null; // 声明结果集对象 + Float allInPrice = (float) 0; // 初始化总进货金额为0 + + try { + // 准备SQL查询语句，计算指定日期的进货金额总和 + preparedStatement = conn.prepareStatement("select sum(allInPrice) from inOrder where inDate>=? and inDate<=date_add(?,interval 1 day)"); + preparedStatement.setString(1, date); // 设置起始日期 + preparedStatement.setString(2, date); // 设置结束日期（起始日期+1天） + resultSet = preparedStatement.executeQuery(); // 执行查询 + if (resultSet.next()) { // 如果有结果 + allInPrice = resultSet.getFloat("sum(allInPrice)"); // 获取总进货金额 + } + } catch (SQLException e) { + e.printStackTrace(); // 捕获并打印异常堆栈信息 + } finally { + JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭结果集、预编译语句和数据库连接 + } + return allInPrice; // 返回总进货金额 + } + + // 查找指定状态订单 + public Vector FindStatus(int status) { + Vector inOrders = new Vector(); // 创建一个向量用于存储InOrder对象 + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement preparedStatement = null; // 声明预编译语句对象 + ResultSet resultSet = null; // 声明结果集对象 + + try { + // 准备SQL查询语句，根据状态查找订单 + preparedStatement = conn.prepareStatement("select * from inOrder where status=? and delmark=1 order by inDate desc"); + preparedStatement.setInt(1, status); // 设置状态参数 + resultSet = preparedStatement.executeQuery(); // 执行查询 + while (resultSet.next()) { // 遍历结果集 + InOrder inOrder = new InOrder(); // 创建InOrder对象 + // 从结果集中获取属性并设置到inOrder对象 + inOrder.setiNumber(resultSet.getString("iNumber")); // 设置订单号 + inOrder.setAllInPrice(resultSet.getFloat("allInPrice")); // 设置总价格 + inOrder.setInDate(resultSet.getString("inDate")); // 设置入库日期 + inOrder.setPrincipal(resultSet.getString("principal")); // 设置负责人 + inOrder.setStatus(resultSet.getInt("status")); // 设置订单状态 + inOrder.setDelmark(resultSet.getInt("Delmark")); // 设置删除标记 + inOrders.add(inOrder); // 将InOrder对象添加到向量中 + } + + } catch (SQLException e) { + e.printStackTrace(); // 捕获并打印异常堆栈信息 + } finally { + JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭结果集、预编译语句和数据库连接 + } + + return inOrders; // 返回指定状态的订单向量 + } + +} diff --git a/Supermarket/lib/dao/impl/inRecordServiceImpl.java b/Supermarket/lib/dao/impl/inRecordServiceImpl.java new file mode 100644 index 0000000..9964df6 --- /dev/null +++ b/Supermarket/lib/dao/impl/inRecordServiceImpl.java @@ -0,0 +1,174 @@ +package com.lingnan.supermarket.dao.impl; + +import com.lingnan.supermarket.dao.inRecordService; +import com.lingnan.supermarket.dto.InRecord; +import com.lingnan.supermarket.dto.Production; +import com.lingnan.supermarket.utils.JDBCUtil; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.Vector; +/** + * 进货记录服务实现类 + * @cwf2210461197 2024/12/2 + * @version 1.0 + */ + +public class inRecordServiceImpl implements inRecordService{ + /** + * 查询所有进货记录的方法 + * @return 包含所有进货记录的向量 + */ + @Override + public Vector findAllinRecord() { + Vector inRecords = new Vector(); // 创建一个向量用于存储进货记录 + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement preparedStatement = null; // 初始化预编译语句对象 + ResultSet resultSet=null; // 初始化结果集对象 + + String SQL = "select * from inRecord"; // SQL查询语句，选择所有进货记录 + + try { + preparedStatement = conn.prepareStatement(SQL); // 准备SQL语句 + resultSet = preparedStatement.executeQuery(); // 执行查询 + while(resultSet.next()) { // 遍历结果集 + InRecord inRecord = new InRecord(); // 创建一个新的进货记录对象 + inRecord.setiNumber(resultSet.getString("iNumber")); // 设置进货单号 + inRecord.setSum(resultSet.getInt("sum")); // 设置进货数量 + inRecord.setInPrice(resultSet.getFloat("inPrice")); // 设置进货价格 + inRecords.add(inRecord); // 将进货记录对象添加到向量中 + } + + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + } finally { // 无论是否发生异常，都会执行的代码块 + JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭结果集、预编译语句和数据库连接 + } + + return inRecords; // 返回存储所有进货记录的向量 + } + + + /** + * 根据进货单号查询进货记录 + * + * @param iNumber 进货单号 + * @return 包含符合条件的进货记录的向量 + */ +@Override + public Vector findByIdinRecord(String iNumber) { + InRecord inRecord; // 声明一个进货记录对象 + Vector v = new Vector(); // 创建一个向量用于存储进货记录 + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement preparedStatement = null; // 初始化预编译语句对象 + ResultSet resultSet = null; // 初始化结果集对象 + + try { + preparedStatement = conn.prepareStatement("select * from inRecord where iNumber = ?"); // 准备SQL查询语句 + preparedStatement.setString(1, iNumber); // 设置查询参数 + resultSet = preparedStatement.executeQuery(); // 执行查询 + while(resultSet.next()) { // 遍历结果集 + inRecord = new InRecord(); // 创建一个新的进货记录对象 + inRecord.setiNumber(resultSet.getString("iNumber")); // 设置进货单号 + inRecord.setId(resultSet.getString("id")); // 设置商品ID + inRecord.setSum(resultSet.getInt("sum")); // 设置进货数量 + inRecord.setInPrice(resultSet.getFloat("Price")); // 设置进货价格 + v.add(inRecord); // 将进货记录对象添加到向量中 + } + + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + } finally { // 无论是否发生异常，都会执行的代码块 + JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭结果集、预编译语句和数据库连接 + } + return v; // 返回存储进货记录的向量 + } + + + @Override + // 该方法用于将进货记录添加到数据库中。 +// 参数 ir 是一个包含进货信息的对象。 +// 返回值 flag 表示插入的结果，1表示成功，-1表示失败。 +public int addinRecord(InRecord ir) { + int flag = 0; // 初始化标志为0 + + String iNumber = ir.getiNumber(); // 获取进货单号 + int sum = ir.getSum(); // 获取进货数量 + Float inPrice = ir.getInPrice(); // 获取进货价格 + + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement preparedStatement = null; // 初始化预编译语句对象 + + try { + preparedStatement = conn.prepareStatement + ("insert into inRecord values (?,?,?)"); // 准备SQL插入语句 + preparedStatement.setString(1, iNumber); // 设置进货单号 + preparedStatement.setInt(2, sum); // 设置进货数量 + preparedStatement.setFloat(3, inPrice); // 设置进货价格 + preparedStatement.executeUpdate(); // 执行插入操作 + flag = 1; // 设置标志为1，表示插入成功 + } catch (SQLException e) { // 捕获SQL异常 + flag = -1; // 设置标志为-1，表示插入失败 + e.printStackTrace(); // 打印异常堆栈信息 + } finally { // 无论是否发生异常，都会执行的代码块 + JDBCUtil.close(null,preparedStatement, conn); // 关闭预编译语句和数据库连接 + } + + return flag; // 返回插入结果标志 + } + + + // 删除进货记录方法，根据进货单号进行删除操作 +@Override + public int deleteinRecord(String iNumber) { + int flag = 0; // 初始化标志为0 + + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement preparedStatement = null; // 初始化预编译语句对象 + + try { + preparedStatement = conn.prepareStatement + ("delete from inRecord where iNumber = ?"); // 准备SQL删除语句 + preparedStatement.setString(1, iNumber); // 设置进货单号 + preparedStatement.executeUpdate(); // 执行删除操作 + flag = 1; // 设置标志为1，表示删除成功 + } catch (SQLException e) { // 捕获SQL异常 + flag = -1; // 设置标志为-1，表示删除失败 + e.printStackTrace(); // 打印异常堆栈信息 + } finally { // 无论是否发生异常，都会执行的代码块 + JDBCUtil.close(null,preparedStatement, conn); // 关闭预编译语句和数据库连接 + } + return flag; // 返回删除结果标志 + } + + /** + * 将进货记录插入到数据库中 + * + * @param iNumber 进货单号 + * @param p 进货的商品对象 + * @return 成功插入返回true，失败返回false + */ +public boolean insertInRecord(String iNumber,Production p) { + boolean flag = false; // 初始化标志为false + Connection conn = JDBCUtil.getConn(); // 获取数据库连接 + PreparedStatement preparedStatement = null; // 初始化预编译语句对象 + + try { + preparedStatement = conn.prepareStatement("insert into inRecord values(?,?,?,?)"); // 准备SQL插入语句 + preparedStatement.setString(1, iNumber); // 设置进货单号 + preparedStatement.setString(2, p.getId()); // 设置商品ID + preparedStatement.setInt(3,p.getSum()); // 设置进货数量 + preparedStatement.setFloat(4, p.getPrice()); // 设置进货价格 + + if(preparedStatement.executeUpdate()==1) // 执行插入操作 + flag = true; // 如果成功执行插入，设置标志为true + } catch (SQLException e) { // 捕获SQL异常 + e.printStackTrace(); // 打印异常堆栈信息 + } finally { // 无论是否发生异常，都会执行的代码块 + JDBCUtil.close(null,preparedStatement, conn); // 关闭预编译语句和数据库连接 + } + return flag; // 返回插入结果标志 + } +} \ No newline at end of file diff --git a/Supermarket/lib/dao/impl/outOrderServiceImpl.java b/Supermarket/lib/dao/impl/outOrderServiceImpl.java new file mode 100644 index 0000000..bcdd022 --- /dev/null +++ b/Supermarket/lib/dao/impl/outOrderServiceImpl.java @@ -0,0 +1,189 @@ +package com.lingnan.supermarket.dao.impl; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Timestamp; +import java.util.Date; +import java.util.Vector; + +import com.lingnan.supermarket.dao.outOrderService; +import com.lingnan.supermarket.dto.InOrder; +import com.lingnan.supermarket.dto.OutOrder; +import com.lingnan.supermarket.utils.JDBCUtil; + +// 实现outOrderService接口--用于处理与出库订单相关的数据访问操作 +public class outOrderServiceImpl implements outOrderService { + + // 查询所有出库订单信息，并按照日期降序排列返回 + @Override + public Vector findAllOutOrder() { + // 存储查询到的所有出库订单信息的向量集合 + Vector outOrders = new Vector(); + // 获取数据库连接 + Connection conn = JDBCUtil.getConn(); + PreparedStatement preparedStatement = null; + ResultSet resultSet = null; + + // 从OutOrder表中查询所有记录，并按oDate字段降序排序 + String SQL = "select * from OutOrder order by oDate desc"; + + try { + // 根据SQL语句创建预编译的Statement对象 + preparedStatement = conn.prepareStatement(SQL); + // 执行查询操作 + resultSet = preparedStatement.executeQuery(); + // 遍历结果集，将每条记录封装成OutOrder对象，并添加到outOrders集合中 + while (resultSet.next()) { + OutOrder outOrder = new OutOrder(); + outOrder.setoNumber(resultSet.getString("oNumber")); + outOrder.setAllOutPrice(resultSet.getFloat("allOutPrice")); + outOrder.setoDate(resultSet.getDate("oDate")); + outOrder.setPrincipal(resultSet.getString("principal")); + outOrders.add(outOrder); + } + + } catch (SQLException e) { + e.printStackTrace(); + } finally { + // 关闭结果集、预编译语句以及数据库连接，释放相关资源 + JDBCUtil.close(resultSet, preparedStatement, conn); + } + + return outOrders; + } + + // 根据订单编号查询对应的出库订单信息 + @Override + public OutOrder findByIdOutOrder(String oNumber) { + // 用于存储查询到的出库订单信息的对象 + OutOrder outOrder = new OutOrder(); + // 获取数据库连接 + Connection conn = JDBCUtil.getConn(); + PreparedStatement preparedStatement = null; + ResultSet resultSet = null; + + try { + // 根据订单编号查询对应的出库订单记录 + preparedStatement = conn.prepareStatement("select * from outOrder where oNumber =?"); + // 设置查询的订单编号 + preparedStatement.setString(1, oNumber); + // 执行查询操作 + resultSet = preparedStatement.executeQuery(); + // 如果结果集中有记录，说明找到了对应的订单，则将记录中的各字段值封装到outOrder对象中 + if (resultSet.next()) { + outOrder.setoNumber(resultSet.getString("oNumber")); + outOrder.setAllOutPrice(resultSet.getFloat("allOutPrice")); + outOrder.setoDate(resultSet.getDate("oDate")); + outOrder.setPrincipal(resultSet.getString("principal")); + } else { + // 如果结果集中没有记录，说明没有找到该订单或订单不存在，返回null + return null; + } + + } catch (SQLException e) { + e.printStackTrace(); + } finally { + // 关闭结果集、预编译语句以及数据库连接，释放相关资源 + JDBCUtil.close(resultSet, preparedStatement, conn); + } + return outOrder; + } + + // 向数据库中添加一条出库订单记录 + @Override + public int addOutOrder(String oNumber, float allOutPrice) { + int flag = 0; + // 获取当前系统时间戳，用于作为出库订单的日期（oDate）字段值，表示订单创建时间 + Timestamp oDate = new Timestamp(System.currentTimeMillis()); + + // 获取数据库连接 + Connection conn = JDBCUtil.getConn(); + PreparedStatement preparedStatement = null; + + try { + // 创建预编译的SQL插入语句，向outOrder表中插入一条记录 + preparedStatement = conn.prepareStatement("insert into outOrder values (?,?,?,?)"); + // 设置预编译语句中的参数，依次为订单编号、总出库价格、订单日期、负责人（此处写死为"a1"，可能后续需要改进） + preparedStatement.setString(1, oNumber); + preparedStatement.setFloat(2, allOutPrice); + preparedStatement.setTimestamp(3, oDate); + preparedStatement.setString(4, "a1"); + // 执行插入操作 + preparedStatement.executeUpdate(); + // 如果插入成功，将标志位flag设置为1，表示操作成功 + flag = 1; + } catch (SQLException e) { + // 如果插入出现异常，将标志位flag设置为 -1，表示操作失败 + flag = -1; + e.printStackTrace(); + } finally { + // 关闭预编译语句以及数据库连接，释放相关资源 + JDBCUtil.close(null, preparedStatement, conn); + } + + return flag; + } + + // 根据订单编号从数据库中删除对应的出库订单记录 + @Override + public int deleteOutOrder(String oNumber) { + int flag = 0; + + // 获取数据库连接 + Connection conn = JDBCUtil.getConn(); + PreparedStatement preparedStatement = null; + + try { + // 创建预编译的SQL删除语句，根据订单编号（oNumber）删除对应的出库订单记录 + preparedStatement = conn.prepareStatement("delete from outOrder where oNumber =?"); + // 设置预编译语句中的参数，即要删除的订单编号 + preparedStatement.setString(1, oNumber); + // 执行删除操作 + preparedStatement.executeUpdate(); + // 如果删除成功，将标志位flag设置为1，表示操作成功 + flag = 1; + } catch (SQLException e) { + // 如果删除出现异常，将标志位flag设置为 -1，表示操作失败 + flag = -1; + e.printStackTrace(); + } finally { + // 关闭预编译语句以及数据库连接，释放相关资源 + JDBCUtil.close(null, preparedStatement, conn); + } + return flag; + } + + // 获取指定日期的今日出库金额总和（此处方法名可能有点混淆，从代码逻辑看是获取指定日期的出库金额总和） + public Float TodayOutPrice(String date) { + // 创建一个InOrder对象 + InOrder inOrder = new InOrder(); + // 获取数据库连接 + Connection conn = JDBCUtil.getConn(); + PreparedStatement preparedStatement = null; + ResultSet resultSet = null; + // 用于存储查询到的今日出库金额总和，初始为0 + Float allInPrice = (float) 0; + + try { + // 通过求和函数查询指定日期范围内的总出库价格 + preparedStatement = conn.prepareStatement("select sum(allOutPrice) from outOrder where oDate>=? and oDate<=date_add(?,interval 1 day)"); + // 设置两个参数均为传入的日期值，用于限定查询的日期范围 + preparedStatement.setString(1, date); + preparedStatement.setString(2, date); + // 执行查询操作 + resultSet = preparedStatement.executeQuery(); + // 如果结果集中有记录，说明查询到了对应的金额数据，则将其取出赋值给allInPrice变量 + if (resultSet.next()) { + allInPrice = resultSet.getFloat("sum(allOutPrice)"); + } + } catch (SQLException e) { + e.printStackTrace(); + } finally { + // 关闭结果集、预编译语句以及数据库连接，释放相关资源 + JDBCUtil.close(resultSet, preparedStatement, conn); + } + return allInPrice; + } +} \ No newline at end of file diff --git a/Supermarket/lib/dao/impl/outRecordServiceImpl.java b/Supermarket/lib/dao/impl/outRecordServiceImpl.java new file mode 100644 index 0000000..98f4958 --- /dev/null +++ b/Supermarket/lib/dao/impl/outRecordServiceImpl.java @@ -0,0 +1,161 @@ +package com.lingnan.supermarket.dao.impl; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.Vector; + +import com.lingnan.supermarket.dao.outRecordService; +import com.lingnan.supermarket.dto.InOrder; +import com.lingnan.supermarket.dto.InRecord; +import com.lingnan.supermarket.dto.OutRecord; +import com.lingnan.supermarket.utils.JDBCUtil; + +// 实现了outRecordService接口--用于处理出库记录相关的数据操作逻辑 +public class outRecordServiceImpl implements outRecordService { + + // 查询所有出库记录信息 + @Override + public Vector findAllOutRecord() { + // 用于存储查询到的所有出库记录信息的向量集合 + Vector outRecords = new Vector(); + // 通过JDBCUtil工具类的静态方法来获取数据库连接 + Connection conn = JDBCUtil.getConn(); + PreparedStatement preparedStatement = null; + ResultSet resultSet = null; + + // 从outRecord表中获取所有记录 + String SQL = "select * from outRecord"; + + try { + // 根据SQL语句创建预编译的Statement对象 + preparedStatement = conn.prepareStatement(SQL); + // 执行查询操作 + resultSet = preparedStatement.executeQuery(); + // 遍历结果集，将每条记录封装成OutRecord对象，并添加到outRecords集合中 + while (resultSet.next()) { + OutRecord outRecord = new OutRecord(); + outRecord.setoNumber(resultSet.getString("oNumber")); + outRecord.setSum(resultSet.getInt("sum")); + outRecord.setOutPrice(resultSet.getFloat("outPrice")); + outRecords.add(outRecord); + } + + } catch (SQLException e) { + e.printStackTrace(); + } finally { + // 关闭结果集、预编译语句以及数据库连接，释放相关资源 + JDBCUtil.close(resultSet, preparedStatement, conn); + } + + return outRecords; + } + + // 根据订单编号查询对应的出库记录信息，返回符合条件的多条记录 + @Override + public Vector findByIdOutRecordr(String oNumber) { + // 用于临时存储单个出库记录信息的对象 + OutRecord outRecord; + // 获取数据库连接 + Connection conn = JDBCUtil.getConn(); + PreparedStatement preparedStatement = null; + ResultSet resultSet = null; + // 存储查询到的符合条件的所有出库记录信息的向量集合 + Vector v = new Vector(); + + try { + //根据给定的订单编号查询outRecord表中对应的记录 + preparedStatement = conn.prepareStatement("select * from outRecord where oNumber =?"); + // 设置要查询的订单编号 + preparedStatement.setString(1, oNumber); + // 执行查询操作，获取结果集 + resultSet = preparedStatement.executeQuery(); + // 遍历结果集，将每条符合条件的记录封装成OutRecord对象，并添加到向量集合v中 + while (resultSet.next()) { + outRecord = new OutRecord(); + outRecord.setoNumber(resultSet.getString("oNumber")); + outRecord.setId(resultSet.getString("id")); + outRecord.setSum(resultSet.getInt("sum")); + outRecord.setOutPrice(resultSet.getFloat("Price")); + v.add(outRecord); + } + + } catch (SQLException e) { + e.printStackTrace(); + } finally { + // 关闭结果集、预编译语句以及数据库连接，释放相关资源 + JDBCUtil.close(resultSet, preparedStatement, conn); + } + return v; + } + + // 向数据库中添加一条出库记录信息 + @Override + public int addoutRecord(OutRecord or) { + int flag = 0; + + // 获取要添加的出库记录对象中的订单编号 + String oNumber = or.getoNumber(); + // 获取要添加的出库记录对象中的数量 + int sum = or.getSum(); + // 获取要添加的出库记录对象中的出库价格 + Float outPrice = or.getOutPrice(); + + // 获取数据库连接 + Connection conn = JDBCUtil.getConn(); + PreparedStatement preparedStatement = null; + + try { + // 创建预编译的SQL插入语句，向outRecord表中插入一条记录，包含订单编号、数量、出库价格三个字段的值 + preparedStatement = conn.prepareStatement("insert into outRecord values (?,?,?)"); + // 设置预编译语句中的参数，依次为订单编号、数量、出库价格 + preparedStatement.setString(1, oNumber); + preparedStatement.setInt(2, sum); + preparedStatement.setFloat(3, outPrice); + // 执行插入操作 + preparedStatement.executeUpdate(); + // 如果插入成功，将标志位flag设置为1，表示操作成功 + flag = 1; + } catch (SQLException e) { + // 如果插入出现异常，将标志位flag设置为 -1，表示操作失败 + flag = -1; + e.printStackTrace(); + } finally { + // 关闭预编译语句以及数据库连接，释放相关资源，此处结果集为null + JDBCUtil.close(null, preparedStatement, conn); + } + + return flag; + } + + // 根据订单编号从数据库中删除对应的出库记录信息 + @Override + public int deleteOutOrder(String oNumber) { + int flag = 0; + + // 获取数据库连接 + Connection conn = JDBCUtil.getConn(); + PreparedStatement preparedStatement = null; + + try { + // 创建预编译的SQL删除语句，根据给定的订单编号删除outRecord表中对应的记录 + preparedStatement = conn.prepareStatement("delete from outRecord where oNumber =?"); + // 设置要删除的订单编号 + preparedStatement.setString(1, oNumber); + // 执行删除操作 + preparedStatement.executeUpdate(); + // 如果删除成功，将标志位flag设置为1，表示操作成功 + flag = 1; + } catch (SQLException e) { + // 如果删除出现异常，将标志位flag设置为 -1，表示操作失败 + flag = -1; + e.printStackTrace(); + } finally { + // 关闭预编译语句以及数据库连接，释放相关资源，此处结果集为null + JDBCUtil.close(null, preparedStatement, conn); + } + return flag; + } + +} \ No newline at end of file diff --git a/Supermarket/lib/dao/impl/prodCatalogImpl.java b/Supermarket/lib/dao/impl/prodCatalogImpl.java new file mode 100644 index 0000000..917c235 --- /dev/null +++ b/Supermarket/lib/dao/impl/prodCatalogImpl.java @@ -0,0 +1,252 @@ +package com.lingnan.supermarket.dao.impl; + +import java.io.StreamCorruptedException; +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.Vector; + +import com.lingnan.supermarket.dao.prodCatalogService; +import com.lingnan.supermarket.dto.ProdCatalog; +import com.lingnan.supermarket.utils.JDBCUtil; + +// 实现prodCatalogService接口--用于处理商品目录相关的数据持久化操作 +public class prodCatalogImpl implements prodCatalogService { + + // 将商品目录表和商品表联合查询，获取商品目录及相关商品信息 + @Override + public Vector findProdCatalogAndProd() { + // 通过JDBCUtil工具类来获取已经配置好的连接对象 + Connection conn = JDBCUtil.getConn(); + // 创建一个Vector容器，存放查询到的ProdCatalog对象 + Vector v = new Vector(); + ProdCatalog prodCatalog; + PreparedStatement pstmt = null; + ResultSet resultSet = null; + try { + // 通过预编译语句准备调用存储过程allProdCatalog + pstmt = conn.prepareStatement("call allProdCatalog()"); + // 执行查询操作 + resultSet = pstmt.executeQuery(); + // 遍历结果集，将每一条记录封装成ProdCatalog对象，并添加到Vector容器中 + while (resultSet.next()) { + prodCatalog = new ProdCatalog(); + // 设置ProdCatalog对象的id属性 + prodCatalog.setId(resultSet.getString("id")); + // 设置ProdCatalog对象的name属性 + prodCatalog.setName(resultSet.getString("name")); + v.add(prodCatalog); + } + } catch (SQLException e) { + // 若出现SQL异常，打印异常栈信息 + e.printStackTrace(); + } finally { + // 通过JDBCUtil工具类提供的方法进行关闭操作 + JDBCUtil.close(resultSet, pstmt, conn); + } + + return v; + + } + + // 根据给定的id1查找商品目录名称 + @Override + public String findProdCatalog(String id1) { + // 获取数据库连接 + Connection conn = JDBCUtil.getConn(); + + PreparedStatement pstmt = null; + ResultSet resultSet = null; + String catalog = null; + try { + // 预编译SQL语句，用于根据给定的id2查询prodCatalog表中的记录 + pstmt = conn.prepareStatement("select *from prodCatalog where id2 =?"); + // 设置SQL语句中的参数，将传入的id1赋值给查询语句中的占位符 + pstmt.setString(1, id1); + + // 执行查询操作 + resultSet = pstmt.executeQuery(); + // 如果结果集中有下一条记录，则获取对应记录中的name1字段值作为商品目录名称 + if (resultSet.next()) { + catalog = resultSet.getString("name1"); + } + } catch (SQLException e) { + e.printStackTrace(); + } finally { + // 关闭相关资源 + JDBCUtil.close(resultSet, pstmt, conn); + } + + return catalog; + + } + + // 向商品目录表prodCatalog中添加一条记录 + @Override + public int addProdCatalog(String id1, String id2) { + int flag = 0; + String name1 = null; + // 根据传入的id1判断商品类别名称，01对应食品，02对应电器，03对应生活用品，04对应其他 + if (id1.equals("01")) + name1 = "食品"; + else if (id1.equals("02")) + name1 = "电器"; + else if (id1.equals("03")) + name1 = "生活用品"; + else + name1 = "其他"; + + // 获取数据库连接 + Connection conn = JDBCUtil.getConn(); + PreparedStatement pstmt = null; + ResultSet resultSet = null; + + try { + // 预编译插入数据的SQL语句，向prodCatalog表中插入三条数据 + pstmt = conn.prepareStatement("insert into prodCatalog values(?,?,?)"); + // 设置SQL语句中的第一个参数 + pstmt.setString(1, id1); + // 设置SQL语句中的第二个参数 + pstmt.setString(2, name1); + // 设置SQL语句中的第三个参数 + pstmt.setString(3, id2); + + // 执行插入操作，若插入成功，将flag置为1，表示添加成功 + pstmt.executeUpdate(); + flag = 1; + + } catch (SQLException e) { + e.printStackTrace(); + } finally { + // 关闭相关资源 + JDBCUtil.close(resultSet, pstmt, conn); + } + + return flag; + } + + // 根据给定的id2删除商品目录表prodCatalog中的一条记录 + @Override + public int deleteProdCatalog(String id2) { + int flag = 0; + // 获取数据库连接 + Connection conn = JDBCUtil.getConn(); + PreparedStatement pstmt = null; + ResultSet resultSet = null; + + try { + // 预编译删除数据的SQL语句，根据传入的id2作为条件，从prodCatalog表中删除对应的记录 + pstmt = conn.prepareStatement("delete from prodCatalog where id2=?"); + // 设置SQL语句中的参数，将传入的id2赋值给查询语句中的占位符（?） + pstmt.setString(1, id2); + // 执行删除操作，若删除成功，将flag置为1，表示删除成功 + pstmt.executeUpdate(); + flag = 1; + + } catch (SQLException e) { + // 若出现SQL异常打印异常栈信息 + e.printStackTrace(); + } finally { + // 关闭相关资源 + JDBCUtil.close(resultSet, pstmt, conn); + } + + return flag; + } + + // 根据商品类production的name查询并输出类别id，如果传入的name为"全部"，则直接返回默认的catalogid "0" + @Override + public String findProdCatalogByname(String name) { + Connection conn = JDBCUtil.getConn(); + + PreparedStatement pstmt = null; + ResultSet resultSet = null; + + String catalogid = "0"; + try { + // 如果传入的商品名称为"全部"，则直接返回默认的catalogid + if (name.equals("全部")) { + return catalogid; + } + // 预编译SQL语句，用于根据给定的商品名称查询prodCatalog表中的记录，获取对应的类别id + pstmt = conn.prepareStatement("select * from prodCatalog where name =?"); + // 设置SQL语句中的参数，将传入的name赋值给查询语句中的占位符 + pstmt.setString(1, name); + + // 执行查询操作，获取结果集 + resultSet = pstmt.executeQuery(); + // 如果结果集中有下一条记录，则获取对应记录中的id字段值作为类别id + if (resultSet.next()) { + catalogid = resultSet.getString("id"); + } + } catch (SQLException e) { + // 若出现SQL异常，打印异常栈信息 + e.printStackTrace(); + } finally { + // 关闭相关资源 + JDBCUtil.close(resultSet, pstmt, conn); + } + + return catalogid; + } + /* + public static void main(String[] args) { + ProdCatalog p = new ProdCatalog(); + prodCatalogImpl pi = new prodCatalogImpl(); + p.setName("全部"); + System.out.println(pi.findProdCatalogByname(p.getName())); + } + */ + + // 查询商品目录表prodCatalog中的所有商品类别名称，并添加"全部"作为第一个元素后返回 + @Override + public ArrayList findNameProdCatalog() { + Connection conn = JDBCUtil.getConn(); + ArrayList v = new ArrayList(); + // 先添加"全部"作为默认的第一个类别名称 + v.add("全部"); + ProdCatalog prodCatalog; + PreparedStatement pstmt = null; + ResultSet resultSet = null; + try { + // 预编译查询所有记录的SQL语句，用于获取prodCatalog表中的所有商品类别名称 + pstmt = conn.prepareStatement("select * from prodCatalog"); + // 执行查询操作 + resultSet = pstmt.executeQuery(); + // 遍历结果集，将每条记录中的商品类别名称添加到ArrayList容器中 + while (resultSet.next()) { + + v.add(resultSet.getString("name")); + } + } catch (SQLException e) { + // 若出现SQL异常，打印异常栈信息 + e.printStackTrace(); + } finally { + // 关闭相关资源 + JDBCUtil.close(resultSet, pstmt, conn); + } + + return v; + } + /* + public static void main(String[] args) { + prodCatalogImpl pi = new prodCatalogImpl(); + ArrayList log = null; + + + log = pi.findNameProdCatalog(); + String[] s = new String[log.size()]; + for (int i = 0; i < log.size(); i++) { + s[i] = log.get(i); + System.out.println(log.get(i)); + } + for (int i = 0; i < s.length; i++) { + System.out.println(s[i]); + } + + + } + */ +} \ No newline at end of file diff --git a/Supermarket/lib/dao/impl/productionImpl.java b/Supermarket/lib/dao/impl/productionImpl.java new file mode 100644 index 0000000..268b5f3 --- /dev/null +++ b/Supermarket/lib/dao/impl/productionImpl.java @@ -0,0 +1,329 @@ +package com.lingnan.supermarket.dao.impl; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.Vector; + +import com.lingnan.supermarket.dao.productionService; +import com.lingnan.supermarket.dto.Production; +import com.lingnan.supermarket.utils.JDBCUtil; + +public class productionImpl implements productionService { + + @Override + /** + * 查找全部商品信息 + */ + public Vector findAllproduction() { + Vector productions = new Vector(); + + Connection conn = JDBCUtil.getConn(); + + String SQL = "select * from production where delmark = 1"; + + PreparedStatement preparedStatement = null; + ResultSet resultSet = null; + try { + preparedStatement = conn.prepareStatement(SQL); + + resultSet = preparedStatement.executeQuery(); + + while (resultSet.next()) { + Production production = new Production(); + production.setId(resultSet.getString("id")); + production.setName(resultSet.getString("name")); + production.setInPrice(resultSet.getFloat("inPrice")); + production.setOutPrice(resultSet.getFloat("OutPrice")); + production.setLife(resultSet.getInt("life")); + production.setSum(resultSet.getInt("sum")); + production.setSupplyId(resultSet.getInt("supplyId")); + production.setId2(resultSet.getString("id2")); + production.setName2(resultSet.getString("name2")); + production.setDelmark(resultSet.getInt("delmark")); + productions.add(production); + } + } catch (SQLException e) { + e.printStackTrace(); + } finally { + JDBCUtil.close(resultSet, preparedStatement, conn); + } + return productions; + } + + /* 用于收银系统，通过商品id返回所有信息 */ + public Production findByIdProduction(String id) { + Production production = new Production(); + Connection conn = JDBCUtil.getConn(); + PreparedStatement preparedStatement = null; + ResultSet resultSet = null; + try { + preparedStatement = conn + .prepareStatement("select * from production where id=? and delmark = 1"); + preparedStatement.setString(1, id); + resultSet = preparedStatement.executeQuery(); + + if (resultSet.next()) { + production.setId(resultSet.getString("id")); + production.setName(resultSet.getString("name")); + production.setInPrice(resultSet.getFloat("inPrice")); + production.setOutPrice(resultSet.getFloat("OutPrice")); + production.setLife(resultSet.getInt("life")); + production.setSum(resultSet.getInt("sum")); + production.setSupplyId(resultSet.getInt("supplyId")); + production.setId2(resultSet.getString("id2")); + production.setName2(resultSet.getString("name2")); + production.setDelmark(resultSet.getInt("delmark")); + } else { + System.out.println("未找到"); + return null; + } + + } catch (SQLException e) { + e.printStackTrace(); + } finally { + JDBCUtil.close(resultSet, preparedStatement, conn); + } + return production; + } + + @Override + public Vector findproduction(String name) { + /** + * 由一个商品名查找并输出全部商品信息 + */ + Vector productions = new Vector(); + Connection conn = JDBCUtil.getConn(); + PreparedStatement preparedStatement = null; + ResultSet resultSet = null; + try { + preparedStatement = conn.prepareStatement("select * from production where name like ? and delmark = 1"); + String s='%'+name+'%'; + preparedStatement.setString(1, s); + resultSet = preparedStatement.executeQuery(); + + while (resultSet.next()) { + Production production = new Production(); + production.setId(resultSet.getString("id")); + production.setName(resultSet.getString("name")); + production.setInPrice(resultSet.getFloat("inPrice")); + production.setOutPrice(resultSet.getFloat("OutPrice")); + production.setLife(resultSet.getInt("life")); + production.setSum(resultSet.getInt("sum")); + production.setSupplyId(resultSet.getInt("supplyId")); + production.setId2(resultSet.getString("id2")); + production.setName2(resultSet.getString("name2")); + production.setDelmark(resultSet.getInt("delmark")); + productions.add(production); + } + } catch (SQLException e) { + e.printStackTrace(); + } finally { + JDBCUtil.close(resultSet, preparedStatement, conn); + } + return productions; + } + + @Override + /** + * 通过商品名字来查找输出单个商品信息 + */ + public Production findByNameProduction(String name) { + Production production = new Production(); + Connection conn = JDBCUtil.getConn(); + PreparedStatement preparedStatement = null; + ResultSet resultSet = null; + try { + preparedStatement = conn + .prepareStatement("select * from production where name=?"); + preparedStatement.setString(1, name); + resultSet = preparedStatement.executeQuery(); + + if (resultSet.next()) { + production.setId(resultSet.getString("id")); + production.setName(resultSet.getString("name")); + production.setInPrice(resultSet.getFloat("inPrice")); + production.setOutPrice(resultSet.getFloat("OutPrice")); + production.setLife(resultSet.getInt("life")); + production.setSum(resultSet.getInt("sum")); + production.setSupplyId(resultSet.getInt("supplyId")); + production.setDelmark(resultSet.getInt("delmark")); + } else { + return null; + } + + } catch (SQLException e) { + e.printStackTrace(); + } finally { + JDBCUtil.close(resultSet, preparedStatement, conn); + } + return production; + } + + @Override + /** + * 假设商品不存在，增加商品的信息 + */ + public int addProduction(Production p) { + int flag = 0; + Connection conn = JDBCUtil.getConn(); + PreparedStatement preparedStatement = null; + PreparedStatement preparedStatement1 = null; + ResultSet resultSet1=null; + // 假设商品不存在 + try { + preparedStatement1 = conn.prepareStatement("select * from production where id=?"); + preparedStatement1.setString(1, p.getId()); + resultSet1=preparedStatement1.executeQuery(); + if(resultSet1.next()){ + return flag=2; + } + preparedStatement = conn.prepareStatement("insert into production values(?,?,?,?,?,?,?,?,?,?,?)"); + preparedStatement.setString(1, p.getId()); + preparedStatement.setString(2, p.getName()); + preparedStatement.setFloat(3, p.getInPrice()); + preparedStatement.setFloat(4, p.getOutPrice()); + preparedStatement.setInt(5, p.getLife()); + preparedStatement.setInt(6, p.getSum()); + preparedStatement.setInt(7, p.getSupplyId()); + preparedStatement.setString(8, p.getId2()); + preparedStatement.setString(9, p.getName2()); + preparedStatement.setFloat(10, 0); + preparedStatement.setInt(11, 1); + preparedStatement.executeUpdate(); + flag=1; + } catch (SQLException e) { + e.printStackTrace(); + } finally { + JDBCUtil.close(null, preparedStatement, conn); + } + + return flag; + } + + @Override + /** + * 删除商品信息 + */ + public int deleteProduction(String id) { + int flag = 0; + Connection conn = JDBCUtil.getConn(); + PreparedStatement preparedStatement = null; + + try { + preparedStatement = conn + .prepareStatement("delete from production where id = ?"); + preparedStatement.setString(1, id); + preparedStatement.executeUpdate(); + flag = 1; + } catch (SQLException e) { + e.printStackTrace(); + } finally { + JDBCUtil.close(null, preparedStatement, conn); + } + return flag; + + } + + @Override + /** + * 更新商品信息 + */ + public int updateProduction(Production p) { + int flag = 0; + Connection conn = JDBCUtil.getConn(); + PreparedStatement preparedStatement = null; + + try { + preparedStatement = conn + .prepareStatement("update production set name=?,inPrice=?,OutPrice=?,life=?,sum=?,delmark=? where id = ? and supplyId=?"); + + preparedStatement.setString(1, p.getName()); + preparedStatement.setFloat(2, p.getInPrice()); + preparedStatement.setFloat(3, p.getOutPrice()); + preparedStatement.setInt(4, p.getLife()); + preparedStatement.setInt(5, p.getSum()); + preparedStatement.setInt(6, p.getDelmark()); + preparedStatement.setString(7, p.getId()); + preparedStatement.setInt(8, p.getSupplyId()); + + preparedStatement.executeUpdate(); + flag = 1; + + } catch (SQLException e) { + e.printStackTrace(); + } finally { + JDBCUtil.close(null, preparedStatement, conn); + } + return flag; + } + + @Override + public Vector findProductionById2(String id) { + /** + * 由一个商品类别id2查找并输出全部商品 + */ + + Vector productions = new Vector(); + Connection conn = JDBCUtil.getConn(); + PreparedStatement preparedStatement = null; + ResultSet resultSet = null; + try { + if(id.equals("0")) + preparedStatement = conn.prepareStatement("select * from production where delmark = 1"); + else + {preparedStatement = conn.prepareStatement("select * from production where id2= ? and delmark = 1"); + preparedStatement.setString(1, id);} + resultSet = preparedStatement.executeQuery(); + + while (resultSet.next()) { + Production production = new Production(); + production.setId(resultSet.getString("id")); + production.setName(resultSet.getString("name")); + production.setInPrice(resultSet.getFloat("inPrice")); + production.setOutPrice(resultSet.getFloat("OutPrice")); + production.setLife(resultSet.getInt("life")); + production.setSum(resultSet.getInt("sum")); + production.setSupplyId(resultSet.getInt("supplyId")); + production.setId2(resultSet.getString("id2")); + production.setName2(resultSet.getString("name2")); + production.setDelmark(resultSet.getInt("delmark")); + productions.add(production); + } + } catch (SQLException e) { + e.printStackTrace(); + } finally { + JDBCUtil.close(resultSet, preparedStatement, conn); + } + return productions; + } + @Override + /** + * 更新商品数量和价格 + */ + public boolean updateProductionSum(String prodId,int sum) { + boolean flag = false; + Connection conn = JDBCUtil.getConn(); + PreparedStatement preparedStatement = null; + + try { + preparedStatement = conn + .prepareStatement("update production set sum=?+(select sum from(select sum from production where id = ? and delmark=1 ) p) where id = ? and delmark=1;"); + + preparedStatement.setInt(1, sum); + preparedStatement.setString(2, prodId); + preparedStatement.setString(3, prodId); + + if(preparedStatement.executeUpdate()==1); + flag = true; + + } catch (SQLException e) { + e.printStackTrace(); + } finally { + JDBCUtil.close(null, preparedStatement, conn); + } + return flag; + } + +} diff --git a/Supermarket/lib/dao/impl/storageRecordImpl.java b/Supermarket/lib/dao/impl/storageRecordImpl.java new file mode 100644 index 0000000..2fc09f4 --- /dev/null +++ b/Supermarket/lib/dao/impl/storageRecordImpl.java @@ -0,0 +1,144 @@ +package com.lingnan.supermarket.dao.impl; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.Vector; + +// 导入相关的业务逻辑接口、数据传输对象以及工具类，用于数据库操作和日期处理等功能 +import com.lingnan.supermarket.dao.storageRecordService; +import com.lingnan.supermarket.dto.StorageRecord; +import com.lingnan.supermarket.utils.DateUtil; +import com.lingnan.supermarket.utils.JDBCUtil; + +// 实现storageRecordService接口--用于处理库存记录相关的数据持久化操作 +public class storageRecordImpl implements storageRecordService { + + // 查询所有库存记录信息，并以Vector容器存储返回 + @Override + public Vector findAllStorageRecord() { + // 创建一个Vector容器，用于存放查询到的StorageRecord对象 + Vector v = new Vector(); + + // 获取数据库连接，通过JDBCUtil工具类来获取已经配置好的连接对象 + Connection conn = JDBCUtil.getConn(); + PreparedStatement pstmt = null; + ResultSet resultSet = null; + try { + // 编写SQL查询语句，从storageRecord表中查询所有记录，并按照cDate字段降序排序 + String sql = "select * from storageRecord order by cDate desc"; + // 使用获取到的数据库连接对象，预编译SQL语句 + pstmt = conn.prepareStatement(sql); + + // 执行查询操作 + resultSet = pstmt.executeQuery(); + // 遍历结果集，将每一条记录封装成StorageRecord对象，并添加到Vector容器中 + while (resultSet.next()) { + StorageRecord sr = new StorageRecord(); + // 设置StorageRecord对象的id属性 + sr.setId(resultSet.getString("id")); + // 设置StorageRecord对象的库存编号属性 + sr.setTheNumber(resultSet.getString("theNumber")); + // 设置StorageRecord对象的数量属性 + sr.setNum(resultSet.getInt("num")); + // 设置StorageRecord对象的执行情况属性 + sr.setExecute(resultSet.getString("execute")); + // 通过DateUtil工具类的dateToString方法将数据库中获取的时间戳类型的日期数据转换为字符串类型，方便后续使用（第二个参数为null可能表示使用默认的日期格式转换，具体看DateUtil实现） + + sr.setcDate(DateUtil.dateToString(resultSet.getTimestamp("cDate"), null)); + + // 将StorageRecord对象添加到Vector中 + v.add(sr); + } + + } catch (SQLException e) { + // 若出现SQL异常，打印异常栈信息 + e.printStackTrace(); + } finally { + // 通过JDBCUtil工具类提供的方法进行关闭操作 + JDBCUtil.close(resultSet, pstmt, conn); + + } + + return v; + } + + // 根据给定的库存编号（theNumber）查找对应的库存记录信息并返回 + @Override + public StorageRecord findByIdStorageRecord(String theNumber) { + // 初始化一个StorageRecord对象为null，用于存放查询到的库存记录信息，如果没查到则返回null + StorageRecord sr = null; + // 获取数据库连接 + Connection conn = JDBCUtil.getConn(); + PreparedStatement pstmt = null; + ResultSet resultSet = null; + + try { + // 创建一个新的StorageRecord对象，用于后续封装查询到的数据 + sr = new StorageRecord(); + // 预编译SQL语句，用于根据给定的库存编号（theNumber）查询storageRecord表中的记录 + pstmt = conn.prepareStatement("select *from storageRecord where theNumber=?"); + // 设置SQL语句中的参数，将传入的库存编号赋值给查询语句中的占位符 + pstmt.setString(1, theNumber); + // 执行查询操作，获取结果集 + resultSet = pstmt.executeQuery(); + // 如果结果集中有下一条记录，则将对应记录中的各字段值封装到StorageRecord对象中 + if (resultSet.next()) { + sr.setTheNumber((resultSet.getString("theNumber"))); + sr.setId((resultSet.getString("id"))); + sr.setNum(resultSet.getInt("num")); + sr.setExecute(resultSet.getString("execute")); + // 设置存储记录的创建日期，并进行格式化 + sr.setcDate(DateUtil.dateToString(resultSet.getTimestamp("cDate"), null)); + } + + } catch (SQLException e) { + // 若出现SQL异常，打印异常栈信息 + e.printStackTrace(); + } finally { + // 关闭相关资源 + JDBCUtil.close(resultSet, pstmt, conn); + } + + return sr; + } + + // 向库存记录表storageRecord中插入一条新的库存记录信息 + public boolean insertStorageRecord(String iNumber, String time, String prodId, String execute, int sum) { + // 定义一个布尔变量用于标记插入操作是否成功，初始化为false + boolean flag = false; + // 获取数据库连接 + Connection conn = JDBCUtil.getConn(); + PreparedStatement pstmt = null; + ResultSet resultSet = null; + + try { + // 预编译插入数据的SQL语句，向storageRecord表中插入五条数据 + pstmt = conn.prepareStatement("insert into storageRecord values(?,?,?,?,?) "); + // 设置SQL语句中的第一个参数 + pstmt.setString(1, iNumber); + // 设置SQL语句中的第二个参数 + pstmt.setString(2, time); + // 设置SQL语句中的第三个参数 + pstmt.setString(3, prodId); + // 设置SQL语句中的第四个参数 + pstmt.setString(4, execute); + // 设置SQL语句中的第五个参数 + pstmt.setInt(5, sum); + + // 执行插入操作，若受影响的行数为1，则将flag置为true，表示插入成功 + if (pstmt.executeUpdate() == 1) { + flag = true; + } + + } catch (SQLException e) { + // 若出现SQL异常，打印异常栈信息 + e.printStackTrace(); + } finally { + // 关闭相关资源 + JDBCUtil.close(resultSet, pstmt, conn); + } + return flag; + } +} \ No newline at end of file diff --git a/Supermarket/lib/dao/inOrderService.java b/Supermarket/lib/dao/inOrderService.java new file mode 100644 index 0000000..293aa66 --- /dev/null +++ b/Supermarket/lib/dao/inOrderService.java @@ -0,0 +1,18 @@ +package com.lingnan.supermarket.dao; + +import java.util.Vector; + +import com.lingnan.supermarket.dto.InOrder; + +public interface inOrderService { + //查询全部进货订单 + Vector findAllInOrder (); + //查询某个进货订单 + InOrder findByIdinOrder (String iNumber); + + //默认princial为a1. 创建时new一个时间插入,总价随机模拟 + int addInOrder(String iNumber,float allInPrice ); + int deleteInOrder(String iNumber); + + +} diff --git a/Supermarket/lib/dao/inRecordService.java b/Supermarket/lib/dao/inRecordService.java new file mode 100644 index 0000000..84b6d44 --- /dev/null +++ b/Supermarket/lib/dao/inRecordService.java @@ -0,0 +1,17 @@ +package com.lingnan.supermarket.dao; + +import java.util.Vector; + +import com.lingnan.supermarket.dto.InRecord; +import com.lingnan.supermarket.dto.User; + +public interface inRecordService { + //查询全部进货详细订单 + Vector findAllinRecord(); + //查询某个进货详细订单 + public Vector findByIdinRecord(String iNumber); + + //默认princial为a1. 创建时new一个时间插入,总价随机模拟 + int addinRecord(InRecord ir ); + int deleteinRecord(String iNumber); +} diff --git a/Supermarket/lib/dao/outOrderService.java b/Supermarket/lib/dao/outOrderService.java new file mode 100644 index 0000000..9b10c5c --- /dev/null +++ b/Supermarket/lib/dao/outOrderService.java @@ -0,0 +1,18 @@ +package com.lingnan.supermarket.dao; + +import java.util.Vector; + +import com.lingnan.supermarket.dto.InOrder; +import com.lingnan.supermarket.dto.OutOrder; + +public interface outOrderService { + //查询全部进货订单 + Vector findAllOutOrder (); + //查询某个进货订单 + OutOrder findByIdOutOrder (String oNumber ); + + //默认princial为a1. 创建时new一个时间插入,总价随机模拟 + int addOutOrder(String oNumber ,float allOutPrice ); + int deleteOutOrder(String oNumber ); + +} diff --git a/Supermarket/lib/dao/outRecordService.java b/Supermarket/lib/dao/outRecordService.java new file mode 100644 index 0000000..729976a --- /dev/null +++ b/Supermarket/lib/dao/outRecordService.java @@ -0,0 +1,16 @@ +package com.lingnan.supermarket.dao; + +import java.util.Vector; + +import com.lingnan.supermarket.dto.OutRecord; + +public interface outRecordService { + //查询全部进货订单 + Vector findAllOutRecord (); + //查询某个进货订单 + Vector findByIdOutRecordr (String oNumber ); + + + int addoutRecord(OutRecord or); + int deleteOutOrder(String oNumber); +} diff --git a/Supermarket/lib/dao/prodCatalogService.java b/Supermarket/lib/dao/prodCatalogService.java new file mode 100644 index 0000000..6fbb624 --- /dev/null +++ b/Supermarket/lib/dao/prodCatalogService.java @@ -0,0 +1,22 @@ +package com.lingnan.supermarket.dao; + +import java.util.ArrayList; +import java.util.Vector; + +import com.lingnan.supermarket.dto.ProdCatalog; + +public interface prodCatalogService { + //根据商品类production的id查询并输出类别 + Vector findProdCatalogAndProd(); + String findProdCatalog(String id1 ); + int addProdCatalog(String id1,String id2); + int deleteProdCatalog(String id2); + + //根据商品类production的name查询并输出类别id + String findProdCatalogByname(String name ); + + //查找所有商品类的类名并以数组输出 + ArrayList findNameProdCatalog(); + + +} diff --git a/Supermarket/lib/dao/productionService.java b/Supermarket/lib/dao/productionService.java new file mode 100644 index 0000000..0e81865 --- /dev/null +++ b/Supermarket/lib/dao/productionService.java @@ -0,0 +1,31 @@ +package com.lingnan.supermarket.dao; + +import java.util.Vector; + +import com.lingnan.supermarket.dto.Production; +import com.lingnan.supermarket.dto.User; + +public interface productionService { + //查找并输出全部商品 + Vector findAllproduction (); + //由一个商品名查找并输出全部商品 + Vector findproduction (String name); + Production findByNameProduction(String name); + + //由一个商品类别id2查找并输出全部商品 + Vector findProductionById2 (String id); + + /*通过id查找商品*/ + public Production findByIdProduction(String id); + //根据id增加 + int addProduction(Production p); + + //根据id删除 + public int deleteProduction(String id) ; + + //根据id更新 + int updateProduction(Production p) ; + + boolean updateProductionSum(String prodId,int sum); + +} diff --git a/Supermarket/lib/dao/storageRecordService.java b/Supermarket/lib/dao/storageRecordService.java new file mode 100644 index 0000000..6b8d383 --- /dev/null +++ b/Supermarket/lib/dao/storageRecordService.java @@ -0,0 +1,13 @@ +package com.lingnan.supermarket.dao; + +import java.util.Vector; + +import com.lingnan.supermarket.dto.StorageRecord; + +public interface storageRecordService { + /*库存日志,在进货和顾客购买时进行增加或删除操作*/ + //查询全部进货订单 + Vector findAllStorageRecord (); + //查询某个进货订单 + StorageRecord findByIdStorageRecord (String theNumber ); +}