2024.2.27 模拟实现 RabbitMQ —— 网络通信设计（客户端）

目录

需求分析

RabbitMQ 客户端设定

ConnectionFactory（连接工厂）

Connection（连接）

Channel（通道）

针对 客户端 和 服务器 单元测试

需求分析

RabbitMQ 客户端设定

  • 一个客户端可以有多个模块
  • 每个模块均可以和 Broker Server 之间建立 "逻辑上的连接"（channel）
  • 这几个模块的 channel 彼此之间是相互不影响的
  • 同时这几个 channel 复用了同一个 TCP 连接
  • 此处我们将仿照 RabbitMQ 客户端设定

ConnectionFactory（连接工厂）

  • 这个类持有服务器的地址
  • 该类用于创建 Connection 对象

具体代码编写：

import lombok.Getter;
import lombok.Setter;

import java.io.IOException;

@Getter
@Setter
public class ConnectionFactory {
//    broker server 的 ip 地址
    private String host;
//    broker server 的端口号
    private int port;

    public Connection newConnection() throws IOException {
        Connection connection = new Connection(host,port);
        return connection;
    }

//    访问 broker server 的哪个虚拟主机
//    下列几个属性暂时先不搞了
//    private String virtualHostName;
//    private String username;
//    private String password;
}

Connection（连接）

  • 这个类表示一个 TCP 连接，持有 Socket 对象
  • 该类用于写入请求/读取响应，管理多个 Channel 对象

具体代码编写：

  • 编写成员变量
    private Socket socket = null;
//    需要管理多个 channel 使用一个 hash 表把若干个 channel 组织起来
    private ConcurrentHashMap<String,Channel> channelMap = new ConcurrentHashMap<>();

    private InputStream inputStream;
    private OutputStream outputStream;
    private DataOutputStream dataOutputStream;
    private DataInputStream dataInputStream;

//用来处理 0xc 的回调，这里开销可能会很大，不希望把 扫描线程 阻塞住，因此使用 线程池 来处理
    private ExecutorService callbackPool = null;
  • 编写构造方法
  • 此处不仅需要初始化成员变量，还需创建一个扫描线程，不停的从 socket 中读取响应数据，并将读取到的响应交给 dispatchResponse 方法执行
 public Connection(String host, int port) throws IOException {
        socket = new Socket(host,port);
        inputStream = socket.getInputStream();
        outputStream = socket.getOutputStream();
        dataInputStream = new DataInputStream(inputStream);
        dataOutputStream = new DataOutputStream(outputStream);

        callbackPool = Executors.newFixedThreadPool(4);

//        创建一个 扫描线程，由这个线程负责不停的从 socket 中取响应数据 把这个响应数据再交给对应的 channel 负责处理
        Thread t = new Thread(() -> {
            try {
                while (!socket.isClosed()) {
                    Response response = readResponse();
                    dispatchResponse(response);
                }
            }catch (SocketException e) {
//                连接正常断开，此时这个异常直接忽略
                System.out.println("[Connection] 连接正常断开！");
            }catch (IOException | ClassNotFoundException | MqException e) {
                System.out.println("[Connection] 连接异常断开！");
                e.printStackTrace();
            }
        });
        t.start();
    }
  • 编写 dispatchResponse 方法
  • 使用该方法来区分，当前响应是一个针对控制请求的响应，还是服务器推送过来的消息
  • 如果是服务器推送过来的消息，type = 0xc，也就需要执行回调，通过线程池来执行
  • 如果只是一个普通的响应，就将该结果放到 channel 的 哈希表中
  • 随后 channel 的 putReturns 方法会唤醒所有阻塞等待的线程，让这些线程从 哈希表中拿与自己 rid 相等的返回结果
