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"));
}

 

 

 

打印如下

办公楼室内装修工程厨具供货合同（高伟力）
办公楼室内装修工程施工（大堂）的补充协议（高伟力）
办公楼室内装修工程玻纤板供货合同（高伟力）
工程项目咨询合同（高伟力）
办公楼室内装修工程玻璃墙面补充合同（高伟力）
......