jackjack_abc
jackjack_abc

Spring Boot集成ES7.10

    在Spring boot中主要有Java REST Client、spring-data-elasticsearch两种方式，这里建议使用Elasticsearch官方提供的Java High Level REST Client来集成。

一：导入依赖：


    org.elasticsearch.client
    elasticsearch-rest-high-level-client
    7.10.2


    org.elasticsearch
    elasticsearch
    7.10.2

创建es映射

PUT user_index
{
	"settings":{
	"number_of_shards": "3",
	"number_of_replicas": "0"
	},
  	"mappings": {
  		"properties":{
			"age" : {
			  "type" : "short"
			},
			"createTime" : {
			  "type" : "long"
			},
			"id" : {
			  "type" : "integer"
			},
			"updateTime" : {
			  "type" : "long"
			},
			"userName" : {
			  "type" : "text",
			  "fields" : {
				"keyword" : {
				  "type" : "keyword"
				}
			  }
			}
		}
  	}
}

二：初始化客户端

1，添加配置文件添加连接信息

elasticsearch:
  host: 127.0.0.1:9200
  port: 9200
  connTimeout: 3000
  socketTimeout: 5000
  connectionRequestTimeout: 1000
  username: elastic
  password: 123456

2，添加ES配置类

import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.StringUtils;

/**
 * @date 2022/7/15
 **/
@Configuration
public class ElasticsearchConfiguration {

    @Value("${elasticsearch.host}")
    private String host;

    @Value("${elasticsearch.port}")
    private Integer port;

    @Value("${elasticsearch.connTimeout}")
    private Integer connTimeout;

    @Value("${elasticsearch.socketTimeout}")
    private Integer socketTimeout;

    @Value("${elasticsearch.connectionRequestTimeout}")
    private Integer connectionRequestTimeout;

    @Value("${elasticsearch.username}")
    private String username;

    @Value("${elasticsearch.password}")
    private String password;

    @Bean(destroyMethod = "close", name = "client")
    public RestHighLevelClient initRestClient() {
        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(username, password));

        RestClientBuilder builder = RestClient.builder(toHttpHost())
                .setRequestConfigCallback(requestConfigBuilder ->
                        requestConfigBuilder.setConnectTimeout(connTimeout)
                                .setSocketTimeout(socketTimeout)
                                .setConnectionRequestTimeout(connectionRequestTimeout))
                                .setHttpClientConfigCallback(h -> h.setDefaultCredentialsProvider(credentialsProvider));
        return new RestHighLevelClient(builder);
    }


    /**
     * 解析配置的字符串，转为HttpHost对象数组
     */
    private HttpHost[] toHttpHost() {
        if (!StringUtils.hasLength(host)) {
            throw new RuntimeException("invalid elasticsearch configuration");
        }

        String[] hostArray = host.split(",");
        HttpHost[] httpHosts = new HttpHost[hostArray.length];
        HttpHost httpHost;
        for (int i = 0; i < hostArray.length; i++) {
            String[] strings = hostArray[i].split(":");
            httpHost = new HttpHost(strings[0], Integer.parseInt(strings[1]), "http");
            httpHosts[i] = httpHost;
        }
        return httpHosts;
    }
}

三，springboot api封装

@Component
public class EsUtil {

    @Resource
    private RestHighLevelClient restHighLevelClient;

    /**
     * 创建索引
     */
    @SneakyThrows
    public Boolean createIndex(String indexName) {
        CreateIndexRequest request = new CreateIndexRequest(indexName);
        // request.settings()  可以设置分片规则
        // request.mapping() 可以设置映射字段
        CreateIndexResponse indexResponse = restHighLevelClient.indices().create(request, RequestOptions.DEFAULT);
        return indexResponse.isAcknowledged();
    }

    /**
     * 查询索引  * 查询全部
     */
    @SneakyThrows
    public List searchIndex(String indexName) {
        GetIndexRequest request = new GetIndexRequest(indexName);
        boolean exists = restHighLevelClient.indices().exists(request, RequestOptions.DEFAULT);
        if (!exists) {
            return Lists.newArrayList();
        }
        GetIndexResponse getIndexResponse = restHighLevelClient.indices().get(request, RequestOptions.DEFAULT);
        return Lists.newArrayList(getIndexResponse.getIndices());
    }

    /**
     * 删除索引
     */
    @SneakyThrows
    public Boolean deleteIndex(String indexName) {
        GetIndexRequest getIndexRequest = new GetIndexRequest(indexName);
        boolean exists = restHighLevelClient.indices().exists(getIndexRequest, RequestOptions.DEFAULT);
        if (!exists) {
            return false;
        }
        DeleteIndexRequest request = new DeleteIndexRequest(indexName);
        AcknowledgedResponse response = restHighLevelClient.indices().delete(request, RequestOptions.DEFAULT);
        return response.isAcknowledged();
    }


