1. /*
   
2. 需求：上传图片。
   
3. 
   
4. 
   
5. 
   
6. */
   
7. /*
   
8. 客户端。
   
9. 1，服务端点。
   
10. 2，读取客户端已有的图片数据。
    
11. 3，通过socket 输出流将数据发给服务端。
    
12. 4，读取服务端反馈信息。
    
13. 5，关闭。
    
14. 
    
15. */
    
16. 
    
17. import java.io.*;
    
18. import java.net.*;
    
19. class  PicClient
    
20. {
    
21.         public static void main(String[] args)throws Exception
    
22.         {
    
23.                 if(args.length!=1)
    
24.                 {
    
25.                         System.out.println("请选择一个jpg格式的图片");
    
26.                         return ;
    
27.                 }
    
28. 
    
29. 
    
30. 
    
31. 
    
32.                 File file = new File(args[0]);
    
33.                 if(!(file.exists() && file.isFile()))
    
34.                 {
    
35.                         System.out.println("该文件有问题，要么补存在，要么不是文件");
    
36.                         return ;
    
37. 
    
38.                 }
    
39. 
    
40.                 if(!file.getName().endsWith(".jpg"))
    
41.                 {
    
42.                         System.out.println("图片格式错误,请重新选择");
    
43.                         return ;
    
44.                 }
    
45. 
    
46.                 if(file.length()>1024*1024*5)
    
47.                 {
    
48.                         System.out.println("文件过大，没安好心");
    
49.                         return ;
    
50.                 }
    
51.                
    
52. 
    
53. 
    
54. 
    
55.                 Socket s = new Socket("192.168.1.254",10007);
    
56. 
    
57.                 FileInputStream fis = new FileInputStream(file);
    
58. 
    
59.                 OutputStream out = s.getOutputStream();
    
60. 
    
61.                 byte[] buf = new byte[1024];
    
62. 
    
63.                 int len = 0;
    
64. 
    
65.                 while((len=fis.read(buf))!=-1)
    
66.                 {
    
67.                         out.write(buf,0,len);
    
68.                 }
    
69. 
    
70.                 //告诉服务端数据已写完
    
71.                 s.shutdownOutput();
    
72. 
    
73.                 InputStream in = s.getInputStream();
    
74. 
    
75.                 byte[] bufIn = new byte[1024];
    
76. 
    
77.                 int num = in.read(bufIn);
    
78.                 System.out.println(new String(bufIn,0,num));
    
79. 
    
80.                 fis.close();
    
81.                 s.close();
    
82.         }
    
83. }
    
84. 
    
85. /*
    
86. 服务端
    
87. 
    
88. 这个服务端有个局限性。当A客户端连接上以后。被服务端获取到。服务端执行具体流程。
    
89. 这时B客户端连接，只有等待。
    
90. 因为服务端还没有处理完A客户端的请求，还有循环回来执行下次accept方法。所以
    
91. 暂时获取不到B客户端对象。
    
92. 
    
93. 那么为了可以让多个客户端同时并发访问服务端。
    
94. 那么服务端最好就是将每个客户端封装到一个单独的线程中，这样，就可以同时处理多个客户端请求。
    
95. 
    
96. 
    
97. 
    
98. 如何定义线程呢？
    
99. 
    
100. 只要明确了每一个客户端要在服务端执行的代码即可。将该代码存入run方法中。
     
101. */
     
102. 
     
103. class PicThread implements Runnable
     
104. {
     
105. 
     
106.         private Socket s;
     
107.         PicThread(Socket s)
     
108.         {
     
109.                 this.s = s;
     
110.         }
     
111.         public void run()
     
112.         {
     
113. 
     
114.                 int count = 1;
     
115.                 String ip  = s.getInetAddress().getHostAddress();
     
116.                 try
     
117.                 {
     
118.                         System.out.println(ip+"....connected");
     
119. 
     
120.                         InputStream in = s.getInputStream();
     
121. 
     
122.                         File dir =  new File("d:\\pic");
     
123. 
     
124.                         File file = new File(dir,ip+"("+(count)+")"+".jpg");//这里count==1
     
125.                                                                                                                    //等于创建了1号文件
     
126. 
     
127.                         while(file.exists())
     
128.                                 file = new File(dir,ip+"("+(count++)+")"+".jpg");
     
129.                                                                 //这里count++不是也创建了1号文件么？加过之后count
     
130.                                                                 //count不是才等于2么？为什么这个程序运行起来却没有
     
131.                                           //出现文件覆盖的情况呢？
     
132.                         FileOutputStream fos = new FileOutputStream(file);
     
133. 
     
134.                         byte[] buf = new byte[1024];
     
135. 
     
136.                         int len = 0;
     
137.                         while((len=in.read(buf))!=-1)
     
138.                         {
     
139.                                 fos.write(buf,0,len);
     
140.                         }
     
141. 
     
142.                         OutputStream out = s.getOutputStream();
     
143. 
     
144.                         out.write("上传成功".getBytes());
     
145. 
     
146.                         fos.close();
     
147. 
     
148.                         s.close();
     
149.                 }
     
150.                 catch (Exception e)
     
151.                 {
     
152.                         throw new RuntimeException(ip+"上传失败");
     
153.                 }
     
154.         }
     
155. }
     
156. 
     
157. 
     
158. 
     
159. class  PicServer
     
160. {
     
161.         public static void main(String[] args) throws Exception
     
162.         {
     
163.                 ServerSocket ss = new ServerSocket(10007);
     
164. 
     
165.                 while(true)
     
166.                 {
     
167.                         Socket s = ss.accept();
     
168. 
     
169.                         new Thread(new PicThread(s)).start();
     
170. 
     
171.                
     
172.                 }
     
173. 
     
174.                 //ss.close();
     
175.         }
     
176. }
     
177. <FONT size=6>问题见124行
     
178. </FONT>

复制代码

呵呵,你没见那句话前面是个while循环吗?那个循环就是当文件存在的时候才执行那句话,直到文件不存在为止.所以不会覆盖.
在new File对象的时候并不会创建文件.

杨玲 发表于 2013-1-30 17:32
呵呵,你没见那句话前面是个while循环吗?那个循环就是当文件存在的时候才执行那句话,直到文件不存在为止.所 ...

亲你根本没看懂我问的是什么，如果进入循环，count++==1，而不是2就把之前的1覆盖了

李跃达 发表于 2013-1-30 18:10
亲你根本没看懂我问的是什么，如果进入循环，count++==1，而不是2就把之前的1覆盖了 ...

我说哥们,new File对象是不会创建文件的,真正创建文件的是后面的步骤呀!

杨玲 发表于 2013-1-30 21:14
我说哥们,new File对象是不会创建文件的,真正创建文件的是后面的步骤呀!

就是不创建，之前写到那个文件中的东西也会被覆盖的

李跃达 发表于 2013-1-30 22:29
就是不创建，之前写到那个文件中的东西也会被覆盖的

呵呵,难道你的File对象特殊点?File对象只是一个文件对象,只有当你调用它的创建对象的方法或者是与流相关联了以后它才会创建文件.而覆盖发生在创建文件的时候,如果连new个 File对象也要覆盖那就神了奇了,

杨玲 发表于 2013-1-30 23:55
呵呵,难道你的File对象特殊点?File对象只是一个文件对象,只有当你调用它的创建对象的方法或者是与流相关 ...

关键是它除了穿件文件夹之外还有上传一张图片，就是不创建，往1号文件里面上传两次图片，第二次不会把第一次覆盖么