Springboot 定时任务 调度远程服务方法 ，完成 Mqtt 遗嘱消息

最新推荐文章于 2024-05-13 16:04:25 发布
最新推荐文章于 2024-05-13 16:04:25 发布
阅读量1.5k 收藏 10
点赞数
分类专栏： # JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37788383/article/details/106899384
版权

一、Springboot 定时任务 调度远程服务方法 ，完成 Mqtt 遗嘱消息

DEMO的主要功能为：

springboot的定时调度任务，远程访问设备存储在数据库的断面信息，并将取到的断面信息发送给设备。

相关配置，依赖，启动类如下：

1.1相关配置

#Mqtt消息的配置       
mqtt.broker = tcp://177.168.7.184:1883
mqtt.clientId = mqttRetained
mqtt.userName = client
mqtt.password = client
mqtt.connectionTimeout = 3
mqtt.keepAliveInterval = 10


#进行eureka 注册，
#注册时的 name
spring.application.name=pppppppppppppppppppppppppppppppppppppppppmqttretained
#日志文件输出 保存位置，D:/ROOT/logs/mqttRetained.log,可以自动生成文件夹和文件
logging.file.name = D:/ROOT/logs/mqttRetained.log
server.port=8081

## 心跳时间，即服务续约间隔时间（缺省为30s）
#eureka.instance.lease-renewal-interval-in-seconds= 5
## 发呆时间，即服务续约到期时间（缺省为90s）
#eureka.instance.lease-expiration-duration-in-seconds= 15
## 开启健康检查（依赖spring-boot-starter-actuator）
#eureka.client.healthcheck.enabled= true
# 注册的 地址，可以打开 http://177.168.7.184:8761 进行查看，看注册表里是否有 name。
eureka.client.service-url.defaultZone = http://177.168.7.184:8761/eureka





#是否开启jackson的序列化.#fail_on_empty_beans: false忽略无法转换的对象
spring.jackson.serialization.FAIL_ON_EMPTY_BEANS = false
management.security.enabled = false
hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds = 15000

apollo.bootstrap.enabled = true
eureka.instance.perfer-ip-address = true

1.2添加依赖

主要有两方面的依赖：

mqtt消息相关的依赖、
调用远程服务方法的依赖EnableEurekaClient

<?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 https://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.3.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.jowoiot</groupId>
    <artifactId>mqtt_retained</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mqttRetained</name>
    <packaging>jar</packaging>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.RELEASE</spring-cloud.version>
    </properties>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- mqtt -->
        <dependency>
            <groupId>org.eclipse.paho</groupId>
            <artifactId>org.eclipse.paho.client.mqttv3</artifactId>
            <version>1.2.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-integration</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.integration</groupId>
            <artifactId>spring-integration-stream</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.integration</groupId>
            <artifactId>spring-integration-mqtt</artifactId>
        </dependency>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.2</version>
        </dependency>



        <dependency>
        <groupId>com.vaadin.external.google</groupId>
        <artifactId>android-json</artifactId>
        <version>0.0.20131108.vaadin1</version>
        <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>



        <!-- @EnableEurekaClient -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

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

</project>

1.3启动类

在启动类中，注意注解：

远程服务调用（@EnableDiscoveryClient、@EnableFeignClients），
定时任务（@EnableScheduling）。

package com.jowoiot.mqtt_retained;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
//注册进 Eureka 服务中心，开启服务发现 只要一个注解@EnableDiscoveryClient就可以，不需要编写其它程序，然后就是将配置文件要配置好。
@EnableDiscoveryClient
//注解@EnableFeignClients告诉框架扫描所有使用注解@FeignClient定义的feign客户端,
@EnableFeignClients
// 启动类启用 定时调度任务
@EnableScheduling
public class MqttJowoiotApplication {
    public static void main(String[] args) {
        SpringApplication.run(MqttJowoiotApplication.class, args);
    }
}

二、实现mqtt遗嘱消息

相关设置参考文章：Springboot 写一个mqtt 发布/订阅案例(一)
这里贴上代码：

2.1 mqtt消息的配置类

package com.jowoiot.mqtt_retained.config;

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;

import java.util.UUID;

/**
 * mqtt客户端连接配置信息
 */
@Configuration
public class BeanConfig {

    @Value("${mqtt.broker:tcp://177.168.7.184:1883}")
    String broker;

    /*@Value("${mqtt.clientId:ups_mqtt_service}")
    String clientId;*/

    @Value("${mqtt.userName:client}")
    String username;

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

