满汉楼项目

满汉楼项目

1. 满汉楼介绍

满汉楼是一个综合餐饮管理系统,其主要分为:

  • 人事登记:各部门人员信息
  • 登录管理:员工号、姓名、职位、密码
  • 菜谱价格:菜谱及价格
  • 报表统计:统计销售额
  • 成本及库房:名称注册登记 -> 录入初期余额 -> 入库出库清单 -> 库存统计盘点 -> 查询分析统计
  • 系统设置
  • 动画帮助

该项目应用到的核心知识:java+jdbc(druid)+mysql

满汉楼项目有很多界面,这里展示部分:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p8ywrVGr-1688202019358)(E:\Java study\Markdown\本地图片\满汉楼初始界面.png)]

2. 需求说明

满汉楼项目的功能比较多,界面复杂,涉及到复杂的awt和swing技术和事件编程,做如下调整:

  1. 去掉界面和事件处理(工作中使用很少),使用控制台界面
  2. 完成满汉楼项目的登录、订座、点餐、结账和查看账单等功能

3. 界面设计

我们先大致弄成以下界面:

  1. 用户登录

  2. 显示餐桌状态

  3. 预定餐桌

  4. 显示所有菜品

  5. 点餐服务

  6. 查看账单

  7. 结账

  8. 退出满汉楼

4. 项目设计

项目设计—程序框架图

在这里插入图片描述

5. 功能实现

5.1 准备阶段

  1. 准备工具类Utility,提高开发效率,并搭建项目的整体结构
  2. 在实际开发中,公司都会提供相应的工具类和开发库,提高开发效率
    • 了解Utility的使用
    • 测试Utility
  3. 在本项目下创建一个libs目录,把相应的jar包导入到libs目录

  1. 导入Utility和JDBCUtilsByDruid工具类

    • 添加配置文件druid.properties
    #key=value
    driverClassName=com.mysql.jdbc.Driver
    url=jdbc:mysql://localhost:3306/sys_db02?rewriteBatchedStatements=true
    #url=jdbc:mysql://localhost:3306/sys_db02
    username=root
    password=sys
    #initial connection Size
    initialSize=10
    #min idle connecton size
    minIdle=5
    #max active connection size
    maxActive=20
    #max wait time (5000 mil seconds)
    maxWait=5000
    
    • 添加Utility工具类
    package com.song.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;
        }
    }
    
    • 添加JDBCUtilsByDruid工具类
    package com.song.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数据库连接池的工具类
     */
    public class JDBCUtilsByDruid {
        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) {
                throw new RuntimeException(e);
            }
        }
    
        //编写getConnection方法
        public static Connection getConncteion() throws SQLException {
            return ds.getConnection();
        }
    
        //关闭连接
        //注意:这里的关闭连接,在数据库连接池技术中,不是真的断掉连接
        //而是把使用的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);
            }
        }
    }
    
  2. 对上面两个工具类做个简单的测试,查看是否导入成功

5.2 显示主菜单、二级菜单和退出系统功能

5.2.1 主菜单界面

  1. 先创建一个MHLView类,把主菜单界面的相关代码写入
  2. 然后创建一个employee的表格,录入部分员工的信息,用于验证是否登录成功,如果登录成功,则进入二级菜单;
  3. 然后创建对应的Employee类:javabean和employee对应
  4. 然后再创建相应的EmployeeDAO继承BasicDAO
  5. 最后创建EmployeeService类,用于完成对employee表的各种操作(通过调用EmployeeDAO对象完成)

5.2.2 二级菜单界面

  • 显示餐桌状态界面
  1. 先创建一个diningTable表格,先初步填写几个空白的信息
  2. 然后创建对应的DiningTable类:javabean和diningTable对应
  3. 然后再创建相应的DiningTableDAO继承BasicDAO
  4. 最后创建DiningTableService类,完成对diningTable表的各种操作(通过调用DiningTableDAO对象完成)

  • 预定餐桌界面
  1. 如果该餐桌处于已经预定或者就餐状态,给出提示
  2. 思路分析:
    1. 检测餐桌是否存在
    2. 检测餐桌的状态
    3. 如果餐桌存在并且未预定,那么可以进行预定
  3. 进行餐桌预定:
    1. 接收预定信息
    2. 更新餐桌状态
    3. 提示预订成功

  • 显示所有菜品界面
  1. 先创建一个menu表格,先初步填写几个空白的信息
  2. 然后创建对应的Menu类:javabean和menu对应
  3. 然后再创建相应的MenuDAO继承BasicDAO
  4. 最后创建MenuService类,完成对menu表的各种操作(通过调用MenuDAO对象完成)

  • 点餐服务界面
  1. 要求对餐桌号,菜品编号做合理性校验,如果不合理,给出提示信息
  2. 思路分析:
    1. 餐桌号,菜品编号进行检验
    2. 点单成功后,需要修改餐桌状态
    3. 生成账单

  • 查看账单界面

  • 结账界面
  1. 思路分析:
    1. 对餐桌号进行校验
    2. 修改bill表的state
    3. 修改diningTable信息
    4. 不需求增加新表,不需要增加新的类,需要增加新的业务逻辑

  • 退出满汉楼

