hibernate+spring 的泛型dao接口和和实现类..以及配置

最新推荐文章于 2022-09-27 17:12:21 发布
最新推荐文章于 2022-09-27 17:12:21 发布
阅读量871 收藏
点赞数
分类专栏： hibernate+spring 文章标签： DAO Hibernate Spring 配置管理 ORM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/silentJesse/article/details/83840910
版权
1.泛型dao接口 

package hibernate.basedao;
import java.io.Serializable;
import java.util.LinkedHashMap;
import java.util.List;

import co.th.tools.PageData;


/**
 * 通用Dao父类实现的接?口，只提供常见的一些功能，其它特殊的功能，可以在子接口中定义。
 * 事务也在需要的时候加到实现类中
 *
 * @param <T> 实体类型
 */
public interface GenericDao<T> {


	public List<T> findTbyHql(String hql);

	/**
	 * by this method you can get all information about T
	 * @return
	 */
	public List<T> findAll();

	/**
	 * 和数据库同步
	 * @param entityClass 实体类
	 * @return
	 */
	public void fulsh();
	/**
	 * 获取记录总数
	 * @param entityClass 实体类
	 * @return
	 */
	public long getCount(final String wherejpql, 
              final Object[] queryParams);
	/**
	 * 清除一级缓存的数据
	 */
	public void clear();
	/**
	 * 保存实体
	 * @param entity 实体id
	 */
	public void save(Object entity);
	/**
	 * 更新实体
	 * @param entity 实体id
	 */
	public void update(Object entity);
	/**
	 * 删除实体
	 * @param entityClass 实体类
	 * @param entityids 实体id数组
	 */
	public void delete(Serializable ... entityids);
	/**
	 * 获取实体
	 * @param <T>
	 * @param entityClass 实体类
	 * @param entityId 实体id
	 * @return
	 */
	public T find(Serializable entityId)  ;
	/**
	 * 获取实体
	 * @param <T>
	 * @param entityClass 实体类
	 * @param entityId 实体id
	 * @return
	 */
	public T get(Serializable entityId);
	/**
	 * 获取分页数据
	 * @param <T>
	 * @param entityClass 实体类
	 * @param firstindex 开始索引
	 * @param maxresult 需要获取的记录数
	 * @return
	 */
	public PageData<T> getScrollData(int firstindex, int     
               maxresult, String wherejpql, Object[]
               queryParams,LinkedHashMap<String, String> orderby);

	public PageData<T> getScrollData(int firstindex, 
                int maxresult, String wherejpql, 
                 Object[]  queryParams);

	public PageData<T> getScrollData(int firstindex,
            int maxresult, LinkedHashMap<String, String> orderby);

	public PageData<T> getScrollData(int firstindex, 
              int maxresult);

	public PageData<T> getScrollData();

	public PageData<T> getScrollDataByHql(
               final int firstindex, 
               final int maxresult,
               final String hql_search, 
               final String hql_totalRecords);

	public int executeDML(final String hql);
	public int executeDML(final String sethql, 
                 Object[] values);
	public List<T> limitFindByHql(final int firstindex, 
                  final int maxresult,
		final String wherejpql,
                  final Object[] queryParams,
		final LinkedHashMap<String, String> orderby);
}





2.泛型dao接口实现类 

package hibernate.basedao;


import java.io.Serializable;
import java.sql.SQLException;
import java.util.LinkedHashMap;
import java.util.List;


import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
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;

import co.th.tools.GenericsUtils;
import co.th.tools.PageData;
@SuppressWarnings("unchecked")
public abstract class GenericDaoImpl<T> extends HibernateDaoSupport implements GenericDao<T>{

	protected Log logger = LogFactory.getLog(GenericDaoImpl.class);

	protected Class<T> entityClass = GenericsUtils.getSuperClassGenricType(this.getClass());

	public void clear() {
		getHibernateTemplate().clear(); 
	}

	public void fulsh(){
		getHibernateTemplate().flush();
	}

	public void delete(Serializable... entityids) {
		for (int i = 0; i < entityids.length; i++) {
			T t = get(entityids[i]);

			if(t != null){
				getHibernateTemplate().delete(t);
			} 
		}
	}

	public T find(Serializable entityId) {
		if(entityId  == null){
			throw new RuntimeException(this.entityClass.getName()+ ":id is empty or null");
		}
		T t = null; 
		t = get(entityId);
		return  t;
	}

