最基础的是创建一个数据库，用来存储要用到的数据
#创建数据库 CREATE DATABASE IF NOT EXISTS ChiHuoSystem;
#订单序号（id）、订餐人姓名（name）、菜品信息（dishMegs）、送餐时间（time）、 #送餐地址（addresses）、订单状态（states）、订单总价格（sumPrices） #创建Order表，将id设置为自增长，其他均设置为非空
CREATE TABLE IF NOT EXISTS order
( id INT PRIMARY KEY AUTO_INCREMENT,
name VARCHAR(10) NOT NULL,
dishMegs VARCHAR(20) NOT NULL,
fen INT NOT NULL,
time INT,
addresses VARCHAR(30) NOT NULL,
states INT NOT NULL COMMENT '只能填写1(已完成)或0(未完成)',
sumPrices DOUBLE NOT NULL );
#菜品序号（cid）、菜品名称（dishNames）、菜品单价（prices）、菜品点赞数（praiseNum） #初始化两条订单信息，向表中插入，使用不带字段名的插入方式，需和表中字段名顺序一致 INSERT INTO order VALUES(1,'张三','红烧肉',2,12,'北大青鸟',1,60);
INSERT INTO order VALUES(2,'李四','鱼香肉丝',2,18,'怡园小区',1,56);
#创建Food表，将cid设置为自增长，其他均设置为非空order
CREATE TABLE IF NOT EXISTS food
( cid INT PRIMARY KEY AUTO_INCREMENT,
dishNames VARCHAR(20) NOT NULL,
prices DOUBLE NOT NULL,
praiseNum INT NOT NULL COMMENT '点赞数' );
#罗列三个菜的菜品信息，菜的名称，单价，点赞数,插入表中，使用不带字段名的插入方式(多条一起插入)，需和表中字段名顺序一致
INSERT INTO food VALUES(1,'红烧肉',30,70);
INSERT INTO food VALUES(2,'西红柿炒蛋',18,99);
INSERT INTO food VALUES(3,'鱼香肉丝',28,66);
INSERT INTO food VALUES(4,'特色地锅鸡',79,289);
之后就是Java代码的编写部分：
首先创建一个项目chlm-ApacheDBUtils，并在新建一个lib目录导入三个jar包commons-dbutils-1.7 (1).jar，druid-1.2.8 (1).jar，mysql-connector-j-8.0.33.jar。并将三个jar包添加为库。
第二步：在默认文件src文件下创建一个包，包名自定义，再创建一个db.properties文件，里面是关于数据库访问文件的配置。然后在包里创建5个包，分别为Dao包(Data Access Object的缩写，代表数据访问对象层，主要负责与数据库进行交互，封装了与数据库的连接、查询、更新等操作。)，entity包(实体层，放置一个个实体类，这些类通常对应于数据库中的表，包含了表中的字段和相关的getter和setter方法。)，service包(业务逻辑层，封装了数据库底层操作的更高级的操作，将Dao层和Entity层整合起来，进行再次封装，封装成一个方法，以便于业务逻辑的实现)，utils包(工具类层，包含一些常用的工具方法，如字符串处理、日期处理、文件操作等，用于辅助开发人员快速完成开发任务。 )，view包(表示层，存放与用户界面相关的类或组件，有时也用于存放DTO（Data Transfer Object）或VO（Value Object），用于数据的传输和展示,这里一般用来作为测试类)。
driver=com.mysql.cj.jdbc.Driver url=jdbc:mysql://localhost:3306/chihuosystem username=root password=CSY123 # ???????????????这里粘贴过去就是会变乱码，不过是注释无所谓 initialSize=10 #????? maxActive=30 #?????? maxIdle=5 #????????????? maxWait=3000
我这里用的数据库是8.0版本的，所以数据库注册驱动是com.mysql.cj.jdbc.Driver，地址是本地地址加数据库，mysql一般默认3306.不同版本不一样，同时用户名密码也是自己设置的。
然后就是要先创建第二个包，实体类的包
分别根据数据库提供的数据创建出两个实体类，分别为Food和Order类
public class Food {
private int cid;
private String dishNames;
private double prices;
private int praiseNum;
public Food() {
}
//不包含cid的构造方法
public Food(String dishNames, double prices, int praiseNum) {
this.dishNames = dishNames;
this.prices = prices;
this.praiseNum = praiseNum;
}
//包含cid的构造方法
public Food(int cid, String dishNames, double prices, int praiseNum) {
this.cid = cid;
this.dishNames = dishNames;
this.prices = prices;
this.praiseNum = praiseNum;
}
//只含cid和的praiseNum的构造方法
public Food(int cid, int praiseNum) {
this.cid = cid;
this.praiseNum = praiseNum;
}
public int getCid() {
return cid;
}
public void setCid(int cid) {
this.cid = cid;
}
public String getDishNames() {
return dishNames;
}
public void setDishNames(String dishNames) {
this.dishNames = dishNames;
}
public double getPrices() {
return prices;
}
public void setPrices(double prices) {
this.prices = prices;
}
public int getPraiseNum() {
return praiseNum;
}
public void setPraiseNum(int praiseNum) {
this.praiseNum = praiseNum;
}
@Override
public String toString() {
return "Food{" +
"cid=" + cid +
", dishNames='" + dishNames + '\'' +
", prices=" + prices +
", praiseNum=" + praiseNum +
'}';
}
}
public class Order {
private int id;
private String name;
private String dishMegs;
private int fen;
private int time;
private String addresses;
private int states;
private double sumPrices;
//定义构造方法
public Order() {
}
//不包含id的构造方法
public Order(String name, String dishMegs, int fen, int time, String addresses, int states, double sumPrices) {
this.name = name;
this.dishMegs = dishMegs;
this.fen = fen;
this.time = time;
this.addresses = addresses;
this.states = states;
this.sumPrices = sumPrices;
}
//包含id的构造方法
public Order(int id, String name, String dishMegs, int fen, int time, String addresses, int states, double sumPrices) {
this.id = id;
this.name = name;
this.dishMegs = dishMegs;
this.fen = fen;
this.time = time;
this.addresses = addresses;
this.states = states;
this.sumPrices = sumPrices;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDishMegs() {
return dishMegs;
}
public void setDishMegs(String dishMegs) {
this.dishMegs = dishMegs;
}
public int getFen() {
return fen;
}
public void setFen(int fen) {
this.fen = fen;
}
public int getTime() {
return time;
}
public void setTime(int time) {
this.time = time;
}
public String getAddresses() {
return addresses;
}
public void setAddresses(String addresses) {
this.addresses = addresses;
}
public int getStates() {
return states;
}
public void setStates(int states) {
this.states = states;
}
public double getSumPrices() {
return sumPrices;
}
public void setSumPrices(double sumPrices) {
this.sumPrices = sumPrices;
}
@Override
public String toString() {
return "Order{" +
"id=" + id +
", name='" + name + '\'' +
", dishMegs='" + dishMegs + '\'' +
", fen=" + fen +
", time=" + time +
", addresses='" + addresses + '\'' +
", states=" + states +
", sumPrices=" + sumPrices +
'}';
}
}
这里注意生成构造方法的时候要生成带主键和不带主键的。
然后就是创建Dao包，分别根据实体类创建两个daoimpl包，分别对应两个接口的实现类，也就是编写2个实体类的接口，并将接口的实现类定义出来。FoodDaoImpl.java。OrderDaoImpl.java。FoodDao.java。OrderDao.java。
public interface FoodDao {
// 定义更新点赞数的方法
int update(Food food);
// 定义查询单个食品的方法
Food selectOneFood(int cid);
// 定义查询所有食品的方法
List<Food> selectAllFood();
}
public interface OrderDao {
// 定义添加订单的方法
int insert(Order order);
// 定义删除订单的方法
int delete(int id);
// 定义修改订单的方法
int update(Order order);
// 定义查询单个订单的方法
Order selectOneOrder(int id);
// 定义查询所有订单的方法
List<Order> selectAllOrder();
}
public class FoodDaoImpl implements FoodDao {
// 创建QueryRunner对象，需要传递数据源
private QueryRunner queryRunner = new QueryRunner(DBUtils.getDataSource());
// 实现更新点赞数的方法
@Override
public int update(Food food) {
// 准备SQL更新语句
String sql = "update `food` set praiseNum=? where cid=?";
// 准备参数数组
Object[] args = {food.getPraiseNum(), food.getCid()};
try {
// 执行更新操作，返回受影响的行数
return queryRunner.update(sql, args);
} catch (SQLException e) {
// 异常处理，抛出运行时异常
throw new RuntimeException(e);
}
}
// 实现查询单个食品的方法
@Override
public Food selectOneFood(int cid) {
// 创建BeanHandler对象，用于处理查询结果
BeanHandler<Food> beanHandler = new BeanHandler<Food>(Food.class);
// 准备SQL查询语句
String sql = "select * from `food` where cid=?";
try {
// 执行查询操作，返回单个Food对象
return queryRunner.query(sql, beanHandler, cid);
} catch (SQLException e) {
// 异常处理，抛出运行时异常
throw new RuntimeException(e);
}
}
// 实现查询所有食品的方法
@Override
public List<Food> selectAllFood() {
// 创建BeanListHandler对象，用于处理查询结果
BeanListHandler<Food> beanListHandler = new BeanListHandler<Food>(Food.class);
// 准备SQL查询语句
String sql = "select * from `food`";
try {
// 执行查询操作，返回Food对象列表
return queryRunner.query(sql, beanListHandler);
} catch (SQLException e) {
// 异常处理，抛出运行时异常
throw new RuntimeException(e);
}
}
}
public class OrderDaoImpl implements OrderDao {
//定义一个私有对象，方便后面的方法的调用,且传递一个数据源对象
private QueryRunner queryRunner=new QueryRunner(DBUtils.getDataSource());
//增删改调用update的方法，查询调用Query方法
//方法一 添加订单数据
@Override
public int insert(Order order) {
//准备sql语句,id是自增长
String sql="insert into `Order` (name,dishMegs,fen,time,addresses,states,sumPrices) values(?,?,?,?,?,?,?)";
//准备一个可变数组,对占位符进行赋值，占位符的赋值来源于Order对象
Object[] args={order.getName(),order.getDishMegs(),order.getFen(),order.getTime(),order.getAddresses(),order.getStates(),order.getSumPrices()};
try {
//传入一个sql语句和一个可变数组,并抛出异常,添加受影响的是行数
int result=queryRunner.update(sql,args);
return result;
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
@Override
public int delete(int id) {
//准备sql语句,id是自增长
String sql="delete from `order` where id=?";
//删除数据不需要对象，是根据id进行删除的，故不需要可变数组
try {
//使用queryRunner调用update方法，返回值是受影响的行数
int result=queryRunner.update(sql,id);
//返回结果
return result;
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
@Override
public int update(Order order) {
//准备sql语句,id是自增长
String sql="update `order` set states=? where id=?";
//准备一个可变数组
Object [] args={order.getStates(),order.getId()};
try {
//使用queryRunner调用update方法，返回值是受影响的行数
return queryRunner.update(sql,args);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
@Override
public Order selectOneOrder(int id) {
//创建beanHandler泛型集合对象
BeanHandler<Order> beanHandler=new BeanHandler<>(Order.class);
//使用queryRunner调用query方法，返回值是一个结果集，即Order对象
//准备sql语句
String sql="select * from `order` where id=?";
//查询单个不需要准备可变数组，直接使用id查询，返回的是一个对象Order
try {
return queryRunner.query(sql,beanHandler,id);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
@Override
public List<Order> selectAllOrder() {
//创建beanListHandler泛型集合对象
BeanListHandler<Order> beanListHandler=new BeanListHandler<Order>(Order.class);
//准备一个sql语句
String sql="select * from `Order`";
//查询无占位符，故不需要准备可变数组
//使用queryRunner调用query方法，返回值是一个结果集，即多个Order对象，可组装成为一个集合
try {
return queryRunner.query(sql,beanListHandler);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}
之后再创建一个服务类service，同样是创建2个2个service接口，以及2个实现类。分别为FoodServiceImpl.java OrderServiceImpl.java FoodService.java OrderService.java。这个包是业务逻辑层，封装了数据库底层操作的更高级的操作，将Dao层和Entity层整合起来，进行再次封装，封装成一个方法，以便于业务逻辑的实现
public class FoodServiceImpl implements FoodService {
//实现规范服务类方法的接口
//定义FoodDao对象，指向其实现类，方便调用方法
FoodDao foodDao=new FoodDaoImpl();
//创建scanner对象
Scanner scanner=new Scanner(System.in);
Food food=new Food();
@Override
public int updateFood() {
System.out.println("请输入你要点赞的菜品序号");
int id=scanner.nextInt();
//根据用户输入的id，调用查询方法查询菜品存在与否
Food food1=foodDao.selectOneFood(id);
if (food1==null){
System.out.println("对不起，你输入的菜品不存在，无法点赞");
}else {
food1.setPraiseNum(food1.getPraiseNum()+1);
//存在则调用修改方法
int result= foodDao.update(food1);
return result;
}
return 0;
}
@Override
public Food selectOneFood(int cid) {
Food food1=foodDao.selectOneFood(food.getCid());
return food1;
}
@Override
public List<Food> selectAllFood() {
List<Food> foodList=foodDao.selectAllFood();
return null;
}
}
public class OrderServiceImpl implements OrderService {
//实现规范服务类方法的接口
//创建OrderDao对象，指向其实现类，方便调用其中的方法
OrderDao orderDao=new OrderDaoImpl();
//创建FoodDao对象，指向其实现类，方便调用其中的方法
FoodDao foodDao=new FoodDaoImpl();
//创建order的对象
Order order=new Order();
//因为订餐等数据来源于用户从键盘输入，创建Scanner对象
Scanner scanner=new Scanner(System.in);
//添加订单，首先需要查看系统是否有此订单
@Override
public int add() {
//使用foodDao调用查询所有方法，返回一个food集合对象
List<Food> foodList=foodDao.selectAllFood();
System.out.println("请输入订餐人姓名：");
String name =scanner.next();
System.out.println("请选择你要点的菜（输入序号）：");
int dishChoose=scanner.nextInt();
Food food = foodDao.selectOneFood(dishChoose);
//通过food对象获取用户点的什么菜，并定义变量接收
String dishNames=food.getDishNames();
//通过food对象获取该菜品的价格
double newPprices=food.getPrices();
Syst
em.out.println("请输入你要点餐的份数");
int fen=scanner.nextInt();
System.out.println("请输入您的送餐时间(请输入10~22的整数)");
int time=scanner.nextInt();
//对用户输入的时间进行判断
while (time <10 && time>22){
System.out.println("对不起，您输入的时间不在配送范围内(请重新输入)");
int ErrTime=scanner.nextInt();
}
System.out.println("请输入你的配送地址");
String addresses=scanner.next();
//设置订单状态
order.setStates(0);
//计算订单价格，从对象之中获取的菜品价格 * 用户输入的份数
double sumPrices=newPprices * fen;
double newSumPrices= 0;
//对价格进行判断，如果订单总金额大于50，免配送费，否则收取配送费6元
if (sumPrices>=50){
newSumPrices=sumPrices;
System.out.println("订单总金额为"+newSumPrices);
}else {
//订单总金额小于50时，加配送费6元
newSumPrices=sumPrices+6;
System.out.println("订单总金额为"+newSumPrices);
}
//将获取到的总金额添加到对象之中，再将对象添加到数据库之中
Order order2=new Order(name,dishNames,fen,time,addresses,0,newSumPrices);
//使用orderDao调用添加方法，将组成的对象添加进数据库之中
int rows=orderDao.insert(order2);
System.out.println(rows==0?"点餐失败":"点餐成功");
return 0;
}
//删除订单
@Override
public int delete() {
System.out.println("请输入您要删除的订单编号");
int id1=scanner.nextInt();
//使用 orderDao调用方法查询系统内部是否有此订单,返回一个order的对象
Order order1=orderDao.selectOneOrder(id1);
//对返回的结果进行判断，若系统内部无此订单，则不可以删除，反之有订单则可删除
if (order1==null){
System.out.println("对不起，订单不存在，不可删除");
}else {
//调用方法执行删除
int result =orderDao.delete(id1);
return result;
}
return 0;
}
//签收订单（修改订单）
@Override
public int update() {
System.out.println("请输入你要签收的订单号");
int id =scanner.nextInt();
//使用 orderDao调用方法查询系统内部是否有此订单,返回一个order的对象
Order order1=orderDao.selectOneOrder(id);
//对返回的结果进行判断，若系统内部无此订单，则不可以签收，反之有订单则可签收
//设置订单状态为1,1表示已签收，0表示未签收
if (order1==null){
System.out.println("对不起，您要签收的订单不存在");
}else {
//调用修改方法，进行修改订单状态,返回受影响的行数
order1.setStates(1);
int result=orderDao.update(order1);
return result;
}
return 0;
}
//查看餐袋
@Override
public Order selectOneOrder(int id) {
//使用 orderDao调用查询单个方法查询系统内部是否有此订单,返回一个order的对象
Order order1=orderDao.selectOneOrder(id);
return order1;
}
@Override
public List<Order> selectAllOrder() {
//使用 orderDao调用查询所有方法查询系统内部是否有此订单,返回一个List<Order>的泛型集合
List<Order> orderList=orderDao.selectAllOrder();
return orderList;
}
@Override
public void showOrder() {
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("-------------------------------------------");
System.out.println("请小主选择菜单，输入序号即可");
}
}
import com.bdqn.Entity.Food;
import java.util.List;
public interface FoodService {
//规范一下服务类的方法
int updateFood();
Food selectOneFood(int cid);
List<Food> selectAllFood();
}
public interface OrderService {
//规范一下服务类的方法
int add();//添加
int delete();//删除
int update();//修改
Order selectOneOrder(int id); //查单个
List<Order> selectAllOrder(); //查所有
void showOrder();
}
接下来就是工具类
date工具类和DBUtils工具类
import java.text.ParseException;
import java.text.SimpleDateFormat;
/**
* 日期时间工具类DateUtils
*
*
*
*/
public class DateUtils {
private static final SimpleDateFormat SIMPLEDATEFORMAT = new SimpleDateFormat("yyyy-MM-dd");
// 字符串转换为java.util.Date类型日期时间
public static java.util.Date strDateToUtilDate(String strDate) {
try {
return SIMPLEDATEFORMAT.parse(strDate);
} catch (ParseException e) {
e.printStackTrace();
}
return null;
}
// java.util.Date类型日期时间转换为java.sql.Date类型日期时间
public static java.sql.Date utilDateToSqlDate(java.util.Date date) {
// long date.getTime():返回自 1970 年 1 月 1 日 00:00:00 GMT以来此 Date对象表示的毫秒数
return new java.sql.Date(date.getTime());
}
// java.util.Date类转换为字符串类型
public static String utilDateToString(java.util.Date date) {
return SIMPLEDATEFORMAT.format(date);
}
}
import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
public class DBUtils {
// 声明一个连接池对象
private static DruidDataSource druidDataSource;
static {
// 实例化配置文件对象
Properties properties = new Properties();
try {
// 加载配置文件内容
InputStream is = DBUtils.class.getResourceAsStream("/db.properties");
properties.load(is);
// 创建连接池
druidDataSource = (DruidDataSource) DruidDataSourceFactory
.createDataSource(properties);
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
//返回一个数据源
public static DataSource getDataSource(){
return druidDataSource;
}
}
最后也就是view类，也就是测试类
public class chiHuoSystemTest {
public static void main(String[] args) {
//因为订餐等数据来源于用户从键盘输入，创建Scanner对象
Scanner scanner=new Scanner(System.in);
//定义一个num的值用来控制while循环
int num=-1;
//定义一个布尔值用来退出系统
boolean isExit=false;
//创建OrderServiceImpl对象，方便后面的方法调用
OrderServiceImpl orderService=new OrderServiceImpl();
//创建FoodServiceImpl对象，方便后面的方法调用
FoodServiceImpl foodService=new FoodServiceImpl();
System.out.println("--------------------------------------------欢迎光临牛逼外卖---------------------------------------------");
do {
orderService.showOrder();
//定义变量用来接收用户输入的订单序号
int choose=scanner.nextInt();
switch(choose){
case 1:
//具体功能表现
System.out.println("---------------------------------我要订餐---------------------------------");
//调用方法实现我要点餐
orderService.add();
break;//该break的作用是用来结束整个switch选择结构
case 2:
//具体功能表现
System.out.println("---------------------------------查看餐袋---------------------------------");
//调用方法查询数据库，实现查询餐袋，这里需要对集合进行遍历，输出集合（数据库）里面已经有的对象
List<Order> orderList =orderService.selectAllOrder();
orderList.forEach(System.out::println);
break;//该break的作用是用来结束整个switch选择结构
case 3:
//具体功能表现
System.out.println("---------------------------------签收订单---------------------------------");
//调用修改的方法
int rows=orderService.update();
System.out.println(rows==0?"签收失败":"签收成功");
break;//该break的作用是用来结束整个switch选择结构
case 4:
//具体功能表现
System.out.println("---------------------------------删除订单---------------------------------");
//调用删除的方法
int result=orderService.delete();
System.out.println(result==0?"删除失败":"删除成功");
break;//该break的作用是用来结束整个switch选择结构
case 5:
//具体功能表现
System.out.println("---------------------------------我要点赞---------------------------------");
//调用food之中修改的方法
int result1=foodService.updateFood();
System.out.println(result1==0?"点赞失败":"点赞成功");
break;//该break的作用是用来结束整个switch选择结构
case 6:
//具体功能表现
System.out.println("---------------------------------退出系统---------------------------------");
isExit=true;
break;//该break的作用是用来结束整个switch选择结构
default:
System.out.println("退出系统");
isExit=true;
break;
}
if (!isExit){
System.out.println("------------输入0返回------------");
//定义变量接收用户输入的数字
num=scanner.nextInt();
}else {
break;
}
}while(num==0);
System.out.println("----------------------------------------欢迎下次光临----------------------------------------");
}
}标签：return,int,吃货,System,id,println,Apache,DBUtils,public From： https://blog.csdn.net/qq_57071220/article/details/142108345