Verwendung von jOOQ mit Spring:CRUD

jOOQ ist eine Bibliothek, die uns hilft, die Kontrolle über unser SQL zurückzugewinnen. Es kann Code aus unserer Datenbank generieren und uns helfen, typsichere Datenbankabfragen zu erstellen, indem es seine fließende API verwendet.

Die früheren Teile meines jOOQ-Tutorials haben uns gezeigt, wie wir den Anwendungskontext unserer Beispielanwendung konfigurieren und Code aus unserer Datenbank generieren können.

Wir sind jetzt bereit, einen Schritt nach vorne zu machen und zu lernen, wie wir mit jOOQ typsichere Abfragen erstellen können. Dieser Blogbeitrag beschreibt, wie wir CRUD-Vorgänge zu einer einfachen Anwendung hinzufügen können, die Aufgabeneinträge verwaltet.

Fangen wir an.

Erstellen der Todo-Klasse

Beginnen wir damit, eine Klasse zu erstellen, die die Informationen eines einzelnen Aufgabeneintrags enthält. Diese Klasse hat die folgenden Felder:

• Die ID Feld enthält die ID des Aufgabeneintrags.
• Die Erstellungszeit enthält einen Zeitstempel, der beschreibt, wann der Todo-Eintrag zum ersten Mal persistiert wurde.
• Die Beschreibung Feld enthält die Beschreibung des Aufgabeneintrags.
• Die Änderungszeit Feld enthält einen Zeitstempel, der beschreibt, wann der Aufgabeneintrag aktualisiert wurde.
• Der Titel enthält den Titel des Aufgabeneintrags.

Der Name dieser relativ einfachen Klasse ist Todo , und folgt drei Prinzipien, die im Folgenden beschrieben werden:

• Wir können neue Aufgaben erstellen Objekte mithilfe des Builder-Musters, das in Effective Java von Joshua Bloch beschrieben wird. Wenn Sie mit diesem Muster nicht vertraut sind, sollten Sie einen Artikel mit dem Titel Punkt 2:Betrachten Sie einen Builder, wenn Sie mit vielen Konstruktorparametern konfrontiert sind.
lesen
• Der Titel Das Feld ist ein Pflichtfeld und wir können keine neue Aufgabe erstellen Objekt, das entweder einen leeren oder einen leeren Titel hat. Wenn wir versuchen, ein Todo zu erstellen Objekt mit einem ungültigen Titel, eine IllegalStateException wird geworfen.
• Diese Klasse ist unveränderlich. Mit anderen Worten, alle seine Felder werden als final deklariert .

Der Quellcode des Todo Klasse sieht wie folgt aus:

import org.apache.commons.lang3.builder.ToStringBuilder;
import org.joda.time.LocalDateTime;

import java.sql.Timestamp;

public class Todo {

    private final Long id;

    private final LocalDateTime creationTime;

    private final String description;

    private final LocalDateTime modificationTime;

    private final String title;

    private Todo(Builder builder) {
        this.id = builder.id;

        LocalDateTime creationTime = null;
        if (builder.creationTime != null) {
            creationTime = new LocalDateTime(builder.creationTime);
        }
        this.creationTime = creationTime;

        this.description = builder.description;

        LocalDateTime modificationTime = null;
        if (builder.modificationTime != null) {
            modificationTime = new LocalDateTime(builder.modificationTime);
        }
        this.modificationTime = modificationTime;

        this.title = builder.title;
    }

    public static Builder getBuilder(String title) {
        return new Builder(title);
    }

    //Getters are omitted for the sake of clarity.

    public static class Builder {

        private Long id;

        private Timestamp creationTime;

        private String description;

        private Timestamp modificationTime;

        private String title;

        public Builder(String title) {
            this.title = title;
        }

        public Builder description(String description) {
            this.description = description;
            return this;
        }

        public Builder creationTime(Timestamp creationTime) {
            this.creationTime = creationTime;
            return this;
        }

        public Builder id(Long id) {
            this.id = id;
            return this;
        }

        public Builder modificationTime(Timestamp modificationTime) {
            this.modificationTime = modificationTime;
            return this;
        }

        public Todo build() {
            Todo created = new Todo(this);

            String title = created.getTitle();

            if (title == null || title.length() == 0) {
                throw new IllegalStateException("title cannot be null or empty");
            }

            return created;
        }
    }
}

