end

# Conflicts:
#	Supermarket/bin/com/lingnan/supermarket/componet/BGPanel.class
#	Supermarket/bin/com/lingnan/supermarket/dao/impl/storageRecordImpl.class
#	Supermarket/bin/com/lingnan/supermarket/utils/CreateOrder.class
#	Supermarket/bin/com/lingnan/supermarket/utils/JDBCUtil.class
#	Supermarket/bin/com/lingnan/supermarket/utils/TimeAndOrder.class
#	Supermarket/bin/com/lingnan/supermarket/view/InView.class
#	Supermarket/bin/com/lingnan/supermarket/view/MainView.class
#	Supermarket/src/com/lingnan/supermarket/dao/impl/storageRecordImpl.java
#	Supermarket/src/com/lingnan/supermarket/utils/CreateOrder.java
#	Supermarket/src/com/lingnan/supermarket/utils/JDBCUtil.java
#	Supermarket/src/com/lingnan/supermarket/utils/TimeAndOrder.java
#	Supermarket/src/com/lingnan/supermarket/view/InView.java

.idea/misc.xml

@@ -3,5 +3,5 @@
   <component name="JavaScriptSettings">
     <option name="languageLevel" value="ES6" />
   </component>
-  <component name="ProjectRootManager" version="2" project-jdk-name="21" project-jdk-type="JavaSDK" />
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_11" project-jdk-name="11" 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-5.1.32.jar"/>
+	<classpathentry kind="lib" path="Supermarket/lib/mysql-connector-java-8.0.20.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="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">
+      <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">
         <extra-name-characters>#@</extra-name-characters>
         <identifier-quote-string>`</identifier-quote-string>
       </database-info>

Supermarket/.idea/libraries/mysql_connector_java.xml

@@ -0,0 +1,11 @@
+<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

@@ -0,0 +1,6 @@
+<?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://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" />
+    <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" />
     <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,5 +47,6 @@
         <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-5.1.32.jar"/>
+	<classpathentry kind="lib" path="Supermarket/lib/mysql-connector-java-8.0.20.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="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">
+      <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">
         <extra-name-characters>#@</extra-name-characters>
         <identifier-quote-string>`</identifier-quote-string>
       </database-info>

Supermarket/bin/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?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://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" />
+    <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" />
     <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,5 +47,6 @@
         <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.jdbc.Driver
-url=jdbc:mysql://localhost:3306/supermarket
+driver=com.mysql.cj.jdbc.Driver
+url=jdbc:mysql://localhost:3306/supermarket?serverTimezone=UTC
 user=root
 password=123456

Supermarket/bin/jdbc.properties

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

Supermarket/config/jdbc.properties

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

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

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

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

@@ -1,5 +1,9 @@
 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;
@@ -8,211 +12,255 @@ import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.Vector;
 
-import com.lingnan.supermarket.dao.SupplierInfService;
-import com.lingnan.supermarket.dto.ProdCatalog;
-import com.lingnan.supermarket.dto.SupplierInf;
-import com.lingnan.supermarket.dto.User;
-import com.lingnan.supermarket.utils.JDBCUtil;
 
