ElasticSearch对象化

ElasticSearch对象化

ElasticSearch对象化

之前写的一篇基于ElasticSearch6.X对象化的博客由于时间太长了，不知道是哪个账号上面的，现在重新写了一个基于7.1的，并且打包成jar包，引入maven之后可以直接使用，源码会放在github上，欢迎大家一起来进行优化，jar包和github地址我会在文章结尾给出,

引入jar包

将elastic-search.jar放在电脑中的任意一个盘中
输入命令 mvn install:install-file -Dfile=<jar包绝对路径> -DgroupId=com.leo.elasticsearch -DartifactId=elastic-search -Dversion=0.0.1 -Dpackaging=jar
然后在pom.xml文件中加入依赖，就可以直接使用了

配置文件

在properties静态文件中需要加上es的配置

es.host=127.0.0.1
es.port=9200
es.connect.num=10
es.connect.per.route=50
## 需要创建es索引的类所在包
base.package=com.leo.elasticsearch

在spring的配置文件中需要加入以下配置

工厂类

<!--elasticsearch 的工厂类-->
    <bean id="ElasticSearchClientFactory" class="com.leo.elasticsearch.config.ElasticSearchClientFactory"
          init-method="init" destroy-method="close">
        <constructor-arg name="httpHost" ref="httpHost"/>
        <constructor-arg name="maxConnectNum" value="${es.connect.num}"/>
        <constructor-arg name="maxConnectPerRoute" value="${es.connect.per.route}"/>
    </bean>
    <!--HttpHost-->
    <bean id="httpHost" class="org.apache.http.HttpHost">
        <constructor-arg name="scheme" value="http"/>
        <constructor-arg name="hostname" value="${es.host}"/>
        <constructor-arg name="port" value="${es.port}"/>
    </bean>

项目启动时会先装配工厂，设置一些基本参数，之后调用工厂类的init方法创建RestHighLevelClient

 public void init(){
        builder = RestClient.builder(HTTP_HOST);
        setConnectTimeOutConfig();
        setMultiConnectConfig();
        restClient = builder.build();
        restHighLevelClient = new RestHighLevelClient(builder);
        System.out.println("init factory");
    }

RestHighLevelClient

获取client，通过调用工厂类的***getRestHighLevelClient***方法获取到RestHighLevelClient

<!--RestHighLevelClient-->
    <bean factory-bean="ElasticSearchClientFactory" 
          id="RestHighLevelClient" scope="singleton" 
          class="org.elasticsearch.client.RestHighLevelClient" factory-method="getRestHighLevelClient">
    </bean>

ElasticSearch启动类，启动ElasticSearchStart的init方法，在方法中通过在静态文件properties中设置的base.package获取所需要在elasticsearch中创建索引的类

启动类

<!--启动类-->
    <bean class="com.leo.elasticsearch.start.ElasticSearchStart" init-method="init">
        <property name="client" ref="RestHighLevelClient"/>
        <property name="initPackage" value="${base.package}"/>
    </bean>

注解

@EsCommonFilter

所有需要在es中创建索引的类上必须要加上 @EsCommonFilter 注解，注解中填写该类的class，没有加上该注解的类，不会为其创建索引，该类需要继承 com.leo.elasticsearch.base.pojo 类
com.leo.elasticsearch.base.pojo如下

public class BasePojo implements Serializable {
    private static final long serialVersionUID = -6643658369190411001L;
    private String id;
    @DateFormat
    private String createDate;
    
    private String createBy;
    
    @DateFormat
    private String updateDate;
    
    private String updateBy;

    public String getId() {
        return id;
    }

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

    public String getCreateDate() {
        return createDate;
    }

    public void setCreateDate(String createDate) {
        this.createDate = createDate;
    }

    public String getCreateBy() {
        return createBy;
    }

    public void setCreateBy(String createBy) {
        this.createBy = createBy;
    }

    public String getUpdateDate() {
        return updateDate;
    }

    public void setUpdateDate(String updateDate) {
        this.updateDate = updateDate;
    }

    public String getUpdateBy() {
        return updateBy;
    }

    public void setUpdateBy(String updateBy) {
        this.updateBy = updateBy;
    }
}

@DateFormat

如果字段是日期类型，该字段上需要加上 @DateFormat 注解，在注解中填写日期格式，默认格式是yyyy-MM-dd HH:mm:ss，暂时日期类型仅支持Date和String

@ExcludeField

如果该字段不需要创建索引，则加上 @ExcludeField 注解

@FieldType

如果字段需要创建索引的类型和字段本身的类型不一致时，可以添加 @FieldType 注解，在注解中填写es的类型，所包含的es类型如下所示

