.idea/misc.xml

@@ -3,5 +3,5 @@
   <component name="JavaScriptSettings">
     <option name="languageLevel" value="ES6" />
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_11" project-jdk-name="11" project-jdk-type="JavaSDK" />
+  <component name="ProjectRootManager" version="2" project-jdk-name="21" project-jdk-type="JavaSDK" />
 </project>

Supermarket/.classpath

@@ -6,6 +6,6 @@
 	<classpathentry kind="src" path="config"/>
 	<classpathentry kind="lib" path="Supermarket/lib/activation.jar"/>
 	<classpathentry kind="lib" path="Supermarket/lib/mail.jar"/>
-	<classpathentry kind="lib" path="Supermarket/lib/mysql-connector-java-8.0.20.jar"/>
+	<classpathentry kind="lib" path="Supermarket/lib/mysql-connector-java-5.1.32.jar"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

Supermarket/.idea/dataSources.local.xml

@@ -2,7 +2,7 @@
 <project version="4">
   <component name="dataSourceStorageLocal" created-in="IU-231.8109.175">
     <data-source name="@localhost" uuid="5b23e521-053a-47c0-ae28-a98b513bc6ec">
-      <database-info product="MySQL" version="8.4.0" jdbc-version="4.2" driver-name="MySQL Connector/J" driver-version="mysql-connector-j-8.2.0 (Revision: 06a1f724497fd81c6a659131fda822c9e5085b6c)" dbms="MYSQL" exact-version="8.4.0" exact-driver-version="8.2">
+      <database-info product="MySQL" version="5.7.44-log" jdbc-version="4.2" driver-name="MySQL Connector/J" driver-version="mysql-connector-j-8.2.0 (Revision: 06a1f724497fd81c6a659131fda822c9e5085b6c)" dbms="MYSQL" exact-version="5.7.44" exact-driver-version="8.2">
         <extra-name-characters>#@</extra-name-characters>
         <identifier-quote-string>`</identifier-quote-string>
       </database-info>

Supermarket/.idea/libraries/mysql_connector_java.xml

@@ -1,11 +0,0 @@
-<component name="libraryTable">
-  <library name="mysql.connector.java" type="repository">
-    <properties maven-id="mysql:mysql-connector-java:8.0.20" />
-    <CLASSES>
-      <root url="jar://$PROJECT_DIR$/lib/mysql-connector-java-8.0.20.jar!/" />
-      <root url="jar://$PROJECT_DIR$/lib/protobuf-java-3.6.1.jar!/" />
-    </CLASSES>
-    <JAVADOC />
-    <SOURCES />
-  </library>
-</component>

Supermarket/.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
-  </component>
-</project>

Supermarket/Supermarket.iml

@@ -1,9 +1,9 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <module type="JAVA_MODULE" version="4">
   <component name="EclipseModuleManager">
-    <libelement value="file://$MODULE_DIR$/../../../大二下学期实训超市管理系统/Supermarket/lib/activation.jar" />
-    <libelement value="file://$MODULE_DIR$/../../../大二下学期实训超市管理系统/Supermarket/lib/mail.jar" />
-    <libelement value="file://$MODULE_DIR$/../../../大二下学期实训超市管理系统/Supermarket/lib/mysql-connector-java-5.1.32.jar" />
+    <libelement value="file://D:/大二下学期实训超市管理系统/Supermarket/lib/activation.jar" />
+    <libelement value="file://D:/大二下学期实训超市管理系统/Supermarket/lib/mail.jar" />
+    <libelement value="file://D:/大二下学期实训超市管理系统/Supermarket/lib/mysql-connector-java-5.1.32.jar" />
     <src_description expected_position="1">
       <src_folder value="file://$MODULE_DIR$/src" expected_position="0" />
       <src_folder value="file://$MODULE_DIR$" expected_position="1" />
@@ -47,6 +47,5 @@
         <SOURCES />
       </library>
     </orderEntry>
-    <orderEntry type="library" name="mysql.connector.java" level="project" />
   </component>
 </module>

Supermarket/bin/.classpath

@@ -6,6 +6,6 @@
 	<classpathentry kind="src" path="config"/>
 	<classpathentry kind="lib" path="Supermarket/lib/activation.jar"/>
 	<classpathentry kind="lib" path="Supermarket/lib/mail.jar"/>
-	<classpathentry kind="lib" path="Supermarket/lib/mysql-connector-java-8.0.20.jar"/>
+	<classpathentry kind="lib" path="Supermarket/lib/mysql-connector-java-5.1.32.jar"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

Supermarket/bin/.idea/dataSources.local.xml

@@ -2,7 +2,7 @@
 <project version="4">
   <component name="dataSourceStorageLocal" created-in="IU-231.8109.175">
     <data-source name="@localhost" uuid="5b23e521-053a-47c0-ae28-a98b513bc6ec">
-      <database-info product="MySQL" version="8.4.0" jdbc-version="4.2" driver-name="MySQL Connector/J" driver-version="mysql-connector-j-8.2.0 (Revision: 06a1f724497fd81c6a659131fda822c9e5085b6c)" dbms="MYSQL" exact-version="8.4.0" exact-driver-version="8.2">
+      <database-info product="MySQL" version="5.7.44-log" jdbc-version="4.2" driver-name="MySQL Connector/J" driver-version="mysql-connector-j-8.2.0 (Revision: 06a1f724497fd81c6a659131fda822c9e5085b6c)" dbms="MYSQL" exact-version="5.7.44" exact-driver-version="8.2">
         <extra-name-characters>#@</extra-name-characters>
         <identifier-quote-string>`</identifier-quote-string>
       </database-info>

