springBoot整合rabbitMQ，通过注册bean的方式创建exchange，queue，容器中成功注入，但rabbitserver中不显示

已于 2022-09-30 14:53:15 修改
阅读量2.3k 收藏 2
点赞数 1
分类专栏： java 文章标签： java-rabbitmq rabbitmq spring boot
于 2022-09-30 11:59:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liulala16/article/details/127119742
版权 
一：解决办法
1、添加一个监听器
@RabbitListener(queues = "你的队列名")
public void handle(Message message){

}
2、或者加入如下bean创建一个connection 
@Bean
ApplicationRunner runner(ConnectionFactory cf) {
    return args -> cf.createConnection().close();
}



二原理：
因为在rabbitMQ采用的是懒加载， connection 启动时不会创建，下面第6步的 ConnectionListener 为空，因此需要创建一个连接，通过 ConnectionFactory接口 调用createConnection()方法创建一个连接注册到容器中
public interface ConnectionFactory {
    Connection createConnection() throws AmqpException;
public interface ConnectionListener {
    void onCreate(Connection var1);

    default void onClose(Connection connection) {
    }

    default void onShutDown(ShutdownSignalException signal) {
    }

    default void onFailed(Exception exception) {
    }
}
 

 

下面为springboot为自动创建rabbit的交换机，队列，绑定关系的原理
 

1、springBoot自动帮助我们创建RabbitMQ的Queue和Exchange是通过 RabbitAutoConfiguration类
 

@AutoConfiguration
@ConditionalOnClass({ RabbitTemplate.class, Channel.class })
@EnableConfigurationProperties(RabbitProperties.class)
@Import({ RabbitAnnotationDrivenConfiguration.class, RabbitStreamConfiguration.class })
public class RabbitAutoConfiguration
 

2、该类中注入了AmqpAdmin，可以看到是通过RabbitAdmin方法创建的连接
 

@Bean
		@ConditionalOnSingleCandidate(ConnectionFactory.class)
		@ConditionalOnProperty(prefix = "spring.rabbitmq", name = "dynamic", matchIfMissing = true)
		@ConditionalOnMissingBean
		public AmqpAdmin amqpAdmin(ConnectionFactory connectionFactory) {
			return new RabbitAdmin(connectionFactory);
		}
 

3、查看 RabbitAdmin类，可以看到实现了InitializingBean接口，这个接口是用于实例化bean
 


@ManagedResource(
    description = "Admin Tasks"
)
public class RabbitAdmin implements AmqpAdmin, ApplicationContextAware, ApplicationEventPublisherAware, BeanNameAware, InitializingBean
 

4、查看InitializingBean接口，只有afterPropertiesSet一个接口
 

package org.springframework.beans.factory;

public interface InitializingBean {
    void afterPropertiesSet() throws Exception;
}
 

5、查看RabbitAdmin中是如何实现这个接口
 

 public void afterPropertiesSet() {
        synchronized(this.lifecycleMonitor) {
            if (!this.running && this.autoStartup) {
                if (this.retryTemplate == null && !this.retryDisabled) {
                    this.retryTemplate = new RetryTemplate();
                    this.retryTemplate.setRetryPolicy(new SimpleRetryPolicy(5));
                    ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
                    backOffPolicy.setInitialInterval(1000L);
                    backOffPolicy.setMultiplier(2.0D);
                    backOffPolicy.setMaxInterval(5000L);
                    this.retryTemplate.setBackOffPolicy(backOffPolicy);
                }

                if (this.connectionFactory instanceof CachingConnectionFactory && ((CachingConnectionFactory)this.connectionFactory).getCacheMode() == CacheMode.CONNECTION) {
                    this.logger.warn("RabbitAdmin auto declaration is not supported with CacheMode.CONNECTION");
                } else {
                    AtomicBoolean initializing = new AtomicBoolean(false);
                    this.connectionFactory.addConnectionListener((connection) -> {
                        if (initializing.compareAndSet(false, true)) {
                            try {
                                if (this.retryTemplate != null) {
                                    this.retryTemplate.execute((c) -> {
                                        this.initialize();
                                        return null;
                                    });
                                } else {
                                    this.initialize();
                                }
                            } finally {
                                initializing.compareAndSet(true, false);
                            }

                        }
                    });
                    this.running = true;
                }
            }
        }
    }
 

6、可以看到连接工厂添加了一个连接监听器，在里面调用了initalize方法
 

this.connectionFactory.addConnectionListener((connection) -> {
                        if (initializing.compareAndSet(false, true)) {
                            try {
                                if (this.retryTemplate != null) {
                                    this.retryTemplate.execute((c) -> {
                                        this.initialize();
                                        return null;
                                    });
                                } else {
                                    this.initialize();
                                }
                            } finally {
                                initializing.compareAndSet(true, false);
                            }

                        }
                    });
 

7、查看initialize方法
 

