Java SE ပတ်ဝင်းကျင်တွင်အသုံးပြုမည်ဆိုပါက JPA အား အသုံးပြုနိုင်ရန် User Library အား အင်စတော လုပ်ထားရန်လိုအပ်ပါသည်။ အသုံးများသည်မှာ EclipseLink Library ဖြစ်ပြီး ဤဘလောဂ်တွင် Java SE ပတ်ဝင်းကျင်တွင် ရေးသားသွားမည်ဖြစ်၏။
Java EE ပတ်ဝင်းကျင်တွင် Databaseအနေဖြင့် MySQL Database Server အား၎င်း၊ Java SE ပတ်ဝင်းကျင်တွင် Derby အား၎င်း အသုံးပြု၍ရေးသားသွားပါမည်။ Database Installation များအား ဤနေရာတွင် ဖော်ပြသွားမည် မဟုတ်။ ထို့အပြင် Eclipse Installation အားလည်း ယခင်အခန်းများတွင် ဖော်ပြခဲ့ဘူးပါသဖြင့် ယခင်အခန်းများတွင် လေ့လာစေလိုပါသည်။
Environment Preparation for Java EE environment နှင့်ပတ်သက်၍ ရေးသားခဲ့ဘူးပါသဖြင့် ဤနေရာတွင် ထပ်မံရေးသားတော့မည် မဟုတ်ပါ။
Java SE အတွက် ပတ်ဝင်းကျင်ပြင်ဆင်မှု့
ကျွှန်တော်တို့ ဒီတစ်ခေါက် လိုအပ်မှာကတော့ JDK ရယ်၊ Eclipse IDE ရယ် JPA အတွက် အသုံးပြုမယ့် Library နဲ့ Derby Database ပဲ ဖြစ်ပါတယ်။
JDK ကတော့ လက်ရှိ နောက်ဆုံးဖြစ်တဲ့ JDK 1.7 ရဲ့ Update 45 ကို အသုံးပြုပါမယ်။ Java SE 7 ရဲ့ Feature တွေကို သုံးမှာဖြစ်တဲ့အတွက် Update 45 မရှိရင်လဲ JDK 1.7 ဖြစ်ရင် ရပါပြီ။ ဒေါင်းလုဒ်လုပ်ထားတဲ့ JDK ကို Install လုပ်ပါမယ်။ အကယ်၍ JDK 1.7 ရှိပြီးသားဆိုရင် ဒီအဆင့်ဟာ လုပ်စရာ မလိုအပ်ပါဘူး။
JPA ကို ရေးမှာဖြစ်တဲ့ အတွက် Java EE Edition ကို ရွေးပါမယ်။ ဗားရှင်းအနေနဲ့လည်း လက်ရှိ နောက်ဆုံးဖြစ်တဲ့ Kepler ဗားရှင်းကို အသုံးပြုပါမယ်။ လိုအပ်တဲ့ Eclipse ကိုဒေါင်းလုဒ်လုပ်ပြီး၊ Archive ဖိုင်ကို Unzip လုပ်ထားပါမယ်။ ပြီးရင် Eclipse IDE ကို Start လုပ်ပြီး Windows > Preferences > Java > Installed JRE မှာ စောစောက Installed လုပ်ထားတဲ့ JDK 1.7 ကို ဖြည့်လိုက်ပါမယ်။ အသစ် ဖြည့်ထားတဲ့ JDK 1.7 ကို Default အဖြစ် ပြောင်းထားပါမယ်။ ဒါကတော့ Eclipse Installed လုပ်ပြီးတိုင်း လုပ်သင့်တဲ့အလုပ်ပါ။
EclipseLink Library ကတော့ ပရိုဂျက် စဆောက်တဲ့အခါမှ Eclipse က တဆင့် ဒေါင်းလုဒ်လုပ်ပါတော့မယ်။
နောက်ဆုံး Derby DBကတော့ JDK 1.7 မှာပါတဲ့အတွက် တကူးတက ဒေါင်းစရာ မလိုအပ်ပါဘူး။ ဒါဆိုရင် ကျွှန်တော်တို့ Java SE ပတ်ဝင်းကျင်မှာ JPA Project တစ်ခုကို စရေးလို့ရပါပြီ။
Hello JPA
ဒီတစ်ခေါက် နမှုနာအနေနဲ့ ရန်ကုန်တိုင်းမှာရှိတဲ့ မြို့နယ်တွေကို Text ဖိုင်ထဲမှာထားပြီး၊ Database ထဲကို ထည့်ကြည့်ပါမယ်။ လက်ရှိ အသုံးပြုနေတဲ့ JPA 2.1ဟာ schema generation function ပါတဲ့အတွက် တကူးတက Schema တွေ Table တွေ ဆောက်စရာမလိုအပ်ပါဘူး။ ဒီတစ်ခေါက်က ပတ်ဝင်းကျင်တည်ဆောက်မှု့ကို အဓိကထားဖော်ပြမှာ ဖြစ်တဲ့အတွက် Schema Generation နဲ့ ပတ်သက်ပြီး နောက်အခန်းများမှပဲ ဖော်ပြပါတော့မယ်။
ပထမဦးဆုံး Eclipse ကို ဖွင့်ပြီး၊ File > New > JPA Project ကိုရွေးပါမယ်။
EclipseLink Library အား ဖြည့်စွက်ခြင်း
နှစ်သက်ရာ ပရိုဂျက်အမည် တစ်ခုအားပေးပြီး Next ကို နှစ်ခါနှိပ်ပါမယ်။ ဒီနေရာမှာ JPA အတွက် Library ကို ရွေးချယ်ရပါမယ်။
အထက်ဖော်ပြပါအတိုင်း ပလတ်ဖောင်းအား EclipseLink 2.5.x ကို ရွေးချယ်ပြီး၊ ညာဘက်မှ Download ခလုပ်ကို နှိပ်ပါမယ်။
အထက်ဖော်ပြပါအတိုင်း Kepler Version ကို ရွေးပြီး Next ကို နှိပ်တဲ့အခါ လိုင်စင်လိုက်နာကြောင်း ဝန်ခံချက် သဘောတူညီကြောင်း စာမျက်နှာကို ရောက်ပါမယ်။ လိုက်နာကြောင်း အမှတ်အသားပေးပြီး Next ကို နှိပ်တဲ့အခါ လိုင်ဘရီအား အွန်လိုင်းမှ ဒေါင်းလုဒ်လုပ်ပါလိမ့်မယ်။ အင်တာနက်ကိုသုံးပြီး ဒေါင်းလုဒ်လုပ်မှာဖြစ်တဲ့အတွက် ၁၅မိနစ်ခန့် ကြာအောင်စောင့်ရပါမယ်။ အကယ်၍ Glassfish 4.0 ကို ဒေါင်းထားပြီးသားရှိမယ်ဆိုရင် အဲ့ဒီထဲက Jar ဖိုင်တွေကို သုံးပြီး User Lib ကို ဆောက်မယ်ဆိုလဲရပါတယ်။
Finish ခလုပ်ကို နှိပ်လိုက်ရင် JPA ကို အသုံးပြုနိုင်မယ့် Project တစ်ခုကို တည်ဆောက်ပြီး ဖြစ်ပါတယ်။
Derby Library အား ပရိုဂျက်အတွင်း ဖြည့်စွက်ခြင်း
ဒါနဲ့ကျွှန်တော်တို့ပရိုဂျက်အတွက် Derby Connector Library ကို ဖြည့်ဖို့လိုအပ်ပါသေးတယ်။ ဆောက်ထားတဲ့ ပရိုဂျက်အပေါ် ကလစ်ထောက်ပြီး Right Click Menu ကနေ Build Path > Configure Build Path ကို ရွေးပြီး Build Path ကို Configure လုပ်မယ့် Window ကို ဖွင့်ပါမယ်။
ပြီးပါက အောက်ပါအတိုင်း Add External Jars ကို ရွေးပြီး Connector ကို ရွေးမယ့် Window ကို ဖွင့်ပါမယ်။
အောက်ပါအတိုင်း JDK အင်စတောလုပ်ထားတဲ့ Folder အောက်က db\lib\derby.jar အား ရွေးချယ်ပြီး Open Button ကို နှိပ်ပါမယ်။
Library အောက်မှာ darby.jar ကိုတွေ့ရင် OK Button နှိပ်လိုက်တာနဲ့ JPA ပရိုဂျက်မှနေ Derby Database အား Embedded Mode နဲ့ အသုံးပြုလို့ရရှိမှာ ဖြစ်ပါတယ်။
persistence.xml အား ပြုပြင်ရေးသားခြင်း
လိုအပ်တဲ့ Library တွေကို ဖြည့်စွက်ပြီးတဲ့အခါမှာ Project ကနေအသုံးပြုမည့် Database အတွက် သတ်မှတ်ချက်တွေ ရေးသားရပါမယ်။ ဦးစွာ Connection နဲ့ ပတ်သက်ပြီး ရေးသားရမှာဖြစ်ပါတယ်။
ပြီးတာနဲ့ အထက်ဖော်ပြပါအတိုင်း persistence.xml ကို Double Click နှိပ်၍၊ Connection Tab ကို ဖွင့်ကာ အထက်ပါအတိုင်း ဖြည့်စွက်ရပါမယ်။
| Fields | Value |
|---|---|
| Transaction | Type Resource Local |
| Driver | org.apache.derby.jdbc.EmbeddedDriver |
| URL | jdbc:derby:mydb;create=true |
အထက်ဖော်ပြပါအတိုင်း Database Creation မှာ Create ကို ရွေးချယ်ပြီး၊ Create database schema မှာ check on လုပ်ပြီး Save လုပ်လိုက်ရင် ကျွှန်တော်တို့ Java SE ပတ်ဝင်းကျင်ကနေ Derby Database ကို Embedded Mode နဲ့ အသုံးပြုနိုင်မှာ ဖြစ်ပါတယ်။
Entity Class အား ရေးသားခြင်း
ကျွှန်တော်တို့ ပတ်ဝင်းကျင်ပြင်ဆင်မှု့ ပြီးတဲ့အခါမှာ အသုံးပြုမယ့် Entity Class ကို ရေးသားရပါမယ်။ ဒီနေရာမှာတော့ Township Class အား အောက်ပါအတိုင်း ရေးသားပါမယ်။
package com.dtc.firstjpa;
import java.io.Serializable;
import java.lang.String;
import javax.persistence.*;
/**
* Entity implementation class for Entity: Township
*
*/
@Entity
public class Township implements Serializable {
@Id
@GeneratedValue
private int id;
private String name;
private static final long serialVersionUID = 1L;
public Township() {
super();
}
public int getId() {
return this.id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Township Class ထဲမှာ id နဲ့ name သာပါဝင်ပြီး၊ id ကတော့ Primary Key ဖြစ်မယ့် Column ဖြစ်တဲ့အတွက် @id ကို ရေးသားထားပါတယ်။ ပြီးတော့ id ရဲ့ တန်ဖိုးကို Framework ကနေ အလိုအလျှောက် ထုတ်ပေးစေလိုတဲ့အတွက် @GeneratedValue ကိုလည်း ရေးသားထားပါတယ်။ ကျန်တာကတော့ getter နဲ့ setter တွေပါပဲ။
ဒီနေရာမှာ @Entity နေရာမှာ Error တက်လေ့ရှိပါတယ်။ ဒါဟာ Entity Class ဟာ Database မှာမရှိပါဘူးလို့ဆိုတဲ့ အဓိပ္ပါယ်ပါ။ Schema Creation Function ကို သုံးပြီး Table ကို Create လုပ်မှာဖြစ်တဲ့အတွက် Preferences > Java Persistence > JPA > Errors / Warnings ကနေ အောက်ပါအတိုင်း သွားပြင်ထားရင် ရပါပြီ။
Data အား Load လုပ်မယ့် Class အားရေးသားခြင်း
Entity Class ကို ရေးသားပြီးတဲ့အခါမှာ Database ထဲကို ထည့်မယ့် Text File တစ်ခုကို township.txt ဟု Project Folder အောက်မှာ သွားပြီး ရေးထားပါမယ်။ အထဲမှာတော့ အောက်ပါအတိုင်း ရေးဖြည့်ထားလိုက်ပါမယ်။
Yankin Bahan Botahtaung Latharပြီးတဲ့အခါ Text File က Data တွေကို ဖတ်ပြီး Database ထဲကိုသွင်းမယ့် Class ကို ရေးသားပါမယ်။
package com.dtc.firstjpa;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
public class TownshipLoader {
private EntityManager em;
public static void main(String[] args) {
TownshipLoader tl = new TownshipLoader();
try {
tl.load();
tl.showResult();
} catch (IOException e) {
System.err.println(e.getMessage());
}
}
void load() throws IOException {
List<String> lines = Files.readAllLines(Paths.get("township.txt"),
Charset.defaultCharset());
EntityManagerFactory emf = Persistence
.createEntityManagerFactory("first-jpa");
em = emf.createEntityManager();
em.getTransaction().begin();
for (String s : lines) {
Township t = new Township();
t.setName(s);
em.persist(t);
}
em.getTransaction().commit();
}
void showResult() {
String sql = "select t from Township t order by t.id";
List<Township> list = em.createQuery(sql, Township.class)
.getResultList();
for (Township t : list) {
System.out.print(t.getId());
System.out.print("\t");
System.out.println(t.getName());
}
}
}
အထက်ပါ TownshipLoader Class ထဲမှာတော့ load နဲ့ showResult method နှစ်ခုပါပါတယ်။ load ထဲမှာတော့ township.txt ထဲက စာကြောင်းတွေကို ဖတ်ပြီး တစ်ကြောင်းစီကို Township အဖြစ်ပြောင်းကာ Database ထဲကို ထည့်ပါတယ်။စာကြောင်း ၃၁ကိုကြည့်ပါ။ Persistence#createEntityManagerFactory ကို သုံးပြီး EntityManagerFactory ရဲ့ Object ကို ရယူပါတယ်။ အဲ့ဒီမှာ အသုံးပြုတဲ့ Argument ကတော့ String Type ဖြစ်ပြီး၊ persistence.xml မှာရေးထားတဲ့ Persistence Unit ရဲ့ အမည်ပါပဲ။ persistence.xml မှာ အဲ့ဒီအမည်နဲ့ ရေးထားတဲ့ Configuration တွေကို ဖတ်ပြီး EntityManagerFactory Object ကို Create လုပ်ပေးမှာ ဖြစ်ပါတယ်။
စာကြောင်း ၃၃ကို ကြည့်ပါ။ emf.createEntityManagerFactory မက်သတ်ကိုသုံးပြီး EntityManager Object ကို ရယူပြန်တယ်။ EntityManager Object ဟာ Entity Object တွေကို Database ထဲကိုသွားပြီး သိမ်းပေးမယ့် Object ဖြစ်ပါတယ်။
စာကြောင်း ၃၅မှာ em.getTransaction.begin ဆိုပြီး Transaction ကို စတင်နေပါတယ်။
အဲ့ဒီနောက်မှာ For ဝါကျကို သုံးပြီး township.txt ကနေ ဖတ်ယူထားတဲ့ စာကြောင်းတွေကို Township Object မှာ Set လုပ်ပါတယ်။ id ကတော့ Container ကနေအလိုအလျှောက် ဖြည့်ပေးမှာ ဖြစ်တဲ့အတွက် name ကိုသာ Set လုပ်ပါတယ်။
ပြီးတဲ့အခါ em.persist ဆိုပြီး Township Object ကို Persist လုပ်ပါတယ်။
နောက်ဆုံးစာကြောင်း ၄၃မှာ em.getTransaction.commit ဆိုပြီး Update လုပ်ထားတဲ့ Transaction ကို Commit လုပ်ပါတယ်။ အဲ့ဒီအချိန်ရောက်မှ Persist လုပ်ထားတဲ့ Data တွေဟာ Database ထဲကို ရောက်ရှိသွားမှာဖြစ်ပါတယ်။
Java EE ရဲ့ EJB ဒါမှမဟုတ် CDI အတွင်းမှာသာ ရေးသားမည်ဆိုပါက Transaction ကို Container ကနေ ထိမ်းပေးမှာဖြစ်တဲ့အတွက် မလိုအပ်ရင် ရေးစရာမလိုပါ။
Database ထဲရောက်သွားတဲ့ Data တွေကို ပြန်ပြီး ခေါ်ကြည့်နေတာကတော့ showResult method ဖြစ်ပါတယ်။ ဒီတစ်ခေါက် ပတ်ဝင်းကျင်တည်ဆောက်မှု့ကို အဓိကထားဖော်ပြလိုတာ ဖြစ်တဲ့အတွက် ဒီနေရာမှာ အသေးစိတ်ရှင်း မပြတော့ပါဘူး။
လက်တွေ့ TownshipLoader ကို Run ကြည့်ပါမယ်။
အထက်ပါအတိုင်း Text Fileအတွင်းမှာရေးသားထားတဲ့ အချက်တွေ Database ထဲကို ရောက်ရှိသွားတာကို တွေ့ရပါတယ်။
အခုဆိုရင် Eclipse ကိုသုံးပြီး Java EE 7 ရဲ့ JPA 2.1 ကို Java SE ပတ်ဝင်းကျင်မှာ အသုံးပြုနိုင်တာကို တွေ့ရပါပြီ။ နောက်ရက်များတွင် OR Mapping အကြောင်းကို ဆက်လက်၍ ဖော်ပြသွားပါဦးမည်။
လေးစားစွာဖြင့်
မင်းလွင်
No comments:
Post a Comment