global=“jdbc/ens” 中的参数值(“jdbc/ens”)必须和上一段配置中的name属性的值保持一样。name=“jdbc/ens” 这个可以随便取,但是在程序中调用的时候,就应该与name的值保持一致。到这里,连接池已经配置好啦。

用JSP测试一下：

<%@ page language="java" pageEncoding="gbk"%>
<%@page import="java.sql.Connection"%>
<%@page import="javax.naming.Context"%>
<%@page import="javax.naming.InitialContext"%>
<%@page import="javax.sql.DataSource"%>
<%@page import="java.sql.Statement"%>
<%@page import="java.sql.ResultSet"%>
<%
   //连接池的获取
    Connection conn = null;
    DataSource ds = null;
    ResultSet rs  =null;
    Statement stmt = null;
    Context initCtx = new InitialContext();
    ds =(DataSource)initCtx.lookup("java:comp/env/jdbc/ens");
   if(ds!=null){
        out.println("已经获得DataSource!"); 
        out.println("<br>");
        conn = ds.getConnection();
       try{
        stmt = conn.createStatement();
        String sql ="select * from ens_area";
        rs = stmt.executeQuery(sql);
        out.println("以下是从数据库中读取出来的数据:<br>");
            while(rs.next()){
                out.println("<br>");
                out.println(rs.getString("area_name"));
            }
       }catch(Exception ex){
         ex.printStackTrace();
       }finally{
          conn.close();
          rs.close();
          stmt.close();
       }
   }
%>

方法六

Tomcat7 新的数据库连接池Tomcat jdbc pool

Tomcat 在 7.0 以前的版本都是使用commons-dbcp做为连接池的实现，但是 dbcp存在一些问题： 
（1）dbcp 是单线程的，为了保证线程安全会锁整个连接池 
（2）dbcp 性能不佳 
（3）dbcp 太复杂，超过 60 个类，发展滞后。 
因此，通常J2EE中还会使用其它的高性能连接池，如 C3P0，还有阿里系的 druid 等。为此，Tomcat 从 7.0 开始引入一个新的模块： Tomcat jdbc pool 
tomcat jdbc pool 近乎兼容 dbcp ，性能更高 
异步方式获取连接 
tomcat jdbc pool 是 tomcat 的一个模块，基于 tomcat JULI，使用 Tomcat 的日志框架 
使用 javax.sql.PooledConnection 接口获取连接 
支持高并发应用环境 
超简单，核心文件只有8个，比 c3p0 还少 
更好的空闲连接处理机制 
支持 JMX 
支持 XA Connection。 
tomcat jdbc pool 可在 Tomcat 中直接使用，也可以在独立的应用中使用。

1.web项目中中直接使用的方法： 

在META-INF/context.xml下的节点里配置resource，例如：

<Resource name="jdbc/TestDB"
      auth="Container"
      type="javax.sql.DataSource"
      factory="org.apache.tomcat.jdbc.pool.DataSourceFactory"
      testWhileIdle="true"
      testOnBorrow="true"
      testOnReturn="false"
      validationInterval="30000"
      timeBetweenEvictionRunsMillis="30000"
      maxActive="100"
      minIdle="10"
      maxWait="10000"
      initialSize="10"
      removeAbandonedTimeout="60"
      removeAbandoned="true"
      logAbandoned="true"
      minEvictableIdleTimeMillis="30000"
      jmxEnabled="true"
      jdbcInterceptors=
"org.apache.tomcat.jdbc.pool.interceptor.ConnectionState;org.apache.tomcat.jdbc.pool.interceptor.StatementFinalizer"
      username="root"
      password="123"
      driverClassName="com.mysql.jdbc.Driver"
      url="jdbc:mysql://localhost:3306/ens"/>

然后，在WEB-INF/web.xml文件的节点中添加如下配置：

</resource-ref>
    <resource-ref>
    <description>DB_Connection</description>
    <res-ref-name>jdbc/TestDB</res-ref-name>
    <res-type>javax.sql.DataSource</res-type>
    <res-auth>Container</res-auth>
  </resource-ref>

这个可以随便取,但是在程序中调用的时候,就应该与name的值保持一致。到这里,连接池已经配置好啦。

方法七为单个web项目配置数据池

1 配置连接池

   将以下内容保存为context.xml，放在web项目下的META-INF文件夹下：