Lassen Sie uns herausfinden, warum wir das aktuelle Datum und die aktuelle Uhrzeit benötigen und, was noch wichtiger ist, wie dies am besten zu tun ist.

Abrufen des aktuellen Datums und der Uhrzeit

Da die Erstellungszeit und die Änderungszeit jedes Aufgabeneintrags in der Datenbank gespeichert werden, benötigen wir eine Möglichkeit, das aktuelle Datum und die aktuelle Uhrzeit zu erhalten. Natürlich könnten wir diese Informationen einfach in unserem Repository anlegen. Das Problem ist, dass wir dann keine automatisierten Tests schreiben können, die sicherstellen, dass die Erstellungszeit und die Änderungszeit korrekt eingestellt sind (wir können keine Zusicherungen für diese Felder schreiben, da ihre Werte von der aktuellen Zeit abhängen).

Aus diesem Grund müssen wir eine separate Komponente erstellen, die für die Rückgabe des aktuellen Datums und der Uhrzeit verantwortlich ist. Der DateTimeService interface deklariert zwei Methoden, die im Folgenden beschrieben werden:

• Die getCurrentDateTime() -Methode gibt das aktuelle Datum und die Uhrzeit als LocalDateTime zurück Objekt.
• Der getCurrentTimestamp() -Methode gibt das aktuelle Datum und die Uhrzeit als Timestamp zurück Objekt.

Der Quellcode des DateTimeService Die Benutzeroberfläche sieht wie folgt aus:

import org.joda.time.LocalDateTime;
import java.sql.Timestamp;

public interface DateTimeService {

    public LocalDateTime getCurrentDateTime();

    public Timestamp getCurrentTimestamp();
}

Da unsere Anwendung an der „echten“ Zeit interessiert ist, müssen wir diese Schnittstelle implementieren und eine Komponente erstellen, die das tatsächliche Datum und die tatsächliche Uhrzeit zurückgibt. Wir können dies tun, indem wir diesen Schritten folgen:

1. Erstellen Sie einen CurrentTimeDateTimeService Klasse, die den DateTimeService implementiert Schnittstelle.
2. Kommentieren Sie die Klasse mit @Profile Anmerkung und setzen Sie den Namen des Profils auf „Anwendung“. Das bedeutet, dass die Komponente im Spring-Container registriert wird, wenn das aktive Spring-Profil „Anwendung“ ist.
3. Annotieren Sie die Klasse mit @Component Anmerkung. Dadurch wird sichergestellt, dass die Klasse beim Classpath-Scannen gefunden wird.
4. Implementieren Sie die im DateTimeService deklarierten Methoden Schnittstelle. Jede Methode muss das aktuelle Datum und die Uhrzeit zurückgeben.

Der Quellcode des CurrentTimeDateTimeService sieht wie folgt aus:

import org.joda.time.LocalDateTime;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Component;

import java.sql.Timestamp;

@Profile("application")
@Component
public class CurrentTimeDateTimeService implements DateTimeService {

    @Override
    public LocalDateTime getCurrentDateTime() {
        return LocalDateTime.now();
    }

    @Override
    public Timestamp getCurrentTimestamp() {
        return new Timestamp(System.currentTimeMillis());
    }
}

Fahren wir fort und implementieren die Repository-Schicht unserer Beispielanwendung.

Implementierung der Repository-Schicht

Zuerst haben wir eine Repository-Schnittstelle erstellt, die CRUD-Operationen für Aufgabeneinträge bereitstellt. Diese Schnittstelle deklariert fünf Methoden, die im Folgenden beschrieben werden:

• Die Todo add(Todo todoEntry) -Methode speichert einen neuen Aufgabeneintrag in der Datenbank und gibt die Informationen des gespeicherten Aufgabeneintrags zurück.
• Die Todo-Löschung (lange ID) Methode löscht einen Aufgabeneintrag und gibt den gelöschten Aufgabeneintrag zurück.
• Die Liste findAll() Methode gibt alle Todo-Einträge zurück, die in der Datenbank gefunden werden.
• Der Todo findById(Long id) gibt die Informationen eines einzelnen Aufgabeneintrags zurück.
• Das Todo-Update(Todo todoEntry) aktualisiert die Informationen eines Aufgabeneintrags und gibt den aktualisierten Aufgabeneintrag zurück.

Der Quellcode des TodoRepository Die Benutzeroberfläche sieht wie folgt aus:

import java.util.List;

public interface TodoRepository {

    public Todo add(Todo todoEntry);

    public Todo delete(Long id);

    public List<Todo> findAll();

    public Todo findById(Long id);

    public Todo update(Todo todoEntry);
}

Als nächstes müssen wir das TodoRepository implementieren Schnittstelle. Wenn wir das tun, müssen wir die folgende Regel befolgen:

Alle von jOOQ erstellten Datenbankabfragen müssen innerhalb einer Transaktion ausgeführt werden . Der Grund dafür ist, dass unsere Anwendung den TransactionAwareDataSourceProxy verwendet Klasse, und wenn wir Datenbankabfragen ohne Transaktion ausführen, verwendet jOOQ für jede Operation eine andere Verbindung. Dies kann zu Race-Condition-Bugs führen.

Typischerweise fungiert die Dienstschicht als Transaktionsgrenze, und jeder Aufruf an ein jOOQ-Repository sollte innerhalb einer Transaktion erfolgen. Da aber auch Programmierer Fehler machen, können wir darauf nicht vertrauen. Deshalb müssen wir die Repository-Klasse oder ihre Methoden mit @Transactional annotieren Anmerkung.

Jetzt, wo wir das erledigt haben, sind wir bereit, unsere Repository-Klasse zu erstellen.

Erstellen der Repository-Klasse

Wir können das „Skelett“ unserer Repository-Klasse erstellen, indem wir diesen Schritten folgen:

1. Erstellen Sie ein JOOQTodoRepository Klasse und implementieren Sie das TodoRepository Schnittstelle.
2. Kommentieren Sie die Klasse mit @Repository Anmerkung. Dadurch wird sichergestellt, dass die Klasse während des Classpath-Scans gefunden wird.
3. Fügen Sie einen DateTimeService hinzu Feld zur erstellten Klasse. Wie wir uns erinnern, der DateTimeService interface deklariert die Methoden, die verwendet werden, um das aktuelle Datum und die Uhrzeit zu erhalten.
4. Fügen Sie einen DSLContext hinzu Feld zur erstellten Klasse. Diese Schnittstelle fungiert als Einstiegspunkt in die jOOQ-API und wir können unsere SQL-Abfragen mithilfe dieser Schnittstelle erstellen.
5. Fügen Sie der erstellten Klasse einen öffentlichen Konstruktor hinzu und kommentieren Sie den Konstruktor mit @Autowired Anmerkung. Dadurch wird sichergestellt, dass die Abhängigkeiten unseres Repositorys mithilfe der Konstruktorinjektion injiziert werden.
6. Fügen Sie ein privates Todo convertQueryResultToModelObject(TodosRecord queryResult) hinzu -Methode zur Repository-Klasse. Diese Hilfsmethode wird von den öffentlichen Methoden unserer Repository-Klasse verwendet. Implementieren Sie diese Methode, indem Sie die folgenden Schritte ausführen:
   1. Erstelle ein neues Todo Objekt, indem Sie die Informationen des TodosRecord verwenden Objekt als Methodenparameter angegeben.
   2. Gib das erstellte Objekt zurück.

Der relevante Teil des JOOQTodoRepository Klasse sieht wie folgt aus:

import net.petrikainulainen.spring.jooq.todo.db.tables.records.TodosRecord;
import org.jooq.DSLContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;


@Repository
public class JOOQTodoRepository implements TodoRepository {

    private final DateTimeService dateTimeService;

    private final DSLContext jooq;

    @Autowired
    public JOOQTodoRepository(DateTimeService dateTimeService, DSLContext jooq) {
        this.dateTimeService = dateTimeService;
        this.jooq = jooq;
    }

    private Todo convertQueryResultToModelObject(TodosRecord queryResult) {
        return Todo.getBuilder(queryResult.getTitle())
                .creationTime(queryResult.getCreationTime())
                .description(queryResult.getDescription())
                .id(queryResult.getId())
                .modificationTime(queryResult.getModificationTime())
                .build();
    }
}

Lassen Sie uns weitermachen und die Methoden implementieren, die CRUD-Operationen für Aufgabeneinträge bereitstellen.

Hinzufügen eines neuen Aufgabeneintrags

Das öffentliche Todo add(Todo todoEntry) Methode des TodoRepository Schnittstelle wird verwendet, um der Datenbank neue Aufgabeneinträge hinzuzufügen. Wir können diese Methode implementieren, indem wir diesen Schritten folgen:

1. Fügen Sie einen privaten TodosRecord createRecord(Todo todoEntry) hinzu -Methode in die Repository-Klasse und implementieren Sie diese Methode mit den folgenden Schritten:
   1. Erhalten Sie das aktuelle Datum und die Uhrzeit, indem Sie getCurrentTimestamp() aufrufen Methode des DateTimeService Schnittstelle.
   2. Erstellen Sie einen neuen TodosRecord -Objekt und legen Sie seine Feldwerte fest, indem Sie die Informationen des Todo verwenden Objekt als Methodenparameter angegeben.
   3. Gib den erstellten TodosRecord zurück Objekt.
2. Fügen Sie add() hinzu -Methode in das JOOQTodoRepository Klasse und kommentieren Sie die Methode mit @Transactional Anmerkung. Dadurch wird sichergestellt, dass die INSERT -Anweisung wird innerhalb einer Lese-Schreib-Transaktion ausgeführt.
3. Implementieren Sie add() Methode, indem Sie die folgenden Schritte ausführen:
   1. Fügen Sie der Datenbank einen neuen Aufgabeneintrag hinzu, indem Sie die folgenden Schritte ausführen:
      1. Erstellen Sie ein neues INSERT -Anweisung durch Aufrufen von insertInto(Table table) Methode des DSLContext Schnittstelle und geben Sie an, dass Sie Informationen in die todos einfügen möchten Tabelle.
      2. Erstellen Sie einen neuen TodosRecord Objekt durch Aufrufen von createRecord() Methode. Übergeben Sie die Aufgabe Objekt als Methodenparameter.
      3. Legen Sie die eingefügten Informationen fest, indem Sie set(Record record) aufrufen Methode des InsertSetStep Schnittstelle. Übergeben Sie den erstellten TodosRecord Objekt als Methodenparameter.
      4. Stellen Sie sicher, dass die INSERT Die Abfrage gibt alle eingefügten Felder zurück, indem sie returning() aufruft Methode des InsertReturningStep Schnittstelle.
      5. Holen Sie sich den TodosRecord Objekt, das die Werte aller eingefügten Felder enthält, durch Aufruf von fetchOne() Methode des InsertResultStep Schnittstelle.
   2. Konvertieren Sie den TodosRecord Objekt, das von INSERT zurückgegeben wird Anweisung in ein Todo -Objekt durch Aufrufen von convertQueryResultToModelObject() Methode.
   3. Geben Sie das erstellte Todo zurück Objekt.

Der relevante Teil des JOOQTodoRepository Klasse sieht wie folgt aus:

import net.petrikainulainen.spring.jooq.todo.db.tables.records.TodosRecord;
import org.jooq.DSLContext;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import java.sql.Timestamp;

import static net.petrikainulainen.spring.jooq.todo.db.tables.Todos.TODOS;

@Repository
public class JOOQTodoRepository implements TodoRepository {

    private final DateTimeService dateTimeService;

    private final DSLContext jooq;

	//The constructor is omitted for the sake of clarity

    @Transactional
    @Override
    public Todo add(Todo todoEntry) {
        TodosRecord persisted = jooq.insertInto(TODOS)
                .set(createRecord(todoEntry))
                .returning()
                .fetchOne();

        return convertQueryResultToModelObject(persisted);
    }

    private TodosRecord createRecord(Todo todoEntry) {
        Timestamp currentTime = dateTimeService.getCurrentTimestamp();

        TodosRecord record = new TodosRecord();
        record.setCreationTime(currentTime);
        record.setDescription(todoEntry.getDescription());
        record.setModificationTime(currentTime);
        record.setTitle(todoEntry.getTitle());

        return record;
    }

    private Todo convertQueryResultToModelObject(TodosRecord queryResult) {
        return Todo.getBuilder(queryResult.getTitle())
                .creationTime(queryResult.getCreationTime())
                .description(queryResult.getDescription())
                .id(queryResult.getId())
                .modificationTime(queryResult.getModificationTime())
                .build();
    }
}

Lassen Sie uns weitermachen und herausfinden, wie wir alle Einträge finden können, die in der Datenbank gespeichert sind.

Alle Aufgabeneinträge finden

