`

mybatis泛型Dao参考二

阅读更多

IBatis通用DAO的封装

已有 521 次阅读2012-8-17 08:36 |个人分类:IBATIS| IBatisJava淘课江湖封装

IBatis一个基于Java的数据持久层框架, 是一种“半自动化”的ORM实现,ibatis 并不会为程序员在运行期自动生成 SQL 执行。具体的 SQL 需要程序员编写,然后通过映射配置文件,将SQL所需的参数,以及返回的结果字段映射到指定 POJO。
很多情况下在与java集成的过程中,一般会使用底层的数据操作接口来实现一些SQL操作,如在具体模块的DAO实现层:
@Resource(name = "sqlMapClient")
    private SqlMapClient sqlMapClient;//配置文件中加载后使用注解的方式获取数据库操作接口
 public Goods queryGoods(Map parameMap)
   throws SQLException {
  return (Goods)sqlMapClient.queryForObject("goodsSQLMap.queryGoodsDiscuss",parameMap);//此方法中的参数均与配置文件中对应
 }
以上是最直接的调用方法,简单明了,当然你也可以将其封装成通用的DAO,不用直接面对底层,封装如下(仅供参考):
/**
 * IBatis Dao的泛型基类,使用泛型后有比较好的通用性
 * 继承于Spring的SqlMapClientDaoSupport,提供分页函数和若干便捷查询方法,并对返回值作了泛型类型转换.
 */
@SuppressWarnings("unchecked")
public class IBatisGenericDao extends SqlMapClientDaoSupport {
 public static final String POSTFIX_INSERT = ".insert";
 public static final String POSTFIX_UPDATE = ".update";
 public static final String POSTFIX_DELETE = ".delete";
 public static final String POSTFIX_DELETE_PRIAMARYKEY = ".deleteByPrimaryKey";
 public static final String POSTFIX_SELECT = ".select";
 public static final String POSTFIX_SELECTMAP = ".selectByMap";
 public static final String POSTFIX_SELECTSQL = ".selectBySql";
 public static final String POSTFIX_COUNT = ".count";
 /**
  * 根据ID获取对象
  * 
  * @throws BaseException
  * @throws SQLException 
  */
 public <T> T get(Class<T> entityClass, Serializable id) throws BaseException, SQLException {
  T o = (T) getSqlMapClient().queryForObject(entityClass.getName() + POSTFIX_SELECT, id);
  if (o == null)
   throw new BaseException(BaseException.DATA_NOTFOUND, "未找到实体: " + id);
  return o;
 }
 /**
  * 获取全部对象
  * @throws SQLException 
  */
 public <T> List<T> getAll(Class<T> entityClass) throws SQLException {
  return getSqlMapClient().queryForList(entityClass.getName() + POSTFIX_SELECT, null);
 }
 /**
  * 新增对象
  * @throws SQLException 
  */
 public void insert(Object o) throws SQLException {
  getSqlMapClient().insert(o.getClass().getName() + POSTFIX_INSERT, o);
 }
 /**
  * 保存对象
  * @throws SQLException 
  */
 public int update(Object o) throws SQLException {
  return getSqlMapClient().update(o.getClass().getName() + POSTFIX_UPDATE, o);
 }
 /**
  * 删除对象
  * @throws SQLException 
  */
 public int remove(Object o) throws SQLException {
  return getSqlMapClient().delete(o.getClass().getName() + POSTFIX_DELETE, o);
 }
 /**
  * 根据ID删除对象
  * @throws SQLException 
  */
 public <T> int removeById(Class<T> entityClass, Serializable id) throws SQLException {
  return getSqlMapClient().delete(entityClass.getName() + POSTFIX_DELETE_PRIAMARYKEY, id);
 }
 /**
  * map查询.
  * 
  * @param map
  *            包含各种属性的查询
  * @throws SQLException 
  */
 public <T> List<T> find(Class<T> entityClass, Map<String, Object> map) throws SQLException {
  if (map == null)
   return this.getSqlMapClient().queryForList(entityClass.getName() + POSTFIX_SELECT, null);
  else {
   map.put("findBy", "True");
   return this.getSqlMapClient()
     .queryForList(entityClass.getName() + POSTFIX_SELECTMAP, map);
  }
 }
 /**
  * sql 查询.
  * 
  * @param sql
  *            直接sql的语句(需要防止注入式攻击)
  * @throws SQLException 
  */
 public <T> List<T> find(Class<T> entityClass, String sql) throws SQLException {
  Assert.hasText(sql);
  if (StringUtils.isEmpty(sql))
   return this.getSqlMapClient().queryForList(entityClass.getName() + POSTFIX_SELECT, null);
  else
   return this.getSqlMapClient()
     .queryForList(entityClass.getName() + POSTFIX_SELECTSQL, sql);
 }
 /**
  * 根据属性名和属性值查询对象.
  * 
  * @return 符合条件的对象列表
  * @throws SQLException 
  */
 public <T> List<T> findBy(Class<T> entityClass, String name, Object value) throws SQLException {
  Assert.hasText(name);
  Map<String, Object> map = new HashMap<String, Object>();
  map.put(name, value);
  return find(entityClass, map);
 }
 /**
  * 根据属性名和属性值查询对象.
  * 
  * @return 符合条件的唯一对象
  */
 public <T> T findUniqueBy(Class<T> entityClass, String name, Object value) {
  Assert.hasText(name);
  Map<String, Object> map = new HashMap<String, Object>();
  try {
   PropertyUtils.getProperty(entityClass.newInstance(), name);
   map.put(name, value);
   map.put("findUniqueBy", "True");
   return (T) getSqlMapClient().queryForObject(entityClass.getName() + POSTFIX_SELECTMAP,
     map);
  } catch (Exception e) {
   logger.error("Error when propertie on entity," + e.getMessage(), e.getCause());
   return null;
  }
 }
 /**
  * 根据属性名和属性值以Like AnyWhere方式查询对象.
  * @throws SQLException 
  */
 public <T> List<T> findByLike(Class<T> entityClass, String name, String value) throws SQLException {
  Assert.hasText(name);
  Map<String, Object> map = new HashMap<String, Object>();
  map.put(name, value);
  map.put("findLikeBy", "True");
  return getSqlMapClient().queryForList(entityClass.getName() + POSTFIX_SELECTMAP, map);
 }
 /**
  * 判断对象某些属性的值在数据库中不存在重复
  * 
  * @param tableName
  *            数据表名字
  * @param names
  *            在POJO里不能重复的属性列表,以逗号分割 如"name,loginid,password" <br>
  *            FIXME how about in different schema?
  */
 public boolean isNotUnique(Object entity, String tableName, String names) {
  try {
   String primarykey;
   Connection con = getSqlMapClient().getCurrentConnection();
   ResultSet dbMetaData = con.getMetaData().getPrimaryKeys(con.getCatalog(), null, tableName);
   dbMetaData.next();
   if (dbMetaData.getRow() > 0) {
    primarykey = dbMetaData.getString(4);
    if (names.indexOf(primarykey) > -1)
     return false;
   } else {
    return true;
   }
  } catch (SQLException e) {
   logger.error(e.getMessage(), e);
   return false;
  }
  return false;
 }
 /**
  * 分页查询函数,使用PaginatedList.
  * 
  * @param pageNo
  *            页号,从0开始.
  * @throws SQLException
  */
 @SuppressWarnings("rawtypes")
 public DataPage pagedQuery(String sqlName, HashMap<String, Object> hashMap, Integer pageNo, Integer pageSize)
   throws SQLException {
  if (pageNo == null || pageSize == null) {
   List list = getSqlMapClient().queryForList(sqlName, hashMap);
   if (list == null || list.size() == 0) {
    return new DataPage();
   } else {
    return new DataPage(0, list.size(), list.size(), list);
   }
  } else {
   Assert.hasText(sqlName);
   Assert.isTrue(pageNo >= 1, "pageNo should start from 1");
   // Count查询
   Integer totalCount = (Integer) getSqlMapClient().queryForObject(sqlName + ".Count", hashMap);
   if (totalCount < 1) {
    return new DataPage();
   }
   // 实际查询返回分页对象
   int startIndex = DataPage.getStartOfPage(pageNo, pageSize);
   hashMap.put("startIndex", startIndex);
   hashMap.put("pageSize", pageSize);
   List list = getSqlMapClient().queryForList(sqlName, hashMap);
   return new DataPage(startIndex, totalCount, pageSize, list);
  }
 }
 public String getMappedSQL(String sqlName) {
  String sql = null;
  SqlMapClientImpl sqlmap = (SqlMapClientImpl) getSqlMapClient();
  MappedStatement stmt = sqlmap.getMappedStatement(sqlName);
  StaticSql staticSql = (StaticSql) stmt.getSql();
  sql = staticSql.getSql(null, null);
  return sql;
 }
}
 
以上两种方式可根据项目的需求自由选择,但是需要注意的是,无论是哪种方式,都要将配置文件和dao具体实现中所需参数保持一致
分享到:
评论

相关推荐

    基于spring MVC 和 MyBatis 泛型的代码生成模板,可以根据自己的需求修改

    它利用Java的泛型特性实现了通用的DAO层,结合Spring MVC和MyBatis的灵活性,帮助开发者快速构建Web应用的后台逻辑。对于初学者而言,理解这两个框架的原理以及如何结合使用,是提升开发技能的关键步骤;对于有经验...

    泛型dao

    【泛型DAO】是一种在Java开发中常见的设计模式,它利用了Java泛型特性来提高代码的可重用性和类型安全性。在Java中,DAO(Data Access Object)模式是用来封装对数据库的操作,将业务逻辑与数据访问逻辑分离,使得...

    泛型DAO,注释详细

    接下来,我们可以使用Hibernate或MyBatis等持久层框架实现这个泛型DAO。以Hibernate为例,一个简单的实现可能如下: ```java public class HibernateGenericDAO, ID extends Serializable&gt; implements GenericDAO, ...

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

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

    Mybatis通用DAO设计封装(mybatis)

    Mybatis通用DAO设计封装主要涉及的是在Java开发中如何高效地使用Mybatis框架进行数据库操作。Mybatis是一款轻量级的持久层框架,它避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。通过提供自定义SQL、存储...

    ssh整合下的通用泛型DAO+分页

    在这个特定的讨论中,我们聚焦于SSH1中的一个关键概念:通用泛型DAO(Data Access Object)以及分页功能的实现。DAO层是模型层和数据访问层之间的桥梁,它的主要职责是处理数据库操作,为业务层提供无状态的数据访问...

    mybatis 通用DAO 简单实现

    - **泛型**:使用泛型可以确保DAO方法返回的对象与实体类类型一致,提高了代码的类型安全。 - **事务管理**:通用DAO通常不包含事务控制,需要在服务层(Service Layer)进行事务的开启、提交和回滚。 - **性能优化*...

    基于MAVEN的SpringMVC+Mybatis整合及dao、service强封装

    二、在封装上针对Mybatis进行Dao、service层封装,里面提供两种实现机制:一种采用注解泛型动态实现cud操作,目前查询还是有缺陷;另一种机制采用xml文件形式实现dao、service、controller层封装,具体业务类只需...

    泛型通用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); } ``` 然后,对于特定...

    ssh通用基于泛型的dao

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

    dao.rar_dao

    在实际应用中,我们可以为JXVA框架提供一个泛型DAO的实现,如`HibernateGenericDAO`或`MyBatisGenericDAO`,利用ORM(对象关系映射)工具如Hibernate或MyBatis进行数据库操作。这些实现类将处理与具体数据库系统的...

    ssh2 + dao泛型

    在SSH2框架中,我们可以利用Spring的JdbcTemplate或MyBatis等工具来实现DAO层的泛型化。这些工具提供了强大的SQL执行能力,与泛型结合可以大大减少代码量,避免了重复的模板代码。例如,我们可以定义一个泛型方法`...

    SSH泛型代码实例

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

    通用DAO

    1. **创建泛型DAO接口**:定义一个泛型接口,如`GenericDAO&lt;T&gt;`,其中T代表数据库实体类型。 2. **实现DAO接口**:在实现类中,使用反射获取实体类的字段信息,构造SQL语句。 3. **执行SQL操作**:使用JDBC或其他ORM...

    iBatis和MyBatis对比

    MyBatis不仅继承了iBatis的优点,还引入了更多的增强功能,如泛型和注解的支持,使得框架更加现代化和易于使用。MyBatis的出现意味着iBatis的升级,它不再仅仅是SQL映射框架,而是发展成一个更全面的ORM解决方案。 ...

    MyBatis中英文文档.tar.gz

    前者是MyBatis的官方中文用户指南,详细介绍了MyBatis的安装、配置、映射文件的编写、事务管理等内容,是学习和使用MyBatis的重要参考资料。后者则是iBatis的英文教程,对于理解iBatis的工作原理和对比MyBatis的新...

    Java反射泛型,实现数据库的动态增删改查等功能

    在动态数据库操作中,泛型可以用来创建通用的DAO(数据访问对象)接口和实现,以处理不同类型的实体对象。例如,我们可以定义一个`GenericDAO&lt;T&gt;`接口,其中`T`代表任何数据模型类。这个接口可以包含`insert(T ...

    mybatis 通用mapper

    2. **创建项目的基础Mapper(Dao)** 需要定义一个基础的Mapper接口,通常命名为`BaseMapper`或者类似的名称。这个接口需要继承自通用Mapper提供的`Mapper&lt;T&gt;`接口,其中`T`表示泛型,代表具体的实体类型。此外,还...

Global site tag (gtag.js) - Google Analytics