java类com.alibaba.fastjson.util.TypeUtils的实例源码

@SuppressWarnings("unchecked")
public <T> T deserialze(DefaultJSONParser parser, Type clazz, Object fieldName) {
    final JSONLexer lexer = parser.getLexer();

    Long longObject;
    if (lexer.token() == JSONToken.LITERAL_INT) {
        long longValue = lexer.longValue();
        lexer.nextToken(JSONToken.COMMA);
        longObject = Long.valueOf(longValue);
    } else {

        Object value = parser.parse();

        if (value == null) {
            return null;
        }

        longObject = TypeUtils.castToLong(value);
    }

    if (clazz == AtomicLong.class) {
        return (T) new AtomicLong(longObject.longValue());
    }

    return (T) longObject;
}

public <T> T deserialze(DefaultJSONParser parser, Type clazz, Object fieldName) {
    Long longObject;
    JSONLexer lexer = parser.getLexer();
    if (lexer.token() == 2) {
        long longValue = lexer.longValue();
        lexer.nextToken(16);
        longObject = Long.valueOf(longValue);
    } else {
        Object value = parser.parse();
        if (value == null) {
            return null;
        }
        longObject = TypeUtils.castToLong(value);
    }
    if (clazz == AtomicLong.class) {
        return new AtomicLong(longObject.longValue());
    }
    return longObject;
}

@SuppressWarnings("unchecked")
public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
    JSONLexer lexer = parser.getLexer();

    if (lexer.token() == JSONToken.NULL) {
        lexer.nextToken();
        return null;
    }

    if (lexer.token() != JSONToken.LITERAL_STRING) {
        throw new JSONException("expect className");
    }
    String className = lexer.stringVal();
    lexer.nextToken(JSONToken.COMMA);

    return (T) TypeUtils.loadClass(className);
}

public void test_bean_2() throws Exception {
    Map<String, Object> map = new HashMap<String, Object>();
    map.put("id", 123);
    PO vo = TypeUtils.castToJavaBean(map, PO.class);
    Assert.assertEquals(123, vo.id);

    SerializeWriter out = new SerializeWriter();

    try {
        SerializeConfig config = new SerializeConfig();
        JSONSerializer serializer = new JSONSerializer(out, config);
        config.put(PO.class, new JavaBeanSerializer(PO.class, Collections.singletonMap("id", "ID")));

        serializer.write(vo);

        Assert.assertEquals("{\"ID\":123}", out.toString());
    } finally {
        out.close();
    }


}

public void test_bean_3() throws Exception {
    Map<String, Object> map = new HashMap<String, Object>();
    map.put("id", 123);
    PO vo = TypeUtils.castToJavaBean(map, PO.class);
    Assert.assertEquals(123, vo.id);

    SerializeWriter out = new SerializeWriter();

    try {
        SerializeConfig config = new SerializeConfig();
        JSONSerializer serializer = new JSONSerializer(out, config);
        config.put(PO.class, new JavaBeanSerializer(PO.class, Collections.singletonMap("id", (String) null)));

        serializer.write(vo);

        Assert.assertEquals("{}", out.toString());
    } finally {
        out.close();
    }


}

@SuppressWarnings("unchecked")
public static <T> T deserialze(DefaultJSONParser parser) {
    final JSONLexer lexer = parser.getLexer();
    if (lexer.token() == JSONToken.LITERAL_INT) {
        String val = lexer.numberString();
        lexer.nextToken(JSONToken.COMMA);
        return (T) new BigInteger(val);
    }

    Object value = parser.parse();

    if (value == null) {
        return null;
    }

    return (T) TypeUtils.castToBigInteger(value);
}

@SuppressWarnings("unchecked")
public <T> T deserialze(DefaultJSONParser parser, Type clazz, Object fieldName) {
    final JSONLexer lexer = parser.getLexer();

    if (lexer.token() == JSONToken.NULL) {
        lexer.nextToken(JSONToken.COMMA);
        return null;
    }

    Integer intObj;
    if (lexer.token() == JSONToken.LITERAL_INT) {
        int val = lexer.intValue();
        lexer.nextToken(JSONToken.COMMA);
        intObj = Integer.valueOf(val);
    } else if (lexer.token() == JSONToken.LITERAL_FLOAT) {
        BigDecimal decimalValue = lexer.decimalValue();
        lexer.nextToken(JSONToken.COMMA);
        intObj = Integer.valueOf(decimalValue.intValue());
    } else {
        Object value = parser.parse();

        intObj = TypeUtils.castToInt(value);
    }

    if (clazz == AtomicInteger.class) {
        return (T) new AtomicInteger(intObj.intValue());
    }

    return (T) intObj;
}

