实现自己的SpringBoot starter

最新推荐文章于 2024-08-18 10:45:03 发布
最新推荐文章于 2024-08-18 10:45:03 发布
阅读量408 收藏
点赞数
分类专栏： Java 文章标签： elasticsearch starter springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wang_shuyu/article/details/84962514
版权

在学习Spring Boot的过程中，接触最多的就是starter。可以认为starter是一种服务——使得使用某个功能的开发者不需要关注各种依赖库的处理，不需要具体的配置信息，由Spring Boot自动通过classpath路径下的类发现需要的Bean，并织入bean。

 

本篇将通过一个简单的例子来演示如何编写自己的starter。

Starter要实现的功能，很简单，提供一个Service，包含一个能够将字符串加上前后缀的方法String wrap(String word)。而具体的前缀和后缀是通过读取SpringBoot配置文件而获取的。

这里说下artifactId的命名问题，Spring 官方 Starter通常命名为 spring-boot-starter-{name} 如 spring-boot-starter-web。Spring官方建议非官方Starter命名应遵循 {name}-spring-boot-starter 的格式。

添加必须的maven依赖：

<!-- @ConfigurationProperties annotation processing (metadata for IDEs)
                 生成spring-configuration-metadata.json类，需要引入此类-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>

注意其中 spring-boot-configuration-processor 的作用是编译时生成 spring-configuration-metadata.json ，此文件主要给IDE使用，用于提示使用。

本例讲解的是封装一个自定义的elasticsearch的start，因此还有添加必须的业务jar,完整的pom依赖如下：

