扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > Python >Java中几种常用数据库连接池的使用
  • 479

0
分享到

Java中几种常用数据库连接池的使用

2024-04-02 19:04:59 479人浏览 泡泡鱼

Python 官方文档：入门教程 => 点击学习

摘要

目录一、应用程序直接获取数据库连接的缺点二、使用数据库连接池优化程序性能2.1、数据库连接池的基本概念2.2、编写数据库连接池三、开源数据库连接池3.1、DBCP数据源3.2、在应用

一、应用程序直接获取数据库连接的缺点

　　用户每次请求都需要向数据库获得链接，而数据库创建连接通常需要消耗相对较大的资源，创建时间也较长。假设网站一天10万访问量，数据库服务器就需要创建10万次连接，极大的浪费数据库的资源，并且极易造成数据库服务器内存溢出、拓机。如下图所示：

二、使用数据库连接池优化程序性能

2.1、数据库连接池的基本概念

　　数据库连接是一种关键的有限的昂贵的资源,这一点在多用户的网页应用程序中体现的尤为突出.对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性,影响到程序的性能指标.数据库连接池正式针对这个问题提出来的.数据库连接池负责分配,管理和释放数据库连接,它允许应用程序重复使用一个现有的数据库连接,而不是重新建立一个。如下图所示：

       数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中, 这些数据库连接的数量是由最小数据库连接数来设定的.无论这些数据库连接是否被使用,连接池都将一直保证至少拥有这么多的连接数量.连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数,当应用程序向连接池请求的连接数超过最大连接数量时,这些请求将被加入到等待队列中.

       数据库连接池的最小连接数和最大连接数的设置要考虑到以下几个因素:

  • 最小连接数:是连接池一直保持的数据库连接,所以如果应用程序对数据库连接的使用量不大,将会有大量的数据库连接资源被浪费.
  • 最大连接数:是连接池能申请的最大连接数,如果数据库连接请求超过次数,后面的数据库连接请求将被加入到等待队列中,这会影响以后的数据库操作
  • 如果最小连接数与最大连接数相差很大:那么最先连接请求将会获利,之后超过最小连接数量的连接请求等价于建立一个新的数据库连接.不过,这些大于最小连接数的数据库连接在使用完不会马上被释放,他将被放到连接池中等待重复使用或是空间超时后被释放.

2.2、编写数据库连接池

　　编写连接池需实现java.sql.DataSource接口。DataSource接口中定义了两个重载的getConnection方法：

  • Connection getConnection()
  • Connection getConnection(String username, String passWord)

　　实现DataSource接口，并实现连接池功能的步骤：

  • 在DataSource构造函数中批量创建与数据库的连接，并把创建的连接加入LinkedList对象中。
  • 实现getConnection方法，让getConnection方法每次调用时，从LinkedList中取一个Connection返回给用户。
  • 当用户使用完Connection，调用Connection.close()方法时，Collection对象应保证将自己返回到LinkedList中,而不要把conn还给数据库。Collection保证将自己返回到LinkedList中是此处编程的难点。

 数据库连接池核心代码

　　使用动态代理技术构建连接池中的connection

 JdbcPool.java:

大致思路：1、读取配置文件，将属性值取出

                   2、注册jdbc驱动

                   3、通过数据库连接数和驱动管理器获得相应连接（.getConnection()）,因为DataSource是接口，所以这个方法需要                           我们手动实现

                   4、重点：实现getConnection()方法

                          思考：当外部有连接需求时，直接从connectList拿出一个connect，就实现了这个方法，但是我们再想想，它用完了怎么回收呢，确实，有close()方法，但是这个方法作用是将这个连接还给数据库，而不是数据库连接池，这样会导致数据库连接池中 的连接越来越少，这样可不行，但是我们也不能影响它的正常使用吧，在这种情况下，我们想要监测这个连接对象的动态，在它调用close()方法时，我们将其再添加进connectList,这样连接池中的连接不就没少了吗，在java中对于监听一个对象的动态，最常用也最实用的便是动态代理，对于动态代理，其实我们可以把它想象成就是一个大盒子，里面装着一个真实对象小盒子，这就在大盒子和小盒子间形成了一个横切空隙，而真实做事的还是这个对象，代理只是个接活的，接到活就给内部的小盒子干，自然这个空隙可以用来监测真实对象的事务，也就是监听对象的方法。具体可以看看这个，动态代理：https://www.jb51.net/article/213416.htm


