package kernel.web;

import java.lang.management.ManagementFactory;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.nio.ByteBuffer;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

import javax.management.MBeanServer;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;
import javax.management.Query;
import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.springframework.beans.BeanWrapperImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.core.convert.support.DefaultConversionService;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.StatementCallback;
import org.springframework.util.Assert;
import org.springframework.util.ReflectionUtils;
import org.springframework.util.ReflectionUtils.FieldCallback;
import org.springframework.util.ReflectionUtils.FieldFilter;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import com.beust.jcommander.Strings;
import com.google.common.collect.Sets;

import kernel.bo.RecordObjectMapper;

/**
 * @author JORGE
 * @description 应用工具
 */
@SuppressWarnings({"unchecked","rawtypes"})
public class ApplicationUtil {
	/**
	 * Servlet上下文
	 */
	private static ServletContext servletContext;
	
	/**
	 * Spring上下文
	 */
	private static WebApplicationContext applicationContext;
	
	/**
	 * 空白正则式
	 */
	private static final Pattern BLANK_REGEX=Pattern.compile("\\s+");
	
	/**
	 * 八字节缓冲
	 */
	private static final ByteBuffer EIGHT_BUFFER = ByteBuffer.allocate(8);
	
	/**
	 * 简单类型
	 */
	private static LinkedHashSet<Class<?>> SIMPLE_CLASSES=new LinkedHashSet<Class<?>>();
	
	/**
	 * 全局应用值字典
	 */
	private static final ConcurrentHashMap<String,Object> VALUE_MAP=new ConcurrentHashMap<String,Object>();
	
	/**
	 * 增删改DML操作
	 */
	private static final HashSet<String> DML_OPTIONS=new HashSet<String>(Arrays.asList("DELETE","UPDATE","INSERT"));
	
	static {
		SIMPLE_CLASSES.add(java.lang.String.class);
		SIMPLE_CLASSES.add(Integer.class);
		SIMPLE_CLASSES.add(Double.class);
		SIMPLE_CLASSES.add(Boolean.class);
		SIMPLE_CLASSES.add(Long.class);
		
		SIMPLE_CLASSES.add(java.sql.Date.class);
		SIMPLE_CLASSES.add(java.sql.Time.class);
		SIMPLE_CLASSES.add(java.util.Date.class);
		SIMPLE_CLASSES.add(java.sql.Timestamp.class);
		SIMPLE_CLASSES.add(java.util.Calendar.class);
		SIMPLE_CLASSES.add(Character.class);
		SIMPLE_CLASSES.add(Float.class);
		
		SIMPLE_CLASSES.add(int.class);
		SIMPLE_CLASSES.add(double.class);
		SIMPLE_CLASSES.add(boolean.class);
		SIMPLE_CLASSES.add(long.class);
		SIMPLE_CLASSES.add(char.class);
		SIMPLE_CLASSES.add(float.class);
		SIMPLE_CLASSES.add(byte.class);
		SIMPLE_CLASSES.add(short.class);
		SIMPLE_CLASSES.add(Byte.class);
		SIMPLE_CLASSES.add(Short.class);
	}
	
	/**
	 * 获取客户端会话对象
	 * @return 会话对象
	 */
	public static HttpSession getHttpSession(boolean... creates) {
		boolean create=(null==creates || 0==creates.length)?true:creates[0];
		HttpServletRequest request=getHttpServletRequest();
		return null==request?null:request.getSession(create);
	}
	
	/**
	 * 获取当前请求对象
	 * @return 请求对象
	 */
	public static HttpServletRequest getHttpServletRequest() {
		ServletRequestAttributes sra=getServletRequestAttributes();
		return null==sra?null:sra.getRequest();
	}
	
	/**
	 * 获取当前响应对象
	 * @return 响应对象
	 */
	public static HttpServletResponse getHttpServletResponse() {
		ServletRequestAttributes sra=getServletRequestAttributes();
		return null==sra?null:sra.getResponse();
	}
	
	/**
	 * 当前系统是否为Windows
	 */
	public static final boolean isWindows() {
		return ManagementFactory.getOperatingSystemMXBean()
				.getName().trim()
				.toLowerCase()
				.startsWith("win")?true:false;
	}
	
	/**
	 * 获取当前上下文路径
	 * @return 上下文路径
	 */
	public static String getContextPath() {
		ServletContext currentContext=getServletContext();
		return null==currentContext?null:currentContext.getContextPath();
	}
	
	/**
	 * 获取异常根因
	 * @return 异常对象
	 */
	public static Throwable getRootCause(Throwable e) {
		Throwable cause=e.getCause();
		if(null==cause) return e;
		return getRootCause(cause);
	}
	
	/**
	 * 获取异常根信息
	 * @return 异常信息
	 */
	public static String getRootMessage(Throwable e) {
		if(null==e) return null;
		return getRootCause(e).getMessage();
	}
	
	/**
	 * 是否为声明式异常类型
	 * @param e 异常实例
	 * @param method 声明方法
	 * @return 是否为声明式异常类型
	 */
	public static final boolean isDeclaredException(Throwable e,Method method) {
		if(e instanceof Error) return true;
		if(e instanceof RuntimeException) return true;
		for(Class<?> type:method.getExceptionTypes()) {
			if(type.isInstance(e)) return true;
		}
		return false;
	}
	
	/**
	 * 获取声明原因
	 * @param e 异常实例
	 * @return 声明原因
	 */
	public static final Throwable getDeclaredCause(Throwable e,Method method) {
		if(e instanceof Error) return e;
		if(e instanceof RuntimeException) return e;
		for(Class<?> type:method.getExceptionTypes()) {
			if(type.isInstance(e)) return e;
		}
		return getDeclaredCause(e.getCause(),method);
	}
	
	/**
	 * 获取当前SERVLET请求上下文
	 * @return SERVLET请求上下文
	 */
	public static ServletRequestAttributes getServletRequestAttributes() {
		RequestAttributes requestAttributes=null;
		try {
			requestAttributes=RequestContextHolder.currentRequestAttributes();
		}catch(IllegalStateException e) {
			e.printStackTrace();
		}
		
		if(null==requestAttributes) return null;
		
		return (requestAttributes instanceof ServletRequestAttributes)?(ServletRequestAttributes)requestAttributes:null;
	}
	
	/**
	 * 获取SERVLET上下文
	 * @return SERVLET上下文
	 */
	public static ServletContext getServletContext() {
		if(null==ApplicationUtil.servletContext) {
			if(null==applicationContext) return null;
			Map<String,ServletContext> scMap=applicationContext.getBeansOfType(ServletContext.class);
			if(null==scMap || scMap.isEmpty()) return null;
			if(scMap.size()>1) throw new RuntimeException("Found Multi-ServletContext In Spring ApplicationContext!");
			ApplicationUtil.servletContext=scMap.values().iterator().next();
		}
		
		return ApplicationUtil.servletContext;
	}

	/**
	 * 获取应用上下文
	 * @return 应用上下文
	 */
	public static ApplicationContext getApplicationContext() {
		if(null==ApplicationUtil.applicationContext) {
			if(null==servletContext) return null;
			Object attr = servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
			
			if (null==attr) return null;
			if (attr instanceof Error) throw (Error) attr;
			if (attr instanceof RuntimeException) throw (RuntimeException) attr;
			if (attr instanceof Exception) throw new IllegalStateException((Exception) attr);
			if (!(attr instanceof WebApplicationContext)) throw new IllegalStateException("Context attribute is not of type WebApplicationContext: " + attr);
			
			ApplicationUtil.applicationContext=(WebApplicationContext) attr;
		}
		
		return ApplicationUtil.applicationContext;
	}
	
	/**
	 * 获取应用SPRING上下文类装载器
	 * @return 类装载器
	 */
	public static ClassLoader getApplicationClassLoader() {
		ApplicationContext appContext=getApplicationContext();
		return null==appContext?null:appContext.getClass().getClassLoader();
	}
	