    /**
     * 文档数据插入(插入前会自动生成index)
     * source()  支持json map 键值对等形式
     */
    @SneakyThrows
    public String insert(String indexName, String id, String jsonStr) {
        IndexRequest indexRequest = new IndexRequest(indexName);
        // 不设置id 会自动使用es默认的
        if (StrUtil.isNotBlank(id)) {
            indexRequest.id(id);
        }
        indexRequest.source(jsonStr, XContentType.JSON);
        IndexResponse indexResponse = restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);
        return indexResponse.getId();
    }

    /**
     * 批量插入数据
     * map {id, json}
     */
    @SneakyThrows
    public BulkResponse insertBatch(String indexName, Map valueMap) {
        BulkRequest bulkRequest = new BulkRequest();
        Set keySet = valueMap.keySet();
        for (String id : keySet) {
            IndexRequest request = new IndexRequest(indexName).id(id).source(valueMap.get(id), XContentType.JSON);
            bulkRequest.add(request);
        }
        return restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
    }

    /**
     * 更新- es有则更新，无则写入
     * 可以接受 String、Map、XContentBuilder 或 Object 键对
     */
    @SneakyThrows
    public String update(String indexName, String id, String jsonStr) {
        String searchById = searchById(indexName, id);
        if (StrUtil.isBlank(searchById)) {
            return null;
        }
        UpdateRequest updateRequest = new UpdateRequest(indexName, id).doc(jsonStr, XContentType.JSON);
        UpdateResponse update = restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);
        return update.getId();
    }

    /**
     * 根据id进行删除
     */
    @SneakyThrows
    public String delete(String indexName, String id) {
        DeleteRequest deleteRequest = new DeleteRequest(indexName, id);
        DeleteResponse delete = restHighLevelClient.delete(deleteRequest, RequestOptions.DEFAULT);
        return delete.getId();
    }

    /**
     * 根据id进行删除
     */
    @SneakyThrows
    public List deleteBatch(String indexName, List ids) {
        List deleteList = Lists.newArrayList();
        if (CollectionUtil.isEmpty(ids)) {
            return deleteList;
        }
        for (String id : ids) {
            DeleteRequest deleteRequest = new DeleteRequest(indexName, id);
            deleteList.add(restHighLevelClient.delete(deleteRequest, RequestOptions.DEFAULT).getId());
        }
        return deleteList;
    }

    /**
     * 根据id进行查询
     */
    @SneakyThrows
    public String searchById(String indexName, String id) {
        GetRequest getRequest = new GetRequest(indexName, id);
        GetResponse getResponse = restHighLevelClient.get(getRequest, RequestOptions.DEFAULT);
        return getResponse.getSourceAsString();
    }

    /**
     * 根据QueryBuilder来查询全部的条数
     */
    @SneakyThrows
    public Long findTotal(String indexName, QueryBuilder builder) {
        SearchRequest searchRequest = new SearchRequest(indexName);
        searchRequest.source().query(builder);
        SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        return response.getHits().getTotalHits().value;
    }

    /**
     * 1, id查询: QueryBuilders.idsQuery().ids(id)
     *    精确查询 QueryBuilders.termQuery("userName.keyword", "王五")  .keyword 值是中文时需要，非中文时不需要
     *    范围查询：QueryBuilders.rangeQuery().form().to().includeLower(false).includeUpper(false) 默认是true包含头尾，设置false去掉头尾
     *    匹配所有：QueryBuilders.matchAllQuery()
     *    模糊查询：QueryBuilders.fuzzyQuery()
     *    全文检索，会进行分词,多个字段检索：QueryBuilders.multiMatchQuery("kimchy", "name", "description") 查询name或description包含kimchy
     *    全文检索，会进行分词,单字段检索：QueryBuilders.matchQuery(name", "kimchy") 查询name包含kimchy
     *    通配符查询, 支持*，匹配任何字符序列, 包括空，避免* 开始 QueryBuilders.wildcardQuery("user", "ki*hy")
     *    跨度查询：QueryBuilders.span………
     * 2，组合查询:BoolQueryBuilder  must：and  mustNot:not  should:or  in：termsQuery传list
     *    QueryBuilders.boolQuery().must(QueryBuilders.termsQuery("name", Lists.newArrayList())).mustNot(QueryBuilders.……);
     *    过滤器查询：在原本查询结果的基础上对数据进行筛选，不会计算分值,所以效率比must更高
     *    QueryBuilders.boolQuery().filter(QueryBuilders.termQuery("userName", "王五"))
     * 3, 查询部分字段: SearchSourceBuilder().fetchSource(new String[]{"userName", "age"}, new String[]{}) 查询userName和age字段
     * 4, 权重计算，权重越高月靠前:  给name精确查询提高权重为2 QueryBuilders.termQuery("name", "kimchy").boost(2.0f)
     *    高于设定分数, 不计算相关性查询: QueryBuilders.constantScoreQuery(QueryBuilders.termQuery("name", "kimchy")).boost(2.0f);
     * 5，Nested&Join父子类型：得检索效率慢，不建议在ES做Join操作
     *    父子查询：QueryBuilders.hasChildQuery("tweet", QueryBuilders.termQuery("user", "kimchy")).scoreMode("max")
     *    嵌套查询, 内嵌文档查询 QueryBuilders.nestedQuery("location", QueryBuilders.boolQuery()
     *    .must(QueryBuilders.matchQuery("location.lat", 0.962590433140581))
     *    .must(QueryBuilders.rangeQuery("location.lon").lt(36.0000).gt(0.000))).scoreMode("total")
     * 6, 排序：在查询的结果上进行二次排序，date、float 等类型添加排序，text类型的字段不允许排序 SearchSourceBuilder.sort()
     */
    @SneakyThrows
    public List> findAll(String indexName, QueryBuilder builder) {
        // 设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder()
                .query(builder)
                .fetchSource(new String[]{"userName", "age"}, new String[]{});
        SearchRequest request = new SearchRequest(indexName).source(searchSourceBuilder);
        SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
        return handleResponse(response, 0, 0).getRecords();
    }

    /**
     * 1，from-size浅分页适合数据量不大的情况（官网推荐是数据少于10000条），可以跳码进行查询
     * 2，scroll 是一种滚屏形式的分页检索，scroll查询是很耗性能的方式，不建议在实时查询中运用
     */
    @SneakyThrows
    public P> fromSizePage(String indexName, QueryBuilder queryBuilder, BasePageForm basePageForm) {
        int from = basePageForm.getPageSize() * (basePageForm.getPageNum() - 1);
        // 构建分页搜寻器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(queryBuilder)
                .from(from)
                .size(basePageForm.getPageSize());
        if (StrUtil.isNotBlank(basePageForm.getOrderBy())) {
            sourceBuilder.sort(basePageForm.getOrderBy(), basePageForm.getOrderType() ? SortOrder.ASC : SortOrder.DESC);
        }
        SearchRequest request = new SearchRequest(indexName).source(sourceBuilder);
        SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
        return handleResponse(response, basePageForm.getPageNum(), basePageForm.getPageSize());
    }

    /**
     * 分页返回值处理
     */
    @SneakyThrows
    private P> handleResponse(SearchResponse response, int pageNum, int pageSize) {
        SearchHit[] hits = response.getHits().getHits();
        List> result = Arrays.stream(hits).map(h -> {
            Map sourceAsMap = h.getSourceAsMap();
            sourceAsMap.put("id", h.getId());
            return sourceAsMap;
        }).collect(Collectors.toList());
        return new P<>(result, response.getHits().getTotalHits().value, pageSize, pageNum);
    }

    /**
     * search_after 适用于深度分页+ 排序，分页是根据上一页最后一条数据来定位下一页的位置，所以无法跳页请求，性能最好
     */
    @SneakyThrows
    public P> searchAfterPage(String indexName, QueryBuilder queryBuilder, BasePageForm basePageForm) {
        // 构建分页搜寻器
        // searchAfter需要将from设置为0或-1，当然也可以不写

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(queryBuilder)
                .from(0)
                .size(basePageForm.getPageSize());
        if (StrUtil.isNotBlank(basePageForm.getOrderBy())) {
            sourceBuilder.sort(basePageForm.getOrderBy(), basePageForm.getOrderType() ? SortOrder.ASC : SortOrder.DESC);
        }
        if (null != basePageForm.getSortCursor() && basePageForm.getSortCursor().length > 0) {
            sourceBuilder.searchAfter(basePageForm.getSortCursor());
        }
        SearchRequest request = new SearchRequest(indexName).source(sourceBuilder);
        SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
        SearchHit[] hits = response.getHits().getHits();
        Object[] sortCursor = hits[hits.length - 1].getSortValues();
        P> page = handleResponse(response, basePageForm.getPageNum(), basePageForm.getPageSize());
        page.setSortCursor(sortCursor);
        return page;
    }

    /**
     * moreLikeThisQuery: 实现基于内容推荐, 支持实现一句话相似文章查询
     * percent_terms_to_match：匹配项（term）的百分比，默认是0.3
     * min_term_freq：一篇文档中一个词语至少出现次数，小于这个值的词将被忽略，默认是2
     * max_query_terms：一条查询语句中允许最多查询词语的个数，默认是25
     * stop_words：设置停止词，匹配时会忽略停止词
     * min_doc_freq：一个词语最少在多少篇文档中出现，小于这个值的词会将被忽略，默认是无限制
     * max_doc_freq：一个词语最多在多少篇文档中出现，大于这个值的词会将被忽略，默认是无限制
     * min_word_len：最小的词语长度，默认是0
     * max_word_len：最多的词语长度，默认无限制
     * boost_terms：设置词语权重，默认是1
     * boost：设置查询权重，默认是1
     * analyzer：设置使用的分词器，默认是使用该字段指定的分词器
     */
    public List> moreLikeThisQuery(String indexName) {
        QueryBuilder queryBuilder = QueryBuilders.moreLikeThisQuery(new String[]{"王"})
                .minTermFreq(1).maxQueryTerms(3);
        return findAll(indexName, queryBuilder);
    }

    /**
     * 聚合查询: todo 字段类型是text就不支持聚合排序
     * 桶（bucket）: 满足特定条件的文档的集合  GROUP BY userName
     * 指标（metric）: 对桶内的文档进行聚合分析的操作 COUNT(userName)
     * select age, createTime, SUM(age), AVG(age),MIN(age),COUNT(age) from user_index GROUP BY age, createTime
     */
    @SneakyThrows
    public List aggregateQuery(String indexName, List fieldList, TermsAggregationBuilder aggregation) {
        if (CollectionUtil.isEmpty(fieldList)) {
            return Lists.newArrayList();
        }
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder().aggregation(aggregation);
        SearchRequest request = new SearchRequest(indexName).source(searchSourceBuilder);
        SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
        return handleResult(response);
    }

    /**
     * 对聚合结果进行封装
     */
    private static List handleResult(SearchResponse agg){
        Map aggregations = agg.getAggregations().asMap();
        List objects = Lists.newArrayList();
        // 第一层分组统计
        aggregations.forEach((k,v) -> {
            Map group = Maps.newHashMap();
            parseAggs(k, v, group, objects);
        });
        return objects;
    }

    /**
     * 解析聚合结果
     */
    private static void parseAggs(String key, Aggregation value, Map group, List objects){
        if (value instanceof Terms){
            for (Terms.Bucket bucket:((Terms) value).getBuckets() ){
                Set> entries = bucket.getAggregations().asMap().entrySet();
                group.put(key, bucket.getKeyAsString());
                for (Map.Entry entry : entries) {
                    if (entry.getValue() instanceof Terms){
                        parseAggs(entry.getKey(), entry.getValue(), group, objects);
                    } else {
                        LinkedHashMap map = new LinkedHashMap<>();
                        bucket.getAggregations().asMap().forEach((k2, v2)  -> map.put(k2, getValue(v2)));
                        map.putAll(group);
                        objects.add(map);
                        break;
                    }
                }
            }
        }
    }

    /**
     * 取值
     */
    private static String getValue(Aggregation agg) {
        switch (agg.getType()) {
            case "avg":
                return String.valueOf(((Avg) agg).getValue());
            case "sum":
                return String.valueOf(((Sum) agg).getValue());
            case "value_count":
                return String.valueOf(((ValueCount) agg).getValue());
            case "min":
                return String.valueOf(((Min) agg).getValue());
            case "max":
                return String.valueOf(((Max) agg).getValue());
            case "cardinality":
                return String.valueOf(((Cardinality) agg).getValue());
            default:
                return String.valueOf(agg);
        }
    }

