满汉楼

标签：return String 满汉 System public id out

1. 程序框架

满汉楼_List

2. 代码实现

代码在com.stulzl.mhl.包中

view界面层

主界面MHLView

package com.stulzl.mhl.view;


import com.stulzl.mhl.domain.*;
import com.stulzl.mhl.service.BillService;
import com.stulzl.mhl.service.DiningTableService;
import com.stulzl.mhl.service.EmployeeService;
import com.stulzl.mhl.service.MenuService;
import com.stulzl.mhl.utils.Utility;

import javax.rmi.CORBA.Util;
import java.util.List;

//这是主界面   861
public class MHLView {

    private boolean loop = true;//控制是否退出菜单
    private String key = "";//接收用户输入

    //定义一个EmployeeService属性  862
    private EmployeeService employeeService = new EmployeeService();

    //定义一个DiningTableService的属性  863
    private DiningTableService diningTableService = new DiningTableService();

    //定义一个MenuService属性  866
    private MenuService menuService = new MenuService();

    //定义一个BillService属性  869
    private BillService billService = new BillService();

    public static void main(String[] args) {
        new MHLView().mainMenu();
    }

    //完成结账  872
    public void payBill(){
        System.out.println("===========结账服务===========");
        System.out.print("请选择要结账的餐桌编号(-1退出)：");
        int diningTableId = Utility.readInt();
        if(diningTableId==-1){
            System.out.println("============取消结账=============");
            return;
        }
        //验证餐桌是否存在
        DiningTable diningTable = diningTableService.getDiningTableById(diningTableId);
        if(diningTable==null){
            System.out.println("============结账的餐桌不存在=============");
            return;
        }
        //验证餐桌是否有要结账的账单
        if(!billService.hasPayBillByDiningTableId(diningTableId)){
            System.out.println("============该餐桌没有未结账的账单===========");
            return;
        }
        System.out.print("结账方式(现金/支付宝/微信)---回车表示退出：");
        String payMode = Utility.readString(20, "");//如果回车，就是返回""
        if("".equals(payMode)){
            System.out.println("===========取消结账==========");
            return;
        }
        char key = Utility.readConfirmSelection();
        if(key=='Y'){
            //结账
            if(billService.payBill(diningTableId,payMode)){
                System.out.println("============完成结账==============");
            }else{
                System.out.println("============结账失败==============");
            }
        }else{
            System.out.println("===========取消结账==========");
        }

    }

    //显示账单的信息  870
    public void listBill(){
//        List bills = billService.list();
//        System.out.println("\n编号\t\t菜品号\t\t菜品量\t\t金额\t\t桌号\t\t日期\t\t\t\t\t\t\t状态");
//        for (Bill bill : bills) {
//            System.out.println(bill);
//        }
//        System.out.println("===========显示完毕============");

        //显示所有账单并带有菜品名，价格   873-874
        List multiTableBeans = billService.list2();
        System.out.println("\n编号\t\t菜品号\t\t菜品量\t\t金额\t\t桌号\t\t日期\t\t\t\t\t\t\t状态\t\t菜品名\t\t价格");
        for (MultiTableBean bill : multiTableBeans) {
            System.out.println(bill);
        }
        System.out.println("===========显示完毕============");
    }


    //完成点餐   869
    public void orderMenu(){
        System.out.println("=========点餐服务==========");
        System.out.println("请输入点餐的桌号(-1退出)");
        int orderDiningTableId = Utility.readInt();
        if(orderDiningTableId==-1){
            System.out.println("========取消点餐========\n");
            return;
        }
        System.out.println("请输入点餐的菜品号(-1退出)");
        int orderMenuId = Utility.readInt();
        if(orderMenuId==-1){
            System.out.println("========取消点餐========\n");
            return;
        }
        System.out.println("请输入点餐的菜品量(-1退出)");
        int orderNums = Utility.readInt();
        if(orderNums==-1){
            System.out.println("========取消点餐========\n");
            return;
        }

        //开始验证餐桌号是否存在
        DiningTable diningTable= diningTableService.getDiningTableById(orderDiningTableId);
        if (diningTable==null){
            System.out.println("===========餐桌号不存在============");
            return;
        }
        //验证菜品号
        Menu menu = menuService.getMenuById(orderMenuId);
        if(menu == null){
            System.out.println("===========菜品号不存在============");
            return;
        }

        //点餐
        if(billService.orderMenu(orderMenuId,orderNums,orderDiningTableId)){
            System.out.println("=========点餐成功=========");
        }else{
            System.out.println("=========点餐失败=========");
        }

    }


