java学习笔记——基础29(数据库表项目基础练习)

发表于 | 分类于 | 阅读次数：

1、管家婆家庭记账项目
2、熟练View层、Service层、Dao层之间的方法相互调用操作
3、熟练dbutils操作数据库表完成增删改查

01项目训练目标

  • A: 项目训练目标
  • a: 项目目标
  • 综合运用前面所学习的知识点
  • 熟练View层、Service层、Dao层之间的方法相互调用操作、
  • 熟练dbutils操作数据库表完成增删改查
  • 了解公司项目开发的流程，充分的掌握项目需求分析、设计与功能的代码实现。提高同学们独立分析需求与功能实现的能力。

02项目中的功能模块

  • A: 项目中的功能模块
  • a: 五大模块
  • 查询账务
  • 多条件组合查询账务
  • 添加账务
  • 编辑账务
  • 删除账务

    03技术的选择和相关jar包

  • A: 技术的选择和相关jar包
  • a: apache的commons组件：
    ….. commons-dbutils-1.4.jar：封装并简化了JDBC；
    …..     commons-dbcp-1.4.jar：apache commons提供的数据库连接池组件，命名为DBCP；
  • b:
    ….. commons.pool-1.3.jar：DBCP连接池依赖该jar包；
    …..     mysql-connector-java-5.1.28-bin.jar：MySQL的JDBC驱动包，用JDBC连接MySQL数据库必须使用该JAR包。

04项目中的工具类

  • A: 项目中的工具类
  • a: 工具类的介绍
  • 每个项目中都会有很多个工具类，不要求每个工具类对能独立写出来，但是要会使用工具类
  • JDBCUtils：用来创建数据库连接池对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class JDBCUtils {
    private static BasicDataSource datasource  =new BasicDataSource();
    static {
        //1.注册驱动, 将驱动类加入到内容
        String drivername="com.mysql.jdbc.Driver";

        //2.获得数据库连接  DriverManager类中静态方法
        //static Connection getConnection(String url, String user, String password)
        //返回值是Connection接口的实现类,在mysql驱动程序
        //url: 数据库地址  jdbc:mysql://连接主机IP:端口号/数据库名字
        String url="jdbc:mysql://localhost:3306/qjunbase";
        String username = "root";
        String password = "root";
        datasource.setDriverClassName(drivername);
        datasource.setUrl(url);
        datasource.setUsername(username);
        datasource.setPassword(password);

        //对象连接池中的连接数量配置,可选的
        datasource.setInitialSize(10);
        datasource.setMaxActive(8);
        datasource.setMaxIdle(5);
        datasource.setMinIdle(1);
    }

    public static DataSource getDataSource(){
        return datasource;
    }

}

05数据表的设计

  • A: 数据表的设计
  • a: 数据表的设计
  • 表与表之间是有关系的
  • 主表和从表的关系
  • 主表中的主键作为从表中的外键

