背景
刚使用thingsboard3.4的时候，不清楚thingsboard能够支持多了设备，如果项目中真的要用起来，不免要对它进行测试，花了不少时间写的，特此记录。
mqtt连接请参考：
https://blog.csdn.net/qq_40351360/article/details/127678653
依赖
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.5.13</version>
</dependency>
生成设备和并非测试代码类
package com.example.demo.http;
import com.alibaba.fastjson.JSONObject;
import com.example.demo.mqtt.MqConfig;
import com.example.demo.mqtt.MqUtils;
import com.example.demo.mqtt.SubMessageListener;
import org.eclipse.paho.client.mqttv3.MqttClient;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.concurrent.CustomizableThreadFactory;
import java.io.*;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* 1.第一次启动生成1000个设备，并生成文件记录
* 2.第二次可以连接100台设备并发送数据，可进行压测
* @date 2022/10/28 10:32
*/
public class Demo {
private static final Logger logger = LoggerFactory.getLogger(Demo.class);
private static String host = "192.122.11.151";
private static int port = 5530;
private static String deviceProfileId = "0bf257f0-5511-11ed-b43a-e174163c10d7";
private static String prefix = "aaa_";
private static String username = "abc1124";
private static String password = "abc1124";
private static String path = "d://record.log";
private static int threadNum = 0;
private static ThreadPoolExecutor sendData = new ThreadPoolExecutor(threadNum, 60, 60 * 3, TimeUnit.SECONDS, new LinkedBlockingQueue(10000), new CustomizableThreadFactory("testThreadPool"), new ThreadPoolExecutor.CallerRunsPolicy());
static {
threadNum = (int) Math.floor(Runtime.getRuntime().availableProcessors() / (1 - 0.8));
}
public static void main(String[] args) {
String hostUrl = host + ":" + port;
Boolean correct = false;
Boolean fileExists = true;
//将生成的设备id写入到文件中
File file = new File(path);
if (!file.exists()) {
try {
fileExists = false;
file.createNewFile();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
Set<String> deviceClientIds = new HashSet<>();
//判断文件中是否存在1000个设备
try {
BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
String line = null;
int i = 0;
while ((line = reader.readLine()) != null) {
i++;
//logger.info("{}=readLine data:{}", i, line);
if (line.length() < 37) {
continue;
}
String uuid = line.split(",")[1];
if (uuid.length() == 36 && uuid.contains("-")) {
deviceClientIds.add(uuid);
}
}
if (i == 1006) {
correct = true;
}
} catch (Exception e) {
throw new RuntimeException(e);
}
if (correct) {
//开始发送数据
logger.info("开始发送数据...");
Map<String, MqttClient> map = new HashMap<>();
try {
//创建设备连接
int a1 = 1;
for (String uuid : deviceClientIds) {
/*if (!"2ceb25f4-af1a-4b02-8fa0-ab9223174b3e".equals(uuid)) {
continue;
}*/
MqttClient mqttClient = MqUtils.connect("tcp://192.168.1.51:5200", uuid, username, password);
if (mqttClient.isConnected()) {
System.out.println(uuid);
//
subMsg(mqttClient, "v1/devices/me/attributes", a1 + "");
subMsg(mqttClient, "v1/devices/me/attributes/response/+", a1 + "");
subMsg(mqttClient, "v1/devices/me/rpc/request/+", a1 + "");
subMsg(mqttClient, "v1/devices/me/rpc/response/+", a1 + "");
subMsg(mqttClient, "v2/fw/response/+/chunk/+", a1 + "");
/* ThreadDemo threadDemo = new ThreadDemo(mqttClient, a1, null, username, password);
threadDemo.publish("{
\"current_fw_title\":\"Initial\",\n" +
" \"current_fw_version\":\"v0\"" +
" }", "v1/devices/me/telemetry");*/
/*threadDemo.publish("{
\"current_fw_title\":\"Initial\",\n" +
" \"current_fw_version\":\"v0\",\n" +
" \"fw_state\":\"DOWNLOADING\"\n" +
" }", "v1/devices/me/telemetry");*/
//threadDemo.publish("{
\"sharedKeys\": \"fw_version,fw_checksum_algorithm,fw_checksum,fw_size,fw_title,fw_version\"}", "v1/devices/me/attributes/request/1");
/*int i = (int) Math.ceil(421320 / 1320)+1;
for (int a = 1; a <= i; a++) {
System.out.println("a: "+a);
threadDemo.setI(a);
threadDemo.publish("1320", "v2/fw/request/" + a + "/chunk/" + (a-1));
}*/
map.put(uuid, mqttClient);
}
a1++;
}
logger.info("连接设备数：{}台", map.size());
logger.info("10秒后开始发送数据");
Thread.sleep(2000000);
while (true) {
long startTime = System.currentTimeMillis();
int active = 0;
for (Map.Entry<String, MqttClient> entry : map.entrySet()) {
if (entry.getValue().isConnected()) {
active++;
}
}
logger.info("存活数{}", active);
for (int i = 0; i < 1000; i++) {
int a = 1;
for (Map.Entry<String, MqttClient> entry : map.entrySet()) {
a++;
//发送数据
sendData.execute(new ThreadDemo(entry.getValue(), a, entry.getKey(), username, password));
}
}
logger.info("耗时：{}毫秒", (System.currentTimeMillis() - startTime));
Thread.sleep(60000);
}
} catch (Exception e) {
e.printStackTrace();
}
}
if (fileExists) {
logger.info("结束...");
return;
}
createDevices(hostUrl, file);
logger.info("结束...");
}
private static void subMsg(MqttClient mqttClient, String topic, String id) throws MqttException {
if (mqttClient != null) {
int[] Qos = {
MqConfig.qos};
String[] topics = {
topic};
mqttClient.subscribe(topics, Qos);
}
mqttClient.subscribe(topic, MqConfig.qos, new SubMessageListener(id, mqttClient, topic));
}
private static void createDevices(String hostUrl, File file) {
//第一步获取token
JSONObject resultJson = Http.getLoginJsonObject(hostUrl);
if (resultJson == null) return;
String token = resultJson.getString("token");
BufferedWriter writer = null;
FileWriter fw = null;
try {
fw = new FileWriter(file);
writer = new BufferedWriter(fw);
writer.write(host + "\n");
writer.write(port + "\n");
writer.write(deviceProfileId + "\n");
writer.write(prefix + "\n");
writer.write(username + "\n");
writer.write(password + "\n");
} catch (Exception e) {
throw new RuntimeException(e);
}
for (int i = 0; i < 1000; i++) {
//第二步添加设备
JSONObject deviceJson = Http.createDeviceJsonObject(hostUrl, deviceProfileId, token, prefix);
if (deviceJson == null) return;
//第三步获取凭据
JSONObject getCredentialsJson = Http.getCredentials(hostUrl, token, deviceJson, deviceProfileId);
if (getCredentialsJson == null) return;
//第四步 更新凭据
JSONObject updateCredentialsJson = Http.updateCredentials(hostUrl, token, deviceJson, getCredentialsJson, username, password);
if (updateCredentialsJson == null) return;
try {
// 带有缓冲区，可提高性能
writer.write(deviceJson.getJSONObject("id").getString("id") + "," + updateCredentialsJson.getString("uuid")+"," + deviceJson.getString("name") + "\n");
} catch (IOException e) {
throw new RuntimeException(e);
}
}
try {
writer.close();
fw.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
http请求工具类
package com.example.demo.http;
import com.alibaba.fastjson.JSONObject;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Map;
import java.util.UUID;
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class Http {
private static final Logger logger = LoggerFactory.getLogger(Http.class);
/**
* 发送get请求，参数为json
*
* @param url
* @param param body内容，json格式
* @param token 令牌
* @return
* @throws Exception
*/
public static String sendJsonByGetReq(String url, String param, String token) throws Exception {
logger.debug("[请求]：url={} {} body={} token={}", url, "GET", param, token);
String body = "";
//创建httpclient对象
CloseableHttpClient client = HttpClients.createDefault();
HttpGetWithEntity httpGetWithEntity = new HttpGetWithEntity(url);
HttpEntity httpEntity = new StringEntity(param, ContentType.APPLICATION_JSON);
httpGetWithEntity.setEntity(httpEntity);
httpGetWithEntity.addHeader("Content-Type", "application/json");
httpGetWithEntity.addHeader("X-Authorization", "Bearer " + token);
//执行请求操作，并拿到结果（同步阻塞）
CloseableHttpResponse response = client.execute(httpGetWithEntity);
//获取结果实体
HttpEntity entity = response.getEntity();
if (entity != null) {
//按指定编码转换结果实体为String类型
body = EntityUtils.toString(entity, "utf-8");
}
//释放链接
response.close();
return body;
}
/**
* 改delete请求不能携带body数据
*
* @param methodUrl
* @param token
* @return
*/
public static String httpURLDELETECase(String methodUrl, String token) {
logger.debug("[请求]：url={} {} body={} token={}", methodUrl, "DELETE", token);
HttpURLConnection connection = null;
BufferedReader reader = null;
String line = null;
try {
URL url = new URL(methodUrl);
connection = (HttpURLConnection) url.openConnection();// 根据URL生成HttpURLConnection
connection.setDoInput(true); // 设置是否从connection读入，默认情况下是true;
connection.setRequestMethod("DELETE");// 默认DELETE请求
connection.setRequestProperty("Content-Type", "application/json");
connection.setRequestProperty("X-Authorization", "Bearer " + token);
connection.connect();// 建立TCP连接
if (connection.getResponseCode() == HttpURLConnection.HTTP_OK) {
reader = new BufferedReader(new InputStreamReader(connection.getInputStream(), "UTF-8"));// 发送http请求
StringBuilder result = new StringBuilder();
// 循环读取流
while ((line = reader.readLine()) != null) {
result.append(line).append(System.getProperty("line.separator"));// "\n"
}
return result.toString();
} else {
reader = new BufferedReader(new InputStreamReader(connection.getErrorStream(), "UTF-8"));// 发送http请求
StringBuilder result = new StringBuilder();
// 循环读取流
while ((line = reader.readLine()) != null) {
result.append(line).append(System.getProperty("line.separator"));// "\n"
}
logger.error("[访问错误]:{} {} {}", connection.getResponseCode(), methodUrl, result.toString());
return null;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (reader != null) {
reader.close();
}
} catch (IOException e) {
e.printStackTrace();
}
connection.disconnect();
}
return null;
}
/**
* 改get请求不能携带body数据
*
* @param methodUrl
* @param body
* @param token
* @return
*/
public static String httpURLGETCase(String methodUrl, String body, String token) {
logger.debug("[请求]：url={} {} body={} token={}", methodUrl, "GET", body, token);
HttpURLConnection connection = null;
BufferedReader reader = null;
String line = null;
try {
URL url = new URL(methodUrl);
connection = (HttpURLConnection) url.openConnection();// 根据URL生成HttpURLConnection
connection.setDoInput(true); // 设置是否从connection读入，默认情况下是true;
connection.setRequestMethod("GET");// 默认GET请求
connection.setRequestProperty("Content-Type", "application/json");
connection.setRequestProperty("X-Authorization", "Bearer " + token);
connection.connect();// 建立TCP连接
if (connection.getResponseCode() == HttpURLConnection.HTTP_OK) {
reader = new BufferedReader(new InputStreamReader(connection.getInputStream(), "UTF-8"));// 发送http请求
StringBuilder result = new StringBuilder();
// 循环读取流
while ((line = reader.readLine()) != null) {
result.append(line).append(System.getProperty("line.separator"));// "\n"
}
return result.toString();
} else {
reader = new BufferedReader(new InputStreamReader(connection.getErrorStream(), "UTF-8"));// 发送http请求
StringBuilder result = new StringBuilder();
// 循环读取流
while ((line = reader.readLine()) != null) {
result.append(line).append(System.getProperty("line.separator"));// "\n"
}
logger.error("[访问错误]:{} {} {}", connection.getResponseCode(), methodUrl, result.toString());
return null;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (reader != null) {
reader.close();
}
} catch (IOException e) {
e.printStackTrace();
}
connection.disconnect();
}
return null;
}
private static String httpURLPOSTCase(String methodUrl, String body, String token) {
logger.debug("[请求]：url={} {} body={} token={}", methodUrl, "POST", body, token);
HttpURLConnection connection = null;
OutputStream dataout = null;
BufferedReader reader = null;
String line = null;
try {
URL url = new URL(methodUrl);
connection = (HttpURLConnection) url.openConnection();// 根据URL生成HttpURLConnection
connection.setDoOutput(true);// 设置是否向connection输出，因为这个是post请求，参数要放在http正文内，因此需要设为true,默认情况下是false
connection.setDoInput(true); // 设置是否从connection读入，默认情况下是true;
connection.setRequestMethod("POST");// 设置请求方式为post,默认GET请求
connection.setUseCaches(false);// post请求不能使用缓存设为false
connection.setConnectTimeout(3000);// 连接主机的超时时间
connection.setReadTimeout(3000);// 从主机读取数据的超时时间
connection.setInstanceFollowRedirects(true);// 设置该HttpURLConnection实例是否自动执行重定向
connection.setRequestProperty("connection", "Keep-Alive");// 连接复用
connection.setRequestProperty("charset", "utf-8");
if (token != null && token != "") {
connection.setRequestProperty("X-Authorization", "Bearer " + token);
}
connection.setRequestProperty("Content-Type", "application/json");
connection.connect();// 建立TCP连接,getOutputStream会隐含的进行connect,所以此处可以不要
dataout = new DataOutputStream(connection.getOutputStream());// 创建输入输出流,用于往连接里面输出携带的参数
dataout.write(body.getBytes());
dataout.flush();
dataout.close();
if (connection.getResponseCode() == HttpURLConnection.HTTP_OK) {
reader = new BufferedReader(new InputStreamReader(connection.getInputStream(), "UTF-8"));// 发送http请求
StringBuilder result = new StringBuilder();
// 循环读取流
while ((line = reader.readLine()) != null) {
result.append(line).append(System.getProperty("line.separator"));//
}
return result.toString();
} else {
reader = new BufferedReader(new InputStreamReader(connection.getErrorStream(), "UTF-8"));// 发送http请求
StringBuilder result = new StringBuilder();
// 循环读取流
while ((line = reader.readLine()) != null) {
result.append(line).append(System.getProperty("line.separator"));// "\n"
}
logger.error("[访问错误]:{} {} {}", connection.getResponseCode(), methodUrl, result.toString());
return null;
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
connection.disconnect();
}
return null;
}
public static JSONObject updateCredentials(String hostUrl, String token, JSONObject deviceJson, JSONObject getCredentialsJson, String username, String password) {
String uuid = UUID.randomUUID().toString();
String body = "{
\n" +
"\t\"id\": {
\n" +
"\t\t\"id\": \"" + getCredentialsJson.getJSONObject("id").getString("id") + "\"\n" +
"\t},\n" +
"\t\"createdTime\": 1666667853734,\n" +
"\t\"deviceId\": {
\n" +
"\t\t\"entityType\": \"DEVICE\",\n" +
"\t\t\"id\": \"" + deviceJson.getJSONObject("id").getString("id") + "\"\n" +
"\t},\n" +
"\t\"credentialsType\": \"MQTT_BASIC\",\n" +
"\t\"credentialsId\": null,\n" +
"\t\"credentialsValue\": \"{
\\\"clientId\\\":\\\"" + uuid + "\\\",\\\"userName\\\":\\\"" + username + "\\\",\\\"password\\\":\\\"" + password + "\\\"}\"\n" +
"}\n";
String updateCredentials = httpURLPOSTCase("http://" + hostUrl + "/api/device/credentials", body, token);
logger.debug("[返回数据]：" + updateCredentials);
if (updateCredentials == null || updateCredentials == "") {
logger.error("失败！");
return null;
}
JSONObject credentialsJson = JSONObject.parseObject(updateCredentials);
if (!credentialsJson.containsKey("id")) {
logger.error("更新凭据失败！");
return null;
}
logger.info("更新凭据凭据成功！");
logger.debug("uuid={}",uuid);
credentialsJson.put("uuid", uuid);
return credentialsJson;
}
public static JSONObject getCredentials(String hostUrl, String token, JSONObject deviceJson, String deviceProfileId) {
String body = "{
\n" +
" \"id\": {
\n" +
" \"entityType\": \"DEVICE\",\n" +
" \"id\": \"" + deviceJson.getJSONObject("id").getString("id") + "\"\n" +
" },\n" +
" \"createdTime\": 1666669039384,\n" +
" \"additionalInfo\": {
\n" +
" \"gateway\": false,\n" +
" \"overwriteActivityTime\": false,\n" +
" \"description\": \"\"\n" +
" },\n" +
" \"tenantId\": {
\n" +
" \"entityType\": \"TENANT\",\n" +
" \"id\": \"" + deviceJson.getJSONObject("tenantId").getString("id") + "\"\n" +
" },\n" +
" \"customerId\": {
\n" +
" \"entityType\": \"CUSTOMER\",\n" +
" \"id\": \"" + deviceJson.getJSONObject("customerId").getString("id") + "\"\n" +
" },\n" +
" \"name\": \"" + deviceJson.getString("name") + "\",\n" +
" \"type\": \"" + deviceJson.getString("type") + "\",\n" +
" \"label\": \"" + deviceJson.getString("label") + "\",\n" +
" \"deviceProfileId\": {
\n" +
" \"entityType\": \"DEVICE_PROFILE\",\n" +
" \"id\": \"" + deviceProfileId + "\"\n" +
" },\n" +
" \"deviceData\": {
\n" +
" \"configuration\": {
\n" +
" \"type\": \"DEFAULT\"\n" +
" },\n" +
" \"transportConfiguration\": {
\n" +
" \"type\": \"DEFAULT\"\n" +
" }\n" +
" },\n" +
" \"firmwareId\": null,\n" +
" \"softwareId\": null,\n" +
" \"externalId\": null,\n" +
" \"customerTitle\": null,\n" +
" \"customerIsPublic\": false,\n" +
" \"deviceProfileName\": \"default\"\n" +
"}";
String deviceId = deviceJson.getJSONObject("id").getString("id");
String credentials = null;
try {
credentials = sendJsonByGetReq("http://" + hostUrl + "/api/device/" + deviceId + "/credentials", body, token);
} catch (Exception e) {
throw new RuntimeException(e);
}
logger.debug("[返回数据]：" + credentials);
if (credentials == null || credentials == "") {
logger.error("失败！");
return null;
}
JSONObject credentialsJson = JSONObject.parseObject(credentials);
if (!credentialsJson.containsKey("id")) {
logger.error("获取凭据失败！");
return null;
}
logger.info("获取凭据成功！");
return credentialsJson;
}
public static JSONObject getLoginJsonObject(String hostUrl) {
JSONObject jsonObject = new JSONObject(true);
jsonObject.put("username", "[email protected]");
jsonObject.put("password", "123456");
String result = httpURLPOSTCase("http://" + hostUrl + "/api/auth/login", jsonObject.toJSONString(), null);
logger.debug("[返回数据]：" + result);
if (result == null || result == "") {
logger.error("失败！");
return null;
}
JSONObject resultJson = JSONObject.parseObject(result);
if (!resultJson.containsKey("token")) {
logger.error("登录失败！");
return null;
}
logger.info("登录成功！");
return resultJson;
}
public static JSONObject createDeviceJsonObject(String hostUrl, String deviceProfileId, String token, String prefix) {
String body = "{
\n" +
"\t\"name\": \"" + prefix + System.currentTimeMillis() + "\",\n" +
"\t \"type\": \"interface\",\n" +
"\t\"label\": \"interface\",\n" +
"\t\"deviceProfileId\": {
\n" +
"\t\t\"entityType\": \"DEVICE_PROFILE\",\n" +
"\t\t\"id\": \"" + deviceProfileId + "\"\n" +
"\t},\n" +
"\t\"additionalInfo\": {
\n" +
"\t\t\"gateway\": false,\n" +
"\t\t\"overwriteActivityTime\": false,\n" +
"\t\t\"description\": \"\"\n" +
"\t},\n" +
"\t\"customerId\": null\n" +
"}";
String resultDevice = httpURLPOSTCase("http://" + hostUrl + "/api/device", body, token);
logger.debug("[返回数据]：" + resultDevice);
if (resultDevice == null || resultDevice == "") {
logger.error("失败！");
return null;
}
JSONObject resultDeviceJson = JSONObject.parseObject(resultDevice);
if (!resultDeviceJson.containsKey("id")) {
logger.error("创建设备失败！");
return null;
}
logger.info("创建设备成功！");
return resultDeviceJson;
}
}
生成设备后删除设备
package com.example.demo.http;
import com.alibaba.fastjson.JSONObject;
import java.io.*;
/**
* @author Xiaoxiangdong
* @date 2022/10/28 15:25
*/
public class DeleteDemo {
private static String host = "192.168.1.51";
private static int port = 5300;
private static String path = "d://record.log";
private static String deviceProfileId = "0bf257f0-5511-11ed-b43a-e174163c10d7";
private static String prefix = "xxd_";
private static String username = "abc1124";
private static String password = "abc1124";
public static void main(String[] args) {
File file = new File(path);
BufferedReader reader = null;
try {
reader = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
}
String hostUrl = host + ":" + port;
//第一步获取token
JSONObject resultJson = Http.getLoginJsonObject(hostUrl);
if (resultJson == null) return;
String token = resultJson.getString("token");
String line = null;
int i = 0;
while (true) {
try {
if (!((line = reader.readLine()) != null)) break;
} catch (IOException e) {
throw new RuntimeException(e);
}
i++;
if (line.length() < 37) {
continue;
}
String id = line.split(",")[0];
Http.httpURLDELETECase("http://" + hostUrl + "/api/device/"+id,token);
}
}
}
任务类
package com.example.demo.http;
import com.alibaba.fastjson.JSONObject;
import com.example.demo.mqtt.MqConfig;
import com.example.demo.mqtt.MqUtils;
import org.eclipse.paho.client.mqttv3.MqttClient;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.UUID;
public class ThreadDemo implements Runnable {
private MqttClient mqttClient;
private int i;
private String uuid;
private String username;
private String password;
public void setI(int i) {
this.i = i;
}
private static final Logger logger = LoggerFactory.getLogger(ThreadDemo.class);
public ThreadDemo(MqttClient mqttClient, int i, String uuid, String username, String password) {
this.mqttClient = mqttClient;
this.i = i;
this.uuid = uuid;
this.username = username;
this.password = password;
}
@Override
public void run() {
try {
JSONObject jsonObject=new JSONObject();
jsonObject.put("record","aaaaaa" + UUID.randomUUID() + "bbbbbbbbbbbbbbbbbb");
publish(jsonObject.toJSONString(), "v1/devices/me/telemetry");
} catch (MqttException e) {
throw new RuntimeException(e);
}
}
public void publish(String msg, String topic) throws MqttException {
if (mqttClient != null) {
if (mqttClient.isConnected()) {
logger.info("发送消息-{}：{}", i, msg);
MqttMessage message = new MqttMessage(msg.getBytes());
message.setQos(MqConfig.qos);
//重新连接MQTT服务时，不需要接收该主题最新消息，设置retained为false
//重新连接MQTT服务时，需要接收该主题最新消息，设置retained为true;
message.setRetained(true);
mqttClient.publish(topic, message);
} else {
logger.error("设备{}断开连接", i);
}
}
}
}
get请求带body
package com.example.demo.http;
import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;
import java.net.URI;
/**
* 定义一个带body的GET请求 继承 HttpEntityEnclosingRequestBase
* @date 2022/10/28 10:19
*/
public class HttpGetWithEntity extends HttpEntityEnclosingRequestBase {
private final static String METHOD_NAME = "GET";
@Override
public String getMethod() {
return METHOD_NAME;
}
public HttpGetWithEntity() {
super();
}
public HttpGetWithEntity(final URI uri) {
super();
setURI(uri);
}
HttpGetWithEntity(final String uri) {
super();
setURI(URI.create(uri));
}
}