ရှေ့ဆက်ပြီး လက်တွေ့ Java EE 7 ၏ Application များကို လက်တွေ့ ရေးသား၍ မိတ်ဆက်သွားပါဦးမည်။ စစချင်း JPA အကြောင်းကို ရေးသားပါမည်။ ပြီးမှ JSF နှင့် EJB ကို မိတ်ဆက်သွားပါမည်။ နောက်ဆုံးတွင် Web Services များအကြောင်းကို ရေးသားသွားပါဦးမည်။ ဤကဲ့သို့ လက်တွေ့ရေးသားနိုင်ရန် Developing ပတ်ဝင်းကျင်အား ပြင်ဆင်ရန် လိုအပ်ပါသည်။ ပတ်ဝင်းကျင်အား မှန်ကန်စွာပြင်ဆင်နိုင်ပါမှ ဆက်လက်၍ အပလီကေးရှင်းများအား ရေးသားနိုင်မည် ဖြစ်၏။
ပြင်ဆင်ရန်လိုအပ်သည်မှာမှာ အောက်ပါ တို့ဖြစ်ကြ၏။
- JDK 1.7 u25 (Latest Version)Java အပလီကေးရှင်းများအား အလုပ်လုပ်စေရန်နှင့်၊ ရေးသားထားသော Source များအား Compile လုပ်၍ Package လုပ်ရန် အတွက် JDK ကို လိုအပ်ပါသည်။ Java EE 7 Feature များအား ရေးသားရန် အတွက် JDK 1.7 ကို လိုအပ်ပါသည်။ အထူးသဖြင့် Glassfish 4 အား အလုပ်လုပ် စေရန် လိုအပ်ပါသည်။
JDK 1.7 Download Site
JDK Installation Guide
- MySQL Community Server 5.6
Enterprise Application များသည် တစ်ခုနှင့် တစ်ခုလည်း ဆက်သွယ်ပြီး အသုံးပြုနိုင်သလို၊ User Interface များအား အသုံးပြု၍ အသုံးပြုသူများနှင့် အပြန် အလှန် ဆက်သွယ် အသုံးပြုနိုင်သည်။ ဤကဲ့သို့ အလုပ်လုပ်ရာတွင် Data များအား တစ်နေရာမှ တစ်နေရာသို့ ပေးပို့ခြင်း၊ ပြုပြင်ပြောင်းလည်းခြင်း အားဖြင့် အလုပ်လုပ်နေကြပါသည်။ Enterprise Application များသည်လည်း ပရိုဂရမ်များအား စုဝေးထားသော အစုအဝေး တစ်ခု ဖြစ်သောကြောင့် ပရိုဂရမ်တစ်ခု အတွင်းရှိ Data များသည် Memory အပေါ်တွင်သာတည်ရှိ၍၊ ပရိုဂရမ် ပြီးဆုံးသွားပါက Memory အပေါ်မှ ပျောက်ကွယ်သွားမည် ဖြစ်သည်။ Enterprise Application များတွင် ဤသို့ဖြစ်၍မရပေ။ Application ၏ State များအား ဖော်ပြနိုင်သော Data များအား ထာဝရ သိမ်းဆည်းထားရန် လိုအပ်ပါသည်။ ဤကဲ့သို့သိမ်းဆည်းရာတွင် File များ အဖြစ်သိမ်းဆည်းခြင်း၊ Object များအား Binary Data များအဖြစ် Serialize လုပ်ခြင်း အစရှိသော နည်းများရှိကြပါသည်။ သို့ရာတွင် Enterprise အတွင်းရှိ Data များသည် အတော်လေးကို များပြား၏။ အချင်းချင်း၏ ပတ်သက်မှု့သည်လည်း Business Requirements များအပေါ်မှုတည်၍ ရှုပ်ထွေးတတ်ပါသေးသည်။ ထိုအချက်များအား ဖြေရှင်းနိုင်ရန်၊ အပလီကေးရှင်းများ အကြားတွင် ဘုံအနေဖြင့် အသုံးပြုနိုင်သော၊ Data များ၏ ပတ်သက်မှု့အား သတ်မှတ်၍ စနစ်ကျစွာအသုံးပြုနိုင်သော၊ Data များအား ရှာဖွေခြင်း၊ အသစ်ဖြည့်စွက်ခြင်း၊ ပြုပြင်ခြင်း၊ ဖျက်ထုတ်ပြစ်ခြင်းတို့တွင် Performance ကောင်းစွာ အလုပ်လုပ်စေနိုင်သော Relational Database များအား အသုံးပြုကြသည်က များပါသည်။ ဤဘလောဂ်တွင်လည်း Opensource Database Management System တစ်ခု ဖြစ်သော MySQL Database အား အသုံးပြုပါမည်။
MySQL Server နှင့် Workbench အား Install လုပ်ရာတွင် .Net V4 Client ကို လိုအပ်ပါသည်။ အကယ်၍ မိမိ၏ ကွန်ပျူတာတွင် ပါဝင်ချင်းမရှိပါက ကြိုတင်၍ Download လုပ်ကာ Install လုပ်ထားရန် လိုအပ်ပါသည်။
MySQL Community Server 5.6 Download
MySQL Server Installation Guide
- MySQL Workbench 6.0
Java EE Application များအား ရေးသားရာတွင် ပုံမှန်အားဖြင့်၊ User Requirements များအား ကောက်ယူကာ ၎င်းတို့အပေါ်တွင်မှုတည်၍ Analysis လုပ်၍ Design ရေးကာ Developing လုပ်ကြပါသည်။ ဤသို့ရေးသားရာတွင် Modeling နည်းလမ်းများအား အသုံးပြု၍ ရေးသားလေ့ရှိကြ၏။
- Requirements များမှ တဆင့် UML ကဲ့သို့ Object Modeling နည်းလမ်းများအား အသုံးပြုကာ ရေးသားသွားကြသည် လည်းရှိ၏။ ရေးသား၍ ရရှိလာသော Entity Object များမှ တဆင့် Java Persistence API အားအသုံးပြုကာ Database များအား Create လုပ်သွားနိုင်ပါသည်။
- Requirements များမှ တဆင့် Data Modeling နည်းလမ်းအား အသုံးပြုကာ Database အား တည်ဆောက်၍၊ ထိုမှ တဆင့် Object Modeling နည်းလမ်းအား အသုံးပြု၍ Application Model အား ရေးသားသည့် နည်းလမ်းလည်း ရှိပါသည်။
MySQL Workbench 6.0 Download
MySQL Workbench 6.0 Installation Guide
- JDK 1.8 EA (For windows 32 bit User Only)
Eclipse EE Package များအား Windows 32 Bit အပေါ်တွင် အလုပ်လုပ်ရာတွင် JRE 6 update 10 နောက်ပိုင်းတွင် Permgen Size မလောက်၍ OutOfMemoryException ကို ဖြစ်ပွားစေလေ့ရှိ၏။ JDK အား Downgrade လုပ်ပြန်ရင်လည်း Java EE 7 အား အလုပ်မလုပ်စေနိုင်ခြင်း၊ Permgen Memory ၏ Max Size အား တိုးကြည့်သော်လည်း အစဉ်မပြေခြင်းတို့ ရှိခဲ့၏။ နောက်ဆုံး JDK 8 အား Download လုပ်ကာ Eclipse အား Run ကြည့်ပါမှ Crush မဖြစ်ပဲ အစဉ်ပြေ သွားပါ တော့သည်။
သို့ရာတွင် သတိပြုရန် အချက်မှာ JDK 8 သည် Early Access သာဖြစ်၍ တရားဝင် Release လုပ်ထားသော Product တစ်ခု မဟုတ်ပါ။ ထို့ကြောင့် မိမိ၏ ပတ်ဝင်းကျင်တွင် အသုံးပြုသော JRE အား လက်ရှိ နောက်ဆုံး ဗားရှင်း ဖြစ်သော JRE 7 Update 25 ကို သာအသုံးပြု၍ JDK 8 အား Eclipse အား Run သည့်နေရာတွင်သာ အသုံးပြုသွားပါမည်။ Windows အား အသုံးပြုရန် မလိုပါက JDK 8 အား အသုံးပြုရန် လိုအပ်မည် မဟုတ်ပါ။
JDK 8 Early Access Download
- Eclipse 4.3 (Kepler EE)
လက်ရှိ Java EE 7 အား ရေးသားနိုင်သည်မှာ Netbeans 7.3.1 နှင့် Eclipse Kepler EE တို့ ဖြစ်ကြ၏။ Maven အား အသုံးပြုပါက အခြားသော Eclipse များနှင့် ရေးသားနိုင်မည် ဖြစ်သော်လည်း Maven အား အသုံးပြုရန်မှာ Internet Connection ကောင်းရန် လိုအပ်ပါသည်။ ဤဘလောဂ်တွင် မိမိ၏ ပတ်ဝင်းကျင်အား Customize လုပ်ရလွယ်ကူ၍၊ နိုင်ငံတကာရှိ Enterprise Developing Environment များတွင် အသုံးများသော Eclipse 4.3 (Kepler EE) အား အသုံးပြုသွားပါမည်။
Eclipse 4.3 (Kepler EE) Download
- Java EE 7 SDK (glassfish 4)
ယခင်တစ်ခေါက် ဘလောဂ်ဖြင့် ဖော်ပြသွားသကဲ့သို့ပင် Java EE Application များအား အလုပ်လုပ်စေနိုင်သည်မှာ Java EE Container များ ဖြစ်ကြသော Web Container နှင့် Enterprise Container များ ဖြစ်ကြပြီး ၎င်းတို့သည် Java EE Server များအပေါ်တွင် ပါဝင် ကြပါသည်။ ဤဘလောဂ်တွင် Java EE 7 အား အလုပ်လုပ်စေနိုင်သော Java EE 7 SDK Glassfish 4 အား အသုံးပြုပါမည်။
Java EE 7 SDK (Glassfish 4) Download
ပတ်ဝင်းကျင် ပြင်ဆင်ခြင်း
အထက်ပါ Software များအား Install လုပ်ပြီးတဲ့ အခါမှာ Developing လုပ်နိုင်ရန်အတွက် Configuration များအား ပြင်ဆင်ရန်လိုအပ်ပါသည်။ ဦးစွာ Windows 32 Bit ဆိုပါက Install လုပ်ထားသော JDK 8 ဖြင့် Eclipse အား Run ရန်အတွက် Bat ဖိုင်တစ်ခုကို ရေးသားရပါမည်။
eclipse.exe -vm "C:\Program Files\Java\jdk1.8.0\bin"
Eclipse အား Unzip လုပ်ထားသော Folder ၏ အောက်တွင် အထက်ပါ စာကြောင်းကို ရေးသားထားသော Text ဖိုင်တစ်ခုအား ရေးသားကာ kepler.bat အမည် ဖြင့် သိမ်းဆည်းပါမည်။ ပြီးပါက အဆိုပါ bat ဖိုင်အား Double Click လုပ်ကာ Eclipse IDE အား ခေါ်ယူပါမည်။
ပြီးပါက Eclipse ၏ Windows > Preferences > Installed JREs တွင် jdk1.7.0_25 အား Default အဖြစ် Configure လုပ်ပါမည်။ လက်ရှိ အသုံးပြုနေသော စက်ထဲတွင် JDK 1.7 နှင့် 1.8 သာရှိကာ Environment Variables ၏ Path တွင် JDK 1.7 ကိုသာ ရေးသားထားသောကြောင့် jdk1.7.0_25 ကိုသာ ဖော်ပြနေ၏။ အကယ်၍ Installed JREs တွင် jdk1.7.0_25 မပါဝင်ပါက ရှာဖွေ၍ ထည့်ပေးရပါမည်။
ပြီးပါက Help > Eclipse Marketplace ကို ဖွင့်ကာ Find Text Box အတွင်း glassfish ဟု ရိုက်ထည့်ကာ Glassfish Tools for Kepler အား Install လုပ်ပါမည်။ လက်ရှိစက်ထဲတွင် Install လုပ်ပြီး ဖြစ်ပါသောကြောင့် update နှင့် Uninstall Button ကိုသာ ဖော်ပြနေပါသည်။ အကယ်၍ Install မလုပ်ရသေးပါက Install Button ကို တွေ့ရမည် ဖြစ်ပါသည်။
Install လုပ်ပြီးသည့်နောက်တွင် Eclipse အား Restart လုပ်ကာ Windows > Preferences ကို ဖွင့်ပါမည်။ ပြီးပါက Server > Runtime Environment တွင် Install လုပ်ထားသော Glassfish 4 အား ဖြည့်စွက်ပါမည်။
ပြီးပါက Add Button အား Click လုပ်၍ New Server Runtime Environment အား Configure လုပ်ပါမည်။
အထက်ဖော်ပြပါ ပုံ အတိုင်း Glassfish 4.0 အား ရွေးချယ်ကာ Next > ကို Click လုပ်ပါမည်။
အထက်ပုံတွင် ဖော်ပြထားသည့်အတိုင်း JRE နေရာတွင် jdk1.7.0_25 အား ရွေးချယ်၍၊ Glassfish Server Directory နေရာတွင် Glassfish 4 အား Install လုပ်ထားသည့် Folder ၏ အောက်မှ glassfish Folder အား ရွေးချယ်ကာ Next > အား Click လုပ်ပါမည်။
Administrator Password အား လိုအပ်ပါက ဖြည့်စွက်၍ Finish အား Click လုပ်ပါမည်။ ကျွှန်တော်ကတော့ Developing Server အဖြစ်အသုံးပြုမည် ဖြစ်သောကြောင့် အထွေအထူး Password အား မဖြည့်တော့ပါ။
အထက်ဖော်ပြပါအတိုင်း Runtime Environments အတွင်း GlassFish 4.0 အားတွေ့ရှိပါက Java EE 7 ၏ Feature များအား Eclipse ဖြင့် ရေးသားရန် အစဉ်သင့်ဖြစ်ပြီ ဖြစ်ပါသည်။
First Java EE 7 Application
ပတ်ဝင်းကျင် ပြင်ဆင်ပြီးပါက နမှုနာ အပလီကေးရှင်းတစ်ခုအား ရေးသားကြည့်ပါမည်။ JSF 2.2, EJB 3.2 နှင့် JPA 2.1 တို့အား အသုံးပြု၍ နမှုနာ အပလီကေးရှင်းတစ်ခု ရေးသားကြည့်ပါမည်။
Configuration ၏ နေရာရှိ Modify Button အား Click လုပ်၍ Configuration များအား ပြင်ဆင်ရေးသားပါမည်။
အထက်ဖော်ပြပါ အတိုင်း Java Server Faces နှင့် JPA တို့အား အသစ်ရွေးချယ်ကာ OK အား Click လုပ်ပါမည်။ ပြီးပါက New Dynamic Web Project Configuration Window ၏ Next Button အား နှစ်ကြိမ် Click လုပ်၍ JPA Facet အား Configure လုပ်ပါမည်။
အထက်ဖော်ပြပါအတိုင်း JPA Implementation တွင် Glassfish System Library အား ရွေးချယ်၍၊ Next > အား Click နှစ်ခါ နှိပ်ကာ၊ JSF Capabilities အား Configure လုပ်ပါမည်။
JSF Implementation Library ၏ Type အား Glassfish System Library အား ရွေးချယ်ကာ Finish Button အား Click လုပ်ပါက Java EE 7 Feature များ ဖြစ်ကြသည့် JSF 2.2, EJB 3.2 နှင့် JPA 2.1 တို့အား အသုံးပြုနိုင်သော Dynamic Web Project အား Create လုပ်ပြီး ဖြစ်ပါသည်။
JSF 2.2 အား ရေးသားခြင်း
ဦးစွာ ပရိုဂျက်၏ WebContent/WEB-INF/ အောက်ရှိ web.xml အား အောက်ပါအတိုင်း ပြုပြင် ရေးသားပါမည်။
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" version="3.1">
<display-name>address</display-name>
<welcome-file-list>
<welcome-file>index.xhtml</welcome-file>
</welcome-file-list>
<servlet>
<servlet-name>Faces Servlet</servlet-name>
<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>Faces Servlet</servlet-name>
<url-pattern>*.xhtml</url-pattern>
</servlet-mapping>
</web-app>
index.xhtml အား Welcome File အဖြစ် အသုံးပြုရန် စာကြောင်း 4,5,6 အား ဖြည့်စွက်ထားပါသည်။ xhtml ဖြင့် ဆုံးသော URL များဆိုပါက Faces Servlet အား ခေါ်ယူရန် စာကြောင်း ၁၄အား ပြုပြင် ရေးသားထားပါသည်။
တဖန် Address များအား Register လုပ်ရန်နှင့်၊ ဖော်ပြရန် အတွက် index.xhtml ကို ရေးသားရန် လိုအပ်ပါသည်။
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:f="http://java.sun.com/jsf/core"
xmlns:h="http://java.sun.com/jsf/html">
<h:head>
<title>Address Book</title>
<h:outputStylesheet library="css" name="theme.css" />
</h:head>
<h:body>
<h1>Address Book</h1>
<h:form>
<h:panelGrid columns="2">
<h:outputLabel value="Name"></h:outputLabel>
<h:inputText value="#{userBean.user.name}"
required="true" requiredMessage="You need to fill name"></h:inputText>
<h:outputLabel value="Phone"></h:outputLabel>
<h:inputText value="#{userBean.user.phone}"
required="true" requiredMessage="You need to fill phone."></h:inputText>
<h:outputLabel value="Address"></h:outputLabel>
<h:inputText value="#{userBean.user.address}"
required="true" requiredMessage="You need to fill Address."></h:inputText>
<h:outputLabel value="Profile"></h:outputLabel>
<h:inputTextarea value="#{userBean.user.profile}" rows="5" cols="40">
<f:validateLength minimum="10" maximum="250"></f:validateLength>
</h:inputTextarea>
<h:commandButton value="Add New User" action="#{userBean.add}"></h:commandButton>
</h:panelGrid>
<h:messages style="color:red"></h:messages>
<h2>Address List</h2>
<h:dataTable id="users" value="#{userBean.list}" var="user"
rendered="#{not empty userBean.list}"
styleClass="table" headerClass="header"
rowClasses="odd,even">
<h:column>
<f:facet name="header">
<h:outputText style="font-weight:blod" value="Name"></h:outputText>
</f:facet>
#{user.name}
</h:column>
<h:column>
<f:facet name="header">
<h:outputText style="font-weight:blod" value="Phone"></h:outputText>
</f:facet>
#{user.phone}
</h:column>
<h:column>
<f:facet name="header">
<h:outputText style="font-weight:blod" value="Address"></h:outputText>
</f:facet>
#{user.address}
</h:column>
<h:column>
<f:facet name="header">
<h:outputText style="font-weight:blod" value="Profile"></h:outputText>
</f:facet>
#{user.profile}
</h:column>
</h:dataTable>
</h:form>
</h:body>
</html>
ပြီးပါက MVC Architecture ၏ Model နေရာတွင်ရှိသော JSF ၏ Backing Bean ဖြစ်သည့် UserBean ကို ရေးသားပါသည်။
package com.dtc.address.mbean;
import java.util.List;
import javax.annotation.PostConstruct;
import javax.ejb.EJB;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.RequestScoped;
import com.dtc.address.ejb.AddressManager;
import com.dtc.address.entity.User;
@ManagedBean
@RequestScoped
public class UserBean {
@EJB
private AddressManager am;
private User user = new User();
private List<User> list;
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public List<User> getList() {
return list;
}
public void setList(List<User> list) {
this.list = list;
}
@PostConstruct
public void init() {
this.list = this.am.getUsers();
}
public String add() {
this.am.create(user);
this.init();
return "index";
}
}
UserBean တွင် Properties အနေဖြင့် User Object အား Manage လုပ်ရန်အတွက် EJB Class ဖြစ်သော AddressManager, Input Data များအား လက်ခံရယူရန် အတွက် User နှင့် Address List Table တွင် ဖော်ပြရန် အတွက် List<user> တို့၏ Object များအား ရေးသားရန် လိုအပ်ပါသည်။ ပြီးပါက UserBean အား Container မှ Construct လုပ်ပြီးသည့်အခါတွင် အလုပ်လုပ်ရန် အတွက် @PostContrust annotation ဖြင့် init method အား ရေးသားပါသည်။ ၎င်းအတွင်းတွင် AddressManager ၏ Object ဖြစ်သော am အား အသုံးပြုကာ User List အား ရယူ၍ မိမိ၏ List<User> တွင် အစားထိုးပါသည်။ ဤသို့ရေးသားထားခြင်း အားဖြင့် index.xhtml အား ဖော်ပြသည့်အခါတွင် Database အတွင်းတွင် Data များရှိပါက Address List Table တွင် ဖော်ပြပေးနိုင်မည် ဖြစ်ပါသည်။
JPA အား ရေးသားခြင်း
နမှုနာ အပလီကေးရှင်း၏ Data များအား သိမ်းဆည်းရန် MySQL Database တွင် အောက်ပါ DDL အား အသုံးပြု၍ Table အား တည်ဆောက်ပါသည်။
CREATE DATABASE address;
USE database
CREATE TABLE user (
id INT NOT NULL AUTO_INCREMENT,
name VARCHAR(45) NOT NULL,
address VARCHAR(45) NOT NULL,
phone VARCHAR(45),
profile VARCHAR(255),
PRIMARY KEY (id)
) ENGINE=InnoDB;
ပြီးပါက အဆိုပါ user table ၏ Entity Class ဖြစ်သော User.java အား ရေးသားပါသည်။
package com.dtc.address.entity;
import java.io.Serializable;
import javax.persistence.*;
/**
* The persistent class for the user database table.
*
*/
@Entity
@NamedQuery(name="User.findAll", query="SELECT u FROM User u")
public class User implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private int id;
private String address;
private String name;
private String phone;
private String profile;
public User() {
}
public int getId() {
return this.id;
}
public void setId(int id) {
this.id = id;
}
public String getAddress() {
return this.address;
}
public void setAddress(String address) {
this.address = address;
}
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public String getPhone() {
return this.phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getProfile() {
return this.profile;
}
public void setProfile(String profile) {
this.profile = profile;
}
}
Entity Class အဖြစ်အသုံးပြုရန် အတွက် @Entity အား ရေးသားရန် လိုအပ်ပြီး၊ Serializable Interface အား Implement လုပ်ရန် လိုအပ်ပါသည်။ အတွင်းရှိ Properties များသည် Table ၏ Column များ၏ Name အတိုင်း အသုံးပြုပါသဖြင့် အထွေအထူး Annotation များအား ရေးသားရန် မလိုအပ်ပဲ၊ Default အတိုင်း ရေးသားနိုင်ပါသည်။ ID အဖြစ်အသုံးပြုမည့် id ၏ ရှေ့တွင် @ID ကို ရေးသားရန်လိုအပ်ပြီး Auto Increment အား အသုံးပြုလိုပါသောကြောင့် GeneratedValue Annotation တွင် GenerationType.IDENTITY အား အသုံးပြုရေးသားပါသည်။ပြီးပါက persistence.xml အား အောက်ပါအတိုင်း ရေးသားပါသည်။
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
<persistence-unit name="address">
<jta-data-source>jdbc/address</jta-data-source>
<class>com.dtc.address.entity.User</class>
</persistence-unit>
</persistence>
JTA Datasource အနေဖြင့် jdbc/address အား အသုံးပြုပါသည်။ အပလီကေးရှင်း အတွင်းမှ အသုံးပြုနိုင်ရန် အတွက် Glassfish Server ၏ Admin Console ဖြင့် Datasource အား ကြိုတင်ပြင်ဆင်ထားရန် လိုအပ်ပါသည်။Glassfish Server Datasource Configuration Guide
ထို့အပြင် Server Library အတွင်းတွင်လည်း MySQL ၏ connector အားလည်း ကြိုတင် ဖြည့်စွက်ထားရန် လိုအပ်ပါသည်။ ဘလောဂ်မှာအလွန်ရှည်လာပြီဖြစ်သောကြောင့် ဤနေရာတွင် အသေးစိတ် မဖော်ပြတော့ပါ။ နောက် အခန်းများဖြင့် အသေးစိတ် ရှင်းလင်းသွားပါဦးမည်။
EJB အား ရေးသားခြင်း
နောက်ဆုံးတွင် JSF ၏ Backing Bean ဖြစ်သော UserBean အတွင်းမှ Entity ဖြစ်သော User အား Management လုပ်နိုင်ရန်အတွက် Business Logic များအား Stateless Session Bean အဖြစ် AddressManager Class အား ရေးသားပါမည်။
package com.dtc.address.ejb;
import java.util.List;
import javax.ejb.LocalBean;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import com.dtc.address.entity.User;
/**
* Session Bean implementation class AddressManager
*/
@Stateless
@LocalBean
public class AddressManager {
@PersistenceContext(name = "address")
private EntityManager em;
public List<User> getUsers() {
return this.em.createNamedQuery("User.findAll", User.class)
.getResultList();
}
public void create(User user) {
this.em.persist(user);
}
}
AddressManager အတွင်းတွင် EntityManager အား @PersistenseContext Annotation ဖြင့် ရေးသားထားသောကြောင့် Enterprise Container မှ အလိုအလျှောက် Create လုပ်ပေးနိုင်မည် ဖြစ်ပါသည်။
Backing Bean အတွင်းမှ ခေါ်ယူရန် အတွက် List<User> အား ရရှိနိုင်သော getUsers Method နှင့် User များအား Database အတွင်း သိမ်းဆည်းပေးနိုင်သော create Method တို့အား ရေးသားထားပါသည်။getUsers Method အတွင်းတွင် EntityManager မှတဆင့် User.findAll အမည်ဖြင့် ရေးသားထားသော NamedQuery Object အား ခေါ်ယူကာ၊ User များအား List အနေဖြင့်ရယူကာ Return ပြန်လုပ်ပေးပါသည်။ create Method အတွင်းမှာမူ EntityManager#persist Method ဖြင့် User Object အား Database အတွင်း သိမ်းဆည်းပါသည်။
ရေးသားထားသော ပရိုဂျက်အား Run ကြည့်သောအခါ အောက်ပါအတိုင်း ဖော်ပြနိုင်သည်ကို တွေ့ရပါသည်။
ဤတစ်ခေါက်တွင် Eclipse Kepler EE အား အသုံးပြု၍ Java EE 7 ၏ Features များဖြစ်ကြသော JSF2.2, EJB3.2 နှင့် JPA2.1 တို့အား အလွယ်တကူ ရေးသားနိုင်ကြောင်းကို တွေ့ရပါသည်။
နမှုနာ အဖြစ်ရေးသားထားသော Source များအား အောက်ပါလင့်ခ်မှ ရယူနိုင်ပါသည်။
https://github.com/minlwin/mmju/tree/master/address
ဆက်ပါဦးမည်။ လေးစားစွာဖြင့်
မင်းလွင်
thank brother, ple
ReplyDeleteCan we use java EE 8? How can we use?
I am sorry. Do you mean Java EE 7 or Java SE 8?
ReplyDeleteJava SE 8 will release next year and Java EE 8 is not release yet.
If you want to use Java SE 8 you can download from Early Access Release.
https://jdk8.java.net/
Java.net cant access from Myanmar IP, so you need to use some proxy from other country.