	/**
	 * 获取Spring应用上下文类
	 * @param classFullName 全类名
	 * @return 应用上下文类
	 */
	public static Class<?> getApplicationClass(String classFullName) {
		ClassLoader classLoader=getApplicationClassLoader();
		try {
			return null==classLoader?null:classLoader.loadClass(classFullName);
		} catch (ClassNotFoundException e) {
			System.err.println(e.getMessage());
			return null;
		}
	}
	
	/**
	 * 获取本地HTTP端口
	 * @return 本地HTTP端口
	 */
	public static Integer getLocalPort() {
		Set<ObjectName> objectNames=null;
        MBeanServer beanServer = ManagementFactory.getPlatformMBeanServer();
        try {
            objectNames = beanServer.queryNames(new ObjectName("*:type=Connector,*"), Query.match(Query.attr("protocol"), Query.value("HTTP/1.1")));
        } catch (MalformedObjectNameException e) {
        	e.printStackTrace();
            return null;
        }
        
        if(null==objectNames || objectNames.isEmpty()) return null;
        
        String port=null;
        try {
            port = objectNames.iterator().next().getKeyProperty("port");
        } catch (NoSuchElementException e) {
        	e.printStackTrace();
            return null;
        }
        
        return (null==port || (port=port.trim()).isEmpty())?null:Integer.parseInt(port);
    }
	
	/**
	 * 设置SPRING上下文
	 * @param applicationContext SPRING上下文
	 */
	public static void setApplicationContext(WebApplicationContext applicationContext) {
		Assert.notNull(applicationContext, "ApplicationContext must not be null");
		ApplicationUtil.applicationContext = applicationContext;
	}

	/**
	 * 设置SERVLET上下文
	 * @param servletContext SERVLET上下文
	 */
	public static void setServletContext(ServletContext servletContext) {
		Assert.notNull(servletContext, "ServletContext must not be null");
		ApplicationUtil.servletContext = servletContext;
	}
	
	public static <T> T getAttribute(String key) {
		return (T)servletContext.getAttribute(key);
	}
	
	public static void removeAttribute(String key) {
		servletContext.removeAttribute(key);
	}
	
	public static void setAttribute(String key,Object value) {
		servletContext.setAttribute(key, value);
	}
	
	public static <T> T getBean(String beanId) {
		return (T)applicationContext.getBean(beanId);
	}
	
	public static <T> T getBean(Class<T> beanType) {
		return applicationContext.getBean(beanType);
	}
	
	public static <T> Map<String,T> getBeanOfMap(Class<T> beanType) {
		return applicationContext.getBeansOfType(beanType,true,true);
	}
	
	public static final void setValue(String key,Object value) {
		VALUE_MAP.put(key, value);
	}
	
	public static final <T> T getValue(String key) {
		return (T)VALUE_MAP.get(key);
	}
	
	public static final void delValue(String key) {
		VALUE_MAP.remove(key);
	}
	
	public static final void delAllValues() {
		VALUE_MAP.clear();
	}
	
	public static Object getBeanWithClassName(String classFullName) {
		ApplicationContext appContext=getApplicationContext();
		if(null==appContext) return null;
		ClassLoader classLoader=appContext.getClass().getClassLoader();
		if(null==classLoader) return null;
		
		Class<?> loadedClass=null;
		try {
			loadedClass = classLoader.loadClass(classFullName);
		} catch (ClassNotFoundException e) {
			return null;
		}
		
		return appContext.getBean(loadedClass);
	}
	
	public static Map<String,?> getBeanOfMapWithClassName(String classFullName) {
		ApplicationContext appContext=getApplicationContext();
		if(null==appContext) return null;
		ClassLoader classLoader=appContext.getClass().getClassLoader();
		if(null==classLoader) return null;
		
		Class<?> loadedClass=null;
		try {
			loadedClass = classLoader.loadClass(classFullName);
		} catch (ClassNotFoundException e) {
			return null;
		}
		
		return appContext.getBeansOfType(loadedClass,true,true);
	}
	
	/**
	 * 根据JVM实例时间获取UUID字串序列
	 * @description 不同JVM例程的随机值不同,同一个JVM例程随机值相同
	 * @return UUID字串序列
	 */
	public static final String getRandomJvmTimeUUID(String... prexfixs) {
		EIGHT_BUFFER.clear();
		EIGHT_BUFFER.putLong(System.nanoTime());
		EIGHT_BUFFER.flip();
		
		byte[] b=new byte[8];
		EIGHT_BUFFER.get(b);
		EIGHT_BUFFER.clear();
		
		String prefix=(null==prexfixs || 0==prexfixs.length)?"":prexfixs[0];
		prefix=(null==prefix || (prefix=prefix.trim()).isEmpty())?"":prefix;
		
		return prefix+UUID.nameUUIDFromBytes(b).toString().replace("-", "");
	}
	
	/**
	 * 根据操作系统时间获取UUID字串序列
	 * @return UUID字串序列
	 */
	public static final synchronized String getCurrentTimeUUID(String... prexfixs) {
		EIGHT_BUFFER.clear();
		EIGHT_BUFFER.putLong(System.currentTimeMillis());
		EIGHT_BUFFER.flip();
		
		byte[] b=new byte[8];
		EIGHT_BUFFER.get(b);
		EIGHT_BUFFER.clear();
		
		String prefix=(null==prexfixs || 0==prexfixs.length)?"":prexfixs[0];
		prefix=(null==prefix || (prefix=prefix.trim()).isEmpty())?"":prefix;
		String uuid=prefix+UUID.nameUUIDFromBytes(b).toString().replace("-", "");
		
		try {
			Thread.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		return uuid;
	}
	
	/**
	 * 判断给定的基类型superType是否可以兼容到指定的子类型childType
	 * @param superType 基类型
	 * @param childType 子类型
	 * @return 是否兼容
	 */
	public static boolean compatible(Class<?> superType,Class<?> childType){
		if(superType==childType) return true;
		if(null==superType && null!=childType) return false;
		if(null!=superType && null==childType) return false;
		if(superType.isAssignableFrom(childType)) return true;
		try{
			if(superType.isPrimitive() && superType==childType.getField("TYPE").get(null)) return true;
			if(childType.isPrimitive() && childType==superType.getField("TYPE").get(null)) return true;
			return false;
		}catch(Exception e){
			return false;
		}
	}
	
	/**
	 * 判断给定的基类型superTypes数组是否可以兼容到指定的子类型数组childTypes
	 * @param superTypes 基类型数组
	 * @param childTypes 子类型数组
	 * @return 数组类型是否兼容
	 */
	public static boolean compatible(Class<?>[] superTypes,Class<?>[] childTypes){
		if(superTypes==childTypes) return true;
		if(null==superTypes && null!=childTypes) return false;
		if(null!=superTypes && null==childTypes) return false;
		if(superTypes.length!=childTypes.length) return false;
		try{
			for(int i=0;i<superTypes.length;i++){
				if(superTypes[i]==childTypes[i] || superTypes[i].isAssignableFrom(childTypes[i])) continue;
				if(superTypes[i].isPrimitive() && superTypes[i]==childTypes[i].getField("TYPE").get(null)) continue;
				if(childTypes[i].isPrimitive() && childTypes[i]==superTypes[i].getField("TYPE").get(null)) continue;
				return false;
			}
			return true;
		}catch(Exception e){
			return false;
		}
	}
	
	/**
	 * 将实体对象映射为字典对象
	 * @param mappedObject 实体对象
	 * @param excludeBooleanFieldss 不需要做转换的boolean类型字段集
	 * @return 字典对象
	 */
	public static final HashMap<String,Object> beanToMap(Object mappedObject,Set<String>... excludeBooleanFieldss) {
		if(null==mappedObject) return null;
		Set<String> excludeBooleanFields=(null==excludeBooleanFieldss || 0==excludeBooleanFieldss.length)?null:excludeBooleanFieldss[0];
		
		Class<?> mappedClass=mappedObject.getClass();
		HashMap<String,Object> retMap=new HashMap<String,Object>();
		ReflectionUtils.doWithFields(mappedClass, new FieldCallback() {
			public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
				Object fieldValue=field.get(mappedObject);
				if(null==fieldValue) return;
				
				Column column=field.getAnnotation(Column.class);
				String fieldName=field.getName();
				String mappedKey=null;
				if(null==column) {
					mappedKey=fieldName;
				}else {
					mappedKey=column.name();
					if(null==mappedKey || (mappedKey=mappedKey.trim()).isEmpty()) mappedKey=fieldName;
				}
				
				Class<?> fieldType=field.getType();
				if((boolean.class!=fieldType&&Boolean.class!=fieldType) || (null!=excludeBooleanFields&&excludeBooleanFields.contains(fieldName))) {
					retMap.put(mappedKey, fieldValue);
				}else {
					retMap.put(mappedKey, ((Boolean)fieldValue).booleanValue()?"Y":"N");
				}
			}
		}, new FieldFilter() {
			public boolean matches(Field field) {
				ReflectionUtils.makeAccessible(field);
				return true;
			}
		});
		
		return retMap;
	}
	
