SpringBoot 集成 Table Store

SpringBoot 集成 Table Store 实践。

TableStoreConfig

@Configuration
public class TableStoreConfig {

    @Value("${table.store.endPoint}")
    private String endPoint;
    @Value("${table.store.accessKeyId}")
    private String accessKeyId;
    @Value("${table.store.accessKeySecret}")
    private String accessKeySecret;
    @Value("${table.store.instanceName}")
    private String instanceName;


    @Bean("asyncClient")
    public AsyncClient getAsyncClient() {
        return new AsyncClient(endPoint, accessKeyId, accessKeySecret, instanceName);
    }

    @Bean("syncClient")
    public SyncClient getSyncClient() {
        return new SyncClient(endPoint, accessKeyId, accessKeySecret, instanceName);
    }
}

TableStoreTemplate

@Slf4j
@Component
public class TableStoreTemplate {

    @Resource(name = "syncClient")
    SyncClient syncClient;

    /**
     * 批量读取数据 单次请求中支持读取的最大行数为100行
     */
    private static final int BATCH_SIZE = 100;

    /**
     * 按指定模型输出
     *
     * @param tableName
     * @param pks
     * @param clazz
     * @param <T>
     * @return
     */
    public <T> Result<T> getOne(String tableName, LinkedHashMap<String, Object> pks, Class<T> clazz) {
        if (clazz == null) {
            return Result.newInstance(BizCodeEnum.PARAMS_NULL.getCode(), "缺少参数", null);
        }

        Result<Map<String, Object>> one = getOne(tableName, pks);
        if (!one.isSuccess()) {
            return Result.newInstance(one.getCode(), one.getMessage(), null);
        }

        Map<String, Object> data = one.getData();
        T t = BeanUtil.castToBean(data, clazz);
        return Result.newInstance(t);
    }

    /**
     * 批量读取数据
     *
     * @param tableName
     * @param pks
     * @return
     */
    public Result<Map<String, Object>> getOne(String tableName, LinkedHashMap<String, Object> pks) {

        if (tableName == null || pks == null || pks.isEmpty()) {
            return Result.newInstance(BizCodeEnum.PARAMS_NULL.getCode(), "缺少参数", null);
        }

        Result<Map<String, Object>> result = new Result<>();
        //读取一行数据，设置数据表名称。
        PrimaryKey primaryKey = buildPrimaryKey(pks);
        SingleRowQueryCriteria criteria = new SingleRowQueryCriteria(tableName, primaryKey);
        //设置读取最新版本。
        criteria.setMaxVersions(1);
        try {
            GetRowResponse getRowResponse = syncClient.getRow(new GetRowRequest(criteria));
            result.setData(convertRow2Map(getRowResponse.getRow()));
        } catch (ClientException ex) {
            result.setCode(BizCodeEnum.REMOTE_ERROR.getCode());
            result.setMessage("client error TraceId:" + ex.getTraceId());
            log.error("TableStoreTemplate get ClientException: ", ex);
            return result;
        } catch (TableStoreException ex) {
            result.setCode(BizCodeEnum.REMOTE_ERROR.getCode());
            result.setMessage("table store error, traceId:" + ex.getRequestId());
            log.error("TableStoreTemplate get TableStoreException: ", ex);
            log.error("data-interface getDataByPkValue TableStoreException,result:{}", result, ex);
            return result;
        } catch (Exception ex) {
            result.setCode(BizCodeEnum.REMOTE_ERROR.getCode());
            result.setMessage("TableStoreTemplate get exception, traceId:" + ex.getMessage());
            log.error("TableStoreTemplate exception,result:{}", result, ex);
            return result;
        }
        return result;
    }

    /**
     * 批量读取数据
     *
     * @param tableName
     * @param pkList
     * @param clazz
     * @param <T>
     * @return
     */
    public <T> Result<List<T>> getBatch(String tableName, List<LinkedHashMap<String, Object>> pkList, final Class<T> clazz) {

        Result<List<Map<String, Object>>> result = getBatch(tableName, pkList);
        if (!result.isSuccess()) {
            return Result.newInstance(result.getCode(), result.getMessage(), null);
        }
        List<Map<String, Object>> data = result.getData();
        List<T> list = BeanUtil.castToBeanList(data, clazz);
        return Result.newInstance(list);
    }

