@RunWith(SpringRunner.class)
@SpringBootTest
public class SearchDemoApplicationTests {
	@Autowired
	private RestHighLevelClient client;
	String index = "openapi_customer";
	String type = "customer";
	@Test
	public void createIndex() throws IOException {
		//1. 准备关于索引的settings
		Settings.Builder settings = Settings.builder()
				.put("number_of_shards", 5)
				.put("number_of_replicas", 1);
		//2. 准备关于索引的结构mappings
		XContentBuilder mappings = JsonXContent.contentBuilder()
				.startObject()
				.startObject("properties")
				.startObject("id")
				.field("type", "integer")
				.endObject()
				.startObject("username")
				.field("type", "keyword")
				.endObject()
				.startObject("password")
				.field("type", "keyword")
				.endObject()
				.startObject("nickname")
				.field("type", "text")
				.endObject()
				.startObject("money")
				.field("type", "long")
				.endObject()
				.startObject("address")
				.field("type", "text")
				.endObject()
				.startObject("state")
				.field("type", "integer")
				.endObject()
				.endObject()
				.endObject();
		//3. 将settings和mappings封装到一个Request对象
		CreateIndexRequest request = new CreateIndexRequest(index)
				.settings(settings)
				.mapping(type, mappings);
		//4. 通过client对象去连接ES并执行创建索引
		CreateIndexResponse resp = client.indices().create(request, RequestOptions.DEFAULT);
		//5. 输出
		System.out.println("resp:" + resp.toString());
	}
	@Test
	public void testAddData() throws IOException {
		//1. 准备多个json数据
		Customer c1 = new Customer();
		c1.setId(1);
		c1.setUsername("haier");
		c1.setPassword("111111");
		c1.setNickname("海尔集团");
		c1.setMoney(2000000L);
		c1.setAddress("青岛");
		c1.setState(1);

		Customer c2 = new Customer();
		c2.setId(2);
		c2.setUsername("lianxiang");
		c2.setPassword("111111");
		c2.setNickname("联想");
		c2.setMoney(1000000L);
		c2.setAddress("联想");
		c2.setState(1);

		Customer c3 = new Customer();
		c3.setId(3);
		c3.setUsername("google");
		c3.setPassword("111111");
		c3.setNickname("谷歌");
		c3.setMoney(1092L);
		c3.setAddress("霉果");
		c3.setState(1);

		ObjectMapper mapper = new ObjectMapper();

		String json1 = mapper.writeValueAsString(c1);
		String json2 = mapper.writeValueAsString(c2);
		String json3 = mapper.writeValueAsString(c3);

		//2. 创建Request，将准备好的数据封装进去
		BulkRequest request = new BulkRequest();
		request.add(new IndexRequest(index, type, c1.getId().toString()).source(json1, XContentType.JSON));
		request.add(new IndexRequest(index, type, c2.getId().toString()).source(json2, XContentType.JSON));
		request.add(new IndexRequest(index, type, c3.getId().toString()).source(json3, XContentType.JSON));
		//3. 用client执行
		BulkResponse resp = client.bulk(request, RequestOptions.DEFAULT);
		//4. 输出结果
		System.out.println(resp.toString());
	}
}

8.2：客户模块配置

• Customer工程的pom文件中导入durid连接池

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.22</version>
</dependency>

server:
  port: 80
  
#连接数据库的配置
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql:///openapi_2001
    username: root
    password: 123
    type: com.alibaba.druid.pool.DruidDataSource

#mybatis的配置
mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.qf.open.customer_demo.entity
  configuration:
    map-underscore-to-camel-case: true

<dependency>
    <groupId>commons-beanutils</groupId>
    <artifactId>commons-beanutils</artifactId>
    <version>1.9.3</version>
</dependency>

public interface SearchService {
    String searchByCondition(Map<String,Object> map);
}

@Service
public class SearchServiceImpl implements SearchService{
    @Autowired
    private RestHighLevelClient client;
    private String index = "openapi_customer";
    private String type = "customer";
    @Override
    public String searchByCondition(Map<String, Object> map) {
        //创建request对象
        SearchRequest request = new SearchRequest(index);
        request.types(type);
        //构建查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.sort("id", SortOrder.ASC);
        Object name = map.get("name");
        Object state = map.get("state");
        if(!StringUtils.isEmpty(name)){
            builder.query(QueryBuilders.termQuery("username",name));
        }
        if(state!=null){
             builder.query(QueryBuilders.termQuery("state",state));
        }
        Integer page = Integer.parseInt(map.get("page").toString());
        Integer limit = Integer.parseInt(map.get("limit").toString());
        builder.from((page-1)*limit);
        builder.size(limit);
        request.source(builder);
        try {
            //执行查询
            SearchResponse searchResponse = client.search(request, RequestOptions.DEFAULT);
            TableDataVo<Customer> dataVo = new TableDataVo<>();
            List<Customer> data = new ArrayList<>();
            //设置总条数
            dataVo.setCount(searchResponse.getHits().getTotalHits());
            for (SearchHit hit : searchResponse.getHits().getHits()) {
                Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                Customer customer = new Customer();
                BeanUtils.populate(customer,sourceAsMap);
                data.add(customer);
            }
            //给vo对象中的集合赋值
           dataVo.setData(data);
            //把集合转成json数据,并返回
            return JSON.toJson(dataVo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        //返回结果
        return null;
    }
}

public class JSON {
    public static String toJson(Object value){
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            return objectMapper.writeValueAsString(value);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
            return "";
        }
    }
}

@Data
public class TableDataVo<T> {
    private Integer code = 0;
    private String msg = "";
    private Long count;
    private List<T> data;
}

@RestController
@RequestMapping("/search/customer")
public class SearchController {
    @Autowired
    private SearchService searchService;
    @PostMapping(value = "/table",produces = "application/json;charset=utf-8")
    public String table(@RequestBody Map<String,Object> map){
        //调用方法
        String json = searchService.searchByCondition(map);
        //返回结果
        return json;
    }
}

{
    "page":1,
    "limit":10,
    "name":"google"
}

{
    "code": 0,
    "msg": "",
    "count": 1,
    "data": [
        {
            "id": 3,
            "username": "google",
            "password": "111111",
            "nickname": "谷歌",
            "money": 1092,
            "address": "没过",
            "state": 1
        }
    ]
}

public interface CustomerService {
    String findByCondition(Map<String,Object> map);
}

@Service
public class CustomerServiceImpl implements CustomerService {
    @Autowired
    private RestTemplate restTemplate;
    @Override
    public String findByCondition(Map<String, Object> map) {
        //准备请求参数和请求头
        String json = JSON.toJson(map);
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setContentType(MediaType.parseMediaType("application/json;charset=utf-8"));
        //组合 json和httpHeaders
        HttpEntity entity = new HttpEntity(json,httpHeaders);
        //通过restTemplate调用search模块
        String result = restTemplate.postForObject("http://localhost:8080/sys/customer/table", entity, String.class);
        return result;
    }
}

@Configuration
public class RestTemplateConfig {
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

@RunWith(SpringRunner.class)
@SpringBootTest
public class CustomerServiceTest {
    @Autowired
    private CustomerService customerService;
    @Test
    public void findByCondition() throws Exception {
        Map<String, Object> map = new HashMap<>();
        map.put("page",1);
        map.put("limit",10);
        map.put("name","haier");
        String s = customerService.findByCondition(map);
        System.out.println(s);
    }
}