	public T get(Serializable entityId){
		if(entityId  == null){
			throw new RuntimeException(this.entityClass.getName()+ ":id is empty or null");
		}
		return (T) getHibernateTemplate().get(this.entityClass, entityId);
	}

	public long getCount(final String wherejpql, final Object[] queryParams) {
		final String hql = "select count(o) from "+ 
		getEntityName(this.entityClass)+ " o " + (wherejpql==null || "".equals(wherejpql.trim())? "": "where 1=1 "+ wherejpql);
	  return (Long)getHibernateTemplate().execute(new HibernateCallback(){
		  public Object doInHibernate(Session session)
			throws HibernateException, SQLException { 
		Query query = session.createQuery(hql);
		setQueryParams(query, queryParams);
		return query.uniqueResult();
	}
	  });
	}


	public void save(Object entity) {
		getHibernateTemplate().save(entity);
	}

	public void update(Object entity) {
		getHibernateTemplate().update(entity);
	}

	@SuppressWarnings("unchecked")
	public PageData<T> getScrollData(final int firstindex, final int maxresult,
		final String wherejpql, final Object[] queryParams,
		final LinkedHashMap<String, String> orderby) {
		final PageData qr = new PageData<T>();
		final String entityname = getEntityName(this.entityClass);
		return (PageData<T>)getHibernateTemplate().execute(new HibernateCallback(){
			 public Object doInHibernate(Session session)
				throws HibernateException, SQLException {
				 Query query = session.createQuery("select o from "+ entityname+ " o "+(wherejpql==null || "".equals(wherejpql.trim())? "": "where 1=1 "+ wherejpql)+ buildOrderby(orderby));
					setQueryParams(query, queryParams);
					if(firstindex!=-1 && maxresult!=-1) query.setFirstResult(firstindex).setMaxResults(maxresult);
					qr.setResultlist(query.list());
					query = session.createQuery("select count(o) from "+ entityname+ " o "+(wherejpql==null || "".equals(wherejpql.trim())? "": "where 1=1 "+ wherejpql));
					setQueryParams(query, queryParams);
					qr.setTotalRecords((Long)query.uniqueResult());
					return qr;
			 }
		});
	}



	@SuppressWarnings("unchecked")
	public PageData<T> getScrollDataByHql(final int firstindex, final int maxresult,final String hql_search, final String hql_totalRecords) {
		final PageData qr = new PageData<T>();
		//final String entityname = getEntityName(this.entityClass);
		return (PageData<T>)getHibernateTemplate().execute(new HibernateCallback(){
			 public Object doInHibernate(Session session)
				throws HibernateException, SQLException {
				 Query query = null;
				 query = session.createQuery(hql_search);
					if(firstindex!=-1 && maxresult!=-1) query.setFirstResult(firstindex).setMaxResults(maxresult);
					qr.setResultlist(query.list()); 
					query = session.createQuery(hql_totalRecords);
					qr.setTotalRecords((Long)query.uniqueResult()); 
					return qr;
			 }
		});
	}





	/**
	 * 设置查询条件的参数
	 * @param query
	 * @param queryParams
	 */
	protected static void setQueryParams(Query query, Object[] queryParams){
		if(queryParams!=null && queryParams.length>0){
			for(int i=0; i<queryParams.length; i++){
				query.setParameter(i, queryParams[i]);
			}
		}
	}
	/**
	 * 组装order by语句
	 * @param orderby
	 * @return
	 */
	protected static String buildOrderby(LinkedHashMap<String, String> orderby){
		StringBuffer orderbyql = new StringBuffer("");
		if(orderby!=null && orderby.size()>0){
			orderbyql.append(" order by ");
			for(String key : orderby.keySet()){
				orderbyql.append("o.").append(key).append(" ").append(orderby.get(key)).append(",");
			}
			orderbyql.deleteCharAt(orderbyql.length()-1);
		}
		return orderbyql.toString();
	}

	public PageData<T> getScrollData(int firstindex, int maxresult,
			String wherejpql, Object[] queryParams) {

		return getScrollData(firstindex, maxresult, wherejpql, queryParams, null);
	}

	public PageData<T> getScrollData(int firstindex, int maxresult,
			LinkedHashMap<String, String> orderby) {
		return getScrollData(firstindex, maxresult, null, null, orderby);
	}

	public PageData<T> getScrollData(int firstindex, int maxresult) {

		return getScrollData(firstindex, maxresult, null, null, null);
	}

