Network programming in Java

Internet protocol suite TCP/IP

Package java.net

Identifying a machine

The InetAddress class

The URL class

Servers and clients

Internet protocol suite TCP/IP

Des exemples de protocoles des couches de transport et d'application (Image copiée de ce site )

IP (Internet protocol) - packet switching. No standard Java API allowing direct IP protocol manipulation

UDP (User Datagram Protocol) - fast, unreliable, unconnected message delivery.

TCP (Transmission Control Protocol) - streaming transmission, reliable, slower, in connected mode

The package java.net

This package provides a set of classes to communicate on the Internet (and Intranet), download URLs, define new protocols.

In particular, it allows you to create and access

     * URL connections.
     * Stream socket (TCP) connections.
     * Datagram socket (UDP) connections.

Identifying a machine (network interface card)

32 bits in IPv4:   

0xxx: this is a class A address
10xx: this is a class B address
110xx: this is a class C address

128 bits in IPv6

The class InetAddress - Internet address (numeric IP addresses and host names)

Does not have public variables and constructors

Some functions:

static InetAddress getByName(String host) -  The address IP on one machine (host).
static InetAddress[] getAllByName(String host) - all IP addresses on one machine
public static InetAddress getByAddress(byte[] addr) - IPv4 must be 4 bytes, IPv6 - 16.
static InetAddress getLocalHost() -the address of the local machine.
                      getByName(null) ~ getByName("localhost") ~  getByName("127.0.0.1")

 String getHostAddress() - IP address as a string "%d.%d.%d.%d".
 String getHostName() -  machine name at this address.
 boolean isMulticastAddress() -  checks if it is a multicast IP address.
 

import java.net.*;  public class NSLookupApp {    public static void main(String args[]) {       try {             if(args.length!=1){                 System.out.println(""Requires hostName as parameter"");                 return;             }             InetAddress host = InetAddress.getByName(args[0]);             String hostName = host.getHostName();              System.out.println("Host name: "+hostName);             System.out.println("IP address: "+host.getHostAddress());        }       catch(UnknownHostException ex) {              System.out.println("Unknown host");             return;        }    } }

Exercise: Show all IP addresses of yahoo.com
 

The URL class

URL: Uniforme Resource Locator. 

A character string that allows unique location of a resource on the Internet network - the protocol to use, the host machine (IP address + port number), the access path (path), name of the resource (file ):

protocol: //machine[:port]/path/name

https://ff.tu-sofia.bg/JavaTech/network/Reseau.html

Description

Contains methods for creating and opening web pages. Does not have variables.

Constructors

URL u1 = new URL("https", "ff.tu-sofia.bg", "/futurs-etudiants/");

URL u2 = new URL("https://ff.tu-sofia.bg/");

URL u3 = new URL(u2, "Java/Network.htm");  // https://ff.tu-sofia.bg/Java/Network.html

All constructors can throw MalformedURLException.

The different types of URL objects are used with different protocols, most commonly with http, https and ftp. The URLs for these protocols are used to locate various files, such as web pages, images, multimedia files, text files and downloadable programs. They can be used for executable programs as well, such as CGI scripts.
 

Example 

The I/O classes can be linked to an URL

Example:  copy a binary file from a URL

import java.io.*;
import java.net.*;
public class Test1 {
	  public static void main(String arg[]) {
	      int abyte;
	      try{
	        URL url = new URL("https://ff.tu-sofia.bg/sites/default/files/images/blogs/FF_Poster.jpg");
	        InputStream fi= url.openStream();
	        FileOutputStream fo= new FileOutputStream("picture.jpg");
	        System.out.println("srarting ...");
	        while((abyte= fi.read())!=-1)fo.write(abyte);
	        fi.close();
	        fo.close();
	        System.out.println("created");

	     }catch(MalformedURLException me) {
	         System.out.println("MalformedURLException: "+ me);
	     }catch (IOException ioe){
	          System.out.println("IOException: "+ ioe);
	     }

	}
}

With a buffer:

import java.io.*;
import java.net.*;
public class Test2 {
	  public static void main(String arg[]) throws MalformedURLException, IOException{
	      byte buf[]=new byte[1024];
	      int len;
	     
	        URL url = new URL("https://ff.tu-sofia.bg/sites/default/files/images/blogs/FF_Poster.jpg");
	        InputStream fi= url.openStream();
	        FileOutputStream fo= new FileOutputStream("picture1.jpg");
	        System.out.println("srarting ...");
	        while((len= fi.read(buf))!=-1)fo.write(buf,0,len);
	        fi.close();
	        fo.close();
	        System.out.println("created");
	}
}

Example - displaying source code of a URL page

Servers and clients

Sockets and ports

ServerSocket - binds the server application to the corresponding port, listens on the network
Socket - software abstraction to represent the two "terminals" of the connection between the two machines. Used by the client application to connect and "chat". Used by the server application to "chat" once the connection is established.

server procedures

     * creating a ServerSocket - to reserve a port and listen to the network;
     * starting new TCP connection - creation of a Socket after receiving a call (creating socket) from a client;    
     * creation of an InputStream and OutputStream (or, with corresponding converters, Reader and Writer);    
     * perform reading of InputStream(Reader) and writing to OutputStream(Writer).    
     * finishing the TCP connection -  closing the created Socket after receiving a request (closing the socket) from the client.

Example: A simple server and client

