RabbitMQ入门基础篇

文章目录

  • 安装 / 部署 RabbitMQ
  • 快速入门
    • 消息发送
    • 消息接收
  • WorkQueues模型
    • 消息发送
    • 消息接收
    • 能者多劳
    • 总结
  • 交换机类型
  • Fanout交换机
    • 声明队列和交换机
    • 绑定队列到交换机
    • 消息发送
    • 消息接收
    • 总结
  • Direct交换机
    • 声明队列和交换机
    • 为队列绑定相应的key
    • 消息接收
    • 消息发送
  • Topic交换机
    • 绑定队列
    • 消息接收
    • 消息发送
    • 总结
  • Java声明队列和交换机
    • fanout示例
    • direct示例
    • 基于注解声明
    • 消息转换器
  • 实战运用-hmall
    • 配置MQ
    • 配置消息转换器
    • 接收消息
    • 绑定队列与交换机
    • 发送消息

安装 / 部署 RabbitMQ

mac m1通过docker安装rabbitmq - 掘金

如果有mq.tar的话, 直接就在docker里加载镜像 就行

docker load -i mq.tar

或者直接拉去mq的docker

docker pull rabbitmq:3.8-management

创建网络

docker network create mq-net

接下来就是创建mq容器

docker run --restart=always \
 -e RABBITMQ_DEFAULT_USER=adminovo \
 -e RABBITMQ_DEFAULT_PASS=123321 \
 -v mq-plugins:/plugins \
 --name mq \
 --hostname mq \
 -p 15672:15672 \
 -p 5672:5672 \
 --network mq-net\
 -d \
 rabbitmq:3.8-management

docker run \
-e RABBITMQ_DEFAULT_USER=guest \
-e RABBITMQ_DEFAULT_PASS=guest \
--name mq \
--hostname localhost \
-p 15672:15672 \
-p 5672:5672 \
-d \
rabbitmq

注意更改账号和密码, 还有docker的网络network

快速入门

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

为了方便测试，我们现在控制台新建一个队列：simple.queue
image.png
image.png
image.png
交换机就起到一个放大喇叭的效果。
队列需要绑定交换机才能成功发送。
每一个项目添加一个自己的虚拟主机。

消息发送

image.png
控制台创建消息队列
image.png
首先配置MQ地址，在publi sher服务的application.yml中添加配置：

spring:
  rabbitmq:
    host: 192.168.164.128 # 你的虚拟机IP
    port: 5672 # 端口
    virtual-host: /hmall # 虚拟主机
    username: itheima # 用户名
    password: 123321 # 密码

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

package com.itheima.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;

/**
 * @author Ccoo
 * 2024/1/20
 */
@SpringBootTest
public class SpringAmqpTest {

	@Autowired
	private RabbitTemplate rabbitTemplate;

	@Test
	public void testSimpleQueue() {
		// 队列名称
		String queueName = "simple.queue";
		// 消息
		String message = "hello, spring amqp!";
		// 发送消息
		rabbitTemplate.convertAndSend(queueName, message);
	}
}

消息接收

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

spring:
  rabbitmq:
    host: 192.168.164.128 # 你的虚拟机IP  
    port: 5672 # 端口
    virtual-host: /hmall # 虚拟主机
    username: itheima # 用户名
    password: 123321 # 密码

然后在consumer服务的com.itheima.consumer.listener包中新建一个类SpringRabbitListener:

package com.itheima.consumer.listener;

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

/**
 * @author Ccoo
 * 2024/1/20
 */
@Slf4j
@Component
public class SpringRabbitListener {

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

WorkQueues模型

image.png

消息发送

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

消息接收

@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);
}

由于两个队列处理消息的能力不一致, 导致有一个消息队列会处在空闲阶段

能者多劳

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

正所谓能者多劳，这样充分利用了每一个消费者的处理能力，可以有效避免消息积压问题。

总结

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

交换机类型

image.png

  • Publisher：生产者，不再发送消息到队列中，而是发给交换机
  • Exchange：交换机，一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。
  • Queue：消息队列也与以前一样，接收消息、缓存消息**。不过队列一定要与交换机绑定。**
  • Consumer：消费者，与以前一样，订阅队列，没有变化

Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失！