    //显示所有菜品  866
    public void listMenu(){
        List
 list = menuService.list();
        System.out.println("\n菜品编号\t\t菜品名\t\t类别\t\t价格");
        for (Menu menu : list) {
            System.out.println(menu);
        }
        System.out.println("===========显示完毕===========");
    }

    //完成订座  865
    public void orderDiningTable(){
        System.out.println("==========预定餐桌==========");
        System.out.print("请选择要预定的餐桌编号(-1退出)");
        int orderId = Utility.readInt();
        if(orderId==-1){
            System.out.println("========取消预定餐桌========");
            return;
        }
        //该方法得到的是Y或者N
        char key = Utility.readConfirmSelection();
        if(key=='Y'){//要预定
            //根据orderId返回对应的DiningTable对象，如果为null,说明该对象不存在
            DiningTable diningTable = diningTableService.getDiningTableById(orderId);
            if(diningTable==null){//判断餐桌是否存在
                System.out.println("========预定的餐桌不存在=========");
                return;
            }
            //判断该餐桌是否为"空"状态
            if(!("空".equals(diningTable.getState()))){//为空才能预定，取反就是不为空不可预定
                System.out.println("========该餐桌已经预定或者就餐中=========");
                return;
            }
            //这是可以真的预定，更新餐桌状态
            System.out.print("预定人的名字：");
            String orderName = Utility.readString(50);
            System.out.print("预定人的电话：");
            String orderTel = Utility.readString(50);
            //更新餐桌状态
            if(diningTableService.orderDiningTable(orderId,orderName,orderTel)){
                System.out.println("============预定餐桌成功============");
            }else{
                System.out.println("============预定餐桌失败============");
            }

        }else{
            System.out.println("========取消预定餐桌========");
        }
    }

    //显示所有餐桌状态  863
    public void listDiningTable(){
        List list = diningTableService.list();
        System.out.println("\n餐桌编号\t\t餐桌状态");
        //遍历返回的集合，增强for
        for (DiningTable diningTable : list) {
            System.out.println(diningTable);
        }
        System.out.println("=======显示完毕=======");
    }


    //显示主菜单   861
    private  void mainMenu(){
        while(loop){
            System.out.println("===========满汉楼===========");
            System.out.println("\t\t 1 登录满汉楼");
            System.out.println("\t\t 2 退出满汉楼");
            System.out.println("请输入你的选择：");
            key = Utility.readString(1);
            switch(key){
                case "1":
                    System.out.print("请输入员工号：");
                    String empId = Utility.readString(50);
                    System.out.print("请输入密码：");
                    String pwd = Utility.readString(50);
                    //到数据库中去判断   862
                    Employee employee = employeeService.getEmployeeByIdAndPwd(empId, pwd);
                    if(employee!=null){//不得空说明用户存在
                        System.out.println("========登陆成功["+employee.getName()+"]=========\n");


                        //显示二级菜单, 这里二级菜单是循环操作，所以做成while
                        while (loop) {
                            System.out.println("\n===============满汉楼(二级菜单)================");
                            System.out.println("\t\t 1 显示餐桌状态");
                            System.out.println("\t\t 2 预定餐桌");
                            System.out.println("\t\t 3 显示所有菜品");
                            System.out.println("\t\t 4 点餐服务");
                            System.out.println("\t\t 5 查看账单");
                            System.out.println("\t\t 6 结账");
                            System.out.println("\t\t 9 退出满汉楼");
                            System.out.print("请输入你的选择: ");
                            key = Utility.readString(1);
                            switch (key) {
                                case "1":  //  863
                                    listDiningTable();
                                    break;
                                case "2":  //864-865
                                    orderDiningTable();
                                    break;
                                case "3":  //866
                                    listMenu();
                                    break;
                                case "4":  //869
                                    orderMenu();
                                    break;
                                case "5":  //870
                                    listBill();
                                    break;
                                case "6":  //871-872
                                    payBill();
                                    break;
                                case "9":
                                    loop = false;
                                    break;
                                default:
                                    System.out.println("你的输入有误，请重新输入");
                                    break;
                            }
                        }
                    }else{
                        System.out.println("========登陆失败=======");
                    }
                    break;
                case "2":
                    System.out.println("退出满汉楼");
                    loop = false;
                    break;
                default:
                    System.out.println("你的输入有误，请重新输入：");
            }
        }
        System.out.println("你退出了满汉楼系统~");
    }

}

业务层service

员工EmployeeService

package com.stulzl.mhl.service;

