Java基础-数据库操作

最新推荐文章于 2022-08-05 10:26:05 发布

11爱学习的程序员11

最新推荐文章于 2022-08-05 10:26:05 发布

阅读量331

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/zhang1314fudao/article/details/81388537

版权

java基础专栏收录该内容

10 篇文章 0 订阅

订阅专栏

一、Java和数据库交互主要分为三步：

1、加载驱动，由各个数据库厂商自己实现，

2、获得数据库链接，通常是通过scoket获取数据库的链接，所以比较消耗资源。

3、发送sql语句到数据库。

下面以mysql为例：

1）加载驱动，首先要导入mysql的驱动jar mysql-connector-java-5.1.9.jar，其次加载

//1、加载驱动
Class.forName("com.mysql.jdbc.Driver");

2) 获取数据库链接

 Connection con = null;			
 con = DriverManager.getConnection("jdbc:mysql://localhost:3306/datatest","root","root"); //url username password

3)发送sql到数据库

这里java提供了三中方式：

Java.sql.Statement接口

Statement stat = null;
//3、向数据库发送sql语句
stat = con.createStatement();
				
String sql = "insert into user (name,age) values ('zhangsan',18) ";
				
stat.execute(sql);

 Java.sql. PreparedStatement extends Statement

PreparedStatement  preparedStat =null;
String sql = "insert into user (name,age,date) values (?,?,?) ";
preparedStat = con.prepareStatement(sql);
preparedStat.setString(1, "lisi");
preparedStat.setInt(2, 19);
preparedStat.setDate(3, new java.sql.Date(System.currentTimeMillis()));	preparedStat.execute();

PreparedStatement是对发送到数据库的sql进行预编译的，而Statement每次把sql发送到数据库都需要编译一次，因此，对一只执行一次的sql，使用Statement相对效率更高，而对同一个sql需要进行多次操作，则使用PreparedStatement。

public interface CallableStatement extends PreparedStatemen
只要支持对存储过程的支持，

下面分别对数据库的加载，链接，sql处理涉及的接口：DriverManager，Statement，PreparedStatement，CallableStatement，Connection以及查询结果ResultSet进行详细讲解。

二、事务

一组sql要么同时成功，要么同时失败的sql语句，是数据库操作的一个执行单元。

事务开始于：

连接到数据库上，并执行一条DML语句（delete、update、insert）

前一个事务结束后，又输入另外一条DML语句。

事务结束于：

执行一条Commit或rollback语句；

执行一个DDL语句，例如create table 语句，这种情况下会自动执行commit语句；

执行一个DCL语句，例如，great语句，这种情况下会自动执行commit语句；

断开与数据库的链接；

执行了一条DML语句，该语句却失败了，在这种情况下，为会这个无效的DML语句执行ROLLBACK语句。

事务的四大基本特性（ACID特性）

原子性：事务是一个不可再分割的工作单元，事务中的操作要么都发生，要么都不发生。

一致性：事务开始之前和事务结束以后，数据库的完整性约束没有被破坏。这是说数据库事务不能破坏关系数据的完整性以及业务逻辑上的一致性。

持久性：意味着在事务完成以后，该事务所对数据库所作的更改便持久的保存在数据库之中，并不会被回滚。

隔离性：多个事务并发访问时，事务之间是隔离的，一个事务不应该影响其它事务运行效果。

三、DriverManager

public class DriverManager extends Object  管理一组 JDBC 驱动程序的基本服务。

方法摘要
static void	deregisterDriver(Driver driver)从 DriverManager 的列表中删除一个驱动程序。
static Connection	getConnection(String url)试图建立到给定数据库 URL 的连接。
static Connection	getConnection(String url, Properties info)试图建立到给定数据库 URL 的连接。
static Connection	getConnection(String url, String user, String password)试图建立到给定数据库 URL 的连接。
static Driver	getDriver(String url)试图查找能理解给定 URL 的驱动程序。
static Enumeration<Driver>	getDrivers()获取带有当前调用者可以访问的所有当前已加载 JDBC 驱动程序的 Enumeration。
static int	getLoginTimeout()获取驱动程序试图登录到某一数据库时可以等待的最长时间，以秒为单位。
static PrintStream	getLogStream()已过时。
static PrintWriter	getLogWriter() 获取日志 writer。
static void	println(String message)将一条消息打印到当前 JDBC 日志流中。
static void	registerDriver(Driver driver)向 DriverManager 注册给定驱动程序。
static void	setLoginTimeout(int seconds)设置驱动程序试图连接到某一数据库时将等待的最长时间，以秒为单位。
static void	setLogStream(PrintStream out)已过时。
static void	setLogWriter(PrintWriter out)设置由 DriverManager 和所有驱动程序使用的日志/追踪 PrintWriter 对象。

四、Connection

public interface Connection extends Wrapper, AutoCloseable

与特定数据库的连接（会话）。在连接上下文中执行 SQL 语句并返回结果。

Connection 对象的数据库能够提供描述其表、所支持的 SQL 语法、存储过程、此连接功能等等的信息。此信息是使用 getMetaData 方法获得的。

注：在配置 Connection 时，JDBC 应用程序应该使用适当的 Connection 方法，比如 setAutoCommit 或 setTransactionIsolation。在有可用的 JDBC 方法时，应用程序不能直接调用 SQL 命令更改连接的配置。默认情况下，Connection 对象处于自动提交模式下，这意味着它在执行每个语句后都会自动提交更改。如果禁用了自动提交模式，那么要提交更改就必须显式调用 commit 方法；否则无法保存数据库更改。

使用 JDBC 2.1 核心 API 创建的新 Connection 对象有一个与之关联的最初为空的类型映射。用户可以为此类型映射中的 UDT 输入一个自定义映射关系。在使用 ResultSet.getObject 方法从数据源中获取 UDT 时，getObject 方法将检查该连接的类型映射是否有对应该 UDT 的条目。如果有，那么 getObject 方法将该 UDT 映射到所指示的类。如果没有条目，则使用标准映射关系映射该 UDT。

用户可以创建一个新的类型映射，该映射是一个 java.util.Map 对象，可在其中创建一个条目，并将该条目传递给可以执行自定义映射关系的 java.sql 方法。在这种情况下，该方法将使用给定的类型映射，而不是与连接关联的映射。

例如，以下代码片段指定 SQL 类型 ATHLETES 将被映射到 Java 编程语言中的 Athletes 类。该代码片段为 Connection 对象 con 获取类型映射，并在其中插入条目，然后使用新的条目将该类型映射设置为连接的类型映射。

  java.util.Map map = con.getTypeMap();
  map.put("mySchemaName.ATHLETES", Class.forName("Athletes"));
  con.setTypeMap(map);

字段摘要
static int	TRANSACTION_NONE 指示事务不受支持的常量。
static int	TRANSACTION_READ_COMMITTED 指示不可以发生脏读的常量；不可重复读和虚读可以发生。
static int	TRANSACTION_READ_UNCOMMITTED 指示可以发生脏读 (dirty read)、不可重复读和虚读 (phantom read) 的常量。
static int	TRANSACTION_REPEATABLE_READ 指示不可以发生脏读和不可重复读的常量；虚读可以发生。
static int	TRANSACTION_SERIALIZABLE 指示不可以发生脏读、不可重复读和虚读的常量。

