增加备注

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<Buffer> 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<Production> 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);
+}

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<SupplierInf> findAllSupplierInf();
+	 
+	 Vector<SupplierInf> 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<String> findNameSupplier();
+	
+	//通过供应商名查找并输出id
+	int findIdSupplierByName(String name);
+	}

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<User> allUser();
+
+	// 根据用户真实姓名查找用户的方法，返回一个存储匹配用户对象的Vector数组
+	Vector<User> 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);
+}

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<Buffer> allOutBuffer(){
+		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		PreparedStatement pstmt = null; // 初始化预编译语句对象
+		ResultSet resultSet=null; // 初始化结果集对象
+		Vector<Buffer> v = new Vector<Buffer>(); // 创建一个向量用于存储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<Production> allInBuffer(){
+		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		PreparedStatement pstmt = null; // 初始化预编译语句对象
+		ResultSet resultSet=null; // 初始化结果集对象
+		Vector<Production> v = new Vector<Production>(); // 创建一个向量用于存储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;
+	}
+
+
+}

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<SupplierInf> findAllSupplierInf() {
+		Vector<SupplierInf> supplierInfs = new Vector<SupplierInf>(); // 创建一个向量用于存储供应商信息
+		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<SupplierInf> findByNameSupplierInf(SupplierInf supplierInf) {
+		//SupplierInf supplierInf = new SupplierInf();
+		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		Vector<SupplierInf> 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<SupplierInf> 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<String> findNameSupplier() {
+		Connection conn=JDBCUtil.getConn(); // 获取数据库连接
+		ArrayList<String> v = new ArrayList<String>(); // 创建一个列表用于存储供应商名称
+		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; // 返回查询结果标志
+	}
+
+
+
+}

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<User> allUser() {
+		// 获取数据库连接
+		Connection conn = JDBCUtil.getConn();
+		// 创建一个Vector来存储查询到的所有用户对象
+		Vector<User> 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<User> findByrnameUser(User user) {
+		// 获取数据库连接
+		Connection conn = JDBCUtil.getConn();
+		// 创建一个Vector来存储查询到的匹配用户对象
+		Vector<User> 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<User> 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;
+	}
+}

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<InOrder> findAllInOrder() {
+		Vector<InOrder> inOrders = new Vector<InOrder>(); // 创建一个向量用于存储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<InOrder> findUnconfirmInOrder() {
+		Vector<InOrder> inOrders = new Vector<InOrder>(); // 创建一个向量用于存储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<InOrder> FindStatus(int status) {
+		Vector<InOrder> inOrders = new Vector<InOrder>(); // 创建一个向量用于存储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; // 返回指定状态的订单向量
+	}
+
+}

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<InRecord> findAllinRecord() {
+		Vector<InRecord> inRecords = new Vector<InRecord>(); // 创建一个向量用于存储进货记录
+		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<InRecord> findByIdinRecord(String iNumber) {
+		InRecord inRecord; // 声明一个进货记录对象
+		Vector<InRecord> v = new Vector<InRecord>(); // 创建一个向量用于存储进货记录
+		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; // 返回插入结果标志
+	}
+}

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<OutOrder> findAllOutOrder() {
+		// 存储查询到的所有出库订单信息的向量集合
+		Vector<OutOrder> outOrders = new Vector<OutOrder>();
+		// 获取数据库连接
+		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;
+	}
+}

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<OutRecord> findAllOutRecord() {
+		// 用于存储查询到的所有出库记录信息的向量集合
+		Vector<OutRecord> outRecords = new Vector<OutRecord>();
+		// 通过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<OutRecord> findByIdOutRecordr(String oNumber) {
+		// 用于临时存储单个出库记录信息的对象
+		OutRecord outRecord;
+		// 获取数据库连接
+		Connection conn = JDBCUtil.getConn();
+		PreparedStatement preparedStatement = null;
+		ResultSet resultSet = null;
+		// 存储查询到的符合条件的所有出库记录信息的向量集合
+		Vector<OutRecord> v = new Vector<OutRecord>();
+
+		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;
+	}
+
+}

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<ProdCatalog> findProdCatalogAndProd() {
+		// 通过JDBCUtil工具类来获取已经配置好的连接对象
+		Connection conn = JDBCUtil.getConn();
+		// 创建一个Vector容器，存放查询到的ProdCatalog对象
+		Vector<ProdCatalog> v = new Vector<ProdCatalog>();
+		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<String> findNameProdCatalog() {
+		Connection conn = JDBCUtil.getConn();
+		ArrayList<String> v = new ArrayList<String>();
+		// 先添加"全部"作为默认的第一个类别名称
+		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<String> 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]);
+        }
+
+
+    }
+    */
+}

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<Production> findAllproduction() {
+		Vector<Production> productions = new Vector<Production>();
+
+		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<Production> findproduction(String name) {
+		/**
+		 * 由一个商品名查找并输出全部商品信息
+		 */
+		Vector<Production> productions = new Vector<Production>();
+		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<Production> findProductionById2(String id) {
+		/**
+		 * 由一个商品类别id2查找并输出全部商品		
+		 */
+
+		Vector<Production> productions = new Vector<Production>();
+		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;
+	}
+
+}

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<StorageRecord> findAllStorageRecord() {
+		// 创建一个Vector容器，用于存放查询到的StorageRecord对象
+		Vector<StorageRecord> v = new Vector<StorageRecord>();
+
+		// 获取数据库连接，通过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;
+	}
+}

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<InOrder> findAllInOrder ();
+	//查询某个进货订单
+	InOrder findByIdinOrder (String iNumber);
+	
+	//默认princial为a1. 创建时new一个时间插入,总价随机模拟
+	int addInOrder(String iNumber,float allInPrice );
+	int deleteInOrder(String iNumber);
+
+
+}

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<InRecord> findAllinRecord();
+	//查询某个进货详细订单
+	public Vector<InRecord> findByIdinRecord(String iNumber);
+	
+	//默认princial为a1. 创建时new一个时间插入,总价随机模拟
+	int addinRecord(InRecord ir );
+	int deleteinRecord(String iNumber);
+}

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<OutOrder> findAllOutOrder ();
+	//查询某个进货订单
+	OutOrder findByIdOutOrder (String oNumber );
+	
+	//默认princial为a1. 创建时new一个时间插入,总价随机模拟
+	int addOutOrder(String oNumber ,float allOutPrice  );
+	int deleteOutOrder(String oNumber );
+
+}

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<OutRecord> findAllOutRecord ();
+	//查询某个进货订单
+	Vector<OutRecord> findByIdOutRecordr (String oNumber );
+	
+	
+	int addoutRecord(OutRecord or);
+	 int deleteOutOrder(String oNumber);
+}

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<ProdCatalog> findProdCatalogAndProd();
+	String findProdCatalog(String id1 );
+	int addProdCatalog(String id1,String id2);
+	int deleteProdCatalog(String id2);
+	
+	//根据商品类production的name查询并输出类别id
+	String findProdCatalogByname(String name );
+	
+	//查找所有商品类的类名并以数组输出
+	ArrayList<String> findNameProdCatalog();
+
+	
+}

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<Production> findAllproduction ();
+	//由一个商品名查找并输出全部商品
+		Vector<Production> findproduction (String name);
+	Production findByNameProduction(String name);
+	
+	//由一个商品类别id2查找并输出全部商品
+			Vector<Production> 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);
+
+}

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<StorageRecord> findAllStorageRecord ();
+	//查询某个进货订单
+	StorageRecord findByIdStorageRecord (String theNumber  );
+}

