ruoyi-vue 整合EMQX接收MQTT协议数据

news2024/11/18 9:20:42

EMQX安装完成后，需要搭建客户端进行接收数据进一步对数据处理，下面介绍基于若依分离版开源框架来整合EMQX方法。

1.application.yml 添加代码

mqtt:
  hostUrl: tcp://localhost:1883
  username: dev
  password: dev
  client-id: MQTT-CLIENT-DEV
  cleanSession: true
  reconnect: true
  timeout: 100
  keepAlive: 100
  defaultTopic: client/dev/report
  serverTopic: server/dev/report
  isOpen: true
  qos: 0

2.pom.xml 引入依赖

        <!-- mqtt -->
        <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>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
            <scope>provided</scope>
        </dependency>

3.新建 MqttAcceptCallback

package com.ruoyi.iot.mqtt;

import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
import org.eclipse.paho.client.mqttv3.MqttCallbackExtended;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;


/**
 * @Description : MQTT接受服务的回调类
 * @Author : lsyong
 * @Date : 2023/8/1 16:29
 */


@Component
public class MqttAcceptCallback implements MqttCallbackExtended {

    private static final Logger logger = LoggerFactory.getLogger(MqttAcceptCallback.class);

    @Autowired
    private MqttAcceptClient mqttAcceptClient;

    @Autowired
    private MqttProperties mqttProperties;

    /**
     * 客户端断开后触发
     *
     * @param throwable
     */
    @Override
    public void connectionLost(Throwable throwable) {
        logger.info("连接断开，可以重连");
        if (MqttAcceptClient.client == null || !MqttAcceptClient.client.isConnected()) {
            logger.info("【emqx重新连接】....................................................");
            mqttAcceptClient.reconnection();
        }
    }

    /**
     * 客户端收到消息触发
     *
     * @param topic       主题
     * @param mqttMessage 消息
     */
    @Override
    public void messageArrived(String topic, MqttMessage mqttMessage) throws Exception {
        logger.info("【接收消息主题】:" + topic);
        logger.info("【接收消息Qos】:" + mqttMessage.getQos());
        logger.info("【接收消息内容】:" + new String(mqttMessage.getPayload()));
        //        int i = 1/0;
    }

