JAVA 数据库 笔记

JDBC详解

如何用Java操作数据库

Posted by YD Blog on October 6, 2022

JDBC详解

什么是JDBC

JDBC API是一个Java API，可以访问任何类型表列数据，特别是存储在关系数据库中的数据。JDBC代表Java数据库连接。

JDBC本质上是一个关于java操作数据库的标准，它定义了一系列接口，由各个数据库公司为自己的数据库去进行具体实现。

JDBC库中所包含的API通常与数据库使用于：

  • 连接到数据库
  • 创建SQL或MySQL语句
  • 在数据库中执行SQL或MySQL查询
  • 查看和修改数据库中的数据记录

开始使用JDBC

首先使用idea创建java项目，在pom文件中添加如下代码并用maven更新项目：

    <dependencies>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>

    </dependencies>

这段代码的意思是下载对于MySQL数据库的依赖。

然后新建java类，将依赖引入。

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

当然也可以直接使用

import java.sql.*;

但是一方面对于初学者来说，知道用到了哪些类很重要，另一方面引入不需要的依赖会使项目过于臃肿。

那么接下来首先需要创建一个JVM虚拟机和MySQL数据库的连接，这样我们就需要一个驱动来实现这个功能，代码如下：

Class.forName("com.mysql.cj.jdbc.Driver");
//由于我们是使用maven导入的包，这一步可以省略

Class.forName()方法用于初始化一个对象，在这里是初始化了一个mysql的数据库驱动对象，那么在有了驱动以后，就可以进行连接了，那么接下来就可以创建一个数据库连接对象了。

Connection conn = DriverManager.getConnection(url,username,password);

这句话的意思是调用DriverManager对象的getConnection方法创建了一个Connection对象，getConnection方法的参数分别为数据库地址，用户名，密码，其中用户名和密码均为用户自己指定，那么就只需要知道数据库地址的书写规范即可。

以下为常用的数据库url设定：

jdbc:mysql://localhost:3306/数据库名?autoReconnect=true&useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false

乍一看就很复杂对不对，实际上拆解开并不复杂，首先前面的很好理解，“jdbc:mysql://localhost:3306/数据库名”就是指定数据库类型和端口地址，后续的则是指定连接的一些细节，具体如下：

  • useUnicode：是否使用Unicode字符集，如果参数characterEncoding设置为gb2312或gbk，本参数值必须设置为true，如不指定则默认为false
  • characterEncoding：当useUnicode设置为true时，指定字符编码。比如可设置为gb2312或gbk，如不指定则默认为false
  • autoReconnect：当数据库连接异常中断时，是否自动重新连接？如不指定则默认为false
  • autoReconnectForPools：是否使用针对数据库连接池的重连策略，如不指定则默认为false
  • failOverReadOnly：自动重连成功后，连接是否设置为只读？如不指定则默认为true
  • maxReconnects：autoReconnect设置为true时，重试连接的次数，默认为3
  • initialTimeout：autoReconnect设置为true时，两次重连之间的时间间隔，单位：秒，默认为2
  • connectTimeout：和数据库服务器建立socket连接时的超时，单位：毫秒。 0表示永不超时，适用于JDK 1.4及更高版本，默认为0
  • socketTimeout：socket操作（读写）超时，单位：毫秒。 0表示永不超时，默认为0
  • serverTimezone：时区，如果需要使用gmt+8(即国内标准时间)时区，需要写成GMT%2B8，否则会被解析为空
  • useSSL：是否需要SSL验证，默认为true，但是MySQL会警告：建议不要在没有服务器身份验证的情况下建立SSL连接。在没有为服务器证书验证提供信任库的情况下建议设置为false

上述若不需修改默认值则可以省略，每两个设定值之间用 & 符号隔开即可。

创建连接后我们就可以完成对数据库的操作了，这时候我们需要调用Statement接口，如下：

Statement stmt = conn.createStatement();

用我们之前创建的conn对象中的createStatement方法创建接口实例stmt，然后调用接口中的方法就能向数据库传输指令了。

类似如下代码：

boolean count = stmt.execute(sql);

接下来开始研究具体细节。

API详解

DriverManager

驱动管理类，功能主要有：

  1. 注册驱动
  2. 获取数据库连接

在官方API文档中对DriverManager类的描述为：

