【JDBC】JDBC入门汇总及范例讲解

http://blog.youkuaiyun.com/evankaka/article/details/45370609

林炳文Evankaka原创作品。转载请注明出处http://blog.youkuaiyun.com/evankaka

一、JDBC是什么?

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

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

• 连接到数据库

• 创建SQL或MySQL语句

• 在数据库中执行SQL或MySQL查询

• 查看和修改记录

二、使用JDBC要有什么条件呢？

• 目标数据库主机的地址

• 数据库软件在该主机上所占用的端口号

• 登陆数据库用的用户名

• 该用户名的密码

• 连接数据库

三、JDBC技术的原理

         我们知道，数据库是有各种类型的，不同的厂商生产的数据库标格和规范是不同的，这时候，如果我们用JAVA代码来发送SQL语句，就要根据不同的数据库来写一套又一套的操作代码，这对程序开发者的开发成本是十分巨大的，所以，SUN公司在开发JDBC技术的时候，规定了一套标准接口，数据库产商都必须提供一个驱动来实现这套接口，那么，只要程序开发者在开发时使用了该数据库的驱动，就用一致的方法来开发了，而不需自己写一套有一套的代码去适应不同的数据库。

四、JDBC中的核心API

|- Driver : 驱动程序类实现的接口。

　　|-Connection connect(String url, Properties info)  --用于连接数据库，得到连接对象

Properties 里需要设置的参数：

　　　　url： 数据库连接的URL字符串。协议+数据库子协议+主机+端口+数据库

　　　　user： 数据库用户名

　　　　password： 用户的密码

　　|-Connection :    与数据库连接的接口

　　　　　　|- Statement createStatement()   --创建Statement对象，用于发送sql语句

　　　　　　|- PreparedStatement prepareStatement(String sql)  -创建PreparedStatement对象，用于发送预编译的sql语句

　　　　　　|-CallableStatement prepareCall(String sql)  --创建CallableStatement对象，用于调用存储过程。

　　　　　　|-Statement： 用于执行静态sql语句

　　　　　　　　　　|-int executeUpdate(String sql)  --执行更新操作（DDL+DML）

　　　　　　　　　　|-ResultSet executeQuery(String sql)  --执行查询操作(DQL)

　　　　　　|- PreparedStatement： 用于执行预编译的sql语句

　　　　　　　　　　|- int executeUpdate() -- 执行更新操作

　　　　　　　　　　|- ResultSet executeQuery()    -- 执行查询操作

　　　　　　|- CallableStatement： 用于执行存储过程的sql

　　　　　　　　　　|- ResultSet executeQuery()  --调用存储过程

　　　　　　　　　　|- ResultSet： 结果集。用于封装数据库的查询后的数据

　　　　　　　　　　　　　　|- boolean next() --将记录光标移动到下一行

　　　　　　　　　　　　　　|- Object getObject(int columnIndex) -- 得到字段上的值

五、创建JDBC应用程序步骤

1、导入包

这需要你有软件包包含了数据库编程所需的JDBC类。大多数情况下，使用import java.sql.* 就足够了，如下所示

[java]  view plain copy

1. <span style="font-family:SimSun;font-size:12px;">import java.sql.*;</span>  

2、注册jdbc驱动程序

这需要初始化驱动程序，这样就可以打开与数据库的通信信道。以下是代码片段实现这一目标：

[java]  view plain copy

1. <span style="font-family:SimSun;font-size:12px;">Class.forName("com.mysql.jdbc.Driver");</span>  

3、打开一个连接

这需要使用DriverManager.getConnection()方法来创建一个Connection对象，它代表一个物理连接的数据库，如下所示：

[java]  view plain copy

1. static final String USER = "username";  
2. static final String PASS = "password";  
3. System.out.println("Connecting to database...");  
4. conn = DriverManager.getConnection(DB_URL,USER,PASS);  

4、执行一个查询

[java]  view plain copy

1.  System.out.println("Creating statement...");  
2. stmt = conn.createStatement();  
3. String sql;  
4. sql = "SELECT id, first, last, age FROM Employees";  
5. ResultSet rs = stmt.executeQuery(sql);  

如果有一个SQL UPDATE，INSERT或DELETE语句，那么需要下面的代码片段：

