RocketMQ源码阅读-十-事务消息

news2024/11/15 8:48:57

RocketMQ源码阅读-十-事务消息

  • 交互流程
  • 事务消息发送
    • Producer发送事务消息
    • Broker处理结束事务请求
    • Broker 生成 ConsumeQueue
  • 事务消息回查
    • Broker发起回查
    • Producer 接收回查
  • 总结

交互流程

事务消息交互流程图如下：
image.png
事务消息发送步骤如下：

  1. 生产者将半事务消息发送至云消息队列 RocketMQ 版服务端。
  2. 云消息队列 RocketMQ 版服务端将消息持久化成功之后，向生产者返回Ack确认消息已经发送成功，此时消息为半事务消息。
  3. 生产者开始执行本地事务逻辑。
  4. 生产者根据本地事务执行结果向服务端提交二次确认结果（Commit或是Rollback），服务端收到确认结果后处理逻辑如下：
    • 二次确认结果为Commit：服务端将半事务消息标记为可投递，并投递给消费者。
    • 二次确认结果为Rollback：服务端将回滚事务，不会将半事务消息投递给消费者。
  5. 在断网或者是生产者应用重启的特殊情况下，若服务端未收到发送者提交的二次确认结果，或服务端收到的二次确认结果为Unknown未知状态，经过固定时间后，服务端将对消息生产者即生产者集群中任一生产者实例发起消息回查。

事务消息回查步骤如下：

  1. 生产者收到消息回查后，需要检查对应消息的本地事务执行的最终结果。
  2. 生产者根据检查得到的本地事务的最终状态再次提交二次确认，服务端仍按照步骤4对半事务消息进行处理。

事务消息发送

Producer发送事务消息

Producer发送事务消息的代码在类DefaultMQProducerImpl#sendMessageInTransaction方法中，源码如下：

/**
 * 发送事务消息
 *
 * @param msg 消息
 * @param tranExecuter 【本地事务】执行器
 * @param arg 【本地事务】执行器参数
 * @return 事务发送结果
 * @throws MQClientException 当 Client 发生异常时
 */
public TransactionSendResult sendMessageInTransaction(final Message msg, final LocalTransactionExecuter tranExecuter, final Object arg)
throws MQClientException {
    if (null == tranExecuter) {
        throw new MQClientException("tranExecutor is null", null);
    }
    Validators.checkMessage(msg, this.defaultMQProducer);

    // 发送【Half消息】
    SendResult sendResult;
    MessageAccessor.putProperty(msg, MessageConst.PROPERTY_TRANSACTION_PREPARED, "true");
    MessageAccessor.putProperty(msg, MessageConst.PROPERTY_PRODUCER_GROUP, this.defaultMQProducer.getProducerGroup());
    try {
        sendResult = this.send(msg);
    } catch (Exception e) {
        throw new MQClientException("send message Exception", e);
    }

    // 处理发送【Half消息】结果
    LocalTransactionState localTransactionState = LocalTransactionState.UNKNOW;
    Throwable localException = null;
    switch (sendResult.getSendStatus()) {
            // 发送【Half消息】成功，执行【本地事务】逻辑
        case SEND_OK: {
            try {
                if (sendResult.getTransactionId() != null) { // 事务编号。目前开源版本暂时没用到，猜想ONS在使用。
                    msg.putUserProperty("__transactionId__", sendResult.getTransactionId());
                }

                // 执行【本地事务】逻辑
                localTransactionState = tranExecuter.executeLocalTransactionBranch(msg, arg);
                if (null == localTransactionState) {
                    localTransactionState = LocalTransactionState.UNKNOW;
                }

                if (localTransactionState != LocalTransactionState.COMMIT_MESSAGE) {
                    log.info("executeLocalTransactionBranch return {}", localTransactionState);
                    log.info(msg.toString());
                }
            } catch (Throwable e) {
                log.info("executeLocalTransactionBranch exception", e);
                log.info(msg.toString());
                localException = e;
            }
        }
            break;
            // 发送【Half消息】失败，标记【本地事务】状态为回滚
        case FLUSH_DISK_TIMEOUT:
        case FLUSH_SLAVE_TIMEOUT:
        case SLAVE_NOT_AVAILABLE:
            localTransactionState = LocalTransactionState.ROLLBACK_MESSAGE;
            break;
        default:
            break;
    }

    // 结束事务：提交消息 COMMIT / ROLLBACK
    try {
        this.endTransaction(sendResult, localTransactionState, localException);
    } catch (Exception e) {
        log.warn("local transaction execute " + localTransactionState + ", but end broker transaction failed", e);
    }

    // 返回【事务发送结果】
    TransactionSendResult transactionSendResult = new TransactionSendResult();
    transactionSendResult.setSendStatus(sendResult.getSendStatus());
    transactionSendResult.setMessageQueue(sendResult.getMessageQueue());
    transactionSendResult.setMsgId(sendResult.getMsgId());
    transactionSendResult.setQueueOffset(sendResult.getQueueOffset());
    transactionSendResult.setTransactionId(sendResult.getTransactionId());
    transactionSendResult.setLocalTransactionState(localTransactionState);
    return transactionSendResult;
}

