alibaba / fastjson

FASTJSON 2.0.x has been released, faster and more secure, recommend you upgrade.

fastjson

Fastjson is a Java library that can be used to convert Java Objects into their JSON representation. It can also be used to convert a JSON string to an equivalent Java object. Fastjson can work with arbitrary Java objects including pre-existing objects that you do not have source-code of.

FASTJSON 2.0.x has been released, faster and more secure, we recommend you upgrade to the latest version.

Fastjson Goals

• Provide the best performance on the server-side and android client
• Provide simple toJSONString() and parseObject() methods to convert Java objects to JSON and vice-versa
• Allow pre-existing unmodifiable objects to be converted to and from JSON
• Extensive support of Java Generics
• Allow custom representations for objects
• Support arbitrarily complex objects (with deep inheritance hierarchies and extensive use of generic types)

Documentation

• Documentation Home
• Contributing Code
• Frequently Asked Questions
• FASTJSON 1.x User Upgrade Guid https://github.com/alibaba/fastjson2/wiki/fastjson_1_upgrade_cn

Benchmark

• Eishay benchmark https://github.com/eishay/jvm-serializers/wiki
• fastjson2 benchmark https://github.com/alibaba/fastjson2/wiki/fastjson_benchmark

Download

• maven
• the latest JAR

Maven

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>2.0.31</version>
</dependency>

Gradle via JCenter

compile 'com.alibaba:fastjson:2.0.28'

Please see this Wiki Download Page for more repository info.

License

Fastjson is released under the Apache 2.0 license.

Copyright 1999-2020 Alibaba Group Holding Ltd.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at the following link.

     http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

fastjson's Issues

fastJSON在springMVC 3.2.0.RELEASE下输出JSON报406错误

SpringMVC配置文件如下

<bean id="mappingFastJsonHttpMessageConverter"
    class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">
</bean>

在Controller中输出如下示：
@RequestMapping(value = "/hello1")
@responsebody
public List json() {
LOG.info("will response json data.");
return new ArrayList() {
/**
*
*/
private static final long serialVersionUID = 1L;

        {
            add("我爱**");
            add("我有我有祖国");
            add("Hello");
            add("Hello");
            add("我爱中华人民共和国");
            add("Hello");
        }
    };
}

FastJsonHttpMessageConverter在Spring3.2中有问题

当前版本下

<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.1.29</version>
</dependency>

在spring3.2中配置mvc:message-converters中增加FastJsonHttpMessageConverter

在@controller的方法中返回一个对象，期待被Fastjson序列化，但是出问题： (Spring3.1以下似乎没问题)

Http status code 406
The resource identified by this request is only capable of generating responses with characteristics not acceptable according to the request "accept" headers ()

经过对spring debug发现，有：

if (compatibleMediaTypes.isEmpty()) {
    throw new HttpMediaTypeNotAcceptableException(allSupportedMediaTypes);
}

因此，建议把FastJsonHttpMessageConverter的构造方法改为：

public FastJsonHttpMessageConverter() {
        super(new MediaType("application", "json", UTF8), 
               new MediaType("application", "*+json", UTF8));
}

于是，可以得到正确的json序列化。

fastjson1.1.28 反序列化带类型信息size为0的HashMap时出错

public class TestJSONMap
{
@test
public void testMap() throws Exception
{
Record record = new Record();
Map<Integer, Integer> map = new HashMap<>();
record.setRecord(map);
String s = JSON.toJSONString(record, SerializerFeature.WriteClassName);
System.out.println(s);
record = (Record)JSON.parse(s); //此处抛出异常
System.out.println(record.getRecord().size());
}

public static class Record
{
    private Map<Integer, Integer> record;

    public Map<Integer, Integer> getRecord()
    {
        return record;
    }

    public void setRecord(Map<Integer, Integer> record)
    {
        this.record = record;
    }
}

}

com.alibaba fastjson 1.1.28

有什么方便的方法解析成ArrayList

现在是com.alibaba.fastjson.JSONObject.parseObject(returnString, new TypeReference<ArrayList>(){})，有点长，有什么简写的方式吗

使用WriteClassName 自省功能能否支持List<Entity>的形式

现在的版本使用WriteClassName序列化后，list中entity的类型会保留，但list的类型就丢失了
JSON.parseObject的时候就不能正确的返回了

Deserialize generic derived class

Code fragment：

