本实例数据库是MySQL:
1.为了方便维护与管理，建立一个数据库配置文件dbconfig.properties,文件内容如下：
dataBaseType = MySQL
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf-8
jdbc.username=root
jdbc.password=root
hibernate.dialect=org.hibernate.dialect.MySQLDialect
jdbc.initialPoolSize=10
#Output SQL statements to console,true:yes ,false:no
hibernate.show_sql=true
#Inquires the cache true:yes ,false:no
hibernate.cache.use_query_cache=true
hibernate.substitutions=true 1, false 0, yes 'Y', no 'N'
hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider
2. spring配置数据库文件applicationContext-db.xml
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<bean id="propertyConfigure" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<value>classpath:dbconfig.properties</value>
</list>
</property>
</bean>
<!-- 数据库连接池配置，本例以用c3p0方式配置 -->
<bean id="sysDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
<!-- 数据库驱动 -->
<property name="driverClass"><value>${jdbc.driverClassName}</value></property>
<!-- 数据库连接地址 -->
<property name="jdbcUrl"><value>${jdbc.url}</value></property>
<!-- 用户名 -->
<property name="user"><value>${jdbc.username}</value></property>
<!-- 用户密码 -->
<property name="password"><value>${jdbc.password}</value></property>
<!-- 初始化连接池大小 -->
<property name="initialPoolSize"><value>${jdbc.initialPoolSize}</value></property>
</bean>
<!-- JDBC start 无事务-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="sysDataSource" />
</bean>
<!-- JDBc end -->
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<property name="dataSource">
<ref bean="sysDataSource" />
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">${hibernate.dialect}</prop>
<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
<prop key="hibernate.cache.provider_class">${hibernate.cache.provider_class}</prop>
<prop key="hibernate.cache.use_query_cache">${hibernate.cache.use_query_cache}</prop>
<prop key="hibernate.jdbc.batch_size">30</prop>
</props>
</property>
<!-- hibernate配置文件（xml类型） -->
<property name="mappingResources">
<list>
<value>/****.xml</value>
</list>
</property>
<!-- hibernate配置文件（annotation类型） -->
<property name="annotatedClasses">
<list>
<value>com.**.pojo.*Model</value>
</list>
</property>
</bean>
<!-- jdbc操作数据库模板 -->
<bean id="CDBManager" class="com.***.CDBManager">
</bean>
</beans>
3. 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"
xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<!-- 事务管理器，将委托给HibernateTransactionManager进行管理//-->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<!-- 事务处理的AOP配置 所有服务层bean声明都要继承此bean//-->
<bean id="TransactionProxyTemplate" abstract="true"
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager" ref="transactionManager" />
<property name="transactionAttributes">
<props>
<!-- 为了保证服务层统一的事务处理。服务层接口，类的方法必须以下面的方法为开口 -->
<!--spring 捕获到RuntimeException和其他一些异常时才会回滚，不是所有异常都会回滚，-Exception 设置 为任何异常都回滚 -->
<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="query*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="save*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="insert*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="update*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="delete*">PROPAGATION_REQUIRED,-Exception </prop>
<prop key="execute*">PROPAGATION_REQUIRED,-Exception</prop>
</props>
</property>
</bean>
<!-- 提供普通java类获取spring上下文 通过上下文获取具体bean,调用其中的方法 -->
<bean id="springApplicationContextUtil" class="**.util.SpringApplicationContextUtil"></bean>
</beans>
4. jdbc数据连接类CDBManager.java
import java.sql.Connection;
import java.sql.SQLException;
import javax.sql.DataSource;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
/**
* <p>Title:简单的数据连接类</p>
*/
public class CDBManager implements ApplicationContextAware {
private static ApplicationContext applicationContext;
/**
* 获取数据源
* @return
*/
public static DataSource getDataSource() {
DataSource dataSource = (DataSource) applicationContext.getBean("sysDataSource");
return dataSource;
}
/**
* 获取连接
* @return
*/
public static Connection getConn() {
DataSource ds = null;
Connection con = null;
try {
ds = getDataSource();
con = ds.getConnection();
} catch (SQLException e) {
e.printStackTrace();
}
return con;
}
/**
* 获取数据源上下文
*/
public void setApplicationContext(ApplicationContext context) throws BeansException {
applicationContext = context;
}
}
5.普通java类获取spring上下文类 SpringApplicationContextUtil.java
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
/**
* <p>Title:springcontex类 </p>
* <p>Description:提供供普通java类获取spring上下文 通过上下文获取具体bean,调用其中的方法</p>
*/
public class SpringApplicationContextUtil implements ApplicationContextAware {
//声明一个静态变量保存
private static ApplicationContext context;
@SuppressWarnings("static-access")
public void setApplicationContext(ApplicationContext context)
throws BeansException {
this.context = context;
}
public static ApplicationContext getContext(){
return context;
}
public static Object getBean(String beanName){
if (StringUtils.isEmpty(beanName)) {
return null;
}
return getContext().getBean(StringUtils.trim(beanName));
}
}
6.普通spring配置文件（applicationContext-test.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"
xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<!-- 测试Dao -->
<bean id="testDao" class="com.**.HibernateEntityDao">
<property name="sessionFactory" ref="sessionFactory"></property>
<property name="entityClass" value="com.**.model.TestModel"></property>
</bean>
<!-- 测试Service -->
<bean id="testService" parent="TransactionProxyTemplate">
<property name="target">
<bean class="com.**.service.imp.testServiceImp">
<property name="testDao" ref="testDao"></property>
</bean>
</property>
</bean>
<!-- 测试Action -->
<bean id="testAction" class="com.**.action.TestAction">
<property name="testService" ref="testService"></property>
</bean>
</beans>
7.HIbernateEntityDao.java类
package com.bobo.base.db;
import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.util.Iterator;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.beanutils.PropertyUtils;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.hibernate.metadata.ClassMetadata;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
/**
* <p>Title:泛型DAO </p>
* <p>Description:该类通过泛型定义了基于实体的基础DAO。该类继承HibernateDaoSupport，提供了常用的DAO方法。
* @author
* @version 1.0 2009-05-06
*/
public class HibernateEntityDao<T> extends HibernateDaoSupport {
private Class<T> entityClass;
public void setEntityClass(Class<T> entityClass) {
this.entityClass = entityClass;
}
/** 是否起用查询缓存 TRUE是，FALSE不启用 */
private static final boolean ISCACHE = true;
/**
* 存取过程，删除基本信息
* @param proce 调用存取过程 的字符串
* @param param 参数
*/
public void callProcedure(String proce,String param){
Session session =this.getSession();
SQLQuery query = session.createSQLQuery(proce);
query.setString(0, param);
query.executeUpdate();
}
/**
* 根据指定的ID获取实体对象。
*
* @param id
* 实体ID
* @return 返回指定ID的实体对象，如果没有找到则返回null。
*/
@SuppressWarnings("unchecked")
public T get(Serializable id) {
if (id == null) {
return null;
}
return (T) getHibernateTemplate().get(entityClass, id);
}
/**
* 根据指定的ID获取实体对象,支持延迟加载。
*
* @param id 实体ID
* @return 返回指定ID的实体对象，如果没有找到则抛出异常。
*/
@SuppressWarnings("unchecked")
public T load(Serializable id) {
if (id == null) {
return null;
}
return (T) getHibernateTemplate().load(entityClass, id);
}
/**
* 保存实体对象。
*
* @param entity
* 待保存实体对象
*/
public void save(T entity) {
getHibernateTemplate().save(entity);
}
/**
* 保存或修改持久化对象
*
* @param object
*/
public void saveOrUpdate(Object object) {
getHibernateTemplate().saveOrUpdate(object);
}
/**
* 更新实体对象.
*
* @param entity
* 待更新实体对象.
*/
@SuppressWarnings({ "hiding", "unchecked" })
public <T> T merge(T entity) {
return (T)getHibernateTemplate().merge(entity);
}
/**
* 删除实体对象。
*
* @param entity
* 待删除实体对象
*/
public void remove(T entity) {
getHibernateTemplate().delete(entity);
}
/**
* 根据ID删除实体对象。
*
* @param id
* 待删除实体对象ID
*/
public void remove(Serializable id) {
getHibernateTemplate().delete(get(id));
}
/**
* 删除多个实体对象
*
* @param entitys
* 待删除的实体对象集合
*/
public void remove(List<T> entitys) {
for (T entity : entitys) {
getHibernateTemplate().delete(entity);
}
}
/**
* 根据属性批量删除实体对象
*
* @param name
* 属性名
* @param value
* 属性值
*/
public void removeBy(String name, Object value) {
Query query = createQuery("delete from " + entityClass.getName() + " where "
+ name + "=?", value);
query.executeUpdate();
}
public int remove(String hsql, Object... values) {
int result = 0;
Query query = createQuery(hsql, values);
result = query.executeUpdate();
return result;
}
public int removeByHql(String hsql) {
int result = 0;
Query query = createQuery(hsql);
result = query.executeUpdate();
return result;
}
/**
* 清理当前Session。
*/
public void clear() {
getSession().clear();
}
/**
* 创建一个绑定实体类型的条件查询对象。
*
* @param criterions
* 查询条件
* @return 返回一个条件查询对象。
*/
public Criteria createCriteria(Criterion... criterions) {
Criteria criteria = getSession().createCriteria(entityClass);
for (Criterion c : criterions) {
criteria.add(c);
}
return criteria;
}
/**
* 创建一个查询对象。
*
* @param hql
* HQL语句
* @param values
* 参数值
* @return 返回一个查询对象。
*/
public Query createQuery(String hql, Object... values) {
Query query = getSession().createQuery(hql);
for (int i = 0; i < values.length; i++) {
query.setParameter(i, values[i]);
}
return query;
}
/**
* 创建一个绑定实体并设定了排序的条件查询对象。
*
* @param orderBy
* 排序属性
* @param isAsc
* 是否升序
* @param criterions
* 查询条件
* @return 返回一个已设定排序的条件查询对象。
*/
public Criteria createCriteria(String orderBy, Boolean isAsc,
Criterion... criterions) {
Criteria criteria = createCriteria(criterions);
if (isAsc) {
criteria.addOrder(Order.asc(orderBy));
} else {
criteria.addOrder(Order.desc(orderBy));
}
return criteria;
}
/**
* 获取指定类型的所有实体对象。
*
* @return 返回指定类型的所有实体对象。
*/
@SuppressWarnings("unchecked")
public List<T> getAll() {
Criteria criteria = createCriteria();
criteria.setCacheable(ISCACHE);
return criteria.list();
}
/**
* 获取指定类型的所有实体对象并进行排序。
*
* @param orderBy
* 排序的属性名
* @param isAsc
* 是否升序
* @return 返回排序后的指定类型的所有实体对象。
*/
@SuppressWarnings("unchecked")
public List<T> getAll(String orderBy, Boolean isAsc) {
Criteria criteria = createCriteria(orderBy, isAsc);
criteria.setCacheable(ISCACHE);
return criteria.list();
}
/**
* 根据属性的值查找实体对象。
*
* @param name
* 属性名
* @param value
* 属性值
* @return 返回属性值相符的实体对象集合，如果没有找到返回一个空的集合。
*/
@SuppressWarnings("unchecked")
public List<T> findBy(String name, Object value) {
Criteria criteria = createCriteria();
if (value == null) {
criteria.add(Restrictions.isNull(name));
} else {
criteria.add(Restrictions.eq(name, value));
}
criteria.setCacheable(ISCACHE);
return criteria.list();
}
/**
* 根据属性的值查找实体对象并进行排序。
*
* @param name
* 属性名
* @param value
* 属性值
* @param orderBy
* 排序属性
* @param isAsc
* 是否升序
* @return 返回排序后的属性值相符的实体对象集合，如果没有找到返回一个空的集合。
*/
@SuppressWarnings("unchecked")
public List<T> findBy(String name, Object value, String orderBy,
boolean isAsc) {
Criteria criteria = createCriteria(orderBy, isAsc);
if (value == null) {
criteria.add(Restrictions.isNull(name));
} else {
criteria.add(Restrictions.eq(name, value));
}
criteria.setCacheable(ISCACHE);
return criteria.list();
}
/**
* 判断是否存在属性重复的实体对象。
*
* @param entity
* 待判断的实体对象
* @param propNames
* 属性名，可以多个属性名用","分割
* @return 如果存在重复的实体对象返回false，否则返回true。
*/
public Boolean isUnique(T entity, String propNames) {
Criteria criteria = createCriteria().setProjection(
Projections.rowCount());
String[] nameList = propNames.split(",");
try {
for (String name : nameList) {
criteria.add(Restrictions.eq(name, PropertyUtils.getProperty(
entity, name)));
}
// 更新实体类时应该排除自身
String idName = getIdName();
Serializable id = getId(entity);
if (id != null && !idName.equals(propNames)) {
criteria.add(Restrictions.not(Restrictions.eq(idName, id)));
}
} catch (Exception e) {
throw new RuntimeException(e);
}
return Integer.parseInt(criteria.uniqueResult().toString()) == 0;
}
/**
* 根据属性的值查找唯一的实体对象。
*
* @param name
* 属性名
* @param value
* 属性值
* @return 返回指定唯一的实体对象，如果没有找到则返回null。
*/
@SuppressWarnings("unchecked")
public T findUnique(String name, Object value) {
Criteria criteria = createCriteria(Restrictions.eq(name, value));
criteria.setCacheable(ISCACHE);
return (T) criteria.uniqueResult();
}
/**
* 根据HQL查询语句进行查询。
*
* @param hql
* HQL查询语句
* @param values
* 参数值
* @return 返回查询得到的分页对象。
*/
@SuppressWarnings("unchecked")
public List findList(String hql, Object... values) {
Query query =createQuery(hql, values);
query.setCacheable(ISCACHE);
return query.list();
}
/**
* 根据HQL查询语句进行查询。
* query.iterate 在启用缓存且查询数据量比较大时
* 性能比 query.list()高
* @param hql HQL查询语句
* @param values 参数值
* @return 返回查询得到Iterator 数据集 。
*/
@SuppressWarnings("unchecked")
public Iterator<T> findIterator(String hql, Object... values) {
Query query =createQuery(hql, values);
query.setCacheable(ISCACHE);
return query.iterate();
}
/**
* 根据HQL查询语句进行分页查询。
*
* @param hql
* HQL查询语句
* @param pageNo
* 待获取的页数
* @param pageSize
* 每页的记录数
* @param values
* 参数值
* @return 返回查询得到的总数。
*/
@SuppressWarnings("unchecked")
public Integer getTotalCount(String hql,Object... values) {
String countQueryString = " select count (*) "
+ removeSelect(removeOrders(hql));
List countlist = createQuery(countQueryString, values).setCacheable(
ISCACHE).list();
int totalCount = Integer.parseInt(countlist.get(0).toString());
return totalCount;
}
/**
* 根据HQL查询语句进行分页查询。
*
* @param hql
* HQL查询语句
* @param pageNo
* 待获取的页数
* @param pageSize
* 每页的记录数
* @param values
* 参数值
* @return 返回查询得到的分页list对象。
*/
@SuppressWarnings("unchecked")
public List findPageList(String hql, Integer pageNo, Integer pageSize,
Object... values) {
String countQueryString = " select count (*) "
+ removeSelect(removeOrders(hql));
List countlist = createQuery(countQueryString, values).setCacheable(
ISCACHE).list();
int totalCount = Integer.parseInt(countlist.get(0).toString());
Integer pageCount = 0;
if (totalCount % pageSize > 0) {
pageCount = totalCount / pageSize + 1;
} else {
pageCount = totalCount / pageSize;
}
if (pageNo > pageCount) {
pageNo = pageCount;
}
if (pageNo < 1) {
pageNo =1;
}
Query query = createQuery(hql, values);
query.setCacheable(ISCACHE);
List list = query.setFirstResult((pageNo - 1) * pageSize).setMaxResults(pageSize).list();
return list;
}
/**
* 获取实体类的主键值。
*/
private Serializable getId(T entity) throws NoSuchMethodException,
IllegalAccessException, InvocationTargetException {
return (Serializable) PropertyUtils.getProperty(entity, getIdName());
}
/**
* 获取实体类的主键名。
*/
private String getIdName() {
ClassMetadata meta = getSession().getSessionFactory().getClassMetadata(
entityClass);
return meta.getIdentifierPropertyName();
}
/**
* 去除HQL查询语句的select部分。
*
* @param hql
* HQL查询语句
* @return 返回去除了select部分的语句。
*/
private String removeSelect(String hql) {
int beginPos = hql.toLowerCase().indexOf("from");
return hql.substring(beginPos);
}
/**
* 去除HQL查询语句的order by部分。
*
* @param hql
* HQL查询语句
* @return 返回去除了order by部分的语句。
*/
private String removeOrders(String hql) {
Pattern p = Pattern.compile("order\\s*by[\\w|\\W|\\s|\\S]*",
Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher(hql);
StringBuffer sb = new StringBuffer();
while (m.find()) {
m.appendReplacement(sb, "");
}
m.appendTail(sb);
return sb.toString();
}
/**
* 支持sql查询
* @param sql
* @param values
* @return
*/
@SuppressWarnings("unchecked")
public List executeSQL(final String sql,final Object... values) {
return (List)getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session) {
Query query = session.createSQLQuery(sql);
for (int i = 0; i < values.length; i++) {
query.setParameter(i, values[i]);
}
return query.list();
}
});
}
/**
* 支持sql查询
* @param sql
* @param values
* @return
*/
@SuppressWarnings("unchecked")
public List executeSQL(final String sql,final List values) {
return (List)getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session) {
Query query = session.createSQLQuery(sql);
for (int i = 0; i < values.size(); i++) {
query.setParameter(i, values.get(i));
}
return query.list();
}
});
}
/**
* 支持sql 新增 和修改
* @param sql
* @param values
* @return
*/
@SuppressWarnings("unchecked")
public Object executeSQLInsertOrUpdate(final String sql,final Object... values) {
return (Object)getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session) {
Query query = session.createSQLQuery(sql);
for (int i = 0; i < values.length; i++) {
query.setParameter(i, values[i]);
}
return query.executeUpdate();
}
});
}
/**
* 支持sql 新增 和修改
* @param sql
* @param values
* @return
*/
@SuppressWarnings("unchecked")
public Object executeSQLInsertOrUpdate(final String sql,final List values) {
return (Object)getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session) {
Query query = session.createSQLQuery(sql);
for (int i = 0; i < values.size(); i++) {
query.setParameter(i, values.get(i));
}
return query.executeUpdate();
}
});
}
/**
* 支持 HQL方式 更新数据
* @param hql
* @param values
* @return
*/
@SuppressWarnings("unchecked")
public Object update(final String hql,final Object... values) {
return (Object)getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session) {
Query query = session.createQuery(hql);
for (int i = 0; i < values.length; i++) {
query.setParameter(i, values[i]);
}
return query.executeUpdate();
}
});
}
/***
* HQL查询结果集 根据结果集 返回结果集记录总数
* @param countQueryString
* @param values
* @return
*/
@SuppressWarnings("unchecked")
public Integer getQueryPageListCount(String hql,Object...values){
int totalCount =0;
List countlist = createQuery(hql, values).setCacheable(ISCACHE).list();
if (countlist !=null) {
totalCount = countlist.size();
}
return totalCount;
}
/****
* 分页查询查询记录 同
* getQueryPageListCount(String hql,Object...values)
* 一起使用 达到分页查询
* @param hql
* @param pageNo 当前页
* @param pageSize 每页大小
* @param values
* @return
*/
@SuppressWarnings("unchecked")
public List<T> findQueryPageList(String hql, Integer pageNo, Integer pageSize, Object... values) {
Query query = createQuery(hql, values);
query.setCacheable(ISCACHE);
List list = query.setFirstResult((pageNo - 1) * pageSize).setMaxResults(pageSize).list();
return list;
}
/**
* 执行返回MAP对象的 返回的对象属性全部为大写字母
* <FIRSTNAME,"JISEN"><LASTNAME,"STANSEN">
* @param sql
* @return
*/
@SuppressWarnings("unchecked")
public List executeSql(String sql){
return this.getSession().createSQLQuery(sql).setResultTransformer(Criteria.ALIAS_TO_ENTITY_MAP).list();
}
}