SpringBoot-integration 使用MQTT对接大疆机场+无人机 完整示例

置顶 已于 2025-06-13 10:18:15 修改
阅读量259 收藏
点赞数 2
CC 4.0 BY-SA版权
分类专栏： 大疆机场+无人机 文章标签： spring boot 后端 java
于 2025-06-13 09:26:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/now19930616/article/details/148625191

参考大疆上云API - 大疆上云api是二级路由方案，我这做开发直接使用一级路由满足当前系统要求

mqttconfig  定义mqtt连接工厂，消息处理通道和路由定义，只监听需要的topic


import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;
import com.central.common.utils.CustomThreadPoolTaskExecutor;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.annotation.ServiceActivator;
import org.springframework.integration.channel.DirectChannel;
import org.springframework.integration.channel.ExecutorChannel;
import org.springframework.integration.dsl.IntegrationFlow;
import org.springframework.integration.dsl.IntegrationFlows;
import org.springframework.integration.mqtt.core.DefaultMqttPahoClientFactory;
import org.springframework.integration.mqtt.core.MqttPahoClientFactory;
import org.springframework.integration.mqtt.inbound.MqttPahoMessageDrivenChannelAdapter;
import org.springframework.integration.mqtt.outbound.MqttPahoMessageHandler;
import org.springframework.integration.mqtt.support.DefaultPahoMessageConverter;
import org.springframework.integration.mqtt.support.MqttHeaders;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.MessageHandler;

import java.nio.charset.StandardCharsets;
import java.util.UUID;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

@Configuration
@Slf4j
public class MqttConfig {

    @Value("${mqtt.broker-url}")
    private String brokerUrl;

    @Value("${mqtt.client-id}")
    private String clientId;

    @Value("${mqtt.username}")
    private String username;

    @Value("${mqtt.password}")
    private String password;

    @Value("${mqtt.keep-alive-interval}")
    private int keepAliveInterval;

    @Value("${mqtt.default-topic}")
    private String defaultTopic;


    // 显式定义所有通道
    @Bean
    public MessageChannel osdChannel() {
        return new DirectChannel();
    }

    @Bean
    public MessageChannel stateChannel() {
        return new DirectChannel();
    }

    @Bean
    public MessageChannel eventsChannel() {
        return new DirectChannel();
    }

    @Bean
    public MessageChannel defaultChannel() {
        return new DirectChannel();
    }

    /**
     * 接收reply消息
     */
    @Bean
    public MessageChannel replyChannel() {
        return new DirectChannel();
    }

    /**
     * 连接工厂
     */
    @Bean
    public MqttPahoClientFactory mqttClientFactory() {
        DefaultMqttPahoClientFactory factory = new DefaultMqttPahoClientFactory();
        MqttConnectOptions options = new MqttConnectOptions();
        options.setServerURIs(new String[]{brokerUrl});
        options.setUserName(username);
        options.setPassword(password.toCharArray());
        options.setConnectionTimeout(10);
        options.setKeepAliveInterval(keepAliveInterval);
        options.setAutomaticReconnect(true);
        factory.setConnectionOptions(options);
        return factory;
    }

    /**
     * 消息路由
     */
    @Bean
    public MessageChannel mqttRouterInputChannel() {
        return new ExecutorChannel(mqttRouterExecutor());
    }