public abstract class IdObject<I> {
     private I id;
     public I getId() {
        return id;
     }
     public void setId(I id) {
        this.id = id;
     }
}
public class Child extends IdObject<Long> {
    public static void main(String[] args) {
        String str = {"id":0};
        Child child = JSON.parseObject(str, Child.class);
        System.out.println(child.getId().getClass());
    }
}

I'm using fast-json 1.1.23. The 'id' property of child should be Long, but was Integer.

I modified com.alibaba.fastjson.util.FieldInfo.java to solve this issue， but I'm not sure if such a change is appropriate：

I insert this lines at line 75:

    if (clazz != null && fieldClass == Object.class && fieldType instanceof TypeVariable) {
        TypeVariable<?> tv = (TypeVariable<?>) fieldType;
        Type genericFieldType = getInheritGenericType(clazz, tv);
        if (genericFieldType != null) {
            this.fieldClass = TypeUtils.getClass(genericFieldType);
            this.fieldType = genericFieldType;
            return;
        }
    }

and write a function:

public static Type getInheritGenericType(Class<?> clazz, TypeVariable<?> tv) {
    Type type = null;
    GenericDeclaration gd = tv.getGenericDeclaration();
    do {
        type = clazz.getGenericSuperclass();
        if (type instanceof ParameterizedType) {
            ParameterizedType ptype = (ParameterizedType) type;
            if (ptype.getRawType() == gd) {
                TypeVariable<?>[] tvs = gd.getTypeParameters();
                Type[] types = ptype.getActualTypeArguments();
                for (int i = 0; i < tvs.length; i++) {
                    if (tvs[i] == tv)
                        return types[i];
                }
                return null;
            }
        }
        clazz = TypeUtils.getClass(type);
    } while (type != null);
    return null;
}

syntax error, 序列化时启用WriteMapNullValue，对该结果反序列化则报错

public class MethodReturn{
    public Object ReturnValue;
    public Throwable Exception;
}

序列化时启用WriteMapNullValue，对该结果反序列化则报错

JSON.parseObject(JSON.toJSONString(new MethodReturn(), SerializerFeature.WriteMapNullValue), MethodReturn.class);

json如下

{"Exception":null,"ReturnValue":null}

出现值为null的字段，在声明反序列化类型则如下错误：

com.alibaba.fastjson.JSONException: syntax error
    at com.alibaba.fastjson.parser.deserializer.ThrowableDeserializer.deserialze(ThrowableDeserializer.java:31)
    at Fastjson_ASM_MethodReturn_1.deserialze(Unknown Source)
    at com.alibaba.fastjson.parser.DefaultJSONParser.parseObject(DefaultJSONParser.java:485)
    at com.alibaba.fastjson.JSON.parseObject(JSON.java:235)
    at com.alibaba.fastjson.JSON.parseObject(JSON.java:188)
    at com.alibaba.fastjson.JSON.parseObject(JSON.java:321)
    at com.taobao.top.link.remoting.JsonSerializerTest.null_test(JsonSerializerTest.java:22)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
    at java.lang.reflect.Method.invoke(Unknown Source)
    at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:44)
    at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)
    at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:41)
    at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20)
    at org.junit.runners.BlockJUnit4ClassRunner.runNotIgnored(BlockJUnit4ClassRunner.java:79)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:71)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:49)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:193)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:52)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:191)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:42)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:184)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:236)
    at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50)
    at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)

com.alibaba.fastjson.parser.Feature中似乎没有关于此的开关设置？

反序列化时出现NullPointerException

你好，我在使用fastjson作Clojure RPC的序列化支持，我通过

(JSON/toJSONString {:a 1} (into-array Serializer/WriteClassName))

得到JSON字符串

{"@type":"clojure.lang.PersistentArrayMap",{"@type":"clojure.lang.Keyword","name":"a","sym":{"name":"a"}}:1}

然后通过parse进行反序列化遇到这个空指针异常

No message.
[Thrown class com.alibaba.fastjson.JSONException]

Restarts:
0: [QUIT] Quit to the SLIME top level
1: [CAUSE1] Invoke debugger on cause [Thrown class java.lang.NullPointerException]

