public static JSONObject parseObject(String text);
public static JSONObject parseObject(String text, Feature... features);
public static <T> T parseObject(String text, Class<T> clazz);
public static <T> T parseObject(String text, Class<T> clazz, Feature... features);
public static <T> T parseObject(String text, TypeReference<T> type, Feature... features);
public static JSONArray parseArray(String text);
public static <T> List<T> parseArray(String text, Class<T> clazz);

public static <T> T parseObject(String input, Type clazz, ParserConfig config, ParseProcess processor, int featureValues, Feature... features) {
        if (input == null) {
            return null;
        }
        // featureValues作为基准解析特性开关值
        // 入参features和featureValues取并集得到最终的解析特性
        if (features != null) {
            for (Feature feature : features) {
                featureValues |= feature.mask;
            }
        }
        DefaultJSONParser parser = new DefaultJSONParser(input, config, featureValues);
        if (processor != null) {
            if (processor instanceof ExtraTypeProvider) {
                parser.getExtraTypeProviders().add((ExtraTypeProvider) processor);
            }
            if (processor instanceof ExtraProcessor) {
                parser.getExtraProcessors().add((ExtraProcessor) processor);
            }
            if (processor instanceof FieldTypeResolver) {
                parser.setFieldTypeResolver((FieldTypeResolver) processor);
            }
        }
        T value = (T) parser.parseObject(clazz, null);
        parser.handleResovleTask(value);
        parser.close();
        return (T) value;
    }

static {
        int features = 0;
        features |= Feature.AutoCloseSource.getMask();
        features |= Feature.InternFieldNames.getMask();
        features |= Feature.UseBigDecimal.getMask();
        features |= Feature.AllowUnQuotedFieldNames.getMask();
        features |= Feature.AllowSingleQuotes.getMask();
        features |= Feature.AllowArbitraryCommas.getMask();
        features |= Feature.SortFeidFastMatch.getMask();
        features |= Feature.IgnoreNotMatch.getMask();
        DEFAULT_PARSER_FEATURE = features;
}

@Test
    public void printFastJsonDefaultParserFeature() {
        for (Feature feature : Feature.values()) {
            if (Feature.isEnabled(JSON.DEFAULT_PARSER_FEATURE, feature)) {
                System.out.println(feature);
            }
        }
    }

public static String toJSONString(Object object);
public static String toJSONString(Object object, SerializerFeature... features);
public static String toJSONStringWithDateFormat(Object object, String dateFormat, SerializerFeature... features);
public static String toJSONString(Object object, boolean prettyFormat);
public static void writeJSONString(Writer writer, Object object, SerializerFeature... features);

public static String toJSONString(Object object, SerializeConfig config, SerializeFilter[] filters, String dateFormat, int defaultFeatures, SerializerFeature... features) {
         SerializeWriter out = new SerializeWriter(null, defaultFeatures, features);
         try {
             JSONSerializer serializer = new JSONSerializer(out, config);
             if (dateFormat != null && dateFormat.length() != 0) {
                 serializer.setDateFormat(dateFormat);
                 serializer.config(SerializerFeature.WriteDateUseDateFormat, true);
             }
             if (filters != null) {
                 for (SerializeFilter filter : filters) {
                     serializer.addFilter(filter);
                 }
             }
             serializer.write(object);
             return out.toString();
         } finally {
             out.close();
         }
     }

static {
        int features = 0;
        features |= SerializerFeature.QuoteFieldNames.getMask();
        features |= SerializerFeature.SkipTransientField.getMask();
        features |= SerializerFeature.WriteEnumUsingName.getMask();
        features |= SerializerFeature.SortField.getMask();
        DEFAULT_GENERATE_FEATURE = features;
        config(IOUtils.DEFAULT_PROPERTIES);
    }

@Test
    public void printFastJsonDefaultGenerateFeature() {
        for (SerializerFeature feature : SerializerFeature.values()) {
            if (SerializerFeature.isEnabled(JSON.DEFAULT_GENERATE_FEATURE, feature)) {
                System.out.println(feature);
            }
        }
    }