private void _newCollection(MethodVisitor mw, Class<?> fieldClass, int i, boolean set) {
    if (fieldClass.isAssignableFrom(ArrayList.class) && !set) {
        mw.visitTypeInsn(NEW, "java/util/ArrayList");
        mw.visitInsn(DUP);
        mw.visitMethodInsn(INVOKESPECIAL, "java/util/ArrayList", "<init>", "()V");
    } else if (fieldClass.isAssignableFrom(LinkedList.class) && !set) {
        mw.visitTypeInsn(NEW, type(LinkedList.class));
        mw.visitInsn(DUP);
        mw.visitMethodInsn(INVOKESPECIAL, type(LinkedList.class), "<init>", "()V");
    } else if (fieldClass.isAssignableFrom(HashSet.class)) {
        mw.visitTypeInsn(NEW, type(HashSet.class));
        mw.visitInsn(DUP);
        mw.visitMethodInsn(INVOKESPECIAL, type(HashSet.class), "<init>", "()V");
    } else if (fieldClass.isAssignableFrom(TreeSet.class)) {
        mw.visitTypeInsn(NEW, type(TreeSet.class));
        mw.visitInsn(DUP);
        mw.visitMethodInsn(INVOKESPECIAL, type(TreeSet.class), "<init>", "()V");
    } else if (fieldClass.isAssignableFrom(LinkedHashSet.class)) {
        mw.visitTypeInsn(NEW, type(LinkedHashSet.class));
        mw.visitInsn(DUP);
        mw.visitMethodInsn(INVOKESPECIAL, type(LinkedHashSet.class), "<init>", "()V");
    } else if (set) {
        mw.visitTypeInsn(NEW, type(HashSet.class));
        mw.visitInsn(DUP);
        mw.visitMethodInsn(INVOKESPECIAL, type(HashSet.class), "<init>", "()V");
    } else {
        mw.visitVarInsn(ALOAD, 0);
        mw.visitLdcInsn(i);
        mw.visitMethodInsn(INVOKEVIRTUAL, type(JavaBeanDeserializer.class), "getFieldType",
                           "(I)Ljava/lang/reflect/Type;");
        mw.visitMethodInsn(INVOKESTATIC, type(TypeUtils.class), "createCollection",
                           "(Ljava/lang/reflect/Type;)Ljava/util/Collection;");
    }
    mw.visitTypeInsn(CHECKCAST, type(fieldClass)); // cast
}

public byte[] getBytes(String key) {
    Object value = get(key);
    if (value == null) {
        return null;
    }
    return TypeUtils.castToBytes(value);
}

public <T> T getObject(String key, TypeReference typeReference) {
    Object obj = map.get(key);
    if (typeReference == null) {
        return (T) obj;
    }
    return TypeUtils.cast(obj, typeReference.getType(), ParserConfig.getGlobalInstance());
}

public Integer readInteger() {
    Object object;
    if (context == null) {
        object = parser.parse();
    } else {
        readBefore();
        object = parser.parse();
        readAfter();
    }

    return TypeUtils.castToInt(object);
}

public Long readLong() {
    Object object;
    if (context == null) {
        object = parser.parse();
    } else {
        readBefore();
        object = parser.parse();
        readAfter();
    }

    return TypeUtils.castToLong(object);
}

@SuppressWarnings("unchecked")
public static <T> T deserialze(DefaultJSONParser parser) {
    final JSONLexer lexer = parser.lexer;
    if (lexer.token() == JSONToken.LITERAL_INT) {
        String val = lexer.numberString();
        lexer.nextToken(JSONToken.COMMA);
        return (T) new BigInteger(val);
    }

    Object value = parser.parse();
    return value == null //
        ? null //
        : (T) TypeUtils.castToBigInteger(value);
}

public Object getPropertyValueDirect(Object object) throws InvocationTargetException, IllegalAccessException {
    Object fieldValue =  fieldInfo.get(object);
    if (persistenceXToMany && !TypeUtils.isHibernateInitialized(fieldValue)) {
        return null;
    }
    return fieldValue;
}

public void test_error_1() throws Exception {
    Exception error = null;
    try {
        TypeUtils.castToChar(true);
    } catch (JSONException e) {
        error = e;
    }
    Assert.assertNotNull(error);
}

public float getFloatValue(String key) {
    Object value = get(key);
    if (value == null) {
        return 0.0f;
    }
    return TypeUtils.castToFloat(value).floatValue();
}

public boolean getBooleanValue(int index) {
    Object value = get(index);
    if (value == null) {
        return false;
    }
    return TypeUtils.castToBoolean(value).booleanValue();
}

public Integer readInteger() {
    Object object;
    if (context == null) {
        object = parser.parse();
    } else {
        readBefore();
        object = parser.parse();
        readAfter();
    }

    return TypeUtils.castToInt(object);
}

