jackson:基于BeanSerializer实现自定义的Java bean序列化器

已于 2024-06-26 17:59:37 修改
阅读量616 收藏 3
点赞数 3
分类专栏： java json 文章标签： java jackson BeanSerializer 自定义序列化 Bean
于 2024-06-07 15:14:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/10km/article/details/139525936
版权
java 同时被 2 个专栏收录
229 篇文章 4 订阅
订阅专栏
json
23 篇文章 1 订阅
订阅专栏

之前写过一篇博客《jackson:基于BeanDeserializer实现自定义的Java bean 解析器》，介绍了如何继承com.fasterxml.jackson.databind.deser.BeanDeserializer实现自定义的反序列化器。

如果要实现继承BeanDeserializer实现自定义的Java bean 解析器，与做序列化器一样，如何将一个Class转为BeanSserializer构造方法需要的类型才是关键。

BeanSerializerBuilder

如下是BeanSserializer的构造方法：

public BeanSerializer(JavaType type, BeanSerializerBuilder builder,
            BeanPropertyWriter[] properties, BeanPropertyWriter[] filteredProperties);
protected BeanSerializer(BeanSerializerBase src);
protected BeanSerializer(BeanSerializerBase src,ObjectIdWriter objectIdWriter);
protected BeanSerializer(BeanSerializerBase src,ObjectIdWriter objectIdWriter,Object filterId);
protected BeanSerializer(BeanSerializerBase src, Set<String> toIgnore, Set<String> toInclude);
protected BeanSerializer(BeanSerializerBase src,BeanPropertyWriter[] properties, BeanPropertyWriter[] filteredProperties)

这么多构造方法，从哪一个开始是个问题，通过反复跟踪代码，在BeanSerializeFactory.constructBeanOrAddOnSerializer(SerializerProvider prov, JavaType type, BeanDescription beanDesc, boolean staticTyping) 方法中找到了从Class创建BeanSerializerBuilder实例的代码。

上面BeanSserializer的第一个构造方法虽然要的参数多，但是有了BeanSerializerBuilder实例，所有的其他参数都可以想办法从BeanSerializerBuilder实例中获取 。

JacksonBeanSerializerFactory

由此我继承BeanSerializeFactory创建了一个新的类JacksonBeanSerializerFactory，只为照抄父类方法constructBeanOrAddOnSerializer的逻辑,
下面代码中JacksonBeanSerializerFactory.constructBeanSerializerBuilder方法只为从BeanDescription实例返回一个BeanSerializerBuilder实例

JacksonBeanSerializerFactory.java

class JacksonBeanSerializerFactory extends BeanSerializerFactory {

	private static final long serialVersionUID = 4346918816045771010L;
	static JacksonBeanSerializerFactory instance = new JacksonBeanSerializerFactory();
	public JacksonBeanSerializerFactory() {
		this(null);
	}
	
