小区停车管理系统（SQL，JDBC）

柚几哥哥

已于 2022-03-21 11:08:29 修改

阅读量3.1k

点赞数 16

分类专栏：项目文章标签： sql jdbc java

于 2021-08-28 16:14:15 首次发布

本文链接：https://blog.csdn.net/Zyw907155124/article/details/119969241

版权

项目专栏收录该内容

5 篇文章 1 订阅

订阅专栏

1、总体思想

2、分包思想

我们会在代码当中，进行分包管理。

1.  src.bean  用来存放 JavaBean 信息POJO, 要求是成员变量和表的字段对应,名称要一样。
2.  src.dao   定义接口(规则) 增、删、改、查 查单个、查所有
3.  src.service  定义接口(规则) 主要是针对于业务层面了。登录的业务、注册业务、车辆进入、车辆退出...
4.  src.controller 与客户打交道的, 当用户选择对应操作的过程当中,执行对应的方法
5.  src.entry 定义入口程序,现在的入口程序,也就是 main 方法
6.  src.util  用来定义一些工具类,工具接口,工具方法,常量信息等
7.  src.test  测试程序需要使用的包, 都是测试三层(dao\service\controller)测试工具类(util)需要使用的单元测试

第二章案例代码

第01节工具类

1、JDBCUtil


package zyw.util;


import com.alibaba.druid.pool.DruidDataSourceFactory;

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

public class JDBCUtils {

    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 Connection getConnection(){
        Connection conn = null;
        try {
            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();
                System.out.println("释放资源resu");
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(stat!=null){
            try {
                stat.close();
                System.out.println("释放资源satat");
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(conn!=null){
            try {
                conn.close();
                System.out.println("释放资源conn");
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    public static DataSource getDataSource(){
        return  ds;
    }
}

2、ScannerUtil


package zyw.util;
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


package zyw.util;
//用于记录常量相关的接口
public interface Constant {
//项目当中文件夹的路径
    public static  final String DIR="C:\\develop\\work0719\\TCar0823\\lib";
    //记录缓存，记住密码的状态的路径
    public static final String CACHE_FILE = DIR + "\\cache.txt";
}

4、CacheLoginUtil


package zyw.util;

import zyw.bean.UserBean;

import java.io.*;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

//用于缓存登录的状态，解决免登录的问题
public class CacheLoginUtil {

    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;
    }
    public static UserBean loadOnly(String uname){
        List<UserBean> list = loadAll();
        int index = -1;
        for (int i = 0; i < list.size(); i++) {
            UserBean userBean = list.get(i);
            if (uname.equals(userBean.getUname())){
                index = i;
                break;
            }
        }
        return index == -1 ? null : list.get(index);
    }


    public static void storeOnly(UserBean bean){
        List<UserBean> list = loadAll();
        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);
                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 void storeAll(List<UserBean> mlist){
        List<UserBean> list = loadAll();
        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);
                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();
                }
            }
        }
    }

}

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、实体类编写


package zyw.bean;

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 String toString() {
        return "UserBean{" +
                "uid=" + uid +
                ", uname='" + uname + '\'' +
                ", upass='" + upass + '\'' +
                ", remember='" + remember + '\'' +
                '}';
    }
}

2、Dao层的代码


zyw.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层代码


zyw.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 层代码


zyw.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、入口程序


zyw.entry.Home

import blb.chc.controller.UserController;

//程序的入口, 所有的操作,都在这里开始,包含有main方法
public class Home {

    public static void main(String[] args) {
        //直接调用用户模块的操作
        UserController.start();
    }
}

第03节车辆模块

1、实体类编写


zyw.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层的代码


zyw.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层代码


zyw.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层代码


zyw.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、入口程序


zyw.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();
    }
}

6、成果展示

7、数据库存储记录

人员信息录入表单：

车辆信息录入表单

柚几哥哥

关注

16
点赞
踩
45

收藏

觉得还不错? 一键收藏
打赏
0
评论
小区停车管理系统（SQL，JDBC）

1、总体思想2、分包思想我们会在代码当中，进行分包管理。1. blb.chc.bean 用来存放 JavaBean 信息POJO, 要求是成员变量和表的字段对应,名称要一样。2. blb.chc.dao 定义接口(规则) 增、删、改、查查单个、查所有3. blb.chc.service 定义接口(规则) 主要是针对于业务层面了。登录的业务、注册业务、车辆进入、车辆退出...4. blb.chc.controller 与客户打交道的, 当用户选择对应操作的过程当中,执行对.
复制链接

扫一扫