Backtrace:
0: com.alibaba.fastjson.parser.deserializer.DefaultObjectDeserializer.deserialze(DefaultObjectDeserializer.java:349)
1: com.alibaba.fastjson.parser.deserializer.DefaultObjectDeserializer.deserialze(DefaultObjectDeserializer.java:251)
2: com.alibaba.fastjson.parser.DefaultJSONParser.parseObject(DefaultJSONParser.java:251)
3: com.alibaba.fastjson.parser.AbstractJSONParser.parse(AbstractJSONParser.java:157)
4: com.alibaba.fastjson.parser.AbstractJSONParser.parse(AbstractJSONParser.java:135)
5: com.alibaba.fastjson.JSON.parse(JSON.java:87)
6: com.alibaba.fastjson.JSON.parse(JSON.java:78)
7: slacker.serialization.fastjson$parse_string.invoke(fastjson.clj:6)
8: user$eval1853.invoke(NO_SOURCE_FILE:1)
9: clojure.lang.Compiler.eval(Compiler.java:5424)
--more--

我使用的是maven仓库的1.1.9版本。

关于循环引用 SerializerFeature.DisableCircularReferenceDetect 的建议

提一个“重复引用” 情形：
Class B {
..
}

Class A {
B b;
...
}

B b = new B();
A a1 = new A();
A a2 = new A();
a1.setB(b);
a2.setB(b);

a1,a2 里面的 b 指向同一个对象；

这就是所谓的重复引用；

我想“重复引用”跟“循环引用”还是不一样，没有导致引用的回路（或递归），这种情况我想应该是允许的，实际应用中这种情况也挺多的（比如 hibernate 中的一对多，多对多）

如果把这种情况也 $ref 掉的话，无疑是增加了前端的代码量，所以建议这种情况按正常处理；

虽然可以加 DisableCircularReferenceDetect， 但总是不怎么保险

1.1.31 android 专版不需要提供?

从maven 库那里看到,从27 以后,的版本,都不提供了android专版了,是不是不用更新?

好多天了。。。。。

contextArray中丢失数组路径

搞死我了.

如果, 根是一个[]数组, 下面是一组{a:{b:c},d:{e:f}}, 会导致contextArray中的路径丢失, 即:原本应该是$[0].a.b, $[0].d.e, 丢失后变成$[0].a.b, $.d.e, 从而导致后面对无法取到$[0].d.e引用的值.

原因:

在425行setContext(context, obj, key); 重新设置了context, 而key不是最开始传进来的数组编号, 而是{}属性名, 从而导致在生成路径是判断非Integer, 因此丢失[0].

修改:
if (!setContextFlag) {
setContextFlag = true;
setContext(context, obj, key);
}

加上这个判断就可以了.

修改后还是有点奇怪的地方, 见下面,$[5][5], 搞不懂, 也没去研究.

,$[5].files
,$[5].files[0]
,$[5].files[0].docType
,$[5].files[0].fileType
,$[5].type
,$[5][5]
,$[6]
,$[6].files
,$[6].files[0]
,$[6].files[0].status
,$[6][6]
,$[7]
,$[7].files
,$[7].files[0]
,$[7].type
,$[8]
,$[8].files

修改前的路径 👍

[$
,$[0]
,$[0].source
,$.source
,$.source.type
,$.type
,$.type.version
,$.version
,$[1]
,$[1].files
,$[1].files[0]
,$[1].files[0].docType
,$[1].files.docType
,$[1].files.docType.fileType
,$[1].files.fileType
,$[1].files.fileType.status
,$[1].files.status
,$.source
,$.source.type
,$.type
,$.version
,$[2]
,$[2].files
,$[2].files[0]
,$[2].files[0].docType
,$[2].files.docType
,$[2].files.docType.fileType
,$[2].files.fileType
,$[2].files.status
,$.source
,$.type
,$.version
,$[3]
,$.source
,$.source.type
,$.type
,$.version
,$[4]

json seriliazble error for \u2028 charactor

json seriliazble error for \u2028 charactor when string content has this special charactor

NonScientificDoubleSerializer

I prefer to use this serializer for doubles to avoid e-notation. Maybe you would like to include it as an option in the distribution?

class NonScientificDoubleSerializer extends DoubleSerializer {

    DecimalFormat format = new DecimalFormat("###.#########");

    public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType) throws IOException {
        Double value = (Double) object;
        SerializeWriter out = serializer.getWriter();

        if (value == null || value.isNaN() || value.isInfinite())
            out.writeNull();
        else
            out.append(format.format(value));
    }
}

该Json无法解析

