2. 程式人生 > >sentinel控制檯監控資料持久化【InfluxDB】

sentinel控制檯監控資料持久化【InfluxDB】

阿新 • • 發佈：2018-11-09

根據官方wiki文件，sentinel控制檯的實時監控資料，預設僅儲存 5 分鐘以內的資料。如需持久化，需要定製實現相關介面。

https://github.com/alibaba/Sentinel/wiki/在生產環境中使用-Sentinel-控制檯 也給出了指導步驟：

1.自行擴充套件實現 MetricsRepository 介面；

2.註冊成 Spring Bean 並在相應位置通過 @Qualifier 註解指定對應的 bean name 即可。

本文從下載InfluxDB開始，一步步編寫一個基於InfluxDB的儲存實現。

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

InfluxDB官網：https://www.influxdata.com

最新版本：1.6.4

下載

windows：wget https://dl.influxdata.com/influxdb/releases/influxdb-1.6.4_windows_amd64.zip

linux：wget https://dl.influxdata.com/influxdb/releases/influxdb-1.6.4_linux_amd64.tar.gz

注：windows下載安裝wget  https://eternallybored.org/misc/wget/

 

在windows環境，解壓zip檔案至D:\influxdb\influxdb-1.6.4-1目錄：

開啟cmd命令列視窗，在D:\influxdb\influxdb-1.6.4-1執行命令啟動influxdb服務端：influxd

 再開啟一個cmd視窗，在目錄下輸入influx -precision rfc3339啟動客戶端： // -precision rfc3339 是指定時間格式顯示，後面寫select查詢結果顯示會用到

show databases發現只有系統的2個數據庫，這裡我們新建一個sentinel_db，輸入命令：create database sentinel_db

use sentinel_db  使用sentinel_db資料庫

show measurements  檢視資料庫中的資料表(measurement)

 可以看到，這幾個InfluxDB的命令列操作跟MySQL有點類似。

 

==============================================================

InfluxDB名詞概念：

database：資料庫 // 關係資料庫的database

measurement：資料庫中的表 // 關係資料庫中的table

point：表裡的一行資料 // 關係資料庫中的row

point由3部分組成：

time：每條資料記錄的時間，也是資料庫自動生成的主索引；// 類似主鍵

fields：各種記錄的值；// 沒有索引的欄位

tags：各種有索引的屬性 // 有索引的欄位

==============================================================

 

在官方github上，有一個java的客戶端庫：

https://github.com/influxdata/influxdb-java

 

在sentinel-dashboard的pom.xml中，加入maven依賴：

<dependency>
    <groupId>org.influxdb</groupId>
    <artifactId>influxdb-java</artifactId>
    <version>2.14</version>
</dependency>

 

封裝一個工具類：儲存InfluxDB連線資訊以及方便呼叫

/**
 * @author cdfive
 * @date 2018-10-19
 */
@Component
public class InfluxDBUtils {

    private static Logger logger = LoggerFactory.getLogger(InfluxDBUtils.class);

    private static String url;

    private static String username;

    private static String password;

    private static InfluxDBResultMapper resultMapper = new InfluxDBResultMapper();

    @Value("${influxdb.url}")
    public void setUrl(String url) {
        InfluxDBUtils.url = url;
    }

    @Value("${influxdb.username}")
    public void setUsername(String username) {
        InfluxDBUtils.username = username;
    }

    @Value("${influxdb.password}")
    public void setPassword(String password) {
        InfluxDBUtils.password = password;
    }

    public static void init(String url, String username, String password) {
        InfluxDBUtils.url = url;
        InfluxDBUtils.username = username;
        InfluxDBUtils.password = password;
    }

    public static <T> T process(String database, InfluxDBCallback callback) {
        InfluxDB influxDB = null;
        T t = null;
        try {
            influxDB = InfluxDBFactory.connect(url, username, password);
            influxDB.setDatabase(database);

            t = callback.doCallBack(database, influxDB);
        } catch (Exception e) {
            logger.error("[process exception]", e);
        } finally {
            if (influxDB != null) {
                try {
                    influxDB.close();
                } catch (Exception e) {
                    logger.error("[influxDB.close exception]", e);
                }
            }
        }

        return t;
    }

    public static void insert(String database, InfluxDBInsertCallback influxDBInsertCallback) {
        process(database, new InfluxDBCallback() {
            @Override
            public <T> T doCallBack(String database, InfluxDB influxDB) {
                influxDBInsertCallback.doCallBack(database, influxDB);
                return null;
            }
        });

    }

