解决 seata 序列化异常

已于 2022-08-17 16:14:37 修改
阅读量1.3k 收藏
点赞数
文章标签： java 后端 数据库 分布式
于 2022-07-15 14:27:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46998705/article/details/125803519
版权

最近使用 seata 当分布事务回滚发现，回滚失败，而日志一直在打印序列化的问题。根据网上博客和 issue 的记录，最终解决方案如下：

根据 github-issue 发现需要等待版本更新或是更新依赖。觉得太过麻烦，这里参考 issue 与 掘金-seata中undolog报LocalDateTime转换异常，源码层分析和处理 的方式，最终是如下解决：这里以 json 方式为例，这个问题在 1.5.0 以上的版本已经修改，这里将 1.5.0 的 undoLog 解析类，的代码复制下来 github-1.5.0 版本的解析类。

定义解析类代码

这个是 seata 1.5.0 版本的json方式解析类，这里进行了修改，@LoadLevel(name = MyJacksonUndoLogParser.NAME)定义了序列方式的名称，这里我定义了为myJackson。

import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.core.type.WritableTypeId;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.std.JsonNodeDeserializer;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.ser.std.ArraySerializerBase;
import io.seata.common.Constants;
import io.seata.common.executor.Initialize;
import io.seata.common.loader.EnhancedServiceLoader;
import io.seata.common.loader.EnhancedServiceNotFoundException;
import io.seata.common.loader.LoadLevel;
import io.seata.common.util.CollectionUtils;
import io.seata.rm.datasource.undo.BranchUndoLog;
import io.seata.rm.datasource.undo.UndoLogParser;
import io.seata.rm.datasource.undo.parser.spi.JacksonSerializer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.sql.rowset.serial.SerialBlob;
import javax.sql.rowset.serial.SerialClob;
import javax.sql.rowset.serial.SerialException;
import java.io.IOException;
import java.io.Reader;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;

/**
 * The type Json based undo log parser.
 *
 * @author jsbxyyx
 */
@LoadLevel(name = MyJacksonUndoLogParser.NAME)
public class MyJacksonUndoLogParser implements UndoLogParser, Initialize {

    public static final String NAME = "myJackson";

    private static final Logger LOGGER = LoggerFactory.getLogger(MyJacksonUndoLogParser.class);

    /**
     * the zoneId for LocalDateTime
     */
    private static ZoneId zoneId = ZoneId.systemDefault();

    private final ObjectMapper mapper = new ObjectMapper();

    private final SimpleModule module = new SimpleModule();

    /**
     * customize serializer for java.sql.Timestamp
     */
    private final JsonSerializer timestampSerializer = new TimestampSerializer();

    /**
     * customize deserializer for java.sql.Timestamp
     */
    private final JsonDeserializer timestampDeserializer = new TimestampDeserializer();

    /**
     * customize serializer of java.sql.Blob
     */
    private final JsonSerializer blobSerializer = new BlobSerializer();

    /**
     * customize deserializer of java.sql.Blob
     */
    private final JsonDeserializer blobDeserializer = new BlobDeserializer();

    /**
     * customize serializer of java.sql.Clob
     */
    private final JsonSerializer clobSerializer = new ClobSerializer();

    /**
     * customize deserializer of java.sql.Clob
     */
    private final JsonDeserializer clobDeserializer = new ClobDeserializer();

    /**
     * customize serializer of java.time.LocalDateTime
     */
    private final JsonSerializer localDateTimeSerializer = new LocalDateTimeSerializer();

    /**
     * customize deserializer of java.time.LocalDateTime
     */
    private final JsonDeserializer localDateTimeDeserializer = new LocalDateTimeDeserializer();

