断点续传的原理

最新推荐文章于 2024-06-15 23:59:04 发布
最新推荐文章于 2024-06-15 23:59:04 发布
阅读量87 收藏
点赞数
分类专栏： 网络通信 Java 文章标签： java 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/windshg/article/details/84427770
版权

转自：http://www.ibm.com/developerworks/cn/java/joy-down/index.html

 

其实断点续传的原理很简单，就是在 Http 的请求上和一般的下载有所不同而已。 
打个比方，浏览器请求服务器上的一个文时，所发出的请求如下： 
假设服务器域名为 wwww.sjtu.edu.cn，文件名为 down.zip。 
GET /down.zip HTTP/1.1 
Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/vnd.ms- 
excel, application/msword, application/vnd.ms-powerpoint, */* 
Accept-Language: zh-cn 
Accept-Encoding: gzip, deflate 
User-Agent: Mozilla/4.0 (compatible; MSIE 5.01; Windows NT 5.0) 
Connection: Keep-Alive

服务器收到请求后，按要求寻找请求的文件，提取文件的信息，然后返回给浏览器，返回信息如下：

200 
Content-Length=106786028 
Accept-Ranges=bytes 
Date=Mon, 30 Apr 2001 12:56:11 GMT 
ETag=W/"02ca57e173c11:95b" 
Content-Type=application/octet-stream 
Server=Microsoft-IIS/5.0 
Last-Modified=Mon, 30 Apr 2001 12:56:11 GMT

所谓断点续传，也就是要从文件已经下载的地方开始继续下载。所以在客户端浏览器传给 Web 服务器的时候要多加一条信息 -- 从哪里开始。 
下面是用自己编的一个"浏览器"来传递请求信息给 Web 服务器，要求从 2000070 字节开始。 
GET /down.zip HTTP/1.0 
User-Agent: NetFox 
RANGE: bytes=2000070- 
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2

仔细看一下就会发现多了一行 RANGE: bytes=2000070- 
这一行的意思就是告诉服务器 down.zip 这个文件从 2000070 字节开始传，前面的字节不用传了。 
服务器收到这个请求以后，返回的信息如下： 
206 
Content-Length=106786028 
Content-Range=bytes 2000070-106786027/106786028 
Date=Mon, 30 Apr 2001 12:55:20 GMT 
ETag=W/"02ca57e173c11:95b" 
Content-Type=application/octet-stream 
Server=Microsoft-IIS/5.0 
Last-Modified=Mon, 30 Apr 2001 12:55:20 GMT

和前面服务器返回的信息比较一下，就会发现增加了一行： 
Content-Range=bytes 2000070-106786027/106786028 
返回的代码也改为 206 了，而不再是 200 了。

知道了以上原理，就可以进行断点续传的编程了。

 

回页首

Java 实现断点续传的关键几点

  1. (1) 用什么方法实现提交 RANGE: bytes=2000070-。 
    当然用最原始的 Socket 是肯定能完成的，不过那样太费事了，其实 Java 的 net 包中提供了这种功能。代码如下： 

    URL url = new URL("http://www.sjtu.edu.cn/down.zip"); 
    HttpURLConnection httpConnection = (HttpURLConnection)url.openConnection(); 

    // 设置 User-Agent 
    httpConnection.setRequestProperty("User-Agent","NetFox"); 
    // 设置断点续传的开始位置 
    httpConnection.setRequestProperty("RANGE","bytes=2000070"); 
    // 获得输入流 
    InputStream input = httpConnection.getInputStream(); 

    从输入流中取出的字节流就是 down.zip 文件从 2000070 开始的字节流。 大家看，其实断点续传用 Java 实现起来还是很简单的吧。 接下来要做的事就是怎么保存获得的流到文件中去了。

  2. 保存文件采用的方法。 
    我采用的是 IO 包中的 RandAccessFile 类。 
    操作相当简单，假设从 2000070 处开始保存文件，代码如下： 
    RandomAccess oSavedFile = new RandomAccessFile("down.zip","rw"); 
    long nPos = 2000070; 
    // 定位文件指针到 nPos 位置 
    oSavedFile.seek(nPos); 
    byte[] b = new byte[1024]; 
    int nRead; 
    // 从输入流中读入字节流，然后写到文件中 
    while((nRead=input.read(b,0,1024)) > 0) 
    { 
    oSavedFile.write(b,0,nRead); 
    } 

怎么样，也很简单吧。 接下来要做的就是整合成一个完整的程序了。包括一系列的线程控制等等。

 

回页首

断点续传内核的实现

主要用了 6 个类，包括一个测试类。 
SiteFileFetch.java 负责整个文件的抓取，控制内部线程 (FileSplitterFetch 类 )。 
FileSplitterFetch.java 负责部分文件的抓取。 
FileAccess.java 负责文件的存储。 
SiteInfoBean.java 要抓取的文件的信息，如文件保存的目录，名字，抓取文件的 URL 等。 
Utility.java 工具类，放一些简单的方法。 
TestMethod.java 测试类。 

下面是源程序：

/* 
 /*
 * SiteFileFetch.java 
 */ 
 package NetFox; 
 import java.io.*; 
 import java.net.*; 
 public class SiteFileFetch extends Thread { 
 SiteInfoBean siteInfoBean = null; // 文件信息 Bean 
 long[] nStartPos; // 开始位置
 long[] nEndPos; // 结束位置
 FileSplitterFetch[] fileSplitterFetch; // 子线程对象
 long nFileLength; // 文件长度
 boolean bFirst = true; // 是否第一次取文件
 boolean bStop = false; // 停止标志
 File tmpFile; // 文件下载的临时信息
 DataOutputStream output; // 输出到文件的输出流
 public SiteFileFetch(SiteInfoBean bean) throws IOException 
 { 
 siteInfoBean = bean; 
 //tmpFile = File.createTempFile ("zhong","1111",new File(bean.getSFilePath())); 
 tmpFile = new File(bean.getSFilePath()+File.separator + bean.getSFileName()+".info");
 if(tmpFile.exists ()) 
 { 
 bFirst = false; 
 read_nPos(); 
 } 
 else 
 { 
 nStartPos = new long[bean.getNSplitter()]; 
 nEndPos = new long[bean.getNSplitter()]; 
 } 
 } 
 public void run() 
 { 
 // 获得文件长度
 // 分割文件
 // 实例 FileSplitterFetch 
 // 启动 FileSplitterFetch 线程
 // 等待子线程返回
 try{ 
 if(bFirst) 
 { 
 nFileLength = getFileSize(); 
 if(nFileLength == -1) 
 { 
 System.err.println("File Length is not known!"); 
 } 
 else if(nFileLength == -2) 
 { 
 System.err.println("File is not access!"); 
 } 
 else 
 { 
 for(int i=0;i<nStartPos.length;i++) 
 { 
 nStartPos[i] = (long)(i*(nFileLength/nStartPos.length)); 
 } 
 for(int i=0;i<nEndPos.length-1;i++) 
 { 
 nEndPos[i] = nStartPos[i+1]; 
 } 
 nEndPos[nEndPos.length-1] = nFileLength; 
 } 
 } 
 // 启动子线程
 fileSplitterFetch = new FileSplitterFetch[nStartPos.length]; 
 for(int i=0;i<nStartPos.length;i++) 
 { 
 fileSplitterFetch[i] = new FileSplitterFetch(siteInfoBean.getSSiteURL(), 
 siteInfoBean.getSFilePath() + File.separator + siteInfoBean.getSFileName(), 
 nStartPos[i],nEndPos[i],i); 
 Utility.log("Thread " + i + " , nStartPos = " + nStartPos[i] + ", nEndPos = " 
 + nEndPos[i]); 
 fileSplitterFetch[i].start(); 
 } 
 // fileSplitterFetch[nPos.length-1] = new FileSplitterFetch(siteInfoBean.getSSiteURL(),
 siteInfoBean.getSFilePath() + File.separator 
 + siteInfoBean.getSFileName(),nPos[nPos.length-1],nFileLength,nPos.length-1); 
 // Utility.log("Thread " +(nPos.length-1) + ",nStartPos = "+nPos[nPos.length-1]+",
 nEndPos = " + nFileLength); 
 // fileSplitterFetch[nPos.length-1].start(); 
 // 等待子线程结束
 //int count = 0; 
 // 是否结束 while 循环
 boolean breakWhile = false; 
 while(!bStop) 
 { 
 write_nPos(); 
 Utility.sleep(500); 
 breakWhile = true; 
 for(int i=0;i<nStartPos.length;i++) 
 { 
 if(!fileSplitterFetch[i].bDownOver) 
 { 
 breakWhile = false; 
 break; 
 } 
 } 
 if(breakWhile) 
 break; 
 //count++; 
 //if(count>4) 
 // siteStop(); 
 } 
 System.err.println("文件下载结束！"); 
 } 
 catch(Exception e){e.printStackTrace ();} 
 } 
 // 获得文件长度
 public long getFileSize() 
 { 
 int nFileLength = -1; 
 try{ 
 URL url = new URL(siteInfoBean.getSSiteURL()); 
 HttpURLConnection httpConnection = (HttpURLConnection)url.openConnection ();
 httpConnection.setRequestProperty("User-Agent","NetFox"); 
 int responseCode=httpConnection.getResponseCode(); 
 if(responseCode>=400) 
 { 
 processErrorCode(responseCode); 
 return -2; //-2 represent access is error 
 } 
 String sHeader; 
 for(int i=1;;i++) 
 { 
 //DataInputStream in = new DataInputStream(httpConnection.getInputStream ()); 
 //Utility.log(in.readLine()); 
 sHeader=httpConnection.getHeaderFieldKey(i); 
 if(sHeader!=null) 
 { 
 if(sHeader.equals("Content-Length")) 
 { 
 nFileLength = Integer.parseInt(httpConnection.getHeaderField(sHeader)); 
 break; 
 } 
 } 
 else 
 break; 
 } 
 } 
 catch(IOException e){e.printStackTrace ();} 
 catch(Exception e){e.printStackTrace ();} 
 Utility.log(nFileLength); 
 return nFileLength; 
 } 
 // 保存下载信息（文件指针位置）
 private void write_nPos() 
 { 
 try{ 
 output = new DataOutputStream(new FileOutputStream(tmpFile)); 
 output.writeInt(nStartPos.length); 
 for(int i=0;i<nStartPos.length;i++) 
 { 
 // output.writeLong(nPos[i]); 
 output.writeLong(fileSplitterFetch[i].nStartPos); 
 output.writeLong(fileSplitterFetch[i].nEndPos); 
 } 
 output.close(); 
 } 
 catch(IOException e){e.printStackTrace ();} 
 catch(Exception e){e.printStackTrace ();} 
 } 
 // 读取保存的下载信息（文件指针位置）
 private void read_nPos() 
 { 
 try{ 
 DataInputStream input = new DataInputStream(new FileInputStream(tmpFile)); 
 int nCount = input.readInt(); 
 nStartPos = new long[nCount]; 
 nEndPos = new long[nCount]; 
 for(int i=0;i<nStartPos.length;i++) 
 { 
 nStartPos[i] = input.readLong(); 
 nEndPos[i] = input.readLong(); 
 } 
 input.close(); 
 } 
 catch(IOException e){e.printStackTrace ();} 
 catch(Exception e){e.printStackTrace ();} 
 } 
 private void processErrorCode(int nErrorCode) 
 { 
 System.err.println("Error Code : " + nErrorCode); 
 } 
 // 停止文件下载
 public void siteStop() 
 { 
 bStop = true; 
 for(int i=0;i<nStartPos.length;i++) 
 fileSplitterFetch[i].splitterStop(); 
 } 
 }

 

 /* 
 **FileSplitterFetch.java 
 */ 
 package NetFox; 
 import java.io.*; 
 import java.net.*; 
 public class FileSplitterFetch extends Thread { 
 String sURL; //File URL 
 long nStartPos; //File Snippet Start Position 
 long nEndPos; //File Snippet End Position 
 int nThreadID; //Thread's ID 
 boolean bDownOver = false; //Downing is over 
 boolean bStop = false; //Stop identical 
 FileAccessI fileAccessI = null; //File Access interface 
 public FileSplitterFetch(String sURL,String sName,long nStart,long nEnd,int id)
 throws IOException 
 { 
 this.sURL = sURL; 
 this.nStartPos = nStart; 
 this.nEndPos = nEnd; 
 nThreadID = id; 
 fileAccessI = new FileAccessI(sName,nStartPos); 
 } 
 public void run() 
 { 
 while(nStartPos < nEndPos && !bStop) 
 { 
 try{ 
 URL url = new URL(sURL); 
 HttpURLConnection httpConnection = (HttpURLConnection)url.openConnection (); 
 httpConnection.setRequestProperty("User-Agent","NetFox"); 
 String sProperty = "bytes="+nStartPos+"-"; 
 httpConnection.setRequestProperty("RANGE",sProperty); 
 Utility.log(sProperty); 
 InputStream input = httpConnection.getInputStream(); 
 //logResponseHead(httpConnection); 
 byte[] b = new byte[1024]; 
 int nRead; 
 while((nRead=input.read(b,0,1024)) > 0 && nStartPos < nEndPos 
 && !bStop) 
 { 
 nStartPos += fileAccessI.write(b,0,nRead); 
 //if(nThreadID == 1) 
 // Utility.log("nStartPos = " + nStartPos + ", nEndPos = " + nEndPos); 
 } 
 Utility.log("Thread " + nThreadID + " is over!"); 
 bDownOver = true; 
 //nPos = fileAccessI.write (b,0,nRead); 
 } 
 catch(Exception e){e.printStackTrace ();} 
 } 
 } 
 // 打印回应的头信息
 public void logResponseHead(HttpURLConnection con) 
 { 
 for(int i=1;;i++) 
 { 
 String header=con.getHeaderFieldKey(i); 
 if(header!=null) 
 //responseHeaders.put(header,httpConnection.getHeaderField(header)); 
 Utility.log(header+" : "+con.getHeaderField(header)); 
 else 
 break; 
 } 
 } 
 public void splitterStop() 
 { 
 bStop = true; 
 } 
 } 
 
 /* 
 **FileAccess.java 
 */ 
 package NetFox; 
 import java.io.*; 
 public class FileAccessI implements Serializable{ 
 RandomAccessFile oSavedFile; 
 long nPos; 
 public FileAccessI() throws IOException 
 { 
 this("",0); 
 } 
 public FileAccessI(String sName,long nPos) throws IOException 
 { 
 oSavedFile = new RandomAccessFile(sName,"rw"); 
 this.nPos = nPos; 
 oSavedFile.seek(nPos); 
 } 
 public synchronized int write(byte[] b,int nStart,int nLen) 
 { 
 int n = -1; 
 try{ 
 oSavedFile.write(b,nStart,nLen); 
 n = nLen; 
 } 
 catch(IOException e) 
 { 
 e.printStackTrace (); 
 } 
 return n; 
 } 
 } 
 
 /* 
 **SiteInfoBean.java 
 */ 
 package NetFox; 
 public class SiteInfoBean { 
 private String sSiteURL; //Site's URL 
 private String sFilePath; //Saved File's Path 
 private String sFileName; //Saved File's Name 
 private int nSplitter; //Count of Splited Downloading File 
 public SiteInfoBean() 
 { 
 //default value of nSplitter is 5 
 this("","","",5); 
 } 
 public SiteInfoBean(String sURL,String sPath,String sName,int nSpiltter)
 { 
 sSiteURL= sURL; 
 sFilePath = sPath; 
 sFileName = sName; 
 this.nSplitter = nSpiltter; 
 } 
 public String getSSiteURL() 
 { 
 return sSiteURL; 
 } 
 public void setSSiteURL(String value) 
 { 
 sSiteURL = value; 
 } 
 public String getSFilePath() 
 { 
 return sFilePath; 
 } 
 public void setSFilePath(String value) 
 { 
 sFilePath = value; 
 } 
 public String getSFileName() 
 { 
 return sFileName; 
 } 
 public void setSFileName(String value) 
 { 
 sFileName = value; 
 } 
 public int getNSplitter() 
 { 
 return nSplitter; 
 } 
 public void setNSplitter(int nCount) 
 { 
 nSplitter = nCount; 
 } 
 } 
 
 /* 
 **Utility.java 
 */ 
 package NetFox; 
 public class Utility { 
 public Utility() 
 { 
 } 
 public static void sleep(int nSecond) 
 { 
 try{ 
 Thread.sleep(nSecond); 
 } 
 catch(Exception e) 
 { 
 e.printStackTrace (); 
 } 
 } 
 public static void log(String sMsg) 
 { 
 System.err.println(sMsg); 
 } 
 public static void log(int sMsg) 
 { 
 System.err.println(sMsg); 
 } 
 } 
 
 /* 
 **TestMethod.java 
 */ 
 package NetFox; 
 public class TestMethod { 
 public TestMethod() 
 { ///xx/weblogic60b2_win.exe 
 try{ 
 SiteInfoBean bean = new SiteInfoBean("http://localhost/xx/weblogic60b2_win.exe",
     "L:\\temp","weblogic60b2_win.exe",5); 
 //SiteInfoBean bean = new SiteInfoBean("http://localhost:8080/down.zip","L:\\temp",
     "weblogic60b2_win.exe",5); 
 SiteFileFetch fileFetch = new SiteFileFetch(bean); 
 fileFetch.start(); 
 } 
 catch(Exception e){e.printStackTrace ();} 
 } 
 public static void main(String[] args) 
 { 
 new TestMethod(); 
 } 
 }

 

