敲详细的springframework-amqp-rabbit源码解析

news2024/9/20 22:31:47

看源码时将RabbitMQ的springframework-amqp-rabbit和spring-rabbit的一套区分开，springboot是基于RabbitMQ的Java客户端建立了简便易用的框架。

springboot的框架下相对更多地使用消费者Consumer和监听器Listener的概念，这两个概念不注意区分容易混淆。默认情况下，springboot中消费者为单线程串行消费的模型，体现了队列的特性。

在springboot的框架下使用rabbitmq的一般步骤

  1. 启动rabbitmq服务器，springboot项目引入依赖
  2. 配置信息，有两种方式
    1. 配置文件配置
    2. 配置类配置SimpleMessageListenerContainer
  3. 实现消息处理类ChannelAwareMessageListener处理业务逻辑，或用@RabbitListener注解

这两种方式其实异曲同工，@RabbitListener的方式在实际使用时创建MessagingMessageListenerAdapter，这个对象是ChannelAwareMessageListener接口的实现类，实现了onMessage()方法，这个方法利用了适配器模式，能够调用注解标注的方法，而实现ChannelAwareMessageListener的方式比较直白就是实现onMessage()方法

源码解析

关于SimpleMessageListenerContainer

SimpleMessageListenerContainer是在spring项目中使用RabbitMQ关键的类，用来接收并处理消息的。阅读源码可以从这个类入手。

  1. 首先关注构造器，需要传入ConnectionFactory用于获取连接，这跟原生rabbitmq是一致的，都从Connection连接开始。

  2. 关键属性

    concurrentConsumers：指定要创建的并发消费者的数量。默认值为1。建议增加并发使用者的数量，以便扩展从队列传入的消息的消耗。但是，请注意，一旦注册了多个消费者，将无法保证顺序。一般来说，对于低容量队列，坚持使用1个消费者。同时不能超过maxConcurrentConsumers(如果设置了)。

    maxConcurrentConsumers：设置消费者数量的上限。默认为concurrentConsumers。消费者可以根据需求增加，但不会小于concurrentConsumers。

    acknowledgeMode：消息确认模式

    // 自动确认消息
container.setAcknowledgeMode(AcknowledgeMode.NONE);
// 根据情况确认消息
container.setAcknowledgeMode(AcknowledgeMode.AUTO);
// 手动确认消息
container.setAcknowledgeMode(AcknowledgeMode.MANUAL);

  3. 绑定组件：

  4. 设置消费者的Consumer_tag和Arguments：container.setConsumerTagStrategy可以设置消费者的 Consumer_tag， container.setConsumerArguments可以设置消费者的 Arguments

    container.setConsumerTagStrategy(queue -> "order_queue_"+(++count));
//设置消费者的Arguments
Map<String, Object> args = new HashMap<>();
args.put("module","订单模块");
args.put("fun","发送消息");
container.setConsumerArguments(args);

    在这里插入图片描述

spring的亮点在于用注解简化了很多代码操作，其中最常用的当属@RabbitListener

@RabbitListener(queues = {BiMqConstant.BI_QUEUE_NAME}, ackMode = "MANUAL")
public void receiveMessage(String message, Channel channel, @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag){
}

从@RabbitListener入手

1、从spring开启RabbitMQ的注解模式，@EnableRabbit导入RabbitBootstrapConfiguration配置类。

2、这个配置类定义了RabbitListenerAnnotationBeanPostProcessor和RabbitListenerEndpointRegistry两个bean。前者用来扫描加了@RabbitListener 的类，通过反射找到带注解的类，再找到对应的方法，存为handlerMethods。后者在注册终端后用于构建ListenerContainer（继承了RabbitListener注解内的信息，包括监听的队列和注解所在的类和方法）。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(RabbitBootstrapConfiguration.class)
public @interface EnableRabbit {
}

3、RabbitListenerEndpointRegistry通过创建MethodRabbitListenerEndpoint对象和SimpleRabbitListenerContainerFactory工厂bean，生成SimpleMessageListenerContainer对象。

