四、Java持久化基础-第三方数据库连接池：C3P0 - ranji13 - ITeye技术网站
博客分类：
第三方数据库连接池：C3P0的使用
目前，在实际开发中存在很多流行的性能优良的第三方数据库连接池，我不用费时费力的去写一个连接池而且还得考虑性能和稳定性等因素，既然有现成的为什么不用呢。来试试C3P0连接池的使用：
一、下载并导入C3P0的jar包，下载地址：
二、配置数据源，有三种方法：
1、通过set方法手动配置
ComboPooledDataSource cpds = new ComboPooledDataSource();
cpds.setDriverClass(props.getProperty("driverClass"));
cpds.setJdbcUrl(props.getProperty("jdbcUrl"));
cpds.setUser(props.getProperty("user"));
cpds.setPassword(props.getProperty("password"));
2、配置默认的属性文件c3p0.properties(既然是默认当然文件名不能随意更改)
配置如下：
c3p0.driverClass=com.mysql.jdbc.Driver
c3p0.jdbcUrl=jdbc:mysql://localhost:3306/jdbc
c3p0.user=root
c3p0.password=java
在程序中初始化数据化只需要调用：ComboPooledDataSource cpds = new ComboPooledDataSource();它会自动对属性文件进行解析。
3、类路径下配置一个默认的xml配置文件：c3p0-config.xml
这种方式和第二种方式类似，但是利用配置文件有一个好处就是支持多数据源的配置，提供default-config和named-config两种配置方式例如：
//配置MySQL和Oracle两种数据源的配置
&c3p0-config&
&default-config&
&property name="driverClass"&com.mysql.jdbc.Driver&/property&
&property name="jdbcUrl"&jdbc:mysql://localhost:3306/day16&/property&
&property name="user"&root&/property&
&property name="password"&root&/property&
&property name="initialPoolSize"&10&/property&
&property name="maxIdleTime"&30&/property&
&property name="maxPoolSize"&20&/property&
&property name="minPoolSize"&5&/property&
&property name="maxStatements"&200&/property&
&/default-config&
&named-config name="oracle"&
&property name="driverClass"&oracle.jdbc.driver.OracleDriver&/property&
&property name="jdbcUrl"&jdbc:oracle:thin:@127.0.0.1:1521:ORCL&/property&
&property name="user"&scott&/property&
&property name="password"&tiger&/property&
&property name="acquireIncrement"&50&/property&
&property name="initialPoolSize"&100&/property&
&property name="minPoolSize"&50&/property&
&property name="maxPoolSize"&1000&/property&&!-- intergalactoApp adopts a different approach to configuring statement caching --&
&property name="maxStatements"&0&/property&
&property name="maxIdleTime"&60&/property&
&property name="maxStatementsPerConnection"&5&/property&
&/named-config&
&/c3p0-config&
default-config表示默认的数据源配置，named-config表示自定义配置数据源，调用默认数据源和第二种方式一样，如果调用自定义数据源只需在构造方法里传递自定义数据源名即可，如上面name中的"oracle"：
ComboPooledDataSource cpds = new ComboPooledDataSource(“oracle”);
演示代码：
import java.sql.C
import java.sql.SQLE
import com.mchange.boPooledDataS
* C3P0连接池类
* @author Administrator
public class DBManager {
private static final DBManager dbm = new DBManager();
static ComboPooledDataSource cpds = new ComboPooledDataSource("oracle");
private Connection conn =
public DBManager(){}
* 获取连接
public synchronized Connection getConnection(){
conn = cpds.getConnection();
} catch (SQLException e) {
e.printStackTrace();
//观察当前连接状态(测试用)
public synchronized void getInfo() throws Exception{
System.out.println(cpds.getMaxPoolSize());// 最大连接数
System.out.println(cpds.getMinPoolSize());// 最小连接数
System.out.println(cpds.getNumBusyConnections());// 正在使用连接数
System.out.println(cpds.getNumIdleConnections());// 空闲连接数
System.out.println(cpds.getNumConnections());// 总连接数
浏览: 5268 次Hibernate C3P0数据库连接池配置办法 | 基于实例代码分步讲解 一站式学习Java |
建立数据库连接时比较消耗时间的，所以通常都会采用数据库连接池的技术来建立多条数据库连接，并且在将来持续使用，从而节约掉建立数据库连接的时间
hibernate本身是提供了数据库连接池的，但是hibernate官网也不推荐使用他自带的数据库连接池。
一般都会使用第三方的数据库连接池
C3P0是免费的第三方的数据库连接池，并且有不错的表现
右边可以下载c3p0的jar包
注：当运行次数不大的时候，从运行效果上来看，是看不出区别的。 只有在高并发量的情况下，才会体会出来。本知识主要是提供这个相关配置办法，以供以后有需要的时候，查询与修改方便。
加上高亮的配置即可，代码无需做任何改动
&?xml version='1.0' encoding='utf-8'?&
&!DOCTYPE hibernate-configuration PUBLIC
&-//Hibernate/Hibernate Configuration DTD 3.0//EN&
&http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd&&
&hibernate-configuration&
&session-factory&
&!-- Database connection settings --&
&property name=&connection.driver_class&&com.mysql.jdbc.Driver&/property&
&property name=&connection.url&&jdbc:mysql://localhost:3306/test?characterEncoding=GBK&/property&
&property name=&connection.username&&root&/property&
&property name=&connection.password&&admin&/property&
&!-- SQL dialect --&
&property name=&dialect&&org.hibernate.dialect.MySQLDialect&/property&
&property name=&current_session_context_class&&thread&/property&
&property name=&show_sql&&true&/property&
&property name=&hbm2ddl.auto&&update&/property&
&property name=&hibernate.connection.provider_class&&
org.hibernate.connection.C3P0ConnectionProvider
&/property&
&property name=&hibernate.c3p0.max_size&&20&/property&
&property name=&hibernate.c3p0.min_size&&5&/property&
&property name=&hibernate.c3p0.timeout&&50000&/property&
&property name=&hibernate.c3p0.max_statements&&100&/property&
&property name=&hibernate.c3p0.idle_test_period&&3000&/property&
&!-- 当连接池耗尽并接到获得连接的请求，则新增加连接的数量 --&
&property name=&hibernate.c3p0.acquire_increment&&2&/property&
&!-- 是否验证，检查连接 --&
&property name=&hibernate.c3p0.validate&&false&/property&
&mapping resource=&com/how2java/pojo/Product.hbm.xml& /&
&mapping resource=&com/how2java/pojo/Category.hbm.xml& /&
&mapping resource=&com/how2java/pojo/User.hbm.xml& /&
&/session-factory&
&/hibernate-configuration&
记得要把上一步的二级缓存的相关配置去掉
&?xml version=&1.0&?&
&!DOCTYPE hibernate-mapping PUBLIC
&-//Hibernate/Hibernate Mapping DTD 3.0//EN&
&http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd&&
&hibernate-mapping package=&com.how2java.pojo&&
&class name=&Category& table=&category_&&
&cache usage=&read-only& /&--&
&id name=&id& column=&id&&
&generator class=&native&&
&/generator&
&property name=&name& /&
&set name=&products& lazy=&true&&
&key column=&cid& not-null=&false& /&
&one-to-many class=&Product& /&
&/hibernate-mapping&
注：当运行次数不大的时候，从运行效果上来看，是看不出区别的。 只有在高并发量的情况下，才会体会出来。本知识主要是提供这个相关配置办法，以供以后有需要的时候，查询与修改方便。
package com.how2java.
import org.hibernate.S
import org.hibernate.SessionF
import org.hibernate.cfg.C
public class TestHibernate {
public static void main(String[] args) {
SessionFactory sf = new Configuration().configure().buildSessionFactory();
Session s = sf.openSession();
s.beginTransaction();
s.createQuery(&from Category&).list();
s.getTransaction().commit();
s.close();
sf.close();
package com.how2java.
import org.hibernate.S
import org.hibernate.SessionF
import org.hibernate.cfg.C
public class TestHibernate {
public static void main(String[] args) {
SessionFactory sf = new Configuration().configure().buildSessionFactory();
Session s = sf.openSession();
s.beginTransaction();
s.createQuery(&from Category&).list();
s.getTransaction().commit();
s.close();
sf.close();
在右上角有本知识点对应的可运行项目下载 ,实在自己搞不出来，就下载解压出来比较一下
把你的代码复制到下面区域
根据练习目标尽量自己实现代码效果，期间会碰到疑问，难题，和自己不懂的地方，这些都是必要的过程
完成过程中，碰到无法解决的问题，带着疑问，查看答案，分析答案的解决思路
依然有不明白的地方，点开视频讲解，带着疑问，听视频讲解有问题的部分
理解后，再从头做一遍，把有疑问的地方都捋清楚
最后再总结一边，总结思路，总结解决办法，以后遇到类似的问题，怎么处理
把这时的想法，思路，研究都记录下来，等全部学完了，再回过头来巩固和理解，学习效果就会很好，知识点掌握得也牢固
答案时间：
答案时间：
答案时间：
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
提问之前请SSH框架整合——基于XML配置文件_ASP.NET技巧_动态网站制作指南
SSH框架整合——基于XML配置文件
来源：人气：48
SSH框架整合——基于配置文件
@(Sing)[spring, struts2, hibernate, 框架整合, ssh, Spring]
SSH框架整合基于XML配置文件
SSH框架整合
SSH框架整合的基本环境准备
第一步创建web项目引入jar包
第二步引入框架的配置文件
第三步创建包结构和类
第四步将Service和DAO交给Spring管理
第五步引入页面
SSH整合Struts2和Spring的整合
第六步修改页面链接为Struts2所能匹配的格式
第七步编写Action中的listCustomer方法
第八步Struts2和Spring整合方式一Action由Struts2自身创建
第八步Struts2和Spring整合方式二Action交给Spring管理推荐
第九步在客户Service中使用客户Dao
SSH整合Hibernate和Spring的整合
第十步Hibernate和Spring整合方式一带hibernate的配置文件
第十步Hibernate和Spring整合方式二不带hibernate的配置文件推荐
第十一步添加事务管理
Hibernate的的API
使用Hibernate的模板完成CRUD的操作
完成增删改的操作
完成查询的操作
配置openInView过滤器解决Hibernate懒加载问题
配置全站编码过滤器
SSH框架整合
该SSH整合是基于Spring4、Struts2、Hibernate5的。
SSH框架整合的基本环境准备
第一步：创建web项目，引入jar包
标红为整合必须引入的
struts-2.3.24\apps\struts2-blank\WEB-INF\lib*.jar —Struts2基本开发包
struts2-convention-plugin-2.3.24.jar
—Struts2的注解开发包
struts2-spring-plugin-2.3.24.jar
—Struts2整合Spring的开发包
struts2-json-plugin-2.3.24.jar
—Struts2整合的开发包
x.servlet..jstl-1.2.1.jar
— java标准标签库
-connector-java-5.1.7-bin.jar
hibernate-release-5.0.7.Final\lib\required*.jar
—Hibernate必须包
c3p0连接池
注意：在struts2基础包和Hibernate5基础包中javassist-x.jar这个包会有冲突，搭环境时请使用Hibernate中的高版本javassist的包
Spring的基本开发包
Spring的AOP的开发包
Spring整合web项目包：spring-web-4.2.4.RELEASE.jar
Spring整合Junit项目包
spring-test-4.2.4.RELEASE.jar
junit-4.9.jar
Spring的JDBC模板包：spring-jdbc-4.2.4.RELEASE.jar
Spring事务管理包：spring-tx-4.2.4.RELEASE.jar
Spring整合Hibernate：spring-orm-4.2.4.RELEASE.jar
整合c3p0连接池：.mchange.v2.c3p0-0.9.1.2.jar，需要使用c3p0连接池，可以导入。
如果使用有hibernate配置文件的ssh整合，使用c3p0连接池，需要使用hibernate中c3p0可选包中的三个jar包；
如果使用没有hibernate配置文件的ssh整合，使用c3p0连接池，需要使用spring整合c3p0连接池中的jar包。
两者不可同用，否则会有冲突。
第二步：引入框架的配置文件
&!-- Struts核心过滤器 --&
&filter-name&struts2&/filter-name&
&filter-class&org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter&/filter-class&
&filter-mapping&
&filter-name&struts2&/filter-name&
&url-pattern&/*&/url-pattern&
&/filter-mapping&
struts.xml
&?xml version="1.0" encoding="UTF-8"?&
&!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
"http://struts.apache.org/dtds/struts-2.3.dtd"&
hibernate.cfg.xml
&?xml version="1.0" encoding="UTF-8"?&
&!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"&
&hibernate-configuration&
&session-factory&
&/session-factory&
&/hibernate-configuration&
&?xml version="1.0" encoding="UTF-8"?&
&!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"&
&hibernate-mapping package=""&
&/hibernate-mapping&
&!-- 配置Spring上下文环境 --&
&context-param&
&param-name&contextConfigLocation&/param-name&
&param-value&classpath:Context.xml&/param-value&
&/context-param&
&listener&
&listener-class&org.springframework.web.context.ContextLoaderListener&/listener-class&
&/listener&
applicationContext.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:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd"&
log4j.properties
### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c\:mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### set log levels - for more verbose logging change 'info' to 'debug' ###
log4j.rootLogger=info, stdout
第三步：创建包结构和类
package com.pc.crm.
import java.io.S
* 客户实体类
* @author Switch
public class Customer implements Serializable {
private static final long serialVersionUID = 6309236L;
package com.pc.crm.web.
import com.opensymphony.xwork2.ActionS
import com.opensymphony.xwork2.ModelD
import com.pc.crm.domain.C
* 客户Action
* @author Switch
public class CustomerAction extends ActionSupport implements ModelDriven&Customer& {
private static final long serialVersionUID = 0064108L;
Customer customer = new Customer();
public Customer getModel() {
return this.
package com.pc.crm.
* 客户服务接口
* @author Switch
public interface CustomerService {
package com.pc.crm.service.
import com.pc.crm.service.CustomerS
* 客户服务实现类
* @author Switch
public class CustomerServiceImpl implements CustomerService {
package com.pc.crm.
* 客户持久层接口
* @author Switch
public interface CustomerDao {
package com.pc.crm.dao.
import com.pc.crm.dao.CustomerD
* 客户持久层接口实现类
* @author Switch
public class CustomerDaoImpl implements CustomerDao {
第四步：将Service和DAO交给Spring管理
&!-- 配置客户服务bean --&
&bean id="customerService" class="com.pc.crm.service.impl.CustomerServiceImpl"&
&!-- 配置客户持久层bean --&
&bean id="customerDao" class="com.pc.crm.dao.impl.CustomerDaoImpl"&
第五步：引入页面
这里只给出一个访问链接，基于JSP的。
&a href="${pageContext.request.contextPath}/customer/listCustomer"&客户列表&/a&
SSH整合：Struts2和Spring的整合
第六步：修改页面链接为Struts2所能匹配的格式
&a href="${pageContext.request.contextPath}/customer/list_Customer.action"&客户列表&/a&
第七步：编写Action中的listCustomer方法
package com.pc.crm.web.
import java.util.L
import com.opensymphony.xwork2.ActionS
import com.opensymphony.xwork2.ModelD
import com.pc.crm.domain.C
import com.pc.crm.service.CustomerS
* 客户Action
* @author Switch
public class CustomerAction extends ActionSupport implements ModelDriven&Customer& {
private static final long serialVersionUID = 0064108L;
// 客户服务类
CustomerService customerS
// 用于使用值栈特性，在页面中使用
List&Customer& customers =
public List&Customer& getCustomers() {
public void setCustomers(List&Customer& customers) {
this.customers =
// 模型驱动
Customer customer = new Customer();
public Customer getModel() {
return this.
* 显示客户列表
public String listCustomer() {
// 从数据库中获客户列表
customers = customerService.findAllCustomer();
// 转发到客户列表视图
return "list";
第八步：Struts2和Spring整合方式一：Action由Struts2自身创建
引入Struts2和Spring整合的插件包
struts2-spring-plugin-2.3.24.jar
该jar包下有一个struts-plugin.xml的文件，在该文件中开启了Spring工厂对Action中的属性按照名称自动装配等功能。
Make the Spring object factory the automatic default --&
&constant name="struts.objectFactory" value="spring" /&
该常量在struts2核心包的default.properties文件中，有如下配置
### if specified, the default object factory can be overridden here
### Note: short-hand notation is supported in some cases, such as "spring"
Alternatively, you can provide a com.opensymphony.xwork2.ObjectFactory subclass name here
# struts.objectFactory = spring
### specifies the autoWiring logic when using the SpringObjectFactory.
### valid values are: name, type, auto, and constructor (name is the default)
struts.objectFactory.spring.autoWire = name
### indicates to the struts-spring integration if Class instances should be cached
### this should, until a future Spring release makes it possible, be left as true
### unless you know exactly what you are doing!
### valid values are: true, false (true is the default)
struts.objectFactory.spring.useClassCache = true
### ensures the autowire strategy is always respected.
### valid values are: true, false (false is the default)
struts.objectFactory.spring.autoWire.alwaysRespect = false
### By default SpringObjectFactory doesn't support AOP
### This flag was added just temporally to check if nothing is broken
### See https://issues.apache.org/jira/browse/WW-4110
struts.objectFactory.spring.enableAopSupport = false
当struts.objectFactory常量启用时，开启对Spring的一系列支持。比如说按名自动装配。
在Action中不需要使用原来的工厂获取，提供set方法即可。
// 客户服务类
CustomerService customerS
public void setCustomerService(CustomerService customerService) {
this.customerService = customerS
* customerService未优化
/* public CustomerAction() {
ApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(ServletActionContext.getServletContext());
customerService = context.getBean("customerService", CustomerService.class);
配置Action：Action是Struts2自身创建
&package name="customer" extends="struts-default" namespace="/customer"&
&!-- 形如list_Customer --&
&action name="*_*" class="com.pc.crm.web.action.CustomerAction" method="{1}{2}"&
&!-- 转发到客户列表视图 --&
&result name="list" type="dispatcher"&/jsp/customer/list.jsp&/result&
&/package&
第八步：Struts2和Spring整合方式二：Action交给Spring管理（推荐）
引入Struts2和Spring整合的插件包
struts2-spring-plugin-2.3.24.jar
将Action交给Spring创建
&!-- 配置Action，Action注入属性，必须手工注入，且必须声明为多例 --&
&!-- 客户Action --&
&bean id="customerAction" class="com.pc.crm.web.action.CustomerAction" scope="prototype"&
&property name="customerService" ref="customerService" /&
注意的事项
一定要将Action配置为多例的
属性的注入必须手动完成
struts.xml文件中对应action的class属性为bean的id属性
&package name="customer" extends="struts-default" namespace="/customer"&
&!-- 形如list_Customer --&
&action name="*_*" class="customerAction" method="{1}{2}"&
&!-- 转发到客户列表视图 --&
&result name="list" type="dispatcher"&/jsp/customer/list.jsp&/result&
&/package&
第九步：在客户Service中使用客户Dao
package com.pc.crm.service.
import java.util.L
import com.pc.crm.dao.CustomerD
import com.pc.crm.domain.C
import com.pc.crm.service.CustomerS
* 客户服务实现类
* @author Switch
public class CustomerServiceImpl implements CustomerService {
// 注入客户Dao
private CustomerDao customerD
public void setCustomerDao(CustomerDao customerDao) {
this.customerDao = customerD
public List&Customer& findAllCustomer() {
// 查找客户列表
return customerDao.findAllCustomer();
&!-- 配置客户服务bean --&
&bean id="customerService" class="com.pc.crm.service.impl.CustomerServiceImpl"&
&property name="customerDao" ref="customerDao"/&
SSH整合：Hibernate和Spring的整合
第十步：Hibernate和Spring整合方式一：带hibernate的配置文件
创建实体类和映射文件Customer.hbm.xml
package com.pc.crm.
import java.io.S
* 客户实体类
* @author Switch
public class Customer implements Serializable {
private static final long serialVersionUID = 6309236L;
private Long custId;
private String custN
private String custS
private String custI
private String custL
private String custA
private String custP
&?xml version="1.0" encoding="UTF-8"?&
&!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"&
&hibernate-mapping package="com.pc.crm.domain"&
&class name="Customer" table="cst_customer" lazy="true" batch-size="3"&
&id name="custId" column="cust_id" type="java.lang.Long"&
&generator class="native"/&
&property name="custName" column="cust_name" type="java.lang.String" length="32"/&
&property name="custSource" column="cust_source" type="java.lang.String" length="32"/&
&property name="custIndustry" column="cust_industry" type="java.lang.String" length="32"/&
&property name="custLevel" column="cust_level" type="java.lang.String" length="32"/&
&property name="custAddress" column="cust_address" type="java.lang.String" length="128"/&
&property name="custPhone" column="cust_phone" type="java.lang.String" length="64"/&
&/hibernate-mapping&
配置hibernate.cfg.xml配置文件
&?xml version="1.0" encoding="UTF-8"?&
&!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"&
&hibernate-configuration&
&session-factory&
&!-- 1、连接数据库的基本信息 --&
&property name="hibernate.connection.driver_class"&com.mysql.jdbc.Driver&/property&
&property name="hibernate.connection.url"&jdbc:mysql://localhost:3306/mycrm&/property&
&property name="hibernate.connection.username"&root&/property&
&property name="hibernate.connection.pass"&123456&/property&
&!-- 数据库的方言 --&
&property name="hibernate.dialect"&org.hibernate.dialect.MySQLDialect&/property&
&!-- 2、hibernate的基本配置 --&
&!-- 是否显示SQL语句 --&
&property name="hibernate.show_sql"&true&/property&
&!-- 是否格式化显示SQL语句 --&
&property name="hibernate.format_sql"&true&/property&
&!-- 采用何种策略来创建表结构： --&
&!-- update：检查表结构和实体类映射文件的变化，如果发现映射文件和表结构不一致，更新表结构。 --&
&property name="hibernate.hbm2ddl.auto"&update&/property&
&!-- 配置hibernate使用连接池：告知Hibernate使用连接池的厂商 --&
&property name="hibernate.connection.provider_class"&org.hibernate.connection.C3P0ConnectionProvider&/property&
&!-- 3、映射文件的位置 --&
&mapping resource="com/pc/crm/domain/Customer.hbm.xml" /&
&mapping resource="com/pc/crm/domain/LinkMan.hbm.xml" /&
&/session-factory&
&/hibernate-configuration&
在Spring中引入Hibernate的配置文件
&!-- 配置Hibernate的SessionFactory,有hibernate配置文件 --&
&bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean"&
&property name="configLocation" value="classpath:hibernate.cfg.xml"/&
Spring为了简化Hibernate的开发，提供了Hibernate的模板
package com.pc.crm.dao.
import java.util.L
import org.springframework.orm.hibernate5.support.HibernateDaoS
import com.pc.crm.dao.CustomerD
import com.pc.crm.domain.C
* 客户持久层接口实现类
* @author Switch
public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {
public List&Customer& findAllCustomer() {
&!-- 配置客户持久层bean --&
&bean id="customerDao" class="com.pc.crm.dao.impl.CustomerDaoImpl"&
&!-- 该bean继承了HibernateDaoSupport，则可以直接注入sessionFactory --&
&property name="sessionFactory" ref="sessionFactory"/&
在客户Dao中使用Hibernate的模板
package com.pc.crm.dao.
import java.util.L
import org.springframework.orm.hibernate5.support.HibernateDaoS
import com.pc.crm.dao.CustomerD
import com.pc.crm.domain.C
* 客户持久层接口实现类
* @author Switch
public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {
public List&Customer& findAllCustomer() {
return (List&Customer&) this.getHibernateTemplate().find("from Customer");
第十步：Hibernate和Spring整合方式二：不带hibernate的配置文件（推荐）
创建实体类和映射文件Customer.hbm.xml
package com.pc.crm.
import java.io.S
* 客户实体类
* @author Switch
public class Customer implements Serializable {
private static final long serialVersionUID = 6309236L;
private Long custId;
private String custN
private String custS
private String custI
private String custL
private String custA
private String custP
&?xml version="1.0" encoding="UTF-8"?&
&!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"&
&hibernate-mapping package="com.pc.crm.domain"&
&class name="Customer" table="cst_customer" lazy="true" batch-size="3"&
&id name="custId" column="cust_id" type="java.lang.Long"&
&generator class="native"/&
&property name="custName" column="cust_name" type="java.lang.String" length="32"/&
&property name="custSource" column="cust_source" type="java.lang.String" length="32"/&
&property name="custIndustry" column="cust_industry" type="java.lang.String" length="32"/&
&property name="custLevel" column="cust_level" type="java.lang.String" length="32"/&
&property name="custAddress" column="cust_address" type="java.lang.String" length="128"/&
&property name="custPhone" column="cust_phone" type="java.lang.String" length="64"/&
&/hibernate-mapping&
替换hibernate.cfg.xml中的相关内容，将其配置在spring中
提供数据库属性文件db.properties
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mycrm
jdbc.user=root
jdbc.password=123456
配置属性持有对象
&!-- 配置属性持有对象 --&
&context:property-placeholder location="classpath:db.properties"/&
配置数据源
&!-- 配置数据源 --&
&bean id="dataSource" class="com.mchange.boPooledDataSource"&
&property name="driverClass" value="${jdbc.driverClass}"/&
&property name="jdbcUrl" value="${jdbc.url}"/&
&property name="user" value="${jdbc.user}"/&
&property name="password" value="${jdbc.password}"/&
替换hibernate配置信息
&!-- 配置Hibernate的SessionFactory,无hibernate配置文件 --&
&bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean"&
&!-- 配置数据源 --&
&property name="dataSource" ref="dataSource"/&
&!-- 配置hibernate属性--&
&property name="hibernateProperties"&
&!-- 数据库的方言 --&
&prop key="hibernate.dialect"&org.hibernate.dialect.MySQLDialect&/prop&
&!-- 是否显示SQL语句 --&
&prop key="hibernate.show_sql"&true&/prop&
&!-- 是否格式化显示SQL语句 --&
&prop key="hibernate.format_sql"&true&/prop&
&!-- 采用何种策略来创建表结构： --&
&prop key="hibernate.hbm2ddl.auto"&update&/prop&
&/property&
&!-- 配置映射文件 --&
&property name="mappingLocations" value="classpath:com/pc/crm/domain/*.hbm.xml"/&
Spring为了简化Hibernate的开发，提供了Hibernate的模板
package com.pc.crm.dao.
import java.util.L
import org.springframework.orm.hibernate5.support.HibernateDaoS
import com.pc.crm.dao.CustomerD
import com.pc.crm.domain.C
* 客户持久层接口实现类
* @author Switch
public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {
public List&Customer& findAllCustomer() {
&!-- 配置客户持久层bean --&
&bean id="customerDao" class="com.pc.crm.dao.impl.CustomerDaoImpl"&
&!-- 该bean继承了HibernateDaoSupport，则可以直接注入sessionFactory --&
&property name="sessionFactory" ref="sessionFactory"/&
在客户Dao中使用Hibernate的模板
package com.pc.crm.dao.
import java.util.L
import org.springframework.orm.hibernate5.support.HibernateDaoS
import com.pc.crm.dao.CustomerD
import com.pc.crm.domain.C
* 客户持久层接口实现类
* @author Switch
public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {
public List&Customer& findAllCustomer() {
return (List&Customer&) this.getHibernateTemplate().find("from Customer");
第十一步：添加事务管理
配置事务管理器
&!-- 配置事务管理器 --&
&bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager"&
&property name="sessionFactory" ref="sessionFactory"/&
配置事务通知
&!-- 配置事务通知 --&
&tx:advice id="txAdvice" transaction-manager="transactionManager"&
&tx:attributes&
&!-- 事务管理策略，查为只读 --&
&!-- 事务隔离级别：mysql为可重复读，事务传播行为：默认值required --&
&tx:method name="find*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true"/&
&tx:method name="get*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true"/&
&tx:method name="save*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/&
&tx:method name="*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/&
&/tx:attributes&
&/tx:advice&
配置事务AOP
&!-- 配置事务AOP --&
&aop:config&
&aop:pointcut expression="execution(* com.pc.crm.service.impl.*.*(..))" id="pointcut1"/&
&aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1"/&
&/aop:config&
PS：如果需要配置基于注解的事务，请参考之前的博文《Spring事务管理》。
Hibernate的模板的API
使用Hibernate的模板完成CRUD的操作
完成增删改的操作
Serializable save(Object obj);
void update(Object obj);
void delete(Object obj);
package com.pc.crm.dao.
import java.util.L
import org.hibernate.criterion.DetachedC
import org.springframework.orm.hibernate5.support.HibernateDaoS
import com.pc.crm.dao.CustomerD
import com.pc.crm.domain.C
* 客户持久层接口实现类
* @author Switch
public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {
public void save(Customer customer) {
this.getHibernateTemplate().save(customer);
public void update(Customer customer) {
this.getHibernateTemplate().update(customer);
public void delete(Customer customer) {
this.getHibernateTemplate().delete(customer);
完成查询的操作
T get(Class c,Serializable id); / T load(Class c,Serializable id);
package com.pc.crm.dao.
import java.util.L
import org.hibernate.criterion.DetachedC
import org.springframework.orm.hibernate5.support.HibernateDaoS
import com.pc.crm.dao.CustomerD
import com.pc.crm.domain.C
* 客户持久层接口实现类
* @author Switch
public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {
public Customer findById(Long id) {
return this.getHibernateTemplate().load(Customer.class, id);
public List&Customer& findAll() {
// 使用HQL查询:
// List&Customer& list = (List&Customer&) this.getHibernateTemplate().find("from Customer ");
// 使用QBC查询:使用DetchedCriteria
// DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class);
// List&Customer& list = (List&Customer&) this.getHibernateTemplate().findByCriteria(detachedCriteria);
// 命名查询：
List&Customer& list = (List&Customer&) this.getHibernateTemplate().findByNamedQuery("queryAll");
public List&Customer& findByPage() {
DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class);
List&Customer& list = (List&Customer&) this.getHibernateTemplate().findByCriteria(detachedCriteria, 0, 3);
配置openSessionInView过滤器，解决Hibernate懒加载问题
&!-- 配置openSessionInView，解决Hibernate懒加载问题 --&
&filter-name&OpenSessionInViewFilter&/filter-name&
&filter-class&org.springframework.orm.hibernate5.support.OpenSessionInViewFilter&/filter-class&
&filter-mapping&
&filter-name&OpenSessionInViewFilter&/filter-name&
&url-pattern&*.action&/url-pattern&
&/filter-mapping&
PS：将该过滤器放在Struts2核心过滤器上面。
配置全站编码过滤器
&!-- 配置全站编码过滤器 --&
&filter-name&CharacterEncodingFilter&/filter-name&
&filter-class&org.springframework.web.filter.CharacterEncodingFilter&/filter-class&
&!-- 编码 --&
&init-param&
&param-name&encoding&/param-name&
&param-value&UTF-8&/param-value&
&/init-param&
&!-- 是否强制使用该编码 --&
&init-param&
&param-name&forceEncoding&/param-name&
&param-value&true&/param-value&
&/init-param&
&filter-mapping&
&filter-name&CharacterEncodingFilter&/filter-name&
&url-pattern&/*&/url-pattern&
&/filter-mapping&
PS：将该过滤器放在Struts2核心过滤器上面。
优质网站模板