<?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.zoujc.boot</groupId>
    <artifactId>springboot</artifactId>
    <version>0.0.1</version>
    <packaging>jar</packaging>

    <name>springboot</name>
    <description>Demo project for Spring Boot</description>

    <parent>
 

        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
 

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <elasticsearch>5.5.2</elasticsearch>
    </properties>

    <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.elasticsearch.client</groupId>
            <artifactId>transport</artifactId>
            <version>${elasticsearch.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>2.7</version>
        </dependency>
    </dependencies>

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


</project>

MyConf類

package com.zoujc.boot.springboot;

import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.InetSocketTransportAddress;
import org.elasticsearch.transport.client.PreBuiltTransportClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.net.InetAddress;

@Configuration
public class MyConfig {

   @Bean
   public TransportClient client() throws Exception{

      InetSocketTransportAddress node = new InetSocketTransportAddress(
            InetAddress.getByName("localhost"),
            9300
      );

      Settings settings = Settings.builder()
            .put("cluster.name","zoujc")
            .build();

      TransportClient client = new PreBuiltTransportClient(settings);
      client.addTransportAddress(node);
      //client.addTransportAddress(node2);  //放多個節點

      return client;
   }
}

SpringbootApplication類

package com.zoujc.boot.springboot;

import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequestBuilder;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.search.SearchType;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentFactory;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.RangeQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;

@SpringBootApplication
@RestController
public class SpringbootApplication {

   @Autowired
   private TransportClient client;

   @GetMapping("/")
   public String index(){
      return "index";
   }

   @GetMapping("/get/book/novel")
   @ResponseBody
   public ResponseEntity get(@RequestParam(name = "id",defaultValue = "") String id){

      if(id.isEmpty()){
         return new ResponseEntity(HttpStatus.NOT_FOUND);
      }
      GetResponse result = this.client.prepareGet("book","novel",id)
            .get();

      if(result.isExists()){
         return new ResponseEntity(HttpStatus.NOT_FOUND);
      }
      return new ResponseEntity(result.getSource(), HttpStatus.OK);
   }

   @PostMapping("/add/book/novel")
   @ResponseBody
   public ResponseEntity add(
         @RequestParam(name = "title") String title,
         @RequestParam(name = "author") String author,
         @RequestParam(name = "word_count") int wordCount,
         @RequestParam(name = "publish_date")
               @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
               Date publishDate){

      try {
         XContentBuilder content = XContentFactory.jsonBuilder()
               .startObject()
               .field("title",title)
               .field("author",author)
               .field("word_count",wordCount)
               .field("publish_date",publishDate)
               .endObject();

         IndexResponse result = this.client.prepareIndex("book","novel")
               .setSource(content)
               .get();
         return new ResponseEntity(result.getId(),HttpStatus.OK);

      } catch (IOException e) {
         e.printStackTrace();
         return new ResponseEntity(HttpStatus.INTERNAL_SERVER_ERROR);
      }
   }

   @DeleteMapping("/delete/book/novel")
   @ResponseBody
   public ResponseEntity delete(@RequestParam(name = "id") String id){
      DeleteResponse result = this.client.prepareDelete("book","novle",id).get();

      return new ResponseEntity(result.getResult().toString(),HttpStatus.OK);
   }

   @PutMapping("/update/book/novel")
   @ResponseBody
   public ResponseEntity update(
         @RequestParam(name = "id") String id,
         @RequestParam(name = "title", required = false) String title,
         @RequestParam(name = "author", required = false) String author){

      UpdateRequest update = new UpdateRequest("book","novel",id);

      try {
         XContentBuilder builder = XContentFactory.jsonBuilder()
               .startObject();

         if(title != null){
            builder.field("title",title);
         }

         if(author != null){
            builder.field("author", author);
         }

         builder.endObject();

         update.doc(builder);
      } catch (IOException e) {
         e.printStackTrace();
         return new ResponseEntity(HttpStatus.INTERNAL_SERVER_ERROR);
      }

      try {
         UpdateResponse result = this.client.update(update).get();
         return new ResponseEntity(result.getResult().toString(),HttpStatus.OK);
      } catch (InterruptedException e) {
         e.printStackTrace();
         return new ResponseEntity(HttpStatus.INTERNAL_SERVER_ERROR);
      } catch (ExecutionException e) {
         e.printStackTrace();
         return new ResponseEntity(HttpStatus.INTERNAL_SERVER_ERROR);
      }
   }

   @PostMapping("/query/book/novel")
   @ResponseBody
   public ResponseEntity query(
         @RequestParam(name = "author", required = false) String author,
         @RequestParam(name = "title", required = false) String title,
         @RequestParam(name = "gt_word_count", defaultValue = "0") int gtWordCount,
         @RequestParam(name = "lt_word_count", required = false) Integer ltWordCount){

      BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();

      if(author != null){
         boolQuery.must(QueryBuilders.matchQuery("author",author));
      }

      if(title != null){
         boolQuery.must(QueryBuilders.matchQuery("title",title));
      }

      RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("word_count")
            .from(gtWordCount);
      if(ltWordCount != null && ltWordCount > 0){
         rangeQuery.to(ltWordCount);
      }

      boolQuery.filter(rangeQuery);

      SearchRequestBuilder builder = this.client.prepareSearch("book")
            .setTypes("novel")
            .setSearchType(SearchType.DFS_QUERY_THEN_FETCH)
            .setQuery(boolQuery)
            .setFrom(0)
            .setSize(10);

      System.out.println(builder);

      SearchResponse response = builder.get();
      List<Map<String,Object>> result = new ArrayList<>();

      for(SearchHit hit: response.getHits()){
         result.add(hit.getSource());
      }

      return new ResponseEntity(result,HttpStatus.OK);
   }

   public static void main(String[] args) {
      SpringApplication.run(SpringbootApplication.class, args);
   }
}