Spring+IBatis整合各层设计(I)

最新推荐文章于 2019-03-21 13:48:11 发布

岁寒松柏

最新推荐文章于 2019-03-21 13:48:11 发布

阅读量2.2k

点赞数

文章标签： ibatis spring string object integer autowired

针对Spring和IBatis的整合文章很多,鄙人自己搭建的框架,提供三层结构如下,以供学习之用,如用好的建议和意见以便沟通,希望大家一起学习,谢谢.

package easyway.tbs.app.dao.generics;

import java.io.Serializable;
import java.sql.SQLException;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import easyway.tbs.app.dao.ext.pagination.Pagination;
import easyway.tbs.app.model.PersistenceSupport;

/**
 * 泛型 DAO 的基础是其 CRUD 操作是数据访问层接口
 * @author longgangbai
 *
 * @param <T> 实现数据库接口的实体类
 * @param <PK>  实现数据库库接口的实体类的主键类型
 */
public interface GenericDAO<T extends PersistenceSupport, PK extends Serializable> {
	

	/**
	 * 保存对象
	 * @param sqlId
	 * @param entry
	 * @return
	 */
	public abstract void save(String sqlId, T entry) ;
	/**
	 * 保存对象集合
	 * @param sqlId
	 * @param coll
	 * @return
	 */
	public abstract void batchSave(String sqlId, Collection<T> coll) ;
   /**
    * 保存对行啊
    * @param sqlId 
    * @param entry
    * @return
    */
	public abstract void update(String sqlId, T entry) ;
	
   /**
    * 删除一个对象集合
    * @param sqlID
    * @param coll
    * @return
    */
	public abstract void delete(String sqlID, Collection<T> coll);
    /**
     * 删除所有对象
     * @param sqlId
     * @return
     */
	public abstract void delete(String sqlId);
    /**
     * 删除符合条件的对象
     * @param sqlId
     * @param object
     * @return
     */
	public abstract void delete(String sqlId,Object object);

	/**
	 * 根据封装的DTO对象查询对象
	 * @param sqlId
	 * @param entry 
	 * @return
	 */
	public abstract T queryForObject(String sqlId, Object entry);
   

	/**
	 * 根据一个对象查询匹配的对象
	 * @param sqlId
	 * @param entry
	 * @return
	 */
	public abstract List<T> queryForList(String sqlId, T entry);

	/**
	 * 根据一个对象查询匹配的对象
	 * @param sqlId
	 * @param entry
	 * @return
	 */
	public abstract List queryForList(String sqlID,Object param);
	
	/**
	 * 查询所有列表
	 * @param sqlID
	 * @return
	 */
	public abstract List<T> queryForList(String sqlID);

	/**
	 * 
	 * @param sqlId
	 * @param entry
	 * @param firstResult
	 * @param maxResults
	 * @return
	 */
	public List<T> queryForList(final String sqlId,final  T object,final  int firstResult,final  int maxResults);


	

	/**
	 * 分页查询
	 * @param itemSqlId
	 * @param countSqlId
	 * @param parameter
	 * @param skip
	 * @return
	 */
	public  abstract Pagination<T> queryForPaginatedList(String itemSqlId,String countSqlId, Object parameter, int skip)throws SQLException ;


	/**
	 * 分页查询的方法
	 * @param itemSqlId
	 * @param countSqlId
	 * @param parameter
	 * @param skip
	 * @param max
	 * @return
	 */
	public  abstract Pagination<T> queryForPaginatedList(String itemSqlId,String countSqlId, Object parameter, int skip, int max)throws SQLException;
		
	/**
	 * 分页使用
	 * @param statementName
	 * @param parameterObject
	 * @param skipResults
	 * @param maxResults
	 * @return
	 */
	public List<T> queryForList(final String statementName, final Object parameterObject, final int skipResults, final int maxResults);
	
	

	/**
	 * 查询总记录数
	 * 
	 * @param countSqlId
	 *            总页数sqlmap名称
	 * @param parameter
	 *            查询条件
	 * @return 总记录数
	 * @throws SQLException
	 */
	public abstract int queryForTotalResult(String countSqlId, Object parameter);
	
	/**
	 * 根据Map中查询信息查询信息列表
	 * @param sqlID
	 * @param param
	 * @return
	 */
	public List<T> queryForList(final String sqlID,final  Map<String ,Object> param) ;
	
	
	
	
	/**
	 * 
	 * @param sqlID
	 * @param param
	 * @param key
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public Map<String,Object> queryForMap(final String sqlID,final  Object param,final String key);
	/**
	 * 
	 * @param sqlID
	 * @param param
	 * @param key
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public List<Map<String,Object>> queryForList(final String sqlID,final  Object param,final String key);
	
}

package easyway.tbs.app.dao.generics;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;

import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.engine.execution.SqlExecutor;
import com.ibatis.sqlmap.engine.impl.ExtendedSqlMapClient;

import easyway.tbs.app.dao.ext.pagination.LimitSqlExecutor;
import easyway.tbs.commons.ReflectUtil;


/**
 * 通过重写DaoSupport类实现InitializingBean，在初始化的时候，调用afterPropertiesSet()同时调用initDao()
 * ,通过重写实现相关的调用
 * @author longgangbai
 *
 */
public class IBatisSqlMapDataAccessor extends SqlMapClientDaoSupport {

	
	private SqlExecutor sqlExecutor;
	
	
	/**
	 * 一次性注入以供多个类分享
	 * @param sqlMapClient
	 */
	@Autowired
    public void setExSqlMapClient(SqlMapClient sqlMapClient){
    	super.setSqlMapClient(sqlMapClient);
    }
    public SqlExecutor getSqlExecutor() {
        return sqlExecutor;
    }
    /**
     * 提供分页使用
     * @param sqlExecutor
     */
    @Autowired
    public void setSqlExecutor(SqlExecutor sqlExecutor) {
        this.sqlExecutor = sqlExecutor;
    }