    /**
     * 多线程处理器
     */
    @Bean
    public Executor mqttRouterExecutor() {
        CustomThreadPoolTaskExecutor executor = new CustomThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setDaemon(true);
        executor.setAllowCoreThreadTimeOut(false);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("mqtt-router-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }

    /**
     * 发送处理器
     */
    @Bean
    @ServiceActivator(inputChannel = IMqttMessageGateway.SEND_CHANNEL)
    public MessageHandler mqttOutbound(MqttPahoClientFactory mqttPahoClientFactory) {
        MqttPahoMessageHandler messageHandler = new MqttPahoMessageHandler(
                UUID.randomUUID().toString(), mqttPahoClientFactory);
        DefaultPahoMessageConverter converter = new DefaultPahoMessageConverter();
        // use byte types uniformly
        converter.setPayloadAsBytes(true);
        messageHandler.setAsync(true);
        messageHandler.setDefaultQos(0);
        messageHandler.setConverter(converter);
        return messageHandler;
    }

    /**
     * 接收消息适配器
     */
    @Bean
    public MqttPahoMessageDrivenChannelAdapter mqttInbound(MqttPahoClientFactory mqttPahoClientFactory) {
        // 代理接收指定的topic消息 根据路径匹配
        MqttPahoMessageDrivenChannelAdapter adapter = new MqttPahoMessageDrivenChannelAdapter(
                "inboundClient-" + UUID.randomUUID().toString(), mqttPahoClientFactory);
        String[] split = defaultTopic.split(",");
        for (String s : split) {
            adapter.addTopic(s, 1);
        }
        DefaultPahoMessageConverter converter = new DefaultPahoMessageConverter();
        // use byte types uniformly  使用字节类型处理消息
        converter.setPayloadAsBytes(true);
        // 将接收到的 MQTT 消息转换为 Spring Integration 消息
        adapter.setConverter(converter);
        // 设置消息的服务质量为 1，表示消息至少会被传递一次。
        adapter.setQos(1);
        // 将接收到的消息发送到 inboundChannel 消息通道中。
        adapter.setOutputChannel(mqttRouterInputChannel());
        return adapter;
    }

    @Bean
    public IntegrationFlow routerFlow() {
        return IntegrationFlows.from(mqttRouterInputChannel())
                .route(Message.class, message -> {
                    String topic = message.getHeaders().get(MqttHeaders.RECEIVED_TOPIC, String.class);
                    // 使用正则匹配动态主题   此处return返回的结果 在下方 channelMapping 第一个参数进行匹配使用
                    if (topic.matches("thing/product/.+/osd")) {
                        return "osdChannel";
                    } else if (topic.matches("thing/product/.+/events")) {
                        return "eventsChannel";
                    } else if (topic.matches("thing/product/.+/state")) {
                        return "stateChannel";
                    }
                    return "defaultChannel";
                }, mapping -> {
                    mapping.channelMapping("osdChannel", "osdChannel");
                    mapping.channelMapping("eventsChannel", "eventsChannel");
                    mapping.channelMapping("stateChannel", "stateChannel");
                    mapping.defaultOutputChannel("defaultChannel");
                })
                .get();
    }

    /**
     * 回复消息的入站适配器
     */
    @Bean
    public MqttPahoMessageDrivenChannelAdapter mqttReplyInbound(MqttPahoClientFactory mqttPahoClientFactory) {
        // 这里使用通配符订阅所有可能的回复主题
        MqttPahoMessageDrivenChannelAdapter adapter = new MqttPahoMessageDrivenChannelAdapter(
                "replyClient-" + UUID.randomUUID().toString(), mqttPahoClientFactory);
        adapter.addTopic("thing/product/+/services_reply", 1); // 订阅所有主题，实际应用中应该更精确

        DefaultPahoMessageConverter converter = new DefaultPahoMessageConverter();
        converter.setPayloadAsBytes(true);
        adapter.setConverter(converter);
        adapter.setQos(1);
        adapter.setOutputChannel(replyChannel());
        return adapter;
    }

    @Bean
    @ServiceActivator(inputChannel = IMqttMessageGateway.REPLY_CHANNEL)
    public MessageHandler replyMessageHandler() {
        return message -> {
            try {
                byte[] payload = (byte[]) message.getPayload();
                JSONObject jo = JSONObject.parseObject(new String(payload, StandardCharsets.UTF_8));
                String tid = jo.getString("tid");

                if (StrUtil.isNotBlank(tid)) {
                    // 关键修改：始终创建通道（true）
                    Chan.getInstance(tid, true).put(tid, jo);

                    log.debug("Processed MQTT reply, tid={}, topic={}, data={}",
                            tid,
                            message.getHeaders().get(MqttHeaders.RECEIVED_TOPIC),
                            jo.toJSONString());
                }
            } catch (Exception e) {
                log.error("MQTT reply processing failed. Payload: {}",
                        new String((byte[]) message.getPayload()), e);
            }
        };
    }
}

发送消息网关


import org.springframework.integration.annotation.MessagingGateway;
import org.springframework.integration.mqtt.support.MqttHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

@Component
@MessagingGateway(defaultRequestChannel = IMqttMessageGateway.SEND_CHANNEL)
public interface IMqttMessageGateway {

    /**
     * 回复topic
     */
    String REPLY_TOPIC = "REPLY_TOPIC";

    String SEND_CHANNEL = "outbound";

    String REPLY_CHANNEL = "replyChannel";

    String REPLY_TIMEOUT_MS = "5000";

    /**
     * Publish a message to a specific topic.
     *
     * @param topic   target
     * @param payload message
     */
    void publish(@Header(MqttHeaders.TOPIC) String topic, byte[] payload);

    /**
     * Use a specific qos to push messages to a specific topic.
     *
     * @param topic   target
     * @param payload message
     * @param qos     qos
     */
    void publish(@Header(MqttHeaders.TOPIC) String topic, byte[] payload, @Header(MqttHeaders.QOS) int qos);


}

处理消息 handler 自定义实现逻辑，可以选择写入redis或者入库，未后续业务做前置数据准备


import cn.geoyt.business.common.PatrolConstant;
import cn.geoyt.business.mapper.DeviceOsdInfoMapper;
import cn.geoyt.business.mapper.ReturnHomeInfoMapper;
import cn.geoyt.business.model.entity.DeviceOsdInfo;
import cn.geoyt.business.model.entity.ReturnHomeInfo;
import cn.geoyt.business.utils.helper.PSDKUtil;
import cn.geoyt.business.utils.invoke.CloudApiInvoke;
import cn.hutool.core.util.IdUtil;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.util.TypeUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.annotation.ServiceActivator;
import org.springframework.integration.mqtt.support.MqttHeaders;
import org.springframework.messaging.MessageHandler;

import java.nio.charset.StandardCharsets;
import java.util.Date;
import java.util.LinkedHashMap;

@Configuration
@Slf4j
public class ChannelHandlerConfig {

    
    @Autowired
    private XXXMapper xxxmapper;

    @Autowired
    private Redistemplate redistemplate;

    @Bean
    @ServiceActivator(inputChannel = "stateChannel")
    public MessageHandler stateMessageHandler() {
        return message -> {
            String topic = message.getHeaders().get("mqtt_receivedTopic").toString();
            // 截取topic  thing/product/+/osd
            String sb = topic.substring("thing/product/".length());
            String sn = sb.substring(0, sb.length() - "/state".length());
            byte[] bytes = (byte[]) message.getPayload();
            String stateJson = new String(bytes, StandardCharsets.UTF_8);
            JSONObject jo = JSONObject.parseObject(stateJson);
            boolean dataFlag = jo.containsKey("data");
            // 处理业务逻辑
        };
    }

    @Bean
    @ServiceActivator(inputChannel = "osdChannel")
    public MessageHandler handler() {
        return message -> {
            String topic = message.getHeaders().get("mqtt_receivedTopic").toString();
            // 截取topic  thing/product/+/osd
            String sb = topic.substring("thing/product/".length());
            String sn = sb.substring(0, sb.length() - "/osd".length());
            byte[] bytes = (byte[]) message.getPayload();
//            System.out.println("Received message from topic: " + topic + ", payload: " + new String(bytes, StandardCharsets.UTF_8));
            
        };
    }

    // Events通道处理器
    @Bean
    @ServiceActivator(inputChannel = "eventsChannel")
    public MessageHandler eventsHandler() {
        return message -> {
            String topic = message.getHeaders().get(MqttHeaders.RECEIVED_TOPIC, String.class);
            // 截取topic  thing/product/+/osd
            String sb = topic.substring("thing/product/".length());
            String sn = sb.substring(0, sb.length() - "/events".length());
            byte[] bytes = (byte[]) message.getPayload();
            String json = new String(bytes, StandardCharsets.UTF_8);
            JSONObject jo = JSONObject.parseObject(json);
//            System.out.println("Received message from topic: " + topic + ", payload: " + new String(bytes, StandardCharsets.UTF_8));
        };
    }

    @Bean
    @ServiceActivator(inputChannel = "defaultChannel")
    public MessageHandler defaultHandler() {
        return message -> {
            System.out.println("Received message on default channel: " + message);
        };
    }
}

处理发送消息接收回复消息监听类


import com.alibaba.fastjson.JSONObject;

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.LockSupport;

public class Chan {
    private static final ConcurrentHashMap<String, Chan> CHANNEL_MAP = new ConcurrentHashMap<>();
    private static final ScheduledExecutorService CLEANER = Executors.newSingleThreadScheduledExecutor();

    private final AtomicReference<JSONObject> data = new AtomicReference<>();
    private final AtomicReference<Thread> waitingThread = new AtomicReference<>();
    private volatile ScheduledFuture<?> cleanupTask;

    private Chan() {
        scheduleCleanup(30_000);
    }

    public static Chan getInstance(String channelId, boolean createIfAbsent) {
        return createIfAbsent ? 
               CHANNEL_MAP.computeIfAbsent(channelId, k -> new Chan()) : 
               CHANNEL_MAP.get(channelId);
    }

    public JSONObject get(String channelId, long timeoutMillis) {
        Chan chan = CHANNEL_MAP.get(channelId);
        if (chan == null) return null;

        if (!chan.waitingThread.compareAndSet(null, Thread.currentThread())) {
            return null; // 已经有线程在等待
        }
        chan.cancelCleanup();

        try {
            long deadline = System.nanoTime() + TimeUnit.MILLISECONDS.toNanos(timeoutMillis);
            while (chan.data.get() == null) {
                if (System.nanoTime() >= deadline) {
                    chan.waitingThread.compareAndSet(Thread.currentThread(), null);
                    return null;
                }
                LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(10)); // 更高效的等待
            }

            JSONObject result = chan.data.get();
            CHANNEL_MAP.remove(channelId);
            return result;
        } finally {
            chan.waitingThread.compareAndSet(Thread.currentThread(), null);
        }
    }

    public void put(String channelId, JSONObject responseData) {
        Chan chan = CHANNEL_MAP.computeIfAbsent(channelId, k -> new Chan());

        chan.data.set(responseData);
        chan.cancelCleanup();

        Thread waiter = chan.waitingThread.getAndSet(null);
        if (waiter != null) {
            LockSupport.unpark(waiter);
        } else {
            chan.scheduleCleanup(10_000);
        }
    }

    private void scheduleCleanup(long delayMillis) {
        this.cleanupTask = CLEANER.schedule(() -> {
            if (waitingThread.get() == null && data.get() == null) {
                CHANNEL_MAP.values().removeIf(c -> c == this);
            }
        }, delayMillis, TimeUnit.MILLISECONDS);
    }

    private void cancelCleanup() {
        ScheduledFuture<?> task = this.cleanupTask;
        if (task != null) {
            task.cancel(false);
            cleanupTask = null;
        }
    }

    public static void shutdown() {
        CLEANER.shutdownNow();
        CHANNEL_MAP.clear();
    }
}

// 发送和回复消息使用示例  在MqttConfig配置类中有  replyMessageHandler() 方法使用到了


import cn.geoyt.business.config.mqtt.Chan;
import cn.geoyt.business.config.mqtt.IMqttMessageGateway;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.util.TypeUtils;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.json.JsonMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Map;

/**
 * @author sean
 * @version 1.7
 * @date 2023/5/23
 */
public class Common {

