【人工智能应用技术】-基础实战-小程序应用（基于springAI+百度语音技术）智能语音控制-Java部分核心逻辑

Java端与ESP32交互实现核心逻辑

Java端核心定位是「远程指令发送中心」与「执行结果接收中心」，基于Spring Boot框架实现（便于后续扩展前端页面），采用MQTT协议与ESP32通信。

总体交互流通图（先理清全链路）

先通过流程图明确Java端与ESP32、MQTT Broker、受控设备的完整交互链路，核心流程：Java前端请求→Java后端处理→MQTT发布指令→ESP32订阅接收→控制设备→ESP32发布结果→Java后端订阅接收→Java前端展示。

Java端核心交互代码

依赖关系说明：model（数据模型） → config（配置） → mqtt（通信工具） → service（业务逻辑） → controller（接口），后续按此依赖顺序迭代实现代码。

先准备基础依赖（pom.xml），再按「模型→配置→MQTT通信→服务→控制层」的顺序逐步实现，每一步都说明代码作用及与ESP32的交互关联。

ESP32与Java平台交互核心：Java端开发核心

本文核心聚焦Java端与ESP32单片机的交互实现，采用「递进式开发」思路（从基础依赖到完整交互），详细拆解Java端代码逻辑、通信协议约定及全链路交互流程。ESP32单片机部分仅说明与Java交互的核心前提，不展开详细实现细节。

一、交互前提：ESP32端核心约定（简化说明）

Java端与ESP32的交互核心是「统一通信协议+标准化数据格式」，ESP32端需提前完成以下配置，才能与Java端正常通信：

• 通信协议：采用MQTT轻量级协议，ESP32需连接指定MQTT Broker（本文统一使用公共Broker：tcp://broker.emqx.io:1883）；

• 主题约定： - 订阅主题（接收Java指令）：esp32/control/switch - 发布主题（反馈执行结果）：esp32/control/result

• 数据格式：统一使用JSON格式，指令/结果字段需严格对齐（由Java端定义标准，ESP32适配）；

• 核心逻辑：ESP32启动后自动连接WiFi→连接MQTT Broker→订阅指令主题，收到Java指令后解析执行，执行完成后向结果主题发布反馈。

关键：ESP32端只需严格遵循上述「主题+JSON格式」约定，无需关注Java端内部实现；Java端核心任务是按约定发送指令、接收反馈。

二、Java端递进式开发：从基础到完整交互

采用「迭代式递进」开发思路，按「依赖配置→数据模型→核心配置→通信层→业务层→接口层」的顺序逐步实现，每一步都可独立验证，降低开发难度。

迭代1：基础准备——依赖配置（pom.xml）

核心目标：引入Java端实现MQTT通信、JSON序列化及Web接口所需的基础依赖，搭建项目骨架。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.10</version>
        <relativePath/>
    </parent>
    <groupId>com.esp32</groupId>
    <artifactId>esp32-remote-control-java</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>esp32-remote-control-java&lt;/name&gt;

    &lt;dependencies&gt;
        <!-- 1. Spring Boot Web：提供HTTP接口，供前端调用 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency&gt;

        <!-- 2. MQTT客户端核心依赖：Eclipse Paho，实现与ESP32的MQTT通信 -->
        <dependency>
            <groupId>org.eclipse.paho</groupId>
            <artifactId>org.eclipse.paho.client.mqttv3</artifactId>
            <version>1.2.5&lt;/version&gt;
        &lt;/dependency&gt;

        <!-- 3. FastJSON：JSON序列化/反序列化，与ESP32的ArduinoJson格式对齐 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.32&lt;/version&gt;
        &lt;/dependency&gt;

        <!-- 可选：测试依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

说明：核心依赖为「paho-mqttv3」（MQTT通信）和「fastjson」（JSON格式适配），Spring Boot Web用于后续提供前端访问接口，整体依赖轻量化，无冗余。

迭代2：数据模型定义——与ESP32约定JSON格式

核心目标：定义与ESP32完全对齐的Java数据模型（DTO），确保JSON序列化/反序列化无偏差，这是双方交互的基础。

2.1 控制指令DTO（CommandDTO）：Java→ESP32

封装Java端发送给ESP32的控制指令，字段与ESP32解析逻辑严格一致。

package com.esp32.control.model;

import com.alibaba.fastjson.annotation.JSONField;
import lombok.Data;

