个人学习参考所用，勿喷！

使用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表：

  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代码如下：

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

mysql数据库连接的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. Connection conn = DriverManager.getConnection(url, user, password);
  12. Statement stmt = conn.createStatement();
  13. String sql = "select * from user";
  14. ResultSet rs = stmt.executeQuery(sql);
  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.使用配置数据源的方式连接数据库，该方式其实质就是在上述方法的基础上增加了数据库连接池，这种方式效率高。

1）mysql数据库数据源连接池的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. Statement stmt = conn.createStatement();
  10. String sql = "select * from user";
  11. ResultSet rs = stmt.executeQuery(sql);
  12. while(rs.next()) {
  13. out.print("<br />" + "====================" + "<br />");
  14. out.print(rs.getLong("id") + "   ");
  15. out.print(rs.getString("username") + "   ");
  16. out.print(rs.getString("password") + "   ");
  17. out.print(rs.getString("email") + "   ");
  18. }
  19. %>
  20. </body>
  21. </html>

2） 添加如下代码到tomcat的conf目录下的server.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的根节点下配置如下内容：

  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中（这个文件需要自行建立）：

  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.使用配置数据源的数据库连接池时的数据库操作工具类

代码如下：

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

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

JDBC数据源连接池的配置和使用实例的更多相关文章

  1. springboot添加多数据源连接池并配置Mybatis

    springboot添加多数据源连接池并配置Mybatis 转载请注明出处:https://www.cnblogs.com/funnyzpc/p/9190226.html May 12, 2018  ...

  2. JDBC数据源连接池(4)---自定义数据源连接池

    [续上文<JDBC数据源连接池(3)---Tomcat集成DBCP>] 我们已经 了解了DBCP,C3P0,以及Tomcat内置的数据源连接池,那么,这些数据源连接池是如何实现的呢?为了究 ...

  3. JDBC数据源连接池(3)---Tomcat集成DBCP

    此文续<JDBC数据源连接池(2)---C3P0>. Apache Tomcat作为一款JavaWeb服务器,内置了DBCP数据源连接池.在使用中,只要进行相应配置即可. 首先,确保Web ...

  4. JDBC数据源连接池(2)---C3P0

    我们接着<JDBC数据源连接池(1)---DBCP>继续介绍数据源连接池. 首先,在Web项目的WebContent--->WEB-INF--->lib文件夹中添加C3P0的j ...

  5. JDBC数据源连接池(1)---DBCP

    何为数据源呢?也就是数据的来源.我在前面的一篇文章<JDBC原生数据库连接>中,采用了mysql数据库,数据来源于mysql,那么mysql就是一种数据源.在实际工作中,除了mysql,往 ...

  6. Spring+Tomcat的JNDI数据源连接池简单配置

    使用Tomcat JNDI数据源与Spring一起使用步骤如下: 1.将数据库驱动复制到Tomcat的lib文件夹下面 2.配置Tomcat的server.xml配置文件,在GlobalNamingR ...

  7. JavaWeb之数据源连接池(4)---自定义数据源连接池

    [续上文<JavaWeb之数据源连接池(3)---Tomcat>] 我们已经 了解了DBCP,C3P0,以及Tomcat内置的数据源连接池,那么,这些数据源连接池是如何实现的呢?为了究其原 ...

  8. JavaWeb之数据源连接池(3)---Tomcat

    此文续 <JavaWeb之数据源连接池(2)---C3P0>. Apache Tomcat作为一款JavaWeb服务器,内置了DBCP数据源连接池.在使用中,只要进行相应配置即可. 首先, ...

  9. JavaWeb之数据源连接池(2)---C3P0

    我们接着<JavaWeb之数据源连接池(1)---DBCP>继续介绍数据源连接池. 首先,在Web项目的WebContent--->WEB-INF--->lib文件夹中添加C3 ...

随机推荐

  1. SQL Server分区动态生成脚本（三）（按年份划分）

    --生成分区脚本DECLARE @DataBaseName NVARCHAR(50)--数据库名称DECLARE @TableName NVARCHAR(50)--表名称DECLARE @Column ...

  2. a标签的 target 使用

    <a target="_blank" href="www.baidu.com" onclick="return test()"> ...

  3. SVN管理工具Cornerstone之：创建分支、提交合并

      创建工程的分支: 步骤: 1.选择左下角仓库repositories中的工程名->选择trunk->点击Branch->在提示框里填写分支名称create, 2.在做上角work ...

  4. [Android] hid设备按键流程简述

    hexdump /dev/hidraw0就能看到usbhid设备传输过来的裸流 如:按下Input键 003ae60 0000 0096 8000 006b 0000 0000 0000 0000 * ...

  5. 三个QT咨询公司以及QT5.0的主要特点

    三个咨询公司(他们也贡献代码):http://www.kdab.com/http://v-play.net/http://www.ics.com/qt 一个论坛:http://forum.qt.io/ ...

  6. org.elasticsearch.bootstrap : JNA not found. native methods will be disabled

    在pom.xml中添加以下依赖,解决elasticsearch的WARN: <dependency> <groupId>com.sun.jna</groupId> ...

  7. BZOJ1660: [Usaco2006 Nov]Bad Hair Day 乱发节

    1660: [Usaco2006 Nov]Bad Hair Day 乱发节 Time Limit: 2 Sec  Memory Limit: 64 MBSubmit: 606  Solved: 289 ...

  8. JavaScript AMD 模块加载器原理与实现

    关于前端模块化,玉伯在其博文 前端模块化开发的价值 中有论述,有兴趣的同学可以去阅读一下. 1. 模块加载器 模块加载器目前比较流行的有 Requirejs 和 Seajs.前者遵循 AMD规范,后者 ...

  9. -_-#【Canvas】绘制文本

    <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title> ...

  10. 【动态规划】XMU 1030 苦恼的月下老人

    题目链接: http://acm.xmu.edu.cn/JudgeOnline/problem.php?id=1030 题目大意: 给定两个字符串的长度和内容,求最长公共子序列. 题目思路: [动态规 ...