对hibernate的封装 HibernateTemplate

最新推荐文章于 2023-01-31 22:39:32 发布
最新推荐文章于 2023-01-31 22:39:32 发布 · 210 阅读 · 0
标签
#Hibernate #SQL #F#
本文提供了一套针对Hibernate操作的封装方案，包括增删改查等基本功能，并实现了分页查询等功能。
使用hibernate也有很久一段时间了，做了点简单的封装：

package org.jutil.hibernate.base;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.Transaction;

public abstract  class HibernateTemplate<T extends Object> {

	private static HibernateUtil util = HibernateUtil.getInstance();

	/**
	 * 获得接口中泛型的实例
	 * 
	 * @param index
	 * @return
	 */
	@SuppressWarnings("unchecked")
	private Class getGenericType(int index) {
		Type genType = getClass().getGenericSuperclass();
		if (!(genType instanceof ParameterizedType)) {
			return Object.class;
		}
		Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
		if (index >= params.length || index < 0) {
			throw new RuntimeException("Index outof bounds");
		}
		if (!(params[index] instanceof Class)) {
			return Object.class;
		}
		return (Class) params[index];
	}

	/**
	 * 保存对象
	 * @param entity
	 */
	public void save(Object entity) {
		Session s = null;
		Transaction tx = null;
		try {
			s = util.getSession();
			tx = s.beginTransaction();
			s.save(entity);
			tx.commit();
		} finally {
			if (s != null)
				util.closeSession(s);
		}
	}

	/**
	 * 删除对象
	 * @param entity
	 */
	public boolean delete(Object entity) {
		Session s = null;
		Transaction tx = null;
		try {
			s = util.getSession();
			tx = s.beginTransaction();
			s.delete(entity);
			tx.commit();
			return true;
		}catch (Exception e) {
			return false;
		} finally {
			if (s != null)
				util.closeSession(s);
		}
	}

	/**
	 * 删除对象
	 * @param entityName
	 * @param object
	 * @return
	 */
	public boolean delete(String entityName, Object object) {
		Session s = null;
		Transaction tx = null;
		try {
			s = util.getSession();
			tx = s.beginTransaction();
			s.delete(entityName, object);
			tx.commit();return true;
		}catch (Exception e) {
			return false;
		} finally {
			if (s != null) {
				util.closeSession(s);
			}
		}
	}

	/**
	 * 更新对象
	 * @param entity
	 */
	public void update(Object entity) {
		Session s = null;
		Transaction tx = null;
		try {
			s = util.getSession();
			tx = s.beginTransaction();
			s.update(entity);
			tx.commit();
		} finally {
			if (s != null)
				util.closeSession(s);
		}
	}