[html] 

 view plain
 
  copy![在CODE上查看代码片](https://code.csdn.net/assets/CODE_ico.png)
 
 ![派生到我的代码片](https://code.csdn.net/assets/ico_fork.svg)

4. <Resource name=“jdbc/test”
5. auth=“Container”
6. type=“javax.sql.DataSource”
7. factory=“org.apache.tomcat.jdbc.pool.DataSourceFactory”
8. maxActive=“100” //最大激活连接
9. maxIdle=“30”   //最大空闲连接
10. maxWait=“1000”  //最大等待数
11. username=“test”  //数据库用户名
12. password=“testtest” //数据库密码
13. driverClassName=“com.mysql.jdbc.Driver” //此处使用mysql数据库，请自行修改驱动
14. url=“jdbc:mysql://localhost:3306/test?characterEncoding=UTF-8” />   //test为数据库名，编码为UTF-8

2.项目中web.xml中引用连接池

 DB_Connection
    jdbc/TestDB
    javax.sql.DataSource
    Container
   

 3 代码中引用连接池 

[java] 

 view plain
 
  copy![在CODE上查看代码片](https://code.csdn.net/assets/CODE_ico.png)
 
 ![派生到我的代码片](https://code.csdn.net/assets/ico_fork.svg)

1. package com.hrb2c.servlet;

2. import java.io.IOException;

3. import java.io.PrintWriter;

4. import java.sql.Connection;

5. import java.sql.ResultSet;

6. import java.sql.SQLException;

7. import java.sql.Statement;

8. import java.util.concurrent.Future;

9. import javax.naming.Context;

10. import javax.naming.InitialContext;

11. import javax.naming.NamingException;

12. import javax.servlet.ServletException;

13. import javax.servlet.annotation.WebServlet;

14. import javax.servlet.http.HttpServlet;

15. import javax.servlet.http.HttpServletRequest;

16. import javax.servlet.http.HttpServletResponse;

17. import org.apache.tomcat.jdbc.pool.DataSource;

18. /**

19. * 数据库连接池

21. * @author Yuedong Li

23. */

24. @WebServlet("/ConnPoolTest")

25. public class ConnPoolTest extends HttpServlet {

26. private static final long serialVersionUID = 1L;

27. private Connection con = null;

28. private static DataSource datasource;

29. /**

30. * @see HttpServlet#HttpServlet()

31. */

32. public ConnPoolTest() {

33. super();

34. try {

35. //获取数据源

36. datasource = getInstance();

37. //连接池同步

38. Future future = datasource.getConnectionAsync();

39. while (!future.isDone()) {

40. // 等待连接池同步

41. Thread.sleep(100);

42. }

43. // 获取连接池

44. con = future.get();

45. } catch (Exception e) {

46. e.printStackTrace();

47. }

48. }

49. /**

50. * 单例模式获取数据源

51. * @return

52. * @throws NamingException

53. */

54. private DataSource getInstance() throws NamingException {

55. if (datasource == null) {

56. Context initContext = new InitialContext();

57. Context envContext = (Context) initContext.lookup(“java:/comp/env”);

58. datasource = (DataSource) envContext.lookup(“jdbc/test”);

59. }

60. return datasource;

61. }

62. /**

63. * 处理get方法

64. */

65. protected void doGet(HttpServletRequest request,

66. HttpServletResponse response) throws ServletException, IOException {

67. doPost(request, response);

68. }

69. /**

70. * 处理post方法

71. */

72. protected void doPost(HttpServletRequest request,

73. HttpServletResponse response) throws ServletException, IOException {

74. Statement st;

75. StringBuffer buff = new StringBuffer("");

76. try {

77. if (con != null) {

78. //简单查询，test表中有2列，id与name

79. buff.append(“id”);

80. buff.append("  “);

81. buff.append(“name”);

82. buff.append("
    ”);

83. st = con.createStatement();

84. ResultSet rs = st.executeQuery(“select * from test”);

85. while (rs.next()) {

86. buff.append(rs.getString(“id”));

87. buff.append("  “);

88. buff.append(rs.getString(“name”));

89. buff.append("
    ”);

90. }

91. }

92. buff.append("");

93. } catch (SQLException e) {

94. e.printStackTrace();

95. }

96. PrintWriter out = response.getWriter();

97. out.write(buff.toString());

98. }

99. }