2. 程式人生 > 實用技巧 >RocketMQ（二）

RocketMQ（二）

阿新 • • 發佈：2020-08-09

11 訊息傳送樣例

  • 匯入MQ客戶端依賴
<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-client</artifactId>
    <version>4.7.1</version>
</dependency>
  • 訊息傳送者步驟分析
1.建立訊息生產者producer，並制定生產者組名
2.指定Nameserver地址
3.啟動producer
4.建立訊息物件，指定主題Topic、Tag和訊息體
5.傳送訊息
6.關閉生產者producer
  • 訊息生產者步驟分析
1.建立消費者Consumer，制定消費者組名
2.指定Nameserver地址
3.訂閱主題Topic和Tag
4.設定回撥函式，處理訊息
5.啟動消費者consumer

11.1 基本樣例

11.1.1 傳送訊息

11.1.1.1 傳送同步訊息

這種可靠性同步傳送方式使用比較廣泛，比如：重要的訊息通知、簡訊通知。

public class SyncProducer {
    public static void main(String[] args) throws Exception {
        //1. 建立訊息生產者producer，並制定生產者組名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2. 指定NameServer地址
        producer.setNamesrvAddr("192.168.56.134:9876;192.168.56.135:9876");
        //3. 啟動producer
        producer.start();

        for (int i = 0; i < 10; i++) {
            //4. 建立訊息物件，指定主題Topic、Tag和訊息體
            Message msg = new Message("TopicA","TagA", ("Hello RocketMQ" + i).getBytes(RemotingHelper.DEFAULT_CHARSET));
            //5. 傳送訊息
            SendResult sendResult = producer.send(msg);
            System.out.printf("%s%n", sendResult); //通過sendResult返回訊息是否成功送達

            TimeUnit.SECONDS.sleep(1);
        }

        //6. 關閉生產者producer
        producer.shutdown();
    }
}

11.1.1.2 傳送非同步訊息

非同步訊息通常用在對響應時間敏感的業務場景，即傳送端不能容忍長時間地等待Broker的響應。

public class AsyncProducer {
    public static void main(String[] args) throws Exception {
        //1. 建立訊息生產者producer，並制定生產者組名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2. 指定NameServer地址
        producer.setNamesrvAddr("192.168.56.134:9876;192.168.56.135:9876");
        //3. 啟動producer
        producer.start();

        producer.setRetryTimesWhenSendAsyncFailed(0);
        for (int i = 0; i < 10; i++) {
            final int index = i;
            //4. 建立訊息物件，指定主題Topic、Tag和訊息體
            Message msg = new Message("TopicA", "TagB", ("Hello RocketMQ" + i).getBytes(RemotingHelper.DEFAULT_CHARSET));

            //5. 傳送非同步訊息
            producer.send(msg, new SendCallback() { 
                //SendCallback接收非同步返回結果的回撥
                @Override
                public void onSuccess(SendResult sendResult) {
                    System.out.printf("%-10d 0K%s%n", index, sendResult);
                }

                @Override
                public void onException(Throwable e) {
                    System.out.printf("%-10d Exception%s%n", index, e);
                    e.printStackTrace();
                }
            });

            TimeUnit.SECONDS.sleep(1);
        }

        //6. 關閉生產者producer
        producer.shutdown();
    }
}

11.1.1.3 傳送單向訊息

public class OneWayProducer {
    public static void main(String[] args) throws Exception {
        //1. 建立訊息生產者producer，並制定生產者組名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2. 指定NameServer地址
        producer.setNamesrvAddr("192.168.56.134:9876;192.168.56.128:9876");
        //3. 啟動producer
        producer.start();

        for (int i = 0; i < 10; i++) {
            //4. 建立訊息物件，指定主題Topic、Tag和訊息體
            Message msg = new Message("TopicA", "TagA", ("Hello RocketMQ" + i).getBytes(RemotingHelper.DEFAULT_CHARSET));
            //5. 傳送單向訊息
            producer.sendOneway(msg);

            TimeUnit.SECONDS.sleep(1);
        }

        //6. 關閉生產者producer
        producer.shutdown();
    }
}

