这篇博客详细列举了使用JDBC连接多种数据库（如Oracle、DB2、SQL Server、Sybase、Informix、MySQL、PostgreSQL、Access）的示例代码，并介绍了数据库连接池的配置方法，包括Tomcat数据源配置、Hibernate的C3P0和proxool配置，以及Spring的连接池配置。此外，还提供了基于Mysql的JDBC连接示例和数据库连接池应用的步骤，帮助开发者理解和实现数据库的高效管理。
下面罗列了各种数据库使用JDBC连接的方式，可以作为一个手册使用。... 2
下面罗列了各种数据库使用JDBC连接的方式，可以作为一个手册使用。
1、Oracle8/8i/9i数据库（thin模式）
Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
String url="jdbc:oracle:thin:@localhost:1521:orcl";
//orcl为数据库的SID
String user="test";
String password="test";
Connection conn= DriverManager.getConnection(url,user,password); 2、DB2数据库
Class.forName("com.ibm.db2.jdbc.app.DB2Driver ").newInstance();
String url="jdbc:db2://localhost:5000/sample"; //sample为你的数据库名
String user="admin";
String password="";
Connection conn= DriverManager.getConnection(url,user,password); 3、Sql Server7.0/2000数据库
Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver").newInstance();
String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=mydb";
//mydb为数据库
String user="sa";
String password="";
Connection conn= DriverManager.getConnection(url,user,password);
SQLServer2005数据库
Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
conn=DriverManager.getConnection("jdbc:sqlserver://localhost:1433;databaseName=BookTrade","sa","1234");
4、Sybase数据库
Class.forName("com.sybase.jdbc.SybDriver").newInstance();
String url =" jdbc:sybase:Tds:localhost:5007/myDB";//myDB为你的数据库名
Properties sysProps = System.getProperties();
SysProps.put("user","userid");
SysProps.put("password","user_password");
Connection conn= DriverManager.getConnection(url, SysProps); 5、5、5、Informix数据库
Class.forName("com.informix.jdbc.IfxDriver").newInstance();
String url = "jdbc:informix-sqli://123.45.67.89:1533/myDB:INFORMIXSERVER=myserver;
user=testuser;password=testpassword"; //myDB为数据库名
Connection conn= DriverManager.getConnection(url);
6、MySQL数据库
Class.forName("org.gjt.mm.mysql.Driver").newInstance(); //或者Class.forName("com.mysql.jdbc.Driver");
String url
="jdbc:mysql://localhost/myDB?user=soft&password=soft1234&useUnicode=true&characterEncoding=8859_1"
//myDB为数据库名
Connection conn= DriverManager.getConnection(url);
7、PostgreSQL数据库
Class.forName("org.postgresql.Driver").newInstance();
String url ="jdbc:postgresql://localhost/myDB" //myDB为数据库名
String user="myuser";
String password="mypassword";
Connection conn= DriverManager.getConnection(url,user,password);
8、Access数据库直连用ODBC的
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver") ;
String url="jdbc:odbc:Driver={MicroSoft Access Driver (*.mdb)};DBQ=" application.getRealPath("/Data/ReportDemo.mdb");
Connection conn = DriverManager.getConnection(url,"","");
Statement stmtNew=conn.createStatement() ;
一段基于Mysql的JDBC连接数据库——JDBUtil.java
import java.sql.*;
public final class JDBCUtil {
private static final String URL
="jdbc:mysql://localhost:3306/student_score?useUnicode=true&characterEncoding=utf8";
private static final String USERNAME = "root";
private static final String PASSWORD = "1234";
private static Connection conn = null;
private JDBCUtil(){
}
static {
try {
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);
}catch(ClassNotFoundException e){
e.printStackTrace();
}catch(SQLException e){
e.printStackTrace();
}
}
public static Connection getConnection(){
return conn;
}
public static Statement getStatement(){
try{
return conn.createStatement();
}catch(SQLException e){
e.printStackTrace();
}
return null;
}
public static ResultSet query(Statement stmt , String sql){
try{
return stmt.executeQuery(sql);
}catch(SQLException e){
e.printStackTrace();
}
return null;
}
public static int excute(Statement stmt, String sql){
try{
return stmt.executeUpdate(sql);
}catch(SQLException e){
e.printStackTrace();
}
return -1;
}
public static void closeResultSet(ResultSet rs){
if(rs != null){
try{
rs.close();
rs = null;//可以加速垃圾回收
}catch(SQLException e){
e.printStackTrace();
}
}
}
public static void clossSatement(Statement stmt){
if(stmt != null){
try{
stmt.close();
stmt = null;
}catch(SQLException e){
e.printStackTrace();
}
}
}
public static void clossConn(){
if(conn != null){
try{
conn.close();
conn = null;
}catch(SQLException e){
e.printStackTrace();
}
}
}
}
数据库连接池的应用。
1.首先在相应的工程导入数据库连接jar包以mysql为例
注：Oracle数据库jar包到oracle的安装路径寻找E:\oracle\jdbc\lib\ ojdbc14.jar
2.编写数据库连接池的类DBUtil.java
package cn.tsp2c.booklib.util;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;
import cn.tsp2c.booklib.exception.DBException;
public class DBUtil {
private static DataSource ds = null;
/**
* 从数据库连接池获得一个数据库连接
* @return 数据库连接
* @throws DBException
*/
public static Connection getConnection() throws DBException {
//用数据库连接池的方式实现,JNDI
try {
if(ds == null){
Context context = new InitialContext();
ds= (DataSource) context.lookup("java:comp/env/jdbc/BookLibDB");
}
return ds.getConnection();
} catch (NamingException e) {
throw new DBException("数据库连接池查找失败", e);
} catch (SQLException e) {
throw new DBException("获取数据库连接异常", e);
}
}
public static PreparedStatement getPreparedStatement(Connection conn,
String sql) throws DBException {
PreparedStatement pstmt = null;
try {
if (conn != null) {
pstmt = conn.prepareStatement(sql);
}
} catch (SQLException e) {
throw new DBException("创建执行语句失败", e);
}
return pstmt;
}
public static PreparedStatement getPreparedStatement(Connection conn, String sql, int autoGenereatedKeys) throws DBException {
PreparedStatement pstmt = null;
try {
if (conn != null) {
pstmt = conn.prepareStatement(sql, autoGenereatedKeys);
}
} catch (SQLException e) {
throw new DBException("创建执行语句失败", e);
}
return pstmt;
}
public static Statement getStatement(Connection conn) throws DBException {
Statement stmt = null;
try {
if (conn != null) {
stmt = conn.createStatement();
}
} catch (SQLException e) {
throw new DBException("创建执行语句失败", e);
}
return stmt;
}
public static ResultSet getResultSet(Statement stmt, String sql)
throws DBException {
ResultSet rs = null;
try {
if (stmt != null) {
rs = stmt.executeQuery(sql);
}
} catch (SQLException e) {
throw new DBException("获得查询结果集失败：" + sql, e);
}
return rs;
}
public static void executeUpdate(Statement stmt, String sql)
throws DBException {
try {
if (stmt != null) {
stmt.executeUpdate(sql);
}
} catch (SQLException e) {
throw new DBException("更新失败：" + sql, e);
}
}
/**
* 归还数据库连接
* @param conn 数据库连接实例
* @throws DBException
*/
public static void close(Connection conn) throws DBException {
try {
if (conn != null) {
conn.close(); //把数据库连接归还到数据库连接池，并不是真正的断开数据库的连接
}
} catch (SQLException e) {
throw new DBException("关闭数据库连接异常", e);
}
}
public static void close(Statement stmt) throws DBException {
try {
if (stmt != null) {
stmt.close();
stmt = null;
}
} catch (SQLException e) {
throw new DBException("关闭数据库语句异常", e);
}
}
public static void close(ResultSet rs) throws DBException {
try {
if (rs != null) {
rs.close();
rs = null;
}
} catch (SQLException e) {
throw new DBException("关闭数据库结果集异常", e);
}
}
}
3.在WebRoot下面建文件夹META-INF，里面建一个文件context.xml
以Mysql为例
<Context reloadable="true" >
<Resource name="jdbc/BookLibDB" auth="Container"
type="javax.sql.DataSource"
maxActive="100" maxIdle="30" maxWait="10000"
username="root" password="1234"
driverClassName="com.mysql.jdbc.Driver"
url="jdbc:mysql://localhost:3306/dbbooklib?useUnicode=true&
characterEncoding=utf-8"/>
</Context>
若为Oracle数据库则如下：
<Context reloadable="true" >
<Resource name="jdbc/drshopdb" auth="Container" type="javax.sql.DataSource"
maxActive="100" maxIdle="30" maxWait="10000"
username="drshop_admin" password="drsoft"
driverClassName="oracle.jdbc.driver.OracleDriver"
url="jdbc:oracle:thin:@localhost:1521:orcl"/>
</Context>
4.在web.xml配置数据池连接
- 具体类中的应用
package cn.tsp2c.booklib.dao.impl;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import org.apache.log4j.Logger;
import cn.tsp2c.booklib.dao.UserDao;
import cn.tsp2c.booklib.domain.UserBean;
import cn.tsp2c.booklib.domain.vo.UserVO;
import cn.tsp2c.booklib.exception.DBException;
import cn.tsp2c.booklib.exception.UserException;
import cn.tsp2c.booklib.util.DBUtil;
/**
* 用户数据管理实现类
* @author lvxda
*/
public class UserDaoImpl implements UserDao{
private static final Logger log = Logger.getLogger(UserDaoImpl.class);
public void add(UserBean userBean) throws UserException {
String sql = "insert into t_user(username, password, gender, tel, email, classname, grade, userrole)"
+ " values(?,?,?,?,?,?,?,?)";
Connection conn = null;
PreparedStatement pstmt = null;
try {
conn = DBUtil.getConnection();
pstmt = DBUtil.getPreparedStatement(conn, sql);
pstmt.setString(1, userBean.getUsername());
pstmt.setString(2, userBean.getPassword());
pstmt.setString(3, userBean.getGender());
pstmt.setString(4, userBean.getTel());
pstmt.setString(5, userBean.getEmail());
pstmt.setString(6, userBean.getClassname());
pstmt.setString(7, userBean.getGrade());
pstmt.setString(8, userBean.getUserrole());
pstmt.executeUpdate();
} catch (SQLException ex) {
throw new UserException("保存用户失败", ex);
} catch (DBException ex) {
throw new UserException("保存用户失败", ex);
} finally{
try {
DBUtil.close(pstmt);
DBUtil.close(conn); //把数据库连接归还到数据库连接池，提高数据库的响应能力
} catch (DBException ex) {
throw new UserException("关闭数据库失败", ex);
}
}
}
public List<UserBean> queryUserList(UserVO userVO) throws UserException {
//处理userVO 组成查询条件，实现模糊查询
String where = "";
String un = userVO.getUsername();
if(un != null && !"".equals(un)){
where = "username like '%" + un + "%'";
}
String cname = userVO.getClassname();
if(cname != null && !"".equals(cname)){
if (!where.equals(""))
where = where + " and ";
where = where + "classname like '%" + cname + "%'";
}
String gd = userVO.getGrade();
if(!"-1".equals(gd)){
if (!where.equals(""))
where = where + " and ";
where = where + "grade = '" + gd + "'";
}
String ur = userVO.getUserRole();
if(!"-1".equals(ur)){
if (!where.equals(""))
where = where + " and ";
where = where + "userrole = '" + ur + "'";
}
if (!where.equals("")){
where = " where " + where;
}
String sql = "select * from t_user" + where;
log.debug("查询用户SQL:" + sql);
List<UserBean> userList = new ArrayList<UserBean>();
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try {
conn = DBUtil.getConnection();
stmt = DBUtil.getStatement(conn);
rs = stmt.executeQuery(sql);
while(rs.next()){
int uid = rs.getInt("userid");
String uname = rs.getString("username");
//password 不拿出来
String gender = rs.getString("gender");
gender = (gender.equals("0") ? "男" : "女");
String tel = rs.getString("tel");
tel = (tel == null ? "" : tel);
String email = rs.getString("email");
email = (email == null ? "" : email);
String classname = rs.getString("classname");
String grade = rs.getString("grade");
String userrole = rs.getString("userrole");
userrole = (userrole.equals("0") ? "学生" : "管理员");
UserBean userBean
= new UserBean(uid,uname,null,gender,tel,email,classname,grade,userrole);
userList.add(userBean);
}
return userList;
} catch (SQLException ex) {
throw new UserException("查询用户失败", ex);
} catch (DBException ex) {
throw new UserException("查询用户失败", ex);
} finally{
try {
DBUtil.close(rs);
DBUtil.close(stmt);
DBUtil.close(conn);
} catch (DBException ex) {
throw new UserException("关闭数据库失败", ex);
}
}
}
}
今天遇到了关于数据源连接池配置的问题，发现有很多种方式可以配置，现总结如下，希望对大家有所帮助：（已Mysql数据库为例）
一、Tomcat配置数据源：
方式一：在WebRoot下面建文件夹META-INF，里面建一个文件context.xml，内容如下：
| <Context> <Resource name="jdbc/test" auth="Container" type="javax.sql.DataSource" maxActive="50" maxIdle="30" maxWait="10000" logAbandoned="true" username="root" password="111111" driverClassName="com.mysql.jdbc.Driver" url="jdbc:mysql://localhost:3306/testdb" /> </Context> |
方式二：在tomcat6.0的目录conf下面的context.xml中，修改原来的context标签，改成内容如下：
| <Context> <!-- Default set of monitored resources --> <WatchedResource>WEB-INF/web.xml</WatchedResource> <Resource name="jdbc/test" auth="Container" type="javax.sql.DataSource" maxActive="50" maxIdle="30" maxWait="10000" logAbandoned="true" username="root" password="111111" driverClassName="com.mysql.jdbc.Driver" url="jdbc:mysql://localhost:3306/testdb" /> </Context> |
方式三：在配置虚拟目录时，也就是在配置conf下面的server.xml时，在context标签内改成如下形式：
| <Context path="/WebRoot" reloadable="true" docBase="E:\workspace\DataSource\WebRoot" > <Resource name="jdbc/test" auth="Container" type="javax.sql.DataSource" maxActive="50" maxIdle="30" maxWait="10000" logAbandoned="true" username="root" password="111111" driverClassName="com.mysql.jdbc.Driver" url="jdbc:mysql://localhost:3306/testdb" /> </Context> |
配置文件中Resource标签中各属性的含义：
driverClassName - JDBC 所用到的数据库驱动的类全名.
maxActive - 连接池在同一时刻内所提供的最大活动连接数。
maxIdle - 连接池在空闲时刻保持的最大连接数.
maxWait - 当发生异常时数据库等待的最大毫秒数 (当没有可用的连接时).
password - 连接数据库的密码.
url - 连接至驱动的URL. (为了向后兼容, DRIVERNAME也被允许.)
user - 数据库用户名.
各种配置方式的范围也应该是不一样的。我在这就不细说了，总之就是在Context标签下面配置个Resource标签即可。
测试代码：
| Context initContext = new InitialContext(); Context envContext = (Context)initContext.lookup("java:/comp/env"); DataSource ds = (DataSource)envContext.lookup("jdbc/test"); System.out.println(ds.getConnection()); |
打印出来不是null应该就成功了。
注意，测试的时候要在tomcat内测试，也就是要在TOMCAT这个容器内（不要闲麻烦，写个简单的JSP页面测下，用个<%...%>就可以了，相当简单的）。不在tomcat这个容器里面测，会抛异常：
... javax.naming.NoInitialContextException: Need to specify class name in environment or system property, or as an applet parameter, or in an application resource file: java.naming.factory.initial
二、Hibernate配置连接池有三种方法：
方式1 使用Hibernate自带的连接池。
| <hibernate-configuration> <session-factory > <!--JDBC驱动程序--> <property name="connection.driver_class">com.mysql.jdbc.Driver</property> <!-- 连接数据库的URL--> <property name="connection.url"> jdbc:mysql://localhost:3306/feifei </property> <!--连接的登录名--> <property name="connection.username">root</property> <!--登录密码--> <property name="connection.password"></property> <!--是否将运行期生成的SQL输出到日志以供调试--> <property name="show_sql">true</property> <!--指定连接的语言--> <property name="dialect">org.hibernate.dialect.MySQLDialect</property> <!--映射资源--> <mapping resource="/xx/xx.hbm.xml" /> </session-factory> </hibernate-configuration> |
我自己的配置如下，注释的部分，他是公用的，其它的连接池需要用到！
| <hibernate-configuration> <session-factory> <property name="show_sql">true</property> <!-- common conf dbcp/c3p0 needed <property name="connection.username">informix</property> <property name="connection.password">informix</property> <property name="connection.driver_class">com.informix.jdbc.IfxDriver</property> <property name="connection.url"> jdbc:informix-sqli://192.168.0.188:1526/db_crm:informixserver=ol_sx;NEWLOCALE=zh_cn,en_us;NEWCODESET=gbk,8859_1,819; </property> <property name="dialect"> com.huatech.sysframe.webapp.common.dao.hibernate.dialet.BaseInformixDialect </property> --> ... ... ... ... </session-factory> </hibernate-configuration> |
=======================================================
关联文件：test/huatech/conf/ProxoolConf.xml配置如下：
| <?xml version="1.0" encoding="utf-8"?> <something-else-entirely> <proxool> <alias>dbpool</alias> <!--proxool只能管理由自己产生的连接--> <driver-url> jdbc:informix-sqli://192.168.0.188:1526/db_crm:informixserver=ol_sx;NEWLOCALE=zh_cn,en_us;NEWCODESET=gbk,8859_1,819; </driver-url> <driver-class>com.informix.jdbc.IfxDriver</driver-class> <driver-properties> <property name="user" value="informix" /> <property name="password" value="informix" /> </driver-properties> <!-- proxool自动侦察各个连接状态的时间间隔(毫秒),侦察到空闲的连接就马上回收,超时的销毁--> <house-keeping-sleep-time>90000</house-keeping-sleep-time> <!-- 指因未有空闲连接可以分配而在队列中等候的最大请求数,超过这个请求数的用户连接就不会被接受--> <maximum-new-connections>20</maximum-new-connections> <!-- 最少保持的空闲连接数--> <prototype-count>5</prototype-count> <!-- 允许最大连接数,超过了这个连接，再有请求时，就排在队列中等候，最大的等待请求数由maximum-new-connections决定--> <maximum-connection-count>100</maximum-connection-count> <!-- 最小连接数--> <minimum-connection-count>10</minimum-connection-count> </proxool> </something-else-entirely> |
===================================================
方式3： 从容器中获取得到连接池（如：Tomcat）
用服务器本身的连接池：如Tomcat、resin、weblogic等
hibernate配置如下：
| <!-- <property name="hibernate.connection.datasource"> java:comp/env/jdbc/crm </property> <property name="show_sql">true</property> <property name="dialect"> com.huatech.sysframe.webapp.common.dao.hibernate.dialet.BaseInformixDialect </property> <property name="hibernate.generate_statistics">true</property> --> |
其中java:comp/env/jdbc/crm的jdbc/crm是对应的服务器中数据库连接池名字，需要在对应的环境中配置
Tomcat配置如第一种Tomcat配置方式所描述，注意jndi的name根据情况修改，要与hibernate所使用的名字对应起来。
====================================================
上面配置中需要用到各自数据库连接池的jar包，在hibernate包中有，如果需要最新的可以到各自网站下载
本文主要内容：Hibernate 连接池有三种配置方式：dbcp , c3p0 , proxool。URL的多种指定方式连接池监控，上班第二天，看到公司的Hibernate连接池配置文件在写法上，跟我以前的不一样，就去研究了哈，得出的结果如下。
在Hibernate3.0中，已经不再支持dbcp了，Hibernate的作者在Hibernate.org中，明确指出在实践中发现dbcp有BUG,在某些种情会产生很多空连接不能释放，所以抛弃了对dbcp的支持。
一、Hibernate 连接池:C3P0 配置
1. <?xml version="1.0" encoding="UTF-8"?>
2. <!DOCTYPE Hibernate-configuration PUBLIC
3. "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
4. "http：//Hibernate.sourceforge.net/Hibernate-configuration-3.0.dtd">
5. <Hibernate-configuration>
6. <session-factory>
7. <!-- 配置事务实现方式 -->
8. <property name="transaction.factory_class">
9. org.Hibernate.transaction.JDBCTransactionFactory
10. </property>
11. <!-- 配置JDBC里batch的大小 -->
12. <property name="jdbc.batch_size">50</property>
13. <property name="cache.use_second_level_cache">false</property>
14. <!-- 配置线程安全的session -->
15. <property name="current_session_context_class">thread</property>
16. <!-- 显示SQL -->
17. <property name="show_sql">true</property>
18. <property name="format_sql">true</property>
19. <!-- 配置数据库方言 -->
20. <property name="dialect">org.Hibernate.dialect.Oracle9Dialect</property>
21. <!-- 配置数据库连接 -->
22. <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
23. <property name="connection.username">0804</property>
24. <property name="connection.password">0804</property>
25. <property name="connection.url">jdbc：oracle：thin：@192.168.0.200：1521：orcl</property>
26. <!-- 配置连接池 -->
27. <property name="c3p0.max_size">2</property>
28. <property name="c3p0.min_size">2</property>
29. <property name="c3p0.timeout">5000</property>
30. <property name="c3p0.max_statements">100</property>
31. <property name="c3p0.idle_test_period">3000</property>
32. <property name="c3p0.acquire_increment">2</property>
33. <property name="c3p0.validate">false</property>
34. <!-- 指定Hibernate管理的映射文件 -->
35. <mapping resource="com/ket/ruan/so/entity/User.hbm.xml"/>
36. <mapping resource="com/ket/ruan/so/entity/Product.hbm.xml"/>
37. </session-factory>
38. </Hibernate-configuration>
二、Hibernate 连接池：使用proxool
1. <Hibernate-configuration>
2. <session-factory>
3. <property name="show_sql">true</property>
4. <property name="dialect">
5. org.Hibernate.dialect.MySQLDialect
6. </property>
7. <!-- 配置proxool属性 -->
8. <!--- 使用proxoolConf.xml中定义的别名 -->
9. <property name="proxool.pool_alias">pool1</property>
10. <!-- 指定使用的proxoolConf文件的位置（这里在SRC下）-->
11. <property name="proxool.xml">ProxoolConf.xml</property>
12. <property name="connection.provider_class">
13. org.Hibernate.connection.ProxoolConnectionProvider
14. </property>
15. ....
16. <!-- 指定Hibernate管理的映射文件 -->
17. <mapping resource="com/ket/ruan/so/entity/User.hbm.xml"/>
18. ....
19. </Hibernate-configuration>
1.ProxoolConf.xml：xml文件放在同级目录中，需要 proxool-0.8.3.jar。
1. <?xml version="1.0" encoding="gb2312"?>
2. <something-else-entirely>
3. <proxool>
4. <alias>pool1</alias>
5. <driver-url>
6. jdbc：mysql：//tpdb：3306/tpdb
7. </driver-url>
8. <driver-class>com.mysql.jdbc.Driver</driver-class>
9. <driver-properties>
10. <property name="user" value="username"/>
11. <property name="password" value="password"/>
12. <property name="schema" value="tpdb"/> <!-- ？？？-->
13. <!-- 自动重连 -->
14. <property name="autoReconnect" value="true"/>
15. </driver-properties>
16. <!-- proxool自动侦察各个连接状态的时间间隔(毫秒),
17. 侦察到空闲的连接就马上回收,超时的销毁-->
18. <house-keeping-sleep-time>90000</house-keeping-sleep-time>
19. <!-- 指因未有空闲连接可以分配而在队列中等候的最大请求数,超过这个请求数的
20. 用户连接就不会被接受(正式库10，测试库1)-->
21. <maximum-new-connections>10</maximum-new-connections>
22. <!-- 最少保持的空闲连接数(正式库10，测试库1)-->
23. <prototype-count>10</prototype-count>
24. <!-- 连接池允许的最大连接数(正式库700，测试库10)-->
25. <maximum-connection-count>700</maximum-connection-count>
26. <!-- 连接池开启的最小连接数(正式库350，测试库5)-->
27. <minimum-connection-count>350</minimum-connection-count>
28. <!-- 一个活动连接的最长时间15分钟，单位毫秒 -->
29. <maximum-active-time>900000</maximum-active-time>
30. <!-- 一个连接的最长活动时间4小时，单位毫秒 -->
31. <maximum-connection-lifetime>14400000</maximum-connection-lifetime>
32. <!-- 自动检查连接是否断掉开关 -->
33. <test-before-use>true</test-before-use>
34. <!-- 自动检查连接是否断的测试sql语句 -->
35. <house-keeping-test-sql>select sysdate() from dual</house-keeping-test-sql>
36. </proxool>
37. </something-else-entirely>
2.数据库名可以这样指定
1. <property name="connection.url">
2. jdbc：sqlserver：//localhost：1433;DatabaseName=supermarket
3. </property>
3.URL 还可以传参数
1. <property name="connection.driver_class">org.gjt.mm.mysql.Driver</property>
2. <property name="connection.url">
3. jdbc：mysql：//localhost：3306/struts?useUnicode=true&characterEncoding=GBK
4. </property>
目前，proxool用法，被大部分人认为是最优秀的。
4.连接池监控
1).在web.xml中加上下面这段
1. <servlet>
2. <servlet-name> proxool </servlet-name>
3. <servlet-class> org.logicalcobwebs.proxool.admin.servlet.AdminServlet
4. </servlet-class>
5. </servlet>
6. <servlet-mapping>
7. <servlet-name> proxool </servlet-name>
8. <url-pattern> /Admin/proxool/ </url-pattern>
9. </servlet-mapping>
2).http：//localhost：8080/testHibernate/Admin/proxool
就可以监控到连接池的状况了！
三、Spring配置连接池的方法：
| <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"> <property name="driverClassName"> <value>com.mysql.jdbc.Driver</value> </property> <property name="url"> <value>jdbc:mysql://localhost:3306/dbname</value> </property> <property name="username"> <value>root</value> </property> <property name="password"> <value>******</value> </property> <property name="maxActive"> <value>100</value> </property> <property name="maxWait"> <value>1000</value> </property> <property name="maxIdle"> <value>30</value> </property> <property name="defaultAutoCommit"> <value>true</value> </property> <property name="removeAbandoned"> //自动回收连接池，避免连接池泄露 <value>true</value> </property> <property name="removeAbandonedTimeout"> <value>60</value> </property> </bean> |
四、也是我今天要说的最后一种，则是通过代码的编写配置连接池，代码如下：
| import java.sql.*; import java.sql.DataSource; import org.apache.commons.dbcp.BasicDataSource; public class ConnectionPool{ private static BasicDataSource dbs = null; public static DataSource setupDataSource(){ bds = new BasicDataSource(); //设置驱动程序 bds.sestDriverClassName("com.mysql.jdbc.Driver"); //设置连接用户名 bds.setUsername("root"); //设置连接密码 bds.setPassword("root"); //设置连接地址 bds.setUrl("jdbc:mysql://localhost:3306/databasename"); //设置初始化连接总数 bds.setInitialSize(50); //设置同时应用的连接总数 bds.setMaxActive(-1); //设置在缓冲池的最大连接数 bds.setMaxIdle(-1); //设置在缓冲池的最小连接数 bds.setMinIdle(0); //设置最长的等待时间 bds.setMaxWait(-1); return (DataSource)bds; } //显示连接池的连接个数的方法 public static void printDataSourceStats(DataSource ds) throws SQLException{ bds = (BasicDataSource)ds; System.out.println(); System.out.println(); } //关闭连接池的方法 public static void shutdownDataSource(DataSource ds) throws SQLException{ bds = (BasicDataSource)ds; bds.close(); } } |
要获得连接池只许使用该类的静态方法setupDataSource()即可
以上是我总结的几种配置数据库连接池的方法，这些只是常用的几种配置方法，应该还有其他方式方法，只要各位朋友肯花功夫，总能找到适合你的一种配置方式，祝您好运！
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
