O middleware de enfileiramento de mensagens é um componente importante em um sistema distribuído. Ele resolve principalmente problemas como acoplamento de aplicativos, mensagens assíncronas e corte de tráfego. Obtenha alto desempenho, alta disponibilidade, escalabilidade e arquitetura eventualmente consistente . É um middleware indispensável para grandes sistemas distribuídos. O formato da mensagem oferece suporte à publicação ponto a ponto e por assinatura .
O que é ActiveMQ?
- ActiveMQ é uma tecnologia de enfileiramento de mensagens, nascida para resolver problemas de alta concorrência
- Modelo produtor-consumidor ActiveMQ (produtores e consumidores podem usar plataformas e sistemas cruzados)
- ActiveMQ suporta os dois métodos de transmissão de mensagem a seguir
- No modo ponto a ponto, o produtor produz uma mensagem, que só pode ser consumida por um consumidor
- No modo de publicação / assinatura, o produtor produz uma mensagem, que pode ser realizada por vários consumidores
SpringBoot integra ActiveMQ
1. O download do ActiveMQ começa
Você pode entrar diretamente no site oficial para fazer o download e concluir. http://activemq.apache.org/download-archives.html
Se você conseguir acessar http: // localhost: 8161 / admin (o nome de usuário e a senha são admin por padrão), a inicialização foi bem-sucedida.
2. Crie dois projetos springboot como provedor e consumidor, respectivamente, e adicione dependências
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-activemq</artifactId>
</dependency>
<!--消息队列连接池-->
<dependency>
<groupId>org.apache.activemq</groupId>
<artifactId>activemq-pool</artifactId>
<version>5.15.0</version>
</dependency>3. Configure a fila de mensagens em application.properires nos dois projetos e adicione @EnableJms à classe de inicialização para habilitar a fila de mensagens.
application.properties
# failover:(tcp://localhost:61616,tcp://localhost:61617)
# tcp://localhost:61616
spring.activemq.broker-url=tcp://localhost:61616
#true 表示使用内置的MQ，false则连接服务器
spring.activemq.in-memory=false
#true表示使用连接池；false时，每发送一条数据创建一个连接
spring.activemq.pool.enabled=true
#连接池最大连接数
spring.activemq.pool.max-connections=10
#空闲的连接过期时间，默认为30秒
spring.activemq.pool.idle-timeout=30000
#强制的连接过期时间，与idleTimeout的区别在于：idleTimeout是在连接空闲一段时间失效，而expiryTimeout不管当前连接的情况，只要达到指定时间就失效。默认为0，never
spring.activemq.pool.expiry-timeout=0Aqui está a configuração do par de valores-chave de valor-chave. Você também pode usar o formato yaml para configurar (este formato é o formato oficial recomendado)
Iniciar aula (provedor), consumidor também
@SpringBootApplication
@EnableJms //启动消息队列
public class ProviderApplication {
public static void main(String[] args) {
SpringApplication.run(ProviderApplication.class, args);
}
}4. Diagrama da estrutura do projeto do provador
BeanConfig define a fila de mensagens
import javax.jms.Queue;
import org.apache.activemq.command.ActiveMQQueue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/*
* @author ww
* @date 2021/3/23 11:55
*/
@Configuration
public class BeanConfig {
//定义存放消息的队列
@Bean
public Queue queue() {
return new ActiveMQQueue("ActiveMQQueue");
}
}ProviderController
import javax.jms.Queue;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsMessagingTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/*
* @author ww
* @date
*
*/
@RestController
public class ProviderController {
//注入存放消息的队列，用于下列方法一
@Autowired
private Queue queue;
//注入springboot封装的工具类
@Autowired
private JmsMessagingTemplate jmsMessagingTemplate;
@RequestMapping("send")
public void send(String name) {
//方法一：添加消息到消息队列
jmsMessagingTemplate.convertAndSend(queue, name);
//方法二：这种方式不需要手动创建queue，系统会自行创建名为test的队列
//jmsMessagingTemplate.convertAndSend("test", name);
}
}5. Inicie o provedor, adicione dados à fila de mensagens, desta vez adicione 5 dados
Aqui, a ferramenta carteiro é usada para simular o envio de solicitações.
Visualize http: // localhost: 8161 / admin / queues.jsp da seguinte maneira
- Número de mensagens pendentes: mensagens pendentes na fila de mensagens
- Número de consumidores: o número de consumidores
- Mensagens enfileiradas: o número total de mensagens que entraram na fila de mensagens
- Mensagens retiradas da fila: a quantidade total de mensagens consumidas
6. Diagrama da estrutura do projeto do consumidor
Application.properties e ConsumerApplication são semelhantes aos provedores e os seguintes são ConsumerServices diferentes:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.annotation.JmsListener;
import org.springframework.jms.core.JmsMessagingTemplate;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.stereotype.Component;
/*
* @author ww
* @date 2021/3/23 11:58
*
*/
@Component
public class ConsumerService {
@Autowired
private JmsMessagingTemplate jmsMessagingTemplate;
// 使用JmsListener配置消费者监听的队列，其中name是接收到的消息
@JmsListener(destination = "ActiveMQQueue")
// SendTo 会将此方法返回的数据, 写入到 OutQueue 中去.
@SendTo("SQueue")
public String handleMessage(String name) {
System.out.println("成功接受Name" + name);
return "成功接受Name" + name;
}
}7. Inicie o consumidor, a saída do console é a seguinte
Se a mensagem for recebida com sucesso, verifique http: // localhost: 8161 / admin / queues.jsp . Conforme mostrado na figura abaixo, não há mais mensagens não processadas na fila de mensagens. Devido ao início do consumidor, o número de consumidores é 1, Mensagens Desenfileiradas (O valor do número total de mensagens consumidas) também se tornou 5; além disso, após o consumidor ter recebido 5 mensagens para processamento, ele retorna ao OutQueue 5 mensagens, como pode ser visto no figura abaixo.
Referência do blog: https://blog.csdn.net/qq_22200097/article/details/82713261