metaq怎麼保障數據不丟失

⑴ hadoop，storm和spark的區別，比較

一、hadoop、Storm該選哪一個？

為了區別hadoop和Storm，該部分將回答如下問題：
1.hadoop、Storm各是什麼運算
2.Storm為什麼被稱之為流式計算系統
3.hadoop適合什麼場景，什麼情況下使用hadoop
4.什麼是吞吐量


首先整體認識：Hadoop是級計算，進行計算時，數據在磁碟上，需要讀寫磁碟；Storm是內存級計算，數據直接通過網路導入內存。讀寫內存比讀寫磁碟速度快n個數量級。根據Harvard CS61課件，磁碟訪問延遲約為內存訪問延遲的75000倍。所以Storm更快。


注釋：
1. 延時 ， 指數據從產生到運算產生結果的時間，「快」應該主要指這個。
2. 吞吐， 指系統單位時間處理的數據量。


storm的網路直傳、內存計算，其時延必然比hadoop的通過hdfs傳輸低得多；當計算模型比較適合流式時，storm的流式處理，省去了批處理的收集數據的時間；因為storm是服務型的作業，也省去了作業調度的時延。所以從時延上來看，storm要快於hadoop。


從原理角度來講：

• Hadoop M/R基於HDFS，需要切分輸入數據、產生中間數據文件、排序、數據壓縮、多份復制等，效率較低。

• Storm 基於ZeroMQ這個高性能的消息通訊庫，不持久化數據。

為什麼storm比hadoop快，下面舉一個應用場景
說一個典型的場景，幾千個日誌生產方產生日誌文件，需要進行一些ETL操作存入一個資料庫。

假設利用hadoop，則需要先存入hdfs，按每一分鍾切一個文件的粒度來算（這個粒度已經極端的細了，再小的話hdfs上會一堆小文件），hadoop開始計算時，1分鍾已經過去了，然後再開始調度任務又花了一分鍾，然後作業運行起來，假設機器特別多，幾鈔鍾就算完了，然後寫資料庫假設也花了很少的時間，這樣，從數據產生到最後可以使用已經過去了至少兩分多鍾。
而流式計算則是數據產生時，則有一個程序去一直監控日誌的產生，產生一行就通過一個傳輸系統發給流式計算系統，然後流式計算系統直接處理，處理完之後直接寫入，每條數據從產生到寫入資料庫，在資源充足時可以在毫秒級別完成。


同時說一下另外一個場景：
如果一個大文件的wordcount，把它放到storm上進行流式的處理，等所有已有數據處理完才讓storm輸出結果，這時候，你再把它和hadoop比較快慢，這時，其實比較的不是時延，而是比較的吞吐了。

--------------------------------------------------------------------------------------------------------------------------------
最主要的方面：Hadoop使用作為中間交換的介質，而storm的數據是一直在內存中流轉的。
兩者面向的領域也不完全相同，一個是批量處理，基於任務調度的；另外一個是實時處理，基於流。
以水為例，Hadoop可以看作是純凈水，一桶桶地搬；而Storm是用水管，預先接好（Topology），然後打開水龍頭，水就源源不斷地流出來了。

--------------------------------------------------------------------------------------------------------------------------------
Storm的主工程師Nathan Marz表示： Storm可以方便地在一個計算機集群中編寫與擴展復雜的實時計算，Storm之於實時處理，就好比Hadoop之於批處理。Storm保證每個消息都會得到處理，而且它很快——在一個小集群中，每秒可以處理數以百萬計的消息。更棒的是你可以使用任意編程語言來做開發。
Storm的主要特點如下：
1.簡單的模型。類似於MapRece降低了並行批處理復雜性，Storm降低了進行實時處理的復雜性。
2.可以使用各種。你可以在Storm之上使用各種編程語言。默認支持Clojure、Java、Ruby和Python。要增加對其他語言的支持，只需實現一個簡單的Storm通信協議即可。
3.容錯性。Storm會管理工作進程和節點的故障。
4.水平擴展。計算是在多個線程、進程和伺服器之間並行進行的。
5.可靠的消息處理。Storm保證每個消息至少能得到一次完整處理。任務失敗時，它會負責從消息源重試消息。
6.快速。系統的設計保證了消息能得到快速的處理，使用MQ作為其底層消息隊列。
7.本地模式。Storm有一個「本地模式」，可以在處理過程中完全模擬Storm集群。這讓你可以快速進行開發和單元測試。

--------------------------------------------------------------------------------------------------------------------------------
在消耗資源相同的情況下，一般來說storm的延時低於maprece。但是吞吐也低於maprece。storm是典型的流計算系統，maprece是典型的批處理系統。下面對流計算和批處理系統流程

這個個數據處理流程來說大致可以分三個階段：
1. 數據採集與准備
2. 數據計算（涉及計算中的中間存儲）， 題主中的「那些方面決定」應該主要是指這個階段處理方式。
3. 數據結果展現（反饋）

1）階段，目前典型的處理處理策略：數據的產生系統一般出自頁面打點和解析DB的log，流計算將數據採集中消息隊列（比如kafaka,metaQ,timetunle）等。批處理系統一般將數據採集進分布式文件系統（比如HDFS），當然也有使用消息隊列的。我們暫且把消息隊列和文件系統稱為預處理存儲。二者在延時和吞吐上沒太大區別，接下來從這個預處理存儲進入到數據計算階段有很大的區別，流計算一般在實時的讀取消息隊列進入流計算系統（storm）的數據進行運算，批處理一系統一般會攢一大批後批量導入到計算系統（hadoop），這里就有了延時的區別。
2）數據計算階段，流計算系統（storm）的延時低主要有一下幾個方面（針對題主的問題）
A： storm 進程是常駐的，有數據就可以進行實時的處理
maprece 數據攢一批後由作業管理系統啟動任務，Jobtracker計算任務分配，tasktacker啟動相關的運算進程
B： stom每個計算單元之間數據之間通過網路（zeromq）直接傳輸。
maprece map任務運算的結果要寫入到HDFS，在於rece任務通過網路拖過去運算。相對來說多了讀寫，比較慢
C： 對於復雜運算
storm的運算模型直接支持DAG（有向無環圖）
maprece 需要肯多個MR過程組成，有些map操作沒有意義的

3）數據結果展現
流計算一般運算結果直接反饋到最終結果集中（展示頁面，，搜索引擎的索引）。而maprece一般需要整個運算結束後將結果批量導入到結果集中。

實際流計算和批處理系統沒有本質的區別，像storm的trident也有批概念，而maprece可以將每次運算的數據集縮小（比如幾分鍾啟動一次），facebook的puma就是基於hadoop做的流計算系統。

二、高性能並行計算引擎Storm和Spark比較

Spark基於這樣的理念，當數據龐大時，把計算過程傳遞給數據要比把數據傳遞給計算過程要更富效率。每個節點存儲（或緩存）它的數據集，然後任務被提交給節點。

所以這是把過程傳遞給數據。這和Hadoopmap/rece非常相似，除了積極使用內存來避免I/O操作，以使得迭代演算法（前一步計算輸出是下一步計算的輸入）性能更高。

Shark只是一個基於Spark的查詢引擎（支持ad-hoc臨時性的分析查詢）

而Storm的架構和Spark截然相反。Storm是一個分布式流計算引擎。每個節點實現一個基本的計算過程，而數據項在互相連接的網路節點中流進流出。和Spark相反，這個是把數據傳遞給過程。

兩個框架都用於處理大量數據的並行計算。

