抽奖相关提交

101captain

2022-02-22 c83cf9d2d82a0a29a15e38f4566eb470b9a3517b

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
package com.panzhihua.service_community.config;
 
import org.springframework.amqp.core.*;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
import java.util.HashMap;
import java.util.Map;
 
@Configuration
public class RabbitmqConfig {
 
 
    public static final String PreOrder_QUEUE="preOrder.queue";
    public static final String PreOrder_ROUTING_KEY="preOrder.key";
    public static final String PreOrder_EXCHANGE="preOrder.exchange";
 
    public static final String Order_QUEUE="order.queue";
    public static final String Order_ROUTING_KEY="order.key";
    public static final String Order_EXCHANGE="order.exchange";
 
    public static final String RAFFLE_QUEUE="raffle.queue";
    public static final String RAFFLE_ROUTING_KEY="raffle.key";
    public static final String RAFFLE_EXCHANGE="raffle.exchange";
 
 
 
    @Bean
    public Queue preOrderQueue(){
        return new Queue(PreOrder_QUEUE,true,false,false,null);
    }
 
    @Bean
    public Exchange preOrderExchange(){
        Map<String, Object> arguments = new HashMap<>();
        arguments.put("x-delayed-type", ExchangeTypes.DIRECT);
        return new CustomExchange(PreOrder_EXCHANGE,"x-delayed-message",true,false,arguments);
    }
 
    @Bean
    public Binding preOrderBinding(){
        return BindingBuilder.bind(preOrderQueue()).to(preOrderExchange()).with(PreOrder_ROUTING_KEY).noargs();
    }
 
    @Bean
    public Queue raffleQueue(){
        return new Queue(RAFFLE_QUEUE,true,false,false,null);
    }
 
    @Bean
    public Exchange raffleExchange(){
        Map<String, Object> arguments = new HashMap<>();
        arguments.put("x-delayed-type", ExchangeTypes.DIRECT);
        return new CustomExchange(RAFFLE_EXCHANGE,"x-delayed-message",true,false,arguments);
    }
 
    @Bean
    public Binding raffleBinding(){
        return BindingBuilder.bind(raffleQueue()).to(raffleExchange()).with(RAFFLE_ROUTING_KEY).noargs();
    }
 
    @Bean
    public Queue orderQueue(){
        return new Queue(Order_QUEUE,true,false,false,null);
    }
 
    @Bean
    public Exchange orderExchange(){
        Map<String, Object> arguments = new HashMap<>();
        arguments.put("x-delayed-type", ExchangeTypes.DIRECT);
        return new CustomExchange(Order_EXCHANGE,"x-delayed-message",true,false,arguments);
    }
 
    @Bean
    public Binding orderBinding(){
        return BindingBuilder.bind(orderQueue()).to(orderExchange()).with(Order_ROUTING_KEY).noargs();
    }
 
    public Queue directQueue() {
        // durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
        // exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
        // autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
        //   return new Queue("TestDirectQueue",true,true,false);
 
        //一般设置一下队列的持久化就好,其余两个就是默认false
        return new Queue("directQueue",true);
    }
 
    //Direct交换机 起名：TestDirectExchange
    @Bean
    DirectExchange directExchange() {
        //  return new DirectExchange("TestDirectExchange",true,true);
        return new DirectExchange("directExchange",true,false);
    }
 
    //绑定  将队列和交换机绑定, 并设置用于匹配键：TestDirectRouting
    @Bean
    Binding bindingDirect() {
        return BindingBuilder.bind(directQueue()).to(directExchange()).with("directRouting");
    }
 
 
    public Queue pushQueue() {
        // durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
        // exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
        // autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
        //   return new Queue("TestDirectQueue",true,true,false);
 
        //一般设置一下队列的持久化就好,其余两个就是默认false
        return new Queue("pushQueue",true);
    }
 
    //Direct交换机 起名：TestDirectExchange
    @Bean
    DirectExchange pushExchange() {
        //  return new DirectExchange("TestDirectExchange",true,true);
        return new DirectExchange("PUSH_Exchange",true,false);
    }
 
    //绑定  将队列和交换机绑定, 并设置用于匹配键：TestDirectRouting
    @Bean
    Binding bindingPush() {
        return BindingBuilder.bind(directQueue()).to(directExchange()).with("PUSH_ROUTING");
    }
 
 
 
    @Bean
    DirectExchange lonelyDirectExchange() {
        return new DirectExchange("lonelyDirectExchange");
    }
 
    @Bean
    public MessageConverter messageConverter(){
        return new Jackson2JsonMessageConverter();
    }
 
 
}