5.2.3 代码实现

表格
  1. 创建员工表employee
-- 创建满汉楼的数据库
CREATE DATABASE mhl
-- 创建表 employee表(主键id,empid,name,pwd,job等)
CREATE TABLE employee(
	id INT PRIMARY KEY AUTO_INCREMENT,-- 主键id,自增
	empid VARCHAR(32) UNIQUE NOT NULL DEFAULT '',-- 员工号
	pwd CHAR(32) NOT NULL DEFAULT '',-- 密码
	NAME VARCHAR(32) NOT NULL DEFAULT '',-- 名字
	job VARCHAR(32) 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;

DROP TABLE employee;
  1. 创建订餐表diningTable
-- 创建表 diningTable 订餐表/餐桌表
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 * FROM diningTable WHERE id = 1;

UPDATE diningTable SET state = '空',orderName = '',orderTel = '' WHERE id = 1;
  1. 创建菜单表menu
-- 创建 menu表	菜单表
CREATE TABLE menu(
	id INT PRIMARY KEY AUTO_INCREMENT,-- 菜谱编号,主键自增
	NAME VARCHAR(32)NOT NULL DEFAULT '',-- 菜品名称
	TYPE VARCHAR(32)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;
  1. 创建账单bill
-- 创建账单bill表(id,billId,menuId,nums,billDate,money,state,diningTableId)
-- 编号   菜品号   菜品量   金额  桌号  日期   状态

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;

DROP TABLE bill;

SELECT * FROM bill;

-- 验证用
SELECT * FROM bill WHERE diningTableId = 1 AND state = '未结账' LIMIT 0,1;
SELECT * FROM bill WHERE diningTableId = ? AND state = '未结账' LIMIT 0,1;
domain类
  1. Employee类
package com.song.mhl.domain;

/**
 * 这是一个javabean和employee对应
 *
 * 	id INT PRIMARY KEY AUTO_INCREMENT,-- 主键id,自增
 * 	empid VARCHAR(32) NOT NULL DEFAULT '',-- 员工号
 * 	pwd CHAR(32) NOT NULL DEFAULT '',-- 密码
 * 	NAME VARCHAR(32) NOT NULL DEFAULT '',-- 名字
 * 	job VARCHAR(32) NOT NULL DEFAULT ''-- 职位
 */
public class Employee {
    private Integer id;
    private String empid;
    private String pwd;
    private String name;
    private String job;

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

    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;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", empid='" + empid + '\'' +
                ", pwd='" + pwd + '\'' +
                ", name='" + name + '\'' +
                ", job='" + job + '\'' +
                '}';
    }
}

  1. DiningTable类
package com.song.mhl.domain;

/**
 * 这是一个javabean和diningTable对应
 * <p>
 * id INT PRIMARY KEY AUTO_INCREMENT, -- 自增, 表示餐桌编号
 * state VARCHAR(20) NOT NULL DEFAULT '',-- 餐桌的状态
 * orderName VARCHAR(50) NOT NULL DEFAULT '',-- 预订人的名字
 * orderTel VARCHAR(20) NOT NULL DEFAULT ''-- 订餐人的电话
 */
public class DiningTable {
    private Integer id;
    private String state;
    private String orderName;
    private String orderTel;

    //无参构造器,底层apache-dbutils反射必须需要
    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 ;
    }
}
  1. menu类
package com.song.mhl.domain;

/**
 * 这是一个javabean和menu对应
 *
 * 	id INT PRIMARY KEY AUTO_INCREMENT,-- 菜谱编号,主键自增
 * 	NAME VARCHAR(32)NOT NULL DEFAULT '',-- 菜品名称
 * 	TYPE VARCHAR(32)NOT NULL DEFAULT '',-- 菜品种类
 * 	price DOUBLE NOT NULL DEFAULT 0 -- 价格
 */
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\t" + name +
                "\t\t" + type +
                "\t\t" + price ;
    }
}
  1. bill类
package com.song.mhl.domain;

import com.song.mhl.service.DiningTableService;
import com.song.mhl.service.MenuService;

import java.util.Date;

/**
 * 这是一个javabean和bill对应
 * <p>
 * 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 '' # 状态 '未结账' , '已经结账', '挂单','现金','支付宝'
 */
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;

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

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

    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\t" + menuId +
                "\t\t\t" + nums +
                "\t\t\t" + money +
                "\t\t" + diningTableId +
                "\t\t\t" + billDate +
                "\t\t" + state;
    }
}
DAO类
  1. 父类BasicDAO
package com.song.mhl.dao;


import com.song.mhl.utils.JDBCUtilsByDruid;
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 的父类
 */
public class BasicDAO<T> {//泛型指定具体类型

    private QueryRunner qr = new QueryRunner();

    //开发通用的 dml 方法,针对任意的表
    public int update(String sql,Object...parameters){

        Connection connection = null;

        try {
            connection = JDBCUtilsByDruid.getConncteion();
            int update = qr.update(connection, sql, parameters);
            return update;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            JDBCUtilsByDruid.close(null,null,connection);
        }
    }

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

    //查询单行结果的通用方法
    public T querySingle(String sql,Class<T> clazz,Object...parameters){
        Connection connection = null;
        try {
            connection = JDBCUtilsByDruid.getConncteion();
            return qr.query(connection,sql,new BeanHandler<T>(clazz),parameters);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            JDBCUtilsByDruid.close(null,null,connection);
        }
    }

    //查询单行单列结果的通用方法,即返回单值的方法
    public Object queryScalar(String sql,Object...parameters){
        Connection connection = null;
        try {
            connection = JDBCUtilsByDruid.getConncteion();
            return qr.query(connection,sql,new ScalarHandler(),parameters);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            JDBCUtilsByDruid.close(null,null,connection);
        }
    }
}
  1. 子类EmployeeDAO
package com.song.mhl.dao;

import com.song.mhl.domain.Employee;

public class EmployeeDAO extends BasicDAO<Employee>{
    //这里还可以写特有的操作
}
  1. 子类DiningTableDAO
package com.song.mhl.dao;

import com.song.mhl.domain.DiningTable;

public class DiningTableDAO extends BasicDAO<DiningTable>{
    //还可以添加自己特有的方法
}
  1. 子类MenuDAO
package com.song.mhl.dao;

import com.song.mhl.domain.Menu;

import java.util.List;

public class MenuDAO extends BasicDAO<Menu>{
    //这里还可以写特有的操作

}
  1. 子类BillDAO
package com.song.mhl.dao;

import com.song.mhl.domain.Bill;

public class BillDAO extends BasicDAO<Bill>{
    //这里还可以写特有的操作
}
Service类
  1. EmployeeService类
package com.song.mhl.service;

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

/**
 * 该类完成对employee表的各种操作(通过调用EmployeeDAO对象完成)
 */
public class EmployeeService {
    //定义一个EmployeeDAO属性
    private EmployeeDAO employeeDAO = new EmployeeDAO();

    //写一个方法,根据empid和pwd返回一个Employee对象
    public Employee getEmployeeByIdAndPwd(String empid,String pwd){
        Employee employee = employeeDAO.querySingle
                ("select * from employee where empid = ? and pwd = md5(?)", Employee.class, empid, pwd);
        return employee;
    }
}
  1. DiningTableService类
package com.song.mhl.service;

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

import java.util.List;

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

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

    //根据id检测餐桌是否存在
    //如果DiningTable对象为空,表示id编号对应的餐桌不存在
    public DiningTable getDiningTableById(int id){
        //小技巧:每次写完SQL语句,把SQL语句放在查询分析器测试一下
        DiningTable diningTable = diningTableDAO.querySingle
                ("select * from diningTable where id = ?", DiningTable.class, id);
        return diningTable;
        //或者直接写为一句
        /*
        return diningTableDAO.querySingle
           ("select * from diningTable where id = ?", DiningTable.class, id);
         */
    }

    //如果餐桌可以预定,创建一个方法,对其状态进行更新(包括预订人的名字和电话)
    public boolean orderDiningTable(int id,String state,String orderName,String orderTel){
        int update = diningTableDAO.update
                ("update diningTable set state = '已经预定',orderName = ?,orderTel = ? " +
                        "where id = ?", orderName, orderTel,id);
        return update > 0;
    }

    //需要提供一个更新 餐桌状态的方法,用于BillService
    public boolean updateDiningTableState(int id,String state){
        int update = diningTableDAO.update("update diningTable set state = ? where id = ?", state, id);
        return update > 0;
    }

    //提供方法,将指定的餐桌设置为空闲状态
    public boolean updateDiningTableToFree(int id,String state){
        int update = diningTableDAO.update("update diningTable set state = ?,orderName = '',orderTel = '' where id = ?", state, id);
        return update > 0;
    }
}
  1. MenuService类
