AI 助理
备案控制台
开发者社区 数据库 文章 正文

JDBC数据源连接池的配置和使用实例

2016-07-27 1177
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
云数据库 RDS MySQL，集群系列 2核4GB
推荐场景：
搭建个人博客
RDS MySQL Serverless 基础系列，0.5-2RCU 50GB
推荐场景：
学生管理系统数据库设计 搭建个人博客
云数据库 RDS MySQL，高可用系列 2核4GB
简介： 个人学习参考所用，勿喷！ 使用JDBC建立数据库连接的两种方式:1.在代码中使用DriverManager获得数据库连接。
个人学习参考所用，勿喷！

 

使用JDBC建立数据库连接的两种方式:

1.在代码中使用DriverManager获得数据库连接。这种方式效率低，并且其性能、可靠性和稳定性随着用户访问量得增加逐渐下降。

2.使用配置数据源的方式连接数据库，该方式其实质就是在上述方法的基础上增加了数据库连接池，这种方式效率高。

 

数据源连接池的方式连接数据库与在代码中使用DriverManager获得数据库连接存在如下差别：

1） 数据源连接池的方式连接数据库是在程序中,通过向一个JNDI(Java Naming and  Directory Interface)服务器查询,即调用Context接口的lookup()方法,来得到DataSource对象,然后调用DataSource对象 的getConnection()方法建立连接

2） 为了能重复利用数据库连接对象,提高对请求的响应时间和服务器的性能,采用连接池技术.连接池技术预先建立多个数据库连接对象,然后将连接对象保存到连接 池中,当客户请求到来时,从池中取出一个连接对象为客户服务,当请求完成时,客户程序调用close()方法,将连接对象放回池中.

3） 在代码中使用DriverManager获得数据库连接的方式中,客户程序得到的连接对象是物理连接,调用连接对象的close()方法将关闭连接,而采 用连接池技术,客户程序得到的连接对象是连接池中物理连接的一个句柄,调用连接对象的close()方法,物理连接并没有关闭,数据源的实现只是删除了客 户程序中的连接对象和池中的连接对象之间的联系.

 

为了测试方便可以在数据库（这里以mysql 5为例）中建立一个USER表：

Sql代码   收藏代码
  1. <span style="font-family: Helvetica, Tahoma, Arial, sans-serif; font-size: x-small;">CREATE TABLE `user` (  
  2.   `id` int(10) unsigned NOT NULL AUTO_INCREMENT,  
  3.   `username` varchar(50) DEFAULT NULL,  
  4.   `password` varchar(50) DEFAULT NULL,  
  5.   `email` varchar(50) DEFAULT NULL,  
  6.   PRIMARY KEY (`id`),  
  7. );</span>  

 

导入数据库的驱动的jar包到tomcat的lib目录下（这里以mysql5为例，所用到的jar包为：mysql-connector-java-5.0.8-bin.jar）。

 

1.在代码中使用DriverManager获得数据库连接。这种方式效率低，并且其性能、可靠性和稳定性随着用户访问量得增加逐渐下降。

   oracle数据库连接的Java代码如下：

Java代码   收藏代码
  1. import java.sql.Connection;  
  2. import java.sql.DriverManager;  
  3. /** 
  4.  * 获取数据库连接 
  5.  */  
  6. public class DBConnection {  
  7.       
  8.     /** Oracle数据库连接URL*/  
  9.     private final static String DB_URL = "jdbc:oracle:thin:@127.0.0.1:1521:orcl";  
  10.       
  11.     /** Oracle数据库连接驱动*/  
  12.     private final static String DB_DRIVER = "oracle.jdbc.driver.OracleDriver";  
  13.       
  14.     /** 数据库用户名*/  
  15.     private final static String DB_USERNAME = "root";  
  16.       
  17.     /** 数据库密码*/  
  18.     private final static String DB_PASSWORD = "admin";  
  19.       
  20.     /** 
  21.      * 获取数据库连接 
  22.      * @return 
  23.      */  
  24.     public Connection getConnection(){  
  25.         /** 声明Connection连接对象*/  
  26.         Connection conn = null;  
  27.         try{  
  28.             /** 使用Class.forName()方法自动创建这个驱动程序的实例且自动调用DriverManager来注册它*/  
  29.             Class.forName(DB_DRIVER);  
  30.             /** 通过DriverManager的getConnection()方法获取数据库连接*/  
  31.             conn = DriverManager.getConnection(DB_URL,DB_USERNAME,DB_PASSWORD);  
  32.         }catch(Exception ex){  
  33.             ex.printStackTrace();  
  34.         }  
  35.         return conn;  
  36.     }  
  37.       
  38.     /** 
  39.      * 关闭数据库连接 
  40.      *  
  41.      * @param connect 
  42.      */  
  43.     public void closeConnection(Connection conn){  
  44.         try{  
  45.             if(conn!=null){  
  46.                 /** 判断当前连接连接对象如果没有被关闭就调用关闭方法*/  
  47.                 if(!conn.isClosed()){  
  48.                     conn.close();  
  49.                 }  
  50.             }  
  51.         }catch(Exception ex){  
  52.             ex.printStackTrace();  
  53.         }  
  54.     }  
  55.       
  56. }  

 

 mysql数据库连接的JSP代码如下：

