Kursus Lengkap Backend Developer dengan Java (MVC +

Spring Boot)
Level: Pemula → Menengah → Siap Produksi

Komponen kursus: Teori, Source Code Lengkap, Latihan, dan Best Practice untuk setiap modul (0–20).
Modul 0 — Orientasi & Setup Lingkungan
Tujuan Modul
• Memahami peran backend dan arsitektur umum.

• Menyiapkan JDK 17/21, Maven/Gradle, IDE, dan Git.

• Menjalankan program Java pertama dan membuat repo Git.

Kenapa Penting
• Fondasi alat yang benar menghindari hambatan teknis saat belajar.

• Standarisasi versi (LTS) meningkatkan stabilitas dan kompatibilitas.

Teori Inti
• Arsitektur: Client ↔ API ↔ Service ↔ DB ↔ Cache ↔ Message Broker ↔ Observability.

• HTTP dasar (method, status) dan JSON sebagai format pertukaran data.

• Git workflow (commit kecil, pesan jelas, branch feature).

Contoh Kode #1
// src/main/java/com/example/hello/[Link]
package [Link];
public class Hello {
public static void main(String[] args) {
[Link]("Hello, Backend!");
}
}

Contoh Kode #2
<!-- [Link] -->
<project xmlns="[Link]
xmlns:xsi="[Link]
xsi:schemaLocation="[Link] [Link]
<modelVersion>4.0.0</modelVersion>
<groupId>[Link]</groupId>
<artifactId>hello-backend</artifactId>
<version>0.0.1-SNAPSHOT</version>
<properties>
<[Link]>17</[Link]>
<[Link]>17</[Link]>
</properties>
</project>

Latihan / Praktikum
1. Instal JDK 17/21 dan verifikasi dengan `java -version`.

2. Buat project Maven minimal dan jalankan kelas Hello.

3. Inisialisasi Git repo; buat .gitignore untuk Java + Maven.

Best Practices
• Pakai versi LTS (Java 17/21).

• Pisahkan profil environment (dev/stage/prod).

• Commit sering dengan pesan bermakna.

Checklist Kelulusan Modul
[ ] Perintah `java -version` dan `mvn -v` berjalan.

[ ] Project build sukses (`mvn clean package`).

[ ] Repo Git tersetup dengan .gitignore yang benar.

Modul 1 — Java Fundamental (Variabel, Tipe Data,
Operator, Control Flow)
Tujuan Modul
• Menguasai sintaks dasar Java dan tipe data primitif.

• Membuat program console interaktif dengan percabangan dan perulangan.

Kenapa Penting
• Sintaks dasar adalah pondasi semua fitur lanjut.

• Kontrol alur menentukan logika bisnis yang benar.

Teori Inti
• Tipe data: byte, short, int, long, float, double, char, boolean.

• Operator aritmatika, relasional, logika, assignment.

• Percabangan (if/else, switch) dan perulangan (for/while/do-while).

Contoh Kode #1
// Variabel dan operasi dasar
public class Basics {
public static void main(String[] args) {
int a = 10;
int b = 3;
int sum = a + b;
boolean isGreater = a > b;
[Link]("Sum = " + sum + ", a>b? " + isGreater);
}
}

Contoh Kode #2
// Loop dan kondisi
public class Looping {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
if (i % 2 == 0) [Link](i + " genap");
else [Link](i + " ganjil");
}
}
}

Latihan / Praktikum
1. Buat kalkulator CLI (+, -, *, /) dengan input dari argumen.

2. Cetak deret Fibonacci sampai N menggunakan loop.

3. Buat menu interaktif sederhana dengan switch-case.

Best Practices
• Gunakan nama variabel yang deskriptif.

• Hindari angka ajaib; gunakan konstanta.

• Pisahkan logika ke method kecil (single responsibility).

Checklist Kelulusan Modul
[ ] Kalkulator CLI berjalan dengan benar.

[ ] Program loop dan kondisi menghasilkan output yang diharapkan.

Modul 2 — OOP Dasar (Class, Object, Encapsulation) &
Collections
Tujuan Modul
• Membuat class dengan field dan method yang rapi.

• Menggunakan List, Set, Map untuk mengelola data.

