redisson中怎么实现一个延时消息组件，针对这个问题，这篇文章详细介绍了相对应的分析和解答，希望可以帮助更多想解决这个问题的小伙伴找到更简单易行的方法。
创新互联专注于长葛企业网站建设,成都响应式网站建设,商城网站制作。长葛网站建设公司,为长葛等地区提供建站服务。全流程按需定制网站，专业设计，全程项目跟踪，创新互联专业和态度为您提供的服务
定义主题队列注解
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface RMessage {
/**
* 消息队列
* @return
*/
String queue();
/**
* 主题
* @return
*/
String topic() default "system";
}springboot启动监听初始化任务队列与消息主题，消费者订阅主题
@Slf4j
@Component
public class RMessageListener implements ApplicationListener {
/**
* consumer monitoringMethod monitorMessage
*/
private final static String METHOD_MONITOR_MESSAGE = "monitorMessage";
/**
* redisson topic name
*/
private final static String ATTRIBUTE_NAME_TOPIC = "topic";
/**
* redisson messageQueue name
*/
private final static String ATTRIBUTE_NAME_QUEUE = "queue";
/**
* redisson queue map
*/
public static Map> messageQueue = new ConcurrentHashMap<>();
/**
* redisson offQueue map
*/
public static Map> offQueue = new ConcurrentHashMap<>();
/**
* redisson topic map
*/
public static Map topicMap = new ConcurrentHashMap<>();
@Override
public void onApplicationEvent(ApplicationStartedEvent applicationStartedEvent) {
ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false);
provider.addIncludeFilter(new AnnotationTypeFilter(RMessage.class));
String basePackage = applicationStartedEvent.getSpringApplication().getMainApplicationClass().getPackage().getName();
Set beanDefinitions = provider.findCandidateComponents(basePackage);
ConfigurableListableBeanFactory beanFactory = applicationStartedEvent.getApplicationContext().getBeanFactory();
mqInit(beanDefinitions, beanFactory);
provider.clearCache();
provider.resetFilters(false);
provider.addIncludeFilter(new AssignableTypeFilter(RMessageConsumer.class));
Set consumers = provider.findCandidateComponents(basePackage);
consumerSubscribe(beanFactory, consumers);
}
/**
* consumer subscription news
*
* @param beanFactory
* @param consumers
*/
private void consumerSubscribe(ConfigurableListableBeanFactory beanFactory, Set consumers) {
consumers.forEach(beanDefinition -> {
log.info("rMessage init consumer {}",beanDefinition.getBeanClassName());
try {
Object bean = beanFactory.getBean(Class.forName(beanDefinition.getBeanClassName()));
Method method = bean.getClass().getMethod(METHOD_MONITOR_MESSAGE);
ReflectionUtils.invokeMethod(method,bean);
} catch (ClassNotFoundException | NoSuchMethodException e) {
e.printStackTrace();
}
});
}
/**
* Parameter initialization
*
* @param beanDefinitions
* @param beanFactory
*/
private void mqInit(Set beanDefinitions,final ConfigurableListableBeanFactory beanFactory) {
RedissonClient redissonClient = beanFactory.getBean(RedissonClient.class);
beanDefinitions.stream().filter(beanDefinition -> beanDefinition instanceof AnnotatedBeanDefinition).forEach(beanDefinition->{
AnnotatedBeanDefinition annotatedBeanDefinition = (AnnotatedBeanDefinition)beanDefinition;
AnnotationMetadata annotationMetadata = annotatedBeanDefinition.getMetadata();
MergedAnnotation mergedAnnotation = annotationMetadata.getAnnotations().get(RMessage.class);
String queryName = mergedAnnotation.getString(ATTRIBUTE_NAME_QUEUE);
String topicName = mergedAnnotation.getString(ATTRIBUTE_NAME_TOPIC);
String shortName = topicName+"."+queryName;
RBlockingDeque blockingDeque = redissonClient.getBlockingDeque(shortName);
messageQueue.put(shortName,blockingDeque);
RDelayedQueue delayedQueue = redissonClient.getDelayedQueue(blockingDeque);
offQueue.put(shortName,delayedQueue);
RTopic topic = redissonClient.getTopic(topicName);
topicMap.put(shortName,topic);
});
}
}
抽象队列主题列表
public abstract class AbstractQueue {
Map> offQueue = RMessageListener.offQueue;
Map> messageQueue = RMessageListener.messageQueue;
Map topicMap = RMessageListener.topicMap;
protected RDelayedQueue getRDelayedQueue() {
return offQueue.get(shortName());
}
protected RBlockingDeque getMessageQueue() {
return messageQueue.get(shortName());
}
private String shortName() {
Annotation[] annotations = this.getClass().getAnnotations();
RMessage rMessage = Arrays.stream(annotations).filter(annotation -> annotation instanceof RMessage)
.map(annotation -> (RMessage)annotation).findAny().get();
String queryName = rMessage.queue();
String topicName = rMessage.topic();
return topicName+"."+queryName;
}
protected RTopic getTopic() {
return topicMap.get(shortName());
}
}抽象生产者模板
@Slf4j
public abstract class RMessageProducer extends AbstractQueue {
/**
* 发送延时消息
* @param message
* @param delay
* @param timeUnit
*/
public void sendMessage(T message, long delay, TimeUnit timeUnit) {
log.info("rMessage sendMessage: {}, delayTime {}",message.toString(),delay+timeUnit.name());
super.getRDelayedQueue().offer(message,delay,timeUnit);
super.getTopic().publish(this.hashCode());
}
/**
* 发送异步消息
* @param message
*/
public void sendMessage(T message) {
this.sendMessage(message,0,TimeUnit.MILLISECONDS);
}
}
抽象消费者模板
@Slf4j
public abstract class RMessageConsumer extends AbstractQueue {
public void monitorMessage() {
CompletableFuture.runAsync(this::pastConsumption);
super.getTopic().addListener(Object.class,(c,m)-> {
try {
Object take = super.getMessageQueue().take();
log.info("rMessage receiveMessage: {}, receiving time {}",take.toString(), LocalDateTime.now());
this.useMessage((T)take);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
}
protected abstract void useMessage(T message);
public void pastConsumption() {
while (super.getRDelayedQueue().size() > 0 || super.getMessageQueue().size() > 0) {
try {
Object take = super.getMessageQueue().take();
log.info("rMessage receiveMessage: {}, receiving time {}",take.toString(), LocalDateTime.now());
this.useMessage((T)take);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
具体使用
生产者
@RMessage(queue = "redisQuery",topic = "order")
public class RedissonProducer extends RMessageProducer {
}
@RestController
@RequestMapping("producer")
@AllArgsConstructor
public class ProducerController {
private RedissonProducer redissonProducer;
@PostMapping
public String send() {
HashMap map = new HashMap<>();
map.put("name","张三");
map.put("time", "测试顺序第二条"+LocalDateTime.now());
redissonProducer.sendMessage(map,5, TimeUnit.MINUTES);
return "send msg";
}
}
消费者
@RMessage(queue = "redisQuery",topic = "order")
public class RedissonConsumer extends RMessageConsumer {
@Override
protected void useMessage(HashMap message) {
System.out.println("接收到消息:"+message);
}
}
关于 Redisson中怎么实现一个延时消息组件问题的解答就分享到这里了，希望以上内容可以对大家有一定的帮助，如果你还有很多疑惑没有解开，可以关注创新互联行业资讯频道了解更多相关知识。
当前名称：Redisson中怎么实现一个延时消息组件
网页链接：
http://bzwzjz.com/article/gggjih.html
