java（JDBC连接数据库）[完整版封装]

1. import java.sql.CallableStatement;  
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.  * 数据库连接类 
14.  * 说明:封装了 无参，有参，存储过程的调用 
15.  * @author iflytek 
16.  * 
17.  */  
18. public class ConnectionDB {  
19.   
20.     /** 
21.      * 数据库驱动类名称 
22.      */  
23.     private static final String DRIVER = "com.microsoft.sqlserver.jdbc.SQLServerDriver";  
24.   
25.     /** 
26.      * 连接字符串 
27.      */  
28.     private static final String URLSTR = "jdbc:sqlserver://localhost:1433; databaseName=Northwind";  
29.   
30.     /** 
31.      * 用户名 
32.      */  
33.     private static final String USERNAME = "sa";  
34.   
35.     /** 
36.      * 密码 
37.      */  
38.     private static final String USERPASSWORD = "111111";  
39.   
40.     /** 
41.      * 创建数据库连接对象 
42.      */  
43.     private Connection connnection = null;  
44.   
45.     /** 
46.      * 创建PreparedStatement对象 
47.      */  
48.     private PreparedStatement preparedStatement = null;  
49.       
50.     /** 
51.      * 创建CallableStatement对象 
52.      */  
53.     private CallableStatement callableStatement = null;  
54.   
55.     /** 
56.      * 创建结果集对象 
57.      */  
58.     private ResultSet resultSet = null;  
59.   
60.     static {  
61.         try {  
62.             // 加载数据库驱动程序  
63.             Class.forName(DRIVER);  
64.         } catch (ClassNotFoundException e) {  
65.             System.out.println("加载驱动错误");  
66.             System.out.println(e.getMessage());  
67.         }  
68.     }  
69.   
70.     /** 
71.      * 建立数据库连接 
72.      * @return 数据库连接 
73.      */  
74.     public Connection getConnection() {  
75.         try {  
76.             // 获取连接  
77.             connnection = DriverManager.getConnection(URLSTR, USERNAME,  
78.                     USERPASSWORD);  
79.         } catch (SQLException e) {  
80.             System.out.println(e.getMessage());  
81.         }  
82.         return connnection;  
83.     }  
84.   
85.     /** 
86.      * insert update delete SQL语句的执行的统一方法 
87.      * @param sql SQL语句 
88.      * @param params 参数数组，若没有参数则为null 
89.      * @return 受影响的行数 
90.      */  
91.     public int executeUpdate(String sql, Object[] params) {  
92.         // 受影响的行数  
93.         int affectedLine = 0;  
94.           
95.         try {  
96.             // 获得连接  
97.             connnection = this.getConnection();  
98.             // 调用SQL   
99.             preparedStatement = connnection.prepareStatement(sql);  
100.               
101.             // 参数赋值  
102.             if (params != null) {  
103.                 for (int i = 0; i < params.length; i++) {  
104.                     preparedStatement.setObject(i + 1, params[i]);  
105.                 }  
106.             }  
107.               
108.             // 执行  
109.             affectedLine = preparedStatement.executeUpdate();  
110.   
111.         } catch (SQLException e) {  
112.             System.out.println(e.getMessage());  
113.         } finally {  
114.             // 释放资源  
115.             closeAll();  
116.         }  
117.         return affectedLine;  
118.     }  
119.   
120.     /** 
121.      * SQL 查询将查询结果直接放入ResultSet中 
122.      * @param sql SQL语句 
123.      * @param params 参数数组，若没有参数则为null 
124.      * @return 结果集 
125.      */  
126.     private ResultSet executeQueryRS(String sql, Object[] params) {  
127.         try {  
128.             // 获得连接  
129.             connnection = this.getConnection();  
130.               
131.             // 调用SQL  
132.             preparedStatement = connnection.prepareStatement(sql);  
133.               
134.             // 参数赋值  
135.             if (params != null) {  
136.                 for (int i = 0; i < params.length; i++) {  
137.                     preparedStatement.setObject(i + 1, params[i]);  
138.                 }  
139.             }  
140.               
141.             // 执行  
142.             resultSet = preparedStatement.executeQuery();  
143.   
144.         } catch (SQLException e) {  
145.             System.out.println(e.getMessage());  
146.         }  
147.   
148.         return resultSet;  
149.     }  
150.   
151.     /** 
152.      * 获取结果集，并将结果放在List中 
153.      *  
154.      * @param sql 
155.      *            SQL语句 
156.      * @return List 
157.      *                       结果集 
158.      */  
159.     public List<Object> excuteQuery(String sql, Object[] params) {  
160.         // 执行SQL获得结果集  
161.         ResultSet rs = executeQueryRS(sql, params);  
162.           
163.         // 创建ResultSetMetaData对象  
164.         ResultSetMetaData rsmd = null;  
165.           
166.         // 结果集列数  
167.         int columnCount = 0;  
168.         try {  
169.             rsmd = rs.getMetaData();  
170.               
171.             // 获得结果集列数  
172.             columnCount = rsmd.getColumnCount();  
173.         } catch (SQLException e1) {  
174.             System.out.println(e1.getMessage());  
175.         }  
176.   
177.         // 创建List  
178.         List<Object> list = new ArrayList<Object>();  
179.   
180.         try {  
181.             // 将ResultSet的结果保存到List中  
182.             while (rs.next()) {  
183.                 Map<String, Object> map = new HashMap<String, Object>();  
184.                 for (int i = 1; i <= columnCount; i++) {  
185.                     map.put(rsmd.getColumnLabel(i), rs.getObject(i));  
186.                 }  
187.                 list.add(map);  
188.             }  
189.         } catch (SQLException e) {  
190.             System.out.println(e.getMessage());  
191.         } finally {  
192.             // 关闭所有资源  
193.             closeAll();  
194.         }  
195.   
196.         return list;  
197.     }  
198.       
199.     /** 
200.      * 存储过程带有一个输出参数的方法 
201.      * @param sql 存储过程语句 
202.      * @param params 参数数组 
203.      * @param outParamPos 输出参数位置 
204.      * @param SqlType 输出参数类型 
205.      * @return 输出参数的值 
206.      */  
207.     public Object excuteQuery(String sql, Object[] params,int outParamPos, int SqlType) {  
208.         Object object = null;  
209.         connnection = this.getConnection();  
210.         try {  
211.             // 调用存储过程  
212.             callableStatement = connnection.prepareCall(sql);  
213.               
214.             // 给参数赋值  
215.             if(params != null) {  
216.                 for(int i = 0; i < params.length; i++) {  
217.                     callableStatement.setObject(i + 1, params[i]);  
218.                 }  
219.             }  
220.               
221.             // 注册输出参数  
222.             callableStatement.registerOutParameter(outParamPos, SqlType);  
223.               
224.             // 执行  
225.             callableStatement.execute();  
226.               
227.             // 得到输出参数  
228.             object = callableStatement.getObject(outParamPos);  
229.               
230.         } catch (SQLException e) {  
231.             System.out.println(e.getMessage());  
232.         } finally {  
233.             // 释放资源  
234.             closeAll();  
235.         }  
236.           
237.         return object;  
238.     }  
239.   
240.     /** 
241.      * 关闭所有资源 
242.      */  
243.     private void closeAll() {  
244.         // 关闭结果集对象  
245.         if (resultSet != null) {  
246.             try {  
247.                 resultSet.close();  
248.             } catch (SQLException e) {  
249.                 System.out.println(e.getMessage());  
250.             }  
251.         }  
252.   
253.         // 关闭PreparedStatement对象  
254.         if (preparedStatement != null) {  
255.             try {  
256.                 preparedStatement.close();  
257.             } catch (SQLException e) {  
258.                 System.out.println(e.getMessage());  
259.             }  
260.         }  
261.           
262.         // 关闭CallableStatement 对象  
263.         if (callableStatement != null) {  
264.             try {  
265.                 callableStatement.close();  
266.             } catch (SQLException e) {  
267.                 System.out.println(e.getMessage());  
268.             }  
269.         }  
270.   
271.         // 关闭Connection 对象  
272.         if (connnection != null) {  
273.             try {  
274.                 connnection.close();  
275.             } catch (SQLException e) {  
276.                 System.out.println(e.getMessage());  
277.             }  
278.         }     
279.     }  
280. }  