	/**
	 * get 方式获得对象
	 * @param id 在hibernate中作为主键的值
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public T get(Serializable id) {
		Class clazz = getGenericType(0);
		Session s = null;
		try {
			s = util.getSession();
			Object obj = s.get(clazz, id);
			return (T) obj;
		} finally {
			if (s != null)
				util.closeSession(s);
		}
	}

	/**
	 * get 方式获得对象
	 * @param id 在hibernate中作为主键的值
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public T get(Class clazz ,Serializable id) {
		Session s = null;
		try {
			s = util.getSession();
			Object obj = s.get(clazz, id);
			return (T) obj;
		} finally {
			if (s != null)
				util.closeSession(s);
		}
	}

	/**
	 * get 方式获得对象
	 * @param id 在hibernate中作为主键的值
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public T get(String entityName,Serializable id) {
		Session s = null;
		try {
			s = util.getSession();
			Object obj = s.get(entityName, id);
			return (T) obj;
		} finally {
			if (s != null)
				util.closeSession(s);
		}
	}

	/**
	 * load 方式获得对象
	 * @param id 在hibernate中作为主键的值
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public T load(Serializable id) {
		Class clazz = getGenericType(0);
		Session s = null;
		try {
			s = util.getSession();
			Object obj = s.load(clazz, id);
			return (T) obj;
		} finally {
			if (s != null)
				util.closeSession(s);
		}
	}

	/**
	 * load 方式获得对象
	 * @param clazz 
	 * @param id 在hibernate中作为主键的值
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public T load(Class clazz ,Serializable id) {
		Session s = null;
		try {
			s = util.getSession();
			Object obj = s.load(clazz, id);
			return (T) obj;
		} finally {
			if (s != null)
				util.closeSession(s);
		}
	}

	/**
	 * load 方式获得对象
	 * @param entityName 实体类全名称
	 * @param id 在hibernate中作为主键的值
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public T load(String entityName,Serializable id) {
		Session s = null;
		try {
			s = util.getSession();
			Object obj = s.load(entityName, id);
			return (T) obj;
		} finally {
			if (s != null)
				util.closeSession(s);
		}
	}

	/**
	 * 根据(HQL: Hibernate查询语言)得到唯一对象，语句查询结果必须只有一条结果，否则抛出异常
	 * @param sql 查询语句
	 * @return T
	 */
	@SuppressWarnings("unchecked")
	public T uniqueResult(String sql){
		sqlValidate(sql);
		Query query = util.getSession().createQuery(sql);
		return (T) query.uniqueResult();
	}

	/**
	 * 根据(数据库的Native SQL语言)得到唯一对象，语句查询结果必须只有一条结果，否则抛出异常
	 * @param sql 查询语句
	 * @return Object[] 封装后的结果
	 */
	public Object[] uniqueResultSQL(String sql){
		sqlValidate(sql);
		SQLQuery query = util.getSession().createSQLQuery(sql);
		return  (Object[]) query.uniqueResult();
	}

	/**
	 * 根据(HQL: Hibernate查询语言)查询所有符合条件的记录,并将结果封装到List<T> 中
	 * @param sql 查询语句
	 * @param args 参数
	 * @return List<T> 
	 */
	@SuppressWarnings("unchecked")
	public List<T> findByQuery(String sql, Object... args) {
		try {
			sqlValidate(sql);
			Query query = util.getSession().createQuery(sql);
			for (int i = 0; i < args.length; i++) {
				query.setParameter(i, args[i]);
			}
			return query.list();
		} catch (Exception e) {
			throw new HibernateException(e.getMessage());
		}
	}

	/**
	 * 根据(Native SQL查询语言)查询所有符合条件的记录List
	 * @param sql 查询语句
	 * @param args 参数
	 * @return List 
	 */
	@SuppressWarnings("unchecked")
	public List findBySQLQuery(String sql,Object ... args) {
		try {
			sqlValidate(sql);
			SQLQuery query = util.getSession().createSQLQuery(sql);
			for (int i = 0; i < args.length; i++) {
				query.setParameter(i, args[i]);
			}
			return query.list();
		} catch (Exception e) {
			throw new HibernateException(e.getMessage());
		}
	}

	/**
	 *根据(Native SQL查询语言)查询所有符合条件的记录,并将结果封装到List<Object[]> 中
	 * @param sql 查询语句
	 * @param args 参数
	 * @return List<Object[]> 封装后的结果
	 */
	@SuppressWarnings("unchecked")
	public List<Object[]> findBySQLQueryToList(String sql,Object ... args) {
		try {
			sqlValidate(sql);
			List<Object[]> result = new ArrayList<Object[]>(0);
			Object[] temp = null;
			SQLQuery query = util.getSession().createSQLQuery(sql);
			for (int i = 0; i < args.length; i++) {
				query.setParameter(i, args[i]);
			}
			List r = query.list();
			Iterator ite =  r.iterator();
			while(ite.hasNext()){
				temp =  (Object[]) ite.next();
				System.out.println(temp[0]+":"+temp[1]+":"+temp[2]);
				result.add(temp);
			}
			return result;
		} catch (Exception e) {
			throw new HibernateException(e.getMessage());
		}
	}

