黑马程序员技术交流社区

标题: 网络编程 [打印本页]
作者: 段波    时间: 2011-12-3 22:53
标题: 网络编程
本帖最后由 段波 于 2011-12-7 12:53 编辑

public class Servicer implements Runnable{
                Socket s;

                public Servicer(Socket s) {
                        this.s = s;
                }

                public void run() {
                       
                        try {
                                InputStream ips= s.getInputStream();
                                OutputStream ops= s.getOutputStream();
                                BufferedReader br= new BufferedReader(new InputStreamReader(ips));
                                DataOutputStream dos= new DataOutputStream(ops);
                                while(true){
                                        String str=br.readLine();
                                        if(str.equalsIgnoreCase("quit")){
                                                System.out.println("The Client has been out !");
                                                break;
                                               
                                        }
                                        String strBack=str.toUpperCase();
                                        dos.writeBytes(strBack);
                                        br.close();
                                        dos.close();
                                        s.close();
                                }
                        } catch (IOException e) {
                               
                                e.printStackTrace();
                        }
                        }
}

public class TcpServer {

        public static void main(String[] args) {
                try {
                        ServerSocket ss= new ServerSocket(8000);
                        while(true){
                                Socket s=ss.accept();
                                new Thread(new Servicer(s)).start();
                               
                               
                        }
                } catch (IOException e) {
                        e.printStackTrace();
                }
               
                        }
}
public class TCPClient {
        public static void main(String[] args) {
        try {
                Socket s= new Socket(InetAddress.getByName("172.16.9.115"),8000);
                InputStream ips=s.getInputStream();
                OutputStream ops= s.getOutputStream();
                BufferedReader brKey= new BufferedReader(new InputStreamReader(System.in));
                DataOutputStream dos= new DataOutputStream(ops);
                BufferedReader brNet= new BufferedReader(new InputStreamReader(ips));
                while(true){
                        String str= brKey.readLine();
            dos.writeBytes(str+System.getProperty("line.separator"));
                        if(str.equalsIgnoreCase("quit")){
                                break;
                                }else
                                {
                                        System.out.println(brNet.readLine());
                                       
                                }
                         
                        }
                   dos.close();
                   brKey.close();
                   brNet.close();
                   s.close();
               
        } catch (Exception e) {
                e.printStackTrace();
        }
               
        }
}
请问为什么客户端和服务端只能通信一次，客户端还没退出就自己死掉了呢？有时还返回null
作者: 成杰    时间: 2011-12-4 09:21
想要多通信几次的话，就要用到循环，一直等待客户端的输入
作者: 李盈科    时间: 2011-12-4 19:32
要用到while（）的
作者: 周敏2011nc    时间: 2011-12-5 09:56
在service端，你将关闭的通道代码写在了while循环内，当然执行一次后，链接就被断开，同时，service端和Client端你都使用的是readLine（）方法，该方法是阻塞式的，你在Client写了结束标记（System.getProperty("line.separator")），但在service端却没用写，因加上。
作者: 刘海涛    时间: 2011-12-5 13:40
本帖最后由 刘海涛 于 2011-12-5 13:49 编辑

你这段代码好多错误，我修改了下，你可以复制运行。
1.close() 关闭的地方不对，应该是在程序结束才关闭，不应该放在循环，所以导致你的刚连接上发信息就退出。
2. 服务器回写客户端的时候也应该加System.getProperty("line.separator")。
3.  Client  用了两次读取 导致也无法打印，使得程序阻塞，打印的应该是服务器回显的。大写。
String str= brKey.readLine();
   dos.writeBytes(str+System.getProperty("line.separator"));
              if(str.equalsIgnoreCase("quit")){
             break;
             }else
      {
             System.out.println(brNet.readLine());
     }
具体解决方案见下面代码。

