浅谈通过使用JDBC的statement进行数据操作

　　使用JDBC的statement进行数据的查询，基本步骤如下：

　　1. 初始化simpleDbSource对象

　　2. 获得getconnection

　　3. createStatement 获得查询语句

　　4. executeUpdate, 执行更新语句

　　5. 关闭使用的statement, connection, 注意次序不要弄错

　　注意：更新语句，执行过一次后，column需要递增，否则报错

　　Java代码

1. /**    
2.  *     
3.  */    
4. package db;     
5.     
6. import java.io.FileNotFoundException;     
7. import java.io.IOException;     
8. import java.sql.Connection;     
9. import java.sql.ResultSet;     
10. import java.sql.SQLException;     
11.     
12. /**    
13.  * @author sean    
14.  *     
15.  * 1. 初始化simpleDbSource对象    
16.  * 2. 获得getconnection    
17.  * 3. createStatement 获得查询语句    
18.  * 4. executeUpdate, 执行更新语句    
19.  * 5. 关闭使用的statement, connection, 注意次序不要弄错    
20.  *     
21.  * 注意：更新语句，执行过一次后，column需要递增，否则报错    
22.  */    
23. public class StatementDemo {     
24.     
25.     private static String insertSql="insert into user values('7','sean','[email protected]','hellofromsean')";     
26.     private static String querySql ="select * from user";     
27.     
28.     /**    
29.      * @param args    
30.      */    
31.     public static void main(String[] args) {     
32.         // TODO Auto-generated method stub     
33.         DBSource dbSource;     
34.         Connection conn = null;     
35.         java.sql.Statement stmt = null;     
36.              
37.         try {     
38.             dbSource = new SimpleDBSource();     
39.             conn = dbSource.getConnect();     
40.             stmt = conn.createStatement();     
41.                  
42.             //数据库更新工作,包括create, drop, update, insert etc.     
43.             stmt.executeUpdate(insertSql);     
44.             System.out.println("执行成功"+ insertSql);     
45.                  
46.             //进行数据库查询     
47.             ResultSet rs = stmt.executeQuery(querySql);     
48.                  
49.             //进行遍历     
50.             while(rs.next()){     
51.                 System.out.println(rs.getInt(1)+ "\t");     
52.                 System.out.println(rs.getString(2)+ "\t");     
53.                 System.out.println(rs.getString(3)+ "\t");     
54.                 System.out.println(rs.getString(4)+ "\t");     
55.                 System.out.println("**********************");     
56.             }     
57.                  
58.                  
59.                  
60.         } catch (FileNotFoundException e) {     
61.             // TODO Auto-generated catch block     
62.             e.printStackTrace();     
63.         } catch (IOException e) {     
64.             // TODO Auto-generated catch block     
65.             e.printStackTrace();     
66.         } catch (ClassNotFoundException e) {     
67.             // TODO Auto-generated catch block     
68.             e.printStackTrace();     
69.         } catch (SQLException e) {     
70.             // TODO Auto-generated catch block     
71.             e.printStackTrace();     
72.         }     
73.              
74.         //依次关闭statement和conn数据库连接对象，清空资源     
75.         finally{     
76.             if(stmt!= null){     
77.                 try {     
78.                     stmt.close();     
79.                 } catch (SQLException e) {     
80.                     // TODO Auto-generated catch block     
81.                     e.printStackTrace();     
82.                 }     
83.                 stmt= null;     
84.             }     
85.             if(conn!=null){     
86.                 try {     
87.                     conn.close();     
88.                 } catch (SQLException e) {     
89.                     // TODO Auto-generated catch block     
90.                     e.printStackTrace();     
91.                 }     
92.                 conn= null;     
93.             }     
94.         }     
95.     }     
96. }    
98. /**  
99.  *   
100.  */  
101. package db;  
103. import java.io.FileNotFoundException;  
104. import java.io.IOException;  
105. import java.sql.Connection;  
106. import java.sql.ResultSet;  
107. import java.sql.SQLException;  
109. /**  
110.  * @author sean  
111.  *   
112.  * 1. 初始化simpleDbSource对象  
113.  * 2. 获得getconnection  
114.  * 3. createStatement 获得查询语句  
115.  * 4. executeUpdate, 执行更新语句  
116.  * 5. 关闭使用的statement, connection, 注意次序不要弄错  
117.  *   
118.  * 注意：更新语句，执行过一次后，column需要递增，否则报错  
119.  */  
120. public class StatementDemo {  
122.  private static String insertSql="insert into user values('7','sean','[email protected]','hellofromsean')";  
123.  private static String querySql ="select * from user";  
125.  /**  
126.   * @param args  
127.   */  
128.  public static void main(String[] args) {  
129.   // TODO Auto-generated method stub  
130.   DBSource dbSource;  
131.   Connection conn = null;  
132.   java.sql.Statement stmt = null;  
133.     
134.   try {  
135.    dbSource = new SimpleDBSource();  
136.    conn = dbSource.getConnect();  
137.    stmt = conn.createStatement();  
138.      
139.    //数据库更新工作,包括create, drop, update, insert etc.  
140.    stmt.executeUpdate(insertSql);  
141.    System.out.println("执行成功"+ insertSql);  
142.      
143.    //进行数据库查询  
144.    ResultSet rs = stmt.executeQuery(querySql);  
145.      
146.    //进行遍历  
147.    while(rs.next()){  
148.     System.out.println(rs.getInt(1)+ "\t");  
149.     System.out.println(rs.getString(2)+ "\t");  
150.     System.out.println(rs.getString(3)+ "\t");  
151.     System.out.println(rs.getString(4)+ "\t");  
152.     System.out.println("**********************");  
153.    }  
154.      
155.      
156.      
157.   } catch (FileNotFoundException e) {  
158.    // TODO Auto-generated catch block  
159.    e.printStackTrace();  
160.   } catch (IOException e) {  
161.    // TODO Auto-generated catch block  
162.    e.printStackTrace();  
163.   } catch (ClassNotFoundException e) {  
164.    // TODO Auto-generated catch block  
165.    e.printStackTrace();  
166.   } catch (SQLException e) {  
167.    // TODO Auto-generated catch block  
168.    e.printStackTrace();  
169.   }  
170.     
171.   //依次关闭statement和conn数据库连接对象，清空资源  
172.   finally{  
173.    if(stmt!= null){  
174.     try {  
175.      stmt.close();  
176.     } catch (SQLException e) {  
177.      // TODO Auto-generated catch block  
178.      e.printStackTrace();  
179.     }  
180.     stmt= null;  
181.    }  
182.    if(conn!=null){  
183.     try {  
184.      conn.close();  
185.     } catch (SQLException e) {  
186.      // TODO Auto-generated catch block  
187.      e.printStackTrace();  
188.     }  
189.     conn= null;  
190.    }  
191.   }  
192.  }  
193. }  
196. /**   
197. *   
198. */   
199. package db;   
201. import java.io.FileNotFoundException;   
202. import java.io.IOException;   
203. import java.sql.Connection;   
204. import java.sql.ResultSet;   
205. import java.sql.SQLException;   
206. import java.sql.Statement;   
208. /**   
209. * @author sean   
210. *   
211. * 1. 初始化simpleDbSource对象   
212. * 2. 获得getconnection   
213. * 3. createPreparedStatement 获得查询语句   
214. * 4. 设置具体更新内容,setInt(colIndex, value), setString(colIndex,value)   
215. * 4. executeUpdate, 执行更新语句   
216. * 5. 关闭使用的PreparedStatementstatement, connection, 注意次序不要弄错   
217. *   
218. * 注意：更新语句，执行过一次后，column需要递增，否则报错   
219. */   
220. public class PreparedStatementDemo {   
222. private static String querySql ="select * from user";   
223. private static String pstmtSql = "insert into user values(?,?,?,?)";   
225. Connection conn1;   
226. static Statement stmt;   
227. /**   
228. * @param args   
229. */   
230. public static void main(String[] args) {   
231. // TODO Auto-generated method stub   
232. DBSource dbSource;   
233. Connection conn = null;   
234. java.sql.PreparedStatement pstmt = null;   
236. try {   
237. dbSource = new SimpleDBSource();   
238. conn = dbSource.getConnect();   
239. pstmt = conn.prepareStatement(pstmtSql);   
241. pstmt.setInt(1, 9);   
242. pstmt.setString(2, "sean");   
243. pstmt.setString(3, "[email protected]");   
244. pstmt.setString(4, "add some comments");   
246. //数据库更新工作,包括create, drop, update, insert etc.   
247. pstmt.executeUpdate();   
249. //清空设置的参数，为后续更新准备   
250. pstmt.clearParameters();   
252. System.out.println("执行成功"+ pstmtSql);   
254. //进行数据库查询   
255. Connection conn1 = dbSource.getConnect();   
256. Statement stmt = conn1.createStatement();   
257. ResultSet rs = stmt.executeQuery(querySql);   
259. //进行遍历   
260. while(rs.next()){   
261. System.out.println(rs.getInt(1)+ "\t");   
262. System.out.println(rs.getString(2)+ "\t");   
263. System.out.println(rs.getString(3)+ "\t");   
264. System.out.println(rs.getString(4)+ "\t");   
265. System.out.println("**********************");   
266. }   
267. } catch (FileNotFoundException e) {   
268. // TODO Auto-generated catch block   
269. e.printStackTrace();   
270. } catch (IOException e) {   
271. // TODO Auto-generated catch block   
272. e.printStackTrace();   
273. } catch (ClassNotFoundException e) {   
274. // TODO Auto-generated catch block   
275. e.printStackTrace();   
276. } catch (SQLException e) {   
277. // TODO Auto-generated catch block   
278. e.printStackTrace();   
279. }   
281. //依次关闭jdbc的statement和conn数据库连接对象，清空资源   
282. finally{   
283. if(stmt!= null){   
284. try {   
285. stmt.close();   
286. } catch (SQLException e) {   
287. // TODO Auto-generated catch block   
288. e.printStackTrace();   
289. }   
290. stmt= null;   
291. }   
293. if(pstmt!= null){   
294. try {   
295. pstmt.close();   
296. } catch (SQLException e) {   
297. // TODO Auto-generated catch block   
298. e.printStackTrace();   
299. }   
300. pstmt= null;   
301. }   
303. if(conn!=null){   
304. try {   
305. conn.close();   
306. } catch (SQLException e) {   
307. // TODO Auto-generated catch block   
308. e.printStackTrace();   
309. }   
310. conn= null;   
311. }   
312. }   
313. }   
314. }