小型订餐系统

夏晓橦

已于 2023-06-07 07:47:26 修改

阅读量235

点赞数 6

文章标签：数据库 java

于 2023-06-06 17:59:06 首次发布

本文链接：https://blog.csdn.net/xiaxiaotong1/article/details/131059850

版权

1.数据库设计

1.1需求分析

本小型订餐系统是基于java，通过连接数据库完成。可以有两种运行方式：命令行输出和GUI页面输出。

下面是对本系统的各个功能进行分别说明：

1.管理员：

（1）注册：输入姓名和密码之后进行注册，注册成功后自动登录成功。

（2）登录：输入姓名和密码，进行查询是否有匹配的数据，如果有就登录成功。

（3）查询全部菜品：管理员可以浏览所有的菜品信息

（4）添加菜品：通过输入的菜品信息来添加菜品

（5）修改菜品：通过输入的菜品信息来修改菜品

（6）删除菜品：通过菜品id来进行删除菜品数据

（7）查询全部消费者信息：管理员可以查询全部消费者信息

（8）查询全部管理员信息：管理员可以查询全部管理员信息

（9）查询全部订单信息：管理员可以查询全部订单信息

2.消费者：

（1）注册：输入姓名和密码之后进行注册，注册成功后自动登录成功。

（2）登录：输入姓名和密码，进行查询是否有匹配的数据，如果有就登录成功。

（3）查询全部菜品：消费者可以浏览所有的菜品信息

（4）购买菜品：用户可以选择订什么菜品、菜品数量，购买，生成订单。系统将保留交易的全部信息，包括订单消费人姓名、消费总价、订单日期的信息。

（5）查询订单（是只能查询自己的订单信息）：当消费者选择查询的姓名之后，可以进行查询该名字所有的订单信息。

1.2概念结构设计

1.消费者管理

消费者管理主要包括消费者姓名、消费者编号、消费者密码属性。

图一

2.菜品管理

菜品管理主要包括菜品编号、菜品名称、菜品说明、菜品价格属性。

图二

3.订单管理

订单管理主要包括订单编号、消费总价、订单时间、消费者姓名属性。

图三

4.员工管理

员工管理主要包括管理员姓名、管理员编号、管理员密码属性。

图四

5.全局E-R图

图五

1.3逻辑结构设计

1.消费者（消费者姓名，消费者编号，消费者手机号，消费者密码）

1-1消费者信息表：Customer

字段名	数据类型	约束	说明
xid	int	主键，长度20	消费者编号
xname	varchar	长度20	消费者姓名
xphone	varchar	长度11	消费者手机号
xpassword	varchar	长度21	消费者密码

2.员工（员工姓名，员工编号，员工手机号，员工密码）

1-2员工信息表：Employee

字段名	数据类型	约束	说明
yid	int	主键，长度20	员工编号
yname	varchar	长度20	员工姓名
yphone	varchar	长度11	员工手机号
ypassword	varchar	长度21	员工密码

3.菜品（菜品名，菜品编号，菜品说明，菜品价格）

1-3菜品信息表：Food

字段名	数据类型	约束	说明
cid	int	主键，长度20	菜品编号
cname	varchar	长度20	菜品名
cintro	varchar	长度50	菜品说明
cprice	int	长度20	菜品价格

4.订单（订单编号，订单时间，订单状态，消费总额，消费者编号）

1-4订单信息表：Order

字段名	数据类型	约束	说明
did	int	主键，长度20	订单编号
dtime	date	长度20	订单时间
dstate	boolean	长度20	订单状态（ture--完成，false--未完成）
dprice	int	长度20	消费总额
xid	int	长度20	消费者编号

1.4数据库实施

1.创建数据库并使用数据库

-- 创建数据库shujuku
CREATE DATABASE shujuku;

-- 使用数据库shujuku
USE shujuku;

2.创建四个表

（1）消费者表

-- 1.创建customer顾客表
CREATE TABLE customer(
xid	INT PRIMARY KEY AUTO_INCREMENT COMMENT '消费者编号',
xname	VARCHAR(20)	COMMENT '消费者姓名',
xpassword VARCHAR(21)	COMMENT '消费者密码'
);

-- 查询customer顾客表
SELECT * FROM customer;
 
-- 给customer顾客表 插入数据
INSERT INTO customer VALUES(1,'小明','123456');
-- 一些数据 写
INSERT INTO customer VALUES(2,'李华','020203');
INSERT INTO customer VALUES(3,'刘洋','010304');
INSERT INTO customer VALUES(4,'妮妮','100016');
INSERT INTO customer VALUES(5,'小杜','123456');
INSERT INTO customer VALUES(6,'彭飞','102309');

（2）管理员表

-- 2.创建Employee员工表
CREATE TABLE employee(
yid	INT PRIMARY KEY AUTO_INCREMENT COMMENT '员工编号',
yname	VARCHAR(20)	COMMENT '员工姓名',
ypassword VARCHAR(21)	COMMENT '员工密码'
);

-- 查询employee员工表
SELECT * FROM employee;

