B/S架构是什么？
- B/S架构，即Brower/Server(浏览器/服务器)架构。它由逻辑上相互分离的表示层、业务层和数据层构成。表示层向客户提供数据，业务层实施业务和数据规则，数据层定义数据访问标准；三层体系结构中的核心是组件对象模型。
- B/S系统统一了客户端，无需特殊安装，拥有Web浏览器即可；它将系统功能实现的核心部分集中到服务器上，简化了系统的开发、维护和使用。可以在服务器上安装数据库，然后浏览器通过mysql等数据库来进行数据交互。
C/S架构是什么？
C/S架构，即Client/Server(客户端/服务器)架构，是一个典型的两层架构。通过将任务合理分配到客户端和服务器，降低了系统的通讯开销，需要安装客户端才可进行管理操作。
客户端包含一个或多个运行在用户计算机上的程序，有两个服务器，一个是数据库服务器，通过数据库连接客户端访问服务器端数据；另一种是套接字服务器，服务器通过套接字程序与客户端通信。
客户端和服务器端的程序不同，用户的程序主要在客户端，服务器端主要提供数据管理、数据共享、数据及系统维护和并发控制等，客户端程序主要完成用户的具体的业务。
开发比较容易，操作简便，但应用程序的升级和客户端程序的维护较为困难。

B/S架构和C/S架构的区别

C/S一般建立在专用的网络上，是小范围里的网络环境，通过专门服务器提供连接和数据交换服务；一般面向相对固定的用户群，对信息安全的控制能力很强。B/S 建立在广域网之上的，不必有专门的网络硬件环境；面向是不可知的用户群，对安全的控制能力相对弱。

1、建立基础不同

C/S是建立在局域网的基础上的；而，B/S是建立在广域网的基础上的。

2、硬件环境不同

C/S 一般建立在专用的网络上，小范围里的网络环境，局域网之间再通过专门服务器提供连接和数据交换服务。

B/S 建立在广域网之上的，不必有专门的网络硬件环境，例与电话上网，租用设备，信息自己管理。有比C/S更强的适应范围, 一般只要有操作系统和浏览器就行。

3、对安全要求不同

C/S 一般面向相对固定的用户群，对信息安全的控制能力很强。一般高度机密的信息系统采用C/S 结构适宜，可以通过B/S发布部分可公开信息.

B/S 建立在广域网之上， 对安全的控制能力相对弱， 面向是不可知的用户群。

4、对程序架构不同

C/S 程序更加注重流程， 可以对权限多层次校验， 对系统运行速度可以较少考虑。

B/S对安全以及访问速度的多重考虑， 建立在需要更加优化的基础之上。 比C/S有更高的要求 B/S结构的程序架构是发展的趋势， 从MS的。Net系列的BizTalk 2000 Exchange 2000等， 全面支持网络的构件搭建的系统。 SUN 和IBM推的JavaBean 构件技术等，使 B/S更加成熟。 例如智赢IPOWER，采用AJAX和数据存储优化技术，相比一般B/S架构软件速度提高30%至99%。

5、软件重用不同

C/S 程序不可避免的考虑整体性， 构件的重用性不如在B/S要求下的构件的重用性好。

B/S对的多重结构，要求构件相对独立的功能， 能够相对较好的重用。

6、系统维护不同

C/S 程序由于整体性， 必须整体考察， 处理出现的问题以及系统升级。 升级难， 可能是再做一个全新的系统

B/S 构件组成，方面构件个别的更换，实现系统的无缝升级。 系统维护开销减到最小；用户从网上自己下载安装就可以实现升级。

7、处理问题不同

C/S 程序可以处理用户面固定， 并且在相同区域， 安全要求高需求， 与操作系统相关。 应该都是相同的系统

B/S 建立在广域网上， 面向不同的用户群， 分散地域， 这是C/S无法作到的；与操作系统平台关系最小。

8、用户接口不同

C/S 多是建立的Window平台上，表现方法有限，对程序员普遍要求较高

B/S 建立在浏览器上， 通过WEB服务或其他公共可识别描述语言可跨平台，使用更灵活。不仅可应用在Window平台上，还可应用于unix/Linux等平台。

9、信息流不同

C/S 程序一般是典型的中央集权的机械式处理， 交互性相对低
B/S 信息流向可变化， B-B B-C B-G等信息、流向的变化， 更象交易中心。

参考：https://www.php.cn/faq/416654.html

JavaWeb技术概览

在这里插入图片描述

第1章：JDBC概述

1.1 数据的持久化

持久化(persistence)：把数据保存到可掉电式存储设备中以供之后使用。大多数情况下，特别是企业级应用，数据持久化意味着将内存中的数据保存到硬盘上加以”固化”，而持久化的实现过程大多通过各种关系数据库来完成。
持久化的主要应用是将内存中的数据存储在关系型数据库中，当然也可以存储在磁盘文件、XML数据文件中。

在这里插入图片描述

1.2 Java中的数据存储技术

在Java中，数据库存取技术可分为如下几类：
- JDBC直接访问数据库
- JDO (Java Data Object )技术
- 第三方O/R工具，如Hibernate, Mybatis 等
JDBC是java访问数据库的基石，JDO、Hibernate、MyBatis等只是更好的封装了JDBC。

1.3 JDBC介绍

JDBC(Java Database Connectivity)是一个独立于特定数据库管理系统、通用的SQL数据库存取和操作的公共接口（一组API），定义了用来访问数据库的标准Java类库，（java.sql,javax.sql）使用这些类库可以以一种标准的方法、方便地访问数据库资源。
JDBC为访问不同的数据库提供了一种统一的途径，为开发者屏蔽了一些细节问题。
JDBC的目标是使Java程序员使用JDBC可以连接任何提供了JDBC驱动程序的数据库系统，这样就使得程序员无需对特定的数据库系统的特点有过多的了解，从而大大简化和加快了开发过程。
如果没有JDBC，那么Java程序访问数据库时是这样的：

在这里插入图片描述

有了JDBC，Java程序访问数据库时是这样的：

在这里插入图片描述

总结如下：

在这里插入图片描述

1.4 JDBC体系结构

JDBC接口（API）包括两个层次：
- 面向应用的API：Java API，抽象接口，供应用程序开发人员使用（连接数据库，执行SQL语句，获得结果）。
- 面向数据库的API：Java Driver API，供开发商开发数据库驱动程序用。

JDBC是sun公司提供一套用于数据库操作的接口，java程序员只需要面向这套接口编程即可。

不同的数据库厂商，需要针对这套接口，提供不同实现。不同的实现的集合，即为不同数据库的驱动。 ————面向接口编程

1.5 JDBC程序编写步骤

在这里插入图片描述

补充：ODBC(Open Database Connectivity，开放式数据库连接)，是微软在Windows平台下推出的。使用者在程序中只需要调用ODBC API，由 ODBC 驱动程序将调用转换成为对特定的数据库的调用请求。

第2章：获取数据库连接

2.1 要素一：Driver接口实现类

2.1.1 Driver接口介绍

java.sql.Driver 接口是所有 JDBC 驱动程序需要实现的接口。这个接口是提供给数据库厂商使用的，不同数据库厂商提供不同的实现。
在程序中不需要直接去访问实现了 Driver 接口的类，而是由驱动程序管理器类(java.sql.DriverManager)去调用这些Driver实现。
- Oracle的驱动：oracle.jdbc.driver.OracleDriver
- mySql的驱动： com.mysql.jdbc.Driver

