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

Example 21 with JSONType

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

the class TypeUtils method buildBeanInfo.

public static // 
SerializeBeanInfo buildBeanInfo(// 
Class<?> beanType, // 
Map<String, String> aliasMap, // 
PropertyNamingStrategy propertyNamingStrategy, // 
boolean fieldBased) {
    JSONType jsonType = TypeUtils.getAnnotation(beanType, JSONType.class);
    String[] orders = null;
    final int features;
    String typeName = null, typeKey = null;
    if (jsonType != null) {
        orders = jsonType.orders();
        typeName = jsonType.typeName();
        if (typeName.length() == 0) {
            typeName = null;
        }
        PropertyNamingStrategy jsonTypeNaming = jsonType.naming();
        if (jsonTypeNaming != PropertyNamingStrategy.CamelCase) {
            propertyNamingStrategy = jsonTypeNaming;
        }
        features = SerializerFeature.of(jsonType.serialzeFeatures());
        for (Class<?> supperClass = beanType.getSuperclass(); supperClass != null && supperClass != Object.class; supperClass = supperClass.getSuperclass()) {
            JSONType superJsonType = TypeUtils.getAnnotation(supperClass, JSONType.class);
            if (superJsonType == null) {
                break;
            }
            typeKey = superJsonType.typeKey();
            if (typeKey.length() != 0) {
                break;
            }
        }
        for (Class<?> interfaceClass : beanType.getInterfaces()) {
            JSONType superJsonType = TypeUtils.getAnnotation(interfaceClass, JSONType.class);
            if (superJsonType != null) {
                typeKey = superJsonType.typeKey();
                if (typeKey.length() != 0) {
                    break;
                }
            }
        }
        if (typeKey != null && typeKey.length() == 0) {
            typeKey = null;
        }
    } else {
        features = 0;
    }
    // fieldName,field ，先生成fieldName的快照，减少之后的findField的轮询
    Map<String, Field> fieldCacheMap = new HashMap<String, Field>();
    ParserConfig.parserAllFieldToCache(beanType, fieldCacheMap);
    List<FieldInfo> fieldInfoList = fieldBased ? // 
    computeGettersWithFieldBase(beanType, aliasMap, false, propertyNamingStrategy) : computeGetters(beanType, jsonType, aliasMap, fieldCacheMap, false, propertyNamingStrategy);
    FieldInfo[] fields = new FieldInfo[fieldInfoList.size()];
    fieldInfoList.toArray(fields);
    FieldInfo[] sortedFields;
    List<FieldInfo> sortedFieldList;
    if (orders != null && orders.length != 0) {
        sortedFieldList = fieldBased ? // 
        computeGettersWithFieldBase(beanType, aliasMap, true, propertyNamingStrategy) : computeGetters(beanType, jsonType, aliasMap, fieldCacheMap, true, propertyNamingStrategy);
    } else {
        sortedFieldList = new ArrayList<FieldInfo>(fieldInfoList);
        Collections.sort(sortedFieldList);
    }
    sortedFields = new FieldInfo[sortedFieldList.size()];
    sortedFieldList.toArray(sortedFields);
    if (Arrays.equals(sortedFields, fields)) {
        sortedFields = fields;
    }
    return new SerializeBeanInfo(beanType, jsonType, typeName, typeKey, features, fields, sortedFields);
}

Example 22 with JSONType

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

the class TypeUtils method getFieldInfos.

private static List<FieldInfo> getFieldInfos(Class<?> clazz, boolean sorted, Map<String, FieldInfo> fieldInfoMap) {
    List<FieldInfo> fieldInfoList = new ArrayList<FieldInfo>();
    String[] orders = null;
    JSONType annotation = TypeUtils.getAnnotation(clazz, JSONType.class);
    if (annotation != null) {
        orders = annotation.orders();
    }
    if (orders != null && orders.length > 0) {
        LinkedHashMap<String, FieldInfo> map = new LinkedHashMap<String, FieldInfo>(fieldInfoList.size());
        for (FieldInfo field : fieldInfoMap.values()) {
            map.put(field.name, field);
        }
        int i = 0;
        for (String item : orders) {
            FieldInfo field = map.get(item);
            if (field != null) {
                fieldInfoList.add(field);
                map.remove(item);
            }
        }
        for (FieldInfo field : map.values()) {
            fieldInfoList.add(field);
        }
    } else {
        for (FieldInfo fieldInfo : fieldInfoMap.values()) {
            fieldInfoList.add(fieldInfo);
        }
        if (sorted) {
            Collections.sort(fieldInfoList);
        }
    }
    return fieldInfoList;
}

