Spring Persistence: Der Einstieg in die Welt der Datenhaltung mit Spring

tiny-tool.de

tiny-tool.de

In diesem Artikel tauchen wir in das Thema Spring Persistence ein und betrachten die verschiedenen Möglichkeiten, wie Spring mit Datenbanken interagiert. Du wirst lernen, wie Du den EntityManager verwenden kannst, wie Du das JPARepository und CrudRepository einsetzt, und welche Rolle Annotations wie @Entity, @NamedQuery und @NamedNativeQuery spielen. Um das Ganze abzurunden, schauen wir uns auch an, wie man Beziehungen zwischen Entitäten modelliert.

EntityManager API

Der EntityManager ist das zentrale API für die Interaktion mit dem JPA (Java Persistence API). Es ermöglicht Dir, Entitäten in der Datenbank zu persistieren, zu aktualisieren und zu löschen. Der EntityManager bietet eine Vielzahl von Methoden, um mit der Datenbank zu arbeiten.

@PersistenceContext
private EntityManager entityManager;

public void createEntity(MyEntity entity) {
    entityManager.persist(entity);
}

public MyEntity findEntity(Long id) {
    return entityManager.find(MyEntity.class, id);
}

public void updateEntity(MyEntity entity) {
    entityManager.merge(entity);
}

public void deleteEntity(Long id) {
    MyEntity entity = entityManager.find(MyEntity.class, id);
    if (entity != null) {
        entityManager.remove(entity);
    }
}

Named Queries und deren Verwendung

@NamedQuery und @NamedNativeQuery sind leistungsfähige Features, um wiederverwendbare und vordefinierte Abfragen in Deinen Entitäten zu hinterlegen. Mit Named Queries kannst Du komplexe Datenbankabfragen zentral in der Entitätsklasse definieren und in Deinem Code flexibel darauf zugreifen. Dies ist besonders hilfreich, wenn Du Abfragen standardisieren möchtest.

@Entity
@NamedQuery(name = "MyEntity.findByStatus",
            query = "SELECT e FROM MyEntity e WHERE e.status = :status")
@NamedNativeQuery(name = "MyEntity.findByNativeQuery",
                  query = "SELECT * FROM my_entity_table WHERE status = :status",
                  resultClass = MyEntity.class)
public class MyEntity {
    @Id
    private Long id;
    private String status;
}

Der Zugriff auf die Named Queries erfolgt dann beispielsweise so:

public List<MyEntity> getEntitiesByStatus(String status) {
    return entityManager.createNamedQuery("MyEntity.findByStatus", MyEntity.class)
                        .setParameter("status", status)
                        .getResultList();
}

Durch den Einsatz von Named Queries kannst Du die Wartbarkeit Deines Codes verbessern, da die Abfragen zentral verwaltet und optimiert werden können. Insbesondere bei umfangreicheren Projekten mit vielen wiederkehrenden Abfragen ist dies von Vorteil.

JPQL und Queries mit EntityManager

Mit JPQL (Java Persistence Query Language) kannst Du Abfragen über Entitäten durchführen. Ein Beispiel für eine einfache JPQL-Abfrage:

public List findByName(String name) {
    String jpql = "SELECT e FROM MyEntity e WHERE e.name = :name";
    return entityManager.createQuery(jpql, MyEntity.class)
                        .setParameter("name", name)
                        .getResultList();
}

Native Queries

Neben JPQL kannst Du auch Native Queries verwenden, um direkt auf die Datenbank zuzugreifen. Dies kann nützlich sein, wenn Du spezielle Funktionen oder Abfragen benötigst, die über JPQL nicht möglich sind:

public List<Object[]> findCustomData() {
    String sql = "SELECT column1, column2 FROM my_table";
    return entityManager.createNativeQuery(sql)
                        .getResultList();
}

JPARepository und CrudRepository

JPARepository und CrudRepository sind zwei Interfaces, die Dir dabei helfen, die Boilerplate-Codes zu reduzieren, die normalerweise für Datenbankoperationen notwendig sind.

CrudRepository

CrudRepository bietet grundlegende CRUD-Operationen an, ohne dass Du diese selbst implementieren musst:

public interface MyEntityRepository extends CrudRepository<MyEntity, Long> {
}

Nun kannst Du CRUD-Operationen wie save, findById, delete ganz einfach verwenden:

@Autowired
private MyEntityRepository repository;

public void saveEntity(MyEntity entity) {
    repository.save(entity);
}

public MyEntity findEntity(Long id) {
    return repository.findById(id).orElse(null);
}

JPARepository

JPARepository erweitert CrudRepository und fügt zusätzliche Methoden hinzu, wie zum Beispiel das Paginieren und Sortieren:

public interface MyEntityRepository extends JpaRepository<MyEntity, Long> {
    List findByName(String name);
}

Fazit

Mit der Kombination aus EntityManager, JPARepository, CrudRepository und den verschiedenen JPA-Annotationen hast Du mächtige Werkzeuge zur Hand, um Deine Datenbankzugriffe effizient und übersichtlich zu gestalten. Ob Du direkt auf den EntityManager zugreifen möchtest oder lieber die vorgefertigten Methoden von JPARepository nutzt, hängt von Deinem spezifischen Anwendungsfall ab. Der EntityManager gibt Dir maximale Kontrolle, während die Repository-Ansätze den Vorteil bieten, dass sie viele grundlegende Funktionen schon out-of-the-box bereitstellen.

Je nachdem, wie viel Flexibilität Du bei Deinen Datenbankoperationen benötigst, kannst Du das passende Tool auswählen. Die Modellierung von Entitäten und deren Beziehungen wird durch die mächtigen JPA-Annotationen sehr einfach gemacht, wodurch Spring Persistence zu einer eleganten und effizienten Lösung für Datenbankzugriffe wird.

Weiterführende Links: