java多线程分块上传并支持断点续传最新修正完整版本

最新推荐文章于 2024-09-23 14:50:27 发布
最新推荐文章于 2024-09-23 14:50:27 发布
阅读量5.4k 收藏 4
点赞数
  1. package com.test;  
  2.   
  3. import java.io.DataInputStream;  
  4. import java.io.DataOutputStream;  
  5. import java.io.File;  
  6. import java.io.FileInputStream;  
  7. import java.io.FileOutputStream;  
  8. import java.io.IOException;  
  9. import java.io.RandomAccessFile;  
  10. import java.net.HttpURLConnection;  
  11. import java.net.URL;  
  12. /** 
  13.  * 文件断点续传加分段上传线程 
  14.  * @author wzztestin 
  15.  * 
  16.  */  
  17. /** 
  18.  * 文件断点续传加分段上传线程 
  19.  * @author wzztestin 
  20.  * 
  21.  */  
  22. public class DownFileFetch extends Thread {  
  23.     DownFileInfoBean siteInfoBean = null; // 文件信息 Bean  
  24.     long[] nStartPos; // 开始位置  
  25.     long[] nEndPos; // 结束位置  
  26.     DownFileSplitterFetch[] fileSplitterFetch; // 子线程对象  
  27.     long nFileLength; // 文件长度  
  28.     boolean bFirst = true; // 是否第一次取文件  
  29.     boolean bStop = false; // 停止标志  
  30.     File tmpFile; // 文件下载的临时信息  
  31.     DataOutputStream output; // 输出到文件的输出流  
  32.     boolean fileflag; //是本地上传还是远程下载的标志  
  33.     File downfile; //本地文件下载  
  34.     int splitter = 0;  
  35.       
  36.     /** 
  37.      * 下载上传文件抓取初始化 
  38.      * @param bean 
  39.      * @throws IOException 
  40.      */  
  41.     public DownFileFetch(DownFileInfoBean bean) throws IOException {  
  42.         siteInfoBean = bean;  
  43.         /** 
  44.          * File.separator windows是\,unix是/ 
  45.          */  
  46.         tmpFile = new File(bean.getSFilePath() + File.separator  
  47.                 + bean.getSFileName() + ".info");  
  48.         if (tmpFile.exists()) {  
  49.             bFirst = false;  
  50.             //读取已下载的文件信息  
  51.             read_nPos();  
  52.         } else {  
  53.             nStartPos = new long[bean.getNSplitter()];  
  54.             nEndPos = new long[bean.getNSplitter()];  
  55.         }  
  56.         fileflag = bean.getFileflag();  
  57.         downfile = bean.getDownfile();  
  58.         this.splitter = bean.getNSplitter();  
  59.     }  
  60.   
  61.     public void run() {  
  62.         // 获得文件长度  
  63.         // 分割文件  
  64.         // 实例 FileSplitterFetch  
  65.         // 启动 FileSplitterFetch 线程  
  66.         // 等待子线程返回  
  67.         try {  
  68.             if (bFirst) {  
  69.                 nFileLength = getFileSize();  
  70.                 if (nFileLength == -1) {  
  71.                     DownFileUtility.log("File Length is not known!");  
  72.                 } else if (nFileLength == -2) {  
  73.                     DownFileUtility.log("File is not access!");  
  74.                 } else {  
  75.                     for (int i = 0; i < nStartPos.length; i++) {  
  76.                         nStartPos[i] = (long) (i * (nFileLength / nStartPos.length));  
  77.                     }  
  78.                     for (int i = 0; i < nEndPos.length - 1; i++) {  
  79.                         nEndPos[i] = nStartPos[i + 1];  
  80.                     }  
  81.                     nEndPos[nEndPos.length - 1] = nFileLength;  
  82.                 }  
  83.             }  
  84.             // 启动子线程  
  85.             fileSplitterFetch = new DownFileSplitterFetch[nStartPos.length];  
  86.             for (int i = 0; i < nStartPos.length; i++) {  
  87.                 fileSplitterFetch[i] = new DownFileSplitterFetch(  
  88.                         siteInfoBean.getSSiteURL(), siteInfoBean.getSFilePath()  
  89.                                 + File.separator + siteInfoBean.getSFileName()+"_"+i,  
  90.                         nStartPos[i], nEndPos[i], i,fileflag,downfile,bFirst);  
  91.                 DownFileUtility.log("Thread " + i + " , nStartPos = " + nStartPos[i]  
  92.                         + ", nEndPos = " + nEndPos[i]);  
  93.                 fileSplitterFetch[i].start();  
  94.             }  
  95.             //下载子线程是否完成标志  
  96.             boolean breakWhile = false;  
  97.             while (!bStop) {  
  98.                 write_nPos();  
  99.                 DownFileUtility.sleep(500);  
  100.                 breakWhile = true;  
  101.                 for (int i = 0; i < nStartPos.length; i++) {  
  102.                     if (!fileSplitterFetch[i].bDownOver) {  
  103.                         breakWhile = false;  
  104.                         break;  
  105.                     }else{  
  106.                         write_nPos();  
  107.                     }  
  108.                 }  
  109.                 if (breakWhile){  
  110.                     break;  
  111.                 }  
  112.             }  
  113.             hebinfile(siteInfoBean.getSFilePath()+ File.separator + siteInfoBean.getSFileName(),splitter);  
  114.             DownFileUtility.log("文件下载结束！");  
  115.         } catch (Exception e) {  
  116.             e.printStackTrace();  
  117.         }  
  118.     }  
  119.       
  120.     /** 
  121.      * 获得文件长度 
  122.      * @return 
  123.      */  
  124.     public long getFileSize() {  
  125.         int nFileLength = -1;  
  126.         if(fileflag){  
  127.             try {  
  128.                 URL url = new URL(siteInfoBean.getSSiteURL());  
  129.                 HttpURLConnection httpConnection = (HttpURLConnection) url  
  130.                         .openConnection();  
  131.                 httpConnection.setRequestProperty("User-Agent", "NetFox");  
  132.                 int responseCode = httpConnection.getResponseCode();  
  133.                 if (responseCode >= 400) {  
  134.                     processErrorCode(responseCode);  
  135.                     //represent access is error  
  136.                     return -2;   
  137.                 }  
  138.                 String sHeader;  
  139.                 for (int i = 1;; i++) {  
  140.                     sHeader = httpConnection.getHeaderFieldKey(i);  
  141.                     if (sHeader != null) {  
  142.                         if (sHeader.equals("Content-Length")) {  
  143.                             nFileLength = Integer.parseInt(httpConnection  
  144.                                     .getHeaderField(sHeader));  
  145.                             break;  
  146.                         }  
  147.                     } else {  
  148.                         break;  
  149.                     }  
  150.                 }  
  151.             } catch (IOException e) {  
  152.                 e.printStackTrace();  
  153.             } catch (Exception e) {  
  154.                 e.printStackTrace();  
  155.             }  
  156.             DownFileUtility.log(nFileLength);  
  157.         }else{  
  158.             try{  
  159.                 File myflie = downfile;  
  160.                 nFileLength = (int)myflie.length();  
  161.             }catch(Exception e){  
  162.                 e.printStackTrace();  
  163.             }  
  164.             DownFileUtility.log(nFileLength);  
  165.         }  
  166.         return nFileLength;  
  167.     }  
  168.   
  169.     /** 
  170.      * 保存下载信息（文件指针位置） 
  171.      */  
  172.     private void write_nPos() {  
  173.         try {  
  174.             output = new DataOutputStream(new FileOutputStream(tmpFile));  
  175.             output.writeInt(nStartPos.length);  
  176.             for (int i = 0; i < nStartPos.length; i++) {  
  177.                 output.writeLong(fileSplitterFetch[i].nStartPos);  
  178.                 output.writeLong(fileSplitterFetch[i].nEndPos);  
  179.             }  
  180.             output.close();  
  181.         } catch (IOException e) {  
  182.             e.printStackTrace();  
  183.         } catch (Exception e) {  
  184.             e.printStackTrace();  
  185.         }  
  186.     }  
  187.   
  188.     /** 
  189.      * 读取保存的下载信息（文件指针位置） 
  190.      */  
  191.     private void read_nPos() {  
  192.         try {  
  193.             DataInputStream input = new DataInputStream(new FileInputStream(  
  194.                     tmpFile));  
  195.             int nCount = input.readInt();  
  196.             nStartPos = new long[nCount];  
  197.             nEndPos = new long[nCount];  
  198.             for (int i = 0; i < nStartPos.length; i++) {  
  199.                 nStartPos[i] = input.readLong();  
  200.                 nEndPos[i] = input.readLong();  
  201.             }  
  202.             input.close();  
  203.         } catch (IOException e) {  
  204.             e.printStackTrace();  
  205.         } catch (Exception e) {  
  206.             e.printStackTrace();  
  207.         }  
  208.     }  
  209.       
  210.     /** 
  211.      * 输出错误信息 
  212.      * @param nErrorCode 
  213.      */  
  214.     private void processErrorCode(int nErrorCode) {  
  215.         DownFileUtility.log("Error Code : " + nErrorCode);  
  216.     }  
  217.   
  218.     /** 
  219.      * 停止文件下载 
  220.      */  
  221.     public void siteStop() {  
  222.         bStop = true;  
  223.         for (int i = 0; i < nStartPos.length; i++)  
  224.             fileSplitterFetch[i].splitterStop();  
  225.     }  
  226.       
  227.     /** 
  228.      * 合并文件 
  229.      * @param sName 
  230.      * @param splitternum 
  231.      */  
  232.     private void hebinfile(String sName,int splitternum){  
  233.         try{  
  234.             File file = new File(sName);  
  235.             if(file.exists()){  
  236.                 file.delete();  
  237.             }  
  238.             RandomAccessFile saveinput = new RandomAccessFile(sName,"rw");  
  239.             for(int i = 0;i<splitternum;i++){  
  240.                 try {  
  241.                     RandomAccessFile input = new RandomAccessFile (new File(sName+"_"+i),"r");  
  242.                     byte[] b = new byte[1024];  
  243.                     int nRead;  
  244.                     while ((nRead = input.read(b, 0, 1024)) > 0) {  
  245.                         write(saveinput,b, 0, nRead);  
  246.                     }  
  247.                     input.close();  
  248.                 } catch (Exception e) {  
  249.                     e.printStackTrace();  
  250.                 }  
  251.             }  
  252.             DownFileUtility.log("file size is "+saveinput.length());  
  253.         }catch(Exception e){  
  254.             e.printStackTrace();  
  255.         }  
  256.     }  
  257.       
  258.     /** 
  259.      * 写文件 
  260.      * @param b 
  261.      * @param nStart 
  262.      * @param nLen 
  263.      * @return 
  264.      */  
  265.     private int write(RandomAccessFile oSavedFile,byte[] b, int nStart, int nLen) {  
  266.         int n = -1;  
  267.         try {  
  268.             oSavedFile.seek(oSavedFile.length());  
  269.             oSavedFile.write(b, nStart, nLen);  
  270.             n = nLen;  
  271.         } catch (IOException e) {  
  272.             e.printStackTrace();  
  273.         }  
  274.         return n;  
  275.     }  
  276. }  

 

