Stateful vs Stateless Design

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

// ========== STATEFUL: Counter ==========
// Behavior depends on internal state
 
public class Counter {
    private int count = 0;  // Internal state
    
    public int increment() {
        return ++count;  // Result depends on previous state
    }
    
    public int getCount() {
        return count;  // Exposes current state
    }
}
 
// Each call to increment() returns a DIFFERENT result
Counter c = new Counter();
c.increment();  // Returns 1
c.increment();  // Returns 2 (different result, same method!)
c.increment();  // Returns 3
 
 
// ========== STATELESS: Calculator ==========
// Behavior depends only on inputs
 
public class Calculator {
    // No instance fields (no state)
    
    public int add(int a, int b) {
        return a + b;  // Result depends ONLY on inputs
    }
    
    public double sqrt(double x) {
        return Math.sqrt(x);  // Pure function of input
    }
}
 
// Same inputs ALWAYS produce same outputs
Calculator calc = new Calculator();
calc.add(2, 3);  // Returns 5
calc.add(2, 3);  // Returns 5 (identical call, identical result)
calc.add(2, 3);  // Returns 5 (always!)
 
// Different Calculator instances are interchangeable
Calculator calc2 = new Calculator();
calc2.add(2, 3);  // Also returns 5 (instance doesn't matter)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

// ========== STATELESS: Scales horizontally ==========
 
@RestController
public class PricingController {
    // No instance state - any instance handles any request
    
    @Autowired
    private PricingService pricingService;  // Also stateless
    
    @GetMapping("/price")
    public BigDecimal calculatePrice(
        @RequestParam String productId,
        @RequestParam int quantity,
        @RequestParam String couponCode  // All info in request
    ) {
        // Pure computation from inputs
        return pricingService.calculate(productId, quantity, couponCode);
    }
    
    // With 10 instances behind a load balancer:
    // - Request 1 → Instance 3 → correct result
    // - Request 2 → Instance 7 → correct result (same inputs = same output)
    // - Instance 5 crashes → no data lost, other instances handle traffic
}
 
 
// ========== STATEFUL: Scaling challenges ==========
 
@RestController  
@SessionScope  // Creates instance per session
public class ShoppingCartController {
    // Instance holds user-specific state
    private List<CartItem> items = new ArrayList<>();
    private BigDecimal total = BigDecimal.ZERO;
    
    @PostMapping("/cart/add")
    public void addItem(@RequestBody CartItem item) {
        items.add(item);
        total = total.add(item.getPrice());
    }
    
    @GetMapping("/cart")
    public CartResponse getCart() {
        return new CartResponse(items, total);
    }
    
    // With 10 instances:
    // - Request 1 (add item) → Instance 3 → items=[item1]
    // - Request 2 (get cart) → Instance 7 → items=[] WRONG! (state in Instance 3)
    // - Instance 3 crashes → cart data LOST
    
    // Solution: sticky sessions (limits scaling) or external state store
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

// ========== PATTERN 1: PASSING STATE AS PARAMETERS ==========
// Push state to client, receive it back with each request
 
public class OrderProcessor {
    // No instance state
    
    public OrderResult process(Order order, ProcessingContext context) {
        // All information needed is in parameters
        // context contains: user info, preferences, permissions, etc.
        
        BigDecimal total = calculateTotal(order, context.getTaxRate());
        boolean canShip = checkInventory(order, context.getWarehouse());
        
        return new OrderResult(total, canShip);
    }
    
    // Pure function: same order + context always yields same result
}
 
 
// ========== PATTERN 2: EXTERNALIZED STATE (DATABASE/CACHE) ==========
// State lives outside the service, fetched on demand
 
@Service
public class ShoppingCartService {
    @Autowired
    private CartRepository cartRepository;  // External state store
    
    public Cart getCart(String userId) {
        return cartRepository.findByUserId(userId);
    }
    
    public Cart addItem(String userId, CartItem item) {
        Cart cart = cartRepository.findByUserId(userId);
        cart.addItem(item);
        return cartRepository.save(cart);  // Persisted externally
    }
    
    // Service is stateless: any instance can handle any user
    // State is in the database, not in service instances
}
 
 
// ========== PATTERN 3: TOKEN-BASED IDENTITY ==========
// Client carries identity proof, server verifies without state
 
@RestController
public class ApiController {
    @Autowired
    private JwtValidator jwtValidator;  // Stateless validation
    