    public void setEnableLimit(boolean enableLimit) {
        if (sqlExecutor instanceof LimitSqlExecutor) {
            ((LimitSqlExecutor) sqlExecutor).setEnableLimit(enableLimit);
        }
    }

    /**
     * 在类初始化时候调用此类的方法
     */
    @Override
    protected void initDao() throws Exception {
    	 super.initDao();
    	 //在初始化时候拦截注入方法
    	 initialize();
	}
    
    
    @SuppressWarnings("deprecation")
	public void initialize() throws Exception {
        if (sqlExecutor != null) {
            SqlMapClient sqlMapClient = getSqlMapClientTemplate()
                    .getSqlMapClient();
            if (sqlMapClient instanceof ExtendedSqlMapClient) {
                ReflectUtil.setFieldValue(((ExtendedSqlMapClient) sqlMapClient)
                        .getDelegate(), "sqlExecutor", SqlExecutor.class,
                        sqlExecutor);
            }
        }
    }


}

package easyway.tbs.app.dao.generics;

import java.io.Serializable;
import java.sql.SQLException;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import org.springframework.orm.ibatis.SqlMapClientCallback;

import com.ibatis.sqlmap.client.SqlMapExecutor;

import easyway.tbs.app.dao.ext.pagination.Pagination;
import easyway.tbs.app.model.PersistenceSupport;

/**
 * 底层数据持久化功能类
 * @author longgangbai
 *
 * @param <T>
 * @param <ID>
 */
public  class BaseIBatisGeneralDAO<T extends PersistenceSupport, ID extends Serializable> extends IBatisSqlMapDataAccessor  implements GenericDAO<T , ID > 
{
	/**
	 * 
	 */
	public void batchSave(final String sqlId,final  Collection<T> coll)  {
		getSqlMapClientTemplate().execute(new SqlMapClientCallback(){
			public Object doInSqlMapClient(SqlMapExecutor executor) throws SQLException {
				executor.startBatch();
				for (T entry: coll) {
					executor.insert(sqlId, entry);
				}
				return executor.executeBatch();
			}
		});
	}

	public void delete(final String sqlID,final  Collection<T> coll) {
		 getSqlMapClientTemplate().execute(new SqlMapClientCallback(){
			public Object doInSqlMapClient(SqlMapExecutor sqlmapexecutor) throws SQLException {
				sqlmapexecutor.startBatch();
				for (T entry : coll) {
					sqlmapexecutor.delete(sqlID, entry);
				}
				return sqlmapexecutor.executeBatch();
			}
		});
	}

    /**
     * 
     */
	public void delete(final String sqlId) {
		 getSqlMapClientTemplate().execute(new SqlMapClientCallback(){
				public Object doInSqlMapClient(SqlMapExecutor sqlmapexecutor) throws SQLException {
						return sqlmapexecutor.delete(sqlId);
				}
			});
	}

	/**
	 * 
	 */
	@SuppressWarnings("unchecked")
	public List<T> queryForList(final String sqlId,final  T entry)  {
		return (List<T>)getSqlMapClientTemplate().executeWithListResult(new SqlMapClientCallback(){

			public Object doInSqlMapClient(final SqlMapExecutor sqlmapexecutor) throws SQLException {
				return sqlmapexecutor.queryForList(sqlId, entry);
			}
		});
	}

    /**
     * 
     */
	@SuppressWarnings("unchecked")
	public List<T> queryForList(final String sqlID) {
		return (List<T>)getSqlMapClientTemplate().executeWithListResult(new SqlMapClientCallback(){
			public Object doInSqlMapClient(final SqlMapExecutor sqlmapexecutor) throws SQLException {
				return sqlmapexecutor.queryForList(sqlID);
			}
		});	
	}








	/**
	 * 查询总记录数
	 * 
	 * @param countSqlId
	 *            总页数sqlmap名称
	 * @param parameter
	 *            查询条件
	 * @return 总记录数
	 * @throws SQLException
	 */
	public int queryForTotalResult(final String SqlId,final  Object parameter)  {
		return  (Integer)getSqlMapClientTemplate().execute(new SqlMapClientCallback(){
			public Object doInSqlMapClient(final SqlMapExecutor sqlmapexecutor) throws SQLException {
				return sqlmapexecutor.queryForObject(SqlId,parameter);
			}
		});	
	}
 /*
  * (non-Javadoc)
  * @see easyway.tbs.app.dao.generics.GenericDAO#save(java.lang.String, easyway.tbs.app.model.PersistenceSupport)
  */
	public void save(final String sqlId,final  T entry)  {
		getSqlMapClientTemplate().execute(new SqlMapClientCallback(){
			public Object doInSqlMapClient(final SqlMapExecutor sqlmapexecutor) throws SQLException {
				return sqlmapexecutor.insert(sqlId, entry);
			}
		});	
		

		

	}
	
