2. 程式人生 > >【Spring訊息】RabbitMq安裝及簡單應用（二）

【Spring訊息】RabbitMq安裝及簡單應用（二）

阿新 • • 發佈：2018-12-12

前言：

埋頭苦寫。先把官方文件翻譯過來。整個流程跑一遍。上一篇文章，【Spring訊息】RabbitMq安裝及簡單應用（一），把點對點發送訊息寫完了。之前雖然也可以一個生產者多個消費者，但是一條訊息只能被一個消費者處理，所以是點對點。這篇文章來講講釋出訂閱，一對多。一條訊息同時被多個消費者（本文稱為訂閱者）處理。

正文：

一、釋出/訂閱模式：

引入了一個新概念：Exchange（即上圖的X概念）。（其實此概念，在Amqp協議中是必要的一環，暫時可無需理解，後續會提到）可簡單先理解為一個路由功能。RabbitMq定義了四種路由模式，direct, topic, headers and fanout.（本文會講到除headers外其它三種）

1、fanout廣播：

由上圖可知生產者和佇列之間沒直接關聯關係，甚至不需要知道有這麼個東西，所以如果看過上一篇文章的小夥伴可以刪掉佇列名有關的程式碼。

1）生產者程式碼

package com.haibo.future.web.rabbitmq.demo6;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.MessageProperties;

public class RabbitProduct {
    private final static String EXCHANGE_NAME = "logs";

    public static void main(String[] argv) throws Exception {
        for (int i = 0; i < 20; i++) {
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("localhost");
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
            String message = "第"+i+"條"+"Hello World!";
            //本次新增EXCHANGE
            channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
            //傳送的時候只需要制定Exchange，不需要制定第二個引數佇列名稱
            channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + message + "'");
            channel.close();
            connection.close();
        }
    }
}

2）消費者程式碼

package com.haibo.future.web.rabbitmq.demo6;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class RabbitConsumer {
    private static final String EXCHANGE_NAME = "logs";


    public static void main(String[] argv)
            throws IOException,
            InterruptedException {

        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = null;
        try {
            connection = factory.newConnection();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        final Channel channel = connection.createChannel();
        //定義路由模式廣播
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
        //消費者需要知道佇列名稱，因為已知是fanout廣播模式，queueName直接從channel定義中獲取
        String queueName = channel.queueDeclare().getQueue();
        //將佇列和Exchange繫結起來
        channel.queueBind(queueName, EXCHANGE_NAME, "");
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                String message = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
            }
        };
        boolean autoAck = true;
        channel.basicConsume(queueName, autoAck, consumer);
    }
}

3）測試執行

執行兩個消費者，再執行生產者。結果：生產者訊息，同時發給了兩個消費者。日誌略。

2、direct直連：

直連：即binding Key全匹配。上圖中Binding Key即black。

1）、生產者：（不與佇列直接關聯，繫結binding Key）

package com.haibo.future.web.rabbitmq.demo7;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class RabbitProduct {
    private final static String EXCHANGE_NAME = "logs2";

    public static void main(String[] argv) throws Exception {
        for (int i = 0; i < 20; i++) {
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("localhost");
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
            String message = "第"+i+"條"+"Hello World!";;
            //本次新增EXCHANGE:direct直接匹配，全匹配模式
            channel.exchangeDeclare(EXCHANGE_NAME, "direct");
            //傳送的時候只需要制定Exchange，不需要制定第二個引數佇列名稱/此處是drect模式，第二個引數為binding key
            channel.basicPublish(EXCHANGE_NAME, "black", null, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + message + "'");
            channel.close();
            connection.close();
        }
    }
}

2）、消費者1（與佇列直接關聯，繫結binding Key "black"）

package com.haibo.future.web.rabbitmq.demo7;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class RabbitConsumer {
    private static final String EXCHANGE_NAME = "logs2";

    public static void main(String[] argv)
            throws IOException,
            InterruptedException {

        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = null;
        try {
            connection = factory.newConnection();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        final Channel channel = connection.createChannel();
        //定義路由模式direct
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");
        //消費者需要知道佇列名稱，因為已知是direct模式，queueName直接從channel定義中獲取
        String queueName = channel.queueDeclare().getQueue();
        //將佇列和Exchange繫結起來
        channel.queueBind(queueName, EXCHANGE_NAME, "black");
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                String message = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
            }
        };
        boolean autoAck = true;
        channel.basicConsume(queueName, autoAck, consumer);
    }
}

3）、消費者2（與佇列直接關聯，繫結binding Key "red"）