交换机的类型有四种：

  • Fanout：广播，将消息交给所有绑定到交换机的队列。我们最早在控制台使用的正是Fanout交换机
  • Direct：订阅，基于RoutingKey（路由key）发送给订阅了消息的队列
  • Topic：通配符订阅，与Direct类似，只不过RoutingKey可以使用通配符
  • Headers：头匹配，基于MQ的消息头匹配，用的较少。

Fanout交换机

image.png

image.png

  • 1）  可以有多个队列
  • 2）  每个队列都要绑定到Exchange（交换机）
  • 3）  生产者发送的消息，只能发送到交换机
  • 4）  交换机把消息发送给绑定过的所有队 列
  • 5）  订阅队列的消费者都能拿到消息

操作:

  • 创建一个名为 hmall.fanout的交换机，类型是Fanout
  • 创建两个队列fanout.queue1和fanout.queue2，绑定到交换机hmall.fanout

声明队列和交换机

image.png

image.png

绑定队列到交换机

image.png

消息发送

@Test
public void testSendFanout() {
	// 队列名称
	String exchangeName = "hmall.fanout";
	// 消息
	String message = "hello, everyone!";
	// 发送消息
	rabbitTemplate.convertAndSend(exchangeName, null, message);
}

消息接收

@RabbitListener(queues = "fanout.queue1")
public void listenFanoutQueue1(String msg) throws InterruptedException {
	System.out.println("fanout1接收到消息：【" + msg + "】" + LocalTime.now());
}
@RabbitListener(queues = "fanout.queue2")
public void listenFanoutQueue2(String msg) throws InterruptedException {
	System.out.println("fanout2........接收到消息：【" + msg + "】" + LocalTime.now());
}

总结

  • 接收publisher发送的消息
  • 将消息按照规则路由到与之绑定的队列
  • 不能缓存消息，路由失败，消息丢失
  • FanoutExchange的会将消息路由到每个绑定的队列

Direct交换机

image.png

  • 队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）
  • 消息的发送方在 向 Exchange发送消息时，也必须指定消息的 RoutingKey。
  • Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的Routingkey与消息的 Routing key完全一致，才会接收到消息

操作:
image.png

  1. 声明一个名为hmall.direct的交换机
  2. 声明队列direct.queue1，绑定hmall.direct，bindingKey为blud和red
  3. 声明队列direct.queue2，绑定hmall.direct，bindingKey为yellow和red
  4. 在consumer服务中，编写两个消费者方法，分别监听direct.queue1和direct.queue2
  5. 在publisher中编写测试方法，向hmall.direct发送消息

声明队列和交换机

image.png

image.png

为队列绑定相应的key

image.png
image.png

消息接收

@RabbitListener(queues = "direct.queue1")
public void listenDirectQueue1(String msg) throws InterruptedException {
	System.out.println("direct1接收到消息：【" + msg + "】" + LocalTime.now());
}
@RabbitListener(queues = "direct.queue2")
public void listenDirectQueue2(String msg) throws InterruptedException {
	System.out.println("direct2........接收到消息：【" + msg + "】" + LocalTime.now());
}

消息发送

@Test
public void testSendDirect() {
	// 队列名称
	String exchangeName = "hmall.direct";
	// 消息
	String message = "Red!";
	// 发送消息
	rabbitTemplate.convertAndSend(exchangeName, "red", message);
}

测试结果:
image.png

@Test
public void testSendDirect() {
	// 队列名称
	String exchangeName = "hmall.direct";
	// 消息
	String message = "BLUE!";
	// 发送消息
	rabbitTemplate.convertAndSend(exchangeName, "blue", message);
}

image.png

Topic交换机

Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。
只不过Topic类型Exchange可以让队列在绑定BindingKey 的时候使用通配符！

通配符规则：

  • #：匹配一个或多个词
  • *：匹配不多不少恰好1个词

举例：

  • item.#：能够匹配item.spu.insert 或者 item.spu
  • item.*：只能匹配item.spu

image.png

绑定队列

image.png

消息接收

@RabbitListener(queues = "topic.queue1")
public void listenTopicQueue1(String msg){
    System.out.println("消费者1接收到topic.queue1的消息：【" + msg + "】");
}

@RabbitListener(queues = "topic.queue2")
public void listenTopicQueue2(String msg){
    System.out.println("消费者2接收到topic.queue2的消息：【" + msg + "】");
}

消息发送

/**
 * topicExchange
 */
