JMS (Java Message Service)

JMS (Java Message Service)

Java Message Service (JMS) is a Java API for sending and receiving messages between distributed systems, enabling loosely coupled, reliable, and asynchronous communication.

What Is JMS?
- JMS (Java Message Service) is a standard API provided by Java EE for messaging between software components in distributed applications.
- It allows asynchronous communication, meaning the sender and receiver do not need to interact with the message at the same time.
- JMS is designed to be loosely coupled, which improves scalability and flexibility in system architecture.

Core Concepts
- Message: The data being transmitted. JMS supports different message types like `TextMessage`, `ObjectMessage`, `BytesMessage`, etc.
- Producer: The component that sends messages.
- Consumer: The component that receives messages.
- Destination: The target for messages, which can be a **Queue** (point-to-point) or a **Topic** (publish-subscribe).
- ConnectionFactory: Used to create connections to the messaging system.
- Session: A single-threaded context for producing and consuming messages.

Messaging Models
Model | Description
Point-to-Point | Uses Queue. One message is delivered to one consumer.
Publish-Subscribe | Uses Topic. One message can be delivered to multiple subscribers.

Benefits of JMS
- Decouples components: Promotes modular and maintainable architecture.
- Reliable delivery: Supports persistent messaging and acknowledgment mechanisms.
- Scalable: Easily integrates with enterprise systems and cloud-native architectures.
- Transactional support: Ensures message integrity with commit/rollback capabilities.

JMS in Practice
- Commonly used with Java EE servers like GlassFish, WildFly, or Spring Boot with ActiveMQ/RabbitMQ.
- Ideal for event-driven systems, order processing, notification services, and microservices communication.



step-by-step guide to help you build a Spring Boot + JMS + ActiveMQ mini-project. 

This project will simulate a secure message producer and consumer architecture—perfect for your JWT-authenticated microservices and CI/CD simulations.

Project Overview
Goal: Build a Spring Boot app with:
- A REST API that sends messages to a JMS queue.
- A listener that consumes messages from the queue.
- ActiveMQ as the message broker.

Step-by-Step Implementation
1. Set Up the Project
- Use [Spring Initializr](https://start.spring.io/) with:
  - Spring Boot version: 3.x
  - Dependencies: Spring Web, Spring Boot Starter ActiveMQ, Spring Boot DevTools
```bash
curl https://start.spring.io/starter.zip \
  -d dependencies=web,activemq \
  -d name=jms-demo \
  -o jms-demo.zip
```
Unzip and open in your IDE.

2. Configure ActiveMQ
Add this to `application.yml` or `application.properties`:
```yaml
spring:
  activemq:
    broker-url: tcp://localhost:61616
    user: admin
    password: admin
    packages:
      trust-all: true
```

> Install ActiveMQ locally or run it via Docker:
```bash
docker run -d --name activemq -p 61616:61616 -p 8161:8161 rmohr/activemq
```

3. Create a Message DTO
```java
public class MessageDTO {
    private String to;
    private String body;
    // Getters and setters
}
```

4. Create a Producer Service
```java
@Service
public class JmsProducer {
    @Autowired
    private JmsTemplate jmsTemplate;

    public void send(MessageDTO message) {
        jmsTemplate.convertAndSend("demo.queue", message);
    }
}
```

5. Create a REST Controller
```java
@RestController
@RequestMapping("/api/messages")
public class MessageController {
    @Autowired
    private JmsProducer producer;

    @PostMapping
    public ResponseEntity<String> send(@RequestBody MessageDTO message) {
        producer.send(message);
        return ResponseEntity.ok("Message sent to queue");
    }
}
```

6. Create a Consumer Listener
```java
@Component
public class JmsConsumer {
    @JmsListener(destination = "demo.queue")
    public void receive(MessageDTO message) {
        System.out.println("Received message: " + message.getBody());
    }
}
```

7. Secure the API (Optional JWT)
Add Spring Security and configure JWT-based authentication to protect `/api/messages`.

8. Test the Flow
- Start ActiveMQ.
- Run your Spring Boot app.
- POST a message to `/api/messages` using Postman or curl.
- Watch the console for the consumed message.

Bonus Ideas
- Add retry logic and dead-letter queues.
- Integrate with Vault for secure credentials.
- Visualize message flow with a dashboard (Spring Boot + Vue.js).
- Containerize with Docker and orchestrate with Helm/Kubernetes.


Comments

Post a Comment

Popular posts from this blog

Java 25 Features

Java 25 Features Major Features in Java SE 25 1. Scoped Values (Finalized) Scoped values provide a safer alternative to thread-local variables, allowing values to be shared across threads in a controlled way. ```java import java.util.concurrent.Executors; import jdk.incubator.concurrent.ScopedValue; public class ScopedValueDemo {     static final ScopedValue<String> USER = ScopedValue.newInstance();     public static void main(String[] args) {         ScopedValue.where(USER, "Alice").run(() -> {             System.out.println("Running as user: " + USER.get());             Executors.newSingleThreadExecutor().submit(() ->                 System.out.println("Child thread user: " + USER.get())             );         });     } } ``` 2. Flexible Constructor Bodies Constructors now all...
Read more

Java Version Features

Java has evolved significantly from JDK 1.0 to Java 22, introducing powerful features like lambdas, modules, records, virtual threads, and structured concurrency. Java Version Highlights Version | Key Features Java 8 (2014) | Lambda expressions, Streams API, Optional, Default methods, Nashorn JS engine Java 9 (2017) | Module system (Project Jigsaw), JShell, Stream improvements Java 10 (2018) | Local variable type inference (`var`) Java 11 (2018) | New HTTP Client API, String methods, Flight Recorder, Removed deprecated APIs Java 12 (2019) | Switch expressions (preview), Shenandoah GC Java 13 (2019) | Text blocks (preview) Java 14 (2020) | Records (preview), Pattern matching for instanceof (preview) Java 15 (2020) | Sealed classes (preview), Hidden classes Java 16 (2021) | Records, Pattern matching, JEP 376: ZGC improvements Java 17 (2021) | Sealed classes, Pattern matching, Foreign function & memory API (preview) Java 18 (2022) | Simple web server, UTF-8 by default, Code snip...
Read more

Java 8 Programs

Java 8 Programs Program to ADD PREFIX and SUFFIX to the STRING? - StringJoiner class, used to add prefix and suffix in a given String      StringJoiner stringJoiner = new StringJoiner(",", "#", "#");      stringJoiner.add("Interview");      stringJoiner.add("Questions");      stringJoiner.add("Answers");      System.out.println(stringJoiner); Program to PRINT 10 RANDOM NUMBERs using forEach? - Use Random class to generate Random number      Random random = new Random();      random.ints().limit(10).forEach(System.out::println); Program to iterate a Stream using the forEach method?      List<String> str = Arrays.asList("Hello","Hola","Namaste","Hi");      str.stream().forEach(System.out::println); Program to find the Minimum and Maximum number of a Stream? To find minimum or maximum number in stream, use comparator.comparing() method which will take...
Read more