使用泛型类简化ibatis系统架构

最新推荐文章于 2024-11-10 21:51:21 发布
最新推荐文章于 2024-11-10 21:51:21 发布
阅读量98 收藏
点赞数
文章标签： 系统架构 数据库 java
原文链接：http://www.cnblogs.com/hd-zg/p/7883922.html
版权

jdk1.5的推出为我们带来了枚举、泛型、foreach循环、同步工具包等等好东西。其中，泛型的使用为我们的代码开发提供了很大的简便，简化了我们的代码。

1、设计思路

    1）GenericDao泛型类提供所有的增删改查功能；

    2）所有的dao在继承GenericDao泛型类拥有自身的增删改查功能，不需再写其他代码。

 

2、实现GenericDao，基类

public abstract class GenericDao<T, PK extends Serializable> {

protected final Logger logger = LoggerFactory.getLogger(getClass());

public static final String POSTFIX_SELECTBYID = ".selectById";
public static final String POSTFIX_SELECTBYIDS = ".selectByIds";
public static final String POSTFIX_SELECTBYMAP = ".selectByMap";
public static final String POSTFIX_SELECTIDSLIKEBYMAP = ".selectIdsLikeByMap";
public static final String POSTFIX_PKSELECTMAP = ".pkSelectByMap";
public static final String POSTFIX_COUNT = ".count";
public static final String POSTFIX_COUNTLIKEBYMAP = ".countLikeByMap";
public static final String POSTFIX_INSERT = ".insert";
public static final String POSTFIX_DELETEBYID = ".deleteById";
public static final String POSTFIX_DELETEBYIDS = ".deleteByIds";
public static final String POSTFIX_DELETEBYIDSMAP = ".deleteByIdsMap";
public static final String POSTFIX_DELETEBYMAP = ".deleteByMap";
public static final String POSTFIX_UPDATE = ".update";
public static final String POSTFIX_UPDATEBYMAP = ".updateByMap";
public static final String POSTFIX_UPDATEBYIDSMAP = ".updateByIdsMap";

protected Class<T> clazz;

protected String clazzName;

protected T t;

// 定义主从数据库服务器，主数据库负责（Write op），从数据库负责（read op）
@Autowired
protected SqlMapClientTemplate masterSqlMapClientTemplate;

@Autowired
protected SqlMapClientTemplate slaveSqlMapClientTemplate;

public GenericDao() {
      // 通过范型反射，取得在子类中定义的class.
      clazz = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
      clazzName = clazz.getSimpleName();
}

public Integer count(String propertyName, Object propertyValue) {
      return count(new String[]{propertyName},new Object[]{propertyValue});
}

public Integer count(String[] propertyNames, Object[] propertyValues) {

     Map<String, Object> map = new HashMap<String, Object>();
     for (int i = 0; i < propertyNames.length; i++) {
         map.put(propertyNames[i], propertyValues[i]);
     }
    return (Integer) slaveSqlMapClientTemplate.queryForObject(clazz.getName() + POSTFIX_COUNT, map);
}

@Override
public Integer countLikeByMap(String[] propertyNames, Object[] propertyValues) {
         Map<String, Object> map = new HashMap<String, Object>();
        for (int i = 0; i < propertyNames.length; i++) {
             map.put(propertyNames[i], propertyValues[i]);
        }
        return (Integer) slaveSqlMapClientTemplate.queryForObject(clazz.getName() + POSTFIX_COUNTLIKEBYMAP, map);
}

/** 根据自定义SqlMap中的条件语句查询出记录数量 */
public Integer countByStatementPostfix(String statementPostfix,String[] properties, Object[] propertyValues){
      Map<String, Object> map = new HashMap<String, Object>();
      for (int i = 0; i < properties.length; i++) {
          map.put(properties[i], propertyValues[i]);
      }
      return (Integer) slaveSqlMapClientTemplate.queryForObject(clazz.getName() + statementPostfix, map);
}
/**
* 通过id得到实体对象
*/
public T findById(PK id) {
       return (T) slaveSqlMapClientTemplate.queryForObject(clazz.getName() + POSTFIX_SELECTBYID, id);

}

/**
* 根据ids获取实体列表
*
* @param ids
* @return
*/
public List<T> findByIds(List<PK> ids) {
       return (List<T>) slaveSqlMapClientTemplate.queryForList(clazz.getName() + POSTFIX_SELECTBYIDS, ids);
}

/**
* 直接从数据库查询出ids列表（包括符合条件的所有id）
*
* @param properties
* 查询条件字段名
* @param propertyValues
* 字段取值
* @return
*/
public List<PK> findIdsBy(String[] properties, Object[] propertyValues, String orderBy, String order) {
        Map<String, Object> map = new HashMap<String, Object>();
        for (int i = 0; i < properties.length; i++) {
            map.put(properties[i], propertyValues[i]);
        }
        if (orderBy != null) {
            map.put("orderBy", orderBy);
            map.put("order", order);
         }
        return (List<PK>) slaveSqlMapClientTemplate.queryForList(clazz.getName() + POSTFIX_PKSELECTMAP, map);
}

/**
* 根据条件查询结果
*
* @param properties
* 查询条件名
* @param propertyValues
* 查询条件值
* @return
*/
public List<T> findByMap(String[] properties, Object[] propertyValues, String orderBy, String order) {
         return (List<T>) slaveSqlMapClientTemplate.queryForList(clazz.getName() + POSTFIX_SELECTBYMAP, map);
}

/**
* 根据条件查询结果的id列表
*
* @param properties
* 查询条件名
* @param propertyValues
* 查询条件值
* @return
*/
public List<PK> findIdsByMap(String[] properties, Object[] propertyValues, String orderBy, String order) {
         Map<String, Object> map = new HashMap<String, Object>();
         for (int i = 0; i < properties.length; i++) {
                map.put(properties[i], propertyValues[i]);
         }
         if (orderBy != null) {
              map.put("orderBy", orderBy);
              map.put("order", order);
          }
           return (List<PK>) slaveSqlMapClientTemplate.queryForList(clazz.getName() + POSTFIX_PKSELECTMAP, map);
}

/**
* 分页查询（未处理缓存）
*
* @param properties
* 查询条件字段名
* @param propertyValues
* 字段取值
* @return
*/
public List<T> pageQueryBy(String[] properties, Object[] propertyValues, String orderBy, String order, int pageSize, int pageNo) {
        Map<String, Object> map = new HashMap<String, Object>();
         for (int i = 0; i < properties.length; i++) {
              map.put(properties[i], propertyValues[i]);
        }
         if (orderBy != null) {
                 map.put("orderBy", orderBy);
                 map.put("order", order);
         }
         map.put("limit", true);
         map.put("start", (pageNo - 1) * pageSize );// limit 操作
         map.put("end", pageSize);
         return (List<T>) slaveSqlMapClientTemplate.queryForList(clazz.getName() + POSTFIX_SELECTBYMAP, map);
}

/**
* 从数据库分页查询出ids列表的前200个id
*
* @param properties
* 查询条件字段名
* @param propertyValues
* 字段取值
* @return
*/
protected List<PK> pageQueryIdsBy(String[] properties, Object[] propertyValues, String orderBy, String order) {
       Map<String, Object> map = new HashMap<String, Object>();
       for (int i = 0; i < properties.length; i++) {
                 map.put(properties[i], propertyValues[i]);
        }
        if (orderBy != null) {
            map.put("orderBy", orderBy);
            map.put("order", order);
        }
        map.put("limit", true);
         map.put("start", 0);// 操作
         map.put("end", Config.getInstance().getPageCacheSize());
         return (List<PK>) slaveSqlMapClientTemplate.queryForList(clazz.getName() + POSTFIX_PKSELECTMAP, map);

}

/**
* 分页查询出id列表（处理缓存）
*
* @param properties
* 查询条件字段名
* @param propertyValues
* 字段取值
* @return
*/
public List<PK> pageQueryIdsByMap(String[] properties, Object[] propertyValues, String orderBy, String order, int pageSize, int pageNo) {
        Map<String, Object> map = new HashMap<String, Object>();
        for (int i = 0; i < properties.length; i++) {
              map.put(properties[i], propertyValues[i]);
        }
         if (orderBy != null) {
             map.put("orderBy", orderBy);
             map.put("order", order);
         }
         map.put("limit", true);
         map.put("start", (pageNo - 1) * pageSize );// limit 操作
         map.put("end", pageSize);
         return (List<PK>) slaveSqlMapClientTemplate.queryForList(clazz.getName() + POSTFIX_PKSELECTMAP, map);
}

/** like分页查询(不走列表缓存) */
public List<T> pageLikeBy(String[] properties, Object[] propertyValues, String orderBy, String order, int pageSize, int pageNo){
      Map<String, Object> map = new HashMap<String, Object>();
        for (int i = 0; i < properties.length; i++) {
             map.put(properties[i], propertyValues[i]);
        }
       if (orderBy != null) {
             map.put("orderBy", orderBy);
              map.put("order", order);
        }
        map.put("limit", true);
        map.put("start", (pageNo - 1) * pageSize );// limit 操作
        map.put("end", pageSize);
        List<PK> ids = (List<PK>) slaveSqlMapClientTemplate.queryForList(clazz.getName() + POSTFIX_SELECTIDSLIKEBYMAP, map);
        return findByIds(ids);
}

/**
* 新增对象
*/
public Serializable insert(T o) throws Exception {
       if (t instanceof QueryCachable) {
           // 清除受影响的缓存
           clearListCache(o);
        }
        return (Serializable) masterSqlMapClientTemplate.insert(clazz.getName() + POSTFIX_INSERT, o);
}


/**
* 更新对象
*/
public T update(T o) throws Exception {
      masterSqlMapClientTemplate.update(clazz.getName() + POSTFIX_UPDATE, o);
       return o;
}

/**
* 更新对象的部分属性
*/
public int update(PK id, String[] properties, Object[] propertyValues) throws Exception {
    // 更新数据库
     Map<String, Object> map = new HashMap<String, Object>();
     for (int i = 0; i < properties.length; i++) {
          map.put(properties[i], propertyValues[i]);
     }
      map.put("id", id);
       return masterSqlMapClientTemplate.update(clazz.getName() + POSTFIX_UPDATEBYMAP, map);
}

/**
* 根据ID列表更新对象的部分属性
*/
public int updateByIdsMap(List<PK> ids,String[] properties, Object[] propertyValues) throws Exception{
      // 更新数据库
       Map<String, Object> map = new HashMap<String, Object>();
       for (int i = 0; i < properties.length; i++) {
            map.put(properties[i], propertyValues[i]);
        }
        map.put("ids", ids);
        return masterSqlMapClientTemplate.update(clazz.getName() + POSTFIX_UPDATEBYIDSMAP, map);
}

/**
* 根据ID删除对象
*/
public void deleteById(PK id) throws Exception {
         masterSqlMapClientTemplate.delete(clazz.getName() + POSTFIX_DELETEBYID, id);
}

/**
* 根据ID删除对象
*/
public void deleteByIds(List<PK> ids) throws Exception {
          masterSqlMapClientTemplate.delete(clazz.getName() + POSTFIX_DELETEBYIDS, ids);
}

/** 根据ID及条件删除对象 */
public void deleteByIdsMap(List<PK> ids, String[] properties, Object[] propertyValues) throws Exception {
         Map<String, Object> map = new HashMap<String, Object>();
         for (int i = 0; i < properties.length; i++) {
                map.put(properties[i], propertyValues[i]);
         }
         map.put("ids", ids);
         masterSqlMapClientTemplate.delete(clazz.getName() + POSTFIX_DELETEBYIDSMAP, map);
}

/**
* 根据条件删除对象
*/
public int deleteByMap(String[] properties, Object[] propertyValues) throws Exception {

        Map<String, Object> map = new HashMap<String, Object>();
        for (int i = 0; i < properties.length; i++) {
             map.put(properties[i], propertyValues[i]);
        }
        return masterSqlMapClientTemplate.delete(clazz.getName() + POSTFIX_DELETEBYMAP, map);
}

/**
* 根据自定义SqlMap中的条件语句查询出列表(注意：不处理缓存)
*/
public List<T> findByStatementPostfix(String statementPostfix, String[] properties, Object[] propertyValues, String orderBy, String order) {
      Map<String, Object> map = new HashMap<String, Object>();
      for (int i = 0; i < properties.length; i++) {
           map.put(properties[i], propertyValues[i]);
       }
       if (orderBy != null) {
            map.put("orderBy", orderBy);
            map.put("order", order);
       }
         return slaveSqlMapClientTemplate.queryForList(clazz.getName() + statementPostfix, map);
}

/**
* 根据自定义SqlMap中的条件语句查询出列表(注意：不处理缓存)
*/
public List<T> pageQueryByStatementPostfix(String statementPostfix, String[] properties, Object[] propertyValues, String orderBy, String order,int pageSize,int pageNo) {
       Map<String, Object> map = new HashMap<String, Object>();
       for (int i = 0; i < properties.length; i++) {
               map.put(properties[i], propertyValues[i]);
         }
        if (orderBy != null) {
            map.put("orderBy", orderBy);
            map.put("order", order);
         }
         map.put("limit", true);
         map.put("start", (pageNo - 1) * pageSize );// limit 操作
         map.put("end", pageSize);
         List<PK> ids = (List<PK>) slaveSqlMapClientTemplate.queryForList(clazz.getName() + statementPostfix, map);
         return findByIds(ids);
}

/**
* 根据自定义SqlMap中的条件语句更新数据（注意：不处理缓存）
*/
public void updateByStatementPostfix(String statementPostfix, String[] properties, Object[] propertyValues) {
      Map<String, Object> map = new HashMap<String, Object>();
      for (int i = 0; i < properties.length; i++) {
              map.put(properties[i], propertyValues[i]);
        }
        masterSqlMapClientTemplate.update(clazz.getName() + statementPostfix, map);
}

/**
* 根据自定义SqlMap中的条件语句删除数据（注意：不处理缓存）
*/
public void deleteByStatementPostfix(String statementPostfix, String[] properties, Object[] propertyValues) {
     Map<String, Object> map = new HashMap<String, Object>();
     for (int i = 0; i < properties.length; i++) {
          map.put(properties[i], propertyValues[i]);
      }
      masterSqlMapClientTemplate.delete(clazz.getName() + statementPostfix, map);
}

/**
* 根据自定义SqlMap中的条件语句插入数据（注意：不处理缓存）
*/
public void insertByStatementPostfix(String statementPostfix, String[] properties, Object[] propertyValues) {
        Map<String, Object> map = new HashMap<String, Object>();
        for (int i = 0; i < properties.length; i++) {
               map.put(properties[i], propertyValues[i]);
        }
          masterSqlMapClientTemplate.insert(clazz.getName() + statementPostfix, map);
    }

}