 public void initialize() {
        if (this.applicationContext == null) {
            this.logger.debug("no ApplicationContext has been set, cannot auto-declare Exchanges, Queues, and Bindings");
        } else {
            this.logger.debug("Initializing declarations");
            Collection<Exchange> contextExchanges = new LinkedList(this.applicationContext.getBeansOfType(Exchange.class).values());
            Collection<Queue> contextQueues = new LinkedList(this.applicationContext.getBeansOfType(Queue.class).values());
            Collection<Binding> contextBindings = new LinkedList(this.applicationContext.getBeansOfType(Binding.class).values());
            Collection<DeclarableCustomizer> customizers = this.applicationContext.getBeansOfType(DeclarableCustomizer.class).values();
            this.processDeclarables(contextExchanges, contextQueues, contextBindings);
            Collection<Exchange> exchanges = this.filterDeclarables(contextExchanges, customizers);
            Collection<Queue> queues = this.filterDeclarables(contextQueues, customizers);
            Collection<Binding> bindings = this.filterDeclarables(contextBindings, customizers);
            Iterator var8 = exchanges.iterator();

            while(true) {
                Exchange exchange;
                do {
                    if (!var8.hasNext()) {
                        var8 = queues.iterator();

                        while(true) {
                            Queue queue;
                            do {
                                if (!var8.hasNext()) {
                                    if (exchanges.size() == 0 && queues.size() == 0 && bindings.size() == 0 && this.manualDeclarables.size() == 0) {
                                        this.logger.debug("Nothing to declare");
                                        return;
                                    }

                                    this.rabbitTemplate.execute((channel) -> {
                                        this.declareExchanges(channel, (Exchange[])exchanges.toArray(new Exchange[exchanges.size()]));
                                        this.declareQueues(channel, (Queue[])queues.toArray(new Queue[queues.size()]));
                                        this.declareBindings(channel, (Binding[])bindings.toArray(new Binding[bindings.size()]));
                                        return null;
                                    });
                                    if (this.manualDeclarables.size() > 0) {
                                        synchronized(this.manualDeclarables) {
                                            this.logger.debug("Redeclaring manually declared Declarables");
                                            Iterator var14 = this.manualDeclarables.values().iterator();

                                            while(var14.hasNext()) {
                                                Declarable dec = (Declarable)var14.next();
                                                if (dec instanceof Queue) {
                                                    this.declareQueue((Queue)dec);
                                                } else if (dec instanceof Exchange) {
                                                    this.declareExchange((Exchange)dec);
                                                } else {
                                                    this.declareBinding((Binding)dec);
                                                }
                                            }
                                        }
                                    }

                                    this.logger.debug("Declarations finished");
                                    return;
                                }

                                queue = (Queue)var8.next();
                            } while(queue.isDurable() && !queue.isAutoDelete() && !queue.isExclusive());

                            if (this.logger.isInfoEnabled()) {
                                this.logger.info("Auto-declaring a non-durable, auto-delete, or exclusive Queue (" + queue.getName() + ") durable:" + queue.isDurable() + ", auto-delete:" + queue.isAutoDelete() + ", exclusive:" + queue.isExclusive() + ". It will be redeclared if the broker stops and is restarted while the connection factory is alive, but all messages will be lost.");
                            }
                        }
                    }

                    exchange = (Exchange)var8.next();
                } while(exchange.isDurable() && !exchange.isAutoDelete());

                if (this.logger.isInfoEnabled()) {
                    this.logger.info("Auto-declaring a non-durable or auto-delete Exchange (" + exchange.getName() + ") durable:" + exchange.isDurable() + ", auto-delete:" + exchange.isAutoDelete() + ". It will be deleted by the broker if it shuts down, and can be redeclared by closing and reopening the connection.");
                }
            }
        }
    }
 

8、可以看到，底层还是RabbitAdmin 在执行声明交换机，队列，绑定关系
 

this.rabbitTemplate.execute((channel) -> {
                                        this.declareExchanges(channel, (Exchange[])exchanges.toArray(new Exchange[exchanges.size()]));
                                        this.declareQueues(channel, (Queue[])queues.toArray(new Queue[queues.size()]));
                                        this.declareBindings(channel, (Binding[])bindings.toArray(new Binding[bindings.size()]));
                                        return null;
                                    });
 

9、进入declareExchanges 方法
 