/**
 * 控制指令DTO：与ESP32约定的JSON格式完全对齐
 * 字段说明：
 * - deviceId：设备标识（如"bedroom_light"卧室灯、"livingroom_fan"客厅风扇）
 * - action：动作指令（"ON"开/"OFF"关）
 * - timestamp：时间戳（防过期指令，单位：毫秒）
 */
@Data // Lombok注解：自动生成getter、setter、toString，简化代码
public class CommandDTO {
    @JSONField(name = "deviceId") // 序列化后JSON字段名，必须与ESP32约定一致
    private String deviceId;

    @JSONField(name = "action")
    private String action;

    @JSONField(name = "timestamp")
    private long timestamp;
}

2.2 执行结果DTO（ResultDTO）：ESP32→Java

封装ESP32执行指令后反馈给Java端的结果，字段与ESP32发布的JSON格式对齐。

package com.esp32.control.model;

import com.alibaba.fastjson.annotation.JSONField;
import lombok.Data;

/**
 * 执行结果DTO：与ESP32发布的JSON格式完全对齐
 * 字段说明：
 * - status：执行状态（"SUCCESS"成功/"ERROR"失败）
 * - message：结果描述（如"卧室灯已打开"）
 * - timestamp：反馈时间戳
 * - deviceId：执行指令的设备标识（便于Java端关联）
 */
@Data
public class ResultDTO {
    @JSONField(name = "status")
    private String status;

    @JSONField(name = "message")
    private String message;

    @JSONField(name = "timestamp")
    private long timestamp;

    @JSONField(name = "deviceId")
    private String deviceId;
}

注意：字段名大小写、拼写必须与ESP32完全一致（如"deviceId"不能写成"deviceid"），否则会导致解析失败。若不使用Lombok，需手动编写getter/setter方法。

迭代3：核心配置——MQTT客户端初始化

核心目标：集中管理MQTT连接参数（Broker地址、主题、端口等），初始化MQTT客户端并注入Spring容器，供后续通信层调用。

3.1 全局配置文件（application.yml）

将MQTT连接参数、服务端口等配置外置，便于后续修改（无需改动代码）。

spring:
  application:
    name: esp32-remote-control-java # 应用名称

# MQTT连接配置：与ESP32的config.h参数严格一致
mqtt:
  broker: tcp://broker.emqx.io:1883 # MQTT Broker地址（公共Broker，无需本地部署）
  clientId: Java_Switch_Control_Client # Java端MQTT客户端ID（唯一即可，区分多客户端）
  username: "" # 公共Broker无需用户名密码，留空
  password: ""
  subTopic: esp32/control/result # 订阅主题：接收ESP32的执行结果
  pubTopic: esp32/control/switch # 发布主题：发送控制指令给ESP32
  qos: 1 # 消息质量（1表示至少送达一次，适合控制场景）
  connectionTimeout: 30 # 连接超时时间（秒）
  keepAliveInterval: 60 # 心跳间隔（秒，确保连接不中断）

# 服务端口（默认8080，可根据需求修改）
server:
  port: 8080

3.2 MQTT客户端配置类（MqttConfig.java）

通过Spring Boot配置类初始化MQTT客户端，自动连接Broker并订阅结果主题。

package com.esp32.control.config;

import com.esp32.control.mqtt.MqttReceiveCallback;
import org.eclipse.paho.client.mqttv3.MqttClient;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * MQTT客户端配置类：初始化MQTT客户端，注入Spring容器
 */
@Configuration // 标识为Spring配置类
public class MqttConfig {
    // 从application.yml中读取MQTT配置参数（@Value自动注入）
    @Value("${mqtt.broker}")
    private String broker;

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

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

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

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

    @Value("${mqtt.qos}")
    private int qos;

    @Value("${mqtt.connectionTimeout}")
    private int connectionTimeout;

    @Value("${mqtt.keepAliveInterval}")
    private int keepAliveInterval;

    /**
     * 初始化MQTT连接选项（连接参数配置）
     */
    @Bean // 注入Spring容器，供后续创建MQTT客户端使用
    public MqttConnectOptions mqttConnectOptions() {
        MqttConnectOptions options = new MqttConnectOptions();
        options.setBrokerUrl(broker); // 设置Broker地址
        options.setClientId(clientId); // 设置客户端ID
        options.setUserName(username); // 用户名（公共Broker留空）
        options.setPassword(password.toCharArray()); // 密码（公共Broker留空）
        options.setCleanSession(false); // 不清除会话：重新连接后可接收离线消息
        options.setConnectionTimeout(connectionTimeout); // 连接超时时间
        options.setKeepAliveInterval(keepAliveInterval); // 心跳间隔：确保连接活跃
        return options;
    }

