黑马程序员技术交流社区

标题: 不知道哪里错了,第二次键盘输入卡了！ [打印本页]
作者: 唐宋博宇    时间: 2013-3-16 19:38
标题: 不知道哪里错了,第二次键盘输入卡了！
  1. package com.shanhw.fifthDay;

  3. import java.io.BufferedReader;
  4. import java.io.BufferedWriter;
  5. import java.io.InputStreamReader;
  6. import java.io.OutputStreamWriter;
  7. import java.net.ServerSocket;
  8. import java.net.Socket;

  10. public class TestTCPChatSingleProcess {

  12.         /**
  13.          * TCP聊天
  14.          */
  15.         public static void main(String[] args) throws InterruptedException {
  16.                 TCPChatServer ts = new  TCPChatServer();
  17.                 new Thread(ts).start();
  18.                 TCPChatClient tc = new  TCPChatClient();
  19.                 new Thread(tc).start();
  20.         }
  21. }
  22. /**
  23. * TCP聊天：客户端
  24. */
  25. class TCPChatClient implements Runnable{

  27.         public void run() {
  28.                 try {
  29.                         System.out.println("Client……");
  30.                         Socket socket = new Socket("192.168.1.100", 10005);
  31.                         // 键盘录入流
  32.                         BufferedReader br = new BufferedReader(new InputStreamReader(
  33.                                         System.in));
  34.                         // 要写入服务端的输出流
  35.                         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket
  36.                                         .getOutputStream()));
  37.                         String len = null;
  38.                         while ((len = br.readLine()) != null) {
  39.                                 if ("over".equals(len)){
  40.                                         System.out.println("Client 关闭成功");
  41.                                         break;
  42.                                 }
  43.                                 bw.write(len);
  44.                                 bw.newLine();
  45.                                 bw.flush();
  46.                         }
  47.                         System.out.println("2");
  48.                         // 在服务器端返回的信息
  49.                         BufferedReader bufR = new BufferedReader(new InputStreamReader(socket
  50.                                         .getInputStream()));
  51.                         String serverMessage = bufR.readLine();
  52.                         System.out.println("Sever Say ：" + serverMessage);

  54.                         br.close();
  55.                         // 关闭服务端
  56.                         socket.close();
  57.                 } catch (Exception e) {
  58.                         throw new RuntimeException("客户端运行时错误");
  59.                 }
  60.         }
  61. }
  62. /**
  63. * TCP聊天：服务端
  64. */
  65. class TCPChatServer implements Runnable {

  67.         public void run() {
  68.                 try {
  69.                         System.out.println("Server……");
  70.                         ServerSocket ss = new ServerSocket(10005);
  71.                         // 得到客户端socket对象
  72.                         Socket socket = ss.accept();
  73.                         BufferedReader br = new BufferedReader(new InputStreamReader(socket
  74.                                         .getInputStream()));
  75.                         String clientMessage = br.readLine();
  76.                         System.out.println("Clinet Say：" + clientMessage);
  77.                         // 键盘录入流
  78.                         BufferedReader bufR = new BufferedReader(new InputStreamReader(
  79.                                         System.in));
  80.                         // 要写入服务端的输出流
  81.                         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
  82.                                         socket.getOutputStream()));
  83.                         String len = null;
  84.                         while ((len = bufR.readLine()) != null) {
  85.                                 if ("over".equals(len)) {
  86.                                         System.out.println("Server 关闭成功");
  87.                                         break;
  88.                                 }
  89.                                 bw.write(len.toUpperCase());
  90.                                 bw.newLine();
  91.                                 bw.flush();
  92.                         }
  93.                         bufR.close();
  94.                         // 关闭客户端，选择性关闭服务端
  95.                         socket.close();
  96.                         ss.close();
  97.                 } catch (Exception e) {
  98.                         throw new RuntimeException("服务端运行时错误");
  99.                 }
  100.         }

  102. }
复制代码
作者: BitmapFactory    时间: 2013-3-16 22:41
本帖最后由 张学林 于 2013-3-16 22:52 编辑

