Modul network programming

PRAKTIKUM
PEMROGRAMAN JARINGAN
Oleh :
Arief Prasetyo, S.Kom.
NIP. 19790313 200812 1 002
POLITEKNIK NEGERI MALANG
2012

ii
KATA PENGANTAR
Dengan mengucap syukur Alhamdulillah, akhirnya selesai juga pembuatan
buku ajar dengan judul PRAKTIKUM PEMROGRAMAN JARINGAN. Buku
ajar ini diperuntukkan bagi mahasiswa jurusan Teknik Elektro program studi D4
Teknik Informatika tingkat tiga pada semester lima.
Dengan mempelajari buku ini, diharapkan pembaca dapat menguasai
pengetahuan tentang Pemrograman Jaringan, antara lain, InetAddressing, Stream,
Filter Stream, Object Persistence dan Object Serialization, pemrograman
komunikasi UDP dan TCP, pemrogram multicast, serta koneksi URL.
Tiada gading yang tak retak, begitu juga dengan buku ajar ini yang masih
banyak kekurangannya. Untuk itu penulis sangat mengharapkan kritik dan saran
yang membangun, sehingga bisa dilakukan perbaikan. Akhir kata penulis
menyampaikan terima kasih atas bantuan dari berbagai pihak, hanya Allah SWT
yang mampu membalasnya. Dan bagi yang mempelajari buku ini, selamat belajar.
Malang, Nopember 2012
Penulis

iii
DAFTAR ISI
HALAMAN PENGESAHAN..............ERROR! BOOKMARK NOT DEFINED.
SURAT PERNYATAAN .....................ERROR! BOOKMARK NOT DEFINED.
KATA PENGANTAR.......................................................................................... II
DAFTAR ISI........................................................................................................III
MODUL 1 REVIEW KONSEP JARINGAN .................................................... 1
1.1. JARINGAN KOMPUTER (NETWORK)...................................................... 1
1.2. PRAKTIKUM MODUL 1 ............................................................................. 1
MODUL 2 INTERNET ADDRESS.................................................................... 5
2.1. IPV4 .............................................................................................................. 5
2.2. DNS.............................................................................................................. 6
2.3. ALAMAT IP DAN JAVA................................................................................. 6
2.4. PENGGUNAAN INETADDRESS ........................................................................ 7
2.5. PRAKTIKUM MODUL 2................................................................................... 8
MODUL 3 STREAM ......................................................................................... 10
3.1. REVIEW STREAM ......................................................................................... 10
3.2. INPUT STREAM ............................................................................................ 11
3.3. PENGGUNAAN INPUT STREAM ..................................................................... 13
3.4. OUTPUT STREAM......................................................................................... 14
3.5. PENGGUNAAN OUTPUT STREAM.................................................................. 16
3.6. PRAKTIKUM MODUL 3................................................................................. 17
MODUL 4 FILTER STREAM ......................................................................... 18
4.1. DASAR FILTER STREAM.............................................................................. 18
4.2. FILTER INPUT STREAM ................................................................................ 19
4.2.1. Buffered Input Stream ...................................................................................19
4.2.2. Data Input Stream .........................................................................................20
4.2.3. LineNumber Input Stream .............................................................................21

iv
4.2.4.PushBackInputStream ....................................................................................21
4.3. FILTER OUTPUT STREAM............................................................................. 22
4.3.1. Buffered Output Stream ................................................................................22
4.3.2. Data Output Stream ......................................................................................22
4.3.3. PrintStream....................................................................................................23
4.4. PRAKTIKUM MODUL 4................................................................................. 25
MODUL 5 OBJECT PERSISTENCE DAN OBJECT SERIALIZATION.. 26
5.1. OBJECT PERSISTENCE................................................................................... 26
5.2. OBJECT SERIALIZATION................................................................................. 26
5.3. CARA KERJA OBJECT SERIALIZATION ........................................................... 26
5.4. PERMASALAHAN PADA PENGGUNAAN SERIALISASI..................................... 27
5.5. MEMBACA DAN MENULISKAN OBJECT PADA STREAM ................................ 28
5.5.1. Kelas ObjectInputStream...............................................................................28
5.5.2. Kelas ObjectOutputStream............................................................................28
5.6. PENGGUNAAN OBJECT SERIALIZATION ......................................................... 29
5.7. PRAKTIKUM MODUL 5................................................................................. 32
MODUL 6 PEMROGRAMAN USER DATAGAM PROTOCOL (UDP).... 33
6.1. PROTOKOL UDP.......................................................................................... 33
6.2. UDP PADA JAVA........................................................................................ 33
6.2.1. DatagramPacket............................................................................................34
6.2.2. DatagramSocket............................................................................................36
6.3. MENGIRIM DATA UDP................................................................................ 38
6.4. MENERIMA DATA UDP............................................................................... 38
6.5. PRAKTIKUM MODUL 6................................................................................. 39
MODUL 7 PEMROGRAMAN TRANSMISSION CONTROL PROTOCOL
(TCP).................................................................................................................... 41
7.1. PROTOKOL TCP .......................................................................................... 41
7.2. TCP PADA JAVA .......................................................................................... 41
7.3. SOCKET ....................................................................................................... 42
7.4. SERVERSOCKET........................................................................................... 43
7.5. CONTOH PENGGUNAAN SERVERSOCKET..................................................... 45

v
7.6. CONTOH PENGGUNAAN SOCKET (KLIEN) .................................................... 47
7.7. PRAKTIKUM MODUL 7................................................................................. 49
MODUL 8 MULTICAST .................................................................................. 52
8.1. KONSEP KOMUNIKASI MULTICAST.............................................................. 52
8.2. MULTICASTSOCKET .................................................................................... 53
8.3. PENGGUNAAN MULTICASTSOCKET ............................................................. 56
8.4. PRAKTIKUM MODUL 8................................................................................. 58
MODUL 9 UNIFORM RESOURCE LOCATOR ........................................... 59
9.1. KELAS URL ................................................................................................ 59
9.2. KONEKSI URL............................................................................................. 60
9.3. PRAKTIKUM MODUL 9................................................................................. 61
DAFTAR PUSTAKA.......................................................................................... 62
RENCANA PEMBELAJARAN BERBASIS KOMPETENSI .............ERROR!
BOOKMARK NOT DEFINED.

1
MODUL 1 REVIEW KONSEP JARINGAN
Setelah mempelajari modul ini mahasiswa diharapkan dapat mengingat
kembali konsep jaringan, pengalamatan jaringan dan cara mendesain,
mengkonfigurasi dan menguji jaringan sederhana.
1.1. Jaringan Komputer (NETWORK)
Secara sederhana, jaringan adalah sekumpulan perangkat-perangkat
komunikasi yang dihubungkan dengan suatu media dan menggunakan protokol-
protokol komunikasi yang umum. Perangkat-perangkat di sini termasuk komputer
sebagai host, dan perangkat jaringan perantara seperti hub, switch dan router .
Media jaringan adalah media tempat data / informasi dilewatkan, seperti kabel
tembaga, fiber optik dan atmosfir untuk komunikasi wireless.
Untuk dapat berkomunikasi dalam jaringan komputer, maka diperlukan
pengalamatan antara perangkat-perangkat yang terhubung dalam jaringan
komputer, untuk dapat dibedakan mana komputer/host yang terlibat dalam
komunikasi.
1.2.Praktikum Modul 1
Dalam modul 1 ini, untuk mengingat kembali konsep jaringan komputer
maka kerjakanlah beberapa soal berikut.
1. Dengan menggunakan Packet Tracer, buatlah desain jaringan seperti di
bawah ini :
a. Ada berapa jaringankah yang ada pada diagram jaringan di atas ?

2
b. Perlukah router diberi konfigurasi routing agar jaringan-jaringan yang
terkoneksi langsung dengan dirinya bisa saling berkomunikasi?
Sebutkan alasannya .
c. Untuk masing-masing host (PC A, PC B & PC C ), berikan alokasi
pengalamatan agar diagram jaringan di atas bisa saling berkomunikasi.
Dengan format :
PC A :
IP address : ....
Subnet mask : ...
Gateway :....
Network ID : ...
d. Berikan konfigurasi pengalamatan untuk masing-masing interface
fastethernet Router, dengan asumsi fastEthernet 0/0 terhubung ke
switch, dan fastEthernet 0/1 terhubung langsung ke PC C.
Router fastEthernet 0/0 :
Ip Address : ...
Subnet mask : ...
IP Address : ...
Subnet mask : ...
e. Kabel jenis bagaimanakah yang digunakan untuk menghubungkan
masing-masing perangkat pada diagram jaringan di atas ? (Straight,
Cross atau Rollover)
PC A – Switch : ...
PC B - Switch : ...
Switch – Router : ...
Router – PC C : ...
f. Perintah apakah yang dapat digunakan untuk mengecek koneksi antar
host yang ada ?
2. Dengan menggunakan Packet Tracer, buatlah desain jaringan seperti di
bawah ini :

3
a. Ada berapa jaringankah yang ada pada diagram jaringan di atas ?
b. Perlukah router diberi konfigurasi routing agar jaringan-jaringan
yang terkoneksi langsung dengan dirinya bisa saling
berkomunikasi? Mengapa ?
c. Untuk masing-masing host (PC A, PC B , PC C , PC D), berikan
alokasi pengalamatan agar diagram jaringan di atas bisa saling
berkomunikasi. Dengan format :
PC A :
IP address : ....
Subnet mask : ...
Gateway :....
Network ID : ...
d. Berikan konfigurasi pengalamatan untuk masing-masing interface
fastethernet Router, dan pada Router1 dengan asumsi fastEthernet 0/0
terhubung ke switch, dan fastEthernet 0/1 terhubung langsung ke PC C.
Ethernet 0/0 terhubung ke Fastethernet 0/0 Router 1, FastEthernet 0/1
router 1 terhubung ke PC D.
Ip Address : ...
Subnet mask : ...
IP Address : ...

