package com.vci.web.util;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.vci.client.common.objects.UserEntityObject;
import com.vci.common.exception.VciException;
import com.vci.corba.common.PLException;
import com.vci.corba.common.data.UserEntityInfo;
import com.vci.corba.omd.data.AttributeValue;
import com.vci.corba.omd.data.BusinessObject;
import com.vci.corba.omd.data.LinkObject;
import com.vci.omd.utils.ObjectTool;
import com.vci.starter.revision.bo.TreeWrapperOptions;
import com.vci.starter.web.annotation.*;
import com.vci.starter.web.constant.QueryOptionConstant;
import com.vci.starter.web.enumpck.BooleanEnum;
import com.vci.starter.web.enumpck.VciFieldTypeEnum;
import com.vci.starter.web.exception.VciBaseException;
import com.vci.starter.web.pagemodel.SessionInfo;
import com.vci.starter.web.pagemodel.Tree;
import com.vci.starter.web.toolmodel.DateConverter;
import com.vci.starter.web.util.*;
import com.vci.starter.web.wrapper.VciQueryWrapperForDO;
import com.vci.web.pageModel.*;
import com.vci.web.service.impl.WebLoServiceImpl;
import net.sf.jsqlparser.parser.CCJSqlParserUtil;
import net.sf.jsqlparser.statement.select.PlainSelect;
import net.sf.jsqlparser.statement.select.SelectItem;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import javax.servlet.http.HttpServletRequest;
import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.reflect.*;
import java.math.BigDecimal;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.sql.Timestamp;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 通用工具类
 * @author weidy
 * @date 2021-2-13
 */
@Component
public  class WebUtil extends VciBaseUtil {

	/**
	 * 全部标记，常用语树形展示时
	 */
	public static final String ALL = "${all}";

	/**
	 * 是否持久化
	 */
	private static ThreadLocal<String> needPersistenceInThread = new ThreadLocal<>();
	/**
	 * 日志对象
	 */
	private static Logger logger = LoggerFactory.getLogger(WebUtil.class);

    /**
     * 获取错误信息
     * @param e 异常对象
     * @return 错误信息
     */
	public static String getErrorMsg(Throwable e){
		String errContent = "";
		try {
			if (e == null) {
				return errContent;
			}
			if (e instanceof PLException ) {
//				String error_code = ((VCIError) e).error_code;
//				String[] error_message = ((VCIError) e).error_message;
//				return MessageUtils.get(error_code, error_message);
				return null;
			} else if(e instanceof VciBaseException || e.getClass().getSuperclass().equals(VciBaseException.class)){
				return LangBaseUtil.getErrorMsg(e);
			}else if (e instanceof VciException){
				String error_code = ((VciException) e).getCode();
				Object[] error_message = ((VciException) e).getObjArray();
				return MessageUtils.get(error_code, error_message);
			}else if (e.getCause() != null
					&& !e.getCause().toString().equals("")) {
				errContent = e.getCause().toString();
			} else if (e.getLocalizedMessage() != null
					&& !e.getLocalizedMessage().equals("")) {
				errContent = e.getLocalizedMessage();
			} else if (e.getMessage() != null && !e.getMessage().equals("")) {
				errContent = e.getMessage();
			} else {
				errContent = e.toString();
			}
		} catch (Exception e1) {
			return LangBaseUtil.getErrorMsg(e1);
		}
		return errContent;
	}

	/**
	 * 获取当前用户的用户名
	 * @return 用户名
	 */
	public  static  String getCurrentUserId( ){
		SessionInfo s = getCurrentUserSessionInfoNotException();
		if(s !=null){
			return s.getUserId();
		}else{
			return  "";
		}
	}
	

	/**
	 * 获取当前用户的主键
	 * @return 主键
	 */
	public  static  String getCurrentUserOid( ){
		SessionInfo s = getCurrentUserSessionInfoNotException();
		if(s !=null){
			return s.getUserId();
		}else{
			return  "";
		}
	}
		
	/**
	 * json字符串转为对象
	 * @param jsonString json的字符串
	 * @param beanClass bean的类
	 * @return bean
	 */
	public static <T> T jsonString2JavaBean(String jsonString,Class<T> beanClass){
		return (T)JSONObject.parseObject(jsonString,  beanClass);
	}

	/**
	 * 从json字符串中获取第一个对象
	 * @param jsonString json的字符串
	 * @param beanClass Bean的类
	 * @return 从列表里获取第一个对象
	 */
	public static <T> T getFirstObjectFromJson(String jsonString,Class<T> beanClass){
		if(!isNull(jsonString)) {
			return JSONObject.parseArray(jsonString, beanClass).get(0);
		} else {
			return null;
		}
	}
	
	/**
	 * 获取sessionInfo对象
	 * @return 获取当前用户的信息
	 */
	public static SessionInfo getSessionInfo(){
		try{
			return getCurrentUserSessionInfoNotException();
		}catch(Exception e){
			return null;
		}
	}

	/**
	 * 获取当前线程中的用户对象
	 * @return 当前用户信息
	 * @throws VciBaseException 没有登录会抛出异常
	 */
	public static SessionInfo getCurrentUserSessionInfo() throws VciBaseException{
		SessionInfo si= getCurrentUserSessionInfoNotException();
		if(si==null){
			throw new VciBaseException("noLogin",new String[]{"没有当前用户信息"});
		}
		return si;
	}

	/**
	 * 获取当前线程中的用户对象
	 * @return 用户对象，但是不抛出异常
	 */
	public static SessionInfo getCurrentUserSessionInfoNotException() {
		return WebThreadLocalUtil.getCurrentUserSessionInfoInThread();
	}

	/**
	 * 设置用户的会话信息对象
	 * @param sessionInfo 会话信息
	 */
	public static synchronized void setSessionInfo(SessionInfo sessionInfo){
		 WebThreadLocalUtil.setCurrentUserSessionInfoInThread(sessionInfo);
	}

	/**
	 * 是否设置了corba需要使用的上下文信息，只针对webService的
	 */
	private static volatile boolean isSetContext = false;

	/**
	 * 获取IP地址，通过request
	 * @param request 请求的对象
	 * @return ip地址
	 */
	public static String getClientInfo(HttpServletRequest request){
		String ip = request.getHeader("X-Forwarded-For");
		if (StringUtils.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) {
			ip = request.getHeader("Proxy-Client-IP");
		}
		if (StringUtils.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) {
			ip = request.getHeader("WL-Proxy-Client-IP");
		}
		if (StringUtils.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) {
			ip = request.getHeader("HTTP_CLIENT_IP");
		}
		if (StringUtils.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) {
			ip = request.getHeader("HTTP_X_FORWARDED_FOR");
		}
		if (StringUtils.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) {
			ip = request.getRemoteAddr();
		}
		if (StringUtils.isBlank(ip) || ip.indexOf("0:0:0:0:0:0:0:1") >-1) {//0:0:0:0:0:0:0:1是本机在访问
			ip = "127.0.0.1";
		}
		return ip;
	}

	/**
	 * 获取corba要的用户对象
	 * @param model 当前模块
	 * @return 用户对象
	 */
	public static UserEntityInfo getUserEntityInfo(String model){
		SessionInfo si = WebUtil.getCurrentUserSessionInfo();
		UserEntityInfo ueo = new UserEntityInfo();
//		ueo.ip = si.getIp();
		ueo.modules = model;
		ueo.userName = si.getUserId();
		return ueo;
	}
	
