Enjoy A New Student Discount All 55,000 Courses on sale for Only $12.99

Ends in 05h 23m 49s

Java17 – Probando el trabajo con RabbitMQ-4

El «Producer»

Siguiendo los pasos del articulo anterior, ahora nos toca crear la aplicación que se encarga de solicitar la inclusión este objeto, que contiene el nombre del cliente y su dirección de correo electrónico en la base de datos remota. Según nuestro planteamiento inicial, esta aplicación es un CRUD completo que maneja tantas tablas como sean necesarias; para nuestro ejemplo, obviaremos todo ello, y únicamente crearemos un servicio para realizar la petición a nuestro servidor RabbitMQ

La aplicación

Vamos a crear una aplicación con Java17 y Spring, llamada AMQP-ProducerCrud

  • Utilizaremos Maven
  • Java 17

En eclipse, quedaría así

Los módulos a incluir en el package serán

  • Spring for RabbitMQ
  • Spring Boot DevTools

Añadiendo que solo el primero seria necesario. Insisto en que solo estamos teniendo en cuenta la recepción de los mensajes

Como vamos a utilizar JSON para enviar la clase, necesitaremos incorporar una clase mas, y directamente en el pom.xml podemos añadir

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.4</version>
</dependency>

Debemos configurar la conexión al servidor, para lo cual, en src/main/resources abrimos el fichero application.properties

spring.rabbitmq.host=http://localhost
spring.rabbitmq.port=5679		
spring.rabbitmq.username=blogCrud
spring.rabbitmq.password=<pass usuario>
spring.rabbitmq.virtual-host=HostCrud

rabbitmq.exchange.name=exchangeCRUD
rabbitmq.routing.key=guardaCli

Son los datos de conexión al servidor, y, los dos últimos son los datos de exchange y RoutingKey que necesitaremos mas adelante, y que son lo único que emplearemos para enviar el mensaje, ya que la decisión de a que cola entregarlo, esta en el servidor.

Podemos escribir la clase para configuración, en la que incorporamos en el rabbitTemplate una clase para realizar las conversiones a Json que necesitamos, y que podría ser asi

package com.rf.rabbit.config;

import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMQConfig {

	@Bean
	public MessageConverter converter() {
		return new Jackson2JsonMessageConverter();
	}

	@Bean
	public AmqpTemplate amqpTemplate(ConnectionFactory connectionFactory) {
		RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
		rabbitTemplate.setMessageConverter(converter());
		return rabbitTemplate;
	}

}

Tenemos que escribir la clase DTO que deberá ser idéntica a la clase que espera Consumer, y, que en nuestro caso, seria

package com.rf.rabbit.dto;


public class ClienteMail {
    private int id;
    private String nombreCliente;
    private String correoElectronico;
	
    public ClienteMail() {
		super();		
	}

	public ClienteMail(int id, String nombreCliente, String correoElectronico) {
		super();
		this.id = id;
		this.nombreCliente = nombreCliente;
		this.correoElectronico = correoElectronico;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getNombreCliente() {
		return nombreCliente;
	}

	public void setNombreCliente(String nombreCliente) {
		this.nombreCliente = nombreCliente;
	}

	public String getCorreoElectronico() {
		return correoElectronico;
	}

	public void setCorreoElectronico(String correoElectronico) {
		this.correoElectronico = correoElectronico;
	}

	@Override
	public String toString() {
		return "ClienteMail [id=" + id + ", nombreCliente=" + nombreCliente + ", correoElectronico=" + correoElectronico
				+ "]";
	}
    
}

Como ya lo tenemos todo, vamos a escribir la clase que realizara el envio, como siempre apoyandose en el paquete AMPQ de Spring, y que puede ser

package com.rf.rabbit.producers;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import com.rf.rabbit.dto.ClienteMail;


@Service
public class RabbitMqProducer {
	@Value("${rabbitmq.exchange.name}")
	private String exchange;

	@Value("${rabbitmq.routing.key}")
	private String routingKey;

	private static final Logger LOGGER = LoggerFactory.getLogger(RabbitMqProducer.class);

	private RabbitTemplate rabbitTemplate;

	public RabbitMqProducer(RabbitTemplate rabbitTemplate) {
	        this.rabbitTemplate = rabbitTemplate;
	    }

	public void sendMessage(ClienteMail cliente) {
		LOGGER.info(String.format("Enviando mensaje JSON -> %s", cliente.toString()));
		rabbitTemplate.convertAndSend(exchange, routingKey, cliente);
	}

}

Si la analizáis, veréis que recibe los valores de application.properties y desde Spring, y que con esos valores, se limita a realizar un «converterAndSend» en donde especifica el exchange al que lo envía y la routingKey

Y aquí se acabaría el trabajo, ya que tenemos el servicio que realiza el envío, solo seria necesario crear un Controller que formateara el objeto ClienteMail y lo llamara, pero, como queremos poder hacer una prueba, podemos añadir una clase mas

La clase Demo que definimos a continuación, se arranca al finalizar la configuración de Spring, por lo que la podemos utilizar para cualquier cosa que deseemos, en este caso, lanzar un mensaje, y este podría ser el código

package com.rf.rabbit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

import com.rf.rabbit.producers.RabbitMqProducer;
import com.rf.rabbit.dto.ClienteMail;


@Component
public class Demo implements CommandLineRunner { 

	@Autowired
	RabbitMqProducer rmpq;


	@Override
	public void run(String... args) throws Exception {
		System.out.println("Enviando mensaje...");
		ClienteMail cm = new ClienteMail(1,"Miguel Garcia","[email protected]");
		rmpq.sendMessage(cm);
		
	}
}

Con todo esto, ya podemos realizar el Run de la aplicación, y veréis que tras arrancar, comunica que ha enviado un mensaje

Si tenéis arrancada la aplicación de consumer en una ventana CMD como hemos descrito antes, veréis también la recepción

Y cada vez que hagáis un restart del producer, veréis un nuevo mensaje en el cliente

Hasta aqui una sencilla presentacion de RabbitMQ y de alguna de sus posibilidades, si veis interesante el tema, podeis acudir a las paginas de RabbitMq

Deja un comentario

/*Si te ha gustado el artículo
no dudes en compartirlo*/

Facebook
Twitter
LinkedIn

Uso de cookies

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información.plugin cookies

ACEPTAR
Aviso de cookies

Ver mi IP

Ver ip de mi máquina
tipo valor
Ip: 100.28.227.63
Proxy: 100.28.227.63
Remote host: ec2-100-28-227-63.compute-1.amazonaws.com
Remote port: 56444
** 100.28.227.63, 172.70.38.24