	/**
	 * 将字典对象映射为实体对象
	 * @param <T> 实体泛型
	 * @param map 字典对象
	 * @param mappedClass 实体类型
	 * @param excludeBooleanFieldss 不需要做转换的boolean类型字段集
	 * @return 实体对象
	 */
	public static final <T> T mapToBean(Map<String,Object> map,Class<T> mappedClass,Set<String>... excludeBooleanFieldss) {
		if(null==map || map.isEmpty() || null==mappedClass) return null;
		Set<String> excludeBooleanFields=(null==excludeBooleanFieldss || 0==excludeBooleanFieldss.length)?null:excludeBooleanFieldss[0];
		
		T t=null;
		try {
			t=mappedClass.newInstance();
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		
		BeanWrapperImpl beanWrapper=new BeanWrapperImpl();
		beanWrapper.setBeanInstance(t);
		beanWrapper.setConversionService(DefaultConversionService.getSharedInstance());
		
		ReflectionUtils.doWithFields(mappedClass, new FieldCallback() {
			public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
				Column column=field.getAnnotation(Column.class);
				String fieldName=field.getName();
				Object fieldValue=null;
				
				if(null==column) {
					fieldValue=map.get(fieldName);
				}else {
					String columnName=column.name();
					if(null==columnName || (columnName=columnName.trim()).isEmpty()) columnName=fieldName;
					fieldValue=map.get(columnName);
				}
				
				if(null==fieldValue) return;
				
				Class<?> fieldType=field.getType();
				if((boolean.class!=fieldType&&Boolean.class!=fieldType) || (null!=excludeBooleanFields&&excludeBooleanFields.contains(fieldName))) {
					beanWrapper.setPropertyValue(fieldName, fieldValue);
				}else {
					if(fieldValue instanceof Boolean) {
						beanWrapper.setPropertyValue(fieldName, ((Boolean)fieldValue).booleanValue());
					}else if(fieldValue instanceof CharSequence) {
						beanWrapper.setPropertyValue(fieldName, RecordObjectMapper.TRUE_VALUES.contains(fieldValue.toString())?true:false);
					}else{
						beanWrapper.setPropertyValue(fieldName, (1==((Number)fieldValue).intValue())?true:false);
					}
				}
			}
		}, new FieldFilter() {
			public boolean matches(Field field) {
				ReflectionUtils.makeAccessible(field);
				return true;
			}
		});
		
		return t;
	}
	
	/**
	 * 数据库是否存在指定的数据表
	 * @param mappedClass 映射实体类
	 * @return 是否存在
	 */
	public static final boolean hasTable(Class<?> mappedClass) {
		Table table=mappedClass.getAnnotation(Table.class);
		
		String tabName=table.name();
		if(null==tabName || (tabName=tabName.trim()).isEmpty()) {
			throw new RuntimeException("Unknown Table Name For: "+mappedClass.getName());
		}
		
		return hasTable(tabName,true);
	}
	
	/**
	 * 数据库是否存在指定的数据表
	 * @param databases 数据库(默认来自于JDBC链接)
	 * @return 是否存在
	 */
	public static final boolean hasTable(String tabName,boolean ignoreCase,String... databases) {
		if(null==tabName || (tabName=tabName.trim()).isEmpty()) return false;
		final String tableName=tabName;
		
		String database=(null==databases || 0==databases.length)?null:databases[0];
		database=(null==database || (database=database.trim()).isEmpty())?null:database;
		String sqlStat=null==database?"show tables;":new StringBuilder("use ").append(database).append(";show tables;").toString();
		
		return getBean(JdbcTemplate.class).execute(new StatementCallback<Boolean>() {
			public Boolean doInStatement(Statement stmt) throws SQLException, DataAccessException {
				ResultSet res=stmt.executeQuery(sqlStat);
				if(ignoreCase) {
					while(res.next()) if(tableName.equalsIgnoreCase(res.getString(1))) return true;
				}else {
					while(res.next()) if(tableName.equals(res.getString(1))) return true;
				}
				return false;
			}
		}).booleanValue();
	}
	
	/**
	 * 执行通用SQL语句
	 * @param sql SQL语句
	 * @param sqlParams SQL参数列表
	 * @return SQL执行结果
	 */
	public static final Object executeSQL(String sql,Object... sqlParams) {
		if(null==sql || (sql=sql.trim()).isEmpty()) return null;
		String prexfix=BLANK_REGEX.split(sql)[0].toUpperCase(Locale.SIMPLIFIED_CHINESE);
		
		JdbcTemplate jdbcTemplate=getBean(JdbcTemplate.class);
		
		if("SELECT".equals(prexfix)) return jdbcTemplate.query(sql, RecordObjectMapper.newInstance(HashMap.class),sqlParams);
		if(DML_OPTIONS.contains(prexfix)) return jdbcTemplate.update(sql,sqlParams);
		
		jdbcTemplate.execute(sql);
		return null;
	}
	
	/**
	 * 执行通用DML语句
	 * @param dmlSql DML-SQL语句
	 * @param sqlParams SQL参数列表
	 * @return 影响行数
	 */
	public static final int executeDML(String dmlSql,Object... sqlParams) {
		return getBean(JdbcTemplate.class).update(dmlSql,sqlParams);
	}
	
	/**
	 * 批量执行通用DML语句
	 * @param dmlSqls DML-SQL语句列表
	 * @return 影响行数列表
	 */
	public static final int[] executeBatchDML(String... dmlSqls) {
		if(null==dmlSqls || 0==dmlSqls.length) return null;
		return getBean(JdbcTemplate.class).batchUpdate(dmlSqls);
	}
	
	/**
	 * 批量执行通用DML语句
	 * @param dmlSql DML-SQL语句
	 * @param sqlParams SQL参数列表
	 * @return 影响行数列表
	 */
	public static final int[] executeBatchDML(String dmlSql,List<Object[]> batchSqlParams) {
		return getBean(JdbcTemplate.class).batchUpdate(dmlSql, batchSqlParams);
	}
	
	/**
	 * 执行通用DQL语句(无预编译参数的查询操作)
	 * @param dqlSql DQL-SQL语句
	 * @param mappedClass 映射类型
	 * @param primitivesDefaultedForNullValues 是否对NULL值映射到基本类型抛出异常
	 * @return 字典或实体列表
	 */
	public static final <T> List<T> executeDQL(String dqlSql,Class<T> mappedClass,boolean... primitivesDefaultedForNullValues) {
		return executeDQL(dqlSql,mappedClass, null, primitivesDefaultedForNullValues);
	}
	