<?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.ganinfo</groupId>
    <artifactId>elastic-spring-boot-starter</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <boot.processor.version>1.4.3.RELEASE</boot.processor.version>
        <boot.version>2.0.4.RELEASE</boot.version>
        <elasticsearch.version>5.6.1</elasticsearch.version>
        <google.gson.version>2.8.5</google.gson.version>
        <lombok.version>1.16.20</lombok.version>
    </properties>

    <dependencies>
        <dependency><!-- 以下两个依赖是自动配置的依赖 -->
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
            <version>${boot.processor.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <version>${boot.processor.version}</version>
            <optional>true</optional>
        </dependency>

        <!--X-Pack 安全插件-->
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>x-pack-transport</artifactId>
            <version>${elasticsearch.version}</version>
        </dependency>

        <!--boot web-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>${boot.version}</version>
            <optional>true</optional>
        </dependency>

        <!-- gson -->
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>${google.gson.version}</version>
            <optional>true</optional>
        </dependency>

        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>1.5.10.RELEASE</version>
                <configuration>
                    <skip>true</skip>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

属性类：

package com.ganinfo.elastic.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;

/**
 * @package:com.ganinfo.elastic
 * @className:ElasticProperties
 * @description:
 * @author:Shuyu.Wang
 * @date:2018-12-09 22:06
 * @version:V1.0
 **/

@ConfigurationProperties(prefix="ganinfo.elastic")
@Data
public class ElasticProperties {
    /**
     * @Field： 服务器地址
     */
    private String host;
    /**
     * @Field：端口
     */
    private int port;
    /**
     * @Field：节点名
     */
    private String clusterName;
}

本例提供两个service类，分别是连接池的ClientHelper和提供接口服务的ESService；

package com.ganinfo.elastic;

import com.ganinfo.elastic.config.ElasticProperties;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import com.ganinfo.elastic.constant.ESConstant;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.client.Client;
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.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @package:com.ganinfo.elastic
 * @className:ClientHelper
 * @description:
 * @author:Shuyu.Wang
 * @date:2018-12-09 22:19
 * @version:V1.0
 **/
@Slf4j
public class ClientHelper {

    private ElasticProperties elasticProperties;

    public ClientHelper() {
    }

    public ClientHelper(ElasticProperties elasticProperties) {
        super();
        this.elasticProperties = elasticProperties;
    }

    private Settings setting;

    private ConcurrentHashMap<String, TransportClient> clientMap = new ConcurrentHashMap<String, TransportClient>();

    private Map<String, Integer> ips = new HashMap<String, Integer>();

    public static final ClientHelper getInstance() {
        return ClientHolder.INSTANCE;
    }

    private static class ClientHolder {
        private static final ClientHelper INSTANCE = new ClientHelper();
    }

    /**
     * @author:shuyu.wang
     * @description:初始化默认的client
     * @date: 2018/12/3 22:20
     * @param: null
     * @return: null
     */
    private void init() {
        log.info("host:" + elasticProperties.getHost());
        log.info("clusterName:" + elasticProperties.getClusterName());
        if (elasticProperties.getHost().contains(",")) {
            String[] split = elasticProperties.getHost().split(",");
            for (String ip : split) {
                ips.put(ip, elasticProperties.getPort());
            }
        } else {
            ips.put(elasticProperties.getHost(), elasticProperties.getPort());
        }
        setting = Settings.builder().put(ESConstant.CLUSTER_NAME_STRING, elasticProperties.getClusterName()).put(ESConstant.CLIENT_TRANSPORT_SNIFF_STRING, true).build();
        addClient(setting, ips);
    }

    /**
     * @author:shuyu.wang
     * @description:获得所有的地址端口
     * @date: 2018/12/3 22:20
     * @param: ips
     * @return: null
     */
    private List<InetSocketTransportAddress> getAllAddress(Map<String, Integer> ips) {
        List<InetSocketTransportAddress> addressList = new ArrayList<InetSocketTransportAddress>();
        for (String ip : ips.keySet()) {
            try {
                addressList.add(new InetSocketTransportAddress(InetAddress.getByName(ip), Integer.valueOf(ips.get(ip).toString())));
            } catch (UnknownHostException e) {
                e.printStackTrace();
            }
        }
        return addressList;
    }

    /**
     * @author:shuyu.wang
     * @description:获得client连接
     * @date: 2018/12/3 22:20
     * @param: null
     * @return: Client
     */
    public Client getClient() {
        if ((clientMap != null && !clientMap.isEmpty()) || (ips != null && !ips.isEmpty())) {
            init();
        }
        return getClient(elasticProperties.getClusterName());
    }

    /**
     * @author:shuyu.wang
     * @description:获得client连接
     * @date: 2018/12/3 22:20
     * @param: clusterName
     * @return: Client
     */
    public Client getClient(String clusterName) {
        if (clientMap == null || clientMap.isEmpty()) {
            init();
        }
        return clientMap.get(clusterName);
    }

    /**
     * @author:shuyu.wang
     * @description:建立client连接
     * @date: 2018/12/3 22:20
     * @param: clusterName
     * @return: Client
     */
    private void addClient(Settings setting, Map<String, Integer> ips) {
        TransportClient client = null;
        for (String ip : ips.keySet()) {
            try {
                client = new PreBuiltTransportClient(setting).addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName(ip), Integer.valueOf(ips.get(ip).toString())));
            } catch (UnknownHostException e) {
                e.printStackTrace();
            }
        }
        if (client != null) {
            clientMap.put(setting.get(ESConstant.CLUSTER_NAME_STRING), client);
        }

    }
}

/**
 * @package:com.ganinfo.elasticsearch
 * @className:ESQueryParams
 * @description:ESService
 * @author:Shuyu.Wang
 * @date:2018-12-03 22:13
 * @version:V1.0
 * @NOTICE：本内容仅限于新疆感知科技有限公司内部传阅,禁止外泄以及用于其他的商业目
 * @ Copyright © 2017-ganinfo. All rights reserved.
 **/
public interface ESService {

    /**
     * @param index 索引
     * @param type  类型
     * @param obj   插入的对象
     * @author:shuyu.wang
     * @description:新增接口
     * @date: 2018/3/29 10:20
     * @return: Boolean
     */
    Boolean add(String index, String type, Object obj);

