Jackson序列化返回空对象问题深度分析与解决方案

最新推荐文章于 2026-06-17 10:18:41 发布
原创 最新推荐文章于 2026-06-17 10:18:41 发布 · 513 阅读 · 9 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#java #数据库 #linux

Jackson序列化返回空对象问题深度分析与解决方案

问题描述

在使用Jackson进行JSON序列化时，经常遇到调用JsonUtils.toJsonStr(obj)返回空对象{}的问题。这种情况下，方法没有抛出异常，但序列化结果为空，导致无法正确获取对象的属性信息。

问题分析

1. JsonUtils实现分析

public static String toJsonStr(Object object) {
    try {
        return mapper.writeValueAsString(object);
    } catch (Exception var2) {
        LOG.error("parse object to json string error with object=" + object, var2);
        return "";  // 注意：异常时返回空字符串""，而不是"{}"
    }
}

从实现可以看出，如果发生异常，返回的是空字符串""，而不是空对象{}。因此，返回{}说明序列化过程成功，但对象内部没有可序列化的字段。

2. 可能的原因分析

2.1 Spring代理对象问题

现象：Spring AOP或事务管理创建的代理对象可能导致序列化失败。

原因：

  • CGLIB代理：创建子类代理，可能隐藏原始对象的字段
  • JDK动态代理：基于接口代理，只能访问接口方法，无法访问实现类的字段

示例：

@Service
@Transactional
public class UserService {
    private String name;
    private int age;
    
    // 没有getter方法
}

// 在其他地方调用
@Autowired
private UserService userService; // 这是一个代理对象
String json = JsonUtils.toJsonStr(userService); // 返回 "{}"
2.2 缺少Getter方法

现象：对象字段为private，且没有对应的getter方法。

原因：Jackson默认通过getter方法获取字段值，如果没有getter方法，无法序列化私有字段。

public class User {
    private String name;
    private int age;
    
    // 没有getter方法
}

User user = new User();
String json = JsonUtils.toJsonStr(user); // 返回 "{}"
2.3 Jackson配置问题

现象：Jackson配置不当，导致字段无法访问。

解决方案：

// 配置Jackson可以访问私有字段
mapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
mapper.setVisibility(PropertyAccessor.GETTER, JsonAutoDetect.Visibility.NONE);
mapper.setVisibility(PropertyAccessor.SETTER, JsonAutoDetect.Visibility.NONE);
2.4 @JsonIgnore注解

现象：使用了@JsonIgnore注解忽略了所有字段。

public class User {
    @JsonIgnore
    private String name;
    @JsonIgnore
    private int age;
    
    // getters and setters
}
2.5 循环引用问题

现象：对象之间存在循环引用，导致序列化失败。

public class Parent {
    private String name;
    private List<Child> children;
    // getters and setters
}

public class Child {
    private String name;
    private Parent parent; // 循环引用
    // getters and setters
}

解决方案

1. 增强的JsonUtils实现

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

public class EnhancedJsonUtils {
    private static final Logger LOG = LoggerFactory.getLogger(EnhancedJsonUtils.class);
    private static ObjectMapper mapper = new ObjectMapper();
    
    static {
        // 配置反序列化
        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        
        // 配置序列化
        mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
        
        // 配置字段访问权限
        mapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
        mapper.setVisibility(PropertyAccessor.GETTER, JsonAutoDetect.Visibility.PUBLIC_ONLY);
        mapper.setVisibility(PropertyAccessor.SETTER, JsonAutoDetect.Visibility.PUBLIC_ONLY);
    }
    
    public static String toJsonStr(Object object) {
        if (object == null) {
            return "null";
        }
        
        try {
            return mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            LOG.error("Failed to serialize object to JSON: {}", object.getClass().getName(), e);
            return "{}";
        }
    }
    
    /**
     * 调试专用方法，输出详细信息
     */
    public static String toJsonStrDebug(Object object) {
        if (object == null) {
            return "null";
        }
        
        LOG.info("Serializing object: {}", object.getClass().getName());
        LOG.info("Object toString: {}", object.toString());
        
        try {
            String result = mapper.writeValueAsString(object);
            LOG.info("Serialization result: {}", result);
            return result;
        } catch (JsonProcessingException e) {
            LOG.error("Failed to serialize object to JSON: {}", object.getClass().getName(), e);
            return "{}";
        }
    }
}

2. Spring代理对象处理

import org.springframework.aop.framework.AopContext;
import org.springframework.aop.support.AopUtils;

public class ProxyAwareJsonUtils {
    
