storm存儲數據

① 什麼是Storm，它可以用來做什麼

直接網路啊，storm其實就是做實時流式處理的，而hadoop做的一般是批處理，實時性跟不上。當你需要實時就可以用storm來處理你的數據，當然實時流式計算還有spark之類的可以做。可以去官網看看文檔http://storm.apache.org/

② 1.2.2 Storm怎麼使用這些元數據

1.2.2Storm怎麼使用這些元數據
了解了存儲在ZooKeeper中的數據，我們自然想知道Storm是如何使用這些元數據的。例如，這些數據何時被寫入、更新或刪除，這些數據都是由哪種類型的節點（Nimbus、Supervisor、Worker或者Executor）來維護的。接下來，我們就簡單介紹一下這些關系，希望讀者能對Storm的整體設計實現有更深一層的認識。帶上這些知識，能讓你的Storm源碼之路變得更加輕松愉快。
首先來看一下總體交互圖，如圖1-4所示。

這個圖描述了Storm中每個節點跟ZooKeeper內元數據之間的讀寫依賴關系，詳細介紹如下。
1. Nimbus
Nimbus既需要在ZooKeeper中創建元數據，也需要從ZooKeeper中獲取元數據。下面簡述圖1-4中箭頭1和箭頭2的作用。
箭頭1表示由Nimbus創建的路徑，包括：

a. /storm/workerbeats/<topology-id> b. /storm/storms/<topology-id> c. /storm/assignments/<topology-id>

其中對於路徑a，Nimbus只會創建路徑，不會設置數據（數據是由Worker設置的，後面會介紹）；對於路徑b和c，Nimbus在創建它們的時候就會設置數據。a和b只有在提交新Topology的時候才會創建，且b中的數據設置好後就不再變化，c則在第一次為該Topology進行任務分配的時候創建，若任務分配計劃有變，Nimbus就會更新它的內容。
箭頭2表示Nimbus需要獲取數據的路徑，包括：

a. /storm/workerbeats/<topology-id>/node-port b. /storm/supervisors/<supervisor-id> c. /storm/errors/<topology-id>/<component-id>/e<sequential-id>

