Das Problem: Generierte IDs nach einem INSERT abrufen

Jeder Entwickler kennt das Szenario: Nach dem Einfügen eines neuen Datensatzes in eine Datenbank benötigen wir oft die automatisch generierte ID für weitere Operationen. Sei es für Logging, für die Rückgabe an den Client oder für nachfolgende Datenbankoperationen – der generierte Primärschlüssel ist essentiell.

Mit Spring Boot 3.2 wurde der neue JdbcClient eingeführt, der eine moderne, fluent API für JDBC-Operationen bietet. In diesem Artikel zeigen wir, wie Sie mit dem JdbcClient und KeyHolder zuverlässig auf Auto-Increment-Werte zugreifen können.

Beispiel-Szenario: User-Verwaltung

Nehmen wir eine einfache User-Tabelle als Beispiel:

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(50) NOT NULL,
    email VARCHAR(100) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Und eine entsprechende Java-Klasse:

public class User {
    private Integer id;
    private String username;
    private String email;
    private LocalDateTime createdAt;
    
    // Konstruktoren, Getter und Setter...
}

Die Lösung: JdbcClient mit KeyHolder

Der bewährte und zuverlässige Ansatz verwendet den KeyHolder in Kombination mit dem modernen JdbcClient:

@Repository
public class UserRepository {
    
    private final JdbcClient jdbcClient;
    
    public UserRepository(JdbcClient jdbcClient) {
        this.jdbcClient = jdbcClient;
    }
    
    public int createUser(User user) {
        KeyHolder keyHolder = new GeneratedKeyHolder();

        int update = jdbcClient.sql("""
                INSERT INTO users (username, email, created_at) 
                VALUES (?, ?, ?)
                """)
                .params(
                        user.getUsername(),
                        user.getEmail(),
                        user.getCreatedAt()
                )
                .update(keyHolder);

        Assert.state(update == 1, "Failed to create user: " + user.getUsername());

        return keyHolder.getKey().intValue();
    }
}

Was passiert hier im Detail?

1. KeyHolder erstellen

KeyHolder keyHolder = new GeneratedKeyHolder();

Der GeneratedKeyHolder ist die Standard-Implementierung des KeyHolder-Interfaces und sammelt automatisch alle von der Datenbank generierten Schlüssel.

2. SQL mit Parametern ausführen

int update = jdbcClient.sql("""
        INSERT INTO users (username, email, created_at) 
        VALUES (?, ?, ?)
        """)
        .params(user.getUsername(), user.getEmail(), user.getCreatedAt())
        .update(keyHolder);

Der entscheidende Punkt ist der Aufruf von .update(keyHolder) anstatt dem einfachen .update(). Dadurch wird Spring angewiesen, die generierten Schlüssel zu erfassen.

3. Generierte ID abrufen

return keyHolder.getKey().intValue();

Nach der Ausführung enthält der KeyHolder die generierte ID, die wir als Integer zurückgeben können.

Vollständiges Service-Beispiel

@Service
@Transactional
public class UserService {
    
    private final UserRepository userRepository;
    
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    public User createUser(String username, String email) {
        User user = new User();
        user.setUsername(username);
        user.setEmail(email);
        user.setCreatedAt(LocalDateTime.now());
        
        int generatedId = userRepository.createUser(user);
        user.setId(generatedId);
        
        log.info("Created user with ID: {} and username: {}", generatedId, username);
        
        return user;
    }
}

Error Handling und Best Practices

Robuste Fehlerbehandlung

public int createUserSafely(User user) {
    try {
        KeyHolder keyHolder = new GeneratedKeyHolder();
        
        int rowsAffected = jdbcClient.sql("""
                INSERT INTO users (username, email, created_at) 
                VALUES (?, ?, ?)
                """)
                .params(user.getUsername(), user.getEmail(), user.getCreatedAt())
                .update(keyHolder);
        
        if (rowsAffected != 1) {
            throw new DataAccessException("Expected 1 row to be affected, but was: " + rowsAffected) {};
        }
        
        Number key = keyHolder.getKey();
        if (key == null) {
            throw new DataAccessException("No generated key returned") {};
        }
        
        return key.intValue();
        
    } catch (DataAccessException e) {
        log.error("Failed to create user: {}", user.getUsername(), e);
        throw new ServiceException("Could not create user", e);
    }
}

Validierung der Eingangsdaten

public int createUser(User user) {
    // Validierung vor dem Insert
    if (user.getUsername() == null || user.getUsername().trim().isEmpty()) {
        throw new IllegalArgumentException("Username cannot be null or empty");
    }
    
    if (user.getEmail() == null || !isValidEmail(user.getEmail())) {
        throw new IllegalArgumentException("Valid email is required");
    }
    
    KeyHolder keyHolder = new GeneratedKeyHolder();
    
    int update = jdbcClient.sql("""
            INSERT INTO users (username, email, created_at) 
            VALUES (?, ?, ?)
            """)
            .params(user.getUsername(), user.getEmail(), user.getCreatedAt())
            .update(keyHolder);

    Assert.state(update == 1, "Failed to create user: " + user.getUsername());
    
    return keyHolder.getKey().intValue();
}

Batch-Operationen

Auch bei mehreren Einfügungen funktioniert der KeyHolder-Ansatz zuverlässig:

public List<Integer> createMultipleUsers(List<User> users) {
    List<Integer> generatedIds = new ArrayList<>();
    
    for (User user : users) {
        KeyHolder keyHolder = new GeneratedKeyHolder();
        
        jdbcClient.sql("""
                INSERT INTO users (username, email, created_at) 
                VALUES (?, ?, ?)
                """)
                .params(user.getUsername(), user.getEmail(), user.getCreatedAt())
                .update(keyHolder);
        
        generatedIds.add(keyHolder.getKey().intValue());
    }
    
    return generatedIds;
}

Datenbankkompatibilität

Der KeyHolder-Ansatz funktioniert zuverlässig mit allen gängigen Datenbanken:

• MySQL: AUTO_INCREMENT wird automatisch erkannt
• PostgreSQL: SERIAL und IDENTITY Spalten werden unterstützt
• SQL Server: IDENTITY Spalten funktionieren out-of-the-box
• Oracle: SEQUENCE-basierte Auto-Increment wird unterstützt

Testing

Unit Test mit H2 In-Memory-Datenbank

@DataJdbcTest
class UserRepositoryTest {
    
    @Autowired
    private JdbcClient jdbcClient;
    
    private UserRepository userRepository;
    
    @BeforeEach
    void setUp() {
        userRepository = new UserRepository(jdbcClient);
    }
    
    @Test
    void shouldReturnGeneratedIdWhenCreatingUser() {
        // Given
        User user = new User();
        user.setUsername("testuser");
        user.setEmail("test@example.com");
        user.setCreatedAt(LocalDateTime.now());
        
        // When
        int generatedId = userRepository.createUser(user);
        
        // Then
        assertThat(generatedId).isGreaterThan(0);
    }
    
    @Test
    void shouldCreateMultipleUsersWithUniqueIds() {
        // Given
        User user1 = createTestUser("user1", "user1@example.com");
        User user2 = createTestUser("user2", "user2@example.com");
        
        // When
        int id1 = userRepository.createUser(user1);
        int id2 = userRepository.createUser(user2);
        
        // Then
        assertThat(id1).isNotEqualTo(id2);
        assertThat(id2).isGreaterThan(id1);
    }
    
    private User createTestUser(String username, String email) {
        User user = new User();
        user.setUsername(username);
        user.setEmail(email);
        user.setCreatedAt(LocalDateTime.now());
        return user;
    }
}

Warum KeyHolder der zuverlässige Standard ist

Nach ausgiebigen Tests verschiedener Ansätze hat sich der KeyHolder-Pattern als der stabilste und konsistenteste Weg erwiesen, um mit Auto-Increment-Werten zu arbeiten:

Vorteile des KeyHolder-Ansatzes:

• Zuverlässigkeit: Funktioniert konsistent über alle Datenbanktypen hinweg
• Explizite Kontrolle: Klare Trennung zwischen Insert-Operation und Key-Abruf
• Fehlerbehandlung: Einfache Überprüfung, ob ein Schlüssel generiert wurde
• Flexibilität: Unterstützt auch Szenarien mit mehreren generierten Schlüsseln
• Bewährt: Lange etablierter Standard in der Spring-Community

Fazit

Der Spring JdbcClient in Kombination mit dem KeyHolder bietet eine moderne, saubere und zuverlässige Lösung für den Umgang mit automatisch generierten Datenbankschlüsseln. Dieser Ansatz sollte in allen neuen Spring-Projekten verwendet werden, wo Auto-Increment-Werte benötigt werden.

Die wichtigsten Punkte zum Mitnehmen:

1. Verwenden Sie immer einen KeyHolder beim Einfügen von Datensätzen mit Auto-Increment
2. Prüfen Sie die Anzahl der betroffenen Zeilen für zusätzliche Sicherheit
3. Implementieren Sie robuste Fehlerbehandlung für Produktionsumgebungen
4. Der KeyHolder-Ansatz ist datenbankagnostisch und funktioniert überall

Mit diesem Pattern können Sie Auto-Increment-Werte zuverlässig und performant in Ihren Spring-Anwendungen handhaben – eine solide Grundlage für robuste Datenbankoperationen.