rabbitmq多数据源连接配置

原创 已于 2022-11-16 15:03:32 修改 · 2.4k 阅读 · 7 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java-rabbitmq #rabbitmq #java

于 2022-11-16 15:03:11 首次发布
本文详细介绍了如何配置Spring框架中的RabbitMQ连接属性，包括连接地址、认证信息、连接池模式，以及如何创建模板和监听容器。还展示了如何创建队列、交换机和绑定，以及在不同场景下的消费者实现和消息处理.

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.mq连接属性文件

spring:
  rabbitmq4esb:
    host: 192.168.0.1
  rabbitmq:
    host: 192.168.1.7
    port: 5672
    username: admin
    password: ********
    virtual-host: /
#连接超时，单位毫秒，0表示无穷大
    connection-timeout: 15000
#缓存的连接数，只有是CONNECTION模式时生效
#spring.rabbitmq.cache.connection.size=16
#连接工厂缓存模式：CHANNEL 和 CONNECTION
#spring.rabbitmq.cache.connection.mode=CHANNEL
#发送重试是否可用
    template:
      retry:
        enabled: true
#最大重试次数
        max-attempts: 5
#第一次和第二次尝试发布或传递消息之间的间隔
        initial-interval: 60000
#应用于上一重试间隔的乘数
        multiplier: 5
#最大重试时间间隔
        max-interval: 1500000

2. mq配置（连接数和连接工厂缓存模式未配置）

package com.java.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.AcknowledgeMode;
import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory.CacheMode;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.env.Environment;

@Configuration
public class RabbitMQTemplateConfig {

	private final Logger logger = LoggerFactory.getLogger(this.getClass());
	
	@Value("${spring.rabbitmq4esb.host}")
	private String addresses4esb;

	@Value("${spring.rabbitmq.host}")
	private String addresses;

	@Value("${spring.rabbitmq.port}")
	private String port;

	@Value("${spring.rabbitmq.username}")
	private String username;

	@Value("${spring.rabbitmq.password}")
	private String password;

	@Value("${spring.rabbitmq.virtual-host}")
	private String virtualHost;
	
	@Value("${spring.rabbitmq.connection-timeout}")
	private String connectionTimeout;
	
	//@Value("${spring.rabbitmq.cache.connection.mode}")
	//private String cacheMode;
	
	//@Value("${spring.rabbitmq.cache.connection.size}")
	//private String cacheSize;
	
	@Autowired
    private Environment env;

	public MessageConverter jsonMessageConverter() {
		return new Jackson2JsonMessageConverter();
	}
	
	
	public ConnectionFactory connectionFactory() {
		CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
		connectionFactory.setAddresses(addresses + ":" + port);
		connectionFactory.setUsername(username);
		connectionFactory.setPassword(password);
		connectionFactory.setVirtualHost(virtualHost);
		connectionFactory.setConnectionTimeout(Integer.valueOf(connectionTimeout));
//		if ("CONNECTION".equals(cacheMode)) {
//			logger.info("connectionFactory CONNECTION cacheMode={}", cacheMode);
//			connectionFactory.setCacheMode(CacheMode.CONNECTION);
//			connectionFactory.setConnectionCacheSize(Integer.valueOf(cacheSize));
//		} else {
//			logger.info("connectionFactory CHANNEL cacheMode={}", cacheMode);
//			connectionFactory.setCacheMode(CacheMode.CHANNEL);
//			connectionFactory.setChannelCacheSize(Integer.valueOf(cacheSize));
//		}
		/** 如果要进行消息回调，则这里必须要设置为true */
		//connectionFactory.setPublisherConfirms(false);
		//connectionFactory.setPublisherReturns(true);
		return connectionFactory;
	}

	@Primary
	@Bean(name = "rabbitMQTemplate")
	public RabbitTemplate rabbitTemplate() {
		RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory());
		rabbitTemplate.setMessageConverter(jsonMessageConverter());
		rabbitTemplate.setUsePublisherConnection(false);
		/****
		rabbitTemplate.setMandatory(false);
		rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {

			@Override
			public void confirm(CorrelationData correlationData, boolean ack, String cause) {
				System.out.println("MsgSendConfirmCallBack  , 回调id:" + correlationData);
		        if (ack) {
		        	logger.info("消息发送成功:correlationData({}),ack({}),cause({})", correlationData, ack, cause);
		        } else {
		            System.out.println("消息消费失败:" + cause+"\n重新发送");
		        }
			}
		});
		****/
		
