java使用dbutils工具类实现小程序 管家婆记账软件

1.所需创建的包和 jar包

2.创建表结构

 #生成一些表数据

INSERT  INTO gjp_zhangwu(zwid,flname,money,zhangHu,createtime,description) VALUES (1,'吃饭支出',247,'交通银行','2016-03-02','家庭聚餐');
INSERT  INTO gjp_zhangwu(zwid,flname,money,zhangHu,createtime,description) VALUES (2,'工资收入',12345,'现金','2016-03-15','开工资了');
INSERT  INTO gjp_zhangwu(zwid,flname,money,zhangHu,createtime,description) VALUES (3,'服装支出',1998,'现金','2016-04-02','买衣服');
INSERT  INTO gjp_zhangwu(zwid,flname,money,zhangHu,createtime,description) VALUES (4,'吃饭支出',325,'现金','2016-06-18','朋友聚餐');
INSERT  INTO gjp_zhangwu(zwid,flname,money,zhangHu,createtime,description) VALUES (5,'股票收入',8000,'工商银行','2016-10-28','股票大涨');
INSERT  INTO gjp_zhangwu(zwid,flname,money,zhangHu,createtime,description) VALUES (6,'股票收入',5000,'工商银行','2016-10-28','股票又大涨');
INSERT  INTO gjp_zhangwu(zwid,flname,money,zhangHu,createtime,description) VALUES (7,'工资收入',5000,'交通银行','2016-10-28','又开工资了');
INSERT  INTO gjp_zhangwu(zwid,flname,money,zhangHu,createtime,description) VALUES (8,'礼金支出',5000,'现金','2016-10-28','朋友结婚');
INSERT  INTO gjp_zhangwu(zwid,flname,money,zhangHu,createtime,description) VALUES (9,'其他支出',1560,'现金','2016-10-29','丢钱了');
INSERT  INTO gjp_zhangwu(zwid,flname,money,zhangHu,createtime,description) VALUES (10,'交通支出',2300,'交通银行','2016-10-29','油价还在涨啊');
INSERT  INTO gjp_zhangwu(zwid,flname,money,zhangHu,createtime,description) VALUES (11,'吃饭支出',1000,'工商银行','2016-10-29','又吃饭');
INSERT  INTO gjp_zhangwu(zwid,flname,money,zhangHu,createtime,description) VALUES (12,'工资收入',1000,'现金','2016-10-30','开资');
INSERT  INTO gjp_zhangwu(zwid,flname,money,zhangHu,createtime,description) VALUES (13,'交通支出',2000,'现金','2016-10-30','机票好贵');
INSERT  INTO gjp_zhangwu(zwid,flname,money,zhangHu,createtime,description) VALUES (14,'工资收入',5000,'现金','2016-10-30','又开资');

3.代码

javabean类

package com.company.gjp.domain;



public class ZhangWu {
    private int zwid;
    
    private String flname;
    
    private double money;
    
    private String zhanghu;
    
    private String createtime;
    
    private String description;
    
    public ZhangWu(){
        
    }

    

    public ZhangWu(int zwid, String flname, double money, String zhangwu, String createtime, String description) {
        super();
        this.zwid = zwid;
        this.flname = flname;
        this.money = money;
        this.zhanghu = zhangwu;
        this.createtime = createtime;
        this.description = description;
    }



    public int getZwid() {
        return zwid;
    }



    public void setZwid(int zwid) {
        this.zwid = zwid;
    }



    public String getFlname() {
        return flname;
    }



    public void setFlname(String flname) {
        this.flname = flname;
    }



    public double getMoney() {
        return money;
    }



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



    public String getZhanghu() {
        return zhanghu;
    }



    public void setZhanghu(String zhanghu) {
        this.zhanghu = zhanghu;
    }



    public String getCreatetime() {
        return createtime;
    }



    public void setCreatetime(String createtime) {
        this.createtime = createtime;
    }



    public String getDescription() {
        return description;
    }



    public void setDescription(String description) {
        this.description = description;
    }



    @Override
    public String toString() {
        return "ZhangWu [zwid=" + zwid + ", flname=" + flname + ", money=" + money + ", zhanghu=" + zhanghu
                + ", createtime=" + createtime + ", description=" + description + "]";
    }
    
    
}

数据库连接的工具类，使用连接池的方式

package com.company.gjp.tools;
/*
 * 获取数据库连接的工具类
 * 实现连接池，dbcp连接池
 */

import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSource;