    /**
     * 初始化MQTT客户端：连接Broker并订阅结果主题
     */
    @Bean
    public MqttClient mqttClient(MqttConnectOptions mqttConnectOptions, MqttReceiveCallback mqttReceiveCallback) throws MqttException {
        // 采用内存持久化（避免写本地文件，适合简单控制场景）
        MqttClient mqttClient = new MqttClient(broker, clientId, new MemoryPersistence());
        // 设置消息接收回调：处理ESP32发送的执行结果
        mqttClient.setCallback(mqttReceiveCallback);
        // 连接MQTT Broker
        mqttClient.connect(mqttConnectOptions);
        // 连接成功后，订阅ESP32的结果主题
        mqttClient.subscribe(subTopic, qos);
        System.out.println("MQTT客户端初始化成功，已订阅结果主题：" + subTopic);
        return mqttClient;
    }
}

说明：配置类通过「@Value」自动读取application.yml中的参数，避免硬编码；「@Bean」将MQTT客户端注入Spring容器，后续通信层可直接注入使用，无需重复创建。

迭代4：MQTT通信层实现——核心交互逻辑

核心目标：封装MQTT消息的「发送」（Java→ESP32）和「接收」（ESP32→Java）逻辑，这是Java端与ESP32交互的核心层。

4.1 消息接收回调（MqttReceiveCallback.java）

当ESP32向结果主题发布执行结果时，自动触发此回调，处理结果数据（如打印日志、存入数据库、推送给前端等）。

package com.esp32.control.mqtt;

import com.alibaba.fastjson.JSON;
import com.esp32.control.model.ResultDTO;
import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
import org.eclipse.paho.client.mqttv3.MqttCallback;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.springframework.stereotype.Component;

/**
 * MQTT消息接收回调：专门处理ESP32发送的执行结果
 */
@Component // 标识为Spring组件，供MqttConfig注入
public class MqttReceiveCallback implements MqttCallback {
    /**
     * 连接丢失时触发（可扩展重连逻辑）
     */
    @Override
    public void connectionLost(Throwable cause) {
        System.out.println("MQTT连接丢失，原因：" + cause.getMessage());
        // 实际项目可扩展：自动重连逻辑（调用mqttClient.reconnect()）
    }

    /**
     * 收到ESP32的结果时触发（核心处理方法）
     */
    @Override
    public void messageArrived(String topic, MqttMessage message) throws Exception {
        System.out.println("\n===== 收到ESP32执行结果 =====");
        System.out.println("主题：" + topic);
        System.out.println("原始消息：" + new String(message.getPayload()));

        // 1. JSON反序列化：将ESP32发送的JSON字符串转为ResultDTO
        ResultDTO resultDTO = JSON.parseObject(new String(message.getPayload()), ResultDTO.class);

        // 2. 结果处理（可按需扩展）
        System.out.println("执行状态：" + resultDTO.getStatus());
        System.out.println("结果描述：" + resultDTO.getMessage());
        System.out.println("设备ID：" + resultDTO.getDeviceId());
        System.out.println("==========================\n");

        // 扩展方向：
        // - 存入数据库：记录设备控制日志
        // - 推送给前端：通过WebSocket实时展示结果
        // - 异常告警：若status为ERROR，触发邮件/短信告警
    }

    /**
     * 指令发送完成时触发（确认指令是否成功发送）
     */
    @Override
    public void deliveryComplete(IMqttDeliveryToken token) {
        try {
            if (token.isComplete()) {
                System.out.println("指令发送成功，消息ID：" + token.getMessageId());
            }
        } catch (Exception e) {
            System.out.println("指令发送状态确认失败：" + e.getMessage());
        }
    }
}

4.2 MQTT工具类（MqttClientUtil.java）

封装控制指令的发送逻辑，供后续业务层调用，简化代码冗余。

package com.esp32.control.mqtt;

import com.alibaba.fastjson.JSON;
import com.esp32.control.model.CommandDTO;
import org.eclipse.paho.client.mqttv3.MqttClient;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * MQTT客户端工具类：封装向ESP32发送控制指令的逻辑
 */
@Component
public class MqttClientUtil {
    // 注入application.yml配置的发布主题（发送指令给ESP32）
    @Value("${mqtt.pubTopic}")
    private String pubTopic;

    // 注入消息质量
    @Value("${mqtt.qos}")
    private int qos;

