datax自定义处理器Transformer

已于 2023-06-08 09:52:30 修改
阅读量620 收藏
点赞数
文章标签： transformer java 深度学习
于 2023-06-05 17:39:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44757149/article/details/131052741
版权

问题：

使用datax同步数据 对方Oracle库字符集编码为 ISO_8859_1/ASCII，设置连接串字符集传输也是乱码

解决办法：

自定义Transformer类

GbkIsConvertToAsciiTransformer.java
package com.alibaba.datax.core.transport.transformer;

import com.alibaba.datax.common.element.Column;
import com.alibaba.datax.common.element.Record;
import com.alibaba.datax.common.element.StringColumn;
import com.alibaba.datax.transformer.Transformer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.nio.charset.StandardCharsets;


public class GbkIsConvertToAsciiTransformer extends Transformer {
    private static final Logger LOG = LoggerFactory.getLogger(GbkIsConvertToAsciiTransformer.class);

    public GbkIsConvertToAsciiTransformer() {
        setTransformerName("dx_ConvertToAscii");
    }

    @Override
    public Record evaluate(Record record, Object... paras) {

        if (null != record) {
            for (int i = 0; i < record.getColumnNumber(); i++) {
                Column column = record.getColumn(i);
                if (column.getType() == Column.Type.STRING) {
                    String oriValue = column.asString();
                    record.setColumn(i, new StringColumn(convertGbkToAscii(oriValue)));
                }
            }
        }
        return record;
    }

    private String convertGbkToAscii(String gbkString) {
        String isoString = "";
        try {
            isoString = new String(gbkString.getBytes("GBK"), StandardCharsets.ISO_8859_1);
            LOG.info("\n 转换之前的值：{}, \n 转换之后的值{}", gbkString, isoString);
        } catch (Exception e){
            LOG.error(e.getMessage());
        }
        return  isoString;
    }
}

在TransformerRegistry中注册

package com.alibaba.datax.core.transport.transformer;

import com.alibaba.datax.common.exception.DataXException;
import com.alibaba.datax.common.util.Configuration;
import com.alibaba.datax.core.util.container.CoreConstant;
import com.alibaba.datax.core.util.container.JarLoader;
import com.alibaba.datax.transformer.ComplexTransformer;
import com.alibaba.datax.transformer.Transformer;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * no comments.
 * Created by liqiang on 16/3/3.
 */
public class TransformerRegistry {

    private static final Logger LOG = LoggerFactory.getLogger(TransformerRegistry.class);
    private static Map<String, TransformerInfo> registedTransformer = new HashMap<String, TransformerInfo>();

    static {
        /**
         * add native transformer
         * local storage and from server will be delay load.
         */

        registTransformer(new SubstrTransformer());
        registTransformer(new PadTransformer());
        registTransformer(new ReplaceTransformer());
        registTransformer(new FilterTransformer());
        registTransformer(new GroovyTransformer());
        registTransformer(new DigestTransformer());
        /** 注册我们自己自定义的Transformer*/
        registTransformer(new GbkIsConvertToAsciiTransformer());
    }

    public static void loadTransformerFromLocalStorage() {
        //add local_storage transformer
        loadTransformerFromLocalStorage(null);
    }


    public static void loadTransformerFromLocalStorage(List<String> transformers) {

        String[] paths = new File(CoreConstant.DATAX_STORAGE_TRANSFORMER_HOME).list();
        if (null == paths) {
            return;
        }

        for (final String each : paths) {
            try {
                if (transformers == null || transformers.contains(each)) {
                    loadTransformer(each);
                }
            } catch (Exception e) {
                LOG.error(String.format("skip transformer(%s) loadTransformer has Exception(%s)", each, e.getMessage()), e);
            }

        }
    }

