返回介绍
文江博客 开发文档 Hive 教程 文章详情

Hive SerDe 序列化与反序列化

发布于 2024-06-23 16:10:22 字数 17020 浏览 0 评论 0 收藏 0

SerDe 是 Serializer/Deserializer 的缩写，即序列化和反序列化。

  • 序列化是对象转换成字节序列的过程。
  • 反序列化是字节序列转换成对象的过程。

对象的序列化主要有两种用途：

  • 对象的持久化，即把对象转换成字节序列后保存到文件。
  • 对象数据的网络传输。

除了上面这两点，Hive 中序列化的作用还包括：Hive 的反序列化是对 key / value 反序列化成 Hive 表的每个列的值。Hive 可以方便的把数据加载到表而不需要对数据进行转换。这样在处理海量数据时可以节省大量的时间。

SerDe 可以让 Hive 从表中读取数据，然后以任意自定义格式把数据写回 HDFS。你可以根据具体的数据格式开发自定义的 SerDe 实现。

表数据行的序列化和反序列化大概过程如下：

  • HDFS 文件 ——> InputFileFormate ——>——> 反序列化 ——> 数据行对象（Row object）
  • 数据行对象（Row object）——> 序列化 ——>——> OutputFileFormate ——> HDFS 文件

需要特别注意的是，在数据读取的时候 “key” 部分是会被忽略的，并且在数据写入的时候 “key” 部分总是一个常量。而数据行对象是被存储在 “value” 里的。

SerDe 的使用

数据的序列化方式与反序列号方式是在创建表的时候指定的。

  1. CREATE [EXTERNAL] TABLE [IF NOT EXISTS] table_name
  2. [(col_name data_type [COMMENT col_comment], ...)]
  3. [COMMENT table_comment]
  4. [PARTITIONED BY (col_name data_type [COMMENT col_comment], ...)]
  5. [CLUSTERED BY (col_name, col_name, ...)
  6. [SORTED BY (col_name [ASC|DESC], ...)]
  7. INTO num_buckets BUCKETS]
  8. [ROW FORMAT row_format]
  9. [STORED AS file_format]
  10. [LOCATION hdfs_path]

如上创建表语句， 使用 row format 参数来指定 SerDe 的类型。

Hive 的 SerDe 分类

Hive 最新的 SerDe 库是 org.apache.hadoop.hive.serde2 ，而旧的库 org.apache.hadoop.hive.serde 已经摒弃不用了。看源码的话只需要看 serde2 这个库即可。

Hive 内置的 SerDe 类型

Hive 使用下面的 FileFormat 类型来读写 HDFS 文件：

TextInputFormat/HiveIgnoreKeyTextOutputFormat
该格式用于读写文本文件格式的数据。

SequenceFileInputFormat/SequenceFileOutputFormat
该格式用于读写 Hadoop 的序列文件格式。

Hive 序列化和反序列化数据使用以下 SerDe 类：

MetadataTypedColumnsetSerDe
这个 SerDe 类型用于读写以某个分隔符分隔的记录。比如使用逗号分隔符的记录（CSV），tab 键分隔符的记录。

LazySimpleSerDe
这个是默认的 SerDe 类型。读取与 MetadataTypedColumnsetSerDe 和 TCTLSeparatedProtocol 相同的数据格式，可以用这个 Hive SerDe 类型。它是以惰性的方式创建对象的，因此具有更好的性能。在 Hive 0.14.0 版本以后，在读写数据时它支持指定字符编码。例如：

  1. ALTER TABLE person SET SERDEPROPERTIES (‘serialization.encoding’=’GBK’)

如果把配置属性 hive.lazysimple.extended_boolean_literal 设置为 true（Hive 0.14.0 以后版本），LazySimpleSerDe 可以把 ‘T’, ‘t’, ‘F’, ‘f’, ‘1’, and ‘0’ 视为合法的布尔字面量。而该配置默认是 false 的，因此它只会把 ‘True’ 和 ‘False’ 视为合法的布尔字面量。

Thrift SerDe
读写 Thrift 序列化对象，可以使用这种 Hive SerDe 类型。需要确定的是，对于 Thrift 对象，类文件必须先被加载。