06创建数据库数据表写入测试数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
* A: 创建数据库数据表写入测试数据
* a: 创建数据库数据表
/*
创建管家婆的数据库
名字 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;
* b: 写入数据
-- 写入测试的数据
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','又开资');

07项目中的分层设计

  • A: 项目中的分层设计
  • a: 各层功能介绍
    ….. view层作用: 视图层,即项目中的界面
    …..     controller层作用: 控制层, 获取界面上的数据,为界面设置数据; 将要实现的功能交给业务层处理
    ….. service层作用: 业务层, 功能的实现, 与controller控制层和数据访问层DAO交互, 将对数据库的操作交给DAO数据访问层来处理
    …..     dao层作用: 数据访问层, 用来操作数据库表的数据

……. database数据库: 这里指MySQL
……. domain 实体包: 存放JavaBean
……. tools工具包:存放项目中使用到的工具类
……. test 测试包: 存放项目功能测试的代码

08创建项目_分层_导入jar包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
* A: 创建项目_分层_导入jar包
* a: 创建工程包
* cn.itcast.gjp.app: 存放main方法类；
* cn.itcast.gjp.domain: 存放JavaBean；
* cn.itcast.gjp.view: 存放界面，及表现层类；
* cn.itcast.gjp.service: 存放业务层类；
* cn.itcast.gjp.dao: 存放数据访问层类;
* cn.itcast.gjp.tools:存放工具类
* b: 导入jar包
* 在项目根路径下建立文件夹lib
* 导入以下jar包
* mysql-connector-java-5.1.37-bin.jar：数据库驱动
* commons-dbutils-1.6.jar：提供QueryRunner类方便进行增删改查操作
* commons-dbcp-1.4.jar：
* commons-pool-1.5.6.jar：提供高效的数据库连接池技术				
* 拷贝以上jar包，选定拷贝的jar包/右键/Build Path/Add to Build Path

首先，完成本项目中类的创建:

  1. 复制已编写好的工具类JDBCUtils.java 到 tools包中；
  2. 复制jar包mysql-connector-java-5.1.28-bin.jar、commons-dbutils-1.4.jar、commons-dbcp-1.4.jar、commons-pool-1.3.jar，到lib文件夹中，通过Build Path操作，添加到classPath路径中，提供给JDBCUtils使用;
  3. 在app包中，创建类MainApp.java，编写main主方法，用来完成本项目的启动
  4. 在domain包中，创建类ZhangWu.java，它是用来封装账务信息的JavaBean。
  5. 在dao包中，创建类ZhangWuDao.java，给ZhangWuDao类添加一个成员变量QueryRunner对象，因为我们使用dbutils来操作数据库。
  6. 在service包中，创建类ZhangWuService.java，给ZhangWuService类添加一个类型为ZhangWuDao的成员变量，因为service依赖dao。
  7. 在view包中，创建类MainView.java，给MainView类添加一个类型为ZhangWuService的成员变量，因为本项目中view依赖service。

09创建domain包中的类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
* A: 创建domain包中的类
* a: 案例代码
public class ZhangWu {
 private int  zwid;
  
 private String flname; 

 private double  money; 
  
 private String zhanghu;

 private String createtime; 

 private String description;
 //注意生成空参构造、有参构造、set和get方法、toString方法等
}

10创建JDBCUtils工具类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
* A：创建JDBCUtils工具类
* a: 案例代码
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("123");
	datasource.setMaxActive(10);
	datasource.setMaxIdle(5);
	datasource.setMinIdle(2);
	datasource.setInitialSize(10);
}
public static DataSource getDataSource(){
	return datasource;
}
}

11创建其他包中的类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
* A: 创建其他包中的类
* a: cn.itcast.gjp.dao包中"创建ZhangWuDao类"
"/*
*  实现对数据表 gjp_zhangwu 数据增删改查操作
*  dbuils工具类完成,类成员创建QueryRunner对象,指定数据源
*/"
public class ZhangWuDao {
private QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
}
——————————————————————————————————————————————————————————————————————————————————————
* b: cn.itcast.gjp.service包中"创建ZhangWuService类"
"/*
*  业务层类
*  接收上一层,控制层controller的数据
*  经过计算,传递给dao层,操作数据库
*  调用dao层中的类,类成员位置,创建Dao类的对象
*/"
public class ZhangWuService {
private ZhangWuDao dao = new ZhangWuDao();

}
——————————————————————————————————————————————————————————————————————————————————————
* c: cn.itcast.gjp.controller包中"建立ZhangWuController类"
"/*
*  控制器层
*  接收视图层的数据,数据传递给service层
*  成员位置,创建service对象
*/"
public class ZhangWuController {
private ZhangWuService service = new ZhangWuService();				
}
——————————————————————————————————————————————————————————————————————————————————————
* d: cn.itcast.gjp.view包中"建立MainView类"
"/*
*  试图层,用户看到和操作的界面
*  数据传递给controller层实现
*  成员位置,创建controller对象
*/"
public class MainView {
private ZhangWuController controller = new ZhangWuController();

}
——————————————————————————————————————————————————————————————————————————————————————
* e: cn.itcast.gjp.app包中"建立MainApp类"
"/*
*  主程序类,作用,开启软件程序
*/"
public class MainApp {
public static void main(String[] args) {
	new MainView().run();
}
}

12实现用户的界面菜单

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
* A: 实现用户的界面菜单
* a: 案例核心代码
* cn.itcast.gjp.view包中建立MainView类中添加run方法
/*
*  实现界面效果
*  接收用户的输入
*  根据数据,调用不同的功能方法
*/
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:
	   // 选择添加账务,调用添加账务的方法
		break;
	case 2:
		// 选择的编辑账务,调用编辑账务方法
		break;
	case 3:
		// 选择的删除账务,调用删除账务方法
		break;
	case 4:
		// 选择的是查询账务,调用查询方法
		//selectZhangWu();
		break;
	case 5:
		System.exit(0);
		break;
	}
}
}