	public JacksonBeanSerializerFactory(SerializerFactoryConfig config) {
		super(config);
	}

	
    JacksonBeanSerializerBuilder constructBeanSerializerBuilder(SerializerProvider prov,
            BeanDescription beanDesc)
        throws JsonMappingException
    {
        final SerializationConfig config = prov.getConfig();
        JacksonBeanSerializerBuilder builder = new JacksonBeanSerializerBuilder(beanDesc);
        builder.setConfig(config);

        // First: any detectable (auto-detect, annotations) properties to serialize?
        List<BeanPropertyWriter> props = findBeanProperties(prov, beanDesc, builder);
        if (props == null) {
            props = new ArrayList<BeanPropertyWriter>();
        } else {
            props = removeOverlappingTypeIds(prov, beanDesc, builder, props);
        }
        
        // [databind#638]: Allow injection of "virtual" properties:
        prov.getAnnotationIntrospector().findAndAddVirtualProperties(config, beanDesc.getClassInfo(), props);

        // [JACKSON-440] Need to allow modification bean properties to serialize:
        if (_factoryConfig.hasSerializerModifiers()) {
            for (BeanSerializerModifier mod : _factoryConfig.serializerModifiers()) {
                props = mod.changeProperties(config, beanDesc, props);
            }
        }

        // Any properties to suppress?
        props = filterBeanProperties(config, beanDesc, props);

        // Need to allow reordering of properties to serialize
        if (_factoryConfig.hasSerializerModifiers()) {
            for (BeanSerializerModifier mod : _factoryConfig.serializerModifiers()) {
                props = mod.orderProperties(config, beanDesc, props);
            }
        }

        /* And if Object Id is needed, some preparation for that as well: better
         * do before view handling, mostly for the custom id case which needs
         * access to a property
         */
        builder.setObjectIdWriter(constructObjectIdHandler(prov, beanDesc, props));
        
        builder.setProperties(props);
        builder.setFilterId(findFilterId(config, beanDesc));

        AnnotatedMember anyGetter = beanDesc.findAnyGetter();
        if (anyGetter != null) {
            JavaType type = anyGetter.getType();
            // copied from BasicSerializerFactory.buildMapSerializer():
            boolean staticTyping = config.isEnabled(MapperFeature.USE_STATIC_TYPING);
            JavaType valueType = type.getContentType();
            TypeSerializer typeSer = createTypeSerializer(config, valueType);
            // last 2 nulls; don't know key, value serializers (yet)
            // 23-Feb-2015, tatu: As per [databind#705], need to support custom serializers
            JsonSerializer<?> anySer = findSerializerFromAnnotation(prov, anyGetter);
            if (anySer == null) {
                // TODO: support '@JsonIgnoreProperties' with any setter?
                anySer = MapSerializer.construct(/* ignored props*/ (Set<String>) null,
                        type, staticTyping, typeSer, null, null, /*filterId*/ null);
            }
            // TODO: can we find full PropertyName?
            PropertyName name = PropertyName.construct(anyGetter.getName());
            BeanProperty.Std anyProp = new BeanProperty.Std(name, valueType, null,
                    beanDesc.getClassAnnotations(), anyGetter, PropertyMetadata.STD_OPTIONAL);
            builder.setAnyGetter(new AnyGetterWriter(anyProp, anyGetter, anySer));
        }
        // Next: need to gather view information, if any:
        processViews(config, builder);

        // Finally: let interested parties mess with the result bit more...
        /** 暂时删除 */
//        if (_factoryConfig.hasSerializerModifiers()) {
//            for (BeanSerializerModifier mod : _factoryConfig.serializerModifiers()) {
//                builder = mod.updateBuilder(config, beanDesc, builder);
//            }
//        }

        return builder.builder();

    }

}

createBeanSerializer

然后我们就可以实现一个方法从Class创建一个BeanSerializerBuilder的实例：如下

	/**
	 * 创建{@code beanClass}对应的{@link BeanDeserializerBase}实例用于父类构造方法的参数,
	 * 将{@code beanClass}的序列化参数注入到当前实例中
	 * @param beanClass
	 */
	private static JacksonBeanSerializerBuilder createBeanSerializer(Class<?> beanClass){
		try {
			JavaType type = TypeFactory.defaultInstance().constructType(beanClass);
			ObjectMapper mapper = new ObjectMapper();
			BeanDescription desc = mapper.getSerializationConfig().introspect(type);
			SerializerProvider provider = ((DefaultSerializerProvider) mapper.getSerializerProvider())
							.createInstance(mapper.getSerializationConfig(), JacksonBeanSerializerFactory.instance);
			return JacksonBeanSerializerFactory.instance
					.constructBeanSerializerBuilder(provider, desc);
		} catch (Exception e) {
			throw new ExceptionInInitializerError(e);
		}
	}

JacksonBeanSerializerBuilder

上面方法中返回类型JacksonBeanSerializerBuilder是BeanSerializerBuilder的子类,
实现代码如下：
JacksonBeanSerializerBuilder.java

import com.fasterxml.jackson.databind.BeanDescription;
import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.SerializationConfig;
import com.fasterxml.jackson.databind.ser.BeanPropertyWriter;
import com.fasterxml.jackson.databind.ser.BeanSerializerBuilder;

/**
 * @author guyadong
 * @since 3.31.3
 */
