前言

CoAP（Constrained Application Protocol，受限应用协议）是专为物联网、低功耗设备、低带宽/高延迟网络设计的轻量级应用层协议，兼容HTTP语义且适配受限环境。本文将从基础概念到实战整合Spring Boot，循序渐进讲解CoAP全链路知识，兼顾易懂性与技术深度。

第一章：CoAP核心概念（入门）

1.1 什么是CoAP

CoAP由IETF的CoRE工作组制定（RFC 7252），核心目标是为资源受限设备（如传感器、嵌入式设备）提供类似HTTP的RESTful通信能力，解决HTTP在低资源场景下的臃肿问题：

• 轻量级：头部仅4字节，报文结构极简；
• UDP基础：默认基于UDP（可通过CoAP-over-TCP补充可靠性）；
• RESTful语义：支持GET/POST/PUT/DELETE方法，资源URI、状态码（如2.05 Success对应HTTP 200）；
• 内置可靠性：通过重传、确认（ACK）机制弥补UDP不可靠性；
• 发现机制：支持资源发现（CoRE Link Format）。

1.2 CoAP与HTTP核心对比

特性	CoAP	HTTP
传输层	基于UDP（可选TCP）	基于TCP
头部大小	4字节（紧凑二进制）	文本型，通常数十字节
资源发现	内置支持	需额外扩展（如SDDP）
功耗/资源	极低（适配嵌入式）	较高（需完整TCP栈）
状态码	2.xx/4.xx/5.xx	2xx/4xx/5xx
适用场景	物联网、受限设备	通用Web应用

1.3 CoAP核心组件

• 资源（Resource）：CoAP通信的核心，对应URI（如coap://localhost:5683/sensor/temp）；
• 端点（Endpoint）：CoAP通信的节点（客户端/服务器）；
• 报文（Message）：分请求/响应/确认/重传等类型，二进制格式；
• 观察机制（Observe）：客户端订阅资源，资源变化时服务器主动推送（类似HTTP长轮询，更轻量）；
• 块传输（Blockwise）：支持大报文分片传输（适配受限MTU）。

第二章：CoAP环境搭建（入门）

2.1 核心依赖（Java）

Java开发CoAP首选californium（Eclipse开源的CoAP实现），Maven/Gradle依赖如下：

Maven

<!-- CoAP核心依赖 -->
<dependency>
    <groupId>org.eclipse.californium</groupId>
    <artifactId>californium-core</artifactId>
    <version>3.8.0</version>
</dependency>
<!-- 可选：TCP支持 -->
<dependency>
    <groupId>org.eclipse.californium</groupId>
    <artifactId>californium-proxy2</artifactId>
    <version>3.8.0</version>
</dependency>
<!-- 可选：安全层（DTLS） -->
<dependency>
    <groupId>org.eclipse.californium</groupId>
    <artifactId>californium-scandium</artifactId>
    <version>3.8.0</version>
</dependency>

Gradle

implementation 'org.eclipse.californium:californium-core:3.8.0'
implementation 'org.eclipse.californium:californium-proxy2:3.8.0' // 可选
implementation 'org.eclipse.californium:californium-scandium:3.8.0' // 可选

2.2 基础工具（调试/测试）

• CoAP客户端工具：
  • coap-cli（命令行）：npm install -g coap-cli；
  • Californium CoAP Client（桌面端）：Eclipse官方工具；
  • Postman：新版支持CoAP协议调试。
• 端口说明：CoAP默认端口5683（UDP/TCP），CoAPS（DTLS加密）默认5684。

第三章：CoAP基础实战（进阶）

3.1 最简CoAP服务器

实现一个温度传感器资源，支持GET请求获取温度：

import org.eclipse.californium.core.CoapServer;
import org.eclipse.californium.core.server.resources.CoapResource;
import org.eclipse.californium.core.coap.CoAP.ResponseCode;
import org.eclipse.californium.core.server.resources.Resource;
import org.eclipse.californium.core.server.resources.ResourceAttributes;

