hibernate通用方法接口与实现

最新推荐文章于 2018-06-21 09:14:47 发布
最新推荐文章于 2018-06-21 09:14:47 发布
阅读量148 收藏
点赞数
文章标签： Hibernate Spring OO ASP DAO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteye_4343/article/details/81758793
版权

hibernate通用方法接口（一）

package com.diyjava.dao;

import java.io.Serializable;
import java.util.List;

/**
 * 一些通用的CRUD方法接口
 * http://www.diyjava.com
 * @author colin
 *
 * @param <T>
 */
public interface BaseDao<T extends Serializable> {
 /**
  * 添加对象
  *
  * @param t
  * @return
  */
 T add(T t);

 /**
  * 修改对象
  *
  * @param t
  * @return
  */
 T update(T t);

 /**
  * 删除对象
  *
  * @param t
  * @return
  */
 T remove(T t);

 /**
  * 按id进行删除对象
  *
  * @param id
  * @return
  */
 T removeById(Serializable id);

 /**
  * 按id进行查询对象
  *
  * @param id
  * @return
  */
 T load(Serializable id);

 /**
  * 按id进行查询对象
  *
  * @param id
  * @param lock
  *            是否锁定对象
  * @return
  */
 T load(Serializable id, bOOlean lock);

 /**
  * 按id进行查询对象
  *
  * @param id
  * @return
  */
 T get(Serializable id);

 /**
  * 查询对象
  *
  * @param first
  *            记录开始位置
  * @param max
  *            返回最大的记录数
  * @return
  */
 List<T> find(int first, int max);

 /**
  * 按条件进行查询
  *
  * @param parameter
  *            属性
  * @param value
  *            属性对应的值
  * @return
  */
 List<T> find(String[] parameter, Object[] value);

 /**
  * 按条件进行查询，返回从first开始的max条记录
  *
  * @param parameter
  *            属性
  * @param value
  *            属性对应的值
  * @param first
  *            记录起始位置
  * @param max
  *            返回最大的记录
  * @return
  */
 List<T> find(String[] parameter, Object[] value, int first, int max);

 /**
  * 按条件进行查询并进行排序，返回从first开始的max条记录
  *
  * @param parameter
  *            属性
  * @param value
  *            属性对应的值
  * @param first
  *            记录起始位置
  * @param max
  *            返回最大的记录
  * @param order
  *            排序
  * @return
  */
 List<T> find(String[] parameter, Object[] value, int first, int max,
   String[][] order);

 /**
  * 查找所有结果
  *
  * @return
  */
 List<T> findAll();
 
 /**
  * 查找所有结果并进行排序
  * @param order
  * @return
  */
 List<T> findAll(String[][] order);
}

 

 

接口实现请参考http://www.diyjava.com/kyjs/ShowArticle.asp?ArticleID=6289

引用请注明出处：http://www.diyjava.com

 

hibernate通用方法接口实现（二）

package com.diyjava.dao;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.sql.SQLException;
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.hibernateException;
import org.hibernate.LockMode;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.orm.hibernate3.hibernateCallback;
import org.springframework.orm.hibernate3.support.hibernateDaoSupport;
import org.springframework.util.Assert;

/**
 * 实现通用的CRUD方法
 * http://www.diyjava.com
 * @author colin
 *
 * @param <T>
 */
