System Design trong Java Enterprise

1. Nguyên tắc Thiết kế Hệ thống

1.1 Scalability (Khả năng mở rộng)

  • Vertical Scaling (Scale Up)
  • Tăng tài nguyên cho server hiện có
  • Ưu điểm: Đơn giản, dễ quản lý

  • Nhược điểm: Giới hạn về phần cứng, chi phí cao

  • Horizontal Scaling (Scale Out)

  • Thêm nhiều server/instance
  • Load balancing giữa các instance
  • Stateless design để dễ scale java @Configuration public class LoadBalancerConfig { @Bean public LoadBalancerClient loadBalancer() { return LoadBalancerBuilder.newBuilder() .round_robin() .build(); } }

1.2 Availability (Tính sẵn sàng)

  • High Availability Design
  • Active-Active configuration
  • Active-Passive configuration
  • Failover mechanisms ```java @CircuitBreaker(name = "userService", fallbackMethod = "fallbackMethod") public User getUser(Long id) { // Primary logic }

public User fallbackMethod(Long id, Exception ex) { // Fallback logic } ```

1.3 Reliability (Độ tin cậy)

  • Fault Tolerance
  • Circuit Breaker Pattern
  • Bulkhead Pattern
  • Retry Pattern java @Retry(maxAttempts = 3, backoff = @Backoff(delay = 1000)) public Response callExternalService() { // Service call logic }

2. Distributed Systems Design

2.1 Consistency Models

  • Strong Consistency java @Transactional(propagation = Propagation.REQUIRED) public void updateWithStrongConsistency() { // Transaction logic }

  • Eventual Consistency java @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT) public void handleEventualConsistency(DomainEvent event) { // Async update logic }

2.2 Distributed Caching

@Configuration
@EnableCaching
public class DistributedCacheConfig {
    @Bean
    public CacheManager cacheManager() {
        RedisCacheManager.RedisCacheManagerBuilder builder = 
            RedisCacheManager.RedisCacheManagerBuilder
                .fromConnectionFactory(redisConnectionFactory());

        return builder
            .cacheDefaults(defaultConfig())
            .withInitialCacheConfigurations(customConfigs())
            .build();
    }

    private RedisCacheConfiguration defaultConfig() {
        return RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(10))
            .serializeKeysWith(
                RedisSerializationContext.SerializationPair.fromSerializer(
                    new StringRedisSerializer()))
            .serializeValuesWith(
                RedisSerializationContext.SerializationPair.fromSerializer(
                    new GenericJackson2JsonRedisSerializer()));
    }
}

3. Data Architecture

3.1 Database Design

  • Sharding Strategies ```java @Configuration public class ShardingConfig { @Bean public ShardingDataSource shardingDataSource() { Map dataSourceMap = new HashMap<>(); dataSourceMap.put("shard0", shard0DataSource()); dataSourceMap.put("shard1", shard1DataSource());

      ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
  // Configure sharding rules

  return new ShardingDataSource(dataSourceMap, shardingRuleConfig);

    } } ```

  • Partitioning ```sql CREATE TABLE orders ( id BIGINT, order_date DATE, customer_id BIGINT ) PARTITION BY RANGE (EXTRACT(YEAR FROM order_date));

CREATE TABLE orders_2023 PARTITION OF orders FOR VALUES FROM (2023) TO (2024); ```

3.2 Data Flow Architecture

@Configuration
public class DataFlowConfig {
    @Bean
    public StreamsBuilder streamsBuilder() {
        StreamsBuilder builder = new StreamsBuilder();

        builder.stream("input-topic")
            .groupByKey()
            .aggregate(
                () -> new Aggregate(),
                (key, value, aggregate) -> aggregate.add(value),
                Materialized.as("aggregated-store")
            )
            .toStream()
            .to("output-topic");

        return builder;
    }
}

4. Security Architecture

4.1 Authentication & Authorization

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .oauth2ResourceServer()
                .jwt()
            .and()
            .authorizeRequests()
                .antMatchers("/public/**").permitAll()
                .antMatchers("/api/**").authenticated()
            .and()
            .sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    }
}

4.2 Data Encryption

@Service
public class EncryptionService {
    @Value("${encryption.key}")
    private String secretKey;

    public String encrypt(String data) throws Exception {
        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        SecretKey key = new SecretKeySpec(secretKey.getBytes(), "AES");
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] encryptedData = cipher.doFinal(data.getBytes());
        return Base64.getEncoder().encodeToString(encryptedData);
    }
}

5. Performance Architecture

5.1 Caching Strategies

@Service
public class UserService {
    @Cacheable(
        value = "users",
        key = "#id",
        unless = "#result == null",
        cacheManager = "redisCacheManager"
    )
    public User getUser(Long id) {
        return userRepository.findById(id)
            .orElseThrow(() -> new UserNotFoundException(id));
    }

    @CacheEvict(value = "users", key = "#user.id")
    public User updateUser(User user) {
        return userRepository.save(user);
    }
}

5.2 Async Processing

@Service
public class AsyncService {
    @Async
    public CompletableFuture<Result> processAsync() {
        return CompletableFuture.supplyAsync(() -> {
            // Long running task
            return new Result();
        }).thenApply(result -> {
            // Post processing
            return result;
        }).exceptionally(ex -> {
            // Error handling
            return new Result();
        });
    }
}

6. Monitoring và Observability

6.1 Metrics Collection

@Component
public class MetricsCollector {
    private final MeterRegistry registry;

    public MetricsCollector(MeterRegistry registry) {
        this.registry = registry;
    }

    public void recordOperation(String name, long duration) {
        Timer timer = Timer.builder("app.operation")
            .tag("name", name)
            .register(registry);

        timer.record(duration, TimeUnit.MILLISECONDS);
    }
}

6.2 Distributed Tracing

@Configuration
public class TracingConfig {
    @Bean
    public Tracer jaegerTracer() {
        return new Configuration("my-service")
            .withSampler(new Configuration.SamplerConfiguration()
                .withType("const").withParam(1))
            .withReporter(new Configuration.ReporterConfiguration()
                .withLogSpans(true))
            .getTracer();
    }
}

7. Best Practices và Guidelines

7.1 Design Principles

  • SOLID Principles
  • DRY (Don't Repeat Yourself)
  • KISS (Keep It Simple, Stupid)
  • YAGNI (You Aren't Gonna Need It)

7.2 Architecture Patterns

  • Microservices Architecture
  • Event-Driven Architecture
  • Domain-Driven Design
  • Clean Architecture

7.3 Design Reviews

  • Performance Impact Analysis
  • Security Review
  • Scalability Assessment
  • Maintainability Evaluation

8. Common Pitfalls và Solutions

8.1 Performance Issues

  • N+1 Query Problem
  • Memory Leaks
  • Thread Pool Exhaustion
  • Connection Pool Saturation

8.2 Scalability Issues

  • Single Points of Failure
  • Bottlenecks
  • Data Consistency
  • Cache Coherence

9. Case Studies

9.1 E-commerce Platform

  • Microservices Architecture
  • Event-Driven Design
  • Distributed Caching
  • Search Engine Integration

9.2 Payment System

  • High Availability Design
  • Security Measures
  • Transaction Management
  • Audit Logging

10. References và Resources

  • Clean Architecture by Robert C. Martin
  • Designing Data-Intensive Applications by Martin Kleppmann
  • System Design Interview by Alex Xu
  • Microservices Patterns by Chris Richardson