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   Class primitiveToWrapper(final Class type) {        if (type == null || !type.isPrimitive())            return type;        if (type == Integer.TYPE)            return (Class) Integer.class;        if (type == Double.TYPE)            return (Class) Double.class;        if (type == Long.TYPE)            return (Class) Long.class;        if (type == Boolean.TYPE)            return (Class) Boolean.class;        if (type == Float.TYPE)            return (Class) Float.class;        if (type == Short.TYPE)            return (Class) Short.class;        if (type == Byte.TYPE)            return (Class) Byte.class;        if (type == Character.TYPE)            return (Class) 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  Short.MAX_VALUE)                throw new IllegalArgumentException("the value is bigger than Short.MAX_VALUE");            if (longValue  Integer.MAX_VALUE)                throw new IllegalArgumentException("the value is bigger than Integer.MAX_VALUE");            if (longValue  Float.MAX_VALUE)                throw new IllegalArgumentException("the value is bigger than Float.MAX_VALUE");            if (doubleValue  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;    }}