Example 23 with JSONType

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

the class TypeUtils method computeGetters.

public static List<FieldInfo> computeGetters(Class<?> clazz, Map<String, String> aliasMap, boolean sorted) {
    JSONType jsonType = TypeUtils.getAnnotation(clazz, JSONType.class);
    Map<String, Field> fieldCacheMap = new HashMap<String, Field>();
    ParserConfig.parserAllFieldToCache(clazz, fieldCacheMap);
    return computeGetters(clazz, jsonType, aliasMap, fieldCacheMap, sorted, PropertyNamingStrategy.CamelCase);
}

Example 24 with JSONType

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

the class SerializeConfig method createJavaBeanSerializer.

public ObjectSerializer createJavaBeanSerializer(SerializeBeanInfo beanInfo) {
    JSONType jsonType = beanInfo.jsonType;
    boolean asm = this.asm && !fieldBased;
    if (jsonType != null) {
        Class<?> serializerClass = jsonType.serializer();
        if (serializerClass != Void.class) {
            try {
                Object seralizer = serializerClass.newInstance();
                if (seralizer instanceof ObjectSerializer) {
                    return (ObjectSerializer) seralizer;
                }
            } catch (Throwable e) {
            // skip
            }
        }
        if (jsonType.asm() == false) {
            asm = false;
        }
        if (asm) {
            for (SerializerFeature feature : jsonType.serialzeFeatures()) {
                if (// 
                SerializerFeature.WriteNonStringValueAsString == feature || // 
                SerializerFeature.WriteEnumUsingToString == feature || SerializerFeature.NotWriteDefaultValue == feature || SerializerFeature.BrowserCompatible == feature) {
                    asm = false;
                    break;
                }
            }
        }
        if (asm) {
            final Class<? extends SerializeFilter>[] filterClasses = jsonType.serialzeFilters();
            if (filterClasses.length != 0) {
                asm = false;
            }
        }
    }
    Class<?> clazz = beanInfo.beanType;
    if (!Modifier.isPublic(beanInfo.beanType.getModifiers())) {
        return new JavaBeanSerializer(beanInfo);
    }
    if (asm && asmFactory.classLoader.isExternalClass(clazz) || clazz == Serializable.class || clazz == Object.class) {
        asm = false;
    }
    if (asm && !ASMUtils.checkName(clazz.getSimpleName())) {
        asm = false;
    }
    if (asm && beanInfo.beanType.isInterface()) {
        asm = false;
    }
    if (asm) {
        for (FieldInfo fieldInfo : beanInfo.fields) {
            Field field = fieldInfo.field;
            if (field != null && !field.getType().equals(fieldInfo.fieldClass)) {
                asm = false;
                break;
            }
            Method method = fieldInfo.method;
            if (method != null && !method.getReturnType().equals(fieldInfo.fieldClass)) {
                asm = false;
                break;
            }
            JSONField annotation = fieldInfo.getAnnotation();
            if (annotation == null) {
                continue;
            }
            String format = annotation.format();
            if (format.length() != 0) {
                if (fieldInfo.fieldClass == String.class && "trim".equals(format)) {
                } else {
                    asm = false;
                    break;
                }
            }
            if (// 
            (!ASMUtils.checkName(annotation.name())) || annotation.jsonDirect() || annotation.serializeUsing() != Void.class || annotation.unwrapped()) {
                asm = false;
                break;
            }
            for (SerializerFeature feature : annotation.serialzeFeatures()) {
                if (// 
                SerializerFeature.WriteNonStringValueAsString == feature || // 
                SerializerFeature.WriteEnumUsingToString == feature || SerializerFeature.NotWriteDefaultValue == feature || SerializerFeature.BrowserCompatible == feature || SerializerFeature.WriteClassName == feature) {
                    asm = false;
                    break;
                }
            }
            if (TypeUtils.isAnnotationPresentOneToMany(method) || TypeUtils.isAnnotationPresentManyToMany(method)) {
                asm = false;
                break;
            }
        }
    }
    if (asm) {
        try {
            ObjectSerializer asmSerializer = createASMSerializer(beanInfo);
            if (asmSerializer != null) {
                return asmSerializer;
            }
        } catch (ClassNotFoundException ex) {
        // skip
        } catch (ClassFormatError e) {
        // skip
        } catch (ClassCastException e) {
        // skip
        } catch (OutOfMemoryError e) {
            if (e.getMessage().indexOf("Metaspace") != -1) {
                throw e;
            }
        // skip
        } catch (Throwable e) {
            throw new JSONException("create asm serializer error, verson " + JSON.VERSION + ", class " + clazz, e);
        }
    }
    return new JavaBeanSerializer(beanInfo);
}

