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

复制代码

为什么Socket s = ss.accept();不能拿到循环外面？难道它有类似同步锁的功能？

拿到循环外面服务器玩一次就不干了~

放循环里面可以不停地监听端口,一旦有连接过来时,就可以为这个连接创建线程,为其服务.
要是拿出来,那就只能对一个客户端进行服务.

没有同步锁的功能，放在循环是为了不停地执行，以便不停的监听，放在循环外执行一次就完了