开发进度7

  记账本这个程序，如过想要做出来其实用不了七天，主要是自己做完后要学会发现程序的不足，并进行修改，去解决一些自己不熟悉的问题，而且学会一些新的东西不断对程序进行优化，这几天开发的记账本就修改到这，以下是源码。

mainapp

package cn.cyxd.gjp.dao;

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

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

import cn.cyxd.gjp.domain.Users;
import cn.cyxd.gjp.tools.JDBCUtils;



/*
 * 实现对数据表gjp_users数据增、删、改、查操作。
 * dbutils工具类完成，类成员创建QueryRunner对象，指定数据源
 */
public class UsersDao {
        private QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
        
        /*
         * 定义方法：实现删除用户
         * 业务层调用，传递主键id值
         */
        public void deleteUsers(int uid) {
            try {
                    //拼写删除数据SQl语句
                    String sql = "DELETE FROM gjp_users WHERE uid=?";
                    qr.update(sql, uid);
            } catch (SQLException ex) {
                    System.out.println(ex);
                    throw new RuntimeException("删除用户失败");
            }
        }
        
        /*
         * 定义方法：实现编辑用户功能
         * 由业务层调用，传递Users对象
         * 将对象中的数据，更新到数据表中
         */
        public void editUsers(Users user) {
            try{
                //拼写编辑账务的SQL语句
                String sql = "UPDATE gjp_users SET uname=?,upassword=? WHERE uid=?";
                //定义对象数组，将所有的参数传递给对象数组
                Object[] params = {user.getUname(),user.getUpassword(),user.getUid()};
                qr.update(sql, params);
            }catch (SQLException ex) {
                System.out.println(ex);
                throw new RuntimeException("很遗憾！用户编辑失败");
            }
        }
        /*
         * 定义方法：实现添加用户
         * 由业务层调用，传递Users对象
         * 将Users对象中的数据，添加到数据表
         */
        public void addUsers(Users user){
            try{
                    //拼写添加数据的SQL语句
                    String sql = "INSERT  INTO gjp_users(uname,upassword) VALUES (?,?)";
                    //创建对象数据，存储2个占位符的实际参数
                    //实际参数来源是：传递过来的对象Users
                    Object[] params = {user.getUname(),user.getUpassword()};
                    //调用qr对象中的方法updata执行添加
                    qr.update(sql,params);
            }catch(SQLException ex){
                    System.out.println(ex);
                    throw new RuntimeException("用户添加失败");
            }
        }
        
        
        /*
         * 定义方法：查询数据库，带有条件去查询账务表
         * 由业务层调用，查询结果集存储到Bean对象，存储到List集合
         * 调用者传递2个日期字符串
         */
        public List<Users> select(String uname,String upassword){
            try{
                    //拼写条件查询的SQL语句
                    String sql = "SELECT *FROM gjp_users WHERE uname = ? AND upassword = ?";
                    //定义对象数组，存储？占位符
                    Object[] params = {uname,upassword};
                    //调用qr对象的方法query查询数据表，获取结果集
                    return qr.query(sql, new BeanListHandler<>(Users.class),params);
            }catch(SQLException ex){
                    System.out.println(ex);
                    throw new RuntimeException("无法识别用户");
            }
        }
        
        /*
         * 定义方法：查询用户信息
         * 由业务层调用
         * 结果集,将所有的账务数据，存储到Bean对象，存储到集合中
         */
        public List<Users> selectAll(){
                try{
                        //查询用户数据的SQL语句
                        String sql = "SELECT * FROM gjp_users";
                        //调用qr对象的方法，query方法，结果集BeanListHandler
                        return qr.query(sql,new BeanListHandler<>(Users.class) );
                }catch(SQLException e){
                        System.out.println(e);
                        throw new RuntimeException("查询所有用户失败");
                }
            }

}

usersController

package cn.cyxd.gjp.controller;

import java.util.List;

import cn.cyxd.gjp.domain.Users;
import cn.cyxd.gjp.service.UsersService;

