管家婆家庭记账软件
目录
第一章 项目介绍
管家婆家庭记账软件
1.1 项目安排
1.1.1 项目目标
本项目为JAVAEE基础班综合项目，包含了若干个知识点，达到将基础班所学知识综合使用，提高了我们对项目的理解与知识点的运用。
熟练View层、Service层、Dao层之间的方法相互调用操作、
熟练dbutils操作数据库表完成增删改查
通过本项目，让我们了解公司项目开发的流程，充分的掌握项目需求分析、设计与功能的代码实现。提高同学们独立分析需求与功能实现的能力。
1.2 项目功能分析
1.2.1 项目功能介绍
- 查询账务
- 多条件组合查询账务
- 添加账务
- 编辑账务
- 删除账务
第二章 项目环境搭建
2.1 技术选型和jar包介绍
每个项目都要使用一些已经成熟的技术，它们通常是由一些专业组织或团队所提供的开源免费技术。在今后的学习过程中，我们会逐渐对这些专业组织有所了解。本项目中使用的技术如下：
apache的commons组件：
- commons-dbutils-1.4.jar：封装并简化了JDBC；
- commons-dbcp-1.4.jar：apache commons提供的数据库连接池组件，命名为DBCP；
- commons.pool-1.3.jar：DBCP连接池依赖该jar包；
- mysql-connector-java-5.1.28-bin.jar：MySQL的JDBC驱动包，用JDBC连接MySQL数据库必须使用该JAR包。
2.2 工具类介绍
每个项目都会用到一些工具类，本项目也不例外。我们不会教大家如何实现这些类，而是让大家知道在项目我们如何使用这些工具类，下面是本项目中所使用的工具类以及介绍：
JDBCUtils：用来创建数据库连接池对象；
在项目的实现过程中，我们会说明工具类的使用，这里就不再过多介绍。
2.3 数据表创建
对一个项目而言，表设计是非常重要的，因为应用程序中所有的操作都是基于数据库表而进行的，所以我们第一步就是创建数据库表。
管家婆项目的数据库设计很简单，我们只需找到gjp.sql文件，然后执行之即可。下面是创建库及表的SQL语句：
2.3.1 创建数据库
/*
创建管家婆的数据库
名字 gjp
*/
CREATE DATABASE gjp;
2.3.2 创建数据库表
CREATE TABLE gjp_zhangwu (
zwid INT PRIMARY KEY AUTO_INCREMENT,
flname VARCHAR(200),
money DOUBLE,
zhangHu VARCHAR(100),
createtime DATE,
description VARCHAR(1000)
);
2.3.3 添加表数据
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','又开资');
2.4 项目分层（分包）的作用
程序为什么要分包分层?
以顾客去饭店吃饭案例分析一下：
小饭店: 一个服务员搞定(接待顾客\点菜\炒菜)
大饭店:
- 迎宾员(是否有预定\ 询问吃中餐还是西餐或者烧烤等\ 几位用餐 \ 领路到指定的包间\ 找点菜员为顾客点菜 )
- 点菜员(记录顾客点餐内容\ 记录是否有忌口等问题\ 找厨师为顾客炒菜)
- 厨师(按照顾客菜肴清单,进行炒菜)
通过案例发现，当程序规模小的时候，可以一个人全部完成；但程序规模大的时候，一个人难以完成，这时，要采用多人合作的方式来完成程序开发。
多人合作方式将会碰到工作任务分配问题，这时我们会想，每个人负责完成项目的一块内容就可以了。那么，这一块块内容的划分，就需要我们采用分层（分包）的方式完成了。
通过下图（用户注册功能）来讲解下，项目中常见的分层（分包）。
- view层作用: 视图层,即项目中的界面
- controller层作用: 控制层, 获取界面上的数据,为界面设置数据; 将要实现的功能交给业务层处理
- service层作用: 业务层, 功能的实现, 与controller控制层和数据访问层DAO交互, 将对数据库的操作交给DAO数据访问层来处理
- dao层作用: 数据访问层, 用来操作数据库表的数据
- db数据库: 这里指MySQL
- domain 实体包: 存放JavaBean
- tools工具包:存放项目中使用到的工具类
- test 测试包: 存放项目功能测试的代码
2.5 工程创建及包管理
1.使用Eclipse创建Java工程，命名为gjp
2. 创建工程包
- cn.itcast.gjp.app: 存放main方法类；
- cn.itcast.gjp.domain: 存放JavaBean；domain包与数据库是有关联的
- cn.itcast.gjp.view: 存放界面，及表现层类；
- cn.itcast.gjp.service: 存放业务层类；
- cn.itcast.gjp.dao: 存放数据访问层类;
- cn.itcast.gjp.tools:存放工具类
- cn.itcast.gjp.controller: 存放从界面上获取的数据。
3. 创建lib文件夹，用来存储使用的jar包
第三章 功能模块
3.1 相关类创建
完成本项目中类的创建，无需在类中添加代码。
- 复制已编写好的工具类JDBCUtils.java 到 tools包中；
- 复制jar包mysql-connector-java-5.1.28-bin.jar[L1] 、commons-dbutils-1.4.jar[L2] 、commons-dbcp-1.4.jar[L3] 、commons-pool-1.3.jar[L4]，到lib文件夹中，通过Build Path操作，添加到classPath路径中，提供给JDBCUtils使用;
- 在app包中，创建类MainApp.java，编写main主方法，用来完成本项目的启动
- 在domain包中，创建类ZhangWu.java，它是用来封装账务信息的JavaBean。
- 在dao包中，创建类ZhangWuDao.java，给ZhangWuDao类添加一个成员变量QueryRunner对象，因为我们使用dbutils来操作数据库。
- 在service包中，创建类ZhangWuService.java，给ZhangWuService类添加一个类型为ZhangWuDao的成员变量，因为service依赖dao。
- 在view包中，创建类MainView.java，给MainView类添加一个类型为ZhangWuService的成员变量，因为本项目中view依赖service。
MySQL的JDBC驱动包，用JDBC连接MySQL数据库必须使用该JAR包
1. 编写tools中的JDBCUtils.java：
package cn.itcast.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("");
datasource.setMaxActive(10);
datasource.setMaxIdle(5);
datasource.setMinIdle(2);
datasource.setInitialSize(10);
}
public static DataSource getDataSource(){
return datasource;
}
}
/*
* private static DataSource datasource1 ;
* datasource1= BasicDataSourceFactory.createDataSource(Properties键值对)
* createDataSource返回值,返回的是DataSource接口实现类
*/ 2.编写domain包中ZhangWu.java：
package cn.itcast.gjp.domain;
public class ZhangWu {
}3.编写app包中MainApp.java
package cn.itcast.gjp.app;
public class MainApp {
public static void main(String[] args) {
// TODO Auto-generated method stub
}
}
4.编写Dao包中ZhangWuDao.java
package cn.itcast.gjp.dao;
import org.apache.commons.dbutils.QueryRunner;
import cn.itcast.gjp.tools.JDBCUtils;
public class ZhangWuDao {
private QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
}
5.编写Service包，ZhangWuService.java
package cn.itcast.gjp.service;
import cn.itcast.gjp.dao.ZhangWuDao;
public class ZhangWuService {
private ZhangWuDao dao = new ZhangWuDao();
}
6.编写controller包，ZhangWuController.java
package cn.itcast.gjp.controller;
import cn.itcast.gjp.service.ZhangWuService;
public class ZhangWuController {
private ZhangWuService service = new ZhangWuService();
}
7.编写view包，MainView.java
package cn.itcast.gjp.view;
import cn.itcast.gjp.controller.ZhangWuController;
public class MainView {
private ZhangWuController controller = new ZhangWuController();
}
3.2 账务JavaBean
JavaBean是指的是Java中的类，该类中的成员变量与数据库表中的字段相对应（变量名对应数据库表字段名、变量数据类型对应数据库表字段类型），并提供空参数构造方法、set、get方法。
我们现在来完成账务类的代码编写，如下：
package cn.itcast.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() {
super();
// TODO Auto-generated constructor stub
}
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 + "]";
}
}
3.3 功能界面菜单
界面菜单的完成，是项目编写的第一步。
我们通过输出语句，完成界面菜单的输出，之后再根据输入的功能序号，进行对应功能的调用执行。
3.3.1 功能实现步骤
1.编写MainView类run方法
- 完成功能界面菜单显示
- 接收键盘输入的功能选项
- 根据选项值，调用对应的功能方法
2. 编写MainApp类的main主方法
- 调用MainView类中run方法，实现将程序执行起来，显示功能界面菜单。
3.3.2 功能实现代码
1.在view包MainView类中编写run方法
package cn.itcast.gjp.view;
import java.util.Scanner;
import cn.itcast.gjp.controller.ZhangWuController;
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;
}
}
}
/*
* 定义方法 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 select() {
}
public void selectAll() {
//调用控制层中的方法,查询所有的账务数据
}
public void deleteZhangWu() {
}
public void editZhangWu() {
}
public void addZhangWu() {
}
}
2.app包MainApp类的main主方法中，调用MainView类中run方法
public static void main(String[] args) {
new MainView().run();
}
3.4 查询所有账务
3.4.1 功能分析
1.编写MainView类中selectZhangWu方法
- 通过输出语句，显示出要查询账务的方式
- 接收键盘的输入项，调用对应的方法（1.查询所有 2.按条件查询）
2. 编写MainView类中selectAll查询所有账务方法
- 调用ZhangWuService类selectAll方法，返回包含所有账务数据的List<ZhangWu>集合
- 调用MainView类中print方法，实现控制台显示所有账务数据
3. 编写controller类的selectAll方法
4..编写ZhangWuService类中selectAll方法
- 调用ZhangWuDao类中selectAll方法，返回包含所有账务数据的List<ZhangWu>集合
5. 编写ZhangWuDao类中selectAll()方法
- 通过QueryRunner对象，调用query方法查询数据库表gjp_zhangwu，返回包含所有账务数据的List<ZhangWu>集合
- 控制层调用业务层，业务层调用dao层，dao层查询数据库。
- 查询结果的返回值是数据库中的多行数据，因此返回值应该为每行封装成Bean，然后组成的List集合。即javabean对象，因为domain包中为ZhangWu类。因此返回对象应为List<ZhangWu>对象。
3.4.2 功能实现代码
1.编写MainView类中selectZhangWu、selectAll方法
package cn.itcast.gjp.view;
import java.util.List;
import java.util.Scanner;
import cn.itcast.gjp.controller.ZhangWuController;
import cn.itcast.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);
break;
}
}
}
/*
* 定义方法 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 select() {
}
public void selectAll() {
//调用控制层中的方法,查询所有的账务数据
List<ZhangWu> list = controller.selectAll();
//输出表头
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());
}
}
public void deleteZhangWu() {
}
public void editZhangWu() {
}
public void addZhangWu() {
}
//输出账务数据方法,接收List集合,遍历集合,输出表格
}
2. 编写controller类的selectAll方法
package cn.itcast.gjp.controller;
import java.util.List;
import cn.itcast.gjp.domain.ZhangWu;
import cn.itcast.gjp.service.ZhangWuService;
public class ZhangWuController {
private ZhangWuService service = new ZhangWuService();
/*
* 定义方法,实现条件查询账务
* 方法由试图层调用,传递两个日期的字符串
* 调用service层的方法,传递两个日期字符串,获取结果集
* 结果集返回给试图
*/
// public List<ZhangWu> select(){
// return service.select();
// }
/*
* 控制层类定义方法,实现查询所有的账务数据
* 方法由试图层调用,方法调用service层
*/
public List<ZhangWu> selectAll(){
return service.selectAll();
}
}
3.编写ZhangWuService类中selectAll方法
package cn.itcast.gjp.service;
import java.util.List;
import cn.itcast.gjp.dao.ZhangWuDao;
import cn.itcast.gjp.domain.ZhangWu;
public class ZhangWuService {
private ZhangWuDao dao = new ZhangWuDao();
/*
* 定义方法,实现条件查询账务
* 方法由控制层调用,传递2个日期字符串
* 调用dao层的方法,传递2个日期字符串
* 获取到查询结果集
*/
// public List<ZhangWu> select(){
// return dao.select();
// }
/*
* 定义方法,实现查询所有的账务数据
* 此方法,由控制层调用, 去调用dao层的方法
* 返回存储ZhangWu对象的List集合
*/
public List<ZhangWu> selectAll(){
return dao.selectAll();
}
}
4.编写ZhangWuDao类中selectAll()方法
package cn.itcast.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.itcast.gjp.domain.ZhangWu;
import cn.itcast.gjp.tools.JDBCUtils;
public class ZhangWuDao {
private QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
public List<ZhangWu> selectAll(){
try{
//查询账务数据的SQL语句
String sql = "SELECT * FROM gjp_zhangwu";
//调用qr对象的方法,query方法,结果集BeanListHandler
List<ZhangWu> list = qr.query(sql, new BeanListHandler<>(ZhangWu.class));
return list;
}catch(SQLException ex){
System.out.println(ex);
throw new RuntimeException("查询所有账务失败");
}
}
// public List<ZhangWu> select(){
//
// }
}
3.5 多条件查询账务
3.5.1 功能分析
1. 编写MainView类中select方法
- 通过键盘输入查询日期的范围
- 调用ZhangWuSerice类中select方法，返回查询日期范围内的账务信息集合List<ZhangWu>
- 调用MainView类中的print方法，将账务信息集合中的内容显示在控制台中
2. 编写MainView类中print方法
- 使用输出语句，打印出账务表的表头名称
- 遍历账务集合，将每个账务信息输出打印
3. 编写ZhangWuController类中select方法
4. 编写ZhangWuService类中select方法
- 调用ZhangWuDao 类中select方法，返回查询日期范围内的账务信息集合List<ZhangWu>
5. 编写ZhangWuDao类中select方法
- 通过QueryRunner对象，调用query方法查询数据库表gjp_zhangwu，返回包含查询日期范围内的账务数据List<ZhangWu>集合
- 打印信息，代码重复率太高，因此将打印信息的代码进行方法抽取，alt+shift+m
3.5.2 功能实现步骤
1. 编写MainView类中select方法
package cn.itcast.gjp.view;
import java.util.List;
import java.util.Scanner;
import cn.itcast.gjp.controller.ZhangWuController;
import cn.itcast.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);
break;
}
}
}
/*
* 定义方法 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;
}
}
/*
* 定义方法,实现条件查询账务数据
* 提供用户的输入日期,开始日期结束日期
* 就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("没有查询到数据");
}
public void selectAll() {
//调用控制层中的方法,查询所有的账务数据
List<ZhangWu> list = controller.selectAll();
print(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());
}
}
public void deleteZhangWu() {
}
public void editZhangWu() {
}
public void addZhangWu() {
}
//输出账务数据方法,接收List集合,遍历集合,输出表格
}
2. 编写ZhangWuController类中select方法
package cn.itcast.gjp.controller;
import java.util.List;
import cn.itcast.gjp.domain.ZhangWu;
import cn.itcast.gjp.service.ZhangWuService;
public class ZhangWuController {
private ZhangWuService service = new ZhangWuService();
/*
* 定义方法,实现条件查询账务
* 方法由试图层调用,传递两个日期的字符串
* 调用service层的方法,传递两个日期字符串,获取结果集
* 结果集返回给试图
*/
public List<ZhangWu> select(String startDate,String endDate){
return service.select(startDate, endDate);
}
/*
* 控制层类定义方法,实现查询所有的账务数据
* 方法由试图层调用,方法调用service层
*/
public List<ZhangWu> selectAll(){
return service.selectAll();
}
}
3. 编写ZhangWuService类中select方法
package cn.itcast.gjp.service;
import java.util.List;
import cn.itcast.gjp.dao.ZhangWuDao;
import cn.itcast.gjp.domain.ZhangWu;
public class ZhangWuService {
private ZhangWuDao dao = new ZhangWuDao();
/*
* 定义方法,实现条件查询账务
* 方法由控制层调用,传递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();
}
}
4.编写ZhangWuDao类中select方法
package cn.itcast.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.itcast.gjp.domain.ZhangWu;
import cn.itcast.gjp.tools.JDBCUtils;
public class ZhangWuDao {
private QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
public List<ZhangWu> selectAll(){
try{
//查询账务数据的SQL语句
String sql = "SELECT * FROM gjp_zhangwu";
//调用qr对象的方法,query方法,结果集BeanListHandler
List<ZhangWu> list = qr.query(sql, new BeanListHandler<>(ZhangWu.class));
return list;
}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("条件查询失败");
}
}
}
运行结果：
只需要运行MainApp.java
3.6 添加账务
3.6.1 功能分析
1. 编写MainView类中addZhangWu方法
- 键盘输入新添加的账务信息
- 调用ZhangWuService类中addZhangWu方法，用来指定账务的添加
- 添加完毕后，使用输出语句，提示“添加账务成功！”
2. 编写ZhangWuController类中addZhangWu方法
- 调用ZhangWuService类中addZhangWu方法
3. 编写ZhangWuService类中addZhangWu方法
- 调用ZhangWuDao类中addZhangWu方法，用来指定账务的添加
4. 编写ZhangWuDao类中addZhangWu方法
- 通过QueryRunner对象，调用update方法更新数据库表gjp_zhangwu，完成指定账务添加到数据库表中
3.6.2 功能实现步骤
1. 编写MainView类中addZhangWu方法
数据库中自动增加的值，不用传递。写的时候，写默认值0即可。
//将用户输入的所有参数，封装成ZhangWu对象
ZhangWu zw = new ZhangWu(0, flname, money, zhanghu, createtime, description);/*
* 定义方法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("恭喜添加账务成功");
}
2.编写controller中的ZhangWuController.java
传递参数(传递过来的参数不能是5个数据，传递的是一个ZhangWu类型的对象)
/*
* 定义方法，实现账务添加功能
* 由视图层调用，传递参数(传递过来的参数不能是5个数据，传递的是一个ZhangWu类型的对象)
* 本方法调用service层的方法，传递ZhangWu对象，获取到添加后的结果集(添加成功影响的行数，int)
*
*/
public void addZhangWu(ZhangWu zw) {
service.addZhangWu(zw);
}
3. 编写ZhangWuService类中addZhangWu方法
/*
* 定义方法，实现添加账务
* 是由控制层调用，传递ZhangWu对象
*/
public void addZhangWu(ZhangWu zw) {
dao.addZhangWu(zw);
}4.编写ZhangWuDao类中addZhangWu方法
/*
* 定义方法，实现添加账务功能
* 由业务层调用，传递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("账务添加失败");
}
}
3.7 编辑账务
3.7.1功能分析
1.编写MainView类中editZhangWu方法
- 键盘输入要编辑的账务信息ID号
- 键盘输入要修改的账务信息内容
- 调用ZhangWuService类中editZhangWu方法，用来将指定的账务信息进行更新
- 更新完毕后，使用输出语句，提示 “编辑账务成功！”
2.编写ZhangWuController中的editZhangWu方法
3.编写ZhangWuService类中editZhangWu方法
- 调用ZhangWuDao类中editZhangWu方法，用来将指定的账务信息进行更新
4.编写ZhangWuDao类中editZhangWu方法
- 通过QueryRunner对象，调用update方法更新数据库表gjp_zhangwu，完成数据库表中指定账务更新操作
3.7.2 功能实现步骤
1. 编写MainView类中editZhangWu方法
/*
* 定义方法，实现对账务的编辑功能
* 实现思想：
* 接收用户的输入的信息
* 封装成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("账务编辑成功");
}2.编写ZhangWuController中的editZhangWu方法
/*
* 定义方法，实现编辑账务功能
* 由视图层调用，传递参数，也是ZhangWu对象
* 调用service层的方法，也是ZhangWu对象
*/
public void editZhangWu(ZhangWu zw) {
service.editZhangWu(zw);
}
3. 编写ZhangWuService类中editZhangWu方法
/*
* 定义方法，实现编辑账务
* 由控制层调用，传递ZhangWu对象
* 调用dao层的方法，传递ZhangWu对象
*/
public void editZhangWu(ZhangWu zw) {
dao.editZhangWu(zw);
}4.编写ZhangWuDao类中editZhangWu方法
/*
* 定义方法，实现编辑功能
* 由业务层调用，传递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执行更新
qr.update(sql, params);
} catch (SQLException ex) {
System.out.println(ex);
throw new RuntimeException("编辑账务失败");
}
}
3.8 删除账务
3.8.1 功能分析
1. 编写MainView类中deleteZhangWu方法
- 键盘输入要删除的账务信息ID号
- 调用ZhangWuService类中deleteZhangWu方法，用来将指定的账务信息删除
- 删除完毕后，使用输出语句，提示 “删除账务成功！”
2. 编写ZhangWuController 类中deleteZhangWu方法
3. 编写ZhangWuService类中deleteZhangWu方法
- 调用ZhangWuDao类中deleteZhangWu方法，用来将指定的账务信息删除
4. 编写ZhangWuDao类中deleteZhangWu方法
- 通过QueryRunner对象，调用update方法更新数据库表gjp_zhangwu，完成数据库表中指定账务删除操作
3.8.2 功能实现步骤
1. 编写MainView类中deleteZhangWu方法
/*
* 定义方法，实现账务删除
* 实现思想：
* 接收用户的输入，输入一个主键数据
* 调用控制层方法，传递一个主键
*/
public void deleteZhangWu() {
//调用查询所有账务数据的功能，显示出来
//看到所有数据，从中选择一项，进行修改
selectAll();
System.out.println("选择的是删除功能，请输入序号即可");
int zwid = new Scanner(System.in).nextInt();
//调用控制层方法，传递主键id即可
controller.deleteZhangWu(zwid);
System.out.println("删除账务成功");
}2. 编写ZhangWuController 类中deleteZhangWu方法
/*
* 定义方法，实现删除功能
* 视图层调用，传递int类型主键
* 调用service层方法，传递int主键
*/
public void deleteZhangWu(int zwid) {
service.deleteZhangWu(zwid);
}3. 编写ZhangWuService类中deleteZhangWu方法
/*
* 定义方法，实现删除账务功能
* 由控制层调用，传递主键id
* 调用dao层方法，传递主键id
*/
public void deleteZhangWu(int zwid) {
dao.deleteZhangWu(zwid);
}4. 编写ZhangWuDao类中deleteZhangWu方法
/*
* 定义方法，实现删除业务
* 业务层调用，传递主键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("删除账务失败");
}
}
第四章 总结
通过分类模块功能的实现，大家可能会发现如下几个问题：
1. 难度大的地方：自行功能分析的能力欠缺，需要讲师来分析；
2. 代码实现：
- View（Controller）：代码量最大；
- Service层：代码量最小；
- DAO层：相似度高，难度不大；
view层的作用是“界面”，用来完成数据显示给用户。当前项目view层中，包含了Controller层代码。
Controller层的作用是“调度”，调度的是表现层view和业务层Service，主要功能分为：一是把表现层的数据交给业务层处理；二是把业务层返回的数据交给表现层显示。至于为什么这一层View（Controller）的代码量大，这里我要说明一下，其实不是View（Controller）层的代码量大，而是其他层代码量少，所以你会感觉View（Controller）层代码量大。
Service层的作用是“业务”，我们也可以把“业务”当成是“功能”。那为什么Service层代码量少呢？原因是现在我们写的项目很小，没有什么复杂的业务，而今后大家要写的大型项目代码量最大的就是Service层。
DAO层是操作数据库，现在我们使用的是commons-dbutils工具来简化JDBC，所以我们发现代码不多，比较简单。最后我们还会学习其他DAO层的工具，例如：hibernate和mybatis，他们都是JDBC的封装，用来简化JDBC。
全部代码：
app包中的MainApp.java:
package cn.itcast.gjp.app;
import cn.itcast.gjp.view.MainView;
/*
* 主程序类,作用,开启软件程序
*/
public class MainApp {
public static void main(String[] args) {
// TODO Auto-generated method stub
new MainView().run();
}
}
view包中的MainView.java：
package cn.itcast.gjp.view;
import java.util.List;
import java.util.Scanner;
import cn.itcast.gjp.controller.ZhangWuController;
import cn.itcast.gjp.domain.ZhangWu;
/*
* 视图层,用户看到和操作的界面
* 数据传递给controller层实现
* 成员位置,创建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;
}
}
}
/*
* 定义方法，实现对账务的编辑功能
* 实现思想：
* 接收用户的输入的信息
* 封装成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("账务编辑成功");
}
/*
* 定义方法 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;
}
}
/*
* 定义方法,实现条件查询账务数据
* 提供用户的输入日期,开始日期结束日期
* 就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("没有查询到数据");
}
public void selectAll() {
//调用控制层中的方法,查询所有的账务数据
List<ZhangWu> list = controller.selectAll();
print(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());
}
}
/*
* 定义方法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("恭喜添加账务成功");
}
//输出账务数据方法,接收List集合,遍历集合,输出表格
/*
* 定义方法，实现账务删除
* 实现思想：
* 接收用户的输入，输入一个主键数据
* 调用控制层方法，传递一个主键
*/
public void deleteZhangWu() {
//调用查询所有账务数据的功能，显示出来
//看到所有数据，从中选择一项，进行修改
selectAll();
System.out.println("选择的是删除功能，请输入序号即可");
int zwid = new Scanner(System.in).nextInt();
//调用控制层方法，传递主键id即可
controller.deleteZhangWu(zwid);
System.out.println("删除账务成功");
}
}
controller包中的ZhangWuController.java
package cn.itcast.gjp.controller;
/*
* 控制器层
* 接收视图层的数据,数据传递给service层
* 成员位置,创建service对象
*/
import java.util.List;
import cn.itcast.gjp.domain.ZhangWu;
import cn.itcast.gjp.service.ZhangWuService;
public class ZhangWuController {
private ZhangWuService service = new ZhangWuService();
/*
* 定义方法，实现编辑账务功能
* 由视图层调用，传递参数，也是ZhangWu对象
* 调用service层的方法，也是ZhangWu对象
*/
public void editZhangWu(ZhangWu zw) {
service.editZhangWu(zw);
}
/*
* 定义方法，实现删除功能
* 视图层调用，传递int类型主键
* 调用service层方法，传递int主键
*/
public void deleteZhangWu(int zwid) {
service.deleteZhangWu(zwid);
}
/*
* 定义方法，实现账务添加功能
* 由视图层调用，传递参数(传递过来的参数不能是5个数据，传递的是一个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包中的ZhangWuService.java：
package cn.itcast.gjp.service;
import java.util.List;
import cn.itcast.gjp.dao.ZhangWuDao;
import cn.itcast.gjp.domain.ZhangWu;
/*
* 业务层类
* 接收上一层,控制层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对象
*/
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包中的ZhangWuDao.java:
package cn.itcast.gjp.dao;
/*
* 实现对数据表 gjp_zhangwu 数据增删改查操作
* dbuils工具类完成,类成员创建QueryRunner对象,指定数据源
*/
import java.sql.SQLException;
import java.util.List;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import cn.itcast.gjp.domain.ZhangWu;
import cn.itcast.gjp.tools.JDBCUtils;
public class ZhangWuDao {
private QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
/*
* 定义方法，实现编辑功能
* 由业务层调用，传递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执行更新
qr.update(sql, params);
} catch (SQLException ex) {
System.out.println(ex);
throw new RuntimeException("编辑账务失败");
}
}
/*
* 定义方法，实现删除业务
* 业务层调用，传递主键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对象
* 将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("账务添加失败");
}
}
public List<ZhangWu> selectAll(){
try{
//查询账务数据的SQL语句
String sql = "SELECT * FROM gjp_zhangwu";
//调用qr对象的方法,query方法,结果集BeanListHandler
List<ZhangWu> list = qr.query(sql, new BeanListHandler<>(ZhangWu.class));
return list;
}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("条件查询失败");
}
}
}
domain中的ZhangWu.java:
package cn.itcast.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) {
this.zwid = zwid;
this.flname = flname;
this.money = money;
this.zhanghu = zhanghu;
this.createtime = createtime;
this.description = description;
}
public ZhangWu() {
}
@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;
}
}
tools中的JDBCUtils.java：
package cn.itcast.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("");
datasource.setMaxActive(10);
datasource.setMaxIdle(5);
datasource.setMinIdle(2);
datasource.setInitialSize(10);
}
public static DataSource getDataSource(){
return datasource;
}
}
/*
* private static DataSource datasource1 ;
* datasource1= BasicDataSourceFactory.createDataSource(Properties键值对)
* createDataSource返回值,返回的是DataSource接口实现类
*/
gjp.sql:
/*
创建管家婆的数据库
名字 gjp
*/
CREATE DATABASE gjp;
USE gjp;
/*
创建数据表,表名账务
字段,列
主键
分类名称 可变字符
金额 double
账户 可变字符 (支付,收入方法)
创建日期 date
账务描述 可变字符
*/
CREATE TABLE gjp_zhangwu(
-- 主键
zwid INT PRIMARY KEY AUTO_INCREMENT,
-- 分类名称
flname VARCHAR(200),
-- 金额
money DOUBLE,
-- 账户
zhanghu VARCHAR(100),
-- 创建日期
createtime DATE,
-- 账务描述
description VARCHAR(1000)
);
SELECT * FROM gjp_zhangwu
-- 写入测试的数据
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','又开资');
代码和环境配置的jar包
网盘链接：https://pan.baidu.com/s/1cZq2US675Zrc0z89il3DUw
提取码：u41g
636
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