不知道你的需求是什么，我把需求改成了：（可能改变了你的本意，可做参考）
客户端向服务端发送数据，服务端将收到的数据变成大写，再返给客户端
客户端将收到的数据打印在控制台上，当客户端输入over时，服务端将客户端连接关掉，客户端自己也关掉
你的问题出现在了标号<1>处（84行）导致49行和93行阻塞等待读取数据
  1. import java.io.BufferedReader;
  2. import java.io.BufferedWriter;
  3. import java.io.InputStreamReader;
  4. import java.io.OutputStreamWriter;
  5. import java.net.ServerSocket;
  6. import java.net.Socket;

  8. public class TestTCPChatSingleProcess {

  10.         /**
  11.          * TCP聊天
  12.          */
  13.         public static void main(String[] args) throws InterruptedException {
  14.                 TCPChatServer ts = new TCPChatServer();
  15.                 new Thread(ts).start();
  16.                 TCPChatClient tc = new TCPChatClient();
  17.                 new Thread(tc).start();
  18.         }
  19. }

  21. /**
  22. * TCP聊天：客户端
  23. */
  24. class TCPChatClient implements Runnable {

  26.         public void run() {
  27.                 try {
  28.                         // System.out.println("Client……");
  29.                         Socket socket = new Socket("127.0.0.1", 10005);
  30.                         // 键盘录入流
  31.                         BufferedReader br = new BufferedReader(new InputStreamReader(
  32.                                         System.in));
  33.                         // 要写入服务端的输出流
  34.                         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
  35.                                         socket.getOutputStream()));
  36.                         //定义一个接收服务端数据的缓冲区
  37.                         BufferedReader br2 = new BufferedReader(new InputStreamReader(
  38.                                         socket.getInputStream()));
  39.                         String len = null;
  40.                         String len2 = null;
  41.                         while ((len = br.readLine()) != null) {//<1>处错误，没有返回给客户端任何数据，使客户端和服务端都等待读取数据
  42.                                 if ("over".equals(len)) {
  43.                                         System.out.println("Client 关闭成功");
  44.                                         break;
  45.                                 }
  46.                                 bw.write(len);
  47.                                 bw.newLine();
  48.                                 bw.flush();
  49.                                 len2 = br2.readLine();// 接收服务器转换后的数据
  50.                                 System.out.println(len2 + ".........这是服务端转好的数据");
  51.                         }
  52.                         socket.shutdownOutput();
  53.                         System.out.println("2");
  54.                         // 在服务器端返回的信息
  55.                         BufferedReader bufR = new BufferedReader(new InputStreamReader(
  56.                                         socket.getInputStream()));
  57.                         String serverMessage = bufR.readLine();
  58.                         System.out.println("Sever Say ：" + serverMessage);

  60.                         br.close();
  61.                         // 关闭服务端
  62.                         socket.close();
  63.                 } catch (Exception e) {
  64.                         throw new RuntimeException("客户端运行时错误");
  65.                 }
  66.         }
  67. }

  69. /**
  70. * TCP聊天：服务端
  71. */
  72. class TCPChatServer implements Runnable {

  74.         public void run() {
  75.                 try {
  76.                         System.out.println("Server……");
  77.                         ServerSocket ss = new ServerSocket(10005);
  78.                         // 得到客户端socket对象
  79.                         Socket socket = ss.accept();
  80.                         System.out.println(socket.getInetAddress().getHostAddress()
  81.                                         + "......connection");
  82.                         BufferedReader br = new BufferedReader(new InputStreamReader(socket
  83.                                         .getInputStream()));
  84.                         // String clientMessage = br.readLine();//<1>错误出在这里了当服务端接收这个之后，
  85.                         // System.out.println("Clinet Say：" + clientMessage);
  86.                         // 键盘录入流
  87.                         // BufferedReader bufR = new BufferedReader(new InputStreamReader(
  88.                         // System.in));
  89.                         // 要写入服务端的输出流
  90.                         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
  91.                                         socket.getOutputStream()));
  92.                         String len = null;
  93.                         while ((len = br.readLine()) != null) {//<1>处错误，没有返回给客户端任何数据，使客户端和服务端都等待读取数据
  94.                                 if ("over".equals(len)) {
  95.                                         System.out.println("Server 关闭成功");
  96.                                         break;
  97.                                 }
  98.                                 System.out.println(len + ".........这是从客户端接收的数据");
  99.                                 bw.write(len.toUpperCase());
  100.                                 bw.newLine();
  101.                                 bw.flush();
  102.                         }
  103.                         bw.write("接收数据完毕，服务端将干掉客户端!!");
  104.                         bw.newLine();
  105.                         bw.close();
  106.                         br.close();
  107.                         // 关闭客户端，选择性关闭服务端
  108.                         socket.close();
  109.                         ss.close();
  110.                 } catch (Exception e) {
  111.                         throw new RuntimeException("服务端运行时错误");
  112.                 }
  113.         }

  115. }
