Jansson是一个用于解码、编码、操控JSON的C库。其特性为：

1. 简单直观的API和数据模型
2. 没有依赖项
3. 完整的Unicode支持（UTF-8）

Jansson使用cmake作为构建工具。可以执行下面的命令构建：

git clone https://github.com/akheron/jansson
cd jansson
mkdir build && cd build
cmake -DCMAKE_INSTALL_PREFIX:STRING=/home/alex/CPP/lib/jansson/2.9 -DJANSSON_BUILD_DOCS=OFF ..
cmake --build . -- install

上述命令执行后，Jansson的头文件和静态库被安装到/home/alex/CPP/lib/jansson/2.9目录

这里我们创建一个CMake工程：

cmake_minimum_required(VERSION 3.6)
project(jansson_demo C)
set(SOURCE_FILES main.c)
include_directories(/home/alex/CPP/lib/jansson/2.9/include)
add_executable(jansson_demo ${SOURCE_FILES})
set_property(TARGET jansson_demo PROPERTY C_STANDARD 99)
target_link_libraries(jansson_demo /home/alex/CPP/lib/jansson/2.9/lib/libjansson.a)

下面的代码展示了如何把字符串解码为json_t结构：

#include <jansson.h>
#include <assert.h>

int main() {
    char *text = "{ \"name\":\"汪震\", \"age\":30, \"children\":[ \"彩彩\", \"当当\" ] }";
    json_error_t error;
    // json_t用于引用任何JSON节点
    json_t *root = json_loads( text, 0, &error );
    // 如果读取失败，自动置为空指针
    if ( !root ) {
        fprintf( stderr, "error: on line %d: %s\n", error.line, error.text );
        return 1;
    } else {
        // json_is_*宏用于判断数据类型
        // 处理JSON对象
        assert( json_is_object( root ));
        json_t *name, *age, *children;
        name = json_object_get( root, "name" );
        age = json_object_get( root, "age" );
        fprintf( stdout, "NAME: %s, AGE: %d\n", json_string_value( name ), json_integer_value( age ));
        children = json_object_get( root, "children" );
        // 处理JSON数组
        assert( json_is_array( children ));
        int sof = json_array_size( children );
        for ( int i = 0; i != sof; i++ ) {
            json_t *child = json_array_get( children, i );
            fprintf( stdout, "CHILDREN: %s\n", json_string_value( child ));
        }
        // 减小引用计数，导致资源回收
        json_decref( root );
    }
    return 0;
}

运行上述代码后输出：

NAME: 汪震, AGE: 30
CHILDREN: 彩彩
CHILDREN: 当当

下面的代码展示了如何把json_t结构编码为字符串：

json_t *root = json_pack( "{sssis[ss]}", "name", "汪震", "age", 30, "children", "彩彩", "当当" );
char *text = json_dumps( root, JSON_INDENT( 4 ) | JSON_SORT_KEYS );
fprintf( stdout, "%s\n", text );

运行上述代码后输出：

{
    "age": 30,
    "children": [
        "彩彩",
        "当当"
    ],
    "name": "汪震"
}

下面的代码展示了如何把零散数据打包（pack）为json_t结构：

assert( json_is_integer( json_pack( "i", 1 )));
assert( json_is_array(
        // jansson使用格式限定符来指定要创建的JSON的JSON节点的类型
        // 下面的例子创建三元素的数组：字符串、字符串、布尔值
        json_pack( "[ssb]", "foo", "bar", 1 )
));
/* 打包一个空对象 */
json_pack( "{}" );
/* 打包出 {age:30,childNum:2} */
json_pack( "{sisi}", "age", 30, "childNum", 2 );
/* 打包出 [[1, 2], {"num": true}] */
json_pack( "[[i,i],{s:b}]", 1, 2, "num", 1 );
return 0;

可用的格式限定符如下表：

下面的代码展示了如何把json_t结构解包为零散数据： 

json_t *root = json_pack( "{sssis[ss]}", "name", "汪震", "age", 30, "children", "彩彩", "当当" );
char *name;
int age;
// 可以仅仅解包一部分
json_unpack( root, "{sssi}", "name", &name, "age", &age );
fprintf( stdout, "NAME: %s, AGE:%d\n", name, age );

The post 使用Jansson处理JSON appeared first on 绿色记忆.

Jackson JSON 提供了一系列API，便于Java程序读写JSON字符串。它具有强大对数据绑定能力，可以方便的在Java对象和JSON字符串之间进行转换。

代码示例：

ObjectMapper mapper = new ObjectMapper();
// 启用缩进，更易读
mapper.configure(SerializationFeature.INDENT_OUTPUT, true);
// 输出Map类型时，以键排序
mapper.configure(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS, true);
// 日期对象的默认输出格式
mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd"));

/**
 * Java字段名/属性名到JSON字段的映射策略
 */
mapper.setPropertyNamingStrategy( new PropertyNamingStrategy() {
    public String nameForField( MapperConfig config, AnnotatedField field, String defaultName ) {
        if ( field.getFullName().equals( "cc.gmem.vo.Entity#name" ) )
            return "Entity-Name";
        return super.nameForField( config, field, defaultName );
    }

    public String nameForGetterMethod( MapperConfig config, AnnotatedMethod method, String defaultName ) {
        if ( method.getAnnotated().getDeclaringClass().equals( Entity.class ) && defaultName.equals( "no" ) )
            return "Entity-No";
        return super.nameForGetterMethod( config, method, defaultName );
    }
} );
// 忽略空属性/字段
mapper.setSerializationInclusion(Include.NON_EMPTY);
// 把entity转换为JSON然后写入标准输出
mapper.writeValue(System.out, entity);

示例代码：

// 此工厂用于创建JsonNode对象
JsonNodeFactory factory = new JsonNodeFactory( false );
// 此工厂用于创建JSON的生成器、解析器
JsonFactory jsonFactory = new JsonFactory();
// 写入到标准输出
JsonGenerator generator = jsonFactory.createGenerator( System.out );
ObjectMapper mapper = new ObjectMapper();
// 根节点
ObjectNode entity = factory.objectNode();
entity.put( "name", "entityname" );
mapper.writeTree( generator, entity );

这种方式很不直观，但是节约内存：

JsonFactory factory = new JsonFactory();
JsonGenerator generator = factory.createGenerator(new FileWriter(new File("entity.json")));


generator.writeStartObject();
generator.writeFieldName("name");
generator.writeString("Alex");
generator.writeFieldName("dataset");

generator.writeStartArray();
generator.writeStartObject();
generator.writeStringField("zip", "223442");
generator.writeEndObject();
generator.writeEndArray();
generator.writeEndObject();

generator.close();

Jackson提供了一种底层API，允许逐符号的处理JSON：

JsonFactory factory = new JsonFactory();
JsonParser parser = factory.createParser( "{ addresses: [ { zip: 223442 } ] }" );
// 允许非标准的JSON格式：不带引号的字段名
parser.configure( JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true );
while ( !parser.isClosed() ) {
    // 获取下一个解析得到的记号
    JsonToken token = parser.nextToken();
    // 没有下一个记号，说明解析完毕
    if ( token == null ) break;
    // 寻找名为addresses的字段
    if ( JsonToken.FIELD_NAME.equals( token ) && "addresses".equals( parser.getCurrentName() ) ) {
        // 期望下一个符号是数组开始
        token = parser.nextToken();
        if ( !JsonToken.START_ARRAY.equals( token ) ) break;
        // 期望下一个符号是对象开始
        token = parser.nextToken();
        if ( !JsonToken.START_OBJECT.equals( token ) ) break;
        while ( true ) {
            token = parser.nextToken();
            if ( token == null ) break;
            if ( JsonToken.FIELD_NAME.equals( token ) && "zip".equals( parser.getCurrentName() ) ) {
                token = parser.nextToken();
                System.out.println( parser.getText() );
            }

        }

    }

}