Jsp代码   收藏代码
  1. <%@page import="java.sql.*, com.mysql.jdbc.Driver"%>  
  2. <%@ page language="java" contentType="text/html; charset=UTF-8"  pageEncoding="UTF-8"%>  
  3. <html>  
  4. <body>      
  5.     <%  
  6.     //com.mysql.jdbc.Driver  
  7.     Class.forName(Driver.class.getName()).newInstance();  
  8.     String url = "jdbc:mysql://localhost:3306/demo?useUnicode=true&characterEncoding=UTF8";  
  9.     String user = "root";  
  10.     String password = "123";  
  11.       
  12.     Connection conn = DriverManager.getConnection(url, user, password);  
  13.     Statement stmt = conn.createStatement();  
  14.       
  15.     String sql = "select * from user";  
  16.     ResultSet rs = stmt.executeQuery(sql);  
  17.       
  18.     while(rs.next()) {  
  19.         out.print("<br />" + "====================" + "<br />");  
  20.         out.print(rs.getLong("id") + "   ");  
  21.         out.print(rs.getString("username") + "   ");  
  22.         out.print(rs.getString("password") + "   ");  
  23.         out.print(rs.getString("email") + "   ");  
  24.     }  
  25.     %>  
  26. </body>  
  27. </html>  

 

2.使用配置数据源的方式连接数据库，该方式其实质就是在上述方法的基础上增加了数据库连接池，这种方式效率高。

1）mysql数据库数据源连接池的JSP代码如下：

Jsp代码   收藏代码
  1. <%@page import="java.sql.*, javax.naming.*, javax.sql.DataSource"%>  
  2. <%@ page language="java" contentType="text/html; charset=UTF-8"  pageEncoding="UTF-8"%>  
  3. <html>  
  4. <body>  
  5.     <%  
  6.     Context initCtx = new InitialContext();  
  7.     DataSource ds = (DataSource)initCtx.lookup("java:comp/env/jdbc/demoDB");  
  8.     Connection conn = ds.getConnection();  
  9.       
  10.     Statement stmt = conn.createStatement();  
  11.       
  12.     String sql = "select * from user";  
  13.     ResultSet rs = stmt.executeQuery(sql);  
  14.       
  15.     while(rs.next()) {  
  16.         out.print("<br />" + "====================" + "<br />");  
  17.         out.print(rs.getLong("id") + "   ");  
  18.         out.print(rs.getString("username") + "   ");  
  19.         out.print(rs.getString("password") + "   ");  
  20.         out.print(rs.getString("email") + "   ");  
  21.     }  
  22.     %>  
  23. </body>  
  24. </html>  

 

2） 添加如下代码到tomcat的conf目录下的server.xml中：

Xml代码   收藏代码
  1. <Context>   
  2.     <Resource name="jdbc/demoDB" auth="Container"   
  3.     type="javax.sql.DataSource"  
  4.     driverClassName="com.mysql.jdbc.Driver"  
  5.     url="jdbc:mysql://localhost:3306/demo"  
  6.     username="root"  
  7.     password="123"  
  8.     maxActive="50"  
  9.     maxIdle="30"  
  10.     maxWait="10000" />  
  11. </Context>  

 

3）在web工程目录下的web.xml的根节点下配置如下内容：

