package com.yami.trading.common.util;

import java.io.File;
import java.io.UnsupportedEncodingException;
import java.lang.management.ManagementFactory;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import javax.websocket.DeploymentException;
import javax.websocket.server.ServerContainer;
import javax.websocket.server.ServerEndpointConfig;

import org.slf4j.Logger;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.origin.OriginTrackedValue;
import org.springframework.context.support.GenericApplicationContext;
import org.springframework.core.Ordered;
import org.springframework.core.env.PropertySource;
import org.springframework.core.env.StandardEnvironment;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.util.SystemPropertyUtils;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.context.support.GenericWebApplicationContext;

import com.yami.trading.common.config.ThreadPool;

/**
 * @author JORGE
 * @description SpringBoot应用工具
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
public class ApplicationUtil {
	/**
	 * SpringBoot应用命令行启动参数
	 */
	private static String[] cmdLineArgs;

	/**
	 * Bean标识模式
	 */
	public enum BeanIdMode {
		BEAN_NAME, BEAN_TYPE
	}
	
	/**
	 * SpringBoot应用上下文环境
	 */
	private static SpringApplication springApplication;

	/**
	 * SpringBoot环境
	 */
	private static StandardEnvironment environment;
	
	/**
	 * SpringBoot生命周期字典
	 */
	private static ConcurrentHashMap<String, Object> lifecycleDict;

	/**
	 * 工程类路径配置
	 */
	private static final String PROJECT_CLASS_PATH = "java.class.path";
	
	/**
     * 八字节缓冲
     */
    private static final ByteBuffer EIGHT_BUFFER = ByteBuffer.allocate(8);

	/**
	 * Email地址分隔符正则式
	 */
	private static final Pattern EMAIL_SEPARATOR_REGEX = Pattern.compile("@");
	
	/**
	 * 路径前缀正则式(同时兼容jar[war]包和工程模式)
	 */
	private static final Pattern PATH_PREFIX = Pattern.compile("[/\\\\]{1}[A-Za-z]{1}:");

	/**
	 * WebSocket容器配置
	 */
	private static final String WS_SERVER_CONTANER = "javax.websocket.server.ServerContainer";

	/**
	 * SpringBoot配置文件后缀键(默认支持Nacos)
	 */
	private static final String[] CONFIG_SUFFIX = { ".yml]", ".yaml]", ".properties]", "DEFAULT_GROUP" };

	/**
	 * 类路径分隔符正则式
	 */
	private static final Pattern CLASSPATH_SEPARATOR_REGEX = Pattern.compile(File.pathSeparator);

	/**
	 * Spring应用上下文字典
	 */
	private static final LinkedHashMap<Class<?>, GenericApplicationContext> CONTEXT_DICT = new LinkedHashMap<Class<?>, GenericApplicationContext>();

	/**
	 * 获取Spring上下文字典
	 * 
	 * @return
	 */
	public static LinkedHashMap<Class<?>, GenericApplicationContext> getContextDict() {
		return new LinkedHashMap<Class<?>, GenericApplicationContext>(CONTEXT_DICT);
	}

	/**
	 * 获取命令行参数列表
	 * 
	 * @return
	 */
	public static String[] getCmdLineArgs() {
		return cmdLineArgs;
	}

	/**
	 * 获取Web应用服务器端口
	 * 
	 * @return 端口
	 */
	public static Integer getServerPort() {
		return getProperty("server.port", Integer.class);
	}

	/**
	 * 获取SpringBoot应用名
	 * 
	 * @return 端口
	 */
	public static String getApplicationName() {
		return getProperty("spring.application.name");
	}

	/**
	 * 获取系统部署环境
	 * 
	 * @return dev/test/pre/prod..etc
	 */
	public static String getDeployEnvironment() {
		String[] profiles = getEnvironment().getActiveProfiles();
		if (null == profiles || 0 == profiles.length) return null;
		return profiles[0];
	}
	
	/**
	 * 根据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;
	}
	
	/**
	 * 输出线程堆栈信息
	 * @param loggers
	 */
	public static void printStackTrace(Logger... loggers) {
		List<String> elementList=Arrays.stream(Thread.currentThread().getStackTrace())
				.map(element->new StringBuilder(element.getClassName()).append(".")
				.append(element.getMethodName()).append(":")
				.append(element.getLineNumber()).toString())
				.collect(Collectors.toList());
		
		Logger logger=(null==loggers || 0==loggers.length)?null:loggers[0];
		if(null==logger) {
			System.out.println(String.join("\n", elementList));
		}else {
			logger.error(String.join("\n", elementList));
		}
	}

	/**
	 * 获取Web应用上下文路径(默认空串)
	 * 
	 * @return 上下文路径
	 */
	public static String getContextPath() {
		String appName = null;
		StandardEnvironment environment = getEnvironment();
		if (null != environment) {
			appName = environment.getProperty("server.servlet.contextPath");
			if (null == appName || appName.trim().isEmpty())
				appName = environment.getProperty("server.servlet.context-path");
			if (null == appName || appName.trim().isEmpty())
				appName = environment.getProperty("server.servlet.context_path");
		}
		if (null != appName && !appName.trim().isEmpty())
			return appName;

		GenericApplicationContext applicationContext = getApplicationContext();
		if (null != applicationContext)
			appName = applicationContext.getApplicationName();
		if (null == appName || appName.trim().isEmpty())
			return "";
		return appName;
	}

	/**
	 * 获取Servlet配置
	 * 
	 * @return Servlet配置
	 */
	public static ServletConfig getServletConfig() {
		GenericApplicationContext applicationContext = getApplicationContext();
		if (null == applicationContext) return null;
		if (!(applicationContext instanceof GenericWebApplicationContext)) return null;
		return ((GenericWebApplicationContext) applicationContext).getServletConfig();
	}

	/**
	 * 获取Servlet上下文
	 * 
	 * @return Servlet上下文
	 */
	public static ServletContext getServletContext() {
		GenericApplicationContext applicationContext = getApplicationContext();
		if (null == applicationContext) return null;
		if (!(applicationContext instanceof GenericWebApplicationContext)) return null;
		return ((GenericWebApplicationContext) applicationContext).getServletContext();
	}

	/**
	 * 从当前线程中获取请求上下文属性
	 * 
	 * @return 请求属性对象
	 */
	public static RequestAttributes getRequestAttributes() {
		RequestAttributes requestAttributes = null;
		try {
			requestAttributes = RequestContextHolder.currentRequestAttributes();
		} catch (IllegalStateException e) {
		}
		return requestAttributes;
	}

	/**
	 * 获取Servlet请求对象
	 * 
	 * @return Servlet请求对象
	 */
	public static HttpServletRequest getServletRequest() {
		RequestAttributes requestAttributes = getRequestAttributes();
		// not found in spring application context
		if (null == requestAttributes) return null;
		// not servlet context
		if (!(requestAttributes instanceof ServletRequestAttributes)) return null;
		return ((ServletRequestAttributes) requestAttributes).getRequest();
	}

	/**
	 * 获取Servlet响应对象
	 * 
	 * @return Servlet请求对象
	 */
	public static HttpServletResponse getServletResponse() {
		RequestAttributes requestAttributes = getRequestAttributes();
		// not found in spring application context
		if (null == requestAttributes) return null;
		// not servlet context
		if (!(requestAttributes instanceof ServletRequestAttributes)) return null;
		return ((ServletRequestAttributes) requestAttributes).getResponse();
	}

	/**
	 * 获取HttpSession对象
	 * 
	 * @return HttpSession对象
	 */
	public static HttpSession getHttpSession(boolean... createIfNotExists) {
		HttpServletRequest request = getServletRequest();
		return null == request ? null : request.getSession((null == createIfNotExists || 0 == createIfNotExists.length) ? true : false);
	}

	/**
	 * 获取底层服务器实现的WebSocket容器
	 * 
	 * @return WebSocket容器
	 */
	public static ServerContainer getWebSocketContainer() {
		ServletContext servletContext = ApplicationUtil.getServletContext();
		if (null == servletContext) return null;

		Object object = servletContext.getAttribute(WS_SERVER_CONTANER);
		if (null == object || !ServerContainer.class.isInstance(object)) return null;

		return ServerContainer.class.cast(object);
	}

	/**
	 * 绑定EndPoint
	 * 
	 * @param path     ForExample:"/ws/chat"
	 * @param endpoint 继承至javax.websocket.Endpoint类的子类
	 * @throws DeploymentException
	 */
	public static void bindEndpoint(String path, Class<?> endpoint) throws DeploymentException {
		ServerContainer container = getWebSocketContainer();
		if (null == container) throw new RuntimeException("Not Found WebSocket Container");
		container.addEndpoint(ServerEndpointConfig.Builder.create(endpoint, path).build());
	}

	/**
	 * 绑定EndPoint
	 * 
	 * @param endpoint 使用注解ServerEndpoint(value = "/ws/chat")标注的类
	 * @throws DeploymentException
	 */
	public static void bindEndpoint(Class<?> endpoint) throws DeploymentException {
		ServerContainer container = getWebSocketContainer();
		if (null == container) throw new RuntimeException("Not Found WebSocket Container");
		container.addEndpoint(endpoint);
	}
	
	/**
	 * 获取应用入口参数
	 * @return 应用入口参数数组
	 * @throws DeploymentException
	 */
	public static String[] getBootAllArguments() {
		ApplicationArguments arguments=getBean(ApplicationArguments.class);
		return null==arguments?null:arguments.getSourceArgs();
	}
	
	/**
	 * 获取Redis模版
	 * @return Redis模版
	 */
	public static RedisTemplate getRedisTemplate() {
		Map<String, RedisTemplate> templateMap=ApplicationUtil.getBeansOfType(RedisTemplate.class);
		return (null==templateMap || templateMap.isEmpty())?null:templateMap.getOrDefault("redisTemplate", templateMap.values().iterator().next());
	}
	
	/**
	 * 启动重置Spring上下文监控任务
	 * @param listKey Redis队列键
	 * @param resetRunnables 重置任务
	 */
	public static void startResetContextMonitorTask(String listKey,Class bootClass,Runnable... resetRunnables) {
		Runnable resetRunnable=(null==resetRunnables || 0==resetRunnables.length)?null:resetRunnables[0];
		ThreadPoolTaskExecutor executor=ThreadPool.getFixedTaskExecutor(1,"REDIS-HOOK-RESET-CONTEXT");
		
		if(null==resetRunnable) {
			resetRunnable=()->{
				StringRedisTemplate template=ApplicationUtil.getBean(StringRedisTemplate.class);
				if(null==template) return;
				
				ListOperations listOperations=template.opsForList();
				while(true) {
					if(null==listOperations.rightPop(listKey, 3L, TimeUnit.SECONDS)) continue;
					break;
				}
				
				getApplicationContext().close();
				SpringApplication.run(bootClass,cmdLineArgs);
			};
		}
		
		executor.execute(resetRunnable);
	}
	
	/**
	 * 动态获取SpringBoot配置参数字典
	 * 
	 * @param suffixStr 配置文件后缀
	 * @return 配置字典
	 * @description SpringBoot环境配置参数必须是动态获取,不能静态初始化,
	 *              因为在SpringCloud应用中可以通过配置管理中心动态更新环境配置参数值
	 */
	public static ConcurrentHashMap<String, Object> getPropertiesConfig(String... suffixStr) {
		StandardEnvironment environment = getEnvironment();
		ConcurrentHashMap<String, Object> properties = new ConcurrentHashMap<String, Object>();
		String[] suffixStrs = (null == suffixStr || 0 == suffixStr.length) ? CONFIG_SUFFIX : suffixStr;
		Set<String> configSuffixs = new HashSet<String>(Arrays.asList(suffixStrs));
		environment.getPropertySources().stream().filter(propertySource -> {
			for (String e : configSuffixs)
				if (propertySource.getName().endsWith(e))
					return true;
			return false;
		}).forEach(propertySource -> {
			Object source = propertySource.getSource();
			if (!(source instanceof Map))
				return;
			((Map<Object, Object>) source).forEach((k, v) -> {
				Object strVal = (v instanceof String) ? (String) v : ((OriginTrackedValue) v).getValue();
				if (null != strVal)
					strVal = resolvePlaceHolder(strVal.toString());
				properties.put((String) k, strVal);
			});
		});
		return properties;
	}

	/**
	 * 递归解析配置占位符
	 * 
	 * @param placeHolder 占位符
	 * @return 字串值
	 */
	public static String resolvePlaceHolder(String placeHolder) {
		if (null == placeHolder) return null;
		placeHolder = placeHolder.trim();
		if (placeHolder.isEmpty()) return "";
		StandardEnvironment environment = getEnvironment();
		if (!placeHolder.startsWith(SystemPropertyUtils.PLACEHOLDER_PREFIX) || !placeHolder.endsWith(SystemPropertyUtils.PLACEHOLDER_SUFFIX)) {
			return placeHolder;
		}
		String placeHolderKey = placeHolder.substring(2, placeHolder.length() - 1);
		String valueHolder = environment.getProperty(placeHolderKey);
		if (null == valueHolder || valueHolder.isEmpty()) return placeHolder;
		return resolvePlaceHolder(valueHolder);
	}

	public static ConcurrentHashMap<String, Object> getLifecycleDict() {
		return lifecycleDict;
	}

	/**
	 * 获取SpringBoot原始配置环境
	 * 
	 * @return SpringBoot配置环境
	 */
	public static StandardEnvironment getRawEnvironment() {
		return environment;
	}

	/**
	 * 获取SpringBoot配置环境
	 * 
	 * @param levels 上下文层级(从0开始计算)
	 * @return SpringBoot配置环境
	 */
	public static StandardEnvironment getEnvironment(Integer... levels) {
		GenericApplicationContext applicationContext = getApplicationContext(levels);
		if (null == applicationContext) return environment;
		return (StandardEnvironment) applicationContext.getEnvironment();
	}

	/**
	 * 获取SpringBoot应用容器
	 * 
	 * @return SpringBoot应用容器
	 */
	public static SpringApplication getSpringApplication() {
		return springApplication;
	}

	/**
	 * 获取Spring之BeanFactory
	 * 
	 * @param levels 上下文层级
	 * @return BeanFactory
	 */
	public static DefaultListableBeanFactory getBeanFactory(Integer... levels) {
		GenericApplicationContext applicationContext = getApplicationContext(levels);
		return null == applicationContext ? null : applicationContext.getDefaultListableBeanFactory();
	}

	/**
	 * 获取Spring应用上下文
	 * 
	 * @param levels 上下文层级(从0开始计算)
	 * @return ApplicationContext
	 */
	public static GenericApplicationContext getApplicationContext(Integer... levels) {
		if (0 == CONTEXT_DICT.size()) return null;
		GenericApplicationContext applicationContext = null;
		int index = null == levels || 0 == levels.length ? CONTEXT_DICT.size() - 1 : levels[0].intValue();
		Iterator<Map.Entry<Class<?>, GenericApplicationContext>> contextIterator = CONTEXT_DICT.entrySet().iterator();
		for (int i = 0; i <= index && contextIterator.hasNext(); applicationContext = contextIterator.next().getValue(), i++);
		return applicationContext;
	}

	/**
	 * 获取操作系统属性字典
	 * 
	 * @return 字典类型
	 */
	public static Map<String, Object> getSystemProperties() {
		return getEnvironment().getSystemEnvironment();
	}

	/**
	 * 获取虚拟机系统属性字典
	 * 
	 * @return 字典类型
	 */
	public static Map<String, Object> getJVMProperties() {
		return getEnvironment().getSystemProperties();
	}

	/**
	 * 设置生命周期全局域缓存
	 * 
	 * @param key   键
	 * @param value 值
	 */
	public static void setValue(String key, Object value) {
		lifecycleDict.put(key, value);
	}

	/**
	 * 获取生命周期全局域缓存
	 * 
	 * @param key          键
	 * @param returnType   返回类型
	 * @param defaultValue 默认值
	 * @return 泛化类型
	 */
	public static Object getValue(String key, Object... defaultValue) {
		return getValue(key, Object.class, defaultValue);
	}

	/**
	 * 获取生命周期全局域缓存
	 * 
	 * @param key          键
	 * @param returnType   返回类型
	 * @param defaultValue 默认值
	 * @return 泛化类型
	 */
	public static <R> R getValue(String key, Class<R> returnType, R... defaultValue) {
		return getValue(key, null, returnType, defaultValue);
	}

	/**
	 * 获取生命周期全局域缓存
	 * 
	 * @param key          键
	 * @param defaultKey   默认键
	 * @param returnType   返回类型
	 * @param defaultValue 默认值
	 * @return 泛化类型
	 */
	public static <R> R getValue(String key, String defaultKey, Class<R> returnType, R... defaultValue) {
		R defaultVal = (null == defaultValue || 0 == defaultValue.length) ? null : defaultValue[0];
		Object value = lifecycleDict.get(key);
		if (null == value && null != defaultKey) value = lifecycleDict.get(defaultKey);
		if (null == value) return defaultVal;
		return returnType.cast(value);
	}

	/**
	 * 获取Spring上下文中指定Bean名称对应的Bean对象
	 * 
	 * @param beanName BeanId
	 * @return 对象类型
	 */
	public static Object getBean(String beanName) {
		return (null == beanName || beanName.trim().isEmpty())?null:getBean(beanName, Object.class);
	}

	/**
	 * 获取Spring上下文中兼容到指定类型的唯一Bean对象
	 * 
	 * @param beanType Bean类型
	 * @return 泛化类型
	 * @description 兼容Bean不唯一或不存在则返回null
	 */
	public static <R> R getBean(Class<R> beanType) {
		GenericApplicationContext applicationContext = getApplicationContext();
		return (null == beanType || null == applicationContext)?null:applicationContext.getBean(beanType);
	}

	/**
	 * 获取Spring上下文中给定Bean类型简单名对应的Bean对象
	 * 
	 * @param beanType Bean类型
	 * @return 泛化类型
	 */
	public static <R> R getBeanOfName(Class<R> beanType) {
		if (null == beanType) return null;
		String beanName = CommonUtil.lowerFirstChar(beanType.getSimpleName());
		return getBean(beanName, beanType);
	}

	/**
	 * 获取Spring上下文中兼容到指定类型的随机Bean对象
	 * 
	 * @param beanType Bean类型
	 * @return 泛化类型
	 * @description 兼容Bean不存在则返回null,兼容Bean有多个则随机返回一个
	 */
	public static <R> R getRandomBean(Class<R> beanType) {
		if (null == beanType) return null;
		Map<String, R> beanDict = getBeansOfType(beanType, true, true);
		if (null == beanDict || beanDict.isEmpty()) return null;
		return beanDict.entrySet().iterator().next().getValue();
	}

	/**
	 * 获取Spring上下文中的类型兼容Bean字典
	 * 
	 * @param beanType Bean类型
	 * @return 泛化字典
	 */
	public static <R> Map<String, R> getBeansOfType(Class<R> beanType) {
		return null == beanType?null:getBeansOfType(beanType, true, true);
	}

	/**
	 * 获取Spring上下文中的类型兼容Bean字典
	 * 
	 * @param beanType Bean类型
	 * @return 泛化字典
	 */
	public static <R> Map<String, R> getBeansOfType(Class<R> beanType, boolean includeNonSingletons,boolean requireInit) {
		GenericApplicationContext applicationContext = getApplicationContext();
		return (null == beanType || null == applicationContext)?null:applicationContext.getBeansOfType(beanType, includeNonSingletons, requireInit);
	}

	/**
	 * 获取Spring上下文中的Bean对象
	 * 
	 * @param beanName BeanId
	 * @param beanType Bean类型
	 * @return 泛化类型
	 */
	public static <R> R getBean(String beanName, Class<R> beanType) {
		GenericApplicationContext applicationContext = getApplicationContext();
		if (null == beanName || null == beanType || null == applicationContext || beanName.trim().isEmpty()) return null;
		return !applicationContext.containsBean(beanName)?null:applicationContext.getBean(beanName, beanType);
	}

	/**
	 * 通过BeanName和beanType在容器中搜索Bean
	 * 
	 * @param beanName BeanId
	 * @param beanType Bean类型
	 * @return 对象类型
	 */
	public static Object getBeanOfSearch(String beanName, Class<?> beanType) {
		GenericApplicationContext applicationContext = getApplicationContext();
		if (null != beanName && !beanName.trim().isEmpty() && null != applicationContext) {
			if (applicationContext.containsBean(beanName)) {
				return applicationContext.getBean(beanName);
			}
		}
		if (null == beanType || null == applicationContext)
			return null;
		Map<String, ?> beanDict = applicationContext.getBeansOfType(beanType, true, true);
		if (null == beanDict || beanDict.isEmpty())
			return null;
		if (beanDict.size() > 1)
			return beanDict;
		return beanDict.entrySet().iterator().next().getValue();
	}

	/**
	 * 获取Spring上下文中的Bean定义
	 * 
	 * @param beanName BeanId
	 * @return Bean定义对象
	 * @description 从单例对象字典singletonObjects中获取指定Bean名称对应的单例Bean对象
	 */
	public static Object getSingletonBean(String beanName) {
		if (null == beanName || beanName.trim().isEmpty())
			return null;
		return getSingletonBean(beanName, Object.class);
	}

	/**
	 * 获取Spring上下文中的Bean定义
	 * 
	 * @param beanName BeanId
	 * @param type     Bean类型
	 * @return 泛化类型
	 * @description 从单例对象字典singletonObjects中获取指定Bean名称对应的单例Bean对象
	 */
	public static <R> R getSingletonBean(String beanName, Class<R> type) {
		if (null == beanName || null == type || beanName.trim().isEmpty())
			return null;
		DefaultListableBeanFactory beanFactory = getBeanFactory();
		if (!beanFactory.containsSingleton(beanName))
			return null;
		return type.cast(beanFactory.getSingleton(beanName));
	}

	/**
	 * 获取Spring上下文中的Bean定义
	 * 
	 * @param beanName BeanId
	 * @return Bean定义对象
	 * @description 从Bean定义字典beanDefinitionMap中获取指定Bean名称对应的Bean定义
	 */
	public static BeanDefinition getBeanDefinition(String beanName) {
		GenericApplicationContext applicationContext = getApplicationContext();
		if (null == beanName || null == applicationContext || beanName.trim().isEmpty()) return null;
		if (!applicationContext.containsBeanDefinition(beanName)) return null;
		return applicationContext.getBeanDefinition(beanName);
	}

	/**
	 * 移除Spring上下文中的Bean定义
	 * 
	 * @param beanName BeanId
	 * @description 从整个容器中移除指定Bean名称的Bean定义和单例Bean对象
	 */
	public static void removeBean(String beanName) {
		if (null == beanName || beanName.trim().isEmpty()) return;
		DefaultListableBeanFactory beanFactory = getBeanFactory();
		if (beanFactory.containsBeanDefinition(beanName)) {
			beanFactory.removeBeanDefinition(beanName);
		} else {
			beanFactory.destroySingleton(beanName);
		}
	}

	/**
	 * 移除Spring上下文中的所有兼容Bean定义
	 * 
	 * @param beanType 兼容Bean类型
	 * @return 移除的兼容类型Bean数量
	 * @description 从整个容器中移除指定兼容类型的Bean定义和单例Bean对象
	 */
	public static <R> Integer removeBean(Class<R> beanType) {
		GenericApplicationContext applicationContext = getApplicationContext();
		if (null == beanType || null == applicationContext) return null;
		String[] beanNames = applicationContext.getBeanNamesForType(beanType, true, true);
		if (null == beanNames || 0 == beanNames.length) return 0;
		for (String beanName : beanNames) removeBean(beanName);
		return beanNames.length;
	}

	/**
	 * 检查给定Bean名称对应的Bean是否为单例Bean
	 * 
	 * @param beanName Bean名称(BeanId)
	 * @return 是否为单例Bean
	 */
	public static Boolean isSingleton(String beanName) {
		GenericApplicationContext applicationContext = getApplicationContext();
		if (null == beanName || null == applicationContext || beanName.trim().isEmpty()) return null;
		return applicationContext.isSingleton(beanName);
	}

	/**
	 * 判断Spring上下文中是否存在指定名称的Bean对象
	 * 
	 * @param beanType Bean名称
	 * @return 逻辑类型
	 * @description 检查整个容器中是否存在指定Bean名称的Bean对象
	 */
	public static Boolean hasBean(String beanName) {
		GenericApplicationContext applicationContext = getApplicationContext();
		if (null == beanName || null == applicationContext || beanName.trim().isEmpty()) return null;
		return applicationContext.containsBean(beanName);
	}

	/**
	 * 判断Spring上下文中是否存在指定兼容类型的Bean对象
	 * 
	 * @param beanType Bean类型
	 * @return 逻辑类型
	 * @description 检查整个容器中是否存在指定兼容类型的Bean对象
	 */
	public static <R> Boolean hasBean(Class<R> beanType) {
		GenericApplicationContext applicationContext = getApplicationContext();
		if (null == beanType || null == applicationContext) return null;
		String[] beanNames = applicationContext.getBeanNamesForType(beanType, true, true);
		return null == beanNames || 0 == beanNames.length ? false : true;
	}

	/**
	 * 判断Spring上下文中是否存在指定兼容类型的唯一Bean对象
	 * 
	 * @param beanType Bean类型
	 * @return 逻辑类型
	 * @description 检查整个容器中是否存在指定兼容类型的唯一Bean对象
	 */
	public static <R> Boolean hasUniqueBean(Class<R> beanType) {
		GenericApplicationContext applicationContext = getApplicationContext();
		if (null == beanType || null == applicationContext) return null;
		String[] beanNames = applicationContext.getBeanNamesForType(beanType, true, true);
		return null == beanNames || 0 == beanNames.length ? false : 1 < beanNames.length ? false : true;
	}

	/**
	 * 判断Spring上下文中是否存在指定名称的单例Bean对象
	 * 
	 * @param beanType Bean名称
	 * @return 逻辑类型
	 * @description 检查单例对象字典singletonObjects中是否存在指定的名称的单例Bean对象
	 */
	public static Boolean hasSingletonBean(String beanName) {
		if (null == beanName || beanName.trim().isEmpty()) return null;
		DefaultListableBeanFactory beanFactory = getBeanFactory();
		return beanFactory.containsSingleton(beanName);
	}

	/**
	 * 判断Spring上下文中是否存在指定名称的Bean定义
	 * 
	 * @param beanType Bean名称
	 * @return 逻辑类型
	 * @description 检查Bean定义字典beanDefinitionMap中是否存在指定的名称的Bean定义
	 */
	public static Boolean hasBeanDefinition(String beanName) {
		GenericApplicationContext applicationContext = getApplicationContext();
		if (null == beanName || null == applicationContext || beanName.trim().isEmpty()) return null;
		return applicationContext.containsBeanDefinition(beanName);
	}

	/**
	 * 环境中是否配置指定的属性
	 * 
	 * @param key 键
	 * @return 逻辑类型
	 */
	public static Boolean hasProperty(String key) {
		return getEnvironment().containsProperty(key);
	}

	/**
	 * 环境中是否配置指定的属性前缀
	 * 
	 * @param prefix 键前缀
	 * @return 是否存在指定的属性前缀
	 */
	public static Boolean hasPropertyPrefix(String prefix) {
		for (PropertySource<?> propertySource : getEnvironment().getPropertySources()) {
			Object source = propertySource.getSource();
			if (null == source || !(source instanceof Map)) continue;
			for (Object key : ((Map<Object, Object>) source).keySet()) 
				if (key.toString().startsWith(prefix)) return true;
		}
		return false;
	}

	/**
	 * 获取环境配置
	 * 
	 * @param key 键
	 * @return 字串类型
	 */
	public static String getProperty(String key) {
		return getProperty(key, (String) null, (String[]) null);
	}

	/**
	 * 获取环境配置
	 * 
	 * @param key          键
	 * @param defaultValue 默认值
	 * @return 字串类型
	 */
	public static String getProperty(String key, String defaultValue) {
		return getProperty(key, (String) null, defaultValue);
	}

	/**
	 * 获取环境配置
	 * 
	 * @param key          键
	 * @param defaultKey   默认键
	 * @param defaultValue 默认值
	 * @return 字串类型
	 */
	public static String getProperty(String key, String defaultKey, String... defaultValue) {
		return getProperty(key, defaultKey, String.class, defaultValue);
	}

	/**
	 * 获取环境配置
	 * 
	 * @param key          键
	 * @param defaultValue 默认值
	 * @return 对象类型
	 */
	public static Object getProperty(String key, Object... defaultValue) {
		return getProperty(key, Object.class, defaultValue);
	}

	/**
	 * 获取环境配置
	 * 
	 * @param key          键
	 * @param defaultKey   默认键
	 * @param defaultValue 默认值
	 * @return 对象类型
	 */
	public static Object getProperty(String key, String defaultKey, Object... defaultValue) {
		return getProperty(key, defaultKey, Object.class, defaultValue);
	}

	/**
	 * 获取环境配置
	 * 
	 * @param key          键
	 * @param returnType   返回类型
	 * @param defaultValue 默认值
	 * @return 泛化类型
	 */
	public static <R> R getProperty(String key, Class<R> returnType, R... defaultValue) {
		return getProperty(key, (String) null, returnType, defaultValue);
	}

	/**
	 * 获取环境配置
	 * 
	 * @param key          键
	 * @param defaultKey   默认键
	 * @param returnType   返回类型
	 * @param defaultValue 默认值
	 * @return 泛化类型
	 */
	public static <R> R getProperty(String key, String defaultKey, Class<R> returnType, R... defaultValue) {
		R defaultVal = (null == defaultValue || 0 == defaultValue.length) ? null : defaultValue[0];

		StandardEnvironment env = getEnvironment();
		String value = env.getProperty(key);

		if (null == value && null != defaultKey)
			value = env.getProperty(defaultKey);
		if (null == value)
			return defaultVal;
		String stringValue = value.toString().trim();

		try {
			if (Number.class.isAssignableFrom(returnType)) {
				return returnType.getConstructor(String.class).newInstance(stringValue);
			} else if (Date.class.isAssignableFrom(returnType)) {
				return returnType.getConstructor(long.class).newInstance(DateUtil.stringToMillSeconds(stringValue));
			} else if (Boolean.class == returnType) {
				return (R) Boolean.valueOf(stringValue);
			} else if (Character.class == returnType) {
				return (R) Character.valueOf(stringValue.charAt(0));
			} else {
				return (R) stringValue;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 获取环境配置
	 * 
	 * @param prefix       配置前缀
	 * @param defaultValue 默认值
	 * @return 字典类型
	 * @throws Exception
	 */
	public static Map<String, Object> getProperties(String prefix, Map<String, Object>... defaultValue)
			throws Exception {
		return getProperties(prefix, null, Map.class, null, defaultValue);
	}

	/**
	 * 获取环境配置
	 * 
	 * @param prefix       配置前缀
	 * @param returnType   返回类型
	 * @param defaultValue 默认值
	 * @return 实体类型或字典类型
	 * @throws Exception
	 */
	public static <R> R getProperties(String prefix, Class<R> returnType, R... defaultValue) throws Exception {
		return getProperties(prefix, null, returnType, null, defaultValue);
	}

	/**
	 * 获取环境配置
	 * 
	 * @param prefix       配置前缀
	 * @param returnType   返回类型
	 * @param valueType    字典值类型
	 * @param defaultValue 默认值
	 * @return 实体类型或字典类型
	 * @throws Exception
	 */
	public static <R, E> R getProperties(String prefix, Class<R> returnType, Class<E> valueType, R... defaultValue)
			throws Exception {
		return getProperties(prefix, null, returnType, valueType, defaultValue);
	}

	/**
	 * 获取环境配置
	 * 
	 * @param prefix        配置前缀
	 * @param defaultPrefix 默认配置前缀
	 * @param returnType    返回类型
	 * @param valueType     字典值类型
	 * @param defaultValue  默认值
	 * @return 实体类型或字典类型
	 * @throws Exception
	 */
	public static <R, E> R getProperties(String prefix, String defaultPrefix, Class<R> returnType, Class<E> valueType,
			R... defaultValue) throws Exception {
		Map<String, Object> dict = new HashMap<String, Object>();
		R defaultVal = (null == defaultValue || 0 == defaultValue.length) ? null : defaultValue[0];

		// 获取环境配置
		Map<String, Object> properties = getPropertiesConfig();

		// 过滤出前缀配置组
		properties.entrySet().stream().filter(entry -> entry.getKey().startsWith(prefix)).forEach(entry -> {
			String attrName = entry.getKey().substring(prefix.length());
			if (!prefix.endsWith("."))
				attrName = attrName.substring(attrName.indexOf(".") + 1);
			dict.put(attrName, entry.getValue());
		});

		if (0 == dict.size() && null != defaultPrefix) {
			properties.entrySet().stream().filter(entry -> entry.getKey().startsWith(defaultPrefix)).forEach(entry -> {
				String attrName = entry.getKey().substring(defaultPrefix.length());
				if (!defaultPrefix.endsWith("."))
					attrName = attrName.substring(attrName.indexOf(".") + 1);
				dict.put(attrName, entry.getValue());
			});
		}

		if (0 == dict.size())
			return defaultVal;

		// 按实体类型解析
		if (!Map.class.isAssignableFrom(returnType)) {
			R r = returnType.newInstance();
			dict.forEach((key, value) -> recursionInjection(key, value, r));
			return r;
		}

		// 按普通Map接口类型解析
		if (null == valueType || CommonUtil.isSimpleType(valueType)) {
			if (returnType.isInterface())
				return returnType.cast(dict);
			R r = returnType.newInstance();
			Method method = CommonUtil.findMethod(returnType, "putAll", Map.class);
			method.invoke(r, dict);
			return r;
		}

		// 按嵌套实体的Map接口类型解析
		Map<String, E> returnMap = new HashMap<String, E>();
		dict.forEach((key, value) -> {
			String[] attrs = CommonUtil.DOT_REGEX.split(key);
			if (attrs.length != 2)
				return;
			String mapKey = CommonUtil.dashToHump(attrs[0]);
			String attrName = CommonUtil.dashToHump(attrs[1]);
			E e = returnMap.get(mapKey);
			try {
				if (null == e)
					returnMap.put(mapKey, e = valueType.newInstance());
				Field field = CommonUtil.findField(valueType, attrName);
				field.set(e, CommonUtil.transferType(value, field.getType()));
			} catch (Exception e1) {
				e1.printStackTrace();
			}
		});

		return returnType.cast(returnMap);
	}

	/**
	 * 设置Web应用域缓存
	 * 
	 * @param key   键
	 * @param value 值
	 */
	public static void setAttribute(String key, Object value) {
		getServletContext().setAttribute(key, value);
	}

	/**
	 * 获取Web应用域缓存
	 * 
	 * @param key          键
	 * @param defaultValue 默认值
	 * @return 对象类型
	 */
	public static Object getAttribute(String key, Object... defaultValue) {
		return getAttribute(key, Object.class, defaultValue);
	}

	/**
	 * 获取Web应用域缓存
	 * 
	 * @param key          键
	 * @param returnType   返回类型
	 * @param defaultValue 默认值
	 * @return 泛化类型
	 */
	public static <R> R getAttribute(String key, Class<R> returnType, R... defaultValue) {
		return getAttribute(key, null, returnType, defaultValue);
	}

	/**
	 * 获取Web应用域缓存
	 * 
	 * @param key          键
	 * @param defaultKey   默认键
	 * @param returnType   返回类型
	 * @param defaultValue 默认值
	 * @return 泛化类型
	 */
	public static <R> R getAttribute(String key, String defaultKey, Class<R> returnType, R... defaultValue) {
		R defaultVal = (null == defaultValue || 0 == defaultValue.length) ? null : defaultValue[0];
		ServletContext servletContext = getServletContext();
		Object value = servletContext.getAttribute(key);
		if (null == value && null != defaultKey)
			value = servletContext.getAttribute(defaultKey);
		if (null == value)
			return defaultVal;
		return returnType.cast(value);
	}

	/**
	 * 获取当前位置上下文
	 * 
	 * @param levels 线程栈层级
	 * @return 位置上下文字典
	 */
	public static StackTraceElement getPositionContext(Integer... levels) {
		Integer level = null == levels || 0 == levels.length ? 2 : null == levels[0] || levels[0] < 2 ? 2 : levels[0];
		return Thread.currentThread().getStackTrace()[level];
	}

	/**
	 * 获取当前文件名
	 * 
	 * @return 当前源文件名
	 */
	public static String getCurrentFileName(Integer... levels) {
		Integer level = null == levels || 0 == levels.length ? 2 : null == levels[0] || levels[0] < 2 ? 2 : levels[0];
		return Thread.currentThread().getStackTrace()[level].getFileName();
	}

	/**
	 * 获取当前文件行号
	 * 
	 * @return 当前文件行号
	 */
	public static Integer getCurrentLineNumber(Integer... levels) {
		Integer level = null == levels || 0 == levels.length ? 2 : null == levels[0] || levels[0] < 2 ? 2 : levels[0];
		return Thread.currentThread().getStackTrace()[level].getLineNumber();
	}

	/**
	 * 获取当前类名称
	 * 
	 * @return 当前类对象
	 * @throws ClassNotFoundException
	 */
	public static Class<?> getCurrentClass(Integer... levels) throws ClassNotFoundException {
		Integer level = null == levels || 0 == levels.length ? 2 : null == levels[0] || levels[0] < 2 ? 2 : levels[0];
		String className = Thread.currentThread().getStackTrace()[level].getClassName();
		return Class.forName(className);
	}

	/**
	 * 获取当前类名称
	 * 
	 * @return 当前类名
	 */
	public static String getCurrentClassName(Integer... levels) {
		Integer level = null == levels || 0 == levels.length ? 2 : null == levels[0] || levels[0] < 2 ? 2 : levels[0];
		return Thread.currentThread().getStackTrace()[level].getClassName();
	}

	/**
	 * 获取当前方法
	 * 
	 * @return 当前方法对象
	 * @throws ClassNotFoundException
	 */
	public static Method getCurrentMethod(Integer... levels) throws ClassNotFoundException {
		Integer level = null == levels || 0 == levels.length ? 2 : null == levels[0] || levels[0] < 2 ? 2 : levels[0];
		StackTraceElement threadStack = Thread.currentThread().getStackTrace()[level];
		String methodName = threadStack.getMethodName();
		Method[] methods = Class.forName(threadStack.getClassName()).getDeclaredMethods();
		for (Method method : methods)
			if (methodName.equals(method.getName()))
				return method;
		return null;
	}

	/**
	 * 获取当前方法名称
	 * 
	 * @return 当前方法名
	 */
	public static String getCurrentMethodName(Integer... levels) {
		Integer level = null == levels || 0 == levels.length ? 2 : null == levels[0] || levels[0] < 2 ? 2 : levels[0];
		return Thread.currentThread().getStackTrace()[level].getMethodName();
	}

	/**
	 * 获取当前类路径 返回此方法调用方的类路径目录
	 * 
	 * @return 字串类型
	 */
	public static String getCurrentClassPath(Integer... levels) {
		Integer level = null == levels || 0 == levels.length ? 2 : null == levels[0] || levels[0] < 2 ? 2 : levels[0];
		String callClassName = Thread.currentThread().getStackTrace()[level].getClassName();
		String callPkgPath = callClassName.substring(0, callClassName.lastIndexOf('.')).replace('.',
				File.separatorChar);
		return new StringBuilder(getClassPathRoot()).append(File.separatorChar).append(callPkgPath).toString();
	}

	/**
	 * 获取参数包对应的类路径目录
	 * 
	 * @param packagePath 包路径
	 * @return 字串类型
	 */
	public static String getPackageClassPath(String packagePath) {
		String packageDir = packagePath.replace('.', File.separatorChar);
		return new StringBuilder(getClassPathRoot()).append(File.separatorChar).append(packageDir).toString();
	}

	/**
	 * 获取工程类路径根目录
	 * 
	 * @return 字串类型
	 */
	public static String getClassPathRoot() {
		try {
			return new File(ApplicationUtil.class.getResource("/").toURI()).getAbsolutePath();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return getClassPathList().get(0);
	}

	/**
	 * 获取类路径目录列表
	 * 
	 * @return 路径列表
	 */
	public static List<String> getClassPathList() {
		String classpaths = getJVMProperties().get(PROJECT_CLASS_PATH).toString();
		return Arrays.asList(CLASSPATH_SEPARATOR_REGEX.split(classpaths));
	}

	/**
	 * 获取工程脚本目录
	 * 
	 * @param isDecode 是否需要中文解码
	 * @description 按常规服务器目录编排获取
	 * @return 工程脚本目录
	 */
	public static File getBinPath(Boolean... isDecode) {
		return new File(getProjectPath(isDecode), "bin");
	}

	/**
	 * 获取工程配置目录
	 * 
	 * @param isDecode 是否需要中文解码
	 * @description 按常规服务器目录编排获取
	 * @return 工程配置目录
	 */
	public static File getConfPath(Boolean... isDecode) {
		return new File(getProjectPath(isDecode), "conf");
	}

	/**
	 * 获取工程目录
	 * 
	 * @param isDecode 是否需要中文解码
	 * @description 按常规服务器目录编排获取
	 * @return 工程目录
	 */
	public static File getProjectPath(Boolean... isDecode) {
		return getLibPath(isDecode).getParentFile();
	}

	/**
	 * 获取工程库目录
	 * 
	 * @param isDecode 是否需要中文解码
	 * @description 按常规服务器目录编排获取
	 * @return 工程库目录
	 */
	public static File getLibPath(Boolean... isDecode) {
		return getJarPkgFile(isDecode).getParentFile();
	}

	/**
	 * 获取当前JAR包绝对路径文件
	 * 
	 * @param isDecode 是否需要中文解码
	 * @return 绝对路径文件
	 */
	public static File getJarPkgFile(Boolean... isDecode) {
		String jarPkgPath = getJarPkgPath(isDecode);
		return new File(jarPkgPath);
	}

	/**
	 * 获取当前JAR包绝对路径
	 * 
	 * @param isDecode 是否需要中文解码
	 * @return JAR包绝对路径
	 */
	public static String getJarPkgPath(Boolean... isDecode) {
		boolean decode = null == isDecode || 0 == isDecode.length || null == isDecode[0] ? false : isDecode[0];
		String currentClassPath = ApplicationUtil.class.getProtectionDomain().getCodeSource().getLocation().getPath();

		try {
			if (decode)
				currentClassPath = java.net.URLDecoder.decode(currentClassPath, "UTF-8");
		} catch (UnsupportedEncodingException e) {
			throw new RuntimeException(e);
		}

		String jarUriPath = currentClassPath;
		int firstSep = currentClassPath.indexOf("!");
		if (-1 != firstSep)
			jarUriPath = currentClassPath.substring(0, firstSep);

		String prefix = jarUriPath.substring(0, 3);
		if (PATH_PREFIX.matcher(prefix).matches()) {
			return new File(jarUriPath.substring(1)).getAbsolutePath();
		} else {
			if (!isWindows()) {
				return new File(jarUriPath).getAbsolutePath();
			} else {
				try {
					return new File(new URI(jarUriPath)).getAbsolutePath();
				} catch (URISyntaxException e) {
					throw new RuntimeException(e);
				}
			}
		}
	}

	/**
	 * 获取工程类路径绝对路径目录
	 * 
	 * @return 类路径绝对路径目录
	 */
	public static File getClassPathRealFile() {
		String realPath = getClassPathRealPath();
		if (null == realPath) return null;
		return new File(realPath);
	}

	/**
	 * 获取工程类路径绝对路径
	 * 
	 * @return 类路径绝对路径
	 */
	public static String getClassPathRealPath() {
		String location = null;
		try {
			location = ApplicationUtil.class.getProtectionDomain().getCodeSource().getLocation().toURI().toString();
		} catch (URISyntaxException e) {
			e.printStackTrace();
		}
		if (null == location) return null;
		return location.startsWith("file:") ? location.substring(5) : location;
	}

	/**
	 * 递归获取参数包路径下的所有类
	 * 
	 * @param packagePath 包路径(使用'.'分隔)
	 * @return 类表
	 * @throws ClassNotFoundException
	 */
	public static ArrayList<Class<?>> getClasses(String packagePath) throws ClassNotFoundException {
		if (null == packagePath || packagePath.trim().isEmpty()) return null;
		String classPath = new StringBuilder(getClassPathRoot()).append(File.separatorChar).toString();
		return getClasses(classPath,new File(new StringBuilder(classPath).append(packagePath.replace('.', File.separatorChar)).toString()));
	}

	/**
	 * 递归获取指定目录下的
	 * 
	 * @param classPath 类路径目录(使用'/'分隔并以'/'结尾)
	 * @param directory 目录绝对路径
	 * @return 类表
	 * @throws ClassNotFoundException
	 */
	public static ArrayList<Class<?>> getClasses(String classPath, File directory) throws ClassNotFoundException {
		if (null == classPath || null == directory || 0 == classPath.trim().length() || directory.isFile()) return null;
		ArrayList<Class<?>> list = new ArrayList<Class<?>>();
		for (File file : directory.listFiles()) {
			if (file.isFile()) {
				String fullPath = file.getAbsolutePath();
				String packgeName = fullPath.substring(classPath.trim().length(), fullPath.length() - 6)
						.replace(File.separatorChar, '.');
				list.add(Class.forName(packgeName));
				continue;
			}
			ArrayList<Class<?>> tmpList = getClasses(classPath, file);
			if (null == tmpList || 0 == tmpList.size())
				continue;
			list.addAll(tmpList);
		}
		return list;
	}

	/**
	 * 获取当前Jvm进程ID
	 */
	public static Integer getJvmProcessID() {
		String jvmName = ManagementFactory.getRuntimeMXBean().getName();
		if (null == jvmName) return null;
		jvmName = jvmName.trim();
		if (0 == jvmName.length()) return null;
		if (-1 == jvmName.indexOf("@")) return null;
		return Integer.parseInt(EMAIL_SEPARATOR_REGEX.split(jvmName)[0]);
	}

	/**
	 * 当前系统是否为Windows
	 */
	public static final boolean isWindows() {
		return ManagementFactory.getOperatingSystemMXBean().getName().trim().toLowerCase().startsWith("win") ? true : false;
	}

	/**
	 * 强制杀掉子进程
	 * 
	 * @param process 子进程ID
	 */
	public static final Boolean forceKillProcess(long processId) {
		return killProcess(processId, true);
	}

	/**
	 * 平滑杀掉子进程
	 * 
	 * @param process 子进程ID
	 */
	public static final Boolean gracefulKillProcess(long processId) {
		return killProcess(processId, false);
	}

	/**
	 * 杀掉子进程
	 * 
	 * @param processId 子进程ID
	 * @param force     是否强制杀掉(true:强制,false:平滑)
	 */
	public static final Boolean killProcess(long processId, boolean force) {
		String osName = ManagementFactory.getOperatingSystemMXBean().getName().trim().toLowerCase();
		try {
			if (osName.startsWith("win")) {
				if (force) {
					return Runtime.getRuntime().exec("taskkill /T /F /PID " + processId).waitFor(15, TimeUnit.SECONDS);
				} else {
					return Runtime.getRuntime().exec("taskkill /T /PID " + processId).waitFor(15, TimeUnit.SECONDS);
				}
			} else {
				if (force) {
					return Runtime.getRuntime().exec("kill -9 " + processId).waitFor(15, TimeUnit.SECONDS);
				} else {
					return Runtime.getRuntime().exec("kill -sigterm " + processId).waitFor(15, TimeUnit.SECONDS);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 获取Spring切面执行优先级
	 * 
	 * @param aspectBeanName 切面Bean名称
	 * @param aspectBeanType 切面Bean类型
	 * @return 切面优先级顺序
	 */
	public static Integer getAspectOrder(String aspectBeanName) {
		Object aspectBean = ApplicationUtil.getBean(aspectBeanName);
		return Ordered.class.isInstance(aspectBean) ? ((Ordered) aspectBean).getOrder() : null;
	}

	/**
	 * 修改Spring事务切面的执行顺序
	 * 
	 * @param order 切面执行优先级
	 */
	public static void setTransactionAdvisorOrder(Integer order) {
		Class<?> advisorType = null;
		try {
			advisorType = Class.forName("org.springframework.transaction.interceptor.BeanFactoryTransactionAttributeSourceAdvisor");
		} catch (ClassNotFoundException e) {
			throw new RuntimeException(e);
		}

		if (null == advisorType) return;

		Object advisor = null;
		if (null == (advisor = getBean("org.springframework.transaction.config.internalTransactionAdvisor",advisorType))) return;

		try {
			Method setOrder = advisorType.getDeclaredMethod("setOrder", int.class);
			if (null != order) {
				setOrder.invoke(advisor, order);
			} else {
				setOrder.invoke(advisor, Ordered.HIGHEST_PRECEDENCE);
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 注册单例Bean到Spring上下文
	 * 
	 * @param bean 单例Bean对象
	 */
	public static void registerSingleton(Object bean) {
		String simpleName = bean.getClass().getSimpleName();
		String beanName = CommonUtil.lowerFirstChar(simpleName);
		registerSingleton(beanName, bean);
	}

	/**
	 * 注册单例Bean到Spring上下文
	 * 
	 * @param beanName Bean名称(BeanId)
	 * @param bean     单例Bean对象
	 */
	public static void registerSingleton(String beanName, Object bean) {
		registerSingleton(beanName, bean, BeanIdMode.BEAN_NAME);
	}

	/**
	 * 注册单例Bean到Spring上下文
	 * 
	 * @param beanName        Bean名称(BeanId)
	 * @param bean            单例Bean对象
	 * @param removeNonUnique 重复Bean定义的移除模式
	 * @description 注册单例Bean定义和单例Bean对象
	 */
	public static void registerSingleton(String beanName, Object bean, BeanIdMode removeNonUnique) {
		if (null == bean) throw new RuntimeException("bean can not be null...");
		if (null == beanName || beanName.trim().isEmpty()) throw new RuntimeException("beanName can not be empty...");
		registerBeanDefinition(beanName, bean.getClass(), removeNonUnique);
		registerSingletonBean(beanName, bean);
	}

	/**
	 * 注册单例Bean到Spring上下文
	 * 
	 * @param beanName Bean名称(BeanId)
	 * @param bean     单例Bean对象
	 * @description 注册单例Bean对象
	 */
	public static void registerSingletonBean(String beanName, Object bean) {
		DefaultListableBeanFactory beanFactory = getBeanFactory();
		if (null == beanFactory) return;
		beanFactory.registerSingleton(beanName, bean);
	}

	/**
	 * 注册Bean到Spring上下文
	 * 
	 * @param beanType Bean类型
	 * @return 泛化类型
	 * @description 注册Bean定义
	 */
	public static <R> void registerBeanDefinition(Class<R> beanType) {
		registerBeanDefinition(beanType, new HashMap<String, Object>());
	}

	/**
	 * 注册Bean到Spring上下文
	 * 
	 * @param beanName Bean名称(beanId)
	 * @param beanType Bean类型
	 * @return 泛化类型
	 * @description 注册Bean定义
	 */
	public static <R> void registerBeanDefinition(String beanName, Class<R> beanType) {
		registerBeanDefinition(beanName, beanType, new HashMap<String, Object>());
	}

	/**
	 * 注册Bean到Spring上下文
	 * 
	 * @param beanType   Bean类型
	 * @param properties Bean属性字典
	 * @return 泛化类型
	 * @description 注册Bean定义
	 */
	public static <R> void registerBeanDefinition(Class<R> beanType, Map<String, Object> properties) {
		registerBeanDefinition(beanType, properties, BeanIdMode.BEAN_NAME);
	}

	/**
	 * 注册Bean到Spring上下文
	 * 
	 * @param beanName        Bean名称(beanId)
	 * @param beanType        Bean类型
	 * @param removeNonUnique 重复Bean定义的移除模式
	 * @return 泛化类型
	 * @description 注册Bean定义
	 */
	public static <R> void registerBeanDefinition(String beanName, Class<R> beanType, BeanIdMode removeNonUnique) {
		registerBeanDefinition(beanType, beanName, new HashMap<String, Object>(), removeNonUnique);
	}

	/**
	 * 注册Bean到Spring上下文
	 * 
	 * @param beanName   Bean名称(beanId)
	 * @param beanType   Bean类型
	 * @param properties Bean属性字典
	 * @return 泛化类型
	 * @description 注册Bean定义
	 */
	public static <R> void registerBeanDefinition(String beanName, Class<R> beanType, Map<String, Object> properties) {
		registerBeanDefinition(beanType, beanName, properties, BeanIdMode.BEAN_NAME);
	}

	/**
	 * 注册Bean到Spring上下文
	 * 
	 * @param beanType        Bean类型
	 * @param properties      Bean属性字典
	 * @param removeNonUnique 重复Bean定义的移除模式
	 * @return 泛化类型
	 * @description 注册Bean定义
	 */
	public static <R> void registerBeanDefinition(Class<R> beanType, Map<String, Object> properties,
			BeanIdMode removeNonUnique) {
		registerBeanDefinition(beanType, null, properties, removeNonUnique);
	}

	/**
	 * 注册Bean到Spring上下文
	 * 
	 * @param beanType        Bean类型
	 * @param beanName        Bean名称(beanId)
	 * @param properties      Bean属性字典
	 * @param removeNonUnique 重复Bean定义的移除模式
	 * @param constructorArgs Bean类构造器参数列表
	 * @return 泛化类型
	 * @description 注册Bean定义
	 */
	public static <R> void registerBeanDefinition(Class<R> beanType, String beanName, Map<String, Object> properties,
			BeanIdMode removeNonUnique, Object... constructorArgs) {
		DefaultListableBeanFactory beanFactory = getBeanFactory();
		if (null == beanFactory) return;

		// 获取Bean参数定义
		Object scope = null;
		Object lazyInit = null;
		Object initMethod = null;
		Object dependsBeanId = null;
		Object autowireMode = null;
		Object destoryMethod = null;
		if (null != properties && 0 != properties.size()) {
			scope = properties.remove("scope");
			lazyInit = properties.remove("lazyInit");
			initMethod = properties.remove("initMethod");
			dependsBeanId = properties.remove("dependsBeanId");
			autowireMode = properties.remove("autowireMode");
			destoryMethod = properties.remove("destoryMethod");
		}

		// 设置Bean定义参数
		BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(beanType);
		beanDefinitionBuilder.setAutowireMode(
				null == autowireMode ? AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE : (Integer) autowireMode);
		beanDefinitionBuilder.setScope(null == scope ? BeanDefinition.SCOPE_SINGLETON : (String) scope);
		beanDefinitionBuilder.setLazyInit(null == lazyInit ? true : (Boolean) lazyInit);
		if (null != dependsBeanId)
			beanDefinitionBuilder.addDependsOn((String) dependsBeanId);
		if (null != initMethod)
			beanDefinitionBuilder.setInitMethodName((String) initMethod);
		if (null != destoryMethod)
			beanDefinitionBuilder.setDestroyMethodName((String) destoryMethod);

		// 添加构造参数值
		if (null != constructorArgs && 0 != constructorArgs.length) {
			for (Object argValue : constructorArgs)
				beanDefinitionBuilder.addConstructorArgValue(argValue);
		}

		// 设置Bean属性值
		if (null != properties) properties.forEach((key, value) -> beanDefinitionBuilder.addPropertyValue(key, value));

		// 设置Bean的名字(BeanId)
		if (null == beanName) beanName = CommonUtil.lowerFirstChar(beanType.getSimpleName());

		// 移除已经包含此Bean的定义
		if (removeNonUnique == BeanIdMode.BEAN_NAME) {
			removeBean(beanName);
		} else {
			removeBean(beanType);
		}

		// 注册Bean到容器
		beanFactory.registerBeanDefinition(beanName, beanDefinitionBuilder.getRawBeanDefinition());
	}

	/**
	 * 包装实体对象(递归处理对象图结构)
	 * 
	 * @param key   复合类型Key
	 * @param value 最终设定的简单类型值
	 */
	public static <R> void recursionInjection(String key, Object value, R r) {
		String curAttrName = key;
		String nextAttrName = null;
		int index = key.indexOf(".");
		if (-1 != index) {
			curAttrName = key.substring(0, index);
			nextAttrName = key.substring(index + 1);
		}

		String fieldName = CommonUtil.dashToHump(curAttrName);
		Class<? extends Object> returnType = r.getClass();
		try {
			Field field = CommonUtil.findField(returnType, fieldName);
			if (null == field) return;
			Class<?> attrType = field.getType();
			Boolean isSimpleType = CommonUtil.isSimpleType(attrType);
			if (null != nextAttrName && (isSimpleType || attrType.isArray())) return;

			// 简单类型设值
			if (isSimpleType) {
				field.set(r, CommonUtil.transferType(value, field.getType()));
				return;
			}

			// 字符数组类型赋值
			if (char[].class == attrType || Character[].class == attrType) {
				field.set(r, CommonUtil.transferArray(value.toString().toCharArray(), attrType.getComponentType()));
				return;
			}

			// 数组类型设值
			if (attrType.isArray()) {
				Class<?> eleType = attrType.getComponentType();
				String[] array = CommonUtil.COMMA.split(value.toString());
				Object arrValue = Array.newInstance(eleType, array.length);
				for (int i = 0; i < array.length; i++) {
					Object transferValue = CommonUtil.transferType(array[i], eleType);
					Array.set(arrValue, i, transferValue);
				}
				field.set(r, arrValue);
				return;
			}

			// 集合类型设值(集合泛型为简单类型)
			if (Collection.class.isAssignableFrom(attrType)) {
				Collection cols = null;
				if (attrType.isInterface()) {
					cols = List.class.isAssignableFrom(attrType) ? new ArrayList() : new HashSet();
				} else {
					try {
						cols = (Collection) attrType.newInstance();
					} catch (Exception e) {
						e.printStackTrace();
					}
				}

				Class<?>[] genericParams = CommonUtil.getGenericClass(field);
				String[] array = CommonUtil.COMMA.split(value.toString());
				if (null == genericParams || 0 == genericParams.length) {
					cols.add(Arrays.asList(array));
				} else {
					Object newArray = CommonUtil.transferArray(array, genericParams[0]);
					cols.addAll(CommonUtil.arrayToList(newArray));
				}
				field.set(r, cols);
				return;
			}

			// 字典类型设值(字典泛型为简单类型)
			if (Map.class.isAssignableFrom(attrType)) {
				Map map = null;
				if (attrType.isInterface()) {
					map = new HashMap();
				} else {
					try {
						map = (Map) attrType.newInstance();
					} catch (Exception e) {
						e.printStackTrace();
					}
				}

				Map readMap = CommonUtil.jsonStrToJava(value.toString(), Map.class);
				Class<?>[] genericParams = CommonUtil.getGenericClass(field);
				if (null == genericParams || 2 != genericParams.length) {
					map.putAll(readMap);
				} else {
					for (Map.Entry entry : (Set<Map.Entry>) readMap.entrySet()) {
						Object attrName = CommonUtil.transferType(entry.getKey(), genericParams[0]);
						Object attrValue = CommonUtil.transferType(entry.getValue(), genericParams[1]);
						map.put(attrName, attrValue);
					}
				}
				field.set(r, map);
				return;
			}

			// 复合类型设值
			recursionInjection(nextAttrName, value, attrType.newInstance());
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}