事务的最后结束，执行Commit或者rollback，调用的方法：

/**
 * 结束事务：提交消息 COMMIT / ROLLBACK
 *
 * @param sendResult 发送【Half消息】结果
 * @param localTransactionState 【本地事务】状态
 * @param localException 执行【本地事务】逻辑产生的异常
 * @throws RemotingException 当远程调用发生异常时
 * @throws MQBrokerException 当 Broker 发生异常时
 * @throws InterruptedException 当线程中断时
 * @throws UnknownHostException 当解码消息编号失败是
 */
public void endTransaction(//
    final SendResult sendResult, //
    final LocalTransactionState localTransactionState, //
    final Throwable localException) throws RemotingException, MQBrokerException, InterruptedException, UnknownHostException {
    // 解码消息编号
    final MessageId id;
    if (sendResult.getOffsetMsgId() != null) {
        id = MessageDecoder.decodeMessageId(sendResult.getOffsetMsgId());
    } else {
        id = MessageDecoder.decodeMessageId(sendResult.getMsgId());
    }

    // 创建请求
    String transactionId = sendResult.getTransactionId();
    final String brokerAddr = this.mQClientFactory.findBrokerAddressInPublish(sendResult.getMessageQueue().getBrokerName());
    EndTransactionRequestHeader requestHeader = new EndTransactionRequestHeader();
    requestHeader.setTransactionId(transactionId);
    requestHeader.setCommitLogOffset(id.getOffset());
    switch (localTransactionState) {
        case COMMIT_MESSAGE:
            requestHeader.setCommitOrRollback(MessageSysFlag.TRANSACTION_COMMIT_TYPE);
            break;
        case ROLLBACK_MESSAGE:
            requestHeader.setCommitOrRollback(MessageSysFlag.TRANSACTION_ROLLBACK_TYPE);
            break;
        case UNKNOW:
            requestHeader.setCommitOrRollback(MessageSysFlag.TRANSACTION_NOT_TYPE);
            break;
        default:
            break;
    }
    requestHeader.setProducerGroup(this.defaultMQProducer.getProducerGroup());
    requestHeader.setTranStateTableOffset(sendResult.getQueueOffset());
    requestHeader.setMsgId(sendResult.getMsgId());
    String remark = localException != null ? ("executeLocalTransactionBranch exception: " + localException.toString()) : null;

    // 提交消息 COMMIT / ROLLBACK。！！！通信方式为：Oneway！！！
    this.mQClientFactory.getMQClientAPIImpl().endTransactionOneway(brokerAddr, requestHeader, remark, this.defaultMQProducer.getSendMsgTimeout());
}

至此，Producer对于事务消息的处理就结束了，后面的逻辑交给Broker处理。

Broker处理结束事务请求

Broker处理事务消息在类EndTransactionProcessor中:

/**
 * 结束事务，提交/回滚消息
 *
 * @param ctx ctx
 * @param request 请求
 * @return 响应
 * @throws RemotingCommandException 当解析请求失败时
 */
