SpringBoot数据访问-------------MySQL数据库

最新推荐文章于 2023-04-24 08:50:39 发布

weixin_30699741

最新推荐文章于 2023-04-24 08:50:39 发布

阅读量83

点赞数

CC 4.0 BY-SA版权

文章标签：数据库 java 测试

原文链接：http://www.cnblogs.com/youzhongmin/p/10163845.html

本文详细介绍了在Spring框架中如何配置MySQL数据源，包括使用c3p0连接池进行参数设置，以及自定义的数据库操作DAO层实现。涵盖了数据源配置、连接管理、SQL执行、结果集解析、异常处理等关键环节。

数据源配置

<?xml version="1.0" encoding="UTF-8"?>
<beans
 xmlns="http://www.springframework.org/schema/beans"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:p="http://www.springframework.org/schema/p"
 xmlns:util="http://www.springframework.org/schema/util"
 xmlns:mvc="http://www.springframework.org/schema/mvc"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:task="http://www.springframework.org/schema/task"
 xmlns:rabbit="http://www.springframework.org/schema/rabbit"
 xmlns:cache="http://www.springframework.org/schema/cache"
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
                    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                    http://www.springframework.org/schema/context
                    http://www.springframework.org/schema/context/spring-context-3.0.xsd
                    http://www.springframework.org/schema/mvc
                    http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
                    http://www.springframework.org/schema/util
                    http://www.springframework.org/schema/util/spring-util-3.0.xsd
                    http://www.springframework.org/schema/task
                    http://www.springframework.org/schema/task/spring-task-3.0.xsd
                    http://www.springframework.org/schema/rabbit
                    http://www.springframework.org/schema/rabbit/spring-rabbit-1.0.xsd
                    http://www.springframework.org/schema/cache
           			http://www.springframework.org/schema/cache/spring-cache.xsd">

<!-- spring的属性加载器，加载properties文件中的属性 -->  
<bean id="propertyConfigurer"  
    class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
    <property name="location">  
        <value>classpath:common.properties</value>  
    </property>
    <property name="fileEncoding" value="utf-8" />  
</bean>
<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"  destroy-method="close">      
 		<property name="driverClass">
			<value>com.mysql.jdbc.Driver</value>
		</property>
		<property name="jdbcUrl">
			<value>jdbc:mysql://${mysql.db.ip}:${mysql.db.port}/${mysql.db.database}?useUnicode=true&characterEncoding=UTF-8</value>
		</property>
		<property name="user">
			<value>${mysql.db.user}</value>
		</property>
		<property name="password">
			<value>${mysql.db.password}</value>
		</property>
		<!--连接池中保留的最小连接数。 -->
		<property name="minPoolSize">
			<value>1</value>
		</property>
		<!--连接池中保留的最大连接数。Default: 15 -->
		<property name="maxPoolSize">
			<value>15</value>
		</property>
		<!--初始化时获取的连接数，取值应在minPoolSize与maxPoolSize之间。Default: 3 -->
		<property name="initialPoolSize">
			<value>1</value>
		</property>
		<!--最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 -->
		<property name="maxIdleTime">
			<value>60</value>
		</property>
		<!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 -->
		<property name="acquireIncrement">
			<value>5</value>
		</property>
		<!--JDBC的标准参数，用以控制数据源内加载的PreparedStatements数量。但由于预缓存的statements 属于单个connection而不是整个连接池。所以设置这个参数需要考虑到多方面的因素。 
			如果maxStatements与maxStatementsPerConnection均为0，则缓存被关闭。Default: 0 -->
		<property name="maxStatements">
			<value>0</value>
		</property>
		<!--每60秒检查所有连接池中的空闲连接。Default: 0 -->
		<property name="idleConnectionTestPeriod">
			<value>60</value>
		</property>
		<!--定义在从数据库获取新连接失败后重复尝试的次数。Default: 30 -->
		<property name="acquireRetryAttempts">
			<value>30</value>
		</property>
		<!--获取连接失败将会引起所有等待连接池来获取连接的线程抛出异常。但是数据源仍有效 保留，并在下次调用getConnection()的时候继续尝试获取连接。如果设为true，那么在尝试 
			获取连接失败后该数据源将申明已断开并永久关闭。Default: false -->
		<property name="breakAfterAcquireFailure">
			<value>true</value>
		</property>
		<!--因性能消耗大请只在需要的时候使用它。如果设为true那么在每个connection提交的 时候都将校验其有效性。建议使用idleConnectionTestPeriod或automaticTestTable 
			等方法来提升连接测试的性能。Default: false -->
		<property name="testConnectionOnCheckout">
			<value>false</value>
		</property>