（RabbitListenerAnnotationBeanPostProcessor中拥有注解信息，如队列名，以及被标注注解的方法，所以endpoint的注册还是在processor类中）

（processor中有注册员成员变量registrar的registerEndpoint()注册endpoint，registrar有注册处registry成员变量注册利用registerListenerContainer()的createListenerContainer()注册container）

public class RabbitListenerEndpointRegistry  implements SmartLifecycle{
 
	private final Map<String, MessageListenerContainer> listenerContainers =
			new ConcurrentHashMap<String, MessageListenerContainer>();
	//注册终端
	public void registerListenerContainer(RabbitListenerEndpoint endpoint, RabbitListenerContainerFactory<?> factory,
				boolean startImmediately) {
 
		String id = endpoint.getId();
		synchronized (this.listenerContainers) {
			//创建 listenerContainer
			MessageListenerContainer container = createListenerContainer(endpoint, factory);
			this.listenerContainers.put(id, container);
			……
 
			if (startImmediately) {
				startIfNecessary(container);
			}
		}
	}
 
	    protected MessageListenerContainer createListenerContainer(RabbitListenerEndpoint endpoint,
            RabbitListenerContainerFactory<?> factory) {
        //调用RabbitListener容器工厂的createListenerContainer方法获取RabbitListener容器
        MessageListenerContainer listenerContainer = factory.createListenerContainer(endpoint);
 
        return listenerContainer;
    }

4、SimpleMessageListenerContainer对象保存了要监听的队列名（可以是configuration时set的也可以是@RabbitListener中标注的），创建了用于处理消息的MessagingMessageListenerAdapter实例（实际上是一个listener）

public class MethodRabbitListenerEndpoint extends AbstractRabbitListenerEndpoint {
    ......
    @Override
    protected MessagingMessageListenerAdapter createMessageListener(MessageListenerContainer container) {
        Assert.state(this.messageHandlerMethodFactory != null,
                "Could not create message listener - MessageHandlerMethodFactory not set");
        MessagingMessageListenerAdapter messageListener = createMessageListenerInstance();
        messageListener.setHandlerMethod(configureListenerAdapter(messageListener));
        String replyToAddress = getDefaultReplyToAddress();
        if (replyToAddress != null) {
            messageListener.setResponseAddress(replyToAddress);
        }
        MessageConverter messageConverter = container.getMessageConverter();
        if (messageConverter != null) {
            messageListener.setMessageConverter(messageConverter);
        }
        if (getBeanResolver() != null) {
            messageListener.setBeanResolver(getBeanResolver());
        }
        return messageListener;
    }

    protected MessagingMessageListenerAdapter createMessageListenerInstance() {
        return new MessagingMessageListenerAdapter(this.bean, this.method);
    }
    