动态 SerDe
为了读写 Thrift 序列化对象，我们可以使用这种 SerDe 类型。它可以理解 Thrift DDL 语句，所以对象的模式可以在运行时被提供。另外，它支持许多不同的协议，包括 TBinaryProtocol, TJSONProtocol, TCTLSeparatedProtocol。

下面汇集了一些其他的 SerDe 类型及其新增的对应 Hive 版本：
Hive 0.12.0 新增支持 Json 文件的 JsonSerDe。
Hive 0.9.1 新增支持 Avro 文件格式的 AvroSerDe，在建表时，如果文件格式指定的是 AVRO（STORED AS AVRO），那么默认 SerDe 就是 AvroSerDe。
Hive 0.11.0 新增支持 ORC 文件格式的 SerDe ，即 ORCSerDe
Hive 0.10 新增支持 Parquet 文件格式的 SerDe ，即 ParquetSerDe

自定义 SerDe 类型

如果 Hive 的自定义 Serde 类型不能满足你的需求，你可以自己定义自己的 SerDe 类型。

开发自定义 SerDe 类型

定义一个类， 继承抽象类 AbstractSerDe， 实现 initialize 和 deserialize 两个方法。示例代码如下：

  1. package com.coder4.hive;
  2. import java.util.ArrayList;
  3. import java.util.Arrays;
  4. import java.util.HashMap;
  5. import java.util.List;
  6. import java.util.Map;
  7. import java.util.Properties;
  9. import org.apache.commons.lang.StringUtils;
  10. import org.apache.hadoop.conf.Configuration;
  11. import org.apache.hadoop.hive.serde.Constants;
  12. import org.apache.hadoop.hive.serde2.AbstractSerDe;
  13. import org.apache.hadoop.hive.serde2.SerDeException;
  14. import org.apache.hadoop.hive.serde2.SerDeStats;
  15. import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
  16. import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory;
  17. import org.apache.hadoop.hive.serde2.typeinfo.PrimitiveTypeInfo;
  18. import org.apache.hadoop.hive.serde2.typeinfo.TypeInfo;
  19. import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoUtils;
  20. import org.apache.hadoop.io.Text;
  21. import org.apache.hadoop.io.Writable;
  23. public class MySerDe extends AbstractSerDe {
  24.     // params
  25.     private List<String> columnNames = null;
  26.     private List<TypeInfo> columnTypes = null;
  27.     private ObjectInspector objectInspector = null;
  28.     // seperator
  29.     private String nullString = null;
  30.     private String lineSep = null;
  31.     private String kvSep = null;
  33.     @Override
  34.     public void initialize(Configuration conf, Properties tbl)
  35.             throws SerDeException {
  36.         // Read sep
  37.         lineSep = "\n";
  38.         kvSep = "=";
  39.         nullString = tbl.getProperty(Constants.SERIALIZATION_NULL_FORMAT, "");
  41.         // Read Column Names
  42.         String columnNameProp = tbl.getProperty(Constants.LIST_COLUMNS);
  43.         if (columnNameProp != null && columnNameProp.length() > 0) {
  44.             columnNames = Arrays.asList(columnNameProp.split(","));
  45.         } else {
  46.             columnNames = new ArrayList<String>();
  47.         }
  49.         // Read Column Types
  50.         String columnTypeProp = tbl.getProperty(Constants.LIST_COLUMN_TYPES);
  51.         // default all string
  52.         if (columnTypeProp == null) {
  53.             String[] types = new String[columnNames.size()];
  54.             Arrays.fill(types, 0, types.length, Constants.STRING_TYPE_NAME);
  55.             columnTypeProp = StringUtils.join(types, ":");
  56.         }
  57.         columnTypes = TypeInfoUtils.getTypeInfosFromTypeString(columnTypeProp);
  59.         // Check column and types equals
  60.         if (columnTypes.size() != columnNames.size()) {
  61.             throw new SerDeException("len(columnNames) != len(columntTypes)");
  62.         }
  64.         // Create ObjectInspectors from the type information for each column
  65.         List<ObjectInspector> columnOIs = new ArrayList<ObjectInspector>();
  66.         ObjectInspector oi;
  67.         for (int c = 0; c < columnNames.size(); c++) {
  68.             oi = TypeInfoUtils
  69.                     .getStandardJavaObjectInspectorFromTypeInfo(columnTypes
  70.                             .get(c));
  71.             columnOIs.add(oi);
  72.         }
  73.         objectInspector = ObjectInspectorFactory
  74.                 .getStandardStructObjectInspector(columnNames, columnOIs);
  76.     }
  78.     @Override
  79.     public Object deserialize(Writable wr) throws SerDeException {
  80.         // Split to kv pair
  81.         if (wr == null)
  82.             return null;
  83.         Map<String, String> kvMap = new HashMap<String, String>();
  84.         Text text = (Text) wr;
  85.         for (String kv : text.toString().split(lineSep)) {
  86.             String[] pair = kv.split(kvSep);
  87.             if (pair.length == 2) {
  88.                 kvMap.put(pair[0], pair[1]);
  89.             }
  90.         }
  92.         // Set according to col_names and col_types
  93.         ArrayList<Object> row = new ArrayList<Object>();
  94.         String colName = null;
  95.         TypeInfo type_info = null;
  96.         Object obj = null;
  97.         for (int i = 0; i < columnNames.size(); i++) {
  98.             colName = columnNames.get(i);
  99.             type_info = columnTypes.get(i);
  100.             obj = null;
  101.             if (type_info.getCategory() == ObjectInspector.Category.PRIMITIVE) {
  102.                 PrimitiveTypeInfo p_type_info = (PrimitiveTypeInfo) type_info;
  103.                 switch (p_type_info.getPrimitiveCategory()) {
  104.                 case STRING:
  105.                     obj = StringUtils.defaultString(kvMap.get(colName), "");
  106.                     break;
  107.                 case LONG:
  108.                 case INT:
  109.                     try {
  110.                         obj = Long.parseLong(kvMap.get(colName));
  111.                     } catch (Exception e) {
  112.                     }
  113.                 }
  114.             }
  115.             row.add(obj);
  116.         }
  117.         return row;
  118.     }
  119.     @Override
  120.     public ObjectInspector getObjectInspector() throws SerDeException {
  121.         return objectInspector;
  122.     }
  123.     @Override
  124.     public SerDeStats getSerDeStats() {
  125.         return null;
  126.     }
  127.     @Override
  128.     public Class<? extends Writable> getSerializedClass() {
  129.         return Text.class;
  130.     }
  131.     @Override
  132.     public Writable serialize(Object arg0, ObjectInspector arg1)
  133.             throws SerDeException {
  134.         return null;
  135.     }
  136. }

