精华内容
下载资源
问答
  • ElasticSearch插入数据
    万次阅读
    2019-04-27 17:30:47

    向之前创建的people索引中插入一条man的数据,请求的url: http://127.0.00.1:9200/people/man/1
    请求类型PUT,参数如下

    {
    	"name": "wali",
    	"country": "China",
    	"age": 20,
    	"date": "1996-04-20"
    }
    

    如果自动生成id,请求url如下: http://127.0.00.1:9200/people/man 请求类型: POST

    更多相关内容
  • 现有a表和b表,两张mysql数据库的表,需要把两张表的数据取共同字段,合并并导入es中,其中a表共有数据1000条,b表共有数据1200条,a表和b表的主键id都是从1开始递增的,结果导入的时候显示成功导入2200条数据,而...
  • ElasticSearch数据导入

    2020-04-30 16:32:41
    ElasticSearch数据导入 文件导入 单个索引导入 文件按格式采用Json
  • 本文介绍了基于Spring Batch向Elasticsearch批量导入数据示例,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • ElasticSearch 批量导入一批数据 解压后再当前位置命令行执行命令
  • 首先,我的索引结构是酱紫的。   ...以上所述是小编给大家介绍的Python中elasticsearch插入和更新数据的实现方法,希望对大家有所帮助,如果大家有任何疑问欢迎给我留言,小编会及时回复大家的!
  • 今天小编就为大家分享一篇python批量导入数据Elasticsearch的实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • elasticsearch批量导入数据重复问题

    千次阅读 2019-09-13 08:25:26
    package com.zhidou.es.export; import com.zhidou.es.config.ExporES; import com.zhidou.es.config.InitES; import com.zhidou.es.util.DateUtil; import ...
    package com.zhidou.es.export;
    
    import com.zhidou.es.config.ExporES;
    import com.zhidou.es.config.InitES;
    import com.zhidou.es.util.DateUtil;
    import org.elasticsearch.action.bulk.BulkRequestBuilder;
    import org.elasticsearch.action.search.SearchResponse;
    import org.elasticsearch.action.search.SearchType;
    import org.elasticsearch.client.Client;
    import org.elasticsearch.common.unit.TimeValue;
    import org.elasticsearch.index.query.QueryBuilders;
    import org.elasticsearch.search.SearchHits;
    
    import java.io.*;
    import java.util.Date;
    
    
    /**
     * description
     * Created by 08101 on 2017/6/5.
     */
    public class ExportES {
    
    
        public void  getESinformatation()
    
        {
            Client client = InitES.initClient();
            SearchResponse response = client.prepareSearch("i_his_adas_data").setTypes("his_adas_data")
                    .setQuery(QueryBuilders.matchAllQuery()).setSize(50000).setScroll(new TimeValue(600000))
                    .setSearchType(SearchType.SCAN).execute().actionGet();//setSearchType(SearchType.Scan) 告诉ES不需要排序只要结果返回即可 setScroll(new TimeValue(600000)) 设置滚动的时间
            String scrollid = response.getScrollId();
            try {
                //把导出的结果以JSON的格式写到文件里
                BufferedWriter out = new BufferedWriter(new FileWriter("eseses", true));
    
                //每次返回数据10000条。一直循环查询直到所有的数据都查询出来
                while (true) {
                    SearchResponse response2 = client.prepareSearchScroll(scrollid).setScroll(new TimeValue(1000000))
                            .execute().actionGet();
                    SearchHits searchHit = response2.getHits();
                    //再次查询不到数据时跳出循环
                    if (searchHit.getHits().length == 0) {
                        break;
                    }
                    System.out.println("查询数量 :" + searchHit.getHits().length);
                    for (int i = 0; i < searchHit.getHits().length; i++) {
                        String json = searchHit.getHits()[i].getSourceAsString();
                        out.write(json);
                        out.write("\r\n");
                    }
                }
                System.out.println("查询结束");
                out.close();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
    
        public void insertESInformation(){
    
    
            Client client= ExporES.initClient();
            try {
                //读取刚才导出的ES数据
                BufferedReader br = new BufferedReader(new FileReader("eseses"));
                String json = null;
                int count = 0;
                //开启批量插入
                BulkRequestBuilder bulkRequest = client.prepareBulk();
                while ((json = br.readLine()) != null) {
                    bulkRequest.add(client.prepareIndex("i_his_adas_data", "his_adas_data").setSource(json));
                    //每一千条提交一次
                    if (count% 10000==0) {
                        bulkRequest.execute().actionGet();
                        System.out.println(DateUtil.format(new Date())+"提交了:" + count);
                    }
                    count++;
                }
                bulkRequest.execute().actionGet();
                System.out.println("插入完毕");
                br.close();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
    }

     

     

     

    /**
    * description
    * Created by 08101 on 2017/6/13.
    */
    public class mainEs {

        public static void main(String[] args) {

            ExportES exportES=new ExportES();
            exportES.getESinformatation();
            exportES.insertESInformation();

        }
    }

     

    转载于:https://my.oschina.net/u/3537613/blog/948324

    展开全文
  • JAVA 导入数据Elasticsearch

    千次阅读 2022-01-15 15:29:52
    导入数据Elasticsearch中 前言 我们在使用es时候,需要手动将数据导入到es中,导入数据无非就是给es中写入数据,可以从mysql中写入,也可以从其他db或者excle中导入中间需要做一层转换,然后使用es的相关api批量...

    导入数据到Elasticsearch中

    es入门使用
    es索引使用
    es分词使用
    es聚合使用
    java操作es

    前言

    我们在使用es时候,需要手动将数据导入到es中,导入数据无非就是给es中写入数据,可以从mysql中写入,也可以从其他db或者excle中导入中间需要做一层转换,然后使用es的相关api批量写入es中。

    写入的几种方案

    写入方案有很多种:

    • 业务代码中异步写入
      如我们创单成功时,异步将订单数据写入es中
    • 数据同步到mq中然后mq在写入es中
      如项目日志操作,kafka + es 收集日志操作
    • 将mysql指定表中数据写入到es
      这里我们演示将某个表中数据写入es中
    • 订阅mysql binlog 异步导入es
      cancel伪装bin log 将解析后的数据导入到es中

    具体操作

    一般随着业务的发展,db查询到一定程度就显得力不从心(当然这里指的是加索引,分库分表以及各种优化之后也无济于事,数据量还是很大),此时我们就需要使用es来提高查询效率,此时就需要从db将数据导入到es中。

    • 读取db数据
    • 批量写入es
    • 依次循环,直到数据都被写完

    实现

    写入es方法有很多种,我们可以使用es的api,一条一条写,也可以批量操作。

    这里我们使用es官方推荐的一个工具类Using Bulk Processor操作
    官方文档地址

    版本:

    jdk: 11
    es:7.1
    sb : 2.1
    mysql: 5.7

    首先导入依赖

     <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
    
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
            </dependency>
            <dependency>
                <groupId>org.elasticsearch.client</groupId>
                <artifactId>elasticsearch-rest-high-level-client</artifactId>
                <version>7.3.0</version>
                <exclusions>
                    <exclusion>
                        <groupId>org.elasticsearch</groupId>
                        <artifactId>elasticsearch</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
    
            <dependency>
                <groupId>org.elasticsearch</groupId>
                <artifactId>elasticsearch</artifactId>
                <version>7.3.0</version>
            </dependency>
    
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-thymeleaf</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-devtools</artifactId>
                <scope>runtime</scope>
                <optional>true</optional>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-configuration-processor</artifactId>
                <optional>true</optional>
            </dependency>
    
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
                <exclusions>
                    <exclusion>
                        <groupId>org.junit.vintage</groupId>
                        <artifactId>junit-vintage-engine</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
    
            <!-- HttpClient -->
            <dependency>
                <groupId>org.apache.httpcomponents</groupId>
                <artifactId>httpclient</artifactId>
                <version>4.5.3</version>
            </dependency>
    
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.58</version>
            </dependency>
    
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>
    
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.38</version>
                <classifier></classifier>
                <scope>compile</scope>
            </dependency>
    
            <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
                <version>3.9</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
                <scope>test</scope>
            </dependency>
    
    
        </dependencies>
    
    

    yml配置

    spring:
      devtools:
        restart:
          enabled: true  #\u8BBE\u7F6E\u5F00\u542F\u70ED\u90E8\u7F72
          additional-paths: src/main/java #\u91CD\u542F\u76EE\u5F55
          exclude: WEB-INF/**
        freemarker:
          cache: false    #\u9875\u9762\u4E0D\u52A0\u8F7D\u7F13\u5B58\uFF0C\u4FEE\u6539\u5373\u65F6\u751F\u6548
    
      elasticsearch:
        rest:
          uris: 127.0.0.1:9200
    server:
      port: 8080
    
    logging:
      level:
        root: info
        com.xdclass.search: debug
    

    我们需要初始化db,以及es(这里可以集群,也可以单机),然后写相关api
    首先是db操作,这里直接单个db实例,简单一点,当然也可以使用其他的mybatis,jpa,jdbc等

    package com.example.esdemo.config;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    
    public class DBHelper {
        public static final String url = "jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai";
    //    public static final String name = "com.mysql.cj.jdbc.Driver";
        public static final String name = "com.mysql.jdbc.Driver";
        public static final String user = "root";
        public static final String password = "root";
        private  static Connection  connection = null;
    
        public  static   Connection  getConn(){
            try {
                Class.forName(name);
                connection = DriverManager.getConnection(url,user,password);
            }catch (Exception e){
                e.printStackTrace();
            }
            return  connection;
        }
    }
    
    

    es配置

    package com.example.esdemo.config;
    
    import org.apache.http.HttpHost;
    import org.elasticsearch.client.RestClient;
    import org.elasticsearch.client.RestHighLevelClient;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    public class ElasticsearchConfig {
    
    
        @Value("${spring.elasticsearch.rest.uris}")
        private String hostlist;
    
        @Bean
        public RestHighLevelClient restHighLevelClient() {
            //解析hostlist配置信息
            String[] split = hostlist.split(",");
            //创建HttpHost数组,其中存放es主机和端口的配置信息
            HttpHost[] httpHostArray = new HttpHost[split.length];
            for (int i = 0; i < split.length; i++) {
                String item = split[i];
                httpHostArray[i] = new HttpHost(item.split(":")[0], Integer.parseInt(item.split(":")[1]), "http");
            }
            //创建RestHighLevelClient客户端
            return new RestHighLevelClient(RestClient.builder(httpHostArray));
        }//项目主要使用RestHighLevelClient,对于低级的客户端暂时不用
    
        @Bean
        public RestClient restClient() {
            // 解析hostlist配置信息
            String[] split = hostlist.split(",");
            //创建HttpHost数组,其中存放es主机和端口的配置信息
            HttpHost[] httpHostArray = new HttpHost[split.length];
            for (int i = 0; i < split.length; i++) {
                String item = split[i];
                httpHostArray[i] = new HttpHost(item.split(":")[0], Integer.parseInt(item.split(":")[1]), "http");
            }
            return RestClient.builder(httpHostArray).build();
        }
    }
    
    

    db 和es相关的表明和index名

     */
    public class ImportDb2Es {
    
        private String dbTableName;
    
        private String esIndexName;
        //get  set 省略
    }
    
    

    然后是相关service,导入service

    public interface ImportService {
    
        void importDb2Es(String dbName,String esIndexName);
    }
    

    实现

    package com.example.esdemo.service.impl;
    
    import com.example.esdemo.config.DBHelper;
    import com.example.esdemo.imports.ImportDb2Es;
    import com.example.esdemo.service.ImportService;
    import org.apache.logging.log4j.LogManager;
    import org.apache.logging.log4j.Logger;
    import org.elasticsearch.action.ActionListener;
    import org.elasticsearch.action.bulk.BackoffPolicy;
    import org.elasticsearch.action.bulk.BulkProcessor;
    import org.elasticsearch.action.bulk.BulkRequest;
    import org.elasticsearch.action.bulk.BulkResponse;
    import org.elasticsearch.action.index.IndexRequest;
    import org.elasticsearch.client.RequestOptions;
    import org.elasticsearch.client.RestHighLevelClient;
    import org.elasticsearch.common.unit.ByteSizeUnit;
    import org.elasticsearch.common.unit.ByteSizeValue;
    import org.elasticsearch.common.unit.TimeValue;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    import java.sql.*;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.concurrent.TimeUnit;
    import java.util.function.BiConsumer;
    
    
    /**
     * 导入db2es 实现类
     */
    @Component
    public class ImportServiceImpl implements ImportService {
    
        private static final Logger logger = LogManager.getLogger(ImportServiceImpl.class);
    
        @Autowired
        private RestHighLevelClient client;
    
    
        @Override
        public void importDb2Es(ImportDb2Es importDb2Es) {
            writeMySQLDataToES(importDb2Es.getDbTableName(),importDb2Es.getDbTableName());
        }
    
    
        private void writeMySQLDataToES(String tableName,String esIndeName) {
            BulkProcessor bulkProcessor = getBulkProcessor(client);
            Connection connection = null;
            PreparedStatement ps = null;
            ResultSet rs = null;
            try {
                connection = DBHelper.getConn();
                logger.info("start handle data :" + tableName);
                String sql = "select * from " + tableName;
                ps = connection.prepareStatement(sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
                // 根据自己需要设置 fetchSize
                ps.setFetchSize(20);
                rs = ps.executeQuery();
                ResultSetMetaData colData = rs.getMetaData();
                ArrayList<HashMap<String, String>> dataList = new ArrayList<>();
                HashMap<String, String> map = null;
                int count = 0;
                // c 就是列的名字   v 就是列对应的值
                String c = null;
                String v = null;
                while (rs.next()) {
                    count++;
                    map = new HashMap<String, String>(128);
                    for (int i = 1; i < colData.getColumnCount(); i++) {
                        c = colData.getColumnName(i);
                        v = rs.getString(c);
                        map.put(c, v);
                    }
                    dataList.add(map);
                    // 每1万条 写一次   不足的批次的数据 最后一次提交处理
                    if (count % 10000 == 0) {
                        logger.info("mysql handle data  number:" + count);
                        // 将数据添加到 bulkProcessor
                        for (HashMap<String, String> hashMap2 : dataList) {
                            bulkProcessor.add(new IndexRequest(esIndeName).source(hashMap2));
                        }
                        // 每提交一次 清空 map 和  dataList
                        map.clear();
                        dataList.clear();
                    }
                }
                // 处理 未提交的数据
                for (HashMap<String, String> hashMap2 : dataList) {
                    bulkProcessor.add(new IndexRequest(esIndeName).source(hashMap2));
                }
                bulkProcessor.flush();
    
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                try {
                    rs.close();
                    ps.close();
                    connection.close();
                    boolean terinaFlag = bulkProcessor.awaitClose(150L, TimeUnit.SECONDS);
                    logger.info(terinaFlag);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
    
        }
    
        private BulkProcessor getBulkProcessor(RestHighLevelClient client) {
    
            BulkProcessor bulkProcessor = null;
            try {
    
                BulkProcessor.Listener listener = new BulkProcessor.Listener() {
                    @Override
                    public void beforeBulk(long executionId, BulkRequest request) {
                        logger.info("Try to insert data number : "
                                + request.numberOfActions());
                    }
    
                    @Override
                    public void afterBulk(long executionId, BulkRequest request,
                                          BulkResponse response) {
                        logger.info("************** Success insert data number : "
                                + request.numberOfActions() + " , id: " + executionId);
                    }
    
                    @Override
                    public void afterBulk(long executionId, BulkRequest request, Throwable failure) {
                        logger.error("Bulk is unsuccess : " + failure + ", executionId: " + executionId);
                    }
                };
    
                BiConsumer<BulkRequest, ActionListener<BulkResponse>> bulkConsumer = (request, bulkListener) -> client
                        .bulkAsync(request, RequestOptions.DEFAULT, bulkListener);
    
                BulkProcessor.Builder builder = BulkProcessor.builder(bulkConsumer, listener);
                builder.setBulkActions(5000);
                builder.setBulkSize(new ByteSizeValue(100L, ByteSizeUnit.MB));
                builder.setConcurrentRequests(10);
                builder.setFlushInterval(TimeValue.timeValueSeconds(100L));
                builder.setBackoffPolicy(BackoffPolicy.constantBackoff(TimeValue.timeValueSeconds(1L), 3));
                // 注意点:让参数设置生效
                bulkProcessor = builder.build();
    
            } catch (Exception e) {
                e.printStackTrace();
                try {
                    bulkProcessor.awaitClose(100L, TimeUnit.SECONDS);
                } catch (Exception e1) {
                    logger.error(e1.getMessage());
                }
            }
            return bulkProcessor;
        }
    }
    
    

    这里我们提供一个http 测试

     @Autowired
        private ImportService importService;
    
        @RequestMapping("api/import")
        public Map<String, Object> imports(ImportDb2Es importDb2Es) {
            Map<String, Object> map = new HashMap<>();
    
    
            importService.importDb2Es(importDb2Es);
            map.put("code", 200);
            map.put("msg", "成功");
    
            return map;
        }
    

    这里我们准备了一个表一些数据
    在这里插入图片描述

    测试

    我们调用http接口

    http://127.0.0.1:8080/api/import?dbTableName=position&esIndexName=position_index
    

    可以看到我们的后台导入日志50条数据
    在这里插入图片描述
    我们去es中查询如下100条(这里我请求了2次,所以是100条)在这里插入图片描述

    展开全文
  • Elasticsearch批量插入数据使用bulk批量操作数据库1. 创建批量操作文件格式:{"index":{"_index":"home","_type":"home",""_id":"2"}}{"id": 2, "location": "南京市栖霞区马群街道29号", "money": 3000, "area":80, ...

    Elasticsearch批量插入数据

    使用bulk批量操作数据库

    1. 创建批量操作文件

    格式:

    {"index":{"_index":"home","_type":"home",""_id":"2"}}

    {"id": 2, "location": "南京市栖霞区马群街道29号", "money": 3000, "area":80, "type": "三居室", "style": "整租"}

    第一行指定请求与索引和类型,可以选择的请求有"create","index","delete","ubdate",

    "_index"指定索引名,"_type"指定类型名,"_id"指定id

    第二行指定插入的内容.

    如request.json:

    {"index":{"_index":"home","_type":"home","_id":"2"}}

    {"id": 2, "location": "南京市栖霞区马群街道29号", "money": 3000, "area":80, "type": "三居室", "style": "整租"}

    {"index":{"_index":"home","_type":"home","_id":"3"}}

    {"id": 3, "location": "南京市玄武区山西路门路29号", "money": 400, "area":15, "type": "四居室", "style": "合租"}

    {"index":{"_index":"home","_type":"home","_id":"4"}}

    {"id": 4, "location": "南京市秦淮区山北京东路29号", "money": 500, "area":14, "type": "三居室", "style": "合租"}

    {"index":{"_index":"home","_type":"home","_id":"5"}}

    {"id": 5, "location": "南京市秦淮区新街口29号", "money": 450, "area":16, "type": "四居室", "style": "合租"}

    2.执行批量操作文件

    在数据库根目录执行:

    curl -XPUT 'localhost:9200/_bulk' -H "Content-Type: application/json" --data-binary @request.json

    展开全文
  • elasticsearch插入数据

    千次阅读 2019-08-25 19:21:09
    我们先创建一个book索引,类型为小说,字段 (author:作者,title:标题,world_count:字数,publish... "title": "ElasticSearch入门", "world_count":"3000", "publish_date":"2017-08-20" } head插件结果:
  • java整合ElasticSearch导入数据es

    千次阅读 2021-03-05 14:36:55
    实体类:利用注解建立实体类会自动根据实体类创建索引,不需要自己建立mappingpackage com.msic.mall.search.domain;import lombok.AllArgsConstructor;import lombok.Data;import lombok.NoArgsConstructor;import ...
  • (三)ElasticSearch插入数据 分类:分为指定文档id插入、自动产生文档id插入两类。(文档id是唯一索引指,指向索引数据) 1 自己指定id { "name":"瓦力", "country":"China", "age":30, "date":"1987-3-7" } ...
  • 从mysql导入数据elasticsearch 这个项目使用Spring Boot和Spring jdbc和elasticsearch框架将数据从mysql表导入到elasticsearch中 如何使用 您需要扩展AbstractDataCollector类,然后重写AbstractDataCollector类...
  • 3.1 插入数据时对索引进行预排序 Index sorting (索引排序)可用于在插入时对索引进行预排序,而不是在查询时再对索引进行排序,这将提高范围查询(range query)和排序操作的性能。 在 Elasticsearch 中创建新索引...
  • [logstash.outputs.elasticsearch] retrying failed action with response code: 429 ({type=>es_rejected_execution_exception, reason=>rejected execution of processing of [12373521] [indices:data/write/bulk...
  • elasticsearch数据插入后,需要刷新分片,最长1s。可以在请求时设置refresh=true,立马可见。 es官方文档
  • 在这里,我使用Elasticsearch官方推荐elasticsearch第三方包来讲述插入数据的两种方法。安装elasticsearch插件pip install elasticsearch1.index这是很简单的一个插入数据的方法,每条数据调用一个index方法,代码...
  • 官网给出的介绍:https://www.elastic.co/guide/en/elasticsearch/reference/6.0/docs-bulk.html The REST API endpoint is /_bulk, and it expects the following newline delimited JSON (NDJSON) structure: ...
  • 1.安装Elasticsearch-Head进行搜索本地es环境内的所有数据 下载git项目文件:https://github.com/mobz/elasticsearch-head 本地解压之后,直接使用浏览器打开即可 第二步:关于kibana不能监控es环境内...
  • 弹性的 一种将数据从excel文件移动到elasticsearch的工具。 用法:java -jar excelastic.jar data.xls -es:host localhost -es:index test -es:type mytype
  • 主要介绍了利用Java多线程技术导入数据Elasticsearch的方法步骤,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 导入数据(后续ES索引表中的数据均来源于数据库中,所以需要将数据库中的数据查询出来后统一导入到ES库中) 需求:将数据库中的Goods表中的所有数据,导入到ElasticSearch中 实现步骤: ​ 1. 在ES创建一个Goods的的...
  • from elasticsearch import Elasticsearchfrom elasticsearch import helpersimport pymysqlimport time# 连接ESes = Elasticsearch(['127.0.0.1'],port=9200# 连接MySQLprint("Connect to mysql...")mysql_db = ...
  • php-elasticsearch 单条、批量插入数据 1.单条插入 <?php include '../vendor/Elasticsearch/autoload.php'; $a['hosts'] = array( #需要用户名时 http://user:password@URL:por 其他时候直接写ip:port 'ip:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 86,436
精华内容 34,574
关键字:

es插入数据

友情链接: Alina.rar