Java JDBC 数据库访问汇总

各种数据库连接依赖及其配制：

http://blog.163.com/luowei505050@126/blog/static/119907206201210223827126/

JDBC理论笔记：

http://www.cnblogs.com/hoojo/archive/2011/06/10/2077643.html

JDBC实践实例：

http://blog.csdn.net/iquicksandi/article/details/8545066

 

 

Java JDBC 理论笔记

Blog：http://blog.csdn.net/IBM_hoojo

email: hoojo_@126.com

 

一、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表示不作任何过滤。

JDBC, Java Database Connecive, Java 数据库连接，是一组专门负责连接并操作数据库的标准，在整个JDBC 中实际上大量的提供的是接口。针对于各个不同的数据库生产商 ，只要想使用JAVA 进行数据库的开发，则对这些标准有所支持。

JDBC 在使用中常见的有以下三类：

JDBC-ODBC 桥连接：是SUN 在JDK的开发包中提供的最标准的一套JDBC 操作类库，使用的时候将JDBC-ODB-数据库，中间要经过一个ODBC 的连接，那么就意味着整体的性能将会降低，所以在开发中是绝对不会去使用JDBC-ODBC的连接方式的。

JDBC 连接，使用各个数据库提供商给定的数据库驱动程序，完成JDBC的开发，使用的时候需要在classpath中配置数据库的驱动程序

JDBC 网络连接：主要使用通过网络连接数据库

 

JDBC 的操作步骤

在进行JDBC 操作的时候可以按照以下的步骤完成：

1、加载数据库驱动程序，加载的时候需要将驱动程序配置到classpath之中

2、连接数据库，通过Connection 接口和 DriverManager 类完成

3、操作数据库，通过Statement、PreparedStatement、ResultSet 三个接口完成

4、关闭数据库，在实际开发中数据库资源非常有限，操作完之后必须关闭

 

数据库连接操作

在JDBC 的操作中，如果要想进行数据库的连接，则必须按照以上的几步完成

1、通过Class.forName()加载数据库的驱动程序

2、通过DriverManager 类进行数据库的连接，连接的时候要输入数据库的连接地址、用户名、密码

3、通过Connection 接口接收连接

 

 

[java]  view plain copy print ?

 

1. package org.connectiondemo;  
2.   
3. import java.sql.Connection;  
4. import java.sql.DriverManager;  
5.   
6. public class ConnectionJDBC {  
7.   
8.     /** 
9.      * @param args 
10.      */  
11.     //驱动程序就是之前在classpath中配置的JDBC的驱动程序的JAR 包中  
12.     public static final String DBDRIVER = "com.mysql.jdbc.Driver";  
13.     //连接地址是由各个数据库生产商单独提供的，所以需要单独记住  
14.     public static final String DBURL = "jdbc:mysql://localhost:3306/test";  
15.     //连接数据库的用户名  
16.     public static final String DBUSER = "root";  
17.     //连接数据库的密码  
18.     public static final String DBPASS = "";  
19.       
20.       
21.     public static void main(String[] args) throws Exception {  
22.         Connection con = null; //表示数据库的连接对象  
23.         Class.forName(DBDRIVER); //1、使用CLASS 类加载驱动程序  
24.         con = DriverManager.getConnection(DBURL,DBUSER,DBPASS); //2、连接数据库  
25.         System.out.println(con);  
26.         con.close(); // 3、关闭数据库  
27.     }  
28.   
29. }  

 

数据库更新操作

 

如果要想执行数据库的更新操作，则可以使用Statement接口，数据库更新就是增加、修改、删除

 

增加、更新、删除操作

 

 

[java]  view plain copy print ?

 