    public static void loadTransformer(String each) {
        String transformerPath = CoreConstant.DATAX_STORAGE_TRANSFORMER_HOME + File.separator + each;
        Configuration transformerConfiguration;
        try {
            transformerConfiguration = loadTransFormerConfig(transformerPath);
        } catch (Exception e) {
            LOG.error(String.format("skip transformer(%s),load transformer.json error, path = %s, ", each, transformerPath), e);
            return;
        }

        String className = transformerConfiguration.getString("class");
        if (StringUtils.isEmpty(className)) {
            LOG.error(String.format("skip transformer(%s),class not config, path = %s, config = %s", each, transformerPath, transformerConfiguration.beautify()));
            return;
        }

        String funName = transformerConfiguration.getString("name");
        if (!each.equals(funName)) {
            LOG.warn(String.format("transformer(%s) name not match transformer.json config name[%s], will ignore json's name, path = %s, config = %s", each, funName, transformerPath, transformerConfiguration.beautify()));
        }
        JarLoader jarLoader = new JarLoader(new String[]{transformerPath});

        try {
            Class<?> transformerClass = jarLoader.loadClass(className);
            Object transformer = transformerClass.newInstance();
            if (ComplexTransformer.class.isAssignableFrom(transformer.getClass())) {
                ((ComplexTransformer) transformer).setTransformerName(each);
                registComplexTransformer((ComplexTransformer) transformer, jarLoader, false);
            } else if (Transformer.class.isAssignableFrom(transformer.getClass())) {
                ((Transformer) transformer).setTransformerName(each);
                registTransformer((Transformer) transformer, jarLoader, false);
            } else {
                LOG.error(String.format("load Transformer class(%s) error, path = %s", className, transformerPath));
            }
        } catch (Exception e) {
            //错误funciton跳过
            LOG.error(String.format("skip transformer(%s),load Transformer class error, path = %s ", each, transformerPath), e);
        }
    }

    private static Configuration loadTransFormerConfig(String transformerPath) {
        return Configuration.from(new File(transformerPath + File.separator + "transformer.json"));
    }

    public static TransformerInfo getTransformer(String transformerName) {

        TransformerInfo result = registedTransformer.get(transformerName);

        //if (result == null) {
        //todo 再尝试从disk读取
        //}

        return result;
    }

    public static synchronized void registTransformer(Transformer transformer) {
        registTransformer(transformer, null, true);
    }

    public static synchronized void registTransformer(Transformer transformer, ClassLoader classLoader, boolean isNative) {

        checkName(transformer.getTransformerName(), isNative);

        if (registedTransformer.containsKey(transformer.getTransformerName())) {
            throw DataXException.asDataXException(TransformerErrorCode.TRANSFORMER_DUPLICATE_ERROR, " name=" + transformer.getTransformerName());
        }

        registedTransformer.put(transformer.getTransformerName(), buildTransformerInfo(new ComplexTransformerProxy(transformer), isNative, classLoader));

    }

    public static synchronized void registComplexTransformer(ComplexTransformer complexTransformer, ClassLoader classLoader, boolean isNative) {

        checkName(complexTransformer.getTransformerName(), isNative);

        if (registedTransformer.containsKey(complexTransformer.getTransformerName())) {
            throw DataXException.asDataXException(TransformerErrorCode.TRANSFORMER_DUPLICATE_ERROR, " name=" + complexTransformer.getTransformerName());
        }

        registedTransformer.put(complexTransformer.getTransformerName(), buildTransformerInfo(complexTransformer, isNative, classLoader));
    }

    private static void checkName(String functionName, boolean isNative) {
        boolean checkResult = true;
        if (isNative) {
            if (!functionName.startsWith("dx_")) {
                checkResult = false;
            }
        } else {
            if (functionName.startsWith("dx_")) {
                checkResult = false;
            }
        }

        if (!checkResult) {
            throw DataXException.asDataXException(TransformerErrorCode.TRANSFORMER_NAME_ERROR, " name=" + functionName + ": isNative=" + isNative);
        }

    }

    private static TransformerInfo buildTransformerInfo(ComplexTransformer complexTransformer, boolean isNative, ClassLoader classLoader) {
        TransformerInfo transformerInfo = new TransformerInfo();
        transformerInfo.setClassLoader(classLoader);
        transformerInfo.setIsNative(isNative);
        transformerInfo.setTransformer(complexTransformer);
        return transformerInfo;
    }

    public static List<String> getAllSuportTransformer() {
        return new ArrayList<String>(registedTransformer.keySet());
    }
}