方法摘要
void	clearWarnings()清除为此 Connection 对象报告的所有警告。
void	close()立即释放此 Connection 对象的数据库和 JDBC 资源，而不是等待它们被自动释放。
void	commit()使所有上一次提交/回滚后进行的更改成为持久更改，并释放此 Connection 对象当前持有的所有数据库锁。
Array	createArrayOf(String typeName, Object[] elements)创建 Array 对象的工厂方法。
Blob	createBlob() 构造实现 Blob 接口的对象。
Clob	createClob()构造实现 Clob 接口的对象。
NClob	createNClob()构造实现 NClob 接口的对象。
SQLXML	createSQLXML()构造实现 SQLXML 接口的对象。
Statement	createStatement()创建一个 Statement 对象来将 SQL 语句发送到数据库。
Statement	createStatement(int resultSetType, int resultSetConcurrency)创建一个 Statement 对象，该对象将生成具有给定类型和并发性的 ResultSet 对象。
Statement	createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability)创建一个 Statement 对象，该对象将生成具有给定类型、并发性和可保存性的 ResultSet 对象。
Struct	createStruct(String typeName, Object[] attributes)创建 Struct 对象的工厂方法。
boolean	getAutoCommit()获取此 Connection 对象的当前自动提交模式。
String	getCatalog()获取此 Connection 对象的当前目录名称。
Properties	getClientInfo()返回一个列表，它包含驱动程序支持的每个客户端信息属性的名称和当前值。
String	getClientInfo(String name)返回通过名称指定的客户端信息属性的值。
int	getHoldability()获取使用此 Connection 对象创建的 ResultSet 对象的当前可保存性。
DatabaseMetaData	getMetaData()获取一个 DatabaseMetaData 对象，该对象包含关于此 Connection 对象所连接的数据库的元数据。
int	getTransactionIsolation()获取此 Connection 对象的当前事务隔离级别。
Map<String,Class<?>>	getTypeMap()获取与此 Connection 对象关联的 Map 对象。
SQLWarning	getWarnings()获取此 Connection 对象上的调用报告的第一个警告。
boolean	isClosed()查询此 Connection 对象是否已经被关闭。
boolean	isReadOnly()查询此 Connection 对象是否处于只读模式。
boolean	isValid(int timeout)如果连接尚未关闭并且仍然有效，则返回 true。
String	nativeSQL(String sql)将给定的 SQL 语句转换成系统本机 SQL 语法。
CallableStatement	prepareCall(String sql)创建一个 CallableStatement 对象来调用数据库存储过程。
CallableStatement	prepareCall(String sql, int resultSetType, int resultSetConcurrency)创建一个 CallableStatement 对象，该对象将生成具有给定类型和并发性的 ResultSet 对象。
CallableStatement	prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) 创建一个 CallableStatement 对象，该对象将生成具有给定类型和并发性的 ResultSet 对象。
PreparedStatement	prepareStatement(String sql)创建一个 PreparedStatement 对象来将参数化的 SQL 语句发送到数据库。
PreparedStatement	prepareStatement(String sql, int autoGeneratedKeys)创建一个默认 PreparedStatement 对象，该对象能获取自动生成的键。
PreparedStatement	prepareStatement(String sql, int[] columnIndexes) 创建一个能返回由给定数组指定的自动生成键的默认 PreparedStatement 对象。
PreparedStatement	prepareStatement(String sql, int resultSetType, int resultSetConcurrency) 创建一个 PreparedStatement 对象，该对象将生成具有给定类型和并发性的 ResultSet 对象。
PreparedStatement	prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)创建一个 PreparedStatement 对象，该对象将生成具有给定类型、并发性和可保存性的 ResultSet 对象。
PreparedStatement	prepareStatement(String sql, String[] columnNames)创建一个能返回由给定数组指定的自动生成键的默认 PreparedStatement 对象。
void	releaseSavepoint(Savepoint savepoint)从当前事务中移除指定的 Savepoint 和后续 Savepoint 对象。
void	rollback()取消在当前事务中进行的所有更改，并释放此 Connection 对象当前持有的所有数据库锁。
void	rollback(Savepoint savepoint)取消所有设置给定 Savepoint 对象之后进行的更改。
void	setAutoCommit(boolean autoCommit)将此连接的自动提交模式设置为给定状态。
void	setCatalog(String catalog)设置给定目录名称，以便选择要在其中进行工作的此 Connection 对象数据库的子空间。
void	setClientInfo(Properties properties)设置连接的客户端信息属性的值。
void	setClientInfo(String name, String value) 将 name 指定的客户端信息属性的值设置为 value 指定的值。
void	setHoldability(int holdability)将使用此 Connection 对象创建的 ResultSet 对象的默认可保存性 (holdability) 更改为给定可保存性。
void	setReadOnly(boolean readOnly)将此连接设置为只读模式，作为驱动程序启用数据库优化的提示。
Savepoint	setSavepoint()在当前事务中创建一个未命名的保存点 (savepoint)，并返回表示它的新 Savepoint 对象。
Savepoint	setSavepoint(String name)在当前事务中创建一个具有给定名称的保存点，并返回表示它的新 Savepoint 对象。
void	setTransactionIsolation(int level)试图将此 Connection 对象的事务隔离级别更改为给定的级别。
void	setTypeMap(Map<String,Class<?>> map)将给定的 TypeMap 对象安装为此 Connection 对象的类型映射。

其中的setAutoCommit（Boolean b）方法默认置为true；就是每执行一条sql语句，就自动提交一次；对于批量操作sql语句，需要手动先设置connection对象的setAutoCommit(false); 执行完sql操作后在执行提交事务的操作方法commit()。

eg: 批量插入数据到数据库

public static void test1(){
		
		Connection con = null;
		Statement stat = null;
		try {
			//1、加载驱动
			Class.forName("com.mysql.jdbc.Driver");
		
			try {
				 //2、获得驱动
				 con = DriverManager.getConnection("jdbc:mysql://localhost:3306/datatest","root","root");
			     con.setAutoCommit(false);

				 //3、向数据库发送sql语句
				 stat = con.createStatement();
				
				 long start = System.currentTimeMillis();
				 for(int i = 0; i<1000;i++){
					 String sql = "insert into user (name,age) values ('zhangsan"+i+"',18)" ;
					 stat.addBatch(sql);
				 }
				 
				
				 stat.executeBatch();
				 
				 con.commit();
			     
				 long end = System.currentTimeMillis();
				 System.out.println("插入1000条数据耗时"+(end-start)+"毫秒");
			   
				 
			} catch (SQLException e) {
				try {
					con.rollback();
				} catch (SQLException e1) {
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}
				e.printStackTrace();			}finally{
				if(null != con)
					try {
						con.close();
					} catch (SQLException e) {
						e.printStackTrace();
					}
				if(null != stat)
					try {
						stat.close();
					} catch (SQLException e) {
						e.printStackTrace();
					}
			}
		} catch (ClassNotFoundException e) {
			
			e.printStackTrace();
		}
	}

五、Statement

public interface Statement extends Wrapper   用于执行静态 SQL 语句并返回它所生成结果的对象

字段摘要
static int	CLOSE_ALL_RESULTS 该常量指示调用 getMoreResults 时应该关闭以前一直打开的所有 ResultSet 对象。
static int	CLOSE_CURRENT_RESULT 该常量指示调用 getMoreResults 时应该关闭当前 ResultSet 对象。
static int	EXECUTE_FAILED 该常量指示在执行批量语句时发生错误。
static int	KEEP_CURRENT_RESULT 该常量指示调用 getMoreResults 时应该关闭当前 ResultSet 对象。
static int	NO_GENERATED_KEYS 该常量指示生成的键应该不可用于获取。
static int	RETURN_GENERATED_KEYS 该常量指示生成的键应该可用于获取。
static int	SUCCESS_NO_INFO 该常量指示批量语句执行成功但不存在受影响的可用行数计数。