基础的分页参数


@Data
@ApiModel("基础分页信息 BasePageForm")
public class BasePageForm {
    
    @ApiModelProperty(value = "页条数", example = "20")
    private int pageSize = 20;
    
    @ApiModelProperty(value = "第几页", example = "1")
    private int pageNum = 1;
    
    @ApiModelProperty(value = "排序字段: 可选: 不同列表排序不同需再协商", example = "")
    private String orderBy;

    @ApiModelProperty(value = "排序规则 true升序 false降序")
    private Boolean orderType = false;

    @ApiModelProperty("排序游标")
    private Object[] sortCursor;
    
    @ApiModelProperty("查询所有: 默认查询今日及所有未审核单子")
    private boolean isAll = false;
}


封装的分页返回对象


@Data
@ApiModel("分页查询: P")
public class P {
    
    @ApiModelProperty("当前页数据")
    private List records;
    
    @ApiModelProperty("总条数")
    private long total;
    
    @ApiModelProperty("每页条数")
    private long size;
    
    @ApiModelProperty("第几页")
    private long current;

    @ApiModelProperty("sortCursor 游标")
    private Object[] sortCursor;
    
    public P(List records, long total, long size, long current) {
        this.records = records;
        this.total   = total;
        this.size    = size;
        this.current = current;
    }
    
    public P(List records, Page page) {
        this.records = records;
        this.total   = page.getTotal();
        this.size    = page.getSize();
        this.current = page.getCurrent();
    }
    
    public static P of(List records, Page page) {
        return new P(records, page);
    }
    
    public static  P of(Page page) {
        return new P<>(page.getRecords(), page);
    }
}


四：测试


/**
 * es官方文档：https://www.elastic.co/guide/en/elasticsearch/client/java-rest/7.10/java-rest-high-supported-apis.html
 * @author Gordon
 * @date 2022/7/15
 **/
@Api(tags = "es基本用法测试")
@RequestMapping("/ceshi")
@RestController
@Slf4j
public class TestController {

    private static String indexName = "user_index";

    @Resource
    private EsUtil esUtil;

    @ApiOperation(value = "创建索引")
    @GetMapping("/createIndex")
    public Boolean create(@RequestParam("indexName") String indexName) {
        return esUtil.createIndex(indexName);
    }

    @ApiOperation(value = "查询索引 * 查询全部")
    @GetMapping("searchIndex")
    public List searchIndex(@RequestParam("indexName") String indexName) {
        return esUtil.searchIndex(indexName);
    }

    @ApiOperation(value = "删除索引")
    @GetMapping("deleteIndex")

    public Boolean deleteIndex(@RequestParam("indexName") String indexName) {
        return esUtil.deleteIndex(indexName);
    }


    @ApiOperation(value = "插入文档")
    @GetMapping("insert")
    public String insert(@RequestParam("id") String id) {
        User user = new User().setUserName("张三").setAge(22).setCreateTime(System.currentTimeMillis());
        return esUtil.insert(indexName, id, JSON.toJSONString(user));
    }