{
"track": [
{
"name": "Android",
"color": "#A6BC40",
"abstract": "Learn about developing mobile handset and tablet apps for Android."
},
{
"name": "Chrome",
"color": "#46B0E2",
"abstract": "Build for the modern web with the Chrome platform."
},
{
"name": "Cloud Platform",
"color": "#2076BC",
"abstract": "Learn about Google's cloud offerings for developers."
},
{
"name": "Code Labs",
"color": "#E4388F",
"abstract": "Get your hands dirty in longer, classroom-style sessions. Bring your laptop. Write code."
},
{
"name": "Commerce",
"color": "#4CAA47",
"abstract": "Learn how to use Google Commerce products to improve monetization on the web, in app, and in store."
},
{
"name": "Entrepreneurship",
"color": "#97B0DA",
"abstract": "Talks on topics related to startups, venture capital, and entrepreneurship."
},
{
"name": "Google APIs",
"color": "#00773F",
"abstract": "Learn about Google's various developer platforms."
},
{
"name": "Google Drive",
"color": "#F5851F",
"abstract": "Learn to develop for Google Drive and Google Apps Script."
},
{
"name": "Google Maps",
"color": "#4CAA47",
"abstract": "Leverage the power of Google's geospatial technology in your apps."
},
{
"name": "Google TV",
"color": "#37505C",
"abstract": "Build apps for the big screen. Learn about developing for Google TV."
},
{
"name": "Google+",
"color": "#DC4E30",
"abstract": "Learn about developing on the Google+ platform."
},
{
"name": "Tech Talk",
"color": "#A1609D",
"abstract": "Tech talks on subjects such as computer science problems, programming languages, and more."
},
{
"name": "YouTube",
"color": "#E72C2E",
"abstract": "Learn about developing for YouTube."
}
]
}

对属性命名中第一个单词只有一个字母的属性无法序列化

如User对象中tName属性，它的get方法是 gettName();这种情况下均无法序化。

getpId()的情况

getpId() 目前在最新版本中不能生成到json字符串中，还有javabean的规范不是这样的吗？

pid getPid

PId getPId

pId getpId

Pid error

现在比如(ZTree.java)

public class ZTree<ID extends Serializable> implements Serializable {
    private ID id;
    private ID pId;
    private String name;
    private String iconSkin;
    private boolean open;
    private boolean root;
    private boolean isParent;
    private boolean nocheck = false;

    public ID getId() {
        return id;
    }

    public void setId(ID id) {
        this.id = id;
    }

    public ID getpId() {
        return pId;
    }

    public void setpId(ID pId) {
        this.pId = pId;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getIconSkin() {
        return iconSkin;
    }

    public void setIconSkin(String iconSkin) {
        this.iconSkin = iconSkin;
    }

    public boolean isOpen() {
        return open;
    }

    public void setOpen(boolean open) {
        this.open = open;
    }


    public boolean isRoot() {
        return root;
    }

    public void setRoot(boolean root) {
        this.root = root;
    }

    public boolean isIsParent() {
        return isParent;
    }

    public void setIsParent(boolean isParent) {
        this.isParent = isParent;
    }

    public boolean isNocheck() {
        return nocheck;
    }

    public void setNocheck(boolean nocheck) {
        this.nocheck = nocheck;
    }

    public static void main(String[] args) {
        ZTree<Long> zTree = new ZTree<Long>();
        zTree.setId(123L);
        zTree.setpId(123L);
        System.out.println(JSONObject.toJSONString(zTree));
    }
}

得到
{"id":123,"isParent":false,"nocheck":false,"open":false,"root":false}

格式 map<String, List<Bean>> ,其中某些Bean被多个list引用，反序列化后部分list的bean值为null。

测试代码：

fastjson序列化代码

    @Test
    public void testSerialAndUnSerial() throws Exception {
        Map<String, List<JSONTestBean>> map = new HashMap<String, List<JSONTestBean>>();

        JSONTestBean bean1 = new JSONTestBean();
        bean1.setId("1");
        bean1.setName("name1");

        JSONTestBean bean2 = new JSONTestBean();
        bean2.setId("2");
        bean2.setName("name2");

        JSONTestBean bean3 = new JSONTestBean();
        bean3.setId("3");
        bean3.setName("name3");

        List<JSONTestBean> beans1 = new ArrayList<JSONTestBean>();
        beans1.add(bean1);
        beans1.add(bean2);

        List<JSONTestBean> beans2 = new ArrayList<JSONTestBean>();
        beans2.add(bean1);
        beans2.add(bean3);

        map.put("beans1", beans1);
        map.put("beans2", beans2);

        String expectedStr = JSONObject.toJSONString(map, SerializerFeature.WriteClassName, SerializerFeature.PrettyFormat);

        Map<String, List<JSONTestBean>> unSerialMap = JSONObject.parseObject(expectedStr, new TypeReference<Map<String, List<JSONTestBean>>>() {
        });

        String actualStr = JSONObject.toJSONString(unSerialMap, SerializerFeature.WriteClassName, SerializerFeature.PrettyFormat);
        assertEquals(expectedStr, actualStr);
    }

