电商离线数仓项目-DWD层ETL数据清洗,最大亮点之自定义UDF函数

ODS层所得到的数据,是最原始的数据,保持原貌,不做任何的改变,例如 id:1 name:zhangsan类型字段加上字段值。在导入DWD层的时候,我们要对这个数据做处理,只取到value值,去除字段的名称。这里面用到UDF(一进一出)和UDTF(一进多出)。

展示一条最初始的数据:

这条数据,红色框起来的部分是基本字段对应一对一出。而蓝色框起来的部分是一进多出。所要的格式如下:

要对获取到的日志数据进行处理,去空,转义,清洗等等.这时候我就需要我们来对初始的原始数据进行清洗.日志服务器获取到的数据是往往json对象,因此要对json对象进行解析,通过自定义UDF/UDTF函数来对其进行清洗:

(1)新建一个maven工程,在新建的maven工程中,创建好包.(com.atguigu.udf),然后再对pom.xml中导入如下的所需依赖:

    <repositories>
        <repository>
            <id>spring</id>
            <url>https://maven.aliyun.com/repository/spring</url>
        </repository>
    </repositories>
    <properties>
        <project.build.sourceEncoding>UTF8</project.build.sourceEncoding>
        <hive.version>1.2.1</hive.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-exec</artifactId>
            <version>${hive.version}</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

UDF函数实现的思路:UDF函数有两个参数,一个是叫line也就是采集到的一条完整的日志数据,另一个参数是我们dwd层所创建的表的字段的string集合叫做keys。
首先将keys集合进行切割成String数组.接着将line切割成包含时间戳和json格式的数据,切割好之后,先做一个合法性的校验:判断切割好的数组长度是否为2和json格式的数据是否为空,如果错误.返回false。如果不为空,则创建jsonObject对象开始进行处理.通过遍历keys的中元素,取出jsonObject对象中所对应的值,并将其添加到StringBuilder对象中,最后将StringBuilder对象转成String并且返回。

package com.atguigu.udf;

import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.hive.ql.exec.UDF;
import org.json.JSONException;
import org.json.JSONObject;

public class BaseFieldUDF extends UDF {
    //line:整条的原始数据  jsonkeysString:公众字段keys的集合
    public String evaluate(String line,String jsonkeysString){
        //new 一个sb
        StringBuilder sb = new StringBuilder();
        //1.切割jsonkeys mid.uid,vc....
        String[] jsonkeys = jsonkeysString.split(",");
        //2.处理line 服务器时间|json
        String[] logContents = line.split("\\|");
        //3.合法性校验(判断空可以通过StringUtils.isBlank方法)
        if(logContents.length != 2 || StringUtils.isBlank(logContents[1])){
            return "";
        }
        //4.开始处理json
        try {
            JSONObject jsonObject = new JSONObject(logContents[1]);
            if(jsonObject==null){
                return "";
            }else{
                JSONObject base = jsonObject.getJSONObject("cm");
                if(base == null ){
                    return "";
                }else{
                    //循环遍历取值
                    for(int i =0;i<jsonkeys.length;i++){
                        String fieldName = jsonkeys[i].trim();
                        if(base.has(fieldName)){
                            sb.append(base.getString(fieldName)).append("\t");
                        }else{
                            sb.append(" ").append("\t");
                        }
                    }
                    sb.append(jsonObject.getString("et")).append("\t");
                    sb.append(logContents[0]).append("\t");
                }
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }
     return sb.toString();
    }
    //主方法主要是用来做测试
    public static void main(String[] args) {

        String line = "1541217850324|{\"cm\":{\"mid\":\"m7856\",\"uid\":\"u8739\",\"ln\":\"-74.8\",\"sv\":\"V2.2.2\",\"os\":\"8.1.3\",\"g\":\"[email protected]\",\"nw\":\"3G\",\"l\":\"es\",\"vc\":\"6\",\"hw\":\"640*960\",\"ar\":\"MX\",\"t\":\"1541204134250\",\"la\":\"-31.7\",\"md\":\"huawei-17\",\"vn\":\"1.1.2\",\"sr\":\"O\",\"ba\":\"Huawei\"},\"ap\":\"weather\",\"et\":[{\"ett\":\"1541146624055\",\"en\":\"display\",\"kv\":{\"newsid\":\"n4195\",\"copyright\":\"ESPN\",\"content_provider\":\"CNN\",\"extend2\":\"5\",\"action\":\"2\",\"extend1\":\"2\",\"place\":\"3\",\"showtype\":\"2\",\"category\":\"72\",\"newstype\":\"5\"}},{\"ett\":\"1541213331817\",\"en\":\"loading\",\"kv\":{\"extend2\":\"\",\"loading_time\":\"15\",\"action\":\"3\",\"extend1\":\"\",\"type1\":\"\",\"type\":\"3\",\"loading_way\":\"1\"}},{\"ett\":\"1541126195645\",\"en\":\"ad\",\"kv\":{\"entry\":\"3\",\"show_style\":\"0\",\"action\":\"2\",\"detail\":\"325\",\"source\":\"4\",\"behavior\":\"2\",\"content\":\"1\",\"newstype\":\"5\"}},{\"ett\":\"1541202678812\",\"en\":\"notification\",\"kv\":{\"ap_time\":\"1541184614380\",\"action\":\"3\",\"type\":\"4\",\"content\":\"\"}},{\"ett\":\"1541194686688\",\"en\":\"active_background\",\"kv\":{\"active_source\":\"3\"}}]}";
        String x = new BaseFieldUDF().evaluate(line, "mid,uid,vc,vn,l,sr,os,ar,md,ba,sv,g,hw,nw,ln,la,t");
        System.out.println(x);
    }

}

一进多出UDTF:的写法如下:

package com.atguigu.udtf;

import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.hive.ql.exec.UDFArgumentException;
import org.apache.hadoop.hive.ql.metadata.HiveException;
import org.apache.hadoop.hive.ql.udf.generic.GenericUDTF;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory;
import org.apache.hadoop.hive.serde2.objectinspector.StructObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory;
import org.json.JSONArray;
import org.json.JSONException;

import java.util.ArrayList;

public class EventJsonUDTF extends GenericUDTF {

