Flink实时处理并将结果写入ElasticSearch实战

参考原博客： https://blog.csdn.net/weixin_44516305/article/details/90258883

1 需求分析

使用Flink对实时数据流进行实时处理，并将处理后的结果保存到Elasticsearch中，在Elasticsearch中使用IK Analyzer中文分词器对指定字段进行分词。

为了模拟获取流式数据，自定义一个流式并行数据源，每隔10ms生成一个Customer类型的数据对象并返回给Flink进行处理。

Flink处理后的结果保存在Elasticsearch中的index_customer索引的type_customer类型中，并且对description字段的数据使用IK Analyzer中文分词器进行分词。

2 Flink实时处理

2.1 版本说明

1. Flink：1.8.0
2. Elasticsearch：6.5.4
3. JDK：1.8

使用IDEA创建一个名称为FlinkElasticsearchDemo的Maven工程，目录结构如下图所示：

2.3 程序代码

1. 在pom.xml中引入flink以及flink连接elasticsearch相关的依赖，代码如下所示：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.flink</groupId>
    <artifactId>flink-elasticsearch-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-core</artifactId>
            <version>1.8.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-clients_2.11</artifactId>
            <version>1.8.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-java</artifactId>
            <version>1.8.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-streaming-java_2.11</artifactId>
            <version>1.8.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-elasticsearch6_2.11</artifactId>
            <version>1.8.0</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.56</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

　　

2. 创建两个具有依赖关系的实体类Customer和Address，用于封装实时数据，代码如下所示：

package com.flink.domain;

import java.util.Date;

/**
 * 客户实体类
 */
public class Customer {
    private Long id;
    private String name;
    private Boolean gender;
    private Date birth;
    private Address address;
    private String description;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Boolean getGender() {
        return gender;
    }

    public void setGender(Boolean gender) {
        this.gender = gender;
    }

    public Date getBirth() {
        return birth;
    }

    public void setBirth(Date birth) {
        this.birth = birth;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}

　　

package com.flink.domain;

/**
 * 地址实体类
 */
public class Address {
    private Integer id;
    private String province;
    private String city;

    public Address(Integer id, String province, String city) {
        this.id = id;
        this.province = province;
        this.city = city;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }
}

　　

3. 自定义一个获取流式实时数据的Flink数据源，如下所示：

package com.flink.source;

import com.flink.domain.Address;
import com.flink.domain.Customer;
import org.apache.flink.streaming.api.functions.source.ParallelSourceFunction;
import java.util.Date;
import java.util.Random;

/**
 * 自定义的流式并行数据源
 */
public class StreamParallelSource implements ParallelSourceFunction<Customer> {

    private boolean isRunning = true;
    private String[] names = new String[5];
    private Address[] addresses = new Address[5];
    private Random random = new Random();
    private Long id = 1L;

    public  void init() {
        names[0] = "刘备";
        names[1] = "关羽";
        names[2] = "张飞";
        names[3] = "曹操";
        names[4] = "诸葛亮";

        addresses[0]= new Address(1, "湖北省", "武汉市");
        addresses[1]= new Address(2, "湖北省", "黄冈市");
        addresses[2]= new Address(3, "广东省", "广州市");
        addresses[3]= new Address(4, "广东省", "深圳市");
        addresses[4]= new Address(5, "浙江省", "杭州市");
    }

    /**
     * 每隔10ms生成一个Customer数据对象（模拟获取实时数据）
     */
    @Override
    public void run(SourceContext sourceContext) throws Exception {
        init();
        while(isRunning) {
            int nameIndex = random.nextInt(5);
            int addressIndex = random.nextInt(5);

            Customer customer = new Customer();
            customer.setId(id++);
            customer.setName(names[nameIndex]);
            customer.setGender(random.nextBoolean());
            customer.setBirth(new Date());
            customer.setAddress(addresses[addressIndex]);
            customer.setDescription("" + names[nameIndex] + "来自" + addresses[addressIndex].getProvince() + addresses[addressIndex].getCity());
            /**
             * 把创建的数据返回给Flink进行处理
             */
            sourceContext.collect(customer);
            Thread.sleep(10);
        }
    }

    @Override
    public void cancel() {
        this.isRunning = false;
    }
}

　　

4. 编写一个Flink实时处理流式数据的主程序，代码如下所示：

package com.flink.main;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.flink.domain.Customer;
import com.flink.source.StreamParallelSource;
import org.apache.flink.api.common.functions.FilterFunction;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.functions.RuntimeContext;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.elasticsearch.ElasticsearchSinkFunction;
import org.apache.flink.streaming.connectors.elasticsearch.RequestIndexer;
import org.apache.flink.streaming.connectors.elasticsearch6.ElasticsearchSink;
import org.apache.http.HttpHost;
import org.elasticsearch.client.Requests;
import java.util.ArrayList;
import java.util.List;

/**
 * Flink实时处理并将结果写入到ElasticSearch主程序
 */
public class FlinkToElasticSearchApp {

