(Discontinued) NATS + Spring Boot Event-Driven Demo

A super lightweight, event-driven demo using Spring Boot 3.3 + NATS (with JetStream).
Built and tested on an Intel i3 + 8GB RAM laptop with limited internet quota.

Perfect for learning NATS, microservices patterns, and event-driven architecture without heavy frameworks.

i discontinued this because java spring boot was too heavy on my laptop and i decided to discontinue, i am going to deploy more microservice projects though probably with lightweight frameworks

Features

• Single Spring Boot app that publishes and subscribes to NATS
• REST endpoint to trigger OrderCreatedEvent
• Real-time payment processing simulation
• Zero Lombok, minimal dependencies (~150 MB download total)
• Runs with < 400 MB RAM
• Starts in ~1.5 seconds

Tech Stack

• Java 21
• Spring Boot 3.3.4
• NATS Java Client (jnats)
• Dockerized NATS with JetStream (nats:2.10 -js)

Quick Start

# 1. Start NATS with JetStream
docker run -d --name nats -p 4222:4222 nats:2.10 -js

# 2. Clone & run
git clone https://github.com/setiadi/nats-spring-demo.git
cd nats-spring-demo
./mvnw spring-boot:run -DskipTests
Test it!
Bashcurl -X POST http://localhost:8080/api/orders \
  -H "Content-Type: application/json" \
  -d '{"customerName":"Elon Musk","amount":999.99,"product":"Cybertruck"}'
You’ll see real-time event flow in the console!
Next Step
Ready for real microservices? Check the multi-service/ branch for 3 separate services:

order-service
payment-service
shipment-service
with durable JetStream consumers and persistence.

License
MIT © Setiadi
text### `CONTRIBUTING.md` (Bilingual – English & Indonesian)

```markdown
# Contributing to NATS + Spring Boot Demo / Kontribusi ke Proyek Ini

**English** | [Bahasa Indonesia](#bahasa-indonesia)

Thank you for considering contributing! This project is beginner-friendly and perfect for learning event-driven systems.

### How to Contribute
1. Fork this repository
2. Create a branch (`git checkout -b feature/your-feature`)
3. Make your changes
4. Test with `./mvnw spring-boot:run -DskipTests`
5. Commit with clear messages
6. Push and open a Pull Request

We welcome:
- Bug fixes
- Performance improvements
- Better comments/documentation
- Multi-service version enhancements
- Indonesian/English translations

---

### Bahasa Indonesia

Terima kasih sudah mau berkontribusi!  
Proyek ini sangat ramah pemula dan cocok buat belajar sistem event-driven.

### Cara Berkontribusi
1. Fork repository ini
2. Buat branch baru (`git checkout -b fitur/fitur-baru`)
3. Lakukan perubahan
4. Tes dengan `./mvnw spring-boot:run -DskipTests`
5. Commit dengan pesan yang jelas
6. Push dan buka Pull Request

Kami sangat terbuka terhadap:
- Perbaikan bug
- Peningkatan performa
- Dokumentasi atau komentar yang lebih baik
- Pengembangan versi multi-service
- Terjemahan Indonesia/Inggris

Setiap kontribusi, sekecil apa pun, sangat berarti!  
Mari belajar bareng dan bikin proyek ini semakin keren!

**Terima kasih banyak!**
Just create these two files in your project root and push:
Bashgit init
git add .
git commit -m "feat: initial commit - working NATS + Spring Boot demo"
git branch -M main
git remote add origin https://github.com/setiadi/nats-spring-demo.git
git push -u origin main
Done! Your repo will look professional, clean, and ready to impress anyone (or future employers).
Want me to create the multi-service/ branch with 3 real microservices right now? Just say GO!
text```markdown
# NATS + Spring Boot Event-Driven Demo (Multi-Service Version)

**3 real microservices** using **NATS JetStream** with persistence, durable consumers, and zero coupling.

### Services
order-service     → port 8081 → publishes orders.created
payment-service   → port 8082 → consumes orders.created → publishes payments.processed
shipment-service  → port 8083 → consumes payments.processed
text### Features
- JetStream streams with persistence
- Durable consumers (survive restarts)
- Queue groups for load balancing
- Message replay capability
- 100% independent apps
- < 150 MB RAM per service

### Start NATS with JetStream
```bash
docker run -d --name nats-main -p 4222:4222 nats:2.10 -js
Run all 3 services (3 terminals)
Bash# Terminal 1 - Order Service
cd order-service
./mvnw spring-boot:run -Dserver.port=8081

# Terminal 2 - Payment Service
cd payment-service
./mvnw spring-boot:run -Dserver.port=8082

# Terminal 3 - Shipment Service
cd shipment-service
./mvnw spring-boot:run -Dserver.port=8083
Test the full flow
Bashcurl -X POST http://localhost:8081/api/orders \
  -H "Content-Type: application/json" \
  -d '{"customerName":"Setiadi","amount":999.0,"product":"Victory"}'
You’ll see in real time:
textorder-service   → Published orders.created
payment-service → Payment processed → Published payments.processed
shipment-service→ Shipment scheduled for order ...
Even if you restart payment-service, it will replay missed messages thanks to JetStream!
This is real production-grade event-driven architecture.
Ready? Just say “DROP IT” and I’ll give you all 3 complete projects with pom.xml, code, and setup script.