/*
 * 控制器层
 * 接收视图层的数据，数据传递给service层
 * 成员位置，创建service对象
 */
public class UsersController {
        private UsersService uservice = new UsersService();
        /*
         * 定义方法：删除管理员的功能
         * 视图层调用，传递int类型的主键
         * 调用serivtce层方法，传递int主键
         */
        public void deleteUsers(int uid){
            uservice.deleteUsers(uid);
        }
        
        
        /*
         * 定义方法：实现编辑管理员的功能
         * 由视图层调用，传递Users对象参数
         * 调用service层的方法，传递Users对象
         */
        public void editUsers(Users user){
            uservice.editUsers(user);
        }
        
        /*
         * 定义方法，实现管理员添加功能
         * 由视图层调用，传递参数(传递的是1个Users类型的对象)
         * 方法调用service层的方法，传递Users对象，获取到添加后的结果集(添加成功的行数，int)
         */
        public void addUsers(Users user){
            uservice.addUsers(user);
        }
        /*
         * 定义方法，实现判断用户是否存在
         * 方法由视图层调用，传递两个日期的字符串
         * 调用service层，
         */
        public List<Users> select(String uname,String upassword){
            return uservice.select(uname, upassword);
        }
        
        /*
         * 控制层类定义方法，查询所有的管理员数据
         * 方法由视图层调用，方法调用service层
         */
        public List<Users> selectAll(){
            return uservice.selectAll();
        }
}

ZhangWuController

package cn.cyxd.gjp.controller;

import java.util.List;

import cn.cyxd.gjp.domain.ZhangWu;
import cn.cyxd.gjp.service.ZhangWuService;

/*
 * 控制器层
 * 接收视图层的数据，数据传递给service层
 * 成员位置，创建service对象
 */
public class ZhangWuController {
        private ZhangWuService service = new ZhangWuService();
        /*
         * 定义方法：删除账务功能
         * 视图层调用，传递int类型的主键
         * 调用serivtce层方法，传递int主键
         */
        public void deleteZhangWu(int zwid){
            service.deleteZhangWu(zwid);
        }
        
        
        /*
         * 定义方法：实现编辑账务功能
         * 由视图层调用，传递ZhangWu对象参数
         * 调用service层的方法，传递ZhangWu对象
         */
        public void editZhangWu(ZhangWu zw){
            service.editZhangWu(zw);
        }
        
        /*
         * 定义方法，实现账务添加功能
         * 由视图层调用，传递参数(传递的是1个ZhangWu类型的对象)
         * 方法调用service层的方法，传递ZhangWu对象，获取到添加后的结果集(添加成功的行数，int)
         */
        public void addZhangWu(ZhangWu zw){
            service.addZhangWu(zw);
        }
    
        /*
         * 定义方法，实现条件查询账务
         * 方法由视图层调用，传递两个日期的字符串
         * 调用service层，
         */
        public List<ZhangWu> select(String startDate,String endDate){
            return service.select(startDate, endDate);
        }
        
        /*
         * 控制层类定义方法，查询所有的账务数据
         * 方法由视图层调用，方法调用service层
         */
        public List<ZhangWu> selectAll(){
            return service.selectAll();
        }
}

UserDao

package cn.cyxd.gjp.dao;

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

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

import cn.cyxd.gjp.domain.Users;
import cn.cyxd.gjp.tools.JDBCUtils;



/*
 * 实现对数据表gjp_users数据增、删、改、查操作。
 * dbutils工具类完成，类成员创建QueryRunner对象，指定数据源
 */
public class UsersDao {
        private QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
        
        /*
         * 定义方法：实现删除用户
         * 业务层调用，传递主键id值
         */
        public void deleteUsers(int uid) {
            try {
                    //拼写删除数据SQl语句
                    String sql = "DELETE FROM gjp_users WHERE uid=?";
                    qr.update(sql, uid);
            } catch (SQLException ex) {
                    System.out.println(ex);
                    throw new RuntimeException("删除用户失败");
            }
        }
        