package com.song.mhl.service;

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

import java.util.List;

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

    //返回所有菜单
    public List<Menu> list() {
        return menuDAO.queryMulti("select * from menu", Menu.class);
    }

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

    }
}
  1. BillService类
package com.song.mhl.service;

import com.song.mhl.dao.BillDAO;
import com.song.mhl.domain.Bill;

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

/**
 * 该类完成对bill表的各种操作(通过调用BillDAO对象完成)
 */
public class BillService {
    //定义一个BillDAO对象
    private BillDAO billDAO = new BillDAO();

    //定义一个MenuService对象
    private MenuService menuService = new MenuService();

    //定义一个DiningTableService对象
    private DiningTableService diningTableService = new DiningTableService();

    //思路
    //编写点餐的方法
    //1.生成账单
    //2.需要更新对应餐桌的状态
    //3.如果成功返回true,否则返回false
    public boolean orderMenu(int menuId,int nums,int diningTableId){
        //生成一个账单号   通过UUID
        //UUID.randomUUID().toString(); 每次随机生成一个id且不重复
        String billId = UUID.randomUUID().toString();

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

        //3.做一个判断
        if (update<=0){
            return false;
        }

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

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

    //结账功能的思路:
    //1. 对餐桌号进行校验
    //2. 修改bill表的state
    //3. 修改diningTable信息

    //1. 对餐桌号进行校验
    //查看某个餐桌是否有未结账的账单
    public boolean hasPayBillByDiningTable(int diningTableId){
        Bill bill = billDAO.querySingle
                ("SELECT * FROM bill WHERE diningTableId = ? AND state = '未结账' LIMIT 0,1", Bill.class,diningTableId);
        return bill != null;
    }

    //完成结账【如果餐桌存在,并且该餐桌有未结账的账单】
    //如果成功,返回true,失败则返回false
    public boolean payBill(int diningTableId,String payMode){
        //这里也可以用事物来解决
        //如果这里使用事务的话,需要用ThreadLocal来解决 , 框架中比如mybatis 提供了事务支持

        //2. 修改bill表的state
        int update = billDAO.update("update bill set state = ? where diningTableId = ? and state = '未结账'",payMode,diningTableId);
        if (update <= 0){//如果更新没有成功,则表示失败
            return false;
        }
        //3. 修改diningTable信息
        //注意:不要直接在这里操作,而应该调用DiningTableService方法完成更新,体现各司其职
        if (!(diningTableService.updateDiningTableToFree(diningTableId,"空"))){
            return false;
        }

        //如果上面两项都成功,则返回true
        return true;
    }
}
界面层
  1. 最后的界面层MHLView
package com.song.mhl.view;

import com.song.mhl.domain.Bill;
import com.song.mhl.domain.DiningTable;
import com.song.mhl.domain.Employee;
import com.song.mhl.domain.Menu;
import com.song.mhl.service.BillService;
import com.song.mhl.service.DiningTableService;
import com.song.mhl.service.EmployeeService;
import com.song.mhl.service.MenuService;
import com.song.mhl.utils.Utility;

import java.util.List;

public class MLHView {
    //控制是否退出菜单
    private boolean loop = true;
    //接收用户选择
    private String key = "";

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

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

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

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

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

    //定义二级菜单方法,进行封装

    //1.显示所有餐桌的状态
    //写在一个方法里面进行封装
    public void listDiningTable() {
        List<DiningTable> list = diningTableService.list();
        System.out.println("\n餐桌编号\t\t餐桌编号");
        for (DiningTable diningTable : list) {
            System.out.println(diningTable);
        }
        System.out.println("=================显示完毕=================");
    }