    ......
}

5、SimpleMessageListenerContainer的内部类AsyncMessageProcessingConsumer（区分，该类封装了BlockingQueueConsumer，由于该类实现了Runnable接口，可以视为一个线程任务放入线程池中执行）有一个run()方法，调用了receiveAndExecute()，这个方法会获取BlockingQueueConsumer，阻塞读取其消息（一次获取多条），完成消息读取。

6、接着调用listener进行消息处理，这里设置了代理，最终会执行actualInvokeListener所谓实际被执行的listener，溯源最终调用了listener.onMessage(message, channelToUse)。

SimpleMessageListenerContainer {
     //接受并执行
    private boolean receiveAndExecute(final BlockingQueueConsumer consumer) throws Throwable {
 
       //do接受并执行
        return doReceiveAndExecute(consumer);
    }
     //do接受并执行
    private boolean doReceiveAndExecute(BlockingQueueConsumer consumer) throws Throwable {
 
        Channel channel = consumer.getChannel();
        for (int i = 0; i < this.txSize; i++) {//txSize为一次事务接受的消息个数
            //读取消息，这里阻塞的，但是有一个超时时间。
            Message message = consumer.nextMessage(this.receiveTimeout);
            if (message == null) {//阻塞超时
				break;
			}
            try {
                executeListener(channel, message);//消息接收已完成，现在开始处理消息。
            }
            catch (Exception e) {}
        }
        return consumer.commitIfNecessary(isChannelLocallyTransacted());
    }
        
    
    //处理消息开始。该方法在其父类中
    protected void executeListener(Channel channel, Message messageIn) throws Exception {
        try {
            Message message = messageIn;
            if (……) {
                //批处理信息，这个不研究
            }else {
                invokeListener(channel, message);
            }
        }catch (Exception ex) {}
    }
    //在其父类中
    protected void invokeListener(Channel channel, Message message) throws Exception {
        //这里this.proxy.invokeListener最终会调用actualInvokeListener方法。
        this.proxy.invokeListener(channel, message);
    }
    //在其父类中
    protected void actualInvokeListener(Channel channel, Message message) throws Exception {
        Object listener = getMessageListener();
        if (listener instanceof ChannelAwareMessageListener) {
            doInvokeListener((ChannelAwareMessageListener) listener, channel, message);
        }
        else if (listener instanceof MessageListener) {
            //……
            doInvokeListener((MessageListener) listener, message)
        }else{
            //……
        }
        
    }    
 
    protected void doInvokeListener(ChannelAwareMessageListener listener, Channel channel, Message message)
            throws Exception {
            Channel channelToUse = channel;
            try {
                listener.onMessage(message, channelToUse);
            }
            catch (Exception e) {
                throw wrapToListenerExecutionFailedExceptionIfNeeded(e, message);
            }
 
    }
}

7、关于第6点，根据这个listener实例的不同，有两种处理方式：

如果是前面所说的实现ChannelAwareMessageListener，就直接调用实现类的onMessage()。

如果是@RabbitListener注解，不同在于MessagingMessageListenerAdapter（ChannelAwareMessageListener的实现类，也是listen），基于适配器模式持有@RabbitListener注解的对象和方法（adapter实例中有HandlerMethod属性加入到adapter类中，HandlerMethod调用invoke()就能执行注解标注的方法）。

public class HandlerAdapter {
  private final InvocableHandlerMethod invokerHandlerMethod;
  private final DelegatingInvocableHandler delegatingHandler;
 