    //该方法中，我们将指定输出参数的名称和参数类型：
    @Override
    public StructObjectInspector initialize(ObjectInspector[] argOIs) throws UDFArgumentException {

        ArrayList<String> fieldNames = new ArrayList<String>();
        ArrayList<ObjectInspector> fieldOIs = new ArrayList<ObjectInspector>();
		//输出参数的名称和参数类型:
        fieldNames.add("event_name");
        //这一个语句的意思是:event_name和event_json的类型指定为String
        fieldOIs.add(PrimitiveObjectInspectorFactory.javaStringObjectInspector);
        fieldNames.add("event_json");
        fieldOIs.add(PrimitiveObjectInspectorFactory.javaStringObjectInspector);

        return ObjectInspectorFactory.getStandardStructObjectInspector(fieldNames, fieldOIs);
    }

    //输入1条记录，输出若干条结果
    @Override
    public void process(Object[] objects) throws HiveException {

        // 获取传入的et
        String input = objects[0].toString();

        // 如果传进来的数据为空，直接返回过滤掉该数据
        if (StringUtils.isBlank(input)) {
            return;
        } else {

            try {
                // 获取一共有几个事件（ad/facoriters）
                JSONArray ja = new JSONArray(input);

                if (ja == null)
                    return;

                // 循环遍历每一个事件
                for (int i = 0; i < ja.length(); i++) {
                    String[] result = new String[2];

                    try {
                        // 取出每个的事件名称（ad/facoriters）
                        result[0] = ja.getJSONObject(i).getString("en");

                        // 取出每一个事件整体
                        result[1] = ja.getString(i);
                    } catch (JSONException e) {
                        continue;
                    }

                    // 将结果返回
                    forward(result);
                }
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }
    }

    //当没有记录处理的时候该方法会被调用，用来清理代码或者产生额外的输出
    @Override
    public void close() throws HiveException {

    }
}

总结:
UDF:
创建MAVEN工程,导入HIVE相关的依赖,创建类去继承UDF类,自己写一校验的方法(evaluate),这个方法传染两个参数:一个是一条原始的数据line,一个是表字段用逗号分割的String,叫做keys :首先准备一个StringBuilder对象,然后分别对我们传入的两个参数进行切割,将keys集合通过split方法进行切割成String数组.将原始的一条数据line切割成包含时间戳和json格式的数据,切割好之后,先做一个合法性的校验:判断切割好的数组长度是否为2和json格式的数据是否为空,如果错误.返回false。如果不为空,则创建jsonObject对象开始进行处理.通过遍历keys的中元素,取出jsonObject对象中所对应的值,并将其添加到StringBuilder对象中,最后将StringBuilder对象转成String并且返回。
UDTF:
创建一个类,extends GenericUDTF类,实现三个方法:initialize(),process(),close()方法。
在initialize()方法中,我们将指定输出参数的名称和参数的类型:event_name,event_json。两个都是String类型。在process方法中,获取我们输入的json对象,遍历循环每一个事件,取出事件的名称和事件整体。最后将结果返回。close()方法,当没有记录处理的时候,方法会被调用,关闭资源。