Quick Guide to RabbitMQ Message Broker using Spring Boot

@Configuration
public class RabbitMqDirectConfiguration {
  public final static String ADD_QUEUE_NAME = "ADD_QUEUE";
  public final static String SUBTRACT_QUEUE_NAME = "SUBTRACT_QUEUE";
  public final static String MULTIPLICATION_QUEUE_NAME = "MULTIPLICATION_QUEUE";
  public final static String DIVIDE_QUEUE_NAME = "DIVISION_QUEUE";
  public final static String MATH_EXCHANGE = "MATH_EXCHANGE";

  /**
   * This bean creates a queue with the name ADD_QUEUE_NAME
   * This queue will be used to send all the messages that are related to the addition operation
   * .nonDurable property is set to true, so the queue will not survive a broker restart
   * .autoDelete property is set to true, so the queue will be deleted when
   * there are no more consumers subscribed to it
   * Below additional properties are set to true because we want to
   * create a temporary queue for guide purposes
   */
  @Bean
  Queue queueAdd() {
    return QueueBuilder.nonDurable(ADD_QUEUE_NAME)
      .autoDelete()
      .build();
  }

  /**
   * This bean creates a queue with the name SUBTRACT_QUEUE_NAME
   * This queue will be used to send all the messages that are related to the subtraction operation
   * Like above additional properties are set to create temporary queues
   */
  @Bean
  Queue queueSubtract() {
    return QueueBuilder.nonDurable(SUBTRACT_QUEUE_NAME)
      .autoDelete()
      .build();
  }

  /**
   * This bean creates  a queue with the name MULTIPLICATION_QUEUE_NAME
   * At this queue will be sent all the messages that are related to the multiplication operation
   * Like above additional properties are set to create temporary queues
   */
  @Bean
  Queue queueMultiplication() {
    return QueueBuilder.nonDurable(MULTIPLICATION_QUEUE_NAME)
      .autoDelete()
      .build();
  }

  /**
   * This bean creates  a queue with the name DIVIDE_QUEUE_NAME
   * At this queue will be sent all the messages that are related to the division operation
   * Like above additional properties are set to create temporary queues
   * =
   */
  @Bean
  Queue queueDivide() {
    return QueueBuilder.nonDurable(DIVIDE_QUEUE_NAME)
      .autoDelete()
      .build();
  }

  /**
   * This bean creates  a direct exchange with the name MATH_EXCHANGE
   * This exchange will be used to route messages to the queues
   * autoDelete property is set to true, so the exchange will be deleted when
   * there are no more queues bound to it
   */
  @Bean
  DirectExchange directMathExchange() {
    return ExchangeBuilder.directExchange(MATH_EXCHANGE)
      .autoDelete()
      .build();
  }

  /**
   * This bean creates  a binding between the ADD_QUEUE_NAME queue and the MATH_EXCHANGE exchange
   * The routing key is the same as the queue name
   */
  @Bean
  Binding bindAddQueueToExchange() {
    return BindingBuilder
      .bind(queueAdd())
      .to(directMathExchange())
      .withQueueName();
  }

  /**
   * This bean creates  a binding between the SUBTRACT_QUEUE_NAME queue and the MATH_EXCHANGE exchange
   * The routing key is the same as the queue name
   */
  @Bean
  Binding bindSubtractQueueToExchange() {
    return BindingBuilder
      .bind(queueSubtract())
      .to(directMathExchange())
      .withQueueName();
  }

  /**
   * This bean creates  a binding between the MULTIPLICATION_QUEUE_NAME queue and the MATH_EXCHANGE exchange
   * The routing key is the same as the queue name
   */
  @Bean
  Binding bindMultiplicationQueueToExchange() {
    return BindingBuilder
      .bind(queueMultiplication())
      .to(directMathExchange())
      .withQueueName();
  }

  /**
   * This bean creates  a binding between the DIVIDE_QUEUE_NAME queue and the MATH_EXCHANGE exchange
   * The routing key is the same as the queue name
   */
  @Bean
  Binding bindDivideQueueToExchange() {
    return BindingBuilder
      .bind(queueDivide())
      .to(directMathExchange())
      .withQueueName();
  }
}

