Tutorial Belajar Spring Framework Part V: CRUD Menggunakan Spring JDBC

Seperti aplikasi pada umumnya, tentu kita membutuhkan database untuk melakukan penyimpanan dan pengolahan data. Jika kita sudah sering menggunakan database pada aplikasi java, tentu sudah tidak asing lagi dengan istilah jdbc(java database connectivity). JDBC merupakan application programming interface(API) pada Java yang digunakan untuk mengakses database dari aplikasi java yang kita gunakan.

jdbc-architecture

Begitu pula pada aplikasi berbasis spring, kita juga tetap membutuhkan jdbc untuk mengakses database. Namun tentu terdapat perbedaan saat kita menggunakan jdbc secara konvensional dan saat menggunakan spring framework. Jika secara konvensional, maka kira-kira code kita akan seperti ini,

//STEP 1. Import required packages
import java.sql.*;

public class FirstExample {
   // JDBC driver name and database URL
   static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";  
   static final String DB_URL = "jdbc:mysql://localhost/EMP";

   //  Database credentials
   static final String USER = "username";
   static final String PASS = "password";
   
   public static void main(String[] args) {
   Connection conn = null;
   Statement stmt = null;
   try{
      //STEP 2: Register JDBC driver
      Class.forName("com.mysql.jdbc.Driver");

      //STEP 3: Open a connection
      System.out.println("Connecting to database...");
      conn = DriverManager.getConnection(DB_URL,USER,PASS);

      //STEP 4: Execute a query
      System.out.println("Creating statement...");
      stmt = conn.createStatement();
      String sql;
      sql = "SELECT id, first, last, age FROM Employees";
      ResultSet rs = stmt.executeQuery(sql);

      //STEP 5: Extract data from result set
      while(rs.next()){
         //Retrieve by column name
         int id  = rs.getInt("id");
         int age = rs.getInt("age");
         String first = rs.getString("first");
         String last = rs.getString("last");

         //Display values
         System.out.print("ID: " + id);
         System.out.print(", Age: " + age);
         System.out.print(", First: " + first);
         System.out.println(", Last: " + last);
      }
      //STEP 6: Clean-up environment
      rs.close();
      stmt.close();
      conn.close();
   }catch(SQLException se){
      //Handle errors for JDBC
      se.printStackTrace();
   }catch(Exception e){
      //Handle errors for Class.forName
      e.printStackTrace();
   }finally{
      //finally block used to close resources
      try{
         if(stmt!=null)
            stmt.close();
      }catch(SQLException se2){
      }// nothing we can do
      try{
         if(conn!=null)
            conn.close();
      }catch(SQLException se){
         se.printStackTrace();
      }//end finally try
   }//end try
   System.out.println("Goodbye!");
}//end main
}//end FirstExample

Sekarang kita akan mencoba membandingkan dengan saat kita menggunakan spring jdbc. Sebagai perbandingan terdapat tabel yang menunjukkan apa saja yang sudah bisa dilakukan oleh spring jdbc dan yang masih harus kita lakukan sendiri saat mengakses database menggunakan spring jdbc

spring12

Dapat kita lihat pada tabel diatas, tentu membuat kita semakin mudah dalam mengakses database karena banyak yang sudah di handle oleh spring jdbc. Sekarang kita akan mencoba membuat CRUD menggunakan spring jdbc, kali ini kita akan menggunakan database mysql. Sebagai permulaan kita akan melanjutkan dari template project yang sudah kita buat pada part sebelumnya menggunakan spring boot. Kita buka file pom.xml, lalu tambahkan dependency untuk spring jdbc dan connector mysql

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

Setelah itu kita siapkan terlebih dahulu tabel di database mysql, sebagai contoh kita akan membuat tabel karyawan,

CREATE DATABASE  IF NOT EXISTS `belajar_spring_boot`;
USE `belajar_spring_boot`;
DROP TABLE IF EXISTS `karyawan`;

CREATE TABLE `karyawan` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `nama` varchar(200) NOT NULL,
  `tanggal_lahir` date NOT NULL,
  `gaji` decimal(12,2) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB;
INSERT INTO `karyawan` VALUES (1,'Budi Luhur','1995-12-19',2000000.00),(2,'Sri Rejeki','1993-03-22',1500000.00);

Setelah kita buat tabel tersebut pada database mysql, sekarang kita akan membuat model class Karyawan yang kita gunakan untuk menampung data dari tabel karyawan di database menjadi object pada aplikasi spring kita. Berikut isi class Karyawan

package com.github.model;

import java.io.Serializable;
import java.math.BigDecimal;
import java.sql.Date;

public class Karyawan implements Serializable{ 
    
    private Integer id;
    private String nama;
    private Date tanggalLahir;
    private BigDecimal gaji;

    public Integer getId() {
        return id;
    }

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

    public String getNama() {
        return nama;
    }

    public void setNama(String nama) {
        this.nama = nama;
    }

    public Date getTanggalLahir() {
        return tanggalLahir;
    }

    public void setTanggalLahir(Date tanggalLahir) {
        this.tanggalLahir = tanggalLahir;
    }

    public BigDecimal getGaji() {
        return gaji;
    }

    public void setGaji(BigDecimal gaji) {
        this.gaji = gaji;
    }
    
}

