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:
- Verwenden Sie immer einen KeyHolder beim Einfügen von Datensätzen mit Auto-Increment
- Prüfen Sie die Anzahl der betroffenen Zeilen für zusätzliche Sicherheit
- Implementieren Sie robuste Fehlerbehandlung für Produktionsumgebungen
- 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.