1. package org.updatedemo;  
2.   
3. import java.sql.Connection;  
4. import java.sql.DriverManager;  
5. import java.sql.Statement;  
6.   
7. public class UpdateDemo {  
8.   
9.     /** 
10.      * @param args 
11.      */  
12.     //驱动程序就是之前在classpath中配置的JDBC的驱动程序的JAR 包中  
13.     public static final String DBDRIVER = "com.mysql.jdbc.Driver";  
14.     //连接地址是由各个数据库生产商单独提供的，所以需要单独记住  
15.     public static final String DBURL = "jdbc:mysql://localhost:3306/test";  
16.     //连接数据库的用户名  
17.     public static final String DBUSER = "root";  
18.     //连接数据库的密码  
19.     public static final String DBPASS = "";  
20.       
21.       
22.     public static void main(String[] args) throws Exception {  
23.         Connection con = null; //表示数据库的连接对象  
24.         Statement stmt = null;   
25.         Class.forName(DBDRIVER); //1、使用CLASS 类加载驱动程序  
26.         con = DriverManager.getConnection(DBURL,DBUSER,DBPASS); //2、连接数据库  
27.         stmt = con.createStatement(); //3、Statement 接口需要通过Connection 接口进行实例化操作  
28.         stmt.executeUpdate("insert into java_study.person values(\'Tom\',20,\'SH\')"); //执行SQL 语句，插入、更新、删除数据  
29.         stmt.executeUpdate("update java_study.person set name='Jery' where age = 20");  
30.         stmt.executeUpdate("delete from java_study.person where age = 20");  
31.         con.close(); // 4、关闭数据库  
32.     }  
33.   
34. }  

 

数据库查询操作

 

通过SELECT 语句，可以查询数据中的内容，在mysql 中直接查询的时候可以发现将返回全部的查询结果给用户看，那么对于程序的操作中也是一样的，所有的查询结果要返回到程序处进行输出查看，那么程序通过ResultSet 接口保存全部的查询结果，通过Statement 接口中的executeQuery()方法查询。

查询之后的数据需要分别的取出。通过 next ()方法找到返回的每一行数据，每一行中各个列的数据需要通过getXxx()方法取得，例如：

取得整型：getInt()

取得字符串：getString()

取得日期：getDate()

取得小数：getFloat()

 

 

[java]  view plain copy print ?

 

1. package org.querydemo;  
2.   
3. import java.sql.Connection;  
4. import java.sql.DriverManager;  
5. import java.sql.ResultSet;  
6. import java.sql.Statement;  
7.   
8. public class QueryDemo {  
9.   
10.     /** 
11.      * @param args 
12.      */  
13.     //驱动程序就是之前在classpath中配置的JDBC的驱动程序的JAR 包中  
14.     public static final String DBDRIVER = "com.mysql.jdbc.Driver";  
15.     //连接地址是由各个数据库生产商单独提供的，所以需要单独记住  
16.     public static final String DBURL = "jdbc:mysql://localhost:3306/test";  
17.     //连接数据库的用户名  
18.     public static final String DBUSER = "root";  
19.     //连接数据库的密码  
20.     public static final String DBPASS = "";  
21.       
22.       
23.     public static void main(String[] args) throws Exception {  
24.         Connection con = null; //表示数据库的连接对象  
25.         Statement stmt = null;  //表示数据库的更新操作  
26.         ResultSet result = null; //表示接收数据库的查询结果  
27.         Class.forName(DBDRIVER); //1、使用CLASS 类加载驱动程序  
28.         con = DriverManager.getConnection(DBURL,DBUSER,DBPASS); //2、连接数据库  
29.         stmt = con.createStatement(); //3、Statement 接口需要通过Connection 接口进行实例化操作  
30.         result = stmt.executeQuery("select name,age,address from java_study.person"); //执行SQL 语句，查询数据库  
31.         while (result.next()){  
32.             String name = result.getString("name");  
33.             int age = result.getInt("age");  
34.             String address = result.getString("address");  
35.             System.out.println(name+age+address);  
36.         }  
37.                 result.close();  
38.                 con.close(); // 4、关闭数据库  
39.     }  
40.   
41. }  

PreparedStatement

此接口是在实际的开发中使用最广泛的一个操作接口，此接口是Statement接口的子接口，采用预处理的方式完成

 

完成增加操作

 

[java]  view plain copy print ?

 