-- 给employee员工表 插入数据
INSERT INTO employee VALUES(1,'张三','123456');
-- 一些数据
INSERT INTO employee VALUES(2,'小张','123456');
INSERT INTO employee VALUES(3,'小王','123456');
INSERT INTO employee VALUES(4,'小景','123456');
INSERT INTO employee VALUES(5,'小华','123456');
INSERT INTO employee VALUES(6,'小龙','123456');

（3）食物表

-- 3.创建Food食物表
CREATE TABLE food(
cid	INT PRIMARY KEY AUTO_INCREMENT COMMENT '菜品编号',
cname	VARCHAR(20)	COMMENT '菜品名',
cintro  VARCHAR(50)	COMMENT '菜品说明',
cprice  VARCHAR(20) COMMENT '菜品价格'
);

-- 查询food食物表
SELECT * FROM food;

 
-- 给food食物表 插入数据
INSERT INTO food VALUES(1,'金陵烤鸭','肥而不腻，卤汁是金陵烤鸭的灵魂','38');
INSERT INTO food VALUES(2,'招牌盐水鸭','秘方腌制，肉质细嫩，咸鲜味十足','30');
INSERT INTO food VALUES(3,'姜汁肴蹄','秘制卤水浸泡，咸鲜味美','28');
INSERT INTO food VALUES(4,'苏式熏鱼','经典传统制法，口感甘香','28');
INSERT INTO food VALUES(5,'松仁香干马兰头','爽口清淡','28');
INSERT INTO food VALUES(6,'鸭血粉丝砂锅','南京传统地方风味，鲜美无比','24');
INSERT INTO food VALUES(7,'王府泡椒鸡','微酸、微辣、微甜，三重口感','32');
INSERT INTO food VALUES(8,'鸡汁白鱼','色泽银白肉质细腻，鲜美无比','78');
INSERT INTO food VALUES(9,'麻辣鸭血','鸭血辣辣很开胃，口感顺滑','18');
INSERT INTO food VALUES(10,'状元大春卷','手工现包，香脆可口','15');
INSERT INTO food VALUES(11,'江南水乡一桶鲜','各色水鲜，汇聚一桶','42');
INSERT INTO food VALUES(12,'民国美龄粥','宋美龄钟爱的一道粥，口味独特','18');
INSERT INTO food VALUES(13,'韭香水晶虾饺','外皮晶莹澄澈，虾仁新鲜大只','9');
INSERT INTO food VALUES(14,'清炖狮子头','肥瘦搭配黄金比例，入口即化','28');
INSERT INTO food VALUES(15,'东北大米饭','颗颗饱满（规格：碗）','2');

（4）订单表

-- 4.创建Order订单表
CREATE TABLE IF NOT EXISTS `order`(
did	INT PRIMARY KEY AUTO_INCREMENT COMMENT '订单编号',
dtime	DATE	    COMMENT '订单时间',
dprice  VARCHAR(20)	COMMENT '消费总额',
xname	VARCHAR(20) COMMENT '消费者姓名'
);

-- 删除订单表
DROP TABLE `order`;

-- 查询order订单表
SELECT * FROM `order`;

-- 给order订单表 插入数据
INSERT INTO `order` VALUES(1,'2023-03-20','28','李华');
-- 一些数据
INSERT INTO `order` VALUES(2,'2023-03-22','28','小明'); 
INSERT INTO `order` VALUES(3,'2023-04-25','30','妮妮');
INSERT INTO `order` VALUES(4,'2023-04-27','42','李华');
INSERT INTO `order` VALUES(5,'2023-05-20','78','刘洋');

2.应用程序

首先我们把程序分成几个包：Util类、Entity实体类、Dao接口类、Impl实现类、Test测试类、Gui类

2.1Util类：

建立连接和释放连接（主要是建立与数据库的连接，可以对数据进行增删改查）

连接数据库时，要注意地址不要写错，写错会导致连接不上数据库。特别是，前面用两个斜线（为什么：要多一个斜线是因为其中一个斜线是转义字符）后面用一个斜线。

public class DBUtil {
	
		//连接数据库
		//1.加载并注册数据库的驱动
		private static final String DRIVER="com.mysql.jdbc.Driver";
		//2.通过DriverManager获取数据库连接
		private static final String URL="jdbc:mysql://localhost:3306/shujuku?useSSL=false";
		private static final String USERNAME="root";
		private static final String USERPWD="root";
			
    	public static Connection DBConnection(){
    		try {
				Class.forName(DRIVER);
			} catch (ClassNotFoundException e1) {
				e1.printStackTrace();
			}
			Connection conn=null;
			try {
				conn = DriverManager.getConnection(URL, USERNAME, USERPWD);
			} catch (SQLException e) {
				e.printStackTrace();
			}
			return conn;
    	}
    	
