kelompok5 4 program socket
Post on 28-Nov-2015
159 Views
Preview:
DESCRIPTION
TRANSCRIPT
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
new BufferedReader(new
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 {
public static void main(String argv[]) throws
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.
BufferedReader inFromUser =
new BufferedReader(new
InputStreamReader(System.in));
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 =
new BufferedReader(new
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.
clientSocket.close();
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 {
public static void main(String argv[]) throws
Exception
{
String clientSentence;
String capitalizedSentence;
ServerSocket welcomeSocket = new
ServerSocket(6789);
while(true) {
13
Socket connectionSocket =
welcomeSocket.accept();
BufferedReader inFromClient =
new BufferedReader(new
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
{
BufferedReader inFromUser =
new BufferedReader(new
InputStreamReader(System.in));
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);
clientSocket.close();
}
}
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.
byte[] sendData = new byte[1024];
byte[] receiveData = new byte[1024];
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.
DatagramPacket sendPacket =
new DatagramPacket(sendData, sendData.length,
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.
DatagramPacket receivePacket =
22
new DatagramPacket(receiveData,
receiveData.length);
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.
clientSocket.close();
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);
byte[] receiveData = new byte[1024];
byte[] sendData = new byte[1024];
while(true)
{
DatagramPacket receivePacket =
new DatagramPacket(receiveData,
receiveData.length);
serverSocket.receive(receivePacket);
String sentence = new
String(receivePacket.getData());
InetAddress IPAddress = receivePacket.getAddress();
int port = receivePacket.getPort();
String capitalizedSentence = sentence.toUpperCase();
sendData = capitalizedSentence.getBytes();
DatagramPacket sendPacket =
new DatagramPacket(sendData, sendData.length,
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.
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
top related