@Override
public RemotingCommand processRequest(ChannelHandlerContext ctx, RemotingCommand request) throws RemotingCommandException {
    final RemotingCommand response = RemotingCommand.createResponseCommand(null);
    final EndTransactionRequestHeader requestHeader = (EndTransactionRequestHeader) request.decodeCommandCustomHeader(EndTransactionRequestHeader.class);

    // 打印日志（只处理 COMMIT / ROLLBACK）
    if (requestHeader.getFromTransactionCheck()) {
        switch (requestHeader.getCommitOrRollback()) {
            case MessageSysFlag.TRANSACTION_NOT_TYPE: {
                LOGGER.warn("check producer[{}] transaction state, but it's pending status."
                            + "RequestHeader: {} Remark: {}",
                            RemotingHelper.parseChannelRemoteAddr(ctx.channel()),
                            requestHeader.toString(),
                            request.getRemark());
                return null;
            }

            case MessageSysFlag.TRANSACTION_COMMIT_TYPE: {
                LOGGER.warn("check producer[{}] transaction state, the producer commit the message."
                            + "RequestHeader: {} Remark: {}",
                            RemotingHelper.parseChannelRemoteAddr(ctx.channel()),
                            requestHeader.toString(),
                            request.getRemark());

                break;
            }

            case MessageSysFlag.TRANSACTION_ROLLBACK_TYPE: {
                LOGGER.warn("check producer[{}] transaction state, the producer rollback the message."
                            + "RequestHeader: {} Remark: {}",
                            RemotingHelper.parseChannelRemoteAddr(ctx.channel()),
                            requestHeader.toString(),
                            request.getRemark());
                break;
            }
            default:
                return null;
        }
    } else {
        switch (requestHeader.getCommitOrRollback()) {
            case MessageSysFlag.TRANSACTION_NOT_TYPE: {
                LOGGER.warn("the producer[{}] end transaction in sending message,  and it's pending status."
                            + "RequestHeader: {} Remark: {}",
                            RemotingHelper.parseChannelRemoteAddr(ctx.channel()),
                            requestHeader.toString(),
                            request.getRemark());
                return null;
            }

            case MessageSysFlag.TRANSACTION_COMMIT_TYPE: {
                break;
            }

            case MessageSysFlag.TRANSACTION_ROLLBACK_TYPE: {
                LOGGER.warn("the producer[{}] end transaction in sending message, rollback the message."
                            + "RequestHeader: {} Remark: {}",
                            RemotingHelper.parseChannelRemoteAddr(ctx.channel()),
                            requestHeader.toString(),
                            request.getRemark());
                break;
            }
            default:
                return null;
        }
    }

    // 查询提交的消息
    final MessageExt msgExt = this.brokerController.getMessageStore().lookMessageByOffset(requestHeader.getCommitLogOffset());
    if (msgExt != null) {
        // 校验 producerGroup
        final String pgroupRead = msgExt.getProperty(MessageConst.PROPERTY_PRODUCER_GROUP);
        if (!pgroupRead.equals(requestHeader.getProducerGroup())) {
            response.setCode(ResponseCode.SYSTEM_ERROR);
            response.setRemark("the producer group wrong");
            return response;
        }

        // 校验 队列位置
        if (msgExt.getQueueOffset() != requestHeader.getTranStateTableOffset()) {
            response.setCode(ResponseCode.SYSTEM_ERROR);
            response.setRemark("the transaction state table offset wrong");
            return response;
        }

        // 校验 CommitLog物理位置
        if (msgExt.getCommitLogOffset() != requestHeader.getCommitLogOffset()) {
            response.setCode(ResponseCode.SYSTEM_ERROR);
            response.setRemark("the commit log offset wrong");
            return response;
        }

        // 生成消息
        MessageExtBrokerInner msgInner = this.endMessageTransaction(msgExt);
        msgInner.setSysFlag(MessageSysFlag.resetTransactionValue(msgInner.getSysFlag(), requestHeader.getCommitOrRollback()));
        msgInner.setQueueOffset(requestHeader.getTranStateTableOffset());
        msgInner.setPreparedTransactionOffset(requestHeader.getCommitLogOffset());
        msgInner.setStoreTimestamp(msgExt.getStoreTimestamp());
        if (MessageSysFlag.TRANSACTION_ROLLBACK_TYPE == requestHeader.getCommitOrRollback()) {
            msgInner.setBody(null);
        }

        // 存储生成消息
        final MessageStore messageStore = this.brokerController.getMessageStore();
        final PutMessageResult putMessageResult = messageStore.putMessage(msgInner);

        // 处理存储结果
        if (putMessageResult != null) {
            switch (putMessageResult.getPutMessageStatus()) {
                // Success
                case PUT_OK:
                case FLUSH_DISK_TIMEOUT:
                case FLUSH_SLAVE_TIMEOUT:
                case SLAVE_NOT_AVAILABLE:
                    response.setCode(ResponseCode.SUCCESS);
                    response.setRemark(null);
                    break;
                // Failed
                case CREATE_MAPEDFILE_FAILED:
                    response.setCode(ResponseCode.SYSTEM_ERROR);
                    response.setRemark("create maped file failed.");
                    break;
                case MESSAGE_ILLEGAL:
                case PROPERTIES_SIZE_EXCEEDED:
                    response.setCode(ResponseCode.MESSAGE_ILLEGAL);
                    response.setRemark("the message is illegal, maybe msg body or properties length not matched. msg body length limit 128k, msg properties length limit 32k.");
                    break;
                case SERVICE_NOT_AVAILABLE:
                    response.setCode(ResponseCode.SERVICE_NOT_AVAILABLE);
                    response.setRemark("service not available now.");
                    break;
                case OS_PAGECACHE_BUSY:
                    response.setCode(ResponseCode.SYSTEM_ERROR);
                    response.setRemark("OS page cache busy, please try another machine");
                    break;
                case UNKNOWN_ERROR:
                    response.setCode(ResponseCode.SYSTEM_ERROR);
                    response.setRemark("UNKNOWN_ERROR");
                    break;
                default:
                    response.setCode(ResponseCode.SYSTEM_ERROR);
                    response.setRemark("UNKNOWN_ERROR DEFAULT");
                    break;
            }

            return response;
        } else {
            response.setCode(ResponseCode.SYSTEM_ERROR);
            response.setRemark("store putMessage return null");
        }
    } else {
        response.setCode(ResponseCode.SYSTEM_ERROR);
        response.setRemark("find prepared transaction message failed");
        return response;
    }

    return response;
}

