2. 程式人生 > >Elasticsearch JAVA api輕松搞定groupBy聚合

Elasticsearch JAVA api輕松搞定groupBy聚合

阿新 • • 發佈：2017-12-14
ont text 遇到 初始化 演示 是我 getprop square 遍歷

本文給出如何使用Elasticsearch的Java API做類似SQL的group by聚合。

為了簡單起見，只給出一級groupby即group by field1(而不涉及到多級，例如group by field1, field2, ...)；如果你需要多級的groupby，在實現上可能需要拆分的更加細致。

即將給出的方法，適用於如下的場景：

場景1：找出分組中的所有桶，例如，select group_name from index_name group by group_name;

場景2：靈活添加一個或者多個聚合函數，例如，select group_name, max(count), avg(count) group by group_name;

1、用法

GroupBy類是我們的實現。

1）測試用例

public static void main(String[] args) {
        /*
        *   初始化es客戶端
        * */
        ESClient esClient = new ESClient(
                "dqa-cluster",
                "10.93.21.21:9300,10.93.18.34:9300,10.93.18.35:9300,100.90.62.33:9300,100.90.61.14:9300",
                false);

        
 
/*
        *   為了演示, 構造了一個距離查詢, 相當於where子句.
        * */
        GeoDistanceRangeQueryBuilder queryBuilder = QueryBuilders.geoDistanceRangeQuery("location")
                .point(39.971424, 116.398251)
                .from("0m")
                .to(String.format("%fm", 500.0))
                .includeLower(
 
true)
                .includeUpper(true)
                .optimizeBbox("memory")
                .geoDistance(GeoDistance.SLOPPY_ARC);
        
        SearchRequestBuilder search = esClient.getClient().prepareSearch("moon").setTypes("bj")
                .setSearchType(SearchType.DFS_QUERY_AND_FETCH)
                .setQuery(queryBuilder);

        /*
        *  GroupBy類就是我們的實現, 初始化的時候傳入的參數依次是, search, 桶命名, 分桶字段, 排序asc
        *  select date as date_group from index group by date;
        * */
        GroupBy groupBy = new GroupBy(search, "date_group", "date", true);

        /*
        *   添加各種分組函數
        *   這裏我實現了10種, 下面是其中的6種
        * */
        groupBy.addSumAgg("pre_total_fee_sum", "pre_total_fee");
        groupBy.addAvgAgg("pre_total_fee_avg", "pre_total_fee");
        groupBy.addPercentilesAgg("pre_total_fee_percent", "pre_total_fee");
        groupBy.addPercentileRanksAgg("pre_total_fee_percentRank", "pre_total_fee", new double[]{13, 16, 20});
        groupBy.addStatsAgg("pre_total_fee_stats", "pre_total_fee");
        groupBy.addCardinalityAgg("type_card", "type");

        /*
        *   獲取groupBy聚合的結果
        *   結果是兩級Map, 這裏的實現是TreeMap因為要保護桶的排序
        * */
        Map<String, Object> groupbyResponse = groupBy.getGroupbyResponse();
        for (Map.Entry<String, Object> entry : groupbyResponse.entrySet()) {
            String bucketKey = entry.getKey();
            Map<String, String> subAggMap = (Map<String, String>) entry.getValue();
            System.out.println(String.format("%s\t%s\t%s", bucketKey, "pre_total_fee_sum", subAggMap.get("pre_total_fee_sum")));
            System.out.println(String.format("%s\t%s\t%s", bucketKey, "pre_total_fee_avg", subAggMap.get("pre_total_fee_avg")));
            System.out.println(String.format("%s\t%s\t%s", bucketKey, "pre_total_fee_percent", subAggMap.get("pre_total_fee_percent")));
            System.out.println(String.format("%s\t%s\t%s", bucketKey, "pre_total_fee_percentRank", subAggMap.get("pre_total_fee_percentRank")));
            System.out.println(String.format("%s\t%s\t%s", bucketKey, "pre_total_fee_stats", subAggMap.get("pre_total_fee_stats")));
            System.out.println(String.format("%s\t%s\t%s", bucketKey, "type_card", subAggMap.get("type_card")));

        }
    }

