NETWORK PROGRAMMING

java is the first programming language designed from the ground up with networking in mind. a network is a collection of

computers and other devices that can send data to and receive data from each other,more or less in real time. a network

is normally connected by wires and the bits of data are turned into electromagnetic waves that move through the wires. the

host-to-network layer defines how a particular network interface send ip datagrams over its physical connection to the local

network and the world. the part of the host -to-network layer made up of the hardware used to connect different computers.

a network layer protocol defines how bits and bytes of data are organized into large group called packets and the

addressing shcema by which different machines find each other. the transport layer is responsible for ensuring that

packets are received in the order they were sent and making sure that no data is lost or corrupted. the hypertext transfer

protocol is a standard that defines how a web client talks to a server and how data is transfered from the server back to

the client. http relies heavily on two other standards the multipurpose internet mail extensions and the hypertext markup

lanuage. mime is a way to encode different kinds of data to be transmitted over a 7-bits ascii connection it also lets the

recipeint know  what kind of data has been sent.
i/o in java is built on streams. inputs streams read data; output streams wrtite data. different fundamental steam classes

such java.io.fileinputstream and sun.net.telnetoutputstream read and write particulart sources of data. however, all

fundamental output streams have the same basic methods to write data and all fundamental input streams use the same

basic methods to read data. filter streams can be chained to either an input stream or an output stream. filters can modify

the data as it is read or wriiten. readers and writes can be chained to input and output streams to allow programs to read

and write text rather than bytes. there are at least two solutions to this problem. this first is to reuse processes rather than

spawning new ones. the second solution to this problem is to use lightweight threads to handle connections instead of

using heavyweight processes. the simplest way to implement a thread pool is by using a fixed number of threads set when

the pool is first created.
the java.net.inetaddress class is java's encapsulation of an ip address. this class represents an internet address as two

fields;hostname and address. hostname contains the name of the host. the simplest way for a java program to locate and

retrieve data from the network is to use the url class, alithough java can handle only a few protocols and content types out

of the box. the java.net.url class is an abstract of a uniform resource locator. it extends java.lang.object and it is a final

class that can not be subclassed. protocol handlers are the strategies and the url  class itself froms the context through which the different strategies are selected. it is helpful to think of url as objkects with fields that include the protocol,hostname,port,path,query string and ref. the java.net.urlencoder class contains a single static method called encode() that encodes a string according to these rules. data is transimitted across the internet in packets of finite size called datagrams. each datagram contains a header and a payload. the header contains the address and port to which the packet is going, the address and port from which the packet came and various other housekeeping information used to ensure reliable transimission. the payload contains the data itself. sockets are an innovation of berkeley unix that allow the programmer to treat a network connection as  just another steam onto which bytrs can be written and from which bytes can be read. sockets are an extension of one of unix's most important ideas: that all i/o should look like file i/o to the programmer whether you are working with a keyboard or a network connection. a socket is a connection between two hosts. it can peform seven basic operations: conect to a remote machine,send data; receive data;close a connection; bind to a port;listen for incoming data; accept connections from remote machines on the bound port. the java.net.socket class is java's fundamental class for performaing client_side tcp operations. other client-oriented classes that make tcp network connections all ultimately end up invokong the methods of this class. this class itself use native code to communicate with the local tcp stack of the host operating system. the method of the socket class set up and tear down connections and set as various socket options. java provides a serversocket class to allow programmers to write servers. bascially, a server ' s job is to sit by the phone and waiting for incoming calls. more technically, a serversocket runs on a particular poert on the server machine. when a client socket on a remote host attempts to connect to that port, the server wakes up,negotiates the connection between the client and the servr and opne a regular socket between the two hosts. in other words, srver sockets wait for connection while client sockets initiate connections. once the server socket has set up the connection, the server use a regular socket object to send dat to the client. data always travels over the regular socket.
the seversocket class containsw everything you need to write servers in java. it has constructors that create new serversocket objects,method that listen for connections on a specified port and methods that returns a socket object when a connection is made so that you can send and receive data. the operating system stores incoming connection requests addressed to a particular port in a first-in,first-out queue.
the sslsocket class has a number of methods for configuring exactly how much and what kind of authentication and encryption is performed. different implementation of the jsse support different combinations of authentication and encrytion algorithms. the base java.net.urlconnection class is abstract to implement a specific protocol ,you write a subclass. these subaclsses can be loaded at runtime by your own applications or by the hotjava browser.
java divides the task of handling protocol into a number of pieces. as a result ,there is no single class called protocolhandler. instead,pieces of the protocol hanlder mechanism are implemented  by four different classed in the java.net package. a content hanlder is an instance of a subclass of java.net.contenthanlder. this class knows how to take a utrlconnection and a mime type and turn the data coming from the urlconnection into a java object of an appropriate type.
 rmi is a core java api and class library that allows java programs to call certain methods on a remote server. furthermore, the methods running on the server can invoke methods in objects on the client. return values and arguments can be passed back and forth in both directions. a remote object lives on a server. each remote object implements a remote interface that specifies which of its method cane invoked by clients. clients invoke the methods of the remote object almost exactly as they invoke local methods. the stub is a local object that implements the remote interfaces of the remote object; this means that the stub has methods matching the signatures of all the methods the remote object exports. in effect, the client thinks it is calling a method in the remote object,but it is really calling an equivalent method in the stub. stubs are used in the client 's virtual machine in place of the real objects and methods that live on the server. it is helpful to think of the stub as the remote object's surrogate on the client. when the client invokes a method, the stub passes the invocation to the remote reference layer. the remote reference layer carries out a specific remote referernce protocol which is independent of the specific client stubs and server skeletons. in essence, the remote reference layer translates the local reference to the stub into a remote reference to the object on the server whatever the syntax or semantics of the remote reference may be, then it passes the invocation to the transport layer. the transport layer sends the invocation across the internet. on the server side ,the transport ;layer listens for incoming connections,upon receiving an invocation, the transport layer frowards it to the remote reference layer on the server. the remote reference layer converts the remote references sent by the client into referemnce for the local virtual machine. then it passes the request to the skeleton. the skeleton reads the arguments and passes the data to the server program which makes the actual method call. if the method call return a value, that value is sent down through the skeleton,remore reference and transport layers on the server side across the internet and then up throught the transport,remote reference and stub layers on the client side. the java.rmi package defines the classes interfaces and exceptions that will be seen on the client side. the java.rmi.server package defines the classes,interfaces and exceptions that will be visble on the server side. the java.rmi.registry package defines the classes,interfaces and exceptions that are used to locate and name remote objects.
to create a new remote object ,you first define an interface that extends the java.rmi.remote interface. the remote interface does not have any methods of its own; its sole purpose is to tag remore objects so that they can be identified as such. your subeinterface of remote determines whick methods of the remote object may be called by clients.