Pembuatan game menggunakan (menggunakan Game maker) Buat UAS

Pembuatan Game menggunakan Game maker Versi 8.1
permainan Game domino sample.

 

Praktek: Membangun aplikasi Client-Server dengan metode RMI di java

5 Juni 2013

Buat Projek untuk client server di netbeans, seperti berikut, :
package com.echo.clientserver.sayhello.server;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
/**
 *
 * @author dodis
 */
public class Main {
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws RemoteException {
        Registry registry = LocateRegistry.createRegistry(1099);
        sayHelloServer sayHello = new sayHelloServer();
        registry.rebind(“sayHello”, sayHello);
        System.out.println(“server telah berjalan (you should run)”);
        // TODO code application logic here
    }
}
masih dalam satu projek buat lagi file dengan nama SayHelloServer.java, berikut codingnya:
package com.echo.clientserver.sayhello.server;
import com.echo.clientserver.sayhello.SayHello;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
/**
 *
 * @author dodis
 */
public class sayHelloServer extends UnicastRemoteObject implements SayHello{
    
    public sayHelloServer() throws RemoteException{
    }
    public String sayHello(String nama) throws RemoteException{
           System.out.println(“Client Dengan Nama “+nama+”Melakukan Request”);
           return “Hello “+nama;
    }
}
Buat projek untuk clientnya, buat dengan java gui berikut design dan codingnya:

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package com.echo.clientserver.sayhello.client;
import javax.swing.SwingUtilities;
/**
*
* @author dodis
*/
public class Main {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
SwingUtilities.invokeLater(new Runnable(){
public void run(){
FormClient client = new FormClient();
client.setVisible(true);
}
});
}
}
Buatlah projek lagi untuk RMI nya:
package com.echo.clientserver.sayhello;
import java.rmi.Remote;
import java.rmi.RemoteException;
/**
*
* @author dodis
*/
public interface SayHello extends Remote {
public String sayHello(String nama) throws RemoteException;
}
Kemudian Jalankan Server terlebih dahulu



lalu jalankan clientnya, dan inputkan nama anda, maka akan muncul respon dari server.

Posted by dodis
Filed in Catatan Kuliah, Client Server
Kaitkata:Catatan Kuliah Client Server

Tinggalkan sebuah Komentar »

Multithreading

Multithreading

1 Mei 2013

Multithreading mengacu kepada dua atau lebih task (tugas, thread) yang berjalan (sedang dieksekusi) di dalam satu program. Thread merupakan suatu path eksekusi independen di dalam program. Banyak thread dapat nerjalan secara konkuren (berbarengan) di dalam program. Setiap thread di dalam Java dibuat dan dikendalikan oleh kelas java.lang.Thread. Suatu program Java dapat mempunyai banyak thread, dan thread-thread ini dapat berjalan secara bersamaan, secara asinkron atau sinkron.
Multithreading mempunyai beberapa keuntungan, dibandingkan multiprocessing, di antaranya:

• Thread bersifat lightweight, sedangkan proses lebih berat. Perlu diketahui bahwa proses adalah program yang sedang berada di memory atau processor, sedang dieksekusi. Thread dapat diartikan sebagai anak dari proses.
• Thread-thread berbagi pakai ruang alamat yang sama dan karena itu dapat berbagi pakai data dan kode (instruksi)
• Context switching antar thread biasanya lebih murah daripada antar proses.
• Biaya komunikasi antar thread relatif lebih rendah daripada komunikasi antar proses.
• Thread memungkinkan task-task berbeda dikerjakan secara konkuren.

Note: Penjelasan lebih detail mengenai konsep thread dan proses dapat dibaca pada buku teks mengenai Sistem Operasi, di antaranya karya Stallings dan Tanenbaum yang banyak digunakan di Universitas di Dunia.
Kelas Thread merupakan turunan dari kelas Object. Kelas Object sendiri mempunyai metode notify(), notifyAll() dan wait(), sedangkan kelas Thread menyediakan metode sleep() dan yield(). Metode-metode ini akan sering digunakan dalam pengelolaan aplikasi banyak thread.

Pembuatan Thread
Terdapat 2 (dua) cara membuat thread di dalam Java:

• Mengimplementasikan interface Runnable (java.lang.Runnable)
• Menurunkan (extend) kelas Thread (java.lang.Thread)

Mengimplementasikan Interface Runnable
Bentuk dasar (signature) dari interface Runnable adalah

1 2 3

public interface Runnable {     void run(); }

Pada pendekatan ini, kita harus membuat sebuah kelas yang implementasi interface Runnable menggunakan kata kunci implements Runnable. Kemudian dibuat instansiasi berupa suatu obyek dari kelas itu. Kita perlu meng-override metode run() di dalam kelas itu, satu-satunya metode yang perlu diimplementasikan. Metode run() mengandung logika dari thread yang dibangun.
Prosedur pembuatan thread berdasarkan pendekatan interface Runnable adalah sebagai berikut:

1. Sebuah kelas meng-implements interface Runnable, menyediakan metode run() di dalamnya yang akan dieksekusi oleh thread nantinya. Obyek dari kelas ini merupakan obyek Runnable.
2. Obyek dari kelas Thread dibuat dengan melewatkan obyek Runnable sebagai argumen ke konstruktur Thread. Obyek Thread sekarang mempunyai suatu obyek Runnable yang mengimplementasikan metode run().
3. Metode start() pada obyek Thread yang dibuat sebelumnya dipanggil. Metode start() tersebut kembali segera setelah suatu thread dilahirkan (berhasil dibuat).
4. Thread berakhir ketika metode run() berakhir, baik dengan penyelesaian normal atau dengan melempar suatu eksepsi tidak tertangkap (uncaught exception).

Di bawah ini adalah sebuah program yang mengilustrasikan pembuatan thread menggunakan interfaca Runnable, bukan meng-extend kelas Thread. Suatu thread dimulai ketika kita memanggil metode start() pada obyek yang dibuat.

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

class RunnableThread implements Runnable {     Thread runner;     public RunnableThread() {   }     public RunnableThread(String threadName) {         runner = new Thread(this, threadName); // (1) Buat thread baru.         System.out.println(runner.getName());         runner.start(); // (2) Memulai eksekusi thread tersebut.     }     public void run() {         //Tampilkan info tentang thread ini         System.out.println(Thread.currentThread());     } } public class RunnableExample {     public static void main(String[] args) {         Thread thread1 = new Thread(new RunnableThread(), "thread1");         Thread thread2 = new Thread(new RunnableThread(), "thread2");         RunnableThread thread3 = new RunnableThread("thread3");         //Memulai eksekusi thread.         thread1.start();         thread2.start();         try {             //delay selama satu detik (1000 ms).             Thread.currentThread().sleep(1000);         } catch (InterruptedException e) {   }         //Tampilkan info tentang thread main (utama).         System.out.println(Thread.currentThread());     } }

Keluaran dari Program di atas dapat berupa:
thread3
Thread[thread1,5,main]
Thread[thread2,5,main]
Thread[thread3,5,main]
Thread[main,5,main]private
Pendekatan ini harus digunakan jika kelas yang menginstansiasi obyek thread diperlukan (sebagai parent) untuk membuat kelas-kelas lain yang merupakan keturunannya. Pada kasus demikian, kita tidak boleh menurunkan kelas Thread, harus mengimplementasikan Runnable.
Meng-Extend Kelas Thread
Prosedur pembuatan thread melalui pendekatan penurunan kelas Thread adalah sebagai berikut:

1. Membuat sebuah sub-kelas turunan dari kelas Thread, kemudian meng-override metode run() dari kelas Thread dan di dalamnya didefinisikan beberapa kode yang dieksekusi oleh thread.
2. Sub-kelas ini dapat memanggil suatu konstruktur Thread secara eksplisit untuk menginisialisasi thread, menggunakan metode super().
3. Metode start() yang telah diturunkan (secara otomatis) dari kelas Thread dipanggil agar thread segera berjalan.

Berikut ini adalah sebuah program yang mengilustrasikan pembuatan thread dengan meng-extend kelas Thread sebagai ganti mengimplementasikan interface Runnable. Metode start() digunakanuntuk mengeksekusi obyek thread yang dibuat.

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

class XThread extends Thread {     XThread() {  }     XThread(String threadName) {         super(threadName); // Memulai thread.         System.out.println(this);         start();     }     public void run() {         //Tampilkan info tentang thread ini         System.out.println(Thread.currentThread().getName());     } } public class ThreadExample {     public static void main(String[] args) {         Thread thread1 = new Thread(new XThread(), "thread1");         Thread thread2 = new Thread(new XThread(), "thread2");         // 2 thread diberikan nama default         Thread thread3 = new XThread();         Thread thread4 = new XThread();         Thread thread5 = new XThread("thread5");         //Memulai eksekusi thread         thread1.start();         thread2.start();         thread3.start();         thread4.start();         try {     //Metode sleep() dipanggil pada thred main (utama), delay 1 detik.             Thread.currentThread().sleep(1000);         } catch (InterruptedException e) {  }         //Tampilkan info tentang thread main         System.out.println(Thread.currentThread());     } }

Keluaran yang diperoleh dapat berupa:
Thread[thread5,5,main]
thread1
thread5
thread2
Thread-3
Thread-2
Thread[main,5,main]
Pada saat membuat thread, ada dua alasan mengapa kita mengimplementasikan interface Runnable, bukan meng-extend kelas Thread:

• Menurunkan kelas Thread berarti bahwa subclass tidak dapat diturunkan menjadi kelas lain lagi, sedangkan suatu kelas yang mengimplementasikan interface Runnable mempunyai opsi ini.
• Suatu kelas mungkin hanya diinginkan runnable, karena itu menurunkan Thread secara penuh merupakan pemborosan.

Contoh dari kelas anonim berikut memperlihatkan bagaimana membuat sebuah thread dan langsung menjalankannya:

1 2 3 4 5 6

( new Thread() {    public void run() {       for(;;) System.out.println(”Stop the world!”);    } } ).start();

Masih banyak fitur lain di Java yang dapat digunakan untuk mengelola thread. Insya Allah coba dibahas pada tulisan berikutnya.

Socket Connection

• Pengertian Socket

Socket adalah sebuah Class yang disediakan oleh beberapa bahasa pemrograman. Dengan socket, sebuah aplikasi di suatu komputer dapat Tentu saja aplikasi di komputer yang dihubungi menerima koneksi juga menggunakan socket. Dengan kata lain socket adalah suatu Class yang digunakan oleh aplikasi untuk saling berhubungan. berikut ini menunjukkan bagaimana suatu aplikasi berhubungan dengan aplikasi lainnya. Paradigma pada aplikasi jaringan berlaku model client-server. Aplikasi yang menginisialisasi koneksi, disebut aplikasi client. Sedangkan aplikasi yang menerima inisialisasi disebut sebagai aplikasi server. Oleh karena itu, jika kita membangun suatu aplikasi jaringan yang lengkap, maka kita harus membuat aplikasi client maupun aplikasi server.

• Pemrograman Socket Menggunakan TCP

Cara kerja aplikasi yang menggunakan TCP dapat digambarkan oleh di bawah ini :

Detail dari proses tersebut adalah :

Untuk bisa melakukan koneksi client server, program server harus berjalan terlebih dahulu. Di sisi server disediakan sebuah socket, yang disebut welcoming socket yang fungsinya untuk mendeteksi adanya permintaan koneksi dari sisi client. Di sisi client terdapat client socket. Jika ingin menghubungi server, maka melalui client socket-nya, client membuat inisialisai koneksi ke welcoming socket milik server, dengan mode three-way handshake. Setelah welcoming socket menerima inisialisasi koneksi dari client socket, aplikasi server akan membuat connection socket di sisi server. Dengan connection socket ini, client socket dan connection socket berinteraksi satu sama lain untuk mengirim dan menerima data.

Client membaca data yang dikirim oleh server dari client socketnya. Kemudian menampilkan data tersebut di monitor.

• Pemrograman Socket Menggunakan UDP

Contoh aplikasi untuk UDP socket berikut ini menggunakan kasus yang sama dengan kasus yang digunakan oleh TCP socket, yaitu :

Client membaca inputan dari keyboard, kemudian mengirimkan hasilnya ke server melalui socket-nya. Server membaca data yang dikirim oleh client di connection socket Server mengubah data menjadi huruf besar Server mengirimkan data yang telah diubah menuju client melalui socket-nya. Client membaca data yang dikirim oleh server dari client socket-nya. Kemudian menampilkan data tersebut di monitor. Perbedaan utama antara aplikasi berbasis TCP dengan aplikasi berbasis UDP adalah di aplikasi UDP tidak ada welcoming socket. Pada UDP tidak ada socket khusus untuk permintaan inisialisai koneksi. Setiap data yang datang ditangani lansung oleh server socket.

Sumber: Rino Subekti, MKom.from handout

Praktek Client-Server: Membuat Aplikasi Client Server Sederhana Berbasis Java

Buatlah sebuah project aplikasi di Netbeans atau di eclipse (tergantung anda) dengan Source Code untuk Server adalah sbb:
package client_server;
/**
*
* @author dodi
*/
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.logging.Level;
import java.util.logging.Logger;
public class Client_Server {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
try{
//inisial objek server soket denga meset port 51111
ServerSocket ss = new ServerSocket(5111);
Socket s;
String balasan;
String balasan2;
//inisialisasi objek input dan ouput stream
ObjectInputStream in = null;
ObjectOutputStream out = null;
//fungsi bawaan dari class server sket yang mereturn objek soket
//tanda clent server terhubung
s = ss.accept();
//alokasi memori objek
out = new ObjectOutputStream(s.getOutputStream());
//fungsi bawaan objek output stream untuk membersihkan isi memory
out.flush();
//alokasi memory
in = new ObjectInputStream(s.getInputStream());
balasan = “”;
balasan2 = “”;
while (true) {
balasan = “”;
balasan2 = “”;
balasan=ReadMassage(in);
//program akan berhenti sampai input exit dari klien
if(balasan.equals(“exit”)) break;
else {
if(balasan.equals(“ini client”)) {
SendMassage(“ini server, masukan username”, out);
balasan2 = ReadMassage(in);
if(balasan2.equals(“admin”)) SendMassage(“Selamat datang admin”, out);
else
{
if (balasan2.equals(“user”)) SendMassage(“Selamat datang user”, out);
else SendMassage(“username tidak diketahui”, out);
}
} else {
SendMassage(“perintah tidak diketahui”, out);
}
}
}
//Menutup semua stream
in.close();
out.close();
s.close();
ss.close();
} catch (IOException ex) {
Logger.getLogger(Client_Server.class.getName()).log(Level.SEVERE, null, ex);
}
}
//fungsi membaca input dari client
public static String ReadMassage(ObjectInputStream in)
{
String reader = “”;
try {
reader=(String) in.readObject();
} catch (IOException ex) {
Logger.getLogger(Client_Server.class.getName()).log(Level.SEVERE, null, ex);
} catch (ClassNotFoundException ex) {
Logger.getLogger(Client_Server.class.getName()).log(Level.SEVERE, null, ex);
}
System.out.println(reader);
//mereturn nilai string hasil bacaan
return reader;
}
//Fungsi untuk mengirim objek /data ke klient
public static void SendMassage(String word, ObjectOutputStream out)
{
try {
out.writeObject(word);
//bersihkan memori
out.flush();
} catch (IOException ex) {
Logger.getLogger(Client_Server.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
Apabila anda sudah membuat aplikasi servernya maka anda tinggal membuat aplikasi clientnya, maka buat projek baru di netbeans atau eclipse (terserah anda inigi pilih yang mana, hehe), dengan source code sebagai berikut:
package client;
import java.util.Scanner;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
*
* @author dodi
*/
public class Client {
/**
* @param args the command line arguments
*/
public static void main(String[] args) throws IOException {
// TODO code application logic here
Socket s = new Socket(“localhost”,5111);
ObjectInputStream in = null;
ObjectOutputStream out = null;
Scanner scanf = new Scanner(System.in);
String input=”";
String balasan;
String balasan2;
out=new ObjectOutputStream(s.getOutputStream());
out.flush();
in=new ObjectInputStream(s.getInputStream());
balasan=”";
balasan2=”";
while(true)
{
balasan=”";
balasan2=”";
input = scanf.nextLine();
SendMessage(input,out);
if(input.equals(“exit”))break;
else
{
balasan=ReadMessage(in);
if(balasan.equals(“ini server, masukkan username”))
{
input=scanf.nextLine();
SendMessage(input,out);
balasan2=ReadMessage(in);
}
}
}
in.close();
out.close();
s.close();
}
public static void SendMessage(String word, ObjectOutputStream out)
{
try{
out.writeObject(word);
out.flush();
}catch(IOException ex){
Logger.getLogger(Client.class.getName()).log(Level.SEVERE,null,ex);
}
}
public static String ReadMessage(ObjectInputStream in)
{
String reader=”";
try{
reader=(String)in.readObject();
}catch(IOException ex){
Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null,ex);
}catch(ClassNotFoundException ex){
Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null,ex);
}
System.out.println(reader);
return reader;
}
}
Setelah anda berhasil membuat aplikasi server dan clientnya, langsung saja anda running kedua aplikasi tersebut, berikut aplikasi server yang sedang running, dan statusnya listen.

Coba jalankan aplikasi clientnya dan coba ketikan beberapa kasus seperti contoh dibawah ini.
Case1

Case2

Case3

Case 4

exit

Source : Praktikum Client Server #1

Pertemuan ke-4: RPC ( Remote Procedure Call )

1.        Definisi

RPC adalah sebuah metode yang memungkinkan kita untuk mengakses sebuah prosedur yang berada di komputer lain. Untuk dapat melakukan ini sebuah server harus menyediakan layanan remote procedure. Pendekatan yang dilakukan adalah sebuah server membuka socket, lalu menunggu client yang meminta prosedur yang disediakan server. RPC masih menggunakan cara primtif dalam pemrograman yaitu menggunakan paradigma procedural programming.

2.        Tujuan
RPC digunakan untuk administrasi sistem sehingga seorang administrator jaringan dapat mengakses sistemnya dan mengelola sistemnya darimna saja, selama sistemnya terhubung ke jaringan.
3.        Socket
RPC menggunakan socket untuk berkomunikasi dengan proses lainnya.
4.         Cara Kerja RPC
Tiap prosedur yang dipanggil dalam RPC, maka proses ini harus berkoneksi dengan server remote dengan mengirimkan semua parameter yang dibutuhkan, menunggu balasan dari server dan melakukan proses kemudian selesai. Proses di atas disebut juga dengan stub pada sisi klien. Sedangkan Stub pada sisi server adalah proses menunggu tiap message yang berisi permintaan mengenai prosedur tertentu.
5.        Implementasi RPC
Untuk proses nya kurang lebih sama dengan RMI. Kalau RMI kita mengenal proxy dan skeleton, pada RPC dikenal dengan Stub( Client stub dan Server stub).

Gambar Ilustrasi Implementasi RPC

Remote Reference Modul dan Communication Modul berada pada tatanan sistem operasi.
Contoh implementasi adalah Sun Microsystems Open Network Computing (ONC) : RPC specification, XDR (eXternal Data Representation) standard, UDP atau TCP transport protocol. Xerox Courier : RPC model, Data representation standard, XNS (Xerox Network
Systems) SPP (Sequenced Packet Protocol) sbg transport protocol, Apollo s Network Computing Architecture (NCA), RPC protocol, NDR (Network Data Representation).
6.        Langkah-langkah dalam RPC

1. Prosedur client memanggil client stub
2. Client stub membuat pesan dan memanggil OS client
3. OS client mengirim pesan ke OS server
4. OS server memberikan pesan ke server stub
5. Server stub meng-unpack parameter-parameter untuk memanggil server
6. Server mengerjakan operasi, dan mengembalikan hasilnya ke server stub
7. Server stub meng-pack hasil tersebut dan memanggil OS server
8. OS server mengirim pesan (hasil) ke OS client
9. OS client memberikan pesan tersebut ke client stub
10. Client stub meng-unpack hasil dan mengembalikan hasil tersebut ke client

7.        Contoh RPC dengan SUN RPC
Fungsi yg dipanggil client melalui RPC:
bin_date_1:
No arguments.
Result in long integer: waktu saat ini, dlm jumlah detik sejak 00:00:00 GMT,
January 1, 1970.
str_date_1
Mengkonversi hasil bin_date_1 menjadi readable ASCII sring.
Berkas yg dibuat programmer:
Server procedure: date_proc.c
RPC specification file: date.x
Client main function: rdate.c
date.x -> rpcgen ->
Server stub: date_svc.c
date.h
Client stub: date_clnt.c
Generate executable client program:
cc o rdate rdate.c date_clnt.c lrpclib
Generate executable server program:
cc o date_svc date_proc.c date_svc.c lrpclib

Pertemuan ke-3: RMI (Remote Method Invocation)

1.        Definisi
RMI adalah sebuah tekhnik pemanggilan method remote yang lebih secara umum lebih baik dari RPC. RMI menggunakan paradigma pemrograman berorientasi obyek. RMI memungkinkan kita untuk mengirim obyek sebagai parameter dari remote method. Dengan dibolehkannya program Java memanggil method pada remote obyek, RMI membuat pengguna dapat mengembangkan aplikasi Java yang terdistribusi pada jaringan.
2.        Tujuan

1. Menyediakan fasilitas bagi programmer untuk dapat mendistribusikan objek yang digunakan pada beberapa proses yang berbeda.
2. Dapat berjalan dalam satu mesin ataupun di beberapa mesin yang terhubung dengan jaringan.

3.        Aplikasi Obyek Terdistribusi
Aplikasi RMI sering kali terdiri dari dua program terpisah yaitu server dan client.
1.    Aplikasi Server

• Membuat beberapa remote objek
• Menyediakan referensi terhadap objek-objek tersebut sehingga dapat diakses
• Menunggu RMI client merequest server

2.   Aplikasi Client

• Mendapatkan referensi remote ke satu atau lebih objek remote di server
• Menjalankan method dari objek tersebut
• Meminta pemanggilan ke beberapa remote objek berbasarkan referensi yang ditnya.

erimaRMI menyediakan mekanisme dimana server dan client berkomunikasi dan memberikan informasi secara timbal balik, aplikasi ini disebut aplikasi obyek terdistribusi.
4.        Cara Kerja RMI
Dalam model ini, sebuah proses memanggil method dari objek yang terletak pada suatu host/computer remote. Dalam paradigma ini, penyedia layanan mendaftarkan dirinya dengan server direktori pada jaringan. Proses yang menginginkan suatu layanan mengontak server direktori saat runtime, jika layanan tersedia, maka referensi ke layanan akan diberikan. Dengan menggunakan referensi ini, proses dapat berinteraksi dengan layanan tsb. Paradigma ini ekstensi penting dari paradigma RPC. Perbedaannya adalah objek yang memberikan layanan didaftarkan (diregister) ke suatu layanan direktori global, sehingga memungkinkan untuk ditemukan dan diakses oleh aplikasi yang meminta layanan tersebut.
5.        Implementasi RMI

Berikut ilustrasi yang terjadi pada metode RMI:
Programmer pada client menulis :
Server_id.service(values_to_server,result_arguments);
Pada sisi server mempunyai fungsi sebagai berikut :
Public service(in type1 arg from client; out type2 arg to_client)
{——-}
Programmer pada client tidak mengetahui bahwa reply message yang didapatkan berasal dari server yang dikirim melalui jaringan.

 

Gambar Ilustrasi Implementasi RMI

Komponen-komponen dam RMI(gambar 2.2) :

• Object A(client) : meminta layanan
• Object B(server) : menghantarkan layanan
• Proxy for B

-  Ketika object A mempunyai remote reference ke object B, maka akan timbul objek proxy B pada host object A. Proxy terbuat ketika remote object reference digunakan pertama kali.
-  Proxy adalah perwakilan objek yang berada pada remote, dengan kata lain ketika terjadi invokasi dari A ke B ditangani seolah – olah hanya mengakses Proxy B.
-  Ketika invokasi terjadi proxy menggunakan metode marshals untuk membungkus pesan yang akan dikirim ke server. Dan setelah menerima hasil dari server proxy menggunakan metode unmarshal (membuka bungkus) untuk kemudian diteruskan ke client (Object A).

•  Skeleton for object B

-          Pada sisi server, terdapat object kerangka (skeleton) yang berhubungan ke class, kalau object pada class tersebut dapat diakses oleh RMI.
-          Skeleton menerima pesan kemudian melakukan unmarshal dan meneruskan ke  method object yang dituju. Dan kemudian menunggu hasil dari object B dan kemudian membungkus hasil (unmarshal) dan kemudian dikirimkan ke client (Objec A).
-          Ada bagian dari skeleton B yang disebut dengan dispatcher. Dispatcher menerima request dari communication module, dan kemudian mengidentifikasi invokasi dan mengarahkan permintaan ke corresponding method ( method pada skeleton yang berfungsi untuk berkomunikasi dengan object).

• Communication Modul (Modul Komunikasi)

-          Communication modul pada client atau server bertanggung jawab dalam pertukaran pesan yang dilakukan melalui metode request dan reply.

• Remote Reference Module

-        Bagian ini bertugas untuk menterjemahkan antara referensi objek lokal dan remote. Proses berkomunikasi antara mereka disimpan dalam remote object table.
-       Yang menggenerate class untuk proxy dan skeleton adalah middleware.
-       Contoh : CORBA, Java RMI
Object A dan object B dipunyai oleh aplikasi (berada pada Application Layer) Remote Reference Modul dan Communication modul dimiliki oleh middleware. Proxy B dan Sekeleton B berada antara middleware dan aplikasi yang di generate oleh middleware.
6.        Langkah-langkah  proses dengan RMI :

1. Urutan pemanggilan pada object client mengaktifkan method pada proxy yang akan berhubungan dengan invoked method (method yang ter-invokasi) pada object B.
2. Kemudian method yang ada pada proxy melakukan pembungkusan argumen menjadi suatu pesan (marshalling) dan meneruskan ke modul komunikasi.
3. Berdasarkan pada remote reference yang didapat dari remote reference modul, modul komunikasi memulai request dan reply protocol melalui network.
4. Modul komunikasi pada server menerima request dari client. Kemudian berdasarkan referensi lokal yang diterima dari remote reference modul maka akan mengaktifkan method untuk berkomunikasi dengan object pada skeleton B (corresponding method).
5. Method pada skeleton meng-ekstrak (unmarshalling) argumen pada pesan yang di terima dan mengaktifkan corresponding method (method yang berfungsi untuk melakukan komunikasi) pada object B (server).
6. Setelah menerima hasil dari object B, method dari skeleton akan membungkus hasil tersebut dalam sebuah pesan (marshalling) dan meneruskan pesan yang sudah dibungkus ke modul komunikasi.
7. Modul komunikasi mengrimkan pesan tersebut ke client melalui jaringan.
8. Modul komunikasi pada client menerima hasil (reply) dari server dan meneruskan ke corresponding method pada proxy.
9. Kemudian proxy meng-ektrak hasil (unmarshalling) dan meneruskan ke object A (client).

7.        Contoh RMI dengan menggunakan Java RMI :
Server object akan mencetak ”Hello Ruddy” ke layar & mengembalikan pesan ke klien
Pada sisi server :
-          Server Method
import java.rmi.*;
public interface SimpleInterface       
String printMessage(String name) throws RemoteException;
}
-          Server Object
import java.rmi.*;
import java.rmi.server.*;
public class SimpleServer extends UnicastRemoteObject implements SimpleInterfac
public SimpleServer() throws RemoteException { super(); }
public String printMessage(String name) throws RemoteException {
System.out.println(name);
return(Hello + name);
}
public static void main(String args[]) {
System.setSecurityManager(new RMISecurityManager());
try {
SimpleServer newServer = new SimpleServer();
System.out.println(SimpleServer attempting to
bind to the registry);
Naming.rebind(//ruddy.info:30010/SimpleServer,
newServer);
System.out.println(SimpleServer bound in the registry);
} catch(Exception e) {System.out.println(SimpleServer error: + e.getMessage());
e.printStackTrace();
}}
}

Pada sisi client :
import java.rmi.*;
public class SimpleClient {
private static SImpleInterface server = null;
public static void main(String args[]) {
try {
server = (SimpleInterface)
Naming.lookup(//ruddy.info:30010/SimpleServer);
System.out.println(server.printMessage (Ruddy));
} catch(Exception e) {
System.out.println(SimpleClient error: + e.getMessage());
e.printStackTrace();
}}
}

Pengantar Sistem Terdistribusi & Overview

Definisi dan contoh Sistem Terdistribusi

03/13/2012 in Pengantar Sistem Terdistribusi, Tugas Kuliah

DEFINISI :
Sebelum menjelaskan tentang definisi dari sistem terdistribusi, saya akan menjelaskan lagi tentang apa itu sistem. Sistem adalah suatu kesatuan yang terdiri komponen atau elemen yang dihubungkan bersama untuk melakukan suatu kegiatan atau untuk menyelesaikan suatu tujuan tertentu.
Sedangkan definisi dari sistem terdistribusi adalah sebuah sistem dimana komponen software atau hardware-nya terletak di dalam jaringan komputer dan saling berkomunikasi menggunakan message passing (Message passing adalah sebuah teknik untuk melakukan sinkronisasi dan komunikasi antara proses-proses yang saling berinteraksi). Ada juga yang mengatakan Sistem Terdistribusi adalah sebuah sistem yang terdiri dari beberapa komponen yang terdapat di dalam sebuah jaringan komputer. Komponen-komponen tersebut saling berinteraksi dan berkomunikasi hanya dengan melalui pengiriman pesan.

Contoh Sistem Terdistribusi :

• Internet.

• Mobile Computing.

• Sistem Otomasi Bank.

• Deteksi Roaming Pada Telepon Seluler.

• GPS (Global Positioning System).

• Retail Point-of-Sale Terminals.

PENJELASAN :
Internet

• Jaringan komputer dan aplikasi yang heterogen.

• Mengimplementasikan protokol Internet.

Intranet

• Jaringan yang teradministrasi secara local.

• Terhubung ke internet melalui firewall.

• Menyediakan layanan internal dan eksternal.

Mobile Computing (Sistem Komunikasi Telepon Seluler)

• Menggunakan frekuensi radio sebagai media transmisi.

• Perangkat dapat bergerak kemanapun asal masih terjangkau dengan frekuensinya.

• Dapat menghandle/dihubungan dengan perangkat lain.

Contoh lain Sistem Terdistribusi

• Sistem Telepon : ISDN, PSTN.

• Network File System (NFS). (Arsitektur untuk mengakses sistem file melalui jaringan).

• www. (Arsitektur client server yang diterapkan dalam infrastruktur internet).

Perbedaan antara jaringan Peer-to-peer dan Client-Server

Berdasarkan typenya jaringan di bagi menjadi dua jenis yaitu:

1.   1. Peer to Peer,  telah kita bahas secara ringkas di atas bahwa jaringan  Peer to Peer adalah jaringan dimana hanya terdapat dua computer yang saling berhubungan, maksud di sini adalah umumnya pada jaringan type ini mengunakan dua komputer bukan maksimum hanya bisa dua computer, bisa saja tiga atau empat tetapi pada jaringan yang terhubung tersebut tidak ada satu computer pun yang berperan sebagai sever murninya (computer yang menyediakan layanan atau fasilitas kepada client). Bisa saja semua computer berperan sebagai server dan begitu juga berperan sebagi Client. Mengapa demikian? Karena setiap computer bertanggung jawab atas file dan data-datanya masing-masing, tidak ada computer khusus(server) yang menyimpan resource setiap computer yang ada di jaringan sehingga akan lebih sulit dalam menata file pada type jaringan ini dan biasanya di sebut dengan jaringan non-dedicated server.

2.      Client-Server, adalah jaringan yang terdiri dari Client dan server dimana pada jaringan tersebut terdapat sebuah computer yang berperan sebagai pusat pelayanan(server) memberi layanan dan fasilitas untuk client sedangkan computer yang lain berperan sebagai client(computer yang mengunakan fasilitas yang di sediakan oleh Server). Sehingga di sebut dengan server murni atau Dedicated server dalam bahasa inggris.

Penjelasan Singkat

Client  Adalah pengguna(user), computer yang mengunakan fasilitas yang di sediakan  oleh computer server.

Server adalah computer yang menyediakan layanan kepada client-clientnya.

