基于springboot设计能支持http协议、mqtt协议、coap协议的物联网平台，每段协议代码要包含：协议网关，协议数据发送端，协议数据订阅端、协议服务器信息，该物联网平台能把来自http协议、mqtt协议、coap协议的信息JSON数据化的能力，json格式包含：mode:信息来源，1表发送端，0表订阅端；gateID：协议类型，01表http，02表mqtt，03表coap;obid:传感器的标识，obtype：传感器编号，value：具体传感数值。最后，列出该完整代码，包含依赖项，import语句

以下是基于Spring Boot设计的支持HTTP、MQTT和CoAP协议的物联网平台的完整代码，包含依赖项和import语句：

pom.xml

<dependencies>
    <!-- Spring Boot dependencies -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- MQTT dependencies -->
    <dependency>
        <groupId>org.springframework.integration</groupId>
        <artifactId>spring-integration-mqtt</artifactId>
        <version>5.3.2.RELEASE</version>
    </dependency>

    <!-- CoAP dependencies -->
    <dependency>
        <groupId>com.github.eclipse.californium</groupId>
        <artifactId>californium-core</artifactId>
        <version>2.0.0-M8</version>
    </dependency>

    <!-- JSON dependencies -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.12.1</version>
    </dependency>

</dependencies>

Application.java

import org.eclipse.californium.core.CoapServer;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.integration.annotation.IntegrationComponentScan;
import org.springframework.integration.annotation.MessageEndpoint;
import org.springframework.integration.annotation.ServiceActivator;
import org.springframework.integration.channel.DirectChannel;
import org.springframework.integration.channel.PublishSubscribeChannel;
import org.springframework.integration.config.EnableIntegration;
import org.springframework.integration.mqtt.inbound.MqttPahoMessageDrivenChannelAdapter;
import org.springframework.integration.mqtt.outbound.MqttPahoMessageHandler;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageHandler;
import org.springframework.messaging.MessagingException;
import org.springframework.messaging.SubscribableChannel;
import org.springframework.messaging.handler.annotation.Payload;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

@SpringBootApplication
@EnableIntegration
@IntegrationComponentScan
public class Application {

    private static final String HTTP_GATEWAY_ID = "01";
    private static final String MQTT_GATEWAY_ID = "02";
    private static final String COAP_GATEWAY_ID = "03";

    private static final ObjectMapper objectMapper = new ObjectMapper();

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

    // HTTP protocol gateway
    @MessageEndpoint
    public static class HttpGateway {
        @ServiceActivator(inputChannel = "httpChannel")
        public void handleMessage(Message<?> message) throws JsonProcessingException {
            String jsonString = objectMapper.writeValueAsString(message.getPayload());
            System.out.println(jsonString);
        }
    }

    // MQTT protocol gateway
    @Bean
    public SubscribableChannel mqttInputChannel() {
        return new DirectChannel();
    }

    @Bean
    public MessageHandler mqttOutbound() {
        MqttPahoMessageHandler handler = new MqttPahoMessageHandler("mqtt://localhost:1883", "mqttClient");
        handler.setAsync(true);
        handler.setDefaultTopic("mqttTopic");
        return handler;
    }

    @Bean
    public MessageHandler mqttInbound() {
        MqttPahoMessageDrivenChannelAdapter adapter = new MqttPahoMessageDrivenChannelAdapter(
                "mqtt://localhost:1883", "mqttClient", "mqttTopic");
        adapter.setCompletionTimeout(5000);
        adapter.setConverter(new MqttPayloadConverter());
        adapter.setQos(1);
        adapter.setOutputChannel(mqttInputChannel());
        return adapter;
    }

    @MessageEndpoint
    public static class MqttGateway {
        @ServiceActivator(inputChannel = "mqttInputChannel")
        public void handleMessage(Message<?> message) throws JsonProcessingException {
            String jsonString = objectMapper.writeValueAsString(message.getPayload());
            System.out.println(jsonString);
        }
    }

    // CoAP protocol gateway
    @Bean
    public CoapServer coapServer() {
        CoapServer server = new CoapServer();
        server.add(new CoapResource() {
            @Override
            public void handlePOST(CoapExchange exchange) {
                String jsonString = objectMapper.writeValueAsString(exchange.getRequestText());
                System.out.println(jsonString);
                exchange.respond("OK");
            }
        });
        return server;
    }

    // JSON message converter
    public static class MqttPayloadConverter implements org.springframework.integration.mqtt.support.DefaultPahoMessageConverter {
        @Override
        public Object fromPayload(byte[] payload, Class<?> targetClass) {
            try {
                String jsonString = new String(payload, "UTF-8");
                return objectMapper.readValue(jsonString, targetClass);
            } catch (Exception e) {
                throw new MessagingException("Failed to convert JSON message", e);
            }
        }
    }

    // Message channels
    @Bean
    public SubscribableChannel httpChannel() {
        return new PublishSubscribeChannel();
    }

    @Bean
    public SubscribableChannel mqttChannel() {
        return new PublishSubscribeChannel();
    }

    @Bean
    public SubscribableChannel coapChannel() {
        return new PublishSubscribeChannel();
    }

    // Message handlers
    @Bean
    public MessageHandler httpOutbound() {
        return message -> {
            try {
                String jsonString = objectMapper.writeValueAsString(message.getPayload());
                System.out.println(jsonString);
            } catch (JsonProcessingException e) {
                throw new MessagingException("Failed to convert message to JSON", e);
            }
        };
    }

    @Bean
    public MessageHandler mqttOutboundHandler() {
        return mqttOutbound();
    }

    @Bean
    public MessageHandler coapOutbound() {
        return message -> {
            try {
                String jsonString = objectMapper.writeValueAsString(message.getPayload());
                System.out.println(jsonString);
            } catch (JsonProcessingException e) {
                throw new MessagingException("Failed to convert message to JSON", e);
            }
        };
    }

}

注意：以上代码仅供参考，实际应用场景中可能需要根据具体需求进行修改和扩展。同时，代码中的日志输出也需要根据实际情况进行修改，以便更好地进行调试和监控。