[java]  view plain copy

1. System.out.println("Creating statement...");  
2. stmt = conn.createStatement();  
3. String sql;  
4. sql = "DELETE FROM Employees";  
5. ResultSet rs = stmt.executeUpdate(sql);  

5、从结果中提取数据

这一步是必需的情况下，从数据库中获取数据。可以使用适当的ResultSet.getXXX()方法来检索的数据结果如下：

[java]  view plain copy

1. while(rs.next()){  
2.     //Retrieve by column name  
3.     int id  = rs.getInt("id");  
4.     int age = rs.getInt("age");  
5.     String first = rs.getString("first");  
6.     String last = rs.getString("last");  
7.   
8.     //Display values  
9.     System.out.print("ID: " + id);  
10.     System.out.print(", Age: " + age);  
11.     System.out.print(", First: " + first);  
12.     System.out.println(", Last: " + last);  
13. }  

6、清理环境

应该明确地关闭所有的数据库资源，对依赖于JVM的垃圾收集如下：

[java]  view plain copy

1. rs.close();  
2. stmt.close();  
3. conn.close();  

六、使用范例

下面的例子，简单的使用了创建数据表、插入数据、查找数据的功能：

工程目录如下：

记得加相应的包：mysql-connector-java-5.1.22-bin.jar

[java]  view plain copy

1. package com.mucfc;  
2. import java.sql.*;  
3.   
4. public class JdbcTest {  
5.     //定义数据库驱动程序  
6.     private static final String DBDRIVER="com.mysql.jdbc.Driver";  
7.     //数据库连接地址  
8.     private static final String DBURL="jdbc:mysql://localhost:3306/school";//school表示数据库  
9.     //数据库用户名  
10.     private static final String DBUSER="root";  
11.     //电脑上的数据库密码  
12.     private static final String DBPASS="christmas258@";  
13.     public void testDDL(){  
14.         try {  
15.         //1.注册驱动  
16.         Class.forName(DBDRIVER);  
17.         //2.获取连接  
18.         Connection conn = DriverManager.getConnection(DBURL,DBUSER,DBPASS);    
19.         //3.创建Statement对象  
20.         Statement stmt = conn.createStatement();        
21.         //4.准备sql语句  
22.         String sql  ="CREATE TABLE student(sid INT PRIMARY KEY,sname VARCHAR(20),age INT)";       
23.         //5.通过statement对象发送sql语句,返回执行结果  
24.         int count = stmt.executeUpdate(sql);   
25.         System.out.println("CREATE TABLE student......");  
26.         //6.打印执行结果  
27.         System.out.println("影响了"+count+"条记录");  
28.           
29.         //执行插入操作  
30.         System.out.println("Inserting records into the table...");  
31.         sql = "INSERT INTO student " +  
32.                      "VALUES (100, '小文', 18)";  
33.         stmt.executeUpdate(sql);  
34.         sql = "INSERT INTO student " +  
35.                      "VALUES (101, '大林', 25)";  
36.         stmt.executeUpdate(sql);  
37.         sql = "INSERT INTO student " +  
38.                      "VALUES (102, '阿白',  30)";  
39.         stmt.executeUpdate(sql);  
40.         sql = "INSERT INTO student " +  
41.                      "VALUES(103, '小小', 28)";  
42.         stmt.executeUpdate(sql);  
43.         System.out.println("Inserted records into the table...");  
44.           
45.         //执行查找操作  
46.         sql = "SELECT* FROM student";  
47.         System.out.println("SELECT records FROM the table...");  
48.         ResultSet rs = stmt.executeQuery(sql);  
49.        //输出查找结果  
50.         while(rs.next()){  
51.            //先获取数据  
52.            int sid  = rs.getInt("sid");         
53.            String sname = rs.getString("sname");  
54.            int age = rs.getInt("age");  
55.            //打印结果  
56.            System.out.print("sid: " + sid);  
57.            System.out.print("  sname: " +sname);  
58.            System.out.println("  age: " + age);  
59.         }  
60.         rs.close();  
61.         //7.关闭资源  
62.         try {     
63.         if(stmt!=null)  
64.         {  
65.             stmt.close();  
66.         }  
67.         } catch (Exception e) {  
68.            e.printStackTrace();  
69.         }  
70.         try {         
71.         if(conn!=null)  
72.         {      
73.             conn.close();  
74.         }  
75.         } catch (Exception e) {  
76.               
77.         }  
78.         } catch (Exception e) {  
79.              e.printStackTrace();  
80.         }  
81.           
82. }  
83.     public static void main(String[] args) {  
84.         JdbcTest jdbcTest=new JdbcTest();  
85.         jdbcTest.testDDL();  
86.   
87.     }  
88.   
89. }  

