socket

 今天终于有时间来实践一下Java socket的使用方法了，需要注意几个问题：

(1)、使用socket.getInputStream 读取数据时，该方法是阻塞方法，即如果管道流中没有数据时，使用inputStream.read(byte)是会一直阻塞，所以如果想要使用inputStream.read(new byte[]) > 0 来结束

循环是行不通的；

（2）、由于我的目的是不停的交互数据，所以不能IO流关闭，也不能把socket会话关闭，否则数据交换就会停止。

贴代码做记录：

1、服务端代码：

001package com.server;

002 

003import java.io.IOException;

004import java.io.InputStream;

005import java.io.OutputStream;

006import java.net.ServerSocket;

007import java.net.Socket;

008 

009import com.base.Constant;

010 

011public classServerMain {

012    /**

013     * @param args

014     */

015    publicstatic void main(String[] args) {

016        ServerSocket serverSocket =null;

017        System.out.println("ServerSocket Begin........");

018        intnum = 0;

019        try{

020                serverSocket =new ServerSocket(Constant.PORT);

021                //使用循环方式一直等待客户端的连接

022                while(true){

023                    num ++;

024                    Socket accept = serverSocket.accept();

025                    //启动一个新的线程，接管与当前客户端的交互会话

026                    newThread(new ServerThread(accept),"Client "+num).start();

027                }

028        } catch (IOException e) {

029            e.printStackTrace();

030        }

031        finally{

032            try{

033                serverSocket.close();

034                System.out.println("---->  serverSocket closed.");

035            }catch (IOException e) {

036                e.printStackTrace();

037            }

038        }

039    }

040}

041/**

042 * @author JCC

043 * 服务器处理客户端会话的线程

044 */

045class ServerThreadimplements Runnable {

046     

047    Socket socket =null;

048    publicServerThread(Socket socket){

049        System.out.println("Create a new ServerThread...");

050        this.socket = socket;

051    }

052 

053    @Override

054    publicvoid run() {

055        InputStream in =null;

056        OutputStream out =null;

057        try{

058            in = socket.getInputStream();

059            out  = socket.getOutputStream();

060            //使用循环的方式，不停的与客户端交互会话

061            while(true){

062                try{

063                    Thread.sleep(1000);

064                }catch (InterruptedException e) {

065                    e.printStackTrace();

066                }

067                //处理客户端发来的数据

068                doRead(in);

069                System.out.println("send Message to client.");

070                //发送数据回客户端

071                doWrite(out);

072            }

073             

074        } catch (IOException e) {

075            e.printStackTrace();

076        }

077        finally{

078            try{

079                in.close();

080                out.close();

081            }catch (IOException e) {

082                // TODO Auto-generated catch block

083                e.printStackTrace();

084            }

085        }

086    }

087     

088    /**

089     * 读取数据

090     * @param in

091     * @return

092     */

093    publicboolean doRead(InputStream in){

094        //引用关系，不要在此处关闭流

095        try{

096            byte[] bytes =new byte[in.available()];

097            in.read(bytes);

098            System.out.println("line:"+newString(bytes).trim());

099        } catch (IOException e) {

100            e.printStackTrace();

101        }

102         

103        returntrue;

104    }

105     

106    /**

107     * 写入数据

108     * @param out

109     * @return

110     */

111    publicboolean doWrite(OutputStream out){

112        //引用关系，不要在此处关闭流

113        try{

114            out.write("welcome you client.".getBytes());

115            out.flush();       

116        } catch (IOException e) {

117            // TODO Auto-generated catch block

118            e.printStackTrace();

119        }

120        returntrue;

121    }

122}

 

2、客户端代码：

001package com.client;

002 

003import java.io.IOException;

004import java.io.InputStream;

005import java.io.OutputStream;

006import java.net.Socket;

007import java.net.UnknownHostException;

008 

009import com.base.Constant;

010 

011class ClientMain {

012    /**

013     * @param args

014     */

015    publicstatic void main(String[] args) {

016        Socket socket =null;

017        System.out.println("ClientSocket Begin........");

018        try{

019            for(inti = 0;i<5;i++){

020                socket =new Socket(Constant.SERVER_IP,Constant.PORT);

021                newThread(new ClientThread(socket,i),"ClientThread "+i).start();

022            }

023             

024        } catch (UnknownHostException e) {

025            e.printStackTrace();

026        } catch (IOException e) {

027            e.printStackTrace();

028        }

029    }

030     

031     

032}