    @GetMapping("/protected")
    public Response protectedEndpoint(@RequestHeader("Authorization") String token) {
        // Validate JWT without storing sessions
        Claims claims = jwtValidator.validate(token);  // Pure operation
        
        String userId = claims.getSubject();
        List<String> roles = claims.get("roles", List.class);
        
        // All user context comes from the token
        // No server-side session storage needed
        return buildResponse(userId, roles);
    }
    
    // Server keeps no per-user state
    // Scales infinitely: any server can validate any token
}
 
 
// ========== PATTERN 4: FUNCTIONAL STATELESS OBJECTS ==========
// Objects with no fields, only pure methods
 
public final class EmailValidator {
    // No fields at all
    
    public boolean isValid(String email) {
        return email != null 
            && email.contains("@")
            && email.length() <= 254
            && EMAIL_PATTERN.matcher(email).matches();
    }
    
    // Can be singleton: no reason to have multiple instances
    public static final EmailValidator INSTANCE = new EmailValidator();
}
 
 
// ========== PATTERN 5: IMMUTABLE REQUEST/RESPONSE ==========
// All state travels with the message
 
public record PriceRequest(
    String productId,
    int quantity,
    String currency,
    String customerTier,
    List<String> appliedCoupons,
    Instant requestTime
) {
    // Everything needed to compute price is in this record
    // No hidden context; completely self-describing
}
 
public record PriceResponse(
    BigDecimal basePrice,
    BigDecimal discount,
    BigDecimal tax,
    BigDecimal finalPrice,
    List<String> appliedCoupons
) {
    // Complete response; no need to query service for more info
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

// ========== PATTERN 1: STATE OBJECT ==========
// Encapsulate related state in a dedicated class
 
public class ConversationState {
    private final String conversationId;
    private final String userId;
    private List<Message> messages;
    private ConversationStatus status;
    private Instant startedAt;
    private Instant lastActiveAt;
    
    public void addMessage(Message message) {
        messages.add(message);
        lastActiveAt = Instant.now();
    }
    
    public void close() {
        this.status = ConversationStatus.CLOSED;
    }
    
    // Clear lifecycle, well-defined transitions
}
 
 
// ========== PATTERN 2: STATE PROVIDER/MANAGER ==========
// Centralized state management with clear access patterns
 
@Service
public class SessionManager {
    private final Map<String, UserSession> sessions = new ConcurrentHashMap<>();
    private final ScheduledExecutorService cleaner = Executors.newScheduledThreadPool(1);
    
    public SessionManager() {
        // Automatic cleanup of expired sessions
        cleaner.scheduleAtFixedRate(this::cleanExpiredSessions, 1, 1, TimeUnit.MINUTES);
    }
    
    public UserSession createSession(User user) {
        UserSession session = new UserSession(user, Duration.ofHours(24));
        sessions.put(session.getId(), session);
        return session;
    }
    
    public Optional<UserSession> getSession(String sessionId) {
        UserSession session = sessions.get(sessionId);
        if (session != null && !session.isExpired()) {
            session.touch();  // Update last access time
            return Optional.of(session);
        }
        return Optional.empty();
    }
    
    public void invalidateSession(String sessionId) {
        sessions.remove(sessionId);
    }
    
    private void cleanExpiredSessions() {
        sessions.entrySet().removeIf(e -> e.getValue().isExpired());
    }
}
 
 
// ========== PATTERN 3: BUILDER WITH ACCUMULATED STATE ==========
// State accumulates during construction, then frozen
 
public class QueryBuilder {
    private String table;
    private List<String> columns = new ArrayList<>();
    private List<String> conditions = new ArrayList<>();
    private List<String> orderBy = new ArrayList<>();
    private Integer limit;
    
    public QueryBuilder from(String table) {
        this.table = table;
        return this;
    }
    
    public QueryBuilder select(String... cols) {
        columns.addAll(Arrays.asList(cols));
        return this;
    }
    
    public QueryBuilder where(String condition) {
        conditions.add(condition);
        return this;
    }
    
    public QueryBuilder orderBy(String column) {
        orderBy.add(column);
        return this;
    }
    
    public QueryBuilder limit(int limit) {
        this.limit = limit;
        return this;
    }
    
    public String build() {
        // Accumulated state used to construct final result
        StringBuilder sql = new StringBuilder("SELECT ");
        sql.append(columns.isEmpty() ? "*" : String.join(", ", columns));
        sql.append(" FROM ").append(table);
        if (!conditions.isEmpty()) {
            sql.append(" WHERE ").append(String.join(" AND ", conditions));
        }
        if (!orderBy.isEmpty()) {
            sql.append(" ORDER BY ").append(String.join(", ", orderBy));
        }
        if (limit != null) {
            sql.append(" LIMIT ").append(limit);
        }
        return sql.toString();
    }
}
 
 
// ========== PATTERN 4: OBSERVABLE STATE ==========
// State changes notify observers
 
public class ObservableInventory {
    private final Map<String, Integer> stock = new ConcurrentHashMap<>();
    private final List<InventoryObserver> observers = new CopyOnWriteArrayList<>();
    
    public void addObserver(InventoryObserver observer) {
        observers.add(observer);
    }
    
    public void updateStock(String productId, int newQuantity) {
        int oldQuantity = stock.getOrDefault(productId, 0);
        stock.put(productId, newQuantity);
        
        // Notify observers of state change
        StockUpdate update = new StockUpdate(productId, oldQuantity, newQuantity);
        observers.forEach(o -> o.onStockUpdate(update));
        
        if (newQuantity == 0 && oldQuantity > 0) {
            observers.forEach(o -> o.onOutOfStock(productId));
        }
    }
    
    public int getStock(String productId) {
        return stock.getOrDefault(productId, 0);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

/**
 * Hybrid Architecture Example: E-Commerce System
 * 
 * Layer 1 (Stateless): API Gateway / Controllers
 *   - Handles HTTP requests
 *   - Validates tokens
 *   - Routes to services
 *   - Any instance handles any request
 * 
 * Layer 2 (Stateless): Business Logic Services
 *   - Pure domain logic
 *   - No instance state
 *   - All state passed as parameters or fetched from stores
 * 
 * Layer 3 (Stateful): State Stores
 *   - Redis for sessions/carts
 *   - PostgreSQL for persistent data
 *   - Kafka for event streams
 */
 
// API Layer: Completely stateless
@RestController
public class OrderController {
    @Autowired private OrderService orderService;  // Stateless
    @Autowired private SessionStore sessionStore;  // External state store
    
    @PostMapping("/orders")
    public Order createOrder(@RequestBody CreateOrderRequest request,
                             @RequestHeader("Authorization") String token) {
        // Step 1: Stateless validation
        String userId = jwtValidator.extractUserId(token);
        
        // Step 2: Fetch state from external store
        Cart cart = sessionStore.getCart(userId);
        UserProfile user = userRepository.findById(userId);
        
        // Step 3: Stateless business logic
        Order order = orderService.createOrder(cart, user, request);
        
        // Step 4: Persist state to external store
        orderRepository.save(order);
        sessionStore.clearCart(userId);
        
        return order;
    }
}
 
// Business Logic: Stateless services
@Service
public class OrderService {
    // No instance fields
    
    @Autowired private InventoryChecker inventoryChecker;  // Stateless
    @Autowired private PricingEngine pricingEngine;        // Stateless
    @Autowired private TaxCalculator taxCalculator;        // Stateless
    
    public Order createOrder(Cart cart, UserProfile user, CreateOrderRequest request) {
        // Pure business logic: all inputs provided
        inventoryChecker.validateAvailability(cart);
        
        BigDecimal subtotal = pricingEngine.calculate(cart, user.getTier());
        BigDecimal tax = taxCalculator.calculate(subtotal, user.getAddress());
        BigDecimal total = subtotal.add(tax);
        
        return Order.builder()
            .userId(user.getId())
            .items(cart.getItems())
            .subtotal(subtotal)
            .tax(tax)
            .total(total)
            .shippingAddress(request.getShippingAddress())
            .build();
    }
    
    // Testable in isolation: provide inputs, verify output
}
 
// State Stores: Externalized stateful components
@Component
public class SessionStore {
    @Autowired private RedisTemplate<String, Object> redis;
    
    public Cart getCart(String userId) {
        return (Cart) redis.opsForValue().get("cart:" + userId);
    }
    
    public void saveCart(String userId, Cart cart) {
        redis.opsForValue().set("cart:" + userId, cart, Duration.ofHours(24));
    }
    
    public void clearCart(String userId) {
        redis.delete("cart:" + userId);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

// ========== TESTING STATELESS COMPONENTS ==========
// Pure input/output: straightforward
 
class PricingEngineTest {
    
    private final PricingEngine engine = new PricingEngine();
    
    @Test
    void shouldCalculateBasicPrice() {
        // Given: inputs
        var cart = Cart.of(
            new CartItem("PROD-1", 2, new BigDecimal("10.00")),
            new CartItem("PROD-2", 1, new BigDecimal("25.00"))
        );
        
        // When: pure computation
        BigDecimal result = engine.calculate(cart, CustomerTier.STANDARD);
        
        // Then: verify output
        assertEquals(new BigDecimal("45.00"), result);
    }
    
    @ParameterizedTest
    @CsvSource({
        "STANDARD, 45.00",
        "SILVER, 42.75",    // 5% discount
        "GOLD, 40.50",      // 10% discount
        "PLATINUM, 36.00"   // 20% discount
    })
    void shouldApplyTierDiscounts(CustomerTier tier, String expectedPrice) {
        var cart = Cart.of(new CartItem("PROD-1", 1, new BigDecimal("45.00")));
        
        BigDecimal result = engine.calculate(cart, tier);
        
        assertEquals(new BigDecimal(expectedPrice), result);
    }
    
    // No setup, no teardown, no mocks, no state to manage
    // Tests are independent and can run in any order
}
 
 
// ========== TESTING STATEFUL COMPONENTS ==========
// Requires careful lifecycle management
 
class ShoppingCartTest {
    
    private ShoppingCart cart;
    
    @BeforeEach
    void setUp() {
        // Must establish initial state
        cart = new ShoppingCart();
    }
    
    @Test
    void shouldTrackItemsAcrossMultipleAdds() {
        // Stateful: each add affects the next
        cart.addItem(new Product("A", new BigDecimal("10")), 1);
        cart.addItem(new Product("B", new BigDecimal("20")), 2);
        
        assertEquals(3, cart.getItemCount());
        assertEquals(new BigDecimal("50"), cart.getTotal());
    }
    
    @Test
    void shouldRemoveItemsCorrectly() {
        // Must set up state first
        cart.addItem(new Product("A", new BigDecimal("10")), 2);
        cart.addItem(new Product("B", new BigDecimal("20")), 1);
        
        // Then test state transition
        cart.removeItem("A");
        
        assertEquals(1, cart.getItemCount());
        assertEquals(new BigDecimal("20"), cart.getTotal());
    }
    
    @Test
    void shouldHandleStateThroughCompleteLifecycle() {
        // Integration test: state through multiple phases
        assertTrue(cart.isEmpty());
        
        cart.addItem(new Product("A", new BigDecimal("10")), 1);
        assertFalse(cart.isEmpty());
        
        cart.clear();
        assertTrue(cart.isEmpty());
    }
    
    // Test order may matter if tests share state (they shouldn't!)
    // Must reset state between tests
}
 
 
// ========== TESTING HYBRID SYSTEMS ==========
// Mock external state stores; test business logic in isolation
 
class OrderServiceTest {
    
    @Mock private SessionStore sessionStore;
    @Mock private OrderRepository orderRepository;
    @Mock private InventoryChecker inventoryChecker;
    
    @InjectMocks private OrderService orderService;
    
    @Test
    void shouldCreateOrderFromCart() {
        // Arrange: mock stateful dependencies
        Cart cart = Cart.of(new CartItem("PROD-1", 2, new BigDecimal("50.00")));
        UserProfile user = new UserProfile("USER-1", CustomerTier.GOLD, address);
        
        when(inventoryChecker.isAvailable(any())).thenReturn(true);
        
        // Act: test stateless business logic
        Order order = orderService.createOrder(cart, user, request);
        
        // Assert: verify computation
        assertEquals(new BigDecimal("90.00"), order.getTotal());  // 10% GOLD discount + tax
        assertEquals("USER-1", order.getUserId());
    }
}