然后直接运行，输出结果如下：

从上面的例子可以看到，这个过程还是比较简单的，这里要注意的是，school数据库要存在，如果没有的话，自己在MySql按如下语句创建一个：

[sql]  view plain copy

1. CREATE DATABASE school;  

          如果要进行DQL与DDL操作，都可以把SQL语句写好，然后调用statement的executlUpdate方法来给数据库执行SQL语句，这个方法返回一个整数值，表示数据库中有多少行受到了影响。如果我们不改变上述的程序，想要再向数据库发出SQL语句，那么又要写一个程序来再次连接，操作完后又要关闭statement对象 和connection对象，这是十分繁琐的。所以，我们一般把连接过程和释放对象的过程抽取到一个工具类中。工具类中的代码如下：

[java]  view plain copy

1. package com.mucfc;  
2. import java.sql.Connection;  
3. import java.sql.DriverManager;  
4. import java.sql.SQLException;  
5. import java.sql.Statement;  
6. public class SqlDB {  
7.   
8.     //定义数据库驱动程序  
9.     private static final String DBDRIVER="com.mysql.jdbc.Driver";  
10.     //数据库连接地址  
11.     private static final String DBURL="jdbc:mysql://localhost:3306/school";//school表示数据库  
12.     //数据库用户名  
13.     private static final String DBUSER="root";  
14.     //电脑上的数据库密码  
15.     private static final String DBPASS="christmas258@";  
16.         public static Connection getconnection() {  
17.             Connection conn = null;  
18.             try {  
19.                 // 1.注册驱动  
20.                 Class.forName(DBDRIVER);  
21.                 //2.获取连接  
22.                 conn = DriverManager.getConnection(DBURL,DBUSER,DBPASS);    
23.                 //3.创建Statement对象  
24.                 Statement stmt = conn.createStatement();     
25.             } catch (Exception e) {  
26.                 e.printStackTrace();  
27.             }   
28.             return conn;  
29.   
30.         }   
31.          //7.关闭资源  
32.         public static void close(Statement statement, Connection connection) {  
33.             {  
34.                 try {  
35.                     if (statement != null)  
36.                         statement.close();  
37.                     if (connection != null) {  
38.                         connection.close();  
39.                     }  
40.                 } catch (SQLException e) {  
41.                     e.printStackTrace();  
42.                 }  
43.             }  
44.         }  
45. }  

然后我们还是要完成上面相同的事情，在JdbcTest里添加如下方法

[java]  view plain copy