11.1.2 消費訊息

11.1.2.1 負載均衡模式

預設的消費模式，多個消費者共同消費佇列訊息，每個消費者處理的訊息不同。

public class Consumer {
    public static void main(String[] args) throws Exception {
        //1.建立消費者Consumer，制定消費者組名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.56.134:9876;192.168.56.128:9876");
        //3.訂閱主題Topic和Tag
        consumer.subscribe("TopicA", "TagA || TagB");//消費全部tag可以用*
        //設定消費模式：負載均衡|廣播
        consumer.setMessageModel(MessageModel.CLUSTERING);
        //4.設定回撥函式，處理訊息
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            //接收訊息內容
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for (MessageExt msg : list)
                    System.out.println(new String(msg.getBody()));
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        //5.啟動消費者consumer
        consumer.start();
    }
}

11.1.2.2 廣播模式

每個消費者消費的訊息是相同的。

consumer.setMessageModel(MessageModel.BROADCASTING);

11.2 順序訊息

訊息有序指的是可以按照訊息的傳送順序來消費（FIFO）。RocketMQ可以嚴格的保證訊息有序，可以分為分割槽有序或者全域性有序。
順序消費的原理解析，在預設的情況下訊息傳送會採取Round Robin輪詢方式把訊息傳送到不同的queue（分割槽佇列）；而消費訊息的時候從多個queue上拉取訊息，這種情況傳送和消費是不能保證順序。但是如果控制傳送的順序訊息只依次傳送到同一個queue中，消費的時候只從這個queue上依次拉取，則就保證了順序。當傳送和消費參與的queue只有一個，則是全域性有序；如果多個queue參與，則為分割槽有序，即相對每個queue，訊息都是有序的。
下面用訂單進行分割槽有序的示例。一個訂單的順序流程是：建立、付款、推送、完成。訂單號相同的訊息會被先後傳送到同一個佇列中，消費時，同一個Orderld獲取到的肯定是同一個佇列。

11.2.1 生產者

public class Producer {
    public static void main(final String[] args) throws Exception {
        //1. 建立訊息生產者producer，並制定生產者組名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2. 指定NameServer地址
        producer.setNamesrvAddr("192.168.56.134:9876;192.168.56.128:9876");
        //3. 啟動producer
        producer.start();

        //建立訊息集合
        List<OrderStep> orderSteps = OrderStep.buildOrders();
        for (int i = 0; i < orderSteps.size(); i++) {
            String body = JSON.toJSONString(orderSteps.get(i));
            //4. 建立訊息物件，指定主題topic、tags、keys、訊息體
            Message message = new Message("OrderTopic", "OrderTag", "key" + i, body.getBytes());
            /**
             * 5. 傳送訊息
             *
             * 引數一：訊息物件
             * 引數二：訊息佇列的選擇器
             * 引數三：選擇佇列的業務標識（訂單ID）
             */
            SendResult sendResult = producer.send(message, new MessageQueueSelector() {
                /**
                 * @param list 佇列集合
                 * @param message 訊息物件
                 * @param o 業務標識的引數
                 * @return
                 */
                @Override
                public MessageQueue select(List<MessageQueue> list, Message message, Object o) {
                    Long orderId = (Long) o;
                    long index = orderId % list.size();
                    return list.get((int) index);
                }
            }, orderSteps.get(i).getOrderId());
            System.out.println("傳送結果：" + sendResult);
        }

        //6. 關閉生產者producer
        producer.shutdown();
    }
}

11.2.2 消費者