    /**
     * 批量读取数据
     *
     * @param tableName
     * @param pkList
     * @return
     */
    public Result<List<Map<String, Object>>> getBatch(String tableName, List<LinkedHashMap<String, Object>> pkList) {

        if (tableName == null || pkList == null || pkList.isEmpty()) {
            return Result.newInstance(BizCodeEnum.PARAMS_NULL.getCode(), "缺少参数", null);
        }
        List<Row> rowList = new ArrayList<>();
        List<List<LinkedHashMap<String, Object>>> batchPkList = Lists.partition(pkList, BATCH_SIZE);

        for (List<LinkedHashMap<String, Object>> oneBatchPk : batchPkList) {
            MultiRowQueryCriteria multiRowQueryCriteria = new MultiRowQueryCriteria(tableName);
            for (LinkedHashMap<String, Object> onePk : oneBatchPk) {
                PrimaryKey primaryKey = buildPrimaryKey(onePk);
                multiRowQueryCriteria.addRow(primaryKey);
            }
            multiRowQueryCriteria.setMaxVersions(1);
            BatchGetRowRequest batchGetRowRequest = new BatchGetRowRequest();
            batchGetRowRequest.addMultiRowQueryCriteria(multiRowQueryCriteria);

            try {
                BatchGetRowResponse batchGetRowResponse = syncClient.batchGetRow(batchGetRowRequest);

                if (!batchGetRowResponse.isAllSucceed()) {
                    for (BatchGetRowResponse.RowResult rowResult : batchGetRowResponse.getFailedRows()) {
                        log.error("TableStoreTemplate getBatch failed row：{}, error:{}",
                                batchGetRowRequest.getPrimaryKey(rowResult.getTableName(), rowResult.getIndex()), rowResult.getError());
                    }
                }
                List<BatchGetRowResponse.RowResult> rows = batchGetRowResponse.getSucceedRows();
                if (!CollectionUtils.isEmpty(rows)) {
                    for (BatchGetRowResponse.RowResult rowResult : rows) {
                        if (rowResult == null || rowResult.getRow() == null) {
                            continue;
                        }
                        rowList.add(rowResult.getRow());
                    }
                }
            } catch (ClientException | TableStoreException ex) {
                log.error("TableStoreTemplate getBatch client error: ", ex);
                return Result.newInstance(BizCodeEnum.REMOTE_ERROR.getCode(), "table store client error" + ex.getMessage(), null);
            } catch (Exception ex) {
                log.error("TableStoreTemplate getBatch error: ", ex);
                return Result.newInstance(BizCodeEnum.REMOTE_ERROR.getCode(), "table store error" + ex.getMessage(), null);
            }

        }
        if (CollectionUtils.isEmpty(rowList)) {
            return Result.newInstance(Collections.emptyList());
        }

        List<Map<String, Object>> resultList =
                rowList.stream().map(row -> convertRow2Map(row)).collect(Collectors.toList());

        return Result.newInstance(resultList);
    }

    /**
     * 范围读取数据
     *
     * @param tableName
     * @param startPk
     * @param endPk
     * @param clazz
     * @param <T>
     * @return
     */
    public <T> Result<List<T>> getRange(String tableName,
                                        LinkedHashMap<String, Object> startPk,
                                        LinkedHashMap<String, Object> endPk,
                                        Class<T> clazz) {

        Result<List<Map<String, Object>>> result = getRange(tableName, startPk, endPk);
        if (!result.isSuccess()) {
            return Result.newInstance(result.getCode(), result.getMessage(), null);
        }
        List<Map<String, Object>> data = result.getData();
        List<T> list = BeanUtil.castToBeanList(data, clazz);
        return Result.newInstance(list);
    }