    /*
     * (non-Javadoc)
     * @see easyway.tbs.app.dao.generics.GenericDAO#update(java.lang.String, easyway.tbs.app.model.PersistenceSupport)
     */
	public void update(final String sqlId,final  T entry)  {
		
		getSqlMapClientTemplate().execute(new SqlMapClientCallback(){
			public Object doInSqlMapClient(final SqlMapExecutor sqlmapexecutor) throws SQLException {
				return sqlmapexecutor.update(sqlId, entry);
			}
		});	
	}

	/**
	 * 
	 */
	public void delete(final String sqlId,final  Object object) {
      this.getSqlMapClientTemplate().execute(new SqlMapClientCallback(){
		public Object doInSqlMapClient(SqlMapExecutor sqlmapexecutor) throws SQLException {
			return sqlmapexecutor.delete(sqlId, object);
		}
      });		
	}
    /**
     * 
     */
	@SuppressWarnings("unchecked")
	public List<T> queryForList(final String sqlId,final  Object entry,final  int firstResult,final  int maxResults) {
	   return  (List<T>)this.getSqlMapClientTemplate().executeWithListResult(new SqlMapClientCallback(){

		public Object doInSqlMapClient(SqlMapExecutor sqlmapexecutor) throws SQLException {
			 return sqlmapexecutor.queryForList(sqlId, entry, firstResult, maxResults);
		}
	   });
	}



    /**
     * 
     */
	@SuppressWarnings("unchecked")
	public T queryForObject(final String sqlId,final  Object param)  {
		return (T)this.getSqlMapClientTemplate().execute(new SqlMapClientCallback(){

			public Object doInSqlMapClient(SqlMapExecutor sqlmapexecutor) throws SQLException {
				return sqlmapexecutor.queryForObject(sqlId, param);
			}
			
		});
	}
    /**
     * 
     */
	public Pagination queryForPaginatedList(String itemSqlId,
			String countSqlId, Object parameter, int skip)throws SQLException {
		return queryForPaginatedList(itemSqlId, countSqlId, parameter, skip,
				Pagination.PAGESIZE);
	}

	/**
	 * 
	 */
	@SuppressWarnings({ "unchecked", "deprecation" })
	public Pagination queryForPaginatedList(String itemSqlId,
			String countSqlId, Object parameter, int skip, int max) throws SQLException {
	/*
		if (sqlMapClient instanceof ExtendedSqlMapClient) {
			LimitSqlExecutor limitSqlExecutor = new LimitSqlExecutor();
			limitSqlExecutor.setDialect(new OracleDialect());
			RefUtils.setFieldValue(((ExtendedSqlMapClient) sqlMapClient)
					.getDelegate(), "sqlExecutor", SqlExecutor.class,
					limitSqlExecutor);
		}
	 */
		try {
			// 偏移值
			int offset = (skip - 1) * max;
			// 数据项
			List listItem = getSqlMapClient().queryForList(itemSqlId, parameter,
					offset, max);
			// 总页数
			int totalResult = queryForTotalResult(countSqlId, parameter);
			return new Pagination(listItem, totalResult, offset, max);
		} catch (SQLException e) {
			throw new SQLException(e);
		}
	}

    /**
     * 
     */
	@SuppressWarnings("unchecked")
	public List queryForList(final String sqlId,final  T entry,final  int firstResult,final  int maxResults) {
		return (List<T>)this.getSqlMapClientTemplate().executeWithListResult(new SqlMapClientCallback(){

			public Object doInSqlMapClient(SqlMapExecutor sqlmapexecutor) throws SQLException {
				return sqlmapexecutor.queryForList(sqlId,entry,firstResult,maxResults);
			}
			
		});
	}
    /**
     * 
     */
	@SuppressWarnings("unchecked")
	public List<T> queryForList(final String sqlID,final  Object param) {
		return (List<T>)getSqlMapClientTemplate().executeWithListResult(new SqlMapClientCallback(){

			public Object doInSqlMapClient(final SqlMapExecutor sqlmapexecutor) throws SQLException {
				return sqlmapexecutor.queryForList(sqlID, param);
			}
			
		});
		
	}
	/**
	 * 
	 * @param sqlID
	 * @param param
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public List<T> queryForList(final String sqlID,final  Map<String ,Object> param) {
		return (List<T>)getSqlMapClientTemplate().executeWithListResult(new SqlMapClientCallback(){
			public Object doInSqlMapClient(SqlMapExecutor sqlmapexecutor) throws SQLException {
				return sqlmapexecutor.queryForList(sqlID, param);
			}
		});
	}
	
	@SuppressWarnings("unchecked")
	public Map<String,Object> queryForMap(final String sqlID,final  Object param,final String key) {
		return (Map<String,Object>)getSqlMapClientTemplate().executeWithMapResult(new SqlMapClientCallback(){
			public Object doInSqlMapClient(SqlMapExecutor sqlmapexecutor) throws SQLException {
				return sqlmapexecutor.queryForMap(sqlID, param, key);
			}
			
		});
	}
	
	@SuppressWarnings("unchecked")
	public List<Map<String,Object>> queryForList(final String sqlID,final  Object param,final String key) {
		return  getSqlMapClientTemplate().executeWithListResult(new SqlMapClientCallback(){

			public Object doInSqlMapClient(final SqlMapExecutor sqlmapexecutor) throws SQLException {
				return sqlmapexecutor.queryForMap(sqlID, param, key);
			}
		});
		
		
	}
	
}

package easyway.tbs.app.dao.ext.dialect;

/**
 * 
 * 
 * Mysql 分页查询方言
 * @author longgangbai
 *
 */

public class MySQLDialect implements Dialect {

