p4vsywzlp
/
test
1
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

添加了进货模块注释

Browse Source
pull/1/head
cwfeng 10 months ago
parent e95c524ffd
commit e9cf9c9e44
9 changed files with 1011 additions and 867 deletions
Show Stats Download Patch File Download Diff File

852
Supermarket/src/com/lingnan/supermarket/dao/impl/BufferImpl.java
View File

File diff suppressed because it is too large Load Diff

320
Supermarket/src/com/lingnan/supermarket/dao/impl/SupplierInfImpl.java
Unescape View File

@ -1,5 +1,9 @@
package com.lingnan.supermarket.dao.impl; 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.Connection;
import java.sql.PreparedStatement; import java.sql.PreparedStatement;
import java.sql.ResultSet; import java.sql.ResultSet;
@ -8,209 +12,253 @@ import java.util.ArrayList;
import java.util.Iterator; import java.util.Iterator;
import java.util.Vector; 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{ public class SupplierInfImpl implements SupplierInfService{
// 查询所有供应商信息的方法
@Override @Override
// 该方法用于查找所有未被标记为删除的供应商信息，返回一个供应商信息的向量
// 此方法连接数据库，执行查询，并将结果封装为供应商信息对象的向量
public Vector<SupplierInf> findAllSupplierInf() { public Vector<SupplierInf> findAllSupplierInf() {
Vector<SupplierInf> supplierInfs = new Vector<SupplierInf>(); Vector<SupplierInf> supplierInfs = new Vector<SupplierInf>(); // 创建一个向量用于存储供应商信息
Connection conn = JDBCUtil.getConn(); Connection conn = JDBCUtil.getConn(); // 获取数据库连接
PreparedStatement preparedStatement = null; PreparedStatement preparedStatement = null; // 初始化预编译语句对象
ResultSet resultSet=null; ResultSet resultSet=null; // 初始化结果集对象
String SQL = "select * from supplierInf where delmark = 1"; String SQL = "select * from supplierInf where delmark = 1"; // SQL查询语句，选择未被标记为删除的供应商信息
try { try {
preparedStatement = conn.prepareStatement(SQL); preparedStatement = conn.prepareStatement(SQL); // 准备SQL语句
resultSet = preparedStatement.executeQuery(); resultSet = preparedStatement.executeQuery(); // 执行查询
while(resultSet.next()) { while(resultSet.next()) { // 遍历结果集
SupplierInf supplierInf = new SupplierInf(); SupplierInf supplierInf = new SupplierInf(); // 创建一个新的供应商信息对象
supplierInf.setId(resultSet.getInt("id")); supplierInf.setId(resultSet.getInt("id")); // 设置供应商ID
supplierInf.setName(resultSet.getString("name")); supplierInf.setName(resultSet.getString("name")); // 设置供应商名称
supplierInf.setContact(resultSet.getString("contact")); supplierInf.setContact(resultSet.getString("contact")); // 设置供应商联系人
supplierInf.setEmail(resultSet.getString("email")); supplierInf.setEmail(resultSet.getString("email")); // 设置供应商邮箱
supplierInf.setAddress(resultSet.getString("address")); supplierInf.setAddress(resultSet.getString("address")); // 设置供应商地址
supplierInf.setDelmark(resultSet.getInt("delmark")); supplierInf.setDelmark(resultSet.getInt("delmark")); // 设置删除标记
supplierInfs.add(supplierInf); supplierInfs.add(supplierInf); // 将供应商信息对象添加到向量中
} }
} catch (SQLException e) { } catch (SQLException e) { // 捕获SQL异常
e.printStackTrace(); e.printStackTrace(); // 打印异常堆栈信息
} finally { } finally { // 无论是否发生异常，都会执行的代码块
JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭数据库连接和相关资源
JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭结果集、预编译语句和数据库连接
} }
return supplierInfs; return supplierInfs; // 返回存储所有供应商信息的向量
} }
// 根据供应商名称查询供应商信息的方法
@Override @Override
// 定义一个查找供应商信息的方法，根据传入的供应商对象进行查询
/**
* 根据供应商名称查找供应商信息
* @param supplierInf 包含供应商名称的供应商信息对象
* @return 返回包含查询到的供应商信息的向量
*/
public Vector<SupplierInf> findByNameSupplierInf(SupplierInf supplierInf) { public Vector<SupplierInf> findByNameSupplierInf(SupplierInf supplierInf) {
//SupplierInf supplierInf = new SupplierInf(); //SupplierInf supplierInf = new SupplierInf();
Connection conn = JDBCUtil.getConn(); Connection conn = JDBCUtil.getConn(); // 获取数据库连接
Vector<SupplierInf> v = new Vector<>(); Vector<SupplierInf> v = new Vector<>(); // 创建一个向量用于存储供应商信息
System.out.println(supplierInf.getName()); System.out.println(supplierInf.getName()); // 打印供应商名称
PreparedStatement preparedStatement = null; PreparedStatement preparedStatement = null; // 初始化预编译语句对象
ResultSet resultSet = null; ResultSet resultSet = null; // 初始化结果集对象
try { try {
if(!supplierInf.getName().equals("")){ if(!supplierInf.getName().equals("")){ // 如果供应商名称不为空
String s='%'+supplierInf.getName()+'%'; String s='%'+supplierInf.getName()+'%'; // 构建模糊查询字符串
preparedStatement = conn.prepareStatement("select * from supplierInf where name like ? and delmark = 1"); preparedStatement = conn.prepareStatement("select * from supplierInf where name like ? and delmark = 1"); // 准备SQL查询语句
preparedStatement.setString(1, s); preparedStatement.setString(1, s); // 设置查询参数
}else }else
preparedStatement = conn.prepareStatement("select * from supplierInf where delmark = 1"); preparedStatement = conn.prepareStatement("select * from supplierInf where delmark = 1"); // 准备SQL查询语句，选择未被标记为删除的供应商信息
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) { resultSet = preparedStatement.executeQuery(); // 执行查询
supplierInf = new SupplierInf(); while (resultSet.next()) { // 遍历结果集
supplierInf.setId(resultSet.getInt("id")); supplierInf = new SupplierInf(); // 创建一个新的供应商信息对象
supplierInf.setName(resultSet.getString("name")); supplierInf.setId(resultSet.getInt("id")); // 设置供应商ID
supplierInf.setAddress(resultSet.getString("address")); supplierInf.setName(resultSet.getString("name")); // 设置供应商名称
supplierInf.setContact(resultSet.getString("contact")); supplierInf.setAddress(resultSet.getString("address")); // 设置供应商地址
supplierInf.setEmail(resultSet.getString("email")); supplierInf.setContact(resultSet.getString("contact")); // 设置供应商联系人
supplierInf.setDelmark(1); supplierInf.setEmail(resultSet.getString("email")); // 设置供应商邮箱
v.add(supplierInf); supplierInf.setDelmark(1); // 设置删除标记
v.add(supplierInf); // 将供应商信息对象添加到向量中
} }
Iterator<SupplierInf> it=v.iterator(); Iterator<SupplierInf> it=v.iterator(); // 获取向量的迭代器
while(it.hasNext()){ while(it.hasNext()){ // 遍历向量
supplierInf=it.next(); supplierInf=it.next(); // 获取下一个供应商信息对象
System.out.println(supplierInf.getId()+" "+supplierInf.getName()+" "+supplierInf.getAddress()+" "+supplierInf.getContact()+" "+supplierInf.getEmail()+" "+supplierInf.getDelmark()+" "); System.out.println(supplierInf.getId()+" "+supplierInf.getName()+" "+supplierInf.getAddress()+" "+supplierInf.getContact()+" "+supplierInf.getEmail()+" "+supplierInf.getDelmark()+" "); // 打印供应商信息
} }
} catch (SQLException e) { } catch (SQLException e) { // 捕获SQL异常
e.printStackTrace(); e.printStackTrace(); // 打印异常堆栈信息
} finally { } finally { // 无论是否发生异常，都会执行的代码块
JDBCUtil.close(resultSet, preparedStatement, conn); JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭结果集、预编译语句和数据库连接
} }
return v; return v; // 返回存储供应商信息的向量
} }
// 添加供应商信息的方法
/**
* 添加供应商信息
*
* @param supplierInf 供应商信息对象
* @return 插入结果标志，1表示成功，0表示失败
*/
@Override @Override
public int addSupplierInf(SupplierInf supplierInf) { public int addSupplierInf(SupplierInf supplierInf) {
int flag = 0; int flag = 0; // 初始化标志为0
Connection conn = JDBCUtil.getConn(); Connection conn = JDBCUtil.getConn(); // 获取数据库连接
PreparedStatement preparedStatement = null; PreparedStatement preparedStatement = null; // 初始化预编译语句对象
try { try {
preparedStatement = conn.prepareStatement preparedStatement = conn.prepareStatement
("insert into supplierInf values (null,?,?,?,?,?)"); ("insert into supplierInf values (null,?,?,?,?,?)"); // 准备SQL插入语句
//preparedStatement.setInt(1, supplierInf.getId()); //preparedStatement.setInt(1, supplierInf.getId());
preparedStatement.setString(1, supplierInf.getName()); preparedStatement.setString(1, supplierInf.getName()); // 设置供应商名称
preparedStatement.setString(2, supplierInf.getAddress()); preparedStatement.setString(2, supplierInf.getAddress()); // 设置供应商地址
preparedStatement.setString(3, supplierInf.getContact()); preparedStatement.setString(3, supplierInf.getContact()); // 设置供应商联系人
preparedStatement.setString(4, supplierInf.getEmail()); preparedStatement.setString(4, supplierInf.getEmail()); // 设置供应商邮箱
preparedStatement.setInt(5, 1); preparedStatement.setInt(5, 1); // 设置删除标记
preparedStatement.executeUpdate(); preparedStatement.executeUpdate(); // 执行插入操作
flag = 1; flag = 1; // 设置标志为1，表示插入成功
} catch (SQLException e) { } catch (SQLException e) { // 捕获SQL异常
e.printStackTrace(); e.printStackTrace(); // 打印异常堆栈信息
} finally { } finally { // 无论是否发生异常，都会执行的代码块
JDBCUtil.close(null,preparedStatement, conn); JDBCUtil.close(null,preparedStatement, conn); // 关闭预编译语句和数据库连接
} }
return flag; return flag; // 返回插入结果标志
} }
// 删除供应商信息的方法
/**
* 删除指定ID的供应商信息
*
* @param id 要删除的供应商ID
* @return 删除操作的结果标志，1表示成功，0表示失败
*/
@Override @Override
public int deleteSupplierInf(int id) { public int deleteSupplierInf(int id) {
int flag = 0; int flag = 0; // 初始化标志为0
Connection conn = JDBCUtil.getConn(); Connection conn = JDBCUtil.getConn(); // 获取数据库连接
PreparedStatement preparedStatement = null; PreparedStatement preparedStatement = null; // 初始化预编译语句对象
try { try {
preparedStatement = conn.prepareStatement preparedStatement = conn.prepareStatement
("delete from supplierInf where id = ?"); ("delete from supplierInf where id = ?"); // 准备SQL删除语句
preparedStatement.setInt(1, id); preparedStatement.setInt(1, id); // 设置供应商ID
preparedStatement.executeUpdate(); preparedStatement.executeUpdate(); // 执行删除操作
flag = 1; flag = 1; // 设置标志为1，表示删除成功
} catch (SQLException e) { } catch (SQLException e) { // 捕获SQL异常
e.printStackTrace(); e.printStackTrace(); // 打印异常堆栈信息
} finally { } finally { // 无论是否发生异常，都会执行的代码块
JDBCUtil.close(null,preparedStatement, conn); JDBCUtil.close(null,preparedStatement, conn); // 关闭预编译语句和数据库连接
} }
return flag; return flag; // 返回删除结果标志
} }
// 更新供应商信息的方法
/**
* 更新供应商信息
*
* @param supplierInf 供应商信息对象
* @return 更新结果标志，1表示成功，0表示失败
*/
@Override @Override
public int updateSupplierInf(SupplierInf supplierInf) { public int updateSupplierInf(SupplierInf supplierInf) {
int flag=0; int flag=0; // 初始化标志为0
Connection conn = JDBCUtil.getConn(); Connection conn = JDBCUtil.getConn(); // 获取数据库连接
PreparedStatement preparedStatement = null; PreparedStatement preparedStatement = null; // 初始化预编译语句对象
try { try {
preparedStatement = conn.prepareStatement("update supplierInf set name=?,address=?,contact=?,email=?,delmark=? where id = ?"); preparedStatement = conn.prepareStatement("update supplierInf set name=?,address=?,contact=?,email=?,delmark=? where id = ?"); // 准备SQL更新语句
preparedStatement.setString(1,supplierInf.getName()); preparedStatement.setString(1,supplierInf.getName()); // 设置供应商名称
preparedStatement.setString(2,supplierInf.getAddress()); preparedStatement.setString(2,supplierInf.getAddress()); // 设置供应商地址
preparedStatement.setString(3,supplierInf.getContact()); preparedStatement.setString(3,supplierInf.getContact()); // 设置供应商联系人
preparedStatement.setString(4, supplierInf.getEmail()); preparedStatement.setString(4, supplierInf.getEmail()); // 设置供应商邮箱
preparedStatement.setInt(5, supplierInf.getDelmark()); preparedStatement.setInt(5, supplierInf.getDelmark()); // 设置删除标记
preparedStatement.setInt(6,supplierInf.getId()); preparedStatement.setInt(6,supplierInf.getId()); // 设置供应商ID
preparedStatement.executeUpdate(); preparedStatement.executeUpdate(); // 执行更新操作
flag = 1; flag = 1; // 设置标志为1，表示更新成功
} catch (SQLException e) { } catch (SQLException e) { // 捕获SQL异常
e.printStackTrace(); e.printStackTrace(); // 打印异常堆栈信息
} finally { } finally { // 无论是否发生异常，都会执行的代码块
JDBCUtil.close(null, preparedStatement, conn); JDBCUtil.close(null, preparedStatement, conn); // 关闭预编译语句和数据库连接
} }
return flag; return flag; // 返回更新结果标志
} }
// 获取所有供应商名称的方法
// 该方法从数据库中查询所有供应商的名称，并将其存储在一个列表中返回
@Override @Override
public ArrayList<String> findNameSupplier() { public ArrayList<String> findNameSupplier() {
Connection conn=JDBCUtil.getConn(); Connection conn=JDBCUtil.getConn(); // 获取数据库连接
ArrayList<String> v = new ArrayList<String>(); ArrayList<String> v = new ArrayList<String>(); // 创建一个列表用于存储供应商名称
SupplierInf supplierInf; SupplierInf supplierInf; // 声明一个供应商信息对象
PreparedStatement pstmt = null; PreparedStatement pstmt = null; // 初始化预编译语句对象
ResultSet resultSet=null; ResultSet resultSet=null; // 初始化结果集对象
v.add("全部"); v.add("全部"); // 添加默认选项“全部”
try { try {
pstmt = conn.prepareStatement("select * from supplierInf"); pstmt = conn.prepareStatement("select * from supplierInf"); // 准备SQL查询语句
resultSet = pstmt.executeQuery(); resultSet = pstmt.executeQuery(); // 执行查询
while(resultSet.next()){ while(resultSet.next()){ // 遍历结果集
v.add(resultSet.getString("name")); v.add(resultSet.getString("name")); // 将供应商名称添加到列表中
} }
} catch (SQLException e) { } catch (SQLException e) { // 捕获SQL异常
// TODO Auto-generated catch block // TODO Auto-generated catch block
e.printStackTrace(); e.printStackTrace(); // 打印异常堆栈信息
}finally{ }finally{ // 无论是否发生异常，都会执行的代码块
JDBCUtil.close(resultSet, pstmt, conn); JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接
} }
return v; return v; // 返回存储供应商名称的列表
} }
// 根据供应商名称查找其ID的方法
/**
* 根据给定的供应商名称查找对应的供应商ID。
* 如果名称为“全部”，返回默认ID（0）。
* 如果未找到对应的供应商，返回-1作为标志。
*
* @param name 供应商名称
* @return 供应商ID或标志
*/
@Override @Override
public int findIdSupplierByName(String name) { public int findIdSupplierByName(String name) {
int flag = -1; int flag = -1; // 初始化标志为-1
Connection conn = JDBCUtil.getConn(); Connection conn = JDBCUtil.getConn(); // 获取数据库连接
PreparedStatement preparedStatement = null; PreparedStatement preparedStatement = null; // 初始化预编译语句对象
ResultSet resultSet= null; ResultSet resultSet= null; // 初始化结果集对象
int id=0; int id=0; // 初始化供应商ID为0
try { try {
if(name.equals("全部")) if(name.equals("全部")) // 如果供应商名称为“全部”
return id; return id; // 返回默认ID
preparedStatement = conn.prepareStatement preparedStatement = conn.prepareStatement
("select * from supplierInf where name=?"); ("select * from supplierInf where name=?"); // 准备SQL查询语句
preparedStatement.setString(1, name); preparedStatement.setString(1, name); // 设置查询参数
resultSet=preparedStatement.executeQuery(); resultSet=preparedStatement.executeQuery(); // 执行查询
if(resultSet.next()){ if(resultSet.next()){ // 如果找到对应记录
return resultSet.getInt("id"); return resultSet.getInt("id"); // 返回供应商ID
} }
} catch (SQLException e) { } catch (SQLException e) { // 捕获SQL异常
e.printStackTrace(); e.printStackTrace(); // 打印异常堆栈信息
} finally { } finally { // 无论是否发生异常，都会执行的代码块
JDBCUtil.close(null,preparedStatement, conn); JDBCUtil.close(null,preparedStatement, conn); // 关闭预编译语句和数据库连接
} }
return flag; return flag; // 返回查询结果标志
} }

224
Supermarket/src/com/lingnan/supermarket/dao/impl/inRecordServiceImpl.java
Unescape View File

@ -1,152 +1,174 @@
package com.lingnan.supermarket.dao.impl; 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.Connection;
import java.sql.PreparedStatement; import java.sql.PreparedStatement;
import java.sql.ResultSet; import java.sql.ResultSet;
import java.sql.SQLException; import java.sql.SQLException;
import java.sql.Timestamp;
import java.util.Vector; import java.util.Vector;
/**
import com.lingnan.supermarket.dao.inRecordService; * 进货记录服务实现类
import com.lingnan.supermarket.dto.InOrder; * @cwf2210461197 2024/12/2
import com.lingnan.supermarket.dto.InRecord; * @version 1.0
import com.lingnan.supermarket.dto.Production; */
import com.lingnan.supermarket.dto.User;
import com.lingnan.supermarket.utils.JDBCUtil;
public class inRecordServiceImpl implements inRecordService{ public class inRecordServiceImpl implements inRecordService{
/**
* 查询所有进货记录的方法
* @return 包含所有进货记录的向量
*/
@Override @Override
public Vector<InRecord> findAllinRecord() { public Vector<InRecord> findAllinRecord() {
Vector<InRecord> inRecords = new Vector<InRecord>(); Vector<InRecord> inRecords = new Vector<InRecord>(); // 创建一个向量用于存储进货记录
Connection conn = JDBCUtil.getConn(); Connection conn = JDBCUtil.getConn(); // 获取数据库连接
PreparedStatement preparedStatement = null; PreparedStatement preparedStatement = null; // 初始化预编译语句对象
ResultSet resultSet=null; ResultSet resultSet=null; // 初始化结果集对象
String SQL = "select * from inRecord"; String SQL = "select * from inRecord"; // SQL查询语句，选择所有进货记录
try { try {
preparedStatement = conn.prepareStatement(SQL); preparedStatement = conn.prepareStatement(SQL); // 准备SQL语句
resultSet = preparedStatement.executeQuery(); resultSet = preparedStatement.executeQuery(); // 执行查询
while(resultSet.next()) { while(resultSet.next()) { // 遍历结果集
InRecord inRecord = new InRecord(); InRecord inRecord = new InRecord(); // 创建一个新的进货记录对象
inRecord.setiNumber(resultSet.getString("iNumber")); inRecord.setiNumber(resultSet.getString("iNumber")); // 设置进货单号
inRecord.setSum(resultSet.getInt("sum")); inRecord.setSum(resultSet.getInt("sum")); // 设置进货数量
inRecord.setInPrice(resultSet.getFloat("inPrice")); inRecord.setInPrice(resultSet.getFloat("inPrice")); // 设置进货价格
inRecords.add(inRecord); inRecords.add(inRecord); // 将进货记录对象添加到向量中
} }
} catch (SQLException e) { } catch (SQLException e) { // 捕获SQL异常
e.printStackTrace(); e.printStackTrace(); // 打印异常堆栈信息
} finally { } finally { // 无论是否发生异常，都会执行的代码块
JDBCUtil.close(resultSet, preparedStatement, conn); JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭结果集、预编译语句和数据库连接
} }
return inRecords; return inRecords; // 返回存储所有进货记录的向量
} }
@Override
/**
* 根据进货单号查询进货记录
*
* @param iNumber 进货单号
* @return 包含符合条件的进货记录的向量
*/
@Override
public Vector<InRecord> findByIdinRecord(String iNumber) { public Vector<InRecord> findByIdinRecord(String iNumber) {
InRecord inRecord; InRecord inRecord; // 声明一个进货记录对象
Vector<InRecord> v = new Vector<InRecord>(); Vector<InRecord> v = new Vector<InRecord>(); // 创建一个向量用于存储进货记录
Connection conn = JDBCUtil.getConn(); Connection conn = JDBCUtil.getConn(); // 获取数据库连接
PreparedStatement preparedStatement = null; PreparedStatement preparedStatement = null; // 初始化预编译语句对象
ResultSet resultSet = null; ResultSet resultSet = null; // 初始化结果集对象
try { try {
preparedStatement = conn.prepareStatement("select * from inRecord where iNumber = ?"); preparedStatement = conn.prepareStatement("select * from inRecord where iNumber = ?"); // 准备SQL查询语句
preparedStatement.setString(1, iNumber); preparedStatement.setString(1, iNumber); // 设置查询参数
resultSet = preparedStatement.executeQuery(); resultSet = preparedStatement.executeQuery(); // 执行查询
while(resultSet.next()) { while(resultSet.next()) { // 遍历结果集
inRecord = new InRecord(); inRecord = new InRecord(); // 创建一个新的进货记录对象
inRecord.setiNumber(resultSet.getString("iNumber")); inRecord.setiNumber(resultSet.getString("iNumber")); // 设置进货单号
inRecord.setId(resultSet.getString("id")); inRecord.setId(resultSet.getString("id")); // 设置商品ID
inRecord.setSum(resultSet.getInt("sum")); inRecord.setSum(resultSet.getInt("sum")); // 设置进货数量
inRecord.setInPrice(resultSet.getFloat("Price")); inRecord.setInPrice(resultSet.getFloat("Price")); // 设置进货价格
v.add(inRecord); v.add(inRecord); // 将进货记录对象添加到向量中
} }
} catch (SQLException e) { } catch (SQLException e) { // 捕获SQL异常
e.printStackTrace(); e.printStackTrace(); // 打印异常堆栈信息
} finally { } finally { // 无论是否发生异常，都会执行的代码块
JDBCUtil.close(resultSet, preparedStatement, conn); JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭结果集、预编译语句和数据库连接
} }
return v; return v; // 返回存储进货记录的向量
} }
@Override @Override
public int addinRecord(InRecord ir) { // 该方法用于将进货记录添加到数据库中。
int flag = 0; // 参数 ir 是一个包含进货信息的对象。
// 返回值 flag 表示插入的结果，1表示成功，-1表示失败。
public int addinRecord(InRecord ir) {
int flag = 0; // 初始化标志为0
String iNumber = ir.getiNumber(); String iNumber = ir.getiNumber(); // 获取进货单号
int sum = ir.getSum(); int sum = ir.getSum(); // 获取进货数量
Float inPrice = ir.getInPrice(); Float inPrice = ir.getInPrice(); // 获取进货价格
Connection conn = JDBCUtil.getConn(); Connection conn = JDBCUtil.getConn(); // 获取数据库连接
PreparedStatement preparedStatement = null; PreparedStatement preparedStatement = null; // 初始化预编译语句对象
try { try {
preparedStatement = conn.prepareStatement preparedStatement = conn.prepareStatement
("insert into inRecord values (?,?,?)"); ("insert into inRecord values (?,?,?)"); // 准备SQL插入语句
preparedStatement.setString(1, iNumber); preparedStatement.setString(1, iNumber); // 设置进货单号
preparedStatement.setInt(2, sum); preparedStatement.setInt(2, sum); // 设置进货数量
preparedStatement.setFloat(3, inPrice); preparedStatement.setFloat(3, inPrice); // 设置进货价格
preparedStatement.executeUpdate(); preparedStatement.executeUpdate(); // 执行插入操作
flag = 1; flag = 1; // 设置标志为1，表示插入成功
} catch (SQLException e) { } catch (SQLException e) { // 捕获SQL异常
flag = -1; flag = -1; // 设置标志为-1，表示插入失败
e.printStackTrace(); e.printStackTrace(); // 打印异常堆栈信息
} finally { } finally { // 无论是否发生异常，都会执行的代码块
JDBCUtil.close(null,preparedStatement, conn); JDBCUtil.close(null,preparedStatement, conn); // 关闭预编译语句和数据库连接
} }
return flag; return flag; // 返回插入结果标志
} }
@Override
// 删除进货记录方法，根据进货单号进行删除操作
@Override
public int deleteinRecord(String iNumber) { public int deleteinRecord(String iNumber) {
int flag = 0; int flag = 0; // 初始化标志为0
Connection conn = JDBCUtil.getConn(); Connection conn = JDBCUtil.getConn(); // 获取数据库连接
PreparedStatement preparedStatement = null; PreparedStatement preparedStatement = null; // 初始化预编译语句对象
try { try {
preparedStatement = conn.prepareStatement preparedStatement = conn.prepareStatement
("delete from inRecord where iNumber = ?"); ("delete from inRecord where iNumber = ?"); // 准备SQL删除语句
preparedStatement.setString(1, iNumber); preparedStatement.setString(1, iNumber); // 设置进货单号
preparedStatement.executeUpdate(); preparedStatement.executeUpdate(); // 执行删除操作
flag = 1; flag = 1; // 设置标志为1，表示删除成功
} catch (SQLException e) { } catch (SQLException e) { // 捕获SQL异常
flag = -1; flag = -1; // 设置标志为-1，表示删除失败
e.printStackTrace(); e.printStackTrace(); // 打印异常堆栈信息
} finally { } finally { // 无论是否发生异常，都会执行的代码块
JDBCUtil.close(null,preparedStatement, conn); 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 { try {
preparedStatement = conn.prepareStatement("insert into inRecord values(?,?,?,?)"); preparedStatement = conn.prepareStatement("insert into inRecord values(?,?,?,?)"); // 准备SQL插入语句
preparedStatement.setString(1, iNumber); preparedStatement.setString(1, iNumber); // 设置进货单号
preparedStatement.setString(2, p.getId()); preparedStatement.setString(2, p.getId()); // 设置商品ID
preparedStatement.setInt(3,p.getSum()); preparedStatement.setInt(3,p.getSum()); // 设置进货数量
preparedStatement.setFloat(4, p.getPrice()); preparedStatement.setFloat(4, p.getPrice()); // 设置进货价格
if(preparedStatement.executeUpdate()==1) if(preparedStatement.executeUpdate()==1) // 执行插入操作
flag = true; flag = true; // 如果成功执行插入，设置标志为true
} catch (SQLException e) { } catch (SQLException e) { // 捕获SQL异常
e.printStackTrace(); e.printStackTrace(); // 打印异常堆栈信息
} finally { } finally { // 无论是否发生异常，都会执行的代码块
JDBCUtil.close(null,preparedStatement, conn); JDBCUtil.close(null,preparedStatement, conn); // 关闭预编译语句和数据库连接
} }
return flag; return flag; // 返回插入结果标志
} }
} }

9
Supermarket/src/com/lingnan/supermarket/dao/inOrderService.java
Unescape View File

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

22
Supermarket/src/com/lingnan/supermarket/dto/InRecord.java
Unescape View File

@ -2,26 +2,40 @@ package com.lingnan.supermarket.dto;
import com.lingnan.supermarket.dto.base.BsDomain; import com.lingnan.supermarket.dto.base.BsDomain;
public class InRecord extends BsDomain{ // 表示入库记录的数据传输对象类，继承自BsDomain
private String iNumber; public class InRecord extends BsDomain {
private int sum; private String iNumber; // 入库编号
private Float inPrice; private int sum; // 入库总数
private Float inPrice; // 入库单价
// 获取入库编号
public String getiNumber() { public String getiNumber() {
return iNumber; return iNumber;
} }
// 设置入库编号
public void setiNumber(String iNumber) { public void setiNumber(String iNumber) {
this.iNumber = iNumber; this.iNumber = iNumber;
} }
// 获取入库总数
public int getSum() { public int getSum() {
return sum; return sum;
} }
// 设置入库总数
public void setSum(int sum) { public void setSum(int sum) {
this.sum = sum; this.sum = sum;
} }
// 获取入库单价
public Float getInPrice() { public Float getInPrice() {
return inPrice; return inPrice;
} }
// 设置入库单价
public void setInPrice(Float inPrice) { public void setInPrice(Float inPrice) {
this.inPrice = inPrice; this.inPrice = inPrice;
} }
} }

16
Supermarket/src/com/lingnan/supermarket/dto/SupplierInf.java
Unescape View File

@ -2,21 +2,19 @@ package com.lingnan.supermarket.dto;
import com.lingnan.supermarket.dto.base.BaseDomain; import com.lingnan.supermarket.dto.base.BaseDomain;
// 供应商信息类，继承自BaseDomain
public class SupplierInf extends BaseDomain{ public class SupplierInf extends BaseDomain{
private String name; private String name; // 供应商名称
private String address; private String address; // 供应商地址
private String contact; private String contact; // 供应商联系人
private String email; private String email; // 供应商电子邮件
public String getEmail() { public String getEmail() {
return email; return email;
} }
public void setEmail(String email) { public void setEmail(String email) {
this.email = email; this.email = email;
} }
private int delmark; private int delmark; // 删除标记
public int getDelmark() { public int getDelmark() {
return delmark; return delmark;
@ -42,4 +40,4 @@ public class SupplierInf extends BaseDomain{
public void setContact(String contact) { public void setContact(String contact) {
this.contact = contact; this.contact = contact;
} }
} }

46
Supermarket/src/com/lingnan/supermarket/table/InOrderTM.java
Unescape View File

@ -1,41 +1,39 @@
package com.lingnan.supermarket.table; package com.lingnan.supermarket.table;
import java.util.List; import com.lingnan.supermarket.dao.impl.inOrderServiceImpl;
import java.util.Vector; import com.lingnan.supermarket.dao.impl.productionImpl;
import javax.swing.JFrame;
import javax.swing.table.AbstractTableModel;
import com.lingnan.supermarket.dto.Buffer;
import com.lingnan.supermarket.dto.InOrder; import com.lingnan.supermarket.dto.InOrder;
import com.lingnan.supermarket.dto.Buffer;
import com.lingnan.supermarket.dto.Production;
import com.lingnan.supermarket.dto.User;
import com.lingnan.supermarket.dao.UserService;
import com.lingnan.supermarket.dao.impl.*;
import com.lingnan.supermarket.dialog.InDialog;
import javax.swing.table.AbstractTableModel;
import java.util.Vector;
// 定义InOrderTM类，继承自AbstractTableModel
public class InOrderTM extends AbstractTableModel{ public class InOrderTM extends AbstractTableModel{
// 定义列名数组
private String [] columnName = {"订单号","总价","时间","负责人","状态"}; private String [] columnName = {"订单号","总价","时间","负责人","状态"};
// 实例化生产实现类
private productionImpl prodDao = new productionImpl(); private productionImpl prodDao = new productionImpl();
// 用于存储InOrder对象的向量
private Vector<InOrder> InOrders; private Vector<InOrder> InOrders;
// 实例化入库订单服务实现类
private inOrderServiceImpl inOrderImpl= new inOrderServiceImpl(); private inOrderServiceImpl inOrderImpl= new inOrderServiceImpl();
// 用于存储当前操作的InOrder对象
private InOrder inOrder ; private InOrder inOrder ;
// 用于存储当前操作的订单号
String iNumber ;/*订单号*/ String iNumber ;/*订单号*/
// 获取所有入库订单记录
public void allInOrderRecord() { public void allInOrderRecord() {
//将添加的商品加入到静态变量Vector数组中 // 将添加的商品加入到静态变量Vector数组中
/*prod = InDialog.getProduction();*/ /*prod = InDialog.getProduction();*/
InOrders = inOrderImpl.findAllInOrder(); InOrders = inOrderImpl.findAllInOrder();
} }
//查找分类结果 // 根据分类查找结果
public void resultOfFind(int catalog) { public void resultOfFind(int catalog) {
if(catalog==0) if(catalog==0)
InOrders = inOrderImpl.findAllInOrder(); InOrders = inOrderImpl.findAllInOrder();
@ -43,27 +41,30 @@ public class InOrderTM extends AbstractTableModel{
InOrders = inOrderImpl.FindStatus(catalog); InOrders = inOrderImpl.FindStatus(catalog);
} }
//根据订单查找 // 根据订单号查找
public void resultOfNumber(String Number) { public void resultOfNumber(String Number) {
InOrders=new Vector<InOrder>(); InOrders=new Vector<InOrder>();
inOrder = inOrderImpl.findByIdinOrder(Number); inOrder = inOrderImpl.findByIdinOrder(Number);
InOrders.add(inOrder); InOrders.add(inOrder);
} }
// 返回表格行数
@Override @Override
public int getRowCount() { public int getRowCount() {
return InOrders.size(); return InOrders.size();
} }
/* public Float getAllPrice() { /* public Float getAllPrice() {
return BufferImpl.InBufferAllPrice(); return BufferImpl.InBufferAllPrice();
} }
*/ */
// 返回列数
@Override @Override
public int getColumnCount() { public int getColumnCount() {
return columnName.length; return columnName.length;
} }
// 获取指定单元格的值
@Override @Override
public Object getValueAt(int rowIndex, int columnIndex) { public Object getValueAt(int rowIndex, int columnIndex) {
inOrder = InOrders.get(rowIndex); inOrder = InOrders.get(rowIndex);
@ -93,11 +94,12 @@ public class InOrderTM extends AbstractTableModel{
} }
} }
// 返回要修改或删除的记录的订单号
public String getINumber() { /*返回要修改或删除的记录*/ public String getINumber() { /*返回要修改或删除的记录*/
return iNumber; return iNumber;
} }
// 返回指定列的列名
@Override @Override
public String getColumnName(int column) { public String getColumnName(int column) {
return columnName[column]; return columnName[column];

47
Supermarket/src/com/lingnan/supermarket/table/InRecordTM.java
Unescape View File

@ -1,62 +1,60 @@
package com.lingnan.supermarket.table; package com.lingnan.supermarket.table;
import java.util.List; import com.lingnan.supermarket.dao.impl.inRecordServiceImpl;
import java.util.Vector; import com.lingnan.supermarket.dao.impl.productionImpl;
import javax.swing.JFrame;
import javax.swing.table.AbstractTableModel;
import com.lingnan.supermarket.dto.Buffer;
import com.lingnan.supermarket.dto.InOrder;
import com.lingnan.supermarket.dto.InRecord; import com.lingnan.supermarket.dto.InRecord;
import com.lingnan.supermarket.dto.Buffer;
import com.lingnan.supermarket.dto.Production;
import com.lingnan.supermarket.dto.User;
import com.lingnan.supermarket.dao.UserService;
import com.lingnan.supermarket.dao.impl.*;
import com.lingnan.supermarket.dialog.InDialog;
import javax.swing.table.AbstractTableModel;
import java.util.Vector;
// 定义InRecordTM类，继承自AbstractTableModel
public class InRecordTM extends AbstractTableModel{ public class InRecordTM extends AbstractTableModel{
// 定义列名数组
private String [] columnName = {"订单号","id","数量","金额"}; private String [] columnName = {"订单号","id","数量","金额"};
// 实例化生产实现类
private productionImpl prodDao = new productionImpl(); private productionImpl prodDao = new productionImpl();
// 用于存储InRecord对象的向量
private Vector<InRecord> InRecords; private Vector<InRecord> InRecords;
// 实例化入库记录服务实现类
private inRecordServiceImpl inRecordImpl = new inRecordServiceImpl(); private inRecordServiceImpl inRecordImpl = new inRecordServiceImpl();
// 用于存储当前操作的InRecord对象
private InRecord inRecord= new InRecord(); private InRecord inRecord= new InRecord();
// 用于存储当前操作的订单号
private String iNumber ;/*订单号*/ private String iNumber ;/*订单号*/
// 构造方法，接收一个订单号作为参数
public InRecordTM(String iNumber) { public InRecordTM(String iNumber) {
this.iNumber=iNumber; this.iNumber=iNumber;
} }
// 根据订单号查找入库记录
public void findInRecordByINumber() { public void findInRecordByINumber() {
//将添加的商品加入到静态变量Vector数组中 // 将添加的商品加入到静态变量Vector数组中
/*prod = InDialog.getProduction();*/ /*prod = InDialog.getProduction();*/
InRecords = inRecordImpl.findByIdinRecord(iNumber); InRecords = inRecordImpl.findByIdinRecord(iNumber);
} }
// 返回表格行数
@Override @Override
public int getRowCount() { public int getRowCount() {
return InRecords.size(); return InRecords.size();
} }
/* public Float getAllPrice() { /* public Float getAllPrice() {
return BufferImpl.InBufferAllPrice(); return BufferImpl.InBufferAllPrice();
} }
*/ */
// 返回列数
@Override @Override
public int getColumnCount() { public int getColumnCount() {
return columnName.length; return columnName.length;
} }
// 获取指定单元格的值
@Override @Override
public Object getValueAt(int rowIndex, int columnIndex) { public Object getValueAt(int rowIndex, int columnIndex) {
inRecord = InRecords.get(rowIndex); inRecord = InRecords.get(rowIndex);
@ -77,11 +75,12 @@ public class InRecordTM extends AbstractTableModel{
} }
} }
// 返回要修改或删除的记录的订单号
public String getINumber() { /*返回要修改或删除的记录*/ public String getINumber() { /*返回要修改或删除的记录*/
return iNumber; return iNumber;
} }
// 返回指定列的列名
@Override @Override
public String getColumnName(int column) { public String getColumnName(int column) {
return columnName[column]; return columnName[column];

116
Supermarket/src/com/lingnan/supermarket/table/InTableModel.java
Unescape View File

@ -1,99 +1,87 @@
package com.lingnan.supermarket.table; package com.lingnan.supermarket.table; // 定义包名
import java.util.List;
import java.util.Vector;
import javax.swing.JFrame;
import javax.swing.table.AbstractTableModel;
import com.lingnan.supermarket.dto.InOrder;
import com.lingnan.supermarket.dao.impl.productionImpl;
import com.lingnan.supermarket.dto.Production; import com.lingnan.supermarket.dto.Production;
import com.lingnan.supermarket.dto.User;
import com.lingnan.supermarket.dao.UserService;
import com.lingnan.supermarket.dao.impl.*;
import com.lingnan.supermarket.dialog.InDialog;
public class InTableModel extends AbstractTableModel{ import javax.swing.table.AbstractTableModel;
import java.util.Vector;
// 定义InTableModel类，继承自AbstractTableModel
public class InTableModel extends AbstractTableModel {
private String [] columnName = {"id","名称","数量","单价","价格","保质期","类别","供应商id"}; // 列名数组
private String[] columnName = {"id", "名称", "数量", "单价", "价格", "保质期", "类别", "供应商id"};
// 声明生产实现类的实例
private productionImpl prodDao = new productionImpl(); private productionImpl prodDao = new productionImpl();
private Vector<Production> v; // 用于存储Production对象的向量
private Vector<Production> v;
String id ;
// 用于存储选中记录的id
String id;
// 构造方法，接收一个Production的向量作为参数
public InTableModel(Vector<Production> v) { public InTableModel(Vector<Production> v) {
System.out.println("调用imtablemodel里面的构造函数"); System.out.println("调用InTableModel里面的构造函数");
this.v=v; this.v = v; // 将传入的向量赋值给实例变量
} }
// 返回表格行数
public int getRowCount() { public int getRowCount() {
return v.size(); return v.size(); // 向量的大小即为行数
} }
// 计算并返回所有商品的总价格
public Float getAllPrice() { public Float getAllPrice() {
Float allPrice=(float) 0; Float allPrice = (float) 0; // 初始化总价格为0
for(Production p:v) { for (Production p : v) { // 遍历每个Production对象
allPrice+=p.getPrice(); allPrice += p.getPrice(); // 累加单个产品的价格
} }
return allPrice; return allPrice; // 返回总价格
} }
// 返回列数
@Override @Override
public int getColumnCount() { public int getColumnCount() {
return columnName.length; return columnName.length; // 列数为列名数组的长度
} }
// 获取指定单元格的值
@Override @Override
public Object getValueAt(int rowIndex, int columnIndex) { public Object getValueAt(int rowIndex, int columnIndex) {
Production p = v.get(rowIndex); Production p = v.get(rowIndex); // 获取行索引对应的Production对象
/* System.out.println( "id="+users.get(rowIndex).getId()); id = p.getId(); // 获取产品ID
System.out.println("rowIndex"+rowIndex); // 根据列索引返回相应的属性值
System.out.println("columnIndex"+columnIndex);*/ if (columnIndex == 0) {
id=p.getId(); return p.getId(); // 返回ID
if(columnIndex==0) { } else if (columnIndex == 1) {
return p.getId(); return p.getName(); // 返回名称
}else if(columnIndex==1) { } else if (columnIndex == 2) {
return p.getName(); return p.getSum(); // 返回数量
}else if(columnIndex==2) { } else if (columnIndex == 3) {
return p.getSum(); return p.getInPrice(); // 返回单价
}else if(columnIndex==3) { } else if (columnIndex == 4) {
return p.getInPrice() ; return p.getPrice(); // 返回价格
}else if(columnIndex==4) { } else if (columnIndex == 5) {
return p.getPrice() ; return p.getLife(); // 返回保质期
}else if(columnIndex==5) { } else if (columnIndex == 6) {
return p.getLife(); return p.getName2() + p.getId2(); // 返回类别
}else if(columnIndex==6) { } else if (columnIndex == 7) {
return p.getName2()+p.getId2(); return p.getSupplyId(); // 返回供应商ID
}else if(columnIndex==7) { } else {
return p.getSupplyId(); return null; // 其他情况返回null
}else {
return null;
} }
} }
public String getId() { /*返回要修改或删除的记录*/ // 返回要修改或删除的记录的ID
return id; public String getId() {
return id; // 返回当前选中记录的ID
} }
// 返回指定列的列名
@Override @Override
public String getColumnName(int column) { public String getColumnName(int column) {
return columnName[column]; return columnName[column]; // 返回列名
} }
} }
Write Preview
Loading…
Cancel
Save