package com.haibo.future.web.rabbitmq.demo7;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class RabbitConsumer2 {
    private static final String EXCHANGE_NAME = "logs2";


    public static void main(String[] argv)
            throws IOException,
            InterruptedException {

        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = null;
        try {
            connection = factory.newConnection();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        final Channel channel = connection.createChannel();
        //定義路由模式direct
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");
        //消費者需要知道佇列名稱，因為已知是direct模式，queueName直接從channel定義中獲取
        String queueName = channel.queueDeclare().getQueue();
        //將佇列和Exchange繫結起來,binding key 為black
        channel.queueBind(queueName, EXCHANGE_NAME, "red");
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                String message = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
            }
        };
        boolean autoAck = true;
        channel.basicConsume(queueName, autoAck, consumer);
    }
}

4）、消費者3（與佇列直接關聯，繫結binding Key "black"）

package com.haibo.future.web.rabbitmq.demo7;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class RabbitConsumer3 {
    private static final String EXCHANGE_NAME = "logs2";


    public static void main(String[] argv)
            throws IOException,
            InterruptedException {

        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = null;
        try {
            connection = factory.newConnection();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        final Channel channel = connection.createChannel();
        //定義路由模式direct
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");
        //消費者需要知道佇列名稱，因為已知是direct模式，queueName直接從channel定義中獲取
        String queueName = channel.queueDeclare().getQueue();
        //將佇列和Exchange繫結起來,binding key 為black
        channel.queueBind(queueName, EXCHANGE_NAME, "black");
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                String message = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
            }
        };
        boolean autoAck = true;
        channel.basicConsume(queueName, autoAck, consumer);
    }
}

5）、執行測試：

3個消費者啟動，啟動生產者。日誌顯示：消費者1、消費者3顯示收到生產者的訊息，消費者2不能收到生產者的訊息。日誌略。

3、Topic主題：

直接上程式碼：

1）、消費者1:（rootingKey是*.orange.rabbit）

package com.haibo.future.web.rabbitmq.demo8;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class RabbitConsumer {
    private static final String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] argv)
            throws IOException,
            InterruptedException {

        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = null;
        try {
            connection = factory.newConnection();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        final Channel channel = connection.createChannel();
        //定義路由模式direct
        channel.exchangeDeclare(EXCHANGE_NAME, "topic");
        //消費者需要知道佇列名稱，因為已知是direct模式，queueName直接從channel定義中獲取
        String queueName = channel.queueDeclare().getQueue();
        //將佇列和Exchange繫結起來
        channel.queueBind(queueName, EXCHANGE_NAME, "*.orange.rabbit");
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                String message = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
            }
        };
        boolean autoAck = true;
        channel.basicConsume(queueName, autoAck, consumer);
    }
}

2）、消費者2:(rooting key 是 *.orange.bird)

package com.haibo.future.web.rabbitmq.demo8;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class RabbitConsumer2 {
    private static final String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] argv)
            throws IOException,
            InterruptedException {

        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = null;
        try {
            connection = factory.newConnection();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        final Channel channel = connection.createChannel();
        //定義路由模式direct
        channel.exchangeDeclare(EXCHANGE_NAME, "topic");
        //消費者需要知道佇列名稱，因為已知是direct模式，queueName直接從channel定義中獲取
        String queueName = channel.queueDeclare().getQueue();
        //將佇列和Exchange繫結起來
        channel.queueBind(queueName, EXCHANGE_NAME, "*.orange.bird");
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                String message = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
            }
        };
        boolean autoAck = true;
        channel.basicConsume(queueName, autoAck, consumer);
    }
}

3）、消費者3:(rooting key是lazy.#)

package com.haibo.future.web.rabbitmq.demo8;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class RabbitConsumer3 {
    private static final String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] argv)
            throws IOException,
            InterruptedException {

        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = null;
        try {
            connection = factory.newConnection();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        final Channel channel = connection.createChannel();
        //定義路由模式direct
        channel.exchangeDeclare(EXCHANGE_NAME, "topic");
        //消費者需要知道佇列名稱，因為已知是direct模式，queueName直接從channel定義中獲取
        String queueName = channel.queueDeclare().getQueue();
        //將佇列和Exchange繫結起來
        channel.queueBind(queueName, EXCHANGE_NAME, "lazy.#");
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                String message = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
            }
        };
        boolean autoAck = true;
        channel.basicConsume(queueName, autoAck, consumer);
    }
}

4）、生產者：

