# jackson-example

**Repository Path**: jonathanzyf/jackson-example

## Basic Information

- **Project Name**: jackson-example
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2024-10-23
- **Last Updated**: 2024-10-23

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Jackson 示例
## ObjectMapper功能简介
- ObjectMapper是Jackson中序列化的核心类，有两个子类：JsonMapper和XmlMapper，分别用于JSON和XML的序列化； 
- ObjectMapper(JsonFactory)构造函数可以选择使用MappingJsonFactory或者XmlFactory，
- ObjectMapper(MappingJsonFactory)相当于JsonMapper，ObjectMapper(XmlFactory)相当于XmlMapper；
- ObjectMapper()默认采用了MappingJsonFactory作为JsonFactory，相当于JsonMapper。

- ObjectMapper可以通过valueToTree()将对象转换为节点树，通过或readTree()方法将资源换为节点树，节点类型为JsonNode的子类；
- JsonNode有ARRAY、BINARY、BOOLEAN、MISSING、NULL、NUMBER、OBJECT、POJO、STRING几种类型，其中Array和Object属于容器类型，其它的属于值类型。

## 范型
通过TypeReference<T>保留原始类型，在反序列化时，可以获得原始类型。
```java
public class JacksonObject {
    public <T> T load(String path, TypeReference<T> typeRef) throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        try (InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream(path)) {
            return mapper.readValue(is, typeRef);
        }
    }
}
```

Unit Test：
```java
class JacksonObjectTest {
    @Test
    public void should_get_product_list() throws IOException {
        final TypeReference<Result<List<ProductDTO>>> typeRef = new TypeReference<Result<List<ProductDTO>>>() {
        };
        JacksonObject json = new JacksonObject();
        Result<List<ProductDTO>> result = json.load("data/result-example.json", typeRef);
        // assert
        new ResultAssert().assertResult(result);
    }
}
```

## JsonNode Tree
```java
public class JacksonObject {
    public <T> void visitTree(String path, BiConsumer<String, Integer> visitor) throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        try (InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream(path)) {
            JsonNode root = mapper.readTree(is);
            visit(root, 1, visitor);
        }
    }

    private void visit(JsonNode node, int depth, BiConsumer<String, Integer> visitor) {
        JsonNodeType type = node.getNodeType();
        visitor.accept(node.getClass().getSimpleName() + ":" + type.name() + ":" + node.toString(), depth);
        if (node.isObject()) {
            node.fields().forEachRemaining(e -> visit(e.getValue(), depth + 1, visitor));
        } else if (node.isArray()) {
            node.forEach(e -> visit(e, depth + 1, visitor));
        }
    }
}
```

Unit Test：
```java
class JacksonObjectTest {
    @Test
    public void should_walk_with_resource() throws IOException {
        JacksonObject json = new JacksonObject();
        json.visitTree("data/result-example.json", (expr, idx) -> {
            for (int i = 1; i < idx; i++) {
                System.out.print("--");
            }
            System.out.println(expr);
        });
    }
}
```