	/**
	 * 执行通用DQL语句(无预编译参数的查询操作)
	 * @param dqlSql DQL-SQL语句
	 * @param mappedClass 映射类型
	 * @param excludeBooleanFields 不需要做转换的boolean类型字段集
	 * @param primitivesDefaultedForNullValues 是否对NULL值映射到基本类型抛出异常
	 * @return 字典或实体列表
	 */
	public static final <T> List<T> executeDQL(String dqlSql,Class<T> mappedClass,Set<String> excludeBooleanFields,boolean... primitivesDefaultedForNullValues) {
		return executeDQL(dqlSql,null,mappedClass,excludeBooleanFields,primitivesDefaultedForNullValues);
	}
	
	/**
	 * 执行通用DQL语句
	 * @param dqlSql DQL-SQL语句
	 * @param sqlParams SQL语句参数
	 * @param mappedClass 映射类型
	 * @param primitivesDefaultedForNullValues 是否对NULL值映射到基本类型抛出异常
	 * @return 字典或实体列表
	 */
	public static final <T> List<T> executeDQL(String dqlSql,Object[] sqlParams,Class<T> mappedClass,boolean... primitivesDefaultedForNullValues) {
		return executeDQL(dqlSql,sqlParams,mappedClass,null,primitivesDefaultedForNullValues);
	}
	
	/**
	 * 执行通用DQL语句
	 * @param dqlSql DQL-SQL语句
	 * @param sqlParams SQL语句参数
	 * @param mappedClass 映射类型
	 * @param excludeBooleanFields 不需要做转换的boolean类型字段集
	 * @param primitivesDefaultedForNullValues 是否对NULL值映射到基本类型抛出异常
	 * @return 字典或实体列表
	 */
	public static final <T> List<T> executeDQL(String dqlSql,Object[] sqlParams,Class<T> mappedClass,Set<String> excludeBooleanFields,boolean... primitivesDefaultedForNullValues) {
		JdbcTemplate jdbcTemplate=getBean(JdbcTemplate.class);
		if(SIMPLE_CLASSES.contains(mappedClass)) return jdbcTemplate.queryForList(dqlSql, mappedClass, sqlParams);
		
		if(null==sqlParams || 0==sqlParams.length) {
			return jdbcTemplate.query(dqlSql,RecordObjectMapper.newInstance(mappedClass, excludeBooleanFields, primitivesDefaultedForNullValues));
		}else {
			return jdbcTemplate.query(dqlSql,RecordObjectMapper.newInstance(mappedClass, excludeBooleanFields, primitivesDefaultedForNullValues),sqlParams);
		}
	}
	
	/**
	 * 执行Insert语句
	 * @param mappedObject 映射实体对象
	 * @param excludeBooleanFields 无需做转换处理的Boolean类型集
	 * @return 主键对象
	 */
	public static final <T> T executeInsert(Object mappedObject,String... excludeBooleanFields) {
		Object[] jdbcParams=getInsertStatement(mappedObject,excludeBooleanFields);
		getBean(JdbcTemplate.class).update((String)jdbcParams[0], (Object[])jdbcParams[1]);
		return (T)((Object[])jdbcParams[3])[0];
	}
	
	/**
	 * 批量执行Insert语句
	 * @param mappedObjects 映射实体对象列表
	 * @param excludeBooleanFields 无需做转换处理的Boolean类型集
	 * @return 主键对象列表
	 */
	public static final <T> Object[] executeBatchInsert(List<?> mappedObjects,String... excludeBooleanFields) {
		ArrayList<Object[]> batchArgs=new ArrayList<Object[]>();
		HashSet<String> insertSqls=new HashSet<String>();
		ArrayList<Object> pks=new ArrayList<Object>();
		for(Object mappedObject:mappedObjects) {
			Object[] jdbcParams=getInsertStatement(mappedObject,excludeBooleanFields);
			insertSqls.add((String)jdbcParams[0]);
			batchArgs.add((Object[])jdbcParams[1]);
			pks.add(((Object[])jdbcParams[3])[0]);
		}
		
		if(1!=insertSqls.size()) throw new RuntimeException("Check Batch SQL Failure!");
		getBean(JdbcTemplate.class).batchUpdate(insertSqls.iterator().next(), batchArgs);
		return pks.toArray(new Object[pks.size()]);
	}
	
	/**
	 * 根据主键执行Delete语句
	 * @param mappedObject 映射实体对象
	 * @return 影响行数
	 */
	public static final int executeDelete(Object mappedObject) {
		Object[] idWhereParams=getPKWhereStatement(mappedObject);
		Object[] jdbcParams=getDeleteStatement(mappedObject.getClass(),(String)idWhereParams[0],(Object[])idWhereParams[1]);
		return getBean(JdbcTemplate.class).update((String)jdbcParams[0], (Object[])jdbcParams[1]);
	}
	
	/**
	 * 根据主键批量执行Delete语句
	 * @param mappedObjects 映射实体对象列表
	 * @return 影响行数列表
	 */
	public static final int[] executeBatchDelete(List<?> mappedObjects) {
		ArrayList<Object[]> batchArgs=new ArrayList<Object[]>();
		HashSet<String> deleteSqls=new HashSet<String>();
		for(Object mappedObject:mappedObjects) {
			Object[] idWhereParams=getPKWhereStatement(mappedObject);
			Object[] jdbcParams=getDeleteStatement(mappedObject.getClass(),(String)idWhereParams[0],(Object[])idWhereParams[1]);
			deleteSqls.add((String)jdbcParams[0]);
			batchArgs.add((Object[])jdbcParams[1]);
		}
		
		if(1!=deleteSqls.size()) throw new RuntimeException("Check Batch SQL Failure!");
		return getBean(JdbcTemplate.class).batchUpdate(deleteSqls.iterator().next(), batchArgs);
	}
	
	/**
	 * 根据主键执行Delete语句
	 * @param primaryKey 主键值
	 * @param mappedClass 映射实体类型
	 * @return 影响行数
	 * @description
	 * 仅支持单个主键,对于复合主键存在主键值顺序匹配问题,请使用其它重载
	 */
	public static final int executeDel(Object primaryKey,Class<?> mappedClass) {
		ArrayList<Object[]> pkList=getPrimaryKeyInfos(mappedClass);
		if(null==pkList || pkList.isEmpty() || pkList.size()>1) {
			throw new RuntimeException("Not Found Primary Key OR Found Multi-Key By Annotation: @Id For Class: "+mappedClass.getName());
		}
		
		return executeDelete(mappedClass,new StringBuilder("WHERE ").append((String)(pkList.get(0)[0])).append("=?").toString(),new Object[] {primaryKey});
	}
	
	/**
	 * 根据主键列表批量执行Delete语句
	 * @param primaryKeys 主键值列表
	 * @param mappedClass 映射实体类型
	 * @return 影响行数数组
	 * @description
	 * 仅支持单个主键,对于复合主键存在主键值顺序匹配问题,请使用其它重载
	 */
	public static final int[] executeBatchDel(List<Object> primaryKeys,Class<?> mappedClass) {
		ArrayList<Object[]> pkList=getPrimaryKeyInfos(mappedClass);
		if(null==pkList || pkList.isEmpty() || pkList.size()>1) {
			throw new RuntimeException("Not Found Primary Key OR Found Multi-Key By Annotation: @Id For Class: "+mappedClass.getName());
		}
		
		return executeBatchDelete(mappedClass,new StringBuilder("WHERE ").append((String)(pkList.get(0)[0])).append("=?").toString(),primaryKeys.stream().map(pk->new Object[] {pk}).collect(Collectors.toList()));
	}
	
	/**
	 * 执行Delete语句
	 * @param mappedClass 映射实体类型
	 * @param whereSubStatement 自定义的where子句
	 * @param whereParams 自定义的where子句参数列表
	 * @return 影响行数
	 * @description 
	 * 需要确保whereParams中的参数传值顺序, 
	 * 一般不会修改整表,如果需要修改整表记录则:
	 * whereSubStatement参数可传递值: 'where 1=1'
	 * whereParams参数可传递值: new Object[0]
	 */
	public static final int executeDelete(Class<?> mappedClass,String whereSubStatement,Object[] whereParams) {
		Object[] jdbcParams=getDeleteStatement(mappedClass,whereSubStatement,whereParams);
		return getBean(JdbcTemplate.class).update((String)jdbcParams[0], (Object[])jdbcParams[1]);
	}
	