2）初始化

初始化的時候，相當於構造了這樣一個SQL：select date as date_group from index group by date;

傳入search對象，相當於where子句

傳入分桶命名， 相當於 as date_group

傳入分桶字段，相當於date

傳入排序，asc=true

3）初始化完成後，可以添加各種聚合函數，也就是場景2。

GroupBy類裏實現了10種聚合函數

4）讀取結果

結果的返回是兩級Map，為了保護分桶的排序，實現中使用了TreeMap。

這裏需要註意的是，有些聚合函數的返回，並不是一個值，而是一組值，如Percentiles、Stats等等，這裏我們把這一組值壓縮成JSONString了。

5）打印輸出

我們以日期進行了分桶，同一個分桶中的聚合結果，sum、avg、cardinality都是單個的值。而percentiles、percentileRanks、stats是壓縮的jsonstring。

技術分享圖片

2、實現

先上代碼，然後在後面進行講解。

public class GroupBy {

    private SearchRequestBuilder search;

    private String termsName;

    private TermsBuilder termsBuilder;

    private List<Map<String, Object>> subAggList = new ArrayList<Map<String, Object>>();

    public GroupBy(SearchRequestBuilder search, String termsName, String fieldName, boolean asc) {
        this.search = search;
        this.termsName = termsName;
        termsBuilder = AggregationBuilders.terms(termsName).field(fieldName).order(Terms.Order.term(asc)).size(0);
    }

    private void addSubAggList(String aggName, MetricsAggregationBuilder aggBuilder) {
        Map<String, Object> subAgg = new HashMap<String, Object>();
        subAgg.put("aggName", aggName);
        subAgg.put("aggBuilder", aggBuilder);
        subAggList.add(subAgg);
    }

    public void addSumAgg(String aggName, String fieldName) {
        SumBuilder builder = AggregationBuilders.sum(aggName).field(fieldName);
        termsBuilder.subAggregation(builder);
        addSubAggList(aggName, builder);
    }

    public boolean bucketSumAgg(Terms.Bucket bucket, String aggName, MetricsAggregationBuilder aggBuilder, Map<String, String> tmpMap) {
        if (aggBuilder instanceof SumBuilder) {
            tmpMap.put(aggName, bucket.getAggregations().get(aggName).getProperty("value").toString());
            return true;
        } else {
            return false;
        }
    }

    public void addCountAgg(String aggName, String fieldName) {
        ValueCountBuilder builder = AggregationBuilders.count(aggName).field(fieldName);
        termsBuilder.subAggregation(builder);
        addSubAggList(aggName, builder);
    }

    public boolean bucketCountAgg(Terms.Bucket bucket, String aggName, MetricsAggregationBuilder aggBuilder, Map<String, String> tmpMap) {
        if (aggBuilder instanceof ValueCountBuilder) {
            tmpMap.put(aggName, bucket.getAggregations().get(aggName).getProperty("value").toString());
            return true;
        } else {
            return false;
        }
    }

    public void addAvgAgg(String aggName, String fieldName) {
        AvgBuilder builder = AggregationBuilders.avg(aggName).field(fieldName);
        termsBuilder.subAggregation(builder);
        addSubAggList(aggName, builder);
    }

    public boolean bucketAvgAgg(Terms.Bucket bucket, String aggName, MetricsAggregationBuilder aggBuilder, Map<String, String> tmpMap) {
        if (aggBuilder instanceof AvgBuilder) {
            tmpMap.put(aggName, bucket.getAggregations().get(aggName).getProperty("value").toString());
            return true;
        } else {
            return false;
        }
    }

    public void addMinAgg(String aggName, String fieldName) {
        MinBuilder builder = AggregationBuilders.min(aggName).field(fieldName);
        termsBuilder.subAggregation(builder);
        addSubAggList(aggName, builder);
    }

    public boolean bucketMinAgg(Terms.Bucket bucket, String aggName, MetricsAggregationBuilder aggBuilder, Map<String, String> tmpMap) {
        if (aggBuilder instanceof MinBuilder) {
            tmpMap.put(aggName, bucket.getAggregations().get(aggName).getProperty("value").toString());
            return true;
        } else {
            return false;
        }
    }