Supermarket/bin/.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
-  </component>
-</project>

Supermarket/bin/Supermarket.iml

@@ -1,9 +1,9 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <module type="JAVA_MODULE" version="4">
   <component name="EclipseModuleManager">
-    <libelement value="file://$MODULE_DIR$/../../../大二下学期实训超市管理系统/Supermarket/lib/activation.jar" />
-    <libelement value="file://$MODULE_DIR$/../../../大二下学期实训超市管理系统/Supermarket/lib/mail.jar" />
-    <libelement value="file://$MODULE_DIR$/../../../大二下学期实训超市管理系统/Supermarket/lib/mysql-connector-java-5.1.32.jar" />
+    <libelement value="file://D:/大二下学期实训超市管理系统/Supermarket/lib/activation.jar" />
+    <libelement value="file://D:/大二下学期实训超市管理系统/Supermarket/lib/mail.jar" />
+    <libelement value="file://D:/大二下学期实训超市管理系统/Supermarket/lib/mysql-connector-java-5.1.32.jar" />
     <src_description expected_position="1">
       <src_folder value="file://$MODULE_DIR$/src" expected_position="0" />
       <src_folder value="file://$MODULE_DIR$" expected_position="1" />
@@ -47,6 +47,5 @@
         <SOURCES />
       </library>
     </orderEntry>
-    <orderEntry type="library" name="mysql.connector.java" level="project" />
   </component>
 </module>

Supermarket/bin/config/jdbc.properties

@@ -1,4 +1,4 @@
-driver=com.mysql.cj.jdbc.Driver
-url=jdbc:mysql://localhost:3306/supermarket?serverTimezone=UTC
+driver=com.mysql.jdbc.Driver
+url=jdbc:mysql://localhost:3306/supermarket
 user=root
 password=123456

Supermarket/bin/jdbc.properties

@@ -1,4 +1,4 @@
-driver=com.mysql.cj.jdbc.Driver
-url=jdbc:mysql://localhost:3306/supermarket?serverTimezone=UTC
+driver=com.mysql.jdbc.Driver
+url=jdbc:mysql://localhost:3306/supermarket
 user=root
 password=123456

Supermarket/config/jdbc.properties

@@ -1,4 +1,4 @@
-driver=com.mysql.cj.jdbc.Driver
-url=jdbc:mysql://localhost:3306/supermarket?serverTimezone=UTC
+driver=com.mysql.jdbc.Driver
+url=jdbc:mysql://localhost:3306/supermarket
 user=root
 password=123456

Supermarket/src/com/lingnan/supermarket/componet/BGPanel.java

@@ -1,45 +1,36 @@
 package com.lingnan.supermarket.componet;
+
 import java.awt.Graphics;
 import java.awt.Image;
 import java.awt.Toolkit;