@Test
public void testSendTopicExchange() {
    // 交换机名称
    String exchangeName = "hmall.topic";
    // 消息
    String message = "喜报！孙悟空大战哥斯拉，胜!";
    // 发送消息
    rabbitTemplate.convertAndSend(exchangeName, "china.news", message);
}

总结

  • Topic交换机接收的消息RoutingKey必须是多个单词，以 . 分割
  • Topic交换机与队列绑定时的bindingKey可以指定通配符
  • #：代表0个或多个词
  • *：代表1个词

Java声明队列和交换机

image.png

fanout示例

package com.itheima.consumer.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FanoutConfig {
    /**
     * 声明交换机
     * @return Fanout类型交换机
     */
    @Bean
    public FanoutExchange fanoutExchange(){
        // ExchangeBuilder.fanoutExchange("").build();
        return new FanoutExchange("hmall.fanout");
    }

    /**
     * 第1个队列
     */
    @Bean
    public Queue fanoutQueue1(){
    // 	QueueBuilder.durable("ff").build(); durable:持久化
        return new Queue("fanout.queue1");
    }

    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue1(Queue fanoutQueue1, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
        
    }

    /**
     * 第2个队列
     */
    @Bean
    public Queue fanoutQueue2(){
        return new Queue("fanout.queue2");
    }

    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue2(Queue fanoutQueue2, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
    }
}

direct示例

package com.itheima.consumer.config;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class DirectConfig {

    /**
     * 声明交换机
     * @return Direct类型交换机
     */
    @Bean
    public DirectExchange directExchange(){
        return ExchangeBuilder.directExchange("hmall.direct").build();
    }

    /**
     * 第1个队列
     */
    @Bean
    public Queue directQueue1(){
        return new Queue("direct.queue1");
    }

    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue1WithRed(Queue directQueue1, DirectExchange directExchange){
        return BindingBuilder.bind(directQueue1).to(directExchange).with("red");
    }
    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue1WithBlue(Queue directQueue1, DirectExchange directExchange){
        return BindingBuilder.bind(directQueue1).to(directExchange).with("blue");
    }

    /**
     * 第2个队列
     */
    @Bean
    public Queue directQueue2(){
        return new Queue("direct.queue2");
    }

    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue2WithRed(Queue directQueue2, DirectExchange directExchange){
        return BindingBuilder.bind(directQueue2).to(directExchange).with("red");
    }
    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue2WithYellow(Queue directQueue2, DirectExchange directExchange){
        return BindingBuilder.bind(directQueue2).to(directExchange).with("yellow");
    }
}

基于注解声明

Direct:

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "direct.queue1"),
    exchange = @Exchange(name = "hmall.direct", type = ExchangeTypes.DIRECT),
    key = {"red", "blue"}
))
public void listenDirectQueue1(String msg){
    System.out.println("消费者1接收到direct.queue1的消息：【" + msg + "】");
}

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "direct.queue2"),
    exchange = @Exchange(name = "hmall.direct", type = ExchangeTypes.DIRECT),
    key = {"red", "yellow"}
))
public void listenDirectQueue2(String msg){
    System.out.println("消费者2接收到direct.queue2的消息：【" + msg + "】");
}

Topic:

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "topic.queue1"),
    exchange = @Exchange(name = "hmall.topic", type = ExchangeTypes.TOPIC),
    key = "china.#"
))
public void listenTopicQueue1(String msg){
    System.out.println("消费者1接收到topic.queue1的消息：【" + msg + "】");
}

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "topic.queue2"),
    exchange = @Exchange(name = "hmall.topic", type = ExchangeTypes.TOPIC),
    key = "#.news"
))
public void listenTopicQueue2(String msg){
    System.out.println("消费者2接收到topic.queue2的消息：【" + msg + "】");
}

消息转换器

image.png
测试默认转换器:
image.png
一堆乱码，采用的是JDK序列话方式

配置JSON转换器:
在publisher和consumer两个服务中都引入依赖：

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.9.10</version>	
</dependency>

注意，如果项目中引入了spring-boot-starter-web依赖，则无需再次引入Jackson依赖。

配置消息转换器，在publisher和consumer两个服务的启动类中添加一个Bean即可：

@Bean
public MessageConverter messageConverter(){
    // 1.定义消息转换器
    Jackson2JsonMessageConverter jackson2JsonMessageConverter = new Jackson2JsonMessageConverter();
    // 2.配置自动创建消息id，用于识别不同消息，也可以在业务中基于ID判断是否是重复消息
    jackson2JsonMessageConverter.setCreateMessageIds(true);
    return jackson2JsonMessageConverter;
}

