JDBC

来源：互联网发布：spss mac 破解编辑：程序博客网时间：2024/06/01 10:35

什么是JDBC?

Java语言访问数据库的一种规范,是一套API

JDBC (Java Database Connectivity) API，即Java数据库编程接口，是一组标准的Java语言中的接口和类，使用这些接口和类，Java客户端程序可以访问各种不同类型的数据库。比如建立数据库连接、执行SQL语句进行数据的存取操作。

JDBC规范采用接口和实现分离的思想设计了Java数据库编程的框架。接口包含在java.sql及javax.sql包中，其中java.sql属于JavaSE，javax.sql属于JavaEE。这些接口的实现类叫做数据库驱动程序，由数据库的厂商或其它的厂商或个人提供。

为了使客户端程序独立于特定的数据库驱动程序，JDBC规范建议开发者使用基于接口的编程方式，即尽量使应用仅依赖java.sql及javax.sql中的接口和类。

JDBC驱动程序:

什么是JDBC驱动程序?

这些是各个数据库厂家根据JDBC的规范制作的JDBC实现类

JDBC驱动程序的四种类型:

1. 第一种类型的驱动程序的实现是通过将JDBC的调用全部委托给其它编程接口来实现的，比如ODBC。这种类型的驱动程序需要安装本地代码库，即依赖于本地的程序，所以便携性较差。比如JDBC-ODBC桥驱动程序

2. 第二种类型的驱动程序的实现是部分基于Java语言的。即该驱动程序一部分是用Java语言编写，其它部分委托本地的数据库的客户端代码来实现。同类型1的驱动一样，该类型的驱动程序也依赖本地的程序，所以便携性较差

3. 第三种类型的驱动程序的实现是全部基于JAVA语言的。该类型的驱动程序通常由某个中间件服务器提供，这样客户端程序可以使用数据库无关的协议和中间件服务器进行通信，中间件服务器再将客户端的JDBC调用转发给数据库进行处理

4. 第四种类型的驱动程序的实现是全部基于JAVA语言的。该类型的驱动程序中包含了特定数据库的访问协议，使得客户端可以直接和数据库进行通信

JDBC类结构:

DriverManager

Driver Driver

Connection Connection

Statement Statement

Resultset Resultset

DriverManager:这个是一个实现类,它是一个工厂类,用来生产Driver对象的

这个类的结构设计模式为工厂方法

Driver:这是驱动程序对象的接口,它指向一个实实在在的数据库驱动程序对象,那么这个数据库驱动程序对象是从哪里来的呢?

DriverManager工厂中有个方法:getDriver(String URL),通过这个方法可以得到驱动程序对象,这个方法是在各个数据库厂商按JDBC规范设计的数据库驱动程序包里的类中静态实现的,也就是在静态块中

Connection:这个接口可以制向一个数据库连接对象,那么如何得到这个连接对象呢?

是通过DriverManager工厂中的getConnection(String URL)方法得到的

Statement:用于执行静态的SQL语句的接口,通过Connection中的createStatement方法得到的

Resultset:用于指向结果集对象的接口,结果集对象是通过Statement中的execute等方法得到的

JAVA使用JDBC访问数据库的步骤:

1. 得到数据库驱动程序

2. 创建数据库连接

3. 执行SQL语句

4. 得到结果集

5. 对结果集做相应的处理(增,删,改,查)

6. 关闭资源:这里释放的是DB中的资源

设置classpath:

1. 在java文件中起的包名一定要是工程基目录下的子目录,classpath:基目录

2. .jar包,需要将这个.jar包的路径包括这个文件的全名添加到classpath中来

Oracle连接字符串的书写格式:

“oracle:jdbc:thin:@ip:1521: 数据库名”,”数据库用户名”,”数据库密码”

简单的例子:

package moudule1.first;

import java.sql.*;

public class FirstJdbc