    public void addMaxAgg(String aggName, String fieldName) {
        MaxBuilder builder = AggregationBuilders.max(aggName).field(fieldName);
        termsBuilder.subAggregation(builder);
        addSubAggList(aggName, builder);
    }

    public boolean bucketMaxAgg(Terms.Bucket bucket, String aggName, MetricsAggregationBuilder aggBuilder, Map<String, String> tmpMap) {
        if (aggBuilder instanceof MaxBuilder) {
            tmpMap.put(aggName, bucket.getAggregations().get(aggName).getProperty("value").toString());
            return true;
        } else {
            return false;
        }
    }

    public void addStatsAgg(String aggName, String fieldName) {
        StatsBuilder builder = AggregationBuilders.stats(aggName).field(fieldName);
        termsBuilder.subAggregation(builder);
        addSubAggList(aggName, builder);
    }

    public boolean bucketStatsAgg(Terms.Bucket bucket, String aggName, MetricsAggregationBuilder aggBuilder, Map<String, String> tmpMap) {
        if (aggBuilder instanceof StatsBuilder) {
            Stats stats = bucket.getAggregations().get(aggName);
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("min", stats.getMin());
            jsonObject.put("max", stats.getMax());
            jsonObject.put("sum", stats.getMax());
            jsonObject.put("count", stats.getCount());
            jsonObject.put("avg", stats.getAvg());
            tmpMap.put(aggName, jsonObject.toJSONString());
            return true;
        } else {
            return false;
        }
    }

    public void addExtendedStatsAgg(String aggName, String fieldName) {
        ExtendedStatsBuilder builder = AggregationBuilders.extendedStats(aggName).field(fieldName);
        termsBuilder.subAggregation(builder);
        addSubAggList(aggName, builder);
    }

    public boolean bucketExtendedStatsAgg(Terms.Bucket bucket, String aggName, MetricsAggregationBuilder aggBuilder, Map<String, String> tmpMap) {
        if (aggBuilder instanceof ExtendedStatsBuilder) {
            ExtendedStats extendedStats = bucket.getAggregations().get(aggName);
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("min", extendedStats.getMin());
            jsonObject.put("max", extendedStats.getMax());
            jsonObject.put("sum", extendedStats.getMax());
            jsonObject.put("count", extendedStats.getCount());
            jsonObject.put("avg", extendedStats.getAvg());
            jsonObject.put("stdDeviation", extendedStats.getStdDeviation());
            jsonObject.put("sumOfSquares", extendedStats.getSumOfSquares());
            jsonObject.put("variance", extendedStats.getVariance());
            tmpMap.put(aggName, jsonObject.toJSONString());
            return true;
        } else {
            return false;
        }
    }

    public void addPercentilesAgg(String aggName, String fieldName) {
        PercentilesBuilder builder = AggregationBuilders.percentiles(aggName).field(fieldName);
        termsBuilder.subAggregation(builder);
        addSubAggList(aggName, builder);
    }

    public void addPercentilesAgg(String aggName, String fieldName, double[] percentiles) {
        PercentilesBuilder builder = AggregationBuilders.percentiles(aggName).field(fieldName).percentiles(percentiles);
        termsBuilder.subAggregation(builder);
        addSubAggList(aggName, builder);
    }

    public boolean bucketPercentilesAgg(Terms.Bucket bucket, String aggName, MetricsAggregationBuilder aggBuilder, Map<String, String> tmpMap) {
        if (aggBuilder instanceof PercentilesBuilder) {
            Percentiles percentiles = bucket.getAggregations().get(aggName);
            JSONObject jsonObject = new JSONObject();
            for (Percentile percentile : percentiles) {
                jsonObject.put(String.valueOf(percentile.getPercent()), percentile.getValue());
            }
            tmpMap.put(aggName, jsonObject.toJSONString());
            return true;
        } else {
            return false;
        }
    }

    public void addPercentileRanksAgg(String aggName, String fieldName, double[] percentiles) {
        PercentileRanksBuilder builder = AggregationBuilders.percentileRanks(aggName).field(fieldName).percentiles(percentiles);
        termsBuilder.subAggregation(builder);
        addSubAggList(aggName, builder);
    }

