SpringBoot BasicService

 Springboot 使用的配置数据库

spring:
    datasource:
       url: jdbc:mysql://*.*.*.*:3306/absplus?characterEncoding=utf8
       username: root
       password: ******
       driver-class-name: com.mysql.cj.jdbc.Driver
       type: com.alibaba.druid.pool.DruidDataSource
       filters: stat
       druid:
         initiaSize: 5
         minIdle: 5
         maxActive: 20
         maxWait: 60000
         timeBetweenEvictionRunsMillis: 60000
         minEvictablIdleTimeMills: 300000
         validationQuery: SELECT 1 FROM DUAL
         testWhileIdle: true
         testOnBorrow: false
         testOnReturn: false
         poolPreparedStatements: true
         filter:
             stat:
               enabled: true
         maxPoolPreparedStatementPerConnectionSize: 20
         useGlobalDataSourceStat: true
         connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

 IAbsBasicService

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

import javax.sql.DataSource;

import com.abs.system.util.Params;

public interface IAbsBasicService {

	DataSource dataSource = null;

	public <T> void addEntity(T obj);

	public <T> void delEntity(T obj);

	public <T> void updateEntity(T record,String primekey);

	public <T> void batchAddObjectList(List<T> list_obj);

	public <T> void delByGuid(String rowguid, Class<T> clazz);

	public void delByGuid(String fmguid, String tablename);

	public <T> T findOneEntityByGuid(String rowguid, Class<T> clazz);

	public <T> T findOneByCondition(String sqlcondition, Class<T> clazz);

	public <T> List<T> findPageList(int pagesize, int pagenum, Class<T> clazz);

	public <T> List<T> findPageListByCondition(int pagesize, int pagenum, Class<T> clazz, String sqlCondition);

	public List<Params> findPageListRecordBySql(int pagesize, int pageno, String sql);

	public List<Params> findListRecordBySql(String sql);

	public <T> List<T> getListByCondition(String sqlCondition, Class<T> clazz);

	public long count(String sql);

	public <T> long countByCondition(Class<T> clazz, String sqlcondition);

	public <T> T getFieldByCondition(String sqlCondition, String colname, Class<?> clazz);

	public <T> void execSql(String sql);

	public <T> List<String> getListFieldByCondition(String sqlCondition, String colname, Class<?> clazz);

	public <T> List<Map<String, Object>> findPageListLimitFiled(int pagesize, int pagenum, Class<T> clazz, String sqlCondition, String[] fields);

	public List<Params> findListRecordById(String rowguid, Params record);
	
	
	public void close();
	
	public void setAutoCommit(boolean floag);
	
}

  AbsBasicServiceImpl

import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import javax.management.RuntimeErrorException;
import javax.persistence.Id;
import javax.persistence.Table;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.dao.RecoverableDataAccessException;
import org.springframework.jdbc.core.BatchPreparedStatementSetter;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.PreparedStatementSetter;
import org.springframework.stereotype.Repository;

import com.abs.system.api.IAbsBasicService;
import com.abs.system.util.BasicServiceUtil;
import com.abs.system.util.ConstantUtil;
import com.abs.system.util.MSG;
import com.abs.system.util.Params;
import com.abs.system.util.StrUtil;

/**
 * **v1.0 优化相关的查询 **v1.01 增加日志
 * 
 * @author wdg
 * 
 * @date 2020-12-11 多线程查询
 *
 */

@Repository
public class AbsBasicServiceImpl implements IAbsBasicService {

	private static Logger logger = LoggerFactory.getLogger(AbsBasicServiceImpl.class);

	@Autowired
	private JdbcTemplate jdbcTemplate;

	/**
	 * 新增v1.1 date 2021-03-15
	 * 
	 * @param entity 要添加的实体
	 * @return 新增成功 返回true 新增失败 返回false
	 */

