ibatis dao模板

最新推荐文章于 2024-09-25 23:52:45 发布
最新推荐文章于 2024-09-25 23:52:45 发布
阅读量562 收藏
点赞数
分类专栏： Ibatis 文章标签： ibatis dao模板 spring管理 ssi 
import java.io.Serializable;
import java.util.List;

public interface EntityDAO<T> {
	 /**
	  * 根据主键查找对象
	  * 
	  * @param id
	  *            主键值
	  * @return 对象实体
	  */
	 T findByPrimarykey(Serializable id);
	 /**
	  * 新增对象到数据库
	  * 
	  * @param o
	  *            对象实体
	  */
	 void insert(T o);
	 /**
	  * 更新对象实体到数据库
	  * 
	  * @param o
	  *            对象实体
	  */
	 void update(T o);
	 /**
	  * 根据主键删除对象
	  * 
	  * @param id
	  *            主键值
	  */
	 void deleteByPrimarykey(Serializable id);
	 /**
	  * 更新对象信息
	  * 
	  * @param statementId
	  *            sql语句名称后缀
	  * @param parameters
	  *            sql参数
	  */
	 void update(String statementId, Object parameters);
	 /**
	  * sql查询单个对象
	  * 
	  * @param statementId
	  *            sql语句名称后缀
	  * @param parameters
	  *            sql参数
	  * @return 查询结果
	  */
	 T queryForObject(String statementId, Object parameters);
	 /**
	  * sql查询列表
	  * 
	  * @param statementId
	  *            sql语句名称后缀
	  * @param parameters
	  *            sql参数
	  * @return 查询结果
	  */
	 List<T> queryForList(String statementId, Object parameters);
}

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

import org.apache.commons.lang.StringUtils;



public class EntityDAOImpl<T> extends IbatisGenericDao implements EntityDAO<T> {

	 /**
	  * DAO所管理的Entity类型.
	  */
	 protected Class<T> entityClass;
	 protected String primaryKeyName;
	 /**
	  * 在构造函数中将泛型T.class赋给entityClass.
	  */
	 @SuppressWarnings("unchecked")
	 public EntityDAOImpl() {
	  entityClass = GenericsUtils.getSuperClassGenricType(getClass());
	 }
	 /**
	  * 根据ID获取对象.
	  */
	 public T findByPrimarykey(Serializable id) {
	  return get(getEntityClass(), id);
	 }
	 /**
	  * 取得entityClass. <p/> JDK1.4不支持泛型的子类可以抛开Class<T> entityClass,重载此函数达到相同效果。
	  */
	 protected Class<T> getEntityClass() {
	  return entityClass;
	 }
	 public String getIdName(Class clazz) {
	  return "id";
	 }
	 /**
	  * 分页查询.
	  */
	 public Page pagedQuery(Map parameterObject, int start, int limit) {
	  return pagedQuery(getEntityClass(), parameterObject, start, limit);
	 }
	 /**
	  * 分页查询.
	  */
	 public Page pagedQuery(Map parameterObject, int start, int limit,
	   String countSqlId, String pageQuerySqlId) {
	  if (StringUtils.isNotBlank(pageQuerySqlId))
	   return pagedQuery(getEntityClass(), parameterObject, start, limit,
	     countSqlId, pageQuerySqlId);
	  else {
	   return pagedQuery(getEntityClass(), parameterObject, start, limit);
	  }
	 }
	 /**
	  * 根据ID移除对象.
	  */
	 public void deleteByPrimarykey(Serializable id) {
	  removeById(getEntityClass(), id);
	 }
	 /**
	  * 根据ID移除对象.
	  */
	 public void delete(Class<?> entityClass,Object obj) {
		 super._delete(entityClass,obj);
	 }
	 /**
	  * 保存对象. 为了实现IEntityDao 我在内部使用了insert和upate 2个方法.
	  */
	 public void insert(T o) {
	  super._insert(o);
	 }
	 public void setPrimaryKeyName(String primaryKeyName) {
	  this.primaryKeyName = primaryKeyName;
	 }
	 
	 public List<T> queryForList(String statementId, Object parameters) {
	  return super.queryForList(getEntityClass(), statementId, parameters);
	 }
	 
	 public T queryForObject(String statementId, Object parameters) {
	  return super.queryForObject(getEntityClass(), statementId, parameters);
	 }
	 