package com.haibo.future.web.rabbitmq.demo8;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class RabbitProduct {
    private static final String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] argv) throws Exception {
        for (int i = 0; i < 10; i++) {
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("localhost");
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
            String message = null;
            //P-->X :本次新增EXCHANGE:direct直接匹配，全匹配模式
            channel.exchangeDeclare(EXCHANGE_NAME, "topic");
            //X-->Q :傳送的時候只需要制定Exchange，不需要制定第二個引數佇列名稱/此處是drect模式，第二個引數為binding key/此處是topic模式，第二個引數為rooting key
            if (i == 5) {
                message = "第" + i + "條:" + "lazy.orange.rabbit" + i;
                channel.basicPublish(EXCHANGE_NAME, "lazy.orange.rabbit" + i, null, message.getBytes("UTF-8"));
            } else {
                if (i % 2 == 1) {
                    message = "第" + i + "條:" + i + ".orange." + "rabbit";
                    channel.basicPublish(EXCHANGE_NAME, i + ".orange." + "rabbit", null, message.getBytes("UTF-8"));
                } else {
                    message = "第" + i + "條:" + i + ".orange." + "bird";
                    channel.basicPublish(EXCHANGE_NAME, i + ".orange." + "bird", null, message.getBytes("UTF-8"));
                }
            }
            System.out.println(" [x] Sent '" + message + "'");
            channel.close();
            connection.close();
        }
    }
}

5）、執行測試：

消費者1，2，3分別執行，執行生產者。結果如下：

生產者：

[x] Sent '第0條:0.orange.bird'
 [x] Sent '第1條:1.orange.rabbit'
 [x] Sent '第2條:2.orange.bird'
 [x] Sent '第3條:3.orange.rabbit'
 [x] Sent '第4條:4.orange.bird'
 [x] Sent '第5條:lazy.orange.rabbit5'
 [x] Sent '第6條:6.orange.bird'
 [x] Sent '第7條:7.orange.rabbit'
 [x] Sent '第8條:8.orange.bird'
 [x] Sent '第9條:9.orange.rabbit'

消費者1:（rootingKey是*.orange.rabbit）

[*] Waiting for messages. To exit press CTRL+C
 [x] Received '第1條:1.orange.rabbit'
 [x] Received '第3條:3.orange.rabbit'
 [x] Received '第7條:7.orange.rabbit'
 [x] Received '第9條:9.orange.rabbit'

消費者2:(rooting key 是 *.orange.bird)

[*] Waiting for messages. To exit press CTRL+C
 [x] Received '第0條:0.orange.bird'
 [x] Received '第2條:2.orange.bird'
 [x] Received '第4條:4.orange.bird'
 [x] Received '第6條:6.orange.bird'
 [x] Received '第8條:8.orange.bird'

