Kuasai flow process diagram, kemampuan debugging, dan keahlian dalam menemukan Root Cause (analisis akar masalah) pada Java

 Untuk menguasai flow process diagram, kemampuan debugging, dan keahlian dalam menemukan root cause (analisis akar masalah) pada Java, berikut adalah poin-poin yang perlu dikuasai:

---

1. Flow Process Diagram

Flow process diagram adalah alat visual untuk menggambarkan alur sistem atau proses. Kemampuan ini membantu dalam memahami dan merancang sistem yang kompleks.

Yang perlu dikuasai:

1. Dasar-dasar Diagram Alur (Flowchart):

   • Simbol standar (decision, process, input/output, terminator).
   • Aliran kontrol: if, while, for, dan switch.

2. Pemodelan dengan UML (Unified Modeling Language):

   • Activity Diagram: Untuk menggambarkan alur logika proses bisnis.
   • Sequence Diagram: Untuk menunjukkan interaksi antara objek atau komponen.
   • Class Diagram: Untuk menggambarkan hubungan antar kelas di Java.

3. Tools yang Sering Digunakan:

   • Lucidchart, Draw.io, atau Microsoft Visio.
   • IDE dengan plugin diagram seperti IntelliJ IDEA atau Visual Studio Code.

---

2. Debugging di Java

Debugging adalah proses menemukan dan memperbaiki kesalahan dalam program.

Yang perlu dikuasai:

1. Memahami Alur Program:

   • Analisis kode untuk memahami bagaimana data mengalir di aplikasi.
   • Identifikasi titik kritis di mana bug mungkin terjadi (e.g., null pointer, concurrency issues).

2. Menggunakan Debugger di IDE:

   • Breakpoint: Hentikan eksekusi pada titik tertentu.
   • Step Over, Step Into, Step Out: Kendalikan eksekusi per baris.
   • Watch Variable: Pantau nilai variabel.
   • Evaluate Expression: Jalankan ekspresi secara manual saat debugging.

3. Logging untuk Debugging:

   • Gunakan framework logging seperti Log4j atau SLF4J untuk menambahkan informasi debug.
   • Pilih level log yang sesuai: DEBUG, INFO, WARN, ERROR.

4. Tools Eksternal:

   • JConsole dan VisualVM untuk debugging performa.
   • Postman untuk menguji API.

---

3. Root Cause Analysis (RCA)

RCA adalah proses mencari penyebab utama dari suatu masalah atau error.

Yang perlu dikuasai:

1. Memahami Jenis Masalah:

   • Syntax Errors: Kesalahan dalam kode.
   • Runtime Errors: Kesalahan saat program berjalan (e.g., NullPointerException).
   • Logic Errors: Kesalahan logika program yang menyebabkan hasil tak diinginkan.

2. Proses RCA:

   • Identifikasi Gejala:
     • Apa yang tidak berfungsi? (e.g., stack trace, log errors).
   • Reproduksi Masalah:
     • Buat lingkungan yang serupa untuk mengulang error.
   • Analisis Data:
     • Analisis log dan exception menggunakan stack trace.
     • Lihat dependency atau konfigurasi yang terlibat.
   • Cari Penyebab Utama:
     • Telusuri alur kode dari error yang terlihat ke akar penyebab.

3. Alat untuk Analisis:

   • Stack Trace:
     • Analisis pesan error untuk menemukan lokasi di mana masalah terjadi.
   • Thread Dump:
     • Untuk menganalisis masalah multi-threading.
   • Profiling Tools:
     • Gunakan tools seperti YourKit, JProfiler, atau VisualVM untuk masalah performa.
   • Static Code Analysis Tools:
     • SonarQube untuk menemukan potensi bug.

4. Penanganan Masalah:

   • Jika masalah terjadi pada runtime:
     • NullPointerException: Pastikan semua objek diinisialisasi.
     • IndexOutOfBoundsException: Periksa indeks yang digunakan.
   • Jika masalah berasal dari logika:
     • Periksa algoritma atau kondisi if-else yang digunakan.

---

Skill Tambahan untuk Pendukung Debug dan RCA

1. Concurrency Handling:

   • Kuasai konsep thread, race condition, deadlock, dan synchronization.
   • Gunakan synchronized, ReentrantLock, dan java.util.concurrent.