4 资源关闭前应该判断是否为空，否则抛空指针异常。
  1. import java.io.IOException;
  2. import java.net.ServerSocket;
  3. import java.net.Socket;

  5. public class TcpServer {

  7.         public static void main(String[] args) {
  8.                 try {
  9.                         ServerSocket ss = new ServerSocket(8000);
  10.                         while (true) {
  11.                                 Socket s = ss.accept();
  12.                                 new Thread(new Servicer(s)).start();
  13.                         }
  14.                 } catch (IOException e) {
  15.                         e.printStackTrace();
  16.                 }
  17.         }
  18. }





  24. import java.io.BufferedReader;
  25. import java.io.DataOutputStream;
  26. import java.io.IOException;
  27. import java.io.InputStream;
  28. import java.io.InputStreamReader;
  29. import java.io.OutputStream;
  30. import java.net.Socket;

  32. public class Servicer implements Runnable {
  33.         Socket s;

  35.         public Servicer(Socket s) {
  36.                 this.s = s;
  37.         }

  39.         public void run() {
  40.                 BufferedReader br = null;
  41.                 DataOutputStream dos = null;
  42.                 try {
  43.                         InputStream ips = s.getInputStream();
  44.                         OutputStream ops = s.getOutputStream();
  45.                         br = new BufferedReader(new InputStreamReader(ips));
  46.                         dos = new DataOutputStream(ops);
  47.                         while (true) {
  48.                                 String str = br.readLine();
  49.                                 if (str.equalsIgnoreCase("quit")) {
  50.                                         System.out.println("The Client has been out !");
  51.                                         break;
  52.                                 }
  53.                                 String strBack = str.toUpperCase();
  54.                                 System.out.println(strBack);
  55.                                
  56.                                 dos.writeBytes(strBack +  System.getProperty("line.separator"));
  57.                                 dos.flush();

  59.                         }
  60.                 } catch (IOException e) {
  61.                         e.printStackTrace();
  62.                 } finally {
  63.                         try {
  64.                                 if (br != null) {
  65.                                         br.close();
  66.                                 }
  67.                                 if (dos != null) {
  68.                                         dos.close();
  69.                                 }
  70.                                 if (s != null) {
  71.                                         s.close();
  72.                                 }
  73.                         } catch (IOException e1) {
  74.                                 e1.printStackTrace();
  75.                         }
  76.                 }
  77.         }
  78. }



  82. import java.io.BufferedReader;
  83. import java.io.DataOutputStream;
  84. import java.io.IOException;
  85. import java.io.InputStream;
  86. import java.io.InputStreamReader;
  87. import java.io.OutputStream;
  88. import java.net.InetAddress;
  89. import java.net.Socket;

  91. public class TCPClient {
  92.         public static void main(String[] args) {
  93.                 BufferedReader brKey = null;
  94.                 DataOutputStream dos = null;
  95.                 BufferedReader brNet = null;
  96.                 Socket s = null;
  97.                 try {
  98.                         s = new Socket(InetAddress.getByName("127.0.0.1"), 8000);
  99.                         InputStream ips = s.getInputStream();
  100.                         OutputStream ops = s.getOutputStream();
  101.                         brKey = new BufferedReader(new InputStreamReader(System.in));
  102.                         dos = new DataOutputStream(ops);
  103.                         brNet = new BufferedReader(new InputStreamReader(ips));
  104.                         while (true) {
  105.                                 String str = brKey.readLine();
  106.                                 dos.writeBytes(str + System.getProperty("line.separator"));
  107.                                 if (str.equalsIgnoreCase("quit")) {
  108.                                         break;
  109.                                 }  
  110.                                 dos.flush();
  111.                                 System.out.println(brNet.readLine());
  112.                         }
  113.                 } catch (Exception e) {
  114.                         e.printStackTrace();
  115.                 } finally {
  116.                         try {
  117.                                 if (dos != null) {
  118.                                         dos.close();
  119.                                 }
  120.                                 if (brKey != null) {
  121.                                         brKey.close();
  122.                                 }
  123.                                 if (brNet != null) {
  124.                                         brNet.close();
  125.                                 }
  126.                                 if (s != null) {
  127.                                         s.close();
  128.                                 }
  129.                         } catch (IOException e1) {
  130.                                 e1.printStackTrace();
  131.                         }
  132.                 }

  134.         }
  135. }
复制代码
作者: 许邦存    时间: 2011-12-5 20:23
楼主的问题应该是出在客户端和服务端都在等待，因为都有阻塞式方法readLine（），导致两端都在等待，比如客户端向服务端发送中并只是把回车符之前的发送给服务端，服务端没收到结束标志，导致停在那了，应该客户端 dos.writeBytes(str+System.getProperty("line.separator"));String str= brKey.readLine();再加上写过去换行。同样在服务端中也没有回车符的结束标志，也应该在dos.writeBytes(strBack);后再加换行符写过去给客户端。



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2