operamasks+hibernate(泛型)+spring 整合框架 - 个人工程备份.不喜勿下
operamasks+hibernate(泛型)+spring 整合框架 - 个人工程备份.不喜勿下
部署到 operamasks 下 . 编译前需要清理下工程
修改数据库连接. 建一个表. 放几条数据, 修改下sql
就可以测试了.
框架说明:
GenericDao (泛型接口)
package org.framework.dao;
/**
* 该类为hibernaeDao的基础类，所以其它模块的类的dao都集成该接口
* @author cheafen
* @version 1.0 05/30/2007
* @since 1.0
*/
import java.io.Serializable;
import java.util.List;
import java.util.Map;
public interface GenericDao<T,ID extends Serializable> {
/**
* <strong>根据对象id获得一个对象</strong>
* @param id 对象主键id
* @return 返回一个对象类型
*/
T loadObjectById(ID id);
/**
* <strong>保存一条记录</strong>
* @param entity 一个对象实体
* @return 返回保存的对象实体
*/
T save(T entity);
/**
* <strong>保存一条新的记录或者跟新一条新的记录</strong>
* @param entity 一个对象实体
* @return 返回保存/更新的对象实体
*/
T saveOrUpdate(T entity);
/**
* <strong>更新一条记录</strong>
* @param entity 一个对象实体
* @return 返回更新的对象实体
*/
T update(T entity);
/**
* <strong>执行del 或者 update语句 </strong>
* <li> delete from com.jpc.model.JpcUser us where us.id>0
* <li> update com.jpc.model.JpcUser us set us.ucode = 'admin' where id in (0,1,2,3,4)
* @param ts 多个对象实体
* @param isHql 是否是 Hibernate语言
*/
void executeDelOrUpdateHql(String hql);
/**
* <strong>删除一个对象实体</strong>
* @param entity 对象实体
*/
void delete(T entity);
/**
* <strong>查询出所有的对象集合</strong>
* @return 返回一个对象实体的集合
*/
List<T> findAll();
/**
* <strong>根据条件列出对象实体集合</strong>
* @param cmd可以是HQL/SQL语句 也可以是XML中配置的HQL语句的查询相关关键字
* <li> 例如: from com.jpc.model.JpcUser as p where p.ucode = ?
* <li> 例如: findUserBycode 这里HQL语句在XML中声明
* <li> 例如: select JPC_JPCUSER as p where p.ucode = ? //前提该表必须有相应的po
* @param page 显示的第几个页面
* @param count 一共返回的条数
* @param params 参数数组
* @return 返回集合为count条记录的集合
*/
List<T> findListByCmd(String cmd ,int page,int count,Object... params);
/**
* <strong>根据动态querySql来列出对象实体集合-适合对象为动态结构的数据表</strong>
* <li> 例如: select did,ucode,uname,email或者* from D_FILE1 as u where u.uname = '李春雨' //表名为数据库中的名称 返回单个对象为Map的list
* <li> 注意: map 获取值必须大写 即: map.get("TITLE")
* @param querySql 查询语句
* @param page 显示的第几页面
* @param count 集合的条数 每页显示的条目数
* @return 返回集合为count条记录的集合
* 注意: 查询字段中不能存在大字段类型
*/
List<Map> findMapListByDynSql(String querySql,int page,int count);
/**
* <strong>返回实体类对象/或者单个对象例如Max/min等</strong>
* 根据cmd对应语句查询可以执行如下操作：count、max、min、sum、avg
* <li> from net.vscholl.user.User as user where user.userCode = '刘玉华' and ...
* <li> from com.jpc.model.JpcUser as p where p.ucode = ?
* <li> select max(did) from d_file1 where title like '%我们%'
* <li>count: select count(*) from net.vschool.user.User as user
* <li>max: select max(user.id) from net.vschool.user.User as user
* <li>min: select min(user.id) from net.vschool.user.User as user
* <li>sum: select sum(user.id) from net.vschool.user.User as user
* <li>avg: select avg(user.id) from net.vschool.user.User as user
* <li> 返回一条记录<font color=red>obj对象</font>的时候 object 可以强制转换成Object[] 数组,保存该记录内多个key-value
* <li> 例如: select * from JPC_USER as u where u.did = 2 可强制转换成Object[]
* <li> 根据cmd对应语句查询可以执行如下操作：count、max、min、sum、avg 这个时候则是Object对象
* <li> 例如: select MAX(did) from JPC_USER as u where u.did = 2 返回为Object 不可转换为数组
* @param querySql 可以是xml中定义的query Name 也可以是Hql语句 也可以是 SQL语句
* @param params ? 的数组对象 用来简化sql
* @return 单挑记录或者cout . max obj等等
* 注意: 如果返回结果不是实体对象的情况下,返回为数组 则返回结果中(即查询字段中)不能存在大字段类型
*/
Object queryForCmd(String querySql , Object... params);
/**
* 获取单条记录对象(Map)
* @param querySql sql/hql/qname
* @param params 参数
* @return 单条记录的Map对象
* 注意: 查询字段中不能存在大字段类型
*/
Object queryForSingleResultMap(String querySql , Object... params);
}
HibernateBaseDaoImpl (泛型实现类)
package org.framework.dao.impl;
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.List;
import org.framework.dao.GenericDao;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
/**
* @author lovejj
*
*/
public class HibernateBaseDaoImpl<T, ID extends Serializable> extends
HibernateDaoSupport implements GenericDao<T, ID> {
private Class<T> persistentClass = null;
protected Query getQuery(Session session,String cmd) {
Query query;
try {
query = session.getNamedQuery(cmd);//创建xml中声明的query名称
} catch (HibernateException e) {
try{
query = session.createQuery(cmd);//否则创建Hibernate的SQL
}catch (HibernateException ex) {
query = session.createSQLQuery(cmd);//否则创建数据库SQL
}
}
return query;
}
/*
* Cmd parameter is the named query's name. Please refer to Hibernate Named
* Query.
*
* @see com.zybedu.dao.FindCmdDao#findCmd(java.lang.String,
* java.lang.Object[], int, int)
*/
@SuppressWarnings("unchecked")
public List findListByCmd(final String cmd ,
final int page, final int count, final Object... params) {
List result = null;
Object o = this.getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException {
Query query = getQuery(session, cmd);
if (params != null) {
int len = params.length;
for (int i = 0; i < len; i++) {
query.setParameter(i, params[i]);
}
}
if (page > 0) {
int maxResult = count;
if (count < 1)
maxResult = 1;
int first = (page - 1) * maxResult;
query.setFirstResult(first);
query.setMaxResults(maxResult);
} else {
}
List list = query.list();
org.hibernate.Hibernate.initialize(list);
return list;
}
});
if (o != null)
result = (List) o;
return result;
}
public void delete(T entity) {
this.getHibernateTemplate().delete(entity);
this.getSession().flush();
}
@SuppressWarnings("unchecked")
public List<T> findAll() {
List list = this.getHibernateTemplate().loadAll(
this.getPersistentClass());
org.hibernate.Hibernate.initialize(list);
return list;
}
@SuppressWarnings("unchecked")
public T loadObjectById(ID id) {
return (T) this.getHibernateTemplate().get(this.getPersistentClass(),
id);
}
public T saveOrUpdate(T entity) {
this.getHibernateTemplate().saveOrUpdate(entity);
return entity;
}
public T save(T entity) {
this.getHibernateTemplate().save(entity);
return entity;
}
public T update(T entity) {
this.getHibernateTemplate().update(entity);
return entity;
}
public void executeDelOrUpdateHql(final String hql) {
Object o = this.getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException {
Query query = getQuery(session, hql);
query.executeUpdate();
return null;
}
});
}
protected Class<T> getPersistentClass() {
if (this.persistentClass == null) {
this.persistentClass = (Class<T>) ((ParameterizedType) getClass()
.getGenericSuperclass()).getActualTypeArguments()[0];
}
return this.persistentClass;
}
public List findMapListByDynSql(String querySql ,final int page,
final int count) {
List result = null;
final String fullHql = querySql;
// LazyParser parser=parsers.get(cmd);
if (fullHql != null) {
Object o = this.getHibernateTemplate().execute(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException {
Query query = getQuery(session, fullHql);//创建sql对象
if (page > 0) {
int maxResult = count;
if (count < 1)
maxResult = 1;
int first = (page - 1) * maxResult;
query.setFirstResult(first);
query.setMaxResults(maxResult);
}
return query.setResultTransformer(Criteria.ALIAS_TO_ENTITY_MAP).list();
}
});
if (o != null)
result = (List) o;
}
return result;
}
public Object queryForCmd(String querySql , final Object... params) {
Object result = null;
final String fullHql = querySql;
// LazyParser parser=parsers.get(cmd);
if (fullHql != null) {
Object o = this.getHibernateTemplate().execute(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException {
Query query = getQuery(session, fullHql);
if (params != null) {
int len = params.length;
for (int i = 0; i < len; i++) {
query.setParameter(i, params[i]);
}
}
return query.uniqueResult();
}
});
if (o != null)
result = o;
}
return result;
}
public Object queryForSingleResultMap(String querySql, final Object... params ) {
Object result = null;
final String fullHql = querySql;
// LazyParser parser=parsers.get(cmd);
if (fullHql != null) {
Object o = this.getHibernateTemplate().execute(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException {
Query query = getQuery(session, fullHql);
if (params != null) {
int len = params.length;
for (int i = 0; i < len; i++) {
query.setParameter(i, params[i]);
}
}
return query.setResultTransformer(Criteria.ALIAS_TO_ENTITY_MAP).uniqueResult();
}
});
if (o != null)
result = o;
}
return result;
}
}
满足了有实体对象的所有增删查改操作. 满足了没有实体对象的增删查改操作
调用:
1. 可以自定义Dao
public interface UserDao extends GenericDao<User, Serializable> {
}
并且注入到Service中使用
2. 可以直接调用
@ManagedProperty("#{genericDao}")
private GenericDao<SUser, Integer> genericDao;
前提: 将泛型接口声明在spring-beans中
<bean id="genericDao" class="org.framework.dao.impl.HibernateBaseDaoImpl"> <property name="sessionFactory" ref="sessionFactory" /> </bean>
解析:
1. 例如: objectDao.queryForCmd("select usercode,passwd,did,pid from s_user t where t.did = 1") 返回的是长度为4的一个数组
2. 例如: SUser user = (SUser) genericDao.queryForCmd("from com.jj.demo.hbm.SUser as u where u.did = 1"); 返回的是SUser对象
3. 例如: objectDao.queryForSingleResultMap("select * from F_D_FILE1 where did = ?",3); 返回单条记录为一个map
4. 例如: objectDao.queryForCmd("from com.jj.demo.hbm.FDFile as fd where fd.fieldname = ?","CREATOR"); 返回为一个FDFile对象
5. 例如: objectDao.findMapListByDynSql("select * from d_file1", -1, -1); 返回为每条记录为一个map的多条记录list
6. 例如: objectDao.queryForCmd("select count(*) from s_all"); 返回为一个结果obj . 可转换为整型
List<Map> ls = objectDao.findMapListByDynSql("select * from D_FILE1", 1, 30);
for (Map map : ls) {
System.out.println(map.get("TITLE"));
}
打印如下
办公楼室内装修工程厨具供货合同（高伟力） 办公楼室内装修工程施工（大堂）的补充协议（高伟力） 办公楼室内装修工程玻纤板供货合同（高伟力） 工程项目咨询合同（高伟力） 办公楼室内装修工程玻璃墙面补充合同（高伟力） ......