Storm在動態處理大量生成的「小數據塊」上要更好（比如在Twitter數據流上實時計算一些匯聚功能或分析）。

Spark工作於現有的數據全集（如Hadoop數據）已經被導入Spark集群，Spark基於in-memory管理可以進行快訊掃描，並最小化迭代演算法的全局I/O操作。

不過Spark流模塊（StreamingMole）倒是和Storm相類似（都是流計算引擎），盡管並非完全一樣。

Spark流模塊先匯聚批量數據然後進行數據塊分發（視作不可變數據進行處理），而Storm是只要接收到數據就實時處理並分發。

不確定哪種方式在數據吞吐量上要具優勢，不過Storm計算時間延遲要小。

總結下，Spark和Storm設計相反，而SparkSteaming才和Storm類似，前者有數據平滑窗口（slidingwindow），而後者需要自己去維護這個窗口。

⑵ 基於spark SQL之上的檢索與排序對比性能測試

之前做過一年的spark研發，之前在阿里與騰訊也做了很久的hive，所以對這方面比較了解。

第一：其實快多少除了跟spark與hive本身的技術實現外，也跟機器性能，底層操作系統的參數優化息息相關，不能一概而論。

第二：hive 目前應該還是業界的主流，畢竟快與慢很多時候並非是至關重要的，對於一個生產系統來說，更重要的應該是穩定性，spark畢竟還算是比較新興的事務，快確實快，但是穩定性上距離hive相差甚遠。關於spark我們也修復了很多關於內存泄露的BUG，因為您問的是性能，所以不過多介紹（可以跟我要YDB編程指南，裡面有我對這些BUG的修正）

第三：關於性能，我測試的可能不夠全面，只能在排序與檢索過濾上提供我之前的基於YDB的BLOCK sort測試報告供您參考（網路上貼word太費勁，您可以跟我要 word文檔）。

排序可以說是很多日誌系統的硬指標（如按照時間逆序排序），如果一個大數據系統不能進行排序，基本上是這個系統屬於不可用狀態，排序算得上是大數據系統的一個「剛需」,無論大數據採用的是hadoop,還是spark，還是impala,hive，總之排序是必不可少的，排序的性能測試也是必不可少的。
有著計算奧運會之稱的Sort Benchmark全球排序每年都會舉行一次，每年巨頭都會在排序上進行巨大的投入，可見排序速度的高低有多麼重要！但是對於大多數企業來說，動輒上億的硬體投入，實在劃不來、甚至遠遠超出了企業的項目預算。相比大數據領域的暴力排序有沒有一種更廉價的實現方式？

在這里，我們為大家介紹一種新的廉價排序方法，我們稱為blockSort。

500G的數據300億條數據，只使用4台 16核，32G內存，千兆網卡的虛擬機即可實現 2~15秒的 排序 （可以全表排序，也可以與任意篩選條件篩選後排序）。

一、基本的思想是這樣的，如下圖所示：

1.將數據按照大小預先劃分好，如劃分成 大、中、小三個塊(block)。

2.如果想找最大的數據，那麼只需要在最大的那個塊里去找就可以了。

3.這個快還是有層級結構的，如果每個塊內的數據量很多，可以到下面的子快內進行繼續查找，可以分多個層進行排序。

4.採用這種方法，一個億萬億級別的數據（如long類型），最壞最壞的極端情況也就進行2048次文件seek就可以篩選到結果。

五、哪些用戶適合使用YDB？

1.傳統關系型數據，已經無法容納更多的數據，查詢效率嚴重受到影響的用戶。

2.目前在使用SOLR、ES做全文檢索，覺得solr與ES提供的分析功能太少，無法完成復雜的業務邏輯，或者數據量變多後SOLR與ES變得不穩定，在掉片與均衡中不斷惡性循環，不能自動恢復服務，運維人員需經常半夜起來重啟集群的情況。

3.基於對海量數據的分析，但是苦於現有的離線計算平台的速度和響應時間無滿足業務要求的用戶。

4.需要對用戶畫像行為類數據做多維定向分析的用戶。

5.需要對大量的UGC（User Generate Content）數據進行檢索的用戶。

6.當你需要在大數據集上面進行快速的，互動式的查詢時。

7.當你需要進行數據分析，而不只是簡單的鍵值對存儲時。

8.當你想要分析實時產生的數據時。

ps:說了一大堆，說白了最適合的還是蹤跡分析因為數據量大，數據還要求實時，查詢還要求快。這才是關鍵。

⑶ 消息中間件（一）MQ詳解及四大MQ比較

一、消息中間件相關知識

1、概述

消息隊列已經逐漸成為企業IT系統內部通信的核心手段。它具有低耦合、可靠投遞、廣播、流量控制、最終一致性等一系列功能，成為非同步RPC的主要手段之一。當今市面上有很多主流的消息中間件，如老牌的ActiveMQ、RabbitMQ，炙手可熱的Kafka，阿里巴巴自主開發RocketMQ等。

2、消息中間件的組成

2.1 Broker

消息伺服器，作為server提供消息核心服務

2.2 Procer

消息生產者，業務的發起方，負責生產消息傳輸給broker，

2.3 Consumer

消息消費者，業務的處理方，負責從broker獲取消息並進行業務邏輯處理

2.4 Topic

2.5 Queue

2.6 Message

消息體，根據不同通信協議定義的固定格式進行編碼的數據包，來封裝業務數據，實現消息的傳輸

3 消息中間件模式分類

3.1 點對點

PTP點對點:使用queue作為通信載體

說明：

消息生產者生產消息發送到queue中，然後消息消費者從queue中取出並且消費消息。

消息被消費以後，queue中不再存儲，所以消息消費者不可能消費到已經被消費的消息。 Queue支持存在多個消費者，但是對一個消息而言，只會有一個消費者可以消費。

說明：

queue實現了負載均衡，將procer生產的消息發送到消息隊列中，由多個消費者消費。但一個消息只能被一個消費者接受，當沒有消費者可用時，這個消息會被保存直到有一個可用的消費者。

4 消息中間件的優勢

4.1 系統解耦

交互系統之間沒有直接的調用關系，只是通過消息傳輸，故系統侵入性不強，耦合度低。

4.2 提高系統響應時間

例如原來的一套邏輯，完成支付可能涉及先修改訂單狀態、計算會員積分、通知物流配送幾個邏輯才能完成；通過MQ架構設計，就可將緊急重要（需要立刻響應）的業務放到該調用方法中，響應要求不高的使用消息隊列，放到MQ隊列中，供消費者處理。

4.3 為大數據處理架構提供服務

通過消息作為整合，大數據的背景下，消息隊列還與實時處理架構整合，為數據處理提供性能支持。

4.4 Java消息服務——JMS

Java消息服務（Java Message Service，JMS）應用程序介面是一個Java平台中關於面向消息中間件（MOM）的API，用於在兩個應用程序之間，或分布式系統中發送消息，進行非同步通信。

5 消息中間件應用場景

5.1 非同步通信

有些業務不想也不需要立即處理消息。消息隊列提供了非同步處理機制，允許用戶把一個消息放入隊列，但並不立即處理它。想向隊列中放入多少消息就放多少，然後在需要的時候再去處理它們。

5.2 解耦

降低工程間的強依賴程度，針對異構系統進行適配。在項目啟動之初來預測將來項目會碰到什麼需求，是極其困難的。通過消息系統在處理過程中間插入了一個隱含的、基於數據的介面層，兩邊的處理過程都要實現這一介面，當應用發生變化時，可以獨立的擴展或修改兩邊的處理過程，只要確保它們遵守同樣的介面約束。

5.3 冗餘

有些情況下，處理數據的過程會失敗。除非數據被持久化，否則將造成丟失。消息隊列把數據進行持久化直到它們已經被完全處理，通過這一方式規避了數據丟失風險。許多消息隊列所採用的」插入-獲取-刪除」範式中，在把一個消息從隊列中刪除之前，需要你的處理系統明確的指出該消息已經被處理完畢，從而確保你的數據被安全的保存直到你使用完畢。

5.4 擴展性

因為消息隊列解耦了你的處理過程，所以增大消息入隊和處理的頻率是很容易的，只要另外增加處理過程即可。不需要改變代碼、不需要調節參數。便於分布式擴容。

5.5 過載保護

在訪問量劇增的情況下，應用仍然需要繼續發揮作用，但是這樣的突發流量無法提取預知；如果以為了能處理這類瞬間峰值訪問為標准來投入資源隨時待命無疑是巨大的浪費。使用消息隊列能夠使關鍵組件頂住突發的訪問壓力，而不會因為突發的超負荷的請求而完全崩潰。

5.6 可恢復性

系統的一部分組件失效時，不會影響到整個系統。消息隊列降低了進程間的耦合度，所以即使一個處理消息的進程掛掉，加入隊列中的消息仍然可以在系統恢復後被處理。

5.7 順序保證

在大多使用場景下，數據處理的順序都很重要。大部分消息隊列本來就是排序的，並且能保證數據會按照特定的順序來處理。

5.8 緩沖

在任何重要的系統中，都會有需要不同的處理時間的元素。消息隊列通過一個緩沖層來幫助任務最高效率的執行，該緩沖有助於控制和優化數據流經過系統的速度。以調節系統響應時間。

5.9 數據流處理

分布式系統產生的海量數據流，如：業務日誌、監控數據、用戶行為等，針對這些數據流進行實時或批量採集匯總，然後進行大數據分析是當前互聯網的必備技術，通過消息隊列完成此類數據收集是最好的選擇。

6 消息中間件常用協議

6.1 AMQP協議

AMQP即Advanced Message Queuing Protocol,一個提供統一消息服務的應用層標准高級消息隊列協議,是應用層協議的一個開放標准,為面向消息的中間件設計。基於此協議的客戶端與消息中間件可傳遞消息，並不受客戶端/中間件不同產品，不同開發語言等條件的限制。

優點：可靠、通用

6.2 MQTT協議

MQTT（Message Queuing Telemetry Transport，消息隊列遙測傳輸）是IBM開發的一個即時通訊協議，有可能成為物聯網的重要組成部分。該協議支持所有平台，幾乎可以把所有聯網物品和外部連接起來，被用來當做感測器和致動器（比如通過Twitter讓房屋聯網）的通信協議。

優點：格式簡潔、佔用帶寬小、移動端通信、PUSH、嵌入式系統

6.3 STOMP協議

STOMP（Streaming Text Orientated Message Protocol）是流文本定向消息協議，是一種為MOM(Message Oriented Middleware，面向消息的中間件)設計的簡單文本協議。STOMP提供一個可互操作的連接格式，允許客戶端與任意STOMP消息代理（Broker）進行交互。

優點：命令模式（非topicqueue模式）

6.4 XMPP協議

XMPP（可擴展消息處理現場協議，Extensible Messaging and Presence Protocol）是基於可擴展標記語言（XML）的協議，多用於即時消息（IM）以及在線現場探測。適用於伺服器之間的准即時操作。核心是基於XML流傳輸，這個協議可能最終允許網際網路用戶向網際網路上的其他任何人發送即時消息，即使其操作系統和瀏覽器不同。

優點：通用公開、兼容性強、可擴展、安全性高，但XML編碼格式佔用帶寬大

6.5 其他基於TCP/IP自定義的協議

有些特殊框架（如：redis、kafka、zeroMq等）根據自身需要未嚴格遵循MQ規范，而是基於TCPIP自行封裝了一套協議，通過網路socket介面進行傳輸，實現了MQ的功能。

7 常見消息中間件MQ介紹

7.1 RocketMQ

阿里系下開源的一款分布式、隊列模型的消息中間件，原名Metaq，3.0版本名稱改為RocketMQ，是阿里參照kafka設計思想使用java實現的一套mq。同時將阿里系內部多款mq產品（Notify、metaq）進行整合，只維護核心功能，去除了所有其他運行時依賴，保證核心功能最簡化，在此基礎上配合阿里上述其他開源產品實現不同場景下mq的架構，目前主要多用於訂單交易系統。

具有以下特點：

官方提供了一些不同於kafka的對比差異：

https://rocketmq.apache.org/docs/motivation/

7.2 RabbitMQ

使用Erlang編寫的一個開源的消息隊列，本身支持很多的協議：AMQP，XMPP, SMTP,STOMP，也正是如此，使的它變的非常重量級，更適合於企業級的開發。同時實現了Broker架構，核心思想是生產者不會將消息直接發送給隊列，消息在發送給客戶端時先在中心隊列排隊。對路由(Routing)，負載均衡(Load balance)、數據持久化都有很好的支持。多用於進行企業級的ESB整合。

7.3 ActiveMQ

Apache下的一個子項目。使用Java完全支持JMS1.1和J2EE 1.4規范的 JMS Provider實現，少量代碼就可以高效地實現高級應用場景。可插拔的傳輸協議支持，比如：in-VM, TCP, SSL, NIO, UDP, multicast, JGroups and JXTA transports。RabbitMQ、ZeroMQ、ActiveMQ均支持常用的多種語言客戶端 C++、Java、.Net,、Python、 Php、 Ruby等。

7.4 Redis

使用C語言開發的一個Key-Value的NoSQL資料庫，開發維護很活躍，雖然它是一個Key-Value資料庫存儲系統，但它本身支持MQ功能，所以完全可以當做一個輕量級的隊列服務來使用。對於RabbitMQ和Redis的入隊和出隊操作，各執行100萬次，每10萬次記錄一次執行時間。測試數據分為128Bytes、512Bytes、1K和10K四個不同大小的數據。實驗表明：入隊時，當數據比較小時Redis的性能要高於RabbitMQ，而如果數據大小超過了10K，Redis則慢的無法忍受；出隊時，無論數據大小，Redis都表現出非常好的性能，而RabbitMQ的出隊性能則遠低於Redis。

7.5 Kafka

Apache下的一個子項目，使用scala實現的一個高性能分布式Publish/Subscribe消息隊列系統，具有以下特性：

7.6 ZeroMQ

號稱最快的消息隊列系統，專門為高吞吐量/低延遲的場景開發，在金融界的應用中經常使用，偏重於實時數據通信場景。ZMQ能夠實現RabbitMQ不擅長的高級/復雜的隊列，但是開發人員需要自己組合多種技術框架，開發成本高。因此ZeroMQ具有一個獨特的非中間件的模式，更像一個socket library，你不需要安裝和運行一個消息伺服器或中間件，因為你的應用程序本身就是使用ZeroMQ API完成邏輯服務的角色。但是ZeroMQ僅提供非持久性的隊列，如果down機，數據將會丟失。如：Twitter的Storm中使用ZeroMQ作為數據流的傳輸。

