数据库：JDBC编程

From:http://blog.youkuaiyun.com/leelit/article/details/41044187

    JDBC（Java Data Base Connectivity,Java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。说白了，它用于直接调用 SQL 命令。

主要步骤：

1.加载JDBC驱动程序    
2.建立于数据库的连接   
3.创建一个Statement，添加相关参数
4.执行SQL语句
5.处理执行结果
6.关闭JDBC的对象

几个重要的类：
（1）
public class DriverManager extends Object
管理一组 JDBC 驱动程序的基本服务。
主要方法是：
public static Connection getConnection(String url,String user,String password)throws SQLException
试图建立到给定数据库 URL 的连接。DriverManager 试图从已注册的 JDBC 驱动程序集中选择一个适当的驱动程序。

（2）
public interface PreparedStatement extends Statement
表示预编译的 SQL 语句的对象。 SQL 语句被预编译并存储在PreparedStatement对象中。然后可以使用此对象多次高效地执行该语句。 与Statement接口相比，Statement用于执行静态 SQL 语句并返回它所生成结果的对象。 
主要方法是：
1. void setObject(int parameterIndex,Object x) throws SQLException
使用给定对象设置指定参数的值，其实就是为SQL语句占位符的设定实际参数。

2. intexecuteUpdate() throws SQLException

在此 PreparedStatement 对象中执行 SQL 语句，该语句必须是一个 SQL 数据操作语言（Data Manipulation Language，DML）语句，比如 INSERT、UPDATE 或 DELETE 语句；或者是无返回内容的 SQL 语句，比如 DDL 语句。 
返回：
(1) SQL 数据操作语言 (DML) 语句的行数 (2) 对于无返回内容的 SQL 语句，返回 0 

3. ResultSet executeQuery() throws SQLException
在此 PreparedStatement 对象中执行 SQL 查询，并返回该查询生成的 ResultSet 对象。 
返回：
包含该查询生成的数据的 ResultSet 对象；不会返回 null

（3）
留意执行executeUpdate()和executeQuery()方法返回的值发现executeQuery()返回的是一个结果集对象。
public interface ResultSet extends Wrapper
表示数据库结果集的数据表，通常通过执行查询数据库的语句生成。

主要方法是：
1. ResultSetMetaData getMetaData() throws SQLException

获取此ResultSet对象的列的编号、类型和属性。 
而ResultSetMetaData的主要方法就是 int getColumnCount() 返回此 ResultSet 对象中的列数；  String getColumnName(int column) 获取指定列的名称。  

2. Object getObject(int columnIndex) throws SQLException

以 Java 编程语言中 Object 的形式获取此 ResultSet 对象的当前行中指定列的值。 

实例一：MySQL+JDBC

Windows用户可以再http://dev.mysql.com/downloads/windows/installer/下载MySql的自动配置安装版

使用Navicat作为MySql的数据库管理工具

另外还需要下载JDBC驱动程序http://dev.mysql.com/downloads/connector/j/，工程需要引用里面的jar包

①新建一个工具类JdbcUtils

[java]  view plain  copy

1. import java.lang.reflect.Field;  
2. import java.sql.Connection;  
3. import java.sql.DriverManager;  
4. import java.sql.PreparedStatement;  
5. import java.sql.ResultSet;  
6. import java.sql.ResultSetMetaData;  
7. import java.sql.SQLException;  
8. import java.util.ArrayList;  
9. import java.util.HashMap;  
10. import java.util.List;  
11. import java.util.Map;  
12.   
13. public class JdbcUtils {  
14.     // 数据库的登陆账号密码  
15.     private final String USERNAME = "root";  
16.     private final String PASSWORD = "123456";  
17.     // JDBC驱动程序  
18.     private final String DRIVER = "com.mysql.jdbc.Driver";  
19.     // 数据库地址  
20.     private final String URL = "jdbc:mysql://localhost:3306/test";  
21.   
22.     // 三个重要类的对象  
23.     private Connection connection;  
24.     private PreparedStatement ps;  
25.     private ResultSet resultSet;  
26.   
27.     public JdbcUtils() {  
28.         try {  
29.             // 步骤1：加载驱动程序  
30.             Class.forName(DRIVER);  
31.             // 步骤2：建立连接，这里的处理是当实例化这个工具类对象时就完成这两个步骤  
32.             connection = DriverManager.getConnection(URL, USERNAME, PASSWORD);  
33.         } catch (ClassNotFoundException e) {  
34.             // TODO 自动生成的 catch 块  
35.             e.printStackTrace();  
36.         } catch (SQLException e) {  
37.             // TODO 自动生成的 catch 块  
38.             e.printStackTrace();  
39.         }  
40.     }  
41.   
42.     // 封装的update函数  
43.     public int update(String sql, List<Object> params) throws SQLException {  
44.         int result = 0;  
45.         // 步骤3：创建一个Statement，添加相关参数  
46.         ps = connection.prepareStatement(sql);  
47.         if (params != null && !params.isEmpty()) {  
48.             for (int i = 0; i < params.size(); i++)  
49.                 // 注意数据库的下标都是从1开始的，第i个占位符填充params的第i个值  
50.                 ps.setObject(i + 1, params.get(i));  
51.         }  
52.         // 步骤4：执行SQL语句，步骤5和6则留给客户端处理  
53.         result = ps.executeUpdate();  
54.         return result;  
55.     }  
56.   
57.     // 封装的query函数，返回的是List套个Map，数据库是以键值对的形式存储的  
58.     public List<Map<String, Object>> query(String sql, List<Object> params)  
59.             throws SQLException {  
60.         List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();  
61.         // 步骤3：创建一个Statement，添加相关参数  
62.         ps = connection.prepareStatement(sql);  
63.         if (params != null && !params.isEmpty()) {  
64.             for (int i = 0; i < params.size(); i++)  
65.                 ps.setObject(i + 1, params.get(i));  
66.         }  
67.         // 步骤4：执行SQL语句  
68.         resultSet = ps.executeQuery();  
69.         // 步骤5：处理执行结果  
70.         // 获取此ResultSet对象的列的属性  
71.         ResultSetMetaData metaData = resultSet.getMetaData();  
72.         // 列的长度  
73.         int col_len = metaData.getColumnCount();  
74.         // 若有下一条记录  
75.         while (resultSet.next()) {  
76.             // 将该条记录以map形式存储  
77.             Map<String, Object> map = new HashMap<String, Object>();  
78.             for (int i = 0; i < col_len; i++) {  
79.                 // 根据列名获得键值并存放在map中  
80.                 String col_name = metaData.getColumnName(i + 1);  
81.                 Object col_value = resultSet.getObject(col_name);  
82.                 map.put(col_name, col_value);  
83.             }  
84.             // 将该记录添加到list中  
85.             list.add(map);  
86.         }  
87.         // 遍历完resultSet返回list  
88.         return list;  
89.     }  
90.   
91.     // 封装步骤6关闭JDBC对象  
92.     public void release() {  
93.         if (resultSet != null)  
94.             try {  
95.                 resultSet.close();  
96.             } catch (SQLException e) {  
97.                 // TODO 自动生成的 catch 块  
98.                 e.printStackTrace();  
99.             }  
100.         if (ps != null)  
101.             try {  
102.                 ps.close();  
103.             } catch (SQLException e) {  
104.                 // TODO 自动生成的 catch 块  
105.                 e.printStackTrace();  
106.             }  
107.         if (connection != null)  
108.             try {  
109.                 connection.close();  
110.             } catch (SQLException e) {  
111.                 // TODO 自动生成的 catch 块  
112.                 e.printStackTrace();  
113.             }  
114.     }  
115. }  

②TestMain类

[java]  view plain  copy

