Java 如何通过ObjectMapper捕获序列化和反序列化的延迟度量？

我有一个基本的

ObjectMapper

，为对象中的属性配置了自定义序列化程序和反序列化程序。我想使用测微计

计时器
计时器捕获整个对象序列化和反序列化的延迟

我可以在顶级对象级别添加自定义序列化器和反序列化器，而不仅仅是我拥有它的属性，并传入
计时器
以捕获度量。但是，这将需要显式地解析整个对象，其唯一目的是捕获度量。我希望得到反馈，这是唯一的选择，还是有更好的方法来实现这一点

我正在处理的对象

公共类人物{
字符串名；
智力年龄；
地址
}

我有自定义序列化程序和反序列化程序的属性

公共类地址{
字符串addLineOne；
字符串addline2；
int-zipCode；
}

ObjectMapper
已配置

@Bean
公共对象映射器对象映射器（）{
ObjectMapper ObjectMapper=新的ObjectMapper（）；
objectMapper.setSerializationInclusion（JsonInclude.Include.NON_NULL）；
objectMapper.configure（在未知属性上反序列化.FAIL\u，false）；
SimpleModule=新的SimpleModule（）；
addDeserializer（Address.class，新的AddressDeserializer（））；
module.addSerializer（Address.class，新的AddressSerializer（））；
objectMapper.registerModule（模块）；
返回对象映射器；
}
对于
POJO
反序列化
Jackson
默认情况下使用
com.fasterxml.Jackson.databind.desr.BeanDeserializer
类。我们可以使用
com.fasterxml.jackson.databind.desr.beandSerializerModifier
类来扩展和注册它。下面的例子说明了这个想法：

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.BeanDescription;
import com.fasterxml.jackson.databind.DeserializationConfig;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.deser.BeanDeserializer;
import com.fasterxml.jackson.databind.deser.BeanDeserializerBase;
import com.fasterxml.jackson.databind.deser.BeanDeserializerModifier;
import com.fasterxml.jackson.databind.module.SimpleModule;

import java.io.IOException;

public class JsonApp {

    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = objectMapper();
        String json = mapper.writeValueAsString(new Person());

        for (int i = 0; i < 10; i++) {
            mapper.readValue(json, Person.class);
        }
    }

    public static ObjectMapper objectMapper() {
        ObjectMapper objectMapper = new ObjectMapper();

        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

        SimpleModule module = new SimpleModule();
        module.setDeserializerModifier(new BeanDeserializerModifier() {
            @Override
            public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config, BeanDescription beanDesc, JsonDeserializer<?> deserializer) {
                if (deserializer instanceof BeanDeserializer && beanDesc.getBeanClass() == Person.class) {
                    return new TimerBeanDeserializer((BeanDeserializerBase) deserializer);
                }
                return super.modifyDeserializer(config, beanDesc, deserializer);
            }
        });
        module.addDeserializer(Address.class, new AddressDeserializer());
        module.addSerializer(Address.class, new AddressSerializer());
        objectMapper.registerModule(module);

        return objectMapper;
    }
}

class TimerBeanDeserializer extends BeanDeserializer {

    private Timer timer = new Timer();

    protected TimerBeanDeserializer(BeanDeserializerBase src) {
        super(src);
    }

    @Override
    public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
        timer.start();
        Object res = super.deserialize(p, ctxt);
        System.out.println("Deserialization took: " + timer.end() + " nanos");

        return res;
    }
}

class Timer {
    private long start;

    public void start() {
        this.start = System.nanoTime();
    }

    public long end() {
        return System.nanoTime() - start;
    }
}

另见：




如果您对objectmapper上的操作计时感兴趣，从而对序列化计时，为什么不从objectmapper继承并在重写的方法中添加计时信息呢？
Deserialization took: 660853 nanos
Deserialization took: 48276 nanos
Deserialization took: 43741 nanos
Deserialization took: 44786 nanos
Deserialization took: 39230 nanos
Deserialization took: 39917 nanos
Deserialization took: 39745 nanos
Deserialization took: 38330 nanos
Deserialization took: 38994 nanos
Deserialization took: 38717 nanos