1. /*
   
2. TCP赋值文件
   
3. */
   
4. 
   
5. import java.io.*;
   
6. import java.net.*;
   
7. 
   
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. }
    
68. 
    
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("发送成功");
     
109. 
     
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。请大家帮忙解答，谢谢
问题已解决，谢谢大家的回答

谢谢大家的解答

戴乾刚 发表于 2013-3-10 17:38
write方法是写到buffer缓冲区中，通过flush方法将数据刷新到Socket流中

你关的bufw，不是bufOut

谢谢解答

张学林 发表于 2013-3-10 17:01
不一样的流啊
     BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s
             ...

谢谢解答

客服端读取反馈信息后，socket服务才关闭的

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

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

你关的bufw，不是bufOut

如果直接关Socket对象，那么将数据目的Socket流（也就是客户端的数据源）也给关了

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

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

这个是写入流，如果关Socket流，它还向哪里刷呢

戴乾刚 发表于 2013-3-10 16:37
在服务端的" bufOut.write("发送成功");"后面刷新一下，write只是写到缓冲区中

我下面已经关闭流了，为什么写入缓存的没有刷新呢？是不是Socket中的输出流不提供刷新呢？

张学林 发表于 2013-3-10 16:04
/*
TCP赋值文件
*/

我下面已经关闭流了，为什么写入缓存的没有刷新呢？是不是Socket中的输出流不提供刷新呢？

1. /*
   
2. 
   
3. TCP赋值文件
   
4. 
   
5. */
   
6. 
   
7. 
   
8. import java.io.*;
   
9. 
   
10. import java.net.*;
    
11. 
    
12. 
    
13. //客户端
    
14. 
    
15. class CopyClient
    
16. 
    
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"));
    
35. 
    
36.                         //创建写入缓冲区，写入网络输出流中
    
37.                         BufferedWriter bufOut =
    
38.                                 new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
    
39. 
    
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. }
    
77. 
    
78. 
    
79. //服务端
    
80. 
    
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只是写到缓冲区中

/*
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("资源关闭失败");
                        }
                }
        }
}