封装的jdbc

分手后的思念是犯贱 2021-11-22 12:58 441阅读 0赞
  1. package com.zcq.visitMysql;
  2. import java.sql.CallableStatement;
  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. /** * 对jdbc的完整封装 * */
  14. public class JDBCUtil {
  15. private static String driver = "com.mysql.jdbc.Driver";
  16. private static String url = "jdbc:msyql://localhost:3306/数据库名?useUnicode=true&characterEncoding=utf-8&useSSL=false";
  17. private static String username = "root";
  18. private static String password = "密码";
  19. private CallableStatement callableStatement = null;//创建CallableStatement对象
  20. private Connection conn = null;
  21. private PreparedStatement pst = null;
  22. private ResultSet rst = null;
  23. /* static { try { // 加载数据库驱动程序 Class.forName(driver); } catch (ClassNotFoundException e) { System.out.println("加载驱动错误"); System.out.println(e.getMessage()); } } */
  24. /*public JDBCUtil(String driver,String url ,String username,String password) { this.driver = driver; this.url = url; this.username = username; this.password = password; }*/
  25. /** * 建立数据库连接 * @return 数据库连接 */
  26. public Connection getConnection() {
  27. try {
  28. // 加载数据库驱动程序
  29. try {
  30. Class.forName(driver);
  31. } catch (ClassNotFoundException e) {
  32. System.out.println("加载驱动错误");
  33. System.out.println(e.getMessage());
  34. e.printStackTrace();
  35. }
  36. // 获取连接
  37. conn = DriverManager.getConnection(url, username,
  38. password);
  39. } catch (SQLException e) {
  40. System.out.println(e.getMessage());
  41. }
  42. return conn;
  43. }
  44. /** * insert update delete SQL语句的执行的统一方法 * @param sql SQL语句 * @param params 参数数组,若没有参数则为null * @return 受影响的行数 */
  45. public int executeUpdate(String sql, Object[] params) {
  46. // 受影响的行数
  47. int affectedLine = 0;
  48. try {
  49. // 获得连接
  50. conn = this.getConnection();
  51. // 调用SQL
  52. pst = conn.prepareStatement(sql);
  53. // 参数赋值
  54. if (params != null) {
  55. for (int i = 0; i < params.length; i++) {
  56. pst.setObject(i + 1, params[i]);
  57. }
  58. }
  59. /*在此 PreparedStatement 对象中执行 SQL 语句, 该语句必须是一个 SQL 数据操作语言(Data Manipulation Language,DML)语句,比如 INSERT、UPDATE 或 DELETE 语句;或者是无返回内容的 SQL 语句,比如 DDL 语句。 */
  60. // 执行
  61. affectedLine = pst.executeUpdate();
  62. } catch (SQLException e) {
  63. System.out.println(e.getMessage());
  64. } finally {
  65. // 释放资源
  66. closeAll();
  67. }
  68. return affectedLine;
  69. }
  70. /** * SQL 查询将查询结果直接放入ResultSet中 * @param sql SQL语句 * @param params 参数数组,若没有参数则为null * @return 结果集 */
  71. private ResultSet executeQueryRS(String sql, Object[] params) {
  72. try {
  73. // 获得连接
  74. conn = this.getConnection();
  75. // 调用SQL
  76. pst = conn.prepareStatement(sql);
  77. // 参数赋值
  78. if (params != null) {
  79. for (int i = 0; i < params.length; i++) {
  80. pst.setObject(i + 1, params[i]);
  81. }
  82. }
  83. // 执行
  84. rst = pst.executeQuery();
  85. } catch (SQLException e) {
  86. System.out.println(e.getMessage());
  87. }
  88. return rst;
  89. }
  90. /** * SQL 查询将查询结果:一行一列 * @param sql SQL语句 * @param params 参数数组,若没有参数则为null * @return 结果集 */
  91. public Object executeQuerySingle(String sql, Object[] params) {
  92. Object object = null;
  93. try {
  94. // 获得连接
  95. conn = this.getConnection();
  96. // 调用SQL
  97. pst = conn.prepareStatement(sql);
  98. // 参数赋值
  99. if (params != null) {
  100. for (int i = 0; i < params.length; i++) {
  101. pst.setObject(i + 1, params[i]);
  102. }
  103. }
  104. // 执行
  105. rst = pst.executeQuery();
  106. if(rst.next()) {
  107. object = rst.getObject(1);
  108. }
  109. } catch (SQLException e) {
  110. System.out.println(e.getMessage());
  111. } finally {
  112. closeAll();
  113. }
  114. return object;
  115. }
  116. /** * 获取结果集,并将结果放在List中 * * @param sql SQL语句 * params 参数,没有则为null * @return List * 结果集 */
  117. public List<Object> excuteQuery(String sql, Object[] params) {
  118. // 执行SQL获得结果集
  119. ResultSet rs = executeQueryRS(sql, params);
  120. // 创建ResultSetMetaData对象
  121. ResultSetMetaData rsmd = null;
  122. // 结果集列数
  123. int columnCount = 0;
  124. try {
  125. rsmd = rs.getMetaData();
  126. // 获得结果集列数
  127. columnCount = rsmd.getColumnCount();
  128. } catch (SQLException e1) {
  129. System.out.println(e1.getMessage());
  130. }
  131. // 创建List
  132. List<Object> list = new ArrayList<Object>();
  133. try {
  134. // 将ResultSet的结果保存到List中
  135. while (rs.next()) {
  136. Map<String, Object> map = new HashMap<String, Object>();
  137. for (int i = 1; i <= columnCount; i++) {
  138. map.put(rsmd.getColumnLabel(i), rs.getObject(i));
  139. }
  140. list.add(map);//每一个map代表一条记录,把所有记录存在list中
  141. }
  142. } catch (SQLException e) {
  143. System.out.println(e.getMessage());
  144. } finally {
  145. // 关闭所有资源
  146. closeAll();
  147. }
  148. return list;
  149. }
  150. /** * 存储过程带有一个输出参数的方法 * @param sql 存储过程语句 * @param params 参数数组 * @param outParamPos 输出参数位置 * @param SqlType 输出参数类型 * @return 输出参数的值 */
  151. public Object excuteQuery(String sql, Object[] params,int outParamPos, int SqlType) {
  152. Object object = null;
  153. conn = this.getConnection();
  154. try {
  155. // 调用存储过程
  156. // prepareCall:创建一个 CallableStatement 对象来调用数据库存储过程。
  157. callableStatement = conn.prepareCall(sql);
  158. // 给参数赋值
  159. if(params != null) {
  160. for(int i = 0; i < params.length; i++) {
  161. callableStatement.setObject(i + 1, params[i]);
  162. }
  163. }
  164. // 注册输出参数
  165. callableStatement.registerOutParameter(outParamPos, SqlType);
  166. // 执行
  167. callableStatement.execute();
  168. // 得到输出参数
  169. object = callableStatement.getObject(outParamPos);
  170. } catch (SQLException e) {
  171. System.out.println(e.getMessage());
  172. } finally {
  173. // 释放资源
  174. closeAll();
  175. }
  176. return object;
  177. }
  178. /** * 关闭所有资源 */
  179. private void closeAll() {
  180. // 关闭结果集对象
  181. if (rst != null) {
  182. try {
  183. rst.close();
  184. } catch (SQLException e) {
  185. System.out.println(e.getMessage());
  186. }
  187. }
  188. // 关闭PreparedStatement对象
  189. if (pst != null) {
  190. try {
  191. pst.close();
  192. } catch (SQLException e) {
  193. System.out.println(e.getMessage());
  194. }
  195. }
  196. // 关闭CallableStatement 对象
  197. if (callableStatement != null) {
  198. try {
  199. callableStatement.close();
  200. } catch (SQLException e) {
  201. System.out.println(e.getMessage());
  202. }
  203. }
  204. // 关闭Connection 对象
  205. if (conn != null) {
  206. try {
  207. conn.close();
  208. } catch (SQLException e) {
  209. System.out.println(e.getMessage());
  210. }
  211. }
  212. }
  213. }

发表评论

表情:
评论列表 (有 0 条评论,441人围观)

还没有评论,来说两句吧...

相关阅读

    相关 概念

      封装:         概念:            将类的某些信息隐藏在类内部,不允许外部程序直接访问,            而是通过该类提供的方法来实现对隐藏

    相关 Java深入浅出

    前言 封装是一种隐藏信息的技术,是将一个系统中的结构和行为通过类来划分的过程。即通过定义一组类,将特定的数据组合到某一个类中,形成一个整体,将该隐藏的数据进行保护,只对外

    相关 自己JDBC

    > 对JDBC进行一些简单的封装,可以方便在项目中调用,同时也减少了重复代码量,降低代码的冗余度,提高代码的可读性和美观。 package JdbcUtil