Example 25 with JSONType

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

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) {
        String className = clazz.getName();
        Class<?> superClass;
        if (Map.class.isAssignableFrom(clazz)) {
            put(clazz, writer = MapSerializer.instance);
        } else if (List.class.isAssignableFrom(clazz)) {
            put(clazz, writer = ListSerializer.instance);
        } else if (Collection.class.isAssignableFrom(clazz)) {
            put(clazz, writer = CollectionCodec.instance);
        } else if (Date.class.isAssignableFrom(clazz)) {
            put(clazz, writer = DateCodec.instance);
        } else if (JSONAware.class.isAssignableFrom(clazz)) {
            put(clazz, writer = JSONAwareSerializer.instance);
        } else if (JSONSerializable.class.isAssignableFrom(clazz)) {
            put(clazz, writer = JSONSerializableSerializer.instance);
        } else if (JSONStreamAware.class.isAssignableFrom(clazz)) {
            put(clazz, writer = MiscCodec.instance);
        } else if (clazz.isEnum()) {
            JSONType jsonType = TypeUtils.getAnnotation(clazz, JSONType.class);
            if (jsonType != null && jsonType.serializeEnumAsJavaBean()) {
                put(clazz, writer = createJavaBeanSerializer(clazz));
            } else {
                put(clazz, writer = EnumSerializer.instance);
            }
        } else if ((superClass = clazz.getSuperclass()) != null && superClass.isEnum()) {
            JSONType jsonType = TypeUtils.getAnnotation(superClass, JSONType.class);
            if (jsonType != null && jsonType.serializeEnumAsJavaBean()) {
                put(clazz, writer = createJavaBeanSerializer(clazz));
            } else {
                put(clazz, writer = EnumSerializer.instance);
            }
        } else if (clazz.isArray()) {
            Class<?> componentType = clazz.getComponentType();
            ObjectSerializer compObjectSerializer = getObjectWriter(componentType);
            put(clazz, writer = new ArraySerializer(componentType, compObjectSerializer));
        } else if (Throwable.class.isAssignableFrom(clazz)) {
            SerializeBeanInfo beanInfo = TypeUtils.buildBeanInfo(clazz, null, propertyNamingStrategy);
            beanInfo.features |= SerializerFeature.WriteClassName.mask;
            put(clazz, writer = new JavaBeanSerializer(beanInfo));
        } else if (TimeZone.class.isAssignableFrom(clazz) || Map.Entry.class.isAssignableFrom(clazz)) {
            put(clazz, writer = MiscCodec.instance);
        } else if (Appendable.class.isAssignableFrom(clazz)) {
            put(clazz, writer = AppendableSerializer.instance);
        } else if (Charset.class.isAssignableFrom(clazz)) {
            put(clazz, writer = ToStringSerializer.instance);
        } else if (Enumeration.class.isAssignableFrom(clazz)) {
            put(clazz, writer = EnumerationSerializer.instance);
        } else if (// 
        Calendar.class.isAssignableFrom(clazz) || XMLGregorianCalendar.class.isAssignableFrom(clazz)) {
            put(clazz, writer = CalendarCodec.instance);
        } else if (Clob.class.isAssignableFrom(clazz)) {
            put(clazz, writer = ClobSeriliazer.instance);
        } else if (TypeUtils.isPath(clazz)) {
            put(clazz, writer = ToStringSerializer.instance);
        } else if (Iterator.class.isAssignableFrom(clazz)) {
            put(clazz, writer = MiscCodec.instance);
        } else if (org.w3c.dom.Node.class.isAssignableFrom(clazz)) {
            put(clazz, writer = MiscCodec.instance);
        } else {
            if (// 
            className.startsWith("java.awt.") && // 
            AwtCodec.support(clazz)) {
                // awt
                if (!awtError) {
                    try {
                        String[] names = new String[] { "java.awt.Color", "java.awt.Font", "java.awt.Point", "java.awt.Rectangle" };
                        for (String name : names) {
                            if (name.equals(className)) {
                                put(Class.forName(name), writer = AwtCodec.instance);
                                return writer;
                            }
                        }
                    } catch (Throwable e) {
                        awtError = true;
                    // skip
                    }
                }
            }
            // 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 {
                    {
                        String[] names = new String[] { "java.time.LocalDateTime", "java.time.LocalDate", "java.time.LocalTime", "java.time.ZonedDateTime", "java.time.OffsetDateTime", "java.time.OffsetTime", "java.time.ZoneOffset", "java.time.ZoneRegion", "java.time.Period", "java.time.Duration", "java.time.Instant" };
                        for (String name : names) {
                            if (name.equals(className)) {
                                put(Class.forName(name), writer = Jdk8DateCodec.instance);
                                return writer;
                            }
                        }
                    }
                    {
                        String[] names = new String[] { "java.util.Optional", "java.util.OptionalDouble", "java.util.OptionalInt", "java.util.OptionalLong" };
                        for (String name : names) {
                            if (name.equals(className)) {
                                put(Class.forName(name), writer = OptionalCodec.instance);
                                return writer;
                            }
                        }
                    }
                    {
                        String[] names = new String[] { "java.util.concurrent.atomic.LongAdder", "java.util.concurrent.atomic.DoubleAdder" };
                        for (String name : names) {
                            if (name.equals(className)) {
                                put(Class.forName(name), writer = AdderSerializer.instance);
                                return writer;
                            }
                        }
                    }
                } catch (Throwable e) {
                    // skip
                    jdk8Error = true;
                }
            }
            if (// 
            (!oracleJdbcError) && className.startsWith("oracle.sql.")) {
                try {
                    String[] names = new String[] { "oracle.sql.DATE", "oracle.sql.TIMESTAMP" };
                    for (String name : names) {
                        if (name.equals(className)) {
                            put(Class.forName(name), writer = DateCodec.instance);
                            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"), writer = SwaggerJsonSerializer.instance);
                    return writer;
                } catch (ClassNotFoundException e) {
                    // skip
                    springfoxError = true;
                }
            }
            if (// 
            (!guavaError) && className.startsWith("com.google.common.collect.")) {
                try {
                    String[] names = new String[] { "com.google.common.collect.HashMultimap", "com.google.common.collect.LinkedListMultimap", "com.google.common.collect.ArrayListMultimap", "com.google.common.collect.TreeMultimap" };
                    for (String name : names) {
                        if (name.equals(className)) {
                            put(Class.forName(name), writer = GuavaCodec.instance);
                            return writer;
                        }
                    }
                } catch (ClassNotFoundException e) {
                    // skip
                    guavaError = true;
                }
            }
            if ((!jsonnullError) && className.equals("net.sf.json.JSONNull")) {
                try {
                    put(Class.forName("net.sf.json.JSONNull"), writer = MiscCodec.instance);
                    return writer;
                } catch (ClassNotFoundException e) {
                    // skip
                    jsonnullError = true;
                }
            }
            if ((!jodaError) && className.startsWith("org.joda.")) {
                try {
                    String[] names = new String[] { "org.joda.time.LocalDate", "org.joda.time.LocalDateTime", "org.joda.time.LocalTime", "org.joda.time.Instant", "org.joda.time.DateTime", "org.joda.time.Period", "org.joda.time.Duration", "org.joda.time.DateTimeZone", "org.joda.time.UTCDateTimeZone", "org.joda.time.tz.CachedDateTimeZone", "org.joda.time.tz.FixedDateTimeZone" };
                    for (String name : names) {
                        if (name.equals(className)) {
                            put(Class.forName(name), writer = JodaCodec.instance);
                            return writer;
                        }
                    }
                } catch (ClassNotFoundException e) {
                    // skip
                    jodaError = true;
                }
            }
            Class[] interfaces = clazz.getInterfaces();
            if (interfaces.length == 1 && interfaces[0].isAnnotation()) {
                put(clazz, AnnotationSerializer.instance);
                return AnnotationSerializer.instance;
            }
            if (TypeUtils.isProxy(clazz)) {
                Class<?> superClazz = clazz.getSuperclass();
                ObjectSerializer superWriter = getObjectWriter(superClazz);
                put(clazz, superWriter);
                return superWriter;
            }
            if (Proxy.isProxyClass(clazz)) {
                Class handlerClass = null;
                if (interfaces.length == 2) {
                    handlerClass = interfaces[1];
                } else {
                    for (Class proxiedInterface : interfaces) {
                        if (proxiedInterface.getName().startsWith("org.springframework.aop.")) {
                            continue;
                        }
                        if (handlerClass != null) {
                            // multi-matched
                            handlerClass = null;
                            break;
                        }
                        handlerClass = proxiedInterface;
                    }
                }
                if (handlerClass != null) {
                    ObjectSerializer superWriter = getObjectWriter(handlerClass);
                    put(clazz, superWriter);
                    return superWriter;
                }
            }
            if (create) {
                writer = createJavaBeanSerializer(clazz);
                put(clazz, writer);
            }
        }
        if (writer == null) {
            writer = serializers.get(clazz);
        }
    }
    return writer;
}