Kenapa Penting
• OOP memudahkan pemodelan domain nyata.

• Collections efisien untuk operasi CRUD di memori.

Teori Inti
• Encapsulation via private field dan getter/setter.

• List vs Set vs Map dan kapan menggunakannya.

• Equals/hashCode dan ordering (Comparable/Comparator).

Contoh Kode #1
// Class dan enkapsulasi
public class BankAccount {
private String owner;
private long balance;
public BankAccount(String owner) { [Link] = owner; }
public void deposit(long amount) { [Link] += amount; }
public boolean withdraw(long amount) {
if (amount > balance) return false;
[Link] -= amount; return True;
}
public long getBalance() { return balance; }
public String getOwner() { return owner; }
}

Contoh Kode #2
// Collections dasar
import [Link].*;
public class CollectionsDemo {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
[Link]("Ana"); [Link]("Budi"); [Link]("Ana"); // duplikat boleh di List
Set<String> uniq = new HashSet<>(names); // duplikat hilang
Map<String,Integer> score = new HashMap<>();
[Link]("Ana", 90); [Link]("Budi", 80);
[Link](names); [Link](uniq); [Link](score);
}
}

Latihan / Praktikum
1. Implementasikan kelas `User` dengan equals/hashCode berdasar email.

2. Kelola daftar rekening bank dalam List, hilangkan duplikat pemilik dengan Set.

Best Practices
• Tulis equals/hashCode konsisten bila dipakai di koleksi.

• Pilih struktur data sesuai kebutuhan (lookup cepat → Map).

Checklist Kelulusan Modul
[ ] Unit kecil untuk BankAccount dan CollectionsDemo berjalan.
Modul 3 — Exception Handling, Generics, Stream API
Tujuan Modul
• Menangani error dengan try/catch dan membuat custom exception.

• Menggunakan generics dan Stream untuk pemrosesan data deklaratif.

Kenapa Penting
• Error tak tertangani menyebabkan crash; handler global diperlukan.

• Stream meningkatkan keterbacaan dan mengurangi boilerplate.

Teori Inti
• Checked vs unchecked exception, finally, try-with-resources.

• Generic type parameter dan manfaatnya.

• Stream pipeline: map, filter, reduce, collect.

Contoh Kode #1
// Custom exception
class InsufficientBalanceException extends RuntimeException {
public InsufficientBalanceException(String msg) { super(msg); }
}

Contoh Kode #2
// Stream API contoh sederhana
import [Link].*;
import [Link];
public class StreamExample {
public static void main(String[] args) {
List<Integer> nums = [Link](1,2,3,4,5,6);
List<Integer> evensSquared = [Link]()
.filter(n -> n % 2 == 0)
.map(n -> n * n)
.collect([Link]());
[Link](evensSquared);
}
}

Latihan / Praktikum
1. Buat util membaca file CSV lalu filter baris tertentu dengan Stream.

2. Tambahkan unit test untuk skenario exception.

Best Practices
• Tangani exception pada lapisan yang tepat; jangan menelan error.

• Gunakan Optional untuk menghindari NullPointerException.

Checklist Kelulusan Modul

[ ] Custom exception dipakai di jalur error.

[ ] Program Stream menghasilkan output yang benar.

Modul 4 — Database: SQL Dasar, Desain Skema, dan
JDBC
Tujuan Modul
• Menguasai CRUD SQL dan constraint dasar.

• Terkoneksi ke database via JDBC.

Kenapa Penting
• Data persisten kunci aplikasi backend.

• Validasi di level DB mencegah korupsi data.

Teori Inti
• DDL vs DML, primary key, foreign key, unique, index.

• Normalisasi ringkas (1NF–3NF) dan trade-off performa.

• Connection pool konsep singkat.

Contoh Kode #1
-- Skema sederhana
CREATE TABLE users (
id BIGSERIAL PRIMARY KEY,
email VARCHAR(255) UNIQUE NOT NULL,
password_hash VARCHAR(255) NOT NULL,
roles VARCHAR(100) NOT NULL,
created_at TIMESTAMP NOT NULL DEFAULT now()
);