在这里插入图片描述

将上述jar包拷贝到Java工程的一个目录中，习惯上新建一个lib文件夹。

在这里插入图片描述

在驱动jar上右键–>Build Path–>Add to Build Path

在这里插入图片描述

注意：如果是Dynamic Web Project（动态的web项目）话，则是把驱动jar放到WebContent（有的开发工具叫WebRoot）目录中的WEB-INF目录中的lib目录下即可

在这里插入图片描述

2.1.2 加载与注册JDBC驱动

加载驱动：加载 JDBC 驱动需调用 Class 类的静态方法 forName()，向其传递要加载的 JDBC 驱动的类名
- Class.forName(“com.mysql.jdbc.Driver”);
注册驱动：DriverManager 类是驱动程序管理器类，负责管理驱动程序
- 使用DriverManager.registerDriver(com.mysql.jdbc.Driver)来注册驱动
- 通常不用显式调用 DriverManager 类的 registerDriver() 方法来注册驱动程序类的实例，因为 Driver 接口的驱动程序类都包含了静态代码块，在这个静态代码块中，会调用 DriverManager.registerDriver() 方法来注册自身的一个实例。下图是MySQL的Driver实现类的源码：

在这里插入图片描述

2.2 要素二：URL

JDBC URL 用于标识一个被注册的驱动程序，驱动程序管理器通过这个 URL 选择正确的驱动程序，从而建立到数据库的连接。
JDBC URL的标准由三部分组成，各部分间用冒号分隔。
- jdbc:子协议:子名称
- 协议：JDBC URL中的协议总是jdbc
- 子协议：子协议用于标识一个数据库驱动程序
- 子名称：一种标识数据库的方法。子名称可以依不同的子协议而变化，用子名称的目的是为了定位数据库提供足够的信息。包含主机名(对应服务端的ip地址)，端口号，数据库名
举例：

在这里插入图片描述

几种常用数据库的 JDBC URL
- MySQL的连接URL编写方式：
  - jdbc:mysql://主机名称:mysql服务端口号/数据库名称?参数=值&参数=值
  - jdbc:mysql://localhost:3306/test
  - jdbc:mysql://localhost:3306/test**?useUnicode=true&characterEncoding=utf8**（如果JDBC程序与服务器端的字符集不一致，会导致乱码，那么可以通过参数指定服务器端的字符集）
  - jdbc:mysql://localhost:3306/test?user=root&password=123456
- Oracle 9i的连接URL编写方式：
  - jdbc:oracle:thin:@主机名称:oracle服务端口号:数据库名称
  - jdbc:oracle:thin:@localhost:1521:test
- SQLServer的连接URL编写方式：
  - jdbc:sqlserver://主机名称:sqlserver服务端口号:DatabaseName=数据库名称
  - jdbc:sqlserver://localhost:1433:DatabaseName=test

2.3 要素三：用户名和密码

user,password可以用“属性名=属性值”方式告诉数据库
可以调用 DriverManager 类的 getConnection() 方法建立到数据库的连接

2.4 数据库连接方式举例

2.4.1 连接方式一

import java.sql.Connection;
import java.sql.Driver;
import java.sql.SQLException;
import java.util.Properties;

import org.junit.Test;

public class ConTest {
	
	//方式一:
	@Test
	public void testConnection1() throws SQLException{
		// 获取Driver实现类对象
		Driver driver = new com.mysql.jdbc.Driver();
		
		// jdbc:mysql:协议
		// localhost:ip地址
		// 3306:默认mysql的端口号
		// test:test数据库
		String url = "jdbc:mysql://localhost:3306/test";
		//将用户名和密码封装在Properties中
		Properties info = new Properties();
		info.setProperty("user", "root");
		info.setProperty("password", "root");
		
		Connection conn = driver.connect(url, info);
		
		System.out.println(conn);
	}
}

说明：上述代码中显式出现了第三方数据库的API

2.4.2 连接方式二

	//方式二:对方式一的迭代,在如下的程序中不出现第三方的api,使得程序具有更好的可移植性
	@Test
	public void testConnection2() throws Exception{
		//1.获取Driver实现类对象,使用反射
		Class clazz = Class.forName("com.mysql.jdbc.Driver");
		Driver driver = (Driver) clazz.newInstance();
		//2.提供url,指明具体操作的数据
		String url = "jdbc:mysql://localhost:3306/test";
		//3.提供需要的用户名和密码
		Properties info = new Properties();
		info.setProperty("user", "root");
		info.setProperty("password", "root");
		//4.调用driver的connect(),获取连接
		Connection conn = driver.connect(url, info);
		
		System.out.println(conn);
	}

说明：相较于方式一，这里使用反射实例化Driver，不在代码中体现第三方数据库的API。体现了面向接口编程思想。

2.4.3 连接方式三

	// 方式三:使用DriverManager替换Driver
	@Test
	public void testConnection3() throws Exception {
		// 1.获取Driver实现类的对象
		Class clazz = Class.forName("com.mysql.jdbc.Driver");
		Driver driver = (Driver) clazz.newInstance();

		// 2.提供另外三个连接的基本信息：
		String url = "jdbc:mysql://localhost:3306/test";
		String user = "root";
		String password = "root";

		// 注册驱动
		DriverManager.registerDriver(driver);

		// 获取连接
		Connection conn = DriverManager.getConnection(url, user, password);
		
		System.out.println(conn);
	}

说明：使用DriverManager实现数据库的连接。体会获取连接必要的4个基本要素。

2.4.4 连接方式四

// 方式四:可以只是加载驱动,不用显示的注册驱动过了。
	@Test
	public void testConnection4() throws Exception {
		// 1.提供三个连接的基本信息:
		String url = "jdbc:mysql://localhost:3306/test";
		String user = "root";
		String password = "root";

		// 2.加载Driver实现类的对象
		Class.forName("com.mysql.jdbc.Driver");	
//		Driver driver = (Driver) clazz.newInstance();
		// 注册驱动
//		DriverManager.registerDriver(driver);
		/*
		 * 为什么可以省略上述操作呢？
		 * 在mysql的Driver实现类中，声明了如下的操作：
		 * static {
				try {
					java.sql.DriverManager.registerDriver(new Driver());
				} catch (SQLException E) {
					throw new RuntimeException("Can't register driver!");
				}
			}
		 */

		// 3.获取连接
		Connection conn = DriverManager.getConnection(url, user, password);
		
		System.out.println(conn);
	}

说明：不必显式的注册驱动了。因为在DriverManager的源码中已经存在静态代码块，实现了驱动的注册。

2.4.5 连接方式五(最终版)

在src下，先新建一个File文件，作为配置文件：

在这里插入图片描述

其中，配置文件【jdbc.properties】内容如下：

user=root
password=root
url=jdbc:mysql://localhost:3306/test
driverClass=com.mysql.jdbc.Driver

方法五源码：

	// 方式五(最终版):将数据库连接需要的4个基本信息声明在配置文件中,通过读取配置文件的方式,获取连接
	@Test
	public void testConnection5() throws Exception {
		// 1.读取配置文件中的4个基本信息
		InputStream is = ConTest.class.getClassLoader().getResourceAsStream("jdbc.properties");

		Properties pros = new Properties();
		pros.load(is);

		String user = pros.getProperty("user");
		String password = pros.getProperty("password");
		String url = pros.getProperty("url");
		String driverClass = pros.getProperty("driverClass");

		// 2.加载驱动
		Class.forName(driverClass);

		// 3.获取连接
		Connection conn = DriverManager.getConnection(url, user, password);
		
		System.out.println(conn);
	}