job.json
{
	"job": {
		"setting": {
			"speed": {
				"byte": 10485760
			}
		},
		"content": [{
			"reader": {
				"name": "mysqlreader",
				"parameter": {
					"username": "${rusername}",
					"password": "${rpassword}",
					"connection": [{
						"jdbcUrl": ["jdbc:mysql://192.168.1.9:3928/test?useSSL=false"],
						"querySql": [
							"SELECT '大渡桥横铁索寒。更喜岷山千里雪，三军过后尽开颜。' as test, '大渡桥横铁索寒。更喜岷山千里雪，' as TEST1, '三军过后尽开颜。' as TEST2, '你好' as TEST3,'测试' as TEST4 FROM test.test WHERE 1=1 LIMIT 1 "
						]
					}]
				}
			},
			"writer": {
				"name": "oraclewriter",
				"parameter": {
					"batchSize": 1024,
					"username": "${wusername}",
					"password": "${wpassword}",
					"column": ["TEST", "TEST1", "TEST2", "TEST3", "TEST4"],
					"connection": [{
						"jdbcUrl": "jdbc:oracle:thin:@(DESCRIPTION = (ADDRESS = (PROTOCOL = TCP)(HOST = 192.168.1.3)(PORT = 1521)) (ADDRESS = (PROTOCOL = TCP)(HOST = 192.168.1.5)(PORT = 1521)) (LOAD_BALANCE = yes)(failover=on)(connect_data= (service_name = orcl)))",
						"table": [
							"TEST"
						]
					}]
				}
			},
			//新增节点
			"transformer": [{
				//name为我们自定义的transformer中起的名字
                public GbkIsConvertToAsciiTransformer() {
                    setTransformerName("dx_ConvertToAscii");
                  }
	            "name": "dx_ConvertToAscii",
                "parameter": {
				   "columnIndex":1
				}
            }]
		}]
	}
}