    // 注入Spring容器中的MQTT客户端（由MqttConfig初始化）
    @Autowired
    private MqttClient mqttClient;

    /**
     * 发送控制指令给ESP32
     * @param commandDTO 控制指令DTO（封装设备ID、动作、时间戳）
     * @throws MqttException MQTT发送异常
     */
    public void sendControlCommand(CommandDTO commandDTO) throws MqttException {
        // 1. 校验MQTT连接状态：断开则重新连接
        if (!mqttClient.isConnected()) {
            mqttClient.reconnect();
            System.out.println("MQTT连接已重连");
        }

        // 2. JSON序列化：将CommandDTO转为JSON字符串（与ESP32格式对齐）
        String commandJson = JSON.toJSONString(commandDTO);
        System.out.println("待发送指令：" + commandJson);

        // 3. 构建MQTT消息
        MqttMessage message = new MqttMessage();
        message.setPayload(commandJson.getBytes()); // 设置消息内容
        message.setQos(qos); // 设置消息质量（至少送达一次）
        message.setRetained(false); // 不保留消息：避免ESP32重启后重复执行

        // 4. 发布消息到指定主题（ESP32已订阅此主题）
        mqttClient.publish(pubTopic, message);
    }
}

说明：工具类的核心是「JSON序列化」和「MQTT消息发布」，通过FastJSON将CommandDTO转为ESP32可解析的JSON字符串，确保格式无偏差；同时添加连接状态校验，提升稳定性。

迭代5：业务层实现——指令校验与逻辑封装

核心目标：对前端传递的参数进行合法性校验（过滤无效指令），调用MQTT工具类发送指令，隔离通信层与接口层，提升代码可维护性。

package com.esp32.control.service;

import com.esp32.control.model.CommandDTO;
import com.esp32.control.mqtt.MqttClientUtil;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Arrays;
import java.util.List;

/**
 * 设备控制服务层：处理业务逻辑，校验参数合法性
 */
@Service // 标识为Spring服务层组件
public class DeviceControlService {
    // 注入MQTT工具类，调用发送指令方法
    @Autowired
    private MqttClientUtil mqttClientUtil;

    // 合法设备ID列表（与ESP32支持的设备完全一致，避免无效设备指令）
    private static final List<String> VALID_DEVICE_IDS = Arrays.asList("bedroom_light", "livingroom_fan");

    // 合法动作列表（仅支持ON/OFF，过滤无效动作）
    private static final List<String> VALID_ACTIONS = Arrays.asList("ON", "OFF");

    /**
     * 发送设备控制指令（对外提供的核心方法）
     * @param deviceId 设备ID（前端传递）
     * @param action 动作指令（前端传递）
     * @throws Exception 校验失败或发送异常
     */
    public void sendControlCommand(String deviceId, String action) throws Exception {
        // 1. 校验设备ID合法性
        if (!VALID_DEVICE_IDS.contains(deviceId)) {
            throw new Exception("无效设备ID！合法ID：" + VALID_DEVICE_IDS);
        }

        // 2. 校验动作合法性
        if (!VALID_ACTIONS.contains(action)) {
            throw new Exception("无效动作！合法动作：" + VALID_ACTIONS);
        }

        // 3. 构建控制指令DTO（设置时间戳为当前毫秒数）
        CommandDTO commandDTO = new CommandDTO();
        commandDTO.setDeviceId(deviceId);
        commandDTO.setAction(action);
        commandDTO.setTimestamp(System.currentTimeMillis()); // 防过期

        // 4. 调用MQTT工具类发送指令
        try {
            mqttClientUtil.sendControlCommand(commandDTO);
        } catch (MqttException e) {
            throw new Exception("指令发送失败：" + e.getMessage());
        }
    }
}

说明：服务层的核心作用是「过滤无效请求」，通过VALID_DEVICE_IDS和VALID_ACTIONS定义合法参数，避免ESP32处理无效指令；后续新增设备时，只需修改这两个列表，无需改动其他层代码，扩展性强。

迭代6：接口层实现——提供前端访问入口

核心目标：提供RESTful接口，供前端页面调用（如按钮点击控制设备），接收前端参数并调用服务层处理，返回统一格式结果。

package com.esp32.control.controller;

import com.esp32.control.service.DeviceControlService;
import org.springframework.beans.factory.annotation.Autowired;
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 java.util.HashMap;
import java.util.Map;

/**
 * 设备控制接口层：提供前端访问的HTTP接口
 */