13实现查询的界面菜单

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
* A: 实现查询的界面菜单
* a: 案例核心代码
*  cn.itcast.gjp.view包中建立MainView类中添加selectZhangWu方法、selectAll方法、select方法
/*
 * 定义方法 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(){
	 
 }

 /*
  * 定义方法,实现条件查询账务数据
  * 提供用户的输入日期,开始日期结束日期
  * 就2个日期,传递到controller层
  * 调用controller的方法,传递2个日期参数
  * 获取到controller查询的结果集,打印出来
  */
 public void select(){
	
 }

14实现查询所有账务的控制,业务层的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
* A: 实现查询所有账务的控制,业务层的实现
* a: 案例核心代码
* a: cn.itcast.gjp.dao包中创建ZhangWuDao类
/*
*  实现对数据表 gjp_zhangwu 数据增删改查操作
*  dbuils工具类完成,类成员创建QueryRunner对象,指定数据源
*/
public class ZhangWuDao {
private QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
/*
 * 定义方法,查询数据库,获取所有的账务数据
 * 方法,由业务层调用
 * 结果集,将所有的账务数据,存储到Bean对象中,存储到集合中
 */
public List<ZhangWu> selectAll(){					
	return null;
}
}

————————————————————————————————————————————————————————————————————————————————————
* b: cn.itcast.gjp.service包中创建ZhangWuService类
/*
 *  业务层类
 *  接收上一层,控制层controller的数据
 *  经过计算,传递给dao层,操作数据库
 *  调用dao层中的类,类成员位置,创建Dao类的对象
 */
public class ZhangWuService {
	private ZhangWuDao dao = new ZhangWuDao();
	/*
	 *  定义方法,实现查询所有的账务数据
	 *  此方法,由控制层调用, 去调用dao层的方法
	 *  返回存储ZhangWu对象的List集合
	 */
	public List<ZhangWu> selectAll(){
		return dao.selectAll();
	}
}

————————————————————————————————————————————————————————————————————————————————————
* c: cn.itcast.gjp.controller包中建立ZhangWuController类
/*
 *  控制器层
 *  接收视图层的数据,数据传递给service层
 *  成员位置,创建service对象
 */
public class ZhangWuController {
	private ZhangWuService service = new ZhangWuService();		
	/*
	 * 控制层类定义方法,实现查询所有的账务数据
	 * 本方法由视图层调用,本方法调用service层
	 */
	public List<ZhangWu> selectAll(){
		return service.selectAll();
	}					
}

15实现查询所有账务的dao层的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
* A: 实现查询所有账务的dao层的实现
* a: 案例核心代码
* a: cn.itcast.gjp.dao包中创建ZhangWuDao类selectAll方法
/*
*  实现对数据表 gjp_zhangwu 数据增删改查操作
*  dbuils工具类完成,类成员创建QueryRunner对象,指定数据源
*/
public class ZhangWuDao {
private QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
/*
 * 定义方法,查询数据库,获取所有的账务数据
 * 方法,由业务层调用
 * 结果集,将所有的账务数据,存储到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.class));
			return list;
		}catch(SQLException ex){
			System.out.println(ex);
			throw new RuntimeException("查询所有账务失败");
		}
}
}

16实现查询所有账务的view层的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
* A: 实现查询所有账务的view层的实现
* a: 案例核心代码
* cn.itcast.gjp.view包中建立MainView类selectAll方法
/*
* 定义方法,实现查询所有的账务数据
*/
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());
 }
}

17实现条件查询账务的菜单实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
* A: 实现条件查询账务的菜单实现
* a: 案例核心代码
* cn.itcast.gjp.view包中建立MainView类select方法
/*
* 定义方法,实现条件查询账务数据
* 提供用户的输入日期,开始日期结束日期
* 就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层的方法,传递日期,获取查询结果集
 
}

18实现条件查询账务的控制层,业务层实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
* A: 实现条件查询账务的控制层,业务层实现
* a: 案例核心代码
* a: cn.itcast.gjp.dao包中创建ZhangWuDao类
/*
 *  实现对数据表 gjp_zhangwu 数据增删改查操作
 *  dbuils工具类完成,类成员创建QueryRunner对象,指定数据源
 */