package jdbcPoolTest;
 
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.LinkedList;
import java.util.Properties;
import java.util.logging.Logger;
 
import javax.sql.DataSource;
 
import org.omg.PortableServer.POA;
 
public class JdbcPool implements DataSource{
	
	
	private static LinkedList<Connection> listConnections = new LinkedList<>();
	
	static {
		//静态代码块中加载db.properties配置文件
		InputStream in = JdbcPool.class.getClassLoader().getResourceAsStream("db.properties");
		
		Properties prop = new Properties();
		try {
			//读取文件内容
			prop.load(in);
			String driver = prop.getProperty("driver");
			String url = prop.getProperty("url");
			String username = prop.getProperty("username");
			String password = prop.getProperty("password");
			
			//数据库连接池的初始化连接大小
			int jdbcPoolInitSize = Integer.parseInt(prop.getProperty("jdbcPoolInitSize"));
			//加载数据库驱动		
			Class.forName(driver);	
			for(int i=0; i<jdbcPoolInitSize; i++) {
			//获取连接	
			Connection conn = DriverManager.getConnection(url, username, password);
			System.out.println("获取连接："+conn);
			//将conn连接加入listConnections集合中，此时的listConnections就是一个连接池
			listConnections.add(conn);
			
				
			}
			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		
		
	}
 
	@Override
	public Connection getConnection() throws SQLException {
		// TODO Auto-generated method stub
		//如果数据库连接池的连接数大于0
		System.out.println("进来了");
		if (listConnections.size()>0) {
			//从listConnections中获取一个连接
			final Connection conn = listConnections.removeFirst();
			System.out.println("数据库连接池的大小为："+listConnections.size());
			//返回Connection的代理，利用代理可以处理一些横切事件
			System.out.println("取出的连接为："+conn);
			return (Connection) Proxy.newProxyInstance(JdbcPool.class.getClassLoader(), conn.getClass().getInterfaces(), new InvocationHandler() {
				
				@Override
				public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
					// TODO Auto-generated method stub
					//如果不是执行关闭操作，则通过反射执行相应方法
					if (!method.getName().equals("close")) {
												
						return method.invoke(conn, args);
						
					}else {
						//否则，将conn归还给连接池
						listConnections.add(conn);
						System.out.println("归还连接："+conn);
						System.out.println("连接池大小为："+listConnections.size());
						return null;
					}
					
				}
			});
			
		}else {
			throw new RuntimeException("对不起，数据库正忙");
		}
		
	}
	@Override
	public PrintWriter getLogWriter() throws SQLException {
		// TODO Auto-generated method stub
		return null;
	}
 
	@Override
	public int getLoginTimeout() throws SQLException {
		// TODO Auto-generated method stub
		return 0;
	}
 
	@Override
	public Logger getParentLogger() throws SQLFeatureNotSupportedException {
		// TODO Auto-generated method stub
		return null;
	}
 
	@Override
	public void setLogWriter(PrintWriter arg0) throws SQLException {
		// TODO Auto-generated method stub
		
	}
 
	@Override
	public void setLoginTimeout(int arg0) throws SQLException {
		// TODO Auto-generated method stub
		
	}
 
	@Override
	public boolean isWrapperFor(Class<?> arg0) throws SQLException {
		// TODO Auto-generated method stub
		return false;
	}
 
	@Override
	public <T> T unwrap(Class<T> arg0) throws SQLException {
		// TODO Auto-generated method stub
		return null;
	}
 
	
 
	@Override
	public Connection getConnection(String username, String password) throws SQLException {
		// TODO Auto-generated method stub
		return null;
	}
 
}

写一个JdbcUtil测试数据库连接池


package jdbcPoolTest;
 
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
 
public class JdbcUtil {
 
	
	private static JdbcPool jdbcPool = new JdbcPool();
	