public class RandomNumberPair {

  private static final Random random = new Random();
  private final UUID id;
  private final long x;
  private final long y;

  public RandomNumberPair() {
    id = UUID.randomUUID();
    this.x = random.nextInt(100) + 1;
    this.y = random.nextInt(100) + 1;
  }

  @Override
  public String toString() {
    return "Random Pair number with ID: " + id + " and values X: " + x + ", Y: " + y;
  }

  /** GETTERS */
}

@Service
public class DirectService {


  private final Scanner scanner;
  private RabbitTemplate rabbitTemplate;

  public DirectService(RabbitTemplate rabbitTemplate) {
    scanner = new Scanner(System.in);
    this.rabbitTemplate = rabbitTemplate;
  }

  /**
   * This method is used to send the pair of random numbers to the RabbitMq.
   * The method will ask the user to enter a number between 1 and 4.
   * If the user enters number betwen 1-4, the program will send the pair of
   * random numbers to the specific queue.
   * If the user enters Q, the program will be terminated.
   * The method start after the Spring application is ready.
   */
  @EventListener(ApplicationReadyEvent.class)
  public void runLogic() {
    System.out.println("Direct Service is running...");
    while (true) {
      System.out.println("Please enter a number between 1 and 4" +
        "to select the operation you want to perform on random numbers: \n" +
        "1-Add, 2-Subtract, 3-Multiply, 4-Divide, Q-Quit");
      String userInput = scanner.nextLine();
      switch (userInput.toUpperCase()) {
        case "1":
          sendToAdd(new RandomNumberPair());
          break;
        case "2":
          sendToSubtract(new RandomNumberPair());
          break;
        case "3":
          sendToMultiplication(new RandomNumberPair());
          break;
        case "4":
          sendToDivide(new RandomNumberPair());
          break;
        case "Q":
          System.out.println("Goodbye! The application is terminated");
          System.exit(0);
        default:
          System.out.println("Invalid input. Please enter a number between 1 and 4.");
          break;
      }
    }
  }

  /**
   * The following method is used to send a pair of random numbers to RabbitMq to perform the add calculation
   * RandomNumberPair is a pair of random numbers which is randomly generated in the class constructor
   * PairNumber is mapped to Json format using JsonParser class
   * The message is sent to RabbitMq using the RabbitTemplate
   * The first parameter is the exchange name, which is the name of the exchange that will handle message
   * If exchange name is empty, the message will be sent to the default exchange
   * The second parameter is the routing key, by this key the message will be routed to the specific queue
   * If the routing key doesn't match any queue, the message will be discarded
   * The third parameter is the new RabbitMq message which have some metadata and the body of the message
   * The Body of the message is the pair of random numbers in Json format transformed to bytes
   */
  public void sendToAdd(RandomNumberPair pairNumbers) {
    System.out.println(String.format("%s is sent to Calculator Service with routing key: %s to add values.",
                       pairNumbers.toString(),
                       RabbitMqDirectConfiguration.ADD_QUEUE_NAME));

    String pairNumberJson = JsonParser.mapToJson(pairNumbers);

    rabbitTemplate.send(RabbitMqDirectConfiguration.MATH_EXCHANGE,
                        RabbitMqDirectConfiguration.ADD_QUEUE_NAME,
                        new Message(pairNumberJson.getBytes()));
  }

  /**
   * The following method is used to send a pair of random numbers
   * to RabbitMq to perform the substract calculation
   * Parameters logic is the same as the previous method
   */
  public void sendToSubtract(RandomNumberPair pairNumbers) {
    System.out.println(String.format("%s is sent to Calculator Service with routing key: %s to subtract values",
                       pairNumbers.toString(),
                       RabbitMqDirectConfiguration.SUBTRACT_QUEUE_NAME));

    String pairNumberJson = JsonParser.mapToJson(pairNumbers);

    rabbitTemplate.send(RabbitMqDirectConfiguration.MATH_EXCHANGE,
                        RabbitMqDirectConfiguration.SUBTRACT_QUEUE_NAME,
                        new Message(pairNumberJson.getBytes()));
  }