Java代码   收藏代码
  1. package com.test;  
  2.   
  3. import java.io.File;  
  4. import java.io.IOException;  
  5. import java.io.InputStream;  
  6. import java.io.RandomAccessFile;  
  7. import java.net.HttpURLConnection;  
  8. import java.net.URL;  
  9. /** 
  10.  * 下载上传子线程 
  11.  * @author wzztestin 
  12.  * 
  13.  */  
  14. public class DownFileSplitterFetch extends Thread {  
  15.     String sURL; // 下载文件的地址  
  16.     long nStartPos; // 文件分段的开始位置  
  17.     long nEndPos; // 文件分段的结束位置  
  18.     int nThreadID; // 线程的 ID  
  19.     boolean bDownOver = false; // 是否下载完成  
  20.     boolean bStop = false; // 停止下载  
  21.     DownFileAccess fileAccessI = null; // 文件对象  
  22.     boolean fileflag; //是URL下载还是本地下载  
  23.     File file = null;//本地下载文件  
  24.     boolean bFirst = true;  
  25.       
  26.     /** 
  27.      * 下载，上传子线程初始化 
  28.      * @param sURL 
  29.      * @param sName 
  30.      * @param nStart 
  31.      * @param nEnd 
  32.      * @param id 
  33.      * @param fileflag 
  34.      * @param downfile 
  35.      * @throws IOException 
  36.      */  
  37.     public DownFileSplitterFetch(String sURL, String sName, long nStart, long nEnd,  
  38.             int id,boolean fileflag,File downfile,boolean bFirst) throws IOException {  
  39.         this.sURL = sURL;  
  40.         this.nStartPos = nStart;  
  41.         this.nEndPos = nEnd;  
  42.         nThreadID = id;  
  43.         fileAccessI = new DownFileAccess(sName, nStartPos,bFirst);  
  44.         this.fileflag = fileflag;  
  45.         this.file = downfile;  
  46.         this.bFirst = bFirst;  
  47.     }  
  48.       
  49.     /** 
  50.      * 线程执行 
  51.      */  
  52.     public void run() {  
  53.         if(fileflag){  
  54.             this.urldownload();  
  55.         }else{  
  56.             this.filedownload();  
  57.         }  
  58.     }  
  59.   
  60.     /** 
  61.      * 打印回应的头信息 
  62.      * @param con 
  63.      */  
  64.     public void logResponseHead(HttpURLConnection con) {  
  65.         for (int i = 1;; i++) {  
  66.             String header = con.getHeaderFieldKey(i);  
  67.             if (header != null){  
  68.                 DownFileUtility.log(header + " : " + con.getHeaderField(header));  
  69.             }else{  
  70.                 break;  
  71.             }  
  72.         }  
  73.     }  
  74.       
  75.     /** 
  76.      * 地址下载 
  77.      */  
  78.     private void urldownload(){  
  79.         DownFileUtility.log("Thread " + nThreadID + " url down filesize is "+(nEndPos-nStartPos));  
  80.         DownFileUtility.log("Thread " + nThreadID + " url start >> "+nStartPos +"------end >> "+nEndPos);  
  81.         while (nStartPos < nEndPos && !bStop) {  
  82.             try {  
  83.                 URL url = new URL(sURL);  
  84.                 HttpURLConnection httpConnection = (HttpURLConnection) url  
  85.                         .openConnection();  
  86.                 httpConnection.setRequestProperty("User-Agent", "NetFox");  
  87.                 String sProperty = "bytes=" + nStartPos + "-";  
  88.                 httpConnection.setRequestProperty("RANGE", sProperty);  
  89.                 DownFileUtility.log(sProperty);  
  90.                 InputStream input = httpConnection.getInputStream();  
  91.                 byte[] b = new byte[1024];  
  92.                 int nRead;  
  93.                 while ((nRead = input.read(b, 0, 1024)) > 0  
  94.                         && nStartPos < nEndPos && !bStop) {  
  95.                     if((nStartPos+nRead)>nEndPos)  
  96.                     {  
  97.                         nRead = (int)(nEndPos - nStartPos);  
  98.                     }  
  99.                     nStartPos += fileAccessI.write(b, 0, nRead);  
  100.                 }  
  101.                 DownFileUtility.log("Thread " + nThreadID + " nStartPos : "+nStartPos);  
  102.                 fileAccessI.oSavedFile.close();  
  103.                 DownFileUtility.log("Thread " + nThreadID + " is over!");  
  104.                 input.close();  
  105.                 bDownOver = true;  
  106.             } catch (Exception e) {  
  107.                 e.printStackTrace();  
  108.             }  
  109.         }  
  110.         if(!bDownOver){  
  111.             if(nStartPos >= nEndPos){  
  112.                 bDownOver = true;  
  113.             }  
  114.         }  
  115.     }  
  116.       
  117.     /** 
  118.      * 文件下载 
  119.      */  
  120.     private void filedownload(){  
  121.         DownFileUtility.log("Thread " + nThreadID + " down filesize is "+(nEndPos-nStartPos));  
  122.         DownFileUtility.log("Thread " + nThreadID + " start >> "+nStartPos +"------end >> "+nEndPos);  
  123.         while (nStartPos < nEndPos && !bStop) {  
  124.             try {  
  125.                 RandomAccessFile input = new RandomAccessFile(file,"r");  
  126.                 input.seek(nStartPos);  
  127.                 byte[] b = new byte[1024];  
  128.                 int nRead;  
  129.                 while ((nRead = input.read(b, 0, 1024)) > 0  
  130.                         && nStartPos < nEndPos && !bStop) {  
  131.                     if((nStartPos+nRead)>nEndPos)  
  132.                     {  
  133.                         nRead = (int)(nEndPos - nStartPos);  
  134.                     }  
  135.                     nStartPos += fileAccessI.write(b, 0, nRead);  
  136.                 }  
  137.                 fileAccessI.oSavedFile.close();  
  138.                 DownFileUtility.log("Thread " + nThreadID + " is over!");  
  139.                 input.close();  
  140.                 bDownOver = true;  
  141.                 input.close();  
  142.             } catch (Exception e) {  
  143.                 e.printStackTrace();  
  144.             }  
  145.         }  
  146.         if(!bDownOver){  
  147.             if(nStartPos >= nEndPos){  
  148.                 bDownOver = true;  
  149.             }  
  150.         }  
  151.         DownFileUtility.log("Thread " + nThreadID + "last start >> "+nStartPos );  
  152.     }  
  153.       
  154.     /** 
  155.      * 停止 
  156.      */  
  157.     public void splitterStop() {  
  158.         bStop = true;  
  159.     }  
  160. }  

 

Java代码   收藏代码
  1. package com.test;  
  2.   
  3. import java.io.*;  
  4.   
  5. /** 
  6.  * 文件对象 
  7.  * @author wzztestin 
  8.  * 
  9.  */  
  10. public class DownFileAccess implements Serializable {  
  11.     /** 
  12.      *  
  13.      */  
  14.     private static final long serialVersionUID = -2518013155676212866L;  
  15.     //写入文件的流  
  16.     RandomAccessFile oSavedFile;  
  17.     //开始位置  
  18.     long nPos;  
  19.     boolean bFirst;  
  20.   
  21.     public DownFileAccess() throws IOException {  
  22.         this("", 0,true);  
  23.     }  
  24.       
  25.     /** 
  26.      * 写入文件初始化 
  27.      * @param sName 
  28.      * @param nPos 
  29.      * @throws IOException 
  30.      */  
  31.     public DownFileAccess(String sName, long nPos,boolean bFirst) throws IOException {  
  32.         File wfile = new File(sName);  
  33.         oSavedFile = new RandomAccessFile(wfile,"rw");  
  34.         if(!bFirst){  
  35.             oSavedFile.seek(wfile.length());  
  36.         }  
  37.         this.nPos = nPos;  
  38.         this.bFirst = bFirst;  
  39.     }  
  40.       
  41.     /** 
  42.      * 写文件 
  43.      * @param b 
  44.      * @param nStart 
  45.      * @param nLen 
  46.      * @return 
  47.      */  
  48.     public synchronized int write(byte[] b, int nStart, int nLen) {  
  49.         int n = -1;  
  50.         try {  
  51.             oSavedFile.write(b, nStart, nLen);  
  52.             n = nLen;  
  53.         } catch (IOException e) {  
  54.             e.printStackTrace();  
  55.         }  
  56.         return n;  
  57.     }  
  58. }  

 