public class JDBCUtils {
    //创建BasicDatasource对象
    private static BasicDataSource dataSource=new BasicDataSource();
    
    //静态代码块，实现必要参数设置
    static{
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/gjp");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        
        dataSource.setMaxActive(10);
        dataSource.setMaxIdle(5);
        dataSource.setMinIdle(2);
        dataSource.setInitialSize(10);
    }
    
    public static DataSource getDataSource(){
        
        return dataSource;
    }
}

开启程序的主方法类

package com.company.gjp.app;

import com.company.gjp.view.MainView;

/*
 * 主程序，作用：开启软件程序
 */
public class MainApp {
    public static void main(String[] args) {
        new MainView().run();
    }
}

主视图类，用于用户的输入输出，以及向controller层请求数据的类

package com.company.gjp.view;
/*
 *     视图层，用户看到和操作的界面
 *     数据传递给controller层实现
 *     成员位置，创建controller对象
 */

import java.util.List;
import java.util.Scanner;

import com.company.gjp.controller.ZhangWuController;
import com.company.gjp.domain.ZhangWu;

public class MainView {
    private ZhangWuController controller=new ZhangWuController();
        
    
    /*
     * 实现界面效果
     * 接受用户的输入
     * 根据数据，调用不同的功能方法
     */
    public void run(){
        //创建Scanner类对象，反复键盘输入
        Scanner sc=new Scanner(System.in);
        while(true){
            System.out.println("---------------管家婆家庭记账软件---------------");
            System.out.println("1.添加账务　2.编辑账务　3.删除账务　4.查询账务　5.退出系统");
            System.out.println("请输入要操作的功能序号[1-5]:");
            //接受用户的选择
            int choose=sc.nextInt();
            //对选择的菜单判断，调用不同的功能
            switch(choose){
            case 1:
                //选择添加账务，调用添加账务的方法
                addZhangWu();
                break;
            case 2:
                editZhangWu();
                //编辑账务，调用编辑账务的方法
                break;
            case 3:
                deleteZhangWu();
                //选择的删除账务，调用删除账务方法
                break;
            case 4:
                selectZhangWu();
                //选择查询账务，调用查询账务的方法
                break;
            case 5:
                System.exit(0);
                
            
            }
        }
    }
    /**
     * 接受键盘输入的账务id
     * 
     */
    public void deleteZhangWu(){
        selectAll();
        System.out.println("选择的是删除功能，请输入你要删除的账务ID");
        Scanner sc=new Scanner(System.in);
        int zwid=sc.nextInt();
        controller.deleteZhangWu(zwid);
        System.out.println("删除账务成功！");
    }
    
    /**
     * 接受键盘输入
     * 数据的信息，封装成ZhangWu对象
     * 调用控制层的方法，传递ZhangWu对象，实现编辑
     */
    public void editZhangWu(){
        //用查询所有账务数据的功能，显示出来
        //看到所有数据，从中选择一项，进行修改
        selectAll();
        System.out.println("选择的是编辑功能,请输入数据");
        Scanner sc=new Scanner(System.in);
        //接受用户的数据
        System.out.println("输入ID:");
        int zwid=sc.nextInt();
        System.out.print("请输入类别：");
        String flname=sc.next();
        System.out.print("请输入账户：");
        String zhanghu=sc.next();
        System.out.print("请输入金额：");
        Double money=sc.nextDouble();
        System.out.print("请输入时间：");
        String createtime=sc.next();
        System.out.print("请输入说明：");
        String description=sc.next();
        //将所有用户输入的数据，封装到ZhangWu对象中
        //输入的ID,必须封装对象
        ZhangWu zw=new ZhangWu(zwid,flname,money,zhanghu,createtime,description);
        //调用controller层中的方法，编辑账务
        controller.editZhangWu(zw);
        System.out.println("账务编辑成功！");

    }
    
