Java Enterprise Edition (J2EE) - PROGRAMMING LOGIC

Breaking

Sunday, 27 March 2016

Home Unlabelled Java Enterprise Edition (J2EE)

Java Enterprise Edition (J2EE)

Java Enterprise, J2EE, Java EE adalah istilah-istilah yang mungkin sulit dimengerti oleh sebagian orang, bahkan programer Java (yang baru) sekalipun. Di artikel kali ini, saya akan berusaha memberikan gambaran, apa itu Java Enterprise, dan bagaimana kita bisa memanfaatkannya dalam membangun sebuah aplikasi.
J2EE adalah singkatan dari Java 2 Enterprise Edition, dan sejak versi 5 berubah menjadi Java EE atau cukup Java Enterprise Edition. Java EE adalah sebuah spesifikasi, bukan berupa product berwujud nyata. Ada banyak vendor software atau komunitas opensource membuat software berupa application server yang mengikuti standard Java EE sehingga disebut Java EE compliant application server.
Application server ini memungkinkan kita untuk membuat aplikasi berskala enterprise dengan lebih mudah karena application server sudah menyediakan berbagai fasilitas yang siap untuk digunakan sebagai pendukung aplikasi kita.
Full Java EE compliant application server menyediakan berbagai service seperti web container, messaging, web service, mail, directory service, database connectivity, distributed transaction, remoting, persistence, dan lain lain.
Contoh application server adalah Glassfish, Oracle AS, JBoss, IBM Websphere, JRun, JOnAS, dll. Apache Tomcat adalah salah satu webserver/webcontainer untuk aplikasi web Java yang cukup terkenal, tapi bukan termasuk Java EE application server karena tidak menyediakan semua service yang ada di spesifikasi Java EE. Jika kita membuka website sun.java.com, dan menuju halaman tentang Java EE, maka kita bisa mendownload salah satu produk implementasi Java EE yang dibuat di bawah kendali Sun Microsystem, yaitu Sun Java System Application Server, yang sebenarnya adalah nama lain dari Glassfish application server.
Mengapa perlu ada Java EE ?
Untuk menjawab pertanyaan ini, perlu sedikit kilas balik tentang apa yang sudah dilakukan oleh para developer untuk membuat aplikasi “enterprise”, sebelum munculnya Java EE. Aplikasi enterprise dapat diasumsikan sebagai aplikasi yang kompleks, melakukan hal-hal yang penting (critical), memerlukan performa yang tinggi, menangani banyak tugas, ber-antarmuka dengan sistem-sistem yang lain, terdistribusi, dan sederet istilah lainnya yang mencerminkan bahwa aplikasi tersebut jauh dari kata “sederhana”.
Untuk membangun sebuah aplikasi enterprise, kita membutuhkan banyak fasilitas, seperti web interface, messaging, distributed transaction, web service, dan lain lain. Sebelum ada spesifikasi Java EE, developer harus membangun sendiri semua komponen ini. Alternatifnya, kita bisa membeli application server yang dibuat oleh beberapa vendor, dimana cara penggunaannya dan bagaimana kita membangun aplikasi di atasnya akan sangat tergantung pada jenis application server yang kita beli. Hal ini menjadi sesuatu yang sulit ketika kita ingin mengembangkan aplikasi melebihi dari apa yang disediakan vendor, atau ingin memindahkan aplikasi kita ke application server lain. Ini bisa membuat developer harus melakukan coding ulang keseluruhan aplikasi.
Java EE menyediakan spesifikasi yang terbuka dan terstandarisasi, sehingga kita bisa membangun aplikasi yang mengikuti spesifikasi Java EE, dan ketika kita sudah sampai pada tahap implementasi kita bisa dengan mudah memilih application server mana yang kita inginkan. Migrasi antar application serverpun menjadi sangat mudah karena server yang baru juga mengimplementasikan spesifikasi yang sama, yaitu Java EE.
Java EE design model
Desain Java EE mengacu pada 3 tier application design. Seperti kita ketahui, desain aplikasi sederhana biasanya menggunakan desain 2 tier, atau yang biasa disebut client-server. Aplikasi 2 tier terdiri atas aplikasi client (user interface) yang juga memuat semua business logic aplikasi. Aplikasi client ini berhubungan secara langsung dengan tier ke dua yaitu database server.
Konsep yang digunakan di Java EE dengan 3 tier application design, bertujuan untuk memisahkan business logic aplikasi dengan user interface menjadi 2 bagian yang terpisah. Jadi, desain aplikasi ini terdiri dari user interface, business logic server, dan enterprise information server (EIS). Dengan adanya pemisahan ini, aplikasi menjadi lebih modular. User interface dan business logic component memiliki tugas masing-masing.
User Interface Component
User interface bisa dibuat dengan 2 cara, thin dan thick client.
Thin client merupakan sebutan untuk user interface yang berbasis web. Komponen web interface ini disusun di sisi server kemudian hasilnya dirender oleh web browser yang dijalankan di client. Untuk komponen ini, Java menyediakan Servlet, Java Server Page (JSP), dan Java Server Faces (JSF).
Cara kedua adalah menggunakan user interface berbasis Graphical User Interface (GUI), atau yang disebut juga thick client karena aplikasi berjalan sepenuhnya menggunakan resource dari komputer client. Untuk komponen ini, Java menyediakan Swing dan Abstract Windowing Toolkit (AWT).
Command line atau text based user interface tentunya juga dapat digunakan, meskipun biasanya jarang digunakan untuk aplikasi enterprise. User interface ini biasanya juga digolongkan ke dalam thick client.
Business Logic Server
Komponen ini merupakan pusat dari semua proses bisnis (business logic) aplikasi. Sebagai gambaran, pada sebuah aplikasi internet banking, business logicnya meliputi autentikasi dan otorisasi user, query saldo, pembayaran kartu kredit, pembayaran bill/tagihan, transfer, dan sebagainya. Semua proses ini ditangani oleh business logic component yang berjalan di dalam sebuah application server. Java menyediakan komponen yang bernama Enterprise Java Bean (EJB) untuk melakukan hal ini.
Enterprise Information Server
EIS adalah server yang menangani manajemen data. Umumnya berupa sebuah database server. Namun tidak menutup kemungkinan untuk menggunakan sistem lain (seperti legacy system) sebagai EIS. Layer ini berada di luar batasan Java EE. Java EE hanya menyediakan standard API untuk mengakses EIS, tapi tidak menyediakan implementasinya.
Java EE Application Programming Interface (API)
Ada banyak sekali API yang disupport oleh spesifikasi Java EE, diantaranya:
1. Java Persistence API (JPA)
2. Java Transaction API (JTA)
3. Java Messaging Service (JMS)
4. Web Service
5. Java Connector Architecture (JCA)
6. Java Authentication and AuthorizationService (JAAS)
7. Java Mail
8. Web Component (Servlet, JSP, JSF, JSTL)
9. Java Management
Dan masih banyak API yang lain. Lengkapnya bisa dilihat disini.
Anda sudah tidak sabar ? Mari kita mulai !
Kali ini saya akan menggunakan skenario yang paling sederhana, tetapi memenuhi desain 3 tier yang digunakan pada spesifikasi Java EE. Kita akan mendesain kembali aplikasi calculator yang sebelumnya kita buat hanya dengan console dan Swing di artikel sebelumnya.
Artikel ini merupakan tutorial yang berisi aplikasi kalkulator sederhana dengan menggunakan arsitektur Java EE. Jika Anda belum tahu tentang apa itu Java EE, silahkan baca artikel ini terlebih dahulu. Kali ini kita akan menggunakan Netbeans 6.1 sebagai IDE dan Glasshfish v2 sebagai application servernya.
1. Download & install
Kedua software tersebut bisa didownload sekaligus di http://download.netbeans.org/netbeans/6.1/final/. Install netbeans dan glassfish di komputer Anda dengan mengikuti wizard.
2. Setup Project
Start Netbeans, pilih menu File -> New Project.
Pada dialog New Project, pilih categori Enterprise -> Enterprise Application, klik Next.
Masukkan nama project TestEnterpriseProject.
Pilih Server Glassfish V2, Java EE Version 5, dan pastikan Anda mengaktifkan pilihan Create EJB Module dan Create Web Application Module, kemudian klik Finish.
Maka Netbeans akan mengcreate project TestEnterpriseProject sebagai project utama, project TestEnterpriseProject-ejb sebagai sub-project untuk modul EJB, dan TestEnterpriseProject-war sebagai sub-project untuk modul web.
Struktur project seperti tampak pada gambar berikut:
3. EJB module
Ada 3 macam EJB dalam spesifikasi EJB versi 3.0 (EJB3) :
a. Session Bean
Session bean adalah EJB yang digunakan untuk mengeksekusi proses. Isi dari Session Bean ini biassanya berupa kata kerja (transfer, pay, calculate, updateData, dll). Stateless Session Bean (SLSB) adalah Session Bean yang tidak menyimpan state (keadaan) pada setiap kali eksekusi. Berbeda dengan Statefull Session Bean (SFSB) yang dapat menyimpan state. State ini dapat kita gunakan misalnya untuk menyimpan informasi user atau barang-barang yang sudah dibeli (pada kasus online shop).
b. Entity Bean
Entity Bean adalah EJB yang digunakan untuk mempermudah manipulasi database. Konsepnya adalah Object – Relational Mapping (ORM) yang berarti memetakan object dengan data di dalam database. Entity Bean sebenarnya adalah spesifikasi “bawaan” dari versi EJB sebelumnya yaitu EJB 2.1. Dalam EJB3, ada API lain yang lebih sederhana yaitu Java Persistence API (JPA). Sekarang orang lebih banyak menggunakan JPA dibandingkan Entity Bean.
c. Message Driven Bean
Message Driven Bean (MDB) adalah EJB yang digunakan untuk keperluan messaging menggunakan Java Messaging Service (JMS).
Kali ini kita akan menggunakan Stateless Session Bean. Session Bean karena kita akan melakukan pertihutang matematik, Stateless karena kita tidak perlu menyimpan informasi apapun.
Klik kanan di sub-project EJB, pilih New -> Session Bean. Masukkan properties berikut:
EJB Name: CalculatorSession
Package: suhearie.blog.enterprise.ejb
Session Type: Stateless
Create Interface: Local
Netbeans secara otomatis akan meng-create class CalculatorSessionBean sebagai bean class dan CalculatorSessionLocal sebagai interface. Untuk membuat Session Bean, kita membutuhkan sebuah interface dan sebuah class. Interface digunakan untuk menentukan method apa yang bisa dipanggil oleh client, sedangkan bean class merupakan implementasi dari method tersebut.
Business Logic Interface – Local
Interface CalculatorSessionLocal diberi annotation @Local, artinya interface ini bisa diakses oleh client yang “local” atau berada dalam JVM yang sama dengan EJB server. Client yang kita gunakan adalah web component (JSP dan Servlet) yang berjalan di application server yang sama, sehingga kita cukup menggunakan Local interface. Di interface ini, kita hanya mendefinisikan satu method saja yaitu calculate yang menerima parameter-parameter berupa OPERATION, operand1 dan operand2.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package suhearie.blog.enterprise.ejb;
 