    /**
     * @param index           索引
     * @param type            类型
     * @param id
     * @param xContentBuilder 更新内容
     * @author:shuyu.wang
     * @description:更新接口
     * @date: 2018/4/9 12:05
     * @return: Boolean
     */
    Boolean update(String index, String type, String id, XContentBuilder xContentBuilder);

    /**
     * @param index        索引
     * @param type         类型
     * @param queryBuilder 拼接的查询条件
     * @param sort         排序字段，默认降序
     * @param from         起始记录位置
     * @param size         返回条数
     * @author:shuyu.wang
     * @description:查询接口
     * @date: 2018/3/29 10:33
     * @return: ESReturn<List<Map<String,Object>>>
     */
    ESReturn<List<Map<String, Object>>> query(String index, String type, QueryBuilder queryBuilder, String sort, Integer from, Integer size);

    /**
     * @param esQueryParams
     * @author:shuyu.wang
     * @description:es查询封装
     * @date: 2018/5/22 18:22
     * @return: ESReturn<List<Map<String,Object>>>
     */
    ESReturn<List<Map<String, Object>>> queryES(ESQueryParams esQueryParams);


    /**
     * @param index   索引
     * @param type    类型
     * @param id
     * @param jsonDoc json串数据
     * @author:shuyu.wang
     * @description:es查询封装
     * @date: 2018/5/22 18:22
     * @return: Boolean
     */
    Boolean updateES(String index, String type, String id, String jsonDoc);

}

 

package com.ganinfo.elastic;

import com.ganinfo.elastic.config.ElasticProperties;
import com.ganinfo.elastic.service.ESService;
import com.ganinfo.elastic.service.impl.ESServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

/**
 * @package:com.ganinfo.elastic
 * @className:
 * @description:
 * @author:Shuyu.Wang
 * @date:2018-12-09 22:34
 * @version:V1.0
 **/
@Configuration // 配置注解
@EnableConfigurationProperties(ElasticProperties.class) // 开启指定类的配置
@ConditionalOnClass(ClientHelper.class)// 当PersonService这个类在类路径中时，且当前容器中没有这个Bean的情况下，开始自动配置
@ConditionalOnProperty(prefix = "ganinfo.elastic", value = "enabled", matchIfMissing = true)// 指定的属性是否有指定的值
public class ElasticAutoConfiguration {
    @Autowired
    private ElasticProperties elasticProperties;

    @Bean("clientHelper")
    @ConditionalOnMissingBean(ClientHelper.class)// 当容器中没有指定Bean的情况下，自动配置PersonService类
    public ClientHelper getClientHelper() {
        ClientHelper cientHelper = new ClientHelper(elasticProperties);
        return cientHelper;
    }


    @Bean
    @ConditionalOnMissingBean(ESService.class)// 当容器中没有指定Bean的情况下，自动配置PersonService类
    public ESService getESService(@Qualifier("clientHelper") ClientHelper clientHelper) {
        ESServiceImpl esService = new ESServiceImpl(clientHelper);
        return esService;
    }
}

其他辅助类：

package com.ganinfo.elastic.service.impl;


import com.ganinfo.elastic.ClientHelper;
import com.ganinfo.elastic.constant.ESConstant;
import com.ganinfo.elastic.po.ESQueryParams;
import com.ganinfo.elastic.po.ESReturn;
import com.ganinfo.elastic.po.RangeEntity;
import com.ganinfo.elastic.service.ESService;
import com.ganinfo.elastic.util.CommonUtil;
import com.google.gson.JsonObject;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.bulk.BulkRequestBuilder;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequestBuilder;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.Client;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.*;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.sort.SortBuilders;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.stereotype.Service;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;

/**
 * @package:com.ganinfo.elasticsearch
 * @className:ESServiceImpl
 * @description:ES实现服务层
 * @author:Shuyu.Wang
 * @date:2018-12-03 22:13
 * @version:V1.0
 **/
@Slf4j
public class ESServiceImpl implements ESService {

    private ClientHelper clientHelper;


    public ESServiceImpl(ClientHelper clientHelper) {
        this.clientHelper=clientHelper;
    }


    @Override
    public Boolean add(String index, String type, Object obj) {
        JsonObject jsonObject = objToJson(obj);
        Client client = clientHelper.getClient();
        try {
            IndexResponse response = client.prepareIndex(index, type).setSource(jsonObject.toString(), XContentType.JSON).get();
            RestStatus status = response.status();
            int status1 = status.getStatus();
            log.info(">>>>>ES新增执行结果" + status1);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    @Override
    public Boolean update(String index, String type, String id, XContentBuilder xContentBuilder) {
        UpdateRequest updateRequest = new UpdateRequest();
        updateRequest.index(index);
        updateRequest.type(type);
        updateRequest.id(id);
        updateRequest.doc(xContentBuilder);
        Client client = clientHelper.getClient();
        try {
            UpdateResponse updateResponse = client.update(updateRequest).get();
            int status = updateResponse.status().getStatus();
            log.info(">>>>>ES更新执行结果：" + status);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public ESReturn<List<Map<String, Object>>> query(String index, String type, QueryBuilder queryBuilder, String sort, Integer from, Integer size) {
        ESReturn<List<Map<String, Object>>> esReturn = new ESReturn<List<Map<String, Object>>>();
        Client client = clientHelper.getClient();
        SearchRequestBuilder srb = client.prepareSearch(index).setTypes(type);
        SearchResponse sr = srb.setQuery(queryBuilder).setFrom(from).setSize(size).addSort(SortBuilders.fieldSort(sort).unmappedType("integer").order(SortOrder.DESC)).execute().actionGet(); // 分页排序所有
        long totalHits = sr.getHits().totalHits();
        esReturn.setTotal(totalHits);
        SearchHits hits = sr.getHits();
        List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
        for (SearchHit hit : hits) {
            Map<String, Object> map = (Map<String, Object>) hit.getSource();
            result.add(map);
        }
//        log.info("返回结果：" + totalHits + "条数据");
        esReturn.setData(result);
        return esReturn;
    }

    public JsonObject objToJson(Object obj) {
        Field[] fields = obj.getClass().getDeclaredFields();
        JsonObject jsonObject = new JsonObject();
        for (int i = 0, len = fields.length; i < len; i++) {
            // 对于每个属性，获取属性名
            String varName = fields[i].getName();
            try {
                // 获取原来的访问控制权限
                boolean accessFlag = fields[i].isAccessible();
                // 修改访问控制权限
                fields[i].setAccessible(true);
                // 获取在对象f中属性fields[i]对应的对象中的变量
                Object o;
                try {
                    o = fields[i].get(obj);
                    if (o != null) {
                        jsonObject.addProperty(varName, o.toString());
                    }
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
                // 恢复访问控制权限
                fields[i].setAccessible(accessFlag);
            } catch (IllegalArgumentException ex) {
                ex.printStackTrace();
            }
        }
        return jsonObject;
    }

    @Override
    public ESReturn<List<Map<String, Object>>> queryES(ESQueryParams esQueryParams) {
        ESReturn<List<Map<String, Object>>> esReturn = new ESReturn<List<Map<String, Object>>>();
        if (!CommonUtil.isNotNullEmpty(esQueryParams.getIndex())) {
            log.error(ESConstant.INDEX_NULL_STRING);
            return esReturn;
        }
        if (!CommonUtil.isNotNullEmpty(esQueryParams.getType())) {
            log.error(ESConstant.TYPE_NULL_STRING);
            return esReturn;
        }
        if (!CommonUtil.isNotNullEmpty(esQueryParams.getSort())) {
            log.error(ESConstant.SORT_NULL_STRING);
            return esReturn;
        }
        if (esQueryParams.getFrom() == null) {
            esQueryParams.setFrom(0);
        }
        if (esQueryParams.getSize() == null) {
            esQueryParams.setSize(10);
        }
        BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
        //完全不匹配查询
        if (CommonUtil.isNotMapNull(esQueryParams.getNoTermsList())) {
            for (String key : esQueryParams.getNoTermsList().keySet()) {
                TermsQueryBuilder notTermsQueryBuilder = QueryBuilders.termsQuery(key, esQueryParams.getNoTermsList().get(key));
                queryBuilder.mustNot(notTermsQueryBuilder);
            }
        }
        //完全匹配查询
        if (CommonUtil.isNotMapNull(esQueryParams.getTerms())) {
            for (String key : esQueryParams.getTerms().keySet()) {
                TermsQueryBuilder termsQueryBuilder = QueryBuilders.termsQuery(key, esQueryParams.getTerms().get(key));
                queryBuilder.must(termsQueryBuilder);
            }
        }
        //完全匹配查询
        if (CommonUtil.isNotMapNull(esQueryParams.getTermsList())) {
            for (String key : esQueryParams.getTermsList().keySet()) {
                TermsQueryBuilder termsQueryBuilder = QueryBuilders.termsQuery(key, esQueryParams.getTermsList().get(key));
                queryBuilder.must(termsQueryBuilder);
            }
        }
        //完全模糊查询
        if (CommonUtil.isNotMapNull(esQueryParams.getAllWildcards())) {
            for (String key : esQueryParams.getAllWildcards().keySet()) {
                WildcardQueryBuilder wildcardQueryBuilder = QueryBuilders.wildcardQuery(key, "*" + esQueryParams.getAllWildcards().get(key) + "*");
                queryBuilder.must(wildcardQueryBuilder);
            }
        }

        //右模糊查询
        if (CommonUtil.isNotMapNull(esQueryParams.getRightWildcards())) {
            for (String key : esQueryParams.getRightWildcards().keySet()) {
                WildcardQueryBuilder wildcardQueryBuilder = QueryBuilders.wildcardQuery(key, esQueryParams.getRightWildcards().get(key) + "*");
                queryBuilder.must(wildcardQueryBuilder);
            }
        }
        //范围查询
        if (CommonUtil.isNotMapNull(esQueryParams.getRanges())) {
            for (String key : esQueryParams.getRanges().keySet()) {
                RangeEntity rangeEntity = (RangeEntity) esQueryParams.getRanges().get(key);
                if (CommonUtil.isNotNullEmpty(rangeEntity.getFrom()) && CommonUtil.isNotNullEmpty(rangeEntity.getTo())) {
                    RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery(key).from(rangeEntity.getFrom(), true).to(rangeEntity.getTo(), true);// 包含上届
                    queryBuilder.must(rangeQueryBuilder);
                }

                if (CommonUtil.isNotNullEmpty(rangeEntity.getFrom()) && !CommonUtil.isNotNullEmpty(rangeEntity.getTo())) {
                    RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery(key).from(rangeEntity.getFrom(), true);// 包含上届
                    queryBuilder.must(rangeQueryBuilder);
                }
            }
        }
        //判断字段非空
        if (CommonUtil.isNotListNull(esQueryParams.getExistsFiles())) {
            for (String name : esQueryParams.getExistsFiles()) {
                queryBuilder.must(QueryBuilders.existsQuery(name));
            }
        }
//        log.info("ES查询条件>>>" + GsonUtil.GsonString(queryBuilder));
        Client client = clientHelper.getClient();
        SearchRequestBuilder srb = client.prepareSearch(esQueryParams.getIndex()).setTypes(esQueryParams.getType());
        SearchResponse sr = srb.setQuery(queryBuilder).setFrom(esQueryParams.getFrom()).setSize(esQueryParams.getSize()).addSort(SortBuilders.fieldSort(esQueryParams.getSort()).unmappedType("integer").order(SortOrder.DESC)).execute().actionGet(); // 分页排序所有
        long totalHits = sr.getHits().totalHits();
        esReturn.setTotal(totalHits);
        SearchHits hits = sr.getHits();
        List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
        for (SearchHit hit : hits) {
            Map<String, Object> map = (Map<String, Object>) hit.getSource();
            map.put(ESConstant.ES_ID_STRING, hit.getId());
            result.add(map);
        }
//        log.info("ES查询结果：" +esReturn.getTotal()+"条数据");
        esReturn.setData(result);
        return esReturn;
    }

    /**
     * @param index
     * @param type
     * @param jsonDoc json串数据  @author:shuyu.wang
     * @description:es查询封装
     * @date: 2018/5/22 18:22
     */
    @Override
    public Boolean updateES(String index, String type, String id, String jsonDoc) {
        Client client = clientHelper.getClient();
        BulkRequestBuilder prepareBulk = client.prepareBulk();
        UpdateResponse updateResponse = client.prepareUpdate(index, type, id).setDoc(jsonDoc, XContentType.JSON).get();
        RestStatus status = updateResponse.status();
        if (status.name().equals(ESConstant.OK_STRING)) {
//            log.info("處理狀態—————————" + status.name());
            return true;
        }
        return false;
    }
}


public class ESConstant {

    public static final String CLUSTER_NAME_STRING="cluster.name";

    public static final String CLIENT_TRANSPORT_SNIFF_STRING="client.transport.sniff";

    public static final String INDEX_NULL_STRING="索引不能为空！";

    public static final String TYPE_NULL_STRING="类型不能为空！";

    public static final String SORT_NULL_STRING="排序字段不能为空！";

    public static final String ES_ID_STRING="es_id";

    public static final String OK_STRING="OK";
}
@Data
public class ESReturn<T> {

    /**
     * @Field： Result data
     */
    private T data;
    /**
     * @Field：Total item size
     */
    private long total;

}
@Data
public class ESQueryParams {
    /**
    * @Field：索引
    */
    private String index;
    /**
     * @Field：类型
     */
    private String type;
    /**
     * @Field：完全匹配字段
     */
    private Map<String,String> terms;
    /**
     * @Field：完全不匹配字段
     */
    private Map<String,List<String>> noTermsList;
    /**
     * @Field：右模糊查询
     */
    private Map<String,String> rightWildcards;
    /**
     * @Field：完全模糊查询
     */
    private Map<String,String> allWildcards;
    /**
     * @Field：范围查询
     */
    private Map<String,RangeEntity> ranges;
    /**
     * @Field：一次匹配多个值
     */
    private Map<String,List<String>> termsList;
    /**
     * @Field：判断字段非空
     */
    private List<String> existsFiles=new ArrayList<String>();

    /**
     * @Field：排序字段
     */
    private String sort;
    /**
     * @Field：起始记录条数
     */
    private Integer from;
    /**
     * @Field：返回条数
     */
    private Integer size;

    public ESQueryParams() {
    }

    public ESQueryParams(String index, String type, String sort) {
        this.index = index;
        this.type = type;
        this.sort = sort;
    }

}
@Data
public class RangeEntity {
    private String from;
    private String to;
}

 

wang_shuyu
关注
专栏目录
【Springboot】| 从深入自动配置原理到实现 自定义Springboot starter
狮子也疯狂的博客
08-27 3494
是SpringBoot的一个重要概念，是“一站式服务 (one-stop)”的依赖 Jar 包包含 Spring 以及相关技术(比如 Redis)的所有依赖提供了自动配置的功能，开箱即用提供了良好的依赖管理，避免了包遗漏、版本冲突等问题。简单来说， Springboot starter 提供了一种自动配置的机制，我们只需要将需要的Starter引入项目中，它就会自动为我们配置相关的依赖和配置。这使得开发人员可以更加关注业务逻辑的实现；现在我们来学习一下它的原理，以便后面能更清晰地实现。这个技能对你有用么。
【SpringBoot】如何实现一个SpringBoot的starter
刷刷的破壳日常
11-20 1220
官网地址： 自动配置类可以捆绑在外部jar中，并依旧可以被Spring Boot获取。自动配置可以与一个“starter”相关联
Spring boot创建自定义starter的完整步骤
08-25
主要给大家介绍了关于Spring boot创建自定义starter的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Spring boot具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
SpringBoot自己开发一个starter
weixin_60523038的博客
07-11 1346
SpringBoot自己写一个Starter，SpringBoot
Druid-Spring-Boot-Starter 教程指南
最新发布
gitblog_00959的博客
08-18 408
Druid-Spring-Boot-Starter 教程指南 项目地址:https://gitcode.com/gh_mirrors/dr/druid-spring-boot 本教程将引导您了解并快速上手 Druid-Spring-Boot 这一项目，它旨在简化在Spring Boot应用中集成阿里巴巴的Druid数据连接池的过程。我们将逐一探索项目的结构、启动机制以及配置方法。 1. 项目目录结...
第三章 实现自己的Spring Boot Starter
u011909918的博客
11-19 454
文章目录前言一、properties和yml配置1.1 IDEA 中Spring Boot的的配置文件1.2 配置文件提示来源二、Starter结构2.1 Jar包结构2.1.1 官方starter - Thymeleaf2.1.1.1 starter2.1.1.2 autoconfigure2.1.2 非官方starter - Mybatis2.1.2.1 starter2.1.2.2 autoconfigure2.2 配置和代码实现（Mybatis为例）2.2.1 依赖配置2.2.2 propertie
实现springboot的starter
qq_43842093的博客
12-13 1537
什么是 Spring Boot Spring Boot 基本上是 Spring 框架的扩展，它消除了设置 Spring 应用程序所需的复杂例行配置。我们在使用 Spring 框架的时候，我们接触得比较多的应该是 Spring MVC、 IOC 、 DI 、AOP 等等，而这些框架在使用的过程中会需要配置大量的 XML，或者需要做很多繁琐的配置。Spring Boot 可以帮助我们快速搭建一个基于 Spirng 框架以及 Spring 生态体系的应用解决方案。 创建独立的 Spring 应用程序 直接嵌入
【Spring Boot】Spring Boot 中的 Starter
书山有路，学海无涯。记录成长，追逐梦想
05-12 4791
Spring Boot 为了简化配置，提供了非常多的 Starter。它先打包好与常用模块相关的所有 JAR 包，并完成自动配置，然后组装成 Starter（如把 Web 相关的 Spring MVC、容器等打包好后组装成 spring-boot-starter-web）。这使得在开发业务代码时不需要过多关注框架的配置，只需关注业务逻辑即可。
SpringBoot Starter模板
11-26
SpringBoot Starter模板是Spring Boot框架中的一个重要组成部分，它旨在简化应用程序的初始搭建和配置过程。Spring Boot通过Starters提供了一种“开箱即用”的体验，使得开发者可以快速地构建基于Spring的应用。在这...
springboot starter实现包
12-31
SpringBoot Starter实现包是SpringBoot框架的核心特性之一，它提供了一种简化Spring应用程序初始搭建以及开发过程的方法。Starter是SpringBoot预配置的模块集合，包含了一系列相关依赖和配置，帮助开发者快速上手并...
SpringBoot封装自己的Starter的实现方法
08-26
SpringBoot封装自己的Starter实现方法 SpringBoot是一款基于Java的开源框架，提供了丰富的starter来帮助开发者快速构建项目。其中，starter是SpringBoot的核心组件之一，提供了默认的配置和功能，帮助开发者快速...
实现一个自己的springboot starter
quietKim的博客
07-03 270
一、为什么需要自定义starter 在我们日常开发中，通常会有一些独立于业务之外的公共功能模块，例如：数据字典、可配置的实时生效的系统参数等。多个模块都需要复用这块功能，如果每个模块硬核拷贝代码和对应的依赖去集成，麻烦至极。这个时候只需要把独立的复用的这个模块做成一个starter，需要使用的直接引入依赖，这样极大的简化了集成的工作量，也可以做到统一维护。 二、starter是如何自动装配到项目中的呢 可以在SpringFactoriesLoader这个类的loadSp...
手把手教你实现自定义 Spring Boot 的 Starter
骏马逸动，心随你动的博客
06-30 531
引言 上篇文章《天天用SpringBoot，它的自动装配原理却说不出来》我们有说springBoot的自动装配怎么实现的（建议最好先看下篇文章，因为前后有关系），这篇文章的话我们就自己来实现一个SpringBoot的 starter吧。废话不多说我们还是直入主题吧。 什么是Spring Boot Starter呢?我们直接来看看官网是怎么介绍的吧。 ❝ Starters are a set of convenient dependency descriptors that you can in
自己实现一个Starter
creaylei的小花园
11-05 2371
SpringBoot自动配置中Starter的原理，自己实现一个，测试用例
【SpringBoot框架篇】8.搭建自己的spring-boot-starter
皓亮君的博客
05-19 3094
文章目录简述创建starter服务引入构建starter的核心依赖创建配置类封装服务提供者注册Bean对象暴露需要被装配的类发布jar包到本地仓库引入我的my-spring-boot-starter依赖引入依赖修改配置文件启动程序 简述 我们可以认为starter是一种服务,在使用某个功能的开发者不需要关注各种依赖库的处理，不需要具体的配置信息，由Spring Boot自动注入的bean。 我们在开发springboot项目的时候,经常会引用spring-boot-starter-web,spring-bo
SpringBoot-创建自己的Starter
雨后是冰雹
12-20 805
创建自己的Starter自定义starter1. 创建一个空的 maven 项目，并引入依赖2. 创建配置属性类3. 创建服务类4. 创建自动配置类5. 创建 META-INF/spring.factories测试Starter springboot 官方提供了很多 starter 来实现自动配置，简化我们的开发，那么我们能不能把自己常用的一些组件也封装成一个starter来实现自动化配置呢？答案是可以的。 自定义starter 1. 创建一个空的 maven 项目，并引入依赖 <dependenci
如何自己实现一个Spring Boot Starter
如无必要勿增实体
01-21 1717
使用AOP实现拦截方法执行和打印日志的功能import org} }} }} }} }如果我们需要从 application.yaml 或 application.properties 中拿到一些使用者配置的数据，那么我们就需要定义一个properties类。
手把手教你开发SpringBoot starter
u010720120的博客
06-04 594
前言： SpringBoot在java中的地位简直是至尊的存在，非常的好用。Spring Boot有四大神器，分别是auto-configuration、starters、cli、actuator，我们用各种中间件的话就是各种starter 对应版本依赖引用，然后就是配置属性文件，就可以用了，其实工作当中，我们可以把一些通用的方法，服务来封装成starter，本文来交大家进行手动实现一个starter，满足我们以后工作的需要。 1.源码中的starter和自动配置： Spring boot开发的时候我们不需
自定义创建springBoot starter
csdn_tiger1993的博客
07-30 238
平时我们在工作中总会写一些非业务相关的公共代码，这些公共代码通常会单独放置到一个模块中，在使用springBoot进行开发时，spring团队为我们提供了许多开箱即用的starter，那么怎么创建一个自己的starter，将这些公共的非业务代码封装起来呢。...
自定义SpringBoot Starter教程
"本文将介绍如何在SpringBoot中封装自己的Starter，以便于在不同的项目中复用，降低项目的配置复杂度。我们将以一个短信业务的实现为例，讲解创建自定义Starter的步骤和注意事项。" SpringBoot封装自己的Starter是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值