public class Consumer {
    public static void main(String[] args) throws Exception {
        //1.建立消費者Consumer，制定消費者組名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.56.134:9876;192.168.56.128:9876");
        //3.訂閱主題Topic和Tag
        consumer.subscribe("OrderTopic", "*");//消費全部tag可以用*
        //4.註冊訊息監聽器
        consumer.registerMessageListener(new MessageListenerOrderly() {
            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> list, ConsumeOrderlyContext consumeOrderlyContext) {
                for (MessageExt msg : list) {
                    System.out.println("執行緒名稱：【" + Thread.currentThread().getName() + "】，消費訊息：" + new String(msg.getBody()));
                }
                return ConsumeOrderlyStatus.SUCCESS;
            }
        });
        //5.啟動消費者consumer
        consumer.start();
        System.out.println("消費者啟動");
    }
}

11.3 延時訊息

比如電商裡，提交了一個訂單就可以傳送一個延時訊息，1h後去檢查這個訂單的狀態，如果還是未付款就取消訂單釋放庫存。

生產者

public class Producer {
    public static void main(String[] args) throws Exception {
        //1. 建立訊息生產者producer，並制定生產者組名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2. 指定NameServer地址
        producer.setNamesrvAddr("192.168.56.134:9876;192.168.56.128:9876");
        //3. 啟動producer
        producer.start();

        for (int i = 0; i < 10; i++) {
            //4. 建立訊息物件，指定主題Topic、Tag和訊息體
            Message msg = new Message("DelayTopic", "TagA", ("Hello RocketMQ" + i).getBytes(RemotingHelper.DEFAULT_CHARSET));
            msg.setDelayTimeLevel(2);
            //5. 傳送訊息
            SendResult sendResult = producer.send(msg);
            System.out.println("傳送結果：" + sendResult);

            TimeUnit.SECONDS.sleep(1);
        }

        //6. 關閉生產者producer
        producer.shutdown();
    }
}

使用限制

//org/apache/rocketmq/store/config/MessagestoreConfig.java 
private string messageDelayleve1 = "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2th";

不支援任意時間的延時，需要設定幾個固定的延時等級，從1s到2h分別對應1到18等級。

批量訊息

批量傳送訊息能顯著提高傳遞小訊息的效能。限制是這些批量訊息應該有相同的topic，相同的waitStoreMsgOK，而且不能是延時訊息。此外，這一批訊息的總大小不應超過4MB。

傳送批量訊息

每次傳送不超過4MB的訊息，樣例如下：

//4. 建立訊息物件，指定主題Topic、Tag和訊息體
List<Message> msgs = new ArrayList<Message>();
Message msg1 = new Message("BatchTopic", "TagA", ("Hello RocketMQ" + 1).getBytes());
Message msg2 = new Message("BatchTopic", "TagA", ("Hello RocketMQ" + 2).getBytes());
Message msg3 = new Message("BatchTopic", "TagA", ("Hello RocketMQ" + 3).getBytes());
msgs.add(msg1);
msgs.add(msg2);
msgs.add(msg3);

//5. 傳送訊息
SendResult sendResult = producer.send(msgs);
System.out.println("傳送結果：" + sendResult);

如果訊息的總長度可能大於4MB，最好把訊息進行分割：

public class ListSplitter implements Iterator<List<Message>> {
    private final int SIZE_LIMIT = 1024 * 1024 * 4;
    private final List<Message> messages;
    private int currIndex;

    public ListSplitter(List<Message> messages) {
        this.messages = messages;
    }

    @Override
    public boolean hasNext() {
        return currIndex < messages.size();
    }

    @Override
    public List<Message> next() {
        int nextIndex = currIndex;
        int totalSize = 0;
        for (; nextIndex < messages.size(); nextIndex++) {
            Message message = messages.get(nextIndex);
            int tmpSize = message.getTopic().length() + message.getBody().length;
            Map<String, String> properties = message.getProperties();
            for (Map.Entry<String, String> entry : properties.entrySet()) {
                tmpSize += entry.getKey().length() + entry.getValue().length();
            }
            tmpSize = tmpSize + 20;//增加日誌的開銷20位元組
            if (tmpSize > SIZE_LIMIT) {
                //單個訊息超過了最大的限制
                //忽略,否則會阻塞分裂的程序
                if (nextIndex - currIndex == 0) {
                    //假如下一個子列表沒有元素,則新增這個子列表然後退出迴圈,否則只是退出迴圈
                    nextIndex++;
                }
                break;
            }
            if (tmpSize + totalSize > SIZE_LIMIT) {
                break;
            } else {
                totalSize += tmpSize;
            }
        }
        List<Message> subList = messages.subList(currIndex, nextIndex);
        currIndex = nextIndex;
        return subList;
    }
}