@RestController // 标识为REST接口控制器（返回JSON格式结果）
@RequestMapping("/device") // 接口统一前缀：/device
public class DeviceControlController {
    // 注入设备控制服务层
    @Autowired
    private DeviceControlService deviceControlService;

    /**
     * 设备控制接口（POST请求：适合提交数据）
     * @param deviceId 设备ID（前端传递，如"bedroom_light"）
     * @param action 动作（前端传递，如"ON"）
     * @return 统一格式的接口结果
     */
    @PostMapping("/control") // 接口路径：/device/control
    public Map<String, Object> controlDevice(
            @RequestParam String deviceId, // 接收前端参数：设备ID
            @RequestParam String action    // 接收前端参数：动作
    ) {
        // 统一返回格式：便于前端解析
        Map<String, Object> result = new HashMap<>();
        try {
            // 调用服务层发送指令
            deviceControlService.sendControlCommand(deviceId, action);
            result.put("code", 200); // 200：成功
            result.put("message", "指令发送成功，等待ESP32执行结果");
        } catch (Exception e) {
            result.put("code", 500); // 500：失败
            result.put("message", "指令发送失败：" + e.getMessage());
        }
        return result;
    }
}

说明：接口采用POST请求（适合提交控制数据），返回统一的JSON格式结果（code+message），前端可根据code判断请求状态，根据message展示用户提示；接口地址为http://localhost:8080/device/control，可直接通过Postman、前端页面调用。

迭代7：工程启动类——程序入口

核心目标：Spring Boot工程的入口，开启自动配置，扫描所有组件（配置类、服务层、接口层等）。

package com.esp32.control;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * ESP32与Java交互工程启动类
 */
@SpringBootApplication // 开启Spring Boot自动配置，扫描当前包及子包下的组件
public class Esp32RemoteControlApplication {
    public static void main(String[] args) {
        SpringApplication.run(Esp32RemoteControlApplication.class, args);
        System.out.println("ESP32远程控制Java端服务启动成功！");
    }
}

三、Java端与ESP32全链路交互流程

结合上述递进式开发的代码，梳理Java端与ESP32的完整交互链路，明确各层代码的协作逻辑：

1. 初始化阶段： - Java端启动后，MqttConfig自动初始化MQTT客户端，连接Broker并订阅结果主题； - ESP32启动后，自动连接WiFi→连接MQTT Broker→订阅指令主题； - 双方完成初始化，进入「等待指令/结果」状态。

2. 指令发送流程（Java→ESP32）： - 前端调用Java接口（/device/control），传递deviceId和action； - 接口层接收参数，调用服务层进行合法性校验； - 服务层构建CommandDTO（设置时间戳），调用MQTT工具类； - MQTT工具类将DTO序列化为JSON，发布到指令主题； - MQTT Broker将指令推送给ESP32。

3. 结果反馈流程（ESP32→Java）： - ESP32接收指令，解析JSON→执行设备控制动作→构建结果JSON； - ESP32将结果发布到结果主题； - MQTT Broker将结果推送给Java端； - Java端通过MqttReceiveCallback接收结果，反序列化为ResultDTO并处理（打印/存库/推前端）。

四、联调测试步骤（验证交互有效性）

核心验证「Java发送指令→ESP32执行→Java接收结果」全链路通畅：

1. 环境准备： - 启动ESP32（确保已上传适配代码，连接WiFi和MQTT Broker）； - 启动Java后端服务（运行启动类，控制台打印「启动成功」）； - 确保双方连接同一MQTT Broker（tcp://broker.emqx.io:1883）。

2. 发送测试指令： - 方式1：Postman调用接口（POST）： 地址：http://localhost:8080/device/control 参数：deviceId=bedroom_light&action=ON； - 方式2：前端页面按钮点击调用接口。

3. 验证结果： - 硬件验证：ESP32连接的LED是否点亮； - Java控制台：打印「指令发送成功」和ESP32的反馈结果； - ESP32串口监视器：打印收到的Java指令和执行状态。

五、扩展方向（递进式开发延伸）

基于当前代码，可逐步扩展以下功能，实现更完善的交互体系：

• 前端页面集成：开发Vue/React前端，通过Axios调用Java接口，实现可视化控制；

• 安全机制增强：添加指令签名校验（如给JSON指令加签，ESP32验签），防止非法指令；

• 日志与监控：将控制日志存入MySQL，通过ELK实现日志分析，添加设备在线状态监控；

• 多设备扩展：新增设备时，只需修改Java服务层的VALID_DEVICE_IDS和ESP32的引脚配置。