使用自定义 Serde 类型

  1. hive > add jar MySerDe.jar

创建表格时属性 row fromat 指定自定义的 SerDe 类。

  1. CREATE EXTERNAL TABLE IF NOT EXISTS teacher ( 
  2.           id BIGINT, 
  3.           name STRING,
  4.           age INT)
  5. ROW FORMAT SERDE 'com.coder4.hive.MySerDe'
  6. STORED AS TEXTFILE
  7. LOCATION '/usr/hive/text/'

ObjectInspector

Hive 使用 ObjectInspector 对象分析行对象的内部结构以及列的结构。

具体来说，ObjectInspector 给访问复杂的对象提供了一种统一的方式。对象可能以多种格式存储在内存中：

  • Java 类实例，Thrift 或者 原生 Java
  • 标准 Java 对象，比如 Map 字段，我们使用 java.util.List 表示 Struct 和 Array ，以及使用 java.util.Map。
  • 惰性初始化对象。

此外，可以通过 (ObjectInspector, java 对象) 这种结构表示一个复杂的对象。它为我们提供了访问对象内部字段的方法，而不涉及对象结构相关的信息。出了序列化的目的，Hive 建议为自定义 SerDes 创建自定义的 objectinspector，SerDe 有两个构造器，一个无参构造器，一个常规构造器。

如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论， 你可以免费 注册 一个本站的账号。
列表为空，暂无数据
    我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站，即表示您同意使用 Cookies 和您的相关数据。
    原文