  /**
   * The following method is used to send a pair of random numbers
   * to RabbitMq to perform the divide calculation
   * Parameters logic is the same as at the previous method
   */
  public void sendToDivide(RandomNumberPair pairNumbers) {
    System.out.println(String.format("%s is sent to Calculator Service with routing key: %s to divide values.",
                      pairNumbers.toString(),
                      RabbitMqDirectConfiguration.DIVIDE_QUEUE_NAME));

    String pairNumberJson = JsonParser.mapToJson(pairNumbers);

    rabbitTemplate.send(RabbitMqDirectConfiguration.MATH_EXCHANGE,
                        RabbitMqDirectConfiguration.DIVIDE_QUEUE_NAME,
                        new Message(pairNumberJson.getBytes()));
  }

  /**
   * The following method is used to send a pair of random numbers
   * to RabbitMq to perform the multiplicative calculation
   * Parameters logic is the same as at the previous method
   */
  public void sendToMultiplication(RandomNumberPair pairNumbers) {
    System.out.println(String.format("%s is sent to Calculator Service with routing key: %s to multiply values.",
                      pairNumbers.toString(),
                      RabbitMqDirectConfiguration.MULTIPLICATION_QUEUE_NAME));

    String pairNumberJson = JsonParser.mapToJson(pairNumbers);

    rabbitTemplate.send(RabbitMqDirectConfiguration.MATH_EXCHANGE,
                        RabbitMqDirectConfiguration.MULTIPLICATION_QUEUE_NAME,
                        new Message(pairNumberJson.getBytes()));
  }
}

@Service
class RabbitMqListener {

    private final Calculator calculator;

    public RabbitMqListener(Calculator calculator) {
        this.calculator = calculator;
    }

    @RabbitListener(queues = "ADD_QUEUE")
    public void listenerForNumbersToAdd(Message message) {
      RandomNumberPair pair = JsonParser.mapToObject(new String(message.getBody()), RandomNumberPair.class);
      System.out.println(pair + " provided to Calculator!");
        calculator.add(pair);
    }

    @RabbitListener(queues = "SUBTRACT_QUEUE")
    public void listenerForNumbersToSubtract(Message message) {
        RandomNumberPair pair = JsonParser.mapToObject(new String(message.getBody()), RandomNumberPair.class);
        System.out.println(pair + " provided to Calculator!");
        calculator.subtract(pair);
    }

    @RabbitListener(queues = "DIVISION_QUEUE")
    public void listenerForNumbersToDivision(Message message) {
        RandomNumberPair pair = JsonParser.mapToObject(new String(message.getBody()), RandomNumberPair.class);
        System.out.println(pair + " provided to Calculator!");
        calculator.divide(pair);
    }

    @RabbitListener(queues = "MULTIPLICATION_QUEUE")
    public void listenerForNumbersToMultiplication(Message message) {
        RandomNumberPair pair = JsonParser.mapToObject(new String(message.getBody()), RandomNumberPair.class);
        System.out.println(pair + " provided to Calculator!");
        calculator.multiplication(pair);
    }
}

@Service
class Calculator {

    void add(final RandomNumberPair pair) {
        System.out.println(pair + " after add = " +
                           Math.addExact(pair.getX(), pair.getY()));
    }

    void subtract(final RandomNumberPair pair) {
        System.out.println(pair + " after subtract = " +
                           Math.subtractExact(pair.getX(), pair.getY()));
    }

    void divide(final RandomNumberPair pair) {
        DecimalFormat decimalFormat = new DecimalFormat("#.00");
        System.out.println(pair + " after divide = " +
                           decimalFormat.format((double) pair.getX() / pair.getY()));
    }

    void multiplication(final RandomNumberPair pair) {
        System.out.println(pair + " after multiplication = " +
                           Math.multiplyExact(pair.getX(), pair.getY()));
    }
}