    private void declareExchanges(Channel channel, Exchange... exchanges) throws IOException {
        Exchange[] var3 = exchanges;
        int var4 = exchanges.length;

        for(int var5 = 0; var5 < var4; ++var5) {
            Exchange exchange = var3[var5];
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("declaring Exchange '" + exchange.getName() + "'");
            }

            if (!this.isDeclaringDefaultExchange(exchange)) {
                try {
                    if (exchange.isDelayed()) {
                        Map<String, Object> arguments = exchange.getArguments();
                        HashMap arguments;
                        if (arguments == null) {
                            arguments = new HashMap();
                        } else {
                            arguments = new HashMap(arguments);
                        }

                        arguments.put("x-delayed-type", exchange.getType());
                        channel.exchangeDeclare(exchange.getName(), "x-delayed-message", exchange.isDurable(), exchange.isAutoDelete(), exchange.isInternal(), arguments);
                    } else {
                        channel.exchangeDeclare(exchange.getName(), exchange.getType(), exchange.isDurable(), exchange.isAutoDelete(), exchange.isInternal(), exchange.getArguments());
                    }
                } catch (IOException var8) {
                    this.logOrRethrowDeclarationException(exchange, "exchange", var8);
                }
            }
        }

    }
 

10、可以看到最底层调用了channel接口的实现
 

channel.exchangeDeclare(exchange.getName(), "x-delayed-message", exchange.isDurable(), exchange.isAutoDelete(), exchange.isInternal(), arguments);
 

11、可以进入Channel接口查看：
 

DeclareOk exchangeDeclare(String var1, String var2) throws IOException;

    DeclareOk exchangeDeclare(String var1, BuiltinExchangeType var2) throws IOException;

    DeclareOk exchangeDeclare(String var1, String var2, boolean var3) throws IOException;

    DeclareOk exchangeDeclare(String var1, BuiltinExchangeType var2, boolean var3) throws IOException;

    DeclareOk exchangeDeclare(String var1, String var2, boolean var3, boolean var4, Map<String, Object> var5) throws IOException;

    DeclareOk exchangeDeclare(String var1, BuiltinExchangeType var2, boolean var3, boolean var4, Map<String, Object> var5) throws IOException;

    DeclareOk exchangeDeclare(String var1, String var2, boolean var3, boolean var4, boolean var5, Map<String, Object> var6) throws IOException;

    DeclareOk exchangeDeclare(String var1, BuiltinExchangeType var2, boolean var3, boolean var4, boolean var5, Map<String, Object> var6) throws IOException;

 


                

        

        

    




    

      

        

            

              
                
                  liulala16
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    1
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    2
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
springboot+整合rabbitmq的全套代码


				
			

			

				

					09-15
				

			

		

		

			
				