//    使用这个方法来分别处理，当前的响应是一个针对控制请求的响应，还是服务器推送的消息
    private void dispatchResponse(Response response) throws IOException, ClassNotFoundException, MqException {
        if(response.getType() == 0xc) {
//            服务器推送来的消息数据
            SubScribeReturns subScribeReturns = (SubScribeReturns) BinaryTool.fromBytes(response.getPayload());
//            根据 channelId 找到对应的 channel 对象
            Channel channel = channelMap.get(subScribeReturns.getChannelId());
            if(channel == null) {
                throw new MqException("[Connection] 该消息对应的 channel 在客户端中不存在！channelId = " + channel.getChannelId());
            }
//            执行该 channel 对象内部的回调
//            此处我们直接将回调方法交给线程池来执行，而不是用扫描线程来执行
            callbackPool.submit(() -> {
                try {
                    channel.getConsumer().handleDelivery(subScribeReturns.getConsumerTag(),subScribeReturns.getBasicProperties(),
                            subScribeReturns.getBody());
                } catch (MqException | IOException e) {
                    e.printStackTrace();
                }
            });
        }else {
//            当前响应是针对刚才控制请求的响应
            BasicReturns basicReturns = (BasicReturns) BinaryTool.fromBytes(response.getPayload());
//            把这个结果放到对应的 channel 的 hash 表中
            Channel channel = channelMap.get(basicReturns.getChannelId());
            if(channel == null) {
                throw new MqException("[Connection] 该消息对应的 channel 在客户端中不存在！channelId = " + channel.getChannelId());
            }
            channel.putReturns(basicReturns);
        }
    }
  • 编写 发送请求 与 读取响应 的方法
//    发送请求
    public void writeRequest(Request request) throws IOException {
        dataOutputStream.writeInt(request.getType());
        dataOutputStream.writeInt(request.getLength());
        dataOutputStream.write(request.getPayload());
        dataOutputStream.flush();
        System.out.println("[Connection] 发送请求！ type = " + request.getType() + ",length = " + request.getLength());
    }

//    读取响应
    public Response readResponse() throws IOException {
        Response response = new Response();
        response.setType(dataInputStream.readInt());
        response.setLength(dataInputStream.readInt());
        byte[] payload = new byte[response.getLength()];
        int n = dataInputStream.read(payload);
        if(n != payload.length) {
            throw new IOException("读取的响应数据不完整！");
        }
        response.setPayload(payload);
        System.out.println("[Connection] 收到响应！ type = " + response.getType() + ",length = " + response.getLength());
        return response;
    }
  • 编写创建 channel 的方法

注意：

  • 我们的代码中使用了多次 UUID 
  • message 的 id，就是用 UUID 当时加了个 M- 前缀
  • 现在 channel 的 id 也是使用 UUID 此时加个 C- 前缀
  • rid 也使用 UUID 来生成，加个前缀  R-