Broker 生成 ConsumeQueue

事务消息，提交（COMMIT）后才生成 ConsumeQueue。

/**
 * 执行调度请求
 * 1. 非事务消息 或 事务提交消息 建立 消息位置信息 到 ConsumeQueue
 * 2. 建立 索引信息 到 IndexFile
 *
 * @param req 调度请求
 */
public void doDispatch(DispatchRequest req) {
    // 非事务消息 或 事务提交消息 建立 消息位置信息 到 ConsumeQueue
    final int tranType = MessageSysFlag.getTransactionValue(req.getSysFlag());
    switch (tranType) {
        case MessageSysFlag.TRANSACTION_NOT_TYPE: // 非事务消息
        case MessageSysFlag.TRANSACTION_COMMIT_TYPE: // 事务消息COMMIT
            DefaultMessageStore.this.putMessagePositionInfo(req.getTopic(), req.getQueueId(), req.getCommitLogOffset(), req.getMsgSize(),
                req.getTagsCode(), req.getStoreTimestamp(), req.getConsumeQueueOffset());
            break;
        case MessageSysFlag.TRANSACTION_PREPARED_TYPE: // 事务消息PREPARED
        case MessageSysFlag.TRANSACTION_ROLLBACK_TYPE: // 事务消息ROLLBACK
            break;
    }
    // 建立 索引信息 到 IndexFile
    if (DefaultMessageStore.this.getMessageStoreConfig().isMessageIndexEnable()) {
        DefaultMessageStore.this.indexService.buildIndex(req);
    }
}

/**
 * 建立 消息位置信息 到 ConsumeQueue
 *
 * @param topic 主题
 * @param queueId 队列编号
 * @param offset commitLog存储位置
 * @param size 消息长度
 * @param tagsCode 消息tagsCode
 * @param storeTimestamp 存储时间
 * @param logicOffset 队列位置
 */
public void putMessagePositionInfo(String topic, int queueId, long offset, int size, long tagsCode, long storeTimestamp,
                                   long logicOffset) {
    ConsumeQueue cq = this.findConsumeQueue(topic, queueId);
    cq.putMessagePositionInfoWrapper(offset, size, tagsCode, storeTimestamp, logicOffset);
}

事务消息回查

在断网或者是生产者应用重启的特殊情况下，若服务端未收到发送者提交的二次确认结果，或服务端收到的二次确认结果为Unknown未知状态，经过固定时间后，服务端将对消息生产者即生产者集群中任一生产者实例发起消息回查。

Broker发起回查

暂时不看

Producer 接收回查

Producer接收事务消息回查的代码在DefaultMQProducerImpl#checkTransactionState：