方法摘要
void	addBatch(String sql) 将给定的 SQL 命令添加到此 Statement 对象的当前命令列表中。
void	cancel() 如果 DBMS 和驱动程序都支持中止 SQL 语句，则取消此 Statement 对象。
void	clearBatch() 清空此 Statement 对象的当前 SQL 命令列表。
void	clearWarnings() 清除在此 Statement 对象上报告的所有警告。
void	close() 立即释放此 Statement 对象的数据库和 JDBC 资源，而不是等待该对象自动关闭时发生此操作。
boolean	execute(String sql) 执行给定的 SQL 语句，该语句可能返回多个结果。
boolean	execute(String sql, int autoGeneratedKeys) 执行给定的 SQL 语句（该语句可能返回多个结果），并通知驱动程序所有自动生成的键都应该可用于获取。
boolean	execute(String sql, int[] columnIndexes) 执行给定的 SQL 语句（该语句可能返回多个结果），并通知驱动程序在给定数组中指示的自动生成的键应该可用于获取。
boolean	execute(String sql, String[] columnNames) 执行给定的 SQL 语句（该语句可能返回多个结果），并通知驱动程序在给定数组中指示的自动生成的键应该可用于获取。
int[]	executeBatch() 将一批命令提交给数据库来执行，如果全部命令执行成功，则返回更新计数组成的数组。
ResultSet	executeQuery(String sql) 执行给定的 SQL 语句，该语句返回单个 ResultSet 对象。
int	executeUpdate(String sql) 执行给定 SQL 语句，该语句可能为 INSERT、UPDATE 或 DELETE 语句，或者不返回任何内容的 SQL 语句（如 SQL DDL 语句）。
int	executeUpdate(String sql, int autoGeneratedKeys) 执行给定的 SQL 语句，并用给定标志通知驱动程序由此 Statement 生成的自动生成键是否可用于获取。
int	executeUpdate(String sql, int[] columnIndexes) 执行给定的 SQL 语句，并通知驱动程序在给定数组中指示的自动生成的键应该可用于获取。
int	executeUpdate(String sql, String[] columnNames) 执行给定的 SQL 语句，并通知驱动程序在给定数组中指示的自动生成的键应该可用于获取。
Connection	getConnection() 获取生成此 Statement 对象的 Connection 对象。
int	getFetchDirection() 获取从数据库表获取行的方向，该方向是根据此 Statement 对象生成的结果集合的默认值。
int	getFetchSize() 获取结果集合的行数，该数是根据此 Statement 对象生成的 ResultSet 对象的默认获取大小。
ResultSet	getGeneratedKeys() 获取由于执行此 Statement 对象而创建的所有自动生成的键。
int	getMaxFieldSize() 获取可以为此 Statement 对象所生成 ResultSet 对象中的字符和二进制列值返回的最大字节数。
int	getMaxRows() 获取由此 Statement 对象生成的 ResultSet 对象可以包含的最大行数。
boolean	getMoreResults() 移动到此 Statement 对象的下一个结果，如果其为 ResultSet 对象，则返回 true，并隐式关闭利用方法 getResultSet 获取的所有当前 ResultSet 对象。
boolean	getMoreResults(int current) 将此 Statement 对象移动到下一个结果，根据给定标志指定的指令处理所有当前 ResultSet 对象；如果下一个结果为 ResultSet 对象，则返回 true。
int	getQueryTimeout() 获取驱动程序等待 Statement 对象执行的秒数。
ResultSet	getResultSet() 以 ResultSet 对象的形式获取当前结果。
int	getResultSetConcurrency() 获取此 Statement 对象生成的 ResultSet 对象的结果集合并发性。
int	getResultSetHoldability() 获取此 Statement 对象生成的 ResultSet 对象的结果集合可保存性。
int	getResultSetType() 获取此 Statement 对象生成的 ResultSet 对象的结果集合类型。
int	getUpdateCount() 以更新计数的形式获取当前结果；如果结果为 ResultSet 对象或没有更多结果，则返回 -1。
SQLWarning	getWarnings() 获取此 Statement 对象上的调用报告的第一个警告。
boolean	isClosed() 获取是否已关闭了此 Statement 对象。
boolean	isPoolable() 返回指示 Statement 是否是可池化的值。
void	setCursorName(String name) 将 SQL 指针名称设置为给定的 String，后续 Statement 对象的 execute 方法将使用此字符串。
void	setEscapeProcessing(boolean enable) 将转义处理设置为开或关。
void	setFetchDirection(int direction) 向驱动程序提供关于方向的提示，在使用此 Statement 对象创建的 ResultSet 对象中将按该方向处理行。
void	setFetchSize(int rows) 为 JDBC 驱动程序提供一个提示，它提示此 Statement 生成的 ResultSet 对象需要更多行时应该从数据库获取的行数。
void	setMaxFieldSize(int max) 设置此 Statement 对象生成的 ResultSet 对象中字符和二进制列值可以返回的最大字节数限制。
void	setMaxRows(int max) 将此 Statement 对象生成的所有 ResultSet 对象可以包含的最大行数限制设置为给定数。
void	setPoolable(boolean poolable) 请求将 Statement 池化或非池化。
void	setQueryTimeout(int seconds) 将驱动程序等待 Statement 对象执行的秒数设置为给定秒数。

六、PreparedStatement

public interface PreparedStatement extends Statement

表示预编译的 SQL 语句的对象。

SQL 语句被预编译并存储在 PreparedStatement 对象中。然后可以使用此对象多次高效地执行该语句。

注：用于设置 IN 参数值的设置方法（setShort、setString 等等）必须指定与输入参数的已定义 SQL 类型兼容的类型。例如，如果 IN 参数具有 SQL 类型 INTEGER，那么应该使用 setInt 方法。

如果需要任意参数类型转换，使用 setObject 方法时应该将目标 SQL 类型作为其参数。

在以下设置参数的示例中，con 表示一个活动连接：

   PreparedStatement pstmt = con.prepareStatement("UPDATE EMPLOYEES SET SALARY = ? WHERE ID = ?");
   pstmt.setBigDecimal(1, 153833.00)
   pstmt.setInt(2, 110592)
这样可防止statement中的sql注入等不安全问题。

方法摘要
void	addBatch() 将一组参数添加到此 PreparedStatement 对象的批处理命令中。
void	clearParameters() 立即清除当前参数值。
boolean	execute() 在此 PreparedStatement 对象中执行 SQL 语句，该语句可以是任何种类的 SQL 语句。
ResultSet	executeQuery() 在此 PreparedStatement 对象中执行 SQL 查询，并返回该查询生成的 ResultSet 对象。
int	executeUpdate() 在此 PreparedStatement 对象中执行 SQL 语句，该语句必须是一个 SQL 数据操作语言（Data Manipulation Language，DML）语句，比如 INSERT、UPDATE 或 DELETE 语句；或者是无返回内容的 SQL 语句，比如 DDL 语句。
ResultSetMetaData	getMetaData() 获取包含有关 ResultSet 对象列信息的 ResultSetMetaData 对象，ResultSet 对象将在执行此 PreparedStatement 对象时返回。
ParameterMetaData	getParameterMetaData() 获取此 PreparedStatement 对象的参数的编号、类型和属性。
void	setArray(int parameterIndex, Array x) 将指定参数设置为给定 java.sql.Array 对象。
void	setAsciiStream(int parameterIndex, InputStream x) 将指定参数设置为给定输入流。
void	setAsciiStream(int parameterIndex, InputStream x, int length) 将指定参数设置为给定输入流，该输入流将具有给定字节数。
void	setAsciiStream(int parameterIndex, InputStream x, long length) 将指定参数设置为给定输入流，该输入流将具有指定字节数。
void	setBigDecimal(int parameterIndex, BigDecimal x) 将指定参数设置为给定 java.math.BigDecimal 值。
void	setBinaryStream(int parameterIndex, InputStream x) 将指定参数设置为给定输入流。
void	setBinaryStream(int parameterIndex, InputStream x, int length) 将指定参数设置为给定输入流，该输入流将具有给定字节数。
void	setBinaryStream(int parameterIndex, InputStream x, long length) 将指定参数设置为给定输入流，该输入流将具有指定字节数。
void	setBlob(int parameterIndex, Blob x) 将指定参数设置为给定 java.sql.Blob 对象。
void	setBlob(int parameterIndex, InputStream inputStream) 将指定参数设置为 InputStream 对象。
void	setBlob(int parameterIndex, InputStream inputStream, long length) 将指定参数设置为 InputStream 对象。
void	setBoolean(int parameterIndex, boolean x) 将指定参数设置为给定 Java boolean 值。
void	setByte(int parameterIndex, byte x) 将指定参数设置为给定 Java byte 值。
void	setBytes(int parameterIndex, byte[] x) 将指定参数设置为给定 Java byte 数组。
void	setCharacterStream(int parameterIndex, Reader reader) 将指定参数设置为给定 Reader 对象。
void	setCharacterStream(int parameterIndex, Reader reader, int length) 将给定参数设置为给定 Reader 对象，该对象具有给定字符数长度。
void	setCharacterStream(int parameterIndex, Reader reader, long length) 将指定参数设置为给定 Reader 对象，该对象具有给定字符数长度。
void	setClob(int parameterIndex, Clob x) 将指定参数设置为给定 java.sql.Clob 对象。
void	setClob(int parameterIndex, Reader reader) 将指定参数设置为 Reader 对象。
void	setClob(int parameterIndex, Reader reader, long length) 将指定参数设置为 Reader 对象。
void	setDate(int parameterIndex, Date x) 使用运行应用程序的虚拟机的默认时区将指定参数设置为给定 java.sql.Date 值。
void	setDate(int parameterIndex, Date x, Calendar cal) 使用给定的 Calendar 对象将指定参数设置为给定 java.sql.Date 值。
void	setDouble(int parameterIndex, double x) 将指定参数设置为给定 Java double 值。
void	setFloat(int parameterIndex, float x) 将指定参数设置为给定 Java REAL 值。
void	setInt(int parameterIndex, int x) 将指定参数设置为给定 Java int 值。
void	setLong(int parameterIndex, long x) 将指定参数设置为给定 Java long 值。
void	setNCharacterStream(int parameterIndex, Reader value) 将指定参数设置为 Reader 对象。
void	setNCharacterStream(int parameterIndex, Reader value, long length) 将指定参数设置为 Reader 对象。
void	setNClob(int parameterIndex, NClob value) 将指定参数设置为 java.sql.NClob 对象。
void	setNClob(int parameterIndex, Reader reader) 将指定参数设置为 Reader 对象。
void	setNClob(int parameterIndex, Reader reader, long length) 将指定参数设置为 Reader 对象。
void	setNString(int parameterIndex, String value) 将指定参数设置为给定 String 对象。
void	setNull(int parameterIndex, int sqlType) 将指定参数设置为 SQL NULL。
void	setNull(int parameterIndex, int sqlType, String typeName) 将指定参数设置为 SQL NULL。
void	setObject(int parameterIndex, Object x) 使用给定对象设置指定参数的值。
void	setObject(int parameterIndex, Object x, int targetSqlType) 使用给定对象设置指定参数的值。
void	setObject(int parameterIndex, Object x, int targetSqlType, int scaleOrLength) 使用给定对象设置指定参数的值。
void	setRef(int parameterIndex, Ref x) 将指定参数设置为给定 REF(<structured-type>) 值。
void	setRowId(int parameterIndex, RowId x) 将指定参数设置为给定 java.sql.RowId 对象。
void	setShort(int parameterIndex, short x) 将指定参数设置为给定 Java short 值。
void	setSQLXML(int parameterIndex, SQLXML xmlObject) 将指定参数设置为给定 java.sql.SQLXML 对象。
void	setString(int parameterIndex, String x) 将指定参数设置为给定 Java String 值。
void	setTime(int parameterIndex, Time x) 将指定参数设置为给定 java.sql.Time 值。
void	setTime(int parameterIndex, Time x, Calendar cal) 使用给定的 Calendar 对象将指定参数设置为给定 java.sql.Time 值。
void	setTimestamp(int parameterIndex, Timestamp x) 将指定参数设置为给定 java.sql.Timestamp 值。
void	setTimestamp(int parameterIndex, Timestamp x, Calendar cal) 使用给定的 Calendar 对象将指定参数设置为给定 java.sql.Timestamp 值。
void	setUnicodeStream(int parameterIndex, InputStream x, int length) 已过时。
void	setURL(int parameterIndex, URL x) 将指定参数设置为给定 java.net.URL 值。