1. import java.sql.SQLException;  
2. import java.util.ArrayList;  
3. import java.util.List;  
4. import java.util.Map;  
5.   
6. public class TestMain {  
7.   
8.     public static void main(String[] args) {  
9.         // TODO 自动生成的方法存根  
10.         JdbcUtils jdbcUtils = new JdbcUtils();  
11.         /*执行一:新建表*/  
12.         // String sql0 =  
13.         // "create table userinfo(id int primary key auto_increment, username varchar(64), password varchar(64))";  
14.         // try {  
15.         // jdbcUtils.update(sql0, null);  
16.         // } catch (SQLException e) {  
17.         // // TODO 自动生成的 catch 块  
18.         // e.printStackTrace();  
19.         // }  
20.           
21.         /*执行二：增加一条记录*/  
22.         // String sql = "insert into userinfo (username,password) values(?,?)";  
23.         // List<Object> params = new ArrayList<Object>();  
24.         // params.add("jack");  
25.         // params.add("123456");  
26.         // try {  
27.         // jdbcUtils.update(sql, params);  
28.         // } catch (SQLException e) {  
29.         // // TODO 自动生成的 catch 块  
30.         // e.printStackTrace();  
31.         // }  
32.           
33.         /*执行三：修改一条记录*/  
34.         // String sql1 = "update userinfo set username = ? where id = ?";  
35.         // List<Object> param1 = new ArrayList<Object>();  
36.         // param1.add("tommy");  
37.         // param1.add(2);  
38.         // try {  
39.         // jdbcUtils.update(sql1, param1);  
40.         // } catch (SQLException e) {  
41.         // // TODO 自动生成的 catch 块  
42.         // e.printStackTrace();  
43.         // }  
44.           
45.         /*执行四：删除一条记录*/  
46.         // String sql2 = "delete from userinfo where username = 'tommy'";  
47.         // try {  
48.         // jdbcUtils.update(sql2, null);  
49.         // } catch (SQLException e) {  
50.         // // TODO 自动生成的 catch 块  
51.         // e.printStackTrace();  
52.         // }  
53.   
54.         /*执行五：查询所有记录*/  
55.         // String sql3 = "select * from userinfo";  
56.         // try {  
57.         // List<Map<String, Object>> list = jdbcUtils.query(sql3, null);  
58.         // System.out.println(list);  
59.         // } catch (SQLException e) {  
60.         // // TODO 自动生成的 catch 块  
61.         // e.printStackTrace();  
62.         // }  
63.     }  
64.   
65. }  

执行步骤一：创建一个新的表（以下说的执行步骤没有说明的话都是指单独执行，其他步骤都注释掉）

执行步骤二：创建一个表，有三个字段，id是主键

连续执行步骤三两次：增加两条记录

执行步骤四：将第二条记录修改

执行步骤五：删除第二条记录

执行步骤六：查询到一条记录

再次执行步骤一和步骤五：查询到多条记录

实例二：应用反射机制来实现查询数据库记录

①新建一个和数据库字段匹配的类UserInfo

[java]  view plain  copy

1. public class UserInfo {  
2.     private int id;  
3.     private String username;  
4.     private String password;  
5.   
6.     public int getId() {  
7.         return id;  
8.     }  
9.   
10.     public void setId(int id) {  
11.         this.id = id;  
12.     }  
13.   
14.     public String getUsername() {  
15.         return username;  
16.     }  
17.   
18.     public void setUsername(String username) {  
19.         this.username = username;  
20.     }  
21.   
22.     public String getPassword() {  
23.         return password;  
24.     }  
25.   
26.     public void setPassword(String password) {  
27.         this.password = password;  
28.     }  
29.   
30.     @Override  
31.     public String toString() {  
32.         return "UserInfo [id=" + id + ", username=" + username + ", password="  
33.                 + password + "]";  
34.     }  
35.   
36. }  

②在JdbcUtils类中添加一个应用反射机制的数据库查询函数

[java]  view plain  copy

1. public <T> List<T> queryRef(String sql, List<Object> params, Class<T> cls)  
2.         throws Exception {  
3.     List<T> list = new ArrayList<>();  
4.     ps = connection.prepareStatement(sql);  
5.     if (params != null && !params.isEmpty()) {  
6.         for (int i = 0; i < params.size(); i++)  
7.             ps.setObject(i + 1, params.get(i));  
8.     }  
9.     resultSet = ps.executeQuery();  
10.     ResultSetMetaData metaData = resultSet.getMetaData();  
11.     int col_len = metaData.getColumnCount();  
12.     while (resultSet.next()) {  
13.         // 存在记录时，实例化一个对象  
14.         T record = cls.newInstance();  
15.         for (int i = 0; i < col_len; i++) {  
16.             String col_name = metaData.getColumnName(i + 1);  
17.             Object col_value = resultSet.getObject(col_name);  
18.             // 将列对应的值赋给对象的相应字段  
19.             Field field = cls.getDeclaredField(col_name);  
20.             field.setAccessible(true);  
21.             field.set(record, col_value);  
22.         }  
23.         // 将这条记录添加到List中  
24.         list.add(record);  
25.     }  
26.     return list;  
27. }  

③TestMain类，添加一个执行操作

[java]  view plain  copy

1. /*执行六：反射机制查询记录*/  
2. String sqlQuery = "select * from userinfo";  
3. try {  
4.     List<UserInfo> list = jdbcUtils.queryRef(sqlQuery, null,  
5.             UserInfo.class);  
6.     System.out.println(list);  
7. } catch (Exception e) {  
8.     // TODO 自动生成的 catch 块  
9.     e.printStackTrace();  
10. } finally {  
11.     jdbcUtils.release();  
12. }  

执行步骤六