Kelompok5 4 Program Socket

Program Socket

User Datagram Protocol (UDP)

I WAYAN J. WIRATAMA

NIM. 1108605023

I GUSTI AGUNG BAGUS PREMA PRADANA

NIM. 1108605026

I GEDE EDY MAHA PUTRA

NIM. 1108605052

JURUSAN ILMU KOMPUTER

FAKULTAS MATEMATIKA DAN ILMU PENGETAHUAN ALAM

UNIVERSITAS UDAYANA

BUKIT JIMBARAN

2013

ii

KATA PENGANTAR

Rasa syukur yang dalam penulis sampaikan ke hadiran Tuhan Yang Maha

Esa, karena berkat Anugerah-Nya laporan ini dapat penulis selesaikan sesuai yang

diharapkan. Dalam laporan ini penulis membahas tentang “Program Socket”.

Laporan ini dibuat dalam rangka memperdalam pemahaman tentang

mekanisme suatu jaringan atau internet bekerja yang sangat diperlukan dalam

suatu harapan mendapatkan kemudahan dalam memanfaatkan teknologi informasi

terutama yang menggunakan jaringan komputer dan sekaligus melakukan apa

yang menjadi tugas mahasiswa yang mengikuti mata kuliah “Jaringan Komputer

Lanjut”.

Dalam proses pendalaman materi Jaringan Komputer Lanjut ini, tentunya

penulis mendapatkan bimbingan, arahan, koreksi dan saran, untuk itu rasa terima

kasih yang dalam-dalamnya kami sampaikan :

Dosen mata kuliah “Jaringan Komputer Lanjut”

Rekan-rekan mahasiwa yang telah banyak memberikan masukan

untuk laporan ini.

Demikian laporan ini penulis buat semoga bermanfaat bagi pembaca,

Denpasar, 17 November 2013

Penulis

ii

iii

DAFTAR ISI

KATA PENGANTAR.............................................................................................ii

DAFTAR ISI..........................................................................................................iii

DAFTAR GAMBAR..............................................................................................iv

BAB I.......................................................................................................................1

PENDAHULUAN...................................................................................................1

1.1 Latar Belakang..........................................................................................1

1.2 Tujuan........................................................................................................1

1.3 Manfaat......................................................................................................1

BAB II......................................................................................................................2

PEMBAHASAN......................................................................................................2

2.1 Socket Programming.................................................................................2

2.1.1 Socket Programing dengan TCP..............................................................3

2.1.2 Socket Programming dengan UDP........................................................15

BAB III..................................................................................................................26

PEMBAHASAN....................................................................................................26

3.1 UDPChatServer.......................................................................................26

3.2 UDPChatClient........................................................................................31

3.3. Demo Program............................................................................................36

3.3.1 Demo Program Server...........................................................................36

3.3.2 Demo Program Client...........................................................................39

4.1 Kesimpulan...................................................................................................42

DAFTAR PUSTAKA............................................................................................43

iii

iv

DAFTAR GAMBAR

Gambar 2. 1 Socket Programming dengan TCP......................................................4

Gambar 2. 2 Proses pembentukan TCP...................................................................5

Gambar 2. 3 Proses pada TcpClient.........................................................................8

Gambar 2. 4 aktivitas utama soket dari klien dan server pada UDP......................17

Gambar 2. 5 Stream UDP......................................................................................20

Gambar 2. 6 UDPServer tidak memiliki streams...................................................24

Gambar 3. 1 Start Server------------------------------------------------------------------36

Gambar 3. 2 Server menerima pesan dari Client--------------------------------------37

Gambar 3. 3 Server terhubung dengan lebih satu Client-----------------------------38

Gambar 3. 4 Tampilan awal Client------------------------------------------------------39

Gambar 3. 5 Client mengirim pesan ke Server----------------------------------------40

Gambar 3. 6 Multi Client Chat-----------------------------------------------------------41

iv

BAB I

PENDAHULUAN

1.1 Latar Belakang

Di kehidupan masa sekarang, perkembangan teknologi sangat cepat.

Semua aspek kehidupan di masa sekarang menggunakan teknologi, mulai dari

absensi, pendataan penduduk, dan lain-lain. Komunikasi dengan orang yang

dipisahkan jarak yang sangat jauh pun sudah terasa dekat. Pengiriman data

dengan berbagai ukuran dan jarak yang jauh melalui jaringan internet sudah

menjadi hal yang biasa.

Dalam pengiriman data terdapat hal penting yang digunakan yaitu socket.

Socket sendiri merupakan interface pada jaringan yang menjadi titik

komunikasi antar computer yang berbasis protocol jaringan. Socket ini biasa

digunakan pada aplikasi yang saling berhubungan atau biasa disebut aplikasi

client/server. Menggunakan socket pada aplikasi client/server ini disebut

dengan socket programming.

Pada socket programming sendiri terdapat fasilitas pengiriman data, yaitu

dengan TCP maupun UDP. Transfer Control Protocol (TCP) merupakan

protocol yang menyediakan layanan transfer yang dapat dihandalkan.

Sedangkan User Datagram Protocol merupakan protocol yang menyediakan

layanan transfer yang tidak dapat dihandalkan. Untuk lebih jelas tentang

socket programming dengan TCP dan UDP akan dijelaskan pada bab II.

1.2 Tujuan

Mahasiswa Memahami Konsep dari Pemrograman Socket untuk Komunikasi

Client-Server,baik menggunakan TCP ataupun UDP

1.3 Manfaat

Mahasiswa Mampu Membuat Pemrograman Socket untuk Komunikasi

Client-Server

1

BAB II

LANDASAN TEORI

2.1 Socket Programming

inti dari aplikasi jaringan adalah terdiri dari sepasang program -

program client dan program server. Ketika kedua program dijalankan,

proses klien dan server diciptakan, dan kedua proses berkomunikasi satu

sama lain dengan membaca dan menulis ke soket. tugas utama

pengembang ketika membuat sebuah aplikasi jaringan adalah untuk

menulis kode untuk kedua program client dan server.

Ada dua macam aplikasi client-server. Yang pertama adalah

aplikasi client-server yang merupakan implementasi dari protokol standar

yang ditetapkan dalam RFC. Untuk penerapannya, program client dan

server harus sesuai dengan aturan yang ditentukan oleh RFC. Sebagai

contoh, program klien bisa menjadi implementasi klien FTP,

didefinisikan dalam [RFC 959], dan server Program bisa menjadi

implementasi dari server FTP, juga didefinisikan dalam [RFC 959].

Memang, sebagian besar aplikasi jaringan saat ini melibatkan komunikasi

antara program client dan server yang telah dibuat oleh pengembang

independen. (Sebagai contoh, browser Netscape berkomunikasi dengan

Web server Apache, atau klien FTP pada PC untuk meng-upload file ke

server FTP Unix.) Ketika klien atau program server

mengimplementasikan sebuah protokol yang didefinisikan dalam RFC,