+
 import javax.swing.JPanel;
 
 public class BGPanel extends JPanel{
-	private Image image;
 
+
+	private Image image;
 	public BGPanel(Image image) {
-		// 定义构造方法
 		this.image = image;
-		// 将传入的参数image赋值给类的成员变量image
-
+		
 		int width = Toolkit.getDefaultToolkit().getScreenSize().width;
-		// 通过默认工具包（Toolkit）获取屏幕的宽度
 		int height = Toolkit.getDefaultToolkit().getScreenSize().height;
-		// 通过默认工具包（Toolkit）获取屏幕的高度
 		this.setSize(width, height);
-		// 设置该面板的大小为整个屏幕的大小
 	}
-
-	public BGPanel(Image image, int width, int height) {
-		// 定义另一个构造方法，接收一个Image类型的参数image以及表示宽度和高度的两个int类型参数，用于更灵活地创建BGPanel对象并指定其大小
+	
+	public BGPanel(Image image,int width,int height) {
 		this.image = image;
-		// 将传入的参数image赋值给类的成员变量image
-
+		
+		
 		this.setSize(width, height);
-		// 设置该面板（BGPanel）的大小为传入的指定宽度width和指定高度height
 	}
-
-
+	
+	
 	@Override
 	protected void paintComponent(Graphics g) {
-		// 重写JPanel类中的paintComponent方法，用于绘制面板上的图像
 		super.paintComponent(g);
-		// 调用父类（JPanel）的paintComponent方法，以确保完成一些默认的绘制操作，比如背景清除等
-
-		g.drawImage(image, 0, 0, getWidth(), getHeight(), this);
-		// image：要绘制的图像对象，就是之前保存的成员变量image
-		// 0, 0：表示在面板上绘制图像的起始坐标（x坐标和y坐标），这里从面板的左上角（0, 0）位置开始绘制
-		// getWidth(), getHeight()：获取当前面板的宽度和高度，用于指定绘制图像时按照面板的实际大小进行拉伸或缩放，确保图像填满整个面板
-		// this：表示图像观察者，用于接收图像绘制过程中的相关通知等
+		g.drawImage(image,0,0,getWidth(),getHeight(),this);
+		
 	}
-}
+
+}

Supermarket/src/com/lingnan/supermarket/dao/impl/inOrderServiceImpl.java

@@ -52,10 +52,9 @@ public class inOrderServiceImpl implements inOrderService{
 
 		try {
 			// 准备SQL语句，根据订单号查找特定的订单
-			preparedStatement = conn.prepareStatement("select * from inOrder where iNumber = ?");    //根据订单号查询订单
+			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"));

Supermarket/src/com/lingnan/supermarket/dao/impl/outOrderServiceImpl.java

@@ -13,29 +13,21 @@ import com.lingnan.supermarket.dto.InOrder;
 import com.lingnan.supermarket.dto.OutOrder;
 import com.lingnan.supermarket.utils.JDBCUtil;
 
-// 实现outOrderService接口--用于处理与出库订单相关的数据访问操作
-public class outOrderServiceImpl implements 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字段降序排序
+		ResultSet resultSet=null;
+		
 		String SQL = "select * from OutOrder  order by oDate desc";
-
+		
 		try {
-			// 根据SQL语句创建预编译的Statement对象
 			preparedStatement = conn.prepareStatement(SQL);
-			// 执行查询操作
 			resultSet = preparedStatement.executeQuery();
-			// 遍历结果集，将每条记录封装成OutOrder对象，并添加到outOrders集合中
-			while (resultSet.next()) {
+			while(resultSet.next()) {
 				OutOrder outOrder = new OutOrder();
 				outOrder.setoNumber(resultSet.getString("oNumber"));
 				outOrder.setAllOutPrice(resultSet.getFloat("allOutPrice"));
@@ -43,147 +35,117 @@ public class outOrderServiceImpl implements outOrderService {
 				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 = 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;
-			}
+				return null; // 没有找到该订单或订单不存在，返回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());
-
-		// 获取数据库连接
+		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 = conn.prepareStatement
+					("insert into outOrder values (?,?,?,?)");
 			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);
+			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 = 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);
+			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)");
+	
+	//获取今日进货金额
+		public Float TodayOutPrice(String date) {
+
+			InOrder inOrder = new InOrder();
+			Connection conn = JDBCUtil.getConn();
+			PreparedStatement preparedStatement = null;
+			ResultSet resultSet = null;
+			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();
+				if (resultSet.next()) {
+					allInPrice=resultSet.getFloat("sum(allOutPrice)");
+				} 
+			} catch (SQLException e) {
+				e.printStackTrace();
+			} finally {
+				JDBCUtil.close(resultSet, preparedStatement, conn);
 			}
-		} catch (SQLException e) {
-			e.printStackTrace();
-		} finally {
-			// 关闭结果集、预编译语句以及数据库连接，释放相关资源
-			JDBCUtil.close(resultSet, preparedStatement, conn);
+			return allInPrice;
 		}
-		return allInPrice;
-	}
-}
+}