【Android面试八股文】你来说一说HTTP断点续传原理
字节卷动
06-19 86
允许客户端在下载文件时从上次中断的地方继续下载，而不是重新开始整个文件的下载。这种机制对于大文件的下载尤为重要，因为可以节省带宽和时间。
java断点续传原理_很简单的Java断点续传实现原理
weixin_31938727的博客
02-13 1929
原理解析在开发当中，“断点续传”这种功能很实用和常见，听上去也是比较有“逼格”的感觉。所以通常我们都有兴趣去研究研究这种功能是如何实现的？以Java来说，网络上也能找到不少关于实现类似功能的资料。但是呢，大多数都是举个Demo然后贴出源码，真正对其实现原理有详细的说明很少。于是我们在最初接触的时候，很可能就是直接Crtl + C/V代码，然后捣鼓捣鼓，然而最终也能把效果弄出来。但初学时这样做其实很...
java 断点原理_java断点续传原理
weixin_32916125的博客
03-05 356
先说说断点续传的原理：这是HTTP 1.1协议的一部分，并不需要客户端特意去做多么复杂的事情。以前我曾经看过一个单位的技术标书，其中有下载的断点续传这一要求，给出的offer居然还挺高的...简单的说，只要利用了HTTP协议(http://www.ietf.org/rfc/rfc2616.txt)中的如下字段来和服务器端交互，就可以实现文件下载的断点续传：Range : 用于客户端到服务器端的请求...
java断点续传原理_java 文件断点续传实现原理
weixin_35606595的博客
02-13 577
关键字：RandomAccessFile一、作用：随机流(RandomAccessFile)不属于IO流，支持对文件的读取和写入随机访问。二、随机访问文件原理：首先把随机访问的文件对象看作存储在文件系统中的一个大型 byte 数组，然后通过指向该 byte 数组的光标或索引(即：文件指针 FilePointer)在该数组任意位置读取或写入任意数据。三、相关方法说明：1、对象声明：RandomAc...
Android 断点续传实现原理
最新发布
hcgeng的专栏
06-15 1047
断点续传/下载需要使用到 java.io.RandomAccessFile 类，RandomAccessFile 的实例支持读取和写入随机访问文件，它也可以 seek(long pos) 设置从此文件的开头开始测量的文件指针偏移量，在该位置进行下一次读取或写入操作。但是这种做法有个明显的问题，假如手机在下载文件的时候下载了80%，某些原因断网了，如果不支持断点续传，那就只有被迫重头开始下载。在现实的场景中，服务器中的文件是会有发生变化的情况的，那么我们发起续传的请求肯定是失败的。
python断点续传原理_python编写断点续传下载软件
weixin_39789206的博客
12-07 387
一年一度的python小程序编写系列之——断点续传下载软件。其实HTTP断点续传原理比较简单，在HTTP数据包中，可以增加Range头，这个头以字节为单位指定请求的范围，来下载范围内的字节流。如：如上图勾下来的地方，我们发送数据包时选定请求的内容的范围，返回包即获得相应长度的内容。所以，我们在下载的时候，可以将目标文件分成很多“小块”，每次下载一小块(用Range标明小块的范围)，直到把所有小块下...
java断点续传原理_Java文件断点续传实现原理解析
weixin_36212135的博客
02-13 330
一、作用：随机流(RandomAccessFile)不属于IO流，支持对文件的读取和写入随机访问。二、随机访问文件原理：首先把随机访问的文件对象看作存储在文件系统中的一个大型 byte 数组，然后通过指向该 byte 数组的光标或索引(即：文件指针 FilePointer)在该数组任意位置读取或写入任意数据。三、相关方法说明：1、对象声明：RandomAccessFile raf = newRan...
android断点续传原理,Android-断点续传
weixin_29041195的博客
05-27 383
简介其实断点续传的原理很简单，从字面上理解，所谓断点续传就是从停止的地方重新 下载。 断点:线程停止的位置。 续传:从停止的位置重新下载。用代码解析就是: 断点 : 当前线程已经下载完成的数据长度。 续传 : 向服务器 请求上次线程停止位置之后的数据。 原理知道了，功能实现起来也简单。每当线程 停止时就把已下载的数据长度写入记录文件，当重新下载时，从记录文件读取已经 下载了的长度。而这个长度就是所...
断点续传原理解析
AngelDg的博客
08-13 2682
断点续传断点续传概念HTTP 断点续传的原理：举个例子Range & Content-Range增强校验Last-ModifiedEtagIf-Range工作原理 断点续传概念 从文件上次中断的地方开始重新下载或上传,当下载或上传文件的时候,如果没有实现断点续传功能,那么每次出现异常或者用户主动的暂停,都会去重头下载,这样很浪费时间。所以断点续传的功能就应运而生了。 要实现断点续传的功能，需要客户端记录下当前的下载或上传进度，并在需要续传的时候通知服务端本次需要下载或上传的内容片段。 HTTP 断
断点续传文件服务器,断点续传 文件服务器
weixin_39978444的博客
08-11 499
断点续传 文件服务器 内容精选换一换安装传输工具在本地主机和Windows云服务器上分别安装数据传输工具，将文件上传到云服务器。例如QQ.exe。在本地主机和Windows云服务器上分别安装数据传输工具，将文件上传到云服务器。例如QQ.exe。本地磁盘映射(推荐使用)使用远程桌面连接MSTSC方式进行数据传输。该方式不支持断点续传，可能存在传输中断的情况，因此不建议上传大文在本地主机和Windo...
Http断点续传原理及flex实现技术
12-05
在探讨具体的实现之前，我们先来理解下断点续传的基本原理。断点续传功能已经成为现代网络应用中的一项重要特性，尤其是在文件传输领域。其核心目标是在遇到网络中断或用户主动暂停下载时，能够继续之前的下载进度而...
Android 断点续传原理以及实现
01-05
Android 断点续传原理以及实现 0. 前言 在Android开发中，断点续传听起来挺容易，在下载一个文件时点击暂停任务暂停，点击开始会继续下载文件。但是真正实现起来知识点还是蛮多的，因此今天有时间实现了一下，并...
使用Java.util.zip下的zipOutStream和zipInStream对字节流进行压缩和解压缩
windshg的专栏
05-21 809
参考：http://www.blogjava.net/usherlight/archive/2007/09/26/148230.html     网上介绍使用zipInStream和zipOutStream对文件或者文件夹进行压缩和解压缩的文章比较多。但是这次项目中需要对byte[]进行压缩，然后decode，通过http发送到服务端。最简单的方法，当然是把byte[]写到文件里，然后根据网...
Java中读取字节流并按指定编码转换成字符串的方法
windshg的专栏
05-21 739
参考： http://www.blogjava.net/pengpenglin/archive/2008/12/16/220350.html     该方法中使用一个无限循环，从字节流中读取字节，存放到byte数组中，每次读取1024个字节(一般都是这个设置)，由于每次读取的字节数量不一定够1024个(比如最后一次的读取就可能不够)，所以我们要记录每次实际读到的字节数，然后将实际读取到的字节...
hibernate 注解 一对多 唯一索引
windshg的专栏
04-17 459
今天被hibernate和mysql整了一下，切身感受到索引的重要性。   我用的是Hibernate注解的一对多映射，代码如下：   @OneToMany(cascade=CascadeType.ALL, fetch=FetchType.LAZY) @JoinTable(name="user_followBy", joinColumns={@JoinColumn(name="...
基于red5的在线视频录制实例和详细注释
windshg的专栏
05-14 360
参考：http://www.ccvita.com/130.html     //预定义声明import mx.utils.Delegate;//创建一个基本的网络连接对象var nc:NetConnection = new NetConnection();//连接到本地的Red5服务器nc.connect("rtmp://localhost/online");//将已和red5服务器建立连接...
j2ee jar包
windshg的专栏
07-28 344
* ant/ant.jar, ant/ant-launcher.jar, ant-trax.jar, ant-junit.jar - Ant 1.6.5 (http://ant.apache.org) - used to build the framework and the sample apps * antlr/antlr-2.7.6.jar- ANTLR 2.7.6 (http://ww...
jsp URL传参 中文乱码解决
windshg的专栏
11-06 340
在做jsp向后台的servlet传递中文参数时出现乱码,网上看了下,有用编解码方式,还有很多其他的方式,最后发现这种方法是最简单的 打开tomcat的server.xml 添加蓝色部分即可! &lt;Connector port="8080"              maxThreads="150" minSpareThreads="25" maxSpareThreads="75"...
HTTP断点续传原理与AS3实现实例
"Http断点续传原理及flex实现技术"是一篇关于在HTTP协议下实现文件断点续传功能的技术文章。主要内容围绕着HTTP断点续传的核心原理展开，通过对比非断点续传和断点续传的HTTP请求流程来深入理解这一特性。 在非断点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值