1. package org.preparedstatementdemo;  
2.   
3. import java.sql.Connection;  
4. import java.sql.DriverManager;  
5. import java.sql.PreparedStatement;  
6. import java.util.Date;  
7.   
8. public class PreparedStatementDemo  {  
9.   
10.     /** 
11.      * @param args 
12.      */  
13.   
14.     public static final String DBDRIVER = "com.mysql.jdbc.Driver";  
15.     //连接地址是由各个数据库生产商单独提供的，所以需要单独记住  
16.     public static final String DBURL = "jdbc:mysql://localhost:3306/test";  
17.     //连接数据库的用户名  
18.     public static final String DBUSER = "root";  
19.     //连接数据库的密码  
20.     public static final String DBPASS = "";  
21.       
22.     public static void main(String[] args) throws Exception {  
23.         // TODO Auto-generated method stub  
24.         Connection con = null; //表示数据库的连接对象  
25.         PreparedStatement pstmt = null; //表示数据库更新操作  
26.           
27.         String name = "Tom";  
28.         int age = 20;  
29.         Date date = new Date();       
30.         String sql = "insert into java_study.person values(?,?,?)";  
31.           
32.         Class.forName(DBDRIVER); //1、使用CLASS 类加载驱动程序  
33.           
34.         System.out.println(sql);  
35.         con = DriverManager.getConnection(DBURL,DBUSER,DBPASS); //2、连接数据库  
36.         pstmt = con.prepareStatement(sql); //使用预处理的方式创建对象  
37.         pstmt.setString(1, name); //第一个？号的内容  
38.         pstmt.setInt(2, age); //第二个？号的内容  
39.         pstmt.setDate(3, new java.sql.Date(date.getTime()));  
40.         pstmt.executeUpdate(); //执行SQL 语句，更新数据库  
41.         pstmt.close();  
42.         con.close(); // 4、关闭数据库  
43.     }  
44.   
45. }  

 

完成模糊操作

模糊查询要使用LIKE 语句，那么LIKE 语句需要使用%进行匹配

 

[java]  view plain copy print ?

 