用于管理一组JDBC驱动程序的基本服务。
注意： DataSource接口提供了连接数据源的另一种方法。 使用DataSource对象是连接到数据源的首选方法。
作为其初始化的一部分， DriverManager类将尝试通过使用以下方式加载可用的JDBC驱动程序：
jdbc.drivers系统属性，其中包含一个冒号分隔的JDBC驱动程序完全限定类名的列表。 每个驱动程序使用system class loader加载。
jdbc.drivers=foo.bah.Driver:wombat.sql.Driver:bad.taste.ourDriver
java.sql.Driver类的服务提供商，通过service-provider loading机制加载。
DriverManager初始化完成懒惰，并使用线程上下文类加载器查找服务提供程序。 加载并可用于应用程序的驱动程序将取决于通过DriverManager触发驱动程序初始化的线程的线程上下文类加载器。
当调用方法getConnection ， DriverManager将尝试从初始化中加载的驱动程序中找到合适的驱动程序，并使用与当前应用程序相同的类加载器明确加载驱动程序。

DriverManager类具有如下方法：

static void deregisterDriver​(Driver driver);
//从 DriverManager的注册驱动程序列表中删除指定的驱动程序。
static Stream<Driver> drivers​();
//使用当前调用者可以访问的所有当前加载的JDBC驱动程序检索流。 
static Connection getConnection​(String url);
//尝试建立与给定数据库URL的连接，并返回一个connection对象。
static Connection getConnection​(String url, String user, String password);
//尝试建立与给定数据库URL的连接，并返回一个connection对象。
static Connection getConnection​(String url, Properties info);
//尝试建立与给定数据库URL的连接，并返回一个connection对象。
static Driver getDriver​(String url);
//尝试查找了解给定URL的驱动程序。
static Enumeration<Driver> getDrivers​();
//使用当前调用者可以访问的所有当前加载的JDBC驱动程序检索枚举。 
static int getLoginTimeout​();
//获取尝试登录数据库时驱动程序可以等待的最长时间（秒）。
static PrintStream getLogWriter​();
//检索日志记录器。 
static void println​(String message);
//打印到当前JDBC日志流的消息。
static void registerDriver​(Driver driver);
//使用 DriverManager注册给定的驱动程序。 
static void registerDriver​(Driver driver, DriverAction da);
//使用 DriverManager注册给定的驱动程序。
static void setLoginTimeout​(int seconds);
//设置驱动程序在识别驱动程序后尝试连接到数据库时等待的最长时间（秒）。
static void setLogWriter​(PrintWriter out);
//设置 DriverManager和所有驱动程序使用的记录/跟踪 PrintWriter对象。

Connection

数据库连接对象，主要功能有：

  1. 获取执行SQL的对象
  2. 管理事务

在官方API文档中对Connection类的描述为：

与特定数据库的连接（会话）。 执行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方法。 在这种情况下，该方法将使用给定的类型映射，而不是与该连接关联的映射。

Connection对象具有如下方法：

void abort​(Executor executor);
//终止打开的连接。  
default void beginRequest​();
//向驱动提示，一个请求，一个独立的工作单位，正在开始这个连接。  
void clearWarnings​();
//清除此 Connection对象报告的所有警告。  
void close​();
//立即释放此 Connection对象的数据库和JDBC资源，而不是等待它们自动释放。  
void commit​();
//使上次提交/回滚之后所做的所有更改都将永久性，并释放此 Connection对象当前持有的任何数据库锁。  
Array createArrayOf​(String typeName, Object[] elements);
//用于创建Array对象的Factory方法。  
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对象的工厂方法。  
default void endRequest​();
//向驱动提示，要求，独立工作单位已经完成。  
boolean getAutoCommit​();
//检索此 Connection对象的当前自动提交模式。  
String getCatalog​();
//检索此 Connection对象的当前目录名称。  
Properties getClientInfo​();
//返回包含驱动程序支持的每个客户端信息属性的名称和当前值的列表。  
String getClientInfo​(String name);
//返回由name指定的客户端信息属性的值。  
int getHoldability​();
//检索使用此 Connection对象创建的 ResultSet对象的当前可 Connection 。  
DatabaseMetaData getMetaData​();
//检索一个 DatabaseMetaData对象，其中包含有关此 Connection对象表示连接的数据库的元数据。  
int getNetworkTimeout​();
//检索驱动程序等待数据库请求完成的毫秒数。  
String getSchema​();
//检索此 Connection对象的当前模式名称。  
int getTransactionIsolation​();
//检索此 Connection对象的当前事务隔离级别。  
Map<String,Class<?>> getTypeMap​();
//检索与该 Map对象关联的 Connection对象。  
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​(String name, String value);
//将由name指定的客户端信息属性的值设置为由值指定的值。  
void setClientInfo​(Properties properties);
//设置连接的客户端信息属性的值。  
void setHoldability​(int holdability);
//将使用此 Connection对象创建的对象的默认 ResultSet更改为给定的可保存性。  
void setNetworkTimeout​(Executor executor, int milliseconds);
//设置 Connection的最大周期或从 Connection创建的 Connection将等待数据库回复任何一个请求。  
void setReadOnly​(boolean readOnly);
//将此连接设置为只读模式，作为驱动程序的提示以启用数据库优化。  
Savepoint setSavepoint​();
//在当前事务中创建一个未命名的保存点，并返回表示它的新的 Savepoint对象。  
Savepoint setSavepoint​(String name);
//在当前事务中创建具有给定名称的保存点，并返回表示它的新的 Savepoint对象。  
void setSchema​(String schema);
//设置要访问的给定模式名称。  
default void setShardingKey​(ShardingKey shardingKey);
//指定与此Connection一起使用的shardingKey  
default void setShardingKey​(ShardingKey shardingKey, ShardingKey superShardingKey);
//指定与此连接一起使用的shardingKey和superShardingKey  
default boolean setShardingKeyIfValid​(ShardingKey shardingKey, int timeout);
//设置并验证此连接的分片密钥。  
default boolean setShardingKeyIfValid​(ShardingKey shardingKey, ShardingKey superShardingKey, int timeout);
//设置并验证此连接的分片密钥。  
void setTransactionIsolation​(int level);
//尝试将此 Connection对象的事务隔离级别更改为给定的对象。  
void setTypeMap​(Map<String,Class<?>> map);
//安装给定 TypeMap对象的类型映射此 Connection对象。

