hibernate support dao template

最新推荐文章于 2019-09-14 18:49:10 发布
最新推荐文章于 2019-09-14 18:49:10 发布 · 140 阅读 · 0
文章标签：

#DAO #Hibernate #SQL #ORM #J#

本文介绍了一个基于Hibernate的DAO支持类实现，包括增删改查等基本操作及分页查询功能。该类提供了多种查询方式，如HQL、SQL和QBC，并实现了分页查询的支持。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

package com.daluo.fortrade.dao.support;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.dao.DataAccessResourceFailureException;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.daluo.fortrade.dao.IDAO;
import com.daluo.fortrade.model.BaseForm;
import com.daluo.fortrade.util.Pagination;

public class DAOSupport extends HibernateDaoSupport implements IDAO {
	public void delete(BaseForm baseForm) {
		this.getHibernateTemplate().delete(baseForm);
	}

	public void save(BaseForm baseForm) {
		this.getHibernateTemplate().save(baseForm);
	}

	public void update(BaseForm baseForm) {
		this.getHibernateTemplate().update(baseForm);
	}

	public void batchDelete(String[] Id, Class classType) {
		for(int i=0;i<Id.length;i++){
			BaseForm form = (BaseForm)load(classType, Id[i]);
        	getHibernateTemplate().delete(form);
		}
	}
	
	
	public BaseForm get(Class classType, String Id) {
		return (BaseForm)this.getHibernateTemplate().get(classType, Integer.valueOf(Id));
	}
	
	public BaseForm load(Class classType, String Id){
		return (BaseForm)this.getHibernateTemplate().load(classType, Integer.valueOf(Id));
	}


	public List findByExample(BaseForm baseForm) {
		return this.getHibernateTemplate().findByExample(baseForm);
	}
	
	public List findByHql(String hql) {
		return this.getHibernateTemplate().find(hql);
	}

	public List findBySQL(String sql) {
		return this.getSession().createQuery(sql).list();
	}
	