</bean>
	<!-- 连接管理对象 -->
	<bean id="c3P0ConnectionProvider"
		class="com.kingdee.mysql.provider.C3P0ConnectionProvider">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
</beans>

　数据源生成器代码

package com.kingdee.mysql.provider;

import java.sql.Connection;

public interface ConnecttionProvider {

	public Connection getConnection()throws Exception;
}

package com.kingdee.mysql.provider;

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

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.ImportResource;
import org.springframework.stereotype.Component;

@Component
public class C3P0ConnectionProvider implements ConnecttionProvider{

	@Autowired
	private DataSource dataSource;
	public Connection getConnection() throws Exception {
		// TODO Auto-generated method stub
		Connection connection = dataSource.getConnection();
		return connection;
	}
	public DataSource getDataSource() {
		return dataSource;
	}
	public void setDataSource(DataSource dataSource){
		if(dataSource == null){
			System.out.println("===null====");
		}else {
			System.out.println("======!!!!null");
		}
		this.dataSource = dataSource;
	}

}

package com.kingdee.dao.impl;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.Map;
import org.hibernate.validator.internal.util.privilegedactions.GetMethod;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.util.StringUtils;

import com.kingdee.dao.IPage;
import com.kingdee.dao.JdbcUtil;
import com.kingdee.mysql.provider.ConnecttionProvider;
import com.mysql.cj.jdbc.result.ResultSetMetaData;
import com.sun.org.apache.xerces.internal.util.SynchronizedSymbolTable;
import com.sun.xml.internal.bind.v2.schemagen.xmlschema.List;

public class CommonDao {

	private static Logger logger = LoggerFactory.getLogger(CommonDao.class);
	@Autowired
	private ConnecttionProvider c3P0ConnectionProvider;
	
	public ConnecttionProvider getC3P0ConnectionProvider() {
		return c3P0ConnectionProvider;
	}
	public void setC3P0ConnectionProvider(ConnecttionProvider c3p0ConnectionProvider) {
		c3P0ConnectionProvider = c3p0ConnectionProvider;
	}
	public IPage getPage() {
		return page;
	}
	public void setPage(IPage page) {
		this.page = page;
	}

	private static ThreadLocal<Connection> connWrapper = new ThreadLocal<Connection>();
	
	@Autowired
	private IPage page;
	
	public Connection getConnection() throws Exception {

		Connection connection = connWrapper.get();
		if (connection != null && !connection.isClosed()) {
			return connection;
		}
		// 取连接并放入线程属性域中
		connection = c3P0ConnectionProvider.getConnection();
		if (connection == null) {
			throw new SQLException("无法获取数据库连接");
		}
		connWrapper.set(connection);
		return connection;
	}
	// 如果当前线程有连接则调用该方法关闭掉
	public static void closeConnection() {
		Connection conn = connWrapper.get();
		if (conn != null) {
			try {
				conn.close();
			} catch (SQLException e) {
				logger.error("Can not close database connection", e);
			}
			// 释放掉保存的对象
			connWrapper.remove();
			}
		}
	public Method getMethod(Method[] methods,String pre, String name){
		for(Method method:methods){
			String methodname = method.getName();
			if (methodname.equalsIgnoreCase(pre+name)) {
				return method;
			}
		}
		return null;
	}
		