perangkat tersebut harus menggunakan nomor port yang berhubungan

dengan protokol.

Jenis lain dari aplikasi client-server adalah aplikasi client-server

proprietary. Dalam hal ini program client dan server tidak selalu sesuai

dengan setiap RFC yang ada. Sebuah pengembang tunggal (tim

pengembang) menciptakan program klien dan server, dan pengembang

memiliki kontrol penuh atas apa yang terjadi dalam baris kode. Tapi

karena kode tidak menerapkan public-domain protokol, pengembang

independen lain tidak akan mampu mengembangkan aplikasi yang

2

3

beroperasi dengan menggunakan baris-baris kode.

Ketika mengembangkan aplikasi proprietary, pengembang harus berhati-

hati untuk tidak menggunakan salah satu dari nomor port yang

didefinisikan dalam RFC.

Dalam bagian ini dan selanjutnya, kita akan membahas kunci untuk

pengembangan aplikasi client-server proprietary. Selama tahap

pengembangan, salah satu keputusan pertama pengembang harus

membuat apakah aplikasi tersebut bisa berjalan dengan TCP atau UDP.

TCP merupakan connection-oriented dan memberikan aliran saluran byte

handal melalui data yang mengalir antara dua end systems. UDP adalah

connectionless dan mengirimkan paket data dari satu ujung sistem ke

ujung sistem yang lainnya, tanpa jaminan tentang pengirimannya. Dalam

bagian ini kita mengembangkan sebuah aplikasi klien sederhana yang

berjalan di atas TCP, di bagian berikutnya, kita mengembangkan sebuah

aplikasi klien sederhana yang berjalan di atas UDP.

2.1.1 Socket Programing dengan TCP

proses berjalan pada mesin yang berbeda, berkomunikasi

dengan mengirimkan pesan ke soket satu sama lainnya. Kami

mengatakan bahwa setiap proses dianalogikan dengan rumah dan

proses soket dianalogikan dengan sebuah pintu. Seperti

ditunjukkan dalam Gambar 2.1 Soket adalah pintu penghubung

antara proses aplikasi dan TCP. Para pengembang aplikasi

mengontrol segala sesuatu dari sisi application-layer pada soket,

namun memiliki sedikit kontrol dari sisi transport-layer.

4

Gambar 2. 1 Socket Programming dengan TCP

Sekarang kita lihat lebih dekat interaksi program dengan

server. Klien memiliki tugas memulai kontak dengan server. Agar

server dapat siap bereaksi saat terjadi kontak awal dengan klien

bisa karena 2 kemungkinan. Pertama, program server tidak bisa

aktif, jika klien tidak bereaksi dengan server. Kedua, program

server harus memiliki semacam pintu (yaitu, soket) yang

menyambut kontak awal dari klien. Analogi Rumah / pintu

digunakan untuk Proses/Soket, kadang-kadang kita

menganalogikan klien melakukan kontak dengan "mengetuk

pintu".

Dengan menjalankan proses server, client dapat memulai

proses koneksi TCP ke server. Hal ini dilakukan di Program klien

dengan menciptakan sebuah objek socket. Ketika klien

menciptakan objek socket, ia menentukan alamat dari proses

server, yaitu alamat IP dari server dan nomor port dari proses.

Setelah penciptaan obyek socket, TCP di klien memulai Three way

HandShake dan membentuk koneksi TCP dengan server. Three

way HandShake yang transparan kepada program client dan server.

Selama Threeway Hand Shake, klien “mengetuk pintu”

dan server menyambut ketukan pintu tersebut. Ketika server

5

"mendengar" ketukan itu, ia menciptakan sebuah pintu baru (yaitu,

soket baru) yang didedikasikan untuk klien tertentu. Dalam contoh

di bawah ini, sambutan pintu adalah objek ServerSocket yang kita

sebut welcomeSocket tersebut. Ketika klien mengetuk pintu ini,

program memanggil dan () metode welcomeSocket menerima,

yang menciptakan sebuah pintu baru bagi klien. Pada akhir fase

handshaking, Koneksi TCP ada antara soket klien dan soket server

yang baru. Selanjutnya, kita mengacu pada soket yang baru sebagai

server "koneksi soket".

Dari sudut pandang aplikasi, koneksi TCP adalah pipa

virtual langsung antara soket klien dan server koneksi soket. Proses

klien dapat mengirim byte acak ke soket, TCP menjamin bahwa

server akan menerima proses (melalui koneksi soket) setiap byte

yang dikirim dalam urutan. Selain itu, sama seperti orang bisa

masuk dan keluar dengan menggunakan pintu, proses klien juga

dapat menerima byte dari soket, dan proses server juga dapat

mengirim byte ke sambungan socket. Hal ini diilustrasikan dalam

Gambar 2.2

Gambar 2. 2 Proses pembentukan TCP

6

Karena soket memainkan peran sentral dalam aplikasi

client-server, pengembang aplikasi client-server juga disebut

sebagai pemrograman socket. Sebelum kita memberikan contoh

aplikasi client-server,akan dibahas terlebih dahulu konsep dari

stream. Stream A merupakan urutan karakter yang mengalir masuk

atau keluar dari suatu proses. Stream merupakan urutan karakter

yang mengalir masuk atau keluar dari suatu proses. Setiap aliran

bisa berupa input stream untuk proses atau output stream untuk

proses. Jika sebuah stream, adalah input stream, maka stream ini

terdapat pada beberapa sumber input untuk proses seperti input

standar (keyboard) . Jika Stream adalah output stream, maka stream

terdapat pada beberapa sumber output dari proses,seperti standar

output (monitor)

2.1.1.1 Contoh Client-Server Application di Java

Kita akan menggunakan aplikasi client-server

sederhana berikut untuk menunjukkan pemrograman socket

untuk TCP dan UDP:

1. Seorang klien membaca garis dari standar input

(keyboard) dan mengirimkan socket line out untuk

server.

2. Server membaca garis dari soket sambungan.

3. Server mengubah garis ke huruf besar.

4. Server akan mengirimkan garis yang dimodifikasi

koneksi soket keluar ke klien.

5. Klien membaca garis yang dimodifikasi dari soket dan

mencetak garis pada output standar (monitor).

Di bawah ini kami menyediakan pasangan program

client-server untuk implementasi TCP dari aplikasi. Kami

menyediakan, detail masing-masing garis-byline setelah

analisis program. Program klien disebut TCPClient.java, dan

program server disebut TCPServer.java.

7

Setelah dua program yang disusun pada host masing-

masing, program server pertama kali dijalankan pada server,

untuk menciptakan suatu proses di server. Seperti dibahas di

atas, proses server menunggu untuk dihubungi oleh proses

klien. Ketika Program klien dijalankan, proses yang dibuat

pada klien, dan proses ini mengontak server dan menetapkan

itu dengan koneksi TCP. Pengguna pada klien kemudian

dapat "menggunakan" aplikasi untuk mengirim baris dan

kemudian menerima versi baris yang dikapitalisasi.