 		//prepareStatement会先初始化SQL，先把这个SQL提交到数据库中进行预处理，多次使用可提高效率。
 		public static PreparedStatement setParam(Connection conn,String sql,Object...param) throws SQLException{
 			PreparedStatement pstmt=null;
 			pstmt=conn.prepareStatement(sql);
 			for(int i=0;i<param.length;i++) {
 				pstmt.setObject(i+1, param[i]);
 			}
 			return pstmt;
 		}
 		
 		//ResultSet
 		public static int exeUpdate(PreparedStatement pstmt) throws SQLException  {
 			int result=0;
 			result=pstmt.executeUpdate();
 			return result;
 			
 		}
 		
 		//关闭连接
 		public static void closeAll(Connection conn,PreparedStatement pstmt,ResultSet rs) {
 			try {
 				if(pstmt!=null) {
 					pstmt.close();
 				}
 				if(conn!=null) {
 					conn.close();
 				}
 				if(rs!=null) {
 					rs.close();
 				}
 			} catch (SQLException e) {
 				e.printStackTrace();
 			}
 		}

        /*
        需要弄懂具体步骤：

        1.加载并注册数据库驱动程序

        2.建立连接，获取连接对象

        3.获取Statement对象

        4.执行SQL语句（这里是把执行SQL语句放在了测试类）

        5.操作结果集

        6.关闭连接，释放资源
        */
}

2.2Entity实体类：

这个包一共有四个类，对应的是数据库的四个表。（这里只贴出来其中的一个）

类里面：首先要定义和数据库表里面的相同属性（比如说消费者表就对应这里面的实体类，定义属性是相同的，xid , xname , xpassword）

其次重写toString方法和get、set方法（直接自动生成）

然后写的就是构造方法（包括无参构造方法和有参构造方法）主要是方便实现类里面需要获取的方法。

//这是数据库中customer表的实体类
public class customerEntity {


	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}
	//这里是customer表里的属性
	private int xid = 0;
	private String xname = null;
    private String xpassword = null;
    
    //可以写多个构造方法，但是参数数量或类型一定不能相同（叫构造方法的重载）
    //构造方法--无参
    public customerEntity() {
		super();
		this.xid = xid;
		this.xname = xname;
		this.xpassword = xpassword;
	}


    //有参--消费者注册登录
    public customerEntity(String xname1, String xpassword1) {
		// TODO Auto-generated constructor stub
    	super();
		this.xname = xname1;
		this.xpassword = xpassword1;
	}
    
    //有参--查询消费者
	public customerEntity(int xid, String xname, String xpassword) {
		// TODO Auto-generated constructor stub
		super();
		this.xid = xid;
		this.xname = xname;
		this.xpassword = xpassword;
	}



	//重写toString方法
    @Override
	public String toString() {
		return "customerEntity [xid=" + xid + ", xname=" + xname + ", xphone="  + xpassword
				+ "]";
	}

    //get、set方法
	public int getXid() {
		return xid;
	}


	public void setXid(int xid) {
		this.xid = xid;
	}


	public String getXname() {
		return xname;
	}


	public void setXname(String xname) {
		this.xname = xname;
	}


	public String getXpassword() {
		return xpassword;
	}


	public void setXpassword(String xpassword) {
		this.xpassword = xpassword;
	}
    

}

2.3Dao 接口类：

这里面放的是一个DishDao接口，主要是定义出主要功能（操作数据库，对表进行增删改查）就是需求分析里的功能。

接口定义了多个在实现类中需要实现的方法，不关心具体实现方法。所以可以在不改变原有接口情况下，随时进行增加或删除类。（使用接口可以使得程序变得灵活，让实例和实现类的耦合度降低）

像消费者和管理员的注册登录功能是返回布尔值boolean，查询消费者、管理员、菜品和订单都是返回一个集合list，菜品的添加、删除、购买以及订单的删除都是定义成方法void。

public interface DishDao {

	//消费者注册，返回是否注册成功的结果
	boolean customerRegister(customerEntity customer);

	//消费者登录，返回是否登录成功的结果
	boolean customerLogon(customerEntity customer);

	//员工注册，返回是否注册成功的结果
	boolean employeeRegister(employeeEntity employee);

	//员工登录，返回是否注册成功的结果
	boolean employeeLogon(employeeEntity employee);

	//查询消费者，查询全部消费者数据
	List<customerEntity> customerQuery();

	//查询管理员，查询全部管理员数据
	List<employeeEntity> employeeQuery();

	//菜品添加，传入一个新的菜品信息来添加数据
	void foodAdd(foodEntity food);

	//菜品删除，根据返回的菜品id来进行删除
	void foodDel(int cid);

	//菜品修改，传入一个新的菜品信息来替代要修改的数据
	void foodUpdate(foodEntity food);

	//菜品查询，查询全部菜品数据
	List<foodEntity> foodQuery();

	//菜品购买（是新增订单）
	void orderAdd(orderEntity order);

	//订单删除，根据返回的订单id来进行删除
	void orderDel(int did);

	//消费者订单查询，根据返回的消费者姓名来进行查询
	List<orderEntity> orderQuery1(String xname);

	//管理员订单查询，查询全部订单数据
	List<orderEntity> orderQuery2();
	
}