	/**
	 * 批量执行Delete语句
	 * @param mappedClass 映射实体类型
	 * @param whereSubStatement 自定义的where子句
	 * @param whereParames 自定义的where子句参数列表
	 * @return 影响行数数组
	 * @description 
	 * 需要确保whereParams中的参数传值顺序, 
	 * 一般不会修改整表,如果需要修改整表记录则:
	 * whereSubStatement参数可传递值: 'where 1=1'
	 * whereParams参数可传递值: new Object[0]
	 */
	public static final int[] executeBatchDelete(Class<?> mappedClass,String whereSubStatement,List<Object[]> whereParames) {
		ArrayList<Object[]> batchArgs=new ArrayList<Object[]>();
		HashSet<String> deleteSqls=new HashSet<String>();
		for(Object[] whereParams:whereParames) {
			Object[] jdbcParams=getDeleteStatement(mappedClass,whereSubStatement,whereParams);
			deleteSqls.add((String)jdbcParams[0]);
			batchArgs.add((Object[])jdbcParams[1]);
		}
		
		if(1!=deleteSqls.size()) throw new RuntimeException("Check Batch SQL Failure!");
		return getBean(JdbcTemplate.class).batchUpdate(deleteSqls.iterator().next(), batchArgs);
	}
	
	/**
	 * 根据主键执行Update语句
	 * @param mappedObject 映射实体对象
	 * @param excludeBooleanFields 无需做转换处理的Boolean类型集
	 * @return 影响行数
	 */
	public static final int executeUpdate(Object mappedObject,String... excludeBooleanFields) {
		Object[] idWhereParams=getPKWhereStatement(mappedObject);
		return executeUpdate(mappedObject,(String)idWhereParams[0],(Object[])idWhereParams[1]);
	}
	
	/**
	 * 根据主键执行Update语句
	 * @param mappedObject 映射实体对象
	 * @param excludeFields 排除字段集
	 * @param excludeBooleanFields 无需做转换处理的Boolean类型集
	 * @return 影响行数
	 */
	public static final int executeUpdate(Object mappedObject,Set<String> excludeFields,String... excludeBooleanFields) {
		Object[] idWhereParams=getPKWhereStatement(mappedObject);
		return executeUpdate(mappedObject,excludeFields,(String)idWhereParams[0],(Object[])idWhereParams[1]);
	}
	
	/**
	 * 执行Update语句
	 * @param mappedObject 映射实体对象
	 * @param whereSubStatement 自定义的where子句
	 * @param whereParams 自定义的where子句参数列表
	 * @param excludeBooleanFields 无需做转换处理的Boolean类型集
	 * @return 影响行数
	 * @description 
	 * 需要确保whereParams中的参数传值顺序, 
	 * 一般不会修改整表,如果需要修改整表记录则:
	 * whereSubStatement参数可传递值: 'where 1=1'
	 * whereParams参数可传递值: new Object[0]
	 */
	public static final int executeUpdate(Object mappedObject,String whereSubStatement,Object[] whereParams,String... excludeBooleanFields) {
		Object[] jdbcParams=getUpdateStatement(mappedObject,null,whereSubStatement,whereParams,excludeBooleanFields);
		return getBean(JdbcTemplate.class).update((String)jdbcParams[0], (Object[])jdbcParams[1]);
	}
	
	/**
	 * 执行Update语句
	 * @param mappedObject 映射实体对象
	 * @param excludeFields 排除字段集
	 * @param whereSubStatement 自定义的where子句
	 * @param whereParams 自定义的where子句参数列表
	 * @param excludeBooleanFields 无需做转换处理的Boolean类型集
	 * @return 影响行数
	 * @description 
	 * 需要确保whereParams中的参数传值顺序, 
	 * 一般不会修改整表,如果需要修改整表记录则:
	 * whereSubStatement参数可传递值: 'where 1=1'
	 * whereParams参数可传递值: new Object[0]
	 */
	public static final int executeUpdate(Object mappedObject,Set<String> excludeFields,String whereSubStatement,Object[] whereParams,String... excludeBooleanFields) {
		Object[] jdbcParams=getUpdateStatement(mappedObject,excludeFields,whereSubStatement,whereParams,excludeBooleanFields);
		return getBean(JdbcTemplate.class).update((String)jdbcParams[0], (Object[])jdbcParams[1]);
	}
	
	/**
	 * 根据主键判断执行Insert(不存在)或Update(存在)语句
	 * @param mappedObject 映射实体对象
	 * @param excludeBooleanFields 无需做转换处理的Boolean类型集
	 * @description 按@Id注解标识的主键生成Where修改条件
	 * @return 影响行数
	 */
	public static final int executeSaveOrUpdate(Object mappedObject,String... excludeBooleanFields) {
		Object[] idWhereParams=getPKWhereStatement(mappedObject);
		return executeInsertOrUpdate(mappedObject,(String)idWhereParams[0], (Object[])idWhereParams[1]);
	}
	
	/**
	 * 执行Insert(不存在)或Update(存在)语句
	 * @param mappedObject 映射实体对象
	 * @param whereSubStatement 自定义的where子句
	 * @param whereParams 自定义的where子句参数列表
	 * @param excludeBooleanFields 无需做转换处理的Boolean类型集
	 * @return 影响行数
	 * @description 
	 * 需要确保whereParams中的参数传值顺序,
	 * 一般不会修改整表,如果需要修改整表记录则:
	 * whereSubStatement参数可传递值: 'where 1=1'
	 * whereParams参数可传递值: new Object[0]
	 */
	public static final int executeInsertOrUpdate(Object mappedObject,String whereSubStatement,Object[] whereParams,String... excludeBooleanFields) {
		JdbcTemplate jdbcTemplate=getBean(JdbcTemplate.class);
		
		Object[] jdbcParams=getUpdateStatement(mappedObject,null,whereSubStatement,whereParams,excludeBooleanFields);
		int count=jdbcTemplate.update((String)jdbcParams[0], (Object[])jdbcParams[1]);
		
		if(count>0) return count;
		
		jdbcParams=getInsertStatement(mappedObject,excludeBooleanFields);
		return jdbcTemplate.update((String)jdbcParams[0], (Object[])jdbcParams[1]);
	}
	
	/**
	 * 执行Insert(不存在)或Update(存在)语句
	 * @param mappedObject 映射实体对象
	 * @param excludeFields 排除字段集
	 * @param whereSubStatement 自定义的where子句
	 * @param whereParams 自定义的where子句参数列表
	 * @param excludeBooleanFields 无需做转换处理的Boolean类型集
	 * @return 影响行数
	 * @description 
	 * 需要确保whereParams中的参数传值顺序,
	 * 一般不会修改整表,如果需要修改整表记录则:
	 * whereSubStatement参数可传递值: 'where 1=1'
	 * whereParams参数可传递值: new Object[0]
	 */
	public static final int executeInsertOrUpdate(Object mappedObject,Set<String> excludeFields,String whereSubStatement,Object[] whereParams,String... excludeBooleanFields) {
		JdbcTemplate jdbcTemplate=getBean(JdbcTemplate.class);
		
		Object[] jdbcParams=getUpdateStatement(mappedObject,excludeFields,whereSubStatement,whereParams,excludeBooleanFields);
		int count=jdbcTemplate.update((String)jdbcParams[0], (Object[])jdbcParams[1]);
		
		if(count>0) return count;
		
		jdbcParams=getInsertStatement(mappedObject,excludeBooleanFields);
		return jdbcTemplate.update((String)jdbcParams[0], (Object[])jdbcParams[1]);
	}
	
