RabbitMq基本使用

目录

  • SpringAMQP
    • 1.准备Demo工程
    • 2.快速入门
      • 1.1.消息发送
      • 1.2.消息接收
      • 1.3.测试
    • 3.WorkQueues模型
      • 3.1.消息发送
      • 3.2.消息接收
      • 3.3.测试
      • 3.4.能者多劳
      • 3.5.总结

SpringAMQP

将来我们开发业务功能的时候，肯定不会在控制台收发消息，而是应该基于编程的方式。由于RabbitMQ采用了AMQP协议，因此它具备跨语言的特性。任何语言只要遵循AMQP协议收发消息，都可以与RabbitMQ交互。并且RabbitMQ官方也提供了各种不同语言的客户端。
但是，RabbitMQ官方提供的Java客户端编码相对复杂，一般生产环境下我们更多会结合Spring来使用。而Spring的官方刚好基于RabbitMQ提供了这样一套消息收发的模板工具：SpringAMQP。并且还基于SpringBoot对其实现了自动装配，使用起来非常方便。

SpringAmqp的官方地址：
Spring AMQP
SpringAMQP提供了三个功能：

  • 自动声明队列、交换机及其绑定关系
  • 基于注解的监听器模式，异步接收消息
  • 封装了RabbitTemplate工具，用于发送消息

这一章我们就一起学习一下，如何利用SpringAMQP实现对RabbitMQ的消息收发。

1.准备Demo工程

在父工程下建立两个新模块 consumer 和 publisher，暂时不需要添加任何依赖，使用 maven 作为管理工具。
创建项目 SpringBoot 启动依赖，名字为 ConsumerApplication 和 PublisherApplication。

package com.example.consumer;

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

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


package com.example.publisher;

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

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

用Idea打开，项目结构如图：
在这里插入图片描述

包括三部分：

  • mq-demo：父工程，管理项目依赖
  • publisher：消息的发送者
  • consumer：消息的消费者

在mq-demo这个父工程中，已经配置好了SpringAMQP相关的依赖：

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.example.demo</groupId>
    <artifactId>mq-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>publisher</module>
        <module>consumer</module>
    </modules>
    <packaging>pom</packaging>

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

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--AMQP依赖，包含RabbitMQ-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <!--单元测试-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>
</project>

因此，子工程中就可以直接使用SpringAMQP了。

2.快速入门

在之前的案例中，我们都是经过交换机发送消息到队列，不过有时候为了测试方便，我们也可以直接向队列发送消息，跳过交换机。
在入门案例中，我们就演示这样的简单模型，如图：

也就是：

  • publisher直接发送消息到队列
  • 消费者监听并处理队列中的消息

::: warning
注意：这种模式一般测试使用，很少在生产中使用。
:::

为了方便测试，我们现在控制台新建一个队列：simple.queue
添加成功：
在这里插入图片描述

接下来，我们就可以利用Java代码收发消息了。

1.1.消息发送

开启服务(之前已经创建了 docker 实例，并且名称为 myrabbitmq)

docker start myrabbitmq

首先配置MQ地址，在publisher服务的application.yml中添加配置：

spring:
  rabbitmq:
    host: 192.168.193.141 # 你的虚拟机IP
    port: 5672 # 客户端端口,之前的15672是管理界面
    virtual-host: /shen # 虚拟主机
    username: shenjie # 用户名
    password: 123456 # 密码

然后在publisher服务中编写测试类SpringAmqpTest，并利用RabbitTemplate实现消息发送：

package com.example.publisher;

import org.junit.jupiter.api.Test;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest

public class SpringAmqpTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    void testSendMessage2Queue() {
        String queueName = "simple.queue";
        String msg = "hello,amqp";
        //注意这里的消息msg可以是任意Object类型。
        rabbitTemplate.convertAndSend(queueName,msg);
    }
}

打开控制台，可以看到消息已经发送到队列中：
在这里插入图片描述

接下来，我们再来实现消息接收。

1.2.消息接收

首先配置MQ地址，在consumer服务的application.yml中添加配置：

spring:
  rabbitmq:
    host: 192.168.193.141 # 你的虚拟机IP
    port: 5672 # 端口
    virtual-host: /shen # 虚拟主机
    username: shenjie # 用户名
    password: 123456 # 密码

