学习JDBC_mysql-connector-java版本

一、数据库连接回顾

1.1 之前如何操作数据库？

（1）使用DOS命令窗口，输入“mysql -hlocalhost -u数据库用户名 -p数据库密码”命令连接数据库，编写SQL语句（SQL语句以分号;或者\g结尾），回车运行，查看操作结果（受影响行数或结果集）

（2）使用MySQL数据库自带的命令窗口，输入数据库密码连接数据库，编写SQL语句（SQL语句以分号;或者\g结尾），回车运行，查看操作结果（受影响行数或结果集）

（3）使用数据库连接软件（SQLyog）连接数据库，通过图形化界面或者在查询编辑器中编写SQL语句，运行SQL语句查看操作结果（受影响行数或结果集）
1
2
3
4
5

1.2 实际开发中如何操作数据库？

在实际开发中，当用户的数据发生变化时，不会也不可能通过客户端连接数据库去操作SQL语句，因为在实际开发中，数据的操作量很大，如果使用客户端操作数据库，无法保证SQL语句的正确性和执行效率。
1

二、JDBC（Java Database Connectivity）

2.1 JDBC的概念

（1）JDBC（Java DataBase Connectivity）Java连接数据库的规范（标准），可以使用Java语言连接数据库，从而对数据进行增删改查（CURD）操作。
1

2.2 JDBC核心思想

Java中定义了访问数据库的接口，可以为多种关系型数据库提供统一的访问方式。由数据库厂商提供驱动实现类（Driver数据库驱动）。

2.2.1 MySQL数据库驱动

mysql-connector-java-5.1.x 适用于5.x版本

mysql-connector-java-8.1.x 适用于8.x版本
1
2
3

2.2.2 JDBC API

JDBC是由多个接口和类进行功能实现的。

2.3 JDBC环境搭建

（1）在项目下创建lib文件夹，用于存放jar文件。

（2）将mysql驱动mysql-connector-java-5.1.x复制到项目的lib文件夹中。

（3）将选中lib文件中的jar文件配置到项目中。
1
2
3
4
5

2.4 准备一张表

创建数据库jdbcdatabase，专门用来存储学习jdbc要用的表

2.4.1 创建student表

CREATE TABLE IF NOT EXISTS `student`(
`tid` INT(10) AUTO_INCREMENT COMMENT '学号',
`name` VARCHAR(20) NOT NULL COMMENT '姓名',
`age` INT(2) NOT NULL COMMENT '年龄',
`gender` VARCHAR(5) NOT NULL COMMENT '性别',
`phone` VARCHAR(11) UNIQUE NOT NULL COMMENT '手机号码',
`identitycard` VARCHAR(18) UNIQUE NOT NULL COMMENT '身份证号码',
`address` VARCHAR(20) NOT NULL COMMENT '住址',
 PRIMARY KEY (`tid`)
);
1
2
3
4
5
6
7
8
9
10

2.4.2 向表中插入数据

INSERT  INTO `student`(`tid`,`name`,`age`,`gender`,`phone`,`identitycard`,`address`) VALUES (1001,'张三',20,'男','13112345678','340825200212241936','安徽合肥蜀山区');

INSERT  INTO `student`(`tid`,`name`,`age`,`gender`,`phone`,`identitycard`,`address`) VALUES (1002,'李红',18,'女','13111223344','340825200408151936','安徽合肥庐阳区');
1
2
3

三、JDBC的开发步骤（非常重要）

3.1 注册驱动

使用Class.forName(“包含完整路径的驱动类”);//手动加载字节码文件到JVM中。

// 1、注册驱动
Class.forName("com.mysql.jdbc.Driver");
1
2

3.2 获取连接对象

通过DriverManager.getConnection(url,user,password)获取数据库连接对象

​ url：mysql数据库的路径

​ user：mysql数据库用户名

​ password：mysql数据库密码

// 2 、获取数据库连接对象
String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
String user = "root";
String password = "123456";
Connection connection = DriverManager.getConnection(url, user, password);
1
2
3
4
5

3.3 获取发送SQL语句的对象

通过Connection对象获取Statement对象，用于发送SQL语句，实现对数据库进行访问。

//3、获取发送SQL语句的对象
Statement statement = connection.createStatement();
1
2

3.4 编写SQL语句

// 4、编写SQL语句，SQL语句最好是先在SQLyog里面写一遍并运行一下，保证SQL语句没有语法错误，这里sid是自增长，所以不需要写
String sql = "INSERT  INTO `student`(`name`,`age`,`gender`,`phone`,`identitycard`,`address`) 
VALUES ('王五',21,'男','13825869876','340825200109151928','安徽合肥包河区');";
1
2
3

3.5 执行SQL语句

// 5、执行SQL语句
//DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
//DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
int result = statement.executeUpdate(sql);
1
2
3
4

3.6 处理结果

处理第5步返回的数据。对返回的受影响行数结果进行逻辑判断

// 6、处理结果，如果返回的受影响行数不为0，说明数据插入成功
if (result != 0) {
	System.out.println("数据插入成功");
} else {
	System.out.println("数据插入失败");
}
1
2
3
4
5
6

3.7 释放资源

释放（关闭）所使用到的所有资源对象，遵循”先开的后关，后开的先关“原则。

// 7、释放资源，遵循“先开后关，后开先关”的原则
if (connection != null) {
	try {
		connection.close();
	} catch (SQLException e) {
		e.printStackTrace();
	}
}

if (statement != null) {
	try {
		statement.close();
	} catch (SQLException e) {
		e.printStackTrace();
	}
}

//查询操作中多一个关闭resultSet
if(resultSet!=null){
	try {
		resultSet.close();
	} catch (SQLException e) {
		e.printStackTrace();
	}
}
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

3.8 综合案例

3.8.1 插入数据

综合上述7个步骤，实现向student表中插入一条数据。

package com.cxyzxc.www.examples01;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * JDBC连接数据 实现向数据库jdbcdatabase里student表中插入一条数据
 *
 */
public class Jdbc01InsertStudent {