       Dari segi tipenya, kedua buah jaringan tersebut memiliki kelebihan dan kekurangan masing-masing, sesuai dengan apa yang kita ketahui bahwa setiap hal yang ada di dunia ini, asalkan masih di tegakan oleh hukum alam, maka pasti memiliki dua sisi, dengan kata lain, jika ada positifnya pasti ada negatifnya, jika ada baiknya pasti ada jahatnya, jika ada optimisnya pasti ada persimisnya. Benar bukan?

Di sini kita akan bahas satu persatu keuntungan, kerugian dari jaringan peer to peer dan jaringan client-server:

1.      Kelebihan jaringan Peer to Peer:

·        kerja tidaknya setiap computer tidak bergantung pada sebuah computer(Server), dengan kata lain, setiap client atau computer yang terhubung di dalam jaringan dapat bekerja walaupun salah satu dari computer yang merupakan bagian dari jaringan tersebut tidak hidup atau pun rusak.

·      Biaya operasionalnya relative lebih murah di bandingkan dengan jaringan computer Client-server karena tidak memerlukan perangkat tambahan untuk sebagai perantara, seperti Hub, switch, dll dan juga tidak memerlukan computer server yang harus memiliki spesifikasi hardware yang relative lebih mahal dibandingkan dengan client lainya.

·        Antar client dapat berperan sebagai server sendiri, artinya setiap client dapat mengsharing data dan fasilitas hardware dengan mudah, seperti contoh mengsharing printer, harddisk, dan lain-lain

·     Pada system jaringan ini tidak membutuhkan system operasi Jaringan, karena layanan yang di sediakan pada jaringan terdapat pada masing-masing client atau user.

Kelemahan Jaringan Peer to peer:

·         Semua aplikasi dan pengolahan harus di lakukan sendiri sehingga mengakibatkan kualitas pekerjaan lebih rendah di bandingkan dengan jaringan client-server

·         Sistem keamanan tidak terpusat, dengan kata lain, system keamanan dari setiap client harus di atur oleh masing-masing user dengan mengunakan fasilitas atau aplikasi sendiri.

·         System backup dan  restore harus di lakukan oleh masing-masing user karena jaringan ini bersifat privat, artinya, data-data jaringan berada di setiap user berbeda, sehingga perlu perawatan di user masing-masing.

·     Jika terjadi gangguan atau masalah pada jaringan maka akan lebih sulit untuk mencari masalahnya (troubleshooting) karena pada jaringan ini, semua computer terlibat dalam proses komunikasi antara satu dengan yang lain, tidak sama seperti type jaringan client-server yang komunikasinya hanya antar setiap workstation dan server.

·         Tidak sesuai atau tidak cocok untuk jaringan yang berskala besar, karena pada system jaringan ini, administrasi atau cara kerjanya tidak tercontrol.

Penjelasan singkat

Backup adalah sebuah aktivitas untuk menyimpan data dengan cara mengduplikasikan data tersebut dan kemudian di simpan di tempat yang lebih aman, sehingga jika suatu hari terjadi kerusakan pada data yang di gunakan maka data yang kita simpan dapat di panggil kembali dengan mengunakan Restore.

Restore adalah aktivitas memanggil kembali yang kita simpan (Backup)

Troubleshooting adalah sebuah tindakan yang di lakukan untuk mendiagnosa atau mencari masalah yang terjadi di dalam sebuah computer maupun jaringan computer.

Workstation biasanya di sebut juga dengan Client.

