Java Socket 编程

Java socket总结

一，网络编程中两个主要的问题

一个是如何准确的定位网络上一台或多台主机，另一个就是找到主机后如何可靠高效的进行数据传输。

在TCP/IP协议中IP层主要负责网络主机的定位，数据传输的路由，由IP地址可以唯一地确定Internet上的一台主机。

而TCP层则提供面向应用的可靠（tcp）的或非可靠（UDP）的数据传输机制，这是网络编程的主要对象，一般不需要关心IP层是如何处理数据的。

目前较为流行的网络编程模型是客户机/服务器（C/S）结构。即通信双方一方作为服务器等待客户提出请求并予以响应。客户则在需要服务时向服务器提出申请。服务器一般作为守护进程始终运行，监听网络端口，一旦有客户请求，就会启动一个服务进程来响应该客户，同时自己继续监听服务端口，使后来的客户也能及时得到服务。

二，两类传输协议：TCP；UDP

TCP是Tranfer Control Protocol的简称，是一种面向连接的保证可靠传输的协议。通过TCP协议传输，得到的是一个顺序的无差错的数据流。发送方和接收方的成对的两个socket之间必须建立连接，以便在TCP协议的基础上进行通信，当一个socket（通常都是serversocket）等待建立连接时，另一个socket可以要求进行连接，一旦这两个socket连接起来，它们就可以进行双向数据传输，双方都可以进行发送或接收操作。

UDP是User Datagram Protocol的简称，是一种无连接的协议，每个数据报都是一个独立的信息，包括完整的源地址或目的地址，它在网络上以任何可能的路径传往目的地，因此能否到达目的地，到达目的地的时间以及内容的正确性都是不能被保证的。

比较：

UDP：1，每个数据报中都给出了完整的地址信息，因此无需要建立发送方和接收方的连接。

     2，UDP传输数据时是有大小限制的，每个被传输的数据报必须限定在64KB之内。

     3，UDP是一个不可靠的协议，发送方所发送的数据报并不一定以相同的次序到达接收方

TCP：1，面向连接的协议，在socket之间进行数据传输之前必然要建立连接，所以在TCP中需要连接时间。

     2，TCP传输数据大小限制，一旦连接建立起来，双方的socket就可以按统一的格式传输大的数据。

     3，TCP是一个可靠的协议，它确保接收方完全正确地获取发送方所发送的全部数据。

应用：

1，TCP在网络通信上有极强的生命力，例如远程连接（Telnet）和文件传输（FTP）都需要不定长度的数据被可靠地传输。但是可靠的传输是要付出代价的，对数据内容正确性的检验必然占用计算机的处理时间和网络的带宽，因此TCP传输的效率不如UDP高。

2，UDP操作简单，而且仅需要较少的监护，因此通常用于局域网高可靠性的分散系统中client/server应用程序。例如视频会议系统，并不要求音频视频数据绝对的正确，只要保证连贯性就可以了，这种情况下显然使用UDP会更合理一些。

三，基于Socket的java网络编程

1，什么是Socket

网络上的两个程序通过一个双向的通讯连接实现数据的交换，这个双向链路的一端称为一个Socket。Socket通常用来实现客户方和服务方的连接。Socket是TCP/IP协议的一个十分流行的编程界面，一个Socket由一个IP地址和一个端口号唯一确定。

但是，Socket所支持的协议种类也不光TCP/IP一种，因此两者之间是没有必然联系的。在Java环境下，Socket编程主要是指基于TCP/IP协议的网络编程。

2，Socket通讯的过程

Server端Listen(监听)某个端口是否有连接请求，Client端向Server 端发出Connect(连接)请求，Server端向Client端发回Accept（接受）消息。一个连接就建立起来了。Server端和Client 端都可以通过Send，Write等方法与对方通信。

对于一个功能齐全的Socket，都要包含以下基本结构，其工作过程包含以下四个基本的步骤：

　　（1） 创建Socket；

　　（2） 打开连接到Socket的输入/出流；

　　（3） 按照一定的协议对Socket进行读/写操作；