+/**
+ * 供应商信息服务实现类
+ * @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";
-		
+		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);
-			resultSet = preparedStatement.executeQuery();
-			while(resultSet.next()) {
-				SupplierInf supplierInf = new SupplierInf();
-				supplierInf.setId(resultSet.getInt("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);
+			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) {
-			e.printStackTrace();
-		} finally {
-			JDBCUtil.close(resultSet, preparedStatement, conn);
+
+		} catch (SQLException e) { // 捕获SQL异常
+			e.printStackTrace(); // 打印异常堆栈信息
+		} finally { // 无论是否发生异常，都会执行的代码块
+			// 关闭数据库连接和相关资源
+			JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭结果集、预编译语句和数据库连接
 		}
 
-		return supplierInfs;
+		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;
+		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");
-				preparedStatement.setString(1, s);
+			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");			
-			resultSet = preparedStatement.executeQuery();
-			while (resultSet.next()) {
-				supplierInf = new SupplierInf();
-				supplierInf.setId(resultSet.getInt("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);
+				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()+" "); // 打印供应商信息
 			}
-			  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) {
-			e.printStackTrace();
-		} finally {
-			JDBCUtil.close(resultSet, preparedStatement, conn);
+		} catch (SQLException e) { // 捕获SQL异常
+			e.printStackTrace(); // 打印异常堆栈信息
+		} finally { // 无论是否发生异常，都会执行的代码块
+			JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭结果集、预编译语句和数据库连接
 		}
-		return v;
+		return v; // 返回存储供应商信息的向量
 	}
-
+// 添加供应商信息的方法
+	/**
+	 * 添加供应商信息
+	 *
+	 * @param supplierInf 供应商信息对象
+	 * @return 插入结果标志，1表示成功，0表示失败
+	 */
 	@Override
 	public int addSupplierInf(SupplierInf supplierInf) {
-		int flag = 0;
-		Connection conn = JDBCUtil.getConn();
-		PreparedStatement preparedStatement = null;
-		
+		int flag = 0; // 初始化标志为0
+		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		PreparedStatement preparedStatement = null; // 初始化预编译语句对象
+
 		try {
 			preparedStatement = conn.prepareStatement
-					("insert into supplierInf values (null,?,?,?,?,?)");
+					("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;
-		} catch (SQLException e) {
-			e.printStackTrace();
-		} finally {
-			JDBCUtil.close(null,preparedStatement, conn);
+			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;
-	}
 
+		return flag; // 返回插入结果标志
+	}
+	// 删除供应商信息的方法
+	/**
+	 * 删除指定ID的供应商信息
+	 *
+	 * @param id 要删除的供应商ID
+	 * @return 删除操作的结果标志，1表示成功，0表示失败
+	 */
 	@Override
 	public int deleteSupplierInf(int id) {
-		int flag = 0;
-		
-		Connection conn = JDBCUtil.getConn();
-		PreparedStatement preparedStatement = null;
-		
+		int flag = 0; // 初始化标志为0
+
+		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		PreparedStatement preparedStatement = null; // 初始化预编译语句对象
+
 		try {
 			preparedStatement = conn.prepareStatement
-					("delete from supplierInf where id = ?");
-			preparedStatement.setInt(1, id);
-			preparedStatement.executeUpdate();
-			flag = 1;
-		} catch (SQLException e) {
-			e.printStackTrace();
-		} finally {
-			JDBCUtil.close(null,preparedStatement, conn);
+					("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;
+		return flag; // 返回删除结果标志
 	}
 
+	// 更新供应商信息的方法
+	/**
+	 * 更新供应商信息
+	 *
+	 * @param supplierInf 供应商信息对象
+	 * @return 更新结果标志，1表示成功，0表示失败
+	 */
 	@Override
 	public int updateSupplierInf(SupplierInf supplierInf) {
-		int flag=0;
-		Connection conn = JDBCUtil.getConn();
-		PreparedStatement preparedStatement = null;
+		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 = ?");
-		    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());
-		    preparedStatement.executeUpdate();
-			flag = 1;
-	
-		} catch (SQLException e) {
-			e.printStackTrace();
-		} finally {
-			JDBCUtil.close(null, preparedStatement, conn);
+			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;
+		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("全部");
+		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");
-			resultSet = pstmt.executeQuery();
-			while(resultSet.next()){
-				
-				v.add(resultSet.getString("name"));
+			pstmt = conn.prepareStatement("select * from supplierInf"); // 准备SQL查询语句
+			resultSet = pstmt.executeQuery(); // 执行查询
+			while(resultSet.next()){ // 遍历结果集
+
+				v.add(resultSet.getString("name")); // 将供应商名称添加到列表中
 			}
-		} catch (SQLException e) {
+		} catch (SQLException e) { // 捕获SQL异常
 			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}finally{
-			JDBCUtil.close(resultSet, pstmt, conn);
+			e.printStackTrace(); // 打印异常堆栈信息
+		}finally{ // 无论是否发生异常，都会执行的代码块
+			JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接
 		}
-		
-		
-		return v;
+
+
+		return v; // 返回存储供应商名称的列表
 	}
 
+	// 根据供应商名称查找其ID的方法
+	/**
+	 * 根据给定的供应商名称查找对应的供应商ID。
+	 * 如果名称为“全部”，返回默认ID（0）。
+	 * 如果未找到对应的供应商，返回-1作为标志。
+	 *
+	 * @param name 供应商名称
+	 * @return 供应商ID或标志
+	 */
 	@Override
 	public int findIdSupplierByName(String name) {
-		int flag = -1;
-		Connection conn = JDBCUtil.getConn();
-		PreparedStatement preparedStatement = null;
-		ResultSet resultSet= null;
-		int id=0;
+		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;
+			if(name.equals("全部")) // 如果供应商名称为“全部”
+				return id; // 返回默认ID
 			preparedStatement = conn.prepareStatement
-					("select * from supplierInf where name=?");
-			preparedStatement.setString(1, name);
-			resultSet=preparedStatement.executeQuery();
-			if(resultSet.next()){
-				return resultSet.getInt("id");
+					("select * from supplierInf where name=?"); // 准备SQL查询语句
+			preparedStatement.setString(1, name); // 设置查询参数
+			resultSet=preparedStatement.executeQuery(); // 执行查询
+			if(resultSet.next()){ // 如果找到对应记录
+				return resultSet.getInt("id"); // 返回供应商ID
 			}
-			
-		} catch (SQLException e) {
-			e.printStackTrace();
-		} finally {
-			JDBCUtil.close(null,preparedStatement, conn);
+
+		} catch (SQLException e) { // 捕获SQL异常
+			e.printStackTrace(); // 打印异常堆栈信息
+		} finally { // 无论是否发生异常，都会执行的代码块
+			JDBCUtil.close(null,preparedStatement, conn); // 关闭预编译语句和数据库连接
 		}
-		
-		return flag;
+
+		return flag; // 返回查询结果标志
 	}
 
-	
 
-}
+
+}

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