過濾訊息

Tag方式

SQL語法方式

SQL基本語法

RocketMQ只定義了一些基本語法來支援這個特性。你也可以很容易地擴充套件它。

  • 數值比較，比如：>，>=，<，<=，BETWEEN，=；
  • 字元比較，比如：=，<>，IN；
  • IS NULL或者IS NOT NULL；
  • 邏輯符號AND，OR，NOT；

常量支援型別為：

  • 數值，比如：123，3.1415；
  • 字元，比如：'abc'，必須用單引號包裹起來；
  • NULL，特殊的常量
  • 布林值，TRUE或FALSE

只有使用push模式的消費者才能用使用SQL92標準的sql語句，介面如下：

public void subscribe（finalstring topic，final Messageselector messageselector）

生產者

public class Producer {
    public static void main(String[] args) throws Exception {
        //1. 建立訊息生產者producer，並制定生產者組名
        DefaultMQProducer producer = new DefaultMQProducer("group1");
        //2. 指定NameServer地址
        producer.setNamesrvAddr("192.168.56.134:9876;192.168.56.128:9876");
        //3. 啟動producer
        producer.start();

        for (int i = 0; i < 10; i++) {
            //4. 建立訊息物件，指定主題Topic、Tag和訊息體
            Message msg = new Message("FilterSQLTopic", "Tag1", ("Hello RocketMQ" + i).getBytes());
            msg.putUserProperty("i", String.valueOf(i));

            //5. 傳送訊息
            SendResult sendResult = producer.send(msg);
            System.out.println("傳送結果：" + sendResult);

            TimeUnit.SECONDS.sleep(1);
        }

        //6. 關閉生產者producer
        producer.shutdown();
    }
}

消費者

public class Consumer {
    public static void main(String[] args) throws Exception {
        //1.建立消費者Consumer，制定消費者組名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group1");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.56.134:9876;192.168.56.128:9876");
        //3.訂閱主題Topic和Tag
        consumer.subscribe("FilterSQLTopic", MessageSelector.bySql("i>5"));

        //4.設定回撥函式，處理訊息
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            //接收訊息內容
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for (MessageExt msg : list)
                    System.out.println(new String(msg.getBody()));
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });

        //5.啟動消費者consumer
        consumer.start();
        System.out.println("消費者啟動");
    }
}

事務訊息

流程分析

上圖說明了事務訊息的大致方案，其中分為兩個流程：正常事務訊息的傳送及提交、事務訊息的補償流程。

1）事務訊息傳送及提交

  1. 傳送訊息（half訊息）
  2. 服務端響應訊息寫入結果
  3. 根據傳送結果執行本地事務（如果寫入失敗，此時half訊息對業務不可見，本地邏輯不執行）
  4. 根據本地事務狀態執行Commit或者Rollback（Commit操作生成訊息索引，訊息對消費者可見）

2）事務補償

  1. 對沒有Commit/Rollback的事務訊息（pending狀態的訊息），從服務端發起一-次"回查”
  2. Producer收到回查訊息，檢查回查訊息對應的本地事務的狀態
  3. 根據本地事務狀態，重新Commit或者 Rollback其中，補償階段用於解決訊息Commit或者Rollback發生超時或者失敗的情況。

3）事務訊息狀態

