Tutorial Spring Boot dengan Eclipse: Mengambil List User dari Database MySQL

1. Tujuan

Tutorial ini membahas cara membuat aplikasi Spring Boot menggunakan Eclipse untuk mengambil daftar user dari database MySQL dan menampilkannya melalui REST API dalam format JSON.

2. Versi Software yang Digunakan

3. Arsitektur Sederhana

Alur aplikasi:

Browser / Postman
        ↓
UserController
        ↓
UserService
        ↓
UserRepository
        ↓
MySQL Database

Endpoint yang akan dibuat:

GET http://localhost:8080/api/users

4. Membuat Database MySQL

Masuk ke MySQL:

mysql -u root -p

Buat database:

CREATE DATABASE springboot_user_db;

Gunakan database tersebut:

USE springboot_user_db;

Buat tabel users:

CREATE TABLE users (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) NOT NULL,
    phone VARCHAR(30)
);

Masukkan data contoh:

INSERT INTO users (name, email, phone) VALUES
('Budi Santoso', 'budi@example.com', '08123456789'),
('Siti Aminah', 'siti@example.com', '08234567890'),
('Andi Wijaya', 'andi@example.com', '08345678901');

Cek data:

SELECT * FROM users;

5. Membuat Project Spring Boot di Eclipse

Buka Eclipse, lalu pilih:

File > New > Spring Starter Project

Isi konfigurasi project:

Name        : springboot-mysql-user
Type        : Maven
Java        : 21
Packaging   : Jar
Group       : id.nirantara
Artifact    : springboot-mysql-user
Package     : id.nirantara.springbootmysqluser

Pilih dependency:

Spring Web
Spring Data JPA
MySQL Driver

Klik:

Finish

6. Struktur Project

Struktur project yang akan dibuat:

src/main/java/id/nirantara/springbootmysqluser
├── SpringbootMysqlUserApplication.java
├── controller
│   └── UserController.java
├── entity
│   └── User.java
├── repository
│   └── UserRepository.java
└── service
    └── UserService.java

src/main/resources
└── application.properties

7. Konfigurasi Database

Buka file:

src/main/resources/application.properties

Isi dengan konfigurasi berikut:

spring.application.name=springboot-mysql-user

server.port=8080

spring.datasource.url=jdbc:mysql://localhost:3306/springboot_user_db
spring.datasource.username=root
spring.datasource.password=password_mysql_anda

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

spring.jpa.hibernate.ddl-auto=none
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

Ganti bagian berikut sesuai password MySQL:

spring.datasource.password=password_mysql_anda

Penjelasan:

server.port=8080

Menentukan aplikasi berjalan di port 8080.

spring.datasource.url=jdbc:mysql://localhost:3306/springboot_user_db

Menentukan koneksi ke database MySQL bernama springboot_user_db.

spring.jpa.hibernate.ddl-auto=none

Artinya Spring Boot tidak otomatis membuat atau mengubah struktur tabel.

spring.jpa.show-sql=true

Digunakan agar query SQL terlihat di console.

8. Membuat Entity User

Buat package:

entity

Lalu buat file:

User.java

Isi kode:

package id.nirantara.springbootmysqluser.entity;

import jakarta.persistence.*;

@Entity
@Table(name = "users")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private String email;
    private String phone;

    public User() {
    }

    public User(Long id, String name, String email, String phone) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.phone = phone;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public String getEmail() {
        return email;
    }

    public String getPhone() {
        return phone;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }
}

Penjelasan:

@Entity

Menandakan bahwa class User adalah entity JPA.

@Table(name = "users")

Menandakan bahwa entity ini terhubung dengan tabel users.

@Id

Menandakan bahwa field id adalah primary key.

@GeneratedValue(strategy = GenerationType.IDENTITY)

Menandakan bahwa nilai id dibuat otomatis oleh MySQL menggunakan auto increment.

9. Membuat Repository

Buat package:

repository

Lalu buat file:

UserRepository.java

Isi kode:

package id.nirantara.springbootmysqluser.repository;

import id.nirantara.springbootmysqluser.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}

Penjelasan:

JpaRepository<User, Long>

Artinya repository ini digunakan untuk entity User dengan primary key bertipe Long.

Dengan JpaRepository, kita otomatis mendapat banyak method bawaan, seperti:

findAll()
findById()
save()
deleteById()

Pada tutorial ini, method yang digunakan adalah:

findAll()

untuk mengambil seluruh data user dari database.

10. Membuat Service

Buat package:

service

Lalu buat file:

UserService.java

Isi kode:

package id.nirantara.springbootmysqluser.service;

import id.nirantara.springbootmysqluser.entity.User;
import id.nirantara.springbootmysqluser.repository.UserRepository;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {

    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }
}

Penjelasan:

@Service

Menandakan bahwa class ini berisi logic aplikasi.

private final UserRepository userRepository;

Digunakan untuk mengakses repository.

userRepository.findAll()

Digunakan untuk mengambil seluruh data dari tabel users.

11. Membuat Controller

Buat package:

controller

Lalu buat file:

UserController.java

Isi kode:

package id.nirantara.springbootmysqluser.controller;

import id.nirantara.springbootmysqluser.entity.User;
import id.nirantara.springbootmysqluser.service.UserService;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/users")
public class UserController {

    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping
    public List<User> getUsers() {
        return userService.getAllUsers();
    }
}

Penjelasan:

@RestController

Menandakan bahwa class ini adalah REST API controller.

@RequestMapping("/api/users")

Menentukan alamat utama endpoint.

@GetMapping

Menangani request HTTP GET.

Method berikut:

public List<User> getUsers()

akan mengembalikan daftar user dalam format JSON.

12. File Main Application

File ini biasanya otomatis dibuat oleh Spring Boot:

package id.nirantara.springbootmysqluser;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringbootMysqlUserApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootMysqlUserApplication.class, args);
    }
}

Penjelasan:

@SpringBootApplication

Menandakan class utama aplikasi Spring Boot.

SpringApplication.run(...)

Digunakan untuk menjalankan aplikasi.

13. File pom.xml

Pastikan dependency berikut ada di file pom.xml:

<dependencies>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
        <scope>runtime</scope>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>

</dependencies>

Jika ingin menentukan versi Spring Boot, lihat bagian parent pada pom.xml:

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.5.x</version>
    <relativePath/>
</parent>

14. Menjalankan Aplikasi di Eclipse

Klik kanan pada file:

SpringbootMysqlUserApplication.java

Pilih:

Run As > Java Application

Jika berhasil, console akan menampilkan aplikasi berjalan di port 8080.

Contoh log:

Tomcat started on port 8080
Started SpringbootMysqlUserApplication

15. Testing API

Buka browser atau Postman:

http://localhost:8080/api/users

Contoh response:

[
  {
    "id": 1,
    "name": "Budi Santoso",
    "email": "budi@example.com",
    "phone": "08123456789"
  },
  {
    "id": 2,
    "name": "Siti Aminah",
    "email": "siti@example.com",
    "phone": "08234567890"
  },
  {
    "id": 3,
    "name": "Andi Wijaya",
    "email": "andi@example.com",
    "phone": "08345678901"
  }
]

16. Error yang Sering Terjadi

16.1 Access denied for user

Penyebab:

Username atau password MySQL salah.

Solusi:

spring.datasource.username=root
spring.datasource.password=password_yang_benar

16.2 Unknown database

Penyebab:

Database belum dibuat atau nama database salah.

Solusi:

CREATE DATABASE springboot_user_db;

16.3 Table users doesn't exist

Penyebab:

Tabel users belum dibuat.

Solusi:

CREATE TABLE users (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) NOT NULL,
    phone VARCHAR(30)
);

16.4 Port 8080 sudah digunakan

Penyebab:

Ada aplikasi lain yang sedang berjalan di port 8080.

Solusi:

server.port=8081

Lalu akses:

http://localhost:8081/api/users

16.5 Driver MySQL tidak ditemukan

Penyebab:

Dependency MySQL Connector/J belum ada.

Solusi:

Pastikan dependency ini ada di pom.xml:

<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <scope>runtime</scope>
</dependency>

17. Kesimpulan

Dengan Spring Boot, Eclipse, MySQL, Spring Data JPA, dan REST Controller, kita bisa membuat API sederhana untuk mengambil list user dari database MySQL.

Komponen utama yang digunakan:

Entity      : Representasi tabel database
Repository  : Akses database
Service     : Logic aplikasi
Controller  : Endpoint REST API
Database    : Penyimpanan data user

Endpoint akhir:

GET http://localhost:8080/api/users

Response yang dihasilkan berupa JSON berisi daftar user dari database MySQL.