`
happmaoo
  • 浏览: 4548493 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

泛型/类型安全DAO编写

DAOUMLGoogleIBM 
阅读更多
<iframe align="top" marginwidth="0" marginheight="0" src="http://www.zealware.com/46860.html" frameborder="0" width="468" scrolling="no" height="60"></iframe>

由于要求在项目中使用泛型的DAO，所以上网Google了一下，找到了IBM的一篇文章。文章讲得不错，但是有些地方不清楚，如果完全按照那篇文章可能还会遇到一些困难。所以写了这篇文章，解释如何在项目中加入泛型的DAO实现。

首先是总的类关系的UML图:

然后是在配置文件中的关系图：

其中，IStaffDao是我们自己定义的接口，这个接口类似：

public interface IStaffDAO extends GenericDao Staff,Integer > {

 public ListlistAll();

 public StaffgetByLogonAndId(Stringlogon,Integerid);

 // more

}

GenericDao<t pk extends serilizable></t> 是泛型的 Dao 接口：

/***/ /**
*2006-11-22
*范型DAO接口
* @author ZouAng
*ContactZouAng
 */
public interface GenericDao T,PK extends Serializable > {

 /***/ /**
*保存一个对象到数据库
* @param newInstance需要保存的对象
* @return
*/
PKcreate(TnewInstance);
 /***/ /**
*从数据库读取一个对象
* @param id主键
* @return
*/
Tread(PKid);

 /***/ /**
*更新一个对象
* @param transientObject被更新的对象
 */
void update(TtransientObject);

 /***/ /**
*删除一个对象
* @param transientObject被删除的对象
 */
void delete(TtransientObject);
}

GenericDaoHibernateImpl 是 GenericDao 接口的泛型实现 :


/***/ /**
*2006-11-22
*范型DAO实现
* @author ZouAng
*ContactZouAng
 */
public class GenericDaoHibernateImpl T,PK extends Serializable >
extends HibernateDaoSupport
 implements GenericDao T,PK > ,FinderExecutor {

 private Class T > type;
 private FinderNamingStrategynamingStrategy = new SimpleFinderNamingStrategy(); // Default.Canoverrideinconfig
private FinderArgumentTypeFactoryargumentTypeFactory = new SimpleFinderArgumentTypeFactory(); // Default.Canoverrideinconfig

public GenericDaoHibernateImpl(Class T > type) {
 this .type = type;
}

/**/ /* (non-Javadoc)
*@seecom.gdnfha.atcs.common.service.dao.GenericDao#create(java.lang.Object)
 */
public PKcreate(TnewInstance) {
 return (PK)getHibernateTemplate().save(newInstance);
}

/**/ /* (non-Javadoc)
*@seecom.gdnfha.atcs.common.service.dao.GenericDao#delete(java.lang.Object)
 */
public void delete(TtransientObject) {
getHibernateTemplate().delete(transientObject);
}

/**/ /* (non-Javadoc)
*@seecom.gdnfha.atcs.common.service.dao.GenericDao#read(java.io.Serializable)
 */
public Tread(PKid) {
 return (T)getHibernateTemplate().get(type,id);
}

/**/ /* (non-Javadoc)
*@seecom.gdnfha.atcs.common.service.dao.GenericDao#update(java.lang.Object)
 */
public void update(TtransientObject) {
getHibernateTemplate().update(transientObject);
}

public List T > executeFinder(Methodmethod, final Object[]queryArgs)
 {
 final QuerynamedQuery = prepareQuery(method,queryArgs);
 return (List T > )namedQuery.list();
}

public Iterator T > iterateFinder(Methodmethod, final Object[]queryArgs)
 {
 final QuerynamedQuery = prepareQuery(method,queryArgs);
 return (Iterator T > )namedQuery.iterate();
}

private QueryprepareQuery(Methodmethod,Object[]queryArgs)
 {
 final StringqueryName = getNamingStrategy().queryNameFromMethod(type,method);
 final QuerynamedQuery = getSession().getNamedQuery(queryName);
String[]namedParameters = namedQuery.getNamedParameters();
 if (namedParameters.length == 0 )
 {
setPositionalParams(queryArgs,namedQuery);
} else {
setNamedParams(namedParameters,queryArgs,namedQuery);
}
return namedQuery;
}

private void setPositionalParams(Object[]queryArgs,QuerynamedQuery)
 {
 // Setparameter.UsecustomHibernateTypeifnecessary
if (queryArgs != null )
 {
 for ( int i = 0 ;i queryArgs.length;i ++ )
 {
Objectarg = queryArgs[i];
TypeargType = getArgumentTypeFactory().getArgumentType(arg);
 if (argType != null )
 {
namedQuery.setParameter(i,arg,argType);
}
else
{
namedQuery.setParameter(i,arg);
}
}
}
}

private void setNamedParams(String[]namedParameters,Object[]queryArgs,QuerynamedQuery)
 {
 // Setparameter.UsecustomHibernateTypeifnecessary
if (queryArgs != null )
 {
 for ( int i = 0 ;i queryArgs.length;i ++ )
 {
Objectarg = queryArgs[i];
TypeargType = getArgumentTypeFactory().getArgumentType(arg);
 if (argType != null )
 {
namedQuery.setParameter(namedParameters[i],arg,argType);
}
else
{
 if (arg instanceof Collection) {
namedQuery.setParameterList(namedParameters[i],(Collection)arg);
}
else
{
namedQuery.setParameter(namedParameters[i],arg);
}
}
}
}
}

public FinderNamingStrategygetNamingStrategy()
 {
 return namingStrategy;
}

public void setNamingStrategy(FinderNamingStrategynamingStrategy)
 {
 this .namingStrategy = namingStrategy;
}

public FinderArgumentTypeFactorygetArgumentTypeFactory()
 {
 return argumentTypeFactory;
}

public void setArgumentTypeFactory(FinderArgumentTypeFactoryargumentTypeFactory)
 {
 this .argumentTypeFactory = argumentTypeFactory;
}

}


FinderNamingStrategy 是查找方法的命名规范：

public interface FinderNamingStrategy
 {
 public StringqueryNameFromMethod(ClassfindTargetType,MethodfinderMethod);
}


目前有两个命名查找策略，使用的是

Simple 的，也就是直接是 类型名 >. 方法名 > 的形式。

public class SimpleFinderNamingStrategy implements FinderNamingStrategy
 {
 public StringqueryNameFromMethod(ClassfindTargetType,MethodfinderMethod)
</spa
分享到：
| Appfuse2再论
评论
发表评论

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

相关推荐

    泛型dao 泛型dao 泛型dao

    Struts2、Hibernate、Spring整合的泛型DAO （本人评价: 代码开发效率提高30% 代码出错率减少70%） 对于大多数开发人员，系统中的每个 DAO 编写几乎相同的代码到目前为止已经成为一种习惯。虽然所有人都将这种重复...

    泛型dao

    在Java编程语言中，"泛型DAO"（Generic DAO）是一种设计模式，它允许开发者创建可重用的数据访问对象（DAOs），以处理多种不同类型的实体对象，而无需为每种对象编写单独的DAO实现。这种方法提高了代码的复用性和可...

    一个很好的通用泛型dao（含源码）

    而泛型DAO是一个类型安全的，代码精简的设计模式（相对于传统DAO），尤其在DAO组件数量庞大的时候，代码量的减少更加明显。 泛型DAO的核心是定义一个GenericDao接口，声明基本的CRUD操作： 用hibernate作为持久化...

    ssh通用泛型DAO

    总的来说，"ssh通用泛型DAO"是一种设计模式，旨在简化SSH框架下的数据访问层开发，提高代码复用性，减少重复工作，同时通过泛型提供类型安全的保障。理解和熟练运用这一模式，能够有效地提升Java Web应用的开发效率...

    hibernate不是泛型的通用DAo1

    例如，一个泛型DAO接口可能定义如下： ```java public interface GenericDao&lt;T&gt; { void save(T entity); T get(Long id); void update(T entity); void delete(T entity); } ``` 然后，对于一个名为`User`的实体...

    Hibernate泛型Dao

    【内容】在使用Hibernate泛型Dao时，首先需要定义一个基类，比如`AbstractGenericDao&lt;T&gt;`，其中T代表泛型类型，对应你要操作的实体类。这个基类会包含一些通用的CRUD（Create, Read, Update, Delete）方法，如`save...

    Hibernate泛型DAO（结合spring模板支持）

    首先，我们需要创建一个泛型DAO接口，如`GenericDao&lt;T&gt;`，其中`T`代表任意实体类类型。接口中包含增删改查等基本操作： ```java public interface GenericDao&lt;T&gt; { void save(T entity); void update(T entity); ...

    泛型通用DAO，可以很简化DAO层的代码

    例如，我们可以有如下的泛型DAO接口： ```java public interface GenericDao&lt;T&gt; { void save(T entity); T get(Class&lt;T&gt; clazz, int id); void update(T entity); void delete(int id); } ``` 然后，对于特定...

    泛型DAO，注释详细

    泛型DAO（Generic DAO）是DAO模式的一个扩展，它引入了泛型的概念，提高了代码的复用性和类型安全性。本篇文章将深入探讨泛型DAO的实现原理、优势以及如何在实际项目中应用。 首先，我们来理解什么是泛型。泛型是...

    JdbcTemplate通用泛型Dao实现

    本文将深入探讨`JdbcTemplate`通用泛型Dao实现的相关知识点，帮助开发者更好地理解和应用这一技术。 首先，让我们了解什么是`JdbcTemplate`。它是Spring框架的一部分，用于处理SQL操作。`JdbcTemplate`提供了一组...

    大家看看我设计的泛型DAO（使用Spring的Anotation和Hibernate）

    `UserDaoImpl`通过使用泛型DAO提供的通用功能，可以避免重复编写相同的数据库操作代码。 例如，`UserDao`接口可能包含以下方法： 1. `getUserById(Long id)`：根据用户ID获取用户信息。 2. `findUsersByUserName...

    S2SH整合例子 注解配置 JSON 泛型Dao

    6. **泛型Dao**：在Java开发中，泛型Dao（Generic Dao）是一种设计模式，用于减少重复的数据库操作代码。通过定义一个通用的Dao接口，可以实现对不同类型的实体对象进行CRUD操作，提高了代码的复用性和可维护性。...

    spring hibernate 泛型DAO

    本文将深入探讨“Spring Hibernate 泛型DAO”这一主题，以及如何通过泛型DAO实现更加高效、可复用的代码。 首先，让我们理解什么是DAO（Data Access Object）模式。DAO是一种设计模式，它的主要作用是隔离业务逻辑...

    ssh2 + dao泛型

    DAO泛型是Spring框架中一个重要的优化手段，它允许我们在编写DAO层代码时使用泛型，以提高代码的复用性和类型安全性。通过定义泛型接口或抽象类，我们可以创建一个通用的DAO模板，将具体的数据库操作与实体类的类型...

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

    泛型DAO是DAO模式的一种改进，它引入了Java的泛型特性，使得DAO接口或实现类可以支持多种类型的实体类。这大大提高了代码的复用性，减少了重复的代码编写。例如，我们有以下一个简单的泛型DAO接口： ```java public...

    ssh通用基于泛型的dao

    1. `GenericDAO.java`：泛型DAO接口，定义了基本的CRUD方法。 2. `HibernateGenericDAO.java`：实现了`GenericDAO`接口的具体类，使用Hibernate作为底层的数据访问技术。 3. `BaseDAO.java`：可能是一个抽象类，包含...

    SSH泛型代码实例

    - `DAO(1).rar`可能包含使用泛型的DAO设计模式示例，展示了如何创建泛型DAO以处理不同类型的数据对象。 综上所述，SSH框架结合泛型能够提升Java应用的开发效率和代码质量。通过学习和理解这些示例，开发者可以更好...

    泛型工具类

    在现代软件开发中，泛型作为一种强大的类型安全机制，被广泛应用于各种编程语言中，尤其是Java。泛型允许开发者编写灵活且可重用的代码，同时避免了运行时类型检查错误。在Java中，泛型工具类的构建对于实现通用功能...

    Java Web程序运用中泛型DAO的作用.pdf

    Java Web程序中泛型DAO（Data Access Object）模式的应用与作用主要体现在提高程序的运算性能、安全性以及系统架构的复用性、拓展性和可维护性上。泛型DAO模式是基于Java泛型技术的一种设计模式，它在数据访问层提供...

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