黑马程序员技术交流社区

标题: 我的”发送成功“哪里去了？TCP的发送问题 [打印本页]
作者: 黄玉昆    时间: 2013-3-10 15:50
标题: 我的”发送成功“哪里去了？TCP的发送问题
本帖最后由 黄玉昆 于 2013-3-10 16:56 编辑
  1. /*
  2. TCP赋值文件
  3. */

  5. import java.io.*;
  6. import java.net.*;

  8. //客户端
  9. class CopyClient
  10. {
  11.         public static void main(String[] args)
  12.         {
  13.                 //定义全局变量
  14.                 Socket s = null;
  15.                 try
  16.                 {
  17.                         s = new Socket("192.168.1.101",10003);
  18.                 }
  19.                 catch (IOException e)
  20.                 {
  21.                         throw new RuntimeException("创建连接失败");
  22.                 }
  23.                 BufferedReader bufr = null;
  24.                 try
  25.                 {
  26.                         //创建读取流，读取指定文件
  27.                         bufr = new BufferedReader(new FileReader("D:\\File\\udp.java"));
  28.                         //创建写入缓冲区，写入网络输出流中
  29.                         BufferedWriter bufOut =
  30.                                 new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
  31.                         //读取文本，并写入流中
  32.                         String line = null;
  33.                         while((line=bufr.readLine())!=null)
  34.                         {
  35.                                 bufOut.write(line);
  36.                                 bufOut.newLine();
  37.                                 bufOut.flush();
  38.                         }
  39.                         //关闭客户端的输出流。
  40.                         s.shutdownOutput();
  41.                         //创建读取流，读取网络输入流
  42.                         BufferedReader bufIn =
  43.                                 new BufferedReader(new InputStreamReader(s.getInputStream()));
  44.                         //读取反馈信息
  45.                         String str = bufIn.readLine();//应该是这出问题了-------------------------------------------------《《《《《《这里
  46.                         System.out.println(str);
  47.                 }
  48.                 catch (IOException e)
  49.                 {
  50.                         throw new RuntimeException("发送失败");
  51.                 }
  52.                 //关闭流资源
  53.                 finally
  54.                 {
  55.                         try
  56.                         {
  57.                                 if(bufr!=null)
  58.                                         bufr.close();
  59.                                 s.close();
  60.                         }
  61.                         catch (IOException e)
  62.                         {
  63.                                 throw new RuntimeException("资源关闭失败");
  64.                         }
  65.                 }
  66.         }
  67. }

  69. //服务端
  70. class CopyServer
  71. {
  72.         public static void main(String[] args)
  73.         {
  74.                 //定义全局变量
  75.                 ServerSocket ss = null;
  76.                 Socket s= null;
  77.                 try
  78.                 {
  79.                         //创建服务，接收客户端数据
  80.                         ss = new ServerSocket(10003);
  81.                         s= ss.accept();
  82.                         String ip = s.getInetAddress().getHostAddress();
  83.                         System.out.println(ip+"....connected");
  84.                 }
  85.                 catch (IOException e)
  86.                 {
  87.                         throw new RuntimeException("连接失败");
  88.                 }
  89.                 BufferedWriter bufw = null;
  90.                 try
  91.                 {
  92.                         //创建写入流
  93.                         bufw = new BufferedWriter(new FileWriter("server.txt"));
  94.                         //创建读取流
  95.                         BufferedReader bufIn =
  96.                                 new BufferedReader(new InputStreamReader(s.getInputStream()));
  97.                         String line = null;
  98.                         //读取网络输入流数据
  99.                         while((line=bufIn.readLine())!=null)
  100.                         {
  101.                                 bufw.write(line);
  102.                                 bufw.newLine();
  103.                                 bufw.flush();
  104.                         }
  105.                         //创建写入流，反馈给客户端信息
  106.                         BufferedWriter bufOut =
  107.                                 new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
  108.                         bufOut.write("发送成功");

  110.                 }
  111.                 catch (IOException e)
  112.                 {
  113.                         throw new RuntimeException("发送失败");
  114.                 }
  115.                 //关闭流资源
  116.                 finally
  117.                 {
  118.                         try
  119.                         {
  120.                                 if(bufw!=null)
  121.                                         bufw.close();
  122.                                 s.close();
  123.                                 ss.close();
  124.                         }
  125.                         catch (IOException e)
  126.                         {
  127.                                 throw new RuntimeException("资源关闭失败");
  128.                         }
  129.                 }
  130.         }
  131. }
复制代码
最后打印结果是null。请大家帮忙解答，谢谢
问题已解决，谢谢大家的回答
作者: BitmapFactory    时间: 2013-3-10 16:04
本帖最后由 张学林 于 2013-3-10 16:06 编辑

/*
TCP赋值文件
*/

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

