How to use org.dromara.raincat.common.serializer

/**
 * acquire Schema with class.
 * @param clazz Class
 * @return Schema<?>
 */
public Schema<?> get(final Class<?> clazz) {
  return get(clazz, cache);
}

private TransactionRecoverAdapter readRecover(final File file) {
  try {
    try (FileInputStream fis = new FileInputStream(file)) {
      byte[] content = new byte[(int) file.length()];
      fis.read(content);
      return objectSerializer.deSerialize(content, TransactionRecoverAdapter.class);
    }
  } catch (Exception e) {
    e.printStackTrace();
    return null;
  }
}

private void writeFile(final TransactionRecoverAdapter adapter, final String fullFileName) {
  try {
    RandomAccessFile raf = new RandomAccessFile(fullFileName, "rw");
    try (FileChannel channel = raf.getChannel()) {
      byte[] content = objectSerializer.serialize(adapter);
      ByteBuffer buffer = ByteBuffer.allocate(content.length);
      buffer.put(content);
      buffer.flip();
      while (buffer.hasRemaining()) {
        channel.write(buffer);
      }
      channel.force(true);
    }
  } catch (Exception e) {
    e.printStackTrace();
  }
}

@Override
public Boolean updateRetry(final String id, final Integer retry, final String applicationName) {
  if (StringUtils.isBlank(id) || StringUtils.isBlank(applicationName) || Objects.isNull(retry)) {
    return Boolean.FALSE;
  }
  final String rootPath = RepositoryPathUtils.buildZookeeperPath(applicationName);
  final String path = buildRootPath(rootPath, id);
  try {
    byte[] content = zooKeeper.getData(path,
        false, new Stat());
    final TransactionRecoverAdapter adapter =
        objectSerializer.deSerialize(content, TransactionRecoverAdapter.class);
    adapter.setLastTime(DateUtils.getDateYYYY());
    adapter.setRetriedCount(retry);
    zooKeeper.create(path,
        objectSerializer.serialize(adapter),
        ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
    return Boolean.TRUE;
  } catch (Exception e) {
    e.printStackTrace();
  }
  return Boolean.FALSE;
}

@Bean
public ObjectSerializer objectSerializer() {
  final SerializeProtocolEnum serializeProtocolEnum =
      SerializeProtocolEnum.acquireSerializeProtocol(env.getProperty("recover.serializer.support"));
  final ServiceLoader<ObjectSerializer> objectSerializers =
      ServiceBootstrap.loadAll(ObjectSerializer.class);
  return StreamSupport.stream(objectSerializers.spliterator(), false)
      .filter(objectSerializer ->
          Objects.equals(objectSerializer.getScheme(),
              serializeProtocolEnum.getSerializeProtocol())).findFirst().orElse(new KryoSerializer());
}

@Override
public <T> T deSerialize(final byte[] param, final Class<T> clazz) throws TransactionException {
  T object;
  try (ByteArrayInputStream inputStream = new ByteArrayInputStream(param)) {
    object = OBJENESIS.newInstance(clazz);
    Schema schema = getSchema((Class) clazz);
    ProtostuffIOUtil.mergeFrom(inputStream, object, schema);
    return object;
  } catch (IOException e) {
    throw new TransactionException(e.getMessage(), e);
  }
}

private TransactionRecoverVO readTransaction(final File file) {
  try {
    try (FileInputStream fis = new FileInputStream(file)) {
      byte[] content = new byte[(int) file.length()];
      fis.read(content);
      final TransactionRecoverAdapter adapter = objectSerializer.deSerialize(content, TransactionRecoverAdapter.class);
      return ConvertHelper.buildVO(adapter);
    }
  } catch (Exception e) {
    e.printStackTrace();
    return null;
  }
}

@Override
public Boolean updateRetry(final String id, final Integer retry, final String applicationName) {
  if (StringUtils.isBlank(id) || StringUtils.isBlank(applicationName) || Objects.isNull(retry)) {
    return Boolean.FALSE;
  }
  String keyPrefix = RepositoryPathUtils.buildRedisKey(applicationName);
  final String key = cacheKey(keyPrefix, id);
  final byte[] bytes = jedisClient.get(key.getBytes());
  try {
    final TransactionRecoverAdapter adapter =
        objectSerializer.deSerialize(bytes, TransactionRecoverAdapter.class);
    adapter.setRetriedCount(retry);
    adapter.setLastTime(DateUtils.getDateYYYY());
    jedisClient.set(key, objectSerializer.serialize(adapter));
    return Boolean.TRUE;
  } catch (Exception e) {
    e.printStackTrace();
    return Boolean.FALSE;
  }
}

public static byte[] convert(final TransactionRecover transactionRecover, final ObjectSerializer objectSerializer) throws TransactionException {
  TransactionRecoverAdapter adapter = new TransactionRecoverAdapter();
  final TransactionInvocation transactionInvocation = transactionRecover.getTransactionInvocation();
  adapter.setGroupId(transactionRecover.getGroupId());
  adapter.setLastTime(transactionRecover.getLastTime());
  adapter.setRetriedCount(transactionRecover.getRetriedCount());
  adapter.setStatus(transactionRecover.getStatus());
  adapter.setTaskId(transactionRecover.getTaskId());
  adapter.setTransId(transactionRecover.getId());
  adapter.setTargetClass(transactionInvocation.getTargetClazz().getName());
  adapter.setTargetMethod(transactionInvocation.getMethod());
  adapter.setCreateTime(transactionRecover.getCreateTime());
  adapter.setContents(objectSerializer.serialize(transactionInvocation));
  adapter.setVersion(transactionRecover.getVersion());
  adapter.setCompleteFlag(transactionRecover.getCompleteFlag());
  adapter.setOperation(transactionRecover.getOperation());
  return objectSerializer.serialize(adapter);
}

/**
 * load spi.
 *
 * @param txConfig {@linkplain TxConfig}
 */
private void loadSpi(final TxConfig txConfig) {
  //spi  serialize
  final SerializeProtocolEnum serializeProtocolEnum
      = SerializeProtocolEnum.acquireSerializeProtocol(txConfig.getSerializer());
  final ServiceLoader<ObjectSerializer> objectSerializers
      = ServiceBootstrap.loadAll(ObjectSerializer.class);
  final ObjectSerializer serializer =
      StreamSupport.stream(objectSerializers.spliterator(), false)
          .filter(s -> Objects.equals(s.getScheme(), serializeProtocolEnum.getSerializeProtocol()))
          .findFirst().orElse(new KryoSerializer());
  //spi  RecoverRepository support
  final CompensationCacheTypeEnum compensationCacheTypeEnum
      = CompensationCacheTypeEnum.acquireCompensationCacheType(txConfig.getCompensationCacheType());
  final ServiceLoader<TransactionRecoverRepository> recoverRepositories
      = ServiceBootstrap.loadAll(TransactionRecoverRepository.class);
  final TransactionRecoverRepository repository =
      StreamSupport.stream(recoverRepositories.spliterator(), false)
          .filter(r -> Objects.equals(r.getScheme(), compensationCacheTypeEnum.getCompensationCacheType()))
          .findFirst().orElse(new JdbcTransactionRecoverRepository());
  //将compensationCache实现注入到spring容器
  repository.setSerializer(serializer);
  SpringBeanUtils.getInstance().registerBean(TransactionRecoverRepository.class.getName(), repository);
}

private static <T> Schema<T> getSchema(final Class<T> cls) {
  return (Schema<T>) CACHED_SCHEMA.get(cls);
}

@Override
public byte[] serialize(final Object obj) throws TransactionException {
  Class cls = obj.getClass();
  LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
  try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
    Schema schema = getSchema(cls);
    ProtostuffIOUtil.writeTo(outputStream, obj, schema, buffer);
    return outputStream.toByteArray();
  } catch (IOException e) {
    throw new TransactionException(e.getMessage(), e);
  } finally {
    buffer.clear();
  }
}