1. package org.preparedstatementquery;  
2.   
3. import java.sql.Connection;  
4. import java.sql.DriverManager;  
5. import java.sql.PreparedStatement;  
6. import java.sql.ResultSet;  
7. import java.util.Date;  
8.   
9. public class PreparedStatementQuery {  
10.   
11.     /** 
12.      * @param args 
13.      */  
14.     // TODO Auto-generated method stub  
15.     public static final String DBDRIVER = "com.mysql.jdbc.Driver";  
16.     //连接地址是由各个数据库生产商单独提供的，所以需要单独记住  
17.     public static final String DBURL = "jdbc:mysql://localhost:3306/test";  
18.     //连接数据库的用户名  
19.     public static final String DBUSER = "root";  
20.     //连接数据库的密码  
21.     public static final String DBPASS = "";   
22.       
23.     public static void main(String[] args) throws Exception {  
24.         Connection con = null; //表示数据库的连接对象  
25.         PreparedStatement pstmt = null; //表示数据库更新操作  
26.         ResultSet result = null;  
27.           
28.         String like_name ="Tom1";  
29.         int like_age = 12;  
30.           
31.         String sql = "select name,age,birthday from java_study.person where name like ? or age = ?";  
32.           
33.         Class.forName(DBDRIVER); //1、使用CLASS 类加载驱动程序  
34.           
35.         System.out.println(sql);  
36.         con = DriverManager.getConnection(DBURL,DBUSER,DBPASS); //2、连接数据库  
37.         pstmt = con.prepareStatement(sql); //使用预处理的方式创建对象  
38.         pstmt.setString(1, "%"+like_name+"%");  
39.         pstmt.setInt(2, like_age);  
40.   
41.         result = pstmt.executeQuery(); //执行SQL 语句，更新数据库  
42.         while (result.next()){  
43.             String name = result.getString("name");  
44.             int age = result.getInt("age");  
45.             Date date = result.getDate("birthday");  
46.             System.out.println(name+","+age+","+date);  
47.         }  
48. <pre name="code" class="java">                result.close();</pre>  pstmt.close();con.close(); // 4、关闭数据库}}<p></p>  
49. <p><br>  
50. </p>  
51. <pre></pre>  
52. <p></p>  
53. <p><br>  
54. </p>  
55. <p><strong>批处理</strong></p>  
56. <p>批处理，多条SQL 语句可以一次性执行完毕，称为批处理操作</p>  
57. <p><br>  
58. </p>  
59. <p></p><pre name="code" class="java">package org.addbetchdemo;  
60.   
61. import java.sql.Connection;  
62. import java.sql.DriverManager;  
63. import java.sql.PreparedStatement;  
64. import java.util.Date;  
65.   
66. public class AddDetchDemo {  
67.   
68.     /** 
69.      * @param args 
70.      */  
71.     public static final String DBDRIVER = "com.mysql.jdbc.Driver";  
72.     //连接地址是由各个数据库生产商单独提供的，所以需要单独记住  
73.     public static final String DBURL = "jdbc:mysql://localhost:3306/test";  
74.     //连接数据库的用户名  
75.     public static final String DBUSER = "root";  
76.     //连接数据库的密码  
77.     public static final String DBPASS = "";   
78.       
79.     public static void main(String[] args) throws Exception {  
80.         // TODO Auto-generated method stub  
81.         Connection con = null; //表示数据库的连接对象  
82.         PreparedStatement pstmt = null; //表示数据库更新操作  
83.           
84.         String sql = "insert into java_study.person values(?,?,?)";  
85.           
86.         Class.forName(DBDRIVER); //1、使用CLASS 类加载驱动程序  
87.           
88.         System.out.println(sql);  
89.         con = DriverManager.getConnection(DBURL,DBUSER,DBPASS); //2、连接数据库  
90.         pstmt = con.prepareStatement(sql); //使用预处理的方式创建对象  
91.           
92.         for (int i = 0;i<10;i++){  
93.             pstmt.setString(1, "org"+i); //第一个？号的内容  
94.             pstmt.setInt(2, i); //第二个？号的内容  
95.             pstmt.setDate(3, new java.sql.Date(new java.util.Date().getTime()));  
96.             pstmt.addBatch();  
97.         }  
98.         int[] i = pstmt.executeBatch(); //执行SQL 语句，更新数据库  
99.         System.out.println(i);  
100.         pstmt.close();  
101.         con.close(); // 4、关闭数据库  
102.     }  
103.   
104. }  
105. </pre><br>  
106. <p></p>  
107. <p><strong>事务处理</strong><br>  
108. </p>  
109. <p>通过设置 connection  的autocommit(false) 提交事务  con.commit(); 回滚事务 con.rollback()<br>  
110. </p>  
111. <p></p><pre name="code" class="java">package org.transactiondemo;  
112.   
113. import java.sql.Connection;  
114. import java.sql.DriverManager;  
115. import java.sql.Statement;  
116.   
117. public class TransactionDemo {  
118.   
119.     /** 
120.      * @param args 
121.      */  
122.     //驱动程序就是之前在classpath中配置的JDBC的驱动程序的JAR 包中  
123.     public static final String DBDRIVER = "com.mysql.jdbc.Driver";  
124.     //连接地址是由各个数据库生产商单独提供的，所以需要单独记住  
125.     public static final String DBURL = "jdbc:mysql://localhost:3306/test";  
126.     //连接数据库的用户名  
127.     public static final String DBUSER = "root";  
128.     //连接数据库的密码  
129.     public static final String DBPASS = "";  
130.       
131.     public static void main(String[] args) throws Exception {  
132.         // TODO Auto-generated method stub  
133.         Connection con = null; //表示数据库的连接对象  
134.         Statement stmt = null;   
135.         Class.forName(DBDRIVER); //1、使用CLASS 类加载驱动程序  
136.         con = DriverManager.getConnection(DBURL,DBUSER,DBPASS); //2、连接数据库  
137.           
138.         con.setAutoCommit(false);  
139.           
140.         stmt = con.createStatement(); //3、Statement 接口需要通过Connection 接口进行实例化操作  
141.           
142.         try{  
143.         stmt.addBatch("insert into java_study.person values(\'Tom\',20,\'2012-01-01\')"); //执行SQL 语句，插入、更新、删除数据  
144.         stmt.addBatch("insert into java_study.person values(\'Tom\',20,\'2012-01-01\')");  
145.         stmt.addBatch("insert into java_study.person values(\''Tom\',20,\'2012-01-01\')");  
146.             stmt.executeBatch();  
147.             con.commit();  
148.         } catch(Exception e){  
149.             con.rollback();  
150.         }  
151.           
152.           
153.   
154.         stmt.close();  
155.         con.close(); // 4、关闭数据库  
156.     }  
157.   
158. }  
159. </pre><br>  
160. <br>  
161. <p></p>  
162. <p><br>  
163. </p>  
164. <p><br>  
165. </p>  
166. <p></p>