Spring Boot Projesini Multi-Tenant Sisteme Taşımak: AbstractRoutingDataSource

public class TenantContext {
    private static final ThreadLocal<String> CURRENT_TENANT =
        ThreadLocal.withInitial(() -> null);
 
    public static void setTenantId(String tenantId) {
        CURRENT_TENANT.set(tenantId);
    }
 
    public static String getTenantId() {
        return CURRENT_TENANT.get();
    }
 
    public static void clear() {
        CURRENT_TENANT.remove(); // ← Memory leak önleme
    }
}

public class TenantRoutingDataSource extends AbstractRoutingDataSource {
 
    @Override
    protected Object determineCurrentLookupKey() {
        String tenantId = TenantContext.getTenantId();
        if (tenantId == null) {
            return "basedb"; // Default: auth veritabanı
        }
        return tenantId;
    }
}

@Configuration
public class DataSourceConfig {
 
    @Bean
    @Primary
    public DataSource dataSource() {
        Map<Object, Object> targetDataSources = new HashMap<>();
 
        targetDataSources.put("tenant1", buildDataSource(
            "postgres-tenant1", "5432", "elly_tenant1"
        ));
        targetDataSources.put("tenant2", buildDataSource(
            "postgres-tenant2", "5432", "elly_tenant2"
        ));
        targetDataSources.put("basedb", buildDataSource(
            "postgres-basedb", "5432", "elly_basedb"
        ));
 
        TenantRoutingDataSource routingDataSource = new TenantRoutingDataSource();
        routingDataSource.setTargetDataSources(targetDataSources);
        routingDataSource.setDefaultTargetDataSource(targetDataSources.get("basedb"));
        return routingDataSource;
    }
 
    private DataSource buildDataSource(String host, String port, String dbName) {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl(String.format("jdbc:postgresql://%s:%s/%s", host, port, dbName));
        config.setUsername(System.getenv("DB_USERNAME"));
        config.setPassword(System.getenv("DB_PASSWORD"));
        config.setMaximumPoolSize(10);
        config.setMinimumIdle(2);
        config.setConnectionTimeout(30_000);
        return new HikariDataSource(config);
    }
}

@Component
@Order(1)
public class JwtTenantFilter extends OncePerRequestFilter {
 
    private final JwtUtil jwtUtil;
 
    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain chain) throws IOException, ServletException {
        try {
            String token = extractBearerToken(request);
            if (token != null && jwtUtil.isTokenValid(token)) {
                String tenantId = jwtUtil.extractTenantId(token);
                TenantContext.setTenantId(tenantId); // ← ThreadLocal'a yaz
            }
            chain.doFilter(request, response);
        } finally {
            TenantContext.clear(); // ← Mutlaka temizle
        }
    }
 
    private String extractBearerToken(HttpServletRequest request) {
        String header = request.getHeader(HttpHeaders.AUTHORIZATION);
        if (header != null && header.startsWith("Bearer ")) {
            return header.substring(7);
        }
        return null;
    }
}

@Configuration
public class JpaConfig {
 
    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(
            DataSource dataSource,
            JpaVendorAdapter jpaVendorAdapter) {
 
        LocalContainerEntityManagerFactoryBean em =
            new LocalContainerEntityManagerFactoryBean();
        em.setDataSource(dataSource);
        em.setPackagesToScan("com.cms.entity");
        em.setJpaVendorAdapter(jpaVendorAdapter);
 
        Properties jpaProperties = new Properties();
        jpaProperties.put("hibernate.default_schema", "public");
        jpaProperties.put("hibernate.hbm2ddl.auto", "none"); // Migration Flyway ile
        jpaProperties.put("hibernate.show_sql", "false");
        em.setJpaProperties(jpaProperties);
 
        return em;
    }
}

@Service
public class AuthService {
 