	public <T> void addEntity(T entity) {
		// Connection conn = null;
		// Savepoint point = null;
		try {
			logger.info("****添加实体类addEntity*******");
			// conn = jdbcTemplate.getDataSource().getConnection();
			// conn.setAutoCommit(false);
			if (entity == null) {
				throw new RuntimeErrorException(new Error(), MSG.EntityCanNotNull);
			}
			logger.info("生成插入sql");
			// point = conn.setSavepoint();
			String sql = BasicServiceUtil.generateInsertSql(entity.getClass());
			Field[] fields = entity.getClass().getDeclaredFields();
			PreparedStatementSetter setter = new PreparedStatementSetter() {
				@Override
				public void setValues(PreparedStatement ps) throws SQLException {
					for (int j = 0; j < fields.length; j++) {
						// 获取方法
						PropertyDescriptor pd = null;

						/*
						 * try { pd = new PropertyDescriptor(fields[j].getName(),entity.getClass()); }
						 * catch (IntrospectionException e1) { e1.printStackTrace(); }
						 */

						pd = BeanUtils.getPropertyDescriptor(entity.getClass(), fields[j].getName());

						Method getMethod = pd.getReadMethod();
						try {
							ps.setObject(j + 1, getMethod.invoke(entity));
						} catch (IllegalAccessException e) {
							e.printStackTrace();
						} catch (IllegalArgumentException e) {
							e.printStackTrace();
						} catch (InvocationTargetException e) {
							e.printStackTrace();
						}
					}
				}
			};
			jdbcTemplate.update(sql, setter);
			// conn.commit();
		} catch (Exception e) {
			logger.error("****添加实体失败{}*****", e.getMessage());
			throw new RuntimeErrorException(new Error(), e.getMessage());
		}
		logger.info("****结束实体类addEntity*******");

	}

	/**
	 * **@param 要删除的对象 ****删除对象v1.0
	 */

	@Override
	public <T> void delEntity(T obj) {
		logger.info("*****删除对象del方法正在执行******");
		try {
			String tablename = "";
			Table table = obj.getClass().getAnnotation(Table.class);
			if (table != null && StrUtil.isNotBlank(table.name())) {
				tablename = table.name();
			}
			Method method = obj.getClass().getDeclaredMethod("getRowguid");
			String rowguid = (String) method.invoke(obj);
			String sql = "delete from " + tablename + " where rowguid=\'" + rowguid + "\'";
			logger.info("删除:{}", sql);
			jdbcTemplate.execute(sql);
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeErrorException(new Error(), e.getMessage());
		}
		logger.info("删除成功");
	}

	/**
	 **** 分页查询 v1.0
	 *** 
	 * @param pagesize 每页的个数 pagenum 当前页码 clazz 实体类类型 sqlCondition 条件
	 * @return 返回查询list
	 */
	public <T> List<T> findPageListByCondition(int pagesize, int pagenum, Class<T> clazz, String sqlCondition) {
		logger.debug("******开始调用findPageList******");
		String sql = BasicServiceUtil.generateSelectSql(clazz);
		if (StrUtil.isNotBlank(sqlCondition)) {
			sql = sql + sqlCondition + " limit " + pagesize * pagenum + "," + pagesize;
		} else {
			sql = sql + " limit " + pagesize * pagenum + "," + pagesize;
		}
		logger.info("分页查询:{}", sql);
		List<Map<String, Object>> list = jdbcTemplate.queryForList(sql);
		List<T> list_t = BasicServiceUtil.generateEntityListByMapList(list, clazz);
		logger.debug("结束调用findPageList ：{}", list_t.size());
		return list_t;
	}

	/**
	 **** 分页有限字段
	 */