然后在consumer服务的com.itheima.example.listener包中新建一个类SpringRabbitListener，代码如下：

package com.example.consumer.listeners;


import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class MqListenerTest {

    @RabbitListener(queues = {"simple.queue"})
    public void listenSimpleQueue(String msg){//取决于消息发送的类型，spring 自动转换消息类型
        // 利用RabbitListener来声明要监听的队列信息
        // 将来一旦监听的队列中有了消息，就会推送给当前服务，调用当前方法，处理消息。
        // 可以看到方法体中接收的就是消息体的内容
        System.out.println("spring 消费者接收到消息：【" + msg + "】");
    }

}

1.3.测试

启动consumer服务，然后在publisher服务中运行测试代码，发送MQ消息。最终consumer收到消息：
在这里插入图片描述

3.WorkQueues模型

Work queues，任务模型。简单来说就是让多个消费者绑定到一个队列，共同消费队列中的消息。

当消息处理比较耗时的时候，可能生产消息的速度会远远大于消息的消费速度。长此以往，消息就会堆积越来越多，无法及时处理。
此时就可以使用work 模型，多个消费者共同处理消息处理，消息处理的速度就能大大提高了。

接下来，我们就来模拟这样的场景。
首先，我们在控制台创建一个新的队列，命名为work.queue：
在这里插入图片描述

3.1.消息发送

这次我们循环发送，模拟大量消息堆积现象。
在publisher服务中的SpringAmqpTest类中添加一个测试方法：

/**
     * workQueue
     * 向队列中不停发送消息，模拟消息堆积。
     */
@Test
public void testWorkQueue() throws InterruptedException {
    // 队列名称
    String queueName = "simple.queue";
    // 消息
    String message = "hello, message_";
    for (int i = 0; i < 50; i++) {
        // 发送消息，每20毫秒发送一次，相当于每秒发送50条消息
        rabbitTemplate.convertAndSend(queueName, message + i);
        Thread.sleep(20);
    }
}

3.2.消息接收

要模拟多个消费者绑定同一个队列，我们在consumer服务的SpringRabbitListener中添加2个新的方法：

@RabbitListener(queues = "work.queue")
public void listenWorkQueue1(String msg) throws InterruptedException {
    System.out.println("消费者1接收到消息：【" + msg + "】" + LocalTime.now());
    Thread.sleep(20);
}

@RabbitListener(queues = "work.queue")
public void listenWorkQueue2(String msg) throws InterruptedException {
    System.err.println("消费者2........接收到消息：【" + msg + "】" + LocalTime.now());
    Thread.sleep(200);
}

注意到这两消费者，都设置了Thead.sleep，模拟任务耗时：

  • 消费者1 sleep了20毫秒，相当于每秒钟处理50个消息
  • 消费者2 sleep了200毫秒，相当于每秒处理5个消息

3.3.测试

启动ConsumerApplication后，在执行publisher服务中刚刚编写的发送测试方法testWorkQueue。
最终结果如下：