    private static final JsonMapper.Builder MAPPER_BUILDER = JsonMapper.builder();

    static {
        JavaTimeModule timeModule = new JavaTimeModule();
        timeModule.addDeserializer(LocalDateTime.class,
                new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        timeModule.addSerializer(LocalDateTime.class,
                new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));

        MAPPER_BUILDER.propertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE)
                .serializationInclusion(JsonInclude.Include.NON_ABSENT)
                .disable(MapperFeature.IGNORE_DUPLICATE_MODULE_REGISTRATIONS)
                .addModule(timeModule)
                .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
                .configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false)
                .configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true)
                .configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, true)
                .configure(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT, true);
    }


    public static ObjectMapper getObjectMapper() {
        return MAPPER_BUILDER.build();
    }

    public static JSONObject publish(IMqttMessageGateway mqttMessageGateway, String topic, Map<String, Object> map) {
        try {
            byte[] payload = Common.getObjectMapper().writeValueAsBytes(map);
            mqttMessageGateway.publish(topic, payload, 1);
            String tid = TypeUtils.castToString(map.get("tid"));
            // 5秒超时
            return Chan.getInstance(tid, true).get(tid, 5000);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
    }

    public static String convertSnake(String key) {
        StringBuilder sb = new StringBuilder();
        boolean isChange = false;
        for (char c : key.toCharArray()) {
            if (c == '_') {
                isChange = true;
                continue;
            }
            if (isChange) {
                sb.append((char) (c - 32));
                isChange = false;
                continue;
            }
            sb.append(c);
        }
        return sb.toString();
    }
}