    public static QueryResult query(String database, InfluxDBQueryCallback influxDBQueryCallback) {
        return process(database, new InfluxDBCallback() {
            @Override
            public <T> T doCallBack(String database, InfluxDB influxDB) {
                QueryResult queryResult = influxDBQueryCallback.doCallBack(database, influxDB);
                return (T) queryResult;
            }
        });
    }

    public static <T> List<T> queryList(String database, String sql, Map<String, Object> paramMap, Class<T> clasz) {
        QueryResult queryResult = query(database, new InfluxDBQueryCallback() {
            @Override
            public QueryResult doCallBack(String database, InfluxDB influxDB) {
                BoundParameterQuery.QueryBuilder queryBuilder = BoundParameterQuery.QueryBuilder.newQuery(sql);
                queryBuilder.forDatabase(database);

                if (paramMap != null && paramMap.size() > 0) {
                    Set<Map.Entry<String, Object>> entries = paramMap.entrySet();
                    for (Map.Entry<String, Object> entry : entries) {
                        queryBuilder.bind(entry.getKey(), entry.getValue());
                    }
                }

                return influxDB.query(queryBuilder.create());
            }
        });

        return resultMapper.toPOJO(queryResult, clasz);
    }

    public interface InfluxDBCallback {
        <T> T doCallBack(String database, InfluxDB influxDB);
    }

    public interface InfluxDBInsertCallback {
        void doCallBack(String database, InfluxDB influxDB);
    }

    public interface InfluxDBQueryCallback {
        QueryResult doCallBack(String database, InfluxDB influxDB);
    }
}

其中：

url、username、password用於儲存InfluxDB的連線、使用者名稱、密碼資訊，定義為static屬性，因此在set方法上使用@Value註解從配置檔案讀取屬性值；

resultMapper用於查詢結果到實體類的對映；

init方法用於初始化url、username、password；

process為通用的處理方法，負責開啟關閉連線，並且呼叫InfluxDBCallback回撥方法；

insert為插入資料方法，配合InfluxDBInsertCallback回撥使用；

query為通用的查詢方法，配合InfluxDBQueryCallback回撥方法使用，返回QueryResult物件；

queryList為查詢列表方法，呼叫query得到QueryResult，再通過resultMapper轉換為List<實體類>;

 

在resources目錄下的application.properties檔案中，增加InfluxDB的配置： 

influxdb.url=${influxdb.url}
influxdb.username=${influxdb.username}
influxdb.password=${influxdb.password}

用${xxx}佔位符，這樣可以通過maven的pom.xml新增profile配置不同環境(開發、測試、生產) 或 從配置中心讀取引數。

 

在datasource.entity包下，新建influxdb包，下面新建sentinel_metric資料表(measurement)對應的實體類MetricPO：

package com.taobao.csp.sentinel.dashboard.datasource.entity.influxdb;

import org.influxdb.annotation.Column;
import org.influxdb.annotation.Measurement;

import java.time.Instant;

/**
 * @author cdfive
 * @date 2018-10-19
 */
@Measurement(name = "sentinel_metric")
public class MetricPO {

    @Column(name = "time")
    private Instant time;

    @Column(name = "id")
    private Long id;

    @Column(name = "gmtCreate")
    private Long gmtCreate;

    @Column(name = "gmtModified")
    private Long gmtModified;

    @Column(name = "app", tag = true)
    private String app;

    @Column(name = "resource", tag = true)
    private String resource;

    @Column(name = "passQps")
    private Long passQps;

    @Column(name = "successQps")
    private Long successQps;

    @Column(name = "blockQps")
    private Long blockQps;

    @Column(name = "exceptionQps")
    private Long exceptionQps;

    @Column(name = "rt")
    private double rt;

    @Column(name = "count")
    private int count;

    @Column(name = "resourceCode")
    private int resourceCode;

    // getter setter省略
}

該類參考MetricEntity建立，加上influxdb-java包提供的註解，通過@Measurement(name = "sentinel_metric")指定資料表(measurement)名稱，

time作為時序資料庫的時間列；

app、resource設定為tag列，通過註解標識為tag=true；

其它欄位為filed列；

 

接著在InMemoryMetricsRepository所在的repository.metric包下新建InfluxDBMetricsRepository類，實現MetricsRepository<MetricEntity>介面：