/**
 * @since  1.2.23
 */
public <T> List<T> toJavaList(Class<T> clazz) {
    List<T> list = new ArrayList<T>(this.size());

    ParserConfig config = ParserConfig.getGlobalInstance();

    for (Object item : this) {
        T classItem = (T) TypeUtils.cast(item, clazz, config);
        list.add(classItem);
    }

    return list;
}

@SuppressWarnings("unchecked")
public <T> T deserialze(DefaultJSONParser parser, Type clazz, Object fieldName) {
    Object value = parser.parse();

    if (value == null) {
        return null;
    }

    return (T) TypeUtils.castToChar(value);
}

public long getLongValue(String key) {
    Object value = get(key);
    if (value == null) {
        return 0;
    }
    return TypeUtils.castToLong(value).longValue();
}

@SuppressWarnings("unchecked")
public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
    if (type instanceof GenericArrayType) {
        Type componentType = ((GenericArrayType) type).getGenericComponentType();
        if (componentType instanceof TypeVariable) {
            TypeVariable<?> componentVar = (TypeVariable<?>) componentType;
            componentType = componentVar.getBounds()[0];
        }

        List<Object> list = new ArrayList<Object>();
        parser.parseArray(componentType, list);
        Class<?> componentClass;
        if (componentType instanceof Class) {
            componentClass = (Class<?>) componentType;
            if (componentClass == boolean.class) {
                return (T) TypeUtils.cast(list, boolean[].class, parser.getConfig());
            } else if (componentClass == short.class) {
                return (T) TypeUtils.cast(list, short[].class, parser.getConfig());
            } else if (componentClass == int.class) {
                return (T) TypeUtils.cast(list, int[].class, parser.getConfig());
            } else if (componentClass == long.class) {
                return (T) TypeUtils.cast(list, long[].class, parser.getConfig());
            } else if (componentClass == float.class) {
                return (T) TypeUtils.cast(list, float[].class, parser.getConfig());
            } else if (componentClass == double.class) {
                return (T) TypeUtils.cast(list, double[].class, parser.getConfig());
            }

            Object[] array = (Object[]) Array.newInstance(componentClass, list.size());
            list.toArray(array);
            return (T) array;
        } else {
            return (T) list.toArray();
        }

    }

    return (T) parser.parse(fieldName);
}

public byte getByteValue(int index) {
    Object value = get(index);
    if (value == null) {
        return (byte) 0;
    }
    return TypeUtils.castToByte(value).byteValue();
}

public void test_error() throws Exception {
    Exception error = null;
    try {
        TypeUtils.castToEnum("\"A1\"", Type.class, null);
    } catch (Exception ex) {
        error = ex;
    }
    Assert.assertNotNull(error);
}

public void test_error_1() throws Exception {
    Exception error = null;
    try {
        TypeUtils.castToEnum(Boolean.TRUE, Type.class, null);
    } catch (Exception ex) {
        error = ex;
    }
    Assert.assertNotNull(error);
}

public double getDoubleValue(String key) {
    Object value = get(key);
    if (value == null) {
        return 0.0d;
    }
    return TypeUtils.castToDouble(value).doubleValue();
}

public <T> T deserialze(DefaultJSONParser parser, Type clazz, Object fieldName) {
    Object value = parser.parse();
    if (value == null) {
        return null;
    }
    return TypeUtils.castToChar(value);
}

public void test_error_3() throws Exception {
    Exception error = null;
    try {
        TypeUtils.cast("xxx", new TypeReference<Object[]>() {
        }.getType(), null);
    } catch (Exception ex) {
        error = ex;
    }
    Assert.assertNotNull(error);
}

public void test_castToJavaBean_StackTraceElement() throws Exception {
    Map<String, Object> map = new HashMap<String, Object>();
    map.put("className", "java.lang.Object");
    map.put("methodName", "hashCode");
    StackTraceElement element = TypeUtils.castToJavaBean(map, StackTraceElement.class, null);
    Assert.assertEquals("java.lang.Object", element.getClassName());
    Assert.assertEquals("hashCode", element.getMethodName());
    Assert.assertEquals(null, element.getFileName());
}

public void test_castToJavaBean_StackTraceElement_1() throws Exception {
    Map<String, Object> map = new HashMap<String, Object>();
    map.put("className", "java.lang.Object");
    map.put("methodName", "hashCode");
    map.put("lineNumber", 12);
    StackTraceElement element = TypeUtils.castToJavaBean(map, StackTraceElement.class, null);
    Assert.assertEquals("java.lang.Object", element.getClassName());
    Assert.assertEquals("hashCode", element.getMethodName());
    Assert.assertEquals(null, element.getFileName());
    Assert.assertEquals(12, element.getLineNumber());
}