a. TCPClient.java

Berikut adalah kode untuk aplikasi dari sisi klien:

import java.io.*;

import java.net.*;

class TCPClient {

public static void main(String argv[]) throws

Exception

{

String sentence;

String modifiedSentence;

BufferedReader inFromUser =

new BufferedReader(new

InputStreamReader(System.in));

Socket clientSocket = new Socket("hostname",

6789);

DataOutputStream outToServer =

new

DataOutputStream(clientSocket.getOutputStrea

m());

BufferedReader inFromServer =

8


InputStreamReader(clientSocket.getInputStream

()));

sentence = inFromUser.readLine();

outToServer.writeBytes(sentence + '\n');

modifiedSentence = inFromServer.readLine();

System.out.println("FROM SERVER: " +

modifiedSentence);

clientSocket.close();

}

}

Program TcpClient menciptakan tiga stream dan

satu soket, seperti yang ditunjukkan pada Gambar 2.3

Gambar 2. 3 Proses pada TcpClient

Socket ini disebut clientSocket. inFromUser adalah

Stream masukan untuk program , inputan standar yaitu

9

keyboard. Ketika pengguna menulis karakter pada

keyboard, karakter masuk ke dalam Stream inFromUser.

Stream dari InFromServer adalah Stream input lain ke

dalam program, melekat pada soket. Karakter yang datang

dari jaringan mengalir ke inFromServer. Yang terakhir

outToServer adalah Stream output dari program ini,yang

juga melekat pada soket. Karakter client yang

mengirimkan aliran jaringan ke dalam aliran outToServer.

Mari sekarang kita lihat dalam kode.

import java.io.*;

import java.net.*;

java.io dan java.net adalah paket java. Paket

java.io berisi kelas untuk input dan output stream. Secara

khusus, java.io package mengandung kelas

BufferedReader dan DataOutputStream, bahwa kelas

program digunakan untuk membuat tiga stream seperti

yang digambarkan di atas. Paket java.net menyediakan

kelas untuk mendukung jaringan. Secara khusus, berisi

Socket dan kelas ServerSocket. Obyek clientSocket dari

program ini berasal dari kelas Socket.

class TCPClient {


Exception

{......}

}

Di atas adalah hal-hal standar yang Anda lihat pada

kebanyakan kode awal java. Baris pertama adalah awal

dari sebuah definisi kelas blok. Kelas kata kunci mulai

mendefinisikan kelas untuk kelas bernama TcpClient.

Kelas A berisi variabel, dan metode. Variabel dan metode

dari kelas yang dianut oleh kurung keriting {} yang

10

memulai dan mengakhiri blok definisi kelas. Itu kelas

TcpClient tidak memiliki kelas variabel dan satu metode

tepat,yaitu metode (utama). Metode ini mirip dengan

fungsi atau prosedur dalam bahasa seperti C, metode

utama dalam bahasa Java adalah mirip dengan fungsi utama

dalam C dan C + +. Ketika interpreter Java menjalankan

aplikasi (yang dipanggil pada kelas kontrol aplikasi), itu

dimulai dengan memanggil Kelas metode yang utama. Metode

utama kemudian memanggil semua metode lain yang

diperlukan untuk menjalankan aplikasi. Untuk pengenalan ke

soket pemrograman di Java ini, Anda mungkin mengabaikan

kata kunci public, static, void, main, throw Pengecualian

(meskipun Anda harus memasukkannya dalam kode).

String sentence;

String modifiedSentence;

Kedua atas garis mendeklarasikan objek dari tipe

String. Kalimat objek adalah string yang diketik oleh

pengguna dan dikirim ke server. ModifiedSentence objek

adalah string yang diperoleh dari server dan dikirim output

standar pengguna.




Baris di atas menciptakan aliran objek inFromUser

jenis BufferedReader. Input stream diinisialisasi dengan

System.in, yang menempel ke aliran standar input.

Perintah ini memungkinkan klien untuk membaca teks

dari keyboard.

Socket clientSocket = new Socket("hostname", 6789);

Baris di atas menciptakan clientSocket jenis objek

Socket. Hal ini juga memulai koneksi TCP antara klien

11

dan server. Variabel "nama host" harus diganti dengan

nama host dari server (misalnya, "fling.seas.upenn.edu").

Sebelum koneksi TCP sebenarnya dimulai, klien mencari

DNS di hostname untuk mendapatkan alamat IP host.

angka 6789 itu adalah nomor port. Anda dapat

menggunakan nomor port yang berbeda, tapi Anda harus

memastikan bahwa Anda menggunakan nomor port yang

sama pada aplikasi sisi server. Seperti telah dibahas

sebelumnya, alamat IP host bersama dengan nomor

aplikasi pelabuhan mengidentifikasi proses server.

DataOutputStream outToServer =

new

DataOutputStream(clientSocket.getOutputStream());

BufferedReader inFromServer =


inputStreamReader(clientSocket.getInputStream()));

Dua baris di atas membuat aliran objek yang

melekat pada soket. Aliran outToServer menyediakan

output ke proses soket. Aliran inFromServer memberikan

masukan proses dari soket.

sentence = inFromUser.readLine();

Baris di atas menempatkan baris yang diketik oleh

pengguna ke dalam kalimat string. Kalimat String

mengumpulkan karakter sampai pengguna garis berkahir

dan pengguna mengetikkan kata carriage return. Jalur ini

melewati standar input melalui inFromUser dan mengalir

kedalam kalimat String.

outToServer.writeBytes(sentence + '\n');

Baris di atas mengirimkan kalimat string yang

ditambah dengan carriage return ke dalam aliran

outToServer. Ditambah aliran Kalimat melalui soket klien

12

dan ke dalam pipa TCP. Klien kemudian menunggu untuk

menerima karakter dari server.

modifiedSentence = inFromServer.readLine();

Ketika karakter tiba dari server, mereka mengalir

melalui aliran inFromServer dan ditempatkan ke dalam

string modifiedSentence. Karakter terus menumpuk di

modifiedSentence sampai garis berakhir dengan karakter

carriage return.

System.out.println("FROM SERVER " +

modifiedSentence);

Baris di atas mencetak kata di monitor

modifiedSentence string yang dikembalikan oleh server.


Ini baris terakhir dalam menutup soket dan,

menutup koneksi TCP antara klien dan server. Hal ini

menyebabkan TCP dalam klien mengirim pesan ke TCP

TCP di server .

b. TCPServer.java

Sekarang mari kita lihat program server.

import java.io.*;

import java.net.*;

class TCPServer {


Exception

{

String clientSentence;

String capitalizedSentence;

ServerSocket welcomeSocket = new

ServerSocket(6789);

while(true) {

13

Socket connectionSocket =

welcomeSocket.accept();

BufferedReader inFromClient =


InputStreamReader(connectionSocket.getInputStre

am

()));

DataOutputStream outToClient =

new

DataOutputStream(connectionSocket.getOutputStr

eam());

clientSentence = inFromClient.readLine();

capitalizedSentence =

clientSentence.toUpperCase() + '\n';

outToClient.writeBytes(capitalizedSentence);

}

}

}