private TransactionRecoverVO buildByNodePath(final String rootPath, final String zNodePath) {
  try {
    byte[] content = zooKeeper.getData(buildRootPath(rootPath, zNodePath),
        false, new Stat());
    final TransactionRecoverAdapter adapter =
        objectSerializer.deSerialize(content, TransactionRecoverAdapter.class);
    return ConvertHelper.buildVO(adapter);
  } catch (KeeperException | InterruptedException | TransactionException e) {
    e.printStackTrace();
  }
  return null;
}

@Override
public int create(final TransactionRecover recover) {
  String sql = "insert into " + tableName
      + "(id,target_class,target_method,retried_count,create_time,last_time,version,group_id,task_id,invocation,complete_flag,operation)"
      + " values(?,?,?,?,?,?,?,?,?,?,?,?)";
  try {
    final TransactionInvocation transactionInvocation = recover.getTransactionInvocation();
    final String className = transactionInvocation.getTargetClazz().getName();
    final String method = transactionInvocation.getMethod();
    final byte[] serialize = serializer.serialize(transactionInvocation);
    return executeUpdate(sql, recover.getId(), className,
        method, recover.getRetriedCount(),
        recover.getCreateTime(), recover.getLastTime(),
        recover.getVersion(), recover.getGroupId(),
        recover.getTaskId(), serialize, recover.getCompleteFlag(), recover.getOperation());
  } catch (TransactionException e) {
    e.printStackTrace();
    return FAIL_ROWS;
  }
}

private TransactionRecoverVO buildVOByKey(final byte[] key) {
  final byte[] bytes = jedisClient.get(key);
  final TransactionRecoverAdapter adapter;
  try {
    adapter = objectSerializer.deSerialize(bytes, TransactionRecoverAdapter.class);
    return ConvertHelper.buildVO(adapter);
  } catch (TransactionException e) {
    e.printStackTrace();
  }
  return null;
}