	public void cleanup(ResultSet set,PreparedStatement pre){
		if (set!=null) {
			try{
				set.close();
			}catch(SQLException e){
				
			}
		}
		cleanup(pre);
	}
	public void cleanup(PreparedStatement pre){
		if (pre!=null) {
			try{
				pre.close();
			}catch(SQLException e){
					
			}
		}
	}
	public void cleanup(Statement stat) {

		if (stat != null) {
			try {
				stat.close();
			} catch (SQLException e) {
				// ignore
			}
		}
	}
	public <T> LinkedList<T> queryBeans(String sql, Object[] params, Class<T> clazz, int offset, int limit) throws Exception{
		Connection con = getConnection();
		LinkedList<T> result = new LinkedList<T>();
		sql = page.formatPageSQL(sql, offset, limit);
		ResultSet rs = null;
		PreparedStatement pre = null;
		try{
			pre = con.prepareStatement(sql);
			if(params!=null&&params.length>0){
				for(int i=0;i<params.length;i++){
					pre.setObject(i+1, params[i]);
				}
			}
			rs = pre.executeQuery();
			ResultSetMetaData RSMD = (ResultSetMetaData) rs.getMetaData();
			int count = RSMD.getColumnCount();
			Method[] methods = clazz.getMethods();
			while(rs.next()){
				T bean = clazz.newInstance();
				for(int i=1;i<=count;i++){
					String name = RSMD.getColumnName(i);
					Method method = getMethod(methods,"set",name);
					if (method==null) {
						continue;
					}
					Class[] arguments = method.getParameterTypes();
					Object value = JdbcUtil.getResultSetValue(rs, i, arguments[0]);
					method.invoke(bean, value);
				}
				result.add(bean);
			}
		}finally{
			cleanup(rs, pre);
			closeConnection();
		}
		return result;
	}
	public LinkedList<HashMap<String,Object>> query(String sql, Object[] params, int offset, int limit) throws Exception{
		Connection con = getConnection();
		sql = page.formatPageSQL(sql, offset, limit);
		ResultSet rs = null;
		PreparedStatement pre = null;
		LinkedList<HashMap<String,Object>> result = new LinkedList<HashMap<String,Object>>();
		try{
			pre = con.prepareStatement(sql);
			if(params!=null&&params.length>0){
				for(int i=0;i<params.length;i++){
					pre.setObject(i+1, params[i]);
				}
			}
			rs = pre.executeQuery();
			ResultSetMetaData RSMD = (ResultSetMetaData) rs.getMetaData();
			int count = RSMD.getColumnCount();
			while(rs.next()){
				HashMap<String,Object> map = new HashMap<String,Object>();
				for(int i=1;i<=count;i++){
					Object value = rs.getObject(i);
					String name = RSMD.getColumnName(i);
					map.put(name, value);
				}
				result.add(map);
			}
		}finally{
			cleanup(rs, pre);
			closeConnection();
		}
		return result;
	}

	/**
	 * 查询单一的实体对象
	 * 
	 * @param <T>
	 * @param sql
	 * @param clazz
	 * @return
	 */
	public <T> T querySingleBean(String sql, Class<T> clazz)
			throws Exception {
		return this.querySingleBean(sql, new Object[0], clazz);
	}

	public <T> T querySingleBean(String sql, Object[] params,
			Class<T> clazz) throws Exception {
		LinkedList<T> beans = this.queryBeans(sql, params, clazz);
		if (beans == null || beans.isEmpty()) {
			return null;
		}
		return beans.get(0);
	}

	public <T> T querySingleBean(String sql, Class<T> clazz,
			Object... params) throws Exception {
		if (params == null) {
			return querySingleBean(sql, (Object[]) null, clazz);
		}
		return querySingleBean(sql, params, clazz);
	}