import javax.ejb.Local;
 
/**
 *
 * @author sarianto
 */
@Local
public interface CalculatorSessionLocal {
 
    public enum OPERATION {ADD, SUBSTRACT, MULTIPLY, DIVIDE};
 
    public int calculate(OPERATION operation, int oper1, int oper2);
 
}
Bean Class – Business Logic Implementation
Class CalculatorSessionBean adalah implementasi dari interface CalculatorSessionLocal. Kita menandainya dengan annotation @Stateless yang berarti kita mendefinisikannya sebagai Stateless Session Bean. Pada implementasi method calculate, kita melakukan perhitungan matematika yang sebenarnya.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package suhearie.blog.enterprise.ejb;
 
import javax.ejb.Stateless;
 
/**
 *
 * @author sarianto
 */
@Stateless
public class CalculatorSessionBean implements CalculatorSessionLocal {
 
    public int calculate(OPERATION operation, int oper1, int oper2) {
        switch(operation) {
            case ADD:
                return oper1+oper2;
            case SUBSTRACT:
                return oper1-oper2;
            case MULTIPLY:
                return oper1*oper2;
            case DIVIDE:
                return oper1/oper2;
            default:
                throw new UnsupportedOperationException("Not supported yet.");
        }
    }
}
4. Web Module
Kita akan menggunakan web sebagai user inteerface. Komponen yang akan digunakan adalah Servlet dan JSP.
a. Servlet
Servlet adalah komponen web yang berupa java class yang mengextends javax.servlet.http.HttpServlet. Class ini biasanya digunakan untuk menangani http request, melakukan processing, kemudian memberikan hasil processing tersebut ke halaman JSP untuk ditampilkan di browser. Konsep ini disebut Model-View-Controller (MVC).
b. Java Server Page (JSP)
JSP mirip dengan PHP atau ASP yang merupakan halaman HTML yang dapat disisipi dengan kode java (scriplet). Tujuannya untuk memudahkan developer dalam merancang user interface.
File index.jsp, kita gunakan untuk membuat form html yang akan mensubmit parameter-parameter yang digunakan untuk melakukan perhitungan. Netbeans sudah menyediakan file index.jsp ini di dalam folder TestEnterpriseProject-war -> Web Pages. Edit file tersebut sehingga menjadi seperti berikut. Form html disubmit ke servlet (CalculatorServlet), yang sesaat lagi akan kita buat.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<html>
    <head>
        <title>Java EE Calculator</title>
    </head>
    <body>