    @ApiOperation(value = "批量插入")
    @GetMapping("insertBatch")
    public BulkResponse insertBatch() {
        Map build = new ImmutableMap.Builder()
                .put("1", JSON.toJSONString(new User().setCreateTime(System.currentTimeMillis()).setUserName("张三").setAge(22)))
                .put("2", JSON.toJSONString(new User().setCreateTime(System.currentTimeMillis() + 10000).setUserName("王五").setAge(23)))
                .put("3", JSON.toJSONString(new User().setCreateTime(System.currentTimeMillis() + 20000).setUserName("张三").setAge(25)))
                .put("4", JSON.toJSONString(new User().setCreateTime(System.currentTimeMillis() + 30000).setUserName("王五").setAge(26)))
                .put("5", JSON.toJSONString(new User().setCreateTime(System.currentTimeMillis() + 40000).setUserName("张三").setAge(28)))
                .put("6", JSON.toJSONString(new User().setCreateTime(System.currentTimeMillis() + 50000).setUserName("王五").setAge(27)))
                .put("7", JSON.toJSONString(new User().setCreateTime(System.currentTimeMillis() + 60000).setUserName("张三").setAge(24)))
                .put("8", JSON.toJSONString(new User().setCreateTime(System.currentTimeMillis() + 70000).setUserName("王五").setAge(22)))
                .put("9", JSON.toJSONString(new User().setCreateTime(System.currentTimeMillis() + 80000).setUserName("张三").setAge(23)))
                .put("10", JSON.toJSONString(new User().setCreateTime(System.currentTimeMillis() + 90000).setUserName("王五").setAge(23)))
                .build();
        return esUtil.insertBatch(indexName, build);
    }

    @ApiOperation(value = "文档id 更新文档")
    @GetMapping("update")
    public String update(@RequestParam("id") String id) {
        User user = new User().setUserName("李五").setUpdateTime(System.currentTimeMillis());
        return esUtil.update(indexName, id, JSON.toJSONString(user));
    }

    @ApiOperation(value = "批更新")
    @GetMapping("updateBatch")
    public BulkResponse updateBatch() {
        Map build = new ImmutableMap.Builder()
                .put("2", JSON.toJSONString(new User().setUserName("张四").setUpdateTime(System.currentTimeMillis())))
                .put("3", JSON.toJSONString(new User().setUserName("张五").setUpdateTime(System.currentTimeMillis())))
                .build();
        return esUtil.insertBatch(indexName, build);
    }

    @ApiOperation(value = "文档id 删除文档")
    @GetMapping("delete")
    public String delete(@RequestParam("id") String id) {
        return esUtil.delete(indexName, id);
    }

    @ApiOperation(value = "批量删除文档")
    @GetMapping("deleteBatch")
    public List deleteBatch(@RequestParam("ids") List ids) {
        return esUtil.deleteBatch(indexName, ids);
    }

    @ApiOperation(value = "文档id 查询文档")
    @GetMapping("searchById")
    public String searchById(@RequestParam("id") String id) {
        return esUtil.searchById(indexName, id);
    }

    @ApiOperation(value = "查询全部的条数")
    @GetMapping("findTotal")
    public Long findTotal() {
        TermQueryBuilder queryBuilder = QueryBuilders.termQuery("userName.keyword", "王五");
        return esUtil.findTotal(indexName, queryBuilder);
    }

    @ApiOperation(value = "组合QueryBuilder 进行查询")
    @GetMapping("findAll")
    public List> findAll() {
        QueryBuilder queryBuilder = QueryBuilders.boolQuery()
                .must(QueryBuilders.fuzzyQuery("userName.keyword", "李四"));
        return esUtil.findAll(indexName, queryBuilder);
    }

    @ApiOperation(value = "分页查询文档")
    @PostMapping("fromSizePage")
    public P> fromSizePage(@RequestBody BasePageForm basePageForm) {
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("userName.keyword", "王五");
        return esUtil.fromSizePage(indexName, termQueryBuilder, basePageForm);
    }

    @ApiOperation(value = "分页查询文档")
    @PostMapping("searchAfterPage")
    public P> searchAfterPage(@RequestBody BasePageForm basePageForm) {
        RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery("createTime")
                .from("1660634673318").to("1660634713318");
        return esUtil.searchAfterPage(indexName, rangeQueryBuilder, basePageForm);
    }

    @ApiOperation(value = "单字段聚合查询")
    @GetMapping("sinFieldsAggregateQuery")
    public List sinFieldsAggregateQuery() {
        // 需要分组的字段，可以随意指定
        List fieldList = Lists.newArrayList("age");
        TermsAggregationBuilder termsAge = AggregationBuilders.terms(fieldList.get(0)).field(fieldList.get(0))
                .subAggregation(AggregationBuilders.avg("avg").field(fieldList.get(0)))
                .subAggregation(AggregationBuilders.sum("sum").field(fieldList.get(0)))
                .subAggregation(AggregationBuilders.min("min").field(fieldList.get(0)))
                .subAggregation(AggregationBuilders.count("count").field(fieldList.get(0)))
                .subAggregation(AggregationBuilders.cardinality("cardinality").field(fieldList.get(0)));
        return esUtil.aggregateQuery(indexName, fieldList, termsAge);
    }

    @ApiOperation(value = "多字段聚合查询")
    @GetMapping("multipleFieldsAggregateQuery")
    public List multipleFieldsAggregateQuery() {
        // 需要分组的字段，可以随意指定
        List fieldList = Lists.newArrayList("age", "createTime");
        TermsAggregationBuilder termsAge = AggregationBuilders.terms(fieldList.get(0)).field(fieldList.get(0));
        TermsAggregationBuilder termsCreateTime = AggregationBuilders.terms(fieldList.get(1)).field(fieldList.get(1))
                .subAggregation(AggregationBuilders.avg("avg").field(fieldList.get(0)))
                .subAggregation(AggregationBuilders.sum("sum").field(fieldList.get(0)))
                .subAggregation(AggregationBuilders.min("min").field(fieldList.get(0)))
                .subAggregation(AggregationBuilders.count("count").field(fieldList.get(0)))
                .subAggregation(AggregationBuilders.cardinality("cardinality").field(fieldList.get(0)));
        return esUtil.aggregateQuery(indexName, fieldList, termsAge.subAggregation(termsCreateTime));
    }
}

 五：如何修改es字段类型，比如之前是text,现在要改成 keyword