/**
 * 检查【事务状态】状态
 *
 * @param addr broker地址
 * @param msg 消息
 * @param header 请求
 */
@Override
public void checkTransactionState(final String addr, final MessageExt msg, final CheckTransactionStateRequestHeader header) {
    Runnable request = new Runnable() {
        private final String brokerAddr = addr;
        private final MessageExt message = msg;
        private final CheckTransactionStateRequestHeader checkRequestHeader = header;
        private final String group = DefaultMQProducerImpl.this.defaultMQProducer.getProducerGroup();

        @Override
        public void run() {
            TransactionCheckListener transactionCheckListener = DefaultMQProducerImpl.this.checkListener();
            if (transactionCheckListener != null) {
                // 获取事务执行状态
                LocalTransactionState localTransactionState = LocalTransactionState.UNKNOW;
                Throwable exception = null;
                try {
                    localTransactionState = transactionCheckListener.checkLocalTransactionState(message);
                } catch (Throwable e) {
                    log.error("Broker call checkTransactionState, but checkLocalTransactionState exception", e);
                    exception = e;
                }

                // 处理事务结果，提交消息 COMMIT / ROLLBACK
                this.processTransactionState(//
                    localTransactionState, //
                    group, //
                    exception);
            } else {
                log.warn("checkTransactionState, pick transactionCheckListener by group[{}] failed", group);
            }
        }

        /**
         * 处理事务结果，提交消息 COMMIT / ROLLBACK
         *
         * @param localTransactionState 【本地事务】状态
         * @param producerGroup producerGroup
         * @param exception 检查【本地事务】状态发生的异常
         */
        private void processTransactionState(//
            final LocalTransactionState localTransactionState, //
            final String producerGroup, //
            final Throwable exception) {
            final EndTransactionRequestHeader thisHeader = new EndTransactionRequestHeader();
            thisHeader.setCommitLogOffset(checkRequestHeader.getCommitLogOffset());
            thisHeader.setProducerGroup(producerGroup);
            thisHeader.setTranStateTableOffset(checkRequestHeader.getTranStateTableOffset());
            thisHeader.setFromTransactionCheck(true);

            // 设置消息编号
            String uniqueKey = message.getProperties().get(MessageConst.PROPERTY_UNIQ_CLIENT_MESSAGE_ID_KEYIDX);
            if (uniqueKey == null) {
                uniqueKey = message.getMsgId();
            }
            thisHeader.setMsgId(uniqueKey);

            thisHeader.setTransactionId(checkRequestHeader.getTransactionId());
            switch (localTransactionState) {
                case COMMIT_MESSAGE:
                    thisHeader.setCommitOrRollback(MessageSysFlag.TRANSACTION_COMMIT_TYPE);
                    break;
                case ROLLBACK_MESSAGE:
                    thisHeader.setCommitOrRollback(MessageSysFlag.TRANSACTION_ROLLBACK_TYPE);
                    log.warn("when broker check, client rollback this transaction, {}", thisHeader);
                    break;
                case UNKNOW:
                    thisHeader.setCommitOrRollback(MessageSysFlag.TRANSACTION_NOT_TYPE);
                    log.warn("when broker check, client does not know this transaction state, {}", thisHeader);
                    break;
                default:
                    break;
            }

            String remark = null;
            if (exception != null) {
                remark = "checkLocalTransactionState Exception: " + RemotingHelper.exceptionSimpleDesc(exception);
            }

            try {
                // 提交消息 COMMIT / ROLLBACK
                DefaultMQProducerImpl.this.mQClientFactory.getMQClientAPIImpl().endTransactionOneway(brokerAddr, thisHeader, remark,
                    3000);
            } catch (Exception e) {
                log.error("endTransactionOneway exception", e);
            }
        }
    };

    // 提交执行
    this.checkExecutor.submit(request);
}

该方法会调用发送事务消息时，创建的事务消息监听器，来查询本地事务的状态：

/**
 * 【事务消息回查】检查监听器
 */
public interface TransactionCheckListener {

    /**
     * 获取（检查）【本地事务】状态
     *
     * @param msg 消息
     * @return 事务状态
     */
    LocalTransactionState checkLocalTransactionState(final MessageExt msg);

}

根据本地事务的状态执行Commit或者Rollback。

总结

