Tutorial Spring dan Hibernate

Hibernate

Hibernate adalah Objek Relational Mapping (ORM) library dalam Java, yang menyediakan framework untuk memetakan Objek-Oriented Domain model ke Relational Database. Fitur utama dalam hibernate adalah kemampuannya untuk memetakan kelas-kelas pada Java dengan table-table yang terdapat dalam database. Hibernate juga menyediakan query data dan fasilitas temu kembali. Dengan menggunakan Hibernate, developer hampir tidak akan pernah menyentuh database secara langsung. Hibernate juga akan meng-cover perbedaan dialek SQL pada DBMS.

Spring Framework

Spring Framework adalah salah satu framework yang paling populer di dunia pemrograman Java. Framework ini memiliki banyak fitur untuk memudahkan pembuatan aplikasi. Beberapa keunggulan yang dimiliki Spring adalah:

• Mudah dipelajari
• Tidak terlalu invasif
• Helper class yang banyak
• Mendukung AOP
• Menyediakan integrasi dengan framework lain

Spring Framework sebenarnya menggunakan teknik pemrograman yang sederhana. Seperti kita akan lihat pada pembahasan tentang IoC, model pemrograman dengan Spring mudah, tapi rapi. Ini memudahkan para pemula untuk mempelajarinya. Dengan mempelajari Spring Framework, kita juga berevolusi menjadi programmer yang lebih baik. Ini dimungkinkan karena Spring Framework mendorong kita untuk membuat kode program yang modular dan independen. Hasil akhirnya, kode program yang kita hasilkan menjadi lebih rapi, mudah dites, dan terstruktur dengan baik. Spring Framework tidak terlalu invasif. Artinya, Spring tidak mengharuskan kita untuk meng-extend kelas-kelas yang dimiliki Spring. Oleh karena itu, kode program yang kita hasilkan tidak terlalu terikat dengan Spring. Spring memiliki banyak helper class. Helper class adalah class yang berguna untuk memudahkan pekerjaan pemrograman kita. Dengan menggunakan helper class, aplikasi kita dapat diselesaikan dengan jumlah kode yang lebih sedikit (Muhardin, 2008).

Latar Belakang Pembaca

Pembaca diasumsikan sudah menguasai:

• Dasar Pemrograman Java
• JDBC
• Syntax SQL
• IDE Netbeans

Praktik

Membuat Java Project

Untuk membuat Java Project di NetBeans, langkah yang harus dilakukan yaitu bukalah NetBeans IDE kemudian pilih menu File   >   New   Project kemudian pada pilihan Categories pilihlah Java  dan Java   Application pada pilihan Projects setelah itu tekanlah tombol Next. Pada jendela berikutnya, isikan HibernateSpringTutorial pada kolom isian Project Name kemudian tekanlah tombol Finish. Pastikan  Create Main Class sudah terpilih. Sehingga akan diperoleh tree pada jendela projek seperti gambar di bawah ini:

Membuat Database

DBMS yang akan digunakna adalah derby. Secara default Derby sudah terinstall ketika Anda menginstall Netbeans. Di sebelahk kanan anda akan melihat jendela Services, pilih jendela itu. Expand databases, klik kanan pada Java DB, pilih Create Database.

Database Name: Phone_Book

Username: userKamu

Password: passwordKamu

Menambah Library

Klik kanan pada folder Libraries, kemudian pilih Add Library. Pada jendela Add Library yang muncul pilih Hibernate JPA dan Spring Framework 3.0.2.RELEASE. Selain dua itu, masih dibutuhkan juga tiga file jar berikut:

commons-dbcp.jar

commons-pool.jar

derbyclient.jar

Cara menambahkan file jar: klik kanan >  Add JAR/Folder. Jika anda belum memiliki tiga file jar di atas, silahkan download di sini.

Membuat Package Model

Expand source package, klik kanan pada package hibernateSpringTutorial, kemudian New > Java Package. Isikan hibernateSpringTutorial.model pada Package Name.

Membuat Kelas POJO (Group.java)

Klik kanan package hibernateSpringTutorial.model yang baru saja dibuat, kemudian pilih New > Java Class. Berikan nama: Group. Lengkapi class User.java sehingga menjadi seperti ini:

public class Group {
    private int id;
    private String nama;

    //constructor
    //method getter dan setter
}

Membuat Kelas POJO (User.java)

Klik kanan package hibernateSpringTutorial.model yang baru saja dibuat, kemudian pilih New > Java Class. Berikan nama: Group. Lengkapi class User.java sehingga menjadi seperti ini:

public class User {
    private int id;
    private String nama;
    private Group group;

    //constructor
    //method getter dan setter
}

Menambahkan Anotation pada POJO

Penambahan annotation bertujuan untuk melakukan mapping kelas POJO dengan table pada database. Pada Group.java, tambahkan annotation sehingga menjadi:

package hibernateSpringTutorial.model;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table (name="PB.GROUPS")
public class Group {
    @Id
    @GeneratedValue (strategy=GenerationType.AUTO)
    @Column (name="ID_GROUP")
    private int id;

    @Column (name="NAMA_GROUP")
    private String nama;

    //constructor
    //method getter dan setter
}

User.java

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@Table (name="PB.USERS")
public class User {
    @Id
    @GeneratedValue (strategy=GenerationType.AUTO)
    @Column (name="ID_USER")
    private int id;

    @Column (name="NAMA_USER")
    private String nama;

    @ManyToOne
    @JoinColumn (name="ID_GROUP")
    private Group group;

    //CONSTRUCTOR
    //METHOD GETTER DAN SETTER
}

Membuat Data Access Object (DAO)

Klik kanan pada hibernateSpringTutorial, kemudian pilih New > Java Package. Masukan nama:  hibernateSpringTutorial.dao. Klik kanan pada  hibernateSpringTutorial.dao, kemudian pilih New > Java Interface, masukan nama: GroupDao.

public interface GroupDao {
    public void saveGroup(Group group);
    public Group getGroup(int id);
    public List<Group> getGroups();
    public void removeGroup();
}

Lakukan proses yang sama, buat interface UserDao.java

public interface UserDao {
    public void saveUser(User user);
    public User getUser(int id);
    public List<User> getUsers();
    public void removeUser();
}

Membuat Implementasi DAO

Klik kanan pada  hibernateSpringTutorial.dao kemudian pilih New > Java Package. Masukan nama:  hibernateSpringTutorial.dao.hibernate. Klik kanan pada package yang baru saja dibuat kemudian, pilih New > Java Class, masukan nama: BaseDaoHibernate

import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.HibernateTemplate;

public class BaseDaoHibernate {
    protected HibernateTemplate hibernateTemplate;

    public void setSessionFactory(SessionFactory sessionFactory){
        this.hibernateTemplate = new HibernateTemplate(sessionFactory);
    }
}

hibernateSpringTutorial.dao.hibernate.GroupDaoHibernate

import hibernateSpringTutorial.dao.GroupDao;
import hibernateSpringTutorial.model.Group;
import java.util.List;

public class GroupDaoHibernate extends BaseDaoHibernate implements GroupDao{

    public void saveGroup(Group group) {
        hibernateTemplate.saveOrUpdate(group);
    }

    public Group getGroup(int id) {
        return hibernateTemplate.get(Group.class, id);
    }

    public List<Group> getGroups() {
        return hibernateTemplate.find("from Group");
    }

    public void removeGroup(int id) {
        hibernateTemplate.delete(getGroup(id));
    }

}

hibernateSpringTutorial.dao.hibernate.UserDaoHibernate

package hibernateSpringTutorial.dao.hibernate;

import hibernateSpringTutorial.dao.UserDao;
import hibernateSpringTutorial.model.User;
import java.util.List;

public class UserDaoHibernate extends BaseDaoHibernate implements UserDao{

    public void saveUser(User user) {
        hibernateTemplate.saveOrUpdate(user);
    }

    public User getUser(int id) {
        return hibernateTemplate.get(User.class, id);
    }

    public List<User> getUsers() {
        return hibernateTemplate.find("from User");
    }

    public void removeUser(int id) {
        hibernateTemplate.delete(getUser(id));
    }

}

Konfigurasi Spring

Klik kanan pada Source Package, kemudian pilih New > Other. Pada Categories pilih Other, dan pada File Types pilih: Spring XML Configuration File. Klik Next, masukan nama Spring. Pada step terakhir, untuk lebih memudahkan pilih semua namespace. Finish. JANGAN PANIK, ya, Anda jangan panik melihat tulisan XML yang aneh itu. Abaikan tulisan yang banyak itu. Lihat codenya dengan enjoy, dan sebenernya gampang aja:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:flow="http://www.springframework.org/schema/webflow-config"
       xmlns:jms="http://www.springframework.org/schema/jms"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xmlns:lang="http://www.springframework.org/schema/lang"
       xmlns:osgi="http://www.springframework.org/schema/osgi"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:p="http://www.springframework.org/schema/p"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
          http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
          http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
          http://www.springframework.org/schema/webflow-config http://www.springframework.org/schema/webflow-config/spring-webflow-config-2.0.xsd
          http://www.springframework.org/schema/jms http://www.springframework.org/schema/jms/spring-jms-3.0.xsd
          http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd
          http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang-3.0.xsd
          http://www.springframework.org/schema/osgi http://www.springframework.org/schema/osgi/spring-osgi-3.0.xsd
          http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
          http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd
">

    <bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="org.apache.derby.jdbc.ClientDriver"/>
        <property name="url" value="jdbc:derby://localhost:1527/phone_book"/>
        <property name="username" value="userKamu"/>
        <property name="password" value="passwordKamu"/>
    </bean>

    <bean id="mySessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
        <property name="dataSource" ref="myDataSource" />
	<property name="annotatedClasses">
            <list>
                <value>hibernateSpringTutorial.model.User</value>
                <value>hibernateSpringTutorial.model.Group</value>
            </list>
	</property>
	<property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.DerbyDialect</prop>
		<prop key="hibernate.show_sql">true</prop>
		<prop key="hibernate.hbm2ddl.auto">validate</prop>
            </props>
	</property>
    </bean>

    <!--Group Dao-->
    <bean id="daoGroup" class="hibernateSpringTutorial.dao.hibernate.GroupDaoHibernate">
        <property name="sessionFactory" ref="mySessionFactory"/>
    </bean>

    <!--User Dao-->
    <bean id="daoUser" class="hibernateSpringTutorial.dao.hibernate.UserDaoHibernate">
        <property name="sessionFactory" ref="mySessionFactory"/>
    </bean>

</beans>

Menyimpan Data ke Database

Ini adalah bagian akhir dari tutorial ini. Infrastruktur untuk hibernate dan spring sudah dibuat, sekarang tinggal pakai saja. Tambahkan pada class Main (hibernateSpringTutorial.Main.java) code berikut:

import hibernateSpringTutorial.dao.GroupDao;
import hibernateSpringTutorial.model.Group;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:spring.xml");
        GroupDao groupDao = (GroupDao) ctx.getBean("daoGroup");
        Group g = new Group();
        g.setNama("Keluarga");
        groupDao.saveGroup(g);
    }
}