    @Value("10")
    int connectTimeout;

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


    @Bean
    public MqttConnectOptions mqttConnectOptions() {
        MqttConnectOptions options = new MqttConnectOptions();
        options.setCleanSession(false);
        options.setAutomaticReconnect(true);
        options.setConnectionTimeout(connectTimeout);    //设置连接超时
        options.setKeepAliveInterval(keepAliveInterval); // 设置 心跳  设置保持间隔
        options.setPassword(password.toCharArray());
        options.setUserName(username);
        options.setServerURIs(new String[]{broker});
        return options;
    }

    @Bean
    public MqttClient mqttClient() throws MqttException {
        return new MqttClient(broker,"UPS_"+ UUID.randomUUID().toString(),new MemoryPersistence());

    }
}

2.2 mqtt消息的服务类

package com.jowoiot.mqtt_retained.service;


import com.jowoiot.mqtt_retained.MqttJowoiotApplication;
import org.eclipse.paho.client.mqttv3.*;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.TimeUnit;


@Component
public class JowoiotMqttClient {

    Logger logger = LoggerFactory.getLogger(JowoiotMqttClient.class.getName());
    
    @Autowired
    MqttClient mqttClient;

    @Autowired
    MqttConnectOptions mqttConnectOptions;

    public static ConcurrentLinkedQueue<List<Map<String, Object>>> payloadQueue = new ConcurrentLinkedQueue<>();
    boolean client_1_triggle = false;                                //判断 Client_1 连接上的标志开关
    public JSONArray dataArray;
    
    String messageToJson;
    String topicToJson;

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

    @Value("${retained:false}")
    boolean retained;

    public void connect() throws MqttException {
        //在连接的时候通过调用 MqttConnectOptions 实例的 setWill 方法来设定。任何订阅了下面的主题的客户端都可以收到该遗嘱消息。
        mqttConnectOptions.setWill("jowoiot/toServer/bruceS/lptestpub","i am server_1 OFF line".getBytes(),2,true);                      //***设置mqtt遗嘱，如果PUBLISH消息的RETAIN标记位被设置为1，则称该消息为“保留消息”；Broker会存储每个Topic的最后一条保留消息及其Qos，当订阅该Topic的客户端上线后，Broker需要将该消息投递给它。
        mqttClient.connect(mqttConnectOptions);
        mqttClient.publish("jowoiot/toServer/bruceS/lptestpub", "i am server_1 ON line".getBytes(), 2, false);                               //连接上了，就向Srever发布一个 “I'm back”的消息，作为判断Client连接上的标志。
    }

    //订阅消息
    public void subscrib() {
        try {
            mqttClient.subscribe("jowoiot/toServer/bruce/#");
            mqttClient.setCallback(new MqttCallback() {
                @Override
                public void connectionLost(Throwable throwable) {
                    System.out.println("connectionLost");
                }

                @Override                                                       //This method is called when a message arrives from the server.
                public void messageArrived( String topic,MqttMessage mqttMessage) throws Exception {
                    //接收消息
                    byte[] payload = mqttMessage.getPayload();
                    String message = new String(payload, "utf-8");// 经过转换，这里得到了 字符串式 的消息
                    topicToJson = topic;
                    messageToJson = message;
                    if( !messageToJson.equals("i am client_1 pub OFF line") ){
                        client_1_triggle = true;
                    }else {
                        client_1_triggle = false;
                        System.out.println("马上回来...");
                    }

                    List<Map<String, Object>> mapList = new ArrayList<>();      //map<String,Object>是定义了一个Map集合变量，然后list<map<String,Object>>是定义了一个mapList的集合变量，是map的一个集合,map是那个list的其中一个值。
                    Map<String, Object> map = new HashMap<>();
                    map.put("message", message);                                //实际上是Key/Value形式，Value可以是任意类型
                    mapList.add(map);                                           //map是mapList中的其中一个值。
                    //数据放入容器payloadQueue
                    payloadQueue.offer(mapList);                                // add()和offer()都是用来向队列添加一个元素,在容量已满的情况下，add()方法会抛出IllegalStateException异常，offer() 方法只会返回 false 。
                }

                @Override
                public void deliveryComplete(IMqttDeliveryToken iMqttDeliveryToken) {    // 传输完成
//                    System.out.println("deliveryComplete");
                    logger.info("deliveryComplete");                                     // 使用 打印，不如用 打印日志的方式，帅
                }
            });
        } catch (MqttException e) {

            e.printStackTrace();
        }


    }


    /**
     * 发布消息
     * @throws MqttException
     */
    public void publish() throws MqttException {
        try {
            TimeUnit.SECONDS.sleep(2);                          //延时 timeout 秒
//                    取出messageMap数据
            List<Map<String, Object>> poll = payloadQueue.poll();        //poll()移除队列头的元素并且返回，如果队列为空则返回null;remove()移除队列头的元素并且返回，如果队列为空则抛出异常.
            if (poll != null) {
                //发送数据
                mqttClient.publish("jowoiot/toServer/bruceS/lptestpub", poll.toString().getBytes(), 0, false);
                System.out.println("mqtt发送的数据内容为：    " + poll.toString());          //****************************************************
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }



    //检查 刚接收到 的消息 信息
    // {"meta":{"expire":3600,"t":1552553109000},"data":[{"k":"device.point_1","v":"571"},{"k":"device.point_2","v":"1.333"},{"k":"point_3","v":"345"}]}
    public void saveAndProcessing(){
        try{
            if( client_1_triggle ){
                System.out.println("topicToJson:" + topicToJson);                       //****************************************************
                System.out.println("print received messageToJson:" + messageToJson);    //****************************************************
                JSONObject RootMessageObject = new JSONObject(messageToJson);           //将 全部接收的 字符串消息 转换为 JSON格式

                JSONObject metaObject = RootMessageObject.getJSONObject("meta");

                // IMEI 的处理
                String IMEIId = topicToJson.substring(23);                               //"jowoiot/toServer/bruceS/lptestpub",将字符串从索引号为23开始截取，一直到字符串末尾。（索引值从0开始）
                System.out.println("JSON 格式的 IMEI 数据值是:" + IMEIId);
                // expire 信息 的处理
                String expire = metaObject.getString("expire");
                String time = metaObject.getString("t");
                System.out.println("JSON 格式的 expire 数据值是:" + expire);
                System.out.println("JSON 格式的 time 数据值是:" + time);
                // data 信息 的处理
                dataArray = RootMessageObject.getJSONArray("data");         //[{"k":"device.point_1","v":"571"},{"k":"device.point_2","v":"1.333"},{"k":"point_3","v":"345"}]
                for (int i = 0; i < dataArray.length(); i++) {
                    JSONObject dataSonObject = dataArray.getJSONObject(i);               // {"k":"device.point_1","v":"571"}
                    String key = dataSonObject.getString("k");
                    String value = dataSonObject.getString("v");
                    System.out.println("JSON 格式的 key 数据值是:" + key +",  JSON 格式的 value 数据值是:" + value);

                }
                client_1_triggle = false;
                System.out.println("JSON 格式的 数据 检查完毕。");
                System.out.println();
            }
        }catch(JSONException e){
            e.printStackTrace();
        }

    }


    @PostConstruct
    public void run() throws MqttException {
        LoggerFactory.getLogger(MqttJowoiotApplication.class).info("ups server start...");
        connect();
        subscrib();
        System.out.println("开启 连接 ，订阅完成。");
//        while (true) {
//            publish();
//            System.out.println("i love china111111111");
//            saveAndProcessing();
//        }
    }
}


//mqttClient.subscribe("jowoiot/toServer/bruce/#");
//Integer.parseInt(message.substring(17,22)))

三、Springboot 的定时任务调度

3.1 定时任务的配置类

package com.jowoiot.mqtt_retained.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import java.util.concurrent.Executors;


/**************************************
 * 开启多线程后，每次任务开始的间隔都是5秒钟。这是符合我们预期的，
 * 但是最后还有点缺陷，这种情况下的线程是随着任务一执行完就销毁的，等下次有需要了程序再创建一个。
 * 每次都要重新创建明显是太影响性能了，所以需要在代码里给他一个线程池。
 *
 *可以看到现在程序就不会再自己创建线程了，每次都会从线程池里面拿。
 * 需注意的是，如果线程池里的所有线程都被拿去执行调度任务了，且又到了时间要执行一次任务，那么这个任务又会被阻塞。
 * 所以实际开发中如果想要保证任务以速度被执行，线程池的最大线程数量可要想好。
 * ****************************************/
@Configuration
public class SchedulerConfig implements SchedulingConfigurer{
    //开启一个线程调度池
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.setScheduler(Executors.newScheduledThreadPool(100));
    }
}

3.2 定时任务的服务类

在此服务类里，是一个 远程服务方法的调用，
这个服务需要下面的 第四点： 远程服务的相关配置。

package com.jowoiot.mqtt_retained.service;

import com.fasterxml.jackson.core.type.TypeReference;
import com.jowoiot.mqtt_retained.Model.DeviceInfo;
import com.jowoiot.mqtt_retained.service.MdmService;
import com.jowoiot.mqtt_retained.util.JsonUtil;

import org.eclipse.paho.client.mqttv3.MqttClient;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.json.JSONException;

import org.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;


/*****************************************************************
Spring Boot 默认已经实现了定时任务，只需要添加相应的 注解 即可完成。
 pom.xml 不需要添加其他依赖，只需要加入 Spring Boot 依赖即可，即依赖文件中的 web 和 test 的依赖。
 在启动类上面加上 @EnableScheduling 注解即可开启定时任务。
****************************************************************/
@Component
@EnableAsync
public class TimingServiceImpl {