Contoh Kode #2
// JDBC koneksi (contoh singkat)
import [Link].*;
public class JdbcDemo {
public static void main(String[] args) throws Exception {
String url = "jdbc:postgresql://localhost:5432/app";
try (Connection c = [Link](url, "user", "pass");
PreparedStatement ps = [Link]("select 1")) {
ResultSet rs = [Link]();
while ([Link]()) [Link]([Link](1));
}
}
}

Latihan / Praktikum
1. Buat tabel banks dan accounts dengan relasi FK.

2. Tulis program CLI untuk insert & list users via JDBC.

Best Practices
• Selalu gunakan PreparedStatement (hindari SQL injection).

• Index kolom yang sering dipakai filter/unique.

Checklist Kelulusan Modul

[ ] Schema dibuat dan diuji dengan perintah SQL.
[ ] Program JDBC berhasil terhubung.
Modul 5 — Spring & Spring Boot Dasar (IoC/DI, Starter,
Struktur Proyek)
Tujuan Modul
• Memahami bean, IoC container, dan dependency injection.

• Membuat aplikasi Spring Boot pertama dengan health endpoint.

Kenapa Penting
• IoC/DI membuat kode mudah diuji dan dirawat.

• Spring Boot mempercepat setup dengan auto-configuration.

Teori Inti
• Bean lifecycle singkat, stereotype annotation (@Component/@Service).

• [Link] dan profile (dev/prod).

• Struktur paket: controller, service, repository, dto, config, exception.

Contoh Kode #1
// Aplikasi Spring Boot
@SpringBootApplication
public class AppApplication {
public static void main(String[] args) {
[Link]([Link], args);
}
}

Contoh Kode #2
// Controller sederhana
@RestController
@RequestMapping("/api/health")
public class HealthController {
@GetMapping
public Map<String, Object> health() {
return [Link]("status", "UP", "time", [Link]());
}
}

Latihan / Praktikum
1. Buat endpoint /api/info yang mengembalikan nama aplikasi & versi dari [Link].

2. Tambahkan profile dev & prod dengan port berbeda.

Best Practices
• Gunakan constructor injection, bukan field injection.

• Pisahkan konfigurasi berdasarkan profile.

Checklist Kelulusan Modul

[ ] Aplikasi berjalan dan health endpoint OK.

[ ] Profile dev/prod terkonfigurasi.

Modul 6 — REST API Lengkap dengan DTO & Validasi
Tujuan Modul
• Membuat endpoint CRUD resource menggunakan DTO.

• Menambahkan validasi input dan error handler global.

Kenapa Penting
• DTO menstabilkan kontrak API dan lindungi Entity.

• Error handler global memastikan konsistensi response.

Teori Inti
• Konvensi endpoint, status code (201, 400, 404, 409).

• Bean Validation: @NotBlank, @Email, @Size, custom constraint.

• Global handler dengan @ControllerAdvice.

Contoh Kode #1
// DTO
public record CreateUserRequest(@NotBlank @Email String email,
@NotBlank @Size(min=8) String password) {}
public record UserResponse(Long id, String email, String roles) {}

Contoh Kode #2
// Controller tipis
@RestController @RequestMapping("/api/users")
@RequiredArgsConstructor
public class UserController {
private final UserService service;
@PostMapping
public ResponseEntity<UserResponse> create(@Valid @RequestBody CreateUserRequest req) {
return [Link]([Link]).body([Link](req));
}
}

Contoh Kode #3
// Global Exception Handler
@RestControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler([Link])
ResponseEntity<Map<String,Object>> handleValidation(MethodArgumentNotValidException ex){
var errors = [Link]().getFieldErrors().stream()
.map(f -> [Link]()+": "+[Link]()).toList();
return [Link]().body([Link]("error","VALIDATION","details",errors));
}
}

Latihan / Praktikum
1. Implement CRUD lengkap untuk resource Category (name unik per user).

2. Tambahkan OpenAPI/Swagger dan dokumentasi contoh error.

Best Practices
• Controller tipis, logika di Service, akses data di Repository.
• Jangan expose entity langsung; gunakan DTO.

Checklist Kelulusan Modul

[ ] CRUD users & categories berjalan dengan validasi & error handler.

