跳到主要内容
版本:v4.17

清洗脚本配置样例

为了方便用户使用清洗脚本,我们提供了丰富的清洗脚本使用样例。

一、DML 字段标识脚本​

脚本描述:源表数据发生变化时,在目的地表中增加相应的 DML 标识字段,包括 insert、update、delete。

import com.datapipeline.clients.connector.record.DpRecordMeta;
import java.util.Map;
public class AddDMLField {
public static Map process(Map record, DpRecordMeta meta) {
// 系统会向 dml 字段写入标识:insert、update、delete。
// 如果是定时读取模式,所有 dml 字段会表示为 insert,只有通过实时模式读取数据时才会识别 update 和 delete。
record.put("dml", meta.getType());
// 保存该脚本后,请在目的地表结构添加新字段:dml,并把字段类型改为字符串类型(例如:varchar)
return record;
}
}

二、读取时间脚本​

脚本描述:根据数据读取时间,在目的地表中增加相应的时间字段。

import com.datapipeline.clients.connector.record.DpRecordMeta;
import java.util.Map;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.Instant;
import java.time.format.DateTimeFormatter;
public class AddCollectTimeField {
private static DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
public Map process(Map record, DpRecordMeta meta) {
// 系统会向 collect_time 字段写入读取该数据的时间,格式为:yyyy-MM-dd HH:mm:ss。
record.put("collect_time", Instant.ofEpochMilli(meta.getSourceRecordTimestamp()).atZone(ZoneId.of("UTC")).format(DATE_TIME_FORMATTER));
// 保存脚本后,在目的地表结构中添加字段:collect_time,并把字段类型改为时间类型(或字符串类型)。
return record;
}
}

三、写入时间脚本​

脚本描述:根据数据写入时间,在目的地表中增加相应的时间字段。

import java.util.Map;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
public class AddUpdateTimeField {
private static DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
public Map process(Map record) {
// 系统会向 update_time 字段写入写入目的地的时间,格式为:yyyy-MM-dd HH:mm:ss。
record.put("update_time", LocalDateTime.now(ZoneId.of("Asia/Shanghai")).format(DATE_TIME_FORMATTER));
// 保存脚本后,在目的地表结构中添加字段:update_time,并把字段类型改为时间类型(或字符串类型)。
return record;
}
}

四、日期类型转换脚本​

脚本描述:将 Timestamp 类型数据转换为日期类型

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Map;
public class TimestampProcess {
private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");
private static final DateTimeFormatter TIMESTAMP_FORMATTER =
DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
public Map process(Map record) {
// timestamp_type 类型为字符串,格式为:2019-07-24 17:06:54.000
final String timestampStr = (String) record.get("timestamp_type");
if (timestampStr != null) {
try {
// 将字符串转换为日期对象
final LocalDateTime localDateTime = LocalDateTime.parse(timestampStr, TIMESTAMP_FORMATTER);
// 将时间对象转换为 DATE_FORMATTER 格式的字符串,转化之后的字符串为:2019-07-24
record.put("formatedTime", DATE_FORMATTER.format(localDateTime));
} catch (Exception e) {
e.printStackTrace();
}
}
return record;
}
}

五、Timestamp 转换脚本​

脚本描述:将日期类型转换为 Timestamp 类型数据。