七、CallableStatement

public interface CallableStatement extends PreparedStatement

用于执行 SQL 存储过程的接口。JDBC API 提供了一个存储过程 SQL 转义语法，该语法允许对所有 RDBMS 使用标准方式调用存储过程。此转义语法有一个包含结果参数的形式和一个不包含结果参数的形式。如果使用结果参数，则必须将其注册为 OUT 参数。其他参数可用于输入、输出或同时用于二者。参数是根据编号按顺序引用的，第一个参数的编号是 1。

   {?= call <procedure-name>[(<arg1>,<arg2>, ...)]}

   {call <procedure-name>[(<arg1>,<arg2>, ...)]}

IN 参数值是使用继承自 PreparedStatement 的 set 方法设置的。在执行存储过程之前，必须注册所有 OUT 参数的类型；它们的值是在执行后通过此类提供的 get 方法获取的。

CallableStatement 可以返回一个 ResultSet 对象或多个 ResultSet 对象。多个 ResultSet 对象是使用继承自 Statement 的操作处理的。

为了获得最大的可移植性，某一调用的 ResultSet 对象和更新计数应该在获得输出参数的值之前处理。

下面讲解下存储过程的基本用法：

优点：

存储过程增强了SQL语言的功能和灵活性。存储过程可以用流控制语句编写，有很强的灵活性，可以完成复杂的判断和较复杂的运算。
当SQL语句有变动时，可以只修改数据库中的存储过程而不必修改代码。
存储过程能实现较快的执行速度。如果某一操作包含大量的SQL代码或分别被多次执行，那么存储过程要比批处理的执行速度快很多。因为存储过程是预编译的。在首次运行一个存储过程时查询，优化器对其进行分析优化，并且给出最终被存储在系统表中的执行计划。而批处理的SQL语句在每次运行时都要进行编译和优化，速度相对要慢一些。
减少网络传输。在客户端调用一个存储过程当然比执行一串SQL传输的数据量要小。
存储过程可被作为一种安全机制来充分利用。系统管理员通过执行某一存储过程的权限进行限制，能够实现对相应的数据的访问权限的限制，避免了非授权用户对数据的访问，保证了数据的安全。

缺点：

不同的数据库存储过程语法差异很大，不便于移植。

创建存储过程

create procedure sp_name()
begin
.........
end

调用存储过程

1.基本语法：call sp_name()
注意：存储过程名称后面必须加括号，哪怕该存储过程没有参数传递

删除存储过程

1.基本语法：
drop procedure sp_name//

2.注意事项
(1)不能在一个存储过程中删除另一个存储过程，只能调用另一个存储过程

其他常用命令

1.show procedure status
显示数据库中所有存储的存储过程基本信息，包括所属数据库，存储过程名称，创建时间等

2.show create procedure sp_name
显示某一个MySQL存储过程的详细信息

mysql存储过程的参数用在存储过程的定义，共有三种参数类型,IN,OUT,INOUT

Create procedure|function([[IN |OUT |INOUT ] 参数名数据类形...])

IN 输入参数

表示该参数的值必须在调用存储过程时指定，在存储过程中修改该参数的值不能被返回，为默认值

OUT 输出参数

该值可在存储过程内部被改变，并可返回

INOUT 输入输出参数

调用时指定，并且可被改变和返回

下面举例说明如何通过callableStatement调用存储过程。

1)、数据库首选需要创建存储过程

DROP PROCEDURE IF EXISTS datatest.`proc_case`;
CREATE DEFINER=`root`@`localhost` PROCEDURE `proc_case`(IN type int)
BEGIN
    #Routine body goes here...
    DECLARE c varchar(500);
    CASE type
    WHEN 0 THEN
        set c = 'param is 0';
    WHEN 1 THEN
        set c = 'param is 1';
    ELSE
        set c = 'param is others, not 0 or 1';
    END CASE;
    select c;
END

2)、java代码中调用该存储过程

package dataBaseConnection;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;

/**
 * @author:zhangfd
 * @version:1.0
 * @date:2017年7月2日 下午2:28:59
 * @description:
 */
public class CallableStatementTest {