    /**
     * 接受键盘输入，5项输入，调用controller层方法
     */
    public void addZhangWu(){
        Scanner sc = new Scanner(System.in);
            
        System.out.print("请输入类别：");
        String flname=sc.next();
        System.out.print("请输入账户：");
        String zhanghu=sc.next();
        System.out.print("请输入金额：");
        Double money=sc.nextDouble();
        System.out.print("请输入时间：");
        String createtime=sc.next();
        System.out.print("请输入说明：");
        String description=sc.next();
        //将接收到的数据，调用controller层的方法，传递参数
        //将用户输入的所有参数，封装成ZhangWu对象
        ZhangWu zw=new ZhangWu(0,flname,money,zhanghu,createtime,description);
        controller.addZhangWu(zw);
        System.out.println("恭喜你添加账务成功");
    }
    
    
    /*
     * 定义方法selectZhangWu()
     * 显示查询的方式1.所有查询  2.条件查询
     * 接受用户的选择
     */
    public void selectZhangWu(){
        System.out.println("1.查询所有     2.条件查询");
        Scanner sc=new Scanner(System.in);
        int selectChoose=sc.nextInt();
        //判断根据用户的选择，调用不同的功能
        switch(selectChoose){
        case 1:
            selectAll();
            break;
        case 2:
            select();
            break;
        }
    }
    
    /**
     * 定义方法，实现查询所有的账务数据
     */
    public void selectAll(){
        //调用控制中的方法，查询账务的数据
        List<ZhangWu> list=controller.selectAll();
        //输出表头
        print(list);
    }

    /**
     * 定义方法，实现条件查询账务数据
     * 提供用户的输入日期，开始日期结束日期
     * 就2个日期，传递到controller层
     * 调用controller的方法，传递2个日期参数
     * 获取controller查询的结果集，打印出来
     */
    public void select(){
        System.out.println("选择条件查询，格式xxxx-xx-xx");
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入开始日期：");
        String startDate=sc.nextLine();
        System.out.println("输入结束的日期：");
        String endDate=sc.nextLine();
        //调用controller层的方法，传递日期，获取查询结果集
        List<ZhangWu> list=controller.select(startDate, endDate);
        if(list.size()!=0){
        print(list);
        }else{
            System.out.println("没有查询到数据");
        }        
    }
    
    //输出账务数据方法，接受List集合，遍历集合，输出表格
    private void print(List<ZhangWu> list) {
        System.out.println("ID\t\t类别\t\t账户\t\t金额\t\t时间\t\t说明");
        //遍历集合，结果输出控制台
        for(ZhangWu zw:list){
            System.out.println(zw.getZwid()+"\t\t"+zw.getFlname()+"\t\t"+zw.getZhanghu()
            +"\t\t"+zw.getMoney()+"\t\t"+zw.getCreatetime()+"\t\t"+zw.getDescription());
        }
    }
}

控制层类，用于向service层请求数据

package com.company.gjp.controller;
/*
 * 控制器层
 * 接受视图层的数据，数据传递给service层
 * 成员位置，创建service对象
 */

import java.util.List;

import com.company.gjp.domain.ZhangWu;
import com.company.gjp.service.ZhangWuService;
public class ZhangWuController{
    private ZhangWuService service=new ZhangWuService();
    
    /**
     * 定义方法，实现删除账务
     * 
     */
    public int deleteZhangWu(int zwid){
        return service.deleteZhangWu(zwid);
    }
    
    /**
     * 定义方法，实现编辑账务
     */
    public int editZhangWu(ZhangWu zw){
        return service.editZhangWu(zw);
    }
    
    /**
     * 定义方法，实现增加账务
     */
    public int addZhangWu(ZhangWu zw){
        return service.addZhangWu(zw);
    }
    
    /**
     * 定义方法，实现条件查询账务
     * 方法由试图层调用，传递两个日期的字符串
     * 调用Service层的方法，传递两个日期字符串，获取结果集
     * 结果返回给试图
     */
    public List<ZhangWu> select(String startDate,String endDate){
        return service.select(startDate,endDate);    
    }
    
    /**
     * 控制层类定义方法，实现查询所有的账务数据
     * 方法由视图层调用，
     * 结果集，将所有的账务数据，存储到Bean对象中，存储到集合中
     */
    public List<ZhangWu> selectAll(){
        return service.selectAll();
    }
    
}

业务层类 service向dao层请求数据

package com.company.gjp.service;
/*
 * 业务层类
 * 接受上一层，控制层controller的数据
 * 经过计算，传递给dao层，操作数据库
 * 调用dao层中的类，类成员位置，创建Dao类的对象
 */

import java.util.List;

import com.company.gjp.dao.ZhangWuDao;
import com.company.gjp.domain.ZhangWu;
public class ZhangWuService {
    private ZhangWuDao dao=new ZhangWuDao();
    
    public int deleteZhangWu(int zwid){
        return dao.deleteZhangWu(zwid);
    }
    
    public int editZhangWu(ZhangWu zw){
        return dao.editZhangWu(zw);
    }
        
    
    public int addZhangWu(ZhangWu zw){
        return dao.addZhangWu(zw);
    }
    