//客户端
public class CopyClient {
        public static void main(String[] args) {
                // 定义全局变量
                Socket s = null;
                try {
                        s = new Socket("127.0.0.1", 10003);
                } catch (IOException e) {
                        throw new RuntimeException("创建连接失败");
                }
                BufferedReader bufr = null;
                try {
                        // 创建读取流，读取指定文件
                        bufr = new BufferedReader(new FileReader("C:\\6.txt"));
                        // 创建写入缓冲区，写入网络输出流中
                        BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s
                                        .getOutputStream()));
                        // 读取文本，并写入流中
                        String line = null;
                        while ((line = bufr.readLine()) != null) {
                                bufOut.write(line);
                                bufOut.newLine();
                                bufOut.flush();
                        }
                        // 关闭客户端的输出流。
                        s.shutdownOutput();
                        // 创建读取流，读取网络输入流
                        BufferedReader bufIn = new BufferedReader(new InputStreamReader(s
                                        .getInputStream()));
                        // 读取反馈信息
                        String str = bufIn.readLine();// 应该是这出问题了-------------------------------------------------《《《《《《这里
                        System.out.println(str);
                } catch (IOException e) {
                        throw new RuntimeException("发送失败");
                }
                // 关闭流资源
                finally {
                        try {
                                if (bufr != null)
                                        bufr.close();
                                s.close();
                        } catch (IOException e) {
                                throw new RuntimeException("资源关闭失败");
                        }
                }
        }
}

// 服务端
class CopyServer {
        public static void main(String[] args) {
                // 定义全局变量
                ServerSocket ss = null;
                Socket s = null;
                try {
                        // 创建服务，接收客户端数据
                        ss = new ServerSocket(10003);
                        s = ss.accept();
                        String ip = s.getInetAddress().getHostAddress();
                        System.out.println(ip + "....connected");
                } catch (IOException e) {
                        throw new RuntimeException("连接失败");
                }
                BufferedWriter bufw = null;
                try {
                        // 创建写入流
                        bufw = new BufferedWriter(new FileWriter("c:\\server.txt"));
                        // 创建读取流
                        BufferedReader bufIn = new BufferedReader(new InputStreamReader(s
                                        .getInputStream()));
                        String line = null;
                        // 读取网络输入流数据
                        while ((line = bufIn.readLine()) != null) {
                                bufw.write(line);
                                bufw.newLine();
                                bufw.flush();
                        }
                        // 创建写入流，反馈给客户端信息
                        BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s
                                        .getOutputStream()));
                        bufOut.write("发送成功");
                        bufOut.flush();//这里没有刷新或是不刷新，直接在finally里关流

                } catch (IOException e) {
                        throw new RuntimeException("发送失败");
                }
                // 关闭流资源
                finally {
                        try {
                                if (bufw != null)
                                        bufw.close();
                                s.close();
                                ss.close();
                        } catch (IOException e) {
                                throw new RuntimeException("资源关闭失败");
                        }
                }
        }
}
作者: 戴乾刚    时间: 2013-3-10 16:37
  1. /*

  3. TCP赋值文件

  5. */


  8. import java.io.*;

  10. import java.net.*;


  13. //客户端

  15. class CopyClient

  17. {
  18.         public static void main(String[] args)
  19.         {
  20.                 //定义全局变量
  21.                 Socket s = null;
  22.                 try
  23.                 {
  24.                         s = new Socket("127.0.0.1",10003);
  25.                 }
  26.                 catch (IOException e)
  27.                 {
  28.                         throw new RuntimeException("创建连接失败");
  29.                 }
  30.                 BufferedReader bufr = null;
  31.                 try
  32.                 {
  33.                         //创建读取流，读取指定文件
  34.                         bufr = new BufferedReader(new FileReader("Demo.java"));

  36.                         //创建写入缓冲区，写入网络输出流中
  37.                         BufferedWriter bufOut =
  38.                                 new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

  40.                         //读取文本，并写入流中
  41.                         String line = null;
  42.                         while((line=bufr.readLine())!=null)
  43.                         {
  44.                                 bufOut.write(line);
  45.                                 bufOut.newLine();
  46.                                 bufOut.flush();
  47.                         }
  48.                         //关闭客户端的输出流。
  49.                         s.shutdownOutput();
  50.                         //创建读取流，读取网络输入流
  51.                         BufferedReader bufIn =
  52.                                 new BufferedReader(new InputStreamReader(s.getInputStream()));
  53.                         //读取反馈信息
  54.                         String str = bufIn.readLine();//应该是这出问题了-------------------------------------------------《《《《《《这里
  55.                         System.out.println(str);
  56.                 }
  57.                 catch (IOException e)
  58.                 {
  59.                         throw new RuntimeException("发送失败");
  60.                 }
  61.                 //关闭流资源
  62.                 finally
  63.                 {
  64.                         try
  65.                         {
  66.                                 if(bufr!=null)
  67.                                         bufr.close();
  68.                                 s.close();
  69.                         }
  70.                         catch (IOException e)
  71.                         {
  72.                                 throw new RuntimeException("资源关闭失败");
  73.                         }
  74.                 }
  75.         }
  76. }


  79. //服务端

  81. class CopyServer
  82. {
  83.         public static void main(String[] args)
  84.         {
  85.                 //定义全局变量
  86.                 ServerSocket ss = null;
  87.                 Socket s= null;
  88.                 try
  89.                 {
  90.                         //创建服务，接收客户端数据
  91.                         ss = new ServerSocket(10003);
  92.                         s= ss.accept();
  93.                         String ip = s.getInetAddress().getHostAddress();
  94.                         System.out.println(ip+"....connected");
  95.                 }
  96.                 catch (IOException e)
  97.                 {
  98.                         throw new RuntimeException("连接失败");
  99.                 }
  100.                 BufferedWriter bufw = null;
  101.                 try
  102.                 {
  103.                         //创建写入流
  104.                         bufw = new BufferedWriter(new FileWriter("server.txt"));
  105.                         //创建读取流
  106.                         BufferedReader bufIn =
  107.                                 new BufferedReader(new InputStreamReader(s.getInputStream()));
  108.                         String line = null;
  109.                         //读取网络输入流数据
  110.                         while((line=bufIn.readLine())!=null)
  111.                         {
  112.                                 bufw.write(line);
  113.                                 bufw.newLine();
  114.                                 bufw.flush();
  115.                         }
  116.                         //创建写入流，反馈给客户端信息
  117.                         BufferedWriter bufOut =
  118.                                 new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
  119.                         bufOut.write("发送成功");
  120.                                                 bufOut.flush();//---------------------------------此处刷新一下！！
  121.                 }
  122.                 catch (IOException e)
  123.                 {
  124.                         throw new RuntimeException("发送失败");
  125.                 }
  126.                 //关闭流资源
  127.                 finally
  128.                 {
  129.                         try
  130.                         {
  131.                                 if(bufw!=null)
  132.                                         bufw.close();
  133.                                 s.close();
  134.                                 ss.close();
  135.                         }
  136.                         catch (IOException e)
  137.                         {
  138.                                 throw new RuntimeException("资源关闭失败");
  139.                         }
  140.                 }
  141.         }
  142. }
