jdbc操作mysql

本文讲述2点：

一. jdbc 操作 MySQL 。(封装一个JdbcUtils.java类，实现数据库表的增删改查)

1. 建立数据库连接

Class.forName(DRIVER);

connection = DriverManager.getConnection(URL, USERNAME, PASSWORD);

2.用PrepareStatement执行sql语句

pstmt = connection.prepareStatement(sql);

3. 获得执行Sql结果(int result)或结果集合（ResultSet）

int result = pstmt.executeUpdate();  (增，删，改)

ResultSet resultSet = pstmt.executeQuery(); (查询)

// 获取所有列的信息

ResultSetMetaData metaData = resultSet.getMetaData();

二. 用Java反射机制返回JavaBean,List<JavaBean>

看JdbcUtils.java 中具体代码。

------------------------------------------------------------------------------------------------------------

程序思路：

用eclipse建立一个java 工程，访问mysql数据库。数据库名称：mydb,表格名称：userinfo. user表格有三个属性(id , username , pswd)

工程目录：

1 JdbcUtils.java --封装数据库操作的类

1. package com.jdbc.dbutils;
2. import java.lang.reflect.Field;
3. import java.sql.Connection;
4. import java.sql.DriverManager;
5. import java.sql.PreparedStatement;
6. import java.sql.ResultSet;
7. import java.sql.ResultSetMetaData;
8. import java.sql.SQLException;
9. import java.util.ArrayList;
10. import java.util.HashMap;
11. import java.util.List;
12. import java.util.Map;
13. import com.jdbc.data.UserInfo;
14. import com.mysql.jdbc.Driver;
15. public class JdbcUtils {
16. // 定义数据库的用户名
17. private final String USERNAME = "root";
18. // 定义数据库的密码
19. private final String PASSWORD = "123456";
20. // 定义数据库的驱动信息
21. private final String DRIVER = "com.mysql.jdbc.Driver";
22. // 定义访问数据库的地址
23. private final String URL = "jdbc:mysql://localhost:3306/mydb";
24. // 定义访问数据库的连接
25. private Connection connection;
26. // 定义sql语句的执行对象
27. private PreparedStatement pstmt;
28. // 定义查询返回的结果集合
29. private ResultSet resultSet;
30. public JdbcUtils() {
31. // TODO Auto-generated constructor stub
32. try {
33. Class.forName(DRIVER);
34. System.out.println("注册驱动成功！！");
35. } catch (ClassNotFoundException e) {
36. // TODO Auto-generated catch block
37. System.out.println("注册驱动失败！！");
38. }
39. }
40. // 定义获得数据库的连接
41. public Connection getConnection() {
42. try {
43. connection = DriverManager.getConnection(URL, USERNAME, PASSWORD);
44. } catch (Exception e) {
45. // TODO: handle exception
46. System.out.println("Connection exception !");
47. }
48. return connection;
49. }
50. /**
51. * 完成对数据库标的增加删除和修改的操作
52. *
53. * @param sql
54. * @param params
55. * @return
56. * @throws SQLException
57. */
58. public boolean updateByPreparedStatement(String sql, List<Object> params)
59. throws SQLException {
60. boolean flag = false;
61. int result = -1;// 表示当用户执行增加删除和修改的操作影响的行数
62. int index = 1; // 表示 占位符 ，从1开始
63. pstmt = connection.prepareStatement(sql);
64. if (params != null && !params.isEmpty()) {
65. for (int i = 0; i < params.size(); i++) {
66. pstmt.setObject(index++, params.get(i)); // 填充占位符
67. }
68. }
69. result = pstmt.executeUpdate();
70. flag = result > 0 ? true : false;
71. return flag;
72. }
73. /**
74. * 查询返回单条记录
75. *
76. * @param sql
77. * @param params
78. * @return
79. * @throws SQLException
80. */
81. public  Map<String, Object> findSimpleResult(String sql, List<Object> params)
82. throws SQLException {
83. Map<String, Object> map = new HashMap<String, Object>();
84. pstmt = connection.prepareStatement(sql);
85. int index = 1;
86. if (params != null && !params.isEmpty()) {
87. for (int i = 0; i < params.size(); i++) {
88. pstmt.setObject(index++, params.get(i));
89. }
90. }
91. resultSet = pstmt.executeQuery(); // 返回查询结果
92. ResultSetMetaData metaData = pstmt.getMetaData(); // 获取 结果中，一行所有列的结果
93. int cols_len = metaData.getColumnCount(); // 获得列的总数
94. while (resultSet.next()) {
95. for (int i = 0; i < cols_len; i++) {
96. String col_name = metaData.getColumnName(i + 1); // 获得第i列的字段名称
97. Object col_value = resultSet.getObject(col_name);// 返回 第i列的内容值
98. if (col_value == null) {
99. col_value = "";
100. }
101. map.put(col_name, col_value);
102. }
103. }
104. return map;
105. }
106. /**
107. * 查询返回多条记录
108. *
109. * @param sql
110. * @param params
111. * @return
112. * @throws SQLException
113. */
114. public List<Map<String, Object>> findMoreResult(String sql,
115. List<Object> params) throws SQLException {
116. List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
117. pstmt = connection.prepareStatement(sql);
118. int index = 1; // 表示占位符
119. if (params != null && !params.isEmpty()) {
120. for (int i = 0; i < params.size(); i++) {
121. pstmt.setObject(index++, params.get(i));
122. }
123. }
124. resultSet = pstmt.executeQuery(); // 返回查询结果集合
125. ResultSetMetaData metaData = resultSet.getMetaData(); // 获得列的结果
126. while (resultSet.next()) {
127. Map<String, Object> map = new HashMap<String, Object>();
128. int cols_len = metaData.getColumnCount(); // 获取总的列数
129. for (int i = 0; i < cols_len; i++) {
130. String col_name = metaData.getColumnName(i + 1); // 获取第 i列的字段名称
131. // ,列计算从1开始
132. Object col_value = resultSet.getObject(col_name); // 获取第i列的内容值
133. if (col_value == null) {
134. col_value = "";
135. }
136. map.put(col_name, col_value);
137. }
138. list.add(map);
139. }
140. return list;
141. }
142. /**
143. * 查询返回单个JavaBean(使用java反射机制)
144. *
145. * @param sql
146. * @param params
147. * @param cls
148. * @return
149. * @throws Exception
150. */
151. public <T> T findSimpleRefResult(String sql, List<Object> params,
152. Class<T> cls) throws Exception {
153. T resultObject = null;
154. int index = 1; // 占位符
155. pstmt = connection.prepareStatement(sql);
156. if (params != null && !params.isEmpty()) {
157. for (int i = 0; i < params.size(); i++) {
158. pstmt.setObject(index++, params.get(i)); // 填充占位符
159. }
160. }
161. resultSet = pstmt.executeQuery(); // 获取查询结果
162. ResultSetMetaData metaData = resultSet.getMetaData(); // 获取列的信息
163. int cols_len = metaData.getColumnCount(); // 获取总的列数
164. while (resultSet.next()) {
165. // 通过反射机制创建实例
166. resultObject = cls.newInstance(); // java反射机制
167. for (int i = 0; i < cols_len; i++) {
168. String col_name = metaData.getColumnName(i + 1); // 获取第i列的名称
169. Object col_value = resultSet.getObject(col_name); // 获取第i列的值
170. if (col_value == null) {
171. col_value = "";
172. }
173. Field field = cls.getDeclaredField(col_name);
174. field.setAccessible(true);// 打开 JavaBean的访问 private权限
175. field.set(resultObject, col_value);
176. }
177. }
178. return resultObject;
179. }
180. /** 查询返回多个JavaBean(通过java反射机制)
181. * @param sql
182. * @param params
183. * @param cls
184. * @return
185. * @throws Exception
186. */
187. public <T> List<T> findMoreRefResult(String sql, List<Object> params,
188. Class<T> cls) throws Exception {
189. List<T> list = new ArrayList<T>();
190. int index = 1; //占位符
191. pstmt = connection.prepareStatement(sql);
192. if (params != null && !params.isEmpty()) {
193. for (int i = 0; i < params.size(); i++) {
194. pstmt.setObject(index++, params.get(i));
195. }
196. }
197. resultSet = pstmt.executeQuery(); // 返回查询结果集合
198. ResultSetMetaData metaData = resultSet.getMetaData(); // 返回列的信息
199. int cols_len = metaData.getColumnCount(); // 结果集中总的列数
200. while (resultSet.next()) {
201. // 通过反射机制创建一个java实例
202. T resultObject = cls.newInstance();
203. for (int i = 0; i < cols_len; i++) {
204. String col_name = metaData.getColumnName(i + 1); // 获得第i列的名称
205. Object col_value = resultSet.getObject(col_name); // 获得第i列的内容
206. if (col_value == null) {
207. col_value = "";
208. }
209. Field field = cls.getDeclaredField(col_name);
210. field.setAccessible(true); // 打开JavaBean的访问private权限
211. field.set(resultObject, col_value);
212. }
213. list.add(resultObject);
214. }
215. return list;
216. }
217. /**关闭数据库访问
218. * @throws SQLException
219. */
220. public void releaseConn() throws SQLException{
221. if (resultSet!=null) {
222. resultSet.close();
223. }
224. if (pstmt!=null) {
225. pstmt.close();
226. }
227. if (connection!=null) {
228. connection.close();
229. }
230. }
231. }