<h2>Welcome to Java EE Calculator Test Project !</h2>
<form action='<%=request.getContextPath()%>/CalculatorServlet' method='POST'>
            Operation:
            <select name="operation">
                <option selected value="ADD">ADD</option>
                <option value="SUBSTRACT">SUBSTRACT</option>
                <option value="MULTIPLY">MULTIPLY</option>
                <option value="DIVIDE">DIVIDE</option>
            </select>
 
            Operand 1:<input type="text" name="oper1" value="0" />
 
            Operand 2:<input type="text" name="oper2" value="0" />
 
            <input type="submit" value="Calculate" name="Calculate" />
        </form>
    </body>
</html>
Create servlet, dengan cara klik kanan di module TestEnterpriseProject-war, pilih New -> Servlet. Isikan class name CalculatorServlet, dan package suhearie.blog.enterprise.servlet. Klik next, pastikan option untuk memasukkan informasi servlet ini ke file deployment descriptor diaktifkan, kemudian klik finish.
Modifikasi servlet tersebut menjadi seperti berikut.
Di class ini kita memiliki satu class variable bertipe CalculatorSessionLocal dan memberinya annotation @EJB yang berarti application server akan meng-inject object tersebut secara otomatis ke dalam servlet kita. Konsep ini disebut dengan dependency injection. Selanjutnya, kita mengambil parameter-parameter yang dikirim melalui http request, kemudian menggunakan session bean untuk melakukan perhitungan berdasarkan parameter-parameter tersebut. Hasil perhitungan kita masukkan sebagai attribut di object request. Untuk menampilkannya, kita akan memforward request menuju ke halaman JSP CalculatorPage.jsp (kita buat sesaat lagi) menggunakan RequestDispatcher.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
package suhearie.blog.enterprise.servlet;
 