reabbitmq的完整学习
>rabbitMq软件上传到liunx服务器
>RabbitMQ入门
>RabbitMQ的工作模式
>Springboot整合RabbitMQ
>SpringBoot整合RabbitMQ(交换机与多个队列绑定)
>RabbitMQ-集群搭建>负载均衡-HAProxy

完整链接地址:
https://blog.csdn.net/qq_39505065/article/details/126880533?csdn_share_tail=%7B%22type%22%3A%22blog%22%2C%22rType%22%3A%22article%22%2C%22rId%22%3A%22126880533%22%2C%22source%22%3A%22qq_39505065%22%7D

			
		

	



                

              
                



	

		

			

				
					
springBoot整合rabbitMQ,包括erlang20.3,rabbitmq-server-3.7.14安装包

				
			

			

				

					07-02
				

			

		

		

			
				
springBoot整合rabbitMQ,包括erlang20.3,rabbitmq-server-3.7.14安装包
整合4种常用模式+高级特性死信队列
暂未整合TTL队列
博客地址:https://blog.csdn.net/weixin_45352783/article/details/125554173?spm=1001.2014.3001.5501
遇到问题可以留言

			
		

	



                


  
              

                


	

		

			

				
					
Spring初始化顺序- RabbitMq 无法自动创建队列

				
			

			

				

					qq_27061805的博客
				

				

					04-07
					
					2872
					
				

			

		

		

			
				
Spring初始化顺序- RabbitMq 无法自动创建队列

			
		

	





	

		

			

				
					
springboot声明（创建）RabbitMQ交换机和队列

				
			

			

				

					weixin_46376562的博客
				

				

					02-15
					
					818
					
				

			

		

		

			
				
在之前我们都是基于RabbitMQ控制台来创建队列、交换机。但是在实际开发时，队列和交换机是程序员定义的，将来项目上线，又要交给运维去创建。那么程序员就需要把程序中运行的所有队列和交换机都写下来，交给运维。在这个过程中是很容易出现错误的。因此推荐的做法是由程序启动时检查队列和交换机是否存在，如果不存在自动创建。

			
		

	



		

			
		



	

		

			

				
					
springBoot整合RabbitMQ案例

				
			

			

				

					04-07
				

			

		

		

			
				
springBoot整合RabbitMQ案例

			
		

	





	

		

			

				
					
springboot-rabbitMQ-websocket:springboot整合rabbitMQ和websocket，实现消息的发布和接收，并通过websocket实时推送数据到页面

				
			

			

				

					05-27
				

			

		

		

			
				
springboot-rabbitMQ-websocket
springboot整合rabbitMQ和websocket，实现消息的发布和接收，并通过websocket实时推送数据到页面

			
		

	





	

		

			

				
					
spring boot实战(第十二篇)整合RabbitMQ

				
			

			

				

					weixin_33682790的博客
				

				

					10-10
					
					492
					
				

			

		

		

			
				
前言
最近几篇文章将围绕消息中间件RabbitMQ展开，对于RabbitMQ基本概念这里不阐述，主要讲解RabbitMQ的基本用法、Java客户端API介绍、spring Boot与RabbitMQ整合、
Spring Boot与RabbitMQ整合源码分析。
 
RabbitMQ安装
 
在使用消息中间件RabbitMQ之前就是安装RabbitMQ。
 

安装erlang:yum instal...

			
		

	





	

		

			

				
					
springboot集成rabbitmmq多数据源，解决对源码不熟悉导致多个源出现同样队列，交换机等问题

				
			

			

				

					chenqunjian的博客
				

				

					07-01
					
					1595
					
				

			

		

		

			
				