class JacksonBeanSerializerBuilder extends BeanSerializerBuilder {
	private final static BeanPropertyWriter[] NO_PROPERTIES = new BeanPropertyWriter[0];
	JacksonBeanSerializerBuilder(BeanDescription beanDesc) {
		super(beanDesc);
	}

	JacksonBeanSerializerBuilder(BeanSerializerBuilder src) {
		super(src);
	}
    public void setConfig(SerializationConfig config) {
        _config = config;
    }
    JacksonBeanSerializerBuilder builder()
    {
        if (_anyGetter != null) {
            _anyGetter.fixAccess(_config);
        }
        if (_typeId != null) {
            if (_config.isEnabled(MapperFeature.CAN_OVERRIDE_ACCESS_MODIFIERS)) {
                _typeId.fixAccess(_config.isEnabled(MapperFeature.OVERRIDE_PUBLIC_ACCESS_MODIFIERS));
            }
        }
        return this;
    }
    /**
     * @see #build()
     */
    BeanPropertyWriter[] buildProperties() {
        BeanPropertyWriter[] properties;
        // No properties, any getter or object id writer?
        // No real serializer; caller gets to handle
        if (_properties == null || _properties.isEmpty()) {
            if (_anyGetter == null && _objectIdWriter == null) {
                return null;
            }
            properties = NO_PROPERTIES;
        } else {
            properties = _properties.toArray(new BeanPropertyWriter[_properties.size()]);
            if (_config.isEnabled(MapperFeature.CAN_OVERRIDE_ACCESS_MODIFIERS)) {
                for (int i = 0, end = properties.length; i < end; ++i) {
                    properties[i].fixAccess(_config);
                }
            }
        }
        return properties;
    }
}

示例：JacksonExampleSerializer

有了createBeanSerializer方法，我们就可以很容易继承BeanSerializer实现自定义的序列化器了，示例如下：

JacksonExampleSerializer.java

import java.io.IOException;

import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.BeanDescription;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.BeanSerializer;
import com.fasterxml.jackson.databind.ser.DefaultSerializerProvider;
import com.fasterxml.jackson.databind.type.TypeFactory;

@SuppressWarnings("serial")
public abstract class JacksonExampleSerializer extends BeanSerializer {
	public JacksonExampleSerializer(Class<?> beanClass) {
		this(	createBeanSerializer(beanClass));
	}
	private JacksonExampleSerializer(JacksonBeanSerializerBuilder builder) {
		super(builder.getBeanDescription().getType(),
				builder,builder.buildProperties(),builder.getFilteredProperties());
	}
	