    @Override
    public void init() {
        try {
            List<JacksonSerializer> jacksonSerializers = EnhancedServiceLoader.loadAll(JacksonSerializer.class);
            if (CollectionUtils.isNotEmpty(jacksonSerializers)) {
                for (JacksonSerializer jacksonSerializer : jacksonSerializers) {
                    Class type = jacksonSerializer.type();
                    JsonSerializer ser = jacksonSerializer.ser();
                    JsonDeserializer deser = jacksonSerializer.deser();
                    if (type != null) {
                        if (ser != null) {
                            module.addSerializer(type, ser);
                        }
                        if (deser != null) {
                            module.addDeserializer(type, deser);
                        }
                        LOGGER.info("jackson undo log parser load [{}].", jacksonSerializer.getClass().getName());
                    }
                }
            }
        } catch (EnhancedServiceNotFoundException e) {
            LOGGER.warn("JacksonSerializer not found children class.", e);
        }

        module.addSerializer(Timestamp.class, timestampSerializer);
        module.addDeserializer(Timestamp.class, timestampDeserializer);
        module.addSerializer(SerialBlob.class, blobSerializer);
        module.addDeserializer(SerialBlob.class, blobDeserializer);
        module.addSerializer(SerialClob.class, clobSerializer);
        module.addDeserializer(SerialClob.class, clobDeserializer);
        module.addSerializer(LocalDateTime.class, localDateTimeSerializer);
        module.addDeserializer(LocalDateTime.class, localDateTimeDeserializer);
        mapper.registerModule(module);
        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        mapper.enable(MapperFeature.PROPAGATE_TRANSIENT_MARKER);
    }

    @Override
    public String getName() {
        return NAME;
    }

    @Override
    public byte[] getDefaultContent() {
        return "{}".getBytes(Constants.DEFAULT_CHARSET);
    }

    @Override
    public byte[] encode(BranchUndoLog branchUndoLog) {
        try {
            return mapper.writeValueAsBytes(branchUndoLog);
        } catch (JsonProcessingException e) {
            LOGGER.error("json encode exception, {}", e.getMessage(), e);
            throw new RuntimeException(e);
        }
    }

    @Override
    public BranchUndoLog decode(byte[] bytes) {
        try {
            BranchUndoLog branchUndoLog;
            if (Arrays.equals(bytes, getDefaultContent())) {
                branchUndoLog = new BranchUndoLog();
            } else {
                branchUndoLog = mapper.readValue(bytes, BranchUndoLog.class);
            }
            return branchUndoLog;
        } catch (IOException e) {
            LOGGER.error("json decode exception, {}", e.getMessage(), e);
            throw new RuntimeException(e);
        }
    }

    /**
     * if necessary
     * extend {@link ArraySerializerBase}
     */
    private static class TimestampSerializer extends JsonSerializer<Timestamp> {

        @Override
        public void serializeWithType(Timestamp timestamp, JsonGenerator gen, SerializerProvider serializers,
                                      TypeSerializer typeSerializer) throws IOException {
            JsonToken valueShape = JsonToken.VALUE_NUMBER_INT;
            // if has microseconds, serialized as an array
            if (timestamp.getNanos() % 1000000 > 0) {
                valueShape = JsonToken.START_ARRAY;
            }

            WritableTypeId typeId = typeSerializer.writeTypePrefix(gen,
                    typeSerializer.typeId(timestamp, valueShape));
            serialize(timestamp, gen, serializers);
            gen.writeTypeSuffix(typeId);
        }

        @Override
        public void serialize(Timestamp timestamp, JsonGenerator gen, SerializerProvider serializers) {
            try {
                gen.writeNumber(timestamp.getTime());
                // if has microseconds, serialized as an array, write the nanos to the array
                if (timestamp.getNanos() % 1000000 > 0) {
                    gen.writeNumber(timestamp.getNanos());
                }
            } catch (IOException e) {
                LOGGER.error("serialize java.sql.Timestamp error : {}", e.getMessage(), e);
            }
        }
    }

    /**
     * if necessary
     * extend {@link JsonNodeDeserializer}
     */
    private static class TimestampDeserializer extends JsonDeserializer<Timestamp> {

        @Override
        public Timestamp deserialize(JsonParser p, DeserializationContext ctxt) {
            try {
                if (p.isExpectedStartArrayToken()) {
                    ArrayNode arrayNode = p.getCodec().readTree(p);
                    Timestamp timestamp = new Timestamp(arrayNode.get(0).asLong());
                    timestamp.setNanos(arrayNode.get(1).asInt());
                    return timestamp;
                } else {
                    long timestamp = p.getLongValue();
                    return new Timestamp(timestamp);
                }
            } catch (IOException e) {
                LOGGER.error("deserialize java.sql.Timestamp error : {}", e.getMessage(), e);
            }
            return null;
        }
    }

