创建工程
新建JAVA或者maven项目,并添加 hive-exec-2.1.0.jar 和hadoop-common-2.7.3.jar
hive-exec-2.1.0.jar 在HIVE安装目录的lib目录下,从安装目录直接下载放到工程中即可
hadoop-common-2.7.3.jar在hadoop的安装目录下的\share\hadoop\common
编写自定义UDF函数
当写hive UDF时,有两个选择:一是继承 UDF类,二是继承抽象类GenericUDF。这两种实现不同之处 是:GenericUDF 可以处理复杂类型参数,并且继承GenericUDF更加有效率,因为UDF class 需要HIve使用反射的方式去实现。
处理map类型的数据,是复杂类型因此继承GenericUDF。
简单说明:
// 这个类似于简单API的evaluat方法,它可以读取输入数据和返回结果
abstract Object evaluate(GenericUDF.DeferredObject[] arguments);
// 该方法无关紧要,我们可以返回任何东西,但应当是描述该方法的字符串
abstract String getDisplayString(String[] children);
// 只调用一次,在任何evaluate()调用之前,你可以接收到一个可以表示函数输入参数类型的object inspectors数组
// 这是你用来验证该函数是否接收正确的参数类型和参数个数的地方
abstract ObjectInspector initialize(ObjectInspector[] arguments);
实现map数据排序
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.apache.hadoop.hive.ql.exec.UDFArgumentException;
import org.apache.hadoop.hive.ql.exec.UDFArgumentLengthException;
import org.apache.hadoop.hive.ql.exec.UDFArgumentTypeException;
import org.apache.hadoop.hive.ql.metadata.HiveException;
import org.apache.hadoop.hive.ql.udf.generic.GenericUDF;
import org.apache.hadoop.hive.serde2.objectinspector.MapObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector.Category;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory;
import org.apache.hadoop.io.Text;
/**
* Sort a map
* the function simple:sort_map(map,'key','desc'),返回map(string,string)
* @author Irwin
*
*/
public class SortMapTest extends GenericUDF {
private MapObjectInspector mapOI;
private final Map<Text, Text> sortMap = new LinkedHashMap<Text, Text>();
private ArrayList<Object> keyList = new ArrayList<Object>();
private ArrayList<Object> valueList = new ArrayList<Object>();
@Override
public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException {
// 检查是否接收到正确的参数类型
if (arguments.length != 3) {
throw new UDFArgumentLengthException("The function SORT_MAP only accepts 3 argument. simple: sort_map(map,'key','desc')");
} else if (!(arguments[0] instanceof MapObjectInspector) || !(arguments[1] instanceof ObjectInspector) || !(arguments[2] instanceof ObjectInspector)) {
throw new UDFArgumentTypeException(0, "\""
+ Category.MAP.toString().toLowerCase()
+ "\" is expected at function SORT_MAP, " + "but \""
+ arguments[0].getTypeName() + " or " + arguments[1].getTypeName() + " or " + arguments[2].getTypeName() + "\" is found");
}
mapOI = (MapObjectInspector) arguments[0];
//定义返回类型参数
return ObjectInspectorFactory.getStandardMapObjectInspector(
PrimitiveObjectInspectorFactory.writableStringObjectInspector,
PrimitiveObjectInspectorFactory.writableStringObjectInspector);
}
@Override
public Object evaluate(DeferredObject[] arguments) throws HiveException {
sortMap.clear();
keyList.clear();
valueList.clear();
Object mapObj = arguments[0].get();
String key_valueObj = ((Text)arguments[1].get()).toString();
String orderObj = ((Text)arguments[2].get()).toString();
keyList.addAll(mapOI.getMap(mapObj).keySet());
valueList.addAll(mapOI.getMap(mapObj).values());
Map<Text,Text> inputMap = new HashMap<Text, Text>();
//put keys and values
for (int i = 0; i < keyList.size(); i++) {
inputMap.put(new Text(keyList.get(i).toString()), new Text(valueList.get(i).toString()));
}
if (key_valueObj.equals("key")) {
sortMap.putAll(sortMayByKey(inputMap, orderObj));
return sortMap;
}else {
sortMap.putAll(sortMapByValue(inputMap, orderObj));
return sortMap;
}
}
@Override
public String getDisplayString(String[] children) {
return "map(" + children[0] + ")";
}
public static Map<Text, Text> sortMapByValue(Map<Text, Text> map, final String order) {
Map<Text, Text> sortMap = new LinkedHashMap<Text, Text>();
List<Map.Entry<Text, Text>> list_Data = new ArrayList<Map.Entry<Text, Text>>(map.entrySet());
// 通过Collections.sort(List I,Comparator c)方法进行排序
Collections.sort(list_Data,
new Comparator<Map.Entry<Text, Text>>() {
@Override
public int compare(Entry<Text, Text> o1, Entry<Text, Text> o2) {
if (order.equals("asc")) {
return o1.toString().compareTo(o2.toString());
} else {
return o2.toString().compareTo(o1.toString());
}
}
});
// put the sorted map
for (Entry<Text, Text> entry : list_Data) {
sortMap.put(entry.getKey(), entry.getValue());
}
return sortMap;
}
public static Map<Text, Text> sortMayByKey(Map<Text, Text> map, final String order) {
Map<Text, Text> sortMap = new LinkedHashMap<Text, Text>();
List<Text> arrayList = new ArrayList<Text>(map.keySet());
Collections.sort(arrayList, new Comparator<Text>() {
@Override
public int compare(Text o1, Text o2) {
if (order.equals("asc")) {
return o1.toString().compareTo(o2.toString());
}else {
return o2.toString().compareTo(o1.toString());
}
}
});
//将排序好的key返回
for (Text key : arrayList) {
sortMap.put(key, map.get(key));
}
return sortMap;
}
}
打成jar包
如果想在Hive中使用UDF,那么需要将Java代码进行编译,然后将编译后的UDF二进制类文件打包成一个JAR文件。如下步骤:
1.右键项目,选择Export;
2.选择导出格式为JAR file格式
3.点击Next,选择要导出的项目,以及填写导出的目录:
4.点击Finish完成
hive中操作
1.将jar包上传到服务器上
2.在hive中
add jar /home/hdfs/hadoop-SortMapLabelTest.jar;
create temporary function sort_map as '程序的包名.类名';
select sort_map(usageinfo,'key','asc') from tmp_usage_map_h
需要注意的是,JAR文件路径是不需要用引号括起来的,同时,到目前为止这个路径需要是当前文件系统的全路经。Hive不仅仅将这个JAR文件加入到classpath下,同时还将其加入到分布式缓存中,这样整个集群的机器都是可以获得该JAR文件的。
需要注意的是,CREATE FUNCTION语句中的TEMPORARY这个关键字。当前会话中声明的函数只会在当前会话中有效。因此用户需要在每个会话中都增加JAR然后创建函数。不过,如果用户需要频繁地使用同一个JAR文件和函数的话,那么可以将相关语句增加到$HOME/.hiverc文件中去。
参考:一些网址