	/**
	 * 得到符合条件的总记录数
	 * @param query
	 * @return Integer
	 */
	@SuppressWarnings("unchecked")
	private Integer getTotalSize(Query query){
		List temp = query.list();
		Integer totalSize = temp.size();
		temp.clear();
		temp = null;
		return totalSize;
	}

	/**
	 * 根据(HQL: Hibernate查询语言)查询所有符合条件的记录，封装到Page对象中，page 中list 泛型为 T
	 * @param sql 查询语句
	 * @param pageNo 页码
	 * @param pageSize 每页大小
	 * @param args 参数
	 * @return Page 封装着分页查询结果对象和一些信息的对象
	 */
	@SuppressWarnings("unchecked")
	public Page pageQueryByPageNO(String sql,Integer pageNo,Integer pageSize,Object ...args) {
		try {
			sqlValidate(sql);
			Query query = util.getSession().createQuery(sql);
			for(int i=0;i<args.length;i++){
				query.setParameter(i, args[i]);
			}
			Integer totalSize = getTotalSize(query);
			Integer start = (pageNo-1)*pageSize;
			query.setFirstResult(start);
			query.setMaxResults(pageNo*pageSize);
			List<T> data = query.list();
			return new Page<T>(start, totalSize,pageSize, data);
		} catch (Exception e) {
			throw new HibernateException(e.getMessage());
		}
	}

	/**
	 * 根据(Native SQL查询语言)查询所有符合条件的记录，封装到Page对象中，page 中list 泛型为 OBject[]
	 * @param sql 查询语句
	 * @param pageNo 页码
	 * @param pageSize 每页大小
	 * @param args 参数
	 * @return Page 封装着分页查询结果对象和一些信息的对象
	 */
	@SuppressWarnings("unchecked")
	public Page pageSQLQueryByPageNO(String sql,Integer pageNo,Integer pageSize,Object ...args) {
		try {
			sqlValidate(sql);
			List<Object[]> result = new ArrayList<Object[]>(0);
			Object[] temp = null;
			SQLQuery query = util.getSession().createSQLQuery(sql);
			for (int i = 0; i < args.length; i++) {
				query.setParameter(i, args[i]);
			}
			Integer totalSize = getTotalSize(query);
			Integer start = (pageNo-1)*pageSize;
			query.setFirstResult(start);
			query.setMaxResults(pageNo*pageSize);
			List r = query.list();
			Iterator ite =  r.iterator();
			while(ite.hasNext()){
				temp =  (Object[]) ite.next();
				result.add(temp);
			}
			return new Page<Object[]>(start,totalSize,pageSize, result);
		} catch (Exception e) {
			throw new HibernateException(e.getMessage());
		}
	}

	/**
	 * 验证sql不为null||''
	 * @param sql
	 */
	private void sqlValidate(String sql) {
		if (sql == null || sql.trim().length() < 0) {
			throw new RuntimeException("sql sentence is null or is '' ");
		}
	}

}



[color=darkred]HibernateUtil [/color]


package org.jutil.hibernate.base;

import java.io.File;
import java.io.InputStream;
import java.io.Serializable;
import java.net.URL;
import java.util.Properties;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.w3c.dom.Document;

@SuppressWarnings("serial")
public class HibernateUtil implements Serializable {

	private static SessionFactory factory = null;
	private static HibernateUtil util = null;

	public static HibernateUtil getInstance(){
		if(util == null){
			util = new HibernateUtil();
		}
		return util;
	}