jdk1.8api
关注
使用Datax自定义采集组件Reader/Writer实现国产数据库支持以及_Datax数据清洗/过滤规则功能自定义---大数据之DataX工作笔记007
添柴程序猿的专栏
04-08 572
我们基于datax来做的自己的数据采集系统,现在基本的数据采集已经实现了,也就是调用datax的数据采集能力,实现在已支持的数据库之间同步数据.我们是基于datax-web实现的,里面都有开源的代码了,可以分析以后拿过来用,这个过程并不复杂,而且,结合xxljob的web那个开源项目,也可以让datax和定时任务结合起来,思路是这样的,而且实现也不复杂,小同事去做的就搞定了.然后再去使用的时候,记得,在之前的datax脚本中,添加上,上面的脚本就可以了。在这个文件中,可以看到这里进行了初始化的操作,
datax 中Transformer的使用
阿尼古
03-26 7856
datax中的Transformer的使用 建议看一下datax的源码哦！其实没有我们想象的那么复杂... 同步配置如下：（我把相关连接了，域名了省略了...） { "content": [ { "reader": { "name": "hivereader", "parameter": { "col...
Datax自定义Transformer数据清洗(使用本地加载local_storage解耦合)
qq_18453581的博客
08-23 4365
准备 需要依赖(我的把源码下来,本地install,远程仓库是否有这两个依赖不确定) <dependency> <groupId>com.alibaba.datax</groupId> <artifactId>datax-core</artifactId> <version>0.0.1-SNAPSHOT</version>
DataX 运行时加载自定义 transformer 插件
陆上溪流
03-28 7572
如何让 DataX 运行时加载自定义 transformer 插件 早该知道的一种更高级的 transformer 自定义方法。 前言 之前的文章有介绍过通过自定义 transformer 在 DataX 上实现 ETL(Extract Transform Load) 过程中定制化的数据处理，当时的实现方法是自定义插件并手写代码注册到com/alibaba/datax/core/transport...
数据同步过程中的数据转换——DataX Transformer实践
最新发布
abx2757548434676的博客
07-17 1613
最近遇到一个需求，需要从一个表里读取数据，并解密其中一个字段，然后写入另一个表中，表的数据量大概是一千多万，一开始直接用MyBatis-Plus3.5.4开始支持的一个流式查询来完成这一功能，但是实践起来发现数据同步的效率十分低；后来采用了DataX自定义Transformer的方式实现了高效数据同步。
datax 自定义transformer
wang972779876的博客
05-31 1468
datax 自带的transformer ：
DataX从入门到精通04—自定义transformer
欲望以提升热忱 毅力以磨平高山
09-03 5681
文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import
Datax数据处理自定义接口--Transformer的实现及使用
T_Ghost的博客
01-08 1316
datax会在初始化时加载TransformerRegistry并将指定的Transformer进行注册。要将自定义的Transformer加入其注册的静态代码块中。
DataX自定义transformer编写指南
陆上溪流
04-13 8285
DataX自定义transformer编写指南 用于数据加密 jave开发环境 maven Python 2.* 概述 DataX 是阿里巴巴集团内被广泛使用的离线数据同步工具/平台，实现包括 MySQL、Oracle、SqlServer、Postgre、HDFS、Hive、ADS、HBase、TableStore(OTS)、MaxCompute(ODPS)、DRDS 等各种异...
datax如何将自定义的transformer插件加载到一个新项目中去
05-25
要将自定义的transformer插件加载到一个新项目中，可以按照以下步骤操作： 1. 将自定义的transformer...- 自定义的transformer插件的配置信息需要按照datax的job配置文件的格式配置，具体可以参考datax的官方文档。
DataX插件开发指南
11-03
淘宝： DataX插件开发指南 说明了。datax插件开发的方法，用java语言实现
java身份证工具类（校验身份证是否合法、通过身份证获取年龄、性别、生日，将15位身份证转为18位等）
zjx2016的博客
01-08 7731
一、简介 因为工作需要经常用到身份证做一些相关操作，于是通过查阅资料总结出一些常用的工具方法，包括校验身份证是否合法、通过身份证获取年龄、通过身份证获取性别、通过身份证获取户籍地址、通过身份证获取生日、将15位身份证转为18位身份证等。
datax(21):编写自己的Transformer
热门推荐
water Wang
01-26 12万+
前面2篇文章，已经看完+学习完transform的内容，今天继续编写一个自己的transformer； 一、环境 win10 DataX 3.0(从我的datax分支打包而来) job.json使用datax的样例json，源文件在xxx\DataX\core\src\main\job\中，打包编译后在xxx\DataX\target\datax\datax\job下。本文略做修改，主要修改2出，是否打印和记录行数 { "job": { "setting": { .
DATAX编译及Transformer自定义插件添加
soviet1991的博客
11-23 759
编译成功，已经是万里长征走完了99%，下面就编写插件吧，这是我写的一个关于获取经纬度的插件。别忘了注册：而后编译，找到target目录，里面就是编译好的DATAX工具，可以直接使用。在job.json里，writer节点下面加：短期内，我不想用它了，看到就反胃。
datax自定义transfrom 怎么写？
编程界小学生的博客
04-27 2866
在使用datax数据处理过程中，我们常常要对某些字段进行处理，一般我们首先想到的是使用数据库自定义函数来处理，可是当遇到一些复杂的场景，写函数可能就比较困难，或者根本无法实现，即使实现了，可移植性也很差，比如我最近遇到的 要对身份证号脱敏的需求，需求是要按照SM3加密的方式去脱敏身份证号，之前我也用过oracle实现，因为oracle可以使用java源的方式，可是最近新的产品使用mysql，这样就导致要重写开发这个脱敏的需求。mysql不支持java源，使用函数写出SM3加密算法无疑工作量庞大，可参考的
创建自定义转换器（Creating Custom Transformers）
duguyiren3476的专栏
02-12 467
作者：wuwenyu | 出处：博客园 | 2011/11/30 9:38:29 | 阅读16次 Creating Custom Transformers 一个自定义转换器是实现了org.mule.api.transformer.Transformer接口的用户自定义类。你的类可以根据需要继承 AbstractTransformer 或者 AbstractMessageAwareTr...
自定义类型转换器
08-06 1148
struts2自定义类型转换器
datax自定义reader-＞kuduReader
cclovezbf的博客
05-26 1271
kudureader
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值