package com.taobao.csp.sentinel.dashboard.repository.metric;

import com.alibaba.csp.sentinel.util.StringUtil;
import com.taobao.csp.sentinel.dashboard.datasource.entity.MetricEntity;
import com.taobao.csp.sentinel.dashboard.datasource.entity.influxdb.MetricPO;
import com.taobao.csp.sentinel.dashboard.util.InfluxDBUtils;
import org.apache.commons.lang.time.DateFormatUtils;
import org.apache.commons.lang.time.DateUtils;
import org.influxdb.InfluxDB;
import org.influxdb.dto.Point;
import org.springframework.stereotype.Repository;
import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 * @author cdfive
 * @date 2018-10-19
 */
@Repository("influxDBMetricsRepository")
public class InfluxDBMetricsRepository implements MetricsRepository<MetricEntity> {

    private static final String DATE_FORMAT_PATTERN = "yyyy-MM-dd HH:mm:ss.SSS";

    private static final String SENTINEL_DATABASE = "sentinel_db";

    private static final String METRIC_MEASUREMENT = "sentinel_metric";

    @Override
    public void save(MetricEntity metric) {
        if (metric == null || StringUtil.isBlank(metric.getApp())) {
            return;
        }

        InfluxDBUtils.insert(SENTINEL_DATABASE, new InfluxDBUtils.InfluxDBInsertCallback() {
            @Override
            public void doCallBack(String database, InfluxDB influxDB) {
                if (metric.getId() == null) {
                    metric.setId(System.currentTimeMillis());
                }
                doSave(influxDB, metric);
            }
        });
    }

    @Override
    public void saveAll(Iterable<MetricEntity> metrics) {
        if (metrics == null) {
            return;
        }

        Iterator<MetricEntity> iterator = metrics.iterator();
        boolean next = iterator.hasNext();
        if (!next) {
            return;
        }

        InfluxDBUtils.insert(SENTINEL_DATABASE, new InfluxDBUtils.InfluxDBInsertCallback() {
            @Override
            public void doCallBack(String database, InfluxDB influxDB) {
                while (iterator.hasNext()) {
                    MetricEntity metric = iterator.next();
                    if (metric.getId() == null) {
                        metric.setId(System.currentTimeMillis());
                    }
                    doSave(influxDB, metric);
                }
            }
        });
    }

    @Override
    public List<MetricEntity> queryByAppAndResourceBetween(String app, String resource, long startTime, long endTime) {
        List<MetricEntity> results = new ArrayList<MetricEntity>();
        if (StringUtil.isBlank(app)) {
            return results;
        }

        if (StringUtil.isBlank(resource)) {
            return results;
        }

        StringBuilder sql = new StringBuilder();
        sql.append("SELECT * FROM " + METRIC_MEASUREMENT);
        sql.append(" WHERE app=$app");
        sql.append(" AND resource=$resource");
        sql.append(" AND time>=$startTime");
        sql.append(" AND time<=$endTime");

        Map<String, Object> paramMap = new HashMap<String, Object>();
        paramMap.put("app", app);
        paramMap.put("resource", resource);
        paramMap.put("startTime", DateFormatUtils.format(new Date(startTime), DATE_FORMAT_PATTERN));
        paramMap.put("endTime", DateFormatUtils.format(new Date(endTime), DATE_FORMAT_PATTERN));

        List<MetricPO> metricPOS = InfluxDBUtils.queryList(SENTINEL_DATABASE, sql.toString(), paramMap, MetricPO.class);

        if (CollectionUtils.isEmpty(metricPOS)) {
            return results;
        }

        for (MetricPO metricPO : metricPOS) {
            results.add(convertToMetricEntity(metricPO));
        }

        return results;
    }