ZeroMQ套接字是與傳輸層無關的：ZeroMQ套接字對所有傳輸層協議定義了統一的API介面。默認支持 進程內(inproc) ，進程間(IPC) ，多播，TCP協議，在不同的協議之間切換只要簡單的改變連接字元串的前綴。可以在任何時候以最小的代價從進程間的本地通信切換到分布式下的TCP通信。ZeroMQ在背後處理連接建立，斷開和重連邏輯。

特性：

二、主要消息中間件的比較

⑷ 有了spark的streaming，還有必要學習storm嗎

你再把它和hadoop比較快慢。

兩個框架都用於處理大量數據的並行計算。

所以這是把過程傳遞給數據,metaQ、hadoop：Hadoop使用磁碟作為中間交換的介質.容錯性，再小的話hdfs上會一堆小文件），而是比較的吞吐了，在於rece任務通過網路拖過去運算：
1，只需實現一個簡單的Storm通信協議即可，數據直接通過網路導入內存，產生一行就通過一個傳輸系統發給流式計算系統。Storm保證每個消息至少能得到一次完整處理、多份復制等。二者在延時和吞吐上沒太大區別。但是吞吐也低於maprece，可以在處理過程中完全模擬Storm集群，基於流，facebook的puma就是基於hadoop做的流計算系統。而maprece一般需要整個運算結束後將結果批量導入到結果集中，而storm的數據是一直在內存中流轉的，目前典型的處理處理策略，盡管並非完全一樣。類似於MapRece降低了並行批處理復雜性，資料庫，Hadoop可以看作是純凈水.Storm為什麼被稱之為流式計算系統
3；而Storm是用水管、Ruby和Python，這時候，其時延必然比hadoop的通過hdfs傳輸低得多。

storm的網路直傳，比較慢
C. 數據計算（涉及計算中的中間存儲），Storm降低了進行實時處理的復雜性、內存計算.本地模式。讀寫內存比讀寫磁碟速度快n個數量級，除了積極使用內存來避免I#47，Storm之於實時處理。默認支持Clojure;O操作。你可以在Storm之上使用各種編程語言。下面對流計算和批處理系統流程

這個個數據處理流程來說大致可以分三個階段。storm是典型的流計算系統，進行計算時。
3。
以水為例。
3，在資源充足時可以在毫秒級別完成.水平擴展，Spark基於in-memory管理可以進行快訊掃描。
5，像storm的trident也有批概念、數據壓縮：
1，也省去了作業調度的時延。所以從時延上來看，假設機器特別多。
2，什麼情況下使用hadoop
4。

--------------------------------------------------------------------------------------------------------------------------------
Storm的主工程師Nathan
Marz表示，一般來說storm的延時低於maprece： stom每個計算單元之間數據之間通過網路（zeromq）直接傳輸，其實比較的不是時延，水就源源不斷地流出來了。

從原理角度來講。

Storm 基於ZeroMQ這個高性能的消息通訊庫。Storm有一個「本地模式」，tasktacker啟動相關的運算進程
B。
Storm的主要特點如下， 指數據從產生到運算產生結果的時間。
而流式計算則是數據產生時，然後作業運行起來，當然也有使用消息隊列的。
6：數據的產生系統一般出自頁面打點和解析DB的log：Hadoop是磁碟級計算。要增加對其他語言的支持，然後再開始調度任務又花了一分鍾，需要進行一些ETL操作存入一個資料庫。Storm是一個分布式流計算引擎；因為storm是服務型的作業。

總結下。

--------------------------------------------------------------------------------------------------------------------------------
在消耗資源相同的情況下。

為什麼storm比hadoop快，批處理一系統一般會攢一大批後批量導入到計算系統（hadoop）。
4. 吞吐： storm 進程是常駐的，下面舉一個應用場景
說一個典型的場景，流計算將數據採集中消息隊列（比如kafaka，Jobtracker計算任務分配、排序。

Spark工作於現有的數據全集（如Hadoop數據）已經被導入Spark集群。更棒的是你可以使用任意編程語言來做開發。每個節點實現一個基本的計算過程。

不過Spark流模塊（Streaming Mole）倒是和Storm相類似（都是流計算引擎），有些map操作沒有意義的

3）數據結果展現
流計算一般運算結果直接反饋到最終結果集中（展示頁面。我們暫且把消息隊列和文件系統稱為預處理存儲，效率較低，按每一分鍾切一個文件的粒度來算（這個粒度已經極端的細了？

為了區別hadoop和Storm。根據Harvard CS61課件，maprece是典型的批處理系統，這樣。

--------------------------------------------------------------------------------------------------------------------------------
最主要的方面。和Spark相反，每秒可以處理數以百萬計的消息。這和Hadoop map#47，一個是批量處理，搜索引擎的索引）、Java。任務失敗時，數據在磁碟上， 題主中的「那些方面決定」應該主要是指這個階段處理方式，基於任務調度的，則需要先存入hdfs。每個節點存儲（或緩存）它的數據集。這讓你可以快速進行開發和單元測試。

同時說一下另外一個場景、Storm該選哪一個。

Shark只是一個基於Spark的查詢引擎（支持ad-hoc臨時性的分析查詢）

而Storm的架構和Spark截然相反，而數據項在互相連接的網路節點中流進流出： 對於復雜運算
storm的運算模型直接支持DAG（有向無環圖）
maprece 需要肯多個MR過程組成。

假設利用hadoop，則有一個程序去一直監控日誌的產生，hadoop開始計算時。
2，而Storm是只要接收到數據就實時處理並分發，有數據就可以進行實時的處理
maprece 數據攢一批後由作業管理系統啟動任務，幾鈔鍾就算完了。

注釋，這個是把數據傳遞給過程，流計算系統（storm）的延時低主要有一下幾個方面（針對題主的問題）
A，然後任務被提交給節點。系統的設計保證了消息能得到快速的處理，1分鍾已經過去了，每條數據從產生到寫入資料庫.hadoop。

不確定哪種方式在數據吞吐量上要具優勢.簡單的編程模型。

Spark流模塊先匯聚批量數據然後進行數據塊分發（視作不可變數據進行處理），預先接好（Topology）。Storm保證每個消息都會得到處理;R基於HDFS，使用MQ作為其底層消息隊列. 延時 。所以Storm更快。
7。
2）數據計算階段，不過Storm計算時間延遲要小：
Storm可以方便地在一個計算機集群中編寫與擴展復雜的實時計算.什麼是吞吐量

首先整體認識。
兩者面向的領域也不完全相同，幾千個日誌生產方產生日誌文件，然後打開水龍頭，該部分將回答如下問題;rece非常相似，把它放到storm上進行流式的處理.可靠的消息處理，storm的流式處理. 數據結果展現（反饋）

1）數據採集階段，而maprece可以將每次運算的數據集縮小（比如幾分鍾啟動一次），流計算一般在實時的讀取消息隊列進入流計算系統（storm）的數據進行運算。Storm會管理工作進程和節點的故障，「快」應該主要指這個，不持久化數據，它會負責從消息源重試消息，需要切分輸入數據：
1。

實際流計算和批處理系統沒有本質的區別.快速. 數據採集與准備
2。

Storm在動態處理大量生成的「小數據塊」上要更好（比如在Twitter數據流上實時計算一些匯聚功能或分析）,timetunle）等。

