# jackson-util

**Repository Path**: zhangjian-eng/jackson-util

## Basic Information

- **Project Name**: jackson-util
- **Description**: 工具类：序列化，递归解析字符串
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2021-09-22
- **Last Updated**: 2021-09-22

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

### maven 依赖

```xml
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
			<version>2.10.0</version>
		</dependency>
		<dependency>
			<groupId>com.fasterxml.jackson.datatype</groupId>
			<artifactId>jackson-datatype-jsr310</artifactId>
			<version>2.10.0</version>
		</dependency>
```

###  JacksonUtil 工具类

```Java
package util;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.JsonNodeType;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

/**
 * jackson 工具类
 *
 * @author zhangjian
 * @version 1.0.0
 * @since 2021/09/21 15:19
 */
public class JacksonUtil {

  public static final ObjectMapper mapper = new ObjectMapper().registerModule(new JavaTimeModule());
  static {
    // 反序列化时忽略不存在的JavaBean属性:
    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
  }

  /** 工具类不允许外界创建对象 */
  private JacksonUtil() {
  }

  /**
   * 嵌套 JSONString 转 Map<String, String>
   */
  public static HashMap<String, String> parseJsonNode(String json) throws JsonProcessingException {
    HashMap<String, String> map = new HashMap<>();
    JsonNode jsonNode = mapper.readTree(json);
    parseJsonNode(jsonNode, map, "");
    return map;
  }

  private static void parseJsonNode(JsonNode jsonNode, Map<String, String> map, String key) {
    JsonNodeType nodeType = jsonNode.getNodeType();
    // 数组
    if (nodeType == JsonNodeType.ARRAY) {
      Iterator<JsonNode> elements = jsonNode.elements();
      int i = 0;
      while (elements.hasNext()) {
        parseJsonNode(elements.next(), map, key + String.format("[%d]", i++));
      }
    }
    // 对象
    else if (nodeType == JsonNodeType.OBJECT) {
      Iterator<Map.Entry<String, JsonNode>> fields = jsonNode.fields();
      while (fields.hasNext()) {
        Map.Entry<String, JsonNode> field = fields.next();
        parseJsonNode(field.getValue(), map, key + "." + field.getKey());
      }
    }
    // 数字 / 字符串
    else if(nodeType == JsonNodeType.NUMBER || nodeType == JsonNodeType.STRING){
      map.put(key, jsonNode.textValue());
    }else {
      throw new UnsupportedOperationException("unknown JsonNodeType");
    }
  }

  public static <T> T jsonToObject(String json, Class<T> t) throws JsonProcessingException {
    return mapper.readValue(json, t);
  }

  public static String objectToString(Object obj) throws JsonProcessingException {
    return mapper.writeValueAsString(obj);
  }

}
```

###  自定义序列化

```java
package util;

import java.io.IOException;
import java.math.BigInteger;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;

/**
 * 自定义序列化
 */
public class IsbnDeserializer extends JsonDeserializer<BigInteger> {

	@Override
	public BigInteger deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
		String s = p.getValueAsString();
		if (s != null) {
			try {
				return new BigInteger(s.replace("-", ""));
			} catch (NumberFormatException e) {
				throw new JsonParseException(p, s, e);
			}
		}
		return null;
	}
}
```

###  实体类

```java
package bean;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.time.LocalDate;
import java.util.List;

import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import util.IsbnDeserializer;
import lombok.Data;

@Data
public class Book {

  private long id;

  private String name;

  private String author;

  @JsonDeserialize(using = IsbnDeserializer.class)
  private BigInteger isbn;

  private List<String> tags;

  private LocalDate pubDate;

  private BigDecimal price;
}
```

###  资源文件

`book.json`

```json
{
    "id": 1,
    "name": "Java核心技术",
    "author": "Cay S. Horstmann",
    "isbn": "978-7-111-54742-6",
    "tags": ["Java", "Network"],
    "pubDate": "2016-09-01",
    "price": 119.5
}
```

`albumList.json`

```
{
  "id": 1,
  "name": "Java核心技术",
  "author": "Cay S. Horstmann",
  "isbn": "978-7-111-54742-6",
  "tags": ["Java", "Network", "spring"],
  "pubDate": "2016-09-01",
  "public": {
    "id": 1,
    "name": "Java核心技术",
    "author": "Cay S. Horstmann",
    "isbn": "978-7-111-54742-6",
    "tags": ["Java", "Network"],
    "pubDate": "2016-09-01",
    "price": {

    }
  }
}
```