ObjectMapper 入门：Java 对象与 JSON 之间的「翻译官」

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>

// 痛苦且易错
String json = "{\"id\":1,\"nameCn\":\"中国\",\"nameEn\":\"China\"}";

WeatherCountryOptionVo vo = new WeatherCountryOptionVo();
vo.setId(1L);
vo.setNameCn("中国");

String json = objectMapper.writeValueAsString(vo);
// {"id":1,"nameCn":"中国","nameEn":null,...}

private <T> R loadWithCache(WeatherCacheType type, long dataId,
                            TypeReference<List<T>> typeRef,
                            Supplier<List<T>> dbLoader) {
    try {
        long version = resolveDataVersion();
        Optional<String> cached = weatherFileCacheUtil.read(version, type, dataId);
        if (cached.isPresent()) {
            // 反序列化：JSON 字符串 → List<Vo>
            List<T> list = objectMapper.readValue(cached.get(), typeRef);
            return R.SUCCESS(successMsg(type)).data(list);
        }
        List<T> list = dbLoader.get();
        // 序列化：List<Vo> → JSON 字符串
        String json = objectMapper.writeValueAsString(list);
        weatherFileCacheUtil.write(version, type, dataId, json);
        return R.SUCCESS(successMsg(type)).data(list);
    } catch (Exception e) {
        log.error("查询天气地点失败: type={}, dataId={}", type.getCode(), dataId, e);
        return R.FAILED("获取地点列表失败.");
    }
}

查库得到 List<WeatherCountryOptionVo>
        │
        ▼ writeValueAsString
   JSON 字符串写入磁盘
        │
        ▼ 下次请求 readValue
   List<WeatherCountryOptionVo> 直接返回

String json = objectMapper.writeValueAsString(user);

User user = objectMapper.readValue(json, User.class);

// 编译能过，运行会报错或类型不对
List<WeatherCountryOptionVo> list =
    objectMapper.readValue(json, List.class);  // 实际得到 List<LinkedHashMap>

List<WeatherCountryOptionVo> list = objectMapper.readValue(
    json,
    new TypeReference<List<WeatherCountryOptionVo>>() {}
);

objectMapper.writeValue(new File("cache.json"), list);

List<WeatherCountryOptionVo> list = objectMapper.readValue(
    new File("cache.json"),
    new TypeReference<List<WeatherCountryOptionVo>>() {}
);

Map<String, Object> map = objectMapper.convertValue(
    vo, new TypeReference<Map<String, Object>>() {});

WeatherCountryOptionVo vo2 = objectMapper.convertValue(map, WeatherCountryOptionVo.class);

JsonNode node = objectMapper.readTree(json);
String name = node.get("nameCn").asText();

@GetMapping("/user")
public User getUser() {
    return user;  // Spring 自动用 ObjectMapper 转成 JSON 响应
}

@PostMapping("/user")
public R save(@RequestBody User user) {  // 请求体 JSON 自动转成 User
    ...
}

public class WeatherCountryOptionVo {
    private Long id;
    private String nameCn;  // JSON 键默认也是 nameCn
}

@JsonProperty("name_cn")   // 指定 JSON 字段名
private String nameCn;

@JsonIgnore                  // 序列化时忽略
private String password;

@JsonInclude(JsonInclude.Include.NON_NULL)  // null 不输出
public class XxxVo { ... }

@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;

@Autowired
private ObjectMapper objectMapper;

ObjectMapper mapper = new ObjectMapper();  // 缺少 Spring 全局配置

@Bean
public ObjectMapper objectMapper() {
    ObjectMapper mapper = new ObjectMapper();
    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
    return mapper;
}

spring:
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    default-property-inclusion: non_null
    deserialization:
      fail-on-unknown-properties: false

                    ObjectMapper
                         │
         ┌───────────────┼───────────────┐
         ▼               ▼               ▼
    HTTP 响应        文件缓存          MQ / Redis
  (Spring 自动)   (WeatherPlace 手动)   (业务手动)
         │               │               │
    Java 对象  ←──── JSON 字符串 ────→  Java 对象

public class User {
    private Long id;
    private String name;
    // getter / setter ...
}

ObjectMapper mapper = new ObjectMapper();

// 序列化
String json = mapper.writeValueAsString(user);

// 反序列化
User u = mapper.readValue(json, User.class);

// 泛型集合
List<User> list = mapper.readValue(json,
    new TypeReference<List<User>>() {});

Gson gson = new Gson();

// 序列化
String json = gson.toJson(user);

// 反序列化
User u = gson.fromJson(json, User.class);

// 泛型集合（TypeToken，和 TypeReference 类似）
List<User> list = gson.fromJson(json,
    new TypeToken<List<User>>() {}.getType());

// 序列化
String json = JSON.toJSONString(user);

// 反序列化
User u = JSON.parseObject(json, User.class);

// 泛型集合
List<User> list = JSON.parseObject(json,
    new TypeReference<List<User>>() {});

// Jackson
objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

// Gson
Gson gson = new GsonBuilder().serializeNulls().create();  // 默认就不输出 null

// Fastjson2
JSON.toJSONString(user, JSONWriter.Feature.WriteNulls);  // 默认一般不输出 null

// Jackson
@JsonProperty("user_name")
private String userName;

// Gson
@SerializedName("user_name")
private String userName;

// Fastjson2
@JSONField(name = "user_name")
private String userName;

// Jackson
@JsonIgnore
private String password;

// Gson
@Expose(serialize = false)  // 需 GsonBuilder.excludeFieldsWithoutExposeAnnotation()
private String password;

// Fastjson2
@JSONField(serialize = false)
private String password;

┌─────────────────────────────────────────────────────────┐
│  推荐：一个进程内，HTTP 层只认一种 JSON 库（Jackson）      │
│  非 HTTP（文件缓存、MQ）可注入同一个 ObjectMapper           │
└─────────────────────────────────────────────────────────┘

<!-- Jackson（Spring Boot 已自带，一般无需重复声明） -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>

<!-- Gson -->
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.11.0</version>
</dependency>

<!-- Fastjson2（勿用 1.x 的 com.alibaba:fastjson） -->
<dependency>
    <groupId>com.alibaba.fastjson2</groupId>
    <artifactId>fastjson2</artifactId>
    <version>2.0.53</version>
</dependency>