2. UserInfo.java (用来验证java反射机制的JavaBean , 属性名称和数据表userinfo的字段完全一致)

1. package com.jdbc.data;
2. import java.io.Serializable;
3. public class UserInfo implements Serializable {
4. /**
5. *
6. */
7. private static final long serialVersionUID = 1L;
8. private int id;
9. private String username;
10. private String pswd;
11. public UserInfo() {
12. // TODO Auto-generated constructor stub
13. }
14. public int getId() {
15. return id;
16. }
17. public void setId(int id) {
18. this.id = id;
19. }
20. public String getUsername() {
21. return username;
22. }
23. public void setUsername(String username) {
24. this.username = username;
25. }
26. public String getPswd() {
27. return pswd;
28. }
29. public void setPswd(String pswd) {
30. this.pswd = pswd;
31. }
32. public static long getSerialversionuid() {
33. return serialVersionUID;
34. }
35. @Override
36. public String toString() {
37. return "UserInfo [id=" + id + ", username=" + username + ", pswd="
38. + pswd + "]";
39. }
40. }

3. Test_insert.java  测试添加

1. package com.jdbc.test;
2. import java.sql.SQLException;
3. import java.util.ArrayList;
4. import java.util.List;
5. import com.jdbc.dbutils.JdbcUtils;
6. public class Test_Insert {
7. /**
8. * @param args
9. * @throws SQLException
10. */
11. public static void main(String[] args) throws SQLException {
12. JdbcUtils jdbcUtils = new JdbcUtils();
13. jdbcUtils.getConnection();
14. //增加一条记录。新增一个用户信息 uername = "jack" , password = "admin"
15. String sql = "insert into userinfo(username,pswd) values(?,?)";
16. List<Object> params = new ArrayList<Object>();
17. params.add("jack");
18. params.add("admin");
19. try {
20. boolean flag = jdbcUtils.updateByPreparedStatement(sql, params);
21. System.out.println("添加一条记录： "+flag);
22. } catch (Exception e) {
23. // TODO: handle exception
24. e.printStackTrace();
25. }finally{
26. jdbcUtils.releaseConn();
27. }
28. }
29. }