其中最为常用的方法如下：

  1. 获取执行SQL的对象
Statement createStatement();
//创建一个普通的执行SQL的对象
PreparedStatement preparedStatement();
//创建一个预编译SQL的执行SQL对象，防止SQL注入
CallableStatement prepareCall(sql);
//创建一个执行存储过程的对象，不过执行存储过程在MySQL里不常用到
  1. 事务管理

在MySQL中进行事务管理的操作如下：

-- 开启事务
BEGIN;
START TRANSACTION;
-- 提交事务
COMMIT;
-- 回滚事务
ROLLBACK;

而在connection对象中事务管理的方法如下：

//开启事务,true为自动提交，false为手动提交，即为开启事务
setAutoCommit(boolean autoCommit);
//提交事务
commit();
//回滚事务
rollback();

Statement

Statement作用： 执行SQL语句

官方API文档中对它的描述为：

用于执行静态SQL语句并返回其生成的结果的对象。
默认情况下，每个Statement对象只能有一个ResultSet对象同时打开。 因此，如果一个ResultSet对象的读取与另一个对象的读取交错，则每个对象必须由不同的Statement对象生成。 Statement接口中的所有执行方法会隐式关闭语句的当前ResultSet对象，如果存在该对象。

Statement对象的方法如下：

void addBatch​(String sql);
//将给定的SQL命令添加到此 Statement对象的当前命令列表中。  
void cancel​();
//如果DBMS和驱动程序都支持中止SQL语句，则取消此 Statement对象。  
void clearBatch​();
//清空这个 Statement对象当前的SQL命令列表。  
void clearWarnings​();
//清除所有在这个 Statement对象上报告的警告。  
void close​();
//立即释放此 Statement对象的数据库和JDBC资源，而不是等待它自动关闭时发生。  
void closeOnCompletion​();
//指定当其所有相关结果集都关闭时，此 Statement将关闭。  
default String enquoteIdentifier​(String identifier, boolean alwaysQuote);
//返回一个SQL标识符。  
default String enquoteLiteral​(String val);
//返回一个包含在单引号中的 String 。  
default String enquoteNCharLiteral​(String val);
//返回一个 String表示一个用单引号括起来的前缀为大写字母N的国家字符集文字。  
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​();
//将一批命令提交到数据库以执行，并且所有命令都执行成功，返回一个更新计数的数组。  
default long[] executeLargeBatch​();
//将一批命令提交到数据库以执行，并且所有命令都执行成功，返回一个更新计数的数组。  
default long executeLargeUpdate​(String sql);
//执行给定的SQL语句，这可能是 INSERT ， UPDATE ，或 DELETE声明，或者不返回任何内容，如SQL DDL语句的SQL语句。  
default long executeLargeUpdate​(String sql, int autoGeneratedKeys);
//执行给定的SQL语句，并用给定的标志来向驱动程序发出信号，指出这个 Statement对象生成的自动生成的密钥是否应该可用于检索。  
default long executeLargeUpdate​(String sql, int[] columnIndexes);
//执行给定的SQL语句，并向驱动程序发出信号，指出给定数组中指示的自动生成的键应该可用于检索。  
default long executeLargeUpdate​(String sql, String[] columnNames);
//执行给定的SQL语句，并向驱动程序发出信号，指出给定数组中指示的自动生成的键应该可用于检索。  
ResultSet executeQuery​(String sql);
//执行给定的SQL语句，返回一个 ResultSet对象。  
int executeUpdate​(String sql);
//执行给定的SQL语句，这可能是 INSERT ， UPDATE ，或 DELETE声明，或者不返回任何内容，如SQL DDL语句的SQL语句。  
int executeUpdate​(String sql, int autoGeneratedKeys);
//执行给定的SQL语句，并用给定的标志来向驱动程序发出信号，指出这个 Statement对象产生的自动生成的密钥是否应该可用于检索。  
int executeUpdate​(String sql, int[] columnIndexes);
//执行给定的SQL语句，并向驱动程序发出信号，指出给定数组中指示的自动生成的键应该可用于检索。  
int executeUpdate​(String sql, String[] columnNames);
//执行给定的SQL语句，并向驱动程序发出信号，指出给定数组中指示的自动生成的键应该可用于检索。  
Connection getConnection​();
//检索 Connection生成此对象 Statement对象。  
int getFetchDirection​();
//检索从数据库表中获取行的方向，这是从此 Statement对象生成的结果集的默认值。  
int getFetchSize​();
//检索结果集合的行数是默认为获取大小 ResultSet从该生成的对象 Statement对象。  
ResultSet getGeneratedKeys​();
//检索作为执行此 Statement对象的结果创建的任何自动生成的密钥。  
default long getLargeMaxRows​();
//检索一个的最大行数 ResultSet由此产生对象 Statement对象可以包含。  
default long getLargeUpdateCount​();
//将当前结果作为更新计数检索; 如果结果是一个ResultSet对象或没有更多结果，则返回-1。  
int getMaxFieldSize​();
//检索可以在被返回字符和二进制列值的最大字节数 ResultSet由此产生对象 Statement对象。  
int getMaxRows​();
//检索一个的最大行数 ResultSet由此产生对象 Statement对象可以包含。  
boolean getMoreResults​();
//移动到此 Statement对象的下一个结果，如果它是一个 ResultSet对象，则返回 true ，并隐式关闭使用方法 getResultSet获取的任何当前的 ResultSet对象。  
boolean getMoreResults​(int current);
//移动到此 Statement对象的下一个结果，根据给定标志指定的指令处理任何当前的 ResultSet对象，如果下一个结果是一个 ResultSet对象，则返回 true 。  
int getQueryTimeout​();
//检索驱动程序等待执行 Statement对象的 Statement 。  
ResultSet getResultSet​();
//以 ResultSet对象获取当前结果。  
int getResultSetConcurrency​();
//检索由 ResultSet对象生成的 Statement对象的结果集并发。  
int getResultSetHoldability​();
//检索 ResultSet对象生成的对象的结果集 Statement 。  
int getResultSetType​();
//检索 ResultSet对象生成的 Statement对象的结果集类型。  
int getUpdateCount​();
//将当前结果作为更新计数检索; 如果结果是一个ResultSet对象或没有更多结果，则返回-1。  
SQLWarning getWarnings​();
//检索通过此 Statement对象的呼叫报告的第一个警告。  
boolean isClosed​();
//检索此 Statement对象是否已关闭。  
boolean isCloseOnCompletion​();
//返回一个值，指示当其所有相关结果集都关闭时，此 Statement是否关闭。  
boolean isPoolable​();
//返回一个值，指示 Statement是否可 Statement 。  
default boolean isSimpleIdentifier​(String identifier);
//检索 identifier是否是一个简单的SQL标识符。  
void setCursorName​(String name);
//将SQL游标名称设置为给定的 String ，这将由后续的 Statement对象 execute方法使用。  
void setEscapeProcessing​(boolean enable);
//设置逃脱处理打开或关闭。  
void setFetchDirection​(int direction);
//给出驱动程序一个关于使用这个 Statement对象创建的 ResultSet对象中处理行的方向的提示。  
void setFetchSize​(int rows);
//给JDBC驱动程序提供一个关于应该从数据库中获取的行数，提供 ResultSet由 Statement生成的对象的更多行。  
default void setLargeMaxRows​(long max);
//设置的任何行的最大数目的极限 ResultSet由此生成的对象 Statement对象可以包含给定数目。  
void setMaxFieldSize​(int max);
//设置由 ResultSet对象产生的 Statement对象中的字符和二进制列值可以返回的最大字节数限制。  
void setMaxRows​(int max);
//设置的任何行的最大数目的极限 ResultSet由此生成的对象 Statement对象可以包含给定数目。  
void setPoolable​(boolean poolable);
//请求汇集或不汇集 Statement 。  
void setQueryTimeout​(int seconds);
//设置驱动程序等待 Statement对象执行到给定秒数的秒数。