    /**
     * 发布消息成功
     *
     * @param token token
     */
    @Override
    public void deliveryComplete(IMqttDeliveryToken token) {
        String[] topics = token.getTopics();
        for (String topic : topics) {
            logger.info("向主题【" + topic + "】发送消息成功！");
        }
        try {
            MqttMessage message = token.getMessage();
            byte[] payload = message.getPayload();
            String s = new String(payload, "UTF-8");
            logger.info("【消息内容】:" + s);
        } catch (Exception e) {
            logger.error("MqttAcceptCallback deliveryComplete error,message:{}", e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * 连接emq服务器后触发
     *
     * @param b
     * @param s
     */
    @Override
    public void connectComplete(boolean b, String s) {
        logger.info("============================= 客户端【" + MqttAcceptClient.client.getClientId() + "】连接成功！=============================");
        // 以/#结尾表示订阅所有以test开头的主题
        // 订阅所有机构主题
        mqttAcceptClient.subscribe(mqttProperties.getDefaultTopic(), 0);
    }
}

4.新建 MqttAcceptClient

package com.ruoyi.iot.mqtt;

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.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @Description : MQTT接受服务的客户端
 * @Author : lsyong
 * @Date : 2023/8/1 16:26
 */
@Component
public class MqttAcceptClient {

    private static final Logger logger = LoggerFactory.getLogger(MqttAcceptClient.class);

    @Autowired
    private MqttAcceptCallback mqttAcceptCallback;

    @Autowired
    private MqttProperties mqttProperties;

    public static MqttClient client;

    private static MqttClient getClient() {
        return client;
    }

    private static void setClient(MqttClient client) {
        MqttAcceptClient.client = client;
    }

    /**
     * 客户端连接
     */
    public void connect() {
        MqttClient client;
        try {
            client = new MqttClient(mqttProperties.getHostUrl(), mqttProperties.getClientId(),
                    new MemoryPersistence());
            MqttConnectOptions options = new MqttConnectOptions();
            options.setUserName(mqttProperties.getUsername());
            options.setPassword(mqttProperties.getPassword().toCharArray());
            options.setConnectionTimeout(mqttProperties.getTimeout());
            options.setKeepAliveInterval(mqttProperties.getKeepAlive());
            options.setAutomaticReconnect(mqttProperties.getReconnect());
            options.setCleanSession(mqttProperties.getCleanSession());
            MqttAcceptClient.setClient(client);
            // 设置回调
            client.setCallback(mqttAcceptCallback);
            client.connect(options);
        } catch (Exception e) {
            logger.error("MqttAcceptClient connect error,message:{}", e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * 重新连接
     */
    public void reconnection() {
        try {
            client.connect();
        } catch (MqttException e) {
            logger.error("MqttAcceptClient reconnection error,message:{}", e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * 订阅某个主题
     *
     * @param topic 主题
     * @param qos   连接方式
     */
    public void subscribe(String topic, int qos) {
        logger.info("========================【开始订阅主题:" + topic + "】========================");
        try {
            client.subscribe(topic, qos);
        } catch (MqttException e) {
            logger.error("MqttAcceptClient subscribe error,message:{}", e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * 取消订阅某个主题
     *
     * @param topic
     */
    public void unsubscribe(String topic) {
        logger.info("========================【取消订阅主题:" + topic + "】========================");
        try {
            client.unsubscribe(topic);
        } catch (MqttException e) {
            logger.error("MqttAcceptClient unsubscribe error,message:{}", e.getMessage());
            e.printStackTrace();
        }
    }
}

5.新建 MqttCondition

package com.ruoyi.iot.mqtt;

import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotatedTypeMetadata;

/**
 * @Description : 自定义配置,通过这个配置，来控制启动项目的时候是否启动mqtt
 * @Author : lsyong
 * @Date : 2023/8/1 16:32
 */
public class MqttCondition implements Condition {

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata annotatedTypeMetadata) {
        //1、能获取到ioc使用的beanfactory
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        //2、获取类加载器
        ClassLoader classLoader = context.getClassLoader();
        //3、获取当前环境信息
        Environment environment = context.getEnvironment();
        String isOpen = environment.getProperty("mqtt.isOpen");
        return Boolean.valueOf(isOpen);
    }
}

6.新建 MqttConfig

package com.ruoyi.iot.mqtt;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;

/**
 * @Description : 启动服务的时候开启监听客户端
 * @Author : lsyong
 * @Date : 2023/8/1 16:35
 */
@Configuration
public class MqttConfig {

    @Autowired
    private MqttAcceptClient mqttAcceptClient;

    /**
     * 订阅mqtt
     *
     * @return
     */
    @Conditional(MqttCondition.class)
    @Bean
    public MqttAcceptClient getMqttPushClient() {
        mqttAcceptClient.connect();
        return mqttAcceptClient;
    }
}

7.新建 MqttProperties

package com.ruoyi.iot.mqtt;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * @Description : MQTT配置信息
 * @Author : lsyong
 * @Date : 2023/8/1 16:25
 */
@Component
@ConfigurationProperties("mqtt")
@Data
public class MqttProperties {

    /**
     * 用户名
     */
    private String username;

    /**
     * 密码
     */
    private String password;

    /**
     * 连接地址
     */
    private String hostUrl;

    /**
     * 客户端Id，同一台服务器下，不允许出现重复的客户端id
     */
    private String clientId;

    /**
     * 默认连接主题，以/#结尾表示订阅所有以test开头的主题
     */
    private String defaultTopic;

    /**
     * 默认服务器发送主题前缀，格式：server:${env}:report:${topic}
     */
    private String serverTopic;

    /**
     * 超时时间
     */
    private int timeout;

    /**
     * 设置会话心跳时间 单位为秒 服务器会每隔1.5*20秒的时间向客户端
     * 发送个消息判断客户端是否在线，但这个方法并没有重连的机制
     */
    private int keepAlive;

    /**
     * 设置是否清空session,这里如果设置为false表示服务器会保留客户端的连
     * 接记录，这里设置为true表示每次连接到服务器都以新的身份连接
     */
    private Boolean cleanSession;

    /**
     * 是否断线重连
     */
    private Boolean reconnect;

    /**
     * 启动的时候是否关闭mqtt
     */
    private Boolean isOpen;

    /**
     * 连接方式
     */
    private Integer qos;

    /**
     * 获取默认主题，以/#结尾表示订阅所有以test开头的主题
     *
     * @return
     */
    public String getDefaultTopic() {
        return defaultTopic + "/#";
    }

    /**
     * 获取服务器发送主题，格式：server/${env}/report/${topic}
     *
     * @param topic
     * @return
     */
    public String getServerTopic(String topic) {
        return serverTopic + "/" + topic;
    }
}

8.新建 MqttSendCallBack

package com.ruoyi.iot.mqtt;

import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
import org.eclipse.paho.client.mqttv3.MqttCallbackExtended;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

/**
 * @Description : MQTT发送客户端的回调类
 * @Author : lsyong
 * @Date : 2023/8/1 16:31
 */
@Component
public class MqttSendCallBack implements MqttCallbackExtended {

    private static final Logger logger = LoggerFactory.getLogger(MqttSendCallBack.class);

    /**
     * 客户端断开后触发
     *
     * @param throwable
     */
    @Override
    public void connectionLost(Throwable throwable) {
        logger.info("连接断开，可以重连");
    }

    /**
     * 客户端收到消息触发
     *
     * @param topic       主题
     * @param mqttMessage 消息
     */
    @Override
    public void messageArrived(String topic, MqttMessage mqttMessage) throws Exception {
        logger.info("【接收消息主题】: " + topic);
        logger.info("【接收消息Qos】: " + mqttMessage.getQos());
        logger.info("【接收消息内容】: " + new String(mqttMessage.getPayload()));
    }

    /**
     * 发布消息成功
     *
     * @param token token
     */
    @Override
    public void deliveryComplete(IMqttDeliveryToken token) {
        String[] topics = token.getTopics();
        for (String topic : topics) {
            logger.info("向主题【" + topic + "】发送消息成功！");
        }
        try {
            MqttMessage message = token.getMessage();
            byte[] payload = message.getPayload();
            String s = new String(payload, "UTF-8");
            logger.info("【消息内容】:" + s);
        } catch (Exception e) {
            logger.error("MqttSendCallBack deliveryComplete error,message:{}", e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * 连接emq服务器后触发
     *
     * @param b
     * @param s
     */
    @Override
    public void connectComplete(boolean b, String s) {
        logger.info("============================= 客户端【" + MqttAcceptClient.client.getClientId() + "】连接成功！=============================");
    }
}

9.新建 MqttSendClient

package com.ruoyi.iot.mqtt;


import org.eclipse.paho.client.mqttv3.*;
import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.UUID;

/**
 * @Description : MQTT发送客户端
 * @Author : lsyong
 * @Date : 2023/8/1 16:30
 */
@Component
public class MqttSendClient {

    private static final Logger logger = LoggerFactory.getLogger(MqttSendClient.class);

    @Autowired
    private MqttSendCallBack mqttSendCallBack;

    @Autowired
    private MqttProperties mqttProperties;

    public MqttClient connect() {
        MqttClient client = null;
        try {
            String uuid = UUID.randomUUID().toString().replaceAll("-", "");
            client = new MqttClient(mqttProperties.getHostUrl(), uuid, new MemoryPersistence());
            MqttConnectOptions options = new MqttConnectOptions();
            options.setUserName(mqttProperties.getUsername());
            options.setPassword(mqttProperties.getPassword().toCharArray());
            options.setConnectionTimeout(mqttProperties.getTimeout());
            options.setKeepAliveInterval(mqttProperties.getKeepAlive());
            options.setCleanSession(true);
            options.setAutomaticReconnect(false);
            // 设置回调
            client.setCallback(mqttSendCallBack);
            client.connect(options);
        } catch (Exception e) {
            logger.error("MqttSendClient connect error,message:{}", e.getMessage());
            e.printStackTrace();
        }
        return client;
    }

    /**
     * 发布消息
     *
     * @param retained 是否保留
     * @param topic    主题，格式： server:${env}:report:${topic}
     * @param content  消息内容
     */
    public void publish(boolean retained, String topic, String content) {
        MqttMessage message = new MqttMessage();
        message.setQos(mqttProperties.getQos());
        message.setRetained(retained);
        message.setPayload(content.getBytes());
        MqttDeliveryToken token;
        MqttClient mqttClient = connect();
        try {
            mqttClient.publish(mqttProperties.getServerTopic(topic), message);
        } catch (MqttException e) {
            logger.error("MqttSendClient publish error,message:{}", e.getMessage());
            e.printStackTrace();
        } finally {
            disconnect(mqttClient);
            close(mqttClient);
        }
    }

    /**
     * 关闭连接
     *
     * @param mqttClient
     */
    public static void disconnect(MqttClient mqttClient) {
        try {
            if (mqttClient != null)
                mqttClient.disconnect();
        } catch (MqttException e) {
            logger.error("MqttSendClient disconnect error,message:{}", e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * 释放资源
     *
     * @param mqttClient
     */
    public static void close(MqttClient mqttClient) {
        try {
            if (mqttClient != null)
                mqttClient.close();
        } catch (MqttException e) {
            logger.error("MqttSendClient close error,message:{}", e.getMessage());
            e.printStackTrace();
        }
    }
}

10.新建测试类 MqttController

package com.ruoyi.iot.mqtt;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Description : 测试类
 * @Author : lsyong
 * @Date : 2023/8/1 16:35
 */
@RestController
@RequestMapping("/mqtt")
public class MqttController {

    @Autowired
    private MqttSendClient mqttSendClient;

    @GetMapping(value = "/publishTopic")
    public String publishTopic(String topic, String sendMessage) {
        System.out.println("topic:" + topic);
        System.out.println("message:" + sendMessage);
        this.mqttSendClient.publish(false, topic, sendMessage);
        return "topic:" + topic + "\nmessage:" + sendMessage;
    }

}

放开测试类的访问权限，在com.ruoyi.framework.config 路径下的 SecurityConfig 类中添加如下代码

 .antMatchers("/mqtt/**").permitAll()

11.启动项目进行测试

如果连接不上，确认emqx是否启动成功，详细可以查看Windows安装EMQX（搭建MQTT服务）-CSDN博客

连接成功后可以登入EMQX去查看

浏览器访问 http://localhost:8080/mqtt/publishTopic?sendMessage=你好啊

控制台打印

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1270256.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

leetcode 15. 三数之和（优质解法）

leetcode 15. 三数之和（优质解法）

代码&#xff1a; class Solution {public static List<List<Integer>> threeSum(int[] nums) {Arrays.sort(nums);List<List<Integer>> listsnew ArrayList<>();int lengthnums.length;for(int i0;i<length-3;){int lefti1;int rightlength…
阅读更多...
springboot基础配置及maven运行

springboot基础配置及maven运行

目录 1、spring快速开始&#xff1a; 2、通过idea工具打开导入包 3、maven打包 1、springboot快速开始&#xff1a; 环境依赖&#xff1a;jdk17 Spring | Quickstart spring初始化包下载&#xff1a; 点击generate&#xff0c;下载包 2、通过idea工具打开导入包 我之前写了…
阅读更多...
RK3568 android 13 内置 google GMS服务

RK3568 android 13 内置 google GMS服务

需求&#xff1a;Android 系统在国外使用安装app很多需要gms服务&#xff0c;否则无法正常使用&#xff0c;所以出厂前必须要把GMS包集成进系统 1.下载gms包https://download.csdn.net/download/qq_46524402/88136401 2.解压gms包 并放到Android SDK根目录的vender文件夹下 3…
阅读更多...
内网渗透隧道技术一netsh

内网渗透隧道技术一netsh

隧道技术 百度百科&#xff1a; 网络隧道技术指的是利用一种网络协议来传输另一种网络协议&#xff0c;它主要利用网络隧道协议来实现这种功能。网络隧道技术涉及了三种网络协议&#xff0c;即网络隧道协议、隧道协议下面的承载协议和隧道协议所承载的被承载协议 在网络安全中…
阅读更多...
通往数百万量子比特的商业化之路——

通往数百万量子比特的商业化之路——

在已知物理定律的限制下&#xff0c;我们能制造出的最好的计算机是什么&#xff1f;争夺这一头衔的是通用、容错和可扩展的量子计算机。 这台建立在量子理论基础上的机器能够运行任何量子算法&#xff0c;检测并纠正任何可能危及计算的错误&#xff0c;并容纳大量量子比特。 当…
阅读更多...
开发电脑软件学什么语言?哪些语言最适合?

开发电脑软件学什么语言?哪些语言最适合?

随着信息技术的不断发展&#xff0c;电脑软件已经成为人们日常生活和工作中不可或缺的一部分&#xff0c;许多人都希望学习如何开发电脑软件&#xff0c;而选择一种合适的编程语言是成功的关键&#xff0c;下面将介绍几种最适合开发电脑软件的编程语言&#xff0c;以及一些基础…
阅读更多...
自动提交日志脚本（2）状态机管理

自动提交日志脚本（2）状态机管理

使用状态机作为管理 """ filename:statusHandle.py author:LinXingNan time:2023-11-27 """ import os from enum import Enumimport configHandle import emailReport import logHandle import timeHandle import logging from datetime impo…
阅读更多...
flask中路由route根据字典ID展示部分内容，字典名展示全部内容

flask中路由route根据字典ID展示部分内容，字典名展示全部内容

from flask import Flask, jsonify , request,render_template,app Flask(__name__)app.config[JSON_AS_ASCII] Falsebooks [{"id": 1, "name": 三国演义},{"id": 2, "name": 水浒传},{"id": 3, "name": 西游记…
阅读更多...
【UE】热成像效果

【UE】热成像效果

效果 步骤 1. 新建一个空白项目&#xff0c;勾选“光线追踪”选项 2. 添加一个第一人称游戏内容包到项目 3. 打开第一人称角色蓝图“BP_FirstPersonCharacter”&#xff0c;添加一个后期处理组件 在事件图表中设置通过按键N来切换不同的后期处理效果 将后期处理设置引脚提升为…
阅读更多...
后端Long型数据传到前端js后精度丢失的问题

后端Long型数据传到前端js后精度丢失的问题

假设一个场景&#xff0c;MybatisPlus的雪花算法生成long类型主键ID&#xff0c;存入数据库&#xff0c;前端获取到数据后&#xff0c;要执行一个更新操作&#xff08;updateById&#xff09;&#xff0c;但这时会出现无法成功更新的情况&#xff01;这是因为前端在长度大于17位…
阅读更多...
TCP/IP封装

TCP/IP封装

数据如何通过网络发送&#xff1f;为什么 OSI 模型需要这么多层&#xff1f; 下图显示了数据在网络传输时如何封装和解封装。 步骤1&#xff1a;当设备A通过HTTP协议通过网络向设备B发送数据时&#xff0c;首先在应用层添加HTTP头。 步骤2&#xff1a;然后将TCP或UDP标头添加…
阅读更多...
Python数据清洗--运用3δ准则检测异常值

Python数据清洗--运用3δ准则检测异常值

1.3δ准则检测异常值的基本原理 当数据为连续型变量、服从或近似服从正态分布时&#xff0c;可运用3δ准则检测异常值。在该准则条件下&#xff0c;数据值与均值的偏差如果超过标准差的3倍&#xff0c;那么该数据值就会被视为异常值。即针对样本xi&#xff0c;如果满足&#x…
阅读更多...
【Linux--进程】

【Linux--进程】

目录 一、基本概念1.1描述进程-PCB1.2task_struct中内容分类 二、了解进程2.1查看进程2.2通过系统调用获取进程标识符 三、fork创建进程3.1fork()函数3.2写时拷贝 四、进程的状态4.1操作系统学科里的进程状态&#xff08;运行、阻塞、挂起&#xff09;4.具体的Linux状态是如何维…
阅读更多...
MySQL之undo日志

MySQL之undo日志

聊聊undo log 什么是undo log undo log&#xff08;回滚事务&#xff09;&#xff0c;在事务没有提交前&#xff0c;MySQL将记录更新操作的反向操作到undo log日志中&#xff0c;以便进行回退保证事务的原子性 undo log的作用 1.提供回滚操作 我们在进行数据更新操作的时候…
阅读更多...
【Android Jetpack】Lifecycle 感知生命周期

【Android Jetpack】Lifecycle 感知生命周期

文章目录 背景示例LifeCycle的原理LifecycleOwner自定义LifecycleOwnerLifecycleObserver 示例改进使用LifecycleService解耦Service与组件整个应用进程的生命周期ProcessLifecycleOwner 背景 在Android应用程序开发中&#xff0c;解耦很大程度上表现为系统组件的生命周期与普…
阅读更多...
C++学习之路（十三）C++ 用Qt5实现一个工具箱（增加一个Base64加解密功能）- 示例代码拆分讲解

C++学习之路（十三）C++ 用Qt5实现一个工具箱（增加一个Base64加解密功能）- 示例代码拆分讲解

上篇文章&#xff0c;我们用 Qt5 实现了在小工具箱中添加了《XML文本格式化功能》功能。为了继续丰富我们的工具箱&#xff0c;今天我们就再增加一个平时经常用到的功能吧&#xff0c;就是「 Base64加解密 」功能。下面我们就来看看如何来规划开发一个这样的小功能并且添加到我…
阅读更多...
改造http.server为简单的文件下载服务

改造http.server为简单的文件下载服务

改造 修改http.server.SimpleHTTPRequestHandler&#xff0c;实现简单的文件上传下载服务 simple_http_file_server.py&#xff1a; # !/usr/bin/env python3import datetime import email import html import http.server import io import mimetypes import os import posi…
阅读更多...
hql面试题之字符串使用split分割，并选择其中的一部分字段的问题

hql面试题之字符串使用split分割，并选择其中的一部分字段的问题

版本&#xff1a;20231109 1.题目&#xff1a; 有两张表,a表有id和abstringr两个字段&#xff0c;b表也有id和bstr两个字段&#xff0c;具体如下 A表&#xff1a; 1abc,bcd,cdf2123,456,789 B表: 1acddef2123456 在a表的abstring字段中用‘,’分割&#xff0c;并取出前两…
阅读更多...
万宾科技水环境综合治理监测系统的融合与应用

万宾科技水环境综合治理监测系统的融合与应用

随着社会经济的快速发展&#xff0c;我国的水环境污染问题日益凸显&#xff0c;这不仅对生态环境造成了严重破坏&#xff0c;也严重威胁到人民群众的健康和生活质量。为了解决这一问题&#xff0c;城市生命线与水环境综合治理监测系统应运而生&#xff0c;二者的结合将为水环境…
阅读更多...
TA-Lib学习研究笔记——Overlap Studies（二）下

TA-Lib学习研究笔记——Overlap Studies（二）下

TA-Lib学习研究笔记——Overlap Studies&#xff08;二&#xff09;下 &#xff08;11&#xff09;SAR - Parabolic SAR 抛物线指标 函数名&#xff1a;SAR 名称&#xff1a; 抛物线指标 简介&#xff1a;抛物线转向也称停损点转向&#xff0c;是利用抛物线方式&#xff0c;随…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023