public class SimpleCoapServer {
    public static void main(String[] args) {
        // 创建CoAP服务器，默认端口5683
        CoapServer server = new CoapServer();
        
        // 创建温度资源
        Resource tempResource = new CoapResource("sensor/temp") {
            @Override
            public void handleGET(CoapExchange exchange) {
                // 模拟温度数据（随机数）
                double temp = 20 + Math.random() * 10;
                String response = String.format("{\"temp\": %.1f}", temp);
                
                // 响应客户端，状态码2.05（Success）
                exchange.respond(ResponseCode.CONTENT, response);
            }
        };
        
        // 添加资源到服务器
        server.add(tempResource);
        // 启动服务器
        server.start();
        System.out.println("CoAP服务器启动成功，端口：5683");
    }
}

3.2 最简CoAP客户端

编写客户端请求上述温度资源：

import org.eclipse.californium.core.CoapClient;
import org.eclipse.californium.core.CoapResponse;
import org.eclipse.californium.core.coap.MediaTypeRegistry;

public class SimpleCoapClient {
    public static void main(String[] args) {
        // 创建CoAP客户端，指定资源URI
        CoapClient client = new CoapClient("coap://localhost:5683/sensor/temp");
        
        // 发送GET请求，指定响应格式为JSON
        CoapResponse response = client.get(MediaTypeRegistry.APPLICATION_JSON);
        
        if (response != null) {
            System.out.println("响应状态码：" + response.getCode());
            System.out.println("响应内容：" + response.getResponseText());
        } else {
            System.out.println("请求失败，未收到响应");
        }
        
        // 关闭客户端
        client.shutdown();
    }
}

3.3 核心特性实战：观察（Observe）机制

实现“客户端订阅温度资源，服务器主动推送变化”：

服务器端改造（支持观察）

import org.eclipse.californium.core.coap.CoAP;
import org.eclipse.californium.core.server.resources.ObservableResource;