1. public void CreateTableTest(){  
2.     //获取连接  
3.     Connection  cnn2=SqlDB.getconnection();  
4.        Statement statement = null;  
5.     try {  
6.         statement = cnn2.createStatement();  
7.     } catch (SQLException e) {  
8.         e.printStackTrace();  
9.     }       
10.        //准备SQL语句  
11.      String sql  ="CREATE TABLE student(sid INT PRIMARY KEY,sname VARCHAR(20),age INT)";  
12.      System.out.println("CREATE TABLE student......");  
13.        //调用executeQuery执行查询语   
14.     try {  
15.         statement.executeUpdate(sql);  
16.     } catch (SQLException e) {  
17.         // TODO Auto-generated catch block  
18.         e.printStackTrace();  
19.     }   
20.        SqlDB.close(statement,cnn2);       
21. }  
22.   
23. public void InsertTest(){  
24.     //获取连接  
25.     Connection  cnn2=SqlDB.getconnection();  
26.        Statement statement=null;  
27.     try {  
28.         statement = cnn2.createStatement();  
29.     } catch (SQLException e) {  
30.         e.printStackTrace();  
31.     }    
32.      //执行插入操作  
33.        System.out.println("Inserting records into the table...");  
34.        String sql = "INSERT INTO student " +  
35.                     "VALUES (100, '小文', 18)";  
36.        try {  
37.         statement.executeUpdate(sql);  
38.     } catch (SQLException e1) {  
39.         e1.printStackTrace();  
40.     }  
41.        sql = "INSERT INTO student " +  
42.                     "VALUES (101, '大林', 25)";  
43.        try {  
44.         statement.executeUpdate(sql);  
45.     } catch (SQLException e1) {  
46.         e1.printStackTrace();  
47.     }  
48.        sql = "INSERT INTO student " +  
49.                     "VALUES (102, '阿白',  30)";  
50.        try {  
51.         statement.executeUpdate(sql);  
52.     } catch (SQLException e1) {  
53.         e1.printStackTrace();  
54.     }  
55.        sql = "INSERT INTO student " +  
56.                     "VALUES(103, '小小', 28)";  
57.        try {  
58.         statement.executeUpdate(sql);  
59.     } catch (SQLException e1) {  
60.         e1.printStackTrace();  
61.     }  
62.        System.out.println("Inserted records into the table...");      
63.        SqlDB.close(statement, cnn2);      
64.       
65. }  
66.       
67.   
68.   
69. public void SelectTest(){  
70.     //获取连接  
71.     Connection  cnn2=SqlDB.getconnection();  
72.        Statement statement=null;  
73.     try {  
74.         statement = cnn2.createStatement();  
75.     } catch (SQLException e) {  
76.         // TODO Auto-generated catch block  
77.         e.printStackTrace();  
78.     }    
79.        //准备SQL语句  
80.        String sql = "select * from student";   
81.        //调用executeQuery执行查询语句  
82.        ResultSet res = null;  
83.     try {  
84.         res = statement.executeQuery(sql);  
85.     } catch (SQLException e) {  
86.         // TODO Auto-generated catch block  
87.         e.printStackTrace();  
88.     }    
89.        //查询结束后res会指向表头，想要获取数据必须不断地指向查询结果的下一行，当没有下一行数据时，返回0.  
90.  System.out.println("select  records from the table...");      
91.        try {  
92.         while(res.next())  
93.         {  
94.                //先获取数据  
95.                int sid  = res.getInt("sid");         
96.                String sname = res.getString("sname");  
97.                int age = res.getInt("age");  
98.                //打印结果  
99.                System.out.print("sid: " + sid);  
100.                System.out.print("  sname: " +sname);  
101.                System.out.println("  age: " + age);  
102.         }  
103.     } catch (SQLException e) {  
104.         e.printStackTrace();  
105.     }  
106.        try {  
107.         res.close();  
108.     } catch (SQLException e) {  
109.         e.printStackTrace();  
110.     }  
111.        SqlDB.close(statement, cnn2);      
112.       
113. }  

然后就是调用：

[java]  view plain copy

1. JdbcTest jdbcTest=new JdbcTest();  
2. jdbcTest.CreateTableTest();  
3. jdbcTest.InsertTest();  
4. jdbcTest.SelectTest();  

结果：

发现代码量反而增多了。。。。看来还优化得不好

想办法看是否能把创建数据库、插入数据、查找数据都入在SqlDB之中，然后我们需要时只要传入相应的参数即可，下面就来对SqlDB来进行改造：

把创建数据库、插入和查找都放到一个文件中去

[java]  view plain copy