INTEGER{
        @Override
        public String getValue() {
            return "integer";
        }
    },
    TEXT {
        @Override
        public String getValue() {
            return "text";
        }
    },
    KEYWORD {
        @Override
        public String getValue() {
            return "keyword";
        }
    },
    LONG {
        @Override
        public String getValue() {
            return "long";
        }
    },
    SHORT {
        @Override
        public String getValue() {
            return "short";
        }
    },
    BYTE {
        @Override
        public String getValue() {
            return "byte";
        }
    },
    DOUBLE {
        @Override
        public String getValue() {
            return "double";
        }
    },
    FLOAT {
        @Override
        public String getValue() {
            return "float";
        }
    },
    HALF_FLOAT {
        @Override
        public String getValue() {
            return "half_float";
        }
    },
    SCALED_FLOAT {
        @Override
        public String getValue() {
            return "scaled_float";
        }
    },
    BOOLEAN {
        @Override
        public String getValue() {
            return "boolean";
        }
    },
    DATE {
        @Override
        public String getValue() {
            return "date";
        }
    },
    RANGE {
        @Override
        public String getValue() {
            return "range";
        }
    },
    BINARY {
        @Override
        public String getValue() {
            return "binary";
        }
    },
    ARRAY {
        @Override
        public String getValue() {
            return "array";
        }
    },
    OBJECT {
        @Override
        public String getValue() {
            return "object";
        }
    },
    NESTED {
        @Override
        public String getValue() {
            return "nested";
        }
    },
    GEO_POINT {
        @Override
        public String getValue() {
            return "geo_point";
        }
    },
    GEO_SHAPE {
        @Override
        public String getValue() {
            return "geo_shape";
        }
    },
    IP {
        @Override
        public String getValue() {
            return "ip";
        }
    },
    COMPLETION {
        @Override
        public String getValue() {
            return "completion";
        }
    },
    TOKEN_COUNT {
        @Override
        public String getValue() {
            return "token_count";
        }
    },
    ATTACHMENT {
        @Override
        public String getValue() {
            return "attachment";
        }
    },
    PERCOLATOR {
        @Override
        public String getValue() {
            return "percolator";
        }
    }

@Fuzzy

如果字段需要模糊查询的时候，需要在字段上增加 @Fuzzy 注解

@QueryFilter

在查询的时候建议新建一个类去继承原本的类作为查询类，在查询类上需要添加@QueryFilter注解，注解中需要填上要查询的类的class

@TimeMax @TimeMin

日期查询时，通常都是范围查询，在query类中，定义开始时间和结束时间字段，在开始时间上加上 @TimeMin 注解，在结束时间上加上 @TimeMax 注解，两个注解都需要指明查询的是哪个字段

增删改查

接口层

BaseService

