记得上下班打卡 | git大法好，push需谨慎

Skip to content

L
liquidnet-bus-v1
Commit e4d5499e authored by jiangxiulong's avatar jiangxiulong
Browse files
Options

sweet老队列注释

parent c27b2028
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 1313 additions and 1313 deletions
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/config/ConsumerSweetAnswerRedisStreamConfig.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.config;
import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetAnswerRdsReceiver;
import lombok.var;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.ReadOffset;
import org.springframework.data.redis.connection.stream.StreamOffset;
import org.springframework.data.redis.stream.StreamMessageListenerContainer;
import org.springframework.data.redis.stream.Subscription;
import static com.liquidnet.service.base.constant.MQConst.SweetQueue.SWEET_ANSWER_INSERT;
@Configuration
public class ConsumerSweetAnswerRedisStreamConfig extends RedisStreamConfig {
@Autowired
ConsumerSweetAnswerRdsReceiver consumerSweetAnswerRdsReceiver;
/**
* 缺票登记
*
* @param listenerContainer
* @param t
* @return
*/
private Subscription receiveSqlAnswer(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
return listenerContainer.receiveAutoAck(Consumer.from(SWEET_ANSWER_INSERT.getGroup(), getConsumerName(SWEET_ANSWER_INSERT.name() + t)),
StreamOffset.create(SWEET_ANSWER_INSERT.getKey(), ReadOffset.lastConsumed()), consumerSweetAnswerRdsReceiver);
}
/* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
/* -------------------------------------------------------- ｜ 缺票登记 */
@Bean
public Subscription subscriptionSqlAnswer0(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlAnswer(listenerContainer, 0);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlAnswer1(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlAnswer(listenerContainer, 1);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlAnswer2(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlAnswer(listenerContainer, 2);
listenerContainer.start();
return subscription;
}
/* -------------------------------------------------------- ｜ */
}
//package com.liquidnet.service.consumer.sweet.config;
//
//import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
//import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetAnswerRdsReceiver;
//import lombok.var;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Configuration;
//import org.springframework.data.redis.connection.RedisConnectionFactory;
//import org.springframework.data.redis.connection.stream.Consumer;
//import org.springframework.data.redis.connection.stream.MapRecord;
//import org.springframework.data.redis.connection.stream.ReadOffset;
//import org.springframework.data.redis.connection.stream.StreamOffset;
//import org.springframework.data.redis.stream.StreamMessageListenerContainer;
//import org.springframework.data.redis.stream.Subscription;
//
//import static com.liquidnet.service.base.constant.MQConst.SweetQueue.SWEET_ANSWER_INSERT;
//
//@Configuration
//public class ConsumerSweetAnswerRedisStreamConfig extends RedisStreamConfig {
// @Autowired
// ConsumerSweetAnswerRdsReceiver consumerSweetAnswerRdsReceiver;
//
// /**
// * 缺票登记
// *
// * @param listenerContainer
// * @param t
// * @return
// */
// private Subscription receiveSqlAnswer(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
// return listenerContainer.receiveAutoAck(Consumer.from(SWEET_ANSWER_INSERT.getGroup(), getConsumerName(SWEET_ANSWER_INSERT.name() + t)),
// StreamOffset.create(SWEET_ANSWER_INSERT.getKey(), ReadOffset.lastConsumed()), consumerSweetAnswerRdsReceiver);
// }
//
// /* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
//
// /* -------------------------------------------------------- ｜ 缺票登记 */
//
// @Bean
// public Subscription subscriptionSqlAnswer0(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlAnswer(listenerContainer, 0);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlAnswer1(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlAnswer(listenerContainer, 1);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlAnswer2(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlAnswer(listenerContainer, 2);
// listenerContainer.start();
// return subscription;
// }
//
// /* -------------------------------------------------------- ｜ */
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/config/ConsumerSweetAntigenicQuestionRedisStreamConfig.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.config;
import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetAntigenicQuestionRdsReceiver;
import lombok.var;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.ReadOffset;
import org.springframework.data.redis.connection.stream.StreamOffset;
import org.springframework.data.redis.stream.StreamMessageListenerContainer;
import org.springframework.data.redis.stream.Subscription;
import static com.liquidnet.service.base.constant.MQConst.SweetQueue.SWEET_ANTIGENIC_QUESTION;
@Configuration
public class ConsumerSweetAntigenicQuestionRedisStreamConfig extends RedisStreamConfig {
@Autowired
ConsumerSweetAntigenicQuestionRdsReceiver consumerAntigenicQuestionRdsReceiver;
/**
* 缺票登记
*
* @param listenerContainer
* @param t
* @return
*/
private Subscription receiveSqlAntigenicQuestion(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
return listenerContainer.receiveAutoAck(Consumer.from(SWEET_ANTIGENIC_QUESTION.getGroup(), getConsumerName(SWEET_ANTIGENIC_QUESTION.name() + t)),
StreamOffset.create(SWEET_ANTIGENIC_QUESTION.getKey(), ReadOffset.lastConsumed()), consumerAntigenicQuestionRdsReceiver);
}
/* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
/* -------------------------------------------------------- ｜ 缺票登记 */
@Bean
public Subscription subscriptionSqlAntigenicQuestion0(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlAntigenicQuestion(listenerContainer, 0);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlAntigenicQuestion1(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlAntigenicQuestion(listenerContainer, 1);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlAntigenicQuestion2(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlAntigenicQuestion(listenerContainer, 2);
listenerContainer.start();
return subscription;
}
/* -------------------------------------------------------- ｜ */
}
//package com.liquidnet.service.consumer.sweet.config;
//
//import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
//import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetAntigenicQuestionRdsReceiver;
//import lombok.var;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Configuration;
//import org.springframework.data.redis.connection.RedisConnectionFactory;
//import org.springframework.data.redis.connection.stream.Consumer;
//import org.springframework.data.redis.connection.stream.MapRecord;
//import org.springframework.data.redis.connection.stream.ReadOffset;
//import org.springframework.data.redis.connection.stream.StreamOffset;
//import org.springframework.data.redis.stream.StreamMessageListenerContainer;
//import org.springframework.data.redis.stream.Subscription;
//
//import static com.liquidnet.service.base.constant.MQConst.SweetQueue.SWEET_ANTIGENIC_QUESTION;
//
//@Configuration
//public class ConsumerSweetAntigenicQuestionRedisStreamConfig extends RedisStreamConfig {
// @Autowired
// ConsumerSweetAntigenicQuestionRdsReceiver consumerAntigenicQuestionRdsReceiver;
//
// /**
// * 缺票登记
// *
// * @param listenerContainer
// * @param t
// * @return
// */
// private Subscription receiveSqlAntigenicQuestion(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
// return listenerContainer.receiveAutoAck(Consumer.from(SWEET_ANTIGENIC_QUESTION.getGroup(), getConsumerName(SWEET_ANTIGENIC_QUESTION.name() + t)),
// StreamOffset.create(SWEET_ANTIGENIC_QUESTION.getKey(), ReadOffset.lastConsumed()), consumerAntigenicQuestionRdsReceiver);
// }
//
// /* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
//
// /* -------------------------------------------------------- ｜ 缺票登记 */
//
// @Bean
// public Subscription subscriptionSqlAntigenicQuestion0(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlAntigenicQuestion(listenerContainer, 0);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlAntigenicQuestion1(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlAntigenicQuestion(listenerContainer, 1);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlAntigenicQuestion2(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlAntigenicQuestion(listenerContainer, 2);
// listenerContainer.start();
// return subscription;
// }
//
// /* -------------------------------------------------------- ｜ */
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/config/ConsumerSweetCityVoteRedisStreamConfig.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.config;
import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetCityVoteRdsReceiver;
import lombok.var;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.ReadOffset;
import org.springframework.data.redis.connection.stream.StreamOffset;
import org.springframework.data.redis.stream.StreamMessageListenerContainer;
import org.springframework.data.redis.stream.Subscription;
import static com.liquidnet.service.base.constant.MQConst.SweetQueue.SWEET_CITY_VOTE;
@Configuration
public class ConsumerSweetCityVoteRedisStreamConfig extends RedisStreamConfig {
@Autowired
ConsumerSweetCityVoteRdsReceiver consumerCityVoteRdsReceiver;
/**
* 缺票登记
*
* @param listenerContainer
* @param t
* @return
*/
private Subscription receiveSqlCityVote(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
return listenerContainer.receiveAutoAck(Consumer.from(SWEET_CITY_VOTE.getGroup(), getConsumerName(SWEET_CITY_VOTE.name() + t)),
StreamOffset.create(SWEET_CITY_VOTE.getKey(), ReadOffset.lastConsumed()), consumerCityVoteRdsReceiver);
}
/* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
/* -------------------------------------------------------- ｜ 缺票登记 */
@Bean
public Subscription subscriptionSqlCityVote0(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlCityVote(listenerContainer, 0);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlCityVote1(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlCityVote(listenerContainer, 1);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlCityVote2(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlCityVote(listenerContainer, 2);
listenerContainer.start();
return subscription;
}
/* -------------------------------------------------------- ｜ */
}
//package com.liquidnet.service.consumer.sweet.config;
//
//import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
//import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetCityVoteRdsReceiver;
//import lombok.var;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Configuration;
//import org.springframework.data.redis.connection.RedisConnectionFactory;
//import org.springframework.data.redis.connection.stream.Consumer;
//import org.springframework.data.redis.connection.stream.MapRecord;
//import org.springframework.data.redis.connection.stream.ReadOffset;
//import org.springframework.data.redis.connection.stream.StreamOffset;
//import org.springframework.data.redis.stream.StreamMessageListenerContainer;
//import org.springframework.data.redis.stream.Subscription;
//
//import static com.liquidnet.service.base.constant.MQConst.SweetQueue.SWEET_CITY_VOTE;
//
//@Configuration
//public class ConsumerSweetCityVoteRedisStreamConfig extends RedisStreamConfig {
// @Autowired
// ConsumerSweetCityVoteRdsReceiver consumerCityVoteRdsReceiver;
//
// /**
// * 缺票登记
// *
// * @param listenerContainer
// * @param t
// * @return
// */
// private Subscription receiveSqlCityVote(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
// return listenerContainer.receiveAutoAck(Consumer.from(SWEET_CITY_VOTE.getGroup(), getConsumerName(SWEET_CITY_VOTE.name() + t)),
// StreamOffset.create(SWEET_CITY_VOTE.getKey(), ReadOffset.lastConsumed()), consumerCityVoteRdsReceiver);
// }
//
// /* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
//
// /* -------------------------------------------------------- ｜ 缺票登记 */
//
// @Bean
// public Subscription subscriptionSqlCityVote0(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlCityVote(listenerContainer, 0);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlCityVote1(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlCityVote(listenerContainer, 1);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlCityVote2(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlCityVote(listenerContainer, 2);
// listenerContainer.start();
// return subscription;
// }
//
// /* -------------------------------------------------------- ｜ */
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/config/ConsumerSweetIntegralActivityDrawRedisStreamConfig.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.config;
import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetIntegralActivityDrawRdsReceiver;
import lombok.var;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.ReadOffset;
import org.springframework.data.redis.connection.stream.StreamOffset;
import org.springframework.data.redis.stream.StreamMessageListenerContainer;
import org.springframework.data.redis.stream.Subscription;
import static com.liquidnet.service.base.constant.MQConst.SweetQueue.SWEET_INTEGRAL_ACTIVITY_DRAW;
@Configuration
public class ConsumerSweetIntegralActivityDrawRedisStreamConfig extends RedisStreamConfig {
@Autowired
ConsumerSweetIntegralActivityDrawRdsReceiver consumerIntegralActivityDrawRdsReceiver;
/**
* 缺票登记
*
* @param listenerContainer
* @param t
* @return
*/
private Subscription receiveSqlIntegralActivityDraw(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
return listenerContainer.receiveAutoAck(Consumer.from(SWEET_INTEGRAL_ACTIVITY_DRAW.getGroup(), getConsumerName(SWEET_INTEGRAL_ACTIVITY_DRAW.name() + t)),
StreamOffset.create(SWEET_INTEGRAL_ACTIVITY_DRAW.getKey(), ReadOffset.lastConsumed()), consumerIntegralActivityDrawRdsReceiver);
}
/* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
/* -------------------------------------------------------- ｜ 缺票登记 */
@Bean
public Subscription subscriptionSqlIntegralActivityDraw0(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlIntegralActivityDraw(listenerContainer, 0);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlIntegralActivityDraw1(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlIntegralActivityDraw(listenerContainer, 1);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlIntegralActivityDraw2(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlIntegralActivityDraw(listenerContainer, 2);
listenerContainer.start();
return subscription;
}
/* -------------------------------------------------------- ｜ */
}
//package com.liquidnet.service.consumer.sweet.config;
//
//import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
//import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetIntegralActivityDrawRdsReceiver;
//import lombok.var;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Configuration;
//import org.springframework.data.redis.connection.RedisConnectionFactory;
//import org.springframework.data.redis.connection.stream.Consumer;
//import org.springframework.data.redis.connection.stream.MapRecord;
//import org.springframework.data.redis.connection.stream.ReadOffset;
//import org.springframework.data.redis.connection.stream.StreamOffset;
//import org.springframework.data.redis.stream.StreamMessageListenerContainer;
//import org.springframework.data.redis.stream.Subscription;
//
//import static com.liquidnet.service.base.constant.MQConst.SweetQueue.SWEET_INTEGRAL_ACTIVITY_DRAW;
//
//@Configuration
//public class ConsumerSweetIntegralActivityDrawRedisStreamConfig extends RedisStreamConfig {
// @Autowired
// ConsumerSweetIntegralActivityDrawRdsReceiver consumerIntegralActivityDrawRdsReceiver;
//
// /**
// * 缺票登记
// *
// * @param listenerContainer
// * @param t
// * @return
// */
// private Subscription receiveSqlIntegralActivityDraw(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
// return listenerContainer.receiveAutoAck(Consumer.from(SWEET_INTEGRAL_ACTIVITY_DRAW.getGroup(), getConsumerName(SWEET_INTEGRAL_ACTIVITY_DRAW.name() + t)),
// StreamOffset.create(SWEET_INTEGRAL_ACTIVITY_DRAW.getKey(), ReadOffset.lastConsumed()), consumerIntegralActivityDrawRdsReceiver);
// }
//
// /* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
//
// /* -------------------------------------------------------- ｜ 缺票登记 */
//
// @Bean
// public Subscription subscriptionSqlIntegralActivityDraw0(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlIntegralActivityDraw(listenerContainer, 0);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlIntegralActivityDraw1(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlIntegralActivityDraw(listenerContainer, 1);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlIntegralActivityDraw2(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlIntegralActivityDraw(listenerContainer, 2);
// listenerContainer.start();
// return subscription;
// }
//
// /* -------------------------------------------------------- ｜ */
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/config/ConsumerSweetMaoDengConfig.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.config;
import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetMaoDengReceiver;
import lombok.var;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.ReadOffset;
import org.springframework.data.redis.connection.stream.StreamOffset;
import org.springframework.data.redis.stream.StreamMessageListenerContainer;
import org.springframework.data.redis.stream.Subscription;
import static com.liquidnet.service.base.constant.MQConst.SweetQueue.SWEET_WECHAT_MAODENG_TEXT_INSERT;
@Configuration
public class ConsumerSweetMaoDengConfig extends RedisStreamConfig {
@Autowired
ConsumerSweetMaoDengReceiver consumerSweetMaoDengReceiver;
/**
* 猫登天空
*/
private Subscription receiveSqlMaoDeng(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
return listenerContainer.receiveAutoAck(Consumer.from(SWEET_WECHAT_MAODENG_TEXT_INSERT.getGroup(), getConsumerName(SWEET_WECHAT_MAODENG_TEXT_INSERT.name() + t)),
StreamOffset.create(SWEET_WECHAT_MAODENG_TEXT_INSERT.getKey(), ReadOffset.lastConsumed()), consumerSweetMaoDengReceiver);
}
/* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
/* -------------------------------------------------------- ｜ */
@Bean
public Subscription subscriptionSqlMaoDeng0(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlMaoDeng(listenerContainer, 0);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlMaoDeng1(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlMaoDeng(listenerContainer, 1);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlMaoDeng2(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlMaoDeng(listenerContainer, 2);
listenerContainer.start();
return subscription;
}
/* -------------------------------------------------------- ｜ */
}
//package com.liquidnet.service.consumer.sweet.config;
//
//import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
//import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetMaoDengReceiver;
//import lombok.var;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Configuration;
//import org.springframework.data.redis.connection.RedisConnectionFactory;
//import org.springframework.data.redis.connection.stream.Consumer;
//import org.springframework.data.redis.connection.stream.MapRecord;
//import org.springframework.data.redis.connection.stream.ReadOffset;
//import org.springframework.data.redis.connection.stream.StreamOffset;
//import org.springframework.data.redis.stream.StreamMessageListenerContainer;
//import org.springframework.data.redis.stream.Subscription;
//
//import static com.liquidnet.service.base.constant.MQConst.SweetQueue.SWEET_WECHAT_MAODENG_TEXT_INSERT;
//
//@Configuration
//public class ConsumerSweetMaoDengConfig extends RedisStreamConfig {
// @Autowired
// ConsumerSweetMaoDengReceiver consumerSweetMaoDengReceiver;
//
// /**
// * 猫登天空
// */
// private Subscription receiveSqlMaoDeng(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
// return listenerContainer.receiveAutoAck(Consumer.from(SWEET_WECHAT_MAODENG_TEXT_INSERT.getGroup(), getConsumerName(SWEET_WECHAT_MAODENG_TEXT_INSERT.name() + t)),
// StreamOffset.create(SWEET_WECHAT_MAODENG_TEXT_INSERT.getKey(), ReadOffset.lastConsumed()), consumerSweetMaoDengReceiver);
// }
//
// /* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
//
// /* -------------------------------------------------------- ｜ */
//
// @Bean
// public Subscription subscriptionSqlMaoDeng0(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlMaoDeng(listenerContainer, 0);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlMaoDeng1(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlMaoDeng(listenerContainer, 1);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlMaoDeng2(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlMaoDeng(listenerContainer, 2);
// listenerContainer.start();
// return subscription;
// }
//
// /* -------------------------------------------------------- ｜ */
//
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/config/ConsumerSweetOtherApiStreamConfig.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.config;
import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetStoneIntegralReceiver;
import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetTemplateMsgReceiver;
import lombok.var;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.ReadOffset;
import org.springframework.data.redis.connection.stream.StreamOffset;
import org.springframework.data.redis.stream.StreamMessageListenerContainer;
import org.springframework.data.redis.stream.Subscription;
import static com.liquidnet.service.base.constant.MQConst.SweetQueue.SWEET_TEMPLATE_MSG;
import static com.liquidnet.service.base.constant.MQConst.SweetQueue.SWEET_STONE_INTEGRAL;
@Configuration
public class ConsumerSweetOtherApiStreamConfig extends RedisStreamConfig {
@Autowired
ConsumerSweetTemplateMsgReceiver consumerSweetTemplateMsgReceiver;
@Autowired
ConsumerSweetStoneIntegralReceiver consumerSweetStoneIntegralReceiver;
/**
* 模版消息
*/
private Subscription receiveApiTemplateMsg(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
return listenerContainer.receiveAutoAck(Consumer.from(SWEET_TEMPLATE_MSG.getGroup(), getConsumerName(SWEET_TEMPLATE_MSG.name() + t)),
StreamOffset.create(SWEET_TEMPLATE_MSG.getKey(), ReadOffset.lastConsumed()), consumerSweetTemplateMsgReceiver);
}
/**
* 增减积分
*/
private Subscription receiveApiStoneIntgral(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
return listenerContainer.receiveAutoAck(Consumer.from(SWEET_STONE_INTEGRAL.getGroup(), getConsumerName(SWEET_STONE_INTEGRAL.name() + t)),
StreamOffset.create(SWEET_STONE_INTEGRAL.getKey(), ReadOffset.lastConsumed()), consumerSweetStoneIntegralReceiver);
}
/*----------------------------------------------------------------------------------------------------------------*/
/*------------------模版消息------------------*/
@Bean
public Subscription subscriptionApiTemplateMsg0(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveApiTemplateMsg(listenerContainer, 0);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionApiTemplateMsg1(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveApiTemplateMsg(listenerContainer, 1);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionApiTemplateMsg2(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveApiTemplateMsg(listenerContainer, 2);
listenerContainer.start();
return subscription;
}
/*------------------增减积分------------------*/
@Bean
public Subscription subscriptionApiStoneIntgral0(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveApiStoneIntgral(listenerContainer, 0);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionApiStoneIntgral1(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveApiStoneIntgral(listenerContainer, 1);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionApiStoneIntgral2(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveApiStoneIntgral(listenerContainer, 2);
listenerContainer.start();
return subscription;
}
/*------------------ ------------------*/
}
//package com.liquidnet.service.consumer.sweet.config;
//
//import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
//import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetStoneIntegralReceiver;
//import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetTemplateMsgReceiver;
//import lombok.var;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Configuration;
//import org.springframework.data.redis.connection.RedisConnectionFactory;
//import org.springframework.data.redis.connection.stream.Consumer;
//import org.springframework.data.redis.connection.stream.MapRecord;
//import org.springframework.data.redis.connection.stream.ReadOffset;
//import org.springframework.data.redis.connection.stream.StreamOffset;
//import org.springframework.data.redis.stream.StreamMessageListenerContainer;
//import org.springframework.data.redis.stream.Subscription;
//
//import static com.liquidnet.service.base.constant.MQConst.SweetQueue.SWEET_TEMPLATE_MSG;
//import static com.liquidnet.service.base.constant.MQConst.SweetQueue.SWEET_STONE_INTEGRAL;
//
//@Configuration
//public class ConsumerSweetOtherApiStreamConfig extends RedisStreamConfig {
// @Autowired
// ConsumerSweetTemplateMsgReceiver consumerSweetTemplateMsgReceiver;
// @Autowired
// ConsumerSweetStoneIntegralReceiver consumerSweetStoneIntegralReceiver;
//
// /**
// * 模版消息
// */
// private Subscription receiveApiTemplateMsg(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
// return listenerContainer.receiveAutoAck(Consumer.from(SWEET_TEMPLATE_MSG.getGroup(), getConsumerName(SWEET_TEMPLATE_MSG.name() + t)),
// StreamOffset.create(SWEET_TEMPLATE_MSG.getKey(), ReadOffset.lastConsumed()), consumerSweetTemplateMsgReceiver);
// }
// /**
// * 增减积分
// */
// private Subscription receiveApiStoneIntgral(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
// return listenerContainer.receiveAutoAck(Consumer.from(SWEET_STONE_INTEGRAL.getGroup(), getConsumerName(SWEET_STONE_INTEGRAL.name() + t)),
// StreamOffset.create(SWEET_STONE_INTEGRAL.getKey(), ReadOffset.lastConsumed()), consumerSweetStoneIntegralReceiver);
// }
//
// /*----------------------------------------------------------------------------------------------------------------*/
//
// /*------------------模版消息------------------*/
//
// @Bean
// public Subscription subscriptionApiTemplateMsg0(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveApiTemplateMsg(listenerContainer, 0);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionApiTemplateMsg1(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveApiTemplateMsg(listenerContainer, 1);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionApiTemplateMsg2(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveApiTemplateMsg(listenerContainer, 2);
// listenerContainer.start();
// return subscription;
// }
//
// /*------------------增减积分------------------*/
//
// @Bean
// public Subscription subscriptionApiStoneIntgral0(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveApiStoneIntgral(listenerContainer, 0);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionApiStoneIntgral1(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveApiStoneIntgral(listenerContainer, 1);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionApiStoneIntgral2(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveApiStoneIntgral(listenerContainer, 2);
// listenerContainer.start();
// return subscription;
// }
//
// /*------------------ ------------------*/
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/config/ConsumerSweetPosterRdsReceiverConfig.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.config;
import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetPosterRdsReceiver;
import lombok.var;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.ReadOffset;
import org.springframework.data.redis.connection.stream.StreamOffset;
import org.springframework.data.redis.stream.StreamMessageListenerContainer;
import org.springframework.data.redis.stream.Subscription;
import static com.liquidnet.service.base.constant.MQConst.SweetQueue.SWEET_POSTER;
@Configuration
public class ConsumerSweetPosterRdsReceiverConfig extends RedisStreamConfig {
@Autowired
ConsumerSweetPosterRdsReceiver consumerSweetPosterRdsReceiver;
/**
* 活动海报
*/
private Subscription receiveSqlPoster(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
return listenerContainer.receiveAutoAck(Consumer.from(SWEET_POSTER.getGroup(), getConsumerName(SWEET_POSTER.name() + t)),
StreamOffset.create(SWEET_POSTER.getKey(), ReadOffset.lastConsumed()), consumerSweetPosterRdsReceiver);
}
@Bean
public Subscription subscriptionSqlPoster0(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlPoster(listenerContainer, 0);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlPoster1(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlPoster(listenerContainer, 1);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlPoster2(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlPoster(listenerContainer, 2);
listenerContainer.start();
return subscription;
}
}
//package com.liquidnet.service.consumer.sweet.config;
//
//import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
//import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetPosterRdsReceiver;
//import lombok.var;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Configuration;
//import org.springframework.data.redis.connection.stream.Consumer;
//
//import org.springframework.data.redis.connection.RedisConnectionFactory;
//import org.springframework.data.redis.connection.stream.MapRecord;
//import org.springframework.data.redis.connection.stream.ReadOffset;
//import org.springframework.data.redis.connection.stream.StreamOffset;
//import org.springframework.data.redis.stream.StreamMessageListenerContainer;
//import org.springframework.data.redis.stream.Subscription;
//
//import static com.liquidnet.service.base.constant.MQConst.SweetQueue.SWEET_POSTER;
//
//@Configuration
//public class ConsumerSweetPosterRdsReceiverConfig extends RedisStreamConfig {
// @Autowired
// ConsumerSweetPosterRdsReceiver consumerSweetPosterRdsReceiver;
//
// /**
// * 活动海报
// */
// private Subscription receiveSqlPoster(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
// return listenerContainer.receiveAutoAck(Consumer.from(SWEET_POSTER.getGroup(), getConsumerName(SWEET_POSTER.name() + t)),
// StreamOffset.create(SWEET_POSTER.getKey(), ReadOffset.lastConsumed()), consumerSweetPosterRdsReceiver);
// }
//
// @Bean
// public Subscription subscriptionSqlPoster0(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlPoster(listenerContainer, 0);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlPoster1(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlPoster(listenerContainer, 1);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlPoster2(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlPoster(listenerContainer, 2);
// listenerContainer.start();
// return subscription;
// }
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/config/ConsumerSweetRemindRedisStreamConfig.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.config;
import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetRemindRdsReceiver;
import lombok.var;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.ReadOffset;
import org.springframework.data.redis.connection.stream.StreamOffset;
import org.springframework.data.redis.stream.StreamMessageListenerContainer;
import org.springframework.data.redis.stream.Subscription;
import static com.liquidnet.service.base.constant.MQConst.SweetQueue.SWEET_REMIND_INSERT;
@Configuration
public class ConsumerSweetRemindRedisStreamConfig extends RedisStreamConfig {
@Autowired
ConsumerSweetRemindRdsReceiver consumerSweetRemindRdsReceiver;
/**
* 缺票登记
*
* @param listenerContainer
* @param t
* @return
*/
private Subscription receiveSqlRemind(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
return listenerContainer.receiveAutoAck(Consumer.from(SWEET_REMIND_INSERT.getGroup(), getConsumerName(SWEET_REMIND_INSERT.name() + t)),
StreamOffset.create(SWEET_REMIND_INSERT.getKey(), ReadOffset.lastConsumed()), consumerSweetRemindRdsReceiver);
}
/* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
/* -------------------------------------------------------- ｜ 缺票登记 */
@Bean
public Subscription subscriptionSqlRemind0(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlRemind(listenerContainer, 0);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlRemind1(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlRemind(listenerContainer, 1);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlRemind2(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlRemind(listenerContainer, 2);
listenerContainer.start();
return subscription;
}
/* -------------------------------------------------------- ｜ */
}
//package com.liquidnet.service.consumer.sweet.config;
//
//import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
//import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetRemindRdsReceiver;
//import lombok.var;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Configuration;
//import org.springframework.data.redis.connection.RedisConnectionFactory;
//import org.springframework.data.redis.connection.stream.Consumer;
//import org.springframework.data.redis.connection.stream.MapRecord;
//import org.springframework.data.redis.connection.stream.ReadOffset;
//import org.springframework.data.redis.connection.stream.StreamOffset;
//import org.springframework.data.redis.stream.StreamMessageListenerContainer;
//import org.springframework.data.redis.stream.Subscription;
//
//import static com.liquidnet.service.base.constant.MQConst.SweetQueue.SWEET_REMIND_INSERT;
//
//@Configuration
//public class ConsumerSweetRemindRedisStreamConfig extends RedisStreamConfig {
// @Autowired
// ConsumerSweetRemindRdsReceiver consumerSweetRemindRdsReceiver;
//
// /**
// * 缺票登记
// *
// * @param listenerContainer
// * @param t
// * @return
// */
// private Subscription receiveSqlRemind(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
// return listenerContainer.receiveAutoAck(Consumer.from(SWEET_REMIND_INSERT.getGroup(), getConsumerName(SWEET_REMIND_INSERT.name() + t)),
// StreamOffset.create(SWEET_REMIND_INSERT.getKey(), ReadOffset.lastConsumed()), consumerSweetRemindRdsReceiver);
// }
//
// /* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
//
// /* -------------------------------------------------------- ｜ 缺票登记 */
//
// @Bean
// public Subscription subscriptionSqlRemind0(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlRemind(listenerContainer, 0);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlRemind1(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlRemind(listenerContainer, 1);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlRemind2(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlRemind(listenerContainer, 2);
// listenerContainer.start();
// return subscription;
// }
//
// /* -------------------------------------------------------- ｜ */
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/config/ConsumerSweetSqlLuckDrawRedisStreamConfig.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.config;
import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetSqlLuckDrawRdsReceiver;
import lombok.var;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.ReadOffset;
import org.springframework.data.redis.connection.stream.StreamOffset;
import org.springframework.data.redis.stream.StreamMessageListenerContainer;
import org.springframework.data.redis.stream.Subscription;
import static com.liquidnet.service.base.constant.MQConst.SweetQueue.LUCK_DRAW;
@Configuration
public class ConsumerSweetSqlLuckDrawRedisStreamConfig extends RedisStreamConfig {
@Autowired
ConsumerSweetSqlLuckDrawRdsReceiver consumerSweetSqlLuckDrawRdsReceiver;
/**
* 缺票登记
*
* @param listenerContainer
* @param t
* @return
*/
private Subscription receiveSqlLuckDraw(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
return listenerContainer.receiveAutoAck(Consumer.from(LUCK_DRAW.getGroup(), getConsumerName(LUCK_DRAW.name() + t)),
StreamOffset.create(LUCK_DRAW.getKey(), ReadOffset.lastConsumed()), consumerSweetSqlLuckDrawRdsReceiver);
}
/* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
/* -------------------------------------------------------- ｜ 缺票登记 */
@Bean
public Subscription subscriptionSqlLuckDraw0(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlLuckDraw(listenerContainer, 0);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlLuckDraw1(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlLuckDraw(listenerContainer, 1);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlLuckDraw2(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlLuckDraw(listenerContainer, 2);
listenerContainer.start();
return subscription;
}
/* -------------------------------------------------------- ｜ */
}
//package com.liquidnet.service.consumer.sweet.config;
//
//import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
//import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetSqlLuckDrawRdsReceiver;
//import lombok.var;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Configuration;
//import org.springframework.data.redis.connection.RedisConnectionFactory;
//import org.springframework.data.redis.connection.stream.Consumer;
//import org.springframework.data.redis.connection.stream.MapRecord;
//import org.springframework.data.redis.connection.stream.ReadOffset;
//import org.springframework.data.redis.connection.stream.StreamOffset;
//import org.springframework.data.redis.stream.StreamMessageListenerContainer;
//import org.springframework.data.redis.stream.Subscription;
//
//import static com.liquidnet.service.base.constant.MQConst.SweetQueue.LUCK_DRAW;
//
//@Configuration
//public class ConsumerSweetSqlLuckDrawRedisStreamConfig extends RedisStreamConfig {
// @Autowired
// ConsumerSweetSqlLuckDrawRdsReceiver consumerSweetSqlLuckDrawRdsReceiver;
//
// /**
// * 缺票登记
// *
// * @param listenerContainer
// * @param t
// * @return
// */
// private Subscription receiveSqlLuckDraw(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
// return listenerContainer.receiveAutoAck(Consumer.from(LUCK_DRAW.getGroup(), getConsumerName(LUCK_DRAW.name() + t)),
// StreamOffset.create(LUCK_DRAW.getKey(), ReadOffset.lastConsumed()), consumerSweetSqlLuckDrawRdsReceiver);
// }
//
// /* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
//
// /* -------------------------------------------------------- ｜ 缺票登记 */
//
// @Bean
// public Subscription subscriptionSqlLuckDraw0(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlLuckDraw(listenerContainer, 0);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlLuckDraw1(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlLuckDraw(listenerContainer, 1);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlLuckDraw2(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlLuckDraw(listenerContainer, 2);
// listenerContainer.start();
// return subscription;
// }
//
// /* -------------------------------------------------------- ｜ */
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/config/ConsumerSweetSqlUserRelationMDSKRedisStreamConfig.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.config;
import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetSqlUserRelationMDSKRdsReceiver;
import lombok.var;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.ReadOffset;
import org.springframework.data.redis.connection.stream.StreamOffset;
import org.springframework.data.redis.stream.StreamMessageListenerContainer;
import org.springframework.data.redis.stream.Subscription;
import static com.liquidnet.service.base.constant.MQConst.SweetQueue.ARTISTS_RELATION_MDSK;
@Configuration
public class ConsumerSweetSqlUserRelationMDSKRedisStreamConfig extends RedisStreamConfig {
@Autowired
ConsumerSweetSqlUserRelationMDSKRdsReceiver consumerSweetSqlUserRelationMDSKRdsReceiver;
/**
* 缺票登记
*
* @param listenerContainer
* @param t
* @return
*/
private Subscription receiveSqlUserMdskRelation(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
return listenerContainer.receiveAutoAck(Consumer.from(ARTISTS_RELATION_MDSK.getGroup(), getConsumerName(ARTISTS_RELATION_MDSK.name() + t)),
StreamOffset.create(ARTISTS_RELATION_MDSK.getKey(), ReadOffset.lastConsumed()), consumerSweetSqlUserRelationMDSKRdsReceiver);
}
/* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
/* -------------------------------------------------------- ｜ 缺票登记 */
@Bean
public Subscription subscriptionSqlUserMdskRelation0(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlUserMdskRelation(listenerContainer, 0);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlUserMdskRelation1(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlUserMdskRelation(listenerContainer, 1);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlUserMdskRelation2(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlUserMdskRelation(listenerContainer, 2);
listenerContainer.start();
return subscription;
}
/* -------------------------------------------------------- ｜ */
}
//package com.liquidnet.service.consumer.sweet.config;
//
//import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
//import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetSqlUserRelationMDSKRdsReceiver;
//import lombok.var;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Configuration;
//import org.springframework.data.redis.connection.RedisConnectionFactory;
//import org.springframework.data.redis.connection.stream.Consumer;
//import org.springframework.data.redis.connection.stream.MapRecord;
//import org.springframework.data.redis.connection.stream.ReadOffset;
//import org.springframework.data.redis.connection.stream.StreamOffset;
//import org.springframework.data.redis.stream.StreamMessageListenerContainer;
//import org.springframework.data.redis.stream.Subscription;
//
//import static com.liquidnet.service.base.constant.MQConst.SweetQueue.ARTISTS_RELATION_MDSK;
//
//@Configuration
//public class ConsumerSweetSqlUserRelationMDSKRedisStreamConfig extends RedisStreamConfig {
// @Autowired
// ConsumerSweetSqlUserRelationMDSKRdsReceiver consumerSweetSqlUserRelationMDSKRdsReceiver;
//
// /**
// * 缺票登记
// *
// * @param listenerContainer
// * @param t
// * @return
// */
// private Subscription receiveSqlUserMdskRelation(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
// return listenerContainer.receiveAutoAck(Consumer.from(ARTISTS_RELATION_MDSK.getGroup(), getConsumerName(ARTISTS_RELATION_MDSK.name() + t)),
// StreamOffset.create(ARTISTS_RELATION_MDSK.getKey(), ReadOffset.lastConsumed()), consumerSweetSqlUserRelationMDSKRdsReceiver);
// }
//
// /* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
//
// /* -------------------------------------------------------- ｜ 缺票登记 */
//
// @Bean
// public Subscription subscriptionSqlUserMdskRelation0(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlUserMdskRelation(listenerContainer, 0);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlUserMdskRelation1(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlUserMdskRelation(listenerContainer, 1);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlUserMdskRelation2(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlUserMdskRelation(listenerContainer, 2);
// listenerContainer.start();
// return subscription;
// }
//
// /* -------------------------------------------------------- ｜ */
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/config/ConsumerSweetSqlUserRelationRedisStreamConfig.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.config;
import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetSqlUserRelationRdsReceiver;
import lombok.var;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.ReadOffset;
import org.springframework.data.redis.connection.stream.StreamOffset;
import org.springframework.data.redis.stream.StreamMessageListenerContainer;
import org.springframework.data.redis.stream.Subscription;
import static com.liquidnet.service.base.constant.MQConst.SweetQueue.ARTISTS_RELATION;
@Configuration
public class ConsumerSweetSqlUserRelationRedisStreamConfig extends RedisStreamConfig {
@Autowired
ConsumerSweetSqlUserRelationRdsReceiver consumerSweetSqlUserRelationRdsReceiver;
/**
* 缺票登记
*
* @param listenerContainer
* @param t
* @return
*/
private Subscription receiveSqlUserRelation(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
return listenerContainer.receiveAutoAck(Consumer.from(ARTISTS_RELATION.getGroup(), getConsumerName(ARTISTS_RELATION.name() + t)),
StreamOffset.create(ARTISTS_RELATION.getKey(), ReadOffset.lastConsumed()), consumerSweetSqlUserRelationRdsReceiver);
}
/* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
/* -------------------------------------------------------- ｜ 缺票登记 */
@Bean
public Subscription subscriptionSqlUserRelation0(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlUserRelation(listenerContainer, 0);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlUserRelation1(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlUserRelation(listenerContainer, 1);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlUserRelation2(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlUserRelation(listenerContainer, 2);
listenerContainer.start();
return subscription;
}
/* -------------------------------------------------------- ｜ */
}
//package com.liquidnet.service.consumer.sweet.config;
//
//import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
//import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetSqlUserRelationRdsReceiver;
//import lombok.var;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Configuration;
//import org.springframework.data.redis.connection.RedisConnectionFactory;
//import org.springframework.data.redis.connection.stream.Consumer;
//import org.springframework.data.redis.connection.stream.MapRecord;
//import org.springframework.data.redis.connection.stream.ReadOffset;
//import org.springframework.data.redis.connection.stream.StreamOffset;
//import org.springframework.data.redis.stream.StreamMessageListenerContainer;
//import org.springframework.data.redis.stream.Subscription;
//
//import static com.liquidnet.service.base.constant.MQConst.SweetQueue.ARTISTS_RELATION;
//
//@Configuration
//public class ConsumerSweetSqlUserRelationRedisStreamConfig extends RedisStreamConfig {
// @Autowired
// ConsumerSweetSqlUserRelationRdsReceiver consumerSweetSqlUserRelationRdsReceiver;
//
// /**
// * 缺票登记
// *
// * @param listenerContainer
// * @param t
// * @return
// */
// private Subscription receiveSqlUserRelation(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
// return listenerContainer.receiveAutoAck(Consumer.from(ARTISTS_RELATION.getGroup(), getConsumerName(ARTISTS_RELATION.name() + t)),
// StreamOffset.create(ARTISTS_RELATION.getKey(), ReadOffset.lastConsumed()), consumerSweetSqlUserRelationRdsReceiver);
// }
//
// /* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
//
// /* -------------------------------------------------------- ｜ 缺票登记 */
//
// @Bean
// public Subscription subscriptionSqlUserRelation0(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlUserRelation(listenerContainer, 0);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlUserRelation1(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlUserRelation(listenerContainer, 1);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlUserRelation2(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlUserRelation(listenerContainer, 2);
// listenerContainer.start();
// return subscription;
// }
//
// /* -------------------------------------------------------- ｜ */
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/config/ConsumerSweetUserRedisStreamConfig.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.config;
import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetUserRdsReceiver;
import lombok.var;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.ReadOffset;
import org.springframework.data.redis.connection.stream.StreamOffset;
import org.springframework.data.redis.stream.StreamMessageListenerContainer;
import org.springframework.data.redis.stream.Subscription;
import static com.liquidnet.service.base.constant.MQConst.SweetQueue.SWEET_WECHAT_USER_INSERT;
@Configuration
public class ConsumerSweetUserRedisStreamConfig extends RedisStreamConfig {
@Autowired
ConsumerSweetUserRdsReceiver consumerSweetUserRdsReceiver;
/**
* 缺票登记
*
* @param listenerContainer
* @param t
* @return
*/
private Subscription receiveSqlSweetUser(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
return listenerContainer.receiveAutoAck(Consumer.from(SWEET_WECHAT_USER_INSERT.getGroup(), getConsumerName(SWEET_WECHAT_USER_INSERT.name() + t)),
StreamOffset.create(SWEET_WECHAT_USER_INSERT.getKey(), ReadOffset.lastConsumed()), consumerSweetUserRdsReceiver);
}
/* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
/* -------------------------------------------------------- ｜ 缺票登记 */
@Bean
public Subscription subscriptionSqlSweetUser0(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlSweetUser(listenerContainer, 0);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlSweetUser1(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlSweetUser(listenerContainer, 1);
listenerContainer.start();
return subscription;
}
@Bean
public Subscription subscriptionSqlSweetUser2(RedisConnectionFactory factory) {
var listenerContainer = this.buildStreamMessageListenerContainer(factory);
var subscription = receiveSqlSweetUser(listenerContainer, 2);
listenerContainer.start();
return subscription;
}
/* -------------------------------------------------------- ｜ */
}
//package com.liquidnet.service.consumer.sweet.config;
//
//import com.liquidnet.common.cache.redis.config.RedisStreamConfig;
//import com.liquidnet.service.consumer.sweet.receiver.ConsumerSweetUserRdsReceiver;
//import lombok.var;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Configuration;
//import org.springframework.data.redis.connection.RedisConnectionFactory;
//import org.springframework.data.redis.connection.stream.Consumer;
//import org.springframework.data.redis.connection.stream.MapRecord;
//import org.springframework.data.redis.connection.stream.ReadOffset;
//import org.springframework.data.redis.connection.stream.StreamOffset;
//import org.springframework.data.redis.stream.StreamMessageListenerContainer;
//import org.springframework.data.redis.stream.Subscription;
//
//import static com.liquidnet.service.base.constant.MQConst.SweetQueue.SWEET_WECHAT_USER_INSERT;
//
//@Configuration
//public class ConsumerSweetUserRedisStreamConfig extends RedisStreamConfig {
// @Autowired
// ConsumerSweetUserRdsReceiver consumerSweetUserRdsReceiver;
//
// /**
// * 缺票登记
// *
// * @param listenerContainer
// * @param t
// * @return
// */
// private Subscription receiveSqlSweetUser(StreamMessageListenerContainer<String, MapRecord<String, String, String>> listenerContainer, int t) {
// return listenerContainer.receiveAutoAck(Consumer.from(SWEET_WECHAT_USER_INSERT.getGroup(), getConsumerName(SWEET_WECHAT_USER_INSERT.name() + t)),
// StreamOffset.create(SWEET_WECHAT_USER_INSERT.getKey(), ReadOffset.lastConsumed()), consumerSweetUserRdsReceiver);
// }
//
// /* —————————————————————————— ｜ —————————————————————————— ｜ —————————————————————————— */
//
// /* -------------------------------------------------------- ｜ 缺票登记 */
//
// @Bean
// public Subscription subscriptionSqlSweetUser0(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlSweetUser(listenerContainer, 0);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlSweetUser1(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlSweetUser(listenerContainer, 1);
// listenerContainer.start();
// return subscription;
// }
//
// @Bean
// public Subscription subscriptionSqlSweetUser2(RedisConnectionFactory factory) {
// var listenerContainer = this.buildStreamMessageListenerContainer(factory);
// var subscription = receiveSqlSweetUser(listenerContainer, 2);
// listenerContainer.start();
// return subscription;
// }
//
// /* -------------------------------------------------------- ｜ */
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/receiver/ConsumerSweetAnswerRdsReceiver.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerSweetAnswerRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.SweetQueue.SWEET_ANSWER_INSERT.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.SweetQueue.SWEET_ANSWER_INSERT.getGroup();
}
}
//package com.liquidnet.service.consumer.sweet.receiver;
//
//import com.liquidnet.service.base.constant.MQConst;
//import org.springframework.stereotype.Component;
//
//@Component
//public class ConsumerSweetAnswerRdsReceiver extends AbstractSqlRedisReceiver {
// @Override
// protected String getRedisStreamKey() {
// return MQConst.SweetQueue.SWEET_ANSWER_INSERT.getKey();
// }
//
// @Override
// protected String getRedisStreamGroup() {
// return MQConst.SweetQueue.SWEET_ANSWER_INSERT.getGroup();
// }
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/receiver/ConsumerSweetAntigenicQuestionRdsReceiver.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerSweetAntigenicQuestionRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.SweetQueue.SWEET_ANTIGENIC_QUESTION.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.SweetQueue.SWEET_ANTIGENIC_QUESTION.getGroup();
}
}
//package com.liquidnet.service.consumer.sweet.receiver;
//
//import com.liquidnet.service.base.constant.MQConst;
//import org.springframework.stereotype.Component;
//
//@Component
//public class ConsumerSweetAntigenicQuestionRdsReceiver extends AbstractSqlRedisReceiver {
// @Override
// protected String getRedisStreamKey() {
// return MQConst.SweetQueue.SWEET_ANTIGENIC_QUESTION.getKey();
// }
//
// @Override
// protected String getRedisStreamGroup() {
// return MQConst.SweetQueue.SWEET_ANTIGENIC_QUESTION.getGroup();
// }
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/receiver/ConsumerSweetCityVoteRdsReceiver.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerSweetCityVoteRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.SweetQueue.SWEET_CITY_VOTE.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.SweetQueue.SWEET_CITY_VOTE.getGroup();
}
}
//package com.liquidnet.service.consumer.sweet.receiver;
//
//import com.liquidnet.service.base.constant.MQConst;
//import org.springframework.stereotype.Component;
//
//@Component
//public class ConsumerSweetCityVoteRdsReceiver extends AbstractSqlRedisReceiver {
// @Override
// protected String getRedisStreamKey() {
// return MQConst.SweetQueue.SWEET_CITY_VOTE.getKey();
// }
//
// @Override
// protected String getRedisStreamGroup() {
// return MQConst.SweetQueue.SWEET_CITY_VOTE.getGroup();
// }
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/receiver/ConsumerSweetIntegralActivityDrawRdsReceiver.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerSweetIntegralActivityDrawRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.SweetQueue.SWEET_INTEGRAL_ACTIVITY_DRAW.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.SweetQueue.SWEET_INTEGRAL_ACTIVITY_DRAW.getGroup();
}
}
//package com.liquidnet.service.consumer.sweet.receiver;
//
//import com.liquidnet.service.base.constant.MQConst;
//import org.springframework.stereotype.Component;
//
//@Component
//public class ConsumerSweetIntegralActivityDrawRdsReceiver extends AbstractSqlRedisReceiver {
// @Override
// protected String getRedisStreamKey() {
// return MQConst.SweetQueue.SWEET_INTEGRAL_ACTIVITY_DRAW.getKey();
// }
//
// @Override
// protected String getRedisStreamGroup() {
// return MQConst.SweetQueue.SWEET_INTEGRAL_ACTIVITY_DRAW.getGroup();
// }
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/receiver/ConsumerSweetMaoDengReceiver.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerSweetMaoDengReceiver extends AbstractSqlRedisReceiver{
@Override
protected String getRedisStreamKey() {
return MQConst.SweetQueue.SWEET_WECHAT_MAODENG_TEXT_INSERT.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.SweetQueue.SWEET_WECHAT_MAODENG_TEXT_INSERT.getGroup();
}
}
//package com.liquidnet.service.consumer.sweet.receiver;
//
//import com.liquidnet.service.base.constant.MQConst;
//import org.springframework.stereotype.Component;
//
//@Component
//public class ConsumerSweetMaoDengReceiver extends AbstractSqlRedisReceiver{
// @Override
// protected String getRedisStreamKey() {
// return MQConst.SweetQueue.SWEET_WECHAT_MAODENG_TEXT_INSERT.getKey();
// }
//
// @Override
// protected String getRedisStreamGroup() {
// return MQConst.SweetQueue.SWEET_WECHAT_MAODENG_TEXT_INSERT.getGroup();
// }
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/receiver/ConsumerSweetPosterRdsReceiver.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerSweetPosterRdsReceiver extends AbstractSqlRedisReceiver{
@Override
protected String getRedisStreamKey() {
return MQConst.SweetQueue.SWEET_POSTER.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.SweetQueue.SWEET_POSTER.getGroup();
}
}
//package com.liquidnet.service.consumer.sweet.receiver;
//
//import com.liquidnet.service.base.constant.MQConst;
//import org.springframework.stereotype.Component;
//
//@Component
//public class ConsumerSweetPosterRdsReceiver extends AbstractSqlRedisReceiver{
// @Override
// protected String getRedisStreamKey() {
// return MQConst.SweetQueue.SWEET_POSTER.getKey();
// }
//
// @Override
// protected String getRedisStreamGroup() {
// return MQConst.SweetQueue.SWEET_POSTER.getGroup();
// }
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/receiver/ConsumerSweetRemindRdsReceiver.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerSweetRemindRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.SweetQueue.SWEET_REMIND_INSERT.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.SweetQueue.SWEET_REMIND_INSERT.getGroup();
}
}
//package com.liquidnet.service.consumer.sweet.receiver;
//
//import com.liquidnet.service.base.constant.MQConst;
//import org.springframework.stereotype.Component;
//
//@Component
//public class ConsumerSweetRemindRdsReceiver extends AbstractSqlRedisReceiver {
// @Override
// protected String getRedisStreamKey() {
// return MQConst.SweetQueue.SWEET_REMIND_INSERT.getKey();
// }
//
// @Override
// protected String getRedisStreamGroup() {
// return MQConst.SweetQueue.SWEET_REMIND_INSERT.getGroup();
// }
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/receiver/ConsumerSweetSqlLuckDrawRdsReceiver.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerSweetSqlLuckDrawRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.SweetQueue.LUCK_DRAW.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.SweetQueue.LUCK_DRAW.getGroup();
}
}
//package com.liquidnet.service.consumer.sweet.receiver;
//
//import com.liquidnet.service.base.constant.MQConst;
//import org.springframework.stereotype.Component;
//
//@Component
//public class ConsumerSweetSqlLuckDrawRdsReceiver extends AbstractSqlRedisReceiver {
// @Override
// protected String getRedisStreamKey() {
// return MQConst.SweetQueue.LUCK_DRAW.getKey();
// }
//
// @Override
// protected String getRedisStreamGroup() {
// return MQConst.SweetQueue.LUCK_DRAW.getGroup();
// }
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/receiver/ConsumerSweetSqlUserRelationMDSKRdsReceiver.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerSweetSqlUserRelationMDSKRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.SweetQueue.ARTISTS_RELATION_MDSK.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.SweetQueue.ARTISTS_RELATION_MDSK.getGroup();
}
}
//package com.liquidnet.service.consumer.sweet.receiver;
//
//import com.liquidnet.service.base.constant.MQConst;
//import org.springframework.stereotype.Component;
//
//@Component
//public class ConsumerSweetSqlUserRelationMDSKRdsReceiver extends AbstractSqlRedisReceiver {
// @Override
// protected String getRedisStreamKey() {
// return MQConst.SweetQueue.ARTISTS_RELATION_MDSK.getKey();
// }
//
// @Override
// protected String getRedisStreamGroup() {
// return MQConst.SweetQueue.ARTISTS_RELATION_MDSK.getGroup();
// }
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/receiver/ConsumerSweetSqlUserRelationRdsReceiver.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerSweetSqlUserRelationRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.SweetQueue.ARTISTS_RELATION.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.SweetQueue.ARTISTS_RELATION.getGroup();
}
}
//package com.liquidnet.service.consumer.sweet.receiver;
//
//import com.liquidnet.service.base.constant.MQConst;
//import org.springframework.stereotype.Component;
//
//@Component
//public class ConsumerSweetSqlUserRelationRdsReceiver extends AbstractSqlRedisReceiver {
// @Override
// protected String getRedisStreamKey() {
// return MQConst.SweetQueue.ARTISTS_RELATION.getKey();
// }
//
// @Override
// protected String getRedisStreamGroup() {
// return MQConst.SweetQueue.ARTISTS_RELATION.getGroup();
// }
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/receiver/ConsumerSweetStoneIntegralReceiver.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.receiver;
import com.liquidnet.commons.lang.util.CollectionUtil;
import com.liquidnet.commons.lang.util.JsonUtils;
import com.liquidnet.service.base.ResponseDto;
import com.liquidnet.service.base.constant.MQConst;
import com.liquidnet.service.feign.stone.api.FeignStoneIntegralClient;
import com.liquidnet.service.sweet.param.SweetStoneIntegralParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.StreamRecords;
import org.springframework.stereotype.Component;
import java.util.HashMap;
@Slf4j
@Component
public class ConsumerSweetStoneIntegralReceiver extends AbstractSqlRedisReceiver {
@Autowired
private FeignStoneIntegralClient feignStoneIntegralClient;
@Override
protected String getRedisStreamKey() {
return MQConst.SweetQueue.SWEET_STONE_INTEGRAL.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.SweetQueue.SWEET_STONE_INTEGRAL.getGroup();
}
@Override
public void onMessage(MapRecord<String, String, String> message) {
String redisStreamKey = this.getRedisStreamKey();
log.debug("CONSUMER MSG[streamKey:{},messageId:{},stream:{},body:{}]", redisStreamKey, message.getId(), message.getStream(), message.getValue());
boolean result = this.consumerMessageHandler(message.getValue().get("message"));
log.info("CONSUMER MSG RESULT:{} ==> [{}]MESSAGE_ID:{}", result, redisStreamKey, message.getId());
try {
stringRedisTemplate.opsForStream().acknowledge(getRedisStreamGroup(), message);
} catch (Exception e) {
log.error("#CONSUMER MSG EX_ACK ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
}
try {
stringRedisTemplate.opsForStream().delete(redisStreamKey, message.getId());
} catch (Exception e) {
log.error("#CONSUMER MSG EX_DEL ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
}
}
private boolean consumerMessageHandler(String msg) {
boolean aBoolean = false;
try {
SweetStoneIntegralParam param = JsonUtils.fromJson(msg, SweetStoneIntegralParam.class);
if (param == null) {
aBoolean = true;
} else {
ResponseDto<String> res = null;
if (null == param.getType()) {
aBoolean = true;
return true;
}
if (param.getType() == 1) {
res = feignStoneIntegralClient.in2112(
param.getUid(),
param.getScore(),
param.getContent()
);
} else if (param.getType() == 2) {
res = feignStoneIntegralClient.de2111(
param.getUid(),
param.getScore(),
param.getContent()
);
}
if (null != res && res.getCode().equals("0")) {
aBoolean = true;
}
}
} catch (Exception e) {
log.error("CONSUMER MSG EX_HANDLE ==> [{}]:{}", this.getRedisStreamKey(), msg, e);
} finally {
if (!aBoolean) {
HashMap<String, String> map = CollectionUtil.mapStringString();
map.put("message", msg);
stringRedisTemplate.opsForStream().add(StreamRecords.mapBacked(map).withStreamKey(this.getRedisStreamKey()));
}
}
return aBoolean;
}
}
//package com.liquidnet.service.consumer.sweet.receiver;
//
//import com.liquidnet.commons.lang.util.CollectionUtil;
//import com.liquidnet.commons.lang.util.JsonUtils;
//import com.liquidnet.service.base.ResponseDto;
//import com.liquidnet.service.base.constant.MQConst;
//import com.liquidnet.service.feign.stone.api.FeignStoneIntegralClient;
//import com.liquidnet.service.sweet.param.SweetStoneIntegralParam;
//import lombok.extern.slf4j.Slf4j;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.data.redis.connection.stream.MapRecord;
//import org.springframework.data.redis.connection.stream.StreamRecords;
//import org.springframework.stereotype.Component;
//
//import java.util.HashMap;
//
//@Slf4j
//@Component
//public class ConsumerSweetStoneIntegralReceiver extends AbstractSqlRedisReceiver {
//
// @Autowired
// private FeignStoneIntegralClient feignStoneIntegralClient;
//
// @Override
// protected String getRedisStreamKey() {
// return MQConst.SweetQueue.SWEET_STONE_INTEGRAL.getKey();
// }
//
// @Override
// protected String getRedisStreamGroup() {
// return MQConst.SweetQueue.SWEET_STONE_INTEGRAL.getGroup();
// }
//
// @Override
// public void onMessage(MapRecord<String, String, String> message) {
// String redisStreamKey = this.getRedisStreamKey();
// log.debug("CONSUMER MSG[streamKey:{},messageId:{},stream:{},body:{}]", redisStreamKey, message.getId(), message.getStream(), message.getValue());
// boolean result = this.consumerMessageHandler(message.getValue().get("message"));
// log.info("CONSUMER MSG RESULT:{} ==> [{}]MESSAGE_ID:{}", result, redisStreamKey, message.getId());
//
// try {
// stringRedisTemplate.opsForStream().acknowledge(getRedisStreamGroup(), message);
// } catch (Exception e) {
// log.error("#CONSUMER MSG EX_ACK ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
// }
// try {
// stringRedisTemplate.opsForStream().delete(redisStreamKey, message.getId());
// } catch (Exception e) {
// log.error("#CONSUMER MSG EX_DEL ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
// }
// }
//
// private boolean consumerMessageHandler(String msg) {
// boolean aBoolean = false;
// try {
// SweetStoneIntegralParam param = JsonUtils.fromJson(msg, SweetStoneIntegralParam.class);
// if (param == null) {
// aBoolean = true;
// } else {
// ResponseDto<String> res = null;
// if (null == param.getType()) {
// aBoolean = true;
// return true;
// }
// if (param.getType() == 1) {
// res = feignStoneIntegralClient.in2112(
// param.getUid(),
// param.getScore(),
// param.getContent()
// );
// } else if (param.getType() == 2) {
// res = feignStoneIntegralClient.de2111(
// param.getUid(),
// param.getScore(),
// param.getContent()
// );
// }
// if (null != res && res.getCode().equals("0")) {
// aBoolean = true;
// }
// }
// } catch (Exception e) {
// log.error("CONSUMER MSG EX_HANDLE ==> [{}]:{}", this.getRedisStreamKey(), msg, e);
// } finally {
// if (!aBoolean) {
// HashMap<String, String> map = CollectionUtil.mapStringString();
// map.put("message", msg);
// stringRedisTemplate.opsForStream().add(StreamRecords.mapBacked(map).withStreamKey(this.getRedisStreamKey()));
// }
// }
// return aBoolean;
// }
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/receiver/ConsumerSweetTemplateMsgReceiver.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.receiver;
import com.liquidnet.commons.lang.util.CollectionUtil;
import com.liquidnet.commons.lang.util.JsonUtils;
import com.liquidnet.service.base.constant.MQConst;
import com.liquidnet.service.consumer.sweet.service.impl.SweetWechatTemplateMsgServiceImpl;
import com.liquidnet.service.sweet.dto.param.SweetOpenSendMsgParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.StreamRecords;
import org.springframework.stereotype.Component;
import java.util.HashMap;
@Slf4j
@Component
public class ConsumerSweetTemplateMsgReceiver extends AbstractSqlRedisReceiver {
@Autowired
SweetWechatTemplateMsgServiceImpl sweetWechatTemplateService;
@Override
protected String getRedisStreamKey() {
return MQConst.SweetQueue.SWEET_TEMPLATE_MSG.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.SweetQueue.SWEET_TEMPLATE_MSG.getGroup();
}
@Override
public void onMessage(MapRecord<String, String, String> message) {
String redisStreamKey = this.getRedisStreamKey();
log.debug("CONSUMER MSG[streamKey:{},messageId:{},stream:{},body:{}]", redisStreamKey, message.getId(), message.getStream(), message.getValue());
boolean result = this.consumerMessageHandler(message.getValue().get("message"));
log.info("CONSUMER MSG RESULT:{} ==> [{}]MESSAGE_ID:{}", result, redisStreamKey, message.getId());
try {
stringRedisTemplate.opsForStream().acknowledge(getRedisStreamGroup(), message);
} catch (Exception e) {
log.error("#CONSUMER MSG EX_ACK ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
}
try {
stringRedisTemplate.opsForStream().delete(redisStreamKey, message.getId());
} catch (Exception e) {
log.error("#CONSUMER MSG EX_DEL ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
}
}
private boolean consumerMessageHandler(String msg) {
boolean aBoolean = false;
try {
SweetOpenSendMsgParam sweetOpenSendMsgParam = JsonUtils.fromJson(msg, SweetOpenSendMsgParam.class);
aBoolean = null == sweetOpenSendMsgParam || sweetWechatTemplateService.openSendMsg(sweetOpenSendMsgParam);
} catch (Exception e) {
log.error("CONSUMER MSG EX_HANDLE ==> [{}]:{}", this.getRedisStreamKey(), msg, e);
} finally {
if (!aBoolean) {
HashMap<String, String> map = CollectionUtil.mapStringString();
map.put("message", msg);
stringRedisTemplate.opsForStream().add(StreamRecords.mapBacked(map).withStreamKey(this.getRedisStreamKey()));
}
}
return aBoolean;
}
}
//package com.liquidnet.service.consumer.sweet.receiver;
//
//import com.liquidnet.commons.lang.util.CollectionUtil;
//import com.liquidnet.commons.lang.util.JsonUtils;
//import com.liquidnet.service.base.constant.MQConst;
//import com.liquidnet.service.consumer.sweet.service.impl.SweetWechatTemplateMsgServiceImpl;
//import com.liquidnet.service.sweet.dto.param.SweetOpenSendMsgParam;
//import lombok.extern.slf4j.Slf4j;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.data.redis.connection.stream.MapRecord;
//import org.springframework.data.redis.connection.stream.StreamRecords;
//import org.springframework.stereotype.Component;
//
//import java.util.HashMap;
//
//@Slf4j
//@Component
//public class ConsumerSweetTemplateMsgReceiver extends AbstractSqlRedisReceiver {
//
// @Autowired
// SweetWechatTemplateMsgServiceImpl sweetWechatTemplateService;
//
// @Override
// protected String getRedisStreamKey() {
// return MQConst.SweetQueue.SWEET_TEMPLATE_MSG.getKey();
// }
//
// @Override
// protected String getRedisStreamGroup() {
// return MQConst.SweetQueue.SWEET_TEMPLATE_MSG.getGroup();
// }
//
// @Override
// public void onMessage(MapRecord<String, String, String> message) {
// String redisStreamKey = this.getRedisStreamKey();
// log.debug("CONSUMER MSG[streamKey:{},messageId:{},stream:{},body:{}]", redisStreamKey, message.getId(), message.getStream(), message.getValue());
// boolean result = this.consumerMessageHandler(message.getValue().get("message"));
// log.info("CONSUMER MSG RESULT:{} ==> [{}]MESSAGE_ID:{}", result, redisStreamKey, message.getId());
//
// try {
// stringRedisTemplate.opsForStream().acknowledge(getRedisStreamGroup(), message);
// } catch (Exception e) {
// log.error("#CONSUMER MSG EX_ACK ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
// }
// try {
// stringRedisTemplate.opsForStream().delete(redisStreamKey, message.getId());
// } catch (Exception e) {
// log.error("#CONSUMER MSG EX_DEL ==> [{}]RESULT:{},MESSAGE:{}", redisStreamKey, result, message.getValue(), e);
// }
// }
//
// private boolean consumerMessageHandler(String msg) {
// boolean aBoolean = false;
// try {
// SweetOpenSendMsgParam sweetOpenSendMsgParam = JsonUtils.fromJson(msg, SweetOpenSendMsgParam.class);
// aBoolean = null == sweetOpenSendMsgParam || sweetWechatTemplateService.openSendMsg(sweetOpenSendMsgParam);
// } catch (Exception e) {
// log.error("CONSUMER MSG EX_HANDLE ==> [{}]:{}", this.getRedisStreamKey(), msg, e);
// } finally {
// if (!aBoolean) {
// HashMap<String, String> map = CollectionUtil.mapStringString();
// map.put("message", msg);
// stringRedisTemplate.opsForStream().add(StreamRecords.mapBacked(map).withStreamKey(this.getRedisStreamKey()));
// }
// }
// return aBoolean;
// }
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/receiver/ConsumerSweetUserRdsReceiver.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.receiver;
import com.liquidnet.service.base.constant.MQConst;
import org.springframework.stereotype.Component;
@Component
public class ConsumerSweetUserRdsReceiver extends AbstractSqlRedisReceiver {
@Override
protected String getRedisStreamKey() {
return MQConst.SweetQueue.SWEET_WECHAT_USER_INSERT.getKey();
}
@Override
protected String getRedisStreamGroup() {
return MQConst.SweetQueue.SWEET_WECHAT_USER_INSERT.getGroup();
}
}
//package com.liquidnet.service.consumer.sweet.receiver;
//
//import com.liquidnet.service.base.constant.MQConst;
//import org.springframework.stereotype.Component;
//
//@Component
//public class ConsumerSweetUserRdsReceiver extends AbstractSqlRedisReceiver {
// @Override
// protected String getRedisStreamKey() {
// return MQConst.SweetQueue.SWEET_WECHAT_USER_INSERT.getKey();
// }
//
// @Override
// protected String getRedisStreamGroup() {
// return MQConst.SweetQueue.SWEET_WECHAT_USER_INSERT.getGroup();
// }
//}
liquidnet-bus-service/liquidnet-service-consumer-all/liquidnet-service-consumer-sweet/src/main/java/com/liquidnet/service/consumer/sweet/utils/RedisDataUtils.java
View file @ e4d5499e
package com.liquidnet.service.consumer.sweet.utils;
import com.liquidnet.common.cache.redis.util.RedisUtil;
import com.liquidnet.service.sweet.constant.SweetConstant;
import com.liquidnet.service.sweet.vo.SweetWechatUsersVo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
@Slf4j
public class RedisDataUtils {
@Autowired
private RedisUtil redisUtil;
public SweetWechatUsersVo getSweetWechatUsersOfUnionId(String unionId, Integer type) {
String redisKey = SweetConstant.REDIS_KEY_SWEET_WECHAT_USERS_UNIONID.concat(unionId)
.concat(SweetConstant.REDIS_KEY_SWEET_WECHAT_USERS_TYPE).concat(String.valueOf(type));
Object obj = redisUtil.get(redisKey);
if (null == obj) {
return null;
} else {
SweetWechatUsersVo sweetWechatUsersVo = (SweetWechatUsersVo) obj;
return sweetWechatUsersVo;
}
}
}
//package com.liquidnet.service.consumer.sweet.utils;
//
//import com.liquidnet.common.cache.redis.util.RedisUtil;
//import com.liquidnet.service.sweet.constant.SweetConstant;
//import com.liquidnet.service.sweet.vo.SweetWechatUsersVo;
//import lombok.extern.slf4j.Slf4j;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.stereotype.Component;
//
//@Component
//@Slf4j
//public class RedisDataUtils {
//
// @Autowired
// private RedisUtil redisUtil;
//
// public SweetWechatUsersVo getSweetWechatUsersOfUnionId(String unionId, Integer type) {
// String redisKey = SweetConstant.REDIS_KEY_SWEET_WECHAT_USERS_UNIONID.concat(unionId)
// .concat(SweetConstant.REDIS_KEY_SWEET_WECHAT_USERS_TYPE).concat(String.valueOf(type));
// Object obj = redisUtil.get(redisKey);
// if (null == obj) {
// return null;
// } else {
// SweetWechatUsersVo sweetWechatUsersVo = (SweetWechatUsersVo) obj;
// return sweetWechatUsersVo;
// }
// }
//
//}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment