JavaSE综合案例——管家婆家庭记账软件

用JavaSE实现一个控制台记账软件：

5个功能模块：1.添加账务、2.编辑账务、3.删除账务、4.查询账务（全部查询、条件查询）、5.退出系统

使用到了Apache commons项目下的3个工具类和mysql数据库驱动：

整个工程分为7个层：view层、controller层、service层、dao层、database层、tools层、test层

test层：

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

view层：

/*
 * 视图层，用户看到和操作的界面（用控制台去模拟）
 * 数据传递给controller层实现
 */
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);
				break;
			}

		}
	}
	
	/*
	 * 定义方法,实现账务删除
	 * 实现思想：
	 * 	接收用户的输入，输入一个主键数据
	 * 	调用控制层方法，传递一个主键
	 */
	public void deleteZhangWu() {
		//调用查询所有账务数据的功能，显示出来
		//看到所有数据，从中选择一项，进行删除
		selectAll();
		System.out.println("选择的是删除功能,输入序号");
		int zwid = new Scanner(System.in).nextInt();
		//调用控制层方法，传递主键id即可
		controller.deleteZhangWu(zwid);
		System.out.println("删除账务成功");
	}
	/*
	 * 定义方法，实现对账务的编辑功能
	 * 实现思想：
	 * 	接收用户输入
	 * 	数据的信息，封装成ZhangWu对象
	 * 	调用控制层的方法，传递ZhangWu对象，实现编辑
	 */
	public void editZhangWu() {
		//调用查询所有账务数据的功能，显示出来
		//看到所有数据，从中选择一项，进行修改
		selectAll();
		System.out.println("选择的是编辑功能，请输入数据：");
		Scanner sc = new Scanner(System.in);
		//接收用户的数据
		System.out.print("输入ID：");
		int zwid = sc.nextInt();
		System.out.println("输入分类名称");
		String flname = sc.next();
		System.out.println("输入金额");
		double money = sc.nextDouble();
		System.out.println("输入账户");
		String zhanghu = sc.next();
		System.out.println("输入日期:格式 XXXX-XX-XX");
		String createtime = sc.next();
		System.out.println("输入具体描述");
		String description = sc.next();
		//将所有用户输入的数据，封装到ZhangWu对象中
		//输入的ID，必须封装到对象中
		ZhangWu zw = new ZhangWu(zwid, flname, money, zhanghu, createtime, description);
		//调用controller层中的方法，实现编辑账务
		controller.editZhangWu(zw);
		System.out.println("账务编辑成功");
	}
	/*
	 * 定义方法，addZhangWu
	 * 添加账务的方法，用户在界面中选择菜单1的时候调用
	 * 实现思想：
	 * 	接收键盘输入，5项输入，调用controller层方法
	 */
	public void addZhangWu() {
		System.out.println("选择的添加账务功能，请输入以下内容");
		Scanner sc = new  Scanner(System.in);
		System.out.println("输入分类名称");
		String flname = sc.next();
		System.out.println("输入金额");
		double money = sc.nextDouble();
		System.out.println("输入账户");
		String zhanghu = sc.next();
		System.out.println("输入日期:格式 XXXX-XX-XX");
		String createtime = sc.next();
		System.out.println("输入具体描述");
		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 selectChooser = sc.nextInt();
		//根据用户的选择，调用不同的功能
		switch(selectChooser) {
		case 1:
			//选择的是查询所有，调用查询所有的方法
			selectAll();
			break;
		case 2:
			//选择的是条件查询，调用带有查询条件的方法
			select();
			break;
		}
	}
	/*
	 * 定义方法，实现查询所有的账务数据
	 */
	public void selectAll() {
		//调用控制层中的方法，查询所有账务数据
		List<ZhangWu> list = controller.selectAll();
		//输出表头
		if(list.size() != 0)
			print(list);
		else {
			System.out.println("没有查询到数据");
		}
	}
	
	/*
	 * 定义方法，实现条件查询账务数据
	 * 提供用户输入日期，开始日期、结束日期
	 * 将2个日期，传递到controller层
	 * 调用controller层的方法，传递2个日期参数
	 * 获取到controller层查询的结果集，打印出来
	 */
	public void select() {
		System.out.println("选择条件查询，输入日期格式：XXXX-XX-XX");
		Scanner sc = new Scanner(System.in);
		System.out.print("请输入开始日期:");
		String startDate = sc.nextLine();
		System.out.print("请输入结束日期:");
		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"+zw.getDescription());
		}
	}
}

controller层：

/*
 * 控制器层
 * 接收视图层的数据，数据传递给service层
 * 成员位置，创建service对象
 */
public class ZhangWuController {
	private ZhangWuService service = new ZhangWuService();
	
	/*
	 * 定义方法，实现删除账务功能
	 * 视图层调用，传递int类型主键
	 * 调用service层方法，传递int主键
	 */
	public void deleteZhangWu(int zwid) {
		service.deleteZhangWu(zwid);
	}
	
	/*
	 * 定义方法，实现编辑账务功能
	 * 由视图层调用，传递参数，也是ZhangWu对象
	 * 调用service层方法，传递ZhangWu对象
	 */
	public void editZhangWu(ZhangWu zw) {
		service.editZhangWu(zw);
	}
	/*
	 * 定义方法，实现账户添加功能
	 * 由视图层调用，传递参数（传递过来的参数不能是5个数据，传递的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();
	}
}

service层：

/*
 * 业务层类
 * 接收上一层，控制层controller的数据
 * 经过计算，传递给dao层，操作数据库
 * 调用dao层中的方法，类的成员位置，创建dao类的对象
 */
public class ZhangWuService {
	private ZhangWuDao dao = new ZhangWuDao();
	
	/*
	 * 定义方法，实现删除账务功能
	 * 由控制层调用，传递主键id
	 * 调用dao层方法，传递主键id
	 */
	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层的方法
	 * 返回存储ZhangWu对象的List集合
	 */
	public List<ZhangWu> selectAll() {
		return dao.selectAll();
	}

	
	
}

dao层：

/*
 * 实现对数据表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 {
			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执行更新
			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对象中的方法update执行添加
			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>(ZhangWu.class), params);
		}catch(SQLException ex) {
			System.out.println(ex);
			throw new RuntimeException("条件查询失败");
		}
		
	}
	/*
	 * 定义方法，查询数据库，获取所有的账务信息
	 * 此方法，由业务层调用	
	 * 结果集，将所有的账务数据，存储到Bean对象中，再将Bean对象存储到集合中	
	 */
	public List<ZhangWu> selectAll() {
		try {
			//查询账务数据的SQL语句
			String sql = "SELECT * FROM gjp_zhangwu";
			//调用qr对象的方法,query方法，结果集BeanListHandler
			List<ZhangWu> list = qr.query(sql, new BeanListHandler<ZhangWu>(ZhangWu.class));
			return list;
		}catch(SQLException ex) {
			System.out.println(ex);
			throw new RuntimeException("查询所有账务失败");
		}
	}
}

tools层：

/*
 * 获取数据库连接的工具类
 * 实现连接池，dbcp连接池
 */
public class JDBCUtils {
	//创建BasicDataSource对象
	private static BasicDataSource dataSource = new BasicDataSource();
	//使用静态代码块，实现必要的参数设置
	static {
		dataSource.setDriverClassName("com.mysql.jdbc.Driver");
		dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/gjp");
		dataSource.setUsername("root");
		dataSource.setPassword("root");
		dataSource.setMaxActive(10);
		dataSource.setMaxIdle(5);
		dataSource.setMinIdle(2);
		dataSource.setInitialSize(10);
	}
	public static DataSource getDataSource() {
		return dataSource;
	}
}

JavaBean包（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() {
		super();
	}
	@Override
	public String toString() {
		return "ZhangWu [zwid=" + zwid + ", flname=" + flname + ", money=" + money + ", zhanghu=" + zhanghu
				+ ", createtime=" + createtime + ", 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;
	}
}