Tutorial Spring Boot dari Awal dengan PostgreSQL dan IntelliJ IDEA

1. Tujuan Tutorial

Tutorial ini membahas cara membuat aplikasi Spring Boot dari awal menggunakan:

Java
Spring Boot
Maven
PostgreSQL
IntelliJ IDEA
Spring Web
Spring Data JPA
REST API
Test koneksi database PostgreSQL
CRUD sederhana

Target akhirnya adalah membuat API sederhana untuk data users.

Contoh endpoint:

GET    /api/users
GET    /api/users/{id}
POST   /api/users
PUT    /api/users/{id}
DELETE /api/users/{id}

2. Persiapan Instalasi

2.1 Install Java JDK

Spring Boot modern membutuhkan Java versi 17 atau lebih baru.

Cek apakah Java sudah terinstall:

java -version

Jika belum ada, install JDK.

Ubuntu / Debian

sudo apt update
sudo apt install openjdk-17-jdk -y

Cek versi:

java -version

AlmaLinux / Rocky Linux / RHEL

sudo dnf install java-17-openjdk java-17-openjdk-devel -y

Cek versi:

java -version

Windows

Install JDK dari salah satu pilihan berikut:

Eclipse Temurin JDK
Oracle JDK
Amazon Corretto
Microsoft Build of OpenJDK

Setelah install, cek dari Command Prompt:

java -version

2.2 Install Maven

Maven digunakan untuk build project dan mengelola dependency.

Cek Maven:

mvn -version

Ubuntu / Debian

sudo apt install maven -y

AlmaLinux / Rocky Linux / RHEL

sudo dnf install maven -y

Windows

Bisa install Maven manual atau gunakan Maven bawaan IntelliJ IDEA.

Untuk pemula, Maven bawaan IntelliJ sudah cukup.

2.3 Install PostgreSQL

Ubuntu / Debian

sudo apt update
sudo apt install postgresql postgresql-contrib -y

Cek service:

sudo systemctl status postgresql

Aktifkan service:

sudo systemctl enable postgresql
sudo systemctl start postgresql

AlmaLinux / Rocky Linux / RHEL

sudo dnf install postgresql-server postgresql-contrib -y

Inisialisasi database:

sudo postgresql-setup --initdb

Aktifkan service:

sudo systemctl enable postgresql
sudo systemctl start postgresql

Windows

Download PostgreSQL installer, lalu install seperti aplikasi biasa.

Saat install, biasanya diminta membuat password untuk user:

postgres

Simpan password tersebut karena akan dipakai di Spring Boot.

2.4 Install IntelliJ IDEA

Gunakan salah satu:

IntelliJ IDEA Community Edition
IntelliJ IDEA Ultimate

Untuk development Spring Boot, Ultimate lebih lengkap, tetapi Community Edition tetap bisa digunakan untuk project Maven Spring Boot biasa.

3. Setup Database PostgreSQL

3.1 Masuk ke PostgreSQL

Di Linux:

sudo -u postgres psql

Di Windows, bisa pakai:

psql -U postgres

Atau gunakan pgAdmin.

3.2 Buat Database dan User

Jalankan query berikut di PostgreSQL:

CREATE DATABASE springboot_demo;

CREATE USER springuser WITH PASSWORD 'springpass';

GRANT ALL PRIVILEGES ON DATABASE springboot_demo TO springuser;

Keluar dari PostgreSQL:

\q

Coba login menggunakan user yang baru dibuat:

psql -U springuser -d springboot_demo -h localhost

Jika berhasil, berarti database sudah siap.

4. Membuat Project Spring Boot di IntelliJ IDEA

4.1 Buat Project Baru

Buka IntelliJ IDEA, lalu pilih:

New Project

Pilih:

Spring Boot

Jika menggunakan Spring Initializr, isi konfigurasi seperti berikut:

Language    : Java
Build Tool  : Maven
Group       : com.example
Artifact    : springboot-postgres-demo
Name        : springboot-postgres-demo
Package     : com.example.springbootpostgresdemo
Java        : 17 atau lebih baru
Packaging   : Jar

4.2 Pilih Dependency

Tambahkan dependency berikut:

Spring Web
Spring Data JPA
PostgreSQL Driver
Validation
Lombok

Penjelasan singkat:

Dependency	Fungsi
Spring Web	Membuat REST API
Spring Data JPA	Akses database dengan repository
PostgreSQL Driver	Koneksi ke PostgreSQL
Validation	Validasi request body
Lombok	Mengurangi boilerplate getter/setter

Klik:

Create

5. Struktur Project

Struktur project kira-kira seperti ini:

springboot-postgres-demo
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com.example.springbootpostgresdemo
│   │   │       ├── SpringbootPostgresDemoApplication.java
│   │   │       ├── controller
│   │   │       ├── entity
│   │   │       ├── repository
│   │   │       └── service
│   │   └── resources
│   │       ├── application.properties
│   │       └── static
│   └── test
├── pom.xml

6. Konfigurasi PostgreSQL di Spring Boot

Buka file:

src/main/resources/application.properties

Isi dengan konfigurasi berikut:

spring.application.name=springboot-postgres-demo

server.port=8080

spring.datasource.url=jdbc:postgresql://localhost:5432/springboot_demo
spring.datasource.username=springuser
spring.datasource.password=springpass
spring.datasource.driver-class-name=org.postgresql.Driver

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

spring.jpa.database-platform=org.hibernate.dialect.PostgreSQLDialect

Penjelasan:

Properti	Fungsi
`server.port=8080`	Aplikasi jalan di port 8080
`spring.datasource.url`	URL koneksi PostgreSQL
`spring.datasource.username`	Username database
`spring.datasource.password`	Password database
`spring.jpa.hibernate.ddl-auto=update`	Table otomatis dibuat/update
`spring.jpa.show-sql=true`	Query SQL ditampilkan di console

Untuk development, ddl-auto=update masih aman.

Untuk production, sebaiknya gunakan migration tool seperti Flyway atau Liquibase.

7. Membuat Entity User

Buat package:

entity

Buat file:

User.java

Isi:

package com.example.springbootpostgresdemo.entity;

import jakarta.persistence.*;
import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotBlank;
import lombok.Data;

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

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

    @NotBlank(message = "Nama tidak boleh kosong")
    @Column(nullable = false)
    private String name;

    @Email(message = "Format email tidak valid")
    @NotBlank(message = "Email tidak boleh kosong")
    @Column(nullable = false, unique = true)
    private String email;
}

Penjelasan:

Annotation	Fungsi
`@Entity`	Class ini menjadi table database
`@Table(name = "users")`	Nama table adalah `users`
`@Id`	Primary key
`@GeneratedValue`	ID otomatis
`@Column`	Konfigurasi kolom
`@NotBlank`	Validasi tidak boleh kosong
`@Email`	Validasi format email

8. Membuat Repository

Buat package:

repository

Buat file:

UserRepository.java

Isi:

package com.example.springbootpostgresdemo.repository;

import com.example.springbootpostgresdemo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.Optional;

public interface UserRepository extends JpaRepository<User, Long> {

    Optional<User> findByEmail(String email);
}

Dengan JpaRepository, kita otomatis punya method:

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

9. Membuat Service

Buat package:

service

Buat file:

UserService.java

Isi:

package com.example.springbootpostgresdemo.service;

import com.example.springbootpostgresdemo.entity.User;
import com.example.springbootpostgresdemo.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();
    }

    public User getUserById(
            Long id
    ) {
        return userRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("User tidak ditemukan"));
    }

    public User createUser(
            User user
    ) {
        return userRepository.save(user);
    }

    public User updateUser(
            Long id,
            User request
    ) {
        User user = getUserById(id);

        user.setName(request.getName());
        user.setEmail(request.getEmail());

        return userRepository.save(user);
    }

    public void deleteUser(
            Long id
    ) {
        User user = getUserById(id);

        userRepository.delete(user);
    }
}

10. Membuat Controller REST API

Buat package:

controller

Buat file:

UserController.java

Isi:

package com.example.springbootpostgresdemo.controller;

import com.example.springbootpostgresdemo.entity.User;
import com.example.springbootpostgresdemo.service.UserService;
import jakarta.validation.Valid;
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> getAllUsers() {
        return userService.getAllUsers();
    }

    @GetMapping("/{id}")
    public User getUserById(
            @PathVariable Long id
    ) {
        return userService.getUserById(id);
    }

    @PostMapping
    public User createUser(
            @Valid @RequestBody User user
    ) {
        return userService.createUser(user);
    }

    @PutMapping("/{id}")
    public User updateUser(
            @PathVariable Long id,
            @Valid @RequestBody User user
    ) {
        return userService.updateUser(id, user);
    }

    @DeleteMapping("/{id}")
    public String deleteUser(
            @PathVariable Long id
    ) {
        userService.deleteUser(id);

        return "User berhasil dihapus";
    }
}

11. Menjalankan Aplikasi dari IntelliJ IDEA

11.1 Jalankan dari Main Class

Buka file:

SpringbootPostgresDemoApplication.java

Isinya kira-kira:

package com.example.springbootpostgresdemo;

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

@SpringBootApplication
public class SpringbootPostgresDemoApplication {

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

Klik tombol hijau di samping method main.

Atau klik kanan file tersebut, lalu pilih:

Run SpringbootPostgresDemoApplication

Jika berhasil, console akan menampilkan log seperti:

Started SpringbootPostgresDemoApplication
Tomcat started on port 8080

12. Test Koneksi Database PostgreSQL

Saat aplikasi dijalankan, Spring Boot akan mencoba koneksi ke PostgreSQL.

Jika koneksi berhasil, akan muncul log Hibernate dan table otomatis dibuat.

Cek table di PostgreSQL:

psql -U springuser -d springboot_demo -h localhost

Lalu jalankan:

\dt

Harusnya muncul table:

users

Cek struktur table:

\d users

13. Test API Menggunakan Curl

13.1 Create User

curl -X POST http://localhost:8080/api/users \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Budi",
    "email": "budi@example.com"
  }'

Contoh response:

{
  "id": 1,
  "name": "Budi",
  "email": "budi@example.com"
}

13.2 Get Semua User

curl http://localhost:8080/api/users

Contoh response:

[
  {
    "id": 1,
    "name": "Budi",
    "email": "budi@example.com"
  }
]

13.3 Get User Berdasarkan ID

curl http://localhost:8080/api/users/1

13.4 Update User

curl -X PUT http://localhost:8080/api/users/1 \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Budi Santoso",
    "email": "budi.santoso@example.com"
  }'

13.5 Delete User

curl -X DELETE http://localhost:8080/api/users/1

14. Test API Menggunakan Postman

Selain curl, bisa juga pakai Postman.

14.1 POST User

Method:

POST

URL:

http://localhost:8080/api/users

Body:

{
  "name": "Andi",
  "email": "andi@example.com"
}

Header:

Content-Type: application/json

14.2 GET Users

Method:

GET

URL:

http://localhost:8080/api/users

15. Test Langsung dari PostgreSQL

Masuk ke database:

psql -U springuser -d springboot_demo -h localhost

Cek data:

SELECT * FROM users;

Contoh hasil:

 id | name | email
----+------+------------------
  1 | Budi | budi@example.com

16. Membuat Health Check Database

Agar lebih mudah mengecek apakah aplikasi bisa konek ke database, buat endpoint khusus.

Buat file:

DatabaseTestController.java

Di package:

controller

Isi:

package com.example.springbootpostgresdemo.controller;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DatabaseTestController {

    private final JdbcTemplate jdbcTemplate;

    public DatabaseTestController(
            JdbcTemplate jdbcTemplate
    ) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @GetMapping("/api/db-test")
    public String testDatabase() {
        Integer result = jdbcTemplate.queryForObject(
                "SELECT 1",
                Integer.class
        );

        return "Database connected. Result: " + result;
    }
}

Lalu test:

curl http://localhost:8080/api/db-test

Jika berhasil:

Database connected. Result: 1

17. Tambahkan Dependency JDBC jika Dibutuhkan

Biasanya JdbcTemplate sudah tersedia jika menggunakan starter tertentu. Jika belum, tambahkan dependency ini di pom.xml:

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

Lalu reload Maven di IntelliJ:

Maven > Reload All Maven Projects

18. Contoh pom.xml Lengkap

Contoh pom.xml:

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="
            http://maven.apache.org/POM/4.0.0
            https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

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

    <groupId>com.example</groupId>
    <artifactId>springboot-postgres-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-postgres-demo</name>
    <description>Demo Spring Boot PostgreSQL</description>

    <properties>
        <java.version>17</java.version>
    </properties>

    <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>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>

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

        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

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

    </dependencies>

    <build>
        <plugins>

            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>

        </plugins>
    </build>

</project>

Catatan:

Jika membuat project dari Spring Initializr, biasanya pom.xml sudah otomatis dibuat. Anda cukup memastikan dependency yang dibutuhkan sudah ada.

19. Membuat Unit Test Koneksi Database

Buka folder:

src/test/java

Buat file:

DatabaseConnectionTest.java

Isi:

package com.example.springbootpostgresdemo;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.jdbc.core.JdbcTemplate;

import static org.junit.jupiter.api.Assertions.assertEquals;

@SpringBootTest
public class DatabaseConnectionTest {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Test
    void testDatabaseConnection() {
        Integer result = jdbcTemplate.queryForObject(
                "SELECT 1",
                Integer.class
        );

        assertEquals(1, result);
    }
}

Jalankan test dari IntelliJ:

Klik kanan file test > Run DatabaseConnectionTest

Jika sukses, berarti Spring Boot bisa konek ke PostgreSQL saat test berjalan.

20. Error yang Sering Muncul

20.1 Password Authentication Failed

Error:

password authentication failed for user "springuser"

Penyebab:

Password salah
User database belum dibuat
Konfigurasi application.properties salah

Solusi:

Cek ulang:

spring.datasource.username=springuser
spring.datasource.password=springpass

Coba login manual:

psql -U springuser -d springboot_demo -h localhost

20.2 Connection Refused

Error:

Connection refused

Penyebab:

PostgreSQL belum berjalan
Port salah
Host salah

Solusi:

Cek service PostgreSQL:

sudo systemctl status postgresql

Start PostgreSQL:

sudo systemctl start postgresql

Pastikan port default PostgreSQL:

20.3 Database Does Not Exist

Error:

database "springboot_demo" does not exist

Solusi:

Masuk PostgreSQL:

sudo -u postgres psql

Buat database:

CREATE DATABASE springboot_demo;

20.4 Relation Users Does Not Exist

Error:

relation "users" does not exist

Penyebab:

Table belum dibuat
Entity belum terbaca
ddl-auto tidak aktif

Solusi:

Pastikan ada:

spring.jpa.hibernate.ddl-auto=update

Pastikan class entity ada annotation:

@Entity
@Table(name = "users")

20.5 Lombok Tidak Jalan di IntelliJ

Gejala:

Cannot resolve method getName()
Cannot resolve method setName()

Solusi:

Aktifkan annotation processing:

Settings
> Build, Execution, Deployment
> Compiler
> Annotation Processors
> Enable annotation processing

Atau install plugin Lombok jika belum ada.

21. Menjalankan Aplikasi dari Terminal

Selain dari IntelliJ, aplikasi juga bisa dijalankan dari terminal.

Masuk ke folder project:

cd springboot-postgres-demo

Jalankan:

mvn spring-boot:run

Atau build jar:

mvn clean package

Jalankan file jar:

java -jar target/springboot-postgres-demo-0.0.1-SNAPSHOT.jar

22. Best Practice Development

22.1 Jangan Simpan Password di Git

Untuk development lokal masih boleh di application.properties.

Tapi untuk production, gunakan environment variable.

Contoh:

spring.datasource.url=${DB_URL}
spring.datasource.username=${DB_USERNAME}
spring.datasource.password=${DB_PASSWORD}

Jalankan aplikasi:

DB_URL=jdbc:postgresql://localhost:5432/springboot_demo \
DB_USERNAME=springuser \
DB_PASSWORD=springpass \
mvn spring-boot:run

22.2 Pisahkan Layer

Struktur yang rapi:

controller -> menerima request
service    -> logic aplikasi
repository -> akses database
entity     -> mapping table database

Jangan menaruh logic bisnis terlalu banyak di controller.

22.3 Gunakan DTO untuk Project Serius

Untuk project sederhana, langsung memakai entity di request masih oke.

Untuk project serius, sebaiknya gunakan DTO.

Contoh struktur:

dto
├── UserRequest.java
└── UserResponse.java

Tujuannya agar struktur API tidak terlalu bergantung langsung ke struktur table database.

22.4 Gunakan Migration Tool

Untuk production, jangan mengandalkan:

spring.jpa.hibernate.ddl-auto=update

Lebih baik gunakan:

Flyway
Liquibase

Contoh production:

spring.jpa.hibernate.ddl-auto=validate

23. Ringkasan Alur Development

Alur kerja umum development Spring Boot dengan PostgreSQL:

1. Install Java
2. Install Maven
3. Install PostgreSQL
4. Buat database dan user
5. Buat project Spring Boot di IntelliJ
6. Tambahkan dependency Spring Web, JPA, PostgreSQL
7. Konfigurasi application.properties
8. Buat Entity
9. Buat Repository
10. Buat Service
11. Buat Controller
12. Jalankan aplikasi
13. Test API
14. Cek data di PostgreSQL
15. Tambahkan unit test koneksi database

24. Checklist Berhasil

Project dianggap berhasil jika:

Aplikasi Spring Boot bisa running di port 8080
Tidak ada error koneksi PostgreSQL
Table users otomatis dibuat
Endpoint /api/users bisa diakses
Data bisa insert ke PostgreSQL
Data bisa dibaca dari PostgreSQL
Endpoint /api/db-test menghasilkan Database connected
Unit test database berhasil

25. Endpoint Akhir

Daftar endpoint:

GET    http://localhost:8080/api/users
GET    http://localhost:8080/api/users/1
POST   http://localhost:8080/api/users
PUT    http://localhost:8080/api/users/1
DELETE http://localhost:8080/api/users/1
GET    http://localhost:8080/api/db-test

26. Contoh Request Body

Untuk create dan update user:

{
  "name": "Budi",
  "email": "budi@example.com"
}

27. Penutup

Dengan tutorial ini, Anda sudah memiliki pondasi dasar untuk membuat aplikasi backend menggunakan Spring Boot dan PostgreSQL.

Materi yang sudah dipelajari:

Setup Java
Setup PostgreSQL
Membuat project Spring Boot di IntelliJ IDEA
Konfigurasi koneksi database
Membuat entity
Membuat repository
Membuat service
Membuat REST controller
Menjalankan aplikasi
Test API
Test koneksi database
Unit test sederhana

Setelah ini, pengembangan bisa dilanjutkan ke:

Login dan JWT
Role user
Pagination
Search API
Upload file
Global exception handler
DTO dan mapper
Flyway migration
Docker Compose
Deployment ke server

Tutorial Spring Boot dari Awal dengan PostgreSQL dan IntelliJ IDEA

Tutorial Spring Boot dari Awal dengan PostgreSQL dan IntelliJ IDEA

1. Tujuan Tutorial

2. Persiapan Instalasi

2.1 Install Java JDK

Ubuntu / Debian

AlmaLinux / Rocky Linux / RHEL

Windows

2.2 Install Maven

Ubuntu / Debian

AlmaLinux / Rocky Linux / RHEL

Windows

2.3 Install PostgreSQL

Ubuntu / Debian

AlmaLinux / Rocky Linux / RHEL

Windows

2.4 Install IntelliJ IDEA

3. Setup Database PostgreSQL

3.1 Masuk ke PostgreSQL

3.2 Buat Database dan User

3.3 Test Login Database

4. Membuat Project Spring Boot di IntelliJ IDEA

4.1 Buat Project Baru

4.2 Pilih Dependency

5. Struktur Project

6. Konfigurasi PostgreSQL di Spring Boot

7. Membuat Entity User

8. Membuat Repository

9. Membuat Service

10. Membuat Controller REST API

11. Menjalankan Aplikasi dari IntelliJ IDEA

11.1 Jalankan dari Main Class

12. Test Koneksi Database PostgreSQL

13. Test API Menggunakan Curl

13.1 Create User

13.2 Get Semua User

13.3 Get User Berdasarkan ID

13.4 Update User

13.5 Delete User

14. Test API Menggunakan Postman

14.1 POST User

14.2 GET Users

15. Test Langsung dari PostgreSQL

16. Membuat Health Check Database

17. Tambahkan Dependency JDBC jika Dibutuhkan

18. Contoh pom.xml Lengkap

19. Membuat Unit Test Koneksi Database

20. Error yang Sering Muncul

20.1 Password Authentication Failed

20.2 Connection Refused

20.3 Database Does Not Exist

20.4 Relation Users Does Not Exist

20.5 Lombok Tidak Jalan di IntelliJ

21. Menjalankan Aplikasi dari Terminal

22. Best Practice Development

22.1 Jangan Simpan Password di Git

22.2 Pisahkan Layer

22.3 Gunakan DTO untuk Project Serius

22.4 Gunakan Migration Tool

23. Ringkasan Alur Development

24. Checklist Berhasil

25. Endpoint Akhir

26. Contoh Request Body

27. Penutup

Published by Nirantara

Related Articles

Learn more about Nirantara