    public AuthResponse login(LoginRequest request) {
        // 1. Tenant bağlamını basedb'ye geçici olarak ayarla
        TenantContext.setTenantId("basedb");
 
        try {
            // 2. Kullanıcıyı basedb'den bul
            User user = userRepository.findByEmail(request.getEmail())
                .orElseThrow(() -> new AuthException("Kullanıcı bulunamadı"));
 
            // 3. Şifre doğrula
            if (!passwordEncoder.matches(request.getPassword(), user.getPassword())) {
                throw new AuthException("Geçersiz şifre");
            }
 
            // 4. Kullanıcının erişebildiği tenant'ları al
            List<String> managedTenants = user.getManagedTenants();
 
            // 5. Her tenant için ayrı token üret
            Map<String, String> tenantTokens = new HashMap<>();
            for (String tenantId : managedTenants) {
                String tenantToken = jwtUtil.generateTenantToken(tenantId);
                tenantTokens.put(tenantId, tenantToken);
            }
 
            // 6. Ana access token'ı basedb context'inde üret
            String accessToken = jwtUtil.generateToken(
                user.getId(), "basedb", LoginSource.WEB.name(), user.getTokenVersion()
            );
 
            return AuthResponse.builder()
                .accessToken(accessToken)
                .tenantTokens(tenantTokens) // ← Her tenant için ayrı token
                .managedTenants(managedTenants)
                .build();
 
        } finally {
            TenantContext.clear(); // ← Bağlamı temizle
        }
    }
}

// Tenant-specific resource endpoint
@GetMapping("/api/pages")
public ResponseEntity<List<PageDto>> getPages(
        @RequestHeader("X-Tenant-Token") String tenantToken) {
 
    String tenantId = jwtUtil.extractTenantIdFromTenantToken(tenantToken);
    TenantContext.setTenantId(tenantId); // Bu tenant'ın DB'sine yönlendir
 
    try {
        return ResponseEntity.ok(pageService.getAllPages());
    } finally {
        TenantContext.clear();
    }
}

services:
  postgres-tenant1:
    image: postgres:16
    environment:
      POSTGRES_DB: elly_tenant1
      POSTGRES_USER: ${DB_USERNAME}
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    ports:
      - '5433:5432'
    volumes:
      - tenant1_data:/var/lib/postgresql/data
 
  postgres-tenant2:
    image: postgres:16
    environment:
      POSTGRES_DB: elly_tenant2
      POSTGRES_USER: ${DB_USERNAME}
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    ports:
      - '5434:5432'
    volumes:
      - tenant2_data:/var/lib/postgresql/data
 
  postgres-basedb:
    image: postgres:16
    environment:
      POSTGRES_DB: elly_basedb
      POSTGRES_USER: ${DB_USERNAME}
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    ports:
      - '5435:5432'
    volumes:
      - basedb_data:/var/lib/postgresql/data
 
volumes:
  tenant1_data:
  tenant2_data:
  basedb_data:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: postgres-basedb
spec:
  replicas: 1
  selector:
    matchLabels:
      app: postgres-basedb
  template:
    spec:
      containers:
        - name: postgres
          image: postgres:16
          resources:
            requests:
              memory: '256Mi'
              cpu: '250m'
            limits:
              memory: '512Mi'
              cpu: '500m'
          env:
            - name: POSTGRES_DB
              valueFrom:
                configMapKeyRef:
                  name: elly-config
                  key: BASEDB_NAME
  volumeClaimTemplates:
    - metadata:
        name: postgres-storage
      spec:
        accessModes: ['ReadWriteOnce']
        resources:
          requests:
            storage: 8Gi

@Bean
@Primary
public DataSource dataSource() {
    TenantRoutingDataSource routingDataSource = new TenantRoutingDataSource();
    routingDataSource.setTargetDataSources(buildTargetDataSources());
    routingDataSource.setDefaultTargetDataSource(baseDataSource());
    routingDataSource.afterPropertiesSet();
 
    // LazyConnectionDataSourceProxy: gerçek bağlantıyı ilk SQL çalıştırılana kadar erteler
    return new LazyConnectionDataSourceProxy(routingDataSource);
}