	public PageData<T> getScrollData() {
		return getScrollData(-1, -1);
	}

	/**
	 * 获取实体的名称
	 * @param <E>
	 * @param clazz 实体类
	 * @return
	 */
	protected static <E> String getEntityName(Class<E> clazz){
		String entityname = clazz.getSimpleName();
		return entityname;
	}

	public List<T> findAll(){
		List<T> list = getHibernateTemplate().loadAll(entityClass);
		return list;
	}
	public List<T> findTbyHql(String hql){
		List<T> list = getHibernateTemplate().find(hql);
		return list;
	}

	public int executeDML(final String hql){
		Integer result = 0; 
		result = getHibernateTemplate().bulkUpdate(hql);
		return result;
	}

	public int executeDML(final String sethql, Object[] values){
		Integer result = 0;
		final String entityname = getEntityName(this.entityClass);
		String hql = "update " + entityname + " o " + sethql ;
		result = getHibernateTemplate().bulkUpdate(hql, values);
		return result;
	}


	@SuppressWarnings("unchecked")
	public List<T> limitFindByHql(final int firstindex, final int maxresult,
		final String wherejpql, final Object[] queryParams,
		final LinkedHashMap<String, String> orderby) {
		final String entityname = getEntityName(this.entityClass);
		return (List<T>)getHibernateTemplate().execute(new HibernateCallback(){
			 public Object doInHibernate(Session session)
				throws HibernateException, SQLException {
				 Query query = session.createQuery("select o from "+ entityname+ " o "+(wherejpql==null || "".equals(wherejpql.trim())? "": "where 1=1 "+ wherejpql)+ buildOrderby(orderby));
					setQueryParams(query, queryParams);
					if(firstindex!=-1 && maxresult!=-1) 
						query.setFirstResult(firstindex).setMaxResults(maxresult); 
					return query.list();
			 }
		});
	}
}




3.PageData源代码 

public class PageData<T> {

	private List<T> resultlist;
	private long TotalRecords;

	public List<T> getResultlist() {
		return resultlist;
	}
	public void setResultlist(List<T> resultlist) {
		this.resultlist = resultlist;
	}
	public long getTotalRecords() {
		return TotalRecords;
	}
	public void setTotalRecords(long totalRecords) {
		TotalRecords = totalRecords;
	}

}




4.GenericsUtils 源代码 

public class GenericsUtils {
	/**  
     * 通过反射,获得指定类的父类的泛型参数的实际类型. 如BuyerServiceBean extends DaoSupport<Buyer>  
     *  
     * @param clazz clazz 需要反射的类,该类必须继承范型父类
     * @param index 泛型参数所在索引,从0开始.  
     * @return 范型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回<code>Object.class</code>
     */  
    @SuppressWarnings("unchecked")
	public static Class getSuperClassGenricType(Class clazz, int index) {    
        Type genType = clazz.getGenericSuperclass();//得到泛型父类  
        //如果没有实现ParameterizedType接口，即不支持泛型，直接返回Object.class   
        if (!(genType instanceof ParameterizedType)) {
            return Object.class;   
        }  
        //返回表示此类型实际类型参数的Type对象的数组,数组里放的都是对应类型的Class, 如BuyerServiceBean extends DaoSupport<Buyer,Contact>就返回Buyer和Contact类型   
        Type[] params = ((ParameterizedType) genType).getActualTypeArguments();                   
        if (index >= params.length || index < 0) { 
        	 throw new RuntimeException("你输入的索引"+ (index<0 ? "不能小于0" : "超出了参数的总数"));
        }      
        if (!(params[index] instanceof Class)) {
            return Object.class;   
        }   
        return (Class) params[index];
    }
	/**  
     * 通过反射,获得指定类的父类的第一个泛型参数的实际类型. 如BuyerServiceBean extends DaoSupport<Buyer>  
     *  
     * @param clazz clazz 需要反射的类,该类必须继承泛型父类
     * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回<code>Object.class</code>
     */  
    @SuppressWarnings("unchecked")
	public static Class getSuperClassGenricType(Class clazz) {
    	return getSuperClassGenricType(clazz,0);
    }
	/**  
     * 通过反射,获得方法返回值泛型参数的实际类型. 如: public Map<String, Buyer> getNames(){}
     *  
     * @param Method method 方法
     * @param int index 泛型参数所在索引,从0开始.
     * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回<code>Object.class</code>
     */ 
    @SuppressWarnings("unchecked")
	public static Class getMethodGenericReturnType(Method method, int index) {
    	Type returnType = method.getGenericReturnType();
    	if(returnType instanceof ParameterizedType){
    	    ParameterizedType type = (ParameterizedType) returnType;
    	    Type[] typeArguments = type.getActualTypeArguments();
            if (index >= typeArguments.length || index < 0) { 
            	 throw new RuntimeException("你输入的索引"+ (index<0 ? "不能小于0" : "超出了参数的总数"));
            } 
    	    return (Class)typeArguments[index];
    	}
    	return Object.class;
    }
	/**  
     * 通过反射,获得方法返回值第一个泛型参数的实际类型. 如: public Map<String, Buyer> getNames(){}
     *  
     * @param Method method 方法
     * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回<code>Object.class</code>
     */ 
    @SuppressWarnings("unchecked")
	public static Class getMethodGenericReturnType(Method method) {
    	return getMethodGenericReturnType(method, 0);
    }

