`
guduxing890
  • 浏览: 5680 次
  • 性别: Icon_minigender_1
  • 来自: 南京
社区版块
存档分类
最新评论

Hibernate 通用接口设计

Hibernate 
阅读更多

 

public interface CommonMng {

    /**
     * 根据主键进行单个对象查询
     * 
     * @author guduxing890
     * @param clazz
     *            EntityClass
     * @param pk
     *            主键
     * @return
     * @see [类、类#方法、类#成员]
     */
    public <T> T findEntityById(Class<T> clazz, Serializable pk);

    /**
     * 根据主键和 属性参数进行单个对象查询
     * 
     * @author guduxing890
     * @param clazz
     *            EntityClass
     * @param pk
     *            主键
     * @param properties
     *            属性
     * @param param
     *            参数
     * @return
     * @see [类、类#方法、类#成员]
     */
    public <T> T findByProperty(Class<T> clazz, Serializable pk,
	    String properties, Object param);

    /**
     * 查询实体所有记录
     * 
     * @author guduxing890
     * @param clazz
     *            EntityClass
     * @return
     * @see [类、类#方法、类#成员]
     */
    public <T> List<T> findByClass(Class<T> clazz);

    /**
     * 根据属性和参数，查询实体记录
     * 
     * @author guduxing890
     * @param clazz
     *            EntityClass
     * @param properties
     *            属性数组
     * @param params
     *            参数数组
     * @return
     * @see [类、类#方法、类#成员]
     */
    public <T> List<T> findByProperties(Class<T> clazz, String[] properties,
	    Object[] params);

    /**
     * 根据属性和参数， 查询实例记录，增加排序字段和排序方式 <br/>
     * 备注：如果排序字段和排序方式不对等，多余的排序字段自动使用 升序排列
     * 
     * @author guduxing890
     * @param clazz
     *            实体类
     * @param properties
     *            属性数组
     * @param params
     *            参数数组
     * @param orderProperty
     *            排序字段数组
     * @param sort
     *            排序方式
     * @return
     * @see [类、类#方法、类#成员]
     */
    public <T> List<T> findByProperties(Class<T> clazz, String[] properties,
	    Object[] params, String[] orderProperty, String[] sort);

    /**
     * 根据参数，查询数量
     * 
     * @author guduxing890
     * @param clazz
     * @param properties
     * @param params
     * @return
     * @see [类、类#方法、类#成员]
     */
    public <T> int count(Class<T> clazz, String[] properties, Object[] params);

    /**
     * 根据属性和参数， 查询实例记录，增加排序字段和排序方式 ,和返回最大记录数<br/>
     * 备注：如果排序字段和排序方式不对等，多余的排序字段自动使用 升序排列
     * 
     * @author guduxing890
     * @param clazz
     *            实体类
     * @param properties
     *            属性
     * @param params
     *            参数
     * @param orderProperty
     *            排序字段
     * @param sort
     *            排序方式
     * @param count
     *            最大返回数量
     * @return
     * @see [类、类#方法、类#成员]
     */
    public <T> List<T> findByProperties(Class<T> clazz, String[] properties,
	    Object[] params, String[] orderProperty, String[] sort, int count);

    /**
     * 根据属性和参数， 查询分页，增加排序字段和排序方式 ,和返回最大记录数<br/>
     * 备注：如果排序字段和排序方式不对等，多余的排序字段自动使用 升序排列
     * 
     * @author guduxing890
     * @param clazz
     *            实体类
     * @param properties
     *            属性
     * @param params
     *            参数
     * @param orderProperty
     *            排序字段
     * @param sort
     *            排序方式
     * @param pageNo
     *            页码
     * @param count
     *            最大返回数量
     * @return
     * @see [类、类#方法、类#成员]
     */
    public <T> Pagination<T> findPager(Class<T> clazz, String[] properties,
	    Object[] params, String[] orderProperty, String[] sort, int pageNo,
	    int count);

    /**
     * 根据条件查询对象
     * 
     * @author guduxing890
     * @param clazz
     *            实体类
     * @param properties
     *            属性
     * @param params
     *            参数
     * @param count
     *            最大返回数量
     * @return
     * @see [类、类#方法、类#成员]
     */
    public <T> List<T> findByProperties(Class<T> clazz, String[] properties,
	    Object[] params, int count);

    /**
     * 更新或修改对象
     * 
     * @author guduxing890
     * @param t
     *            实例对象
     * @see [类、类#方法、类#成员]
     */
    public <T> void saveOrUpdate(T t);

    /**
     * 新增对象
     * 
     * @author guduxing890
     * @param t
     *            实例对象
     * @see [类、类#方法、类#成员]
     */
    public <T> void save(T t);

    /**
     * 保存所有对象
     * 
     * @author guduxing890
     * @param t
     * @see [类、类#方法、类#成员]
     */
    <T> void saveAll(T... t);

    /**
     * 根据属性查询实体
     * 
     * @author guduxing890
     * @param clazz
     *            Hibernate映射实体
     * @param properties
     *            属性数组
     * @param params
     *            参数数组
     * @param orderProperty
     *            排序属性数组
     * @param sort
     *            排序方式
     * @param firstResult
     *            起始行
     * @param count
     *            最大返回结果数
     * @return
     * @see [类、类#方法、类#成员]
     */
    <T> List<T> findByProperties(Class<T> clazz, String[] properties,
	    Object[] params, String[] orderProperty, String[] sort,
	    int firstResult, int count);

    /**
     * 删除对象
     * 
     * @author guduxing890
     * @param t
     * @see [类、类#方法、类#成员]
     */
    <T> void delete(T t);

 

 

 

以上为Services 层

 

 dao 层代码实现

 

/*
 * 文 件 名:  CommonDaoImpl.java
 * 版    权:  XX Technologies Co., Ltd. Copyright YYYY-YYYY,  All rights reserved
 * 描    述:  <描述>
 * 修 改 人:  guduxing890
 * 修改时间:  2013-3-22
 * 跟踪单号:  <跟踪单号>
 * 修改单号:  <修改单号>
 * 修改内容:  <修改内容>
 */
package com.xxx.web.dao.impl;

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

import org.apache.commons.lang.StringUtils;
import org.hibernate.Criteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.springframework.stereotype.Repository;

import com.xxx.common.Constants;
import com.xxx.common.dao.HibernateSimpleDao;
import com.xxx.web.dao.CommonDao;
/**
 * 
 * @author guduxing890
 * @version [版本号, 2013-3-22]
 * @see [相关类/方法]
 * @since [产品/模块版本]
 */
@Repository
@SuppressWarnings("rawtypes")
public class CommonDaoImpl extends HibernateSimpleDao implements CommonDao {

    private static final String OBJECT_SEP = ".";

    /**
     * 重载方法
     * 
     * @param clazz
     * @param pk
     * @return
     */
    @SuppressWarnings("unchecked")
    @Override
    public <T> T getEntityById(Class<T> clazz, Serializable pk) {
	return (T) getSession().get(clazz, pk);
    }

    @SuppressWarnings("unchecked")
    @Override
    public <T> T findByProperty(Class<T> clazz, Serializable pk,
	    String properties, Object param) {
	Criteria criteria = getSession().createCriteria(clazz);
	criteria.add(Restrictions.eq(properties, param));
	criteria.add(Restrictions.idEq(pk));
	return (T) criteria.uniqueResult();
    }

    @Override
    public <T> List<T> findByClass(Class<T> clazz) {
	return findByProperties(clazz, null, null, null, null);
    }

    @Override
    public <T> List<T> findByProperties(Class<T> clazz, String[] properties,
	    Object[] params) {
	return findByProperties(clazz, properties, params, null, null);
    }

    @Override
    public <T> void saveOrUpdateAll(T... t) {
	for (T a : t) {
	    this.saveOrUpdate(a);
	}
    }

    /**
     * 重载方法
     * 
     * @param clazz
     * @param properties
     * @param params
     * @param orderProperty
     * @param sort
     * @param count
     * @return
     */
    @Override
    public <T> List<T> findByProperties(Class<T> clazz, String[] properties,
	    Object[] params, String[] orderProperty, String[] sort,
	    Integer count) {
	return this.findByProperties(clazz, properties, params, orderProperty,
		sort, null, count);

    }

    /**
     * 重载方法
     * 
     * @param clazz
     * @param properties
     * @param params
     * @return
     */
    @Override
    public <T> List<T> findByProperties(Class<T> clazz, String[] properties,
	    Object[] params, String[] orderProperty, String[] sort) {
	return findByProperties(clazz, properties, params, null, null, null);
    }

    /**
     * 保存对象
     * 
     * @author guduxing890
     * @param t
     * @see [类、类#方法、类#成员]
     */
    public <T> void save(T t) {
	if (t instanceof Collection) {
	    Collection c = (Collection) t;
	    this.getHibernateTemplate().saveOrUpdateAll(c);
	} else {
	    this.getSession().save(t);
	}
    }

    /**
     * 保存或更新对象
     * 
     * @author guduxing890
     * @param t
     * @see [类、类#方法、类#成员]
     */
    public <T> void saveOrUpdate(T t) {
	this.getSession().saveOrUpdate(t);
    }

    /**
     * 重载方法
     * 
     * @param clazz
     * @param properties
     * @param params
     * @return
     */
    @Override
    public <T> int count(Class<T> clazz, String[] properties, Object[] params) {

	Criteria criteria = getSession().createCriteria(clazz);
	if (null != properties) {
	    int paramLen = properties.length;
	    for (int i = 0; i < paramLen; i++) {
		// 进行属性处理
		String property = properties[i];

		// 把属性进行用 . 分割。 取出里面的每一个子对象。作为一个子 Criteria.进行关联查询
		if (property.indexOf(OBJECT_SEP) != -1) {
		    String[] props = StringUtils.split(property, OBJECT_SEP);

		    Criteria propertyCriteria = null;
		    for (int y = 0; y < props.length - 1; y++) {
			if (y == 0) {
			    propertyCriteria = criteria
				    .createCriteria(props[y]);
			} else {
			    propertyCriteria = propertyCriteria
				    .createCriteria(props[y]);
			}
		    }
		    propertyCriteria.add(Restrictions.eq(
			    props[props.length - 1], params[i]));
		} else {
		    criteria.add(Restrictions.eq(properties[i], params[i]));
		}

	    }
	}
	// 查询记录条数
	criteria.setProjection(Projections.rowCount());

	return Integer.parseInt(criteria.uniqueResult().toString());
    }

    /**
     * 重载方法
     * 
     * @param clazz
     * @param properties
     * @param params
     * @param orderProperty
     * @param sort
     * @param firstResult
     * @param count
     * @return
     */
    @SuppressWarnings("unchecked")
    @Override
    public <T> List<T> findByProperties(Class<T> clazz, String[] properties,
	    Object[] params, String[] orderProperty, String[] sort,
	    Integer firstResult, Integer count) {
	Criteria criteria = getSession().createCriteria(clazz);
	if (null != properties) {
	    int paramLen = properties.length;
	    for (int i = 0; i < paramLen; i++) {
		// 进行属性处理
		String property = properties[i];

		// 把属性进行用 . 分割。 取出里面的每一个子对象。作为一个子 Criteria.进行关联查询
		if (property.indexOf(OBJECT_SEP) != -1) {
		    String[] props = StringUtils.split(property, OBJECT_SEP);

		    Criteria propertyCriteria = null;
		    for (int y = 0; y < props.length - 1; y++) {
			if (y == 0) {
			    propertyCriteria = criteria
				    .createCriteria(props[y]);
			} else {
			    propertyCriteria = propertyCriteria
				    .createCriteria(props[y]);
			}
		    }
		    propertyCriteria.add(Restrictions.eq(
			    props[props.length - 1], params[i]));
		} else {
		    criteria.add(Restrictions.eq(properties[i], params[i]));
		}

	    }
	}
	// 增加排序字段
	if (null != orderProperty) {
	    int length = orderProperty.length;

	    for (int i = 0; i < length; i++) {
		Order order = null;
		if (null != sort && i < sort.length) {
		    order = Constants.SORT_TYPE_ASC.equalsIgnoreCase(sort[i]) ? Order
			    .asc(orderProperty[i]) : Order
			    .desc(orderProperty[i]);
		} else {
		    order = Order.asc(orderProperty[i]);
		}
		criteria.addOrder(order);

	    }
	}
	if (count == null) {
	    count = 5000;
	}
	if (null != firstResult) {
	    criteria.setFirstResult(firstResult);
	}
	criteria.setMaxResults(count);
	return (List<T>) criteria.list();
    }

    /**
     * 重载方法
     * 
     * @param t
     */
    @Override
    public <T> void delete(T t) {
	this.getSession().delete(t);
    }

}

 

 

分享到：
| There is a cycle in the hierarchy! 问题 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    hibernate 通用接口架构

    "hibernate 通用接口架构"是指利用Hibernate框架，通过设计DAO（Data Access Object）层的接口来实现业务逻辑与数据访问的解耦，从而提高代码的可复用性和可维护性。 首先，我们来理解DAO层的作用。DAO层作为业务...

    Hibernate通用Dao设计。

    综上所述，Hibernate通用DAO设计的核心在于抽象出共性的数据库操作，并通过泛型和继承等面向对象设计原则，达到代码复用的目的。这样不仅可以降低开发难度，还能提升系统的可维护性，对于大型项目尤其重要。通过学习...

    Hibernate泛型DAO接口，大部分通用都已包括

    本篇将详细介绍"Hibernate泛型DAO接口，大部分通用都已包括"这一主题。 首先，让我们看看DAO的概念。DAO是软件设计模式中的一种，它的主要职责是封装对数据源的访问，以提供业务逻辑层与数据存储层之间的解耦。通过...

    hibernate4 通用dao,service

    7. 最佳实践：博主可能分享了一些在使用Hibernate时的最佳实践，如避免N+1查询，优化性能，以及如何设计良好的服务接口等。 标签中的“源码”意味着这个资源可能包含了可以下载和学习的代码，而“工具”可能指这个...

    Hibernate的通用dao

    通用DAO则是这一模式的扩展，提供了一套适用于多种数据实体的通用接口和实现，减少代码重复，提高代码复用性。 **三、Hibernate通用DAO实现** 1. **接口定义**：首先，定义一个通用的DAO接口，如`BaseDao&lt;T&gt;`，...

    Hibernate 原生通用DAO

    **Hibernate原生通用DAO**是基于Hibernate框架设计的一种简化数据访问操作的方式，它模仿了Spring框架中的`HibernateTemplate`类，旨在提供一个简单易用的DAO（Data Access Object）层，方便开发人员进行数据库操作...

    Hibernate_通用DAO模式，一个写好的dao层

    本资源“Hibernate_通用DAO模式”提供了一种适用于不同类型表单的DAO实现，基于SSH（Struts2、Spring、Hibernate）框架，特别强调简洁、易懂和高可移植性。 首先，SSH框架是Java Web开发中的经典组合，Struts2负责...

    hibernate通用dao

    Hibernate通用DAO设计** 通用DAO是为了减少重复代码，提高代码复用性。通常包含以下方法： - `save(T entity)`: 保存实体对象。 - `update(T entity)`: 更新实体对象。 - `deleteById(ID id)`: 根据ID删除实体。 - ...

    Struts+Spring+Hibernate通用分页解决方案

    "Struts+Spring+Hibernate通用分页解决方案"是针对基于这三大框架（Struts、Spring、Hibernate）的Java Web应用所设计的一种高效且可复用的分页策略。以下是关于这个主题的详细解释： 1. **Struts框架**：Struts是...

    hibernate不是泛型的通用DAo1

    然而，为了提高代码的复用性和可维护性，通常会设计一个通用DAO（Data Access Object）层来处理基本的数据操作。"hibernate不是泛型的通用DAo1"这个标题暗示了我们讨论的是一种非泛型化的DAO实现，可能是因为开发者...

    Struts+Spring+hibernate通用调查系统

    这个"Struts+Spring+hibernate通用调查系统"是一个基于这个技术栈的网络应用，用于实现在线调查的功能。在这个系统中，Struts负责控制层，Spring处理业务逻辑和服务层，而Hibernate则作为持久层框架，管理数据库交互...

    spring和hibernate集成后，通用的basedao

    在这个名为"ssh"的压缩包中，很可能包含了一个关于Spring和Hibernate集成的示例代码，用于实现一个通用的基于DAO（Data Access Object）的设计模式。 Spring框架通过其IoC（Inversion of Control，控制反转）和AOP...

    Struts2 Spring3 Hibernate 注解功能 DAO 泛型 通用分页

    总的来说，"SSHWithAnnotationDemo"项目展示了如何利用现代Java技术栈的高级特性，包括Struts2、Spring3和Hibernate的注解功能，DAO层的泛型设计以及通用的分页实现，来构建一个高效、可维护的Web应用。这样的实践...

    基于Java的Hibernate统一操作接口封装设计源码

    该源码库采用Java语言，基于Hibernate框架设计了统一的操作接口封装，共包含33个文件，其中28个为Java源文件，2个为XML配置文件，1个为Git忽略文件，并附带1个LICENSE文件和1个描述文档。该封装旨在简化Hibernate的...

    hibernate sturts 分页 通用

    在IT行业中，分页是网页...这些代码应该展示了如何在Hibernate和Struts基础上实现通用的分页功能，并可能通过Spring进行优化。通过学习和理解这些代码，开发者可以掌握如何在实际项目中实现高效且可复用的分页机制。

    封装hibernate统一操作接口

    2. **重用性**：通过接口定义通用操作，不同的数据实体可以共用一套操作接口，减少重复代码。 3. **易维护**：接口提供了一种标准，方便后期修改和扩展。 4. **灵活性**：统一接口允许使用不同的实现策略，如切换到...

    一个通用的Hibernate DAO

    - **作用**：提供了一个简单的文档说明，用于描述通用Hibernate DAO的设计思路和实现方法。 #### 三、标签：DAO - **含义**：DAO是Data Access Object的缩写，数据访问对象，是一种常用的设计模式。在本例中，特指...

    hibernate教程打包下载，史上最全的HIBERNATE

    5. **Session与Transaction**：Hibernate中的Session是操作数据库的主要接口，它负责对象的持久化。Transaction管理则涉及到数据库事务的开始、提交和回滚，确保数据的一致性。 6. **CRUD操作**：创建（Create）、...

    Spring+Hibernate实现）Hibernate公用类

    本文将详细解析如何利用Spring和Hibernate来实现一个通用的DAO（Data Access Object）层，以提高代码复用性和项目开发效率。 首先，让我们了解Spring框架。Spring是一个全面的企业级应用开发框架，提供了依赖注入...

Magicbox
Global site tag (gtag.js) - Google Analytics