Supermarket/src/com/lingnan/supermarket/dao/inOrderService.java

@@ -10,7 +10,10 @@ public interface inOrderService {
 	//查询某个进货订单
 	InOrder findByIdinOrder (String iNumber);
 	
-	//默认princial为a1. 创建时new一个时间插入,总价随机模拟
+	//默认princial为a1.
+	//
+	// 创建时new一个时间插入,
+	// 总价随机模拟
 	int addInOrder(String iNumber,float allInPrice );
 	int deleteInOrder(String iNumber);
 

Supermarket/src/com/lingnan/supermarket/dialog/InDialog.java

@@ -30,17 +30,14 @@ import com.lingnan.supermarket.table.OutTableModel;
 import com.lingnan.supermarket.view.InView;
 import com.lingnan.supermarket.view.OutView;
 
+public class InDialog extends JDialog implements ActionListener {
 
-public class InDialog extends JDialog implements ActionListener{
+	private JPanel prodIdPanel, sumPanel, phonePanel, opePanel;
 
+	private JLabel prodIdLabel, sumLabel;
+	private JTextField prodIdTF, sumTF;
 
-	private JPanel prodIdPanel,sumPanel,phonePanel,opePanel;
-
-	private JLabel prodIdLabel,sumLabel;
-	private JTextField prodIdTF,sumTF;
-
-	private JButton addBtn,cancelBtn;
-
+	private JButton addBtn, cancelBtn;
 
 	private OutTableModel outTableModel = new OutTableModel();
 
@@ -58,38 +55,43 @@ public class InDialog extends JDialog implements ActionListener{
 	private Vector<Production> vAll;
 	private static String catalog;
 
-	public InDialog(JFrame parent,Vector<Production> v,User user) {
-		super(parent,"添加商品");
-
-		setSize(250,200);
+	/**
+	 * 构造函数
+	 *
+	 * @param parent 父级 JFrame
+	 * @param v 商品列表
+	 * @param user 当前用户
+	 */
+	public InDialog(JFrame parent, Vector<Production> v, User user) {
+		super(parent, "添加商品");
+
+		setSize(250, 200);
 		setLocationRelativeTo(null);
 		setModal(true);
 		setResizable(false);
 		this.setLayout(new FlowLayout());
-		JFramparent=parent;
-		this.v=v;
+		JFramparent = parent;
+		this.v = v;
 		this.user = user;
 		initView();
-
-
 	}
 
-
-
-
-
+	/**
+	 * 初始化视图组件
+	 */
 	private void initView() {
+		// 商品编号面板
 		prodIdPanel = new JPanel();
 		prodIdLabel = new JLabel("编号");
 
-
-		productionImpl= new productionImpl();
-		vAll=productionImpl.findAllproduction();
+		// 获取所有商品信息并填充下拉框
+		productionImpl = new productionImpl();
+		vAll = productionImpl.findAllproduction();
 		allProdId = new String[vAll.size()];
-		for(int i=0;i<vAll.size();i++) {
-			allProdId[i]=vAll.elementAt(i).getId();
+		for (int i = 0; i < vAll.size(); i++) {
+			allProdId[i] = vAll.elementAt(i).getId();
 		}
-		catalog = allProdId[0];
+		catalog = allProdId[0]; // 默认选择第一个商品
 		System.out.println(allProdId[0]);
 		combo = new JComboBox<String>(allProdId);
 		combo.addItemListener(new MyItemListener());
@@ -97,15 +99,14 @@ public class InDialog extends JDialog implements ActionListener{
 		prodIdPanel.add(prodIdLabel);
 		prodIdPanel.add(combo);
 
-
-
+		// 商品数量面板
 		sumPanel = new JPanel();
 		sumLabel = new JLabel("数量");
 		sumTF = new JTextField(10);
 		sumPanel.add(sumLabel);
 		sumPanel.add(sumTF);
 
-
+		// 操作按钮面板
 		opePanel = new JPanel();
 		addBtn = new JButton("添加");
 		cancelBtn = new JButton("取消");
@@ -114,111 +115,101 @@ public class InDialog extends JDialog implements ActionListener{
 		opePanel.add(addBtn);
 		opePanel.add(cancelBtn);
 
+		// 设置容器
 		Container container = getContentPane();
 		container.add(prodIdPanel);
 		container.add(sumPanel);
 		container.add(opePanel);
 	}
 
-	/*将数组传到inview的刷新方法里面再刷新*/
-	public Vector<Production> getVector(){
+	/**
+	 * 获取商品列表
+	 *
+	 * @return 商品列表
+	 */
+	public Vector<Production> getVector() {
 		return v;
 	}
 
-
-	//下拉框监听
-	static class MyItemListener implements ItemListener{
+	/**
+	 * 下拉框监听类
+	 */
+	static class MyItemListener implements ItemListener {
 
 		@Override
 		public void itemStateChanged(ItemEvent e) {
-			JComboBox cb=(JComboBox)e.getSource();
-			String select=(String) cb.getSelectedItem();
-			catalog=select;
+			JComboBox cb = (JComboBox) e.getSource();
+			String select = (String) cb.getSelectedItem();
+			catalog = select; // 更新商品编号
 		}
-
 	}
 
-
-
-
-
-
-
-
 	@Override
 	public void actionPerformed(ActionEvent e) {
 		Object source = e.getSource();
-		if(source==addBtn){
-			//1.判断是否存在这个商品
-			//2.如果存在就获取这条商品记录为一个对象
-			//3.判断购物缓冲区是否有这个记录
-			//3.1如果有update数量和price
-			//3.2如果没有就insert这条记录，把sum更新
-			//保存到数据库
-			//关闭对话框
-			//刷新table
-
-
-			String prodId =catalog;
-			System.out.println("proId="+prodId);
-			System.out.println("vatalog="+catalog);
-
-			if(sumTF.getText().equals("")) {
-				JOptionPane.showMessageDialog(this,"请输入完整","提示",JOptionPane.ERROR_MESSAGE);
+
+		if (source == addBtn) {
+			// 1. 判断是否存在这个商品
+			// 2. 如果存在就获取这条商品记录为一个对象
+			// 3. 判断购物缓冲区是否有这个记录
+			// 3.1 如果有 update 数量和 price
+			// 3.2 如果没有就 insert 这条记录，把 sum 更新
+			// 保存到数据库
+			// 关闭对话框
+			// 刷新 table
+
+			String prodId = catalog;
+			System.out.println("proId=" + prodId);
+			System.out.println("vatalog=" + catalog);
+
+			if (sumTF.getText().equals("")) {
+				JOptionPane.showMessageDialog(this, "请输入完整", "提示", JOptionPane.ERROR_MESSAGE);
 				return;
 			}
-			int sum =  Integer.parseInt(sumTF.getText()) ;
+			int sum = Integer.parseInt(sumTF.getText());
 
-			if(sum<0) {/*判断输入大于0*/
-				JOptionPane.showMessageDialog(this,"请输入大于0的数量","提示",JOptionPane.ERROR_MESSAGE);
+			if (sum < 0) { // 判断输入的数量是否大于 0
+				JOptionPane.showMessageDialog(this, "请输入大于0的数量", "提示", JOptionPane.ERROR_MESSAGE);
 				return;
 			}
 
-			//TODO 参数校验
-			/*/判断是已添加,未添加还是不存在*/
+			// TODO: 参数校验
+
+			// 判断商品是否已添加
 			productionImpl productionImpl = new productionImpl();
 			production = new Production();
 			production = productionImpl.findByIdProduction(prodId);
 
-
-			if(production!=null) {/*商品库有这个商品存在*/
+			if (production != null) { // 商品库中有该商品
 				int mark = 0;
-				for(Production p:v) {
+				for (Production p : v) {
 
-					if(p.getId().equals(prodId)){/*如果数组中存在相同商品就更新数量和价格*/
-						sum=p.getSum()+sum;/*数量*/
+					if (p.getId().equals(prodId)) { // 如果数组中存在相同商品，更新数量和价格
+						sum = p.getSum() + sum; // 更新数量
 						p.setSum(sum);
-						p.setPrice(sum*p.getInPrice());/*进货价格*/
+						p.setPrice(sum * p.getInPrice()); // 更新进货价格
 						mark = 1;
 						break;
 					}
 
 				}
-				if(mark==0) {/*插入新的*/
+				if (mark == 0) { // 插入新的商品
 					System.out.println("缓存区不存在，插入新的数据");
-					production.setSum(sum);/*更新价格和数量后插入心的*/
-					production.setPrice(sum*production.getInPrice());
+					production.setSum(sum); // 更新数量和价格后插入新商品
+					production.setPrice(sum * production.getInPrice());
 					v.add(production);
-
 				}
 
-				System.out.println("插入后v的大小"+v.size());
-				this.dispose();
-				JOptionPane.showMessageDialog(this,"添加成功","提示",JOptionPane.ERROR_MESSAGE);
-
-
-			}
-
+				System.out.println("插入后 v 的大小：" + v.size());
+				this.dispose(); // 关闭对话框
+				JOptionPane.showMessageDialog(this, "添加成功", "提示", JOptionPane.INFORMATION_MESSAGE);
 
-			else {/*商品库没有这个商品*/
-				JOptionPane.showMessageDialog(this,"商品不存在","提示",JOptionPane.ERROR_MESSAGE);
+			} else { // 商品库中没有该商品
+				JOptionPane.showMessageDialog(this, "商品不存在", "提示", JOptionPane.ERROR_MESSAGE);
 			}
-		}
-		else if(source == cancelBtn) {
-
-			this.dispose();
+		} else if (source == cancelBtn) {
+			this.dispose(); // 关闭对话框
 		}
 	}
 
-
 }

Supermarket/src/com/lingnan/supermarket/dialog/ProductionDialog.java

@@ -34,23 +34,23 @@ import com.lingnan.supermarket.view.ProdCatalogView.MyItemListener;
 public class ProductionDialog extends JDialog implements ActionListener {
 
 	private JPanel namePanel, addressPanel, contactPanel,
-			opePanel,idPanel,inpricePanel,outpricePanel,lifePanel,
-			sumPanel,supplyidPanel,id2Panel,name2Panel;
+			opePanel, idPanel, inpricePanel, outpricePanel, lifePanel,
+			sumPanel, supplyidPanel, id2Panel, name2Panel;
 
 	private JLabel nameLabel, addressLabel, contactLabel,
-			idLabel,inpriceLabel,outpriceLabel,lifeLabel,sumLabel,
-			supplyidLabel,id2Label,name2Label;
+			idLabel, inpriceLabel, outpriceLabel, lifeLabel, sumLabel,
+			supplyidLabel, id2Label, name2Label;
 	private JTextField nameTF, addressTF, contactTF,
-			idTF,inpriceTF,outpriceTF,lifeTF,sumTF,
-			supplyidTF,id2TF,name2TF;
+			idTF, inpriceTF, outpriceTF, lifeTF, sumTF,
+			supplyidTF, id2TF, name2TF;
 
 	private JButton saveBtn, cancelBtn;
 
 	private productionService productionService = new productionImpl();
 
-	//下拉类别
-	private String log[]=null;
-	private ArrayList<String>alog=null;
+	// 下拉类别
+	private String log[] = null;
+	private ArrayList<String> alog = null;
 	private ProdCatalogTM prodCatalogTM;
 	private ProdCatalog pc;
 	private prodCatalogImpl pci;
@@ -58,9 +58,9 @@ public class ProductionDialog extends JDialog implements ActionListener {
 	private String id2;
 	private String name2;
 
-	//下拉供应商类别
-	private String superlier[]=null;
-	private ArrayList<String>asuperlier=null;
+	// 下拉供应商类别
+	private String superlier[] = null;
+	private ArrayList<String> asuperlier = null;
 	private SupplierInf si;
 	private SupplierInfImpl sii;
 	private JComboBox<String> combo1;
@@ -73,16 +73,11 @@ public class ProductionDialog extends JDialog implements ActionListener {
 	public ProductionDialog(JFrame parent) {
 		super(parent, "添加");
 
-
 		setSize(350, 500);
-
 		setLocationRelativeTo(null);
-
 		setModal(true);
 		setResizable(false);
-
 		this.setLayout(new FlowLayout());
-
 		initView();
 	}
 
@@ -93,14 +88,12 @@ public class ProductionDialog extends JDialog implements ActionListener {
 		idPanel.add(idLabel);
 		idPanel.add(idTF);
 
-
 		namePanel = new JPanel();
 		nameLabel = new JLabel("名称");
 		nameTF = new JTextField(15);
 		namePanel.add(nameLabel);
 		namePanel.add(nameTF);
 
-
 		inpricePanel = new JPanel();
 		inpriceLabel = new JLabel("进货单价");
 		inpriceTF = new JTextField(15);
@@ -113,33 +106,29 @@ public class ProductionDialog extends JDialog implements ActionListener {
 		outpricePanel.add(outpriceLabel);
 		outpricePanel.add(outpriceTF);
 
-
 		lifePanel = new JPanel();
 		lifeLabel = new JLabel("保质期(月份数)");
 		lifeTF = new JTextField(15);
 		lifePanel.add(lifeLabel);
 		lifePanel.add(lifeTF);
 
-
 		sumPanel = new JPanel();
 		sumLabel = new JLabel("库存");
 		sumTF = new JTextField(15);
 		sumPanel.add(sumLabel);
 		sumPanel.add(sumTF);
 
-		//供应商名下拉框 传递supplyid
+		// 供应商名下拉框 传递supplyid
 		supplyidPanel = new JPanel();
 		supplyidLabel = new JLabel("供应商");
-//		supplyidTF = new JTextField(15);
 
-		sii=new SupplierInfImpl();
-		this.asuperlier=sii.findNameSupplier();
-		this.superlier=new String[asuperlier.size()];
-		for(int i=0;i<asuperlier.size();i++)
-			superlier[i]=asuperlier.get(i);
+		sii = new SupplierInfImpl();
+		this.asuperlier = sii.findNameSupplier();
+		this.superlier = new String[asuperlier.size()];
+		for (int i = 0; i < asuperlier.size(); i++)
+			superlier[i] = asuperlier.get(i);
 
-		for(int i=0;i<superlier.length;i++)
-		{
+		for (int i = 0; i < superlier.length; i++) {
 			System.out.println(superlier[i]);
 		}
 
@@ -149,31 +138,20 @@ public class ProductionDialog extends JDialog implements ActionListener {
 		supplyidPanel.add(supplyidLabel);
 		supplyidPanel.add(combo1);
 
-
-
-
-
-	/*	id2Panel = new JPanel();
-		id2Label = new JLabel("分类id");
-		id2TF = new JTextField(id2,15);
-		id2Panel.add(id2Label);
-		id2Panel.add(id2TF);*/
-		//类名下拉框
+		// 类名下拉框
 		name2Panel = new JPanel();
 		name2Label = new JLabel("类名");
-		pci=new prodCatalogImpl();
-		this.alog=pci.findNameProdCatalog();
-		this.log=new String[alog.size()];
-		for(int i=0;i<alog.size();i++)
-			log[i]=alog.get(i);
-
+		pci = new prodCatalogImpl();
+		this.alog = pci.findNameProdCatalog();
+		this.log = new String[alog.size()];
+		for (int i = 0; i < alog.size(); i++)
+			log[i] = alog.get(i);
 
 		combo = new JComboBox<String>(log);
 		combo.addItemListener(new MyItemListener());
 		name2Panel.add(name2Label);
 		name2Panel.add(combo);
 
-
 		addressPanel = new JPanel();
 		addressLabel = new JLabel("地址");
 		addressTF = new JTextField(15);
@@ -202,7 +180,6 @@ public class ProductionDialog extends JDialog implements ActionListener {
 		container.add(lifePanel);
 		container.add(sumPanel);
 		container.add(supplyidPanel);
-//		container.add(id2Panel);
 		container.add(name2Panel);
 		container.add(opePanel);
 	}
@@ -223,22 +200,23 @@ public class ProductionDialog extends JDialog implements ActionListener {
 			int life = Integer.parseInt(lifeTF.getText());
 			int sum = Integer.parseInt(sumTF.getText());
 
-
-
 			// TODO 参数校验
 			if (this.production == null) {
-				if(supplyid==-1){
-					JOptionPane.showMessageDialog(this, "商品检索出错", "提示",
+				if (supplyid == -1) {
+					JOptionPane.showMessageDialog(this,
+							"商品检索出错", "提示",
 							JOptionPane.ERROR_MESSAGE);
 					return;
 				}
-				if(supplyid==0){
-					JOptionPane.showMessageDialog(this, "请选择商品名", "提示",
+				if (supplyid == 0) {
+					JOptionPane.showMessageDialog(this,
+							"请选择商品名", "提示",
 							JOptionPane.ERROR_MESSAGE);
 					return;
 				}
-				if(id2.equals("0")){
-					JOptionPane.showMessageDialog(this, "请选择商品类", "提示",
+				if (id2.equals("0")) {
+					JOptionPane.showMessageDialog(this,
+							"请选择商品类", "提示",
 							JOptionPane.ERROR_MESSAGE);
 					return;
 				}
@@ -256,38 +234,24 @@ public class ProductionDialog extends JDialog implements ActionListener {
 				int result = productionService.addProduction(production);
 				// int result = 1;
 				if (result == 1) {
-
 					JOptionPane.showMessageDialog(this, "添加成功", "提示",
 							JOptionPane.INFORMATION_MESSAGE);
 					this.dispose();
-				} else if(result == 2){
+				} else if (result == 2) {
 					JOptionPane.showMessageDialog(this, "已存在该商品", "提示",
 							JOptionPane.ERROR_MESSAGE);
-				}
-				else {
+				} else {
 					JOptionPane.showMessageDialog(this, "出错！添加失败", "提示",
 							JOptionPane.ERROR_MESSAGE);
 				}
-			}/*else{
-				//更新
-				SupplierInf supplierInf= new SupplierInf();
-				supplierInf.setName(name);
-				supplierInf.setAddress(address);
-				supplierInf.setContact(contact);
-				supplierInf.setId(this.supplierInf.getId());
-
-				int result = supplierInfService.updateSupplierInf(supplierInf);
-				if(result==1){
-					JOptionPane.showMessageDialog(this, "更新成功", "提示",
-							JOptionPane.INFORMATION_MESSAGE);
-				}
-			}*/
+			}
 
 		} else if (source == cancelBtn) {
-
 			this.dispose();
 		}
 	}
+
+
 	public class MyItemListener implements ItemListener {
 
 		@Override

Supermarket/src/com/lingnan/supermarket/dialog/SupplierInfDialog.java

@@ -21,10 +21,10 @@ import com.lingnan.supermarket.view.SupplierView;
 
 public class SupplierInfDialog extends JDialog implements ActionListener {
 
-	private JPanel namePanel, addressPanel, contactPanel,emailPanel, opePanel;
+	private JPanel namePanel, addressPanel, contactPanel, emailPanel, opePanel;
 
-	private JLabel nameLabel, addressLabel, contactLabel,emailLabel;
-	private JTextField nameTF, addressTF, contactTF,emailTF;
+	private JLabel nameLabel, addressLabel, contactLabel, emailLabel;
+	private JTextField nameTF, addressTF, contactTF, emailTF;
 
 	private JButton saveBtn, cancelBtn;
 
@@ -36,21 +36,31 @@ public class SupplierInfDialog extends JDialog implements ActionListener {
 
 	public SupplierInfDialog(JFrame parent, SupplierView supplierView) {
 		super(parent, "添加");
+
+		// 保存传入的SupplierView对象，可能用于刷新视图
 		this.supplierView = supplierView;
 
+		// 设置窗口大小
 		setSize(350, 300);
 
+		// 设置窗口显示的位置为居中
 		setLocationRelativeTo(null);
 
+		// 设置该窗口为模态窗口
 		setModal(true);
+
+		// 设置不可调整大小
 		setResizable(false);
 
+		// 使用FlowLayout布局管理器
 		this.setLayout(new FlowLayout());
 
+		// 初始化组件
 		initView();
 	}
 
 	private void initView() {
+		// 初始化面板和文本框
 		namePanel = new JPanel();
 		nameLabel = new JLabel("名称");
 		nameTF = new JTextField(15);
@@ -75,14 +85,19 @@ public class SupplierInfDialog extends JDialog implements ActionListener {
 		emailPanel.add(emailLabel);
 		emailPanel.add(emailTF);
 
+		// 初始化操作按钮面板
 		opePanel = new JPanel();
 		saveBtn = new JButton("保存");
 		cancelBtn = new JButton("取消");
+
+		// 添加按钮的事件监听器
 		saveBtn.addActionListener(this);
 		cancelBtn.addActionListener(this);
+
 		opePanel.add(saveBtn);
 		opePanel.add(cancelBtn);
 
+		// 将所有面板添加到容器中
 		Container container = getContentPane();
 		container.add(namePanel);
 		container.add(addressPanel);
@@ -93,29 +108,33 @@ public class SupplierInfDialog extends JDialog implements ActionListener {
 
 	@Override
 	public void actionPerformed(ActionEvent e) {
+		// 获取事件源对象
 		Object source = e.getSource();
-		if (source == saveBtn) {
-			// 思路获取数据
-			// 保存到数据库
-			// 关闭对话框
-			// 刷新table
 
+		// 如果点击了保存按钮
+		if (source == saveBtn) {
+			// 获取用户输入的值
 			String name = nameTF.getText();
 			String address = addressTF.getText();
 			String contact = contactTF.getText();
 			String email = emailTF.getText();
 
-			// TODO 参数校验
+			// TODO: 参数校验，确保输入的数据是有效的
+
+			// 如果是新添加的供应商
 			if (this.supplierInf == null) {
+				// 创建一个新的SupplierInf对象并设置值
 				SupplierInf supplierInf = new SupplierInf();
 				supplierInf.setName(name);
 				supplierInf.setAddress(address);
 				supplierInf.setContact(contact);
 				supplierInf.setEmail(email);
+
+				// 调用服务层的添加方法，将供应商信息保存到数据库
 				int result = supplierInfService.addSupplierInf(supplierInf);
-				// int result = 1;
-				if (result == 1) {
 
+				// 根据返回的结果显示相应的提示框
+				if (result == 1) {
 					JOptionPane.showMessageDialog(this, "添加成功", "提示",
 							JOptionPane.INFORMATION_MESSAGE);
 					this.dispose();
@@ -123,23 +142,27 @@ public class SupplierInfDialog extends JDialog implements ActionListener {
 					JOptionPane.showMessageDialog(this, "添加失败", "提示",
 							JOptionPane.ERROR_MESSAGE);
 				}
-			}/*else{
-				//更新
-				SupplierInf supplierInf= new SupplierInf();
-				supplierInf.setName(name);
-				supplierInf.setAddress(address);
-				supplierInf.setContact(contact);
-				supplierInf.setId(this.supplierInf.getId());
-
-				int result = supplierInfService.updateSupplierInf(supplierInf);
-				if(result==1){
-					JOptionPane.showMessageDialog(this, "更新成功", "提示",
-							JOptionPane.INFORMATION_MESSAGE);
-				}
-			}*/
+			} /* else {
+                // 如果是更新操作
+                // 创建一个SupplierInf对象并设置新的值
+                SupplierInf supplierInf = new SupplierInf();
+                supplierInf.setName(name);
+                supplierInf.setAddress(address);
+                supplierInf.setContact(contact);
+                supplierInf.setId(this.supplierInf.getId());
+
+                // 调用更新方法更新数据库中的数据
+                int result = supplierInfService.updateSupplierInf(supplierInf);
+
+                // 根据更新结果显示提示信息
+                if (result == 1) {
+                    JOptionPane.showMessageDialog(this, "更新成功", "提示",
+                            JOptionPane.INFORMATION_MESSAGE);
+                }
+            } */
 
 		} else if (source == cancelBtn) {
-
+			// 如果点击了取消按钮，关闭当前对话框
 			this.dispose();
 		}
 	}

Supermarket/src/com/lingnan/supermarket/table/InOrderTM.java

@@ -15,93 +15,133 @@ import com.lingnan.supermarket.dao.UserService;
 import com.lingnan.supermarket.dao.impl.*;
 import com.lingnan.supermarket.dialog.InDialog;
 
-
 public class InOrderTM extends AbstractTableModel{
 
-	private String [] columnName = {"订单号","总价","时间","负责人","状态"};
+	// 定义列名
+	private String [] columnName = {"订单号", "总价", "时间", "负责人", "状态"};
 
+	// 创建 productionImpl 实例，供后续数据库操作使用
 	private productionImpl prodDao = new productionImpl();
 
-	private  Vector<InOrder> InOrders;
-	private inOrderServiceImpl inOrderImpl= new inOrderServiceImpl();
-	private InOrder inOrder ;
+	// 存储所有的入库订单数据
+	private Vector<InOrder> InOrders;
+
+	// 创建 inOrderServiceImpl 实例，用于与数据库交互，获取订单数据
+	private inOrderServiceImpl inOrderImpl = new inOrderServiceImpl();
 
-	String iNumber ;/*订单号*/
+	// 创建一个 InOrder 对象，用于存储单个订单的数据
+	private InOrder inOrder;
 
+	// 存储订单号
+	String iNumber;
 
+	/**
+	 * 获取所有入库订单记录，并将其存储到 InOrders 中
+	 * 该方法会调用数据库中的接口，获取所有的入库订单
+	 */
 	public void allInOrderRecord() {
-		//将添加的商品加入到静态变量Vector数组中
+		// 从数据库中获取所有的入库订单，存入静态变量 InOrders
 		/*prod = InDialog.getProduction();*/
 		InOrders = inOrderImpl.findAllInOrder();
 	}
 
-	//查找分类结果
+	/**
+	 * 根据分类查找订单记录
+	 *
+	 * @param catalog 分类ID，0表示查找所有订单，其他值表示查找特定状态的订单
+	 */
 	public void resultOfFind(int catalog) {
-		if(catalog==0)
+		// 如果分类为0，则查找所有入库订单
+		if(catalog == 0) {
 			InOrders = inOrderImpl.findAllInOrder();
-		else
+		}
+		// 否则查找指定状态的订单
+		else {
 			InOrders = inOrderImpl.FindStatus(catalog);
+		}
 	}
 
-	//根据订单查找
+	/**
+	 * 根据订单号查找特定的订单
+	 *
+	 * @param Number 订单号
+	 */
 	public void resultOfNumber(String Number) {
-		InOrders=new Vector<InOrder>();
+		// 创建一个新的 Vector 对象，用于存储查询到的订单
+		InOrders = new Vector<InOrder>();
+
+		// 根据订单号查找订单，并将结果加入 InOrders 中
 		inOrder = inOrderImpl.findByIdinOrder(Number);
 		InOrders.add(inOrder);
 	}
 
 	@Override
 	public int getRowCount() {
+		// 返回当前订单记录的数量
 		return InOrders.size();
 	}
 
-	/*	public Float getAllPrice() {
-            return BufferImpl.InBufferAllPrice();
-        }
-    */
 	@Override
 	public int getColumnCount() {
+		// 返回列数
 		return columnName.length;
 	}
 
 	@Override
 	public Object getValueAt(int rowIndex, int columnIndex) {
+		// 获取当前行的订单对象
 		inOrder = InOrders.get(rowIndex);
-/*		System.out.println( "id="+users.get(rowIndex).getId());
-		System.out.println("rowIndex"+rowIndex);
-		System.out.println("columnIndex"+columnIndex);*/
-		iNumber=inOrder.getiNumber();
-		if(columnIndex==0) {
+
+		// 获取订单号
+		iNumber = inOrder.getiNumber();
+
+		// 根据列的索引返回相应的值
+		if(columnIndex == 0) {
+			// 返回订单号
 			return inOrder.getiNumber();
-		}else if(columnIndex==1) {
+		} else if(columnIndex == 1) {
+			// 返回订单的总价
 			return inOrder.getAllInPrice();
-		}else if(columnIndex==2) {
+		} else if(columnIndex == 2) {
+			// 返回订单的日期
 			return inOrder.getInDate();
-		}else if(columnIndex==3) {
-			return  inOrder.getPrincipal();
-		}else if(columnIndex==4) {
+		} else if(columnIndex == 3) {
+			// 返回订单的负责人
+			return inOrder.getPrincipal();
+		} else if(columnIndex == 4) {
+			// 返回订单的状态
 			String status = null;
-			if(inOrder.getStatus()==1)
-				status= "已入库";
-			else if(inOrder.getStatus()==2)
-				status= "待入库";
-			else if(inOrder.getStatus()==3)
-				status= "已取消";
+			// 根据订单状态返回对应的文本
+			if(inOrder.getStatus() == 1) {
+				// 已入库
+				status = "已入库";
+			} else if(inOrder.getStatus() == 2) {
+				// 待入库
+				status = "待入库";
+			} else if(inOrder.getStatus() == 3) {
+				// 已取消
+				status = "已取消";
+			}
 			return status;
-		}else {
+		} else {
+			// 如果列索引无效，返回 null
 			return null;
 		}
 	}
 
-	public String getINumber() {  /*返回要修改或删除的记录*/
+	/**
+	 * 返回当前要修改或删除的订单号
+	 *
+	 * @return 当前订单号
+	 */
+	public String getINumber() {
+		// 返回要操作的订单号
 		return iNumber;
 	}
 
-
 	@Override
 	public String getColumnName(int column) {
+		// 返回对应列的列名
 		return columnName[column];
 	}
-
-
 }

Supermarket/src/com/lingnan/supermarket/table/InRecordTM.java

@@ -16,76 +16,99 @@ import com.lingnan.supermarket.dao.UserService;
 import com.lingnan.supermarket.dao.impl.*;
 import com.lingnan.supermarket.dialog.InDialog;
 
+public class InRecordTM extends AbstractTableModel {
 
-public class InRecordTM extends AbstractTableModel{
-
-	private String [] columnName = {"订单号","id","数量","金额"};
+	// 定义列名
+	private String[] columnName = {"订单号", "id", "数量", "金额"};
 
+	// 创建 productionImpl 实例，供后续数据库操作使用
 	private productionImpl prodDao = new productionImpl();
 
-	private  Vector<InRecord> InRecords;
+	// 存储所有入库记录的数据
+	private Vector<InRecord> InRecords;
 
+	// 创建 inRecordServiceImpl 实例，用于与数据库交互，获取入库记录数据
 	private inRecordServiceImpl inRecordImpl = new inRecordServiceImpl();
-	private InRecord inRecord= new InRecord();
-
 
-	private String iNumber ;/*订单号*/
+	// 创建一个 InRecord 对象，用于存储单个入库记录的数据
+	private InRecord inRecord = new InRecord();
 
+	// 存储订单号
+	String iNumber;
 
+	/**
+	 * 构造方法，传入订单号
+	 *
+	 * @param iNumber 订单号
+	 */
 	public InRecordTM(String iNumber) {
-		this.iNumber=iNumber;
+		// 初始化订单号
+		this.iNumber = iNumber;
 	}
 
+	/**
+	 * 根据订单号查找入库记录
+	 *
+	 * 该方法会调用数据库中的接口，查找指定订单号的所有入库记录
+	 */
 	public void findInRecordByINumber() {
-		//将添加的商品加入到静态变量Vector数组中
+		// 从数据库中获取指定订单号的入库记录，并存入 InRecords 中
 		/*prod = InDialog.getProduction();*/
 		InRecords = inRecordImpl.findByIdinRecord(iNumber);
 	}
 
-
 	@Override
 	public int getRowCount() {
+		// 返回当前入库记录的数量
 		return InRecords.size();
 	}
 
-	/*	public Float getAllPrice() {
-            return BufferImpl.InBufferAllPrice();
-        }
-    */
 	@Override
 	public int getColumnCount() {
+		// 返回列数
 		return columnName.length;
 	}
 
 	@Override
 	public Object getValueAt(int rowIndex, int columnIndex) {
+		// 获取当前行的入库记录对象
 		inRecord = InRecords.get(rowIndex);
-/*		System.out.println( "id="+users.get(rowIndex).getId());
-		System.out.println("rowIndex"+rowIndex);
-		System.out.println("columnIndex"+columnIndex);*/
-		iNumber=inRecord.getiNumber();
-		if(columnIndex==0) {
+
+		// 获取订单号
+		iNumber = inRecord.getiNumber();
+
+		// 根据列的索引返回相应的值
+		if (columnIndex == 0) {
+			// 返回订单号
 			return inRecord.getiNumber();
-		}else if(columnIndex==1) {
+		} else if (columnIndex == 1) {
+			// 返回记录的ID
 			return inRecord.getId();
-		}else if(columnIndex==2) {
+		} else if (columnIndex == 2) {
+			// 返回记录的数量
 			return inRecord.getSum();
-		}else if(columnIndex==3) {
-			return  inRecord.getInPrice();
-		}else {
+		} else if (columnIndex == 3) {
+			// 返回入库金额
+			return inRecord.getInPrice();
+		} else {
+			// 如果列索引无效，返回 null
 			return null;
 		}
 	}
 
-	public String getINumber() {  /*返回要修改或删除的记录*/
+	/**
+	 * 返回当前要修改或删除的订单号
+	 *
+	 * @return 当前订单号
+	 */
+	public String getINumber() {
+		// 返回要操作的订单号
 		return iNumber;
 	}
 
-
 	@Override
 	public String getColumnName(int column) {
+		// 返回对应列的列名
 		return columnName[column];
 	}
-
-
 }

Supermarket/src/com/lingnan/supermarket/table/OutTableModel.java

@@ -19,20 +19,24 @@ public class OutTableModel extends AbstractTableModel {
 	// 定义列名，表示表格的各个列的名称
 	private String [] columnName = {"id", "名称", "数量", "单价", "价格", "保质期", "类别", "供应商id"};
 
-	// 创建生产商品的实现类对象
+	// 创建生产商品的
+	// 实现类对象
 	private productionImpl prodDao = new productionImpl();
 
-	// 定义一个Vector用于存储Buffer对象
+	// 定义一个Vector用于
+	// 存储Buffer对象
 	private Vector<Buffer> Buffers;
 
-	// Buffer实现类对象，用于从数据库获取购物车中的商品数据
+	// Buffer实现类对象，用于从数据
+	// 库获取购物车中的商品数据
 	private BufferImpl BufferImpl  = new BufferImpl();
 
 	/**
 	 * 获取所有购物车商品数据
 	 */
 	public void allOutBuffer() {
-		// 从数据库获取购物车中的商品信息，并将其存入Buffers
+		// 从数据库获取购物车中的商品
+		// 信息，并将其存入Buffers
 		Buffers = BufferImpl.allOutBuffer();
 		// 打印调试信息，查看Buffer数据
 		System.out.println("Fetched " + Buffers.size() + " items from the buffer.");

Supermarket/src/com/lingnan/supermarket/table/SupplierTableModel.java

@@ -3,91 +3,120 @@ package com.lingnan.supermarket.table;
 import java.util.List;
 import java.util.Vector;
 
-
-
 import javax.swing.table.AbstractTableModel;
 
 import com.lingnan.supermarket.dto.SupplierInf;
 import com.lingnan.supermarket.dao.SupplierInfService;
 import com.lingnan.supermarket.dao.impl.*;
 
+public class SupplierTableModel extends AbstractTableModel {
 
-public class SupplierTableModel extends AbstractTableModel{
-
-	private String [] columnName = {"id","名称","地址","电话","邮箱"};
+	// 定义列名
+	private String[] columnName = {"id", "名称", "地址", "电话", "邮箱"};
 
-	//private SupplierInfImpl supplierDao = new SupplierInfImpl();
+	// 声明供应商信息服务接口实现类
 	private SupplierInfService supplierInfService = new SupplierInfImpl();
 
+	// 存储单个供应商的对象
 	private SupplierInf supplierInf = new SupplierInf();
 
+	// 存储所有供应商信息的 Vector 集合
 	private Vector<SupplierInf> suppliers;
 
-	private int id=0;
+	// 存储供应商的ID，用于其他操作
+	private int id = 0;
 
+	/**
+	 * 查找并加载所有供应商数据
+	 *
+	 * 该方法从数据库中获取所有供应商的信息，并将数据存储在 suppliers 中。
+	 */
 	public void all() {
-		//查找全部数据
+		// 调用数据库接口获取所有供应商信息
 		suppliers = supplierInfService.findAllSupplierInf();
 	}
 
+	/**
+	 * 根据供应商名称查找供应商信息
+	 *
+	 * @param supplierInf 供应商对象，其中包含要查询的供应商名称
+	 *
+	 * 该方法从数据库中查询指定名称的供应商，并将结果存入 suppliers 中。
+	 */
 	public void Byname(SupplierInf supplierInf) {
+		// 调用数据库接口根据供应商名称查找供应商信息
 		suppliers = supplierInfService.findByNameSupplierInf(supplierInf);
-
 	}
 
-
 	@Override
 	public int getRowCount() {
+		// 返回当前供应商信息的行数，即供应商的数量
 		return suppliers.size();
 	}
 
 	@Override
 	public int getColumnCount() {
+		// 返回列数，即供应商信息的字段数
 		return columnName.length;
 	}
 
 	@Override
 	public Object getValueAt(int rowIndex, int columnIndex) {
+		// 获取当前行的供应商对象
 		SupplierInf prod = suppliers.get(rowIndex);
-		//id = supplierInf.getId();
-/*		System.out.println( "id="+users.get(rowIndex).getId());
-		System.out.println("rowIndex"+rowIndex);
-		System.out.println("columnIndex"+columnIndex);*/
-		if(columnIndex==0) {
+
+		// 根据列索引返回对应的供应商数据
+		if (columnIndex == 0) {
+			// 返回供应商的ID
 			return prod.getId();
-		}else if(columnIndex==1) {
+		} else if (columnIndex == 1) {
+			// 返回供应商的名称
 			return prod.getName();
-		}else if(columnIndex==2) {
+		} else if (columnIndex == 2) {
+			// 返回供应商的地址
 			return prod.getAddress();
-		}else if(columnIndex==3) {
+		} else if (columnIndex == 3) {
+			// 返回供应商的联系电话
 			return prod.getContact();
-		}else if(columnIndex==4){
+		} else if (columnIndex == 4) {
+			// 返回供应商的邮箱
 			return prod.getEmail();
-		}
-		else {
+		} else {
+			// 如果列索引无效，返回 null
 			return null;
 		}
 	}
 
 	@Override
 	public String getColumnName(int column) {
+		// 返回指定列的列名
 		return columnName[column];
 	}
 
-/*
+	/**
+	 * 返回当前供应商的ID
+	 *
+	 * @return 当前供应商的ID
+	 *
+	 * 该方法用于获取供应商的ID，主要用于修改或删除操作
+	 */
 	public int getId() {
+		// 返回供应商ID
 		return id;
 	}
-    public int getValueAt(int rowIndex){
-    	SupplierInf supplierInf = suppliers.get(rowIndex);
-    	id=suppliers.get(rowIndex).getId();
-    	//System.out.println("rowIndex"+rowIndex);
-		//System.out.println("columnIndex"+columnIndex);
-    	return supplierInf.getId();
-    }
 
- */
+    /*
+    // 注释掉的方法：获取指定行的供应商ID
+    public int getValueAt(int rowIndex) {
+        // 获取指定行的供应商对象
+        SupplierInf supplierInf = suppliers.get(rowIndex);
 
+        // 获取并返回该供应商的ID
+        id = suppliers.get(rowIndex).getId();
 
+        // 返回供应商ID
+        return supplierInf.getId();
+    }
+    */
 
 }

Supermarket/src/com/lingnan/supermarket/view/MainView.java

@@ -65,6 +65,8 @@ public class MainView extends BaseView implements ActionListener, MouseListener,
 	JButton saveBtn, unSaveBtn, cancleBtn; // 退出时的按钮
 
 	Timer timer; // 定时器，用于更新时间
+	//定时器 ，
+	//用于更新时间
 
 	private User user; // 从登录界面传过来的用户信息
 	private BufferImpl bufferImpl; // 缓存实现类

Supermarket/src/com/lingnan/supermarket/view/ProdCatalogView.java

@@ -29,166 +29,153 @@ import com.lingnan.supermarket.table.StorageTableModel;
 import com.lingnan.supermarket.table.UserTableModel;
 import com.lingnan.supermarket.utils.FontUtil;
 
-public class ProdCatalogView extends JPanel  {
-
-	// 上面
-	private JPanel toolBarPanel;
-
-	private JPanel searchPanel;
-	private JLabel logLabel, locationLabel;
-	private JTextField nameSearchTF;
-	private JButton searchBtn;
-
-	private JPanel opePanel;
-	private JButton addBtn, updateBtn, deleteBtn;
-
-	private String catalog = "0";
-	private JComboBox<String> combo;
-	private String log[]=null;
-	private ArrayList<String>alog=null;
-	private ProdCatalogTM prodCatalogTM;
-	private ProdCatalog pc;
-	private prodCatalogImpl pci;
-
-	// 中间
-	private JScrollPane tableScrollPane;
-	private JTable prodCatalogTable;
-
-	// 下面
-	private JPanel bottomPanel;
-	private JLabel countInfoLabel;
-
-	private JFrame jFrame;
-
+// 商品目录界面类，继承 JPanel
+public class ProdCatalogView extends JPanel {
+
+	// ==== 顶部组件 ====
+	private JPanel toolBarPanel; // 工具栏面板
+
+	private JPanel searchPanel; // 搜索面板
+	private JLabel logLabel;    // 分类标签
+	private JLabel locationLabel; // 位置标签
+	private JTextField nameSearchTF; // 搜索文本框
+	private JButton searchBtn; // 搜索按钮
+
+	private JPanel opePanel; // 操作面板
+	private JButton addBtn;  // 添加按钮
+	private JButton updateBtn; // 更新按钮
+	private JButton deleteBtn; // 删除按钮
+
+	// 分类相关
+	private String catalog = "0"; // 当前目录ID，默认值为 0
+	private JComboBox<String> combo; // 分类选择下拉框
+	private String[] log = null; // 分类名称数组
+	private ArrayList<String> alog = null; // 分类名称列表
+	private ProdCatalogTM prodCatalogTM; // 商品目录表模型
+	private ProdCatalog pc; // 商品目录对象
+	private prodCatalogImpl pci; // 商品目录操作实现类
+
+	// ==== 中间表格组件 ====
+	private JScrollPane tableScrollPane; // 表格滚动面板
+	private JTable prodCatalogTable;     // 商品目录表
+
+	// ==== 底部组件 ====
+	private JPanel bottomPanel; // 底部面板
+	private JLabel countInfoLabel; // 记录数信息标签
+
+	// 窗口
+	private JFrame jFrame; // 主窗口
+
+	// 构造函数
 	public ProdCatalogView(JFrame jFrame) {
+		// 设置布局管理器
 		this.setLayout(new BorderLayout());
+
+		// 初始化界面
 		initView();
+
+		// 赋值 JFrame
 		this.jFrame = jFrame;
 	}
 
-
+	// 初始化界面组件的方法
 	private void initView() {
 
-		toolBarPanel = new JPanel(new BorderLayout());
-
-		searchPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
-		locationLabel = new JLabel("商品目录");
-		locationLabel.setFont(new FontUtil().userFont);
-		locationLabel.setForeground(new Color(18, 150, 219));
-		logLabel = new JLabel("分类");
-		nameSearchTF = new JTextField(10);
+		// ==== 工具栏面板 ====
+		toolBarPanel = new JPanel(new BorderLayout()); // 初始化工具栏面板
 
-		searchBtn = new JButton("搜索", new ImageIcon("static\\icon\\search.png"));
+		// 初始化搜索面板
+		searchPanel = new JPanel(new FlowLayout(FlowLayout.LEFT)); // 搜索面板左对齐
+		locationLabel = new JLabel("商品目录"); // 初始化位置标签
+		locationLabel.setFont(new FontUtil().userFont); // 设置自定义字体
+		locationLabel.setForeground(new Color(18, 150, 219)); // 设置字体颜色
 
-//		opePanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
-//		addBtn = new JButton(new ImageIcon("static\\icon\\add.png"));
-//		updateBtn = new JButton(new ImageIcon("static\\icon\\update.png"));
-//		deleteBtn = new JButton(new ImageIcon("static\\icon\\delete.png"));
+		logLabel = new JLabel("分类"); // 初始化分类标签
+		nameSearchTF = new JTextField(10); // 初始化文本框，长度 10
 
-//		addBtn.addActionListener(this);
-//		updateBtn.addActionListener(this);
-//		deleteBtn.addActionListener(this);
+		searchBtn = new JButton("搜索", new ImageIcon("static\\icon\\search.png")); // 创建搜索按钮
 
-//		opePanel.add(addBtn);
-//		opePanel.add(updateBtn);
-//		opePanel.add(deleteBtn);
-
-		pci=new prodCatalogImpl();
-		this.alog=pci.findNameProdCatalog();
-		this.log=new String[alog.size()];
-		for(int i=0;i<alog.size();i++)
-			log[i]=alog.get(i);
-
-		for(int i=0;i<log.length;i++)
-		{
-			System.out.println(log[i]);
+		// 商品目录实现类
+		pci = new prodCatalogImpl();
+		// 查询分类名称列表
+		this.alog = pci.findNameProdCatalog();
+		this.log = new String[alog.size()]; // 初始化数组
+		for (int i = 0; i < alog.size(); i++) {
+			log[i] = alog.get(i); // 填充数组
 		}
 
+		// 调试输出：打印分类
+		for (int i = 0; i < log.length; i++) {
+			System.out.println("分类名称：" + log[i]);
+		}
 
-
-
-
+		// 初始化下拉框
 		combo = new JComboBox<String>(log);
+		// 添加事件监听器
 		combo.addItemListener(new MyItemListener());
 
+		// 将组件添加到搜索面板
 		searchPanel.add(locationLabel);
 		searchPanel.add(logLabel);
 		searchPanel.add(combo);
-		/*
-		 * searchPanel.add(nameSearchTF); searchPanel.add(searchBtn);
-		 */
 
+		// 将搜索面板添加到工具栏
 		toolBarPanel.add(searchPanel, "West");
-//		toolBarPanel.add(opePanel, "East");
 
-		// 中间表格
-		prodCatalogTM = new ProdCatalogTM();
-		prodCatalogTM.all();
-		prodCatalogTable = new JTable(prodCatalogTM);
-		prodCatalogTable.setFont(FontUtil.tableFont);
-		prodCatalogTable.setRowHeight(50);
-		tableScrollPane = new JScrollPane(prodCatalogTable);
+		// ==== 中间表格 ====
+		prodCatalogTM = new ProdCatalogTM(); // 初始化表格模型
+		prodCatalogTM.all(); // 查询所有数据
+		prodCatalogTable = new JTable(prodCatalogTM); // 创建表格
+		prodCatalogTable.setFont(FontUtil.tableFont); // 设置字体
+		prodCatalogTable.setRowHeight(50); // 设置行高
+		tableScrollPane = new JScrollPane(prodCatalogTable); // 将表格包装为滚动面板
 
-		// 下面
-		bottomPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
-		countInfoLabel = new JLabel("总共" + prodCatalogTable.getRowCount() + "条");
-		bottomPanel.add(countInfoLabel);
+		// ==== 底部面板 ====
+		bottomPanel = new JPanel(new FlowLayout(FlowLayout.LEFT)); // 左对齐
+		countInfoLabel = new JLabel("总共" + prodCatalogTable.getRowCount() + "条记录"); // 显示总记录数
+		bottomPanel.add(countInfoLabel); // 添加记录数标签
 
+		// 将各个组件添加到主面板
 		this.add(toolBarPanel, "North");
-		this.add(tableScrollPane, "Center");/* 将表格放到中间 */
+		this.add(tableScrollPane, "Center");
 		this.add(bottomPanel, "South");
 
+		// 设置可见
 		setVisible(true);
 	}
 
-//	@Override
-//	public void actionPerformed(ActionEvent e) {
-//		Object source = e.getSource();
-//		if (addBtn == source) {
-//			UserDialog userDialog = new UserDialog(jFrame);
-//			userDialog.setVisible(true);
-//		} else if (updateBtn == source) {
-//
-//		} else if (deleteBtn == source) {
-//
-//		}
-//	}
-
+	// 下拉框监听器类
 	public class MyItemListener implements ItemListener {
 
 		@Override
 		public void itemStateChanged(ItemEvent e) {
-			JComboBox cb = (JComboBox) e.getSource();
-			String catalog1 = (String) cb.getSelectedItem();
-			pci =new prodCatalogImpl();
-			for(int i=0;i<log.length;i++){
-				if(catalog1.equals(log[i]))
-
-
-					catalog=pci.findProdCatalogByname(catalog1);
-				System.out.println(catalog);
+			JComboBox cb = (JComboBox) e.getSource(); // 获取事件源
+			String catalog1 = (String) cb.getSelectedItem(); // 获取选中的分类名称
+			pci = new prodCatalogImpl(); // 重新实例化商品目录实现类
+			for (int i = 0; i < log.length; i++) {
+				if (catalog1.equals(log[i])) {
+					catalog = pci.findProdCatalogByname(catalog1); // 根据名称查找分类ID
+				}
+				System.out.println("当前目录：" + catalog); // 打印当前分类ID
 			}
-			refreshFindId2();
+			refreshFindId2(); // 刷新界面
 		}
-
 	}
 
-	// 刷新当前界面
+	// 刷新界面
 	public void refreshFindId2() {
-		Production p = new Production();
-
-		p.setId2(catalog);
-		prodCatalogTM = new ProdCatalogTM();
-		prodCatalogTM.ById2(p);
-		prodCatalogTable.setModel(prodCatalogTM);
-		// 同时更新下面的记录数
-		refreshCount();
+		Production p = new Production(); // 创建生产对象
+		p.setId2(catalog); // 设置分类ID
+		prodCatalogTM = new ProdCatalogTM(); // 初始化表格模型
+		prodCatalogTM.ById2(p); // 根据分类加载数据
+		prodCatalogTable.setModel(prodCatalogTM); // 更新表格模型
+		refreshCount(); // 更新记录数
 	}
 
+	// 更新记录数
 	public void refreshCount() {
-		bottomPanel.removeAll();
-		countInfoLabel = new JLabel("总共" + prodCatalogTM.getRowCount() + "条");
-		bottomPanel.add(countInfoLabel);
+		bottomPanel.removeAll(); // 清空底部面板
+		countInfoLabel = new JLabel("总共" + prodCatalogTM.getRowCount() + "条记录"); // 更新标签
+		bottomPanel.add(countInfoLabel); // 添加标签
 	}
-
-}
+}