• Choosing a local port
• You can also specify a local port number,
• Setting the port to 0 tells the system to randomly choose an available port.
• If you need to know the port you're connecting from, you can always get it with getLocalPort().

  Socket webMetalab = new Socket("metalab.unc.edu", 80, "calzone.oit.unc.edu", 0);

• Data is sent and received with output and input streams.
• There are methods to get an input stream for a socket and an output stream for the socket.

  public InputStream  getInputStream()
   throws IOException
  
  public OutputStream getOutputStream()
   throws IOException
  

   

• There's also a method to close a socket:

  public synchronized void close() throws IOException

• The getInputStream() method returns an InputStream which reads data from the socket.
• You can use all the normal methods of the InputStream class to read this data.
• Most of the time you'll chain the input stream to some other input stream or reader object to more easily handle the data.

Reading Data with a Server Socket:

• Server Socket uses accept() method to receive a client. May throw the following exceptions:
  public Socket accept() throws IOException
• There are not getInputStream() or getZOutputStream() methods for server socket
• accept method returns a Socket Object and its getInputStream() and getOutputStream() methods provide streams.
  try {
  ServerSocket ss = new ServerSocket(5216);
  Socket s = ss.accept();
  PrintWriter pw = new
  PrintWriter(s.getOutputStream());
  pw.println("Print message 1!");
  pw.println("Print message 2");
  s.close();
  }
  catch (IOException e) {
  System.err.println(e);
  }

• The getOutputStream() method returns an output stream which writes data to the socket.
• Most of the time you'll chain the raw output stream to some other output stream or writer class to more easily handle the data.

Reading Data

• It's unusual to only read from a socket. It's even more unusual to only write to a socket.
• Most protocols require the client to both read and write.
• Some protocols require the reads and the writes to be interlaced. That is:
   

  	HTTP1.0 multiple writes
  write read write read write read	write write write read read read read

• Java places no restrictions on reading and writing to sockets.
• One thread can read from a socket while another thread writes to the socket at the same time.

• public void setTcpNoDelay(boolean on)
   throws SocketException

• public boolean getTcpNoDelay() t
  hrows SocketException

• public void setSoLinger
  (boolean on, int val) 
  throws SocketException

• public int getSoLinger() 
  throws SocketException

• public void setSoTimeout(int timeout)
   throws SocketException

• public int getSoTimeout() 
  throws SocketException

• These methods to return information about the socket:
  
  public InetAddress getInetAddress()
  public InetAddress getLocalAddress()
  public int getPort()
  public int getLocalPort()
  
  Finally there's the usual toString() method:
  
  public String toString()

• There are two ends to each connection: the client, that is the host that initiates the connection, and the server, that is the host that responds to the connection.
• Clients and servers are connected by sockets.
• A server, rather than connecting to a remote host, a program waits for other hosts to connect to it.

• A server socket binds to a particular port on the local machine.
• Once it has successfully bound to a port, it listens for incoming connection attempts.
• When a server detects a connection attempt, it accepts the connection. This creates a socket between the client and the server over which the client and the server communicate.

• Multiple clients can connect to the same port on the server at the same time.
• Incoming data is distinguished by the port to which it is addressed and the client host and port from which it came.
• The server can tell for which service (like http or ftp) the data is intended by inspecting the port.
• It can tell which open socket on that service the data is intended for by looking at the client address and port stored with the data.

• Incoming connections are stored in a queue until the server can accept them.
• On most systems the default queue length is between 5 and 50.
• Once the queue fills up further incoming connections are refused until space in the queue opens up.

• The java.net.ServerSocket Class
  
  The java.net.ServerSocket class represents a server socket.
  
  A ServerSocket object is constructed on a particular local port. Then it calls accept() to listen for incoming connections.
  
  accept() blocks until a connection is detected. Then accept() returns a java.net.Socket object that performs the actual communication with the client.

• The java.net.ServerSocket class represents a server socket.
• A ServerSocket object is constructed on a particular local port. Then it calls accept() to listen for incoming connections.
• accept() blocks until a connection is detected. Then accept() returns a java.net.Socket object that performs the actual communication with the client.

• There are three constructors that let you specify the port to bind to, the queue length for incoming connections, and the IP address to bind to:
• public ServerSocket(int port) throws IOException
• public ServerSocket(int port, int backlog) throws IOException
• public ServerSocket(int port, int backlog, InetAddress networkInterface) throws IOException