package com.fuzamei.util;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;

import org.springframework.util.StringUtils;

import com.alibaba.fastjson.JSON;

/**
 * 
 * @author ylx
 * @describe: 针对hibernate-validator的实体类进行数据校验的工具类
 * @describe: 针对该项目中其它各类数据校验的工具类
 * @Date: 2017-12-26
 */
public class ValidationUtil {

	private ValidationUtil() {
		throw new AssertionError("不能实例化 ValidationUtil");
	}

	/**
	 * @Title: validate
	 * @Description: TODO(仅针对校验一个实体类的所有校验失败信息)
	 * @return List<String> 返回的是数据校验的所有校验失败信息，封装在一个list中作为返回值
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static <T> List<String> validate(T bo) {
		ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
		Validator validator = factory.getValidator();
		Set<ConstraintViolation<T>> validateSet = validator.validate(bo);
		List<String> list = new ArrayList<String>();
		for (ConstraintViolation<T> validate : validateSet) {
			list.add(validate.getMessage());
		}
		return list; // 包含所有校验出错的信息

		/*
		 * 使用hibernate validator出现上面的错误， 需要 注意
		 * 
		 * @NotNull 和 @NotEmpty 和@NotBlank 区别
		 * 
		 * @NotEmpty 用在集合类上面
		 * 
		 * @NotBlank 用在String上面
		 * 
		 * @NotNull 用在基本类型上
		 */
	}

	/**
	 * @Title: checkRangeOfInt
	 * @Description: 针对传入的参数进行校验--->Integer类型
	 * @Detail: 参数类型虽然是Object,但是要求数据类型是String或者是Integer类型的数据,而且String类型还必须是能被解析成整数的,否则会抛出异常.
	 * 			而且还要限定数值的范围,超出范围的也会报异常.
	 * 			如果一切都解析正常,返回一个true的布尔类型
	 * @Usage: 适用于数据判断的校验
	 * @return boolean
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static boolean checkRangeOfInt(final Object obj, int min, int max) {
		String number = null;
		try {
			if (obj == null) {
				throw new NullPointerException();
			}
			number = String.class.cast(obj);
			try {
				Integer num = Integer.parseInt(number);
				if (num < min) {
					throw new OutOfRangeException("最小值应该大于等于"+min);
				}
				if(num > max){
					throw new OutOfRangeException("最大值应该小于等于"+max);
				}
			} catch (NumberFormatException e) {
				throw new NumberFormatException();
			}
		} catch (Exception e) {
			if (e instanceof NullPointerException) {
				throw new NullPointerException("对象为null");
			}
			if (e instanceof NumberFormatException) {
				throw new RuntimeException("数据类型解析异常");
			}
			if (e instanceof OutOfRangeException) {
				throw new OutOfRangeException(e.getMessage());
			}
			Integer num = null;
			try {
				num = Integer.class.cast(obj);
			} catch (Exception e1) {
				throw new RuntimeException("数字解析异常");
			}
			if (num < min) {
				throw new RuntimeException("最小值应该大于等于"+min);
			}
			if(num > max){
				throw new RuntimeException("最大值应该小于等于"+max);
			}
		}
		return true;
	}

	/**
	 * @Title: checkMinOfInt
	 * @Description: 针对传入的参数进行校验--->Integer类型
	 * @Detail: 参数类型虽然是Object,但是要求数据类型是String或者是Integer类型的数据,而且String类型还必须是能被解析成整数的,否则会抛出异常.
	 * 			而且还要限定数值的最小值,小于最小值的也会报异常.
	 * 			如果一切都解析正常,返回一个true的布尔类型
	 * @Usage: 适用于数据判断的校验
	 * @return boolean
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static boolean checkMinOfInt(final Object obj, int min) {
		return checkRangeOfInt(obj, min, Integer.MAX_VALUE);
	}

	/**
	 * @Title: checkMaxOfInt
	 * @Description: 针对传入的参数进行校验--->Integer类型
	 * @Detail: 参数类型虽然是Object,但是要求数据类型是String或者是Integer类型的数据,而且String类型还必须是能被解析成整数的,否则会抛出异常.
	 * 			而且还要限定数值的最大值,大于最大值的也会报异常.
	 * 			如果一切都解析正常,返回一个true的布尔类型
	 * @Usage: 适用于数据判断的校验
	 * @return boolean
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static boolean checkMaxOfInt(final Object obj, int max) {
		return checkRangeOfInt(obj, Integer.MIN_VALUE, max);
	}
	
	/**
	 * @Title: checkOfInt
	 * @Description: 针对传入的参数进行校验--->Integer类型
	 * @Detail: 参数类型虽然是Object,但是要求数据类型是String或者是Integer类型的数据,而且String类型还必须是能被解析成整数的,否则会抛出异常.
	 * 			针对整个Integer范围内的数据校验(也就是能被解析成Integer的String还是Integer就能校验成功返回true)
	 * 			如果一切都解析正常,返回一个true的布尔类型
	 * @Usage: 适用于数据判断的校验
	 * @return boolean
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static boolean checkOfInt(final Object obj) {
		return checkRangeOfInt(obj, Integer.MIN_VALUE, Integer.MAX_VALUE);
	}
	

	/**
	 * @Title: checkRangeOfLong
	 * @Description: 针对传入的参数进行校验--->Long类型
	 * @Detail: 参数类型虽然是Object,但是要求数据类型是String或者是Long类型的数据,而且String类型还必须是能被解析成整数的,否则会抛出异常.
	 * 			而且还要限定数值的范围,超出范围的也会报异常.
	 * 			如果一切都解析正常,返回一个true的布尔类型
	 * @Usage: 适用于数据判断的校验
	 * @return boolean
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static boolean checkRangeOfLong(final Object obj, long min, long max) {
		String number = null;
		try {
			if (obj == null) {
				throw new NullPointerException();
			}
			number = String.class.cast(obj);
			try {
				Long num = Long.parseLong(number);
				if (num < min) {
					throw new OutOfRangeException("最小值应该大于等于"+min);
				}
				if(num > max){
					throw new OutOfRangeException("最大值应该小于等于"+max);
				}
			} catch (NumberFormatException e) {
				throw new NumberFormatException();
			}
		} catch (Exception e) {
			if (e instanceof NullPointerException) {
				throw new NullPointerException("对象为null");
			}
			if (e instanceof NumberFormatException) {
				throw new RuntimeException("数据类型解析异常");
			}
			if (e instanceof OutOfRangeException) {
				throw new OutOfRangeException(e.getMessage());
			}
			Long num = null;
			try {
				num=Long.parseLong(String.valueOf(obj));
			} catch (Exception e1) {
				throw new RuntimeException("数字解析异常");
			}
			if (num < min) {
				throw new RuntimeException("最小值应该大于等于"+min);
			}
			if(num > max){
				throw new RuntimeException("最大值应该小于等于"+max);
			}
		}
		return true;
	}
	
	/**
	 * @Title: checkMinOfLong
	 * @Description: 针对传入的参数进行校验--->Long类型
	 * @Detail: 参数类型虽然是Object,但是要求数据类型是String或者是Long类型的数据,而且String类型还必须是能被解析成整数的,否则会抛出异常.
	 * 			而且还要限定数值的最小值,小于最小值的也会报异常.
	 * 			如果一切都解析正常,返回一个true的布尔类型
	 * @Usage: 适用于数据判断的校验
	 * @return boolean
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static boolean checkMinOfLong(final Object obj, long min) {
		return checkRangeOfLong(obj, min, Long.MAX_VALUE);
	}

	/**
	 * @Title: checkMaxOfLong
	 * @Description: 针对传入的参数进行校验--->Long类型
	 * @Detail: 参数类型虽然是Object,但是要求数据类型是String或者是Long类型的数据,而且String类型还必须是能被解析成整数的,否则会抛出异常.
	 * 			而且还要限定数值的最大值,大于最大值的也会报异常.
	 * 			如果一切都解析正常,返回一个true的布尔类型
	 * @Usage: 适用于数据判断的校验
	 * @return boolean
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static boolean checkMaxOfLong(final Object obj, long max) {
		return checkRangeOfLong(obj, Long.MIN_VALUE, max);
	}
	
	/**
	 * @Title: checkOfLong
	 * @Description: 针对传入的参数进行校验--->Long类型
	 * @Detail: 参数类型虽然是Object,但是要求数据类型是String或者是Long类型的数据,而且String类型还必须是能被解析成整数的,否则会抛出异常.
	 * 			这个针对Long范围内类型数据的校验
	 * 			如果一切都解析正常,返回一个true的布尔类型
	 * @Usage: 适用于数据判断的校验
	 * @return boolean
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static boolean checkOfLong(final Object obj) {
		return checkRangeOfLong(obj, Long.MIN_VALUE, Long.MAX_VALUE);
	}

	/**
	 * @Title: checkRangeAndAssignInt
	 * @Description: 针对传入的参数进行校验--->Integer类型
	 * @Detail: 参数类型虽然是Object,但是要求数据类型是String或者是Integer类型的数据,而且String类型还必须是能被解析成整数的,否则会抛出异常.
	 * 			而且还要限定数值的范围,超出范围的也会报异常.
	 * 			如果一切都解析正常,说明解析没有问题,结果将解析后的数值以int类型返回
	 * @Usage: 适用于数据判断的校验和赋值同时进行
	 * @return int
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static int checkRangeAndAssignInt(final Object obj, int min, int max) {
		String number = null;
		try {
			if (obj == null) {
				throw new NullPointerException();
			}
			number = String.class.cast(obj);
			try {
				Integer num = Integer.parseInt(number);
				if (num < min) {
					throw new OutOfRangeException("最小值应该大于等于"+min);
				}
				if(num > max){
					throw new OutOfRangeException("最大值应该小于等于"+max);
				}
				return num;
			} catch (NumberFormatException e) {
				throw new NumberFormatException();
			}
		} catch (Exception e) {
			if (e instanceof NullPointerException) {
				throw new NullPointerException("对象为null");
			}
			if (e instanceof NumberFormatException) {
				throw new RuntimeException("数据类型解析异常");
			}
			if (e instanceof OutOfRangeException) {
				throw new OutOfRangeException(e.getMessage());
			}
			Integer num = null;
			try {
				num = Integer.class.cast(obj);
			} catch (Exception e1) {
				throw new RuntimeException("数字解析异常");
			}
			if (num < min) {
				throw new RuntimeException("最小值应该大于等于"+min);
			}
			if(num > max){
				throw new RuntimeException("最大值应该小于等于"+max);
			}
			return num;
		}
	}

	/**
	 * @Title: checkMinAndAssignInt
	 * @Description: 针对传入的参数进行校验--->Integer类型
	 * @Detail: 参数类型虽然是Object,但是要求数据类型是String或者是Integer类型的数据,而且String类型还必须是能被解析成整数的,否则会抛出异常.
	 * 			而且还要限定数值的最小值,小于最小值的也会报异常.
	 * 			如果一切都解析正常,说明解析没有问题,结果将解析后的数值以int类型返回
	 * @Usage: 适用于数据判断的校验和赋值同时进行
	 * @return int
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static int checkMinAndAssignInt(final Object obj, int min) {
		return checkRangeAndAssignInt(obj,min,Integer.MAX_VALUE);
	}
	
	/**
	 * @Title: checkMaxAndAssignInt
	 * @Description: 针对传入的参数进行校验--->Integer类型
	 * @Detail: 参数类型虽然是Object,但是要求数据类型是String或者是Integer类型的数据,而且String类型还必须是能被解析成整数的,否则会抛出异常.
	 * 			而且还要限定数值的最大值,大于最大值的也会报异常.
	 * 			如果一切都解析正常,说明解析没有问题,结果将解析后的数值以int类型返回
	 * @Usage: 适用于数据判断的校验和赋值同时进行
	 * @return int
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static int checkMaxAndAssignInt(final Object obj, int max) {
		return checkRangeAndAssignInt(obj,Integer.MIN_VALUE,max);
	}
	
	/**
	 * @Title: checkAndAssignInt
	 * @Description: 针对传入的参数进行校验--->Integer类型
	 * @Detail: 参数类型虽然是Object,但是要求数据类型是String或者是Integer类型的数据,而且String类型还必须是能被解析成整数的,否则会抛出异常.
	 * 			这个针对Integer范围内类型数据的校验和赋值
	 * 			如果一切都解析正常,说明解析没有问题,结果将解析后的数值以int类型返回
	 * @Usage: 适用于数据判断的校验和赋值同时进行
	 * @return int
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static int checkAndAssignInt(final Object obj) {
		return checkRangeAndAssignInt(obj,Integer.MIN_VALUE,Integer.MAX_VALUE);
	}
	
	/**
	 * @Title: checkRangeAndAssignDouble
	 * @Description: 针对传入的参数进行校验--->Double类型
	 * @Detail: 参数类型虽然是Object,但是要求数据类型是String或者是Double类型的数据,而且String类型还必须是能被解析成double的,否则会抛出异常.
	 * 			而且还要限定数值的范围,超出范围的也会报异常.
	 * 			如果一切都解析正常,说明解析没有问题,结果将解析后的数值以double类型返回
	 * @Usage: 适用于数据判断的校验和赋值同时进行
	 * @return double
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static double checkRangeAndAssignDouble(final Object obj, double min, double max) {
		String number = null;
		try {
			if (obj == null) {
				throw new NullPointerException();
			}
			number = String.class.cast(obj);
			try {
				Double num = Double.parseDouble(number);
				if (num < min) {
					throw new OutOfRangeException("最小值应该大于等于"+min);
				}
				if(num > max){
					throw new OutOfRangeException("最大值应该小于等于"+max);
				}
				return num;
			} catch (NumberFormatException e) {
				throw new NumberFormatException();
			}
		} catch (Exception e) {
			if (e instanceof NullPointerException) {
				throw new NullPointerException("对象为null");
			}
			if (e instanceof NumberFormatException) {
				throw new RuntimeException("数据类型解析异常");
			}
			if (e instanceof OutOfRangeException) {
				throw new OutOfRangeException(e.getMessage());
			}
			Double num = null;
			try {
				num = Double.parseDouble(String.valueOf(obj));
			} catch (Exception e1) {
				throw new RuntimeException("数字解析异常");
			}
			if (num < min) {
				throw new RuntimeException("最小值应该大于等于"+min);
			}
			if(num > max){
				throw new RuntimeException("最大值应该小于等于"+max);
			}
			return num;
		}
	}
	
	/**
	 * @Title: checkRangeAndAssignDouble
	 * @Description: 针对传入的参数进行校验--->Double类型
	 * @Detail: 参数类型虽然是Object,但是要求数据类型是String或者是Double类型的数据,而且String类型还必须是能被解析成double的,否则会抛出异常.
	 * 			而且还要限定数值的最大值,超出最大值的也会报异常.
	 * 			如果一切都解析正常,说明解析没有问题,结果将解析后的数值以double类型返回
	 * @Usage: 适用于数据判断的校验和赋值同时进行
	 * @return double
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static double checkMinAndAssignDouble(final Object obj, double min) {
		return checkRangeAndAssignDouble(obj,min,Double.MAX_VALUE);
	}
	/**
	 * @Title: checkRangeAndAssignDouble
	 * @Description: 针对传入的参数进行校验--->Double类型
	 * @Detail: 参数类型虽然是Object,但是要求数据类型是String或者是Double类型的数据,而且String类型还必须是能被解析成double的,否则会抛出异常.
	 * 			而且还要限定数值的最大值,超出最大值的也会报异常.
	 * 			如果一切都解析正常,说明解析没有问题,结果将解析后的数值以double类型返回
	 * @Usage: 适用于数据判断的校验和赋值同时进行
	 * @return double
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static double checkMaxAndAssignDouble(final Object obj,double max) {
		return checkRangeAndAssignDouble(obj,Double.MIN_VALUE,max);
	}
	/**
	 * @Title: checkRangeAndAssignDouble
	 * @Description: 针对传入的参数进行校验--->Double类型
	 * @Detail: 参数类型虽然是Object,但是要求数据类型是String或者是Double类型的数据,而且String类型还必须是能被解析成double的,否则会抛出异常.
	 * 			而且还要限定数值的最大值,超出最大值的也会报异常.
	 * 			如果一切都解析正常,说明解析没有问题,结果将解析后的数值以double类型返回
	 * @Usage: 适用于数据判断的校验和赋值同时进行
	 * @return double
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static double checkAndAssignDouble(final Object obj) {
		return checkRangeAndAssignDouble(obj,Double.MIN_VALUE,Double.MAX_VALUE);
	}
	
	/**
	 * @Title: range
	 * @Description: 针对传入的参数进行校验--->Long类型
	 * @Detail: 参数类型虽然是Object,但是要求数据类型是String或者是Long类型的数据,而且String类型还必须是能被解析成整数的,否则会抛出异常.
	 * 			而且还要限定数值的范围,超出范围的也会报异常.
	 * 			如果一切都解析正常,说明解析没有问题,结果将解析后的数值以long类型返回
	 * @Usage: 适用于数据判断的校验和赋值同时进行
	 * @return long
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static long checkRangeAndAssignLong(final Object obj, long min, long max) {
		String number = null;
		try {
			if (obj == null) {
				throw new NullPointerException();
			}
			number = String.class.cast(obj);
			try {
				Long num = Long.parseLong(number);
				if (num < min) {
					throw new OutOfRangeException("最小值应该大于等于"+min);
				}
				if(num > max){
					throw new OutOfRangeException("最大值应该小于等于"+max);
				}
				return num;
			} catch (NumberFormatException e) {
				throw new NumberFormatException();
			}
		} catch (Exception e) {
			if (e instanceof NullPointerException) {
				throw new NullPointerException("对象为null");
			}
			if (e instanceof NumberFormatException) {
				throw new RuntimeException("数据类型解析异常");
			}
			if (e instanceof OutOfRangeException) {
				throw new OutOfRangeException(e.getMessage());
			}
			Long num = null;
			try {
				num=Long.parseLong(String.valueOf(obj));
			} catch (Exception e1) {
				throw new RuntimeException("数字解析异常");
			}
			if (num < min) {
				throw new RuntimeException("最小值应该大于等于"+min);
			}
			if(num > max){
				throw new RuntimeException("最大值应该小于等于"+max);
			}
			return num;
		}
	}
	
	/**
	 * @Title: range
	 * @Description: 针对传入的参数进行校验--->Long类型
	 * @Detail: 参数类型虽然是Object,但是要求数据类型是String或者是Long类型的数据,而且String类型还必须是能被解析成整数的,否则会抛出异常.
	 * 			而且还要限定数值的最小值,小于最小值的也会报异常.
	 * 			如果一切都解析正常,说明解析没有问题,结果将解析后的数值以long类型返回
	 * @Usage: 适用于数据判断的校验和赋值同时进行
	 * @return long
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static long checkMinAndAssignLong(final Object obj, long min) {
		return checkRangeAndAssignLong(obj,min,Long.MAX_VALUE);
	}
	
	/**
	 * @Title: range
	 * @Description: 针对传入的参数进行校验--->Long类型
	 * @Detail: 参数类型虽然是Object,但是要求数据类型是String或者是Long类型的数据,而且String类型还必须是能被解析成整数的,否则会抛出异常.
	 * 			而且还要限定数值的最大值,大于最大值的也会报异常.
	 * 			如果一切都解析正常,说明解析没有问题,结果将解析后的数值以long类型返回
	 * @Usage: 适用于数据判断的校验和赋值同时进行
	 * @return long
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static long checkMaxAndAssignLong(final Object obj, long max) {
		return checkRangeAndAssignLong(obj,Long.MIN_VALUE,max);
	}
	
	/**
	 * @Title: range
	 * @Description: 针对传入的参数进行校验--->Long类型
	 * @Detail: 参数类型虽然是Object,但是要求数据类型是String或者是Long类型的数据,而且String类型还必须是能被解析成整数的,否则会抛出异常.
	 * 			这个针对Long范围内类型数据的校验和赋值
	 * 			如果一切都解析正常,说明解析没有问题,结果将解析后的数值以long类型返回
	 * @Usage: 适用于数据判断的校验和赋值同时进行
	 * @return long
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static long checkAndAssignLong(final Object obj) {
		return checkRangeAndAssignLong(obj,Long.MIN_VALUE,Long.MAX_VALUE);
	}
	/**
	 * @Title: range
	 * @Target: 针对空(null)
	 * @Description: TODO(针对传入的参数进行非空(null)校验并返回string数据类型--->只针对String类型，校验和赋值同时进行，同时返回真实的String值)
	 * @Attention: 保证传入的数据是字符串，且不能为空(null)，否则报异常，正常就返回一个正常的String类型的参数
	 * @return String
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static String checkNullAndAssignString(final Object obj){
		try {
			if (obj == null) {
				throw new NullPointerException();
			}
			String str=String.class.cast(obj);
			return str;
		} catch (Exception e) {
			if(e instanceof NullPointerException){
				throw new NullPointerException("对象为null");
			}
			if(e instanceof ClassCastException){
				throw new ClassCastException("强转String类型异常");
			}
			throw new RuntimeException();
		}
	}
	
	/**
	 * @Title: checkEmptyAndAssignString
	 * @Target: 针对空(null)和空字符串("")
	 * @Description: TODO(针对传入的参数进行非空(null)和空字符串("")校验并返回string数据类型--->只针对String类型，校验和赋值同时进行，同时返回真实的String值)
	 * @Attention: 保证传入的数据是字符串，且不能为空(null)和空字符串("")，否则报异常，正常就返回一个正常的String类型的参数
	 * @return String
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static String checkEmptyAndAssignString(final Object obj){
		try {
			if (obj == null) {
				throw new NullPointerException();
			}
			String str=String.class.cast(obj);
			if("".equals(str)){
				throw new RuntimeException("字符串不能为空");
			}
			return str;
		} catch (Exception e) {
			if(e instanceof NullPointerException){
				throw new NullPointerException("对象为null");
			}
			if(e instanceof ClassCastException){
				throw new ClassCastException("强转String类型异常");
			}
			throw new RuntimeException(e.getMessage());
		}
	}
	
	/**
	 * @Title: checkBlankAndAssignString
	 * @target: 针对空(null)和空字符串("")和空内容的字符串("   ")
	 * @Description: TODO(针对传入的参数进行非空(null)和空字符串("")和空内容的字符串("   ")校验并返回string数据类型--->只针对String类型，校验和赋值同时进行，同时返回真实的String值)
	 * @Attention: 保证传入的数据是字符串，且不能为空(null)和空字符串("")和空内容的字符串("   ")，否则报异常，正常就返回一个正常的String类型的参数
	 * @return String
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static String checkBlankAndAssignString(final Object obj){
		try {
			if (obj == null) {
				throw new NullPointerException();
			}
			String str=String.class.cast(obj);
			if("".equals(str.trim())){
				throw new RuntimeException("字符串不能无任何内容");
			}
			return str;
		} catch (Exception e) {
			if(e instanceof NullPointerException){
				throw new NullPointerException("对象为null");
			}
			if(e instanceof ClassCastException){
				throw new ClassCastException("强转String类型异常");
			}
			throw new RuntimeException(e.getMessage());
		}
	}
	
	
	/**
	 * @Title: checkBlankStringAndAssignNullIfIsBlank
	 * @Description: TODO(针对传入的Object类型参数进行非空(null)和空字符串("")和空内容的字符串("   ")校验并返回string数据类型,只要是null,""或"  "全部返回null,不会抛出异常，除非无法强转为String,其它情况正常转String)
	 * @Attention: 默认返回null
	 * @return String
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static String checkBlankStringAndAssignNullIfIsBlank(final Object obj){
		try {
			if (obj == null) {
				return null;
			}
			String str=String.class.cast(obj);
			if("".equals(str.trim())){
				return null;
			}
			return str;
		} catch (Exception e) {
			throw new RuntimeException("String类型转换异常");
		}
	}
	
	/**
	 * @Title: checkBlankStringAndAssignEmptyIfIsBlank
	 * @Description: TODO(针对传入的参数进行非空(null)和空字符串("")和空内容的字符串("   ")校验并返回string数据类型,只要是null,""或"  "全部返回""空串,不会抛出异常，除非无法强转为String,其它情况正常转String)
	 * @Attention: 默认返回""
	 * @return String
	 * @author ylx
	 * @date 2017年12月26日 下午3:48:40
	 */
	public static String checkBlankStringAndAssignEmptyIfIsBlank(final Object obj){
		try {
			if (obj == null) {
				return "";
			}
			String str=String.class.cast(obj);
			if("".equals(str.trim())){
				return "";
			}
			return str;
		} catch (Exception e) {
			throw new RuntimeException("String类型转换异常");
		}
	}
	
	/**
	 * 
	* @Title: checkAndAssignDefaultInt
	* @Description: TODO(如果校验的Object不能转换Integer则抛出异常，如果是null，空字符串或者是长空串，统一返回用户指定的默认值defaultInt)
	* @Attention: obj为null，空字符串""或者是长空串"   "都不会抛异常，而是直接返回默认值
	* @return int    返回类型
	* @author ylx
	* @date 2017年12月27日 下午1:51:43
	 */
	public static int checkAndAssignDefaultInt(final Object obj,int defaultInt){
		String number = null;
		try {
			if (obj == null) {
				return defaultInt;
			}
			number = String.class.cast(obj);
			if("".equals(number.trim())){
				return defaultInt;
			}
			try {
				return Integer.parseInt(number.trim());
			} catch (NumberFormatException e) {
				throw new NumberFormatException();
			}
		} catch (Exception e) {
			if (e instanceof NumberFormatException) {
				throw new RuntimeException("数据类型解析异常");
			}
			Integer num = null;
			try {
				num = Integer.class.cast(obj);
			} catch (Exception e1) {
				throw new RuntimeException("Integer强转异常");
			}
			return num;
		}
	}
	
	
	/**
	 * 
	* @Title: checkAndAssignDefaultLong
	* @Description: TODO(如果校验的Object不能转换Long则抛出异常，如果是null，空字符串或者是长空串，统一返回用户指定的默认值defaultLong)
	* @Attention: obj为null，空字符串""或者是长空串"   "都不会抛异常，而是直接返回默认值
	* @Solved: 这里要特别注意下，Long.class.cast(obj)当obj是Integer时会出现异常，包装类不能像基本类型一样强转，所以这里改成num=Long.parseLong(""+obj);
	* @return long    返回类型
	* @author ylx
	* @date 2017年12月27日 下午1:51:43
	 */
	public static long checkAndAssignDefaultLong(final Object obj,long defaultLong){
		String number = null;
		try {
			if (obj == null) {
				return defaultLong;
			}
			number = String.class.cast(obj);
			if("".equals(number.trim())){
				return defaultLong;
			}
			try {
				return Long.parseLong(number.trim());
			} catch (NumberFormatException e) {
				throw new NumberFormatException();
			}
		} catch (Exception e) {
			if (e instanceof NumberFormatException) {
				throw new RuntimeException("数据类型解析异常");
			}
			Long num = null;
			try {
				num=Long.parseLong(String.valueOf(obj));
			} catch (Exception e1) {
				throw new RuntimeException("Long解析异常");
			}
			return num;
		}
	}
	
	/**
	 * 
	* @Title: checkAndAssignNullIntegerIfIsBlank
	* @Description: TODO(如果校验的Object不能转换Long则抛出异常，如果是null，空字符串或者是长空串，统一返回用户null
	* 				checkAndAssignInt的增强版(对传过来的空串等一系列问题进行扩展处理)
	* @Attention: obj为null，空字符串""或者是长空串"   "都不会抛异常，而是直接返回默认值null
	* @return Integer    返回类型
	* @author ylx
	* @date 2017年12月27日 下午1:51:43
	 */
	public static Integer checkAndAssignNullIntegerIfIsBlank(final Object obj){
		String number = null;
		try {
			if (obj == null) {
				return null;
			}
			number = String.class.cast(obj);
			if("".equals(number.trim())){
				return null;
			}
			try {
				return Integer.parseInt(number.trim());
			} catch (NumberFormatException e) {
				throw new NumberFormatException();
			}
		} catch (Exception e) {
			if (e instanceof NumberFormatException) {
				throw new RuntimeException("数据类型解析异常");
			}
			Integer num = null;
			try {
				num=Integer.parseInt(String.valueOf(obj));
			} catch (Exception e1) {
				throw new RuntimeException("Integer解析异常");
			}
			return num;
		}
	}
	
	
	public static void main(String[] args) {
		System.out.println(checkAndAssignNullIntegerIfIsBlank(" "));
	}
	
	
}

class OutOfRangeException extends RuntimeException{
	public OutOfRangeException() {}
	public OutOfRangeException(String message) {
		super(message);
	}
	@Override
	public String getMessage() {
		return super.getMessage();
	}
}