        /*
         * 定义方法：实现编辑用户功能
         * 由业务层调用，传递Users对象
         * 将对象中的数据，更新到数据表中
         */
        public void editUsers(Users user) {
            try{
                //拼写编辑账务的SQL语句
                String sql = "UPDATE gjp_users SET uname=?,upassword=? WHERE uid=?";
                //定义对象数组，将所有的参数传递给对象数组
                Object[] params = {user.getUname(),user.getUpassword(),user.getUid()};
                qr.update(sql, params);
            }catch (SQLException ex) {
                System.out.println(ex);
                throw new RuntimeException("很遗憾！用户编辑失败");
            }
        }
        /*
         * 定义方法：实现添加用户
         * 由业务层调用，传递Users对象
         * 将Users对象中的数据，添加到数据表
         */
        public void addUsers(Users user){
            try{
                    //拼写添加数据的SQL语句
                    String sql = "INSERT  INTO gjp_users(uname,upassword) VALUES (?,?)";
                    //创建对象数据，存储2个占位符的实际参数
                    //实际参数来源是：传递过来的对象Users
                    Object[] params = {user.getUname(),user.getUpassword()};
                    //调用qr对象中的方法updata执行添加
                    qr.update(sql,params);
            }catch(SQLException ex){
                    System.out.println(ex);
                    throw new RuntimeException("用户添加失败");
            }
        }
        
        
        /*
         * 定义方法：查询数据库，带有条件去查询账务表
         * 由业务层调用，查询结果集存储到Bean对象，存储到List集合
         * 调用者传递2个日期字符串
         */
        public List<Users> select(String uname,String upassword){
            try{
                    //拼写条件查询的SQL语句
                    String sql = "SELECT *FROM gjp_users WHERE uname = ? AND upassword = ?";
                    //定义对象数组，存储？占位符
                    Object[] params = {uname,upassword};
                    //调用qr对象的方法query查询数据表，获取结果集
                    return qr.query(sql, new BeanListHandler<>(Users.class),params);
            }catch(SQLException ex){
                    System.out.println(ex);
                    throw new RuntimeException("无法识别用户");
            }
        }
        
        /*
         * 定义方法：查询用户信息
         * 由业务层调用
         * 结果集,将所有的账务数据，存储到Bean对象，存储到集合中
         */
        public List<Users> selectAll(){
                try{
                        //查询用户数据的SQL语句
                        String sql = "SELECT * FROM gjp_users";
                        //调用qr对象的方法，query方法，结果集BeanListHandler
                        return qr.query(sql,new BeanListHandler<>(Users.class) );
                }catch(SQLException e){
                        System.out.println(e);
                        throw new RuntimeException("查询所有用户失败");
                }
            }

}

ZhangwuDao

package cn.cyxd.gjp.dao;

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

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

import cn.cyxd.gjp.domain.ZhangWu;
import cn.cyxd.gjp.tools.JDBCUtils;



/*
 * 实现对数据表gjp_zhangwu数据增、删、改、查操作。
 * dbutils工具类完成，类成员创建QueryRunner对象，指定数据源
 */
public class ZhangWuDao {
        private QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
        
        /*
         * 定义方法：实现删除账务
         * 业务层调用，传递主键id值
         */
        public void deleteZhangWu(int zwid) {
                    try{
                        //拼写删除数据SQl语句
                        String sql = "DELETE FROM gjp_zhangwu WHERE zwid=?";
                        qr.update(sql, zwid);
                } catch (SQLException ex) {
                        System.out.println(ex);
                        throw new RuntimeException("删除账务失败");
                }

        }
        