TCPServer memiliki banyak kesamaan dengan

TcpClient.

Baris pertama dalam TCPServer yang secara

substansial berbeda dari apa yang kita lihat di

TcpClient adalah:

ServerSocket welcomeSocket = new

ServerSocket(6789);

Baris di atas menciptakan objek

welcomeSocket, yaitu dari jenis ServerSocket.

WelcomeSocket, seperti dibahas di atas, adalah

semacam pintu yang menunggu ketukan dari beberapa

klien. Nomor port 6789 mengidentifikasi proses di

server. Berikut line adalah:

Socket connectionSocket =

welcomeSocket.accept();

14

Baris di atas membuat soket baru, yang

disebut connectionSocket, ketika beberapa klien

mengetuk welcomeSocket. TCP kemudian

menetapkan pipa virtual langsung antara clientSocket

pada klien dan connectionSocket di server. Klien dan

server kemudian dapat mengirim byte satu sama lain

melalui pipa, dan semua byte yang dikirim tiba di sisi

lain dalam rangka. Dengan didirikan

connectionSocket, server dapat terus mendengarkan

permintaan lain dari klien lain untuk aplikasi

menggunakan WelcomeSocket. Program ini

kemudian menciptakan beberapa aliran objek, analog

dengan aliran objek yang dibuat dalam clientSocket.

Sekarang perhatikan:

capitalizedSentence =

clientSentence.toUpperCase() + '\n';

Perintah ini adalah inti dari aplikasi.

Dibutuhkan baris yang dikirim oleh klien,

mengkapitalisasi dan menambahkan carriage return.

Ia menggunakan Metode toUpperCase ().

Itu melengkapi analisis kami dari Program

TCP. Ingatlah bahwa TCP menyediakan layanan

transfer data yang dapat diandalkan. Ini berarti, dalam

khususnya, bahwa jika jaringan satu pengguna rusak ,

maka host klien akan retransmit karakter, sehingga

memberikan pengiriman data yang benar.

Untuk menguji pasangan program, Anda dapat

menginstal dan mengkompilasi TCPClient.java dalam

satu host dan TCPServer.java di host lain. Pastikan

nama host tepat dari server di TCPClient.java.

Kemudian anda jalankan TCPServer.class, kompilasi

15

program di server. Hal ini menciptakan suatu proses

di dalam server yang idles sampai bisa dihubungi oleh

beberapa klien. Kemudian Anda mengeksekusi

TcpClient. Semuanya disusun di klien. Hal ini

menciptakan suatu proses klien dan menetapkan

koneksi TCP antara proses client dan server.

Akhirnya, untuk menggunakan aplikasi ini, Anda

mengetikan kalimat diikuti oleh carriage return.

Untuk mengembangkan sendiri aplikasi client-

server, Anda bisa mulai dengan sedikit memodifikasi

program. Misalnya, mengkonversi semua huruf ke

huruf besar, server dapat menghitung berapa kali

huruf "s" muncul.

2.1.2 Socket Programming dengan UDPUDP memungkinkan dua (atau lebih) proses yang berjalan

pada host yang berbeda untuk berkomunikasi. Namun, UDP

berbeda dari TCP secara fundamental. Pertama, UDP adalah

layanan connectionless - tidak ada fase handshaking awal di mana

pipe dibentuk antara dua proses. Karena UDP tidak memiliki pipe,

ketika proses ingin mengirim batch byte untuk proses lain,

pengiriman proses harus melampirkan alamat proses tujuan untuk

batch byte. Dan ini harus dilakukan untuk setiap batch byte proses

mengirimkan pengiriman. Jadi UDP mirip dengan layanan taksi,

saat sekelompok orang masuk taksi, kelompok tersebut harus

memberitahu sopir alamat tujuan mereka. Seperti TCP, alamat

tujuan adalah tuple yang terdiri dari alamat IP dari host tujuan dan

nomor port dari proses tujuan. Kami akan mengacu pada informasi

batch byte bersama dengan IP alamat tujuan dan nomor port

sebagai "paket" itu. UDP menyediakan model berorientasi layanan

pesan tidak dapat diandalkan, dalam hal ini membuat upaya terbaik

untuk memberikan batch byte ke tujuan. Message oriented dalam

batch adalah byte yang dikirim dalam operasi nol tunggal pada sisi

16

pengirim, akan disampaikan sebagai batch pada sisi penerima, hal

ini kontras dengan TCP byte-stream semantik. Layanan UDP

adalah upaya terbaik, dalam UDP tidak menjamin bahwa batch

byte memang akan dikirimkan. Layanan UDP sangat kontras

(dalam beberapa hal) dengan model layanan byte-stream terpercaya

TCP.

Setelah menciptakan sebuah paket, proses mendorong

pengiriman paket ke jaringan melalui soket. Melanjutkan dengan

analogi taksi, di sisi lain dari soket, ada taksi menunggu paket.

Taksi kemudian mendorong paket ke arah alamat tujuan paket itu.

Namun, taksi tidak menjamin bahwa pada akhirnya akan

mendapatkan datagram ke tujuan utamanya, taksi bisa istirahat

bawah. Dalam istilah lain, UDP menyediakan layanan transportasi

namun tidak bisa diandalkan untuk proses komunikasi – itu tidak

memberikan jaminan bahwa datagram akan mencapai tujuan

akhirnya.

Pada bagian ini akan digambarkan pemrograman UDP

client-server dengan membangun kembali aplikasi yang sama dari

bagian sebelumnya, tapi kali ini menggunakan UDP. Disini akan

terlihat bahwa kode Java untuk UDP berbeda dari kode TCP.

Secara khusus, kita akan melihat bahwa ada (1) tidak ada

handshaking antara dua proses, dan karena itu tidak perlu untuk

welcoming soket, (2) tidak ada streams yang melekat pada soket,

(3) host pengirim menciptakan paket dengan melampirkan alamat

IP tujuan dan nomor port untuk mengirimkan setiap batch byte, dan

(4) proses penerimaan harus mengungkap setiap paket yang

diterima untuk mendapatkan byte informasi paket tersebut.

17

Gambar 2. 4 aktivitas utama soket dari klien dan server pada UDP

2.1.2.1 Contoh Client-Server Application di Java

Dengan menggunakan contoh kasus yang sama dengan

pemrograman pada TCP,berikut akan dijelaskan program

yang menerapkan UDP

a. UDPClient.java

Berikut adalah kode untuk sisi klien dari aplikasi:

import java.io.*;

import java.net.*;