		/*rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {

			@Override
			public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
				logger.info("消息丢失:exchange({}),route({}),replyCode({}),replyText({}),message:{}", exchange, routingKey,
						replyCode, replyText, message);
			}
		});*/
		return rabbitTemplate;
	}
	
	public ConnectionFactory consumeConnectionFactory() {
		CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
		connectionFactory.setAddresses(addresses + ":" + port);
		connectionFactory.setUsername(username);
		connectionFactory.setPassword(password);
		connectionFactory.setVirtualHost(virtualHost);
		connectionFactory.setConnectionTimeout(Integer.valueOf(connectionTimeout));
//		if ("CONNECTION".equals(cacheMode)) {
//			logger.info("connectionFactory CONNECTION cacheMode={}", cacheMode);
//			connectionFactory.setCacheMode(CacheMode.CONNECTION);
//			//connectionFactory.setConnectionCacheSize(Integer.valueOf(cacheSize));
//		} else {
//			logger.info("connectionFactory CHANNEL cacheMode={}", cacheMode);
//			connectionFactory.setCacheMode(CacheMode.CHANNEL);
//			//connectionFactory.setChannelCacheSize(Integer.valueOf(cacheSize));
//		}
		
		/** 如果要进行消息回调，则这里必须要设置为true */
		//connectionFactory.setPublisherConfirms(false);
		//connectionFactory.setPublisherReturns(true);
		return connectionFactory;
	}

	@Primary
	@Bean(name = "rabbitListenerContainerFactory")
    public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory() {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(consumeConnectionFactory());
        factory.setMessageConverter(new Jackson2JsonMessageConverter());
        factory.setAcknowledgeMode(AcknowledgeMode.NONE);
        factory.setPrefetchCount(100);
        factory.setBatchSize(1);
        return factory;
    }
	

    @Bean(name = "primaryRabbitAdmin")
    @Primary
    public RabbitAdmin primaryRabbitAdmin() {
        RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory());
        //设置忽略声明异常
        rabbitAdmin.setIgnoreDeclarationExceptions(true);
        return rabbitAdmin;
    }
	
	
	
	
	
	
	
	
	public ConnectionFactory connectionFactory4ESB() {
		CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
		connectionFactory.setAddresses(addresses4esb + ":" + port);
		connectionFactory.setUsername(username);
		connectionFactory.setPassword(password);
		connectionFactory.setVirtualHost(virtualHost);
		connectionFactory.setConnectionTimeout(Integer.valueOf(connectionTimeout));
//		if ("CONNECTION".equals(cacheMode)) {
//			logger.info("consumeConnectionFactory4ESB CONNECTION cacheMode={}", cacheMode);
//			connectionFactory.setCacheMode(CacheMode.CONNECTION);
//			//connectionFactory.setConnectionCacheSize(Integer.valueOf(cacheSize));
//		} else {
//			logger.info("consumeConnectionFactory4ESB CHANNEL cacheMode={}", cacheMode);
//			connectionFactory.setCacheMode(CacheMode.CHANNEL);
//			//connectionFactory.setChannelCacheSize(Integer.valueOf(cacheSize));
//		}
		/** 如果要进行消息回调，则这里必须要设置为true */
		//connectionFactory.setPublisherConfirms(false);
		//connectionFactory.setPublisherReturns(true);
		return connectionFactory;
	}

	@Bean(name = "rabbitMQTemplate4ESB")
	public RabbitTemplate rabbitTemplate4ESB() {
		RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory4ESB());
		rabbitTemplate.setMessageConverter(jsonMessageConverter());
		rabbitTemplate.setUsePublisherConnection(false);
		
		return rabbitTemplate;
	}
	
	public ConnectionFactory consumeConnectionFactory4ESB() {
		CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
		connectionFactory.setAddresses(addresses4esb + ":" + port);
		connectionFactory.setUsername(username);
		connectionFactory.setPassword(password);
		connectionFactory.setVirtualHost(virtualHost);
		connectionFactory.setConnectionTimeout(Integer.valueOf(connectionTimeout));
//		if ("CONNECTION".equals(cacheMode)) {
//			logger.info("consumeConnectionFactory4ESB CONNECTION cacheMode={}", cacheMode);
//			connectionFactory.setCacheMode(CacheMode.CONNECTION);
//			//connectionFactory.setConnectionCacheSize(Integer.valueOf(cacheSize));
//		} else {
//			logger.info("consumeConnectionFactory4ESB CHANNEL cacheMode={}", cacheMode);
//			connectionFactory.setCacheMode(CacheMode.CHANNEL);
//			//connectionFactory.setChannelCacheSize(Integer.valueOf(cacheSize));
//		}
		
		/** 如果要进行消息回调，则这里必须要设置为true */
		//connectionFactory.setPublisherConfirms(false);
		//connectionFactory.setPublisherReturns(true);
		return connectionFactory;
	}

	@Bean(name = "rabbitListenerContainerFactory4ESB")
    public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory4ESB() {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(consumeConnectionFactory4ESB());
        factory.setMessageConverter(new Jackson2JsonMessageConverter());
        factory.setAcknowledgeMode(AcknowledgeMode.NONE);
        factory.setPrefetchCount(100);
        factory.setBatchSize(1);
        return factory;
    }
	
    @Bean(name = "secondRabbitAdmin")
    public RabbitAdmin secondRabbitAdmin() {
        RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory4ESB());
        //设置忽略声明异常
        rabbitAdmin.setIgnoreDeclarationExceptions(true);
        return rabbitAdmin;
    }
}

