Examples with JSONType com.alibaba.fastjson.annotation.JSONType used on opensource projects

Example 6 with JSONType

use of com.alibaba.fastjson.annotation.JSONType in project fastjson by alibaba.

the class ASMSerializerFactory method createJavaBeanSerializer.

public JavaBeanSerializer createJavaBeanSerializer(SerializeBeanInfo beanInfo) throws Exception {
    Class<?> clazz = beanInfo.beanType;
    if (clazz.isPrimitive()) {
        throw new JSONException("unsupportd class " + clazz.getName());
    }
    JSONType jsonType = clazz.getAnnotation(JSONType.class);
    FieldInfo[] unsortedGetters = beanInfo.fields;
    ;
    for (FieldInfo fieldInfo : unsortedGetters) {
        if (//
        fieldInfo.field == null && //
        fieldInfo.method != null && fieldInfo.method.getDeclaringClass().isInterface()) {
            return new JavaBeanSerializer(clazz);
        }
    }
    FieldInfo[] getters = beanInfo.sortedFields;
    boolean nativeSorted = beanInfo.sortedFields == beanInfo.fields;
    if (getters.length > 256) {
        return new JavaBeanSerializer(clazz);
    }
    for (FieldInfo getter : getters) {
        if (!ASMUtils.checkName(getter.getMember().getName())) {
            return new JavaBeanSerializer(clazz);
        }
    }
    String className = "ASMSerializer_" + seed.incrementAndGet() + "_" + clazz.getSimpleName();
    String packageName = ASMSerializerFactory.class.getPackage().getName();
    String classNameType = packageName.replace('.', '/') + "/" + className;
    String classNameFull = packageName + "." + className;
    ClassWriter cw = new ClassWriter();
    //
    cw.visit(//
    V1_5, //
    ACC_PUBLIC + ACC_SUPER, //
    classNameType, //
    JavaBeanSerializer, //
    new String[] { ObjectSerializer });
    for (FieldInfo fieldInfo : getters) {
        if (//
        fieldInfo.fieldClass.isPrimitive() || //|| fieldInfo.fieldClass.isEnum() //
        fieldInfo.fieldClass == String.class) {
            continue;
        }
        //
        new FieldWriter(cw, ACC_PUBLIC, fieldInfo.name + "_asm_fieldType", "Ljava/lang/reflect/Type;").visitEnd();
        if (List.class.isAssignableFrom(fieldInfo.fieldClass)) {
            new FieldWriter(cw, ACC_PUBLIC, fieldInfo.name + "_asm_list_item_ser_", //
            ObjectSerializer_desc).visitEnd();
        }
        //
        new FieldWriter(cw, ACC_PUBLIC, fieldInfo.name + "_asm_ser_", ObjectSerializer_desc).visitEnd();
    }
    MethodVisitor mw = new MethodWriter(cw, ACC_PUBLIC, "<init>", "(" + desc(SerializeBeanInfo.class) + ")V", null, null);
    mw.visitVarInsn(ALOAD, 0);
    mw.visitVarInsn(ALOAD, 1);
    mw.visitMethodInsn(INVOKESPECIAL, JavaBeanSerializer, "<init>", "(" + desc(SerializeBeanInfo.class) + ")V");
    // init _asm_fieldType
    for (int i = 0; i < getters.length; ++i) {
        FieldInfo fieldInfo = getters[i];
        if (//
        fieldInfo.fieldClass.isPrimitive() || //                || fieldInfo.fieldClass.isEnum() //
        fieldInfo.fieldClass == String.class) {
            continue;
        }
        mw.visitVarInsn(ALOAD, 0);
        if (fieldInfo.method != null) {
            mw.visitLdcInsn(com.alibaba.fastjson.asm.Type.getType(desc(fieldInfo.declaringClass)));
            mw.visitLdcInsn(fieldInfo.method.getName());
            mw.visitMethodInsn(INVOKESTATIC, type(ASMUtils.class), "getMethodType", "(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/reflect/Type;");
        } else {
            mw.visitVarInsn(ALOAD, 0);
            mw.visitLdcInsn(i);
            mw.visitMethodInsn(INVOKESPECIAL, JavaBeanSerializer, "getFieldType", "(I)Ljava/lang/reflect/Type;");
        }
        mw.visitFieldInsn(PUTFIELD, classNameType, fieldInfo.name + "_asm_fieldType", "Ljava/lang/reflect/Type;");
    }
    mw.visitInsn(RETURN);
    mw.visitMaxs(4, 4);
    mw.visitEnd();
    boolean DisableCircularReferenceDetect = false;
    if (jsonType != null) {
        for (SerializerFeature featrues : jsonType.serialzeFeatures()) {
            if (featrues == SerializerFeature.DisableCircularReferenceDetect) {
                DisableCircularReferenceDetect = true;
                break;
            }
        }
    }
    // 2 writeNonContext
    for (int i = 0; i < 3; ++i) {
        String methodName;
        boolean nonContext = DisableCircularReferenceDetect;
        boolean writeDirect = false;
        if (i == 0) {
            methodName = "write";
            writeDirect = true;
        } else if (i == 1) {
            methodName = "writeNormal";
        } else {
            writeDirect = true;
            nonContext = true;
            methodName = "writeDirectNonContext";
        }
        Context context = new Context(getters, beanInfo, classNameType, writeDirect, nonContext);
        mw = new //
        MethodWriter(//
        cw, //
        ACC_PUBLIC, //
        methodName, "(L" + JSONSerializer + //
        ";Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/reflect/Type;I)V", //
        null, //
        new String[] { "java/io/IOException" });
        {
            Label endIf_ = new Label();
            mw.visitVarInsn(ALOAD, Context.obj);
            //serializer.writeNull();
            mw.visitJumpInsn(IFNONNULL, endIf_);
            mw.visitVarInsn(ALOAD, Context.serializer);
            mw.visitMethodInsn(INVOKEVIRTUAL, JSONSerializer, "writeNull", "()V");
            mw.visitInsn(RETURN);
            mw.visitLabel(endIf_);
        }
        mw.visitVarInsn(ALOAD, Context.serializer);
        mw.visitFieldInsn(GETFIELD, JSONSerializer, "out", SerializeWriter_desc);
        mw.visitVarInsn(ASTORE, context.var("out"));
        if (//
        (!nativeSorted) && !context.writeDirect) {
            if (jsonType == null || jsonType.alphabetic()) {
                Label _else = new Label();
                mw.visitVarInsn(ALOAD, context.var("out"));
                mw.visitMethodInsn(INVOKEVIRTUAL, SerializeWriter, "isSortField", "()Z");
                mw.visitJumpInsn(IFNE, _else);
                mw.visitVarInsn(ALOAD, 0);
                mw.visitVarInsn(ALOAD, 1);
                mw.visitVarInsn(ALOAD, 2);
                mw.visitVarInsn(ALOAD, 3);
                mw.visitVarInsn(ALOAD, 4);
                mw.visitVarInsn(ILOAD, 5);
                mw.visitMethodInsn(INVOKEVIRTUAL, classNameType, "writeUnsorted", "(L" + JSONSerializer + ";Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/reflect/Type;I)V");
                mw.visitInsn(RETURN);
                mw.visitLabel(_else);
            }
        }
        // isWriteDoubleQuoteDirect
        if (context.writeDirect && !nonContext) {
            Label _direct = new Label();
            Label _directElse = new Label();
            mw.visitVarInsn(ALOAD, 0);
            mw.visitVarInsn(ALOAD, Context.serializer);
            mw.visitMethodInsn(INVOKEVIRTUAL, JavaBeanSerializer, "writeDirect", "(L" + JSONSerializer + ";)Z");
            mw.visitJumpInsn(IFNE, _directElse);
            mw.visitVarInsn(ALOAD, 0);
            mw.visitVarInsn(ALOAD, 1);
            mw.visitVarInsn(ALOAD, 2);
            mw.visitVarInsn(ALOAD, 3);
            mw.visitVarInsn(ALOAD, 4);
            mw.visitVarInsn(ILOAD, 5);
            mw.visitMethodInsn(INVOKEVIRTUAL, classNameType, "writeNormal", "(L" + JSONSerializer + ";Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/reflect/Type;I)V");
            mw.visitInsn(RETURN);
            mw.visitLabel(_directElse);
            mw.visitVarInsn(ALOAD, context.var("out"));
            mw.visitLdcInsn(SerializerFeature.DisableCircularReferenceDetect.mask);
            mw.visitMethodInsn(INVOKEVIRTUAL, SerializeWriter, "isEnabled", "(I)Z");
            mw.visitJumpInsn(IFEQ, _direct);
            mw.visitVarInsn(ALOAD, 0);
            mw.visitVarInsn(ALOAD, 1);
            mw.visitVarInsn(ALOAD, 2);
            mw.visitVarInsn(ALOAD, 3);
            mw.visitVarInsn(ALOAD, 4);
            mw.visitVarInsn(ILOAD, 5);
            mw.visitMethodInsn(INVOKEVIRTUAL, classNameType, "writeDirectNonContext", "(L" + JSONSerializer + ";Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/reflect/Type;I)V");
            mw.visitInsn(RETURN);
            mw.visitLabel(_direct);
        }
        // obj
        mw.visitVarInsn(ALOAD, Context.obj);
        // serializer
        mw.visitTypeInsn(CHECKCAST, type(clazz));
        // obj
        mw.visitVarInsn(ASTORE, context.var("entity"));
        generateWriteMethod(clazz, mw, getters, context);
        mw.visitInsn(RETURN);
        mw.visitMaxs(7, context.variantIndex + 2);
        mw.visitEnd();
    }
    if (!nativeSorted) {
        // sortField support
        Context context = new Context(getters, beanInfo, classNameType, false, DisableCircularReferenceDetect);
        mw = new MethodWriter(cw, ACC_PUBLIC, "writeUnsorted", "(L" + JSONSerializer + ";Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/reflect/Type;I)V", null, new String[] { "java/io/IOException" });
        mw.visitVarInsn(ALOAD, Context.serializer);
        mw.visitFieldInsn(GETFIELD, JSONSerializer, "out", SerializeWriter_desc);
        mw.visitVarInsn(ASTORE, context.var("out"));
        // obj
        mw.visitVarInsn(ALOAD, Context.obj);
        // serializer
        mw.visitTypeInsn(CHECKCAST, type(clazz));
        // obj
        mw.visitVarInsn(ASTORE, context.var("entity"));
        generateWriteMethod(clazz, mw, unsortedGetters, context);
        mw.visitInsn(RETURN);
        mw.visitMaxs(7, context.variantIndex + 2);
        mw.visitEnd();
    }
    // 2 writeAsArrayNonContext
    for (int i = 0; i < 3; ++i) {
        String methodName;
        boolean nonContext = DisableCircularReferenceDetect;
        boolean writeDirect = false;
        if (i == 0) {
            methodName = "writeAsArray";
            writeDirect = true;
        } else if (i == 1) {
            methodName = "writeAsArrayNormal";
        } else {
            writeDirect = true;
            nonContext = true;
            methodName = "writeAsArrayNonContext";
        }
        Context context = new Context(getters, beanInfo, classNameType, writeDirect, nonContext);
        mw = new MethodWriter(cw, ACC_PUBLIC, methodName, "(L" + JSONSerializer + ";Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/reflect/Type;I)V", null, new String[] { "java/io/IOException" });
        mw.visitVarInsn(ALOAD, Context.serializer);
        mw.visitFieldInsn(GETFIELD, JSONSerializer, "out", SerializeWriter_desc);
        mw.visitVarInsn(ASTORE, context.var("out"));
        // obj
        mw.visitVarInsn(ALOAD, Context.obj);
        // serializer
        mw.visitTypeInsn(CHECKCAST, type(clazz));
        // obj
        mw.visitVarInsn(ASTORE, context.var("entity"));
        generateWriteAsArray(clazz, mw, getters, context);
        mw.visitInsn(RETURN);
        mw.visitMaxs(7, context.variantIndex + 2);
        mw.visitEnd();
    }
    byte[] code = cw.toByteArray();
    Class<?> exampleClass = classLoader.defineClassPublic(classNameFull, code, 0, code.length);
    Constructor<?> constructor = exampleClass.getConstructor(SerializeBeanInfo.class);
    Object instance = constructor.newInstance(beanInfo);
    return (JavaBeanSerializer) instance;
}