image.png

消费者接收Object:
可以使用之前的消费者, 也可以另外定义一个接收Map的消费者

@RabbitListener(queues = "object.queue")
public void listenSimpleQueueMessage(Map<String, Object> msg) throws InterruptedException {
    System.out.println("消费者接收到object.queue消息：【" + msg + "】");
}

实战运用-hmall

image.png

配置MQ

不管是生产者还是消费者，都需要配置MQ的基本信息, 添加依赖

<!--消息发送-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

配置MQ地址：

spring:  
  rabbitmq:
    host: 192.168.164.128 # 你的虚拟机IP
    port: 5672 # 端口
    virtual-host: /hmall # 虚拟主机
    username: itheima # 用户名
    password: 123321 # 密码
    listener:
      simple:
        prefetch: 1 # 每次只能获取一条消息，处理完成才能获取下一个消息

配置消息转换器

image.png

接收消息

在trade-service服务中定义一个消息监听类：

image.png

/**
 * @author Ccoo
 * 2024/1/21
 */
@Component
@RequiredArgsConstructor
public class PayStatusListener {

	private final IOrderService orderService;

	@RabbitListener(bindings = @QueueBinding(
			value = @Queue(name = "mark.order.pay.queue", durable = "true"),
			exchange = @Exchange(name = "pay.topic", type = ExchangeTypes.TOPIC),
			key = "pay.success"
	))
	public void listenPaySuccess(Long orderId){
		orderService.markOrderPaySuccess(orderId);
	}
}

绑定队列与交换机

/**
 * @author Ccoo
 * 2024/2/12
 */
@Configuration
public class MqConfig {
	@Bean
	public MessageConverter jackson2MessageConverter() {
		return new Jackson2JsonMessageConverter();
	}

	@Bean
	public TopicExchange topicExchange(){
		return new TopicExchange(MqConstants.USER_ORDER_EXCHANGE, true, false);
	}
	@Bean
	public Queue insertQueue(){
		return new Queue(MqConstants.USER_ORDER_INSERT_QUEUE, true);
	}
	@Bean
	public Queue deleteQueue(){
		return new Queue(MqConstants.USER_ORDER_DELETE_QUEUE, true);
	}
	@Bean
	public Binding insertQueueBinding(){
		return BindingBuilder.bind(insertQueue()).to(topicExchange()).with(MqConstants.USER_ORDER_INSERT_KEY);
	}
	@Bean
	public Binding deleteQueueBinding(){
		return BindingBuilder.bind(deleteQueue()).to(topicExchange()).with(MqConstants.USER_ORDER_DELETE_KEY);
	}
}

发送消息

// 5.修改订单状态
    // tradeClient.markOrderPaySuccess(po.getBizOrderNo());
    try {
        rabbitTemplate.convertAndSend(exchange:"pay.topic", routingkey:"pay.success", po.getBizOrderNo());
    } catch (Exception e) {
        log.error("支付成功的消息发送失败，支付单id：{}， 交易单id：{}", po.getId(), po.getBizOrderNo(), e);
    }

记得注入rabbitTemplate

RabbitMQ 添加用户-CSDN博客

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

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

相关文章

类与对象（1）

类与对象（1）

1.c升级了类 C 语言结构体中只能定义变量&#xff0c;在 C 中&#xff0c;结构体内不仅可以定义变量&#xff0c;也可以定义函数。 比如&#xff1a; 之前在数据结构初阶中&#xff0c;用 C 语言方式实现的栈&#xff0c;结构体中只能定义变量 &#xff1b;现在以 C 方式实现&…
阅读更多...
什么样的台灯适合学生使用？五款暑假必入护眼大路灯分享

什么样的台灯适合学生使用？五款暑假必入护眼大路灯分享

什么样的台灯适合学生使用&#xff1f;现在近视越来越低龄化&#xff0c;戴眼镜的小朋友越来越多&#xff0c;每每看着自己孩子眼睛贴到作业本上写作业&#xff0c;我的心都会提到嗓子眼。去医院一检查&#xff0c;果然&#xff0c;远视储备即将告罄&#xff0c;必须要防护了&a…
阅读更多...
1500平方米气膜羽毛球馆的造价分析—轻空间

