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

使用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. 完整的struts.xml文件骨架

    完整的struts.xml文件骨架可以直接拿来用,修改一下就可以啦. <?xml version="1.0" encoding="UTF-8"?> ...

  2. 报错：tr was not declared in this scope

    报错代码如下: label->setText(tr("您好,Qt5.5.0!")); 修改为: label->setText(QObject::tr("您好, ...

  3. 【细说Java】方法重载的简单介绍

    1. 什么是重载 方法名称相同,但它们的参数类型或个数不同,这样,方法在被调用时编译器就可以根据参数的类型与个数的不同加以区分,这就是方法的重载. 既然可以通过参数类型或参数个数来作为重载条件,那返回 ...

  4. （转载）php的类中可以不定义成员变量，直接在构造方法中使用并赋值吗？

    (转载)http://s.yanghao.org/program/viewdetail.php?i=184313 php的类中可以不定义成员变量,直接在构造方法中使用并赋值吗? class block ...

  5. Delphi 多线程的操作

    Delphi 操作多线程的代码, 在项目中需要在webservice中使用多线程,程序思想如下: 1.就创建一个线程, 也就是说有两个线程,主线程和创建的线程, 主线程用于程序的别的操作,例如停止服务 ...

  6. Android中bitmap的相关处理

    加载大图片 Options options=new Options(); options.inJustDecodeBounds=true;//不加载图片,只加载文件信息 //加载图片,获取到配置信息 ...

  7. Java学习日记-7 抽象类和接口

    一.抽象类 abstract修饰:类和类中的方法 抽象方法:abstract type name(parameter-list);(abstract不能修饰static方法和构造函数) 引用:抽象类有 ...

  8. Spring JDBC 随笔

    Spring 框架,借助 JdbcTemplate 类来简化 java 访问 database. 完成一个增查改删(CRUD)的基本功能,借助下面 5 个角色来共同来完成. 1. object cla ...

  9. 几何学中的欧拉公式：V-E+F = 2

    几何学中的欧拉公式:V-E+F = 2,V.E.F表示简单几何体的顶点数.边数.面数. 证明: 它的证明有多种,这里呈现一种递归证法. 对于任意简单几何体(几何体的边界不是曲线),我们考察这个几何体的 ...

  10. atol字符串转换函数应用实例

    原型:long atol(const char *nptr); 相关函数 atoi,atol,strtod,strtol,strtoul 头文件:stdlib.h 功能:将字符串转换成整型数 说明:参 ...