    /**
     * 范围读取数据
     *
     * @param tableName
     * @param startPk
     * @param endPk
     * @return
     */
    public Result<List<Map<String, Object>>> getRange(String tableName,
                                                      LinkedHashMap<String, Object> startPk,
                                                      LinkedHashMap<String, Object> endPk) {

        if (tableName == null || startPk == null || endPk == null) {
            return Result.newInstance(BizCodeEnum.PARAMS_NULL.getCode(), "缺少参数", null);
        }
        List<Row> rowList = new ArrayList<>();
        RangeRowQueryCriteria rangeRowQueryCriteria = new RangeRowQueryCriteria(tableName);
        rangeRowQueryCriteria.setInclusiveStartPrimaryKey(buildRangePrimaryKey(true, startPk));
        rangeRowQueryCriteria.setExclusiveEndPrimaryKey(buildRangePrimaryKey(false, endPk));
        rangeRowQueryCriteria.setMaxVersions(1);

        while (true) {
            GetRangeResponse getRangeResponse;
            try {
                getRangeResponse = syncClient.getRange(new GetRangeRequest(rangeRowQueryCriteria));
            } catch (ClientException | TableStoreException ex) {
                log.error("TableStoreTemplate getRange client error: ", ex);
                return Result.newInstance(BizCodeEnum.REMOTE_ERROR.getCode(), "table store client error" + ex.getMessage(), null);
            } catch (Exception ex) {
                log.error("TableStoreTemplate getRange error: ", ex);
                return Result.newInstance(BizCodeEnum.REMOTE_ERROR.getCode(), "table store error" + ex.getMessage(), null);
            }
            for (Row row : getRangeResponse.getRows()) {
                rowList.add(row);
            }
            //如果NextStartPrimaryKey不为null，则继续读取。
            if (getRangeResponse.getNextStartPrimaryKey() == null) {
                break;
            }
            rangeRowQueryCriteria.setInclusiveStartPrimaryKey(getRangeResponse.getNextStartPrimaryKey());
        }
        if (CollectionUtils.isEmpty(rowList)) {
            return Result.newInstance(Collections.emptyList());
        }
        List<Map<String, Object>> resultList =
                rowList.stream().map(row -> convertRow2Map(row)).collect(Collectors.toList());
        return Result.newInstance(resultList);
    }

    /**
     * 保存数据
     *
     * @param tableName
     * @param pks
     * @param data
     * @param <T>
     * @return
     */
    public <T> Result<Integer> saveOne(String tableName, List<String> pks, T data) {
        if (tableName == null || pks == null || data == null) {
            return Result.newInstance(BizCodeEnum.PARAMS_NULL.getCode(), "缺少参数", null);
        }
        Map<String, Object> beanMap = castToMap(data);
        TableStoreSaveData saveData = buildSaveData(pks, beanMap);
        return saveOne(tableName, saveData.getPkMap(), saveData.getColMap());
    }

    /**
     * 保存数据
     *
     * @param tableName
     * @param pk
     * @param col
     * @return
     */
    public Result<Integer> saveOne(String tableName, LinkedHashMap<String, Object> pk, Map<String, Object> col) {

        if (tableName == null || pk == null || col == null) {
            return Result.newInstance(BizCodeEnum.PARAMS_NULL.getCode(), "缺少参数", null);
        }
        RowPutChange rowPutChange = buildRowPutChange(tableName, pk, col);
        try {
            syncClient.putRow(new PutRowRequest(rowPutChange));
        } catch (ClientException | TableStoreException ex) {
            log.error("TableStoreTemplate saveOne client error: ", ex);
            return Result.newInstance(BizCodeEnum.REMOTE_ERROR.getCode(), "table store client error" + ex.getMessage(), null);
        } catch (Exception ex) {
            log.error("TableStoreTemplate saveOne error: ", ex);
            return Result.newInstance(BizCodeEnum.REMOTE_ERROR.getCode(), "table store error" + ex.getMessage(), null);
        }
        return Result.newInstance(1);
    }