@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER })
public @interface JSONField {
    // 序列化和反序列化时的字段顺序，等价于jackson的@JsonProperty.index()
    int ordinal() default 0;
    // 序列化和反序列化时的字段名称映射，等价于jackson的@JsonProperty.value()
    String name() default "";
    // 序列化和反序列化时的数据格式（日期格式、16进制等等），等价于jackson的@JsonFormat.shape() + @JsonFormat.pattern()
    String format() default "";
    // 字段是否序列化，等价于jackson的@JsonProperty.access()
    boolean serialize() default true;
    // 字段是否反序列化，等价于jackson的@JsonProperty.access()
    boolean deserialize() default true;
    // 序列化特性，等价于jackson的@JsonProperty.with()
    SerializerFeature[] serialzeFeatures() default {};
    // 反序列化特性，等价于jackson的@JsonFormat.with()
    Feature[] parseFeatures() default {};
    // 对属性进行打标，便于在序列化时进行exclude或include，等价于jackson的@JsonView
    String label() default "";
    // 序列化时将字段内容直接输出，不经过转义，等价于jackson的@JsonRawValue
    boolean jsonDirect() default false;
    // 指定序列化时使用的Serializer Class，等价于jackson的@JsonSerialize
    Class<?> serializeUsing() default Void.class;
    // 指定反序列化时使用的Deserializer Class，等价于jackson的@JsonDeserialize
    Class<?> deserializeUsing() default Void.class;
    // 指定反序列化时使用的字段别名，等价于jackson的@JsonAlias
    String[] alternateNames() default {};
    // 将字段的子属性映射到父节点上，等价于jackson的@JsonUnwrapped
    boolean unwrapped() default false;
    // 指定序列化时字段为null时使用的默认值，等价于jackson的@JsonProperty.defaultValue()
    String defaultValue() default "";
}

@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE })
public @interface JSONType {
    // 是否使用asm优化，jackson无对应特性
    boolean asm() default true;
    // 序列化和反序列化时的field排序，等价于jackson的@JsonPropertyOrder.value()
    String[] orders() default {};
    // 序列化和反序列化时包含的field，等价于jackson的
    String[] includes() default {};
    // 序列化和反序列化时忽略的field，等价于jackson的@JsonIgnoreProperties
    String[] ignores() default {};
    // 序列化特性，等价于jackson的@JsonProperty.with()
    SerializerFeature[] serialzeFeatures() default {};
    // 反序列化特性，等价于jackson的@JsonFormat.with()
    Feature[] parseFeatures() default {};
    // 序列化时是否依据field字母顺序排序，等价于jackson的@JsonPropertyOrder.alphabetic()
    boolean alphabetic() default true;
    // 反序列化多态类型时，如果根据其他typeName等方式无法找到正确的子类时，默认使用的子类，等价于jackson的@JsonTypeInfo.defaultImpl()
    Class<?> mappingTo() default Void.class;
    // 反序列化时指定java bean builder类(必须是@JSONPOJOBuilder注解的类)，等价于jackson的@JsonDeserialize.builder()
    Class<?> builder() default Void.class;
    // 声明这个类型的别名，反序列化多态类型时使用，等价于jackson的@JsonTypeName
    String typeName() default "";
    // 反序列化某个接口或抽象类或父类的子类时指定根据哪个字段的值和子类的typeName相等来决定具体实现类，等价于jackson的@JsonTypeInfo.use() = Id.CUSTOM + @JsonTypeInfo.property()
    String typeKey() default "";
    // 反序列化某个接口或抽象类或父类的子类时指定可以反序列化的子类类型，等价于jackson的@JsonSubTypes
    Class<?>[] seeAlso() default{};
    // 指定序列化时使用的Serializer Class，等价于jackson的@JsonSerialize
    Class<?> serializer() default Void.class;
    // 指定反序列化时使用的Deserializer Class，等价于jackson的@JsonDeserialize
    Class<?> deserializer() default Void.class;
    // 序列化时，如果filed是枚举类型，则和普通的java bean一样输出枚举的filed，而不是通常使用的Enum.name()值，jackson没有对应特性
    boolean serializeEnumAsJavaBean() default false;
    // 指定json和Java bean之间的字段名称映射策略，等价于jackson的@JsonNaming
    PropertyNamingStrategy naming() default PropertyNamingStrategy.CamelCase;
    // 指定序列化时使用的Serialize filter，等价于jackson的@JsonFilter
    Class<? extends SerializeFilter>[] serialzeFilters() default {};
}

public class JSONObject extends JSON implements Map<String, Object>, Cloneable, Serializable, InvocationHandler {
    private final Map<String, Object> map;
    ...
}
public class JSONArray extends JSON implements List<Object>, Cloneable, RandomAccess, Serializable {
    private static final long  serialVersionUID = 1L;
    private final List<Object> list;
    protected transient Object relatedArray;
    protected transient Type   componentType;
    ...
}

<T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName);

public abstract T deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException;

void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType, int features) throws IOException;

public abstract void serialize(T value, JsonGenerator gen, SerializerProvider serializers) throws IOException;