2.4Impl实现类：

这里是Dao接口的实现类。接口不能实例化，但我们可以使用接口的实现类来进行实例化。

如何进行实例化：

接口 实例 = new 接口的实现类();

实现类里面主要利用SQL语句来进行方法的实现。方法大同小异。

1.定义sql语句，不同的方法是使用不同的语句。

2.给占位符注入值（有多少个问号就注入多少个，参数是需要和SQL语句相匹配）

//定义一个类实现接口DishDao
public class DishDaoImpl implements DishDao{

	//实例化四个表
	customerEntity customer = new customerEntity();
	employeeEntity employee = new employeeEntity();
	foodEntity food = new foodEntity();
	orderEntity order = new orderEntity();
	
	//消费者注册
	@Override
	public boolean customerRegister(customerEntity customer) {
        //1.定义sql语句，这里是给消费者表插入数据（姓名和密码），编号设置的是自动增长所以不用插入
		String sql = "INSERT INTO customer(xname,xpassword) VALUES(?,?)";
		Connection conn = null;
        //PreparedStatement是Statement的子接口，这个接口里面的语句可以使用占位符“?”来代替(安全性强)
		PreparedStatement pstmt = null;
		if(true) {
			try {
				conn = DBUtil.DBConnection();
				pstmt = DBUtil.setParam(conn, sql);
                //2.给占位符注入值，使用参数与SQL类型相匹配的方法
				pstmt.setString(1,customer.getXname());
				pstmt.setString(2,customer.getXpassword());
                //这里是调用了DBUtil的exeUpdate()方法，这个方法里是executeUpdate()用在增删改
				int result = DBUtil.exeUpdate(pstmt);
				if (result > 0) {
					System.out.println("注册成功，自动登录");
				} else {
					System.out.println("注册失败");
				}
			} catch (SQLException e) {
				e.printStackTrace();
			} finally {
				DBUtil.closeAll(conn, pstmt, null);
			}	
			return true;
		}
		return false;
	}