1. package com.mucfc;  
2. import java.sql.*;  
3. /** 
4.  * 数据库操作类的一个简单封装 
5.  * @author 林炳文 
6.  * @time 2015.4.30 
7.  */  
8. public class SqlDB {  
9.   
10.     // 定义数据库驱动程序  
11.     private static final String DBDRIVER = "com.mysql.jdbc.Driver";  
12.     // 数据库连接地址  
13.     private static final String DBURL = "jdbc:mysql://localhost:3306/school";// school表示数据库  
14.     // 数据库用户名  
15.     private static final String DBUSER = "root";  
16.     // 电脑上的数据库密码  
17.     private static final String DBPASS = "christmas258@";  
18.   
19.     /** 
20.      * 创建数据库连接一初始操作 
21.      *  
22.      * @return 数据库连接的句柄 
23.      */  
24.     public static Connection getconnection() {  
25.         Connection conn = null;  
26.         try {  
27.             // 1.注册驱动  
28.             Class.forName(DBDRIVER);  
29.             // 2.获取连接  
30.             conn = DriverManager.getConnection(DBURL, DBUSER, DBPASS);  
31.             // 3.创建Statement对象  
32.             Statement stmt = conn.createStatement();  
33.         } catch (Exception e) {  
34.             e.printStackTrace();  
35.         }  
36.         return conn;  
37.   
38.     }  
39.   
40.     /** 
41.      * 关闭资源 
42.      * @param statement为执行命令的实例，connection为连接对象          
43.      */  
44.     public static void close(Statement statement, Connection connection) {  
45.         {  
46.             try {  
47.                 if (statement != null)  
48.                     statement.close();  
49.                 if (connection != null) {  
50.                     connection.close();  
51.                 }  
52.             } catch (SQLException e) {  
53.                 e.printStackTrace();  
54.             }  
55.         }  
56.     }  
57.     /** 
58.      * 创建一个数据库表，注意这里的表要事先存在的    
59.      */  
60.     public void CreatTable() {  
61.         // 1.获取连接  
62.         Connection connection = SqlDB.getconnection();  
63.         // 2.准备sql语句  
64.         String sql = "CREATE TABLE student(sid INT PRIMARY KEY,sname VARCHAR(20),age INT)";  
65.         PreparedStatement preparedStatement = null;  
66.         // 3.获得对象  
67.         try {  
68.             preparedStatement = connection.prepareStatement(sql);  
69.         } catch (SQLException e) {  
70.             e.printStackTrace();  
71.         }  
72.         // 4.交给数据库执行SQL  
73.         int num = 0;  
74.         try {  
75.             num = preparedStatement.executeUpdate();  
76.         } catch (SQLException e) {  
77.             e.printStackTrace();  
78.         }  
79.         System.out.println("有" + num + "条记录受到了影响");  
80.         SqlDB.close(preparedStatement, connection);  
81.     }  
82.     /** 
83.      * 执行插入操作 
84.      * @param 相应的参数     
85.      */  
86.     public void InsertData(int id, String name, int age) {  
87.         // 1.获取连接  
88.         Connection connection = SqlDB.getconnection();  
89.         // 2.准备sql语句  
90.         String sql = "INSERT INTO student VALUES(?,?,?)";  
91.         PreparedStatement preparedStatement = null;  
92.         // 3.获得对象  
93.         try {  
94.             preparedStatement = connection.prepareStatement(sql);  
95.         } catch (SQLException e) {  
96.             e.printStackTrace();  
97.         }  
98.         // 4.设置SQL参数 需要参数是第几个，并且知道它的类型 下面第一句表示：SQL语句第一个参数是int类型，参数值设置为id，如此类推  
99.         try {  
100.             preparedStatement.setInt(1, id);  
101.             preparedStatement.setString(2, name);  
102.             preparedStatement.setInt(3, age);  
103.         } catch (SQLException e1) {  
104.             e1.printStackTrace();  
105.         }  
106.         // 5.交给数据库执行SQL  
107.         int num = 0;  
108.         try {  
109.             num = preparedStatement.executeUpdate();  
110.         } catch (SQLException e) {  
111.             e.printStackTrace();  
112.         }  
113.         System.out.println("有" + num + "条记录受到了影响");  
114.         SqlDB.close(preparedStatement, connection);  
115.   
116.     }  
117.     /** 
118.      * 执行查找操作 
119.      * @param id 学生编号     
120.      */  
121.     public void SelectDataWithId(int id) {  
122.         // 1.获取连接  
123.         Connection connection = SqlDB.getconnection();  
124.         // 2.准备sql语句  
125.         String sql = "SELECT* FROM student where sid=?";  
126.         PreparedStatement preparedStatement = null;  
127.         ResultSet res = null;  
128.         // 3.获得对象  
129.         try {  
130.             preparedStatement = connection.prepareStatement(sql);  
131.         } catch (SQLException e) {  
132.             e.printStackTrace();  
133.         }  
134.         /* 
135.          * 4.设置SQL参数 需要参数是第几个，并且知道它的类型 下面第一句表示：SQL语句第一个参数是int类型，参数值设置为id，如此类推 
136.          */  
137.         try {  
138.             preparedStatement.setInt(1, id);  
139.         } catch (SQLException e1) {  
140.             e1.printStackTrace();  
141.         }  
142.         // 5.交给数据库执行SQL  
143.         try {  
144.             res = preparedStatement.executeQuery();  
145.             while (res.next()) {  
146.                 // 先获取数据  
147.                 int sid = res.getInt("sid");  
148.                 String sname = res.getString("sname");  
149.                 int age = res.getInt("age");  
150.                 // 打印结果  
151.                 System.out.print("sid: " + sid);  
152.                 System.out.print("  sname: " + sname);  
153.                 System.out.println("  age: " + age);  
154.             }  
155.         } catch (SQLException e1) {  
156.             e1.printStackTrace();  
157.         }  
158.         SqlDB.close(preparedStatement, connection);  
159.     }  
160. }  

