基于applet的FTP断点上传组件（一）

公司项目上需要一个拖曳的组件，花了二周时间写了一个支持FTP和HTTP的上传组件，其中FTP支持断点续传

下面只介绍FTP的相关部分。

我们知道，FTP协议的底层协议是TCP协议，三次握手，可以建立持续的连接和服务器相互通信，和服务器建立相应的socket后，只需要发送相关的指令就可以了，

传输数据需要建立新的socket来和服务器通信。

applet客户端所做的事就是写相关的FTP客户端，然后与服务器通信。

先从FTPClient着手,写一个FTP客户端

 

1. package ftpupload;
3. import java.io.BufferedInputStream;
4. import java.io.BufferedOutputStream;
5. import java.io.DataOutputStream;
6. import java.io.FileInputStream;
7. import java.io.FileNotFoundException;
8. import java.io.IOException;
9. import java.io.OutputStream;
10. import java.net.InetAddress;
11. import java.net.SocketException;
12. import java.net.UnknownHostException;
14. /**
15.  * 
16.  * @author BruceXX
17.  *
18.  */
20. public class FTPClient {
22.     
23.     
24.     
25.     private int ControlPort;
26.     private String controlEncoding;
27.     private boolean cancelTransfer;
28.     private boolean detectTransferMode;
29.     private long monitorInterval;
30.     private int transferBufferSize;
31.     private FTPControlSocket control;
32.     private int timeout;
33.     protected InetAddress remoteAddress;
34.     private FTPReply lastReply;
35.     protected FTPProcessListener listener;
36.     private FTPDataSocket data;
37.     private boolean isASCII;
38.     
39.     private long startSize;
40.     private volatile boolean handling;
41.     private volatile boolean over;
43.     public FTPClient(){
44.         
45.         this.ControlPort=21;
46.         this.controlEncoding="uTF-8";
47.         this.cancelTransfer=false;
48.         this.detectTransferMode=true;
49.         this.monitorInterval=10*1024L;
50.         this.transferBufferSize=16384;
51.         this.handling=true;
52.         this.over=false;
53.     }
54.     
55.     /**
56.      * 建立连接
57.      * @throws FTPException
58.      * @throws SocketException
59.      * @throws IOException
60.      */
61.     
62.     public void connect() throws FTPException, SocketException, IOException{
63.         
64.         checkConnection(false);
65.         initalize(new FTPControlSocket(remoteAddress,ControlPort,timeout,controlEncoding));
66.     }
67.     
68.     
69.     /**
70.      * 登陆
71.      * @param user
72.      * @param password
73.      * @throws FTPException
74.      * @throws IOException
75.      */
76.     public void login(String user,String password) throws FTPException, IOException{
77.         
78.         user(user);
79.         pass(password);
81.     }
83.     
84.     public void user(String user) throws FTPException, IOException{
85.         
86.         sendCommand("USER",user,"230,331");
87.     }
88.     
89.     public void pass(String pass) throws FTPException, IOException{
90.         
91.         sendCommand("PASS",pass,"230,202,332");
92.     }
93.     
94.     /**
95.      * 进入某个目录
96.      * @param dir
97.      * @throws FTPException
98.      * @throws IOException
99.      */
100.     
101.     public void cd(String dir) throws FTPException, IOException{
102.         
103.         sendCommand("CWD",dir,"250");
104.         
105.     }
106.     
107.     /**
108.      * 创建文件夹
109.      * @param dir
110.      * @throws FTPException
111.      * @throws IOException
112.      */
113.     
114.     public void mkdir(String dir) throws FTPException, IOException{
115.         
116.         sendCommand("MKD",dir,"200,250,257");
117.     }
118.     
119.     /**
120.      * 退出连接
121.      * @throws FTPException
122.      * @throws IOException
123.      */
124.     public void quit() throws FTPException, IOException{
125.         sendCommand("QUIT", null, "221,226");
126.         
127.     }
128.     
129.     /**
130.      * 获取远程文件的大小
131.      * @param remoteFile
132.      * @return
133.      * @throws FTPException
134.      * @throws IOException
135.      */
136.     
137.     public long getSize(String remoteFile) throws FTPException, IOException{
138.         
139.         checkConnection(true);
140.         FTPReply replay=control.sendCommand("SIZE "+remoteFile);    
141.         String replyText=replay.getReplyText();
142.         int pos=replyText.indexOf(' ');
143.         if(pos>0)
144.             replyText=replyText.substring(0,pos);
145.         try{
146.         return Long.parseLong(replyText);
147.         }catch(NumberFormatException e){
148.             return 0L;
149.         }
150.     }
151.     /**
152.      * 设置文件传输的类型,FTP有两种，一种是BINARY,第二种是ASCII,我试验了一下，貌似binary可以传任何类型的，不像网上说的那些文本之类的需要用ASCII来传输
153.      * @param type
154.      * @throws FTPException
155.      * @throws IOException
156.      */
157.     
158.     private void sendTransferType(String type) throws FTPException, IOException{
159.         
160.         sendCommand("TYPE", type, "200");
161.     }
162.     
163.     /**
164.      * 根据文件名自动选择传输类型
165.      * @param filename
166.      * @throws FTPException
167.      * @throws IOException
168.      */
169.     
170.     public void autoChooseType(String filename) throws FTPException, IOException{
171.         
172.         if(detectTransferMode){
173.             
174.             if(FTPFileType.matchASCII(filename)){
175.                 isASCII=true;
176.                 sendTransferType("A");
177.             }               
178.             else{
179.                 isASCII=false;
180.                 sendTransferType("I");              
181.             }
183.         }
184.     }
185.     /**
186.      * 来检验是否传输完毕
187.      * @throws FTPException
188.      * @throws IOException
189.      */
190.     
191.     public void validateTransfer() throws FTPException, IOException{
192.         
193.         handling=true;
194.         checkConnection(true);
195.         String[] rightCode={"225", "226", "250", "426", "450"};
196.         FTPReply reply=control.readReply();
197.         String code=reply.getReplyCode();
198.         if((code.equals("426") || code.equals("450")) && !cancelTransfer)
199.         {
200.             handling=false;
201.             throw new FTPException(reply);
202.         } else
203.         {
204.             
205.             lastReply = control.validateReply(reply, rightCode);
206.             handling=false;
207.             return;
208.         }
209.        
210.     }
211.     /**
212.      * 从某个断点开始续传
213.      * @param startSize
214.      * @throws FTPException
215.      * @throws IOException
216.      */
217.     
218.     public void restart(long startSize) throws FTPException, IOException{
219.         
220.         sendCommand("REST", startSize+"", "350");
221.     }
222.     /**
223.      * 向服务器传输文件
224.      * @param remoteFile
225.      * @throws FTPException
226.      * @throws IOException
227.      */
228.     
229.     public void storefile(String remoteFile) throws FTPException, IOException{
230.         
231.         sendCommand("STOR", remoteFile, "125,150,350");
232.     }
233.     /**
234.      * 从服务器已有文件开始附加文件，续传可以用这个，也可以用STOR,不过STOR要先指定start后才可以
235.      * @param remoteFile
236.      * @throws FTPException
237.      * @throws IOException
238.      */
239.     
240.     public void appendfile(String remoteFile) throws FTPException, IOException{
241.         
242.         sendCommand("APPE", remoteFile, "125,150,350");
243.     }
244.     
245.     /**
246.      * 关闭文件传输流
247.      */
248.     private void closeSocket(){
249.         
250.         
251.             try {
252.                 if(data!=null){
253.                 data.close();
254.                 data=null;}
255.             } catch (IOException e) {
256.                 // TODO Auto-generated catch block
257.                 e.printStackTrace();
258.             }       
259.     }
260.     
261.     /**
262.      * 关闭文件传输流，以及相关的输出流
263.      * @param out
264.      */
265.     
266.     private void closeSocket(OutputStream out){
267.         
268.         
269.             try {
270.                 if(out!=null)
271.                 out.close();
272.             } catch (IOException e) {
273.                 // TODO Auto-generated catch block
274.                 e.printStackTrace();
275.             }
276.             closeSocket();
277.     }
278.     
279.     /**
280.      * 初始化传输条件,即传输之前的指令
281.      * @param remoteFile
282.      * @throws FTPException
283.      */
284.     
285.     private void initTransfer(String remoteFile) throws FTPException{
286.         
287.         checkConnection(true);
288.         cancelTransfer=false;
289.         data=null;
290.         try {
291.             data=control.createDataSocketPASV();
292.             data.setSoTimeOut(timeout);         
293.             startSize=getStartSize(remoteFile);
294.             if(!isASCII){               
295.                 restart(startSize);
296.                 storefile(remoteFile);
297.             }
298.             else{
299.                 appendfile(remoteFile);
300.             }
301.             
302.         } catch (Exception e) {
303.             // TODO Auto-generated catch block
304.             e.printStackTrace();
305.         }
306.         
307.     }
308.     
309.     /**
310.      * 传输文件整体过程
311.      * @param localFile
312.      * @param remoteFile
313.      */
314.     
315.     public void transfer(String localFile,String remoteFile){
316.         
317.         
318.         try {
319.             Subtransfer(localFile, remoteFile);
320.             over=true;
321.             validateTransfer();
322.         } catch (FTPException e) {
323.             // TODO Auto-generated catch block
324.             e.printStackTrace();
325.         } catch (IOException e) {
326.             // TODO Auto-generated catch block
327.             e.printStackTrace();
328.         }
329.     }
330.     
331.     /**
332.      * 传输文件写入过程
333.      * @param localFile
334.      * @param remoteFile
335.      */
336.     public void Subtransfer(String localFile,String remoteFile){
337.         
338.         BufferedInputStream bis=null;
339.         BufferedOutputStream bos=null;
340.         long size = 0L;
341.         
342.         try {
343.             bis=new BufferedInputStream(new FileInputStream(localFile));
344.             initTransfer(remoteFile);
345.             bos=new BufferedOutputStream(new DataOutputStream(data.getOutputStream()),transferBufferSize*2);
346. //          if(!isASCII)
348.             bis.skip(startSize);
349.             byte[] buffer=new byte[transferBufferSize];
350.             byte prevBuf[] = null;
351.             long monitorCount = 0L;
352.             int count = 0;       
353.             int separatorPos = 0;
354.             byte[] linseparator=System.getProperty("line.separator").getBytes();
355.             
356.              while ((count = bis.read(buffer)) > 0 && !cancelTransfer) {
357.                 if (isASCII) {
358.                     for (int i = 0; i < count; i++) {
359.                         boolean found = true;
360.                         int skip = 0;
361.                         for (; separatorPos < linseparator.length
362.                                 && i + separatorPos < count; separatorPos++) {
363.                             if (buffer[i + separatorPos] != linseparator[separatorPos]) {
364.                                 found = false;
365.                                 break;
366.                             }
367.                             skip++;
368.                         }
370.                         if (found) {
371.                             if (separatorPos == linseparator.length) {
372.                                 bos.write(13);
373.                                 bos.write(10);
374.                                 size += 2L;
375.                                 monitorCount += 2L;
376.                                 separatorPos = 0;
377.                                 i += skip - 1;
378.                                 prevBuf = null;
379.                             } else {
380.                                 prevBuf = new byte[skip];
381.                                 for (int k = 0; k < skip; k++)
382.                                     prevBuf[k] = buffer[i + k];
384.                             }
385.                         } else {
386.                             if (prevBuf != null) {
387.                                 bos.write(prevBuf);
388.                                 size += prevBuf.length;
389.                                 monitorCount += prevBuf.length;
390.                                 prevBuf = null;
391.                             }
392.                             bos.write(buffer[i]);
393.                             size++;
394.                             monitorCount++;
395.                             separatorPos = 0;
396.                         }
397.                     }
399.                 } else {
400.                     bos.write(buffer, 0, count);
401.                     size += count;
402.                     monitorCount += count;
403.                 }
404.                 if (prevBuf != null) {
405.                     bos.write(prevBuf);
406.                     size += prevBuf.length;
407.                     monitorCount += prevBuf.length;
408.                 }
409.                 /**
410.                  * 监听器转换数值,一定间隔内刷新数值
411.                  */
412.                 if (listener != null && monitorCount > monitorInterval) {
413.                     listener.getUploadSize(size);
414.                     monitorCount = 0L;
415.                 }
416.                 
417.              }
419.             
420.         } catch (FileNotFoundException e) {
421.             // TODO Auto-generated catch block
422.             e.printStackTrace();
423.         } catch (FTPException e) {
424.             // TODO Auto-generated catch block
425.             e.printStackTrace();
426.         } catch (IOException e) {
427.             // TODO Auto-generated catch block
428.             e.printStackTrace();
429.         }
430.         finally{
431.             
432.                 try {
433.                 if (bis != null)
434.                     bis.close();
435.             } catch (IOException e) {
436.                 // TODO Auto-generated catch block
437.                 e.printStackTrace();
438.             }
439.             closeSocket(bos);
440.             if(listener!=null){
441.                 listener.getUploadSize(size);
442.             }
443.         }
445.     }
446.     
447.     
448.     private void sendCommand(String command,String commandafter,String rightCodeSplit) throws FTPException, IOException{
449.         checkConnection(true);
450.         if(commandafter==null)
451.             commandafter="";
452.         String[] rightCode=rightCodeSplit.split(",");
453.         FTPReply reply=control.sendCommand(command+" "+commandafter);
454.         lastReply=control.validateReply(reply, rightCode);
455.     }
456.     
457.     
458.     /**
459.      * 检验控制流
460.      * @return
461.      */
462.     
463.     public boolean connected(){
464.         return control!=null;
465.     }
466.     
467.     /**
468.      * 检验连接
469.      * @param shouldBeConnected
470.      * @throws FTPException
471.      */
472.     
473.     protected void checkConnection(boolean shouldBeConnected) throws FTPException{
474.         
475.         if(shouldBeConnected && !connected()){
476.             
477.             throw new FTPException("客户端还没有连上服务端");
478.         }
479.         if(!shouldBeConnected && connected()){
480.             
481.             throw new FTPException("客户端已经连上,请求的动作必须在建立连接之前进行");
482.         }
483.         else 
484.             return;
485.     }
486.     
487.     
488.     protected void initalize(FTPControlSocket control) throws SocketException{
489.         this.control=control;
490.         control.setSoTimeOut(timeout);
491.     }
492.     
493.     
494.     public int getTimeout() {
495.         return timeout;
496.     }
498.     public void setTimeout(int timeout) throws SocketException {
499.         
500.         this.timeout = timeout;
501.         if(control!=null)
502.             control.setSoTimeOut(timeout);
503.     }
504.     
505.     public int getControlPort() {
506.         return ControlPort;
507.     }
509.     public void setControlPort(int controlPort) {
510.         ControlPort = controlPort;
511.     }
513.     public String getControlEncoding() {
514.         return controlEncoding;
515.     }
517.     public void setControlEncoding(String controlEncoding) {
518.         this.controlEncoding = controlEncoding;
519.     }
521.     public boolean isDetectTransferMode() {
522.         return detectTransferMode;
523.     }
525.     public void setDetectTransferMode(boolean detectTransferMode) {
526.         this.detectTransferMode = detectTransferMode;
527.     }
529.     public long getMonitorInterval() {
530.         return monitorInterval;
531.     }
533.     public void setMonitorInterval(long monitorInterval) {
534.         this.monitorInterval = monitorInterval;
535.     }
537.     public long getTransferBufferSize() {
538.         return transferBufferSize;
539.     }
541.     public void setTransferBufferSize(int transferBufferSize) {
542.         this.transferBufferSize = transferBufferSize;
543.     }
546.     public String getRemoteAddress() {
547.         return remoteAddress.getHostName();
548.     }
550.     public void setRemoteAddress(InetAddress remoteAddress) {
551.         this.remoteAddress = remoteAddress;
552.     }
553.     
554.     public void setRemoteAddress(String remotehost){
555.         try {
556.             this.remoteAddress=InetAddress.getByName(remotehost);
557.         } catch (UnknownHostException e) {
558.             // TODO Auto-generated catch block
559.             e.printStackTrace();
560.         }
561.     }
562.     public FTPProcessListener getListener() {
563.         return listener;
564.     }
566.     public void setListener(FTPProcessListener listener) {
567.         this.listener = listener;
568.     }
569.     
570.     /**
571.      * 获取远程的文件大小,如果没有的话返回0
572.      * @param remoteFile
573.      * @return
574.      * @throws FTPException
575.      * @throws IOException
576.      */
578.     public long getStartSize(String remoteFile) throws FTPException, IOException {
580.         if(startSize==0)            
581.             return getSize(remoteFile);
582.         else
583.             return startSize;
584.     }
585.     
586.     public static void main(String args[]){
587.         
588.         Thread temp=null;
589.         String remoteFolder="";
590.         FTPClient client=new FTPClient();
591.         client.setRemoteAddress("localhost");
592.         try {
593.             client.setTimeout(10000);
594.             client.connect();
595.             client.login("BruceXX", "183320433");
596.             client.cd(" /");
597.             if(!remoteFolder.equals("")){
598.                 String[] t=remoteFolder.split("/");
599.                 StringBuffer sb=new StringBuffer();
600.                 for(int i=0;i<t.length;i++){
601.                     sb.append(t[i]+"/");
602.                     client.mkdir(sb.toString());
603.                 }
604.                 client.cd(remoteFolder);
605.             }
606.             final long size=client.getStartSize("ttplayer.exe");
607.             final FTPProcessMointor m=new FTPProcessMointor();
608.             client.setListener(m);
609.             client.autoChooseType("ttplayer.exe");
610.             temp=new Thread(new Runnable(){
611.                 
612.                 public void run() {
613.                     // TODO Auto-generated method stub
614.                     while(true){
615. //                      System.out.println(monitor.uploadSize);
616.                         System.out.println("现文件大小:"+(m.uploadSize+size));
617.                         try {
618.                             Thread.sleep(1000);
619.                         } catch (InterruptedException e) {
620.                             // TODO Auto-generated catch block
621.                             e.printStackTrace();
622.                         }
623.                     }
624.                     
625.                 }
626.                 
627.             });
628.             temp.start();
629.             client.transfer("F://ttplayer.exe", "ttplayer.exe");
630.             
631.             
632.             
633.             
634.             
635.         } catch (SocketException e) {
636.             // TODO Auto-generated catch block
637.             e.printStackTrace();
638.         } catch (FTPException e) {
639.             // TODO Auto-generated catch block
640.             e.printStackTrace();
641.         } catch (IOException e) {
642.             // TODO Auto-generated catch block
643.             e.printStackTrace();
644.         }
645.         
646.     }
648.     public void setCancelTransfer(boolean cancelTransfer) {
649.         this.cancelTransfer = cancelTransfer;
650.     }
652.     public boolean isHandling() {
653.         return handling;
654.     }
656.     public boolean isOver() {
657.         return over;
658.     }
660.     
662.     
663.     
664. }

 

detectTransferMode  用来是否自动检测文件传输类型

monitorInterval 

里面用到了FTPProcessListener 这个监听上传进度的接口，

monitorInterval 是用来设定隔多少个长度刷新一次正在上传的大小

transferBufferSize 传输缓存大小

FTPControlSocket control 主要用来发送指定的socket

timeout 设定socket的超时时间

FTPReply lastReply 用来获取最后的响应时间

FTPDataSocket data 传输socket

isASCII 文件传输类型

handling 是否上传完了正在等待服务器接收完毕

over 是否上传完毕