springboot集成rabbitmmq多数据源，解决对源码不熟悉导致多个源出现同样队列，交换机等问题

			
		

	





	

		

			

				
					
SpringAMQP之RabbitAdmin类详解

				
			

			

				

					qq_38685072的博客
				

				

					03-02
					
					445
					
				

			

		

		

			
				
经过前面的讲述, 我们大体明白了的作用和原理, 但是还有一个问题我们需要研究一下:ConnectionFactory回调方法的调用时机?也就是说什么时候会向rabbitmq broker声明队列, 交换器这些组件呢?

			
		

	





	

		

			

				
					
RabbitMQ > Spring AMQP

				
			

			

				

					Bingo!
				

				

					09-19
					
					1304
					
				

			

		

		

			
				
Spring AMQP将Spring的核心观念应用于基于AMQP协议的消息解决方案中，可以实现Spring和RabbitMQ的集成。 
主要特征: 
1)提供了一个“模板”–RabbitTemplate来发送和接收消息 
2)使用Listener Container用于异步处理进来的消息 
3)使用RabbitAdmin自动声明Queues、Exchanges和BindingsQuick Start

			
		

	





	

		

			

				
					
RabbitMQ安装与springboot整合RabbitMQ

				
			

			

				

					01-07
				

			

		

		

			
				
RabbitMQ安装
docker hub进入仓库拉镜像数据，链接：https://hub.docker.com
进入tag标签下，找到带有management的，这个是带有web管理界面的。
下载较慢可以是用加速。
docker pull registry.docker-cn.com/library/rabbitmq:3-management
docker images检查镜像
docker run -d -p 5672:5672 -p 15672:15672 –name myrabbit 镜像id（image id）
docker ps -a 查看
主机地址：15672查看rabbitMQ

			
		

	





	

		

			

				
					
springboot整合stream使用rabbitmq作为消息中间件

				
			

			

				

					12-13
				

			

		

		

			
				
springboot整合stream使用rabbitmq作为消息中间件

			
		

	





	

		

			

				
					
springboot整合rabbitmq合集(xml方式和注解方式)

				
			

			

				

					12-20
				

			

		

		

			
				
首先介绍一下rabbitmq三种模式
Direct–路由模式
任何发送到Direct Exchange的消息都会被转发到RouteKey指定的Queue。
这种模式下不需要将Exchange进行任何绑定(binding)操作。
消息传递时需要一个“RouteKey”，可以简单的理解为要发送到的队列名字。
如果vhost中不存在RouteKey中指定的队列名，则该消息会被抛弃。
Fanout–发布/订阅模式
任何发送到Fanout Exchange的消息都会被转发到与该Exchange绑定(Binding)的所有Queue上。
这种模式不需要RouteKey。
这种模式需要提前将Exchange

			
		

	





	

		

			

				
					
Springboot整合RabbitMQ最简单demo

				
			

			

				

					07-11
				

			

		

		

			
				
Springboot整合RabbitMQ最简单demo,适用于springcloud项目,作为消息总线适用,需要安装RabbitMQ,Mac linux可以使用命令行一键安装,在项目配置文件配置好端口即可(已默认配置),启动项目访问8080端口,参数见controller.

			
		

	





	

		

			

				
					
Springboot整合RabbitMQ简单demo

				
			

			

				

					01-22
				

			

		

		

			
				
Springboot整合RabbitMQ最简单demo

			
		

	





	

		

			

				
					
SpringBoot整合RabbitMQ.zip

				
			

			

				

					06-29
				

			

		

		

			
				
SpringBoot整合RabbitMQ的详细过程 **1.该篇博文首先讲述了交换机和队列之间的绑定关系** ①direct、②fanout、③topic  **2.然后讲消息的回调** 四种情况下，确认触发哪个回调函数： ①消息推送到server，但是在...

			
		

	





	

		

			

				
					