消費者3:(rooting key是lazy.#)

[*] Waiting for messages. To exit press CTRL+C
 [x] Received '第5條:lazy.orange.rabbit5'

相關推薦

【Spring訊息】RabbitMq安裝及簡單應用（二）

前言： 埋頭苦寫。先把官方文件翻譯過來。整個流程跑一遍。上一篇文章，【Spring訊息】RabbitMq安裝及簡單應用（一），把點對點發送訊息寫完了。之前雖然也可以一個生產者多個消費者，但是一條訊息只能被一個消費者處理，所以是點對點。這篇文章來講講釋出訂閱，一對多。一條訊息

阿里雲服務上Elasticsearch的安裝及簡單使用（二）

      在上篇文章中我們介紹了在阿里雲上進行Elasticsearch的安裝和執行，下面我們接著進行簡單的操作。      首先我們先要了解一下Elasticsearch中訪問資料的模式。為了能夠快

【Spring 5】響應式Web框架實戰（上）

引子：被譽為“中國大資料第一人”的塗子沛先生在其成名作《資料之巔》裡提到，摩爾定律、社交媒體、資料探勘是大資料的三大成因。IBM的研究稱，整個人類文明所獲得的全部資料中，有90%是過去兩年內產生的。在此背景下，包括NoSQL，Hadoop, Spark,

C# Queue與RabbitMQ的愛恨情仇（文末附原始碼）：Q與MQ訊息佇列簡單應用（二）

上一章我們講了佇列（ Queue），這一章我們講Message Queue訊息佇列，簡稱MQ。 定義： 　　MQ是MessageQueue，訊息佇列的簡稱（是流行的開源訊息佇列系統，利用erlang語言開發）。MQ是一種應用程式對應用程式的通訊方法。 應用程式通過讀寫入隊和出隊的訊息來通訊，無

【計算機網絡】詳解網絡層（二）ARP和RARP

博文 拆分 detail 動態 再次 tcp 將在 ont 關於 ARP ARP（Address Resolution Protocol，地址解析協議）是將IP地址解析為以太網MAC地址（物理地址）的協議。在局域網中，當主機或其他網絡設備有數據要發送給另一個主機或設備時，它

【RL系列】Multi-Armed Bandit筆記補充（二）

one 不等式 pdf bili 其實在 直接 最好 ppr 分享圖片 本篇的主題是對Upper Conference Bound(UCB)策略進行一個理論上的解釋補充，主要探討UCB方法的由來與相關公式的推導。 UCB是一種動作選擇策略，主要用來解決epsilon-gre

【百度】大型網站的HTTPS實踐（二）——HTTPS加密演算法介紹

大型網站的HTTPS實踐（二）——HTTPS加密演算法介紹 原創 網路通訊/物聯網 作者：AIOps智慧運維 時間：2018-11-09 15:09:43  358  0   前言

【c語言】小程式遊戲——飛機遊戲（二）

                                   在接下來，我們需要對飛機新增一些屬性:                                               1.利用鍵盤控制飛機的移動                      

SpringBoot的IOC模組註解及簡單案例（二）

本文將會講到SpringBoot的IOC模組下的註解進行總結，主要目的是為了方便之後查詢註解和快速應用。 將會以：元件註冊，生命週期，屬性賦值，自動裝配來進行區分。 二、生命週期 1、總結：自定義Bean的初始化和銷燬方法     1）、 指定init-method 和

Maven環境配置及簡單使用（二）

Maven環境變數配置 配置Maven前先從官網下載相關版本，Maven下載地址:http://maven.apache.org/download.cgi,筆者使用最新版本apache-mave

【機器學習】範數規則化之（二）核範數與規則項引數選擇

OK，回到問題本身。我們選擇引數λ的目標是什麼？我們希望模型的訓練誤差和泛化能力都很強。這時候，你有可能還反映過來，這不是說我們的泛化效能是我們的引數λ的函式嗎？那我們為什麼按優化那一套，選擇能最大化泛化效能的λ呢？Oh，sorry to tell you that，因為泛化效能並不是λ的簡單的函式！它具有很

【工作筆記】ElasticSearch從零開始學（二）—— 入門（搜尋）

建立一個員工目錄 假設我們剛好在Megacorp工作，這時人力資源部門出於某種目的需要讓我們建立一個員工目錄，這個目錄用於促進人文關懷和用於實時協同工作，所以它有以下不同的需求 資料能夠包含多個值的標籤、數字和純文字。 檢索任何員工的所有資訊。 支援結構化

【工作筆記】從零開始學ExtJs6（二）——登入模組

題外話 上章，已經有一個專案框架了。大概是這個樣子 app/store ： stores檔案 app/model : models檔案 classic 桌面端檔案 modern 手機端檔案 classic/view： viewControl

Spring Boot Actuator詳解與深入應用（二）：Actuator 2.x

《Spring Boot Actuator詳解與深入應用》預計包括三篇，第一篇重點講Spring Boot Actuator 1.x的應用與定製端點；第二篇將會對比Spring Boot Actuator 2.x 與1.x的區別，以及應用和定製2.x的端點；第三篇將會介紹Actuator metric指

【ZooKeeper】ZooKeeper安裝及簡單操作

centos task spa val jdk8 dir mini dmi 高效 ZooKeeper介紹 　　ZooKeeper是一個分布式的，開放源碼的分布式應用程序協調服務，是Google的Chubby一個開源的實現，是Hadoop和Hbase的重要組件。它是一個為分布

office 2016最新安裝及啟用教程（KMS）【親測有效】！！

前言                 博主的一個朋友，咳咳……你們懂得，想裝office，於是我就上網找了一下啟用的方法，親測有效，而且也沒有什麼廣告病毒之類的，還比較方便，所以傳上來方便大家。好了，進入正題： 安裝office 首先我們需要下載安裝offi

1-RabbitMQ安裝及簡單例項

RabbitMQ安裝及簡單例項 1      RabbitMQ簡介 它其實主要就是接受和轉發訊息，你可以把他理解成郵箱，當你把你想要釋出的郵件信箱,可以肯定的是,郵差先生最終會交付收件人的郵件。在這個比喻中,RabbitMQ信箱,一個郵局和一個郵差。 RabbitMQ和郵局

【Java併發】生產者-消費者模式簡單實現（模擬訊息佇列）

簡單的模擬了一個訊息佇列 Producer：生產者 Consumer：消費者 Message：訊息體 import java.util.concurrent.ArrayBlockingQueue; import java.util.c

【Spring-Ldap】環境準備及配置

環境準備（Maven專案為例） spring-ldap-core（Spring LDAP庫）（必須） spring-core（框架內部使用的其他實用程式類） spring-beans

【hadoop pig】pig安裝及使用

1    執行環境說明 1.1     硬軟體環境 l  主機作業系統：Windows 64 bit，雙核4執行緒，主頻2.2G，6G記憶體 l  虛擬軟體：VMware® Workstation 9.0.0 build-812388 l  虛擬機器作業系統：CentOS