	public static void main(String[] args) {

		Connection con = null;

		CallableStatement callst = null;

		ResultSet rs = null;

		con = ConnectionUtil.getMySqlcon();

		String sql = "call datatest.proc_case(?)";
		try {
			callst = con.prepareCall(sql);

			callst.setInt(1, 1);

			rs = callst.executeQuery(); // 注意：所有调用存储过程的sql语句都是使用executeQuery方法执行！！！

			while (rs.next()) {

				String c = rs.getString("c");
				System.out.println(c);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			ConnectionUtil.close(con, callst, rs);
		}
	}
}

八、ResultSet

public interface ResultSet extends Wrapper

表示数据库结果集的数据表，通常通过执行查询数据库的语句生成。

ResultSet 对象具有指向其当前数据行的光标。最初，光标被置于第一行之前。next 方法将光标移动到下一行；因为该方法在 ResultSet 对象没有下一行时返回 false，所以可以在 while 循环中使用它来迭代结果集。

默认的 ResultSet 对象不可更新，仅有一个向前移动的光标。因此，只能迭代它一次，并且只能按从第一行到最后一行的顺序进行。可以生成可滚动和/或可更新的 ResultSet 对象。以下代码片段（其中 con 为有效的 Connection 对象）演示了如何生成可滚动且不受其他更新影响的可更新结果集。有关其他选项，请参见 ResultSet 字段。

Statement stmt = con.createStatement( ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);

ResultSet rs = stmt.executeQuery("SELECT a, b FROM TABLE2");

// rs will be scrollable, will not show changes made by others,

// and will be updatable

ResultSet 接口提供用于从当前行获取列值的获取方法（getBoolean、getLong 等）。可以使用列的索引编号或列的名称获取值。一般情况下，使用列索引较为高效。列从 1 开始编号。为了获得最大的可移植性，应该按从左到右的顺序读取每行中的结果集列，每列只能读取一次。

对于获取方法，JDBC 驱动程序尝试将底层数据转换为在获取方法中指定的 Java 类型，并返回适当的 Java 值。JDBC 规范有一个表，显示允许的从 SQL 类型到 ResultSet 获取方法所使用的 Java 类型的映射关系。

用作获取方法的输入的列名称不区分大小写。用列名称调用获取方法时，如果多个列具有这一名称，则返回第一个匹配列的值。在生成结果集的 SQL 查询中使用列名称时，将使用列名称选项。对于没有在查询中显式指定的列，最好使用列编号。如果使用列名称，则程序员应该注意保证名称唯一引用预期的列，这可以使用 SQL AS 子句确定

当生成 ResultSet 对象的 Statement 对象关闭、重新执行或用来从多个结果的序列获取下一个结果时，ResultSet 对象将自动关闭。

方法摘要
boolean	absolute(int row) 将光标移动到此 ResultSet 对象的给定行编号。
void	afterLast() 将光标移动到此 ResultSet 对象的末尾，正好位于最后一行之后。
void	beforeFirst() 将光标移动到此 ResultSet 对象的开头，正好位于第一行之前。
void	cancelRowUpdates() 取消对 ResultSet 对象中的当前行所作的更新。
void	clearWarnings() 清除在此 ResultSet 对象上报告的所有警告。
void	close() 立即释放此 ResultSet 对象的数据库和 JDBC 资源，而不是等待该对象自动关闭时发生此操作。
void	deleteRow() 从此 ResultSet 对象和底层数据库中删除当前行。
int	findColumn(String columnLabel) 将给定的 ResultSet 列标签映射到其 ResultSet 列索引。
boolean	first() 将光标移动到此 ResultSet 对象的第一行。
Array	getArray(int columnIndex) 以 Java 编程语言中 Array 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Array	getArray(String columnLabel) 以 Java 编程语言中 Array 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
InputStream	getAsciiStream(int columnIndex) 以 ASCII 字符流的形式获取此 ResultSet 对象的当前行中指定列的值。
InputStream	getAsciiStream(String columnLabel) 以 ASCII 字符流的形式获取此 ResultSet 对象的当前行中指定列的值。
BigDecimal	getBigDecimal(int columnIndex) 以具有全精度的 java.math.BigDecimal 的形式获取此 ResultSet 对象的当前行中指定列的值。
BigDecimal	getBigDecimal(int columnIndex, int scale) 已过时。
BigDecimal	getBigDecimal(String columnLabel) 以具有全精度的 java.math.BigDecimal 的形式获取此 ResultSet 对象的当前行中指定列的值。
BigDecimal	getBigDecimal(String columnLabel, int scale) 已过时。
InputStream	getBinaryStream(int columnIndex) 以未解释字节的流的形式获取此 ResultSet 对象的当前行中指定列的值。
InputStream	getBinaryStream(String columnLabel) 以未解释的 byte 流的形式获取此 ResultSet 对象的当前行中指定列的值。
Blob	getBlob(int columnIndex) 以 Java 编程语言中 Blob 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Blob	getBlob(String columnLabel) 以 Java 编程语言中 Blob 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
boolean	getBoolean(int columnIndex) 以 Java 编程语言中 boolean 的形式获取此 ResultSet 对象的当前行中指定列的值。
boolean	getBoolean(String columnLabel) 以 Java 编程语言中 boolean 的形式获取此 ResultSet 对象的当前行中指定列的值。
byte	getByte(int columnIndex) 以 Java 编程语言中 byte 的形式获取此 ResultSet 对象的当前行中指定列的值。
byte	getByte(String columnLabel) 以 Java 编程语言中 byte 的形式获取此 ResultSet 对象的当前行中指定列的值。
byte[]	getBytes(int columnIndex) 以 Java 编程语言中 byte 数组的形式获取此 ResultSet 对象的当前行中指定列的值。
byte[]	getBytes(String columnLabel) 以 Java 编程语言中 byte 数组的形式获取此 ResultSet 对象的当前行中指定列的值。
Reader	getCharacterStream(int columnIndex) 以 java.io.Reader 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Reader	getCharacterStream(String columnLabel) 以 java.io.Reader 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Clob	getClob(int columnIndex) 以 Java 编程语言中 Clob 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Clob	getClob(String columnLabel) 以 Java 编程语言中 Clob 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
int	getConcurrency() 获取此 ResultSet 对象的并发模式。
String	getCursorName() 获取此 ResultSet 对象使用的 SQL 光标的名称。
Date	getDate(int columnIndex) 以 Java 编程语言中 java.sql.Date 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Date	getDate(int columnIndex, Calendar cal) 以 Java 编程语言中 java.sql.Date 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Date	getDate(String columnLabel) 以 Java 编程语言中的 java.sql.Date 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Date	getDate(String columnLabel, Calendar cal) 以 Java 编程语言中 java.sql.Date 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
double	getDouble(int columnIndex) 以 Java 编程语言中 double 的形式获取此 ResultSet 对象的当前行中指定列的值。
double	getDouble(String columnLabel) 以 Java 编程语言中 double 的形式获取此 ResultSet 对象的当前行中指定列的值。
int	getFetchDirection() 获取此 ResultSet 对象的获取方向。
int	getFetchSize() 获取此 ResultSet 对象的获取大小。
float	getFloat(int columnIndex) 以 Java 编程语言中 float 的形式获取此 ResultSet 对象的当前行中指定列的值。
float	getFloat(String columnLabel) 以 Java 编程语言中 float 的形式获取此 ResultSet 对象的当前行中指定列的值。
int	getHoldability() 获取此 ResultSet 对象的可保存性
int	getInt(int columnIndex) 以 Java 编程语言中 int 的形式获取此 ResultSet 对象的当前行中指定列的值。
int	getInt(String columnLabel) 以 Java 编程语言中 int 的形式获取此 ResultSet 对象的当前行中指定列的值。
long	getLong(int columnIndex) 以 Java 编程语言中 long 的形式获取此 ResultSet 对象的当前行中指定列的值。
long	getLong(String columnLabel) 以 Java 编程语言中 long 的形式获取此 ResultSet 对象的当前行中指定列的值。
ResultSetMetaData	getMetaData() 获取此 ResultSet 对象的列的编号、类型和属性。
Reader	getNCharacterStream(int columnIndex) 以 java.io.Reader 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Reader	getNCharacterStream(String columnLabel) 以 java.io.Reader 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
NClob	getNClob(int columnIndex) 以 Java 编程语言中 NClob 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
NClob	getNClob(String columnLabel) 以 Java 编程语言中 NClob 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
String	getNString(int columnIndex) 以 Java 编程语言中 String 的形式获取此 ResultSet 对象的当前行中指定列的值。
String	getNString(String columnLabel) 以 Java 编程语言中 String 的形式获取此 ResultSet 对象的当前行中指定列的值。
Object	getObject(int columnIndex) 以 Java 编程语言中 Object 的形式获取此 ResultSet 对象的当前行中指定列的值。
Object	getObject(int columnIndex, Map<String,Class<?>> map) 以 Java 编程语言中 Object 的形式获取此 ResultSet 对象的当前行中指定列的值。
Object	getObject(String columnLabel) 以 Java 编程语言中 Object 的形式获取此 ResultSet 对象的当前行中指定列的值。
Object	getObject(String columnLabel, Map<String,Class<?>> map) 以 Java 编程语言中 Object 的形式获取此 ResultSet 对象的当前行中指定列的值。
Ref	getRef(int columnIndex) 以 Java 编程语言中 Ref 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Ref	getRef(String columnLabel) 以 Java 编程语言中 Ref 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
int	getRow() 获取当前行编号。
RowId	getRowId(int columnIndex) 以 Java 编程语言中 java.sql.RowId 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
RowId	getRowId(String columnLabel) 以 Java 编程语言中 java.sql.RowId 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
short	getShort(int columnIndex) 以 Java 编程语言中 short 的形式获取此 ResultSet 对象的当前行中指定列的值。
short	getShort(String columnLabel) 以 Java 编程语言中 short 的形式获取此 ResultSet 对象的当前行中指定列的值。
SQLXML	getSQLXML(int columnIndex) 以 Java 编程语言中 java.sql.SQLXML 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
SQLXML	getSQLXML(String columnLabel) 以 Java 编程语言中 java.sql.SQLXML 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Statement	getStatement() 获取生成此 ResultSet 对象的 Statement 对象。
String	getString(int columnIndex) 以 Java 编程语言中 String 的形式获取此 ResultSet 对象的当前行中指定列的值。
String	getString(String columnLabel) 以 Java 编程语言中 String 的形式获取此 ResultSet 对象的当前行中指定列的值。
Time	getTime(int columnIndex) 以 Java 编程语言中 java.sql.Time 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Time	getTime(int columnIndex, Calendar cal) 以 Java 编程语言中 java.sql.Time 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Time	getTime(String columnLabel) 以 Java 编程语言中 java.sql.Time 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Time	getTime(String columnLabel, Calendar cal) 以 Java 编程语言中 java.sql.Time 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Timestamp	getTimestamp(int columnIndex) 以 Java 编程语言中 java.sql.Timestamp 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Timestamp	getTimestamp(int columnIndex, Calendar cal) 以 Java 编程语言中 java.sql.Timestamp 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Timestamp	getTimestamp(String columnLabel) 以 Java 编程语言中 java.sql.Timestamp 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Timestamp	getTimestamp(String columnLabel, Calendar cal) 以 Java 编程语言中 java.sql.Timestamp 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
int	getType() 获取此 ResultSet 对象的类型。
InputStream	getUnicodeStream(int columnIndex) 已过时。使用 getCharacterStream 取代 getUnicodeStream
InputStream	getUnicodeStream(String columnLabel) 已过时。使用 getCharacterStream 代替
URL	getURL(int columnIndex) 以 Java 编程语言中 java.net.URL 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
URL	getURL(String columnLabel) 以 Java 编程语言中 java.net.URL 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
SQLWarning	getWarnings() 获取此 ResultSet 对象上的调用报告的第一个警告。
void	insertRow() 将插入行的内容插入到此 ResultSet 对象和数据库中。
boolean	isAfterLast() 获取光标是否位于此 ResultSet 对象的最后一行之后。
boolean	isBeforeFirst() 获取光标是否位于此 ResultSet 对象的第一行之前。
boolean	isClosed() 获取此 ResultSet 对象是否已关闭。
boolean	isFirst() 获取光标是否位于此 ResultSet 对象的第一行。
boolean	isLast() 获取光标是否位于此 ResultSet 对象的最后一行。
boolean	last() 将光标移动到此 ResultSet 对象的最后一行。
void	moveToCurrentRow() 将光标移动到记住的光标位置，通常为当前行。
void	moveToInsertRow() 将光标移动到插入行。
boolean	next() 将光标从当前位置向前移一行。
boolean	previous() 将光标移动到此 ResultSet 对象的上一行。
void	refreshRow() 用数据库中的最近值刷新当前行。
boolean	relative(int rows) 按相对行数（或正或负）移动光标。
boolean	rowDeleted() 获取是否已删除某行。
boolean	rowInserted() 获取当前行是否已有插入。
boolean	rowUpdated() 获取是否已更新当前行。
void	setFetchDirection(int direction) 设置此 ResultSet 对象中行的处理方向。
void	setFetchSize(int rows) 为 JDBC 驱动程序设置此 ResultSet 对象需要更多行时应该从数据库获取的行数。
void	updateArray(int columnIndex, Array x) 用 java.sql.Array 值更新指定列。
void	updateArray(String columnLabel, Array x) 用 java.sql.Array 值更新指定列。
void	updateAsciiStream(int columnIndex, InputStream x) 用 ascii 流值更新指定的列。
void	updateAsciiStream(int columnIndex, InputStream x, int length) 用 ascii 流值更新指定列，该列将具有指定字节数。
void	updateAsciiStream(int columnIndex, InputStream x, long length) 用 ascii 流值更新指定的列，该值将具有指定的字节数。
void	updateAsciiStream(String columnLabel, InputStream x) 用 ascii 流值更新指定列。
void	updateAsciiStream(String columnLabel, InputStream x, int length) 用 ascii 流值更新指定列，该列具有指定的字节数。
void	updateAsciiStream(String columnLabel, InputStream x, long length) 用 ascii 流值更新指定的列，该值将具有指定的字节数。
void	updateBigDecimal(int columnIndex, BigDecimal x) 用 java.math.BigDecimal 值更新指定列。
void	updateBigDecimal(String columnLabel, BigDecimal x) 用 java.sql.BigDecimal 值更新指定列。
void	updateBinaryStream(int columnIndex, InputStream x) 用二进制流值更新指定的列。
void	updateBinaryStream(int columnIndex, InputStream x, int length) 用二进制流值更新指定列，该列将具有指定字节数。
void	updateBinaryStream(int columnIndex, InputStream x, long length) 用二进制流值更新指定的列，该值将具有指定的字节数。
void	updateBinaryStream(String columnLabel, InputStream x) 用二进制流值更新指定列。
void	updateBinaryStream(String columnLabel, InputStream x, int length) 用二进制流值更新指定列，该列具有指定的字节数。
void	updateBinaryStream(String columnLabel, InputStream x, long length) 用二进制流值更新指定的列，该值将具有指定的字节数。
void	updateBlob(int columnIndex, Blob x) 用 java.sql.Blob 值更新指定列。
void	updateBlob(int columnIndex, InputStream inputStream) 使用给定输入流值更新指定列。
void	updateBlob(int columnIndex, InputStream inputStream, long length) 使用给定输入流更新指定的列，该流将具有指定的字节数。
void	updateBlob(String columnLabel, Blob x) 用 java.sql.Blob 值更新指定列。
void	updateBlob(String columnLabel, InputStream inputStream) 使用给定输入流值更新指定列。
void	updateBlob(String columnLabel, InputStream inputStream, long length) 使用给定输入流更新指定列，该流将具有指定的字节数。
void	updateBoolean(int columnIndex, boolean x) 用 boolean 值更新指定列。
void	updateBoolean(String columnLabel, boolean x) 用 boolean 值更新指定列。
void	updateByte(int columnIndex, byte x) 用 byte 值更新指定列。
void	updateByte(String columnLabel, byte x) 用 byte 值更新指定列。
void	updateBytes(int columnIndex, byte[] x) 用 byte 数组值更新指定列。
void	updateBytes(String columnLabel, byte[] x) 用字节数组值更新指定列。
void	updateCharacterStream(int columnIndex, Reader x) 用字符流值更新指定的列。
void	updateCharacterStream(int columnIndex, Reader x, int length) 用字符流值更新指定列，该列将具有指定字节数。
void	updateCharacterStream(int columnIndex, Reader x, long length) 用字符流值更新指定的列，该值将具有指定的字节数。
void	updateCharacterStream(String columnLabel, Reader reader) 用字符流值更新指定列。
void	updateCharacterStream(String columnLabel, Reader reader, int length) 用字符流值更新指定列，该列具有指定的字节数。
void	updateCharacterStream(String columnLabel, Reader reader, long length) 用字符流值更新指定的列，该值将具有指定的字节数。
void	updateClob(int columnIndex, Clob x) 用 java.sql.Clob 值更新指定列。
void	updateClob(int columnIndex, Reader reader) 使用给定的 Reader 对象更新指定列。
void	updateClob(int columnIndex, Reader reader, long length) 使用给定的 Reader 对象更新指定列，该对象是给定的字符长度数目。
void	updateClob(String columnLabel, Clob x) 用 java.sql.Clob 值更新指定列。
void	updateClob(String columnLabel, Reader reader) 使用给定的 Reader 对象更新指定列。
void	updateClob(String columnLabel, Reader reader, long length) 使用给定的 Reader 对象更新指定列，该对象是给定的字符长度数目。
void	updateDate(int columnIndex, Date x) 用 java.sql.Date 值更新指定列。
void	updateDate(String columnLabel, Date x) 用 java.sql.Date 值更新指定列。
void	updateDouble(int columnIndex, double x) 用 double 值更新指定列。
void	updateDouble(String columnLabel, double x) 用 double 值更新指定列。
void	updateFloat(int columnIndex, float x) 用 float 值更新指定列。
void	updateFloat(String columnLabel, float x) 用 float 值更新指定列。
void	updateInt(int columnIndex, int x) 用 int 值更新指定列。
void	updateInt(String columnLabel, int x) 用 int 值更新指定列。
void	updateLong(int columnIndex, long x) 用 long 值更新指定列。
void	updateLong(String columnLabel, long x) 用 long 值更新指定列。
void	updateNCharacterStream(int columnIndex, Reader x) 用字符流值更新指定的列。
void	updateNCharacterStream(int columnIndex, Reader x, long length) 用字符流值更新指定的列，该值将具有指定的字节数。
void	updateNCharacterStream(String columnLabel, Reader reader) 用字符流值更新指定的列。
void	updateNCharacterStream(String columnLabel, Reader reader, long length) 用字符流值更新指定的列，该值将具有指定的字节数。
void	updateNClob(int columnIndex, NClob nClob) 用 java.sql.NClob 值更新指定的列。
void	updateNClob(int columnIndex, Reader reader) 使用给定的 Reader 对象更新指定列。
void	updateNClob(int columnIndex, Reader reader, long length) 使用给定的 Reader 对象更新指定的列，该对象是给定的字符长度数目。
void	updateNClob(String columnLabel, NClob nClob) 用 java.sql.NClob 值更新指定的列。
void	updateNClob(String columnLabel, Reader reader) 使用给定的 Reader 对象更新指定列。
void	updateNClob(String columnLabel, Reader reader, long length) 使用给定的 Reader 对象更新指定的列，该对象是给定的字符长度数目。
void	updateNString(int columnIndex, String nString) 用 String 值更新指定的列。
void	updateNString(String columnLabel, String nString) 用 String 值更新指定的列。
void	updateNull(int columnIndex) 用 null 值更新指定列。
void	updateNull(String columnLabel) 用 null 值更新指定列。
void	updateObject(int columnIndex, Object x) 用 Object 值更新指定列。
void	updateObject(int columnIndex, Object x, int scaleOrLength) 用 Object 值更新指定列。
void	updateObject(String columnLabel, Object x) 用 Object 值更新指定列。
void	updateObject(String columnLabel, Object x, int scaleOrLength) 用 Object 值更新指定列。
void	updateRef(int columnIndex, Ref x) 用 java.sql.Ref 值更新指定列。
void	updateRef(String columnLabel, Ref x) 用 java.sql.Ref 值更新指定列。
void	updateRow() 用此 ResultSet 对象的当前行的新内容更新底层数据库。
void	updateRowId(int columnIndex, RowId x) 用 RowId 值更新指定列。
void	updateRowId(String columnLabel, RowId x) 用 RowId 值更新指定的列。
void	updateShort(int columnIndex, short x) 用 short 值更新指定列。
void	updateShort(String columnLabel, short x) 用 short 值更新指定列。
void	updateSQLXML(int columnIndex, SQLXML xmlObject) 用 java.sql.SQLXML 值更新指定列。
void	updateSQLXML(String columnLabel, SQLXML xmlObject) 用 java.sql.SQLXML 值更新指定的列。
void	updateString(int columnIndex, String x) 用 String 值更新指定列。
void	updateString(String columnLabel, String x) 用 String 值更新指定列。
void	updateTime(int columnIndex, Time x) 用 java.sql.Time 值更新指定列。
void	updateTime(String columnLabel, Time x) 用 java.sql.Time 值更新指定列。
void	updateTimestamp(int columnIndex, Timestamp x) 用 java.sql.Timestamp 值更新指定列。
void	updateTimestamp(String columnLabel, Timestamp x) 用 java.sql.Timestamp 值更新指定列。
boolean	wasNull() 报告最后一个读取的列是否具有值 SQL NULL。

eg：ResultSet获取查询对象

Connection con = null;
		Statement stat = null;
		PreparedStatement  preparedStat =null;
		