✔ ★Java大项目——用Java模拟RabbitMQ实现一个消息队列（二）【创建核心类、封装数据库操作】

					
最新发布

				
			

			

				

					蓝天it（让亿万孩子在蓝天下共享优质教育）
				

				

					05-03
					
					787
					
				

			

		

		

			
				
SQLite 只是⼀个动态库(当然, 官⽅也提供了可执⾏程序 exe), 我们在 Java 中直接引⼊ SQLite 依赖, 即可直接使⽤, 不必安装其他的软件。对于 Exchange, MSGQueue, Binding, 我们使⽤数据库进⾏持久化保存.此处我们约定, 把数据库⽂件放到 ./data/meta.db 中.SQLite 只是把数据单纯的存储到⼀个⽂件中. ⾮常简单⽅便.此处我们使⽤的数据库是 SQLite, 是⼀个更轻量的数据库.引⼊ pom.xml 依赖。

			
		

	





	

		

			

				
					
Docker部署RabbitMQ与简单使用

				
			

			

				

					qq_65252348的博客
				

				

					04-30
					
					1268
					
				

			

		

		

			
				
官网地址： Messaging that just works — RabbitMQ我的Docker博客:Docker-CSDN博客其中包含几个概念：：生产者，也就是发送消息的一方：消费者，也就是消费消息的一方：队列，存储消息。生产者投递的消息会暂存在消息队列中，等待消费者处理：交换机，负责消息路由。生产者发送的消息由交换机决定投递到哪个队列。：虚拟主机，起到数据隔离的作用。每个虚拟主机相互独立，有各自的exchange、queue基于Docker来安装RabbitMQ，使用下面的命令即可：


root 

			
		

	





	

		

			

				
					
SpringBoot 整合 rabbitMQ

				
			

			

				

					05-24
				

			

		

		

			
				
Spring Boot 可以通过 AMQP（高级消息队列协议）来实现与 RabbitMQ 的集成。下面是整合的步骤：

1. 添加 RabbitMQ 依赖

在 `pom.xml` 文件中添加以下依赖：

```xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
```

2. 配置 RabbitMQ 连接信息

在 `application.properties` 文件中添加以下配置：

```properties
spring.rabbitmq.host=your-rabbitmq-server-hostname
spring.rabbitmq.port=5672
spring.rabbitmq.username=your-rabbitmq-username
spring.rabbitmq.password=your-rabbitmq-password
```

3. 创建消息发送者和接收者

在 Spring Boot 中，可以通过 `RabbitTemplate` 来发送和接收消息。下面是一个简单的发送者和接收者示例：

```java
@Component
public class MessageSender {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void send(String message) {
        rabbitTemplate.convertAndSend("my-exchange", "my-routing-key", message);
    }
}

@Component
public class MessageReceiver {

    @RabbitListener(queues = "my-queue")
    public void receive(String message) {
        System.out.println("Received message: " + message);
    }
}
```

4. 配置交换机和队列

在 RabbitMQ 中，消息发送和接收都需要通过交换机和队列来完成。在 Spring Boot 中，可以通过 `org.springframework.amqp.core` 包中的类来创建交换机和队列。以下是一个简单的配置示例：

```java
@Configuration
public class RabbitMQConfig {

    @Bean
    public DirectExchange myExchange() {
        return new DirectExchange("my-exchange");
    }

    @Bean
    public Queue myQueue() {
        return new Queue("my-queue");
    }

    @Bean
    public Binding binding() {
        return BindingBuilder.bind(myQueue()).to(myExchange()).with("my-routing-key");
    }
}
```

以上就是 Spring Boot 整合 RabbitMQ 的基本步骤。通过这种方式，我们可以在 Spring Boot 应用程序中轻松地集成 RabbitMQ，实现消息的发送和接收。

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值