    @Override
    public List<String> listResourcesOfApp(String app) {
        List<String> results = new ArrayList<>();
        if (StringUtil.isBlank(app)) {
            return results;
        }

        StringBuilder sql = new StringBuilder();
        sql.append("SELECT * FROM " + METRIC_MEASUREMENT);
        sql.append(" WHERE app=$app");
        sql.append(" AND time>=$startTime");

        Map<String, Object> paramMap = new HashMap<String, Object>();
        long startTime = System.currentTimeMillis() - 1000 * 60;
        paramMap.put("app", app);
        paramMap.put("startTime", DateFormatUtils.format(new Date(startTime), DATE_FORMAT_PATTERN));

        List<MetricPO> metricPOS = InfluxDBUtils.queryList(SENTINEL_DATABASE, sql.toString(), paramMap, MetricPO.class);

        if (CollectionUtils.isEmpty(metricPOS)) {
            return results;
        }

        List<MetricEntity> metricEntities = new ArrayList<MetricEntity>();
        for (MetricPO metricPO : metricPOS) {
            metricEntities.add(convertToMetricEntity(metricPO));
        }

        Map<String, MetricEntity> resourceCount = new HashMap<>(32);

        for (MetricEntity metricEntity : metricEntities) {
            String resource = metricEntity.getResource();
            if (resourceCount.containsKey(resource)) {
                MetricEntity oldEntity = resourceCount.get(resource);
                oldEntity.addPassQps(metricEntity.getPassQps());
                oldEntity.addRtAndSuccessQps(metricEntity.getRt(), metricEntity.getSuccessQps());
                oldEntity.addBlockQps(metricEntity.getBlockQps());
                oldEntity.addExceptionQps(metricEntity.getExceptionQps());
                oldEntity.addCount(1);
            } else {
                resourceCount.put(resource, MetricEntity.copyOf(metricEntity));
            }
        }

        // Order by last minute b_qps DESC.
        return resourceCount.entrySet()
                .stream()
                .sorted((o1, o2) -> {
                    MetricEntity e1 = o1.getValue();
                    MetricEntity e2 = o2.getValue();
                    int t = e2.getBlockQps().compareTo(e1.getBlockQps());
                    if (t != 0) {
                        return t;
                    }
                    return e2.getPassQps().compareTo(e1.getPassQps());
                })
                .map(Map.Entry::getKey)
                .collect(Collectors.toList());
    }

    private MetricEntity convertToMetricEntity(MetricPO metricPO) {
        MetricEntity metricEntity = new MetricEntity();

        metricEntity.setId(metricPO.getId());
        metricEntity.setGmtCreate(new Date(metricPO.getGmtCreate()));
        metricEntity.setGmtModified(new Date(metricPO.getGmtModified()));
        metricEntity.setApp(metricPO.getApp());
        metricEntity.setTimestamp(Date.from(metricPO.getTime()));
        metricEntity.setResource(metricPO.getResource());
        metricEntity.setPassQps(metricPO.getPassQps());
        metricEntity.setSuccessQps(metricPO.getSuccessQps());
        metricEntity.setBlockQps(metricPO.getBlockQps());
        metricEntity.setExceptionQps(metricPO.getExceptionQps());
        metricEntity.setRt(metricPO.getRt());
        metricEntity.setCount(metricPO.getCount());

        return metricEntity;
    }

    private void doSave(InfluxDB influxDB, MetricEntity metric) {
        influxDB.write(Point.measurement(METRIC_MEASUREMENT)
                .time(DateUtils.addHours(metric.getTimestamp(), 8).getTime(), TimeUnit.MILLISECONDS)
                .tag("app", metric.getApp())
                .tag("resource", metric.getResource())
                .addField("id", metric.getId())
                .addField("gmtCreate", metric.getGmtCreate().getTime())
                .addField("gmtModified", metric.getGmtModified().getTime())
                .addField("passQps", metric.getPassQps())
                .addField("successQps", metric.getSuccessQps())
                .addField("blockQps", metric.getBlockQps())
                .addField("exceptionQps", metric.getExceptionQps())
                .addField("rt", metric.getRt())
                .addField("count", metric.getCount())
                .addField("resourceCode", metric.getResourceCode())
                .build());
    }
}

其中：

save、saveAll方法通過呼叫InfluxDBUtils.insert和InfluxDBInsertCallback回撥方法，往sentinel_db庫的sentinel_metric資料表寫資料；

saveAll方法不是迴圈呼叫save方法，而是在回撥內部迴圈Iterable<MetricEntity> metrics處理，這樣InfluxDBFactory.connect連線只打開關閉一次；

doSave方法中，.time(DateUtils.addHours(metric.getTimestamp(), 8).getTime(), TimeUnit.MILLISECONDS)

因InfluxDB的UTC時間暫時沒找到修改方法，所以這裡time時間列加了8個小時時差；

queryByAppAndResourceBetween、listResourcesOfApp裡面的查詢方法，使用InfluxDB提供的類sql語法，編寫查詢語句即可。

 

