Elasticsearch
一、Elasticsearch简介
1.什么是Elasticsearch
2.Elasticsearch的使用案例
二、Elasticsearch安装与启动
1.下载ES压缩包
2.安装ES服务
3.启动ES服务
4.安装ES的图形化界面插件
三、Elasticsearch核心概念
1.索引
2.类型
3.字段
字段Field，相当于数据表字段，对不同属性进行分类标识
4.映射
5.文档
四、Elasticsearch的操作
1.安装Postman工具
2.下载Postman工具
3.注册Postman工具
4.使用Postman工具进行RESTful接口访问
Elasticsearch的RESTful接口
创建索引
创建索引时配置映射
创建索引后配置映射
删除索引
创建文档
修改文档
删除文档
根据id查询
querystring查询
term查询
五、IK 分词器和Elasticsearch集成使用
1.上述查询存在问题分析
2.IK分词器简介
3.Elasticsearch集成IK分词器
IK分词器的安装
IK分词器测试
4.修改索引映射mapping
重建索引
再次测试queryString查询
再次测试term测试
六、Elasticsearch集群
1.集群的相关概念
集群 cluster
节点 node
分片和复制 shards&replicas
2.集群的搭建
准备三台Elasticsearch服务器
创建Elasticsearch-cluster文件夹，在内部复制三个Elasticsearch服务
修改每台服务器配置
启动各个节点服务器
集群测试
七、ElasticSearch Java客户端
1.客户端开发环境搭建
2.创建索引index
3.配置索引映射mapping
/**
* 目标:创建索引的type的映射
* 1.获取客户端
* 2.创建mapping请求对象:需要设置index,type,请求体
* 3.创建JSON请求体:参考第一天的设置Mapping的JSON数据
* 4.请求对象执行发送请求操作,请求完成会获取响应对象
* 5.关闭客户端
*/
@Test
public void createMapping() throws IOException, ExecutionException,
InterruptedException {
//配置集群名称，注意采用的事情TCP接口调用
Settings settings = Settings.builder().put("cluster.name",
"elasticsearch").build();
//配置请求地址和端口
InetSocketTransportAddress address = new
InetSocketTransportAddress(InetAddress.getByName("127.0.0.1"), 9300);
PreBuiltTransportClient client = new PreBuiltTransportClient(settings);
client.addTransportAddress(address);
//* 1.获取客户端
//* 2.创建mapping请求对象:需要设置index,type,请求体
PutMappingRequestBuilder request =
client.admin().indices().preparePutMapping("blog3");
request.setType("article");//设置type
//* 3.创建JSON请求体:参考第一天的设置Mapping的JSON数据
XContentBuilder jsonBuilder = XContentFactory.jsonBuilder();
jsonBuilder.startObject()
.startObject("article")
.startObject("properties")
.startObject("id").field("type","long").field("store","yes").field("index","not_
analyzed")
.endObject()
.startObject("title").field("type","string").field("store","yes").field("index",
"analyzed").field("analyzer","ik_smart")
.endObject()
.startObject("content").field("type","string").field("store","yes").field("index
","analyzed").field("analyzer","ik_smart")
.endObject()
.endObject()
.endObject()
.endObject();
request.setSource(jsonBuilder);//设置请求体
//* 4.请求对象执行发送请求操作,请求完成会获取响应对象
PutMappingResponse response = request.get();
System.out.println(response.toString());
//* 5.关闭客户端
client.close();
}
4.建立文档document
创建文档（通过XContentBuilder）
/**
* 目标:创建文档
* 1.获取客户端
* 2.创建索引设置文档请求对象:需要设置index,type,id,请求体
* 3.创建JSON请求体:参考第一天的设置创建文档的JSON数据
* 4.请求对象执行发送请求操作,请求完成会获取响应对象
* 5.关闭客户端
*/
@Test
public void createDocument() throws IOException {
//* 1.获取客户端：设置集群名称，设置请求地址和端口TCP的
Settings settings = Settings.builder().put("cluster.name",
"elasticsearch").build();
InetSocketTransportAddress address = new
InetSocketTransportAddress(InetAddress.getByName("127.0.0.1"), 9300);
PreBuiltTransportClient client = new PreBuiltTransportClient(settings);
client.addTransportAddress(address);
//* 3.创建JSON请求体:参考第一天的设置创建文档的JSON数据
XContentBuilder jsonBuilder = XContentFactory.jsonBuilder();
jsonBuilder.startObject()
.field("id","1")
.field("title","ELasticSearch是一个基于Lucene的搜索服务器")
.field("content","content它提供了一个分布式多用户能力的全文搜索引擎，基于
RESTful web接口。Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当
前流行的企业级搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。")
.endObject();
//* 2.创建索引设置文档请求对象:需要设置index,type,id,请求体
IndexRequestBuilder requestBuilder = client.prepareIndex("blog3", "article",
"1");
requestBuilder.setSource(jsonBuilder);
//* 4.请求对象执行发送请求操作,请求完成会获取响应对象
IndexResponse indexResponse = requestBuilder.get();
System.out.println(indexResponse.toString());
//* 5.关闭客户端
client.close();
}
创建文档（使用Jackson转换实体）
5.查询文档操作
关键词查询
/**
* 目标:term关键词的查询
* 1.获取客户端
* 2.创建搜索请求对象:需要设置index,type,查询对象
* 3.创建Term查询对象,设置查询字段,和关键词
* 4.请求对象执行发送请求操作,请求完成会获取响应对象
* 5.响应对象中获取命中数据,循环遍历输出
* 6.关闭客户端
*/
@Test
public void testTermQuery() throws UnknownHostException {
//* 1.获取客户端
PreBuiltTransportClient client = TransPortClientUtil.getClient();
//* 2.创建搜索请求对象:需要设置index,type,查询对象
SearchRequestBuilder searchRequestBuilder = client.prepareSearch("blog3");
//* 3.创建Term查询对象,设置查询字段,和关键词
searchRequestBuilder.setQuery(QueryBuilders.termQuery("title","搜索"));
//* 4.请求对象执行发送请求操作,请求完成会获取响应对象
SearchResponse searchResponse = searchRequestBuilder.get();
//* 5.响应对象中获取命中数据,循环遍历输出
SearchHits hits = searchResponse.getHits();
for (SearchHit hit : hits) {
System.out.println(hit.getSourceAsString());
System.out.println(hit.getSource().get("id"));
System.out.println(hit.getSource().get("title"));
System.out.println(hit.getSource().get("content"));
}
//* 6.关闭客户端
client.close();
}
字符串查询
/**
* 目标:查询,带分词器的字符串查询
* 1.获取客户端
* 2.创建搜索请求对象:需要设置index,type,查询对象
* 3.创建Query_string查询对象,传入查询字符串
* 4.请求对象执行发送请求操作,请求完成会获取响应对象
* 5.响应对象中获取命中数据,循环遍历输出
* 6.关闭客户端
*/
@Test
public void testStringQuery() throws UnknownHostException {
//1.获取客户端
PreBuiltTransportClient client = TransPortClientUtil.getClient();
//2.创建搜索请求对象:需要设置index,type,查询对象
SearchRequestBuilder searchRequestBuilder = client.prepareSearch("blog2");
searchRequestBuilder.setTypes("article");
//3.创建Query_string查询对象,传入查询字符串
searchRequestBuilder.setQuery(QueryBuilders.queryStringQuery("搜索"));
//4.请求对象执行发送请求操作,请求完成会获取响应对象
SearchResponse searchResponse = searchRequestBuilder.get();//发送请求获取响应
//5.响应对象中获取命中数据,循环遍历输出
SearchHits hits = searchResponse.getHits();
System.out.println("搜索结果有:[" + hits.getTotalHits() + "]条");
Iterator<SearchHit> iterator = hits.iterator();
while (iterator.hasNext()){
SearchHit next = iterator.next();
System.out.println("ID:"+next.getSource().get("id"));
System.out.println("title:"+next.getSource().get("title"));
System.out.println("content:"+next.getSource().get("content"));
}
//6.关闭客户端
client.close();
}
使用文档ID查询文档
/**
* 目标:查询,使用ID查询
* 1.获取客户端
* 2.创建搜索请求对象:需要设置index,type,查询对象
* 3.创建idsQuery查询对象,填入id
* 4.请求对象执行发送请求操作,请求完成会获取响应对象
* 5.响应对象中获取命中数据,循环遍历输出
* 6.关闭客户端
*/
@Test
public void findById() throws UnknownHostException {
//1.获取客户端
PreBuiltTransportClient client = TransPortClientUtil.getClient();
//2.创建搜索请求对象:需要设置index,type,查询对象
SearchRequestBuilder searchRequestBuilder = client.prepareSearch("blog1");
searchRequestBuilder.setTypes("article");
//3.创建idsQuery查询对象,填入id
searchRequestBuilder.setQuery(QueryBuilders.idsQuery().addIds("1"));
//4.请求对象执行发送请求操作,请求完成会获取响应对象
SearchResponse searchResponse = searchRequestBuilder.get();
//5.响应对象中获取命中数据,循环遍历输出
SearchHits hits = searchResponse.getHits();
System.out.println("搜索结果有:[" + hits.getTotalHits() + "]条");
Iterator<SearchHit> iterator = hits.iterator();
while (iterator.hasNext()){
SearchHit next = iterator.next();
System.out.println("ID:"+next.getSource().get("id"));
System.out.println("title:"+next.getSource().get("title"));
System.out.println("content:"+next.getSource().get("content"));
}
//6.关闭客户端
client.close();
}
6.查询文档分页操作
批量插入数据
/**
* 分页查询的准备:批量插入100条数据
* 1.获取客户端
* 循环100次2,3,4的操作:
* 2.创建索引新增文档请求对象:需要设置index,type,id,请求体
* 3.创建JSON请求体:参考第一天的设置创建文档的JSON数据
* 4.请求对象执行发送请求操作,请求完成会获取响应对象
* 5.关闭客户端
*/
@Test
public void testSaveList() throws UnknownHostException, JsonProcessingException
{
//1.获取客户端
PreBuiltTransportClient client = TransPortClientUtil.getClient();
ObjectMapper objectMapper = new ObjectMapper();
//循环100次2,3,4的操作:
for (int i = 0; i < 100; i++) {
//3.创建JSON请求体:参考第一天的设置创建文档的JSON数据
Article article = new Article();
article.setId(i);
article.setTitle("["+i+"] 搜索工作其实很快乐");
article.setContent("["+i+"] 我们希望我们的搜索解决方案要快，我们希望有一个零配置
和一个完全免费的搜索模式，我们希望能够简单地使用JSON通过HTTP的索引数据，我们希望我们的搜索服务
器始终可用，我们希望能够一台开始并扩展到数百，我们要实时搜索，我们要简单的多租户，我们希望建立一
个云的解决方案。Elasticsearch旨在解决所有这些问题和更多的问题。");
//对象转换为JSON数据
String jsonArticle = objectMapper.writeValueAsString(article);
//2.创建索引新增文档请求对象:需要设置index,type,id,请求体
IndexRequestBuilder indexRequestBuilder = client.prepareIndex("blog2",
"article", "" + i);
indexRequestBuilder.setSource(jsonArticle, XContentType.JSON);//设置请求体
//4.请求对象执行发送请求操作,请求完成会获取响应对象
IndexResponse indexResponse = indexRequestBuilder.get();
System.out.println(jsonArticle);
System.out.println(indexResponse.toString());
}
//5.关闭客户端
client.close();
}
分页查询
/**
* 目标:查询,分页查询
* 1.获取客户端
* 2.创建搜索请求对象:需要设置index,type,查询对象
* 3.创建查询所有记录对象,并设置分页信息:form表示起始页,size表示每页多少条
* 4.请求对象执行发送请求操作,请求完成会获取响应对象
* 5.响应对象中获取命中数据,循环遍历输出
* 6.关闭客户端
*/
@Test
public void findByPageable() throws UnknownHostException {
//1.获取客户端
PreBuiltTransportClient client = TransPortClientUtil.getClient();
//2.创建搜索请求对象:需要设置index,type,查询对象
SearchRequestBuilder searchRequestBuilder = client.prepareSearch("blog2");
searchRequestBuilder.setTypes("article");
//3.创建查询所有记录对象,并设置分页信息:form表示起始页,size表示每页多少条
searchRequestBuilder.setQuery(QueryBuilders.matchAllQuery());//默认每页10条
searchRequestBuilder.setFrom(0);//form表示起始页
searchRequestBuilder.setSize(20);//size表示每页多少条
//4.请求对象执行发送请求操作,请求完成会获取响应对象
SearchResponse searchResponse = searchRequestBuilder.get();
//5.响应对象中获取命中数据,循环遍历输出
SearchHits hits = searchResponse.getHits();
System.out.println("搜索结果有:[" + hits.getTotalHits() + "]条");
System.out.println("当前页有:[" + hits.getHits().length + "]条");
Iterator<SearchHit> iterator = hits.iterator();
while (iterator.hasNext()){
SearchHit next = iterator.next();
System.out.println("ID:"+next.getSource().get("id"));
System.out.println("title:"+next.getSource().get("title"));
System.out.println("content:"+next.getSource().get("content"));
}
//6.关闭客户端
client.close();
}
7.查询结果高亮操作
什么是高亮显示
高亮显示的html分析
高亮显示代码实现
/**
* 目标:搜索结果高亮
* 1.获取客户端
* 2.创建搜索请求对象:需要设置index,type,查询对象
* 3.创建Term查询对象,设置查询字段,和关键词
* 3.1 查询对象设置数据高亮配置:配置高亮标签font,配置高亮字段title
* 4.请求对象执行发送请求操作,请求完成会获取响应对象
* 5.响应对象中获取命中数据,循环遍历输出
* 6.关闭客户端
*/
@Test
public void testHighLight() throws UnknownHostException {
//1.获取客户端
PreBuiltTransportClient client = TransPortClientUtil.getClient();
//2.创建搜索请求对象:需要设置index,type,查询对象
SearchRequestBuilder searchRequestBuilder = client.prepareSearch("blog2");
searchRequestBuilder.setTypes("article");
//3.创建Term查询对象,设置查询字段,和关键词
searchRequestBuilder.setQuery(QueryBuilders.termQuery("title","搜索"));//默认
每页10条
//3.1 查询对象设置数据高亮配置
HighlightBuilder highlightBuilder = new HighlightBuilder();
highlightBuilder.preTags("<font style='color:red'>");
highlightBuilder.postTags("</font>");
highlightBuilder.field("title");
searchRequestBuilder.highlighter(highlightBuilder);
//4.请求对象执行发送请求操作,请求完成会获取响应对象
SearchResponse searchResponse = searchRequestBuilder.get();
//5.响应对象中获取命中数据,循环遍历输出
SearchHits hits = searchResponse.getHits();
System.out.println("共搜索到:[" + hits.getTotalHits() + "]条结果");
for (SearchHit hit : hits) {
System.out.println("String方式打印高亮内容:");
System.out.println(hit.getSourceAsString());
System.out.println("Map方式打印高亮内容:");
System.out.println(hit.getHighlightFields());
Map<String, HighlightField> highlightFieldMap =
hit.getHighlightFields();
Text[] titles = hit.getHighlightFields().get("title").fragments();
for (Text title : titles) {
System.out.println(title);
}
}
//6.关闭客户端
client.close();
}
八、Spring Data ElasticSearch 使用
1.Spring Data ElasticSearch简介
什么是Spring Data
什么是Spring Data ElasticSearch
2.Spring Data ElasticSearch环境搭建
<?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.itheima</groupId>
<artifactId>itheima_elasticsearch_demo3</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.elasticsearch</groupId>
<artifactId>elasticsearch</artifactId>
<version>5.6.8</version>
</dependency>
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>transport</artifactId>
<version>5.6.8</version>
</dependency>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-to-slf4j</artifactId>
<version>2.9.1</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.24</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
<version>1.7.21</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.12</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.8.1</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.8.1</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.8.1</version>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-elasticsearch</artifactId>
<version>3.0.5.RELEASE</version>
<exclusions>
<exclusion>
<groupId>org.elasticsearch.plugin</groupId>
<artifactId>transport-netty4-client</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.0.4.RELEASE</version>
</dependency>
</dependencies>
</project>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:elasticsearch="http://www.springframework.org/schema/data/elasticsearch"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/data/elasticsearch
http://www.springframework.org/schema/data/elasticsearch/spring-
elasticsearch-1.0.xsd">
</beans>
package com.itheima.domain;
public class Article {
private Integer id;
private String title;
private String content;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
@Override
public String toString() {
return "Article [id=" + id + ", title=" + title + ", content=" + content
+ "]";
}
}
package com.itheima.dao;
import com.itheima.domain.Article;
import
org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
@Repository
public interface ArticleRepository extends ElasticsearchRepository<Article,
Integer> {
}
package com.itheima.service;
import com.itheima.domain.Article;
public interface ArticleService {
public void save(Article article);
}
package com.itheima.service.impl;
import com.itheima.dao.ArticleRepository;
import com.itheima.domain.Article;
import com.itheima.service.ArticleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class ArticleServiceImpl implements ArticleService {
@Autowired
private ArticleRepository articleRepository;
public void save(Article article) {
articleRepository.save(article);
}
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:elasticsearch="http://www.springframework.org/schema/data/elasticsearch"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/data/elasticsearch
http://www.springframework.org/schema/data/elasticsearch/spring-
elasticsearch-1.0.xsd
">
<!-- 扫描Dao包，自动创建实例 -->
<elasticsearch:repositories base-package="com.itheima.dao"/>
<!-- 扫描Service包，创建Service的实体 -->
<context:component-scan base-package="com.itheima.service"/>
<!-- 配置elasticSearch的连接 -->
<!-- 配置elasticSearch的连接 -->
<elasticsearch:transport-client id="client" cluster-nodes="localhost:9300"
cluster-name="elasticsearch"/>
<!-- ElasticSearch模版对象 -->
<bean id="elasticsearchTemplate"
class="org.springframework.data.elasticsearch.core.ElasticsearchTemplate">
<constructor-arg name="client" ref="client"></constructor-arg>
</bean>
</beans>
package com.itheima.domain;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;
//@Document 文档对象 （索引信息、文档类型 ）
@Document(indexName="blog3",type="article")
public class Article {
//@Id 文档主键 唯一标识
@Id
//@Field 每个文档的字段配置（类型、是否分词、是否存储、分词器 ）
@Field(store=true, index = false,type = FieldType.Integer)
private Integer id;
@Field(index=true,analyzer="ik_smart",store=true,searchAnalyzer="ik_smart",type
= FieldType.text)
private String title;
@Field(index=true,analyzer="ik_smart",store=true,searchAnalyzer="ik_smart",type
= FieldType.text)
private String content;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
@Override
public String toString() {
return "Article [id=" + id + ", title=" + title + ", content=" + content
+ "]";
}
}
package com.itheima.test;
import com.itheima.domain.Article;
import com.itheima.service.ArticleService;
import org.elasticsearch.client.transport.TransportClient;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:applicationContext.xml")
public class SpringDataESTest {
@Autowired
private ArticleService articleService;
@Autowired
private TransportClient client;
@Autowired
private ElasticsearchTemplate elasticsearchTemplate;
/**创建索引和映射*/
@Test
public void createIndex(){
elasticsearchTemplate.createIndex(Article.class);
elasticsearchTemplate.putMapping(Article.class);
}
/**测试保存文档*/
@Test
public void saveArticle(){
Article article = new Article();
article.setId(100);
article.setTitle("测试SpringData ElasticSearch");
article.setContent("Spring Data ElasticSearch 基于 spring data API 简化
elasticSearch操作，将原始操作elasticSearch的客户端API 进行封装Spring Data为
Elasticsearch Elasticsearch项目提供集成搜索引擎");
articleService.save(article);
}
}
3.Spring Data ElasticSearch的常用操作
增删改查方法测试
package com.itheima.service;
import com.itheima.domain.Article;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
public interface ArticleService {
//保存
public void save(Article article);
//删除
public void delete(Article article);
//查询全部
public Iterable<Article> findAll();
//分页查询
public Page<Article> findAll(Pageable pageable);
}
package com.itheima.service.impl;
import com.itheima.dao.ArticleRepository;
import com.itheima.domain.Article;
import com.itheima.service.ArticleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
@Service
public class ArticleServiceImpl implements ArticleService {
@Autowired
private ArticleRepository articleRepository;
public void save(Article article) {
articleRepository.save(article);
}
public void delete(Article article) {
articleRepository.delete(article);
}
public Iterable<Article> findAll() {
Iterable<Article> iter = articleRepository.findAll();
return iter;
}
public Page<Article> findAll(Pageable pageable) {
return articleRepository.findAll(pageable);
}
}
package com.itheima.test;
import com.itheima.domain.Article;
import com.itheima.service.ArticleService;
import org.elasticsearch.client.transport.TransportClient;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:applicationContext.xml")
public class SpringDataESTest {
@Autowired
private ArticleService articleService;
@Autowired
private TransportClient client;
@Autowired
private ElasticsearchTemplate elasticsearchTemplate;
/**创建索引和映射*/
@Test
public void createIndex(){
elasticsearchTemplate.createIndex(Article.class);
elasticsearchTemplate.putMapping(Article.class);
}
/**测试保存文档*/
@Test
public void saveArticle(){
Article article = new Article();
article.setId(100);
article.setTitle("ELasticSearch是一个基于Lucene的搜索服务器");
article.setContent("它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web
接口。Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当前流行的企业级
搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。");
articleService.save(article);
}
/**测试更新*/
@Test
public void update(){
Article article = new Article();
article.setId(1001);
article.setTitle("[更新]ELasticSearch是一个基于Lucene的搜索服务器");
article.setContent("[更新]它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful
web接口。Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当前流行的企
业级搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。");
articleService.save(article);
}
/**测试删除*/
@Test
public void delete(){
Article article = new Article();
article.setId(1001);
articleService.delete(article);
}
/**批量插入*/
@Test
public void save100(){
for(int i=1;i<=100;i++){
Article article = new Article();
article.setId(i);
article.setTitle(i+"elasticSearch 3.0版本发布..，更新");
article.setContent(i+"ElasticSearch是一个基于Lucene的搜索服务器。它提供了
一个分布式多用户能力的全文搜索引擎，基于RESTful web接口");
articleService.save(article);
}
}
/**分页查询*/
@Test
public void findAllPage(){
Pageable pageable = PageRequest.of(1,10);
Page<Article> page = articleService.findAll(pageable);
for(Article article:page.getContent()){
System.out.println(article);
}
}
}
常用查询命名规则
查询方法测试
使用Elasticsearch的原生查询对象进行查询
/**
* 原生查询
* 1.创建原生查询对象构建器
* 2.设置查询方式，设置分页
* 3.构建查询对象
* 4.使用ElasticSearch模板执行查询对象
*/
@Test
public void findByNativeQuery() {
//创建一个SearchQuery对象
SearchQuery searchQuery = new NativeSearchQueryBuilder()
//设置查询条件，此处可以使用QueryBuilders创建多种查询
.withQuery(QueryBuilders.queryStringQuery("备份节点上没有数
据").defaultField("title"))
//还可以设置分页信息
.withPageable(PageRequest.of(1, 5))
//创建SearchQuery对象
.build();
//使用模板对象执行查询
elasticsearchTemplate.queryForList(searchQuery, Article.class)
.forEach(a-> System.out.println(a));
}
扫一扫
2830
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