    protected static final String SQL_END_DELIMITER = ";";

    public String getLimitString(String sql, boolean hasOffset) {
        return new StringBuffer(sql.length() + 20).append(trim(sql)).append(
                hasOffset ? " limit ?,?" : " limit ?")
                .append(SQL_END_DELIMITER).toString();
    }

    public String getLimitString(String sql, int offset, int limit) {
        sql = trim(sql);
        StringBuffer sb = new StringBuffer(sql.length() + 20);
        sb.append(sql);
        if (offset > 0) {
            sb.append(" limit ").append(offset).append(',').append(limit)
                    .append(SQL_END_DELIMITER);
        } else {
            sb.append(" limit ").append(limit).append(SQL_END_DELIMITER);
        }
        return sb.toString();
    }

    public boolean supportsLimit() {
        return true;
    }

    private String trim(String sql) {
        sql = sql.trim();
        if (sql.endsWith(SQL_END_DELIMITER)) {
            sql = sql.substring(0, sql.length() - 1
                    - SQL_END_DELIMITER.length());
        }
        return sql;
    }

    
	public boolean supportsLimitOffset() {
		return true;
	}

	
}

package easyway.tbs.app.dao.ext.pagination;


import java.sql.Connection;
import java.sql.SQLException;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.ibatis.sqlmap.engine.execution.SqlExecutor;
import com.ibatis.sqlmap.engine.mapping.statement.RowHandlerCallback;
import com.ibatis.sqlmap.engine.scope.StatementScope;

import easyway.tbs.app.dao.ext.dialect.Dialect;
/**
 * 其实只要在executeQuery执行前组装sql，然后将其传给executeQuery，并告诉handleResults
 *  我们不需要逻辑分页即可。拦截executeQuery可以采用aop动态实现，也可直接继承SqlExecutor覆盖
 *  executeQuery来静态 地实现，相比之下后者要简单许多，而且由于SqlExecutor没有实现任何接口
 *  ，比较易变，动态拦截反到增加了维护的工作量，所以我们下面来覆盖 executeQuery：
 *
 * @author longgangbai
 *
 */
@Component
public class LimitSqlExecutor extends SqlExecutor {
	
	private final Log logger = LogFactory.getLog(LimitSqlExecutor.class);

	private Dialect dialect;

	private boolean enableLimit = true;

	public Dialect getDialect() {
		return dialect;
	}
	
    @Autowired
	public void setDialect(Dialect dialect) {
		if (dialect != null) {
			logger.info("[iBATIS] 设置 ibatis LimitSqlExecutor.dialect ="+dialect.getClass().getName());			
		}
		this.dialect = dialect;
	}

	public boolean isEnableLimit() {
		return enableLimit;
	}

	public void setEnableLimit(boolean enableLimit) {
		this.enableLimit = enableLimit;
	}
	/**
	 * 
	 * 重新相关的方法
	 */
	@Override
	public void executeQuery(StatementScope request, Connection conn, String sql,
			Object[] parameters, int skipResults, int maxResults,
			RowHandlerCallback callback) throws SQLException {
		String limitSql = sql;
		int changedSkipResults = skipResults;
		int changedMaxResults = maxResults;
		if (supportsLimit()
				&& (skipResults != NO_SKIPPED_RESULTS || maxResults != NO_MAXIMUM_RESULTS)) {
			limitSql = limitSql.trim();
			if (dialect.supportsLimitOffset()) {
				limitSql = dialect.getLimitString(sql, skipResults, maxResults);
				changedSkipResults = NO_SKIPPED_RESULTS;
			} else {
				limitSql = dialect.getLimitString(sql, 0, maxResults);
			}
			changedMaxResults = NO_MAXIMUM_RESULTS;
		}
		super.executeQuery(request, conn, limitSql, parameters,
				changedSkipResults, changedMaxResults, callback);
	}

	public boolean supportsLimit() {
		if (enableLimit && dialect != null) {
			return dialect.supportsLimit();
		}
		return false;
	}

}

package easyway.tbs.app.dao.ext.pagination;


import java.io.Serializable;
import java.util.List;
/**
 * 分页辅助类
 * @author longgangbai
 *
 */
public class Pagination<T> implements Serializable {
	