Nimbus需要從路徑a讀取當前已被分配的Worker的運行狀態。根據該信息，Nimbus可以得知哪些Worker狀態正常，哪些需要被重新調度，同時還會獲取到該Worker所有Executor統計信息，這些信息會通過UI呈現給用戶。從路徑b可以獲取當前集群中所有Supervisor的狀態，通過這些信息可以得知哪些Supervisor上還有空閑的資源可用，哪些Supervisor則已經不再活躍，需要將分配到它的任務分配到其他節點上。從路徑c上可以獲取當前所有的錯誤信息並通過UI呈現給用戶。集群中可以動態增減機器，機器的增減會引起ZooKeeper中元數據的變化，Nimbus通過不斷獲取這些元數據信息來調整任務分配，故Storm具有良好的可擴展性。當Nimbus死掉時，其他節點是可以繼續工作的，但是不能提交新的Topology，也不能重新進行任務分配和負載調整，因此目前Nimbus還是存在單點的問題。
2. Supervisor
同Nimbus類似，Superviser也要通過ZooKeeper來創建和獲取元數據。除此之外，Supervisor還通過監控指定的本地文件來檢測由它啟動的所有Worker的運行狀態。下面簡述圖1-4中箭頭3、箭頭4和箭頭9的作用。
箭頭3表示Supervisor在ZooKeeper中創建的路徑是/storm/supervisors/<supervisor-id>。新節點加入時，會在該路徑下創建一個節點。值得注意的是，該節點是一個臨時節點（創建ZooKeeper節點的一種模式），即只要Supervisor與ZooKeeper的連接穩定存在，該節點就一直存在；一旦連接斷開，該節點則會被自動刪除。該目錄下的節點列表代表了目前活躍的機器。這保證了Nimbus能及時得知當前集群中機器的狀態，這是Nimbus可以進行任務分配的基礎，也是Storm具有容錯性以及可擴展性的基礎。
箭頭4表示Supervisor需要獲取數據的路徑是/storm/assignments/<topology-id>。我們知道它是Nimbus寫入的對Topology的任務分配信息，Supervisor從該路徑可以獲取到Nimbus分配給它的所有任務。Supervisor在本地保存上次的分配信息，對比這兩部分信息可以得知分配信息是否有變化。若發生變化，則需要關閉被移除任務所對應的Worker，並啟動新的Worker執行新分配的任務。Nimbus會盡量保持任務分配的穩定性，我們將在第7章中進行詳細分析。
箭頭9表示Supervisor會從LocalState（相關內容會在第4章中介紹）中獲取由它啟動的所有Worker的心跳信息。Supervisor會每隔一段時間檢查一次這些心跳信息，如果發現某個Worker在這段時間內沒有更新心跳信息，表明該Worker當前的運行狀態出了問題。這時Supervisor就會殺掉這個Worker，原本分配給這個Worker的任務也會被Nimbus重新分配。
3. Worker
Worker也需要利用ZooKeeper來創建和獲取元數據，同時它還需要利用本地的文件來記錄自己的心跳信息。
下面簡述圖4-1中箭頭5、箭頭6和箭頭8的作用。
箭頭5表示Worker在ZooKeeper中創建的路徑是/storm/workerbeats/<topology-id>/node- port。在Worker啟動時，將創建一個與其對應的節點，相當於對自身進行注冊。需要注意的是，Nimbus在Topology被提交時只會創建路徑/storm/workerbeats/<topology-id>，而不會設置數據，數據則留到Worker啟動之後由Worker創建。這樣安排的目的之一是為了避免多個Worker同時創建路徑時所導致的沖突。
箭頭6表示Worker需要獲取數據的路徑是/storm/assignments/<topology-id>，Worker會從這些任務分配信息中取出分配給它的任務並執行。
箭頭8表示Worker在LocalState中保存心跳信息。LocalState實際上將這些信息保存在本地文件中，Worker用這些信息跟Supervisor保持心跳，每隔幾秒鍾需要更新一次心跳信息。Worker與Supervisor屬於不同的進程，因而Storm採用本地文件的方式來傳遞心跳。
4. Executor
Executor只會利用ZooKeeper來記錄自己的運行錯誤信息，下面簡述圖4-1中箭頭7的作用。
箭頭7表示Executor在ZooKeeper中創建的路徑是/storm/errors/<topology-id>/<component-id> /e<sequential-id>。每個Executor會在運行過程中記錄發生的錯誤。
5. 小結
從前面的描述中可以得知，Nimbus、Supervisor以及Worker兩兩之間都需要維持心跳信息，它們的心跳關系如下。
Nimbus和Supervisor之間通過/storm/supervisors/<supervisor-id>路徑對應的數據進行心跳保持。Supervisor創建這個路徑時採用的是臨時節點模式，所以只要Supervisor死掉，對應路徑的數據就會被刪掉，Nimbus就會將原本分配給該Supervisor的任務重新分配。
Worker跟Nimbus之間通過/storm/workerbeats/<topology-id>/node-port中的數據進行心跳保持。Nimbus會每隔一定時間獲取該路徑下的數據，同時Nimbus還會在它的內存中保存上一次的信息。如果發現某個Worker的心跳信息有一段時間沒更新，就認為該Worker已經死掉了，Nimbus會對任務進行重新分配，將分配至該Worker的任務分配給其他Worker。
Worker跟Supervisor之間通過本地文件（基於LocalState）進行心跳保持。

③ 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），而後者需要自己去維護這個窗口。

④ 如何將mysql中的數據實時導入到storm中

1.將選中的數據快兒拷貝到一個TXT文本文件中（記得把後面的空格消掉。。否則導入資料庫後會有對應的空行），假如存到「D:\data.txt」這個位置里。
2.根據要導入的數據快兒建立MySql資料庫和表，然後進入命令提示符里使用命令
load data local infile 'D:/data.txt' into table exceltomysql fields terminated by '\t';
注意：盤符我使用的「/」才成功，否則提示找不到文件 下面文章中是用的「\」！
進行導入操作
手動進行Excel數據和MySql數據轉換

⑤ 有了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基於這樣的理念；另外一個是實時處理一

⑥ STORM不能用ORACLE嗎 能用什麼資料庫

完全可以，12C可能在某些特性上有增加或調整（一般是添加新特性或修正部分問題）
但主要的功能絕對是一樣的所以ORACLE的教程都可以用，乃至9i的也不會有大的問題。
教程教的東西都是普遍性的，新出的特性沒有人嘗試到教程還需要很長時間。

要注意的是ORACLE是「向下兼容的」 就是說11G備份的數據導入12C理論上沒有問題，但是12C里的數據無法通過ORACLE導入導出工具恢復進11G，如果有此需求請繞行以免麻煩。

⑦ Storm與Spark，Hadoop相比是否有優勢