    public static String toJsonStr(Object object) {
        if (object == null) {
            return "null";
        }
        
        // 处理Spring代理对象
        Object targetObject = unwrapProxy(object);
        
        try {
            return mapper.writeValueAsString(targetObject);
        } catch (JsonProcessingException e) {
            LOG.error("Failed to serialize object to JSON: {}", object.getClass().getName(), e);
            return "{}";
        }
    }
    
    private static Object unwrapProxy(Object object) {
        if (AopUtils.isAopProxy(object)) {
            try {
                return ((Advised) object).getTargetSource().getTarget();
            } catch (Exception e) {
                LOG.warn("Failed to unwrap proxy object: {}", object.getClass().getName(), e);
                return object;
            }
        }
        return object;
    }
}

3. 使用Builder模式创建可序列化对象

public class SerializableUser {
    private String name;
    private int age;
    private String email;
    
    // 私有构造函数
    private SerializableUser() {}
    
    // Builder模式
    public static class Builder {
        private String name;
        private int age;
        private String email;
        
        public Builder name(String name) {
            this.name = name;
            return this;
        }
        
        public Builder age(int age) {
            this.age = age;
            return this;
        }
        
        public Builder email(String email) {
            this.email = email;
            return this;
        }
        
        public SerializableUser build() {
            SerializableUser user = new SerializableUser();
            user.name = this.name;
            user.age = this.age;
            user.email = this.email;
            return user;
        }
    }
    
    // 提供getter方法用于序列化
    public String getName() { return name; }
    public int getAge() { return age; }
    public String getEmail() { return email; }
}

4. 使用@JsonProperty注解

public class User {
    @JsonProperty("name")
    private String name;
    
    @JsonProperty("age")
    private int age;
    
    @JsonProperty("email")
    private String email;
    
    // 构造函数
    public User(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }
}

最佳实践

1. 统一的序列化配置

@Configuration
public class JacksonConfig {
    
    @Bean
    @Primary
    public ObjectMapper objectMapper() {
        ObjectMapper mapper = new ObjectMapper();
        
        // 反序列化配置
        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        mapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
        
        // 序列化配置
        mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        
        // 字段访问配置
        mapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
        mapper.setVisibility(PropertyAccessor.GETTER, JsonAutoDetect.Visibility.PUBLIC_ONLY);
        
        return mapper;
    }
}

2. 创建专用的DTO类

public class UserDTO {
    private String name;
    private int age;
    private String email;
    
    // 从实体类转换
    public static UserDTO from(User user) {
        UserDTO dto = new UserDTO();
        dto.name = user.getName();
        dto.age = user.getAge();
        dto.email = user.getEmail();
        return dto;
    }
    
    // getters and setters
}

3. 使用反射工具类

public class ReflectionJsonUtils {
    
    public static String toJsonStr(Object object) {
        if (object == null) {
            return "null";
        }
        
        try {
            // 使用反射获取字段值
            Map<String, Object> fieldMap = new HashMap<>();
            Field[] fields = object.getClass().getDeclaredFields();
            
            for (Field field : fields) {
                field.setAccessible(true);
                try {
                    Object value = field.get(object);
                    fieldMap.put(field.getName(), value);
                } catch (IllegalAccessException e) {
                    LOG.warn("Cannot access field: {}", field.getName(), e);
                }
            }
            
            return mapper.writeValueAsString(fieldMap);
        } catch (JsonProcessingException e) {
            LOG.error("Failed to serialize object to JSON: {}", object.getClass().getName(), e);
            return "{}";
        }
    }
}

调试技巧

1. 输出对象信息

public static void debugObject(Object object) {
    if (object == null) {
        LOG.info("Object is null");
        return;
    }
    
    Class<?> clazz = object.getClass();
    LOG.info("Object class: {}", clazz.getName());
    LOG.info("Is proxy: {}", AopUtils.isAopProxy(object));
    LOG.info("Object toString: {}", object.toString());
    
    // 输出字段信息
    Field[] fields = clazz.getDeclaredFields();
    for (Field field : fields) {
        field.setAccessible(true);
        try {
            Object value = field.get(object);
            LOG.info("Field {}: {}", field.getName(), value);
        } catch (IllegalAccessException e) {
            LOG.warn("Cannot access field: {}", field.getName());
        }
    }
    
    // 输出方法信息
    Method[] methods = clazz.getDeclaredMethods();
    for (Method method : methods) {
        if (method.getName().startsWith("get") && method.getParameterCount() == 0) {
            LOG.info("Getter method: {}", method.getName());
        }
    }
}

2. 使用Jackson的调试功能

import com.fasterxml.jackson.databind.ser.BeanPropertyWriter;
import com.fasterxml.jackson.databind.ser.PropertyWriter;
import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;