	/**
	 * 获取corba要的用户对象
	 * @param model 模块
	 * @return 用户对象
	 */
	public static UserEntityObject getUserEntityObject(String model) {
		UserEntityObject entityObject = new UserEntityObject();
		SessionInfo si = WebUtil.getCurrentUserSessionInfo();
//		entityObject.setIp(si.getIp());
		entityObject.setModules(model);
		entityObject.setUserName(si.getUserId());
		return entityObject;
	}


	/**
	 * 是否持久化
	 * @return 默认为true
	 */
	public static boolean isPersistence(){
		String persistence =needPersistenceInThread.get();
		if(StringUtils.isNotBlank(persistence) && BooleanEnum.FASLE.getValue().equalsIgnoreCase(persistence)){
			return false;
		}else{
			return true;
		}
	}

	/**
	 * 设置是否持久化
	 * @param isPersistence 是否持久化
	 */
	public static void setPersistence(boolean isPersistence){
		if(!isPersistence){
			needPersistenceInThread.set("false");
		}else{
			needPersistenceInThread.set("");
		}
	}


	/**
	 * 将对象转换为字符串出来
	 * @return json字符串
	 */
	public static String getJSONStringWithDateFormat(Object obj){
		return JSONObject.toJSONStringWithDateFormat(obj, VciDateUtil.DateTimeMillFormat, SerializerFeature.WriteDateUseDateFormat);
	}

	/**
	 * 最新转换为map
	 * @param o 对象
	 * @return map
	 */
	public static Map<String,Object> objectToMap(Object o){
		Map<String,Object> map = new HashMap<String,Object>();
		if(o!=null) {
			String jsonString = JSONObject.toJSONStringWithDateFormat(o, VciDateUtil.DateTimeMillFormat, SerializerFeature.WriteDateUseDateFormat);
			if(StringUtils.isNotBlank(jsonString)) {
				JSONObject jsonObject = JSONObject.parseObject(jsonString);
				if(jsonObject!=null){
					for(String key : jsonObject.keySet()){
						map.put(key,jsonObject.get(key));
					}
				}
			}
		}
		return map;
	}

	/**
	 * 对象转换为map
	 * @param o 对象
	 * @return map
	 */
	public static Map<String,String> objectToMapString(Object o){
		Map<String,String> map = new HashMap<String,String>();
		if(o!=null) {
			String jsonString = JSONObject.toJSONStringWithDateFormat(o, VciDateUtil.DateTimeMillFormat, SerializerFeature.WriteDateUseDateFormat);
			if(StringUtils.isNotBlank(jsonString)) {
				JSONObject jsonObject = JSONObject.parseObject(jsonString);
				if(jsonObject!=null){
					for(String key : jsonObject.keySet()){
						map.put(key,jsonObject.getString(key));
					}
				}
			}
		}
		return map;
	}