        /*
         * 定义方法：实现编辑账务功能
         * 由业务层调用，传递ZhangWu对象
         * 将对象中的数据，更新到数据表中
         */
        public void editZhangWu(ZhangWu zw) {
            try{
                //拼写编辑账务的SQL语句
                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()};
                qr.update(sql, params);
            }catch (SQLException ex) {
                System.out.println(ex);
                throw new RuntimeException("很遗憾！账务编辑失败");
            }
        }
        /*
         * 定义方法：实现添加账务功能
         * 由业务层调用，传递ZhangWu对象
         * 将ZhangWu对象中的数据，添加到数据表
         */
        public void addZhangWu(ZhangWu zw){
            try{
                    //拼写添加数据的SQL语句
                    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()};
                    //调用qr对象中的方法updata执行添加
                    qr.update(sql,params);
            }catch(SQLException ex){
                    System.out.println(ex);
                    throw new RuntimeException("账务添加失败");
            }
        }
        
        /*
         * 定义方法：查询数据库，带有条件去查询账务表
         * 由业务层调用，查询结果集存储到Bean对象，存储到List集合
         * 调用者传递2个日期字符串
         */
        public List<ZhangWu> select(String startDate,String endDate){
            try{
                    //拼写条件查询的SQL语句
                    String sql = "SELECT * FROM gjp_zhangwu WHERE createtime BETWEEN ? AND ?";
                    //定义对象数组，存储？占位符
                    Object[] params = {startDate,endDate};
                    //调用qr对象的方法query查询数据表，获取结果集
                    return qr.query(sql, new BeanListHandler<>(ZhangWu.class),params);
            }catch(SQLException ex){
                    System.out.println(ex);
                    throw new RuntimeException("条件查询失败");
            }
        }
        
        
        /*
         * 定义方法：查询数据库，获取所有的账务数据
         * 由业务层调用
         * 结果集,将所有的账务数据，存储到Bean对象，存储到集合中
         */
        public List<ZhangWu> selectAll(){
                try{
                        //查询账务数据的SQL语句
                        String sql = "SELECT * FROM gjp_zhangwu";
                        //调用qr对象的方法，query方法，结果集BeanListHandler
                        return qr.query(sql,new BeanListHandler<>(ZhangWu.class) );
                }catch(SQLException e){
                        System.out.println(e);
                        throw new RuntimeException("查询所有账务失败");
                }
            }


}

Users

package cn.cyxd.gjp.domain;

public class Users {
        private int uid;
        private String uname;
        private String upassword;
        
        public Users(int uid, String uname, String upassword) {
            super();
            this.uid = uid;
            this.uname = uname;
            this.upassword = upassword;
        }
        public Users(){
            
        }
        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 getUpassword() {
            return upassword;
        }
        public void setUpassword(String upassword) {
            this.upassword = upassword;
        }
        @Override
        public String toString() {
            return "Users [uid=" + uid + ", uname=" + uname + ", upassword="
                    + upassword + "]";
        }
        
}

ZhangWu

package cn.cyxd.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(int zwid, String flname, double money, String zhanghu,
                String createtime, String description) {
            super();
            this.zwid = zwid;
            this.flname = flname;
            this.money = money;
            this.zhanghu = zhanghu;
            this.createtime = createtime;
            this.description = description;
        }
        public ZhangWu(){
            
        }
        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 + "]";
        }
}

UsersService

package cn.cyxd.gjp.service;


import java.util.List;

import cn.cyxd.gjp.dao.UsersDao;
import cn.cyxd.gjp.domain.Users;

/*
 * 业务层类:
 * 接收上一层，控制层controller的数据
 * 经过计算，传递给dao层，操作数据库
 * 调用dao层中的类，类成员位置，创建Dao类的对象
 */
public class UsersService {
        private UsersDao udao = new UsersDao();
        
        /*
         * 定义方法：删除管理员功能
         * 由控制层调用，传递主键int
         * 调用dao层方法,传递主键int
         */
        public void deleteUsers(int uid) {
            udao.deleteUsers(uid);
        }
        
        /*
         * 定义方法：实现编辑管理员信息
         * 由控制层调用，传递Users对象
         * 调用dao层的方法，传递Users对象
         */
        public void editUsers(Users user) {
            udao.editUsers(user);
        }
        
        /*
         * 定义方法，实现添加管理员
         * 是由控制层调用，传递Users类型对象
         * 调用dao层方法，传递Users对象
         */
        public void addUsers(Users user){
            udao.addUsers(user);
        }
        