@@ -1,68 +1,63 @@
 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.inOrderService;
 import com.lingnan.supermarket.dto.InOrder;
-import com.lingnan.supermarket.utils.DateUtil;
 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>();
-		Connection conn = JDBCUtil.getConn();
-		PreparedStatement preparedStatement = null;
-		ResultSet resultSet=null;
-		
+	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);
-			resultSet = preparedStatement.executeQuery();
-			while(resultSet.next()) {
-				InOrder inOrder = new InOrder();
+			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);
+				inOrders.add(inOrder); // 将InOrder对象添加到向量中
 			}
-			
+
 		} catch (SQLException e) {
-			e.printStackTrace();
+			e.printStackTrace(); // 捕获并打印异常堆栈信息
 		} finally {
-			JDBCUtil.close(resultSet, preparedStatement, conn);
+			JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭结果集、预编译语句和数据库连接
 		}
 
-		return inOrders;
-		
+		return inOrders; // 返回存储所有InOrder对象的向量
 	}
-	
-	
+
 	@Override
 	public InOrder findByIdinOrder(String iNumber) {
-
-		InOrder inOrder = new InOrder();
-		Connection conn = JDBCUtil.getConn();
-		PreparedStatement preparedStatement = null;
-		ResultSet resultSet = null;
+		InOrder inOrder = new InOrder(); // 创建InOrder对象
+		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		PreparedStatement preparedStatement = null; // 声明预编译语句对象
+		ResultSet resultSet = null; // 声明结果集对象
 
 		try {
-			preparedStatement = conn.prepareStatement("select * from inOrder where iNumber = ?");
-			preparedStatement.setString(1, iNumber);
-			resultSet = preparedStatement.executeQuery();
-			if (resultSet.next()) {
+			// 准备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"));
@@ -70,205 +65,204 @@ public class inOrderServiceImpl implements inOrderService{
 				inOrder.setStatus(resultSet.getInt("status"));
 			} else {
 				return null; // 没有找到该订单或订单不存在，返回null
-			} 
+			}
 
 		} catch (SQLException e) {
-			e.printStackTrace();
+			e.printStackTrace(); // 捕获并打印异常堆栈信息
 		} finally {
-			JDBCUtil.close(resultSet, preparedStatement, conn);
+			JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭结果集、预编译语句和数据库连接
 		}
-		return inOrder;
+		return inOrder; // 返回找到的InOrder对象
 	}