Die öffentliche Liste findAll() Methode des TodoRepository Die Schnittstelle gibt alle Todo-Einträge zurück, die in der Datenbank gespeichert sind. Wir können diese Methode implementieren, indem wir diesen Schritten folgen:

1. Fügen Sie findAll() hinzu -Methode in die Repository-Klasse und kommentieren Sie die Methode mit @Transactional Anmerkung. Legen Sie den Wert von readOnly fest Attribut auf true . Dadurch wird sichergestellt, dass die SELECT -Anweisung wird innerhalb einer schreibgeschützten Transaktion ausgeführt.
2. Alle todo-Einträge aus der Datenbank abrufen, indem Sie diesen Schritten folgen:
   1. Erstellen Sie ein neues SELECT -Anweisung durch Aufrufen von selectFrom(Table table) Methode des DSLContext Benutzeroberfläche und geben Sie an, dass Sie Informationen aus den Aufgaben auswählen möchten Tabelle.
   2. Erhalten Sie eine Liste von TodosRecord Objekte durch Aufrufen von fetchInto(Class type) Methode der ResultQuery Schnittstelle.
3. Iterieren Sie die zurückgegebene Liste von TodosRecord Objekte und konvertieren Sie jeden TodosRecord Objekt in ein Todo -Objekt durch Aufrufen von convertQueryResultToModelObject() Methode. Fügen Sie jede Aufgabe hinzu Objekt der Liste von Todo hinzufügen Objekte.
4. Gib die Liste zurück die das gefundene Todo enthält Objekte.

Der relevante Teil des JOOQTodoRepository Klasse sieht wie folgt aus:

import net.petrikainulainen.spring.jooq.todo.db.tables.records.TodosRecord;
import org.jooq.DSLContext;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;

import static net.petrikainulainen.spring.jooq.todo.db.tables.Todos.TODOS;

@Repository
public class JOOQTodoRepository implements TodoRepository {

    private final DSLContext jooq;

	//The constructor is omitted for the sake of clarity

    @Transactional(readOnly = true)
    @Override
    public List<Todo> findAll() {
        List<Todo> todoEntries = new ArrayList<>();

        List<TodosRecord> queryResults = jooq.selectFrom(TODOS).fetchInto(TodosRecord.class);

        for (TodosRecord queryResult: queryResults) {
            Todo todoEntry = convertQueryResultToModelObject(queryResult);
            todoEntries.add(todoEntry);
        }

        return todoEntries;
    }

    private Todo convertQueryResultToModelObject(TodosRecord queryResult) {
        return Todo.getBuilder(queryResult.getTitle())
                .creationTime(queryResult.getCreationTime())
                .description(queryResult.getDescription())
                .id(queryResult.getId())
                .modificationTime(queryResult.getModificationTime())
                .build();
    }
}

Als nächstes werden wir herausfinden, wie wir einen einzelnen Todo-Eintrag aus der Datenbank bekommen können.

Einen einzelnen Aufgabeneintrag finden

Die öffentliche Todo findById(Long id) Methode des TodoRepository Schnittstelle gibt die Informationen eines einzelnen Todo-Eintrags zurück. Wir können diese Methode implementieren, indem wir diesen Schritten folgen:

1. Fügen Sie findById() hinzu method die Repository-Klasse und kommentieren Sie die Methode mit @Transactional Anmerkung. Legen Sie den Wert von readOnly fest Attribut auf wahr. Dadurch wird sichergestellt, dass die SELECT -Anweisung wird innerhalb einer schreibgeschützten Transaktion ausgeführt.
2. Befolgen Sie die folgenden Schritte, um die Informationen eines einzelnen Aufgabeneintrags aus der Datenbank abzurufen:
   1. Erstellen Sie ein neues SELECT -Anweisung durch Aufrufen von selectFrom(Table table) Methode des DSLContext Benutzeroberfläche und geben Sie an, dass Sie Informationen aus den Aufgaben auswählen möchten Tabelle.
   2. Geben Sie das WO an -Klausel von SELECT -Anweisung durch Aufrufen von where(Collection conditions) Methode des SelectWhereStep Schnittstelle. Stellen Sie sicher, dass die SELECT -Anweisung gibt nur den Aufgabeneintrag zurück, dessen ID als Methodenparameter angegeben wurde.
   3. Holen Sie sich den TodosRecord Objekt durch Aufrufen von fetchOne() Methode der ResultQuery Schnittstelle.