3. 常量

public class MQConstant {
	
	/***
	 * 延迟队列type x-delayed-message
	 */
	public static final String X_DELAYED_MESSAGE = "x-delayed-message";
	/***
	 * 延迟队列args key = "x-delayed-type"
	 */
	public static final String DELAY_ARGS_KEY = "x-delayed-type";
	/***
	 * 延迟队列args value = "direct"
	 */
	public static final String DELAY_ARGS_VALUE = "direct";
	/***
	 * HEADER
	 */
	public static final String DELAY_HEADER_KEY = "x-delay";


	public static final String EXCHANGE132 = "test_exchange132";
	public static final String QUEUE132 = "test_queue132";
	public static final String KEY132 = "queue132";
	
	
	public static final String EXCHANGE74 = "test_exchange74";
	public static final String QUEUE74 = "test_queue74";
	public static final String KEY74 = "queue74";
}

4. 创建队列、交换机以及绑定

import java.util.HashMap;
import java.util.Map;
import javax.annotation.Resource;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.CustomExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MQConfig {

    @Resource(name = "secondRabbitAdmin")
    private RabbitAdmin secondRabbitAdmin;
    @Resource(name = "primaryRabbitAdmin")
    private RabbitAdmin primaryRabbitAdmin;
    
    @Bean
    void delayDeclareBinding132() {
        Queue queue = new Queue(MQConstant.QUEUE132, true);
        secondRabbitAdmin.declareQueue(queue);
    
        CustomExchange delayExchange = delayExchange(MQConstant.EXCHANGE132);
        secondRabbitAdmin.declareExchange(delayExchange);
        secondRabbitAdmin.declareBinding(BindingBuilder.bind(queue).to(delayExchange).with(MQConstant.KEY132).noargs());
    }
    
    @Bean
    void directDeclareBinding74() {
        Queue queue = new Queue(MQConstant.QUEUE74,true);
        primaryRabbitAdmin.declareQueue(queue);
        
        CustomExchange delayExchange = delayExchange(MQConstant.EXCHANGE74);
        primaryRabbitAdmin.declareExchange(delayExchange);
        primaryRabbitAdmin.declareBinding(BindingBuilder.bind(queue).to(delayExchange).with(MQConstant.KEY74).noargs());
    }
    
    public CustomExchange delayExchange(String exchange) {
        Map<String, Object> arguments = new HashMap<>();
        /**
         * 参数说明：
         * 1.交换机的名称
         * 2.交换机的类型
         * 3.是否需要持久化
         * 4.是否自动删除
         * 5.其它参数
         */
        // 参数固定写法 x-delayed-type 延迟插件名称 ,direct 直接模式
        arguments.put(MQConstant.DELAY_ARGS_KEY, MQConstant.DELAY_ARGS_VALUE);
        // 创建交换机
        return new CustomExchange(exchange, MQConstant.X_DELAYED_MESSAGE, true, false, arguments);
    }
    
}

5. 消费

@Component
public class Consumer7 {
	private final Logger log = LoggerFactory.getLogger(this.getClass());
    
	@RabbitListener(queues = MQConstant.QUEUE74, containerFactory = "rabbitListenerContainerFactory", ackMode = "MANUAL", concurrency = "2-12")
	public void doConsume7(Map<String, Object> messageMap, Channel channel, Message message) throws ParseException, IOException{
		try {
			log.info("Consumer192.168.0.7 MQ接收到的消息 messageMap={}, time={}", JSONObject.toJSONString(messageMap), CommonUtils.dateFormat(new Date(), null));
			channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
		} catch (Exception e) {
			log.error("Consumer192.168.0.7  消费时发生异常", e);
		}
	}
	
	
}

