spring与es集成(elasticsearch学习笔记)

本文仅用来记录平常学习所得,也希望能帮助到所有需要的人

实体类如下(Score类仅用来测试当序列不存在时生成新序列使用,Student是主要使用的测试类):

@Document(indexName = "test2",type = "score")
public class Score implements Serializable {
    @Id
    @Field(index = FieldIndex.not_analyzed,type = FieldType.Integer,store = true)
    private Integer id;
    @Field(index = FieldIndex.not_analyzed,type = FieldType.String,store = true)
    private String chinese;
    @Field(index = FieldIndex.not_analyzed,type = FieldType.String,store = true)
    private String math;
    @Field(index = FieldIndex.not_analyzed,type = FieldType.String,store = true)
    private String english;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getChinese() {
        return chinese;
    }

    public void setChinese(String chinese) {
        this.chinese = chinese;
    }

    public String getMath() {
        return math;
    }

    public void setMath(String math) {
        this.math = math;
    }

    public String getEnglish() {
        return english;
    }

    public void setEnglish(String english) {
        this.english = english;
    }
}

@Document(indexName = "test1",type = "student")
public class Student implements Serializable {
    /*@Id
    @Field(index = FieldIndex.not_analyzed,type = FieldType.String,store = true)
    private String id;*/
    @Field(index = FieldIndex.not_analyzed,type = FieldType.String,store = true)
    private String birthday;
    @Field(index = FieldIndex.not_analyzed,type = FieldType.String,store = true)
    private String studentNo;
    @Field(index = FieldIndex.not_analyzed,type = FieldType.String,store = true)
    private String sex;
    @Field(index = FieldIndex.not_analyzed,type = FieldType.String,store = true)
    private String classNo;
    @Field(index = FieldIndex.not_analyzed,type = FieldType.String,store = true)
    private String address;
    @Field(index = FieldIndex.not_analyzed,type = FieldType.String,store = true)
    private String name;
    @Field(index = FieldIndex.not_analyzed,type = FieldType.Integer,store = true)
    private Integer age;
    @Field(index = FieldIndex.not_analyzed,type = FieldType.Boolean,store = true)
    private boolean isLeader;


   /* public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }*/