		try {
			
			try {
				//1、加载驱动
				Class.forName("com.mysql.jdbc.Driver");
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			}
		
				 //2、获得驱动
				 con = DriverManager.getConnection("jdbc:mysql://localhost:3306/datatest","root","root");
				
				 //3、向数据库发送sql语句
				
			     String sql = "select name,age from user  ";

				 preparedStat = con.prepareStatement(sql);
				 
				
				 ResultSet rs = preparedStat.executeQuery();
				 
				 while(rs.next()){
					 
					 String name = rs.getString("name");
					 int age = rs.getInt("age");
					 System.out.println(name+":"+age);
				 }
			}
			 catch (SQLException e) {
				e.printStackTrace();
			}finally{
				if(null != con)
					try {
						con.close();
					} catch (SQLException e) {
						e.printStackTrace();
					}
				if(null != stat)
					try {
						stat.close();
					} catch (SQLException e) {
						e.printStackTrace();
					}
			}

九、DatabaseMetaData

public interface DatabaseMetaData extends Wrapper   

关于数据库的整体综合信息。 
此接口由驱动程序供应商实现，让用户了解 Database Management System (DBMS) 在与驱动程序（基于与其一起使用的 JDBCTM 技术（“JDBC 驱动程序”））相结合时的能力。不同的关系 DBMS 常常支持不同的功能，以不同方式实现这些功能，并使用不同的数据类型。此外，驱动程序可以实现 DBMS 提供的顶级功能。此接口中的方法返回的信息关系到一起工作的特定驱动程序和特定 DBMS 的能力。注意，正如此文档中所使用的那样，术语“数据库”通常既指驱动程序，又指 DBMS。

此接口的用户通常是一个需要发现如何处理底层 DBMS 的工具。对于试图与多个 DBMS 一起使用的应用程序而言尤其如此。例如，一个工具可能使用 getTypeInfo 方法找出可以在 CREATE TABLE 语句中使用的数据类型。或者用户可能调用 supportsCorrelatedSubqueries 方法查看是否可以使用相关子查询，或者调用 supportsBatchUpdates 查看是否可以使用批量更新。

有些 DatabaseMetaData 方法以 ResultSet 对象的形式返回信息列表。常规 ResultSet 方法（比如 getString 和 getInt）可用于从这些 ResultSet 对象中获取数据。如果给定形式的元数据不可用，则将返回一个空 ResultSet。对于被定义为由 ResultSet 对象的给定方法所返回的列以外的其他列，可以由 JDBC 驱动程序供应商定义，且必须通过其列标签访问。

有些 DatabaseMetaData 方法使用 String 模式的参数。这些参数都有 fooPattern 这样的名称。在模式 String 中，"%" 表示匹配 0 个或多个字符的任何子字符串，"_" 表示匹配任何一个字符。仅返回匹配搜索模式的元数据项。如果将搜索模式参数设置为 null，则从搜索中删除参数标准。

eg ：通过DatabaseMetaData获取数据库中的各个表信息。