public class ZhangWuDao {
	private QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
	/*
	 * 定义方法,查询数据库,带有条件去查询账务表
	 * 由业务层调用,查询结果集存储到Bean对象,存储到List集合
	 * 调用者传递2个日期字符串
	 */
	public List<ZhangWu> select(String startDate,String endDate){
		return null;
	}
}

————————————————————————————————————————————————————————————————————————————————————
* b: cn.itcast.gjp.service包中创建ZhangWuService类
/*
 *  业务层类
 *  接收上一层,控制层controller的数据
 *  经过计算,传递给dao层,操作数据库
 *  调用dao层中的类,类成员位置,创建Dao类的对象
 */
public class ZhangWuService {
	private ZhangWuDao dao = new ZhangWuDao();
	/*
	 * 定义方法,实现条件查询账务
	 * 方法由控制层调用,传递2个日期字符串
	 * 调用dao层的方法,传递2个日期字符串
	 * 获取到查询结果集
	 */
	public List<ZhangWu> select(String startDate,String endDate){
		return dao.select(startDate, endDate);
	}
}

————————————————————————————————————————————————————————————————————————————————————
* c: cn.itcast.gjp.controller包中建立ZhangWuController类
/*
 *  控制器层
 *  接收视图层的数据,数据传递给service层
 *  成员位置,创建service对象
 */
public class ZhangWuController {
	private ZhangWuService service = new ZhangWuService();		
	/*
	 * 定义方法,实现条件查询账务
	 * 方法由试图层调用,传递两个日期的字符串
	 * 调用service层的方法,传递两个日期字符串,获取结果集
	 * 结果集返回给试图
	 */
	public List<ZhangWu> select(String startDate,String endDate){
		return service.select(startDate, endDate);
	}					
}

19实现条件查询账务的dao层实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
* A: 实现条件查询账务的dao层实现
* a: 案例核心代码
* a: cn.itcast.gjp.dao包中创建ZhangWuDao类select方法
/*
 *  实现对数据表 gjp_zhangwu 数据增删改查操作
 *  dbuils工具类完成,类成员创建QueryRunner对象,指定数据源
 */
public class ZhangWuDao {
	private QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
	/*
	 * 定义方法,查询数据库,带有条件去查询账务表
	 * 由业务层调用,查询结果集存储到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("条件查询失败");
		}
	}
}

20实现条件查询账务的view层实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
* A: 实现条件查询账务的view层实现
* a: 案例核心代码
* cn.itcast.gjp.view包中建立MainView类selectAll方法优化、抽取print方法、select方法
/*
* 定义方法,实现查询所有的账务数据
*/
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());
	 }
}

21添加账务功能分析

  • A: 添加账务功能分析
  • a: 编写MainView类中addZhangWu方法
    ….. 键盘输入新添加的账务信息
    …..     调用ZhangWuService类中addZhangWu方法，用来指定账务的添加
    …..* 添加完毕后，使用输出语句，提示“添加账务成功！”
  • b: 编写ZhangWuService类中addZhangWu方法
    …..* 调用ZhangWuDao类中addZhangWu方法，用来指定账务的添加
  • c: 编写ZhangWuDao类中addZhangWu方法
    …..* 通过QueryRunner对象，调用update方法更新数据库表gjp_zhangwu，完成指定账务添加到数据库表中

22添加账务功能菜单和输入功能实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
* A: 添加账务功能菜单和输入功能实现	
* a: 案例核心代码
* cn.itcast.gjp.view包中建立MainView类addZhangWu方法
/*
* 定义方法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层的方法，传递参数，实现数据添加

}

23添加账务功能控制层,业务层实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
* A: 添加账务功能控制层,业务层实现
* a: 案例核心代码
* cn.itcast.gjp.controller包中的ZhangWuController类addZhangWu方法
/*
 * 定义方法，实现账务添加功能
 * 由视图层调用，传递参数(传递过来的参数不能是5个数据，传递的是一个ZhangWu类型的对象)
 * 本方法调用service层的方法，传递ZhangWu对象，获取到添加后的结果集(添加成功影响的行数，int)
 * 
 */