	/**  
     * 通过反射,获得方法输入参数第index个输入参数的所有泛型参数的实际类型. 如: public void add(Map<String, Buyer> maps, List<String> names){}
     *  
     * @param Method method 方法
     * @param int index 第几个输入参数
     * @return 输入参数的泛型参数的实际类型集合, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回空集合
     */ 
    @SuppressWarnings("unchecked")
	public static List<Class> getMethodGenericParameterTypes(Method method, int index) {
    	List<Class> results = new ArrayList<Class>();
    	Type[] genericParameterTypes = method.getGenericParameterTypes();
    	if (index >= genericParameterTypes.length ||index < 0) {
             throw new RuntimeException("你输入的索引"+ (index<0 ? "不能小于0" : "超出了参数的总数"));
        } 
    	Type genericParameterType = genericParameterTypes[index];
    	if(genericParameterType instanceof ParameterizedType){
    	     ParameterizedType aType = (ParameterizedType) genericParameterType;
    	     Type[] parameterArgTypes = aType.getActualTypeArguments();
    	     for(Type parameterArgType : parameterArgTypes){
    	         Class parameterArgClass = (Class) parameterArgType;
    	         results.add(parameterArgClass);
    	     }
    	     return results;
    	}
    	return results;
    }
	/**  
     * 通过反射,获得方法输入参数第一个输入参数的所有泛型参数的实际类型. 如: public void add(Map<String, Buyer> maps, List<String> names){}
     *  
     * @param Method method 方法
     * @return 输入参数的泛型参数的实际类型集合, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回空集合
     */ 
    @SuppressWarnings("unchecked")
	public static List<Class> getMethodGenericParameterTypes(Method method) {
    	return getMethodGenericParameterTypes(method, 0);
    }
	/**  
     * 通过反射,获得Field泛型参数的实际类型. 如: public Map<String, Buyer> names;
     *  
     * @param Field field 字段
     * @param int index 泛型参数所在索引,从0开始.
     * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回<code>Object.class</code>
     */ 
    @SuppressWarnings("unchecked")
	public static Class getFieldGenericType(Field field, int index) {
    	Type genericFieldType = field.getGenericType();

    	if(genericFieldType instanceof ParameterizedType){
    	    ParameterizedType aType = (ParameterizedType) genericFieldType;
    	    Type[] fieldArgTypes = aType.getActualTypeArguments();
    	    if (index >= fieldArgTypes.length || index < 0) { 
    	    	throw new RuntimeException("你输入的索引"+ (index<0 ? "不能小于0" : "超出了参数的总数"));
            } 
    	    return (Class)fieldArgTypes[index];
    	}
    	return Object.class;
    }
	/**  
     * 通过反射,获得Field泛型参数的实际类型. 如: public Map<String, Buyer> names;
     *  
     * @param Field field 字段
     * @param int index 泛型参数所在索引,从0开始.
     * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回<code>Object.class</code>
     */ 
    @SuppressWarnings("unchecked")
	public static Class getFieldGenericType(Field field) {
    	return getFieldGenericType(field, 0);
    }}



5.用于分页的PageIndex和PageView 

public class PageIndex {

	private long startindex;
	private long endindex;