	private static final long serialVersionUID = 30161819074846596L;

	/**
	 * 默认每页显示数
	 */
	public final static int PAGESIZE = 20;

	/**
	 * 每页显示数
	 */
	private int pageSize = PAGESIZE;

	/**
	 * 总记录数
	 */
	private int totalResult;

	/**
	 * 开始索引数
	 */
	private int startResult;

	/**
	 * 数组长度为总页数，数组每一维的数值表示每页开始索引数
	 */
	private int indexes;

	/**
	 * 显示项集合
	 */
	@SuppressWarnings("unchecked")
	private List<T> items;
	
	/**
	 * 总页数
	 */
	@SuppressWarnings("unused")
	private int totalCount;

	/**
	 * 
	 * @param items
	 *            显示项集合
	 * @param totalResult
	 *            总记录数
	 */
	public Pagination(List<T> items, int totalResult) {
		setPageSize(PAGESIZE);
		setTotalResult(totalResult);
		setStartResult(0);
		setItems(items);
	}

	/**
	 * 
	 * @param items
	 *            显示项集合
	 * @param totalResult
	 *            总记录数
	 * @param startResult
	 *            开始索引数
	 */
	public Pagination(List<T> items, int totalResult, int startResult) {
		setPageSize(PAGESIZE);
		setTotalResult(totalResult);
		setStartResult(startResult);
		setItems(items);
	}

	/**
	 * 
	 * @param items
	 *            显示项集合
	 * @param totalResult
	 *            总记录数
	 * @param startResult
	 *            开始索引数
	 * @param pageSize
	 *            每页显示数
	 */
	public Pagination(List<T> items, int totalResult, int startResult,
			int pageSize) {
		setPageSize(pageSize);
		setTotalResult(totalResult);
		setStartResult(startResult);
		setItems(items);
	}

	public int getPageSize() {
		return pageSize;
	}

	public void setPageSize(int pageSize) {
		this.pageSize = pageSize;
	}

	public int getTotalResult() {
		return totalResult;
	}

	/**
	 * 设置总页数indexes.length，总记录数totalResult，每页开始索引数(保存在数组每一维中)
	 * 
	 * @param totalResult 总记录数
	 */
	public void setTotalResult(int totalResult) {
		if (totalResult > 0) {
			this.totalResult = totalResult;
			int count = totalResult / pageSize;
			if (totalResult % pageSize > 0)
				count++;
			indexes = count;
		} else {
			this.totalResult = 0;
		}
	}

	public int getStartResult() {
		return startResult;
	}

	/**
	 * 设置显示页相应的开始索引数
	 * 
	 * @param startResult 开始索引数
	 */
	public void setStartResult(int startResult) {
		if (totalResult <= 0)
			this.startResult = 0;
		else if (startResult >= totalResult)
			this.startResult = indexes - 1;
		else if (startResult < 0)
			this.startResult = 0;
		else
			this.startResult = startResult / pageSize;
	}

	/**
	 * 获得下一页索引
	 * 
	 * @return 下一页索引
	 */
	public int getNextIndex() {
		int nextIndex = getStartResult() + pageSize;
		if (nextIndex >= totalResult)
			return getStartResult();
		else
			return nextIndex;
	}

	/**
	 * 获得上一页索引
	 * 
	 * @return 上一页索引
	 */
	public int getPreviousIndex() {
		int previousIndex = getStartResult() - pageSize;
		if (previousIndex < 0)
			return 0;
		else
			return previousIndex;
	}

	public int getIndexes() {
		return indexes;
	}

	public void setIndexes(int indexes) {
		this.indexes = indexes;
	}

	/**
	 * 获得分页数据
	 * 
	 * @return 分页集合
	 */
	public List<T> getItems() {
		return items;
	}

	public void setItems(List<T> items) {
		this.items = items;
	}

	public int getTotalCount() {
		return getIndexes();
	}

	public void setTotalCount(int totalCount) {
		this.totalCount = totalCount;
	}
	
	/*public static void main(String[] args) {
		PaginationSupport ps = new PaginationSupport(null, 90, 1, 10);
		System.out.println("总记录数：" + ps.getTotalResult());
		System.out.println("总共页数：" + ps.getIndexes().length);
		System.out.println("开始索引：" + ps.getStartResult());
		System.out.println("下一页索引：" + ps.getNextIndex());
		System.out.println("上一页索引：" + ps.getPreviousIndex());
		System.out.println("每页显示数：" + ps.getPageSize());
		for (int i = 0; i < ps.getIndexes().length; i++) {
			System.out.println("第" + (i + 1) + "页从" + ps.getIndexes()[i]
					+ "记录开始显示");
		}
	}*/
	
}

package easyway.tbs.app.dao.iface;


import easyway.tbs.app.dao.generics.GenericDAO;
import easyway.tbs.app.model.ChannelVo;

/**
 * 通道服务数据访问层的特殊方法需实现基本方法可以采用基类接口中的方法
 * 
 * @author longgangbai
 *
 */
public interface ChannelDAO extends GenericDAO<ChannelVo, Integer> {
}

package easyway.tbs.app.dao.imp;


import org.springframework.stereotype.Repository;

import easyway.tbs.app.dao.generics.BaseIBatisGeneralDAO;
import easyway.tbs.app.dao.iface.ChannelDAO;
import easyway.tbs.app.model.ChannelVo;

/**
 * 通道的数据访问层的实现类
 *    备注针对DAO层的数据库访问使用注解和@Repository实现相关的各种功能
 * @author longgangbai
 *
 */
@Repository
@SuppressWarnings("unchecked")
public class ChannelImplDao extends BaseIBatisGeneralDAO<ChannelVo,Integer> implements ChannelDAO{

	

}

package easyway.tbs.app.model;

import java.io.Serializable;


/**
 * 模型的基础类
 * @author longgangbai
 *
 */
public class PersistenceSupport implements Serializable {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	/**
	 * 对象的Id
	 */
	private Integer id;
	/**
	 * 创建时间
	 */
	private String createTime;
	