    static class JSONTestBean {
        private String id;
        private String name;

        public String getId() {
            return id;
        }

        public void setId(String id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }

jackson序列化代码

@Test
    public void testJacksonSerialAndUnSerial() throws Exception {
        Map<String, List<JSONTestBean>> map = new HashMap<String, List<JSONTestBean>>();

        JSONTestBean bean1 = new JSONTestBean();
        bean1.setId("1");
        bean1.setName("name1");

        JSONTestBean bean2 = new JSONTestBean();
        bean2.setId("2");
        bean2.setName("name2");

        JSONTestBean bean3 = new JSONTestBean();
        bean3.setId("3");
        bean3.setName("name3");

        List<JSONTestBean> beans1 = new ArrayList<JSONTestBean>();
        beans1.add(bean1);
        beans1.add(bean2);

        List<JSONTestBean> beans2 = new ArrayList<JSONTestBean>();
        beans2.add(bean1);
        beans2.add(bean3);

        map.put("beans1", beans1);
        map.put("beans2", beans2);

        ObjectMapper mapper = new ObjectMapper();
        String expectedStr = mapper.writeValueAsString(map);

        Map<String, List<JSONTestBean>> unSerialMap = mapper.readValue(expectedStr, new org.codehaus.jackson.type.TypeReference<Map<String, List<JSONTestBean>>>() {
        });

        String actualStr = mapper.writeValueAsString(unSerialMap);
        assertEquals(expectedStr, actualStr);
        System.out.println( expectedStr);
    }

序列化结果

    {
     "beans2":[{"id":"1","name":"name1"},{"id":"3","name":"name3"}],
     "beans1":[{"id":"1","name":"name1"},{"id":"2","name":"name2"}]
    }

不加引号的key中不能包含-字符

VER1.1.34

JSON.parseObject("{zh-cn:8}");

这样会报错，是否可以支持不加引号的key中包含-字符呢？

对于变量名类似为pId类的变量，用33版本的fastjson转换后会变成PId，用23版本的fastjson正常

用了最新的33版本的fastjson后，对于一个小写字母加大写字母组合的变量，fastjson转换后会把首字母转成大写。之前是用23版本的是正常的

测试类如下：
public class FastJsonTest {
public static void main(String[] args){
FastJsonTest jsonTest = new FastJsonTest();
TestInfo ts = jsonTest.new TestInfo();
ts.setPId("aa");
System.out.println(JSON.toJSONString(ts));
System.out.println(ts.getPId());
}

private class TestInfo{
    String pId="1";
    String t_id="2";
    String uName="abc";
    public String getPId() {
        return pId;
    }
    public void setPId(String pId) {
        this.pId = pId;
    }
    public String getT_id() {
        return t_id;
    }
    public void setT_id(String t_id) {
        this.t_id = t_id;
    }
    public String getUName() {
        return uName;
    }
    public void setUName(String uName) {
        this.uName = uName;
    }

}

}

@JSONField定制输出key失效

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.1.28</version>
        </dependency>

class KeyBug {
    @JSONField(name = "uid")
    public final int id;