-	
-	
+
 	@Override
 	public int addInOrder(String iNumber, float allInPrice) {
-		int flag = 0;
-		Timestamp inDate = new Timestamp(System.currentTimeMillis()); 
-		//System.out.println(inDate);
-		Connection conn = JDBCUtil.getConn();
-		PreparedStatement preparedStatement = null;
-		
+		int flag = 0; // 状态标志，初始化为0
+		Timestamp inDate = new Timestamp(System.currentTimeMillis()); // 获取当前时间戳
+		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		PreparedStatement preparedStatement = null; // 声明预编译语句对象
+
 		try {
-			preparedStatement = conn.prepareStatement
-					("insert into inOrder values (?,?,?,?)");
-			preparedStatement.setString(1, iNumber);
-			preparedStatement.setFloat(2, allInPrice);
-			preparedStatement.setTimestamp(3, inDate);
-			preparedStatement.setString(4, "a1");
-			preparedStatement.executeUpdate();
-			flag = 1;
+			// 准备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;
-			e.printStackTrace();
+			flag = -1; // 插入失败时标记为-1
+			e.printStackTrace(); // 捕获并打印异常堆栈信息
 		} finally {
-			JDBCUtil.close(null,preparedStatement, conn);
+			JDBCUtil.close(null, preparedStatement, conn); // 关闭预编译语句和数据库连接
 		}
-		
-		return flag;
-	}
 
+		return flag; // 返回插入结果标志
+	}
 
 	@Override
 	public int deleteInOrder(String iNumber) {
-		int flag = 0;
-		
-		Connection conn = JDBCUtil.getConn();
-		PreparedStatement preparedStatement = null;
-		
+		int flag = 0; // 状态标志，初始化为0
+
+		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		PreparedStatement preparedStatement = null; // 声明预编译语句对象
+
 		try {
-			preparedStatement = conn.prepareStatement
-					("update inOrder set delmark=0 where iNumber = ?");
-			preparedStatement.setString(1, iNumber);
-			preparedStatement.executeUpdate();
-			flag = 1;
+			// 准备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;
-			e.printStackTrace();
+			flag = -1; // 删除失败时标记为-1
+			e.printStackTrace(); // 捕获并打印异常堆栈信息
 		} finally {
-			JDBCUtil.close(null,preparedStatement, conn);
+			JDBCUtil.close(null, preparedStatement, conn); // 关闭预编译语句和数据库连接
 		}
-		return flag;
+		return flag; // 返回删除结果标志
 	}
 
 	/*往订单表插入一条记录*/
-	public boolean InsertInOrder(String number,Float allPrice,String time,String username,int c){
-		boolean flag = false;
-		Connection conn = JDBCUtil.getConn();
-		PreparedStatement pstmt = null;
-		ResultSet resultSet = null;;
+	// 插入新的进货订单
+	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);
-			pstmt.setInt(6, 1);
-			
-			if(pstmt.execute())
-					flag = true;
-
-
-			
-		} catch (SQLException e) {
-			e.printStackTrace();
-		}finally {
+			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
 
-			JDBCUtil.close(resultSet, pstmt, conn);
+		} catch (SQLException e) {
+			e.printStackTrace(); // 捕获并打印异常堆栈信息
+		} finally {
+			JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接
 		}
-		return flag;
+		return flag; // 返回插入结果标志
 	}
 
-	/*更新状态*/
-	public boolean updateInOrderStatus(String iNumber,int status) {
-		boolean flag = false;		
-		Connection conn = JDBCUtil.getConn();
-		PreparedStatement preparedStatement = null;		
+	/* 更新状态 */
+	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);		
-			if(preparedStatement.executeUpdate()==1)
+			preparedStatement.setInt(1, status); // 设置状态
+			preparedStatement.setString(2, iNumber); // 设置订单号
+			// 如果更新操作影响了一行，则设置标志为true
+			if (preparedStatement.executeUpdate() == 1)
 				flag = true;
 		} catch (SQLException e) {
-			e.printStackTrace();
+			e.printStackTrace(); // 捕获并打印异常堆栈信息
 		} finally {
-			JDBCUtil.close(null,preparedStatement, conn);
+			JDBCUtil.close(null, preparedStatement, conn); // 关闭预编译语句和数据库连接
 		}
