`
g21121
  • 浏览: 694682 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

连接池与Spring,Hibernate结合

 
阅读更多

        前几篇关于Java连接池的介绍都是基于Java应用的，而我们常用的场景是与Spring和ORM框架结合，下面就利用实例学习一下这方面的配置。


        1.下载相关内容：
        c3p0下载地址：http://sourceforge.net/projects/c3p0/
        Proxool下载地址：http://proxool.sourceforge.net/
        Druid下载地址：http://code.alibabatech.com/mvn/releases/com/alibaba/druid/
        Spring下载地址：http://www.springsource.org/download/community
        Hibernate下载地址：http://www.hibernate.org/downloads.html
        ibatis(mybatis)下载地址：http://code.google.com/p/mybatis/


        这里我们下载并采用的版本是：c3p0-0.9.2.1,proxool-0.9.1,druid-0.2.23,spring-framework-3.2.2,hibernate-4.2.3,mybatis-3.2.2.

 

        2.新建一个web项目，这里以之前举例项目为例，将所需要的相关jar包复制到项目的WEB-INF/lib下，这里就不详细说明各框架的jar包依赖关系了，可以自己百度查下。


        3.新建接口C3P0DAO,DruidDAO,ProxoolDAO，并且添加相同的方法：

/**
* 获取用户信息
* @param usrId
* @return
*/
Object getUsrInfo(Integer usrId);

 
        4.在resource目录下新建c3p0.properties,druid.properties,proxool.properties这三个属性文件，他们分别是几种连接池的详细配置信息。


        5.在resource目录下新建Spring配置文件applicationContext-dataSource.xml，内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

	<!-- spring加载资源文件 -->
	<bean name="propertiesConfig"
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<list>
				<value>classpath:c3p0.properties</value>
				<value>classpath:proxool.properties</value>
				<value>classpath:druid.properties</value>
				<value>classpath:hibernate.properties</value>
			</list>
		</property>
	</bean>

	<!-- c3p0数据源配置 -->
	<bean id="dataSource_c3p0" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<!-- 数据库驱动 -->
		<property name="driverClass" value="${c3p0.driverClass}" />
		<!-- 数据库连接url -->
		<property name="jdbcUrl" value="${c3p0.jdbcUrl}" />
		<!-- 数据库用户 -->
		<property name="user" value="${c3p0.user}" />
		<!-- 数据库密码 -->
		<property name="password" value="${c3p0.password}" />
		<!-- 初始化时获取连接数 -->
		<property name="initialPoolSize" value="${c3p0.initialPoolSize}" />
		<!-- 连接池中保留的最小连接数 -->
		<property name="minPoolSize" value="${c3p0.minPoolSize}" />
		<!-- 连接池中保留的最大连接数 -->
		<property name="maxPoolSize" value="${c3p0.maxPoolSize}" />
	</bean>

	<!-- Proxool数据源配置 -->
	<bean id="dataSource_proxool" class="org.logicalcobwebs.proxool.ProxoolDataSource">
		<!-- 别名 -->
		<property name="alias" value="${proxool.alias}" />
		<!-- 数据库驱动 -->
		<property name="driver" value="${proxool.driver}" />
		<!-- 数据库连接url -->
		<property name="driverUrl" value="${proxool.driverUrl}" />
		<!-- 数据库用户 -->
		<property name="user" value="${proxool.user}" />
		<!-- 数据库密码 -->
		<property name="password" value="${proxool.password}" />
		<!-- 最少保持的空闲连接数 -->
		<property name="prototypeCount" value="${proxool.prototypeCount}" />
		<!-- 最大连接数 -->
		<property name="maximumConnectionCount" value="${proxool.maximumConnectionCount}" />
		<!-- 最小连接数 -->
		<property name="minimumConnectionCount" value="${proxool.minimumConnectionCount}" />
	</bean>

	<!-- Druid数据源配置 -->
	<bean id="dataSource_druid" class="com.alibaba.druid.pool.DruidDataSource"
		init-method="init" destroy-method="close">
		<!-- 数据库连接url -->
		<property name="url" value="${druid.url}" />
		<!-- 数据库用户 -->
		<property name="username" value="${druid.username}" />
		<!-- 数据库密码 -->
		<property name="password" value="${druid.password}" />
		<!-- 配置连接池初始化大小 -->
		<property name="initialSize" value="${druid.initialSize}" />
		<!-- 最小空闲连接数 -->
		<property name="minIdle" value="${druid.minIdle}" />
		<!-- 最大连接数 -->
		<property name="maxActive" value="${druid.maxActive}" />
		<!-- 获取连接等待超时的时间，单位：毫秒 -->
		<property name="maxWait" value="${druid.maxWait}" />
	</bean>

</beans>

 

 

        6.配置Hibernate与Spring集成，新建Spring配置文件applicationContext-hibernate.xml，内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

	<!-- c3p0 sessionFactory配置，注意是版本为Hibernate4 -->
	<bean id="sessionFactory_c3p0"
		class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
		<!-- 将c3p0的数据源注入给hibernate使用 -->
		<property name="dataSource" ref="dataSource_c3p0" />
		<property name="mappingResources">
			<list>
				<value>com/test/jdbc/model/User.hbm.xml</value>
			</list>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">${hibernate.dialect}</prop>
				<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
				<prop key="hibernate.jdbc.fetch_size">${hibernate.jdbc.fetch_size}</prop>
				<prop key="hibernate.jdbc.batch_size">${hibernate.jdbc.batch_size}</prop>
				<prop key="hibernate.connection.characterEncoding">${hibernate.connection.characterEncoding}</prop>
				<prop key="hibernate.connection.autocommit">${hibernate.connection.autocommit}</prop>
				<prop key="hibernate.connection.release_mode">${hibernate.connection.release_mode}</prop>
				<prop key="hibernate.autoReconnect">${hibernate.autoReconnect}</prop>
				<prop key="hibernate.cglib.use_reflection_optimizer">${hibernate.cglib.use_reflection_optimizer}</prop>
			</props>
		</property>
	</bean>
	
	<!-- Druid sessionFactory配置，注意是版本为Hibernate4 -->
	<bean id="sessionFactory_druid"
		class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
		<!-- 将c3p0的数据源注入给hibernate使用 -->
		<property name="dataSource" ref="dataSource_druid" />
		<property name="mappingResources">
			<list>
				<value>com/test/jdbc/model/User.hbm.xml</value>
			</list>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">${hibernate.dialect}</prop>
				<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
				<prop key="hibernate.jdbc.fetch_size">${hibernate.jdbc.fetch_size}</prop>
				<prop key="hibernate.jdbc.batch_size">${hibernate.jdbc.batch_size}</prop>
				<prop key="hibernate.connection.characterEncoding">${hibernate.connection.characterEncoding}</prop>
				<prop key="hibernate.connection.autocommit">${hibernate.connection.autocommit}</prop>
				<prop key="hibernate.connection.release_mode">${hibernate.connection.release_mode}</prop>
				<prop key="hibernate.autoReconnect">${hibernate.autoReconnect}</prop>
				<prop key="hibernate.cglib.use_reflection_optimizer">${hibernate.cglib.use_reflection_optimizer}</prop>
			</props>
		</property>
	</bean>
	
	<!-- Proxool sessionFactory配置，注意是版本为Hibernate4 -->
	<bean id="sessionFactory_proxool"
		class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
		<!-- 将c3p0的数据源注入给hibernate使用 -->
		<property name="dataSource" ref="dataSource_proxool" />
		<property name="mappingResources">
			<list>
				<value>com/test/jdbc/model/User.hbm.xml</value>
			</list>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">${hibernate.dialect}</prop>
				<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
				<prop key="hibernate.jdbc.fetch_size">${hibernate.jdbc.fetch_size}</prop>
				<prop key="hibernate.jdbc.batch_size">${hibernate.jdbc.batch_size}</prop>
				<prop key="hibernate.connection.characterEncoding">${hibernate.connection.characterEncoding}</prop>
				<prop key="hibernate.connection.autocommit">${hibernate.connection.autocommit}</prop>
				<prop key="hibernate.connection.release_mode">${hibernate.connection.release_mode}</prop>
				<prop key="hibernate.autoReconnect">${hibernate.autoReconnect}</prop>
				<prop key="hibernate.cglib.use_reflection_optimizer">${hibernate.cglib.use_reflection_optimizer}</prop>
			</props>
		</property>
	</bean>
</beans>

 

        7.实现我们之前定义的三个DAO接口，实现类代码比较简单我拿DruidDAOImpl为例，其他类代码相同：

package com.test.jdbc.dao.impl;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import com.test.jdbc.dao.DruidDAO;
import com.test.jdbc.model.User;

/**
 * DruidDAO实现
 * @author g21121
 *
 */
public class DruidDAOImpl extends HibernateDaoSupport implements DruidDAO {
    
    /**
     * 获取用户信息
     */
    public Object getUsrInfo(Integer usrId) {
        return getHibernateTemplate().get(User.class, usrId);
    }

}

 

       8.新建spring配置文件applicationContext-dao.xml，将三个实现类与spring结合：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

	<!-- 将c3p0作为数据源的sessionFactory注入 -->
	<bean class="com.test.jdbc.dao.impl.C3P0DAOImpl">
		<property name="sessionFactory" ref="sessionFactory_c3p0" />
	</bean>
	<!-- 将Druid作为数据源的sessionFactory注入 -->
	<bean class="com.test.jdbc.dao.impl.DruidDAOImpl">
		<property name="sessionFactory" ref="sessionFactory_druid" />
	</bean>
	<!-- 将Proxool作为数据源的sessionFactory注入 -->
	<bean class="com.test.jdbc.dao.impl.ProxoolDAOImpl">
		<property name="sessionFactory" ref="sessionFactory_proxool" />
	</bean>

</beans>

        这里我们将之前配置的三个数据源注入到了三个不同命名的sessionFactory，然后将三个sessionFactory分别注入到各自的DAO实现类中，这样就实现了利用不同的数据源来访问数据库。

 

        9.新建一个测试用Servlet，代码如下：

package com.test.jdbc;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.beans.factory.annotation.Autowired;

import com.test.jdbc.dao.C3P0DAO;
import com.test.jdbc.dao.DruidDAO;
import com.test.jdbc.dao.ProxoolDAO;

/**
 * 测试Servlet
 * @author g21121
 *
 */
public class UserServlet extends HttpServlet {
    /**
     * 此处利用Spring注解自动注入属性
     */
    @Autowired
    private C3P0DAO c3P0DAO;
    @Autowired
    private DruidDAO druidDAO;
    @Autowired
    private ProxoolDAO proxoolDAO;

    /**
     * 处理Get请求
     */
    public void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {

        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out
            .println("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">");
        out.println("<HTML>");
        out.println("  <HEAD><TITLE>User Servlet</TITLE></HEAD>");
        out.println("  <BODY>");
        out.println("Druid："+druidDAO.getUsrInfo(1));
        out.println("c3p0："+c3P0DAO.getUsrInfo(1));
        out.println("Proxool："+proxoolDAO.getUsrInfo(1));
        out.println("  </BODY>");
        out.println("</HTML>");
        out.flush();
        out.close();
    }

    public void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
        this.doGet(request, response);
    }

    public UserServlet() {
        super();
    }
}

 

 

       这里采用注解方式注入，可以在spring文件中添加以下内容来支持注解注入：
<!-- 该 BeanPostProcessor 将自动起作用，对标注 @Autowired 的 Bean 进行自动注入 -->
<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" />
 
        最后是项目文件，spring和hibernate包比较大所以没包含在其中。
2
顶
6
踩
分享到：
| java数据库连接池Druid
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    spring3+hibernate4+springmvc+druid连接池

    【标题】"spring3+hibernate4+springmvc+druid连接池"是一个常见的Java Web开发中的技术栈整合，其中包含了Spring框架的三个主要组件：Spring Core、Spring MVC和Hibernate ORM，以及Druid数据库连接池。这个组合常...

    Spring+Hibernate+Proxool连接池

    标题 "Spring+Hibernate+Proxool连接池" 涉及到的是在Java Web开发中，如何使用Spring框架集成Hibernate ORM框架，并结合Proxool作为数据库连接池的技术实践。这通常是为了提高应用性能，有效管理和复用数据库连接，...

    hibernate结合连接池相关配置

    为了提高应用性能和管理数据库连接，通常会将Hibernate与数据库连接池相结合。本篇文章将深入探讨如何配置Hibernate以配合连接池进行高效的数据交互。 一、连接池简介 连接池是数据库连接的一种管理机制，它预先...

    建连接池 hibernate copo3 spring

    同时，由于Spring的出色整合能力，我们可以方便地将其他数据访问技术与Hibernate结合，实现更加灵活的应用设计。 总之，Java Web开发中的数据库连接池配置是优化系统性能的重要环节。SSH框架提供的强大支持使得这一...

    Hibernate2和Hibernate3连接池配置.doc

    《Hibernate2与Hibernate3连接池配置详解》 在Java的持久层框架中，Hibernate是一个广泛使用的ORM（对象关系映射）工具，它允许开发者将数据库操作转化为对Java对象的操作，极大地提高了开发效率。然而，为了优化...

    Spring各种连接池的比较.doc

    其次，Hibernate开发团队推荐使用C3P0（ComboPooledDataSource），这是一个功能更加强大的连接池。C3P0提供了一些高级特性，如连接测试、空闲连接检测以及自动扩展。其配置中，你可以设置最小连接池大小...

    java hibernate中各种连接池比较

    Java Hibernate 中的各种连接池在应用程序开发中扮演着关键角色，它们负责管理数据库连接，提高性能并减少资源消耗。本文将对比分析三个常见的开源数据连接池：C3P0、DBCP 和 Proxool，并深入探讨它们的主要参数和...

    spring hibernate mysql 事务实例

    在Spring与Hibernate的结合下，MySQL的事务控制可以通过设置不同的隔离级别（如READ UNCOMMITTED、READ COMMITTED、REPEATABLE READ、SERIALIZABLE）来优化并发性能和避免数据竞争问题。 在实际开发中，我们还需要...

    spring 与hibernate的集成

    在进行Spring与Hibernate的集成时，首先要在`web.xml`中配置Spring的相关内容。这里有两个关键的元素：`context-param`和`listener`。`context-param`用于指定Spring应用上下文配置文件的位置，通常设置为`/WEB-INF/...

    在Hibernate中配置Proxool连接池

    在上述配置中，我们通过`hibernate.proxool.properties`指定了Proxool的配置文件路径，`hibernate.proxool.pool_alias`设置了连接池的别名，这个别名需要与Proxool配置文件中的alias一致。 接下来，我们需要创建...

    Spring整合Hibernate.jar

    9. **性能优化**：考虑使用二级缓存、批处理操作、懒加载和连接池等技术提高性能。 以上就是Spring整合Hibernate的基本过程和关键知识点。这27个jar包的集合将包含所有必要的组件，使得开发人员能够快速搭建一个...

    HibernateADD (hibernate和spring整合，使用dbcp连接池方式连接数据库)

    整合Hibernate与Spring的主要优点在于： 1. **依赖注入**：Spring可以通过其IoC容器管理Hibernate的SessionFactory和Session实例，使代码更易于测试和维护。 2. **事务管理**：Spring的声明式事务管理可以无缝地...

    spring+hibernate整合jar包

    5. **Spring MVC与Hibernate的结合**： - 在Spring MVC的Controller中，可以通过@Autowired注解注入Service层，Service层则负责调用DAO层，进行数据操作，DAO层通常使用Hibernate的Session和SessionFactory。 6. *...

    Hibernate与常用连接池的配置

    **标题：“Hibernate与常用连接池的配置”** 在Java企业级开发中，数据库连接管理是一项至关重要的任务。Hibernate作为一款强大的对象关系映射（ORM）框架，极大地简化了数据库操作。然而，为了优化数据库资源的...

Magicbox
Global site tag (gtag.js) - Google Analytics