	//消费者登录
	@Override
	public boolean customerLogon(customerEntity customer) {
        //1.定义sql语句 筛选查询
		String sql = "SELECT * from customer where xname= ? and xpassword = ? ";
		int flag=0;
		Connection conn = null;
		PreparedStatement pstmt = null;
		ResultSet rs = null;
		try {
			conn = DBUtil.DBConnection();
			pstmt = DBUtil.setParam(conn, sql);
            //2.给占位符注入值
			pstmt.setString(1,customer.getXname());
			pstmt.setString(2,customer.getXpassword());
            //executeQuery()是用在查询，返回一个ResultSet对象
			rs = pstmt.executeQuery();
            //rs.next()是将游标移动到下一行，如果下一行没数据，则返回false
			if(rs.next()){
				flag = 1;
			}
			if(flag == 1){
				System.out.println("登录成功！");
				return true;
			}else{
				System.out.println("登录失败！");
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtil.closeAll(conn, pstmt,rs);
		}
		return false;
	}

	//员工注册，其实就是把员工的数据信息插入表中
	@Override
	public boolean employeeRegister(employeeEntity employee) {
		String sql = "INSERT INTO employee(yname,ypassword) VALUES(?,?)";
		Connection conn = null;
		PreparedStatement pstmt = null;
		{
			try {
				conn = DBUtil.DBConnection();
				pstmt = DBUtil.setParam(conn, sql);
				pstmt.setString(1,employee.getYname());
				pstmt.setString(2,employee.getYpassword());
				int result = DBUtil.exeUpdate(pstmt);
				if (result > 0) {
					System.out.println("注册成功，自动登录");
				} else {
					System.out.println("注册失败");
				}
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
				
			} finally {
				DBUtil.closeAll(conn, pstmt, null);
			}
			return true;
		}
	}

	//员工登录
	@Override
	public boolean employeeLogon(employeeEntity employee) {
		String sql = "SELECT * from employee where yname= ? and ypassword= ? ";
		int flag=0;
		Connection conn = null;
		PreparedStatement pstmt = null;
		ResultSet rs = null;
		try {
			conn = DBUtil.DBConnection();
			pstmt = DBUtil.setParam(conn, sql);
			pstmt.setString(1,employee.getYname());
			pstmt.setString(2,employee.getYpassword());
			//由于传值过来了，可以直接取到
			rs = pstmt.executeQuery();
			if(rs.next()){
				flag = 1;
			}
			if(flag == 1){
				System.out.println("登录成功！");
				return true;
			}else{
				System.out.println("登录失败！");
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtil.closeAll(conn, pstmt,rs);
		}
		return false;
	}
	
	//查询消费者
	@Override
	public List<customerEntity> customerQuery() {
		String sql = "SELECT * from customer";
		List<customerEntity> list = new ArrayList<customerEntity>();
		Connection conn = null;
		PreparedStatement pstmt = null;
		ResultSet rs = null;
		try {
			conn = DBUtil.DBConnection();
			pstmt = DBUtil.setParam(conn, sql);
			rs = pstmt.executeQuery();
			while (rs.next()) {
				int xid = rs.getInt(1);
				String xname = rs.getString("xname");
				String xpassword = rs.getString("xpassword");
				System.out.println("消费者编号:" + xid + " 消费者名字: "+ xname + " 消费者密码： " + xpassword);
				list.add(new customerEntity(xid, xname, xpassword));
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtil.closeAll(conn, pstmt,rs);
		}
		return list;
	}
	
	//查询管理员
	@Override
	public List<employeeEntity> employeeQuery() {
		String sql = "SELECT * from employee ";
		List<employeeEntity> list = new ArrayList<employeeEntity>();
		Connection conn = null;
		PreparedStatement pstmt = null;
		ResultSet rs = null;
		try {
			conn = DBUtil.DBConnection();
			pstmt = DBUtil.setParam(conn, sql);
			rs = pstmt.executeQuery();
			while (rs.next()) {
				int yid = rs.getInt(1);
				String yname = rs.getString("yname");
				String ypassword = rs.getString("ypassword");
				System.out.println("管理员编号:" + yid + " 管理员名字: "+ yname + " 管理员密码： " + ypassword);
				list.add(new employeeEntity(yid, yname, ypassword));
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtil.closeAll(conn, pstmt,rs);
		}
		return list;
	}

	//菜品添加
	@Override
	public void foodAdd(foodEntity food) {
		String sql = "INSERT INTO food(cname,cintro,cprice) VALUES(?,?,?)";
		Connection conn = null;
		PreparedStatement pstmt = null;
		try {
			conn = DBUtil.DBConnection();
			pstmt = DBUtil.setParam(conn, sql, food.getCname(), food.getCintro(),food.getCprice());
			int result = DBUtil.exeUpdate(pstmt);
			if (result > 0) {
				System.out.println("插入成功");
			} else {
				System.out.println("插入失败");
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtil.closeAll(conn, pstmt, null);
		}
		
	}

	//菜品删除
	@Override
	public void foodDel(int cid) {
		String sql = "delete from food where cid=?";
		Connection conn = null;
		PreparedStatement pstmt = null;
		try {
			conn = DBUtil.DBConnection();
			pstmt = DBUtil.setParam(conn, sql, cid);
			int result = pstmt.executeUpdate();
			if (result > 0) {
				System.out.println("删除成功");
			} else {
				System.out.println("删除失败");
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtil.closeAll(conn, pstmt, null);
		}
		
	}

	//菜品修改
	@Override
	public void foodUpdate(foodEntity food) {
		String sql = "UPDATE food SET cname=?,cintro=?,cprice=? WHERE cid=?";
		Connection conn = null;
		PreparedStatement pstmt = null;
		try {
			conn = DBUtil.DBConnection();
			pstmt = DBUtil.setParam(conn, sql);
			pstmt.setString(1, food.getCname());
			pstmt.setString(2, food.getCintro());
			pstmt.setString(3, food.getCprice());
			pstmt.setInt(4, food.getCid());
			int result = DBUtil.exeUpdate(pstmt);
			if (result > 0) {
				System.out.println("修改成功");
			} else {
				System.out.println("修改失败");
			}
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	//菜品查询
	@Override
	public List<foodEntity> foodQuery() {
		String sql = "SELECT * from food";
		List<foodEntity> list = new ArrayList<foodEntity>();
		Connection conn = null;
		PreparedStatement pstmt = null;
		ResultSet rs = null;
		try {
			conn = DBUtil.DBConnection();
			pstmt = DBUtil.setParam(conn, sql);
			rs = pstmt.executeQuery();
			while (rs.next()) {
				int cid = rs.getInt(1);
				String cname = rs.getString("cname");
				String cintro = rs.getString("cintro");
				String cprice = rs.getString("cprice");
				System.out.println("菜品编号:" + cid + " 菜品名: "+ cname + " 介绍： " + cintro + " 价格: " + cprice+"元");
				list.add(new foodEntity(cid, cname, cintro, cprice));
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtil.closeAll(conn, pstmt,rs);
		}
		return list;
	}

	//购买（新增订单）
	@Override
	public void orderAdd(orderEntity order) {
		String sql = "INSERT INTO `order`(dtime,dprice,xname) VALUES(?,?,?)";
		Connection conn = null;
		PreparedStatement pstmt = null;
		ResultSet rs = null;
		try {
			conn = DBUtil.DBConnection();
			pstmt = DBUtil.setParam(conn, sql);
			pstmt.setDate(1,new Date(System.currentTimeMillis()));
			pstmt.setString(2,order.getDprice());
			pstmt.setString(3,order.getXname());
			int result = DBUtil.exeUpdate(pstmt);
			if ( result == 1) {
				System.out.println("购买成功，生成订单");
			} else {
				System.out.println("购买失败");
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtil.closeAll(conn, pstmt, null);
			System.out.println(" 订单生成时间："+order.getDtime()+"  消费总价："+order.getDprice()+"元"+"  消费者姓名："+order.getXname());
		}
	}
	
	//订单删除
	@Override
	public void orderDel(int did) {
		String sql = "delete from `order` where did=?";
		Connection conn = null;
		PreparedStatement pstmt = null;
		try {
			conn = DBUtil.DBConnection();
			pstmt = DBUtil.setParam(conn, sql, did);
			int result = pstmt.executeUpdate();
			if (result > 0) {
				System.out.println("删除成功");
			} else {
				System.out.println("删除失败");
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtil.closeAll(conn, pstmt, null);
		}
		
	}
	
	//消费者订单查询
	@Override
	public List<orderEntity> orderQuery1(String xname) {
		String sql = "SELECT * from `order` where xname=?";
		int flag=0;
		List<orderEntity> list = new ArrayList<orderEntity>();
		Connection conn = null;
		PreparedStatement pstmt = null;
		ResultSet rs = null;
		try {
			conn = DBUtil.DBConnection();
			pstmt = DBUtil.setParam(conn, sql);
			pstmt.setString(1,xname);
			//传过来
			rs = pstmt.executeQuery();
			if(rs.next()){
				flag = 1;
			}
			if(flag == 1){
				System.out.println("查询成功！");
				while (rs.next()) {
					int did = rs.getInt("did");
					Date dtime = rs.getDate("dtime");
					String dprice = rs.getString("dprice");
					xname = rs.getString("xname");
					System.out.println("订单编号:" + did + " 订单生成时间: "+ dtime + " 消费总价： " + dprice +"元"+ " 消费者姓名: " + xname);
					list.add(new orderEntity(did,dtime,dprice,xname));
				}
			}else{
				System.out.println("查询失败，您没有订单！");
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtil.closeAll(conn, pstmt,rs);
		}
		return list;
	}

	//管理员订单查询
	@Override
	public List<orderEntity> orderQuery2() {
		String sql = "SELECT * from `order`";
		List<orderEntity> list = new ArrayList<orderEntity>();
		Connection conn = null;
		PreparedStatement pstmt = null;
		ResultSet rs = null;
		try {
			conn = DBUtil.DBConnection();
			pstmt = DBUtil.setParam(conn, sql);
			rs = pstmt.executeQuery();
			while (rs.next()) {
				int did = rs.getInt(1);
				Date dtime = rs.getDate("dtime");
				String dprice = rs.getString("dprice");
				String xname = rs.getString("xname");
				System.out.println("订单编号:" + did + " 订单生成时间: "+ dtime + " 消费总价： " + dprice +"元"+ " 消费者姓名: " + xname);
				list.add(new orderEntity(did,dtime,dprice,xname));
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtil.closeAll(conn, pstmt,rs);
		}
		return list;
	}

}

2.5Test测试类

测试类里写的是命令行里运行的

public class TestMenu {
	
	//实例化
	private DishDao dd=new DishDaoImpl();
	private foodEntity menu=new foodEntity();
	private employeeEntity employee=new employeeEntity();
	private customerEntity customer=new customerEntity();
	private orderEntity order=new orderEntity();
	
	Scanner sc = new Scanner(System.in);
	String err=""; // 吸收错误输入
	public void menu() {

		do {
			System.out.println("----欢迎订餐管理系统----");
			System.out.println("1、员工");
			System.out.println("2、消费者");
			System.out.println("3、退出系统");
			System.out.println("请输入对应菜单序号：(输入1~3的数字)");
			int checkNum =0;
			if(sc.hasNextInt()) {	//判断是否输入格式错误
				checkNum = sc.nextInt();
			}else {
				System.out.println("输入错误！");
				err=sc.next();	//吸收错误
				menu();
			}
			switch (checkNum) {// 选择点击菜单
			case 1:
				int flag=0;
				boolean flagmana=employee();	//判断管理员是否登录成功
				while(flag==0) {
					if(flagmana==true) {
						System.out.println("请输入你要进行的操作:(请输入数字)");
						System.out.println("1.查看菜品");
						System.out.println("2.添加菜品");
						System.out.println("3.修改菜品");
						System.out.println("4.删除菜品");
						System.out.println("5.查看消费者");
						System.out.println("6.查看管理员");
						System.out.println("7.查看订单");
						System.out.println("8.返回主界面");
						int manachoose=0;
						if(sc.hasNextInt()) {	//判断是否输入格式错误
							manachoose=sc.nextInt();
						}else{
							System.out.println("输入错误,请输入数字！");
							err=sc.next();
							menu();	//返回菜单
						}
						switch(manachoose) {
						case 1:
							dishque();
							continue;	//此处不用break，可以让 管理员自主选择退出界面
						case 2:
							menuadd();
							continue;
						case 3:
							menuupd();
							continue;
						case 4:
							menudel();
							continue;
						case 5://消费者查询
							System.out.println("管理员的查询消费者功能");
							dd.customerQuery();
							break;
						case 6://管理员查询
							System.out.println("管理员的查询管理员功能");
							dd.employeeQuery();
							break;
						case 7://订单查询
							System.out.println("管理员的查询订单功能");
							dd.orderQuery2();
							break;
						case 8:
							flag=1;
							System.out.println("退出成功!");
							menu();
							break;
						default :
							System.out.println("输入错误！");
							break;
						}	
					}
					
				}
				
				break;
			case 2:
				int flag02=0;
				boolean userflag=false;	//判断用户是否登录成功
				customer();
				while(flag02==0) {
					if(userflag==false) {
						System.out.println("请输入你要进行的操作：(请输入数字)");
						System.out.println("1.查看菜品：");
						System.out.println("2.购买菜品：");
						System.out.println("3.查看所有订单：");
						System.out.println("4.返回主菜单：");
						int userchoose=0;
						if(sc.hasNextInt()) {	//判断是否输入格式错误
							userchoose=sc.nextInt();
						}else{
							System.out.println("输入错误,请输入数字！");
							err=sc.next();
							menu();	//登录失败，重新回到菜单界面
						}
						switch(userchoose) {
						case 1:
							dishque();
							continue;
						case 2:
							orderAdd();
							continue;
						case 3:
							orderque1();
							continue;
						case 4:
							flag=1;
							menu();
							System.out.println("退出成功!");
							break;
						default :
							System.out.println("输入错误！");
							break;
						}	
					}
				}
					break;
				case 3:
					System.out.println("退出成功！");
					System.exit(1);
					break;
				default:
					System.out.println("输入错误！！！");
					break;
				}
			} while (1==1);
				
	}

	// 管理员操作
	public boolean employee() {
		boolean flag=false;
		while(flag==false) {
			System.out.println("1.登录");
			System.out.println("2.注册");
			System.out.println("3.返回主菜单");
			int k=0;
			if(sc.hasNextInt()) {	//判断是否输入格式错误
				k=sc.nextInt();
			}else {
				System.out.println("输入错误,请输入数字！");
				err=sc.next();
				employee();
			}
			switch(k) {
			case 1:	//管理员登录功能
				System.out.println("管理员登录功能");
				System.out.println("请输入姓名:");
				String yname=sc.next();
				System.out.println("请输入密码(6位数)：");
				String ypassword=sc.next();
				employeeEntity employee11=new employeeEntity(yname,ypassword);
				//这里是直接把两个值传到了employeeEntity里面
				if(flag=dd.employeeLogon(employee11)) {
					return true;
				}else{
				}
				break;
			case 2:	//管理员注册
				System.out.println("管理员注册功能");
				System.out.println("请输入姓名:");
				String yname1=sc.next();
				System.out.println("请输入密码：");
				String ypassword1=sc.next();
				employeeEntity employee111=new employeeEntity(yname1,ypassword1);
				if(flag=dd.employeeRegister(employee111)) {
					return true;
				}
				break;
			case 3:
				flag=true;
				menu();
				break;
			default:
				System.out.println("输入错误！！！");
				break;
			}
		}
		return false;
		
	}
	
	//用户操作
	public boolean customer() {
		boolean flag=false;
		while(flag==false) {
			System.out.println("1.登录");
			System.out.println("2.注册");
			System.out.println("3.返回主菜单");
			int k=0;
			if(sc.hasNextInt()) {	//判断是否使用数字输入
				k=sc.nextInt();
			}else {
				System.out.println("输入错误,请输入数字！");
				err=sc.next();
				customer();
			}
			switch(k) {
			case 1:
				System.out.println("消费者登录功能");
				System.out.println("请输入姓名:");
				String xname=sc.next();
				System.out.println("请输入密码(6位数)：");
				String xpassword=sc.next();
				customerEntity customer11=new customerEntity(xname,xpassword);
				if(flag=dd.customerLogon(customer11)) {
					return true;
				}
				break;
			case 2:
				System.out.println("消费者注册功能");
				System.out.println("请输入姓名：");
				String xname1=sc.next();
				System.out.println("请输入密码(6位数)：");
				String xpassword1=sc.next();
				customerEntity customer111=new customerEntity(xname1,xpassword1);
				if(flag=dd.customerRegister(customer111)) {
					return true;
				}
				break;
			case 3:
				flag=true;
				customer();
				break;
			default:
				System.out.println("输入错误！！！");
				break;
			}	
		}	
		return false;
	}
	
	//查询菜品
	public void dishque() {
		dd.foodQuery();
	}
	
	//添加菜品
	public void menuadd() {
		System.out.println("请输入菜品名：");
		String cname=sc.next();
		System.out.println("请输入介绍：（30字以内）");
		String cintro=sc.next();
		System.out.println("请输入价格：（不超过500元）");
		String cprice=sc.next();
		foodEntity menu=new foodEntity(cname,cintro,cprice);
		dd.foodAdd(menu);
	}
	
	//修改菜品
	public void menuupd() {
		System.out.println("请输入你要修改的菜品编号：(请输入数字)");
		int cid=sc.nextInt();
		System.out.println("请输入菜品名：");
		String cname=sc.next();
		System.out.println("请输入介绍：");
		String cintro=sc.next();
		System.out.println("请输入价格：");
		String cprice=sc.next();
		foodEntity menu=new foodEntity(cid,cname,cintro,cprice);
		dd.foodUpdate(menu);
	}
	
	//菜品删除
	public void menudel() {
		System.out.println("请输入你要删除的菜品编号：(请输入数字)");
		int cid=sc.nextInt();
		dd.foodDel(cid);
	}
	
	//购买菜品（其实是新增订单）
	public void orderAdd() {
	        Date dtime = new Date(System.currentTimeMillis());
			int flag=0;	//判断是否结束购买
			int k=0;
			int id1,id2=0;
			String price1 = null;
			int price2,price3 = 0;
			while(flag==0){
				System.out.println("请输入您要购买的菜品id：(请输入数字)");
				id1=sc.nextInt()-1;//
				price1 = dd.foodQuery().get(id1).getCprice();//这个是一个菜品的价格
				int i=Integer.parseInt(price1);//我们需要通过菜品id来获取菜品的价格
				System.out.println("请输入您要购买的菜品数量：(请输入数字)");
				id2=sc.nextInt();
				price2 = i*id2;//这个是乘上数量的菜品的价格
				price3 = price3+price2;//总价
				System.out.println("是否继续购买？（1.是  2.否）");
				k=sc.nextInt();
				String dprice=Integer.toString(price3);
				if(k==2) {
					flag=1;
					System.out.println("请输入购买人姓名，进行购买");
					String xname = sc.next();
					System.out.println("结束购买！");
//					System.out.println("总价为："+dprice+"元");
					orderEntity order11=new orderEntity( dtime, dprice,xname);
					dd.orderAdd(order11);
				}
			}
	}
	
	//消费者查询订单
	public void orderque1() {
		System.out.println("请输入您的名字，进行查询");
		String xname =sc.next();
		orderEntity order = new orderEntity(xname);
		//把值传过去
		dd.orderQuery1(xname);
	}
	
	//管理员查询订单
	public void orderque2() {
		dd.orderQuery2();
	}
	
}

2.6Gui类

Gui类里写的是在GUI里运行的。

这里贴的是首页（一运行进去的样子），一共有三个按钮：管理员、消费者、退出系统。

给三个按钮都添加监听器，当点击之后做出反应。比如点击管理员会跳转到管理员的板块，也就是利用实例化来跳转页面。

//首页
public class Main {
	public static void createAndShow() {
	
		//创建窗体容器
		JFrame jf1 = new JFrame("小型订餐系统");
		jf1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		jf1.setLayout(new FlowLayout(FlowLayout.CENTER));//流式布局
		jf1.setVisible(true);
		
		//按钮
		JButton button1=new JButton("管理员");
		JButton button2=new JButton("消费者");
		JButton button3=new JButton("退出系统");
        
		//设置可见
        jf1.setBounds(800,350,400,400);
        //添加按钮
        jf1.add(button1);
        jf1.add(button2);
        jf1.add(button3);
        
        //给管理员按钮注册鼠标监听器！！
        button1.addMouseListener(new MouseListener() {
			@Override
			public void mouseClicked(MouseEvent arg0) {
				//如果按的是左键
				if(arg0.getButton() == MouseEvent.BUTTON1){
                //如果想要跳转页面，要先新建了界面的类，然后通过构造函数对界面进行初始化，然后其他地方用到的话，就直接新建一个实例就好了。（这里就是实例化）
					employeeFrame ee = new employeeFrame();
				}else {
					System.out.println("你点了右键");
				}
			}

			@Override
			public void mouseEntered(MouseEvent arg0) {
				// TODO Auto-generated method stub
				
			}

			@Override
			public void mouseExited(MouseEvent arg0) {
				// TODO Auto-generated method stub
				
			}

			@Override
			public void mousePressed(MouseEvent arg0) {
				// TODO Auto-generated method stub
				
			}

			@Override
			public void mouseReleased(MouseEvent arg0) {
				// TODO Auto-generated method stub
				
			}
		});
        
        //给消费者按钮注册鼠标监听器！！
        button2.addMouseListener(new MouseListener() {
			@Override
			public void mouseClicked(MouseEvent arg0) {
				//如果按的是左键
				if(arg0.getButton() == MouseEvent.BUTTON1){
					customerFrame cc = new customerFrame();
				}else {
					System.out.println("你点了右键");
				}
			}

			@Override
			public void mouseEntered(MouseEvent arg0) {
				// TODO Auto-generated method stub
				
			}

			@Override
			public void mouseExited(MouseEvent arg0) {
				// TODO Auto-generated method stub
				
			}

			@Override
			public void mousePressed(MouseEvent arg0) {
				// TODO Auto-generated method stub
				
			}

			@Override
			public void mouseReleased(MouseEvent arg0) {
				// TODO Auto-generated method stub
				
			}
		});
        
        //给退出系统按钮注册监听器！！
        button3.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.exit(0);
            }
        });
	}

	public Main(){
		createAndShow();
	}
	
	public static void main(String[] args) {
		createAndShow();

	}
}