    /**
     * 定义方法，实现条件查询账务
     * 方法由控制层调用，传递2个日期字符串
     * 调用dao层的方法，传递2个日期字符串
     * 获取到查询结果集
     */
    public List<ZhangWu> select(String startDate,String endDate){
        
        return dao.select(startDate,endDate);
        
    }
    
    
    /**
     * 定义方法，实现查询所有的账务数据
     * 此方法，由控制层调用，去调用dao层的方法
     * 返回存储 ZhangWu对象的List集合
     */
    
    public List<ZhangWu> selectAll(){
        return dao.selectAll();
    }
}

dao层类，处理数据类，直接向数据库请求数据

package com.company.gjp.dao;

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

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanListHandler;

import com.company.gjp.domain.ZhangWu;
import com.company.gjp.tools.JDBCUtils;

/*
 * 实现对数据表gjp_zhangwu  数据增删改查操作，
 * dbutils工具类完成，类成员创建QueryRunner对象，指定数据源
 */
public class ZhangWuDao {
    private QueryRunner qr=new QueryRunner(JDBCUtils.getDataSource());
    
    /**
     * 定义方法，实现删除账务
     * 传递主键ID即可
     */
    public int deleteZhangWu(int zwid){
        try{
        String sql="delete from gjp_zhangwu where zwid=?";
        return qr.update(sql,zwid);
        }catch (SQLException e){
            System.out.println(e);
            throw new RuntimeException();
        }
    }
    
    /**
     * 定义方法，实现编辑账务(即修改账务)
     * 由业务层调用，传递ZhangWu对象
     * 将对象中的数据，更新到数据表
     */
    public int editZhangWu(ZhangWu zw){
        try{
            String sql="update gjp_zhangwu set flname=?,money=?,zhanghu=?,createtime=?,description=? where zwid=? ";
            Object[] params={zw.getFlname(),zw.getMoney(),zw.getZhanghu(),zw.getCreatetime(),zw.getDescription()
                    ,zw.getZwid()};
            return qr.update(sql,params);
        }catch (SQLException e){
            System.out.println(e);
            throw new RuntimeException("账务编辑失败");
        }
        
    }
    
    
    /**
     * 定义方法，实现添加账务功能
     * 由业务层调用，传递ZhangWu对象
     * 将ZhangWu对象中的数据，添加到数据表
     */
    public int addZhangWu(ZhangWu zw){
        //拼写数据的sql
        try{
            String sql="insert into gjp_zhangwu (flname,money,zhanghu,createtime,description) values"
                    + "(?,?,?,?,?)";
            //创建对象数组，存储5个占位符的实际参数
            //实际参数来源是，传递过来的对象是ZhangWu
            Object[] params={zw.getFlname(),zw.getMoney(),zw.getZhanghu(),zw.getCreatetime()
                    ,zw.getDescription()};
            return qr.update(sql,params);
            
        }catch (Exception e){
            System.out.println(e);
            throw new RuntimeException("账务添加失败");
        }
    }
    
    
    /**
     * 定义方法，查询数据库，带有条件去查询账务表
     * 由业务层调用，查询结果集存储到Bean对象，存储到List集合
     * 调用者传递2个日期字符串
     */
    public  List<ZhangWu> select(String startDate,String endDate){
        //拼写条件查询的sql语句
        try{
            String sql="select * from gjp_zhangwu where createtime between ? and ?";
            //定义对象数组，存储？占位符
            Object[] params={startDate,endDate};
            List<ZhangWu> list=qr.query(sql, new BeanListHandler<>(ZhangWu.class),params);
            return list;
            }catch (SQLException e){
                System.out.println(e);
                throw new RuntimeException("条件查询失败");
        }
    }
    
    /**
     * 定义方法，查询数据库，获取所有的账务数据
     * 方法，由业务层调用
     * 结果集，将所有的账务数据，存储到Bean对象中，存储到集合中
     */
    public List<ZhangWu> selectAll(){
        //查询账务数据的SQL语句
        try{
        String sql="select * from gjp_zhangwu";
        //调用qr对象的方法，query方法，结果集BeanListHandler
        List<ZhangWu> list=qr.query(sql, new BeanListHandler<>(ZhangWu.class));
        return list;
        }catch (SQLException e){
            System.out.println(e);
            throw new RuntimeException("查询所有账务失败");
        }
    }
}

4.效果演示