Supermarket/src/com/lingnan/supermarket/dao/impl/outRecordServiceImpl.java

@@ -12,66 +12,49 @@ import com.lingnan.supermarket.dto.InRecord;
 import com.lingnan.supermarket.dto.OutRecord;
 import com.lingnan.supermarket.utils.JDBCUtil;
 
-// 实现了outRecordService接口--用于处理出库记录相关的数据操作逻辑
-public class outRecordServiceImpl implements 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表中获取所有记录
+		ResultSet resultSet=null;
+		
 		String SQL = "select * from outRecord";
-
+		
 		try {
-			// 根据SQL语句创建预编译的Statement对象
 			preparedStatement = conn.prepareStatement(SQL);
-			// 执行查询操作
 			resultSet = preparedStatement.executeQuery();
-			// 遍历结果集，将每条记录封装成OutRecord对象，并添加到outRecords集合中
-			while (resultSet.next()) {
+			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;
-		// 获取数据库连接
+		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 = 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"));
@@ -79,83 +62,68 @@ public class outRecordServiceImpl implements outRecordService {
 				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 = 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);
+			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 = 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);
+			JDBCUtil.close(null,preparedStatement, conn);
 		}
 		return flag;
 	}
 
-}
+	
+
+}

Supermarket/src/com/lingnan/supermarket/dao/impl/prodCatalogImpl.java

@@ -12,241 +12,214 @@ import com.lingnan.supermarket.dao.prodCatalogService;
 import com.lingnan.supermarket.dto.ProdCatalog;
 import com.lingnan.supermarket.utils.JDBCUtil;
 
-// 实现prodCatalogService接口--用于处理商品目录相关的数据持久化操作
-public class prodCatalogImpl implements prodCatalogService {
+public class prodCatalogImpl implements prodCatalogService{
 
-	// 将商品目录表和商品表联合查询，获取商品目录及相关商品信息
+	/*将商品目录表和商品表联合查询*/
 	@Override
 	public Vector<ProdCatalog> findProdCatalogAndProd() {
-		// 通过JDBCUtil工具类来获取已经配置好的连接对象
-		Connection conn = JDBCUtil.getConn();
-		// 创建一个Vector容器，存放查询到的ProdCatalog对象
+		Connection conn=JDBCUtil.getConn();
 		Vector<ProdCatalog> v = new Vector<ProdCatalog>();
 		ProdCatalog prodCatalog;
 		PreparedStatement pstmt = null;
-		ResultSet resultSet = null;
+		ResultSet resultSet=null;
 		try {
-			// 通过预编译语句准备调用存储过程allProdCatalog
 			pstmt = conn.prepareStatement("call allProdCatalog()");
-			// 执行查询操作
 			resultSet = pstmt.executeQuery();
-			// 遍历结果集，将每一条记录封装成ProdCatalog对象，并添加到Vector容器中
-			while (resultSet.next()) {
+			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异常，打印异常栈信息
+			// TODO Auto-generated catch block
 			e.printStackTrace();
-		} finally {
-			// 通过JDBCUtil工具类提供的方法进行关闭操作
+		}finally{
 			JDBCUtil.close(resultSet, pstmt, conn);
 		}
-
+		
+		
 		return v;
-
+		
+	
 	}
-
-	// 根据给定的id1查找商品目录名称
+	
+	
 	@Override
-	public String findProdCatalog(String id1) {
-		// 获取数据库连接
-		Connection conn = JDBCUtil.getConn();
-
+	public String findProdCatalog(String id1 ) {
+		Connection conn=JDBCUtil.getConn();
+	
 		PreparedStatement pstmt = null;
-		ResultSet resultSet = null;
-		String catalog = 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);
+			pstmt.setString(1,id1);
+			
 
-			// 执行查询操作
 			resultSet = pstmt.executeQuery();
-			// 如果结果集中有下一条记录，则获取对应记录中的name1字段值作为商品目录名称
-			if (resultSet.next()) {
-				catalog = resultSet.getString("name1");
+			if(resultSet.next()){
+				catalog=resultSet.getString("name1");
 			}
 		} catch (SQLException e) {
+			// TODO Auto-generated catch block
 			e.printStackTrace();
-		} finally {
-			// 关闭相关资源
+		}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();
+		int flag=0;
+		String name1=null;
+		//01 食品 02 电器 03 生活用品 04 其他 
+		if(id1.equals("01"))
+			name1="食品";
+		else if(id1.equals("02"))
+				name1="电器";
+		else if(id1.equals("03"))
+				name1="生活用品";
+		else 
+			name1="其他";
+	
+		//连接jdbc
+		Connection conn=JDBCUtil.getConn();
 		PreparedStatement pstmt = null;
-		ResultSet resultSet = 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);
+			pstmt.setString(1,id1);
+			pstmt.setString(2,name1);
+			pstmt.setString(3,id2);
+			
 
-			// 执行插入操作，若插入成功，将flag置为1，表示添加成功
 			pstmt.executeUpdate();
-			flag = 1;
-
+			flag=1;
+		
 		} catch (SQLException e) {
 			e.printStackTrace();
-		} finally {
-			// 关闭相关资源
+		}finally{
 			JDBCUtil.close(resultSet, pstmt, conn);
 		}
-
+		
 		return flag;
 	}
+	
 
-	// 根据给定的id2删除商品目录表prodCatalog中的一条记录
 	@Override
 	public int deleteProdCatalog(String id2) {
-		int flag = 0;
-		// 获取数据库连接
-		Connection conn = JDBCUtil.getConn();
+		int flag=0;
+		//连接jdbc
+		Connection conn=JDBCUtil.getConn();
 		PreparedStatement pstmt = null;
-		ResultSet resultSet = 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.setString(1,id2);
 			pstmt.executeUpdate();
-			flag = 1;
-
+			flag=1;
+		
 		} catch (SQLException e) {
-			// 若出现SQL异常打印异常栈信息
+			// TODO Auto-generated catch block
 			e.printStackTrace();
-		} finally {
-			// 关闭相关资源
+		}finally{
 			JDBCUtil.close(resultSet, pstmt, conn);
 		}
-
+		
 		return flag;
 	}
 