4
Subnet mask : ...
Router Ethernet 0/0
IP Address : ...
Subnet mask : ...
Router1 fastEthernet 0/0 :
Ip Address : ...
Subnet mask : ...
Router1 fastEthernet 0/1 :
IP Address : ...
Subnet mask : ...
e. Kabel jenis bagaimanakah yang digunakan untuk menghubungkan masing-
masing perangkat pada diagram jaringan di atas ? (Straight, Cross atau
Rollover)
PC A – Switch : ...
PC B - Switch : ...
Switch – Router : ...
Router – PC C : ...
Router – router 1 : ...
Router1 – PC D : ...
f. Perintah apakah yang dapat digunakan untuk mengecek koneksi antar host
yang ada ?

5
MODUL 2 INTERNET ADDRESS
Setelah mempelajari modul ini, mahasiswa diharapkan :
- mengerti struktur alamat IP dan DNS
- memahami dan mampu menerapkan class InetAddress
Host adalah perangkat yang terhubung dalam suatu jaringan komputer.
Host dapat berupa komputer, router, IP kamera, IP printer, akses poin, perangkat
genggam, dan lain sebagainya. Setiap host dalam jaringan internet atau TCP/IP
diidentifikasikan dengan alamat unik yang terdiri dari 4 byte Internet Protocol
(IP).
Setiap alamat IP dituliskan perbagiannya dipisahkan dengan titik, dengan
contoh format 192.168.1.10, di mana setiap bagian (byte) – nya menggunakan
integer positif antara 0 sampai 255. Sehingga ada sekitar 4 milyar alamat IP yang
bisa dibuat secara unik. Walaupun begitu, saat ini jumlah sedemikian itu tidaklah
cukup dibagi untuk perangkat-perangkat atau host yang ada dan terus diproduksi
saat ini.
Sehingga solusinya adalah penggunaan IPv6 yang terdiri dari 128 bit
alamat, yang artinya 4x lebih banyak dari IPv4 yang hanya terdiri dari 32 bit (4
byte) alamat. Saat ini, tidak semua ISP menerapkan IPv6 pada jaringan yang
dikelolanya.
2.1. IPv4
Setiap 32 bit alamat IP terdiri dari 2 komponen :
- alamat network
bagian yang digunakan untuk mengidentifikasi alamat jaringan tempat
host tersebut terkoneksi
- alamat host
bagian alamat yang secara unik bisa mengidentifikasikan host itu
sendiri

6
Ada tiga kelas dalam pengalamatan IP, yaitu kelas A, kelas B, dan kelas C.
Untuk IP kelas A, byte pertama selalu di awali dengan bit 0. Untuk kelas B, byte
pertama selalu di awali dengan bit 10, dan untuk kelas C, byte pertamanya selalu
diawali dengan bit 110.
2.2. DNS
Alamat IP yang berbentuk numerik dapat pula dipetakan dalam bentuk
nama untuk kemudahan pemakaian oleh user, seperti www.google.com,
mail.yahoo.com, dan lain sebagainya.
DNS (Domain Name Server) lah yang bertugas untuk memetakan, dan
mentranslasikan antara alamat IP dengan nama host, dan juga sebaliknya dalam
rangka komunikasi yang dilakukan antara host-host yang ada pada jaringan. DNS
merupakan sebuah sistem terdistribusi.
2.3. Alamat IP dan JAVA
Java memiliki klas untuk mendefinisikan alamat IP, yaitu class
java.net.InetAddress. Kelas ini memiliki tiga fungsi :
a. mengenkapsulasi alamat
b. melakukan name-lookup (mengkonversi nama host ke alamat
IP)