  public Object invoke(Message<?> message, Object... providedArgs) throws Exception                
  {
      if (this.invokerHandlerMethod != null) {
          //InvocableHandlerMethod不为null,就调用invokerHandlerMethod.invoke方法。
          return this.invokerHandlerMethod.invoke(message, providedArgs);
 
      }else if (this.delegatingHandler.hasDefaultHandler()) {
            //……
      }else {
            //……
      }
   }
}
public class MessagingMessageListenerAdapter extends AbstractAdaptableMessageListener {
	private HandlerAdapter handlerMethod;
}

现在就能把整个过程串起来了

关于关于endpoint和register

Endpoint为终端，像电脑、手机都是终端，他们都可以接受外部信息并响应，如手机来短信了就有提示。这里也用了终端的概念，被@RabbitListener注解修饰方法也有终端的特点可以接受外部信息并响应，即接到消息就执行对应方法。

registry姑且成为注册处用Map保存endpoint的id和对应的listenerContainer，注册处registerListenerContainer()利用endpoint和factory实例创建container，实际上是用了containerfactory的createListenerContainer(RabbitListenerEndpoint endpoint)方法

public class RabbitListenerEndpointRegistry implements DisposableBean, SmartLifecycle, ApplicationContextAware,
        ApplicationListener<ContextRefreshedEvent> {
        // 检查是否被注册过，注册过就不能注册第二次
        // 调用createListenerContainer创建消息监听
        // 关于分组消费的，我们不关心
        // 是否立即启动，是的话，同步调用startIfNecessary方法
        public void registerListenerContainer(RabbitListenerEndpoint endpoint, RabbitListenerContainerFactory<?> factory,
                                          boolean startImmediately) {
        Assert.notNull(endpoint, "Endpoint must not be null");
        Assert.notNull(factory, "Factory must not be null");

        String id = endpoint.getId();
        Assert.hasText(id, "Endpoint id must not be empty");
        synchronized (this.listenerContainers) {
            Assert.state(!this.listenerContainers.containsKey(id),
                    "Another endpoint is already registered with id '" + id + "'");
            MessageListenerContainer container = createListenerContainer(endpoint, factory);
            this.listenerContainers.put(id, container);
            if (StringUtils.hasText(endpoint.getGroup()) && this.applicationContext != null) {
                List<MessageListenerContainer> containerGroup;
                if (this.applicationContext.containsBean(endpoint.getGroup())) {
                    containerGroup = this.applicationContext.getBean(endpoint.getGroup(), List.class);
                }
                else {
                    containerGroup = new ArrayList<MessageListenerContainer>();
                    this.applicationContext.getBeanFactory().registerSingleton(endpoint.getGroup(), containerGroup);
                }
                containerGroup.add(container);
            }
            if (startImmediately) {
                startIfNecessary(container);
            }
        }

    // 其实就是调用了RabbitListenerContainerFactory的createListenerContainer生成了一个MessageListenerContainer对象
    protected MessageListenerContainer createListenerContainer(RabbitListenerEndpoint endpoint,
            RabbitListenerContainerFactory<?> factory) {

        MessageListenerContainer listenerContainer = factory.createListenerContainer(endpoint);

        if (listenerContainer instanceof InitializingBean) {
            try {
                ((InitializingBean) listenerContainer).afterPropertiesSet();
            }
            catch (Exception ex) {
                throw new BeanInitializationException("Failed to initialize message listener container", ex);
            }
        }

        int containerPhase = listenerContainer.getPhase();
        if (containerPhase < Integer.MAX_VALUE) {  // a custom phase value
            if (this.phase < Integer.MAX_VALUE && this.phase != containerPhase) {
                throw new IllegalStateException("Encountered phase mismatch between container factory definitions: " +
                        this.phase + " vs " + containerPhase);
            }
            this.phase = listenerContainer.getPhase();
        }

        return listenerContainer;
    }
}

把endpoint内的信息全部注入到container里。

@Override
public C createListenerContainer(RabbitListenerEndpoint endpoint) {
    C instance = createContainerInstance();

    if (this.connectionFactory != null) {
        instance.setConnectionFactory(this.connectionFactory);
    }
    if (this.errorHandler != null) {
        instance.setErrorHandler(this.errorHandler);
    }
    if (this.messageConverter != null) {
        instance.setMessageConverter(this.messageConverter);
    }
    if (this.acknowledgeMode != null) {
        instance.setAcknowledgeMode(this.acknowledgeMode);
    }
    if (this.channelTransacted != null) {
        instance.setChannelTransacted(this.channelTransacted);
    }
    if (this.autoStartup != null) {
        instance.setAutoStartup(this.autoStartup);
    }
    if (this.phase != null) {
        instance.setPhase(this.phase);
    }
    instance.setListenerId(endpoint.getId());
    // 最重要的一行！！！
    endpoint.setupListenerContainer(instance);
    initializeContainer(instance);

    return instance;
}

关于container和containerFactory

containerFactory也能配置并发消费者等参数。

@Configuration
@EnableAsync
public class ThreadPoolConfig { 
    @Bean("customContainerFactory") 
    public SimpleRabbitListenerContainerFactory containerFactory(SimpleRabbitListenerContainerFactoryConfigurer configurer, ConnectionFactory connectionFactory) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConcurrentConsumers(10); //设置线程数
        factory.setMaxConcurrentConsumers(10); //最大线程数
        configurer.configure(factory, connectionFactory);
        return factory; 
    }
}

配置containerFactory能够创建container，但一般不在配置类中手动创建。一般是在注解中标记，然后让spring来生产container。

@RabbitListener(queues="demo.queue",containerFactory = "customContainerFactory")

直接配置container效果是相同的，同样可以设置队列，并发消费者等。

细说上面第5步container内的操作。