-	// 根据商品类production的name查询并输出类别id，如果传入的name为"全部"，则直接返回默认的catalogid "0"
+
 	@Override
+	//根据商品类production的name查询并输出类别id
 	public String findProdCatalogByname(String name) {
-		Connection conn = JDBCUtil.getConn();
-
+		Connection conn=JDBCUtil.getConn();
+		
 		PreparedStatement pstmt = null;
-		ResultSet resultSet = null;
-
-		String catalogid = "0";
+		ResultSet resultSet=null;
+		
+		String catalogid="0";
 		try {
-			// 如果传入的商品名称为"全部"，则直接返回默认的catalogid
-			if (name.equals("全部")) {
+			if(name.equals("全部")){
 				return catalogid;
 			}
-			// 预编译SQL语句，用于根据给定的商品名称查询prodCatalog表中的记录，获取对应的类别id
 			pstmt = conn.prepareStatement("select * from prodCatalog where name =?");
-			// 设置SQL语句中的参数，将传入的name赋值给查询语句中的占位符
-			pstmt.setString(1, name);
+			pstmt.setString(1,name);
+			
 
-			// 执行查询操作，获取结果集
 			resultSet = pstmt.executeQuery();
-			// 如果结果集中有下一条记录，则获取对应记录中的id字段值作为类别id
-			if (resultSet.next()) {
-				catalogid = resultSet.getString("id");
+			if(resultSet.next()){
+				catalogid=resultSet.getString("id");
 			}
 		} catch (SQLException e) {
-			// 若出现SQL异常，打印异常栈信息
+			// TODO Auto-generated catch block
 			e.printStackTrace();
-		} finally {
-			// 关闭相关资源
+		}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()));
-    }
-    */
+/*	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();
+		Connection conn=JDBCUtil.getConn();
 		ArrayList<String> v = new ArrayList<String>();
-		// 先添加"全部"作为默认的第一个类别名称
 		v.add("全部");
 		ProdCatalog prodCatalog;
 		PreparedStatement pstmt = null;
-		ResultSet resultSet = null;
+		ResultSet resultSet=null;
 		try {
-			// 预编译查询所有记录的SQL语句，用于获取prodCatalog表中的所有商品类别名称
 			pstmt = conn.prepareStatement("select * from prodCatalog");
-			// 执行查询操作
 			resultSet = pstmt.executeQuery();
-			// 遍历结果集，将每条记录中的商品类别名称添加到ArrayList容器中
-			while (resultSet.next()) {
-
+			while(resultSet.next()){
+				
 				v.add(resultSet.getString("name"));
 			}
 		} catch (SQLException e) {
-			// 若出现SQL异常，打印异常栈信息
+			// TODO Auto-generated catch block
 			e.printStackTrace();
-		} finally {
-			// 关闭相关资源
+		}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]);
-        }
+	/*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/src/com/lingnan/supermarket/dao/impl/productionImpl.java

@@ -19,73 +19,73 @@ public class productionImpl implements productionService {
 	public Vector<Production> findAllproduction() {
 		Vector<Production> productions = new Vector<Production>();
 
-		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		Connection conn = JDBCUtil.getConn();
 
-		String SQL = "select * from production where delmark = 1"; // SQL查询语句，只查询未被删除的商品
+		String SQL = "select * from production where delmark = 1";
 
 		PreparedStatement preparedStatement = null;
 		ResultSet resultSet = null;
 		try {
-			preparedStatement = conn.prepareStatement(SQL); // 创建PreparedStatement对象
+			preparedStatement = conn.prepareStatement(SQL);
 
-			resultSet = preparedStatement.executeQuery(); // 执行查询，获取结果集
+			resultSet = preparedStatement.executeQuery();
 
-			while (resultSet.next()) { // 遍历结果集
+			while (resultSet.next()) {
 				Production production = new 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.setDelmark(resultSet.getInt("delmark")); // 设置删除标记
-				productions.add(production); // 将商品信息添加到Vector中
+				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); // 关闭数据库资源
+			JDBCUtil.close(resultSet, preparedStatement, conn);
 		}
-		return productions; // 返回所有商品信息
+		return productions;
 	}
 
 	/* 用于收银系统，通过商品id返回所有信息 */
 	public Production findByIdProduction(String id) {
 		Production production = new Production();
-		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		Connection conn = JDBCUtil.getConn();
 		PreparedStatement preparedStatement = null;
 		ResultSet resultSet = null;
 		try {
 			preparedStatement = conn
-					.prepareStatement("select * from production where id=? and delmark = 1"); // 查询指定ID且未被删除的商品
-			preparedStatement.setString(1, id); // 设置查询参数
-			resultSet = preparedStatement.executeQuery(); // 执行查询
-
-			if (resultSet.next()) { // 如果找到商品
-				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.setDelmark(resultSet.getInt("delmark")); // 设置删除标记
+					.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; // 如果未找到商品，返回null
+				return null;
 			}
 
 		} catch (SQLException e) {
 			e.printStackTrace();
 		} finally {
-			JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭数据库资源
+			JDBCUtil.close(resultSet, preparedStatement, conn);
 		}
-		return production; // 返回商品信息
+		return production;
 	}
 
 	@Override