033 

034/**

035 * 客户端线程

036 * @author JCC

037 *

038 */

039class ClientThreadimplements Runnable{

040    Socket socket =null;

041    intid = 0;

042    publicClientThread(Socket socket,intid){

043        this.socket = socket;

044        this.id = id;

045    }

046    @Override

047    publicvoid run() {

048        OutputStream out =null;

049        InputStream in =null;

050        System.out.println("Begin to Chat to server...");

051        try{

052            out = socket.getOutputStream();

053            in = socket.getInputStream();

054            //循环发送与服务端不停的交互数据

055            while(true){

056                try{

057                    Thread.sleep(1000);

058                }catch (InterruptedException e) {

059                    e.printStackTrace();

060                }

061                doWrite(out);

062                System.out.println("begin read message from server.");

063                doRead(in);

064            }

065             

066        } catch (IOException e) {

067            e.printStackTrace();

068        }

069        finally{

070            try{

071                in.close();

072                out.close();

073            }catch (IOException e) {

074                e.printStackTrace();

075            }

076        }

077    }

078     

079    /**

080     * 读取服务端数据

081     * @param in

082     * @return

083     */

084    publicstatic boolean doRead(InputStream in){

085        //引用关系，不要在此处关闭流

086        byte[] bytes =new byte[1024];

087        try{

088            in.read(bytes);

089            System.out.println("line:"+newString(bytes).trim());

090        } catch (IOException e) {

091            e.printStackTrace();

092        }

093         

094        returntrue;

095    }

096     

097    /**

098     * 发送数据到服务端

099     * @param out

100     * @return

101     */

102    publicboolean doWrite(OutputStream out){

103        //引用关系，不要在此处关闭流

104        String line ="Hello server, I am client = "+id +"\n";

105        line = line +"I want you to do something for me";

106        try{

107            out.write(line.getBytes());

108            out.flush();       

109        } catch (IOException e) {

110            e.printStackTrace();

111        }

112        returntrue;

113    }

114}

 

3、常量类：

1package com.base;

2 

3public interfaceConstant {

4 

5    publicstatic final  String SERVER_IP = "192.168.1.44";

6    publicstatic final int PORT = 4567;

7}

 

执行结果：

（1）服务端结果：

01ServerSocket Begin........

02Create a newServerThread...

03Create a newServerThread...

04Create a newServerThread...

05Create a newServerThread...

06Create a newServerThread...

07line:

08send Message to client.

09line:

10send Message to client.

11line:

12send Message to client.

13line:Hello server, I am client = 3

14I want you to dosomething for me

15send Message to client.

16line:Hello server, I am client = 4

17I want you to dosomething for me

18send Message to client.

19line:Hello server, I am client = 0

20I want you to dosomething for me

21send Message to client.

22line:Hello server, I am client = 1

23I want you to dosomething for me

24send Message to client.

25line:Hello server, I am client = 2

26I want you to dosomething for me

27send Message to client.

28line:

29send Message to client.

30line:

31send Message to client.

32line:Hello server, I am client = 0

33I want you to dosomething for me

34send Message to client.

35line:Hello server, I am client = 1

36I want you to dosomething for me

37send Message to client.

38line:Hello server, I am client = 2

39I want you to dosomething for me

40send Message to client.

41line:Hello server, I am client = 3

42I want you to dosomething for me

43send Message to client.

44line:Hello server, I am client = 4

45I want you to dosomething for me

46send Message to client.

47line:Hello server, I am client = 0

48I want you to dosomething for me

49send Message to client.

（2）客户端结果：

01ClientSocket Begin........

02Begin to Chat to server...

03Begin to Chat to server...

04Begin to Chat to server...

05Begin to Chat to server...

06Begin to Chat to server...

07begin read message from server.

08line:welcome you client.

09begin read message from server.

10line:welcome you client.

11begin read message from server.

12line:welcome you client.

13begin read message from server.

14line:welcome you client.

15begin read message from server.

16line:welcome you client.

17begin read message from server.

18line:welcome you client.

19begin read message from server.

20line:welcome you client.

21begin read message from server.

22line:welcome you client.

23begin read message from server.

24line:welcome you client.

25begin read message from server.

26line:welcome you client.

27begin read message from server.

28line:welcome you client.

29begin read message from server.

30line:welcome you client.

31begin read message from server.