    public static void main(String[] args) throws Exception {
        /**
         * 获取流处理环境并设置并行度
         */
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(4);

        /**
         * 指定数据源为自定义的流式并行数据源
         */
        DataStream<Customer> source = env.addSource(new StreamParallelSource());

        /**
         * 对数据进行过滤
         */
        DataStream<Customer> filterSource = source.filter(new FilterFunction<Customer>() {
            @Override
            public boolean filter(Customer customer) throws Exception {
                if (customer.getName().equals("曹操") && customer.getAddress().getProvince().equals("湖北省")) {
                    return false;
                }
                return true;
            }
        });

        /**
         * 对过滤后的数据进行转换
         */
        DataStream<JSONObject> transSource = filterSource.map(new MapFunction<Customer, JSONObject>() {
            @Override
            public JSONObject map(Customer customer) throws Exception {
                String jsonString = JSONObject.toJSONString(customer, SerializerFeature.WriteDateUseDateFormat);
                System.out.println("当前正在处理:" + jsonString);
                JSONObject jsonObject = JSONObject.parseObject(jsonString);
                return jsonObject;
            }
        });

        /**
         * 创建一个ElasticSearchSink对象
         */
        List<HttpHost> httpHosts = new ArrayList<>();
        httpHosts.add(new HttpHost("localhost", 9200, "http"));
        ElasticsearchSink.Builder<JSONObject> esSinkBuilder = new ElasticsearchSink.Builder<JSONObject>(
                httpHosts,
                new ElasticsearchSinkFunction<JSONObject>() {
                    @Override
                    public void process(JSONObject customer, RuntimeContext ctx, RequestIndexer indexer) {
                        // 数据保存在Elasticsearch中名称为index_customer的索引中，保存的类型名称为type_customer
                        indexer.add(Requests.indexRequest().index("index_customer").type("type_customer").id(String.valueOf(customer.getLong("id"))).source(customer));
                    }
                }
        );
        // 设置批量写数据的缓冲区大小
        esSinkBuilder.setBulkFlushMaxActions(50);

        /**
         * 把转换后的数据写入到ElasticSearch中
         */
        transSource.addSink(esSinkBuilder.build());

        /**
         * 执行
         */
        env.execute("execute FlinkElasticsearchDemo");
    }

}

　　

至此，使用Flink对流式数据进行实时处理并将处理结果保存到Elasticsearch中的程序已经全部完成。

说明：Flink把数据保存到Elasticsearch时，如果Elasticsearch中没有提前创建对应名称的索引，则会自动创建对应名称的索引。

如果不需要在Elasticsearch中对指定字段使用IK Analyzer中文分词器进行分词，则不需要阅读第3节内容，直接阅读第4节即可。

3 Elasticsearch准备

如果希望对Elasticsearch中指定索引中的数据的指定字段使用中文分词器进行分词，则需要先在Elasticsearch中创建索引并指定分词器，所以需要先确保Elasticsearch中已经安装了分词器插件。

说明：本文使用Elasticsearch可视化插件操作Elasticsearch。

3.1 安装IK Analyzer中文分词器
本文中使用的是IK Analyzer中文分词器，并且基于Window 10操作系统，具体的安装过程如下图所示：

1 打开CMD命令窗口并切换到Elasticsearch安装目录下的bin目录中。
2 运行以下命令下载elasticsearch 6.5.4版本对应的IK Analyzer中文分词器：

elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.5.4/elasticsearch-analysis-ik-6.5.4.zip

　　

3 下载完成后提示是否安装，直接输入y进行安装，完整的过程如下图所示：

4 安装完成后，在Elasticsearch的安装目录的plugins目录下会有一个analysis-ik目录，则表示安装完成，如下所示：

5 重启elasticsearch，并通过elasticsearch-head插件来检验IK Analyzer中文分词器是否已安装成功，在复合查询页面输入如下图所示内容，然后提交请求，如果出现如右图所示的分词结果就表明IK Analyzer中文分词器安装成功：

3.2 在Elasticsearch中创建索引

本文是要把过滤后符合条件的Customer类型的数据保存到ElasticSearch中，并能够对Customer中的description字段进行中文分词，

所以需要在Elasticsearch中创建一个索引，通过elasticsearch-head插件创建索引如下图所示，提交请求后如果如下图右边所示则创建成功：

创建索引index_customer的具体json体如下所示：

{
    "settings": {
        "index": {
            "number_of_shards": "5",
            "number_of_replicas": "1"
        },
        "analysis":{
            "analyzer":{
                "ik":{
                    "tokenizer": "ik_max_word"
                }
            }
        }
    },
    "mappings": {
        "type_customer": {
            "properties": {
                "id": {
                    "type": "long"
                },
                "name": {
                    "type": "text"
                },
                "gender": {
                    "type": "boolean"
                },
                "birth": {
                    "type": "date",
                    "format": "yyyy-MM-dd HH:mm:ss"
                },
                "address": {
                    "properties": {
                        "id": {
                            "type": "integer"
                        },
                        "province": {
                            "type": "keyword"
                        },
                        "city": {
                            "type": "keyword"
                        }
                    }
                },
                "description": {
                    "type": "text",
                    "analyzer": "ik_max_word",
                    "search_analyzer": "ik_max_word"
                }
            }
        }
    }
}

　　

创建成功后在概览页面可以查看到如下信息：

4 测试Flink实时处理

启动Elasticsearch并成功创建索引后，直接运行程序中的FlinkToElasticSearchApp程序，在IDEA的控制台就可以看到如下输出信息，则表示Flink程序正在运行并进行实时处理：

此时，在Elasticsearch-head插件中可以查看到index_customer索引中的数据如下图所示，则表示Flink程序实时处理的结果已经正常保存到了Elasticsearch中：

由于本文在创建index_customer索引时，指定了对description字段使用IK Analyzer中文分词器，所以，在左侧的description字段索引框中输入查询内容之后，右边就会快速查询出description字段中包含了查询内容的所有的数据.

Flink写入数据到ElasticSearch (ElasticSearch详细使用指南及采坑记录)

https://blog.csdn.net/lisongjia123/article/details/81121994

Flink 写入数据到 ElasticSearch

https://blog.csdn.net/weixin_44876457/article/details/89398743