Elasticsearch的Java HTTP Rest客户端。

1、是什么

它是Elasticsearch的Java HTTP Rest客户端。

2、实例

（1）User.java

 public class User {

     @JestId
     private Integer id;
     private String name;
     private Date birth;
     public Integer getId() {
         return id;
     }
     public void setId(Integer id) {
         this.id = id;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public Date getBirth() {
         return birth;
     }
     public void setBirth(Date birth) {
         this.birth = birth;
     }
     public User() {
         super();
         // TODO Auto-generated constructor stub
     }
     public User(Integer id, String name, Date birth) {
         super();
         this.id = id;
         this.name = name;
         this.birth = birth;
     }
     @Override
     public String toString() {
         return "User [id=" + id + ", name=" + name + ", birth=" + birth + "]";
     }
 }

（2）JestService.java

 public class JestService {

     /**
      * 获取JestClient对象
      * @return
      */
     public JestClient getJestClient() {

         JestClientFactory factory = new JestClientFactory();
         factory.setHttpClientConfig(new HttpClientConfig
                                .Builder("http://localhost:9200")
                                .gson(new GsonBuilder().setDateFormat("yyyy-MM-dd'T'hh:mm:ss").create())
                                .connTimeout(1500)
                                .readTimeout(3000)
                                .multiThreaded(true)
                                .build());
         return factory.getObject();
         }

     /**
      * 创建索引
      * @param jestClient
      * @param indexName
      * @return
      * @throws Exception
      */
     public boolean createIndex(JestClient jestClient, String indexName) throws Exception {

         JestResult jr = jestClient.execute(new CreateIndex.Builder(indexName).build());
         return jr.isSucceeded();
     }

     /**
      * Put映射
      * @param jestClient
      * @param indexName
      * @param typeName
      * @param source
      * @return
      * @throws Exception
      */
     public boolean createIndexMapping(JestClient jestClient, String indexName, String typeName, String source) throws Exception {

         PutMapping putMapping = new PutMapping.Builder(indexName, typeName, source).build();
         JestResult jr = jestClient.execute(putMapping);
         return jr.isSucceeded();
         }

     /**
      * Get映射
      * @param jestClient
      * @param indexName
      * @param typeName
      * @return
      * @throws Exception
      */
     public String getIndexMapping(JestClient jestClient, String indexName, String typeName) throws Exception {

         GetMapping getMapping = new GetMapping.Builder().addIndex(indexName).addType(typeName).build();
         JestResult jr = jestClient.execute(getMapping);
         return jr.getJsonString();
         }

     /**
      * 索引文档
      * @param jestClient
      * @param indexName
      * @param typeName
      * @param objs
      * @return
      * @throws Exception
      */
     public boolean index(JestClient jestClient, String indexName, String typeName, List<Object> objs) throws Exception {

         Bulk.Builder bulk = new Bulk.Builder().defaultIndex(indexName).defaultType(typeName);
         for (Object obj : objs) {
           Index index = new Index.Builder(obj).build();
           bulk.addAction(index);
         }
         BulkResult br = jestClient.execute(bulk.build());
         return br.isSucceeded();
         }

     /**
      * 搜索文档
      * @param jestClient
      * @param indexName
      * @param typeName
      * @param query
      * @return
      * @throws Exception
      */
     public SearchResult search(JestClient jestClient, String indexName, String typeName, String query) throws Exception {

         Search search = new Search.Builder(query)
             .addIndex(indexName)
             .addType(typeName)
             .build();
         return jestClient.execute(search);
         }

     /**
      * Count文档
      * @param jestClient
      * @param indexName
      * @param typeName
      * @param query
      * @return
      * @throws Exception
      */
     public Double count(JestClient jestClient, String indexName, String typeName, String query) throws Exception {

         Count count = new Count.Builder()
             .addIndex(indexName)
             .addType(typeName)
             .query(query)
             .build();
         CountResult results = jestClient.execute(count);
         return results.getCount();
     }

     /**
      * Get文档
      * @param jestClient
      * @param indexName
      * @param typeName
      * @param id
      * @return
      * @throws Exception
      */
     public JestResult get(JestClient jestClient, String indexName, String typeName, String id) throws Exception {

         Get get = new Get.Builder(indexName, id).type(typeName).build();
         return jestClient.execute(get);
     }

     /**
      * Delete索引
      * @param jestClient
      * @param indexName
      * @return
      * @throws Exception
      */
     public boolean delete(JestClient jestClient, String indexName) throws Exception {

         JestResult jr = jestClient.execute(new DeleteIndex.Builder(indexName).build());
         return jr.isSucceeded();
     }

     /**
      * Delete文档
      * @param jestClient
      * @param indexName
      * @param typeName
      * @param id
      * @return
      * @throws Exception
      */
     public boolean delete(JestClient jestClient, String indexName, String typeName, String id) throws Exception {

         DocumentResult dr = jestClient.execute(new Delete.Builder(id).index(indexName).type(typeName).build());
         return dr.isSucceeded();
     }

     /**
      * 关闭JestClient客户端
      * @param jestClient
      * @throws Exception
      */
     public void closeJestClient(JestClient jestClient) throws Exception {

         if (jestClient != null) {
           jestClient.shutdownClient();
         }
         }
 }

（3）UserTest.java

 public class UserTest {

     private JestService jestService;
         private JestClient jestClient;
         private String indexName = "hwd";
         private String typeName = "user";

     @Before
     public void setUp() throws Exception {

         jestService = new JestService();
         jestClient = jestService.getJestClient();
     }

     @After
     public void tearDown() throws Exception {

         jestService.closeJestClient(jestClient);
     }

     @Test
         public void createIndex() throws Exception {

         boolean result = jestService.createIndex(jestClient, indexName);
         System.out.println(result);
         }

     @Test
         public void createIndexMapping() throws Exception {

         String source = "{\"" + typeName + "\":{\"properties\":{"
                         + "\"id\":{\"type\":\"integer\"}"
                         + ",\"name\":{\"type\":\"string\",\"index\":\"not_analyzed\"}"
                         + ",\"birth\":{\"type\":\"date\",\"format\":\"strict_date_optional_time||epoch_millis\"}"
                         + "}}}";
             System.out.println(source);
             boolean result = jestService.createIndexMapping(jestClient, indexName, typeName, source);
             System.out.println(result);
         }

     @Test
     public void getIndexMapping() throws Exception {

         String result = jestService.getIndexMapping(jestClient, indexName, typeName);
         System.out.println(result);
     }

     @Test
     public void index() throws Exception {

         List<Object> objs = new ArrayList<Object>();
         objs.add(new User(1, "T:o\"m-", new Date()));
         objs.add(new User(2, "J,e{r}r;y:", new Date()));
         boolean result = jestService.index(jestClient, indexName, typeName, objs);
         System.out.println(result);
     }

     @Test
     public void termQuery() throws Exception {

         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
         QueryBuilder queryBuilder = QueryBuilders
             .termQuery("name", "T:o\"m-");//单值完全匹配查询
         searchSourceBuilder.query(queryBuilder);
         searchSourceBuilder.size(10);
         searchSourceBuilder.from(0);
         String query = searchSourceBuilder.toString();
         System.out.println(query);
         SearchResult result = jestService.search(jestClient, indexName, typeName, query);
         List<Hit<User, Void>> hits = result.getHits(User.class);
         System.out.println("Size:" + hits.size());
         for (Hit<User, Void> hit : hits) {
           User user = hit.source;
           System.out.println(user.toString());
         }
     }

     @Test
     public void termsQuery() throws Exception {

         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
         QueryBuilder queryBuilder = QueryBuilders
             .termsQuery("name", new String[]{ "T:o\"m-", "J,e{r}r;y:" });//多值完全匹配查询
         searchSourceBuilder.query(queryBuilder);
         searchSourceBuilder.size(10);
         searchSourceBuilder.from(0);
         String query = searchSourceBuilder.toString();
         System.out.println(query);
         SearchResult result = jestService.search(jestClient, indexName, typeName, query);
         List<Hit<User, Void>> hits = result.getHits(User.class);
         System.out.println("Size:" + hits.size());
         for (Hit<User, Void> hit : hits) {
           User user = hit.source;
           System.out.println(user.toString());
         }
     }

     @Test
     public void wildcardQuery() throws Exception {

         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
         QueryBuilder queryBuilder = QueryBuilders
             .wildcardQuery("name", "*:*");//通配符和正则表达式查询
         searchSourceBuilder.query(queryBuilder);
         searchSourceBuilder.size(10);
         searchSourceBuilder.from(0);
         String query = searchSourceBuilder.toString();
         System.out.println(query);
         SearchResult result = jestService.search(jestClient, indexName, typeName, query);
         List<Hit<User, Void>> hits = result.getHits(User.class);
         System.out.println("Size:" + hits.size());
         for (Hit<User, Void> hit : hits) {
           User user = hit.source;
           System.out.println(user.toString());
         }
     }

     @Test
     public void prefixQuery() throws Exception {

         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
         QueryBuilder queryBuilder = QueryBuilders
             .prefixQuery("name", "T:o");//前缀查询
         searchSourceBuilder.query(queryBuilder);
         searchSourceBuilder.size(10);
         searchSourceBuilder.from(0);
         String query = searchSourceBuilder.toString();
         System.out.println(query);
         SearchResult result = jestService.search(jestClient, indexName, typeName, query);
         List<Hit<User, Void>> hits = result.getHits(User.class);
         System.out.println("Size:" + hits.size());
         for (Hit<User, Void> hit : hits) {
           User user = hit.source;
           System.out.println(user.toString());
         }
     }

     @Test
     public void rangeQuery() throws Exception {

         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
         QueryBuilder queryBuilder = QueryBuilders
             .rangeQuery("birth")
             .gte("2016-09-01T00:00:00")
             .lte("2016-10-01T00:00:00")
             .includeLower(true)
             .includeUpper(true);//区间查询
         searchSourceBuilder.query(queryBuilder);
         searchSourceBuilder.size(10);
         searchSourceBuilder.from(0);
         String query = searchSourceBuilder.toString();
         System.out.println(query);
         SearchResult result = jestService.search(jestClient, indexName, typeName, query);
         List<Hit<User, Void>> hits = result.getHits(User.class);
         System.out.println("Size:" + hits.size());
         for (Hit<User, Void> hit : hits) {
           User user = hit.source;
           System.out.println(user.toString());
         }
     }

     @Test
     public void queryString() throws Exception {

         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
         QueryBuilder queryBuilder = QueryBuilders
             .queryString(QueryParser.escape("T:o\""));//文本检索，应该是将查询的词先分成词库中存在的词，然后分别去检索，存在任一存在的词即返回，查询词分词后是OR的关系。需要转义特殊字符
         searchSourceBuilder.query(queryBuilder);
         searchSourceBuilder.size(10);
         searchSourceBuilder.from(0);
         String query = searchSourceBuilder.toString();
         System.out.println(query);
         SearchResult result = jestService.search(jestClient, indexName, typeName, query);
         List<Hit<User, Void>> hits = result.getHits(User.class);
         System.out.println("Size:" + hits.size());
         for (Hit<User, Void> hit : hits) {
           User user = hit.source;
           System.out.println(user.toString());
         }
     }

     @Test
     public void count() throws Exception {

         String[] name = new String[]{ "T:o\"m-", "Jerry" };
         String from = "2016-09-01T00:00:00";
         String to = "2016-10-01T00:00:00";
         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
         QueryBuilder queryBuilder = QueryBuilders.boolQuery()
             .must(QueryBuilders.termsQuery("name", name))
             .must(QueryBuilders.rangeQuery("birth").gte(from).lte(to));
         searchSourceBuilder.query(queryBuilder);
         String query = searchSourceBuilder.toString();
         System.out.println(query);
         Double count = jestService.count(jestClient, indexName, typeName, query);
         System.out.println("Count:" + count);
     }

     @Test
     public void get() throws Exception {

         String id = "2";
         JestResult result = jestService.get(jestClient, indexName, typeName, id);
         if (result.isSucceeded()) {
           User user = result.getSourceAsObject(User.class);
           System.out.println(user.toString());
         }
     }

     @Test
     public void deleteIndexDocument() throws Exception {

         String id = "2";
         boolean result = jestService.delete(jestClient, indexName, typeName, id);
         System.out.println(result);
     }

     @Test
     public void deleteIndex() throws Exception {

         boolean result = jestService.delete(jestClient, indexName);
         System.out.println(result);
     }
 }