---------------------------------------------------------------------------略微修改后的版本（加了返回结果集一行一列的方法）-----------------------

1. import java.sql.CallableStatement;  
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.  * 数据库连接类 
14.  * 说明:封装了 无参，有参，存储过程的调用 
15.  * @author iflytek 
16.  * 
17.  */  
18. public class ConnectionDB {  
19.   
20.     /** 
21.      * 数据库驱动类名称 
22.      */  
23.     private static final String DRIVER = "com.microsoft.sqlserver.jdbc.SQLServerDriver";  
24.   
25.     /** 
26.      * 连接字符串 
27.      */  
28.     private static final String URLSTR = "jdbc:sqlserver://localhost:1433; databaseName=Northwind";  
29.   
30.     /** 
31.      * 用户名 
32.      */  
33.     private static final String USERNAME = "sa";  
34.   
35.     /** 
36.      * 密码 
37.      */  
38.     private static final String USERPASSWORD = "111111";  
39.   
40.     /** 
41.      * 创建数据库连接对象 
42.      */  
43.     private Connection connnection = null;  
44.   
45.     /** 
46.      * 创建PreparedStatement对象 
47.      */  
48.     private PreparedStatement preparedStatement = null;  
49.       
50.     /** 
51.      * 创建CallableStatement对象 
52.      */  
53.     private CallableStatement callableStatement = null;  
54.   
55.     /** 
56.      * 创建结果集对象 
57.      */  
58.     private ResultSet resultSet = null;  
59.   
60.     static {  
61.         try {  
62.             // 加载数据库驱动程序  
63.             Class.forName(DRIVER);  
64.         } catch (ClassNotFoundException e) {  
65.             System.out.println("加载驱动错误");  
66.             System.out.println(e.getMessage());  
67.         }  
68.     }  
69.   
70.     /** 
71.      * 建立数据库连接 
72.      * @return 数据库连接 
73.      */  
74.     public Connection getConnection() {  
75.         try {  
76.             // 获取连接  
77.             connnection = DriverManager.getConnection(URLSTR, USERNAME,  
78.                     USERPASSWORD);  
79.         } catch (SQLException e) {  
80.             System.out.println(e.getMessage());  
81.         }  
82.         return connnection;  
83.     }  
84.   
85.     /** 
86.      * insert update delete SQL语句的执行的统一方法 
87.      * @param sql SQL语句 
88.      * @param params 参数数组，若没有参数则为null 
89.      * @return 受影响的行数 
90.      */  
91.     public int executeUpdate(String sql, Object[] params) {  
92.         // 受影响的行数  
93.         int affectedLine = 0;  
94.           
95.         try {  
96.             // 获得连接  
97.             connnection = this.getConnection();  
98.             // 调用SQL   
99.             preparedStatement = connnection.prepareStatement(sql);  
100.               
101.             // 参数赋值  
102.             if (params != null) {  
103.                 for (int i = 0; i < params.length; i++) {  
104.                     preparedStatement.setObject(i + 1, params[i]);  
105.                 }  
106.             }  
107.               
108.             // 执行  
109.             affectedLine = preparedStatement.executeUpdate();  
110.   
111.         } catch (SQLException e) {  
112.             System.out.println(e.getMessage());  
113.         } finally {  
114.             // 释放资源  
115.             closeAll();  
116.         }  
117.         return affectedLine;  
118.     }  
119.   
120.     /** 
121.      * SQL 查询将查询结果直接放入ResultSet中 
122.      * @param sql SQL语句 
123.      * @param params 参数数组，若没有参数则为null 
124.      * @return 结果集 
125.      */  
126.     private ResultSet executeQueryRS(String sql, Object[] params) {  
127.         try {  
128.             // 获得连接  
129.             connnection = this.getConnection();  
130.               
131.             // 调用SQL  
132.             preparedStatement = connnection.prepareStatement(sql);  
133.               
134.             // 参数赋值  
135.             if (params != null) {  
136.                 for (int i = 0; i < params.length; i++) {  
137.                     preparedStatement.setObject(i + 1, params[i]);  
138.                 }  
139.             }  
140.               
141.             // 执行  
142.             resultSet = preparedStatement.executeQuery();  
143.   
144.         } catch (SQLException e) {  
145.             System.out.println(e.getMessage());  
146.         }   
147.   
148.         return resultSet;  
149.     }  
150.       
151.     /** 
152.      * SQL 查询将查询结果：一行一列 
153.      * @param sql SQL语句 
154.      * @param params 参数数组，若没有参数则为null 
155.      * @return 结果集 
156.      */  
157.     public Object executeQuerySingle(String sql, Object[] params) {  
158.         Object object = null;  
159.         try {  
160.             // 获得连接  
161.             connnection = this.getConnection();  
162.               
163.             // 调用SQL  
164.             preparedStatement = connnection.prepareStatement(sql);  
165.               
166.             // 参数赋值  
167.             if (params != null) {  
168.                 for (int i = 0; i < params.length; i++) {  
169.                     preparedStatement.setObject(i + 1, params[i]);  
170.                 }  
171.             }  
172.               
173.             // 执行  
174.             resultSet = preparedStatement.executeQuery();  
175.   
176.             if(resultSet.next()) {  
177.                 object = resultSet.getObject(1);  
178.             }  
179.               
180.         } catch (SQLException e) {  
181.             System.out.println(e.getMessage());  
182.         } finally {  
183.             closeAll();  
184.         }  
185.   
186.         return object;  
187.     }  
188.   
189.     /** 
190.      * 获取结果集，并将结果放在List中 
191.      *  
192.      * @param sql 
193.      *            SQL语句 
194.      * @return List 
195.      *                       结果集 
196.      */  
197.     public List<Object> excuteQuery(String sql, Object[] params) {  
198.         // 执行SQL获得结果集  
199.         ResultSet rs = executeQueryRS(sql, params);  
200.           
201.         // 创建ResultSetMetaData对象  
202.         ResultSetMetaData rsmd = null;  
203.           
204.         // 结果集列数  
205.         int columnCount = 0;  
206.         try {  
207.             rsmd = rs.getMetaData();  
208.               
209.             // 获得结果集列数  
210.             columnCount = rsmd.getColumnCount();  
211.         } catch (SQLException e1) {  
212.             System.out.println(e1.getMessage());  
213.         }  
214.   
215.         // 创建List  
216.         List<Object> list = new ArrayList<Object>();  
217.   
218.         try {  
219.             // 将ResultSet的结果保存到List中  
220.             while (rs.next()) {  
221.                 Map<String, Object> map = new HashMap<String, Object>();  
222.                 for (int i = 1; i <= columnCount; i++) {  
223.                     map.put(rsmd.getColumnLabel(i), rs.getObject(i));  
224.                 }  
225.                 list.add(map);  
226.             }  
227.         } catch (SQLException e) {  
228.             System.out.println(e.getMessage());  
229.         } finally {  
230.             // 关闭所有资源  
231.             closeAll();  
232.         }  
233.   
234.         return list;  
235.     }  
236.       
237.     /** 
238.      * 存储过程带有一个输出参数的方法 
239.      * @param sql 存储过程语句 
240.      * @param params 参数数组 
241.      * @param outParamPos 输出参数位置 
242.      * @param SqlType 输出参数类型 
243.      * @return 输出参数的值 
244.      */  
245.     public Object excuteQuery(String sql, Object[] params,int outParamPos, int SqlType) {  
246.         Object object = null;  
247.         connnection = this.getConnection();  
248.         try {  
249.             // 调用存储过程  
250.             callableStatement = connnection.prepareCall(sql);  
251.               
252.             // 给参数赋值  
253.             if(params != null) {  
254.                 for(int i = 0; i < params.length; i++) {  
255.                     callableStatement.setObject(i + 1, params[i]);  
256.                 }  
257.             }  
258.               
259.             // 注册输出参数  
260.             callableStatement.registerOutParameter(outParamPos, SqlType);  
261.               
262.             // 执行  
263.             callableStatement.execute();  
264.               
265.             // 得到输出参数  
266.             object = callableStatement.getObject(outParamPos);  
267.               
268.         } catch (SQLException e) {  
269.             System.out.println(e.getMessage());  
270.         } finally {  
271.             // 释放资源  
272.             closeAll();  
273.         }  
274.           
275.         return object;  
276.     }  
277.   
278.     /** 
279.      * 关闭所有资源 
280.      */  
281.     private void closeAll() {  
282.         // 关闭结果集对象  
283.         if (resultSet != null) {  
284.             try {  
285.                 resultSet.close();  
286.             } catch (SQLException e) {  
287.                 System.out.println(e.getMessage());  
288.             }  
289.         }  
290.   
291.         // 关闭PreparedStatement对象  
292.         if (preparedStatement != null) {  
293.             try {  
294.                 preparedStatement.close();  
295.             } catch (SQLException e) {  
296.                 System.out.println(e.getMessage());  
297.             }  
298.         }  
299.           
300.         // 关闭CallableStatement 对象  
301.         if (callableStatement != null) {  
302.             try {  
303.                 callableStatement.close();  
304.             } catch (SQLException e) {  
305.                 System.out.println(e.getMessage());  
306.             }  
307.         }  
308.   
309.         // 关闭Connection 对象  
310.         if (connnection != null) {  
311.             try {  
312.                 connnection.close();  
313.             } catch (SQLException e) {  
314.                 System.out.println(e.getMessage());  
315.             }  
316.         }     
317.     }  
318. }