basemanager.java

基于java的组号查询模块

package com.lily.dap.service.core;

import java.io.Serializable;
import java.sql.ResultSet;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.orm.ObjectRetrievalFailureException;

import com.lily.dap.dao.Dao;
import com.lily.dap.dao.QueryCallback;
import com.lily.dap.dao.TransitionCallback;
import com.lily.dap.model.QueryCondition;
import com.lily.dap.service.Manager;
import com.lily.dap.service.core.exception.DataNotExistException;

/**
 * 基本的管理实现类，实现了对任意对象的CRUD操作
 * 
 * <p><a href="BaseManager.java.html"><i>View Source</i></a></p>
 *
 * @author zouxuemo
 */
public class BaseManager implements Manager {
    protected final Log log = LogFactory.getLog(getClass());
    
    /**
     * DAO操作接口
     */
    protected Dao dao = null;
    
    /**
     * @see com.lily.dap.service.Manager#setDao(com.lily.dap.dao.Dao)
     */
    public void setDao(Dao dao) {
        this.dao = dao;
    }

    /**
     * @see com.lily.dap.service.Manager#get(java.lang.Class, long)
     */
    public Object get(Class clazz, long id) {
    	return get(clazz, new Long(id));
    }
    
    /**
     * @see com.lily.dap.service.Manager#get(java.lang.Class, java.io.Serializable)
     */
    public Object get(Class clazz, Serializable id) {
		try{
			return dao.get(clazz, id);
		}catch(ObjectRetrievalFailureException e){
			throw new DataNotExistException("要检索的数据不存在或者已经删除！");
		}
    }

    /**
	 * @see com.lily.dap.service.Manager#get(java.lang.Class, java.lang.String, java.lang.Object)
	 */
	public Object get(Class clazz, String fieldName, Object fieldValue) throws DataNotExistException {
		return get(clazz, new String[]{fieldName}, new Object[]{fieldValue});
	}

    /**
	 * @see com.lily.dap.service.Manager#get(java.lang.Class, java.lang.String[], java.lang.Object[])
	 */
	public Object get(Class clazz, String[] fieldNames, Object[] fieldValues) throws DataNotExistException {
		QueryCondition queryCondition = new QueryCondition();
		
		for (int i = 0; i < fieldNames.length; i++)
			queryCondition.putCondition(fieldNames[i], fieldValues[i]);
		
		List result = gets(clazz, queryCondition);
		if (result.size() == 0)
			throw new DataNotExistException("要检索的数据不存在或者已经删除！");
		
		return result.get(0);
	}
    
    /**
     * @see com.lily.dap.service.Manager#gets(java.lang.Class, com.lily.dap.model.QueryCondition, com.lily.dap.dao.QueryCallback)
     */
    public List gets(Class clazz, QueryCondition queryCondition) {
        return dao.gets(clazz, queryCondition, null);
    }

    /**
	 * @see com.lily.dap.service.Manager#gets(java.lang.String, int, int)
	 */
	public List gets(String sql, int pageNo, int pageSize) {
		ResultSet rs = dao.executeSQLQuery(sql, pageNo, pageSize);
		
		return dao.ResultSet2List(rs);
	}
    
    /**
     * @see com.lily.dap.service.Manager#count(java.lang.Class, com.lily.dap.model.QueryCondition)
     */
    public long count(Class clazz, QueryCondition queryCondition) {
        return dao.count(clazz, queryCondition);
    }

    /**
	 * @see com.lily.dap.service.Manager#count(java.lang.String)
	 */
	public long count(String sql) {
		return dao.executeSQLCount(sql);
	}
    
    /**
     * @see com.lily.dap.service.Manager#remove(java.lang.Class, java.io.Serializable)
     */
    public void remove(Class clazz, Serializable id) {
    	Object entity = get(clazz, id);
    	
    	onBeforeRemove(entity);
    	
		try{
			doRemove(clazz, id);
		}catch(ObjectRetrievalFailureException e){
			throw new DataNotExistException("要删除的数据不存在或者已经删除！");
		}
		
		onAfterRemove(entity);
    }

    /**
	 * @see com.lily.dap.service.Manager#add(java.lang.Object)
	 */
	public Object add(Object o) {
		Object tgt = onBeforeAdd(o);
		
		doSave(tgt);
		
		onAfterAdd(tgt);
		
		return tgt;
	}