    /**
     * the class of serialize blob type
     */
    private static class BlobSerializer extends JsonSerializer<SerialBlob> {

        @Override
        public void serializeWithType(SerialBlob blob, JsonGenerator gen, SerializerProvider serializers,
                                      TypeSerializer typeSer) throws IOException {
            WritableTypeId typeIdDef = typeSer.writeTypePrefix(gen,
                    typeSer.typeId(blob, JsonToken.VALUE_EMBEDDED_OBJECT));
            serialize(blob, gen, serializers);
            typeSer.writeTypeSuffix(gen, typeIdDef);
        }

        @Override
        public void serialize(SerialBlob blob, JsonGenerator gen, SerializerProvider serializers) throws IOException {
            try {
                gen.writeBinary(blob.getBytes(1, (int)blob.length()));
            } catch (SerialException e) {
                LOGGER.error("serialize java.sql.Blob error : {}", e.getMessage(), e);
            }
        }
    }

    /**
     * the class of deserialize blob type
     */
    private static class BlobDeserializer extends JsonDeserializer<SerialBlob> {

        @Override
        public SerialBlob deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
            try {
                return new SerialBlob(p.getBinaryValue());
            } catch (SQLException e) {
                LOGGER.error("deserialize java.sql.Blob error : {}", e.getMessage(), e);
            }
            return null;
        }
    }

    /**
     * the class of serialize clob type
     */
    private static class ClobSerializer extends JsonSerializer<SerialClob> {

        @Override
        public void serializeWithType(SerialClob clob, JsonGenerator gen, SerializerProvider serializers,
                                      TypeSerializer typeSer) throws IOException {
            WritableTypeId typeIdDef = typeSer.writeTypePrefix(gen,
                    typeSer.typeId(clob, JsonToken.VALUE_EMBEDDED_OBJECT));
            serialize(clob, gen, serializers);
            typeSer.writeTypeSuffix(gen, typeIdDef);
        }

        @Override
        public void serialize(SerialClob clob, JsonGenerator gen, SerializerProvider serializers) throws IOException {
            try (Reader r = clob.getCharacterStream()) {
                gen.writeString(r, (int)clob.length());
            } catch (SerialException e) {
                LOGGER.error("serialize java.sql.Blob error : {}", e.getMessage(), e);
            }
        }
    }

    private static class ClobDeserializer extends JsonDeserializer<SerialClob> {

        @Override
        public SerialClob deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
            try {
                return new SerialClob(p.getValueAsString().toCharArray());
            } catch (SQLException e) {
                LOGGER.error("deserialize java.sql.Clob error : {}", e.getMessage(), e);
            }
            return null;
        }
    }

    /**
     * the class of serialize LocalDateTime type
     */
    private static class LocalDateTimeSerializer extends JsonSerializer<LocalDateTime> {

        @Override
        public void serializeWithType(LocalDateTime localDateTime, JsonGenerator gen, SerializerProvider serializers,
                                      TypeSerializer typeSer) throws IOException {
            JsonToken valueShape = JsonToken.VALUE_NUMBER_INT;
            // if has microseconds, serialized as an array
            if (localDateTime.getNano() % 1000000 > 0) {
                valueShape = JsonToken.START_ARRAY;
            }

            WritableTypeId typeIdDef = typeSer.writeTypePrefix(gen,
                    typeSer.typeId(localDateTime, valueShape));
            serialize(localDateTime, gen, serializers);
            typeSer.writeTypeSuffix(gen, typeIdDef);
        }

        @Override
        public void serialize(LocalDateTime localDateTime, JsonGenerator gen, SerializerProvider serializers) throws IOException {
            try {
                Instant instant = localDateTime.atZone(zoneId).toInstant();
                gen.writeNumber(instant.toEpochMilli());
                // if has microseconds, serialized as an array, write the nano to the array
                if (instant.getNano() % 1000000 > 0) {
                    gen.writeNumber(instant.getNano());
                }
            } catch (IOException e) {
                LOGGER.error("serialize java.time.LocalDateTime error : {}", e.getMessage(), e);
            }
        }
    }

    /**
     * the class of deserialize LocalDateTime type
     */
    private static class LocalDateTimeDeserializer extends JsonDeserializer<LocalDateTime> {

        @Override
        public LocalDateTime deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
            try {
                Instant instant;
                if (p.isExpectedStartArrayToken()) {
                    ArrayNode arrayNode = p.getCodec().readTree(p);
                    long timestamp = arrayNode.get(0).asLong();
                    instant = Instant.ofEpochMilli(timestamp);
                    if (arrayNode.size() > 1) {
                        int nano = arrayNode.get(1).asInt();
                        instant = instant.plusNanos(nano % 1000000);
                    }
                } else {
                    long timestamp = p.getLongValue();
                    instant = Instant.ofEpochMilli(timestamp);
                }
                return LocalDateTime.ofInstant(instant, zoneId);
            } catch (Exception e) {
                LOGGER.error("deserialize java.time.LocalDateTime error : {}", e.getMessage(), e);
            }
            return null;
        }
    }

    /**
     * set zone id
     *
     * @param zoneId the zoneId
     */
    public static void setZoneOffset(ZoneId zoneId) {
        Objects.requireNonNull(zoneId, "zoneId must be not null");
        MyJacksonUndoLogParser.zoneId = zoneId;
    }


}