Example 7 with JSONType

use of com.alibaba.fastjson.annotation.JSONType in project fastjson by alibaba.

the class ParserConfig method getDeserializer.

public ObjectDeserializer getDeserializer(Class<?> clazz, Type type) {
    ObjectDeserializer derializer = deserializers.get(type);
    if (derializer != null) {
        return derializer;
    }
    if (type == null) {
        type = clazz;
    }
    derializer = deserializers.get(type);
    if (derializer != null) {
        return derializer;
    }
    {
        JSONType annotation = clazz.getAnnotation(JSONType.class);
        if (annotation != null) {
            Class<?> mappingTo = annotation.mappingTo();
            if (mappingTo != Void.class) {
                return getDeserializer(mappingTo, mappingTo);
            }
        }
    }
    if (type instanceof WildcardType || type instanceof TypeVariable || type instanceof ParameterizedType) {
        derializer = deserializers.get(clazz);
    }
    if (derializer != null) {
        return derializer;
    }
    String className = clazz.getName();
    className = className.replace('$', '.');
    if (//
    className.startsWith("java.awt.") && AwtCodec.support(clazz)) {
        if (!awtError) {
            try {
                deserializers.put(Class.forName("java.awt.Point"), AwtCodec.instance);
                deserializers.put(Class.forName("java.awt.Font"), AwtCodec.instance);
                deserializers.put(Class.forName("java.awt.Rectangle"), AwtCodec.instance);
                deserializers.put(Class.forName("java.awt.Color"), AwtCodec.instance);
            } catch (Throwable e) {
                // skip
                awtError = true;
            }
            derializer = AwtCodec.instance;
        }
    }
    if (!jdk8Error) {
        try {
            if (className.startsWith("java.time.")) {
                deserializers.put(Class.forName("java.time.LocalDateTime"), Jdk8DateCodec.instance);
                deserializers.put(Class.forName("java.time.LocalDate"), Jdk8DateCodec.instance);
                deserializers.put(Class.forName("java.time.LocalTime"), Jdk8DateCodec.instance);
                deserializers.put(Class.forName("java.time.ZonedDateTime"), Jdk8DateCodec.instance);
                deserializers.put(Class.forName("java.time.OffsetDateTime"), Jdk8DateCodec.instance);
                deserializers.put(Class.forName("java.time.OffsetTime"), Jdk8DateCodec.instance);
                deserializers.put(Class.forName("java.time.ZoneOffset"), Jdk8DateCodec.instance);
                deserializers.put(Class.forName("java.time.ZoneRegion"), Jdk8DateCodec.instance);
                deserializers.put(Class.forName("java.time.ZoneId"), Jdk8DateCodec.instance);
                deserializers.put(Class.forName("java.time.Period"), Jdk8DateCodec.instance);
                deserializers.put(Class.forName("java.time.Duration"), Jdk8DateCodec.instance);
                deserializers.put(Class.forName("java.time.Instant"), Jdk8DateCodec.instance);
                derializer = deserializers.get(clazz);
            } else if (className.startsWith("java.util.Optional")) {
                deserializers.put(Class.forName("java.util.Optional"), OptionalCodec.instance);
                deserializers.put(Class.forName("java.util.OptionalDouble"), OptionalCodec.instance);
                deserializers.put(Class.forName("java.util.OptionalInt"), OptionalCodec.instance);
                deserializers.put(Class.forName("java.util.OptionalLong"), OptionalCodec.instance);
                derializer = deserializers.get(clazz);
            }
        } catch (Throwable e) {
            // skip
            jdk8Error = true;
        }
    }
    if (className.equals("java.nio.file.Path")) {
        deserializers.put(clazz, MiscCodec.instance);
    }
    if (clazz == Map.Entry.class) {
        deserializers.put(clazz, MiscCodec.instance);
    }
    final ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    try {
        for (AutowiredObjectDeserializer autowired : ServiceLoader.load(AutowiredObjectDeserializer.class, classLoader)) {
            for (Type forType : autowired.getAutowiredFor()) {
                deserializers.put(forType, autowired);
            }
        }
    } catch (Exception ex) {
    // skip
    }
    if (derializer == null) {
        derializer = deserializers.get(type);
    }
    if (derializer != null) {
        return derializer;
    }
    if (clazz.isEnum()) {
        derializer = new EnumDeserializer(clazz);
    } else if (clazz.isArray()) {
        derializer = ObjectArrayCodec.instance;
    } else if (clazz == Set.class || clazz == HashSet.class || clazz == Collection.class || clazz == List.class || clazz == ArrayList.class) {
        derializer = CollectionCodec.instance;
    } else if (Collection.class.isAssignableFrom(clazz)) {
        derializer = CollectionCodec.instance;
    } else if (Map.class.isAssignableFrom(clazz)) {
        derializer = MapDeserializer.instance;
    } else if (Throwable.class.isAssignableFrom(clazz)) {
        derializer = new ThrowableDeserializer(this, clazz);
    } else {
        derializer = createJavaBeanDeserializer(clazz, type);
    }
    putDeserializer(type, derializer);
    return derializer;
}