	/**
	 * 根据唯一字段值获取实体对象
	 * @param <T> 实体类型
	 * @param mappedClass 映射类型
	 * @param uniqueFieldName 唯一字段名条件
	 * @param uniqueFieldValue 唯一字段值条件
	 * @param primitivesDefaultedForNullValues 是否对NULL值映射到基本类型抛出异常
	 * @return 实体类型列表
	 */
	public static final <T> T getByUniqueField(Class<T> mappedClass,String uniqueFieldName,Object uniqueFieldValue,boolean... primitivesDefaultedForNullValues) {
		List<T> list=getBySingleField(mappedClass,uniqueFieldName,uniqueFieldValue,primitivesDefaultedForNullValues);
		if(null==list || list.isEmpty()) return null;
		if(list.size()>1) throw new RuntimeException("Found Multi-Record For Unique Field: "+uniqueFieldName);
		return list.get(0);
	}
	
	/**
	 * 根据单个字段名获取实体记录
	 * @param <T> 实体类型
	 * @param mappedClass 映射类型
	 * @param fieldName 条件字段名
	 * @param fieldValue 条件字段值
	 * @param primitivesDefaultedForNullValues 是否对NULL值映射到基本类型抛出异常
	 * @return 实体类型列表
	 */
	public static final <T> List<T> getBySingleField(Class<T> mappedClass,String fieldName,Object fieldValue,boolean... primitivesDefaultedForNullValues) {
		return executeSelect(mappedClass,new StringBuilder("WHERE ").append(fieldName).append("=?").toString(),new Object[] {fieldValue},null,primitivesDefaultedForNullValues);
	}
	
	/**
	 * 通过唯一字段值判断是否存在
	 * @param tabName 表名(可以含库名)
	 * @param fieldName 条件字段名
	 * @param fieldValue 条件字段值
	 * @return 是否存在记录
	 */
	public static final boolean existByUniqueField(String tabName,String fieldName,Object fieldValue) {
		Map dict=findByUniqueFields(tabName,fieldName,fieldValue,fieldName);
		return !(null==dict || dict.isEmpty());
	}
	
	/**
	 * 通过唯一字段值获取单个字段值
	 * @param tabName 表名(可以含库名)
	 * @param fieldName 条件字段名
	 * @param fieldValue 条件字段值
	 * @param uniqueFieldName 选择的字段名
	 * @return 单字段值
	 */
	public static final <T> T findByUniqueField(String tabName,String fieldName,Object fieldValue,String uniqueFieldName) {
		Map dict=findByUniqueFields(tabName,fieldName,fieldValue,uniqueFieldName);
		if(null==dict || dict.isEmpty()) return null;
		return (T)dict.get(uniqueFieldName);
	}
	
	/**
	 * 通过唯一字段值获取字典记录
	 * @param tabName 表名(可以含库名)
	 * @param fieldName 条件字段名
	 * @param fieldValue 条件字段值
	 * @param selectFieldNames 选择的字段名列表
	 * @return 字典类型列表
	 */
	public static final Map findByUniqueFields(String tabName,String fieldName,Object fieldValue,String... selectFieldNames) {
		List<Map> dictList=findBySingleFields(tabName,fieldName,fieldValue,selectFieldNames);
		if(null==dictList || dictList.isEmpty()) return null;
		return dictList.get(0);
	}
	
	/**
	 * 通过单个字段名获取字典记录
	 * @param tabName 表名(可以含库名)
	 * @param fieldName 条件字段名
	 * @param fieldValue 条件字段值
	 * @param selectFieldNames 选择的字段名列表
	 * @return 字典类型列表
	 */
	public static final List<Map> findBySingleFields(String tabName,String fieldName,Object fieldValue,String... selectFieldNames) {
		if(null==selectFieldNames || 0==selectFieldNames.length) return null;
		
		StringBuilder sqlBuilder=new StringBuilder("SELECT ");
		for(int i=0;i<selectFieldNames.length;sqlBuilder.append(selectFieldNames[i++]).append(" "));
		String selectSql=sqlBuilder.append("FROM ").append(tabName).append(" WHERE ").append(fieldName).append("=?").toString();
		
		return getBean(JdbcTemplate.class).query(selectSql,RecordObjectMapper.newInstance(Map.class, null, null),new Object[] {fieldValue});
	}
	
	/**
	 * 执行Select语句(查询所有记录)
	 * @param mappedClass 映射实体类型
	 * @param primitivesDefaultedForNullValues 是否对NULL值映射到基本类型抛出异常
	 * @return 实体或字典列表
	 */
	public static final <T> List<T> executeSelect(Class<T> mappedClass,boolean... primitivesDefaultedForNullValues) {
		return executeSelect(mappedClass,null,primitivesDefaultedForNullValues);
	}
	
	/**
	 * 执行Select语句(条件查询)
	 * @param mappedClass 映射实体类型
	 * @param whereSubStatement 自定义的where子句
	 * @param whereParams 自定义的where子句参数列表
	 * @param primitivesDefaultedForNullValues 是否对NULL值映射到基本类型抛出异常
	 * @return 实体或字典列表
	 * @description 
	 * 需要确保whereParams中的参数传值顺序, 
	 * 一般不会查询整表,如果需要查询整表记录则:
	 * whereSubStatement参数可传递值: 'where 1=1'
	 * whereParams参数可传递值: new Object[0]
	 */
	public static final <T> List<T> executeSelect(Class<T> mappedClass,String whereSubStatement,Object[] whereParams,boolean... primitivesDefaultedForNullValues) {
		return executeSelect(mappedClass,whereSubStatement,whereParams,null,primitivesDefaultedForNullValues);
	}
	
	/**
	 * 根据主键执行Select语句
	 * @param primaryKey 主键值
	 * @param mappedClass 映射实体类型
	 * @param primitivesDefaultedForNullValues 是否对NULL值映射到基本类型抛出异常
	 * @return 实体或字典列表
	 * @description
	 * 仅支持单个主键,对于复合主键的情况请使用executeSelect
	 */
	public static final <T> T executeGet(Object primaryKey,Class<T> mappedClass,boolean... primitivesDefaultedForNullValues) {
		return executeSelect(primaryKey,mappedClass,null,primitivesDefaultedForNullValues);
	}
	
	/**
	 * 根据主键执行Select语句
	 * @param primaryKey 主键值
	 * @param mappedClass 映射实体类型
	 * @param excludeBooleanFields 不需要做转换的boolean类型字段集
	 * @param primitivesDefaultedForNullValues 是否对NULL值映射到基本类型抛出异常
	 * @return 实体或字典列表
	 * @description
	 * 仅支持单个主键,对于复合主键存在主键值顺序匹配问题,请使用其它重载
	 */
	public static final <T> T executeSelect(Object primaryKey,Class<T> mappedClass,Set<String> excludeBooleanFields,boolean... primitivesDefaultedForNullValues) {
		ArrayList<Object[]> pkList=getPrimaryKeyInfos(mappedClass);
		if(null==pkList || pkList.isEmpty() || pkList.size()>1) {
			throw new RuntimeException("Not Found Primary Key OR Found Multi-Key By Annotation: @Id For Class: "+mappedClass.getName());
		}
		
		List<T> list=executeSelect(mappedClass,new StringBuilder("WHERE ").append((String)(pkList.get(0)[0])).append("=?").toString(),new Object[] {primaryKey},excludeBooleanFields,primitivesDefaultedForNullValues);
		if(null==list || list.isEmpty()) return null;
		
		if(list.size()>1) throw new RuntimeException("Found Multi-Record For Primary Key: "+primaryKey);
		return list.get(0);
	}
	