ObjectMapper mapper = new ObjectMapper();
mapper.configure( JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true )

JsonNode node = mapper.readTree( "{ addresses: [ { zip: 223442 } ] }" );
Iterator<String> fieldNames = node.fieldNames();
while ( fieldNames.hasNext() ) {
    String fieldName = fieldNames.next();
    System.out.println( fieldName );
    JsonNode el = node.get( fieldName );
    if ( el instanceof ArrayNode ) {
        ArrayNode ael = (ArrayNode) el;
        ael.forEach( n -> {
            System.out.println( n );
        } );
    }
}

ObjectMapper mapper = new ObjectMapper();
// 缩进（漂亮输出pretty-printing
mapper.enable(SerializationFeature.INDENT_OUTPUT);
// 禁止把日期类型串行化为数字时间戳
mapper.disable( SerializationFeature.WRITE_DATES_AS_TIMESTAMPS );
// 遇到里面没有任何可访问字段/属性的对象时怎么办，禁用后将这种对象串行化为{}
mapper.disable( SerializationFeature.FAIL_ON_EMPTY_BEANS );
// 遇到不可映射的属性时，是否报错
mapper.disable( DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES );
// 允许把空串绑定到null值
mapper.enable( DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT );
// 允许非标准的JSON格式：使用单引号
mapper.configure( JsonParser.Feature.ALLOW_SINGLE_QUOTES, true );
// 允许非标准的JSON格式：不带引号的字段名
mapper.configure( JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true );
// 允许JSON中的C/C++风格的注释
mapper.configure(JsonParser.Feature.ALLOW_COMMENTS, true);
// 启用非ASCI字符（默认启用）
mapper.configure( JsonGenerator.Feature.ESCAPE_NON_ASCII, false );

// 绑定为特定类型
Entity entity = mapper.readValue(json, Entity.class);
// 默认自动转换为Map或者List之类集合对象
Map entity = mapper.readValue(json);

Jackson有时可以用来进行数据类型的转换，例如：

// 在包装类型和基本类型的集合之间进行转换
List<Integer> sourceList = ...;
int[] ints = mapper.convertValue(sourceList, int[].class);
// 在POJO和Map之间进行转换
Map<String,Object> propertyMap = mapper.convertValue(pojoValue, Map.class);
PojoType pojo = mapper.convertValue(propertyMap, PojoType.class);
// 将Base64转换为字节数组
String base64 = "TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlz";
byte[] binary = mapper.convertValue(base64, byte[].class);

JSON到Java对象的数据绑定，主要依赖于注解

@JsonAutoDetect(fieldVisibility = Visibility.ANY)
public class PrivateBean {
    private int id;
    private String name;
}

// 格式化为带毫秒的
@JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss.SSSZ", locale = "zh", timezone = "GMT+8")
// 格式化为数字时间戳
@JsonFormat(shape = JsonFormat.Shape.NUMBER)
private Date date;

@JsonNaming( PropertyNamingStrategy.SnakeCaseStrategy.class )
public class FaceRecogResult {} 

public class BeanWithInject {
    @JacksonInject
    public int key;
}

// 注入的上下文对象
InjectableValues inject = new InjectableValues.Std()
                .addValue( int.class, 1 ).addValue( "key", "value" );
new ObjectMapper().reader(inject).forType(BeanWithInject.class).readValue(json);

@JsonCreator
private CtorBean(@JsonProperty("name") String name, @JsonProperty("age") int age)
{
    this.name = name;
    this.age = age;
}

@JsonCreator
public static FactoryBean create(@JsonProperty("name") String name) {
    // construct and return an instance
} 

public class Event {
    @JsonDeserialize(using = CustomDateDeserializer.class)
    public Date eventDate;
}

