Hadoop允许Elasticsearch在Spark中以两种方式使用：通过自2.1以来的专用支持，或者通过自2.0以来的Map/Reduce桥接器。从5.0版本开始，elasticsearch-hadoop就支持Spark 2.0。
为Spark添加ES支持
1、引入Maven
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-sql_${scala.version}</artifactId>
<version>${spark.version}</version>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.elasticsearch</groupId>
<artifactId>elasticsearch-hadoop</artifactId>
<version>7.2.0</version>
<scope>test</scope>
</dependency>
2、添加基础配置
更多配置详情请参考：点我
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.sql.SparkSession;
import org.apache.spark.sql.types.DataTypes;
import org.apache.spark.sql.types.StructField;
import org.apache.spark.sql.types.StructType;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
/**
* @Auther: majx2
* @Date: 2019-8-2 09:41
* @Description:
*/
public class SparkHelper {
private static SparkSession session = SparkSession.builder().config(getConf()).getOrCreate();
public static JavaSparkContext getContext(){
return JavaSparkContext.fromSparkContext(session.sparkContext());
}
public static SparkSession getSession() {
return session;
}
private static SparkConf getConf(){
final SparkConf conf = new SparkConf().setAppName("SparkDemo").setMaster("local[4]");
conf.set("es.nodes", "127.0.0.1");
conf.set("es.port", "9200");
conf.set("es.net.http.auth.user", "elastic");
conf.set("es.net.http.auth.pass", "elastic");
conf.set("es.scroll.size", "10000");
return conf;
}
public static StructType getStructType() {
List<StructField> fields = new ArrayList<>();
StructField field;
field = DataTypes.createStructField("id", DataTypes.StringType, true);
fields.add(field);
field = DataTypes.createStructField("entity", DataTypes.StringType, true);
fields.add(field);
return DataTypes.createStructType(fields);
}
}
3、搭建一个运行结构
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.map.MapUtil;
import com.alibaba.fastjson.JSON;
import com.midea.ec.fc.datacenter.common.spark.dto.CustomOrderReport;
import lombok.extern.slf4j.Slf4j;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.sql.*;
import org.apache.spark.sql.types.DataTypes;
import org.apache.spark.sql.types.StructField;
import org.apache.spark.sql.types.StructType;
import org.elasticsearch.spark.rdd.Metadata;
import org.elasticsearch.spark.rdd.api.java.JavaEsSpark;
import org.elasticsearch.spark.sql.api.java.JavaEsSparkSQL;
import org.spark_project.guava.collect.ImmutableList;
import org.spark_project.guava.collect.ImmutableMap;
import scala.Tuple2;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**
* @Auther: majx2
* @Date: 2019-8-2 09:38
* @Description:
*/
@Slf4j
public class SparkEsTest {
final static JavaSparkContext jsc = SparkHelper.getContext();
final static SparkSession session = SparkHelper.getSession();
final static SQLContext sql = new SQLContext(SparkHelper.getSession());
public static void main(String[] args) throws SQLException {
// 写入数据
simpleWrite();
simpleWrite2();
jsonWrite();
dynamicIndexWrite();
saveWithMeta();
readByRDD();
saveBySQL();
// 读取数据
readByRDD();
readBySQL();
}
}
写入数据到ES
1、通过rdd写入两条记录
并通过es.mapping.id设置元数据_id值为id字段。
private static void simpleWrite(){
Map<String, ?> numbers = ImmutableMap.of("id",1,"one", 1, "two", 2);
Map<String, ?> airports = ImmutableMap.of("id",2,"OTP", "Otopeni", "SFO", "San Fran");
// 创建一个简单的RDD
JavaRDD<Map<String, ?>> javaRDD = SparkHelper.getContext().parallelize(ImmutableList.of(numbers, airports));
JavaEsSpark.saveToEs(javaRDD, "spark/demo",ImmutableMap.of("es.mapping.id", "id"));
}
效果如下：
rdd写入es
2、通过对象的方式写入
准备对象，并实现序列化。如果不序列化会异常
import lombok.Data;
import java.io.Serializable;
import java.sql.Timestamp;
/**
* @Auther: majx2
* @Date: 2019-8-5 11:04
* @Description:
*/
@Data
public class CustomOrderReport implements Serializable {
private static final long serialVersionUID = 4858959432062088728L;
private Long id;
private Timestamp shipedReturnTime;
private String customerCode;
}
通过rdd的方式写入
private static void simpleWrite2() throws SQLException {
List<CustomOrderReport> reportList = Lists.newArrayList();
List<Entity> list = Db.use().query("select * from f_order_report_701 where id < ?", 30);
list.forEach(p->{
CustomOrderReport report = p.toBean(CustomOrderReport.class);
reportList.add(report);
});
JavaRDD<CustomOrderReport> javaRDD = jsc.parallelize(reportList);
JavaEsSpark.saveToEs(javaRDD, "spark-simple2/_doc", ImmutableMap.of("es.mapping.id", "id"));
}
效果如下：
把对象写入ES
3、通过JSON写入ES
public static void jsonWrite(){
String json1 = "{\"reason\" : \"business\",\"airport\" : \"SFO\"}";
String json2 = "{\"participants\" : 5,\"airport\" : \"OTP\"}";
JavaRDD<String> stringRDD = jsc.parallelize(ImmutableList.of(json1, json2));
JavaEsSpark.saveJsonToEs(stringRDD, "spark-json/_doc");
}
效果如下：
将JSON数据写入ES
4、动态索引写入数据
使用占位符：{media_type}，media_type对应数据中的字段key
public static void dynamicIndexWrite(){
Map<String, ?> game = ImmutableMap.of("media_type", "game", "title", "FF VI",
"year", "1994");
JavaRDD<Map<String, ?>> dynamicRDD = jsc.parallelize(ImmutableList.of(game));
JavaEsSpark.saveToEs(dynamicRDD, "spark-collection-{media_type}/_doc");
}
效果如下：
动态索引
5、带上元数据写入
public static void saveWithMeta(){
// 保存元数据
Map<String, ?> otp = ImmutableMap.of("iata", "OTP", "name", "Otopeni");
Map<String, ?> sfo = ImmutableMap.of("iata", "SFO", "name", "San Fran");
// 文档对应的元数据
Map<Metadata, Object> otpMeta = ImmutableMap.of(Metadata.ID, 1, Metadata.VERSION, "1");
Map<Metadata, Object> sfoMeta = ImmutableMap.of(Metadata.ID, "2", Metadata.VERSION, "23");
// create a pair RDD between the id and the docs
JavaPairRDD<?, ?> pairRDD = jsc.parallelizePairs(
ImmutableList.of(new Tuple2(otpMeta, otp), new Tuple2(sfoMeta, sfo))
);
JavaEsSpark.saveToEsWithMeta(pairRDD, "spark-with-meta-data/_doc");
}
效果如下：
添加元数据
6、通过SparkSQL保存结果
private static void saveBySQL(){
final Dataset<Row> dataset = JavaEsSparkSQL.esDF(sql, "spark-simple/_doc", "?q=Otopeni");
JavaEsSparkSQL.saveToEs(dataset, "spark-sql/_doc",ImmutableMap.of("es.mapping.id", "id"));
}
效果如下：
SparkSQL写入数据
从ES读取数据
1、通过rdd读取ES数据
并转换为自定义的Dataset对象。
private static void readByRDD() {
JavaPairRDD<String, Map<String, Object>> esPairRDD = JavaEsSpark.esRDD(SparkHelper.getContext(), "f_order_report_701/_doc");
JavaRDD<Row> esRDD = esPairRDD.map(entity -> {
Map<String, Object> source = entity._2();
source.remove("esCreateTime");
source.remove("esUpdateTime");
source = MapUtil.sort(source);
return RowFactory.create(entity._1(), JSON.toJSONString(source));
});
Dataset<Row> dataset = SparkHelper.getSession().createDataFrame(esRDD, SparkHelper.getStructType());
dataset.show(3);
log.info(dataset.head().toString());
}
返回结果：
+---+--------------------+
| id| entity|
+---+--------------------+
| 69|{"accountTime":15...|
| 70|{"accountTime":15...|
| 72|{"accountTime":15...|
+---+--------------------+
only showing top 3 rows
2019-08-06 14:41:22.460 [main] [INFO ] [c.m.e.f.d.common.spark.SparkEsTest] - [69,{"accountTime":1563379200000,"applyType":5,"cateId":"1","createTime":1563420070000,"customerCode":"C0010850","franchiser":"0","id":69,"isAdjust":0,"itemId":"31031050000042","orderAttribute":2,"ouId":701,"outerOrderId":"920190718004","outerStoreCode":"SHC44F4140","salesCenterCode":"3608380682-1","salesChannel":2,"salesOrderId":"OM19071800000003","settlementAmount":699.0,"shipedReturnTime":1563420061000,"shopId":2,"status":5,"updateTime":1563421756000,"writeOffAmount":0.0,"writeOffStatus":0}]
2、使用SparkSQL读取ES数据
private static void readBySQL() {
final Dataset<Row> dataset = JavaEsSparkSQL.esDF(sql, "spark-simple/_doc");
dataset.createOrReplaceTempView("simple");
final Dataset<Row> result = session.sql("SELECT * FROM simple WHERE id =1");
result.show();
}
返回结果如下：
+----+----+---+---+---+
| OTP| SFO| id|one|two|
+----+----+---+---+---+
|null|null| 1| 1| 2|
+----+----+---+---+---+
3、提高性能的写法
使用elasticsearch-hadoop作为Spark源的一个重要隐藏特性是，连接器理解在DataFrame/SQL中执行的操作，并且在默认情况下，将这些操作转换为适当的QueryDSL。换句话说，连接器直接下推源上的操作，在源上有效地过滤数据，以便只将所需的数据流回Spark。这极大地提高了查询性能，并将Spark和Elasticsearch集群上的CPU、内存和I/O降到最低，因为只返回所需的数据(而不是只返回批量数据，由Spark处理和丢弃)。注意，下推操作即使在指定查询时也适用——连接器将根据指定的SQL增强查询。
private static void readByPushDown(){
Dataset<Row> dataset;
dataset = sql.read().format("org.elasticsearch.spark.sql").load("spark-simple/_doc");
dataset = dataset.filter(dataset.col("id").equalTo(1)).select("id","one","two");
dataset.show();
session.sql("CREATE TEMPORARY TABLE simple USING org.elasticsearch.spark.sql OPTIONS (path 'spark-simple/_doc',scroll_size '20')");
dataset = session.sql("SELECT id,one,two FROM simple WHERE id = 1");
dataset.show();
}
返回结果：
+---+---+---+
| id|one|two|
+---+---+---+
| 1| 1| 2|
+---+---+---+
+---+---+---+
| id|one|two|
+---+---+---+
| 1| 1| 2|
+---+---+---+
The End !
参考资料：https://www.elastic.co/guide/en/elasticsearch/hadoop/7.3/spark.html
网友评论