消息队列:第三章:在Java中使用消息队列

mq的面试题 20200908 1、如何使用 ActiveMQ 解决分布式事务? 在互联网应用中,基本都会有用户注册的功能。在注册的同时,我们会做出如下操作: 1. 收集用户录入信息,保存到数据库 2. 向用户的手机或邮箱发送验证码 等等… 如果是传统的集中式架构,实现这个功能非常简单:开启一个本地事务,往本地数据库中插入一条用户数据,发送 验证码,提交事物。 但是在分布式架构中,用户和发送验证码是两个独立的服务,它们都有各自的数据库,那么就不能通过本地事物 保证操作的原子性... 阅读详情

在项目中导入依赖坐标

        <!--使用消息队列,导入依赖坐标-->

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-activemq</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.apache.activemq</groupId>
            <artifactId>activemq-pool</artifactId>
            <version>5.15.2</version>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

使用队列queue的情况

producer端

    public static void main(String[] args) {
        ConnectionFactory connect = new ActiveMQConnectionFactory("tcp://192.168.0.100:61616");
        try {
            //创建连接对象
            Connection connection = connect.createConnection();
            connection.start();
            //第一个值表示是否使用事务,如果选择true,第二个值相当于选择0
            Session session = connection.createSession(true, Session.SESSION_TRANSACTED);
            //使用队列queue
            Queue testqueue = session.createQueue("boss drink");
            //创建提供者
            MessageProducer producer = session.createProducer(testqueue);
            TextMessage textMessage=new ActiveMQTextMessage();
            textMessage.setText("我渴了,我要喝水!");
            producer.setDeliveryMode(DeliveryMode.PERSISTENT);
            producer.send(textMessage);
            session.commit();// 事务型消息,必须提交后才生效
            connection.close();

        } catch (JMSException e) {
            e.printStackTrace();
        }

    }