Xml代码   收藏代码
  1. <resource-ref>  
  2.     <description>mysqlDB Connection</description>  
  3.     <res-ref-name>jdbc/demoDB</res-ref-name>  
  4.     <res-type>javax.sql.DataSource</res-type>  
  5.     <res-auth>Container</res-auth>  
  6. </resource-ref>  

 

 完成上述步骤数据源的连接池配置已经完成，但是为了提高项目的可移植性，最好将上述第二步的内容放入到工程的META-INF目录的context.xml中（这个文件需要自行建立）：

Xml代码   收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <Context>  
  3.       <Resource name="jdbc/demoDB" auth="Container"   
  4.       type="javax.sql.DataSource"  
  5.       driverClassName="com.mysql.jdbc.Driver"  
  6.       url="jdbc:mysql://localhost:3306/demo"  
  7.       username="root"  
  8.       password="123"  
  9.       maxActive="50"  
  10.       maxIdle="30"  
  11.       maxWait="10000" />  
  12. </Context>  

 

3.使用配置数据源的数据库连接池时的数据库操作工具类

代码如下：

Java代码   收藏代码
  1. package db.utils;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.PreparedStatement;  
  5. import java.sql.ResultSet;  
  6. import java.sql.ResultSetMetaData;  
  7. import java.sql.SQLException;  
  8. import java.sql.Statement;  
  9. import java.text.DateFormat;  
  10. import java.util.ArrayList;  
  11. import java.util.Date;  
  12. import java.util.HashMap;  
  13. import java.util.List;  
  14. import java.util.Map;  
  15.   
  16. import javax.naming.InitialContext;  
  17. import javax.sql.DataSource;  
  18.   
  19. //import org.apache.log4j.Logger;  
  20.   
  21. /** 
  22.  * 数据库操作辅助类 
  23.  */  
  24. public class DbUtils {  
  25.       
  26.     //private static Logger logger = Logger.getLogger("DbUtils");  
  27.       
  28.     /** 
  29.      * 该语句必须是一个 SQL INSERT、UPDATE 或 DELETE 语句 
  30.      * @param sql 
  31.      * @param paramList：参数，与SQL语句中的占位符一一对应 
  32.      * @return 
  33.      * @throws Exception 
  34.      */  
  35.     public int execute(String sql, List<Object> paramList) throws Exception {  
  36.         if(sql == null || sql.trim().equals("")) {  
  37.             //logger.info("parameter is valid!");  
  38.         }  
  39.   
  40.         Connection conn = null;  
  41.         PreparedStatement pstmt = null;  
  42.         int result = 0;  
  43.         try {  
  44.             conn = getConnection();  
  45.             pstmt = DbUtils.getPreparedStatement(conn, sql);  
  46.             setPreparedStatementParam(pstmt, paramList);  
  47.             if(pstmt == null) {  
  48.                 return -1;  
  49.             }  
  50.             result = pstmt.executeUpdate();  
  51.         } catch (Exception e) {  
  52.             //logger.info(e.getMessage());  
  53.             throw new Exception(e);  
  54.         } finally {  
  55.             closeStatement(pstmt);  
  56.             closeConn(conn);  
  57.         }  
  58.   
  59.         return result;  
  60.     }  
  61.       
  62.     /** 
  63.      * 将查询数据库获得的结果集转换为Map对象 
  64.      * @param sql：查询语句 
  65.      * @param paramList：参数 
  66.      * @return 
  67.      */  
  68.     public List<Map<String, Object>> getQueryList(String sql, List<Object> paramList) throws Exception {  
  69.         if(sql == null || sql.trim().equals("")) {  
  70.             //logger.info("parameter is valid!");  
  71.             return null;  
  72.         }  
  73.   
  74.         Connection conn = null;  
  75.         PreparedStatement pstmt = null;  
  76.         ResultSet rs = null;  
  77.         List<Map<String, Object>> queryList = null;  
  78.         try {  
  79.             conn = getConnection();  
  80.             pstmt = DbUtils.getPreparedStatement(conn, sql);  
  81.             setPreparedStatementParam(pstmt, paramList);  
  82.             if(pstmt == null) {  
  83.                 return null;  
  84.             }  
  85.             rs = getResultSet(pstmt);  
  86.             queryList = getQueryList(rs);  
  87.         } catch (RuntimeException e) {  
  88.             //logger.info(e.getMessage());  
  89.             System.out.println("parameter is valid!");  
  90.             throw new Exception(e);  
  91.         } finally {  
  92.             closeResultSet(rs);  
  93.             closeStatement(pstmt);  
  94.             closeConn(conn);  
  95.         }  
  96.         return queryList;  
  97.     }  
  98.       
  99.     private void setPreparedStatementParam(PreparedStatement pstmt, List<Object> paramList) throws Exception {  
  100.         if(pstmt == null || paramList == null || paramList.isEmpty()) {  
  101.             return;  
  102.         }  
  103.         DateFormat df = DateFormat.getDateTimeInstance();  
  104.         for (int i = 0; i < paramList.size(); i++) {  
  105.             if(paramList.get(i) instanceof Integer) {  
  106.                 int paramValue = ((Integer)paramList.get(i)).intValue();  
  107.                 pstmt.setInt(i+1, paramValue);  
  108.             } else if(paramList.get(i) instanceof Float) {  
  109.                 float paramValue = ((Float)paramList.get(i)).floatValue();  
  110.                 pstmt.setFloat(i+1, paramValue);  
  111.             } else if(paramList.get(i) instanceof Double) {  
  112.                 double paramValue = ((Double)paramList.get(i)).doubleValue();  
  113.                 pstmt.setDouble(i+1, paramValue);  
  114.             } else if(paramList.get(i) instanceof Date) {  
  115.                 pstmt.setString(i+1, df.format((Date)paramList.get(i)));  
  116.             } else if(paramList.get(i) instanceof Long) {  
  117.                 long paramValue = ((Long)paramList.get(i)).longValue();  
  118.                 pstmt.setLong(i+1, paramValue);  
  119.             } else if(paramList.get(i) instanceof String) {  
  120.                 pstmt.setString(i+1, (String)paramList.get(i));  
  121.             }  
  122.         }  
  123.         return;  
  124.     }  
  125.       
  126.     /** 
  127.      * 获得数据库连接 
  128.      * @return 
  129.      * @throws Exception 
  130.      */  
  131.     private Connection getConnection() throws Exception {  
  132.         InitialContext cxt = new InitialContext();  
  133.         DataSource ds = (DataSource) cxt.lookup(jndiName);  
  134.         if ( ds == null ) {  
  135.            throw new Exception("Data source not found!");  
  136.         }  
  137.           
  138.         return ds.getConnection();  
  139.     }  
  140.       
  141.     private static PreparedStatement getPreparedStatement(Connection conn, String sql) throws Exception {  
  142.         if(conn == null || sql == null || sql.trim().equals("")) {  
  143.             return null;  
  144.         }  
  145.         PreparedStatement pstmt = conn.prepareStatement(sql.trim());  
  146.         return pstmt;  
  147.     }  
  148.       
  149.     /** 
  150.      * 获得数据库查询结果集 
  151.      * @param pstmt 
  152.      * @return 
  153.      * @throws Exception 
  154.      */  
  155.     private ResultSet getResultSet(PreparedStatement pstmt) throws Exception {  
  156.         if(pstmt == null) {  
  157.             return null;  
  158.         }  
  159.         ResultSet rs = pstmt.executeQuery();  
  160.         return rs;  
  161.     }  
  162.       
  163.     /** 
  164.      * @param rs 
  165.      * @return 
  166.      * @throws Exception 
  167.      */  
  168.     private List<Map<String, Object>> getQueryList(ResultSet rs) throws Exception {  
  169.         if(rs == null) {  
  170.             return null;  
  171.         }  
  172.         ResultSetMetaData rsMetaData = rs.getMetaData();  
  173.         int columnCount = rsMetaData.getColumnCount();  
  174.         List<Map<String, Object>> dataList = new ArrayList<Map<String, Object>>();  
  175.         while (rs.next()) {  
  176.             Map<String, Object> dataMap = new HashMap<String, Object>();  
  177.             for (int i = 0; i < columnCount; i++) {  
  178.                 dataMap.put(rsMetaData.getColumnName(i+1), rs.getObject(i+1));  
  179.             }  
  180.             dataList.add(dataMap);  
  181.         }  
  182.         return dataList;  
  183.     }  
  184.       
  185.     /** 
  186.      * 关闭数据库连接 
  187.      * @param conn 
  188.      */  
  189.     private void closeConn(Connection conn) {  
  190.         if(conn == null) {  
  191.             return;  
  192.         }  
  193.         try {  
  194.             conn.close();  
  195.         } catch (SQLException e) {  
  196.             //logger.info(e.getMessage());  
  197.         }  
  198.     }  
  199.       
  200.     /** 
  201.      * 关闭 
  202.      * @param stmt 
  203.      */  
  204.     private void closeStatement(Statement stmt) {  
  205.         if(stmt == null) {  
  206.             return;  
  207.         }  
  208.         try {  
  209.             stmt.close();  
  210.         } catch (SQLException e) {  
  211.             //logger.info(e.getMessage());  
  212.         }  
  213.     }  
  214.       
  215.     /** 
  216.      * 关闭 
  217.      * @param rs 
  218.      */  
  219.     private void closeResultSet(ResultSet rs) {  
  220.         if(rs == null) {  
  221.             return;  
  222.         }  
  223.         try {  
  224.             rs.close();  
  225.         } catch (SQLException e) {  
  226.             //logger.info(e.getMessage());  
  227.         }  
  228.     }  
  229.       
  230.       
  231.     private String jndiName = "java:/comp/env/jdbc/demoDB";  
  232.   
  233.     public void setJndiName(String jndiName) {  
  234.         this.jndiName = jndiName;  
  235.     }  
  236. } 

 