    KeyBug(int id) {this.id = id;}
}

@Test
public void testCustomedKey() throws Exception {
    assertThat(JSON.toJSONString(new KeyBug(1)), is("{\"uid\":1}"));
}

java.lang.AssertionError: 
Expected: is "{\"uid\":1}"
     got: "{\"id\":1}"

_开头的字段必须为public才能正常解析

rails mongoid 模型主键默认是_id
尝试改为public才能正常decode
这属于bug还是基于安全性什么的考虑吗?

对内部类序列化正常，反序列化报错

Caused by: java.lang.NullPointerException
at com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer.createInstance(JavaBeanDeserializer.java:102)

对于某些特殊字符串，使用fastjson序列后的字符串无法使用org.json或者python里面的json进行解析？

在使用中发现，如果对使用fastjson序列化后的字符串，用java的其他json包如org.json或者使用python的json包进行解析时，在某些情况下会出现错误。而反过来则不会。比如：[{"Name":"Operator","Value":"**移动 "}] **移动后面的字符为特殊字符。当使用fastjson序列化后的结果在vim中打开显示为“^@”， 而org.json的为"\u001"。

FastJsonHttpMessageConverter 類中 serializerFeature 屬性 set 方法命名不規範

在 FastJsonHttpMessageConverter 類中 serializerFeature 屬性的 set 方法名爲 : setFeatures ，而不是 setSerializerFeature 。若通過 Spring 注入時使用 serializerFeature 會報錯。雖然用 features 也行，但還是希望能按規範命名。

当对象同时关联一个对象的时候解析出来的数据有问题

解析的结果数据：
[{"children":[],"fun":{"children":[],"id":"fun1","text":"fun1"},"id":"1","text":"1"},{"children":[],"fun":{"$ref":"$[0].fun"},"id":"2","text":"2"}].
注意里面的"fun":{"$ref":"$[0].fun"}，这里我希望得到的值是"fun":{"children":[],"id":"fun1","text":"fun1"}，即数组中第一个对象的fun属性。，下面是转换代码：
public class Test {
/**
* @author mawujun
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Fun fun=new Fun();
fun.setId("fun1");
fun.setText("fun1");

    MenuItem item1=new MenuItem();
    item1.setId("1");
    item1.setText("1");
    item1.setFun(fun);

    MenuItem item2=new MenuItem();
    item2.setId("2");
    item2.setText("2");
    item2.setFun(fun);
    List<MenuItem> funes=new ArrayList<MenuItem>();
    funes.add(item1);
    funes.add(item2);

    SerializeWriter out = new SerializeWriter();
    JSONSerializer serializer = new JSONSerializer(out);  
    serializer.write(funes);
    System.out.println(serializer.toString());

}

}
item1和item2都应用了实例fun，这个时候通过fastjson转换就造成了上面的问题，而且这个数据我是必须要的，是不是我写法有问题还是怎么样？请帮忙看看。
我想应该是循环引用处理方案 引起的问题。

TypeUtils.castDate error

TypeUtils.castDate("2011-01-22 12:11:00") error

java bean序列化问题

JSON.parseObject(String text,Class clazz)

方法反序列化时是不是只支持标准格式的setter的java bean？我写一个了一append模式setter的bean实例，属性设置都是null

setter的模式如下，如果需要反序列化这种模式的bean，ParseConfigure该怎么设置呢

class Test
{
     private String content;
     public Test setContent(String content)
     {
             this.content = content;
             return this;
     }
}

为啥相同的操作，fastjson比net.sf.json慢很多，前者要412毫秒，后者只有16毫秒，求解释

@Test
public void test() {
    String s = RClassPath.toStr("/org/n3r/json/t.json");

    com.alibaba.fastjson.JSONObject json = new com.alibaba.fastjson.JSONObject();
    json.put("app_id", "1234567890");
    json.put("format", "json");
    json.put("rsp_code", "0000");
    json.put("msg", s);
    long l1 = System.currentTimeMillis();
    String tt = json.toJSONString();
    long l2 = System.currentTimeMillis();
    System.out.println(l2 - l1);
}

@Test
public void test2() {
    String s =RClassPath.toStr("/org/n3r/json/t.json");

    net.sf.json.JSONObject json = new net.sf.json.JSONObject();
    json.put("app_id", "1234567890");
    json.put("format", "json");
    json.put("rsp_code", "0000");
    json.put("msg", s);
    long l1 = System.currentTimeMillis();
    String tt = json.toString();
    long l2 = System.currentTimeMillis();
    System.out.println(l2 - l1);
}

// t.json 见http://www.kuaipan.cn/file/id_50672071402850291.htm

    <dependency>
        <groupId>net.sf.json-lib</groupId>
        <artifactId>json-lib</artifactId>
        <version>2.4</version>
        <classifier>jdk15</classifier>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.1.27</version>
    </dependency>

deserialize public-long field error?

package demo;

import com.alibaba.fastjson.JSON;

public class FJDemo {
public long id;

public static void main(String[] args) throws Exception {
    FJDemo se = new FJDemo();
    se.id = 1000;
    String str = JSON.toJSONString(se);
    System.out.println(str);
    se = JSON.parseObject(str, FJDemo.class);
}

}

---

{"id":1000}
Exception in thread "main" com.alibaba.fastjson.JSONException: create asm deserializer error, demo.FJDemo
at com.alibaba.fastjson.parser.ParserConfig.createJavaBeanDeserializer(ParserConfig.java:405)
at com.alibaba.fastjson.parser.ParserConfig.getDeserializer(ParserConfig.java:344)
at com.alibaba.fastjson.parser.ParserConfig.getDeserializer(ParserConfig.java:271)
at com.alibaba.fastjson.parser.DefaultJSONParser.parseObject(DefaultJSONParser.java:468)
at com.alibaba.fastjson.JSON.parseObject(JSON.java:211)
at com.alibaba.fastjson.JSON.parseObject(JSON.java:171)
at com.alibaba.fastjson.JSON.parseObject(JSON.java:292)
at demo.FJDemo.main(FJDemo.java:13)
Caused by: java.lang.NullPointerException
at com.alibaba.fastjson.parser.deserializer.ASMDeserializerFactory._batchSet(ASMDeserializerFactory.java:515)
at com.alibaba.fastjson.parser.deserializer.ASMDeserializerFactory._deserialze(ASMDeserializerFactory.java:370)
at com.alibaba.fastjson.parser.deserializer.ASMDeserializerFactory.createJavaBeanDeserializer(ASMDeserializerFactory.java:85)
at com.alibaba.fastjson.parser.ParserConfig.createJavaBeanDeserializer(ParserConfig.java:401)
... 7 more

使用的是9月4日从github.com/AlibabaTech/fastjson/下载的源码，不清楚是哪个版本。

通篇一个注释都没有

佩服。....

what the license?

Hello,
I havent found anything suggesting the liense used for fastjson. If you havent decided yet please consider Apachae Liscense.

Split data binding facility from serializer/deserializer

I propose to split data binding facility from serializer/deserializer. It allows to use project code for various goals, such as data transformation between object and map or objects with different structure (like https://github.com/DozerMapper/dozer)

可不可以增加输出字符串为unicode的SerializerFeature

不设置，输出为

{"name":"你好"}

设置后，输出为

{"name":"\u4f60\u597d"}

温少啊，小弟求1.1.31 android 专版哟?

您好温少：

    多考虑照顾一下我们Android这边吧，期待android最新版发布哟

有什么设置 可以在toJSONString的时候让所有的key大写或者小写没

需要转换的 是 一个map对象

NullPointerException for public fields

The following code:

public class JsonLiteTest {
    public static class Naked {
        public int field;
    }

    @Test
    public void testNakedFields() throws  Exception {
        Naked naked = new Naked();
        DefaultJSONParser parser = new DefaultJSONParser("{ \"field\": 3 }");
        parser.parseObject(naked);
    }
}

fails with this exception:

java.lang.NullPointerException
    at com.alibaba.fastjson.parser.DefaultJSONParser.parseObject(DefaultJSONParser.java:772)

Creating a setter method fixes the issue. Version 1.1.34

support SortedSet

I can't create a bean with a SortedSet using fastjson 1.1.32 because I get this exception:

Caused by: com.alibaba.fastjson.JSONException: create instane error, class java.util.SortedSet
    at com.alibaba.fastjson.parser.deserializer.CollectionDeserializer.deserialze(CollectionDeserializer.java:41)
    at com.alibaba.fastjson.parser.deserializer.DefaultFieldDeserializer.parseField(DefaultFieldDeserializer.java:26)
    at com.alibaba.fastjson.parser.deserializer.ASMJavaBeanDeserializer.parseField(ASMJavaBeanDeserializer.java:82)
    at com.alibaba.fastjson.parser.deserializer.ASMJavaBeanDeserializer$InnerJavaBeanDeserializer.parseField(ASMJavaBeanDeserializer.java:94)
    at com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer.deserialze(JavaBeanDeserializer.java:263)
    at com.alibaba.fastjson.parser.deserializer.ASMJavaBeanDeserializer.parseRest(ASMJavaBeanDeserializer.java:104)
    at Fastjson_ASM_InrMeta_1.deserialze(Unknown Source)
    at com.alibaba.fastjson.parser.DefaultJSONParser.parseObject(DefaultJSONParser.java:500)
    at com.alibaba.fastjson.parser.DefaultJSONParser.parseObject(DefaultJSONParser.java:487)

I can use a TreeSet as a workaround.

使用WriteClassName进行序列化的json串, 在无该类的环境下无法进行反序列化

版本1.1.14

请问JSONObject是否保证序列化后按照key的字典序排序？

看实现是hashmap，但测试结果却貌似是字典序？
我的测试是压入n个字符。

这个特性是否存在？主要是目前碰到需要这个特性的场景，如果有的话，就不用再加工了。谢谢！

如何转换List<Object[]>对象成JsonString呀？

NEED a util/JSONStringer class

如题

fastjson / android

can fastjson be made to work on android?

JSONObject.toJavaObject() 对于属性是Calendar，转换成java对象时报错！

JSONObject.toJavaObject(json, myObject.class);对于属性是Calendar，转换成java对象时报错！
报的错如下：
com.alibaba.fastjson.JSONException: Class com.alibaba.fastjson.util.TypeUtils can not access a member of class java.util.Calendar with modifiers "protected"
at com.alibaba.fastjson.util.TypeUtils.castToJavaBean(TypeUtils.java:710)
at com.alibaba.fastjson.util.TypeUtils.cast(TypeUtils.java:445)
at com.alibaba.fastjson.JSON.toJavaObject(JSON.java:601)
at com.tongbor.infra.common.utils.FastJsonTest.testToJavaObject(FastJsonTest.java:28)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:597)
at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:45)
at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)
at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:42)
at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20)
at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:263)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:68)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:47)
at org.junit.runners.ParentRunner$3.run(ParentRunner.java:231)
at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:60)
at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:229)
at org.junit.runners.ParentRunner.access$000(ParentRunner.java:50)
at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:222)
at org.junit.runners.ParentRunner.run(ParentRunner.java:300)
at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50)
at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)
Caused by: com.alibaba.fastjson.JSONException: Class com.alibaba.fastjson.util.TypeUtils can not access a member of class java.util.Calendar with modifiers "protected"
at com.alibaba.fastjson.util.TypeUtils.castToJavaBean(TypeUtils.java:710)
at com.alibaba.fastjson.util.TypeUtils.cast(TypeUtils.java:445)
at com.alibaba.fastjson.util.TypeUtils.cast(TypeUtils.java:576)
at com.alibaba.fastjson.util.TypeUtils.castToJavaBean(TypeUtils.java:703)
... 26 more
Caused by: java.lang.IllegalAccessException: Class com.alibaba.fastjson.util.TypeUtils can not access a member of class java.util.Calendar with modifiers "protected"
at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:65)
at java.lang.Class.newInstance0(Class.java:349)
at java.lang.Class.newInstance(Class.java:308)
at com.alibaba.fastjson.util.TypeUtils.castToJavaBean(TypeUtils.java:695)
... 29 more

allowing setters with return values

Hey, I like to code my objects to allow setters with return values and was wondering what would be necessary to allow this with fastjson as it ignores that in the com / alibaba / fastjson / util / DeserializeBeanInfo.java at Line 162

            if (!method.getReturnType().equals(Void.TYPE)) {
                continue;
            }

If I just remove that line it throws an error complaining about the stack.length not being zero... haven't dived in enough to understand what happens there. but i would really love to be able to write user.setId(10).setName("John") etc. :)

Reference Parse Error

JSON.parseArray method parse reference error.

deserialize does not work expected when @type is not the first element.

I have a class with two properties: firstName and lastName (will full getters and setters).

JSON.parse("{"firstName":"first","@type":"demo.JsonTest$JSONDemo","lastName":"last"}");

will ignore firstName left it null value.

Is this a bug or designed?

@JSONField(serialize=false) on Field not fixed completely

TypeUtils.java line 962

When getter method name starts with "is", serialize=false not effected yet.

toJSONStringWithDateFormat不能覆盖@JsonField中的format

toJSONStringWithDateFormat不能覆盖@JsonField中的format
在其他方法中需要更改formatter的时候需要自己手动put

序列化字符串为JSONObject中如果key类型为数字报CastException

关于_DefaultJSONParser_这个类的parseObject方法在下有一点建议，因为今天用fastjson反序列化为JSONObject的时候遇到这样一个问题，就是如果key如果为数字类型的话，就会报类型转换错误，因为JSONObject只支持String的key类型，所以我想387行处，将new JSONObject()的功能放开，让子类去选择生成一个什么样的Map，希望这个功能能够加入到fastjson中，这将对我们很有用，谢谢

boolean类型字段JSONField指定name无效

@JSONField(name = "is-abc")
private boolean isAbc;

public boolean isAbc() {
     return isAbc;
 }

最后序列化出来的不是is-abc，而是abc。
在TypeUtils中根据方法名猜测属性名的时候，对boolean类型以is开头的方法，是否可以先直接查找等于方法名的属性名，然后再去掉is查找属性名？另外，定义在属性上面的@JSONField是否可以直接读取属性相关信息进行序列化，不从相应方法中获取信息再进行序列化？
这个场景中，如果fastjson不做修改，有两种办法可以使@JSONField生效，1是将isAbc属性改成abc，2是将注解放到方法上面，都有点强制约定的感觉了。