    /**
     * 批量保存数据
     *
     * @param tableName
     * @param pks
     * @param data
     * @param <T>
     * @return
     */
    public <T> Result<Integer> saveBatchBean(final String tableName, final List<String> pks, List<T> data) {
        List<Map<String, Object>> maps = castToMapList(data);
        return saveBatch(tableName, maps.stream().map(map -> buildSaveData(pks, map))
                .collect(Collectors.toList()));
    }

    /**
     * 批量保存数据
     *
     * @param tableName
     * @param data
     * @return
     */
    public Result<Integer> saveBatch(String tableName, List<TableStoreSaveData> data) {

        if (tableName == null || data == null || data.isEmpty()) {
            return Result.newInstance(BizCodeEnum.PARAMS_NULL.getCode(), "缺少参数", null);
        }
        BatchWriteRowRequest batchWriteRowRequest = new BatchWriteRowRequest();
        for (TableStoreSaveData datum : data) {
            RowPutChange rowPutChange = buildRowPutChange(tableName, datum.getPkMap(), datum.getColMap());
            batchWriteRowRequest.addRowChange(rowPutChange);
        }
        try {
            BatchWriteRowResponse response = syncClient.batchWriteRow(batchWriteRowRequest);
            int count = response.getSucceedRows().size();
            if (!response.isAllSucceed()) {
                for (BatchWriteRowResponse.RowResult rowResult : response.getFailedRows()) {
                    log.error("TableStoreTemplate saveBatch failed row：{}, error:{}",
                            rowResult.getRow().getPrimaryKey(), rowResult.getError());
                }
                BatchWriteRowRequest retryRequest = batchWriteRowRequest.createRequestForRetry(response.getFailedRows());
                BatchWriteRowResponse retryResponse = syncClient.batchWriteRow(retryRequest);
                log.info("TableStoreTemplate saveBatch retry batchSaveData Completed:{} tableName:{}", retryResponse.isAllSucceed(), tableName);
                count += retryResponse.getSucceedRows().size();
            }
            return Result.newInstance(count);
        } catch (ClientException | TableStoreException ex) {
            log.error("TableStoreTemplate saveBatch client error: ", ex);
            return Result.newInstance(BizCodeEnum.REMOTE_ERROR.getCode(), "table store client error" + ex.getMessage(), null);
        } catch (Exception ex) {
            log.error("TableStoreTemplate saveBatch error: ", ex);
            return Result.newInstance(BizCodeEnum.REMOTE_ERROR.getCode(), "table store error" + ex.getMessage(), null);
        }
    }

    /**
     * 删除数据
     *
     * @param tableName
     * @param pkMap
     * @return
     */
    public Result<Integer> deleteOne(String tableName, LinkedHashMap<String, Object> pkMap) {
        if (tableName == null || pkMap == null || pkMap.isEmpty()) {
            return Result.newInstance(BizCodeEnum.PARAMS_NULL.getCode(), "缺少参数", null);
        }

        PrimaryKey primaryKey = buildPrimaryKey(pkMap);
        RowDeleteChange rowDeleteChange = new RowDeleteChange(tableName, primaryKey);
        try {
            syncClient.deleteRow(new DeleteRowRequest(rowDeleteChange));
            return Result.newInstance(1);
        } catch (ClientException | TableStoreException ex) {
            log.error("TableStoreTemplate deleteOne client error: ", ex);
            return Result.newInstance(BizCodeEnum.REMOTE_ERROR.getCode(), "table store client error" + ex.getMessage(), null);
        } catch (Exception ex) {
            log.error("TableStoreTemplate deleteOne error: ", ex);
            return Result.newInstance(BizCodeEnum.REMOTE_ERROR.getCode(), "table store error" + ex.getMessage(), null);
        }
    }