	 public void update(String statementId, Object parameters) {
	  super.update(getEntityClass(), statementId, parameters);
	 }
	public void update(T o) {
		super._update(o);
	}
	
}

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class GenericsUtils {
	private static final Log log = LogFactory.getLog(GenericsUtils.class);
    private GenericsUtils() {
    }
   
    public static Class getSuperClassGenricType(Class clazz) {
        return getSuperClassGenricType(clazz, 0);
    }
 
    public static Class getSuperClassGenricType(Class clazz, int index) {
        Type genType = clazz.getGenericSuperclass();
        if (!(genType instanceof ParameterizedType)) {
            log.warn(clazz.getSimpleName() + "'s superclass not ParameterizedType");
            return Object.class;
        }
        Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
        if (index >= params.length || index < 0) {
            log.warn("Index: " + index + ", Size of " + clazz.getSimpleName() + "'s Parameterized Type: "
                    + params.length);
            return Object.class;
        }
        if (!(params[index] instanceof Class)) {
            log.warn(clazz.getSimpleName() + " not set the actual class on superclass generic parameter");
            return Object.class;
        }
        return (Class) params[index];
    }
}

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

import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;
import org.springframework.util.Assert;


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_GETALL = ".getAll";
	 public static final String POSTFIX_SELECTMAP = ".selectByMap";
	 public static final String POSTFIX_SELECTSQL = ".selectBySql";
	 public static final String POSTFIX_COUNT = ".count";
	 public static final String POSTFIX_QUERY = ".query";
	 /**
	  * 根据ID获取对象
	  */
	 public <T> T get(Class<T> entityClass, Serializable id) {
	  T o = (T) getSqlMapClientTemplate().queryForObject(
	    getStatementId(entityClass, IbatisGenericDao.POSTFIX_SELECT),
	    id);
	  return o;
	 }
	 /**
	  * 新增对象
	  */
	 public void _insert(Object o) {
	  getSqlMapClientTemplate().insert(
	    getStatementId(o.getClass(), IbatisGenericDao.POSTFIX_INSERT),
	    o);
	 }
	 /**
	  * 保存对象
	  */
	 public void _update(Object o) {
	  getSqlMapClientTemplate().update(
	    getStatementId(o.getClass(), IbatisGenericDao.POSTFIX_UPDATE),
	    o);
	 }
	 /**
	  * 删除对象
	  */
	 public <T> void _delete(Class<T> entityClass,Object o) {
		 getSqlMapClientTemplate().delete(
				 getStatementId(entityClass,
						 IbatisGenericDao.POSTFIX_DELETE), o);
	 }
	 /**
	  * 根据ID删除对象
	  */
	 public <T> void removeById(Class<T> entityClass, Serializable id) {
	  getSqlMapClientTemplate().delete(
	    getStatementId(entityClass,
	      IbatisGenericDao.POSTFIX_DELETE_PRIAMARYKEY), id);
	 }
	 
	 /**
	  * 分页查询函数，使用PaginatedList.
	  * 
	  * @param start
	     *@param limit @return 含17117717记录数和当前页数据的Page对象.
	  */
	 public Page pagedQuery(Class entityClass, Map parameterObject, int start,
	   int limit) {
	  Assert.isTrue(start >= 0, "pageNo should start from 0");
	  // 计算总数 
	  Integer totalCount = (Integer) getSqlMapClientTemplate()
	    .queryForObject(
	      getStatementId(entityClass,
	        IbatisGenericDao.POSTFIX_COUNT),
	      parameterObject);
	  // 如果没有数据则返回Empty Page
	  Assert.notNull(totalCount, "totalCount Error");
	  if (totalCount.intValue() == 0) {
	   return new Page();
	  }
	  List list;
	  int totalPageCount = 0;
	  int startIndex = 0;
	  // 如果pageSize小于0,则返回所有数捄1177,等同于getAll
	  if (limit > 0) {
	   // 计算页数
	   totalPageCount = (totalCount / limit);
	   totalPageCount += ((totalCount % limit) > 0) ? 1 : 0;
	   // 计算skip数量
	   if (totalCount > start) {
	    startIndex = start;
	   } else {
	    startIndex = (totalPageCount - 1) * limit;
	   }
	   if (parameterObject == null)
	    parameterObject = new HashMap();
	   parameterObject.put("startIndex", startIndex);
	   parameterObject.put("endIndex", limit);
	   list = getSqlMapClientTemplate()
	     .queryForList(
	       getStatementId(entityClass,
	         IbatisGenericDao.POSTFIX_QUERY),
	       parameterObject);
	  } else {
	   list = getSqlMapClientTemplate()
	     .queryForList(
	       getStatementId(entityClass,
	         IbatisGenericDao.POSTFIX_QUERY),
	       parameterObject);
	  }
	  return new Page(startIndex, totalCount, limit, list);
	 }
	 /**
	  * 分页查询函数，使用PaginatedList.
	  * 
	  * @param start
	     *@param limit @return 含17117717记录数和当前页数据的Page对象.
	  */
	 public Page pagedQuery(Class entityClass, Map parameterObject, int start,
	   int limit, String countSqlId, String pageQuerySqlId) {
	  Assert.isTrue(start >= 0, "pageNo should start from 0");
	  // 计算总数 
	  Integer totalCount = (Integer) getSqlMapClientTemplate()
	    .queryForObject(
	      getStatementId(entityClass,
	        countSqlId),
	      parameterObject);
	  // 如果没有数据则返回Empty Page
	  Assert.notNull(totalCount, "totalCount Error");
	  if (totalCount.intValue() == 0) {
	   return new Page();
	  }
	  List list;
	  int totalPageCount = 0;
	  int startIndex = 0;
	  // 如果pageSize小于0,则返回所有数捄1177,等同于getAll
	  if (limit > 0) {
	   // 计算页数
	   totalPageCount = (totalCount / limit);
	   totalPageCount += ((totalCount % limit) > 0) ? 1 : 0;
	   // 计算skip数量
	   if (totalCount >= start) {
	    startIndex = start;
	   } else {
	    startIndex = (totalPageCount - 1) * limit;
	   }
	   if (parameterObject == null)
	    parameterObject = new HashMap();
	   parameterObject.put("startIndex", startIndex);
	   parameterObject.put("endIndex",  limit);
	   list = getSqlMapClientTemplate()
	     .queryForList(
	       getStatementId(entityClass,
	         pageQuerySqlId),
	       parameterObject);
	  } else {
	   list = getSqlMapClientTemplate()
	     .queryForList(
	       getStatementId(entityClass,
	         pageQuerySqlId),
	       parameterObject);
	  }
	  return new Page(startIndex, totalCount, limit, list);
	 }
	 /**
	  * get statement id in SQL Map file
	  * 
	  * @param entityClass
	  *            entity class
	  * @param suffix
	  *            suffix
	  * @return statement id
	  */
	 private String getStatementId(Class entityClass, String suffix) {
	  String className = entityClass.getName();
	  String shortName = className.replace(entityClass.getPackage().getName()
	    + ".", "");
	  return shortName + suffix;
	 }
	 public <T> List<T> queryForList(Class<T> entityClass, String statementId,
	   Object parameters) {
	  return getSqlMapClientTemplate().queryForList(
	    getStatementId(entityClass, statementId), parameters);
	 }
	 public <T> T queryForObject(Class<T> entityClass, String statementId,
	   Object parameters) {
	  return (T) getSqlMapClientTemplate().queryForObject(
	    getStatementId(entityClass, statementId), parameters);
	 }
	 public void update(Class entityClass, String statementId, Object parameters) {
	  getSqlMapClientTemplate().update(
	    getStatementId(entityClass, statementId), parameters);
	 }

}

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