public class DebugJsonUtils {
    
    public static String toJsonStrWithDebug(Object object) {
        ObjectMapper debugMapper = new ObjectMapper();
        
        // 添加调试过滤器
        SimpleBeanPropertyFilter filter = new SimpleBeanPropertyFilter() {
            @Override
            public void serializeAsField(Object pojo, JsonGenerator gen, 
                                       SerializerProvider provider, PropertyWriter writer) throws Exception {
                LOG.info("Serializing field: {} with value: {}", 
                        writer.getName(), writer.getMember().getValue(pojo));
                super.serializeAsField(pojo, gen, provider, writer);
            }
        };
        
        SimpleFilterProvider filters = new SimpleFilterProvider()
            .addFilter("debugFilter", filter);
        
        debugMapper.setFilterProvider(filters);
        
        try {
            return debugMapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            LOG.error("Failed to serialize object to JSON", e);
            return "{}";
        }
    }
}

总结

Jackson序列化返回空对象{}的问题通常由以下原因引起：

  1. Spring代理对象：使用AOP或事务管理的代理对象可能隐藏原始字段
  2. 缺少Getter方法：私有字段没有对应的getter方法
  3. Jackson配置问题：访问权限配置不当
  4. 注解使用不当：@JsonIgnore等注解的误用
  5. 循环引用：对象之间的循环依赖

解决方案包括：

  • 配置Jackson的字段访问权限
  • 处理Spring代理对象
  • 使用专用的DTO类
  • 添加适当的注解
  • 实现调试工具类

通过合理的配置和规范的编码实践，可以有效避免这类问题，确保JSON序列化的正确性和可靠性。

Feign的理解和使用
u010034713的博客
01-30 1380
1简单说明 简单的说, Feign是一个用于请求http接口的框架, 再java中可以用少量代码, 简单整洁的调用http. 2使用例子 maven依赖 <!-- feign-core --> <dependency> <groupId>io.github.openfeign</groupId> <artifactId>feign-core</artifactId> <version>11
Spring Cloud Feign的自定义配置及使用
xq_adress的博客
07-16 2529
配置
微服务调用组件Feign的原理及高级功能实战
nandao158的博客
01-12 4085
微服务调用组件Feign的原理及高级功能实战
单向关联中解决jackson序列化对象时关联对象为空，无法序列化成json的问题
IT_CREATE的博客
01-23 1717
      在我们用hibernate做查询数据的时候，我们会遇到一些问题，就是我们后台向前端以json返回数据的时候，会遇到返回对象中的关联对象属性为空，无法进行序列化；这是因为后台序列化对象的时候位于我们的第一次查询和关联数据查询之间。就是说在关联对象的查询还没进行的时候就开始进行jackson的序列化了，而这时我们的关联对象还没有查询出来数据进行赋值，所以会出现这个问题，所以有以下两种解决方...
