Production Spring Boot Architecture

Fri, 21 Aug 2026 00:00:00 +0000

Whiteboard note: the goal is not to memorize boxes, but to connect each arrow to a request, a contract, and an operational signal.

Start with a real scenario

Use this situation as the mental model: A flash-sale service protects the database with cache, bounded writes, idempotency, and asynchronous inventory events.. A useful backend diagram answers four questions: where does input enter, who owns state, which boundary can fail, and how do we know the system is healthy? The flow is Gateway → Service → Cache / DB / MQ → Observability.

Deconstructing the architecture

Contract: define input, output, and error shape before adding implementation detail.
Mechanism: Nginx / Gateway → auth + rate limit; Service → idempotency + transaction. This is the part that determines latency, throughput, and testability.
State and resources: Redis → cache-aside with TTL; MySQL → source of truth. Explain creation, ownership, cleanup, and recovery.
Failure path: RocketMQ → async side effects; combine it with Metrics + Logs + Traces → feedback loop when choosing a fallback, retry, or rollback.

A small implementation boundary

The following sketch is intentionally small. It shows where a production implementation should place validation and ownership rather than pretending that a happy path is enough.

request → bounded resource → validated boundary → observable result

Keep external systems behind an adapter, repository, client, or gateway. The domain layer should depend on a stable contract so tests can use fakes and incidents can be isolated to one boundary.

Engineering decisions for the scenario

Protect dependencies first. Pools, queues, semaphores, caches, and worker counts need explicit limits. An unbounded queue only hides overload.
Preserve correctness. Use an idempotency key, transaction boundary, lock, version check, or schema validation where retries or concurrency can duplicate work.
Optimize with evidence. Use traces, slow-query data, GC pauses, queue depth, or p99 latency before choosing a cache, index, batch size, or concurrency setting.
Make recovery testable. Timeout, retry, rate limit, circuit breaking, rollback, and alerting should be exercised in a drill.

Common mistakes

Drawing only the happy path while omitting timeout, empty data, rejection, rollback, or replica lag.
Treating framework defaults as business contracts and discovering their limits after an upgrade.
Scaling machines before measuring pool exhaustion, lock contention, slow SQL, allocation, or event-loop blocking.
Treating logs as the only observability tool; metrics, traces, sampling, and redaction are also required.

Production checklist

Input, output, and error responses have explicit schemas
Dependencies have timeout, retry budgets, rate limits, and fallback behavior
Pools and queues expose capacity, waiting, and rejected-work metrics
Important state has idempotency, transaction, or recovery semantics
Logs, metrics, and traces share a request or correlation ID
Regression tests, load tests, and failure drills use production-like data

Summary

You understand this whiteboard when you can start from one request, explain every arrow’s contract, state how each risk is handled, and name the signal that would tell you to change the design.

Distributed Micro Cloud Mall

Fri, 15 May 2026 00:00:00 +0000

Microservice E-commerce Platform - SpringCloud Alibaba Stack (Nacos/Gateway/Sentinel) + MyBatis-Plus + Feign Remote Calls.

Project Overview

Complete practice from monolithic to microservice architecture, covering enterprise middleware integration and distributed solutions. The project benchmarks against mid-senior Java backend engineer core competency models.

Professional GOAL (Position Capability Benchmarking)

Level	Capability Domain	Coverage Modules	Weight
🥇 Distributed Architecture	Microservice splitting, service governance, distributed transactions, message queues	mall-order-service, mall-seckill-service, Middleware	35%
🥈 Middleware Depth	Redis cache, ES search, RocketMQ messaging, Seata transactions, Sentinel rate limiting	docs/Middleware/ (11 middlewares)	30%
🥉 Business Implementation	Product/User/Cart/Order CRUD, JWT auth, AOP logging	mall-product-service, mall-user-service, mall-cart-service	25%
🏅 Engineering	Docker containerization, Gateway, Nacos config center, CI deployment	mall-gateway, docs/docker/	10%

Technical Architecture

┌──────────┐ ┌──────────┐ ┌──────────┐
│ Client │ │ Client │ │ Client │
└────┬─────┘ └────┬─────┘ └────┬─────┘
 └──────────────┴──────────────┘
 │
 ┌──────┴──────┐
 │ Spring Cloud │
 │ Gateway │ ← Unified Auth + Routing + Rate Limiting
 └──────┬──────┘
 │
 ┌──────────┼──────────┐
 │ │ │
┌────┴────┐ ┌──┴───┐ ┌───┴────┐
│ Services │ │Middle│ │Infra │
│ User │ │Redis │ │Nacos │
│ Product │ │MySQL │ │Sentinel│
│ Order │ │Mongo │ │Seata │
│ Cart │ │ES │ │XXL-Job │
│ Pay │ │MQ │ │ │
│ Seckill │ │Canal │ │ │
└─────────┘ └──────┘ └─────────┘

Project Structure

mall-micro-cloud/
├── mall-api/ # Feign Interface Layer
├── mall-common/ # Common Utilities
├── mall-gateway/ # Spring Cloud Gateway
├── mall-services/
│ ├── mall-user-service/ # User Service (JWT + BCrypt)
│ ├── mall-product-service/ # Product Service (MyBatis-Plus)
│ ├── mall-cart-service/ # Cart Service (Redis Cache)
│ ├── mall-order-service/ # Order Service (Seata Distributed Tx)
│ ├── mall-pay-service/ # Payment Service (RocketMQ Tx Messages)
│ ├── mall-seckill-service/ # Seckill Service (High Concurrency)
│ ├── mall-es-service/ # Search Service (Elasticsearch)
│ ├── mall-oss-service/ # Object Storage Service
│ ├── mall-scheduler-service/ # Scheduler Service (XXL-Job)
│ ├── mall-consumer-service/ # Message Consumer Service
│ └── mall-test-service/ # Test Service
├── docs/
│ ├── Middleware/ # 11 Middleware Tutorials
│ ├── interview/ # Interview Questions (9 chapters)
│ ├── db-sql/ # Business SQL
│ └── docker/ # Docker Deployment Guide
└── pom.xml # Maven Parent POM

Technical Highlights

1. Distributed Architecture

Microservice Splitting: Independent services by business domain
Service Governance: Nacos discovery + Gateway routing
Distributed Transactions: Seata AT mode for cross-service consistency

2. Deep Middleware Integration

Redis: Cache + Distributed Lock + Session Management
Elasticsearch: Full-text Search + IK Analyzer
RocketMQ: Async Messaging + Transaction Messages
Sentinel: Rate Limiting + Circuit Breaking

3. High-Concurrency Seckill

Redis pre-deduction + Redisson reentrant lock
RocketMQ async persistence prevents overselling
Sentinel rate limiting protects system stability

4. Engineering Practices

Docker containerization
Gateway unified authentication
Nacos configuration center

Project Results

Architecture: 11 microservices designed and governed
Middleware: 11 enterprise middlewares integrated
Performance: 10k+ concurrent stress testing passed
Documentation: Complete middleware tutorials and interview questions

Project Status: ✅ Completed
GitHub:

Microservices | 1byteone - Java Backend / AI Application Developer