@@ -94,35 +94,35 @@ public class productionImpl implements productionService {
 		 * 由一个商品名查找并输出全部商品信息
 		 */
 		Vector<Production> productions = new Vector<Production>();
-		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		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(); // 执行查询
+			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()) { // 遍历结果集
+			while (resultSet.next()) {
 				Production production = new 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.setDelmark(resultSet.getInt("delmark")); // 设置删除标记
-				productions.add(production); // 将商品信息添加到Vector中
+				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); // 关闭数据库资源
+			JDBCUtil.close(resultSet, preparedStatement, conn);
 		}
-		return productions; // 返回所有匹配的商品信息
+		return productions;
 	}
 
 	@Override
@@ -131,34 +131,34 @@ public class productionImpl implements productionService {
 	 */
 	public Production findByNameProduction(String name) {
 		Production production = new Production();
-		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		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")); // 设置商品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.setDelmark(resultSet.getInt("delmark")); // 设置删除标记
+					.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; // 如果未找到商品，返回null
+				return null;
 			}
 
 		} catch (SQLException e) {
 			e.printStackTrace();
 		} finally {
-			JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭数据库资源
+			JDBCUtil.close(resultSet, preparedStatement, conn);
 		}
-		return production; // 返回商品信息
+		return production;
 	}
 
 	@Override
@@ -167,39 +167,39 @@ public class productionImpl implements productionService {
 	 */
 	public int addProduction(Production p) {
 		int flag = 0;
-		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		Connection conn = JDBCUtil.getConn();
 		PreparedStatement preparedStatement = null;
 		PreparedStatement preparedStatement1 = null;
-		ResultSet resultSet1 = 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; // 如果商品已存在，返回2
+			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()); // 设置商品ID
-			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()); // 设置供应商ID
-			preparedStatement.setString(8, p.getId2()); // 设置商品类别ID
-			preparedStatement.setString(9, p.getName2()); // 设置商品类别名称
-			preparedStatement.setFloat(10, 0); // 设置未知字段
-			preparedStatement.setInt(11, 1); // 设置删除标记为1（未删除）
-			preparedStatement.executeUpdate(); // 执行插入
-			flag = 1; // 插入成功，返回1
+			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); // 关闭数据库资源
+			JDBCUtil.close(null, preparedStatement, conn);
 		}
 