import com.stulzl.mhl.dao.EmployeeDAO;
import com.stulzl.mhl.domain.Employee;

//该类完成对Employee表的各种操作(通过调用EmployeeDAO对象完成)   862
public class EmployeeService {//业务层

    //定义一个EmployeeDAO属性
    private EmployeeDAO employeeDAO = new EmployeeDAO();

    //方法，根据empId 和 pwd 返回一个Employee对象
    //如果查不到就返回空null
    public Employee getEmployeeByIdAndPwd(String empId,String pwd){

        return employeeDAO.querySingle("select * from employee where empId=? and pwd=md5(?)"
                        , Employee.class, empId, pwd);

    }
}

餐桌DiningTableService

package com.stulzl.mhl.service;

import com.stulzl.mhl.dao.DiningTableDAO;
import com.stulzl.mhl.domain.DiningTable;

import java.util.List;

//该类完成对DiningTable表的各种操作(通过调用DiningTableDAO对象完成)   863
public class DiningTableService {//业务层
    //定义一个DiningTableDAO对象
    private DiningTableDAO diningTableDAO = new DiningTableDAO();

    //返回所有餐桌的信息   863
    public List list(){
        return diningTableDAO.queryMulti("select id, state from diningTable"
                , DiningTable.class);
    }


    //根据id，查询对应的餐桌DiningTable对象，如果返回空null，则表示id对应的餐桌不存在  864
    public DiningTable getDiningTableById(int id){
        return diningTableDAO.querySingle("select * from diningTable where id=?"
                ,DiningTable.class,id);
    }

    //如果餐桌可以预定，调用方法，对其状态进行更新(包括预定人的名字和电话)   864
    public boolean orderDiningTable(int id,String orderName,String orderTel){
        //这里结束update这个返回值代表受影响的行数
        int update =
                diningTableDAO.update("update diningTable set state='已经预定',orderName=?,orderTel=? where id=?", orderName, orderTel,id);

        return update>0;//update>0代表更新成功，否则不成功
    }

    //需要提供一个更新餐桌状态的方法  868
    public boolean updateDiningTableState(int id,String state){
        int update = diningTableDAO.update("update diningTable set state=? where id=?"
                , state, id);
        return update>0;//update>0说明更新成功，返回true，否则返回false

    }

    //提供方法，将指定餐桌修改为空闲状态   871
    public boolean updateDiningTableToFree(int id,String state){
        int update = diningTableDAO.update("update diningTable set state=?,orderName='',orderTel='' where id=?"
                , state, id);
        return update>0;//update>0说明更新成功，返回true，否则返回false

    }

}

菜单MenuService

package com.stulzl.mhl.service;

import com.stulzl.mhl.dao.MenuDAO;
import com.stulzl.mhl.domain.Menu;

import java.util.List;

//该类完成对Menu表的各种操作(通过调用MenuDAO对象完成)   866
public class MenuService {
    //定义一个MenuDAO属性
    private MenuDAO menuDAO = new MenuDAO();

    //返回所有的菜品,给界面使用
    public List
 list(){
        return menuDAO.queryMulti("select * from menu", Menu.class);
    }

    //需要一个方法根据id返回menu对象  868
    public Menu getMenuById(int id){
        return menuDAO.querySingle("select * from menu where id = ?",Menu.class,id);
    }
}

账单BillService

package com.stulzl.mhl.service;

import com.stulzl.mhl.dao.BillDAO;
import com.stulzl.mhl.dao.MultiTableDAO;
import com.stulzl.mhl.domain.Bill;
import com.stulzl.mhl.domain.MultiTableBean;

import java.util.List;
import java.util.UUID;

//处理和账单相关的业务逻辑  868
public class BillService {
    //定义一个BillDAO属性
    private BillDAO billDAO = new BillDAO();
    //定义一个MenuService属性   868
    private MenuService menuService = new MenuService();
    //定义一个DiningTableService属性   868
    private DiningTableService diningTableService = new DiningTableService();
    //定义一个MultiTableDAO对象  873
    private MultiTableDAO multiTableDAO = new MultiTableDAO();

    //编写点餐的方法   868
    //1. 生成账单
    //2. 需要更新对应餐桌的状态
    //如果成功返回一个true，否则返回false
    public boolean orderMenu(int menuId,int nums,int diningTable){
        //生成一个账单号，使用UUID方法
        String billID = UUID.randomUUID().toString();

        //将账单生成到bill表，要求直接计算账单金额
        int update = billDAO.update("insert into bill values(null,?,?,?,?,?,now(),'未结账')"
                , billID, menuId, nums
                , menuService.getMenuById(menuId).getPrice() * nums, diningTable);

        if(update<=0){//生成账单失败
            return false;
        }

        //需要更新对应的餐桌状态
        return diningTableService.updateDiningTableState(diningTable,"就餐中");
    }