// Controller

import cn.geoyt.business.config.mqtt.IMqttMessageGateway;
import cn.geoyt.business.utils.Common;
import cn.hutool.core.util.IdUtil;
import com.alibaba.fastjson.JSONObject;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;

@RestController
@RequestMapping("/demo")
public class DemoController {

    @Resource
    private IMqttMessageGateway mqttMessageGateway;

    @PostMapping("/test")
    public String test(@RequestParam("sn") String dockSn) {

        Map<String, Object> map = new HashMap<>();
        String uuid = IdUtil.simpleUUID();
        map.put("bid", uuid);
        map.put("method", "psdk_input_box_text_set");
        map.put("tid", uuid);
        map.put("timestamp", System.currentTimeMillis());
        HashMap<String, Object> data = new HashMap<>();
        data.put("psdk_index", 2);
        data.put("value", "111111");
        map.put("data", data);

        JSONObject result = Common.publish(mqttMessageGateway, "thing/product/" + dockSn + "/services", map);
        return result == null ? "获取结果失败" : result.toJSONString();
    }
}
大疆机场开发和遇到的问题一
q_q王的博客
12-28 4468
大疆机场开发和遇到的问题
零基础小白本地部署大疆上云api（个人记录供参考）
aloha
05-21 3819
3.下载好emqx,redis等（这些必须要求是windows版本的）进入emqx安装目录的bin文件下执行下面指令（必须的管理员运行终端）主要修改（appId,appKey,appLicense这些）最后生成如下界面，再把内容替换到config.ts就行。1.保证电脑又node.js环境，可以正常使用npm。最后我们可以到浏览器看到界面可以成功登录，运行成功。进行如下操作（需要注意申请的是web端的）1.修改confit.ts文件（如下图）运行的host都修改为localhost。
上云API二开实现三维可视化控制中心
yychen_java的博客
05-13 1042
上云API二开实现三维可视化控制中心
简述大疆无人机对接
Naylor的博客
04-22 2279
获取无人机飞行过程中的实时画面，用来直播获取飞机飞行数据（如实时高度，实时经纬度，实时飞机姿态等）获取飞机静态数据（如飞机基本信息、飞行记录、电池信息等）操控飞机飞行（如起飞、降落，改变高度，操作操控杆，设定航飞任务，拍照，录视频等）媒体管理（下载飞机记载内存卡中的文件等）其它业务功能开发（如态势感知，固件升级，多飞机集中管控等）至于应用场景，那就太广泛了，如消防、测绘、林业等等，可以赋能各行各业。应用开发：MobileSDK，UXSDK，WindowsSDK。
《大疆二次开发》EMQX和MQTT部署
前端技术
05-08 2766
《大疆二次开发》EMQX和MQTT部署
大疆上云api 源码解析（上下线功能）
qq617410272的博客
04-18 2845
设备向云平台推送消息，topic为sys/product/{gateway_sn}/status 进行设备上线。3.进行上线逻辑后，最终进入ChannelName.OUTBOUND_STATUS中。当pilot2与云平台建立mqtt连接后，进行设备绑定后。
上云API操纵大疆无人机-Java二次开发
m0_73978383的博客
03-21 1776
上云API操纵大疆无人机
无人机飞行数据java版本api大疆无人机SpringBoot
热门推荐
树
03-09 1万+
一、项目概述 平台功能包括：无人机地图轨迹、无人机数据实时回传、无人机路径规划飞行、无人机历史数据分析、无人机一键起飞以及降落、无人机视频回放、无人机大屏等主要功能，另外含管理平台基础的OA功能。 二、项目运行 使用技术：SpringBoot、SpringDataJpa、Freemaker、Redis、WebSocket等组成，基于B/S模式，使用Maven进行项目管理。 三、功能介绍 的 ...
大疆无人机二次开发调试准备
是夜色太荒芜的专栏
02-09 1348
大疆无人机开发调试环境准备
通过mqtt通信远程控制大疆无人机
silent702366的博客
09-13 2249
通过mqtt通信远程控制大疆无人机
无人机纯前端飞控实践：基于MQTT的Web端控制方案
最新发布
人和代码有一个能跑就行
06-13 319
本文介绍了基于纯前端技术实现大疆无人机飞控的方案。通过MQTT over WebSocket协议与无人机网关通信，采用Vue.js/React框架构建控制界面，使用Paho.js/MQTT.js实现MQTT协议，并整合Mapbox等地图服务进行航线规划。文章详细阐述了开发环境准备、核心代码实现（包括MQTT连接管理、无人机指令封装和状态监控），以及Web端安全连接、航线规划算法等关键技术。此外还提出了消息压缩、WebWorker计算等性能优化方案，并展望了WebRTC视频流、WebAssembly加速等未来
基于netty+mqtt3.1.1+springboot+jdk8 实现的 mqtt 服务端跟客户端.zip
04-08
这是一个基于Java技术栈，具体是Netty、MQTT 3.1.1协议、Spring Boot框架和JDK 8实现的MQTT服务器和客户端的项目。这个项目对于学习和实践物联网(IoT)通信以及Java后端开发具有很高的价值，尤其适合作为毕业设计的...
基于springboot-mqtt的温度、湿度、六氟化硫浓度实时监控系统，本科毕业设计项目
06-20
基于springboot-mqtt的温度、湿度、六氟化硫浓度实时监控系统，本科毕业设计项目，代码无需修改可直接运行。 基于springboot-mqtt的温度、湿度、六氟化硫浓度实时监控系统，本科毕业设计项目，代码无需修改可直接...
SpringBoot + Vue使用MQTT实现智慧停车系统.zip
04-22
基于 SpringBoot + Vue 的智能停车场项目。 背景 在现代城市中，交通拥堵和停车难题一直是令人头疼的难题。为了解决这一问题，智慧停车系统应运而生。智慧停车系统利用物联网技术和实时数据传输，提供了一种更智能...
SpringBoot_实现_mqtt_客户端_示例代码_mqtt-springboot-demo.zip
09-02
在本压缩包中，包含了一个SpringBoot实现MQTT客户端的示例代码，文件名为“mqtt-springboot-demo-main”。这个示例项目展示了如何将SpringBoot与MQTT客户端集成，以便开发者能够在SpringBoot应用程序中快速实现MQTT...
springboot自动化配置mqtt，整合spring-integration-mqtt，连接多个mqtt，动态订阅主题
qq_20280007的博客
04-01 1万+
springboot自动化配置mqtt，整合spring-integration-mqttmqtt整合配置说明类说明订阅消息发送消息 mqtt整合 starter-integration-mqtt整合了spring-integration-mqtt，只需添加配置，并实现消息订阅接口即可。可以实现订阅多个mqtt。 github源码：https://github.com/aLiang-xyl/int...
前端，大疆上云api，使用Websocket、MQTT连接、订阅,进行航线数据传输
IIIIIAN
08-09 2352
【代码】前端使用Websocket、MQTT连接、订阅,进行航线数据传输。
java对接大疆机场SpringBoot对接大疆机场cloudapi上云api无人机实时数据
树
02-26 1352
6、媒体文件：媒体文件自动回传，可对应拍摄位置、拍摄角度、3d仿真摄影锥、地面投射。8、航线绘制：支持面状航线、航点航线绘制、支持飞行高度自适应计算，支持3d绘制。9、计划管理：支持定时、连续、立即等机制执行航线库任意航线，支持拍摄数据回传。7、航线管理：支持导入其他平台绘制的航线、支持预览、支持查看航线参数。5、直播大屏：支持四分屏、九分屏、十六分屏查看直播，可设置直播预案。1、设备管理：设备可自动注册、手动添加、查看直播，延迟1~2s。3、远程控制：支持远程操控无人机、一键起飞、返航、执行航线等。
新版本大疆上云API指令飞行（drc）模式通讯搭建思路
silent702366的博客
09-23 2751
新版本大疆上云API指令飞行（drc）模式通讯搭建思路
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值