public class Page implements Serializable{
	public static int DEFAULT_PAGE_SIZE = 10;
	 private int pageSize = Page.DEFAULT_PAGE_SIZE; // 每页的记录数
	 private int start; // 当前页第一条数据在List中的位置,从0开始
	 private Collection data; // 当前页中存放的记录,类型一般为List
	 private int totalCount; // 总记录数
	 
	    /**
	  * 构造方法，只构造空页.
	  */
	 public Page() {
	  this(0, 0, Page.DEFAULT_PAGE_SIZE, new ArrayList());
	 }
	 /**
	  * 默认构造方法.
	  * 
	  * @param start
	  *            本页数据在数据库中的起始位置
	  * @param totalSize
	  *            数据库中总记录条数
	  * @param pageSize
	  *            本页容量
	  * @param data
	  *            本页包含的数据
	  */
	 public Page(int start, int totalSize, int pageSize, Collection data) {
	  this.pageSize = pageSize;
	  this.start = start;
	  totalCount = totalSize;
	  this.data = data;
	 }
	 /**
	  * 取总记录数.
	  */
	 public int getTotalCount() {
	  return totalCount;
	 }
	 /**
	  * 取总页数.
	  */
	 public int getTotalPageCount() {
	  if (totalCount % pageSize == 0)
	   return totalCount / pageSize;
	  else
	   return totalCount / pageSize + 1;
	 }
	 /**
	  * 取每页数据容量.
	  */
	 public int getPageSize() {
	  return pageSize;
	 }
	 /**
	  * 取当前页中的记录.
	  */
	 public Collection getResult() {
	  return data;
	 }
	 /**
	  * 取该页当前页码,页码从1开始.
	  */
	 public int getCurrentPageNo() {
	  return start / pageSize + 1;
	 }
	 /**
	  * 该页是否有下一页.
	  */
	 public boolean hasNextPage() {
	  return getCurrentPageNo() < getTotalPageCount() - 1;
	 }
	 /**
	  * 该页是否有上一页.
	  */
	 public boolean hasPreviousPage() {
	  return getCurrentPageNo() > 1;
	 }
	 /**
	  * 获取任一页第一条数据在数据集的位置，每页条数使用默认值.
	  * 
	  * @see #getStartOfPage(int,int)
	  */
	 protected static int getStartOfPage(int pageNo) {
	  return Page.getStartOfPage(pageNo, Page.DEFAULT_PAGE_SIZE);
	 }
	 /**
	  * 获取任一页第一条数据在数据集的位置.
	  * 
	  * @param pageNo
	  *            从1开始的页号
	  * @param pageSize
	  *            每页记录条数
	  * @return 该页第一条数据
	  */
	 public static int getStartOfPage(int pageNo, int pageSize) {
	  return (pageNo - 1) * pageSize;
	 }
	 