	public List findBySQL(String sql, List params){
		try {
			Connection con = this.getSession().connection();
			PreparedStatement ps = con.prepareStatement(sql);
			int paramSize = params.size();
			for (int i = 0; i < paramSize; i++) {
				ps.setString(i+1, (String) params.get(i));
			}
			ResultSet rs = ps.executeQuery();
			List<Object[]> items = new ArrayList<Object[]>();
			while(rs.next()){
				Object[] row = new Object[rs.getMetaData().getColumnCount()];
				for (int i = 0; i < row.length; i++) {
					row[i] = rs.getObject(i+1);
				}
				items.add(row);
			}
			//ps.close();
			//con.close();
			return items;
		} catch (DataAccessResourceFailureException e) {
			e.printStackTrace();
		} catch (HibernateException e) {
			e.printStackTrace();
		} catch (IllegalStateException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return null;
	}
	
	public List findByQBC(BaseForm baseForm) {
		return this.getSession().createCriteria(baseForm.getClass()).list();
	}

	public List findByHql(String hql, Object obj) {
		return this.getHibernateTemplate().find(hql, obj);
	}

	public List findByHql(String hql, Object[] obj) {
		return this.getHibernateTemplate().find(hql, obj);
	}

	public List findByPagination(final String hql, final int firstRow,
			final int maxRow) {
		return getHibernateTemplate().executeFind(new HibernateCallback() {
			public Object doInHibernate(Session s) throws HibernateException,
					SQLException {
				Query query = s.createQuery(hql);

				query.setFirstResult(firstRow);
				query.setMaxResults(maxRow);
				List list = query.list();
				return list;
			}
		});
	}

	public List findByPagination(final String hql, final Object[] params,
			final int firstRow, final int maxRow) {
		return getHibernateTemplate().executeFind(new HibernateCallback() {
			public Object doInHibernate(Session s) throws HibernateException,
					SQLException {
				Query query = s.createQuery(hql);
				for (int i = 0; i < params.length; i++) {
					query.setParameter(i, params[i]);
				}
				query.setFirstResult(firstRow);
				query.setMaxResults(maxRow);
				List list = query.list();
				return list;
			}
		});
	}
	
	
	// ---------------------------------------------------------------------
	// 无参数取得一页数据
	// --------------------------------------------------------------------
	public Pagination getPage(String queryName) {
		return getPage(queryName, null, Pagination.defaultPageSize(), 0);
	}

	public Pagination getPage(String queryName, int startIndex) {
		return getPage(queryName, null, Pagination.defaultPageSize(), startIndex);
	}

	public Pagination getPage(String queryName, int pageSize, int startIndex) {
		return getPage(queryName, new ArrayList(), pageSize,startIndex);
	}

	// ---------------------------------------------------------------------------
	// 使用带一个参数的HQL取得一页数据
	// ---------------------------------------------------------------------------
	@SuppressWarnings("unchecked")
	public Pagination getPage(String queryName, Object param) {
		boolean add = new ArrayList().add(param);
		return getPage(queryName, add, Pagination.defaultPageSize(), 0);
	}

	@SuppressWarnings("unchecked")
	public Pagination getPage(String queryName, Object param,
			int startIndex) {
		return getPage(queryName,new ArrayList().add(param), Pagination.defaultPageSize(), startIndex);
	}

	@SuppressWarnings("unchecked")
	public Pagination getPage(String queryName, Object param,
			int pageSize, int startIndex) {
		return getPage(queryName,new ArrayList().add(param), pageSize, startIndex);
	}

	// ------------------------------------------------------------------------------
	// 使用带有一系列参数的HQL取得一页数据
	// .------------------------------------------------------------------------------
	public Pagination getPage(String queryName, List params) {
		return getPage(queryName, params, Pagination.defaultPageSize(), 0);
	}

	public Pagination getPage(String queryName, List params, int startIndex) {
		return getPage(queryName, params, Pagination.defaultPageSize(), startIndex);
	}

	
	public Pagination getPage(final String hql, final List params,  final int curPage, final int pageSize) {
		if (params != null && params.size() != params.size()) {
			throw new IllegalArgumentException("Length of paramNames array must match length of values array");
		}
		return (Pagination) getHibernateTemplate().execute(
				new HibernateCallback() {
					public Object doInHibernate(Session session)
							throws HibernateException {
						Query query = session.createQuery(hql);
						for (int i = 0; i < params.size(); i++) {
							query.setParameter(i, params.get(i));
						}
						int startRecord = (curPage-1)*pageSize;
						query.setFirstResult(startRecord);
						query.setMaxResults(pageSize);
						String hqlCount = query.getQueryString();
						if(hqlCount.indexOf("from")!=-1){
							hqlCount = hqlCount.substring(hqlCount.indexOf("from"),hqlCount.length());
						}
						if(hqlCount.indexOf("order by")!=-1){
							hqlCount = hqlCount.substring(0,hqlCount.indexOf("order by"));
						}
						hqlCount = "select count(*) " + hqlCount;
						Query countQuery = session.createQuery(hqlCount);
						if (params != null) {
							for (int j = 0; j < params.size(); j++) {
								countQuery.setParameter(j, params.get(j));
							}
						}
						int totalCount = ((Integer) countQuery.list().iterator().next()).intValue();
						List items = query.list();
						Pagination ps = new Pagination(items, totalCount, curPage, pageSize, startRecord);
						return ps;
					}
				});
	}

	public Pagination getPageBySQL(String sql, List params, int curPage, int pageSize){
		try {
			Connection con = this.getSession().connection();
			sql = Pagination.getLimitSQL(sql,curPage,pageSize,Pagination.PAGINATION_SQLSERVER);
			PreparedStatement ps = con.prepareStatement(sql);
			System.out.println("sql:" + sql);
			int paramSize = params.size();
			for (int i = 0; i < paramSize; i++) {
				ps.setString(i+1, (String) params.get(i));
			}
			for (int i = 0; i < paramSize; i++) {
				ps.setString(i+1+paramSize, (String) params.get(i));
			}
			ResultSet rs = ps.executeQuery();
			List<Object[]> items = new ArrayList<Object[]>();
			while(rs.next()){
				Object[] row = new Object[rs.getMetaData().getColumnCount()];
				for (int i = 0; i < row.length; i++) {
					row[i] = rs.getObject(i+1);
				}
				items.add(row);
			}
			String hqlCount = sql;
			if(hqlCount.indexOf("from")!=-1){
				hqlCount = hqlCount.substring(hqlCount.indexOf("from"),hqlCount.length());
			}
			if(hqlCount.indexOf("order by")!=-1){
				hqlCount = hqlCount.replaceAll("(order by [^\\s]+? desc)|(order by [^\\s]+? asc)", "");
			}
			hqlCount = "select count(*) " + hqlCount;
			System.out.println("hqlCount:" + hqlCount);
			ps = con.prepareStatement(hqlCount);
			for (int i = 0; i < paramSize; i++) {
				ps.setString(i+1, (String) params.get(i));
			}
			for (int i = 0; i < paramSize; i++) {
				ps.setString(i+1+paramSize, (String) params.get(i));
			}
			ResultSet rsCount = ps.executeQuery();
			int totalCount = 0;
			if(rsCount.next()){
				totalCount = rsCount.getInt(1);
			}
			Pagination pagin = new Pagination(items, totalCount, curPage, pageSize);
			return pagin;
		} catch (DataAccessResourceFailureException e) {
			e.printStackTrace();
		} catch (HibernateException e) {
			e.printStackTrace();
		} catch (IllegalStateException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return null;
	}	
	
	public Pagination getPageByLimitedSQL(String sql, List params, int curPage, int pageSize){
		try {
			Connection con = this.getSession().connection();
			PreparedStatement ps = con.prepareStatement(sql);
			System.out.println("sql:" + sql);
			int paramSize = params.size();
			for (int i = 0; i < paramSize; i++) {
				ps.setString(i+1, (String) params.get(i));
			}
			for (int i = 0; i < paramSize; i++) {
				ps.setString(i+1+paramSize, (String) params.get(i));
			}
			ResultSet rs = ps.executeQuery();
			List<Object[]> items = new ArrayList<Object[]>();
			while(rs.next()){
				Object[] row = new Object[rs.getMetaData().getColumnCount()];
				for (int i = 0; i < row.length; i++) {
					row[i] = rs.getObject(i+1);
				}
				items.add(row);
			}
			String hqlCount = sql;
			if(hqlCount.indexOf("from")!=-1){
				hqlCount = hqlCount.substring(hqlCount.indexOf("from"),hqlCount.length());
			}
			if(hqlCount.indexOf("order by")!=-1){
				hqlCount = hqlCount.replaceAll("(order by [^\\s]+? desc)|(order by [^\\s]+? asc)", "");
			}
			hqlCount = "select count(*) " + hqlCount;
			System.out.println("hqlCount:" + hqlCount);
			ps = con.prepareStatement(hqlCount);
			for (int i = 0; i < paramSize; i++) {
				ps.setString(i+1, (String) params.get(i));
			}
			for (int i = 0; i < paramSize; i++) {
				ps.setString(i+1+paramSize, (String) params.get(i));
			}
			ResultSet rsCount = ps.executeQuery();
			int totalCount = 0;
			if(rsCount.next()){
				totalCount = rsCount.getInt(1);
			}
			Pagination pagin = new Pagination(items, totalCount, curPage, pageSize);
			return pagin;
		} catch (DataAccessResourceFailureException e) {
			e.printStackTrace();
		} catch (HibernateException e) {
			e.printStackTrace();
		} catch (IllegalStateException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return null;
	}

	public Object[] findObjectBySQL(String sql, List params) {
		try {
			Connection con = this.getSession().connection();
			PreparedStatement ps = con.prepareStatement(sql);
			int paramSize = params.size();
			for (int i = 0; i < paramSize; i++) {
				ps.setString(i+1, (String) params.get(i));
			}
			ResultSet rs = ps.executeQuery();
			if(rs.next()){
				Object[] row = new Object[rs.getMetaData().getColumnCount()];
				for (int i = 0; i < row.length; i++) {
					row[i] = rs.getObject(i+1);
				}
				return row;
			}
		} catch (DataAccessResourceFailureException e) {
			e.printStackTrace();
		} catch (HibernateException e) {
			e.printStackTrace();
		} catch (IllegalStateException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return null;
	}	
}
 
33、Spring中Hibernate与JPA 2的使用指南
www00的博客
06-11 14
本文详细介绍了在Spring框架中使用Hibernate和JPA 2进行数据访问开发的实践指南。内容涵盖数据的增删改查操作、Hibernate与JPA的配置、高级查询方法、Spring Data JPA的使用以及实体变更跟踪与审计功能的实现。通过具体代码示例和配置说明，帮助开发者掌握如何在实际项目中高效使用Hibernate和JPA 2进行数据持久化操作。
【Hibernate】HibernateCallback总结
lmb55的专栏
07-19 2310
HibernateCallback总结 HibernateTemplate提供了非常多的常用方法来 完成数据库的基本操作，使得持久层访问模板化 。只要创建HibernateTemplate实例后，注入一 个SessionFactory的引用就可以了，而无需手动 创建sessionFactory，从而可以更加智能的管理 Hibernate的Session，避免了对于try/catch的 大量使用。...
HibernateTemplate和HibernateDaoSupport
weixin_34273481的博客
04-05 198
Spring整合Hibernate后，两个工具类：HibernateTemplate和HibernateDaoSupport。 HibernamteTemplate HibernateTemplate是Spring提供的一个就Hibernate访问持久层技术而言、支持Dao组件的一个工具。HibernateTemplate提供持久层访问模板，应用HibernateTemplate无须实现特定的...
Spring——HibernateTemplate、hibernateDaoTemplate
yaguanzhou2014的专栏
01-28 716
Spring——HibernateTemplate、hibernateDaoTemplate
自己动手写代码，整合Spring和Hibernate（三）之DAOSupport和DAOTemplate
岁月静好
04-20 2211
在《自己动手写代码，整合Spring和Hibernate》系列博文的前两篇中，
HibernateTemplate
iteye_16838的博客
05-27 203
HibernateTemplate源码 [java] view plaincopyprint?       package org.springframework.orm.hibernate3;      import java.io.Serializable;   import java.lang.reflect.InvocationHandler;   import...
Spring Boot 2.0中Hibernate多数据源配置及Dao层集成示例
通过上述配置和实现，可以在Spring Boot 2.0项目中成功集成多数据源，并且使用Hibernate Dao Support来操作数据，而不是采用JPA的方式。这种方法特别适合那些希望继续使用Hibernate的旧项目，或者对Hibernate更熟悉...
Dropwizard(二) hibernate连接Mysql数据库
sf_cyl的博客
11-30 3261
分享一下官网的连接：Dropwizard Hibernate整合  作者自己没有采用JDBI来连接数据库，而是采用了dropwizard-hibernate 框架连接数据库，并进行处理数据。 结合官网的教程，和git-hub上的例子一步一步的整合。 1.1 导入dropwizard-hibernate 包     上一篇文章以已经提到，采用maven管理此web项目，所以先在pom文件中添
struts+spring+hibernate登录功能包括简单增删改查
二进制的博客
09-24 890
初识struts和hibernate很多东西都不是很懂呀，跟着网上的资源实现就简单的增删改查，其中hibernate的hql不是很会用，之前是在学习mybatis，现在一和hibernate对比，让我深深感觉mybatis的好呀！嘻嘻，其实都差不多，好了，直接正文吧！整体功能：学生注册，登录，修改密码，注销。包揽了增删改查。 项目使用maven创建，不用麻烦在WEB-INF的lib目录下手动放那么
Spring源代码分析（16)---HibernateTemplate(ORM的回眸一笑);
浮白
10-21 3610
我们在此之前已经分析过了JdbcTemplate的源代码，现在我们来分析一下HibernateTemplate,HIbernateTemplate中间包含了一个SessionFactory,就好比JdbcTemplate中引用一个DataSource一样，Hibernate会利用这个SessionFactory获取Session会话连接，然后把数据库的curd功能委托给该Session进行；其下是
ValueError: Length of values does not match length of index
爱问西瓜爱大树的博客
09-14 3万+
问题描述： 用多元线性回归模型预测出结果后，返回给主函数处理，报“ValueError: Length of values does not match length of index”错误。 经过多方调试，发现是返回值类型的匹配问题。描述如下： result = LR_reg.predict(scaler_test_data) return result # type(result)...
HibernateTemplate、HibernateDaoSupport两种方法实现增删改查Good
热门推荐
Baple的专栏
04-10 4万+
Spring+Hibernate两种方法实现增删改查     首先，定义一个Customer的bean类，设置好Customer.hbm.xml文件。再定义好一个Dao接口。准备好一个jdbc.properties文件。     第一种方法： 在dao类中定义一个HibernateTemplate类的对象，用该对象调用HibernateTemplate模板封装好的方法，如下：
Sping学习之HibernateTemplate源码
逆风奔跑。。不要去考虑什么天赋异禀，一切都来自经历和渴望。
03-03 7160
对Spring和Hibernate整合过程中，一直不太懂原理，感觉看着API用，实在是不踏实，于是上网找到了这个HibernateDaoSupport中提供的模版方法的源码，代码如下：/* * Copyright 2002-2008 the original author or authors. * * Licensed under the Apache License, Version 2
DAO层注入HibernateTemplate的两种方式
siwuxie095's blog
09-21 2457
-------------------------siwuxie095                               DAO 层注入 HibernateTemplate 的两种方式       方式一：普通方式       具体实现如下：    （1）编写页面    add.jsp：     page language="java"
HibernateTemplate源码
sjhnanwang的专栏
06-19 6417
/*  * Copyright 2002-2009 the original author or authors.  *  * Licensed under the Apache License, Version 2.0 (the "License");  * you may not use this file except in compliance with the License.
自定义Hibernate通用DAO实现业务模块调用
通过结合Hibernate和DAO模式，开发者可以创建一个通用的数据访问对象（DAO），用以处理多种实体的数据存取，提高代码的复用性。 Hibernate超级通用DAO是开发者编写的一个基础的数据访问层框架，它封装了Hibernate...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值