    /**
     * 批量删除数据
     *
     * @param tableName
     * @param pkMapList
     * @return
     */
    public Result<Integer> deleteBatch(String tableName, List<LinkedHashMap<String, Object>> pkMapList) {
        if (tableName == null || pkMapList == null || pkMapList.isEmpty()) {
            return Result.newInstance(BizCodeEnum.PARAMS_NULL.getCode(), "缺少参数", null);
        }

        List<PrimaryKey> primaryKeys = pkMapList.stream().map(pkMap -> buildPrimaryKey(pkMap))
                .collect(Collectors.toList());
        BatchWriteRowRequest batchWriteRowRequest = new BatchWriteRowRequest();
        for (PrimaryKey primaryKey : primaryKeys) {
            RowDeleteChange rowDeleteChange = new RowDeleteChange(tableName, primaryKey);
            batchWriteRowRequest.addRowChange(rowDeleteChange);
        }
        try {
            BatchWriteRowResponse response = syncClient.batchWriteRow(batchWriteRowRequest);
            return Result.newInstance(response.getSucceedRows().size());
        } catch (ClientException | TableStoreException ex) {
            log.error("TableStoreTemplate deleteBatch client error: ", ex);
            return Result.newInstance(BizCodeEnum.REMOTE_ERROR.getCode(), "table store client error" + ex.getMessage(), null);
        } catch (Exception ex) {
            log.error("TableStoreTemplate deleteBatch error: ", ex);
            return Result.newInstance(BizCodeEnum.REMOTE_ERROR.getCode(), "table store error" + ex.getMessage(), null);
        }
    }

    /**
     * 更新数据
     *
     * @param tableName
     * @param pkMap
     * @param colMap
     * @return
     */
    public Result<Integer> updateRow(String tableName, LinkedHashMap<String, Object> pkMap, Map<String, Object> colMap) {
        if (tableName == null || pkMap == null || colMap == null) {
            return Result.newInstance(BizCodeEnum.PARAMS_NULL.getCode(), "缺少参数", null);
        }
        PrimaryKey primaryKey = buildPrimaryKey(pkMap);
        RowUpdateChange rowUpdateChange = new RowUpdateChange(tableName, primaryKey);
        for (Map.Entry<String, Object> columnValue : colMap.entrySet()) {
            rowUpdateChange.put(buildColumn(columnValue));
        }

        try {
            UpdateRowResponse updateRowResponse = syncClient.updateRow(new UpdateRowRequest(rowUpdateChange));
            return Result.newInstance(1);
        } catch (ClientException | TableStoreException ex) {
            log.error("TableStoreTemplate updateRow client error: ", ex);
            return Result.newInstance(BizCodeEnum.REMOTE_ERROR.getCode(), "table store client error" + ex.getMessage(), null);
        } catch (Exception ex) {
            log.error("TableStoreTemplate updateRow error: ", ex);
            return Result.newInstance(BizCodeEnum.REMOTE_ERROR.getCode(), "table store error" + ex.getMessage(), null);
        }
    }

    public <T> Result<Integer> updateRow(String tableName, final List<String> pks, List<T> data) {
        if (tableName == null || pks == null || data == null) {
            return Result.newInstance(BizCodeEnum.PARAMS_NULL.getCode(), "缺少参数", null);
        }
        Map<String, Object> map = castToMap(data);
        TableStoreSaveData tableStoreSaveData = buildSaveData(pks, map);
        return updateRow(tableName, tableStoreSaveData.getPkMap(), tableStoreSaveData.getColMap());
    }

    private TableStoreSaveData buildSaveData(final List<String> pks, Map<String, Object> beanMap) {
        LinkedHashMap<String, Object> pkMap = new LinkedHashMap<>();
        for (String pk : pks) {
            pkMap.put(pk, beanMap.remove(pk));
        }
        return new TableStoreSaveData(pkMap, beanMap);
    }

    private RowPutChange buildRowPutChange(String tableName,
                                           LinkedHashMap<String, Object> pk,
                                           Map<String, Object> col) {
        //构造主键。
        PrimaryKey primaryKey = buildPrimaryKey(pk);
        //加入属性列。
        RowPutChange rowPutChange = new RowPutChange(tableName, primaryKey);
        //加入一些属性列。
        for (Map.Entry<String, Object> columnValue : col.entrySet()) {
            rowPutChange.addColumn(buildColumn(columnValue));
        }
        return rowPutChange;
    }


    private Column buildColumn(Map.Entry<String, Object> columnValue) {
        Column column = null;
        if (columnValue.getValue() instanceof Long || columnValue.getValue() instanceof Integer) {
            column = new Column(columnValue.getKey(), ColumnValue.fromLong(
                    Long.valueOf(String.valueOf(columnValue.getValue())).longValue()));
        } else if (columnValue.getValue() instanceof Boolean) {
            column = new Column(columnValue.getKey(), ColumnValue.fromBoolean(
                    Boolean.valueOf(String.valueOf(columnValue.getValue()))));
        } else if (columnValue.getValue() instanceof Double) {
            column = new Column(columnValue.getKey(), ColumnValue.fromDouble(
                    Double.valueOf(String.valueOf(columnValue.getValue()))));
        } else if (columnValue.getValue() instanceof String) {
            column = new Column(columnValue.getKey(), ColumnValue.fromString(
                    String.valueOf(columnValue.getValue())));
        } else if (columnValue.getValue() instanceof byte[]) {
            column = new Column(columnValue.getKey(), ColumnValue.fromBinary((byte[]) columnValue.getValue()));
        } else {
            column = new Column(columnValue.getKey(), ColumnValue.fromString(Objects.toString(columnValue.getValue())));
        }
        return column;
    }

    /**
     * 构建主键
     *
     * @param pkValueMap
     * @return
     */
    private PrimaryKey buildPrimaryKey(Map<String, Object> pkValueMap) {

        if (pkValueMap == null || pkValueMap.isEmpty()) {
            throw new IllegalArgumentException("invalid primary key");
        }
        PrimaryKeyBuilder primaryKeyBuilder = PrimaryKeyBuilder.createPrimaryKeyBuilder();
        for (Map.Entry<String, Object> entry : pkValueMap.entrySet()) {
            PrimaryKeyValue primaryKeyValue;
            if (entry.getValue() instanceof Long || entry.getValue() instanceof Integer) {
                primaryKeyValue = PrimaryKeyValue.fromLong(Long.valueOf(String.valueOf(entry.getValue())).longValue());
            } else {
                primaryKeyValue = PrimaryKeyValue.fromString(String.valueOf(entry.getValue()));
            }
            primaryKeyBuilder.addPrimaryKeyColumn(entry.getKey(), primaryKeyValue);
        }
        return primaryKeyBuilder.build();
    }

    private PrimaryKey buildRangePrimaryKey(boolean isStart, Map<String, Object> pkValueMap) {
        if (pkValueMap == null || pkValueMap.isEmpty()) {
            throw new IllegalArgumentException("invalid primary key");
        }
        PrimaryKeyBuilder primaryKeyBuilder = PrimaryKeyBuilder.createPrimaryKeyBuilder();
        for (Map.Entry<String, Object> entry : pkValueMap.entrySet()) {

            // 没有设置主键值
            if (entry.getValue() == null) {
                primaryKeyBuilder.addPrimaryKeyColumn(entry.getKey(), isStart ? PrimaryKeyValue.INF_MIN : PrimaryKeyValue.INF_MAX);
            } else if (entry.getValue() instanceof Long || entry.getValue() instanceof Integer) {
                PrimaryKeyValue primaryKeyValue = PrimaryKeyValue.fromLong(Long.valueOf(String.valueOf(entry.getValue())).longValue());
                primaryKeyBuilder.addPrimaryKeyColumn(entry.getKey(), primaryKeyValue);
            } else {
                PrimaryKeyValue primaryKeyValue = PrimaryKeyValue.fromString(String.valueOf(entry.getValue()));
                primaryKeyBuilder.addPrimaryKeyColumn(entry.getKey(), primaryKeyValue);
            }
        }
        return primaryKeyBuilder.build();
    }