	 public int getCurrentPage() {
	  return this.getCurrentPageNo();
	 }
	 
	 public int getTotalPage() {
	  return this.getTotalPageCount();
	 }
	    public int getStart() { 
	  return this.start;
	 }
}




ChanggoCN
关注
专栏目录
iBatis 学习 之一 DAO部分
青之六号
12-07 3038
iBatis作者不喜欢在类前加详尽的说明，批评一下.首先看一下包 com.ibatis.dao.client 1 定义了一个声明式接口 Dao2 一个DaoManager接口，它有一个创建Dao实例的工厂方法:  public Dao getDao(Class type); 是为了将用户自己写的Dao接口与sqlMap实现类解藕,通过在dao.xml中指定二者的映射。   public Dao
生成ibatis Dao
01-23
本知识点主要聚焦于如何生成Ibatis的Dao（数据访问对象）类，以及相关的实体类（Entity）和SQL映射文件（sqlMap）。下面我们将详细介绍这个过程。 首先，Ibatis Dao的生成通常涉及到几个关键步骤： 1. **配置文件*...
ibatis SQL映射文件、DAO、model自动生成工具源码
03-18
ibatis SQL映射文件、DAO、model自动生成工具源码 1.没有注释，生成的代码非常简单，不像其他自动生成工具生成一大堆无用的东西 2.配置简单，只需配置表明，数据库连接，生成的路径即可
iBatis的Dao类
寂寞醉人君自饮，犹落西风花满心...
11-17 111
package com.ibatis.example; import java.io.Serializable; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; public class BaseDao extends ...
IBatis.Net学习笔记三--两种常用的DAO
weixin_34352449的博客
06-22 385
在ibatis中我们可以灵活的选择dao类型，也就是可以在底层选用不同的数据库操作方式。有常规方式、配置文件的方式、hibernet的方式等： 1、常规方式 和我们之前的ado.net开发较为类似，都是将sql语句写在cs代码中进行调用： 首先通过配置文件初始化： domdaomanagerbuilderbuilder=newdomdaomanagerb...
iBATIS DAO框架分析
10-22 5092
 为书写方便，本文采用如下简写约定：       Transaction：Tx       Manager：Mgr       Context：Ctx       Interface：Iface iBATIS DAO框架如图：  DAO的核心在于DaoManager，DaoManager的创建代码如下：          Reader reader = Resour