Java代码   收藏代码
  1. package com.test;  
  2.   
  3. import java.io.File;  
  4.   
  5. public class DownFileInfoBean {  
  6.     private String sSiteURL; // 文件的下载地址  
  7.     private String sFilePath; // 保存文件的路径  
  8.     private String sFileName; // 保存文件的名字  
  9.     private int nSplitter; // 文件分成几段，默认是5段  
  10.     private boolean fileflag; // 如果为FALSE则是本地下载,为TRUE则URL下载  
  11.     private File downfile;  
  12.   
  13.     public File getDownfile() {  
  14.         return downfile;  
  15.     }  
  16.   
  17.     public void setDownfile(File downfile) {  
  18.         this.downfile = downfile;  
  19.     }  
  20.   
  21.     public boolean getFileflag() {  
  22.         return fileflag;  
  23.     }  
  24.   
  25.     public void setFileflag(boolean fileflag) {  
  26.         this.fileflag = fileflag;  
  27.     }  
  28.       
  29.     /** 
  30.      * 默认初始化 
  31.      */  
  32.     public DownFileInfoBean() {  
  33.         // default 5  
  34.         this("", "", "", 5,false,null);  
  35.     }  
  36.       
  37.     /** 
  38.      * 下载文件信息初始化 
  39.      * @param sURL 下载的链接地址 
  40.      * @param sPath 上传的保存路径 
  41.      * @param sName 上传保存的文件名 
  42.      * @param nSpiltter 文件分段个数 
  43.      * @param fileflag 是本地文件上传下载还是链接上传下载的标志 
  44.      * @param downfile 本地下载文件(FILE) 
  45.      */  
  46.     public DownFileInfoBean(String sURL, String sPath, String sName, int nSpiltter,boolean fileflag,File downfile) {  
  47.         sSiteURL = sURL;  
  48.         sFilePath = sPath;  
  49.         sFileName = sName;  
  50.         this.nSplitter = nSpiltter;  
  51.         this.fileflag = fileflag;  
  52.         this.downfile = downfile;  
  53.     }  
  54.   
  55.     public String getSSiteURL() {  
  56.         return sSiteURL;  
  57.     }  
  58.   
  59.     public void setSSiteURL(String value) {  
  60.         sSiteURL = value;  
  61.     }  
  62.   
  63.     public String getSFilePath() {  
  64.         return sFilePath;  
  65.     }  
  66.   
  67.     public void setSFilePath(String value) {  
  68.         sFilePath = value;  
  69.     }  
  70.   
  71.     public String getSFileName() {  
  72.         return sFileName;  
  73.     }  
  74.   
  75.     public void setSFileName(String value) {  
  76.         sFileName = value;  
  77.     }  
  78.   
  79.     public int getNSplitter() {  
  80.         return nSplitter;  
  81.     }  
  82.   
  83.     public void setNSplitter(int nCount) {  
  84.         nSplitter = nCount;  
  85.     }  
  86. }  

 