	/**
	 * 判断某个属性是否为空
	 * @param obj 对象
	 * @param f 字段
	 * @return true是不空
	 */
	public static boolean isNotNullForField(Object obj,Field f){
		if(!"serialVersionUID".equalsIgnoreCase(f.getName()) &&!"DEFAULT_INITIAL_CAPACITY".equalsIgnoreCase(f.getName())&&null!=obj && !WebUtil.isNullOrNullString(obj.toString())) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 数组转换为字符串
	 * @param array 数组
	 * @return 字符串
	 */
	public static String array2String(String[] array) {
		if(null == array || array.length == 0) {
			return "";
		}else{
			return Arrays.stream(array).collect(Collectors.joining(","));
		}
	}

	/**
	 * 对象转换为字符串
	 * @param obj 对象
	 * @return 字符串
	 */
	public static String getString(Object obj){
		if(obj == null) {
			return "";
		}
		if(obj instanceof Date) {
			return VciDateUtil.date2Str((Date) obj, VciDateUtil.DateTimeFormat);
		}
		return String.valueOf(obj);
	}

	/**
	 * 拷贝map里的值
	 * @param source 源
	 * @param target 目标
	 * @param copyField 拷贝的属性
	 */
	public static void copyValueForMap(Map source,Map target,String[] copyField){
		Map<String,String> copyFieldMap = new HashMap<String,String>();
		for(String field : copyField) {
			copyFieldMap.put(field, field);
		}
		copyValueForMap(source,target,copyFieldMap);
	}
	/**
	 * 为map拷贝值
	 * @param source 源
	 * @param target 目标
	 * @param copyField key为目标对象里的字段，
	 */
	public static void copyValueForMap(Map source,Map target,Map<String,String> copyField){
		try{
			Iterator<String> it = copyField.keySet().iterator();
			while(it.hasNext()){
				String field = it.next();
				target.put(field, source.get(copyField.get(field)));
			}
		}catch(Exception e){
			if(logger.isErrorEnabled()){
				logger.error("拷贝值到map",e);
			}
		}
	}

	/**
	* 将字符串转换为时间对象
	* @param text 字符串
	* @return 时间对象
	*/
	public static Date readText2Date(String text){
		DateConverter dateConverter = new DateConverter();
		dateConverter.setAsText(text);
		return dateConverter.getValue();
	}

	/**
	 * 从Map里获取double类型
	 * @param field 字段名称
	 * @param record map
	 * @return 属性
	 */
	public static Double getDoubleFromMap(String field,
			Map<String, Object> record) {
		if(WebUtil.isNullOrNullString(field) || record == null || !record.containsKey(field)) {
			return null;
		}else{
			Object v = record.get(field);
			if(v instanceof BigDecimal){
				return ((BigDecimal)v).doubleValue();
			}else if(v instanceof Double){
				return ((Double)v).doubleValue();
			}else{
				return WebUtil.getDouble((String)v);
			}
		}
	}

    /**
     * 获取不是空值的映射，且key是小写
     * @param map 映射
     * @return 去除空值的
     */
    public static Map getNotNullMap(Map map){
    	if(map == null){
    		return new HashMap();
    	}
    	Iterator it = map.keySet().iterator();
		Map unNullMap = new HashMap();
		while(it.hasNext()){
			Object key = it.next();
			String newKey = key.toString().toLowerCase();
			Object value = map.get(key);
			if(value !=null){
				if(value instanceof String && WebUtil.isNotNull(value.toString())){
					unNullMap.put(newKey, value);
				}else if(!(value instanceof String)){
					unNullMap.put(newKey, value);
				}
			}
		}
		return unNullMap;
    }
    
    /**
     * 获取参照的属性
     * @param c 对象
     * @return 参照属性
     */
    public static Map<String,String> getReferAttrName(Class c){
    	Map<String,String> fieldMap = new HashMap<String, String>();
    	List<Field> allField = getAllFieldForObj(c);
    	if(allField!=null&&allField.size()>0){
    		for(Field field : allField){
    			if (field.isAnnotationPresent(Transient.class)){
    				//有参照或者枚举
    				String referColumn = ((Transient)field.getAnnotation(Transient.class)).referColumn();
    				if(isNotNull(referColumn)){
    					fieldMap.put(referColumn.toLowerCase(), field.getName());
    				}
    			}
    		}
    	}
    	return fieldMap;
    }

	/**
	 * 获取参照的业务类型
	 * @param c 对象
	 * @return 参照的业务类型
	 */
	public static List<String> getReferBoAttrName(Class c){
    	return getReferBoAttrName(c,false);
    }

	/**
	 * 获取参照的业务类型
	 * @param c 对象
	 * @param isNotHasEnum 是否包含枚举
	 * @return 参照的业务类型
	 */
	public static List<String> getReferBoAttrName(Class c,boolean isNotHasEnum){
    	List<String> fieldMap = new ArrayList<String>();
    	List<Field> allField = getAllFieldForObj(c);
    	if(allField!=null&&allField.size()>0){
    		for(Field field : allField){
    			if (field.isAnnotationPresent(Transient.class)){
    				//有参照或者枚举
    				String referColumn = ((Transient)field.getAnnotation(Transient.class)).referColumn();
    				if(isNotNull(referColumn) && 
    						(!isNotHasEnum || (isNotHasEnum && referColumn.indexOf(".")>-1))){
    					fieldMap.add(referColumn.toLowerCase());
    				}
    			}
    		}
    	}
    	return fieldMap;
    }
    
    /**
     * 获取对象与业务类型里的属性映射
     * @param c 对象所属类
     * @return Map<String,String> 业务类型的字段：对象上的属性
     */
    public static Map<String/*业务类型中的字段*/,String/*对象上的属性*/> getFieldNameMap(Class c){
    	Map<String,String> fieldMap = new HashMap<String, String>();
    	List<Field> allField = getAllFieldForObj(c);
    	if(allField!=null&&allField.size()>0){
    		for(Field field : allField){
    			if(!field.getName().equals("serialVersionUID")){
	    			if(!field.isAnnotationPresent(Transient.class) ){
	    				String clientBoAttrName = getCboAttrNameFromField(field,c);
	    				fieldMap.put(clientBoAttrName, field.getName());
	    				if(field.isAnnotationPresent(VciUseEnum.class)){
	    					//这个是枚举，需要
							VciUseEnum vciUseEnum = field.getAnnotation(VciUseEnum.class);
							fieldMap.put(vciUseEnum.value() + "_" + clientBoAttrName,vciUseEnum.showTextField());
						}
	    			}else if (field.isAnnotationPresent(Transient.class)){
	    				//说明不是持久化的属性，但是从平台中查询出来后可能得需要显示
	    				String referColumn = ((Transient)field.getAnnotation(Transient.class)).referColumn();
	    				if(isNotNull(referColumn)){
	    					fieldMap.put(referColumn, field.getName());
	    				}
	    			}else{
	    				//子表的不能这样取 				
	    			}
    			}
    		}
    	}
		if(!CollectionUtils.isEmpty(fieldMap)){
			//看看有没有null
			Map<String,String> fieldMapNotNull = new HashMap<>();
			fieldMap.forEach((key,value)->{
				if(value!=null){
					fieldMapNotNull.put(key,value);
				}
			});
			return fieldMapNotNull;
		}
    	return fieldMap;
    }

	/**
	 * 获取集合的元素类型
	 * @param field 属性
	 * @return 元素类型, 不是集合的时候返回Null
	 */
	public static Class getCollectionElementClass(Field field) throws VciBaseException{
    	Class fieldClass = null;
    	if(field == null){
    		return null;
    	}
		if(field.getType().isAssignableFrom(List.class) || 
				field.getType().isAssignableFrom(Set.class) ||
				field.getType().isAssignableFrom(Vector.class)){
			Type fc = field.getGenericType();
			if(fc instanceof ParameterizedType){
				ParameterizedType pt = (ParameterizedType)fc;
				fieldClass= (Class)pt.getActualTypeArguments()[0];
			}
		}
		return fieldClass;
    }

	/**
	 * 获取字段在业务类型中的名称
	 * @param field 字段
	 * @param c 业务类型
	 * @return 业务类型中的名称
	 */
	public static String getCboAttrNameFromField(Field field,Class c){
    	String clientBoAttrName = field.getName().toLowerCase();
		boolean isFindColumn = false;
		if(field.isAnnotationPresent(Column.class)){
			String name = ((Column)field.getAnnotation(Column.class)).name();
			if(isNotNull(name)){
				clientBoAttrName = name.toLowerCase();
			}
			isFindColumn = true;
		}
		if(!isFindColumn){
			//找一下Get方法上..set方法上肯定是不支持的，
			Method getMethod = getGetmethod(c, field);
			if(getMethod!=null && !getMethod.isAnnotationPresent(Transient.class)){
				if(getMethod.isAnnotationPresent(Column.class)){
					String name = ((Column)getMethod.getAnnotation(Column.class)).name();
					if(isNotNull(name)){
						clientBoAttrName = name.toLowerCase();
					}
				}
			}else if(getMethod!=null && getMethod.isAnnotationPresent(Transient.class)){
				//说明不是持久化的属性，但是从平台中查询出来后可能得需要显示
				String referColumn = ((Transient)field.getAnnotation(Transient.class)).referColumn();
				if(isNotNull(referColumn)){
					clientBoAttrName = referColumn;
				}
			}
		}
		return VciQueryWrapperForDO.BASE_MODEL_COMPATIBILITY_MAP.getOrDefault(clientBoAttrName.toLowerCase(Locale.ROOT),clientBoAttrName);
    }
    
    /**
     * 获取对象中的所有属性，包括其继承的属性
     * @param c 对象
     * @return 所有的属性
     */
    public static List<Field> getAllFieldForObj(Class c){
    	List<Field> allField = new ArrayList<Field>();
    	for(Class<?> classz = c ; classz != Object.class ; classz = classz.getSuperclass() ){
    		Field[] thisClassField = classz.getDeclaredFields();
    		for(Field field : thisClassField){
    			if(!field.getName().equals("serialVersionUID")){
	    			if(!allField.contains(field)){
	    				allField.add(field);
	    			}
    			}
    		}
    	}
    	return allField;
    }
    
    /**
     * 获取对象的主键字段
     * @param c 对象所属的类
     * @return 主键的对象
     */
    public static Field getPkFieldForObj(Class c){
    	List<Field> allField = getAllFieldForObj(c);
    	if(allField!=null&&allField.size()>0){
    		for(Field field : allField){
    			if(field.isAnnotationPresent(Id.class)){
    				return  field;
    			}
    		}
    		//如果没找到，那就找oid
    		for(Field field : allField){
    			if(field.getName().toLowerCase().equalsIgnoreCase("oid")){
    				return  field;
    			}
    		}
    	}
    	return null;
    }

	/**
	 * 获取ts的字段
	 * @param c 对象所属的类
	 * @return 时间戳的对象
	 */
	public static Field getTsField(Class c){
    	List<Field> allField = getAllFieldForObj(c);
    	if(allField!=null&&allField.size()>0){
    		for(Field field : allField){
    			if(field.getName().equals("ts")){
    				return  field;
    			}
    		}
    	}
    	return null;
    }
    
    /**
     * 根据名称获取字段
     * @param field 字段的名称
     * @param obj 对象
     * @return 字段对象
     */
    public static Field getFieldForObject(String field,Object obj){
    	if(obj == null){
    		return null;
    	}
    	return getFieldForObject(field,obj.getClass());
    }

	/**
	 * 根据名称获取字段
	 * @param fieldName 字段的名称
	 * @param c 对象类型
	 * @return 字段对象
	 */
	public static Field getFieldForObject(String fieldName,Class c){
    	List<Field> allField = getAllFieldForObj(c);
    	if(allField!=null&&allField.size()>0){
    		for(Field field : allField){
    			if(field.getName().toLowerCase().equalsIgnoreCase(fieldName.toLowerCase())){
    				return  field;
    			}
    		}
    	}
    	return null;
    }

	/**
	 * 获取连接类型的主键信息
	 * @param s 字符串
	 * @return 连接类型
	 */
	public static LinkTypeInfoVO getLinkTypeAnnotation(String s){
    	if(s.indexOf("\"") > -1 
				&& s.indexOf(":") > -1 
				&& s.indexOf("}") > -1){
			return JSONObject.parseObject(s, LinkTypeInfoVO.class);
    	}
    	return null;
    }
    
    /**
     * 获取字段的setter
     * @param c 对象类
     * @param field 字段
     * @return 方法
     */
    public static Method getSetmethod(Class c,Field field){
    	return getSetmethod(c,field.getName());
    }
    
    /**
     * 获取字段的setter
     * @param c 对象类型
     * @param fieldName 字段名称
     * @return 方法
     */
    public static Method getSetmethod(Class c,String fieldName){
    	if(c!=null&&isNotNull(fieldName)){
    		try {
    			PropertyDescriptor pd = new PropertyDescriptor(fieldName, c);
				return pd.getWriteMethod();
			} catch (SecurityException e) {
			} catch (IntrospectionException e) {
			}
    	}
    	return null;
    }
    
    /**
     * 获取字段的getter
	 * @param c 对象类型
	 * @param fieldName 字段名称
	 * @return 方法
     */
    public static Method getGetmethod(Class c,String fieldName){
    	if(c!=null&&isNotNull(fieldName)){
    		try {
    			PropertyDescriptor pd = new PropertyDescriptor(fieldName, c);
				return pd.getReadMethod();
			} catch (SecurityException e) {
			} catch (IntrospectionException e) {
			}
    	}
    	return null;
    }
    
    /**
     * 获取字段的getter
	 * @param c 对象类型
	 * @param field 字段
	 * @return 方法
     */
    public static Method getGetmethod(Class c,Field field){
    	return getGetmethod(c,field.getName());
    }

	/**
	 * 获取对象转换字符串
	 * @param obj 对象
	 * @return 字符串
	 */
	public static String getStringValueFromObject(Object obj){
    	if(obj == null){
    		return "";
    	}else{
    		if(obj instanceof Integer || obj instanceof Float || obj instanceof Long || obj instanceof Double){
				return String.valueOf(obj);
			}else if(obj instanceof Date){
				return VciDateUtil.date2Str((Date)obj, VciDateUtil.DateTimeMillFormat);
			}else{
				return obj.toString();
			}
    	}
    }
    
    /**
     * 将平台返回的属性值赋值到对象上
     * @param fieldName 属性名
     * @param obj 对象
     * @param value 属性值
     */
    public static void setValueForFieldFromCbo(String fieldName,Object obj,String value){
		try{
			Field field = getFieldForObject(fieldName,obj);
			if(field!=null){
				 field.setAccessible(true);
	                Method setMethod = getSetmethod(field.getDeclaringClass(), fieldName);
	                if(setMethod ==null) {
	                		logger.error(obj.getClass().getName() + "中属性" + fieldName + "没有setter方法");
	                }
	                Class type = field.getType();
	                //从平台读取到的值不会为null，为空时为""；所以不处理空值
	                if(type.equals(int.class) || type.equals(Integer.class)){
	                    int valueObj = getInt(value);
	                    if(setMethod !=null) {
	                        setMethod.invoke(obj,valueObj);
	                    }else{
	                        field.set(obj,valueObj);
	                    }
	                }else if(type.equals(float.class) || type.equals(Float.class)){
	                    float valueObj = getFloat(value);
	                    if(setMethod !=null) {
	                        setMethod.invoke(obj, valueObj);
	                    }else{
	                        field.set(obj,valueObj);
	                    }
	                }else if(type.equals(long.class) || type.equals(Long.class)){
	                    long valueObj = getLong(value);
	                    if(setMethod !=null) {
	                        setMethod.invoke(obj, valueObj);
	                    }else{
	                        field.set(obj,valueObj);
	                    }
	                }else if(type.equals(Double.class) || type.equals(double.class)){
	                    double valueObj = getDouble(value);
	                    if(setMethod !=null) {
	                        setMethod.invoke(obj, valueObj);
	                    }else{
	                        field.set(obj,valueObj);
	                    }
	                    //从平台中查询出来就不用处理精度了，因为平台会自行处理
	                }else if(type.equals(Short.class) || type.equals(short.class)){
	                	short valueObject = getShort(value);
						if(setMethod !=null) {
							setMethod.invoke(obj, valueObject);
						}else{
							field.set(obj,valueObject);
						}
					}else if(type.equals(Date.class)){
	                    //平台实际存储的都是Timestamp,不论是日期，日期时间，都是。如果仅是时间，需要用字符串来存储。
	                    Date d = null;
	                    if(StringUtils.isNotBlank(value)){
	                    		try {
								if (value.indexOf("-") > -1 && value.indexOf(".") > -1 && value.indexOf(" ") > -1 && value.substring(value.lastIndexOf(".") + 1).length() == 9) {
									//2013-4-19.14.5. 45. 734000000  这种格式，这个在使用SQL语句直接查询出时间字段的时候就会显示成这样
									String ymd = value.substring(0, value.indexOf("."));
									value = value.substring(value.indexOf(".") + 1);
									if (value.indexOf(".") > -1) {
										String hms = value.substring(0, value.lastIndexOf("."));
										String nano = value.substring(value.lastIndexOf(".") + 1).trim();
										hms = hms.replace(".", ":").replace(" ", "");
										Date tempDate = VciDateUtil.str2Date(ymd + " " + hms, "yyyy-M-d h:m:s");
										if (tempDate != null) {
											Timestamp ts = Timestamp.valueOf(VciDateUtil.date2Str(tempDate, VciDateUtil.DateTimeFormat) + "." + nano);
											d = ts;
										}
									}
								} else if (value.matches("\\d+\\.?\\d*")) {
									//还有坑爹的是给的long型的字符串
									d = new Date();
									d.setTime(getLong(value));
								} else {
									if(field.isAnnotationPresent(VciFieldType.class)) {
										VciFieldType vciFieldType = field.getAnnotation(VciFieldType.class);
										if(VciFieldTypeEnum.VTDate.equals(vciFieldType.value())) {
											d = VciDateUtil.str2Date(value, VciDateUtil.DateFormat);
										}else if(VciFieldTypeEnum.VTDateTime.equals(vciFieldType.value())){
											d = VciDateUtil.str2Date(value, VciDateUtil.DateTimeFormat);
										}else {
											if(value.indexOf("-") > -1 &&value.length() == 10 ) {
												d = VciDateUtil.str2Date(value, VciDateUtil.DateFormat);
											}else {
												d = VciDateUtil.str2Date(value, VciDateUtil.DateTimeMillFormat);
											}
										}
									}else {
										if(value.indexOf("-") > -1 &&value.length() == 10 ) {
											d = VciDateUtil.str2Date(value, VciDateUtil.DateFormat);
										}else {
											d = VciDateUtil.str2Date(value, VciDateUtil.DateTimeMillFormat);
										}
									}
								}
							} catch (Exception e) {
								try {
									d = VciDateUtil.str2Date(value, VciDateUtil.DateTimeMillFormat);
								} catch (Exception e1) {

								}
							}
	                    }
	                    try {
	                        if(d != null ){
	                            if(setMethod !=null) {
	                                setMethod.invoke(obj, d);
	                            }else{
	                                field.set(obj,d);
	                            }
	                        }
	                    } catch (Exception e) {
	                    }
	                }else if(type.equals(String.class)){
	                    if(setMethod != null) {
	                        setMethod.invoke(obj, value);
	                    }else{
	                        field.set(obj,value);
	                    }
	                }else{
	                    logger.info("WebUtil.setValueForFieldForCbo:不支持的类型" + type.toString());
	                }
			}
		}catch (Exception e) {
			if(logger.isErrorEnabled()){
				logger.error("转换字符串出错",e);
			}
		}
    }

    /**
     * 从对象上获取值，并转换为平台可以存储的内容，需要提前判断字段是否属于平台的字段
     * @param field 属性对象
     * @param obj 要设置值的对象
     * @return 值
     */
    public static String getValueFromFieldForCbo(Field field ,Object obj){
    	Object value = getValueFromField(field.getName(),obj);
    	if(value!=null){
    		try {
    			Class type = field.getType();
				if(type.equals(int.class) || type.equals(Integer.class)){
					return String.valueOf(((Integer)value).intValue());
				}else if(type.equals(long.class) || type.equals(Long.class)){
					return String.valueOf(((Long)value).longValue());
				}else if(type.equals(float.class) || type.equals(Float.class)){
					return String.valueOf(((Float)value).floatValue());
				}else if(type.equals(short.class) || type.equals(Short.class)){
					return String.valueOf(((Short)value).shortValue());
				}else if(type.equals(Double.class) || type.equals(double.class)){
					return String.valueOf(((Double)value).doubleValue());
					//精度由平台底层处理
				}else if(type.equals(Date.class)){
					//平台实际存储的都是Timestamp,不论是日期，日期时间，都是。如果仅是时间，需要用字符串来存储。java保留到毫秒，而oracle是保留到微秒的
					String dataFormat = "";
					if(field.isAnnotationPresent(VciFieldType.class)){
						if(VciFieldTypeEnum.VTDate.name().equals((field.getAnnotation(VciFieldType.class).value()).name().toLowerCase())){
							dataFormat = VciDateUtil.DateFormat;
						}
					}
					if(StringUtils.isBlank(dataFormat)){
						dataFormat = VciDateUtil.DateTimeMillFormat;
					}
					return VciDateUtil.date2Str((Date)value, dataFormat);
				}else if(type.equals(Timestamp.class)){
					return VciDateUtil.date2Str((Timestamp)value, VciDateUtil.DateTimeMillFormat);
				}else if(type.equals(String.class)){
					return value.toString();
				}else{
					logger.info("WebUtil.setValueForFieldForCbo:不支持的类型" + type.toString());
				}
    		} catch (SecurityException e) {
    			if(logger.isErrorEnabled()){
    				logger.error("WebUtil.setValueForFieldForCbo",e);
				}
    		} catch (IllegalArgumentException e) {
				if(logger.isErrorEnabled()){
					logger.error("WebUtil.setValueForFieldForCbo",e);
				}
    		} 
    		return null;
    	}else{
    		return null;//返回给平台的话，不能有null对象
    	}
    }
    
    /**
     * 为对象赋值，不判断类型，属性是什么类型的，value就必须是什么类型
     * @param fieldName 属性名称
     * @param targetObject 对象
     * @param value 属性值
     */
    public static void setValueToField(String fieldName,Object targetObject,Object value){
		if(isNotNull(fieldName)){
			Method setMethod = getSetmethod(targetObject.getClass(), fieldName);
			try {
				if(setMethod != null){
					setMethod.invoke(targetObject, value);
				}else{
					Field field = getFieldForObject(fieldName, targetObject);
					if(field !=null){
						field.setAccessible(true);
						field.set(targetObject, value);
					}
				}
			} catch (IllegalArgumentException e) {
				if(logger.isErrorEnabled()){
					logger.error("WebUtil.setValueToField",e);
				}
			} catch (IllegalAccessException e) {
				if(logger.isErrorEnabled()){
					logger.error("WebUtil.setValueToField",e);
				}
			} catch (InvocationTargetException e) {
				if(logger.isErrorEnabled()){
					logger.error("WebUtil.setValueToField",e);
				}
			}
		}
	}
	
    /**
     * 从对象上获取属性的值
     * @param fieldName 属性名
     * @param sourceObject 对象
     * @return 值
     */
	public static Object getValueFromField(String fieldName,Object sourceObject){
		if(isNotNull(fieldName)){
			try {
				Method getMethod = getGetmethod(sourceObject.getClass(), fieldName);
				if(getMethod !=null){
					return getMethod.invoke(sourceObject);
				}else{
					//说明没有设置getter，比如BO和LO对象这种
					Field field = getFieldForObject(fieldName, sourceObject);
					if(field !=null){
						field.setAccessible(true);
						return field.get(sourceObject);
					}
				}
			} catch (SecurityException e) {
				if(logger.isErrorEnabled()){
					logger.error("WebUtil.getValueFromField",e);
				}
			} catch (IllegalAccessException e) {
				if(logger.isErrorEnabled()){
					logger.error("WebUtil.getValueFromField",e);
				}
			} catch (IllegalArgumentException e) {
				if(logger.isErrorEnabled()){
					logger.error("WebUtil.getValueFromField",e);
				}
			} catch (InvocationTargetException e) {
				if(logger.isErrorEnabled()){
					logger.error("WebUtil.getValueFromField",e);
				}
			}
		}
		return null;
	}

	/**
	 * 拷贝业务数据 到 对象的属性
	 * @param cbo 业务数据
	 * @param obj 对象
	 */
	public static void copyValueToObjectFromCbos(BusinessObject cbo,Object obj){
		if(cbo!=null){
			copyValueToObjectFromBos(cbo,obj);
		}
	}

	/**
	 * 拷贝业务数据 到 对象的属性
	 * @param cbo 业务数据
	 * @param obj 对象
	 * @param fieldAttrMap 属性映射
	 */
	public static void copyValueToObjectFromCbos(BusinessObject cbo,Object obj,Map<String,String> fieldAttrMap){
		if(cbo!=null){
			copyValueToObjectFromBos(cbo,obj,fieldAttrMap);
		}
	}

	/**
	 * 根据对象获取其业务类型的名称
	 * @param c 数据对象所属的类
	 * @return 业务类型
	 */
	public static String getBtmTypeByObject(Class c){
		String btmType = c.getSimpleName().toLowerCase();
		if(btmType.endsWith("DO")) {
			btmType = btmType.substring(0,btmType.length()-2);
		}
		if(c.isAnnotationPresent(VciBtmType.class)) {
			VciBtmType tableAnnotation = (VciBtmType) c.getAnnotation(VciBtmType.class);
			String tempBtmType = tableAnnotation.name();
			if (WebUtil.isNotNull(tempBtmType)) {
				btmType = tempBtmType.toLowerCase();
			}
		}
		return btmType;
	}

	/**
	 * 获取连接类型的名称
	 * @param c 连接类型所属的类
	 * @return 业务类型
	 */
	public static String getLinkTypeByObject(Class c){
		String btmType = c.getSimpleName().toLowerCase();
		if(btmType.endsWith("DO")) {
			btmType = btmType.substring(0,btmType.length()-2);
		}
		if(c.isAnnotationPresent(VciLinkType.class)){
			VciLinkType tableAnnotation = (VciLinkType) c.getAnnotation(VciLinkType.class);
			String tempBtmType = tableAnnotation.name();
			if (WebUtil.isNotNull(tempBtmType)) {
				btmType = tempBtmType.toLowerCase();
			}
		}
		return btmType;
	}


	/**
	 * 拷贝业务数据 到 对象的属性
	 * @param bo 业务数据
	 * @param obj 对象
	 */
	public static void copyValueToObjectFromBos(com.vci.corba.omd.data.BusinessObject bo ,Object obj){
		copyValueToObjectFromBos(bo,obj,null);
	}

	/**
	 * 拷贝业务数据 到 对象的属性
	 * @param bo 业务数据
	 * @param obj 对象
	 * @param fieldAttrMap 属性映射
	 */
    public static void copyValueToObjectFromBos(com.vci.corba.omd.data.BusinessObject bo , Object obj, Map<String,String> fieldAttrMap){
    	if(bo!=null && obj != null){
    		//先把所有的字段映射找到
    		if(fieldAttrMap == null){
    			fieldAttrMap = getFieldNameMap(obj.getClass());
    		}
			com.vci.corba.omd.data.AttributeValue[] newAList = bo.newAttrValList;
			com.vci.corba.omd.data.AttributeValue[] hisAList = bo.hisAttrValList;
			//要先把BO对象上的值拷贝过去
			List<Field> boFields = getAllFieldForObj(bo.getClass());
	
			if(boFields!=null){
				for(Field field :boFields){
					if(fieldAttrMap.containsKey(field.getName().toLowerCase())){
						//说明这个就是在BO对象上的
						Object value = getValueFromField(field.getName(), bo);
						if(value !=null){
							setValueForFieldFromCbo(fieldAttrMap.get(field.getName().toLowerCase()), obj, getStringValueFromObject(value));
						}
					}
				}
			}
			if(newAList!=null&&newAList.length>0){
				for(int i = 0 ; i < newAList.length;i++){
					com.vci.corba.omd.data.AttributeValue av = newAList[i];
					String attrName = av.attrName.toLowerCase();
					if(fieldAttrMap.containsKey(attrName)) {
						String fieldName = fieldAttrMap.get(attrName);
						setValueForFieldFromCbo(fieldName, obj, av.attrVal);
					}else{
						fieldAttrMap.forEach((cboField,fieldName)->{
							if(fieldName!=null && fieldName.equalsIgnoreCase(attrName) && cboField.contains(".")){
								//参照的时候
								setValueForFieldFromCbo(fieldName, obj, av.attrVal);
								return;
							}
						});
					}
				}
			}
			if(hisAList!=null&&hisAList.length>0){
				for(int i = 0 ; i < hisAList.length;i++){
					com.vci.corba.omd.data.AttributeValue av = hisAList[i];
					String attrName = av.attrName.toLowerCase();
					String fieldName = fieldAttrMap.get(attrName);
					if(fieldName!=null){
						setValueForFieldFromCbo(fieldName, obj, av.attrVal);
					}else{
						fieldAttrMap.forEach((cboField,field)->{
							if(field!=null && field.equalsIgnoreCase(attrName) && cboField.contains(".")){
								//参照的时候
								setValueForFieldFromCbo(field, obj, av.attrVal);
								return;
							}
						});
					}
				}
			}
		}
    }

	/**
	 * 拷贝业务类型到map
	 * @param cbo 业务数据
	 * @param map map
	 */
	public static void copyValueToMapFromCbos(BusinessObject cbo,Map<String,String> map){
    	if(cbo!=null){
    		copyValueToMapFromBos(cbo,map);
		}
    }

	/**
	 * 拷贝业务类型到map
	 * @param bo 业务数据
	 * @param map map
	 */
    public static void copyValueToMapFromBos(com.vci.corba.omd.data.BusinessObject bo, Map<String,String> map){
    	if(bo!=null ){
    		//先把所有的字段映射找到
			com.vci.corba.omd.data.AttributeValue[] newAList = bo.newAttrValList;
			com.vci.corba.omd.data.AttributeValue[] hisAList = bo.hisAttrValList;
			if(hisAList!=null&&hisAList.length>0){//
				for(int i = 0 ; i < hisAList.length;i++){
					com.vci.corba.omd.data.AttributeValue av = hisAList[i];
					String attrName = av.attrName.toLowerCase();
					map.put(attrName, av.attrVal);
				}
			}
			if(newAList!=null&&newAList.length>0){//NEW的优先级高些
				for(int i = 0 ; i < newAList.length;i++){
					com.vci.corba.omd.data.AttributeValue av = newAList[i];
					String attrName = av.attrName.toLowerCase();
					map.put(attrName, av.attrVal);
				}
			}
		}
    }

	/**
	 * 拷贝链接类型的值到map
	 * @param clo 链接类型
	 * @param map map
	 */
	public static void copyValueToMapFromClos(LinkObject clo,Map<String,String> map){
    	if(clo!=null){
    		copyValueToMapFromLos(clo,map);
    	}
    }

	/**
	 * 拷贝链接类型的值到map
	 * @param lo 链接类型
	 * @param map map
	 */
	public static void copyValueToMapFromLos(com.vci.corba.omd.data.LinkObject lo,Map<String,String> map){
    	if(lo!=null){
			WebLoServiceImpl.LO_BASE_FIELD_MAP.forEach((field,attr)->{
				map.put(attr.toLowerCase(),getValueFromFieldForCbo(getFieldForObject(field,lo),lo));
			});
    		//先把所有的字段映射找到
			com.vci.corba.omd.data.AttributeValue[] newAList = lo.newAttrValList;
			com.vci.corba.omd.data.AttributeValue[] hisAList = lo.hisAttrValList;
			if(hisAList!=null&&hisAList.length>0){
				for(int i = 0 ; i < hisAList.length;i++){
					com.vci.corba.omd.data.AttributeValue av = hisAList[i];
					String attrName = av.attrName.toLowerCase();
					map.put(attrName, av.attrVal);
				}
			}
			if(newAList!=null&&newAList.length>0){
				for(int i = 0 ; i < newAList.length;i++){
					com.vci.corba.omd.data.AttributeValue av = newAList[i];
					String attrName = av.attrName.toLowerCase();
					map.put(attrName, av.attrVal);
				}
			}
    	}
    }
	/**
	 * 拷贝链接类型的值到对象
	 * @param clo 链接类型
	 * @param obj 对象
	 * @param fieldAttrMap 属性map
	 */
    public static void copyValueToObjectFromClos(LinkObject clo,Object obj,Map<String,String> fieldAttrMap){
		if(clo!=null){
			copyValueToObjectFromLos(clo,obj,fieldAttrMap);
		}
	}

	/**
	 * 拷贝链接类型的值到对象
	 * @param lo 链接类型
	 * @param obj 对象
	 */
	public static void copyValueToObjectFromLos(LinkObject lo ,Object obj){
		copyValueToObjectFromLos(lo,obj,null);
	}

	/**
	 * 拷贝链接类型的值到对象
	 * @param lo 链接类型
	 * @param obj 对象
	 * @param fieldAttrMap 属性map
	 */
    public static void copyValueToObjectFromLos(LinkObject lo , Object obj, Map<String,String> fieldAttrMap){
    	if(lo!=null && obj != null){
    		//先把所有的字段映射找到
    		if(fieldAttrMap == null){
    			fieldAttrMap = getFieldNameMap(obj.getClass());
    		}
			AttributeValue[] newAList = lo.newAttrValList;
			AttributeValue[] hisAList = lo.hisAttrValList;
			if(newAList!=null&&newAList.length>0){
				for(int i = 0 ; i < newAList.length;i++){
					AttributeValue av = newAList[i];
					String attrName = av.attrName.toLowerCase();
					String fieldName = fieldAttrMap.get(attrName);
					setValueForFieldFromCbo(fieldName, obj, av.attrVal);//依然使用CBO的处理方式
				}
			}
			if(hisAList!=null&&hisAList.length>0){
				for(int i = 0 ; i < hisAList.length;i++){
					AttributeValue av = hisAList[i];
					String attrName = av.attrName.toLowerCase();
					String fieldName = fieldAttrMap.get(attrName);
					if(fieldName!=null){
						setValueForFieldFromCbo(fieldName, obj, av.attrVal);
					}
				}
			}
		}
    }
	/**
	 * 拷贝链接类型的值到map
	 * @param cbo 链接类型
	 * @param map 对象
	 */
    public static void copyValueToCboFromMap(BusinessObject cbo,Map<String,String> map) throws VciBaseException{
    	if(map!=null){
    		Iterator<String> it = map.keySet().iterator();
    		while(it.hasNext()){
    			String key = it.next();
    			String value = map.get(key);
    			if(value == null){
    				value = "";
    			}
				if(isDefaultField(key)){
					setValueToField(key, cbo, value);
				}
				ObjectTool.setBOAttributeValue(cbo,key.toLowerCase(), value);
			}
    	}
    }

	/**
	 * 拷贝链接类型的值到map
	 * @param clo 链接类型
	 * @param map 对象
	 */
    public static void copyValueToCloFromMap(LinkObject clo,Map<String,String> map) throws VciBaseException{
    	if(map!=null){
    		Iterator<String> it = map.keySet().iterator();
    		while(it.hasNext()){
    			String key = it.next();
    			String value = map.get(key);
    			if(value == null){
    				value = "";
    			}
				if(isDefaultField(key)){
					setValueToField(key, clo, value);
				}else {
					ObjectTool.setLOAttributeValue(clo,key.toLowerCase(), value);
				}
			}
    	}
    }

	/**
	 * 拷贝业务对象
	 * @param bo 业务对象
	 * @param obj 数据对象
	 * @throws VciBaseException 拷贝出错的时候会抛出异常
	 */
	public static void copyValueToBoFromObj(BusinessObject bo,Object obj) throws VciBaseException{
    	BusinessObject cbo = new BusinessObject();
    	cbo = bo;
    	copyValueToCboFromObj(cbo,obj);
    	bo = cbo;
    }

	/**
	 * 拷贝业务对象
	 * @param cbo 业务对象
	 * @param obj 数据对象
	 * @throws VciBaseException 拷贝出错的时候会抛出异常
	 */
	public static void copyValueToCboFromObj(BusinessObject cbo ,Object obj) throws VciBaseException{
    	Map<String,String> fieldMap = getFieldNameMap(obj.getClass());//先查找所有需要持久化到平台的属性，不需要持久化的就不用赋值了
    	Iterator<String> it = fieldMap.keySet().iterator();
    	while(it.hasNext()){
    		String attrName = it.next();
    		String fieldName = fieldMap.get(attrName);
    		if(isNormalAttr(attrName)){//不是参照的属性才能赋值
    			Field thisField = getFieldForObject(fieldName, obj);
    			String value = getValueFromFieldForCbo(thisField, obj);
    			if(value==null){
    				value = "";
    			}
				if(isDefaultField(fieldName)){
					setValueToField(fieldName, cbo, value);
				}
				ObjectTool.setBOAttributeValue(cbo,attrName.toLowerCase(), value);
			}
    	}
    }

	/**
	 * 是否默认的属性
	 * @param fieldNames 属性的名字
	 * @return true为默认
	 */
	public static boolean isDefaultField(String fieldNames){
		if(VciQueryWrapperForDO.BASIC_FIELD_MAP.containsKey(fieldNames) || VciQueryWrapperForDO.LIFECYCLE_MANAGE_FIELD_MAP.containsKey(fieldNames)
		|| VciQueryWrapperForDO.REVISION_MANAGE_FIELD_MAP.containsKey(fieldNames) ) {
    		return true;
    	}
    	return false;
    }

	/**
	 * 是否默认的属性
	 * @param fieldNames 属性的名字
	 * @return true为默认
	 */
    public static boolean isDefaultLinkField(String fieldNames){
		if(VciQueryWrapperForDO.LINK_TYPE_FIELD_MAP.containsKey(fieldNames) ) {
			return true;
		}
    	return false;
    }

	/**
	 * 是否为普通的属性
	 * @param attrName 属性的名字
	 * @return true
	 */
	public static boolean isNormalAttr(String attrName){
    	attrName = attrName.toLowerCase();
    	if(attrName.indexOf(".")<0 && attrName.indexOf("_")<0 && !attrName.equalsIgnoreCase("lcstatustext")){
    		return true;
    	}else{
    		return false;
    	}
    }


    /**
     * 将whereSql里的内容转化到查询map里
     * @param whereSql sql转换为map
     * @return map
     */
	public static Map<String,String>  whereSql2Map(
			String whereSql) {
		Map<String,String> map = new HashMap<String, String>();
		if(isNotNull(whereSql)){
			String[] selects = whereSql.split("and");
			if(selects!=null&&selects.length>0){
				for(String s : selects){
					s = s.trim();
					map.put(s.substring(0,s.indexOf(" ")).trim(), s.substring(s.indexOf(" ") +1).trim());
				}
			}
		}
		return map;
	}

	/**
	 * 转换异常
	 * @param e 异常对象
	 * @return base异常对象
	 */
//	public static VciBaseException getVciBaseException(PLException e){
////		return new VciBaseException(e.error_code, e.error_message);
//		return null;
//	}

	/**
	 * 转换异常
	 * @param e 异常对象
	 * @return base异常对象
	 */
	public static VciBaseException getVciBaseException(PLException e){
		return new VciBaseException(e.code, new java.lang.String[]{e.getMessage()});
//		return null;
	}

	/**
	 * 转换异常
	 * @param e 异常对象
	 * @return base异常对象
	 */
	public static VciBaseException getVciBaseException(VciException e){
		String[] errorMsgs = new String[0];
		if(e != null && e.getObjArray() !=null ){
			errorMsgs = new String[e.getObjArray().length];
			for(int i = 0 ; i < errorMsgs.length ; i ++){
				errorMsgs[i] = e.getObjArray()[i].toString();
			}
		}
		return new VciBaseException(e == null ?"com.vci.web.base.unknowerror":e.getCode(), errorMsgs);
	}

	/**
	 * 本机的ip
	 */
	private static String localIp = null;

	/**
	 * 获取本机地址，不是客户端电脑的ip,是当前服务所在的ip
	 * @return
	 */
	public static String getLocalIp(){
		if(localIp == null){
			try {
				InetAddress inetAddress = getLocalHostLANAddress();
				if (inetAddress == null) {
					localIp = "127.0.0.1";
				} else {
					localIp = inetAddress.getHostAddress();
				}
			}catch (Exception e){
				localIp = "127.0.0.1";
			}
		}
		return localIp;
	}

	/**
	 * 从网络接口上获取ip地址
	 * @return ip地址
	 */
	private static InetAddress getLocalHostLANAddress(){
		try {
			InetAddress candidateAddress = null;
			// 遍历所有的网络接口
			for (Enumeration ifaces = NetworkInterface.getNetworkInterfaces(); ifaces.hasMoreElements(); ) {
				NetworkInterface iface = (NetworkInterface) ifaces.nextElement();
				// 在所有的接口下再遍历IP
				for (Enumeration inetAddrs = iface.getInetAddresses(); inetAddrs.hasMoreElements(); ) {
					InetAddress inetAddr = (InetAddress) inetAddrs.nextElement();
					if (!inetAddr.isLoopbackAddress()) {// 排除loopback类型地址
						if (inetAddr.isSiteLocalAddress()) {
							// 如果是site-local地址，就是它了
							return inetAddr;
						} else if (candidateAddress == null) {
							// site-local类型的地址未被发现，先记录候选地址
							candidateAddress = inetAddr;
						}
					}
				}
			}
			if (candidateAddress != null) {
				return candidateAddress;
			}
			// 如果没有发现 non-loopback地址.只能用最次选的方案
			InetAddress jdkSuppliedAddress = InetAddress.getLocalHost();
			return jdkSuppliedAddress;
		} catch (Exception e) {
			if(logger.isErrorEnabled()){
				logger.error("获取本机ip",e);
			}
		}
		return null;
	}

	/**
     * oracle in 查询不能超过1000，转换一下集合
     * 由于SQL语句1000个可能很长，超过oracle10g，所以牺牲性能分配为500个数组
     * @param list 需要转换的列表内容
     * @return 分组后的list
     */
    public static <T> Collection<Collection<T>> switchCollectionForOracleIn(Collection<T> list) {
       return switchCollectionForOracleIn(list,500);
    }

    /**
     * 转换集合的大小，这个用在feign调用的时候，不要在sql查询的时候使用
     * @param collection 需要转换的列表内容
     * @param preSize 每个分组的大小
     * @return 分组后的list
     */
    public static <T> Collection<Collection<T>> switchCollectionForOracleIn(Collection<T> collection,int preSize) {
        Collection<Collection<T>> listHasList = new ArrayList<Collection<T>>();
        if(collection == null){
            return listHasList;
        }
        List<T> newList = new ArrayList<T>();
        for(Object obj : collection){
            //为了让list还可以添加内容，因为使用sublist后，list不能再Add了
            newList.add((T)obj);
        }
        int muti = 1;
        if(newList.size() >preSize){
            int balance = newList.size()%preSize;
            muti = (newList.size() - balance)/preSize + (balance == 0?0:1);
        }
        for(int i = 0 ; i < muti; i ++){
            int start = i*preSize;
            int end = start + preSize;
            if(i == muti-1 || end >newList.size() ){
                end = newList.size();
            }
            List subList = newList.subList(start,end);
            listHasList.add(subList);
        }
        return listHasList;
    }

	/**
	 * 构建主键的查询条件
	 * @param oid 主键
	 * @return 查询条件
	 */
	public static Map<String,String> getOidQuery(String oid) {
    	Map<String,String> conditionMap = new HashMap<>();
		if(oid.contains(",")){
			conditionMap.put("oid",QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(VciBaseUtil.str2List(oid).toArray(new String[0])) + ")");
		}else {
			conditionMap.put("oid", oid.trim());
		}
    	return conditionMap;
	}

	/**
	 * 将数据对象转换为树形
	 * @param doList 数据对象
	 * @param wrapperOptions 封装的信息
	 * @return 树列表
	 */
	public static <T,R> List<Tree> cboList2Trees(List<? extends BusinessObject> doList, TreeWrapperOptions wrapperOptions, Function<T,R> f){
		if(CollectionUtils.isEmpty(doList)){
			return new ArrayList<>();
		}
		List<Tree> allTree = new ArrayList<Tree>();
		List<Tree> children = new ArrayList<Tree>();
		for (int i = 0 ; i < doList.size();i++) {
			BusinessObject cbo =  doList.get(i);
			Tree tree =new Tree();
			List<String> oidFieldNames = VciBaseUtil.str2List(wrapperOptions.getOidFieldName());
			List<String> oidValues = new LinkedList<>();
			oidFieldNames.stream().forEach( s->{
				oidValues.add(ObjectTool.getBOAttributeValue(cbo, s));
			});
			tree.setOid(oidValues.stream().collect(Collectors.joining(wrapperOptions.getOidValueSep())));
			if(f !=null){
				tree.setText((String)f.apply((T) cbo));
			}else{
				List<String> textFieldNames = VciBaseUtil.str2List(wrapperOptions.getTextFieldName());
				List<String> textValues = new LinkedList<>();
				textFieldNames.stream().forEach( s->{
					textValues.add(ObjectTool.getBOAttributeValue(cbo, s));
				});
				tree.setText(textValues.stream().collect(Collectors.joining(wrapperOptions.getTextValueSep())));
			}
			if(StringUtils.isNotBlank(wrapperOptions.getParentFieldName())){
				tree.setParentId(ObjectTool.getBOAttributeValue(cbo, wrapperOptions.getParentFieldName()));
			}
			if(wrapperOptions.isAllAttributes()) {
				try {
					Map<String,String> map = new HashMap<>();
					copyValueToMapFromCbos(cbo,map);
					tree.setAttributes(map);
				} catch (Exception e) {
					//这里不做处理
					if (logger.isErrorEnabled()) {
						logger.error("把对象转换为map时出现了错误，但是不影响树的展示，对业务可能有影响");
					}
				}
			}
			if(wrapperOptions.isMultipleSelect() || wrapperOptions.isShowCheckBox()){
				tree.setShowCheckbox(true);
			}
			if(wrapperOptions.getParentOid() == null){
				wrapperOptions.setParentOid("");
			}
			tree.setIndex(String.valueOf(i));
			if(StringUtils.isBlank(tree.getParentId())
					|| (StringUtils.isNotBlank(wrapperOptions.getParentOid()) && wrapperOptions.getParentOid().equalsIgnoreCase(tree.getParentId()))){
				allTree.add(tree);
			}else {
				children.add(tree);
			}
		}

		if(allTree.size()<=0){
			//说明全是子，我们需要从子里获取
			if(!CollectionUtils.isEmpty(children)){
				Map<String, String> oidParentMap = children.stream().collect(Collectors.toMap(s -> s.getOid(), t -> t.getParentId() == null?"":t.getParentId(), (o1, o2) -> o1));
				List<String> rootOids = oidParentMap.entrySet().stream().filter(s -> !oidParentMap.containsKey(s.getValue())).map(s -> s.getKey()).collect(Collectors.toList());
				List<Tree> newChildren = new ArrayList<>();
				allTree = children.stream().filter(s->rootOids.contains(s.getOid())).collect(Collectors.toList());
				newChildren = children.stream().filter(s->!rootOids.contains(s.getOid())).collect(Collectors.toList());
				children = newChildren;
			}
		}
		new Tree().findChild(allTree,children);
		return allTree;
	}

	public static BusinessObject arryAndSqlToBusinessObject(String sqlStr,String[] valueArry) {
		BusinessObject BusinessObject = new BusinessObject();
		try {
			PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse(sqlStr);
			AttributeValue[] attributeValues = new AttributeValue[valueArry.length];
			for (int i = 0; i < select.getSelectItems().size(); i++) {
				SelectItem selectItem = select.getSelectItem(i);
				AttributeValue attributeValue = new AttributeValue();
				attributeValue.attrName = selectItem.getAlias().getName();
				attributeValue.attrVal	= valueArry[i];
				attributeValues[i] = attributeValue;
			}
			BusinessObject.newAttrValList= attributeValues;
		}catch (Exception e){
			logger.error("数据解析错误",e);
			return null;
		}
		return BusinessObject;
	}
}