  1. container的启动入口是star()方法，然后进入doStart()，在该方法中会初始化consumer（BlockingQueueConsumer），每一个并发需要对应一个consumer，consumer的数量是根据前面所说的concurrentConsumers确定

    consumer = new BlockingQueueConsumer(getConnectionFactory(), getMessagePropertiesConverter(),
				this.cancellationLock, getAcknowledgeMode(), isChannelTransacted(), actualPrefetchCount,
				isDefaultRequeueRejected(), getConsumerArguments(), isNoLocal(), isExclusive(), queues);
// 带有连接信息，数据转换器，确认模式，预取值，consumerArgs，监听的队列（可多个）等信息传入

区分一下consumer和listener，consumer是接收消息的消费者，listener是实际处理业务的执行者，consumer接收的每个消息都需要调用listener内的onMessage()方法来处理实际业务。

int newConsumers = initializeConsumers();
  1. 然后将consumer封装成AsyncMessageProcessingConsumer线程任务类型，然后就可以放入线程池中执行。
AsyncMessageProcessingConsumer processor = new AsyncMessageProcessingConsumer(consumer);
processors.add(processor);
getTaskExecutor().execute(processor);

  1. 这里的线程池是SimpleAsyncTaskExecutor（也可以自定义传入），默认是不限制并发量的。每个container都有一个线程池，线程不足以支持consumer并发时就会超时报错。

    private Executor taskExecutor = new SimpleAsyncTaskExecutor();

  2. 进入AsyncMessageProcessingConsumer这个Runnable类的run()方法，如果consumer有监听的队列，就初始化initialize并开启mainloop()

    if (this.consumer.getQueueCount() < 1) {
    ...
}
try {
    initialize();
    while (isActive(this.consumer) || this.consumer.hasDelivery() || !this.consumer.cancelled()) {
        mainLoop();
    }
}

  3. initialize()会创建exchange、queue、bindings等实例，设置Qos，实现consumer与broker之间的对接，完成消息的订阅，并且会根据tag不同在每个BlockingQueueConsumer中再划分出internalConsumer，再放入BlockingQueueConsumer的queue中逐一处理。

    说明Qos流控指令包括prefetch-size、prefetch-count参数。

    //该参数是设置在channel上的
int prefetchCount = 1;
channel.basicQos(prefetchCount);

    broker的delivery指令在客户端会先打包成一个Envelope，所以consumertag是对应consumer一个，而deliveryTag是对应broker中的一条消息一个。

    Envelope envelope = new Envelope(m.getDeliveryTag(),
                                         m.getRedelivered(),
                                         m.getExchange(),
                                         m.getRoutingKey());

    当然在broker执行delivery指令将消息推送到客户端Consumer之前还有channel，一个BlockingQueueConsumer对应一个channel，对应一个线程的调用。内部的consumer共用channel，channel会根据tag在dispatcher将消息推送至对应的consumer。

    一个channel对应了多个consumer

    在这里插入图片描述

    多个AsyncMessageProcessingConsumer对应不同的线程来处理

    在这里插入图片描述

    一个container可能监听多个队列。

    在这里插入图片描述

  4. mainLoop()相较于如何利用consumer接收消息，更侧重于最终的listener来进行业务处理。前面已经知道客户端会将消息存到Consume的queue中，简单来说，mainloop就是只要客户端正常启动就会无限循环来处理业务的，它主要就是完成从queue中提取消息数据然后经过一系列操作最终传递给业务逻辑处理MessageListener中。

    mainLoop()方法中就会从queue中提取消息，根据**batchSize**确定每次提取消息数量，最后回调MessageListener，实现将消息传递到业务逻辑进行处理；

    多个AsyncMessageProcessingConsumer对应一个listener（一个container对应一个listener即是一套处理业务，共用一个线程池，因为它们只是对应不同的并发， 处理的业务逻辑应是相同的。

