JDBC辅助类封装 及应用

 

一：代码图解：

二：配置文件：

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/xlzj_sh_new?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
username=root
password=123456
filters=stat
initialSize=10
maxActive=200
maxWait=60000
#maxIdle=15
minIdle=10
timeBetweenEvictionRunsMillis=60000
minEvictableIdleTimeMillis=300000
validationQuery=SELECT 'x'
testWhileIdle=true
testOnBorrow=false
testOnReturn=false
poolPreparedStatements=false
maxPoolPreparedStatementPerConnectionSize=20
#u7981u7528u5BF9u4E8Eu957Fu65F6u95F4u4E0Du4F7Fu7528u7684u8FDEu63A5u5F3Au5236u5173u95EDu7684u529Fu80FD
removeAbandoned=false
#u8D85u8FC730u5206u949Fu5F00u59CBu5173u95EDu7A7Au95F2u8FDEu63A5uFF0Cu7531u4E8EremoveAbandonedu4E3AfalseuFF0Cu8FD9u4E2Au8BBEu7F6Eu9879u4E0Du518Du8D77u4F5Cu7528
removeAbandonedTimeout=1800
#u5C06u5F53u524Du5173u95EDu52A8u4F5Cu8BB0u5F55u5230u65E5u5FD7uFF0Cu7531u4E8EremoveAbandonedu4E3AfalseuFF0Cu8FD9u4E2Au8BBEu7F6Eu9879u4E0Du518Du8D77u4F5Cu7528
logAbandoned=true

三：获取配置文件信息

PathUtil.java

package com.jacezhu.framework.utils.BeanUtil.pathUtil;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.net.URL;
import java.util.Properties;

/**
 *
*      12 * 项目名称：text     13 * 类名称：PathUtil     14 * 类描述：   获取文件路径
* 创建人： 刘军/shall_liu   16 * 创建时间：2015年11月17日 下午4:10:31     17 * 修改人：Administrator     18 * 修改时间：2015年11月17日 下午4:10:31     19 * 修改备注：     20 * @version      21 *      22  */
public class PathUtil {
	/**
	 * 获取  获取人参文件的 路径
	 * @return
	 */
    public static String getPath(String fileName){
    	String path=getPath(getFileUrl(),  fileName);
		return path;
    }
     /**
      * 获取：入参 properties配置文件里面的值（key_value）
      * @param FileName(*.properties <配置文件名称.properties>)
      * @return  properties 对象
      */
    public static Properties returnPropertiesValue(String FileName){
		return readData(getPath(FileName));
	}


    /**
     *
    * @Title: getPath   45     * @Description: (根据URl 获取指定文件的路径)
    * @param @param url
    * @param @return    设定文件   48     * @return String    返回类型   49     * @throws   50     * 创建者：刘军/shall_liu
    * 创建时间：2015年11月18日下午2:06:50
     */
    public static String getPath(URL url,String fileName){
		String path = (url + fileName );
        int index=lookindex(path,'/');
        String newPath=path.substring(index+1, path.length());
		return newPath;
    }
    /**
     *
    * @Title: getFileUrl   62     * @Description: (获取根目录路径)
    * @param @return    设定文件   64     * @return URL    返回类型   65     * @throws   66     * 创建者：刘军/shall_liu
    * 创建时间：2015年11月18日下午2:04:23
     */
    public static URL getFileUrl(){
    	URL url = ClassLoader.getSystemClassLoader().getResource("./");
		return url;
    }

    /**
     * 获取 某个字符在某个字符串第一次出现的位置
     * @param string
     * @param s
     * @return
     */
	public static int lookindex(String string, char s) {

		int number = 0;
		int index=-1;//-1 表示没有找到 
		char arr[] = string.toCharArray();
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] == s) {
				number++;
			}
			if (number == 1) {
				 index=i;
				  return i;
			}
		}
		return index;
	}
	/**
	 *
	* @Title: lookindex   99 	* @Description: (判断字符 c在 字符串 string中指定出现的index次数时该字符c在字符串string中的位置)
	* @param @param string
	* @param @param s
	* @param @param indexs
	* @param @return    设定文件  104 	* @return int    返回类型  105 	* @throws  106 	* 创建者：刘军/shall_liu
	* 创建时间：2015年11月18日下午1:59:27
	 */
	public static int lookindex(String string, char s,int indexs) {
		int number = 0;
		int index=-1;//-1 表示没有找到 
		char arr[] = string.toCharArray();
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] == s) {
				number++;
			}
			if (number ==indexs) {
				 index=i;
				  return i;
			}
		}
		return index;
	}
	/**
	 *
	* @Title: counter  127 	* @Description: ( 判断字符串c在 字符串source中出现的总次数)
	* @param @param source
	* @param @param c
	* @param @return    设定文件  131 	* @return int    返回类型  132 	* @throws  133 	* 创建者：刘军/shall_liu
	* 创建时间：2015年11月18日下午1:57:29
	 */
	public static int counter(String source,String c){
		 int counter=0;
		 if(c ==null||c.trim().equals("")){
			   counter=0;
		 }else{
			if(!source.trim().equals("")&&source!=null){
				String[] newArray=source.split(c);
				counter=newArray.length-1;
			}
		 }
		return counter;
		}

	public static void main(String[] args) {
		String path=getPath("dabase.properties");
		System.out.println(path);
	}


	/**
	 * 获取整个配置文件中的属性
	 *
	 * @param filePath
	 *            文件路径，即文件所在包的路径，例如：java/util/config.properties
	 */
	public static Properties readData(String filePath) {
		Properties props = new Properties();
		try {
			InputStream in = new BufferedInputStream(new FileInputStream(
					filePath));
			props.load(in);
			in.close();
			return props;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}



}

PropertiesConfig.java

package com.jacezhu.framework.utils.BeanUtil.pathUtil;

import java.io.InputStream;
import java.util.Properties;

/**
 * 主题：读取Config文件工具类 P
 *
 * @author 刘军/shell_liu 2015-4-14
 */
public class PropertiesConfig {


	/**
	 *
	 * @Title: getProperties   17 	 * @Description:
	 *               (TestProperties.class.getClassLoader().getResourceAsStream
	 *               ("db.properties" );
	 *               类名.class.类加载器.从文件流中获取资源（"放在程序根目录下的properties文件中的内容"）
	 *               loader： 载入程序；装货设备；装填器)   22 	 * @param @param fileName
	 * @param @return    设定文件   24 	 * @return Properties    返回类型   25 	 * @throws   26 	 */
	public static Properties getProperties(String fileName) {
		/*
		 * 从properties文件中读取文件思路： 1：声明对象：Properties props=new Properties();
		 * 2：调用获取properties文件内容的流方法：props.load(inStream); 3：将src
		 * /db.propreties以InputStream方式载入 inStream=
		 * TestProperties.class.getClassLoader
		 * ().getResourceAsStream("db.properties"); 4：//读取props中文件信息 String
		 * name=props.getProperty("uesrname");
		 */
		Properties props = new Properties();
		try {
			// 将src /db.propreties以InputStream方式载入
			InputStream inStream = PropertiesConfig.class
					.getResourceAsStream(fileName);
			props.load(inStream);

		} catch (Exception e) {
			e.printStackTrace();
		}
		return props;
	}


	public static void main(String[] args) {
		Properties properties = new Properties();
		properties = getProperties("/dabase.properties");
		System.out.println(properties);
	}
}

PropertyReadUtil.java

package com.jacezhu.framework.utils.BeanUtil.pathUtil;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Iterator;
import java.util.Properties;

/**
 * 主题： *.properties 配置文件内容读取工具
 * @author 刘军/shell_liu
 * 2015-9-8
 */

public class PropertyReadUtil {
	 //获取项目根文件路径地址
	static String path = Thread.currentThread().getContextClassLoader() .getResource("").getPath();
	/**
	 *
	 * @param propertiesName  需要被读取的配置文件
	 * @return   Properties对象
	 * @描述   :*.properties 配置文件内容读取  方法
	 * @author 刘军/shell_liu
	 * @创建日期 2015-9-8
	 * @创建时间 下午5:31:05
	 *
	 */
	 public static Properties getProperties(String propertiesName){
		 Properties prop = new Properties();
		 InputStream in;
		try {
			in = new BufferedInputStream (new FileInputStream(path+propertiesName));
			prop.load(in); ///加载属性列表
		}  catch(Exception e){
            System.out.println(e);
        }

		return prop;


	 }


	public static void main(String[] args) {
        Properties prop = new Properties();
        prop=getProperties("database.properties");
        Iterator<String> it=prop.stringPropertyNames().iterator();
        while(it.hasNext()){
            String key=it.next();
            System.out.println(key+":"+prop.getProperty(key));
        }


    }
}

四：JDBC 获取连接的封装

阿里巴巴开源的数据库连接jar 连接工具类 ：DruidDataSourceUtil.java

package com.jacezhu.framework.connectUtil;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

import javax.sql.DataSource;

import com.alibaba.druid.pool.DruidDataSourceFactory;

/**
 * The Class DruidDataSource.
 */
public class DruidDataSourceUtil {

    /** 使用配置文件构建Druid数据源. */
    public static final int DRUID_MYSQL_SOURCE = 0;

    /** 使用配置文件构建Druid数据源. */
    public static final int DRUID_MYSQL_SOURCE2 = 1;

    /** 使用配置文件构建Dbcp数据源. */
    public static final int DBCP_SOURCE = 4;
    public static String confile = "jdbc.properties";
    public static Properties p = null;

