Spring integração da entrada Activemq combate real introdução detalhada dois

Este artigo é baseado na integração do pacote jar, não no método maven. Se você precisa entender o método maven, verifique a introdução detalhada do combate real do blogger do Activemq. Está escrito no método maven.

O MQ apresenta
primeiro o MQ, o nome em inglês do MQ é MessageQueue e o nome chinês é a fila de mensagens que todos usam. Por que você a usa? Para ser franco, é um contêiner de recebimento e encaminhamento de mensagens que pode ser usado para envio de mensagem.

ActiveMQ é produzido pelo Apache, um barramento de mensagens de código aberto mais popular e poderoso. ActiveMQ é uma implementação do Provedor JMS que oferece suporte completo às especificações JMS1.1 e J2EE 1.4. É muito rápido, oferece suporte a clientes e protocolos em vários idiomas e pode ser facilmente integrado no ambiente de aplicativo corporativo e possui muitas funções avançadas.

Baixe ActiveMQ, aqui está um caso baseado na versão do Windows (produção real ou

Site oficial: http://activemq.apache.org/ 

Baixe e descompacte para obter conforme mostrado abaixo:

A descrição da estrutura de diretório acima: 

Bin armazena arquivos de script,
conf armazena arquivos de configuração básica,
dados armazena arquivos de log,
docs armazena documentos de descrição,
exemplos armazena exemplos simples,
lib armazena pacotes jar exigidos por activemq e
webapps é usado para armazenar o diretório do projeto.
Iniciar ActiveMQ 
Entendemos o diretório básico de activemq, vamos executar o serviço activemq, insira o arquivo de script activemq.bat no diretório bin ou execute o activemq.bat em nossa própria versão de computador, você pode ver o efeito da figura a seguir. 

 Quando o monitoramento do 
ActiveMQ é iniciado por padrão, o servidor jetty integrado é iniciado e um aplicativo administrativo para monitoramento do ActiveMQ é fornecido. 
Entre no navegador: http://127.0.0.1:8161/admin/

O nome de usuário e a senha são admin

Para parar o servidor, basta pressionar Ctrl + Shift + C e, em seguida, inserir y.

======================================================== =====================

Em primeiro lugar, aqui está o diagrama de estrutura do projeto do blogger como segue: Isso deve ficar mais claro, se você ainda não entendeu, o blogger pode fazer upload do código, mas acho que o código é muito simples, você pode seguir o código do blogger para executar através, vamos lá! Os dois projetos são realmente semelhantes ao processo de desenvolvimento empresarial real, um projeto chama os dados do outro projeto. Se ainda não entendeu, deixe uma mensagem para o blogueiro. Se você é um grande deus, pode ignorar este projeto. Afinal, o nível técnico atual do blogueiro não é bom, obrigado.
—————————————————

Duas estruturas de projeto: activemq-producer envia itens na fila de mensagens e activemq-consumer recebe itens na fila de consumo.

Etapas específicas: 1: Primeiro crie dois projetos, activemq-producer e activemq-consumer.

2. Em seguida, importe o pacote jar exigido pela dependência:

3: Configure a configuração do produtor: applicationContext-activemq.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd
	http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.2.xsd">
	<!-- ActiveMQConnectionFactory 工厂连接 -->
	<bean id="targetConnection" class="org.apache.activemq.ActiveMQConnectionFactory">
		<!--activemq的链接地址  -->
		<property name="brokerURL" value="tcp://127.0.0.1:61616"></property>
	</bean>
	<!-- 通用的connectionfacotry 指定真正使用的连接工厂 ，如其他RibbitMQ,kafka,RiketMQ等，到时候只需要修改class指定的工厂-->
	<bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
		<property name="targetConnectionFactory" ref="targetConnection"></property>
	</bean>
	<!-- 接收和发送消息时使用的类 模板对象-->
	<bean class="org.springframework.jms.core.JmsTemplate">
		<property name="connectionFactory" ref="connectionFactory"></property>
	</bean>
	<!--点对点模式，只能是一个生产者产生一个消息，被一个消费者消费。  -->
	 <bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
	 		<!-- 队列消息名称 -->
		<constructor-arg name="name" value="demo-change-queue"></constructor-arg>
	</bean> 
	
	<!-- 发布订阅模式，一个生产者可以一个消息，可以被多个消费者消费。 -->
	 <!-- <bean id="topicDestination" class="org.apache.activemq.command.ActiveMQTopic">
		订阅消息名称
		<constructor-arg name="name" value="demo-change-topic"></constructor-arg>
	</bean>  -->
	
</beans>

4: Configure a configuração do consumidor: applicationContext-activemq.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd
	http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.2.xsd">
	<!-- ActiveMQConnectionFactory 工厂连接 -->
	<bean id="targetConnection" class="org.apache.activemq.ActiveMQConnectionFactory">
		<!--activemq的链接地址  -->
		<property name="brokerURL" value="tcp://127.0.0.1:61616"></property>
	</bean>
	<!-- 通用的connectionfacotry 指定真正使用的连接工厂 ，如其他RibbitMQ,kafka,RiketMQ等，到时候只需要修改class指定的工厂-->
	<bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
		<property name="targetConnectionFactory" ref="targetConnection"></property>
	</bean>
	<!-- 接收和发送消息时使用的类 模板对象-->
	<bean class="org.springframework.jms.core.JmsTemplate">
		<property name="connectionFactory" ref="connectionFactory"></property>
	</bean>
	<!--点对点模式，只能是一个生产者产生一个消息，被一个消费者消费。  -->
	<bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
		<constructor-arg name="name" value="item-change-queue"></constructor-arg>
	</bean> 
	<!-- 发布订阅模式，一个生产者可以一个消息，可以被多个消费者消费。 -->
	<!-- <bean id="topicDestination" class="org.apache.activemq.command.ActiveMQTopic">
		订阅名称
		<constructor-arg name="name" value="demo-change-topic"></constructor-arg>
	</bean> -->
	
	<!-- 监听器 -->
	 <bean id="myMessageListener" class="com.learn.activemq.MyMessageListener"></bean>
	<!-- 监听容器，作用：启动线程做监听 -->
	<bean class="org.springframework.jms.listener.DefaultMessageListenerContainer">
		<property name="connectionFactory" ref="connectionFactory"></property>
		<!--  这里ref需要对应相应的模式进行修改-->
		<property name="destination" ref="queueDestination"></property>
		<property name="messageListener" ref="myMessageListener"></property>
	</bean>
	
	<!-- <bean id="myMessageListener2" class="com.learn.activemq.MyMessageListener"></bean>
	监听容器，作用：启动线程做监听
	<bean class="org.springframework.jms.listener.DefaultMessageListenerContainer">
		<property name="connectionFactory" ref="connectionFactory"></property>
		<property name="destination" ref="topicDestination"></property>
		<property name="messageListener" ref="myMessageListener2"></property>
	</bean>
	<bean id="myMessageListener3" class="com.learn.activemq.MyMessageListener"></bean>
	监听容器，作用：启动线程做监听
	<bean class="org.springframework.jms.listener.DefaultMessageListenerContainer">
		<property name="connectionFactory" ref="connectionFactory"></property>
		<property name="destination" ref="topicDestination"></property>
		<property name="messageListener" ref="myMessageListener3"></property>
	</bean> -->
</beans>

5: Escreva o teste do produtor: Produtor

package com.learn.activemq;

import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;


import org.apache.xbean.spring.context.ClassPathXmlApplicationContext;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;

public class Producer {
	@Test
	public void send() throws Exception{
		//1.初始化spring容器
		ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext-activemq.xml");
		//2.获取到jmstemplate的对象
		JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
		//3.获取destination
		Destination destination = (Destination) context.getBean(Destination.class);
		//4.发送消息
		jmsTemplate.send(destination, new MessageCreator() {
			
			@Override
			public Message createMessage(Session session) throws JMSException {
				return session.createTextMessage("我是activemq发送者，生产者，请问消费者在吗?");
			}
		});
		Thread.sleep(1000);//休息1000毫秒  =1秒
		
	}
}

 

6: Escreva o ouvinte do consumidor:

package com.learn.activemq;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;
import javax.xml.soap.Text;

public class MyMessageListener implements MessageListener {

	@Override
	public void onMessage(Message message) {
		//获取消息
		if(message instanceof TextMessage){
			TextMessage textMessage = (TextMessage)message;
			String text;
			try {
				text = textMessage.getText();
				System.out.println(text);
			} catch (JMSException e) {
				e.printStackTrace();
			}
		}
	}

}

7: Teste de gravação do consumidor: (o blogueiro aqui não tem problemas com o teste do modo de mensagem da fila, mas o teste do modo de mensagem de assinatura não foi bem-sucedido e precisa ser modificado)

package com.learn.activemq;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ActivemqConsumerTest {
	@Test
	public void testQueueConsumer() throws Exception {
		//初始化spring容器
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext-activemq.xml");
		//等待
		System.in.read();
	}

}

Método de inicialização: inicie o Produtor primeiro e, em seguida, execute ActivemqConsumerTest. Execute para ver o resultado:

Por fim, o blogger carrega o código para CSDN. Se você não entende, pode consultar o código baixado para aprender o Demo.