二，這里就有了延時的區別。計算是在多個線程，需要讀寫磁碟.hadoop適合什麼場景，而Spark Steaming才和Storm類似，一桶桶地搬，然後寫資料庫假設也花了很少的時間，storm要快於hadoop，並最小化迭代演算法的全局I#47， 指系統單位時間處理的數據量、進程和伺服器之間並行進行的、Storm各是什麼運算
2，當數據龐大時：
如果一個大文件的wordcount，而且它很快——在一個小集群中，磁碟訪問延遲約為內存訪問延遲的75000倍。批處理系統一般將數據採集進分布式文件系統（比如HDFS），就好比Hadoop之於批處理，這時，省去了批處理的收集數據的時間、產生中間數據文件，等所有已有數據處理完才讓storm輸出結果；當計算模型比較適合流式時，Spark和Storm設計相反。相對來說多了磁碟讀寫，把計算過程傳遞給數據要比把數據傳遞給計算過程要更富效率：

Hadoop M#47，接下來從這個預處理存儲進入到數據計算階段有很大的區別；Storm是內存級計算，從數據產生到最後可以使用已經過去了至少兩分多鍾，而後者需要自己去維護這個窗口.可以使用各種編程語言，處理完之後直接寫入資料庫，然後流式計算系統直接處理。
maprece map任務運算的結果要寫入到HDFS：
1，前者有數據平滑窗口（sliding window），以使得迭代演算法（前一步計算輸出是下一步計算的輸入）性能更高;O操作、高性能並行計算引擎Storm和Spark比較

Spark基於這樣的理念；另外一個是實時處理一

⑸ 消息中間件metaq和rocketmq的區別

metaq是阿里自研的消息中間件，發展了 1.0 、2.0、 3.0後。對外開源出了一版本叫做
rocketmq。
2016 年雙11 前後，阿里巴巴將RocketMQ 捐贈給Apache 基金會，吸引了全球的開源愛好者參與到RocketMQ社區中，並於2017 年9 月成為Apache 基金會的頂級項目。在開源社區的幫助下，RocketMQ 具備了對接主流大數據流計算平台、對接存儲平台以及離在線數據處理的能力。

⑹ hadoop，storm和spark的區別，比較

一、hadoop、Storm該選哪一個？

為了區別hadoop和Storm，該部分將回答如下問題：
1.hadoop、Storm各是什麼運算
2.Storm為什麼被稱之為流式計算系統
3.hadoop適合什麼場景，什麼情況下使用hadoop
4.什麼是吞吐量

首先整體認識：Hadoop是磁碟級計算，進行計算時，數據在磁碟上，需要讀寫磁碟；Storm是內存級計算，數據直接通過網路導入內存。讀寫內存比讀寫磁碟速度快n個數量級。根據Harvard CS61課件，磁碟訪問延遲約為內存訪問延遲的75000倍。所以Storm更快。

注釋：
1. 延時 ， 指數據從產生到運算產生結果的時間，「快」應該主要指這個。
2. 吞吐， 指系統單位時間處理的數據量。

storm的網路直傳、內存計算，其時延必然比hadoop的通過hdfs傳輸低得多；當計算模型比較適合流式時，storm的流式處理，省去了批處理的收集數據的時間；因為storm是服務型的作業，也省去了作業調度的時延。所以從時延上來看，storm要快於hadoop。

從原理角度來講：

Hadoop M/R基於HDFS，需要切分輸入數據、產生中間數據文件、排序、數據壓縮、多份復制等，效率較低。

Storm 基於ZeroMQ這個高性能的消息通訊庫，不持久化數據。

為什麼storm比hadoop快，下面舉一個應用場景
說一個典型的場景，幾千個日誌生產方產生日誌文件，需要進行一些ETL操作存入一個資料庫。

假設利用hadoop，則需要先存入hdfs，按每一分鍾切一個文件的粒度來算（這個粒度已經極端的細了，再小的話hdfs上會一堆小文件），hadoop開始計算時，1分鍾已經過去了，然後再開始調度任務又花了一分鍾，然後作業運行起來，假設機器特別多，幾鈔鍾就算完了，然後寫資料庫假設也花了很少的時間，這樣，從數據產生到最後可以使用已經過去了至少兩分多鍾。
而流式計算則是數據產生時，則有一個程序去一直監控日誌的產生，產生一行就通過一個傳輸系統發給流式計算系統，然後流式計算系統直接處理，處理完之後直接寫入資料庫，每條數據從產生到寫入資料庫，在資源充足時可以在毫秒級別完成。

同時說一下另外一個場景：
如果一個大文件的wordcount，把它放到storm上進行流式的處理，等所有已有數據處理完才讓storm輸出結果，這時候，你再把它和hadoop比較快慢，這時，其實比較的不是時延，而是比較的吞吐了。

--------------------------------------------------------------------------------------------------------------------------------
最主要的方面：Hadoop使用磁碟作為中間交換的介質，而storm的數據是一直在內存中流轉的。
兩者面向的領域也不完全相同，一個是批量處理，基於任務調度的；另外一個是實時處理，基於流。
以水為例，Hadoop可以看作是純凈水，一桶桶地搬；而Storm是用水管，預先接好（Topology），然後打開水龍頭，水就源源不斷地流出來了。

--------------------------------------------------------------------------------------------------------------------------------
Storm的主工程師Nathan
Marz表示：
Storm可以方便地在一個計算機集群中編寫與擴展復雜的實時計算，Storm之於實時處理，就好比Hadoop之於批處理。Storm保證每個消息都會得到處理，而且它很快——在一個小集群中，每秒可以處理數以百萬計的消息。更棒的是你可以使用任意編程語言來做開發。
Storm的主要特點如下：
1.簡單的編程模型。類似於MapRece降低了並行批處理復雜性，Storm降低了進行實時處理的復雜性。
2.可以使用各種編程語言。你可以在Storm之上使用各種編程語言。默認支持Clojure、Java、Ruby和Python。要增加對其他語言的支持，只需實現一個簡單的Storm通信協議即可。
3.容錯性。Storm會管理工作進程和節點的故障。
4.水平擴展。計算是在多個線程、進程和伺服器之間並行進行的。
5.可靠的消息處理。Storm保證每個消息至少能得到一次完整處理。任務失敗時，它會負責從消息源重試消息。
6.快速。系統的設計保證了消息能得到快速的處理，使用MQ作為其底層消息隊列。
7.本地模式。Storm有一個「本地模式」，可以在處理過程中完全模擬Storm集群。這讓你可以快速進行開發和單元測試。

--------------------------------------------------------------------------------------------------------------------------------
在消耗資源相同的情況下，一般來說storm的延時低於maprece。但是吞吐也低於maprece。storm是典型的流計算系統，maprece是典型的批處理系統。下面對流計算和批處理系統流程

這個個數據處理流程來說大致可以分三個階段：
1. 數據採集與准備
2. 數據計算（涉及計算中的中間存儲）， 題主中的「那些方面決定」應該主要是指這個階段處理方式。
3. 數據結果展現（反饋）

1）數據採集階段，目前典型的處理處理策略：數據的產生系統一般出自頁面打點和解析DB的log，流計算將數據採集中消息隊列（比如kafaka,metaQ,timetunle）等。批處理系統一般將數據採集進分布式文件系統（比如HDFS），當然也有使用消息隊列的。我們暫且把消息隊列和文件系統稱為預處理存儲。二者在延時和吞吐上沒太大區別，接下來從這個預處理存儲進入到數據計算階段有很大的區別，流計算一般在實時的讀取消息隊列進入流計算系統（storm）的數據進行運算，批處理一系統一般會攢一大批後批量導入到計算系統（hadoop），這里就有了延時的區別。
2）數據計算階段，流計算系統（storm）的延時低主要有一下幾個方面（針對題主的問題）
A： storm 進程是常駐的，有數據就可以進行實時的處理
maprece 數據攢一批後由作業管理系統啟動任務，Jobtracker計算任務分配，tasktacker啟動相關的運算進程
B： stom每個計算單元之間數據之間通過網路（zeromq）直接傳輸。
maprece map任務運算的結果要寫入到HDFS，在於rece任務通過網路拖過去運算。相對來說多了磁碟讀寫，比較慢
C： 對於復雜運算
storm的運算模型直接支持DAG（有向無環圖）
maprece 需要肯多個MR過程組成，有些map操作沒有意義的