		Connection con = null;
		Statement stat = null;

		try {

			try {
				//1、加载驱动
				Class.forName("com.mysql.jdbc.Driver");
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			}
			
				 //2、获得驱动
				 con = DriverManager.getConnection("jdbc:mysql://localhost:3306/datatest","root","root");
				
				 //3、获取该数据库下的所有表元数据
				DatabaseMetaData dbmt = con.getMetaData();
					
				//4、获取各个表信息
				ResultSet tableRet = dbmt.getTables(null, "%", "%", new String[]{"TABLE"});
				 
				 while(tableRet.next()){
					 
					//(1)、获取表名
					String tableName = (String) tableRet.getObject("TABLE_NAME"); 
					
					//获取表类型："TABLE", "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", "LOCAL TEMPORARY", "ALIAS", "SYNONYM". 
					String tableType = (String) tableRet.getObject("TABLE_TYPE");
					
					System.out.println("表名："+tableName+",表类型："+tableType);
					
					//(2)、列名+该列的数据类型
					ResultSet columnRet = dbmt.getColumns(null, "%" ,tableName, "%");
					while(columnRet.next()){
						
						String columnName = (String) columnRet.getString("COLUMN_NAME"); 
                         
						String typeName = (String) columnRet.getString("TYPE_NAME"); 
						
						System.out.println(columnName+"\n"+typeName+"\n");
						
					}
					
					//(3)、获取本表的主键信息
					ResultSet keysRet = dbmt.getPrimaryKeys(null, "%", tableName);

					while(keysRet.next()){
						
						String  pkName = keysRet.getString("COLUMN_NAME");
						
						String keySeQ = keysRet.getString("KEY_SEQ");
						
						System.out.println(pkName+","+keySeQ);
						
					}
					
				 }
				 
			}catch (SQLException e) {
				e.printStackTrace();
			}finally{
				if(null != con)
					try {
						con.close();
					} catch (SQLException e) {
						e.printStackTrace();
					}
				if(null != stat)
					try {
						
						if(null != con){
							con.close();
						}
						if(null != stat){
							stat.close();
						}
						
						if(null != tableRet){
							tableRet.close();
						}
						
						if(null != columnRet){
							columnRet.close();
						}
						if(null != keysRet){
							keysRet.close();
						}
					
					} catch (SQLException e) {
						e.printStackTrace();
					}
			}

十、ResultSetMetaData

public interface ResultSetMetaData extends Wrapper

可用于获取关于 ResultSet 对象中列的类型和属性信息的对象。以下代码片段创建 ResultSet 对象 rs，创建 ResultSetMetaData 对象 rsmd，并使用 rsmd 查找 rs 有多少列，以及 rs 中的第一列是否可以在 WHERE 子句中使用。

    ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM TABLE2");

