ES 整合 Jest 客户端

关于es 的java 客户端的选择

客户端	优点	缺点	建议
TransportClient	启动速度快，轻量级，可创建极多连接，与应用程序解耦；推荐使用原生的，ES本身就很简单，灵活性很高	分发或查询数据速度较慢，不能获取指定节点数据	不建议使用
JestClient	提供Restful API，原生ES API不具备；若ES集群使用不同的ES版本，使用原生ES API会有问题，而Jest不会；更安全（可以在Http层添加安全处理）；JestClient是ElasticSearch的Java HTTP Rest客户端； JestClient填补了 ElasticSearch缺少HttpRest接口客户端的空白; JestClient可以跨版本	更新缓慢（估计已经停止更新）	不建议使用
RestClient	RestClient 使用HTTP API elasticsearch代替内部协议。这需要更少依赖关系。你也不需要关注那么多版本；RestClient可以跨版本，但是也是要这个api版本都支持才可以跨	HttpClient和Jsoup都不直接支持发送DELETE方法带参数的请求（官方高版本已经放弃使用）	不推荐
high-level	官方推出的，版本与ES同步更新	不要跨版本，版本号与 ES保持一致，这个也不算缺点	强烈推荐推荐使用

以下是使用 Jest 客户端的示例：

加入依赖：

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>
<!--ES 客户端 Jest-->
<dependency>
   <groupId>io.searchbox</groupId>
   <artifactId>jest</artifactId>
   <version>${es.jest.version}</version>
</dependency>
<dependency>
   <groupId>net.java.dev.jna</groupId>
   <artifactId>jna</artifactId>
   <version>${native.jna.version}</version>
</dependency>

搜索如果使用 sourcebuilder，需要引入 es 的包，参考：https://www.jianshu.com/p/1be1d90870e1

<dependency>
   <groupId>org.elasticsearch</groupId>
   <artifactId>elasticsearch</artifactId>
   <version>5.5.3</version>
   <scope>compile</scope>
</dependency>

配置ES（必须带http://，ES 通讯是 HTTP协议的，必须带HTTP协议）

#ES配置
spring.elasticsearch.jest.uris=http://192.168.0.88:9200

测试 ES

@Autowired
private JestClient jestClient;
 

 
/**
 * 测试查询ES中的数据
 *
 * @throws IOException
 */
public void EsConnetTest() throws IOException {
 
    Search search = new Search.Builder("json字符串的查询语句")
            .addIndex("index的名字")
            .addType("type的名称(相当于类名)").build();
    SearchResult execute = jestClient.execute(search);
    List<SearchResult.Hit<PublishNotice, Void>> hits = execute.getHits(PublishNotice.class);
    hits.forEach(item -> {
        //得到每一对象
        PublishNotice notice = item.source;
        System.out.println(notice);
    });
}
 
/**
 * 创建 ES的 Index
 *
 * @param indexName
 * @throws IOException
 */
public void creatIndex(String indexName) throws IOException {
    CreateIndex builder = new CreateIndex.Builder(indexName).build();
    JestResult createResult = jestClient.execute(builder);
    boolean succeeded = createResult.isSucceeded();
    System.out.println(succeeded);
 
}
 
 
/**
 * 删除 ES的 Index
 *
 * @param indexName
 * @throws IOException
 */
public void delIndex(String indexName) throws IOException {
    DeleteIndex deleteIndex = new DeleteIndex.Builder(indexName).build();
    JestResult delResult = jestClient.execute(deleteIndex);
    boolean succeeded = delResult.isSucceeded();
    System.out.println(succeeded);
 
}
 
/**
 * 设置index的mapping（设置数据类型和分词方式）
 *
 * @param indexName
 * @param typeName
 * @param mappingString
 * @throws IOException
 */
public void createIndexMapping(String indexName, String typeName, String mappingString) throws IOException {
    //mappingString为拼接好的json格式的mapping串
    PutMapping builder = new PutMapping.Builder(indexName, typeName, mappingString).build();
 
    JestResult jestResult = jestClient.execute(builder);
    System.out.println("createIndexMapping result:{}" + jestResult.isSucceeded());
    if (!jestResult.isSucceeded()) {
        System.err.println("settingIndexMapping error:{}" + jestResult.getErrorMessage());
    }
}
 
/**
 * 获取index的mapping
 *
 * @param indexName
 * @param typeName
 * @return
 */
public String getMapping(String indexName, String typeName) throws IOException {
    GetMapping builder = new GetMapping.Builder()
            .addIndex(indexName)
            .addType(typeName).build();
 
    JestResult result = jestClient.execute(builder);
    if (result != null && result.isSucceeded()) {
        return result.getSourceAsObject(JsonObject.class).toString();
    }
    return null;
}
 
/**
 * 获取索引index设置setting
 *
 * @param indexName
 * @return
 */
public boolean getIndexSettings(String indexName) throws IOException {
    GetSettings builder = new GetSettings.Builder().addIndex(indexName).build();
    JestResult jestResult = jestClient.execute(builder);
    System.out.println(jestResult.getJsonString());
    if (jestResult != null) {
        return jestResult.isSucceeded();
    }
    return false;
}
 
 
/**
 * 更改索引index设置setting
 *
 * @param indexName
 * @return
 */