Java代码   收藏代码
  1. package com.test;  
  2.   
  3. /** 
  4.  * 简单的工具类 
  5.  * @author wzztestin 
  6.  * 
  7.  */  
  8. public class DownFileUtility {  
  9.     public DownFileUtility() {  
  10.     }  
  11.       
  12.     /** 
  13.      * 休眠时长 
  14.      * @param nSecond 
  15.      */  
  16.     public static void sleep(int nSecond) {  
  17.         try {  
  18.             Thread.sleep(nSecond);  
  19.         } catch (Exception e) {  
  20.             e.printStackTrace();  
  21.         }  
  22.     }  
  23.       
  24.     /** 
  25.      * 打印日志信息 
  26.      * @param sMsg 
  27.      */  
  28.     public static void log(String sMsg) {  
  29.         System.err.println(sMsg);  
  30.     }  
  31.       
  32.     /** 
  33.      * 打印日志信息 
  34.      * @param sMsg 
  35.      */  
  36.     public static void log(int sMsg) {  
  37.         System.err.println(sMsg);  
  38.     }  
  39. }  

 

Java代码   收藏代码
  1. package com.test;  
  2.   
  3. public class TestMethod {  
  4.     public TestMethod() {  
  5.         try {  
  6.             DownFileInfoBean bean = new DownFileInfoBean(  
  7.                     "http://cdn.market.hiapk.com/data/upload//2012/09_27/17/car.wu.wei.kyo.shandian_174928.apk", "D:\\temp",  
  8.                     "shandian_174928.apk", 5,true,null);  
  9.             /*File file = new File("D:\\dan07.apk"); 
  10.             DownFileInfoBean bean = new DownFileInfoBean(null, "D:\\temp", 
  11.                     "dan07.apk", 3,false,file);*/  
  12.             DownFileFetch fileFetch = new DownFileFetch(bean);  
  13.             fileFetch.start();  
  14.         } catch (Exception e) {  
  15.             e.printStackTrace();  
  16.         }  
  17.     }  
  18.   
  19.     public static void main(String[] args) {  
  20.         new TestMethod();  
  21.     }  
  22. }  