    在这里插入图片描述

增加RabbitMQ并发的方法

  1. 增加并发消费者数量。并保障能提供充足的线程资源，虽然默认的线程池不设线程并发上线。示例：Redis与RabbitMQ配合使用多线程（多消费者）处理消息_多线程 处理 rabbitmq消息-CSDN博客

  2. 在listener方法上加上@Async()，这样会在异步的子线程下执行，如果提供线程池，就能实现并发。示例：线程池解决RabbitMQ消息堆积_rabbitmq线程池-CSDN博客

  3. 增大prefetchCount，prefetchCount是BlockingQueueConsumer内部维护的一个阻塞队列LinkedBlockingQueue的大小，其作用就是如果某个消费者队列阻塞，就无法接收新的消息

  4. 配置container的自定义线程池，但这个方法不推荐，示例：【RabbitMQ-9】自定义配置线程池（线程池资源不足-MQ初始化队列&&MQ动态扩容影响） - 简书 (jianshu.com)

  5. 当并发量确实无法短时间内提高时，也应尽可能提高消息队列的容量，并开启持久化。如设置惰性队列。

    RabbitMQ 从 3.6.0 版本开始引入了惰性队列的概念。惰性队列会尽可能的将消息存入磁盘，而在消费者消费到相应的消息时才会被加载到内存中，它的一个重要的设计目标是能够支持更长的队列，即支持更多的消息存储。当消费者由于各种各样的原因(比如消费者下线、宕机亦或者是由于维护而关闭等)而致使长时间内不能消费消息造成消息堆积时，惰性队列就很有必要了。