// 改造温度资源，实现ObservableResource
Resource tempResource = new CoapResource("sensor/temp") implements ObservableResource {
    private double currentTemp = 25.0;
    
    public TempResource() {
        // 启用观察机制
        setObservable(true);
        // 设置更新间隔（2秒推送一次）
        setObserveType(CoAP.Type.CON);
        
        // 模拟温度变化，定时更新
        new Thread(() -> {
            while (true) {
                try {
                    Thread.sleep(2000);
                    // 温度随机波动
                    currentTemp += (Math.random() - 0.5) * 2;
                    // 通知订阅者（触发推送）
                    changed();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        }).start();
    }
    
    @Override
    public void handleGET(CoapExchange exchange) {
        String response = String.format("{\"temp\": %.1f}", currentTemp);
        exchange.respond(ResponseCode.CONTENT, response);
    }
}

客户端订阅（Observe）

import org.eclipse.californium.core.CoapHandler;
import org.eclipse.californium.core.CoapObserveRelation;

public class ObserveCoapClient {
    public static void main(String[] args) {
        CoapClient client = new CoapClient("coap://localhost:5683/sensor/temp");
        
        // 订阅资源，设置回调处理推送
        CoapObserveRelation relation = client.observe(new CoapHandler() {
            @Override
            public void onLoad(CoapResponse response) {
                System.out.println("收到推送：" + response.getResponseText());
            }
            
            @Override
            public void onError() {
                System.out.println("订阅失败");
            }
        });
        
        // 保持客户端运行10秒
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        // 取消订阅
        relation.proactiveCancel();
        client.shutdown();
    }
}

3.4 POST/PUT/DELETE方法实现

扩展资源支持完整RESTful操作（以“设备控制”为例）：

Resource deviceResource = new CoapResource("device/light") {
    private boolean isOn = false; // 灯的状态
    
    @Override
    public void handleGET(CoapExchange exchange) {
        // GET：获取灯的状态
        String response = String.format("{\"lightOn\": %b}", isOn);
        exchange.respond(ResponseCode.CONTENT, response);
    }
    
    @Override
    public void handlePOST(CoapExchange exchange) {
        // POST：切换灯的状态
        isOn = !isOn;
        exchange.respond(ResponseCode.CHANGED, String.format("{\"lightOn\": %b}", isOn));
    }
    
    @Override
    public void handlePUT(CoapExchange exchange) {
        // PUT：设置灯的状态（接收JSON参数）
        String request = exchange.getRequestText();
        // 简化处理：解析{"lightOn": true}
        if (request.contains("true")) {
            isOn = true;
        } else if (request.contains("false")) {
            isOn = false;
        }
        exchange.respond(ResponseCode.CHANGED, String.format("{\"lightOn\": %b}", isOn));
    }
    
    @Override
    public void handleDELETE(CoapExchange exchange) {
        // DELETE：重置灯的状态
        isOn = false;
        exchange.respond(ResponseCode.DELETED, "{\"lightOn\": false}");
    }
};

第四章：CoAP技术细节（精通）

4.1 CoAP报文结构

CoAP报文为二进制格式，核心结构：

字段	长度（位）	说明
Version	2	版本（固定为1）
Type	2	类型（CON/ACK/NON/RST）
Token Length	4	Token长度（0-8字节）
Code	8	方法/状态码（如0.01=GET，2.05=Success）
Message ID	16	报文ID（用于重传/确认）
Token	0-8	令牌（匹配请求/响应）
Options	可变	选项（如URI路径、内容格式）
Payload	可变	负载（数据）

• Type字段说明：
  • CON（Confirmable）：需要确认的报文，服务器必须回复ACK；
  • NON（Non-confirmable）：无需确认，轻量但不可靠；
  • ACK（Acknowledgement）：确认报文；
  • RST（Reset）：重置报文（拒绝/终止）。

4.2 可靠性机制

• 重传：CON报文未收到ACK时，按指数退避策略重传；
• Message ID：唯一标识报文，避免重复处理；
• Blockwise传输：将大Payload分片（Block1/Block2选项），适配MTU<1280的受限网络。

4.3 安全机制（CoAPS）

CoAP通过DTLS（Datagram TLS）实现加密，即CoAPS：

• 依赖scandium库实现DTLS；
• 支持证书/预共享密钥（PSK）认证；
• 默认端口5684，代码中只需替换端点为DTLS端点：

import org.eclipse.californium.scandium.DTLSConnector;
import org.eclipse.californium.scandium.config.DtlsConfig;
import org.eclipse.californium.scandium.config.DtlsConnectorConfig;

// 构建DTLS配置（PSK认证）
DtlsConnectorConfig dtlsConfig = DtlsConnectorConfig.builder()
    .setAddress(new InetSocketAddress(5684))
    .setDtlsConfig(DtlsConfig.builder()
        .setRecommendedCipherSuitesOnly(false)
        .build())
    // 添加PSK密钥（示例）
    .setPskStore((identity, peer) -> new SecretKeySpec("12345678".getBytes(), "PSK"))
    .build();

DTLSConnector dtlsConnector = new DTLSConnector(dtlsConfig);
CoapServer server = new CoapServer(dtlsConnector);

4.4 资源发现（CoRE Link Format）

CoAP内置资源发现机制，客户端可通过/.well-known/core获取所有资源列表：

// 服务器端：注册资源到发现列表
tempResource.getAttributes().addResourceType("sensor.temp");
tempResource.getAttributes().addInterfaceDescription("if.sensor");

// 客户端：访问/.well-known/core获取资源列表
CoapClient client = new CoapClient("coap://localhost:5683/.well-known/core");
CoapResponse response = client.get();
System.out.println("资源列表：" + response.getResponseText());
// 输出示例：</sensor/temp>;rt="sensor.temp";if="if.sensor"

第五章：CoAP整合Spring Boot（精通）

5.1 核心依赖

Spring Boot无官方CoAP Starter，使用californium结合Spring Boot封装，Maven依赖：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.0</version>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.eclipse.californium</groupId>
        <artifactId>californium-core</artifactId>
        <version>3.8.0</version>
    </dependency>
    <!-- 测试依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

5.2 Spring Boot整合CoAP核心配置

步骤1：配置CoAP服务器（Spring Bean）

import org.eclipse.californium.core.CoapServer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class CoapConfig {
    // 从配置文件读取端口，默认5683
    @Value("${coap.port:5683}")
    private int coapPort;
    
    /**
     * 注册CoAP服务器Bean，随Spring Boot启动/停止
     */
    @Bean(destroyMethod = "stop")
    public CoapServer coapServer() {
        CoapServer server = new CoapServer(coapPort);
        // 启动服务器（Spring初始化完成后）
        server.start();
        System.out.println("Spring Boot整合CoAP服务器启动，端口：" + coapPort);
        return server;
    }
}

步骤2：封装CoAP资源（Spring管理）

创建自定义注解标识CoAP资源，结合Spring自动注册：

// 自定义CoAP资源注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Component
public @interface CoapResource {
    String value(); // 资源路径
}

// 温度资源（Spring管理）
@CoapResource("sensor/temp")
public class TempCoapResource extends org.eclipse.californium.core.server.resources.CoapResource {
    public TempCoapResource() {
        super("sensor/temp"); // 资源路径
    }
    
    @Override
    public void handleGET(CoapExchange exchange) {
        double temp = 20 + Math.random() * 10;
        exchange.respond(String.format("{\"temp\": %.1f}", temp));
    }
}

// 资源注册器（自动扫描@CoapResource注解并添加到服务器）
@Component
public class CoapResourceRegistrar implements ApplicationContextAware {
    @Autowired
    private CoapServer coapServer;
    
    @Override
    public void setApplicationContext(ApplicationContext context) throws BeansException {
        // 扫描所有@CoapResource注解的Bean
        Map<String, Object> resources = context.getBeansWithAnnotation(CoapResource.class);
        for (Object resource : resources.values()) {
            if (resource instanceof org.eclipse.californium.core.server.resources.Resource) {
                coapServer.add((org.eclipse.californium.core.server.resources.Resource) resource);
            }
        }
    }
}

步骤3：Spring Boot启动类

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

@SpringBootApplication
public class CoapSpringBootApplication {
    public static void main(String[] args) {
        SpringApplication.run(CoapSpringBootApplication.class, args);
    }
}

步骤4：配置文件（application.yml）

coap:
  port: 5683 # CoAP端口

5.3 Spring Boot + CoAP实战：物联网设备管理

实现“设备状态上报+远程控制”完整场景：

1. 设备状态资源（支持上报/查询）

@CoapResource("device/status")
public class DeviceStatusResource extends CoapResource {
    // 模拟设备状态存储（实际可对接数据库）
    private final Map<String, String> deviceStatus = new ConcurrentHashMap<>();
    
    public DeviceStatusResource() {
        super("device/status");
    }
    
    // GET：查询设备状态（参数：deviceId）
    @Override
    public void handleGET(CoapExchange exchange) {
        String deviceId = exchange.getRequestOptions().getUriQuery().stream()
                .filter(q -> q.startsWith("deviceId="))
                .map(q -> q.split("=")[1])
                .findFirst().orElse("unknown");
        
        String status = deviceStatus.getOrDefault(deviceId, "{\"online\": false}");
        exchange.respond(status);
    }
    
    // POST：设备上报状态
    @Override
    public void handlePOST(CoapExchange exchange) {
        String payload = exchange.getRequestText();
        // 简化解析：{"deviceId": "dev001", "online": true, "battery": 80}
        JSONObject json = new JSONObject(payload);
        String deviceId = json.getString("deviceId");
        deviceStatus.put(deviceId, payload);
        
        exchange.respond(ResponseCode.CHANGED, "{\"code\": 200, \"msg\": \"上报成功\"}");
    }
}

2. 远程控制资源（支持PUT指令）

@CoapResource("device/control")
public class DeviceControlResource extends CoapResource {
    // 指令存储
    private final Map<String, String> deviceCommands = new ConcurrentHashMap<>();
    
    public DeviceControlResource() {
        super("device/control");
        setObservable(true); // 支持设备订阅指令
    }
    
    // PUT：下发控制指令
    @Override
    public void handlePUT(CoapExchange exchange) {
        String payload = exchange.getRequestText();
        JSONObject json = new JSONObject(payload);
        String deviceId = json.getString("deviceId");
        String command = json.getString("command"); // 如"power_off"
        
        deviceCommands.put(deviceId, command);
        changed(); // 通知订阅的设备
        
        exchange.respond(ResponseCode.CHANGED, "{\"code\": 200, \"msg\": \"指令下发成功\"}");
    }
    
    // GET：设备拉取/订阅指令
    @Override
    public void handleGET(CoapExchange exchange) {
        String deviceId = exchange.getRequestOptions().getUriQuery().stream()
                .filter(q -> q.startsWith("deviceId="))
                .map(q -> q.split("=")[1])
                .findFirst().orElse("unknown");
        
        String command = deviceCommands.getOrDefault(deviceId, "{}");
        exchange.respond(command);
    }
}

3. 测试验证

• 设备上报状态：

  coap post coap://localhost:5683/device/status -p '{"deviceId":"dev001","online":true,"battery":80}'
  

• 查询设备状态：

  coap get coap://localhost:5683/device/status?deviceId=dev001
  

• 下发控制指令：

  coap put coap://localhost:5683/device/control -p '{"deviceId":"dev001","command":"power_off"}'
  

• 设备订阅指令：

  coap observe coap://localhost:5683/device/control?deviceId=dev001
  

第六章：CoAP应用场景与最佳实践（精通）

6.1 核心应用场景

1. 物联网（IoT）：传感器/嵌入式设备（如温湿度传感器、智能灯、智能电表）的数据上报/指令下发；
2. 低功耗广域网（LPWAN）：LoRa/NB-IoT等窄带网络的设备通信（适配低带宽/高延迟）；
3. 工业物联网（IIoT）：工业现场受限设备的远程监控/控制；
4. 智能家居：智能设备（如门锁、摄像头）的轻量级通信；
5. 车联网：车载终端与边缘节点的短报文通信。

6.2 最佳实践

1. 协议选择：
   • 轻量、低可靠需求：CoAP（NON报文）；
   • 高可靠需求：CoAP（CON报文）+ 重传机制，或CoAP-over-TCP；
   • 安全需求：CoAPS（DTLS）+ 设备认证（PSK/证书）。
2. 资源设计：
   • 遵循RESTful规范，URI简洁（如/device/{id}/status）；
   • 为资源添加属性（rt/if），支持自动发现；
   • 大报文使用Blockwise传输（分片大小适配网络MTU）。
3. 性能优化：
   • 减少CON报文使用（降低ACK开销）；
   • 合理设置观察机制的更新间隔（避免频繁推送）；
   • 资源复用（避免创建过多细粒度资源）。
4. 容错设计：
   • 客户端添加超时重传逻辑；
   • 服务器添加报文去重（基于Message ID）；
   • 关键操作添加幂等性设计（如PUT指令）。

6.3 常见问题与解决方案

问题	解决方案
UDP报文丢失	使用CON报文+重传，或切换CoAP-over-TCP
资源订阅后推送延迟	优化服务器更新间隔，减少网络拥塞
设备功耗过高	减少CON报文、降低观察频率、使用NON报文
安全风险（未加密）	启用CoAPS（DTLS），禁用明文端口

第七章：总结与进阶方向

7.1 总结

CoAP是受限环境下的轻量级RESTful协议，核心优势是低资源占用、适配UDP、内置观察/发现机制，是物联网场景的首选协议之一。通过本文的学习，你可掌握：

• CoAP核心概念与协议细节；
• 基础CoAP服务器/客户端开发；
• Spring Boot整合CoAP的工程化实践；
• 物联网场景下的最佳实践。

7.2 进阶方向

1. CoAP扩展协议：如CoAP Pub/Sub（发布订阅）、CoAP over QUIC；
2. 边缘计算整合：CoAP网关与边缘节点的通信；
3. 多协议互通：CoAP-HTTP代理（实现物联网设备与Web系统互通）；
4. 大规模部署：CoAP服务器集群、负载均衡；
5. 标准化与认证：遵循OMA LwM2M（基于CoAP的物联网设备管理标准）。

附：常用CoAP状态码对照表

CoAP状态码	含义	HTTP对应
2.01	Created	201
2.02	Deleted	204
2.03	Valid	304
2.04	Changed	204
2.05	Content	200
4.00	Bad Request	400
4.01	Unauthorized	401
4.04	Not Found	404
5.00	Server Error	500