	/**
	 * 执行Select语句(查询所有记录)
	 * @param mappedClass 映射实体类型
	 * @param excludeBooleanFields 不需要做转换的boolean类型字段集
	 * @param primitivesDefaultedForNullValues 是否对NULL值映射到基本类型出异常
	 * @return 实体或字典列表
	 * @description 
	 * 需要确保whereParams中的参数传值顺序, 抛
	 * 一般不会查询整表,如果需要查询整表记录则:
	 * whereSubStatement参数可传递值: 'where 1=1'
	 * whereParams参数可传递值: new Object[0]
	 */
	public static final <T> List<T> executeSelect(Class<T> mappedClass,Set<String> excludeBooleanFields,boolean... primitivesDefaultedForNullValues) {
		Object[] jdbcParams=getSelectStatement(mappedClass);
		return getBean(JdbcTemplate.class).query((String)jdbcParams[0], RecordObjectMapper.newInstance(mappedClass, excludeBooleanFields, primitivesDefaultedForNullValues),(Object[])jdbcParams[1]);
	}
	
	
	/**
	 * 执行Select语句(条件查询)
	 * @param mappedClass 映射实体类型
	 * @param whereSubStatement 自定义的where子句
	 * @param whereParams 自定义的where子句参数列表
	 * @param excludeBooleanFields 不需要做转换的boolean类型字段集
	 * @param primitivesDefaultedForNullValues 是否对NULL值映射到基本类型抛出异常
	 * @return 实体或字典列表
	 * @description 
	 * 需要确保whereParams中的参数传值顺序, 
	 * 一般不会查询整表,如果需要查询整表记录则:
	 * whereSubStatement参数可传递值: 'where 1=1'
	 * whereParams参数可传递值: new Object[0]
	 */
	public static final <T> List<T> executeSelect(Class<T> mappedClass,String whereSubStatement,Object[] whereParams,Set<String> excludeBooleanFields,boolean... primitivesDefaultedForNullValues) {
		Object[] jdbcParams=getSelectStatement(mappedClass,whereSubStatement,whereParams);
		return getBean(JdbcTemplate.class).query((String)jdbcParams[0], RecordObjectMapper.newInstance(mappedClass, excludeBooleanFields, primitivesDefaultedForNullValues),(Object[])jdbcParams[1]);
	}
	
	/**
	 * 提取Insert语句
	 * @param mappedObject 映射实体对象
	 * @param excludeBooleanFields 无需做转换处理的Boolean类型集
	 * @return Insert-SQL
	 */
	public static final Object[] getInsertStatement(Object mappedObject,String... excludeBooleanFields) {
		Class<?> mappedClass=mappedObject.getClass();
		final Set<String> excludeBooleanFieldList=(null==excludeBooleanFields || 0==excludeBooleanFields.length)?null:Sets.newHashSet(excludeBooleanFields).stream()
			.filter(fieldName->null!=fieldName&&!fieldName.trim().isEmpty()).map(fieldName->fieldName.trim()).collect(Collectors.toSet());
		
		Table table=mappedClass.getAnnotation(Table.class);
		String tabName=table.name();
		if(null==tabName || (tabName=tabName.trim()).isEmpty()) {
			throw new RuntimeException("Unknown Table Name For: "+mappedClass.getName());
		}
		
		StringBuilder insertSql=new StringBuilder("INSERT INTO ").append(tabName).append("(");
		
		ArrayList<Object> primaryKeys=new ArrayList<Object>();
		ArrayList<String> columnNameList=new ArrayList<String>();
		ArrayList<Object> fieldValueList=new ArrayList<Object>();
		ArrayList<String> placeHolderList=new ArrayList<String>();
		ReflectionUtils.doWithFields(mappedClass, new FieldCallback() {
			public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
				Column column=field.getAnnotation(Column.class);
				String fieldName=field.getName();
				String columnName=column.name();
				if(null==columnName || (columnName=columnName.trim()).isEmpty()) columnName=fieldName;
				columnNameList.add(columnName);
				placeHolderList.add("?");
				
				Class<?> fieldType=field.getType();
				Object fieldValue=ReflectionUtils.getField(field, mappedObject);
				if(null!=field.getAnnotation(Id.class)) {
					if(null==fieldValue) ReflectionUtils.setField(field,mappedObject,fieldValue=getCurrentTimeUUID());
					primaryKeys.add(fieldValue);
				}
				
				if(null==fieldValue && null!=field.getAnnotation(Id.class)) ReflectionUtils.setField(field,mappedObject,fieldValue=getCurrentTimeUUID());
				
				if((boolean.class!=fieldType&&Boolean.class!=fieldType) || (null!=excludeBooleanFieldList&&excludeBooleanFieldList.contains(fieldName))) {
					fieldValueList.add(fieldValue);
				}else if(null==fieldValue){
					fieldValueList.add(fieldValue);
				}else {
					fieldValueList.add(((Boolean)fieldValue).booleanValue()?"Y":"N");
				}
			}
		}, new FieldFilter() {
			public boolean matches(Field field) {
				if(null==field.getAnnotation(Column.class)) return false;
				ReflectionUtils.makeAccessible(field);
				return true;
			}
		});
		
		if(columnNameList.isEmpty()) {
			throw new RuntimeException("Not Found Any Field For Insert Statement: "+mappedClass.getName());
		}
		
		if(fieldValueList.size()!=columnNameList.size() || columnNameList.size()!=placeHolderList.size()) {
			throw new RuntimeException("Check Field Size And PlaceHolder Size Is Failure For "+mappedClass.getName());
		}
		
		insertSql.append(Strings.join(",", columnNameList)).append(") VALUES(").append(Strings.join(",", placeHolderList)).append(")");
		