复制代码
作者: 唐宋博宇    时间: 2013-3-16 23:35
张学林 发表于 2013-3-16 22:41
不知道你的需求是什么，我把需求改成了：（可能改变了你的本意，可做参考）
客户端向服务端发送数据，服务 ...

很感谢你的耐心回复，毕向东老师的网络编程视频我也看了 嘿嘿、、、你的指正很好、、、不过 我想要的是TCP：聊天（服务端和客户端的聊天），我已经修改好了，代码，你看看
  1. package com.shanhw.fifthDay;

  3. import java.io.BufferedReader;
  4. import java.io.BufferedWriter;
  5. import java.io.InputStreamReader;
  6. import java.io.OutputStreamWriter;
  7. import java.net.ServerSocket;
  8. import java.net.Socket;

  10. public class TestTCPChatSingleProcess {

  12.         /**
  13.          * TCP：聊天
  14.          */
  15.         public static void main(String[] args) {
  16.                 TCPChatServer ts = new TCPChatServer();
  17.                 new Thread(ts).start();
  18.                 TCPChatClient tc = new TCPChatClient();
  19.                 new Thread(tc).start();
  20.         }
  21. }
  22. /**
  23. * TCP：客户端
  24. */
  25. class TCPChatClient implements Runnable{

  27.         public void run() {
  28.                 try {
  29.                         System.out.println("Client……");
  30.                         Socket socket = new Socket("192.168.1.100", 10005);
  31.                         // 键盘录入流
  32.                         BufferedReader br = new BufferedReader(new InputStreamReader(
  33.                                         System.in));
  34.                         // 要写入服务端的输出流
  35.                         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket
  36.                                         .getOutputStream()));
  37.                         // 定义socket读取流，服务器端返回的信息
  38.                         BufferedReader bufR = new BufferedReader(new InputStreamReader(socket
  39.                                         .getInputStream()));
  40.                         String len = null;
  41.                         while ((len = br.readLine()) != null) {
  42.                                 if ("over".equals(len)){
  43.                                         System.out.println("Client 关闭成功");
  44.                                         break;
  45.                                 }
  46.                                 bw.write(len);
  47.                                 bw.newLine();
  48.                                 bw.flush();

  50.                                 String serverMessage = bufR.readLine();
  51.                                 System.out.println("Sever Say ：" + serverMessage);
  52.                         }

  54.                         br.close();
  55.                         // 关闭服务端
  56.                         socket.close();
  57.                 } catch (Exception e) {
  58.                         throw new RuntimeException("客户端运行时错误");
  59.                 }
  60.         }
  61. }
  62. /**
  63. * TCP：服务端
  64. */
  65. class TCPChatServer implements Runnable{

  67.         public void run() {
  68.                 try {
  69.                         System.out.println("Server……");
  70.                         ServerSocket ss = new ServerSocket(10005);
  71.                         // 得到客户端socket对象
  72.                         Socket socket = ss.accept();
  73.                         // socket读取流
  74.                         BufferedReader bufIn = new BufferedReader(new InputStreamReader(socket
  75.                                         .getInputStream()));
  76.                         // 要写入服务端的输出流
  77.                         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
  78.                                         socket.getOutputStream()));
  79.                         // 键盘录入流
  80.                         BufferedReader br = new BufferedReader(new InputStreamReader(
  81.                                         System.in));
  82.                         String len = null;
  83.                         while ((len = bufIn.readLine()) != null) {
  84.                                 System.out.println("Clinet Say：" + len);
  85.                                 if ("over".equals(len)) {
  86.                                         System.out.println("Server 关闭成功");
  87.                                         break;
  88.                                 }
  89.                                 bw.write(br.readLine());
  90.                                 bw.newLine();
  91.                                 bw.flush();
  92.                         }
  93.                         bufIn.close();
  94.                         // 关闭客户端，选择性关闭服务端
  95.                         socket.close();
  96.                         ss.close();
  97.                 } catch (Exception e) {
  98.                         throw new RuntimeException("服务端运行时错误");
  99.                 }
  100.         }
  101. }
复制代码




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