Setelah itu kita buat interface KaryawanDAO, interface ini berisi 5 method yang meliputi fungsi untuk select all, select by id, delete by id, update dan save

package com.github.dao;

import com.github.model.Karyawan;
import java.util.List;

public interface KaryawanDao {
    
    List<Karyawan> findAll();
    
    Karyawan findById(Integer id);
    
    void deleteById(Integer id);
    
    void add(Karyawan karyawan);
    
    void update(Karyawan karyawan);
    
}

Setelah itu kita buat class implemetasinya, disini kita menggunakan bean JdbcTemplate dari spring framework untuk melakukan operasi pada database.

package com.github.dao.impl;

import com.github.model.Karyawan;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import com.github.dao.KaryawanDao;
import org.springframework.stereotype.Component;

@Component
public class KaryawanDaoImpl implements KaryawanDao {
    
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Override
    public List<Karyawan> findAll() {
        return jdbcTemplate.query("SELECT id,nama,tanggal_lahir,gaji FROM karyawan", new RowMapper<Karyawan>() {
            @Override
            public Karyawan mapRow(ResultSet rs, int i) throws SQLException {
                Karyawan karyawan = new Karyawan();
                karyawan.setId(rs.getInt("id"));
                karyawan.setNama(rs.getString("nama"));
                karyawan.setTanggalLahir(rs.getDate("tanggal_lahir"));
                karyawan.setGaji(rs.getBigDecimal("gaji"));
                return karyawan;
            }
        });
    }

    @Override
    public Karyawan findById(Integer id) {
        return jdbcTemplate.queryForObject("SELECT id,nama,tanggal_lahir,gaji FROM karyawan WHERE id=?", new RowMapper<Karyawan>() {
            @Override
            public Karyawan mapRow(ResultSet rs, int i) throws SQLException {
                Karyawan karyawan = new Karyawan();
                karyawan.setId(rs.getInt("id"));
                karyawan.setNama(rs.getString("nama"));
                karyawan.setTanggalLahir(rs.getDate("tanggal_lahir"));
                karyawan.setGaji(rs.getBigDecimal("gaji"));
                return karyawan;
            }
        },id);
    }

    @Override
    public void deleteById(Integer id) {
        jdbcTemplate.update("DELETE from karyawan WHERE id=?",id);
    }

    @Override
    public void add(Karyawan karyawan) {
        jdbcTemplate.update("INSERT INTO karyawan(nama,tanggal_lahir,gaji) VALUES(?,?,?)", new Object[]{karyawan.getNama(),karyawan.getTanggalLahir(),karyawan.getGaji()});
    }

    @Override
    public void update(Karyawan karyawan) {
        jdbcTemplate.update("UPDATE karyawan SET nama=?,tanggal_lahir=?,gaji=? WHERE id=?",new Object[]{karyawan.getNama(),karyawan.getTanggalLahir(),karyawan.getGaji(),karyawan.getId()});
    }
    
}

Kalau kita perhatikan code diatas, tentu lebih sederhana dari pada kita menggunakan jdbc secara konvensional tanpa menggunakan spring jdbc. Kita tidak perlu repot-repot membuka dan menutup koneksi ke database jika menggunakan spring jdbc. Selain itu kita juga tidak perlu melakukan prepare statement, exception juga sudah dihandle oleh spring jdbc. Untuk memastikan method-method CRUD yang kita buat sudah sesuai dan benar, kita akan membuat unit testing untuk setiap method yang kita buat seperti dibawah,

package com.github;

import com.github.dao.KaryawanDao;
import com.github.model.Karyawan;
import java.math.BigDecimal;
import java.sql.Date;
import java.util.List;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class BlogTutorialSpringFrameworkApplicationTests {

    @Autowired
    KaryawanDao karyawanDao;
    
	@Test
	public void contextLoads() {
	}
        
        @Test
        public void KaryawanDaoTest(){
            //test untuk menambahkan karyawan baru
            Karyawan karyawanBaru = new Karyawan();
            karyawanBaru.setNama("Adi Putra");
            karyawanBaru.setTanggalLahir(Date.valueOf("1992-07-14"));
            karyawanBaru.setGaji(BigDecimal.valueOf(5000000.00));
            karyawanDao.add(karyawanBaru);
            Karyawan karyawanEdit = karyawanDao.findById(3);
            Assert.assertEquals("Adi Putra", karyawanEdit.getNama());
            
            //test untuk edit karyawan
            karyawanEdit.setNama("Adi Luhur");
            karyawanDao.update(karyawanEdit);
            Assert.assertNotEquals("Adi Putra", karyawanEdit.getNama());
            
            //test untuk mendapatkan list karyawan
            List<Karyawan> listKaryawan = karyawanDao.findAll();
            Assert.assertTrue(listKaryawan.size()>2);
            
            //test untuk menghapus karyawan
            karyawanDao.deleteById(3);
            listKaryawan = karyawanDao.findAll();
            Assert.assertFalse(listKaryawan.size()>2);
        }

}

Untuk menjalankan unit testing yang telah kita buat, kita bisa menjalankan command berikut pada root project directory,

mvn test

Source code bisa dilihat pada link github berikut https://github.com/leonardusdani/blog-tutorial-spring-framework/releases/tag/5.0
Source
https://www.tutorialspoint.com/jdbc/jdbc-sample-code.htm

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s