@Override
public int create(final TransactionRecover transactionRecover) {
  try {
    MongoAdapter mongoAdapter = new MongoAdapter();
    mongoAdapter.setTransId(transactionRecover.getId());
    mongoAdapter.setCreateTime(transactionRecover.getCreateTime());
    mongoAdapter.setGroupId(transactionRecover.getGroupId());
    mongoAdapter.setLastTime(transactionRecover.getLastTime());
    mongoAdapter.setTaskId(transactionRecover.getTaskId());
    mongoAdapter.setRetriedCount(transactionRecover.getRetriedCount());
    mongoAdapter.setStatus(transactionRecover.getStatus());
    mongoAdapter.setVersion(transactionRecover.getVersion());
    final TransactionInvocation invocation = transactionRecover.getTransactionInvocation();
    mongoAdapter.setTargetClass(invocation.getTargetClazz().getName());
    mongoAdapter.setTargetMethod(invocation.getMethod());
    mongoAdapter.setContents(objectSerializer.serialize(invocation));
    mongoAdapter.setCompleteFlag(transactionRecover.getCompleteFlag());
    mongoAdapter.setOperation(transactionRecover.getOperation());
    template.save(mongoAdapter, collectionName);
  } catch (TransactionException e) {
    e.printStackTrace();
  }
  return ROWS;
}

private TransactionRecover buildByMap(final Map<String, Object> map) {
  TransactionRecover recover = new TransactionRecover();
  recover.setId((String) map.get("id"));
  recover.setRetriedCount((Integer) map.get("retried_count"));
  recover.setCreateTime((Date) map.get("create_time"));
  recover.setLastTime((Date) map.get("last_time"));
  recover.setTaskId((String) map.get("task_id"));
  recover.setGroupId((String) map.get("group_id"));
  recover.setVersion((Integer) map.get("version"));
  recover.setCompleteFlag(String.valueOf(map.get("complete_flag")));
  byte[] bytes = (byte[]) map.get("invocation");
  try {
    final TransactionInvocation transactionInvocation = serializer.deSerialize(bytes, TransactionInvocation.class);
    recover.setTransactionInvocation(transactionInvocation);
  } catch (TransactionException e) {
    e.printStackTrace();
  }
  return recover;
}

  public static TransactionRecover transformBean(final byte[] contents, final ObjectSerializer objectSerializer) throws TransactionException {
    TransactionRecover transactionRecover = new TransactionRecover();
    final TransactionRecoverAdapter adapter = objectSerializer.deSerialize(contents, TransactionRecoverAdapter.class);
    TransactionInvocation transactionInvocation = objectSerializer.deSerialize(adapter.getContents(), TransactionInvocation.class);
    transactionRecover.setLastTime(adapter.getLastTime());
    transactionRecover.setRetriedCount(adapter.getRetriedCount());
    transactionRecover.setCreateTime(adapter.getCreateTime());
    transactionRecover.setGroupId(adapter.getGroupId());
    transactionRecover.setId(adapter.getTransId());
    transactionRecover.setTaskId(adapter.getTaskId());
    transactionRecover.setStatus(adapter.getStatus());
    transactionRecover.setTransactionInvocation(transactionInvocation);
    transactionRecover.setVersion(adapter.getVersion());
    transactionRecover.setCompleteFlag(adapter.getCompleteFlag());
    transactionRecover.setOperation(adapter.getOperation());
    return transactionRecover;
  }
}

public static TransactionRecover transformVO(final byte[] contents, final ObjectSerializer objectSerializer) throws TransactionException {
  TransactionRecover transactionRecover = new TransactionRecover();
  final TransactionRecoverAdapter adapter = objectSerializer.deSerialize(contents, TransactionRecoverAdapter.class);
  transactionRecover.setLastTime(adapter.getLastTime());
  transactionRecover.setRetriedCount(adapter.getRetriedCount());
  transactionRecover.setCreateTime(adapter.getCreateTime());
  transactionRecover.setGroupId(adapter.getGroupId());
  transactionRecover.setId(adapter.getTransId());
  transactionRecover.setTaskId(adapter.getTaskId());
  transactionRecover.setStatus(adapter.getStatus());
  transactionRecover.setVersion(adapter.getVersion());
  transactionRecover.setCompleteFlag(adapter.getCompleteFlag());
  transactionRecover.setOperation(adapter.getOperation());
  return transactionRecover;
}

private TransactionRecover buildByCache(final MongoAdapter cache) {
  TransactionRecover recover = new TransactionRecover();
  recover.setId(cache.getTransId());
  recover.setCreateTime(cache.getCreateTime());
  recover.setGroupId(cache.getGroupId());
  recover.setTaskId(cache.getTaskId());
  recover.setLastTime(cache.getLastTime());
  recover.setRetriedCount(cache.getRetriedCount());
  recover.setVersion(cache.getVersion());
  recover.setStatus(cache.getStatus());
  recover.setCompleteFlag(cache.getCompleteFlag());
  recover.setOperation(cache.getOperation());
  final TransactionInvocation transactionInvocation;
  try {
    transactionInvocation = objectSerializer.deSerialize(cache.getContents(), TransactionInvocation.class);
    recover.setTransactionInvocation(transactionInvocation);
  } catch (TransactionException e) {
    LogUtil.error(LOGGER, "mongodb serialize exception:{}", e::getLocalizedMessage);
  }
  return recover;
}