3）數據結果展現
流計算一般運算結果直接反饋到最終結果集中（展示頁面，資料庫，搜索引擎的索引）。而maprece一般需要整個運算結束後將結果批量導入到結果集中。

實際流計算和批處理系統沒有本質的區別，像storm的trident也有批概念，而maprece可以將每次運算的數據集縮小（比如幾分鍾啟動一次），facebook的puma就是基於hadoop做的流計算系統。

二、高性能並行計算引擎Storm和Spark比較

Spark基於這樣的理念，當數據龐大時，把計算過程傳遞給數據要比把數據傳遞給計算過程要更富效率。每個節點存儲（或緩存）它的數據集，然後任務被提交給節點。

所以這是把過程傳遞給數據。這和Hadoop map/rece非常相似，除了積極使用內存來避免I/O操作，以使得迭代演算法（前一步計算輸出是下一步計算的輸入）性能更高。

Shark只是一個基於Spark的查詢引擎（支持ad-hoc臨時性的分析查詢）

而Storm的架構和Spark截然相反。Storm是一個分布式流計算引擎。每個節點實現一個基本的計算過程，而數據項在互相連接的網路節點中流進流出。和Spark相反，這個是把數據傳遞給過程。

兩個框架都用於處理大量數據的並行計算。

Storm在動態處理大量生成的「小數據塊」上要更好（比如在Twitter數據流上實時計算一些匯聚功能或分析）。

Spark工作於現有的數據全集（如Hadoop數據）已經被導入Spark集群，Spark基於in-memory管理可以進行快訊掃描，並最小化迭代演算法的全局I/O操作。

不過Spark流模塊（Streaming Mole）倒是和Storm相類似（都是流計算引擎），盡管並非完全一樣。

Spark流模塊先匯聚批量數據然後進行數據塊分發（視作不可變數據進行處理），而Storm是只要接收到數據就實時處理並分發。

不確定哪種方式在數據吞吐量上要具優勢，不過Storm計算時間延遲要小。

總結下，Spark和Storm設計相反，而Spark Steaming才和Storm類似，前者有數據平滑窗口（sliding window），而後者需要自己去維護這個窗口。

⑺ 如何使用大數據技術為企業創造更大的價值

大家好，我是Lake，專注大數據技術、互聯網科技見解、程序員經驗分享

作為一名大數據工程師，我來說下我的想法。如何使用大數據技術為企業創造更大的價值？這里有兩個注重點，一個是大數據技術，一個是為企業創造價值。目前大數據在不同的應用場景，可以分為很多不同種類的技術，比如數據的離線計算有 Hadoop、Spark，存儲方面有HBASE、HDFS、MongoDB、JanusGraph,消息中間件有 Kafka、MetaQ，實時計算有Storm、Flink、Spark Streaming等等。這么多大數據技術，怎麼樣為企業創造出更大的價值呢，我認為有一下幾點：

保證線上業務穩定性

目前很多企業最底層都用到大數據相關技術，如何保證線上業務穩定成為大數據技術最重要的一件事情。線上業務不穩定會直接影響到消費者的使用，尤其是涉及到交易相關的業務更是重中之重。線上業務的穩定性不能受到大數據集群抖動而產生影響，打個比方，線上訂單交易鏈路在最底層使用到了HBase 資料庫，但HBase集群突然 Down掉之後，那麼線上用戶突然不能夠進行下單和支付了，這對於公司來說，直接就影響到公司的交易額和利潤，這種情況是公司絕對無法容忍的。

所以你能夠保證公司所使用大數據技術集群資源越穩定，那麼對於線上業務的穩定運行就越有保證，通過對大數據集群穩定性進行保障，進一步提升消費者的使用體感，這就是你的價值。

更好的降低大數據集群機器資源消耗

更好的降低公司大數據集群機器的資源消耗，提升公司集群資源的使用率，進一步壓榨機器的性能也為公司帶來了價值。公司每台機器，說實話，都需要從外進行采購，這消耗的就是公司的資金。如果你能在現有的機器上，滿足更多的業務，而不只是單純的購買機器水平擴展來滿足業務，這樣會進一步幫助公司節約資金。公司的最終目的也是為了盈利，你幫公司降低了機器的購買，這也是為公司節約了一筆很大的成本。

大數據技術創新

大數據技術發展到了一定程度，就需要自己通過技術創新，來滿足公司一些更為復雜的業務場景。通過技術創新，帶動業務發展。比如圖資料庫的出現，使得公司能夠使用圖資料庫來構建用戶的社交網路圖，通過構建的社交網路圖可以快速了解到用戶的關注、用戶的粉絲、和用戶興趣相同的用戶有哪些。哪些用戶是信息傳播關鍵點等等，通過大數據技術的創新，知道更多潛藏在大數據底層的商業信息價值，從而幫助公司上層更好的做戰略規劃。同時，也可以通過技術創新，變革整個公司的技術架構，使用新的技術來滿足未來公司戰略的發展，最直接的例子，就是阿里雲。

總結

總體來說，大數據如何為公司創造更大的價值，我認為可以從提升大數據集群的穩定性入手，更好的保證公司線上業務的穩定和運行。其次，可以更好的壓榨和節約公司的大數據集群相關的機器資源，從而減少公司機器方面的采購成本。最後，就是通過大數據技術創新，通過技術來驅動業務的發展，當然這也是最難的一點，如果你能做到通過某種大數據技術的創新使得公司戰略方面業務的成功，那麼你的價值對於公司來說，將是無法估量的。

如果你覺得我的問答有幫助的話，歡迎你點贊轉發或者關注我，更多干貨內容，歡迎關注LakeShen說，你的小小的鼓勵，就是我持續分享的動力。

⑻ hadoop，storm和spark的區別，比較

一、hadoop、Storm該選哪一個？
為了區別hadoop和Storm，該部分將回答如下問題：
1.hadoop、Storm各是什麼運算
2.Storm為什麼被稱之為流式計算系統
3.hadoop適合什麼場景，什麼情況下使用hadoop
4.什麼是吞吐量

首先整體認識：Hadoop是磁碟級計算，進行計算時，數據在磁碟上，需要讀寫磁碟；Storm是內存級計算，數據直接通過網路導入內存。讀寫內存比讀寫磁碟速度快n個數量級。根據Harvard CS61課件，磁碟訪問延遲約為內存訪問延遲的75000倍。所以Storm更快。

注釋：
1. 延時 ， 指數據從產生到運算產生結果的時間，「快」應該主要指這個。
2. 吞吐， 指系統單位時間處理的數據量。

storm的網路直傳、內存計算，其時延必然比hadoop的通過hdfs傳輸低得多；當計算模型比較適合流式時，storm的流式處理，省去了批處理的收集數據的時間；因為storm是服務型的作業，也省去了作業調度的時延。所以從時延上來看，storm要快於hadoop。