public void addZhangWu(ZhangWu zw) {
	service.addZhangWu(zw);
}

——————————————————————————————————————————————————————————————————————————————————————
* cn.itcast.gjp.service包中的ZhangWuService类addZhangWu方法
/*
 * 定义方法，实现添加账务
 * 是由控制层调用，传递ZhangWu对象
 */
public void addZhangWu(ZhangWu zw) {
	dao.addZhangWu(zw);
}

——————————————————————————————————————————————————————————————————————————————————————
* cn.itcast.gjp.dao包中的ZhangWuDao类addZhangWu方法
/*
 * 定义方法，实现添加账务功能
 * 由业务层调用，传递ZhangWu对象
 * 将ZhangWu对象中的数据，添加到数据库
 */
public void addZhangWu(ZhangWu zw) {
	 
}

24添加账务功能dao层实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
* A: 添加账务功能dao层实现
* a: 案例核心代码	
* cn.itcast.gjp.dao包中的ZhangWuDao类的addZhangWu方法
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("账务添加失败");
	}
}

25添加账务功能view层实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
* A: 添加账务功能view层实现
* a: 案例核心代码
* cn.itcast.gjp.view包中建立MainView类addZhangWu方法
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("恭喜添加账务成功");
}

26编辑账务功能分析

  • A: 编辑账务功能分析
  • a: 编写MainView类中editZhangWu方法
    ….. 键盘输入要编辑的账务信息ID号
    …..     键盘输入要修改的账务信息内容
    ….. 调用ZhangWuService类中editZhangWu方法，用来将指定的账务信息进行更新
    …..     更新完毕后，使用输出语句，提示 “编辑账务成功！”
  • b: 编写ZhangWuService类中editZhangWu方法
    …..* 调用ZhangWuDao类中editZhangWu方法，用来将指定的账务信息进行更新
  • c: 编写ZhangWuDao类中editZhangWu方法
    …..* 通过QueryRunner对象，调用update方法更新数据库表gjp_zhangwu，完成数据库表中指定账务更新操作

27编辑账务功能功能之前实现查询所有

1
2
3
4
5
6
7
8
9
10
11
* A: 编辑账务功能功能之前实现查询所有
* a: 案例核心代码
* cn.itcast.gjp.view包中建立MainView类editZhangWu方法
public void editZhangWu() {
	//调用查询所有账务数据的功能，显示出来
	//看到所有数据，从中选择一项，进行修改
	selectAll();
	System.out.println("选择的是编辑功能，请输入数据");
	
	
}

28编辑账务功能菜单实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
* A: 编辑账务功能菜单实现
* a: 案例核心代码
* cn.itcast.gjp.view包中建立MainView类editZhangWu方法
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层中的方法，实现编辑账务
}

29编辑账务功能控制层,业务层实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
* A: 编辑账务功能控制层,业务层实现
* a: 案例核心代码
* cn.itcast.gjp.controller包中的ZhangWuController类editZhangWu方法
/*
 * 定义方法，实现编辑账务功能
 * 由视图层调用，传递参数，也是ZhangWu对象
 * 调用service层的方法，也是ZhangWu对象
 */
public void editZhangWu(ZhangWu zw) {
	service.editZhangWu(zw);
}
* cn.itcast.gjp.service包中的ZhangWuService类editZhangWu方法
/*
 * 定义方法，实现编辑账务
 * 由控制层调用，传递ZhangWu对象
 * 调用dao层的方法，传递ZhangWu对象
 */
public void editZhangWu(ZhangWu zw) {
	dao.editZhangWu(zw);
}
* cn.itcast.gjp.dao包中的ZhangWuDao类editZhangWu方法
public void editZhangWu(ZhangWu zw) {
	// TODO Auto-generated method stub
	
}

30编辑账务功能dao层实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
* A：编辑账务功能dao层实现
* a: 案例核心代码
* cn.itcast.gjp.dao包中的ZhangWuDao类editZhangWu方法
/*
 * 定义方法，实现编辑功能
 * 由业务层调用，传递ZhangWu对象
 * 将对象中的数据，更新到数据表
 */
public void editZhangWu(ZhangWu zw) {
	try {
		//更新数据的SQL
		String sql = "UPDATE 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("编辑账务失败");
	}
	
}