-		return flag; // 返回操作结果
+		return flag;
 	}
 
 	@Override
@@ -208,21 +208,22 @@ public class productionImpl implements productionService {
 	 */
 	public int deleteProduction(String id) {
 		int flag = 0;
-		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		Connection conn = JDBCUtil.getConn();
 		PreparedStatement preparedStatement = null;
 
 		try {
 			preparedStatement = conn
-					.prepareStatement("delete from production where id = ?"); // 删除指定ID的商品
-			preparedStatement.setString(1, id); // 设置查询参数
-			preparedStatement.executeUpdate(); // 执行删除
-			flag = 1; // 删除成功，返回1
+					.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); // 关闭数据库资源
+			JDBCUtil.close(null, preparedStatement, conn);
 		}
-		return flag; // 返回操作结果
+		return flag;
+
 	}
 
 	@Override
@@ -231,99 +232,98 @@ public class productionImpl implements productionService {
 	 */
 	public int updateProduction(Production p) {
 		int flag = 0;
-		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		Connection conn = JDBCUtil.getConn();
 		PreparedStatement preparedStatement = null;
 
 		try {
 			preparedStatement = conn
-					.prepareStatement("update production set name=?,inPrice=?,OutPrice=?,life=?,sum=?,delmark=? where id = ? and supplyId=?"); // 更新商品信息
+					.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()); // 设置商品ID
-			preparedStatement.setInt(8, p.getSupplyId()); // 设置供应商ID
+			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; // 更新成功，返回1
+			preparedStatement.executeUpdate();
+			flag = 1;
 
 		} catch (SQLException e) {
 			e.printStackTrace();
 		} finally {
-			JDBCUtil.close(null, preparedStatement, conn); // 关闭数据库资源
+			JDBCUtil.close(null, preparedStatement, conn);
 		}
-		return flag; // 返回操作结果
+		return flag;
 	}
 
 	@Override
 	public Vector<Production> findProductionById2(String id) {
 		/**
-		 * 由一个商品类别id2查找并输出全部商品
+		 * 由一个商品类别id2查找并输出全部商品		
 		 */
 
 		Vector<Production> productions = new Vector<Production>();
-		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		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"); // 查询指定类别ID且未删除的商品
-				preparedStatement.setString(1, id); // 设置查询参数
-			}
-			resultSet = preparedStatement.executeQuery(); // 执行查询
-
-			while (resultSet.next()) { // 遍历结果集
+			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")); // 设置商品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.setDelmark(resultSet.getInt("delmark")); // 设置删除标记
-				productions.add(production); // 将商品信息添加到Vector中
+				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); // 关闭数据库资源
+			JDBCUtil.close(resultSet, preparedStatement, conn);
 		}
-		return productions; // 返回所有匹配的商品信息
+		return productions;
 	}
-
 	@Override
 	/**
 	 * 更新商品数量和价格
 	 */
-	public boolean updateProductionSum(String prodId, int sum) {
+	public boolean updateProductionSum(String prodId,int sum) {
 		boolean flag = false;
-		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		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;"); // 更新商品库存数量
+					.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); // 设置商品ID
-			preparedStatement.setString(3, prodId); // 设置商品ID
+			preparedStatement.setInt(1, sum);
+			preparedStatement.setString(2, prodId);
+			preparedStatement.setString(3, prodId);
 
-			if (preparedStatement.executeUpdate() == 1)
-				flag = true; // 更新成功，返回true
+			if(preparedStatement.executeUpdate()==1);
+				flag = true;
 
 		} catch (SQLException e) {
 			e.printStackTrace();
 		} finally {
-			JDBCUtil.close(null, preparedStatement, conn); // 关闭数据库资源
+			JDBCUtil.close(null, preparedStatement, conn);
 		}
-		return flag; // 返回操作结果
+		return flag;
 	}
-}
+
+}

Supermarket/src/com/lingnan/supermarket/dao/impl/storageRecordImpl.java

@@ -4,141 +4,121 @@ import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.Iterator;
 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();
+		Vector<StorageRecord> v=new Vector<StorageRecord>();
+		
+		
+		Connection conn=JDBCUtil.getConn();
 		PreparedStatement pstmt = null;