	public static Connection getConnection() throws SQLException {
		
		return jdbcPool.getConnection();
		
	}
	//释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象
	public static void release(Connection conn,Statement st ,ResultSet rs) {
		if (conn!=null) {
			try {
				conn.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		if (st!=null) {
			try {
				st.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		if (rs!=null) {
			try {
				rs.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			rs = null;
		}
	}
}

 db.properties配置文件如下：


driver=com.Mysql.jdbc.Driver
 url=jdbc:mysql://localhost:3306/student
 username=root
 password=123456
 jdbcPoolInitSize=10

三、开源数据库连接池

　　现在很多WEB服务器(Weblogic, WebSphere, Tomcat)都提供了DataSoruce的实现，即连接池的实现。通常我们把DataSource的实现，按其英文含义称之为数据源，数据源中都包含了数据库连接池的实现。
　　也有一些开源组织提供了数据源的独立实现：

  • DBCP 数据库连接池
  • C3P0 数据库连接池

　　在使用了数据库连接池之后，在项目的实际开发中就不需要编写连接数据库的代码了，直接从数据源获得数据库的连接。

3.1、DBCP数据源

　　DBCP 是 Apache 软件基金组织下的开源连接池实现，要使用DBCP数据源，需要应用程序应在系统中增加如下两个 jar 文件：

  • Commons-dbcp.jar：连接池的实现
  • Commons-pool.jar：连接池实现的依赖库

　　Tomcat 的连接池正是采用该连接池来实现的。该数据库连接池既可以与应用服务器整合使用，也可由应用程序独立使用。

3.2、在应用程序中加入dbcp连接池

　　1.导入相关jar包
   　　   commons-dbcp-1.2.2.jar、commons-pool.jar、common-logging.jar三个包
　　2、在类目录下加入dbcp的配置文件：dbcpconfig.properties

用了官方的连接池，自然配置文件内容也就多了

dbcpconfig.properties的配置信息如下：

 注意这段：

#driver default 指定由连接池所创建的连接的只读（read-only）状态。
 #如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：InfORMix）
 defaultReadOnly=

如果设置为ture,那就只能进行查询操作


#连接设置   报错com.mysql.jdbc.Connection.isValid(I)Z,更新mysql包
driverClassName=com.mysql.jdbc.Driver
 url=jdbc:mysql://localhost:3306/student
 username=root
 password=123456
 #初始化连接池大小
 jdbcPoolInitSize=10
 #最大连接数量
 maxActive=50
 
 #<!-- 最大空闲连接 -->
 maxIdle=20
 
 #<!-- 最小空闲连接 -->
 minIdle=5
 
 #<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
 maxWait=60000
 
 
 #JDBC驱动建立连接时附带的连接属性的格式必须为这样：[属性名=property;] 
 #注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。
 connectionProperties=useUnicode=true;characterEncoding=UTF8
 
 #指定由连接池所创建的连接的自动提交（auto-commit）状态。
 defaultAutoCommit=true
 
 #driver default 指定由连接池所创建的连接的只读（read-only）状态。
 #如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix）
 defaultReadOnly=
 
 #driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。
 #可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
 defaultTransactionIsolation=READ_UNCOMMITTED

包结构： 

jdbcUtils_DBCP：

大致思路：

1、从配置文件中获取输入流，进行加载

2、有了BasicDataSoureFactory,那我们也不需要将配置文件中的属性值一个一个读取出来了，它有个方法createDataSource（）能自动获取到数据源 

3、接下来只需要拿着这个数据源对象ds去获取连接了，具体如何连接，就不需要我们关心，大致思路与我们自行编写连接池类似，只不过多了些其他属性的出来方法。从而简化了我们的开发


package zdb.jdbc.util;
 
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
 
import javax.sql.DataSource;
 
import org.apache.commons.dbcp2.BasicDataSourceFactory;
 
 
public class jdbcUtils_DBCP {
 
	
	private  static DataSource ds = null;
	
	
	static {
	InputStream in = jdbcUtils_DBCP.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");
	Properties prop = new Properties();
	try {
		prop.load(in);
		//创建数据源
		ds = BasicDataSourceFactory.createDataSource(prop);	 
		
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	catch (Exception e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	}
	public static Connection getConnection() throws SQLException{
		return ds.getConnection();
		
	}
	//释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象
	public static void release(Connection conn,PreparedStatement ps ,ResultSet rs) {
		if (conn!=null) {
			try {
				conn.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		if (ps!=null) {
			try {
				ps.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		if (rs!=null) {
			try {
				rs.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			rs = null;
		}
	}
	
}

接下来我们通过在表中插入属性值来测试--DataSourceTest： 

注意这段：

//由于包版本问题：必须加上PreparedStatement.RETURN_GENERATED_KEYS，不然将会报主键错误
 ps = conn.prepareStatement(sql,PreparedStatement.RETURN_GENERATED_KEYS);


package zdb.jdbc.util;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
 
 
import javafx.CSS.PseudoClass;
 
public class DataSourceTest {
	 
	public static void jdbcDataSource() {
		
		PreparedStatement ps = null;
		ResultSet rs = null;
		Connection conn = null;
		try {
			//conn = jdbcUtils_DBCP.getConnection();
			conn = jdbcUtils_DBCP.getConnection();
			String sql = "insert into user(uname) values(?)";
			//由于版本兼容问题：必须加上PreparedStatement.RETURN_GENERATED_KEYS
			ps = conn.prepareStatement(sql,PreparedStatement.RETURN_GENERATED_KEYS);
			ps.setString(1, "lonewolf");
			ps.executeUpdate();
			//获得主键
			rs = ps.getGeneratedKeys();
			if (rs.next()) {
				System.out.println(rs.getInt(1));
			}
		} catch (SQLException e) {
			// TODO Auto-generated catch blockrs
			e.printStackTrace();
		}
			finally {
			jdbcUtils_DBCP.release(conn, ps, rs);
			//jdbcUtils_C3P0.release(conn, ps, rs);
		}
		
		
		
	}
 
	public static void main(String[] args) {
		new DataSourceTest().jdbcDataSource();
	}
	
	
}

3.3、C3P0数据源（重点）

　　C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate，Spring等。C3P0数据源在项目开发中使用得比较多。

　　c3p0与dbcp区别

dbcp默认不自动回收空闲连接，需要手动开启c3p0默认自动回收空闲连接功能3.4、在应用程序中加入C3P0连接池

　　1.导入相关jar包
    　　　c3p0-0.9.5.2.jar、mchange-commons-java-0.2.12jar，如果操作的是oracle数据库，那么还需要导入c3p0-oracle-thin-extras-0.9.2-pre1.jar

注意：导入包时，两个包的版本也是需要匹配的

不然会报错：Exception in thread "main" java.lang.NoClassDefFoundError: com/mchange/v2/ser/Indirector

但是这两个包版本是匹配的，下载链接c3p0_jar_jb51.rar

       2、包结构：


3、在类目录下加入C3P0的配置文件：c3p0-config.xml，即在项目根目录下读取文件

c3p0-config.xml的配置信息如下：

注意：配置文件中有两种内容相似的配置，一种缺省配置，意思是在没有指定配置文件名时，调用该配置，一种命名配置，也就是在使用配置文件时，加上配置名即可引用，如接下来会说的：new ComboPooledDataSource("MySQL");


<c3p0-config>
     <!--
     C3P0的缺省(默认)配置，
     如果在代码中“ComboPooledDataSource ds = new ComboPooledDataSource();”这样写就表示使用的是C3P0的缺省(默认)配置信息来创建数据源
     -->
     <default-config>
         <property name="driverClass">com.mysql.jdbc.Driver</property>
         <property name="jdbcUrl">jdbc:mysql://localhost:3306/student</property>
         <property name="user">root</property>
         <property name="password">123456</property>
         
         <property name="acquireIncrement">5</property>
         <property name="initialPoolSize">10</property>
         <property name="minPoolSize">5</property>
         <property name="maxPoolSize">20</property>
     </default-config>
 
     <!--
     C3P0的命名配置，
     如果在代码中“ComboPooledDataSource ds = new ComboPooledDataSource("MySQL");”这样写就表示使用的是name是MySQL的配置信息来创建数据源
     -->
     <named-config name="MySQL">
         <property name="driverClass">com.mysql.jdbc.Driver</property>
         <property name="jdbcUrl">jdbc:mysql://localhost:3306/student</property>
         <property name="user">root</property>
         <property name="password">123456</property>
         
         <property name="acquireIncrement">5</property>
         <property name="initialPoolSize">10</property>
         <property name="minPoolSize">5</property>
         <property name="maxPoolSize">20</property>
     </named-config>
 
 </c3p0-config>

jdbcUtils_C3P0：

大致思路：

 我们可以通过代码看到，c3p0将我们的代码量又缩减了许多

ComboPooledDataSource ds = new ComboPooledDataSource("MySQL");我们直接new一个ComboPooledDataSource(）对象就可以获得数据源，所以这就是为什么之前需要将xml配置文件放在根目录下，“MySQL”就是我们的配置的名字


package zdb.jdbc.util;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
 
import com.mchange.v2.c3p0.ComboPooledDataSource;
 
public class jdbcUtils_C3P0 {
	
	private static ComboPooledDataSource ds = null;
	static {
		ds = new ComboPooledDataSource("MySQL");
		
	}
	public static Connection getConnection() throws SQLException{
	    //从数据源中获取数据库连接
	    return ds.getConnection();
}
	//释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象
		public static void release(Connection conn,PreparedStatement ps ,ResultSet rs) {
			if (conn!=null) {
				try {
					conn.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if (ps!=null) {
				try {
					ps.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if (rs!=null) {
				try {
					rs.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				rs = null;
			}
		}
 
}

 测试C3P0数据源-DataSourceTest


package zdb.jdbc.util;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
 
 
import javafx.css.PseudoClass;
 
public class DataSourceTest {
	 
	public static void jdbcDataSource() {
		
		PreparedStatement ps = null;
		ResultSet rs = null;
		Connection conn = null;
		try {
			//conn = jdbcUtils_DBCP.getConnection();
			conn = jdbcUtils_C3P0.getConnection();
			String sql = "insert into user(uname) values(?)";
			//由于版本兼容问题：必须加上PreparedStatement.RETURN_GENERATED_KEYS
			ps = conn.prepareStatement(sql,PreparedStatement.RETURN_GENERATED_KEYS);
			ps.setString(1, "lonewolf");
			ps.executeUpdate();
			//获得主键
			rs = ps.getGeneratedKeys();
			if (rs.next()) {
				System.out.println(rs.getInt(1));
			}
		} catch (SQLException e) {
			// TODO Auto-generated catch blockrs
			e.printStackTrace();
		}
			finally {
			jdbcUtils_DBCP.release(conn, ps, rs);
			//jdbcUtils_C3P0.release(conn, ps, rs);
		}
		
		
		
	}
 
	public static void main(String[] args) {
		new DataSourceTest().jdbcDataSource();
	}
	
	
}

这些便是数据库连接池的大致内容。

接下来说说

四、Tomcat中配置数据库源

在实际开发中，我们有时候还会使用服务器提供给我们的数据库连接池，比如我们希望Tomcat服务器在启动的时候可以帮我们创建一个数据库连接池，那么我们在应用程序中就不需要手动去创建数据库连接池，直接使用Tomcat服务器创建好的数据库连接池即可。要想让Tomcat服务器在启动的时候帮我们创建一个数据库连接池，那么需要简单配置一下Tomcat服务器。

4.1、JNDI技术简介

　　JNDI(Java Naming and Directory Interface)，Java命名和目录接口，它对应于J2SE中的javax.naming包，
　　这 套API的主要作用在于：它可以把Java对象放在一个容器中（JNDI容器），并为容器中的java对象取一个名称，以后程序想获得Java对象，只需 通过名称检索即可。其核心API为Context，它代表JNDI容器，其lookup方法为检索容器中对应名称的对象。

　　Tomcat服务器创建的数据源是以JNDI资源的形式发布的，所以说在Tomat服务器中配置一个数据源实际上就是在配置一个JNDI资源

服务器创建好数据源之后，我们的应用程序又该怎么样得到这个数据源呢，Tomcat服务器创建好数据源之后是以JNDI的形式绑定到一个JNDI容器中的，我们可以把JNDI想象成一个大大的容器，我们可以往这个容器中存放一些对象，一些资源，JNDI容器中存放的对象和资源都会有一个独一无二的名称，应用程序想从JNDI容器中获取资源时，只需要告诉JNDI容器要获取的资源的名称，JNDI根据名称去找到对应的资源后返回给应用程序。我们平时做javaEE开发时，服务器会为我们的应用程序创建很多资源，比如request对象，response对象，服务器创建的这些资源有两种方式提供给我们的应用程序使用：第一种是通过方法参数的形式传递进来，比如我们在Servlet中写的doPost和doGet方法中使用到的request对象和response对象就是服务器以参数的形式传递给我们的。第二种就是JNDI的方式，服务器把创建好的资源绑定到JNDI容器中去，应用程序想要使用资源时，就直接从JNDI容器中获取相应的资源即可。

　　对于上面的name="jdbc/datasource"数据源资源，在应用程序中可以用如下的代码去获取


Context initCtx = new InitialContext();
Context envCtx = (Context) initCtx.lookup("java:comp/env");
dataSource = (DataSource)envCtx.lookup("jdbc/datasource");

此种配置下，数据库的驱动jar文件需放置在tomcat的lib下

4.2、配置Tomcat数据源 包结构：

 如果报错com.mysql.jdbc.Connection.isValid(I)Z,说明包太旧了，更新mysql包即可解决

配置数据源JNDI的方式有很多，详细请看：Https://www.jb51.net/article/213425.htm

注意了：有个问题坑了我一天

先看我的这篇文章---解决Tomcat中修改server.xml和content.xml后自动还原问题：https://www.jb51.net/article/213429.htm

之前我是直接在外部的tomcat文件下的conf文件夹下去修改这两个文件，所以落坑

看完这篇文章应该知道了server.xml、context.xml的大概配置，接下来，我们来具体配置

我使用---配置全局JNDI数据源,应用到所有Tomcat下部署的应用

第一步、找到Tomcat的server.xml中GlobalNamingResources节点,在节点下加一个全局数据源

注意：name="jdbc/mysql"中“jdbc/mysql”为数据源名，在文件中多处引用  


<Resource  
    name="jdbc/mysql"   
    scope="Shareable"   
    type="javax.sql.DataSource"  
    factory="org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory"  
    url="jdbc:mysql://localhost:3306/test"  
    driverClassName ="com.mysql.jdbc.Driver"  
    username="root"  
    password="root"  
/>  

第二步,找到Tomcat的context.xml,在Context节点下加一个ResourceLink节点对第一步配置的数据源进行引用

这个XML配置文件的根节点就是<Context>

 插入代码：


<ResourceLink global="jdbc/mysql" name="jdbc/mysql" type="javax.sql.DataSource"/>

 第三步，配置web.xml文件，添加资源映射（此步骤可要可不要）


 <resource-ref>
   <description>DB Connection</description>
   <res-ref-name>jdbc/mysql</res-ref-name>
   <res-type>javax.sql.DataSource</res-type>
   <res-auth>Container</res-auth>
 </resource-ref>

这种配置方式 

优点:重用性,一次性到位

缺点:没有可控性（tomcat原始文件遭到修改）

 配置文件配置好了，现在就来写代码

JdbcUtils_JNDI：


package zdb.util.JNDI_tomcat;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
 
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;
 
public class JdbcUtils_JNDI {
	private static DataSource ds = null;
	static {
		
		try {
			//初始化JNDI
			Context initCtx = new InitialContext();
			//得到JNDI容器
			Context envCtx = (Context) initCtx.lookup("java:comp/env");
			//从JNDI容器中检索name为jdbc/datasource的数据源
			ds = (DataSource) envCtx.lookup("jdbc/mysql");
		} catch (NamingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		
	}
	public static Connection getConnection() throws SQLException{
	    //从数据源中获取数据库连接
		
	    return ds.getConnection();
	   
}
	//释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象
		public static void release(Connection conn,PreparedStatement ps ,ResultSet rs) {
			if (conn!=null) {
				try {
					conn.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if (ps!=null) {
				try {
					ps.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if (rs!=null) {
				try {
					rs.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				rs = null;
			}
 
}
}

 测试下

JNDI_test：


package zdb.util.JNDI_tomcat;
 
import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
 
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet("/JNDI_test")
public class JNDI_test extends HttpServlet{
	
	public void doGet(HttpServletRequest request, HttpServletResponse response)
	             throws ServletException, IOException {
	         Connection conn = null;
	         PreparedStatement st = null;
	         ResultSet rs = null;
	         try{
	             //获取数据库连接
	             conn = JdbcUtils_JNDI.getConnection();
	             System.out.println("mysql Connection pool connected !!");
	             String sql = "insert into user(uname) values(?)";
	             st = conn.prepareStatement(sql,PreparedStatement.RETURN_GENERATED_KEYS);
	             st.setString(1, "gacl");
	             st.executeUpdate();
	             //获取数据库自动生成的主键
	             rs = st.getGeneratedKeys();
	             if(rs.next()){
	                 System.out.println(rs.getInt(1));
	             }
	         }catch (Exception e) {
	             e.printStackTrace();
	         }finally{
	             //释放资源
	             JdbcUtils_JNDI.release(conn, st, rs);
	         }
	     }
	 public void doPost(HttpServletRequest request, HttpServletResponse response)
	              throws ServletException, IOException {
	          doGet(request, response);
	     }
 
}

 我再通过写一个jsp页面来映射到该servlet测试下

test.jsp:


<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
<style>
	body{
	text-align:center;
	}	
</style>
</head>
<body>
	<a href="${pageContext.servletContext.contextPath }/JNDI_test" rel="external nofollow" >测试</a>
	
</body>

测试结果成功：

拓展：由于此种配置模式的缺点，我们还可以通过增加一个新的xml文件来增加节点，而不用动原始文件

具体请看：tomcat虚拟路径的配置

几篇文章推荐给大家看下：

tomcat下面web应用发布路径配置( 即虚拟目录配置 )：http://www.voidcn.com/article/p-zctzsjte-rs.html

Tomcat服务器原理详解：https://www.cnblogs.com/crazylqy/p/4706223.html

Tomcat中主目录配置与虚拟目录配置问题自我总结：http://blog.51cto.com/longx/1357666

文章借鉴参照：-孤傲苍狼-原文：https://www.cnblogs.com/xdp-gacl/p/4002804.html

到此这篇关于Java中几种常用数据库连接池的使用的文章就介绍到这了,更多相关Java 数据库连接池内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

--结束END--

本文标题: Java中几种常用数据库连接池的使用

本文链接: https://lsjlt.com/news/126948.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • Java中几种常用数据库连接池的使用
    目录一、应用程序直接获取数据库连接的缺点二、使用数据库连接池优化程序性能2.1、数据库连接池的基本概念2.2、编写数据库连接池三、开源数据库连接池3.1、DBCP数据源3.2、在应用...
    99+
    2024-04-02
  • Java操作数据库——使用连接池连接数据库
    传统方式和连接池方式传统方式的步骤使用传统方式在Java中使用JDBC连接数据库，完成一次数据库的操作，一般有以下几个步骤： 加载驱动。 建立连接。 执行SQL语句。 释放连接。 传统方式的弊端每一次对数据库的操作都要建立一次连接，并且会将...
    99+
    2014-08-26
    java基础 java 连接池
  • 数据库连接池的方式有哪几种
    这篇文章主要讲解了“数据库连接池的方式有哪几种”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“数据库连接池的方式有哪几种”吧！ 一、介绍数据库连接是...
    99+
    2024-04-02
  • Java中使用Jedis连接池连接Redis数据库流程
    场景 Centos中Redis的下载编译与安装(超详细)： https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/103967334 Redis的启动和关闭(前台启动和...
    99+
    2018-02-08
    Java中使用Jedis连接池连接Redis数据库流程
  • Nodejs使用连接池连接数据库
    创建OptPool.jsvar mysql = require('mysql');function OptPool(){this.flag = true;this.pool = mysql....
    99+
    2024-04-02
  • Java项目中有哪些常用的数据库连接池
    Java项目中有哪些常用的数据库连接池？针对这个问题，这篇文章详细介绍了相对应的分析和解答，希望可以帮助更多想解决这个问题的小伙伴找到更简单易行的方法。定义数据库连接是一种关键的有限的昂贵的资源，这一点在多用户的网页应用程序中体现得尤为突出...
    99+
    2023-05-31
    java 数据库连接池 中有
  • Java数据库连接池Tomcat怎么使用
    这篇文章主要介绍“Java数据库连接池Tomcat怎么使用”，在日常操作中，相信很多人在Java数据库连接池Tomcat怎么使用问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”Java数据库连接池Tomcat怎...
    99+
    2023-06-25
  • JDBC02 利用JDBC连接数据库【使用数据库连接池】
    1 使用Statement执行含有动态信息的SQL语句时有几个不足:　　1.1 由于需要将动态数据拼接到SQL语句中,这导致程序复杂度高,容易出错　　1.2 拼接的数据若含有SQL语法内容就会导致拼接后的S...
    99+
    2024-04-02
  • 数据库连接池DBUtils使用
    一、简介 　　DBUtils简单说python实现的线程化数据库连接(连接池)，DBUtils支持所有遵循DP-API 2规范的数据库连接模块，例如：mysql、sqlserver、oracle、sqlite3等，更多请参考官网：htt...
    99+
    2023-01-30
    数据库 连接池 DBUtils
  • 数据库连接池的原理？连接池使用什么数据结构实现？实现连接池？
    早期我们怎么进行数据库操作呢？ 1、原理：一般来说，Java应用程序访问数据库的过程是： 加载数据库驱动程序； 通过jdbc建立数据库连接； 访问数据库，执行SQL语句； 断开数据库连接。 2、代码 1 //查询所有用户 ...
    99+
    2015-09-26
    数据库连接池的原理？连接池使用什么数据结构实现？实现连接池？
  • c3p0数据库连接池如何在Java项目中使用
    今天就跟大家聊聊有关c3p0数据库连接池如何在Java项目中使用，可能很多人都不太了解，为了让大家更加了解，小编给大家总结了以下内容，希望大家根据这篇文章可以有所收获。c3p0是什么c3p0的出现，是为了大大提高应用程序和数据库之间访问效率...
    99+
    2023-05-31
    java 数据库连接池 c3p0
  • proxool数据库连接池如何在Java项目中使用
    今天就跟大家聊聊有关proxool数据库连接池如何在Java项目中使用，可能很多人都不太了解，为了让大家更加了解，小编给大家总结了以下内容，希望大家根据这篇文章可以有所收获。Proxool是一种Java数据库连接池技术。sourceforg...
    99+
    2023-05-31
    java proxool 数据库连接池
  • c3p0数据库连接池如何使用
    这期内容当中小编将会给大家带来有关c3p0数据库连接池如何使用，文章内容丰富且以专业的角度为大家分析和叙述，阅读完这篇文章希望大家可以有所收获。一、jar包引用开源项目，自然要先下载人家的jar包，我这里有...
    99+
    2024-04-02
  • Druid数据库连接池如何使用
    这篇文章主要介绍了Druid数据库连接池如何使用的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇Druid数据库连接池如何使用文章都会有所收获，下面我们一起来看看吧。概述数据库连接池是个容器，负责分配、管理数据库...
    99+
    2023-07-05
  • sqlite数据库连接池如何使用
    SQLite数据库是一种轻量级的数据库，不支持连接池。每个连接都是一个独立的数据库文件，因此在SQLite中并不需要使用连接池。 如...
    99+
    2024-04-09
    sqlite
  • 利用Python连接数据库mysql的几种姿态
    前言尽管很多 NoSQL 数据库近几年大放异彩，但是像 MySQL 这样的关系型数据库依然是互联网的主流数据库之一，每个学 Python 的都有必要学好一门数据库，不管你是做数据分析，还是网络爬虫，Web 开发、亦或是机器学习，你都离不开要...
    99+
    2023-06-02
  • 详解Java数据库连接池
    目录一、什么是数据库连接池二、为什么需要连接池，好处是什么？三、都有哪些连接池方案四、连接池需要关注的参数五、怎么创建连接池，show me the code5.1 pom.xml ...
    99+
    2024-04-02
  • Java数据库连接池（经典）
    转载自：http://langzixin.iteye.com/blog/808975不错的案例，收藏起来，要不时间长了就找不到了...
    99+
    2023-06-03
  • sqlplus连接数据库的几种方法
    1. sqlplus / as sysdba     操作系统认证，不需要数据库服务器启动listener，也不需要数据库服务器处于可用状态。比如我们想要启动数据库就可以用这种方式...
    99+
    2024-04-02
  • C#连接数据库的几种方法
    一、Oracle 查询 public static DataTable QueryData() { DataTable dtResult = new ...
    99+
    2024-04-02
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作