Hash

Cache Key Generation (Hash)

📝 Note: This guide uses generic placeholder names to be reusable across any Spring Boot microservice. Replace with your actual implementation:

• {YourService} → Your service name (e.g., OrderService, PaymentService)
• BusinessService → Your core service (e.g., OrderService, UserService)
• DataService → Your data processing service (e.g., PaymentService, InventoryService)
• IntegrationService → Your external integration (e.g., PaymentGatewayService)
• {RequestType} → Your request DTO (e.g., CreateOrderRequest)
• {ResponseType} → Your response DTO (e.g., OrderResponse)

Overview

The hash package generates consistent, deterministic cache keys using Base64 encoding for authentication tokens, resource accesss, and user-specific data. Cache hashes enable efficient invalidation and client-side caching strategies.

Package

Base: com.example.microserviceorch.hash.example

Core Components

• HashGenerator - Interface defining hash generation contract
• HashGeneratorImpl - Base64-based implementation with delimiter composition

Key Capabilities

• Generate cache hashes for authenticated users with resource accesss
• Generate user-specific cache hashes (AMC account or Adobe ID)
• Generate cache hashes for unauthenticated users
• Deterministic, consistent hash generation with case normalization
• Compact representation using abbreviated keys
• Base64 encoding for URL-safe cache keys

Quick Reference

Hash Types

// Cache hash for authenticated users
String cacheHash = hashGenerator.generateCacheHash(wrapper, resource accesss);

// User-specific cache hash
String userCacheHash = hashGenerator.generateUserCacheHash(accountId, wrapper);

// Unauthenticated user cache hash
String unauthCacheHash = hashGenerator.generateUnauthUserCacheHash(wrapper);

Cache Key Structure

t=amcn;n=amc;p=web;e=amcn_auth,ob-sub-amcplus;c=us;l=en-us;av=1.0.0
                        ↓ Base64 Encoding ↓
dD1hbWNuO249YW1jO3A9d2ViO2U9YW1jbl9hdXRoLG9iLXN1Yi1hbWNwbHVzO2M9dXM7bD1lbi11czthdj0xLjAuMA==

Design Patterns

• Strategy Pattern: Different strategies for auth, unauth, and user-specific hashes
• Template Method: Common hash generation logic (generateCacheHashCommon)
• Builder Pattern: Fluent RequestParametersWrapper construction
• Dependency Injection: Component injected via constructor

Best Practices

✅ Use abbreviated keys (t, n, p, etc.) for compact cache keys
✅ Normalize case for country and language codes
✅ Maintain consistent parameter ordering for deterministic hashes
✅ Handle optional fields gracefully (only add if present)
✅ Use null-safe checks with default values
✅ Log warnings for invalid inputs

❌ Don't use long key names (increases cache key size)
❌ Don't skip case normalization (causes cache misses)
❌ Don't randomize parameter ordering (breaks determinism)
❌ Don't silently swallow errors

Guides

• Hash Generation Architecture - Patterns, components, and structure
• Implementation Guide - Delimiter strategy, encoding, and common logic
• Testing Strategies - Unit tests, determinism, and validation

Examples

• Basic Hash Generation - Standard cache hash creation
• Service Integration - Using HashGenerator in services
• Testing Examples - Comprehensive test cases

Cache Key Reference

Code Formatting

Use Spotless with Google Java Format (AOSP style):

./gradlew spotlessApply

Performance

• Sub-millisecond hash generation
• No cryptographic overhead (Base64 only)
• Thread-safe stateless operations
• Average hash size: 80-120 characters