	/**
	 * 支持分页的查询
	 * 
	 * @param <T>
	 * @param sql
	 * @param clazz
	 * @param offset
	 * @param limit
	 * @return
	 * @throws Exception
	 */
	public <T> LinkedList<T> queryBeans(String sql, Class<T> clazz,
			int offset, int limit) throws Exception {
		return queryBeans(sql, null, clazz, offset, limit);
	}

	/**
	 * 
	 * @param <T>
	 * @param sql
	 * @param clazz
	 * @return
	 * @throws Exception
	 */
	public <T> LinkedList<T> queryBeans(String sql, Class<T> clazz)
			throws Exception {
		return this.queryBeans(sql, new Object[0], clazz);
	}

	

	/**
	 * 
	 * @param sql
	 * @param params
	 * @return
	 */
	public <T> LinkedList<T> queryBeans(String sql, Object[] params,
			Class<T> clazz) throws Exception {
		return queryBeans(sql, params, clazz, 0, 0);
	}

	public <T> LinkedList<T> queryBeans(String sql, Class<T> clazz,
			Object[] params) throws Exception {
		return queryBeans(sql, params, clazz, 0, 0);
	}

	public <T> LinkedList<T> queryBeans(String sql, Class<T> clazz,
			int offset, int limit, Object... params) throws Exception {
		return queryBeans(sql, (Object[]) params, clazz, offset, limit);
	}

	/**
	 * 查询
	 * 
	 * @param sql
	 * @return
	 */
	public LinkedList<HashMap<String, Object>> query(String sql) throws Exception {
		return this.query(sql, 0,0);
	}

	public LinkedList<HashMap<String, Object>> query(String sql, int offset, int limit)
			throws Exception {
		return this.query(sql, (String[]) null, offset, limit);
	}

	public LinkedList<HashMap<String, Object>> query(String sql, Object[] params)
			throws Exception {
		return this.query(sql, params, 0,0);
	}

	public HashMap<String, Object> querySingle(String sql, Object[] params)
			throws Exception {
		LinkedList<HashMap<String, Object>> result = query(sql, params);
		if (result.isEmpty()) {
			return null;
		}
		return result.get(0);
	}

	/**
	 * @deprecated
	 * @param sql
	 * @param params
	 * @return
	 */
	public <T> int countBeans(String sql, Object[] params,
			Class<T> clazz) throws Exception {
		LinkedList<T> result = this.queryBeans(sql, params, clazz);
		return result == null ? -1 : result.size();

	}

	/**
	 * 查询数据库中的单一整形字段
	 * 
	 * @param sql
	 * @param params
	 * @return
	 * @throws Exception
	 */

	public int queryIntegerValue(String sql, Object[] params) throws Exception {
		LinkedList<HashMap<String, Object>> result = this.query(sql, params);
		if (result == null || result.isEmpty()) {
			return -1;
		}
		HashMap<String, Object> data = result.get(0);
		Object[] ret = data.values().toArray();
		if (ret.length == 0 || ret[0] == null) {
			return -1;
		}
		return ((Number) ret[0]).intValue();
	}

	public int queryIntegerValue(String sql) throws Exception {
		return this.queryIntegerValue(sql, new Object[0]);
	}

	public int count(String sql) throws Exception {
		return this.queryIntegerValue(sql, new Object[0]);
	}

	public int count(String sql, Object[] params) throws Exception {
		return this.queryIntegerValue(sql, params);

	}

	/**
	 * 执行数据的更新操作
	 * 
	 * @param sql
	 * @param params
	 * @return
	 * @throws Exception
	 */
	public int execute(String sql) throws Exception {
		return this.execute(sql, new Object[0]);
	}

