本实例数据库是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>
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(); } }