    //2.完成订座
    public void orderDiningTable() {
        System.out.println("=================预订餐桌=================");
        System.out.println("请选择要预定餐桌编号(-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 diningTableById = diningTableService.getDiningTableById(orderId);
            if (diningTableById == null) {
                System.out.println("==============预订餐桌不存在==============");
                return;
            }

            //如果DiningTable对象不为null,那么判断餐桌的状态是否为"空"
            if (!("空".equals(diningTableById.getState()))) {//取反
                System.out.println("==============餐桌已经被预定==============");
                return;
            }

            //如果上述两种情况都不存在,则可以进行预定
            //1.接收预定信息
            System.out.println("预订人名字:");
            String orderName = Utility.readString(32);
            System.out.println("预订人电话:");
            String orderTel = Utility.readString(32);
            //2.更新餐桌状态
            if (diningTableService.orderDiningTable(orderId, "已经预定", orderName, orderTel)) {
                System.out.println("=================预订成功=================");
            } else {
                System.out.println("=================预订失败=================");
            }

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

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

    //4.完成点餐
    public void orderMenu() {
        System.out.println("=================点餐服务=================");
        System.out.println("请选择点餐的桌号(-1退出):");
        int orderDiningTableId = Utility.readInt();
        if (orderDiningTableId == -1) {
            System.out.println("=================取消点餐=================");
            return;
        }
        System.out.println("请选择菜品的编号(-1退出):");
        int orderMenuId = Utility.readInt();
        if (orderMenuId == -1) {
            System.out.println("=================取消点餐=================");
            return;
        }
        System.out.println("请选择菜品的数量(-1退出):");
        int orderNums = Utility.readInt();
        if (orderNums == -1) {
            System.out.println("=================取消点餐=================");
            return;
        }

        //验证餐桌号是否存在
        DiningTable diningTableById = diningTableService.getDiningTableById(orderDiningTableId);
        if (diningTableById == null) {
            System.out.println("===============餐桌号不存在===============");
            return;
        }

        //验证菜品编号
        Menu menu = menuService.getMenuById(orderMenuId);
        if (menu == null) {
            System.out.println("===============菜品号不存在===============");
            return;
        }

        //进行点餐
        //该方法得到的是 Y 或者 N
        char key = Utility.readConfirmSelection2();
        if (key == 'Y') {
            billService.orderMenu(orderMenuId, orderNums, orderDiningTableId);
            System.out.println("=================点餐成功=================");
        } else if (key == 'N') {
            System.out.println("=================取消点餐=================");
            return;
        } else {
            System.out.println("=================点餐失败=================");
        }
    }

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

    //6.结账
    public void payBill() {
        System.out.println("=================结账服务=================");
        System.out.println("请选择要结账的餐桌编号(-1退出):");
        int diningTableId = Utility.readInt();
        if (diningTableId == -1) {
            System.out.println("=================取消结账=================");
            return;
        }

        //验证餐桌是否存在
        DiningTable diningTableById = diningTableService.getDiningTableById(diningTableId);
        if (diningTableById == null) {
            System.out.println("=============结账的餐桌不存在=============");
            return;
        }
        //验证是否有未结账的餐桌
        if (!billService.hasPayBillByDiningTable(diningTableId)) {
            System.out.println("===========该餐位没有未结账账单===========");
            return;
        }

        //如果上述两个都过了,说明存在未结账的账单

        System.out.println("结账的方式(现金/支付宝/微信)回车表示退出");
        //Utility.readString(10,"")里的""代表如果回车,则表示空串
        String payMode = Utility.readString(10, "");

        //限定结账方式,不能输入别的
        if (!("现金".equals(payMode)||"支付宝".equals(payMode)||"微信".equals(payMode)||"".equals(payMode))){
            System.out.println("=================结账失败=================");
            return;
        }
        if ("".equals(payMode)) {
            System.out.println("=================取消结账=================");
            return;
        }
        //进行选择  确认是否结账(Y/N):
        //该方法得到的是 Y 或者 N
        char key = Utility.readConfirmSelection3();
        if (key == 'Y') {
            //调用billService中的完成结账方法
            if (billService.payBill(diningTableId, payMode)) {
                System.out.println("=================结账完成=================");
            } else {
                System.out.println("=================结账失败=================");
            }
        } else if (key == 'N') {
            System.out.println("=================取消结账=================");
        } else {
            System.out.println("=================结账失败=================");
        }
    }
    
    //显示主菜单
    public void mainMenu() {
        while (loop) {
            System.out.println("===================满汉楼===================");
            System.out.println("\t\t\t 1 登录满汉楼");
            System.out.println("\t\t\t 2 退出满汉楼");
            System.out.println("请输入你的选择:");
            key = Utility.readString(1);

            switch (key) {
                case "1":
                    System.out.println("请输入员工号:");
                    String empid = Utility.readString(32);
                    System.out.println("请输入密  码:");
                    String pwd = Utility.readString(32);
                    //到数据库来验证
                    Employee employee = employeeService.getEmployeeByIdAndPwd(empid, pwd);
                    if (employee != null) {
                        System.out.println("==================登录成功==================");
                        //显示二级菜单,这里二级菜单也是循环,用while
                        while (loop) {
                            System.out.println("===============满汉楼二级菜单===============");
                            System.out.println("\t\t\t 1 显示餐桌状态");
                            System.out.println("\t\t\t 2 预定餐桌");
                            System.out.println("\t\t\t 3 显示所有菜品");
                            System.out.println("\t\t\t 4 点餐服务");
                            System.out.println("\t\t\t 5 查看账单");
                            System.out.println("\t\t\t 6 结账");
                            System.out.println("\t\t\t 9 退出满汉楼");
                            System.out.println("请输入你的选择:");
                            String key = Utility.readString(1);
                            switch (key) {
                                case "1":
                                    System.out.println("显示餐桌状态");
                                    //将下面的代码封装到一个方法里面
                                    //增强代码的阅读性和可维护性
                                    listDiningTable();
                                    /*
                                    //查询表格
                                    //餐桌状态   餐桌编号
                                    List<DiningTable> list = diningTableService.list();
                                    System.out.println("\n餐桌编号\t\t餐桌编号");
                                    for (DiningTable diningTable:list) {
                                        System.out.println(diningTable);
                                    }
                                    System.out.println("=================显示完毕=================");
                                     */
                                    break;
                                case "2":
                                    orderDiningTable();
                                    break;
                                case "3":
                                    listMenu();
                                    //菜品编号   菜品名   类别   价格
                                    //查询数据库表格
                                    break;
                                case "4":
                                    orderMenu();
                                    break;
                                case "5":
                                    listBill();
                                    //编号   菜品号   菜品量   金额  桌号  日期   状态
                                    //查询数据库表格
                                    break;
                                case "6":
                                    payBill();
                                    break;
                                case "9":
                                    loop = false;
                                    break;
                                default:
                                    System.out.println("你的输入有误,请重新输入!");
                            }
                        }
                        System.out.println("退出满汉楼");
                    } else {
                        System.out.println("==================登录失败==================");
                    }
                    break;
                case "2":
                    loop = false;
                    break;
                default:
                    System.out.println("输入有误,请重新输入!");
            }
        }
        System.out.println("退出满汉楼");
    }
}

6. 拓展思考

思考一:多表查询

1. 如果多表查询怎么处理?

  1. 如果查看账单时,希望显示菜品名称,怎么办呢?

  2. 处理方式一:

    1. 单独创建一个MultiTableBean类

      package com.song.mhl.domain;
      
      import com.song.mhl.service.DiningTableService;
      import com.song.mhl.service.MenuService;
      
      import java.util.Date;
      
      /**
       * 这是一个Javabean 可以和多张表进行对应
       */
      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
          private String name;
      
          //定义一个DiningTableService属性
          private DiningTableService diningTableService = new DiningTableService();
      
          //定义一个MenuService属性
          private MenuService menuService = new MenuService();
      
          public MultiTableBean() {
          }
      
          public MultiTableBean(Integer id, String billId, Integer menuId, Integer nums, Double money,
                                Integer diningTableId, Date billDate, String state, String name) {
              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;
          }
      
          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;
          }
      