其中较为常用的如下：

int executeUpdate(sql);
//执行DML、DDL语句，返回值为1.DML语句影响的行数2.DDL语句执行后，执行成功也可能返回0
ResultSet executeQuery(sql);
//执行DQL操作，返回值为ResultSet结果对象

ResultSet

结果集对象作用：

  1. 封装了DQL语句的查询结果

ResultSet类在文档中的描述如下：

表示数据库结果集的数据表，通常通过执行查询数据库的语句生成。
ResultSet对象维护指向其当前数据行的光标。 最初，光标位于第一行之前。 next方法将光标移动到下一行，并且因为在ResultSet对象中没有更多行时返回false ，因此可以在while循环中使用循环来遍历结果集。

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编程语言中的 ResultSet对象的形式 Array此 ResultSet对象的当前行中指定列的值。  
Array getArray​(String columnLabel);
//检索此 ResultSet对象当前行中指定列的值为Java编程语言中的 Array对象。  
InputStream getAsciiStream​(int columnIndex);
//将此 ResultSet对象的当前行中指定列的值作为ASCII字符流 ResultSet 。  
InputStream getAsciiStream​(String columnLabel);
//将此 ResultSet对象的当前行中指定列的值作为ASCII字符流 ResultSet 。  
BigDecimal getBigDecimal​(int columnIndex);
//在 ResultSet对象的当前行中的指定列的值作为 java.math.BigDecimal完全精确 java.math.BigDecimal 。  
BigDecimal getBigDecimal​(String columnLabel);
//在 ResultSet对象的当前行中的指定列的值作为 java.math.BigDecimal完全精确 java.math.BigDecimal。  
InputStream getBinaryStream​(int columnIndex);
//将此 ResultSet对象的当前行中指定列的值作为未解释的字节流 ResultSet 。  
InputStream getBinaryStream​(String columnLabel);
//检索该 ResultSet对象的当前行中指定列的值，作为未解释的流 byte s。  
Blob getBlob​(int columnIndex);
//检索此 ResultSet对象的当前行中指定列的值为Java编程语言中的 Blob对象。  
Blob getBlob​(String columnLabel);
//以Java编程语言中的 ResultSet对象的形式 Blob此 ResultSet对象的当前行中指定列的值。  
boolean getBoolean​(int columnIndex);
//检索该 ResultSet对象的当前行中指定列的值为Java编程语言中的 boolean 。  
boolean getBoolean​(String columnLabel);
//检索此 ResultSet对象的当前行中指定列的值为Java编程语言中的 boolean 。  
byte getByte​(int columnIndex);
//检索此 ResultSet对象当前行中指定列的值为Java编程语言中的 byte 。  
byte getByte​(String columnLabel);
//以Java编程语言中的 byte此 ResultSet对象的当前行中指定列的值。  
byte[] getBytes​(int columnIndex);
//检索此 ResultSet对象的当前行中指定列的值为Java编程语言中的 byte数组。  
byte[] getBytes​(String columnLabel);
//以Java编程语言中的 byte数组来检索此 ResultSet对象的当前行中指定列的值。  
Reader getCharacterStream​(int columnIndex);
//以 ResultSet对象的形式 java.io.Reader此 ResultSet对象的当前行中指定列的值。  
Reader getCharacterStream​(String columnLabel);
//以 ResultSet对象的形式 java.io.Reader此 ResultSet对象的当前行中指定列的值。  
Clob getClob​(int columnIndex);
//检索此 ResultSet对象当前行中指定列的值为Java编程语言中的 Clob对象。  
Clob getClob​(String columnLabel);
//检索此 ResultSet对象的当前行中指定列的值为Java编程语言中的 Clob对象。  
int getConcurrency​();
//检索此 ResultSet对象的并发模式。  
String getCursorName​();
//检索此 ResultSet对象使用的SQL游标的名称。  
Date getDate​(int columnIndex);
//这个检索的当前行中指定列的值 ResultSet对象为 java.sql.Date的Java编程语言对象。  
Date getDate​(int columnIndex, Calendar cal);
//检索该 ResultSet对象的当前行中指定列的值为Java编程语言中的 java.sql.Date对象。  
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);
//检索该 ResultSet对象的当前行中指定列的值为Java编程语言中的 float 。  
float getFloat​(String columnLabel)
//检索此 ResultSet对象的当前行中指定列的值为Java编程语言中的 float 。  
int getHoldability​();
//检索此 ResultSet对象的 ResultSet  
int getInt​(int columnIndex);
//检索此 ResultSet对象的当前行中指定列的值为Java编程语言中的 int 。  
int getInt​(String columnLabel);
//以Java编程语言中的 int此 ResultSet对象的当前行中指定列的值。  
long getLong​(int columnIndex);
//检索此 ResultSet对象的当前行中指定列的值为Java编程语言中的 long 。  
long getLong​(String columnLabel);
//检索此 ResultSet对象的当前行中指定列的值为Java编程语言中的 long 。  
ResultSetMetaData getMetaData​();
//检索此 ResultSet对象列的数量，类型和属性。  
Reader getNCharacterStream​(int columnIndex);
//检索此 ResultSet对象的当前行中指定列的值作为 java.io.Reader对象。  
Reader getNCharacterStream​(String columnLabel);
//以 ResultSet对象的形式 java.io.Reader此 ResultSet对象的当前行中指定列的值。  
NClob getNClob​(int columnIndex);
//检索此 ResultSet对象的当前行中指定列的值为Java编程语言中的 NClob对象。  
NClob getNClob​(String columnLabel);
//这个检索的当前行中指定列的值 ResultSet对象为 NClob的Java编程语言对象。  
String getNString​(int columnIndex);
//检索此 ResultSet对象的当前行中指定列的值为Java编程语言中的 String 。  
String getNString​(String columnLabel);
//检索此 ResultSet对象的当前行中指定列的值为Java编程语言中的 String 。  
Object getObject​(int columnIndex);
//获取此 ResultSet对象的当前行中指定列的值为Java编程语言中的 Object 。  
<T> T getObject​(int columnIndex, Class<T> type);
//检索此 ResultSet对象的当前行中指定列的值，并将转换为SQL类型的列到所请求的Java数据类型，如果转换支持。  
Object getObject​(int columnIndex, Map<String,Class<?>> map);
//以Java编程语言中的 Object此 ResultSet对象的当前行中指定列的值。  
Object getObject​(String columnLabel);
//获取此 ResultSet对象的当前行中指定列的值为Java编程语言中的 Object 。  
<T> T getObject​(String columnLabel, Class<T> type);
//检索此 ResultSet对象的当前行中指定列的值，并将转换为SQL类型的列到所请求的Java数据类型，如果转换支持。  
Object getObject​(String columnLabel, Map<String,Class<?>> map);
//以Java编程语言中的 Object此 ResultSet对象的当前行中指定列的值。  
Ref getRef​(int columnIndex);
//检索此 ResultSet对象的当前行中指定列的值为Java编程语言中的 Ref对象。  
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);
//检索此 ResultSet的当前行中指定列的值为Java编程语言中的 java.sql.SQLXML对象。  
SQLXML getSQLXML​(String columnLabel);
//以Java编程语言中的 java.sql.SQLXML对象的形式获取此 ResultSet的当前行中指定列的值。  
Statement getStatement​();
//检索 Statement生成此对象 ResultSet对象。  
String getString​(int columnIndex);
//检索此 ResultSet对象的当前行中指定列的值为Java编程语言中的 String 。  
String getString​(String columnLabel);
//检索此 ResultSet对象的当前行中指定列的值为Java编程语言中的 String 。  
Time getTime​(int columnIndex);
//检索此 ResultSet对象的当前行中指定列的值为Java编程语言中的 java.sql.Time对象。  
Time getTime​(int columnIndex, Calendar cal);
//检索此 ResultSet对象当前行中指定列的值为Java编程语言中的 java.sql.Time对象。  
Time getTime​(String columnLabel);
//以Java编程语言的 ResultSet对象的形式 java.sql.Time此 ResultSet对象的当前行中指定列的值。  
Time getTime​(String columnLabel, Calendar cal);
//检索此 ResultSet对象的当前行中指定列的值为Java编程语言中的 java.sql.Time对象。  
Timestamp getTimestamp​(int columnIndex);
//检索此 ResultSet对象的当前行中指定列的值为Java编程语言中的 java.sql.Timestamp对象。  
Timestamp getTimestamp​(int columnIndex, Calendar cal);
//以Java编程语言的 java.sql.Timestamp对象的形式，检索此 ResultSet对象的当前行中指定列的值。  
Timestamp getTimestamp​(String columnLabel);
//以Java编程语言的 ResultSet对象的形式 java.sql.Timestamp此 ResultSet对象的当前行中指定列的值。  
Timestamp getTimestamp​(String columnLabel, Calendar cal);
//以Java编程语言中的 ResultSet对象的形式 java.sql.Timestamp此 ResultSet对象的当前行中指定列的值。  
int getType​();
//检索此 ResultSet对象的类型。  
URL getURL​(int columnIndex);
//以Java编程语言的 java.net.URL对象的形式， ResultSet对象的当前行中指定列的值。  
URL getURL​(String columnLabel);
//检索此 ResultSet对象当前行中指定列的值为Java编程语言中的 java.net.URL对象。  
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, InputStream inputStream);
//使用给定的输入流更新指定的列。  
void updateBlob​(int columnIndex, InputStream inputStream, long length);
//使用给定的输入流更新指定列，该输入流将具有指定的字节数。  
void updateBlob​(int columnIndex, Blob x);
//使用 java.sql.Blob值更新指定的列。  
void updateBlob​(String columnLabel, InputStream inputStream);
//使用给定的输入流更新指定的列。  
void updateBlob​(String columnLabel, InputStream inputStream, long length);
//使用给定的输入流更新指定列，该输入流将具有指定的字节数。  
void updateBlob​(String columnLabel, Blob x);
//使用 java.sql.Blob值更新指定的列。  
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, Reader reader);
//使用给定的 Reader对象更新指定的列。  
void updateClob​(int columnIndex, Reader reader, long length);
//使用给定的 Reader对象更新指定的列，这是给定的字符数。  
void updateClob​(int columnIndex, Clob x);
//使用 java.sql.Clob值更新指定的列。  
void updateClob​(String columnLabel, Reader reader);
//使用给定的 Reader对象更新指定的列。  
void updateClob​(String columnLabel, Reader reader, long length);
//使用给定的 Reader对象更新指定的列，这是给定的字符数。  
void updateClob​(String columnLabel, Clob x);
//使用 java.sql.Clob值更新指定的列。  
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, Reader reader);
//使用给定的 Reader更新指定的列。根据需要，将从流中读取数据，直到达到流出端。  
void updateNClob​(int columnIndex, Reader reader, long length);
//使用给定的 Reader对象更新指定的列，这是给定的字符长度。  
void updateNClob​(int columnIndex, NClob nClob);
//使用 java.sql.NClob值更新指定的列。  
void updateNClob​(String columnLabel, Reader reader);
//使用给定的 Reader对象更新指定的列。  
void updateNClob​(String columnLabel, Reader reader, long length);
//使用给定的 Reader对象更新指定的列，这是给定的字符数。  
void updateNClob​(String columnLabel, NClob nClob);
//使用 java.sql.NClob值更新指定的列。  
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值更新指定的列。  
default void updateObject​(int columnIndex, Object x, SQLType targetSqlType);
//使用 Object值更新指定的列。  
default void updateObject​(int columnIndex, Object x, SQLType targetSqlType, int scaleOrLength);
//使用 Object值更新指定的列。  
void updateObject​(String columnLabel, Object x);
//使用 Object值更新指定的列。  
void updateObject​(String columnLabel, Object x, int scaleOrLength);
//使用 Object值更新指定的列。  
default void updateObject​(String columnLabel, Object x, SQLType targetSqlType);
//使用 Object值更新指定的列。  
default void updateObject​(String columnLabel, Object x, SQLType targetSqlType, 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​();
//报告最后一列读取的值是否为 NULL。

其中较为常用的有：

boolean next();
//1.将光标从当前位置向前移动一行2.判断当前行是否为有效行
//返回值：true-有效行，当前行有数据。false-无效行，当前行无数据。
//故可以使用类似如下代码来遍历一个ResultSet对象的所有行
while(resultset.next()){}
//光标指向的行被称为游标行，一开始游标行为第一行的前一行，即表头
xxx getXxx(参数);
//获取数据，xxx为数据类型，例如：
int getInt(参数);
String getString(参数);
//参数为：int-列的编号，从1开始。String-列的名称。

preparedStatement

继承自Statement类，作用： 预编译SQL语句并执行：预防SQL注入问题。

  • SQL注入

SQL注入是通过操作输入来修改事先定义好的SQL语句，用以达到执行代码对服务器进行攻击的方法。

比如万能密码 ‘or ‘1’= ‘1

关于preparedStatement类，在API文档中的描述如下：

表示预编译的SQL语句的对象。
SQL语句已预编译并存储在一个PreparedStatement对象中。 然后可以使用该对象多次有效地执行此语句。
注意：setter方法（ setShort ， setString用于设置IN参数值必须指定与所定义的SQL类型的输入参数的兼容的类型，等等）。 例如，如果IN参数具有SQL类型INTEGER ，则应使用方法setInt。
如果需要任意参数类型转换，方法setObject应与目标SQL类型一起使用。

其拥有的方法有：

void addBatch​();
//向这个 PreparedStatement对象的一批命令添加一组参数。  
void clearParameters​();
//立即清除当前参数值。  
boolean execute​();
//执行此 PreparedStatement对象中的SQL语句，可能是任何类型的SQL语句。  
default long executeLargeUpdate​();
//执行在该SQL语句PreparedStatement对象，它必须是一个SQL数据操纵语言（DML）语句，比如INSERT ， UPDATE或DELETE ; 或不返回任何内容的SQL语句，例如DDL语句。  
ResultSet executeQuery​();
//执行此 PreparedStatement对象中的SQL查询，并返回查询生成的 ResultSet对象。  
int executeUpdate​();
//执行在该SQL语句PreparedStatement对象，它必须是一个SQL数据操纵语言（DML）语句，比如INSERT ， UPDATE或DELETE ; 或不返回任何内容的SQL语句，例如DDL语句。  
ResultSetMetaData getMetaData​();
//检索 ResultSetMetaData对象，该对象包含有关执行此 PreparedStatement对象时将返回的 ResultSet对象的列的信息。  
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, InputStream inputStream);
//将指定的参数设置为 InputStream对象。  
void setBlob​(int parameterIndex, InputStream inputStream, long length);
//将指定的参数设置为 InputStream对象。  
void setBlob​(int parameterIndex, Blob x);
//将指定的参数设置为给定的 java.sql.Blob对象。  
void setBoolean​(int parameterIndex, boolean x);
//将指定的参数设置为给定的Java boolean值。  
void setByte​(int parameterIndex, byte x);
//将指定的参数设置为给定的Java byte值。  
void setBytes​(int parameterIndex, byte[] x);
//将指定的参数设置为给定的Java字节数组。  
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, Reader reader);
//将指定的参数设置为 Reader对象。  
void setClob​(int parameterIndex, Reader reader, long length);
//将指定的参数设置为 Reader对象。  
void setClob​(int parameterIndex, Clob x);
//将指定的参数设置为给定的 java.sql.Clob对象。  
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 float值。  
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, Reader reader);
//将指定的参数设置为 Reader对象。  
void setNClob​(int parameterIndex, Reader reader, long length);
//将指定的参数设置为 Reader对象。  
void setNClob​(int parameterIndex, NClob value);
//将指定的参数设置为 java.sql.NClob对象。  
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);
//使用给定对象设置指定参数的值。  
default void setObject​(int parameterIndex, Object x, SQLType targetSqlType);
//使用给定对象设置指定参数的值。  
default void setObject​(int parameterIndex, Object x, SQLType 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 setURL​(int parameterIndex, URL x);
//将指定的参数设置为给定的 java.net.URL值。

PrepareStatement对象中常用的方法如下：

String sql = "SELECT * FROME USER WHERE username = ? AND password = ?";
PreparedStatement pstmt = conn.prepareStatement(sql);
//如上为创建一个PreparedStatement对象的方法，可以看到它在创建时就已经传入了一个sql语句了，其中需要替换的地方用？作为占位符代替。
setXxx(参数1,参数2);
//如上为设置参数的方法，xxx为数据类型，参数1为占位符?的编号，从1开始，参数2为?的值。
execulteUpdate();
execulteQuery();
//不需要再传递sql作为参数。

PreparedStatement预防SQL注入的原理为，将替换内容中的敏感字符换成转义符。

PreparedStatement能够将预编译好的sql语句传给数据库管理软件直接执行，省去数据库管理软件检查语法和编译的过程，加快数据库操作的速度。

注意：PreparedStatement对象的预编译功能默认是关闭的，如需使用则需要在数据库连接时的url里进行配置，将useServerPrepStmts设置为true。

数据库连接池

数据库连接池简介

  • 数据库连接池是一个容器，负责分配、管理数据库连接
  • 它允许应用程序重复使用一个现有的数据库连接而不是再重新建立一个；
  • 释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏
  • 好处：1.资源重复利用；2.提升系统响应速度；3.避免数据库连接遗漏。

数据库连接池实现

  • 标准接口：DataSource
  • 官方(SUN)提供的数据库连接池标准接口，由第三方组织实现此接口。
  • 功能：获取连接
Connection getConnection();

  • 常见的数据库连接池有：DBCP、C3P0、Druid

  • Druid(德鲁伊)
  • Druid连接池是阿里巴巴开源的数据库连接池项目
  • 功能强大、性能优秀，是Java语言最好的数据库连接池之一

数据库连接池的使用(Druid)

使用步骤：

  • 导入jar包
  • 定义配置文件
  • 加载配置文件
  • 获取数据库连接池对象
  • 获取连接

首先在项目的pom文件里导入jar包，在dependencies标签下添加如下代码：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.0</version>
</dependency>

然后用maven更新项目

在Java项目中新建一个druid.properotes文件，并在里面添加如下代码：

driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/数据库名?useSSL=false
username=root
password=
# 初始化连接数量
initialSize=5
# 最大连接数
maxActive=10
# 最大等待时间
maxWait=3000

这样就配置好了，然后将配置加载。

Properties prop = new Properties();
prop.load(new FileInputStream("配置文件地址"));

获取连接池对象。

DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);

获取连接

Connection conn = dataSource.getConnection();

这样就完成了连接池的使用。

注意：实际开发中通常会通过写一个JDBC工具类，将以上操作写进工具类的静态代码中来完成连接池的创建和使用。

CATALOG
    FEATURED TAGS
    致蛋蛋 一首小诗 编程相关 C/C++ C++标准库 树莓派 DIY 折腾 JAVA 笔记 数据库 Maven 前端 Spring
    FRIENDS