	public PageIndex(long startindex, long endindex) {
		this.startindex = startindex;
		this.endindex = endindex;
	}
	public long getStartindex() {
		return startindex;
	}
	public void setStartindex(long startindex) {
		this.startindex = startindex;
	}
	public long getEndindex() {
		return endindex;
	}
	public void setEndindex(long endindex) {
		this.endindex = endindex;
	}

}


public class PageView<T> {
	/** 分页数据 **/
	private List<T> records;
	/** 页码开始索引和结束索引 **/
	private PageIndex pageindex;
	/** 总页数 **/
	private long totalpage = 1;
	/** 每页显示记录数 **/
	private int maxresult = 12;
	/** 当前页 **/
	private int currentpage = 1;
	/** 总记录数 **/
	private long totalrecord;
	/** 尾页 **/
	private int lastpage;
	/** 页码数量 **/
	private int pagecode = 15;
	/** 要获取记录的开始索引 **/
	public int getFirstResult() {
		return (this.currentpage-1)*this.maxresult;
	}
	/**取得首页**/
	public int getTopPageNo() {
		return 1;
	}
	/** 取得尾页**/
	public long getBottomPageNo() {
		return getTotalpage();
	}

	/**上一页**/
	public int getPreviousPageNo() {
		if (currentpage <= 1) {
			return 1;
		}
		return currentpage - 1;
	}

	/**下一页* */
	public long getNextPageNo() {
		if (currentpage >= getBottomPageNo()) {
			return getBottomPageNo();
		}
		return currentpage + 1;	
	}

	public int getPagecode() {
		return pagecode;
	}

	public void setPagecode(int pagecode) {
		this.pagecode = pagecode;
	}

	public PageView(int maxresult, int currentpage) {
		this.maxresult = maxresult;
		this.currentpage = currentpage;
	}

	public void setPageData(PageData<T> pageData){
		setTotalrecord(pageData.getTotalRecords());
		setRecords(pageData.getResultlist());
	}

	public long getTotalrecord() {
		return totalrecord;
	}
	public void setTotalrecord(long totalrecord) {
		this.totalrecord = totalrecord;
		setTotalpage(this.totalrecord%this.maxresult==0? this.totalrecord/this.maxresult : this.totalrecord/this.maxresult+1);
	}
	public List<T> getRecords() {
		return records;
	}
	public void setRecords(List<T> records) {
		this.records = records;
	}
	public PageIndex getPageindex() {
		return pageindex;
	}
	public long getTotalpage() {
		return totalpage;
	}
	public void setTotalpage(long totalpage) {
		this.totalpage = totalpage == 0 ? 1 : totalpage;
		this.pageindex = getPageIndex(pagecode, currentpage, totalpage);
	}
	public int getMaxresult() {
		return maxresult;
	}
	public int getCurrentpage() {
		return currentpage;
	}


	public int getLastpage() {
		return lastpage;
	}

  public static PageIndex getPageIndex(long viewpagecount, int currentPage, long totalpage){
		long startpage = currentPage-(viewpagecount%2==0? viewpagecount/2-1 : viewpagecount/2);
		long endpage = currentPage+viewpagecount/2;
		if(startpage<1){
			startpage = 1;
			if(totalpage>=viewpagecount) endpage = viewpagecount;
			else endpage = totalpage;
		}
		if(endpage>totalpage){
			endpage = totalpage;
			if((endpage-viewpagecount)>0) startpage = endpage-viewpagecount+1;
			else startpage = 1;
		}
		return new PageIndex(startpage, endpage);
  }

	public PageView() {

	}

	public void setCurrentpage(int currentpage) {
		this.currentpage = currentpage;
	}
	public void setMaxresult(int maxresult) {
		this.maxresult = maxresult;
	}


}




配置
[code]
<!-- 配置sessioFactory -->
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation">
<value>/WEB-INF/hibernate.cfg.xml</value>
</property>
</bean>

<!-- 配置通用dao的注入 -->
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>

<bean id="genericDao" abstract="true" class="hibernate.basedao.GenericDaoImpl">
<property name="hibernateTemplate" ref="hibernateTemplate"/>
<property name="sessionFactory" ref="sessionFactory"/>
</bean>

<!-- 配置事务管理器 -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="sessionFactory" />
</property>
</bean>



<!-- 配置事务的传播特性 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="add*" propagation="REQUIRED" />
<tx:method name="assign*" propagation="REQUIRED" />
<tx:method name="modify*" propagation="REQUIRED" />
<tx:method name="del*" propagation="REQUIRED" />
<tx:method name="update*" propagation="REQUIRED" />
<tx:method name="*" read-only="true" />
</tx:attributes>
</tx:advice>