	private HibernateUtil(){
		try {
			Configuration cfg = new Configuration().configure();
			factory = cfg.buildSessionFactory();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static HibernateUtil getInstance(String resource,String ...files){
		if(util == null){
			util = new HibernateUtil(resource,files);
		}
		return util;
	}

	private HibernateUtil(String resource,String ...files){
		try {
			Configuration cfg = new Configuration();
			if(files.length>0){
				for(String f:files){
					cfg.addFile(f);
				}
			}
			factory = cfg.configure(resource).buildSessionFactory();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static HibernateUtil getInstance(File configFile,File ...files){
		if(util == null){
			util = new HibernateUtil(configFile,files);
		}
		return util;
	}

	private HibernateUtil(File configFile,File ...files){
		try {
			Configuration cfg = new Configuration();
			if(files.length>0){
				for(File f:files){
					cfg.addFile(f);
				}
			}
			factory = cfg.configure(configFile).buildSessionFactory();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static HibernateUtil getInstance(URL url,URL ...urls){
		if(util == null){
			util = new HibernateUtil(url,urls);
		}
		return util;
	}

	private HibernateUtil(URL url,URL ...urls){
		try {
			Configuration cfg = new Configuration();
			for(URL u :urls){
				cfg.addURL(u);
			}
			factory = cfg.configure(url).buildSessionFactory();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static HibernateUtil getInstance(Document document,Document ...docs){
		if(util == null){
			util = new HibernateUtil(document,docs);
		}
		return util;
	}

	private HibernateUtil(Document document,Document ...docs){
		try {
			Configuration cfg = new Configuration();
			for(Document doc :docs){
				cfg.addDocument(doc);
			}
			factory = cfg.configure(document).buildSessionFactory();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static HibernateUtil getInstance(InputStream inputStream,InputStream ...inputStreams){
		if(util == null){
			util = new HibernateUtil(inputStream,inputStreams);
		}
		return util;
	}

	private HibernateUtil(InputStream inputStream,InputStream ...inputStreams){
		try {
			Configuration cfg = new Configuration();
			cfg.addInputStream(inputStream);
			for(InputStream input :inputStreams){
				cfg.addInputStream(input);
			}
			factory = cfg.configure().buildSessionFactory();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static HibernateUtil getInstance(Properties  extraProperties,Properties ...properties){
		if(util == null){
			util = new HibernateUtil(extraProperties,properties);
		}
		return util;
	}

	private HibernateUtil(Properties  extraProperties,Properties ...properties){
		try {
			Configuration cfg = new Configuration();
			cfg.addProperties(extraProperties);
			for(Properties  propertie :properties){
				cfg.addProperties(propertie);
			}
			factory = cfg.configure().buildSessionFactory();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	@SuppressWarnings("unchecked")
	public static HibernateUtil getInstance(Class persistentClass,Class ...classes){
		if(util == null){
			util = new HibernateUtil(persistentClass,classes);
		}
		return util;
	}

	@SuppressWarnings("unchecked")
	private HibernateUtil(Class persistentClass,Class ...classes){
		try {
			Configuration cfg = new Configuration();
			cfg.addClass(persistentClass);
			for(Class  clss :classes){
				cfg.addClass(clss);
			}
			factory = cfg.configure().buildSessionFactory();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public SessionFactory getSessionFactory() {
		return factory;
	}

	public Session getSession() {
		return factory.openSession();
	}

	public void closeSession(Session session) {
		if (session != null) {
			if (session.isOpen()) {
				session.close();
			}
		}
	}

}



用于分页的Page对象


package org.jutil.hibernate.base;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class Page<T> {

	private static final long serialVersionUID = 2728437513842150372L;
	private static final int DEFAULT_PAGE_SIZE = 10;
	private int start;
	private List<T> data;
	private long totalCount;
	private int pageSize = DEFAULT_PAGE_SIZE;

	public Page() {
		this(0, 0L, Page.DEFAULT_PAGE_SIZE, ((List<T>) (new ArrayList<T>())));
	}

	public Page(int pageSize) {
		this(0, 0L, pageSize, ((List<T>) (new ArrayList<T>())));
	}

	public Page(int start, long totalSize, int pageSize, List<T> data) {
		if (pageSize <= 0 || start < 0 || totalSize < 0L) {

		} else {
			this.pageSize = pageSize;
			this.start = start;
			totalCount = totalSize;
			this.data = data;
			return;
		}
	}

	public long getTotalCount() {
		return totalCount;
	}

	public long getTotalPageCount() {
		return totalCount % (long) pageSize != 0L ? totalCount/ (long) pageSize + 1L: totalCount/ (long) pageSize;
	}

	public void setResult(List<T> data) {
		this.data = data;
	}

	public List<T> getResult() {
		return data;
	}

	public int getCurrentPageNo() {
		return start / pageSize + 1;
	}

	public boolean hasNextPage() {
		return (long) getCurrentPageNo() < getTotalPageCount();
	}

	public boolean hasPreviousPage() {
		return getCurrentPageNo() > 1;
	}

	public boolean isEmpty() {
		return data == null || data.isEmpty();
	}

	public int getStartIndex() {
		return (getCurrentPageNo() - 1) * pageSize;
	}

	public int getEndIndex() {
		int endIndex = getCurrentPageNo() * pageSize - 1;
		return (long) endIndex < totalCount ? endIndex : (int) totalCount - 1;
	}

	protected static int getStartOfPage(int pageNo) {
		return getStartOfPage(pageNo, 20);
	}

	public static int getStartOfPage(int pageNo, int pageSize) {
		return (pageNo - 1) * pageSize;
	}

	public int getPageSize() {
		return pageSize;
	}

	public void setPageSize(int pageSize) {
		this.pageSize = pageSize;
	}

}



[color=darkred]最后再附上所有的源码 和测试代码及配置文件。[/color]
基于hibernate封装的BaseDao
01-02
基于hibernate封装的BaseDao，有完整的增删改查，分页，执行hql sql 方法 约 20个方法，详情地址 https://blog.csdn.net/qq_41861261/article/details/85595872
Hibernate查询结果封装成一个自定义实体
xlin
04-17 1232
public void testSql() { List listdata = getHibernateTemplate().executeWithNativeSession( new HibernateCallback() { @Override public List doInHibernate(Session session) thr...
Hibernate查询部分字段并封装到指定类中及其可能遇到的问题
am540的博客
09-11 641
HQL中如果是多对多查询推荐使用@ManyToMany和@JoinTable的方式，可以节省存储空间和简化表结构，但如果是一对多或者多对一时，使用@ManyToOne或@OneToMany反而会产生中间表，表结构本来简单的情况下反而多此一举，只要在多的一方表字段中加入一的一方ID就够用了。不管如何联合查询，往往目的是需要把部分字段封装到特定类，hibernate可以用以下方式对HQL语言或SQL语...
Hibernate 自动进行数据封装
很酷的站长的博客
01-31 352
Hibernate 可以构建各种复杂的 SQL 语句，但其本质都是反射机制结合映射关系完成的。框架也仅是一款程序产品，人为编写的产物。要相信，只要你愿意，你完全可以实现自己的 JDBC 框架。本节课和大家继续聊聊 Hibernate 是如何自动封装数据的。
hibernate的封装
悲欢离合
03-25 452
创建Configuration对象 获取sessionfactory对象 获取session 开启事务transaction public class HibernateUtil { private static final SessionFactory FACTORY=buildSessionFactory(); //建一个session工厂 p...
讨论：在DAO中对Hibernate的封装
it_man的专栏
11-10 4012
我在现在的项目中在DAO层中对Hiberante做了如下封装： 用一个HibernateDAO封装一些共同的操作： 代码 package 
Spring框架学习【HibernateTemplate对Hibernate的封装】
zhixiang2010的专栏
01-21 1774
1.Spring中，不提供具体的ORM实现，而只是为应用提供对ORM产品的集成环境和使用平台，Spring将Hibernate的会话工厂通过IoC容器管理起来，并且将数据源注入，同时Spring为Hibernate提供了更上层的API封装，方便应用调用，本文通过分析相应源码了解Spring对Hibernate支持的实现。 2.AbstractSessionFactoryBean管理Hiberna
《Spring技术内幕》学习笔记12——HibernateTemplate对Hibernate的封装
Tony Chen的专栏
05-12 5848
1.Spring中，不提供具体的ORM实现，而只是为应用提供对ORM产品的集成环境和使用平台，Spring将Hibernate的会话工厂通过IoC容器管理起来，并且将数据源注入，同时Spring为Hibernate提供了更上层的API封装，方便应用调用，本文通过分析相应源码了解Spring对Hibernate支持的实现。 2.AbstractSessionFactoryBean管理Hiberna
spring技术内幕12-HibernateTemplate对Hibernate的封装
duanxin8678的专栏
07-15 597
1、Spring中，不提供具体的ORM实现，而只是为应用提供对ORM产品的集成环境和使用平台，
spring对hibernate的简单封装(hibernateTemplate)
遗失的世界
09-16 255
bean.xml中添加： &lt;!-- spring对hibernate的简单封装 --&gt; &lt;bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate"&gt; &lt;property name="sessionFactory" ref="mySessi.
Hibernate快速入门笔记
weixin_33794672的博客
04-09 374
[toc] Hibernate它是一个轻量级的jdbc封装，也就是说，我们可以使用hibernate来完成原来我们使用jdbc完成操作，就是与数据库的交互操作。它是在dao层去使用的。 对象关系映射（英语：Object Relation Mapping，简称ORM，或O/RM，或O/R mapping）。简单说，我们使用orm可以将我们的对象与我们的类去进行映射，使的我们可以去操作对象就完成对表的...
简单封装 HibernateTemplate 各项功能
09-16
GenericHibernateDao 继承 HibernateDao，简单封装 HibernateTemplate 各项功能，简化基于Hibernate Dao 的编写。
封装了一个Hibernate增删改查的工具类
01-07
一个工具类实现了增删改查 util comm.util beanutils 方便了获取session和sessionFactory
hibernate入门实例封装了HibernateUtil
07-06
hibernate入门实例封装了HibernateUtil,完成数据库的添加操作，和查询操作。 Session的save方法和get方法。
Hibernate封装通用数据操作基类DAO
yuanlaishini2010的专栏
10-28 2006
package com.util; import java.io.Serializable; import java.sql.SQLException; import java.util.List; import java.util.Map; import java.util.Set; import
hibernate封装
chitangya6507的博客
10-29 303
有幸和一个技术比较厉害的同事做项目，本来快要失败的项目被死死的整活了，以下是他对hibernate的封装，可以放在线程里使用的哦(以前不知道呢，-_-!，hibernate的功能真大啊 ) package com.eclink.editp.dao; import java.io.Seria...
Hibernate（对JDBC的轻量级封装）
weixin_44030848的博客
02-13 1526
目录认识Hibernatehibernate部署测试步骤程序文件0.导入hibernate所依赖的的包1.product.java2.类和表的配置文件3.数据库连接配置文件4.TestHibernate.java 认识Hibernate 使用JDBC做数据库相关功能开发会做很多重复性的工作，比如创建连接，关闭连接，把字段逐一映射到属性中。 Hibernate把这一切都封装起来了，使得数据库访问变得...
Hibernate 框架（五）（hibernate的封装工具）
qq_42421212的博客
04-17 374
package dc.com; import java.io.Serializable; import java.util.List; import java.util.Map; import org.hibernate.Hibernate; import org.hibernate.Session; import org.hibernate.SessionFactory; import ...
hibernate 简单封装
weixin_30578677的博客
11-12 160
package com.wode.util; import org.hibernate.HibernateException;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.cfg.Configuration; public class HibernateUtil { p...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值