package org.springframework.orm.hibernate3; import java.io.Serializable;
import java.util.List; import org.springframework.orm.hibernate3.HibernateTemplate; @SuppressWarnings("rawtypes")
public interface BaseDao<T> {
HibernateTemplate getHibernateTemplate(); Serializable save(T instance);
void delete(T instance);
void update(T instance);
void saveOrUpdate(T instance);
T findById(Serializable id);
List<T> findAll();
List<T> findByProperty(String propertyName, Object value);
Object uniqueResult(final String hql,final Object... paras);
List findByHql(String hql,Object... paras);
Integer executeByHql(final String hql,final Object... paras);
List findByHqlInCache(final String hql,final Object... paras);
List findPage(final String hql,final int maxResult,final int firstResult,final Object... paras);
List findBySQLQuery(final String sql,final Object... paras);
}
BaseDao.java
package org.springframework.orm.hibernate3; import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.List; import org.hibernate.HibernateException;
import org.hibernate.LockMode;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.type.Type;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.HibernateTemplate; /**
* Dao的基类，封装了绝大多数的数据库操作
* 命名查询、命名参数查询等在HibernateTemplate已经实现，直接使用即可。
* 调用存储过程使用命名查询来实现，具体参考Hibernate帮助文档
* 放在org.springframework.orm.hibernate3下的目的是为了调用HibernateTemplate的protected方法
*
* @param <T>
*/
@SuppressWarnings(value={"rawtypes","unchecked"})
public abstract class BaseDaoImpl<T> implements BaseDao<T> {
private Class<T> entityClass;
protected HibernateTemplate hibernateTemplate; public BaseDaoImpl() {
//当该类被继承时，它的子类需要初始化T，通过该代码获取T的类型
entityClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
} public Serializable save(T instance) {
return this.hibernateTemplate.save(instance);
} public void delete(T instance) {
this.hibernateTemplate.delete(instance);
} public void update(T instance) {
this.hibernateTemplate.update(instance);
} public void saveOrUpdate(T instance){
//瞬时态则save，游离态则update
hibernateTemplate.saveOrUpdate(instance);
}; public T findById(Serializable id){
T instance = hibernateTemplate.get(entityClass, id);
return instance;
} /**
* 根据HQL查询，支持单值查询，如使用聚合函数查询
*/
public List findByHql(String hql,Object... paras) {
return hibernateTemplate.find(hql, paras);
} /**
* 根据HQL进行增删改，支持单值查询，如使用聚合函数查询
* 插入操作只支持INSERT INTO ... SELECT ...形式,不支持INSERT INTO ... VALUES ...形式
* @param hql
* @param paras
* @return 受影响的行数
*/
public Integer executeByHql(final String hql,final Object... paras) {
return this.hibernateTemplate.executeWithNativeSession(new HibernateCallback<Integer>() {
public Integer doInHibernate(Session session) throws HibernateException {
Query query = session.createQuery(hql);
hibernateTemplate.prepareQuery(query);
if (paras != null) {
for (int i = 0; i < paras.length; i++) {
query.setParameter(i, paras[i]);
}
}
return query.executeUpdate();
}
});
} /**
* 根据HQL使用查询缓存进行查询
*/
public List findByHqlInCache(final String hql,final Object... paras) {
return hibernateTemplate.executeWithNativeSession(new HibernateCallback<List>() {
public List doInHibernate(Session session) throws HibernateException {
Query query = session.createQuery(hql);
hibernateTemplate.prepareQuery(query);
query.setCacheable(true);
if (paras != null) {
for (int i = 0; i < paras.length; i++) {
query.setParameter(i, paras[i]);
}
}
return query.list();
}
});
} /**
* 查询数据库中的所有对象
*/
public List<T> findAll(){
String hql = "from "+this.entityClass.getSimpleName();
List<T> list = hibernateTemplate.find(hql);
return list;
}; /**
* 根据属性查找
*/
public List<T> findByProperty(String propertyName, Object value){
String hql = "from "+this.entityClass.getSimpleName()+" where "+propertyName+"=?";
List<T> list = hibernateTemplate.find(hql,value);
return list;
} /**
* 单值查询
*/
public Object uniqueResult(final String hql,final Object... paras) {
return hibernateTemplate.executeWithNativeSession(new HibernateCallback<Object>() {
public Object doInHibernate(Session session) throws HibernateException {
Query query = session.createQuery(hql);
hibernateTemplate.prepareQuery(query);
if (paras != null) {
for (int i = 0; i < paras.length; i++) {
query.setParameter(i, paras[i]);
}
}
return query.uniqueResult();
}
});
} /**
* 分页查询，记录的下标从0开始
*/
public List findPage(final String hql,final int maxResult,final int firstResult,final Object... paras) {
return hibernateTemplate.executeWithNativeSession(new HibernateCallback<List>() {
public List doInHibernate(Session session){
Query query = session.createQuery(hql);
hibernateTemplate.prepareQuery(query);
query.setMaxResults(maxResult);
query.setFirstResult(firstResult);
if(paras != null){
for(int i = 0;i<paras.length;i++){
query.setParameter(i, paras[i]);
}
}
return query.list();
}
});
} /**
* 使用本地sql语句进行查询，在报表查询、复杂查询时可能用到
* @param sql
* @param paras
* @return
*/
public List findBySQLQuery(final String sql,final Object... paras) {
return hibernateTemplate.executeWithNativeSession(new HibernateCallback<List>() {
public List doInHibernate(Session session){
SQLQuery query = session.createSQLQuery(sql);
if(paras != null){
for(int i = 0;i<paras.length;i++){
query.setParameter(i, paras[i]);
}
}
return query.list();
}
});
} /**
* 将对象转化为瞬时态，只能在Transaction激活的时候使用
* @param instance
*/
private void convertToTransient(T instance) {
hibernateTemplate.getSessionFactory().getCurrentSession().lock(instance, LockMode.NONE);
} public HibernateTemplate getHibernateTemplate() {
return hibernateTemplate;
} public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
this.hibernateTemplate = hibernateTemplate;
} //还可以实现使用jdbc接口查询等功能
}
BaseDaoImpl.java
配置文件
<?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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
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.1.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.1.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.1.xsd"
default-lazy-init="false"
default-autowire="no"
> <!--支持基于注解的配置方式，为@Autowired、@Resource、@PostConstruct、@PreDestroy注解提供支持 -->
<context:annotation-config/> <!--支持annotation实现aop，并允许为没有实现接口的类实现切面 -->
<aop:aspectj-autoproxy proxy-target-class="true" /> <bean id="dataSource" destroy-method="close"
class="com.mchange.v2.c3p0.ComboPooledDataSource">
<!-- 连接数据库的驱动类 -->
<property name="driverClass" value="oracle.jdbc.driver.OracleDriver"/>
<!-- 连接数据库的url -->
<property name="jdbcUrl" value="jdbc:oracle:thin:@localhost:1521:orcl"/>
<!-- 连接数据库的用户名 -->
<property name="user" value="scott"/>
<!-- 连接数据库的密码 -->
<property name="password" value="orcl"/>
<!-- 连接池的最大连接数 -->
<property name="maxPoolSize" value="40"/>
<!-- 连接池的最小连接数 -->
<property name="minPoolSize" value="1"/>
<!-- 初始化连接数 -->
<property name="initialPoolSize" value="1"/>
<!-- 连接的最大空闲时间，超时的连接将被丢弃，单位：秒 -->
<property name="maxIdleTime" value="60"/>
<!-- 没有连接可用时，等待连接的时间，单位：毫秒 -->
<property name="checkoutTimeout" value="2000"/>
</bean> <bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="mappingLocations">
<list>
<value>classpath:com/ssh/entity/*.hbm.xml</value>
</list> </property>
</bean> <bean id="hibernateTemplate"
class="org.springframework.orm.hibernate3.HibernateTemplate">
<property name="sessionFactory" ref="sessionFactory" />
</bean> <!-- 为baseDaoImpl注入hibernateTemplate -->
<bean id="baseDao" class="org.springframework.orm.hibernate3.BaseDaoImpl" abstract="true">
<property name="hibernateTemplate" ref="hibernateTemplate" />
</bean> <!-- 所有dao对象，注意dao需要继承baseDao -->
<!-- <bean id="groupDao" class="com.pb.dao.impl.GroupDaoImpl" parent="baseDao"></bean>
<bean id="userDao" class="com.pb.dao.impl.UserDaoImpl" parent="baseDao"></bean> 所有service对象，注意service需要注入dao
<bean id="groupService" class="com.pb.service.impl.GroupServiceImpl">
<property name="groupDao" ref="groupDao" />
</bean>
<bean id="userService" class="com.pb.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao" />
<property name="groupDao" ref="groupDao" />
</bean> --> <!-- AOP 辅助功能 比如 日志 事务 性能 等 -->
<!-- 声明式事务处理配置 -->
<bean id="txManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<!-- 其他的事务处理配置 -->
<tx:advice id="txAdvice" transaction-manager="txManager">
<tx:attributes>
<!-- 匹配所有方法 -->
<tx:method name="*" propagation="REQUIRED"/>
<!-- 配置查询方法的事务处理操作为只读 -->
<tx:method name="search*" read-only="true"/>
<!-- 不将getter和setter方法纳入事务处理 -->
<tx:method name="get*" propagation="NEVER"/>
<tx:method name="set*" propagation="NEVER"/>
</tx:attributes>
</tx:advice>
<aop:config>
<!-- 配置链接点 (切入点) -->
<aop:pointcut expression="execution(public * com.ssh.service.*.*(..))"
id="servicepointcut"/>
<aop:advisor advice-ref="txAdvice"
pointcut-ref="servicepointcut"/>
</aop:config>
<!-- 控制反转ioc di注入 -->
<bean id="userDao" class="com.ssh.dao.impl.UserDaoImpl" parent="baseDao"></bean>
<bean id="userService" class="com.ssh.service.impl.UserServiceImpl" >
<property name="userDao">
<ref bean="userDao"/>
</property>
</bean>
<!-- 配置Struts2 Action 的bean -->
<bean id="userAction" class="com.ssh.action.UserAction" scope="prototype">
<property name="service" ref="userService"/> </bean> <bean id="empDao" class="com.ssh.dao.impl.EmpDaoImpl">
<property name="hibernateTemplate" ref="hibernateTemplate"/>
</bean>
<bean id="empService" class="com.ssh.service.impl.EmpServiceImpl">
<property name="empDao" ref="empDao"/>
</bean>
<bean id="empAction" class="com.ssh.action.EmpAction">
<property name="empService" ref="empService"/>
</bean> </beans>
接口
实现类
声明式事务处理
定时任务
IOC/DI