复制代码
在服务端的" bufOut.write("发送成功");"后面刷新一下，write只是写到缓冲区中
作者: 黄玉昆    时间: 2013-3-10 16:58
张学林 发表于 2013-3-10 16:04
/*
TCP赋值文件
*/

我下面已经关闭流了，为什么写入缓存的没有刷新呢？是不是Socket中的输出流不提供刷新呢？
作者: 黄玉昆    时间: 2013-3-10 16:59
戴乾刚 发表于 2013-3-10 16:37
在服务端的" bufOut.write("发送成功");"后面刷新一下，write只是写到缓冲区中

我下面已经关闭流了，为什么写入缓存的没有刷新呢？是不是Socket中的输出流不提供刷新呢？
作者: BitmapFactory    时间: 2013-3-10 17:01
黄玉昆 发表于 2013-3-10 16:59
我下面已经关闭流了，为什么写入缓存的没有刷新呢？是不是Socket中的输出流不提供刷新呢？ ...

不一样的流啊
     BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s
                                        .getOutputStream()));
                        bufOut.write("发送成功");
                        bufOut.flush();//这里没有刷新或是不刷新，直接在finally里关流

这个是写入流，如果关Socket流，它还向哪里刷呢
作者: 戴乾刚    时间: 2013-3-10 17:38
本帖最后由 戴乾刚 于 2013-3-10 17:45 编辑
黄玉昆 发表于 2013-3-10 16:58
我下面已经关闭流了，为什么写入缓存的没有刷新呢？是不是Socket中的输出流不提供刷新呢？ ...

write方法是写到buffer缓冲区中，通过flush方法将数据刷新到Socket流中

你关的bufw，不是bufOut

如果直接关Socket对象，那么将数据目的Socket流（也就是客户端的数据源）也给关了
作者: 黑马李超    时间: 2013-3-10 17:49
客服端读取反馈信息后，socket服务才关闭的
作者: 黄玉昆    时间: 2013-3-10 19:58
张学林 发表于 2013-3-10 17:01
不一样的流啊
     BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s
             ...

谢谢解答
作者: 黄玉昆    时间: 2013-3-10 19:58
戴乾刚 发表于 2013-3-10 17:38
write方法是写到buffer缓冲区中，通过flush方法将数据刷新到Socket流中

你关的bufw，不是bufOut

谢谢解答
作者: 黄玉昆    时间: 2013-3-11 12:52
谢谢大家的解答



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