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

最新推荐文章于 2023-03-13 16:58:45 发布
最新推荐文章于 2023-03-13 16:58:45 发布
阅读量323 收藏
点赞数
文章标签： java 数据库 jdbc
[java]  view plain  copy
 print ?
  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.     }  

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

[java]  view plain  copy
 print ?
  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. }  

转载地址：http://blog.csdn.net/haifengzhilian/article/details/7868442

梅宝强
关注
JAVA数据库连接封装（jdbc）
qq_38520458的博客
08-18 1129
一、前请提要 在我们开发的过程中，除了用数据库来保存我们的数据，那么，怎么来获取我们保存在数据库中的数据呢？，特别是在java代码中呢？这里我们就要用到jdbc了，但是使用发现，我们的代码重复度过高，于是，我们对这些重复的代码进行了封装，当然，封装是一个极具挑战性的任务，这里面用到类回调，用到了反射，都是Java中的难点，小编也是在几天的代码阅读思考下才理解，单独给小编封装任务，小标怕是会跑路，...
Java的JDBC连接池底层封装
最新发布
weixin_55415300的博客
12-09 1599
目录一、JDBC回顾1.1 六个基本步骤1.2 问题的引出二、ORM框架三、JDBC连接池性能优化3.1 JDBC连接池在创建连接时优化3.2 将连接（桥梁）和状态进行绑定1、MyConnection3.3 设计连接池用于装连接1、ConnectionPool四、JDBC连接池性能的测试五、将JDBC整体优化5.1 问题的产生5.2 问题解决方案1、单例的连接池对象2、添加配置文件3、多个人同时访问4、防止多余的线程出现null5、代理模式（1）静态代理模式（2）缺省适配器模式5.3 完整的JDBC封装代码
JAVA：数据库操作封装
思想者的专栏
03-04 1281
package creator.common.db;import java.io.InputStream;import java.sql.*;import javax.sql.*;import javax.naming.*;/** * * Title: dbBean.java * Description:  * Copyright: Copyright (c) 2004 * Company:  *
java 数据库管理_封装了一个Java数据库访问管理类
weixin_39684495的博客
02-20 118
package com.groundhog.codingmouse;import java.sql.Connection;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;/*** 数据库管理类* @author...
Java操作数据库之类的封装!...
weixin_34095889的博客
12-09 137
import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; class DBManager{ //定义成员变量 Connection conn =nul...
JDBC连接数据库
m0_69855013的博客
09-18 494
JDBC连接数据库
Java数据库连接-JDBC
weixin_48031392的博客
09-07 1163
jdbc
Java用JDBC连接MySQL数据库
一叶一菩提的博客
06-01 1143
如果你的只是单纯的需要连接数据库的代码和驱动 那么请看前面的讲解 如果需要完整的详细的讲解请向下看 public class TestConnection { //增删改 @Test public void testUpdate() throws Exception { //步骤1：注册驱动（为了让mysql的实现类加载到内存可以使用） //DriverManager.registerDriver(new Driver()); 不建议使用具体的见...
JDBC与数据库连接池
weixin_65228462的博客
03-13 202
jdbc与数据库连接池
java 使用jdbc封装连接数据库
11-30
使用jdbc简单的封装了连接mysql数据库的方式，适合新手进行学习
JDBC的封装
12-05
JDBC的封装，（含预编译，结果集等），执行DML有参、执行DML无参、执行DQL无参及有参
Java连接数据库 JDBC封装类 带使用例子
08-06
Java JDBC封装类，带增删改查例子，支持oracle,MySql,hsqldb 等，支持事务，返回数据格式 支持二维数组，MAP格式，以及javabean对象。有利于初学者DbDemo.java为demo,Connect为jdbc封装类，可以作为项目共通类使用。
mysql封装 java_java连接mysql底层封装详解
weixin_35959421的博客
01-18 255
本文实例为大家分享了java连接mysql底层封装代码，供大家参考，具体内容如下连接数据库package com.dao.db;import java.sql.Connection;import java.sql.SQLException;/*** 数据库连接层MYSQL* @author Administrator**/public class DBConnection {/*** 连接数据库*...
java 数据库封装
daditao的专栏
03-02 3062
package mybm;import java.sql.Connection;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.ResultSetMetaData;import java.sql.SQLException;import
java 数据库封装_java对数据库的封装
weixin_42347426的博客
02-20 665
import java.sql.*;public class Conn { //连接的封装private Conn(){}public static Connection getInstance(){Connection ct=null;try{Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");ct=Driver...
【转】java（JDBC连接数据库）[完整版封装]
心成_111的博客
07-24 165
转自：https://blog.csdn.net/m0_37651226/article/details/73385718# import java.sql.CallableStatement; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; ...
Java JDBC封装：兼容多数据库操作的核心代码示例
"Java数据库开发中的JDBC封装技术，旨在实现与多种数据库的兼容性" 在Java数据库开发中，JDBC（Java Database Connectivity）是Java应用程序连接和操作数据库的标准接口。本篇内容主要关注如何对JDBC进行完整封装，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值