    /**
	 * @see com.lily.dap.service.Manager#modify(java.lang.Object)
	 */
	public void modify(Object o) {
		Object tgt = onBeforeModify(o);
		
		doSave(tgt);
		
		onAfterModify(tgt);
	}

//	 ********* 以下方法可以由子类使用 **********
	
    /**
     * 执行查询对象的查询，返回查询的数据集合列表，返回包含查询结果，分页信息、总记录条数的QueryResult对象
     * 支持查询回调
     * 
     * @param clazz
     * @param queryCondition
     * @param callBack
     * @return
     */
    protected QueryResult doQuery(Class clazz, QueryCondition queryCondition, QueryCallback callBack) {
		List result = dao.gets(clazz, queryCondition, callBack);
		
		int pageSize = queryCondition.getPageSize();
		int pageNo = queryCondition.getPageNo();
		
		long totalCount = dao.count(clazz, queryCondition, callBack);
		
		int start = (pageNo - 1) * pageSize;
		
		return new QueryResult(start, pageSize, result, totalCount);
	}

	/**
	 * 执行SQL查询，返回查询的数据集合列表，返回包含查询结果，分页信息、总记录条数的QueryResult对象
	 * 支持ResultSet数据转换回调，如果不设置回调，则查询结果为查询结果Map的集合
	 * 
	 * @param sql
	 * @param pageNo
	 * @param pageSize
	 * @param callback
	 * @return
	 */
	protected QueryResult doQuery(String sql, int pageNo, int pageSize, TransitionCallback callback) {
		ResultSet rs = dao.executeSQLQuery(sql, pageNo, pageSize);
		
		List result = null;
		if (callback == null)
			result = dao.ResultSet2List(rs);
		else
			result = dao.ResultSet2List(rs, callback);
		
		long totalCount = dao.executeSQLCount(sql);
		
		int start = (pageNo - 1) * pageSize;
		
		return new QueryResult(start, pageSize, result, totalCount);
	}
	
	/**
	 * 内部保存对象方法，供继承的子类调用保存操作
	 * 
	 * @param entity
	 */
	protected void doSave(Object entity) {
		dao.save(entity); 
	}
	
	/**
	 * 内部删除对象方法，供继承的子类调用删除操作
	 * 
	 * @param clazz
	 * @param id
	 */
	protected void doRemove(Class clazz, Serializable id) {
		dao.remove(clazz, id);
	}

// ********* 以下方法可以由子类重载，实现添加、修改、删除操作前后的处理 **********
	
	/**
	 * 子类重载，可以做保存前的操作，如：对数据进行校验，如果校验不通过，则抛出异常
	 * 
	 * @param entity 要保存的对象，可以对这个对象进行处理
	 */
	protected Object onBeforeAdd(Object entity) {
		return entity;
	}
	
	/**
	 * 子类重载，可以做保存后的操作，如：同时要更新其他数据
	 * 
	 * @param entity 保存后的对象，已经关联了对象ID
	 */
	protected void onAfterAdd(Object entity) {
		//默认什么也不做
	}
	
	/**
	 * 子类重载，可以做修改前的操作，如：对数据进行校验，如果校验不通过，则抛出异常
	 * 		一般在WEB的控制层传入要修改的对象是从Form中转换过来的，不是调用get方法获取的，
	 * 		所以还需要根据对象ID调用get方法获取对象，然后进行数据赋值操作，再进行保存
	 * 
	 * @param entity 要修改的对象，可以对这个对象进行处理
	 */
	protected Object onBeforeModify(Object entity) {
		return entity;
	}
	
	/**
	 * 子类重载，可以做修改后的操作，如：同时要修改其他数据
	 * 
	 * @param entity
	 */
	protected void onAfterModify(Object entity) {
		//默认什么也不做
	}
	
	/**
	 * 子类重载，可以做删除前的操作，如：判断给定的数据是否允许删除，如果不允许删除，则抛出异常
	 * 
	 * @param entity
	 */
	protected void onBeforeRemove(Object entity) {
		//默认什么也不做
	}
	
	/**
	 * 子类重载，可以做删除后的操作，如：同时要删除其他数据
	 * 
	 * @param entity
	 */
	protected void onAfterRemove(Object entity) {
		//默认什么也不做
	}
}