3、所有其他Dao只需继承GenericDao，传个具体的类型，不需再写增删改查的方法

package com.teacherclub.business.album.dao;

import org.springframework.stereotype.Repository;

import com.teacherclub.business.album.entity.Album;
import com.teacherclub.core.mem.MemcacheUtil;
import com.teacherclub.core.orm.EntityCachable;
import com.teacherclub.core.orm.dao.impl.GenericDao;

@Repository
public class AlbumDao extends GenericDao<Album,Integer> {  //传参数Album类

}

此泛型的实现，关键在于：clazz = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];

这在项目中经常使用。

 

转载于:https://www.cnblogs.com/hd-zg/p/7883922.html

ibatis与泛型
wanxiaotao12-126-com
01-20 178
http://mccxj.github.io/blog/20121130_ibatis-more-config.html
基于iBatis的通用持久层对象
04-21 2078
在说主题以前先介绍一下iBatis，http://ibatis.apache.org/：　　使用ibatis 提供的ORM机制，对业务逻辑实现人员而言，面对的是纯粹的Java对象， 这一层与通过Hibernate 实现ORM 而言基本一致，而对于具体的数据操作，Hibernate 会自动生成SQL 语句，而ibatis 则要求开发者编写具体的SQL 语句。相对Hibernate等 “全自动”O
ibatis实现的CRUD(持久层)
web开发自学
12-24 119
package persist; import entity.Account; public interface IAccountDAO { public void insert(Object object); public void delete(Object object); public void update(Object object); public...
C++设计模式--解释器模式
lihaidong的博客
08-28 221
解释器模式（Interpreter Pattern） 定义 给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。 AbstractExpression（抽象表达式）...
SPRING + STRUTS + IBATIS测试案例
12-30
JDK1.5的使用意味着这个案例可能包含一些泛型和枚举等新特性。 Struts2（这里可能是指Struts1，因为通常与Spring结合的是Struts1或Struts2）负责接收HTTP请求，通过配置Action-mappings将请求映射到具体的Action。...
30种java技术框架-方案架构图汇总.pdf
01-12
1. **Java类加载器架构**：Java类加载器负责在运行时将类文件加载到JVM中。它包括引导类加载器、扩展类加载器和应用程序类加载器，以及用户自定义的类加载器。理解这个架构有助于优化应用性能和实现动态加载。 2. *...
Struts2+Spring+Ibatis服务层DAO层通用化设计解析
- 编写DAO接口和实现，如IUserDao和UserDao，使用Ibatis的SqlSession执行SQL。 - 创建Action类，如LoginAction，调用UserService执行业务逻辑。 - 编写JSP页面，如login.jsp和index.jsp，展示视图。 5. 服务层和...
java技术架构.doc
06-13
- **Hibernate/iBATIS**：持久层框架，简化数据库操作。 这些知识点构成了Java技术架构的基础，对于理解和开发Java应用程序至关重要。随着技术的发展，新的框架和技术也在不断涌现，如Spring Boot、Spring Cloud等...
SpringBoot+Thymeleaf+iBatis开发项目
02-24 3879
maven该项目为maven项目，在我的一台电脑上配置好的项目copy到另一台电脑上，maven貌似需要重新下载maven依赖，maven项目必须联网吗？参考1：Maven installation and using in project without Internet conncetion，该文表示如果在offline状态下用本地的库使用maven，就背离了maven的原则，maven在原则下
springboot系类代码：springboot-mybatis-org.springframework.boot
BLOG域名:programb.blog.csdn.net
05-25 297
简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件易于学习，易于使用，通过文档和源代码，可以比较完全的掌握它的设计思路和实现。 灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。 sql写在xml里，便于统一管理和优化。通过sql语句可以满足操作数据库的所有需求。 解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。 提供映射标签，支持.
通过泛型实现持久层 BaseDao 的写法
李威威的博客
05-06 5519
通过泛型实现持久层 BaseDao 的写法问题说明：我们在编写 Dao 层的时候，总会遇到通用的增删改查方法，每一次都要写声明和实现是一件很繁琐的事情，而且代码有很多事相同点。于是我们想到了使用面向对象的三大特性和泛型语法来简化持久层的开发。Base 的实现类和接口都是抽象的，所以都带泛型。第 1 步：编写 BaseDao 接口 IBaseDao注意泛型。public interface IBase
dao持久层通用泛型接口模板
萌神30号 ↝
03-10 1533
我们在编写Dao层时，免不了会出现大量的重复性代码（增删改查）。这时如果有一个通用的模板来使用，我们就可以达到事半功倍的效果 一、原理说明 1. 编写持久层通用模板BaseDao<T>，编写增删改查方法 2. 编写模板实现类BaseDaoImpl<T>，实现接口方法 3. 编写用户持久层接口与实现类 4. 分别继承通用模板，实现方法 这样做的好处是： 1. ...
基于泛型实现的ibatis通用分页查询
weixin_33755847的博客
12-27 131
为什么80%的码农都做不了架构师？>>> ...
2024年11月10日系统架构设计师考试题目回顾
最新发布
诗酒趁年华
11-10 78
案例分析 试题一：质量属性 基于描述填空是什么质量属性，常规题。（性能，功能，安全，可用等等） 可用性而言，王工建议采用 ping/echo 机制检测，不过从资源使用角度，李工建议采用心跳机制。问 ping/echo 和 心跳机制的实现原理，心跳机制好在哪里？ （大致是这么回事吧，不太记得了） 试题二：系统设计 ES 的分词器，Standard,Simple, Whitespace, Keyword 介绍四个分词器。 Restful 风格如何实现前后端分离 试题三： 数据库 T1线程读数据，T2
【系统架构设计师】2024年下半年真题论文: 论面向服务的架构设计（包括解题思路和参考素材）
数据知道的博客
11-10 182
概念：面向服务的架构是一种分布式计算架构，它将企业的业务功能抽象为一系列相互独立、可复用的服务。这些服务通过明确定义的接口进行通信，并可以在不同的应用程序和系统中被调用。SOA 的核心思想是将业务逻辑从具体的技术实现中分离出来，以服务的形式对外提供，实现业务功能的灵活组合和复用。 特点： `松耦合性：`服务之间通过接口进行交互，彼此之间的依赖关系较弱。这种松耦合的特性使得服务可以独立开发、部署和更新，不会因为某个服务的变化而对其他服务产生重大影响。例如，在一个电商企业中，订单服务和库存服务是松耦合的，当订
系统架构设计师论文：论基于构件的软件开发方法及其应用
Programming Talk
11-08 137
从下列的4道试题(试题一至试题四) 中任选1道解答。请在答题纸上的指定位置处将所选择试题的题号框涂黑。若多涂或者未涂题号框，则对题号最小的一道试题进行评分。试题一 论基于构件的软件开发方法及其应用基于构作的软件开发 (Component-Based Software Development，CBSD) 是一种基于分布对象技术、强调通过可复用构件设计与构造软件系统的软件复用途径。
架构师备考-概念背诵（系统架构）
wend的博客
11-09 1034
本文总结了关于架构师备考-软件架构设计部分的内容
软考系统架构设计师论文：论面向对象的建模及应用
Programming Talk
11-08 449
用例模型是面向对象建模中的一种重要模型，它主要用于描述系统的功能需求，即用户与系统之间的交互行为。用例模型通常由用例图、用例描述和前置/后置条件等组成。通过用例模型，我们可以清晰地了解系统的功能边界和用户的期望行为。分析模型则是对用例模型的进一步细化，它主要用于描述系统的内部结构和行为。分析模型包括类图、对象图、状态图和顺序图等。通过分析模型，我们可以更深入地理解系统的业务逻辑和对象之间的关系，为后续的设计和实现工作提供基础。在“智能仓储管理系统”项目中，我们首先使用用例模型来描述系统的功能需求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值