原文：http://kingxss.iteye.com/blog/1479451

文章标签：
云数据库 RDS MySQL 版
数据库连接
Java
SQL
关系型数据库
数据库
关键词：
jdbc连接池
jdbc配置
jdbc数据源
jdbc数据源连接池
jdbc实例
相关实践学习
如何在云端创建MySQL数据库
开始实验后，系统会自动创建一台自建MySQL的 源数据库 ECS 实例和一台 目标数据库 RDS。
全面了解阿里云能为你做什么
阿里云在全球各地部署高效节能的绿色数据中心，利用清洁计算为万物互联的新世界提供源源不断的能源动力，目前开服的区域包括中国（华北、华东、华南、香港）、新加坡、美国（美东、美西）、欧洲、中东、澳大利亚、日本。目前阿里云的产品涵盖弹性计算、数据库、存储与CDN、分析与搜索、云通信、网络、管理与监控、应用服务、互联网中间件、移动服务、视频服务等。通过本课程，来了解阿里云能够为你的业务带来哪些帮助 &nbsp; &nbsp; 相关的阿里云产品：云服务器ECS 云服务器 ECS（Elastic Compute Service）是一种弹性可伸缩的计算服务，助您降低 IT 成本，提升运维效率，使您更专注于核心业务创新。产品详情: https://www.aliyun.com/product/ecs
fbh
目录
相关文章
武子康
|
1月前
|
SQL 分布式计算 Java
大数据-96 Spark 集群 SparkSQL Scala编写SQL操作SparkSQL的数据源：JSON、CSV、JDBC、Hive
大数据-96 Spark 集群 SparkSQL Scala编写SQL操作SparkSQL的数据源：JSON、CSV、JDBC、Hive
武子康
35 0
游客j4mujezz7vm7y
|
2月前
|
存储 SQL 监控
5-6|jdbc连接池
5-6|jdbc连接池
游客j4mujezz7vm7y
32 0
小王老师呀
|
3月前
sharding-jdbc 兼容 MybatisPlus的动态数据源
【8月更文挑战第2天】要使 `Sharding-JDBC` 与 `MyBatisPlus` 的动态数据源兼容，需引入相关依赖，配置数据源及分库分表策略，并在 `MyBatisPlus` 中设置参数以协同工作。可能还需自定义代码处理数据源切换。示例代码框架展示整合方式，实际应用中需按具体业务场景详细配置并处理异常情况，如数据一致性问题。
小王老师呀
247 1
长梦
|
5月前
|
监控 Java 数据库连接
Java一分钟之-JDBC连接池：HikariCP, Apache DBCP, C3P0
【6月更文挑战第14天】本文介绍了Java中常用的三种JDBC连接池——HikariCP、Apache DBCP和C3P0。HikariCP以其高性能和低延迟领先，适合高并发环境；Apache DBCP稳定易配置；C3P0则提供高度可定制选项。文章讨论了各连接池的常见问题及避免策略，如配置不当、连接泄露等，并给出示例代码以供参考。选择合适的连接池并正确配置能有效提升应用性能。
长梦
120 7
yuanzhengme
|
6月前
|
Java 数据库连接 网络安全
springboot使用Pivotal Greenplum JDBC如何进行配置
【5月更文挑战第23天】springboot使用Pivotal Greenplum JDBC如何进行配置
yuanzhengme
178 6
杨校
|
5月前
|
缓存 监控 druid
对比各大数据库连接池技术-Jdbc-Dbcp-C3p0-Druid-Hikaricp
对比各大数据库连接池技术-Jdbc-Dbcp-C3p0-Druid-Hikaricp
杨校
72 0
杨校
|
5月前
|
SQL druid Java
JDBC、C3P0、DBCP、Druid 数据源连接池使用的对比总结.md2
JDBC、C3P0、DBCP、Druid 数据源连接池使用的对比总结.md
杨校
34 0
杨校
|
5月前
|
SQL druid Java
JDBC、C3P0、DBCP、Druid 数据源连接池使用的对比总结.md1
JDBC、C3P0、DBCP、Druid 数据源连接池使用的对比总结.md
杨校
58 0
JavaSouth南哥
|
6月前
|
设计模式 Java 数据库连接
【Spring源码】JDBC数据源访问实现
我们再来看看阅读线索三，这方面我们从设计模式进行入手。阅读线索三：从这个模块可以学到什么我们看下以下代码，PreparedStatement实例的是由PreparedStatementCreator实现的。再来看看PreparedStatementCreator接口，一共有三个子类实现。也就是说PreparedStatement的三种不同实现被封装到三个子类中，而具体需要哪种实现，只需要传入不同。
JavaSouth南哥
64 1
【Spring源码】JDBC数据源访问实现
飞翔的佩奇
|
6月前
|
前端开发 Java BI
Servlet+Jsp+JDBC实现房屋租赁管理系统（源码+数据库+论文+系统详细配置指导+ppt）
Servlet+Jsp+JDBC实现房屋租赁管理系统（源码+数据库+论文+系统详细配置指导+ppt）
飞翔的佩奇
93 0