class UDPClient {

public static void main(String args[]) throws Exception

{




18

DatagramSocket clientSocket = new

DatagramSocket();

InetAddress IPAddress =

InetAddress.getByName("hostname");

byte[] sendData = new byte[1024];

byte[] receiveData = new byte[1024];

String sentence = inFromUser.readLine();

sendData = sentence.getBytes();

DatagramPacket sendPacket =

new DatagramPacket(sendData, sendData.length,

IPAddress,

9876);

clientSocket.send(sendPacket);

DatagramPacket receivePacket =

new DatagramPacket(receiveData,

receiveData.length);

clientSocket.receive(receivePacket);

String modifiedSentence =

new String(receivePacket.getData());

System.out.println("FROM SERVER:" +

modifiedSentence);


}

}

Program UDPClient.java membangun satu

streams dan satu soket, seperti yang ditunjukkan pada

Gambar 2.4. Socket itu disebut clientSocket, dan itu

adalah jenis DatagramSocket. Perhatikan bahwa UDP

menggunakan berbagai jenis soket daripada TCP pada

klien. Secara khusus, dengan UDP klien menggunakan

DatagramSocket sedangkan dengan TCP klien

menggunakan Socket. Stream InFromUser adalah stream

masukan untuk program tersebut; stream ini terpasang ke

input standar, yaitu, keyboard. Kami memiliki aliran

setara dalam versi TCP tentang program kita. Ketika

19

pengguna jenis karakter pada keyboard, aliran karakter

inFromUser. Namun sebaliknya dengan TCP, tidak ada

aliran (input atau output) yang melekat pada soket. UDP

akan mendorong paket individu yang melalui objek

DatagramSocket.

Berikut merupakan baris dalam kode yang

memiliki perbedaan signifikan dari TCPClient.java.

DatagramSocket clientSocket = new

DatagramSocket();

Baris di atas menciptakan objek clientSocket

jenis DatagramSocket. Baris ini tidak memulai koneksi

TCP. Secara khusus, host klien tidak menghubungi host

server setelah eksekusi baris ini. Untuk alasan ini,

konstruktor DatagramSocket() tidak mengambil server

hostname atau nomor port sebagai argumen. Eksekusi

baris di atas untuk menciptakan sebuah pintu untuk

proses klien tetapi tidak membuat pipe antara dua proses.

InetAddress IPAddress =

InetAddress.getByName("hostname");

20

Gambar 2. 5 Stream UDP

Dalam rangka untuk mengirim byte ke proses

tujuan, kita akan perlu untuk mendapatkan alamat dari

proses. Bagian dari alamat ini adalah alamat IP dari host

tujuan. Baris diatas memanggil DNS yang

menerjemahkan "hostname" (disediakan dalam kode oleh

pengembang) ke alamat IP. Method getByName()

mengambil sebagai argumen dari hostname dari server

dan mengembalikan alamat IP yang sama dari Server.

Method ini menempatkan alamat dalam objek IP Address

dengan tipe InetAddress.



21

byte array sendData dan receiveData akan

menyimpan masing-masing data client yang

mengirimkan dan menerima.

sendData = sentence.getBytes();

Baris di atas pada dasarnya melakukan sebuah

konversi. Dibutuhkan kalimat string dan mengganti nama

string tersebut sebagai sendData, yang merupakan byte

dari array tersebut.



IPAddress, 9876);

Baris di atas membangun paket, sendPacket,

bahwa klien akan pop ke jaringan melalui socketnya.

Paket ini termasuk bahwa data yang terkandung dalam

paket, sendData, panjang data, alamat IP dari server, dan

nomor port dari aplikasi (yang telah diatur ke 9876).

Perhatikan bahwa sendPacket adalah jenis

DatagramPacket.

clientSocket.send(sendPacket);

Pada baris di atas metode send () dari objek

clientSocket mengambil paket dan muncul ke jaringan

melalui clientSocket. Sekali lagi, perhatikan bahwa UDP

mengirimkan baris karakter yang sangat berbeda dari

cara TCP. TCP hanya dimasukkan ke dalam sebuah

streams, yang memiliki koneksi langsung ke server, UDP

menciptakan paket yang mencakup alamat dari server.

Setelah mengirim paket, klien kemudian menunggu

untuk menerima paket dari server.


22



Pada baris di atas, sambil menunggu paket dari

server, klien membuat ruang untuk paket, receivePacket,

yang merupakan obyek jenis DatagramPacket.

clientSocket.receive(receivePacket);

Klien idles menerima sebuah paket, Jika tidak

menerima paket, maka ditempatkan ke dalam

receivePacket.

String modifiedSentence =

new String(receivePacket.getData());

Baris di atas digunakan untuk ekstrak data dari

receivePacket dan melakukan konversi, mengkonversi

byte array ke dalam string modifiedSentence.

System.out.println("FROM SERVER:" +

modifiedSentence);

Baris diatas digunakan untuk mencetak string

modifiedSentence pada klien.


Ini baris terakhir menutup soket. Karena UDP

adalah connectionless, baris ini tidak menyebabkan klien

untuk mengirim sebuah pesan layer transport ke server.

b. UDPServer.java

Berikut aplikasi dari sisi server :

import java.io.*;

import java.net.*;

class UDPServer {public static void main(String args[])

throws Exception

23

{

DatagramSocket serverSocket = new

DatagramSocket(9876);



while(true)

{




serverSocket.receive(receivePacket);

String sentence = new

String(receivePacket.getData());

InetAddress IPAddress = receivePacket.getAddress();

int port = receivePacket.getPort();

String capitalizedSentence = sentence.toUpperCase();

sendData = capitalizedSentence.getBytes();



IPAddress,

port);

serverSocket.send(sendPacket);

}

}

}

Program UDPServer.java membangun sebuah

soket, seperti yang ditunjukkan pada Gambar 2.6. Socket

ini disebut ServerSocket. Ini adalah obyek dari jenis

DatagramSocket, seperti soket di sisi aplikasi klien.

Sekali lagi, tidak ada streams yang melekat pada soket.

24

Gambar 2. 6 UDPServer tidak memiliki streams

Berikut baris kode yang berbeda dari

TCPServer.java.

DatagramSocket serverSocket = new

DatagramSocket(9876);

Baris di atas mengkonstruksi ServerSocket

DatagramSocket pada port 9876. Semua data yang

dikirim dan diterima akan melewati soket ini. Karena

UDP adalah connectionless, tidak perlu menciptakan

sebuah socket baru dan terus mendengarkan permintaan

sambungan baru, seperti yang dilakukan di

TCPServer.java. Jika beberapa klien mengakses aplikasi

ini, mereka semua akan mengirimkan paket mereka ke

dalam satu pintu, yaitu ServerSocket.

String sentence = new

String(receivePacket.getData());

InetAddress IPAddress = receivePacket.getAddress();

int port = receivePacket.getPort();

25

Tiga baris di atas mengungkap paket yang datang

dari klien. Yang pertama dari tiga baris akan

mengekstrak data dari paket dan menempatkan data ke

String sentence, string sentence memiliki garis analog di

UDPClient. Baris kedua mengekstrak IP address, baris

ketiga mengekstrak nomor port client, yang dipilih oleh

klien dan berbeda dari nomor port server 9876. Hal ini