public abstract class BaseDaoImpl<T extends Serializable> extends
  hibernateDaoSupport implements BaseDao<T> {
 public Logger log = LoggerFactory.getLogger(getClass());

 private Class<T> persistentClass = null;

 @SuppressWarnings("unchecked")
 public BaseDaoImpl() {
  this.persistentClass = (Class<T>) ((ParameterizedType) getClass()
    .getGenericSuperclass()).getActualTypeArguments()[0];
 }

 public Class<T> getPersistentClass() {
  return persistentClass;
 }

 public T add(T t) {
  Assert.notNull(t);
  gethibernateTemplate().save(t);
  return t;
 }

 public T update(T t) {
  Assert.notNull(t);
  gethibernateTemplate().saveOrUpdate(t);
  return t;
 }

 public T remove(T t) {
  Assert.notNull(t);
  gethibernateTemplate().delete(t);
  return t;
 }

 public T removeById(Serializable id) {
  Assert.notNull(id);
  T entity = load(id);
  gethibernateTemplate().delete(entity);
  return entity;
 }

 public T load(Serializable id) {
  Assert.notNull(id);
  return load(id, false);
 }

 @SuppressWarnings("unchecked")
 public T load(Serializable id, bOOlean lock) {
  Assert.notNull(id);
  T entity = null;
  if (lock) {
   entity = (T) gethibernateTemplate().load(getPersistentClass(), id,
     LockMode.UPGRADE);
  } else {
   entity = (T) gethibernateTemplate().load(getPersistentClass(), id);
  }
  return entity;
 }

 @SuppressWarnings("unchecked")
 public T get(Serializable id) {
  Assert.notNull(id);
  T entity = (T) gethibernateTemplate().get(getPersistentClass(), id);
  return entity;
 }

 @SuppressWarnings("unchecked")
 public List<T> find(final int first, final int max) {
  return (List<T>) gethibernateTemplate().execute(
    new hibernateCallback() {
     public Object doInhibernate(Session session)
       throws hibernateException, SQLException {
      Criteria criteria = session
        .createCriteria(getPersistentClass());
      criteria.setFirstResult(first);
      criteria.setMaxResults(max);
      return criteria.list();
     }
    });
 }

 @SuppressWarnings("unchecked")
 public List<T> find(final String[] parameter, final Object[] value) {
  return (List<T>) gethibernateTemplate().execute(
    new hibernateCallback() {
     public Object doInhibernate(Session session)
       throws hibernateException, SQLException {
      Criteria criteria = session
        .createCriteria(getPersistentClass());
      for (int i = 0; i < parameter.length; i++) {
       criteria.add(Restrictions
         .eq(parameter[i], value[i]));
      }
      return criteria.list();
     }
    });
 }

 @SuppressWarnings("unchecked")
 public List<T> find(final String[] parameter, final Object[] value,
   final int first, final int max) {
  return (List<T>) gethibernateTemplate().execute(
    new hibernateCallback() {
     public Object doInhibernate(Session session)
       throws hibernateException, SQLException {
      Criteria criteria = session
        .createCriteria(getPersistentClass());
      for (int i = 0; i < parameter.length; i++) {
       criteria.add(Restrictions
         .eq(parameter[i], value[i]));
      }
      criteria.setFirstResult(first);
      criteria.setMaxResults(max);
      return criteria.list();
     }
    });
 }

 @SuppressWarnings("unchecked")
 public List<T> find(final String[] parameter, final Object[] value,
   final int first, final int max, final String[][] order) {
  return (List<T>) gethibernateTemplate().execute(
    new hibernateCallback() {
     public Object doInhibernate(Session session)
       throws hibernateException, SQLException {
      Criteria criteria = session
        .createCriteria(getPersistentClass());
      for (int i = 0; i < parameter.length; i++) {
       criteria.add(Restrictions
         .eq(parameter[i], value[i]));
      }//end条件过滤
      for (int j = 0; j < order.length; j++) {
       criteria
         .addOrder(order[j][1]
           .compareToIgnoreCase("asc") == 0 ? Order
           .asc(order[j][0])
           : Order.desc(order[j][0]));
      }//end排序
      criteria.setFirstResult(first);
      criteria.setMaxResults(max);

      return criteria.list();
     }
    });
 }

 @SuppressWarnings("unchecked")
 public List<T> findAll() {
  return gethibernateTemplate().find(
    "from " + getPersistentClass().getName());
 }

 @SuppressWarnings("unchecked")
 public List<T> findAll(final String[][] order) {
  return (List<T>) getHibernateTemplate().execute(new hibernateCallback() {
   public Object doInhibernate(Session session)
     throws hibernateException, SQLException {
    Criteria criteria = session
      .createCriteria(getPersistentClass());
    for (int i = 0; i < order.length; i++) {
     criteria
       .addOrder(order[i][1].compareToIgnoreCase("asc") == 0 ? Order
         .asc(order[i][0])
         : Order.desc(order[i][0]));
    }
    return criteria.list();
   }
  });
 }

}

 

接口请参考http://www.diyjava.com/kyjs/ShowArticle.asp?ArticleID=6288

引用请注明出处：http://www.diyjava.com