	public String getCreateTime() {
		return createTime;
	}

	public void setCreateTime(String createTime) {
		this.createTime = createTime;
	}

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	@Override
	public boolean equals(Object obj) {
		boolean superEquals = super.equals(obj);
		if (superEquals) {
			return true;
		}
		if (!(getClass().isAssignableFrom(obj.getClass()))) {
			return false;
		}
		if (getId() == null) {
			return false;
		}
		PersistenceSupport support = (PersistenceSupport) obj;
		if (support.getId() == null) {
			return false;
		}
		return getId().equals(support.getId());
	}

	@Override
	public int hashCode() {
		return super.hashCode();
	}
	
	

}

package easyway.tbs.app.model;

import org.apache.commons.lang.builder.ToStringBuilder;
import org.apache.commons.lang.builder.ToStringStyle;

/**
 * 通道类
 *    目的两个节点之间建立消息队列的通道
 * 
 * @author longgangbai
 *
 */
public class ChannelVo extends  PersistenceSupport{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	/**
	 * 通道编号
	 */
	private Integer channelId;
	/**
	 * 发送节点的名称
	 */
	private Integer sendNodeId;
	

	/**
	 * 发送的通道的名称
	 */
	private String  channelName;
	/**
	 * 是否压缩
	 */
	private Integer compress;
	/**
	 * 压缩的大小
	 */
	private Integer compressSize;
	/**
	 * 加密的方式
	 */
	private String encrypt;
	/**
	 * 尝试发送的次数
	 */
	private Integer tryTimes;
	/**
	 * 通道的备注信息
	 */
	private String notes;
	/**
	 * 通道的验证的用户名称
	 */
	private String userName;
	/**
	 * 通道的验证的用户密码
	 */
	private String password;
	


	public Integer getChannelId() {
		return channelId;
	}

	public void setChannelId(Integer channelId) {
		this.channelId = channelId;
	}

	public String getChannelName() {
		return channelName;
	}

	public void setChannelName(String channelName) {
		this.channelName = channelName;
	}

	public Integer getCompress() {
		return compress;
	}

	public void setCompress(Integer compress) {
		this.compress = compress;
	}

	public Integer getCompressSize() {
		return compressSize;
	}

	public void setCompressSize(Integer compressSize) {
		this.compressSize = compressSize;
	}

	public String getEncrypt() {
		return encrypt;
	}

	public void setEncrypt(String encrypt) {
		this.encrypt = encrypt;
	}

	public String getNotes() {
		return notes;
	}

	public void setNotes(String notes) {
		this.notes = notes;
	}




	public Integer getSendNodeId() {
		return sendNodeId;
	}

	public void setSendNodeId(Integer sendNodeId) {
		this.sendNodeId = sendNodeId;
	}

	public Integer getTryTimes() {
		return tryTimes;
	}

	public void setTryTimes(Integer tryTimes) {
		this.tryTimes = tryTimes;
	}



	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