{

public static void main(String[] args)

{

String sql="select * from yuchen_user";

Connection con=null;

Statement st=null;

ResultSet rs=null;

try

{

Class.forName("oracle.jdbc.driver.OracleDriver");

con=DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:name", "scott","tiger");

st=con.createStatement();

rs=st.executeQuery(sql);

while(rs.next())

{

System.out.println(rs.getInt("id"));

System.out.println(rs.getString("name"));

}

}catch(Exception e)

{

e.printStackTrace();

}finally

{

try

{

con.close();

}catch(Exception e)

{}

try

{

st.close();

}catch(Exception e)

{

}

try

{

rs.close();

}catch(Exception e)

{

}

常用数据库的驱动程序及JDBC URL:

Oracle数据库:

驱动程序包名：ojdbc14.jar

驱动类的名字：oracle.jdbc.driver.OracleDriver

JDBC URL：jdbc:oracle:thin:@dbip:port:databasename

说明：驱动程序包名有可能会变

JDBC URL中黑色字体部分必须原封不动的保留，为该驱动识别的URL格式。红色字体部分需要根据数据库的安装情况填写。其中各个部分含义如下：

dbip –为数据库服务器的IP地址，如果是本地可写：localhost或127.0.0.1。

port –为数据库的监听端口，需要看安装时的配置，缺省为1521。

databasename –为数据库的SID，通常为全局数据库的名字。

举例如果要访问本地的数据库allandb，端口1521，那么URL写法如下：

jdbc:oracle:thin:@localhost:1521:allandb 下载地址如下:

http://www.oracle.com/technology/software/tech/java/sqlj_jdbc/index.html

SQL Server数据库

驱动程序包名：msbase.jar mssqlserver.jar msutil.jar

驱动类的名字：com.microsoft.jdbc.sqlserver.SQLServerDriver

JDBC URL：jdbc:microsoft:sqlserver://dbip:port;DatabaseName=databasename

说明：驱动程序包名有可能会变

JDBC URL中黑色字体部分必须原封不动的保留，为该驱动识别的URL格式。红色字体部需要根据数据库的安装情况填写。其中各个部分含义如下：

dbip –为数据库服务器的IP地址，如果是本地可写：localhost或127.0.0.1。

port –为数据库的监听端口，需要看安装时的配置，缺省为1433。

databasename –数据库的名字。

举例如果要访问本地的数据库allandb，端口1433，那么URL写法如下：

jdbc: microsoft: sqlserver:@localhost:1433; DatabaseName =allandb

下载地址：http://www.microsoft.com/downloads/details.aspx

MySQL数据库

驱动程序包名：mysql-connector-java-3.1.11-bin.jar

驱动类的名字：com.mysql.jdbc.Driver

JDBC URL：jdbc:mysql://dbip:port/databasename

说明：驱动程序包名有可能会变

JDBC URL中黑色字体部分必须原封不动的保留，为该驱动识别的URL格式。红色字体部需要根据数据库的安装情况填写。其中各个部分含义如下：

dbip –为数据库服务器的IP地址，如果是本地可写：localhost或127.0.0.1。

port –为数据库的监听端口，需要看安装时的配置，缺省为3306。

databasename –数据库的名字。

举例如果要访问本地的数据库allandb，端口1433，那么URL写法如下：

jdbc:mysql://localhost:3306/allandb

下载地址：http://dev.mysql.com/downloads/connector/j/

Access数据库

驱动程序包名：该驱动程序包含在JavaSE中，不需要额外安装。

驱动类的名字：sun.jdbc.odbc.JdbcOdbcDriver

JDBC URL：jdbc:odbc:datasourcename

说明：该驱动只能工作在Windows系统中，首先需要在操作系统中建立一个可以访问Access数据库的本地数据源(ODBC)，如果名字为allandb，那么URL写法如下：

jdbc:odbc:allandb

PreparedStatement接口:

预编译的sql语句对象

作用: 解决了书写sql语句时一些特殊的字符与sql保留字符冲突的问题,非常方便

/**

*知识点:

*PreparedStatement接口及方法的使用

*程序目标:

*java文件:

*PreparedInsert.java:连接数据库,插入一条数据

*JdbcUtil.java:实现一个工具类,功能:1.连接数据库 2.关闭资源

package moudule1.preparedstatement;

import java.sql.*;

import moudule1.com.*;

public class PreparedInsert

{

public static void main(String[] args)

{

String sql="insert into yuchen_user (id,name) values (?,?)";

System.out.println(sql);

Connection con=null;

PreparedStatement ps=null;

try{

con=JdbcUtil.getConnection();

ps=con.prepareStatement(sql);

ps.setInt(1,2);

ps.setString(2,"zhangsan");

ps.executeUpdate();

ps.setInt(1,3);

ps.setString(2,"lisi");

ps.executeUpdate();

}catch(Exception e){

e.printStackTrace();

}finally{

JdbcUtil.close(con,ps);

}

package moudule1.com;

import java.sql.*;

public class JdbcUtil{

public static Connection getConnection() throws Exception{

Class.forName("oracle.jdbc.driver.OracleDriver");

return DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:name", "scott","tiger");

}

public static void close(Connection con,Statement st){

close(con);

close(st);

}

public static void close(Connection con,Statement st,ResultSet rs){

close(con,st);

close(rs);

}

public static void close(Connection con){

try{

con.close();

}catch(Exception e){

}

public static void close(Statement st){

try{

st.close();

}catch(Exception e){

}

public static void close(ResultSet rs){

try{

rs.close();

}catch(Exception e){

}

数据库的增删改查的例子:

/**

*知识点:

*JDBC+SQL+ORACLE

*程序目标:

*UserDao.java:实现了数据库的增删改查

*JdbcUtil.java:工具类,有连库和关闭资源的方法

package moudule1.idus;

import java.sql.*;

import moudule1.com.*;

public class UserDao{

private String sql;

private Connection con;

private Statement st;

private ResultSet rs;

public UserDao(){

sql=null;

con=null;

st=null;

rs=null;

}

public void insert(){

sql="insert into yuchen_user (id,name) values(";

sql+="4,‘zhouwu‘)";

System.out.println(sql);

try{

con=JdbcUtil.getConnection();

st=con.createStatement();

st.executeUpdate(sql);

}catch(Exception e){

e.printStackTrace();

}finally{

JdbcUtil.close(con,st);

}

public void delete(){

sql="delete from yuchen_user where id=2";

System.out.println(sql);

try{

con=JdbcUtil.getConnection();

st=con.createStatement();

st.executeUpdate(sql);

}catch(Exception e){

e.printStackTrace();

}finally{

JdbcUtil.close(con,st);

}

public void update(){

sql="update yuchen_user set name=‘liumang‘ where id=1";

System.out.println(sql);

try{

con=JdbcUtil.getConnection();

st=con.createStatement();

st.executeUpdate(sql);

}catch(Exception e){

e.printStackTrace();

}finally{

JdbcUtil.close(con,st);

}

public void select(){

sql="select * from yuchen_user";

System.out.println(sql);

try{

con=JdbcUtil.getConnection();

st=con.createStatement();

rs=st.executeQuery(sql);

while(rs.next()){

System.out.println(rs.getInt(1));

System.out.println(rs.getString(2));

}

}catch(Exception e){

e.printStackTrace();

}finally{

JdbcUtil.close(con,st,rs);

}

public static void main(String[] args){

UserDao ud=new UserDao();

ud.select();

ud.insert();

ud.select();

ud.update();

ud.select();

ud.delete();

ud.select();

}

一些常用的方法:

/**

*知识点:

*execute方法,getResultSet(),getUpdateCount()

*程序目标:

*JdbcUtil.java:工具类,连接数据库,关闭资源

*sqlExecutor.java:命令行参数输入sql语句,并执行该语句

package moudule1.fangfa;

import java.sql.*;

import moudule1.com.*;

public class sqlExecutor{

public static void main(String[] args){

Connection con=null;

Statement st=null;

try{

con=JdbcUtil.getConnection();

st=con.createStatement();

boolean str=st.execute(args[0]);

if(str){

ResultSet rs=st.getResultSet();

while(rs.next()){

System.out.println(rs.getInt("id")+":"+rs.getString("name"));

}

rs.close();

}else{

int row=st.getUpdateCount();

System.out.println(row);

}

}catch(Exception e){

e.printStackTrace();

}finally{

JdbcUtil.close(con,st);

}

2. 补充
JDBC连接MySQL

加载及注册JDBC驱动程序

Class.forName("com.mysql.jdbc.Driver");

Class.forName("com.mysql.jdbc.Driver").newInstance();

JDBC URL 定义驱动程序与数据源之间的连接

标准语法：

<protocol（主要通讯协议）>:<subprotocol（次要通讯协议，即驱动程序名称）>:<data source identifier（数据源）>

MySQL的JDBC URL格式：

jdbc:mysql//[hostname][:port]/[dbname][?param1=value1][&param2=value2]….

示例：jdbc:mysql://localhost:3306/sample_db?user=root&password=your_password

常见参数：

user 用户名

password 密码

autoReconnect 联机失败，是否重新联机（true/false）

maxReconnect 尝试重新联机次数

initialTimeout 尝试重新联机间隔

maxRows 传回最大行数

useUnicode 是否使用Unicode字体编码（true/false）

characterEncoding 何种编码（GB2312/UTF-8/…）

relaxAutocommit 是否自动提交（true/false）

capitalizeTypeNames 数据定义的名称以大写表示

建立连接对象

String url="jdbc:mysql://localhost:3306/sample_db?user=root&password=your_password";

Connection con = DriverManager.getConnection(url);

建立SQL陈述式对象（Statement Object）

Statement stmt = con.createStatement()；

执行SQL语句

executeQuery()

String query = "select * from test";

ResultSet rs=stmt.executeQuery(query);

结果集ResultSet

while(rs.next())

{rs.getString(1);rs.getInt(2);}

executeUpdate()

String upd="insert into test (id,name) values(1001,xuzhaori)";

int con=stmt.executeUpdate(upd);

execute()

示例：

try{
}

catch(SQLException sqle)

{

}

finally

{

}

Java类型和SQL类型技术手册P421

PreparedStatement（预编语句）

PreparedStatement stmt = conn.prepareStatement("insert into test(id,name)values(?,?)");

stmt.setInt(1,id);

stmt.setString(2,name);

注：一旦设定语句的参数值后，就可以多次执行改语句，直到调用clearParameters（）方法将他清除为止

CallableStatement（预储程序）技术手册P430

JDBC2.0使用

ResultSet对象中的光标上下自由移动

Statement stmt = con.createStatement (ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);

ResultSet rs=stmt.executeQuery("select * from test");

public Statement createStatement(int resultSetType,int resultSetConcuttency) throws SQLException

resultSetType

TYPE_FORWARD_ONLY 只能使用next（）方法。

TYPE_SCROLL_SENSITIVE 可以上下移动，可以取得改变后的值。

TYPE_SCROLL_INSENSITIVE 可以上下移动。

resultSetConcuttency

CONCUR_READ_ONLY 只读

CONCUR_UPDATABLE ResultSet对象可以执行数据库的新增、修改、和移除

直接使用ResultSet对象执行更新数据

新增数据

Statement stmt＝con.createStatement（ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_PUDATABLE）;

ResultSet uprs=stmt.executeQuery("select * from test");

uprs.moveToInsertRow();

uprs.updateInt(1,1001);

uprs.updateString(2,"许召日");

uprs.insertRow;

更新数据

Statement stmt＝con.createStatement（ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_PUDATABLE）;

ResultSet uprs=stmt.executeQuery("select * from test");

uprs.last();

uprs.updateString("name","xuzhaori");

uprs.updateRow;

删除数据

Statement stmt＝con.createStatement（ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_PUDATABLE）;

ResultSet uprs=stmt.executeQuery("select * from test");

uprs.absolute(4);

uprs.deleteRow();

批处理

con.setAutoCommit(false); 关闭自动认可模式

Statement stmt=con.createStatement();

int[] rows;

stmt.addBatch("insert into test values(1001,xuzhaori)");

stmt.addBatch("insert into test values(1002,xuyalin)");

rows=stmt.executeBatch();

con.commit(); 没有任何错误，执行批处理stmt.executeBatch();

JNDI-数据源（Data Source）与连接池（Connection Pool）

Tomcat的JDBC数据源设置技术手册P439

连接池工具－Proxool Var 0.8.3 技术手册P446

设置web.xml

<?xml version="1.0" encoding="ISO-8859-1"?>

<web-app xmlns="http://java.sun.com/xml/ns/j2ee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"

version="2.4">

….

<servlet-name>ServletConfigurator</servlet-name>

<servlet-class>org.logicalcobwebs.proxool.configuration.ServletConfigurator</servlet-class>

<init-param>

<param-name>propertyFile</param-name>

<param-value>WEB-INF/classes/Proxool.properties</param-value>

</init-param>

<load-on-startup>1</load-on-startup>

</servlet>

后端统计端口添加下列

<servlet-name>Admin</servlet-name>

<servlet-class>org.logicalcobwebs.proxool.admin.servlet.AdminServlet</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>Admin</servlet-name>

<url-pattern>/Admin</url-pattern>

</servlet-mapping>

….

</web-app>

配置Proxool.properties

jdbc-0.proxool.alias=JSPBook

jdbc-0.proxool.driver-class=com.mysql.jdbc.Driver

jdbc-0.proxool.driver-url=jdbc:mysql://localhost:3306/sample_db?user=root&password=browser&useUnicode=true&characterEncoding=UTF-8

jdbc-0.proxool.maximum-connection-count=10

jdbc-0.proxool.prototype-count=4

jdbc-0.proxool.house-keeping-test-sql=select CURRENT_DATE

jdbc-0.proxool.verbose=true

jdbc-0.proxool.statistics=10s,1m,1d 后端统计接口添加此行

jdbc-0.proxool.statistics-log-level=DEBUG

使用Proxool连接池

Connection con = DriverManager.getConnection("proxool.JSPBook");

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

String query = "SELECT * FROM employee";

ResultSet rs = stmt.executeQuery(query);

一、JDBC常用接口、类介绍

JDBC提供对独立于数据库统一的API，用以执行SQL命令。API常用的类、接口如下：

DriverManager

管理JDBC驱动的服务类，主要通过它获取Connection数据库链接，常用方法如下：

public static synchronized Connection getConnection(String url, String user, String password) throws Exception;

该方法获得url对应的数据库的连接。

Connection常用数据库操作方法：

Statement createStatement throws SQLException: 该方法返回一个Statement对象。

PreparedStatement prepareStatement(String sql) throws SQLException;该方法返回预编译的Statement对象，

    即将SQL语句提交到数据库进行预编译。

CallableStatement prepareCall(String sql) throws SQLException：该方法返回CallableStatement对象，

    该对象用于存储过程的调用。

上面的三个方法都是返回执行SQL语句的Statement对象，PreparedStatement、CallableStatement的对象是Statement的子类，

只有获得Statement之后才可以执行SQL语句。

关于Connection控制事务的方法：

Savepoint setSavepoint(): 创建一个保存点

Savepoint setSavepoint(String name)：创建一个带有名称的保存点

void setTransactionIsolation(int level):设置事务隔离级别

void rollback()：回滚事务

void rollback(Savepoint savepoint)：回滚到指定保存点

void setAutoCommit(boolean autoCommit): 关闭自动提交，打开事务

void commit()：提交事务

Statement

用于执行SQL语句的API接口，该对象可以执行DDL、DCL语句，也可以执行DML语句，

还可以执行SQL查询语句，当执行查询语句是返回结果集，常用方法如下：

ResultSet executeQuery(String sql) throws SQLException：该方法用于执行查询语句，并返回查询结果对应的ResultSet对象，

        该方法只用于查询语句。

int executeUpdate(String sql) throws SQLException：该方法用于执行DML语句，并返回受影响的行数；

        该方法也可以执行DDL，执行DDL返回0；

boolean execute(String sql) throws SQLException：该方法可以执行任何SQL语句，如果执行后第一个结果是ResultSet对象，

        则返回true；如果执行后第一个结果为受影响的行数或没有任何结果，则返回false；

PreparedStatement

预编译的statement对象，PreparedStatement是Statement的子接口，它允许数据库预编译SQL（通常指带参数SQL）语句，

以后每次只改变SQL命令参数，避免数据库每次都编译SQL语句，这样性能就比较好。而相对于Statement而言，

使用PreparedStatement执行SQL语句时，无需重新传入SQL语句，因为它已经预编译了SQL语句。

但是PreparedStatement需要为编译的SQL语句传入参数值，所以它比了如下方法：

void setXxx(int index, value)根据该方法传入的参数值的类型不同，需要使用不同的方法。

传入的值的类型根据传入的SQL语句参数而定。

ResultSet

void close() throws SQLException：释放、关闭ResultSet对象

boolean absolute(int row):将结果集移动到第几行，如果row是负数，则移动到倒数第几行。

        如果移动到的记录指针指向一条有效记录，则该方法返回true；

void beforeFisrt(): 将ResultSet的记录指针定位到首行之前，这是ResultSet结果集记录指针的

        初始状态：记录指针的起始位置位于第一行之前。

boolean first()：将ResultSet的记录指针定位到首行。如果移动后的记录指针指向一条有效记录，则该方法返回true。

boolean previous()：将ResultSet的记录指针定位到上一行，如果移动后的记录指针指向一条有效记录，则该方法返回true。

boolean next()：将ResultSet的记录指针定位到下一行。如果移动后的记录指针指向一条有效记录，则返回true。

boolean last()：将ResultSet的记录指针定位到最后一行。如果移动后的记录指针指向一条有效记录，则返回true。

void afterLast()：将ResultSet的记录指针定位到最后一行之后。

注意：在JDK1.4以前只支持next移动，且每次移动一个位置。到JDK1.5就可以随意定位。

二、JDBC编程步骤

进行jdbc编程步骤大致如下：

1、加载数据库驱动

Class.forName(driverClass)上面的dirverClass就是数据库驱动类所对应的类路径字符串，根据不同数据库厂商提供的驱动也不同。

2、通过DriverManager获取数据库的链接

DriverManager.getConnection(String url, Stirng user, String pass)当使用DriverManager来获取链接，需要传入三个参数：分别是数据量的url、用户名、密码。

3、通过Connection对象创建Statement对象，Connection创建Statement的方法如下三个：

createStatement()创建基本的Statement对象。prepareStatement(String sql)：根据传入的sql语句创建预编译的Statement对象。prepareCall(String sql)：根据传入的sql语句创建CallableStatement对象

4、Statement执行SQL语句，Statement有三大方法来执行SQL语句：

execute：可以执行任何SQL语句，单比较麻烦

executeUpdate：可以执行DML、DDL语句。执行DML返回受影响的SQL语句行数，执行DDL返回0；

executeQuery：只能执行查询语句，执行后返回代表查询结果的ResultSet对象。

5、操作结果集，针对ResultSet

主要移动指针和获得值

next、previous、first、last、beforeFrist、afterLast、absolute等移动指针的方法。

getXxx获得移动指针指向行，特定列、索引的值。使用列名作为获取值的参数可读性好、使用索引作为获取参数性能好。

三、JDBC执行SQL语句

1、 executeUpdate执行DDL、DML语句

Statement提供了execute、executeUpdate、executeQuery三种方法执行，下面用executeUpdate来执行DDL、DML语句，

executeUpdate执行DDL返回值是0，执行了DML是返回影响后的记录条数。

2、 execute执行SQL语句

当我们知道SQL语句是完成修改语句时，我们就知道使用executeUpdate语句来完成操作；

如果SQL语句是完成查询操作的时候，我们就使用executeQuery来完成。

如果我们不知道SQL语句完成什么操作的时候，就可以使用execute方法来完成。

当我们使用Statement对象的execute方法执行SQL语句后返回的是boolean值，这就说明该语句能否返回ResultSet对象。

那么，如何判断是否是ResultSet对象？方法如下：

getResultSet()：获取该Statement执行查询语句返回的ResultSet对象

getUpdateCount()：获取该Statement执行修改语句影响的行数

3、 PrepareStatement执行SQL语句

对于我们操作数据库的时候，执行某一条SQL语句的时候。只有它的参数不同，而SQL语句相同。

我们可以使用占位符来设置我们的参数信息，PrepareStatement中的占位符是？，用？代替参数的位置。

insert into table values(?, ‘abc’, ?);

占位符仅仅支持PrepareStatement，而Statement不支持占位符。PrepareStatement是预编译SQL语句的，

然后将占位符替换成参数。而Statement就不能做到。

PrepareStatement对象也有execute、executeUpdate、executeQuery这三个方法，但这三个方法都无需传递参数。

只需用PrepareStatement来设置占位符的参数，通过用setXxxx(index, value)来完成设置参数信息即可。

PrepareStatement的效率要比Statement的效率高。

PrepareStatement设置参数可以不拼接字符串，而Statement设置参数信息的时候需要手动拼接字符串。

拼接字符串容易操作程序错误、可读性降低、维护性升高、程序性能下降。而PrepareStatement直接设置参数

信息就降低了编程的复杂度。并且它可以放在SQL注入。因为它是通过setXxx方法进行设置参数信息，

而Statement是通过拼接字符串，很容易就造成SQL注入。

综上所述，PrepareStatement比Statement有以下优点：

预编译SQL语句，性能更好

无需拼接SQL语句，编程更简单

可以防止SQL语句注入，安全性更好

4、 CallableStatement调用存储过程

存储过程的调用可以通过CallableStatement，通过Connection对象的prepareCall方法来创建CallableStatement对象。

然后传入存储过程的SQL语句，即可调用存储过程，格式如下：

{call proc_name(?, ?, ?)}

上面的?是占位符，表示传递的参数。

存储过程有传入参数、传出参数。传入参数是程程序必须传入的参数，可以 通过setXxx方法进行设置参数值。

而传出参数则需要通过程序进行设置，可以用CallableStatement对象的registerOutParameter方法来

注册输出参数，cs.registerOutParameter(3, Types.STRING);

设置完毕后，当调用存储过程后要获取输出参数值，可以通过getXxx方法来完成。

四、操作结果集(ResultSet)

JDBC是通过ResultSet来管理结果集，操作ResultSet可以通过移动其指针来指向不同的行记录，然后取出当前记录即可。并且ResultSet可以完成更新记录，还提供了ResultSetMetaData来获得对象相关信息。

1、可移动、可更新的ResultSet

前面介绍过ResultSet的相关方法，可以通过一系列的方法来移动记录指针，

如：absolute、previous、next、first、last、beforeFirst、afterLast等方法。

ResultSet默认是不支持更新的，如果希望ResultSet完成更新操作，必须在创建Statement或PrepareStatement时传入一些参数。

Connection对象在创建Statement或PrepareStatement时可以传入两个参数：

A、 resultSetType：控制ResultSet的类型，该参数有以下三个值：

    a、 ResultSet.TYPE_FORWARD_ONLY该常量控制记录指针只能向前移动。Jdk1.4的默认值

    b、 ResultSet.TYPE_SCROLL_INSENSITIVE：该常量控制记录指针自由移动(可滚动结果集)，

        但底层的数据改变不影响结果集ResultSet的内容

    c、 ResultSet.TYPE_SCROLL_SENSITIVE：该常量控制记录指针自由移动，但底层数据的影响会改变结果集ResultSet的内容

B、 resultSetConcurrency：控制ResultSet的并发类型，该参数可以接收如下两个值：

    a、 ResultSet.CONCUR_READ_ONLY：该常量表示ResultSet是只读并发模式

    b、 ResultSet.CONCUR_UPDATABLE：该常量表示ResultSet是更新并发模式

通过PrepareStatement、Statement的创建时进行参数设置来创建可滚动、可更新的ResultSet，

然后通过rs的updateXxx方法来完成某列的更新值设置，通过updateRow来提交修改。

2、 ResultSet中的二进制Blob数据处理

Blob类型通常用来存储文件，如：图片、音频、视频文件。将文件转换成二进制保存在数据库中，

取出来的时候可以二进制数据恢复成文件。

如果要插入图片到数据库，显然不能直接设置SQL参数拼接字符串进行插入。因为二进制常量无法表示。

但是将Blob类型数据插入到数据可以用PrepareStatement，通过PrepareStatement对象的setBinaryStatement

方法将参数传入到二进制输入流；也可以用Blob对象的getBytes方法直接取出数据。

3、利用ResultSetMetaData操作ResultSet结果集

在我们查询数据返回的结果集中，我们不清楚结果集存放的数据类型、数据列数。

那样我们就可以用ResultSetMetaData来读取ResultSet的信息。

通过ResultSet的getMetaData()的方法可以获取ResultSetMetaData对象。

然后可以用ResultSetMetaData对象的方法来操作ResultSet，常用方法如下：

int getColumnCount()：返回ResultSet的列名数量

int getColumnType(int column)：返回指定索引的类型

String getColumnName(int column)：返回指定索引的列名

五、JDBC事务

1、事务介绍

事务是一步或多步组成操作序列组成的逻辑执行单元，这个序列要么全部执行，要么则全部放弃执行。

事务的四个特性：原子性（Atomicity）、一致性（Consistency）、隔离性（IsoIation）和持续性（Durability）

原子性（Atomicity）：事务应用最小的执行单元，不可再分。是事务中不可再分的最小逻辑执行体。

一致性（Consistency）：事务的执行结果，必须使数据库的从一个一致性的状态变到另一个一致性的状态。

隔离线（IsoIation）：各个事务的执行互不干扰，任意一个事务的内部操作对其他并发的事务，都是隔离的。也就是：并发执行的事务之间不能看到对方的中间状态，并发执行的事务之间不能互相影响。

持续性（Durability）：持续性也称为持久性（Persistence），指事务一旦提交，对数据所做的任何改变，都要记录到永久存储器中，通常就是保存在物理数据库中。

通常数据库的事务涉及到的语句有：

一组DML（Data Munipulation Language，数据操作语言）语句，这组DML语句修改后数据将保持较好的一致性；

    操作表的语句，如插入、修改、删除等；

一个DDL（Data Definition Language，数据定义语言）语句，操作数据对象的语言，有create、alter、drop。

一个DCL（Data Control Language，数据控制语言）语句，主要有grant、revoke语句。

DDL和DCL语句最多只能有一个，因为它们都会导致事务的立即提交。

当事务所包含的全部数据库操作都成功执行后，应该提交事务，使这些修改永久生效。

事务提交有两种方式：显示提交和自动提交。

显示提交：使用commit提交

自动提交：执行DLL或DCL，或者程序正常退出

当事务包含的任意一个数据库操作执行失败后，应该回滚（rollback）事务，使该事务中所作的修改全部失效。

事务的回滚方式有两种：显示回滚和自动回滚。

显示回滚：使用rollback

自动回滚：系统错误或强行退出

2、 JDBC的事物的支持

JDBC的Connection也支持事物，Connection默认打开自动提交，即关闭事物。

也就是说，每条SQL语句执行就会立即提交到数据库，永久生效，无法对其进行操作。

关闭Connection的自动提交，开启事物。Connection的setAutoCommit方法即可：connection.setAutoCommit(false);

通过connection.getAutoCommit()来获取事物的模式。

当我们开启事物后，在当前Connection中完成的数据库操作，都不会立即提交到数据库，需要调用Connection的commit方法才行。

如果有语句执行失败，可以调用rollback来回滚。

注意：如果Connection遇到未处理的SQLException异常时，系统将非正常退出，系统会自动回滚该事务。

如果程序捕捉了该异常，则需要在异常处理中显示回滚事务。

Connection提供了设置事务中间保存点的方法：setSavepoint，有2个方法可以设置中间点：

Savepoint setSavepoint()：在当前事务中创建一个未命名的中间点，并返回该中间点的Savepoint对象。

Savepoint setSavepoint(String name)：当前事务中创建一个具有指定名称的中间点，并返回该中间点的Savepoint对象

通常setSavepoint(String name)设置中间点的名称，事务回滚并不是通过中间点的名称进行回滚的，而是根据中间点对象进行回滚的。

设置名称只是更好的区分中间点对象，用Connection的rollback(Savepoint savepoint)方法即可完成回滚到指定中间点。

3、 JDBC的批量更新

批量更新就是可以同时进行多条SQL语句，将会被作为一批操作被同时执行、同时提交。

批量更新需要得到数据底层的支持，可以通过调研DataBaseMetaData的supportsBatchUpdates方法来查看底层数据库是否支持批量更新。

批量更新也需要创建一个Statement对象，然后通过该对象的addBatch方法将多条SQL语句同时收集在一起，

然后通过Statement对象的executeBatch同时执行这些SQL语句，如下代码：

Statement sm = conn.createStatement();

sm.addBatch(sql);

sm.addBatch(sql2);

sm.addBatch(sql3);

…

//同时执行多条SQL语句

sm.executeBatch();

执行executeBatch将返回一个int[]的数组，因为使用Statement执行DDL、DML都将返回一个int的值，

而执行多条DDL、DML也将返回一个int数组。批量更新中不允许出现select查询语句，一旦出现程序将出现异常。

如果要批量更新正确、批量完成，需要用单个事务，如果批量更新过程中有失败，则需要用事务回滚到原始状态。

如果要达到这样的效果，需要关闭事务的自动提交，当批量更新完成再提交事务，如果出现异常将回滚事务。

然后将连接恢复成自动提交模式。

public int[] executeBatch(String[] sql) throws SQLException {

    int[] result = null;

    conn = DBHelper.getConnection();

    try {

        //获得当前Connection的提交模式

        boolean autoCommit = conn.getAutoCommit();

        //关闭自动提交模式

        conn.setAutoCommit(false);

        sm = conn.createStatement();

        for (String s : sql) {

            sm.addBatch(s);

        //执行批量更新

        result = sm.executeBatch();

        //提交事务

        conn.commit();

        //还原提交模式

        conn.setAutoCommit(autoCommit);

    } catch (Exception e) {

        e.printStackTrace();

        conn.rollback();

    } finally {

        if (sm != null) {

            sm.close();

        DBHelper.close();

    return result;

六、分析数据库数据

1、使用DatabaseMetaData分析数据库数据

JDBC提供了DatabaseMetaData来封装数据库连接对应的数据库信息，通过Connection的getMetaData方法来获取该对象。

DatabaseMetaData接口通常数据库驱动提供商完成实现，其作用是让用户了解数据库的底层信息。

使用该接口可以了解数据库底层的实现，便于完成多个数据库的相互切换。

如：可以利用supportsCorrelatedSubquenes方法来查看数据库底层是否可以利用关联子查询，

或是调用supportsBatchUpdates方法查看是否支持批量更新。

大部分的DatabaseMetaData都是以ResultSet对象返回的，可以通过ResultSet对象的getString、getInt来获取相关信息。

DatabaseMetaData方法都需要传递一个xxxPattern的模式字符串，这个字符串是过滤条件，一般传递是SQL中的%、_等内容。

如果传递一个null表示不作任何过滤。

package com.jdbc;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;

import com.jdbc.entity.Courseinfo;

public class OralceConnTest {
private String url="jdbc:oracle:thin:@localhost:1521:ibn";
private String user="test";
private String pwd="abs";
private Connection conn;
private Statement stat;
private PreparedStatement ps;
private ResultSet rs;
private CallableStatement cs;
/**
* 关闭连接关闭语句对象关闭结果集
* 注意Statement和PreparedStatement的区别
* @param args
* @throws SQLException
* @throws InstantiationException
* @throws IllegalAccessException
* @throws ClassNotFoundException
*/
public static void main(String[]args) throws SQLException, InstantiationException, IllegalAccessException, ClassNotFoundException{
OralceConnTest cont=OralceConnTest.class.newInstance();
cont.getConnection();
cont.callStatement();
// Courseinfo course=new Courseinfo();
// course.setId(5);
// course.setUsername("小明");
// course.setPassword("456");
// cont.insert(course);
}
/**
* 加载驱动，建立连接
* @return
*/
public Connection getConnection(){
try {
Class.forName("oracle.jdbc.driver.OracleDriver");
conn=DriverManager.getConnection(url, user, pwd);
} catch (Exception e) {
e.printStackTrace();
}
return conn;
}
/**
*查询数据库的表
* @throws SQLException
* @throws ClassNotFoundException
*/
public void conn() throws SQLException, ClassNotFoundException{
try {
stat=conn.createStatement();
ResultSet rs=stat.executeQuery("select userid,username,password from userinfo");
while(rs.next()){
StringBuffer sb=new StringBuffer();
String a=rs.getString(1);
String b=rs.getString(2);
String c=rs.getString(3);
sb.append(a).append(b).append(c);
System.out.println(sb);
}
} catch (SQLException e) {
e.printStackTrace();
}finally{
conn.close();
stat.close();
}
}
/**
* 执行插入操作注意插入操作 insert into tablename values(id,'name','password') 注意这个单引号不能忘掉
* @param course
*/
public void insert(Courseinfo course){
try {
//将自动提交事务设关闭
conn.setAutoCommit(false);
stat=conn.createStatement();
String sql="insert into userinfo(userid,username,password)" +
"values("+course.getId()+",'"
+course.getUsername()+"','"+course.getPassword()+"')";
int a=stat.executeUpdate(sql);
if(a==1){
System.out.println("statement插入正常");
//事务提交
conn.commit();
}else{
//事务回滚
conn.rollback();
}
//将事务自动提交恢复
conn.setAutoCommit(true);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{

if(stat!=null){
try {
stat.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(conn!=null){
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
/**
* statement每次执行sql语句，相关数据库都要执行sql语句的编译
* preparedstatement是预编译得, preparedstatement支持批处理
* statement执行update必须有参数
* preparedStatement在创建时已经预编译了，没有参数
* @param course
*/
public void prepareInsert(Courseinfo course){

try {
String sql="insert into userinfo(userid,username,password)values(?,?,?)";
ps=conn.prepareStatement(sql);
ps.setInt(1, course.getId());
ps.setString(2, course.getUsername());
ps.setString(3, course.getPassword());
int a=ps.executeUpdate();
if(a==1){
System.out.println("preparedStatementd插入正常");
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(ps!=null){
try {
ps.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(conn!=null){
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

}
/**
* 获取数据库基本信息
*/
public void getDbData(String tablename){
String sql="select*from "+tablename;
try {
//获取数据库元数据
DatabaseMetaData dmd=conn.getMetaData();
//获取数据库的各种信息数据库名字
System.out.println(dmd.getDatabaseProductName());
stat=conn.createStatement();
rs=stat.executeQuery(sql);
//结果集元数据
ResultSetMetaData rmd=rs.getMetaData();
//获取结果集列数
int columnCount=rmd.getColumnCount();
for(int i=0;i<columnCount;i++){
//获取列名
System.out.println(rmd.getColumnName(i));
}
while(rs.next()){
for(int i=0;i<columnCount;i++){
//由列名获取结果集
String value=rs.getString(rmd.getColumnName(i));
}
}
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 批处理
*/
public void batchExecute(){
String sql="insert into courseinfo(userid) values(?)";
try {
conn.setAutoCommit(false);
ps=conn.prepareStatement(sql);
for(int i=5;i<100;i++){
ps.setInt(1, i);
//将sql语句加入批处理
ps.addBatch();
//每10条处理一次
if(i%10==0){
stat.executeBatch();
stat.clearBatch();
}
stat.executeBatch();//处理最后五条
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
/**
* 操作结果集
*基于缓存的分页策略
*起始数据 (page-1)*pageSize+1
* @param pageSize 每页有多少条数据
* @param page 第几页
*/
public void bufferPageDemo(int pageSize,int page){
String sql="select*from courseinfo";
try {
//结果集滚动不敏感的(可跳步的)
/**
* ResultSet有个结果集指针，初始是指向第一个结果的
*
* 1.ResultSet.TYPE_FORWARD_ONLY 指针只能安装列顺序向前移动，也就是说在取得name列之后，将不能再返回获取id列的值；
* 2.ResultSet.TYPE_SCROLL_INSENSITIVE指针可以前后移动，INSENSITIVE表示不及时更新，就是如果数据库里的数据修改过，并不在ResultSet中反映出来；
* 3.ResultSet.TYPE_SCROLL_SENSITIVE指针可以前后移动，SENSITIVE表示及时跟踪数据库的更新，以便更改ResultSet中的数据。
*
*
* 1.ResultSet.CONCUR_READ_ONLY表示当前ResultSet对象只读，不能用结果集更新数据库中的表
* 2.ResultSet.CONCUR_UPDATABLE表示当前ResultSet能用结果集更新数据库中的表
*
* ResultSet提供各种控制指针的方法
*/
//conn.createStatement(resultSetType, resultSetConcurrency)
stat=conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
rs=stat.executeQuery(sql);
rs.last();//移动到最后一行
int rownum=rs.getRow();//记录当前的行号，记录的条数
rs.absolute(1);//将指针移到第一行
rs.relative(2);//相对当前位置移动2行
/*更新第三条记录*/
rs.updateInt(1, 100);
rs.updateString(2, "更新地方");
rs.updateRow();//更新数据源的数据
/*插入数据*/
rs.moveToInsertRow();//指针移到插入行
rs.updateInt(1, 100);
rs.updateString(2, "插入地方");
rs.insertRow();
rs.moveToCurrentRow();//指针移到插入前的位置
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* 存储过程的调用
*
*
*/
public void callStatement(){
StringBuffer sb=new StringBuffer(20);//线程安全
/*
* sys_refcursor游标类型
create or replace procedure testc(infos out sys_refcursor,num out number,names out varchar2)
is
begin
open infos for 'select*from userinfo';
select count(*) into num from userinfo;
select username into names from userinfo where userid=1;
end testc;
*/
sb.append("{call testc(?,?,?)}");
try {
cs=conn.prepareCall(sb.toString());
//返回游标类型
cs.registerOutParameter(1, oracle.jdbc.OracleTypes.CURSOR);
//返回num类型
cs.registerOutParameter(2, java.sql.Types.INTEGER);
//返回字符类型
cs.registerOutParameter(3, java.sql.Types.VARCHAR);
cs.execute();
rs=(ResultSet)cs.getObject(1);
//获取结果集的列数
int count=rs.getMetaData().getColumnCount();//获得结果集记录的字段数
System.out.println("count="+count);
while(rs.next()){
for(int i=1;i<=count;i++){
System.out.println(rs.getString(i));
}
}
System.out.println("------返回number类型-------");
int counts=cs.getInt(2);
System.out.println(counts);
System.out.println("-----返回varchar-------");
String name=cs.getString(3);
System.out.println(name);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
/*调用存储过程，返回游标，整数，字符串*/

/*调用存储过程，返回整数*/
/**/
/**/

}
}package com.jdbc;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;

import com.jdbc.entity.Courseinfo;

public class OralceConnTest {
private String url="jdbc:oracle:thin:@localhost:1521:ibn";
private String user="test";
private String pwd="abs";
private Connection conn;
private Statement stat;
private PreparedStatement ps;
private ResultSet rs;
private CallableStatement cs;
/**
* 关闭连接关闭语句对象关闭结果集
* 注意Statement和PreparedStatement的区别
* @param args
* @throws SQLException
* @throws InstantiationException
* @throws IllegalAccessException
* @throws ClassNotFoundException
*/
public static void main(String[]args) throws SQLException, InstantiationException, IllegalAccessException, ClassNotFoundException{
OralceConnTest cont=OralceConnTest.class.newInstance();
cont.getConnection();
cont.callStatement();
// Courseinfo course=new Courseinfo();
// course.setId(5);
// course.setUsername("小明");
// course.setPassword("456");
// cont.insert(course);
}
/**
* 加载驱动，建立连接
* @return
*/
public Connection getConnection(){
try {
Class.forName("oracle.jdbc.driver.OracleDriver");
conn=DriverManager.getConnection(url, user, pwd);
} catch (Exception e) {
e.printStackTrace();
}
return conn;
}
/**
*查询数据库的表
* @throws SQLException
* @throws ClassNotFoundException
*/
public void conn() throws SQLException, ClassNotFoundException{
try {
stat=conn.createStatement();
ResultSet rs=stat.executeQuery("select userid,username,password from userinfo");
while(rs.next()){
StringBuffer sb=new StringBuffer();
String a=rs.getString(1);
String b=rs.getString(2);
String c=rs.getString(3);
sb.append(a).append(b).append(c);
System.out.println(sb);
}
} catch (SQLException e) {
e.printStackTrace();
}finally{
conn.close();
stat.close();
}
}
/**
* 执行插入操作注意插入操作 insert into tablename values(id,'name','password') 注意这个单引号不能忘掉
* @param course
*/
public void insert(Courseinfo course){
try {
//将自动提交事务设关闭
conn.setAutoCommit(false);
stat=conn.createStatement();
String sql="insert into userinfo(userid,username,password)" +
"values("+course.getId()+",'"
+course.getUsername()+"','"+course.getPassword()+"')";
int a=stat.executeUpdate(sql);
if(a==1){
System.out.println("statement插入正常");
//事务提交
conn.commit();
}else{
//事务回滚
conn.rollback();
}
//将事务自动提交恢复
conn.setAutoCommit(true);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{

if(stat!=null){
try {
stat.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(conn!=null){
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
/**
* statement每次执行sql语句，相关数据库都要执行sql语句的编译
* preparedstatement是预编译得, preparedstatement支持批处理
* statement执行update必须有参数
* preparedStatement在创建时已经预编译了，没有参数
* @param course
*/
public void prepareInsert(Courseinfo course){

try {
String sql="insert into userinfo(userid,username,password)values(?,?,?)";
ps=conn.prepareStatement(sql);
ps.setInt(1, course.getId());
ps.setString(2, course.getUsername());
ps.setString(3, course.getPassword());
int a=ps.executeUpdate();
if(a==1){
System.out.println("preparedStatementd插入正常");
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(ps!=null){
try {
ps.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(conn!=null){
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

}
/**
* 获取数据库基本信息
*/
public void getDbData(String tablename){
String sql="select*from "+tablename;
try {
//获取数据库元数据
DatabaseMetaData dmd=conn.getMetaData();
//获取数据库的各种信息数据库名字
System.out.println(dmd.getDatabaseProductName());
stat=conn.createStatement();
rs=stat.executeQuery(sql);
//结果集元数据
ResultSetMetaData rmd=rs.getMetaData();
//获取结果集列数
int columnCount=rmd.getColumnCount();
for(int i=0;i<columnCount;i++){
//获取列名
System.out.println(rmd.getColumnName(i));
}
while(rs.next()){
for(int i=0;i<columnCount;i++){
//由列名获取结果集
String value=rs.getString(rmd.getColumnName(i));
}
}
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 批处理
*/
public void batchExecute(){
String sql="insert into courseinfo(userid) values(?)";
try {
conn.setAutoCommit(false);
ps=conn.prepareStatement(sql);
for(int i=5;i<100;i++){
ps.setInt(1, i);
//将sql语句加入批处理
ps.addBatch();
//每10条处理一次
if(i%10==0){
stat.executeBatch();
stat.clearBatch();
}
stat.executeBatch();//处理最后五条
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
/**
* 操作结果集
*基于缓存的分页策略
*起始数据 (page-1)*pageSize+1
* @param pageSize 每页有多少条数据
* @param page 第几页
*/
public void bufferPageDemo(int pageSize,int page){
String sql="select*from courseinfo";
try {
//结果集滚动不敏感的(可跳步的)
/**
* ResultSet有个结果集指针，初始是指向第一个结果的
*
* 1.ResultSet.TYPE_FORWARD_ONLY 指针只能安装列顺序向前移动，也就是说在取得name列之后，将不能再返回获取id列的值；
* 2.ResultSet.TYPE_SCROLL_INSENSITIVE指针可以前后移动，INSENSITIVE表示不及时更新，就是如果数据库里的数据修改过，并不在ResultSet中反映出来；
* 3.ResultSet.TYPE_SCROLL_SENSITIVE指针可以前后移动，SENSITIVE表示及时跟踪数据库的更新，以便更改ResultSet中的数据。
*
*
* 1.ResultSet.CONCUR_READ_ONLY表示当前ResultSet对象只读，不能用结果集更新数据库中的表
* 2.ResultSet.CONCUR_UPDATABLE表示当前ResultSet能用结果集更新数据库中的表
*
* ResultSet提供各种控制指针的方法
*/
//conn.createStatement(resultSetType, resultSetConcurrency)
stat=conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
rs=stat.executeQuery(sql);
rs.last();//移动到最后一行
int rownum=rs.getRow();//记录当前的行号，记录的条数
rs.absolute(1);//将指针移到第一行
rs.relative(2);//相对当前位置移动2行
/*更新第三条记录*/
rs.updateInt(1, 100);
rs.updateString(2, "更新地方");
rs.updateRow();//更新数据源的数据
/*插入数据*/
rs.moveToInsertRow();//指针移到插入行
rs.updateInt(1, 100);
rs.updateString(2, "插入地方");
rs.insertRow();
rs.moveToCurrentRow();//指针移到插入前的位置
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* 存储过程的调用
*
*
*/
public void callStatement(){
StringBuffer sb=new StringBuffer(20);//线程安全
/*
* sys_refcursor游标类型
create or replace procedure testc(infos out sys_refcursor,num out number,names out varchar2)
is
begin
open infos for 'select*from userinfo';
select count(*) into num from userinfo;
select username into names from userinfo where userid=1;
end testc;
*/
sb.append("{call testc(?,?,?)}");
try {
cs=conn.prepareCall(sb.toString());
//返回游标类型
cs.registerOutParameter(1, oracle.jdbc.OracleTypes.CURSOR);
//返回num类型
cs.registerOutParameter(2, java.sql.Types.INTEGER);
//返回字符类型
cs.registerOutParameter(3, java.sql.Types.VARCHAR);
cs.execute();
rs=(ResultSet)cs.getObject(1);
//获取结果集的列数
int count=rs.getMetaData().getColumnCount();//获得结果集记录的字段数
System.out.println("count="+count);
while(rs.next()){
for(int i=1;i<=count;i++){
System.out.println(rs.getString(i));
}
}
System.out.println("------返回number类型-------");
int counts=cs.getInt(2);
System.out.println(counts);
System.out.println("-----返回varchar-------");
String name=cs.getString(3);
System.out.println(name);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
/*调用存储过程，返回游标，整数，字符串*/

/*调用存储过程，返回整数*/
/**/
/**/

}
}package com.jdbc;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;

import com.jdbc.entity.Courseinfo;

public class OralceConnTest {
private String url="jdbc:oracle:thin:@localhost:1521:ibn";
private String user="test";
private String pwd="abs";
private Connection conn;
private Statement stat;
private PreparedStatement ps;
private ResultSet rs;
private CallableStatement cs;
/**
* 关闭连接关闭语句对象关闭结果集
* 注意Statement和PreparedStatement的区别
* @param args
* @throws SQLException
* @throws InstantiationException
* @throws IllegalAccessException
* @throws ClassNotFoundException
*/
public static void main(String[]args) throws SQLException, InstantiationException, IllegalAccessException, ClassNotFoundException{
OralceConnTest cont=OralceConnTest.class.newInstance();
cont.getConnection();
cont.callStatement();
// Courseinfo course=new Courseinfo();
// course.setId(5);
// course.setUsername("小明");
// course.setPassword("456");
// cont.insert(course);
}
/**
* 加载驱动，建立连接
* @return
*/
public Connection getConnection(){
try {
Class.forName("oracle.jdbc.driver.OracleDriver");
conn=DriverManager.getConnection(url, user, pwd);
} catch (Exception e) {
e.printStackTrace();
}
return conn;
}
/**
*查询数据库的表
* @throws SQLException
* @throws ClassNotFoundException
*/
public void conn() throws SQLException, ClassNotFoundException{
try {
stat=conn.createStatement();
ResultSet rs=stat.executeQuery("select userid,username,password from userinfo");
while(rs.next()){
StringBuffer sb=new StringBuffer();
String a=rs.getString(1);
String b=rs.getString(2);
String c=rs.getString(3);
sb.append(a).append(b).append(c);
System.out.println(sb);
}
} catch (SQLException e) {
e.printStackTrace();
}finally{
conn.close();
stat.close();
}
}
/**
* 执行插入操作注意插入操作 insert into tablename values(id,'name','password') 注意这个单引号不能忘掉
* @param course
*/
public void insert(Courseinfo course){
try {
//将自动提交事务设关闭
conn.setAutoCommit(false);
stat=conn.createStatement();
String sql="insert into userinfo(userid,username,password)" +
"values("+course.getId()+",'"
+course.getUsername()+"','"+course.getPassword()+"')";
int a=stat.executeUpdate(sql);
if(a==1){
System.out.println("statement插入正常");
//事务提交
conn.commit();
}else{
//事务回滚
conn.rollback();
}
//将事务自动提交恢复
conn.setAutoCommit(true);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{

if(stat!=null){
try {
stat.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(conn!=null){
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
/**
* statement每次执行sql语句，相关数据库都要执行sql语句的编译
* preparedstatement是预编译得, preparedstatement支持批处理
* statement执行update必须有参数
* preparedStatement在创建时已经预编译了，没有参数
* @param course
*/
public void prepareInsert(Courseinfo course){

try {
String sql="insert into userinfo(userid,username,password)values(?,?,?)";
ps=conn.prepareStatement(sql);
ps.setInt(1, course.getId());
ps.setString(2, course.getUsername());
ps.setString(3, course.getPassword());
int a=ps.executeUpdate();
if(a==1){
System.out.println("preparedStatementd插入正常");
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(ps!=null){
try {
ps.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(conn!=null){
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

}
/**
* 获取数据库基本信息
*/
public void getDbData(String tablename){
String sql="select*from "+tablename;
try {
//获取数据库元数据
DatabaseMetaData dmd=conn.getMetaData();
//获取数据库的各种信息数据库名字
System.out.println(dmd.getDatabaseProductName());
stat=conn.createStatement();
rs=stat.executeQuery(sql);
//结果集元数据
ResultSetMetaData rmd=rs.getMetaData();
//获取结果集列数
int columnCount=rmd.getColumnCount();
for(int i=0;i<columnCount;i++){
//获取列名
System.out.println(rmd.getColumnName(i));
}
while(rs.next()){
for(int i=0;i<columnCount;i++){
//由列名获取结果集
String value=rs.getString(rmd.getColumnName(i));
}
}
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 批处理
*/
public void batchExecute(){
String sql="insert into courseinfo(userid) values(?)";
try {
conn.setAutoCommit(false);
ps=conn.prepareStatement(sql);
for(int i=5;i<100;i++){
ps.setInt(1, i);
//将sql语句加入批处理
ps.addBatch();
//每10条处理一次
if(i%10==0){
stat.executeBatch();
stat.clearBatch();
}
stat.executeBatch();//处理最后五条
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
/**
* 操作结果集
*基于缓存的分页策略
*起始数据 (page-1)*pageSize+1
* @param pageSize 每页有多少条数据
* @param page 第几页
*/
public void bufferPageDemo(int pageSize,int page){
String sql="select*from courseinfo";
try {
//结果集滚动不敏感的(可跳步的)
/**
* ResultSet有个结果集指针，初始是指向第一个结果的
*
* 1.ResultSet.TYPE_FORWARD_ONLY 指针只能安装列顺序向前移动，也就是说在取得name列之后，将不能再返回获取id列的值；
* 2.ResultSet.TYPE_SCROLL_INSENSITIVE指针可以前后移动，INSENSITIVE表示不及时更新，就是如果数据库里的数据修改过，并不在ResultSet中反映出来；
* 3.ResultSet.TYPE_SCROLL_SENSITIVE指针可以前后移动，SENSITIVE表示及时跟踪数据库的更新，以便更改ResultSet中的数据。
*
*
* 1.ResultSet.CONCUR_READ_ONLY表示当前ResultSet对象只读，不能用结果集更新数据库中的表
* 2.ResultSet.CONCUR_UPDATABLE表示当前ResultSet能用结果集更新数据库中的表
*
* ResultSet提供各种控制指针的方法
*/
//conn.createStatement(resultSetType, resultSetConcurrency)
stat=conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
rs=stat.executeQuery(sql);
rs.last();//移动到最后一行
int rownum=rs.getRow();//记录当前的行号，记录的条数
rs.absolute(1);//将指针移到第一行
rs.relative(2);//相对当前位置移动2行
/*更新第三条记录*/
rs.updateInt(1, 100);
rs.updateString(2, "更新地方");
rs.updateRow();//更新数据源的数据
/*插入数据*/
rs.moveToInsertRow();//指针移到插入行
rs.updateInt(1, 100);
rs.updateString(2, "插入地方");
rs.insertRow();
rs.moveToCurrentRow();//指针移到插入前的位置
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* 存储过程的调用
*
*
*/
public void callStatement(){
StringBuffer sb=new StringBuffer(20);//线程安全
/*
* sys_refcursor游标类型
create or replace procedure testc(infos out sys_refcursor,num out number,names out varchar2)
is
begin
open infos for 'select*from userinfo';
select count(*) into num from userinfo;
select username into names from userinfo where userid=1;
end testc;
*/
sb.append("{call testc(?,?,?)}");
try {
cs=conn.prepareCall(sb.toString());
//返回游标类型
cs.registerOutParameter(1, oracle.jdbc.OracleTypes.CURSOR);
//返回num类型
cs.registerOutParameter(2, java.sql.Types.INTEGER);
//返回字符类型
cs.registerOutParameter(3, java.sql.Types.VARCHAR);
cs.execute();
rs=(ResultSet)cs.getObject(1);
//获取结果集的列数
int count=rs.getMetaData().getColumnCount();//获得结果集记录的字段数
System.out.println("count="+count);
while(rs.next()){
for(int i=1;i<=count;i++){
System.out.println(rs.getString(i));
}
}
System.out.println("------返回number类型-------");
int counts=cs.getInt(2);
System.out.println(counts);
System.out.println("-----返回varchar-------");
String name=cs.getString(3);
System.out.println(name);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
/*调用存储过程，返回游标，整数，字符串*/

/*调用存储过程，返回整数*/
/**/
/**/

}
}

2 0