    public boolean bucketPercentileRanksAgg(Terms.Bucket bucket, String aggName, MetricsAggregationBuilder aggBuilder, Map<String, String> tmpMap) {
        if (aggBuilder instanceof PercentileRanksBuilder) {
            PercentileRanks percentileRanks = bucket.getAggregations().get(aggName);
            JSONObject jsonObject = new JSONObject();
            for (Percentile percentile : percentileRanks) {
                jsonObject.put(String.valueOf(percentile.getPercent()), percentile.getValue());
            }
            tmpMap.put(aggName, jsonObject.toJSONString());
            return true;
        } else {
            return false;
        }
    }

    public void addCardinalityAgg(String aggName, String fieldName) {
        CardinalityBuilder builder = AggregationBuilders.cardinality(aggName).field(fieldName);
        termsBuilder.subAggregation(builder);
        addSubAggList(aggName, builder);
    }

    public boolean bucketCardinalityAgg(Terms.Bucket bucket, String aggName, MetricsAggregationBuilder aggBuilder, Map<String, String> tmpMap) {
        if (aggBuilder instanceof CardinalityBuilder) {
            tmpMap.put(aggName, bucket.getAggregations().get(aggName).getProperty("value").toString());
            return true;
        } else {
            return false;
        }
    }

    public List<Terms.Bucket> getTermsBucket() {
        search.addAggregation(termsBuilder);
        Terms termsGroup = search.get().getAggregations().get(termsName);
        return termsGroup.getBuckets();
    }

    public Map<String, Object> getGroupbyResponse() {
        Map<String, Object> aggResponseMap = new TreeMap<String, Object>();
        for (Terms.Bucket bucket : getTermsBucket()) {
            String bucketKeyAsString = bucket.getKeyAsString();
            Map<String, String> tmpMap = new TreeMap<String, String>();
            for (Map<String, Object> subAgg : subAggList) {
                String subAggName = subAgg.get("aggName").toString();
                MetricsAggregationBuilder subAggBuilder = (MetricsAggregationBuilder) subAgg.get("aggBuilder");
                if (bucketAvgAgg(bucket, subAggName, subAggBuilder, tmpMap)) continue;
                if (bucketMaxAgg(bucket, subAggName, subAggBuilder, tmpMap)) continue;
                if (bucketMinAgg(bucket, subAggName, subAggBuilder, tmpMap)) continue;
                if (bucketSumAgg(bucket, subAggName, subAggBuilder, tmpMap)) continue;
                if (bucketCountAgg(bucket, subAggName, subAggBuilder, tmpMap)) continue;
                if (bucketCardinalityAgg(bucket, subAggName, subAggBuilder, tmpMap)) continue;
                if (bucketPercentileRanksAgg(bucket, subAggName, subAggBuilder, tmpMap)) continue;
                if (bucketPercentilesAgg(bucket, subAggName, subAggBuilder, tmpMap)) continue;
                if (bucketExtendedStatsAgg(bucket, subAggName, subAggBuilder, tmpMap)) continue;
                if (bucketStatsAgg(bucket, subAggName, subAggBuilder, tmpMap)) continue;
            }
            aggResponseMap.put(bucketKeyAsString, tmpMap);
        }
        return aggResponseMap;
    }
}

1）構造函數

構造函數中，核心邏輯是termsBuilder = AggregationBuilders.terms(termsName).field(fieldName).order(Terms.Order.term(asc)).size(0);

實例化了termsBuilder也就是分桶。

後面調用add...函數簇添加聚合函數的時候，都是通過termsBuilder.subAggregation(builder)在分桶的基礎上添加了子聚合。

最後在獲取結果的時候search.addAggregation(termsBuilder);將termsBuilder添加到查詢上，進行聚合查詢。

2）添加聚合函數add...函數簇

以sum函數為例

public void addSumAgg(String aggName, String fieldName) {
        SumBuilder builder = AggregationBuilders.sum(aggName).field(fieldName);
        termsBuilder.subAggregation(builder);
        addSubAggList(aggName, builder);
    }