@JsonRootName(value = "user")
public class UserWithRoot {
    public int id;
    public String name;
}

{
    "user": {
        "id": 1,
        "name": "John"
    }
}

@JsonAppend(attrs = { 
  @JsonAppend.Attr(value = "version") 
})
public class BeanWithAppend {
    private int id;
    private String name;
}
ObjectWriter writer = mapper.writerFor(BeanWithAppend.class).withAttribute("version", "1.0");
System.out.println( writer.writeValueAsString(bean) );
// 输出如下：
{
    "id": 2,
    "name": "Bean With Append Annotation",
    "version": "1.0"
}

public class Event {
    @JsonSerialize(using = CustomDateSerializer.class)
    public Date eventDate;
}

@JsonTypeInfo( 
    use = JsonTypeInfo.Id.CLASS, include = JsonTypeInfo.As.PROPERTY, property = "@class" 
)
@JsonSubTypes( {
        @JsonSubTypes.Type( value = Lion.class, name = "lion" ),
        @JsonSubTypes.Type( value = Elephant.class, name = "elephant" )
} )
abstract class Animal {}
class Lion extends Animal {}
class Elephant extends Animal {}

// mapper.writeValue( System.out, new Lion() );
{
  "@class" : "cc.gmem.study.jackson.Lion"
}

@JsonTypeInfo( 
    use = JsonTypeInfo.Id.MINIMAL_CLASS, include = JsonTypeInfo.As.PROPERTY, property = "@class" 
)
abstract class Animal {}

{
  "@class" : ".Lion"
}

@JsonTypeInfo( use=JsonTypeInfo.Id.CLASS, include=JsonTypeInfo.As.PROPERTY, property="@class" )
// 串行化结果：
{
  "@class" : "com.kingsmartsi.pems.fr.stport.vo.Lion"
}

@JsonTypeInfo( use=JsonTypeInfo.Id.NAME, include=JsonTypeInfo.As.PROPERTY, property="@class" )
abstract class Animal {}
// 串行化结果：
{
  "@class" : "Lion"
} 

@JsonTypeInfo( use=JsonTypeInfo.Id.NAME, include=JsonTypeInfo.As.PROPERTY, property="@class" )
abstract class Animal {}
@JsonTypeName("LION")
class Lion extends Animal {}

// 串行化结果：
{
  "@class" : "LION"
}

class Hotel {
    // 管理方，负责输出JSON
    @JsonManagedReference
    private List<Room> rooms;
}
class Room {
    // 被管理方，属性被忽略
    @JsonBackReference
    private Hotel hotel;
}

// mapper.writeValue( System.out, hotel );
{
  "rooms" : [ { }, { } ]
} 

@JsonIdentityInfo(
        generator = ObjectIdGenerators.PropertyGenerator.class,
        property = "id"
)
class Hotel {
    private int id;
    private List<Room> rooms;
}
@JsonIdentityInfo(
        generator = ObjectIdGenerators.PropertyGenerator.class,
        property = "id"
)
class Room {
    private int id;
    private Hotel hotel;
}

// 串行化Hotel的结果为：
{
  "id" : 1,
  "rooms" : [ {
    "id" : 100,
    "hotel" : 1
  }, {
    "id" : 101,
    "hotel" : 1
  } ]
} 

报错信息：Unrecognized field "***" (Class ***), not marked as ignorable
报错原因：JSON中包含对象没有的属性
解决办法：

#方法一
@Entity
@Table ( name = "T_USER" )
@JsonIgnoreProperties ( ignoreUnknown = true )
public class User implements java.io.Serializable

#方法二
ObjectMapper objectMapper = getObjectMapper();
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

报错信息：存在循环引用
解决办法：设置@JsonIgnore。JacksonJson 2.x版本中有专门处理循环引用的注解

The post JacksonJson知识集锦 appeared first on 绿色记忆.