    @Autowired
    MqttClient mqttClient;

    @Autowired
    MdmService mdmService;

    @Autowired
    private JowoiotMqttClient jowoiotMqttClient;

    @Autowired
    private MqttConnectOptions mqttConnectOptions;

    @Scheduled(cron = "*/10 * * * * ?")
    public void runJobA() throws JSONException, MqttException {
        String sql = "MATCH (n:Device)-[e:EXTENDS]->(t:Template)<-[c:CONNECT_INTO]-(p:Point) where p.retained=true return " +
                "{rtuId:e.rtuId,devId:e.devId,customerId:n.customerId,deviceId:n.mdmId,pointId:p.mdmId,pointName:p.name}";
       // Object queryResult
        List<DeviceInfo> deviceInfoList = new ArrayList<DeviceInfo>();
        deviceInfoList= mdmService.queryV2(sql, false);
        System.out.println("deviceInfoList：" + deviceInfoList);


        JSONObject jsonMessageSetWill = new JSONObject();
        for(int i=0;i<deviceInfoList.size();i++){
            DeviceInfo deviceInfo= deviceInfoList.get(i);
            System.out.println("* * * * * *下面是 List 第 " + i + "个 数据值* * * * * *");
            System.out.println("List 格式的 devId 数据值是:     "+deviceInfo.getDevId());
            System.out.println("List 格式的 rtuId 数据值是:     "+deviceInfo.getRtuId());
            System.out.println("List 格式的 pointId 数据值是:   "+deviceInfo.getPointId());
            System.out.println("List 格式的 pointname 数据值是: "+deviceInfo.getPointName());
            System.out.println("List 格式的 customerId 数据值是:"+deviceInfo.getCustomerId());
            System.out.println("List 格式的 deviceId 数据值是:  "+deviceInfo.getDeviceId());

            // 比较 List格式的pointname数据 和  JSON格式的key数据，要是有相同的名称，返回发送List格式的pointname 断面数据
            for(int j=0;j<jowoiotMqttClient.dataArray.length();j++){
                if(jowoiotMqttClient.dataArray.getJSONObject(j).getString("k").equals(deviceInfo.getPointName())){
                    jsonMessageSetWill.put("meta", deviceInfo.getDeviceId());
                    jsonMessageSetWill.put("data", jowoiotMqttClient.dataArray.getJSONObject(j).toString());
                    mqttClient.publish("jowoiot/toServer/bruceS/lptestpub", jsonMessageSetWill.toString().getBytes(), 0, false);
                    mqttConnectOptions.setWill("jowoiot/toServer/bruceS/lptestpub",jsonMessageSetWill.toString().getBytes(),2,true);
                    System.out.println("$ $ $ $ $ $已返回 pointname 断面数据的 deviceId $ $ $ $ $ $");
                    break;
                }
            }


        }

    }
/*******************************************
 * @Scheduled(fixedRate)如何避免任务被阻塞
 * 答案是加上注解@EnableAsync（类上）和@Async（方法上），加了注解以后，就开启了多线程模式，
 * 当到了下一次任务的执行时机时，如果上一次任务还没执行完，就会自动创建一个新的线程来执行它。
 * 异步执行也可以理解为保证了任务以固定速度执行。
 * ********************************************/
    @Async                       //基于@Async标注的方法，称之为异步方法；这些方法将在执行的时候，将会在独立的线程中被执行，调用者无需等待它的完成，即可继续其他的操作。
    @Scheduled(fixedRate = 100) //采用间隔调用
    public void runJobB() throws MqttException  {
//        System.err.println("[MyTaskB-定时调度调度***" + Instant.now());
        jowoiotMqttClient.publish();
        jowoiotMqttClient.saveAndProcessing();
    }

}

//corn表达式：
//每隔5秒执行一次：*/5 * * * * ?
//每隔1分钟执行一次：0 */1 * * * ?
//每天23点执行一次：0 0 23 * * ?
//每天凌晨1点执行一次：0 0 1 * * ?
//每月1号凌晨1点执行一次：0 0 1 1 * ?
//每月最后一天23点执行一次：0 0 23 L * ?
//每周星期天凌晨1点实行一次：0 0 1 ? * L
//在26分、29分、33分执行一次：0 26,29,33 * * * ?
//每天的0点、13点、18点、21点都执行一次：0 0 0,13,18,21 * * ?

四、远程服务方法的配置

远程服务：就是注册 eureka、建立虚拟通道 、实现Feign请求，远程读取数据库的数据。

前辈已经写好服务端，这里只写一个客户端的程序进行试验。

4.1 注册eureka

4.1.1在启动类中添加注解使能：

远程服务调用，要添加注解（@EnableDiscoveryClient、@EnableFeignClients）
还要添加相关依赖文件。

4.1.2在配置文件里配置 eureka 相关内容，要先注册

主要是这两点（spring.application.name、eureka.client.service-url.defaultZone）

通过地址查看， Eureka注册 是否成功。在这里插入图片描述

在这里插入图片描述

4.2 建立数据虚拟专用通道

4.2.1 这个dev_0528文件是 连接 虚拟专用通道 的配置文件

虚拟专用通道下载地址：链接：https://pan.baidu.com/s/1d8HdezRqeuZcpkCcODik6A

提取码：fkal
在这里插入图片描述
在这里插入图片描述

4.2.2 没有这个setting.xml文件，不影响。

在这里插入图片描述

4.3 实现Feigh请求，获取数据

新建服务类，这个服务在 定时调度任务里被调用，用于获取数据库数据。

package com.jowoiot.mqtt_retained.service;

import com.google.gson.JsonObject;
import com.jowoiot.mqtt_retained.Model.DeviceInfo;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

import java.util.List;


@FeignClient(value = "MDMSERVICE")
public interface MdmService {