3. Falls der zurückgegebene TodosRecord object null ist, bedeutet dies, dass kein todo-Eintrag mit der angegebenen ID gefunden wurde. Wenn dies der Fall ist, lösen Sie eine neue TodoNotFoundException aus .
4. Konvertieren Sie TodosRecord Objekt, das von SELECT zurückgegeben wird Anweisung in ein Todo -Objekt durch Aufrufen von convertQueryResultToModelObject() Methode.
5. Geben Sie das erstellte Todo zurück Objekt.

Der relevante Teil des JOOQTodoRepository sieht wie folgt aus:

import net.petrikainulainen.spring.jooq.todo.db.tables.records.TodosRecord;
import org.jooq.DSLContext;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import static net.petrikainulainen.spring.jooq.todo.db.tables.Todos.TODOS;

@Repository
public class JOOQTodoRepository implements TodoRepository {

    private final DSLContext jooq;

	//The constructor is omitted for the sake of clarity.

    @Transactional(readOnly = true)
    @Override
    public Todo findById(Long id) {
        TodosRecord queryResult = jooq.selectFrom(TODOS)
                .where(TODOS.ID.equal(id))
                .fetchOne();

        if (queryResult == null) {
            throw new TodoNotFoundException("No todo entry found with id: " + id);
        }

        return convertQueryResultToModelObject(queryResult);
    }

    private Todo convertQueryResultToModelObject(TodosRecord queryResult) {
        return Todo.getBuilder(queryResult.getTitle())
                .creationTime(queryResult.getCreationTime())
                .description(queryResult.getDescription())
                .id(queryResult.getId())
                .modificationTime(queryResult.getModificationTime())
                .build();
    }
}

Lassen Sie uns herausfinden, wie wir einen Aufgabeneintrag aus der Datenbank löschen können.

Löschen eines Aufgabeneintrags

Das öffentliche Todo delete(Long id) Methode des TodoRepository Schnittstelle wird verwendet, um einen Todo-Eintrag aus der Datenbank zu löschen. Wir können diese Methode implementieren, indem wir diesen Schritten folgen:

1. Fügen Sie das delete() hinzu -Methode in die Repository-Klasse und kommentieren Sie die Methode mit @Transactional Anmerkung. Dadurch wird sichergestellt, dass das DELETE -Anweisung wird innerhalb einer Lese-Schreib-Transaktion ausgeführt.
2. Implementieren Sie diese Methode, indem Sie diesen Schritten folgen:
   1. Finden Sie die gelöschte Aufgabe Objekt durch Aufrufen von findById(Long id) Methode. Übergeben Sie die ID des gelöschten Aufgabeneintrags als Methodenparameter.
   2. Löschen Sie den Aufgabeneintrag aus der Datenbank, indem Sie die folgenden Schritte ausführen:
      1. Erstellen Sie ein neues DELETE -Anweisung durch Aufrufen von delete(Table table) Methode des DSLContext Benutzeroberfläche und geben Sie an, dass Sie Informationen aus den Aufgaben löschen möchten Tabelle.
      2. Geben Sie das WO an Klausel von DELETE -Anweisung durch Aufrufen der where(Condition... conditions) Methode des DeleteWhereStep Schnittstelle. Stellen Sie sicher, dass LÖSCHEN -Anweisung löscht den todo-Eintrag, dessen ID als Methodenparameter angegeben wurde.
      3. Führen Sie das LÖSCHEN aus -Anweisung durch Aufrufen von execute() Methode der Abfrage Schnittstelle.
   3. Gib die Informationen des gelöschten Aufgabeneintrags zurück.

Der relevante Teil des JOOQTodoRepository Klasse sieht wie folgt aus:

import net.petrikainulainen.spring.jooq.todo.db.tables.records.TodosRecord;
import org.jooq.DSLContext;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import static net.petrikainulainen.spring.jooq.todo.db.tables.Todos.TODOS;

@Repository
public class JOOQTodoRepository implements TodoRepository {

    private final DSLContext jooq;

    //The constructor is omitted for the sake of clarity

    @Transactional
    @Override
    public Todo delete(Long id) {
        Todo deleted = findById(id);

        int deletedRecordCount = jooq.delete(TODOS)
                .where(TODOS.ID.equal(id))
                .execute();

        return deleted;
    }
}

