How kimchanho97/sunsuwedding_chat works
Project Type and Purpose
• It is a backend service for a real-time chat application built on Spring Boot.
• Core responsibilities:
• Handle WebSocket/STOMP connections for chat & presence.
• Publish/consume Kafka events for asynchronous processing.
• Maintain three data stores (Redis, MongoDB, RDB) for real-time metadata, message history, and structured relational data.
• Expose internal and external REST APIs for integration.
File Structure
• Top-level: Dockerfile, Gradle build, deploy scripts → containerized, CI/CD ready.
• src/main/java/com/sunsuwedding/chat:
• controller: external (REST), internal (service-to-service), websocket handlers.
• service: business logic.
• kafka: producer & consumer layers.
• redis, repository, model: data access & domain.
• config: Kafka, Redis, WebSocket, MVC, etc.
• client packages contain HTTP/REST clients (inter-server & external).
• scheduler: batch sync tasks for eventual consistency.
Key Insights from README
• Tri-store architecture: Redis for real-time, MongoDB for messages, RDB for chat room metadata.
• Event streaming pipeline: multi-stage Kafka topics for message ingestion, persistence, read-sync, room sorting.
• Unicast message delivery: using Redis to route WebSocket messages to specific server instance.
• Reliability guarantees: combined at-least-once & exactly-once via Kafka transactions and idempotent consumers.
Main Components
a. Clients: Web/Native clients connecting via STOMP/WebSocket and REST.
b. Load Balancer (L4/L7): Distributes WebSocket and HTTP connections to Chat Server instances.
c. Chat Server Cluster (Spring Boot instances):
• REST API Layer (external/internal controllers)
• WebSocket/STOMP Layer (ChatWebSocketController, PresenceWebSocketController)
• Service Layer (ChatRoomService, PresenceService, etc.)
• Kafka Producers/Consumers
• Scheduler (batch sync jobs)
d. Kafka Cluster: Topics (chat-message, chat-message-saved, read-sync, resort-batch, presence-unicast, etc.)
e. Redis Cluster:
• Presence routing (chat:presence:…)
• Metadata (chat:room:meta:…), user room lists, dirty keys, sequences
f. MongoDB Cluster: message documents (ChatMessageDocument)
g. RDB (MySQL/Postgres): chat rooms, participants, transactional metadata
h. S3 / Blob Storage (optional): for image uploads (ChatImageUploadClient)
i. Deployment Infrastructure: Docker, docker-compose, CI/CD pipeline (GitHub Actions → deploy.sh)
Relationships and Data Flows
1. Client ↔ Load Balancer ↔ Chat Server (WebSocket / REST)
2. Chat Server REST endpoints publish Kafka events (chat-message)
3. Kafka → Chat Server consumers → Redis (routing, read-sync, dirty keys) → other Chat Servers via WebSocket
4. Chat Server consumer → MongoDB (persist message) → publish chat-message-saved topic
5. Chat-message-saved consumer → update Redis metadata, schedule batch RDB sync
6. Scheduler → fetch dirty keys from Redis → batch JDBC update to RDB
Architectural Patterns
• Layered Architecture: API (controllers) → Service → Data/Event layer
• Event-Driven: Kafka topics decouple ingestion, persistence, fan-out
• Cache Aside / Write-Through with Redis
• Tri-store: real-time vs. persistent vs. relational
• Unicast Routing: Redis-based location lookup for WebSocket messages
• Batch Synchronization: eventual consistency between Redis and RDB
Diagramming Conventions
• Use rectangles for compute components (Load Balancer, Chat Servers, Scheduler)
• Blue for frontend/client/entry points
• Green for Chat Server internals
• Orange for event bus (Kafka)
• Yellow for Redis cache
• Purple for MongoDB
• Gray for RDB
Detail Without Over-Segmentation
• Major components and their interactions.