    private Map<String, Object> convertRow2Map(Row row) {
        if (row == null || row.isEmpty()) {
            return Collections.emptyMap();
        }
        Map<String, Object> resultMap = new LinkedHashMap<>(16);

        // primary key
        PrimaryKeyColumn[] primaryKeyColumns = row.getPrimaryKey().getPrimaryKeyColumns();
        for (PrimaryKeyColumn primaryKeyColumn : primaryKeyColumns) {

            String name = primaryKeyColumn.getName();
            PrimaryKeyValue primaryKeyValue = primaryKeyColumn.getValue();
            Object val = null;
            switch (primaryKeyValue.getType()) {
                case INTEGER:
                    val = primaryKeyValue.asLong();
                    break;
                case BINARY:
                    val = primaryKeyValue.asBinary();
                    break;
                case STRING:
                default:
                    // 按String 处理
                    val = primaryKeyValue.asString();
                    break;
            }
            resultMap.put(name, val);
        }
        // columns
        Column[] columns = row.getColumns();
        for (Column column : columns) {
            String name = column.getName();
            // 列的类型比较多，直接放进去
            ColumnValue columnValue = column.getValue();
            resultMap.put(name, columnValue.getValue());
        }
        return resultMap;
    }

}

工具类 BeanUti

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.util.TypeUtils;
import org.apache.commons.collections4.CollectionUtils;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
public class BeanUtil {

    public static <T> T castToBean(Map<String, Object> source, Class<T> target) {
        return TypeUtils.castToJavaBean(source, target);
    }

    public static <T> List<T> castToBeanList(List<Map<String, Object>> source, Class<T> target) {
        if (CollectionUtils.isEmpty(source)) {
            return Collections.emptyList();
        }
        List<T> list = new ArrayList<>();
        for (Map<String, Object> map : source) {
            list.add(TypeUtils.castToJavaBean(map, target));
        }
        return list;
    }

    public static <T> Map<String, Object> castToMap(T source) {
        if (source == null) {
            return null;
        }
        Map<String, Object> target = (JSONObject) JSON.toJSON(source);
        return target;
    }

    public static <T> List<Map<String, Object>> castToMapList(List<T> source) {
        if (source == null) {
            return null;
        }
        List<Map<String, Object>> resultMapList = new ArrayList<>(source.size());
        source.forEach(item -> {
            resultMapList.add(castToMap(item));
        });
        return resultMapList;
    }
}

测试代码

public Result<Object> tsdb() {

    Map<String, Object> result = new HashMap<>();
    LinkedHashMap map1 = new LinkedHashMap();
    map1.put("group_id", "group001");
    map1.put("version_id", "100");
    map1.put("user_id", "59WUa");
    Result<Map<String, Object>> groupTest = tableStoreTemplate.getOne("group_test", map1);
    result.put("getOne1", groupTest.getData());

    Result<GroupTestEntity> groupTestBean = tableStoreTemplate.getOne("group_test", map1, GroupTestEntity.class);
    result.put("getOne2", groupTestBean.getData());

    LinkedHashMap map2 = new LinkedHashMap();
    map2.put("group_id", "group001");
    map2.put("version_id", "100");
    map2.put("user_id", "6oxcl");
    Result<List<GroupTestEntity>> getBatch = tableStoreTemplate.getBatch(
            "group_test", Lists.newArrayList(map1, map2), GroupTestEntity.class);
    result.put("getBatch", getBatch.getData());

    map2.put("user_id", null);
    Result<List<GroupTestEntity>> getRange = tableStoreTemplate.getRange("group_test", map1, map2, GroupTestEntity.class);
    result.put("getRange", getRange.getData().size());

    LinkedHashMap map3 = new LinkedHashMap();
    map3.put("group_id", "group001");
    map3.put("version_id", "100");
    map3.put("user_id", "0keqw");
    Result<Integer> result1 = tableStoreTemplate.deleteOne("group_test", map3);
    result.put("deleteOne", result1.getData());

    LinkedHashMap map4 = new LinkedHashMap();
    map4.put("group_id", "group001");
    map4.put("version_id", "100");
    map4.put("user_id", "Z6oge");
    map3.put("user_id", "1PMEd");
    Result<Integer> result2 = tableStoreTemplate.deleteBatch("group_test",Lists.newArrayList(map3, map4));
    result.put("deleteBatch", result2.getData());

    return Result.newInstance(result);
}