consumer端1

    public static void main(String[] args) {
        // 连接
        ConnectionFactory connect = new ActiveMQConnectionFactory(ActiveMQConnection.DEFAULT_USER,ActiveMQConnection.DEFAULT_PASSWORD,"tcp://192.168.0.100:61616");
        try {
            Connection connection = connect.createConnection();
            connection.start();
            //第一个值表示是否使用事务,如果选择true,第二个值相当于选择0
            Session session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
            Destination testqueue = session.createQueue("boss drink");

            MessageConsumer consumer = session.createConsumer(testqueue);
            consumer.setMessageListener(new MessageListener() {
                @Override
                public void onMessage(Message message) {
                    if(message instanceof TextMessage){
                        try {
                            String text = ((TextMessage) message).getText();
                            System.out.println(text+",员工1马上拿起杯子打水。。。");

                            //session.rollback();
                            session.commit();
                        } catch (JMSException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                }
            });


        }catch (Exception e){
            e.printStackTrace();;
        }

    }

 consumer端2

    public static void main(String[] args) {
        // 连接
        ConnectionFactory connect = new ActiveMQConnectionFactory(ActiveMQConnection.DEFAULT_USER,ActiveMQConnection.DEFAULT_PASSWORD,"tcp://192.168.0.100:61616");
        try {
            Connection connection = connect.createConnection();
            connection.start();
            //第一个值表示是否使用事务,如果选择true,第二个值相当于选择0
            Session session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
            Destination testqueue = session.createQueue("boss drink");

            MessageConsumer consumer = session.createConsumer(testqueue);
            consumer.setMessageListener(new MessageListener() {
                @Override
                public void onMessage(Message message) {
                    if(message instanceof TextMessage){
                        try {
                            String text = ((TextMessage) message).getText();
                            System.out.println(text+",员工2马上拿起杯子打水。。。");

                            //session.rollback();
                            session.commit();
                        } catch (JMSException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                }
            });


        }catch (Exception e){
            e.printStackTrace();;
        }

    }

使用topic话题的情况:

producer端:

    public static void main(String[] args) {
        ConnectionFactory connect = new ActiveMQConnectionFactory("tcp://192.168.0.100:61616");
        try {
            //创建连接对象
            Connection connection = connect.createConnection();
            connection.start();
            //第一个值表示是否使用事务,如果选择true,第二个值相当于选择0
            Session session = connection.createSession(true, Session.SESSION_TRANSACTED);
            //使用topic话题(订阅)
            Topic topic = session.createTopic("boss speak");
            //创建提供者
            MessageProducer producer = session.createProducer(topic);
            TextMessage textMessage=new ActiveMQTextMessage();
            textMessage.setText("我们要为中国的伟大复兴而努力奋斗!");
            producer.setDeliveryMode(DeliveryMode.PERSISTENT);
            producer.send(textMessage);
            session.commit();// 事务型消息,必须提交后才生效
            connection.close();

        } catch (JMSException e) {
            e.printStackTrace();
        }

    }

 consumer端1:

    public static void main(String[] args) {
        // 连接
        ConnectionFactory connect = new ActiveMQConnectionFactory(ActiveMQConnection.DEFAULT_USER,ActiveMQConnection.DEFAULT_PASSWORD,"tcp://192.168.0.100:61616");
        try {
            Connection connection = connect.createConnection();
            //设置客户端id
            connection.setClientID("userOne");

            connection.start();
            //第一个值表示是否使用事务,如果选择true,第二个值相当于选择0
            Session session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
            Topic topic = session.createTopic("boss speak");
            //在消费端标记,Session.createDurableSubscriber(Topic topic, String name)
            //是发布-订阅持久化的接收端的设置。
            //参数  topic -> 与发送端的topic 对应,建立连接
            //参数 name -> 为订阅者的标识(相当于id)
            MessageConsumer consumer =session.createDurableSubscriber(topic,"userOne");
            //MessageConsumer consumer = session.createConsumer(topic);
            consumer.setMessageListener(new MessageListener() {
                @Override
                public void onMessage(Message message) {
                    if(message instanceof TextMessage){
                        try {
                            String text = ((TextMessage) message).getText();
                            System.out.println(text+",员工1这个月工资不要了。。。");

                            //session.rollback();
                            session.commit();
                        } catch (JMSException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                }
            });


        }catch (Exception e){
            e.printStackTrace();;
        }

    }

 consumer端2: 

    public static void main(String[] args) {
        // 连接
        ConnectionFactory connect = new ActiveMQConnectionFactory(ActiveMQConnection.DEFAULT_USER,ActiveMQConnection.DEFAULT_PASSWORD,"tcp://192.168.0.100:61616");
        try {
            Connection connection = connect.createConnection();
            connection.start();
            //第一个值表示是否使用事务,如果选择true,第二个值相当于选择0
            Session session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
            //Destination :目标
            Destination topic = session.createTopic("boss speak");

            MessageConsumer consumer = session.createConsumer(topic);
            consumer.setMessageListener(new MessageListener() {
                @Override
                public void onMessage(Message message) {
                    if(message instanceof TextMessage){
                        try {
                            String text = ((TextMessage) message).getText();
                            System.out.println(text+",员工2周末主动来加班。。。");

                            //session.rollback();
                            session.commit();
                        } catch (JMSException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                }
            });
        }catch (Exception e){
            e.printStackTrace();;
        }
    }

关于事务控制

producer提交时的事务

事务开启

只执行send并不会提交到队列中,只有当执行session.commit()时,消息才被真正的提交到队列中。

事务不开启

只要执行send,就进入到队列中。

consumer 接收时的事务

事务开启,签收必须写

Session.SESSION_TRANSACTED

 

收到消息后,消息并没有真正的被消费。消息只是被锁住。一旦出现该线程死掉、抛异常,或者程序执行了session.rollback()那么消息会释放,重新回到队列中被别的消费端再次消费。

事务不开启,签收方式选择

Session.AUTO_ACKNOWLEDGE

只要调用comsumer.receive方法 ,自动确认。

事务不开启,签收方式选择

Session.CLIENT_ACKNOWLEDGE

需要客户端执行 message.acknowledge(),否则视为未提交状态,线程结束后,其他线程还可以接收到。

  这种方式跟事务模式很像,区别是不能手动回滚,而且可以单独确认某个消息。

事务不开启,签收方式选择

Session.DUPS_OK_ACKNOWLEDGE

在Topic模式下做批量签收时用的,可以提高性能。但是某些情况消息可能会被重复提交,使用这种模式的consumer要可以处理重复提交的问题。

 

持久化与非持久化

通过producer.setDeliveryMode(DeliveryMode.PERSISTENT) 进行设置

持久化的好处就是当activemq宕机的话,消息队列中的消息不会丢失。非持久化会丢失。但是会消耗一定的性能。

与springboot整合

在application.properties文件中加入spring.activemq.broker-url=tcp://mq.server.com:61616

配置类ActiveMQConfig:项目启动的时候加载并执行里面所有的方法

@Configuration
public class ActiveMQConfig {

    @Value("${spring.activemq.broker-url:disabled}")
    String brokerURL ;

    @Value("${activemq.listener.enable:disabled}")
    String listenerEnable;

    @Bean
    public ActiveMQUtil getActiveMQUtil() throws JMSException {
        if(brokerURL.equals("disabled")){
            return null;
        }
        ActiveMQUtil activeMQUtil=new ActiveMQUtil();
        activeMQUtil.init(brokerURL);
        return  activeMQUtil;
    }

    //定义一个消息监听器连接工厂,这里定义的是点对点模式的监听器连接工厂
    @Bean(name = "jmsQueueListener")
    public DefaultJmsListenerContainerFactory jmsQueueListenerContainerFactory(ActiveMQConnectionFactory activeMQConnectionFactory ) {
        DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
        if(!listenerEnable.equals("true")){
            return null;
        }

        factory.setConnectionFactory(activeMQConnectionFactory);
        //设置并发数
        factory.setConcurrency("5");

        //重连间隔时间
       factory.setRecoveryInterval(5000L);
       factory.setSessionTransacted(false);
       factory.setSessionAcknowledgeMode(Session.CLIENT_ACKNOWLEDGE);
        return factory;
    }


    @Bean
    public ActiveMQConnectionFactory activeMQConnectionFactory ( ){
/*        if((url==null||url.equals(""))&&!brokerURL.equals("disabled")){
            url=brokerURL;
        }*/
        ActiveMQConnectionFactory activeMQConnectionFactory =
                new ActiveMQConnectionFactory(  brokerURL);
        return activeMQConnectionFactory;
    }

}

工具类ActiveMQUtil

public class ActiveMQUtil {
    PooledConnectionFactory pooledConnectionFactory=null;

    public ConnectionFactory init(String brokerUrl) {

        ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory(brokerUrl);
         //加入连接池
        pooledConnectionFactory=new PooledConnectionFactory(factory);
        //出现异常时重新连接
        pooledConnectionFactory.setReconnectOnException(true);
        //
        pooledConnectionFactory.setMaxConnections(5);
        pooledConnectionFactory.setExpiryTimeout(10000);
        return pooledConnectionFactory;
    }

    public ConnectionFactory getConnectionFactory(){
        return pooledConnectionFactory;
    }
}

案例:

controller:

@RequestMapping("/alipay/callback/return")
    public String callBackReturn(HttpServletRequest request,Map<String,String> paramsMap){// 页面同步反转的回调
        String out_trade_no = request.getParameter("out_trade_no");
        String trade_no = request.getParameter("trade_no");
        String sign = request.getParameter("sign");
        try {
            boolean b = AlipaySignature.rsaCheckV1(paramsMap,AlipayConfig.alipay_public_key,AlipayConfig.charset,AlipayConfig.sign_type);// 对支付宝回调签名的校验
        } catch (AlipayApiException e) {
            e.printStackTrace();
        }
        // 修改支付信息
        PaymentInfo paymentInfo = new PaymentInfo();
        paymentInfo.setPaymentStatus("已支付");
        paymentInfo.setCallbackContent(request.getQueryString());
        paymentInfo.setOutTradeNo(out_trade_no);
        paymentInfo.setAlipayTradeNo(trade_no);
        paymentInfo.setCallbackTime(new Date());

        //这里使用Queue队列
        // 发送系统消息,出发并发商品支付业务服务O2O消息队列
        paymentService.sendPaymentSuccess(paymentInfo.getOutTradeNo(),paymentInfo.getPaymentStatus(),trade_no);

        paymentService.updatePayment(paymentInfo);

        return "finish";
    }

servcieimpl:

@Override
    public void sendPaymentSuccess(String outTradeNo, String paymentStatus,String trackingNo) {
        try {
            // 连接消息服务器
            ConnectionFactory connect = activeMQUtil.getConnectionFactory();
            Connection connection = connect.createConnection();
            connection.start();
            //第一个值表示是否使用事务,如果选择true,第二个值相当于选择0
            Session session = connection.createSession(true, Session.SESSION_TRANSACTED);
            // 发送消息
            Queue testqueue = session.createQueue("PAYMENT_SUCCESS_QUEUE");

            MessageProducer producer = session.createProducer(testqueue);
            MapMessage mapMessage=new ActiveMQMapMessage();
            mapMessage.setString("out_trade_no",outTradeNo);
            mapMessage.setString("payment_status",paymentStatus);
            mapMessage.setString("tracking_no",trackingNo);
            producer.setDeliveryMode(DeliveryMode.PERSISTENT);
            producer.send(mapMessage);
            session.commit();// 事务型消息,必须提交后才生效
            connection.close();
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }

 

 

 

 

 

 

 

java实现rabbitmq消息队列 生产者向交换机发送消息—交换机根据路由key发送给队列-队列的消费者接收消息。多个消费者,每一个消费这都有自己的队列,每个队列都绑定到交换机。在某种场景下,我们希望不同的消息被不同的队列消费。一个生产者丶默认交换机丶一个队列丶一个消费者。一个生产者丶默认交换机丶一个队列丶多个消费者。生产者发送消息到交换机-交换机发送到哪个队列。区别在于Topic类型的交换机可以匹配通配符。符号(通配符):#表示匹配一个或者多个词。创建controller。创建rabbit工具类。 阅读详情

相关推荐

Java利用Redis实现消息队列

Java利用Redis实现消息队列 应用场景 为什么要用redis? 二进制存储、java序列化传输、IO连接数高、连接频繁 一、序列化   这里编写了一个java序列化的工具,主要是将对象转化为byte数组,和根据byte数组反序列化成java对象; 主要是用到了ByteArrayOutputStream和ByteArrayInputStream; 注意:每

qq_34657993的博客 7222

Java开发之消息队列

简介 介绍消息队列的重要性 介绍Java程序员常用的Kafka消息队列 介绍Kafka内部的一些机制及注意问题 为什么要使用消息队列? 比较常见的作用有3点,解耦、异步处理、流量削峰,这里分别一一介绍这些特点。 解耦 我们在设计微服务的时候经常会出现几个模块之间需要相互依赖,例如A和B服务相互依赖,那么部署一个A,必须部署一个B,导致A模块和B模块之间形成了强耦合。如果此时我们在A和B模块之间引入消息队列,那么A可以不用依赖B,只需要A和B之间规定通用的消息格式即可,这样A和B就解耦了,这样以后别的模块

shadon178 博客 8941

Java编程基础教程:Java消息队列

作者:禅与计算机程序设计艺术 1.背景介绍 消息队列(MQ)是一种分布式、容错性强、易于扩展、快速处理的异步通信技术。它通常被应用在企业应用中,用于缓冲、传递和存储需要异步处理的数据。传统的应用系统设计模式有三种基本方式:同步、异步、事件驱动。但是对于消息队列这种独特的技术,它有着不同的特征。随着业

AI天才研究院 1015

Java进阶-实现一个基本的消息队列

消息队列是一种用于在应用程序之间传递消息的关键组件,它能够提高系统的可伸缩性和可靠性。在这篇文章中,我们将探讨如何实现一个基本的消息队列,了解其核心概念和基本原理。

踏雨歌青春,诗酒趁年华 4540

Java与Kafka:消息队列使用指南

Apache Kafka 是一个分布式的流处理平台,它可以用来构建实时数据管道和流应用程序。Kafka 以一种高吞吐量、低延迟的方式处理数据,非常适合用于实时数据流场景。主题(Topic):Kafka 中的数据被组织成主题,每个主题就是一个消息队列。分区(Partition):为了提高吞吐量和容错性,主题被分成多个分区。生产者(Producer):负责向 Kafka 发布消息。消费者(Consumer):负责从 Kafka 中读取消息。消费者组。

java专栏 1438

Java:消息队列传递参数

消息队列(Message Queue)是一种实现进程间通信的机制,通过消息的发送和接收实现解耦、削峰和异步处理等功能。消息队列在分布式系统中非常重要,常见的消息队列中间件有RabbitMQ、Kafka和ActiveMQ等。本文在Java中实现一个简单的消息队列,展示基本的使用方法。

weiweiqiao的专栏 1029

2024年最新消息队列:第三章:在Java中使用消息队列(1),Java校招面试经验汇总

手绘了下图所示的kafka知识大纲流程图(xmind文件不能上传,导出图片展现),但都可提供源文件给每位爱学习的朋友本文已被CODING开源项目:【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友,可以点击这里获取5.15.2org.slf4j使用队列queue的情况producer端try {//创建连接对象//第一个值表示是否使用事务,如果选择true,第二个值相当于选择0//使用队列queue//创建提供者。

2401_84692299的博客 444

snipersim安装

snipersim安装记录,便于后续使用tip:snipersim需要在python2的环境下编译。

weixin_53507617的博客 918

Java中使用redis作为消息队列

本文介绍了在Java中使用Redis作为消息队列的两种主要方法:使用Redis的`List`数据结构和`Pub/Sub`模式。通过`List`,生产者可以使用`lpush`将消息推入队列头部,消费者可以使用`rpop`或`blpop`从队列尾部弹出消息,后者支持阻塞式消费。`Pub/Sub`模式适用于一对多的消息分发,发布者通过`publish`发送消息,订阅者通过`subscribe`接收消息。此外,文章还提到了使用Redisson库来简化操作,Redisson提供了更高层次的抽象,如消息队列和分布式锁。

Xx47585874的博客 1491

Ubuntu22.04上如何用Docker一键部署Ragflow+Ollama(附CUDA配置避坑指南)

本文详细介绍了在Ubuntu22.04系统上使用Docker一键部署Ragflow+Ollama的完整流程,特别提供了CUDA配置的避坑指南。从硬件兼容性检查、驱动安装到容器网络配置,手把手教你搭建本地化大模型环境,解决CUDA驱动冲突等常见问题,助力开发者快速构建AI应用开发平台。

weixin_26875109的博客 285

库卡机器人外部轴配置全流程:从接线到WorkVisual 6.0实战(附避坑指南)

本文详细解析了库卡机器人外部轴配置的全流程,涵盖从硬件接线到WorkVisual 6.0软件配置的实战步骤。重点介绍了KPP驱动模块连接、电机参数匹配、安全配置激活及零点标定等关键环节,并提供了实用的避坑指南,旨在帮助工程师高效、安全地完成外部轴集成,提升工作站柔性。

weixin_29161785的博客 507

Java模拟消息队列

今天面大数据架构师实习生,被问到怎么使用Java来实现简单的消息队列,,一脸懵逼,,, package com; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; /** * created by LMR on 2019/7/10 */ public cl...

LMR的博客 7703

【STM32Cube HAL】输入捕获(六)——PWM测量

实验内容:使用通用定时器输入捕获测量信号的脉宽(检测按键按下的时间)。 一、原理图 二、 CubeMX配置 Step1.打开 STM32CubeMX,点击“New Project”,选择芯片型号,STM32F103VETx。 Step2.选择时钟源,并配置时钟树。选择Crystal/Ceramic Resonator,并配置系统时钟为72M。 Step3.配置SYS,我们这里选择的是Serial Wire。(正常情况配置不配置不影响,debug可以使用。但是你不可以把这...

HAHAHA 1万+

java基础(十三)消息队列

消息队列(Message Queue,简称 MQ)是一种用于在不同系统、服务或组件之间传递消息的通信机制。你可以将其理解为一个中间转发器,负责接收、存储和投递消息,实现系统间的解耦、异步通信和流量削峰。消息队列作为分布式系统的核心组件,在现代架构中扮演着越来越重要的角色。

2301_79028279的博客 1741

基于STM32设计的老人摔倒检测报警系统【升级版】(235)

在 `235 基于STM32设计的老人摔倒检测报警系统(OneNet+MQTT)` 项目基础上增加了心率、血氧、体温测量3个功能。

1511

Loop Engineering 来了:从写 Prompt 到设计 Loop,AI 编程的第四次范式跃迁

文章摘要: Loop Engineering是AI编程领域的新范式,标志着从"人手动喂指令"到"设计自驱动循环"的跃迁。其核心在于通过五个组件(定时器、工作空间、知识体系、连接器和子Agent验证)构建自动化任务流,使AI系统能自主运行。这一概念的火爆源于模型能力和工具链的成熟,使得任务设计成为关键瓶颈。作者指出,从Prompt到Loop的四次范式跃迁(语言学→信息科学→控制论→管理学)反映了人机协作关系的根本变化:人类角色从执行者逐渐退居为目标设定者。落地Loop Engineering的真正挑战在于目标

少说,多做 337

消息队列Java的简单实现

今天看到我们的招牌信息有对消息队列有要求,然后就思索了一翻,网上一搜一大堆。 我可以举个小例子先说明应用场景 假设你的服务器每分钟的处理量为200个,但客户端再峰值的时候可能一分钟会发1000个消息给你,这时候你就可以把他做成队列,然后按正常有序的处理,先进后出(LIFO),先进先出(FIFO)可根据自己的情况进行定夺 stack  先进后出(LIFO)--------java 对应的类 S

刘伊凡2.0 3万+

CAP CDS 和 ABAP Cloud 的 CDS 有什么区别?

摘要:SAP生态中的CAP CDS与ABAP CDS虽同名但存在显著差异。CAP CDS定位为全栈应用的领域模型与服务契约语言,支持声明式建模并直接编译为服务接口;而ABAP CDS更侧重数据语义层,与ABAP平台深度集成,服务于SQL优化和服务发布链路。两者在语法、持久化方式、服务暴露机制及权限模型上均有不同:CAP CDS采用CDL语法,支持模型即服务;ABAP CDS基于ABAP DDL,通过视图定义语义并与RAP框架紧密耦合。这些差异反映了二者在不同平台中的设计哲学和应用场景。

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 208

到底什么是消息队列?Java中如何实现消息队列?

网上查了一些资料,感觉都是概念性的很空泛的东西,可是不知道到底是什么东西,如何在Java中实现并使用…… 在此请教各位前辈到底什么是消息队列?Java中如何实现消息队列? 来个个人通俗的解释吧。 消息队列,顾名思义 首先是个队列。 队列的操作有入队和出队 也就是你有一个程序在产生内容然后入队(生产者) 另一个程序读取内容,内容出队(消费者) 这是最最基本的概念。

Golden_lion的博客 1万+

32GB Jetson Orin SOM 不能刷机问题排查

拿到了一个新的Orin SOM,当用orin Devkit CVB或定制的CVB不能用Linux_For_Tegra刷机,flash日志(JetPack5.0DP和5.0.1DP都失败了) 2. 确认mb2配置中将CVB的eeprom读取大小设置是否为0 ? 已经确认是正常的 在定制的orin cvb flash上使用Orin devkit som,启动是成功的。但新得到的Orin som并不工作可以排除理由:使用Orin Devkit CVB和Orin SOM(不是Devkit SOM)仍然不能

jzwjzw19900922的博客 1499

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

在 Java 中使用 redis 的消息队列服务

关于 redis 我们前面已经讨论过了缓存、分布式锁、分布式唯一标识、LBS服务的用法,这里我们来谈谈利用 redis 来实现一个消息服务。典型的消息服务是一个生产者和消费者模式的服务。一般是有生产者产生消息,将消息发送到队列中。而消息的消费者则监听消息,对消息进行处理。有很多非常优秀的消息队列服务的产品。例如 RabbitMQ、RocketMQ、Kafka 等。这些产品都具备非常高级的功能。可靠性、扩展性都非常的好。但是 redis 自身也能够很简单的实现消息队列的生产者和消费者模式。

BASK2312的博客 4219

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

Java使用Redis实现消息队列

redis实现消息队列时一般使用 list 结构作为队列, rpush 生产消息, lpop 消费消息。当 lpop 没有消息的时候,要适当sleep 一会再重试。若不使用sleep,则可以用指令blpop(该指令在没有消息的时候,它会阻塞住直到消息到来)

21届Java攻城狮&Python民兵 1952

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

Java实现消息队列服务

使用 JAVA 语言自己动手来写一个MQ (类似ActiveMQ,RabbitMQ) 主要角色 首先我们必须需要搞明白 MQ (消息队列) 中的三个基本角色 ProducerBrokerConsumer 整体架构如下所示 自定义协议 首先从上一篇中介绍了协议的相关信息,具体厂商的 MQ(消息队列) 需要遵循某种协议或者自定义协议 , 消息的 生产者和消费者需要遵循其协议(约定)才能后成功地生产...

likunpeng6656201的博客 1万+

Java 消息队列详解

消息队列是一种通过存储消息来实现系统间通信的中间件。消息生产者将消息发送到队列中,消息消费者从队列中取出并处理消息。这种模式实现了生产者和消费者的解耦,即使它们不同时在线,也可以通过消息队列进行通信。

刘可心的博客 2470
上一篇: 消息队列:第二章:安装 ActiveMQ
下一篇: 开发工具:第三章:从gitHub上克隆到Idea和从Idea项目推送到gitHub
Java程序员廖志伟
Java程序员廖志伟 优质创作者: Java技术领域 优质创作者: Java技术领域 领域专家: 后端开发技术领域 领域专家: 后端开发技术领域
博客等级 码龄8年 2万+粉丝 1902原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Java程序员廖志伟

赏我包辣条呗

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值