          //给name生成一个setter和getter方法
      
          public String getName() {
              return name;
          }
      
          public void setName(String name) {
              this.name = name;
          }
      
          @Override
          public String toString() {
              return id +
                      "\t\t\t" + menuId +
                      "\t\t\t" + nums +
                      "\t\t\t" + money +
                      "\t\t" + diningTableId +
                      "\t\t\t" + billDate +
                      "\t\t" + state +
                      "\t\t" + name;
          }
      }
      
    2. 这个类的属性来自于mysql里面多张表的字段

    3. 然后创建子类MultiTableDAO继承父类BasicDAO

      package com.song.mhl.dao;
      
      import com.song.mhl.domain.MultiTableBean;
      
      public class MultiTableDAO extends BasicDAO<MultiTableBean>{
      }
      
    4. 提供给业务层使用,完成某个具体的业务需求

      //定义一个MultiTableDAO
      private MultiTableDAO multiTableDAO = new MultiTableDAO();
      
      //返回所有的账单并带有菜品,提供给View使用
          public List<MultiTableBean> list2(){
              return multiTableDAO.queryMulti
                      ("SELECT bill.*,NAME FROM bill,menu WHERE bill.id = menu.id",MultiTableBean.class);
          }
      
    5. 最后在界面层使用

      public void listBill() {
              /*
              System.out.println("编号\t\t菜品号\t\t菜品量\t\t金额\t\t桌号\t\t日期\t\t\t\t\t\t状态");
              List<Bill> list = billService.list();
              for (Bill bill : list) {
                  System.out.println(bill);
              }
               */
              //用于多表查询
              System.out.println("编号\t\t菜品号\t\t菜品量\t\t金额\t\t桌号\t\t日期\t\t\t\t\t\t状态\t\t菜品名");
              List<MultiTableBean> list = billService.list2();
              for (MultiTableBean multiTableBean : list) {
                  System.out.println(multiTableBean);
              }
              System.out.println("=================显示完毕=================");
          }
      