热门文章

最新文章

  • 1
    报错：java.lang.ClassNotFoundException: com.mysql.cj.jdbc.Driver at java.base/jdk.internal.loader.Bui
  • 2
    Java -- JDBC 学习--通过 ResultSet 执行查询操作
  • 3
    JDBC操作MySQL5日期类型字段的问题解决方法
  • 4
    JDK6笔记（6）----JDBC4.0高级应用(2)
  • 5
    使用JDBC获取各数据库的Meta信息——表以及对应的列
  • 6
    logstash-input-jdbc实现mysql 与elasticsearch实时同步深入详解
  • 7
    JDBC 驱动升级到 Version 8.0.28 连接 MySQL 的踩坑记录
  • 8
    利用JDBC-ODBC驱动访问SQL SERVER2008
  • 9
    OAF_JDBC系列2 - 通过JDBC连接SQLSERVER数据库DriverManager.getConnection
  • 10
    JDBC调用MySQL5存储过程
  • 1
    实时计算 Flink版产品使用合集之将sdkMode从rpc模式改为jdbc模式后，table.exec.mini-batch.enabled参数还生效吗
    57
  • 2
    WARNING: Too Many Parse Errors With error=911 When Running a JDBC Application Connected to an Oracle 19c database
    91
  • 3
    JDBC的连接参数的设置导致rowid自动添加到sql
    52
  • 4
    【服务器】python通过JDBC连接到位于Linux远程服务器上的Oracle数据库
    78
  • 5
    零基础轻松入门Java数据库连接（JDBC）
    61
  • 6
    c.t.t.handler.GlobalExceptionHandler : 捕获异常：org.springframework.jdbc.BadSqlGrammarException:
    51
  • 7
    JDBC编程
    49
  • 8
    JDBC Java标准库提供的一些api(类+方法) 统一各种数据库提供的api
    51
  • 9
    Scala应用 —— JDBC的创建
    74
  • 10
    Springboot框架整合Spring JDBC操作数据
    71

    • 相关课程

    更多
  • JDBC数据库开发入门
  • JDBC数据库开发进阶

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    阿里云OSS设置跨域访问