运行结果：

（用同样的方法，再增加一条记录username="rose",pswd="123"）,此时数据库共2条记录。如下图：

4. Test_FindMore.java (查询多条记录)

1. package com.jdbc.test;
2. import java.sql.SQLException;
3. import java.util.ArrayList;
4. import java.util.List;
5. import java.util.Map;
6. import com.jdbc.dbutils.JdbcUtils;
7. public class Test_FindMore {
8. /** 返回多条记录
9. * @param args
10. * @throws Exception
11. */
12. public static void main(String[] args) throws Exception {
13. // TODO Auto-generated method stub
14. JdbcUtils jdbcUtils = new JdbcUtils();
15. jdbcUtils.getConnection();
16. String sql = "select * from userinfo";
17. try {
18. List<Map<String, Object>> list = jdbcUtils.findMoreResult(sql, null);
19. System.out.println(list);
20. } catch (Exception e) {
21. // TODO: handle exception
22. e.printStackTrace();
23. }finally{
24. jdbcUtils.releaseConn();
25. }
26. }
27. }

运行结果：

5. Test_FindSimple.java (查询返回单条记录)

1. package com.jdbc.test;
2. import java.sql.SQLException;
3. import java.util.ArrayList;
4. import java.util.List;
5. import java.util.Map;
6. import com.jdbc.dbutils.JdbcUtils;
7. public class Test_FindSimple {
8. /**查询返回一条记录
9. * @param args
10. * @throws SQLException
11. */
12. public static void main(String[] args) throws SQLException {
13. // TODO Auto-generated method stub
14. JdbcUtils jdbcUtils = new JdbcUtils();
15. jdbcUtils.getConnection();
16. String sql = "select * from userinfo where username = ?";
17. List<Object> params = new ArrayList<Object>();
18. params.add("rose");
19. try {
20. Map<String, Object> map = jdbcUtils.findSimpleResult(sql, params);
21. System.out.println(map);
22. } catch (Exception e) {
23. // TODO: handle exception
24. e.printStackTrace();
25. }finally{
26. jdbcUtils.releaseConn();
27. }
28. }
29. }