                  Kelebihan Jaringan Client-Server

·   Sistem keamanan yang terdapat pada jaringan ini lebih aman dan terjamin karena controlnya terpusat, dengan kata lain semua fasilitas untuk keamanan jaringan ini di handle atau di tangani oleh sebuah Komputer yang berperan sebagai server.

·      Kecepatan akses lebih tinggi karena penyediaan fasilitas  jaringan dan pengolahanya di lakukan khusus oleh sebuah computer.

·         Untuk melakukan Backup dan Restore akan sangat mudah karena terpusat, dengan kata lain, semua data yang terdapat di dalam jaringan dapat tersimpan di dalam satu computer, sehingga dapat menghindari kehilangan data yang bersebaran di mana-mana.

·      Jika terjadi sebuah kesalahan atau gangguan pada jaringan ini, akan lebih mudah untuk melakukan Troubleshooting karena komunikasi terjadi hanya antar client tertentu dan server.

·         Semua jaringan yang berskala besar mengunakan type jaringan ini.

                  Kelemahan jaringan Client-Server

·    Dapat atau tidak dapat kerjanya jaringan tergantung pada server, dengan kata lain jika computer server mati, maka semua client tidak dapat bekerja. Karena semua layanan dan fasilitas jaringan tersedia di server.

·       Untuk biaya operasionalnya akan relative lebih mahal karena di perlukan perlatan jaringan yang khusus, seperti Hub, switch, dan lain-lain, di samping itu sangat perlu juga sebuah computer yang memiliki spesifikasi lebih tinggi di bandingkan computer client untuk di jadikan sebagai server.

·         Di perlukan sebuah  system operasi jaringan yang khusus untuk server.

didapat di blog   :http://julvicomputer.blogspot.com/2012/06/normal-0-false-false-false-en-us-x-none.html