7
c. melakukan reverse-lookup (mengkonversi alamat IP ke nama
host
Objek dari class tersebut tidaklah dibuat dengan memanggil konstruktor
classnya. Tidak ada konstuktor dari class InetAddress. Melainkan dengan
memanggil method static dari class ini. Yaitu :
- public static InetAddress getByName(String
host) throws UnknownHostException
- public static InetAddress[ ]
getAllByName(String host) throws UnknownHostException
- public static InetAddress getLocalHost() throws
UnknownHostException
Setiap pembuatan objek dengan menggunakan method static di atas
membutuhkan pengecekan dengan DNS. Pada java 1.4 ditambahkan method static
untuk pembuatan objek dari class InetAddress yang tidak membutuhkan
pengecekan dengan DNS lokal. Yaitu dengan menggunakan method :
- public static InetAddress getByAddress(byte[ ]
address) throws UnknownHostException
- public static InetAddress getByAddress(String
hostName, byte[] address) throws UnknownHostException
Selain method untuk menginstansi objek, class InetAddress memiliki
method getter untuk memanggil nama host dalam bentuk String dan alamat IP
dalam bentuk String atau array byte.
• public String getHostName()
• public byte[ ] getAddress()
• public String getHostAddress()
2.4. Penggunaan InetAddress
Contoh penggunaan class InetAddress pada komputer yang terkoneksi
dengan jaringan Internet adalah sebagai berikut :

8
import java.net.InetAddress;
import java.net.UnknownHostExcepion;
public static void main(String[] args)
{
try {
InetAddress inet1 =
InetAddress.getByName("psmi.poltek-
malang.ac.id");
System.out.println(
"HostAddress=" + inet1.getHostAddress());
InetAddress inet2 =
InetAddress.getByName("192.168.134.134");
System.out.println("HostName=" + inet2.getHostName());
if (inet1.equals(inet2))
System.out.println("Alamat sama !");
else System.out.println (“Alamat tidak sama!”);
}
catch (UnknownHostException uhe) {
uhe.printStackTrace();
}
}
Program di atas membuat 2 objek InetAddress yaitu inet1 dan inet2. inet1
membuat objek InetAddress dengan memanggil method static dengan parameter
inputan berupa String nama host yaitu psmi.poltek-malang.ac.id. Sedangkan inet 2
dibuat objeknya dengan menggunakan method static yang parameter inputannya
adalah alamat IP, yaitu 192.168.134.134. Lalu dilakukan proses pembandingan
objek inet1 dengan inet2, apakah inet1 dan inet2 merujuk ke host yang sama atau
tidak. Hasil dari pembandingan kedua objek akan ditampilkan di console melalui
System.out.
2.5. Praktikum Modul 2
1. Coba tuliskan dan kerjakan kode di atas dan laporkan hasil keluaran aplikasi
tersebut.
2. Buatlah aplikasi yang menggunakan objek InetAddress di mana anda bisa
memasukkan nama host, lalu output yang dikeluarkan adalah alamat IP dari
nama host yang diinputkan.

9
3. Buatlah aplikasi yang menggunakan objek InetAddress di mana anda bisa
memasukkan ip address, lalu aplikasi akan mengeluarkan output nama host
dari IP yang diinputkan.

10
MODUL 3 STREAM
Setelah mempelajari modul 3 ini, mahasiswa diharapkan :
- mampu memahami konsep stream
- mampu menerapkan class stream
Komunikasi pada jaringan, dengan file, atau antar aplikasi
direpresentasikan dengan Stream oleh JAVA. Komunikasi berbasis Stream adalah
inti dari hampir semua komunikasi aplikasi yang dikembangkan menggunakan
JAVA. Konsep stream merupakan dasar yang penting dalam mengembangkan
aplikasi jaringan.
3.1. Review Stream
Komunikasi pada level byte, direpresentasikan oleh JAVA menggunakan
stream, sebagai wadah tempat informasi dikirim ataupun tempat informasi
diterima. Stream dapat dianalogikan dengan pipa air, yang apabila terpasan
dengan baik, air (dalam hal ini informasi atau data) dapat mengalir dari suatu
tempat ke tempat lain.
Dalam membangun sebuah aplikasi, kita harus dapat memilih jenis class
stream yang tepat untuk aplikasi kita. Stream dapat digabungkan bersama-sama
untuk mendapatkan kemudahan pengolahan informasi.
Ada 2 macam kategori besar Stream :
- input stream : dimana informasi dapat kita baca / ambil

11
- output stream : dimana informasi dapat kita tulis / kirim
3.2. Input Stream
Paket Input Stream terletak pada java.io.InputStream. Merupakan stream
dimana kita bisa membaca aliran informasi dari suatu sumber.
Ada 6 macam input stream yang bisa kita gunakan dari paket tersebut.
Saat input stream dibuat, objeknya akan membaca informasi dari sumber
informasi.
Low-level Input Stream Fungsi
byteArrayInputStream Membaca data byte dari array di
memory
FileInputStream membaca data byte dari sebuah
file pada sistem file lokal
PipedInputStream Membaca data byte dari pipe
thread
StringBufferInputStream Membaca data byte dari sebuah
string

12
SequenceInputStream Membaca data byte dari stream
input lain
System.in Membaca data byte dari konsol
user
Kelas abstrak InputStream memiliki method-method umum yang
diwariskan pada semua class turunannya, yang mana bersifat public. Method-
method tersebut adalah :
– int available ( ) throws java.io.IOException : untuk mengetahui
jumlah byte data yang saat ini tersedia untuk dibaca.
– void close ( ) throws java.io.IOException : menutup input stream
dan melepaskan sumber daya yang terkait dengan input stream
tersebut (contoh : file yang menjadi sumber input stream)
– void mark(int readLimit) : mencatat posisi input stram saat ini,
agar nanti bisa kembali ke titik yang dicatat dengan memanggil
method InputStream.reset() . Tidak semua input stream
mendukung method ini.
– boolean markSupported ( ) : mengembalikan nilai “true” apabila
input stream mendukung mark() dan reset().
– int read( ) throws java.io.IOException : mengambil byte data
berikutnya dari stream. Subkelas dari InputStream biasanya
menuliskan ulang method ini untuk menyesuaikan fungsinya
(seperti untuk membaca dari string spt pada
StringBufferInputStream, atau untuk membaca dari file seperti
pada FileInputStream). Input stream akan mengeblok penggunaan
I/O, dan akan memblok seterusnya hingga ada byte data berikutnya
untuk dibaca. Apabila akhir dari stream tercapai, nilai -1 akan
dimunculkan.
– int read(byte[ ] byteArray) throws java.io.IOException :
membaca serangkaian byte dan menempatkannya pada array byte
yang ditunjuk dalam paramete input, dengan berulang-ulang

13
memanggil methode read() hingga array byte tersebut penuh terisi
atau tidak ada lagi data yang tersedia untuk di baca. Method ini
akan mengembalikan nilai integer jumlah byte data yang dibaca
secara sukses, atau -1 apabila akhir stream telah tercapai.
– int read(byte [ ] byteArray, int offset, int length) throws
java.io.IOException, java.lang.IndexOutOfBoundsException
– void reset( ) throws java.io.IOException : mengembalikan posisi
stream ke posisi yang telah ditandai oleh method mark().
– long skip(long amount) throws java.io.IOException : membaca
data byte, tapi diabaikan selama sejumlah nilai yang diinputkan
dalam parameter (long amount). Data yang dibaca tidak disimpan,
tetapi proses pembacaan terus mengalir maju.
3.3. Penggunaan Input Stream
Contoh penggunaan kelas turunan InputStream untuk menampilkan isi dari
sebuah file dapat dilihat pada kode di bawah ini. Di mana file dimasukkan pada
parameter awal pemanggilan program ini (nama file dimasukkan sebagai
argumen).
import java.io.*;
public class FileInputStreamDemo
{
public static void main(String args[])
{
if (args.length != 1)
{
System.err.println ("Syntax - FileInputStreamDemo
file");
return;
}
try
{
// Membuat input stream yang membaca dr file
InputStream fileInput = new FileInputStream ( args[0]
);
int data = fileInput.read(); // Baca byte ke 1
while (data != -1) // ulangi : hingga end of file
(EOF) dicapai
{
System.out.write ( data ); // menampilkan byte
data ke console
data = fileInput.read(); // baca byte berikutnya
}

14
fileInput.close(); // Close the file
}
catch (IOException ioe)
{
System.err.println ("I/O error - " + ioe);
}
}}
3.4. Output Stream
Paket OutputSteam terletak pada java.io.OutputStream. Output stream
merupakan stream dimana kita bisa menuliskan infomasi untuk dikirim ke sesuatu
penerima informasi.
Turunan output stream yang bisa langsung kita gunakan ada 6 kelas, yang
memiliki fungsi masing-masing, seperti menuliskan string , menuliskan data ke
file atau ke pipa komunikasi. Output stream merupakan produsen informasi, dia
membuat byte dari informasi dan mengirimkannya ke tempat lain. Data
dikomunikasikan secara sekuensial, data byte yang pertama masuk stream akan
pertama kali keluar pula.
Low-Level Output Stream Fungsi
ByteArrayOutputStream Menuliskan data byte ke sebuah
array byte

15
FileOutputStream Menuliskan data byte ke sebuah
file lokal
PipedOutputStream Menuliskan data byte ke pipa
komunikasi
StringBufferOutputStream Menuliskan byte ke sebuah string
buffer
System.err Menuliskan data byte ke stream
error pada konsol pengguna
System.out Menuliskan data byte ke konsol
pengguna
Method-method yang dimiliki oleh output stream antara lain adalah :
– Void close( ) : menutup output stream, dan memberitahu ujung
stream satunya (penerima) bahwa stream telah berakhir.
– Void flush( ) : melakukan “flushing” data yang belum terkirim ke
sisi penerima dari output stream. Untuk meningkatkan performasi
aplikasi, sering kali stream diberi buffer, sehingga data-data
disimpan terlebih dahulu sebelum dikirim. Method ini cukup
penting bagi subkelas output stream yang digunakan pada operasi
jaringan, dimana ‘flushing’ data selalu terjadi setelah terjadi
operasi request atau response dikirimkan sehingga host lawan
komunikasi tidak menunggu-nunggu data.
– Void write(int byte) : menuliskan byte yang diinputkan pada
parameter method ini. Merupakan method abstrak yang dioverride
oleh subklas-subklas turunan output stream.
– Void write(byte[ ] byteArray) : menuliskan isi dari array byte
yang menjadi parameter method ini.
– Void write(byte[ ] byteArray, int offset, int length)

16
3.5. Penggunaan Output Stream
Di sini diberikan contoh penggunaan output stream pada sebuah kode
aplikasi di mana aplikasi ini akan mengopy sebuah file dengan cara membaca isi
dari suatu file dan menuliskannya ke file lain. Operasi dilakukan byte per byte.
import java.io.*;
public class FileOutputStreamDemo
{
{
if (args.length != 2) // Two parameters
are required, the source and destination
{
System.err.println ("Syntax -
FileOutputStreamDemo src dest");
return;
}
String source = args[0];
String destination = args[1];
try
{
// Open source file for input
InputStream input = new FileInputStream(
source );
System.out.println ("Opened " + source + "
for reading.");
OutputStream output = new FileOutputStream
( destination ); // Ouput output file for output
System.out.println ("Opened " +
destination + " for writing.");
int data = input.read();
while ( data != -1)
{
// Write byte of data to our file
output.write (data);
// Read next byte
data=input.read();
}
// Close both streams
input.close();
output.close();
System.out.println ("I/O streams closed");
}
{
System.err.println ("I/O error - " + ioe);
}
}
}

17
1. Tuliskan kode penggunaan Input Stream dan Output Stream yang ada
pada sub bab 3.3 dan 3.5.
2. Buat modifikasi pada kode Input Stream di subbab 3.3, sehingga
aplikasi tidak lagi membutuhkan argumen dalam eksekusinya, melainkan
memunculkan dialog untuk membuka file yang ada pada komputer kita.
3. Buat modifikasi pada kode Output Stream di subbab 3.5 agar nama file
input dan file output (hasil copy) ditampilkan dalam bentuk dialog.

18
MODUL 4 FILTER STREAM
- dapat memahami fungsi dan mengetahui kelebihan dari filter stream
- dapat menerapkannya dalam aplikasi
Karena stream dasar hanya menerapkan mekanisme pembacaan byte dari
informas atau data secara sederhana, maka fleksibilitasnya terbatas. Pembacaan
byte dari data tidaklah simpel, arti dari byte bisa bervariasi tergantung jenis
datanya. Teks contohnya, merupakan rangkaian dari karakter karakter, dan contoh
lain adalah deretan angka-angka yang mana masing-masing karakter dan angka
bisa dibentuk lebih dari satu byte data tunggal. Komunikasi pada level byte juga
bisa sangat tidak efisien, dan pemberian buffer juga dapat meningkatkan
performasi dari sistem. Permasalahan-permasalahan tersebut bisa diatasi dengan
penggunaan filter stream.
4.1. Dasar Filter Stream
Filter Stream menambahkan fungsionalitas pada stream-stream dasar,
dengan memproses data sedemikian rupa (seperti penambahan buffer untuk
meningkatkan kinerja) atau menambahkan method-method untuk mengakses data
dalam cara yang berbeda ( seperti membaca data per baris, dibandingkan
pembacaan data standar yang byte per byte).
Filter Stream dibagi pula menjadi 2 kategori : filter input stream dan filter
output stream. Setiap filter stream disambungkan ke input stream atau output
stream dalam penggunaannya. Menyambungkan filter stream sangat sederhana,
buat objek filter streamnya ( dengan memasukkan stream yang sudah ada ke
parameter input method pembentuknya), dan selanjutnya proses pembacaan atau
penulisan data cukup melalui filter stream tersebut.
Contoh apabila kita ingin menggunakan salah satu filter output stream
yang bertipe PrintStream (digunakan untuk mencetak teks ke subclass dari Output
Stream) pada stream output yang menuliskan data ke file. Kode di bawah ini dapat
digunakan :

19
FileOutputStream fout = new FileOutputStream ( somefile );
PrintStream pout = new PrintStream (fout);
pout.println ("hello world");
Dapat dilihat bahwa penulisan atau pembacaan yang tadinya dilakukan
pada stream dasar, apabila telah dihubungkan dengan sebuah filter stream, maka
penulisan atau pembacaan data dilakukan pada filter streamnya.
4.2. Filter Input Stream
Beberapa filter input stream yang umum dan terdapat pada semua versi
Java adalah sebagai berikut :
Filter Input Stream Keguanaan
BufferedInputStream Memberi buffer pengaksesan data, untuk
meningkatkan efisiensi dan kinerja
DataInputStream Membaca tipe data primitif (int, float, double etc)
LineNumberInputStream Menjaga hitungan jumlah baris dari data yang
sedang dibaca berdasarkan karakter-karakter yang
memiliki interpretasi end-of-line
PushBackInputStream Filter yang memungkinkan pembacaan data dan
mengembalikannya lagi ke dalam stream untuk
dibaca lagi.
4.2.1. Buffered Input Stream
Kegunaan dari memberikan buffer pada I/O adalah menambah performasi
kerja. Dibandingkan dengan pembacaan data byte per byte, sejumlah besar byte
dibaca bersamaan pada saat method read()class ini dieksekusi. Hal ini
meningkatkan kecepatan waktu akses dari sumber data dan mengurangi jumlah
blok aplikasi ke input yang menjadi sumber data.
Konstruktor buffered input stream :
1. BufferedInputStream(inputStream input) : membuat stream dengan
buffer yang akan membaca dari input stream yang dijadikan parameter

20
2. BufferedInputStream(InputStream input, int bufferSize) : membuat
stream dengan buffer sesuai ukuran yang ditentukan, yang akan membaca
dari input stream yang dijadikan parameter.
Method-method :
Tidak ada method tambahan. Hanya memodifikasi method read(), dan
mendukung pemakaian method mark() dan reset().
4.2.2. Data Input Stream
Penulisan dan pembacaan data bertipe primitif seperti angka dan karakter
sangat sering dijumpai dalam pemrograman. Informasi / data seperti itu tidak
mudah direpresentasikan dalam byte-byte. Dengan filter stream ini, pengembang
aplikasi tidak perlu susah-susah dalam mengkonversi data byte ke data primitif.
Tetapi cukup dengan memanfaatkan method dari kelas filter stream ini, yang
otomatis melakukan mentranlasi data.
• Konstruktor :
DataInputStream( InputStream input)
• Method-method :
Boolean readBoolean( )
Byte readByte( )
char readChar( )
double readDouble( )
float readFloat( )
void readFully(byte[ ] byteArray)
void readFully(byte[] byteArray, int offset, int length)
float readInt( )
string readLine( )
long readLong( )
short readShort( )
int readUnsignedByte( )
int readUnsignedShort( )
String readUTF( )
Static String readUTF(DataInputStream input)

21
int skipBytes(int number).
4.2.3. LineNumber Input Stream
Memberikan fungsionalitas yang berguna yaitu memantau jumlah baris
data yang telah dibaca dari input stream.
• Konstruktor :
LineNumberInputStream(InputStream input) – membuat sebuah line
number stream, yang membaca dari input stream input
• Methods
int getLineNumber( ) – mengembalikan nilai jumlah baris yang telah
dibaca dari input stream yang bersangkutan
void setLineNumber(int number) – mengubah nilai counter nomor baris
menjadi nilai yang ditentukan dalam number
4.2.4.PushBackInputStream
Memiliki kemampuan untuk membaca sebuah byte data tunggal, lalu
dikembalikan lagi ke dalam input stream untuk dibaca kemudian. Untuk itu dia
mempunyai sebuah buffer internal. Kelas ini berguna bila programmer ingin
‘mengintip’ data apa yang akan dibaca selanjutnya dari rangkaian byte data pada
input stream.
• Konstruktor
– PushBackInputStream(InputStream input)
– PushBackInputStream(InputStream input, int bufferSize) –
membuat PushBackInputStream yang akan membaca dari input
stream dan menggunakan buffer dengan besar yang ditentukan
• Method-method
– void unread(byte[] byteArray) – mengembalikan isi dari array
byteArray.
– void unread(byte[] byteArray, int offset, int length)
– void unread(int byte) – mengembalikan byte yang diinputkan ke
awal dari buffer

22
4.3. Filter Output Stream
Beberapa filter output stream yang umum dan terdapat pada semua versi
Java adalah sebagai berikut :
Filter Output Stream Kegunaan
BufferedOutputStream Menyediakan buffer untuk menuliskan data
DataOutputStream Menuliskan tipe data primitif seperti bytes dan angka.
PrintStream Menyediakan method tambahan untuk menuliskan baris teks
atau tipe data lain sebagai sebuah teks
4.3.1. Buffered Output Stream
Memiliki buffer internal yang dikelolanya, dimana apabila buffer tersebut
penuh, maka isi dari buffer akan dikosongkan untuk dimasukkan ke output stream
dimana dia terhubung.
• Konstruktor
– BufferedOutputStream(OutputStream output) – membuat buffer
untuk menuliskan data pada output stream yang ditunjuk (default
buffer nya sebesar 512 bytes)
– BufferedOutputStream(OutputStream output, int bufferSize) –
membuat objek bufferedOutputStream yang terhubung pada output
stream yang ditunjuk dengan ukuran buffer yang ditentukan.
• Methods
Tidak memiliki method tambahan selain bawaan dari kelas Output Stream.
4.3.2. Data Output Stream
Didesain untuk bekerja dengan tipe data primitif seperti angka-angka atau
bytes.
• Konstruktor
– DataOutputStream(OutputStream output) – membuat objek data
output stream yang terhubung dengan output stream yang ditunjuk
• Method

23
– int size( ) – mengembalikan jumlah byte yang telah dikirimkan
pada data output stream
– void writeBoolean(boolean value) – menuliskan nilai boolean yang
ditentukan dalam bentuk byte
– void writeByte(int byte) – menuliskan byte yang ditentukan pada
output stream
– void writeBytes(String string) – menuliskan seluruh isi string ke
output stream sebagai byte, satu per satu byte
– void writeChar(int char) – menuliskan karakter ke output stream
sebagai nilai byte (2 byte per karakter)
– void writeChars(String string) – menuliskan seluruh isi string ke
output stream sebagai byte, masing-masing karakter diwakili 2
byte
– void writeDouble(double doubleValue) – mengkonversi nilai data
double yang dimasukkan menjadi nilai long, lalu mengkonversinya
lagi ke dalam bentuk 8-byte data.
– void writeFloat(float floatValue) – mengkonversi nilai data float
yang dimasukkan menjadi nilai int, lalu mengkonversinya lagi ke
dalam bentuk 4-byte data.
– void writeInt(int intValue) – menuliskan nilai int sebagai 4-byte
data
– void writeLong(int intValue) – menuliskan nilai long sebagai 8-
byte data
– void writeShort(int intValue) – menuliskan nilai short sebagai 2-
byte data
– void writeUTF(String string) – menuliskan isi string menggunakan
UTF-8 encoding
4.3.3. PrintStream
Kelas ini menyediakan cara yang mudah untuk menuliskan tipe data
primitif sebagai bentuk teks menggunakan method print(..) atau println (..) untuk
menuliskannya dengan memberikan line separator.
• Konstuktor :

24
- PrintStream(OutputStream output)
- PrintStream(OutputStream output, boolean flush) – membuat print
stream dimana bila nilai boolean diset ‘true’, maka buffer yang
dimilikinya bisa otomatis melakukan ‘flushing’ data
- Method
o boolean checkError( ) – automatically flushed the output
stream and checks to see if an error has occurred
o void print(boolean value) – print a boolean value
o void print(char character) – prints a character value
o void print(char [] charArray) – prints an array of characters
o void print(double doubleValue) – prints a double value
o void print(float floatValue) – prints a float value
o void print(int intValue) – prints an int value
o void print(long longValue) – prints a long value
o void print(Object obj) – prints the value of the specified
object’s toString( ) method
o void print(String string) – prints a string’s contents
o void println( ) – sends a line separator (n)
o void println(char character) – prints a character value followed
by a println()
o void println(char[] charArray) – prints an array of characters
followed by println()
o void println(double doubleValue) – prints a double value
followed by println() Methods
o void println(float floatValue) – prints a float value followed by
println()
o void println(int intValue) – prints an int value followed by
println()
o void println(long longValue) – prints a long value followed by
println()
o void println(Object obj) – prints the value of the specified
object’s toString( ) method followed by println()

25
o void println(String string) – prints a string followed by a line
separator
o protected void SetError( ) – modifies the error flag to a value
of “true”
1. Tambahkan filter input stream pada aplikasi yang telah Anda
kerjakan pada praktikum Modul 4 no 2. Yaitu filter stream :
BufferedInputStream pada FileInputStream yang Anda gunakan
untuk membaca dari file. Bandingkan kinerja aplikasi setelah
modifikasi (catat waktunya). Hitung waktunya untuk membuka file
dengan ukuran di atas 1 Megabyte.
2. Tambahkan filter stream pada aplikasi yang telah Anda kerjakan
pada praktikum Modul 3 no 3. Yaitu berikan BufferedInputStream
dan BufferedOutputStream pada saat pembacaan dan penulisan
file. Bandingkan waktunya.

26
MODUL 5 OBJECT PERSISTENCE DAN OBJECT
SERIALIZATION
- mampu memahami konsep object persistence
- mampu menerapkan object persistence dengan menggunakan object
serialization pada aplikasi
5.1. Object Persistence
Object persistence adalah kemampuan sebuah object untuk tetap hidup
dalam sebuah sistem, tidak terpengaruh waktu dan ruang (space), bahkan apabila
aplikasi pembuat object tersebut telah dihentikan atau komputer dimatikan. Untuk
itu objek yang diinginkan supaya persistence harus disimpan secara utuh.
Penyimpanan objek secara utuh melibatkan penyimpanan struktur data
yang dimiliki oleh objek tersebut, nilai-nilai atribut yang dimilikinya, dan
pemetaan terhadap referensi ke objek lain apabila ada, sekaligus objek yang
direferensikannya. Proses itu merupakan sebuah proses yang kompleks dan rumit.
5.2. Object Serialization
Object Serialization adalah teknik yang bisa mewujudkan object
persistence. Teknik ini mengontrol bagaimana data yang berisi informasi-
informasi nilai dan status sebuah objek (termasuk nilai atribut-atributnya, hak
akses tiap atributnya baik itu public, protected atau private, dan lain sebagainya)
dituliskan dan disimpan dalam bentuk rangkaian byte-byte data.
Objek yang diserialisasi nantinya dapat dikirimkan lewat jaringan, atau
disimpan dalam file, untuk kemudian dapat diakses di lain waktu sesuai
kebutuhan. Hal tersebut memungkinkan pindahnya suatu objek dari satu JVM ke
JVM lain, entah dalam satu mesin atau mesin yang berbeda.
5.3. Cara Kerja Object Serialization
Setiap objek yang mengimplementasikan interface
java.IO.Serializable dapat diserialisasikan hanya dengan beberapa baris kode.

27
Mengimplementasikannya sama dengan cara menerapkan interface-interface yang
lain pada JAVA, yaitu dengan menambahkan keyword implement pada
deklarasi class yang diinginkan dan menggunakan konstrukto tanpa argumen
tambahan. Interface ini menunjukkan bahwa class yang kita buat dapat
mendukung serialisasi objek. Tidak ada method tambahan yang perlu
diimplementasikan pada class tersebut.
Contoh deklarasi class yang menerapkan interface tersebut :
Public class SomeClass extends SomeOtherClass implements
java.io.Serializable {
public class SomeClass()
}
}
………
}
5.4. Permasalahan pada Penggunaan Serialisasi
Terdapat beberapa masalah pada awal munculnya metode serialisasi.
Contohnya apabila objek yang ingin kita serialisasi memiliki informasi rahasia /
sensitif yang tidak patut kita ikutkan dalam serialisasi untuk disimpan dalam
bentuk file ke media penyimpanan atau dikirimkan ke jaringan.
Apabila ada kasus seperti ini : kelas yang ingin kita serialisasi memiliki
atribut password dimana bisa secara mudah dibaca apabila diserialisasikan. Untuk
mencegah hal-hal tersebut, maka diciptakanlah keyword trancient. Keyword
tersebut bisa diberikan pada deklarasi anggota / atribut dari kelas yang tidak kita
inginkan untuk diikutkan pada proses serialisasi.
Contoh penggunaan trancient pada deklarasi kelas :
Public class UserAccount implements java.io.Serializable {
protected String username;
protected transient String password;
public UserAccount( )
{
….
}
}

28
5.5. Membaca dan Menuliskan Object pada Stream
Point utama dari serialisasi adalah bagaimana kita menuliskan objek ke
stream dan bagaimana cara mendapatkannya kembali untuk bisa digunakan. Hal
tersebut bisa dilakukan dengan menggunakan kelas
java.io.ObjectOutputStream dan java.io.ObjectInputStream .
5.5.1. Kelas ObjectInputStream
Digunakan untuk mengambil objek yang terserialisasi dari byte stream
untuk dapat direkonstruksi ulang menjadi bentuk asli objek tersebut.
Kelas ObjectInputStream mengimplementasikan interface ObjectInput
yang merupakan turunan dari interface DataInput. Artinya kelas ini menyediakan
banyak method untuk beroperasi dengan banyak tipe data seperti halnya pada
kelas DataInputStream.
• Konstruktor
• Protected ObjectInputStream () – merupakan
konstruktor default untuk turunan dari ObjectInputStream
• ObjectInputStream( InputStream input) – membuat
object input stream yang terkoneksi dengan input stream
yang ditunjuk, dapat digunakan untuk mengembalikan
objek yang terserialisasi
• Method - method
• Public final Object readObject( ) – membaca objek
yang terserialisasi dari stream dan merekonstruksinya
kembali
5.5.2. Kelas ObjectOutputStream
Kelas ini digunakan untuk menserialisasi objek dan dikirimkan melalui
byte stream dalam rangka object persistence. Bisa dihubungkan ke semua output
stream seperti file output dan networking stream.
• Konstuktor
• Protected ObjectOutputStream ( ) – konstruktor
default

29
• ObjectOutputStream (OutputStream output) –
membuat objek output stream yang mampu menserialisasi
objek dan dikirim melalui stream output yang ditunjuk
• Method-method
• Void writeObject (Object object) – menuliskan
objek yang dimaksud ke output stream melalui proses
serialisasi.
5.6. Penggunaan Object Serialization
Contoh penggunaan object serialization dapat dilihat pada kode aplikasi di
awah ini, di mana aplikasi membuat objek yang dapat disimpan dan dipanggil
kembali lengkap dengan informasi dan status terakhir (nilai-nilai atribut yang
dimiliki) objek tersebut.
import java.io.*;
import java.util.*;
// Chapter 4, Listing 5
public class SerializationDemo
{
{
try
{
Vector list;
// Create a buffered reader for easy input
BufferedReader reader = new BufferedReader
( new InputStreamReader ( System.in ) );
System.out.println ("Checking for previous
serialized list");
// Check to see if serialized list exists
try
{
FileInputStream fin = new FileInputStream
("list.out");
// Connect an object input stream to the

30
// list
ObjectInputStream oin = new ObjectInputStream
( fin );
try
{
// Read the vector back from the list
Object obj = oin.readObject();
// Cast back to a vector
list = (Vector) obj;
}
catch (ClassCastException cce)
{
// Can't read it, create a blank one
list = new Vector();
}
catch (ClassNotFoundException cnfe)
{
// Can't read it, create a blank one
}
fin.close();
}
catch (FileNotFoundException fnfe)
{
// Create a blank vector
}
// Repeat indefinitely
for (;;)
{
// Now, display menu
System.out.println ("Menu :-");
System.out.println ("1.. Add item");
System.out.println ("2.. Delete item");
System.out.println ("3.. List items");
System.out.println ("4.. Save and quit");
System.out.print ("Choice : ");
// Read choice
String response = reader.readLine();

31
// Convert to an int
int choice = Integer.parseInt (response);
switch (choice)
{
case 1 :
// Add the item to list
System.out.print
("Enter item : ");
String item = reader.readLine();
list.addElement(item);
break;
case 2 :
// Delete the item from list
System.out.print
("Enter item : ");
String deadItem =
reader.readLine();
list.removeElement(deadItem);
break;
case 3 :
// List the elements of the list
for (Enumeration e =
list.elements();
e.hasMoreElements();)
{
System.out.println
(e.nextElement());
}
break;
case 4 :
// Save list and terminate
System.out.println
("Saving list");
FileOutputStream fout =
new FileOutputStream
( "list.out" );
// Construct an object output stream
ObjectOutputStream oout = new

32
ObjectOutputStream ( fout );
// Write the object to the stream
oout.writeObject (list);
fout.close();
System.exit(0);
}
}
}
{
System.err.println ("I/O error");
}
}
}
1. Tuliskan kembali kode aplikasi di atas dan jalankan. Laporkan apa
yang terjadi pada hasil eksekusi aplikasi.
2. Jika pada aplikasi di atas, objek yang diserialisasi adalah objek
bertipe list; modifikasilah dengan membuat class baru beserta
atribut-atributnya untuk diserialisasikan ke dalam file.

33
MODUL 6 PEMROGRAMAN USER DATAGAM
PROTOCOL (UDP)
- mampu memahami User Datagram Protocol (UDP)
- mampu menerapkan komunikasi UDP pada aplikasi menggunakan
JAVA
6.1. Protokol UDP
UDP merupakan protokol lapisan Transport yang sederhana, bersifat
connectionless, yang secara detil dijelaskan pada artikel RFC 768. Protokol ini
memiliki keunggulan sedikitnya informasi tambahan pada header data yang
dibutuhkan untuk mengirimkan data, atau disebut dengan overhead rendah.
Pecahan/bagian data pada protokol ini disebut dengan datagram.
Protokol ini juga disebut protokol yang tidak handal atau unreliable.
Artinya saat kita mengirim data UDP (datagram), kita tidak tahu apakah datagram
tersebut sampai ke tujuan atau tidak, ataupun jika sampai, datagram-datagram
diterima secara urut atau tidak. Namun bagaimanapun, protokol ini bisa mengirim
data dengan cepat karena rendahnya overhead yang dimilikinya, tidak seperti pada
protokol TCP yang overhead datanya tinggi.
Informasi yang ada pada header segmen UDP hanya berisi nomor port
aplikasi pengirim dan nomor port aplikasi penerima/tujuan.
Aplikasi-aplikasi yang menggunakan protokol UDP antara lain adalah :
 DNS
 Video Streaming
 Voice over IP (VoIP)
Soket UDP bisa menerima data dari lebih dari satu mesin atau host.
6.2. UDP pada JAVA
JAVA mendukung pemrograman komunikasi protokol UDP dengan
menyediakan 2 kelas :
java.net.DatagramSocket
java.net.DatagramPacket

34
6.2.1. DatagramPacket
Kelas DatagramPacket mewakili paket data yang ingin ditransmisikan
menggunakan protokol UDP. Kelas ini terdiri dari array bertipe byte yang menjadi
tempat data yang ingin dikirim, atau tempat data yang akan diterima. Kelas ini
juga memiliki alamat IP dan alamat port.
Dua alasan kita membutuhkan objek DatagramPacket :
1. Untuk mengirim data ke komputer lain menggunakan UDP
2. Untuk menerima data dari komputer lain menggunakan UDP
Konstruktor yang bisa kita gunakan bergantung dari alasan untuk apa
objek DatagramPacket tersebut kita buat tadi. Untuk mengirim datagram, maka
konstruktornya adalah :
- public DatagramPacket(byte[] data, int
length, InetAddress remote, int port)
- public DatagramPacket(byte[] data, int
offset, int length, InetAddress remote, int
port)
contoh :

35
InetAddress addr = InetAddress.getByName("192.168.0.1");
DatagramPacket packet = new DatagramPacket ( new byte[128],
128, addr, 2000);
Sedangkan konstruktor untuk menerima datagram adalah :
- public DatagramPacket(byte[] buffer, int
length)
- public DatagramPacket(byte[] buffer, int
offset, int length)
contoh :
DatagramPacket packet = new DatagramPacket(new byte[256], 256);
Sedangkan method-method yang dimiliki class DatagramPacket antara
lain :
 InetAddress getAddress()— mengembalikan alamat IP asal
datagram, atau IP tujuan datagam
 byte[] getData()— mengembalikan isi dari DatagramPacket,
yaitu array byte.
 int getLength()— mengembalikan nilai panjangnya isi data yang
ada pada DatagramPacket.
 int getPort()— mengembalikan nomor port asal datagram, atau
port tujuan datagam, tergantung jenis datagramnya
 void setAddress(InetAddress addr)— mengeset alamat
baru untuk DatagamPacket
 void setData(byte[] buffer)— memberikan buffer data
baru dalam bentuk array byte
 void setLength(int length)— mengeset panjang dari
DatagramPacket dengan nilai yang dimasukkan. Perlu diingat bahwa
panjangnya harus lebih kecil dari ukuran maksimum data buffer atau
IllegalArgumentException akan terjadi.
 void setPort(int port)— memberikan nilai port tujuan baru
bagi DatagramPacket.

36
6.2.2. DatagramSocket
Kelas ini digunakan untuk mengirim dan menerima DatagramPacket dari
atau ke jaringan.
Konstuktor :
• DatagramSocket(int port)
digunakan untuk menyatakan penggunaan suatu nomor port sebagai
"pintu" untuk menerima koneksi dari client.  untuk membuat server
datagram socket
• DatagramSocket(int port, InetAddress laddr)
membentuk koneksi dengan protokol UDP pada alamat IP lokal
tertentu dan pada nomor port tertentu.
• DatagramSocket()
Kelas ini membentuk koneksi dengan protokol UDP pada alamat IP
lokal host dengan penentuan nomor portnya secara random berdasar
tersedianya nomor port yang dapat digunakan.  untuk membuat
client datagram socket
Method-method :
• void close()— menutup socket dan melepaskannya dari port
lokal.
• void connect(InetAddress remote_addr int
remote_port)— membatasi akses menuju alamat tujuan dan port
komputer tujuan
• void disconnect()— memutuskan DatagramSocket.
• InetAddress getInetAddress()— mengembalikan alamat
komputer tujuan dimana socket terhubung, atau null apabila tidak ada
koneksi ke tujuan.
• int getPort()— mengembalikan alamat port komputer tujuan
jika socket terhubung, atau -1 apabila tidak ada koneksi
• InetAddress getLocalAddress()— mengembalikan alamat
lokal dimana soket terkoneksi

37
• int getLocalPort()— mengembalikan nilai alamat port di
mana soket terkoneksi
• int getReceiveBufferSize() throws
java.net.SocketException— mengembalikan nilai ukuran
maksimum buffer untuk paket UDP yang akan diterima
• int getSendBufferSize() throws
java.net.SocketException— mengembalikan nilai ukuran
maksimum buffer untuk paket UDP yang akan dikirim
• int getSoTimeout() throws
java.net.SocketException— mengembalikan nilai optional
timeout soket. Nilai ini digunakan untuk menentukan berapa milidetik
suatu operasi pembacaan akan memblok sebelum mengeluarkan pesan
error java.io.InterruptedIOException. Secara default, nilai ini akan
berisi 0, menandakan bahwa I/O yang terblok akan dapat digunakan..
• void receive(DatagramPacket packet) throws
java.io.IOException— membaca paket UDP dan menyimpan
isi paket tersebut. Atribut alamat dan port dari paket akan ditulis ulang
dengan alamat pengirim dan port pengirim, dan atribut panjang paket
akan berisi panjang paket asli yang mana bisa lebih kecil dari ukuran
array byte paket. Jika nilai atribut timeout tidak ditentukan
menggunakan metode DatagramSocket.setSoTimeout(int duration),
method ini akan memblok seterusnya. Jika sudah ditentukan, maka
error java.io.InterruptedIOException akan dikeluarkan apabila waktu
melebihi waktu timeout yang sudah ditentukan.
• void send(DatagramPacket packet) throws
java.io.IOException— mengirim paket UDP, yang
dimasukkan sebagai parameter.
• void setReceiveBufferSize(int length) throws
java.net. SocketException— mengeset ukuran maksimum
buffer yang digunakan untuk UDP packet yang diterima.

38
• void setSendBufferSize(int length) throws
java.net.SocketException— mengeset ukuran maksimum
buffer yang digunakan untuk UDP packet yang dikirim.
• void setSoTimeout(int duration) throws
java.net.SocketException— mengeset nilai option timeout
soket. Berupa jumlah milidetik yang diperbolehkan untuk melakukan
blok pada operasi pembacaan sebelum dinyatakan error
java.io.InterruptedIOException.
6.3. Mengirim Data UDP
Langkah-langkah untuk mengirim datagram UDP ke sebuah server UDP :
a. Mengkonversi data yang mau dikirim ke dalam bentuk array byte
b. Memasukkan array byte tadi, panjang data dalam array, dan
InetAddress serta nomor port tujuan ke dalam DatagramPacket
lewat konstruktornya
c. Buat DatagramSocket menggunakan konstruktornya (client
DatagramSocket) , dan memanggil method send() dengan
memasukkan DatagramPacket yang telah dibuat.
Contoh :
InetAddress ia = InetAddress.getByName(“localhost");
int Port = 19;
String s = "My second UDP Packet";
byte[] b = s.getBytes();
DatagramPacket dp = new DatagramPacket(b, b.length, ia,
Port);
DatagramSocket sender = new DatagramSocket();
sender.send(dp);
6.4. Menerima Data UDP
Langkah untuk menerima datagram UDP dari klien adalah :
a. Buatlah sebuah DatagramPacket kosong (DatagramPacket untuk
menerima data)

39
b. Buatlah objek DatagramSocket melalui konstruktornya
(DatagramSocket untuk server)
c. Lalu panggil method receive () dari datagramSocket dengan
memasukkan DatagramPacket kosong yang telah dibuat tadi untuk
menampung datagram yang datang.
d. Ambil datanya dalam bentuk array byte pada DatagramPacket yang
telah terisi. Lalu konversikan ke bentuk data yang diinginkan.
Contoh :
try {
byte buffer = new byte[65536];
DatagramPacket incoming = new DatagramPacket(buffer,
buffer.length);
DatagramSocket ds = new DatagramSocket(2134);
ds.receive(incoming);
byte[] data = incoming.getData();
String s = new String(data, 0, data.getLength());
System.out.println("Port " + incoming.getPort() + " on " +
incoming.getAddress() + " sent this message:");
System.out.println(s);
}catch (IOException e) {
System.err.println(e);}
1. Lengkapi potongan kode untuk menerima data (pada bagian 6.5)
dan potongan kode untuk mengirim data (pada bagian 6.4) menjadi
aplikasi yang dapat dieksekusi. Jalankan aplikasi yang menerima
data dan aplikasi yang mengirim data pada komputer yang berbeda.
(Sesuaikan objek InetAddressnya untuk masing-masing aplikasi).

40
2. Modifikasi aplikasi-apblikasi di atas, sehingga pada aplikasi yang
mengirim data, data yang dikirim dapat dimasukkan oleh user
lewat dialog.

41
MODUL 7 PEMROGRAMAN TRANSMISSION
CONTROL PROTOCOL (TCP)
- mampu memahami protokol TCP
- mampu menerapkan komunikasi TCP pada aplikasi menggunakan
JAVA
7.1. Protokol TCP
TCP merupakan protokol yang bersifat connection-oriented, dijelaskan
secara detil pada artikel RFC 793. TCP menggunakan overhead yang lebih besar
dibanding dengan UDP untuk mendukung fungsi-fungsi yang dimilikinya.
Fungsi-fungsi yang dimiliki TCP adalah urutan pengiriman data seperti pada saat
dikirim (same order delivery), pengiriman data yang handal (reliable delivery) dan
adanya pengaturan kecepatan aliran data (flow control). Setiap segmen TCP
memiliki 20 byte overhead dalam header segmen datanya, dimana segmen UDP
hanya membutuhkan overhead 8 byte pada header segmen datanya.
Informasi yang ada pada header segmen data TCP adalah nomor port
aplikasi pengirim & tujuan, nomor sekuen segmen untuk mengurutkan segmen,
informasi acknowledgment untuk konfirmasi data telah diterima tujuan (reliable
delivery), informasi yang dibutuhkan untuk flow control.
Aplikasi yang menggunakan protokol TCP adalah :
 Web Browser
 Email
 File Transfer
7.2. TCP pada Java
Pada Java, komunikasi TCP dilakukan dengan menggunakan socket. TCP
memulai pengiriman data dengan membentuk suatu koneksi antara komputer yang
akan berkomunikasi terlebih dahulu, diikuti transfer data, dan pemutusan koneksi.
Hal ini diakomodasi dengan socket. Operasi-operasi yang bisa dilakukan pada
socket adalah :

42
– Koneksi ke mesin remote
– Mengirim data
– Menerima data
– Mentutup koneksi
– Bind to a port
– Listen pada data yang masuk
– Menerima koneksi dari mesin remote pada port tertentu
Ada 2 kelas yang disediakan oleh JAVA yang dapat digunakan untuk
komunikasi TCP :
o java.net.Socket
o java.net.ServerSocket
Untuk membuat aplikasi klien yang akan melakukan koneksi ke servis
yang ada, kita harus menggunakan Socket. Sedangkan untuk membuat aplikasi
server yang mengikat suatu port tertentu dalam memberikan servis, kita
menggunakan ServerSocket.
7.3. Socket
Pembentukan koneksi dilakukan oleh konstruktor Socket. Setiap objek
Socket terasosiasi dengan hanya satu komputer lawan komunikasi (remote host).
Untuk membuat koneksi dengan komputer lain, maka harus dibuat objek Socket
yang lain.
Konstruktor :
• public Socket(String host, int port) throws
UnknownHostException,IOException
• public Socket(InetAddress address, int port)
throws IOException
• public Socket(String host, int port,
InetAddress localAddress, int localPort)throws
IOException
• public Socket(InetAddress address, int port,
InetAddress localAddress,int localPort) throws
IOException

43
Untuk melakukan pengiriman atau penerimaan data, dilakukan dengan
menggunakan input dan output stream. Method-method yang digunakan untuk
mendapatkan referensi input stream socket dan output stream socket adalah :
 public InputStream getInputStream() throws
IOException
 public OutputStream getOutputStream() throws
IOException
Setelah selesai melakukan komunikasi pengiriman data, kita harus
menutup socket. Metode untuk menutup socket adalah :
 public void close() throws IOException
Secara umum, prinsip atau langkah kerja penggunaan Socket dapat
dirangkum sebagai berikut :
1. Membentuk koneksi ke server, dengan membuat objek Socket dan
menentukan :
a. alamat IP server ( melalui objek InetAddress)
b. alamat port servis yang diinginkan
Socket sok = new Soket (InetAddress.getLocalHost(), 123);
2. Mengeset input dan output Stream
Scanner input = new Scanner(sok.getInputStream());
PrintWriter output = new
PrintWriter(sok.getOutputStream(),true);
3. Mengirim dan menerima data
a. Objek scanner pada klien akan menerima data yang dikirim
oleh objek PrintWriter yang ada pada server
b. Objek printwriter pada klien akan mengirimkan data yang
akan diterima objek Scanner pada server
4. Menutup koneksi (socket)
7.4. ServerSocket
Kelas ServerSocket bertindak sebagai soket yang ada pada server. Kelas
ini dibentuk dengan mengikat port tertentu yang ada pada komputer server. Lalu
selanjutnya menggunakan method accept() untuk siap menerima koneksi yang
datang dari klien.

44
Method accept() yang dipanggil dari ServerSocket akan mengembalikan
objek socket untuk melakukan koneksi dengan klien. Selama belum ada koneksi
dari klien, method ini akan memblok I/O kecuali telah diset waktu timeout-nya.
Konstruktor :
 public ServerSocket(int port) throws
IOException
 public ServerSocket(int port, int backlog)
throws IOException
 public ServerSocket(int port, int backlog,
InetAddress bindAddr)throws IOException
Method :
 public Socket accept() throws IOException
 public void close() throws IOException
Secara umum, prinsip atau langkah kerja penggunaan ServerSocket adalah
sebagai berikut :
1. Membuat objek ServerSocket
ServerSocket servsok = new ServerSocket(123);
2. Membuat server ke posisi/status menunggu koneksi
Socket link = servsok.accept();
3. Mengeset input dan output stream
Scanner input = new Scanner(link.getInputStream());
PrintWriter output = new
PrintWriter(link.getOutputStream());
4. Mengirim dan menerima data
output.println(“Menunggu data ... “);
String input = input.nextLine();
5. Menutup koneksi
link.close()

45
7.5. Contoh Penggunaan ServerSocket
import java.io.*;
import java.net.*;
public class simpleServer
{
public final static int TESTPORT = 1234;
{
ServerSocket checkServer = null;
String line;
BufferedReader is = null;
DataOutputStream os = null;
Socket clientSocket = null;
try
{
checkServer = new ServerSocket(TESTPORT);
System.out.println("Server Ready ...");
}
catch (IOException e)
{
System.out.println(e);
}
try
{
clientSocket = checkServer.accept();
is = new BufferedReader(new
InputStreamReader(clientSocket.getInputStream()));
os = new
DataOutputStream(clientSocket.getOutputStream());
}
catch (Exception ei)

46
{
ei.printStackTrace();
}
try
{
line = is.readLine();
System.out.println("From Client : " + line);
os.writeBytes(line);
if (line.compareTo("polinema") == 0)
{
os.writeBytes("Welcome To Polinema.");
}
else
{
os.writeBytes("Sorry, this is private
area.");
}
}
{
System.out.println(e);
}
try
{
os.close();
is.close();
clientSocket.close();
}
catch (IOException ic)
{
ic.printStackTrace();
}
}}

47
7.6. Contoh Penggunaan Socket (klien)
import java.io.*;
import java.net.*;
public class simpleClient
{
public final static int REMOTE_PORT = 1234;
public final static String host = "localhost";
public static void main(String args[]) throws Exception
{
Socket cl = null;
BufferedReader is = null;
DataOutputStream os = null;
BufferedReader stdin = new BufferedReader(new
InputStreamReader(S
String userInput = null;
String output = null;
try
{
cl = new Socket(host, REMOTE_PORT);
is = new BufferedReader(new
InputStreamReader(cl.getInputStream()))
os = new DataOutputStream(cl.getOutputStream());
}
catch(UnknownHostException e1)
{
System.out.println("Unknown Host: " + e1);
}
catch (IOException e2)
{
System.out.println("Erorr io: " + e2);
}

48
try
{
System.out.print("Your University ? ");
userInput = stdin.readLine();
os.writeBytes(userInput + "n");
}
catch (IOException ex)
{
System.out.println("Error writing to server..." + ex);
}
try
{
output = is.readLine();
System.out.println("From server: " + output);
}
{
e.printStackTrace();
}
try
{
is.close();
os.close();
cl.close();
}
catch (IOException x)
{
System.out.println("Error writing...." + x);
}
}
}

49
1. Buatlah aplikasi TCPEchoClient dengan kode dibawah ini :
import java.net.*; // for Socket
import java.io.*; // for IOException and Input/OutputStream
public class TCPEchoClient {
public static void main(String[] args) throws IOException {
if ((args.length < 2) || (args.length > 3)) // Test for
correct # of args
throw new IllegalArgumentException("Parameter(s): <Server>
<Word> [<Port>]");
String server = args[0]; // Server name or IP address
// Convert input String to bytes using the default character
encoding
byte[] byteBuffer = args[1].getBytes();
int servPort = (args.length == 3) ? Integer.parseInt(args[2])
: 7;
// Create socket that is connected to server on specified port
Socket socket = new Socket(server, servPort);
System.out.println("Connected to server...sending echo
string");
InputStream in = socket.getInputStream();
OutputStream out = socket.getOutputStream();
out.write(byteBuffer); // Send the encoded string to the
server
// Receive the same string back from the server
int totalBytesRcvd = 0; // Total bytes received so far
int bytesRcvd; // Bytes received in last read
while (totalBytesRcvd < byteBuffer.length) {
if ((bytesRcvd = in.read(byteBuffer, totalBytesRcvd,
byteBuffer.length - totalBytesRcvd)) == -
1)
throw new SocketException("Connection close prematurely");
totalBytesRcvd += bytesRcvd;
}
System.out.println("Received: " + new String(byteBuffer));
socket.close(); // Close the socket and its streams
}
}

50
2. Buatlah aplikasi TCPEchoServer dengan kode di bawah ini :
import java.net.*; // for Socket, ServerSocket, and InetAddress
import java.io.*; // for IOException and Input/OutputStream
public class TCPEchoServer {
private static final int BUFSIZE = 32; // Size of receive
buffer
public static void main(String[] args) throws IOException {
if (args.length != 1) // Test for correct # of args
throw new IllegalArgumentException("Parameter(s): <Port>");
int servPort = Integer.parseInt(args[0]);
// Create a server socket to accept client connection requests
ServerSocket servSock = new ServerSocket(servPort);
int recvMsgSize; // Size of received message
byte[] byteBuffer = new byte[BUFSIZE]; // Receive buffer
for (;;) { // Run forever, accepting and servicing connections
Socket clntSock = servSock.accept(); // Get client
connection
System.out.println("Handling client at " +
clntSock.getInetAddress().getHostAddress() + " on port " +
clntSock.getPort());
InputStream in = clntSock.getInputStream();
OutputStream out = clntSock.getOutputStream();
// Receive until client closes connection, indicated by -1
return
while ((recvMsgSize = in.read(byteBuffer)) != -1)
out.write(byteBuffer, 0, recvMsgSize);
clntSock.close(); // Close the socket. We are done with
this client!
}
/* NOT REACHED */
}
}

51
3. Jalankan masing-masing aplikasi sesuai dengan parameter yang
dibutuhkan masing-masing aplikasi.
4. Modifikasi masing-masing aplikasi sehingga argumen yang
dibutuhkan untuk menjalankan masing-masing aplikasi bisa
diinputkan oleh user sesudah aplikasi dieksekusi. Bukan pada saat
memanggil aplikasi.

52
MODUL 8 MULTICAST
Setelah mempelajari modul 8 ini, mahasiswa diharapkan mampu :
- memahami dan mengerti komunikasi multicast
- mengetahui cara kerja multicast dan mampu menerapkan komunikasi
multicast pada aplikasi
8.1. Konsep Komunikasi Multicast
Komunikasi socket yang telah kita bahas selama ini bersifat unicast,
mereka hanya menyediakan komunikasi data point-to-point. Tidak semua
komunikasi data cocok dengan model unicast, atau broadcast yang mengirimkan
data ke semua titik yang ada pada jaringan. Contoh kasus pada videoconference,
hanya anggota grup yang menerima komunikasi antar mereka. Komunikasi seperti
itu disebut dengan multicast.
Untuk memulai komunikasi multicast, harus terbentuk dulu suatu grup
multicast. Setiap host/titik pada jaringan yang ingin bergabung, harus
mendaftarkan diri dahulu sebelum menerima komunikasi yang ada pada grup.
Multicast komunikasi menggunakan alamat multicast, dan host/komputer-
komputer yang tergabung disebut grup multicast.
Alamat multicast adalah alamat IP dalam range 224.0.0.0 sampai
239.255.255.255, yang secara biner diawali dengan 1110 sebagai 4 bit pertama
alamat IPnya. Alamat ini disebut juga alamat IP kelas D.
Anggota dari grup multicast berbagi alamat multicast yang sama. Setiap
data yang dikirim ke sebuah alamat multicast akan diteruskan ke semua anggota
grup multicast yang beralamat multicast tersebut. Keanggotaan pada grup
multicast bersifat terbuka, dalam artian setiap anggota grup multicast dapat
bergabung atau keluar grup sesuai keinginan.
Pada JAVA, komunikasi multicast dilakukan menggunakan kelas – kelas :
- DatagramPacket, dan
- MulticastSocket yang merupakan subclass dari DatagramSocket

53
8.2. MulticastSocket
Paket MulticastSocket terletak pada java.net.MulticastSocket. Cara
kerjanya mirip dengan DatagramSocket, karena memang turunan dari kelas
DatagramSocket.
Konstruktor :
• public MulticastSocket( ) throws
SocketException  membuat objek multicastSocket yang
terikat pada anonymous port (terserah alokasi dari sistem), cocok
untuk klien dimana tidak membutuhkan port khusus/tertentu untuk
menerima jawaban dari server yang dihubungi.
Contoh :
try {
MulticastSocket ms = new MulticastSocket( );
// send some datagrams...
}
catch (SocketException se) {
System.err.println(se);
}
• public MulticastSocket(int port) throws
SocketException membuat objek MulticastSocket untuk
menerima datagram dari port yang ditentukan
Contoh :
try {
MulticastSocket ms = new MulticastSocket(40
// receive incoming datagrams...
}
catch (SocketException ex) {
System.err.println(ex);
}
• public MulticastSocket(SocketAddress
bindAddress) throws IOException  membuat objek
MulticastSocket menggunakan objek SocketAddress. Jika
SocketAddress nya adalah objek yang mengikat alamat port tertentu,

54
maka konstruktor ini akan sama persis dengan konstruktor
sebelumnya.
Contoh :
try {
SocketAddress address = new InetSocketAddress(4000);
MulticastSocket ms = new MulticastSocket(address);
}
}
Jika objek SocketAddress terikat pada alamat dan port dari sebuah
interace, maka multicastSocket hanya akan menerima data dari port
dan alamat interface yang ditentukan (contoh kasus server yang
memiliki banyak interface network).
Contoh :
try {
SocketAddress address = new
InetSocketAddress("192.168.254.32", 4000);
MulticastSocket ms = new MulticastSocket(address);
}
}
Begitu objek MulticastSocket terbentuk, ada 4 operasi yang bisa dilakukan
oleh objek ini :
1. Join ke sebuah grup multicast
2. Mengirim data ke grup multicast
3. Menerima data dari grup multicast
4. Meninggalkan grup multicast.
Untuk bekerja menggunakan MulticastSocket, kita bisa menggunakan
method-method yang dimilikinya :
• public void joinGroup(InetAddress address)
throws IOException

55
• public void joinGroup(SocketAddress address,
NetworkInterface interface) throws IOException
// Java 1.4
• public void leaveGroup(InetAddress address)
throws IOException
• public void leaveGroup(InetAddress address)
throws IOException
• public void leaveGroup(SocketAddress
multicastAddress, NetworkInterface
interface)throws IOException // Java 1.4
• public void send(DatagramPacket packet, byte
ttl)throws IOException
• public void setInterface(InetAddress
address)throws SocketException
• public InetAddress getInterface( ) throws
SocketException
• public void
setNetworkInterface(NetworkInterface
interface)throws SocketException // Java 1.4
• public NetworkInterface getNetworkInterface( )
throws SocketException // Java 1.4
• public void setTimeToLive(int ttl) throws
IOException // Java 1.2
• public void setTimeToLive(int ttl) throws
IOException // Java 1.2
• public void setLoopbackMode(boolean disable)
throws SocketException
• public boolean getLoopbackMode( ) throws
SocketException
• receive( )

56
8.3. Penggunaan MulticastSocket
Pada contoh berikut ini akan diterapkan penggunaan multicastSocket pada
aplikasi yang bernama MulticastSniffer. Aplikasi ini akan membaca nama dari
grup multicast yang dimasukkan lewat konsol, membuat InetAddress dari nama
yang kita masukkan dari konsol tadi, lalu membuat MulticastSocket untuk
bergabung ke grup multicast dari nama host tadi. Jika berhasil maka aplikasi ini
akan menerima datagram dari socket dan mencetaknya pada konsol (System.out).
Aplikasi berguna untuk mengetahui bahwa kita menerima data multicast dari
sebuah host. Hampir semua data multicast adalah data biner yang mana tidak akan
berarti apa-apa bila dicetak sebagai karakter ASCII.
import java.net.*;
import java.io.*;
public class MulticastSniffer {
public static void main(String[] args) {
InetAddress group = null;
int port = 0;
// read the address from the command line
try {
group = InetAddress.getByName(args[0]);
port = Integer.parseInt(args[1]);
} // end try
catch (Exception ex) {
// ArrayIndexOutOfBoundsException, NumberFormatException,
// or UnknownHostException
System.err.println(
"Usage: java MulticastSniffer multicast_address port");
System.exit(1);
}
MulticastSocket ms = null;
try {
ms = new MulticastSocket(port);
ms.joinGroup(group);
byte[] buffer = new byte[8192];
while (true) {
DatagramPacket dp = new DatagramPacket(buffer,
buffer.length);
ms.receive(dp);

57
String s = new String(dp.getData( ));
System.out.println(s);
}
}
catch (IOException ex) {
}
finally {
if (ms != null) {
try {
ms.leaveGroup(group);
ms.close( );
}
catch (IOException ex) {}
}
}
}
}
Contoh berikutnya adalah aplikasi bernama MulticastSender, yaitu aplikasi
yang akan mengirim data yang diinputkan lewat konsol sebagai argumen, ke grup
multicast. Secara umum sangat sederhana.
import java.net.*;
import java.io.*;
public class MulticastSender {
public static void main(String[] args) {
InetAddress ia = null;
int port = 0;
byte ttl = (byte) 1;
// read the address from the command line
try {
ia = InetAddress.getByName(args[0]);
port = Integer.parseInt(args[1]);
if (args.length > 2) ttl = (byte)
Integer.parseInt(args[2]);
}
catch (Exception ex) {

58
System.err.println(
"Usage: java MulticastSender multicast_address port
ttl");
System.exit(1);
}
byte[] data = "Here's some multicast datarn".getBytes(
);
DatagramPacket dp = new DatagramPacket(data,
data.length, ia, port);
try {
MulticastSocket ms = new MulticastSocket( );
ms.joinGroup(ia);
for (int i = 1; i <= 10; i++) {
ms.send(dp, ttl);
}
ms.leaveGroup(ia);
ms.close( );
}
}
catch (IOException ex) {
}
}
}
1. Untuk praktikum, tuliskan kode yang ada pada contoh di atas dan jalankan
masing-masing aplikasi pada komputer yang berbeda.
2. Modifikasilah aplikasi sehingga argumen tidak lagi diperlukan melainkan
dimasukkan melalui dialog GUI.

59
MODUL 9 UNIFORM RESOURCE LOCATOR
Setelah mengikuti modul 9 ini, mahasiswa diharapkan :
- mampu mengetahui tentang URL
- mampu menerapkannya dalam aplikasi
9.1. Kelas URL
Kelas URL adalah cara paling sederhana untuk sebuah program Java untuk
menemukan dan mengambil data dari jaringan. Anda tidak perlu khawatir tentang
rincian protokol yang digunakan, format data yang diambil, atau bagaimana
berkomunikasi dengan server, anda cukup memberitahu URL dan mendapatkan
data untuk Anda.
Kelas java.net.URL adalah sebuah abstraksi dari Uniform Resource
Locator (URL) seperti http://www.hamsterdance.com/ atau
ftp://ftp.redhat.com/pub/. Listing program berikut adalah contoh penggunaan
kelas URL yang meliputi pengecekan URL dan berbagai cara penulisannya
menggunakan kelas URL.
URL terdiri dari lima bagian, yaitu Skema atau dikenal sebagai protokol,
kewenangan, path, fragmen pengenal, juga dikenal sebagai bagian atau ref serta
string query. Contohnya adalah sebagai berikut:
http://java.sun.com:80/docs/books/tutorial/index.html#DOWNLOADING
Contoh penerapannya adalah sebagai berikut:
import java.net.*;
public class urltest1 {
public static void main (String args[]) {
URL webURL, ftpURL;
try {
webURL = new URL("http://www.macfaq.com/vendor.html");
System.out.println(webURL);
ftpURL = new URL("ftp://ftp1.macfaq.com/pub/");

60
System.out.println(ftpURL);
}
catch (MalformedURLException e) {
System.err.println("URL Salah");
}
}
}
9.2. Koneksi URL
URLConnection adalah kelas abstrak yang merupakan sambungan aktif ke
sumber daya yang ditentukan oleh URL. Kelas URLConnection memiliki dua
tujuan yang berbeda tetapi terkait.
Pertama, memberikan kontrol lebih besar atas interaksi dengan server
(terutama server HTTP) daripada kelas URL. Dengan URLConnection, Anda
dapat memeriksa header yang dikirimkan oleh server dan respon yang sesuai.
Anda dapat mengatur field header yang digunakan dalam permintaan klien. Anda
dapat menggunakan URLConnection untuk men-download file biner.
Akhirnya, URLConnection sebuah memungkinkan Anda mengirim data
kembali ke server web dengan POST atau GET dan menggunakan metode
permintaan HTTP yang lain.
Untuk membuat sebuah program yang menggunakan kelas
URLConnection diperlukan urutan langkah-langkah dasar sebagai berikut:
- Buatlah objek URL.
- Panggil metode openConnection() untuk mengambil objek
URLConnection dari suatu URL.
- Mengkonfigurasi URLConnection tersebut.
- Baca field header.
- Dapatkan input stream dan membaca data.
- Dapatkan output stream dan menulis data.
- Menutup koneksi.
Contoh program dibawah ini akan membaca data dari URL www.poltek-
malang.ac.id. Hasil dari program adalah kode-kode HTML penyusun web.

61
import java.net.*;
import java.io.*;
public class URLConnectionReader
{
public static void main(String[] args) throws Exception
{
URL alamat = new URL("http://www.poltek-
malang.ac.id");
URLConnection yc = alamat.openConnection();
BufferedReader in = new BufferedReader(
new InputStreamReader(
yc.getInputStream()));
String inputLine;
while ((inputLine = in.readLine()) != null)
System.out.println(inputLine);
in.close();
}
}
1. Jalankan contoh-contoh aplikasi yang ada pada modul 9 di atas.
2. Buatlah aplikasi yang bisa mendapatkan informasi dari URL yang bisa
diinputkan menggunakan dialog GUI.

62
DAFTAR PUSTAKA
Elliotte Rusty Harold, 2005, Java Network Programming, O’Reilly Media
Inc.
David Reilly, Michael Reilly, 2002, Java Network Programming and
Distributed Computing, Addison Wesley

Modul network programming

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Modul network programming

Similar to Modul network programming (20)

Recently uploaded

Recently uploaded (20)

Modul network programming