    //返回所有的账单，提供给View使用  870
    public List list(){
        return billDAO.queryMulti("select * from bill",Bill.class);
    }

    //返回所有的账单并且带有菜品名，价格  提供给View使用  873-874
    public List list2(){
        return multiTableDAO.queryMulti("SELECT bill.*,NAME,price " +
                "FROM bill,menu " +
                "WHERE bill.menuId=menu.Id",MultiTableBean.class);
    }


    //查看某个餐桌是否有未结账的账单   871
    public boolean hasPayBillByDiningTableId(int diningTableId){
        Bill bill =
                billDAO.querySingle("SELECT * FROM bill WHERE diningTableId=? AND state='未结账' LIMIT 0,1"
                        , Bill.class, diningTableId);
        return bill !=null;//如果不等于空就说明有未结账的放回true，否则返回false
    }

    //完成结账，如果餐桌存在，并且餐桌有未结账的账单  871
    public boolean payBill(int diningTableId,String payMode){
        //修改bill表
        int update =
                billDAO.update("update bill set state=? where diningTableId=? and state='未结账'"
                        , payMode, diningTableId);
        if(update<0){//修改bill更新失败
            return false;
        }

        //修改diningTable表    871
        //注意不要直接在这里操作，而是应该调用DiningTableService 方法
        if(!diningTableService.updateDiningTableToFree(diningTableId,"空")){
            return false;//取反代表失败
        }
        return true;//修改成功
    }
}

各种DAO

基础BasicDAO

package com.stulzl.mhl.dao;

import com.stulzl.mhl.utils.JDBCUtils_Druid;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

//开发BasicDAO，是其他DAO的父类   854
public class BasicDAO {//泛型指定具体的类型

    private QueryRunner qr = new QueryRunner();

    //开发通用的dml方法，针对任意的表
    public int update(String sql,Object... parameters){//Object... parameters可变形参
        Connection connection = null;
        try {
            connection = JDBCUtils_Druid.getConnection();
            int update = qr.update(connection, sql, parameters);
            return update;//返回收影响行数
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            //关闭连接
            JDBCUtils_Druid.close(null,null,connection);
        }
    }

    //返回多个对象（即查询的结果是多行），这么对任意表
    /**
     *
     * @param sql sql 语句，可以有 ?
     * @param clazz 传入一个类的 Class 对象 比如 Actor.class
     * @param parameters 传入 ? 的具体的值，可以是多个
     * @return 根据 Actor.class 返回对应的 ArrayList 集合
     */
    public List queryMulti(String sql, Class clazz, Object...parameters){
        Connection connection = null;
        try {
            connection = JDBCUtils_Druid.getConnection();
            return qr.query(connection, sql, new BeanListHandler(clazz), parameters);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            //关闭连接
            JDBCUtils_Druid.close(null,null,connection);
        }

    }

    //查询单行结果的通用方法
    public T querySingle(String sql, Class clazz, Object... parameters) {
        Connection connection = null;
        try {
            connection = JDBCUtils_Druid.getConnection();
            return qr.query(connection, sql, new BeanHandler(clazz), parameters);
        } catch (SQLException e) {
            throw new RuntimeException(e); //将编译异常->运行异常 ,抛出
        } finally {
            JDBCUtils_Druid.close(null, null, connection);
        }
    }

    //查询单行单列的方法,即返回单值的方法
    public Object queryScalar(String sql, Object... parameters){
        Connection connection = null;
        try {
            connection = JDBCUtils_Druid.getConnection();
            return qr.query(connection, sql, new ScalarHandler(), parameters);
        } catch (SQLException e) {
            throw new RuntimeException(e); //将编译异常->运行异常 ,抛出
        } finally {
            JDBCUtils_Druid.close(null, null, connection);
        }
    }
}

员工EmployeeDAO

package com.stulzl.mhl.dao;

import com.stulzl.mhl.domain.Employee;

//  862
//这里是EmployeeDAO继承BasicDAO类（BasicDAO有基础功能，如果还需要别的功能可以在EmployeeDAO中添加）
public class EmployeeDAO extends BasicDAO{
    //这里还可以写特有的操作
}

餐桌DiningTableDAO

package com.stulzl.mhl.dao;