import java.io.*;
 
import javax.ejb.EJB;
import javax.servlet.*;
import javax.servlet.http.*;
import suhearie.blog.enterprise.ejb.CalculatorSessionLocal;
 
/**
 *
 * @author sarianto
 */
public class CalculatorServlet extends HttpServlet {
 
    /**
    * Processes requests for both HTTP <code>GET</code> and <code>POST</code> methods.
    * @param request servlet request
    * @param response servlet response
    */
    @EJB
    CalculatorSessionLocal calculatorSession;
    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        String operation = request.getParameter("operation");
        int oper1 = Integer.parseInt(request.getParameter("oper1"));
        int oper2 = Integer.parseInt(request.getParameter("oper2"));
 
        int result = calculatorSession.calculate(CalculatorSessionLocal.OPERATION.valueOf(operation), oper1, oper2);
        request.setAttribute("result", result);
        request.getRequestDispatcher("/CalculatorPage.jsp").forward(request, response);
    }
 
    // <editor-fold defaultstate="collapsed" desc="HttpServlet methods. Click on the + sign on the left to edit the code.">
    /**
    * Handles the HTTP <code>GET</code> method.
    * @param request servlet request
    * @param response servlet response
    */
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        processRequest(request, response);
    }
 
    /**
    * Handles the HTTP <code>POST</code> method.
    * @param request servlet request
    * @param response servlet response
    */
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        processRequest(request, response);
    }
}
File CalculatorPage.jsp, kita gunakan untuk menampilkan hasil perhitungan.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Java EE Calculator</title>
    </head>
    <body>
<h2>Java EE Calculator Result:</h2>
Operation: <%=request.getParameter("operation")%>
        Operand 1: <%=request.getParameter("oper1")%>
        Operand 2: <%=request.getParameter("oper2")%>
        Result:<B> <%=  request.getAttribute("result")%></B>
        <a href='<%=request.getContextPath()%>/'>BACK</a>
    </body>
</html>
Setelah selesai semua, pindah ke tab Services, buka tree Servers, klik kanan di Glassfish, pilih Start untuk menjalankan Glassfish application server. Setelah glassfish berjalan, kembali ke tab Projects, klik kanan di TestEnterpriseProject, pilih Undeploy and Deploy. Setelah proses undeploy dan deploy selesai, buka web browser anda dan masukkan alamat http://localhost:8080/TestEnterpriseProject-war, dan Anda akan melihat halaman seperti berikut:

Masukkan parameter, kemudian klik tombol Calculate, maka hasilnya akan ditampilkan:


Sumber : https://suhearie.wordpress.com/2008/08/26/java-enterprise-mulai-dari-mana/
Share This
By on