	// note:UPDATE和DELETE操作能返回被操作到的行数，INSERT成功则都是返回0
	public int execute(String sql, Object[] params) throws Exception {
		Connection conn = getConnection();
		PreparedStatement ps = null;
		try {
			ps = conn.prepareStatement(sql);
			for (int i = 0; i < params.length; i++) {
				ps.setObject(i + 1, params[i]);
			}

			return ps.executeUpdate();

		} finally {
			cleanup(ps);
			closeConnection();
		}

	}
	

	public boolean existByCondition(String tableName, String condition,
			Object... params) throws Exception {

		return this.count("select count(0) from " + tableName + " where "
				+ condition, params) != 0;

	}

	/**
	 * 执行删除操作
	 * 
	 * @param tableName
	 * @param conditions
	 * @param params
	 * @throws Exception
	 */
	public int delete(String tableName, String conditions, Object... params)
			throws Exception {
		StringBuffer sql = new StringBuffer("DELETE FROM ");
		sql.append(tableName);
		sql.append(" WHERE ");
		sql.append(conditions);
		return this.execute(sql.toString(), params);

	}

	public <T> int createBean(T bean, String tableName)
			throws Exception {

		return this.createBean(bean, tableName, null);

	}

	/**
	 * 在数据库中创建一个对象： 使用约定优于配置的方式 <br>
	 * 1.所有的get属性的字段与数据库中对应 <br>
	 * 2.表名与实体名对应(或者需要将表名传递进来)<br>
	 * 
	 * @param <T>
	 * @param bean
	 * @return
	 * @throws Exception
	 */

	public <T> int createBean(T bean, String tableName,
			LinkedList<String> ignoreFieldNames) throws Exception {

		// 分析bean中的数据
		Class clazz = bean.getClass();
		Map<String, Object> data = new LinkedHashMap<String, Object>();

		Field[] fields = clazz.getDeclaredFields();
		Method[] allMethods = clazz.getMethods();
		for (Field f : fields) {
			if (!Modifier.isStatic(f.getModifiers())) {
				String name = f.getName();

				if (ignoreFieldNames != null && ignoreFieldNames.contains(name)) {
					continue;
				}

				// 忽略javabean字段的大小写
				Method method = this.getMethod(allMethods,"get", name);
				if (method != null) {
					data.put(f.getName(), method.invoke(bean, new Object[0]));

				}

			}

		}

		// 合成insert SQL语句
		StringBuffer sql = new StringBuffer("INSERT INTO " + tableName
				+ data.keySet().toString().replace("[", "(").replace("]", ")")
				+ " VALUES(");

		LinkedList<Map.Entry<String, Object>> entrys = new LinkedList<Map.Entry<String, Object>>(
				data.entrySet());
		int size = entrys.size();
		Object[] params = new Object[size];
		for (int i = 0; i < size; i++) {
			Map.Entry<String, Object> entry = entrys.get(i);
			sql.append("?");
			if (i != size - 1) {
				sql.append(",");
			}
			params[i] = entry.getValue();
		}

		sql.append(")");

		// 执行sql
		return this.execute(sql.toString(), params);

	}

	public <T> int createBean(T bean) throws Exception {
		return this.createBean(bean, bean.getClass().getSimpleName());

	}

	/**
	 * 
	 * @param <T>
	 * @param bean
	 * @param idcol
	 * @param tableName
	 * @return
	 * @throws Exception
	 */

	private static boolean isIgnoreCols(String colName, String[] ignoreCols) {
		for (String ignoreCol : ignoreCols) {
			if (ignoreCol.equalsIgnoreCase(colName)) {
				return true;
			}
		}

		return false;

	}

	public <T> int updateBeanByCondition(T bean,
			String condition, String tableName) throws Exception {
		return updateBeanByCondition(bean, condition, tableName, new String[0]);

	}

