data converter

public interface Converter {
    /**
     * 进行转换操作
     * @param val 原对象
     * @return 转换后对象
     */
    Object convert(Object val);
}

public abstract class AbstractConverter implements Converter{
    private boolean useDefaultVal = false;
    private Object defaultVal = null;

    public boolean isUseDefaultVal() {
        return useDefaultVal;
    }

    public void setUseDefaultVal(boolean useDefaultVal) {
        this.useDefaultVal = useDefaultVal;
    }

    public Object getDefaultVal() {
        return defaultVal;
    }

    public void setDefaultVal(Object defaultVal) {
        this.defaultVal = defaultVal;
    }

    protected abstract Class<?> getTargetClass();

    protected abstract Object convert2Type(Object val);

    protected abstract String convert2String(Object val);

        @Override
    public Object convert(Object val) {
        if (null == val)
            return handleNullVal(val);
         if (getTargetClass().equals(val.getClass()))
             return getTargetClass().cast(val);
         if (getTargetClass().equals(String.class))
             return getTargetClass().cast(convert2String(val));
        return getTargetClass().cast(convert2Type(val));
    }

        protected Object handleNullVal(Object val){
        if (isUseDefaultVal())
            return getDefaultVal();
        return val;
    }

        protected  <T> Class<T> primitiveToWrapper(final Class<T> type) {
        if (type == null || !type.isPrimitive())
            return type;
        if (type == Integer.TYPE)
            return (Class<T>) Integer.class;
        if (type == Double.TYPE)
            return (Class<T>) Double.class;
        if (type == Long.TYPE)
            return (Class<T>) Long.class;
        if (type == Boolean.TYPE)
            return (Class<T>) Boolean.class;
        if (type == Float.TYPE)
            return (Class<T>) Float.class;
        if (type == Short.TYPE)
            return (Class<T>) Short.class;
        if (type == Byte.TYPE)
            return (Class<T>) Byte.class;
        if (type == Character.TYPE)
            return (Class<T>) Character.class;
        return type;
    }
}

public abstract class NumberConverter extends AbstractConverter {

    @Override
    protected Number convert2Type(Object val) {
        final Class<?> sourceType = val.getClass();
        Number targetVal;
        if (val instanceof Number)
            targetVal = (Number) val;
        else if (val instanceof Boolean)
            targetVal = ((Boolean)val).booleanValue() ? 1 : 0;
        else if (val instanceof Date)
            targetVal = ((Date)val).getTime();
        else if (val instanceof Calendar)
            targetVal = ((Calendar)val).getTime().getTime();
        else
            targetVal = toNumber(sourceType, (Class<? extends Number>) getTargetClass(),  val.toString().trim());
        return toNumber(sourceType, (Class<? extends Number>) getTargetClass(), targetVal);
    }

    @Override
    protected String convert2String(Object val) {
        return String.valueOf(val);
    }

    private Number toNumber(final Class<?> sourceType, final Class<? extends Number> targetType, final Number value){
            if (targetType.equals(sourceType))
            return targetType.cast(value);
        if (targetType.equals(Byte.class)){
            final long longValue = value.longValue();
            if (longValue > Byte.MAX_VALUE)
                throw new IllegalArgumentException("the value is bigger than Byte.MAX_VALUE");
            if (longValue < Byte.MIN_VALUE)
                throw new IllegalArgumentException("the value is smaller than Byte.MIN_VALUE");
            return value.byteValue();
        }
            if (targetType.equals(Short.class)){
            final long longValue = value.longValue();
            if (longValue > Short.MAX_VALUE)
                throw new IllegalArgumentException("the value is bigger than Short.MAX_VALUE");
            if (longValue < Short.MIN_VALUE)
                throw new IllegalArgumentException("the value is smaller than Short.MIN_VALUE");
            return value.shortValue();
        }
        if (targetType.equals(Integer.class)){
            final long longValue = value.longValue();
            if (longValue > Integer.MAX_VALUE)
                throw new IllegalArgumentException("the value is bigger than Integer.MAX_VALUE");
            if (longValue < Integer.MIN_VALUE)
                throw new IllegalArgumentException("the value is smaller than Integer.MIN_VALUE");
            return value.intValue();
        }
        if (targetType.equals(Long.class)) {
            return targetType.cast(new Long(value.longValue()));
        }
        if (targetType.equals(Float.class)){
            final double doubleValue = value.doubleValue();
            if (doubleValue > Float.MAX_VALUE)
                throw new IllegalArgumentException("the value is bigger than Float.MAX_VALUE");
            if (doubleValue < Float.MIN_VALUE)
                throw new IllegalArgumentException("the value is smaller than Float.MIN_VALUE");
            return value.floatValue();
        }
        if (targetType.equals(Double.class)) {
            return targetType.cast(new Double(value.doubleValue()));
        }       
        // BigDecimal
        if (targetType.equals(BigDecimal.class)) {
            if (value instanceof Float || value instanceof Double) {
                return targetType.cast(new BigDecimal(value.toString()));
            } else if (value instanceof BigInteger) {
                return targetType.cast(new BigDecimal((BigInteger)value));
            } else if (value instanceof BigDecimal) {
                return targetType.cast(new BigDecimal(value.toString()));
            } else {
                return targetType.cast(BigDecimal.valueOf(value.longValue()));
            }
        }
             if (targetType.equals(BigInteger.class)) {
            if (value instanceof BigDecimal) {
                return targetType.cast(((BigDecimal)value).toBigInteger());
            } else {
                return targetType.cast(BigInteger.valueOf(value.longValue()));
            }
        }
                throw new IllegalArgumentException("can't convert from " + sourceType.getName() +" to " + targetType.getName()+" and the value is "+value);
    }

   private Number toNumber(final Class<?> sourceType, final Class<? extends Number> targetType, final String value){
        // Byte
        if (targetType.equals(Byte.class)) {
            return new Byte(value);
        }
                        // Short
        if (targetType.equals(Short.class)) {
            return new Short(value);
        }
        // Integer
        if (targetType.equals(Integer.class)) {
            return new Integer(value);
        }
        // Long
        if (targetType.equals(Long.class)) {
            return new Long(value);
        }
                        // Float
        if (targetType.equals(Float.class)) {
            return new Float(value);
        }
        // Double
        if (targetType.equals(Double.class)) {
            return new Double(value);
        }
        // BigDecimal
        if (targetType.equals(BigDecimal.class)) {
            return new BigDecimal(value);
        }
                        // BigInteger
        if (targetType.equals(BigInteger.class)) {
            return new BigInteger(value);
        }
        throw new IllegalArgumentException("can't convert from " + sourceType.getName() +" to " + targetType.getName()+" and the value is "+value);
    }       

}

public class IntegerConverter extends NumberConverter {

    @Override
    protected Class<?> getTargetClass() {
        return Integer.class;
    }
}

public class FloatConverter  extends NumberConverter {

    @Override
    protected Class<?> getTargetClass() {
        return Float.class;
    }
}