diperlukan untuk server mendapatkan alamat (IP alamat

dan nomor port) dari klien, sehingga dapat mengirim

kalimat yang dikapitalisasi kembali ke klien.

Itu melengkapi analisis kami dari UDP program

pair. Untuk menguji aplikasi, Anda menginstal dan

mengcompile UDPClient.java dalam satu host dan

UDPServer.java di host lain. (Pastikan untuk

menyertakan hostname dari server di UDPClient.java.).

Kemudian dua program dieksekusi pada host masing-

masing. Berbeda dengan TCP, Anda dapat menjalankan

sisi klien dan kemudian sisi server. Hal ini karena, ketika

Anda menjalankan sisi klien, proses klien tidak berusaha

untuk memulai koneksi dengan server. Setelah Anda

mengeksekusi program client dan server, anda dapat

menggunakan aplikasi ini dengan mengetikkan baris di

klien.

BAB III

PEMBAHASAN

3.1 UDPChatServerUdpChatServer merupakan program yang menjalankan fungsi dari

server.Dimana terdapat beberapa class dan method yang memiliki fungsi

masing-masing.Berikut akan dijelaskan lebih jelas. Class ServerSide

merupakan class yang memuat inti kegiatan dari bagian server program

ini.class ini mengimplementasikan interface runnable karena terdapat

penggunaan thread pada class ini

class ServerSide implements Runnable { ArrayList<InetAddress> clientsIP; ArrayList<Integer> clientsPort; DatagramSocket ds; int serverPort; Thread serverThread;

Diatas merupakan potongan kode awal pada class ServerSide.Dimana

dideklarasikan variabel-variabel yang digunakan pada class ini.Terdapa

deklarasi variabel ArrayList,variabel ini digunakan untuk menyimpan data

client yang terhubung ke server.yaitu IP address client dan nomer port yang

digunakan oleh client.Kemudian dideklarasikan variabel DatagramSocket

dengan nama ds,yang nantinya akan dibentuk untuk proses komunikasi ke

client,baik itu mengirim ataupun menerima paket.Kemudian ada variabel

serverPort yan digunakan untuk menyimpan nomer port yang digunakan saat

server berjalan.Ada pula deklarasi thread dengan nama serverThread.

button1 = new JButton("Start"); button1.setBounds(10, 10, 185, 20); button1.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent ae) { server.start(Integer.parseInt(field2.getText())); //beri informasi port field4.setText("Server Online"); button1.setEnabled(false); //tombol start mati button2.setEnabled(true); // tombol stop hidup

26

27

} });