创建新索引
PUT user_index1
{
  "mappings" : {
      "properties" : {
        "age" : {
          "type" : "short"
        },
        "createTime" : {
          "type" : "long"
        },
        "id" : {
          "type" : "integer"
        },
        "updateTime" : {
          "type" : "long"
        },
        "userName" : {
          "type" : "keyword"
        }
      }
    }
}
同步数据到新索引
POST _reindex                    
{
  "source": {
    "index": "user_index"
  },
  "dest": {
    "index": "user_index1"
  }
}
删除旧索引
DELETE user_index
创建旧索引
PUT user_index
{
  "mappings" : {
      "properties" : {
        "age" : {
          "type" : "short"
        },
        "createTime" : {
          "type" : "long"
        },
        "id" : {
          "type" : "integer"
        },
        "updateTime" : {
          "type" : "long"
        },
        "userName" : {
          "type" : "keyword"
        }
      }
    }
}
同步数据到旧索引
POST _reindex                    
{
  "source": {
    "index": "user_index1"
  },
  "dest": {
    "index": "user_index"
  }
}
删除新索引
DELETE user_index1



























你可能感兴趣的:(工具类,spring,boot,elasticsearch,java)






    

  • ReactiveRedisTemplate自动配置定义和序列化方式选择spring-data-redis
简放视野
Spring-Boot工作实战总结Redisspringbootjavaredis

    背景Spring-Boot的Redis自动配置类，RedisReactiveAutoConfiguration和RedisAutoConfiguration，组件ReactiveRedisTemplate和RedisTemplate默认使用JDK序列化方式，在现实业务场景中很难使用，其存储的值可读性差且又长。我觉得不是很合理，意味着使用它们的用户都需要自己重新自定义。ReactiveStringR
    

    • 

  • Python字符串的切片运算操作
MG_鹏鹏
Python学习笔记python开发语言

    Python语言的字符串切片运算功能类比于Java等语言的字符串截取函数要简洁方使很多，使用起来很是顺手。一、语法格式：Python对字符的中的元素或者子串的访问使用方括号[]，类似于Java中的数组，但又青出于蓝而胜于蓝，通过索引值（下标）和：符灵活配合。格式：变量名[始下标：终下标：步长]其中始下标可以是0即从左往左开始，也可以是-1从右往左开始详见下图：从左往右01234567从右往左-8-
    

    • 

  • 基于Java毕业设计新锐台球厅管理系统源码+系统+mysql+lw文档+部署软件
练练科技
java课程设计mysql

    基于Java毕业设计新锐台球厅管理系统源码+系统+mysql+lw文档+部署软件基于Java毕业设计新锐台球厅管理系统源码+系统+mysql+lw文档+部署软件本源码技术栈：项目架构：B/S架构开发语言：Java语言开发软件：ideaeclipse前端技术：Layui、HTML、CSS、JS、JQuery等技术后端技术：JAVA运行环境：Win10、JDK1.8数据库：MySQL5.7/8.0源码
    

    • 

  • export default vs module.exports：JavaScript 模块导出的双雄对决
正小安
vue杂谈前端javascriptecmascript

    exportdefaultvsmodule.exports：JavaScript模块导出的双雄对决在JavaScript的模块化编程中，exportdefault和module.exports是两种不可或缺的语法，它们分别代表了ES6模块系统（也称为ES2015模块或ES6模块）和CommonJS模块系统的核心导出机制。了解它们之间的区别与联系，对于编写可维护、跨平台兼容的JavaScript代码
    

    • 

  • SprinBoot+Vue远程教育网站的设计与实现
赵广陆
projectvue.js前端javascript

    目录1项目介绍2项目截图3核心代码3.1Controller3.2Service3.3Dao3.4application.yml3.5SpringbootApplication3.5Vue4数据库表设计5文档参考6计算机毕设选题推荐7源码获取1项目介绍博主个人介绍：CSDN认证博客专家，CSDN平台Java领域优质创作者，全网30w+粉丝，超300w访问量，专注于大学生项目实战开发、讲解和答疑辅导
    

    • 

  • Maven坐标查找方法及Maven-Search 插件的使用（保姆级教学）
几分醉意.
IDEA插件Mavenmavenjavaintellij-idea

    目录坐标的概念获取坐标方法一获取坐标方法二坐标的概念坐标组成是groupid,artifiactld,version。坐标概念来自数学。坐标作用:确定资源的，是资源的唯一标识。在maven中，每个资源都有坐标。坐标值是唯一的。简称叫gav。拿servlet依赖举例javax.servlet<
    

    • 

  • Java基础——深入理解Java中的多线程（超级详细，值得你看）
2401_84558508
作者\/java开发语言

    开发中优先选择实现Runnable方式原因：实现的方式没有类的单继承性的局限性实现的方式更适合来处理多个线程共享数据的情况相同点：都需要重写run()，将线程要执行的代码声明在run()方法中线程的生命周期解决线程安全问题；使用同步代码块packagecom.haust.java;/*出现线程安全问他的解决方法：当一个线程a在操作ticket的时候，其他线程不能参与进来，直到线程参与进来，也操作完
    

    • 

  • 用JavaScript写一个简单的9*9乘法表
迷雾yx
javascript开发语言ecmascript

    Documentspan{width:80px;padding:5px10px;display:inline-block;/*可以使行内元素表现得像块级元素一样*/text-align:center;/*文本居中*/border:1pxsolidturquoise;margin:2px;/*每个边框之间距离为2px*/border-radius:10px;/*边框圆润*/box-shadow:6p
    

    • 

  • How can I load the openai api configuration through js in html?
营赢盈英
AIaipythonjavascripthtmlnode.jsopenai

    题意：怎样在HTML中通过JavaScript加载OpenAIAPI配置问题背景：Iamtryingtosendarequestthroughjsinmyhtmlsothatopenaianalyzesitandsendsaresponse,butifinthejsIputthefollowing:我正在尝试通过HTML中的JavaScript发送一个请求，以便让OpenAI分析它并发送响应，但如
    

    • 

  • Spring Cloud Gateway：现代微服务架构中的API网关解决方案
鹿又笑
架构微服务springcloudgateway

    引言在微服务架构中，API网关作为客户端与后端服务之间的中介，承担着请求路由、负载均衡、认证授权等重要职责。SpringCloudGateway是Spring生态系统中的一款强大且灵活的API网关解决方案，本文将深入探讨其工作原理、核心功能及应用场景。什么是SpringCloudGateway？SpringCloudGateway是SpringCloud项目的一部分，旨在为微服务架构提供高效的AP
    

    • 

  • jmeter远程启动配置
雪霁_
性能测试压力测试jmeterlinux

    前提条件保持windows端、linux端jdk版本一致配置linux压力机(配置agent)修改文件jmeter.properties，打开注释server_port开启端口(默认1099)；打开注释，修改server.rmi.ssl.disable=false为true运行命令，./jmeter-server-Djava.rmi.server.hostname=10.0.0.48（ip为lin
    

    • 

  • eureka核心操作解析：集群间数据同步、自我保护、三级缓存
dejavu111
eurekajava

    1.什么是注册中心？Eureka是springcloud中的一个负责服务注册与发现的组件。遵循着CAP理论中的A(可用性)P(分区容错性)。一个Eureka中分为eurekaserver和eurekaclient。其中eurekaserver是作为服务的注册与发现中心。eurekaclient既可以作为服务的生产者，又可以作为服务的消费者。具体结构如下图：Eureka是一个基于REST（表述性状态
    

    • 

  • mac java 8卸载_[macOS]macOS上卸载Java9 重装Java8