本篇分析了RocketMQ关于事务消息的实现。

  • Producer发送事务消息会先发送一个half消息，并注册一个事务消息回查监听器
  • 本地事务提交后，Producer会发送half消息提交消息
  • 本地事务回滚，Producer会发送half消息回滚消息
  • 若因网路等问题，迟迟没有收到提交或回滚消息，Broker会发起事务消息反查
  • Producer收到事务消息反查请求，执行创建事务消息时注册的监听器，查询本地消息的状态，根据本地消息的状态决定是Commit还是Rollback事务消息

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

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

相关文章

redis-持久化-1

redis-持久化-1

Redis 提供了2个不同形式的持久化方式。 RDB（Redis DataBase） AOF（Append Of File） 一、Redis持久化之RDB 1.什么是RDB 在指定的时间间隔内将内存中的数据集快照写入磁盘， 也就是行话讲的Snapshot快照&#xff0c…
阅读更多...
爬虫是什么 怎么预防

爬虫是什么 怎么预防

爬虫是一种自动化程序，用于从网页或网站中提取数据。它们通过模拟人类用户的行为，发送HTTP请求并解析响应，以获取所需的信息。 爬虫可以用于各种合法用途，如搜索引擎索引、数据采集和监测等。然而，有些爬虫可能是恶意的…
阅读更多...
HarmonyOS4.0系统性深入开发26方舟开发框架（ArkUI）概述

HarmonyOS4.0系统性深入开发26方舟开发框架（ArkUI）概述

方舟开发框架（ArkUI）概述 方舟开发框架（简称ArkUI）为HarmonyOS应用的UI开发提供了完整的基础设施，包括简洁的UI语法、丰富的UI功能（组件、布局、动画以及交互事件），以及实时界面预览…
阅读更多...
低代码是软件开发的未来吗？

低代码是软件开发的未来吗？

一、前言 低代码开发是近年来在网络开发领域备受关注的一个趋势。低代码开发是指使用最少的编程代码来开发应用程序或业务逻辑，这使得即使是没有IT或编程经验的初学者也能快速创建所需的功能。 虽然低代码开发还没有威胁到传统开发者的角色，但不可否认的…
阅读更多...
【嵌入式学习】C++QT-Day2-C++基础

【嵌入式学习】C++QT-Day2-C++基础

笔记 见我的博客：https://lingjun.life/wiki/EmbeddedNote/19Cpp 作业 自己封装一个矩形类(Rect)，拥有私有属性:宽度(width)、高度(height)， 定义公有成员函数: 初始化函数:void init(int w, int h) 更改宽度的函数:set_w(int w) 更改高度…
阅读更多...
Nginx日志检测分析工具 - WGCLOUD

Nginx日志检测分析工具 - WGCLOUD

WGCLOUD可以对Nginx的日志文件进行全面分析，包括IP、sql注入攻击、搜索引擎蜘蛛爬取记录、HTTP响应状态码、访问量最高的IP统计、扫描攻击统计等 效果如下图
阅读更多...
前端学习：HTTP协议、请求响应、分层解耦

前端学习：HTTP协议、请求响应、分层解耦

HTTP协议 HTTP-概述 HTTP：Hyper Text Transfer Protocol(超文本传输协议)，规定了浏览器与服务器之间数据传输的规则。如果想知道http协议的数据传输格式有哪些，可以打开浏览器，点击 F12 打开开发者工具，点击Network 来…
阅读更多...
国民技术N32G430C8开发笔记一-新建IAR工程

国民技术N32G430C8开发笔记一-新建IAR工程

一、创建IAR工程 1、新建工程，保存到project文件夹。 2、添加SDK到工程。 根据原厂SDK的文件结构在IAR新建相应分组，把各个文件夹的文件加载进去，其中startup文件选择IAR平台的startup_n32g430_EWARM.s。 3、添加头文件路径&#xff0…
阅读更多...
springboot124中药实验管理系统设计与实现

springboot124中药实验管理系统设计与实现

简介 【毕设源码推荐 javaweb 项目】基于springbootvue 的中药实验管理系统设计与实现 适用于计算机类毕业设计，课程设计参考与学习用途。仅供学习参考， 不得用于商业或者非法用途，否则，一切后果请用户自负。 看运行截图看 第五章…
阅读更多...
Java 枚举和注解

Java 枚举和注解