2. Memory Management:

   • Analisis garbage collection dan memory leaks.
   • Tools seperti Eclipse MAT (Memory Analyzer Tool) untuk analisis heap dump.

3. Exception Handling:

   • Pelajari hierarki exception di Java.
   • Tambahkan log untuk semua exception dan gunakan pesan yang informatif.

4. Unit Testing:

   • Tulis unit test menggunakan JUnit atau TestNG.
   • Gunakan mocking framework seperti Mockito.

---

Contoh Debugging dan RCA:

Kode Bermasalah:

java

public class Main {
    public static void main(String[] args) {
        String name = null;
        System.out.println(name.length()); // Error: NullPointerException
    }
}

Langkah Debugging dan RCA:

1. Identifikasi Gejala:

   • Stack trace menunjukkan NullPointerException di name.length().

2. Reproduksi Masalah:

   • Jalankan kode di lingkungan lokal dengan debugger.

3. Analisis Penyebab:

   • Lihat nilai name sebelum digunakan. Ternyata name belum diinisialisasi.

4. Solusi:

   • Pastikan name diinisialisasi sebelum digunakan:

     java
     
     String name = "Default Name";
     System.out.println(name.length());

---

Dengan menguasai flow process diagram, debugging, dan RCA, Anda dapat lebih efisien dalam mengembangkan, memelihara, dan memecahkan masalah pada aplikasi Java.

Implementasi konsep Thread, Race Condition, Deadlock, dan Synchronization

contoh implementasi konsep thread, race condition, deadlock, dan synchronization dalam konteks aplikasi kredit atau keuangan:

---

Studi Kasus: Simulasi Transaksi Bank

Skenario

• Ada dua akun bank dengan saldo masing-masing.
• Beberapa thread mewakili transaksi simultan seperti transfer antar akun.
• Tujuan: Menghindari masalah race condition, deadlock, dan menggunakan teknik synchronization untuk memastikan konsistensi data.

---

1. Race Condition

Masalah:

• Jika dua thread mencoba mengakses dan memodifikasi saldo akun secara bersamaan tanpa sinkronisasi, hasil akhirnya bisa salah.

Kode Bermasalah (Race Condition):

java

public class BankAccount {
    private int balance;
    public BankAccount(int balance) {
        this.balance = balance;
    }
    public void deposit(int amount) {
        balance += amount; // Tidak aman tanpa sinkronisasi
    }
    public void withdraw(int amount) {
        balance -= amount; // Tidak aman tanpa sinkronisasi
    }
    public int getBalance() {
        return balance;
    }
}
public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount(1000);
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                account.deposit(10);
                account.withdraw(10);
            }
        };
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Final Balance: " + account.getBalance());
    }
}

Output Potensial (Race Condition):

sql

Final Balance: 1000 (bisa benar)
Final Balance: 980 (atau hasil lain karena race condition)

---

2. Solusi: Synchronization

Gunakan synchronized untuk memastikan hanya satu thread yang dapat mengakses metode deposit atau withdraw pada satu waktu.

Kode dengan Synchronization:

java

public class BankAccount {
    private int balance;
    public BankAccount(int balance) {
        this.balance = balance;
    }
    public synchronized void deposit(int amount) {
        balance += amount;
    }
    public synchronized void withdraw(int amount) {
        balance -= amount;
    }
    public synchronized int getBalance() {
        return balance;
    }
}
public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount(1000);
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                account.deposit(10);
                account.withdraw(10);
            }
        };
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Final Balance: " + account.getBalance());
    }
}

Output (Sinkronisasi):

yaml

Final Balance: 1000

---

3. Deadlock

Masalah:

• Jika dua thread memegang kunci (lock) pada dua objek berbeda dan mencoba mengakses kunci yang dipegang oleh thread lain, terjadi deadlock.

Kode Deadlock:

java

public class BankAccount {
    private final int id;
    private int balance;
    public BankAccount(int id, int balance) {
        this.id = id;
        this.balance = balance;
    }
    public int getId() {
        return id;
    }
    public synchronized void transfer(BankAccount target, int amount) {
        synchronized (target) {
            this.balance -= amount;
            target.balance += amount;
        }
    }
}

Perbaikan dengan ReentrantLock:

java

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class BankAccount {
    private final int id;
    private int balance;
    private final Lock lock = new ReentrantLock();
    public BankAccount(int id, int balance) {
        this.id = id;
        this.balance = balance;
    }
    public boolean transfer(BankAccount target, int amount) {
        if (this.lock.tryLock()) {
            try {
                if (target.lock.tryLock()) {
                    try {
                        this.balance -= amount;
                        target.balance += amount;
                        return true;
                    } finally {
                        target.lock.unlock();
                    }
                }
            } finally {
                this.lock.unlock();
            }
        }
        return false; // Gagal jika kunci tidak tersedia
    }
}

---

4. ExecutorService dan java.util.concurrent

Untuk menangani banyak thread dengan lebih mudah, gunakan ExecutorService.

Kode dengan ExecutorService:

java
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Main {
    public static void main(String[] args) {
        BankAccount account1 = new BankAccount(1, 1000);
        BankAccount account2 = new BankAccount(2, 1000);
        ExecutorService executor = Executors.newFixedThreadPool(2);
        Runnable task1 = () -> account1.transfer(account2, 100);
        Runnable task2 = () -> account2.transfer(account1, 200);
        executor.submit(task1);
        executor.submit(task2);
        executor.shutdown();
        while (!executor.isTerminated()) {
        }
        System.out.println("Account 1 Balance: " + account1.getBalance());
        System.out.println("Account 2 Balance: " + account2.getBalance());
    }
}

Output:

yaml

 Account 1 Balance: 1100
 Account 2 Balance: 900

---

Konsep yang Digunakan:

1. Race Condition:
   • Dicegah dengan sinkronisasi (synchronized atau ReentrantLock).
2. Deadlock:
   • Dicegah dengan tryLock() atau menghindari penguncian bersamaan.
3. Threading:
   • Menangani banyak thread menggunakan ExecutorService.
4. Concurrency Utilities:
   • Gunakan kelas seperti ReentrantLock untuk pengendalian kunci yang lebih fleksibel.

Contoh ini mencakup skenario umum dalam aplikasi keuangan seperti transaksi antar akun dengan memastikan keamanan data dan menghindari masalah threading.

Analisis Garbage Collection, Memory Leaks, dan Heap Dump

 contoh penggunaan pengelolaan memory management dalam aplikasi kredit/finance, termasuk analisis garbage collection, memory leaks, dan heap dump analysis dengan Eclipse MAT.

---

Studi Kasus: Simulasi Aplikasi Kredit

Skenario

• Sebuah aplikasi kredit memiliki modul untuk memproses pengajuan pinjaman pelanggan.
• Dalam proses tersebut, beberapa data sementara (temporary data) disimpan dalam memori.
• Jika tidak dikelola dengan baik, dapat terjadi memory leaks dan konsumsi memori yang tinggi, yang menyebabkan OutOfMemoryError.

---

1. Contoh Kode dengan Masalah Memory Leaks

Kode Bermasalah:

java

import java.util.HashMap;
import java.util.Map;
public class CreditApplicationService {
    private static Map<Long, String> customerCache = new HashMap<>(); // Cache untuk data pelanggan
    public void processApplication(long customerId, String customerData) {
        // Simpan data pelanggan dalam cache (tapi tidak pernah dihapus)
        customerCache.put(customerId, customerData);
        System.out.println("Processed application for customer: " + customerId);
    }
    public static void main(String[] args) {
        CreditApplicationService service = new CreditApplicationService();
        for (long i = 1; i <= 100000; i++) {
            service.processApplication(i, "CustomerData" + i);
        }
        System.out.println("Processing completed.");
    }
}Masalah:

• Memory Leak: Data pelanggan disimpan di cache (customerCache) dan tidak pernah dihapus.
• Ketika aplikasi berjalan lama, data cache akan terus bertambah dan tidak pernah dirilis, menyebabkan OutOfMemoryError.

---

2. Solusi: Gunakan Weak References atau Eviction Policies

Gunakan WeakHashMap untuk memungkinkan garbage collection membersihkan data yang tidak lagi dirujuk.

Kode yang Diperbaiki:

java