最後一步，在MetricsRepository、MetricController類注入的metricStore屬性，加上@Qualifier("influxDBMetricsRepository")註解：

@Qualifier("influxDBMetricsRepository")
@Autowired
private MetricsRepository<MetricEntity> metricStore;

 

來驗證下成果：

設定sentinel-dashboard工程啟動引數：-Dserver.port=8080 -Dcsp.sentinel.dashboard.server=localhost:8080 -Dproject.name=sentinel-dashboard

啟動工程，開啟http://localhost:8080，檢視不同的頁面均顯示正常，

在命令列通過InfluxDB客戶端命令，show measurements：可以看到已經生成了sentinel_metric資料表(measurement)；

查詢總數：select count(id) from sentinel_metric

查詢最新5行資料：select * from sentinel_metric order by time desc limit 5

注：命令列語句結束不用加分號

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

程式碼參考：https://github.com/cdfive/Sentinel/tree/winxuan_develop/sentinel-dashboard

擴充套件：

1.考慮以什麼時間維度歸檔歷史資料；

2.結合grafana把監控資料進行多維度的統計和呈現。

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

參考：

https://github.com/alibaba/Sentinel/wiki/控制檯

https://github.com/alibaba/Sentinel/wiki/在生產環境中使用-Sentinel-控制檯

官網文件 https://docs.influxdata.com/influxdb/v1.6/introduction/getting-started/

InfluxDB簡明手冊 https://xtutu.gitbooks.io/influxdb-handbook/content/

 

相關推薦

sentinel控制檯監控資料持久化【InfluxDB】

根據官方wiki文件，sentinel控制檯的實時監控資料，預設僅儲存 5 分鐘以內的資料。如需持久化，需要定製實現相關介面。 https://github.com/alibaba/Sentinel/wiki/在生產環境中使用-Sentinel-控制檯 也給出了指導步驟： 1.自行擴充套件實現 Metri

sentinel控制臺監控數據持久化【MySQL】

bean png public stringbu arc rop 連接 uid lec 根據官方wiki文檔，sentinel控制臺的實時監控數據，默認僅存儲 5 分鐘以內的數據。如需持久化，需要定制實現相關接口。 https://github.com/alibaba/Se

prometheus基於influxdb的監控資料持久化儲存方案

用prometheus在線上跑了兩年了，都是用的本地磁碟做資料儲存，磁碟空間有限，當空間不足時直接刪除資料檔案。近期監控系統正式上

SpringBoot 2.0 + InfluxDB+ Sentinel 實時監控資料儲存

前言 阿里巴巴提供的控制檯只是用於演示 Sentinel 的基本能力和工作流程，並沒有依賴生產環境中所必需的元件，比如持久化的後端資料庫、可靠的配置中心等。目前 Sentinel 採用記憶體態的方式儲存監控和規則資料，監控最長儲存時間為 5 分鐘，控制檯重啟後資料丟失。 企業版 這裡推薦一下阿里雲的官方版

【InfluxDB】InfluxDB學習實踐筆記

日誌 class 例如 study search 用戶 一個 命令行 書寫方式 InfluxDB是用Go編寫的一個開源分布式時序、事件和指標數據庫，無需外部依賴。它與Elasticsearch、Graphite等類似。比較適用於與事件緊密相關的數據，例如實時日誌數據、實

python for 資料型別【字典】

dict 字典 {} python唯一的一個鍵值對資料鍵值對 {鍵:值}鍵必須是不可變的資料型別字典是不能當字典的鍵,因為字典是可變的值是沒有任何要求的dic = {'key':'v',1:'True',False:'asdf',(1,2,3):[1,2,3,4]}len()for i in dic

python for 資料型別【集合】

set 集合 {} 無序s = {1,2,3,4,5}s = {}print(type(s)) # 空{}就是字典s = {1,2,3,4,5}s = {1,2,3,'22','ss',False,(3,4)}列表 和 字典 和 集合print(s)增s.add(8)print(s)s.update(

全網最牛乾貨！！！ 年薪80萬的大資料開發【教程】讀完此文全掌握！！！

事實上，大資料工作者可以施展拳腳的領域非常廣泛，從國防部、網際網路創業公司到金融機構，到處需要大資料專案來做創新驅動。 其實JAVA工程師轉型大資料有著天然優勢，不僅僅是前景和薪資等。技術層面來說，大資料使用的Hadoop(在分散式伺服器叢集上儲存海量資料並執行分散式分析應用的一種方法)需要JA