消费者1接收到消息：【hello, message_0】21:06:00.869555300
消费者2........接收到消息：【hello, message_1】21:06:00.884518
消费者1接收到消息：【hello, message_2】21:06:00.907454400
消费者1接收到消息：【hello, message_4】21:06:00.953332100
消费者1接收到消息：【hello, message_6】21:06:00.997867300
消费者1接收到消息：【hello, message_8】21:06:01.042178700
消费者2........接收到消息：【hello, message_3】21:06:01.086478800
消费者1接收到消息：【hello, message_10】21:06:01.087476600
消费者1接收到消息：【hello, message_12】21:06:01.132578300
消费者1接收到消息：【hello, message_14】21:06:01.175851200
消费者1接收到消息：【hello, message_16】21:06:01.218533400
消费者1接收到消息：【hello, message_18】21:06:01.261322900
消费者2........接收到消息：【hello, message_5】21:06:01.287003700
消费者1接收到消息：【hello, message_20】21:06:01.304412400
消费者1接收到消息：【hello, message_22】21:06:01.349950100
消费者1接收到消息：【hello, message_24】21:06:01.394533900
消费者1接收到消息：【hello, message_26】21:06:01.439876500
消费者1接收到消息：【hello, message_28】21:06:01.482937800
消费者2........接收到消息：【hello, message_7】21:06:01.488977100
消费者1接收到消息：【hello, message_30】21:06:01.526409300
消费者1接收到消息：【hello, message_32】21:06:01.572148
消费者1接收到消息：【hello, message_34】21:06:01.618264800
消费者1接收到消息：【hello, message_36】21:06:01.660780600
消费者2........接收到消息：【hello, message_9】21:06:01.689189300
消费者1接收到消息：【hello, message_38】21:06:01.705261
消费者1接收到消息：【hello, message_40】21:06:01.746927300
消费者1接收到消息：【hello, message_42】21:06:01.789835
消费者1接收到消息：【hello, message_44】21:06:01.834393100
消费者1接收到消息：【hello, message_46】21:06:01.875312100
消费者2........接收到消息：【hello, message_11】21:06:01.889969500
消费者1接收到消息：【hello, message_48】21:06:01.920702500
消费者2........接收到消息：【hello, message_13】21:06:02.090725900
消费者2........接收到消息：【hello, message_15】21:06:02.293060600
消费者2........接收到消息：【hello, message_17】21:06:02.493748
消费者2........接收到消息：【hello, message_19】21:06:02.696635100
消费者2........接收到消息：【hello, message_21】21:06:02.896809700
消费者2........接收到消息：【hello, message_23】21:06:03.099533400
消费者2........接收到消息：【hello, message_25】21:06:03.301446400
消费者2........接收到消息：【hello, message_27】21:06:03.504999100
消费者2........接收到消息：【hello, message_29】21:06:03.705702500
消费者2........接收到消息：【hello, message_31】21:06:03.906601200
消费者2........接收到消息：【hello, message_33】21:06:04.108118500
消费者2........接收到消息：【hello, message_35】21:06:04.308945400
消费者2........接收到消息：【hello, message_37】21:06:04.511547700
消费者2........接收到消息：【hello, message_39】21:06:04.714038400
消费者2........接收到消息：【hello, message_41】21:06:04.916192700
消费者2........接收到消息：【hello, message_43】21:06:05.116286400
消费者2........接收到消息：【hello, message_45】21:06:05.318055100
消费者2........接收到消息：【hello, message_47】21:06:05.520656400
消费者2........接收到消息：【hello, message_49】21:06:05.723106700

可以看到消费者1和消费者2竟然每人消费了25条消息：

  • 消费者1很快完成了自己的25条消息
  • 消费者2却在缓慢的处理自己的25条消息。

也就是说消息是平均分配给每个消费者，并没有考虑到消费者的处理能力。导致1个消费者空闲，另一个消费者忙的不可开交。没有充分利用每一个消费者的能力，最终消息处理的耗时远远超过了1秒。这样显然是有问题的。

3.4.能者多劳

消费者消息推送限制默认情况下，RabbitMQ的会将消息依次轮询投递给绑定在队列上的每一个消费者。但这并没有考虑到消费者是否已经处理完消息，可能出现消息堆积。
在spring中有一个简单的配置，可以解决这个问题。我们修改consumer服务的application.yml文件，添加配置：

spring:
  rabbitmq:
    listener:
      simple:
        prefetch: 1 # 每次只能获取一条消息，处理完成才能获取下一个消息

再次测试，发现结果如下：