從原理角度來講：

Hadoop M/R基於HDFS，需要切分輸入數據、產生中間數據文件、排序、數據壓縮、多份復制等，效率較低。
Storm 基於ZeroMQ這個高性能的消息通訊庫，不持久化數據。

為什麼storm比hadoop快，下面舉一個應用場景
說一個典型的場景，幾千個日誌生產方產生日誌文件，需要進行一些ETL操作存入一個資料庫。

假設利用hadoop，則需要先存入hdfs，按每一分鍾切一個文件的粒度來算（這個粒度已經極端的細了，再小的話hdfs上會一堆小文件），hadoop開始計算時，1分鍾已經過去了，然後再開始調度任務又花了一分鍾，然後作業運行起來，假設機器特別多，幾鈔鍾就算完了，然後寫資料庫假設也花了很少的時間，這樣，從數據產生到最後可以使用已經過去了至少兩分多鍾。
而流式計算則是數據產生時，則有一個程序去一直監控日誌的產生，產生一行就通過一個傳輸系統發給流式計算系統，然後流式計算系統直接處理，處理完之後直接寫入資料庫，每條數據從產生到寫入資料庫，在資源充足時可以在毫秒級別完成。

同時說一下另外一個場景：
如果一個大文件的wordcount，把它放到storm上進行流式的處理，等所有已有數據處理完才讓storm輸出結果，這時候，你再把它和hadoop比較快慢，這時，其實比較的不是時延，而是比較的吞吐了。

--------------------------------------------------------------------------------------------------------------------------------
最主要的方面：Hadoop使用磁碟作為中間交換的介質，而storm的數據是一直在內存中流轉的。
兩者面向的領域也不完全相同，一個是批量處理，基於任務調度的；另外一個是實時處理，基於流。
以水為例，Hadoop可以看作是純凈水，一桶桶地搬；而Storm是用水管，預先接好（Topology），然後打開水龍頭，水就源源不斷地流出來了。

--------------------------------------------------------------------------------------------------------------------------------
Storm的主工程師Nathan Marz表示： Storm可以方便地在一個計算機集群中編寫與擴展復雜的實時計算，Storm之於實時處理，就好比Hadoop之於批處理。Storm保證每個消息都會得到處理，而且它很快——在一個小集群中，每秒可以處理數以百萬計的消息。更棒的是你可以使用任意編程語言來做開發。
Storm的主要特點如下：
1.簡單的編程模型。類似於MapRece降低了並行批處理復雜性，Storm降低了進行實時處理的復雜性。
2.可以使用各種編程語言。你可以在Storm之上使用各種編程語言。默認支持Clojure、Java、Ruby和Python。要增加對其他語言的支持，只需實現一個簡單的Storm通信協議即可。
3.容錯性。Storm會管理工作進程和節點的故障。
4.水平擴展。計算是在多個線程、進程和伺服器之間並行進行的。
5.可靠的消息處理。Storm保證每個消息至少能得到一次完整處理。任務失敗時，它會負責從消息源重試消息。
6.快速。系統的設計保證了消息能得到快速的處理，使用MQ作為其底層消息隊列。
7.本地模式。Storm有一個「本地模式」，可以在處理過程中完全模擬Storm集群。這讓你可以快速進行開發和單元測試。

--------------------------------------------------------------------------------------------------------------------------------
在消耗資源相同的情況下，一般來說storm的延時低於maprece。但是吞吐也低於maprece。storm是典型的流計算系統，maprece是典型的批處理系統。下面對流計算和批處理系統流程

這個個數據處理流程來說大致可以分三個階段：
1. 數據採集與准備
2. 數據計算（涉及計算中的中間存儲）， 題主中的「那些方面決定」應該主要是指這個階段處理方式。
3. 數據結果展現（反饋）

1）數據採集階段，目前典型的處理處理策略：數據的產生系統一般出自頁面打點和解析DB的log，流計算將數據採集中消息隊列（比如kafaka,metaQ,timetunle）等。批處理系統一般將數據採集進分布式文件系統（比如HDFS），當然也有使用消息隊列的。我們暫且把消息隊列和文件系統稱為預處理存儲。二者在延時和吞吐上沒太大區別，接下來從這個預處理存儲進入到數據計算階段有很大的區別，流計算一般在實時的讀取消息隊列進入流計算系統（storm）的數據進行運算，批處理一系統一般會攢一大批後批量導入到計算系統（hadoop），這里就有了延時的區別。
2）數據計算階段，流計算系統（storm）的延時低主要有一下幾個方面（針對題主的問題）
A： storm 進程是常駐的，有數據就可以進行實時的處理
maprece 數據攢一批後由作業管理系統啟動任務，Jobtracker計算任務分配，tasktacker啟動相關的運算進程
B： stom每個計算單元之間數據之間通過網路（zeromq）直接傳輸。
maprece map任務運算的結果要寫入到HDFS，在於rece任務通過網路拖過去運算。相對來說多了磁碟讀寫，比較慢
C： 對於復雜運算
storm的運算模型直接支持DAG（有向無環圖）
maprece 需要肯多個MR過程組成，有些map操作沒有意義的

3）數據結果展現
流計算一般運算結果直接反饋到最終結果集中（展示頁面，資料庫，搜索引擎的索引）。而maprece一般需要整個運算結束後將結果批量導入到結果集中。

實際流計算和批處理系統沒有本質的區別，像storm的trident也有批概念，而maprece可以將每次運算的數據集縮小（比如幾分鍾啟動一次），facebook的puma就是基於hadoop做的流計算系統。

二、高性能並行計算引擎Storm和Spark比較
Spark基於這樣的理念，當數據龐大時，把計算過程傳遞給數據要比把數據傳遞給計算過程要更富效率。每個節點存儲（或緩存）它的數據集，然後任務被提交給節點。
所以這是把過程傳遞給數據。這和Hadoop map/rece非常相似，除了積極使用內存來避免I/O操作，以使得迭代演算法（前一步計算輸出是下一步計算的輸入）性能更高。
Shark只是一個基於Spark的查詢引擎（支持ad-hoc臨時性的分析查詢）
而Storm的架構和Spark截然相反。Storm是一個分布式流計算引擎。每個節點實現一個基本的計算過程，而數據項在互相連接的網路節點中流進流出。和Spark相反，這個是把數據傳遞給過程。
兩個框架都用於處理大量數據的並行計算。
Storm在動態處理大量生成的「小數據塊」上要更好（比如在Twitter數據流上實時計算一些匯聚功能或分析）。
Spark工作於現有的數據全集（如Hadoop數據）已經被導入Spark集群，Spark基於in-memory管理可以進行快訊掃描，並最小化迭代演算法的全局I/O操作。
不過Spark流模塊（Streaming Mole）倒是和Storm相類似（都是流計算引擎），盡管並非完全一樣。
Spark流模塊先匯聚批量數據然後進行數據塊分發（視作不可變數據進行處理），而Storm是只要接收到數據就實時處理並分發。
不確定哪種方式在數據吞吐量上要具優勢，不過Storm計算時間延遲要小。
總結下，Spark和Storm設計相反，而Spark Steaming才和Storm類似，前者有數據平滑窗口（sliding window），而後者需要自己去維護這個窗口。

⑼ 領域驅動設計（DDD）實踐之路（第二篇)