CodeSmith IBatis1.92模板
03-22
在本案例中，我们关注的是"CodeSmith IBatis1.92模板"，这表明它是一个专用于生成IBatis框架相关代码的模板。IBatis是一个流行的Java持久层框架，它提供了一种灵活的方式来映射SQL语句到Java对象，从而简化了数据库...
IBatis codesmith模板
01-14
`IBatis Codesmith` 的核心功能是通过模板引擎，根据用户定义的模板和数据库元数据，自动生成Java DAO（数据访问对象）层、实体类以及Mapper XML文件。这样，开发者无需手动编写重复的CRUD（创建、读取、更新、删除...
SpringMVC+ibatis模板项目
04-04
- 集成 MyBatis 或 iBatis，编写 SQL 映射文件和 DAO 接口。 7. **运行与调试** - 使用 IDE（如 IntelliJ IDEA 或 Eclipse）创建项目，导入所需库。 - 配置服务器（如 Tomcat），部署应用。 - 运行项目，通过...
strut2+spring+ibatis 的ation层，service层，dao层自动生成，简单易用
04-22
Struts2、Spring和iBatis是Java Web开发中常用的三大框架，它们分别负责MVC模式中的Action层、业务逻辑层（Service层）以及数据访问层（DAO层）。本项目提供的是一款工具，能够自动化生成这三层的代码，极大地提高了...
ibatis--dao的应用
03-05
博文链接：https://imticg.iteye.com/blog/217727
iBatis DAO入门与进阶
yangzl0123的专栏
07-05 1169
版权声明：任何获得Matrix授权的网站，转载时请务必以超链接形式标明文章原始出处和作者信息及本声明作者:Sunil Patil;rotter_pal原文地址:http://www.onjava.com/pub/a/onjava/2005/08/10/ibatisdao.html中文地址:http://www.matrix.org.cn/resource/article/44/44058_iBat
ibatis源码学习--ibatis-dao
蜗牛的轨迹
11-04 363
ibatis的包组成中从历史版本中我们能看到他是有：ibatis-dao.jar,ibatis-common.jar,ibatis-sqlmap.jar三个包组成，所以学习源码之前，我们先澄清一些东西，同时让大家弄清楚什么时候该引入什么包，一般情况下如果你的项目只是用到了ibatis，没有其他容器使用，那么你可以考虑使用ibatis-dao+ibatis-common+ibatis-sqlmap...
四、spring集成ibatis进行项目中dao层基类封装
aan3237的博客
08-25 423
　　Apache iBatis（现已迁至Google Code下发展，更名为MyBatis）是当前IT项目中使用很广泛的一个半自动ORM框架，区别于Hibernate之类的全自动框架，iBatis对数据库的操作拥有更加灵活的控制，对于那些经常需要调用本地数据库函数自定义SQL语句，或是喜欢自己优化SQL执行效率的开发者来说，iBatis是一个非常不错的选择。而得到广泛应用的开源企业架构S...
ibatis调用存储过程dao类案例
m0_38061183的博客
03-22 1280
try {try {try {try {}else{try {try {try {try {
【MyBatis】原始dao开发（iBatis时代）
最新发布
一根狗尾巴草的博客
09-25 537
iBatis是由Clinton Begin在2001年发起的开源项目，在2002年，iBatis项目被捐献给Apache软件基金会，这一举措极大地推动了iBatis在方法论、源码管理、社交、开源基础建设等方面的进步。例如，iBATIS 2.0版本在2004年发布，随后发布了多个更新版本，直到iBATIS 3.0的发布。2010年6月16日，MyBatis项目被正式归入Apache Attic，属性变为“只读”，这意味着该项目在iBatis时代正式结束。Mybatis的前身为iBatis。
解决ibatis Dao层实现类无法正常使用注解方式
huchen0907的专栏
10-16 941
package com.msun.mms.adapter;import javax.annotation.PostConstruct; import javax.annotation.Resource;import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;import com.ibatis.sqlmap.client
Spring DAO层设计：模板方法与异常处理
Spring的Dao层设计通过统一异常体系和模板方法模式，有效地解决了数据库访问的复杂性，提高了代码的可读性和可维护性，同时也降低了业务层与数据访问层之间的耦合度。这样的设计思路对于大型企业级应用的开发具有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值