-		ResultSet resultSet = 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属性
+			String sql="select * from storageRecord  order by cDate desc";
+			pstmt=conn.prepareStatement(sql);
+			 
+			resultSet=pstmt.executeQuery();
+			 while(resultSet.next()) {
+				 StorageRecord sr=new StorageRecord();
 				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异常，打印异常栈信息
+		catch (SQLException e) {
 			e.printStackTrace();
-		} finally {
-			// 通过JDBCUtil工具类提供的方法进行关闭操作
+		}finally {
 			JDBCUtil.close(resultSet, pstmt, conn);
-
+			
 		}
 
-		return v;
+		
+		
+		return v;	
 	}
 
-	// 根据给定的库存编号（theNumber）查找对应的库存记录信息并返回
+
 	@Override
 	public StorageRecord findByIdStorageRecord(String theNumber) {
-		// 初始化一个StorageRecord对象为null，用于存放查询到的库存记录信息，如果没查到则返回null
-		StorageRecord sr = null;
-		// 获取数据库连接
-		Connection conn = JDBCUtil.getConn();
+		
+		StorageRecord sr=null;
+		Connection conn=JDBCUtil.getConn();	
 		PreparedStatement pstmt = null;
-		ResultSet resultSet = null;
+		ResultSet resultSet=null;
 
 		try {
-			// 创建一个新的StorageRecord对象，用于后续封装查询到的数据
-			sr = new StorageRecord();
-			// 预编译SQL语句，用于根据给定的库存编号（theNumber）查询storageRecord表中的记录
+			sr=new StorageRecord();
 			pstmt = conn.prepareStatement("select *from storageRecord where theNumber=?");
-			// 设置SQL语句中的参数，将传入的库存编号赋值给查询语句中的占位符
-			pstmt.setString(1, theNumber);
-			// 执行查询操作，获取结果集
+			pstmt.setString(1,theNumber);
 			resultSet = pstmt.executeQuery();
-			// 如果结果集中有下一条记录，则将对应记录中的各字段值封装到StorageRecord对象中
-			if (resultSet.next()) {
+			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异常，打印异常栈信息
+			// TODO Auto-generated catch block
 			e.printStackTrace();
-		} finally {
-			// 关闭相关资源
+		}finally{
 			JDBCUtil.close(resultSet, pstmt, conn);
 		}
-
+		
+		
 		return sr;
 	}
 
-	// 向库存记录表storageRecord中插入一条新的库存记录信息
-	public boolean insertStorageRecord(String iNumber, String time, String prodId, String execute, int sum) {
-		// 定义一个布尔变量用于标记插入操作是否成功，初始化为false
+	public boolean insertStorageRecord(String iNumber,String time,String prodId,String execute,int sum) {
 		boolean flag = false;
-		// 获取数据库连接
-		Connection conn = JDBCUtil.getConn();
+		Connection conn=JDBCUtil.getConn();	
 		PreparedStatement pstmt = null;
-		ResultSet resultSet = 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;
+			pstmt.setString(1,iNumber);
+			pstmt.setString(2,time);
+			pstmt.setString(3,prodId);
+			pstmt.setString(4,execute);
+			pstmt.setInt(5,sum);
+
+			if(pstmt.executeUpdate()==1){
+					flag = true;
 			}
-
+			
 		} catch (SQLException e) {
-			// 若出现SQL异常，打印异常栈信息
+			// TODO Auto-generated catch block
 			e.printStackTrace();
-		} finally {
-			// 关闭相关资源
+		}finally{
 			JDBCUtil.close(resultSet, pstmt, conn);
 		}
+		
+		
 		return flag;
 	}
-}
+}

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

@@ -1,18 +1,19 @@
 package com.lingnan.supermarket.dao;
 
-import java.util.Vector;
-
 import com.lingnan.supermarket.dto.InOrder;
 
+import java.util.Vector;
+
+// 进货订单服务接口，定义了与进货订单相关的操作
 public interface inOrderService {
 	//查询全部进货订单
 	Vector<InOrder> findAllInOrder ();
 	//查询某个进货订单
 	InOrder findByIdinOrder (String iNumber);
-	
+
 	//默认princial为a1. 创建时new一个时间插入,总价随机模拟
+	// 添加新的进货订单
 	int addInOrder(String iNumber,float allInPrice );
+	// 删除指定的进货订单
 	int deleteInOrder(String iNumber);
-
-
 }