Example 8 with JSONType

use of com.alibaba.fastjson.annotation.JSONType in project fastjson by alibaba.

the class SerializeConfig method getObjectWriter.

private ObjectSerializer getObjectWriter(Class<?> clazz, boolean create) {
    ObjectSerializer writer = serializers.get(clazz);
    if (writer == null) {
        try {
            final ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
            for (Object o : ServiceLoader.load(AutowiredObjectSerializer.class, classLoader)) {
                if (!(o instanceof AutowiredObjectSerializer)) {
                    continue;
                }
                AutowiredObjectSerializer autowired = (AutowiredObjectSerializer) o;
                for (Type forType : autowired.getAutowiredFor()) {
                    put(forType, autowired);
                }
            }
        } catch (ClassCastException ex) {
        // skip
        }
        writer = serializers.get(clazz);
    }
    if (writer == null) {
        final ClassLoader classLoader = JSON.class.getClassLoader();
        if (classLoader != Thread.currentThread().getContextClassLoader()) {
            try {
                for (Object o : ServiceLoader.load(AutowiredObjectSerializer.class, classLoader)) {
                    if (!(o instanceof AutowiredObjectSerializer)) {
                        continue;
                    }
                    AutowiredObjectSerializer autowired = (AutowiredObjectSerializer) o;
                    for (Type forType : autowired.getAutowiredFor()) {
                        put(forType, autowired);
                    }
                }
            } catch (ClassCastException ex) {
            // skip
            }
            writer = serializers.get(clazz);
        }
    }
    if (writer == null) {
        if (Map.class.isAssignableFrom(clazz)) {
            put(clazz, MapSerializer.instance);
        } else if (List.class.isAssignableFrom(clazz)) {
            put(clazz, ListSerializer.instance);
        } else if (Collection.class.isAssignableFrom(clazz)) {
            put(clazz, CollectionCodec.instance);
        } else if (Date.class.isAssignableFrom(clazz)) {
            put(clazz, DateCodec.instance);
        } else if (JSONAware.class.isAssignableFrom(clazz)) {
            put(clazz, JSONAwareSerializer.instance);
        } else if (JSONSerializable.class.isAssignableFrom(clazz)) {
            put(clazz, JSONSerializableSerializer.instance);
        } else if (JSONStreamAware.class.isAssignableFrom(clazz)) {
            put(clazz, MiscCodec.instance);
        } else if (clazz.isEnum() || (clazz.getSuperclass() != null && clazz.getSuperclass().isEnum())) {
            JSONType jsonType = clazz.getAnnotation(JSONType.class);
            if (jsonType != null && jsonType.serializeEnumAsJavaBean()) {
                put(clazz, createJavaBeanSerializer(clazz));
            } else {
                put(clazz, EnumSerializer.instance);
            }
        } else if (clazz.isArray()) {
            Class<?> componentType = clazz.getComponentType();
            ObjectSerializer compObjectSerializer = getObjectWriter(componentType);
            put(clazz, new ArraySerializer(componentType, compObjectSerializer));
        } else if (Throwable.class.isAssignableFrom(clazz)) {
            SerializeBeanInfo beanInfo = TypeUtils.buildBeanInfo(clazz, null, propertyNamingStrategy);
            beanInfo.features |= SerializerFeature.WriteClassName.mask;
            put(clazz, new JavaBeanSerializer(beanInfo));
        } else if (TimeZone.class.isAssignableFrom(clazz) || Map.Entry.class.isAssignableFrom(clazz)) {
            put(clazz, MiscCodec.instance);
        } else if (Appendable.class.isAssignableFrom(clazz)) {
            put(clazz, AppendableSerializer.instance);
        } else if (Charset.class.isAssignableFrom(clazz)) {
            put(clazz, ToStringSerializer.instance);
        } else if (Enumeration.class.isAssignableFrom(clazz)) {
            put(clazz, EnumerationSerializer.instance);
        } else if (//
        Calendar.class.isAssignableFrom(clazz) || XMLGregorianCalendar.class.isAssignableFrom(clazz)) {
            put(clazz, CalendarCodec.instance);
        } else if (Clob.class.isAssignableFrom(clazz)) {
            put(clazz, ClobSeriliazer.instance);
        } else if (TypeUtils.isPath(clazz)) {
            put(clazz, ToStringSerializer.instance);
        } else if (Iterator.class.isAssignableFrom(clazz)) {
            put(clazz, MiscCodec.instance);
        } else {
            String className = clazz.getName();
            if (//
            className.startsWith("java.awt.") && //
            AwtCodec.support(clazz)) {
                // awt
                if (!awtError) {
                    try {
                        put(Class.forName("java.awt.Color"), AwtCodec.instance);
                        put(Class.forName("java.awt.Font"), AwtCodec.instance);
                        put(Class.forName("java.awt.Point"), AwtCodec.instance);
                        put(Class.forName("java.awt.Rectangle"), AwtCodec.instance);
                    } catch (Throwable e) {
                        awtError = true;
                    // skip
                    }
                }
                return AwtCodec.instance;
            }
            // jdk8
            if (//
            (!jdk8Error) && (//
            className.startsWith("java.time.") || //
            className.startsWith("java.util.Optional") || className.equals("java.util.concurrent.atomic.LongAdder") || className.equals("java.util.concurrent.atomic.DoubleAdder"))) {
                try {
                    put(Class.forName("java.time.LocalDateTime"), Jdk8DateCodec.instance);
                    put(Class.forName("java.time.LocalDate"), Jdk8DateCodec.instance);
                    put(Class.forName("java.time.LocalTime"), Jdk8DateCodec.instance);
                    put(Class.forName("java.time.ZonedDateTime"), Jdk8DateCodec.instance);
                    put(Class.forName("java.time.OffsetDateTime"), Jdk8DateCodec.instance);
                    put(Class.forName("java.time.OffsetTime"), Jdk8DateCodec.instance);
                    put(Class.forName("java.time.ZoneOffset"), Jdk8DateCodec.instance);
                    put(Class.forName("java.time.ZoneRegion"), Jdk8DateCodec.instance);
                    put(Class.forName("java.time.Period"), Jdk8DateCodec.instance);
                    put(Class.forName("java.time.Duration"), Jdk8DateCodec.instance);
                    put(Class.forName("java.time.Instant"), Jdk8DateCodec.instance);
                    put(Class.forName("java.util.Optional"), OptionalCodec.instance);
                    put(Class.forName("java.util.OptionalDouble"), OptionalCodec.instance);
                    put(Class.forName("java.util.OptionalInt"), OptionalCodec.instance);
                    put(Class.forName("java.util.OptionalLong"), OptionalCodec.instance);
                    put(Class.forName("java.util.concurrent.atomic.LongAdder"), AdderSerializer.instance);
                    put(Class.forName("java.util.concurrent.atomic.DoubleAdder"), AdderSerializer.instance);
                    writer = serializers.get(clazz);
                    if (writer != null) {
                        return writer;
                    }
                } catch (Throwable e) {
                    // skip
                    jdk8Error = true;
                }
            }
            if (//
            (!oracleJdbcError) && className.startsWith("oracle.sql.")) {
                try {
                    put(Class.forName("oracle.sql.DATE"), DateCodec.instance);
                    put(Class.forName("oracle.sql.TIMESTAMP"), DateCodec.instance);
                    writer = serializers.get(clazz);
                    if (writer != null) {
                        return writer;
                    }
                } catch (Throwable e) {
                    // skip
                    oracleJdbcError = true;
                }
            }
            if (//
            (!springfoxError) && className.equals("springfox.documentation.spring.web.json.Json")) {
                try {
                    put(//
                    Class.forName("springfox.documentation.spring.web.json.Json"), SwaggerJsonSerializer.instance);
                    writer = serializers.get(clazz);
                    if (writer != null) {
                        return writer;
                    }
                } catch (ClassNotFoundException e) {
                    // skip
                    springfoxError = true;
                }
            }
            if (//
            (!guavaError) && className.startsWith("com.google.common.collect.")) {
                try {
                    put(//
                    Class.forName("com.google.common.collect.HashMultimap"), GuavaCodec.instance);
                    put(//
                    Class.forName("com.google.common.collect.LinkedListMultimap"), GuavaCodec.instance);
                    put(//
                    Class.forName("com.google.common.collect.ArrayListMultimap"), GuavaCodec.instance);
                    put(//
                    Class.forName("com.google.common.collect.TreeMultimap"), GuavaCodec.instance);
                    writer = serializers.get(clazz);
                    if (writer != null) {
                        return writer;
                    }
                } catch (ClassNotFoundException e) {
                    // skip
                    guavaError = true;
                }
            }
            if (className.equals("net.sf.json.JSONNull")) {
                try {
                    put(//
                    Class.forName("net.sf.json.JSONNull"), MiscCodec.instance);
                } catch (ClassNotFoundException e) {
                // skip
                }
                writer = serializers.get(clazz);
                if (writer != null) {
                    return writer;
                }
            }
            if (TypeUtils.isProxy(clazz)) {
                Class<?> superClazz = clazz.getSuperclass();
                ObjectSerializer superWriter = getObjectWriter(superClazz);
                put(clazz, superWriter);
                return superWriter;
            }
            if (create) {
                put(clazz, createJavaBeanSerializer(clazz));
            }
        }
        writer = serializers.get(clazz);
    }
    return writer;
}