public boolean updateIndexSettings(String indexName) throws IOException {
 
    XContentBuilder mapBuilder = XContentFactory.jsonBuilder();
    mapBuilder.startObject().startObject("index")
            .field("max_result_window", "1000000")
            .endObject().endObject();
    String source = mapBuilder.toString();
    JestResult jestResult = jestClient.execute(new UpdateSettings.Builder(source).build());
    System.out.println(jestResult.getJsonString());
    if (jestResult != null) {
        return jestResult.isSucceeded();
    }
    return false;
}
 
 
/**
 * 添加索引别名
 *
 * @param indexName
 * @param alias
 */
public void addAlias(List<String> indexName, String alias) throws IOException {
 
    AddAliasMapping build = new AddAliasMapping.Builder(indexName, alias).build();
    ModifyAliases builder = new ModifyAliases.Builder(build).build();
    JestResult jestResult = jestClient.execute(builder);
    System.out.println("result:" + jestResult.getJsonString());
 
}
 
/**
 * 获取索引 别名
 *
 * @param indexName
 * @return
 */
public boolean getIndexAliases(String indexName) throws IOException {
    GetAliases builder = new GetAliases.Builder().addIndex(indexName).build();
    JestResult jestResult = jestClient.execute(builder);
    System.out.println(jestResult.getJsonString());
    if (jestResult != null) {
        return jestResult.isSucceeded();
    }
    return false;
}
 
 
/**
 * 获取索引模版
 *
 * @param template
 */
@Test
public void getTemplate(String template) throws IOException {
    GetTemplate builder = new GetTemplate.Builder(template).build();
    JestResult jestResult = jestClient.execute(builder);
    System.out.println("result:" + jestResult.getJsonString());
}
 
 
/**
 * 添加索引模版
 */
public void putreturnreportTemplate() throws IOException {
 
    XContentBuilder mapBuilder = XContentFactory.jsonBuilder();
    mapBuilder.startObject().field("template", "df_returnreport*").field("order", 1)//
 
            .startObject("settings").field("number_of_shards", 5)//五个分片
            .startObject("index").field("max_result_window", "1000000")//一次查询最大一百万
            .endObject()
            .endObject()
 
            .startObject("mappings")
            .startObject("df_returnreport")//type名
            .startObject("properties") 
            .startObject("id").field("type", "long")
            .endObject() 
            .startObject("username").field("type", "keyword")
            .endObject() 
            .startObject("content").field("type", "text").field("analyzer", "ik_max_word")
            .endObject() 
            .startObject("returntime").field("type", "date").field("format", "yyyy-MM-dd HH:mm:ss")
            .endObject() 
            .startObject("gateway").field("type", "integer")
            .endObject() 
            .endObject()
            .endObject()
            .endObject()
 
            .startObject("aliases").startObject("df_returnreport").endObject()
            .endObject()//别名
 
            .endObject();    String source = mapBuilder.toString();
 
    PutTemplate putTemplate = new PutTemplate.Builder("my_returnreport", source).build();
    JestResult jestResult = jestClient.execute(putTemplate);
 
    System.out.println("result:" + jestResult.getJsonString());
}
 
/**
 * 索引优化
 */
public void optimizeIndex() {
    Optimize optimize = new Optimize.Builder().build();
    jestClient.executeAsync(optimize, new JestResultHandler<JestResult>() {
        public void completed(JestResult jestResult) {
            System.out.println("optimizeIndex result:{}" + jestResult.isSucceeded());
        }
 
        public void failed(Exception e) {
            e.printStackTrace();
        }
    });
}
 
/**
 * 清理缓存
 */
public void clearCache() throws IOException {
    ClearCache clearCache = new ClearCache.Builder().build();
    JestResult execute = jestClient.execute(clearCache);
    System.out.println("清理是否成功" + execute.isSucceeded());
 
}

补充： Jest 链接配置：

@Configuration
public class EsConfig {
   /**
    * 连接地址
    */
   @Value("${es.uri}")
   private String uri;
   /**
    * 超时时间
    */
   @Value("${es.timeOut:10000}")
   private int timeOut;
   /**
    * 用户名（如果设置有）
    */
   @Value("${es.username}")
   private String username;
   /**
    * 密码（如果设置有）
    */
   @Value("${es.password}")
   private String password;
   /**
    * ES 最大连接数
    */
   @Value("${es.maxTotalConn:10}")
   private Integer maxTotalConn;
   /**
    *
    */
   @Value("${es.defaultMaxTotalConnPerRoute:20}")
   private Integer defaultMaxTotalConnPerRoute;
 
   @Bean
   public JestClient createClient() {
      JestClientFactory clientFactory = new JestClientFactory();
      HttpClientConfig config = new HttpClientConfig.Builder(uri)
            .multiThreaded(true)
            .defaultMaxTotalConnectionPerRoute(2)
            // 最大连接数
            .maxTotalConnection(maxTotalConn)
            .connTimeout(timeOut)
            .readTimeout(timeOut)
            // 所有route连接总数
            .defaultMaxTotalConnectionPerRoute(defaultMaxTotalConnPerRoute)
            // ES 没有设置密码，而连接中加入了密码也不会影响使用
            .defaultCredentials(username, password)
            .gson(new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create())
            .build();
      clientFactory.setHttpClientConfig(config);
      return clientFactory.getObject();
   }
}

ES 整合 Jest 客户端

推荐阅读