	public <T> int updateBeanByCondition(T bean,
			String condition, String tableName, String[] ignoreCols)
			throws Exception {
		// 分析bean中的数据
		Class clazz = bean.getClass();
		Map<String, Object> data = new LinkedHashMap<String, Object>();
		Field[] fields = clazz.getDeclaredFields();
		Method[] allMethods = clazz.getMethods();
		for (Field f : fields) {
			if (!Modifier.isStatic(f.getModifiers())) {
				String name = f.getName();

				// 有需要忽略的列，则不生成指定的字段的sql
				if (ignoreCols != null && isIgnoreCols(name, ignoreCols)) {
					continue;
				}

				Method method = this.getMethod(allMethods,"get", name);
				if (method != null) {
					Object value = method.invoke(bean, new Object[0]);
					if (value != null) {
						data.put(f.getName() + "=?", value);
					}
				}
			}
		}
		// 合成update SQL语句
		String sql = "UPDATE " + tableName + " SET "
				+ data.keySet().toString().replace("[", "").replace("]", "")
				+ " WHERE " + condition;
		return this.execute(sql.toString(), data.values().toArray());

	}

	public <T> int updateBean(T bean, String idcol,
			String tableName, String[] ignoreCols) throws Exception {
		// 分析bean中的数据
		Class clazz = bean.getClass();
		Map<String, Object> data = new LinkedHashMap<String, Object>();
		Field[] fields = clazz.getDeclaredFields();
		Method[] allMethods = clazz.getMethods();
		Object idvalue = "";
		for (Field f : fields) {
			if (!Modifier.isStatic(f.getModifiers())) {
				String name = f.getName();

				// 有需要忽略的列，则不生成指定的字段的sql
				if (ignoreCols != null && isIgnoreCols(name, ignoreCols)) {
					continue;
				}
				Method method = this.getMethod(allMethods,"get", name);
				if (method != null) {
					Object value = method.invoke(bean, new Object[0]);
					data.put(f.getName() + "=?", value);
					if (name.equals(idcol)) {// 获得ID条件
						idvalue = value;
					}
				}
			}
		}
		// 合成update SQL语句
		String sql = "UPDATE " + tableName + " SET "
				+ data.keySet().toString().replace("[", "").replace("]", "")
				+ " WHERE " + idcol + "='" + idvalue + "'";
		return this.execute(sql.toString(), data.values().toArray());
	}
	
	/**
	 * 执行批量sql语句
	 * @param sql
	 * @return
	 * @throws Exception
	 */
	public int[] excute(String[] sql) throws Exception {
		Connection conn = getConnection();
		Statement sta = null;
		try {
			sta = conn.createStatement();
			for(String temp : sql) {
				sta.addBatch(temp);
			}
			return sta.executeBatch();
		} finally {
			cleanup(sta);
			closeConnection();
		}
	}

	/**
	 * 执行批量sql语句
	 * @param sql
	 * @return
	 * @throws Exception
	 */
	public int[] excutePrepare(String sql, LinkedList<Object[]> params) throws Exception {
		Connection conn = getConnection();
		PreparedStatement ps = null;
		try {
			ps = conn.prepareStatement(sql);
			int count = 1;
			for(Object[] temp : params) {
				int i = 1;
				for(Object tp1 : temp) {
					if(tp1 instanceof Integer) {
						ps.setInt(i, (Integer) tp1);
					} else if(tp1 instanceof Double) {
						ps.setDouble(i, (Double) tp1);
					} else if(tp1 instanceof String) {
						ps.setString(i, (String) tp1);
					} else if(tp1 instanceof Date) {
						ps.setDate(i, (java.sql.Date) tp1);
					}
					i ++;
				}
				ps.addBatch();
				if(count% 50 ==0) {
					ps.executeBatch();
					ps.clearBatch();
				}
				count ++;
			}
			return  ps.executeBatch();
		} finally {
			cleanup(ps);
			closeConnection();;
		}
	}	
}

package com.kingdee.dao;

import org.springframework.stereotype.Component;