    @RequestMapping(value = "/graph/v2/single", method = RequestMethod.GET)
    List<Object> queryV2(@RequestParam("query") String query);

    @RequestMapping(value = "/graph/v2/single", method = RequestMethod.GET)
    List<DeviceInfo> queryV2(@RequestParam("query") String query, @RequestParam(value = "single", defaultValue = "false") Boolean single);

}
Bruce_lp
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring boot 开发 MQTT 物联网消息服务（kotlin）
Lincoln 的专栏
07-18 4963
主要针对Ｓpring Ｂoot 使用ＭＱＴＴ协议，远程控制物联网设备，编写的一份教程，希望各位开发物联网的小伙伴们能够有所收获。
SpringBoot 开发之 MQTT 协议遗嘱消息及消息保留的应用
myinsert的博客
09-02 2613
1、消息保留 当客户端连接时将 Retained 为 true ，Broker 会存储每个 Topic 的最后一条保留消息及其 Qos，当订阅该 Topic 的客户端上线后，Broker 需要将该消息投递给它。 保留消息作用： 可以让新订阅的客户端得到发布方的最新的状态值，而不必等待新消息推送。 保留消息弊端： Broker保存的消息会与断线重连接收的断线消息重复。且每次重连时都会投递一次。 保留消息的删除： 发送一条Retained为true，payload为空的消息即可解除。 /**
SpringBoot整合RabbitMQ实现RPC远程调用功能
热门推荐
霁晨晨晨的博客
06-11 3万+
在分布式系统中，RPC（Remote Procedure Call）是一种常用的通信机制，它可以让不同的节点之间像调用本地函数一样进行函数调用，隐藏了底层的网络通信细节。通过本教程，你可以了解RPC的基本原理以及如何使用Java实现一个简单的RPC客户端和服务端。
泛微ECOLOGY9 集成 MQTT 做定时消息推送
最新发布
东枫落定的专栏
05-13 781
泛微ECOLOGY9 集成MQTT 做定时消息推送
Java教程：如何使用SpringBoot项目对接mqtt实现发布者与订阅者进行消息处理
wfeil211的博客
02-11 2536
Java教程：如何使用SpringBoot项目对接mqtt实现发布者与订阅者进行消息处理
springboot整合dubbo实现远程过程调用的简单案例
cc_1113的博客
09-23 1033
dubbo实现远程服务调用的简单案例
SpringBoot+ActiveMq+MQTT实现消息的发送和接收
11-15
5. 编写消息发送接口：为了将消息发送逻辑封装起来，可以创建一个服务类，提供发送消息的方法，这些方法可以根据需要接受不同的参数，比如消息主题和消息内容。 6. 发送消息业务类：在业务层，调用上述接口发送消息...
SpringBoot集成MQTT之消息订阅处理程序
11-08
在本文中，我们将深入探讨如何在SpringBoot应用中集成MQTT协议来实现消息订阅和处理。MQTT（Message Queuing Telemetry Transport）是一种轻量级的发布/订阅型消息协议，广泛应用于物联网(IoT)场景，因为它具有低...
springboot+idea+java+mqtt实现订阅者订阅消息
03-28
springboot+idea+java+mqtt实现订阅者订阅消息 针对业务需要和硬件对接，使用mqtt来处理硬件的数据 java实现订阅者订阅消息，以及处理硬件的数据 是根据业务场景写的demo，包括数据库什么的就不再上传，大家可以根据...
【MQTT服务器】SpringBoot+Mysql存储MQTT消息
05-20
1.springboot新建一个mqtt客户端项目，连接emqx平台，订阅主题消息 2.mybatis通过maven自动生成数据库的类 3.mysql存储数据库的消息 4.mqtt服务器订阅消息、发布消息、断开重连等。 具体使用查看项目...
springboot集成mqtt的实践开发
08-29
在本篇文章中，我们将介绍如何在springboot中集成MQTT（Message Queuing Telemetry Transport）协议，以实现消息队列的发布和订阅。MQTT是一种基于二进制消息的发布/订阅编程模式的消息协议，非常适合需要低功耗和...
MQTT定时上报第三方系统
08-28
根据第三方提供的MQTT配置信息，topic的设计及playload封装，定时的上报相关参数给第三方系统
【应用】SpringBoot 整合 MQTT
情绪瓜皮皮丶的学习之路
10-08 1341
SpringBoot 整合 MQTT 的基本使用
基于SpringBoot实现调用远程服务
w_xz157的专栏
04-09 8119
基于SpringBoot实现的远程服务调用 写在前面的知识概要 SpringBoot 的 @Import 用于将指定的类实例注入到Spring IOC Container中。 SpringBoot 提供了 三种使用 @Import 将 类实例注入至 Spring IOC Container中方法。 直接注入 实现 ImportBeanDefinitionRegistrar 接口注入 ...
MQTT 遗嘱消息（Will Message）发布
m0_50668851的博客
06-07 3031
MQTT遗嘱消息，什么时候订阅者会收到代理服务器发布的遗嘱消息？以下四种情况： 1.服务端发生了I/O 错误或者网络失败； 2.客户端在定义的心跳时期失联； 3.客户端在发送下线包之前关闭网络连接； 4.服务端在收到下线包之前关闭网络连接。 正常状态下发布者断开MQTT连接，AT+MQTTDISCONN，正常关闭MQTT链路，设置的遗嘱消息是不会被代理服务器发布出去的， ......
mqtt定时脚本
铁柱ａｄｍｉｎ的博客
05-11 336
给mqtt的topic发送信息对应的topic接收请求后，执行发送短信指令信息内容lua的mqtt里面，截取判断即可–>可以实现=====定时任务，每月开机一次发短信？或者使用开机通知？
服务器怎么设置mqtt遗嘱消息,MQTT 遗嘱消息、Retained消息、QOS上线下线实现
weixin_30219823的博客
08-05 2692
Retained消息参考：https://www.emqx.com/zh/blog/mqtt5-features-retain-message当你为一个topic设置了Retained消息，那么这个消息会保留在Broker里面，当有新的订阅者订阅到此topic之后，就会接收到这个Retained消息(也就是payload)保留消息虽然存储在服务端中，但它并不属于会话的一部分。也就是说，即便发布这个...
springboot集成MQTT [emqx]
weixin_41221717的博客
02-09 3202
1、引入相关maven依赖 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <depend
springboot 使用mqtt发送消息
03-22
Spring Boot提供了对MQTT的支持，可以方便地使用MQTT发送消息。 要在Spring Boot中使用MQTT发送消息，首先需要添加相关的依赖。在`pom.xml`文件中添加以下依赖： ```xml <groupId>org.springframework.boot ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值