yangcbyang
关注
java多线程上传_Java大文件分片上传/多线程上传功能
weixin_35992880的博客
02-12 449
这里只写后端的代码，基本的思想就是，前端将文件分片，然后每次访问上传接口的时候，向后端传入参数：当前为第几块文件，和分片总数下面直接贴代码吧，一些难懂的我大部分都加上注释了：上传文件实体类：看得出来，实体类中已经有很多我们需要的功能了，还有实用的属性。如MD5秒传的信息。首先是文件数据接收逻辑，负责接收控件上传的文件块数据，然后写到服务器的文件中。控件已经提供了块的索引，大小，MD5和长度信息，我...
java-多线程下载器（支持断点续传、线程加减）包含源码和可运行jar包 第二版
06-17
2、支持多任务多线程同时下载； 3、每个任务的线程数由用户在新建任务时自定义，缺省为5个线程； 4、任务下载过程中可以点击“线程+”或“线程-”即时增减线程； 5、选择任务，可以在任务信息栏中查看任务下载的信息...
java多线程分块上传并支持断点续传
程序领域
08-11 1772
java多线程分块上传并支持断点续传最新修正完整版本   Java代码   package com.test;      import java.io.DataInputStream;   import java.io.DataOutputStream;   import java.io.File;   import java.io.FileInpu
通过JAVA实现文件断点续传功能
最新发布
weixin_52041354的博客
09-23 1450
需求：大文件上传，批量上传，断点续传，文件夹上传，大文件下载，批量下载，断点下载，文件夹下载文件夹：上传下载需要支持层级结构，采用非压缩方式文件大小：100G前端：vue2,vue3,vue-cli,jquery,html,webuploader后端：JSP，springbootweb服务：tomcat数据库：mysql,oracle,达梦，国产化数据库服务器：linux,信创国产化浏览器：ie8+,firefox,chrome,360,2345,QQ,搜狗,猎豹。
JAVA服务中的大文件上传和下载优化技巧分享
alisky119的博客
04-02 334
网上一般的做法都是用的HTML5的API，也就是chrome提供的API，能够满足基本需求，但是还是有痛点，chrome限制死了，固定死了无法扩展，每个域名只允许5个TCP连接，导致了速度有上限，你也无法修改和扩展。进度信息容易丢失，用户关闭网页，刷新网页，关闭浏览器，重启浏览器，关闭电脑，重启电脑后，进度信息都会丢失，无解，没办法。传大文件，超大文件，文件数量多的话，前端就卡，网页反应慢，容易死，崩溃，在配置较差的电脑或者配置一般的电脑上这个痛点体现的非常明显。选择对应的数据表脚本，这里以SQL为例。
Java Web大文件分片上传/多线程上传
weixin_45525177的博客
05-25 159
javaweb上传文件 上传文件的jsp中的部分 上传文件同样可以使用form表单向后端发请求，也可以使用 ajax向后端发请求 1.通过form表单向后端发送请求 <form id="postForm" action="${pageContext.request.contextPath}/UploadServlet" method="post" enctype="multipart/form-data"> <div class=...
java文件切割上传_JAVA大文件上传支持切割上传
weixin_29248611的博客
02-13 179
文件夹数据库处理逻辑publicclassDbFolder{JSONObject root;publicDbFolder(){this.root =newJSONObject();this.root.put(“f_id”,“”);this.root.put(“f_nameLoc”,“根目录”);this.root.put(“f_pid”,“”);this.root.put(“f_p...
Java大文件分片上传/多线程上传功能
Mr_Zang666的博客
05-31 913
大致实现原理：当enctype的值是multipart/form-data时，浏览器会把每个表单项进行分割，分割成不同的部件，以boundary的值为分割标识，这个标识的字符串是随机生成的，最后一个表单项的分割标识字符串末尾会多两个”- -“，代表结束。支持大文件的上传和续传，要求续传支持所有浏览器，包括ie6,ie7,ie8,ie9,Chrome,Firefox,360安全浏览器，并且刷新浏览器后仍然能够续传，重启浏览器（关闭浏览器后再打开）仍然能够继续上传，重启电脑后仍然能够上传。
Java大文件分片上传/多线程上传
Mr_Zang666的博客
05-24 276
4. 上传文件不能使用 request.getParameter("")获取参数了，而是直接将request解析，通过判断每一项是文件还是非文件，然后进行相应的操作（文件的话就是用流来读取，非文件的话，暂时保存到一个map中。接收文件块数据，在这个逻辑中我们接收文件块数据。_this.ui.msg.text("向服务器发送MD5信息错误");this.ui.msg.text("MD5计算完毕，开始连接服务器...");this.ui.msg.text("服务器存在相同文件，快速上传成功。
Java多线程设计模式上传文件
02-10
Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件
java实现多线程文件传输
03-22
利用java技术实现多线程文件传输
java多线程加队列上传文件_后台处理
05-12
java多线程加队列上传文件_后台处理
java实现大文件上传分片上传断点续传.zip
08-12
java实现的大文件上传，支持断点续传 支持分片分片上传 采用springboot框架是实现
java多线程文件传输（基于swing）
08-23
基于socket的多线程文件传输，包中含有整个工程的源代码（有详细的注解） 和 直接运行的打包生成的jar文件 。其中swing界面有待优化.....
Java大文件分片上传/多线程上传解决方案
Mr_Zang666的博客
05-31 1091
4. 上传文件不能使用 request.getParameter("")获取参数了，而是直接将request解析，通过判断每一项是文件还是非文件，然后进行相应的操作（文件的话就是用流来读取，非文件的话，暂时保存到一个map中。, jsonp: "callback" //自定义的jsonp回调函数名称，默认为jQuery自动生成的随机函数名。this.ui.msg.text("MD5计算完毕，开始连接服务器...");this.ui.msg.text("服务器存在相同文件，快速上传成功。
Java大文件分片上传/多线程上传代码
weixin_45525177的博客
05-22 295
上周遇到这样一个问题，客户上传高清视频（1G以上）的时候上传失败。 一开始以为是session过期或者文件大小受系统限制，导致的错误。 查看了系统的配置文件没有看到文件大小限制， web.xml中seesiontimeout是30，我把它改成了120。 但还是不行，有时候10分钟就崩了。 同事说，可能是客户这里服务器网络波动导致网络连接断开，我觉得有点道理。 但是我在本地测试的时候发觉上传也失败，网络原因排除。 看了日志，错误为： java.lang.OutOfMemoryErrorJavaheap...
webuploader java分片上传
juewang_love的博客
07-18 2910
webuploader java分片上传
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值