Android实现TCP断点上传 后台C#服务接收

终端实现大文件上传一直都是比较难的技术，其中涉及到后端与前端的交互，稳定性和流量大小，而且实现原理每个人都有自己的想法，后端主流用的比较多的是http来实现，因为大多实现过断点下载。但稳定性不能保证，一旦断开，无法续传。所以得采用另一种流行的做法，tcp上传大文件。 

网上查找了一些资料，大多数是断点下载，然后就是单独的c#端的上传接收，或是http的，或是只有android端的，由于任务紧所以之前找的首选方案当然是http先来实现文件上传，终端采用post方法，将文件直接传至后端，后端通过file来获得。 

android端： 

requestparams params = new requestparams();
 file file = gettempfile();//获得本地文件
  try {
   params.put("file", file);
  } catch (filenotfoundexception e1) {
   e1.printstacktrace();
  }
  asynchttputil.post(url + "/upload", params, new jsonhttpresponsehandler() {
……

后端：
 var file = request.files["file"];
  file.saveas(upfilename);
还有其它更好的处理方法，也可以传流进来，不通过file文件格式。 在网络好的情况下没什么问题，但网络差点后来经常上传一半掉线或多个客户端上传出现连不上的情况，对于大文件极不稳定，所以赶紧研发tcp协议文件断点上传。

也有网友实现了http断点上传，既然大文件不行，那就将文件分割成小文件来上传，纯net的主要方法： 

上传： 

 bool result = true;
   long cruuent = 0;

   filestream fstream = new filestream(filename, filemode.open, fileaccess.read);
   binaryreader breader = new binaryreader(fstream); 
   
   //模拟断点上传，第一次只上传 100 个字节
   long length = 100;

   filename = filename.substring(filename.lastindexof('\\') + 1);

   #region 开始上传文件
   try
   {

    
    byte[] data; 
    #region 分割文件上传
    for (; cruuent <= length; cruuent = cruuent + bytecount)
    {
     if (cruuent + bytecount > length)
     {
      data = new byte[convert.toint64((length - cruuent))];
      breader.read(data, 0, convert.toint32((length - cruuent)));
     }
     else
     {
      data = new byte[bytecount];
      breader.read(data, 0, bytecount);
     }
     try
     {
      hashtable parms = new hashtable();
      parms.add("filename", filename);
      parms.add("npos", cruuent.tostring());

      byte[] byremoteinfo = postdata(serverpath + "uploadserver.aspx", data, parms);

     }
     catch (exception ex)
     {
      msg = ex.tostring();
      result = false;
      break;
     }
    #endregion
    }
   }
   catch (exception ex)
   {
    msg = ex.tostring();
    result = false;
   }
   finally
   {
    breader.close();
    fstream.close();

   }

   gc.collect();

先将文件分割成小流，npos为断点的位置，即已经上传了的大小，然后循环上传所有包。
后台接收： 

 /// <summary>
 /// 保存文件（从url参数中获取文件名、当前指针，将文件流保存到当前指针后）
 /// 如果是第一次上传，则当前指针为0，代码执行与续传一样，只不过指针没有偏移
 /// </summary>
 public void saveuploadfile()
 {

  string filename = request.params["filename"];
  long npos = convert.toint64(request.params["npos"]);

  int uploadlength = convert.toint32(request.inputstream.length);
  
  string path = server.mappath("/uploadserver");
  filename = path + "//upload//" + filename;

  filestream fstream = new filestream(filename, filemode.openorcreate, fileaccess.readwrite);
  //偏移指针
  fstream.seek(npos, seekorigin.begin);

  //从客户端的请求中获取文件流
  binaryreader breader = new binaryreader(request.inputstream);
  try
  {
   byte[] data = new byte[uploadlength];
   breader.read(data, 0, uploadlength);
   fstream.write(data, 0, uploadlength);
  }
  catch
  {
   //todo 添加异常处理
  }
  finally
  {
   //释放流
   fstream.close();
   breader.close();
  }
 }

重点在 fstream.seek(npos, seekorigin.begin); 从断点位置接收保存。

有兴趣的可以自己实现。  

现在主要讲讲客户端tcp上传，后台tcp接收，主要思路为：android端读取本地文件将文件名，文件大小上传至服务器（文件名必须是全局唯一），服务器将根据文件名查询是否上传过，若是上传过，将已传文件的大小即断点位置传给终端，终端接收后先保存断点位置，然后从断点位置读取文件断续上传，直到全部完成。若没上传过则服务器创建缓存文件接收。 

看看代码android： 

string head = "length=" + uploadfile.length() + ";filename=" + filename

 socket socket = new socket("192.168.0.123", 7080);
     outputstream outstream = socket.getoutputstream();
     outstream.write(head.getbytes());//发送

     pushbackinputstream instream = new pushbackinputstream(socket.getinputstream());
     string response = streamtool.readline(instream);//读取
     string[] items = response.split(";");

 final string position = items[0].substring(items[0].indexof("=") + 1);//断点位置
      final string serviceurl = items[1].substring(items[1].indexof("=") + 1);//保存到服务器路径

randomaccessfile fileoutstream = new randomaccessfile(uploadfile, "r");
      fileoutstream.seek(integer.valueof(position));//从断点位置开始读取文件
      byte[] buffer = new byte[1024];
      int len = -1;
      int length = integer.valueof(position);//已经上传的大小，用于本地显示
      while ( (len = fileoutstream.read(buffer)) != -1) {
       outstream.write(buffer, 0, len);
       length += len;
       message msg = new message();
       msg.getdata().putint("size", length);
       // 更新上传的进度       handler.sendmessage(msg);

      } if (length == uploadfile.length()) {//如果相等,则说明上传成功} fileoutstream.close(); outstream.close(); instream.close(); socket.close(); 

后端处理： 

 private static tcplistener listener;//服务器监听
 ipaddress iphost = ipaddress.any;
 listener = new tcplistener(iphost, 7080);
     listener.start();//开启监听

 socket remotesocketclient = listener.acceptsocket();
     device = new device(remotesocketclient);
//开启一个线程去处理
     threaddev = new thread(new threadstart(device.scan));
     device.curentthread = threaddev;
     threaddev.isbackground = true;
     threaddev.start();

scan处理方法：

string[] items = strgetcontent.split(';');
     string filelength = items[0].substring(items[0].indexof("=") + 1);
     string filename = items[1].substring(items[1].indexof("=") + 1);
 //文件保存完整路径
       filepath = path.combine(directorypath, filename);
//断点位置
      long position = 0;
      if (file.exists(filepath))
      {
       using (filestream reader = new filestream(filepath, filemode.open, fileaccess.read, fileshare.none))
       {
        position = reader.length;
       }
      }
//返回消息
 response = "position=" + position + ";serviceurl=" + dirpath + "/" + filename) ;
      

      //服务器收到客户端的请求信息后，给客户端返回响应信息：;position=0 
      //serviceurl 服务生保存的文件位置 /playfiles/video/2016/07/04/1141142221.mp4
      buffersend = encoding.utf8.getbytes(response);
      remotesocketclient.send(buffersend);

然后处理续传内容：

//获得文件内容
      byte[] buffer = new byte[buffersize];
      int received = 0;
      long receive, length = long.parse(filelength);
      fileinfo file = new fileinfo(filepath);
      using (filestream writer = file.open(file.exists ? filemode.append : filemode.createnew, fileaccess.write, fileshare.none))
      {
       receive = writer.length;
       while (receive < length)
       {
        if ((received = remotesocketclient.receive(buffer)) == 0)
        {
         program.messageadd(" ip【" + remotesocketclient.remoteendpoint.tostring() + "】接收暂停！");
         break;
        }
        writer.write(buffer, 0, received);
        writer.flush();
        receive += (long)received;
       }

      }

if (receive == length)
      {
       program.messageadd(" ip【" + remotesocketclient.remoteendpoint.tostring() + "】接收" + filename + "完成！");
}

主要原理还是从断点位置上传和接收。 

这里只是讲了最主要的代码功能，还有很多细节处理，比如终端要显示进度，所以还要保存进度，后端文件的保存会不会错位，还有多文件上传会不会乱，多客户端上传是创建新线程还是有线程池来处理等等 。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。