    public String getBirthday() {
        return birthday;
    }

    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }

    public String getStudentNo() {
        return studentNo;
    }

    public void setStudentNo(String studentNo) {
        this.studentNo = studentNo;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getClassNo() {
        return classNo;
    }

    public void setClassNo(String classNo) {
        this.classNo = classNo;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public boolean isLeader() {
        return isLeader;
    }

    public void setLeader(boolean leader) {
        isLeader = leader;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

}

配置信息如下:

es的配置信息:

elasticsearch.esNodes=localhost:9300
elasticsearch.cluster.name=elasticsearch

spring的配置信息:

spring_es的配置信息:

增删改操作:

import java.util.ArrayList;
import java.util.List;

/**
 * Created by HP on 2017/8/8.
 */
@Component
public class EsTest1 {
    @Autowired
    private ElasticsearchTemplate elasticsearchTemplate;
    @Autowired
    private Client client;

    @Override
    public String toString() {
        return "EsTest1{" +
                "elasticsearchTemplate=" + elasticsearchTemplate +
                ", client=" + client +
                '}';
    }

    /**
     * 批量插入数据
     * @return
     */
    public boolean update(){
       if (!elasticsearchTemplate.indexExists("test1")){//如果序列不存在,则新增序列
           elasticsearchTemplate.createIndex("test1");
           elasticsearchTemplate.putMapping(Student.class);//新增序列之后,增加type(表结构)
       };
        List list = forUpdate();
        List queryList = new ArrayList();
        for (Student stu : list){
            IndexQuery query = new IndexQueryBuilder().withId("1").withObject(stu).build();//若id存在则更新数据,不存在则新增
            queryList.add(query);
        }
        try {
            elasticsearchTemplate.bulkIndex(queryList);//批量处理,能提高效率
            elasticsearchTemplate.refresh("test1");
            return true;
        }catch (Exception e){
            e.printStackTrace();
        }
        return false;
    }
    private List forUpdate(){
        List list = new ArrayList();
        Student student1 = new Student();
        student1.setAddress("江苏省");
        student1.setAge(25);
        student1.setBirthday("1992/10/1");
        student1.setClassNo("1");
        student1.setLeader(true);
        student1.setName("hp");
        student1.setSex("女");
        student1.setStudentNo("12");
        //student1.setId("AV3AyhW25QrkTDZNw8Ni");

        /*Student student2 = new Student();
        student2.setAddress("上海市");
        student2.setAge(27);
        student2.setBirthday("1992/08/1");
        student2.setClassNo("1");
        student2.setLeader(true);
        student2.setName("sg_e");
        student2.setSex("男");
        student2.setStudentNo("10");
        list.add(student2);*/
        list.add(student1);
        return list;
    }

    /**
     * 插入数据
     */
    public boolean update1(){
        if (!elasticsearchTemplate.indexExists("test1")){
            elasticsearchTemplate.createIndex("test1");
        }
        IndexQuery indexQuery = new IndexQueryBuilder().withObject(forUpdate().get(0)).build();
        try{
            elasticsearchTemplate.index(indexQuery);
            return true;
        }catch (Exception e){
            e.printStackTrace();
        }
        return false;
    }
    /**
     * 删除数据
     */
    public boolean deleteById(){
        try{
            //方法1
           // elasticsearchTemplate.delete("test1","student","1");

            //方法2
            elasticsearchTemplate.delete(Student.class,"AV3A5EAL5QrkTDZNw8Nn");
            return true;
        }catch (Exception e){
            e.printStackTrace();
        }
        return false;
    }
    /**
     * 集群健康状态
     */
    public boolean ping() {
        try {
            ActionFuture health = client.admin().cluster().health(new ClusterHealthRequest());
            ClusterHealthStatus status = health.actionGet().getStatus();
            if (status.value() == ClusterHealthStatus.RED.value()) {
                throw new RuntimeException("elasticsearch cluster health status is red.");
            }
            if (status.value() == ClusterHealthStatus.YELLOW.value()){
                System.out.println("-----------------------");
                System.out.println("YELLOW");
                System.out.println("-----------------------");
            }
            if (status.value() == ClusterHealthStatus.GREEN.value()){
                System.out.println("-----------------------");
                System.out.println("GREEN");
                System.out.println("-----------------------");
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }
}

查询操作:

@Component
public class EsTest2 {
    @Autowired
    private ElasticsearchTemplate elasticsearchTemplate;
    @Autowired
    private Client client;

    /**
     * 查询只需要注意三个对象,一个SearchRequestBuilder,用来创建查询,QueryBuildersyonglai创建查询条件,SearchResponse用于接收返回值
     * @return
     */
    public boolean query(){
        try{
            SearchRequestBuilder requestBuilder = client.prepareSearch("test1").setTypes("student")//查询某个表
                    .addSort("studentNo", SortOrder.ASC)//查询规则studentNo升序
                    .setFrom(0).setSize(20)//从第0条数据开始查,查20条
                    .setSearchType(SearchType.DEFAULT)//设置打分相关性,默认query then fetch
                    .setExplain(true);//设置是否按查询匹配度排序

            //termQuery查询-----精确查询  查询name为hp的同学
            //requestBuilder.setQuery(QueryBuilders.termQuery("name","hp"));

            //ids查询------根据id精确查询   查询id为id1,id2的同学
            //requestBuilder.setQuery(QueryBuilders.idsQuery("id1","id2","....."));

            //boolean should查询,这里的should查询需要依靠其他查询来确定条件,相当于数据库中in查询 查询address为安徽和江苏的同学
            /*requestBuilder.setQuery(
                    QueryBuilders.boolQuery().should(QueryBuilders.termQuery("address","安徽省"))
                    .should(QueryBuilders.termQuery("address","江苏省"))
            );*/

            //boolean should查询 查询可以是任意地址的同学
            //requestBuilder.setQuery(QueryBuilders.boolQuery().should(QueryBuilders.wildcardQuery("address","?*")));

            //boolean must查询,查询sex为男的同学
           /* requestBuilder.setQuery(QueryBuilders.boolQuery().must(  //boolean must查询
               QueryBuilders.termQuery("sex","男")
            ));*/

           //通配符查询  * 代表任意（包括0个）多个字符/? 代表任意一个字符     查询address中以市结尾的同学
           //requestBuilder.setQuery(QueryBuilders.wildcardQuery("address","*市"));

            //判断字段是否存在,存在则输出数据,不存在则无数据返回
           // requestBuilder.setQuery(QueryBuilders.existsQuery("id"));

            //terms查询,多词语查询,查询age为16,18,20的同学
            //requestBuilder.setQuery(QueryBuilders.termsQuery("age","20","18","16"));

            //正则匹配查询  查询地址为安徽省的同学
            //requestBuilder.setQuery(QueryBuilders.regexpQuery("address","安徽省"));

            //fuzzuQuery模糊查询,具体与wildcardquery有什么区别,不是本代码关心的重点,自行百度
            //requestBuilder.setQuery(QueryBuilders.fuzzyQuery("address","安徽省"));

            //全数据查询  match_all
            requestBuilder.setQuery(QueryBuilders.matchAllQuery());

            //返回值
            SearchResponse response = requestBuilder.execute().actionGet();
            SearchHit[] hits = response.getHits().getHits();
            System.out.println("---------------------");
            for (SearchHit s : hits){
                System.out.println(s.getSourceAsString());
            }
            System.out.println("---------------------");
            return true;
        }catch (Exception e){
            e.printStackTrace();
        }

        return false;
    }
}

测试:

public class t1 {
    ApplicationContext context;
    EsTest1 esTest1;
    EsTest2 esTest2;
    @Before
    public void init(){
        //String path = Thread.currentThread().getClass().getClassLoader().getResource("applicationContext.xml").getPath();
        context = new ClassPathXmlApplicationContext("spring/applicationContext.xml");
        esTest1 = (EsTest1) context.getBean("esTest1");
        esTest2 = (EsTest2)context.getBean("esTest2");
    }
    @Test
    public void tUpdate(){
        System.out.println("---------------------------");
        System.out.println(esTest1.update());
        System.out.println("---------------------------");
    }

    @Test
    public void tQuery(){
        System.out.println("---------------------------");
        System.out.println(esTest2.query());
        System.out.println("---------------------------");
    }
}

数据与结果如下