运行结果：

6.Test_RefMore.java 查询返回List<JavaBean>(使用Java反射机制)

1. package com.jdbc.test;
2. import java.sql.SQLException;
3. import java.util.List;
4. import java.util.Map;
5. import com.jdbc.data.UserInfo;
6. import com.jdbc.dbutils.JdbcUtils;
7. public class Test_RefMore {
8. /**返回List<JavaBean> (用Java反射机制)
9. * @param args
10. * @throws SQLException
11. */
12. public static void main(String[] args) throws SQLException {
13. // TODO Auto-generated method stub
14. JdbcUtils jdbcUtils = new JdbcUtils();
15. jdbcUtils.getConnection();
16. String sql = "select * from userinfo";
17. try {
18. List<UserInfo> list = jdbcUtils.findMoreRefResult(sql, null , UserInfo.class);
19. System.out.println(list);
20. } catch (Exception e) {
21. // TODO: handle exception
22. e.printStackTrace();
23. }finally{
24. jdbcUtils.releaseConn();
25. }
26. }
27. }

7. Test_RefSimple.java 查询返回单个JavaBean (使用Java反射机制)

1. package com.jdbc.test;
2. import java.sql.SQLException;
3. import java.util.ArrayList;
4. import java.util.List;
5. import java.util.Map;
6. import com.jdbc.data.UserInfo;
7. import com.jdbc.dbutils.JdbcUtils;
8. public class Test_RefSimple {
9. /**返回一个JavaBean (用Java反射机制)
10. * @param args
11. * @throws SQLException
12. */
13. public static void main(String[] args) throws SQLException {
14. // TODO Auto-generated method stub
15. JdbcUtils jdbcUtils = new JdbcUtils();
16. jdbcUtils.getConnection();
17. String sql = "select * from userinfo where username = ?";
18. List<Object> params = new ArrayList<Object>();
19. params.add("rose");
20. try {
21. UserInfo userInfo = jdbcUtils.findSimpleRefResult(sql, params, UserInfo.class);
22. System.out.println(userInfo);
23. } catch (Exception e) {
24. // TODO: handle exception
25. e.printStackTrace();
26. }finally{
27. jdbcUtils.releaseConn();
28. }
29. }
30. }

运行结果：