1500平方米气膜羽毛球馆的造价分析—轻空间

随着全民健身热潮的兴起&#xff0c;气膜羽毛球馆因其良好的空气质量、恒温恒湿的环境和快捷的建设速度&#xff0c;受到了越来越多人的欢迎。建造一个1500平方米的气膜羽毛球馆涉及多个方面的费用&#xff0c;包括场地准备、设备材料、安装施工、配套设施等。轻空间将详细分析…
阅读更多...
企业微信内嵌H5项目接入聊天功能

企业微信内嵌H5项目接入聊天功能

产品需求是,在列表中把符合条件的列表接入聊天功能,以下是详细步骤: 1.引入企业微信 <script src"https://res.wx.qq.com/wwopen/js/jsapi/jweixin-1.0.0.js"></script> 2.获取wx签名(必须要) /*** 获取wx签名**/ export function getWxJsApi(data) {r…
阅读更多...
DC/AC电源模块：效率与可靠性兼备的能源转换解决方案

DC/AC电源模块：效率与可靠性兼备的能源转换解决方案

BOSHIDA DC/AC电源模块&#xff1a;效率与可靠性兼备的能源转换解决方案 随着科技的迅速发展和人工智能技术的逐渐成熟&#xff0c;各种电子设备的需求也日益增加。然而&#xff0c;这些设备往往需要不同的电压和电流来正常工作&#xff0c;而供电方式却可能不尽相同。这时&am…
阅读更多...
前端框架中的前端打包（Bundling）和前端构建工具（Build Tools）的作用

前端框架中的前端打包（Bundling）和前端构建工具（Build Tools）的作用

聚沙成塔每天进步一点点 本文回顾 ⭐ 专栏简介前端框架中的前端打包&#xff08;Bundling&#xff09;和前端构建工具&#xff08;Build Tools&#xff09;的作用1. 引言2. 前端打包&#xff08;Bundling&#xff09;2.1 概述2.2 常见的打包工具2.2.1 Webpack2.2.2 Parcel 2.3 …
阅读更多...
ERP收费模式是怎样的？SAP ERP是如何收费的？

ERP收费模式是怎样的？SAP ERP是如何收费的？

一、购置SAP ERP系统的费用组成 1、软件费用 传统的ERP系统大多为许可式&#xff0c;即企业在购买ERP服务时付清所有费用&#xff0c;将ERP系统部署于自己的服务器中。根据所购买ERP系统品牌的不同&#xff0c;价格上也有一定的差异。采购ERP系统许可后&#xff0c;后续维护、…
阅读更多...
springboot医院门诊挂号系统-计算机毕业设计源码033123

springboot医院门诊挂号系统-计算机毕业设计源码033123

目 录 摘要 1 绪论 1.1研究背景及意义 1.2研究现状 1.3系统开发技术的特色 1.4论文结构与章节安排 2 医院门诊挂号系统系统分析 2.1 可行性分析 2.2 系统流程分析 2.2.1数据增加流程 2.3.2数据修改流程 2.3.3数据删除流程 2.3 系统功能分析 2.3.1 功能性分析 2.…
阅读更多...
模拟题解析：

模拟题解析：

《互联网域名管理办法》第41条规定&#xff0c;域名根服务器运行机构、域名注册管理机构和域名注册服务机构应当遵守国家相关法律、法规和标准&#xff0c;落实网络与信息安全保障措施&#xff0c;配置必要的网络通信应急设备&#xff0c;建立健全网络与信息安全监测技术手段和…
阅读更多...
3D渲染时如何提高GPU的使用率？这7点告诉你

3D渲染时如何提高GPU的使用率？这7点告诉你

GPU 正逐渐取代 CPU 在 3D 渲染中的地位。我们看到许多 GPU 渲染器如 Redshift、Octane、FStorm 等不断推出。以前只支持 CPU 渲染的渲染器&#xff0c;如 Arnold、V-Ray、Renderman、Keyshot 等&#xff0c;现在也开始支持 GPU 渲染。实时渲染的发展使 GPU 更受欢迎&#xff0…
阅读更多...
V-Series Avalon-MM DMA Interface for PCIE IP核

V-Series Avalon-MM DMA Interface for PCIE IP核

目录 1. IP概述 2. Avalon-MM DMA Ports 3. 参数设置 3.1 系统设置 3.2 基址寄存器 (BAR) 设置 3.3 设备识别寄存器 3.4 PCI Express和PCI功能参数 3.4.1 Device Capabilities 3.4.2 Error Reporting 3.4.3 Link Capabilities 3.4.4 MSI and MSI-X Capabilities …
阅读更多...
【MySQL进阶之路 | 高级篇】索引及索引的数据结构

【MySQL进阶之路 | 高级篇】索引及索引的数据结构

1. 为什么要使用索引 索引是存储引擎用于快速找到数据记录的一种数据结构&#xff0c;就好比一本教科书的目录&#xff0c;通过目录可以找到对应文章的页面&#xff0c;而不用一页一页从头翻到尾.MySQL也是一样的道理.在进行数据查找时&#xff0c;首先查看查询条件是否命中某…
阅读更多...
基于weixin小程序校园快递系统的设计

基于weixin小程序校园快递系统的设计

管理员账户功能包括&#xff1a;系统首页&#xff0c;个人中心&#xff0c;管理员管理&#xff0c;用户管理&#xff0c;订单管理&#xff0c;快递管理&#xff0c;快递记录管理&#xff0c;公告管理&#xff0c;基础数据管理 小程序功能包括&#xff1a;系统首页&#xff0c;…
阅读更多...
Java毕设代码助力，让技术实现更流畅

Java毕设代码助力，让技术实现更流畅

Java毕设代码助力&#xff0c;让技术实现更流畅 在Java毕业设计的道路上&#xff0c;代码的编写往往占据了大部分的时间和精力。为了帮助同学们更专注于项目的核心逻辑和创意实现&#xff0c;Java毕设服务工作室专注于提供高质量的Java代码支持。 一、专业编码&#xff0c;助…
阅读更多...
python-引用配置文件和日志

python-引用配置文件和日志

文章目录 前言python-引用配置文件和日志1. 给一个配置文件2. 获取配置文件信息方法3. 获取配置信息&#xff0c;引入日志分页功能demo4. 测试 前言 如果您觉得有用的话&#xff0c;记得给博主点个赞&#xff0c;评论&#xff0c;收藏一键三连啊&#xff0c;写作不易啊^ _ ^。 …
阅读更多...
【乐吾乐2D可视化组态编辑器】文件

【乐吾乐2D可视化组态编辑器】文件

1 文件 文件&#xff1a;文件的新建、打开、导入、保存、另存为、下载JOSN文件、下载ZIP打包文件、导出为HTML、导出为Vue2组件、导出为Vue3组件、导出为React组件&#xff08;老版将不再维护&#xff09;、下载为PNG、下载为SVG 乐吾乐2D可视化组态编辑器demo&#xff1a;ht…
阅读更多...
HTTP协议和Nginx

HTTP协议和Nginx

一、HTTP协议和Nginx 1.套接字Socket 套接字Socket是进程间通信IPC的一种实现&#xff0c;允许位于不同主机&#xff08;或同一主机&#xff09;上不同进程之间进行通信和数据交换&#xff0c;SocketAPI出现于1983年BSD4.2实现在建立通信连接的每一端&#xff0c;进程间的传输…
阅读更多...
mac配置修改host文件

mac配置修改host文件

1command 空格 输入 terminal 选中回车进入终端控制台. command 空格 2 sudo vi /etc/hosts 输入密码,进入vi编辑器修改文件 sudo vi /etc/hosts3修改内容,:wq保存退出,重启项目即可 :wq
阅读更多...
全景图片/老照片/动漫图片一键无损放大与修复

全景图片/老照片/动漫图片一键无损放大与修复

在日常生活中&#xff0c;我们经常使用系统自带的图片处理软件来对图片进行缩放操作&#xff0c;从而实现放大或缩小图片。然而&#xff0c;这种方法会带来一个问题&#xff1a;如果原始图片较小&#xff0c;放大后会导致精度损失&#xff0c;使图片变得模糊。 近年来&#xf…
阅读更多...
Radxa 学习摘录

Radxa 学习摘录

文章目录 一、参考资料二、硬件知识 一、参考资料 技术论坛&#xff08;推荐&#xff09; 官方资料下载 wiki资料 u-boot 文档 u-boot 源码 内核文档 内核源码 原理图 二、硬件知识 Radxa 3B 主板概览 MIPI接口 MIPI CSI&#xff08;Camera Serial Interface&#xff09;…
阅读更多...
最新文章

Copyright @ 2022~2023