iteye_4343
关注
Hibernate 通用的Dao及其实现类
夏沐的博客
07-19 1168
BaseDao.java接口： package com.crm.dao; import java.io.Serializable; import java.util.List; import org.hibernate.criterion.DetachedCriteria; /** * 通用的DAO的接口 * @author jt * */ public interface Ba...
基于泛型的通用Dao接口和hibernate的实现
07-07
基于泛型的通用Dao接口和Hibernate的实现 基于泛型的通用Dao接口是指使用泛型来实现数据访问对象（DAO）的接口，主要是在使用 Hibernate 或 JPA 时使用。泛型可以使得DAO接口更灵活、更通用。 泛型Dao接口的优点：...
hibernate 通用接口架构
04-13
使用hibernate框架，面向接口进行dao层的设计，是通用的底层架构.
hibetnateTemplate常用方法
a243932069的专栏
10-28 814
1、delete(Object entity) 删除指定的持久化实例 在程序中一般先用 Assert.notNull和 Assert.isTrue断言entity是否为空 和 entity的id是否大于0若 否则事务回滚。再用get(Class entityClass,Serializable id,LockMode lockMode)加锁查询出持久 化实例，一般用lockMode.upda
Hibernate 通用接口设计
我的技术博客
11-18 255
  public interface CommonMng { /** * 根据主键进行单个对象查询 * * @author guduxing890 * @param clazz * EntityClass * @param pk * 主键 ...
hibernate通用方法
gotohbu的专栏
08-31 539
insert方法public void insert(Object o){    Session session = HibernateSessionFactory.currentSession();    Transaction t = session.beginTransaction();    session.save(o);    t.commit();    HibernateSessi
Hibernate泛型DAO接口，大部分通用都已包括
06-01
在实际开发中，为了提高代码的可重用性和可维护性，通常会创建泛型DAO（Data Access Object）接口来处理与数据库交互的通用逻辑。本篇将详细介绍"Hibernate泛型DAO接口，大部分通用都已包括"这一主题。 首先，让...
struts+spring+hibernate通用分页方法
03-05
这个“struts+spring+hibernate通用分页方法”是关于如何在整合这三大框架的项目中实现高效且可复用的分页功能的知识点。 首先，让我们了解分页的基本概念。在Web应用中，特别是在处理大数据量时，分页是一种提高...
HibernateTemplate原理代码-模版设计模式
12-11
Callback 接口： import org.hibernate.Session; public interface MyHibernateCallback { public void doInHibernate(Session s); }
hibernateTemplate的常用方法
04-13
hibernateTemplate的常用方法
Hibernate的Template方法以及SQL简介
12-10
Hibernate的Template方法以及SQL简介 Template方法18种以及SQL23种
使用 HibernateTemplate 实现分页查询 (HibernateCallback接口)
weixin_33750452的博客
09-07 102
HibernateTemplate 只支持 .setMaxResults(int) 方法。 因此，做 Spring+Hibernate 分页处理要使用到一个接口 org.springframework.orm.hibernate3.HibernateCallback来灵活操作数据库，该接口中有一个未实现的方法 Object doInHibernate (Se...
编写一些简单的hibernate的Dao通用性接口（用泛型）
weixin_41692832的博客
06-21 204
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); ...
NHibernate自定义集合类型（中）：通用实现方式
weixin_34208185的博客
10-11 87
上一片文章中我们观察了在代码中自定义一个基于Set的集合类型该怎么做，以及简单了解了一下NHibernate的这些自定义支持大致是如何工作的。不过文章最后还是留了两个问题，一是认为这种扩展方式不够通用，二是其中会出现的“重复”或是“反向依赖”。现在我们就需要在上文的基础上进行总结，提出一个通用的实现，可以方便我们构建自定义的集合类型。 既然要通用，我们要做的第一件事情就是对之前的例子进行总结。在Q...
Hibernate通用Dao实现
Switch的博客
12-02 6965
Hibernate通用Dao实现@(Hibernate)[dao, hibernate, 反射]Hibernate通用Dao实现 BaseDao接口 BaseDao接口实现类 BaseDao接口package com.pc.crm.common.dao;import java.io.Serializable; import java.util.List;import org.hibernate.cr
hibernate的延迟加载通用方法(转)
vjnjjs的专栏
10-22 125
package com.antbee.j2eemodel.util;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;import java.util.Collection;import java.util.Iterator;import org.springframework.or...
Spring+Hibernate框架下泛型DAO实现与使用
作者通过查阅多种实现方式，汇总了一个通用的泛型DAO接口`GenericDao`的实现，方便开发人员进行后续的编码工作。" 在Java开发中，尤其是企业级应用，Spring和Hibernate是常见的两大框架，它们分别负责控制反转（IoC...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值