    正常的队列会尽可能存储在内存中。

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

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

相关文章

【electron6】浏览器实时播放PCM数据

【electron6】浏览器实时播放PCM数据

pcm介绍&#xff1a;PCM&#xff08;Puls Code Modulation&#xff09;全称脉码调制录音&#xff0c;PCM录音就是将声音的模拟信号表示成0,1标识的数字信号&#xff0c;未经任何编码和压缩处理&#xff0c;所以可以认为PCM是未经压缩的音频原始格式。PCM格式文件中不包含头部信…
阅读更多...
FPGA文档阅读

FPGA文档阅读

FPGA的文档没有相应的基础还真不容易看懂&#xff0c;下面是B站上对FPGA文档的解读(本文非对文档解读&#xff0c;只是为个人记录第三期&#xff1a;CycloneIV E最小系统板设计&#xff08;一&#xff09;从Datasheet上获取FPGA的基本参数_哔哩哔哩_bilibili 电源部份 核心电…
阅读更多...
elasticsearch, kibana, 6.8.18 版本下的创建索引，指定timestamp，java CRUD，maven版本等

elasticsearch, kibana, 6.8.18 版本下的创建索引，指定timestamp，java CRUD，maven版本等

ELK 这一套的版本更迭很快&#xff0c; 而且es常有不兼容的东西出现&#xff0c; 经常是搜一篇文章&#xff0c;看似能用&#xff0c;拿到我这边就不能用了。 很是烦恼。 我这边的ELK版本目前是 6.8.18&#xff0c;这次的操作记录一下。 &#xff08;涉密内容略有删改&#xf…
阅读更多...
SQL语句——DDL数据定义语言

SQL语句——DDL数据定义语言

1.sql语言不区分大小写 2._&#xff08;下划线&#xff09;进行名字的分割&#xff0c;不适用驼峰命名 3.; 语句sql结尾处加一个;来表示结束 4.一般关键词建议用大写 5.所有名称不能用中文 1.创建数据库 CREATE DATABASE [IF NOT EXISTS] 库名 -- 库 #创建库 #create databa…
阅读更多...
计算机网络序章

计算机网络序章

计算机网络学习什么&#xff1f; 下列举例由用户使用计算机角度去理解 首先&#xff0c;计算机网络是通过路由等方式去获取我们希望的数据用户可以在APP中去进行方便的操作去获取数据。每个应用都有自己的端口去确定每次来的数据是否是自己需要的数据应该应该传到哪里&#x…
阅读更多...
COD论文笔记 Deep Gradient Learning for Efficient Camouflaged 2022

COD论文笔记 Deep Gradient Learning for Efficient Camouflaged 2022

动机 这篇论文的动机在于解决伪装目标检测(COD)中的一个关键问题&#xff1a;在复杂背景下&#xff0c;伪装目标与背景的边界模糊&#xff0c;使得检测变得极其困难。现有的方法&#xff0c;如基于边界或不确定性的模型&#xff0c;通常仅响应于伪装目标的稀疏边缘&#xff0c…
阅读更多...
oceanbase架构、功能模块、数据存储、特性、sql流转层等概念详解

oceanbase架构、功能模块、数据存储、特性、sql流转层等概念详解

一、架构图 OceanBase 数据库采用无共享&#xff08;Shared-Nothing&#xff09;分布式集群架构&#xff0c;各个节点之间完全对等&#xff0c;每个节点都有自己的 SQL 引擎、存储引擎、事务引擎&#xff0c;运行在普通 PC 服务器组成的集群之上&#xff0c;具备高可扩展性、高…
阅读更多...
澎湃算力 玩转AI 华为昇腾AI开发板——香橙派OriengePi AiPro边缘计算案例评测

澎湃算力 玩转AI 华为昇腾AI开发板——香橙派OriengePi AiPro边缘计算案例评测

澎湃算力 玩转AI 华为昇腾AI开发板 香橙派OriengePi AiPro 边缘计算案例评测 人工智能&#xff08;AI&#xff09;技术正以前所未有的速度改变着我们的生活、工作乃至整个社会的面貌。作为推动这一变革的关键力量&#xff0c;边缘计算与AI技术的深度融合正成为行业发展的新趋势…
阅读更多...
秒懂C++之类与对象（下）

秒懂C++之类与对象（下）

目录 一.static成员 测试&#xff1a; 二.explicit关键字 三.友元&#xff08;少用&#xff09; 友元函数&#xff1a; 友元类&#xff1a; 四.内部类&#xff08;少用&#xff09; 五.&#xff08;扩展&#xff09;编译器的优化 一.static成员 测试&#xff1a; 实现一…
阅读更多...
【分布式事务】怎么解决分布式场景下数据一致性问题

【分布式事务】怎么解决分布式场景下数据一致性问题

分布式事务的由来 拿充值订单举个栗子吧&#xff0c;假设&#xff1a;原本订单模块和账户模块是放在一起的&#xff0c;现在需要做服务拆分&#xff0c;拆分成订单服务&#xff0c;账户余额服务。原本收到充值回调后&#xff0c;可以将修改订单状态和扣减余额放在一个mysql事务…
阅读更多...
邮件安全篇：邮件传输加密（SSL/TLS or STATRTTLS）

邮件安全篇：邮件传输加密（SSL/TLS or STATRTTLS）

1. 前言 使用过邮件客户端的同学一定见过下面这张图。这是客户端账号配置界面&#xff0c;里面有SSL、STARTTLS选项。刚接触邮件客户端的同学肯定会有这些疑问&#xff1a;什么是SSL&#xff1f;什么是STARTTLS&#xff1f;两者有什么区别&#xff1f;具体该如何选择呢&#x…
阅读更多...
首批通过 | 百度通过中国信通院H5端人脸识别安全能力评估工作

首批通过 | 百度通过中国信通院H5端人脸识别安全能力评估工作

2024年5月&#xff0c;中国信息通信研究院人工智能研究所依托中国人工智能产业发展联盟安全治理委员会&#xff08;AIIA&#xff09;、“可信人脸应用守护计划”及多家企业代表共同开展《H5端人脸识别线上身份认证安全能力要求及评估方法》的编制工作&#xff0c;并基于该方法开…
阅读更多...
创新驱动的力量：探索Web3在技术发展中的作用

创新驱动的力量：探索Web3在技术发展中的作用

随着科技的不断进步和创新&#xff0c;Web3作为新一代互联网技术范式&#xff0c;正在以其去中心化、安全、透明和可编程的特性&#xff0c;深刻影响着全球技术发展的方向和速度。本文将深入探讨Web3技术的核心概念、关键特征以及其在技术创新中的重要作用&#xff0c;展示其在…
阅读更多...
【Android】Fragment的静态动态创建以及两种创建方式的生命周期

【Android】Fragment的静态动态创建以及两种创建方式的生命周期

参考&#xff1a; 33.3-Fragment的创建-静态创建2_哔哩哔哩_bilibili Fragment的创建_从现有代码创建foutran-CSDN博客 【Android】Fragment的基本用法、Fragment和活动间的通信、Fragment的生命周期、动态加载布局的技巧_android fragment-CSDN博客 文章目录 Fragment的静态创…
阅读更多...
贝锐蒲公英远程运维方案：即装即用、无需专线，断网也可远程维护

贝锐蒲公英远程运维方案：即装即用、无需专线，断网也可远程维护

目前&#xff0c;公路、隧道、桥梁、航道&#xff0c;甚至是施工现场和工业生产环境等&#xff0c;都采用了实时监测方案。 通过部署各类传感器和摄像头等设备&#xff0c;现场视频画面和控制单元&#xff08;如PLC、工控机等&#xff09;数据可以实时回传&#xff0c;用于集中…
阅读更多...
0711springNews新闻系统管理 实现多级评论

0711springNews新闻系统管理 实现多级评论

0611springmvc新闻系统管理-CSDN博客 0711springNews新闻系统管理项目包 实现多级评论-CSDN博客 数据库字段 需要添加父节点id&#xff0c;通过该字段实现父评论和子评论的关联关系。 对象属性 实现链表&#xff0c;通过一个父评论可以找到它对应的所有子孙评论。 业务层 实现…
阅读更多...
linux集群架构--web服务器--nginx检查模块/算法/rewrite知识补充

linux集群架构--web服务器--nginx检查模块/算法/rewrite知识补充

web集群-负载均衡 轮询算法 &#xff08;1&#xff09;概述 决定负载均衡如何把请求分发给后端节点&#xff0c;这种分发的方式就是轮询算法 &#xff08;2&#xff09;轮询算法 面试题&#xff1a;说说常见nginx轮询算法 rr,wrr,ip_hash,lc算法&#xff08;最小连接数&…
阅读更多...
CH03_布局

CH03_布局

第3章&#xff1a;布局 本章目标 理解布局的原则理解布局的过程理解布局的容器掌握各类布局容器的运用 理解 WPF 中的布局 WPF 布局原则 ​ WPF 窗口只能包含单个元素。为在WPF 窗口中放置多个元素并创建更贴近实用的用户男面&#xff0c;需要在窗口上放置一个容器&#x…
阅读更多...
基于 Three.js 的 3D 模型加载优化

基于 Three.js 的 3D 模型加载优化

作者&#xff1a;来自 vivo 互联网前端团队- Su Ning 作为一个3D的项目&#xff0c;从用户打开页面到最终模型的渲染需要经过多个流程&#xff0c;加载的时间也会比普通的H5项目要更长一些&#xff0c;从而造成大量的用户流失。为了提升首屏加载的转化率&#xff0c;需要尽可能…
阅读更多...
怎么关闭 Windows 安全中心，手动关闭 Windows Defender 教程

怎么关闭 Windows 安全中心，手动关闭 Windows Defender 教程

Windows 安全中心&#xff08;也称为 Windows Defender Security Center&#xff09;是微软 Windows 操作系统内置的安全管理工具&#xff0c;用于监控和控制病毒防护、防火墙、应用和浏览器保护等安全功能。然而&#xff0c;在某些情况下&#xff0c;用户可能需要关闭 Windows…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023