　　（4） 关闭Socket.（在实际应用中，并未使用到显示的close，虽然很多文章都推荐如此，不过在我的程序中，可能因为程序本身比较简单，要求不高，所以并未造成什么影响。）

3，创建Socket

创建Socket

java在包java.net中提供了两个类Socket和ServerSocket，分别用来表示双向连接的客户端和服务端。这是两个封装得非常好的类，使用很方便。其构造方法如下：

　　Socket(InetAddress address, intport);

　　Socket(InetAddress address, intport, boolean stream);

　　Socket(String host, int prot);

　　Socket(String host, int prot,boolean stream);

　　Socket(SocketImpl impl)

　　Socket(String host, int port,InetAddress localAddr, int localPort)

　　Socket(InetAddress address, int port,InetAddress localAddr, int localPort)

　　ServerSocket(int port);

　　ServerSocket(int port, intbacklog);

　　ServerSocket(int port, intbacklog, InetAddress bindAddr)

　　其中address、host和port分别是双向连接中另一方的IP地址、主机名和端口号，stream指明socket是流socket还是数据报socket，localPort表示本地主机的端口号，localAddr和 bindAddr是本地机器的地址（ServerSocket的主机地址），impl是socket的父类，既可以用来创建serverSocket又可以用来创建Socket。count则表示服务端所能支持的最大连接数。例如：

　　Socket client = newSocket("127.0.01.", 80);

　　ServerSocket server = newServerSocket(80);

　　注意，在选择端口时，必须小心。每一个端口提供一种特定的服务，只有给出正确的端口，才能获得相应的服务。0~1023的端口号为系统所保留，例如http服务的端口号为80,telnet服务的端口号为21,ftp服务的端口号为23, 所以我们在选择端口号时，最好选择一个大于1023的数以防止发生冲突。

　　在创建socket时如果发生错误，将产生IOException，在程序中必须对之作出处理。所以在创建Socket或ServerSocket是必须捕获或抛出例外。

4，简单的Client/Server程序

1. 客户端程序

　　import java.io.*;

　　import java.net.*;

　　public class TalkClient {

　　　　public static void main(Stringargs[]) {

　　　　　　try{

　　　　　　　　Socket socket=newSocket("127.0.0.1",4700);

　　　　　　　　//向本机的4700端口发出客户请求

　　　　　　　　BufferedReader sin=newBufferedReader(new InputStreamReader(System.in));

　　　　　　　　//由系统标准输入设备构造BufferedReader对象

　　　　　　　　PrintWriter os=newPrintWriter(socket.getOutputStream());

　　　　　　　　//由Socket对象得到输出流，并构造PrintWriter对象

　　　　　　　　BufferedReader is=newBufferedReader(new InputStreamReader(socket.getInputStream()));

　　　　　　　　//由Socket对象得到输入流，并构造相应的BufferedReader对象

　　　　　　　　String readline;

　　　　　　　　readline=sin.readLine(); //从系统标准输入读入一字符串

　　　　　　　　while(!readline.equals("bye")){

　　　　　　　　//若从标准输入读入的字符串为"bye"则停止循环

　　　　　　　　　　os.println(readline);

　　　　　　　　　　//将从系统标准输入读入的字符串输出到Server

　　　　　　　　　　os.flush();

　　　　　　　　　　//刷新输出流，使Server马上收到该字符串

　　　　　　　　　　System.out.println("Client:"+readline);

　　　　　　　　　　//在系统标准输出上打印读入的字符串

　　　　　　　　　　System.out.println("Server:"+is.readLine());

　　　　　　　　　　//从Server读入一字符串，并打印到标准输出上

　　　　　　　　　　readline=sin.readLine(); //从系统标准输入读入一字符串

　　　　　　　　} //继续循环

　　　　　　　　os.close(); //关闭Socket输出流

　　　　　　　　is.close(); //关闭Socket输入流

　　　　　　　　socket.close(); //关闭Socket

　　　　　　}catch(Exception e) {

　　　　　　　　System.out.println("Error"+e);//出错，则打印出错信息

　　　　　　}

　　}

}