一、枚举类 把具体的对象一个一个例举出来的类就称为枚举类 枚举对应英文(enumeration, 简写 enum)枚举是一组常量的集合。可以这里理解：枚举属于一种特殊的类，里面只包含一组有限的特定的对象。 1.实现方式1——自定义类实现枚举 public class Enume…
阅读更多...
HarmonyOS 讨论一下 TextInput的inputFilter正则表达式解决方案

HarmonyOS 讨论一下 TextInput的inputFilter正则表达式解决方案

我们 TextInput组件中有这样一个属性 inputFilter 按官方文档的描述 它有两个行参 第一个是字符串类型的 就是 正则表达式 你要怎么去匹配内容 然后 第二个是一个函数 它可以接到一个行参 如果错误时 第二个参数的方法才会执行 行参字符串类型输出被过滤的无效内容 我们可以这…
阅读更多...
力扣hot100 两数相加 链表 思维

力扣hot100 两数相加 链表 思维

Problem: 2. 两数相加 Code ⏰ 时间复杂度: O ( n ) O(n) O(n) 🌎 空间复杂度: O ( n ) O(n) O(n) /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}* ListNode(int val) { this.…
阅读更多...
【代码随想录】刷题笔记Day53

【代码随想录】刷题笔记Day53

前言 不用开组会的我是多么阳光开朗，这周就要离开杭州回家啦，多刷题刷题 115. 不同的子序列 - 力扣（LeetCode） dp[i][j] 以i-1为结尾的s子序列中出现以j-1为结尾的t的个数为dp[i][j]递推公式 dp[i][j] dp[i - 1][j - 1] dp[i…
阅读更多...
前端动画特效分享（附效果图及在线演示）

前端动画特效分享（附效果图及在线演示）

分享7款有趣也实用的前端动画特效 其中有CSS动画、canvas动画、js小游戏等等 下方效果图可能不是特别的生动 那么你可以点击在线预览进行查看相应的动画特效 同时也是可以下载该资源的 SVG天气图标动画特效 SVG天气图标动画特效 不管是晴天雨天等都很完美的展示出了各自真实的…
阅读更多...
Linux——shell程序的简单实现

Linux——shell程序的简单实现

shell程序的简单实现 本章思维导图： 注：本章思维导图对应的.xmind和.png文件都已同步导入至资源，可免费查阅 在学习完有关进程的知识后，我们就可以开始尝试自己实现一个简单的shell程序了。 注：在编写简单的shell程…
阅读更多...
R语言-检验正态性

R语言-检验正态性

1.为什么要检验正态性 首先需要明确正态性与正态分布是有区别的，正态分布（标准分布）是统计数据的分布方式，是个钟形曲线，已平均值为对称轴，数据在对称轴两侧对称分布。正态性是检验实际数据与标准正态分布…
阅读更多...
基于Java SSM框架实现在线考试系统项目【项目源码+论文说明】

基于Java SSM框架实现在线考试系统项目【项目源码+论文说明】

基于java的SSM框架实现在线考试系统演示 摘要 21世纪的今天，随着社会的不断发展与进步，人们对于信息科学化的认识，已由低层次向高层次发展，由原来的感性认识向理性认识提高，管理工作的重要性已逐渐被人们所认识&#…
阅读更多...
字符金字塔（C语言刷题）

字符金字塔（C语言刷题）

个人博客主页：https://blog.csdn.net/2301_79293429?typeblog 专栏：https://blog.csdn.net/2301_79293429/category_12545690.html 题目描述 请打印输出一个字符金字塔，字符金字塔的特征请参考样例 输入描述: 输入一个字母，保…
阅读更多...
06.搭建一个自己的私有仓库-Gitea

06.搭建一个自己的私有仓库-Gitea

06.搭建一个自己的私有仓库-Gitea | DLLCNX的博客 如果你是一位程序员或者IT相关领域的从业者，那么肯定知道git，而且也或多或少接触了不少开源仓库以及公司的私有仓库，但是我们有没有想过自己也搭建一个私有仓库呢。 这么多开源仓库&#xf…
阅读更多...
C++练习题1-9

C++练习题1-9

文章目录 NO1、选出妃子、宫女和嬷嬷No2、根据数字判断月份No3、循环计数No4、循环选数No5、玩转字符No6、计算字符串长度No7、显示字符串中的字符No8、字符串反转No9、二维数组的应用 NO1、选出妃子、宫女和嬷嬷 其他要求： 超女用结构体表示不要嵌套if输入所有数据…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023