<aop:config proxy-target-class="true">
<!-- ************************for module:csl**************************************** -->
<aop:advisor advice-ref="txAdvice"
pointcut="execution (* co.th.csl.*.service.*.*(..))" />

<aop:advisor advice-ref="txAdvice"
pointcut="execution (* co.th.csl.*.*.service.*.*(..))" />
<!-- ************************for module:csl**************************************** -->


<!-- ************************for module:content**************************************** -->
<aop:advisor advice-ref="txAdvice"
pointcut="execution (* co.th.content.*.*.service.*.*(..))" />
<!-- ************************for module:content**************************************** -->

</aop:config>
<!-- 配置哪些类哪些方法使用事务 -->

<!-- <aop:config>
配置切入点(定义哪些方法要进行事务处理)
<aop:pointcut id="allManager"
expression="execution(* co.th.csl.contact.service.*.*(..))" />
定义advice
<aop:advisor advice-ref="txAdvice" pointcut-ref="allManager" />
</aop:config>
-->
[/code]
莫感
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于hibernate泛型接口的基础语句
YKWNDY的博客
07-19 290
1、创建一个泛型通用接口：IBaseDao package com.msit.oa.base.dao; import java.util.List; /** * 泛型通用dao接口 * @author Administrator * */ public interface IBaseDao { public void add(T t);//添加 public voi
【Hibernate】【泛型DAO接口+泛型DAO实现类】
Armo的博客
12-29 651
背景 1.每个Impl接口都要写get,delete,save,update,list,query的方法 2.每个DAO类都要去实现impl的方法. 结果:造成大量接口和类的代码重复—>违背dry原则
Spring+Hibernate下泛型DAO的自动注入
平行
10-13 193
泛型DAO能给编码节省大量的代码，一个通用的泛型DAO类即可完成整个DAO层的功能，基本的结构如下： /** * 泛型DAO。 * * @param &lt;T&gt; * 业务实体类型 */ public class Dao&lt;T&gt; { @Resource private SessionFactory sessionFactory...
Hibernate泛型DAO接口，大部分通用都已包括
iteye_13217的博客
01-24 281
过了大半年，来把这个更新下。 Hibernate通用泛型DAO，执行一些通用操作。简单封装一些操作。相互印证学习。Hibernate整合Spring的配置等在此略过。 首说下DAO接口，由于有的方法是后来补充的，所以注释不全，详细的说明可以在实现类里看到。 如果你要运行测试实例，将3个类拷贝到自己的项目中，按测试示例写测试用例。 DAO接口： [code="java"] pac...
框架学习笔记之Hibernate框架基础(二)如何建立泛型接口实现增删改查
YuQuanZhang的博客
07-27 345
本文章讲述了如何用Hibernate框架创建session对象，通过实体类、object类和泛型建立通用接口，实现泛型对象的增删改查。 映射文件中的各项元素： oracle中键位自增模式：increment、identity、native、assigned。   Hibernate内置的映射类型如下： integer,long，short,float,double,character,b...
基于hibernate的泛型dao实现
tonysong111073的专栏
02-03 198
我们在进行hibernate开发时，因为hibernate是基于对象的ORM，所以由此我们可以在hibernate的基础上在做一层封装，从而大大简化我们的DAO层代码。 首先封装一个分页工具类：Pager<T> public class Pager<T> { private int offset; private int pagesize; private L...
Spring+Hibernate泛型DAO的自动注入（例子）
ckxiaozj的专栏
07-09 389
总体架构： [img]http://dl.iteye.com/upload/attachment/0070/5025/0752a9f3-58de-3e09-abd3-0fe65ccae950.png[/img] 1.定义泛型DAO接口: [code="java"]package com.integration.framework.dao; import java.io.Serial...
基于泛型的通用Dao接口和hibernate的实现
leopowerword的专栏
12-24 83
基于泛型的通用Dao接口：（主要是在使用hibernate或JPA时使用） [code="java"] package com.qiujy.dao; import java.io.Serializable; import java.util.List; public interface GenericDao { void create(T entity); ...
ssh，spring 泛型注入，泛型dao和service的实现
raylee2007的专栏
07-10 307
spring 泛型注入 project层次严格按照ssh：view - action - service - dao 把dao层与service层抽象，还有抽出父类 中间会遇到一个问题，在service层里面dao是泛型，注入就会失败 解决办法： 1.直接去掉service抽象层，service层直接继承dao层的父类，这样在dao里面因为sessionfactory是通过spring的...
spring hibernate注解实现泛型dao
HMC20071120015的专栏
06-26 3457
<br />写给像我一样的菜菜的，高手们么就不用看了<br />ssh开发中重复写dao是个头疼的事情，可以把dao抽象写成一个泛型到，网上有好多方法实习，这里用的是注解（annotation），其实跟xml也差不多。<br /><br /><br /> public class GenericDAOImpl<T, PK extends Serializable> extends<br />         HibernateDaoSupport implements GenericDAO<T, PK>
编写一些简单的hibernate的Dao通用性接口（用泛型）
weixin_41692832的博客
06-21 190
1.编写接口package com.testdao; import java.io.Serializable; import java.util.List; import java.util.Map; public interface IBaseDao&lt;T&gt; { public void save(T obj); public void deleteById(T obj); ...
一个好用的hibernate泛型dao
huidaoli
08-01 1465
以前从springside2.0上搞下来的很好用的,基本实现dao零编码只要配置xml文件就行了。 先看图： 一共4层,com.demonstration.hibernate.basedao是我加的用来进一步解耦hibernate和spring的耦合。 原来的官方解释如下： SpringSide对Hibernate做了三层封装： 第一层：HibernateGenericDao，基于spri...
Spring框架中Dao支持总结：spring中普通类使用hibernate
Java技术栈，分享最主流的Java技术
09-26 371
Dao 的支持类可以有好多，如： JdbcDaoSupport ， HibernateDaoSupport ，JdoDaoSupport等，下面对最常用的HibernateDaoSupport与JdbcDaoSupport做一小总结：一、在Spring框架中实现连接数据库方式：1、、借助类HibernateDaoSupport的简约化实现：借助这个类必须需要HIbernate框架，用到HIbern...
Hibernate Generic DAO的介绍安装和使用
weixin_34205076的博客
08-10 268
java 的包挺多,比c#多 . jar包一个名,解压缩出来又出来又叫另一个名 .搜索起来,内容都分散的很 http://mvnrepository.com maven库搜索 com.googlecode.genericdao com/googlecode/genericdao/search/1.2.0 这个是网站上的目录 就能找到源码包.从源码包便可...
SmallHB: 一个用Java自行编写的dao层微型化Hibernate架构,方便操作，使用简单。
qq_42849206的博客
01-24 155
希望设计一个可以实现对象和SQL自动映射的框架，但是整体用法和设计比Hibernate简单。砍掉不必要的功能。会穿插使用设计模式 1.增加 将对象对应成sql语句，执行sql，插入数据库中 2.删除 根据对象主键的值，生成sql，执行，从库中删除 3.修改 根据对象需要修改属性的值，生成sql，执行 核心架构： Query接口：负责查询（对外提供服务的核心类） QueryFactory类：负责根据...
executeQuery、executeUpdate 和 execute 的区别 ,DDL、DML、DCL、TCL的区别
天才中年英俊的博客
08-22 2477
Statement 接口提供了三种执行 SQL 语句的方法：executeQuery、executeUpdate 和 execute。 使用哪一个方法由 SQL 语句所产生的内容决定。 execute(): 用于执行返回多个结果集、多个更新计数或二者组合的语句 比较少用 executeQuery() 用于产生单个结果集的语句，例如SELECT 语句。 被使用最多的执行 SQL ...
DAO的使用
最新发布
m0_71917549的博客
09-27 117
DAO包基础到其子类。
java泛型T.class的获取
热门推荐
ykdsg的专栏
04-11 8万+
   很早之前写过利用泛型和反射机制抽象DAO ，对其中获取子类泛型的class一直不是很理解。关键的地方是HibernateBaseDao的构造方法中的Type genType = getClass().getGenericSuperclass(); Type[] params = ((ParameterizedType) genType).getActualTypeArguments(
Struts2、Hibernate、Spring整合的泛型DAO,以及通用的分页技术
阿布客栈
07-03 1万+
 1.基本DAO泛型接口package abu.csdn.dao;import java.io.Serializable;import java.util.Collection;import java.util.List;/** * * 使用泛型作为DAO的通用接口 这里没有提供按名称精确查找,和模糊查找 上述两个方法应该由各自的具体接口去定义 * *

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值