	@Override
	public <T> List<Map<String, Object>> findPageListLimitFiled(int pagesize, int pagenum, Class<T> clazz,
			String sqlCondition, String[] fields) {
		ExecutorService executor = Executors.newFixedThreadPool(2);
		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
		Callable myCallable = new Callable() {
			@Override
			public List<Map<String, Object>> call() throws Exception {
				String tablename = "";
				Table table = clazz.getAnnotation(Table.class);
				if (table != null && StrUtil.isNotBlank(table.name())) {
					tablename = table.name();
				}
				StringBuffer sb = new StringBuffer();
				for (String f : fields) {
					sb = sb.append(f).append(",");
				}
				String sqlfileds = sb.toString().substring(0, sb.lastIndexOf(","));
				String sql = null;
				if (StrUtil.isNotBlank(sqlCondition)) {
					sql = "select " + sqlfileds + " from " + tablename + " where 1=1 " + sqlCondition + " limit "
							+ pagesize * pagenum + "," + pagesize;
				} else {
					sql = "select " + sqlfileds + " from " + tablename + " limit " + pagesize * pagenum + ","
							+ pagesize;
				}
				logger.info("分页有限字段:{}", sql);
				List<Object> list = new ArrayList<Object>();
				List<Map<String, Object>> list1 = jdbcTemplate.queryForList(sql);
				return list1;
			}
		};

		try {
			Future future = executor.submit(myCallable);
			list = (List<Map<String, Object>>) future.get();
			future.cancel(true);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return list;

	}

	public <T> List<T> findPageList(int pagesize, int pagenum, Class<T> clazz) {
		ExecutorService executor = Executors.newFixedThreadPool(2);
		List<T> list = new ArrayList<T>();
		Callable myCallable = new Callable() {
			@Override
			public List<T> call() throws Exception {
				String tablename = "";
				Table table = clazz.getAnnotation(Table.class);
				if (table != null && StrUtil.isNotBlank(table.name())) {
					tablename = table.name();
				}
				Field[] fields = clazz.getDeclaredFields();
				StringBuffer sb = new StringBuffer();
				for (Field f : fields) {
					sb = sb.append(f.getName().toLowerCase()).append(",");
				}
				String sqlfileds = sb.toString().substring(0, sb.lastIndexOf(","));
				String sql = "select " + sqlfileds + " from " + tablename + " limit " + pagesize * pagenum + ","
						+ pagesize;
				logger.info("分页查询:{}", sql);
				List<Object> list = new ArrayList<Object>();
				List<Map<String, Object>> list1 = jdbcTemplate.queryForList(sql);
				try {
					for (int i = 0; i < list1.size(); i++) {
						Map<String, Object> map = list1.get(i);
						Class<?> classType = Class.forName(clazz.getName());
						Object obj = classType.newInstance();
						for (Field field : fields) {
							String methodname = field.getName().substring(0, 1).toUpperCase()
									+ field.getName().substring(1);
							PropertyDescriptor pd = BeanUtils.getPropertyDescriptor(clazz, field.getName());
							Method setMethod = pd.getWriteMethod();// 获得set方法
							String fieldtypename = pd.getPropertyType().getCanonicalName();
							if (ConstantUtil.basicmap.containsKey(fieldtypename)) {
								if (StrUtil.isObjBlank(map.get(methodname))) {
									// 默认的空值
									setMethod.invoke(obj, ConstantUtil.basicmap.get(fieldtypename));
								} else {
									String methodName = "parse" + fieldtypename.substring(0, 1).toUpperCase()+ fieldtypename.substring(1);
									Class<?> claz = (Class<?>) ConstantUtil.parsemap.get(fieldtypename);
									Method method = claz.getMethod(methodName, String.class);
									Object value = method.invoke(null, map.get(methodname));
									setMethod.invoke(obj, value);
								}
							} else {
								setMethod.invoke(obj, map.get(methodname));
							}
						}
						list.add(obj);
					}
				} catch (Exception e) {
					e.printStackTrace();
				}
				return (List<T>) list;
			}
		};

		try {
			Future future = executor.submit(myCallable);
			list = (List<T>) future.get();
			future.cancel(true);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return list;

	}

	@Override
	public <T> void updateEntity(T record, String primekey) {
		String tablename = "";
		String rowguid = "";
		Table table = record.getClass().getAnnotation(Table.class);
		if (table != null && StrUtil.isNotBlank(table.name())) {
			tablename = table.name();
		}
		StringBuffer sb = new StringBuffer();
		StringBuffer sb1 = new StringBuffer();
		sb.append("update " + tablename.toLowerCase() + " set ");
		Field[] fields = record.getClass().getDeclaredFields();

		for (Field f : fields) {
			String methodname = f.getName().substring(0, 1).toUpperCase() + f.getName().substring(1);
			try {
				if ("rowguid".equals(methodname.toLowerCase())) {
					Method method = record.getClass().getMethod("get" + methodname, null);
					Object value = method.invoke(record, null);
					rowguid = value + "";
					continue;
				} else {
					sb1.append(f.getName());
					sb1.append("=");
					Method method = record.getClass().getMethod("get" + methodname, null);
					Object value = method.invoke(record, null);
					if (value == null) {
						sb1.append(value);
					} else {
						if (value.getClass().toString().indexOf("util.Date") > 0) {
							Date d = (Date) value;
							java.sql.Timestamp sdate = new java.sql.Timestamp(d.getTime());
							value = sdate;
						}
						sb1.append("\'" + value + "\'");
					}
					sb1.append(",");
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		String sql = sb1.toString().substring(0, sb1.toString().lastIndexOf(','));
		sql = sb.toString() + sql + " where rowguid=\'" + rowguid + "\'";
		logger.info("更新:{}", sql);
		jdbcTemplate.execute(sql);

	}

	public long count(String sql) {

		try {

			Connection conn = jdbcTemplate.getDataSource().getConnection();
			conn.setAutoCommit(false);
			logger.info("count: conn catalog：{}", conn.getCatalog());
			logger.info("count: conn.toString(){}", conn.toString());

			ExecutorService executor = Executors.newFixedThreadPool(2);
			Callable myCallable = new Callable() {
				@Override
				public Object call() throws Exception {
					Map<String, Object> map = jdbcTemplate.queryForMap(sql);
					Set<String> set = map.keySet();
					String str = "";
					for (String s : set) {
						str = s;
					}
					if (StrUtil.isStrBlank(map.get(str) + "")) {
						return 0;
					} else {
						long value = Long.parseLong((map.get(str) + "").toString());
						return value;
					}
				}
			};

			Future future = executor.submit(myCallable);
			long value = (long) future.get();
			future.cancel(true);
			return value;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return 0;
	}

	public <T> T getFieldByCondition(String sqlCondition, String colname, Class<?> clazz) {
		// TODO Auto-generated method stub
		try {
			String tablename = "";
			Table table = clazz.getAnnotation(Table.class);
			if (table != null && StrUtil.isNotBlank(table.name())) {
				tablename = table.name();
			}
			String sql = "select " + colname + " from " + tablename + " where 1=1 " + sqlCondition;
			logger.info("字段查询:sql->{}", sql);
			Map<String, Object> map = jdbcTemplate.queryForMap(sql);
			if (map == null) {
				return null;
			} else {
				Object obj = map.get(colname);
				return (T) obj;
			}
		} catch (EmptyResultDataAccessException e) {
			return null;
		}
	}

	public <T> List<String> getListFieldByCondition(String sqlCondition, String colname, Class<?> clazz) {
		// TODO Auto-generated method stub
		try {

			List<String> list_t = new ArrayList<String>();
			String tablename = "";
			Table table = clazz.getAnnotation(Table.class);
			if (table != null && StrUtil.isNotBlank(table.name())) {
				tablename = table.name();
			}
			String sql = "select " + colname + " from " + tablename + " where 1=1 " + sqlCondition;
			List<Map<String, Object>> list = jdbcTemplate.queryForList(sql);
			if (list == null) {
				return null;
			} else {
				for (Map<String, Object> map : list) {
					Object obj = map.get(colname);
					list_t.add(obj.toString());
				}
				return list_t;
			}
		} catch (EmptyResultDataAccessException e) {
			return null;
		}
	}

	public <T> T findOjectById(Class<?> clazz, Object value) {
		String tablename = "";
		Table table = clazz.getAnnotation(Table.class);
		if (table != null && StrUtil.isNotBlank(table.name())) {
			tablename = table.name();
		}
		String sql_suffix = "";
		String sql_mod = "";
		Field[] fields = clazz.getDeclaredFields();
		for (Field f : fields) {
			if (f.getAnnotation(Id.class) != null) {
				sql_suffix = " where " + f.getName().toLowerCase() + "\'" + value + "\'";
			}
			sql_mod += f.getName().toLowerCase() + ",";
		}
		sql_mod = sql_mod.substring(0, sql_mod.toString().length() - 1);
		String sql = "select " + sql_mod + " from " + tablename + sql_suffix;
		Map<String, Object> map = jdbcTemplate.queryForMap(sql);
		try {
			if (map != null) {
				Object obj = clazz.newInstance();
				for (Field f : fields) {
					// PropertyDescriptor pd = new PropertyDescriptor(f.getName(), clazz);
					PropertyDescriptor pd = BeanUtils.getPropertyDescriptor(clazz, f.getName());

					Method wM = pd.getWriteMethod();
					wM.invoke(obj, map.get(f.getName().toLowerCase()));
				}
				return (T) obj;
			} else {
				return null;
			}
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	public <T> T findOneEntityByGuid(String rowguid, Class<T> clazz) {
		String tablename = "";
		Table table = clazz.getAnnotation(Table.class);
		if (table != null && StrUtil.isNotBlank(table.name())) {
			tablename = table.name();
		}
		String sql_suffix = "";
		String sql_mod = "";
		Field[] fields = clazz.getDeclaredFields();
		sql_suffix = " where rowguid= " + "\'" + rowguid + "\'";
		for (Field f : fields) {
			sql_mod += f.getName().toLowerCase() + ",";
		}
		sql_mod = sql_mod.substring(0, sql_mod.toString().length() - 1);
		String sql = "select " + sql_mod + " from " + tablename + sql_suffix;
		logger.info("当前执行sql=>>>>>{}", sql);
		try {
			Map<String, Object> map = jdbcTemplate.queryForMap(sql);
			if (map != null) {
				Object obj = clazz.newInstance();
				for (Field field : fields) {
					String methodname = field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);
					// PropertyDescriptor pd = new PropertyDescriptor(field.getName(), clazz);
					PropertyDescriptor pd = BeanUtils.getPropertyDescriptor(clazz, field.getName());
					Method setMethod = pd.getWriteMethod();// 获得set方法
					String fieldtypename = pd.getPropertyType().getCanonicalName();
					if (ConstantUtil.basicmap.containsKey(fieldtypename)) {
						if (StrUtil.isObjBlank(map.get(methodname))) {
							// 默认的空值
							setMethod.invoke(obj, ConstantUtil.basicmap.get(fieldtypename));
						} else {
							String methodName = "parse" + fieldtypename.substring(0, 1).toUpperCase()
									+ fieldtypename.substring(1);
							Class<?> claz = (Class<?>) ConstantUtil.parsemap.get(fieldtypename);
							Method method = claz.getMethod(methodName, String.class);
							Object value = method.invoke(null, map.get(methodname) + "");
							setMethod.invoke(obj, value);
						}
					} else {
						setMethod.invoke(obj, map.get(methodname));
					}
				}
				return (T) obj;
			} else {
				return null;
			}
		} catch (EmptyResultDataAccessException e) {
			logger.info("未找到相关信息");
			return null;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/****
	 *** 优化查询v1.1
	 */
	public <T> List<T> getListByCondition(String sqlCondition, Class<T> clazz) {
		String tablename = "";
		Table table = clazz.getAnnotation(Table.class);
		if (table != null && StrUtil.isNotBlank(table.name())) {
			tablename = table.name();
		}
		Field[] fields = clazz.getDeclaredFields();
		StringBuffer sb = new StringBuffer();
		for (Field f : fields) {
			sb = sb.append(f.getName()).append(",");
		}
		String fields_str = sb.toString().substring(0, sb.toString().lastIndexOf(","));
		String sql = "select " + fields_str + " from " + tablename + " where 1=1";
		if (StrUtil.isNotBlank(sqlCondition)) {
			sql += sqlCondition;
		}
		logger.info("获取list:sql->{}", sql);
		List<Object> list = new ArrayList<Object>();
		List<Map<String, Object>> list1 = jdbcTemplate.queryForList(sql);
		try {
			for (int i = 0; i < list1.size(); i++) {
				Map<String, Object> map = list1.get(i);
				Class<?> classType = Class.forName(clazz.getName());
				Object obj = classType.newInstance();
				for (Field field : fields) {
					String methodname = field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);
					// PropertyDescriptor pd = new PropertyDescriptor(field.getName(), clazz);
					PropertyDescriptor pd = BeanUtils.getPropertyDescriptor(clazz, field.getName());
					Method setMethod = pd.getWriteMethod();// 获得set方法
					String fieldtypename = pd.getPropertyType().getCanonicalName();
					if (ConstantUtil.basicmap.containsKey(fieldtypename)) {
						if (StrUtil.isObjBlank(map.get(methodname))) {
							// 默认的空值
							setMethod.invoke(obj, ConstantUtil.basicmap.get(fieldtypename));
						} else {
							String methodName = "parse" + fieldtypename.substring(0, 1).toUpperCase()
									+ fieldtypename.substring(1);
							Class<?> claz = (Class<?>) ConstantUtil.parsemap.get(fieldtypename);
							Method method = claz.getMethod(methodName, String.class);
							Object value = method.invoke(null, map.get(methodname) + "");
							setMethod.invoke(obj, value);
						}
					} else {
						setMethod.invoke(obj, map.get(methodname));
					}
				}
				list.add(obj);
			}
		} catch (EmptyResultDataAccessException e) {
			return null;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return (List<T>) list;
	}

	@Override
	public void execSql(String sql) {
		try {
			jdbcTemplate.execute(sql);
		} catch (Exception e) {
			throw new RuntimeErrorException(new Error(), e.getMessage());
		}
	}

	@Override
	public <T> void delByGuid(String rowguid, Class<T> clazz) {
		try {
			String tablename = "";
			Table table = clazz.getAnnotation(Table.class);
			if (table != null && StrUtil.isNotBlank(table.name())) {
				tablename = table.name();
			}

			if (StrUtil.isStrBlank(tablename)) {
				throw new RuntimeErrorException(new Error(), MSG.EntityAnnotationIsNull);
			}
			String sql = "delete from " + tablename + " where rowguid=\'" + rowguid + "\'";
			jdbcTemplate.execute(sql);
		} catch (Exception e) {
			throw new RuntimeErrorException(new Error(), e.getMessage());
		}

	}

	@Override
	public void delByGuid(String rowguid, String tablename) {
		String sql = "delete from " + tablename + " where rowguid=\'" + rowguid + "\'";
		jdbcTemplate.execute(sql);
	}

	@Override
	public List<Params> findListRecordBySql(String sql) {
		logger.info("list_record:{}", sql);
		List<Map<String, Object>> list = jdbcTemplate.queryForList(sql);
		List<Params> list_r = new ArrayList<Params>();
		if (list != null) {
			for (Map<String, Object> map : list) {
				Params r = Params.getRecordByMap(map);
				list_r.add(r);
			}
		}
		return list_r;
	}

	/**
	 * **查询个体优化v1.1 ** 优化了java基本的数据类型默认赋值
	 */
	@Override
	public <T> T findOneByCondition(String sqlcondition, Class<T> clazz) {
		String tablename = "";
		Table table = clazz.getAnnotation(Table.class);
		if (table != null && StrUtil.isNotBlank(table.name())) {
			tablename = table.name();
		}
		Field[] fields = clazz.getDeclaredFields();
		StringBuffer sb = new StringBuffer();
		for (Field field : fields) {
			sb = sb.append(field.getName()).append(",");
		}
		String fields_str = sb.toString().substring(0, sb.toString().lastIndexOf(","));
		String sql = "select " + fields_str + " from " + tablename + " where 1=1" + sqlcondition + " limit 1";
		logger.info("findOneByCondition===>{}", sql);
		try {
			Map<String, Object> map = jdbcTemplate.queryForMap(sql);
			if (map == null) {
				return null;
			}
			Class<?> classType = Class.forName(clazz.getName());
			Object obj = classType.newInstance();
			for (Field field : fields) {
				String methodname = field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);
				// PropertyDescriptor pd = new PropertyDescriptor(field.getName(), clazz);
				PropertyDescriptor pd = BeanUtils.getPropertyDescriptor(clazz, field.getName());
				Method setMethod = pd.getWriteMethod();// 获得set方法
				String fieldtypename = pd.getPropertyType().getCanonicalName();
				if (ConstantUtil.basicmap.containsKey(fieldtypename)) {
					if (StrUtil.isObjBlank(map.get(methodname))) {
						// 默认的空值
						setMethod.invoke(obj, ConstantUtil.basicmap.get(fieldtypename));
					} else {
						String methodName = "parse" + fieldtypename.substring(0, 1).toUpperCase()
								+ fieldtypename.substring(1);
						Class<?> claz = (Class<?>) ConstantUtil.parsemap.get(fieldtypename);
						Method method = claz.getMethod(methodName, String.class);
						Object value = method.invoke(null, map.get(methodname) + "");
						setMethod.invoke(obj, value);
					}
				} else {
					setMethod.invoke(obj, map.get(methodname));
				}
			}
			return (T) obj;
		} catch (EmptyResultDataAccessException e) {
			return null;
		} catch (RecoverableDataAccessException e) {
			logger.info("网络异常，请稍后重试");
			throw new RuntimeErrorException(new Error(), "网络异常，请稍后重试");
		} catch (Exception e) {
			logger.info(sql);
			e.printStackTrace();
			return null;
		}
	}

	@Override
	public <T> long countByCondition(Class<T> clazz, String sqlcondition) {
		String tablename = "";
		Table table = clazz.getAnnotation(Table.class);
		if (table != null && StrUtil.isNotBlank(table.name())) {
			tablename = table.name();
		}
		String sql = "select count(1) from " + tablename + " where 1=1" + sqlcondition;
		Map<String, Object> map = jdbcTemplate.queryForMap(sql);
		Set<String> set = map.keySet();
		String str = "";
		for (String s : set) {
			str = s;
		}
		if (StrUtil.isStrBlank(map.get(str) + "")) {
			return 0;
		} else {
			long value = Long.parseLong((map.get(str) + "").toString());
			return value;
		}
	}

	@Override
	public List<Params> findPageListRecordBySql(int pagesize, int pageno, String sql) {
		String condition = " limit " + pageno * pagesize + "," + pagesize;
		List<Map<String, Object>> list = jdbcTemplate.queryForList(sql + condition);

		List<Params> list_r = new ArrayList<Params>();
		if (list != null) {
			for (Map<String, Object> map : list) {
				Params r = Params.getRecordByMap(map);
				list_r.add(r);
			}
		}
		return list_r;
	}

	/**
	 * V1.1 批量更新 ** date 2021-03-15
	 */

	@Override
	public <T> void batchAddObjectList(List<T> list) {

		logger.info("*************开始执行批量增加**************");
		if (list == null || list.size() == 0) {
			throw new RuntimeErrorException(new Error(), MSG.ListIsEmpty);
		}
		T obj_1 = list.get(0);
		String sql = BasicServiceUtil.generateInsertSql(obj_1.getClass());
		try {
			BatchPreparedStatementSetter setter = new BatchPreparedStatementSetter() {
				@Override
				public void setValues(PreparedStatement ps, int i) throws SQLException {
					T obj = list.get(i);
					Field[] fields = obj.getClass().getDeclaredFields();
					for (int j = 0; j < fields.length; j++) {
						// 获取方法
						PropertyDescriptor pd = BeanUtils.getPropertyDescriptor(obj.getClass(), fields[j].getName());
						Method getMethod = pd.getReadMethod();
						try {
							ps.setObject(j + 1, getMethod.invoke(obj));
						} catch (IllegalAccessException e) {
							e.printStackTrace();
						} catch (IllegalArgumentException e) {
							e.printStackTrace();
						} catch (InvocationTargetException e) {
							e.printStackTrace();
						}
					}
				}

				@Override
				public int getBatchSize() {
					return list.size();
				}
			};
			jdbcTemplate.batchUpdate(sql, setter);
			logger.info("****************结束调用批量更新****************");
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeErrorException(new Error(), e.getMessage());
		}

	}

	@Override
	public List<Params> findListRecordById(String sqlId, Params record) {

		return null;
	}

	@Override
	public void close() {
		// TODO Auto-generated method stub

	}

	public void setAutoCommit(boolean flag) {
		Connection conn;
		try {
			conn = jdbcTemplate.getDataSource().getConnection();
			conn.setAutoCommit(false);
			logger.info("conn catalog：{}", conn.getCatalog());
			logger.info("commit: conn.toString(){}", conn.toString());
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}