说明：使用配置文件的方式保存配置信息，在代码中加载配置文件

使用配置文件的好处：

①实现了代码和数据的分离，如果需要修改配置信息，直接在配置文件中修改，不需要深入代码
②如果修改了配置信息，省去重新编译的过程。

第3章：使用PreparedStatement实现CRUD操作

3.1 操作和访问数据库

数据库连接被用于向数据库服务器发送命令和 SQL 语句，并接受数据库服务器返回的结果。其实一个数据库连接就是一个Socket连接。
在 java.sql 包中有 3 个接口分别定义了对数据库的调用的不同方式：
- Statement：用于执行静态 SQL 语句并返回它所生成结果的对象。
- PrepatedStatement：SQL 语句被预编译并存储在此对象中，可以使用此对象多次高效地执行该语句。
- CallableStatement：用于执行 SQL 存储过程

在这里插入图片描述

3.2 使用Statement操作数据表的弊端

通过调用 Connection 对象的 createStatement() 方法创建该对象。该对象用于执行静态的 SQL 语句，并且返回执行结果。

Statement 接口中定义了下列方法用于执行 SQL 语句：

int excuteUpdate(String sql)：执行更新操作INSERT、UPDATE、DELETE
ResultSet executeQuery(String sql)：执行查询操作SELECT

但是使用Statement操作数据表存在弊端：
- 问题一：存在拼串操作，繁琐
- 问题二：存在SQL注入问题
SQL 注入是利用某些系统没有对用户输入的数据进行充分的检查，而在用户输入数据中注入非法的 SQL 语句段或命令(如：SELECT user, password FROM user_table WHERE user=‘a’ OR 1 = ’ AND password = ’ OR ‘1’ = ‘1’) ，从而利用系统的 SQL 引擎完成恶意行为的做法。
对于 Java 而言，要防范 SQL 注入，只要用 PreparedStatement(从Statement扩展而来) 取代 Statement 就可以了。
代码演示：
工具类User

public class User {
	private String user;
	private String password;

	public User() {
	}

	public User(String user, String password) {
		super();
		this.user = user;
		this.password = password;
	}

	@Override
	public String toString() {
		return "User [user=" + user + ", password=" + password + "]";
	}

	public String getUser() {
		return user;
	}

	public void setUser(String user) {
		this.user = user;
	}

	public String getPassword() {
		return password;
	}

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

实例：

import java.io.InputStream;
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
import java.util.Scanner;

import org.junit.Test;

public class StatementTest {

	// 使用Statement的弊端：需要拼写sql语句，并且存在SQL注入的问题
	@Test
	public void testLogin() {
		@SuppressWarnings("resource")
		Scanner scan = new Scanner(System.in);

		System.out.print("用户名：");
		String user = scan.nextLine();
		System.out.print("密   码：");
		String password = scan.nextLine();

		// SELECT user,password FROM user_table WHERE user = '1' or ' AND password = '='1' or '1' = '1';
		String sql = "SELECT user,password FROM user_table WHERE user = '" + user + "' AND password = '" + password + "'";
		User resuser = get(sql, User.class);
		if (resuser != null) {
			System.out.println("登陆成功!");
		} else {
			System.out.println("用户名或密码错误！");
		}
	}