a）初始化了一個SumBuilder聚合操作，然後作為termsBuilder的子聚合。

b）addSubAggList方法在subAggList屬性(subAggList屬性是一個List<Map<String, Object>>)上保存了所有添加了的子聚合的名字和builder。這樣做是為了在解析結果的時候，知道是哪種type的聚合(instanceof)，以便使用不同的邏輯去解析。

private void addSubAggList(String aggName, MetricsAggregationBuilder aggBuilder) {
        Map<String, Object> subAgg = new HashMap<String, Object>();
        subAgg.put("aggName", aggName);
        subAgg.put("aggBuilder", aggBuilder);
        subAggList.add(subAgg);
    }

3）按類型獲取結果

還是以sum函數為例

public boolean bucketSumAgg(Terms.Bucket bucket, String aggName, MetricsAggregationBuilder aggBuilder, Map<String, String> tmpMap) {
        if (aggBuilder instanceof SumBuilder) {
            tmpMap.put(aggName, bucket.getAggregations().get(aggName).getProperty("value").toString());
            return true;
        } else {
            return false;
        }
    }

a）這裏先判斷了aggBuilder是哪種類型的(instanceof)，如果是SumBuilder類型的，就按照sum的結果類型去讀取返回結果。

b）sum的返回結果就是一個值，當遇到percentiles這種類型的，返回結果不是一個值，此時為了簡單，我將結果壓縮成了jsonstring，也相當於一個值，可以自行參看代碼。

c）後面依賴return true實現了一個邏輯，一旦命中了類型，就不再繼續判斷了，提升效率。

d）tmpMap是外部傳入的一個全局接收器，用來存儲結果。

4）解析所有的子聚合結果

public Map<String, Object> getGroupbyResponse() {
        Map<String, Object> aggResponseMap = new TreeMap<String, Object>();
        for (Terms.Bucket bucket : getTermsBucket()) {
            String bucketKeyAsString = bucket.getKeyAsString();
            Map<String, String> tmpMap = new TreeMap<String, String>();
            for (Map<String, Object> subAgg : subAggList) {
                String subAggName = subAgg.get("aggName").toString();
                MetricsAggregationBuilder subAggBuilder = (MetricsAggregationBuilder) subAgg.get("aggBuilder");
                if (bucketAvgAgg(bucket, subAggName, subAggBuilder, tmpMap)) continue;
                if (bucketMaxAgg(bucket, subAggName, subAggBuilder, tmpMap)) continue;
                if (bucketMinAgg(bucket, subAggName, subAggBuilder, tmpMap)) continue;
                if (bucketSumAgg(bucket, subAggName, subAggBuilder, tmpMap)) continue;
                if (bucketCountAgg(bucket, subAggName, subAggBuilder, tmpMap)) continue;
                if (bucketCardinalityAgg(bucket, subAggName, subAggBuilder, tmpMap)) continue;
                if (bucketPercentileRanksAgg(bucket, subAggName, subAggBuilder, tmpMap)) continue;
                if (bucketPercentilesAgg(bucket, subAggName, subAggBuilder, tmpMap)) continue;
                if (bucketExtendedStatsAgg(bucket, subAggName, subAggBuilder, tmpMap)) continue;
                if (bucketStatsAgg(bucket, subAggName, subAggBuilder, tmpMap)) continue;
            }
            aggResponseMap.put(bucketKeyAsString, tmpMap);
        }
        return aggResponseMap;
    }

這裏是解析結果的代碼。tmpMap定義為全局接收器。

a）通過遍歷subAggList存儲的所有子聚合函數，獲取所有的子聚合結果，並保存成兩級TreeMap。

b）對每個叠代，調用所有的bucket...函數簇，這裏通過if判斷是否命中類型，如果命中了，就通過continue不再繼續檢查。

c） aggResponseMap使用treeMap是為了保持bucket的有序。

3、十種聚合函數

最後列出我們實現的十種聚合函數，你可以根據自己的需求繼續添加。

1）返回單個值：sum、avg、min、max、count、cardinality(有誤差)