        /*
         * 定义方法：实现判断管理员是否存在
         * 方法由控制层调用，传递用户名和密码字符串
         * 调用dao层的方法，传递用户名和密码字符串
         * 获取到查询结果集
         */
        public List<Users> select(String startDate,String endDate){
            return udao.select(startDate, endDate);
        }
        
        /*
         * 定义方法：查询所有的管理员数据
         * 此方法由控制层调用，去调用dao层的方法
         */
        public List<Users> selectAll(){
            return udao.selectAll();
        }

}

ZhangWuService

package cn.cyxd.gjp.service;


import java.util.List;

import cn.cyxd.gjp.dao.ZhangWuDao;
import cn.cyxd.gjp.domain.ZhangWu;

/*
 * 业务层类:
 * 接收上一层，控制层controller的数据
 * 经过计算，传递给dao层，操作数据库
 * 调用dao层中的类，类成员位置，创建Dao类的对象
 */
public class ZhangWuService {
        private ZhangWuDao dao = new ZhangWuDao();
        
        /*
         * 定义方法：删除账务功能
         * 由控制层调用，传递主键int
         * 调用dao层方法,传递主键int
         */
        public void deleteZhangWu(int zwid) {
            dao.deleteZhangWu(zwid);
        }
        
        /*
         * 定义方法：实现编辑账务
         * 由控制层调用，传递ZhangWu对象
         * 调用dao层的方法，传递ZhangWu对象
         */
        public void editZhangWu(ZhangWu zw) {
            dao.editZhangWu(zw);
        }
        
        /*
         * 定义方法，实现添加账务
         * 是由控制层调用，传递ZhangWu类型对象
         * 调用dao层方法，传递ZhangWu对象
         */
        public void addZhangWu(ZhangWu zw){
            dao.addZhangWu(zw);
        }
        
        /*
         * 定义方法：实现条件查询账务
         * 方法由控制层调用，传递2个日期字符串
         * 调用dao层的方法，传递2个日期字符串
         * 获取到查询结果集
         */
        public List<ZhangWu> select(String startDate,String endDate){
            return dao.select(startDate, endDate);
        }
        /*
         * 定义方法：查询所有的账务数据
         * 此方法由控制层调用，去调用dao层的方法
         */
        public List<ZhangWu> selectAll(){
            return dao.selectAll();
        }

}

JDBCUtils

package cn.cyxd.gjp.tools;
/*
 * 获取数据库连接的工具类
 * 实现连接池，dbcp连接池
 */
import java.io.InputStream;
import java.util.Properties;

import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSource;

public class JDBCUtils {
        //设置四个最基本的连接信息
        private static String driverClass;
        private static String url;
        private static String username;
        private static String password;
    
        //    创建出BasicDataSource类对象
        private static BasicDataSource dataSource = new BasicDataSource();
        
        //静态代码块，对象BasicDataSource对象中的配置，自定义
        static{
            try {
                readConfig();
                //数据库连接信息，必须的
                dataSource.setDriverClassName(driverClass);
                dataSource.setUrl(url);
                dataSource.setUsername(username);
                dataSource.setPassword(password);
                //对象链接池中的连接数量配置
                dataSource.setInitialSize(10);//初始化的链接数
                dataSource.setMaxActive(8);//最大链接数
                dataSource.setMaxIdle(5);//最大空闲数
                dataSource.setMinIdle(1);//最小空闲数
            } catch (Exception e) {
                e.printStackTrace();
                System.out.println("数据链接失败");
            }
        }
        
        //读取配置文件
        private static void readConfig()  throws Exception{
            InputStream in = JDBCUtils.class.getClassLoader().getResourceAsStream("database.properties");
            Properties pro = new Properties();
            pro.load(in);
            driverClass = pro.getProperty("driverClass");
            url = pro.getProperty("url");
            username = pro.getProperty("username");
            password = pro.getProperty("password");
        }
        
        public static DataSource getDataSource(){
            return dataSource;
        }
}