-		return flag;
+		return flag; // 返回更新结果标志
 	}
-	
-	//查找所有待入库订单*/待确认
-	public Vector<InOrder> findUnconfirmInOrder(){
-		Vector<InOrder> inOrders = new Vector<InOrder>();
-		Connection conn = JDBCUtil.getConn();
-		PreparedStatement preparedStatement = null;
-		ResultSet resultSet=null;
-		
+
+	// 查找所有待入库订单（待确认）
+	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);
-			resultSet = preparedStatement.executeQuery();
-			while(resultSet.next()) {
-				InOrder inOrder = new 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);
+			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();
+			e.printStackTrace(); // 捕获并打印异常堆栈信息
 		} finally {
-			JDBCUtil.close(resultSet, preparedStatement, conn);
+			JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭结果集、预编译语句和数据库连接
 		}
 
-		return inOrders;
-		
+		return inOrders; // 返回存储待确认订单的向量
 	}
-	
-	//获取今日进货金额
-	public Float TodayInPrice(String date) {
 
-		InOrder inOrder = new InOrder();
-		Connection conn = JDBCUtil.getConn();
-		PreparedStatement preparedStatement = null;
-		ResultSet resultSet = null;
-		Float allInPrice=(float) 0;
+	// 获取今日进货金额
+	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);
-			resultSet = preparedStatement.executeQuery();
-			if (resultSet.next()) {
-				allInPrice=resultSet.getFloat("sum(allInPrice)");
-			} 
+			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();
+			e.printStackTrace(); // 捕获并打印异常堆栈信息
 		} finally {
-			JDBCUtil.close(resultSet, preparedStatement, conn);
+			JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭结果集、预编译语句和数据库连接
 		}
-		return allInPrice;
+		return allInPrice; // 返回总进货金额
 	}
 
-	//查找指定状态订单
-	public Vector<InOrder> FindStatus(int status){
-		Vector<InOrder> inOrders = new Vector<InOrder>();
-		Connection conn = JDBCUtil.getConn();
-		PreparedStatement preparedStatement = null;
-		ResultSet resultSet=null;
-		
-	
-		
-		try {		
+	// 查找指定状态订单
+	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.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);
+			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();
+			e.printStackTrace(); // 捕获并打印异常堆栈信息
 		} finally {
-			JDBCUtil.close(resultSet, preparedStatement, conn);
+			JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭结果集、预编译语句和数据库连接
 		}
 
-		return inOrders;
-		
+		return inOrders; // 返回指定状态的订单向量
 	}
 
 }

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

@@ -1,152 +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.sql.Timestamp;
 import java.util.Vector;