@Component("page")
public class MySQLPage implements IPage{

	public String formatPageSQL(String sql, int offset, int limit) {
		// TODO Auto-generated method stub
		if(offset<0){
			offset=0;
		}
		if(limit<0){
			limit=0;
		}
		if(offset==0&&limit==0){
			return sql;
		}
		if(offset>0&&limit==0){
			limit = Integer.MAX_VALUE;
		}
		sql = sql + "limit " + offset + " , "+ limit;
		return sql;
	}

}

package com.kingdee.dao;

import java.math.BigDecimal;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.ResultSet;
import java.sql.SQLException;

public class JdbcUtil {
		/**
		 * 
		 * @param rs
		 * @param index
		 * @param requiredType
		 * @return
		 * @throws SQLException
		 */
		public static Object getResultSetValue(ResultSet rs, int index, Class requiredType) throws SQLException {
			if (requiredType == null) {
				return getResultSetValue(rs, index);
			}

			Object value = null;
			boolean wasNullCheck = false;

			// Explicitly extract typed value, as far as possible.
			if (String.class.equals(requiredType)) {
				value = rs.getString(index);
			}
			else if (boolean.class.equals(requiredType) || Boolean.class.equals(requiredType)) {
				value = rs.getBoolean(index);
				wasNullCheck = true;
			}
			else if (byte.class.equals(requiredType) || Byte.class.equals(requiredType)) {
				value = rs.getByte(index);
				wasNullCheck = true;
			}
			else if (short.class.equals(requiredType) || Short.class.equals(requiredType)) {
				value = rs.getShort(index);
				wasNullCheck = true;
			}
			else if (int.class.equals(requiredType) || Integer.class.equals(requiredType)) {
				value = rs.getInt(index);
				wasNullCheck = true;
			}
			else if (long.class.equals(requiredType) || Long.class.equals(requiredType)) {
				value = rs.getLong(index);
				wasNullCheck = true;
			}
			else if (float.class.equals(requiredType) || Float.class.equals(requiredType)) {
				value = rs.getFloat(index);
				wasNullCheck = true;
			}
			else if (double.class.equals(requiredType) || Double.class.equals(requiredType) ||
					Number.class.equals(requiredType)) {
				value = rs.getDouble(index);
				wasNullCheck = true;
			}
			else if (byte[].class.equals(requiredType)) {
				value = rs.getBytes(index);
			}
			else if (java.sql.Date.class.equals(requiredType)) {
				value = rs.getDate(index);
			}
			else if (java.sql.Time.class.equals(requiredType)) {
				value = rs.getTime(index);
			}
			else if (java.sql.Timestamp.class.equals(requiredType) || java.util.Date.class.equals(requiredType)) {
				value = rs.getTimestamp(index);
			}
			else if (BigDecimal.class.equals(requiredType)) {
				value = rs.getBigDecimal(index);
			}
			else if (Blob.class.equals(requiredType)) {
				value = rs.getBlob(index);
			}
			else if (Clob.class.equals(requiredType)) {
				value = rs.getClob(index);
			}
			else {
				// Some unknown type desired -> rely on getObject.
				value = getResultSetValue(rs, index);
			}

			// Perform was-null check if demanded (for results that the
			// JDBC driver returns as primitives).
			if (wasNullCheck && value != null && rs.wasNull()) {
				value = null;
			}
			return value;
		}
		/**
		 * @see org.springframework.jdbc.support.JdbcUtils
		 * @param rs
		 * @param index
		 * @return
		 * @throws SQLException
		 */
		public static Object getResultSetValue(ResultSet rs, int index) throws SQLException {
			return org.springframework.jdbc.support.JdbcUtils.getResultSetValue(rs, index);
		}
	}

package com.kingdee.dao;

public interface IPage {

	public String formatPageSQL(String sql, int offset, int limit);
}

转载于:https://www.cnblogs.com/youzhongmin/p/10163845.html