然后有需要时，直接使用：

[java]  view plain copy

1.             SqlDB sqlDB=new SqlDB();  
2. sqlDB.CreatTable();  
3. sqlDB.InsertData(309, "小红",12);  
4. sqlDB.InsertData(33, "小灰",34);  
5. sqlDB.InsertData(23, "阿大",145);  
6.    sqlDB.SelectDataWithId(33);  

在这里，我们使用了PreparedStatement来进行数据库操作，下面说说它们的区别

Statement 与 PreparedStatement的区别：

1.语法不同

Statement只支持静态编译，SQL语句是写死的。

PreparedStatement支持预编译，用？号来占位。

2.效率不同

Statement每次都要发送一条SQL语句，不支持缓存，执行效率低。

PreparedStatement支持预编译，缓存在数据库，只需发送参数，执行效率快。

3.安全性不同

Statement容易被注入。

注入：狡猾的分子可以编写特殊的SQL语句来入侵数据库。

例如：要查询某个用户的信息

一般情况：SELECT * FROM user_list where username=xxx and password=xxx;(这里的xxx本应为用户填写自己的用户名和密码)

注入情况：SELECT * FROM user_list where username='abc' or 1=1 -- password=xxx;

这样1=1恒等，而且在password前加上了“--”号，后面的内容成为了注释不被执行。也就是说，这样就能不用密码地查询所有的用户信息。

PreparedStatement，因为规定了SQL语句中的参数，所以可以防止注入。

结论：建议使用PreparedStatement，因为它更快更安全。

七、JDBC用法小结

DriverManger:驱动管理器类
要操作数据库，必须先与数据库创建连接，得到连接对象
public static Connection getConnection(String url, String username,String password){}

Connection:连接接口：
通过DriverManger类的getConnection方法，将获得连接对象，执行sql语句必须借助语句对象(Statement)
Statement createStatement();

Statement:语句接口
通过连接对象的createStatement方法获得语句对象后，语句对象即可执行sql语句，Statement中提供了executeUpdate、executeQuery语句，分别执行不同的sql语句
int executeUpdate(String sql):执行增删改操作的语句，返回值为操作的总行数
ResultSet executeQuery(String sql)：执行查询语句，返回值为查询结果集合

ResultSet：结果集接口
boolean next()：该方法可以使结果集游标向下移动，如果仍有记录返回true，如果已经遍历结束，返回false

getXXX(String columnName):该系列方法用来根据字段名返回字段的值结果集接口里面有大量的getXXX(String columnName)方法，如getString，getInt等

getXXX(int index)：该系列方法用来根据字段在结果集中的索引值返回字段的值，结果集中有大量的getXXX方法，与 上面的类似，用来根据索引值，获取该字段的值，XXX是该字段的数据类型。

JDBC语句对象：
Statement:如上 stmt = conn.createStatement();
PrepareStatement:称为预编译的语句对象，是Statement的子接口 stmt = conn.prepareStatement(String sql),和Statement的不同之处

林炳文Evankaka原创作品。转载请注明出处http://blog.youkuaiyun.com/evankaka