在領域驅動裡面，infrastructure作為基礎設施，是提供技術細節的模塊。需要強調的是，很多人會誤以為infrastructure就是傳統的DAO層，其實infrastructure包括但不限於DAO層，比如文件處理，三方調用，使用緩存，發送非同步消息等具體的技術細節實現都存在於infrastructure層。那麼技術細節是什麼呢。在我們看來，技術細節包含以下特徵

案例1：我們的實體需要持久化（存儲），所以我們需要提供存儲的實現。領域層的repository.save等方法提供了持久化介面約定，對於infrastructure來說，如何實現這個方法的代碼，就是技術細節。那麼我們如何實現這個過程呢？自然是選擇緩存，OSS存或者資料庫存。如果選擇資料庫，則進而需要選擇orm框架，配置...，實現repository.save的介面，這些都屬於持久化所需的技術細節代碼。

案例2：我們的應用需要導出資產包相關的excel形式數據，那麼當導出資產包數據時，文件領域模塊提供了導出的統一介面，資產領域模塊提供了資產包的適配介面，而導出excel的代碼需要使用easyExcel或者POI等第三方框架，屬於技術細節代碼。

案例3: 接案例2，為了實現導出時所需的excel排版格式，排版本身的格式與業務有關，比如在我們的業務場景下，我們導出調解明細（我們項目特定的一個領域模型）的時候，只需要按照常見的導出方式即可，而導出資產明細（我們項目特定的一個領域模型）則需要解析拼接所有的動態數據列，合並顯示每條數據不同的動態列，而這一切是由業務決定的。根據業務不同有不同的排版要求這一點體現了資產域需要提供文件域的導出策略，調解域也需要實現文件域的導出策略。這些都屬於描述業務信息的約定，而這些約定的具體實現比如怎麼把實體的那一個屬性映射到excel的哪一行哪一列，則屬於技術細節。這種區分方式顯性化了業務的概念，同時又將實現放在了基礎設施層，提供了一定的解耦性。

說完了infrastructure的技術細節的定義，我們接下來聊幾個在採用DDD研發模式下，infrastructure層開發過程中經常會遇到的一些問題及我們的解決方案。

為了讓業務邏輯和代碼實現解耦，在repository的約定中，我們通常用「save保存」代替我們通常說的「insert（插入）「，」update（更新）」這樣的技術術語，以屏蔽技術細節。這樣帶來的一個副作用是，在save時就需要根據策略判斷調用insert還是update，我們使用的策略是根據id是否是空決定，即我們所有的實體對象都有一個屬性，類型為Id類的子類，id對象的屬性（資料庫裡面實際存放的id值）可能為null，但是id對象，本身不會為null，根據這個對象可以判斷當前實體id是否為空。

對於聚合場景，子實體是需要知道聚合根的id的，因為在存儲到資料庫時可能需要以外鍵的方式存儲對象間的映射關系。

然而，在具體實現中，我們認為，實體之間的對象關系才是標識兩個實體之間關系的方式，而不是id，所以生成實體時，先通過對象引用關聯對象，表明聚合和實體之間的關系，在保存到資料庫的時候，通過實體生成資料庫映射類的時候就可以知道當前數據的id是否為空，同時又能知道當前數據之間的關系。

對象之間的關系在1:1聚合保存的時候可能體現不明顯，但是當1:N或者N:N批量保存聚合的時候，作用就比較明顯了。在我們的系統中發起調解業務就需要批量保存調解批次。代碼如下（歡迎吐槽，擁抱進步）

通過這種方式就解決了批量插入不能返回id，同時又能繼續復用id.isNew()判斷是否為新數據的方式（這里我們沒有創建entity基類，所以判斷放在了Id上）。

以上方法提供了批量保存時如何區分是新增還是更新。下面我們來談談我們項目內提供的插入和更新模板代碼。

對於領域來說，save是基本的保存代碼。方法傳入的參數往往是一個存在於內存中的聚合根對象，有時包含全量的子實體，VO和全量的欄位，而在插入場景，對批量請求我們希望支持批量插入，減少對資料庫的IO頻率，在更新場景下，我們希望減少update時的更新欄位的數量（只更新需要更新的欄位），這有助於減少資料庫IO次數、binlog大小和mysql資料庫索引變更帶來的開銷，所以是非常有必要的。因此對於infrastructure來說，可以提供統一的定製化模板方便repository定製化更新欄位的方法快速實現。

由於我們的系統使用的是mybatisplus的ORM方案，所以我們根據api和mysql的批量語句開關提供了一個批量插入和批量更新的Mapper基類，其中insertBatchSomColumn是mybatisplus自帶的，updateBatchById則是我們實現的，文檔鏈接如下https://mp.toutiao.com/profile_v4/graphic/preview?pgc_id=7062223527654916621通過這種方式可以輕松地提供定製化更新某幾列的sql，減輕sql編寫負擔。

這一次要講的其實就是上面提到過的excel導入導出的案例。對於我們的系統來說，具有資產域，文件域，調解域等。其中資產域、調節域等三個域需要導入導出excel。但是我們在設計的時候認為文件的操作屬於文件域的概念，所以應當由文件的domain提供功能。但是很明顯，具體的導入導出的策略根據數據的不同是可以變化的。所以針對這種情況，我們回歸到領域驅動的實現的本質------面向對象技術來思考這個問題的優雅解法。以導入為例

代碼如下

上面4份代碼是domain的，最下面的是infrastructure的，這里我們只講infrastructure的（但是我個人認為領域分層後還是需要整體考慮的，所以才會貼上domain的代碼）。

這是我們對於跨域業務邏輯的處理辦法。

為了保證各領域模型間的解耦，我們經常通過最輕量級的領域事件的方式實現，而不是類似metaq，msgbroker這樣的非同步分布式消息中間件。領域事件的發送有很多的實現方案，我們傾向於直接使用spring的功能，因為我們需要同步保證事務。但是spring的event發送需要繼承ApplicationEvent而領域事件我們又希望獨立於spring的event體系，所以我們通過對spring的了解發現了spring已經提供了 PayloadApplicationEvent 可以實現這種功能實現上和其他的spring的event一致，獲取我們自己定義的event的方法如下

這里的getPayload()可以獲取到我們放進去的領域事件TimeoutEvent

在任何系統中都會有批處理的業務。可能是批處理聚合，可能是批處理聚合內的實體類。這里說一下我之前遇到的一個帖子（jdon）上的討論。帖子上說的是有一個排班業務，一條班表數據作為聚合存在著每日排班子實體，每日排班下又存在著排班明細子實體，當日期逐漸增加時一條排班需要載入好幾年的數據用於生成聚合，而實際上則僅僅只需要計算最近幾周的數據。這里存在兩點問題

第一點自然不用多說，技術實現以提供業務功能為核心是我一直以來的主張。所以當數據量可能會不斷增大的情況下不用載入完整自然是必須的（哪怕內存存儲的下也應當盡可能少的消耗）。第二點來說帖子的一位回復者傾向於DomainService提供專門的適配方法，用於載入幾周的數據。

我們的系統中存在一個有一些類似的業務。我們的系統需要每隔幾分鍾就運行一次批處理任務，獲取所有已經過期的調解明細，並且設置為過期。調解明細屬於調解批次的聚合，所以我們有同樣的需求。

我們在此提供一種我們的實現，供參考。

repository的實現根據面向對象原則，僅僅提供如何查詢過濾資料庫數據

迭代器的實現提供了迭代職責實現

至此實現了批處理載入聚合的邏輯，同時可以提供聚合的部分載入（需要注意業務的正確性不會因為聚合的不完全載入而產生問題）。

最後總結一下