public void start(int port) { serverPort = port; try { // open DatagramSocket to receive ds = new DatagramSocket(serverPort); } catch (SocketException ex) { Logger.getLogger(UDPChatServer.class.getName()).log(Level.SEVERE, null, ex); }

serverThread = new Thread(this); serverThread.start(); }

Diatas merupakan sebuah method dengan nama start yang menerima variabel

port.method ini digunakan untuk memulai server dengan nomer port yang

sudah ditentukan oleh user.Method ini akan berjalan ketika user menekan

tombol start pada program,ketika tombol start ditekan,maka akan dipanggil

method start,dengan membawa nilai dari nomer port yang akan

digunaka,yang diambil dari inputan user.Ketika method ini dijalankan,akan

dibentuk objek datagramsocket yang baru dengan nama ds,yang akan

digunakan untuk menerima paket dari client.Apabila gagal dibentuk,program

akan menampilakan kesalahan yang terjadi.Setelah proses tersebut,maka akan

dibentuk thread baru dengan nama ServerThread,dan thread tersebut akan

dijalankan.Ketika thread dijalankan,maka method run() akan langsung

dieksekusi,berikut merupakan potongan kode dari method run().

try { //array penampung data client clientsIP = new ArrayList<InetAddress>(); clientsPort = new ArrayList<Integer>();

area.append("#Server :\n" + "#IP address " + InetAddress.getLocalHost().getHostAddress() + " port " + serverPort + "\n" );

//terima pesan masuk

28

try { // loop forever reading datagrams from the DatagramSocket while (true) { byte[] buffer = new byte[100000]; // array to put datagrams in DatagramPacket dp = new DatagramPacket(buffer, buffer.length); // DatagramPacket to hold the datagram ds.receive(dp); String s = new String(dp.getData(),0,dp.getLength()); String msg = dp.getAddress() + ": " + s;

Pada method run,akan dibentuk ArrayList yang akan menampung ip client

dan port dari client.Kemudian program akan menampilkan pesan yang

menyatakan server telah aktif pada IP dan Host sekian.Setelah itu program

akan melakukan looping forever untuk menerima/membaca datagrampacket

dari datagramsocket.Setelah datagrampacket diterima,pesan asli dari

datagrampacket tersebut akan ditampung pada variabel string dengan nama

‘s’ kemudian ditampung lagi pada variabel string msg,dan digabungkan

dengan alamat pengirim paket tersebut.

boolean userExist = false; int n=0; for(n=0; n<clientsIP.size(); n++) { if(clientsIP.get(n).toString().equals(dp.getAddress().toString())&& clientsPort.get(n)==dp.getPort()) { userExist = true; } } if(userExist == false) { clientsIP.add(n, dp.getAddress()); clientsPort.add(n, dp.getPort()); area.append("#Ada Client Baru Terhubung " + dp.getAddress() + " Dengan port " + dp.getPort() + "\n"); }

Kemudian diatas merupakan potongan kode untuk mengetahui apakah client

yang terhubung sudah ada atau belum.Disini digunakan variabel dengan tipe

29

boolean bernama userExist yang diawal akan diset false.Variabel ini yang

akan menetukan apakah iclient tersebut sudah ada atau belum di

server.Dilakukan pengecekan sebanyak panjang dari ArrayList

ClientIP.Disini dicek satu persatu data IP dan port yang tersimpan pada

arraylist.Jika data IP dan port pada urutan array tertentu sama dengan IP dan

port pada pengirim paket,berarti client tersebut sudah ada diserver,dan nilai

dari userExist akan diset true.Namun jika tidakberarti client tersebut

merupakan client yang baru terhubung ke server, maka IP dan nomer port

pada client tersebut akan disimpan pada array.Dan kemudian akan

ditampilkan pada program bahwa ada client baru yang terhubung.

for(int i=0 ; i<clientsIP.size(); i++) { if(! (clientsIP.get(i).toString().equals(dp.getAddress().toString())&& clientsPort.get(i)==dp.getPort())){ try{ //kirim pesan InetAddress clientIP = clientsIP.get(i); int clientPort = clientsPort.get(i); byte[] data = msg.getBytes(); // convert to byte array DatagramSocket theSocket = new DatagramSocket(); // create datagram socket and the datagram DatagramPacket theOutput = new DatagramPacket(data, data.length, clientIP, clientPort); theSocket.send(theOutput); } catch (Exception e) {area.append("Gagal Mengirim Datagram" + e + "\n");} } }

Potongan kode diatas digunakan untuk mengirimkan pesan yang masuk ke

server,ke semua client yang terhubung ke server,kecuali si pengirim pesan itu

sendiri.Caranya akan dilakukan pengecekan sebanyak ukuran dari array

penampung ip dari client.Sama seperti proses pengecekan client

sebelumnya,dimana akan dicek dengan membandingkan satu persatu data IP

30

dan port pada array dengan ip dan port si pengirim paket,apabila tidak

sama,maka paket akan dikirimkan ke client dengan IP dan nomer Port pada

urutan array tersebut

button2 = new JButton("Stop"); button2.setBounds(200, 10, 175, 20); button2.addActionListener(new ActionListener() { public void actionPerformed (ActionEvent ae) { server.stop(); field4.setText("Server Offline"); area.append("===================================================\n"); button1.setEnabled(true); button2.setEnabled(false); } });

public void stop() { serverThread.interrupt(); }

Method stop() diatas digunakan untuk menghentikan serverThread yang

sedang berjalan.Pada Program ini,method stop akan berjalan ketika user

menekan button stop pada program.

button = new JButton("Send"); button.setBounds(305, 98, 70, 20); button.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent ae) { server.sendRequest(field3.getText()); } });

public void sendRequest(String message) { String msg = "+SERVER: " + message; area.append(msg + "\n"); field3.setText("");

//kirim pesan yang masuk ke semua user kecuali pengirim for(int i=0 ; i<clientsIP.size(); i++){ try{ //kirim pesan

31

InetAddress clientIP = clientsIP.get(i); int clientPort = clientsPort.get(i); byte[] data = msg.getBytes(); // konversi ke byte array DatagramSocket theSocket = new DatagramSocket(); // membuat datagram socket and datagram paket DatagramPacket theOutput = new DatagramPacket(data, data.length, clientIP, clientPort); theSocket.send(theOutput);

} catch (Exception e) {area.append("Gagal Mengirim Datagram " + e + "\n");} }

}

Method sendRequest digunakan untuk mengirim pesan dari server ke semua

client yang terhubung.Dimana method ini akan berjalan ketika user menekan

tombol “send”.Ketika tombol send ditekan,maka akan dipanggil method

sendRequest dengan membawa pesan yang diperoleh dari inputan program.

Pesan akan dikirimkan sebanyak data yang terdapat pada array yang

menampung IP dari client yang terhubung ke server.Proses pengiriman pesan

dimulai dengan mengkonversi pesan ke dalam byte array,kemudian dibentuk

datagramsocket dengan nama theSocket dan datagrampacket dengan nama

theOutput yang memuat isi pesan,panjang pesan,ip dari client,dan port dari

client.Kemudia datagrampacket ini akan dikirimkan melalui

datagramsocketnya.

3.2 UDPChatClientUDPChatClient merupakan program yang menjalan fungsi dari client. Pada

program ini akan menghubungkan antara client dengan client maupun client

dengan server. Pada program ini terdapat beberapa method dan class yang

memiliki fungsi masing-masing. Penjelasan tentang program ini akan

dijelaskan di bawah berikut :

import javax.swing.*;import java.awt.*;import java.awt.event.*;import java.net.*;import java.io.*;

32

Code diatas merupakan library yang digunakan untuk program client kami.

//variable publik JFrame frame; JPanel panel; JTextField field1, field2, field3; JTextArea area; JScrollPane pane; JLabel label; JButton button; DatagramSocket socket; Thread thread;

Code diatas merupakan variable public untuk program client ini. 7 baris code

pertama merupakan variable untuk GUI program, dan 2 baris selanjutnya

merupakan variable untuk proses thread dan socket di client.

//main program public static void main(String[] args) throws SocketException { UDPChatClient u = new UDPChatClient(); //menjalankan class UDPChatClient }

Code diatas merupakan main program yang akan menjalankan class

UDPChatClient saat dieksekusi.

//design interface program public UDPChatClient() throws SocketException{ //inisialisasi socket socket = new DatagramSocket();

//untuk bingkai dasar tempat semua frame = new JFrame("Client"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); panel = new JPanel(); panel.setLayout(null);

//untuk tata letak tulisan IP Server dan textfieldnya label = new JLabel("IP Server"); label.setBounds(10, 10, 100, 30); panel.add(label); field1 = new JTextField(20); field1.setBounds(85, 13, 150, 20); panel.add(field1);

//untuk tata letak tulisan Port tujuan dan textfieldnya label = new JLabel("Port Tujuan"); label.setBounds(10, 40, 100, 30);

33

panel.add(label); field2 = new JTextField(10); field2.setBounds(85, 43, 100, 20); panel.add(field2);

//untuk tata letak textfield untuk chat field3 = new JTextField(10); field3.setBounds(10, 70, 290, 20); panel.add(field3);

//untuk tata letak Tombol send button = new JButton("Send"); button.setBounds(305, 70, 70, 20); button.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent ae){ sendRequest(); //memanggil class SendRequest saat tombol send di klik } }); panel.add(button);

///untuk tata letak History chat area = new JTextArea(); pane = new JScrollPane(area); area.setEditable(false); pane.setBounds(10, 95, 365, 250); panel.add(pane);

//untuk bingkai diset dengan ukuran 400 x 400 pixel frame.add(panel); frame.setSize(400, 400); frame.setVisible(true);

//membuat thread baru dengan nama client Thread client = new Thread(this); client.start(); //thread berjalan dan mengeksekusi method run }

Code diatas digunakan untuk mengatur dan design dari interface program

client ini. Pada code bagian tombol send terdapat action saat tombol send di

klik, action tersebut akan memanggil class Send Request saat tombol send

tersebut di klik. Selanjutnya pada 2 baris terakhir yaitu “Thread client =

new Thread(this);” code ini akan membuat thread baru. Selanjutnya

untuk “client.start();” code ini akan menjalankan thread yang sudah

dibuat dan langsung mengeksekusi method run.

public void sendRequest() { try//eksekusi pengiriman paket { String dip = field1.getText(); //mengambil text pada textfield ip dan disimpan pada variabel string dip

34

InetAddress address = InetAddress.getByName(dip); //class ini akan mengambil alamat ip pada variable string dip String port = field2.getText(); //mengambil text pada textfield port dan disimpan pada variabel string port int pnum = Integer.parseInt(port); //variabel string port dikonversi bilangan bulat pada variable pnum. String mess = field3.getText(); //mengambil text pada textfield chat dan disimpan pada variabel string mess

//untuk mengirim pesan ke klien byte message[] = mess.getBytes();//mengkonversi pesan menjadi byte DatagramPacket packet = new DatagramPacket(message, message.length, address, pnum); //mengeset paket yang dikirim dengan isi pesan, panjang pesan, alamat tujuan dan port socket.send(packet);//mengirim paket ke tujuan

//cetak ke text area area.append("+Anda : "+field3.getText()+"\n");//mencetak hasil pengiriman ke text area/history chat field3.setText("");//membersihkan textfield chat } catch(IOException io)//untuk menangkap kesalahan yang terjadi saat program berjalan { } }

Code diatas digunakan untuk mengeksekusi perintah pengiriman pesan

setelah tombol send diklik, penjelasan per baris code sebagai berikut :

a. Try : code ini akan mengeksekusi pengiriman paket

b. String dip = field1.getText(); : code ini mengambil text pada

textfield ip dan disimpan pada variabel string dip

c. InetAddress address = InetAddress.getByName(dip); : code ini

akan mengambil alamat ip pada variable string dip

d. String port = field2.getText(); : code ini mengambil text pada

textfield port dan disimpan pada variabel string port

e. int pnum = Integer.parseInt(port); : code ini akan mengkonversi

variabel string port menjadi bilangan bulat pada variable pnum.

f. String mess = field3.getText(); : code ini mengambil text pada

textfield chat dan disimpan pada variabel string mess

g. byte message[] = mess.getBytes(); : code ini mengkonversi pesan

menjadi byte

35

h. DatagramPacket packet = new DatagramPacket(message,

message.length, address, pnum); : code ini mengeset paket yang

dikirim dengan isi pesan, panjang pesan, alamat tujuan dan port

i. socket.send(packet); : code ini mengirim paket ke tujuan

j. area.append("+Anda : "+field3.getText()+"\n"); : code ini

mencetak hasil pengiriman ke text area/history chat

k. field3.setText(""); : code ini membersihkan textfield chat

l. catch(IOException io) : code ini digunakan untuk menangkap

kesalahan yang terjadi saat program berjalan

public void run() //method yang pertama kali saat thread di buat { byte[] terima = new byte[100000]; //membuat array untuk menerima pesan while(true){// looping forever untuk menerima pesan try{//eksekusi penerimaan paket DatagramPacket terimapaket = new DatagramPacket(terima, terima.length); //membuat ruang untuk menerima datagram paket yang dikirimkan

socket.receive(terimapaket);//menerima paket String bacapesan = new String(terimapaket.getData(),0,terimapaket.getLength());//membuat string untuk membaca isi dari paket dengan mengambil data dan panjang dari paket yang dikirim area.append( bacapesan+"\n");//mencetak pesan yang di terima ke text area/history chat } catch(Exception e)//untuk menangkap kesalahan yang terjadi saat program berjalan { } } }

Code ini akan berjalan saat thread sudah dibuat. Code ini digunakan untuk

menerima pesan yang dikirimkan ke client baik dari server maupun client yang

lain. Penjelasan per baris codenya sebagai berikut :

a. byte[] terima = new byte[100000]; : code ini untuk membuat array

untuk menerima pesan

b. while(true){} : code ini merupakan looping forever untuk menerima

pesan

c. try{} : code ini akan mengeksekusi penerimaan paket

36

d. DatagramPacket terimapaket = new DatagramPacket(terima,

terima.length); : code ini akan membuat ruang untuk menerima

datagram paket yang dikirimkan

e. socket.receive(terimapaket); : code ini digunakan untuk menerima

paket

f. String bacapesan = new String(terimapaket.getData(), 0,

terimapaket.getLength()); : code ini membuat string untuk membaca

isi dari paket dengan mengambil data dan panjang dari paket yang dikirim

g. area.append( bacapesan+"\n"); : code ini akan mencetak pesan yang

di terima ke text area/history chat

h. catch(Exception e) : code ini digunakan untuk menangkap kesalahan

yang terjadi saat program berjalan

3.3. Demo Program

3.3.1 Demo Program Server

Gambar 3. 1 Start Server

37

Diatas merupakan tampilan awal program dari sisi server.Dimana

terdapat beberapa tombol yaitu tombol start.tombol stop,dan tombol

send.untuk mengaktifkan server agar dapat dihubungi oleh client,kita

harus menginputkan nomer port yang akan digunakan.Pada gambar

diatas digunakan nomer port 8080.Setelah menginputkan nomer

port,kemudian tekan button start.Maka pada field status akan muncul

pesan dimana server telah online.Dan pada text area akan muncul

informasi ip dari server dan nomer port yang digunakan.Server siap

menunggu client yang terhubung.

Gambar 3. 2 Server menerima pesan dari Client

Diatas merupakan tampilan ketika server menerima pesan dari

client.Dimana ketika client baru terhubung ditampilkan informasi

tentang alamat ip dan port dari client yang terhubung. Setelah itu akan

ditampilkan pesan yang dikirimkan oleh client tersebut.

38

Gambar 3. 3 Server terhubung dengan lebih satu Client

Program ini akan bisa melakukan percakapan ke lebih dari satu

client.Terlihat pada gambar diatas, dimana terdapat client baru yang

terhubung.Dimana pesan yang dikirimkan oleh client baru tersebut,akan

dikirmkan juga ke client yang sebelumnya telah terhubung ke server.

39

3.3.2 Demo Program Client

Gambar 3. 4 Tampilan awal Client

Tampilan diatas merupakan tampilan awal program client. Untuk dapat

saling terhubung maka pada program ini harus menginputkan IP Server,

port tujuannya, dan text yang ingin di kirimkan jika sudah klik tombol

send seperti terlihat pada gambar dibawah berikut.

40

Gambar 3. 5 Client mengirim pesan ke Server

41

Jika sudah mengklik tombol send, pesan akan tercetak di history chat

tersebut seperti terlihat pada gambar diatas. Terlihat juga pada gambar

diatas server sudah membalas pesan dari client, dan ini berarti chatting

sudah dilakukan. Tampilan program diatas merupakan saat program

client dengan server ini ada client baru yang baru bergabung. Client

baru tersebut akan terlihat IP address serta pesannya, dan client ini

harus terhubung keserver terlebih dahulu sebelum melakukan chatting

ini.

Gambar 3. 6 Multi Client Chat

BAB IV

PENUTUP

4.1 Kesimpulan

Kesimpulan yang kami dapat dari materi tentang socket programming ini adalah :

1. Socket programming merupakan suatu cara dalam menggunakan

socket API, agar satu program bisa berinteraksi dengan program

lainnya dalam satu jaringan.

2. Socket programming dengan UDP tidak memiliki keunggulan yang

terdapat pada TCP. Pengiriman data pada UDP biasanya data akan

hilang maupun rusak. Namun pengiriman dengan UDP lebih cepat

karena tidak ada proses pemeriksaan koneksi.

3. Pada Socket programming dengan UDP,pesan dikirimkan tanpa

mementingkan apakah server berjalan atau tidak.Karena tidak ada

pembentukan koneksi terlebih dahulu seperti yang dilakukan oleh

TCP.

42

DAFTAR PUSTAKA

James F. Kurose, K. W. (2010). Computer Networking, A Top-Down Approach. Boston: Pearson Education, Inc.

43

Kelompok5 4 Program Socket

Documents

Transcript of Kelompok5 4 Program Socket