		return new Object[] {insertSql.toString(),fieldValueList.toArray(new Object[fieldValueList.size()]),columnNameList.toArray(new String[columnNameList.size()]),primaryKeys.toArray(new Object[primaryKeys.size()])};
	}
	
	/**
	 * 提取Delete语句
	 * @param mappedClass 映射实体类型
	 * @param whereSubStatement 自定义的where子句
	 * @param whereParams 自定义的where子句参数列表
	 * @return Delete-SQL
	 * @description 
	 * 需要确保whereParams中的参数传值顺序, 
	 * 一般不会修改整表,如果需要修改整表记录则:
	 * whereSubStatement参数可传递值: 'where 1=1'
	 * whereParams参数可传递值: new Object[0]
	 */
	public static final Object[] getDeleteStatement(Class<?> mappedClass,String whereSubStatement,Object[] whereParams) {
		if(null==whereSubStatement || (whereSubStatement=whereSubStatement.trim()).isEmpty()) {
			throw new RuntimeException("Where Clause Not Be Null Or Empty For Delete Statement!");
		}
		
		Table table=mappedClass.getAnnotation(Table.class);
		
		String tabName=table.name();
		if(null==tabName || (tabName=tabName.trim()).isEmpty()) {
			throw new RuntimeException("Unknown Table Name For: "+mappedClass.getName());
		}
		
		String deleteSql=new StringBuilder("DELETE FROM ").append(tabName).append(" ").append(whereSubStatement).toString();
		
		return new Object[] {deleteSql,whereParams};
	}
	
	/**
	 * 提取Update语句
	 * @param mappedObject 映射实体对象
	 * @param whereSubStatement 自定义的where子句
	 * @param whereParams 自定义的where子句参数列表
	 * @param excludeBooleanFields 无需做转换处理的Boolean类型集
	 * @return Update-SQL
	 * @description 
	 * 需要确保whereParams中的参数传值顺序, 
	 * 一般不会修改整表,如果需要修改整表记录则:
	 * whereSubStatement参数可传递值: 'where 1=1'
	 * whereParams参数可传递值: new Object[0]
	 */
	public static final Object[] getUpdateStatement(Object mappedObject,String whereSubStatement,Object[] whereParams,String... excludeBooleanFields) {
		return getUpdateStatement(mappedObject,null,whereSubStatement,whereParams,excludeBooleanFields);
	}
	
	/**
	 * 提取Update语句
	 * @param mappedObject 映射实体对象
	 * @param excludeFields 需要排除修改的字段
	 * @param whereSubStatement 自定义的where子句
	 * @param whereParams 自定义的where子句参数列表
	 * @param excludeBooleanFields 无需做转换处理的Boolean类型集
	 * @return Update-SQL
	 * @description 
	 * 需要确保whereParams中的参数传值顺序, 
	 * 一般不会修改整表,如果需要修改整表记录则:
	 * whereSubStatement参数可传递值: 'where 1=1'
	 * whereParams参数可传递值: new Object[0]
	 */
	public static final Object[] getUpdateStatement(Object mappedObject,Set<String> excludeFields,String whereSubStatement,Object[] whereParams,String... excludeBooleanFields) {
		if(null==whereSubStatement || (whereSubStatement=whereSubStatement.trim()).isEmpty()) {
			throw new RuntimeException("Where Clause Not Be Null Or Empty For Update Statement!");
		}
		
		Class<?> mappedClass=mappedObject.getClass();
		final Set<String> excludeBooleanFieldList=(null==excludeBooleanFields || 0==excludeBooleanFields.length)?null:Sets.newHashSet(excludeBooleanFields).stream()
			.filter(fieldName->null!=fieldName&&!fieldName.trim().isEmpty()).map(fieldName->fieldName.trim()).collect(Collectors.toSet());
		
		Table table=mappedClass.getAnnotation(Table.class);
		String tabName=table.name();
		if(null==tabName || (tabName=tabName.trim()).isEmpty()) {
			throw new RuntimeException("Unknown Table Name For: "+mappedClass.getName());
		}
		
		StringBuilder updateSql=new StringBuilder("UPDATE ").append(tabName).append(" SET ");
		
		Set<String> excludeFieldSet=null==excludeFields?new HashSet<String>():excludeFields;
		ArrayList<String> columnNamePlaceholderList=new ArrayList<String>();
		ArrayList<Object> fieldValueList=new ArrayList<Object>();
		ReflectionUtils.doWithFields(mappedClass, new FieldCallback() {
			public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
				Column column=field.getAnnotation(Column.class);
				String fieldName=field.getName();
				String columnName=column.name();
				if(null==columnName || (columnName=columnName.trim()).isEmpty()) columnName=field.getName();
				columnNamePlaceholderList.add(columnName+"=?");
				
				Class<?> fieldType=field.getType();
				Object fieldValue=ReflectionUtils.getField(field, mappedObject);
				if((boolean.class!=fieldType&&Boolean.class!=fieldType) || (null!=excludeBooleanFieldList&&excludeBooleanFieldList.contains(fieldName))) {
					fieldValueList.add(fieldValue);
				}else if(null==fieldValue){
					fieldValueList.add(fieldValue);
				}else {
					fieldValueList.add(((Boolean)fieldValue).booleanValue()?"Y":"N");
				}
			}
		}, new FieldFilter() {
			public boolean matches(Field field) {
				if(excludeFieldSet.contains(field.getName())) return false;
				if(null==field.getAnnotation(Column.class)) return false;
				ReflectionUtils.makeAccessible(field);
				return true;
			}
		});
		
		if(columnNamePlaceholderList.isEmpty()) {
			throw new RuntimeException("Not Found Any Field For Update Statement: "+mappedClass.getName());
		}
		
		if(fieldValueList.size()!=columnNamePlaceholderList.size()) {
			throw new RuntimeException("Check Field Size And ColumnNamePlaceHolder Size Is Failure For "+mappedClass.getName());
		}
		
		updateSql.append(Strings.join(",", columnNamePlaceholderList)).append(" ").append(whereSubStatement);
		Object[] setParams=fieldValueList.toArray(new Object[fieldValueList.size()]);
		Object[] allParams=new Object[setParams.length+whereParams.length];
		System.arraycopy(setParams, 0, allParams, 0, setParams.length);
		System.arraycopy(whereParams, 0, allParams, setParams.length, whereParams.length);
		
		return new Object[] {updateSql.toString(),allParams};
	}
	
	/**
	 * 提取Select语句
	 * @param mappedClass 映射实体类型
	 * @param whereSubStatement 自定义的where子句
	 * @param whereParams 自定义的where子句参数列表
	 * @return Select-SQL
	 * @description 
	 * 需要确保whereParams中的参数传值顺序, 
	 * 一般不会查询整表,如果需要查询整表记录则:
	 * whereSubStatement参数可传递值: 'where 1=1'
	 * whereParams参数可传递值: new Object[0]
	 */
	public static final Object[] getSelectStatement(Class<?> mappedClass,String whereSubStatement,Object[] whereParams) {
		if(null==whereSubStatement || (whereSubStatement=whereSubStatement.trim()).isEmpty()) {
			throw new RuntimeException("Where Clause Not Be Null Or Empty For Select Statement!");
		}
		
		Table table=mappedClass.getAnnotation(Table.class);
		
		String tabName=table.name();
		if(null==tabName || (tabName=tabName.trim()).isEmpty()) {
			throw new RuntimeException("Unknown Table Name For: "+mappedClass.getName());
		}
		
		String deleteSql=new StringBuilder("SELECT * FROM ").append(tabName).append(" ").append(whereSubStatement).toString();
		
		return new Object[] {deleteSql,whereParams};
	}
	
	/**
	 * 提取Select语句
	 * @param mappedClass 映射实体类型
	 * @return Select-SQL
	 */
	public static final Object[] getSelectStatement(Class<?> mappedClass) {
		Table table=mappedClass.getAnnotation(Table.class);
		
		String tabName=table.name();
		if(null==tabName || (tabName=tabName.trim()).isEmpty()) {
			throw new RuntimeException("Unknown Table Name For: "+mappedClass.getName());
		}
		
		String deleteSql=new StringBuilder("SELECT * FROM ").append(tabName).toString();
		
		return new Object[] {deleteSql,new Object[0]};
	}
	
	/**
	 * 提取基于主键的条件语句
	 * @param mappedObject 映射实体对象
	 * @return Select-SQL
	 * @description 
	 * 基于注解@Id注解标识获取条件查询语句
	 */
	public static final Object[] getPKWhereStatement(Object mappedObject) {
		Class<?> entityClass=mappedObject.getClass();
		ArrayList<Object[]> pkList=getPrimaryKeyInfos(entityClass);
		if(pkList.isEmpty()) throw new RuntimeException("Not Found Primary Key By Annotation: @Id For Class: "+entityClass.getName());
		
		StringBuilder whereBuilder=new StringBuilder("WHERE 1=1 ");
		ArrayList<String> columnNameList=new ArrayList<String>();
		ArrayList<String> propertyNameList=new ArrayList<String>();
		ArrayList<Object> paramList=new ArrayList<Object>();
		for(Object[] pk:pkList) {
			columnNameList.add((String)pk[0]);
			propertyNameList.add((String)pk[1]);
			paramList.add(ReflectionUtils.getField((Field)pk[2], mappedObject));
			whereBuilder.append("AND ").append((String)pk[0]).append("=").append("? ");
		}
		
		return new Object[] {whereBuilder.toString(),paramList.toArray(new Object[paramList.size()]),columnNameList.toArray(new String[columnNameList.size()]),propertyNameList.toArray(new String[propertyNameList.size()])};
	}
	
	/**
	 * 获取映射主键信息
	 * @param mappedClass 映射实体类
	 * @return 主键数组表(数据库列名、实体属性名和属性对象)
	 */
	public static final ArrayList<Object[]> getPrimaryKeyInfos(Class<?> mappedClass) {
		ArrayList<Object[]> primaryKeyList=new ArrayList<Object[]>();
		ReflectionUtils.doWithFields(mappedClass, new FieldCallback() {
			public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
				Column column=field.getAnnotation(Column.class);
				Object[] pks=new Object[3];
				primaryKeyList.add(pks);
				pks[1]=field.getName();
				pks[0]=column.name();
				pks[2]=field;
			}
		}, new FieldFilter() {
			public boolean matches(Field field) {
				if(null==field.getAnnotation(Column.class) || null==field.getAnnotation(Id.class)) return false;
				ReflectionUtils.makeAccessible(field);
				return true;
			}
		});
		
		return primaryKeyList;
	}
}