//    通过这个方法，在 Connection 中能够创建出一个 Channel
    public Channel createChannel() throws IOException, InterruptedException {
        String channelId = "C-" + UUID.randomUUID().toString();
        Channel channel = new Channel(channelId,this);
//        把这个 channel 对象放到 Connection 管理 channel 的 哈希表 中
        channelMap.put(channelId,channel);
//        同时也需要把 创建 channel 的这个消息也告诉服务器
        boolean ok = channel.createChannel();
        if(!ok) {
//            服务器这里创建失败了！！整个这次创建 channel 操作不顺利！
//            把刚才已经加入 hash 表的键值对，再删了
            channelMap.remove(channelId);
            return null;
        }
        return channel;
    }
  • 编写释放 Connection 相关资源的方法
    public void close() {
//        关闭 Connection 释放上述资源
        try {
            callbackPool.shutdownNow();
            channelMap.clear();
            inputStream.close();
            outputStream.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

Channel（通道）

  • 这个类表示一个逻辑上的连接

  • 该类用于提供一系列的方法，去和服务器提供的核心 API 相对应

  • 客户端提供的这些方法，其方法内部就是发送了一个特定的请求

具体代码编写：

  • 编写成员变量  与 构造方法
    private String channelId;
//    当前这个 channel 属于哪个连接的
    private Connection connection;
//    用来存储后续客户端收到的服务器的响应
    private ConcurrentHashMap<String, BasicReturns> basicReturnsMap = new ConcurrentHashMap<>();
//    如果当前 Channel 订阅了某个队列，就需要在此处记录下对应回调是啥，当该队列的消息返回回来的时候，调用回调
//    此处约定一个 Channel 中只能有一个回调
    private Consumer consumer = null;

    public Channel(String channelId,Connection connection) {
        this.channelId = channelId;
        this.connection = connection;
    }
  • 实现 type = 0x1，即创建 channel
  • 构造请求发给服务器，随后阻塞等待，唤醒后从 basicReturnsMap 中尝试获取响应结果
  • 其余 type （0xc 除外，因为 0xc 只有响应没有请求）类型的请求与 0x1 大差不差，对着所需参数，构造即可
//    在这个方法中，和服务器进行交互，告知服务器，此处客户端创建了新的 channel 了
    public Boolean createChannel() throws IOException, InterruptedException {
//        对于创建 Channel 来说，
        BasicArguments basicArguments = new BasicArguments();
        basicArguments.setChannelId(channelId);
        basicArguments.setRid(generateRid());
        byte[] payload = BinaryTool.toBytes(basicArguments);

        Request request = new Request();
        request.setType(0x1);
        request.setLength(payload.length);
        request.setPayload(payload);

//        构造出完整请求之后，就可以发送这个请求了
        connection.writeRequest(request);
//        等待服务器的响应
        BasicReturns basicReturns = waitResult(basicArguments.getRid());
        return basicReturns.isOk();
    }

    private String generateRid() {
        return "R-" + UUID.randomUUID().toString();
    }

//    期望使用这个方法来阻塞等待服务器的响应
    private BasicReturns waitResult(String rid) throws InterruptedException {
        BasicReturns basicReturns = null;
        while ((basicReturns = basicReturnsMap.get(rid)) == null) {
//            如果查询结果为 null，说明响应还没回来
//            此时就需要阻塞等待
            synchronized (this) {
                wait();
            }
        }
//        读取成功之后，还需要把这个消息从 哈希表中给删除掉
        basicReturnsMap.remove(rid);
        System.out.println("[Channel] 获取到服务器响应！rid = " + rid);
        return basicReturns;
    }

    public void putReturns(BasicReturns basicReturns) {
        basicReturnsMap.put(basicReturns.getRid(),basicReturns);
        synchronized (this) {
//            当前也不知道有多少个线程在等待上述的这个响应
//            把所有的等待的线程都唤醒
            notifyAll();
        }
    }
  • 特别注意 type = 0xa ，即 订阅消息

  • 其次值得注意的是 consumerTag 使用 channelId 来表示
//    订阅消息
    public boolean basicConsume(String queueName, boolean autoAck, Consumer consumer) throws MqException, IOException, InterruptedException {
//        先设置回调
        if(this.consumer != null) {
            throw new MqException("该 channel 已经设置过消费消息的回调了，不能重复设置！");
        }
        this.consumer = consumer;
        BasicConsumeArguments basicConsumeArguments = new BasicConsumeArguments();
        basicConsumeArguments.setRid(generateRid());
        basicConsumeArguments.setChannelId(channelId);
//        此处 ConsumerTag 也使用 channelId 来表示
        basicConsumeArguments.setConsumerTag(channelId);
        basicConsumeArguments.setQueueName(queueName);
        basicConsumeArguments.setAutoAck(autoAck);
        byte[] payload = BinaryTool.toBytes(basicConsumeArguments);

        Request request = new Request();
        request.setType(0xa);
        request.setLength(payload.length);
        request.setPayload(payload);

        connection.writeRequest(request);
        BasicReturns basicReturns = waitResult(basicConsumeArguments.getRid());
        return basicReturns.isOk();
    }

针对 客户端 和 服务器 单元测试

  • 编写测试用例代码是十分重要的！
package com.example.demo;

import com.example.demo.common.Consumer;
import com.example.demo.common.MqException;
import com.example.demo.mqclient.Channel;
import com.example.demo.mqclient.Connection;
import com.example.demo.mqclient.ConnectionFactory;
import com.example.demo.mqserver.BrokerServer;
import com.example.demo.mqserver.core.BasicProperties;
import com.example.demo.mqserver.core.ExchangeType;
import org.apache.tomcat.util.http.fileupload.FileUtils;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.boot.SpringApplication;

import java.io.File;
import java.io.IOException;

public class MqClientTests {
    private BrokerServer brokerServer = null;
    private ConnectionFactory connectionFactory = null;
    private Thread t = null;

    @BeforeEach
    public void setUp() throws IOException {
//        1、先启动服务器
        DemoApplication.context = SpringApplication.run(DemoApplication.class);
        brokerServer = new BrokerServer(9090);
        t = new Thread(() -> {
//        这个 start 方法会进入一个死循环，使用一个新的线程来运行 start 即可！
            try {
                brokerServer.start();
            } catch (IOException e) {
                e.printStackTrace();
            }
        });
        t.start();

//        2、配置 ConnectionFactory
        connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(9090);

    }

    @AfterEach
    public void tearDown() throws IOException {
//        停止服务器
        brokerServer.stop();
//        t.join();
        DemoApplication.context.close();

//        删除必要的文件
        File file = new File("./data");
        FileUtils.deleteDirectory(file);

        connectionFactory = null;
    }

    @Test
    public void testConnection() throws IOException {
        Connection connection = connectionFactory.newConnection();
        Assertions.assertNotNull(connection);
    }

    @Test
    public void testChannel() throws IOException, InterruptedException {
        Connection connection = connectionFactory.newConnection();
        Assertions.assertNotNull(connection);
        Channel channel = connection.createChannel();
        Assertions.assertNotNull(channel);
    }

    @Test
    public void testExchange() throws IOException, InterruptedException {
        Connection connection = connectionFactory.newConnection();
        Assertions.assertNotNull(connection);
        Channel channel = connection.createChannel();
        Assertions.assertNotNull(channel);

        boolean ok = channel.exchangeDeclare("testExchange", ExchangeType.DIRECT,true,false,null);
        Assertions.assertTrue(ok);

        ok = channel.exchangeDelete("testExchange");
        Assertions.assertTrue(ok);

//        此处稳妥起见，把该关闭的要进行关闭
        channel.close();
        connection.close();
    }

    @Test
    public void testQueue() throws IOException, InterruptedException{
        Connection connection = connectionFactory.newConnection();
        Assertions.assertNotNull(connection);
        Channel channel = connection.createChannel();
        Assertions.assertNotNull(channel);

        boolean ok = channel.queueDeclare("testQueue",true,false,false,null);
        Assertions.assertTrue(ok);

        ok = channel.queueDelete("testQueue");
        Assertions.assertTrue(ok);

        channel.close();
        connection.close();
    }

    @Test
    public void testBinding() throws IOException, InterruptedException{
        Connection connection = connectionFactory.newConnection();
        Assertions.assertNotNull(connection);
        Channel channel = connection.createChannel();
        Assertions.assertNotNull(channel);

        boolean ok = channel.exchangeDeclare("testExchange", ExchangeType.DIRECT,true,false,null);
        Assertions.assertTrue(ok);

        ok = channel.queueDeclare("testQueue",true,false,false,null);
        Assertions.assertTrue(ok);

        ok = channel.queueBind("testQueue","testExchange","testBindingKey");
        Assertions.assertTrue(ok);

        ok = channel.queueUnbind("testQueue","testExchange");
        Assertions.assertTrue(ok);

        channel.close();
        connection.close();
    }

    @Test
    public void testMessage() throws IOException, InterruptedException, MqException {
        Connection connection = connectionFactory.newConnection();
        Assertions.assertNotNull(connection);
        Channel channel = connection.createChannel();
        Assertions.assertNotNull(channel);

        boolean ok = channel.exchangeDeclare("testExchange", ExchangeType.DIRECT,true,false,null);
        Assertions.assertTrue(ok);

        ok = channel.queueDeclare("testQueue",true,false,false,null);
        Assertions.assertTrue(ok);

        byte[] requestBody = "hello".getBytes();
        ok = channel.basicPublish("testExchange","testQueue",null,requestBody);
        Assertions.assertTrue(ok);

        channel.basicConsume("testQueue", true, new Consumer() {
            @Override
            public void handleDelivery(String consumerTag, BasicProperties basicProperties, byte[] body) throws MqException, IOException {
                System.out.println("[消费数据] 开始！");
                System.out.println("consumeTag = " + consumerTag);
                System.out.println("basicProperties = " + basicProperties);
                Assertions.assertArrayEquals(requestBody,body);
                System.out.println("[消费数据] 结束！");
            }
        });
        Assertions.assertTrue(ok);

        Thread.sleep(500);

        channel.close();
        connection.close();
    }
}

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

HuggingFists系统功能介绍(5)--环境资源

HuggingFists系统功能介绍(5)--环境资源

模型库 模型库用于管理由HuggingFists系统自己生成的或者外部导入的各种模型。如&#xff1a;HuggingFace网站提供的各类模型可导入该模块进行统一管理及部署。该功能目前在HuggingFists的社区版中并未提供。 环境管理 环境管理-工作节点 环境管理-服务配置 环境管理主要用于与…
阅读更多...
KubeSphere 镜像构建器（S2I）服务证书过期解决方案

KubeSphere 镜像构建器（S2I）服务证书过期解决方案

目前 KubeSphere 所有 3.x.x 版本&#xff0c;如果开启了 DevOps 模块并使用了镜像构建器功能&#xff08;S2I&#xff09;都会遇到证书过期问题。 解决方法 已开启 DevOps 模块 下载这个更新 S2I 服务证书压缩包&#xff0c;上传到任一可以访问 K8s 集群的节点&#xff1b; …
阅读更多...
抖店商家每天都需要做什么？这六点内容不能少！新手建议收藏！

抖店商家每天都需要做什么？这六点内容不能少！新手建议收藏！

大家好&#xff0c;我是电商小布。 在我们开店运营的过程中&#xff0c;每天需要做的事情其实还是挺多的。 想要我们小店稳定长期的发展下去&#xff0c;有哪些必做的内容呢&#xff1f; 今天&#xff0c;小布就根据我们自己做店几年的经验&#xff0c;来带大家详细的了解一…
阅读更多...
Linux-实用操作(黑马学习笔记)

Linux-实用操作(黑马学习笔记)

各类小技巧&#xff08;快捷键&#xff09; ctrl c 强制停止 ● Linux某些程序的运行&#xff0c;如果想要强制停止它&#xff0c;可以使用快捷键ctrl c ● 命令输入错误&#xff0c;也可以通过快捷键ctrl c&#xff0c;退出当前输入&#xff0c;重新输入 ctrl d 退出或登…
阅读更多...
Project_Euler-24 题解

Project_Euler-24 题解

Project_Euler-24 题解 题目 思路 如果是用笔算的话&#xff0c;可以找到这样的规律&#xff1a; 对于下面的这个组合&#xff1a; 0123456789 {0123456789} 0123456789 我们将其看作一种排列情况&#xff0c;然后我们先使用微扰的方式更改变动一下其中的数值&#xff0c;具…
阅读更多...
SQL Developer 小贴士：PL/SQL语法分析

SQL Developer 小贴士：PL/SQL语法分析

对于SQL或PL/SQL中的语法错误和警告&#xff0c;SQL Developer可以用不同颜色的下划波浪线显示。 启用语法分析&#xff0c;可以用菜单Tool>Preferences>Code Editor>Completion Insight>Enable Semantic Analysis Info Tips 例如&#xff0c;以下的代码中&…
阅读更多...
linux系统---安装使用nginx

linux系统---安装使用nginx

目录 一、编译安装Nginx 1、关闭防火墙&#xff0c;将安装nginx所需要软件包传到/opt目录下 ​编辑2、安装依赖包 3、创建运行用户、组 4、编译安装nginx 5、创建软链接后直接nginx启动 ​编辑 6、创建nginx自启动文件 ​编辑6.1 重新加载配置、设置开机自启并开启服务…
阅读更多...
【开源】JAVA+Vue.js实现大病保险管理系统

【开源】JAVA+Vue.js实现大病保险管理系统

目录 一、摘要1.1 项目介绍1.2 项目录屏 二、功能模块2.1 系统配置维护2.2 系统参保管理2.3 大病保险管理2.4 大病登记管理2.5 保险审核管理 三、系统详细设计3.1 系统整体配置功能设计3.2 大病人员模块设计3.3 大病保险模块设计3.4 大病登记模块设计3.5 保险审核模块设计 四、…
阅读更多...
多线程基础说明【基础篇】

多线程基础说明【基础篇】

目录 &#x1f32d;1.相关概念 &#x1f37f;2.创建和启动线程 &#x1f95e;3.线程安全 &#x1f9c8;4.死锁 &#x1f953;5.线程通信的方法 1.相关概念 1.1程序 为完成特定任务&#xff0c;用某种语言编写的一组指令的集合。即指一段静态的代码&#xff0c;静态对象…
阅读更多...
数据结构二叉树顺序结构——堆的实现

数据结构二叉树顺序结构——堆的实现

二叉树顺序结构——堆的实现 结构体的创建以及接口函数结构体的创建堆的初始化交换函数堆的插入向上调整删除向下调整返回堆的个数返回堆顶数据判断堆是否为空 该文章以大堆作为研究对象 结构体的创建以及接口函数 typedef int HPDateType;//定义动态数组的数据类型 typedef s…
阅读更多...
Spring Cloud学习

Spring Cloud学习

1、什么是SpringCloud Spring cloud 流应用程序启动器是基于 Spring Boot 的 Spring 集成应用程序&#xff0c;提供与外部系统的集成。Spring cloud Task&#xff0c;一个生命周期短暂的微服务框架&#xff0c;用于快速构建执行有限数据处理的应用程序。Spring cloud 流应用程…
阅读更多...
Oracle ADG相关介绍

Oracle ADG相关介绍

文章目录 一、ADG原理1、ADG介绍2、ADG搭建流程 二、ADG相关参数三、增量修复 一、ADG原理 1、ADG介绍 Oracle ADG&#xff08;Advanced Data Guard&#xff09;是Oracle数据库的一项高可用和灾难恢复技术&#xff0c;它通过将数据保持在物理备库中来提供数据保护和容灾能力。…
阅读更多...
Odoo系统安装部署并结合内网穿透实现固定域名访问本地ERP系统

Odoo系统安装部署并结合内网穿透实现固定域名访问本地ERP系统

文章目录 前言1. 下载安装Odoo&#xff1a;2. 实现公网访问Odoo本地系统&#xff1a;3. 固定域名访问Odoo本地系统 前言 Odoo是全球流行的开源企业管理套件&#xff0c;是一个一站式全功能ERP及电商平台。 开源性质&#xff1a;Odoo是一个开源的ERP软件&#xff0c;这意味着企…
阅读更多...
C++ 游戏飞机大战， 字符型的

C++ 游戏飞机大战， 字符型的

//#define _CRT_SECURE_NO_WARNINGS 1 用于禁止不安全函数的警告 #include<iostream> #include<stdlib.h> #include<string> #include<conio.h> #include<Windows.h> #include<time.h> #include <graphics.h> using namespace std;…
阅读更多...
Python爬虫-付费代理推荐和使用

Python爬虫-付费代理推荐和使用

付费代理的使用 相对免费代理来说&#xff0c;付费代理的稳定性更高。本节将介绍爬虫付费代理的相关使用过程。 1. 付费代理分类 付费代理分为两类&#xff1a; 一类提供接口获取海量代理&#xff0c;按天或者按量收费&#xff0c;如讯代理。 一类搭建了代理隧道&#xff0…
阅读更多...
一元函数微分学——刷题（22

一元函数微分学——刷题（22

目录 1.题目&#xff1a;2.解题思路和步骤&#xff1a;3.总结&#xff1a;小结&#xff1a; 1.题目&#xff1a; 2.解题思路和步骤&#xff1a; 由于是极坐标方程&#xff0c;所以这个式子一定成立&#xff1a; 然后代入r即可变为参数方程的求导&#xff1a; 3.总结&#xff…
阅读更多...
52.仿简道云公式函数实战-文本函数-LEFT

52.仿简道云公式函数实战-文本函数-LEFT

1. LEFT函数 从一个文本字符串的第一个字符开始返回指定个数的字符。 2. 函数用法 LEFT(text,[num_chars]) 3. 函数示例 从一个文本字符串的第一个字符开始返回指定个数的字符。 4. 代码实战 首先我们在function包下创建text包&#xff0c;在text包下创建LeftFunction类…
阅读更多...
POST参数里加号+变成空格的问题处理

POST参数里加号+变成空格的问题处理

今天遇到个这样的问题&#xff0c;从前端传到后端的加密报文&#xff0c;里面包含了号&#xff0c;但在后端日志输出看出&#xff0c;变成空格。这个是由于经过RSA加密后引起的 解决办法&#xff1a; 1.前端转码&#xff1a;使用encodeURIComponent对参数进行转码 2.后端解码…
阅读更多...
msvcp110.dll找不到的处理方法，一键修复msvcp110.dll文件

msvcp110.dll找不到的处理方法，一键修复msvcp110.dll文件

如果你遭遇到了“msvcp110.dll文件丢失”的现象&#xff0c;那就要引起足够的重视&#xff0c;因为这通常意味着你的电脑上某些依赖此DLL文件的应用程序将无法正常启动。msvcp110.dll是许多软件中必须的组件&#xff0c;一旦发生丢失&#xff0c;影响的不仅是单个程序&#xff…
阅读更多...
Java SpringBoot 整合 MyBatis 小案例

Java SpringBoot 整合 MyBatis 小案例

Java SpringBoot 整合 MyBatis 小案例 基础配置&#xff08;注意版本号&#xff0c;容易报错&#xff09; pom.xml <?xml version"1.0" encoding"UTF-8"?> <project xmlns"http://maven.apache.org/POM/4.0.0" xmlns:xsi"http…
阅读更多...
最新文章

Copyright @ 2022~2023