[ ] Swagger UI menampilkan dokumentasi lengkap.

Modul 7 — Spring Data JPA: Entity, Relasi, Transaksi
Tujuan Modul
• Memetakan entity ke tabel dan mengelola relasi.

• Menangani transaksi di service layer.

Kenapa Penting
• ORM mengurangi boilerplate akses DB.

• Transaksi memastikan konsistensi data saat operasi kompleks.

Teori Inti
• Annotation: @Entity, @Table, @Id, @GeneratedValue.

• Relasi @OneToMany, @ManyToOne (hindari @ManyToMany jika bisa).

• LAZY vs EAGER, N+1 problem, fetch join.

Contoh Kode #1
@Entity @Table(name="users")
public class User {
@Id @GeneratedValue(strategy=[Link]) Long id;
@Column(nullable=false, unique=true) String email;
@Column(nullable=false) String passwordHash;
@Column(nullable=false) String roles;
}

Contoh Kode #2
@Entity @Table(name="categories")
public class Category {
@Id @GeneratedValue(strategy=[Link]) Long id;
@ManyToOne(fetch=[Link]) @JoinColumn(name="user_id")
private User owner;
@Column(nullable=false) String name;
}

Contoh Kode #3
@Service @RequiredArgsConstructor
public class CategoryService {
private final CategoryRepository repo;
@Transactional
public CategoryResponse create(CreateCategoryRequest req, Long userId){
if([Link](userId, [Link]())){
throw new ConflictException("Category already exists");
}
Category c = new Category();
[Link](new User(){{ setId(userId); }});
[Link]([Link]());
return map([Link](c));
}
}

Latihan / Praktikum
1. Buat skema transaksi (Transaction) dan relasi dengan Category & User.

2. Optimalkan query list transaksi agar tidak N+1 (fetch join).

Best Practices
• Gunakan LAZY untuk koleksi; gunakan fetch join saat perlu.

• Transaksi di service, bukan di controller.

Checklist Kelulusan Modul

[ ] Entity & relasi jalan; CRUD tidak memicu N+1 signifikan.
Modul 8 — Security Dasar: Password Hashing,
Authentication Skeleton
Tujuan Modul
• Mengamankan kredensial dengan hashing (BCrypt).

• Membuat kerangka autentikasi dasar.

Kenapa Penting
• Password plaintext berbahaya saat kebocoran.

• Kerangka auth memudahkan penambahan JWT nanti.

Teori Inti
• BCrypt dan alasan memilihnya (salt, adaptive cost).

• Spring Security filter chain konsep.

Contoh Kode #1
@Configuration
public class SecurityConfig {
@Bean PasswordEncoder passwordEncoder(){ return new BCryptPasswordEncoder(); }
@Bean SecurityFilterChain filter(HttpSecurity http) throws Exception {
[Link](csrf -> [Link]())
.authorizeHttpRequests(auth -> auth
.requestMatchers("/api/auth/**", "/v3/api-docs/**","/swagger-ui/**").permitAll()
.anyRequest().authenticated())
.httpBasic();
return [Link]();
}
}

Contoh Kode #2
@Service @RequiredArgsConstructor
public class AuthService {
private final UserRepository users;
private final PasswordEncoder encoder;
public void register(String email, String rawPassword){
if([Link](email)) throw new ConflictException("Email used");
User u = new User(); [Link](email); [Link]([Link](rawPassword)); u.s
[Link](u);
}
}

Latihan / Praktikum
1. Buat endpoint register dan login basic (sementara HTTP Basic).

2. Tambahkan validasi kekuatan password (panjang, karakter).

Best Practices
• Jangan pernah log atau kirim ulang password.

• Gunakan HTTPS dan kebijakan CORS yang ketat.

Checklist Kelulusan Modul

[ ] Register & login bekerja; password tersimpan sebagai hash.
Modul 9 — JWT Authentication & Authorization (RBAC)
Tujuan Modul
• Mengeluarkan dan memverifikasi JWT untuk sesi stateless.

• Memberi peran (role) dan mengamankan endpoint.

Kenapa Penting
• JWT cocok untuk aplikasi terdistribusi dan mobile.

• RBAC menyederhanakan izin per fitur.