import java.util.Map;
import java.util.WeakHashMap;
public class CreditApplicationService {
    private static Map<Long, String> customerCache = new WeakHashMap<>();
    public void processApplication(long customerId, String customerData) {
        customerCache.put(customerId, customerData); // Data dapat dihapus oleh garbage collector
        System.out.println("Processed application for customer: " + customerId);
    }
    public static void main(String[] args) {
        CreditApplicationService service = new CreditApplicationService();
        for (long i = 1; i <= 100000; i++) {
            service.processApplication(i, "CustomerData" + i);
        }
        System.out.println("Processing completed.");
    }
}

Keuntungan:

• WeakHashMap memungkinkan data dihapus oleh garbage collector jika tidak ada referensi kuat ke kunci.

---

3. Analisis Garbage Collection

Jenis-Jenis Garbage Collector di Java:

• Serial GC: Cocok untuk aplikasi kecil.
• Parallel GC: Untuk throughput tinggi.
• G1 GC: Untuk aplikasi dengan kebutuhan low-latency.
• ZGC: Untuk meminimalkan jeda.

Menambahkan Flag JVM untuk Debugging GC:

Tambahkan flag berikut saat menjalankan aplikasi untuk memantau garbage collection:

bash

java -XX:+PrintGCDetails -XX:+PrintGCDateStamps -Xlog:gc* -jar yourapp.jar

Output Log GC:

mathematica

[2025-01-15T10:23:45.123+0000][GC (Allocation Failure) [PSYoungGen: 2048K->512K(6144K)] 4096K->2560K(8192K), 0.0054321 secs]

---

4. Analisis Heap Dump dengan Eclipse MAT

Langkah untuk Menganalisis Heap Dump:

1. Tambahkan flag berikut saat menjalankan aplikasi:

   bash
   java -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/path/to/heapdump.hprof -jar yourapp.jar

   • HeapDumpOnOutOfMemoryError: Memicu pembuatan heap dump saat terjadi OutOfMemoryError.
   • HeapDumpPath: Lokasi file heap dump.

2. Jalankan aplikasi dan biarkan hingga error terjadi (misalnya, OutOfMemoryError).

3. Buka file .hprof menggunakan Eclipse Memory Analyzer Tool (MAT).

---

Contoh Analisis Heap Dump

Langkah di Eclipse MAT:

1. Buka file heap dump di MAT.
2. Gunakan fitur "Leak Suspects Report":
   • Identifikasi objek yang terus berada dalam memori.
   • Cari tahu referensi yang membuat objek tersebut tidak dihapus.
3. Analisis Dominators Tree:
   • Lihat objek yang memegang referensi terbesar dalam memori.

Contoh Output Analisis:

• Suspected Leak: customerCache memegang referensi besar karena data tidak pernah dihapus.
• Solusi yang Direkomendasikan: Gunakan struktur data seperti WeakHashMap atau tambahkan kebijakan penghapusan data lama.

---

5. Simulasi OutOfMemoryError

Untuk mensimulasikan OutOfMemoryError, tambahkan batas heap kecil:

bash

java -Xmx16m -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=heapdump.hprof -jar yourapp.jar

Hasil Output:

arduino

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
Dumping heap to heapdump.hprof ...

---

Kesimpulan

1. Memory Management:

   • Gunakan WeakHashMap untuk cache atau tambahkan mekanisme pembersihan.
   • Monitor penggunaan memori dengan flag JVM dan analisis log garbage collection.

2. Heap Dump Analysis:

   • Gunakan Eclipse MAT untuk menemukan sumber memory leaks.
   • Fokus pada referensi objek besar yang tidak diperlukan lagi.

Dengan teknik ini, Anda dapat mengelola memori dengan efisien di aplikasi kredit/finance dan mencegah masalah seperti OutOfMemoryError.

Beda Spring , Spring Web MVC dan SpringBoot

 Perbedaan Spring, Spring Web MVC, dan Spring Boot

---

1. Spring Framework

Spring adalah kerangka kerja Java yang menyediakan berbagai modul untuk membangun aplikasi enterprise-grade. Modul-modulnya meliputi Spring Core, Spring AOP, Spring Security, dan lainnya. Spring adalah dasar dari ekosistem yang lebih besar, termasuk Spring Web MVC dan Spring Boot.

Fitur Utama Spring Framework:

• Dependency Injection (DI) untuk mengelola objek dan siklus hidupnya.
• Modul modular (Spring Core, AOP, Security, dll.).
• Cocok untuk berbagai jenis aplikasi, termasuk aplikasi non-web.

Contoh Implementasi Spring (DI dengan konfigurasi XML):

xml
----------—----------------------------------

<!-- beans.xml -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="myService" class="com.example.MyService" />
</beans>

java
-----------------—---------------------
public class MyService {
    public void doSomething() {
        System.out.println("Service is working!");
    }
}

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        MyService service = context.getBean(MyService.class);
        service.doSomething();
    }
}

---

2. Spring Web MVC

Spring Web MVC adalah modul dalam Spring Framework untuk membangun aplikasi berbasis web menggunakan pola Model-View-Controller (MVC). Ini menyediakan fitur seperti dispatcher servlet, controller, view resolvers, dan sebagainya.

Fitur Utama Spring Web MVC:

• Membantu membangun aplikasi web berbasis REST atau berbasis UI.
• Dukungan penuh untuk anotasi seperti @Controller dan @RequestMapping.
• Konfigurasi berbasis XML atau Java.

Contoh Implementasi Spring Web MVC:

java
----------------------------------------
@Controller
public class HomeController {
    @RequestMapping("/home")
    public String home(Model model) {
        model.addAttribute("message", "Welcome to Spring Web MVC!");
        return "home"; // Nama view (home.jsp)
    }
}

xml
-----------------------------------
<!-- web.xml -->
<web-app>
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

xml
------------------------------------
<!-- dispatcher-servlet.xml -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <mvc:annotation-driven />
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/" />
        <property name="suffix" value=".jsp" />
    </bean>
</beans>

---

3. Spring Boot

Spring Boot adalah kerangka kerja berbasis Spring yang dirancang untuk menyederhanakan pengembangan aplikasi. Spring Boot menghilangkan boilerplate konfigurasi dengan menyediakan starter dependencies, embedded server, dan konfigurasi otomatis (auto-configuration).

Fitur Utama Spring Boot:

• Starter Dependencies untuk mempermudah pengelolaan library.
• Embedded Server (Tomcat, Jetty, atau Undertow) untuk menjalankan aplikasi tanpa konfigurasi tambahan.
• Konfigurasi otomatis sehingga Anda tidak perlu membuat banyak file konfigurasi.
• Spring Boot Actuator untuk memantau aplikasi.

Contoh Implementasi Spring Boot:

java
--------------------------------------
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, Spring Boot!";
    }
}

File application.properties (opsional):

properties
--------------------------------------
server.port=8081

Jalankan aplikasi dengan satu file, dan Spring Boot secara otomatis mengatur server, dependensi, dan konfigurasi.

---

Perbandingan Singkat

Fitur	Spring	Spring Web MVC	Spring Boot
Tujuan	Kerangka kerja inti (modular)	Pembangunan aplikasi web MVC	Simplifikasi pengembangan aplikasi Spring
Konfigurasi	Manual (XML/Java)	Manual (XML/Java)	Otomatis dengan starter dan embedded server
Fokus	Aplikasi umum	Aplikasi berbasis web (REST/UI)	Semua jenis aplikasi, dengan konfigurasi minimal
Embedded Server	Tidak ada	Tidak ada	Ada (Tomcat default)
Cocok Untuk	Enterprise aplikasi kompleks	Aplikasi web berbasis MVC	Aplikasi cepat dan mudah di-deploy

Kesimpulan:

• Gunakan Spring Framework untuk aplikasi kompleks dengan kebutuhan spesifik modul.
• Gunakan Spring Web MVC untuk membangun aplikasi web berbasis MVC.
• Gunakan Spring Boot untuk pengembangan aplikasi yang cepat, sederhana, dan modern.

Beda JPA, Hibernate, JDBC

 Perbedaan JPA, Hibernate, dan JDBC dapat dijelaskan sebagai berikut:

---

1. JPA (Java Persistence API)

JPA adalah spesifikasi Java untuk manajemen data persisten. JPA hanya mendefinisikan serangkaian antarmuka (interface) dan anotasi, tetapi tidak memberikan implementasi konkret. Framework seperti Hibernate adalah implementasi dari JPA.

Fitur Utama JPA:

• Anotasi untuk mendefinisikan relasi entitas.
• Query menggunakan JPQL (Java Persistence Query Language), mirip dengan SQL tetapi berbasis entitas.
• Deklaratif dan fokus pada ORM (Object Relational Mapping).

Contoh Implementasi JPA:

Java
----------------------
@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private String email;

    // Getter dan Setter
}

public class UserDAO {
    private EntityManager entityManager;

    public UserDAO(EntityManager entityManager) {
        this.entityManager = entityManager;
    }

    public void saveUser(User user) {
        entityManager.getTransaction().begin();
        entityManager.persist(user);
        entityManager.getTransaction().commit();
    }

    public User findUser(Long id) {
        return entityManager.find(User.class, id);
    }
}

---

2. Hibernate

Hibernate adalah implementasi dari JPA sekaligus framework ORM (Object Relational Mapping) yang menawarkan fitur tambahan di luar JPA, seperti caching, custom SQL, dan lain-lain. Hibernate mendukung JPA, tetapi Anda juga dapat menggunakan API Hibernate tanpa JPA.

Fitur Utama Hibernate:

• Fitur caching tingkat pertama (session cache) dan tingkat kedua (distributed cache).
• Query dengan HQL (Hibernate Query Language), yang serupa dengan JPQL.
• Fitur mapping lebih luas dibandingkan JPA.

Contoh Implementasi Hibernate (Non-JPA):

java
-----------------------------------

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private Double price;

    // Getter dan Setter
}

public class ProductDAO {
    private Session session;

    public ProductDAO(Session session) {
        this.session = session;
    }

    public void saveProduct(Product product) {
        Transaction transaction = session.beginTransaction();
        session.save(product);
        transaction.commit();
    }

    public Product findProduct(Long id) {
        return session.get(Product.class, id);
    }
}

---

3. JDBC (Java Database Connectivity)

JDBC adalah API tingkat rendah untuk menghubungkan Java dengan database. Tidak ada abstraksi ORM di sini; pengembang langsung menulis query SQL mentah. JDBC memberikan kontrol penuh atas database tetapi lebih rawan kesalahan dan membutuhkan banyak kode boilerplate.

Fitur Utama JDBC:

• Menggunakan SQL secara langsung.
• Memberikan fleksibilitas untuk query kompleks.
• Tidak menyediakan ORM, sehingga data diakses sebagai tabel.

Contoh Implementasi JDBC:

java
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class CustomerDAO {
    private Connection getConnection() throws Exception {
        String url = "jdbc:mysql://localhost:3306/mydb";
        String username = "root";
        String password = "password";
        return DriverManager.getConnection(url, username, password);
    }

    public void saveCustomer(String name, String email) throws Exception {
        Connection connection = getConnection();
        String query = "INSERT INTO customers (name, email) VALUES (?, ?)";
        PreparedStatement statement = connection.prepareStatement(query);
        statement.setString(1, name);
        statement.setString(2, email);
        statement.executeUpdate();
        connection.close();
    }

    public void findCustomer(int id) throws Exception {
        Connection connection = getConnection();
        String query = "SELECT * FROM customers WHERE id = ?";
        PreparedStatement statement = connection.prepareStatement(query);
        statement.setInt(1, id);
        ResultSet resultSet = statement.executeQuery();

        while (resultSet.next()) {
            System.out.println("Name: " + resultSet.getString("name"));
            System.out.println("Email: " + resultSet.getString("email"));
        }
        connection.close();
    }
}

---

Perbandingan Singkat:

Fitur	JPA	Hibernate	JDBC
Level Abstraksi	Tinggi (ORM)	Tinggi (ORM + fitur tambahan)	Rendah (SQL mentah)
Query	JPQL	HQL, Native SQL	SQL langsung
ORM	Ya	Ya	Tidak
Anotasi	Ya	Ya	Tidak
Kinerja	Bergantung pada implementasi	Bisa dioptimalkan (caching)	Bergantung pada kode SQL

Kesimpulan:

• Gunakan JPA atau Hibernate jika Anda menginginkan pengelolaan database berbasis objek dengan sintaks deklaratif.
• Gunakan JDBC jika Anda memerlukan kontrol penuh dan fleksibilitas terhadap query SQL.