import com.stulzl.mhl.domain.DiningTable;

//863
//这里是DiningTableDAO继承BasicDAO类（BasicDAO有基础功能，如果还需要别的功能可以在DiningTableDAO中添加）
public class DiningTableDAO extends BasicDAO {
    //这里还可以写特有的操作
}

菜单MenuDAO

package com.stulzl.mhl.dao;


import com.stulzl.mhl.domain.Menu;

//866
//这里是MenuDAO继承BasicDAO类（BasicDAO有基础功能，如果还需要别的功能可以在MenuDAO中添加）
public class MenuDAO extends BasicDAO
{
    //这里还可以写特有的操作
}

账单BillDAO

package com.stulzl.mhl.dao;

import com.stulzl.mhl.domain.Bill;

//868
//这里是BillDAO继承BasicDAO类（BasicDAO有基础功能，如果还需要别的功能可以在BillDAO中添加）
public class BillDAO extends BasicDAO{
    //这里还可以写特有的操作
}

多表查询MultiTableDAO

package com.stulzl.mhl.dao;

import com.stulzl.mhl.domain.MultiTableBean;

//873
//这里是MultiTableDAO继承BasicDAO类（BasicDAO有基础功能，如果还需要别的功能可以在MultiTableDAO中添加）
public class MultiTableDAO extends BasicDAO{

}

各种domain（javabean）

员工Employee

package com.stulzl.mhl.domain;

//这是一个javabean  和employee对应  862
public class Employee {
    private Integer id;
    private String empId;
    private String pwd;
    private String name;
    private String job;

    public Employee() {//无参构造器，底层需要apache-dbutils反射需要
    }

    public Employee(Integer id, String empId, String pwd, String name, String job) {
        this.id = id;
        this.empId = empId;
        this.pwd = pwd;
        this.name = name;
        this.job = job;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getEmpId() {
        return empId;
    }

    public void setEmpId(String empId) {
        this.empId = empId;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }
}

餐桌DiningTable

package com.stulzl.mhl.domain;

//这是一个javabean 和diningTable表对应  863
public class DiningTable {
    private Integer id;
    private String state;
    private String orderName;
    private String orderTel;

    public DiningTable() {
    }

    public DiningTable(Integer id, String state, String orderName, String orderTel) {
        this.id = id;
        this.state = state;
        this.orderName = orderName;
        this.orderTel = orderTel;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    public String getOrderTel() {
        return orderTel;
    }

    public void setOrderTel(String orderTel) {
        this.orderTel = orderTel;
    }

    @Override
    public String toString() {
        return id + "\t\t\t" + state;
    }
}

菜单Menu

package com.stulzl.mhl.domain;

//该类是javabean  和menu表对应  866
public class Menu {
    private Integer id;
    private String name;
    private String type;
    private Double price;

    public Menu() {
    }

    public Menu(Integer id, String name, String type, Double price) {
        this.id = id;
        this.name = name;
        this.type = type;
        this.price = price;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return id + "\t\t" + name + "\t\t" + type + "\t\t" + price;
    }
}

账单Bill

package com.stulzl.mhl.domain;

import java.util.Date;

//这是一个javabean 和bill表对应  868
public class Bill {
    private Integer id;
    private String billId;
    private Integer menuId;
    private Integer nums;
    private Double money;
    private Integer diningTableId;
    private Date billDate;
    private String state;

    public Bill() {
    }

    public Bill(Integer id, String billId, Integer menuId, Integer nums
            , Double money, Integer diningTableId, Date billDate, String state) {
        this.id = id;
        this.billId = billId;
        this.menuId = menuId;
        this.nums = nums;
        this.money = money;
        this.diningTableId = diningTableId;
        this.billDate = billDate;
        this.state = state;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getBillId() {
        return billId;
    }

    public void setBillId(String billId) {
        this.billId = billId;
    }

    public Integer getMenuId() {
        return menuId;
    }

    public void setMenuId(Integer menuId) {
        this.menuId = menuId;
    }

    public Integer getNums() {
        return nums;
    }

    public void setNums(Integer nums) {
        this.nums = nums;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    public Integer getDiningTableId() {
        return diningTableId;
    }

    public void setDiningTableId(Integer diningTableId) {
        this.diningTableId = diningTableId;
    }

    public Date getBillDate() {
        return billDate;
    }

    public void setBillDate(Date billDate) {
        this.billDate = billDate;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    @Override
    public String toString() {
        return  id +
                "\t\t" + menuId +
                "\t\t\t" + nums +
                "\t\t\t" + money +
                "\t" + diningTableId +
                "\t\t" + billDate +
                "\t\t" + state;
    }
}

多表查询MultiTableBean

package com.stulzl.mhl.domain;

import java.util.Date;

//这个javabean可以和多张表尽相映射，用来进行多表查询    873
public class MultiTableBean {
    private Integer id;
    private String billId;
    private Integer menuId;
    private Integer nums;
    private Double money;
    private Integer diningTableId;
    private Date billDate;
    private String state;
    //增加一个menu表的name字段   873
    private String name;
    //增加一个来自menu表的price  874
    private Double price;

    public MultiTableBean() {
    }

    public MultiTableBean(Integer id, String billId, Integer menuId, Integer nums,
                          Double money, Integer diningTableId, Date billDate,
                          String state, String name, Double price) {
        this.id = id;
        this.billId = billId;
        this.menuId = menuId;
        this.nums = nums;
        this.money = money;
        this.diningTableId = diningTableId;
        this.billDate = billDate;
        this.state = state;
        this.name = name;
        this.price = price;
    }

    //给price生成setter和getter方法  874


    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    //给name  setter和getter方法   873
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getBillId() {
        return billId;
    }

    public void setBillId(String billId) {
        this.billId = billId;
    }

    public Integer getMenuId() {
        return menuId;
    }

    public void setMenuId(Integer menuId) {
        this.menuId = menuId;
    }

    public Integer getNums() {
        return nums;
    }

    public void setNums(Integer nums) {
        this.nums = nums;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    public Integer getDiningTableId() {
        return diningTableId;
    }

    public void setDiningTableId(Integer diningTableId) {
        this.diningTableId = diningTableId;
    }

    public Date getBillDate() {
        return billDate;
    }

    public void setBillDate(Date billDate) {
        this.billDate = billDate;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    @Override
    public String toString() {
        return  id +
                "\t\t" + menuId +
                "\t\t\t" + nums +
                "\t\t\t" + money +
                "\t" + diningTableId +
                "\t\t" + billDate +
                "\t\t" + state +
                "\t\t" + name +
                "\t\t" + price;
    }
}

工具类Utils

JDBCUtils_Druid

package com.stulzl.mhl.utils;


import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

//这是一个基于druid的数据库连接池的工具类  845
//将 JDBCUtils 工具类改成 Druid(德鲁伊)实现
public class JDBCUtils_Druid {
    private static DataSource ds;

    //在静态代码块完成ds的初始化
    static{
        Properties properties = new Properties();
        try {
            properties.load(new FileInputStream("src\\druid.properties"));

            ds = DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //编写getConnection方法
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }
    //关闭连接, 再次强调： 在数据库连接池技术中，close 不是真的断掉连接
    //而是把使用的 Connection 对象放回连接池
    public static void close(ResultSet resultSet, Statement statement, Connection connection){
        try {
            if (resultSet != null) {
                resultSet.close();
            }
            if (statement != null) {
                statement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

Utility

package com.stulzl.mhl.utils;


/**
	工具类的作用:
	处理各种情况的用户输入，并且能够按照程序员的需求，得到用户的控制台输入。
*/

import java.util.*;
/**

	
*/
public class Utility {
	//静态属性。。。
    private static Scanner scanner = new Scanner(System.in);

    
    /**
     * 功能：读取键盘输入的一个菜单选项，值：1——5的范围
     * @return 1——5
     */
	public static char readMenuSelection() {
        char c;
        for (; ; ) {
            String str = readKeyBoard(1, false);//包含一个字符的字符串
            c = str.charAt(0);//将字符串转换成字符char类型
            if (c != '1' && c != '2' && 
                c != '3' && c != '4' && c != '5') {
                System.out.print("选择错误，请重新输入：");
            } else break;
        }
        return c;
    }

	/**
	 * 功能：读取键盘输入的一个字符
	 * @return 一个字符
	 */
    public static char readChar() {
        String str = readKeyBoard(1, false);//就是一个字符
        return str.charAt(0);
    }
    /**
     * 功能：读取键盘输入的一个字符，如果直接按回车，则返回指定的默认值；否则返回输入的那个字符
     * @param defaultValue 指定的默认值
     * @return 默认值或输入的字符
     */
    
    public static char readChar(char defaultValue) {
        String str = readKeyBoard(1, true);//要么是空字符串，要么是一个字符
        return (str.length() == 0) ? defaultValue : str.charAt(0);
    }
	
    /**
     * 功能：读取键盘输入的整型，长度小于2位
     * @return 整数
     */
    public static int readInt() {
        int n;
        for (; ; ) {
            String str = readKeyBoard(2, false);//一个整数，长度<=2位
            try {
                n = Integer.parseInt(str);//将字符串转换成整数
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }
    /**
     * 功能：读取键盘输入的 整数或默认值，如果直接回车，则返回默认值，否则返回输入的整数
     * @param defaultValue 指定的默认值
     * @return 整数或默认值
     */
    public static int readInt(int defaultValue) {
        int n;
        for (; ; ) {
            String str = readKeyBoard(10, true);
            if (str.equals("")) {
                return defaultValue;
            }
			
			//异常处理...
            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }

    /**
     * 功能：读取键盘输入的指定长度的字符串
     * @param limit 限制的长度
     * @return 指定长度的字符串
     */

    public static String readString(int limit) {
        return readKeyBoard(limit, false);
    }

    /**
     * 功能：读取键盘输入的指定长度的字符串或默认值，如果直接回车，返回默认值，否则返回字符串
     * @param limit 限制的长度
     * @param defaultValue 指定的默认值
     * @return 指定长度的字符串
     */
	
    public static String readString(int limit, String defaultValue) {
        String str = readKeyBoard(limit, true);
        return str.equals("")? defaultValue : str;
    }


	/**
	 * 功能：读取键盘输入的确认选项，Y或N
	 * 将小的功能，封装到一个方法中.
	 * @return Y或N
	 */
    public static char readConfirmSelection() {
        System.out.println("确认是否预定(Y/N): ");
        char c;
        for (; ; ) {//无限循环
        	//在这里，将接受到字符，转成了大写字母
        	//y => Y n=>N
            String str = readKeyBoard(1, false).toUpperCase();
            c = str.charAt(0);
            if (c == 'Y' || c == 'N') {
                break;
            } else {
                System.out.print("选择错误，请重新输入：");
            }
        }
        return c;
    }

    /**
     * 功能： 读取一个字符串
     * @param limit 读取的长度
     * @param blankReturn 如果为true ,表示 可以读空字符串。 
     * 					  如果为false表示 不能读空字符串。
     * 			
	 *	如果输入为空，或者输入大于limit的长度，就会提示重新输入。
     * @return
     */
    private static String readKeyBoard(int limit, boolean blankReturn) {
        
		//定义了字符串
		String line = "";

		//scanner.hasNextLine() 判断有没有下一行
        while (scanner.hasNextLine()) {
            line = scanner.nextLine();//读取这一行
           
			//如果line.length=0, 即用户没有输入任何内容，直接回车
			if (line.length() == 0) {
                if (blankReturn) return line;//如果blankReturn=true,可以返回空串
                else continue; //如果blankReturn=false,不接受空串，必须输入内容
            }

			//如果用户输入的内容大于了 limit，就提示重写输入  
			//如果用户如的内容 >0 <= limit ,我就接受
            if (line.length() < 1 || line.length() > limit) {
                System.out.print("输入长度（不能大于" + limit + "）错误，请重新输入：");
                continue;
            }
            break;
        }

        return line;
    }
}

数据库代码在E:\java学习\初级\course174\db_

满汉楼mhl

-- 创建满汉楼的数据库
CREATE DATABASE mhl
-- 创建表employee表（主键id，empId，name，pwd，job等）   862
#用户表
CREATE TABLE employee (
	id INT PRIMARY KEY AUTO_INCREMENT, #自增
	empId VARCHAR(50) UNIQUE NOT NULL DEFAULT '',#员工号
	pwd CHAR(32) NOT NULL DEFAULT '',#密码md5
	NAME VARCHAR(50) NOT NULL DEFAULT '',#姓名
	job VARCHAR(50) NOT NULL DEFAULT '' #岗位
)CHARSET=utf8; 

-- 添加数据
INSERT INTO employee VALUES(NULL, '6668612', MD5('123456'), '张三丰', '经理');
INSERT INTO employee VALUES(NULL, '6668622', MD5('123456'),'小龙女', '服务员');
INSERT INTO employee VALUES(NULL, '6668633', MD5('123456'), '张无忌', '收银员');
INSERT INTO employee VALUES(NULL, '666', MD5('123456'), '老韩', '经理');

SELECT * FROM employee
SELECT * FROM employee WHERE empId=666 AND pwd=MD5(123456)


-- 创建dingTable 表(id，state，orderName，orderTel...)   863
#餐桌表
CREATE TABLE diningTable (
	id INT PRIMARY KEY AUTO_INCREMENT, #自增, 表示餐桌编号
	state VARCHAR(20) NOT NULL DEFAULT '',#餐桌的状态
	orderName VARCHAR(50) NOT NULL DEFAULT '',#预订人的名字
	orderTel VARCHAR(20) NOT NULL DEFAULT ''
)CHARSET=utf8; 
-- 测试数据
INSERT INTO diningTable VALUES(NULL, '空','','');
INSERT INTO diningTable VALUES(NULL, '空','','');
INSERT INTO diningTable VALUES(NULL, '空','','');

SELECT * FROM diningTable

SELECT id, state FROM diningTable

SELECT * FROM diningTable WHERE id=1
UPDATE diningTable SET state='空',orderName='',orderTel='' WHERE id=1


-- 创建menu表（id，name，type，price）   866
#菜谱
CREATE TABLE menu (
	id INT PRIMARY KEY AUTO_INCREMENT, #自增主键，作为菜谱编号(唯一)
	NAME VARCHAR(50) NOT NULL DEFAULT '',#菜品名称
	TYPE VARCHAR(50) NOT NULL DEFAULT '', #菜品种类
	price DOUBLE NOT NULL DEFAULT 0#价格
)CHARSET=utf8; 

INSERT INTO menu VALUES(NULL, '八宝饭', '主食类', 10);
INSERT INTO menu VALUES(NULL, '叉烧包', '主食类', 20);
INSERT INTO menu VALUES(NULL, '宫保鸡丁', '热菜类', 30);
INSERT INTO menu VALUES(NULL, '山药拨鱼', '凉菜类', 14);
INSERT INTO menu VALUES(NULL, '银丝卷', '甜食类', 9);
INSERT INTO menu VALUES(NULL, '水煮鱼', '热菜类', 26);
INSERT INTO menu VALUES(NULL, '甲鱼汤', '汤类', 100);
INSERT INTO menu VALUES(NULL, '鸡蛋汤', '汤类', 16);

SELECT * FROM menu
SELECT * FROM menu WHERE id = 1


-- 增加表bill账单表(id, billId, menuId, nums, billDate, money, state, diningTableId)   867
#账单流水, 考虑可以分开结账, 并考虑将来分别统计各个不同菜品的销售情况
CREATE TABLE bill (
	id INT PRIMARY KEY AUTO_INCREMENT, #自增主键
	billId VARCHAR(50) NOT NULL DEFAULT '',#账单号可以按照自己规则生成 UUID
	menuId INT NOT NULL DEFAULT 0,#菜品的编号, 也可以使用外键
	nums SMALLINT NOT NULL DEFAULT 0,#份数
	money DOUBLE NOT NULL DEFAULT 0, #金额
	diningTableId INT NOT NULL DEFAULT 0, #餐桌
	billDate DATETIME NOT NULL ,#订单日期
	state VARCHAR(50) NOT NULL DEFAULT '' # 状态 '未结账' , '已经结账', '挂单','现金','支付宝','坏账'
)CHARSET=utf8;

SELECT * FROM bill
-- 查看某个餐桌是否有未结账的账单  871
SELECT * FROM bill WHERE diningTableId=1 AND state='未结账' LIMIT 0,1

-- 写出sql语句，可以返回菜品名和账单信息  873
SELECT bill.*,NAME
	FROM bill,menu
	WHERE bill.menuId=menu.Id

配置文件druid.properties

#key=value
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mhl?rewriteBatchedStatements=true
username=root
password=lzl
#initial connection Size
initialSize=10
#min idle connecton size
minIdle=5
#max active connection size
maxActive=50
#max wait time (5000 mil seconds)
maxWait=5000

还有三个jar文件包

标签：return,String,满汉,System,public,id,out
From： https://blog.51cto.com/u_15784725/6365077

1. 程序框架

2. 代码实现

代码在com.stulzl.mhl.包中

view界面层

主界面MHLView

业务层service

员工EmployeeService

餐桌DiningTableService

菜单MenuService

账单BillService

各种DAO

基础BasicDAO

员工EmployeeDAO

餐桌DiningTableDAO

菜单MenuDAO

账单BillDAO

多表查询MultiTableDAO

各种domain（javabean）

员工Employee

餐桌DiningTable

菜单Menu

账单Bill

多表查询MultiTableBean

工具类Utils

JDBCUtils_Druid

Utility

数据库代码在E:\java学习\初级\course174\db_

满汉楼mhl

配置文件druid.properties

还有三个jar文件包

相关文章

赞助商

阅读排行