　2. 服务器端程序

　　import java.io.*;

　　import java.net.*;

　　import java.applet.Applet;

　　public class TalkServer{

　　　　public static void main(Stringargs[]) {

　　　　　　try{

　　　　　　　　ServerSocket server=null;

　　　　　　　　try{

　　　　　　　　　　server=new ServerSocket(4700);

　　　　　　　　//创建一个ServerSocket在端口4700监听客户请求

　　　　　　　　}catch(Exception e) {

　　　　　　　　　　System.out.println("can notlisten to:"+e);

　　　　　　　　//出错，打印出错信息

　　　　　　　　}

　　　　　　　　Socket socket=null;

　　　　　　　　try{

　　　　　　　　　　socket=server.accept();

　　　　　　　　　　//使用accept()阻塞等待客户请求，有客户请求到来则产生一个Socket对象，并继续执行

　　　　　　　　}catch(Exception e) {

　　　　　　　　　　System.out.println("Error."+e);

　　　　　　　　　　//出错，打印出错信息

　　　　　　　　}

　　　　　　　　String line;

　　　　　　　　BufferedReader is=newBufferedReader(new InputStreamReader(socket.getInputStream()));

　　　　　　　　　//由Socket对象得到输入流，并构造相应的BufferedReader对象

　　　　　　　　PrintWriteros=newPrintWriter(socket.getOutputStream());

　　　　　　　　　//由Socket对象得到输出流，并构造PrintWriter对象

　　　　　　　　BufferedReader sin=newBufferedReader(new InputStreamReader(System.in));

　　　　　　　　　//由系统标准输入设备构造BufferedReader对象

　　　　　　　　System.out.println("Client:"+is.readLine());

　　　　　　　　//在标准输出上打印从客户端读入的字符串

　　　　　　　　line=sin.readLine();

　　　　　　　　//从标准输入读入一字符串

　　　　　　　　while(!line.equals("bye")){

　　　　　　　　//如果该字符串为"bye"，则停止循环

　　　　　　　　　　os.println(line);

　　　　　　　　　　//向客户端输出该字符串

　　　　　　　　　　os.flush();

　　　　　　　　　　//刷新输出流，使Client马上收到该字符串

　　　　　　　　　　System.out.println("Server:"+line);

　　　　　　　　　　//在系统标准输出上打印读入的字符串

　　　　　　　　　　System.out.println("Client:"+is.readLine());

　　　　　　　　　　//从Client读入一字符串，并打印到标准输出上

　　　　　　　　　　line=sin.readLine();

　　　　　　　　　　//从系统标准输入读入一字符串

　　　　　　　　} 　//继续循环

　　　　　　　　os.close(); //关闭Socket输出流

　　　　　　　　is.close(); //关闭Socket输入流

　　　　　　　　socket.close(); //关闭Socket

　　　　　　　　server.close(); //关闭ServerSocket

　　　　　　}catch(Exception e){

　　　　　　　　System.out.println("Error:"+e);

　　　　　　　　//出错，打印出错信息

　　　　　　}

　　　　}

　　}

5，支持多客户的client/server程序

前面的Client/Server程序只能实现Server和一个客户的对话。在实际应用中，往往是在服务器上运行一个永久的程序，它可以接收来自其他多个客户端的请求，提供相应的服务。为了实现在服务器方给多个客户提供服务的功能，需要对上面的程序进行改造，利用多线程实现多客户机制。服务器总是在指定的端口上监听是否有客户请求，一旦监听到客户请求，服务器就会启动一个专门的服务线程来响应该客户的请求，而服务器本身在启动完线程之后马上又进入监听状态，等待下一个客户的到来。

ServerSocketserverSocket=null;

　　　　boolean listening=true;

　　　　try{

　　　　　　serverSocket=newServerSocket(4700);

　　　　　　//创建一个ServerSocket在端口4700监听客户请求

　　　　}catch(IOException e) {　　}

