A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

  1. package com.shanhw.fifthDay;

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

  8. public class TestTCPChatSingleProcess {

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

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

  49.                         br.close();
  50.                         // 关闭服务端
  51.                         socket.close();
  52.                 } catch (Exception e) {
  53.                         throw new RuntimeException("客户端运行时错误");
  54.                 }
  55.         }
  56. }
  57. /**
  58. * TCP聊天:服务端
  59. */
  60. class TCPChatServer implements Runnable {

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

  95. }
复制代码

评分

参与人数 1技术分 +1 收起 理由
黄玉昆 + 1

查看全部评分

2 个回复

正序浏览
张学林 发表于 2013-3-16 22:41
不知道你的需求是什么,我把需求改成了:(可能改变了你的本意,可做参考)
客户端向服务端发送数据,服务 ...

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

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

  8. public class TestTCPChatSingleProcess {

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

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

  45.                                 String serverMessage = bufR.readLine();
  46.                                 System.out.println("Sever Say :" + serverMessage);
  47.                         }

  48.                         br.close();
  49.                         // 关闭服务端
  50.                         socket.close();
  51.                 } catch (Exception e) {
  52.                         throw new RuntimeException("客户端运行时错误");
  53.                 }
  54.         }
  55. }
  56. /**
  57. * TCP:服务端
  58. */
  59. class TCPChatServer implements Runnable{

  60.         public void run() {
  61.                 try {
  62.                         System.out.println("Server……");
  63.                         ServerSocket ss = new ServerSocket(10005);
  64.                         // 得到客户端socket对象
  65.                         Socket socket = ss.accept();
  66.                         // socket读取流
  67.                         BufferedReader bufIn = new BufferedReader(new InputStreamReader(socket
  68.                                         .getInputStream()));
  69.                         // 要写入服务端的输出流
  70.                         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
  71.                                         socket.getOutputStream()));
  72.                         // 键盘录入流
  73.                         BufferedReader br = new BufferedReader(new InputStreamReader(
  74.                                         System.in));
  75.                         String len = null;
  76.                         while ((len = bufIn.readLine()) != null) {
  77.                                 System.out.println("Clinet Say:" + len);
  78.                                 if ("over".equals(len)) {
  79.                                         System.out.println("Server 关闭成功");
  80.                                         break;
  81.                                 }
  82.                                 bw.write(br.readLine());
  83.                                 bw.newLine();
  84.                                 bw.flush();
  85.                         }
  86.                         bufIn.close();
  87.                         // 关闭客户端,选择性关闭服务端
  88.                         socket.close();
  89.                         ss.close();
  90.                 } catch (Exception e) {
  91.                         throw new RuntimeException("服务端运行时错误");
  92.                 }
  93.         }
  94. }
复制代码
回复 使用道具 举报
本帖最后由 张学林 于 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;

  7. public class TestTCPChatSingleProcess {

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

  18. /**
  19. * TCP聊天:客户端
  20. */
  21. class TCPChatClient implements Runnable {

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

  55.                         br.close();
  56.                         // 关闭服务端
  57.                         socket.close();
  58.                 } catch (Exception e) {
  59.                         throw new RuntimeException("客户端运行时错误");
  60.                 }
  61.         }
  62. }

  63. /**
  64. * TCP聊天:服务端
  65. */
  66. 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.                         System.out.println(socket.getInetAddress().getHostAddress()
  74.                                         + "......connection");
  75.                         BufferedReader br = new BufferedReader(new InputStreamReader(socket
  76.                                         .getInputStream()));
  77.                         // String clientMessage = br.readLine();//<1>错误出在这里了当服务端接收这个之后,
  78.                         // System.out.println("Clinet Say:" + clientMessage);
  79.                         // 键盘录入流
  80.                         // BufferedReader bufR = new BufferedReader(new InputStreamReader(
  81.                         // System.in));
  82.                         // 要写入服务端的输出流
  83.                         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
  84.                                         socket.getOutputStream()));
  85.                         String len = null;
  86.                         while ((len = br.readLine()) != null) {//<1>处错误,没有返回给客户端任何数据,使客户端和服务端都等待读取数据
  87.                                 if ("over".equals(len)) {
  88.                                         System.out.println("Server 关闭成功");
  89.                                         break;
  90.                                 }
  91.                                 System.out.println(len + ".........这是从客户端接收的数据");
  92.                                 bw.write(len.toUpperCase());
  93.                                 bw.newLine();
  94.                                 bw.flush();
  95.                         }
  96.                         bw.write("接收数据完毕,服务端将干掉客户端!!");
  97.                         bw.newLine();
  98.                         bw.close();
  99.                         br.close();
  100.                         // 关闭客户端,选择性关闭服务端
  101.                         socket.close();
  102.                         ss.close();
  103.                 } catch (Exception e) {
  104.                         throw new RuntimeException("服务端运行时错误");
  105.                 }
  106.         }

  107. }
复制代码

评分

参与人数 1技术分 +1 收起 理由
黄玉昆 + 1

查看全部评分

回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马