Lassen Sie uns weitermachen und herausfinden, wie wir die Informationen eines bestehenden Aufgabeneintrags aktualisieren können.

Aktualisieren eines bestehenden Aufgabeneintrags

Das öffentliche Todo-Update(Todo todoEntry) Methode des TodoRepository Schnittstelle aktualisiert die Informationen eines bestehenden Aufgabeneintrags. Wir können diese Methode implementieren, indem wir diesen Schritten folgen:

1. Fügen Sie das update() hinzu -Methode in die Repository-Klasse und kommentieren Sie die Methode mit @Transactional Anmerkung. Dadurch wird sichergestellt, dass das UPDATE -Anweisung wird innerhalb einer Lese-Schreib-Transaktion ausgeführt.
2. Erhalten Sie das aktuelle Datum und die Uhrzeit, indem Sie getCurrentTimestamp() aufrufen Methode des DateTimeService Schnittstelle.
3. Aktualisieren Sie die Informationen des Aufgabeneintrags, indem Sie diesen Schritten folgen:
   1. Erstellen Sie ein neues UPDATE -Anweisung durch Aufrufen von update(Table table) Methode des DSLContext Benutzeroberfläche und geben Sie an, dass Sie Informationen aus den todos aktualisieren möchten Tabelle.
   2. Legen Sie die neue Beschreibung, die Änderungszeit und den Titel fest, indem Sie set(Field field, T value) aufrufen Methode des UpdateSetStep Schnittstelle.
   3. Geben Sie das WO an -Klausel des UPDATE -Anweisung durch Aufrufen der where(Condition... conditions) Methode des UpdateWhereStep Schnittstelle. Stellen Sie sicher, dass das UPDATE -Anweisung aktualisiert den Todo-Eintrag, dessen ID aus Todo gefunden wird Objekt als Methodenparameter angegeben.
   4. Führen Sie das UPDATE aus -Anweisung durch Aufrufen von execute() Methode der Abfrage Schnittstelle.
4. Erhalten Sie die Informationen des aktualisierten Aufgabeneintrags, indem Sie findById() aufrufen Methode. Übergeben Sie die ID des aktualisierten Aufgabeneintrags als Methodenparameter.
5. Gib die Informationen des aktualisierten Aufgabeneintrags zurück.

Der relevante Teil des JOOQTodoRepository Klasse sieht wie folgt aus:

import org.jooq.DSLContext;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import java.sql.Timestamp;

import static net.petrikainulainen.spring.jooq.todo.db.tables.Todos.TODOS;

@Repository
public class JOOQTodoRepository implements TodoRepository {

    private final DateTimeService dateTimeService;

    private final DSLContext jooq;

	//The constructor is omitted for the sake of clarity.

    @Transactional
    @Override
    public Todo update(Todo todoEntry) {
        Timestamp currentTime = dateTimeService.getCurrentTimestamp();
		
        int updatedRecordCount = jooq.update(TODOS)
                .set(TODOS.DESCRIPTION, todoEntry.getDescription())
                .set(TODOS.MODIFICATION_TIME, currentTime)
                .set(TODOS.TITLE, todoEntry.getTitle())
                .where(TODOS.ID.equal(todoEntry.getId()))
                .execute();

        return findById(todoEntry.getId());
    }
}

Das ist alles, Leute. Fassen wir zusammen, was wir aus diesem Blogbeitrag gelernt haben.

Zusammenfassung

Wir haben jetzt CRUD-Operationen für Aufgabeneinträge implementiert. Dieses Tutorial hat uns drei Dinge gelehrt:

• Wir haben gelernt, wie wir das aktuelle Datum und die Uhrzeit auf eine Weise abrufen können, die uns nicht daran hindert, automatisierte Tests für unsere Beispielanwendung zu schreiben.
• Wir haben gelernt, wie wir sicherstellen können, dass alle von jOOQ ausgeführten Datenbankabfragen innerhalb einer Transaktion ausgeführt werden.
• Wir haben gelernt, wie wir INSERT erstellen können , AUSWÄHLEN , LÖSCHEN , und AKTUALISIEREN Anweisungen mithilfe der jOOQ-API.

Der nächste Teil dieses Tutorials beschreibt, wie wir unserer Beispielanwendung eine Suchfunktion hinzufügen können, die Sortierung und Paginierung unterstützt.

P.S. Sie können die Beispielanwendung dieses Blogbeitrags von Github herunterladen.