jackson序列化（jackson codec）
gzyes
07-23 1956
Jackson 是一个用于 Java 平台的开源 JSON 库，它提供了灵活且高效的方式来处理 JSON 数据的序列化(Java对象 → JSON字符串)和反序列化(JSON 字符串→ Java对象)。 以下是 Jackson 的一些主要特点和功能： 高性能：Jackson 通过使用基于流的处理模型和性能优化技术，提供了出色的性能。它支持快速的数据绑定和处理大型 JSON 数据。 灵活性...
Java反序列化漏洞实战：Jackson、FastJson、XStream组件安全攻防解析
最新发布
weixin_30908941的博客
06-17 395
序列化与反序列化是Java等编程语言中数据持久化和网络传输的核心机制，其原理是将对象状态转换为可存储或传输的格式，并在需要时重建。然而，当反序列化过程未对输入数据进行严格校验时，攻击者可能通过构造恶意数据触发危险方法调用链，最终实现远程代码执行（RCE），这构成了严重的安全威胁。在Java生态中，广泛使用的JSON/XML解析库如Jackson、FastJson和XStream，因其默认配置或特定功能（如多态类型处理、autoType）曾多次曝出高危反序列化漏洞，成为红队攻击和高级持续性威胁（APT）中的关
第6篇：`ObjectMapper`深度配置：全局行为定制
LBJ_2016_1984_12_30
10-15 1157
场景推荐方案优势项目统一规则（如日期格式、命名策略、空值过滤）全局配置一处配置，全域生效，减少重复代码个别字段特殊需求（如特殊日期格式、特殊字段名）局部注解灵活覆盖全局规则，不影响其他字段通过本文的四大核心配置，你可以彻底告别“注解泛滥”的问题，实现项目JSON处理规则的统一化、标准化——这不仅能提升开发效率，更能降低后续维护成本（如需修改规则，只需调整全局配置，无需逐个修改实体类）。
【SpringBoot 4.x 第1节】夯爆了，为什么现在要学 Spring Boot 4.x？从零开始理解版本体系、核心变化与真实项目开发路线（超详解）！
热门推荐
**My Coding Family**
05-19 1万+
🏆 本文收录于 《滚雪球学 Spring Boot 4.x》 专栏。 本专栏面向 有一点 Java 基础，但没有系统学过 Spring Boot 的读者，采用“滚雪球式学习法”：先跑通、再理解、再重构、再上线，最终带你从第一个 Hello API 一路完成一个可部署、可监控、可扩展的后端项目。
手把手教你用ObjectMapper和JavaTimeModule搞定LocalDateTime的JSON序列化（附完整工具类）
weixin_27219587的博客
04-23 301
本文详细解析了Java 8时间类型在JSON序列化中的常见问题及解决方案，重点介绍了如何使用ObjectMapper和JavaTimeModule处理LocalDateTime的序列化与反序列化。通过实战案例和完整工具类代码，帮助开发者避免日期格式、时区等常见陷阱，提升开发效率。
响应报文null值字段设置为“”
qq_39815502的博客
11-26 654
响应报文null值字段设置为“” ​ 前端要求后台响应报文null值字段设置为“”，配置Jackson解析器 import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.JsonSerializer; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.Seria
通过Feign远程调用第三方接口
Carson073的博客
11-13 4904
远程调用第三方接口的有几种方法，常用就是用HttpClient等插件，其实SpringCloud的Fegin组件也可以 用于第三方接口调用。 1、引入Maven插件 <!-- feign核心包 --> <dependency> <groupId>io.github.openfeign</grou...
【深入浅出SpringCloud原理及实战】「Netflix系列之Fegin」打开Fegin之RPC技术的开端，你会使用原生态的Fegin吗？(中)
世界上并没有完美的程序，但是我们并不因此而沮丧，因为写程序就是一个不断追求完美的过程。
01-20 953
Feign 有许多可以自定义的方面。// AccountDecoder() 是自己实现的一个Decoder。
[享学Feign] 十、Feign通过feign-jackson模块天然支持POJO的编码和解码
架构师：通透，才能写出好代码！
02-15 3927
上文介绍了Feign的Client相关模块，体验到Feign核心内容的高扩展性同时，亦能明显感觉到其子模块其实为对**Feign核心功能**的延伸，让其更能适应复杂的生产环境要求。 本文将介绍它的另一个实用模块：`feign-jackson`。它能解决我们平时工作中非常大的一个痛点：Feign只能编码/解码字符串类型的数据。有了它便能使得我们编码更加的面向对象，对Feign的内部处理细节更加无感~
[JAVA安全]JACKSON反序列化
snowlyzz的博客
01-28 2334
JACKSON反序列化原理
Jackson全局转化long类型为String，解决jackson序列化时long类型缺失精度问题
03-29 1482
【代码】Jackson全局转化long类型为String，解决jackson序列化时long类型缺失精度问题。
SprinCloud之feign
roykingw的专栏
06-27 561
本文目录一、feign原理二、简单例子三、深入feign组件1、Encoder 与 Decoder2、client 客户端3、Constract 注解翻译器4、requestInterceptor 请求拦截器5、logger与logLevel四、SpringCloud结合feign，了解SpringCloud为我们干了些什么。 Feign是Netflix开发的声明式、模板化的HTTP客户端。其实之...
Jackson序列化对象属性丢失，返回空对象的问题
TOP丶Chen
05-10 2182
使用SpringBoot默认的json框架Jackson进行返回数据序列化的时候，发现返回结果中，有部分对象被序列化成了空对象，即：”{}“。经过DEBUG和查阅资料发现是由于改对象的属性为private私有属性，且没有Getter和Setter方法导致的。
Feign接口调用-请求响应数据底层实现
小汤圆的博客
02-14 958
Jackson 是一个广泛使用的 JSON 编解码库，用于将 Java 对象序列化为 JSON 字符串（编码），以及将 JSON 字符串反序列化为 Java 对象（解码）。
JSON.toJSONString中序列化空字符串
不怕万人阻挡，只怕自己投降
05-08 1932
最近用JSON.toJSONString处理时，发现JSON.toJSONString中序列化会把对象中某些为空的属性给清空。上示例代码段： if (list.size() == 1 && CollectionUtils.isNotEmpty(results)) { results.forEach(item -> { if ("全国".equals(item.getAreaname())) {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值