import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
public class Date2TimeStampSample {
public Map<String, Object> process(Map<String, Object> record) throws Exception{
// date = "20180101 12:0:22.123"
String date = record.get("date");
long timeStamp = ZonedDateTime.parse(date, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS").withZone(ZoneId.of("Asia/Shanghai"))).toInstant().toEpochMilli();
record.put("ts", timeStamp);
return record;
}
}

六、JSON 解析脚本​

脚本描述:将 JSON 数据解析,并指定到目标表表结构。

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
public class Test_api_url_nameTransformEngine {
public List<Map<String, Object>> process(Map<String, Object> record) {
List<Map<String, Object>> records = new ArrayList<>();
if (!Objects.isNull(record)) {
String jsonStr = (String) record.get("content");
JSONObject jsonNode = JSON.parseObject(jsonStr);
JSONArray items = jsonNode.getJSONObject("reponseData").getJSONArray("data");
for (Object iterm : items) {
JSONObject eachIterm = (JSONObject) iterm;
String title = String.valueOf(eachIterm.get("title"));
if (title != null && title.length() > 100) {
title = title.substring(0, 100);
}
Map<String, Object> eachRowData = new HashMap<>();
eachRowData.put("_id", String.valueOf(eachIterm.get("id")));
eachRowData.put("tab", String.valueOf(eachIterm.get("tab")));
eachRowData.put("title", title);
records.add(eachRowData);
}
}
return records;
}
}

七、数据脱敏​

场景描述:用户想对表格中的信息进行脱敏,比如手机号或者身份证号。

例:身份证号脱敏,保留前四位和后四位,手机号码脱敏,保留前三位和后四位。

具体代码如下:

import java.util.Map;
public class Sid_2382_05b0f75d2382f96a23824d7023829c612382ef7ac208785d {
public Map process(Map record) {
record.put("id",((String)record.get("id")).replaceAll("(\\d{4})\\d{10}(\\d{4})","$1**********$2"));
record.put("phone",((String)record.get("phone")).replaceAll("(\\d{3})\\d{4}(\\d{4})","$1****$2"));
return record;
}
}

八、枚举类型转换​

场景描述:用户想对表格中的类型进行转换。

例:把原表中表示性别的‘0’和‘1‘,到目的地表中,转换为对应的‘男’和‘女’。

具体代码如下:

import java.util.Map;
public class Sid_2383_a8984a582383944223834f332383b7e52383aa115c629f93 {
public Map process(Map record) {
if (record.get("sex").equals("0"))
{record.put("sex","男");}
else if(record.get("sex").equals("1"))
{record.put("sex","女");}
else
{record.put("sex","");}
return record;
}
}

九、字段求和​

场景描述:用户想对表格中的几个字段的内的数据进行求和。

例:把原表中的两个字段内的薪水,到目的地表中,生成一个新的字段,其值为前两个字段的和。

具体代码如下:

import java.util.Map;
public class Sid_2384_f049d91a2384daea23844a3a23848fd923847cc3bc23dc6e {
public Map<String, Object>process(Map<String, Object>record) {
record.put("sum",(Double) record.get("salary1")+(Double) record.get("salary2"));
return record;
}
}

十、时间类型格式统一​

场景描述:用户想对表格中字段的日期格式统一。(2019115、20190115、2019.01.15)转换成 YYYY-MM-DD(2019-01-15)。

具体代码如下:

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
public class ConventDateSample {
public Map<String, Object> process(Map<String, Object> record) throws Exception{
try{
SimpleDateFormat df = new SimpleDateFormat("yyyyMMdd");
SimpleDateFormat df2 = new SimpleDateFormat("yyyy-MM-dd");
Date datetime=df1.parse(record.get("datetime").toString());
String newDatetime = df2.format(datetime);
record.put("datetime",newDatetime);
}catch(Exception e){
}
return record;
}
}

十一、库存日期结合​

场景描述:用户想对表格中日期和时间,结合到一个字段内。

具体代码如下:

import java.util.Map;
import java.util.Date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
public class Sid_2516_8ffcc7ca2516201f25164ee7251690f3251641b41d3bbd5c {
public Map<String, Object>process(Map<String, Object>record) {
record.put("datetime2", record.get("date")+" "+ record.get("time"));
return record;
}
}

十二、日期间隔计算​

场景描述:用户想对表格中两个日期之间相差的天数,进行计算,再写入到一个字段内。

具体代码如下:

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
public class Sid_2519_5017952225194a2425194ff5251980f3251985af080e3b28 {
public Map<String, Object>process(Map<String, Object> record) throws Exception{
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
SimpleDateFormat df2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date start=df2.parse(record.get("startTime").toString());
Date end=df2.parse(record.get("endTine").toString());
try{
int days= (int) ((df.parse(df.format(end)).getTime() -df.parse(df.format(start)).getTime()) / (24 * 60 * 60 * 1000));
record.put("days",days);
}catch(Exception e){
}
return record;
}
}

十三、非空字段判断​

场景描述:判断一个字段是否为空。

import java.util.Map;
import java.util.Objects;
import com.datapipeline.clients.utils.CodeEngineUtils;
public class Example13 {
public Map process(Map record)
final Object orderno = record.get("orderno");
boolean ordernoIsNull = CodeEngineUtils.isNull(orderno);
}

十四、指定数据进错误队列​

场景描述:指定某一些数据进入错误队列。

import java.util.Map;
import java.util.Objects;
import java.lang.String;
import java.lang.Throwable;
import com.datapipeline.clients.codeengine.CustomizedCodeEngineException;
public class Example14 {
public Map process(Map record) throws CustomizedCodeEngineException {
if(Integer.parseInt(record.get("age").toString()) <= 20){
throw new CustomizedCodeEngineException(new Exception("Illegal data!"));
}
return record;
}
}

十五、时区转换​

场景描述:将上海时间转化为标准时间。

import java.util.Map;
import java.time.*;
import java.time.format.DateTimeFormatter;
public class localTime2standardTime {
public Map<String, Object> process(Map<String, Object> record) {
String crt = (String)record.get("create_time");
try {
long ncrt = ZonedDateTime.parse(crt,DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS").withZone(ZoneId.of("Asia/Shanghai"))).toInstant().toEpochMilli();
record.put("timestamp",ncrt);
}
catch (Exception e) {
e.printStackTrace();
}
return record;
}
}

十六、字符集编码转换​

场景描述:当数据源的数据为乱码时,可通过高级清洗转换字符集编码,处理乱码数据。

package com.dp.exltcsv;
import java.io.UnsupportedEncodingException;
import java.util.Map;
public class utf2gbk {
public Map<String, Object> process(Map<String, Object> record) throws UnsupportedEncodingException {
// 针对单个字段的格式
// String key = (String)record.get("key");
// record.put(key,(Object)new String(key.getBytes("utf-8"),"gbk"));
// return record;
// 针对所有字段
for (String key : record.keySet()) {
String value = (String)record.get(key);
record.put(key,(Object)new String( value.getBytes("utf-8"), "gbk"));
}
return record;
}
}

十七、Kafka 目的地 Avro 格式定义​

场景描述:当数据目的地节点为 Kafka,且 Topic 序列化器为 Avro 时,可以通过高级清洗代码定义 Avro 数据结构,并将 Schema 信息写入 Schema Registry。

import java.util.Map;
import com.datapipeline.clients.codeengine.CustomizedCodeEngineException;
import com.datapipeline.clients.connector.schema.base.SinkColumn;
import com.datapipeline.clients.connector.record.DpRecordMeta;
import com.datapipeline.clients.connector.schema.base.SinkSchema;
import com.datapipeline.internal.bean.node.column.DataType;
import com.datapipeline.internal.bean.node.column.kafka.KafkaType;
import com.datapipeline.clients.connector.schema.base.DpRecordKey;
import java.nio.ByteBuffer;
import java.util.List;
import java.util.Objects;
import org.apache.kafka.connect.data.Schema;
import org.apache.kafka.connect.data.Schema.Type;
import org.apache.kafka.connect.data.SchemaBuilder;
import org.apache.kafka.connect.data.Struct;
import org.codehaus.jettison.json.JSONObject;

/**
* 详情请见产品手册:
*
* @see https://www.kancloud.cn/datapipeline-group/v3_7_0/1475482
*/
public class AvroCodeEngine {

private List<String> valueSyncColumnNames;
private List<String> keySyncColumnNames;

private Schema valueSchema;
private Schema keySchema;

public AvroCodeEngine() {}

public Struct getKeyStruct(DpRecordKey dpRecordKey,
SinkSchema sinkSchema,
JSONObject dataJson){
List<String> pkNames = dpRecordKey.getPrimaryKeyNames();


if (!Objects.equals(keySyncColumnNames, sinkSchema.getSyncColumnNames())) {
keySyncColumnNames = sinkSchema.getSyncColumnNames();

SchemaBuilder keySchemaBuilder = SchemaBuilder.struct().name("key");
for (SinkColumn sinkColumn : sinkSchema.getSyncColumns()) {
if (pkNames.contains(sinkColumn.getName())) {
keySchemaBuilder.field(
sinkColumn.getName(),
convertDefinitionToSchema(sinkColumn.getDefinition().getType()));
}
}

keySchema = keySchemaBuilder.build();
}
Struct struct = new Struct(keySchema);

for (SinkColumn sinkColumn : sinkSchema.getSyncColumns()) {
String columnName = sinkColumn.getName();
if (pkNames.contains(columnName)) {

struct.put(
columnName,
convertValue(keySchema.field(columnName).schema(), dataJson.opt(columnName)));
}
}
return struct;

}

public Map<String, Object> process(Map<String, Object> record, DpRecordMeta meta) {
// 系统会向 dml 字段写入标识:insert、update、delete。
// 如果是定时读取模式,存量 dml 字段会标识为 insert,增量 dml 字段会标识为 update,
// 如果是实时读取模式,存量 dml 字段会标识为 insert,增量 dml 字段会标识为 update 和 delete。
Map<String,String> customParams = meta.getCustomParams();
if(customParams!=null){
record.put("enttyp",customParams.get("ENTTYP"));
}
record.put("op", meta.getType());

// 保存该脚本后,请在目的地表结构添加新字段:dml,并把字段类型改为字符串类型(例如:varchar)
return record;
}



public Struct getValueStruct(SinkSchema sinkSchema, JSONObject dataJson)
throws CustomizedCodeEngineException {
if (!Objects.equals(valueSyncColumnNames, sinkSchema.getSyncColumnNames())) {
valueSyncColumnNames = sinkSchema.getSyncColumnNames();

SchemaBuilder messageSchema = SchemaBuilder.struct().name("message");
for (SinkColumn sinkColumn : sinkSchema.getSyncColumns()) {
messageSchema.field(
sinkColumn.getName(), convertDefinitionToSchema(sinkColumn.getDefinition().getType()));
}

valueSchema =
SchemaBuilder.struct()
.name("DBMessage")
.field("op", Schema.OPTIONAL_STRING_SCHEMA)
.field("enttyp",Schema.OPTIONAL_STRING_SCHEMA)
.field("message", messageSchema.build())
.build();
}
Struct struct = new Struct(valueSchema);
Schema messageSchema = valueSchema.field("message").schema();
Struct messageStruct = new Struct(messageSchema);

for (SinkColumn sinkColumn : sinkSchema.getSyncColumns()) {
String columnName = sinkColumn.getName();
messageStruct.put(
columnName,
convertValue(messageSchema.field(columnName).schema(), dataJson.opt(columnName)));
}

struct.put("op", dataJson.optString("op"));
struct.put("enttyp",dataJson.optString("enttyp"));
struct.put("message", messageStruct);
return struct;
}

private Schema convertDefinitionToSchema(DataType dataType) {
KafkaType kafkaType = (KafkaType) dataType;
if (kafkaType == KafkaType.INT8) {
return SchemaBuilder.OPTIONAL_INT8_SCHEMA;
}
if (kafkaType == KafkaType.INT16) {
return SchemaBuilder.OPTIONAL_INT16_SCHEMA;
}
if (kafkaType == KafkaType.INT32) {
return SchemaBuilder.OPTIONAL_INT32_SCHEMA;
}
if (kafkaType == KafkaType.INT64) {
return SchemaBuilder.OPTIONAL_INT64_SCHEMA;
}
if (kafkaType == KafkaType.FLOAT32) {
return SchemaBuilder.OPTIONAL_FLOAT32_SCHEMA;
}
if (kafkaType == KafkaType.FLOAT64) {
return SchemaBuilder.OPTIONAL_FLOAT64_SCHEMA;
}
if (kafkaType == KafkaType.BOOLEAN) {
return SchemaBuilder.OPTIONAL_BOOLEAN_SCHEMA;
}
if (kafkaType == KafkaType.STRING) {
return SchemaBuilder.OPTIONAL_STRING_SCHEMA;
}
if (kafkaType == KafkaType.BYTES) {
return SchemaBuilder.OPTIONAL_BYTES_SCHEMA;
}
throw new IllegalArgumentException(
String.format("data type %s not support", dataType.toString()));

}

private Object convertValue(Schema schema, Object data) {
if (data == JSONObject.NULL || data == null) {
return null;
}
Schema.Type type = schema.type();
if (type == Type.INT8) {
if (data instanceof Byte) {
return data;
}
// convert data to Byte
}
if (type == Type.INT16) {
if (data instanceof Short) {
return data;
} else {
return Short.valueOf(data.toString());
}
}
if (type == Type.INT32) {
if (data instanceof Integer) {
return data;
} else {
return Integer.valueOf(data.toString());
}
}
if (type == Type.INT64) {
if (data instanceof Long) {
return data;
} else {
return Long.valueOf(data.toString());
}
}
if (type == Type.FLOAT32) {
if (data instanceof Float) {
return data;
} else {
return Float.valueOf(data.toString());
}
}
if (type == Type.FLOAT64) {
if (data instanceof Double) {
return data;
} else {
return Double.valueOf(data.toString());
}
}
if (type == Type.BOOLEAN) {
if (data instanceof Boolean) {
return data;
} else {
return Boolean.valueOf(data.toString());
}
}
if (type == Type.STRING) {
return data.toString();
}
if (type == Type.BYTES) {
if (data instanceof ByteBuffer || data instanceof byte[]) {
return data;
} else {
return data.toString().getBytes();
}
}
// convert data to ByteBuffer or byte[]
if (type == Type.STRUCT || type == Type.MAP || type == Type.ARRAY) {
// Customized handling.
return data;
}
throw new IllegalArgumentException(
String.format("data type %s not support", schema.type().toString()));
}
}

十八、时间类型转换 DateFormatConverter.java​

场景描述:将源端写入目的地指定字段(字符串类型)的值转换成固定格式的时间格式(字符串类型)写入目的地

import java.util.Map;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* 系统将源端写入目的地指定字段(字符串类型)的时间值转换成固定格式的时间字符串写入目的地,具体格式可以自行定义
*/

public class DateFormatConverter {

public Map<String, Object> process(Map<String, Object> record) {
String COLUMN = "COLU15";
try {

//从源端的"COLU15"字段中获取日期字符串
String oldDateString = record.get(COLUMN).toString();
//根据源端时间的日期格式将字符串进行解析
SimpleDateFormat oldDateFormatter = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
Date date = oldDateFormatter.parse(oldDateString);

/*设定新的时间解析格式,可选的有yyyyMMddhhmmss、yyyy/MM/dd/hh/mm/ss、yyyy-MM-dd-hh-mm-ss、yyyy-MM-dd hh:mm:ss、yyyy/MM/dd hh:mm:ss、yyyyMMdd hh:mm:ss
*其中年、月、日、时、分、秒不可为空,否则将被赋予默认值
*/
SimpleDateFormat newDateFormatter = new SimpleDateFormat("yyyy年MM月dd日 hh时mm分ss秒");
String newDateString = newDateFormatter.format(date);

record.put(COLUMN, newDateString);

} catch (Exception e) {
e.printStackTrace();
}
return record;
}
}java

十九、字符串拼接 StringConnector.java​

场景描述:将源表指定的多个字段按规则拼接写到目的地表的某个指定字段,或者将源表指定的某个字段按规则添加前后缀(字符常量)写到目的地表的某个指定字段

import java.util.Map;
import java.lang.StringBuilder;
import java.util.List;
import java.util.Arrays;
/**
* 1.将源表指定的多个字段按规则拼接写到目的地表的某个指定字段
* 2.将源表指定的某个字段按规则添加前后缀(字符常量)写到目的地表的某个指定字段
*/
public class StringConnector {

Map<String, Object> record = null;

/**
* 在process()函数中,可以使用不同的函数及其组合来进行字符串的拼接(connectStrings)、添加前缀(addPrefix),添加后缀(addSuffix)操作。
* 以上函数及其使用示例均已给出
*/
public Map<String, Object> process(Map<String, Object> record) {
//初始化,不可删除
this.record = record;

//调用connectStrings()函数举例
record.put("COLU6", connectStrings());

//调用addPrefix()函数举例
record.put("COLU5", addPrefix("COLU5", "qiaoao"));

//调用addSuffix()函数举例
record.put("COLU14", addSuffix("COLU14", "qiaoao"));

return record;
}

/*字段拼接函数,仅适用于字符串类型字段
*修改columnNames之后即可正常使用
*/
protected String connectStrings () {
//按顺序保存需要拼接的字段名称,可以新增或者修改
List<String> columnNames = Arrays.asList("COLU1", "COLU14", "COLU5");
StringBuilder sb = new StringBuilder();

for (String columnName : columnNames) {
String value = record.get(columnName).toString();
sb.append(value);
}

return sb.toString();
}

//添加前缀函数,适用于字符串类型字段
protected String addPrefix (String columnName, String prefix) {
String oldString = record.get(columnName).toString();
String newString = prefix + oldString;
return newString;
}

//添加后缀函数,适用于字符串类型字段
protected String addSuffix (String columnName, String suffix) {
String oldString = record.get(columnName).toString();
String newString = oldString + suffix;
return newString;
}

}

二十、自定义时间加减 DateCalculator.java​

场景描述:将系统提供的写入时间或读取时间进行加减处理后写到目的地的某一列

import java.util.Map;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;

/**
* 系统将 数据写入时间 写到目的地的对应列,支持对该时间进行加减功能,加减单位:天、时、分
*/

public class DateCalculator {
private static DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

public Map<String, Object> process(Map<String, Object> record) {
//系统会向 sys_time字段写入写入目的地的时间,格式为:yyyy-MM-dd HH:mm:ss。
//其中sys_time字段需自行在目的地添加,名称可以更改
LocalDateTime dateTime = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));

/*日期时间增减修改举例,还可以使用以下几种函数
*增加n年:plusYears(n); 减少n年:minusYears(n);
*增加n月:plusMonths(n); 减少n月:minusMonths(n);
*增加n周:plusWeeks(n); 减少n周:minusWeeks(n);
*增加n天:plusDays(n); 减少n天:minusDays(n);
*增加n小时:plusHours(n); 减少n小时:minusHours(n);
*增加n分钟:plusMinutes(n); 减少n分钟:minusMinutes(n);
*增加n秒:plusSeconds(n); 减少n秒:minusSeconds(n);
*/
dateTime = dateTime.plusSeconds(1);
dateTime = dateTime.plusDays(1);

record.put("sys_time", dateTime.format(DATE_TIME_FORMATTER));
// 保存脚本后,在目的地表结构中添加字段:sys_time,并把字段类型改为时间类型(或字符串类型)。
return record;
}

二十一、字符串替换 StringReplacer.java​

场景描述:通过正则表达式匹配到源表中的字符串,并将其替换成另一个固定值或者固定格式的值

import java.util.Map;
import java.util.List;
import java.util.Arrays;
/**
* 使用正则匹配替换目标字段中的字符串
*/
public class StringReplacer {

public Map<String, Object> process(Map<String, Object> record) {
//此处设置需要替换的列名
List<String> columns = Arrays.asList("COLU14", "COLU24");
//此处设置正则表达式
String REGEX = "[a-zA-Z]";
//此处设置替换内容
String replacement = "";

for (String column : columns) {
String oldString = record.get(column).toString();
String newString = oldString.replaceAll(REGEX, replacement);
record.put(column, newString);
}

return record;
}
}

二十二、添加前后缀(有条件判断)LimitedStringJoiner.java​

场景描述:对指定字段进行判断,如果符合某个值就对根据正则表达式匹配到的字符串做添加前后缀(字符常量)的操作

import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
* 系统对指定字段进行判断,如果符合某个值就对根据正则表达式匹配到的字符串做添加前后缀(字符常量)的操作
*/
public class LimitedStringJoiner {

public Map<String, Object> process(Map<String, Object> record) {
//在这里设置正则表达式
String REGEX = "[a-z]";
//在这里设置目标字段名称
String COLUMN = "COLU14";

Pattern pattern = Pattern.compile(REGEX);
String oldString = record.get(COLUMN).toString();
Matcher matcher = pattern.matcher(oldString);

while (matcher.find()) {
String temp = matcher.group();
//这里的替换函数可以使用addPrefix()添加前缀、addSuffix()添加后缀;且需要设置相应的前后缀内容
oldString = oldString.replaceAll(temp, addPrefix(temp, "prefix"));
}


record.put(COLUMN, oldString);
return record;
}

//添加前缀函数,适用于字符串类型字段
protected String addPrefix (String oldString, String prefix) {
String newString = prefix + oldString;
return newString;
}

//添加后缀函数,适用于字符串类型字段
protected String addSuffix (String oldString, String suffix) {
String newString = oldString + suffix;
return newString;
}
}

二十三、条件赋值 ConditionalAssignment.java​

场景描述:对指定字段进行判断,根据源表的条件判断对目的地某一列写入特定值

import java.util.Map;

/**
* 系统对指定字段进行判断,根据源表的条件判断对目的地某一列写入特定值
*/
public class ConditionalAssignment {

public Map<String, Object> process(Map<String, Object> record) {
//此处修改为目标字段名
String COLUMN = "COLU1";
String oldString = record.get(COLUMN).toString();
String newString = "";
switch (oldString) {
//在这里添加不同的case,以下为具体举例
case "10143":
newString = "11";
break;
case "29469":
newString = "22";
break;
default:
newString = "";
}
if (!newString.equals("")) {
record.put(COLUMN, newString);
}
return record;
}
}