    6. 下图所示

  3. 处理方式二:

    1. 使用MapListHandler最终返回List<map<String,Object>>,使用迭代的方式通过查询字段取出value,首先根据Department类中的key从map中取出对应的value,将其封装为Department对象。最终再封装为Employee对象,这样就解决了使用BeanListHandler出现空指针异常的现象。

2. 多表查询细节

  1. 上面那个方法可以处理多表查询,但是如果我们后面要查询的字段越来越多,一直在一个类里面添加太麻烦,可以将MultiTableBean拆分成几个类,例如MultiTableBean1、MultiTableBean2等;

  1. 当我们多表查询的时候,创建的MultiTableBean类里面的属性名是否一定要跟表的列名一致呢?
    1. 情况一:当我们的SQL语句中就是用的原先表的列名的时候,属性名必须一致
    2. 情况二:当我们定义的属性名与原先表的列名不一致的时候,我们在SQL语句中要给相对应的列名取一个别名,这个别名要跟我们定义的属性名一致;
    3. 所以是可以不一致的,但是我们建议最好一致

思考二:分表设计

  1. 我们在创建员工表的时候,员工的信息字段可能会很多,而且员工数也会有很多,那样的话效率会比较低。
  2. 所以为了提高效率,我们可以采用分表设计:employee和login;

思考三:更多功能

思考:完成更多功能,登录管理、人事管理、统计报表、成本控制

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/36617.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

flutter聊天界面-聊天气泡长按弹出复制、删除按钮菜单

flutter聊天界面-聊天气泡长按弹出复制、删除按钮菜单 在之前实现了flutter聊天界面的富文本展示内容&#xff0c;这里记录一下当长按聊天气泡的时候弹出复制、删除等菜单功能 一、查看效果 当长按聊天气泡的时候弹出复制、删除等菜单&#xff0c;可新增更多按钮 二、代码实现…

2023/7/8总结

Tomcat 启动&#xff1a;双击bin目录下的startup.bat文件停止&#xff1a;双击bin目录下的shutdown.bat 文件访问 &#xff1a;http://localhost:8080&#xff08;默认是8080&#xff0c;可以修改&#xff09; git的使用 打开git bash git config --global user.name "名…

OpenCV读取一张深度图像并显示

#include <iostream> #include <opencv2/imgcodecs.hpp> #include <opencv2/opencv.hpp> #include

服务端研发提测模板

test环境分支自测通过 提测邮件标注test环境分支 【xxxxxx需求】服务端研发提测了&#xff0c;快去测试吧!

第十二章 elk

1、ELK可以帮助我们解决哪些问题 日志分布在多台不同的服务器上,业务一旦出现故障,需要一台台查看日志 单个日志文件巨大,无法使用常用的文本工具分析,检索困难; 2、架构设计分析 Filebeat和Logstash ELK架构中使用Logstash收集、解析日志,但是Logstash对内存、cpu、i…

简述JMeter实现分布式并发及操作

为什么要分布式并发&#xff1f; JMeter性能实践过程中&#xff0c;一旦进行高并发操作时就会出现以下尴尬场景&#xff0c;JMeter客户端卡死、请求错误或是超时等&#xff0c;导致很难得出准确的性能测试结论。 目前知道的有两个方法可以解决JMeter支撑高并发&#xff1a; …

【ELK企业级日志分析系统】部署Filebeat+ELK详解

部署FilebeatELK详解 1. 部署Filebeat节点&#xff08;CentOS 7-4&#xff09;1.1 部署Apache服务1.2 部署Filebeat服务 2. filter插件2.1 grok正则捕获插件2.1.1 内置正则表达式调用2.1.2 自定义表达式调用2.1.3 设置正则表达式过滤条件 2.2 mutate数据修改插件2.2.1 Mutate过…

抖音seo矩阵系统源码|需求文档编译说明(二)

目录 1.抖音seo矩阵系统文档开发流程 2.各平台源码编译方式说明 3.底层技术功能表达式 1.抖音seo矩阵系统文档开发流程 ①产品原型 ②需求文档 ③产品流程图 ④部署方式说明 ⑤完整源码 ⑥源码编译方式说明 ⑦三方框架和SDK使用情况说明和代码位置 ⑧平台操作文档 ⑨程序架…

Ubuntu 20.04 L2TP VPN 自动重连脚本,cron定时任务设置

1、连接VNP脚本 reconnect_l2tp_vpn.sh #!/bin/sh ppp0_flagifconfig | grep ppp0 echo $ppp0_flag if [ -z "$ppp0_flag" ];thenecho "connet to vpn ..."# connet vpn# echo PASSWORD &#xff5c; sudo -S 这样可以不用手动输入密码!echo abc123| su…

IDEA集成Maven

目录 配置Maven环境 创建Maven项目 Maven坐标 导入Maven项目 Maven依赖管理&#xff08;核心&#xff09; 配置Maven环境 两种方法 每没创建一个maven项目都需要在项目中配置一遍在所有设置中进行全局设置&#xff0c;适用于所有的maven项目 步骤 在idea的初始界面中找到所…

【雕爷学编程】Arduino动手做(158)---VL53L0X激光测距模块

37款传感器与执行器的提法&#xff0c;在网络上广泛流传&#xff0c;其实Arduino能够兼容的传感器模块肯定是不止这37种的。鉴于本人手头积累了一些传感器和执行器模块&#xff0c;依照实践出真知&#xff08;一定要动手做&#xff09;的理念&#xff0c;以学习和交流为目的&am…

【Django学习】(十二)GenericAPIView_过滤_排序_分页

上篇文章初步接触了GenericAPIView&#xff0c;这次来更加深入的学习它&#xff0c;了解里面的一些使用和方法 get_object&#xff1a;源码中&#xff1a;处理查询集&#xff0c;并含有所需要得pk值,lookup_fieldget_queryset&#xff1a;源码中&#xff1a;先判断queryset是否…

可使用Linux 测试IP和端口是否能访问,查看返回状态码

一、 使用wget判断 wget是linux下的下载工具&#xff0c;需要先安装. 用法: wget ip:port wget ip:port连接存在的端口 二、使用telnet判断 telnet是windows标准服务&#xff0c;可以直接用&#xff1b;如果是linux机器&#xff0c;需要安装telnet. 用法: telnet ip port…

uniapp电子签名以及竖屏签名后内容旋转90度变为横屏图片

用该插件挺不错的 电子签名插件地址 如果你一个页面要用多个该插件&#xff0c;就改成不同的cavas-id&#xff0c;修改插件源码 效果图 竖屏写 旋转成横屏图片 插件内 在拿到签名临时地址后的页面 <!-- 旋转图片canvas --> <canvas canvas-id"camCacnvs&quo…

MySQL-SQL存储函数以及触发器详解

♥️作者&#xff1a;小刘在C站 ♥️个人主页&#xff1a; 小刘主页 ♥️努力不一定有回报&#xff0c;但一定会有收获加油&#xff01;一起努力&#xff0c;共赴美好人生&#xff01; ♥️学习两年总结出的运维经验&#xff0c;以及思科模拟器全套网络实验教程。专栏&#xf…

15 Java 使用for进行死循环

括号里直接写两个分号即可。for(;;) package demo;public class Demo8 {public static void main(String[] args) {for (;;){System.out.println("你是最棒的&#xff01;");}} }

springboot高校党务系统

开发语言&#xff1a;Java 框架&#xff1a;springboot JDK版本&#xff1a;JDK1.8 服务器&#xff1a;tomcat7 数据库&#xff1a;mysql 5.7 数据库工具&#xff1a;Navicat11 开发软件&#xff1a;eclipse/myeclipse/idea Maven包&#xff1a;Maven3.3.9

神经网络解决预测问题(以共享单车预测为例)

背景:大约从2015年起,共享单车席卷了大部分城市。共享单车在给人们带来便利的同时,也存在一些问题:单车的分布很不均匀。比如在早高峰的时候,一些地铁口往往聚集着大量的单车,而到了晚高峰却很难找到一辆单车了。那么如何解决共享单车分布不均匀的问题呢?目前,共享单车…

Docker镜像

是什么 是一种轻量级、可执行的独立软件包&#xff0c;它包含运行某个软件所需的所有内容&#xff0c;我们把应用程序和配置依赖打包好形成一个可交付的运行环境(包括代码、运行时需要的库、环境变量和配置文件等)&#xff0c;这个打包好的运行环境就是image镜像文件。 只有通…

离散化模板(附 区间和 解决方法)

目录 用于解决的问题类型&#xff1a; 作用&#xff1a; 使用到的函数&#xff1a; 常用模板&#xff1a; 例题引入&#xff1a; 题目&#xff1a; 解题思路&#xff1a; 代码详解&#xff1a; 用于解决的问题类型&#xff1a; 对于值域比较大&#xff0c;但个数比较少…