31编辑账务功能view层实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
* A: 编辑账务功能view层实现
* a: 案例核心代码
* cn.itcast.gjp.view包中建立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("账务编辑成功");
}

32删除账务功能分析

  • A: 删除账务功能分析
  • a: 编写MainView类中deleteZhangWu方法
    ….. 键盘输入要删除的账务信息ID号
    …..     调用ZhangWuService类中deleteZhangWu方法，用来将指定的账务信息删除
    …..* 删除完毕后，使用输出语句，提示 “删除账务成功！”
  • b: 编写ZhangWuService类中deleteZhangWu方法
    …..* 调用ZhangWuDao类中deleteZhangWu方法，用来将指定的账务信息删除
  • c: 编写ZhangWuDao类中deleteZhangWu方法
    …..* 通过QueryRunner对象，调用update方法更新数据库表gjp_zhangwu，完成数据库表中指定账务删除操作

33删除账务功能菜单实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
* A: 删除账务功能菜单实现
* a: 案例核心代码
* cn.itcast.gjp.view包中建立MainView类deleteZhangWu方法
/*
 * 定义方法，实现账务删除
 * 实现思想：
 * 	接收用户的输入，输入一个主键数据
 *  调用控制层方法，传递一个主键
 */
public void deleteZhangWu() {
	//调用查询所有账务数据的功能，显示出来
	//看到所有数据，从中选择一项，进行修改
	selectAll();
	System.out.println("选择的是删除功能，请输入序号即可");
	int zwid = new Scanner(System.in).nextInt();
	//调用控制层方法，传递主键id即可
}

34删除账务功能控制层,业务层实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
* A: 删除账务功能控制层,业务层实现
* a: 案例核心代码
* cn.itcast.gjp.controller包中的ZhangWuController类deleteZhangWu方法
/*
 * 定义方法，实现删除功能
 * 视图层调用，传递int类型主键
 * 调用service层方法，传递int主键
 */
public void deleteZhangWu(int zwid) {
	service.deleteZhangWu(zwid);
}
* cn.itcast.gjp.service包中的ZhangWuService类deleteZhangWu方法
/*
 * 定义方法，实现删除账务功能
 * 由控制层调用，传递主键id
 * 调用dao层方法，传递主键id
 */
public void deleteZhangWu(int zwid) {
	dao.deleteZhangWu(zwid);
}
* cn.itcast.gjp.dao包中的ZhangWuDao类deleteZhangWu方法
public void deleteZhangWu(int zwid) {

}

35删除账务功能dao实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
* A: 删除账务功能dao实现
* a: 案例核心代码
* cn.itcast.gjp.dao包中的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("删除账务失败");
	}
}

36删除账务功能view层实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
* A: 删除账务功能view层实现
* a: 案例核心代码
* cn.itcast.gjp.view包中建立MainView类editZhangWu方法
/*
 * 定义方法，实现账务删除
 * 实现思想：
 * 	接收用户的输入，输入一个主键数据
 *  调用控制层方法，传递一个主键
 */
public void deleteZhangWu() {
	//调用查询所有账务数据的功能，显示出来
	//看到所有数据，从中选择一项，进行修改
	selectAll();
	System.out.println("选择的是删除功能，请输入序号即可");
	int zwid = new Scanner(System.in).nextInt();
	//调用控制层方法，传递主键id即可
	controller.deleteZhangWu(zwid);
	System.out.println("删除账务成功");

37总结

…..view层的作用是“界面”，用来完成数据显示给用户。当前项目view层中，包含了Controller层代码。
…..Controller层的作用是“调度”，调度的是表现层view和业务层Service，主要功能分为：一是把表现层的数据交给业务层处理；二是把业务层返回的数据交给表现层显示。

…..Service层的作用是“业务”，我们也可以把“业务”当成是“功能”。今后要写的大型项目代码量最大的就是Service层。
…..DAO层是操作数据库，现在我们使用的是commons-dbutils工具来简化JDBC，所以我们发现代码不多，比较简单。最后我们还会学习其他DAO层的工具，例如：hibernate和mybatis，他们都是JDBC的封装，用来简化JDBC。

-------------本文结束感谢您的阅读-------------
感谢您的支持，我会继续努力的!
0%