Storm優勢就在於Storm是實時的連續性的分布式的計算框架,一旦運行起來,除非你將它殺掉,否則它一直處理計算或等待計算的狀態.Spark和hadoop都做不到.
當然它們各自都有其應用場景,各有各的優勢.可以配合使用.
下面我轉一份別人的資料,講的很清楚.
Storm與Spark、Hadoop這三種框架，各有各的優點，每個框架都有自己的最佳應用場景。
所以，在不同的應用場景下，應該選擇不同的框架。
Storm是最佳的流式計算框架，Storm由Java和Clojure寫成，Storm的優點是全內存計算，所以它的定位是分布式實時計算系統，按照Storm作者的說法，Storm對於實時計算的意義類似於Hadoop對於批處理的意義。
Storm的適用場景：
1）流數據處理
Storm可以用來處理源源不斷流進來的消息，處理之後將結果寫入到某個存儲中去。
2）分布式RPC。由於Storm的處理組件是分布式的，而且處理延遲極低，所以可以作為一個通用的分布式RPC框架來使用。
SparkSpark是一個基於內存計算的開源集群計算系統，目的是更快速的進行數據分析。Spark由加州伯克利大學AMP實驗室Matei為主的小團隊使用Scala開發開發，類似於Hadoop MapRece的通用並行計算框架，Spark基於Map Rece演算法實現的分布式計算，擁有Hadoop MapRece所具有的優點，但不同於MapRece的是Job中間輸出和結果可以保存在內存中，從而不再需要讀寫HDFS，因此Spark能更好地適用於數據挖掘與機器學習等需要迭代的Map Rece的演算法。
Spark的適用場景：
1）多次操作特定數據集的應用場合
Spark是基於內存的迭代計算框架，適用於需要多次操作特定數據集的應用場合。需要反復操作的次數越多，所需讀取的數據量越大，受益越大，數據量小但是計算密集度較大的場合，受益就相對較小。
2）粗粒度更新狀態的應用
由於RDD的特性，Spark不適用那種非同步細粒度更新狀態的應用，例如Web服務的存儲或者是增量的Web爬蟲和索引。就是對於那種增量修改的應用模型不適合。
總的來說Spark的適用面比較廣泛且比較通用。
Hadoop是實現了MapRece的思想，將數據切片計算來處理大量的離線數據數據。Hadoop處理的數據必須是已經存放在HDFS上或者類似HBase的資料庫中，所以Hadoop實現的時候是通過移動計算到這些存放數據的機器上來提高效率。
Hadoop的適用場景：
1）海量數據的離線分析處理
2）大規模Web信息搜索
3）數據密集型並行計算
簡單來說：
Hadoop適合於離線的批量數據處理適用於對實時性要求極低的場景
Storm適合於實時流數據處理，實時性方面做得極好
Spark是內存分布式計算框架，試圖吞並Hadoop的Map-Rece批處理框架和Storm的流處理框架，但是Spark已經做得很不錯了，批處理方面性能優於Map-Rece，但是流處理目前還是弱於Storm，產品仍在改進之中

⑧ 請描述下大數據三大平台hadoop，storm，spark的區別和應用場景

Hadoop 當前大數據管理標准之一，運用在當前很多商業應用系統。可以輕松地集成結構化、半結構化甚至非結構化數據集還是離線處理，批處理比較多，用的比較廣的是hive
Storm 用於處理高速、大型數據流的分布式實時計算系統。為Hadoop添加了可靠的實時數據處理功能
spark基於內存的，吞吐量比storm大一點。而且spark集成的sparkSQL，MLlib，Graph貌似比較方便 ！

⑨ 為什麼storm的數據來自於消息隊列

Storm的解決問題的scope主要在於流計算，說流計算之前我們先簡單的說下一般數據處理系統的過程。一般數據處理簡單說要有幾個環節：數據採集，數據計算，結果輸出。題主的問題主要是在數據採集和計算之間的對接。
一般來說計算系統（storm）不會自己產生業務數據，業務數據一般來自頁面的埋點，或者對資料庫log的解析，對於storm來說採集系統是個外部系統。 採集系統是數據的生產者，流計算（storm）是數據的消費者。二者的速度並不是時時刻刻匹配的，中間就需要需要一個緩沖，這個模型下消息隊列在適合不過了。當然為什麼一般用kafka，這個超出了這個問題，我們暫不討論。如果題主要處理的數據不是實時產生的而是靜態數據那就沒必要使用消息隊列了，當然也沒必要使用storm，使用Hadoop MR更合適。
關於spout會不會重復讀取數據的問題，簡單來說消息隊列中數據會分partition支持多並發。 題主可以看看kafka的文檔，一般消息隊列，對一份數據（一個topic，對應離線系統的表）會分不同的parition，不同的spout並發可以讀取不同的parition，當然一個並發可以讀取多個parition，但是多個並發讀取一個parition會引起混亂這就是題主的問題。也就是實際應用中一個parition只會有一個並發讀取。