课程笔记Day32
-
准备工作
-
案例代码
第一章 准备工作
第01节 数据表的准备
1、数据库的准备
-- 1. 删除数据库
DROP DATABASE IF EXISTS mydb11;
-- 2. 创建数据库
CREATE DATABASE IF NOT EXISTS mydb11;
-- 3. 使用数据库
USE mydb11;
2、使用的用户表
表字段展示
uid | uname | upass | remember |
---|---|---|---|
建表语句
-- 1. 删除用户表
DROP TABLE IF EXISTS t_user;
-- 2. 创建用户表
CREATE TABLE IF NOT EXISTS t_user (
uid INT PRIMARY KEY AUTO_INCREMENT, -- 编号,主键自增
uname VARCHAR(20) NOT NULL, -- 用户名信息
upass VARCHAR(20) NOT NULL, -- 密码信息
remember SET('0','1') DEFAULT '0' -- 是否记住密码,0表示不记住,1表示记住
);
-- 3. 查询表信息
SELECT * FROM t_user;
3、使用的停车表
表字段展示
car_id | car_number | car_name | car_phone | car_in_time | car_out_time | car_money | car_vip |
---|---|---|---|---|---|---|---|
建表语句
-- 1. 删除停车表
DROP TABLE IF EXISTS t_car;
-- 2. 创建停车表
CREATE TABLE IF NOT EXISTS t_car(
car_id INT PRIMARY KEY AUTO_INCREMENT, -- 主键id 编号信息
car_number VARCHAR(20) NOT NULL, -- 车牌号
car_name VARCHAR(20), -- 车主的姓名
car_phone VARCHAR(20), -- 车主的手机号码
car_in_time DATETIME, -- 车辆进入的时间
car_out_time DATETIME, -- 车辆退出的时间
car_money DOUBLE(8,1), -- 停车的费用
car_vip SET('0','1','2') DEFAULT '0' -- 车的临停0,包月1,包年2
);
-- 3. 查询表信息
SELECT * FROM t_car;
第02节 资源库的准备
1、jar包的准备
JDBC连接数据库的jar包
mysql-connector-java-5.1.37-bin.jar
druid连接池的jar包
druid-1.0.9.jar
jdbcTemplate的jar包
commons-logging-1.2.jar
spring-beans-5.0.0.RELEASE.jar
spring-core-5.0.0.RELEASE.jar
spring-jdbc-5.0.0.RELEASE.jar
spring-tx-5.0.0.RELEASE.jar
单元测试的jar包
junit-4.8.2.jar
2、配置文件properties
druid 的配置文件
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/mydb11
username=root
password=root
initialSize=5
maxActive=10
maxWait=3000
第03节 思路的准备
1、分层思想
2、分包思想
我们会在代码当中,进行分包管理。
1. blb.chc.bean 用来存放 JavaBean 信息POJO, 要求是成员变量和表的字段对应,名称要一样。
2. blb.chc.dao 定义接口(规则) 增、删、改、查 查单个、查所有
3. blb.chc.service 定义接口(规则) 主要是针对于业务层面了。登录的业务、注册业务、车辆进入、车辆退出...
4. blb.chc.controller 与客户打交道的, 当用户选择对应操作的过程当中,执行对应的方法
5. blb.chc.entry 定义入口程序,现在的入口程序,也就是 main 方法
6. blb.chc.util 用来定义一些工具类,工具接口,工具方法,常量信息等
7. blb.chc.test 测试程序需要使用的包, 都是测试三层(dao\service\controller)测试工具类(util)需要使用的单元测试
第二章 案例代码
第01节 工具类
1、JDBCUtil
blb.chc.util.JDBCUtil
public class JDBCUtil {
private static DataSource ds = null;
static {
try {
Properties pp = new Properties();
InputStream is = ClassLoader.getSystemResourceAsStream("druid.properties");
pp.load(is);
is.close();
ds = DruidDataSourceFactory.createDataSource(pp);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 获取到连接池对象的方法
*/
public static DataSource getDataSource(){
return ds;
}
/***
* 获取到连接的对象
*/
public static Connection getConnection() {
Connection conn = null;
try {
//预防空指针异常。如果我们的 Properties 内容错误
if (ds != null) {
conn = ds.getConnection();
}
} catch (SQLException e) {
e.printStackTrace();
}
return conn;
}
/**
* 释放资源
*/
public static void close(Connection conn, Statement stat){
close(conn,stat,null);
}
public static void close(Connection conn, Statement stat, ResultSet resu){
if (resu!=null){
try {
resu.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (stat!=null){
try {
stat.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (conn!=null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
2、ScannerUtil
import java.util.Scanner;
//封装键盘录入的工具类
public class ScannerUtil {
/***
* 构造方法私有化修饰, 无法让外界去创建对象
*/
private ScannerUtil() {
}
/***
* 给出一些提示 message 输入字符串类型的数据之后返回
* @param message
* @return
*/
public static String inputString(String message){
Scanner sc = new Scanner(System.in);
System.out.println(message);
String str = sc.nextLine();
return str;
}
/***
* 给出一些提示 message 输入 整数类型的数据之后返回
* @param message
* @return
*/
public static int inputInt(String message){
//调用上面输入字符串的方法
String str = inputString(message);
//对输入的字符串进行处理,转换成为 int类型的数据
int number = Integer.parseInt(str);
//返回结果
return number;
}
}
3、Constant
//用于记录常量相关的接口
public interface Constant {
//项目当中文件夹的路径
public static final String DIR = "JavaWebDay09\\dir";
//记录缓存,记住密码的状态的路径
public static final String CACHE_FILE = DIR + "\\cache.txt";
//记录一小时多少钱
public static final double MONEY_OF_HOUR = 5.0;
}
4、CacheLoginUtil
/***
* 用于缓存登录的状态,解决免登陆的问题
*
* 将记住密码的,用户名和密码信息. 把他保存起来, 保存到文件当中。
*
* 存储到文件的,有两个操作:
*
* 1. 存的操作
* 2. 取的操作
*
* 记录数据的格式:
* zhangsan,123456,1
*/
@SuppressWarnings("all")
public class CacheLoginUtil {
//保存单个记录,将数据读取到集合,最后添加bean,写回数据到文件
public static void storeOnly(UserBean bean) {
//直接调用下面的,获取所有的记录信息
List<UserBean> list = loadAll();
//将bean存放到集合,可能会有重复的数据
list.add(bean);
//去重操作
List<UserBean> noRepeatList = list.stream().distinct().collect(Collectors.toList());
//把集合写回文件
BufferedWriter bw = null;
try {
bw = new BufferedWriter(new FileWriter(Constant.CACHE_FILE));
for (int i = 0; i < noRepeatList.size(); i++) {
UserBean userBean = noRepeatList.get(i);
//zhangsan,123456,1
StringBuilder sb = new StringBuilder();
sb.append(userBean.getUname()).append(",");
sb.append(userBean.getUpass()).append(",");
sb.append(userBean.getRemember());
//写数据
bw.write(sb.toString());
bw.newLine();
bw.flush();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (bw!=null){
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//保存所有记录,将数据读取到集合,最后添加List,写回数据到文件
public static void storeAll(List<UserBean> mlist) {
//直接调用下面的,获取所有的记录信息
List<UserBean> list = loadAll();
//将bean存放到集合,可能会有重复的数据
list.addAll(mlist);
//去重操作
List<UserBean> noRepeatList = list.stream().distinct().collect(Collectors.toList());
//把集合写回文件
BufferedWriter bw = null;
try {
bw = new BufferedWriter(new FileWriter(Constant.CACHE_FILE));
for (int i = 0; i < noRepeatList.size(); i++) {
UserBean userBean = noRepeatList.get(i);
//zhangsan,123456,1
StringBuilder sb = new StringBuilder();
sb.append(userBean.getUname()).append(",");
sb.append(userBean.getUpass()).append(",");
sb.append(userBean.getRemember());
//写数据
bw.write(sb.toString());
bw.newLine();
bw.flush();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (bw!=null){
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//取单个记录
public static UserBean loadOnly(String uname) {
//直接调用下面的,获取所有的记录信息
List<UserBean> list = loadAll();
//判断在集合当中,是否存在上面的uname 数据
int index = -1;
for (int i = 0; i < list.size(); i++) {
UserBean userBean = list.get(i);
//拿着上面的数据和集合当中的uname进行比较,如果存在相同,则找到了
if (uname.equals(userBean.getUname())) {
index = i;
break;
}
}
//判断,如果index的值不是-1则表示找到数据,否则表示没有找到
//如果是-1表示没有找到,那么返回 null
//如果不是-1 表示找到了,那么返回当前的对象
return index == -1 ? null : list.get(index);
}
//取所有记录
public static List<UserBean> loadAll() {
//读取文件数据,将数据保存到集合当中
BufferedReader br = null;
List<UserBean> mList = new ArrayList<>();
try {
br = new BufferedReader(new FileReader(Constant.CACHE_FILE));
//查询数据,将数据保存到集合当中
String line;
while ((line = br.readLine()) != null) {
//zhangsan,123456,1
String[] array = line.split(",");
//判断是否不为null,则存放到集合当中
if (array != null && array.length > 0) {
UserBean bean = new UserBean();
bean.setUname(array[0]);
bean.setUpass(array[1]);
bean.setRemember(array[2]);
//保存到集合
mList.add(bean);
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (br != null) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//返回结果
return mList;
}
}
5、CalcTimeUtil
import blb.chc.bean.CarBean;
import blb.chc.dao.CarDao;
import blb.chc.dao.impl.CarDaoImpl;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.List;
//需要去定义一个计算停车时长的工具类
public class CalcTimeUtil {
/***
* 通过车牌号码 和 出场时间去计算停车的总时长。
* @param carNumber
* @param outTime
* @return
*/
public static int calcStopTime(String carNumber,String outTime){
//我们可以根据车牌号码,查询得到最新的入场时间
CarDao dao = new CarDaoImpl();
List<CarBean> mList = dao.selectByNumber(carNumber);
//循环遍历mList集合,查看当前的哪一项的出场时间是null,如果是null则表示最后的一次进入的操作
String iTime = null;
for (int i=0;i<mList.size();i++) {
CarBean car = mList.get(i);
//获取到进场时间和出场时间
String oTime = car.getCar_out_time();
//最新的进场时间对应的出场时间
if (oTime == null){
iTime = car.getCar_in_time();
}
}
try {
//通过进场的时间和出场的时间,进行计算,计算两个时间差值
if (iTime!=null){
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
long outHaoMiao = sdf.parse(outTime).getTime();
long inHaoMiao = sdf.parse(iTime).getTime();
//采用毫秒值相减
long cha = (outHaoMiao - inHaoMiao)/(1000*60*60);
return (int)cha;
}
} catch (ParseException e) {
e.printStackTrace();
}
return 0;
}
}
第02节 用户模块
1、实体类编写
blb.chc.bean.UserBean
//用户信息,对应着用户表 t_user
public class UserBean {
private int uid;
private String uname;
private String upass;
private String remember;
public UserBean() {
}
public UserBean(int uid, String uname, String upass, String remember) {
this.uid = uid;
this.uname = uname;
this.upass = upass;
this.remember = remember;
}
public int getUid() {
return uid;
}
public void setUid(int uid) {
this.uid = uid;
}
public String getUname() {
return uname;
}
public void setUname(String uname) {
this.uname = uname;
}
public String getUpass() {
return upass;
}
public void setUpass(String upass) {
this.upass = upass;
}
public String getRemember() {
return remember;
}
public void setRemember(String remember) {
this.remember = remember;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
UserBean userBean = (UserBean) o;
if (uname != null ? !uname.equals(userBean.uname) : userBean.uname != null) return false;
if (upass != null ? !upass.equals(userBean.upass) : userBean.upass != null) return false;
return remember != null ? remember.equals(userBean.remember) : userBean.remember == null;
}
@Override
public int hashCode() {
int result = uname != null ? uname.hashCode() : 0;
result = 31 * result + (upass != null ? upass.hashCode() : 0);
result = 31 * result + (remember != null ? remember.hashCode() : 0);
return result;
}
@Override
public String toString() {
return "UserBean{" +
"uid=" + uid +
", uname='" + uname + '\'' +
", upass='" + upass + '\'' +
", remember='" + remember + '\'' +
'}';
}
}
2、Dao层的代码
blb.chc.dao.UserDao
import blb.chc.bean.UserBean;
import java.util.List;
//用户表的数据访问层,接口
public interface UserDao {
/***
* 添加数据【增】
* 直接添加一条记录,添加的时候,返回的是影响的行数
*/
public abstract int insertUser(UserBean bean);
/**
* 删除数据【删】
* 根据用户名 uname 删除记录,将删除的影响行数返回
*/
public abstract int deleteUser(String uname);
/***
* 修改数据【改】
* 根据UserBean当中的用户名去修改信息, 可以修改密码,可以修改记录状态
*/
public abstract int updateUser(UserBean bean);
/***
* 通过用户名去查询 用户的信息
* @param uname 用户名
* @return
*/
public abstract UserBean selectByName(String uname);
/***
* 直接查询整张用户表的信息,返回的结果是一个集合数据
* @return
*/
public abstract List<UserBean> selectAll();
}
blb.chc.dao.impl.UserDaoImpl
//用户访问层 UserDao具体实现
@SuppressWarnings("all")
public class UserDaoImpl implements UserDao {
@Override
public int insertUser(UserBean bean) {
String sql = "INSERT INTO t_user VALUES (NULL,?,?,?)";
Object[] objects = {
bean.getUname(),
bean.getUpass(),
bean.getRemember()
};
//-------------------
//创建到工具类 JdbcTemplate 的对象
JdbcTemplate temp = new JdbcTemplate(JDBCUtil.getDataSource());
//执行SQL语句
int lineNumber = temp.update(sql, objects);
//结果返回
return lineNumber;
}
@Override
public int deleteUser(String uname) {
String sql = "DELETE FROM t_user WHERE uname=?";
Object[] objects = {uname};
//-------------------
//创建到工具类 JdbcTemplate 的对象
JdbcTemplate temp = new JdbcTemplate(JDBCUtil.getDataSource());
//执行SQL语句
int lineNumber = temp.update(sql, objects);
//结果返回
return lineNumber;
}
@Override
public int updateUser(UserBean bean) {
int lineNumber = 0;
//判断,如果包含有所有的信息,密码信息和状态的信息
if (bean.getUpass()!=null&&bean.getRemember()!=null){
//更新所有的信息
String sql = "UPDATE t_user SET upass=?,remember=? WHERE uname=?";
Object[] objects = {
bean.getUpass(),
bean.getRemember(),
bean.getUname()
};
JdbcTemplate temp = new JdbcTemplate(JDBCUtil.getDataSource());
//执行SQL语句
lineNumber = temp.update(sql, objects);
}else if (bean.getRemember()==null){
//更新密码
String sql = "UPDATE t_user SET upass=? WHERE uname=?";
Object[] objects = {
bean.getUpass(),
bean.getUname()
};
JdbcTemplate temp = new JdbcTemplate(JDBCUtil.getDataSource());
//执行SQL语句
lineNumber = temp.update(sql, objects);
}else if (bean.getUpass() == null){
//更新是否记住密码
String sql = "UPDATE t_user SET remember=? WHERE uname=?";
Object[] objects = {
bean.getRemember(),
bean.getUname()
};
JdbcTemplate temp = new JdbcTemplate(JDBCUtil.getDataSource());
//执行SQL语句
lineNumber = temp.update(sql, objects);
}
return lineNumber;
}
@Override
public UserBean selectByName(String uname) {
//根据用户名查询单个
String sql = "SELECT * FROM t_user WHERE uname=?";
Object[] objects = { uname };
JdbcTemplate temp = new JdbcTemplate(JDBCUtil.getDataSource());
//执行SQL语句,查询的结果封装成为对象
Map<String, Object> map = temp.queryForMap(sql, objects);
//封装成为 UserBean的对象
UserBean bean = new UserBean();
bean.setUid((Integer) map.get("uid"));
bean.setUname((String) map.get("uname"));
bean.setUpass((String) map.get("upass"));
bean.setRemember((String) map.get("remember"));
return bean;
}
@Override
public List<UserBean> selectAll() {
//根据用户表所有信息
String sql = "SELECT * FROM t_user";
JdbcTemplate temp = new JdbcTemplate(JDBCUtil.getDataSource());
List<UserBean> list = temp.query(sql, new BeanPropertyRowMapper<>(UserBean.class));
return list;
}
}
3、Service层代码
blb.chc.service.UserService
import blb.chc.bean.UserBean;
//与用户相关的业务功能
//1. 登陆功能
//2. 注册功能
//3. 修改密码
//4. 修改是否记住密码
//5. 修改密码和记住密码状态
@SuppressWarnings("all")
public interface UserService {
/***
* 登陆功能
* @param bean 需要的是用户名和密码
* @return 是否登陆成功
*/
public abstract boolean login(UserBean bean);
/***
* 注册功能
* @param bean 需要的是用户名和密码以及记住密码的状态
* @return 是否注册成功
*/
public abstract boolean regist(UserBean bean);
/***
* 修改密码的功能
* @param bean 需要是用户名和新密码
* @return 是否修改成功
*/
public abstract boolean updatePassWord(UserBean bean);
/***
* 修改记住密码的状态
* @param bean 需要的是用户名和状态信息
* @return 是否修改成功
*/
public abstract boolean updateState(UserBean bean);
/***
* 修改密码和记住密码的状态
* @param bean 需要的是用户名和密码和记住密码的状态
* @return 是否修改成功
*/
public abstract boolean updatePassWordAndState(UserBean bean);
}
blb.chc.service.impl.UserServiceImpl
import blb.chc.bean.UserBean;
import blb.chc.dao.UserDao;
import blb.chc.dao.impl.UserDaoImpl;
import blb.chc.service.UserService;
import java.util.List;
/***
* 用户模块,业务层的接口实现
*/
@SuppressWarnings("all")
public class UserServiceImpl implements UserService {
/***
* 登录功能
* @param bean 需要的是用户名和密码
* @return
*/
@Override
public boolean login(UserBean bean) {
//查询数据.查看数据库当中是否存在用户名和密码
//调用查询数据表的操作
UserDao dao = new UserDaoImpl();
//查询单个
UserBean userBean = dao.selectByName(bean.getUname());
//查看当前 userBean 是否存在。不为null
if (userBean != null) {
//判断密码是否正确
if (bean.getUpass().equals(userBean.getUpass())) {
return true;
}
}
return false;
}
/****
* 注册功能
* @param bean 需要的是用户名和密码以及记住密码的状态
* @return
*/
@Override
public boolean regist(UserBean bean) {
//查询所有的信息
//isSameUname 表示的含义是是否存在相同的用户名。刚开始的时候设置为false
boolean isSameUname = false;
UserDao dao = new UserDaoImpl();
List<UserBean> list = dao.selectAll();
for (UserBean userBean : list) {
//判断
if (userBean.getUname().equals(bean.getUname())) {
//存在重复的用户名。
isSameUname = true;
break;
}
}
//判断一下是否存在重复的用户名
if (isSameUname == false) {
//执行插入数据的操作
int lineNumber = dao.insertUser(bean);
return lineNumber > 0 ? true : false;
}
return false;
}
/***
* 修改密码
* @param bean 需要是用户名和新密码
* @return
*/
@Override
public boolean updatePassWord(UserBean bean) {
if (bean.getUname() != null && bean.getUpass() != null && bean.getRemember() == null) {
//创建Dao的对象,调用修改的方法
UserDao dao = new UserDaoImpl();
int lineNumber = dao.updateUser(bean);
return lineNumber > 0 ? true : false;
}
return false;
}
/***
* 修改记住密码的状态
* @param bean 需要的是用户名和状态信息
* @return
*/
@Override
public boolean updateState(UserBean bean) {
if (bean.getUname() != null && bean.getUpass() == null&& bean.getRemember() != null) {
//创建Dao的对象,调用修改的方法
UserDao dao = new UserDaoImpl();
int lineNumber = dao.updateUser(bean);
return lineNumber > 0 ? true : false;
}
return false;
}
/***
* 修改密码和记住密码的状态
* @param bean 需要的是用户名和密码和记住密码的状态
* @return
*/
@Override
public boolean updatePassWordAndState(UserBean bean) {
if (bean.getUname() != null && bean.getUpass() != null&& bean.getRemember() != null) {
//创建Dao的对象,调用修改的方法
UserDao dao = new UserDaoImpl();
int lineNumber = dao.updateUser(bean);
return lineNumber > 0 ? true : false;
}
return false;
}
}
4、Controller 层代码
blb.chc.controller.UserController
//用户的控制层视图类
public class UserController {
//表示开关开启的操作,可以去控制是否还需要死循环的操作。
public static boolean toggle = true;
//定义启动的方法
public static void start() {
//定义死循环的操作,刚开始的时候为 true 则表示会一直执行
//如果修改成为 false 之后,循环就介绍了
while (toggle) {
System.out.println("欢迎进入车辆管理系统");
System.out.println("请选择你的操作:");
System.out.println("1.用户注册");
System.out.println("2.用户登录");
System.out.println("3.输入其他操作,则退出");
//调用输入的方法
String choice = ScannerUtil.inputString("请输入选择:");
//创建服务的对象
UserService service = new UserServiceImpl();
//分支处理
switch (choice) {
//注册操作
case "1":
String unameReg = ScannerUtil.inputString("请输入用户名");
String upassReg = ScannerUtil.inputString("请输入密码");
String rememberReg = ScannerUtil.inputString("请输入是否记住密码(0-不记住,1-记住)");
//封装成为 JavaBean对象
UserBean regUserBean = new UserBean();
regUserBean.setUname(unameReg);
regUserBean.setUpass(upassReg);
regUserBean.setRemember(rememberReg);
//直接调用后面服务的方法
boolean flagReg = service.regist(regUserBean);
System.out.println(flagReg ? "注册成功" : "注册失败");
//判断,如果我们注册状态是成功的,则将数据存储到本地
if (flagReg == true && "1".equals(rememberReg)){
//记录到本地
CacheLoginUtil.storeOnly(regUserBean);
}
break;
//登录操作
case "2":
String unameLog = ScannerUtil.inputString("请输入用户名");
//做判断,是否处于免登陆的状态。
UserBean noPassWordUserBean = CacheLoginUtil.loadOnly(unameLog);
//判断
if (noPassWordUserBean!=null){
System.out.println("登录成功");
toggle = false;
break;
}
String upassLog = ScannerUtil.inputString("请输入密码");
//封装成为 JavaBean对象
UserBean logUserBean = new UserBean();
logUserBean.setUname(unameLog);
logUserBean.setUpass(upassLog);
//直接调用后面服务的方法
boolean flagLog = service.login(logUserBean);
System.out.println(flagLog ? "登录成功" : "登录失败");
//当我们登录成功之后,关闭开关了
if (flagLog == true){
toggle = false;
}
break;
//其他情况,则退出,修改boolean值为 false
default:
toggle = false;
System.out.println("感谢你的使用");
break;
}
}
}
}
5、入口程序
blb.chc.entry.Home
import blb.chc.controller.UserController;
//程序的入口, 所有的操作,都在这里开始,包含有main方法
public class Home {
public static void main(String[] args) {
//直接调用用户模块的操作
UserController.start();
}
}
第03节 车辆模块
1、实体类编写
blb.chc.bean.CarBean
//车辆的实体类
public class CarBean {
private int car_id;
private String car_number;
private String car_name;
private String car_phone;
private String car_in_time;
private String car_out_time;
private Double car_money;
private String car_vip;
public CarBean() {
}
public CarBean(int car_id, String car_number, String car_name, String car_phone, String car_in_time, String car_out_time, Double car_money, String car_vip) {
this.car_id = car_id;
this.car_number = car_number;
this.car_name = car_name;
this.car_phone = car_phone;
this.car_in_time = car_in_time;
this.car_out_time = car_out_time;
this.car_money = car_money;
this.car_vip = car_vip;
}
public int getCar_id() {
return car_id;
}
public void setCar_id(int car_id) {
this.car_id = car_id;
}
public String getCar_number() {
return car_number;
}
public void setCar_number(String car_number) {
this.car_number = car_number;
}
public String getCar_name() {
return car_name;
}
public void setCar_name(String car_name) {
this.car_name = car_name;
}
public String getCar_phone() {
return car_phone;
}
public void setCar_phone(String car_phone) {
this.car_phone = car_phone;
}
public String getCar_in_time() {
return car_in_time;
}
public void setCar_in_time(String car_in_time) {
this.car_in_time = car_in_time;
}
public String getCar_out_time() {
return car_out_time;
}
public void setCar_out_time(String car_out_time) {
this.car_out_time = car_out_time;
}
public Double getCar_money() {
return car_money;
}
public void setCar_money(Double car_money) {
this.car_money = car_money;
}
public String getCar_vip() {
return car_vip;
}
public void setCar_vip(String car_vip) {
this.car_vip = car_vip;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
CarBean bean = (CarBean) o;
if (car_number != null ? !car_number.equals(bean.car_number) : bean.car_number != null) return false;
if (car_name != null ? !car_name.equals(bean.car_name) : bean.car_name != null) return false;
if (car_phone != null ? !car_phone.equals(bean.car_phone) : bean.car_phone != null) return false;
if (car_in_time != null ? !car_in_time.equals(bean.car_in_time) : bean.car_in_time != null) return false;
if (car_out_time != null ? !car_out_time.equals(bean.car_out_time) : bean.car_out_time != null) return false;
if (car_money != null ? !car_money.equals(bean.car_money) : bean.car_money != null) return false;
return car_vip != null ? car_vip.equals(bean.car_vip) : bean.car_vip == null;
}
@Override
public int hashCode() {
int result = car_number != null ? car_number.hashCode() : 0;
result = 31 * result + (car_name != null ? car_name.hashCode() : 0);
result = 31 * result + (car_phone != null ? car_phone.hashCode() : 0);
result = 31 * result + (car_in_time != null ? car_in_time.hashCode() : 0);
result = 31 * result + (car_out_time != null ? car_out_time.hashCode() : 0);
result = 31 * result + (car_money != null ? car_money.hashCode() : 0);
result = 31 * result + (car_vip != null ? car_vip.hashCode() : 0);
return result;
}
@Override
public String toString() {
return "CarBean{" +
"car_id=" + car_id +
", car_number='" + car_number + '\'' +
", car_name='" + car_name + '\'' +
", car_phone='" + car_phone + '\'' +
", car_in_time='" + car_in_time + '\'' +
", car_out_time='" + car_out_time + '\'' +
", car_money=" + car_money +
", car_vip='" + car_vip + '\'' +
'}';
}
}
2、Dao层的代码
blb.chc.dao.CarDao
import blb.chc.bean.CarBean;
import java.util.List;
//车辆表的数据访问层,接口
public interface CarDao {
/***
* 新增车辆信息
* @param bean
* @return
*/
public abstract int insertCar(CarBean bean);
/***
* 删除车辆信息, 根据车牌号, 删除此车辆的所有信息
* @param car_number
* @return
*/
public abstract int deleteCar(String car_number);
/***
* 修改车辆的信息,根据车牌号,修改车辆,入场时间
* @param car_number
* @param inTime
* @return
*/
public abstract int updateCarInTime(String car_number, String inTime);
/***
* 修改车辆的信息,根据车牌号,修改车辆,出场时间,修改VIP的方式,修改停车费
* @param car_number
* @param outTime
* @return
*/
public abstract int updateCarOutTime(String car_number, String outTime);
/***
* 修改车辆的信息,根据车牌号,修改VIP的方式,修改停车费
* @param car_number
* @param vip
* @return
*/
public abstract int updateCarVIP(String car_number, String vip);
/***
* 修改车辆的信息,根据车牌号,修改停车费
* @param car_number
* @param money
* @return
*/
public abstract int updateCarMoney(String car_number,double money);
/***
* 查询所有的车辆信息
* @return
*/
public abstract List<CarBean> selectAll();
/***
* 根据车牌号,查询该车辆的信息
* @param car_number
* @return
*/
public abstract List<CarBean> selectByNumber(String car_number);
/***
* 根据时间,去查询入场时间之间的车辆信息,车流量信息
* @param startTime 入场时间
* @param endTime 入场时间
* @return
*/
public abstract List<CarBean> selectByTime(String startTime, String endTime);
}
blb.chc.dao.impl.CarDaoImpl
import blb.chc.bean.CarBean;
import blb.chc.dao.CarDao;
import blb.chc.util.JDBCUtil;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.List;
//车辆访问层 CarDao具体实现
@SuppressWarnings("all")
public class CarDaoImpl implements CarDao {
/***
* 车辆刚开始进入的信息,车辆入场信息
* @param bean
* @return
*/
@Override
public int insertCar(CarBean bean) {
String sql = "INSERT INTO t_car (car_id,car_number,car_name,car_phone,car_in_time,car_vip) VALUES (NULL,?,?,?,?,?)";
Object[] objects = {
bean.getCar_number(),
bean.getCar_name(),
bean.getCar_phone(),
bean.getCar_in_time(),
bean.getCar_vip()
};
//创建对象
JdbcTemplate temp = new JdbcTemplate(JDBCUtil.getDataSource());
//插入数据
int lineNumber = temp.update(sql, objects);
//返回结果
return lineNumber;
}
/***
* 根据车牌号,删除该车辆的所有信息
* @param car_number
* @return
*/
@Override
public int deleteCar(String car_number) {
String sql = "DELETE FROM t_car WHERE car_number = ?";
Object[] objects = {car_number};
//创建对象
JdbcTemplate temp = new JdbcTemplate(JDBCUtil.getDataSource());
//插入数据
int lineNumber = temp.update(sql, objects);
//返回结果
return lineNumber;
}
/***
* 修改车辆的进场时间
* @param car_number
* @param inTime
* @return
*/
@Override
public int updateCarInTime(String car_number, String inTime) {
String sql = "UPDATE t_car SET car_in_time=? WHERE car_number=?";
Object[] objects = {
inTime, car_number
};
//创建对象
JdbcTemplate temp = new JdbcTemplate(JDBCUtil.getDataSource());
//插入数据
int lineNumber = temp.update(sql, objects);
//返回结果
return lineNumber;
}
/***
* 修改车辆的出场时间
* @param car_number
* @param inTime
* @return
*/
@Override
public int updateCarOutTime(String car_number, String outTime) {
String sql = "UPDATE t_car SET car_out_time=? WHERE car_number=? AND car_out_time IS NULL";
Object[] objects = {
outTime, car_number
};
//创建对象
JdbcTemplate temp = new JdbcTemplate(JDBCUtil.getDataSource());
//插入数据
int lineNumber = temp.update(sql, objects);
//返回结果
return lineNumber;
}
/***
* 修改车辆的停车VIP
* @param car_number
* @param vip
* @return
*/
@Override
public int updateCarVIP(String car_number, String vip) {
String sql = "UPDATE t_car SET car_vip=? WHERE car_number=?";
Object[] objects = {
vip, car_number
};
//创建对象
JdbcTemplate temp = new JdbcTemplate(JDBCUtil.getDataSource());
//插入数据
int lineNumber = temp.update(sql, objects);
//返回结果
return lineNumber;
}
/***
* 修改车辆本次应该提交的停车费
* @param car_number
* @param money
* @return
*/
@Override
public int updateCarMoney(String car_number, double money) {
String sql = "UPDATE t_car SET car_money=? WHERE car_number=? AND car_money IS NULL";
Object[] objects = {
money, car_number
};
//创建对象
JdbcTemplate temp = new JdbcTemplate(JDBCUtil.getDataSource());
//插入数据
int lineNumber = temp.update(sql, objects);
//返回结果
return lineNumber;
}
/**
* 查询车辆整张表的信息
*
* @return
*/
@Override
public List<CarBean> selectAll() {
String sql = "SELECT * FROM t_car";
//创建对象
JdbcTemplate temp = new JdbcTemplate(JDBCUtil.getDataSource());
//查询表的所有信息
List<CarBean> list = temp.query(sql, new BeanPropertyRowMapper<>(CarBean.class));
return list;
}
/***
* 根据车牌号码,去查询该车辆停车的信息
* @param car_number
* @return
*/
@Override
public List<CarBean> selectByNumber(String car_number) {
String sql = "SELECT * FROM t_car WHERE car_number=?";
Object[] objects = {car_number};
//创建对象
JdbcTemplate temp = new JdbcTemplate(JDBCUtil.getDataSource());
//查询表的所有信息
List<CarBean> list = temp.query(sql, objects, new BeanPropertyRowMapper<>(CarBean.class));
return list;
}
/***
* 查询某段范围内的车流量信息
* @param startTime 入场时间
* @param endTime 入场时间
* @return
*/
@Override
public List<CarBean> selectByTime(String startTime, String endTime) {
String sql = "SELECT * FROM t_car WHERE car_in_time BETWEEN ? AND ?";
Object[] objects = {startTime, endTime};
//创建对象
JdbcTemplate temp = new JdbcTemplate(JDBCUtil.getDataSource());
//查询表的所有信息
List<CarBean> list = temp.query(sql, objects, new BeanPropertyRowMapper<>(CarBean.class));
return list;
}
}
3、Service层代码
blb.chc.service.CarService
import blb.chc.bean.CarBean;
import java.sql.Date;
import java.util.List;
/***
* 定义车辆的业务功能
*
* 1. 车辆的进入
* 2. 车辆的退出
* 3. 某辆车,一共在停车场单次消费金额
* 4. 某辆车,一共在停车场已经消费了多少钱
* 5. 某段时间内的车流量信息
*/
public interface CarService {
/**
* 进入停车场的操作
* @param bean
* @return
*/
public abstract boolean inPark(CarBean bean);
/***
* 退出停车场的操作
* @param bean
* @return
*/
public abstract boolean outPark(CarBean bean);
/***
* 根据车牌号,查询单次的消费
* @param car_number
* @return
*/
public abstract double selectOnceFee(String car_number);
/***
* 根据车牌号,查询所有消费
* @param car_number
* @return
*/
public abstract double selectAllFee(String car_number);
/**
* 根据两次的入场时间,查询该时间段内的车流量
* @param startTime 第一个入场时间
* @param endTime 第二个入场时间
* @return
*/
public abstract List<CarBean> selectAllCarByTime(String startTime,String endTime);
}
blb.chc.service.impl.CarServiceImpl
/***
* 车辆模块,业务层的接口实现
*/
@SuppressWarnings("all")
public class CarServiceImpl implements CarService {
/***
* 进入停车场的操作
* @param bean
* @return
*/
@Override
public boolean inPark(CarBean bean) {
//调用添加数据的方法
CarDao dao = new CarDaoImpl();
int lineNumber = dao.insertCar(bean);
//返回结果
return lineNumber > 0;
}
/***
* 退出停车场
* @param bean
* @return
*/
@Override
public boolean outPark(CarBean bean) {
String carNumber = bean.getCar_number();
String outTime = bean.getCar_out_time();
//调用方法,设置获取到停车的时长
int hours = CalcTimeUtil.calcStopTime(carNumber, outTime);
//修改数据
CarDao dao = new CarDaoImpl();
//1.修改停车出场的时间
int lineNumber1 = dao.updateCarOutTime(carNumber, outTime);
//2.修改停车费用
int lineNumber2 = dao.updateCarMoney(carNumber, hours * Constant.MONEY_OF_HOUR);
return lineNumber1 > 0 && lineNumber2 > 0;
}
@Override
public double selectOnceFee(String car_number) {
return 0;
}
@Override
public double selectAllFee(String car_number) {
return 0;
}
@Override
public List<CarBean> selectAllCarByTime(String startTime, String endTime) {
return null;
}
}
4、Controller层代码
blb.chc.controller.CarController
/**
* 车辆的控制层视图类
*/
public class CarController {
//表示开关开启的操作,可以去控制是否还需要死循环的操作。
public static boolean toggle = true;
//定义启动的方法
public static void start() {
//定义死循环的操作,刚开始的时候为 true 则表示会一直执行
//如果修改成为 false 之后,循环就介绍了
while (toggle) {
System.out.println("欢迎进入车辆管理系统");
System.out.println("请选择你的操作:");
System.out.println("1.车辆进入");
System.out.println("2.车辆退出");
System.out.println("3.查询车辆单次消费金额");
System.out.println("4.查询车辆累计消费金额");
System.out.println("5.查询车流量");
System.out.println("6.输入其他操作,则退出");
//调用输入的方法
String choice = ScannerUtil.inputString("请输入");
//分支选择
switch (choice) {
//车辆进入
case "1":
carIn();
break;
//车辆退出
case "2":
carOut();
break;
case "3":
System.out.println("功能尚在开发中,敬请期待...");
break;
case "4":
System.out.println("功能尚在开发中,敬请期待...");
break;
case "5":
System.out.println("功能尚在开发中,敬请期待...");
break;
default:
System.out.println("感谢您的使用,谢谢");
toggle = false;
break;
}
}
}
/***
* 车辆进入
*/
public static void carIn() {
String number = ScannerUtil.inputString("请输入车牌号");
String name = ScannerUtil.inputString("请输入车主姓名");
String phone = ScannerUtil.inputString("请输入车主电话");
String inTime = ScannerUtil.inputString("请输入车辆入场时间 yyyy-MM-dd HH:mm:ss");
String vip = ScannerUtil.inputString("请输入车辆VIP级别(0-临停,1-包月,2-包年)");
//封装成为对象
CarBean bean = new CarBean();
bean.setCar_number(number);
bean.setCar_name(name);
bean.setCar_phone(phone);
bean.setCar_in_time(inTime);
bean.setCar_vip(vip);
//调用服务层
CarService service = new CarServiceImpl();
boolean flag = service.inPark(bean);
System.out.println(flag ? "车辆入库成功" : "车辆入库失败");
}
/***
* 车辆退出
*/
public static void carOut() {
String number = ScannerUtil.inputString("请输入车牌号");
String outTime = ScannerUtil.inputString("请输入车辆出场时间 yyyy-MM-dd HH:mm:ss");
//封装成为对象
CarBean bean = new CarBean();
bean.setCar_number(number);
bean.setCar_out_time(outTime);
//调用服务层
CarService service = new CarServiceImpl();
boolean flag = service.outPark(bean);
System.out.println(flag ? "车辆出库成功" : "车辆出库失败");
}
}
5、入口程序
blb.chc.entry.Home
import blb.chc.controller.CarController;
import blb.chc.controller.UserController;
//程序的入口, 所有的操作,都在这里开始,包含有main方法
public class Home {
public static void main(String[] args) {
//直接调用用户模块的操作
UserController.start();
//直接调用车辆模块的操作
CarController.start();
}
}