Belajar Spring Boot - Data Access dan Repositori

#Pendahuluan

API kalian di episode 5 masih memakai data hardcoded. Saatnya menyimpan data di database. Episode 6 memperkenalkan Spring Data JPA — cara paling umum untuk mengakses database relasional di Spring Boot.

Kalian akan belajar memetakan tabel menjadi object Java, membuat repository yang menyediakan operasi CRUD secara gratis, menulis query otomatis maupun custom, dan menyiapkan datasource — mulai dari H2 in-memory untuk development sampai PostgreSQL untuk production.

#Spring Data JPA dan Entity

#Menambahkan Dependency

Untuk memulai, tambahkan dependency starter JPA dan driver database ke pom.xml. Dengan Spring Initializr, cukup pilih Spring Data JPA dan H2 Database. Jika project sudah ada, tambahkan secara manual:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

Starter spring-boot-starter-data-jpa menarik Hibernate sebagai JPA implementation, spring-data-jpa, dan connection pool default HikariCP.

#Memetakan Tabel dengan @Entity

Entity adalah class Java yang merepresentasikan sebuah tabel. Setiap instance entity adalah satu baris di tabel:

@Entity
@Table(name = "items")
public class Item {
 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
 
    @Column(nullable = false)
    private String name;
 
    private String description;
}

@Entity menandai class sebagai entitas JPA, @Id menentukan primary key, @GeneratedValue mengatur auto-increment, dan @Table mengatur nama tabel. Hibernate akan membuat schema secara otomatis sesuai konfigurasi ddl-auto.

#Repository dan CRUD Otomatis

#CrudRepository dan JpaRepository

Repository adalah interface yang menangani query. Cukup mendeklarasikan interface yang mewarisi CrudRepository atau JpaRepository, dan Spring Data menyediakan implementasi lengkap operasi CRUD:

public interface ItemRepository extends CrudRepository<Item, Long> {
}

Tanpa menulis satu baris implementasi, repository ini sudah menyediakan method seperti save, findById, findAll, count, dan deleteById. Inilah kekuatan Spring Data: pola-pola yang selalu berulang dibangkitkan otomatis.

#Memakai Repository di Service

Hubungkan repository ke service lewat constructor injection:

@Service
public class ItemService {
 
    private final ItemRepository repository;
 
    public ItemService(ItemRepository repository) {
        this.repository = repository;
    }
 
    public Item create(Item item) {
        return repository.save(item);
    }
 
    public Optional<Item> findById(Long id) {
        return repository.findById(id);
    }
}

Perintah repository.save(item) menyisipkan baris baru atau memperbarui baris yang ada, dan repository.findById(id) mengembalikan Optional yang kosong jika data tidak ditemukan.

#Query Method dan Custom Query

#Query Method Otomatis

Spring Data bisa menurunkan query dari nama method. Contoh: findByNameContaining akan menghasilkan query WHERE name LIKE %value%:

public interface ItemRepository extends CrudRepository<Item, Long> {
 
    List<Item> findByNameContaining(String keyword);
 
    List<Item> findByDescriptionIsNotNullOrderByNameAsc();
}

Aturan pemikirannya sederhana: awali dengan findBy, lalu sebutkan field yang difilter, dan akhiri dengan modifier seperti Containing, OrderBy, atau Between. Daftar lengkap keyword tersedia di Spring Data documentation.

#Custom Query dengan @Query

Untuk query yang kompleks atau memakai native SQL, gunakan @Query:

public interface ItemRepository extends CrudRepository<Item, Long> {
 
    @Query("SELECT i FROM Item i WHERE i.name LIKE %:k%")
    List<Item> cariByName(@Param("k") String keyword);
 
    @Query(value = "SELECT COUNT(*) FROM items WHERE name = :n",
           nativeQuery = true)
    long countByName(@Param("n") String name);
}

Query pertama memakai JPQL — query berorientasi object. Query kedua memakai native SQL langsung ke database. Pilih JPQL untuk portabilitas dan native untuk kasus yang butuh SQL spesifik database.

#Konfigurasi Datasource

#H2 In-Memory untuk Development

Default Spring Boot memakai H2 in-memory — database yang hilang setiap aplikasi berhenti, cocok untuk prototyping. Aktifkan konfigurasi eksplisit dan console H2:

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driver-class-name=org.h2.Driver
spring.jpa.hibernate.ddl-auto=create-drop
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

Setting spring.jpa.hibernate.ddl-auto=create-drop meminta Hibernate membuat schema saat start dan menghapusnya saat berhenti. Console H2 bisa diakses di /h2-console untuk melihat isi database.

#PostgreSQL untuk Produksi

Untuk lingkungan yang lebih nyata, ganti datasource ke PostgreSQL:

spring.datasource.url=jdbc:postgresql://localhost:5432/belajar
spring.datasource.username=belajar
spring.datasource.password=rahasia
spring.jpa.hibernate.ddl-auto=validate
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect

Pada production, gunakan validate agar Hibernate hanya memeriksa schema, tidak mengubahnya. Strategi migrasi schema yang benar dengan Flyway atau Liquibase akan dibahas di episode 10.

#Penutup

Episode 6 membekali kalian dengan akses data menggunakan Spring Data JPA: memetakan tabel dengan @Entity, membuat repository CRUD otomatis lewat CrudRepository, menulis query method dan custom query dengan @Query, serta mengonfigurasi datasource H2 dan PostgreSQL.

Inti yang harus dibawa pulang:

• @Entity memetakan class Java ke tabel database; @Id menandai primary key.
• Repository interface yang mewarisi CrudRepository menyediakan CRUD tanpa implementasi.
• Query method seperti findByNameContaining menurunkan query dari nama method.
• @Query menulis query JPQL atau native SQL secara eksplisit.
• H2 in-memory cocok untuk development; gunakan ddl-auto=create-drop.
• Untuk produksi gunakan PostgreSQL dengan ddl-auto=validate dan migrasi terkelola.

Di episode 7 selanjutnya kita akan membahas validasi dan exception handling — Jakarta Bean Validation dengan @Valid, @NotNull, dan @Size, custom validation annotation, global exception handling dengan @ControllerAdvice dan @ExceptionHandler, serta format error response yang konsisten untuk API kalian.