V6火箭
macjava8卸载

    [TOC]0x00场景装了Java9，但是发现不少应用不支持，没办法，卸载。0x01探索查看java版本java--versionorjava-version查看Java路径whichjava显示结果：/usr/bin/java。进入目录/usr/bin/，定位到原始位置/System/Library/Frameworks/JavaVM.framework/Versions/A/Commands。
    

    • 

  • java计算机毕业设计高校学生资助管理信息系统源码+mysql数据库+系统+lw文档+部署
鸿源网络
数据库mysqljava

    java计算机毕业设计高校学生资助管理信息系统源码+mysql数据库+系统+lw文档+部署java计算机毕业设计高校学生资助管理信息系统源码+mysql数据库+系统+lw文档+部署本源码技术栈：项目架构：B/S架构开发语言：Java语言开发软件：ideaeclipse前端技术：Layui、HTML、CSS、JS、JQuery等技术后端技术：JAVA运行环境：Win10、JDK1.8数据库：MySQ
    

    • 

  • Pixel2刷入原生Google系统并获取ROOT权限
Devil丶LY
移动端android

    一、设备信息机型：pixel2二、预刷系统系统：google原生系统(pixel对应版本为walleye)Android版本：11Magisk版本：23.0(root用)三、刷机工具fastbootadb四、下载网站Google原生系统镜像下载地址TWRP下载地址Magisk下载地址五、刷机文件walleye-rp1a.201005.004.a1-factory-0c23f6cf.zip(goog
    

    • 

  • 分享JavaScript中直接调用CSS中的类名
奔跑的呱呱牛
javascriptcss开发语言

    分享JavaScript中直接调用CSS中的类名在现代的JavaScript框架（如React、Vue）中，使用CSS模块（CSSModules）是一种非常流行的方式。.module.css文件扩展名代表的是CSS模块，它与普通的CSS文件不同，能够解决样式全局污染的问题，并且实现更好的样式隔离。为什么要使用.module.css作用域隔离：传统的CSS文件中的类名是全局的，这意味着如果多个组件或
    

    • 

  • 从头开始学习->JVM（一）：java内存模型（JMM）不是java虚拟机内存模型(JVM)哦！
吴里斯蒂亚诺_翀纳尔多

    前言在进入jvm的世界之前，我要先给大家整理一个概念上的细节，java内存模型和jvm内存模型，是两回事哦。在网上很多朋友的博客上，都会无意识的将java内存模型和jvm内存模型混为一谈，这让一部分不明白真相的看客都会以为是这样，但是实际上java内存模型和jvm内存模型，在概念上来讲是两回事，当然，不能否认的是这两者有着极大的关联性，甚至某种意义上来讲，JVM是JMM的实现方式，JMM是为JVM
    

    • 

  • mac上安装和卸载java的jdk
默然相爱鱼鱼鱼
jdk

    mac上安装和卸载java的jdkbrew安装brewcaskinstalljava8#安装java81配置Java环境变量1、定位JAVA_HOME位置/usr/libexec/java_home12、编辑profile文件vim~/.bash_profile1格式参考JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk1.8.0_152.jdk/Con
    

    • 

  • LinkedList模拟出栈入栈
虾米大王
Javajavawindows开发语言

    packagecom.shrimpking.t11;importjava.util.LinkedList;/***CreatedbyIntelliJIDEA.**@Author:Shrimpking*@create2024/9/1011:49*/publicclassMyStack{privateLinkedListlist=newLinkedListms=newMyStack<>();ms.pu
    

    • 

  • Java 正则表达式
南风_001

    正则表达式定义了字符串的模式。正则表达式可以用来搜索、编辑或处理文本。正则表达式并不仅限于某一种语言，但是在每种语言中有细微的差别。正则表达式实例一个字符串其实就是一个简单的正则表达式，例如HelloWorld正则表达式匹配"HelloWorld"字符串。.（点号）也是一个正则表达式，它匹配任何一个字符如："a"或"1"。下表列出了一些正则表达式的实例及描述：正则表达式描述thisistext匹配
    

    • 

  • 庖丁解java(一篇文章学java)
庖丁解java
java开发语言

    (大家不用收藏这篇文章,因为这篇文章会经常更新,也就是删除后重发)一篇文章学java,这是我滴一个执念...当然,真一篇文章就写完java基础,java架构,java业务实现,java业务扩展,根本不可能.所以,这篇文章,就是一个索引,索什么呢?请看下文.关于决定开始写博文的介绍(一切故事的起点源于这一次反省)中小技术公司的软扩展(微服务扩展是否有必要?)-CSDN博客SpringCloud(一个
    

    • 

  • 基于JAVA高校毕业就业管理系统计算机毕业设计源码+数据库+lw文档+系统+部署
源新网络
java开发语言

    基于JAVA高校毕业就业管理系统计算机毕业设计源码+数据库+lw文档+系统+部署基于JAVA高校毕业就业管理系统计算机毕业设计源码+数据库+lw文档+系统+部署本源码技术栈：项目架构：B/S架构开发语言：Java语言开发软件：ideaeclipse前端技术：Layui、HTML、CSS、JS、JQuery等技术后端技术：JAVA运行环境：Win10、JDK1.8数据库：MySQL5.7/8.0源码
    

    • 

  • 如何用Kotlin实现MVP架构的Android快速开发框架？
2401_84132496
程序员androidkotlin架构

    下拉刷新和上拉加载更多空页面在断网情况下加载缓存网络请求错误并重新加载基于Kotlin的使用说明（Java的使用具体参考java版本的demo）导入依赖在根目录中的build.gradle文件中加入maven{url“https://jitpack.io”}在应用下的build.gradle文件中加入在自定义的Application类中的onCreate方法中初始化CommonLibrary//初
    

    • 

  • Java 获取中文拼音和首字母
颇有几分姿色
java基础java

    需求：获取中文首字母当做用户登录名。获取用户姓名拼音做其他逻辑。不需要定制化使用hutool封装的PinyinUtil即可，我这里需要自己定制，所以写了个工具类。实现基于搜狐的Pinyin4j库。依赖：cn.hutoolhutool-all5.4.2com.belerwebpinyin4j2.5.1PinyinUtils代码示例PinyinUtils提供了以下主要方法：toHanYuPinyinS
    

    • 

  • 面试频繁被问Java中的各种锁，今天就给大伙来梳理梳理外加视频教学
java涛仔

    大伙在面试的时候应该会经常碰到线程并发方面的问题，而且也会问到你各种分布式锁的概念，本文就给大家整理了下各种锁的分类，希望对你有所帮助。视频获取方式：私信【锁】即可领取锁的分类我们先总体的来看看有哪些具体的分类一、乐观锁/悲观锁  注意，乐观锁与悲观锁并不是具体的两种锁的实现，而一种设计思想。乐观锁  顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断
    

    • 

  • 信创那些事儿——Spring Boot中集成东方通中间件（TongWeb）
北欧人写代码
tomcat安全

    在SpringBoot中集成东方通中间件（如TongWeb作为Servlet容器）通常涉及几个步骤，但需要注意的是，TongWeb本身是一个独立的JavaEE应用服务器，而不是像Tomcat那样可以直接嵌入到SpringBoot应用中的中间件。因此，集成通常意味着将SpringBoot应用打包为WAR文件并部署到TongWeb服务器上。以下是在SpringBoot中集成东方通中间件（以TongWe
    

    • 

  • Java开发中的常用字段校验注解
呢喃coding
Javajavawindowspython

    在Java开发中，数据校验是确保应用程序的数据完整性和一致性的重要步骤。Java提供了一系列注解来简化数据校验的过程，以下是一些常用的字段校验注解及其示例代码：@NotNull@NotNull用于确保字段不为null，适用于任何类型的字段，包括基本数据类型和对象引用。importjavax.validation.constraints.NotNull;publicclassExample{@Not
    

    • 

  • 斐波纳契数列(f(n)=f(n-1)+f(n-2))问题
剑海风云
Algorithm算法数列

    packageorg.nxt.algorithm.series;importjava.math.BigInteger;/***fibonacciseries*@authornanxiaotao**/publicclassFibonacciSeries{privatestaticBigInteger[][]matrix(BigInteger[][]arrLeft,BigInteger[][]arrR
    

    • 

  • 基于spring boot的旅游管理系统
鹿屿二向箔
springboot旅游后端

    一个简单的SpringBoot应用的基础结构示例，以及如何设置一个基本的旅游管理系统。这个例子将包含用户注册和登录的基本功能。首先，你需要设置一个新的SpringBoot项目。可以通过SpringInitializr网站（https://start.spring.io/）来快速生成一个基础项目结构，选择必要的依赖项，比如Web、Thymeleaf、SpringDataJPA和MySQLDriver
    

    • 

  • Selenium面试题（二）
知识的宝藏
Selenium（Java）selenium测试工具

    如何在不使用sendKeys()的情况下输入文本可以通过组合使用JavaScript和WebDriver扩展类来实现。以下是一个示例代码：publicstaticvoidsetAttribute(WebElementelement,StringattributeName,Stringvalue){WrapsDriverwrappedElement=(WrapsDriver)element;Java
    

    • 

  • 对于规范和实现，你会混淆吗？
yangshangchuan
HotSpot

    昨晚和朋友聊天，喝了点咖啡，由于我经常喝茶，很长时间没喝咖啡了，所以失眠了，于是起床读JVM规范，读完后在朋友圈发了一条信息：
JVM Run-Time Data Areas：The Java Virtual Machine defines various run-time data areas that are used during execution of a program. So
    

    • 

  • android 网络
百合不是茶
网络

    android的网络编程和java的一样没什么好分析的都是一些死的照着写就可以了,所以记录下来  方便查找   ,  服务器使用的是TomCat
 
服务器代码;  servlet的使用需要在xml中注册
package servlet;
import java.io.IOException;
import java.util.Arr
    

    • 

  • [读书笔记]读法拉第传
comsci
读书笔记

    
      1831年的时候,一年可以赚到1000英镑的人..应该很少的...
      要成为一个科学家,没有足够的资金支持,很多实验都无法完成
      但是当钱赚够了以后....就不能够一直在商业和市场中徘徊......
    

    • 

  • 随机数的产生
沐刃青蛟
随机数

    c++中阐述随机数的方法有两种：
 
一是产生假随机数（不管操作多少次，所产生的数都不会改变）
 
       这类随机数是使用了默认的种子值产生的，所以每次都是一样的。
 
//默认种子
for (int i = 0; i < 5; i++)
{
cout<<
    

    • 

  • PHP检测函数所在的文件名
IT独行者
PHP函数

    很简单的功能，用到PHP中的反射机制，具体使用的是ReflectionFunction类，可以获取指定函数所在PHP脚本中的具体位置。 创建引用脚本。
代码：
 
[php]  
view plain
copy
// Filename: functions.php   
<?php&nbs
    

    • 

  • 银行各系统功能简介
文强chu
金融

    银行各系统功能简介 　 业务系统 核心业务系统 业务功能包括：总账管理、卡系统管理、客户信息管理、额度控管、存款、贷款、资金业务、国际结算、支付结算、对外接口等 清分清算系统 以清算日期为准，将账务类交易、非账务类交易的手续费、代理费、网络服务费等相关费用，按费用类型计算应收、应付金额，经过清算人员确认后上送核心系统完成结算的过程 国际结算系
    

    • 

  • Python学习1(pip django 安装以及第一个project)
小桔子
pythondjangopip

        最近开始学习python,要安装个pip的工具。听说这个工具很强大，安装了它，在安装第三方工具的话so easy!然后也下载了，按照别人给的教程开始安装，奶奶的怎么也安装不上！
第一步：官方下载pip-1.5.6.tar.gz, https://pypi.python.org/pypi/pip easy!
第二部：解压这个压缩文件，会看到一个setup.p
    

    • 

  • php 数组
aichenglong
PHP排序数组循环多维数组

    1 php中的创建数组
$product = array('tires','oil','spark');//array()实际上是语言结构而不  是函数
2 如果需要创建一个升序的排列的数字保存在一个数组中，可以使用range()函数来自动创建数组
$numbers=range(1,10)//1 2 3 4 5 6 7 8 9 10
$numbers=range(1,10,
    

    • 

  • 安装python2.7
AILIKES
python

    安装python2.7
1、下载可从 http://www.python.org/进行下载#wget https://www.python.org/ftp/python/2.7.10/Python-2.7.10.tgz
2、复制解压
#mkdir -p /opt/usr/python
#cp  /opt/soft/Python-2
    

    • 

  • java异常的处理探讨
百合不是茶
JAVA异常

    //java异常 
/*
1，了解java 中的异常处理机制，有三种操作
a,声明异常 
b,抛出异常 
c,捕获异常
2，学会使用try-catch-finally来处理异常
3，学会如何声明异常和抛出异常
4，学会创建自己的异常
 
*/
 
//2，学会使用try-catch-finally来处理异常
  
    

    • 

  • getElementsByName实例
bijian1013
element

    实例1：
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/x
    

    • 

  • 探索JUnit4扩展：Runner
bijian1013
java单元测试JUnit

            参加敏捷培训时，教练提到Junit4的Runner和Rule，于是特上网查一下，发现很多都讲的太理论，或者是举的例子实在是太牵强。多搜索了几下，搜索到两篇我觉得写的非常好的文章。
        文章地址：http://www.blogjava.net/jiangshachina/archive/20
    

    • 

  • [MongoDB学习笔记二]MongoDB副本集
bit1129
mongodb

    1. 副本集的特性
  1)一台主服务器(Primary),多台从服务器(Secondary)
  2)Primary挂了之后，从服务器自动完成从它们之中选举一台服务器作为主服务器，继续工作，这就解决了单点故障，因此，在这种情况下，MongoDB集群能够继续工作
  3)挂了的主服务器恢复到集群中只能以Secondary服务器的角色加入进来
 
2
    

    • 

  • 【Spark八十一】Hive in the spark assembly
bit1129
assembly

    Spark SQL supports most commonly used features of HiveQL. However, different HiveQL statements are executed in different manners:
1. DDL statements (e.g. CREATE TABLE, DROP TABLE, etc.)
    

    • 

  • Nginx问题定位之监控进程异常退出
ronin47

    nginx在运行过程中是否稳定，是否有异常退出过？这里总结几项平时会用到的小技巧。
1. 在error.log中查看是否有signal项，如果有，看看signal是多少。
比如，这是一个异常退出的情况：
$grep signal error.log
2012/12/24 16:39:56 [alert] 13661#0: worker process 13666 exited on s
    

    • 

  • No grammar constraints (DTD or XML schema).....两种解决方法
byalias
xml

    方法一：常用方法   关闭XML验证
工具栏：windows => preferences => xml => xml files => validation => Indicate when no grammar is specified:选择Ignore即可。
方法二：（个人推荐）
添加 内容如下
<?xml version=
    

    • 

  • Netty源码学习-DefaultChannelPipeline
bylijinnan
netty

    package com.ljn.channel;
/**
* ChannelPipeline采用的是Intercepting Filter 模式
* 但由于用到两个双向链表和内部类，这个模式看起来不是那么明显，需要仔细查看调用过程才发现
*
* 下面对ChannelPipeline作一个模拟，只模拟关键代码：
*/
public class Pipeline {

    

    • 

  • MYSQL数据库常用备份及恢复语句
chicony
mysql

    
备份MySQL数据库的命令，可以加选不同的参数选项来实现不同格式的要求。
mysqldump -h主机 -u用户名 -p密码 数据库名 > 文件
备份MySQL数据库为带删除表的格式，能够让该备份覆盖已有数据库而不需要手动删除原有数据库。
mysqldump -–add-drop-table -uusername -ppassword databasename > ba
    

    • 

  • 小白谈谈云计算--基于Google三大论文
CrazyMizzz
Google云计算GFS

        之前在没有接触到云计算之前，只是对云计算有一点点模糊的概念，觉得这是一个很高大上的东西，似乎离我们大一的还很远。后来有机会上了一节云计算的普及课程吧，并且在之前的一周里拜读了谷歌三大论文。不敢说理解，至少囫囵吞枣啃下了一大堆看不明白的理论。现在就简单聊聊我对于云计算的了解。
    我先说说GFS
  &n
    

    • 

  • hadoop 平衡空间设置方法
daizj
hadoopbalancer

    在hdfs-site.xml中增加设置balance的带宽，默认只有1M：
<property>
  <name>dfs.balance.bandwidthPerSec</name>
    <value>10485760</value>
    <description&g
    

    • 

  • Eclipse程序员要掌握的常用快捷键
dcj3sjt126com
编程

      判断一个人的编程水平，就看他用键盘多，还是鼠标多。用键盘一是为了输入代码（当然了，也包括注释），再有就是熟练使用快捷键。 曾有人在豆瓣评
《卓有成效的程序员》：“人有多大懒，才有多大闲”。之前我整理了一个
程序员图书列表，目的也就是通过读书，让程序员变懒。  程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可以那么勤奋，每天都孜孜不倦得
    

    • 

  • Android学习之路
dcj3sjt126com
Android学习

    转自：http://blog.csdn.net/ryantang03/article/details/6901459
以前有J2EE基础，接触JAVA也有两三年的时间了，上手Android并不困难，思维上稍微转变一下就可以很快适应。以前做的都是WEB项目，现今体验移动终端项目，让我越来越觉得移动互联网应用是未来的主宰。
下面说说我学习Android的感受，我学Android首先是看MARS的视
    

    • 

  • java 遍历Map的四种方法
eksliang
javaHashMapjava 遍历Map的四种方法

    转载请出自出处：
http://eksliang.iteye.com/blog/2059996
package com.ickes;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
/**
* 遍历Map的四种方式 
    

    • 

  • 【精典】数据库相关相关
gengzg
数据库

    package C3P0;
import java.sql.Connection;
import java.sql.SQLException;
import java.beans.PropertyVetoException;
import com.mchange.v2.c3p0.ComboPooledDataSource;
public class DBPool{ 
    

    • 

  • 自动补全
huyana_town
自动补全

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml&quo
    

    • 

  • jquery在线预览PDF文件，打开PDF文件
天梯梦
jquery

    最主要的是使用到了一个jquery的插件jquery.media.js，使用这个插件就很容易实现了。
 
核心代码
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.
    

    • 

  • ViewPager刷新单个页面的方法
lovelease
androidviewpagertag刷新

      使用ViewPager做滑动切换图片的效果时，如果图片是从网络下载的，那么再子线程中下载完图片时我们会使用handler通知UI线程，然后UI线程就可以调用mViewPager.getAdapter().notifyDataSetChanged()进行页面的刷新，但是viewpager不同于listview，你会发现单纯的调用notifyDataSetChanged()并不能刷新页面
    

    • 

  • 利用按位取反（~）从复合枚举值里清除枚举值
草料场
enum

    以 C# 中的 System.Drawing.FontStyle 为例。
 
如果需要同时有多种效果，
如：“粗体”和“下划线”的效果，可以用按位或（|）
FontStyle style = FontStyle.Bold | FontStyle.Underline;
 
如果需要去除 style 里的某一种效果， 
    

    • 

  • Linux系统新手学习的11点建议
刘星宇
编程工作linux脚本

    　　随着Linux应用的扩展许多朋友开始接触Linux，根据学习Windwos的经验往往有一些茫然的感觉：不知从何处开始学起。这里介绍学习Linux的一些建议。
　　一、从基础开始：常常有些朋友在Linux论坛问一些问题，不过，其中大多数的问题都是很基础的。例如：为什么我使用一个命令的时候，系统告诉我找不到该目录，我要如何限制使用者的权限等问题，这些问题其实都不是很难的，只要了解了 Linu
    

    • 

  • hibernate dao层应用之HibernateDaoSupport二次封装
wangzhezichuan
DAOHibernate

    /**
* <p>方法描述:sql语句查询 返回List<Class> </p>
* <p>方法备注: Class 只能是自定义类 </p>
* @param calzz
* @param sql
* @return
* <p>创建人：王川</p>
* <p>创建时间：Jul
    

    •