    static {
        p = new Properties();
        InputStream inputStream = null;
        try {
            //java应用  
            confile = DruidDataSourceUtil.class.getClassLoader().getResource("").getPath()+ confile;
            System.out.println(confile);
            File file = new File(confile);
            inputStream = new BufferedInputStream(new FileInputStream(file));
            p.load(inputStream);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (inputStream != null) {
                    inputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 根据类型获取数据源
     *
     * @param sourceType
     *            数据源类型
     * @return druid或者dbcp数据源
     * @throws Exception
     *             the exception
     */
    public static final DataSource getDataSource(int sourceType) throws Exception {
        DataSource dataSource = null;
        switch (sourceType) {
        case DRUID_MYSQL_SOURCE:
            dataSource = DruidDataSourceFactory.createDataSource(p);
            break;
        case DRUID_MYSQL_SOURCE2:
            dataSource = DruidDataSourceFactory.createDataSource(p);
            break;
        case DBCP_SOURCE:
            // dataSource = BasicDataSourceFactory.createDataSource(  
            // MySqlConfigProperty.getInstance().getProperties());  
            break;
        }
        return dataSource;
    }
	public static void main(String[] args) throws Exception {
		int dbType=0;
		DataSource dataSource=DruidDataSourceUtil.getDataSource(dbType);

	}
}

c3p0连接池管理类  DataSourceConnUtil.java

package com.jacezhu.framework.connectUtil;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

import javax.sql.DataSource;

import com.mchange.v2.c3p0.DataSources;

/**
 *
*      14 * 项目名称：s4h4s2s     15 * 类名称：DataSourceConnUtil     16 * 类描述： c3p0连接池管理类    17 * 创建人：刘军/jun liu     18 * 创建时间：2015-12-19 下午11:40:35     19 * 修改人：刘军/shall_liu     20 * 修改时间：2015-12-19 下午11:40:35     21 * 修改备注：     22 * @version      23 *      24  */
public class DataSourceConnUtil {

	private static final String JDBC_DRIVER = "driverClass";
	private static final String JDBC_URL = "jdbcUrl";

	private static DataSource ds;
	/**
	 * 初始化连接池代码块
	 */
	static{
		initDBSource();
	}

	/**
	 * 初始化c3p0连接池
	 */
	private static final void initDBSource(){
		Properties c3p0Pro = new Properties();
		try {
			//加载配置文件
			c3p0Pro.load(DataSourceConnUtil.class.getResourceAsStream("/config.properties"));
			//c3p0Pro.load(new FileInputStream(PathUtil.getPath("dabase.properties")));
		} catch (Exception e) {
			e.printStackTrace();
		}

		String drverClass = c3p0Pro.getProperty(JDBC_DRIVER);
		if(drverClass != null){
			try {
				//加载驱动类
				Class.forName(drverClass);
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			}

		}

		Properties jdbcpropes = new Properties();
		Properties c3propes = new Properties();
		for(Object key:c3p0Pro.keySet()){
			String skey = (String)key;
			if(skey.startsWith("c3p0.")){
				c3propes.put(skey, c3p0Pro.getProperty(skey));
			}else{
				jdbcpropes.put(skey, c3p0Pro.getProperty(skey));
			}
		}

		try {
			//建立连接池
			DataSource unPooled = DataSources.unpooledDataSource(c3p0Pro.getProperty(JDBC_URL),jdbcpropes);
			ds = DataSources.pooledDataSource(unPooled,c3propes);

		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 获取数据库连接对象
	 * @return 数据连接对象
	 * @throws SQLException
	 */
	public static synchronized Connection getConnection() {
		  Connection conn = null;
		  try {
			conn = ds.getConnection();
			conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
			conn.setAutoCommit(false);//取消 事务管理：事务提交机制
		} catch (SQLException e) {
			e.printStackTrace();
		}
		  return conn;
	}
}

普通的 数据库连接  ConnUtil.java

package com.jacezhu.framework.connectUtil;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;

import javax.servlet.ServletException;


/**
 *
*      16 * 项目名称：s4h4s2s     17 * 类名称：ConnUtil     18 * 类描述：  主题：数据库连接工具类——包含取得连接和关闭资源； 没有数据库连接池     19 * 创建人：刘军/jun liu     20 * 创建时间：2015-12-19 下午11:40:21     21 * 修改人：刘军/shall_liu     22 * 修改时间：2015-12-19 下午11:40:21     23 * 修改备注：     24 * @version      25 *      26  */
public class ConnUtil {
	private static Connection conn = null;
	private static String DRIVER_NAME;
	private static String URL;
	private static String USER_NAME;
	private static String PASSWORD;


	static {
		try {
			getConn();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 得到连接(没有入参)
	 *
	 * @return
	 */
	public static Connection getConn() {
		try {
			if (conn == null || conn.isValid(10) == false) {
				ConnUtil connInfo = getConnectInfo();
				conn = getConn(connInfo);
			}
			return conn;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}finally{

			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 获取：ConnUtil 数据库连接参数的值
	 *
	 * @return MerchatInfo 对象
	 * @描述 :从 dabase.properties配置文件获取 value 的值赋值给Properties 对象
	 * @author 刘军/shell_liu
	 * @创建日期 2015-9-8
	 * @创建时间 下午9:04:32
	 *
	 */
	public static ConnUtil getConnectInfo() {
		ConnUtil connInfo = new ConnUtil();
		try {
			Properties  properties=new Properties();
			//获取 配置文件的key-value
 	     	properties.load(ConnUtil.class.getResourceAsStream("/config.properties"));
			//properties = PathUtil.returnPropertiesValue("dabase.properties");

			ConnUtil.setDRIVER_NAME(properties.getProperty("driverClass"));
			ConnUtil.setURL(properties.getProperty("jdbcUrl"));
			ConnUtil.setUSER_NAME(properties.getProperty("user"));
			ConnUtil.setPASSWORD(properties.getProperty("password"));
			return connInfo;
		} catch (Exception e) {
			  try {
					throw new ServletException("加载数据库链接参数失败");

				} catch (ServletException e1) {
					e1.printStackTrace();
					return null;
				}
		}
	}

	/**
	 * 得到连接
	 *
	 * @param connUtil
	 *            （数据库连接需要的值）
	 * @return
	 */
	@SuppressWarnings("static-access")
	public static Connection getConn(ConnUtil connUtil) {
		try {
			Class.forName(connUtil.getDRIVER_NAME());
			conn = DriverManager.getConnection(connUtil.getURL(),
					connUtil.getUSER_NAME(), connUtil.getPASSWORD());
			conn.setAutoCommit(false);//取消 事务管理：事务提交机制
		} catch (Exception e) {
			  try {
				throw new ServletException("链接数据库失败！");
			} catch (ServletException e1) {
				e1.printStackTrace();
			}
		}
		return conn;
	}

	/**
	 * 关闭连接
	 *
	 * @param conn
	 * @throws SQLException
	 */
	public static void close(Connection conn) throws SQLException {
		if (conn != null) {
			conn.close();
			conn = null;
		}
	}

	/**
	 * 关闭PreparedStatement
	 *
	 * @param pstmt
	 * @throws SQLException
	 */
	public static void close(PreparedStatement pstmt) throws SQLException {
		if (pstmt != null) {
			pstmt.close();
			pstmt = null;
		}
	}

	/**
	 * 关闭结果集
	 *
	 * @param rs
	 * @throws SQLException
	 */
	public static void close(ResultSet rs) throws SQLException {
		if (rs != null) {
			rs.close();
			rs = null;
		}
	}


	//----------------------get set-------------------------------------------------
	/**
	 *
	* @Title: getDRIVER_NAME  170 	* @Description: ()  171 	* @param @return    设定文件  172 	* @return String    返回类型  173 	* @throws  174 	 */
	public static String getDRIVER_NAME() {
		return DRIVER_NAME;
	}

	public static void setDRIVER_NAME(String dRIVER_NAME) {
		DRIVER_NAME = dRIVER_NAME;
	}

	public static String getURL() {
		return URL;
	}

	public static void setURL(String uRL) {
		URL = uRL;
	}

	public static String getUSER_NAME() {
		return USER_NAME;
	}

	public static void setUSER_NAME(String uSER_NAME) {
		USER_NAME = uSER_NAME;
	}

	public static String getPASSWORD() {
		return PASSWORD;
	}

	public static void setPASSWORD(String pASSWORD) {
		PASSWORD = pASSWORD;
	}
   //--------------------main 方法----------------------------------------------
	/**
	 * 测试 连接是否成功
	 *
	 * @param args
	 */
	public static void main(String[] args) {
		getConn();
	}
}

SqlParameter.java

package com.jacezhu.framework.connectUtil.jdbcUtl;
/**
 *
* @Title: SqlParameter.java    5 * @Package com.jacezhu.framework.connectUtil.jdbcUtl    6 * @Description: (存储过程参数类型)    7 * @author  刘军
* @date 2016-3-19 下午2:47:02    9 * @version V1.0    10  */
public class SqlParameter {

	/**
     * 参数名称
     */
    public String Name;
    /**
     * 参数值
     */
    public Object Value;
    /**
     * true表示参数为输出类型
     */
    public boolean OutPut;
    /**
     * 参数类型
     */
    public int Type;
    /**
     * 输入类型参数的构造函数
     * @param name 存储过程 输入类型 参数名称
     * @param value 存储过程 输入类型 参数值
     */
    public SqlParameter(String name,Object value){
        this.Name = name;
        this.Value= value;
    }
    /**
     * 输出类型参数的构造函数
     * @param type 存储过程 输出类型 参数类型
     * @param name 存储过程 输出类型 参数名称
     */
    public SqlParameter(int type,String name){
        this.Name = name;
        this.OutPut = true;
        this.Type = type;
    }
    /**
     * 返回类型参数的构造函数
     * @param type 存储过程 返回类型
     */
    public SqlParameter(int type){
        this.Name = "";
        this.OutPut = true;
        this.Type = type;
    }
}

PageModel.java

package com.jacezhu.framework.connectUtil.jdbcUtl;
import java.util.List;
/**
 * 分页封装类
*       6 * 项目名称：s4h4s2s      7 * 类名称：PageModel      8 * 类描述：      9 * 创建人：刘军/jun liu     10 * 创建时间：2015-12-20 下午2:40:55     11 * 修改人：Administrator     12 * 修改时间：2015-12-20 下午2:40:55     13 * 修改备注：     14 * @version      15 *      16  */
public class PageModel<T> {

	//结果集
	private List<T> list;

	//记录数
	private int totalRecords;

	//每页多少条数据
	private int pageSize;

	//第几页
	private int pageNo;
	//总共多少页
	private int countPageNo;

	/**
	 * 返回总页数
	 * @return
	 */
	public int getTotalPages() {
		return (totalRecords + pageSize - 1) / pageSize;
	}

	/**
	 * 首页
	 * @return
	 */
	public int getTopPageNo() {
		return 1;
	}

	/**
	 * 上一页
	 * @return
	 */
	public int getPreviousPageNo() {
		if (this.pageNo <= 1) {
			return 1;
		}
		return this.pageNo - 1;
	}

	/**
	 * 下一页
	 * @return
	 */
	public int getNextPageNo() {
		if (this.pageNo >= getButtomPageNo()) {
			return getButtomPageNo();
		}
		return this.pageNo + 1;
	}

	/**
	 * 尾页
	 * @return
	 */
	public int getButtomPageNo() {
		return getTotalPages();
	}

	public List<T> getList() {
		return list;
	}

	public void setList(List<T> list) {
		this.list = list;
	}

	public int getTotalRecords() {
		return totalRecords;
	}

	public void setTotalRecords(int totalRecords) {
		this.totalRecords = totalRecords;
	}

	public int getPageSize() {
		return pageSize;
	}

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

	public int getPageNo() {
		return pageNo;
	}

	public void setPageNo(int pageNo) {
		this.pageNo = pageNo;
	}

	public int getCountPageNo() {
		return countPageNo;
	}

	public void setCountPageNo(int countPageNo) {
		this.countPageNo = countPageNo;
	}

}

ObjectMapper.java

package com.jacezhu.framework.connectUtil.jdbcUtl;

import java.sql.ResultSet;
/**
 *
* @Title: ObjectMapper.java    7 * @Package com.jacezhu.framework.connectUtil.jdbcUtl    8 * @Description: (用于转换数据结果集 )    9 * @author  刘军
* @date 2016-3-19 上午9:52:18   11 * @version V1.0    12  */
public interface ObjectMapper {
	public Object mapping(ResultSet rs);

}

五：JDBC 封装层：dao层

BaseDaoI.java

package com.jacezhu.dao;

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

public interface BaseDaoI<T> {

	public Serializable save(T o);

	public void delete(T o);

	public void update(T o);

	public void saveOrUpdate(T o);

	public T get(Class<T> c, Serializable id);

	public T get(String hql);

	public T get(String hql, Map<String, Object> params);

	public List<T> find(String hql);

	public List<T> find(String hql, Map<String, Object> params);

	public List<T> find(String hql, int page, int rows);

	public List<T> find(String hql, Map<String, Object> params, int page,
			int rows);

	public Long count(String hql);

	public Long count(String hql, Map<String, Object> params);

	public int executeHql(String hql);

	public int executeHql(String hql, Map<String, Object> params);

	public List<Object[]> findBySql(String sql);

	public List<Object[]> findBySql(String sql, int page, int rows);

	public List<Object[]> findBySql(String sql, Map<String, Object> params);

	public List<Object[]> findBySql(String sql, Map<String, Object> params,
			int page, int rows);

	public int executeSql(String sql);

	public int executeSql(String sql, Map<String, Object> params);

	public BigInteger countBySql(String sql);

	public BigInteger countBySql(String sql, Map<String, Object> params);

	public void refresh(T o);

	public void merge(T o);
}

JdbcBaseDao.java

package com.jacezhu.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.lang.reflect.Field;
import java.sql.Statement;
import java.sql.CallableStatement;
import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.sql.*;
import java.lang.reflect.*;


import com.jacezhu.framework.connectUtil.ConnUtil;
import com.jacezhu.framework.connectUtil.DataSourceConnUtil;
import com.jacezhu.framework.connectUtil.jdbcUtl.ObjectMapper;
import com.jacezhu.framework.connectUtil.jdbcUtl.SqlParameter;


public interface JdbcBaseDao {

    /**
     *
    * @author  刘军
    * @date 2016-3-19 上午11:14:17   31     * @version V1.0    32     * @Title: getStatement   33     * @Description: ( )   34     * @param @return
    * @param @throws SQLException    设定文件   36     * @return Connection    返回类型   37     * @throws   38      */
	public Connection getStatement() throws SQLException;

	/**
	 *
	 * @Title: update   44 	 * @Description: (更新：update)   45 	 * @param @param sql
	 * @param @param obj
	 * @param @param isGenerateKey
	 * @param @return    设定文件   49 	 * @return boolean    返回类型   50 	 * @throws   51 	 */
	public boolean update(String sql, Object[] obj, boolean isGenerateKey) ;
	/**
	 *
	 * @Title: updateByPreparedStatement  增加、删除、改
	 * @Description: (增加、删除、改)   57 	 * @param @param sql
	 * @param @param params
	 * @param @return    设定文件   60 	 * @return boolean    返回类型   61 	 * @throws   62 	 */
	public boolean updateByPreparedStatement(String sql, List<Object> params) ;



	/**
	 * insert update delete SQL语句的执行的统一方法
	 *
	 * @param sql
	 *            SQL语句
	 * @param params
	 *            参数数组，若没有参数则为null
	 * @return 受影响的行数
	 */
	public int executeUpdate(String sql, Object[] params) ;


	/**
	 *
	 * @Title: query   82 	 * @Description: ( )   83 	 * @param @param sql
	 * @param @param obj
	 * @param @param mapper
	 * @param @return    设定文件   87 	 * @return List<? extends Object>    返回类型   88 	 * @throws   89 	 */
	public List<? extends Object> query(String sql, Object[] obj,
			ObjectMapper mapper) ;

	/**
	 *
	* @author   liujun<1136808529@qq.coom>
	* @date 2016-5-12 下午1:58:12   97 	* @version V1.0    98 	* @Title: query   99 	* @Description: (
	 *
	 *)  102 	* @param @param sql
	* @param @param obj
	* @param @param mapper
	* @param @return    设定文件  106 	* @return List<? extends Object>    返回类型  107 	* @throws  108 	 */
	public List<? extends Object> query(String sql, List obj,
			ObjectMapper mapper) ;




     /**
      *
     * @Title: returnTableCount  118      * @Description: ( select count(*)from table 的总数据条数)  119      * @param @param table
     * @param @return    设定文件  121      * @return int    返回类型  122      * @throws  123       */
	public int returnTableCount(String table);
	/**
	 *
	* @author   liujun<1136808529@qq.coom>
	* @date 2016-5-12 下午11:19:59  129 	* @version V1.0   130 	* @Title: Count  131 	* @Description: (
	 * 返回 统计count 数据的数量
	 *)  134 	* @param @param sql
	* @param @return    设定文件  136 	* @return int    返回类型  137 	* @throws  138 	 */
	public long  Count(String sql);
	/**
	 *
	 * @Title: findSimpleResult  获取最后一条（单条）记录
	 * @Description: (查询单条记录)  144 	 * @param @param sql
	 * @param @param params
	 * @param @return    设定文件  147 	 * @return Map<String,Object>    返回类型  148 	 * @throws  149 	 */
	public Map<String, Object> findSimpleResult(String sql, List<Object> params);
	/**
	 * 获取结果集，并将结果放在List中
	 *
	 * @param sql
	 *            SQL语句
	 * @return List 结果集
	 */
	public List<Object> excuteQuery(String sql, Object[] params) ;

     /**
	 *
	 * @Title: findModeResult  查询多条记录
	 * @Description: (查询多条记录)  164 	 * @param @param sql
	 * @param @param params
	 * @param @return
	 * @param @throws SQLException    设定文件  168 	 * @return List<Map<String,Object>>    返回类型  169 	 * @throws  170 	 */
	public List<Map<String, Object>> findModeResult(String sql,	List<Object> params) ;

	/**
	 * SQL 查询将查询结果：一行一列
	 *
	 * @param sql
	 *            SQL语句
	 * @param params
	 *            参数数组，若没有参数则为null
	 * @return 结果集
	 */
	public Object executeQuerySingle(String sql, Object[] params) ;


	/**
	 *
	 * @Title: findSimpleRefResult  通过反射机制查询单条记录
	 * @Description: (通过反射机制查询单条记录)  189 	 * @param @param sql
	 * @param @param params
	 * @param @param cls
	 * @param @return
	 * @param @throws Exception    设定文件  194 	 * @return T    返回类型  195 	 * @throws  196 	 */
	public    <T> T  findSimpleRefResult(String sql, List<Object> params,Class<T> cls) ;
	/**
	 * 通过反射机制查询多条记录
	 *
	 * @param sql
	 * @param params
	 * @param cls
	 * @return
	 * @throws Exception
	 */
	public <T> List<T> findMoreRefResult(String sql, List<Object> params,
			Class<T> cls) ;

	/**
	 *
	 * @Title: find  213 	 * @Description: ( 查询一条记录)  214 	 * @param @param sql
	 * @param @param obj
	 * @param @param mapper
	 * @param @return    设定文件  218 	 * @return Object    返回类型  219 	 * @throws  220 	 */
	public Object find(String sql, Object[] obj, ObjectMapper mapper)  ;
	/**
	 *
	* @author   liujun<1136808529@qq.coom>
	* @date 2016-5-14 下午1:18:51  226 	* @version V1.0   227 	* @Title: find  228 	* @Description: (
	 *  查询一条记录
	 *)  231 	* @param @param sql
	* @param @param obj
	* @param @param mapper
	* @param @return    设定文件  235 	* @return Object    返回类型  236 	* @throws  237 	 */
	public Object find(String sql, List obj, ObjectMapper mapper);
	/**
	 *
	 * @Title: executeQuery  统一的select语句，为了能够访问结果集，将结果集放入ArrayList，这样可以直接关闭资源
	 * @Description: (统一的select语句，为了能够访问结果集，将结果集放入ArrayList，这样可以直接关闭资源)  243 	 * @param @param sql
	 * @param @param parameters
	 * @param @return    设定文件  246 	 * @return ArrayList    返回类型  247 	 * @throws  248 	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public ArrayList executeQuery(String sql, String[] parameters);

	/**
	 *
	 * @Title: executeQuery  by statement
	 * @Description: (执行 查询sql 获取结果集)  256 	 * @param @param sql
	 * @param @return statement resultSet
	 * @param @throws SQLException    设定文件  259 	 * @return ResultSet    返回类型  260 	 * @throws  261 	 */
	public ResultSet executeQuery(String sql);


	//-------------------------------------------对象化---------------








//----------------------存储过程调用-------------------------------------------


	/**
	 * 存储过程带有一个输出参数的方法
	 *
	 * @param sql
	 *            存储过程语句
	 * @param params
	 *            参数数组
	 * @param outParamPos
	 *            输出参数位置
	 * @param SqlType
	 *            输出参数类型
	 * @return 输出参数的值
	 */
	public Object executeQuery(String sql, Object[] params, int outParamPos,
			int SqlType) ;

    /**
     * 执行不返回结果集的存储过程
     *
     * @param sql
     *            存储过程名称
     * @param params
     *            存储过程参数
     * @throws ClassNotFoundException
     * @throws SQLException
     */
    public   void executeNonQuery(String sql, SqlParameter... params) ;

    /**
     * 执行Insert语句，返回Insert成功之后标识列的值
     *
     * @param sql
     * @return
     * @throws ClassNotFoundException
     * @throws SQLException
     */
    public   int executeIdentity(String sql) ;
    /**
     * 执行不返回结果集的存储过程
     *
     * @param sql
     *            存储过程名称
     * @param params
     *            存储过程参数
     * @throws ClassNotFoundException
     * @throws SQLException
     */
    public   void executeNonQuery1(String sql, SqlParameter... params) ;
    /**
     * 执行返回聚合函数的操作
     *
     * @param sql
     *            含有聚合函数的SQL语句
     * @return 聚合函数的执行结果
     * @throws SQLException
     * @throws ClassNotFoundException
     */
    public   int executeScalar(String sql) ;
    /**
     * 执行返回泛型集合的SQL语句
     *
     * @param cls
     *            泛型类型
     * @param sql
     *            查询SQL语句
     * @return 泛型集合
     * @throws ClassNotFoundException
     * @throws SQLException
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
    public   <T> List<T> executeList(Class<T> cls, String sql) ;
    /**
     * 执行返回泛型集合的存储过程
     *
     * @param cls
     *            泛型类型
     * @param sql
     *            存储过程名称
     * @param params
     *            存储过程参数
     * @return 泛型集合
     * @throws ClassNotFoundException
     * @throws SQLException
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
    public   <T> List<T> executeList(Class<T> cls, String sql,
            SqlParameter... params)  ;
    /**
     * 执行返回泛型类型对象的SQL语句
     *
     * @param cls
     *            泛型类型
     * @param sql
     *            SQL语句
     * @return 泛型类型对象
     * @throws SQLException
     * @throws ClassNotFoundException
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
    public   <T> T executeEntity(Class<T> cls, String sql)  ;
    /**
     * 执行返回泛型类型对象的存储过程
     *
     * @param cls
     *            泛型类型
     * @param sql
     *            SQL语句
     * @param params
     *            存储过程参数
     * @return 泛型类型对象
     * @throws SQLException
     * @throws ClassNotFoundException
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
    public   <T> T executeEntity(Class<T> cls, String sql,
            SqlParameter... params) ;

	/**
	 *
	 * @Title: executeUpdate  by statement
	 * @Description: (更新结果集)  402 	 * @param @param sql
	 * @param @return
	 * @param @throws SQLException    设定文件  405 	 * @return int    返回类型  406 	 * @throws  407 	 */
	@SuppressWarnings("null")
	public int executeUpdate(String sql)  ;




	/**
	 *
	* @author   liujun<1136808529@qq.coom>
	* @date 2016-5-17 上午11:33:28  418 	* @version V1.0   419 	* @Title: getSeq  420 	* @Description:  (
	 *  获取sequence 序列号
	 *)  423 	* @param @param sequenceName
	* @param @return    设定文件  425 	* @return int    返回类型  426 	* @throws  427 	 */
	public int getSeq(String sequenceName) ;
}

jdbc.java

package com.jacezhu.dao;

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

import com.jacezhu.framework.connectUtil.jdbcUtl.ObjectMapper;
import com.jacezhu.framework.connectUtil.jdbcUtl.PageModel;

/**
 *
* @Title: JdbcUtil.java   13 * @Package com.jacezhu.framework.connectUtil.jdbcUtl   14 * @Description: (JdbcUtil)   15 * @author  刘军
* @date 2016-3-17 下午11:04:19   17 * @version V1.0    18  */
public interface JdbcDao  {


	/**
	 *
	* @Title: insert   25 	* @Description: (插入单挑数据)   26 	* @param @param sql 查询sql
	* @param @param obj 参数数组
	* @param @param isGenerateKey (true  false)
	* @param @return    设定文件   30 	* @return boolean    返回类型   31 	* @throws   32 	 */
	public boolean insert(String sql, Object[] obj);
	/**
	 *
	* @author  刘军
	* @date 2016-3-19 下午2:23:42   38 	* @version V1.0    39 	* @Title: insertLines   40 	* @Description: (新增)   41 	* @param @param sql
	* @param @param obj
	* @param @return    设定文件   44 	* @return int    返回类型   45 	* @throws   46 	 */
	public int insertLines(String sql, Object[] obj);
	/**
	 *
	* @author  刘军
	* @date 2016-3-19 下午2:05:19   52 	* @version V1.0    53 	* @Title: insert   54 	* @Description: (新增)   55 	* @param @param sql
	* @param @param obj
	* @param @return    设定文件   58 	* @return boolean    返回类型   59 	* @throws   60 	 */
	public boolean insertByList(String sql, List<Object> obj);

	/**
	 *
	* @Title: delete   66 	* @Description: (删除单挑数据)   67 	* @param @param sql 删除sql
	* @param @param obj 参数数组
	* @param @param isGenerateKey (true  false)
	* @param @return    设定文件   71 	* @return boolean    返回类型   72 	* @throws   73 	 */
	public boolean delete(String sql, Object[] obj);
	/**
	 *
	* @author  刘军
	* @date 2016-3-19 下午2:19:20   79 	* @version V1.0    80 	* @Title: delete   81 	* @Description: (删除单挑数据)   82 	* @param @param sql
	* @param @param obj
	* @param @return    设定文件   85 	* @return boolean    返回类型   86 	* @throws   87 	 */
	public boolean delete(String sql,List<Object> obj);

	 /**
	  *
	 * @Title: deleteALL   93 	 * @Description: (批量删除数据)   94 	 * @param @param sql
	 * @param @param obj
	 * @param @return    设定文件   97 	 * @return boolean    返回类型   98 	 * @throws   99 	  */
	public boolean deleteALL(String sql, Object[] obj);
	/**
	 *
	* @author  刘军
	* @date 2016-3-19 下午2:20:56  105 	* @version V1.0   106 	* @Title: deleteALL  107 	* @Description: (删除 批量删除 )  108 	* @param @param sql
	* @param @param obj
	* @param @return    设定文件  111 	* @return boolean    返回类型  112 	* @throws  113 	 */
	public boolean deleteALL(String sql,List<Object> obj);
	 /**
	  *
	 * @Title: update  118 	 * @Description: (更新单挑数据记录)  119 	 * @param @param sql
	 * @param @param obj
	 * @param @return    设定文件  122 	 * @return boolean    返回类型  123 	 * @throws  124 	  */
	public boolean update(String sql, Object[] obj);
	/**
	 *
	* @author  刘军
	* @date 2016-3-19 下午2:21:45  130 	* @version V1.0   131 	* @Title: update  132 	* @Description: (修改 )  133 	* @param @param sql
	* @param @param obj
	* @param @return    设定文件  136 	* @return boolean    返回类型  137 	* @throws  138 	 */
	public boolean update(String sql, List<Object> obj);
	 /**
	  *
	 * @Title: queryFrist  143 	 * @Description: (查询出第一条数据记录)  144 	 * @param @param tale
	 * @param @param objParams
	 * @param @return    设定文件  147 	 * @return Object    返回类型  148 	 * @throws  149 	  */
	 public Object queryFrist(String tale,Object[] objParams,ObjectMapper mapper);
	 /**
	  *
	 * @author  刘军
	 * @date 2016-3-19 上午9:41:06  155 	 * @version V1.0   156 	 * @Title: find  157 	 * @Description: (查询一条记录 )  158 	 * @param @param sql
	 * @param @param obj
	 * @param @param mapper
	 * @param @return    设定文件  162 	 * @return Object    返回类型  163 	 * @throws  164 	  */
	 public	 Object find(String sql, Object[] obj, ObjectMapper mapper);
	 /**
		 *
		* @author   liujun<1136808529@qq.coom>
		* @date 2016-5-14 下午1:18:51  170 		* @version V1.0   171 		* @Title: find  172 		* @Description: (
		 *  查询一条记录
		 *)  175 		* @param @param sql
		* @param @param obj
		* @param @param mapper
		* @param @return    设定文件  179 		* @return Object    返回类型  180 		* @throws  181 		 */
		public Object find(String sql, List obj, ObjectMapper mapper);
	/**
	 *
	* @Title: query  186 	* @Description: ( 查询所有的数据记录；并以list 集合(或者：Object 对象)返回 )  187 	* @param @param sql
	* @param @param obj
	* @param @param mapper
	* @param @return    设定文件  191 	* @return List<? extends Object>    返回类型  192 	* @throws  193 	 */
	public List<? extends Object> query(String sql, Object[] obj,
			ObjectMapper mapper) ;
	/**
	 *
	* @author   liujun<1136808529@qq.coom>
	* @date 2016-5-12 下午2:03:54  200 	* @version V1.0   201 	* @Title: query  202 	* @Description: (
	 *
	 *)  205 	* @param @param sql
	* @param @param obj
	* @param @param mapper
	* @param @return    设定文件  209 	* @return List<? extends Object>    返回类型  210 	* @throws  211 	 */
	public List<? extends Object> query(String sql, List obj,
			ObjectMapper mapper) ;
	/**
	 *
	* @author   liujun<1136808529@qq.coom>
	* @date 2016-5-12 下午11:19:59  218 	* @version V1.0   219 	* @Title: Count  220 	* @Description: (
	 * 返回 统计count 数据的数量
	 *)  223 	* @param @param sql
	* @param @return    设定文件  225 	* @return int    返回类型  226 	* @throws  227 	 */
	public long  Count(String sql);
	/**
	 *
	* @Title: CountNum  232 	* @Description: ( select count(*)from table 的总数据条数)
	* @param @param tableName (数据库表名)
	* @param @return    设定文件  235 	* @return int    返回类型  236 	* @throws  237 	 */
	public int CountNum (String tableName);
	/**
	 *
	* @Title: queryPageNumber  242 	* @Description: (分页查询)  243 	* @param @param pageNo 第几页
	* @param @param pageSize  一页显示多少条数据
	* @param @param table  查询哪个表
	* 全表无条件查询
	*  {select * from （ tablea a,tableb b where a.id=b.id）limt numStrat,numStop}
	* 全表 带条件模糊查询：
	*SELECT * FROM  demo a ,demo b WHERE a.id=b.id AND  a.id LIKE "1%" LIMIT 0,15;
	* @param @return    设定文件  251 	* @return PageModel    返回类型  252 	* @throws  253 	 */
	public PageModel queryPageNumber(int pageNo, int pageSize,String table) ;
	/**
	 *
	 * @Title: findSimpleResult  获取最后一条（单条）记录
	 * @Description: (查询单条记录)  259 	 * @param @param sql
	 * @param @param params
	 * @param @return    设定文件  262 	 * @return Map<String,Object>    返回类型  263 	 * @throws  264 	 */
	public Map<String, Object> findSimpleResult(String sql, List<Object> params);
	/**
	 *
	* @author  刘军
	* @date 2016-3-19 上午12:30:02  270 	* @version V1.0   271 	* @Title: findModeResult  查询多条记录
	* @Description: (查询多条记录)  273 	* @param @param sql
	* @param @param params
	* @param @return    设定文件  276 	* @return List<Map<String,Object>>    返回类型  277 	* @throws  278 	 */
	public List<Map<String, Object>> findModeResult(String sql,	List<Object> params);
	/**
	 *
	* @author  刘军
	* @date 2016-3-19 上午8:43:07  284 	* @version V1.0   285 	* @Title: executeQuerySingle  286 	* @Description: (SQL 查询将查询结果：一行一列)  287 	* @param @param sql
	* @param @param params
	* @param @return    设定文件  290 	* @return Object    返回类型  291 	* @throws  292 	 */
	public Object executeQuerySingle(String sql, Object[] params);

	/**
	 *
	* @author  刘军
	* @date 2016-3-19 上午9:08:05  299 	* @version V1.0   300 	* @Title: findSimpleRefResult  301 	* @Description: (通过反射机制查询单条记录
	*   如果需要调用：请调用jdbcBaseUtil
	* )  304 	* @param @param sql
	* @param @param params
	* @param @param cls
	* @param @return    设定文件  308 	* @return T    返回类型  309 	* @throws  310 	 */
	public <T> T findSimpleRefResult(String sql, List<Object> params,Class<T> cls) ;
	/**
	 *
	* @author  刘军
	* @date 2016-3-19 上午9:13:39  316 	* @version V1.0   317 	* @Title: findMoreRefResult  318 	* @Description: ( 通过反射机制查询多条记录)  319 	* @param @param sql
	* @param @param params
	* @param @param cls
	* @param @return    设定文件  323 	* @return List<T>    返回类型  324 	* @throws  325 	 */
	public <T> List<T> findMoreRefResult(String sql, List<Object> params,
			Class<T> cls);
	/**
	 *
	* @author  刘军
	* @date 2016-3-19 上午11:03:06  332 	* @version V1.0   333 	* @Title: excuteQuery  334 	* @Description: (获取结果集，并将结果放在List中)  335 	* @param @param sql
	* @param @param params
	* @param @return    设定文件  338 	* @return List<Object>    返回类型  339 	* @throws  340 	 */
	public List<Object> excuteQuery(String sql, Object[] params);
	/**
	 *
	* @author  刘军
	* @date 2016-3-19 上午11:03:03  346 	* @version V1.0   347 	* @Title: executeQuery  348 	* @Description: (统一的select语句，为了能够访问结果集，将结果集放入ArrayList，)  349 	* @param @param sql
	* @param @param parameters
	* @param @return    设定文件  352 	* @return ArrayList    返回类型  353 	* @throws  354 	 */
	public ArrayList executeQuery(String sql, String[] parameters) ;

	/**
	 *
	* @author   liujun<1136808529@qq.coom>
	* @date 2016-5-17 上午11:33:28  361 	* @version V1.0   362 	* @Title: getSeq  363 	* @Description:  (
	 *  获取sequence 序列号
	 *)  366 	* @param @param sequenceName
	* @param @return    设定文件  368 	* @return int    返回类型  369 	* @throws  370 	 */
	public int getSeq(String sequenceName);
}

BaseDaoImpl.java

package com.jacezhu.dao.impl;

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

import com.jacezhu.dao.BaseDaoI;

import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

@Repository
public class BaseDaoImpl<T> implements BaseDaoI<T> {

	@Autowired
	private SessionFactory sessionFactory;

	/**
	 * 获得当前事物的session
	 *
	 * @return org.hibernate.Session
	 */
	public Session getCurrentSession() {
		return this.sessionFactory.getCurrentSession();
	}

	@Override
	public Serializable save(T o) {
		if (o != null) {
			return this.getCurrentSession().save(o);
		}
		return null;
	}

	@Override
	public T get(Class<T> c, Serializable id) {
		return (T) this.getCurrentSession().get(c, id);
	}

	@Override
	public T get(String hql) {
		Query q = this.getCurrentSession().createQuery(hql);
		List<T> l = q.list();
		if ((l != null) && (l.size() > 0)) {
			return l.get(0);
		}
		return null;
	}

	@Override
	public T get(String hql, Map<String, Object> params) {
		Query q = this.getCurrentSession().createQuery(hql);
		if ((params != null) && !params.isEmpty()) {
			for (String key : params.keySet()) {
				q.setParameter(key, params.get(key));
			}
		}
		List<T> l = q.list();
		if ((l != null) && (l.size() > 0)) {
			return l.get(0);
		}
		return null;
	}

	@Override
	public void delete(T o) {
		if (o != null) {
			this.getCurrentSession().delete(o);
		}
	}

	@Override
	public void update(T o) {
		if (o != null) {
			this.getCurrentSession().update(o);
		}
	}

	@Override
	public void saveOrUpdate(T o) {
		if (o != null) {
			this.getCurrentSession().saveOrUpdate(o);
		}
	}

	@Override
	public List<T> find(String hql) {
		Query q = this.getCurrentSession().createQuery(hql);
		return q.list();
	}

	@Override
	public List<T> find(String hql, Map<String, Object> params) {
		Query q = this.getCurrentSession().createQuery(hql);
		if ((params != null) && !params.isEmpty()) {
			for (String key : params.keySet()) {
				q.setParameter(key, params.get(key));
			}
		}
		return q.list();
	}

	@Override
	public List<T> find(String hql, Map<String, Object> params, int page,
			int rows) {
		Query q = this.getCurrentSession().createQuery(hql);
		if ((params != null) && !params.isEmpty()) {
			for (String key : params.keySet()) {
				q.setParameter(key, params.get(key));
			}
		}
		return q.setFirstResult((page - 1) * rows).setMaxResults(rows).list();
	}

	@Override
	public List<T> find(String hql, int page, int rows) {
		Query q = this.getCurrentSession().createQuery(hql);
		return q.setFirstResult((page - 1) * rows).setMaxResults(rows).list();
	}

	@Override
	public Long count(String hql) {
		Query q = this.getCurrentSession().createQuery(hql);
		return (Long) q.uniqueResult();
	}

	@Override
	public Long count(String hql, Map<String, Object> params) {
		Query q = this.getCurrentSession().createQuery(hql);
		if ((params != null) && !params.isEmpty()) {
			for (String key : params.keySet()) {
				q.setParameter(key, params.get(key));
			}
		}
		return (Long) q.uniqueResult();
	}

	@Override
	public int executeHql(String hql) {
		Query q = this.getCurrentSession().createQuery(hql);
		return q.executeUpdate();
	}

	@Override
	public int executeHql(String hql, Map<String, Object> params) {
		Query q = this.getCurrentSession().createQuery(hql);
		if ((params != null) && !params.isEmpty()) {
			for (String key : params.keySet()) {
				q.setParameter(key, params.get(key));
			}
		}
		return q.executeUpdate();
	}

	@Override
	public List<Object[]> findBySql(String sql) {
		SQLQuery q = this.getCurrentSession().createSQLQuery(sql);
		return q.list();
	}

	@Override
	public List<Object[]> findBySql(String sql, int page, int rows) {
		SQLQuery q = this.getCurrentSession().createSQLQuery(sql);
		return q.setFirstResult((page - 1) * rows).setMaxResults(rows).list();
	}

	@Override
	public List<Object[]> findBySql(String sql, Map<String, Object> params) {
		SQLQuery q = this.getCurrentSession().createSQLQuery(sql);
		if ((params != null) && !params.isEmpty()) {
			for (String key : params.keySet()) {
				q.setParameter(key, params.get(key));
			}
		}
		return q.list();
	}

	@Override
	public List<Object[]> findBySql(String sql, Map<String, Object> params,
			int page, int rows) {
		SQLQuery q = this.getCurrentSession().createSQLQuery(sql);
		if ((params != null) && !params.isEmpty()) {
			for (String key : params.keySet()) {
				q.setParameter(key, params.get(key));
			}
		}
		return q.setFirstResult((page - 1) * rows).setMaxResults(rows).list();
	}

	@Override
	public int executeSql(String sql) {
		SQLQuery q = this.getCurrentSession().createSQLQuery(sql);
		return q.executeUpdate();
	}

	@Override
	public int executeSql(String sql, Map<String, Object> params) {
		SQLQuery q = this.getCurrentSession().createSQLQuery(sql);
		if ((params != null) && !params.isEmpty()) {
			for (String key : params.keySet()) {
				q.setParameter(key, params.get(key));
			}
		}
		return q.executeUpdate();
	}

	@Override
	public BigInteger countBySql(String sql) {
		SQLQuery q = this.getCurrentSession().createSQLQuery(sql);
		return (BigInteger) q.uniqueResult();
	}

	@Override
	public BigInteger countBySql(String sql, Map<String, Object> params) {
		SQLQuery q = this.getCurrentSession().createSQLQuery(sql);
		if ((params != null) && !params.isEmpty()) {
			for (String key : params.keySet()) {
				q.setParameter(key, params.get(key));
			}
		}
		return (BigInteger) q.uniqueResult();
	}

	@Override
	public void refresh(T o) {
		this.getCurrentSession().refresh(o);

	}

	@Override
	public void merge(T o) {
		this.getCurrentSession().merge(o);
	}
}

JdbcBaseDaoImpl.java

package com.jacezhu.dao.impl;

import java.lang.reflect.Field;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.sql.DataSource;

import org.springframework.stereotype.Repository;
import com.jacezhu.dao.JdbcBaseDao;
import com.jacezhu.framework.connectUtil.ConnUtil;
import com.jacezhu.framework.connectUtil.DataSourceConnUtil;
import com.jacezhu.framework.connectUtil.DruidDataSourceUtil;
import com.jacezhu.framework.connectUtil.jdbcUtl.ObjectMapper;
import com.jacezhu.framework.connectUtil.jdbcUtl.SqlParameter;

@Repository
public class JdbcBaseDaoImpl implements JdbcBaseDao {
	/**
	 * 获取连接
	 */
	static {
		getConnection();
	}
    /**
    * @author  刘军
    * @date 2016-3-19 上午11:14:17   37     * @version V1.0    38     * @Title: getStatement   39     * @Description: ( )   40     * @param @return
    * @param @throws SQLException    设定文件   42     * @return Connection    返回类型   43     * @throws   44      */
	public Connection getStatement() throws SQLException {
		Connection connection = null;
		Statement statement = null;
		// 仅当statement失效时才重新创建
		if (statement == null || statement.isClosed() == true) {
			statement = connection.createStatement(
					ResultSet.TYPE_SCROLL_INSENSITIVE,
					ResultSet.CONCUR_READ_ONLY);
		}
		return connection;
	}

	/**
	 *
	 * @Title: getConnection   60 	 * @Description: (得到数据库连接)   61 	 * @param @return    设定文件   62 	 * @return Connection    返回类型   63 	 * @throws   64 	 */
	public static Connection getConnection() {
		Connection connection = null;
		try {
			/**
			 *  从 阿里巴巴 开源的数据库连接池中获取连接
			 */
			int dbType=0;
			DataSource dataSource=DruidDataSourceUtil.getDataSource(dbType);
			connection = dataSource.getConnection();
			if (connection == null) {
				/**
				 *  连接C3P0 连接池
				 */
				connection = DataSourceConnUtil.getConnection();
			}
			if (connection == null) {
				/**
				 * 直接连接数据库
				 */
				connection = ConnUtil.getConn();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return connection;
	}


	/**
	 *
	 * @Title: update   96 	 * @Description: (更新：update)   97 	 * @param @param sql
	 * @param @param obj
	 * @param @param isGenerateKey
	 * @param @return    设定文件  101 	 * @return boolean    返回类型  102 	 * @throws  103 	 */
	public boolean update(String sql, Object[] obj, boolean isGenerateKey) {
		Connection conn = null;
		PreparedStatement pstmt = null;
		boolean bFlag = false;
		try {
			conn = JdbcBaseDaoImpl.getConnection();
			pstmt = isGenerateKey ? conn.prepareStatement(sql,
					Statement.RETURN_GENERATED_KEYS) : conn
					.prepareStatement(sql);
			for (int i = 0; i < obj.length; i++) {
				pstmt.setObject(i + 1, obj[i]);
			}
			conn.setAutoCommit(false);//JDBC 事务管理
			int i = pstmt.executeUpdate();
			conn.commit();//JDBC 事务管理
			if (i > 0)
				bFlag = true;
		} catch (SQLException ex) {
			ex.printStackTrace();
			try {
				conn.rollback();//JDBC 事务管理
			} catch (SQLException e) {
				e.printStackTrace();
			}
		} finally {
			try {
				conn.close();
				pstmt.close();
			} catch (SQLException ex) {
				ex.printStackTrace();
			}
		}
		return bFlag;
	}
	/**
	 *
	 * @Title: updateByPreparedStatement  增加、删除、改
	 * @Description: (增加、删除、改)  142 	 * @param @param sql
	 * @param @param params
	 * @param @return    设定文件  145 	 * @return boolean    返回类型  146 	 * @throws  147 	 */
	public boolean updateByPreparedStatement(String sql, List<Object> params) {
		boolean flag = false;
		Connection connection = null;
		PreparedStatement pstmt = null;
		int result = -1;
		try {
			connection = JdbcBaseDaoImpl.getConnection();
			pstmt = connection.prepareStatement(sql);
			int index = 1;
			if (params != null && !params.isEmpty()) {
				for (int i = 0; i < params.size(); i++) {
					pstmt.setObject(index++, params.get(i));
				}
			}
			result = pstmt.executeUpdate();
			connection.commit();//JDBC 事务管理
			flag = result > 0 ? true : false;
		} catch (SQLException e) {
			try {
				connection.rollback();//JDBC 事务管理
			} catch (SQLException e1) {
				e1.printStackTrace();
			}
			e.printStackTrace();
		} finally {
			try {
				pstmt.close();
				connection.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}

		}
		return flag;
	}



	/**
	 * insert update delete SQL语句的执行的统一方法
	 *
	 * @param sql
	 *            SQL语句
	 * @param params
	 *            参数数组，若没有参数则为null
	 * @return 受影响的行数
	 */
	public int executeUpdate(String sql, Object[] params) {
		PreparedStatement preparedStatement = null;
		// 受影响的行数
		int affectedLine = 0;
		Connection connection = null;
		try {
			// 获得连接
			connection = JdbcBaseDaoImpl.getConnection();
			// 调用SQL
			preparedStatement = connection.prepareStatement(sql);
			// 参数赋值
			if (params != null) {
				for (int i = 0; i < params.length; i++) {
					preparedStatement.setObject(i + 1, params[i]);
				}
			}
			// 执行
			affectedLine = preparedStatement.executeUpdate();
			connection.commit();// 提交事务
		} catch (SQLException e) {
			System.out.println(e.getMessage());
			try {
				connection.rollback();//JDBC 事务管理
			} catch (SQLException e1) {
				e1.printStackTrace();
			}
		} finally {
			// 释放资源
			close(connection, preparedStatement, null);
		}
		return affectedLine;
	}



	/**
	 *
	 * @Title: query  233 	 * @Description: (这里用一句话描述这个方法的作用)  234 	 * @param @param sql
	 * @param @param obj
	 * @param @param mapper
	 * @param @return    设定文件  238 	 * @return List<? extends Object>    返回类型  239 	 * @throws  240 	 */
	public List<? extends Object> query(String sql, Object[] obj,
			ObjectMapper mapper) {
		Object o = null;
		List<Object> list = new ArrayList<Object>();
		Connection conn = null;
		PreparedStatement pstmt = null;
		try {
			conn = JdbcBaseDaoImpl.getConnection();
			pstmt = conn.prepareStatement(sql);
			for (int i = 0; i < obj.length; i++) {
				pstmt.setObject(i + 1, obj[i]);
			}
			ResultSet rs = pstmt.executeQuery();
			while (rs.next()) {
				o = mapper.mapping(rs);
				list.add(o);
			}
		} catch (SQLException ex) {
			ex.printStackTrace();
		} finally {
			try {
				pstmt.close();
				conn.close();
			} catch (SQLException ex) {
				ex.printStackTrace();
			}
		}
		return list;
	}
	/**
	 *
	* @author   liujun<1136808529@qq.coom>
	* @date 2016-5-12 下午1:54:42  274 	* @version V1.0   275 	* @Title: query  276 	* @Description: (
	 *
	 *)  279 	* @param @param sql
	* @param @param obj
	* @param @param mapper
	* @param @return    设定文件  283 	* @return List<? extends Object>    返回类型  284 	* @throws  285 	 */
	public List<? extends Object> query(String sql, List obj,
			ObjectMapper mapper) {
		Object o = null;
		List<Object> list = new ArrayList<Object>();
		Connection conn = null;
		PreparedStatement pstmt = null;
		try {
			conn = JdbcBaseDaoImpl.getConnection();
			pstmt = conn.prepareStatement(sql);
			for (int i = 0; i < obj.size(); i++) {
				pstmt.setObject(i + 1, obj.get(i));
			}
			ResultSet rs = pstmt.executeQuery();
			while (rs.next()) {
				o = mapper.mapping(rs);
				list.add(o);
			}
		} catch (SQLException ex) {
			ex.printStackTrace();
		} finally {
			try {
				pstmt.close();
				conn.close();
			} catch (SQLException ex) {
				ex.printStackTrace();
			}
		}
		return list;
	}

     /**
      *
     * @Title: returnTableCount  319      * @Description: ( select count(*)from table 的总数据条数)  320      * @param @param table
     * @param @return    设定文件  322      * @return int    返回类型  323      * @throws  324       */
	public int returnTableCount(String table){
		String sql="select count(*) as counts from "+table+"";
		Connection conn = null;
		ResultSet resultSet = null;
		Statement pstmt = null;
		int count=0;
		try {
			conn = JdbcBaseDaoImpl.getConnection();
			pstmt = conn.createStatement();
			resultSet=pstmt.executeQuery(sql);
			if(resultSet.next()){
				count=resultSet.getInt("counts");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			try {
				resultSet.close();
				pstmt.close();
				conn.close();
			} catch (SQLException ex) {
				ex.printStackTrace();
			}
		}
		return count;

	}
	/**
	 *
	* @author   liujun<1136808529@qq.coom>
	* @date 2016-5-12 下午11:19:02  356 	* @version V1.0   357 	* @Title: Count  358 	* @Description: (
	 *  统计有多少记录
	 *)  361 	* @param @param sql
	* @param @return    设定文件  363 	* @return int    返回类型  364 	* @throws  365 	 */
	public long  Count(String sql){
		if(sql==null || sql==""){
			 return (long)0;
		}
		Connection conn = null;
		ResultSet resultSet = null;
		Statement pstmt = null;
		long count=0;
		try {
			conn = JdbcBaseDaoImpl.getConnection();
			pstmt = conn.createStatement();
			resultSet=pstmt.executeQuery(sql);
			if(resultSet.next()){
				count=resultSet.getInt("counts");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			try {
				resultSet.close();
				pstmt.close();
				conn.close();
			} catch (SQLException ex) {
				ex.printStackTrace();
			}
		}
		return count;

	}

	/**
	 *
	 * @Title: findSimpleResult  获取最后一条（单条）记录
	 * @Description: (查询单条记录)  400 	 * @param @param sql
	 * @param @param params
	 * @param @return    设定文件  403 	 * @return Map<String,Object>    返回类型  404 	 * @throws  405 	 */
	public Map<String, Object> findSimpleResult(String sql, List<Object> params) {
		Map<String, Object> map = new HashMap<String, Object>();
		Connection connection = null;
		PreparedStatement pstmt = null;
		ResultSet resultSet = null;
		int index = 1;
		try {
			connection = JdbcBaseDaoImpl.getConnection();
			pstmt = connection.prepareStatement(sql);
			if (params != null && !params.isEmpty()) {
				for (int i = 0; i < params.size(); i++) {
					pstmt.setObject(index++, params.get(i));
				}
			}
			resultSet = pstmt.executeQuery();// 返回查询结果
			ResultSetMetaData metaData = resultSet.getMetaData();
			int col_len = metaData.getColumnCount();
			while (resultSet.next()) {
			 	for (int i = 0; i < col_len; i++) {
					String cols_name = metaData.getColumnName( i +  1);
					Object cols_value = resultSet.getObject(cols_name);
					if (cols_value == null) {
						cols_value = "";
					}
					map.put(cols_name, cols_value);
			 	}
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			try {
				resultSet.close();
				pstmt.close();
				connection.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return map;
	}
	/**
	 * 获取结果集，并将结果放在List中
	 *
	 * @param sql
	 *            SQL语句
	 * @return List 结果集
	 */
	public List<Object> excuteQuery(String sql, Object[] params) {
		// 创建List
		List<Object> list = new ArrayList<Object>();
		Connection connection = null;
		ResultSet rs = null;
		// 创建ResultSetMetaData对象
		ResultSetMetaData rsmd = null;
		// 结果集列数
		int columnCount = 0;
		try {
			// 获得连接
			connection = JdbcBaseDaoImpl.getConnection();
			// 执行SQL获得结果集
			rs = executeQueryRS(sql, params);
			// 将ResultSet的结果保存到List中
			while (rs.next()) {
				rsmd = rs.getMetaData();
				// 获得结果集列数
				columnCount = rsmd.getColumnCount();
				Map<String, Object> map = new HashMap<String, Object>();
				for (int i = 1; i <= columnCount; i++) {
					map.put(rsmd.getColumnLabel(i), rs.getObject(i));
				}
				list.add(map);
			}
		} catch (SQLException e) {
			e.printStackTrace();
			System.out.println(e.getMessage());
		} finally {
			// 关闭所有资源
			try {
				rs.close();
				connection.close();
			} catch (Exception e) {
				e.printStackTrace();
			}

		}
		return list;
	}

	/**
	 * SQL 查询将查询结果直接放入ResultSet中
	 *
	 * @param sql
	 *            SQL语句
	 * @param params
	 *            参数数组，若没有参数则为null
	 * @return 结果集
	 */
	private ResultSet executeQueryRS(String sql, Object[] params) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		try {
			// 获得连接
			connection = JdbcBaseDaoImpl.getConnection();
			// 调用SQL
			preparedStatement = connection.prepareStatement(sql);
			// 参数赋值
			if (params != null) {
				for (int i = 0; i < params.length; i++) {
					preparedStatement.setObject(i + 1, params[i]);
				}
			}
			// 执行
			resultSet = preparedStatement.executeQuery();

		} catch (SQLException e) {
			System.out.println(e.getMessage());
		} finally {
			try {
				resultSet.close();
				preparedStatement.close();
				connection.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}

		return resultSet;
	}

	/**
	 *
	 * @Title: findModeResult  查询多条记录
	 * @Description: (查询多条记录)  540 	 * @param @param sql
	 * @param @param params
	 * @param @return
	 * @param @throws SQLException    设定文件  544 	 * @return List<Map<String,Object>>    返回类型  545 	 * @throws  546 	 */
	public List<Map<String, Object>> findModeResult(String sql,
			List<Object> params) {
		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
		Connection connection = null;
		PreparedStatement pstmt = null;
		ResultSet resultSet = null;
		int index = 1;
		try {
			connection = JdbcBaseDaoImpl.getConnection();
			pstmt = connection.prepareStatement(sql);
			if (params != null && !params.isEmpty()) {
				for (int i = 0; i < params.size(); i++) {
					pstmt.setObject(index++, params.get(i));
				}
			}
			resultSet = pstmt.executeQuery();
			ResultSetMetaData metaData = resultSet.getMetaData();
			int cols_len = metaData.getColumnCount();
			while (resultSet.next()) {
				Map<String, Object> map = new HashMap<String, Object>();
				for (int i = 0; i < cols_len; i++) {
					String cols_name = metaData.getColumnName(i + 1);
					Object cols_value = resultSet.getObject(cols_name);
					if (cols_value == null) {
						cols_value = "";
					}
					map.put(cols_name, cols_value);
				}
				list.add(map);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			try {
				resultSet.close();
				pstmt.close();
				connection.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}

		return list;
	}

	/**
	 * SQL 查询将查询结果：一行一列
	 *
	 * @param sql
	 *            SQL语句
	 * @param params
	 *            参数数组，若没有参数则为null
	 * @return 结果集
	 */
	public Object executeQuerySingle(String sql, Object[] params) {
		Object object = null;
		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		try {
			// 获得连接
			connection = JdbcBaseDaoImpl.getConnection();
			// 调用SQL
			preparedStatement = connection.prepareStatement(sql);
			// 参数赋值
			if (params != null) {
				for (int i = 0; i < params.length; i++) {
					preparedStatement.setObject(i + 1, params[i]);
				}
			}
			// 执行
			resultSet = preparedStatement.executeQuery();
			if (resultSet.next()) {
				object = resultSet.getObject(1);
			}
		} catch (SQLException e) {
			System.out.println(e.getMessage());
		} finally {
			close(connection, preparedStatement, resultSet);
		}
		return object;
	}



	/**
	 *
	 * @Title: findSimpleRefResult  通过反射机制查询单条记录
	 * @Description: (通过反射机制查询单条记录)  636 	 * @param @param sql
	 * @param @param params
	 * @param @param cls
	 * @param @return
	 * @param @throws Exception    设定文件  641 	 * @return T    返回类型  642 	 * @throws  643 	 */
	public   <T> T findSimpleRefResult(String sql, List<Object> params,
			Class<T> cls) {
		T resultObject = null;
		Connection connection = null;
		PreparedStatement pstmt = null;
		ResultSet resultSet = null;
		int index = 1;
		try {
			connection = JdbcBaseDaoImpl.getConnection();
			pstmt = connection.prepareStatement(sql);
			if (params != null && !params.isEmpty()) {
				for (int i = 0; i < params.size(); i++) {
					pstmt.setObject(index++, params.get(i));
				}
			}
			resultSet = pstmt.executeQuery();
			ResultSetMetaData metaData = resultSet.getMetaData();
			int cols_len = metaData.getColumnCount();
			while (resultSet.next()) {
				// 通过反射机制创建一个实例
				resultObject = cls.newInstance();
				for (int i = 0; i < cols_len; i++) {
					String cols_name = metaData.getColumnName(i + 1);
					Object cols_value = resultSet.getObject(cols_name);
					if (cols_value == null) {
						cols_value = "";
					}
					Field field = cls.getDeclaredField(cols_name);
					field.setAccessible(true); // 打开javabean的访问权限
					field.set(resultObject, cols_value);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				resultSet.close();
				pstmt.close();
				connection.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return resultObject;

	}

	/**
	 * 通过反射机制查询多条记录
	 *
	 * @param sql
	 * @param params
	 * @param cls
	 * @return
	 * @throws Exception
	 */
	public <T> List<T> findMoreRefResult(String sql, List<Object> params,
			Class<T> cls) {
		List<T> list = new ArrayList<T>();
		Connection connection = null;
		PreparedStatement pstmt = null;
		ResultSet resultSet = null;
		int index = 1;
		try {
			connection = JdbcBaseDaoImpl.getConnection();
			pstmt = connection.prepareStatement(sql);
			if (params != null && !params.isEmpty()) {
				for (int i = 0; i < params.size(); i++) {
					pstmt.setObject(index++, params.get(i));
				}
			}
			resultSet = pstmt.executeQuery();
			ResultSetMetaData metaData = resultSet.getMetaData();
			int cols_len = metaData.getColumnCount();
			while (resultSet.next()) {
				// 通过反射机制创建一个实例
				T resultObject = cls.newInstance();
				for (int i = 0; i < cols_len; i++) {
					String cols_name = metaData.getColumnName(i + 1);
					Object cols_value = resultSet.getObject(cols_name);
					if (cols_value == null) {
						cols_value = "";
					}
					Field field = cls.getDeclaredField(cols_name);
					field.setAccessible(true); // 打开javabean的访问权限
					field.set(resultObject, cols_value);
				}
				list.add(resultObject);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				resultSet.close();
				pstmt.close();
				connection.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}

		}
		return list;
	}

	/**
	 *
	 * @Title: find  751 	 * @Description: (查询一条记录)  752 	 * @param @param sql
	 * @param @param obj
	 * @param @param mapper
	 * @param @return    设定文件  756 	 * @return Object    返回类型  757 	 * @throws  758 	 */
	public Object find(String sql, Object[] obj, ObjectMapper mapper) {
		Object o = null;
		Connection conn = null;
		PreparedStatement pstmt = null;
		try {
			conn = JdbcBaseDaoImpl.getConnection();
			pstmt = conn.prepareStatement(sql);
			for (int i = 0; i < obj.length; i++) {
				pstmt.setObject(i + 1, obj[i]);
				ResultSet rs = pstmt.executeQuery();
				if (rs.next()) {
					o = mapper.mapping(rs);
				}
			}
		} catch (Exception ex) {
			ex.printStackTrace();
		} finally {
			try {
				pstmt.close();
				conn.close();
			} catch (SQLException ex) {
				ex.printStackTrace();
			}
		}
		return o;
	}
	/**
	 *
	* @author   liujun<1136808529@qq.coom>
	* @date 2016-5-14 下午1:17:28  789 	* @version V1.0   790 	* @Title: find  791 	* @Description: (
	 *  查询一条记录
	 *)  794 	* @param @param sql
	* @param @param obj
	* @param @param mapper
	* @param @return    设定文件  798 	* @return Object    返回类型  799 	* @throws  800 	 */
	public Object find(String sql, List obj, ObjectMapper mapper) {
		Object o = null;
		Connection conn = null;
		PreparedStatement pstmt = null;
		try {
			conn = JdbcBaseDaoImpl.getConnection();
			pstmt = conn.prepareStatement(sql);
			for (int i = 0; i < obj.size(); i++) {
				pstmt.setObject(i + 1, obj.get(i));
				ResultSet rs = pstmt.executeQuery();
				if (rs.next()) {
					o = mapper.mapping(rs);
				}
			}
		} catch (Exception ex) {
			ex.printStackTrace();
		} finally {
			try {
				pstmt.close();
				conn.close();
			} catch (SQLException ex) {
				ex.printStackTrace();
			}
		}
		return o;
	}


	/**
	 *
	 * @Title: executeQuery  统一的select语句，为了能够访问结果集，将结果集放入ArrayList，这样可以直接关闭资源
	 * @Description: (统一的select语句，为了能够访问结果集，将结果集放入ArrayList，这样可以直接关闭资源)  833 	 * @param @param sql
	 * @param @param parameters
	 * @param @return    设定文件  836 	 * @return ArrayList    返回类型  837 	 * @throws  838 	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public ArrayList executeQuery(String sql, String[] parameters) {
		ArrayList results = new ArrayList();
		// 定义需要的变量
		Connection conn = null;
		PreparedStatement ps = null;
		ResultSet rs = null;

		try {
			// 获得连接
			conn = JdbcBaseDaoImpl.getConnection();
			ps = conn.prepareStatement(sql);

			if (parameters != null) {
				for (int i = 0; i < parameters.length; i++) {
					ps.setString(i + 1, parameters[i]);
				}
			}
			rs = ps.executeQuery();
			ResultSetMetaData rsmd = rs.getMetaData();
			int column = rsmd.getColumnCount();
			while (rs.next()) {
				Object[] objects = new Object[column];
				for (int i = 1; i <= column; i++) {
					objects[i - 1] = rs.getObject(i);
				}
				results.add(objects);
			}
		} catch (SQLException e) {
			e.printStackTrace();
			throw new RuntimeException(e.getMessage());
		} finally {
			try {
				rs.close();
				ps.close();
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return results;
	}


	/**
	 *
	 * @Title: executeQuery  by statement
	 * @Description: (执行 查询sql 获取结果集)  887 	 * @param @param sql
	 * @param @return statement resultSet
	 * @param @throws SQLException    设定文件  890 	 * @return ResultSet    返回类型  891 	 * @throws  892 	 */
	public ResultSet executeQuery(String sql) {
		Statement statement = null;
		ResultSet resultSet = null;
		Connection connection = null;
		try {
			connection = getStatement();
			if (resultSet != null && resultSet.isClosed() == false) {
				resultSet.close();
			}
			resultSet = null;
			resultSet = statement.executeQuery(sql);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {

		}
		return resultSet;
	}


	//-------------------------------------------对象化---------------
	  /**
     * 将一条记录转成一个对象
     *
     * @param cls
     *            泛型类型
     * @param rs
     *            ResultSet对象
     * @return 泛型类型对象
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws SQLException
     */
    private static <T> T executeResultSet(Class<T> cls, ResultSet rs)
            throws InstantiationException, IllegalAccessException, SQLException {
        T obj = cls.newInstance();
        ResultSetMetaData rsm = rs.getMetaData();
        int columnCount = rsm.getColumnCount();
        // Field[] fields = cls.getFields();
        Field[] fields = cls.getDeclaredFields();
        for (int i = 0; i < fields.length; i++) {
            Field field = fields[i];
            String fieldName = field.getName();
            for (int j = 1; j <= columnCount; j++) {
                String columnName = rsm.getColumnName(j);
                if (fieldName.equalsIgnoreCase(columnName)) {
                    Object value = rs.getObject(j);
                    field.setAccessible(true);
                    field.set(obj, value);
                    break;
                }
            }
        }
        return obj;
    }



	/**
	 *
	* @author   liujun<1136808529@qq.coom>
	* @date 2016-5-17 上午11:33:28  955 	* @version V1.0   956 	* @Title: getSeq  957 	* @Description:  (
	 *  获取sequence 序列号
	 *)  960 	* @param @param sequenceName
	* @param @return    设定文件  962 	* @return int    返回类型  963 	* @throws  964 	 */
    public   int getSeq(String sequenceName){
		 int count = 0;
		  Connection conn = getConnection();
		  String sql = "SELECT nextval('"+sequenceName+"');";
		  PreparedStatement ptmt = null;
		  ResultSet rs = null;
		  try {
		    ptmt = conn.prepareStatement(sql);
		    rs = ptmt.executeQuery();
		    while (rs.next()) {
		      count = rs.getInt(1);
		    }
		    System.out.println(count);
		  } catch (SQLException e) {
		    e.printStackTrace();
		  } finally {
			  try {
				  rs.close();
				  ptmt.close();
				  conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}

		  }

		return count;
	}






//----------------------存储过程调用-------------------------------------------


	/**
	 * 存储过程带有一个输出参数的方法
	 *
	 * @param sql
	 *            存储过程语句
	 * @param params
	 *            参数数组
	 * @param outParamPos
	 *            输出参数位置
	 * @param SqlType
	 *            输出参数类型
	 * @return 输出参数的值
	 */
	public Object executeQuery(String sql, Object[] params, int outParamPos,
			int SqlType) {
		Connection connection = null;
		Statement statement = null;
		Object object = null;
		CallableStatement callableStatement = null;
		try {
			connection = JdbcBaseDaoImpl.getConnection();
			// 调用存储过程
			callableStatement = connection.prepareCall(sql);
			// 给参数赋值
			if (params != null) {
				for (int i = 0; i < params.length; i++) {
					callableStatement.setObject(i + 1, params[i]);
				}
			}
			// 注册输出参数
			callableStatement.registerOutParameter(outParamPos, SqlType);
			// 执行
			callableStatement.execute();
			// 得到输出参数
			object = callableStatement.getObject(outParamPos);
		} catch (SQLException e) {
			System.out.println(e.getMessage());
		} finally {
			// 释放资源
			closeAll(connection, null, callableStatement, null);
		}
		return object;
	}

    /**
     * 执行不返回结果集的存储过程
     *
     * @param sql
     *            存储过程名称
     * @param params
     *            存储过程参数
     * @throws ClassNotFoundException
     * @throws SQLException
     */
    public   void executeNonQuery(String sql, SqlParameter... params) {
        Connection con = null;
        CallableStatement cs = null;
        try {
            con = getConnection();
            cs = con.prepareCall(sql);
            setSqlParameter(cs, params);
            cs.executeUpdate();
            getSqlParameter(cs, params);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
        	close3(con, cs, null);
        }
    }

    /**
     * 执行Insert语句，返回Insert成功之后标识列的值
     *
     * @param sql
     * @return
     * @throws ClassNotFoundException
     * @throws SQLException
     */
    public   int executeIdentity(String sql) {
        int identity = -1;
        Connection con = null;
        Statement ps = null;
        ResultSet rs = null;
        try {
            con = getConnection();
            ps = con.createStatement();
            ps.executeUpdate(sql, Statement.RETURN_GENERATED_KEYS);
            rs = ps.getGeneratedKeys();
            if (rs.next()) {
                // identity = rs.getInt("GENERATED_KEYS");
                identity = rs.getInt(1);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            close3(con, ps, null);
        }
        return identity;
    }
    /**
     * 执行不返回结果集的存储过程
     *
     * @param sql
     *            存储过程名称
     * @param params
     *            存储过程参数
     * @throws ClassNotFoundException
     * @throws SQLException
     */
    public   void executeNonQuery1(String sql, SqlParameter... params) {
        Connection con = null;
        CallableStatement cs = null;
        try {
            con = getConnection();
            cs = con.prepareCall(sql);
            setSqlParameter(cs, params);
            cs.executeUpdate();
            getSqlParameter(cs, params);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            close3(con, cs, null);
        }
    }
    /**
     * 执行返回聚合函数的操作
     *
     * @param sql
     *            含有聚合函数的SQL语句
     * @return 聚合函数的执行结果
     * @throws SQLException
     * @throws ClassNotFoundException
     */
    public   int executeScalar(String sql) {
        int result = -1;
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            con = getConnection();
            ps = con.prepareStatement(sql);
            rs = ps.executeQuery();
            if (rs.next()) {
                result = rs.getInt(1);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            close3(con, ps, rs);
        }
        return result;
    }
    /**
     * 执行返回泛型集合的SQL语句
     *
     * @param cls
     *            泛型类型
     * @param sql
     *            查询SQL语句
     * @return 泛型集合
     * @throws ClassNotFoundException
     * @throws SQLException
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
    public   <T> List<T> executeList(Class<T> cls, String sql) {
        List<T> list = new ArrayList<T>();
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            con = getConnection();
            ps = con.prepareStatement(sql);
            rs = ps.executeQuery();
            while (rs.next()) {
                T obj = executeResultSet(cls, rs);
                list.add(obj);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            close3(con, ps, rs);
        }
        return list;
    }
    /**
     * 执行返回泛型集合的存储过程
     *
     * @param cls
     *            泛型类型
     * @param sql
     *            存储过程名称
     * @param params
     *            存储过程参数
     * @return 泛型集合
     * @throws ClassNotFoundException
     * @throws SQLException
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
    public   <T> List<T> executeList(Class<T> cls, String sql,
            SqlParameter... params) {
        List<T> list = new ArrayList<T>();
        Connection con = null;
        CallableStatement cs = null;
        ResultSet rs = null;
        try {
            con = getConnection();
            cs = con.prepareCall(sql);
            setSqlParameter(cs, params);
            rs = cs.executeQuery();
            while (rs.next()) {
                T obj = executeResultSet(cls, rs);
                list.add(obj);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            close3(con, cs, rs);
        }
        return list;
    }
    /**
     * 执行返回泛型类型对象的SQL语句
     *
     * @param cls
     *            泛型类型
     * @param sql
     *            SQL语句
     * @return 泛型类型对象
     * @throws SQLException
     * @throws ClassNotFoundException
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
    public   <T> T executeEntity(Class<T> cls, String sql) {
        T obj = null;
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            con = getConnection();
            ps = con.prepareStatement(sql);
            rs = ps.executeQuery();
            while (rs.next()) {
                obj = executeResultSet(cls, rs);
                break;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            close3(con, ps, rs);
        }
        return obj;
    }
    /**
     * 执行返回泛型类型对象的存储过程
     *
     * @param cls
     *            泛型类型
     * @param sql
     *            SQL语句
     * @param params
     *            存储过程参数
     * @return 泛型类型对象
     * @throws SQLException
     * @throws ClassNotFoundException
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
    public   <T> T executeEntity(Class<T> cls, String sql,
            SqlParameter... params) {
        T obj = null;
        Connection con = null;
        CallableStatement cs = null;
        ResultSet rs = null;
        try {
            con = getConnection();
            cs = con.prepareCall(sql);
            setSqlParameter(cs, params);
            rs = cs.executeQuery();
            while (rs.next()) {
                obj = executeResultSet(cls, rs);
                break;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            close3(con, cs, rs);
        }
        return obj;
    }

    /**
     * 设置存储过程参数名称，参数值，参数方向
     *
     * @param cs
     * @param params
     * @throws SQLException
     */
    private   void setSqlParameter(CallableStatement cs,
            SqlParameter... params) throws SQLException {
        if (params != null) {
            for (SqlParameter param : params) {
                if (param.OutPut) {
                    String paramName = param.Name;
                    if (paramName == null || paramName.equals("")) {
                        cs.registerOutParameter(1, param.Type);// 设置返回类型参数
                    } else {
                        cs.registerOutParameter(paramName, param.Type);// 设置输出类型参数
                    }
                } else {
                    cs.setObject(param.Name, param.Value);// 设置输入类型参数
                }
            }
        }
    }
    /**
     * 得到存储过程参数执行结果
     *
     * @param cs
     * @param params
     * @throws SQLException
     */
    private   void getSqlParameter(CallableStatement cs,
            SqlParameter... params) throws SQLException {
        for (SqlParameter param : params) {
            if (param.OutPut) {
                String paramName = param.Name;
                if (paramName == null || paramName.equals("")) {
                    param.Value = cs.getObject(1);// 返回类型参数值
                } else {
                    param.Value = cs.getObject(paramName);// 输出类型参数值
                }
            }
        }
    }

	/**
	 *
	 * @Title: executeUpdate  by statement
	 * @Description: (更新结果集)  1344 	 * @param @param sql
	 * @param @return
	 * @param @throws SQLException    设定文件  1347 	 * @return int    返回类型  1348 	 * @throws  1349 	 */
	@SuppressWarnings("null")
	public int executeUpdate(String sql) {
		Statement statement = null;
		Connection connection = null;
		int result = 0;
		try {
			connection = getStatement();
			result = statement.executeUpdate(sql);
			connection.commit();//JDBC 事务管理
		} catch (Exception e) {
			e.printStackTrace();
			try {
				connection.rollback();//JDBC 事务管理
			} catch (SQLException e1) {
				e1.printStackTrace();
			}
		} finally {
			try {
				statement.close();
				connection.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}

		}
		return result;
	}





	//-----------------------资源关闭---------------------------------------------
	/**
	 * 关闭所有资源
	 *
	 * @param statement
	 */
	private void closeAll(Connection connection,
			PreparedStatement preparedStatement,
			CallableStatement callableStatement, ResultSet resultSet) {
		// 关闭结果集对象
		if (resultSet != null) {
			try {
				resultSet.close();
			} catch (SQLException e) {
				System.out.println(e.getMessage());
			}
		}

		// 关闭PreparedStatement对象
		if (preparedStatement != null) {
			try {
				preparedStatement.close();
			} catch (SQLException e) {
				System.out.println(e.getMessage());
			}
		}

		// 关闭CallableStatement 对象
		if (callableStatement != null) {
			try {
				callableStatement.close();
			} catch (SQLException e) {
				System.out.println(e.getMessage());
			}
		}

		// 关闭Connection 对象
		if (connection != null) {
			try {
				connection.close();
			} catch (SQLException e) {
				System.out.println(e.getMessage());
			}
		}
	}

	/**
	 *
	 * @Title: close  1431 	 * @Description: (关闭所有的连接)  1432 	 * @param @throws SQLException    设定文件  1433 	 * @return void    返回类型  1434 	 * @throws  1435 	 */
	public void close(Connection connection, Statement statement,
			ResultSet resultSet) {
		try {
			if (resultSet != null) {
				resultSet.close();
				resultSet = null;
			}
			if (statement != null) {
				statement.close();
				statement = null;
			}
			if (connection != null) {
				connection.close();
				connection = null;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	 /**
     * 关闭JDBC对象，释放资源。
     *
     * @param con
     *            连接对象
     * @param ps
     *            命令对象
     * @param rs
     *            结果集对象
     * @throws SQLException
     */
    private static void close3(Connection con, Statement ps, ResultSet rs) {
        try {
            rs.close();
            if (rs != null) {

                rs = null;
            }
            if (ps != null) {
                ps.close();
                ps = null;
            }
            if (con != null) {
                con.close();
                con = null;
            }
        } catch (SQLException e) {
            //  Auto-generated catch block
            e.printStackTrace();
        }
    }

	  //--------------------main 方法----------------------------------------------
		/**
		 * 测试 连接是否成功
		 *
		 * @param args
		 */
		public static void main(String[] args) {
			getConnection();
		}


}

JdbcDaoImpl.java

package com.jacezhu.dao.impl;

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

import com.jacezhu.dao.JdbcBaseDao;
import com.jacezhu.dao.JdbcDao;
import com.jacezhu.framework.connectUtil.jdbcUtl.ObjectMapper;
import com.jacezhu.framework.connectUtil.jdbcUtl.PageModel;
import com.jacezhu.model.demo.vo.Demo;
import com.jacezhu.service.demo.impl.DemoMapper;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
@Repository
public class JdbcDaoImpl extends Object implements JdbcDao{
	@Autowired
    private   JdbcBaseDaoImpl jdbcBaseUtil =new JdbcBaseDaoImpl();

	public JdbcBaseDaoImpl getJdbcBaseUtil() {
		return jdbcBaseUtil;
	}
	public void setJdbcBaseUtil(JdbcBaseDaoImpl jdbcBaseUtil) {
		this.jdbcBaseUtil = jdbcBaseUtil;
	}
	/**
	 *
	* @Title: insert   30 	* @Description: (插入单挑数据)   31 	* @param @param sql 查询sql
	* @param @param obj 参数数组
	* @param @param isGenerateKey (true  false)
	* @param @return    设定文件   35 	* @return boolean    返回类型   36 	* @throws   37 	 */
	public boolean insert(String sql, Object[] obj){

		return jdbcBaseUtil.update(sql, obj, false);
	 }
	/**
	 *
	* @author  刘军
	* @date 2016-3-19 下午2:23:42   46 	* @version V1.0    47 	* @Title: insertLines   48 	* @Description: (新增)   49 	* @param @param sql
	* @param @param obj
	* @param @return    设定文件   52 	* @return int    返回类型   53 	* @throws   54 	 */
	public int insertLines(String sql, Object[] obj){

		return jdbcBaseUtil.executeUpdate(sql, obj);
	 }
	/**
	 *
	* @author  刘军
	* @date 2016-3-19 下午2:05:19   63 	* @version V1.0    64 	* @Title: insert   65 	* @Description: (新增)   66 	* @param @param sql
	* @param @param obj
	* @param @return    设定文件   69 	* @return boolean    返回类型   70 	* @throws   71 	 */
	public boolean insertByList(String sql, List<Object> obj){

		return jdbcBaseUtil.updateByPreparedStatement(sql, obj);
	 }

	/**
	 *
	* @Title: delete   80 	* @Description: (删除单挑数据)   81 	* @param @param sql 删除sql
	* @param @param obj 参数数组
	* @param @param isGenerateKey (true  false)
	* @param @return    设定文件   85 	* @return boolean    返回类型   86 	* @throws   87 	 */
	public boolean delete(String sql, Object[] obj){

		return jdbcBaseUtil.update(sql, obj, false);
	 }
	/**
	 *
	* @author  刘军
	* @date 2016-3-19 下午2:19:20   96 	* @version V1.0    97 	* @Title: delete   98 	* @Description: (删除单挑数据)   99 	* @param @param sql
	* @param @param obj
	* @param @return    设定文件  102 	* @return boolean    返回类型  103 	* @throws  104 	 */
	public boolean delete(String sql,List<Object> obj){

		return jdbcBaseUtil.updateByPreparedStatement(sql, obj);
	 }

	 /**
	  *
	 * @Title: deleteALL  113 	 * @Description: (批量删除数据)  114 	 * @param @param sql
	 * @param @param obj
	 * @param @return    设定文件  117 	 * @return boolean    返回类型  118 	 * @throws  119 	  */
	public boolean deleteALL(String sql, Object[] obj){
		StringBuffer sbStr = new StringBuffer();
		for (int i = 0; i < obj.length; i++) {
			sbStr.append("?,");
		}
		String sqls =sql+"("+ sbStr.substring(0, sbStr.length() - 1) + ")";
		return jdbcBaseUtil.update(sqls, obj, false);
	 }
	/**
	 *
	* @author  刘军
	* @date 2016-3-19 下午2:20:56  132 	* @version V1.0   133 	* @Title: deleteALL  134 	* @Description: (删除 批量删除 )  135 	* @param @param sql
	* @param @param obj
	* @param @return    设定文件  138 	* @return boolean    返回类型  139 	* @throws  140 	 */
	public boolean deleteALL(String sql,List<Object> obj){
		StringBuffer sbStr = new StringBuffer();
		for (int i = 0; i < obj.size(); i++) {
			sbStr.append("?,");
		}
		String sqls =sql+"("+ sbStr.substring(0, sbStr.length() - 1) + ")";
		return jdbcBaseUtil.updateByPreparedStatement(sqls, obj);
	 }
	 /**
	  *
	 * @Title: update  152 	 * @Description: (更新单挑数据记录)  153 	 * @param @param sql
	 * @param @param obj
	 * @param @return    设定文件  156 	 * @return boolean    返回类型  157 	 * @throws  158 	  */
	public boolean update(String sql, Object[] obj){

		return jdbcBaseUtil.update(sql, obj, false);
	 }
	/**
	 *
	* @author  刘军
	* @date 2016-3-19 下午2:21:45  167 	* @version V1.0   168 	* @Title: update  169 	* @Description: (修改 )  170 	* @param @param sql
	* @param @param obj
	* @param @return    设定文件  173 	* @return boolean    返回类型  174 	* @throws  175 	 */
	public boolean update(String sql, List<Object> obj){

		return jdbcBaseUtil.updateByPreparedStatement(sql, obj);
	 }
	 /**
	  *
	 * @Title: queryFrist  183 	 * @Description: (查询出第一条数据记录)  184 	 * @param @param tale
	 * @param @param objParams
	 * @param @return    设定文件  187 	 * @return Object    返回类型  188 	 * @throws  189 	  */
	 public Object queryFrist(String tale,Object[] objParams,ObjectMapper mapper){

		 String sql = "select * from "+tale+"";
			Object[] obj = objParams;
		   return (Object) query(sql, obj, mapper).get(0);
	 }
	 /**
	  *
	 * @author  刘军
	 * @date 2016-3-19 上午9:41:06  200 	 * @version V1.0   201 	 * @Title: find  202 	 * @Description: (查询一条记录 )  203 	 * @param @param sql
	 * @param @param obj
	 * @param @param mapper
	 * @param @return    设定文件  207 	 * @return Object    返回类型  208 	 * @throws  209 	  */
	 public	 Object find(String sql, Object[] obj, ObjectMapper mapper){
		return jdbcBaseUtil. find( sql,  obj,  mapper) ;

	 }

	 /**
	  *
	 * @author  刘军
	 * @date 2016-3-19 上午9:41:06  219 	 * @version V1.0   220 	 * @Title: find  221 	 * @Description: (查询一条记录 )  222 	 * @param @param sql
	 * @param @param obj
	 * @param @param mapper
	 * @param @return    设定文件  226 	 * @return Object    返回类型  227 	 * @throws  228 	  */
	 public Object find(String sql,List obj,ObjectMapper mapper){

		 return jdbcBaseUtil. find( sql,  obj,  mapper) ;
	 }
	/**
	 *
	* @Title: query  236 	* @Description: ( 查询所有的数据记录；并以list 集合(或者：Object 对象)返回 )  237 	* @param @param sql
	* @param @param obj
	* @param @param mapper
	* @param @return    设定文件  241 	* @return List<? extends Object>    返回类型  242 	* @throws  243 	 */
	public List<? extends Object> query(String sql, Object[] obj,
			ObjectMapper mapper) {

		 return jdbcBaseUtil.query(sql, obj, mapper);
	}
	/**
	 *
	* @author   liujun<1136808529@qq.coom>
	* @date 2016-5-12 下午1:55:08  253 	* @version V1.0   254 	* @Title: query  255 	* @Description: (
	 *查询所有的数据记录；并以list 集合(或者：Object 对象)返回
	 *)  258 	* @param @param sql
	* @param @param obj
	* @param @param mapper
	* @param @return    设定文件  262 	* @return List<? extends Object>    返回类型  263 	* @throws  264 	 */
	public List<? extends Object> query(String sql, List obj,
			ObjectMapper mapper) {

		 return jdbcBaseUtil.query(sql, obj, mapper);
	}
	/**
	 *
	* @Title: CountNum  273 	* @Description: ( select count(*)from table 的总数据条数)
	* @param @param tableName (数据库表名)
	* @param @return    设定文件  276 	* @return int    返回类型  277 	* @throws  278 	 */
	public int CountNum (String tableName){
		return jdbcBaseUtil.returnTableCount(tableName);
	}

	/**
	 *
	* @author   liujun<1136808529@qq.coom>
	* @date 2016-5-12 下午11:19:59  287 	* @version V1.0   288 	* @Title: Count  289 	* @Description: (
	 * 返回 统计count 数据的数量
	 *)  292 	* @param @param sql
	* @param @return    设定文件  294 	* @return int    返回类型  295 	* @throws  296 	 */
	public long  Count(String sql){
		return jdbcBaseUtil.Count(sql);
	};
	/**
	 *
	* @Title: queryPageNumber  303 	* @Description: (分页查询)  304 	* @param @param pageNo 第几页
	* @param @param pageSize  一页显示多少条数据
	* @param @param table  查询哪个表
	* 全表无条件查询
	*  {select * from （ tablea a,tableb b where a.id=b.id）limt numStrat,numStop}
	* 全表 带条件模糊查询：
	*SELECT * FROM  demo a ,demo b WHERE a.id=b.id AND  a.id LIKE "1%" LIMIT 0,15;
	* @param @return    设定文件  312 	* @return PageModel    返回类型  313 	* @throws  314 	 */
	public PageModel queryPageNumber(int pageNo, int pageSize,String table) {
		//oracle  分页
		//String sql="select * from (select j.*,rownum rn from (select * from "+table+") j where rownum<=?) where rn>?";
		//mysql  分页
		String sql="SELECT * FROM "+table+" LIMIT ?,?;";
		return  queryPageNumber( pageNo, pageSize, table, sql);

	}


	@SuppressWarnings({ "rawtypes", "unchecked" })
	public PageModel queryPageNumber(int pageNo, int pageSize,String table,String sql) {
		int countTotal=CountNum(table);
		Object[] obj = {(pageNo - 1) * pageSize,  pageNo * pageSize};
		List<Demo> list = (List<Demo>) query(sql, obj,new DemoMapper());
		PageModel pagemodel = new PageModel();
		pagemodel.setPageNo(pageNo);
		pagemodel.setPageSize(pageSize);
		pagemodel.setList(list);
		pagemodel.setTotalRecords(countTotal);
		if(pageSize!=0){
		 pagemodel.setCountPageNo(countTotal/pageSize);
		}
		return pagemodel;

	}
	/**
	 *
	 * @Title: findSimpleResult  获取最后一条（单条）记录
	 * @Description: (查询单条记录)  345 	 * @param @param sql
	 * @param @param params
	 * @param @return    设定文件  348 	 * @return Map<String,Object>    返回类型  349 	 * @throws  350 	 */
	public Map<String, Object> findSimpleResult(String sql, List<Object> params){

		return jdbcBaseUtil.findSimpleResult(sql, params);
	}
	/**
	 *
	* @author  刘军
	* @date 2016-3-19 上午12:30:02  359 	* @version V1.0   360 	* @Title: findModeResult  查询多条记录
	* @Description: (查询多条记录)  362 	* @param @param sql
	* @param @param params
	* @param @return    设定文件  365 	* @return List<Map<String,Object>>    返回类型  366 	* @throws  367 	 */
	public List<Map<String, Object>> findModeResult(String sql,	List<Object> params){
		return jdbcBaseUtil.findModeResult(sql,params);
	}
	/**
	 *
	* @author  刘军
	* @date 2016-3-19 上午8:43:07  375 	* @version V1.0   376 	* @Title: executeQuerySingle  377 	* @Description: (SQL 查询将查询结果：一行一列)  378 	* @param @param sql
	* @param @param params
	* @param @return    设定文件  381 	* @return Object    返回类型  382 	* @throws  383 	 */
	public Object executeQuerySingle(String sql, Object[] params){
		return jdbcBaseUtil.executeQuerySingle(sql, params);
	}

	/**
	 *
	* @author  刘军
	* @date 2016-3-19 上午9:08:05  392 	* @version V1.0   393 	* @Title: findSimpleRefResult  394 	* @Description: (通过反射机制查询单条记录)  395 	* @param @param sql
	* @param @param params
	* @param @param cls
	* @param @return    设定文件  399 	* @return T    返回类型  400 	* @throws  401 	 */
	public <T> T findSimpleRefResult(String sql, List<Object> params,Class<T> cls) {

		//return  JdbcBaseUtil.findSimpleRefResult(sql,  params, cls);
		return null;
	}
	/**
	 *
	* @author  刘军
	* @date 2016-3-19 上午9:13:39  411 	* @version V1.0   412 	* @Title: findMoreRefResult  413 	* @Description: ( 通过反射机制查询多条记录)  414 	* @param @param sql
	* @param @param params
	* @param @param cls
	* @param @return    设定文件  418 	* @return List<T>    返回类型  419 	* @throws  420 	 */
	public <T> List<T> findMoreRefResult(String sql, List<Object> params,
			Class<T> cls) {
		return jdbcBaseUtil.findMoreRefResult(sql, params, cls);
	}
	/**
	 *
	* @author  刘军
	* @date 2016-3-19 上午11:03:06  429 	* @version V1.0   430 	* @Title: excuteQuery  431 	* @Description: (获取结果集，并将结果放在List中)  432 	* @param @param sql
	* @param @param params
	* @param @return    设定文件  435 	* @return List<Object>    返回类型  436 	* @throws  437 	 */
	public List<Object> excuteQuery(String sql, Object[] params){
		return jdbcBaseUtil.excuteQuery( sql,  params);
	}
	/**
	 *
	* @author  刘军
	* @date 2016-3-19 上午11:03:03  445 	* @version V1.0   446 	* @Title: executeQuery  447 	* @Description: (统一的select语句，为了能够访问结果集，将结果集放入ArrayList，)  448 	* @param @param sql
	* @param @param parameters
	* @param @return    设定文件  451 	* @return ArrayList    返回类型  452 	* @throws  453 	 */
	public ArrayList executeQuery(String sql, String[] parameters){
		return jdbcBaseUtil.executeQuery( sql,  parameters);
	}

	/**
	 *
	* @author   liujun<1136808529@qq.coom>
	* @date 2016-5-17 上午11:33:28  462 	* @version V1.0   463 	* @Title: getSeq  464 	* @Description:  (
	 *  获取sequence 序列号
	 *)  467 	* @param @param sequenceName
	* @param @return    设定文件  469 	* @return int    返回类型  470 	* @throws  471 	 */
	public int getSeq(String sequenceName){
		return jdbcBaseUtil.getSeq(sequenceName);
	}
}

六：实例参考

控制层顶层：BaseController.java

package com.jacezhu.controller.base;

import java.text.SimpleDateFormat;
import java.util.Date;

import com.jacezhu.framework.utils.StringEscapeEditor;

import org.springframework.beans.propertyeditors.CustomDateEditor;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.ServletRequestDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/base")
public class BaseController {

	protected int page = 1;// 当前页
	protected int rows = 10;// 每页显示记录数
	protected String sort;// 排序字段
	protected String order = "asc";// asc/desc

	protected String ids;// 主键集合，逗号分割

	@InitBinder
	public void initBinder(ServletRequestDataBinder binder) {
		/**
		 * 自动转换日期类型的字段格式
		 */
		binder.registerCustomEditor(Date.class, new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"), true));

		/**
		 * 防止XSS攻击
		 */
		binder.registerCustomEditor(String.class, new StringEscapeEditor(true, false));
	}

	/**
	 * 用户跳转JSP页面
	 *
	 * 此方法不考虑权限控制
	 * produces = "text/html;charset=UTF-8"
	 * @param folder
	 *            路径
	 * @param jspName
	 *            JSP名称(不加后缀)
	 * @return 指定JSP页面
	 */
	@RequestMapping("/{folder}/{jspName}")
	public String redirectJsp(@PathVariable String folder, @PathVariable String jspName) {
		return "/" + folder + "/" + jspName;
	}

}

控制层实现层：StudentinfoController.java

package com.jacezhu.controller.businessCore.CustomerManagement;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.jacezhu.controller.base.BaseController;
import com.jacezhu.framework.utils.BeanUtil.dateUtils.DateUtils;
import com.jacezhu.model.base.pageModel.Grid;
import com.jacezhu.model.base.pageModel.Json;
import com.jacezhu.model.base.pageModel.PageFilter;
import com.jacezhu.model.businessCore.CustomerManagement.TStudentinfo;
import com.jacezhu.model.businessCore.CustomerManagement.vo.StudentInfo;
import com.jacezhu.service.businessCore.CustomerManagement.StudentinfoServiceI;
/**
 *
* @Title: StudentinfoController.java   22 * @Package com.jacezhu.controller.businessCore.CustomerManagement   23 * @Description: ( 客户管理：学生信息管理)   24 * @author  刘军
* @date 2016-3-20 下午3:59:30   26 * @version V1.0    27  */
@Controller
@RequestMapping("/studentinfo")
public class StudentinfoController extends BaseController{
	@Autowired
	private StudentinfoServiceI studentinfoServiceI;

	@RequestMapping("/manager")
	public String manager() {
		return "/businessCore/customer/student";
	}
    /**
     *
    * @author  刘军
    * @date 2016-3-20 下午10:56:25   42     * @version V1.0    43     * @Title: dataGrid   44     * @Description: (获取列表数据： )   45     * @param @param studentInfo
    * @param @param ph
    * @param @return    设定文件   48     * @return Grid    返回类型   49     * @throws   50      */
	@RequestMapping("/dataGrid")
	@ResponseBody
	public Grid dataGrid(StudentInfo studentInfo, PageFilter ph) {
		Grid grid = new Grid();
		grid.setRows(studentinfoServiceI.dataGrid(studentInfo, ph));
		grid.setTotal(studentinfoServiceI.count(studentInfo, ph));
		return grid;
	}
	//------------start----学生签到管理：查询学生信息-------------------------------
	 /**
	  *
	 * @author   liujun<1136808529@qq.coom>
	 * @date 2016-5-11 下午5:27:42   64 	 * @version V1.0    65 	 * @Title: dataGridToReport   66 	 * @Description: (
	  * 查询未签到的学生信息
	  *)   69 	 * @param @param studentInfo
	 * @param @param ph
	 * @param @return    设定文件   72 	 * @return Grid    返回类型   73 	 * @throws   74 	  */
	@RequestMapping("/dataGridToReport")
	@ResponseBody
	public Grid dataGridToReport(StudentInfo studentInfo, PageFilter ph) {
		Grid grid = new Grid();
		grid.setRows(studentinfoServiceI.dataGridToReport(studentInfo, ph));
		grid.setTotal(studentinfoServiceI.countToReport(studentInfo, ph));
		return grid;
	}
	/**
	 *
	* @author   liujun<1136808529@qq.coom>
	* @date 2016-5-11 下午5:29:16   87 	* @version V1.0    88 	* @Title: dataGridIsReported   89 	* @Description: (
	 * 已经签到的学生信息
	 *)   92 	* @param @param studentInfo
	* @param @param ph
	* @param @return    设定文件   95 	* @return Grid    返回类型   96 	* @throws   97 	 */
	@RequestMapping("/dataGridIsReported")
	@ResponseBody
	public Grid dataGridIsReported(StudentInfo studentInfo, PageFilter ph) {
		Grid grid = new Grid();
		grid.setRows(studentinfoServiceI.dataGridIsReported(studentInfo, ph));
		grid.setTotal(studentinfoServiceI.countIsReported(studentInfo, ph));
		return grid;
	}
	//---------end-------学生签到管理：查询学生信息-------------------------------
    /**
     *
    * @author  刘军
    * @date 2016-3-20 下午11:01:23  111     * @version V1.0   112     * @Title: addPage  113     * @Description: (显示：添加页面)  114     * @param @return    设定文件  115     * @return String    返回类型  116     * @throws  117      */
	@RequestMapping("/addPage")
	public String addPage() {
		return "/businessCore/customer/studentInfoAdd";
	}
	@RequestMapping("/addStuInfo")
	@ResponseBody
	public Json add(StudentInfo studentInfo) {
		Json j = new Json();
		try {
			studentinfoServiceI.add(studentInfo);
			j.setSuccess(true);
			j.setMsg("添加成功！");
		} catch (Exception e) {
			j.setMsg(e.getMessage());
		}
		return j;
	}

	@RequestMapping("/delete")
	@ResponseBody
	public Json delete(Long id) {
		Json j = new Json();
		try {
			studentinfoServiceI.delete(id);
			j.setMsg("删除成功！");
			j.setSuccess(true);
		} catch (Exception e) {
			j.setMsg(e.getMessage());
		}
		return j;
	}

	@RequestMapping("/get")
	@ResponseBody
	public TStudentinfo get(Long id) {
		return studentinfoServiceI.get(id);
	}
	@RequestMapping("/editPage")
	public String editPage(HttpServletRequest request, Long id) {
		TStudentinfo studentInfo = studentinfoServiceI.get(id);
		request.setAttribute("studentInfo", studentInfo);
		return "/businessCore/customer/studentInfoEdit";
	}

	@RequestMapping("/edit")
	@ResponseBody
	public Json edit(StudentInfo studentInfo ) {
		Json j = new Json();
		try {
		    TStudentinfo studentinfos=new TStudentinfo();
			BeanUtils.copyProperties(studentInfo, studentinfos);
			studentinfos.setStuapplyTime(DateUtils.formatDate(studentInfo.getStuapplyTime(),DateUtils.FORMAT_SHORT));

			studentinfoServiceI.edit(studentinfos);
			j.setSuccess(true);
			j.setMsg("编辑成功！");
		} catch (Exception e) {
			j.setMsg(e.getMessage());
		}
		return j;
	}
	@RequestMapping("/viewPage")
	public String viewPage(HttpServletRequest request, Long id) {
		TStudentinfo studentInfo = studentinfoServiceI.get(id);
		request.setAttribute("studentInfo", studentInfo);
		return "/businessCore/customer/studentInfoView";
	}

}

服务层 StudentinfoServiceI.java

package com.jacezhu.service.businessCore.CustomerManagement;

import java.util.List;

import com.jacezhu.model.base.pageModel.PageFilter;
import com.jacezhu.model.businessCore.CustomerManagement.TStudentinfo;
import com.jacezhu.model.businessCore.CustomerManagement.vo.StudentInfo;
import com.jacezhu.model.businessCore.CustomerManagement.vo.VStudentinfo;

public interface StudentinfoServiceI {

	public List<TStudentinfo> dataGrid(StudentInfo studentInfo, PageFilter ph);
	public Long count(StudentInfo studentInfo, PageFilter ph);
	//---------学生签到管理 查询学生信息------------
	 /**  查询 未签到的学生信息
	  */
	public List<VStudentinfo> dataGridToReport(StudentInfo studentInfo, PageFilter ph);
	public Long countToReport(StudentInfo studentInfo, PageFilter ph);

	 /**查询已经签到的学生信息
	  */
	public List<TStudentinfo> dataGridIsReported(StudentInfo studentInfo, PageFilter ph);
	public Long countIsReported(StudentInfo studentInfo, PageFilter ph);
	//----------------------
	public void add(StudentInfo studentInfo);
	public void delete(Long id);
	public TStudentinfo get(Long id);
	public void edit(TStudentinfo studentInfo);


}

服务实现层：StudentinfoServiceImpl.java

package com.jacezhu.service.businessCore.CustomerManagement.impl;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.Httpssion;

import com.jacezhu.dao.BaseDaoI;
import com.jacezhu.dao.impl.JdbcDaoImpl;
import com.jacezhu.framework.constant.GlobalConstant;
import com.jacezhu.model.base.pageModel.PageFilter;
import com.jacezhu.model.base.pageModel.SessionInfo;
import com.jacezhu.model.businessCore.CustomerManagement.THisStudentinfo;
import com.jacezhu.model.businessCore.CustomerManagement.TStudentinfo;
import com.jacezhu.model.businessCore.CustomerManagement.mapper.TStudentInfoMapper;
import com.jacezhu.model.businessCore.CustomerManagement.mapper.VStudentinfoMapper;
import com.jacezhu.model.businessCore.CustomerManagement.vo.StudentInfo;
import com.jacezhu.model.businessCore.CustomerManagement.vo.VStudentinfo;
import com.jacezhu.service.businessCore.CustomerManagement.StudentinfoServiceI;

import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class StudentinfoServiceImpl implements StudentinfoServiceI{
	@Autowired
	private BaseDaoI<TStudentinfo> tstudentInfoDao ;
	@Autowired
	private BaseDaoI<StudentInfo> studentInfoDao ;

	@Autowired
	private BaseDaoI<THisStudentinfo> hisStudentInfoDao ;
	//----使用spring专属的方式获取session 
    @Autowired
    private HttpSession session;
    @Autowired
    private HttpServletRequest request;
    //引入 jsbc 
	private JdbcDaoImpl  daoImpl=new JdbcDaoImpl() ;

	public JdbcDaoImpl getDaoImpl() {
		return daoImpl;
	}

	public void setDaoImpl(JdbcDaoImpl daoImpl) {
		this.daoImpl = daoImpl;
	}
     /**
      * datagrid 列表数据查询
      */
	@Override
	public List<TStudentinfo> dataGrid(StudentInfo studentInfo, PageFilter ph) {
		List<TStudentinfo> ul = new ArrayList<TStudentinfo>();
		Map<String, Object> params = new HashMap<String, Object>();
		String hql = " from TStudentinfo t  ";
		List<TStudentinfo> l = tstudentInfoDao.find(hql + whereHql(studentInfo, params) + orderHql(ph), params, ph.getPage(), ph.getRows());
		for (TStudentinfo t : l) {
			TStudentinfo u = new TStudentinfo();
			BeanUtils.copyProperties(t, u);
			ul.add(u);
		}
		return ul;
	}

	@Override
	public Long count(StudentInfo studentInfo, PageFilter ph) {
		Map<String, Object> params = new HashMap<String, Object>();
		String hql = " from TStudentinfo t ";
		return tstudentInfoDao.count("select count(*) " + hql + whereHql(studentInfo, params), params);
	}

	/**
	 *
	* @author  刘军
	* @date 2016-4-16 下午11:17:07   80 	* @version V1.0    81 	* @Title: whereHql   82 	* @Description: ( datagrid  拼接查询语句  )   83 	* @param @param studentInfo
	* @param @param params
	* @param @return    设定文件   86 	* @return String    返回类型   87 	* @throws   88 	 */
	private String whereHql(StudentInfo studentInfo, Map<String, Object> params) {
		String hql = "";
		if (studentInfo != null) {
			hql += " where 1=1 and stustatus=1  ";
			if (studentInfo.getStuname() != null && !studentInfo.getStuname().equals("") ) {
				hql += " and t.stuname like :stuname";
				params.put("stuname", "%%" + studentInfo.getStuname() + "%%");
			}
			if (studentInfo.getStuenglishName() != null && !studentInfo.getStuenglishName().equals("") ) {
				hql += " and t.stuenglishName like :stuenglishName";
				params.put("stuenglishName", "%%" + studentInfo.getStuenglishName() + "%%");
			}
			if (studentInfo.getStuapplyTimeStart() != null) {
				hql += " and t.stuapplyTime >= :stuapplyTimeStart";
				params.put("stuapplyTimeStart", studentInfo.getStuapplyTimeStart());
			}
			if (studentInfo.getStuapplyTimeEnd() != null) {
				hql += " and t.stuapplyTime <= :stuapplyTimeEnd";
				params.put("stuapplyTimeEnd", studentInfo.getStuapplyTimeEnd());
			}
		}
		return hql;
	}
	/**
	 *
	* @author  刘军
	* @date 2016-4-16 下午11:18:25  116 	* @version V1.0   117 	* @Title: orderHql  118 	* @Description: (datagrid  拼接 排序)  119 	* @param @param ph
	* @param @return    设定文件  121 	* @return String    返回类型  122 	* @throws  123 	 */
	private String orderHql(PageFilter ph) {
		String orderString = "";
		if ((ph.getSort() != null) && (ph.getOrder() != null)) {
			orderString = " order by t." + ph.getSort() + "" + ph.getOrder();
		}
		return orderString;
	}
	//----------------------学生签到管理：查询未签到学生信息-ToReport------------------------------
	@Override
	public List<VStudentinfo> dataGridToReport(StudentInfo studentInfo, PageFilter ph) {
	    List<VStudentinfo> listJdbc=getSql(studentInfo,ph);
		return listJdbc;
	}

	@Override
	public Long countToReport(StudentInfo studentInfo, PageFilter ph) {
		List<Object> obj=new ArrayList<Object>();
		String sql = " select count(*) as counts from t_studentinfo ts where 1=1  ";
		//----------拼写：查询条件
		if (studentInfo.getStuname() != null && !studentInfo.getStuname().equals("") ) {
			sql += " and ts.stuname like '%"+ studentInfo.getStuname()+"%'";
		}
		if (studentInfo.getStuenglishName() != null && !studentInfo.getStuenglishName().equals("") ) {
			sql += " and ts.stuenglishName like '%" +studentInfo.getStuenglishName()+"%'";
		}
		if (studentInfo.getStuapplyTimeStart() != null) {
			sql += " and ts.stuapplyTime >= '"+studentInfo.getStuapplyTimeStart()+"'";
		}
		if (studentInfo.getStuapplyTimeEnd() != null) {
			sql += " and ts.stuapplyTime <= '"+studentInfo.getStuapplyTimeEnd()+"'";
		}
		return daoImpl.Count(sql);
	}

	//------jdbc  查询

	@SuppressWarnings("unchecked")
	private List<VStudentinfo> getSql(StudentInfo studentInfo, PageFilter ph){
		List<VStudentinfo> list=new ArrayList<VStudentinfo>();
		String sql= "   SELECT ts.stuid AS stuid ,"
			         +" ts.stuname AS stuname  ,"
			         +" ts.stuenglishName AS stuenglishName,"
			         +" ts.stusex AS stusex ,"
			         +" ds.value AS sexname,"
			         +" ts.stubrithday AS stubrithday,"
			         +" ts.stuschool AS stuschool ,"
			         +" ts.stugrade AS stugrade,"
			         +" ts.studepartment AS studepartment,"
			         +" dp.value AS studepartmentname ,"
			         +" ts.stuRegistration AS stuRegistration,"
			         +" tr.value AS registrationname,"
			         +" ts.stupickUp AS stupickUp,"
			         +" dpk.value AS pickUpName,"
			         +" ts.stuattention AS stuattention,"
			         +" ts.stuhobby AS stuhobby ,"
			         +" ts.stuavoidFood AS stuavoidFood,"
			         +" ts.stuallergySmptoms AS stuallergySmptoms,"
			         +" ts.stuacuteillness AS stuacuteillness,"
			         +" ts.stuotherInfo AS stuotherInfo,"
			         +" ts.prId AS prId,"
			         +" tp.prName AS prName,"
			         +" ts.stustatus AS stustatus,"
			         +" dst.value AS stustatusName ,"
			         +" ts.stuapplyTime AS stuapplyTime,"
			         +" ts.userid AS userid ,su.name AS userName,"
			         +" ts.druguse AS druguse "
			         +" FROM   t_studentinfo  ts ,   t_dic_sex ds ,  t_dic_partment dp,  t_dic_pickup dpk,"
			         +" t_dic_status dst,   t_dic_registration tr , sys_user su, t_parentsinfo tp "
			         +" WHERE ts.stusex =ds.id  AND  ts.studepartment=dp.id  AND  ts.stuRegistration=tr.id "
			         +" AND  ts.stupickUp=dpk.id  AND  ts.stustatus=dst.id  AND  ts.userid = su.id AND  ts.prId=tp.prId   "
			         +" AND  ts.stuid NOT IN (SELECT tre.stuid  FROM t_reportsorexit tre WHERE  tre.reportstime BETWEEN  TIMESTAMP(DATE(SYSDATE())) AND  TIMESTAMP(ADDDATE(DATE(SYSDATE()),1)) )  ";
		//------拼接查询条件
		List<Object> obj=new ArrayList<Object>();
		//----------拼写：查询条件
		if (studentInfo.getStuname() != null && !studentInfo.getStuname().equals("") ) {
			sql += " and ts.stuname like ? ";
			obj.add( "%" + studentInfo.getStuname() + "%");
		}
		if (studentInfo.getStuenglishName() != null && !studentInfo.getStuenglishName().equals("") ) {
			sql += " and ts.stuenglishName like ? ";
			obj.add(  "%" + studentInfo.getStuenglishName() + "%");
		}
		if (studentInfo.getStuapplyTimeStart() != null) {
			sql += " and ts.stuapplyTime >= ? ";
			obj.add(  studentInfo.getStuapplyTimeStart());
		}
		if (studentInfo.getStuapplyTimeEnd() != null) {
			sql += " and ts.stuapplyTime <= ?  ";
			obj.add(  studentInfo.getStuapplyTimeEnd());
		}
		//----------  order by
		if(ph.getSort()!= null && ph.getOrder()!=null){
			sql +=  "   order by ts." + ph.getSort() + "" + ph.getOrder();
		}
		//----------- limit 分页        
		sql += "   LIMIT "+((ph.getPage() - 1) * ph.getRows())+","+ ph.getPage() * ph.getRows() ;

		list=(List<VStudentinfo>)daoImpl.query(sql , obj, new VStudentinfoMapper());
		return list;
	}



	/**
	 *
	* @author  刘军
	* @date 2016-4-16 下午11:17:07  231 	* @version V1.0   232 	* @Title: whereHql  233 	* @Description: ( datagrid  拼接查询语句  )  234 	* @param @param studentInfo
	* @param @param params
	* @param @return    设定文件  237 	* @return String    返回类型  238 	* @throws  239 	 */
	private String whereHqlToReport(StudentInfo studentInfo, Map<String, Object> params) {
		String hql = "";
		if (studentInfo != null) {
			hql += " where 1=1 and t.stustatus=1  and t.stuid not in"
	     	+  " (select tr.stuid  from TReportsorexit tr  "
			+  "   WHERE  tr.reportstime BETWEEN  TIMESTAMP(DATE(SYSDATE())) AND  TIMESTAMP(ADDDATE(DATE(SYSDATE()),1)) )  ";
			if (studentInfo.getStuname() != null && !studentInfo.getStuname().equals("") ) {
				hql += " and t.stuname like :stuname";
				params.put("stuname", "%%" + studentInfo.getStuname() + "%%");
			}
			if (studentInfo.getStuenglishName() != null && !studentInfo.getStuenglishName().equals("") ) {
				hql += " and t.stuenglishName like :stuenglishName";
				params.put("stuenglishName", "%%" + studentInfo.getStuenglishName() + "%%");
			}
			if (studentInfo.getStuapplyTimeStart() != null) {
				hql += " and t.stuapplyTime >= :stuapplyTimeStart";
				params.put("stuapplyTimeStart", studentInfo.getStuapplyTimeStart());
			}
			if (studentInfo.getStuapplyTimeEnd() != null) {
				hql += " and t.stuapplyTime <= :stuapplyTimeEnd";
				params.put("stuapplyTimeEnd", studentInfo.getStuapplyTimeEnd());
			}
		}
		return hql;
	}







	//-------------查询：已经签到的学生信息-----------------------------

	@Override
	public List<TStudentinfo> dataGridIsReported(StudentInfo studentInfo, PageFilter ph) {
		Map<String, Object> params = new HashMap<String, Object>();
		String hql = " from TStudentinfo t  ";
		List<TStudentinfo> l = tstudentInfoDao.find(hql + whereHqlIsReported(studentInfo, params) + orderHqlIsReported(ph), params, ph.getPage(), ph.getRows());

		return l;
	}



	@Override
	public Long countIsReported(StudentInfo studentInfo, PageFilter ph) {
		Map<String, Object> params = new HashMap<String, Object>();
		String hql = " from TStudentinfo t ";
		return tstudentInfoDao.count("select count(*) " + hql + whereHqlToReport(studentInfo, params), params);
	}

	/**
	 *
	* @author  刘军
	* @date 2016-4-16 下午11:17:07  296 	* @version V1.0   297 	* @Title: whereHql  298 	* @Description: ( datagrid  拼接查询语句  )  299 	* @param @param studentInfo
	* @param @param params
	* @param @return    设定文件  302 	* @return String    返回类型  303 	* @throws  304 	 */
	private String whereHqlIsReported(StudentInfo studentInfo, Map<String, Object> params) {
		String hql = "";
		if (studentInfo != null) {
			hql += " where 1=1 and t.stustatus=1  and t.stuid  in"
	     	+  " (select tr.stuid  from TReportsorexit tr  "
			+  "   WHERE  tr.reportstime BETWEEN  TIMESTAMP(DATE(SYSDATE())) AND  TIMESTAMP(ADDDATE(DATE(SYSDATE()),1)) )  ";
			if (studentInfo.getStuname() != null && !studentInfo.getStuname().equals("") ) {
				hql += " and t.stuname like :stuname";
				params.put("stuname", "%%" + studentInfo.getStuname() + "%%");
			}
			if (studentInfo.getStuenglishName() != null && !studentInfo.getStuenglishName().equals("") ) {
				hql += " and t.stuenglishName like :stuenglishName";
				params.put("stuenglishName", "%%" + studentInfo.getStuenglishName() + "%%");
			}
			if (studentInfo.getStuapplyTimeStart() != null) {
				hql += " and t.stuapplyTime >= :stuapplyTimeStart";
				params.put("stuapplyTimeStart", studentInfo.getStuapplyTimeStart());
			}
			if (studentInfo.getStuapplyTimeEnd() != null) {
				hql += " and t.stuapplyTime <= :stuapplyTimeEnd";
				params.put("stuapplyTimeEnd", studentInfo.getStuapplyTimeEnd());
			}
		}
		return hql;
	}

	/**
	 *
	* @author  刘军
	* @date 2016-4-16 下午11:18:25  335 	* @version V1.0   336 	* @Title: orderHql  337 	* @Description: (datagrid  拼接 排序)  338 	* @param @param ph
	* @param @return    设定文件  340 	* @return String    返回类型  341 	* @throws  342 	 */
	private String orderHqlIsReported(PageFilter ph) {
		String orderString = "";
		if ((ph.getSort() != null) && (ph.getOrder() != null)) {
			orderString = " order by t." + ph.getSort() + "" + ph.getOrder();
		}
		return orderString;
	}

	//-------------------------------------------------------------------------

    /**
     * 添加学生信息
     */
	@Override
	public void add(StudentInfo studentInfo) {
		TStudentinfo tStudentinfo = new TStudentinfo();
		BeanUtils.copyProperties(studentInfo, tStudentinfo);
		tStudentinfo.setStuapplyTime(new Date());//创建时间
		tStudentinfo.setStustatus(1);//有效状态
		tStudentinfo.setStudayCost( studentInfo.getStudayCost() );
		tstudentInfoDao.save(tStudentinfo);
	}
	/**
	 *
	* @author  刘军
	* @date 2016-4-16 下午11:18:25  369 	* @version V1.0   370 	* @Title: orderHql  371 	* @Description: ( 删除学生信息)  372 	* @param @param ph
	* @param @return    设定文件  374 	* @return String    返回类型  375 	* @throws  376 	 */
	@Override
	public void delete(Long id) {
		TStudentinfo studentInfo = tstudentInfoDao.get(TStudentinfo.class, id);
		studentInfo.setStustatus(0);//置为无效状态
		//获取登陆 用户信息
		SessionInfo sessionInfo=(SessionInfo) session.getAttribute(GlobalConstant.SESSION_INFO);
		THisStudentinfo hisStudentinfo=new THisStudentinfo() ;
		BeanUtils.copyProperties(studentInfo, hisStudentinfo);
		//保存：修改用户信息的操作员信息
		hisStudentinfo.setUpdateTime(new Date());
		hisStudentinfo.setUpdateUserId(Integer.parseInt((sessionInfo.getId()+"").trim()));
		hisStudentinfo.setActionMethod("delete");
		//保存历史表信息
	    hisStudentInfoDao.save(hisStudentinfo);

	  //跟新数据
	  	tstudentInfoDao.update(studentInfo);
	}
	/**
	 *
	* @author  刘军
	* @date 2016-4-16 下午11:18:25  399 	* @version V1.0   400 	* @Title: orderHql  401 	* @Description: ( 根据学生id  获取学生信息)  402 	* @param @param ph
	* @param @return    设定文件  404 	* @return String    返回类型  405 	* @throws  406 	 */
	@Override
	public TStudentinfo get(Long id) {
		TStudentinfo studentInfo  = tstudentInfoDao.get(TStudentinfo.class, id);
		return studentInfo;
	}
	/**
	 *
	* @author  刘军
	* @date 2016-4-16 下午11:18:25  416 	* @version V1.0   417 	* @Title: orderHql  418 	* @Description: ( 修改 学生信息 )  419 	* @param @param ph
	* @param @return    设定文件  421 	* @return String    返回类型  422 	* @throws  423 	 */
	@Override
	public void edit(TStudentinfo studentInfo) {

		//获取登陆 用户信息
		SessionInfo sessionInfo=(SessionInfo) session.getAttribute(GlobalConstant.SESSION_INFO);

		THisStudentinfo hisStudentinfo=new THisStudentinfo() ;
		TStudentinfo studentinfo2=queryfirst((long)studentInfo.getStuid()) ;//get((long)studentInfo.getUserid());
		BeanUtils.copyProperties(studentinfo2, hisStudentinfo);

		//保存：修改用户信息的操作员信息
		hisStudentinfo.setUpdateTime(new Date());
		hisStudentinfo.setUpdateUserId(Integer.parseInt((sessionInfo.getId()+"").trim()));
		hisStudentinfo.setActionMethod("update");
		//保存历史表信息
	    hisStudentInfoDao.save(hisStudentinfo);

		//跟新数据
		tstudentInfoDao.update(studentInfo);
	}
	   /**
     * 查询第一条数据
     */
	public TStudentinfo queryfirst(Long stuid) {
		String sql = "select * from  t_studentinfo where stuid= ?";
		Object[] obj = {stuid};
		return (TStudentinfo) daoImpl.find(sql, obj, new TStudentInfoMapper()) ;
	}
}

JavaBean 层：TStudentinfo.java

package com.jacezhu.model.businessCore.CustomerManagement;

import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import static javax.persistence.GenerationType.IDENTITY;
import javax.persistence.Id;
import javax.persistence.Table;

/**
 * TStudentinfo entity. @author MyEclipse Persistence Tools
 * 学生信息注册管理
 */
@Entity
@Table(name = "t_studentinfo", catalog = "xlzj_sh")
public class TStudentinfo implements java.io.Serializable {

	// Fields

	private Long stuid;//学生信息表主键  id
	private String stuname;//学生名字
	private String stuenglishName;//学生英文名
	private Integer stusex;//学生性别  dic: 0 ;男 1 女
	private String stubrithday;//学生生日
	private String stuschool;//学生就读于那个学校
	private String stugrade;//学生是几年级的
	private Integer studepartment;//中/英文部	dic: 1   中文部   2英文部
	private String stuRegistration;//报名方式  dic: 0 :晚托班 1:1对1辅导 2：上门家教服务 3：其他
	private Integer stupickUp;//是否接送  dic: 1 接送 ；0 ：不接送
	private String stuattention;//注意事项
	private String stuhobby;//兴趣爱好
	private String stuavoidFood;//忌口食物
	private String stuallergySmptoms;//过敏症状
	private String stuacuteillness;//急性病史
	private String stuotherInfo;//其他信息
	private Long prId;//家长信息表主键
	private Integer stustatus;//学生有效状态  dic: 0 无效 1：有效
	private Date stuapplyTime;//注册时间
	private Integer userid;//注册人id
	private String druguse;//drug use  药物使用
	private String stuschoolTech;// 学生在学校的负责老师姓名
	private String stuschoolTechTel;//学生在校的负责老师的联系电话
	private String startStudayDate;//课程服务的起始时间
	private String endStudayDate;//课程服务的终止时间
 	private String studayCost;//学费


	// Constructors

	/** default constructor */
	public TStudentinfo() {
	}

	/** full constructor */
	public TStudentinfo(String stuname, String stuenglishName, Integer stusex,
			String stubrithday, String stuschool, String stugrade,
			Integer studepartment, String stuRegistration, Integer stupickUp,
			String stuattention, String stuhobby, String stuavoidFood,
			String stuallergySmptoms, String stuacuteillness,
			String stuotherInfo, Long prId, Integer stustatus,
			Date stuapplyTime, Integer userid, String druguse ,String stuschoolTech, String stuschoolTechTel,
			String startStudayDate , String endStudayDate , String studayCost) {
		this.stuname = stuname;
		this.stuenglishName = stuenglishName;
		this.stusex = stusex;
		this.stubrithday = stubrithday;
		this.stuschool = stuschool;
		this.stugrade = stugrade;
		this.studepartment = studepartment;
		this.stuRegistration = stuRegistration;
		this.stupickUp = stupickUp;
		this.stuattention = stuattention;
		this.stuhobby = stuhobby;
		this.stuavoidFood = stuavoidFood;
		this.stuallergySmptoms = stuallergySmptoms;
		this.stuacuteillness = stuacuteillness;
		this.stuotherInfo = stuotherInfo;
		this.prId = prId;
		this.stustatus = stustatus;
		this.stuapplyTime = stuapplyTime;
		this.userid = userid;
		this.druguse = druguse;
		this.stuschoolTech = stuschoolTech;
		this.stuschoolTechTel = stuschoolTechTel;
		this.startStudayDate = startStudayDate;
		 this.endStudayDate = endStudayDate;
		this.studayCost = studayCost;
	}

	// Property accessors
	@Id
	@GeneratedValue(strategy = IDENTITY)
	@Column(name = "stuid", unique = true, nullable = false)
	public Long getStuid() {
		return this.stuid;
	}

	public void setStuid(Long stuid) {
		this.stuid = stuid;
	}

	@Column(name = "stuname", length = 50)
	public String getStuname() {
		return this.stuname;
	}

	public void setStuname(String stuname) {
		this.stuname = stuname;
	}

	@Column(name = "stuenglishName", length = 50)
	public String getStuenglishName() {
		return this.stuenglishName;
	}

	public void setStuenglishName(String stuenglishName) {
		this.stuenglishName = stuenglishName;
	}

	@Column(name = "stusex", length = 1)
	public Integer getStusex() {
		return this.stusex;
	}

	public void setStusex(Integer stusex) {
		this.stusex = stusex;
	}

	@Column(name = "stubrithday", length = 10)
	public String getStubrithday() {
		return this.stubrithday;
	}

	public void setStubrithday(String stubrithday) {
		this.stubrithday = stubrithday;
	}

	@Column(name = "stuschool", length = 100)
	public String getStuschool() {
		return this.stuschool;
	}

	public void setStuschool(String stuschool) {
		this.stuschool = stuschool;
	}

	@Column(name = "stugrade", length = 10)
	public String getStugrade() {
		return this.stugrade;
	}

	public void setStugrade(String stugrade) {
		this.stugrade = stugrade;
	}

	@Column(name = "studepartment", length = 1)
	public Integer getStudepartment() {
		return this.studepartment;
	}

	public void setStudepartment(Integer studepartment) {
		this.studepartment = studepartment;
	}

	@Column(name = "stuRegistration", length = 1)
	public String getStuRegistration() {
		return this.stuRegistration;
	}

	public void setStuRegistration(String stuRegistration) {
		this.stuRegistration = stuRegistration;
	}

	@Column(name = "stupickUp", length = 1)
	public Integer getStupickUp() {
		return this.stupickUp;
	}

	public void setStupickUp(Integer stupickUp) {
		this.stupickUp = stupickUp;
	}

	@Column(name = "stuattention", length = 500)
	public String getStuattention() {
		return this.stuattention;
	}

	public void setStuattention(String stuattention) {
		this.stuattention = stuattention;
	}

	@Column(name = "stuhobby", length = 200)
	public String getStuhobby() {
		return this.stuhobby;
	}

	public void setStuhobby(String stuhobby) {
		this.stuhobby = stuhobby;
	}

	@Column(name = "stuavoidFood", length = 200)
	public String getStuavoidFood() {
		return this.stuavoidFood;
	}

	public void setStuavoidFood(String stuavoidFood) {
		this.stuavoidFood = stuavoidFood;
	}

	@Column(name = "stuallergySmptoms", length = 500)
	public String getStuallergySmptoms() {
		return this.stuallergySmptoms;
	}

	public void setStuallergySmptoms(String stuallergySmptoms) {
		this.stuallergySmptoms = stuallergySmptoms;
	}

	@Column(name = "stuacuteillness", length = 500)
	public String getStuacuteillness() {
		return this.stuacuteillness;
	}

	public void setStuacuteillness(String stuacuteillness) {
		this.stuacuteillness = stuacuteillness;
	}

	@Column(name = "stuotherInfo", length = 500)
	public String getStuotherInfo() {
		return this.stuotherInfo;
	}

	public void setStuotherInfo(String stuotherInfo) {
		this.stuotherInfo = stuotherInfo;
	}

	@Column(name = "prId")
	public Long getPrId() {
		return this.prId;
	}

	public void setPrId(Long prId) {
		this.prId = prId;
	}

	@Column(name = "stustatus", length = 1)
	public Integer getStustatus() {
		return this.stustatus;
	}

	public void setStustatus(Integer stustatus) {
		this.stustatus = stustatus;
	}

	@Column(name = "stuapplyTime" )
	public Date getStuapplyTime() {
		return this.stuapplyTime;
	}

	public void setStuapplyTime(Date stuapplyTime) {
		this.stuapplyTime = stuapplyTime;
	}

	@Column(name = "userid")
	public Integer getUserid() {
		return this.userid;
	}

	public void setUserid(Integer userid) {
		this.userid = userid;
	}

	@Column(name = "druguse", length = 500)
	public String getDruguse() {
		return this.druguse;
	}

	public void setDruguse(String druguse) {
		this.druguse = druguse;
	}

	@Column(name = "stuschool_tech", length = 100)
	public String getStuschoolTech() {
		return this.stuschoolTech;
	}

	public void setStuschoolTech(String stuschoolTech) {
		this.stuschoolTech = stuschoolTech;
	}

	@Column(name = "stuschool_tech_tel", length = 20)
	public String getStuschoolTechTel() {
		return this.stuschoolTechTel;
	}

	public void setStuschoolTechTel(String stuschoolTechTel) {
		this.stuschoolTechTel = stuschoolTechTel;
	}

	@Column(name = "start_studay_date", length = 19)
	public String getStartStudayDate() {
		return this.startStudayDate;
	}

	public void setStartStudayDate(String startStudayDate) {
		this.startStudayDate = startStudayDate;
	}

	 @Column(name = "end_studay_date", length = 19)
	public String getEndStudayDate() {
		return this.endStudayDate;
	}

	public void setEndStudayDate(String endStudayDate) {
		this.endStudayDate = endStudayDate;
	}

	@Column(name = "studay_cost", precision = 16, scale = 0)
	public String getStudayCost() {
		return this.studayCost;
	}

	public void setStudayCost(String studayCost) {
		this.studayCost = studayCost;
	}
}

JavaBean 参数对象：StudentInfo.java

package com.jacezhu.model.businessCore.CustomerManagement.vo;
import java.util.Date;
/**
 *
* @Title: StudentInfo.java    6 * @Package com.jacezhu.pageModel.businessCore.CustomerManagement    7 * @Description: (
* beanVo  用于接收查询条件 的参数
* )   10 * @author   liujun<1136808529@qq.coom>
* @date 2016-4-24 下午12:11:17   12 * @version V1.0    13  */
public class StudentInfo implements java.io.Serializable {

	// Fields

	/**   19 	* @Fields serialVersionUID : (用一句话描述这个变量表示什么)   20 	*/
	private static final long serialVersionUID = 1L;
	private Long stuid;//学生信息表主键  id
	private String stuname;//学生名字
	private String stuenglishName;//学生英文名
	private Integer stusex;//学生性别  dic: 0 ;男 1 女
	private String stubrithday;//学生生日
	private String stuschool;//学生就读于那个学校
	private String stugrade;//学生是几年级的
	private Integer studepartment;//中/英文部	dic: 1   中文部   2英文部
	private String stuRegistration;//报名方式  dic: 0 :晚托班 1:1对1辅导 2：上门家教服务 3：其他
	private Integer stupickUp;//是否接送  dic: 1 接送 ；0 ：不接送
	private String stuattention;//注意事项
	private String stuhobby;//兴趣爱好
	private String stuavoidFood;//忌口食物
	private String stuallergySmptoms;//过敏症状
	private String stuacuteillness;//急性病史
	private String stuotherInfo;//其他信息
	private Long prId;//家长信息表主键
	private Integer stustatus;//学生有效状态  dic: 0 无效 1：有效
	private String stuapplyTime;//注册时间
	private Integer userid;//注册人id
	private String druguse;//drug use  药物使用
	private Date  stuapplyTimeStart;
	private Date  stuapplyTimeEnd;
	private String stuschoolTech;// 学生在学校的负责老师姓名
	private String stuschoolTechTel;//学生在校的负责老师的联系电话
	private String startStudayDate;//课程服务的起始时间
	private String endStudayDate;//课程服务的终止时间
	private String studayCost;//学费


	public Date getStuapplyTimeStart() {
		return stuapplyTimeStart;
	}
	public void setStuapplyTimeStart(Date stuapplyTimeStart) {
		this.stuapplyTimeStart = stuapplyTimeStart;
	}
	public Date getStuapplyTimeEnd() {
		return stuapplyTimeEnd;
	}
	public void setStuapplyTimeEnd(Date stuapplyTimeEnd) {
		this.stuapplyTimeEnd = stuapplyTimeEnd;
	}
	public Long getStuid() {
		return stuid;
	}
	public void setStuid(Long stuid) {
		this.stuid = stuid;
	}
	public String getStuname() {
		return stuname;
	}
	public void setStuname(String stuname) {
		this.stuname = stuname;
	}
	public String getStuenglishName() {
		return stuenglishName;
	}
	public void setStuenglishName(String stuenglishName) {
		this.stuenglishName = stuenglishName;
	}
	public Integer getStusex() {
		return stusex;
	}
	public void setStusex(Integer stusex) {
		this.stusex = stusex;
	}
	public String getStubrithday() {
		return stubrithday;
	}
	public void setStubrithday(String stubrithday) {
		this.stubrithday = stubrithday;
	}
	public String getStuschool() {
		return stuschool;
	}
	public void setStuschool(String stuschool) {
		this.stuschool = stuschool;
	}
	public String getStugrade() {
		return stugrade;
	}
	public void setStugrade(String stugrade) {
		this.stugrade = stugrade;
	}
	public Integer getStudepartment() {
		return studepartment;
	}
	public void setStudepartment(Integer studepartment) {
		this.studepartment = studepartment;
	}
	public String getStuRegistration() {
		return stuRegistration;
	}
	public void setStuRegistration(String stuRegistration) {
		this.stuRegistration = stuRegistration;
	}
	public Integer getStupickUp() {
		return stupickUp;
	}
	public void setStupickUp(Integer stupickUp) {
		this.stupickUp = stupickUp;
	}
	public String getStuattention() {
		return stuattention;
	}
	public void setStuattention(String stuattention) {
		this.stuattention = stuattention;
	}
	public String getStuhobby() {
		return stuhobby;
	}
	public void setStuhobby(String stuhobby) {
		this.stuhobby = stuhobby;
	}
	public String getStuavoidFood() {
		return stuavoidFood;
	}
	public void setStuavoidFood(String stuavoidFood) {
		this.stuavoidFood = stuavoidFood;
	}
	public String getStuallergySmptoms() {
		return stuallergySmptoms;
	}
	public void setStuallergySmptoms(String stuallergySmptoms) {
		this.stuallergySmptoms = stuallergySmptoms;
	}
	public String getStuacuteillness() {
		return stuacuteillness;
	}
	public void setStuacuteillness(String stuacuteillness) {
		this.stuacuteillness = stuacuteillness;
	}
	public String getStuotherInfo() {
		return stuotherInfo;
	}
	public void setStuotherInfo(String stuotherInfo) {
		this.stuotherInfo = stuotherInfo;
	}
	public Long getPrId() {
		return prId;
	}
	public void setPrId(Long prId) {
		this.prId = prId;
	}
	public Integer getStustatus() {
		return stustatus;
	}
	public void setStustatus(Integer stustatus) {
		this.stustatus = stustatus;
	}
	public String getStuapplyTime() {
		return stuapplyTime;
	}
	public void setStuapplyTime(String stuapplyTime) {
		this.stuapplyTime = stuapplyTime;
	}
	public Integer getUserid() {
		return userid;
	}
	public void setUserid(Integer userid) {
		this.userid = userid;
	}
	public String getDruguse() {
		return druguse;
	}
	public void setDruguse(String druguse) {
		this.druguse = druguse;
	}
	public String getStuschoolTech() {
		return stuschoolTech;
	}
	public void setStuschoolTech(String stuschoolTech) {
		this.stuschoolTech = stuschoolTech;
	}
	public String getStuschoolTechTel() {
		return stuschoolTechTel;
	}
	public void setStuschoolTechTel(String stuschoolTechTel) {
		this.stuschoolTechTel = stuschoolTechTel;
	}
	public String getStartStudayDate() {
		return startStudayDate;
	}
	public void setStartStudayDate(String startStudayDate) {
		this.startStudayDate = startStudayDate;
	}
	public String getEndStudayDate() {
		return endStudayDate;
	}
	public void setEndStudayDate(String endStudayDate) {
		this.endStudayDate = endStudayDate;
	}
	public String getStudayCost() {
		return studayCost;
	}
	public void setStudayCost(String studayCost) {
		this.studayCost = studayCost;
	}


}

JavaBean 与表字段的取值对于关系对象：TStudentInfoMapper.java

package com.jacezhu.model.businessCore.CustomerManagement.mapper;

import java.sql.ResultSet;

import com.jacezhu.framework.connectUtil.jdbcUtl.ObjectMapper;
import com.jacezhu.model.businessCore.CustomerManagement.TStudentinfo;

//
public class TStudentInfoMapper  implements ObjectMapper {

	@Override
	public Object mapping(ResultSet rs) {
		TStudentinfo d=new TStudentinfo();
		try{

			d.setStuid(rs.getLong("stuid"));//学生信息表主键  id
			d.setStuname(rs.getString("stuname"));//学生名字
			d.setStuenglishName( rs.getString("stuenglishName") );//学生英文名
			d.setStusex( rs.getInt("stusex") ); //学生性别  dic: 0 ;男 1 女
			d.setStubrithday(rs.getString("stubrithday")); //学生生日
			d.setStuschool(rs.getString("stuschool")); //学生就读于那个学校
			d.setStugrade(rs.getString("stugrade")); //学生是几年级的
			d.setStudepartment(rs.getInt("studepartment"));//中/英文部	dic: 1   中文部   2英文部 
			d.setStuRegistration(rs.getString("stuRegistration")); //报名方式  dic: 0 :晚托班 1:1对1辅导 2：上门家教服务 3：其他
			d.setStupickUp(rs.getInt("stupickUp")); //是否接送  dic: 1 接送 ；0 ：不接送
			d.setStuattention(rs.getString("stuattention")); //注意事项
			d.setStuhobby(rs.getString("stuhobby")); //兴趣爱好
			d.setStuavoidFood(rs.getString("stuavoidFood"));//忌口食物 
			d.setStuallergySmptoms(rs.getString("stuallergySmptoms")); //过敏症状
			d.setStuacuteillness(rs.getString("stuacuteillness")); //急性病史
			d.setStuotherInfo(rs.getString("stuotherInfo")); //其他信息
			d.setPrId(rs.getLong("prId"));//家长信息表主键
			d.setStustatus(rs.getInt("stustatus"));//学生有效状态  dic: 0 无效 1：有效
			d.setStuapplyTime(rs.getDate("stuapplyTime")); //注册时间
			d.setUserid(rs.getInt("userId")); //注册人id
			d.setDruguse(rs.getString("druguse")); //drug use  药物使用
			d.setStuschoolTech(rs.getString("stuschool_tech"));//学生老师
			d.setStuschoolTechTel(rs.getString("stuschool_tech_tel"));//学生老师电话
			d.setStartStudayDate(rs.getString("start_studay_date"));//课程开始时间
		 	d.setEndStudayDate(rs.getString("end_studay_date"));//课程结束时间
 			d.setStudayCost(rs.getString("studay_cost"));
		}catch(Exception ex){
			ex.printStackTrace();
		}
	return d;
	}

}

=参考二：============================================================

Config类

读取同一包下的数据库连接配置文件，这样是为了更好的通用性考虑

package com.tly.dbutil;

import java.io.IOException;
import java.util.Properties;

public class Config {
    private static Properties prop = new Properties();
    static{
        try {
            //加载dbconfig.properties配置文件
            prop.load(Config.class.getResourceAsStream("dbconfig.properties"));
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    //设置常量
    public static final String CLASS_NAME = prop.getProperty("CLASS_NAME");
    public static final String DATABASE_URL = prop.getProperty("DATABASE_URL");
    public static final String SERVER_IP = prop.getProperty("SERVER_IP");
    public static final String SERVER_PORT = prop.getProperty("SERVER_PORT");
    public static final String DATABASE_SID = prop.getProperty("DATABASE_SID");
    public static final String USERNAME = prop.getProperty("USERNAME");
    public static final String PASSWORD = prop.getProperty("PASSWORD");

}

dbconfig.properties：数据库配置文件，你也可以用xml格式等，注意Config类里面该文件的调用位置

CLASS_NAME=com.mysql.jdbc.Driver
DATABASE_URL=jdbc:mysql
SERVER_IP=localhost
SERVER_PORT=3306
DATABASE_SID=employees
USERNAME=root
PASSWORD=1

接下来就是数据库连接辅助类DBConn了

package com.employees.dbutil;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;


public class DBConn {
    //三属性、四方法

    //三大核心接口
    private Connection conn = null;
    private PreparedStatement pstmt = null;
    private ResultSet rs = null;

    //四个方法
    //method1: 创建数据库的连接
    public Connection getConntion(){
        try {
            //1: 加载连接驱动，Java反射原理
            Class.forName(Config.CLASS_NAME);
            //2:创建Connection接口对象，用于获取MySQL数据库的连接对象。三个参数：url连接字符串    账号  密码
            String url = Config.DATABASE_URL+"://"+Config.SERVER_IP+":"+Config.SERVER_PORT+"/"+Config.DATABASE_SID;
            conn = DriverManager.getConnection(url,Config.USERNAME,Config.PASSWORD);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }


    //method2：关闭数据库的方法
    public void closeConn(){
        if(rs!=null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(pstmt!=null){
            try {
                pstmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(conn!=null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }


    //method3: 专门用于发送增删改语句的方法
    public int execOther(PreparedStatement pstmt){
        try {
            //1、使用Statement对象发送SQL语句
            int affectedRows = pstmt.executeUpdate();
            //2、返回结果
            return affectedRows;
        } catch (SQLException e) {
            e.printStackTrace();
            return -1;
        }
    }


    //method4: 专门用于发送查询语句
    public ResultSet execQuery(PreparedStatement pstmt){
        try {
            //1、使用Statement对象发送SQL语句
            rs = pstmt.executeQuery();
            //2、返回结果
            return rs;
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }
    }

}

平时的用上面的代码能够解决一些简单的CRUD的应用了，但是还有很多限制，比如每次程序拿连接都要new,这样就给系统加大了负担，没有事务，没有dataSource等等，今天看见一哥们在园里面写的一篇用反射解决直接以对象参数的方式CRUD,这个我以前也写过，没写完，主要是自己想写一个通用的DButil,最后研究来研究去，发现越来越和hibernate里面的simpleJdbcTemplate接近了，所以就直接去看hibernate的源码了，加上那段时间有些事，没有时间，就将这件事闲置起来了，现在把这个东西补上，也给自己回顾一下下

BaseDao类

package com.employees.dao;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.sql.Connection;
import java.sql.Date;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import com.employees.dbutil.DBConn;

public class BaseDAO<T> {

    DBConn conn = new DBConn();
    private Connection connection = null;

    @SuppressWarnings("unused")
    private Class<T> persistentClass;

    @SuppressWarnings("unchecked")
    public BaseDAO() {
        initConnection();
        //获得参数化类型        
        ParameterizedType type = (ParameterizedType)getClass().getGenericSuperclass();
        persistentClass = (Class<T>)type.getActualTypeArguments()[0];
    }


    /**
     * 获得数据库连接
     */
    public void initConnection() {
        connection = conn.getConntion();
    }


    /**
     * 保存
     */
    public void save(T entity) throws Exception{
        //SQL语句,insert into table name (
        String sql = "insert into " + entity.getClass().getSimpleName().toLowerCase() + "(";

        //获得带有字符串get的所有方法的对象
        List<Method> list = this.matchPojoMethods(entity,"get");

        Iterator<Method> iter = list.iterator();

        //拼接字段顺序 insert into table name(id,name,email,
        while(iter.hasNext()) {
            Method method = iter.next();
            sql += method.getName().substring(3).toLowerCase() + ",";
        }

        //去掉最后一个,符号insert insert into table name(id,name,email) values(
        sql = sql.substring(0, sql.lastIndexOf(",")) + ") values(";

        //拼装预编译SQL语句insert insert into table name(id,name,email) values(?,?,?,
        for(int j = 0; j < list.size(); j++) {
            sql += "?,";
        }

        //去掉SQL语句最后一个,符号insert insert into table name(id,name,email) values(?,?,?);
        sql = sql.substring(0, sql.lastIndexOf(",")) + ")";

        //到此SQL语句拼接完成,打印SQL语句
        System.out.println(sql);

        //获得预编译对象的引用
        PreparedStatement statement = connection.prepareStatement(sql);

        int i = 0;
        //把指向迭代器最后一行的指针移到第一行.
        iter = list.iterator();
        while(iter.hasNext()) {
            Method method = iter.next();
            //此初判断返回值的类型,因为存入数据库时有的字段值格式需要改变,比如String,SQL语句是'"+abc+"'
            if(method.getReturnType().getSimpleName().indexOf("String") != -1) {
                statement.setString(++i, this.getString(method, entity));
            } else if(method.getReturnType().getSimpleName().indexOf("Date") != -1){
                statement.setDate(++i, this.getDate(method, entity));
            } else if(method.getReturnType().getSimpleName().indexOf("InputStream") != -1) {
                statement.setAsciiStream(++i, this.getBlob(method, entity),1440);
            } else {
                statement.setInt(++i, this.getInt(method, entity));
            }
        }
        //执行
        conn.execOther(statement);
        //关闭连接
        conn.closeConn();
    }


    /**
     * 修改
     */
    public void update(T entity) throws Exception{
        String sql = "update " + entity.getClass().getSimpleName().toLowerCase() + " set ";

        //获得该类所有get方法对象集合
        List<Method> list = this.matchPojoMethods(entity,"get");

        //临时Method对象,负责迭代时装method对象.
        Method tempMethod = null;

        //由于修改时不需要修改ID,所以按顺序加参数则应该把Id移到最后.
        Method idMethod = null;
        Iterator<Method> iter = list.iterator();
        while(iter.hasNext()) {
            tempMethod = iter.next();
            //如果方法名中带有ID字符串并且长度为2,则视为ID.
            if(tempMethod.getName().lastIndexOf("Id") != -1 && tempMethod.getName().substring(3).length() == 2) {
                //把ID字段的对象存放到一个变量中,然后在集合中删掉.
                idMethod = tempMethod;
                iter.remove();
            //如果方法名去掉set/get字符串以后与pojo + "id"想符合(大小写不敏感),则视为ID
            } else if((entity.getClass().getSimpleName() + "Id").equalsIgnoreCase(tempMethod.getName().substring(3))) {
                idMethod = tempMethod;
                iter.remove();
            }
        }

        //把迭代指针移到第一位
        iter = list.iterator();
        while(iter.hasNext()) {
            tempMethod = iter.next();
            sql += tempMethod.getName().substring(3).toLowerCase() + "= ?,";
        }

        //去掉最后一个,符号
        sql = sql.substring(0,sql.lastIndexOf(","));

        //添加条件
        sql += " where " + idMethod.getName().substring(3).toLowerCase() + " = ?";

        //SQL拼接完成,打印SQL语句
        System.out.println(sql);

        PreparedStatement statement = this.connection.prepareStatement(sql);

        int i = 0;
        iter = list.iterator();
        while(iter.hasNext()) {
            Method method = iter.next();
            //此初判断返回值的类型,因为存入数据库时有的字段值格式需要改变,比如String,SQL语句是'"+abc+"'
            if(method.getReturnType().getSimpleName().indexOf("String") != -1) {
                statement.setString(++i, this.getString(method, entity));
            } else if(method.getReturnType().getSimpleName().indexOf("Date") != -1){
                statement.setDate(++i, this.getDate(method, entity));
            } else if(method.getReturnType().getSimpleName().indexOf("InputStream") != -1) {
                statement.setAsciiStream(++i, this.getBlob(method, entity),1440);
            } else {
                statement.setInt(++i, this.getInt(method, entity));
            }
        }

        //为Id字段添加值
        if(idMethod.getReturnType().getSimpleName().indexOf("String") != -1) {
            statement.setString(++i, this.getString(idMethod, entity));
        } else {
            statement.setInt(++i, this.getInt(idMethod, entity));
        }

        //执行SQL语句
        statement.executeUpdate();

                //关闭预编译对象
                statement.close();

                //关闭连接
                connection.close();
    }


    /**
     * 删除
     */
    public void delete(T entity) throws Exception{
        String sql = "delete from " + entity.getClass().getSimpleName().toLowerCase() + " where ";

        //存放字符串为"id"的字段对象
        Method idMethod = null;

        //取得字符串为"id"的字段对象
        List<Method> list = this.matchPojoMethods(entity, "get");
        Iterator<Method> iter = list.iterator();
        while(iter.hasNext()) {
            Method tempMethod = iter.next();
            //如果方法名中带有ID字符串并且长度为2,则视为ID.
            if(tempMethod.getName().lastIndexOf("Id") != -1 && tempMethod.getName().substring(3).length() == 2) {
                //把ID字段的对象存放到一个变量中,然后在集合中删掉.
                idMethod = tempMethod;
                iter.remove();
            //如果方法名去掉set/get字符串以后与pojo + "id"想符合(大小写不敏感),则视为ID
            } else if((entity.getClass().getSimpleName() + "Id").equalsIgnoreCase(tempMethod.getName().substring(3))) {
                idMethod = tempMethod;
                iter.remove();
            }
        }

        sql += idMethod.getName().substring(3).toLowerCase() + " = ?";

        PreparedStatement statement = this.connection.prepareStatement(sql);

        //为Id字段添加值
        int i = 0;
        if(idMethod.getReturnType().getSimpleName().indexOf("String") != -1) {
            statement.setString(++i, this.getString(idMethod, entity));
        } else {
            statement.setInt(++i, this.getInt(idMethod, entity));
        }

        //执行
        conn.execOther(statement);
        //关闭连接
        conn.closeConn();
    }


    /**
     * 通过ID查询
     */
    public T findById(Object object) throws Exception{
        String sql = "select * from " + persistentClass.getSimpleName().toLowerCase() + " where ";

        //通过子类的构造函数,获得参数化类型的具体类型.比如BaseDAO<T>也就是获得T的具体类型
        T entity = persistentClass.newInstance();

        //存放Pojo(或被操作表)主键的方法对象
        Method idMethod = null;

        List<Method> list = this.matchPojoMethods(entity, "set");
        Iterator<Method> iter = list.iterator();

        //过滤取得Method对象
        while(iter.hasNext()) {
            Method tempMethod = iter.next();
            if(tempMethod.getName().indexOf("Id") != -1 && tempMethod.getName().substring(3).length() == 2) {
                idMethod = tempMethod;
            } else if((entity.getClass().getSimpleName() + "Id").equalsIgnoreCase(tempMethod.getName().substring(3))){
                idMethod = tempMethod;
            }
        }
        //第一个字母转为小写
        sql += idMethod.getName().substring(3,4).toLowerCase()+idMethod.getName().substring(4) + " = ?";

        //封装语句完毕,打印sql语句
        System.out.println(sql);

        //获得连接
        PreparedStatement statement = this.connection.prepareStatement(sql);

        //判断id的类型
        if(object instanceof Integer) {
            statement.setInt(1, (Integer)object);
        } else if(object instanceof String){
            statement.setString(1, (String)object);
        }

        //执行sql,取得查询结果集.
        ResultSet rs = conn.execQuery(statement);

        //记数器,记录循环到第几个字段
        int i = 0;

        //把指针指向迭代器第一行
        iter = list.iterator();

        //封装
        while(rs.next()) {
            while(iter.hasNext()) {
                Method method = iter.next();
                if(method.getParameterTypes()[0].getSimpleName().indexOf("String") != -1) {
                    //由于list集合中,method对象取出的方法顺序与数据库字段顺序不一致(比如:list的第一个方法是setDate,而数据库按顺序取的是"123"值)
                    //所以数据库字段采用名字对应的方式取.
                    this.setString(method, entity, rs.getString(method.getName().substring(3).toLowerCase()));
                } else if(method.getParameterTypes()[0].getSimpleName().indexOf("Date") != -1){
                    this.setDate(method, entity, rs.getDate(method.getName().substring(3).toLowerCase()));
                } else if(method.getParameterTypes()[0].getSimpleName().indexOf("InputStream") != -1) {
                    this.setBlob(method, entity, rs.getBlob(method.getName().substring(3).toLowerCase()).getBinaryStream());
                } else {
                    this.setInt(method, entity, rs.getInt(method.getName().substring(3).toLowerCase()));
                }
            }
        }

        //关闭结果集
        rs.close();

        //关闭预编译对象
        statement.close();

        return entity;
    }


    /**
     * 过滤当前Pojo类所有带传入字符串的Method对象,返回List集合.
     */
    private List<Method> matchPojoMethods(T entity,String methodName) {
        //获得当前Pojo所有方法对象
        Method[] methods = entity.getClass().getDeclaredMethods();

        //List容器存放所有带get字符串的Method对象
        List<Method> list = new ArrayList<Method>();

        //过滤当前Pojo类所有带get字符串的Method对象,存入List容器
        for(int index = 0; index < methods.length; index++) {
            if(methods[index].getName().indexOf(methodName) != -1) {
                list.add(methods[index]);
            }
        }
        return list;
    }


    /**
     * 方法返回类型为int或Integer类型时,返回的SQL语句值.对应get
     */
    public Integer getInt(Method method, T entity) throws Exception{
        return (Integer)method.invoke(entity, new Object[]{});
    }

    /**
     * 方法返回类型为String时,返回的SQL语句拼装值.比如'abc',对应get
     */
    public String getString(Method method, T entity) throws Exception{
        return (String)method.invoke(entity, new Object[]{});
    }

    /**
     * 方法返回类型为Blob时,返回的SQL语句拼装值.对应get
     */
    public InputStream getBlob(Method method, T entity) throws Exception{
        return (InputStream)method.invoke(entity, new Object[]{});
    }


    /**
     * 方法返回类型为Date时,返回的SQL语句拼装值,对应get
     */
    public Date getDate(Method method, T entity) throws Exception{
        return (Date)method.invoke(entity, new Object[]{});
    }


    /**
     * 参数类型为Integer或int时,为entity字段设置参数,对应set
     */
    public Integer setInt(Method method, T entity, Integer arg) throws Exception{
        return (Integer)method.invoke(entity, new Object[]{arg});
    }

    /**
     * 参数类型为String时,为entity字段设置参数,对应set
     */
    public String setString(Method method, T entity, String arg) throws Exception{
        return (String)method.invoke(entity, new Object[]{arg});
    }

    /**
     * 参数类型为InputStream时,为entity字段设置参数,对应set
     */
    public InputStream setBlob(Method method, T entity, InputStream arg) throws Exception{
        return (InputStream)method.invoke(entity, new Object[]{arg});
    }


    /**
     * 参数类型为Date时,为entity字段设置参数,对应set
     */
    public Date setDate(Method method, T entity, Date arg) throws Exception{
        return (Date)method.invoke(entity, new Object[]{arg});
    }
}

EmployeesDao继承BaseDAO,可以直接使用父类的方法，增加了代码的复用

package com.employees.dao;

import java.util.ArrayList;
import java.util.List;
import com.employees.po.Employees;

public class EmployeesDao extends BaseDAO<Employees> {

    // 添加员工信息的操作
    public boolean addEmployees(final Employees employees) throws Exception {
        save(employees);
        return true;
    }

    // 将员工信息添加到表格中
    public List<Employees> addEmployees(int id) throws Exception {
        List<Employees> lstEmployees = new ArrayList<Employees>();
        Employees employees = findById(id);
        // 将当前封转好的数据装入对象中
        lstEmployees.add(employees);
        return lstEmployees;
    }

    public void deleteEmp(final Employees entity) throws Exception {
        this.delete(entity);
    }

    public void updateEmp(final Employees entity) throws Exception {
        this.update(entity);
    }


}

po层的代码就不贴了，现在用junit4做一下测试

package com.employees.dao;

import org.junit.Test;

import com.employees.po.Employees;

public class EmployeesDaoTest {

    @Test
    public void testAdd() throws Exception {
        Employees emp = new Employees();
        emp.setPname("tly");
        emp.setPsex("男");
        emp.setPbeliefs("xxxxx");
        emp.setPaddr("天河");
        emp.setPhobby("打篮球");
        emp.setPsubject("计算机");
        emp.setPtel("123456");
        EmployeesDao dao = new EmployeesDao();
        dao.addEmployees(emp);
    }
    @Test
    public void testUpdate() throws Exception {
        EmployeesDao dao = new EmployeesDao();
        Employees emp = dao.findById(14);
        emp.setPtel("999999");
        dao.updateEmp(emp);
    }
    @Test
    public void testdelete() throws Exception {
        EmployeesDao dao = new EmployeesDao();
        Employees emp = dao.findById(15);
        dao.deleteEmp(emp);
    }

}

注：该段内容来自：cnblogs：牛奶、不加糖