public class FirstServer {
  // Choose a port outside of the range 1-1024:
  public static final int PORT = 8080;
  public static void main(String[] args)
      throws IOException {
    ServerSocket s = new ServerSocket(PORT);
    System.out.println("Started: " + s);
    try {
      // Blocks until a connection occurs:
      Socket socket = s.accept();
      try {
        System.out.println(
          "Connection accepted: "+ socket);
        BufferedReader in =
          new BufferedReader(
            new InputStreamReader(
              socket.getInputStream()));
        // Output is automatically flushed
        // by PrintWriter:
        PrintWriter out =
          new PrintWriter(
            new BufferedWriter(
              new OutputStreamWriter(
                socket.getOutputStream())),true);
        while (true) {
          String str = in.readLine();
          if (str.equals("END")) break;
          System.out.println("Echoing: " + str);
          out.println(str);
        }
      // Always close the two sockets...
      } finally {
        System.out.println("closing...");
        socket.close();
      }
    } finally {
      s.close();
    }
  }
}

// Very simple client that just sends
// lines to the server and reads lines
// that the server sends.
import java.net.*;
import java.io.*;

public class FirstClient {
  public static void main(String[] args)throws IOException {
    // Passing null to getByName() produces the
    // special "Local Loopback" IP address, for
    // testing on one machine w/o a network:
    // Alternatively, you can use
    // the address or name:
    // InetAddress addr = InetAddress.getByName("127.0.0.1");
    // InetAddress addr = InetAddress.getByName("localhost");

    String serveur = null;
    InetAddress addr =  InetAddress.getByName(serveur);
    System.out.println("addr = " + addr);
    Socket socket = new Socket(addr, FirstServer.PORT);
    // Guard everything in a try-finally to make
    // sure that the socket is closed:
    try {
      System.out.println("socket = " + socket);
      BufferedReader in =
        new BufferedReader(
          new InputStreamReader(socket.getInputStream()));
      BufferedReader sin =  new BufferedReader(
new InputStreamReader(System.in));
      // Output is automatically flushed
      // by PrintWriter:
      PrintWriter out =
        new PrintWriter(
          new BufferedWriter(
            new OutputStreamWriter(
              socket.getOutputStream())),true);
      for(int i = 0; i <10 ; i ++) {
        System.out.println("input a line [empty for finish] " + i + ":");
        String s = sin.readLine();
         if(s.length()==0) break;
         out.println(s + "   :" +i);
         String str = in.readLine();
         System.out.println(str);
      }
      out.println("END");
    }
    finally {
      System.out.println("closing...");
      socket.close();
    }
  }
}

Serving multiple customers, clients with names

The communication protocol - diagram of information exchange between server and client:

Server

//: MultiClientServer.java
// A server that uses multithreading to handle
// any number of clients.
import java.io.*;
import java.net.*;

class ServeOneClient extends Thread {
    private Socket socket;
    private BufferedReader in;
    private PrintWriter out;
    public ServeOneClient(Socket s)  throws IOException {
        socket = s;
        in = new BufferedReader(
                new InputStreamReader(
                  socket.getInputStream()));
    // Enable auto-flush:
        out = new PrintWriter( new BufferedWriter(
                                                   new OutputStreamWriter(
                                                     socket.getOutputStream()
                                                   )
                                              ),
                  true);
    // If any of the above calls throw an
    // exception, the caller is responsible for
    // closing the socket. Otherwise the thread
    // will close it.
        start();    // Calls run()
  }
  public void run() {
    try {
        while (true) {
             String str = in.readLine();
             if (str.equals("END")) break;
            System.out.println("Echoing: " + str);
            out.println(str);
        }
        System.out.println("closing...");
    } catch (IOException e) {  }
   finally {
      try {
        socket.close();
      } catch(IOException e) {}
    }
  }
}

public class MultiClientServer {
  static final int PORT = 8080;
  public static void main(String[] args) throws IOException {
    ServerSocket s = new ServerSocket(PORT);
    System.out.println("Server Started");
    try {
      while(true) {
        // Blocks until a connection occurs:
        Socket socket = s.accept();
        try {
          new ServeOneClient(socket);
        } catch(IOException e) {
          // If it fails, close the socket,
          // otherwise the thread will close it:
          socket.close();
        }
      }
    } finally {
      s.close();
    }
  }
}

Clients with name:

// Client with name
import java.net.*;
import java.io.*;

public class ClientWithName {
    public static void main(String[] args)throws IOException {
        // Passing null to getByName() produces the
        // special "Local Loopback" IP address, for
        // testing on one machine w/o a network:
        // Alternatively, you can use
        // the address or name:
        // InetAddress addr = InetAddress.getByName("127.0.0.1");
        // InetAddress addr = InetAddress.getByName("localhost");

        String server = null;
        InetAddress addr = InetAddress.getByName(server);
        System.out.println("addr = " + addr);
        Socket socket = new Socket(addr, MultiClientServer.PORT); //or MultiClientServer1.PORT
        // Guard everything in a try-finally to make
        // sure that the socket is closed:
        try {
            System.out.println("socket = " + socket);
            BufferedReader sin = new BufferedReader(
                    new InputStreamReader(System.in));
            BufferedReader in =  new BufferedReader(
                    new InputStreamReader(socket.getInputStream()));
            // Output is automatically flushed
            // by PrintWriter:
            PrintWriter out = new PrintWriter(new BufferedWriter(
                    new OutputStreamWriter(socket.getOutputStream())),true);
            System.out.print("Your name: ");
            String name = sin.readLine();
            for(int i = 0; i <10 ; i ++) {
                System.out.println("input a line [empty for finish] :");
                String s = sin.readLine();
                if(s.length()==0) break;
                out.println(name+":"+s);
                String str = in.readLine();
                System.out.println(str);
            }
            out.println("END");
        } finally {
            System.out.println("closing...");
            socket.close();
        }
    }
}