service层继承 com.leo.elasticsearch.base.service.BaseService< T extend BasePojo, Q extend T > 类
service中包含大量的基本的增删改查和分页查询接口，如下

 /**
     * 保存，有id就更新，没id就插入
     * @param t
     * @return
     */
    T save(T t);

    /**
     * 保存，有id就更新，没id就插入
     * 是否及时刷新
     * @param t
     * @param isRefresh
     * @return
     */
    T save(T t,Boolean isRefresh);

    /**
     * 批量更新,是否及时刷新
     * @param list
     * @param isRefresh
     * @return
     */
    Boolean updateList(List<T> list, Boolean isRefresh);

    /**
     * 批量更新
     * @param list
     * @return
     */
    Boolean updateList(List<T> list);

    /**
     * 根据id查询
     * @param t
     * @return
     */
    T getById(T t);

    /**
     * 根据id查询，是否及时刷新
     * @param t
     * @param isRefresh
     * @return
     */
    T getById(T t,Boolean isRefresh);

    /**
     * 单条删除
     * @param t
     * @return
     */
    Boolean delete(T t);

    /**
     * 单条删除，是否及时刷新
     * @param t
     * @param isRefresh
     * @return
     */
    Boolean delete(T t,Boolean isRefresh);

    /**
     * 批量删除
     * @param list
     * @return
     */
    Boolean deleteList(List<T> list);

    /**
     * 批量删除，是否及时更新
     * @param list
     * @param isRefresh
     * @return
     */
    Boolean deleteList(List<T> list,Boolean isRefresh);

    /**
     * 批量获取
     * @param list
     * @return
     */
    List<T> multiGet(List<T> list);

    /**
     * 批量获取，是否及时刷新
     * @param list
     * @param isRefresh
     * @return
     */
    List<T> multiGet(List<T> list,Boolean isRefresh);

    /**
     * 批量新增，是否及时刷新
     * @param list
     * @param isRefresh
     * @return
     */
    List<T> insertList(List<T> list, Boolean isRefresh);

    /**
     * 批量新增
     * @param list
     * @return
     */
    List<T> insertList(List<T> list);

    /**
     * 获取查询结果数量
     * @param q
     * @return
     */
    Long getTotalCount(Q q);

    /**
     * 同步删除
     * @return
     */
    Long deleteByQuery(Q q);

    /**
     * 异步删除
     * @param q
     */
    void deleteNyQueryAsync(Q q);

    /**
     * 查询
     * @param q
     * @param orderField
     * @param size
     * @param from
     * @param order
     * @return
     */
    List<T> getList(Q q, String orderField, Integer size, Integer from, SortOrder order);
    List<T> getList(Q q);
    List<T> getList(Integer from, Q q);
    List<T> getList(Q q, Integer size);
    List<T> getList(Q q, String orderField);
    List<T> getList(Q q, SortOrder order, Integer from);
    List<T> getList(Q q, Integer size, SortOrder order);
    List<T> getList(Q q, String orderField, SortOrder order);
    List<T> getList(Q q, Integer size, Integer from);
    List<T> getList(Q q, Integer from, String orderField);
    List<T> getList(Q q, String orderField, Integer size);
    List<T> getList(Q q, Integer size, Integer from, SortOrder order);
    List<T> getList(Q q, String orderField, SortOrder order, Integer from);
    List<T> getList(Q q, String orderField, Integer size, SortOrder order);
    List<T> getList(Q q, String orderField, Integer size, Integer from);

    /**
     * 获取最大值
     * @param q
     * @param orderField
     * @return
     */
    T getMaxOne(Q q,String orderField);

    /**
     * 获取最小值
     * @param q
     * @param orderField
     * @return
     */
    T getMinOne(Q q,String orderField);
    PageList<T> getPageList(Q q, PageBounds pbs, String orderField, SortOrder order);
    PageList<T> getPageList(Q q, PageBounds pbs);
    PageList<T> getPageList(Q q, PageBounds pbs, SortOrder order);
    PageList<T> getPageList(Q q, PageBounds pbs, String orderField);

与坐标有关的 GeoPointBaseService

在需要根据中心点坐标查询与该中心点一定有一定距离的所有对象或根据长方形对角两点的坐标查询包含在这个长方形中的所有对象时，继承 com.leo.elasticsearch.base.service.GeoPointBaseService<T extends BasePojo,Q extends T>
该service也是继承 BaseService 接口

public interface GeoPointBaseService<T extends BasePojo,Q extends T> extends BaseService<T, Q> {
    /**
     * 边界框过滤
     * @param q
     * @param topLeft
     * @param bottomRight
     * @return
     */
    List<T> borderFilter(Q q, String geoField, GeoPoint topLeft, GeoPoint bottomRight, Integer size);

    /**
     * 边界框过滤
     * @param q
     * @param geoField
     * @param topLeft
     * @param bottomRight
     * @return
     */
    List<T> borderFilter(Q q, String geoField, GeoPoint topLeft, GeoPoint bottomRight);

    /**
     * 根据中心距离查询
     * @param q
     * @param geoField
     * @param distance
     * @param size
     * @return
     */
    List<T> distanceFilter(Q q, String geoField, Double distance, Integer size);

    /**
     * 根据中心距离查询
     * @param q
     * @param geoField
     * @param distance
     * @return
     */
    List<T> distanceFilter(Q q, String geoField, Double distance);

    /**
     * 
     * @param q
     * @param geoField
     * @param size
     * @return
     */
    List<T> distanceFilter(Q q, String geoField, Integer size);
}

实现层

BaseImpl

实现层需继承 com.leo.elasticsearch.base.impl.BaseImpl <T extends BasePojo, Q extends T> 类
该类实现了BaseService的接口，在插入和修改的时候，调用的都是 save 方法，区别在于，如果对象的id为空的话，就时插入，如果id不为空的话，则会判断es中是否有该id的那条数据，如果没有，则进行插入，如果有，则进行修改

与坐标有关 GeoPointBaseImpl

与坐标查询有关的需要继承 com.leo.elasticsearch.base.impl，该类也继承了 BaseImpl 类，实现了 GeoPointBaseService 的所有方法

源码

源码地址
jar包在源码的resource目录下
使用mvn clean install 命令可将源码打包成jar包，选择打包之后包含dependencies的jar包

后记

可能在一些大神的眼里的，这代码质量不行，我将源码开源了，如果各位觉得哪里写的不够好，欢迎批评指正