-
-import com.lingnan.supermarket.dao.inRecordService;
-import com.lingnan.supermarket.dto.InOrder;
-import com.lingnan.supermarket.dto.InRecord;
-import com.lingnan.supermarket.dto.Production;
-import com.lingnan.supermarket.dto.User;
-import com.lingnan.supermarket.utils.JDBCUtil;
+/**
+ * 进货记录服务实现类
+ * @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";
-		
+		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);
-			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);
+			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) {
-			e.printStackTrace();
-		} finally {
-			JDBCUtil.close(resultSet, preparedStatement, conn);
+
+		} catch (SQLException e) { // 捕获SQL异常
+			e.printStackTrace(); // 打印异常堆栈信息
+		} finally { // 无论是否发生异常，都会执行的代码块
+			JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭结果集、预编译语句和数据库连接
 		}
 
-		return inRecords;
+		return inRecords; // 返回存储所有进货记录的向量
 	}
 
-	@Override
+
+	/**
+ * 根据进货单号查询进货记录
+ *
+ * @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;
+		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 = ?");
-			preparedStatement.setString(1, iNumber);
-			resultSet = preparedStatement.executeQuery();
-			while(resultSet.next()) {
-				inRecord = new InRecord();
-				inRecord.setiNumber(resultSet.getString("iNumber"));
-				inRecord.setId(resultSet.getString("id"));
-				inRecord.setSum(resultSet.getInt("sum"));
-				inRecord.setInPrice(resultSet.getFloat("Price"));
-				v.add(inRecord);
-			}  
-				
-		} catch (SQLException e) {
-			e.printStackTrace();
-		} finally {
-			JDBCUtil.close(resultSet, preparedStatement, conn);
+			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;
+		return v; // 返回存储进货记录的向量
 	}
 
+
 	@Override
-	public int addinRecord(InRecord ir) {
-		int flag = 0;
-		
-		String iNumber = ir.getiNumber();
-		int sum = ir.getSum();
-	    Float inPrice = ir.getInPrice();
-		
-		Connection conn = JDBCUtil.getConn();
-		PreparedStatement preparedStatement = null;
-		
+	// 该方法用于将进货记录添加到数据库中。
+// 参数 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 (?,?,?)");
-			preparedStatement.setString(1, iNumber);
-			preparedStatement.setInt(2, sum);
-			preparedStatement.setFloat(3, inPrice);
-			preparedStatement.executeUpdate();
-			flag = 1;
-		} catch (SQLException e) {
-			flag = -1;
-			e.printStackTrace();
-		} finally {
-			JDBCUtil.close(null,preparedStatement, conn);
+					("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;
+
+		return flag; // 返回插入结果标志
 	}
 
-	@Override
+
+	// 删除进货记录方法，根据进货单号进行删除操作
+@Override
 	public int deleteinRecord(String iNumber) {
-		int flag = 0;
-		
-		Connection conn = JDBCUtil.getConn();
-		PreparedStatement preparedStatement = null;
-		
+		int flag = 0; // 初始化标志为0
+
+		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		PreparedStatement preparedStatement = null; // 初始化预编译语句对象
+
 		try {
 			preparedStatement = conn.prepareStatement
-					("delete from inRecord where iNumber = ?");
-			preparedStatement.setString(1, iNumber);
-			preparedStatement.executeUpdate();
-			flag = 1;
-		} catch (SQLException e) {
-			flag = -1;
-			e.printStackTrace();
-		} finally {
-			JDBCUtil.close(null,preparedStatement, conn);
+					("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;
+		return flag; // 返回删除结果标志
 	}
 
-	public boolean insertInRecord(String iNumber,Production p) {
-		boolean flag = false;		
-		Connection conn = JDBCUtil.getConn();
-		PreparedStatement preparedStatement = null;
-		
+		/**
+		 * 将进货记录插入到数据库中
+		 *
+		 * @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(?,?,?,?)");
-			preparedStatement.setString(1, iNumber);
-			preparedStatement.setString(2, p.getId());
-			preparedStatement.setInt(3,p.getSum());
-			preparedStatement.setFloat(4, p.getPrice());
-			
-			if(preparedStatement.executeUpdate()==1)
-				flag = true;
-		} catch (SQLException e) {
-			e.printStackTrace();
-		} finally {
-			JDBCUtil.close(null,preparedStatement, conn);
+			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;
+		return flag; // 返回插入结果标志
 	}
-
-	
-
-}
+}

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

@@ -13,21 +13,29 @@ import com.lingnan.supermarket.dto.InOrder;
 import com.lingnan.supermarket.dto.OutOrder;
 import com.lingnan.supermarket.utils.JDBCUtil;
 
-public class outOrderServiceImpl implements outOrderService{
+// 实现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;
-		
+		ResultSet resultSet = null;
+
+		// 从OutOrder表中查询所有记录，并按oDate字段降序排序
 		String SQL = "select * from OutOrder  order by oDate desc";
-		
+
 		try {
+			// 根据SQL语句创建预编译的Statement对象
 			preparedStatement = conn.prepareStatement(SQL);
+			// 执行查询操作
 			resultSet = preparedStatement.executeQuery();
-			while(resultSet.next()) {
+			// 遍历结果集，将每条记录封装成OutOrder对象，并添加到outOrders集合中
+			while (resultSet.next()) {
 				OutOrder outOrder = new OutOrder();
 				outOrder.setoNumber(resultSet.getString("oNumber"));
 				outOrder.setAllOutPrice(resultSet.getFloat("allOutPrice"));
@@ -35,117 +43,147 @@ 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 {
-				return null; // 没有找到该订单或订单不存在，返回null
-			} 
+				// 如果结果集中没有记录，说明没有找到该订单或订单不存在，返回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;
-		Timestamp oDate = new Timestamp(System.currentTimeMillis()); 
-		
+		// 获取当前系统时间戳，用于作为出库订单的日期（oDate）字段值，表示订单创建时间
+		Timestamp oDate = new Timestamp(System.currentTimeMillis());
+
+		// 获取数据库连接
 		Connection conn = JDBCUtil.getConn();
 		PreparedStatement preparedStatement = null;
-		
+
 		try {
-			preparedStatement = conn.prepareStatement
-					("insert into outOrder values (?,?,?,?)");
+			// 创建预编译的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);
+			// 关闭预编译语句以及数据库连接，释放相关资源
+			JDBCUtil.close(null, preparedStatement, conn);
 		}
-		
+
 		return flag;
 	}
 
+	// 根据订单编号从数据库中删除对应的出库订单记录
 	@Override
 	public int deleteOutOrder(String oNumber) {
 		int flag = 0;
-		
+
+		// 获取数据库连接
 		Connection conn = JDBCUtil.getConn();
 		PreparedStatement preparedStatement = null;
-		
+
 		try {
-			preparedStatement = conn.prepareStatement
-					("delete from outOrder where oNumber = ?");
+			// 创建预编译的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);
+			// 关闭预编译语句以及数据库连接，释放相关资源
+			JDBCUtil.close(null, preparedStatement, conn);
 		}
 		return flag;
 	}
 
-	
-	//获取今日进货金额
-		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);
+	// 获取指定日期的今日出库金额总和（此处方法名可能有点混淆，从代码逻辑看是获取指定日期的出库金额总和）
+	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)");
 			}
-			return allInPrice;
+		} catch (SQLException e) {
+			e.printStackTrace();
+		} finally {
+			// 关闭结果集、预编译语句以及数据库连接，释放相关资源
+			JDBCUtil.close(resultSet, preparedStatement, conn);
 		}
-}
+		return allInPrice;
+	}
+}

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

@@ -12,49 +12,66 @@ import com.lingnan.supermarket.dto.InRecord;
 import com.lingnan.supermarket.dto.OutRecord;
 import com.lingnan.supermarket.utils.JDBCUtil;
 
-public class outRecordServiceImpl implements outRecordService{
+// 实现了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;
-		
+		ResultSet resultSet = null;
+
+		// 从outRecord表中获取所有记录
 		String SQL = "select * from outRecord";
-		
+
 		try {
+			// 根据SQL语句创建预编译的Statement对象
 			preparedStatement = conn.prepareStatement(SQL);
+			// 执行查询操作
 			resultSet = preparedStatement.executeQuery();
-			while(resultSet.next()) {
+			// 遍历结果集，将每条记录封装成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 ;
+		// 用于临时存储单个出库记录信息的对象
+		OutRecord outRecord;
+		// 获取数据库连接
 		Connection conn = JDBCUtil.getConn();
 		PreparedStatement preparedStatement = null;
 		ResultSet resultSet = null;
+		// 存储查询到的符合条件的所有出库记录信息的向量集合
 		Vector<OutRecord> v = new Vector<OutRecord>();
 
 		try {
-			preparedStatement = conn.prepareStatement("select * from outRecord where oNumber = ?");
+			//根据给定的订单编号查询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"));
@@ -62,68 +79,83 @@ 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 {
-			preparedStatement = conn.prepareStatement
-					("insert into outRecord values (?,?,?)");
+			// 创建预编译的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 {
-			JDBCUtil.close(null,preparedStatement, conn);
+			// 关闭预编译语句以及数据库连接，释放相关资源，此处结果集为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 {
-			preparedStatement = conn.prepareStatement
-					("delete from outRecord where oNumber = ?");
+			// 创建预编译的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 {
-			JDBCUtil.close(null,preparedStatement, conn);
+			// 关闭预编译语句以及数据库连接，释放相关资源，此处结果集为null
+			JDBCUtil.close(null, preparedStatement, conn);
 		}
 		return flag;
 	}
 
-	
-
-}
+}

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

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