消费者1接收到消息：【hello, message_0】21:12:51.659664200
消费者2........接收到消息：【hello, message_1】21:12:51.680610
消费者1接收到消息：【hello, message_2】21:12:51.703625
消费者1接收到消息：【hello, message_3】21:12:51.724330100
消费者1接收到消息：【hello, message_4】21:12:51.746651100
消费者1接收到消息：【hello, message_5】21:12:51.768401400
消费者1接收到消息：【hello, message_6】21:12:51.790511400
消费者1接收到消息：【hello, message_7】21:12:51.812559800
消费者1接收到消息：【hello, message_8】21:12:51.834500600
消费者1接收到消息：【hello, message_9】21:12:51.857438800
消费者1接收到消息：【hello, message_10】21:12:51.880379600
消费者2........接收到消息：【hello, message_11】21:12:51.899327100
消费者1接收到消息：【hello, message_12】21:12:51.922828400
消费者1接收到消息：【hello, message_13】21:12:51.945617400
消费者1接收到消息：【hello, message_14】21:12:51.968942500
消费者1接收到消息：【hello, message_15】21:12:51.992215400
消费者1接收到消息：【hello, message_16】21:12:52.013325600
消费者1接收到消息：【hello, message_17】21:12:52.035687100
消费者1接收到消息：【hello, message_18】21:12:52.058188
消费者1接收到消息：【hello, message_19】21:12:52.081208400
消费者2........接收到消息：【hello, message_20】21:12:52.103406200
消费者1接收到消息：【hello, message_21】21:12:52.123827300
消费者1接收到消息：【hello, message_22】21:12:52.146165100
消费者1接收到消息：【hello, message_23】21:12:52.168828300
消费者1接收到消息：【hello, message_24】21:12:52.191769500
消费者1接收到消息：【hello, message_25】21:12:52.214839100
消费者1接收到消息：【hello, message_26】21:12:52.238998700
消费者1接收到消息：【hello, message_27】21:12:52.259772600
消费者1接收到消息：【hello, message_28】21:12:52.284131800
消费者2........接收到消息：【hello, message_29】21:12:52.306190600
消费者1接收到消息：【hello, message_30】21:12:52.325315800
消费者1接收到消息：【hello, message_31】21:12:52.347012500
消费者1接收到消息：【hello, message_32】21:12:52.368508600
消费者1接收到消息：【hello, message_33】21:12:52.391785100
消费者1接收到消息：【hello, message_34】21:12:52.416383800
消费者1接收到消息：【hello, message_35】21:12:52.439019
消费者1接收到消息：【hello, message_36】21:12:52.461733900
消费者1接收到消息：【hello, message_37】21:12:52.485990
消费者1接收到消息：【hello, message_38】21:12:52.509219900
消费者2........接收到消息：【hello, message_39】21:12:52.523683400
消费者1接收到消息：【hello, message_40】21:12:52.547412100
消费者1接收到消息：【hello, message_41】21:12:52.571191800
消费者1接收到消息：【hello, message_42】21:12:52.593024600
消费者1接收到消息：【hello, message_43】21:12:52.616731800
消费者1接收到消息：【hello, message_44】21:12:52.640317
消费者1接收到消息：【hello, message_45】21:12:52.663111100
消费者1接收到消息：【hello, message_46】21:12:52.686727
消费者1接收到消息：【hello, message_47】21:12:52.709266500
消费者2........接收到消息：【hello, message_48】21:12:52.725884900
消费者1接收到消息：【hello, message_49】21:12:52.746299900

可以发现，由于消费者1处理速度较快，所以处理了更多的消息；消费者2处理速度较慢，只处理了6条消息。而最终总的执行耗时也在1秒左右，大大提升。
正所谓能者多劳，这样充分利用了每一个消费者的处理能力，可以有效避免消息积压问题。

3.5.总结

Work模型的使用：

  • 多个消费者绑定到一个队列，可以加快消息处理速度，同一条消息只会被一个消费者处理。
  • 通过设置prefetch来控制消费者预取的消息数量。

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

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

相关文章

ArrayList与LinkLIst

ArrayList与LinkLIst

ArrayList 在Java中&#xff0c;ArrayList是java.util包中的一个类&#xff0c;它实现了List接口&#xff0c;是一个动态数组&#xff0c;可以根据需要自动增长或缩小。下面是ArrayList的一些基本特性以及其底层原理的简要讲解&#xff1a; ArrayList基本特性&#xff1a; 动…
阅读更多...
科大讯飞（深圳）测开面试真题

科大讯飞（深圳）测开面试真题

一面&#xff08;测试组长面&#xff09; 1、上家公司项目以及团队的规模是怎么样的&#xff1f; 2、你负责的项目整体的流程是怎么样的&#xff1f; 3、自动化实施过程中&#xff0c;是如何和业务测试进行沟通的&#xff1f; 4、在上家公司你已经是专职做自动化了&#xf…
阅读更多...
会声会影怎么使用? 会声会影2024快速掌握入门技巧

会声会影怎么使用? 会声会影2024快速掌握入门技巧

一听说视频剪辑我们就不由得联想到电影、电视等一些高端的视频剪辑技术&#xff0c;大家都觉得视频剪辑是一个非常复杂而且需要很昂贵的设备才可以完成的技术活&#xff0c;这对很多“门外汉”来说都可望而不可及。实际上&#xff0c;使用会声会影剪辑视频不仅是很多人都可以操…
阅读更多...
《面向机器学习的数据标注规程》摘录

《面向机器学习的数据标注规程》摘录

说明&#xff1a;本文使用的标准是2019年的团体标准&#xff0c;最新的国家标准已在2023年发布。 3 术语和定义 3.2 标签 label 标识数据的特征、类别和属性等。 3.4 数据标注员 data labeler 对待标注数据进行整理、纠错、标记和批注等操作的工作人员。 【批注】按照定义…
阅读更多...
【话题】低代码123

【话题】低代码123

目录 一、什么是低代码 二、低代码的优缺点 三、你认为低代码会替代传统编程吗&#xff1f; 四、有哪些低代码工具和框架 4.1 国外的平台 4.2 国内的平台 五、未来的软件研发 低代码&#xff0c;听着就过瘾的一个词。而且不是无代码&#xff0c;这说明&#xff0c;低代码…
阅读更多...
GoogLeNet(pytorch)

GoogLeNet(pytorch)

亮点与创新&#xff1a; 1. 引入Inception基础结构 2. 引入PW维度变换卷积&#xff0c;启迪后续参数量的优化 3. 丢弃全连接层&#xff0c;使用平均池化层&#xff08;大大减少模型参数&#xff09; 4. 添加两个辅助分类器帮助训练&#xff08;避免梯度消失&#xff0c;用于…
阅读更多...
方舟无限ARX-5臂的奇异验证

方舟无限ARX-5臂的奇异验证

事情起因是&#xff0c;某技术人员号称这款机械臂无奇异点&#xff0c;博主当场一个【黑人问号脸】。 既然是串联臂&#xff0c;大概很难做到无奇异点~ 为了反驳&#xff0c;博主建模简单分析了下&#xff0c;偏置参数随便写了个&#xff0c;具体验证程序见文末。 clear,clc,…
阅读更多...
共同编辑文档功能实现（websocket）

共同编辑文档功能实现（websocket）

目录 前言 websocket封装 wangeditor下载 共同编辑文档代码实现 HTML样式部分 JS部分 css部分 前言 功能&#xff1a;实现文档共同编辑功能&#xff0c;可以实时接收到其他人的信息 思路&#xff1a;先调用接口获取相应的数据进行渲染&#xff0c;然后通过webSocket建…
阅读更多...
C#基础知识 - 基本语法篇

C#基础知识 - 基本语法篇

C#基础知识-基本语法篇 第2节 C#基本语法2.1 C#程序结构2.2 C# 结构解析2.3 命名空间及标识符、关键字2.3.1 别名的使用2.3.2 标识符2.3.3 C#关键字 更多C#基础知识详解请查看&#xff1a;C#基础知识 - 从入门到放弃 第2节 C#基本语法 2.1 C#程序结构 “Hello, World”程序历…
阅读更多...
棋牌的电脑计时计费管理系统教程，棋牌灯控管理软件操作教程

棋牌的电脑计时计费管理系统教程，棋牌灯控管理软件操作教程

一、前言 有的棋牌室在计时的时候&#xff0c;需要使用灯控管理&#xff0c;在开始计时的时候打开灯&#xff0c;在结账后关闭灯&#xff0c;也有的不需要用灯控&#xff0c;只用来计时。 下面以 佳易王棋牌计时计费管理系统软件为例说明&#xff1a; 软件试用版下载或技术支…
阅读更多...
Java架构师系统架构高可用维度分析

Java架构师系统架构高可用维度分析

目录 1 导语2 可用性介绍3 本地高可用-集群、分布式4 本地高可用-数据逻辑保护5 异地容灾-双活、两地三中心6 异地容灾-DRP规划&BCP业务连续性7 多活和妥协方案8 高可用流程9 总结想学习架构师构建流程请跳转：Java架构师系统架构设计 1 导语 Java架构师在进行系统架构设…
阅读更多...
ELk（七）—部署Nginx

ELk（七）—部署Nginx