2）percentiles：分位數查詢，傳入分位數，獲取分位數上的值；percentileRanks，分位數排名查詢，傳入值，返回對應的分位數；互為逆向操作。

3）stats和extendedStats，extended聚合更詳細的信息max、min、avg、sum、平方和、標準差等。

Elasticsearch JAVA api輕松搞定groupBy聚合

相關推薦

Elasticsearch JAVA api輕松搞定groupBy聚合

ont text 遇到 初始化 演示 是我 getprop square 遍歷 本文給出如何使用Elasticsearch的Java API做類似SQL的group by聚合。 為了簡單起見，只給出一級groupby即group by field1(而不涉及到多級，例如

【微服務】之七：輕松搞定SpringCloud微服務-API權限控制

cat https lte urn 錯誤碼 netflix req ons 體系 權限控制，是一個系統當中必須的重要功能。張三只能訪問輸入張三的特定功能，李四不能訪問屬於趙六的特定菜單。這就要求對整個體系做一個完善的權限控制體系。該體系應該具備針區分用戶、權限、角色等各種

【微服務】之六：輕松搞定SpringCloud微服務-API網關zuul

公司 create lan ice 子項目 專題 系統 如果 rose 通過前面幾篇文章的介紹，我們可以輕松搭建起來微服務體系中比較重要的幾個基礎構建服務。那麽，在本篇博文中，我們重點講解一下，如何將所有微服務的API同意對外暴露，這個就設計API網關的概念。 本系列教

寫文章賺錢34期：用100個問答輕松搞定1個領域！

輕松賺錢 很多人聽說做自媒體很賺錢，在網絡上只要一部手機、一臺電腦就可以輕松賺錢，紛紛跑到網絡上去嘗試做。 他們選擇了一個領域就開始寫文章，但是寫了一段時間後，卻發現寫得文章沒人看，吸引不到精準粉絲，根本沒有粉絲可以成交，非常痛苦，就覺得做自媒體根本不能賺錢，是騙人的。 俊哥說：只有先搞定一個領域，把你變成專

輕松搞定對容器實例日誌設置定期清理和回卷

實現 drive 所有 存在 磁盤 hour 日誌文件 tar 文件 說明：該文轉載自騰訊雲技術社區騰雲閣，已征求作者本人同意。 引言 Kubernetes對於容器實例的日誌收集，並沒有提供原生的解決方案。但提供使用kubectl logs命令查看容器實例運行時的日誌。ku

輕松搞定RabbitMQ（五）——路由選擇

byte[] view 轉發器 ews 磁盤空間 表示 info 直接 net 轉自 http://blog.csdn.net/xiaoxian8023/article/details/48733249 翻譯地址：http://www.rabbitmq.com/tutori

從零開始，輕松搞定SpringCloud微服務系列

markdown class net 配置中心 html div .html href .com 本系列博文目錄 【微服務】之一：從零開始，輕松搞定SpringCloud微服務系列–開山篇（spring boot 小demo） 【微服務】之二：從零開始，輕松搞定Spring

網頁被限制無法復制？除了開發者工具還可以用瀏覽器插件輕松搞定

代碼 怎樣 ima 方式 程序 blank allow ble 開發 有些網站總是會用些JavaScript 或特殊的技巧將網路瀏覽器的文字選取、文字復制或滑鼠右鍵…等功能給鎖起來，以為這樣真的能禁止其他人復制、盜用文章。小編的每天的工作就是尋找各種素材遇到這樣的網站自然是

轉載 輕松搞定面試中的二叉樹題目

相同 tree otp article ref position too -c rri 版權所有，轉載請註明出處，謝謝！http://blog.csdn.net/walkinginthewind/article/details/7518888 樹是一種比較重要的數據結構，尤

這群超酷的開發者，是如何輕松搞定軟件開發？

webide 不容易 XML nba MF 模型設計 分享 min-width eating 前些日子我看到兩則有關線上Office的新聞，一是空客的十三萬員工將全部遷移到谷歌的在線文檔套件G Suite；二是騰訊發布在線文檔產品，可以與微軟Excel和Wor

報表工具輕松搞定票據單據套打

項目開發 分享圖片 畫圖軟件 什麽 class 畫圖 根據 接下來 需要 實際項目開發中，很多情況會涉及到票據的打印。即在一張印刷好的空白票據上，準確無誤地打印上票據的內容。用傳統的報表工具，我們通常會用尺子量每一個數據區域的位置，然後在屏幕上根據尺子量出的尺寸設計每一個格

報表工具輕松搞定卡片式報表

分享圖片 size 遇到的問題 神器 con font 報表設計器 com 能夠 在我們日常生活或工作中，經常會看到這樣一個個小卡片，上面記載著某件商品或者某個人的基本信息。如同名片一般，看起來簡單明了。而在數據庫中，這些信息實際上是密密麻麻的一條條記錄，直接查看非常容易看

10點小tip幫你輕松搞定頭疼的服務器日常維護！

硬件故障 機器 掃描 時間表 一點 創建 磁盤容量 挑戰 報表 服務器真不簡單，每天“哼唱”24個小時，每周七天，好像有無限能量，但其實它也不過是一臺機器，是機器都是需要維護的，不維護的話怎麽能夠和它“長相廝守”呢？ 有些人可能一聽到要維護服務器就感到頭疼，因為不懂就會束

如何將CAD圖紙轉換成彩色，只需幾步即可輕松搞定！

官網 -c 等待 輸出 href text RoCE 電腦桌 第一步 如何將CAD圖紙轉換成彩色，只需幾步即可輕松搞定！在日常的工作中，建築設計師們在編輯器完圖紙後，基本圖紙都是黑白的，這樣不利用我們更好的進行查看，那就需要將CAD圖紙的顏色進行轉換，如何將CAD圖紙轉換成

阿裏雲HBase發布冷存儲特性，輕松搞定冷數據處理

雲盤 dfs 部分 col ces 透明 mar 不變 thread 摘要： 9月27日，阿裏雲HBase發布了冷存儲特性。用戶可以在購買雲HBase實例時選擇冷存儲作為一個附加的存儲空間，並通過建表語句指定將冷數據存放在冷存儲介質上面，從而降低存儲成本。冷存儲的存儲成本僅

輕松搞定JSONP跨域請求

set 合同 bsp 豆瓣 con 註意 wiki str ref 一、同源策略 要理解跨域，先要了解一下“同源策略”。所謂同源是指，域名，協議，端口相同。所謂“同源策略“，簡單的說就是基於安全考慮，當前域不能訪問其他域的東西。 一些常見的是否同源示例可參照下表： 在同源

網站圖片需要付費禁止下載？這個網站神器輕松搞定！

images 神器 mar 下載到本地 個人 直接下載 網站 共享 無法 有時候我們需要下載一個有版權或者無版權的圖片作為個人使用，但是有些網站是無法直接下載圖片的，需要付費購買才行，今天給大家共享一個很簡單的方法，只要使用這個網站就可以解決網頁需要付費的圖片免費下載了；

Excel表格太大，無法同時打印在一張紙上？一鍵幫你輕松搞定！

置1 images 菜單欄 分頁 虛線 image ice 縮小 圖片 不知道大家在打印Excel表格時候有沒有遇到這樣的一個問題，表格太大了無法同時打印在一張紙上？這時候只能將表格的部分內容打印出來，著實令人感到頭痛！ 這時候有的朋友為了將Excel表格打印在一張紙張，硬

Go語言開發分布式任務調度 輕松搞定高性能Crontab

監聽 接口 記錄 簡單 inux 寫入 可用 初始化 創建 第1章 課程介紹本章中將介紹一下本課程的基本內容，包括：我們要做什麽、要求什麽基礎、將學會哪些工具、收獲哪些獨家幹貨，以及課程具體安排。1-1 導學視頻第2章 如何執行shell命令執行"定時任務"其實就是執行"s

Niushop 小程序商城不在復雜，兩招輕松搞定

規範 創業者 tex color png 數據統計 完整 接下來 com 小程序發展至今，已經拓展到了各行各業的領域當中。據相關的數據統計來說，小程序的應用廣泛存在於電商行業當中。不過現在也有很多電商的中小創業者們，都面臨著如何開發小程序的問題。如何開發小程序？怎樣找開發商