機器學習資料集【轉】

500款各領域機器學習資料集,總有一個是你要找的 金融 美國勞工部統計局官方釋出資料：http://dataju.cn/Dataju/web/datasetInstanceDetail/139 滬深股票除權除息、配股增發全量資料，截止 2016.12.31 http://dataju.c

【洛谷P1738】洛谷的資料夾【Trie】

題目大意： 給出nnn個目錄地址，為了使這些資料夾都存在，需要新建幾個資料夾？ 思路: 一眼看上去就是TrieTrieTrie。雖然暴力可過。 這道題其實就是不用查詢的TrieTrieTrie。直接

大話資料結構【2】—演算法

  經常聽他們吹牛逼，這個用了什麼什麼牛逼的演算法，起了一個牛哄哄的名字，反正挺嚇人人的，不知道為什麼，現在給新東西起名字是越來越“嚇人了”！   其實演算法就是解決特定問題的求解步驟，在計算機中表現為指令的有限序列。沒有什麼嚇人的東西，只是它的思想很精妙，有些作者可能是為

2018年最強幹貨！年薪80萬+的大資料開發【教程】都在這兒！

事實上，大資料工作者可以施展拳腳的領域非常廣泛，從國防部、網際網路創業公司到金融機構，到處需要大資料專案來做創新驅動。 其實JAVA工程師轉型大資料有著天然優勢，不僅僅是前景和薪資等。技術層面來說，大資料使用的Hadoop(在分散式伺服器叢集上儲存海量資料並執行分散式分析應

利用Python進行資料分析【01】-資料型別及結構

Python資料型別詳解 Python基本資料型別一般分為:數字、字串、列表、元組、字典、集合這六種基本資料型別。下面分別來介紹這幾種資料型別基本用法。 目錄 數字—>int 類 字串 —>str類 列表—>list類 元組—>tupl

大資料學習乾貨，年薪50萬+的大資料開發【教程】都在這兒！

事實上，大資料工作者可以施展拳腳的領域非常廣泛，從國防部、網際網路創業公司到金融機構，到處需要大資料專案來做創新驅動。 其實JAVA工程師轉型大資料有著天然優勢，不僅僅是前景和薪資等。技術層面來說，大資料使用的Hadoop(在分散式伺服器叢集上儲存海量資料並執行

【Jmeter】解決從csv引數檔案中獲取帶引號/逗號的資料問題【轉】

原文：【jmeter隨筆（3）-從csv中獲取帶引號的資料詳情】  點選檢視原文 作者：黑夜小怪 軟體測試技術交流群 : 429183023  最近在工作中，對jmeter實踐的點滴的記錄這裡分享，不一定正確，僅供參考和討論，有想法的歡迎留言、談論。 1技巧

lua和C++相互交換資料1 【轉】

Lua生來就是為了和C互動的，因此使用C擴充套件Lua或者將Lua嵌入到C當中都是非常流行的做法。要想理解C和Lua的互動方式，首先要回顧一下C語言是如何處理函式引數的。 C函式和引數 大家知道C語言是用匯編實現的，在組合語言中可沒有函式的概念，與函式對應的是叫做子過程

objective-c基本資料型別【轉】

1、Object-c提供基本資料型別:int、float 、double 、char     示例程式碼測位元組數： //資料型別：         //整形（int、short int、long int、unsigned int、unsigned shor

年薪40w的大資料開發【教程】，都在這兒！

全球最頂尖管理諮詢公司麥肯錫(McKinsey)出具的一份詳細分析報告顯示，預計到2018年，大

機器學習和深度學習資料彙總【02】

介紹:使用卷積神經網路的影象縮放. 介紹:ICML2015 論文集,優化4個+稀疏優化1個；強化學習4個，深度學習3個+深度學習計算1個；貝葉斯非參、高斯過程和學習理論3個；還有計算廣告和社會選擇.ICML2015 Sessions. 介紹:使

檔案監控效能問題【BUG】

# 檔案監控效能問題【BUG】 背景：JAVA寫了一個資料夾目錄監控的程式，使用的是org.apache.commons.io.monitor 包，專案穩定運行了一個月，現場反饋，資料夾資料處理越來越慢，等到資料推送到前端要好幾分鐘，於是開始了尋找問題的路程。 ## 監控程式碼 [之前寫的檔案監控程式