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

复制代码

解释客户端：
25.                if(args.length != 1)

26.                {

27.                        System.out.println("请选择一个jpg格式的图片");

28.                        return;

29.                }

以上是判断有没有输入的内容；

File file = new File(args[0]);

31.                if(!(file.exists() && file.isFile()))

32.                {

33.                        System.out.println("该文件有问题，要么不存在，要么不是文件");

34.                        return;

35.                }

36.                if(!file.getName().endsWith(".jpg"))

37.                {

38.                        System.out.println("图片格式错误，请重新选择");

39.                        return;

40.                }

41.                if(file.length()>1024*1024*5)

42.                {

43.                        System.out.println("文件太大了，我放不下");

44.                        return;

45.                }

以上是判断文件是否存在，限制大小和格式；

Socket s = new Socket("127.0.0.1",10007);这句是连接到ip地址为127.0.0.1的电脑上的10007端口上；
FileInputStream fis = new FileInputStream(file);输入流关联文件，用来读取文件内容；
  OutputStream out = s.getOutputStream();得到客户端的输出流，往里面写东西（写文件内容）；

• byte[] buf = new byte[1024];
•                 int len = 0;
•                 while((len = fis.read(buf)) != -1)
•                 {
•                         out.write(buf,0,len);
•                 }
  

以上是把文件的内容读到一个byte数组中，再写到客户端的输出流里；
InputStream in = s.getInputStream();得到客户端的输入流，里面有服务器端传来的数据；

• byte[] bufIn = new byte[1024];
•                 int num = in.read(bufIn);
•                 System.out.println(new String(bufIn,0,num));
  

以上是读取客户端输入流里面的数据并输出；

下面解释服务器端：

ServerSocket ss = new ServerSocket(10007);开启一个10007端口

• while(true){
•                 Socket s = ss.accept();
•                 new Thread(new PicThread(s)).start();
•                 }
  

以上是得到连接的客户端，并为每个连接的客户端开启一个线程；

解释服务器线程：
InputStream in = s.getInputStream();得到客户端的输入流，里面放有客户端文件内容；

• File file = new File(ip+"("+count+")"+".jpg");
•                         while(file.exists())
•                                 file = new File(ip+"("+(count++)+")"+".jpg");
  

以上是设置存放接收的文件路径和名称；

• FileOutputStream fos = new FileOutputStream(file);
•                         byte[] buf = new byte[1024];
•                         int len = 0;
•                         while((len = in.read(buf)) != -1)
•                         {
•                                 fos.write(buf,0,len);
•                         }
  

以上是把客户端输入流里的内容写到服务器端的文件中；

• OutputStream out = s.getOutputStream();
•                         out.write("上传成功".getBytes());
  

以上是把“上传成功”变成字节写到客户端的输出流中。


翻译完毕！写那么多快累死本人了，没有功劳也有苦劳，请加分，谢谢！

侯伟浩 发表于 2011-12-12 10:23
解释客户端：
25.                if(args.length != 1)

谢谢！！