　　　　while(listening){ //永远循环监听

　　　　　　new ServerThread(serverSocket.accept(),clientnum).start();

　　　　　　//监听到客户请求，根据得到的Socket对象和

　　　　　　　客户计数创建服务线程，并启动之

　　　　　　clientnum++; //增加客户计数

　　　　}

　　　　serverSocket.close(); //关闭ServerSocket

设计ServerThread类

　public class ServerThread extendsThread{

　　　Socket socket=null; //保存与本线程相关的Socket对象

　　　int clientnum; //保存本进程的客户计数

　　　public ServerThread(Socketsocket,int num) { //构造函数

　　　　this.socket=socket; //初始化socket变量

　　　　clientnum=num+1; //初始化clientnum变量

　　　}

　　　public void run() { //线程主体

　　　　try{//在这里实现数据的接受和发送}

四，Datagram通讯

在TCP/IP协议的传输层除了TCP协议之外还有一个UDP协议，相比而言UDP的应用不如TCP广泛，几个标准的应用层协议HTTP，FTP，SMTP…使用的都是TCP协议。但是，UDP协议可以应用在需要很强的实时交互性的场合，如网络游戏，视频会议等。

1，什么是Datagram

数据报（Datagram）就跟日常生活中的邮件系统一样，是不能保证可靠的寄到的，而面向链接的TCP就好比电话，双方能肯定对方接受到了信息。

TCP，可靠，传输大小无限制，但是需要连接建立时间，差错控制开销大。
UDP，不可靠，差错控制开销较小，传输大小限制在64K以下，不需要建立连接。

2，Datagram使用

包java.net中提供了两个类DatagramSocket和DatagramPacket用来支持数据报通信，DatagramSocket用于在程序之间建立传送数据报的通信连接，DatagramPacket则用来表示一个数据报。

DatagramSocket的构造方法：

          DatagramSocket（）；

　　　DatagramSocket（intprot）;

　　　DatagramSocket(int port,InetAddress laddr)

其中，port指明socket所使用的端口号，如果未指明端口号，则把socket连接到本地主机上一个可用的端口。laddr指明一个可用的本地地址。给出端口号时要保证不发生端口冲突，否则会生成SocketException类例外。注意：上述的两个构造方法都声明抛弃非运行时例外SocketException，程序中必须进行处理，或者捕获、或者声明抛弃。

   用数据报方式编写client/server程序时，无论在客户方还是服务方，首先都要建立一个DatagramSocket对象，用来接收或发送数据报，然后使用DatagramPacket类对象作为传输数据的载体。

DatagramPacket的构造方法 ：

　　　DatagramPacket（bytebuf[],int length）；

　　　DatagramPacket(byte buf[], intlength, InetAddress addr, int port);

　　　DatagramPacket(byte[] buf, intoffset, int length)；

　　　DatagramPacket(byte[] buf, intoffset, int length, InetAddress address, int port)；

其中，buf中存放数据报数据，length为数据报中数据的长度，addr和port旨明目的地址，offset指明了数据报的位移量。

在接收数据前，应该采用上面的第一种方法生成一个DatagramPacket对象，给出接收数据的缓冲区及其长度。然后调用DatagramSocket的方法receive()等待数据报的到来，receive()将一直等待，直到收到一个数据报为止。

　　DatagramPacket packet=newDatagramPacket(buf, 256);

　　Socket.receive (packet);

发送数据前，也要先生成一个新的DatagramPacket对象，这时要使用上面的第二种构造方法，在给出存放发送数据的缓冲区的同时，还要给出完整的目的地址，包括IP地址和端口号。发送数据是通过DatagramSocket的方法send()实现的，send()根据数据报的目的地址来寻径，以传递数据报。

　　DatagramPacket packet=newDatagramPacket(buf, length, address, port);

　　Socket.send(packet)；

   在构造数据报时，要给出InetAddress类参数。类InetAddress在包java.net中定义，用来表示一个Internet地址，我们可以通过它提供的类方法getByName（）从一个表示主机名的字符串获取该主机的IP地址，然后再获取相应的地址信息。

3，用Datagram进行广播通讯（MulticastSocket）

DatagramSocket只允许数据报发送一个目的地址，java.net包中提供了一个类MulticastSocket，允许数据报以广播方式发送到该端口的所有客户。MulticastSocket用在客户端，监听服务器广播来的数据。

1. 客户方程序:MulticastClient.java

　　import java.io.*;

　　import java.net.*;

　　import java.util.*;

　　public class MulticastClient {

　　　　public static void main(Stringargs[]) throws IOException

　　　　{

　　　　　MulticastSocket socket=newMulticastSocket(4446);

　　　　　//创建4446端口的广播套接字

　　　　　InetAddressaddress=InetAddress.getByName("230.0.0.1");

　　　　　//得到230.0.0.1的地址信息

　　　　　socket.joinGroup(address);

　　　　　//使用joinGroup()将广播套接字绑定到地址上

　　　　　DatagramPacket packet;

　　　　　for(int i=0;i<5;i++) {

　　　　　　　byte[] buf=new byte[256];

　　　　　　　//创建缓冲区

　　　　　　　packet=newDatagramPacket(buf,buf.length);

　　　　　　　//创建接收数据报

　　　　　　　socket.receive(packet); //接收

　　　　　　　String received=newString(packet.getData());

　　　　　　　//由接收到的数据报得到字节数组，

　　　　　　　//并由此构造一个String对象

　　　　　　　System.out.println("Quote oftheMoment:"+received);

　　　　　　　//打印得到的字符串

　　　　　} //循环5次

　　　　　socket.leaveGroup(address);

　　　　　//把广播套接字从地址上解除绑定

　　　　　socket.close(); //关闭广播套接字

　　　}

　}

　2. 服务器方程序:MulticastServer.java

　　public class MulticastServer{

　　　　public static void main(Stringargs[]) throws java.io.IOException

　　　　{

　　　　　　new MulticastServerThread().start();

　　　　　　//启动一个服务器线程

　　　　}

　　}

　3. 程序MulticastServerThread.java

　　import java.io.*;
import java.net.*;

　　import java.util.*;

　　public class MulticastServerThreadextends QuoteServerThread

　　//从QuoteServerThread继承得到新的服务器线程类MulticastServerThread

　　{

　　　　Private long FIVE_SECOND=5000; //定义常量，5秒钟

　　　　publicMulticastServerThread(String name) throws IOException

　　　　{

　　　　　　super("MulticastServerThread");

　　　　　　//调用父类，也就是QuoteServerThread的构造函数

　　　　}

　　　　public void run() //重写父类的线程主体

　　　　{

　　　　　while(moreQuotes) {

　　　　　//根据标志变量判断是否继续循环

　　　　　　try{

　　　　　　　　byte[] buf=new byte[256];

　　　　　　　　//创建缓冲区

　　　　　　　　String dString=null;

　　　　　　　　if(in==null) dString=newDate().toString();

　　　　　　　　//如果初始化的时候打开文件失败了，

　　　　　　　　//则使用日期作为要传送的字符串

　　　　　　　　else dString=getNextQuote();

　　　　　　　　//否则调用成员函数从文件中读出字符串

　　　　　　　　buf=dString.getByte();

　　　　　　　　//把String转换成字节数组，以便传送send it

　　　　　　　　InetAddressgroup=InetAddress.getByName("230.0.0.1");

　　　　　　　　//得到230.0.0.1的地址信息

　　　　　　　　DatagramPacket packet=newDatagramPacket(buf,buf.length,group,4446);

　　　　　　　　//根据缓冲区，广播地址，和端口号创建DatagramPacket对象

　　　　　　　　socket.send(packet); //发送该Packet

　　　　　　　　try{

　　　　　　　　　　sleep((long)(Math.random()*FIVE_SECONDS));

　　　　　　　　　　//随机等待一段时间，0～5秒之间

　　　　　　　　}catch(InterruptedException e) { }//异常处理

　　　　　　}catch(IOException e){ //异常处理

　　　　　　　　e.printStackTrace( ); //打印错误栈

　　　　　　　　moreQuotes=false; //置结束循环标志

　　　　　　}

　　　　}

　　　　socket.close( ); //关闭广播套接口

　　　}

　}
原文链接：http://edu.codepub.com/2009/1024/16769_5.php

 

======================================================================================================

 

1、Socket 发送Get请求

 

import java.net.*;

import java.io.*;

public class URLSender { 

  /**     * @param args */

 publicstatic void main(String[] args) throws IOException {

        try{

           Socket socket = newSocket("www.nwu.edu.cn", 80);

           boolean autoflush = true;

           PrintWriter out = newPrintWriter(socket.getOutputStream(), autoflush);

           BufferedReader in = newBufferedReader(new InputStreamReader(socket.getInputStream()));

           //send an HTTP request to the web server

           out.println("GET /HTTP/1.1");

           out.println("Host:nwu.edu.cn");

           out.println("Connection:Close");

           out.println();

          //read the response       

          boolean loop = true;

          StringBuffer sb = new StringBuffer(8096);

          while (loop) {

             if (in.ready()) {

               int i = 0;

               while (i != -1) {

                   i = in.read();

                   sb.append((char) i);

               }

               loop = false;

           }

          //Thread.currentThread().sleep(50); 

         } 

         //display the response to the out console 

         System.out.println(sb.toString());

         socket.close();

       }catch (UnknownHostException e) {

           System.err.println("Don't know about host: Victest.");

           System.exit(1);

       }catch (IOException e) {

          System.err.println("Couldn't get I/O for " + "theconnection to: Victest."); 

          System.exit(1);

       }

  }

}

 

2、用Socket发送一个POST请求

 

    try {

        //Construct data

       String data = URLEncoder.encode("key1", "UTF-8") +"=" + URLEncoder.encode("value1", "UTF-8");

        data+= "&" + URLEncoder.encode("key2", "UTF-8") +"=" + URLEncoder.encode("value2", "UTF-8");

  

        //Create a socket to the host

       String hostname = "hostname.com";

        intport = 80;

        InetAddress addr =InetAddress.getByName(hostname);

       Socket socket = new Socket(addr, port);

  

        //Send header

        String path ="/servlet/SomeServlet";

        BufferedWriter wr = newBufferedWriter(new OutputStreamWriter(socket.getOutputStream(),"UTF8"));

        wr.write("POST "+path+"HTTP/1.0/r/n");

        wr.write("Content-Length:"+data.length()+"/r/n");

        wr.write("Content-Type:application/x-www-form-urlencoded/r/n");

        wr.write("/r/n");

  

        //Send data

       wr.write(data);

       wr.flush();

  

        //Get response

       BufferedReader rd = new BufferedReader(newInputStreamReader(socket.getInputStream()));

       String line;

       while ((line = rd.readLine()) != null) {

           // Process line...

        }

       wr.close();

       rd.close();

    } catch(Exception e) {

    }

 

=====================================================================================

This example introduces you to Java socketprogramming. The server listens for a connection. When a connection isestablished by a client. The client can send data. In the current example theclient sends the message "Hi my server". To terminate the connection,the client sends the message "bye". Then the server sends the message"bye" too. Finally the connection is ended and the server waits foran other connection. The two programs should be runned in the same machine.however if you want to run them in two different machines, you may simplychange the adress "localhost" by the IP adress of the machine whereyou will run the server.

The server

package ChinaCache;

 

import java.io.*;

import java.net.*;

 

public class Provider {

  ServerSocket providerSocket;

  Socket connection = null;

  ObjectOutputStream out;

  ObjectInputStream in;

  String message;

 

  Provider() {

  }

 

  void run() {

        try {

              // 1. creating a server socket

              providerSocket = newServerSocket(2004, 10);

             

              // 2. Wait for connection

              System.out.println("Waitingfor connection");

              connection = providerSocket.accept();

              System.out.println("Connectionreceived from "+ connection.getInetAddress().getHostName());

             

              // 3. get Input and Output streams

              out = newObjectOutputStream(connection.getOutputStream());

              out.flush();

             

              in = new ObjectInputStream(connection.getInputStream());

              sendMessage("Connectionsuccessful");

             

              // 4. The two parts communicatevia the input and output streams

              do {

                    try {

                          message = (String) in.readObject();

                          System.out.println("client>" + message);

                          if (message.equals("bye"))

                                sendMessage("bye");

                    } catch(ClassNotFoundException classnot) {

                          System.err.println("Datareceived in unknown format");

 

                    }

              } while (!message.equals("bye"));

        } catch (IOExceptionioException) {

              ioException.printStackTrace();

        } finally {

              // 4: Closing connection

              try {

                    in.close();

                    out.close();

 

                    providerSocket.close();

              } catch (IOExceptionioException) {

                    ioException.printStackTrace();

              }

        }

  }

 

  void sendMessage(String msg) {

        try {

              out.writeObject(msg);

              out.flush();

              System.out.println("server>" + msg);

        } catch (IOExceptionioException) {

              ioException.printStackTrace();

        }

  }

 

  public static void main(Stringargs[]) {

        Provider server = new Provider();

 

        while (true) {

              server.run();

        }

  }

}

The client

package ChinaCache;

 

import java.io.*;

import java.net.*;

 

public class Requester {

      Socket requestSocket;

      ObjectOutputStream out;

      ObjectInputStream in;

      String message;

 

      Requester() {

      }

 

      void run() {

 

            try {

                  // 1. creating a socket to connect to the server

                  requestSocket = new Socket("localhost", 2004);

                  System.out.println("Connectedto localhost in port 2004");

                 

                  // 2. get Input and Output streams

                  out = newObjectOutputStream(requestSocket.getOutputStream());

                  out.flush();

                  in = newObjectInputStream(requestSocket.getInputStream());

                 

                  // 3: Communicating with the server

                  do {

                        try {

                              message = (String) in.readObject();

                              System.out.println("server>" + message);

                              sendMessage("Hi myserver");

                              message = "bye";

                              sendMessage(message);

                        } catch(ClassNotFoundException classNot) {

                              System.err.println("datareceived in unknown format");

                        }

                  } while (!message.equals("bye"));

            } catch(UnknownHostException unknownHost) {

                  System.err.println("You aretrying to connect to an unknown host!");

 

            } catch (IOExceptionioException) {

                  ioException.printStackTrace();

            } finally {

                  // 4: Closing connection

                  try {

                        in.close();

                        out.close();

                        requestSocket.close();

                  } catch (IOExceptionioException) {

 

                        ioException.printStackTrace();

                  }

            }

      }

 

      voidsendMessage(String msg) {

            try {

                  out.writeObject(msg);

                  out.flush();

                  System.out.println("client>" + msg);

            } catch (IOExceptionioException) {

 

                  ioException.printStackTrace();

            }

      }

 

      public static void main(Stringargs[]) {

            Requester client= new Requester();

            client.run();

      }

}

===========================================================================

import java.io.*;
import java.net.*;

public class EchoClient {
    public static void main(String[] args) throws IOException {

        Socket echoSocket = null;
        PrintWriter out = null;
        BufferedReader in = null;

        try {
            // echoSocket = new Socket("taranis", 7);
            echoSocket = new Socket("127.0.0.1", 10007);

            out = new PrintWriter(echoSocket.getOutputStream(), true);
            in = new BufferedReader(new InputStreamReader(echoSocket.getInputStream()));

        } catch (UnknownHostException e) {

            System.err.println("Don't know about host: taranis.");
            System.exit(1);
        } catch (IOException e) {
            System.err.println("Couldn't get I/O for "+ "the connection to: taranis.");
            System.exit(1);
        }

        BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));

        String userInput;

        while ((userInput = stdIn.readLine()) != null) {
                out.println(userInput);
                System.out.println("echo: " + in.readLine());
        }

        out.close();
        in.close();
        stdIn.close();

        echoSocket.close();
    }
}