	@Override
	public String toString(){
		return ToStringBuilder.reflectionToString(this, ToStringStyle.MULTI_LINE_STYLE);
	}
}

package easyway.tbs.app.service.generics;

import java.io.Serializable;
import java.sql.SQLException;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.InitializingBean;

import easyway.tbs.app.dao.ext.pagination.Pagination;
import easyway.tbs.app.dao.generics.GenericDAO;
import easyway.tbs.app.exceptions.ServiceInitializationException;
import easyway.tbs.app.model.PersistenceSupport;
/**
 * 业务逻辑访问的底层服务类
 * @author longgangbai
 *
 * @param <T>
 * @param <ID>
 * @param <M>
 */
public class BaseServiceImpl <T extends PersistenceSupport, ID extends Serializable, M extends GenericDAO<T, ID>> 
implements GenericService<T, ID>, InitializingBean {
	
	protected M entityDao;
	
	
	public void setEntityDao(M entityDao) {
		this.entityDao = entityDao;
	}
	/**
	 * 用于初始化类服务信息
	 */
	public final void afterPropertiesSet() throws Exception {
		try {
			initService();
		} catch (Exception e) {
			throw new ServiceInitializationException("Initialization of Service failed", e);
		}
	}

	/**
	 * 
	 */
	protected void initService() throws Exception {
	}
	public void batchSave(String sqlId, Collection<T> coll) {
		entityDao.batchSave(sqlId, coll);
	}
	public void delete(String sqlID, Collection<T> coll) {
		
		entityDao.delete(sqlID, coll);
	}
	public void delete(String sqlId) {
		entityDao.delete(sqlId);
		
	}
	public void delete(String sqlId, Object object) {
		entityDao.delete(sqlId, object);
		
	}
	public List<T> queryForList(String sqlId, T entry) {
		return entityDao.queryForList(sqlId, entry);
	}
	public List<T> queryForList(String sqlID) {
	   return entityDao.queryForList(sqlID);
	}
	
	@SuppressWarnings("unchecked")
	public List<T> queryForList(String sqlID,Object param) {
		   return entityDao.queryForList(sqlID,param);
    }
	public List<T> queryForList(String sqlId, T object, int firstResult, int maxResults) {
	    return entityDao.queryForList(sqlId, object, firstResult, maxResults);
	}
	public List<T> queryForList(String statementName, Object parameterObject, int skipResults, int maxResults) {
		 return entityDao.queryForList(statementName, parameterObject, skipResults, maxResults);
	}
	public T queryForObject(String sqlId, Object entry) {
		 return entityDao.queryForObject(sqlId, entry);
	}
	public Pagination<T> queryForPaginatedList(String itemSqlId, String countSqlId, Object parameter, int skip) throws SQLException {
		 return entityDao.queryForPaginatedList(itemSqlId, countSqlId, parameter, skip);
	}
	public Pagination<T> queryForPaginatedList(String itemSqlId, String countSqlId, Object parameter, int skip, int max) throws SQLException {
		 return entityDao.queryForPaginatedList(itemSqlId, countSqlId, parameter, skip, max);
	}
	public int queryForTotalResult(String countSqlId, Object parameter) {
		 return entityDao.queryForTotalResult(countSqlId, parameter);
	}
	public void save(String sqlId, T entry) {
		entityDao.save(sqlId, entry);
		
	}
	public void update(String sqlId, T entry) {
	   entityDao.update(sqlId, entry);
	}
	public List<T> queryForList(String sqlID, Map<String, Object> param) {
		return entityDao.queryForList(sqlID, param);
	}
	
	/**
	 * 
	 * @param sqlID
	 * @param param
	 * @param key
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public Map<String,Object> queryForMap(final String sqlID,final  Object param,final String key)
	{
		return entityDao.queryForMap(sqlID, param, key);
	}
	/**
	 * 
	 * @param sqlID
	 * @param param
	 * @param key
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public List<Map<String,Object>> queryForList(final String sqlID,final  Object param,final String key)
	{
		  return entityDao.queryForList(sqlID,param,key);
	}
	
}

package easyway.tbs.app.service.generics;

import java.io.Serializable;
import java.sql.SQLException;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import easyway.tbs.app.dao.ext.pagination.Pagination;
import easyway.tbs.app.model.PersistenceSupport;


/**
 * 业务逻辑层访问的基层接口类
 * @author longgangbai
 *
 * @param <T>
 * @param <ID>
 */
public interface GenericService<T extends PersistenceSupport, ID extends Serializable> {

	/**
	 * 保存对象
	 * @param sqlId
	 * @param entry
	 * @return
	 */
	public abstract void save(String sqlId, T entry) ;
	/**
	 * 保存对象集合
	 * @param sqlId
	 * @param coll
	 * @return
	 */
	public abstract void batchSave(String sqlId, Collection<T> coll) ;
   /**
    * 保存对行啊
    * @param sqlId 
    * @param entry
    * @return
    */
	public abstract void update(String sqlId, T entry) ;
	
   /**
    * 删除一个对象集合
    * @param sqlID
    * @param coll
    * @return
    */
	public abstract void delete(String sqlID, Collection<T> coll);
    /**
     * 删除所有对象
     * @param sqlId
     * @return
     */
	public abstract void delete(String sqlId);
    /**
     * 删除符合条件的对象
     * @param sqlId
     * @param object
     * @return
     */
	public abstract void delete(String sqlId,Object object);

	/**
	 * 根据封装的DTO对象查询对象
	 * @param sqlId
	 * @param entry 
	 * @return
	 */
	public abstract T queryForObject(String sqlId, Object entry);
   

	/**
	 * 根据一个对象查询匹配的对象
	 * @param sqlId
	 * @param entry
	 * @return
	 */
	public abstract List<T> queryForList(String sqlId, T entry);

	/**
	 * 根据一个对象查询匹配的对象
	 * @param sqlId
	 * @param entry
	 * @return
	 */
	public abstract List<T> queryForList(String sqlID,Object param);
	
	/**
	 * 查询所有列表
	 * @param sqlID
	 * @return
	 */
	public abstract List<T> queryForList(String sqlID);

	/**
	 * 
	 * @param sqlId
	 * @param entry
	 * @param firstResult
	 * @param maxResults
	 * @return
	 */
	public List<T> queryForList(final String sqlId,final  T object,final  int firstResult,final  int maxResults);


	

	/**
	 * 分页查询
	 * @param itemSqlId
	 * @param countSqlId
	 * @param parameter
	 * @param skip
	 * @return
	 */
	public  abstract Pagination<T> queryForPaginatedList(String itemSqlId,String countSqlId, Object parameter, int skip)throws SQLException ;


	/**
	 * 分页查询的方法
	 * @param itemSqlId
	 * @param countSqlId
	 * @param parameter
	 * @param skip
	 * @param max
	 * @return
	 */
	public  abstract Pagination<T> queryForPaginatedList(String itemSqlId,String countSqlId, Object parameter, int skip, int max)throws SQLException;
		
	/**
	 * 分页使用
	 * @param statementName
	 * @param parameterObject
	 * @param skipResults
	 * @param maxResults
	 * @return
	 */
	public List<T> queryForList(final String statementName, final Object parameterObject, final int skipResults, final int maxResults);
	
	

	/**
	 * 查询总记录数
	 * 
	 * @param countSqlId
	 *            总页数sqlmap名称
	 * @param parameter
	 *            查询条件
	 * @return 总记录数
	 * @throws SQLException
	 */
	public abstract int queryForTotalResult(String countSqlId, Object parameter);
	
	/**
	 * 根据Map中查询信息查询信息列表
	 * @param sqlID
	 * @param param
	 * @return
	 */
	public List<T> queryForList(final String sqlID,final  Map<String ,Object> param) ;
	
	
	/**
	 * 
	 * @param sqlID
	 * @param param
	 * @param key
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public Map<String,Object> queryForMap(final String sqlID,final  Object param,final String key);
	/**
	 * 
	 * @param sqlID
	 * @param param
	 * @param key
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public List<Map<String,Object>> queryForList(final String sqlID,final  Object param,final String key);
	
}

package easyway.tbs.app.service.iface;

import java.util.List;
import java.util.Map;

import org.springframework.transaction.annotation.Transactional;

import easyway.tbs.app.model.ChannelVo;
import easyway.tbs.app.service.generics.GenericService;
import easyway.tbs.file.transport.core.dto.FileChannel;

/**
 * 通道使用事务注解类的
 * @author longgangbai
 *
 */
@Transactional
public interface ChannelService  extends GenericService<ChannelVo, Integer>{
	/**
	 * 根据节点id查询相关的通道的列表
	 * @param nodeId  节点的ID
	 * @return
	 */
	public List<ChannelVo> getChannelListByNodeId(Map<String,Integer> paramsMap);

	/**
	 * 根据节点ip查询相关的通道的列表
	 * @param nodeIp  节点的ID
	 * @return
	 */
	public List<FileChannel> getChannelListByNodeIp(String nodeIp);
	
	
	/**
	 * 根据节点id查询相关的接收端通道信息
	 * @param nodeId  
	 * @return
	 */
	public List<ChannelVo> queryChannelListByRecNodeId(Integer nodeId);
}

package easyway.tbs.app.service.imp;

import java.util.List;
import java.util.Map;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import easyway.tbs.app.constants.IBatisSQLConstants;
import easyway.tbs.app.dao.iface.ChannelDAO;
import easyway.tbs.app.model.ChannelVo;
import easyway.tbs.app.service.generics.BaseServiceImpl;
import easyway.tbs.app.service.iface.ChannelService;
import easyway.tbs.file.transport.core.dto.FileChannel;

/**
 *通道服务的实现类
 *   备注：注意此处使用@Service和@Autowired 自动注入的功能实现
 *   
 * @author longgangbai
 *
 */
@Service
public class ChannelServiceImpl extends BaseServiceImpl<ChannelVo, Integer, ChannelDAO> implements ChannelService {
	private static Log log = LogFactory.getLog(ChannelServiceImpl.class);
	
	/**
	 * 注解通道的数据访问对象
	 */
	@Autowired
	@Override
	public void setEntityDao(ChannelDAO entityDao) {
		super.setEntityDao(entityDao);
	}
	
	/**
	 * 根据节点ID查询相关的通道的列表
	 * @param nodeId  节点的ID
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public List<ChannelVo> getChannelListByNodeId(Map<String,Integer> paramsMap)
	{
		return  entityDao.queryForList(IBatisSQLConstants.Channel_QueryChannelDetailListByNodeId, paramsMap);	
	}
    



	public List<FileChannel> getChannelListByNodeIp(String nodeIp) {
		return  entityDao.queryForList(IBatisSQLConstants.Channel_QueryChannelListByNodeIp, nodeIp);	
	}


	/**
	 * 根据节点id查询相关的接收端通道信息
	 * @param nodeId  
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public List<ChannelVo> queryChannelListByRecNodeId(Integer nodeId)
	{
		return  entityDao.queryForList(IBatisSQLConstants.Channel_QueryChannelListByRecNodeId, nodeId);	

	}
	
	

}

岁寒松柏

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Spring+IBatis整合各层设计(I)

针对Spring和IBatis的整合文章很多,鄙人自己搭建的框架,提供三层结构如下,以供学习之用,如用好的建议和意见以便沟通,希望大家一起学习,谢谢.package easyway.tbs.app.dao.generics;import java.io.Serializable;import java.sql.SQLException;import java.util.Co
复制链接

扫一扫