定义 services 文件

在 META-INF/services 目录中定义名称为io.seata.rm.datasource.undo.UndoLogParser的文件，将复制下来的解析类，类全路径写入。如我的：

com.old.seata.MyJacksonUndoLogParser

undoLogParser spi

配置 undo_log 的解析方式

注意， seata 的客户端使用不同的配置方式，配置 undo_log 的序列化方式就不同，所以可能和使用者的不同。需要注意这点。最重要的一点是看序列化类是否有初始化，在请求时对序列化类进行断点，查看是否有初始化。如果没有初始化表示配置的方式不对。

以 yml 为例，**注意：**要与类上注解定义的名称相同。

seata:
  client:
    undo:
      logSerialization: myJackson

完成之后这三步之后，再次进行事务的回滚即可避免序列化异常的问题，不过要确定 client.undo.logSerialization 的配置是否生效。

1854君
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【Seata】分布式事务框架Seata踩坑集锦，火爆全网MySQL路线笔记
2401_84103191的博客
04-10 699
说句实话，如果一个打工人不想提升自己，那便没有工作的意义，毕竟大家也没有到养老的年龄。当你的技术在一步步贴近阿里p7水平的时候，毫无疑问你的薪资肯定会涨，同时你能学到更多更深的技术，交结到更厉害的大牛。推荐一份Java架构之路必备的学习笔记，内容相当全面！！！成年人的世界没有容易二字，前段时间刷抖音看到一个程序员连着加班两星期到半夜2点的视频。在这个行业若想要拿高薪除了提高硬实力别无他法。你知道吗？现在有的应届生实习薪资都已经赶超开发5年的程序员了，实习薪资26K，30K，你没有紧迫感吗？
seata0.8.1
05-21
5. **可扩展性**：Seata 的架构设计允许通过插件化的方式扩展事务协调器、存储引擎等组件，适应不同的环境需求。 ### Seata 的工作原理 Seata 分为三个主要组件：TM（Transaction Manager）、RM（Resource Manager...
seata序列化问题
zbh1957282580的博客
06-19 1509
seata datetime字段序列化问题 个人解决方案： 在2022年5月17号官方地址，官方推出的1.5.1版本的解决了这个序列化问题： 引入下面依赖：一定要版本
nacos集成分布式事务插件Seata的序列化问题，实际上是Seata本身存在bug！！
玩火的稻草人的博客
06-29 2138
最近做微服务，更换了分布式事务组件seata的版本，出现了莫名其妙的问题，分析了好长时间也没有找出问题，最后看了网络高手的帖子，最后解决了问题。 1、错误现象 17:10:46.037 [http-nio-9204-exec-1] ERROR i.s.r.d.u.p.JacksonUndoLogParser - [encode,127] - json encode exception, Type id handling not implemented for type java.lang.Object (b
springcloud seata 1.3使用心得 service模块 undolog序列化问题
weixin_37791473的博客
12-07 991
seata 1.3版本file.conf配置 以及undolog 序列化
Seata入门系列(6)- undo_log支持的多种序列化方式
记录知识、锤炼自我
01-25 2943
文章目录rollback_infoundo 配置项支持的序列化方式自定义序列化使用fastjson时的主要事项 rollback_info 在undo_log表中，rollback_info字段存储了事务失败时，需要回滚的相关信息，该字段为longblob类型（二进制数据）。 在Navicat 中，可以选中当前数据，然后通过查看选择文本方式展示。 通过Json 格式化工具，可以查看到详细信息。 undo 配置项 @Component @ConfigurationProperties( prefi
Seata遇到的问题
xhq6288038的博客
10-21 604
1.jar包问题 服务端 seata-server 1.2 正确配置： <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-seata</artifactId> <version>2.2.0.RELEASE</version> <exclusions>
seata分布式事务解决方案
10-15
Seata（Simple Extensible Autonomous Transaction Architecture）是一款开源的分布式事务解决方案，旨在提供高性能和简单易用的分布式事务服务。在微服务架构中，由于服务之间的交互变得复杂，单个数据库事务无法...
Seata搭建初始化sql
最新发布
04-26
分布式事务seata搭建初始化sql
分布式事务解决方案Seata 框架学习代码 Demo
02-22
分布式事务解决方案Seata 框架学习代码 Demo 。里面包含了完成的seata使用代码，包括AT、TCC、XA等模式的直接使用案例。开箱即用。 分布式事务解决方案Seata 框架学习代码 Demo 。里面包含了完成的seata使用代码，...
seata-1.3.0.zip
08-24
在1.3.0版本中，Seata提供了多种事务处理模式，包括AT（Automatic Two-Phase Commit）、TCC（Try-Confirm-Cancel）、SAGA（Saga）以及XA，为开发者提供了多样化的选择来适应不同的业务场景。 **AT模式**是Seata中最...
seata nacos 整合 异常
xiyeming的博客
07-27 845
seata nacos 整合异常
springcloud-alibaba学习笔记（五）seata使用(当oracle中使用TIMESTAMP类型导致undolog序列化失败)
sssdal19995的博客
02-28 1808
场景 使用seata + oracle 实现分布式事务 ，当表中存在一个字段使用的是TIMESTAMP类型，那么在开启分布式事务的时候jackson会报出一个序列化失败的错误 报错信息 2021-02-28 20:43:43.358 ERROR 12964 — [nio-8865-exec-2] i.s.r.d.u.parser.JacksonUndoLogParser : json encode exception, No serializer found for class java.io.B
seata
qq_27579471的博客
03-15 585
seata中文官网 从v1.4.2版本开始，已支持从一个Nacos dataId中获取所有配置信息,你只需要额外添加一个dataId配置项 注意Server和Client的命名空间和组要一致
Seata 序列化问题
qq_33776323的博客
12-22 164
seata序列化问题，出现序列化问题可能因为部分版本bug,可以考虑升级客户端版本。
Java Seata使用常见错误
letterljhx的博客
11-09 701
Java Seata使用常见错误
Seata json decode exception, Cannot construct instance of `java.time.LocalDateTime`问题，有效解决！
Hang的博客
08-09 601
seata回滚报错Seata json decode exception, Cannot construct instance of `java.time.LocalDateTime`
Spring集成Seata项目无法进行Feign调用
m0_47333020的博客
11-09 2296
问题描述 两个微服务 用户微服务加入了Seata并使用了数据库 文件微服务未使用Seata也未使用数据库 使用用户微服务Feign调用文件微服务时调用失败 探寻原因 考虑到之前没有加入Seata之前能够成功Feign调用 排除把用户微服务Seata除去的尝试 就剩给文件微服务加上Seata了。。。 如果要加上Seata就需要有undo_log表 那就新建一个数据库试试 配上数据库 配上Seata 加入Seata依赖 配上必要的文件 最后把不自动加载数据库的配置删了 然后
seata1.4.2异常：feign远程调用时，服务提供方全局事务未生效（不回滚）
qq_42154996的博客
08-21 3253
https://note.youdao.com/s/P9mL0BKi
提供解决seata不能序列化LocalDateTime
05-17
如果你在使用 Seata 分布式事务框架时，遇到了不能序列化 LocalDateTime 的问题，可以尝试以下解决方案： 1. 升级 Seata 版本到 1.4.0 或以上，这个版本已经修复了 LocalDateTime 序列化的问题。 2. 如果不能升级 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值