目录 部署Nginxfilebeat启动Nginx模块Module对nginx模块配置进行修改修改nginx-log.yml配置文件 部署Nginx 下面是nginx的安装脚本&#xff0c;里面的参数可以根据实际需要进行修改。 #!/bin/bash#新建一个文件夹用来存放下载的nginx源码包mkdir -p /opt/nginx cd /opt/nginx…
阅读更多...
Android Studio 软件如何将系统自带的标题栏隐藏

Android Studio 软件如何将系统自带的标题栏隐藏

目录 一、实现效果 二、开发环境 三、实现方法 ①首先创建一个新的项目 ②打开你需要隐藏标题栏的Activity ③我们看下正常的显示效果 ④然后在onCreate中进行代码编写 ⑤点击运行查询看效果 三、Android Studio 模板 一、实现效果 二、开发环境 三、实现方法 在Andro…
阅读更多...
千帆竞渡，鸿蒙已过万重山

千帆竞渡，鸿蒙已过万重山

近期&#xff0c;华为宣布其自主研发的鸿蒙Next系统将不再兼容Android系统&#xff0c;而是完全独立运营。 也就是说&#xff0c;你的 Android APK 已经不能在 HarmonyOS NEXT 上运行&#xff0c;因为系统已经不存在 AOSP 代码&#xff0c;甚至没有 JVM。 此举意味着鸿蒙系统…
阅读更多...
pytorch网络的增删改

pytorch网络的增删改

本文介绍对加载的网络的层进行增删改, 以alexnet网络为例进行介绍。 1. 加载网络 import torchvision.models as models alexnet models.alexnet(weightsmodels.AlexNet_Weights.DEFAULT) print(alexnet)2. 删除网络 在做迁移学习的时候&#xff0c;我们通常是在分类网络的…
阅读更多...
为uniDBGrid设置文字操作栏

为uniDBGrid设置文字操作栏

为uniDBGrid设置文字操作栏&#xff0c;如下图的效果&#xff0c;用户点击审核&#xff0c;执行审核代码&#xff0c;点退回&#xff0c;执行退回代码&#xff1a; 对于Web应用界面&#xff0c;这是最常见的方式&#xff0c;那对于我等Delphi开发者来说&#xff0c;基于uniGUI该…
阅读更多...
贝蒂详解＜string.h＞哦~（用法与实现）

贝蒂详解＜string.h＞哦~（用法与实现）

目录 引言&#xff1a; &#xff08;一&#xff09;字符函数和字符串函数 1.简介 2.strlen()函数 2.1用法 2.2实例 2.3 实现strlen() &#xff08;1&#xff09;计数法 &#xff08;2&#xff09;递归法 &#xff08;3&#xff09; 指针-指针 2.4sizeof和strlen()的区别 3.s…
阅读更多...
车规MCU应用场景及国产替代进展

车规MCU应用场景及国产替代进展

目录 1.车规MCU应用场景 1.1 车身域 1.2 动力底盘域 1.3 座舱域和智驾域 1.4 网联域 2.国产替代进展 3.小结 前面一篇文章征途漫漫:汽车MCU的国产替代往事-CSDN博客对车规MCU国产替代的背景与一些往事进行了简单叙述&#xff0c;今天来聊聊车规MCU具体会在汽车哪些地方用…
阅读更多...
金智融门户（统一身份认证）同步数据至钉钉通讯录

金智融门户（统一身份认证）同步数据至钉钉通讯录

前言：因全面使用金智融门户和数据资产平台，二十几个信息系统已实现统一身份认证和数据同步，目前单位使用的钉钉尚未同步组织机构和用户信息，职工入职、离职、调岗时都需要手工在钉钉后台操作，一是操作繁琐，二是钉钉通讯录更新不及时或经常遗漏，带来管理问题。通过金智融…
阅读更多...
基于JavaEE智能实时疫情监管服务平台设计与实现

基于JavaEE智能实时疫情监管服务平台设计与实现

末尾获取源码 开发语言&#xff1a;Java Java开发工具&#xff1a;JDK1.8 后端框架&#xff1a;SSM 前端&#xff1a;采用JSP技术开发 数据库&#xff1a;MySQL5.7和Navicat管理工具结合 服务器&#xff1a;Tomcat8.5 开发软件&#xff1a;IDEA / Eclipse 是否Maven项目&#x…
阅读更多...
最新文章

Copyright @ 2022~2023