@RabbitListener(queues = MQConstant.QUEUE132, containerFactory = "rabbitListenerContainerFactory4ESB", ackMode = "MANUAL", concurrency = "2-12")
public void doConsume1(Map<String, Object> messageMap, Channel channel, Message message)
        throws ParseException, IOException {
    try {
        if (null == messageMap) {
            log.error("Consume192.168.0.1 MQ接收到的消息messageMap为空");
        } else {
            log.info("Consume192.168.0.1 MQ接收到的消息 messageMap={}, time={}", JSONObject.toJSONString(messageMap), CommonUtils.dateFormat(new Date(), null));
        }
        // 此处不做确认，mq管理页面会显示有一个消息Unacked=1，防止程序异常消息丢失
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    } catch (Exception e) {
        log.error("doConsume132 ex:" + e.getMessage(), e);
        e.printStackTrace();
    }

}

6. 测试类

@Resource(name = "rabbitMQTemplate")
private RabbitTemplate rabbitTemplate;

@Resource(name = "rabbitMQTemplate4ESB")
private RabbitTemplate rabbitTemplate4esb;

@Resource
private MqUtils mqUtils;

@RequestMapping(value = "/mq")
public void testMQ() {
    Map<String, Object> paramMap = new HashMap<String, Object>();
    paramMap.put("name", "123456789");
    rabbitTemplate.convertAndSend(MQConstant.EXCHANGE74, MQConstant.KEY74, paramMap);
    rabbitTemplate4esb.convertAndSend(MQConstant.EXCHANGE132, MQConstant.KEY132, paramMap);
    
    paramMap.put("ip", "192.168.0.1");
    paramMap.put("template", "1");
    mqUtils.sendEsb(MQConstant.EXCHANGE132, MQConstant.KEY132, 20000, paramMap);
    
    paramMap.put("ip", "192.168.0.7");
    paramMap.put("template", "7");
    mqUtils.send(MQConstant.EXCHANGE74, MQConstant.KEY74, 30000, paramMap);
    
}

RabbitMQ 多数据源配置
空槐树的博客
09-16 1686
背景 公司多个研发团队，多套 RabbitMQ 地址，同一套地址中，也区分为多个 VirtualHost。如何控制某个 exchange/queue 只创建于某一个 virtualhost 中。 采用 Spring 的 @Configuration 配置方式。???? Spring AMQP 单数据源配置 org.springframework.amqp.rabbit.connection.CachingConnectionFactory org.springframework.a
RabbitMQ 多源配置，并配置开关
haoranhaoshi的博客
10-10 1193
RabbitMQ多源配置
SpringBoot集成RabbitMQ配置多数据源
qq_26432153的博客
03-07 1330
SpringBoot集成rabbitmq，并配置多个rabbitmq数据源，并测试
Spring Boot RabbitMQ多数据源配置
weixin_46993901的博客
09-06 891
在构建复杂的应用程序时，经常需要与多个数据源进行交互。这可能包括连接多个数据库、消息队列或其他数据存储系统。RabbitMQ 是一个流行的消息队列系统，它通过消息队列实现了应用程序之间的松耦合，适用于异步任务处理、解耦、削峰填谷等场景。本篇博客将介绍如何在 Spring Boot 中配置和管理多个 RabbitMQ 数据源，以满足不同的应用需求，并提供示例代码首先，在 文件中添加 RabbitMQ 的 Spring Boot Starter 依赖，以便引入 RabbitMQ 相关的库和功能。 2. 抽象类
详解Spring Boot 配置多个RabbitMQ
08-30
本篇文章主要介绍了Spring Boot 配置多个RabbitMQ，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
springboot整合rabbitMq和多数据源动态切换和跨域访问和gradle加maven和shiro安全框架和lombok自动getset生成
05-21
3. **多数据源动态切换**: 在一个项目中可能需要连接多个数据库，Spring Boot支持配置多个数据源，并可以通过条件注解或配置中心进行动态切换，实现读写分离、数据隔离等需求。 4. **跨域访问**: 在前后端分离的...
SpringBoot项目中的RabbitMQ多数据源订阅消费解决方案
4. 多数据源连接： 在Spring Boot应用中，连接多个数据源是一项常见的需求，尤其是在涉及到多种类型数据库（如Oracle和MySQL）时。通过配置数据源和JDBC模板或事务管理器，Spring Boot应用可以同时与多个数据库进行...
springboot整合JTA组件，多数据源事务管理
最新发布
06-25
一个JTA事务可以有多个参与者，而一个JDBC事务则被限定在一个单一的数据库连接。下列任一个Java平台的组件都可以参与到一个JTA事务中 2、分布式事务 分布式事务（DistributedTransaction）包括事务管理器...
SpringBoot+Rabbitmq多连接多队列
qq_37822565的博客
05-24 305
【代码】SpringBoot+Rabbitmq多连接多队列。
RabbitMQ的配置与使用
冰点契约的博客
09-12 488
安装RabbitMQ 安装⽅式1(推荐): 1.安装Erlang：Erlang官网 2.安装RabbitMQ：RabbitMQ官网 3.rabbitmq-server安装包下载 安装⽅式2: # 1. 安装erlang #由于rabbitmq需要erlang语⾔言的支持，在安装rabbitmq之前需要安装erlang sudo apt-get install erlang-nox # 2. 安装Rabbitmq #更新源 sudo apt-get update #安装 sudo apt-get instal
Spring Boot 整合 RabbitMQ 多数据 测试用例
qq_42697946的博客
05-12 555
大千世界，奇葩需求千千万，为应对开发中可能会遇到到业务场景，需要我们连接多个MQ，因此本篇文章应运而生，希望能得到....
RABBIT MQ 连接服务配置
wsen1988的博客
05-17 1683
&lt;?xml version="1.0" encoding="UTF-8"?&gt;&lt;beans xmlns="http://www.springframework.org/schema/beans"    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    xmlns:rabbit="http://www.springfr
rabbitmq 连接、通道及线程池说明和配置
热门推荐
convict_EVA的专栏
09-05 2万+
bean id="connectionFactory" class="org.springframework.amqp.rabbit.connection.CachingConnectionFactory"> property name="host" value="${rabbitmq.host}" /> property name="port" value="${rabbit
2020-11-10
qq_51986815的博客
11-10 266
2020-11-10 发布 大数据生态系统 Hadoop是一个用Java写好的软件，只要计算机安装好了jdk就可以部署Hadoop. 在这里插入图片描述HDFS，是Hadoop Distributed File System的简称，是Hadoop抽象文件系统的一种实现。Hadoop抽象文件系统可以与本地系统、Amazon S3等集成，甚至可以通过Web协议（webhsfs）来操作。HDFS的文件分布在集群机器上，同时提供副本进行容错及可靠性保证。例如客户端写入读取文件的直接操作都是分布在集群各个机器上的，没
修改RabbitMQ最大连接数
Sunshine
04-22 1502
https://blog.csdn.net/weixin_34268579/article/details/92171002
RabbitMQ 参数配置说明
普通人一枚
09-20 1708
【代码】RabbitMQ 参数配置说明。
RabbitMQ——最大连接数
hncscwc的博客
08-30 1万+
默认情况下，rabbitmq文件句柄数设置是1024。连接数最多为829，连接数的具体计算方式为： 连接数=（文件句柄数-100）*0.9，计算后的值取整再减2。 例如：（1024-100）*0.9=831.6，取整831再减2得到829。 真正使用时，1024可能无法满足实际需求。这个时候，一般通过ulimit来调整程序的最大文件句柄数。下图为通过ulimit将文件句柄数调整到1024...
RabbitMQ最大连接数
我的博客
07-21 2141
RabbitMQ的Socket连接数（socket descriptors）是文件描述符（File descriptors）的一个子集，也就是说，RabbitMQ能同时打开的最大连接数和最大文件句柄数都是受限于操作系统关于文件描述符数量的限制，两者是此消彼长的关系。默认情况下，rabbitmq文件句柄数设置是1024。例如：（1024-100）*0.9=831.6，取整831再减2得到829。连接数=（文件句柄数-100）*0.9，计算后的值取整再减2。一般通过ulimit来调整程序的最大文件句柄数。
第二章 RabbitMQ的配置
还想做MAD
03-04 2446
RabbitMQ的配置 1、RabbitMQ的管理命令行 # 启动相关[ start启动 | restart重启 | stop停止 | status状态 ] # 1.服务启动 systemctl start rabbitmq-server # 1.服务重启 systemctl restart rabbitmq-server # 1.服务关闭 systemctl stop rabbitmq-server # 1.服务状态 systemctl status rabbitmq-server # 管理命
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值