	@Override
	protected void serializeFieldsFiltered(Object bean, JsonGenerator gen, SerializerProvider provider)
			throws IOException, JsonGenerationException {
		// 根据需要重写实现方法
		super.serializeFieldsFiltered(bean, gen, provider);
	}
	/**
	 * 创建{@code beanClass}对应的{@link BeanSerializerBuilder}实例用于父类构造方法的参数,
	 * 将{@code beanClass}的序列化参数注入到当前实例中
	 * @param beanClass
	 */
	private static JacksonBeanSerializerBuilder createBeanSerializer(Class<?> beanClass){
		try {
			JavaType type = TypeFactory.defaultInstance().constructType(beanClass);
			ObjectMapper mapper = new ObjectMapper();
			BeanDescription desc = mapper.getSerializationConfig().introspect(type);
			SerializerProvider provider = ((DefaultSerializerProvider) mapper.getSerializerProvider())
							.createInstance(mapper.getSerializationConfig(), JacksonBeanSerializerFactory.instance);
			return JacksonBeanSerializerFactory.instance
					.constructBeanSerializerBuilder(provider, desc);
		} catch (Exception e) {
			throw new ExceptionInInitializerError(e);
		}
	}
}
10km
关注
专栏目录
[享学Jackson] 十、jackson-databind序列化之ObjectMapper序列化原理、序列化器匹配原理
架构师：通透，才能写出好代码！
01-13 4991
序列化/反序列作高层API的核心概念，重要程度可见一斑。但是关于序列化/反序列化是什么，大多数小伙伴其实停留在概念阶段，并不知其内幕。 > 说明：本文讨论的序列化/反序列化自然是是关注JSON方面的 学习本专栏定位，就是要把自己放在专业人士的位置，要能实现Jackson的高级定制。而若想具备此能力，自然需要知道很多技术细节和其内部的实现步骤/原理。
实现自定义序列化和反序列化控制的5种方式
码到三十五
11-14 4447
在 Jackson 中，你可以通过多种方式来实现自定义的序列化和反序列化控制。自定义 Serializer 和 Deserialize，使用 Mix-in Annotations，注解如 @JsonSerialize 和 @JsonDeserialize，自定义的模块或者处理器如 SimpleModule 或者 HandlerInstantiator，使用 JsonSerializerModifier 和 BeanSerializerModifie
Jackson库中的@JsonSerialize：定制JSON序列化的利器
最新发布
xycxycooo的博客
08-15 1104
注解是Jackson库中的一个注解，用于指定自定义的序列化器（Serializer）。通过使用注解，开发者可以控制对象在序列化为JSON字符串时的具体行为，例如格式化日期、处理复杂数据类型等。要使用注解，首先需要定义一个自定义的序列化器。自定义序列化器需要继承类，并实现serialize方法。假设我们有一个User类，其中包含一个birthDate字段，我们希望在序列化时将其格式化为特定的日期格式（如yyyy-MM-dd} }} }} }
jackson自定义序列化器
u013361107的博客
11-21 1053
工作中遇到的问题记录 当这种默认的jackson序列化满足不了要求的时候 ObjectMapper mapper = new ObjectMapper(); String string = mapper.writeValueAsString(bean); 需要自己定义序列化器 实现也很简单 public class MySerializer extends JsonSerialize...
Jackson自定义序列化
Remember_Z的博客
11-20 4180
Jackson自定义序列化
Jackson 2.x 系列【22】自定义序列化/反序列化器
记录知识、锤炼自我
04-12 1449
在实际开发中，Jackson核心模块支持了常见类型的数据转换，此外还有很多第三方模块支持不常用的类型，基本已经够用。但是在某些特殊场景下，可能需要支持自定义类型或者转换规则。
Jackson的自定义序列化器调用默认序列化器详解
白石的专栏
10-24 4317
将我们完整的数据结构序列化为JSON时使用所有字段的精确一对一表示有时可能不合适，或者根本可能不是我们想要的。 相反，我们可能想要创建数据的扩展或简化视图。 这就是自定义 Jackson 序列化程序发挥作用的地方。
Jackson 自定义序列化器的使用
JavaSupeMan的博客
01-03 2469
注意：从简单的例子去延伸使用，内容紧凑，排版就这样了哈 输出结果： 实现接口ContextualSerializer，判断类型然后返回具体的序列化器 但是使用的话会发现不能使用，是因为这个接口并没有实现JsonSerializer类 走起！ 1.定义一个自定义注解： 2.使用 是不是更简洁了！
springboot自定义指定类型的数据序列化方式
hupoling的专栏
12-18 2423
近期，IOS团队反馈反参中如果存在BigDecimal类型数据，反序列化时会出现丢失精度问题，需要后台把所有BigDecimal类型转变为String类型。 环境 java JDK1.8 springboot 2.3.0.RELEASE 设计概要： 主要思路是配置自定义的Bigdeciaml类型的json序列化,重现com.fasterxml.jackson.databind.ser.BeanSerializerModifier的changeProperties方法，对指定类型设置自定义的序列化方
Hessian 反序列化及相关利用链
晓得哥的博客
02-29 2372
作者：Longofo@知道创宇404实验室 时间：2020年2月20日 原文地址：https://paper.seebug.org/1131/#_2 前不久有一个关于Apache Dubbo Http反序列化的漏洞，本来是一个正常功能（通过正常调用抓包即可验证确实是正常功能而不是非预期的Post），通过Post传输序列化数据进行远程调用，但是如果Post传递恶意的序列化数据就能进行恶意利用。Apa...
Spring Boot框架中使用Jackson的处理总结
八一菜刀的专栏
03-26 2875
1.前言 通常我们在使用Spring Boot框架时，如果没有特别指定接口的序列化类型，则会使用Spring Boot框架默认集成的Jackson框架进行处理，通过Jackson框架将服务端响应的数据序列化成JSON格式的数据。 本文主要针对在Spring Boot框架中使用Jackson进行处理的经验进行总结，同时也结合在实际开发场景中碰到的问题以及解决方案进行陈述。 本文涉及到的源码地址：https://gitee.com/dt_research_institute/code-in-action PS
Spring Boot 项目中Java对象的字符串类型属性值转换为JSON对象的布尔类型键值的解决方法及过程
oscar999的专栏
03-27 4796
在Spring Boot项目中， 很多场景是将一个实体对象返回为JSON格式的字串， 但是在返回时需要指定一个String类型的属性返回的是Boolean类型的值。 举例来说：定义了一个Animal类，该类有两个属性 name: 名字 和extinct： 是否灭绝。该类的定义如下： public class Animal { private String name; private String ...
java：jackson 三：Jackson – Custom Serializer
a232884c的博客
12-26 670
1 前言jackson支持自定义序列化器，参考文档地址如下： 依赖如下（这里使用jackson-databind的2.14.1版本）： 2 使用2.1 Standard Serialization of an Object GraphThis will result in a full JSON representation for both entities: 执行结果： 2.2 Custom Serializer on the ObjectMapper 执行结果： 2.3 Custom Serializ
Jackson 2.x 系列【21】序列化修饰器 BeanSerializerModifier
记录知识、锤炼自我
04-12 1139
Java Bean对象的序列化过程是比较复杂的，因为它可能包含了各种类型的属性，在Jackson中该过程是交由BeanSerializer来负责的。同时Jackson也提供了扩展机制，允许通过BeanSerializerModifier在BeanSerializer的创建过程中进行干预和修改，从而实现对序列化过程的自定义。
java jackson 自定义_Jackson自定义序列化器
weixin_39936403的博客
02-25 153
Jackson自定义序列化器自定义Jackson序列化器非常好用，比如数据库存储图片相对地址而接口中需要拼接Http路径、隐藏手机号中间某几位、Double保留两位小数输出等等。使用方法也很简单自定义序列化器，集成JsonSerializerimport com.fasterxml.jackson.core.JsonGenerator;import com.fasterxml.jackson.co...
使用Jackson自定义序列化操作（Jackson – Custom Serializer）
张紫娃的博客
08-04 415
【代码】使用Jackson自定义序列化操作（Jackson – Custom Serializer）
Jackson自定义序列化器(针对null，针对指定name的属性)
01-26 706
public class JsonObjectMapper extends ObjectMapper { /** * */ private static final long serialVersionUID = 8034942567620323925L; public JsonObjectMapper() { super(); this.setSerializerFactory(this.getSerializerFactory().withSerializerMod...
jackson 自定义序列化
chizhenzhi8061的博客
03-12 257
/** *jsonnull值不返回 * *@authorxulin *@version1.02015年3月10日 */ publicclassNotNullObjectMapperextendsObjectMapper{ privatestaticfi...
java的bean对象通过注解在set方法实现自定义序列化
05-26
在 Java 中，我们可以通过实现 Serializable 接口来实现对象的序列化和反序列化。不过，有时候我们可能需要对某些属性进行自定义序列化，这时可以使用注解来实现。 假设有一个 Person 类，其中包含了 name、age 两个属性，我们希望在序列化时只序列化 name 属性。那么我们可以在 name 属性的 set 方法上添加 @JsonProperty 注解，同时在 age 属性的 set 方法上添加 @JsonIgnore 注解，具体代码如下： ```java import com.fasterxml.jackson.annotation.JsonIgnore; import com.fasterxml.jackson.annotation.JsonProperty; public class Person { private String name; private int age; @JsonProperty("name") public void setName(String name) { this.name = name; } @JsonIgnore public void setAge(int age) { this.age = age; } // 省略 getter 和其他方法 } ``` 在上面的例子中，@JsonProperty 注解指定了序列化时使用的属性名为 name，@JsonIgnore 注解则表示该属性不参与序列化。 当我们需要将 Person 对象序列化为 JSON 字符串时，只会序列化 name 属性，而 age 属性则被忽略。反序列化同理，只会将 JSON 中的 name 属性赋值给 Person 对象的 name 属性，age 属性则不会赋值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

10km

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值