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

最新推荐文章于 2024-09-21 19:40:38 发布
最新推荐文章于 2024-09-21 19:40:38 发布
阅读量2.3k 收藏 1
点赞数
分类专栏： 原创技术 文章标签： applet null buffer 服务器 socket string
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BruceXX/article/details/3122485
版权

公司项目上需要一个拖曳的组件，花了二周时间写了一个支持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 是否上传完毕

 

 

brucest0078
关注
专栏目录
java applet实现的一个FTP上传组件
09-05
java applet实现的一个FTP上传组件 老外写的,不怎么支持中文,第一次打开没装jdk会提示安装jdk,里面已自带是1.4版本 安装完后即可使用
APPLET实现大文件FTP上传
鸣志工作室
01-20 4791
      由于要实现大文件FTP上传下载，从网上搜索了几下，找到很多资料，最后决定采用基于org.apache.commons.net.ftp包实现FTP上传下载， Net包中的类既提供对协议的底层访问也有高层的抽象。在大多数情况下，抽象是足够的，它可以使你不必编写解析各种协议的底层套接字的代码。使用抽象不会损失任何功能。    借此感叹，org.apache.commons开源包真是森罗万
Applet通过FTP上传大文件
11-30
一个applet小应用城西，通过commons-net包操作ftp上传大文件，有上传进度显示。上传完成后可以回传文件名和文件路径给js，网页参数设置如下： <applet code="com.cmp.training.ftp.FtpJApplet.class" name="ftpupload" archive="ftpupload.jar" width="400" height="150" mayscript="true"> <param name="ipAddress" value="192.168.1.45" /> <!-- Ftp服务器地址 --> <param name="port" value="21" /> <!-- Ftp服务器端口号 --> <param name="username" value="Training" /> <!-- Ftp登陆用户名 --> <param name="password" value="Training" /> <!-- Ftp登陆密码 --> <param name="ffmpegPath " value="D:/ffmpeg/ffmpeg.exe" /> <!-- 视频处理工具Ffmpeg所在路径 --> <param name="imgSize " value="640*480" /> <!-- 缩略图分辨率大小 --> </applet> <!--<input type="text" name="uploadFileName"/>--> <script type="text/javascript"> function setValue(status, message, fileName, filePath){ alert(status); alert(message); alert(fileName); alert(filePath); } document.applets[0].sendMsgToHtml(); </script>
基于applet的FTP断点上传组件（五）
BruceXX的专栏
10-22 1136
拖曳几个文件上上传 上传 取消当前上传： 下面是源码，after 10 minutes...原来该死的CSDN没有上传附件的功能,上传到千脑了，下面是地址：http://www.qiannao.com/space/show/brucexx/ftpupload.rar/.page第一次写博，不足之处请各位强淫指正。 
亲测有效，解决宝塔面板连接ftp时，出现Socket错误导致FTP无法连接或超时
t1174148618的博客
07-25 2768
折腾半天终于解决了，宝塔面板连接ftp时，出现Socket错误，导致FTP无法连接或超时的问题，自从用了宝塔面板后发现，这个东西简直太方便了，无论是建站也好，或者是操作文件，安装ftp都非常快速简单，但是最近我趁早活动买了个云服务器，安装FTP的时候发现。 这ftp死活就是连不上，额不，说连不上也不对，是连上去了，大家可以看上面的图片，看里面的文字显示ftp已经登录上去了，但是最后在获取里面的文件时超时了，所以就导致ftp连接超时而失败了。 这个还真是第一次遇到，于是我就去网上找解决方法，说起这个我就气，
基于applet的FTP断点上传组件（四）
BruceXX的专栏
10-22 1328
 OK，主界面的表格中需要相关的修饰器，和作业调度以及作业窗口情况 UploadTableCellRender.class package ftpupload;import java.awt.Component;import java.io.File;import javax.swing.Icon;import javax.swing.JLabel;
ftp.zip_file upload applet_ftp_swing文件上传_传文件_有界面的的ftp
09-24
file upload applet_ftp_swing文件上传_传文件_有界面的的ftp"的项目中，开发者利用Java Swing库创建了一个带有图形用户界面（GUI）的小型应用程序，即Applet，实现了FTP文件上传功能，包括断点续传特性。...
Java实现FTP批量大文件上传下载
04-21
通过 Java 现有的可用的库来编写 FTP 客户端代码，并开发成 Applet 控件，做成基于 Web 的批量、大文件的上传下载控件。 一、概述 在项目实施过程中出现了一种基于 Web 的文件上传下载需求。在全省（或全国）各地...
FTP上传下载代码
03-28
这个项目对于开发者来说，是一个学习FTP通信和Java applet的好例子，也可以作为一个基础框架，根据实际需求进行扩展和定制，例如增加多线程上传下载、断点续传、SSL/TLS加密等功能。同时，由于Applet的安全性和兼容...
IIS 远程目录发布(Linux:Samba) & VS 远程目录开发 [Geoff原创]
weixin_33971977的博客
02-27 125
很多时候，我们要进行多台机进行项目开发，有些是Linux，有些是Win，有些是VMware里的虚拟机。方法都一样，如果搞清楚了，就发现其实都是权限问题。这个世界太多漏洞了**** IIS 远程目录发布 1、设置远程机 目录权限：如 root 2、设置本地机 用户权限：如 root  （带有IIS相关权限组） 3、注意 以上密码要相同 4、IIS里：主目录设置“另一台计算机的共享...
FTPClient自定义连接池实现
好记性不如烂笔头
01-03 3264
最新在工作当中使用到了ftp服务器，我是使用org.apache.commons.net.ftp.FTPClient做的连接，但是在测试调用的时候经常报断开的管道错误，就此问题我做了一些分析和总结，是因为在调用的时候我只new了一个对象，而使用了多线程进行调用，也就是同一个对象进行了多次调用，而每次调用都有调disconnect()方法，所有再调用的时候就报了断开的管道错误。 针对上面的问题...
错误hello:applet not found
信号处理总结
09-25 5855
 宿主机：Windows xp+VMware(Fedora core)目标机：ARM+uclinux2.6.x+nfs解决方法：arm-elf-gcc -o hello -elf2flt hello.c
基于applet的FTP断点上传组件（二）
BruceXX的专栏
10-22 1641
FTP客户端相关的附加类FTPControlSocket.classpackage ftpupload;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;import java
基于applet的FTP断点上传组件（三）
BruceXX的专栏
10-22 1102
客户端基本上写完了，剩下的事情就是写一个封装的组件业适合applet的插件的要求 FTPCOM.classpackage ftpupload;import java.io.IOException;public class FTPCOM {        private FTPClient client;    volatile boolean fin
基于主从Reactor模型实现高并发服务器
最新发布
m0_65558082的博客
09-21 473
高并发服务器
Java实现大规模FTP文件上传下载：基于j-ftp库的Applet解决方案
本文主要关注的是如何使用Java的j-ftp类库来构建基于Web的FTP客户端，以提供批量上传和下载的功能。以下将详细介绍关键知识点： 1. **背景与需求**：项目中需要支持全省或全国范围内的用户上传大文件至中心服务器，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值