## 前言

我們已經在前文中介紹了[如何使用 JMeter 的 Java Sampler 擴充套件機制](https://www.emqx.com/zh/blog/jmeter-extension-development-custom-java-sampler)輕鬆實現對新協議的支援。Java Sampler 方式的優點在於實現快速，只需關注協議的邏輯部分即可；但缺點是隻能以引數的方式進行互動，介面可用性不高，主要用於待測試協議的原型開發。如果希望實現類似 HTTP Sampler 的介面完整友好的協議擴充套件，JMeter 也提供了相應的擴充套件機制，接下來我們將以擴充套件一個簡單的 Apache Kafaka Producer Sampler 為例，介紹如何實現更完善的新協議外掛。

## Kafka 簡介

Apache Kafka 是由 Apache 軟體基金會開發的一個開源訊息系統專案。Kafka 最初是由 LinkedIn 開發，並於2011年初開源，2012年10月從 Apache 孵化器畢業。該專案的目標是為處理實時資料提供一個統一、高通量、低等待的平臺。

如下圖所示，Kafka 的 Producer（資料生產者）透過 Socket 向 Kafka 叢集上配置好的 Topic（主題）傳送資料，Consumer（資料消費者）在另一端消費由生產者產生的資料，並進行業務的處理。Kafka 作為一個優秀的訊息處理系統，在叢集配置、主題管理等方面有很多值得深入理解和最佳化的地方，由於本文的重點是 JMeter 的擴充套件，只以 Kafka 的生產者為例來介紹如何利用 JMeter 模擬大量生產者。

## 準備工作

擴充套件實現 JMeter 外掛之前，先考慮清楚哪些選項需要暴露給測試人員。像使用 HTTP Sampler 進行測試時，需要讓測試人員提供伺服器地址、埠號、路徑、請求方法、請求內容等資訊。有時也需要進行一些高階配置，比如同執行緒組裡的連線是否共用，這些選項也會在介面中體現，當然外掛實現業務邏輯的時候處理連線的程式碼也會有所不同。

往 Kafka 上傳送訊息時，需要提供一些基本配置資訊（實際 Kafka 的生產者配置不止這些，這裡只舉例了最基本的一些配置項作為演示），如果讀者對下面所說的內容不瞭解也不要緊，只需要理解做這些準備的目的是為了將這些配置選項提供給 Kafka 測試人員，在開始測試之前可以針對被測系統進行配置。

1. 伺服器所在地址，在 Kafka 中稱之為 Broker；
2. 目標主題的名稱；
3. Value Serializer：Kafka 透過網路傳送的訊息，需要將其序列化。Kafka 訊息包括 Key 和 Value，示例中傳送不帶 Key 的訊息，因此要指定是訊息中的 Value 的序列化方式；
4. 傳送的訊息。

下圖是本文最終完成的 JMeter Kafka Producer Sampler 外掛的截圖，使用該外掛進行測試前，需要輸入上面所列的資訊。

[![](http://img.blog.itpub.net/blog/2022/11/10/6f6524aa6d910af2.png?x-oss-process=style/bb)](https://www.emqx.com/zh/blog/support-for-custom-protocols-through-jmeter-extensions)

## JMeter 擴充套件實現

### 步驟1：準備開發環境

前方已經介紹過如何準備開發環境，請參考 [JMeter 擴充套件開發：自定義函式](https://www.emqx.com/zh/blog/jmeter-extension-development-custom-functions) 建立 Maven 專案。針對本文的任務， 專案中需要使用到的依賴包括 `ApacheJMeter_core` 和 `ApacheJMeter_java`，以及 Kafka 類庫。

專案 pom.xml 中所需的依賴部分如下：

```xml
<dependencies>
    <dependency>
        <groupid>org.apache.jmeter</groupid>
        <artifactid>ApacheJMeter_core</artifactid>
        <version>5.4.3</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupid>org.apache.jmeter</groupid>
        <artifactid>ApacheJMeter_java</artifactid>
        <version>5.4.3</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupid>org.apache.kafka</groupid>
        <artifactid>kafka-clients</artifactid>
        <version>3.3.0</version>
    </dependency>
</dependencies>
```

專案建立完畢後，開始編寫程式碼來實現外掛。

### 步驟2：開發外掛介面

之前擴充套件的 Java Sampler 的介面已由 JMeter 擴充套件框架來處理，因此不需要我們重新編寫。但是本文示例的外掛，需要自定義外掛的介面，所以需要把外掛介面也一併開發。JMeter 擴充套件機制中，介面與業務邏輯是分離的，介面的開發也由獨立的類來完成。

需要注意的是，JMeter 的擴充套件機制會從 $JMETER_HOME/lib/ext 目錄下去動態載入符合指定條件的 jar 包，並在 JMeter 中顯示出來。比如要擴充套件 UI 的話，擴充套件的 Java 類的包名須包含”.gui”，回憶一下，之前介紹的擴充套件函式也是類似，它的 Java 類的包名需要包含”.functions”。我們建立以下這個包：com.emqx.xmeter.demo.kafka.sampler.gui。

然後新建一個類：com.emqx.xmeter.demo.kafka.sampler.gui.KafkaSamplerUI，並指定其父類為org.apache.jmeter.samplers.gui.AbstractSamplerGui。AbstractSamplerGui 是 JMeter Sampler 實現介面的統一父類。新建的 KafkaSamplerUI.java 要實現以下的功能：

1. 介面佈局與控制元件生成。JMeter 的介面是標準的 Swing，所以裡面的控制元件和佈局都是標準 Swing 的寫法。
2. 介面與 Sampler 之間的資料交換。Sampler 在 JMeter 中繼承自 TestElement，使用者輸入的資料儲存在 Sampler 中，並持久化儲存到 .jmx 指令碼檔案中。因此可以認為 Sampler 是介面的模型。

介面與模型（Sampler）之間的資料交換需要實現父類的以下幾個方法：

方法 1：

```java
public void configure(TestElement element)
```

該方法用於把 Sampler 中的資料載入到介面中。在實現自己的邏輯之前，先呼叫父類的方法super.configure(element)，可以確保框架自動為你載入一些預設資料，比如 Sampler 名字。

方法 2：

```java
public void modifyTestElement(TestElement element)
```

該方法用於把介面的資料移到 Sampler 中，剛好與 `configure` 方法相反。在呼叫自己的實現方法前，先呼叫super.configureTestElement(element)，也會幫助移動一些預設資料到 Sampler 中。

方法 3：

```csharp
public TestElement createTestElement()
```

該方法建立一個新的 Sampler，然後將介面中的資料設定到這個新的 Sampler 例項中。

方法 4：

```csharp
public void clearGui()
```

該方法會在重新渲染介面的時候呼叫，可以在其中設定介面控制元件中顯示的一些預設值。

方法 5：

```arduino
public String getLabelResource()
```

該方法指定顯示在介面上 Sampler 子選單中顯示的 Sampler 名稱，是透過指定資原始檔中的資源名來匹配多語言的。也可以透過方法 getStaticLabel 來指定固定的名稱，這樣的名稱將不會隨 JMeter 語言改變而變動。如本文的例子中，我們將 Sampler 顯示名稱設定為固定的”Kafka Producer Sampler”。

本例中使用的完整介面程式碼如下，對以上的方法均進行了實現。介面上包括4個控制元件（3個設定引數的控制元件中同一個 panel 中，傳送訊息的控制元件在另一個 panel 中）。

```reasonml
package com.emqx.xmeter.demo.kafka.sampler.gui;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.GridLayout;

import javax.swing.BorderFactory;
import javax.swing.JLabel;
import javax.swing.JPanel;

import org.apache.jmeter.gui.util.JSyntaxTextArea;
import org.apache.jmeter.gui.util.JTextScrollPane;
import org.apache.jmeter.gui.util.VerticalPanel;
import org.apache.jmeter.samplers.gui.AbstractSamplerGui;
import org.apache.jmeter.testelement.TestElement;
import org.apache.jorphan.gui.JLabeledTextField;

import com.emqx.xmeter.demo.kafka.samplers.KafkaSampler;

public class KafkaSamplerUI extends AbstractSamplerGui {

private static final long serialVersionUID = 1L;

private final JLabeledTextField brokersField = new JLabeledTextField("Brokers");
    private final JLabeledTextField topicField = new JLabeledTextField("Topic");
    private final JLabeledTextField valueSerializerField = new JLabeledTextField("Value Serializer");

private final JSyntaxTextArea textMessage = JSyntaxTextArea.getInstance(10, 50);
    private final JLabel textArea = new JLabel("Message");
    private final JTextScrollPane textPanel = JTextScrollPane.getInstance(textMessage);

public KafkaSamplerUI() {
        super();
        this.init();
    }

//介面佈局初始化
    private void init() {
        setLayout(new BorderLayout());
        setBorder(makeBorder());

add(makeTitlePanel(), BorderLayout.NORTH);
        JPanel mainPanel = new VerticalPanel();
        add(mainPanel, BorderLayout.CENTER);

JPanel DPanel = new JPanel();
        DPanel.setLayout(new GridLayout(3, 2));
        DPanel.add(brokersField);
        DPanel.add(topicField);
        DPanel.add(valueSerializerField);

JPanel ControlPanel = new VerticalPanel();
        ControlPanel.add(DPanel);
        ControlPanel.setBorder(BorderFactory.createTitledBorder(BorderFactory.createLineBorder(Color.gray), "Parameters"));
        mainPanel.add(ControlPanel);

JPanel ContentPanel = new VerticalPanel();
        JPanel messageContentPanel = new JPanel(new BorderLayout());
        messageContentPanel.add(this.textArea, BorderLayout.NORTH);
        messageContentPanel.add(this.textPanel, BorderLayout.CENTER);
        ContentPanel.add(messageContentPanel);
        ContentPanel.setBorder(BorderFactory.createTitledBorder(BorderFactory.createLineBorder(Color.gray), "Content"));
        mainPanel.add(ContentPanel);
    }

public String getLabelResource() {
        throw new RuntimeException();
    }

public String getStaticLabel() {
        return "Kafka Producer Sampler";
    }

public TestElement createTestElement() {
        KafkaSampler sampler = new KafkaSampler();
        this.setupSamplerProperties(sampler);
        return sampler;
    }

public void modifyTestElement(TestElement element) {
        KafkaSampler sampler = (KafkaSampler) element;
        this.setupSamplerProperties(sampler);
    }

private void setupSamplerProperties(KafkaSampler sampler) {
        this.configureTestElement(sampler);
        sampler.setBrokers(this.brokersField.getText());
        sampler.setTopic(this.topicField.getText());
        sampler.setMessage(this.textMessage.getText());
        sampler.setValueSerializer(this.valueSerializerField.getText());
    }

@Override
    public void configure(TestElement element) {
        super.configure(element);
        KafkaSampler sampler = (KafkaSampler)element;
        this.brokersField.setText(sampler.getBrokers());
        this.topicField.setText(sampler.getTopic());
        this.valueSerializerField.setText(sampler.getValueSerializer());
        this.textMessage.setText(sampler.getMessage());
    }

@Override
    public void clearGui() {
        super.clearGui();
        this.brokersField.setText("kafka_server:9092");
        this.topicField.setText("jmeterTest");
        this.valueSerializerField.setText("kafka.serializer.StringEncoder");
        this.textMessage.setText("");
    }
}
```

### 步驟3：開發 Sampler 邏輯

新開發的 Sampler 需要繼承父類 org.apache.jmeter.samplers.AbstractSampler，並做以下實現：

1. 增加 getter/setter 方法，用於與介面之間的資料交換。使用者儲存/開啟 .jmx 指令碼檔案時，這些資料將被自動序列化/反序列化。
2. 實現 sample 方法：

```fortran
public SampleResult sample(Entry entry)
```

JMeter 透過該方法，對目標系統發起請求，主要完成的工作包括：

- 記錄請求處理時間
- 對返回結果進行處理和判斷
- 根據處理結果返回 SampleResult，該 SampleResult 中需要判斷返回的內容是否成功，並指定展示給測試人員的訊息等。

該方法的基本實現框架如下所示：

```reasonml
public SampleResult sample(Entry entry) {
    SampleResult result = new SampleResult();
    result.setSampleLabel(getName());
    try {
        result.sampleStart();
        //對目標系統發出測試請求
        //...
        //收到目標系統的響應
        result.sampleEnd();
        result.setSuccessful(true);
        result.setResponseCodeOK();
    } catch (Exception e) {
        result.sampleEnd();
        result.setSuccessful(false);
        result.setResponseMessage("Exception: " + e);
        java.io.StringWriter stringWriter = new java.io.StringWriter();
        e.printStackTrace(new java.io.PrintWriter(stringWriter));
        result.setResponseData(stringWriter.toString(), null);
        result.setDataType(org.apache.jmeter.samplers.SampleResult.TEXT);
        result.setResponseCode("FAILED");
    }
    return result;
}
```

本例的實現中，將為每個虛擬使用者生成一個 Kafka 的 Producer 物件，並將介面中指定的訊息傳送到 Kafka 伺服器。完整的程式碼如下：

```java
package com.emqx.xmeter.demo.kafka.samplers;

import java.text.MessageFormat;
import java.util.Properties;
import java.util.concurrent.ConcurrentHashMap;

import org.apache.jmeter.samplers.AbstractSampler;
import org.apache.jmeter.samplers.Entry;
import org.apache.jmeter.samplers.SampleResult;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.log4j.Logger;

public class KafkaSampler extends AbstractSampler {

private static final long serialVersionUID = 1L;

private static final String KAFKA_BROKERS = "kafka.brokers";
    private static final String KAFKA_TOPIC = "kafka.topic";
    private static final String KAFKA_MESSAGE = "kafka.message";
    private static final String KAFKA_VALUE_SERIALIZER = "kafka.value.serializer";

private static ConcurrentHashMap<string producer="" string="">> producers = new ConcurrentHashMap<>();
    private static final Logger log = Logger.getLogger(KafkaSampler.class);

public KafkaSampler() {
        setName("Kafka Sampler");
    }

@Override
    public SampleResult sample(Entry entry) {
        SampleResult result = new SampleResult();
        result.setSampleLabel(getName());
        try {
            result.sampleStart();

Producer<string string=""> producer = getProducer();
            ProducerRecord<string string=""> msg = new ProducerRecord<string string="">(
                    getTopic(), getMessage());
            producer.send(msg);

result.sampleEnd(); 
            result.setSuccessful(true);
            result.setResponseCodeOK();
        } catch (Exception e) {
            result.sampleEnd();
            result.setSuccessful(false);
            result.setResponseMessage("Exception: " + e);
            java.io.StringWriter stringWriter = new java.io.StringWriter();
            e.printStackTrace(new java.io.PrintWriter(stringWriter));
            result.setResponseData(stringWriter.toString(), null);
            result.setDataType(org.apache.jmeter.samplers.SampleResult.TEXT);
            result.setResponseCode("FAILED");
        }
        return result;
    }

private Producer<string string=""> getProducer() {
        String threadGrpName = getThreadName();
        Producer<string string=""> producer = producers.get(threadGrpName);
        if(producer == null) {
            log.info(MessageFormat.format("Cannot find the producer for {0}, going to create a new producer.", threadGrpName));
            Properties props = new Properties();
            props.put("bootstrap.servers", getBrokers());
            props.put("value.serializer", getValueSerializer());
            props.put("linger.ms", 1);
            producer = new KafkaProducer<string>(props);

producers.put(threadGrpName, producer);
        }
        return producer;
    }

public String getBrokers() {
        return getPropertyAsString(KAFKA_BROKERS);
    }

public void setBrokers(String brokers) {
        setProperty(KAFKA_BROKERS, brokers);
    }

public String getTopic() {
        return getPropertyAsString(KAFKA_TOPIC);
    }

public void setTopic(String topic) {
        setProperty(KAFKA_TOPIC, topic);
    }

public String getMessage() {
        return getPropertyAsString(KAFKA_MESSAGE);
    }

public void setMessage(String message) {
        setProperty(KAFKA_MESSAGE, message);
    }

public String getValueSerializer() {
        return getPropertyAsString(KAFKA_VALUE_SERIALIZER);
    }

public void setValueSerializer(String valueSerializer) {
        setProperty(KAFKA_VALUE_SERIALIZER, valueSerializer);
    }
}
```

### 步驟4：編譯、打包和部署

打包過程與 [JMeter 擴充套件開發：自定義函式](https://www.emqx.com/zh/blog/jmeter-extension-development-custom-functions) 中提到的相似，注意把本外掛需要的 Kafka 相關依賴庫檔案也一併打入，否則還需要將所依賴的 Kafka jar 包單獨部署到 JMeter 外掛目錄下。可以參考以下方式在 pom.xml 中配置 build 外掛：

```dust
<build>
    <finalname>${project.artifactId}</finalname>
    <plugins>
        <plugin>
            <groupid>org.apache.maven.plugins</groupid>
            <artifactid>maven-compiler-plugin</artifactid>
            <version>3.8.0</version>
            <configuration>
                <source>1.8<source>
                <target>1.8</target>
            </configuration>
        </plugin>
        <plugin>
            <groupid>org.apache.maven.plugins</groupid>
            <artifactid>maven-assembly-plugin</artifactid>
            <configuration>
                <descriptorrefs>
                    <descriptorref>jar-with-dependencies</descriptorref>
                </descriptorrefs>
            </configuration>
            <executions>
                <execution>
                    <id>assemble-all</id>
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>
```

編譯打包完成後，從 target 目錄下將 kafka-producer-plugin-jar-with-dependencies.jar 複製至 $JMETER_HOME/lib/ext 目錄下，並重啟 JMeter。

### 步驟5：測試外掛

新建一個測試指令碼，在測試計劃中加入一個執行緒組，然後新增 Sampler。如果外掛開發與部署沒有問題，在子選單中就能看到我們擴充套件出來的”Kafka Sampler”。
[![](http://img.blog.itpub.net/blog/2022/11/10/6e6d9b63003c5cff.png?x-oss-process=style/bb)](https://www.emqx.com/zh/blog/support-for-custom-protocols-through-jmeter-extensions)

修改執行緒組中的執行緒數，就能模擬多虛擬使用者的併發測試了。下圖是“察看結果樹”中顯示的示例結果內容：

[![](http://img.blog.itpub.net/blog/2022/11/10/ef73aaff4c14e6c3.png?x-oss-process=style/bb)](https://www.emqx.com/zh/blog/support-for-custom-protocols-through-jmeter-extensions)

從 Kafka 的消費者端，也可以看到可以接收到相關的訊息：
[![](http://img.blog.itpub.net/blog/2022/11/10/7feb12c5e80640f6.png?x-oss-process=style/bb)](https://www.emqx.com/zh/blog/support-for-custom-protocols-through-jmeter-extensions)

## 總結

如本文所示，如果透過比較”標準”的方式來擴充套件 JMeter 對新協議的測試 Sampler，還是有一定的工作量，特別是需要比較豐富的介面功能的話，介面的實現會比較複雜。如果對介面的要求不高，並且透過傳參的方式可以完成與 Sampler 的互動，那麼使用前文 [JMeter 自定義協議擴充套件之 Java Sampler](https://www.emqx.com/zh/blog/jmeter-extension-development-custom-java-sampler) 介紹的方法擴充套件 Java Sampler 會是更簡單的一種方式。

>版權宣告： 本文為 EMQ 原創，轉載請註明出處。
>
>原文連結：[https://www.emqx.com/zh/blog/support-for-custom-protocols-through-jmeter-extensions](https://www.emqx.com/zh/blog/support-for-custom-protocols-through-jmeter-extensions)</string></string></string></string></string></string></string>

JMeter 擴充套件外掛實現對自定義協議的支援

相關文章