	// 使用Statement实现对数据表的查询操作
	public <T> T get(String sql, Class<T> clazz) {
		T t = null;

		Connection conn = null;
		Statement st = null;
		ResultSet rs = null;
		try {
			// 1.加载配置文件
			InputStream is = StatementTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
			Properties pros = new Properties();
			pros.load(is);

			// 2.读取配置信息
			String user = pros.getProperty("user");
			String password = pros.getProperty("password");
			String url = pros.getProperty("url");
			String driverClass = pros.getProperty("driverClass");

			// 3.加载驱动
			Class.forName(driverClass);

			// 4.获取连接
			conn = DriverManager.getConnection(url, user, password);

			st = conn.createStatement();

			rs = st.executeQuery(sql);

			// 获取结果集的元数据
			ResultSetMetaData rsmd = rs.getMetaData();

			// 获取结果集的列数
			int columnCount = rsmd.getColumnCount();

			if (rs.next()) {

				t = clazz.newInstance();

				for (int i = 0; i < columnCount; i++) {
					// //1. 获取列的名称
					// String columnName = rsmd.getColumnName(i+1);

					// 1. 获取列的别名
					String columnName = rsmd.getColumnLabel(i + 1);

					// 2. 根据列名获取对应数据表中的数据
					Object columnVal = rs.getObject(columnName);

					// 3. 将数据表中得到的数据，封装进对象
					Field field = clazz.getDeclaredField(columnName);
					field.setAccessible(true);
					field.set(t, columnVal);
				}
				return t;
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// 关闭资源
			if (rs != null) {
				try {
					rs.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			if (st != null) {
				try {
					st.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

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

综上：

在这里插入图片描述

3.3 PreparedStatement的使用

3.3.1 PreparedStatement介绍

可以通过调用 Connection 对象的 preparedStatement(String sql) 方法获取 PreparedStatement 对象
PreparedStatement 接口是 Statement 的子接口，它表示一条预编译过的 SQL 语句
PreparedStatement 对象所代表的 SQL 语句中的参数用问号(?)来表示，调用 PreparedStatement 对象的 setXxx() 方法来设置这些参数. setXxx() 方法有两个参数，第一个参数是要设置的 SQL 语句中的参数的索引(从 1 开始)，第二个是设置的 SQL 语句中的参数的值

3.3.2 PreparedStatement vs Statement

代码的可读性和可维护性。
PreparedStatement 能最大可能提高性能：
- DBServer会对预编译语句提供性能优化。因为预编译语句有可能被重复调用，所以语句在被DBServer的编译器编译后的执行代码被缓存下来，那么下次调用时只要是相同的预编译语句就不需要编译，只要将参数直接传入编译过的语句执行代码中就会得到执行。
- 在statement语句中,即使是相同操作但因为数据内容不一样,所以整个语句本身不能匹配,没有缓存语句的意义.事实是没有数据库会对普通语句编译后的执行代码缓存。这样每执行一次都要对传入的语句编译一次。
- (语法检查，语义检查，翻译成二进制命令，缓存)
PreparedStatement 可以防止 SQL 注入

3.3.3 Java与SQL对应数据类型转换表

Java类型	SQL类型
boolean	BIT
byte	TINYINT
short	SMALLINT
int	INTEGER
long	BIGINT
String	CHAR,VARCHAR,LONGVARCHAR
byte array	BINARY , VAR BINARY
java.sql.Date	DATE
java.sql.Time	TIME
java.sql.Timestamp	TIMESTAMP

3.3.4 PreparedStatement实现表数据的添加操作

import java.io.InputStream;
import java.sql.Connection;
import java.sql.Date;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.Properties;

import org.junit.Test;

import github.ConTest;

/*
 * 使用PreparedStatement来替换Statement,实现对数据表的增删改操作
 * 
 */
public class PupdateTest {

	// 向customers表中添加一条记录
	@Test
	public void testInsert() {
		Connection conn = null;
		PreparedStatement ps = null;
		try {
			// 1.读取配置文件中的4个基本信息
			InputStream is = ConTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
			Properties pros = new Properties();
			pros.load(is);
			String user = pros.getProperty("user");
			String password = pros.getProperty("password");
			String url = pros.getProperty("url");
			String driverClass = pros.getProperty("driverClass");
			// 2.加载驱动
			Class.forName(driverClass);
			// 3.获取连接
			conn = DriverManager.getConnection(url, user, password);
			System.out.println(conn);
			// 4.预编译sql语句，返回PreparedStatement的实例
			String sql = "insert into customers(name,email,birth)values(?,?,?)";// ?:占位符
			ps = conn.prepareStatement(sql);
			// 5.填充占位符
			ps.setString(1, "鲁迅");
			ps.setString(2, "luxun@gmail.com");
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			java.util.Date date = sdf.parse("1900-09-11");
			ps.setDate(3, new Date(date.getTime()));
			// 6.执行操作
			ps.execute();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// 7.资源的关闭
			try {
				if (ps != null)
					ps.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
			try {
				if (conn != null)
					conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}
}

3.3.5 JDBCUtils：封装据库连接和关闭操作

import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

/**
 * 
 * @Description 操作数据库的工具类
 * @author subei Email:subei@163.com
 * @version
 * @date 2020年7月8日上午8:40:07
 *
 */
public class JDBCUtil {
	// 获取数据库的连接
	public static Connection getConnection() throws Exception {
		// 1.读取配置文件中的4个基本信息
		InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");

		Properties pros = new Properties();
		pros.load(is);

		String user = pros.getProperty("user");
		String password = pros.getProperty("password");
		String url = pros.getProperty("url");
		String driverClass = pros.getProperty("driverClass");

		// 2.加载驱动
		Class.forName(driverClass);

		// 3.获取连接
		Connection conn = DriverManager.getConnection(url, user, password);

		return conn;
	}

	// 关闭资源操作
	public static void closeResource(Connection conn, Statement ps, ResultSet rs) {
		try {
			if (ps != null)
				ps.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		try {
			if (conn != null)
				conn.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

	// 关闭连接和Statement的操作
	public static void closeResource(Connection conn, Statement ps) {
		try {
			if (ps != null)
				ps.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		try {
			if (conn != null)
				conn.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
}

3.3.6 PreparedStatement实现表数据的修改操作

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

import org.junit.Test;

import github3.utils.JDBCUtil;

public class PupdateTest {

	// 修改customers表的一条记录
	@Test
	public void testUpdate() {
		Connection conn = null;
		PreparedStatement ps = null;
		try {
			// 1.获取数据库的连接
			conn = JDBCUtil.getConnection();
			// 2.预编译sql语句,返回PreparedStatement的实例
			String sql = "update customers set name = ? where id = ?";
			ps = conn.prepareStatement(sql);
			// 3.填充占位符
			ps.setObject(1, "李斯特");
			ps.setObject(2, 18);
			// 4.执行
			ps.execute();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// 5.资源的关闭
			JDBCUtil.closeResource(conn, ps);
		}
	}
}

3.3.7 使用PreparedStatement实现增、删、改操作

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

import org.junit.Test;

import github3.utils.JDBCUtil;

public class PupdateTest {
	// 通用的增删改操作
	public void update(String sql, Object ...args) {// sql中占位符的个数与可变形参的长度相同！
		Connection conn = null;
		PreparedStatement ps = null;
		try {
			// 1.获取数据库的连接
			conn = JDBCUtil.getConnection();
			// 2.预编译sql语句,返回PreparedStatement的实例
			ps = conn.prepareStatement(sql);
			// 3.填充占位符
			for (int i = 0; i < args.length; i++) {
				ps.setObject(i + 1, args[i]);// 小心参数声明错误！！
			}
			// 4.执行
			ps.execute();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// 5.资源的关闭
			JDBCUtil.closeResource(conn, ps);
		}
	}
	
	// 测试
	@Test
	public void testCommonUpdate(){
		String sql = "update `order` set order_name = ? where order_id = ?";
		update(sql,"DD","2");
	}
}

3.3.8 查询操作的流程

在这里插入图片描述

3.3.9 使用PreparedStatement实现查询操作

Customer类

import java.util.Date;

/*
 * ORM编程思想  (object relational mapping)
 * 一个数据表对应一个java类
 * 表中的一条记录对应java类的一个对象
 * 表中的一个字段对应java类的一个属性
 * 
 */
public class Customer {
	private int id;
	private String name;
	private String email;
	private Date birth;
	
	public Customer() {
		super();
	}

	public Customer(int id, String name, String email, Date birth) {
		super();
		this.id = id;
		this.name = name;
		this.email = email;
		this.birth = birth;
	}

	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 String getEmail() {
		return email;
	}

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

	public Date getBirth() {
		return birth;
	}

	public void setBirth(Date birth) {
		this.birth = birth;
	}

	@Override
	public String toString() {
		return "Customer [id=" + id + ", name=" + name + ", email=" + email + ", birth=" + birth + "]";
	}
}

Order类

import java.util.Date;

public class Order {
	private int orderId;
	private String orderName;
	private Date orderDate;
	
	public Order() {
		super();
	}

	public Order(int orderId, String orderName, Date orderDate) {
		super();
		this.orderId = orderId;
		this.orderName = orderName;
		this.orderDate = orderDate;
	}

	public int getOrderId() {
		return orderId;
	}

	public void setOrderId(int orderId) {
		this.orderId = orderId;
	}

	public String getOrderName() {
		return orderName;
	}

	public void setOrderName(String orderName) {
		this.orderName = orderName;
	}

	public Date getOrderDate() {
		return orderDate;
	}

	public void setOrderDate(Date orderDate) {
		this.orderDate = orderDate;
	}

	@Override
	public String toString() {
		return "Order [orderId=" + orderId + ", orderName=" + orderName + ", orderDate=" + orderDate + "]";
	}
}

JDBCUtil类

import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

/**
 * 
 * @Description 操作数据库的工具类
 * @author subei Email:subei@163.com
 * @version
 * @date 2020年7月8日上午8:40:07
 *
 */
public class JDBCUtil {
	// 获取数据库的连接
	public static Connection getConnection() throws Exception {
		// 1.读取配置文件中的4个基本信息
		InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");

		Properties pros = new Properties();
		pros.load(is);

		String user = pros.getProperty("user");
		String password = pros.getProperty("password");
		String url = pros.getProperty("url");
		String driverClass = pros.getProperty("driverClass");

		// 2.加载驱动
		Class.forName(driverClass);

		// 3.获取连接
		Connection conn = DriverManager.getConnection(url, user, password);

		return conn;
	}

	// 关闭资源操作
	public static void closeResource(Connection conn,Statement ps,ResultSet rs){
		try {
			if(ps != null)
				ps.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		try {
			if(conn != null)
				conn.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		try {
			if(rs != null)
				rs.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	// 关闭连接和Statement的操作
	public static void closeResource(Connection conn, Statement ps) {
		try {
			if (ps != null)
				ps.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		try {
			if (conn != null)
				conn.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
}

具体代码

import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;

import org.junit.Test;

import github3.hub.Customer;
import github3.hub.Order;
import github3.utils.JDBCUtil;

/**
  * 
  * @Description 使用PreparedStatement实现针对于不同表的通用的查询操作
  * @author subei Email:subei@163.com
  * @version
  * @date 2020年7月9日上午10:54:50
  *
 */
public class PSQueryTest {
	/**
	  * 
	  * @Description 针对于不同的表的通用的查询操作，返回表中的一条记录
	  * @author subei
	  * @date 2020年7月9日上午11:12:49
	  * @param clazz
	  * @param sql
	  * @param args
	  * @return
	 */
	public <T> T getInstance(Class<T> clazz,String sql, Object... args) {
		Connection conn = null;
		PreparedStatement ps = null;
		//执行,结果集
		ResultSet rs = null;
		try {
			// 1.获取数据库连接
			conn = JDBCUtil.getConnection();
			// 2.预编译sql语句,得到PreparedStatement对象
			ps = conn.prepareStatement(sql);
			// 3.填充占位符
			for (int i = 0; i < args.length; i++) {
				ps.setObject(i + 1, args[i]);
			}
			// 4.执行executeQuery(),得到结果集：ResultSet
			rs = ps.executeQuery();
			// 5.得到结果集的元数据:ResultSetMetaData
			ResultSetMetaData rsmd = rs.getMetaData();
			// 6.1通过ResultSetMetaData得到columnCount,columnLabel;通过ResultSet得到列值
			int count = rsmd.getColumnCount();
			if (rs.next()) {
				T t = clazz.newInstance();
				for (int i = 0; i < count; i++) {
					//获取每个列值:通过ResultSet
					Object value = rs.getObject(i + 1);
					//获取列的别名:getColumnLabel()
					String columnLabel = rsmd.getColumnLabel(i + 1);
					
					// 6.2通过反射,将t对象指定名className的属性赋值为指定的值value
					Field field = clazz.getDeclaredField(columnLabel);
					field.setAccessible(true);
					field.set(t, value);
				}
				return t;
			} 
		} catch (Exception e) {
			e.printStackTrace();
		} finally {	
			// 7.关闭资源
			JDBCUtil.closeResource(conn, ps, rs);
		}
		return null;
	}
	
	@Test
	public void testGetInstance(){
		String sql = "select id,name,email from customers where id = ?";
		Customer customer = getInstance(Customer.class,sql,12);
		System.out.println(customer);
		
		String sql2 = "select order_id orderId,order_name orderName from `order` where order_id = ?";
		Order order = getInstance(Order.class, sql2, 1);
		System.out.println(order);
	}
}

说明：使用PreparedStatement实现的查询操作可以替换Statement实现的查询操作，解决Statement拼串和SQL注入问题。

3.4 ResultSet与ResultSetMetaData

3.4.1 ResultSet

查询需要调用PreparedStatement 的 executeQuery() 方法，查询结果是一个ResultSet 对象
ResultSet 对象以逻辑表格的形式封装了执行数据库操作的结果集，ResultSet 接口由数据库厂商提供实现
ResultSet 返回的实际上就是一张数据表。有一个指针指向数据表的第一条记录的前面。
ResultSet 对象维护了一个指向当前数据行的游标，初始的时候，游标在第一行之前，可以通过 ResultSet 对象的 next() 方法移动到下一行。调用 next()方法检测下一行是否有效。若有效，该方法返回 true，且指针下移。相当于Iterator对象的 hasNext() 和 next() 方法的结合体。
当指针指向一行时, 可以通过调用 getXxx(int index) 或 getXxx(int columnName) 获取每一列的值。
- 例如: getInt(1), getString(“name”)
- 注意：Java与数据库交互涉及到的相关Java API中的索引都从1开始。
ResultSet 接口的常用方法：
- boolean next()
- getString()
- …

在这里插入图片描述

3.4.2 ResultSetMetaData

可用于获取关于 ResultSet 对象中列的类型和属性信息的对象
ResultSetMetaData meta = rs.getMetaData();
- getColumnName(int column)：获取指定列的名称
- getColumnLabel(int column)：获取指定列的别名
- getColumnCount()：返回当前 ResultSet 对象中的列数。
- getColumnTypeName(int column)：检索指定列的数据库特定的类型名称。
- getColumnDisplaySize(int column)：指示指定列的最大标准宽度，以字符为单位。
- isNullable(int column)：指示指定列中的值是否可以为 null。
- isAutoIncrement(int column)：指示是否自动为指定列进行编号，这样这些列仍然是只读的。

在这里插入图片描述

问题1：得到结果集后, 如何知道该结果集中有哪些列？列名是什么？

需要使用一个描述 ResultSet 的对象，即 ResultSetMetaData

问题2：关于ResultSetMetaData

如何获取 ResultSetMetaData：调用 ResultSet 的 getMetaData() 方法即可
获取 ResultSet 中有多少列：调用 ResultSetMetaData 的 getColumnCount() 方法
获取 ResultSet 每一列的列的别名是什么：调用 ResultSetMetaData 的getColumnLabel() 方法

在这里插入图片描述

3.5 资源的释放

释放ResultSet, Statement,Connection。
数据库连接（Connection）是非常稀有的资源，用完后必须马上释放，如果Connection不能及时正确的关闭将导致系统宕机。Connection的使用原则是尽量晚创建，尽量早的释放。
可以在finally中关闭，保证及时其他代码出现异常，资源也一定能被关闭。

3.6 JDBC API小结

两种思想
- 面向接口编程的思想
- ORM思想(object relational mapping)
  - 一个数据表对应一个java类
  - 表中的一条记录对应java类的一个对象
  - 表中的一个字段对应java类的一个属性
sql是需要结合列名和表的属性名来写。注意起别名。
两种技术
- JDBC结果集的元数据：ResultSetMetaData
  - 获取列数：getColumnCount()
  - 获取列的别名：getColumnLabel()
- 通过反射，创建指定类的对象，获取指定的属性并赋值

章节练习

练习题1：从控制台向数据库的表customers中插入一条数据，表结构如下：

在这里插入图片描述

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.util.Scanner;

import org.junit.Test;

import github3.utils.JDBCUtil;

public class ExerTest {
	// 通用的增删改操作
	public int update(String sql, Object... args) {// sql中占位符的个数与可变形参的长度相同！
		Connection conn = null;
		PreparedStatement ps = null;
		try {
			// 1.获取数据库的连接
			conn = JDBCUtil.getConnection();
			// 2.预编译sql语句,返回PreparedStatement的实例
			ps = conn.prepareStatement(sql);
			// 3.填充占位符
			for (int i = 0; i < args.length; i++) {
				ps.setObject(i + 1, args[i]);// 小心参数声明错误！！
			}
			// 4.执行
			/*
			 * ps.execute():
			 * 如果执行的是查询操作,有返回结果,则此方法返回true;
			 * 如果执行的是增、删、改操作,没有返回结果,则此方法返回false.
			 */
			//方式一:
//			return ps.execute();
			//方式二:
			return ps.executeUpdate();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// 5.资源的关闭
			JDBCUtil.closeResource(conn, ps);
		}
		return 0;
	}
	
	@Test
	public void testInsert(){
		@SuppressWarnings("resource")
		Scanner scanner = new Scanner(System.in);
		System.out.print("请输入用户名:");
		String name = scanner.next();
		System.out.print("请输入邮箱:");
		String email = scanner.next();
		System.out.print("请输入生日:");	//1998-08-08
		String birthday = scanner.next();
		
		String sql = "insert into customers(name,email,birth)values(?,?,?)";
		int insertCount = update(sql, name,email,birthday);
		if(insertCount > 0){
			System.out.println("添加成功！");
		}else{
			System.out.println("添加失败！");
		}
	}
}

练习题2：创立数据库表 examstudent，表结构如下：

在这里插入图片描述

向数据表中添加如下数据：

在这里插入图片描述

代码实现1：插入一个新的student 信息

具体界面：

请输入考生的详细信息Type: 

IDCard:
ExamCard:
StudentName:
Location:
Grade:

信息录入成功!

实现代码：

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.util.Scanner;

import org.junit.Test;

import github3.utils.JDBCUtil;

public class Exer2Test {
	// 通用的增删改操作
	public int update(String sql, Object... args) {// sql中占位符的个数与可变形参的长度相同！
		Connection conn = null;
		PreparedStatement ps = null;
		try {
			// 1.获取数据库的连接
			conn = JDBCUtil.getConnection();
			// 2.预编译sql语句,返回PreparedStatement的实例
			ps = conn.prepareStatement(sql);
			// 3.填充占位符
			for (int i = 0; i < args.length; i++) {
				ps.setObject(i + 1, args[i]);// 小心参数声明错误！！
			}
			// 4.执行
			/*
			 * ps.execute(): 如果执行的是查询操作,有返回结果,则此方法返回true;
			 * 如果执行的是增、删、改操作,没有返回结果,则此方法返回false.
			 */
			// 方式一:
			// return ps.execute();
			// 方式二:
			return ps.executeUpdate();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// 5.资源的关闭
			JDBCUtil.closeResource(conn, ps);
		}
		return 0;
	}
	
	// 问题1:向examstudent表中添加一条记录
	@Test
	public void testInsert(){
		@SuppressWarnings("resource")
		Scanner scanner = new Scanner(System.in);
		System.out.print("四级/六级:");
		int type = scanner.nextInt();
		System.out.print("身份证号:");
		String IDCard = scanner.next();
		System.out.print("准考证号:");
		String examCard = scanner.next();
		System.out.print("学生姓名:");
		String studentName = scanner.next();
		System.out.print("所在城市:");
		String location = scanner.next();
		System.out.print("考试成绩:");
		int grade = scanner.nextInt();
		
		String sql = "insert into examstudent(type,IDCard,examCard,studentName,location,grade)values(?,?,?,?,?,?)";
		int insertCount = update(sql,type,IDCard,examCard,studentName,location,grade);
		if(insertCount > 0){
			System.out.println("添加成功！");
		}else{
			System.out.println("添加失败！");
		}
	}
}

代码实现2：在 eclipse中建立 java 程序：输入身份证号或准考证号可以查询到学生的基本信息。结果如下：
在这里插入图片描述

Student类

public class Student {
	private int flowID;//流水号
	private int type;//考试类型
	private String IDCard;//身份证号
	private String examCard;//准考证号
	private String name;//学生姓名
	private String location;//所在城市
	private int grade;//成绩
	
	public Student() {
		super();
	}

	public Student(int flowID, int type, String iDCard, String examCard, String name, String location, int grade) {
		super();
		this.flowID = flowID;
		this.type = type;
		IDCard = iDCard;
		this.examCard = examCard;
		this.name = name;
		this.location = location;
		this.grade = grade;
	}

	public int getFlowID() {
		return flowID;
	}

	public void setFlowID(int flowID) {
		this.flowID = flowID;
	}

	public int getType() {
		return type;
	}

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

	public String getIDCard() {
		return IDCard;
	}

	public void setIDCard(String iDCard) {
		IDCard = iDCard;
	}

	public String getExamCard() {
		return examCard;
	}

	public void setExamCard(String examCard) {
		this.examCard = examCard;
	}

	public String getName() {
		return name;
	}

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

	public String getLocation() {
		return location;
	}

	public void setLocation(String location) {
		this.location = location;
	}

	public int getGrade() {
		return grade;
	}

	public void setGrade(int grade) {
		this.grade = grade;
	}
	
	@Override
	public String toString() {
		System.out.println("=========查询结果===========");
		return info();
	}
	
	private String info() {
		return "流水号：" + flowID + "
四级/六级：" + type + "
身份证号：" + IDCard + "
准考证号：" + examCard + 
				"
学生姓名：" + name + "
区域：" + location + "
成绩：" + grade;
	}
}

实现代码

import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.Scanner;

import org.junit.Test;

import github3.utils.JDBCUtil;

public class Exer2Test {	
	//问题2:根据身份证号或者准考证号查询学生成绩信息
	public <T> T getInstance(Class<T> clazz,String sql, Object... args) {
		Connection conn = null;
		PreparedStatement ps = null;
		//执行,结果集
		ResultSet rs = null;
		try {
			// 1.获取数据库连接
			conn = JDBCUtil.getConnection();
			// 2.预编译sql语句,得到PreparedStatement对象
			ps = conn.prepareStatement(sql);
			// 3.填充占位符
			for (int i = 0; i < args.length; i++) {
				ps.setObject(i + 1, args[i]);
			}
			// 4.执行executeQuery(),得到结果集：ResultSet
			rs = ps.executeQuery();
			// 5.得到结果集的元数据:ResultSetMetaData
			ResultSetMetaData rsmd = rs.getMetaData();
			// 6.1通过ResultSetMetaData得到columnCount,columnLabel;通过ResultSet得到列值
			int count = rsmd.getColumnCount();
			if (rs.next()) {
				T t = clazz.newInstance();
				for (int i = 0; i < count; i++) {
					//获取每个列值:通过ResultSet
					Object value = rs.getObject(i + 1);
					//获取列的别名:getColumnLabel()
					String columnLabel = rsmd.getColumnLabel(i + 1);
					
					// 6.2通过反射,将t对象指定名className的属性赋值为指定的值value
					Field field = clazz.getDeclaredField(columnLabel);
					field.setAccessible(true);
					field.set(t, value);
				}
				return t;
			} 
		} catch (Exception e) {
			e.printStackTrace();
		} finally {	
			JDBCUtil.closeResource(conn, ps, rs);
		}
		return null;
	}
	
	@Test
	public void queryWithIDCardOrExamCard(){
		System.out.println("请选择您要输入的类型:");
		System.out.println("a.准考证号");
		System.out.println("b.身份证号");
		@SuppressWarnings("resource")
		Scanner scanner = new Scanner(System.in);
		String selection = scanner.next();
		if("a".equalsIgnoreCase(selection)){//if(selection.equalsIgnoreCase("a")){
			System.out.println("请输入准考证号:");
			String examCard = scanner.next();
			String sql = "select FlowID flowID,Type type,IDCard,ExamCard examCard,StudentName name,Location location,Grade grade from examstudent where examCard = ?";
			
			Student student = getInstance(Student.class,sql,examCard);
			if(student != null){
				System.out.println(student);
				
			}else{
				System.out.println("输入的准考证号有误！");
			}
			
		}else if("b".equalsIgnoreCase(selection)){
			System.out.println("请输入身份证号:");
			String IDCard = scanner.next();
			String sql = "select FlowID flowID,Type type,IDCard,ExamCard examCard,StudentName name,Location location,Grade grade from examstudent where IDCard = ?";
			
			Student student = getInstance(Student.class,sql,IDCard);
			if(student != null){
				System.out.println(student);	
			}else{
				System.out.println("输入的身份证号有误！");
			}
		}else{
			System.out.println("您的输入有误,请重新进入程序。");
		}
	}
}

代码实现3：完成学生信息的删除功能

在这里插入图片描述

import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.Scanner;

import org.junit.Test;

import github3.utils.JDBCUtil;

public class Exer2Test {
	// 通用的增删改操作
	public int update(String sql, Object... args) {// sql中占位符的个数与可变形参的长度相同！
		Connection conn = null;
		PreparedStatement ps = null;
		try {
			// 1.获取数据库的连接
			conn = JDBCUtil.getConnection();
			// 2.预编译sql语句,返回PreparedStatement的实例
			ps = conn.prepareStatement(sql);
			// 3.填充占位符
			for (int i = 0; i < args.length; i++) {
				ps.setObject(i + 1, args[i]);// 小心参数声明错误！！
			}
			// 4.执行
			/*
			 * ps.execute(): 如果执行的是查询操作,有返回结果,则此方法返回true;
			 * 如果执行的是增、删、改操作,没有返回结果,则此方法返回false.
			 */
			// 方式一:
			// return ps.execute();
			// 方式二:
			return ps.executeUpdate();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// 5.资源的关闭
			JDBCUtil.closeResource(conn, ps);
		}
		return 0;
	}
    
	// 问题2:根据身份证号或者准考证号查询学生成绩信息
	public <T> T getInstance(Class<T> clazz, String sql, Object... args) {
		Connection conn = null;
		PreparedStatement ps = null;
		// 执行,结果集
		ResultSet rs = null;
		try {
			// 1.获取数据库连接
			conn = JDBCUtil.getConnection();
			// 2.预编译sql语句,得到PreparedStatement对象
			ps = conn.prepareStatement(sql);
			// 3.填充占位符
			for (int i = 0; i < args.length; i++) {
				ps.setObject(i + 1, args[i]);
			}
			// 4.执行executeQuery(),得到结果集：ResultSet
			rs = ps.executeQuery();
			// 5.得到结果集的元数据:ResultSetMetaData
			ResultSetMetaData rsmd = rs.getMetaData();
			// 6.1通过ResultSetMetaData得到columnCount,columnLabel;通过ResultSet得到列值
			int count = rsmd.getColumnCount();
			if (rs.next()) {
				T t = clazz.newInstance();
				for (int i = 0; i < count; i++) {
					// 获取每个列值:通过ResultSet
					Object value = rs.getObject(i + 1);
					// 获取列的别名:getColumnLabel()
					String columnLabel = rsmd.getColumnLabel(i + 1);

					// 6.2通过反射,将t对象指定名className的属性赋值为指定的值value
					Field field = clazz.getDeclaredField(columnLabel);
					field.setAccessible(true);
					field.set(t, value);
				}
				return t;
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			JDBCUtil.closeResource(conn, ps, rs);
		}
		return null;
	}

	// 问题3:删除指定的学生信息
	@Test
	public void testDeleteByExamCard() {
		System.out.println("请输入学生的考号:");
		@SuppressWarnings("resource")
		Scanner scanner = new Scanner(System.in);
		String examCard = scanner.next();
		// 查询指定准考证号的学生
		String sql = "select FlowID flowID,Type type,IDCard,ExamCard examCard,StudentName name,Location location,Grade grade from examstudent where examCard = ?";
		Student student = getInstance(Student.class, sql, examCard);
		if (student == null) {
			System.out.println("查无此人,请重新输入!");
		} else {
			String sql1 = "delete from examstudent where examCard = ?";
			int deleteCount = update(sql1, examCard);
			if (deleteCount > 0) {
				System.out.println("删除成功!");
			}
		}
	}

	// 优化以后的操作：
	@Test
	public void testDeleteByExamCard1() {
		System.out.println("请输入学生的考号:");
		@SuppressWarnings("resource")
		Scanner scanner = new Scanner(System.in);
		String examCard = scanner.next();
		String sql = "delete from examstudent where examCard = ?";
		int deleteCount = update(sql, examCard);
		if (deleteCount > 0) {
			System.out.println("删除成功!");
		} else {
			System.out.println("查无此人,请重新输入!");
		}
	}
}

第4章操作BLOB类型字段

4.1 MySQL BLOB类型

MySQL中，BLOB是一个二进制大型对象，是一个可以存储大量数据的容器，它能容纳不同大小的数据。
插入BLOB类型的数据必须使用PreparedStatement，因为BLOB类型的数据无法使用字符串拼接写的。
MySQL的四种BLOB类型(除了在存储的最大信息量上不同外，他们是等同的)

在这里插入图片描述

实际使用中根据需要存入的数据大小定义不同的BLOB类型。
需要注意的是：如果存储的文件过大，数据库的性能会下降。
如果在指定了相关的Blob类型以后，还报错：xxx too large，那么在mysql的安装目录下，找my.ini文件加上如下的配置参数： max_allowed_packet=16M。同时注意：修改了my.ini文件之后，需要重新启动mysql服务。

4.2 向数据表中插入大数据类型

import java.io.File;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;

import org.junit.Test;

import github3.utils.JDBCUtil;

public class BlobTest {
	// 向数据表customers中插入Blob类型的字段
	@Test
	public void testInsert() throws Exception {
		Connection conn = JDBCUtil.getConnection();
		String sql = "insert into customers(name,email,birth,photo)values(?,?,?,?)";
		PreparedStatement ps = conn.prepareStatement(sql);
		
		ps.setObject(1,"墨子");
		ps.setObject(2, "subei@qq.com");
		ps.setObject(3,"1998-08-08");
		FileInputStream is = new FileInputStream(new File("n6qx6q.jpg"));
		ps.setBlob(4, is);
		
		ps.execute();
		JDBCUtil.closeResource(conn, ps);
	}
}

4.3 修改数据表中的Blob类型字段

Connection conn = JDBCUtil.getConnection();
String sql = "update customers set photo = ? where id = ?";
PreparedStatement ps = conn.prepareStatement(sql);

// 填充占位符
// 操作Blob类型的变量
FileInputStream fis = new FileInputStream("n6qx6q.jpg");
ps.setBlob(1, fis);
ps.setInt(2, 25);

ps.execute();

fis.close();
JDBCUtil.closeResource(conn, ps);

4.4 从数据表中读取大数据类型

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Blob;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Date;

import org.junit.Test;

import github3.hub.Customer;
import github3.utils.JDBCUtil;

public class BlobTest {
	// 查询数据表customers中Blob类型的字段
	@Test
	public void testQuery(){
		Connection conn = null;
		PreparedStatement ps = null;
		ResultSet rs = null;
		InputStream is = null;
		FileOutputStream fos = null;
		try {
			conn = JDBCUtil.getConnection();
			String sql = "select id,name,email,birth,photo from customers where id = ?";
			ps = conn.prepareStatement(sql);
			ps.setInt(1, 25);
			rs = ps.executeQuery();
			if (rs.next()) {
				//方式一:
//				int id = rs.getInt(1);
//				String name = rs.getString(2);
//				String email = rs.getString(3);
//				Date birth = rs.getDate(4);
				//方式二:
				int id = rs.getInt("id");
				String name = rs.getString("name");
				String email = rs.getString("email");
				Date birth = rs.getDate("birth");
				
				Customer customer = new Customer(id, name, email, birth);
				System.out.println(customer);
				
				//将Blob类型的字段下载下来,以文件的方式保存在本地
				Blob photo = rs.getBlob("photo");
				is = photo.getBinaryStream();
				fos = new FileOutputStream("github.jpg");
				byte[] buffer = new byte[1024];
				int len;
				while((len = is.read(buffer)) != -1){
					fos.write(buffer,0,len);
				}
			} 
		} catch (Exception e) {
			e.printStackTrace();
		} finally {		
			try {
				if(is != null)
					is.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
			
			try {
				if(fos != null)
					fos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
			JDBCUtil.closeResource(conn, ps, rs);
		}
	}
}

第5章批量插入

5.1 批量执行SQL语句

当需要成批插入或者更新记录时，可以采用Java的批量更新机制，这一机制允许多条语句一次性提交给数据库批量处理。通常情况下比单独提交处理更有效率

JDBC的批量处理语句包括下面三个方法：

addBatch(String)：添加需要批量处理的SQL语句或是参数；
executeBatch()：执行批量处理语句；
clearBatch():清空缓存的数据

通常我们会遇到两种批量执行SQL语句的情况：

多条SQL语句的批量处理；
一个SQL语句的批量传参；

5.2 高效的批量插入

举例：向数据表中插入20000条数据

数据库中提供一个goods表。创建如下：

CREATE TABLE goods(
id INT PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR(20)
);

5.2.1 实现层次一：使用Statement

Connection conn = JDBCUtils.getConnection();
Statement st = conn.createStatement();
for(int i = 1;i <= 20000;i++){
	String sql = "insert into goods(name) values('name_' + "+ i +")";
	st.executeUpdate(sql);
}

5.2.2 实现层次二：使用PreparedStatement

	@Test
	public void testInsert(){
		Connection conn = null;
		PreparedStatement ps = null;
		try {
			long start = System.currentTimeMillis();
			
			conn = JDBCUtil.getConnection();
			String sql = "insert into goods(name)values(?)";
			ps = conn.prepareStatement(sql);
			for (int i = 1; i <= 20000; i++) {
				ps.setObject(1, "name_" + i);

				ps.execute();
			} 
			long end = System.currentTimeMillis();
			System.out.println("花费的时间为:" + (end - start));//13798
		} catch (Exception e) {
			e.printStackTrace();
		} finally{			
			JDBCUtil.closeResource(conn, ps);
		}
	}

5.2.3 实现层次三：使用 addBatch() / executeBatch() / clearBatch()

/*
 * 修改1： 使用 addBatch() / executeBatch() / clearBatch()
 * 修改2：mysql服务器默认是关闭批处理的，我们需要通过一个参数，让mysql开启批处理的支持。
 * 		 ?rewriteBatchedStatements=true 写在配置文件的url后面
 * 修改3：使用更新的mysql 驱动：mysql-connector-java-5.1.37-bin.jar
 * 
 */
	@Test
	public void testInsert2() {
		Connection conn = null;
		PreparedStatement ps = null;
		try {
			long start = System.currentTimeMillis();
			
			conn = JDBCUtil.getConnection();
			String sql = "insert into goods(name)values(?)";
			ps = conn.prepareStatement(sql);
			for (int i = 1; i <= 20000; i++) {
				ps.setObject(1, "name_" + i);

				//1."攒"sql
				ps.addBatch();
				
				if(i % 500 == 0){
					//2.执行batch
					ps.executeBatch();
					
					//3.清空batch
					ps.clearBatch();
				}
			} 
			long end = System.currentTimeMillis();
			System.out.println("花费的时间为:" + (end - start));//357
		} catch (Exception e) {
			e.printStackTrace();
		} finally{			
			JDBCUtil.closeResource(conn, ps);
		}
	}

5.2.4 实现层次四：在层次三的基础上操作

/*
 * 层次四:设置连接不允许自动提交数据
 * 使用Connection 的 setAutoCommit(false)  /  commit()
 */
	@Test
	public void testInsert3() {
		Connection conn = null;
		PreparedStatement ps = null;
		try {
			long start = System.currentTimeMillis();

			conn = JDBCUtil.getConnection();
			
			//设置不允许自动提交数据
			conn.setAutoCommit(false);
			
			String sql = "insert into goods(name)values(?)";
			ps = conn.prepareStatement(sql);
			for (int i = 1; i <= 1000000; i++) {
				ps.setObject(1, "name_" + i);

				// 1."攒"sql
				ps.addBatch();

				if (i % 500 == 0) {
					// 2.执行batch
					ps.executeBatch();

					// 3.清空batch
					ps.clearBatch();
				}
			}
			//提交数据
			conn.commit();
			long end = System.currentTimeMillis();
			System.out.println("花费的时间为:" + (end - start));// 4020
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			JDBCUtil.closeResource(conn, ps);
		}
	}

感谢查阅！！！

查看全文

相关阅读:
Hadoop Ambari 安装
 hadoop 集群配置--增加减少新的机器不重启
 使用 XMPP 构建一个基于 web 的通知工具——转
 Hadoop 1.1.2 Eclipse 插件使用——异常解决
 UltraEdit中文乱码的解决方法
 Hadoop开发环境简介(转)
Hadoop构成
 hadoop 1.2.1 eclipse 插件编译
 Python print 输出到控制台丢数据
 社招面试总结

原文地址：https://www.cnblogs.com/gh110/p/13282302.html

JDBC核心技术(上)

文章目录

JDBC核心技术

web技术概述

第1章：JDBC概述

1.1 数据的持久化

1.2 Java中的数据存储技术

1.3 JDBC介绍

1.4 JDBC体系结构

1.5 JDBC程序编写步骤

第2章：获取数据库连接

2.1 要素一：Driver接口实现类

2.1.1 Driver接口介绍

2.1.2 加载与注册JDBC驱动

2.2 要素二：URL

2.3 要素三：用户名和密码

2.4 数据库连接方式举例

2.4.1 连接方式一

2.4.2 连接方式二

2.4.3 连接方式三

2.4.4 连接方式四

2.4.5 连接方式五(最终版)

第3章：使用PreparedStatement实现CRUD操作

3.1 操作和访问数据库

3.2 使用Statement操作数据表的弊端

3.3 PreparedStatement的使用

3.3.1 PreparedStatement介绍

3.3.2 PreparedStatement vs Statement

3.3.3 Java与SQL对应数据类型转换表

3.3.4 PreparedStatement实现表数据的添加操作

3.3.5 JDBCUtils：封装据库连接和关闭操作

3.3.6 PreparedStatement实现表数据的修改操作

3.3.7 使用PreparedStatement实现增、删、改操作

3.3.8 查询操作的流程

3.3.9 使用PreparedStatement实现查询操作

3.4 ResultSet与ResultSetMetaData

3.4.1 ResultSet

3.4.2 ResultSetMetaData

3.5 资源的释放

3.6 JDBC API小结

章节练习

第4章 操作BLOB类型字段

4.1 MySQL BLOB类型

4.2 向数据表中插入大数据类型

4.3 修改数据表中的Blob类型字段

4.4 从数据表中读取大数据类型

第5章 批量插入

5.1 批量执行SQL语句

5.2 高效的批量插入

5.2.1 实现层次一：使用Statement

5.2.2 实现层次二：使用PreparedStatement

5.2.3 实现层次三：使用 addBatch() / executeBatch() / clearBatch()

5.2.4 实现层次四：在层次三的基础上操作

感谢查阅！！！

第4章操作BLOB类型字段

第5章批量插入