事務訊息共有三種狀態，提交狀態、回滾狀態、中間狀態：

  • TransactionStatus.CommitTransaction：提交事務，它允許消費者消費此訊息
  • TransactionStatus.RollbackTransaction：回滾事務，它代表該訊息將被刪除，不允許被消費
  • TransactionStatus.Unknown：中間狀態，它代表需要檢查訊息佇列來確定狀態

生產者

public class Producer {
    public static void main(String[] args) throws Exception {
        //1. 建立訊息生產者producer，並制定生產者組名
        TransactionMQProducer producer = new TransactionMQProducer("group2");
        //2. 指定NameServer地址
        producer.setNamesrvAddr("192.168.56.134:9876;192.168.56.128:9876");

        //新增事務監聽器
        producer.setTransactionListener(new TransactionListener() {
            /**
             * 本地事務
             * @param message
             * @param o
             * @return
             */
            @Override
            public LocalTransactionState executeLocalTransaction(Message message, Object o) {
                if (StringUtils.equals("TagA", message.getTags())) {
                    return LocalTransactionState.COMMIT_MESSAGE;
                } else if (StringUtils.equals("TagB", message.getTags())) {
                    return LocalTransactionState.ROLLBACK_MESSAGE;
                } else {
                    return LocalTransactionState.UNKNOW;
                }
            }

            /**
             * 回查
             * @param messageExt
             * @return
             */
            @Override
            public LocalTransactionState checkLocalTransaction(MessageExt messageExt) {
                System.out.println("回查訊息的tag：" + messageExt.getTags());
                return LocalTransactionState.COMMIT_MESSAGE;
            }
        });

        //3. 啟動producer
        producer.start();

        String[] tags = {"TagA", "TagB", "TagC"};
        for (int i = 0; i < 3; i++) {
            //4. 建立訊息物件，指定主題Topic、Tag和訊息體
            Message msg = new Message("TransactionTopic", tags[i], ("Hello RocketMQ" + i).getBytes());
            //5. 傳送訊息
            SendResult sendResult = producer.sendMessageInTransaction(msg, null);//事務可以應用到一個訊息上面，也可以應用到整個producer上面，null表示整個producer
            System.out.println("傳送結果：" + sendResult);

            TimeUnit.SECONDS.sleep(2);
        }

        //6. 關閉生產者producer
        //producer.shutdown();關閉producer就沒法回查了
    }
}

消費者

public class Consumer {
    public static void main(String[] args) throws Exception {
        //1.建立消費者Consumer，制定消費者組名
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("group2");
        //2.指定Nameserver地址
        consumer.setNamesrvAddr("192.168.56.134:9876;192.168.56.128:9876");
        //3.訂閱主題Topic和Tag
        consumer.subscribe("TransactionTopic", "*");

        //4.設定回撥函式，處理訊息
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            //接收訊息內容
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
                for (MessageExt msg : list)
                    System.out.println(new String(msg.getBody()));
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        //5.啟動消費者consumer
        consumer.start();
        System.out.println("消費者啟動");
    }
}

相關推薦

RocketMQ（二）

11 訊息傳送樣例 匯入MQ客戶端依賴 <dependency> <groupId>org.apache.rocketmq</groupId>

RocketMq原始碼分析篇Producer（二）

生產者介紹 rocketmq原始碼分析篇生產者傳送訊息到broker，生產者生產訊息分為三種方式SYNC（同步模式）、ASYNC（非同步模式）、ONEWAY（直接發）。同步傳送（SYNC）:客戶端提交訊息到broker

RocketMQ深度解析（二）：NameServer

NamerServer NameServer是一個非常簡單的Topic路由註冊中心，其角色類似Dubbo中的zookeeper，支援Broker的動態註冊與發現。主要包括兩個功能：Broker管理，NameServer接受Broker叢集的註冊資訊並且儲存下來作為路由資

RocketMQ入門到入土（二）事務訊息&順序訊息

接上一篇：RocketMQ入門到入土（一）新手也能看懂的原理和實戰！ 一、事務訊息的由來

rocketMq之快速入門（二）

技術標籤：MQ 安裝jdk(參考：https://blog.csdn.net/github_38336924/article/details/82221258) 執行安裝jdk命令

RocketMQ系列（二）——應用篇

技術標籤：RocketMQ 本篇以應用角度講解RocketMQ的本地安裝、啟動與簡單配置，以及各主要類的功能及使用方式。更多其它瞭解請參考：

RocketMQ詳解（二）核心原理

一、broker訊息儲存 本節揭露broker上訊息儲存的真實目錄結構+儲存方式。 1.1 目錄、檔案結構

從零開始學習Vue（二）

元件模組化 簡介 如果我們將一個頁面中所有的處理邏輯全部放在一起，處理起來就會變得非常複雜，而且不利於後續的管理以及擴充套件。但如果，我們講一個頁面拆分成一個個小的功能塊，每個功能塊完成屬於自己這部分獨

演演算法基礎篇-關於棧的演演算法題分析（二）

算法系列篇章-可以參照如下順序閱讀 演演算法基礎篇-關於連結串列的演演算法題解析

Java 多執行緒基礎（二）

簡介 在上篇 Java 多執行緒基礎（一） 我們提到了一些執行緒的常用方法，這篇我們具體看看其中一些方法的使用以及方法的區別，讓我們在工作中更好的使用。

RabbitMQ 入門 （二）——建立一個基本的訊息佇列(點對點模式)

上一篇文章：RabbitMQ環境的搭建（一）——CentOS7下安裝rabbitMQ環境 Virtual Host的作用

Swift 遊戲開發之「能否關個燈」（二）

前言 在上一篇文章中，我們對遊戲主體的邏輯進行了完善，通過一個 GameManager 配置了遊戲的關卡，並一同完成了遊戲的判贏和判輸邏輯。

不推薦使用Spring Boot 2.2.0 ，這個問題你肯定會遇到 （二）

專案推薦:Spring Cloud 、Spring Security OAuth2的RBAC許可權管理系統 歡迎關注 最新版本實踐

寫給Java程式設計師的TypeScript入門教程（二）

本文內容承接本系列的上一篇《寫給Java程式設計師的TypeScript入門教程（一）》。上一篇介紹了本系列教程的背景，並進行了開發環境的搭建。本系列的教學思路是通過專案實戰來學習TypeScript，選取了一個簡單的雲服務

Dubbo原始碼解析（二）Dubbo擴充套件機制SPI

Dubbo擴充套件機制SPI 前一篇文章《dubbo原始碼解析（一）Hello,Dubbo》是對dubbo整個專案大體的介紹，而從這篇文章開始，我將會從原始碼來解讀dubbo再各個模組的實現原理以及特點，由於全部由截圖的方式去解讀原始碼

併發讀寫資料一致性保證（二）-MySQL

業務開發過程，其實就是使用者業務資料的處理過程，因而開發的核心任務就是維護資料一致不出錯。現實場景中，多個使用者會併發讀寫同一份資料（如秒殺），不加控制會翻車、加了控制則降低併發度，影響效能和使用者體

Java併發程式設計（二）——併發級別

由於臨界區的存在，多執行緒之間的併發必須受到控制。根據控制併發的策略，可以把併發分為幾個級別：阻塞、無飢餓、無障礙、無鎖、無等待。

帶你入坑大資料（二） --- HDFS的讀寫流程和一些重要策略

前言 前情回顧 如果說上一篇是在闡述HDFS最基礎的理論知識，這一篇就是HDFS的主要工作流程，和一些較為有用的策略

Node 使用 Egg 框架 之 上TS 的教程（二）

Node + Egg + TS + Mongodb + Resetful + graphql 本節課內容： graphql 和 egg 定時任務 執行環境： Node ，Yarn/NPM，MongoDB

JVM從零開始：Java重要概念與JVM（二）

原文地址：www.sudo.ren/article/81?… Java的體系結構主要由Java程式語言、位元組碼、Java API 和Java虛擬機器器相關技術組成。