Teori Inti
• [Link], HS256 vs RS256.

• Expiration, refresh token, dan revocation strategi.

Contoh Kode #1
// Util JWT ringkas (HS256)
public class JwtUtil {
private final SecretKey key = [Link]([Link]("JWT_SECRET").getBytes(StandardC
public String generate(String subject, Map<String,Object> claims, Duration ttl) {
Instant now = [Link]();
return [Link]()
.setClaims(claims).setSubject(subject)
.setIssuedAt([Link](now))
.setExpiration([Link]([Link](ttl)))
.signWith(key, SignatureAlgorithm.HS256).compact();
}
public Jws<Claims> verify(String token){
return [Link]().setSigningKey(key).build().parseClaimsJws(token);
}
}

Contoh Kode #2
// Filter JWT
public class JwtAuthFilter extends OncePerRequestFilter {
private final JwtUtil jwtUtil; private final UserDetailsService uds;
protected void doFilterInternal(HttpServletRequest req, HttpServletResponse res, FilterChain ch
throws ServletException, IOException {
String h = [Link]("Authorization");
if(h != null && [Link]("Bearer ")) {
String token = [Link](7);
try {
var jws = [Link](token);
String email = [Link]().getSubject();
UserDetails ud = [Link](email);
UsernamePasswordAuthenticationToken auth =
new UsernamePasswordAuthenticationToken(ud, null, [Link]());
[Link]().setAuthentication(auth);
} catch (Exception e) { /* ignore -> unauthorized */ }
}
[Link](req,res);
}
}

Latihan / Praktikum
1. Implement login yang mengembalikan access token JWT.

2. Lindungi endpoint `/api/admin/**` untuk role ADMIN saja.

Best Practices
• Simpan secret di environment/secret manager.

• Tetapkan expiry yang wajar dan sediakan refresh flow.

Checklist Kelulusan Modul

[ ] JWT diterbitkan & diverifikasi; RBAC berjalan.
Modul 10 — Dokumentasi API (OpenAPI/Swagger)
Tujuan Modul
• Menjelaskan kontrak API dengan jelas.

• Memberikan contoh request/response dan error.

Kenapa Penting
• Mempercepat integrasi front-end/mobile.

• Mengurangi miskomunikasi antar tim.

Teori Inti
• springdoc-openapi untuk generasi otomatis.

• Konvensi deskripsi, status code, dan schema error standar.

Contoh Kode #1
<!-- Maven dependency -->
<dependency>
<groupId>[Link]</groupId>
<artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
<version>2.5.0</version>
</dependency>

Contoh Kode #2
@OpenAPIDefinition(info = @Info(title = "MoneyMate API", version = "1.0",
description = "API untuk pengelolaan keuangan"))
@SpringBootApplication
public class App {}

Latihan / Praktikum
1. Lengkapi dokumentasi semua endpoint CRUD dan auth.

2. Tambahkan contoh payload error untuk validasi.

Best Practices
• Samakan nama field antara DTO dan dokumentasi.

• Sertakan parameter pagination & filter dengan jelas.

Checklist Kelulusan Modul

[ ] Swagger UI tampil; spesifikasi OpenAPI bisa diunduh.
Modul 11 — Testing (Unit, Slice, Integration)
Tujuan Modul
• Menulis unit test untuk service dan util.

• Slice test untuk controller/repository, dan integration test ujung-ke-ujung.

Kenapa Penting
• Mengurangi regresi dan meningkatkan kepercayaan saat refactor.

• Mempercepat feedback lewat test otomatis.

Teori Inti
• JUnit 5, Mockito untuk mocking.

• @WebMvcTest, @DataJpaTest, Testcontainers untuk DB nyata.

Contoh Kode #1
// Unit test service (contoh)
@ExtendWith([Link])
class UserServiceTest {
@Mock UserRepository repo; @InjectMocks UserService service;
@Test void create_user_ok(){
when([Link]("a@[Link]")).thenReturn(false);
var res = [Link](new CreateUserRequest("a@[Link]","password123"));
assertNotNull(res);
}
}

Contoh Kode #2
// Controller slice
@WebMvcTest([Link])
class UserControllerTest {
@Autowired MockMvc mvc; @MockBean UserService service;
@Test void post_create_returns_201() throws Exception {
when([Link](any())).thenReturn(new UserResponse(1L,"a@[Link]","USER"));
[Link](post("/api/users").contentType(MediaType.APPLICATION_JSON)
.content("{\"email\":\"a@[Link]\",\"password\":\"password123\"}"))
.andExpect(status().isCreated());
}
}

Latihan / Praktikum
1. Tambahkan integration test end-to-end untuk alur register → login → akses protected endpoint.

2. Gunakan Testcontainers PostgreSQL agar mirip produksi.

Best Practices
• Tes jalur bahagia dan error (boundary & negative cases).

• Gunakan data builder untuk mengurangi duplikasi setup.

Checklist Kelulusan Modul

[ ] Semua test utama hijau di CI.
Modul 12 — Observability: Logging, Metrics, Tracing
Tujuan Modul
• Membuat log terstruktur, metrik kinerja, dan tracing.

• Menambahkan traceId ke response untuk troubleshooting.

Kenapa Penting
• Debug cepat saat insiden produksi.

• Pemantauan proaktif mencegah downtime panjang.

Teori Inti
• SLF4J + Logback, Micrometer + Prometheus, OpenTelemetry tracing.

• Level log yang tepat; hindari log data sensitif.

Contoh Kode #1
// Filter untuk traceId sederhana
@Component
public class TraceFilter implements Filter {
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
throws IOException, ServletException {
String traceId = [Link]().toString();
[Link]("traceId", traceId);
((HttpServletResponse)res).setHeader("X-Trace-Id", traceId);
try { [Link](req, res); } finally { [Link]("traceId"); }
}
}

Latihan / Praktikum
1. Tambahkan counter request per endpoint menggunakan Micrometer.

2. Pastikan traceId ikut tercetak pada setiap log baris.

Best Practices
• Gunakan format JSON untuk log di produksi.

• Sampling tracing agar overhead rendah.

Checklist Kelulusan Modul

[ ] Log, metrics, dan trace tersedia dan terbaca.
Modul 13 — Kinerja: Pagination, Sorting, Caching
Tujuan Modul
• Menghindari response besar dan mempercepat pembacaan data.

• Menambahkan cache baca dengan invalidasi yang aman.

Kenapa Penting
• Pagination mengontrol beban DB.

• Cache mengurangi latency pada data yang sering diakses.

Teori Inti
• Spring Data Pageable & Sort.

• Spring Cache (Caffeine/Redis) dan strategi TTL/invalidasi.

Contoh Kode #1
// Pageable di repository
interface TransactionRepository extends JpaRepository<Transaction, Long> {
Page<Transaction> findByUserId(Long userId, Pageable pageable);
}

Contoh Kode #2
// Cache contoh
@Service @RequiredArgsConstructor
public class BankService {
private final BankRepository repo;
@Cacheable("banks") public List<BankResponse> list(){ return [Link]().stream().map(this::
@CacheEvict(value="banks", allEntries=true) public BankResponse create(CreateBankRequest req){
}

Latihan / Praktikum
1. Tambahkan pagination dan sorting pada /api/transactions.

2. Cache daftar bank dengan TTL 10 menit; invalidasi saat insert/update/delete.

Best Practices
• Selalu sediakan default page & size yang aman.

• Jangan cache data user-spesifik tanpa key yang tepat.

Checklist Kelulusan Modul

[ ] Endpoint list menggunakan pagination; cache bekerja.
Modul 14 — Desain API & Error Handling Konsisten
Tujuan Modul
• Membuat format error yang seragam dan mudah dipakai klien.

• Menetapkan konvensi status code.

Kenapa Penting
• Konsistensi mengurangi kode sisi klien.

• Memudahkan retry & penanganan error otomatis.

Teori Inti
• Format error tunggal (code, message, details, traceId).

• Pemetaan: 400, 401, 403, 404, 409, 422, 500.

Contoh Kode #1
public record ApiError(String code, String message, List<String> details) {}
public record ApiResponse<T>(boolean success, T data, ApiError error, String traceId) {
public static <T> ApiResponse<T> ok(T data){ return new ApiResponse<>(true, data, null, [Link]
public static ApiResponse<?> err(String c, String m, List<String> d){ return new ApiResponse<>(
}

Latihan / Praktikum
1. Pastikan semua exception dipetakan ke error format standar.

2. Tambahkan contoh error di dokumentasi OpenAPI.

Best Practices
• Jangan expose stack trace ke klien.

• Gunakan kode error yang stabil (string enum).

Checklist Kelulusan Modul

[ ] Semua error mengikuti format seragam dengan traceId.
Modul 15 — Arsitektur Aplikasi: Layered vs Hexagonal
Tujuan Modul
• Memahami trade-off desain dan kapan dipakai.

• Menerapkan port & adapter sederhana.

Kenapa Penting
• Isolasi domain memudahkan testing dan perubahan infrastruktur.

Teori Inti
• Layered: Controller→Service→Repository.

• Hexagonal: Domain + Ports (interface) + Adapters (impl).

Contoh Kode #1
// Port
public interface BankPort {
List<Bank> list();
Bank save(Bank bank);
}
// Adapter JPA
@Repository
public class BankJpaAdapter implements BankPort {
private final BankRepository repo;
public BankJpaAdapter(BankRepository repo){ [Link] = repo; }
public List<Bank> list(){ return [Link](); }
public Bank save(Bank bank){ return [Link](bank); }
}

Latihan / Praktikum
1. Abstraksikan akses storage kategori sebagai port.

2. Uji domain tanpa mem-boot konteks Spring.

Best Practices
• Domain tidak bergantung pada framework.

• Boundary jelas antara domain dan infrastruktur.

Checklist Kelulusan Modul

[ ] Port/adapter minimal berjalan dan teruji.
Modul 16 — Messaging & Asynchronous Processing
Tujuan Modul
• Memproses pekerjaan berat di background.

• Menerapkan idempotency & retry.

Kenapa Penting
• Mengurangi latency request-response.

• Meningkatkan ketahanan saat beban lonjakan.

Teori Inti
• RabbitMQ/Kafka, DLQ, backoff retry.

• Idempotency key untuk mencegah duplikasi.

Contoh Kode #1
// Pseudocode publisher (RabbitTemplate)
@Service @RequiredArgsConstructor
public class TransactionPublisher {
private final RabbitTemplate rabbit;
public void publish(TransactionCreated evt){
[Link]("[Link]","[Link]", evt);
}
}

Latihan / Praktikum
1. Publish event TransactionCreated saat insert transaksi.

2. Bangun consumer sederhana yang hanya log event.

Best Practices
• Definisikan skema event stabil.

• Pantau DLQ dan metrik konsumsi.

Checklist Kelulusan Modul

[ ] Event terkirim & diterima (lokal).
Modul 17 — CI/CD, Docker & Deployment
Tujuan Modul
• Build dapat diulang dan release otomatis.

• Menjalankan aplikasi dalam container.

Kenapa Penting
• CI mencegah broken main.

• Container menyamakan lingkungan dev-prod.

Teori Inti
• GitHub Actions pipeline: build→test→package.

• Dockerfile multi-stage dan best practice image kecil.

Contoh Kode #1
# Dockerfile (multi-stage)
FROM maven:3.9-eclipse-temurin-17 as build
WORKDIR /app
COPY . .
RUN mvn -q -DskipTests package

FROM eclipse-temurin:17-jre
WORKDIR /app
COPY --from=build /app/target/[Link] /app/[Link]
USER 1000
ENTRYPOINT ["java","-jar","/app/[Link]"]

Contoh Kode #2
# .github/workflows/[Link]
name: CI
on: [push]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-java@v4
with:
distribution: temurin
java-version: '17'
- run: mvn -q -DskipTests=false test package

Latihan / Praktikum
1. Bangun image Docker dan jalankan bersama PostgreSQL via docker-compose.

2. Tambahkan job CI untuk menjalankan test dan build image.

Best Practices
• Gunakan non-root user di container.

• Parameter via env var, bukan hardcode.

Checklist Kelulusan Modul

[ ] Image berjalan lokal; pipeline CI hijau.
Modul 18 — Performance & Profiling
Tujuan Modul
• Mengidentifikasi bottleneck dan mengoptimalkan query/kode.

• Menerapkan strategi cache & pagination terukur.

Kenapa Penting
• Performa buruk = biaya tinggi & UX jelek.

Teori Inti
• JFR, Actuator metrics, profiling DB (EXPLAIN ANALYZE).

• DTO projection, fetch join, limit field.

Contoh Kode #1
// Projection JPA
public interface TxnSummary {
Long getId(); String getCategoryName(); BigDecimal getAmount();
}
interface TxnRepo extends JpaRepository<Transaction,Long> {
@Query("select [Link] as id, [Link] as categoryName, [Link] as amount from Transaction t join t
Page<TxnSummary> findSummaries(Long uid, Pageable p);
}

Latihan / Praktikum
1. Profiling endpoint paling lambat dan turunkan latensi 30%.

2. Tambahkan cache read-only untuk master data.

Best Practices
• Ukur sebelum optimasi ('measure, don’t guess').

• Dokumentasikan hasil tuning (sebelum/sesudah).

Checklist Kelulusan Modul

[ ] Laporan profiling dan perbaikan tercatat.
Modul 19 — Keamanan Lanjutan & Hardening Produksi
Tujuan Modul
• Mengurangi permukaan serangan dan memperkuat konfigurasi produksi.

• Audit & logging keamanan.

Kenapa Penting
• Serangan nyata terjadi; pencegahan lebih murah dari penanganan insiden.

Teori Inti
• CORS strict, rate limiting, header keamanan, rotasi secret.

• OWASP Top 10 ringkas; dependency scanning.

Contoh Kode #1
// Contoh Security Header Filter
@Component
public class SecurityHeaderFilter implements Filter {
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOExcep
HttpServletResponse r = (HttpServletResponse) res;
[Link]("X-Content-Type-Options","nosniff");
[Link]("X-Frame-Options","DENY");
[Link]("X-XSS-Protection","1; mode=block");
[Link](req,res);
}
}

Latihan / Praktikum
1. Tambahkan rate limiter (resilience4j/bucket4j) untuk endpoint login.

2. Aktifkan scan dependency otomatis di CI.

Best Practices
• Pisahkan kredensial via secret manager.

• Audit log akses administratif.

Checklist Kelulusan Modul

[ ] Limiter bekerja; keamanan dasar tervalidasi.
Modul 20 — Capstone Project — MoneyMate (Personal
Finance Backend)
Tujuan Modul
• Menyatukan semua modul menjadi aplikasi siap produksi.

• Menerapkan best practices end-to-end.

Kenapa Penting
• Pembuktian kemampuan dengan proyek nyata.

Teori Inti
• User, Bank, Category, Transaction domain & aturan bisnis.

• Auth JWT, RBAC, pagination, caching, observability, CI/CD, Docker.

Contoh Kode #1
// Sketsa endpoint inti
POST /api/auth/register
POST /api/auth/login
GET /api/banks (cached)
POST /api/user-banks (relasi unik)
GET /api/transactions?from=&to=&categoryId=&page=&size=
POST /api/transactions (update saldo total secara transaksional)

Contoh Kode #2
// Contoh Service Transaksi (sketsa)
@Service @RequiredArgsConstructor
public class TransactionService {
private final TxnRepo txns; private final UserBankRepo rels;
@Transactional
public TxnResponse create(CreateTxnRequest req, Long userId){
var rel = [Link]([Link](), userId)
.orElseThrow(() -> new NotFoundException("USER_BANK_NOT_FOUND"));
BigDecimal newBalance = [Link]().add([Link]());
if([Link]([Link]) < 0) throw new ConflictException("NEGATIVE_BALANCE
[Link](newBalance);
var saved = [Link](map(req, rel));
return map(saved);
}
}

Latihan / Praktikum
1. Selesaikan semua endpoint + validasi + dokumentasi.

2. Tulis test e2e utama + Dockerize + jalankan lokal dengan Compose.

Best Practices
• Gunakan DTO, error format, dan logging terstruktur.

• Pastikan traceId hadir pada setiap respons.

Checklist Kelulusan Modul

[ ] Semua fitur inti jalan; build, test, dan container OK.