	public static void main(String[] args) {
		Connection connection = null;
		Statement statement = null;

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String user = "root";
			String password = "123456";
			connection = DriverManager.getConnection(url, user, password);

			// 3、获取发送SQL语句对象
			statement = connection.createStatement();

			// 4、编写SQL语句，SQL语句最好是先在SQLyog里面写一遍并运行一下，保证SQL语句没有语法错误，这里sid是自增长，所以不需要写
			String sql = "INSERT  INTO `student`(`name`,`age`,`gender`,`phone`,`identitycard`,`address`) VALUES ('王五',21,'男','13825869876','340825200109151928','安徽合肥包河区');";

			// 5、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			int result = statement.executeUpdate(sql);

			// 6、处理结果，如果返回的受影响行数不为0，说明数据插入成功
			if (result != 0) {
				System.out.println("数据插入成功");
			} else {
				System.out.println("数据插入失败");
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 7、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (statement != null) {
				try {
					statement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72

3.8.2 删除数据

综合上述7个步骤，实现根据学号sid删除数据库表中一条数据。

package com.cxyzxc.www.examples01;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * JDBC连接数据 实现删除数据库jdbcdatabase里student表中的一条数据
 * 
 */
public class Jdbc02DeleteStudent {

	public static void main(String[] args) {
		Connection connection = null;
		Statement statement = null;

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String user = "root";
			String password = "123456";
			connection = DriverManager.getConnection(url, user, password);

			// 3、获取发送SQL语句对象
			statement = connection.createStatement();

			// 4、编写SQL语句，SQL语句最好是先在SQLyog里面写一遍并运行一下，保证SQL语句没有语法错误
			String sql = "DELETE FROM `student` WHERE `tid` = 1003;";

			// 5、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			int result = statement.executeUpdate(sql);

			// 6、处理结果，如果返回的受影响行数不为0，说明数据删除成功
			if (result != 0) {
				System.out.println("数据删除成功");
			} else {
				System.out.println("数据删除失败");
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 7、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (statement != null) {
				try {
					statement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72

3.8.3 修改数据

综合上述7个步骤，实现根据学号sid修改数据库表中一条数据。

package com.cxyzxc.www.examples01;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * JDBC连接数据 实现修改数据库jdbcdatabase里student表中的一条数据
 * 
 */
public class Jdbc03UpdateStudent {

	public static void main(String[] args) {
		Connection connection = null;
		Statement statement = null;

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String user = "root";
			String password = "123456";
			connection = DriverManager.getConnection(url, user, password);

			// 3、获取发送SQL语句对象
			statement = connection.createStatement();

			// 4、编写SQL语句，SQL语句最好是先在SQLyog里面写一遍并运行一下，保证SQL语句没有语法错误
			String sql = "UPDATE `student` SET `name`='李红',`age`=19,`gender`='女',`phone`='13111223344',`identitycard`='340825200308151936',`address`='安徽合肥高新区' WHERE `sid`=1002;";

			// 5、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			int result = statement.executeUpdate(sql);

			// 6、处理结果，如果返回的受影响行数不为0，说明数据修改成功
			if (result != 0) {
				System.out.println("数据修改成功");
			} else {
				System.out.println("数据修改失败");
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 7、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (statement != null) {
				try {
					statement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72

四、ResultSet（结果集）

JDBC中执行DQL查询语句后，使用ResultSet存放查询到的结果集数据。

4.1 接收结果集

ResultSet resultSet = statement.executeQuery(String sql);

// 4、编写SQL语句，SQL语句最好是先在SQLyog里面写一遍并运行一下，保证SQL语句没有语法错误
String sql = "SELECT * FROM `student` WHERE `sid`= 1002;";

// 5、执行SQL语句
// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
ResultSet resultSet = statement.executeQuery(sql);
1
2
3
4
5
6
7

4.2 遍历ResultSet结果集中的数据

ResultSet以表（table）结构进行临时结果的存储，需要通过JDBC API将其中的数据依次获取。

数据行指针：初始位置在第一行数据前，每调用一次boolean next()方法ResultSet的指针向下移动一行，结果为true，表示当前行有数据。

• resultSet.getXxx(int columnIndex)：根据字段的索引顺序获取表中字段的数据，索引从1开始，Xxx表示字段类型。
• resultSet.getXxx(String columnLabel)：根据字段的名称获取表中字段的数据。

// 6、处理结果，对返回的resultSet结果集进行处理，需要将结果集中的数据取出来
// 查询一条数据时，使用if判断resultSet.next()为true，说明resultSet结果集中有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据。
// 查询所有数据时，使用while循环判断resultSet.next()为true，说明resultSet结果集中还有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据了。

//查询一条数据，根据记录中字段的索引获取字段数据
if (resultSet.next()) {
	//根据记录中字段的索引获取字段数据，字段索引从1开始
	int sid = resultSet.getInt(1);
	String name = resultSet.getString(2);
	int age = resultSet.getInt(3);
	String gender = resultSet.getString(4);
	String phone = resultSet.getString(5);
	String identitycard = resultSet.getString(6);
	String address = resultSet.getString(7);
	System.out.println(sid + "-" + name + "-" + age + "-" + gender+ "-" + phone + "-" + identitycard + "-" + address);
}

//查询一条数据，根据记录中字段的名称获取字段数据
if (resultSet.next()) {
	//根据记录中字段的名称获取字段数据
	int sid = resultSet.getInt("sid");
	String name = resultSet.getString("name");
	int age = resultSet.getInt("age");
	String gender = resultSet.getString("gender");
	String phone = resultSet.getString("phone");
	String identitycard = resultSet.getString("identitycard");
	String address = resultSet.getString("address");
	System.out.println(sid + "-" + name + "-" + age + "-" + gender+ "-" + phone + "-" + identitycard + "-" + address);
}

//查询所有数据，根据记录中字段的索引获取字段数据
while (resultSet.next()) {
	//根据记录中字段的索引获取字段数据，字段索引从1开始
	int sid = resultSet.getInt(1);
	String name = resultSet.getString(2);
	int age = resultSet.getInt(3);
	String gender = resultSet.getString(4);
	String phone = resultSet.getString(5);
	String identitycard = resultSet.getString(6);
	String address = resultSet.getString(7);
	System.out.println(sid + "-" + name + "-" + age + "-" + gender+ "-" + phone + "-" + identitycard + "-" + address);
}

//查询所有数据，根据记录中字段的名称获取字段数据
while (resultSet.next()) {
	//根据记录中字段的名称获取字段数据
	int sid = resultSet.getInt("sid");
	String name = resultSet.getString("name");
	int age = resultSet.getInt("age");
	String gender = resultSet.getString("gender");
	String phone = resultSet.getString("phone");
	String identitycard = resultSet.getString("identitycard");
	String address = resultSet.getString("address");
	System.out.println(sid + "-" + name + "-" + age + "-" + gender+ "-" + phone + "-" + identitycard + "-" + address);
}
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

4.2.1 常用遍历方法

• int getInt(int columnIndex) throws SQLException //获得当前行第N列的int值

• int getInt(String columnLabel) throws SQLException //获得当前行名为cloumnLabel列的int值

• int getDouble(int columnIndex) throws SQLException //获得当前行第N列的double值

• int getDouble(String columnLabel) throws SQLException //获得当前行名为cloumnLabel列的double值

• int getString(int columnIndex) throws SQLException //获得当前行第N列的String值

• int getString(String columnLabel) throws SQLException //获得当前行名为cloumnLabel列的String值

4.3案例代码

4.3.1 查询一条数据

根据学号sid查询student表中的一条学生记录。

4.3.1.1 根据字段的索引获取数据

package com.cxyzxc.www.examples01;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * JDBC连接数据 实现根据学号sid查询数据库jdbcdatabase里student表中的一条数据
 * 
 */
public class Jdbc04SelectOneStudent01 {

	public static void main(String[] args) {
		Connection connection = null;
		Statement statement = null;
		ResultSet resultSet = null;

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String user = "root";
			String password = "123456";
			connection = DriverManager.getConnection(url, user, password);

			// 3、获取发送SQL语句对象
			statement = connection.createStatement();

			// 4、编写SQL语句，SQL语句最好是先在SQLyog里面写一遍并运行一下，保证SQL语句没有语法错误
			String sql = "SELECT * FROM `student` WHERE `sid`= 1002;";

			// 5、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			resultSet = statement.executeQuery(sql);

			// 6、处理结果，对返回的resultSet结果集进行处理，需要将结果集中的数据取出来
			// 查询一条数据时，使用if判断resultSet.next()为true，说明resultSet结果集中有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据。
			// 查询所有数据时，使用while循环判断resultSet.next()为true，说明resultSet结果集中还有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据了。
			if (resultSet.next()) {
				// 根据记录中字段的索引获取字段数据，字段索引从1开始
				int sid = resultSet.getInt(1);
				String name = resultSet.getString(2);
				int age = resultSet.getInt(3);
				String gender = resultSet.getString(4);
				String phone = resultSet.getString(5);
				String identitycard = resultSet.getString(6);
				String address = resultSet.getString(7);
				System.out.println(sid + "-" + name + "-" + age + "-" + gender
						+ "-" + phone + "-" + identitycard + "-" + address);
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 7、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (statement != null) {
				try {
					statement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			
			if(resultSet!=null){
				try {
					resultSet.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

4.3.1.2 根据字段的名称获取数据

package com.cxyzxc.www.examples01;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * JDBC连接数据 实现根据学号sid查询数据库jdbcdatabase里student表中的一条数据
 * 
 */
public class Jdbc04SelectOneStudent02 {

	public static void main(String[] args) {
		Connection connection = null;
		Statement statement = null;
		ResultSet resultSet = null;

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String user = "root";
			String password = "123456";
			connection = DriverManager.getConnection(url, user, password);

			// 3、获取发送SQL语句对象
			statement = connection.createStatement();

			// 4、编写SQL语句，SQL语句最好是先在SQLyog里面写一遍并运行一下，保证SQL语句没有语法错误
			String sql = "SELECT * FROM `student` WHERE `sid`= 1002;";

			// 5、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			resultSet = statement.executeQuery(sql);

			// 6、处理结果，对返回的resultSet结果集进行处理，需要将结果集中的数据取出来
			// 查询一条数据时，使用if判断resultSet.next()为true，说明resultSet结果集中有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据。
			// 查询所有数据时，使用while循环判断resultSet.next()为true，说明resultSet结果集中还有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据了。
			if (resultSet.next()) {
				// 根据记录中字段的名称获取字段数据
				int sid = resultSet.getInt("sid");
				String name = resultSet.getString("name");
				int age = resultSet.getInt("age");
				String gender = resultSet.getString("gender");
				String phone = resultSet.getString("phone");
				String identitycard = resultSet.getString("identitycard");
				String address = resultSet.getString("address");
				System.out.println(sid + "-" + name + "-" + age + "-" + gender
						+ "-" + phone + "-" + identitycard + "-" + address);
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 7、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (statement != null) {
				try {
					statement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			
			if(resultSet!=null){
				try {
					resultSet.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

4.3.2 查询所有数据

查询student表中所有的学生记录。

4.3.2.1 根据字段的索引获取数据

package com.cxyzxc.www.examples01;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * JDBC连接数据 实现查询数据库jdbcdatabase里student表中的所有数据
 * 
 */
public class Jdbc05SelectAllStudent01 {

	public static void main(String[] args) {
		Connection connection = null;
		Statement statement = null;
		ResultSet resultSet = null;

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String user = "root";
			String password = "123456";
			connection = DriverManager.getConnection(url, user, password);

			// 3、获取发送SQL语句对象
			statement = connection.createStatement();

			// 4、编写SQL语句，SQL语句最好是先在SQLyog里面写一遍并运行一下，保证SQL语句没有语法错误
			String sql = "SELECT * FROM `student`;";

			// 5、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			resultSet = statement.executeQuery(sql);

			// 6、处理结果，对返回的resultSet结果集进行处理，需要将结果集中的数据取出来
			// 查询一条数据时，使用if判断resultSet.next()为true，说明resultSet结果集中有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据。
			// 查询所有数据时，使用while循环判断resultSet.next()为true，说明resultSet结果集中还有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据了。
			while (resultSet.next()) {
				// 根据记录中字段的索引获取字段数据，字段索引从1开始
				int sid = resultSet.getInt(1);
				String name = resultSet.getString(2);
				int age = resultSet.getInt(3);
				String gender = resultSet.getString(4);
				String phone = resultSet.getString(5);
				String identitycard = resultSet.getString(6);
				String address = resultSet.getString(7);
				System.out.println(sid + "-" + name + "-" + age + "-" + gender
						+ "-" + phone + "-" + identitycard + "-" + address);
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 7、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (statement != null) {
				try {
					statement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			
			if(resultSet!=null){
				try {
					resultSet.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

4.3.2.2 根据字段的名称获取数据

package com.cxyzxc.www.examples01;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * JDBC连接数据 实现查询数据库jdbcdatabase里student表中的所有数据
 *  
 */
public class Jdbc05SelectAllStudent02 {

	public static void main(String[] args) {
		Connection connection = null;
		Statement statement = null;
		ResultSet resultSet = null;

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String user = "root";
			String password = "123456";
			connection = DriverManager.getConnection(url, user, password);

			// 3、获取发送SQL语句对象
			statement = connection.createStatement();

			// 4、编写SQL语句，SQL语句最好是先在SQLyog里面写一遍并运行一下，保证SQL语句没有语法错误
			String sql = "SELECT * FROM `student`;";

			// 5、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			resultSet = statement.executeQuery(sql);

			// 6、处理结果，对返回的resultSet结果集进行处理，需要将结果集中的数据取出来
			// 查询一条数据时，使用if判断resultSet.next()为true，说明resultSet结果集中有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据。
			// 查询所有数据时，使用while循环判断resultSet.next()为true，说明resultSet结果集中还有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据了。
			while (resultSet.next()) {
				// 根据记录中字段的名称获取字段数据
				int sid = resultSet.getInt("sid");
				String name = resultSet.getString("name");
				int age = resultSet.getInt("age");
				String gender = resultSet.getString("gender");
				String phone = resultSet.getString("phone");
				String identitycard = resultSet.getString("identitycard");
				String address = resultSet.getString("address");
				System.out.println(sid + "-" + name + "-" + age + "-" + gender
						+ "-" + phone + "-" + identitycard + "-" + address);
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 7、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (statement != null) {
				try {
					statement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			
			if(resultSet!=null){
				try {
					resultSet.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

五、ORM

（1）ORM（Object Relational Mapping），对象关系映射。

（2）从数据库查询到的结果集（ResultSet）在进行遍历时，逐行遍历，然后一个字段一个字段的读取数据，取出的都是零散的数据，然后将零散数据一个一个输出，这样比较麻烦，不利于操作。在实际应用开发中，我们需要将零散的数据进行封装整理。

（3）在Java中，将一个封装好的对象插入到数据库的student表中，也可以将查询出来的数据封装成一个对象。

5.1 实体类(entity)：零散数据的载体

• 一行数据中，多个零散的数据进行整理，一行数据（在数据库中称之为一条记录或者一个实体）对应Java中的一个对象。
• 通过entity的规则对表中的数据进行对象的封装。
• 表名=类名；字段名=属性名；提供各个属性的getXxx()/setXxx()方法。
• 提供无参构造方法、有参构造方法
• 重写toString()方法

5.2 ORM应用步骤

5.2.1 创建entity实体类Student

package com.cxyzxc.www.examples02;

/**
 * entity实体类Student
 * 
 */
public class Student {
	/** 学号 */
	private int sid;
	/** 姓名 */
	private String name;
	/** 年龄 */
	private int age;
	/** 性别 */
	private String gender;
	/** 手机号码 */
	private String phone;
	/** 身份证号码 */
	private String identitycard;
	/** 住址 */
	private String address;

	// 无参构造方法
	public Student() {
		super();
	}

	// 有参构造方法
	public Student(String name, int age, String gender, String phone,
			String identitycard, String address) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
		this.phone = phone;
		this.identitycard = identitycard;
		this.address = address;
	}

	// 有参构造方法
	public Student(int sid, String name, int age, String gender, String phone,
			String identitycard, String address) {
		super();
		this.sid = sid;
		this.name = name;
		this.age = age;
		this.gender = gender;
		this.phone = phone;
		this.identitycard = identitycard;
		this.address = address;
	}

	// getXxx()/setXxx()方法
	public int getSid() {
		return sid;
	}

	public void setSid(int sid) {
		this.sid = sid;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getGender() {
		return gender;
	}

	public void setGender(String gender) {
		this.gender = gender;
	}

	public String getPhone() {
		return phone;
	}

	public void setPhone(String phone) {
		this.phone = phone;
	}

	public String getIdentitycard() {
		return identitycard;
	}

	public void setIdentitycard(String identitycard) {
		this.identitycard = identitycard;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	// 重写toString()方法
	@Override
	public String toString() {
		return "Student [sid=" + sid + ", name=" + name + ", age=" + age
				+ ", gender=" + gender + ", phone=" + phone + ", identitycard="
				+ identitycard + ", address=" + address + "]";
	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

5.2.2 插入一条数据封装

package com.cxyzxc.www.examples02;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * JDBC连接数据 实现向数据库jdbcdatabase里student表中插入一条数据
 * 
 */
public class Jdbc01ORMInsertStudent {

	public static void main(String[] args) {
		Connection connection = null;
		Statement statement = null;

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String user = "root";
			String password = "123456";
			connection = DriverManager.getConnection(url, user, password);

			// 3、获取发送SQL语句对象
			statement = connection.createStatement();
			
			//创建Student类对象
			Student student = new Student("李二牛", 28, "男", "13844556633", "340825199409192345", "安徽合肥经开区");

			// 4、编写SQL语句，SQL语句最好是先在SQLyog里面写一遍并运行一下，保证SQL语句没有语法错误，这里sid是自增长，所以不需要写
			String sql = "INSERT  INTO `student`(`name`,`age`,`gender`,`phone`,`identitycard`,`address`) VALUES ('"+student.getName()+"',"+student.getAge()+",'"+student.getGender()+"','"+student.getPhone()+"','"+student.getIdentitycard()+"','"+student.getAddress()+"');";

			// 5、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			int result = statement.executeUpdate(sql);

			// 6、处理结果，如果返回的受影响行数不为0，说明数据插入成功
			if (result != 0) {
				System.out.println("数据插入成功");
			} else {
				System.out.println("数据插入失败");
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 7、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (statement != null) {
				try {
					statement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

5.2.3 删除一条数据封装

package com.cxyzxc.www.examples02;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * JDBC连接数据 实现删除数据库jdbcdatabase里student表中的一条数据
 * 
 */
public class Jdbc02ORMDeleteStudent {

	public static void main(String[] args) {
		Connection connection = null;
		Statement statement = null;

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String user = "root";
			String password = "123456";
			connection = DriverManager.getConnection(url, user, password);

			// 3、获取发送SQL语句对象
			statement = connection.createStatement();
			
			//创建Student类对象
			Student student = new Student(1003,"李二狗", 28, "男", "13844556644", "340825199409192345", "安徽合肥高新区");

			// 4、编写SQL语句，SQL语句最好是先在SQLyog里面写一遍并运行一下，保证SQL语句没有语法错误
			String sql = "DELETE FROM `student` WHERE `sid` = "+student.getSid()+";";

			// 5、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			int result = statement.executeUpdate(sql);

			// 6、处理结果，如果返回的受影响行数不为0，说明数据删除成功
			if (result != 0) {
				System.out.println("数据删除成功");
			} else {
				System.out.println("数据删除失败");
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 7、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (statement != null) {
				try {
					statement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

5.2.4 修改一条数据封装

package com.cxyzxc.www.examples02;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * JDBC连接数据 实现修改数据库jdbcdatabase里student表中的一条数据
 * 
 */
public class Jdbc03ORMUpdateStudent {

	public static void main(String[] args) {
		Connection connection = null;
		Statement statement = null;

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String user = "root";
			String password = "123456";
			connection = DriverManager.getConnection(url, user, password);

			// 3、获取发送SQL语句对象
			statement = connection.createStatement();
			
			//创建Student类对象
			Student student = new Student(1003,"李二狗", 28, "男", "13844556644", "340825199409192345", "安徽合肥高新区");

			// 4、编写SQL语句，SQL语句最好是先在SQLyog里面写一遍并运行一下，保证SQL语句没有语法错误
			String sql = "UPDATE `student` SET `name`='"+student.getName()+"',`age`="+student.getAge()+",`gender`='"+student.getGender()+"',`phone`='"+student.getPhone()+"',`identitycard`='"+student.getIdentitycard()+"',`address`='"+student.getAddress()+"' WHERE `sid`="+student.getSid()+";";

			// 5、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			int result = statement.executeUpdate(sql);

			// 6、处理结果，如果返回的受影响行数不为0，说明数据修改成功
			if (result != 0) {
				System.out.println("数据修改成功");
			} else {
				System.out.println("数据修改失败");
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 7、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (statement != null) {
				try {
					statement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

5.2.5 查询一条结果封装

package com.cxyzxc.www.examples02;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * JDBC连接数据 实现根据学号sid查询数据库jdbcdatabase里student表中的一条数据
 * 
 */
public class Jdbc04ORMSelectOneStudent {

	public static void main(String[] args) {
		Connection connection = null;
		Statement statement = null;
		ResultSet resultSet = null;
		Student student = null;

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String user = "root";
			String password = "123456";
			connection = DriverManager.getConnection(url, user, password);

			// 3、获取发送SQL语句对象
			statement = connection.createStatement();

			// 4、编写SQL语句，SQL语句最好是先在SQLyog里面写一遍并运行一下，保证SQL语句没有语法错误
			String sql = "SELECT * FROM `student` WHERE `sid`= 1002;";

			// 5、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			resultSet = statement.executeQuery(sql);

			// 6、处理结果，对返回的resultSet结果集进行处理，需要将结果集中的数据取出来
			// 查询一条数据时，使用if判断resultSet.next()为true，说明resultSet结果集中有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据。
			// 查询所有数据时，使用while循环判断resultSet.next()为true，说明resultSet结果集中还有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据了。
			if (resultSet.next()) {
				// 根据记录中字段的索引获取字段数据，字段索引从1开始
				int sid = resultSet.getInt(1);
				String name = resultSet.getString(2);
				int age = resultSet.getInt(3);
				String gender = resultSet.getString(4);
				String phone = resultSet.getString(5);
				String identitycard = resultSet.getString(6);
				String address = resultSet.getString(7);

				// System.out.println(sid + "-" + name + "-" + age + "-" +gender + "-" + phone + "-" + identitycard + "-" + address);
				// 创建实体类对象
				student = new Student();
				// 给实体类对象属性赋值，也可以通过有参构造方法创建实体类对象并给对象属性赋值
				student.setSid(sid);
				student.setName(name);
				student.setAge(age);
				student.setGender(gender);
				student.setPhone(phone);
				student.setIdentitycard(identitycard);
				student.setAddress(address);
				//输出对象
				System.out.println(student);
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 7、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (statement != null) {
				try {
					statement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			
			if(resultSet!=null){
				try {
					resultSet.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

5.2.6 查询所有结果封装

package com.cxyzxc.www.examples02;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

/**
 * JDBC连接数据 实现查询数据库jdbcdatabase里student表中的所有数据
 * 
 */
public class Jdbc05ORMSelectAllStudent {

	public static void main(String[] args) {
		Connection connection = null;
		Statement statement = null;
		ResultSet resultSet = null;
		Student student = null;
		List<Student> studentList = new ArrayList<Student>();

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String user = "root";
			String password = "123456";
			connection = DriverManager.getConnection(url, user, password);

			// 3、获取发送SQL语句对象
			statement = connection.createStatement();

			// 4、编写SQL语句，SQL语句最好是先在SQLyog里面写一遍并运行一下，保证SQL语句没有语法错误
			String sql = "SELECT * FROM `student`;";

			// 5、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			resultSet = statement.executeQuery(sql);

			// 6、处理结果，对返回的resultSet结果集进行处理，需要将结果集中的数据取出来
			// 查询一条数据时，使用if判断resultSet.next()为true，说明resultSet结果集中有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据。
			// 查询所有数据时，使用while循环判断resultSet.next()为true，说明resultSet结果集中还有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据了。
			while (resultSet.next()) {
				// 根据记录中字段的索引获取字段数据，字段索引从1开始
				int sid = resultSet.getInt(1);
				String name = resultSet.getString(2);
				int age = resultSet.getInt(3);
				String gender = resultSet.getString(4);
				String phone = resultSet.getString(5);
				String identitycard = resultSet.getString(6);
				String address = resultSet.getString(7);
				// System.out.println(sid + "-" + name + "-" + age + "-" + gender + "-" + phone + "-" + identitycard + "-" + address);
				// 通过有参构造方法创建实体类对象
				student = new Student(sid, name, age, gender, phone, identitycard, address);
				// 输出对象
				studentList.add(student);
			}

			// 遍历输出studentList集合中的数据
			for (Student student2 : studentList) {
				System.out.println(student2);
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 7、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (statement != null) {
				try {
					statement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			
			if(resultSet!=null){
				try {
					resultSet.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

六、JDBC常见异常

• java.lang.ClassNotFoundException：找不到类（类名书写错误、没有导入jar包）
• java.sql.SQLException：与SQL语句相关的异常（约束错误、表名列名字段名书写错误），建议：在客户端工具中测试SQL语句正确后再复制到代码中
• com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException:Unknown column原因：列值String类型没有加单引号
• Duplicate entry ‘1’ for key 'PRIMARY’原因，主键值已经存在或混乱，更改主键值或清空表
• com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException:Unknown column ‘password’ in原因：可能输入的值类型不对，确定是否插入的元素是对应的值的类型正确

七、综合案例（账号密码登录）

7.1 准备一张表

7.1.1创建user表

表的字段如下：

​ id，用户编号，主键、自动增长。

​ username，用户名，字符串类型、唯一、非空。

​ password，密码，字符串类型、非空。

​ phone，手机号码，字符串类型

CREATE TABLE IF NOT EXISTS `user`(
`uid` INT PRIMARY KEY AUTO_INCREMENT,
`username` VARCHAR(10) UNIQUE NOT NULL,
`password` VARCHAR(10) NOT NULL,
`phone` VARCHAR(11) 
);
1
2
3
4
5
6

7.1.2 向表中插入数据

向user表中插入两条数据：

INSERT INTO `user`(`uid`,`username`,`password`,`phone`) VALUES(1001,'zhangsan','123456','13112345678');

INSERT INTO `user`(`uid`,`username`,`password`,`phone`) VALUES(1002,'lisi','123456','13844445555');
1
2
3

7.2 JDBC实现增删改查

使用JDBC+ORM技术点实现对user表增删改查操作，巩固知识点。

7.2.1 创建entity实体类User

package com.cxyzxc.www.examples03;

/**
 * entity类User类
 * 
 */
public class User {
	/** 用户编号 */
	private int uid;
	/** 用户名 */
	private String name;
	/** 密码 */
	private String password;
	/** 手机号码 */
	private String phone;

	// 无参构造方法
	public User() {
		super();
	}

	// 有参构造方法
	public User(String name, String password, String phone) {
		super();
		this.name = name;
		this.password = password;
		this.phone = phone;
	}

	// 有参构造方法
	public User(int uid, String name, String password, String phone) {
		super();
		this.uid = uid;
		this.name = name;
		this.password = password;
		this.phone = phone;
	}

	// getXxx()/setXxx()方法
	public int getUid() {
		return uid;
	}

	public void setUid(int uid) {
		this.uid = uid;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public String getPhone() {
		return phone;
	}

	public void setPhone(String phone) {
		this.phone = phone;
	}

	// 重写toString()方法
	@Override
	public String toString() {
		return "User [uid=" + uid + ", name=" + name + ", password=" + password
				+ ", phone=" + phone + "]";
	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

7.2.2 插入数据

package com.cxyzxc.www.examples03;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * JDBC连接数据 实现向数据库jdbcdatabase里user表中插入一条数据
 * 
 */
public class Jdbc01ORMInsertUser {

	public static void main(String[] args) {
		Connection connection = null;
		Statement statement = null;

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String user = "root";
			String password = "123456";
			connection = DriverManager.getConnection(url, user, password);

			// 3、获取发送SQL语句对象
			statement = connection.createStatement();
			
			//创建User对象
			User user2 = new User("王五", "123456", "13966669999");

			// 4、编写SQL语句，SQL语句最好是先在SQLyog里面写一遍并运行一下，保证SQL语句没有语法错误，这里sid是自增长，所以不需要写
			String sql = "INSERT INTO `user`(`username`,`password`,`phone`) VALUES('"+user2.getName()+"','"+user2.getPassword()+"','"+user2.getPhone()+"');";

			// 5、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			int result = statement.executeUpdate(sql);

			// 6、处理结果，如果返回的受影响行数不为0，说明数据插入成功
			if (result != 0) {
				System.out.println("数据插入成功");
			} else {
				System.out.println("数据插入失败");
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 7、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (statement != null) {
				try {
					statement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

7.2.3 删除数据

package com.cxyzxc.www.examples03;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * JDBC连接数据 实现删除数据库jdbcdatabase里user表中的一条数据
 * 
 */
public class Jdbc02ORMDeleteUser {

	public static void main(String[] args) {
		Connection connection = null;
		Statement statement = null;

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String user = "root";
			String password = "123456";
			connection = DriverManager.getConnection(url, user, password);

			// 3、获取发送SQL语句对象
			statement = connection.createStatement();
			
			//创建对象
			User user2 = new User(1003, "王五", "123456", "13966669999");

			// 4、编写SQL语句，SQL语句最好是先在SQLyog里面写一遍并运行一下，保证SQL语句没有语法错误
			String sql = "DELETE FROM `user` WHERE `uid` = "+user2.getUid()+";";

			// 5、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			int result = statement.executeUpdate(sql);

			// 6、处理结果，如果返回的受影响行数不为0，说明数据删除成功
			if (result != 0) {
				System.out.println("数据删除成功");
			} else {
				System.out.println("数据删除失败");
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 7、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (statement != null) {
				try {
					statement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

7.2.4 修改数据

package com.cxyzxc.www.examples03;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * JDBC连接数据 实现修改数据库jdbcdatabase里user表中的一条数据
 * 
 */
public class Jdbc03ORMUpdateUser {

	public static void main(String[] args) {
		Connection connection = null;
		Statement statement = null;

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String user = "root";
			String password = "123456";
			connection = DriverManager.getConnection(url, user, password);

			// 3、获取发送SQL语句对象
			statement = connection.createStatement();
			
			//创建User对象
			User user2 = new User(1002, "李四", "112233", "13999998888");

			// 4、编写SQL语句，SQL语句最好是先在SQLyog里面写一遍并运行一下，保证SQL语句没有语法错误
			String sql = "UPDATE `user` SET `username`='"+user2.getName()+"',`password`='"+user2.getPassword()+"',`phone`='"+user2.getPhone()+"' WHERE `uid`="+user2.getUid()+";";

			// 5、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			int result = statement.executeUpdate(sql);

			// 6、处理结果，如果返回的受影响行数不为0，说明数据修改成功
			if (result != 0) {
				System.out.println("数据修改成功");
			} else {
				System.out.println("数据修改失败");
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 7、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (statement != null) {
				try {
					statement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

7.2.5 查询数据

7.2.5.1 查询1条数据

package com.cxyzxc.www.examples03;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * JDBC连接数据 实现根据学号uid查询数据库jdbcdatabase里user表中的一条数据
 * 
 */
public class Jdbc04ORMSelectOneUser {

	public static void main(String[] args) {
		Connection connection = null;
		Statement statement = null;
		ResultSet resultSet = null;
		User user = null;

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String name = "root";
			String pwd = "123456";
			connection = DriverManager.getConnection(url, name, pwd);

			// 3、获取发送SQL语句对象
			statement = connection.createStatement();

			// 4、编写SQL语句，SQL语句最好是先在SQLyog里面写一遍并运行一下，保证SQL语句没有语法错误
			String sql = "SELECT * FROM `user` WHERE `uid`= 1002;";

			// 5、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			resultSet = statement.executeQuery(sql);

			// 6、处理结果，对返回的resultSet结果集进行处理，需要将结果集中的数据取出来
			// 查询一条数据时，使用if判断resultSet.next()为true，说明resultSet结果集中有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据。
			// 查询所有数据时，使用while循环判断resultSet.next()为true，说明resultSet结果集中还有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据了。
			if (resultSet.next()) {
				// 根据记录中字段的索引获取字段数据，字段索引从1开始
				int uid = resultSet.getInt(1);
				String username = resultSet.getString(2);
				String password = resultSet.getString(3);
				String phone = resultSet.getString(4);

				//使用有参构造方法创建user对象
				user = new User(uid, username, password, phone);
				//输出对象
				System.out.println(user);
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 7、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (statement != null) {
				try {
					statement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			
			if(resultSet!=null){
				try {
					resultSet.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

7.2.5.2 查询所有数据

package com.cxyzxc.www.examples03;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

/**
 * JDBC连接数据 实现根据学号uid查询数据库jdbcdatabase里user表中的一条数据
 * 
 */
public class Jdbc05ORMSelectAllUser {

	public static void main(String[] args) {
		Connection connection = null;
		Statement statement = null;
		ResultSet resultSet = null;
		User user = null;
		List<User> userList = new ArrayList<User>();

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String name = "root";
			String pwd = "123456";
			connection = DriverManager.getConnection(url, name, pwd);

			// 3、获取发送SQL语句对象
			statement = connection.createStatement();

			// 4、编写SQL语句，SQL语句最好是先在SQLyog里面写一遍并运行一下，保证SQL语句没有语法错误
			String sql = "SELECT * FROM `user`;";

			// 5、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			resultSet = statement.executeQuery(sql);

			// 6、处理结果，对返回的resultSet结果集进行处理，需要将结果集中的数据取出来
			// 查询一条数据时，使用if判断resultSet.next()为true，说明resultSet结果集中有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据。
			// 查询所有数据时，使用while循环判断resultSet.next()为true，说明resultSet结果集中还有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据了。
			while (resultSet.next()) {
				// 根据记录中字段的索引获取字段数据，字段索引从1开始
				int uid = resultSet.getInt(1);
				String username = resultSet.getString(2);
				String password = resultSet.getString(3);
				String phone = resultSet.getString(4);

				//使用有参构造方法创建user对象
				user = new User(uid, username, password, phone);
				//将创建的对象添加到集合中
				userList.add(user);
			}
			
			//遍历集合，输出所有user对象
			for (User user2 : userList) {
				System.out.println(user2);
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 7、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (statement != null) {
				try {
					statement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			
			if(resultSet!=null){
				try {
					resultSet.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

7.3 实现登录

需求：

• ​ 通过Scanner对象在控制台输入用户名和密码。
• ​ 将用户输入的用户名和密码作为条件，编写查询SQL语句，在第七节知识点中的user表中查询用户。
• ​ 如果该用户存在，提示登录成功，反之提示登录失败。

package com.cxyzxc.www.examples03;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Scanner;

/**
 * 登录类：Login类
 * 
 */
public class Login {

	public static void main(String[] args) {
		
		Connection connection = null;
		Statement statement = null;
		ResultSet resultSet = null;
		
		//创建Scanner对象，获取用户名和密码
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入用户名：");
		String username = sc.nextLine();
		System.out.println("请输入密码：");
		String password = sc.nextLine();

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String name = "root";
			String pwd = "123456";
			connection = DriverManager.getConnection(url, name, pwd);

			// 3、获取发送SQL语句对象
			statement = connection.createStatement();

			// 4、编写SQL语句，SQL语句最好是先在SQLyog里面写一遍并运行一下，保证SQL语句没有语法错误
			String sql = "SELECT * FROM `user` WHERE `username`='"+username+"' AND `password` = '"+password+"';";

			// 5、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			resultSet = statement.executeQuery(sql);

			// 6、处理结果，对返回的resultSet结果集进行处理，需要将结果集中的数据取出来
			// 查询一条数据时，使用if判断resultSet.next()为true，说明resultSet结果集中有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据。
			// 查询所有数据时，使用while循环判断resultSet.next()为true，说明resultSet结果集中还有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据了。
			if(resultSet.next()){
				System.out.println("用户名和密码正确，登录成功");
			}else{
				System.out.println("用户名或密码不正确，登录失败");
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 7、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (statement != null) {
				try {
					statement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			
			if(resultSet!=null){
				try {
					resultSet.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			
			sc.close();

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

八、SQL注入

8.1 SQL注入的效果的演示

8.1.1 SQL注入代码

参照上面的登录代码

8.1.2 SQL注入效果

输入错误的用户名和密码，提示登录失败：

输入错误的用户名和密码，提示登录成功：产生了SQL注入

![在这里插入图片描述](https://img-blog.csdnimg.cn/9f4a36654b5a45e28a001d2798729500.png#pic_center

8.2 什么是SQL注入

在用户输入的数据中有SQL关键字或语法，并且关键字或语法参与了SQL语句的编译。导致SQL语句编译后的条件为true，一直得到正确的结果。这种现象就是SQL注入。

上面案例代码中，当你的用户名为 qwert’ or 1=1;# 密码为123，拼接到SQL语句中，变成如下效果：

SELECT * FROM USER WHERE `username`='qwert' OR 1=1;#' AND `password` = '123';
1

此SQL语句or 后面1=1永远正确，#后面的成了注释，所以这条语句会将表中所有的数据查询出来，然后再做数据判断的时候，就会得到正确结果，从而说用户名和密码正确，登录成功

8.3 如何避免SQL注入

由于SQL注入产生的原因是在用户输入数据对SQL整合，整合后再发送到数据库进行编译产生的。所以为了避免SQL注入，就需要SQL语句在用户输入数据前就进行编译，成为完整的SQL语句，编译完成后再进行数据填充。这个操作需要使用PrepareStatement实现。

九、PrepareStatement解决SQL注入（重要）

PreparedStatement接口继承了Statement接口，执行SQL语句的方法与Statement执行SQL语句的方法相同。

9.1 PreparedStatement的应用

PreparedStatement的作用：

• ​ 预编译SQL语句，效率高
• ​ 安全，避免SQL注入
• ​ 可以动态的填充数据，执行多个同结构的SQL语句

9.1.1 参数标记

//预编译SQL语句，SQL中的所有参数由？符号占位，这被称为参数标记。在执行SQL语句之前，必须为每个参数提供值。
String sql = "select * from user where `username` = ? and `password`=?;";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
1
2
3

9.1.2 动态参数绑定

preparedStatement.sexXxx(下标，值)：参数下标从1开始，为指定参数下标绑定值。Xxx表示数据类型。

//绑定参数，有多少个?绑定多少个参数值
preparedStatement.setString(1, username);
preparedStatement.setString(2, pwd);
1
2
3

9.2 综合案例

9.2.1 PreparedStatement插入数据

package com.cxyzxc.www.examples04;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * JDBC连接数据 实现向数据库jdbcdatabase里user表中插入一条数据
 * 
 */
public class Jdbc01PreparedStatementInsertUser {

	public static void main(String[] args) {
		Connection connection = null;
		PreparedStatement preparedStatement =null;

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String user = "root";
			String password = "123456";
			connection = DriverManager.getConnection(url, user, password);
			
			// 3、编写SQL语句，SQL语句中需要的数据先使用占位符?表示，然后在执行前给占位符赋值
			String sql = "INSERT INTO `user`(`username`,`password`,`phone`) VALUES(?,?,?);";

			// 4、获取发送SQL语句对象
			preparedStatement = connection.prepareStatement(sql);
			
			//创建对象
			User user2 = new User("如花", "123456", "13311112222");
			
			//5、绑定参数，给?赋值
			preparedStatement.setString(1, user2.getName());
			preparedStatement.setString(2, user2.getPassword());
			preparedStatement.setString(3, user2.getPhone());

			// 6、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			int result = preparedStatement.executeUpdate();

			// 7、处理结果，如果返回的受影响行数不为0，说明数据插入成功
			if (result != 0) {
				System.out.println("数据插入成功");
			} else {
				System.out.println("数据插入失败");
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 8、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (preparedStatement != null) {
				try {
					preparedStatement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

9.2.2 PreparedStatement删除数据

package com.cxyzxc.www.examples04;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * JDBC连接数据 实现删除数据库jdbcdatabase里user表中的一条数据
 * 
 */
public class Jdbc02PreparedStatementDeleteUser {

	public static void main(String[] args) {
		Connection connection = null;
		PreparedStatement preparedStatement =null;

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String user = "root";
			String password = "123456";
			connection = DriverManager.getConnection(url, user, password);
			
			// 3、编写SQL语句，SQL语句中需要的数据先使用占位符?表示，然后在执行前给占位符赋值
			String sql = "DELETE FROM `user` WHERE `uid` = ?;";

			// 4、获取发送SQL语句对象
			preparedStatement = connection.prepareStatement(sql);

			//5、绑定参数，给?赋值
			preparedStatement.setInt(1, 1003);
			
			// 6、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			int result = preparedStatement.executeUpdate();

			// 7、处理结果，如果返回的受影响行数不为0，说明数据删除成功
			if (result != 0) {
				System.out.println("数据删除成功");
			} else {
				System.out.println("数据删除失败");
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 8、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (preparedStatement != null) {
				try {
					preparedStatement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

9.2.3 PreparedStatement修改数据

package com.cxyzxc.www.examples04;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * JDBC连接数据 实现修改数据库jdbcdatabase里user表中的一条数据
 * 
 */
public class Jdbc03PreparedStatementUpdateUser {

	public static void main(String[] args) {
		Connection connection = null;
		PreparedStatement preparedStatement =null;

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String user = "root";
			String password = "123456";
			connection = DriverManager.getConnection(url, user, password);
			
			// 3、编写SQL语句，SQL语句最好是先在SQLyog里面写一遍并运行一下，保证SQL语句没有语法错误
			String sql = "UPDATE `user` SET `username`=?,`password`=?,`phone`=? WHERE `uid`=?;";

			// 4、获取发送SQL语句对象
			preparedStatement = connection.prepareStatement(sql);
			
			//创建User对象
			User user2 = new User(1002, "李四", "112233", "13955661133");

			//5、绑定参数，给?赋值
			preparedStatement.setString(1,user2.getName());
			preparedStatement.setString(2,user2.getPassword());
			preparedStatement.setString(3,user2.getPhone());
			preparedStatement.setInt(4, user2.getUid());
			
			// 6、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			int result = preparedStatement.executeUpdate();

			// 7、处理结果，如果返回的受影响行数不为0，说明数据修改成功
			if (result != 0) {
				System.out.println("数据修改成功");
			} else {
				System.out.println("数据修改失败");
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 8、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (preparedStatement != null) {
				try {
					preparedStatement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

9.2.4 PreparedStatement查询数据

9.2.4.1 查询一条数据

package com.cxyzxc.www.examples04;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

/**
 * JDBC连接数据 实现根据学号uid查询数据库jdbcdatabase里user表中的一条数据
 * 
 */
public class Jdbc04PreparedStatementSelectOneStudent {

	public static void main(String[] args) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		User user = null;

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String name = "root";
			String pwd = "123456";
			connection = DriverManager.getConnection(url, name, pwd);
			
			// 3、编写SQL语句，SQL语句中需要的数据先使用占位符?表示，然后在执行前给占位符赋值
			String sql = "SELECT * FROM `user` WHERE `uid`= ?;";
			
			// 4、获取发送SQL语句对象
			preparedStatement  = connection.prepareStatement(sql);

			// 5、绑定参数，给?赋值
			preparedStatement.setInt(1, 1002);

			// 6、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			resultSet = preparedStatement.executeQuery();

			// 6、处理结果，对返回的resultSet结果集进行处理，需要将结果集中的数据取出来
			// 查询一条数据时，使用if判断resultSet.next()为true，说明resultSet结果集中有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据。
			// 查询所有数据时，使用while循环判断resultSet.next()为true，说明resultSet结果集中还有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据了。
			if (resultSet.next()) {
				// 根据记录中字段的索引获取字段数据，字段索引从1开始
				int uid = resultSet.getInt(1);
				String username = resultSet.getString(2);
				String password = resultSet.getString(3);
				String phone = resultSet.getString(4);

				//使用有参构造方法创建user对象
				user = new User(uid, username, password, phone);
				//输出对象
				System.out.println(user);
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 7、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (preparedStatement != null) {
				try {
					preparedStatement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			
			if(resultSet!=null){
				try {
					resultSet.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

9.2.4.2 查询所有数据

package com.cxyzxc.www.examples04;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

/**
 * JDBC连接数据 实现根据学号uid查询数据库jdbcdatabase里user表中的一条数据
 * 
 */
public class Jdbc05PreparedStatementSelectAllStudent {

	public static void main(String[] args) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		User user = null;
		List<User> userList = new ArrayList<User>();

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String name = "root";
			String pwd = "123456";
			connection = DriverManager.getConnection(url, name, pwd);
			
			// 3、编写SQL语句，SQL语句中需要的数据先使用占位符?表示，然后在执行前给占位符赋值
			String sql = "SELECT * FROM `user`;";

			// 4、获取发送SQL语句对象
			preparedStatement = connection.prepareStatement(sql);

			// 5、绑定参数，给?赋值，这里不需要绑定参数

			// 6、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			resultSet = preparedStatement.executeQuery();

			// 7、处理结果，对返回的resultSet结果集进行处理，需要将结果集中的数据取出来
			// 查询一条数据时，使用if判断resultSet.next()为true，说明resultSet结果集中有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据。
			// 查询所有数据时，使用while循环判断resultSet.next()为true，说明resultSet结果集中还有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据了。
			while (resultSet.next()) {
				// 根据记录中字段的索引获取字段数据，字段索引从1开始
				int uid = resultSet.getInt(1);
				String username = resultSet.getString(2);
				String password = resultSet.getString(3);
				String phone = resultSet.getString(4);

				//使用有参构造方法创建user对象
				user = new User(uid, username, password, phone);
				//将创建的对象添加到集合中
				userList.add(user);
			}
			
			//遍历集合，输出所有user对象
			for (User user2 : userList) {
				System.out.println(user2);
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 8、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (preparedStatement != null) {
				try {
					preparedStatement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			
			if(resultSet!=null){
				try {
					resultSet.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

9.2.5 PreparedStatement实现登录

package com.cxyzxc.www.examples04;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Scanner;

/**
 * PreparedStatement实现登录，解决SQL注入问题
 * 
 */

public class PreparedStatementLogin {

	public static void main(String[] args) {
		
		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		
		//创建Scanner对象，获取用户名和密码
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入用户名：");
		String username = sc.nextLine();
		System.out.println("请输入密码：");
		String password = sc.nextLine();

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String name = "root";
			String pwd = "123456";
			connection = DriverManager.getConnection(url, name, pwd);
			
			// 3、编写SQL语句，SQL语句中需要的数据先使用占位符?表示，然后在执行前给占位符赋值
			String sql = "SELECT * FROM `user` WHERE `username`=? AND `password` = ?;";
			
			// 4、获取发送SQL语句对象
			preparedStatement = connection.prepareStatement(sql);
			
			//5、绑定参数，给?赋值
			preparedStatement.setString(1, username);
			preparedStatement.setString(2, password);

			// 6、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			resultSet = preparedStatement.executeQuery();

			// 7、处理结果，对返回的resultSet结果集进行处理，需要将结果集中的数据取出来
			// 查询一条数据时，使用if判断resultSet.next()为true，说明resultSet结果集中有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据。
			// 查询所有数据时，使用while循环判断resultSet.next()为true，说明resultSet结果集中还有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据了。
			if(resultSet.next()){
				System.out.println("用户名和密码正确，登录成功");
			}else{
				System.out.println("用户名或密码不正确，登录失败");
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 8、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (preparedStatement != null) {
				try {
					preparedStatement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			
			if(resultSet!=null){
				try {
					resultSet.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			
			sc.close();

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

十、Date工具类

学完使用JDBC连接数据库并使用PrepareStatement类对表中数据进行增删改查后，我们做一个练习，对下列people表进行增删改查操作。

10.1 创建people表

10.1.1 创建表

创建一张用户表peopler，表的字段如下：

​ pid，编号，主键、自动增长

​ name，姓名，varchar(20)、非空

​ age，年龄，int(3)，非空

​ gender，性别，varchar(3)，非空

​ birthday，出生日期，Date类型，非空

​ identitycard，身份证号码，varchar(18) ，唯一，非空

​ phone，手机号码，字符串类型，唯一，非空

​ address，住址，varchar(20)，非空

CREATE TABLE IF NOT EXISTS `people`(
`pid` INT PRIMARY KEY AUTO_INCREMENT COMMENT '编号',
`name` VARCHAR(20) NOT NULL COMMENT '姓名',
`age` INT(3) NOT NULL COMMENT '年龄',
`gender` VARCHAR(3) NOT NULL COMMENT '性别',
`birthday` DATE NOT NULL COMMENT '出生日期',
`identitycrd` VARCHAR(18) NOT NULL UNIQUE COMMENT '身份证号码',
`phone` VARCHAR(11) NOT NULL UNIQUE COMMENT '手机号码', 
`address` VARCHAR(20) NOT NULL COMMENT '住址'
);
1
2
3
4
5
6
7
8
9
10

10.1.2 向表中添加数据

向people表中插入两条数据：

INSERT INTO `people`(`pid`,`name`,`age`,`gender`,`birthday`,`identitycrd`,`phone`,`address`)
VALUES
(1001,'张三',30,'男','1992-04-05','340825199204051920','13888885555','安徽合肥庐阳区');

INSERT INTO `people`(`pid`,`name`,`age`,`gender`,`birthday`,`identitycrd`,`phone`,`address`)
VALUES
(1002,'李红',28,'女','1994-04-15','340825199204151922','13888886666','安徽合肥瑶海区');
1
2
3
4
5
6
7

10.2 问题描述

在上述操作过程中发现如下问题：

• 数据库中存储的日期时间类型为java.sql.Date类型，Java应用层存储的日期时间类型为java.util.Date类型。

• 从数据库获取的日期时间类型数据可以直接赋值给Java应用层的日期时间类型变量，因为java.sql.Date类是java.util.Date类的子类，向上转型（父类引用指向子类对象）是可以直接赋值的。

• Java应用层的日期时间类型数据不能直接存储在数据库中，需要进行相应的转换。

• preparedStatement.setDate(int parameterIndex, Date x)中Date为java.sql.Date类型。

10.3 与日期时间相关的类

10.3.1 java.util.Date

（1）Java语言常规应用层面的日期时间类型，可以通过字符串创建对应的日期时间对象，但是已经过时。常用构造方法如下（很多构造方法已经过时）：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O3LfZxvU-1690879270297)(img/09java.util.date类的构造方法.png)]

（2）不能直接通过JDBC将java.util.Date类型数据插入到数据库中。

10.3.2 java.sql.Date

（1）不可以通过字符串创建对应的时间对象，只能通过毫秒值创建对象（1970年1月1日0点0分0秒至今的毫秒值），常用构造方法如下：

（2）可以直接通过JDBC将java.util.Date类型数据插入到数据库中。

10.3.3 SimpleDateFormat

（1）SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。

（2）SimpleDateFormat使得可以选择任何用户定义的日期-时间格式的模式。

（3）SimpleDateFormat应用如下：

package com.cxyzxc.www.examples05;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * SimpleDateFormat类应用
 * 
 */
public class SimpleDateFormatTest {

	public static void main(String[] args) {

		// 指定日期格式
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

		try {
			String strDate1 = "2022-10-22";
			// 将字字符串解析成日期类型（java.util.Date）
			java.util.Date date1 = sdf.parse(strDate1);
			System.out.println("字符串解析成日期：" + date1);

			Date date2 = new Date();
			String strDate2 = sdf.format(date2);
			System.out.println("日期解析成字符串：" + strDate2);
		} catch (ParseException e) {
			e.printStackTrace();
		}
	}

}
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

10.3 封装DateUtils工具类

package com.cxyzxc.www.examples05;

import java.text.ParseException;
import java.text.SimpleDateFormat;

/**
 * 日期时间工具类DateUtils
 * 
 */
public class DateUtils {

	private static final SimpleDateFormat SIMPLEDATEFORMAT = new SimpleDateFormat("yyyy-MM-dd");

	// 字符串转换为java.util.Date类型日期时间
	public static java.util.Date strDateToUtilDate(String strDate) {
		try {
			return SIMPLEDATEFORMAT.parse(strDate);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return null;
	}

	// java.util.Date类型日期时间转换为java.sql.Date类型日期时间
	public static java.sql.Date utilDateToSqlDate(java.util.Date date) {
		// long date.getTime():返回自 1970 年 1 月 1 日 00:00:00 GMT以来此 Date对象表示的毫秒数
		return new java.sql.Date(date.getTime());
	}

	// java.util.Date类转换为字符串类型
	public static String utilDateToString(java.util.Date date) {
		return SIMPLEDATEFORMAT.format(date);
	}

}
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

10.4 综合案例

10.4.1 创建entity类People类

package com.cxyzxc.www.examples05;

import java.util.Date;

/**
 * entity实体类People类
 * 
 */
public class People {
	/** 编号 */
	private int pid;
	/** 姓名 */
	private String name;
	/** 年龄 */
	private int age;
	/** 性别 */
	private String gender;
	/** 出生日期 */
	private Date birthday;
	/** 身份证号码 */
	private String identitycard;
	/** 手机号码 */
	private String phone;
	/** 住址 */
	private String address;

	// 无参构造方法
	public People() {
		super();
	}

	// 有参构造方法
	public People(String name, int age, String gender, Date birthday,
			String identitycard, String phone, String address) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
		this.birthday = birthday;
		this.identitycard = identitycard;
		this.phone = phone;
		this.address = address;
	}

	// 有参构造方法
	public People(int pid, String name, int age, String gender, Date birthday,
			String identitycard, String phone, String address) {
		super();
		this.pid = pid;
		this.name = name;
		this.age = age;
		this.gender = gender;
		this.birthday = birthday;
		this.identitycard = identitycard;
		this.phone = phone;
		this.address = address;
	}

	// getXxx()/setXxx()方法
	public int getPid() {
		return pid;
	}

	public void setPid(int pid) {
		this.pid = pid;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getGender() {
		return gender;
	}

	public void setGender(String gender) {
		this.gender = gender;
	}

	public Date getBirthday() {
		return birthday;
	}

	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}

	public String getIdentitycard() {
		return identitycard;
	}

	public void setIdentitycard(String identitycard) {
		this.identitycard = identitycard;
	}

	public String getPhone() {
		return phone;
	}

	public void setPhone(String phone) {
		this.phone = phone;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	// 重写toString()方法
	@Override
	public String toString() {
		return "People [pid=" + pid + ", name=" + name + ", age=" + age
				+ ", gender=" + gender + ", birthday=" + birthday
				+ ", identitycard=" + identitycard + ", phone=" + phone
				+ ", address=" + address + "]";
	}

}

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

10.4.2 插入数据

package com.cxyzxc.www.examples05;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * JDBC连接数据 实现向数据库jdbcdatabase里people表中插入一条数据
 * 
 */
public class Jdbc01PreparedStatementInsertPeople {

	public static void main(String[] args) {
		Connection connection = null;
		PreparedStatement preparedStatement =null;

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String user = "root";
			String password = "123456";
			connection = DriverManager.getConnection(url, user, password);
			
			// 3、编写SQL语句，SQL语句中需要的数据先使用占位符?表示，然后在执行前给占位符赋值
			String sql = "INSERT INTO `people`(`name`,`age`,`gender`,`birthday`,`identitycard`,`phone`,`address`) VALUES(?,?,?,?,?,?,?);";

			// 4、获取发送SQL语句对象
			preparedStatement = connection.prepareStatement(sql);
			
			//创建People对象
			People people = new People("王五", 30, "男", DateUtils.strDateToUtilDate("1992-04-05"), "340825199204051926", "13845691236", "安徽合肥庐阳区");
			
			//5、绑定参数，给?赋值
			preparedStatement.setString(1, people.getName());
			preparedStatement.setInt(2,people.getAge());
			preparedStatement.setString(3,people.getGender());
			//setDate(Date date)方法中需要的参数date类型是java.sql.Date类型，People对象中的Date类型是java.util.Date，需要进行转换
			preparedStatement.setDate(4,DateUtils.utilDateToSqlDate(people.getBirthday()));
			preparedStatement.setString(5,people.getIdentitycard());
			preparedStatement.setString(6, people.getPhone());
			preparedStatement.setString(7, people.getAddress());

			// 6、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			int result = preparedStatement.executeUpdate();

			// 7、处理结果，如果返回的受影响行数不为0，说明数据插入成功
			if (result != 0) {
				System.out.println("数据插入成功");
			} else {
				System.out.println("数据插入失败");
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 8、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (preparedStatement != null) {
				try {
					preparedStatement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

10.4.3 删除数据

package com.cxyzxc.www.examples05;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * JDBC连接数据 实现删除数据库jdbcdatabase里people表中的一条数据
 * 
 */
public class Jdbc02PreparedStatementDeletePeople {

	public static void main(String[] args) {
		Connection connection = null;
		PreparedStatement preparedStatement =null;

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String user = "root";
			String password = "123456";
			connection = DriverManager.getConnection(url, user, password);
			
			// 3、编写SQL语句，SQL语句中需要的数据先使用占位符?表示，然后在执行前给占位符赋值
			String sql = "DELETE FROM `people` WHERE `pid` = ?;";

			// 4、获取发送SQL语句对象
			preparedStatement = connection.prepareStatement(sql);

			//5、绑定参数，给?赋值
			preparedStatement.setInt(1, 1003);
			
			// 6、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			int result = preparedStatement.executeUpdate();

			// 7、处理结果，如果返回的受影响行数不为0，说明数据删除成功
			if (result != 0) {
				System.out.println("数据删除成功");
			} else {
				System.out.println("数据删除失败");
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 8、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (preparedStatement != null) {
				try {
					preparedStatement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

10.4.4 修改数据

package com.cxyzxc.www.examples05;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * JDBC连接数据 实现修改数据库jdbcdatabase里people表中的一条数据
 * 
 */
public class Jdbc03PreparedStatementUpdatePeople {

	public static void main(String[] args) {
		Connection connection = null;
		PreparedStatement preparedStatement =null;

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String user = "root";
			String password = "123456";
			connection = DriverManager.getConnection(url, user, password);
			
			// 3、编写SQL语句，SQL语句最好是先在SQLyog里面写一遍并运行一下，保证SQL语句没有语法错误
			String sql = "UPDATE `people` SET `name`=?,`age`=?,`gender`=?,`birthday`=?,`identitycard`=?,`phone`=?,`address`=? WHERE `pid`=?;";

			// 4、获取发送SQL语句对象
			preparedStatement = connection.prepareStatement(sql);
			
			//创建对象
			People people = new People(1002, "李花花", 28, "女", DateUtils.strDateToUtilDate("1994-04-15"), "340825199404151922", "13122337788", "安徽合肥政务区");

			//5、绑定参数，给?赋值
			preparedStatement.setString(1,people.getName());
			preparedStatement.setInt(2, people.getAge());
			preparedStatement.setString(3,people.getGender());
			preparedStatement.setDate(4, DateUtils.utilDateToSqlDate(people.getBirthday()));
			preparedStatement.setString(5,people.getIdentitycard());
			preparedStatement.setString(6,people.getPhone());
			preparedStatement.setString(7,people.getAddress());
			preparedStatement.setInt(8, people.getPid());
			
			// 6、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			int result = preparedStatement.executeUpdate();

			// 7、处理结果，如果返回的受影响行数不为0，说明数据修改成功
			if (result != 0) {
				System.out.println("数据修改成功");
			} else {
				System.out.println("数据修改失败");
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 8、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (preparedStatement != null) {
				try {
					preparedStatement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

10.4.5 查询数据

10.4.5.1 查询一条数据

package com.cxyzxc.www.examples05;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;

/**
 * JDBC连接数据 实现根据学号uid查询数据库jdbcdatabase里people表中的一条数据
 * 
 */
public class Jdbc04PreparedStatementSelectOnePeople {

	public static void main(String[] args) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		People people = null;

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String name = "root";
			String pwd = "123456";
			connection = DriverManager.getConnection(url, name, pwd);
			
			// 3、编写SQL语句，SQL语句中需要的数据先使用占位符?表示，然后在执行前给占位符赋值
			String sql = "SELECT * FROM `people` WHERE `pid`= ?;";
			
			// 4、获取发送SQL语句对象
			preparedStatement  = connection.prepareStatement(sql);

			// 5、绑定参数，给?赋值
			preparedStatement.setInt(1, 1002);

			// 6、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			resultSet = preparedStatement.executeQuery();

			// 6、处理结果，对返回的resultSet结果集进行处理，需要将结果集中的数据取出来
			// 查询一条数据时，使用if判断resultSet.next()为true，说明resultSet结果集中有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据。
			// 查询所有数据时，使用while循环判断resultSet.next()为true，说明resultSet结果集中还有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据了。
			if (resultSet.next()) {
				// 根据记录中字段的索引获取字段数据，字段索引从1开始
				int pid = resultSet.getInt(1);
				String peopleName = resultSet.getString(2);
				int age = resultSet.getInt(3);
				String gender = resultSet.getString(4);
				Date birthday = resultSet.getDate(5);
				String identitycard=resultSet.getString(6);
				String phone =resultSet.getString(7);
				String address=resultSet.getString(8);

				//使用有参构造方法创建People对象
				people = new People(pid, peopleName, age, gender, birthday, identitycard, phone, address);
				//输出对象
				System.out.println(people);
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 7、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (preparedStatement != null) {
				try {
					preparedStatement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			
			if(resultSet!=null){
				try {
					resultSet.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

10.4.5.2 查询所有数据

package com.cxyzxc.www.examples05;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * JDBC连接数据 实现根据编号pid查询数据库jdbcdatabase里people表中的一条数据
 * 
 */
public class Jdbc05PreparedStatementSelectAllPeople {

	public static void main(String[] args) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		People people = null;
		List<People> peopleList = new ArrayList<People>();

		try {
			// 1、注册驱动
			Class.forName("com.mysql.jdbc.Driver");

			// 2 、获取数据库连接对象
			String url = "jdbc:mysql://127.0.0.1:3306/jdbcdatabase";
			String name = "root";
			String pwd = "123456";
			connection = DriverManager.getConnection(url, name, pwd);
			
			// 3、编写SQL语句，SQL语句中需要的数据先使用占位符?表示，然后在执行前给占位符赋值
			String sql = "SELECT * FROM `people`;";

			// 4、获取发送SQL语句对象
			preparedStatement = connection.prepareStatement(sql);

			// 5、绑定参数，给?赋值，这里不需要绑定参数
			

			// 6、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			resultSet = preparedStatement.executeQuery();

			// 7、处理结果，对返回的resultSet结果集进行处理，需要将结果集中的数据取出来
			// 查询一条数据时，使用if判断resultSet.next()为true，说明resultSet结果集中有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据。
			// 查询所有数据时，使用while循环判断resultSet.next()为true，说明resultSet结果集中还有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据了。
			while (resultSet.next()) {
				// 根据记录中字段的索引获取字段数据，字段索引从1开始
				int pid = resultSet.getInt(1);
				String peopleName = resultSet.getString(2);
				int age = resultSet.getInt(3);
				String gender = resultSet.getString(4);
				Date birthday = resultSet.getDate(5);
				String identitycard=resultSet.getString(6);
				String phone =resultSet.getString(7);
				String address=resultSet.getString(8);

				//使用有参构造方法创建People对象
				people = new People(pid, peopleName, age, gender, birthday, identitycard, phone, address);
				//将创建的对象添加到集合中
				peopleList.add(people);
			}
			
			//遍历集合，输出所有People对象
			for (People People2 : peopleList) {
				System.out.println(People2);
			}

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 8、释放资源，遵循“先开后关，后开先关”的原则
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

			if (preparedStatement != null) {
				try {
					preparedStatement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			
			if(resultSet!=null){
				try {
					resultSet.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

十一、封装工具类

11.1 为什么要封装工具类

• 在实际JDBC中的使用中，存在着大量的重复代码：例如连接数据库、关闭数据库这些操作。
• 我们需要把传统的JDBC代码进行重构，抽取出通用的JDBC工具类。以后连接任何数据库、释放资源都可以使用这个工具类。

11.2 重用性方案

11.2.1 方案思想

（1）新建一个工具类DBUtils。

（2）在工具类DBUtils类中封装获取连接、释放资源两个方法。

• 提供public static Connection getConnection(){}方法。
• 提供public static void closeAll(Connection connection,Statement statement,ResultSet resultSet){}方法

11.2.2 方案代码

package com.cxyzxc.www.examples01;

import java.sql.*;

/**
 * 重用性方案 注册驱动 获取连接 释放资源
 * 
 */
public class DBUtils {

	// 类加载，执行一次！
	static {
		try {
			// 注册驱动
			Class.forName("com.mysql.jdbc.Driver");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

	// 获取连接
	public static Connection getConnection() {
		Connection connection = null;
		try {
			connection = DriverManager.getConnection(
					"jdbc:mysql://localhost:3306/jdbcdatabase", "root",
					"123456");
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return connection;
	}

	// 释放资源
	public static void closeAll(Connection connection, Statement statement,
			ResultSet resultSet) {
		try {
			if (resultSet != null) {
				resultSet.close();
			}
			if (statement != null) {
				statement.close();
			}
			if (connection != null) {
				connection.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
}
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

11.3 跨平台方案

11.3.1 方案思想

（1）在重用性方案中数据库的相关信息写在Java代码中，如果要修改数据库的相关信息，需要修改Java代码，比较麻烦，所以需要将数据库相关信息抽取出来放到一个专门的文件中存储。

（2）在项目src文件夹下创建db.properties文件，在文件中编写数据库驱动、数据库url、用户名、密码相关数据。

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/java2217
username=root
password=123456
1
2
3
4

（2）在工具类DBUtils类中读取db.properties配置文件数据。

定义private static final Properties PROPERTIES = new Properties();//读取配置文件的Map

定义static{

	//通过复用本类自带流，读取配置文件中的数据

	InputStream is = DBUtils.class.getResourceAsStream("配置文件路径");

	// 通过prop对象将流中的配置信息分隔成键值对

	PROPERTIES.load(is);

	//通过driverName的键获取对应的值（com.mysql.jdbc.Driver）

	String driverName=PROPERTIES.getProperty("driver");
	//注册驱动
	Class.forName(driverName);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

（3）在工具类DBUtils类中封装获取连接、释放资源两个方法。

• 提供public static Connection getConnection(){}方法。
• 提供public static void closeAll(Connection connection,Statement statement,ResultSet resultSet){}方法

11.3.2 方案代码

package com.cxyzxc.www.examples02;

import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

/**
 * 跨平台方案 注册驱动 获取连接 释放资源
 * 
 */
public class DBUtils {
	// //读取配置文件的Map
	private static final Properties PROPERTIES = new Properties();

	static {
		// 通过复用本类自带流，读取配置文件中的数据
		InputStream is = DBUtils.class.getResourceAsStream("/db.properties");

		try {
			// 通过prop对象将流中的配置信息分隔成键值对,将配置文件内容加载到properties集合
			PROPERTIES.load(is);
			// 注册驱动，通过driverName的键获取对应的值（com.mysql.jdbc.Driver）
			Class.forName(PROPERTIES.getProperty("driver"));
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

	// 获取连接对象
	public static Connection getConnection() {
		Connection connection = null;
		try {
			connection = DriverManager.getConnection(
					PROPERTIES.getProperty("url"),
					PROPERTIES.getProperty("username"),
					PROPERTIES.getProperty("password"));
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return connection;
	}

	// 释放所有资源
	public static void closeAll(Connection connection, Statement statement,
			ResultSet resultSet) {
		try {
			if (resultSet != null) {
				resultSet.close();
			}
			if (statement != null) {
				statement.close();
			}
			if (connection != null) {
				connection.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
}
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
60
61
62
63

11.4 综合案例（重复性方案）

11.4.1 创建animal表

11.4.1.1 创建表

CREATE TABLE IF NOT EXISTS `animal`(
`aid` INT PRIMARY KEY AUTO_INCREMENT COMMENT '宠物编号',
`type` VARCHAR(10) NOT NULL COMMENT '类型',
`name` VARCHAR(10) NOT NULL COMMENT '名字',
`age` INT NOT NULL COMMENT '年龄',
`gender` VARCHAR(3) NOT NULL COMMENT '性别',
`birthday` DATE NOT NULL COMMENT '出生日期'
);
1
2
3
4
5
6
7
8

11.4.1.2 插入数据

INSERT INTO `animal`(`aid`,`type`,`name`,`age`,`gender`,`birthday`) 
VALUES
(1001,'狗','旺财',3,'公','2019-12-18');

INSERT INTO `animal`(`aid`,`type`,`name`,`age`,`gender`,`birthday`) 
VALUES
(1002,'猫','阿狸',2,'母','2020-03-27');
1
2
3
4
5
6
7

11.4.2 创建entity类Animal类

package com.cxyzxc.www.examples01;

import java.util.Date;

public class Animal {

	/** 宠物编号 */
	private int aid;
	/** 类型 */
	private String type;
	/** 名字 */
	private String name;
	/** 年龄 */
	private int age;
	/** 性别 */
	private String gender;
	/** 出生日期 */
	private Date birthday;

	// 无参构造方法
	public Animal() {
		super();
	}

	// 有参构造方法
	public Animal(String type, String name, int age, String gender,
			Date birthday) {
		super();
		this.type = type;
		this.name = name;
		this.age = age;
		this.gender = gender;
		this.birthday = birthday;
	}

	// 有参构造方法
	public Animal(int aid, String type, String name, int age, String gender,
			Date birthday) {
		super();
		this.aid = aid;
		this.type = type;
		this.name = name;
		this.age = age;
		this.gender = gender;
		this.birthday = birthday;
	}

	// getXxx()/setXxx()方法
	public int getAid() {
		return aid;
	}

	public void setAid(int aid) {
		this.aid = aid;
	}

	public String getType() {
		return type;
	}

	public void setType(String type) {
		this.type = type;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getGender() {
		return gender;
	}

	public void setGender(String gender) {
		this.gender = gender;
	}

	public Date getBirthday() {
		return birthday;
	}

	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}

	// 重写toString()方法
	@Override
	public String toString() {
		return "Animal [aid=" + aid + ", type=" + type + ", name=" + name
				+ ", age=" + age + ", gender=" + gender + ", birthday="
				+ birthday + "]";
	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

11.4.3 插入数据

package com.cxyzxc.www.examples01;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * JDBC连接数据 实现向数据库jdbcdatabase里animal表中插入一条数据
 * 
 */
public class Jdbc01PreparedStatementInsertAnimal {

	public static void main(String[] args) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;

		try {
			// 2、获取连接对象
			connection = DBUtils.getConnection();

			// 3、编写SQL语句，SQL语句中需要的数据先使用占位符?表示，然后在执行前给占位符赋值
			String sql = "INSERT INTO `animal`(`type`,`name`,`age`,`gender`,`birthday`) VALUES(?,?,?,?,?);";

			// 4、获取发送SQL语句对象
			preparedStatement = connection.prepareStatement(sql);

			// 创建People对象
			Animal animal = new Animal("狗", "来福", 2, "公",DateUtils.strDateToUtilDate("2020-11-02"));

			// 5、绑定参数，给?赋值
			preparedStatement.setString(1, animal.getType());
			preparedStatement.setString(2, animal.getName());
			preparedStatement.setInt(3, animal.getAge());
			preparedStatement.setString(4, animal.getGender());
			// setDate(Date
			// date)方法中需要的参数date类型是java.sql.Date类型，animal对象中的Date类型是java.util.Date，需要进行转换
			preparedStatement.setDate(5,DateUtils.utilDateToSqlDate(animal.getBirthday()));

			// 6、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			int result = preparedStatement.executeUpdate();

			// 7、处理结果，如果返回的受影响行数不为0，说明数据插入成功
			if (result != 0) {
				System.out.println("数据插入成功");
			} else {
				System.out.println("数据插入失败");
			}

		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(connection, preparedStatement, null);

		}

	}

}
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
60

11.4.4 删除数据

package com.cxyzxc.www.examples01;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * JDBC连接数据 实现删除数据库jdbcdatabase里people表中的一条数据
 * 
 */
public class Jdbc02PreparedStatementDeleteAnimal {

	public static void main(String[] args) {
		Connection connection = null;
		PreparedStatement preparedStatement =null;

		try {
			
			connection = DBUtils.getConnection();
			
			// 3、编写SQL语句，SQL语句中需要的数据先使用占位符?表示，然后在执行前给占位符赋值
			String sql = "DELETE FROM `animal` WHERE `aid` = ?;";

			// 4、获取发送SQL语句对象
			preparedStatement = connection.prepareStatement(sql);

			//5、绑定参数，给?赋值
			preparedStatement.setInt(1, 1003);
			
			// 6、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			int result = preparedStatement.executeUpdate();

			// 7、处理结果，如果返回的受影响行数不为0，说明数据删除成功
			if (result != 0) {
				System.out.println("数据删除成功");
			} else {
				System.out.println("数据删除失败");
			}

		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 8、释放资源，遵循“先开后关，后开先关”的原则
			DBUtils.closeAll(connection, preparedStatement, null);

		}

	}

}
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

11.4.5 修改数据

package com.cxyzxc.www.examples01;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * JDBC连接数据 实现修改数据库jdbcdatabase里animal表中的一条数据
 * 
 */
public class Jdbc03PreparedStatementUpdateAnimal {

	public static void main(String[] args) {
		Connection connection = null;
		PreparedStatement preparedStatement =null;

		try {
			
			connection = DBUtils.getConnection();
			
			// 3、编写SQL语句，SQL语句最好是先在SQLyog里面写一遍并运行一下，保证SQL语句没有语法错误
			String sql = "UPDATE `animal` SET `type`=?,`name`=?,`age`=?,`gender`=?,`birthday`=? WHERE `aid`=?;";

			// 4、获取发送SQL语句对象
			preparedStatement = connection.prepareStatement(sql);
			
			//创建对象
			Animal animal = new Animal(1002,"猫","Tom",2,"公",DateUtils.strDateToUtilDate("2020-06-11"));
			
			//5、绑定参数，给?赋值
			preparedStatement.setString(1,animal.getType());
			preparedStatement.setString(2, animal.getName());
			preparedStatement.setInt(3,animal.getAge());
			preparedStatement.setString(4,animal.getGender());
			preparedStatement.setDate(5, DateUtils.utilDateToSqlDate(animal.getBirthday()));
			preparedStatement.setInt(6,animal.getAid());

			// 6、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			int result = preparedStatement.executeUpdate();

			// 7、处理结果，如果返回的受影响行数不为0，说明数据修改成功
			if (result != 0) {
				System.out.println("数据修改成功");
			} else {
				System.out.println("数据修改失败");
			}

		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 8、释放资源，遵循“先开后关，后开先关”的原则
			DBUtils.closeAll(connection, preparedStatement, null);

		}

	}

}
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
60

11.4.5 查询数据

11.4.5.1 查询一条数据

package com.cxyzxc.www.examples01;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;

/**
 * JDBC连接数据 实现根据学号uid查询数据库jdbcdatabase里animal表中的一条数据
 * 
 */
public class Jdbc04PreparedStatementSelectOneAnimal {

	public static void main(String[] args) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		Animal animal = null;

		try {
			
			connection = DBUtils.getConnection();
			
			// 3、编写SQL语句，SQL语句中需要的数据先使用占位符?表示，然后在执行前给占位符赋值
			String sql = "SELECT * FROM `animal` WHERE `aid`= ?;";
			
			// 4、获取发送SQL语句对象
			preparedStatement  = connection.prepareStatement(sql);

			// 5、绑定参数，给?赋值
			preparedStatement.setInt(1, 1001);

			// 6、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			resultSet = preparedStatement.executeQuery();

			// 6、处理结果，对返回的resultSet结果集进行处理，需要将结果集中的数据取出来
			// 查询一条数据时，使用if判断resultSet.next()为true，说明resultSet结果集中有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据。
			// 查询所有数据时，使用while循环判断resultSet.next()为true，说明resultSet结果集中还有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据了。
			if (resultSet.next()) {
				// 根据记录中字段的索引获取字段数据，字段索引从1开始
				int aid = resultSet.getInt(1);
				String type = resultSet.getString(2);
				String name = resultSet.getString(3);
				int age = resultSet.getInt(4);
				String gender=resultSet.getString(5);
				Date birthday = resultSet.getDate(6);
				
				//使用有参构造方法创建Animal对象
				animal = new Animal(aid, type, name, age, gender, birthday);
				
				//输出对象
				System.out.println(animal);
			}

		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 7、释放资源，遵循“先开后关，后开先关”的原则
			DBUtils.closeAll(connection, preparedStatement, resultSet);

		}

	}

}
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
60
61
62
63
64
65
66
67
68

11.4.5.2 查询所有数据

package com.cxyzxc.www.examples01;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * JDBC连接数据 实现根据编号pid查询数据库jdbcdatabase里animal表中的一条数据
 * 
 */
public class Jdbc05PreparedStatementSelectAllAnimal {

	public static void main(String[] args) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		Animal animal = null;
		List<Animal> animalList = new ArrayList<Animal>();

		try {
			
			connection = DBUtils.getConnection();
			
			// 3、编写SQL语句，SQL语句中需要的数据先使用占位符?表示，然后在执行前给占位符赋值
			String sql = "SELECT * FROM `animal`;";

			// 4、获取发送SQL语句对象
			preparedStatement = connection.prepareStatement(sql);

			// 5、绑定参数，给?赋值，这里不需要绑定参数

			// 6、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			resultSet = preparedStatement.executeQuery();

			// 7、处理结果，对返回的resultSet结果集进行处理，需要将结果集中的数据取出来
			// 查询一条数据时，使用if判断resultSet.next()为true，说明resultSet结果集中有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据。
			// 查询所有数据时，使用while循环判断resultSet.next()为true，说明resultSet结果集中还有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据了。
			while (resultSet.next()) {
				// 根据记录中字段的索引获取字段数据，字段索引从1开始
				int aid = resultSet.getInt(1);
				String type = resultSet.getString(2);
				String name = resultSet.getString(3);
				int age = resultSet.getInt(4);
				String gender=resultSet.getString(5);
				Date birthday = resultSet.getDate(6);
				
				//使用有参构造方法创建Animal对象
				animal = new Animal(aid, type, name, age, gender, birthday);
				//将创建的对象添加到集合中
				animalList.add(animal);
			}
			
			//遍历集合，输出所有People对象
			for (Animal animal2 : animalList) {
				System.out.println(animal2);
			}

		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 8、释放资源，遵循“先开后关，后开先关”的原则
			DBUtils.closeAll(connection, preparedStatement, resultSet);

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

11.5 综合案例（跨平台方案）

11.5.1 创建car表

11.5.1.1 创建表

CREATE TABLE IF NOT EXISTS `car`(
`cid` INT PRIMARY KEY AUTO_INCREMENT COMMENT '编号',
`brand` VARCHAR(10) NOT NULL COMMENT '品牌',
`type` VARCHAR(10) NOT NULL COMMENT '型号',
`color` VARCHAR(10) NOT NULL COMMENT '颜色',
`birthday` DATE NOT NULL COMMENT '出厂日期',
`vin` VARCHAR(20) UNIQUE NOT NULL COMMENT '车架号',
`price` DOUBLE NOT NULL COMMENT '价格'
);
1
2
3
4
5
6
7
8
9

11.5.1.2 插入数据

INSERT INTO `car`(`cid`,`brand`,`type`,`color`,`birthday`,`vin`,`price`)
VALUES
(1001,'吉利','星越L','蓝色','2021-11-19','34091564784664WK45',156800);

INSERT INTO `car`(`cid`,`brand`,`type`,`color`,`birthday`,`vin`,`price`)
VALUES
(1002,'奔驰','E300','黑色','2021-11-19','35291579654688BC45',352800);
1
2
3
4
5
6
7

11.5.2 创建entity类Car类

package com.cxyzxc.www.examples02;

import java.util.Date;

public class Car {

	/** 编号 */
	private int cid;
	/** 品牌 */
	private String brand;
	/** 型号 */
	private String type;
	/** 颜色 */
	private String color;
	/** 出厂日期 */
	private Date birthday;
	/** 车架号 */
	private String vin;
	/** 价格 */
	private String price;

	// 无参构造方法
	public Car() {
		super();
	}

	// 有参构造方法
	public Car(String brand, String type, String color, Date birthday,
			String vin, String price) {
		super();
		this.brand = brand;
		this.type = type;
		this.color = color;
		this.birthday = birthday;
		this.vin = vin;
		this.price = price;
	}

	// 有参构造方法
	public Car(int cid, String brand, String type, String color, Date birthday,
			String vin, String price) {
		super();
		this.cid = cid;
		this.brand = brand;
		this.type = type;
		this.color = color;
		this.birthday = birthday;
		this.vin = vin;
		this.price = price;
	}

	// getXxx()/setXxx()方法
	public int getCid() {
		return cid;
	}

	public void setCid(int cid) {
		this.cid = cid;
	}

	public String getBrand() {
		return brand;
	}

	public void setBrand(String brand) {
		this.brand = brand;
	}

	public String getType() {
		return type;
	}

	public void setType(String type) {
		this.type = type;
	}

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}

	public Date getBirthday() {
		return birthday;
	}

	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}

	public String getVin() {
		return vin;
	}

	public void setVin(String vin) {
		this.vin = vin;
	}

	public String getPrice() {
		return price;
	}

	public void setPrice(String price) {
		this.price = price;
	}

	// 重写toString()方法
	@Override
	public String toString() {
		return "Car [cid=" + cid + ", brand=" + brand + ", type=" + type
				+ ", color=" + color + ", birthday=" + birthday + ", vin="
				+ vin + ", price=" + price + "]";
	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

11.5.3 插入数据

package com.cxyzxc.www.examples02;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * JDBC连接数据 实现向数据库jdbcdatabase里car表中插入一条数据
 * 
 */
public class Jdbc01PreparedStatementInsertCar {

	public static void main(String[] args) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;

		try {
			// 2、获取连接对象
			connection = DBUtils.getConnection();
			

			// 3、编写SQL语句，SQL语句中需要的数据先使用占位符?表示，然后在执行前给占位符赋值
			String sql = "INSERT INTO `car`(`brand`,`type`,`color`,`birthday`,`vin`,`price`) VALUES(?,?,?,?,?,?);";

			// 4、获取发送SQL语句对象
			preparedStatement = connection.prepareStatement(sql);

			// 创建People对象
			Car car = new Car("奥迪", "A8", "黑色", DateUtils.strDateToUtilDate("2021-12-17"), "452915723546EYBC45", 1365200);

			// 5、绑定参数，给?赋值
			preparedStatement.setString(1, car.getBrand());
			preparedStatement.setString(2, car.getType());
			preparedStatement.setString(3, car.getColor());
			// setDate(Date date)方法中需要的参数date类型是java.sql.Date类型，car对象中的Date类型是java.util.Date，需要进行转换
			preparedStatement.setDate(4, DateUtils.utilDateToSqlDate(car.getBirthday()));
			preparedStatement.setString(5, car.getVin());
			preparedStatement.setDouble(6, car.getPrice());
			
			// 6、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			int result = preparedStatement.executeUpdate();

			// 7、处理结果，如果返回的受影响行数不为0，说明数据插入成功
			if (result != 0) {
				System.out.println("数据插入成功");
			} else {
				System.out.println("数据插入失败");
			}

		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(connection, preparedStatement, null);

		}

	}

}
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
60
61

11.5.4 删除数据

package com.cxyzxc.www.examples02;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * JDBC连接数据 实现删除数据库jdbcdatabase里car表中的一条数据
 * 
 */
public class Jdbc02PreparedStatementDeleteCar {

	public static void main(String[] args) {
		Connection connection = null;
		PreparedStatement preparedStatement =null;

		try {
			
			connection = DBUtils.getConnection();
			
			// 3、编写SQL语句，SQL语句中需要的数据先使用占位符?表示，然后在执行前给占位符赋值
			String sql = "DELETE FROM `car` WHERE `cid` = ?;";

			// 4、获取发送SQL语句对象
			preparedStatement = connection.prepareStatement(sql);

			//5、绑定参数，给?赋值
			preparedStatement.setInt(1, 1003);
			
			// 6、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			int result = preparedStatement.executeUpdate();

			// 7、处理结果，如果返回的受影响行数不为0，说明数据删除成功
			if (result != 0) {
				System.out.println("数据删除成功");
			} else {
				System.out.println("数据删除失败");
			}

		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 8、释放资源，遵循“先开后关，后开先关”的原则
			DBUtils.closeAll(connection, preparedStatement, null);

		}

	}

}
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

11.5.5 修改数据

package com.cxyzxc.www.examples02;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * JDBC连接数据 实现修改数据库jdbcdatabase里car表中的一条数据
 * 
 */
public class Jdbc03PreparedStatementUpdateCar {

	public static void main(String[] args) {
		Connection connection = null;
		PreparedStatement preparedStatement =null;

		try {
			
			connection = DBUtils.getConnection();
			
			// 3、编写SQL语句，SQL语句最好是先在SQLyog里面写一遍并运行一下，保证SQL语句没有语法错误
			String sql = "UPDATE `car` SET `brand`=?,`type`=?,`color`=?,`birthday`=?,`vin`=?,`price`=? WHERE `cid`=?;";

			// 4、获取发送SQL语句对象
			preparedStatement = connection.prepareStatement(sql);
			
			//创建对象
			Car car = new Car(1002, "奔驰", "E330", "黑色", DateUtils.strDateToUtilDate("2022-01-11"), "45291579664688WD45", 415600);
			
			//5、绑定参数，给?赋值
			preparedStatement.setString(1,car.getBrand());
			preparedStatement.setString(2, car.getType());
			preparedStatement.setString(3,car.getColor());
			preparedStatement.setDate(4, DateUtils.utilDateToSqlDate(car.getBirthday()));
			preparedStatement.setString(5,car.getVin());
			preparedStatement.setDouble(6,car.getPrice());
			preparedStatement.setInt(7,car.getCid());

			// 6、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			int result = preparedStatement.executeUpdate();

			// 7、处理结果，如果返回的受影响行数不为0，说明数据修改成功
			if (result != 0) {
				System.out.println("数据修改成功");
			} else {
				System.out.println("数据修改失败");
			}

		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 8、释放资源，遵循“先开后关，后开先关”的原则
			DBUtils.closeAll(connection, preparedStatement, null);

		}

	}

}
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
60
61

11.5.5 查询数据

11.5.5.1 查询一条数据

package com.cxyzxc.www.examples02;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;

/**
 * JDBC连接数据 实现根据学号uid查询数据库jdbcdatabase里car表中的一条数据
 * 
 */
public class Jdbc04PreparedStatementSelectOneCar {

	public static void main(String[] args) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		Car car = null;

		try {
			
			connection = DBUtils.getConnection();
			
			// 3、编写SQL语句，SQL语句中需要的数据先使用占位符?表示，然后在执行前给占位符赋值
			String sql = "SELECT * FROM `car` WHERE `cid`= ?;";
			
			// 4、获取发送SQL语句对象
			preparedStatement  = connection.prepareStatement(sql);

			// 5、绑定参数，给?赋值
			preparedStatement.setInt(1, 1002);

			// 6、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			resultSet = preparedStatement.executeQuery();

			// 6、处理结果，对返回的resultSet结果集进行处理，需要将结果集中的数据取出来
			// 查询一条数据时，使用if判断resultSet.next()为true，说明resultSet结果集中有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据。
			// 查询所有数据时，使用while循环判断resultSet.next()为true，说明resultSet结果集中还有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据了。
			if (resultSet.next()) {
				// 根据记录中字段的索引获取字段数据，字段索引从1开始
				int cid = resultSet.getInt(1);
				String brand = resultSet.getString(2);
				String type = resultSet.getString(3);
				String color = resultSet.getString(4);
				Date birthday=resultSet.getDate(5);
				String vin = resultSet.getString(6);
				double price =resultSet.getDouble(7);
				
				//使用有参构造方法创建Animal对象
				car = new Car(cid, brand, type, color, birthday, vin, price);
				
				//输出对象
				System.out.println(car);
			}

		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 7、释放资源，遵循“先开后关，后开先关”的原则
			DBUtils.closeAll(connection, preparedStatement, resultSet);

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69

11.5.5.2 查询所有数据

package com.cxyzxc.www.examples02;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * JDBC连接数据 实现根据编号pid查询数据库jdbcdatabase里car表中的一条数据
 * 
 */
public class Jdbc05PreparedStatementSelectAllCar {

	public static void main(String[] args) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		Car car = null;
		List<Car> carList = new ArrayList<Car>();

		try {
			
			connection = DBUtils.getConnection();
			
			// 3、编写SQL语句，SQL语句中需要的数据先使用占位符?表示，然后在执行前给占位符赋值
			String sql = "SELECT * FROM `car`;";

			// 4、获取发送SQL语句对象
			preparedStatement = connection.prepareStatement(sql);

			// 5、绑定参数，给?赋值，这里不需要绑定参数

			// 6、执行SQL语句
			// DML语句：对于插入数据、修改数据、删除数据操作，都调用executeUpdate()方法，返回受影响的行数（int类型）
			// DQL语句：对于查询数据，调用executeQuery()方法，返回一个结果集（ResultSet类型）
			resultSet = preparedStatement.executeQuery();

			// 7、处理结果，对返回的resultSet结果集进行处理，需要将结果集中的数据取出来
			// 查询一条数据时，使用if判断resultSet.next()为true，说明resultSet结果集中有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据。
			// 查询所有数据时，使用while循环判断resultSet.next()为true，说明resultSet结果集中还有一条数据，如果resultSet.next()为false，说明resultSet结果集中没有数据了。
			while (resultSet.next()) {
				// 根据记录中字段的索引获取字段数据，字段索引从1开始
				int cid = resultSet.getInt(1);
				String brand = resultSet.getString(2);
				String type = resultSet.getString(3);
				String color = resultSet.getString(4);
				Date birthday=resultSet.getDate(5);
				String vin = resultSet.getString(6);
				double price =resultSet.getDouble(7);
				
				//使用有参构造方法创建Animal对象
				car = new Car(cid, brand, type, color, birthday, vin, price);
				//将创建的对象添加到集合中
				carList.add(car);
			}
			
			//遍历集合，输出所有People对象
			for (Car car2 : carList) {
				System.out.println(car2);
			}

		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 8、释放资源，遵循“先开后关，后开先关”的原则
			DBUtils.closeAll(connection, preparedStatement, resultSet);

		}

	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

十二、DAO数据访问对象（Data Access Object）

（1）DAO(Data Access Object) ,数据访问对象，是一个数据访问接口，数据访问：顾名思义就是与数据库打交道。夹在业务逻辑与数据库资源中间。

（2）之前代码中，业务逻辑代码和对数据库的访问操作代码全部写在一个类中，比较混乱，使用DAO实现业务逻辑与数据库访问相分离。

• 对同一张表的所有操作（增删改查，定义成方法）封装在XxxDaoImpl类中。Xxx表示实体类名
• 根据增删改查的不同功能实现具体的方法（insert、update、delete、select、selectAll）。

12.1 创建表teacher

1、创建一张教师表teacher，表的字段如下：

​ tid，教师编号，主键、自动增长。

​ name，教师姓名，字符串类型、非空。

​ age，年龄，int类型、非空。

​ bornDate，Date类型

​ email，邮箱，字符串类型，非空

​ address，住址，字符串类型，非空

CREATE TABLE IF NOT EXISTS `teacher`(
	`tid` INT PRIMARY KEY AUTO_INCREMENT,
	`name` VARCHAR(10) NOT NULL,
	`age` INT NOT NULL,
	`bornDate` DATE,
	`email` VARCHAR(30) NOT NULL,
	`address` VARCHAR(30) NOT NULL
);
1
2
3
4
5
6
7
8

2、向teacher表中插入两条数据：

INSERT INTO `teacher` VALUES(1001,'zhangsan',29,'1993-11-26','1319866976@qq.com','安徽合肥蜀山区长江西路132号');

INSERT INTO `teacher` VALUES(1002,'lisi',31,'1991-9-16','147589641@qq.com','安徽合肥新站区环城西路12号');
1
2
3

12.2 封装实体类Teacher

创建entity实体类Teacher类，封装属性，添加无参构造方法和有参构造方法，添加getXxx()/setXxx()方法

package com.cxyzxc.www.examples03;

/**
 * entity实体类Teacher类
 * 
 */
import java.util.Date;

public class Teacher {
	/** 教师编号 */
	private int tid;
	/** 姓名 */
	private String name;
	/** 年龄 */
	private int age;
	/** 出生日期 */
	private Date bornDate;
	/** 邮箱 */
	private String email;
	/** 住址 */
	private String address;

	// 无参构造方法
	public Teacher() {
		super();
	}

	// 有参构造方法
	public Teacher(String name, int age, Date bornDate, String email,
			String address) {
		super();
		this.name = name;
		this.age = age;
		this.bornDate = bornDate;
		this.email = email;
		this.address = address;
	}

	public Teacher(int tid, String name, int age, Date bornDate, String email,
			String address) {
		super();
		this.tid = tid;
		this.name = name;
		this.age = age;
		this.bornDate = bornDate;
		this.email = email;
		this.address = address;
	}

	// getXxx()/setXxx()方法
	public int getTid() {
		return tid;
	}

	public void setTid(int tid) {
		this.tid = tid;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public Date getBornDate() {
		return bornDate;
	}

	public void setBornDate(Date bornDate) {
		this.bornDate = bornDate;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	// 重写Object类中的toString()方法
	@Override
	public String toString() {
		return "tid=" + tid + ", name=" + name + ", age=" + age + ", bornDate="
				+ bornDate + ", email=" + email + ", address=" + address;
	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

12.3 编写TeacherDaoImpl类

编写TeacherDaoImpl类，提供增删改查方法，使用JDBC完成开发功能。

package com.cxyzxc.www.examples03;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 
 */
public class TeacherDaoImpl {
	/*
	 * （1）该类中提供对teacher表进行增、删、改、查单个、查所有5个方法。
	 * 
	 * （2）该类中的代码只做数据库访问操作，不做任何业务逻辑操作。
	 * 
	 * （3）该类只对数据库一张表进行操作，从而实现复用
	 */

	// 新增：向teacher表中插入一条数据（一条数据对应一个Teacher对象）,插入成功，返回一个受影响行数值（int类型）
	public int insert(Teacher teacher) {

		Connection connection = null;
		PreparedStatement preparedStatement = null;
		String sql = "insert into `teacher`(name,age,bornDate,email,address) values(?,?,?,?,?);";

		connection = DBUtils.getConnection();

		try {
			preparedStatement = connection.prepareStatement(sql);
			// 绑定参数，赋值
			preparedStatement.setString(1, teacher.getName());
			preparedStatement.setInt(2, teacher.getAge());
			// 将java.util.Date类型日期时间转换为java.sql.Date类型，然后插入到数据库中
			preparedStatement.setDate(3,DateUtils.utilDateToSqlDate(teacher.getBornDate()));
			preparedStatement.setString(4, teacher.getEmail());
			preparedStatement.setString(5, teacher.getAddress());
			// 执行SQL语句，返回受影响的行数值
			int result = preparedStatement.executeUpdate();
			// 将结果返回给调用者
			return result;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(connection, preparedStatement, null);
		}
		return 0;
	}

	// 删除：根据教师tid删除一条数据,删除成功，返回一个受影响行数值（int类型）
	public int delete(int tid) {

		Connection connection = null;
		PreparedStatement preparedStatement = null;
		String sql = "delete from teacher where tid = ?;";

		connection = DBUtils.getConnection();

		try {
			preparedStatement = connection.prepareStatement(sql);
			// 绑定参数，赋值
			preparedStatement.setInt(1, tid);
			// 执行SQL语句，返回受影响的行数值
			int result = preparedStatement.executeUpdate();
			// 将结果返回给调用者
			return result;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(connection, preparedStatement, null);
		}
		return 0;
	}

	// 修改：修改teacher表中的数据，可能对任意的一个字段进行修改，所以方法中直接传递一个对象进行修改,修改成功，返回一个受影响行数值（int类型）
	public int update(Teacher teacher) {

		Connection connection = null;
		PreparedStatement preparedStatement = null;
		String sql = "update teacher set name = ?,age = ?,bornDate = ?,email = ?,address = ? where tid = ?;";

		connection = DBUtils.getConnection();

		try {
			preparedStatement = connection.prepareStatement(sql);
			// 绑定参数，赋值
			preparedStatement.setString(1, teacher.getName());
			preparedStatement.setInt(2, teacher.getAge());
			// 将java.util.Date类型日期时间转换为java.sql.Date类型，然后插入到数据库中
			preparedStatement.setDate(3,DateUtils.utilDateToSqlDate(teacher.getBornDate()));
			preparedStatement.setString(4, teacher.getEmail());
			preparedStatement.setString(5, teacher.getAddress());
			preparedStatement.setInt(6, teacher.getTid());
			// 执行SQL语句，返回受影响的行数值
			int result = preparedStatement.executeUpdate();
			// 将结果返回给调用者
			return result;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(connection, preparedStatement, null);
		}
		return 0;
	}

	// 查询单个：根据教师tid查询一条数据，查询成功返回一个结果集（ResultSet类型）,从结果集中取出元素，封装成一个Teacher对象，将该对象返回
	public Teacher select(int tid) {

		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		Teacher teacher = null;
		String sql = "select * from teacher where tid = ?;";

		connection = DBUtils.getConnection();

		try {
			preparedStatement = connection.prepareStatement(sql);
			// 绑定参数，赋值
			preparedStatement.setInt(1, tid);
			resultSet = preparedStatement.executeQuery();
			// 处理结果集，因为是查询单个数据，所以不需要循环遍历获取数据，集合中有数据就取出来
			if (resultSet.next()) {
				teacher = new Teacher();
				int teacherid = resultSet.getInt("tid");
				String name = resultSet.getString("name");
				int age = resultSet.getInt("age");
				Date bornDate = resultSet.getDate("bornDate");
				String email = resultSet.getString("email");
				String address = resultSet.getString("address");
				// 将获取的赋值给teacher对象
				teacher.setTid(teacherid);
				teacher.setName(name);
				teacher.setAge(age);
				teacher.setBornDate(bornDate);
				teacher.setEmail(email);
				teacher.setAddress(address);
			}
			return teacher;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(connection, preparedStatement, resultSet);
		}
		return null;
	}

	// 查询所有：将teacher表中的所有数据全部查询出来，查询成功返回一个结果集（ResultSet类型）,从结果集中取出元素，封装成多个Teacher对象，将多个对象存储在集合中，返回这个集合
	public List<Teacher> selectAll() {

		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		Teacher teacher = null;
		List<Teacher> teacherList = new ArrayList<Teacher>();
		String sql = "select * from teacher;";

		connection = DBUtils.getConnection();

		try {
			preparedStatement = connection.prepareStatement(sql);
			resultSet = preparedStatement.executeQuery();
			// 查询出来多个结果，存在resultSet结果集中，遍历该结果集
			while (resultSet.next()) {
				int teacherid = resultSet.getInt("tid");
				String name = resultSet.getString("name");
				int age = resultSet.getInt("age");
				Date bornDate = resultSet.getDate("bornDate");
				String email = resultSet.getString("email");
				String address = resultSet.getString("address");
				teacher = new Teacher(teacherid, name, age, bornDate, email,address);
				teacherList.add(teacher);
			}
			return teacherList;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(connection, preparedStatement, resultSet);
		}
		return null;
	}
}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185

12.4 测试

12.4.1 测试增加数据

package com.cxyzxc.www.examples03;

public class TestTeacherDaoImpl01Insert {

	public static void main(String[] args) {
		// 创建TteacherDaoImpl类对象
		TeacherDaoImpl teacherDaoImpl = new TeacherDaoImpl();
		// 创建字符串类型的日期
		String strDate = "1992-03-22";

		// 创建Teacher类对象
		// DateUtils.strDateToUtilDate(strDate)：将字符串类型的日期时间转换为java.util.Date类型
		Teacher teacher = new Teacher("王五", 32,DateUtils.strDateToUtilDate(strDate), "1319866123@qq.com","安徽合肥蜀山区淠河路200号");
		// 将teacher对象插入到数据库teacher表中
		int result = teacherDaoImpl.insert(teacher);
		if (result == 1) {
			System.out.println("数据插入成功");
		} else {
			System.out.println("数据插入失败");
		}
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

12.4.2 测试删除数据

package com.cxyzxc.www.examples03;

public class TestTeacherDaoImpl02Delete {

	public static void main(String[] args) {
		
		// 创建TteacherDaoImpl类对象
		TeacherDaoImpl teacherDaoImpl = new TeacherDaoImpl();

		int result = teacherDaoImpl.delete(1003);
		if (result == 1) {
			System.out.println("数据删除成功");
		} else {
			System.out.println("数据删除失败");
		}
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

12.4.3 测试修改数据

package com.cxyzxc.www.examples03;

public class TestTeacherDaoImpl03Update {


	public static void main(String[] args) {
		
		// 创建TteacherDaoImpl类对象
		TeacherDaoImpl teacherDaoImpl = new TeacherDaoImpl();
		//创建字符串类型日期时间
		String strDate = "2000-03-22";
		
		// 创建Teacher类对象
		//DateUtils.strDateToUtilDate(strDate)：将字符串类型的日期时间转换为java.util.Date类型
		Teacher teacher = new Teacher(1002,"李四", 22, DateUtils.strDateToUtilDate(strDate), "1319869999@qq.com","安徽合肥蜀山区淠河路19号");
		// 将teacher对象插入到数据库teacher表中
		int result = teacherDaoImpl.update(teacher);
		if (result == 1) {
			System.out.println("数据修改成功");
		} else {
			System.out.println("数据修改败");
		}
	}

}
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

12.4.4 测试查询单个

package com.cxyzxc.www.examples03;

public class TestTeacherDaoImpl04SelectOne {

	public static void main(String[] args) {
		
		// 创建TteacherDaoImpl类对象
		TeacherDaoImpl teacherDaoImpl = new TeacherDaoImpl();

		Teacher teacher = teacherDaoImpl.select(1001);
		if (teacher != null) {
			System.out.println(teacher);
		} else {
			System.out.println("没有这个老师");
		}
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

12.4.5 测试查询所有

package com.cxyzxc.www.examples03;

import java.util.List;

public class TestTeacherDaoImpl05SelectAll {

	public static void main(String[] args) {
		
		// 创建TteacherDaoImpl类对象
		TeacherDaoImpl teacherDaoImpl = new TeacherDaoImpl();

		List<Teacher> teacherList = teacherDaoImpl.selectAll();
		// 遍历teacherList集合
		for (Teacher teacher : teacherList) {
			System.out.println(teacher);
		}
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

十三、Service业务逻辑层

13.1 什么是业务

（1）业务即用户完成的一个功能，可以有一个或者多个Dao的调用组成。（软件所提供的一个功能都叫业务）。

（2）你去银行取钱是一个业务，存钱是另一个业务，生活中你做的任何一件事都可以看成是一个业务。有的业务只需要一步就能完成，有的业务需要多个步骤才能完成。

13.2 service开发流程（注册账号业务）

13.2.1 业务需求和逻辑

（1）业务需求：

• 注册一个employee账户，存入employee表中

（2）业务逻辑：

1. 首先在数据库中查询你要注册的账号是否存在（根据身份证号码查询，身份证号码具有唯一性）
2. 如果查询不到你想要注册的账号，则将你注册的账号存入employee表中
3. 如果查询到了你要注册的账号名称，则提示账号已存在，不能注册

13.2.2 业务实现步骤

1、创建表employee

CREATE TABLE IF NOT EXISTS `employee`(
	`id` INT PRIMARY KEY AUTO_INCREMENT,
	`name` VARCHAR(20) NOT NULL,
	`age` INT NOT NULL,
	`gender` VARCHAR(3),
	`bornDate` DATE NOT NULL,
	`identityCard` VARCHAR(18) UNIQUE NOT NULL,
	`phone` VARCHAR(11) NOT NULL,
	`email` VARCHAR(20) NOT NULL,
	`address` VARCHAR(30) NOT NULL
);
1
2
3
4
5
6
7
8
9
10
11

2、向employee表中插入数据

INSERT INTO `employee` VALUES(1001,'zhangsan',24,'男','1998-12-16','340825199812161316','13845687890','1319866912@qq.com','安徽合肥蜀山区');

INSERT INTO `employee` VALUES(1002,'lisi',25,'男','1997-12-26','340825199712261396','13845682233','1396548732@qq.com','安徽合肥瑶海区');
1
2
3

3、封装实体类Employee

package com.cxyzxc.www.examples04;

import java.util.Date;
/**
 * entity实体类Employee
 * 
 */
public class Employee {
	/** 员工编号 */
	private int id;
	/** 姓名 */
	private String name;
	/** 年龄 */
	private int age;
	/** 性别 */
	private String gender;
	/** 出生日期 */
	private Date bornDate;
	/** 身份证号码 */
	private String identityCard;
	/** 手机号码 */
	private String phone;
	/** 邮箱 */
	private String email;
	/** 住址 */
	private String address;

	// 无参构造方法
	public Employee() {
		super();
	}

	// 有参构造方法
	public Employee(String name, int age, String gender, Date bornDate,
			String identityCard, String phone, String email, String address) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
		this.bornDate = bornDate;
		this.identityCard = identityCard;
		this.phone = phone;
		this.email = email;
		this.address = address;
	}

	public Employee(int id, String name, int age, String gender, Date bornDate,
			String identityCard, String phone, String email, String address) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
		this.gender = gender;
		this.bornDate = bornDate;
		this.identityCard = identityCard;
		this.phone = phone;
		this.email = email;
		this.address = address;
	}

	// getXxx()/setXxx()方法
	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getGender() {
		return gender;
	}

	public void setGender(String gender) {
		this.gender = gender;
	}

	public Date getBornDate() {
		return bornDate;
	}

	public void setBornDate(Date bornDate) {
		this.bornDate = bornDate;
	}

	public String getIdentityCard() {
		return identityCard;
	}

	public void setIdentityCard(String identityCard) {
		this.identityCard = identityCard;
	}

	public String getPhone() {
		return phone;
	}

	public void setPhone(String phone) {
		this.phone = phone;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	// 重写Object类中的toString()方法
	@Override
	public String toString() {
		return "id=" + id + ", name=" + name + ", age=" + age + ", gender="
				+ gender + ", bornDate=" + bornDate + ", identityCard="
				+ identityCard + ", phone=" + phone + ", email=" + email
				+ ", address=" + address;
	}
}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

4、编写EmployeeDaoImpl类（Dao层代码）

package com.cxyzxc.www.examples04;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class EmployeeDaoImpl {

	/*
	 * （1）该类中提供对teacher表进行增、删、改、查单个、查所有5个方法。
	 * 
	 * （2）该类中的代码只做数据库访问操作，不做任何业务逻辑操作。
	 * 
	 * （3）该类只对数据库一张表进行操作，从而实现复用
	 */

	// 新增：向employee表中插入一条数据（一条数据对应一个Employee对象）,插入成功，返回一个受影响行数值（int类型）
	public int insert(Employee employee) {

		Connection connection = null;
		PreparedStatement preparedStatement = null;
		String sql = "insert into `employee`(name,age,gender,bornDate,identityCard,phone,email,address) values(?,?,?,?,?,?,?,?);";

		connection = DBUtils.getConnection();

		try {
			preparedStatement = connection.prepareStatement(sql);
			// 绑定参数，赋值
			preparedStatement.setString(1, employee.getName());
			preparedStatement.setInt(2, employee.getAge());
			preparedStatement.setString(3, employee.getGender());
			// 将java.util.Date类型日期时间转换为java.sql.Date类型，然后插入到数据库中
			preparedStatement.setDate(4,DateUtils.utilDateToSqlDate(employee.getBornDate()));
			preparedStatement.setString(5, employee.getIdentityCard());
			preparedStatement.setString(6, employee.getPhone());
			preparedStatement.setString(7, employee.getEmail());
			preparedStatement.setString(8, employee.getAddress());
			// 执行SQL语句，返回受影响的行数值
			int result = preparedStatement.executeUpdate();
			// 将结果返回给调用者
			return result;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(connection, preparedStatement, null);
		}
		return 0;
	}

	// 删除：根据员工id删除一条数据,删除成功，返回一个受影响行数值（int类型）
	public int delete(int id) {

		Connection connection = null;
		PreparedStatement preparedStatement = null;
		String sql = "delete from employee where id = ?;";

		connection = DBUtils.getConnection();

		try {
			preparedStatement = connection.prepareStatement(sql);
			// 绑定参数，赋值
			preparedStatement.setInt(1, id);
			// 执行SQL语句，返回受影响的行数值
			int result = preparedStatement.executeUpdate();
			// 将结果返回给调用者
			return result;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(connection, preparedStatement, null);
		}
		return 0;
	}

	// 修改：修改employee表中的数据，可能对任意的一个字段进行修改，所以方法中直接传递一个对象进行修改,修改成功，返回一个受影响行数值（int类型）
	public int update(Employee employee) {

		Connection connection = null;
		PreparedStatement preparedStatement = null;
		String sql = "update employee set name = ?,age = ?,gender = ?,bornDate = ?,identityCard = ?,phone = ?,email = ?,address = ? where id = ?;";

		connection = DBUtils.getConnection();

		try {
			preparedStatement = connection.prepareStatement(sql);
			// 绑定参数，赋值
			// 绑定参数，赋值
			preparedStatement.setString(1, employee.getName());
			preparedStatement.setInt(2, employee.getAge());
			preparedStatement.setString(3, employee.getGender());
			// 将java.util.Date类型日期时间转换为java.sql.Date类型，然后插入到数据库中
			preparedStatement.setDate(4,DateUtils.utilDateToSqlDate(employee.getBornDate()));
			preparedStatement.setString(5, employee.getIdentityCard());
			preparedStatement.setString(6, employee.getPhone());
			preparedStatement.setString(7, employee.getEmail());
			preparedStatement.setString(8, employee.getAddress());
			preparedStatement.setInt(9, employee.getId());
			// 执行SQL语句，返回受影响的行数值
			int result = preparedStatement.executeUpdate();
			// 将结果返回给调用者
			return result;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(connection, preparedStatement, null);
		}
		return 0;
	}

	// 查询单个：根据员工id查询一条数据，查询成功返回一个结果集（ResultSet类型）,从结果集中取出元素，封装成一个Employee对象，将该对象返回
	public Employee select(int id) {

		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		Employee employee = null;
		String sql = "select * from employee where id = ?;";

		connection = DBUtils.getConnection();

		try {
			preparedStatement = connection.prepareStatement(sql);
			// 绑定参数，赋值
			preparedStatement.setInt(1, id);
			resultSet = preparedStatement.executeQuery();
			// 处理结果集，因为是查询单个数据，所以不需要循环遍历获取数据，集合中有数据就取出来
			if (resultSet.next()) {
				employee = new Employee();
				int employeeid = resultSet.getInt("id");
				String name = resultSet.getString("name");
				int age = resultSet.getInt("age");
				String gender = resultSet.getString("gender");
				Date bornDate = resultSet.getDate("bornDate");
				String identityCard = resultSet.getString("identityCard");
				String phone = resultSet.getString("phone");
				String email = resultSet.getString("email");
				String address = resultSet.getString("address");
				// 将获取的赋值给teacher对象
				employee.setId(employeeid);
				employee.setName(name);
				employee.setAge(age);
				employee.setGender(gender);
				employee.setBornDate(bornDate);
				employee.setIdentityCard(identityCard);
				employee.setPhone(phone);
				employee.setEmail(email);
				employee.setAddress(address);
			}
			return employee;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(connection, preparedStatement, null);
		}
		return null;
	}

	// 查询单个：根据员工身份证号码查询一条数据，查询成功返回一个结果集（ResultSet类型）,从结果集中取出元素，封装成一个Employee对象，将该对象返回
	public Employee select(String identityCard) {

		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		Employee employee = null;
		String sql = "select * from employee where identityCard = ?;";

		connection = DBUtils.getConnection();

		try {
			preparedStatement = connection.prepareStatement(sql);
			// 绑定参数，赋值
			preparedStatement.setString(1, identityCard);
			resultSet = preparedStatement.executeQuery();
			// 处理结果集，因为是查询单个数据，所以不需要循环遍历获取数据，集合中有数据就取出来
			if (resultSet.next()) {
				employee = new Employee();
				int employeeid = resultSet.getInt("id");
				String name = resultSet.getString("name");
				int age = resultSet.getInt("age");
				String gender = resultSet.getString("gender");
				Date bornDate = resultSet.getDate("bornDate");
				String idCard = resultSet.getString("identityCard");
				String phone = resultSet.getString("phone");
				String email = resultSet.getString("email");
				String address = resultSet.getString("address");
				// 将获取的赋值给teacher对象
				employee.setId(employeeid);
				employee.setName(name);
				employee.setAge(age);
				employee.setGender(gender);
				employee.setBornDate(bornDate);
				employee.setIdentityCard(idCard);
				employee.setPhone(phone);
				employee.setEmail(email);
				employee.setAddress(address);
			}
			return employee;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(connection, preparedStatement, null);
		}
		return null;
	}

	// 查询所有：将employee表中的所有数据全部查询出来，查询成功返回一个结果集（ResultSet类型）,从结果集中取出元素，封装成多个Employee对象，将多个对象存储在集合中，返回这个集合
	public List<Employee> selectAll() {

		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		Employee employee = null;
		List<Employee> employeeList = new ArrayList<Employee>();
		String sql = "select * from employee;";

		connection = DBUtils.getConnection();

		try {
			preparedStatement = connection.prepareStatement(sql);
			resultSet = preparedStatement.executeQuery();
			// 查询出来多个结果，存在resultSet结果集中，遍历该结果集
			while (resultSet.next()) {
				int employeeid = resultSet.getInt("id");
				String name = resultSet.getString("name");
				int age = resultSet.getInt("age");
				String gender = resultSet.getString("gender");
				Date bornDate = resultSet.getDate("bornDate");
				String identityCard = resultSet.getString("identityCard");
				String phone = resultSet.getString("phone");
				String email = resultSet.getString("email");
				String address = resultSet.getString("address");
				employee = new Employee(employeeid, name, age, gender,bornDate, identityCard, phone, email, address);
				employeeList.add(employee);
			}
			return employeeList;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(connection, preparedStatement, null);
		}
		return null;
	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248

5、编写EmployeeServiceImpl类（业务层代码）

package com.cxyzxc.www.examples04;

public class EmployeeServiceImpl {

	/*
	 * 注册账号的业务逻辑： 
	 * 		1、查询你要注册的员工是否存在（根据身份证号码进行查询） 
	 * 
	 * 		2、如果要注册的员工不存在，就注册账号
	 * 
	 * 		3、如果注册的员工已经存在，就返回已经注册该员工
	 */
	public void register(Employee employee) {

		EmployeeDaoImpl employeeDaoImpl = new EmployeeDaoImpl();

		// 1、查询你要注册的员工是否存在
		Employee emp = employeeDaoImpl.select(employee.getIdentityCard());

		// 2、如果要注册的员工不存在（emp为null），就注册账号
		if (emp == null) {
			employeeDaoImpl.insert(employee);
			System.out.println("员工注册成功（数据插入成功）");
		} else {
			System.out.println("该员工已经注册（数据插入失败）");
		}
	}
}
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

6、测试注册业务

package com.cxyzxc.www.examples04;

public class TestRegister {

	public static void main(String[] args) {

		EmployeeServiceImpl employeeServiceImpl = new EmployeeServiceImpl();

		Employee employee = new Employee("赵六", 30, "男",DateUtils.strDateToUtilDate("1992-11-29"),"340825199211291123", "13877884455", "13877884455@qq.com","安徽合肥肥西");

		employeeServiceImpl.register(employee);

	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

13.3 Service开发流程（转账业务）

13.3.1 业务需求和逻辑

（1）业务需求：

• 一个账户向另一个账户转账

（2）业务逻辑：

1. 首先在数据库中查询转账账号是否存在
2. 然后在数据库中查询转账账号密码是否存在
3. 再验证转账账号的余额是否足够转账
4. 再验证收款账号是否存在
5. 执行转账操作，转账账号余额减少，收款账号余额增加（减少的金额与增加的金额相等）

13.3.2 业务实现步骤

1、创建表account

CREATE TABLE IF NOT EXISTS `account`(
`cardNo` VARCHAR(20) PRIMARY KEY COMMENT '卡号',
`password` VARCHAR(20) NOT NULL COMMENT '密码',
`name` VARCHAR(20) NOT NULL COMMENT '名称',
`balance` DOUBLE NOT NULL COMMENT '账户余额'
);
1
2
3
4
5
6

2、向account表中插入数据

INSERT INTO account VALUES('6001','123456','zhangsan',10000);
INSERT INTO account VALUES('6002','123456','lisi',5000);
1
2

3、封装实体类Account

package com.cxyzxc.www.examples05;

/**
 * entity实体类Account类
 * 
 */
public class Account {
	/** 账号 */
	private String cardNo;
	/** 密码 */
	private String password;
	/** 用户名 */
	private String name;
	/** 账户余额 */
	private double balance;

	// 无参构造方法
	public Account() {
		super();
	}

	// 有参构造方法
	public Account(String cardNo, String password, String name, double balance) {
		super();
		this.cardNo = cardNo;
		this.password = password;
		this.name = name;
		this.balance = balance;
	}

	// getXxx()/setXxx()方法
	public String getCardNo() {
		return cardNo;
	}

	public void setCardNo(String cardNo) {
		this.cardNo = cardNo;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public double getBalance() {
		return balance;
	}

	public void setBalance(double balance) {
		this.balance = balance;
	}

	// 重写Object类中的toString()方法
	@Override
	public String toString() {
		return "cardNo=" + cardNo + ", password=" + password + ", name=" + name
				+ ", balance=" + balance;
	}
}
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
60
61
62
63
64
65
66
67
68
69
70

4、 编写AccountDaoImpl类（Dao层代码）

package com.cxyzxc.www.examples05;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class AccountDaoImpl {

	// 新增：插入一个Account对象到数据库中
	public int insert(Account account) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;

		connection = DBUtils.getConnection();

		String sql = "insert into account values(?,?,?,?)";

		try {
			preparedStatement = connection.prepareStatement(sql);

			// 绑定参数
			preparedStatement.setString(1, account.getCardNo());
			preparedStatement.setString(2, account.getPassword());
			preparedStatement.setString(3, account.getName());
			preparedStatement.setDouble(4, account.getBalance());

			// 执行SQL
			int result = preparedStatement.executeUpdate();
			return result;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(connection, preparedStatement, null);
		}
		return 0;
	}

	// 删除：根据卡号，删除账号
	public int delete(String cardNo) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;

		connection = DBUtils.getConnection();

		String sql = "delete from account where cardNo = ?;";
		try {
			preparedStatement = connection.prepareStatement(sql);
			// 绑定参数
			preparedStatement.setString(1, cardNo);
			// 执行SQL
			int result = preparedStatement.executeUpdate();
			return result;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(connection, preparedStatement, null);
		}

		return 0;
	}

	// 修改
	public int update(Account account) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;

		connection = DBUtils.getConnection();

		String sql = "update account set password = ?,name = ?,balance = ? where cardNo=?;";

		try {
			preparedStatement = connection.prepareStatement(sql);

			// 绑定参数
			preparedStatement.setString(1, account.getPassword());
			preparedStatement.setString(2, account.getName());
			preparedStatement.setDouble(3, account.getBalance());
			preparedStatement.setString(4, account.getCardNo());

			// 执行SQL
			int result = preparedStatement.executeUpdate();
			return result;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(connection, preparedStatement, null);
		}
		return 0;
	}

	// 查询单个
	public Account select(String cardNo) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		Account account = null;

		connection = DBUtils.getConnection();

		String sql = "select * from account where cardNo = ?";

		try {
			preparedStatement = connection.prepareStatement(sql);

			// 绑定参数
			preparedStatement.setString(1, cardNo);

			// 执行SQL
			resultSet = preparedStatement.executeQuery();

			if (resultSet.next()) {
				String cardNumber = resultSet.getString("cardNo");
				String password = resultSet.getString("password");
				String name = resultSet.getString("name");
				double balance = resultSet.getDouble("balance");

				account = new Account(cardNumber, password, name, balance);
			}

			return account;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(connection, preparedStatement, resultSet);
		}
		return null;
	}

	// 查询所有
	public List<Account> selectAll() {
		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		Account account = null;
		List<Account> accountList = new ArrayList<Account>();

		connection = DBUtils.getConnection();

		String sql = "select * from account;";

		try {
			preparedStatement = connection.prepareStatement(sql);

			// 执行SQL
			resultSet = preparedStatement.executeQuery();

			while (resultSet.next()) {
				String cardNumber = resultSet.getString("cardNo");
				String password = resultSet.getString("password");
				String name = resultSet.getString("name");
				double balance = resultSet.getDouble("balance");

				account = new Account(cardNumber, password, name, balance);
				accountList.add(account);
			}
			return accountList;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(connection, preparedStatement, resultSet);
		}
		return null;
	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168

5、 编写AccountServiceImpl类（业务层代码）

package com.cxyzxc.www.examples05;

public class AccountServiceImpl {

	/**
	 * 转账业务
	 * 
	 * @param fromNo
	 *            转账人账号
	 * @param password
	 *            转账人账号密码
	 * @param toNo
	 *            收款人账号
	 * @param money
	 *            转账金额
	 */
	public void transfer(String fromNo, String password, String toNo,
			double money) {
		AccountDaoImpl accountDaoImpl = new AccountDaoImpl();

		try {
			// 1.验证fromNo账号是否存在
			Account fromAccount = accountDaoImpl.select(fromNo);
			if (fromAccount == null) {
				throw new RuntimeException("卡号不存在");
			}

			// 2.验证fromNo的密码是否正确
			if (!fromAccount.getPassword().equals(password)) {
				throw new RuntimeException("密码错误");
			}

			// 3.验证余额是否充足
			if (fromAccount.getBalance() < money) {
				throw new RuntimeException("余额不足");
			}

			// 4.验证toNo账号是否存在
			Account toAccount = accountDaoImpl.select(toNo);
			if (toAccount == null) {
				throw new RuntimeException("对方卡号不存在");
			}
			// 5.减少fromNo账号的余额
			fromAccount.setBalance(fromAccount.getBalance() - money);
			accountDaoImpl.update(fromAccount);

			// 6.增加toNo账号的余额
			toAccount.setBalance(toAccount.getBalance() + money);
			accountDaoImpl.update(toAccount);
			System.out.println("转账成功");
		} catch (Exception e) {
			System.out.println("转账失败");
			e.printStackTrace();
		}
	}
}
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

6、 测试转账业务

package com.cxyzxc.www.examples05;

public class TestTransfer {

	public static void main(String[] args) {

		AccountServiceImpl AccountServiceImpl = new AccountServiceImpl();

		AccountServiceImpl.transfer("6001", "123456", "6002", 2000);

	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13

十四、事务

在JDBC中，获得Connection对象来处理事务–提交或回滚事务–关闭连接。其事务策略是：

• connection.setAutoCommit(false)：true等价于1，false等于0
• connection.commit()：手动提交事务
• connection.rollback()：手动回滚事务

14.1 service层控制事务

package com.cxyzxc.www.examples06;

import java.sql.Connection;
import java.sql.SQLException;

public class AccountServiceImpl {

	/**
	 * 转账业务
	 * 
	 * @param fromNo
	 *            转账人账号
	 * @param password
	 *            转账人账号密码
	 * @param toNo
	 *            收款人账号
	 * @param money
	 *            转账金额
	 */
	public String transfer(String fromNo, String password, String toNo,
			double money) {
		String result = "转账失败";
		AccountDaoImpl accountDaoImpl = new AccountDaoImpl();

		// 创建一个连接对象
		Connection connection = null;

		try {
			// 获取连接对象
			connection = DBUtils.getConnection();
			// 开启事务，关闭事务的自动提交，改为手动提交
			connection.setAutoCommit(false);
			// 1.验证fromNo账号是否存在
			Account fromAccount = accountDaoImpl.select(fromNo);
			if (fromAccount == null) {
				throw new RuntimeException("卡号不存在");
			}

			// 2.验证fromNo的密码是否正确
			if (!fromAccount.getPassword().equals(password)) {
				throw new RuntimeException("密码错误");
			}

			// 3.验证余额是否充足
			if (fromAccount.getBalance() < money) {
				throw new RuntimeException("余额不足");
			}

			// 4.验证toNo账号是否存在
			Account toAccount = accountDaoImpl.select(toNo);
			if (toAccount == null) {
				throw new RuntimeException("对方卡号不存在");
			}
			// 5.减少fromNo账号的余额
			fromAccount.setBalance(fromAccount.getBalance() - money);
			accountDaoImpl.update(fromAccount);

			// 程序出现异常
			@SuppressWarnings("unused")
			int num = 10 / 0;

			// 6.增加toNo账号的余额
			toAccount.setBalance(toAccount.getBalance() + money);
			accountDaoImpl.update(toAccount);
			// 代码执行到这里，说明转账成功，提交事务
			connection.commit();
			result = "转账成功";
			return result;
		} catch (Exception e) {
			e.printStackTrace();
			try {
				// 出现异常，回滚整个事务
				System.out.println("出现异常，回滚整个事务，转账失败");
				connection.rollback();
			} catch (SQLException e1) {
				e1.printStackTrace();
			}
		} finally {
			DBUtils.closeAll(connection, null, null);
		}
		return result;
	}
}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

14.2 service层控制事务失败的原因

执行这个代码，观察account表中的数据发现，当程序出现异常，转账账号余额减少了，但是收款账户余额没有增加，事务控制失败了。失败的原因是：

• AccountServiceImpl类中的connection连接对象与AccountDaoImpl类中给各个方法里的connection连接对象是不同的connection连接对象。
• AccountServiceImpl类中的connection连接对象控制事务，只能控制AccountServiceImpl类中的事务，不能控制该类之外的类里的事务

14.3 解决方案一：传递Connection

为了解决AccountServiceImpl类中的connection连接对象与AccountDaoImpl类中给各个方法里的connection连接对象是不同步的问题，可以将Connection对象通过service传递给AccountDaoImpl类中的各个方法

14.3.1 AccountDaoImpl类代码

AccountDaoImpl类中的每个方法参数列表里都要添加一个Connection类型的参数

package com.cxyzxc.www.examples07;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class AccountDaoImpl {


	// 新增：插入一个Account对象到数据库中
	public int insert(Account account,Connection connection) {
		PreparedStatement preparedStatement = null;

		String sql = "insert into account values(?,?,?,?)";

		try {
			preparedStatement = connection.prepareStatement(sql);

			// 绑定参数
			preparedStatement.setString(1, account.getCardNo());
			preparedStatement.setString(2, account.getPassword());
			preparedStatement.setString(3, account.getName());
			preparedStatement.setDouble(4, account.getBalance());

			// 执行SQL
			int result = preparedStatement.executeUpdate();
			return result;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally{
			DBUtils.closeAll(null, preparedStatement, null);
		}
		return 0;
	}

	// 删除：根据卡号，删除账号
	public int delete(String cardNo,Connection connection) {
		PreparedStatement preparedStatement = null;

		String sql = "delete from account where cardNo = ?;";
		try {
			preparedStatement = connection.prepareStatement(sql);
			// 绑定参数
			preparedStatement.setString(1, cardNo);
			// 执行SQL
			int result = preparedStatement.executeUpdate();
			return result;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally{
			DBUtils.closeAll(null, preparedStatement, null);
		}
		return 0;
	}

	// 修改
	public int update(Account account,Connection connection) {
		PreparedStatement preparedStatement = null;

		String sql = "update account set password = ?,name = ?,balance = ? where cardNo=?;";

		try {
			preparedStatement = connection.prepareStatement(sql);

			// 绑定参数
			preparedStatement.setString(1, account.getPassword());
			preparedStatement.setString(2, account.getName());
			preparedStatement.setDouble(3, account.getBalance());
			preparedStatement.setString(4, account.getCardNo());

			// 执行SQL
			int result = preparedStatement.executeUpdate();
			return result;
		} catch (SQLException e) {
			e.printStackTrace();
		}finally{
			DBUtils.closeAll(null, preparedStatement, null);
		}
		return 0;
	}

	// 查询单个
	public Account select(String cardNo,Connection connection) {
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		Account account = null;


		String sql = "select * from account where cardNo = ?";

		try {
			preparedStatement = connection.prepareStatement(sql);

			// 绑定参数
			preparedStatement.setString(1, cardNo);

			// 执行SQL
			resultSet = preparedStatement.executeQuery();

			if (resultSet.next()) {
				String cardNumber = resultSet.getString("cardNo");
				String password = resultSet.getString("password");
				String name = resultSet.getString("name");
				double balance = resultSet.getDouble("balance");

				account = new Account(cardNumber, password, name, balance);
			}

			return account;
		} catch (SQLException e) {
			e.printStackTrace();
		}finally{
			DBUtils.closeAll(null, preparedStatement, resultSet);
		}
		return null;
	}

	// 查询所有
	public List<Account> selectAll(Connection connection) {
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		Account account = null;
		List<Account> accountList = new ArrayList<Account>();

		String sql = "select * from account;";

		try {
			preparedStatement = connection.prepareStatement(sql);

			// 执行SQL
			resultSet = preparedStatement.executeQuery();

			while (resultSet.next()) {
				String cardNumber = resultSet.getString("cardNo");
				String password = resultSet.getString("password");
				String name = resultSet.getString("name");
				double balance = resultSet.getDouble("balance");

				account = new Account(cardNumber, password, name, balance);
				accountList.add(account);
			}
			return accountList;
		} catch (SQLException e) {
			e.printStackTrace();
		}finally{
			DBUtils.closeAll(null, preparedStatement, resultSet);
		}
		return null;
	}
}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

14.3.2 AccountServiceImpl类代码

package com.cxyzxc.www.examples07;

import java.sql.Connection;
import java.sql.SQLException;

public class AccountServiceImpl {

	/**
	 * 转账业务
	 * 
	 * @param fromNo
	 *            转账人账号
	 * @param password
	 *            转账人账号密码
	 * @param toNo
	 *            收款人账号
	 * @param money
	 *            转账金额
	 */
	public String transfer(String fromNo, String password, String toNo,
			double money) {
		String result = "转账失败";
		AccountDaoImpl accountDaoImpl = new AccountDaoImpl();

		// 创建一个连接对象
		Connection connection = null;

		try {
			// 获取连接对象
			connection = DBUtils.getConnection();
			// 开启事务，关闭事务的自动提交，改为手动提交
			connection.setAutoCommit(false);
			// 1.验证fromNo账号是否存在
			Account fromAccount = accountDaoImpl.select(fromNo, connection);
			if (fromAccount == null) {
				throw new RuntimeException("卡号不存在");
			}

			// 2.验证fromNo的密码是否正确
			if (!fromAccount.getPassword().equals(password)) {
				throw new RuntimeException("密码错误");
			}

			// 3.验证余额是否充足
			if (fromAccount.getBalance() < money) {
				throw new RuntimeException("余额不足");
			}

			// 4.验证toNo账号是否存在
			Account toAccount = accountDaoImpl.select(toNo, connection);
			if (toAccount == null) {
				throw new RuntimeException("对方卡号不存在");
			}
			// 5.减少fromNo账号的余额
			fromAccount.setBalance(fromAccount.getBalance() - money);
			accountDaoImpl.update(fromAccount, connection);

			// 程序出现异常
			@SuppressWarnings("unused")
			int num = 10 / 0;

			// 6.增加toNo账号的余额
			toAccount.setBalance(toAccount.getBalance() + money);
			accountDaoImpl.update(toAccount, connection);
			// 代码执行到这里，说明转账成功，提交事务
			connection.commit();
			result = "转账成功";
			return result;
		} catch (Exception e) {
			e.printStackTrace();
			try {
				// 出现异常，回滚整个事务
				System.out.println("出现异常，回滚整个事务，转账失败");
				connection.rollback();
			} catch (SQLException e1) {
				e1.printStackTrace();
			}
		} finally {
			DBUtils.closeAll(connection, null, null);
		}
		return result;
	}
}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

14.3.3 测试

测试发现，这种方法可以解决service层控制事务失败的问题。

14.3.4 解决方案的弊端

（1）如果使用传递Connection，更容易造成接口污染（BadSmell）。

（2）定义接口是为了更容易更换实现，而将Connection定义在接口中（XxxDao接口，XXXDaoImpl实现XxxDao接口）中，会造成污染当前接口。因为在当前代码中连接对象叫Connection，而在其它数据库连接框架中，连接对象不叫Connection（Mybatis框架中数据库连接对象叫SqlSession，Hibernate框架中数据库连接对象叫session），这时候，你需要重新定义接口，重新传递连接对象。

14.4 解决方案二：ThreadLocal

（1）在整个线程中（单线程），存储一个共享值（Connection对象）。

（2）线程类中拥有一个类似Map的属性（），以键值对的结构<ThreadLocal对象,值>存储数据。

14.4.1 ThreadLocal应用

一个线程中所有的操作共享一个ThreadLocal，ThreadLocal里存储的是Connection连接对象，在整个操作流程中任何一个操作环节都可以设置或者获取值。

14.4.2 ThreadLocal代码实现

在DBUtils类中，将当前Connection对象添加到ThreadLocal中。其它类代码保持不变。

package com.cxyzxc.www.examples08;

import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

/**
 * 跨平台方案 注册驱动 获取连接 释放资源
 * 
 */
public class DBUtils {
	// 读取配置文件的Map
	private static final Properties PROPERTIES = new Properties();
	// 声明一个ThreadLocal<Connection>对象用来存储数据库连接对象
	private static ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();

	static {
		// 通过复用本类自带流，读取配置文件中的数据
		InputStream is = DBUtils.class.getResourceAsStream("/db.properties");

		try {
			// 通过prop对象将流中的配置信息分隔成键值对,将配置文件内容加载到properties集合
			PROPERTIES.load(is);
			// 注册驱动，通过driverName的键获取对应的值（com.mysql.jdbc.Driver）
			Class.forName(PROPERTIES.getProperty("driver"));
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

	// 获取连接对象
	public static Connection getConnection() {
		// 将当前线程中绑定的Connection对象赋值给connection变量
		Connection connection = threadLocal.get();
		try {
			// 如果连接对象为null，则创建一个连接对象
			if (connection == null) {
				connection = DriverManager.getConnection(
						PROPERTIES.getProperty("url"),
						PROPERTIES.getProperty("username"),
						PROPERTIES.getProperty("password"));
				// 将创建的连接对象存储到当前线程中共享
				threadLocal.set(connection);
			}

		} catch (SQLException e) {
			e.printStackTrace();
		}
		return connection;
	}

	// 释放所有资源
	public static void closeAll(Connection connection, Statement statement,
			ResultSet resultSet) {
		try {
			if (resultSet != null) {
				resultSet.close();
			}
			if (statement != null) {
				statement.close();
			}
			if (connection != null) {
				connection.close();
				// 将connection从threadLocal中移除
				threadLocal.remove();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

14.4.3 AccountDaoImpl类代码

package com.cxyzxc.www.examples08;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class AccountDaoImpl {

	// 新增：插入一个Account对象到数据库中
	public int insert(Account account) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;

		connection = DBUtils.getConnection();

		String sql = "insert into account values(?,?,?,?)";

		try {
			preparedStatement = connection.prepareStatement(sql);

			// 绑定参数
			preparedStatement.setString(1, account.getCardNo());
			preparedStatement.setString(2, account.getPassword());
			preparedStatement.setString(3, account.getName());
			preparedStatement.setDouble(4, account.getBalance());

			// 执行SQL
			int result = preparedStatement.executeUpdate();
			return result;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(null, preparedStatement, null);
		}
		return 0;
	}

	// 删除：根据卡号，删除账号
	public int delete(String cardNo) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;

		connection = DBUtils.getConnection();

		String sql = "delete from account where cardNo = ?;";
		try {
			preparedStatement = connection.prepareStatement(sql);
			// 绑定参数
			preparedStatement.setString(1, cardNo);
			// 执行SQL
			int result = preparedStatement.executeUpdate();
			return result;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(null, preparedStatement, null);
		}

		return 0;
	}

	// 修改
	public int update(Account account) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;

		connection = DBUtils.getConnection();

		String sql = "update account set password = ?,name = ?,balance = ? where cardNo=?;";

		try {
			preparedStatement = connection.prepareStatement(sql);

			// 绑定参数
			preparedStatement.setString(1, account.getPassword());
			preparedStatement.setString(2, account.getName());
			preparedStatement.setDouble(3, account.getBalance());
			preparedStatement.setString(4, account.getCardNo());

			// 执行SQL
			int result = preparedStatement.executeUpdate();
			return result;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(null, preparedStatement, null);
		}
		return 0;
	}

	// 查询单个
	public Account select(String cardNo) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		Account account = null;

		connection = DBUtils.getConnection();

		String sql = "select * from account where cardNo = ?";

		try {
			preparedStatement = connection.prepareStatement(sql);

			// 绑定参数
			preparedStatement.setString(1, cardNo);

			// 执行SQL
			resultSet = preparedStatement.executeQuery();

			if (resultSet.next()) {
				String cardNumber = resultSet.getString("cardNo");
				String password = resultSet.getString("password");
				String name = resultSet.getString("name");
				double balance = resultSet.getDouble("balance");

				account = new Account(cardNumber, password, name, balance);
			}

			return account;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(null, preparedStatement, resultSet);
		}
		return null;
	}

	// 查询所有
	public List<Account> selectAll() {
		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		Account account = null;
		List<Account> accountList = new ArrayList<Account>();

		connection = DBUtils.getConnection();

		String sql = "select * from account;";

		try {
			preparedStatement = connection.prepareStatement(sql);

			// 执行SQL
			resultSet = preparedStatement.executeQuery();

			while (resultSet.next()) {
				String cardNumber = resultSet.getString("cardNo");
				String password = resultSet.getString("password");
				String name = resultSet.getString("name");
				double balance = resultSet.getDouble("balance");

				account = new Account(cardNumber, password, name, balance);
				accountList.add(account);
			}
			return accountList;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(null, preparedStatement, resultSet);
		}
		return null;
	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168

14.4.4 AccountServiceImpl类代码

package com.cxyzxc.www.examples08;

import java.sql.Connection;
import java.sql.SQLException;

public class AccountServiceImpl {

	/**
	 * 转账业务
	 * 
	 * @param fromNo
	 *            转账人账号
	 * @param password
	 *            转账人账号密码
	 * @param toNo
	 *            收款人账号
	 * @param money
	 *            转账金额
	 */
	public String transfer(String fromNo, String password, String toNo,
			double money) {
		String result = "转账失败";
		AccountDaoImpl accountDaoImpl = new AccountDaoImpl();

		// 创建一个连接对象
		Connection connection = null;

		try {
			// 获取连接对象
			connection = DBUtils.getConnection();
			// 开启事务，关闭事务的自动提交，改为手动提交
			connection.setAutoCommit(false);
			// 1.验证fromNo账号是否存在
			Account fromAccount = accountDaoImpl.select(fromNo);
			if (fromAccount == null) {
				throw new RuntimeException("卡号不存在");
			}

			// 2.验证fromNo的密码是否正确
			if (!fromAccount.getPassword().equals(password)) {
				throw new RuntimeException("密码错误");
			}

			// 3.验证余额是否充足
			if (fromAccount.getBalance() < money) {
				throw new RuntimeException("余额不足");
			}

			// 4.验证toNo账号是否存在
			Account toAccount = accountDaoImpl.select(toNo);
			if (toAccount == null) {
				throw new RuntimeException("对方卡号不存在");
			}
			// 5.减少fromNo账号的余额
			fromAccount.setBalance(fromAccount.getBalance() - money);
			accountDaoImpl.update(fromAccount);

			// 程序出现异常
			@SuppressWarnings("unused")
			int num = 10 / 0;

			// 6.增加toNo账号的余额
			toAccount.setBalance(toAccount.getBalance() + money);
			accountDaoImpl.update(toAccount);
			// 代码执行到这里，说明转账成功，提交事务
			connection.commit();
			result = "转账成功";
			return result;
		} catch (Exception e) {
			e.printStackTrace();
			try {
				// 出现异常，回滚整个事务
				System.out.println("出现异常，回滚整个事务，转账失败");
				connection.rollback();
			} catch (SQLException e1) {
				e1.printStackTrace();
			}
		} finally {
			DBUtils.closeAll(connection, null, null);
		}
		return result;
	}
}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

十五、事务的封装

15.1 问题描述

（1）XXXDaoImpl类是专门用来操作数据表的，在这个类中只存在对数据表增删改查的方法，没有其它的内容。这是我们需要的。但是在XXXServiceImpl类中，既有业务需求，还有获取数据库连接对象以及释放资源的代码，在XXXServiceImpl类中，应该只有业务逻辑需求，除此，没有其它操作代码，这才是我们需要的。

（2）因此我们需要将对事务的开启、提交、回滚都封装到DBUtils工具类中。业务层调用DBUtils类中的与事务相关的代码即可。

15.2 完善工具类

package com.cxyzxc.www.examples09;

import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

/**
 * 跨平台方案 注册驱动 获取连接 释放资源
 * 
 */
public class DBUtils {
	// 读取配置文件的Map
	private static final Properties PROPERTIES = new Properties();
	
	// 声明一个ThreadLocal<Connection>对象用来存储数据库连接对象
	private static ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();

	static {
		// 通过复用本类自带流，读取配置文件中的数据
		InputStream is = DBUtils.class.getResourceAsStream("/db.properties");

		try {
			// 通过prop对象将流中的配置信息分隔成键值对,将配置文件内容加载到properties集合
			PROPERTIES.load(is);
			// 注册驱动，通过driverName的键获取对应的值（com.mysql.jdbc.Driver）
			Class.forName(PROPERTIES.getProperty("driver"));
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

	// 获取连接对象
	public static Connection getConnection() {
		// 将当前线程中绑定的Connection对象赋值给connection变量
		Connection connection = threadLocal.get();
		try {
			// 如果连接对象为null，则创建一个连接对象
			if (connection == null) {
				connection = DriverManager.getConnection(
						PROPERTIES.getProperty("url"),
						PROPERTIES.getProperty("username"),
						PROPERTIES.getProperty("password"));
				// 将创建的连接对象存储到当前线程中共享
				threadLocal.set(connection);
			}

		} catch (SQLException e) {
			e.printStackTrace();
		}
		return connection;
	}

	// 释放所有资源
	public static void closeAll(Connection connection, Statement statement,
			ResultSet resultSet) {
		try {
			if (resultSet != null) {
				resultSet.close();
			}
			if (statement != null) {
				statement.close();
			}
			if (connection != null) {
				connection.close();
				// 将connection从threadLocal中移除
				threadLocal.remove();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

	// 3、开启事务
	public static void startTransaction() {
		Connection connection = null;
		try {
			connection = getConnection();
			connection.setAutoCommit(false);
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

	// 4、提交事务
	public static void commitTransaction() {
		Connection connection = getConnection();
		try {
			connection.commit();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(connection, null, null);
		}
	}

	// 5、回滚事务
	public static void rollbackTransaction() {
		Connection connection = getConnection();
		try {
			connection.rollback();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(connection, null, null);
		}
	}
}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

15.3 AccountServiceImpl类代码修改

package com.cxyzxc.www.examples09;

public class AccountServiceImpl {

	/**
	 * 转账业务
	 * 
	 * @param fromNo
	 *            转账人账号
	 * @param password
	 *            转账人账号密码
	 * @param toNo
	 *            收款人账号
	 * @param money
	 *            转账金额
	 */
	public String transfer(String fromNo, String password, String toNo,
			double money) {
		String result = "转账失败";
		AccountDaoImpl accountDaoImpl = new AccountDaoImpl();

		try {

			// 开启事务，关闭事务的自动提交，改为手动提交
			DBUtils.startTransaction();
			// 1.验证fromNo账号是否存在
			Account fromAccount = accountDaoImpl.select(fromNo);
			if (fromAccount == null) {
				throw new RuntimeException("卡号不存在");
			}

			// 2.验证fromNo的密码是否正确
			if (!fromAccount.getPassword().equals(password)) {
				throw new RuntimeException("密码错误");
			}

			// 3.验证余额是否充足
			if (fromAccount.getBalance() < money) {
				throw new RuntimeException("余额不足");
			}

			// 4.验证toNo账号是否存在
			Account toAccount = accountDaoImpl.select(toNo);
			if (toAccount == null) {
				throw new RuntimeException("对方卡号不存在");
			}
			// 5.减少fromNo账号的余额
			fromAccount.setBalance(fromAccount.getBalance() - money);
			accountDaoImpl.update(fromAccount);

			// 程序出现异常
			@SuppressWarnings("unused")
			int num = 10 / 0;

			// 6.增加toNo账号的余额
			toAccount.setBalance(toAccount.getBalance() + money);
			accountDaoImpl.update(toAccount);
			// 代码执行到这里，说明转账成功，提交事务
			DBUtils.commitTransaction();
			result = "转账成功";
			return result;
		} catch (Exception e) {
			e.printStackTrace();
			// 出现异常，回滚整个事务
			System.out.println("出现异常，回滚整个事务，转账失败");
			DBUtils.rollbackTransaction();
		}
		return result;
	}
}
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
60
61
62
63
64
65
66
67
68
69
70

十六、三层架构

16.1 什么是三层

（1）表示层（View）

• 命名：XxxView
• 职责：收集用户的数据和需求、数据

（2）业务逻辑层（service）

• 命名：XxxServiceImpl
• 职责：数据加工处理、调用DAO完成业务实现、控制事务

（3）数据访问层（Dao）

• 命名：XxxDaoImpl
• 职责：向业务层提供数据，将业务层加工后的数据同步到数据库

16.2 三层架构项目搭建步骤

16.2.1 项目环境搭建

1）新建一个项目，在项目中创建lib文件夹，将MySQL数据库jar包放在lib文件夹中，配置环境。

2）在src文件夹下面创建db.properties文件，编写数据库driver、url、user、password信息。

3）创建三层需要的各个包。

（1）utils包：存放工具类（DBUtils类、DateUtils类）

（2）entity包：存放实体类（Xxx.java）

（3）dao包：存放DAO接口

		impl包：存放DAO接口实现类

（4）service包：存放service接口

		impl：存放service接口实现类

（5）view包：存放程序启动类或测试类（main）
1
2
3
4
5
6
7
8
9
10
11
12
13

16.2.2 创建book表

16.2.2.1 创建表

CREATE TABLE IF NOT EXISTS `book`(
`bid` INT PRIMARY KEY AUTO_INCREMENT COMMENT '图书编号',
`isbn` VARCHAR(20) UNIQUE NOT NULL COMMENT '国际标准书号',
`name` VARCHAR(20) NOT NULL COMMENT '书名',
`author` VARCHAR(20) NOT NULL COMMENT '作者',
`press` VARCHAR(20) NOT NULL COMMENT '出版社',
`price` DOUBLE NOT NULL COMMENT '价格',
`classification` VARCHAR(20) NOT NULL COMMENT '分类'
);
1
2
3
4
5
6
7
8
9

16.2.2.2 向表中插入数据

INSERT INTO `book`(`bid`,`isbn`,`name`,`author`,`press`,`price`,`classification`)
VALUES
(1001,'978-7-5170-7654-4','SQL从入门到精通','张三','中国水利水电出版社',79.80,'数据库');

INSERT INTO `book`(`bid`,`isbn`,`name`,`author`,`press`,`price`,`classification`)
VALUES
(1002,'976-9-5245-7633-5','java从入门到精通','李四','清华大学出版社',99.80,'程序设计');
1
2
3
4
5
6
7

16.2.3 创建entity实体类Book

package com.cxyzxc.www.entity;

import java.util.Date;

/**
 * entity实体类Booke类
 * 
 */
public class Book {
	/** 图书编号 */
	private int bid;
	/** 国际标准书号 */
	private String isbn;
	/** 书名 */
	private String name;
	/** 作者 */
	private String author;
	/** 出版社 */
	private String press;
	/** 价格 */
	private double price;
	/** 分类 */
	private String classification;
	/** 出版日期 */
	private Date pubdate;

	public Book() {
		super();
	}

	public Book(String isbn, String name, String author, String press,
			double price, String classification, Date pubdate) {
		super();
		this.isbn = isbn;
		this.name = name;
		this.author = author;
		this.press = press;
		this.price = price;
		this.classification = classification;
		this.pubdate = pubdate;
	}

	public Book(int bid, String isbn, String name, String author, String press,
			double price, String classification, Date pubdate) {
		super();
		this.bid = bid;
		this.isbn = isbn;
		this.name = name;
		this.author = author;
		this.press = press;
		this.price = price;
		this.classification = classification;
		this.pubdate = pubdate;
	}

	public int getBid() {
		return bid;
	}

	public void setBid(int bid) {
		this.bid = bid;
	}

	public String getIsbn() {
		return isbn;
	}

	public void setIsbn(String isbn) {
		this.isbn = isbn;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getAuthor() {
		return author;
	}

	public void setAuthor(String author) {
		this.author = author;
	}

	public String getPress() {
		return press;
	}

	public void setPress(String press) {
		this.press = press;
	}

	public double getPrice() {
		return price;
	}

	public void setPrice(double price) {
		this.price = price;
	}

	public String getClassification() {
		return classification;
	}

	public void setClassification(String classification) {
		this.classification = classification;
	}

	public Date getPubdate() {
		return pubdate;
	}

	public void setPubdate(Date pubdate) {
		this.pubdate = pubdate;
	}

	@Override
	public String toString() {
		return "Book [bid=" + bid + ", isbn=" + isbn + ", name=" + name
				+ ", author=" + author + ", press=" + press + ", price="
				+ price + ", classification=" + classification + ", pubdate="
				+ pubdate + "]";
	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

16.2.4 创建BookDao接口

package com.cxyzxc.www.dao;

import java.util.List;

import com.cxyzxc.www.entity.Book;
/**
 * 定义BookDao接口，接口中定义对book表增删改查的方法
 * 
 */
public interface BookDao {
	
	//增
	int insert(Book book);
	
	//删
	int delete(int bid);
	
	//改
	int update(Book book);
	
	//查单个
	Book selectOne(int bid);
	
	//查所有
	List<Book> selectAll();

}
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

16.2.5 创建BookDaoImpl实现类

package com.cxyzxc.www.dao.impl;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import com.cxyzxc.www.dao.BookDao;
import com.cxyzxc.www.entity.Book;
import com.cxyzxc.www.utils.DBUtils;
import com.cxyzxc.www.utils.DateUtils;
/**
 * 定义BookDaoImpl类，实现BookDao接口，重写接口中的增删改查方法
 * 
 */
public class BookDaoImpl implements BookDao {

	@Override
	public int insert(Book book) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;

		connection = DBUtils.getConnection();

		String sql = "INSERT INTO `book`(`isbn`,`name`,`author`,`press`,`price`,`classification`,`pubdate`)VALUES(?,?,?,?,?,?,?);";

		try {
			preparedStatement = connection.prepareStatement(sql);
			// 绑定参数
			preparedStatement.setString(1, book.getIsbn());
			preparedStatement.setString(2, book.getName());
			preparedStatement.setString(3, book.getAuthor());
			preparedStatement.setString(4, book.getPress());
			preparedStatement.setDouble(5, book.getPrice());
			preparedStatement.setString(6, book.getClassification());
			preparedStatement.setDate(7,
					DateUtils.utilDateToSqlDate(book.getPubdate()));

			int result = preparedStatement.executeUpdate();
			return result;
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return 0;
	}

	@Override
	public int delete(int bid) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;

		connection = DBUtils.getConnection();

		String sql = "DELETE FROM `book` WHERE `bid`=?;";

		try {
			preparedStatement = connection.prepareStatement(sql);
			// 绑定参数
			preparedStatement.setInt(1, bid);
			int result = preparedStatement.executeUpdate();
			return result;
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return 0;
	}

	@Override
	public int update(Book book) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;

		connection = DBUtils.getConnection();

		String sql = "UPDATE `book` SET `isbn`=?,`name`=?,`author`=?,`press`=?,`price`=?,`classification`=?,`pubdate`=? WHERE `bid`=?;";

		try {
			preparedStatement = connection.prepareStatement(sql);
			// 绑定参数
			preparedStatement.setString(1, book.getIsbn());
			preparedStatement.setString(2, book.getName());
			preparedStatement.setString(3, book.getAuthor());
			preparedStatement.setString(4, book.getPress());
			preparedStatement.setDouble(5, book.getPrice());
			preparedStatement.setString(6, book.getClassification());
			preparedStatement.setDate(7,
					DateUtils.utilDateToSqlDate(book.getPubdate()));
			preparedStatement.setDouble(8, book.getBid());

			int result = preparedStatement.executeUpdate();
			return result;
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return 0;
	}

	@Override
	public Book selectOne(int bid) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		Book book = null;
		connection = DBUtils.getConnection();

		String sql = "Select * FROM `book` WHERE `bid`=?;";
		try {
			preparedStatement = connection.prepareStatement(sql);
			// 绑定参数
			preparedStatement.setInt(1, bid);

			resultSet = preparedStatement.executeQuery();

			if (resultSet.next()) {
				int bookid = resultSet.getInt(1);
				String isbn = resultSet.getString(2);
				String name = resultSet.getString(3);
				String author = resultSet.getString(4);
				String press = resultSet.getString(5);
				double price = resultSet.getDouble(6);
				String classification = resultSet.getString(7);
				Date pubdate = resultSet.getDate(8);
				book = new Book(bookid, isbn, name, author, press, price,
						classification, pubdate);
			}
			return book;
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return null;
	}

	@Override
	public List<Book> selectAll() {

		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		Book book = null;
		List<Book> bookList = new ArrayList<Book>();
		connection = DBUtils.getConnection();

		String sql = "Select * FROM `book`;";
		try {
			preparedStatement = connection.prepareStatement(sql);

			resultSet = preparedStatement.executeQuery();

			while (resultSet.next()) {
				int bookid = resultSet.getInt(1);
				String isbn = resultSet.getString(2);
				String name = resultSet.getString(3);
				String author = resultSet.getString(4);
				String press = resultSet.getString(5);
				double price = resultSet.getDouble(6);
				String classification = resultSet.getString(7);
				Date pubdate = resultSet.getDate(8);
				book = new Book(bookid, isbn, name, author, press, price,
						classification, pubdate);
				bookList.add(book);
			}
			return bookList;
		} catch (SQLException e) {
			e.printStackTrace();
		}

		return null;
	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173

16.2.6 创建BookService接口

package com.cxyzxc.www.service;

import java.util.List;

import com.cxyzxc.www.entity.Book;
/**
 * 定义BookService接口，接口中定义业务逻辑方法
 * 
 */
public interface BookService {
	//添加图书
	int addBook(Book book);
	
	//删除图书
	int deleteBook(int bid);
	
	//修改图书
	int updateBook(Book book);
	
	//查询一本图书
	Book selectOne(int bid);
	
	//查询所有图书
	List<Book> selectAll();

}
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

16.2.7 创建BookServiceImpl实现类

package com.cxyzxc.www.service.impl;

import java.util.List;

import com.cxyzxc.www.dao.BookDao;
import com.cxyzxc.www.dao.impl.BookDaoImpl;
import com.cxyzxc.www.entity.Book;
import com.cxyzxc.www.service.BookService;
/**
 * 定义BookServiceImpl类，实现BookService接口，重写BookService接口中的所有方法
 * 
 */
public class BookServiceImpl implements BookService {

	BookDao bookDao = new BookDaoImpl();

	@Override
	public int addBook(Book book) {
		// 首先查询一下插入的图书在数据库中是否存在
		Book book2 = bookDao.selectOne(book.getBid());
		if (book2 == null) {
			return bookDao.insert(book);
		} else {
			System.out.println("插入的图书已经存在，插入失败");
		}
		return 0;
	}

	@Override
	public int deleteBook(int bid) {
		// 查询要删除的图书是否存在
		Book book2 = bookDao.selectOne(bid);
		if (book2 == null) {
			System.out.println("删除的图书不存在，无法删除");
		} else {
			return bookDao.delete(bid);
		}
		return 0;
	}

	@Override
	public int updateBook(Book book) {
		// 查询要修改的图书是否存在
		Book book2 = bookDao.selectOne(book.getBid());
		if (book2 == null) {
			System.out.println("你要修改的图书不存在");
		} else {
			return bookDao.update(book);
		}
		return 0;
	}

	@Override
	public Book selectOne(int bid) {
		Book book2 = bookDao.selectOne(bid);
		return book2;
	}

	@Override
	public List<Book> selectAll() {
		List<Book> bookList = bookDao.selectAll();
		return bookList;
	}

}
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
60
61
62
63
64
65

16.2.8 编写测试类

16.2.8.1 测试增加数据

package com.cxyzxc.www.view;

import com.cxyzxc.www.entity.Book;
import com.cxyzxc.www.service.BookService;
import com.cxyzxc.www.service.impl.BookServiceImpl;
import com.cxyzxc.www.utils.DateUtils;

public class Test01InsertBook {

	public static void main(String[] args) {

		BookService bookService = new BookServiceImpl();

		// 添加图书
		Book book = new Book("978-9-9456-3286-9", "JSP从入门到精通", "李二狗", "邮电出版社",129, "编程设计", DateUtils.strDateToUtilDate("2022-01-13"));
		int result = bookService.addBook(book);
		if (result == 1) {
			System.out.println("图书添加成功");
		} else {
			System.out.println("图书添加失败");
		}

	}

}
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

16.2.8.2 测试删除数据

package com.cxyzxc.www.view;

import com.cxyzxc.www.service.BookService;
import com.cxyzxc.www.service.impl.BookServiceImpl;

public class Test02DeleteBook {

	public static void main(String[] args) {

		BookService bookService = new BookServiceImpl();

		// 删除图书
		int result = bookService.deleteBook(1003);
		if (result == 1) {
			System.out.println("删除成功");
		} else {
			System.out.println("删除失败");
		}
		
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

16.2.8.3 测试修改数据

package com.cxyzxc.www.view;

import com.cxyzxc.www.entity.Book;
import com.cxyzxc.www.service.BookService;
import com.cxyzxc.www.service.impl.BookServiceImpl;
import com.cxyzxc.www.utils.DateUtils;

public class Test03UpdateBook {

	public static void main(String[] args) {

		BookService bookService = new BookServiceImpl();

		// //修改图书
		Book book = new Book(1002, "976-9-5245-7633-5", "JSP从入门到放弃", "李四","清华大学出版社", 109.8, "编程设计",DateUtils.strDateToUtilDate("2022-10-13"));

		int result = bookService.updateBook(book);
		if (result == 1) {
			System.out.println("修改成功");
		} else {
			System.out.println("修改失败");
		}

	}

}
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

16.2.8.4 测试查询单个

package com.cxyzxc.www.view;

import com.cxyzxc.www.entity.Book;
import com.cxyzxc.www.service.BookService;
import com.cxyzxc.www.service.impl.BookServiceImpl;

public class Test04SelectOneBook {

	public static void main(String[] args) {

		BookService bookService = new BookServiceImpl();

		Book book = bookService.selectOne(1003);
		if (book == null) {
			System.out.println("没有你要查找的图书");
		} else {
			System.out.println(book);
		}
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

16.2.8.4 测试查询所有

package com.cxyzxc.www.view;

import java.util.List;

import com.cxyzxc.www.entity.Book;
import com.cxyzxc.www.service.BookService;
import com.cxyzxc.www.service.impl.BookServiceImpl;

public class Test05SelectAllBook {

	public static void main(String[] args) {

		BookService bookService = new BookServiceImpl();

		List<Book> books = bookService.selectAll();
		if (books.isEmpty()) {

			System.out.println("数据库里没有书的数据");
		} else {
			for (int i = 0; i < books.size(); i++) {
				System.out.println(books.get(i));
			}
		}
	}

}
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

十七、DaoUtils（Object类型方法）

在Dao层的DaoImpl类中，对数据表进行的增、删、改、查操作方法中存在很多相同的代码，可以将这些相同的代码抽取出来封装到一个类中，形成DaoUtils工具类，实现复用。以查询teacher表为例。

17.1 commonsUpdae方法

该方法是对数据表进行增、删、改的公共方法。

// 增、删、改三个方法封装成一个方法
public int commonsUpdate(String sql, Object... args) {
	Connection connection = null;
	PreparedStatement preparedStatement = null;
	// 获取数据库连接对象
	connection = DBUtils.getConnection();

	try {
		// 获取SQL语句发送对象
		preparedStatement = connection.prepareStatement(sql);
		if (args != null) {
			// 绑定参数
			for (int i = 0; i < args.length; i++) {
				preparedStatement.setObject(i + 1, args[i]);
			}
		}
		// 执行SQL语句
		int result = preparedStatement.executeUpdate();
		return result;
	} catch (SQLException e) {
		e.printStackTrace();
	} finally {
		DBUtils.closeAll(null, preparedStatement, null);
	}
	return 0;
}
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

17.2 commonsSelect方法

该方法是对数据表进行查询的公共方法，可以查询一条数据，也可以查询多条数据。不管是查询一条数据还是查询多条数据，都将查询到的数据封装到Object类型的集合中。

public List<Object> commonsSelect(String sql,RowMapper rowMapper, Object... args) {
		Connection connection = null;
	PreparedStatement preparedStatement = null;
	ResultSet resultSet = null;
	List<Object> objectList = new ArrayList<Object>();
	// 获取数据库连接对象
	connection = DBUtils.getConnection();

	try {
		// 获取SQL语句发送对象
		preparedStatement = connection.prepareStatement(sql);
		if (args != null) {
			// 绑定参数
			for (int i = 0; i < args.length; i++) {
				preparedStatement.setObject(i + 1, args[i]);
			}
		}
		// 执行SQL语句
		resultSet = preparedStatement.executeQuery();

		while (resultSet.next()) {
			Object object = rowMapper.getRow(resultSet);
			objectList.add(object);
		}
		return objectList;

	} catch (SQLException e) {
		e.printStackTrace();
	}finally {
		DBUtils.closeAll(null, preparedStatement, resultSet);
	}

	return null;
}
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

17.3 RowMapper类封装resultSet结果集

使用查询方法从表中查询出来的结果存储在ResultSet结果集中，需要从ResultSet结果集中遍历出数据封装成对应对象，然后将封装出来的对象返回给DaoImpl类使用。这个封装的过程由RowMapper类完成。

package com.cxyzxc.www.examples01;

/**
 * 数据封装类，专门用来处理查询返回的resultSet结果集
 * 
 * 针对每一个实体类，封装一个RowMapper类
 */
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;

public class RowMapper {
	
	public static Object getRow(ResultSet resultSet){
		
		Teacher teacher = null;
		
		try {
			//返回的结果集中有哪些字段，RowMapper类是知道的，因为他是实体类的封装类
			int tid = resultSet.getInt("tid");
			String name = resultSet.getString("name");
			int age = resultSet.getInt("age");
			Date bornDate = resultSet.getDate("bornDate");
			String email = resultSet.getString("email");
			String address = resultSet.getString("address");
			
			teacher = new Teacher(tid, name, age, bornDate, email, address);
			return teacher;
		} catch (SQLException e) {
			e.printStackTrace();
		}
		
		return null;
		
	}

}
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

17.4 综合案例

综合案例完全按照三层架构实现，创建不同的包存放不同的接口、实现类、工具类、测试类等代码。使用数据库中的teacher表来完成综合案例。

17.4.1 com.cxyzxc.www.utils包

该包用来存放项目开发所需要的数据库连接工具类DBUtils类、日期时间转换工具类DateUtils类，数据库操作工具类DaoUtils类

17.4.1.1 DaoUtils工具类完整代码

package com.cxyzxc.www.utils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.cxyzxc.www.advanced.RowMapper;

public class DaoUtils {

	// 增、删、改三个方法封装成一个方法
	public int commonsUpdate(String sql, Object... args) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;
		// 获取数据库连接对象
		connection = DBUtils.getConnection();

		try {
			// 获取SQL语句发送对象
			preparedStatement = connection.prepareStatement(sql);
			if (args != null) {
				// 绑定参数
				for (int i = 0; i < args.length; i++) {
					preparedStatement.setObject(i + 1, args[i]);
				}
			}
			// 执行SQL语句
			int result = preparedStatement.executeUpdate();
			return result;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(null, preparedStatement, null);
		}
		return 0;
	}

	public List<Object> commonsSelect(String sql,RowMapper rowMapper, Object... args) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		List<Object> objectList = new ArrayList<Object>();
		// 获取数据库连接对象
		connection = DBUtils.getConnection();

		try {
			// 获取SQL语句发送对象
			preparedStatement = connection.prepareStatement(sql);
			if (args != null) {
				// 绑定参数
				for (int i = 0; i < args.length; i++) {
					preparedStatement.setObject(i + 1, args[i]);
				}
			}
			// 执行SQL语句
			resultSet = preparedStatement.executeQuery();

			while (resultSet.next()) {
				Object object = rowMapper.getRow(resultSet);
				objectList.add(object);
			}
			return objectList;

		} catch (SQLException e) {
			e.printStackTrace();
		}finally {
			DBUtils.closeAll(null, preparedStatement, resultSet);
		}

		return null;
	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

17.4.1.2 DBUtils工具类完整代码

package com.cxyzxc.www.utils;

import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

/**
 * 跨平台方案 注册驱动 获取连接 释放资源
 * 
 * @author 程序员张小厨
 * 
 */
public class DBUtils {
	// 读取配置文件的Map
	private static final Properties PROPERTIES = new Properties();
	// 声明一个ThreadLocal<Connection>对象用来存储数据库连接对象
	private static ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();

	static {
		// 通过复用本类自带流，读取配置文件中的数据
		InputStream is = DBUtils.class.getResourceAsStream("/db.properties");

		try {
			// 通过prop对象将流中的配置信息分隔成键值对,将配置文件内容加载到properties集合
			PROPERTIES.load(is);
			// 注册驱动，通过driverName的键获取对应的值（com.mysql.jdbc.Driver）
			Class.forName(PROPERTIES.getProperty("driver"));
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

	// 获取连接对象
	public static Connection getConnection() {
		// 将当前线程中绑定的Connection对象赋值给connection变量
		Connection connection = threadLocal.get();
		try {
			// 如果连接对象为null，则创建一个连接对象
			if (connection == null) {
				connection = DriverManager.getConnection(
						PROPERTIES.getProperty("url"),
						PROPERTIES.getProperty("username"),
						PROPERTIES.getProperty("password"));
				// 将创建的连接对象存储到当前线程中共享
				threadLocal.set(connection);
			}

		} catch (SQLException e) {
			e.printStackTrace();
		}
		return connection;
	}

	// 释放所有资源
	public static void closeAll(Connection connection, Statement statement,
			ResultSet resultSet) {
		try {
			if (resultSet != null) {
				resultSet.close();
			}
			if (statement != null) {
				statement.close();
			}
			if (connection != null) {
				connection.close();
				// 将connection从threadLocal中移除
				threadLocal.remove();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

	// 3、开启事务
	public static void startTransaction() {
		Connection connection = null;
		try {
			connection = getConnection();
			connection.setAutoCommit(false);
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

	// 4、提交事务
	public static void commitTransaction() {
		Connection connection = getConnection();
		try {
			connection.commit();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(connection, null, null);
		}
	}

	// 5、回滚事务
	public static void rollbackTransaction() {
		Connection connection = getConnection();
		try {
			connection.rollback();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(connection, null, null);
		}
	}
}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

17.4.1.3 DateUtils工具类完整代码

package com.cxyzxc.www.utils;

import java.text.ParseException;
import java.text.SimpleDateFormat;

/**
 * 日期时间工具类DateUtils
 */
public class DateUtils {

	private static final SimpleDateFormat SIMPLEDATEFORMAT = new SimpleDateFormat("yyyy-MM-dd");

	// 字符串转换为java.util.Date类型日期时间
	public static java.util.Date strDateToUtilDate(String strDate) {
		try {
			return SIMPLEDATEFORMAT.parse(strDate);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return null;
	}

	// java.util.Date类型日期时间转换为java.sql.Date类型日期时间
	public static java.sql.Date utilDateToSqlDate(java.util.Date date) {
		// long date.getTime():返回自 1970 年 1 月 1 日 00:00:00 GMT以来此 Date对象表示的毫秒数
		return new java.sql.Date(date.getTime());
	}

	// java.util.Date类转换为字符串类型
	public static String utilDateToString(java.util.Date date) {
		return SIMPLEDATEFORMAT.format(date);
	}

}
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

17.4.2 com.cxyzxc.www.entity包

该包用来存储实体类，根据teacher表创建实体类Teacher类

package com.cxyzxc.www.entity;

import java.util.Date;

public class Teacher {
	/** 教师编号 */
	private int tid;
	/** 姓名 */
	private String name;
	/** 年龄 */
	private int age;
	/** 出生日期 */
	private Date bornDate;
	/** 邮箱 */
	private String email;
	/** 住址 */
	private String address;

	// 无参构造方法
	public Teacher() {
		super();
	}

	// 有参构造方法
	public Teacher(String name, int age, Date bornDate, String email,
			String address) {
		super();
		this.name = name;
		this.age = age;
		this.bornDate = bornDate;
		this.email = email;
		this.address = address;
	}

	public Teacher(int tid, String name, int age, Date bornDate, String email,
			String address) {
		super();
		this.tid = tid;
		this.name = name;
		this.age = age;
		this.bornDate = bornDate;
		this.email = email;
		this.address = address;
	}

	// getXxx()/setXxx()方法
	public int getTid() {
		return tid;
	}

	public void setTid(int tid) {
		this.tid = tid;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public Date getBornDate() {
		return bornDate;
	}

	public void setBornDate(Date bornDate) {
		this.bornDate = bornDate;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	// 重写Object类中的toString()方法
	@Override
	public String toString() {
		return "tid=" + tid + ", name=" + name + ", age=" + age + ", bornDate="
				+ bornDate + ", email=" + email + ", address=" + address;
	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

17.4.3 com.cxyzxc.www.advanced包

该包中存放RowMapper接口，用来约束封装对象的ORM

package com.cxyzxc.www.advanced;

import java.sql.ResultSet;

/**
 * 该接口用来约束封装对象的ORM
 * 
 */
public interface RowMapper {
	
	Object getRow(ResultSet resultSet);

}
1
2
3
4
5
6
7
8
9
10
11
12
13

17.4.4 com.cxyzxc.www.advanced.impl包

package com.cxyzxc.www.advanced.impl;

/**
 * 数据封装类，专门用来处理查询返回的resultSet结果集
 * 
 * 针对每一个实体类，封装一个RowMapper类
 */
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;

import com.cxyzxc.www.advanced.RowMapper;
import com.cxyzxc.www.entity.Teacher;

public class TeacherRowMapper implements RowMapper {

	@Override
	public Object getRow(ResultSet resultSet) {
		Teacher teacher = null;
		try {
			// 返回的结果集中有哪些字段，RowMapper类是知道的，因为他是实体类的封装类
			int tid = resultSet.getInt("tid");
			String name = resultSet.getString("name");
			int age = resultSet.getInt("age");
			Date bornDate = resultSet.getDate("bornDate");
			String email = resultSet.getString("email");
			String address = resultSet.getString("address");

			teacher = new Teacher(tid, name, age, bornDate, email, address);
			return teacher;
		} catch (SQLException e) {
			e.printStackTrace();
		}

		return null;
	}

}
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

17.4.5 com.cxyzxc.www.dao包

该包用来存放操作数据库的接口

package com.cxyzxc.www.dao;

import java.util.List;

import com.cxyzxc.www.entity.Teacher;

public interface TeacherDao {
	//增
	int insert(Teacher teacher);
	
	//删
	int delete(int tid);
	
	//改
	int update(Teacher teacher);
	
	//查单个
	Teacher selectOne(int tid);
	
	//查所有
	List<Teacher> selectAll();
	

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

17.4.6 com.cxyzxc.www.dao.impl包

该包用来存放数据库操作接口的实现类

package com.cxyzxc.www.dao.impl;

import java.util.ArrayList;
import java.util.List;

import com.cxyzxc.www.advanced.RowMapper;
import com.cxyzxc.www.advanced.impl.TeacherRowMapper;
import com.cxyzxc.www.dao.TeacherDao;
import com.cxyzxc.www.entity.Teacher
 */
public class TeacherDaoImpl implements TeacherDao {
	/*
	 * （1）该类中提供对teacher表进行增、删、改、查单个、查所有5个方法。
	 * 
	 * （2）该类中的代码只做数据库访问操作，不做任何业务逻辑操作。
	 * 
	 * （3）该类只对数据库一张表进行操作，从而实现复用
	 */

	DaoUtils daoUtils = new DaoUtils();
	RowMapper rowMapper = new TeacherRowMapper();

	// 新增：向teacher表中插入一条数据（一条数据对应一个Teacher对象）,插入成功，返回一个受影响行数值（int类型）
	@Override
	public int insert(Teacher teacher) {

		String sql = "insert into `teacher`(name,age,bornDate,email,address) values(?,?,?,?,?);";

		// 赋值
		Object[] args = { teacher.getName(), teacher.getAge(),
				teacher.getBornDate(), teacher.getEmail(), teacher.getAddress() };

		return daoUtils.commonsUpdate(sql, args);
	}

	// 删除：根据教师tid删除一条数据,删除成功，返回一个受影响行数值（int类型）
	@Override
	public int delete(int tid) {

		String sql = "delete from teacher where tid = ?;";
		return daoUtils.commonsUpdate(sql, tid);

	}

	// 修改：修改teacher表中的数据，可能对任意的一个字段进行修改，所以方法中直接传递一个对象进行修改,修改成功，返回一个受影响行数值（int类型）
	@Override
	public int update(Teacher teacher) {

		String sql = "update teacher set name = ?,age = ?,bornDate = ?,email = ?,address = ? where tid = ?;";

		Object[] args = { teacher.getName(), teacher.getAge(),
				teacher.getBornDate(), teacher.getEmail(),
				teacher.getAddress(), teacher.getTid() };
		return daoUtils.commonsUpdate(sql, args);
	}

	// 查询单个：根据教师tid查询一条数据，查询成功返回一个结果集（ResultSet类型）,从结果集中取出元素，封装成一个Teacher对象，将该对象返回
	@Override
	public Teacher selectOne(int tid) {

		String sql = "select * from teacher where tid = ?;";
		List<Object> objectList = daoUtils.commonsSelect(sql, rowMapper, tid);

		if (objectList.size() == 1) {
			Teacher teacher = (Teacher) objectList.get(0);
			return teacher;
		} else {
			return null;
		}
	}

	// 查询所有：将teacher表中的所有数据全部查询出来，查询成功返回一个结果集（ResultSet类型）,从结果集中取出元素，封装成多个Teacher对象，将多个对象存储在集合中，返回这个集合
	@Override
	public List<Teacher> selectAll() {

		List<Teacher> teacherList = new ArrayList<Teacher>();
		String sql = "select * from teacher;";
		DaoUtils daoUtils = new DaoUtils();
		Object[] args = null;
		List<Object> objectList = daoUtils.commonsSelect(sql, rowMapper, args);
		for (int i = 0; i < objectList.size(); i++) {
			teacherList.add((Teacher) objectList.get(i));
		}
		return teacherList;
	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

17.4.7 com.cxyzxc.www.service包

该包用来存储业务层接口代码

package com.cxyzxc.www.service;

import java.util.List;

import com.cxyzxc.www.entity.Teacher;

public interface TeacherService {
	
	//添加老师
	int addTeacher(Teacher teacher);
	
	//删除老师
	int deleteTeacher(int tid);
	
	//修改老师
	int updateTeacher(Teacher teacher);
	
	//查询一个老师
	Teacher selectOne(int tid);
	
	//查询所有老师
	List<Teacher> selectAll();

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

17.4.8 com.cxyzxc.www.service.impl包

该包用来存储service层实现类代码

package com.cxyzxc.www.service.impl;

import java.util.List;

import com.cxyzxc.www.dao.impl.TeacherDaoImpl;
import com.cxyzxc.www.entity.Teacher;
import com.cxyzxc.www.service.TeacherService;

public class TeacherServiceImpl implements TeacherService {

	@Override
	public int addTeacher(Teacher teacher) {

		TeacherDaoImpl teacherDaoImpl = new TeacherDaoImpl();

		Teacher teacher2 = teacherDaoImpl.selectOne(teacher.getTid());

		if (teacher2 == null) {
			return teacherDaoImpl.insert(teacher);
		} else {
			System.out.println("老师已存在");
		}

		return 0;

	}

	@Override
	public int deleteTeacher(int tid) {
		TeacherDaoImpl teacherDaoImpl = new TeacherDaoImpl();
		Teacher teacher2 = teacherDaoImpl.selectOne(tid);

		if (teacher2 == null) {
			System.out.println("你要删除的老师不存在，无法删除");
		} else {
			return teacherDaoImpl.delete(tid);
		}
		return 0;

	}

	@Override
	public int updateTeacher(Teacher teacher) {
		TeacherDaoImpl teacherDaoImpl = new TeacherDaoImpl();
		Teacher teacher2 = teacherDaoImpl.selectOne(teacher.getTid());
		if (teacher2 == null) {
			System.out.println("你要修改的老师不存在，无法修改");
		} else {
			return teacherDaoImpl.update(teacher);
		}
		return 0;
	}
	
	@Override
	public Teacher selectOne(int tid){
		TeacherDaoImpl teacherDaoImpl = new TeacherDaoImpl();
		Teacher teacher =teacherDaoImpl.selectOne(tid);
		return teacher;
	}
	
	@Override
	public List<Teacher> selectAll(){
		TeacherDaoImpl teacherDaoImpl = new TeacherDaoImpl();
		return teacherDaoImpl.selectAll();
	}

}
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
60
61
62
63
64
65
66
67

17.4.9 com.cxy.zxc.view包

该包用来存储测试类

17.4.9.1 测试插入数据

package com.cxyzxc.www.view;

import com.cxyzxc.www.entity.Teacher;
import com.cxyzxc.www.service.TeacherService;
import com.cxyzxc.www.service.impl.TeacherServiceImpl;
import com.cxyzxc.www.utils.DateUtils;

public class TestTeacherServiceImpl01Insert {

	public static void main(String[] args) {

		
		TeacherService teacherService = new TeacherServiceImpl();
		
		Teacher teacher = new Teacher(1004, "王五", 30, DateUtils.strDateToUtilDate("1992-10-07"), "13645678912@qq.com", "安徽合肥庐阳区");
		
		int result =teacherService.addTeacher(teacher);
		
		if(result!=0){
			System.out.println("老师添加成功");
		}

	}

}
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

17.4.9.2 测试删除数据

package com.cxyzxc.www.view;

import com.cxyzxc.www.service.TeacherService;
import com.cxyzxc.www.service.impl.TeacherServiceImpl;

public class TestTeacherServiceImpl02Delete {

	public static void main(String[] args) {
		
		TeacherService teacherService = new TeacherServiceImpl();
				
		int result =teacherService.deleteTeacher(1004);
		
		if(result!=0){
			System.out.println("删除成功");
		}

	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

17.4.9.3 测试修改数据

package com.cxyzxc.www.view;

import com.cxyzxc.www.entity.Teacher;
import com.cxyzxc.www.service.TeacherService;
import com.cxyzxc.www.service.impl.TeacherServiceImpl;
import com.cxyzxc.www.utils.DateUtils;

public class TestTeacherServiceImpl03Update {

	public static void main(String[] args) {

		TeacherService teacherService = new TeacherServiceImpl();

		Teacher teacher = new Teacher(1003, "王五", 30,
				DateUtils.strDateToUtilDate("1992-08-07"),
				"13677881122@qq.com", "安徽合肥政务区");

		int result = teacherService.updateTeacher(teacher);
		
		if(result!=0){
			System.out.println("修改成功");
		}
	}

}
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

17.4.9.4 测试查询一条数据

package com.cxyzxc.www.view;

import com.cxyzxc.www.entity.Teacher;
import com.cxyzxc.www.service.TeacherService;
import com.cxyzxc.www.service.impl.TeacherServiceImpl;

public class TestTeacherServiceImpl04SelectOne {

	public static void main(String[] args) {

		TeacherService teacherService = new TeacherServiceImpl();

		Teacher teacher = teacherService.selectOne(1002);

		if (teacher != null) {
			System.out.println(teacher);
		} else {
			System.out.println("你查询的老师不存在");
		}

	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

17.4.9.5 测试查询所有数据

package com.cxyzxc.www.view;

import java.util.List;

import com.cxyzxc.www.entity.Teacher;
import com.cxyzxc.www.service.TeacherService;
import com.cxyzxc.www.service.impl.TeacherServiceImpl;

public class TestTeacherServiceImpl05SelectAll {

	public static void main(String[] args) {
		
		TeacherService teacherService = new TeacherServiceImpl();

		List<Teacher> listTeacher = teacherService.selectAll();

		for (int i = 0; i < listTeacher.size(); i++) {
			System.out.println(listTeacher.get(i));
		}
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

十八、DaoUtils（泛型类型方法）

18.1 commonsUpdate方法

该方法是对数据表进行增、删、改的公共方法。与17.1小节中的代码一样，不再赘述。

18.2 commonsSelect方法

该方法是对数据表进行查询的公共方法，可以查询一条数据，也可以查询多条数据。不管是查询一条数据还是查询多条数据，都将查询到的数据封装到泛型类型的集合中。

public List<T> commonsSelect(String sql,RowMapper<T> rowMapper, Object... args) {
		Connection connection = null;
	PreparedStatement preparedStatement = null;
	ResultSet resultSet = null;
	List<T> list = new ArrayList<T>();
	// 获取数据库连接对象
	connection = DBUtils.getConnection();

	try {
		// 获取SQL语句发送对象
		preparedStatement = connection.prepareStatement(sql);
		if (args != null) {
			// 绑定参数
			for (int i = 0; i < args.length; i++) {
				preparedStatement.setObject(i + 1, args[i]);
			}
		}
		// 执行SQL语句
		resultSet = preparedStatement.executeQuery();

		while (resultSet.next()) {
			T t = rowMapper.getRow(resultSet);
			list.add(t);
		}
		return list;

	} catch (SQLException e) {
		e.printStackTrace();
	}finally {
		DBUtils.closeAll(null, preparedStatement, resultSet);
	}

	return null;
}
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

18.3 RowMapper类封装resultSet结果集

18.3.1 RowMapper接口：

package com.cxyzxc.www.advanced;

import java.sql.ResultSet;

/**
 * 该接口用来约束封装对象的ORM
 *
 */
public interface RowMapper<T> {
	
	T getRow(ResultSet resultSet);

}
1
2
3
4
5
6
7
8
9
10
11
12
13

18.3.2 RowMapper接口实现类：

package com.cxyzxc.www.advanced.impl;

/**
 * 数据封装类，专门用来处理查询返回的resultSet结果集
 * 
 * 针对每一个实体类，封装一个RowMapper类
 */
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;

import com.cxyzxc.www.advanced.RowMapper;
import com.cxyzxc.www.entity.Teacher;

public class TeacherRowMapper implements RowMapper<Teacher> {

	@Override
	public Teacher getRow(ResultSet resultSet) {
		Teacher teacher = null;
		try {
			// 返回的结果集中有哪些字段，RowMapper类是知道的，因为他是实体类的封装类
			int tid = resultSet.getInt("tid");
			String name = resultSet.getString("name");
			int age = resultSet.getInt("age");
			Date bornDate = resultSet.getDate("bornDate");
			String email = resultSet.getString("email");
			String address = resultSet.getString("address");

			teacher = new Teacher(tid, name, age, bornDate, email, address);
			return teacher;
		} catch (SQLException e) {
			e.printStackTrace();
		}

		return null;
	}

}
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

18.4 综合案例

综合案例完全按照三层架构实现，创建不同的包存放不同的接口、实现类、工具类、测试类等代码。使用数据库中的teacher表来完成综合案例。

18.4.1 com.cxyzxc.www.utils包

该包用来存放项目开发所需要的数据库连接工具类DBUtils类、日期时间转换工具类DateUtils类，数据库操作工具类DaoUtils类

18.4.1.1 DaoUtils工具类完整代码

package com.cxyzxc.www.utils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.cxyzxc.www.advanced.RowMapper;

public class DaoUtils<T> {

	// 增、删、改三个方法封装成一个方法
	public int commonsUpdate(String sql, Object... args) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;
		// 获取数据库连接对象
		connection = DBUtils.getConnection();

		try {
			// 获取SQL语句发送对象
			preparedStatement = connection.prepareStatement(sql);
			if (args != null) {
				// 绑定参数
				for (int i = 0; i < args.length; i++) {
					preparedStatement.setObject(i + 1, args[i]);
				}
			}
			// 执行SQL语句
			int result = preparedStatement.executeUpdate();
			return result;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			DBUtils.closeAll(null, preparedStatement, null);
		}
		return 0;
	}

	public List<T> commonsSelect(String sql,RowMapper<T> rowMapper, Object... args) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		List<T> list = new ArrayList<T>();
		// 获取数据库连接对象
		connection = DBUtils.getConnection();

		try {
			// 获取SQL语句发送对象
			preparedStatement = connection.prepareStatement(sql);
			if (args != null) {
				// 绑定参数
				for (int i = 0; i < args.length; i++) {
					preparedStatement.setObject(i + 1, args[i]);
				}
			}
			// 执行SQL语句
			resultSet = preparedStatement.executeQuery();

			while (resultSet.next()) {
				T t = rowMapper.getRow(resultSet);
				list.add(t);
			}
			return list;

		} catch (SQLException e) {
			e.printStackTrace();
		}finally {
			DBUtils.closeAll(null, preparedStatement, resultSet);
		}

		return null;
	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

18.4.1.2 DBUtils工具类完整代码

该类与17.4.1.2小节中的代码一样，不再赘述。

18.4.1.3 DateUtils工具类完整代码

该类与17.4.1.3小节中的代码一样，不再赘述。

18.4.2 com.cxyzxc.www.entity包

该包用来存储实体类，根据teacher表创建实体类Teacher类，与17.4.2小节中的代码一样，不再赘述。

18.4.3 com.cxyzxc.www.advanced包

该包中存放RowMapper接口，用来约束封装对象的ORM

package com.cxyzxc.www.advanced;

import java.sql.ResultSet;

/**
 * 该接口用来约束封装对象的ORM
 * 
 */
public interface RowMapper<T> {
	
	T getRow(ResultSet resultSet);

}
1
2
3
4
5
6
7
8
9
10
11
12
13

18.4.4 com.cxyzxc.www.advanced.impl包

package com.cxyzxc.www.advanced.impl;

/**
 * 数据封装类，专门用来处理查询返回的resultSet结果集
 * 
 * 针对每一个实体类，封装一个RowMapper类
 */
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;

import com.cxyzxc.www.advanced.RowMapper;
import com.cxyzxc.www.entity.Teacher;

public class TeacherRowMapper implements RowMapper<Teacher> {

	@Override
	public Teacher getRow(ResultSet resultSet) {
		Teacher teacher = null;
		try {
			// 返回的结果集中有哪些字段，RowMapper类是知道的，因为他是实体类的封装类
			int tid = resultSet.getInt("tid");
			String name = resultSet.getString("name");
			int age = resultSet.getInt("age");
			Date bornDate = resultSet.getDate("bornDate");
			String email = resultSet.getString("email");
			String address = resultSet.getString("address");

			teacher = new Teacher(tid, name, age, bornDate, email, address);
			return teacher;
		} catch (SQLException e) {
			e.printStackTrace();
		}

		return null;
	}

}
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

18.4.5 com.cxyzxc.www.dao包

该包用来存放操作数据库的接口

package com.cxyzxc.www.dao;

import java.util.List;

import com.cxyzxc.www.entity.Teacher;

public interface TeacherDao {
	//增
	int insert(Teacher teacher);
	
	//删
	int delete(int tid);
	
	//改
	int update(Teacher teacher);
	
	//查单个
	Teacher selectOne(int tid);
	
	//查所有
	List<Teacher> selectAll();
	

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

18.4.6 com.cxyzxc.www.dao.impl包

该包用来存放数据库操作接口的实现类

package com.cxyzxc.www.dao.impl;

import java.util.ArrayList;
import java.util.List;

import com.cxyzxc.www.advanced.RowMapper;
import com.cxyzxc.www.advanced.impl.TeacherRowMapper;
import com.cxyzxc.www.dao.TeacherDao;
import com.cxyzxc.www.entity.Teacher;
import com.cxyzxc.www.utils.DaoUtils;

/**
 * 
 */
public class TeacherDaoImpl implements TeacherDao {
	/*
	 * （1）该类中提供对teacher表进行增、删、改、查单个、查所有5个方法。
	 * 
	 * （2）该类中的代码只做数据库访问操作，不做任何业务逻辑操作。
	 * 
	 * （3）该类只对数据库一张表进行操作，从而实现复用
	 */

	DaoUtils<Teacher> daoUtils = new DaoUtils<Teacher>();
	RowMapper<Teacher> rowMapper = new TeacherRowMapper();

	// 新增：向teacher表中插入一条数据（一条数据对应一个Teacher对象）,插入成功，返回一个受影响行数值（int类型）
	@Override
	public int insert(Teacher teacher) {

		String sql = "insert into `teacher`(name,age,bornDate,email,address) values(?,?,?,?,?);";

		// 赋值
		Object[] args = { teacher.getName(), teacher.getAge(),
				teacher.getBornDate(), teacher.getEmail(), teacher.getAddress() };

		return daoUtils.commonsUpdate(sql, args);
	}

	// 删除：根据教师tid删除一条数据,删除成功，返回一个受影响行数值（int类型）
	@Override
	public int delete(int tid) {

		String sql = "delete from teacher where tid = ?;";
		return daoUtils.commonsUpdate(sql, tid);

	}

	// 修改：修改teacher表中的数据，可能对任意的一个字段进行修改，所以方法中直接传递一个对象进行修改,修改成功，返回一个受影响行数值（int类型）
	@Override
	public int update(Teacher teacher) {

		String sql = "update teacher set name = ?,age = ?,bornDate = ?,email = ?,address = ? where tid = ?;";

		Object[] args = { teacher.getName(), teacher.getAge(),
				teacher.getBornDate(), teacher.getEmail(),
				teacher.getAddress(), teacher.getTid() };
		return daoUtils.commonsUpdate(sql, args);
	}

	// 查询单个：根据教师tid查询一条数据，查询成功返回一个结果集（ResultSet类型）,从结果集中取出元素，封装成一个Teacher对象，将该对象返回
	@Override
	public Teacher selectOne(int tid) {

		String sql = "select * from teacher where tid = ?;";
		List<Teacher> objectList = daoUtils.commonsSelect(sql, rowMapper, tid);

		if (objectList.size() == 1) {
			Teacher teacher = (Teacher) objectList.get(0);
			return teacher;
		} else {
			return null;
		}
	}

	// 查询所有：将teacher表中的所有数据全部查询出来，查询成功返回一个结果集（ResultSet类型）,从结果集中取出元素，封装成多个Teacher对象，将多个对象存储在集合中，返回这个集合
	@Override
	public List<Teacher> selectAll() {

		List<Teacher> teacherList = new ArrayList<Teacher>();
		String sql = "select * from teacher;";
		Object[] args = null;
		List<Teacher> list = daoUtils.commonsSelect(sql, rowMapper, args);
		for (int i = 0; i < list.size(); i++) {
			teacherList.add(list.get(i));
		}
		return teacherList;
	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

18.4.7 com.cxyzxc.www.service包

该包用来存储业务层接口代码，与17.4.7小节代码一直，这里不再赘述。

18.4.8 com.cxyzxc.www.service.impl包

该包用来存储service层实现类代码，与17.4.8小节中代码一致，这里不再赘述。

18.4.9 com.cxy.zxc.view包

该包用来存储测试类

18.4.9.1 测试插入数据

与17.4.9.1小节代码一致，不再赘述。

18.4.9.2 测试删除数据

与17.4.9.2小节代码一致，不再赘述。

18.4.9.3 测试修改数据

与17.4.9.3小节代码一致，不再赘述。

18.4.9.4 测试查询一条数据

与17.4.9.4小节代码一致，不再赘述。

18.4.9.5 测试查询所有数据

与17.4.9.5小节代码一致，不再赘述。

十九、Druid连接池

19.1 连接池思想

在程序初始化时，提前创建好指定数量的数据库连接对象存储在“池子”中（这个池子称为“连接池”），当需要连接数据库的时候，从这个“池子”中取出一个连接对象使用，使用完毕后，不会将这个连接对象关闭，而是将这个连接对象放回“池子”中，实现复用，节省资源。

19.2 Druid连接池使用步骤

19.2.1 引入相关jar包

在lib文件夹中引入druid-1.1.5.jar文件和mysql-connector-java-5.1.0-bin.jar文件，并将两个jar文件配置到项目中。

19.2.2 创建database.properties配置文件

在src文件夹下创建database.properties配置文件，配置文件中内容如下：

# 连接设置
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcdatabase
username=root
password=123456

# 初始化连接，连接池连接对象数量
initialSize=10

#最大连接数
maxActive=30

#最小空闲连接
maxIdle=5

#超时等待时间（毫秒为单位）
maxWait=3000
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

19.2.3 编写连接池工具类

package com.cxyzxc.www.utils;

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;

public class DBUtils {

	// 声明一个连接池对象
	private static DruidDataSource druidDataSource;

	static {
		// 实例化配置文件对象
		Properties properties = new Properties();

		try {
			// 加载配置文件内容
			InputStream is = DBUtils.class
					.getResourceAsStream("/database.properties");
			properties.load(is);
			// 创建连接池
			druidDataSource = (DruidDataSource) DruidDataSourceFactory
					.createDataSource(properties);
		} catch (IOException e) {
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	// 获取连接对象
	public static Connection getConnection() {
		try {
			// 通过连接池获得连接对象
			return druidDataSource.getConnection();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return null;
	}

	// 释放资源，将连接对象放入连接池中
	public static void closeAll(Connection connection, Statement statement,
			ResultSet resultSet) {
		try {
			if (resultSet != null) {
				resultSet.close();
			}
			if (statement != null) {
				statement.close();
			}

			if (connection != null) {
				// 使用完连接对象后，将连接对象还给连接池,这里的close()方法是DruidPooledConnection实现类里的close()方法，将connection连接对象还给连接池
				connection.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

}
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
60
61
62
63
64
65
66
67
68
69

19.3 Druid连接池测试

package com.cxyzxc.www.utils;

import java.sql.Connection;

public class Test {

	public static void main(String[] args) {

		// 获取20个连接对象，输出连接对象，地址值不同
		for (int i = 1; i <= 20; i++) {
			Connection connection = DBUtils.getConnection();
			System.out.println(connection);

			// 调用关闭连接对象的方法后，发现获取的20个连接对象地址值是同一个，说明每次从连接池中取出的连接对象是同一个
			// DBUtils.closeAll(connection, null, null);

		}

	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

二十、Apache的DBUtils使用

前面的DaoUtils工具类是我们经过千难万阻自己封装的，也有一些组织给我们封装DBUtils工具类，比如Apache组织提供了一个对JDBC进行简单封装的开源工具类库Commons DbUtils类，使用它能够简化JDBC应用程序的开发，同时也不影响程序的性能。

20.1 Apache DBUtils介绍

20.1.1 Apache DBUtils特征

Apache DBUtils是java编程中的数据库操作实用工具，小巧简单实用，主要特征有：
1）对于数据表的读操作，他可以把结果转换成List，Array，Set等java集合，便于程序员操作；
2）对于数据表的写操作，也变得很简单（只需写sql语句）
3）可以使用数据源，使用JNDI，数据库连接池等技术来优化性能–重用已经构建好的数据库连接对象，而不像php，asp那样，费时费力的不断重复的构建和析构这样的对象。

20.1.2 Apache DbUtils主要组成

1）ResultSetHandler接口：转换类型接口

• BeanHandler类：实现类，把一条记录转换成对象。
• BeanListHandler类：实现类，把多条记录转换成List集合。
• ScalarHandler类：实现类，适合获取一行一列的数据。

2）QueryRunner类：执行SQL语句的类

• update()方法：增、删、改
• query()方法：查询

20.1.3 Apache DbUtils使用步骤

1）创建lib文件夹，导入需要的jar包，并将其配置到项目中

• mysql-connector-java-5.1.0-bin.jar
• druid-1.1.5.jar
• commons-dbutils-1.7.jar

2）在src文件夹下面创建database.properties配置文件

# 连接设置
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcdatabase
username=root
password=123456

# 初始化连接，连接池连接对象数量
initialSize=10

#最大连接数
maxActive=30

#最小空闲连接
maxIdle=5

#超时等待时间（毫秒为单位）
maxWait=3000
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3）编写DBUtils连接池工具类

package com.cxyzxc.www.utils;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

import javax.sql.DataSource;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;

public class DBUtils {

	// 声明一个连接池对象
	private static DruidDataSource druidDataSource;

	static {
		// 实例化配置文件对象
		Properties properties = new Properties();

		try {
			// 加载配置文件内容
			InputStream is = DBUtils.class
					.getResourceAsStream("/database.properties");
			properties.load(is);
			// 创建连接池
			druidDataSource = (DruidDataSource) DruidDataSourceFactory
					.createDataSource(properties);
		} catch (IOException e) {
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	//返回一个数据源
	public static DataSource getDataSource(){
		return druidDataSource;
	}

}
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

20.2 综合案例

20.2.1 创建product表

CREATE TABLE IF NOT EXISTS `product` (
`pid` INT PRIMARY KEY AUTO_INCREMENT COMMENT '产品编号',
`pname` VARCHAR(20) NOT NULL COMMENT '产品名称',
`price` DOUBLE NOT NULL COMMENT '产品价格',
`birthday` DATE NOT NULL COMMENT '产品生产日期'
);
1
2
3
4
5
6

20.2.2 向表中添加数据

INSERT INTO `product`(`pid`,`pname`,`price`,`birthday`)VALUES(1001,'虎皮凤爪',20.5,'2022-06-12');

INSERT INTO `product`(`pid`,`pname`,`price`,`birthday`)VALUES(1002,'卧龙锅巴',18.5,'2022-09-22');
1
2
3

20.2.3 创建实体类Product

package com.cxyzxc.www.entity;

import java.util.Date;

public class Product {

	private int pid;

	private String pname;

	private double price;

	private Date birthday;

	public Product() {
		super();
	}

	public Product(String pname, double price, Date birthday) {
		super();
		this.pname = pname;
		this.price = price;
		this.birthday = birthday;
	}

	public Product(int pid, String pname, double price, Date birthday) {
		super();
		this.pid = pid;
		this.pname = pname;
		this.price = price;
		this.birthday = birthday;
	}

	public int getPid() {
		return pid;
	}

	public void setPid(int pid) {
		this.pid = pid;
	}

	public String getPname() {
		return pname;
	}

	public void setPname(String pname) {
		this.pname = pname;
	}

	public double getPrice() {
		return price;
	}

	public void setPrice(double price) {
		this.price = price;
	}

	public Date getBirthday() {
		return birthday;
	}

	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}

	@Override
	public String toString() {
		return "Product [pid=" + pid + ", pname=" + pname + ", price=" + price
				+ ", birthday=" + birthday + "]";
	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72

20.2.4 创建ProductDao接口

package com.cxyzxc.www.dao;

import java.util.List;

import com.cxyzxc.www.entity.Product;

public interface ProductDao {
	
	//添加
	int insert(Product product);
	
	//删除
	int delete(int pid);
	
	//修改
	int update(Product product);
	
	//查询单个
	Product selectOne(int pid);
	
	//查询所有
	List<Product> selectAll();

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

20.2.4 创建ProductDaoImpl实现类

package com.cxyzxc.www.dao.impl;

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

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

import com.cxyzxc.www.dao.ProductDao;
import com.cxyzxc.www.entity.Product;
import com.cxyzxc.www.utils.DBUtils;
import com.cxyzxc.www.utils.DateUtils;

public class ProductDaoImpl implements ProductDao {
	// 创建QueryRunner对象，并传递一个数据源对象
	private QueryRunner queryRunner = new QueryRunner(DBUtils.getDataSource());

	@Override
	public int insert(Product product) {

		String sql = "INSERT INTO `product`(`pname`,`price`,`birthday`)VALUES(?,?,?);";
		Object[] args = { product.getPname(), product.getPrice(),
				DateUtils.utilDateToSqlDate(product.getBirthday()) };

		try {
			return queryRunner.update(sql, args);
		} catch (SQLException e) {
			e.printStackTrace();
		}

		return 0;
	}

	@Override
	public int delete(int pid) {
		String sql = "DELETE FROM `product` WHERE `pid` = ?;";
		try {
			return queryRunner.update(sql, pid);
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return 0;
	}

	@Override
	public int update(Product product) {

		String sql = "UPDATE `product` SET `pname` = ?,`price`=?,`birthday`=? WHERE `pid`=?;";

		Object[] args = { product.getPname(), product.getPrice(),
				DateUtils.utilDateToSqlDate(product.getBirthday()),
				product.getPid() };

		try {
			return queryRunner.update(sql, args);
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return 0;
	}

	@Override
	public Product selectOne(int pid) {
		// 查询一个数据，使用BeanHandler将记录转换为对象
		BeanHandler<Product> product = new BeanHandler<Product>(Product.class);
		String sql = "SELECT * FROM `product` WHERE `pid`=?;";
		try {
			return queryRunner.query(sql, product, pid);
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return null;
	}

	@Override
	public List<Product> selectAll() {
		// 查询一个数据，使用BeanHandler将记录转换为对象
		BeanListHandler<Product> productList = new BeanListHandler<Product>(Product.class);
		String sql = "SELECT * FROM `product`;";
		try {
			return queryRunner.query(sql, productList);
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return null;
	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

20.2.5 创建ProductService接口

package com.cxyzxc.service;

import java.util.List;

import com.cxyzxc.www.entity.Product;

public interface ProductService {
	//增加
	int addProduct(Product product);
	
	//删除
	int deleteProduct(int pid);
	
	//修改
	int updateProduct(Product product);
	
	//查询单个
	Product selectOneProduct(int pid);
	
	//查询所有
	List<Product> selectAllProduct();
	

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

20.2.6 创建ProductServiceImpl实现类

package com.cxyzxc.service.impl;

import java.util.List;

import com.cxyzxc.service.ProductService;
import com.cxyzxc.www.dao.ProductDao;
import com.cxyzxc.www.dao.impl.ProductDaoImpl;
import com.cxyzxc.www.entity.Product;

public class ProductServiceImpl implements ProductService {
	ProductDao productDao = new ProductDaoImpl();

	@Override
	public int addProduct(Product product) {
		// 查询添加的商品是否存在
		Product pd = productDao.selectOne(product.getPid());
		if (pd == null) {
			return productDao.insert(product);
		} else {
			System.out.println("商品已经存在，不能重复添加");
		}

		return 0;
	}

	@Override
	public int deleteProduct(int pid) {
		// 查询添加的商品是否存在
		Product pd = productDao.selectOne(pid);
		if (pd != null) {
			return productDao.delete(pid);
		} else {
			System.out.println("商品不存在，不能删除");
		}
		return 0;
	}

	@Override
	public int updateProduct(Product product) {
		// 查询添加的商品是否存在
		Product pd = productDao.selectOne(product.getPid());
		if (pd!= null) {
			return productDao.update(product);
		} else {
			System.out.println("商品不存在，不能修改");
		}
		return 0;
	}

	@Override
	public Product selectOneProduct(int pid) {
		Product product =productDao.selectOne(pid);
		if(product!=null){
			return product;
		}else{
			System.out.println("没有你要查找产品，查找失败");
		}
		return null;
	}

	@Override
	public List<Product> selectAllProduct() {
		 List<Product> productList = productDao.selectAll();
		 if(productList.size()!=0){
			 return productList;
		 }else{
			 System.out.println("数据库为空，没有产品");
		 }
		return null;
	}

}
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
60
61
62
63
64
65
66
67
68
69
70
71
72

20.2.7 创建测试类

20.2.7.1 测试插入数据

package com.cxyzxc.www.view;

import com.cxyzxc.service.ProductService;
import com.cxyzxc.service.impl.ProductServiceImpl;
import com.cxyzxc.www.entity.Product;
import com.cxyzxc.www.utils.DateUtils;

public class Test01InsertProduct {

	public static void main(String[] args) {
		//创建ProductService引用，指向ProductServiceImpl实现类
		ProductService productService = new ProductServiceImpl();

		//增加产品
		 Product product = new Product(1003,"流心威化饼干", 13.5, DateUtils.strDateToUtilDate("2022-11-10"));
		 
		 int result = productService.addProduct(product);
		 
		 String str = result==1?"商品添加成功":"商品添加失败";
		 System.out.println(str);

	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

20.2.7.2 测试删除数据

package com.cxyzxc.www.view;

import com.cxyzxc.service.ProductService;
import com.cxyzxc.service.impl.ProductServiceImpl;

public class Test02DeleteProduct {

	public static void main(String[] args) {
		// 创建ProductService引用，指向ProductServiceImpl实现类
		ProductService productService = new ProductServiceImpl();

		int result = productService.deleteProduct(1003);

		String str = result == 1 ? "删除成功" : "删除失败";
		System.out.println(str);

	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

20.2.7.3 测试修改数据

package com.cxyzxc.www.view;

import com.cxyzxc.service.ProductService;
import com.cxyzxc.service.impl.ProductServiceImpl;
import com.cxyzxc.www.entity.Product;
import com.cxyzxc.www.utils.DateUtils;

public class Test03UpdateProduct {

	public static void main(String[] args) {
		// 创建ProductService引用，指向ProductServiceImpl实现类
		ProductService productService = new ProductServiceImpl();

		// 增加产品
		Product product = new Product(1002, "流心威化饼干", 13.5,
				DateUtils.strDateToUtilDate("2022-11-10"));

		int result = productService.updateProduct(product);
		String str = result == 1 ? "修改成功" : "修改失败";
		System.out.println(str);

	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

20.2.7.4 测试查询一条数据

package com.cxyzxc.www.view;

import com.cxyzxc.service.ProductService;
import com.cxyzxc.service.impl.ProductServiceImpl;
import com.cxyzxc.www.entity.Product;

public class Test04SelectOneProduct {

	public static void main(String[] args) {
		// 创建ProductService引用，指向ProductServiceImpl实现类
		ProductService productService = new ProductServiceImpl();

		Product product = productService.selectOneProduct(1003);

		if (product != null) {
			System.out.println(product);
		} else {
			System.out.println("你要查询的商品不存在");
		}

	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

20.2.7.5 测试查询所有数据

package com.cxyzxc.www.view;

import java.util.List;

import com.cxyzxc.service.ProductService;
import com.cxyzxc.service.impl.ProductServiceImpl;
import com.cxyzxc.www.entity.Product;

public class Test05SelectAllProduct {

	public static void main(String[] args) {
		// 创建ProductService引用，指向ProductServiceImpl实现类
		ProductService productService = new ProductServiceImpl();

		List<Product> productList = productService.selectAllProduct();
		for (int i = 0; i < productList.size(); i++) {
			System.out.println(productList.get(i));
		}

	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

自此，JDBC所有知识点学习完毕。希望大家多看笔记多理解笔记，多写写笔记中的代码，熟练掌握所有技能。

urce(properties);
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}

//返回一个数据源
public static DataSource getDataSource(){
	return druidDataSource;
}
1
2
3
4

}

## 20.2 综合案例

### 20.2.1 创建product表

1
2
3
4
5

CREATE TABLE IF NOT EXISTS product (
pid INT PRIMARY KEY AUTO_INCREMENT COMMENT ‘产品编号’,
pname VARCHAR(20) NOT NULL COMMENT ‘产品名称’,
price DOUBLE NOT NULL COMMENT ‘产品价格’,
birthday DATE NOT NULL COMMENT ‘产品生产日期’
);

### 20.2.2 向表中添加数据

1
2
3

INSERT INTO product(pid,pname,price,birthday)VALUES(1001,‘虎皮凤爪’,20.5,‘2022-06-12’);

INSERT INTO product(pid,pname,price,birthday)VALUES(1002,‘卧龙锅巴’,18.5,‘2022-09-22’);

### 20.2.3 创建实体类Product

1
2
3

package com.cxyzxc.www.entity;

import java.util.Date;

public class Product {

private int pid;

private String pname;

private double price;

private Date birthday;

public Product() {
	super();
}

public Product(String pname, double price, Date birthday) {
	super();
	this.pname = pname;
	this.price = price;
	this.birthday = birthday;
}

public Product(int pid, String pname, double price, Date birthday) {
	super();
	this.pid = pid;
	this.pname = pname;
	this.price = price;
	this.birthday = birthday;
}

public int getPid() {
	return pid;
}

public void setPid(int pid) {
	this.pid = pid;
}

public String getPname() {
	return pname;
}

public void setPname(String pname) {
	this.pname = pname;
}

public double getPrice() {
	return price;
}

public void setPrice(double price) {
	this.price = price;
}

public Date getBirthday() {
	return birthday;
}

public void setBirthday(Date birthday) {
	this.birthday = birthday;
}

@Override
public String toString() {
	return "Product [pid=" + pid + ", pname=" + pname + ", price=" + price
			+ ", birthday=" + birthday + "]";
}
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
60
61
62
63
64

}

### 20.2.4 创建ProductDao接口

1
2
3

package com.cxyzxc.www.dao;

import java.util.List;

import com.cxyzxc.www.entity.Product;

public interface ProductDao {

//添加
int insert(Product product);

//删除
int delete(int pid);

//修改
int update(Product product);

//查询单个
Product selectOne(int pid);

//查询所有
List<Product> selectAll();
1
2
3
4
5
6
7
8
9
10
11
12
13
14

}

### 20.2.4 创建ProductDaoImpl实现类

1
2
3

package com.cxyzxc.www.dao.impl;

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

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

import com.cxyzxc.www.dao.ProductDao;
import com.cxyzxc.www.entity.Product;
import com.cxyzxc.www.utils.DBUtils;
import com.cxyzxc.www.utils.DateUtils;

public class ProductDaoImpl implements ProductDao {
// 创建QueryRunner对象，并传递一个数据源对象
private QueryRunner queryRunner = new QueryRunner(DBUtils.getDataSource());

@Override
public int insert(Product product) {

	String sql = "INSERT INTO `product`(`pname`,`price`,`birthday`)VALUES(?,?,?);";
	Object[] args = { product.getPname(), product.getPrice(),
			DateUtils.utilDateToSqlDate(product.getBirthday()) };

	try {
		return queryRunner.update(sql, args);
	} catch (SQLException e) {
		e.printStackTrace();
	}

	return 0;
}

@Override
public int delete(int pid) {
	String sql = "DELETE FROM `product` WHERE `pid` = ?;";
	try {
		return queryRunner.update(sql, pid);
	} catch (SQLException e) {
		e.printStackTrace();
	}
	return 0;
}

@Override
public int update(Product product) {

	String sql = "UPDATE `product` SET `pname` = ?,`price`=?,`birthday`=? WHERE `pid`=?;";

	Object[] args = { product.getPname(), product.getPrice(),
			DateUtils.utilDateToSqlDate(product.getBirthday()),
			product.getPid() };

	try {
		return queryRunner.update(sql, args);
	} catch (SQLException e) {
		e.printStackTrace();
	}
	return 0;
}

@Override
public Product selectOne(int pid) {
	// 查询一个数据，使用BeanHandler将记录转换为对象
	BeanHandler<Product> product = new BeanHandler<Product>(Product.class);
	String sql = "SELECT * FROM `product` WHERE `pid`=?;";
	try {
		return queryRunner.query(sql, product, pid);
	} catch (SQLException e) {
		e.printStackTrace();
	}
	return null;
}

@Override
public List<Product> selectAll() {
	// 查询一个数据，使用BeanHandler将记录转换为对象
	BeanListHandler<Product> productList = new BeanListHandler<Product>(Product.class);
	String sql = "SELECT * FROM `product`;";
	try {
		return queryRunner.query(sql, productList);
	} catch (SQLException e) {
		e.printStackTrace();
	}
	return null;
}
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
60
61
62
63
64
65
66
67
68
69

}

### 20.2.5 创建ProductService接口

1
2
3

package com.cxyzxc.service;

import java.util.List;

import com.cxyzxc.www.entity.Product;

public interface ProductService {
//增加
int addProduct(Product product);

//删除
int deleteProduct(int pid);

//修改
int updateProduct(Product product);

//查询单个
Product selectOneProduct(int pid);

//查询所有
List<Product> selectAllProduct();
1
2
3
4
5
6
7
8
9
10
11

}

### 20.2.6 创建ProductServiceImpl实现类

1
2
3

package com.cxyzxc.service.impl;

import java.util.List;

import com.cxyzxc.service.ProductService;
import com.cxyzxc.www.dao.ProductDao;
import com.cxyzxc.www.dao.impl.ProductDaoImpl;
import com.cxyzxc.www.entity.Product;

public class ProductServiceImpl implements ProductService {
ProductDao productDao = new ProductDaoImpl();

@Override
public int addProduct(Product product) {
	// 查询添加的商品是否存在
	Product pd = productDao.selectOne(product.getPid());
	if (pd == null) {
		return productDao.insert(product);
	} else {
		System.out.println("商品已经存在，不能重复添加");
	}

	return 0;
}

@Override
public int deleteProduct(int pid) {
	// 查询添加的商品是否存在
	Product pd = productDao.selectOne(pid);
	if (pd != null) {
		return productDao.delete(pid);
	} else {
		System.out.println("商品不存在，不能删除");
	}
	return 0;
}

@Override
public int updateProduct(Product product) {
	// 查询添加的商品是否存在
	Product pd = productDao.selectOne(product.getPid());
	if (pd!= null) {
		return productDao.update(product);
	} else {
		System.out.println("商品不存在，不能修改");
	}
	return 0;
}

@Override
public Product selectOneProduct(int pid) {
	Product product =productDao.selectOne(pid);
	if(product!=null){
		return product;
	}else{
		System.out.println("没有你要查找产品，查找失败");
	}
	return null;
}

@Override
public List<Product> selectAllProduct() {
	 List<Product> productList = productDao.selectAll();
	 if(productList.size()!=0){
		 return productList;
	 }else{
		 System.out.println("数据库为空，没有产品");
	 }
	return null;
}
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

}

### 20.2.7 创建测试类

#### 20.2.7.1 测试插入数据

1
2
3
4
5

package com.cxyzxc.www.view;

import com.cxyzxc.service.ProductService;
import com.cxyzxc.service.impl.ProductServiceImpl;
import com.cxyzxc.www.entity.Product;
import com.cxyzxc.www.utils.DateUtils;

public class Test01InsertProduct {

public static void main(String[] args) {
	//创建ProductService引用，指向ProductServiceImpl实现类
	ProductService productService = new ProductServiceImpl();

	//增加产品
	 Product product = new Product(1003,"流心威化饼干", 13.5, DateUtils.strDateToUtilDate("2022-11-10"));
	 
	 int result = productService.addProduct(product);
	 
	 String str = result==1?"商品添加成功":"商品添加失败";
	 System.out.println(str);

}
1
2
3
4
5
6
7
8
9
10
11
12
13

}

#### 20.2.7.2 测试删除数据

1
2
3

package com.cxyzxc.www.view;

import com.cxyzxc.service.ProductService;
import com.cxyzxc.service.impl.ProductServiceImpl;

public class Test02DeleteProduct {

public static void main(String[] args) {
	// 创建ProductService引用，指向ProductServiceImpl实现类
	ProductService productService = new ProductServiceImpl();

	int result = productService.deleteProduct(1003);

	String str = result == 1 ? "删除成功" : "删除失败";
	System.out.println(str);

}
1
2
3
4
5
6
7
8
9
10

}

#### 20.2.7.3 测试修改数据

1
2
3

package com.cxyzxc.www.view;

import com.cxyzxc.service.ProductService;
import com.cxyzxc.service.impl.ProductServiceImpl;
import com.cxyzxc.www.entity.Product;
import com.cxyzxc.www.utils.DateUtils;

public class Test03UpdateProduct {

public static void main(String[] args) {
	// 创建ProductService引用，指向ProductServiceImpl实现类
	ProductService productService = new ProductServiceImpl();

	// 增加产品
	Product product = new Product(1002, "流心威化饼干", 13.5,
			DateUtils.strDateToUtilDate("2022-11-10"));

	int result = productService.updateProduct(product);
	String str = result == 1 ? "修改成功" : "修改失败";
	System.out.println(str);

}
1
2
3
4
5
6
7
8
9
10
11
12
13

}

#### 20.2.7.4 测试查询一条数据

1
2
3

package com.cxyzxc.www.view;

import com.cxyzxc.service.ProductService;
import com.cxyzxc.service.impl.ProductServiceImpl;
import com.cxyzxc.www.entity.Product;

public class Test04SelectOneProduct {

public static void main(String[] args) {
	// 创建ProductService引用，指向ProductServiceImpl实现类
	ProductService productService = new ProductServiceImpl();

	Product product = productService.selectOneProduct(1003);

	if (product != null) {
		System.out.println(product);
	} else {
		System.out.println("你要查询的商品不存在");
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13

}

#### 20.2.7.5 测试查询所有数据

1
2
3

package com.cxyzxc.www.view;

import java.util.List;

import com.cxyzxc.service.ProductService;
import com.cxyzxc.service.impl.ProductServiceImpl;
import com.cxyzxc.www.entity.Product;

public class Test05SelectAllProduct {

public static void main(String[] args) {
	// 创建ProductService引用，指向ProductServiceImpl实现类
	ProductService productService = new ProductServiceImpl();

	List<Product> productList = productService.selectAllProduct();
	for (int i = 0; i < productList.size(); i++) {
		System.out.println(productList.get(i));
	}

}
1
2
3
4
5
6
7
8
9
10

}

**自此，JDBC所有知识点学习完毕。希望大家多看笔记多理解笔记，多写写笔记中的代码，熟练掌握所有技能。**

1
2
3
4
5