`
13146489
  • 浏览: 252981 次
  • 性别: Icon_minigender_1
  • 来自: 成都
社区版块
存档分类
最新评论

(转)断点续传

阅读更多
原文:http://falchion.iteye.com/blog/170346
其他文章:
1、http://desert3.iteye.com/blog/803072
2、HTTP断点续传:http://www.oschina.net/code/snippet_54100_624
3、FTP断点续传:http://club.163.com/viewElite.m?catalogId=15393&eliteId=15393_100d2d3fa8c0002
IIS 默认支持:断点续传
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-");(请注意200070后面的这个“-”减号,没这个是不行的。。。)
      // 获得输入流
      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);
      }

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


ftp断点续传的原理
客户端的实现步骤如下:

一、下载:
1、向服务器发送“REST + 本地文件长度”命令,告诉服务器,客户端要断点下载了。这时服务器还不知道客户端要下载哪个文件;
2、向服务器发送“RETR + 文件名”命令,通知服务器要下载的文件名,这时服务器开始定位文件指针读文件并发送数据。
3、客户端定位本地文件指针(文件末尾);
4、两端的准备工作都做完了以后,客户端创建socket,以被动或非被动方式建立数据通道,循环调用recv接收数据并追加入本地文件;

二、上传:
1、获取服务器上和本地要上传文件的同名文件大小;
2、向服务器发送“APPE + 文件名”,通知服务器,接下来从数据通道发送给你的数据要附加到这个文件末尾。
3、定位本地文件指针(和FTP上文件大小相同的位置)
4、从文件指针处读数据并发送。
  代码里将断点上传和断点下载放到同一个函数(MoveFile)里,通过get参数说明是上传还是下载。当然,整个FTP类的实现有800多行,包括登录、退出、获取FTP文件大小、删除FTP服务器上文件、响应服务器,解析响应信息等函数。相应的注释代码里都有,这里就不一一熬述了。


HTTP断点续传的原理http://www.it.com.cn/f/edu/058/17/159759.htm请求服务器上的一个文时,所发出的请求如下:
假设服务器域名为wwww.name.org,文件名为name.zip。
GET /name.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 /gman.zip HTTP/1.0
User-Agent: NetFox
RANGE: bytes=2000070-
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2

仔细看一下就会发现多了一行RANGE: bytes=2000070-
这一行的意思就是告诉服务器gman.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了。

http断点续传内核的实现:

  主要用了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(); 
  } 
  } 


分享到:
评论

相关推荐

    c#制作FTP上传(支持断点续传)

    在本文中,我们将深入探讨如何使用C#编程语言来实现FTP(文件传输协议)上传功能,特别是支持断点续传的特性。FTP是一种标准网络协议,用于在客户端和服务器之间交换文件。C#中的System.Net命名空间提供了丰富的类库...

    【ASP.NET编程知识】.NET或.NET Core Web APi基于tus协议实现断点续传的示例.docx

    .NET 或.NET Core Web API基于tus 协议实现断点续传的示例 本文档提供了一个基于tus 协议的断点续传示例,使用.NET 或.NET Core Web API 实现大文件分片上传。该示例使用 tusdotnet 方案,提供了一个基本的 demo,...

    FTP上传(断点续传)更新进度条

    FTP上传和断点续传是网络传输中两个重要的概念,特别是在大文件传输场景下,而更新进度条则是提升用户体验的关键元素。在这个公司项目的第一个版本中,我们关注的是如何实现一个功能完善的FTP上传系统,该系统支持...

    mongodb存取文件、webuploader断点续传,支持秒传,openOffice转pdf实现在线预览

    利用mongodb存储文件,前台使用百度webuploader的文件md5实现断点续传,一次上传,下次秒传,解决文件重复问题,避免数据冗余,文件上传后支持下载, 特定格式支持在线预览,office转pdf后前台新页面显示pdf,相关...

    WPF ftp上传下载支持断点续传

    在本文中,我们将深入探讨如何在Windows Presentation Foundation (WPF) 应用程序中实现FTP(File Transfer Protocol)上传和下载功能,同时支持断点续传,并解决在显示进度条时可能遇到的问题。WPF是一种.NET框架下...

    C# HttpWebRequest断点续传

    在IT行业中,网络编程是不可或缺的一部分,特别是在处理大文件下载时,断点续传功能显得尤为重要。本知识点主要探讨如何使用C#中的HttpWebRequest类实现断点续传和下载进度的展示。 首先,断点续传是一种允许用户在...

    PHP断点续传,亲测可用

    在IT领域,断点续传是一项非常实用的技术,尤其在大文件传输中,它能够提高文件上传或下载的效率,并且允许用户在中断后继续之前的过程。PHP作为一门广泛使用的服务器端脚本语言,实现断点续传的功能是完全可能的。...

    Android大文件断点续传

    在Android开发中,大文件的断点续传是一项重要的技术,尤其在处理视频、音频或者大型数据文件时显得尤为重要。断点续传允许用户在上传或下载过程中因网络中断而中断后,从上次中断的位置继续,而不是从头开始,极大...

    android实现下载,断点续传等

    在Android平台上,实现文件下载,特别是支持断点续传和进度显示,是移动应用开发中的常见需求。这有助于用户在不稳定的网络环境下高效地下载大文件,并提供良好的用户体验。以下是对这些知识点的详细讲解: 一、...

    Delphi多线程 断点续传 下载模块源码.rar

    一个Delphi支持多线程的断点续传下载模块源码,可用在Delphi下载程序中,部分参数设置:  dtAddTime : TDateTime; //发布时间  sResTitle : string; //资源名称  sDownloadURL, sSavedPath : string; //下载及...

    JAVA实现HTTP断点续传[借鉴].pdf

    以下将详细讲解断点续传的原理以及如何使用Java来实现。 断点续传的原理主要依赖于HTTP协议的范围请求(Range Request)特性。当客户端希望从已下载的部分开始继续下载文件时,它会在HTTP请求头中添加一个`Range`...

    C# 文件分片断点续传

    在IT行业中,文件分片和断点续传是提高大文件传输效率和可靠性的关键技术。在本项目中,我们看到“C# 文件分片断点续传”是使用Visual Studio 2012(VS2012)实现的一个功能,主要涉及到前端WebUploader组件与后端C#...

    点对点多线程断点续传软件源代码

    断点续传功能则允许在文件传输中断后,从停止的地方继续传输,这对于大文件传输和网络不稳定的情况非常有用。软件源代码是程序员用编程语言编写的原始指令集合,可被编译器转换为可执行程序。 在这个"点对点多线程...

    M3U8批量下载器3.0多线程多任务自动解密断点续传网页视频下载软件.rar

    断点续传 自动合并文件 手动合并文件 自定义添加请求头 1.界面精简 2.升级到.net 5 3.底层性能优化 相比之前的版本cpu使用率更低 4.增加插件功能 5.合并文件和下载功能合并 请求地址那里 如果是网络请求地址 就去...

    Android多线程断点续传下载+在线播放音乐

    在Android应用开发中,实现“多线程断点续传下载+在线播放音乐”涉及到多个关键技术,主要包括网络编程、文件操作、多线程处理、内存管理以及多媒体播放等。以下是对这些知识点的详细阐述: 1. **多线程下载**: ...

    OKHttp断点续传Demo 下载

    在Android平台上,开发一款应用时常会遇到需要下载大文件的需求,这时断点续传功能就显得尤为重要。OKHttp是一款高效且强大的网络请求库,而RxJava则是一个优秀的响应式编程库,两者结合可以构建出优雅的下载解决...

    Android多线程断点续传下载+在线播放音乐.rar

    在Android应用开发中,实现多线程断点续传下载和在线播放音乐是两个重要的功能。下面我们将详细探讨这两个主题。 一、Android多线程断点续传下载 1. 多线程下载:传统的单线程下载方式速度受限于网络环境,而多...

    Unity 最新UnityWebRequest 断点续传 下载显示下载进度,百分比 和网速 多少kb.rar

    在这个项目中,我们看到如何利用UnityWebRequest实现一个网络资源的下载功能,特别是关注断点续传、进度显示以及速度监控。 首先,断点续传是一种下载技术,允许用户在下载中断后从上次停止的地方继续下载,而不是...

    断点续传相关整理文档

    断点续传是一种在网络传输过程中,因网络中断而能从上次中断的位置继续传输的技术,尤其在大文件下载中非常有用。以下是对断点续传实现原理的详细解释: 1. **HTTP 协议中的关键头信息** - `Accept-Ranges`:...

    人工智能-项目实践-多线程-断点续传与多线程下载.zip

    在IT领域,尤其是在移动开发和网络编程中,断点续传和多线程下载是两个重要的技术概念,尤其对于处理大文件的下载场景至关重要。在这个名为"人工智能-项目实践-多线程-断点续传与多线程下载.zip"的压缩包中,可能...

Global site tag (gtag.js) - Google Analytics