    ResultSetMetaData rsmd = rs.getMetaData();

    int numberOfColumns = rsmd.getColumnCount();

    boolean b = rsmd.isSearchable(1);

方法摘要
String	getCatalogName(int column) 获取指定列的表目录名称。
String	getColumnClassName(int column) 如果调用方法 ResultSet.getObject 从列中获取值，则返回构造其实例的 Java 类的完全限定名称。
int	getColumnCount() 返回此 ResultSet 对象中的列数。
int	getColumnDisplaySize(int column) 指示指定列的最大标准宽度，以字符为单位。
String	getColumnLabel(int column) 获取用于打印输出和显示的指定列的建议标题。
String	getColumnName(int column) 获取指定列的名称。
int	getColumnType(int column) 获取指定列的 SQL 类型。
String	getColumnTypeName(int column) 获取指定列的数据库特定的类型名称。
int	getPrecision(int column) 获取指定列的指定列宽。
int	getScale(int column) 获取指定列的小数点右边的位数。
String	getSchemaName(int column) 获取指定列的表模式。
String	getTableName(int column) 获取指定列的名称。
boolean	isAutoIncrement(int column) 指示是否自动为指定列进行编号。
boolean	isCaseSensitive(int column) 指示列的大小写是否有关系。
boolean	isCurrency(int column) 指示指定的列是否是一个哈希代码值。
boolean	isDefinitelyWritable(int column) 指示在指定的列上进行写操作是否明确可以获得成功。
int	isNullable(int column) 指示指定列中的值是否可以为 null。
boolean	isReadOnly(int column) 指示指定的列是否明确不可写入。
boolean	isSearchable(int column) 指示是否可以在 where 子句中使用指定的列。
boolean	isSigned(int column) 指示指定列中的值是否带正负号。
boolean	isWritable(int column) 指示在指定的列上进行写操作是否可以获得成功。

这个类就是获取ResultSet结果中，数据的元数据库信息，包括表名，表别名，列名，列别名，结果数等等元数据信息

eg:

PreparedStatement ps =null;
		ResultSet rs = null;
		List lists = null;
		try {
			ps = con.prepareStatement(sql);	
		    rs = ps.executeQuery();	
			ResultSetMetaData metadata = rs.getMetaData();	
			while(rs.next()){
				
				if(lists == null)
					lists = new ArrayList();
				
				Object objentity = cls.newInstance();
				
				for(int i = 0 ; i<metadata.getColumnCount();i++){
					//获取查询列的列名（如果有别名，取别名）
					String colName = metadata.getColumnLabel(i+1);
					
					System.out.println(colName);
					
					Object val = rs.getObject(i+1);
					
					if(null != val){
						val = val.toString();
					}
			Method m = cls.getDeclaredMethod("set"+StringUtils.firstConverToUpper("a")+(i+1), String.class);
					
					m.invoke(objentity, val);			
				}
				lists.add(objentity);
				
			}
		} catch (Exception e) {
			
			e.printStackTrace();
		}finally{
			DBManager.close(con, ps, rs);
		}
			return lists;

十一、连接池

连接池：就是将Connection对象放入List中，反复重用的过程！

----连接池的初始化：

事先放入多个链接对象

----从连接池中获取对象：

如果池中有可用链接，就将池中最后一个返回，同时，将该链接从池中remove掉，表示正在使用；如果没用可用链接，则创建新的链接。

----关闭链接：

不是真正关闭链接，而是将链接放回池中。

市面上的连接池产品：

DBCP、C3p0、proxool。

为什么使用连接池？

我们知道每次让java应用服务和数据库链接，需要花费大量的时间，若执行一次sql语句，就与数据库链接一次，用完就关闭，这样对于大量的数据库操作而言，会严重影响系统的性能，

下面是自己写的简单数据库连接池：

package dataBaseConnection.sorm.pool;

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

import dataBaseConnection.sorm.core.DBManager;
import dataBaseConnection.sorm.core.MysqlQuery;
import dataBaseConnection.sorm.entity.Demo;

/**
 * @author:zhangfd
 * @version:1.0
 * @date:2017年7月29日 上午12:54:13
 * @description:手写数据库连接池
 */
public class DBConnectionPool {

	/**
	 * 连接池
	 */
	private static List<Connection> poolLists;

	private static final int Pool_max_size = 10;

	private static final int Pool_min_size = 5;

	public DBConnectionPool() {
		super();

	}
	//提前先把链接放入List集合中
	static{
		init();
	}

	public static void init() {
		if (null == poolLists) {
			poolLists = new ArrayList<Connection>();
		}
		while (poolLists.size() < Pool_min_size) {
			poolLists.add(DBManager.createcon());
		}

	}

	public synchronized static Connection getCon() {
		int i = poolLists.size();

		if (i >= 1) {
			Connection con = poolLists.get(i-1);

			poolLists.remove(i-1);

			return con;

		} else {
			return DBManager.getcon();
		}

	}

	public synchronized static void close(Connection con) {
		if (poolLists.size() + 1 > Pool_max_size) {

			if (null != con) {
				try {
					con.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		} else {
			if (null != con)
				poolLists.add(con);
		}

	}

	public static void main(String[] args) {
		test1();// 不使用连接池查询1000次需要花费的时间:8102ms
		test2();//使用连接池查询1000吃需要花费的时间是557ms
	}

	/**
	 * 测试不使用连接池查询1000次需要花费的时间
	 */
	public static void test1() {
		long beginTime = System.currentTimeMillis();

		for (int i = 0; i < 1000; i++) {
			seleTest();
		}

		long endTime = System.currentTimeMillis();

		System.out.println(endTime - beginTime);
	}

	public static void test2() {
		long beginTime = System.currentTimeMillis();

		for(int i=0;i<1000;i++){
			seleTest();
		}
		
		long endTime = System.currentTimeMillis();

		System.out.println(endTime - beginTime);

	}

	
	public static  void seleTest(){
		String sql = "select * from user,school where school_id=user_id";

		List<Demo> lists = new MysqlQuery().queryrows(sql, Demo.class, null);

		for (Demo demo : lists) {
			System.out.println(demo.getA1() + "===" + demo.getA4() + "===" + demo.getA8() + "===" + demo.getA10());
		}

		System.out.println(lists.size());
	}
}

11爱学习的程序员11

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java基础-数据库操作

目录一、Java和数据库交互主要分为三步：二、事务三、DriverManager四、Connection五、Statement六、PreparedStatement七、CallableStatement 八、ResultSet九、DatabaseMetaData十、ResultSetMetaData十一、连接池一、Java和数据库交互主要分...
复制链接

扫一扫