Example 9 with JSONType

use of com.alibaba.fastjson.annotation.JSONType in project fastjson by alibaba.

the class ParserConfigBug569 method getDeserializer.

public ObjectDeserializer getDeserializer(Class<?> clazz, Type type) {
    com.alibaba.fastjson.util.IdentityHashMap<Type, ObjectDeserializer> derializers = super.getDeserializers();
    ObjectDeserializer derializer = derializers.get(type);
    if (derializer != null) {
        return derializer;
    }
    if (type == null) {
        type = clazz;
    }
    derializer = derializers.get(type);
    if (derializer != null) {
        return derializer;
    }
    {
        JSONType annotation = clazz.getAnnotation(JSONType.class);
        if (annotation != null) {
            Class<?> mappingTo = annotation.mappingTo();
            if (mappingTo != Void.class) {
                return getDeserializer(mappingTo, mappingTo);
            }
        }
    }
    if (type instanceof WildcardType || type instanceof TypeVariable || type instanceof ParameterizedType) {
        derializer = derializers.get(clazz);
    }
    if (derializer != null) {
        return derializer;
    }
    String className = clazz.getName();
    className = className.replace('$', '.');
    for (int i = 0; i < denyList.length; ++i) {
        String deny = denyList[i];
        if (className.startsWith(deny)) {
            throw new JSONException("parser deny : " + className);
        }
    }
    if (//
    className.startsWith("java.awt.") && AwtCodec.support(clazz)) {
        if (!awtError) {
            try {
                derializers.put(Class.forName("java.awt.Point"), AwtCodec.instance);
                derializers.put(Class.forName("java.awt.Font"), AwtCodec.instance);
                derializers.put(Class.forName("java.awt.Rectangle"), AwtCodec.instance);
                derializers.put(Class.forName("java.awt.Color"), AwtCodec.instance);
            } catch (Throwable e) {
                // skip
                awtError = true;
            }
            derializer = AwtCodec.instance;
        }
    }
    if (!jdk8Error) {
        try {
            if (className.startsWith("java.time.")) {
                derializers.put(Class.forName("java.time.LocalDateTime"), Jdk8DateCodec.instance);
                derializers.put(Class.forName("java.time.LocalDate"), Jdk8DateCodec.instance);
                derializers.put(Class.forName("java.time.LocalTime"), Jdk8DateCodec.instance);
                derializers.put(Class.forName("java.time.ZonedDateTime"), Jdk8DateCodec.instance);
                derializers.put(Class.forName("java.time.OffsetDateTime"), Jdk8DateCodec.instance);
                derializers.put(Class.forName("java.time.OffsetTime"), Jdk8DateCodec.instance);
                derializers.put(Class.forName("java.time.ZoneOffset"), Jdk8DateCodec.instance);
                derializers.put(Class.forName("java.time.ZoneRegion"), Jdk8DateCodec.instance);
                derializers.put(Class.forName("java.time.ZoneId"), Jdk8DateCodec.instance);
                derializers.put(Class.forName("java.time.Period"), Jdk8DateCodec.instance);
                derializers.put(Class.forName("java.time.Duration"), Jdk8DateCodec.instance);
                derializers.put(Class.forName("java.time.Instant"), Jdk8DateCodec.instance);
                derializer = derializers.get(clazz);
            } else if (className.startsWith("java.util.Optional")) {
                derializers.put(Class.forName("java.util.Optional"), OptionalCodec.instance);
                derializers.put(Class.forName("java.util.OptionalDouble"), OptionalCodec.instance);
                derializers.put(Class.forName("java.util.OptionalInt"), OptionalCodec.instance);
                derializers.put(Class.forName("java.util.OptionalLong"), OptionalCodec.instance);
                derializer = derializers.get(clazz);
            }
        } catch (Throwable e) {
            // skip
            jdk8Error = true;
        }
    }
    if (className.equals("java.nio.file.Path")) {
        derializers.put(clazz, MiscCodec.instance);
    }
    final ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    try {
        for (AutowiredObjectDeserializer autowired : ServiceLoader.load(AutowiredObjectDeserializer.class, classLoader)) {
            for (Type forType : autowired.getAutowiredFor()) {
                derializers.put(forType, autowired);
            }
        }
    } catch (Exception ex) {
    // skip
    }
    if (derializer == null) {
        derializer = derializers.get(type);
    }
    if (derializer != null) {
        return derializer;
    }
    if (clazz.isEnum()) {
        derializer = new EnumDeserializer(clazz);
    } else if (clazz.isArray()) {
        derializer = ObjectArrayCodec.instance;
    } else if (clazz == Set.class || clazz == HashSet.class || clazz == Collection.class || clazz == List.class || clazz == ArrayList.class) {
        derializer = CollectionCodec.instance;
    } else if (Collection.class.isAssignableFrom(clazz)) {
        derializer = CollectionCodec.instance;
    } else if (Map.class.isAssignableFrom(clazz)) {
        derializer = MapDeserializer.instance;
    } else if (Throwable.class.isAssignableFrom(clazz)) {
        derializer = new ThrowableDeserializer(this, clazz);
    } else {
        derializer = createJavaBeanDeserializer(clazz, type);
    }
    putDeserializer(type, derializer);
    return derializer;
}