android中okhttp实现断点上传示例

前言

成都服务器托管，创新互联公司提供包括服务器租用、遂宁托管服务器、带宽租用、云主机、机柜租用、主机租用托管、CDN网站加速、国际域名空间等业务的一体化完整服务。电话咨询：028-86922220

之前项目需要上传大文件的功能，上传大文件经常遇到上传一半由于网络或者其他一些原因上传失败。然后又得重新上传（很麻烦），所以就想能不能做个断点上传的功能。于是网上搜索，发现市面上很少有断点上传的案例，有找到一个案例也是采用SOCKET作为上传方式（大文件上传，不适合使用POST,GET形式）。由于大文件夹不适合http上传的方式，所以就想能不能把大文件切割成n块小文件，然后上传这些小文件，所有小文件全部上传成功后再在服务器上进行拼接。这样不就可以实现断点上传，又解决了http不适合上传大文件的难题了吗！！！

原理分析

Android客户端

首先，android端调用服务器接口1，参数为filename（服务器标识判断是否上传过）

如果存在filename，说明之前上传过，则续传；如果没有，则从零开始上传。

然后，android端调用服务器接口2，传入参数name，chunck（传到第几块），chuncks（总共多少块）

android中okhttp实现断点上传示例 

android中okhttp实现断点上传示例

服务器端

接口一：根据上传文件名称filename 判断是否之前上传过，没有则返回客户端chunck=1，有则读取记录chunck并返回。

接口二：上传文件，如果上传块数chunck=chuncks，遍历所有块文件拼接成一个完整文件。

 服务端源代码

服务器接口1

@WebServlet(urlPatterns = { "/ckeckFileServlet" })
public class CkeckFileServlet extends HttpServlet {

  private FileUploadStatusServiceI statusService;
  String repositoryPath;
  String uploadPath;

  @Override
  public void init(ServletConfig config) throws ServletException {
    ServletContext servletContext = config.getServletContext();
    WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(servletContext);
    statusService = (FileUploadStatusServiceI) context.getBean("fileUploadStatusServiceImpl");

    repositoryPath = FileUtils.getTempDirectoryPath();
    uploadPath = config.getServletContext().getRealPath("datas/uploader");
    File up = new File(uploadPath);
    if (!up.exists()) {
      up.mkdir();
    }
  }

  @Override
  protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    // TODO Auto-generated method stub

    String fileName = new String(req.getParameter("filename"));
    //String chunk = req.getParameter("chunk");
    //System.out.println(chunk);
    System.out.println(fileName);
    resp.setContentType("text/json; charset=utf-8");

    TfileUploadStatus file = statusService.get(fileName);

    try {
      if (file != null) {
        int schunk = file.getChunk();
        deleteFile(uploadPath + schunk + "_" + fileName);
        //long off = schunk * Long.parseLong(chunkSize);
        resp.getWriter().write("{\"off\":" + schunk + "}");

      } else {
        resp.getWriter().write("{\"off\":1}");
      }
    } catch (Exception e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
}

服务器接口2

@WebServlet(urlPatterns = { "/uploaderWithContinuinglyTransferring" })
public class UploaderServletWithContinuinglyTransferring extends HttpServlet {

  private static final long serialVersionUID = 1L;

  private FileUploadStatusServiceI statusService;
  String repositoryPath;
  String uploadPath;

  @Override
  public void init(ServletConfig config) throws ServletException {
    ServletContext servletContext = config.getServletContext();
    WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(servletContext);
    statusService = (FileUploadStatusServiceI) context.getBean("fileUploadStatusServiceImpl");

    repositoryPath = FileUtils.getTempDirectoryPath();
    System.out.println("临时目录：" + repositoryPath);
    uploadPath = config.getServletContext().getRealPath("datas/uploader");
    System.out.println("目录：" + uploadPath);
    File up = new File(uploadPath);
    if (!up.exists()) {
      up.mkdir();
    }
  }
  @SuppressWarnings("unchecked")
  public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    response.setCharacterEncoding("UTF-8");
    Integer schunk = null;// 分割块数
    Integer schunks = null;// 总分割数
    String name = null;// 文件名
    BufferedOutputStream outputStream = null;
    if (ServletFileUpload.isMultipartContent(request)) {
      try {
        DiskFileItemFactory factory = new DiskFileItemFactory();
        factory.setSizeThreshold(1024);
        factory.setRepository(new File(repositoryPath));// 设置临时目录
        ServletFileUpload upload = new ServletFileUpload(factory);
        upload.setHeaderEncoding("UTF-8");
        upload.setSizeMax(5 * 1024 * 1024 * 1024);// 设置附近大小
        List items = upload.parseRequest(request);
        // 生成新文件名

        String newFileName = null; 
        for (FileItem item : items) {
          if (!item.isFormField()) {// 如果是文件类型
            name = newFileName;// 获得文件名
            if (name != null) {
              String nFname = newFileName;
              if (schunk != null) {
                nFname = schunk + "_" + name;
              }
              File savedFile = new File(uploadPath, nFname);
              item.write(savedFile);
            }
          } else {
            // 判断是否带分割信息
            if (item.getFieldName().equals("chunk")) {
              schunk = Integer.parseInt(item.getString());
              //System.out.println(schunk);
            }
            if (item.getFieldName().equals("chunks")) {
              schunks = Integer.parseInt(item.getString());
            }

            if (item.getFieldName().equals("name")) {
              newFileName = new String(item.getString());
            }
          }
        }
        //System.out.println(schunk + "/" + schunks);
        if (schunk != null && schunk == 1) {
          TfileUploadStatus file = statusService.get(newFileName);
          if (file != null) {
            statusService.updateChunk(newFileName, schunk);
          } else {
            statusService.add(newFileName, schunk, schunks);
          }

        } else {
          TfileUploadStatus file = statusService.get(newFileName);
          if (file != null) {
            statusService.updateChunk(newFileName, schunk);
          }
        }
        if (schunk != null && schunk.intValue() == schunks.intValue()) {
          outputStream = new BufferedOutputStream(new FileOutputStream(new File(uploadPath, newFileName)));
          // 遍历文件合并
          for (int i = 1; i <= schunks; i++) {
            //System.out.println("文件合并:" + i + "/" + schunks);
            File tempFile = new File(uploadPath, i + "_" + name);
            byte[] bytes = FileUtils.readFileToByteArray(tempFile);
            outputStream.write(bytes);
            outputStream.flush();
            tempFile.delete();
          }
          outputStream.flush();
        }
        response.getWriter().write("{\"status\":true,\"newName\":\"" + newFileName + "\"}");
      } catch (FileUploadException e) {
        e.printStackTrace();
        response.getWriter().write("{\"status\":false}");
      } catch (Exception e) {
        e.printStackTrace();
        response.getWriter().write("{\"status\":false}");
      } finally {
        try {
          if (outputStream != null)
            outputStream.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }
  }

}

android端源码

UploadTask 上传线程类

package com.mainaer.wjoklib.okhttp.upload;

import android.database.sqlite.SQLiteDatabase;
import android.os.Environment;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.text.TextUtils;

import java.io.Closeable;
import java.io.File;
import java.io.IOException;
import java.text.DecimalFormat;
import java.util.HashMap;
import java.util.Map;

import okhttp3.Headers;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

/**
 * 上传线程
 *
 * @author hst
 * @date 2016/9/6 .
 */
  public class UploadTask implements Runnable {

  private static String FILE_MODE = "rwd";
  private OkHttpClient mClient;
  private SQLiteDatabase db;
  private UploadTaskListener mListener;

  private Builder mBuilder;
  private String id;// task id
  private String url;// file url
  private String fileName; // File name when saving
  private int uploadStatus;
  private int chunck, chuncks;//流块
  private int position;

  private int errorCode;
  static String BOUNDARY = "----------" + System.currentTimeMillis();
  public static final MediaType MEDIA_TYPE_MARKDOWN = MediaType.parse("multipart/form-data;boundary=" + BOUNDARY);

  private UploadTask(Builder builder) {
    mBuilder = builder;
    mClient = new OkHttpClient();
    this.id = mBuilder.id;
    this.url = mBuilder.url;
    this.fileName = mBuilder.fileName;
    this.uploadStatus = mBuilder.uploadStatus;
    this.chunck = mBuilder.chunck;
    this.setmListener(mBuilder.listener);
    // 以kb为计算单位
  }

  @Override
  public void run() {
    try {
      int blockLength = 1024 * 1024;
      File file = new File(Environment.getExternalStorageDirectory().getAbsolutePath()+ File.separator +fileName);
      if (file.length() % blockLength == 0) {
        chuncks = (int) file.length() / blockLength;
      } else {
        chuncks = (int) file.length() / blockLength + 1;

      }
      while (chunck <= chuncks&&uploadStatus!= UploadStatus.UPLOAD_STATUS_PAUSE&&uploadStatus!= UploadStatus.UPLOAD_STATUS_ERROR)
      {

        uploadStatus = UploadStatus.UPLOAD_STATUS_UPLOADING;
        Map params = new HashMap();
        params.put("name", fileName);
        params.put("chunks", chuncks + "");
        params.put("chunk", chunck + "");
        final byte[] mBlock = FileUtils.getBlock((chunck - 1) * blockLength, file, blockLength);
        MultipartBody.Builder builder = new MultipartBody.Builder()
            .setType(MultipartBody.FORM);
        addParams(builder, params);
        RequestBody requestBody = RequestBody.create(MEDIA_TYPE_MARKDOWN, mBlock);
        builder.addFormDataPart("mFile", fileName, requestBody);
        Request request = new Request.Builder()
            .url(url+ "uploaderWithContinuinglyTransferring")
            .post(builder.build())
            .build();
        Response response = null;
        response = mClient.newCall(request).execute();
        if (response.isSuccessful()) {
          onCallBack();
          chunck++;
          /* if (chunck <= chuncks) {
             run();
          }*/
        }
        else
        {
          uploadStatus = UploadStatus.UPLOAD_STATUS_ERROR;
          onCallBack();
        }

      }
    } catch (IOException e) {
      uploadStatus = UploadStatus.UPLOAD_STATUS_ERROR;
      onCallBack();
      e.printStackTrace();
    }
  }


/*  *//**
   * 删除数据库文件和已经上传的文件
   *//*
  public void cancel() {
    if (mListener != null)
      mListener.onCancel(UploadTask.this);
  }*/

  /**
   * 分发回调事件到ui层
   */
  private void onCallBack() {
    mHandler.sendEmptyMessage(uploadStatus);
    // 同步manager中的task信息
    //UploadManager.getInstance().updateUploadTask(this);
  }

  Handler mHandler = new Handler(Looper.getMainLooper()) {
    @Override
    public void handleMessage(Message msg) {
      int code = msg.what;
      switch (code) {
        // 上传失败
        case UploadStatus.UPLOAD_STATUS_ERROR:
          mListener.onError(UploadTask.this, errorCode,position);
          break;
        // 正在上传
        case UploadStatus.UPLOAD_STATUS_UPLOADING:
          mListener.onUploading(UploadTask.this, getDownLoadPercent(), position);
         // 暂停上传
          break;
        case UploadStatus.UPLOAD_STATUS_PAUSE:
          mListener.onPause(UploadTask.this);
          break;

      }
    }
  };

  private String getDownLoadPercent() {
    String baifenbi = "0";// 接受百分比的值
    if (chunck >= chuncks) {
      return "100";
    }
    double baiy = chunck * 1.0;
    double baiz = chuncks * 1.0;
    // 防止分母为0出现NoN
    if (baiz > 0) {
      double fen = (baiy / baiz) * 100;
      //NumberFormat nf = NumberFormat.getPercentInstance();
      //nf.setMinimumFractionDigits(2); //保留到小数点后几位
      // 百分比格式，后面不足2位的用0补齐
      //baifenbi = nf.format(fen);
      //注释掉的也是一种方法
      DecimalFormat df1 = new DecimalFormat("0");//0.00
      baifenbi = df1.format(fen);
    }
    return baifenbi;
  }


  private String getFileNameFromUrl(String url) {
    if (!TextUtils.isEmpty(url)) {
      return url.substring(url.lastIndexOf("/") + 1);
    }
    return System.currentTimeMillis() + "";
  }

  private void close(Closeable closeable) {
    try {
      closeable.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }


  public void setClient(OkHttpClient mClient) {
    this.mClient = mClient;
  }

  public Builder getBuilder() {
    return mBuilder;
  }

  public void setBuilder(Builder builder) {
    this.mBuilder = builder;
  }

  public String getId() {
    if (!TextUtils.isEmpty(id)) {
    } else {
      id = url;
    }
    return id;
  }

  public String getUrl() {
    return url;
  }

  public String getFileName() {
    return fileName;
  }


  public void setUploadStatus(int uploadStatus) {
    this.uploadStatus = uploadStatus;
  }

  public int getUploadStatus() {
    return uploadStatus;
  }


  public void setmListener(UploadTaskListener mListener) {
    this.mListener = mListener;
  }

  public static class Builder {
    private String id;// task id
    private String url;// file url
    private String fileName; // File name when saving
    private int uploadStatus = UploadStatus.UPLOAD_STATUS_INIT;
    private int chunck;//第几块
    private UploadTaskListener listener;

    /**
     * 作为上传task开始、删除、停止的key值，如果为空则默认是url
     *
     * @param id
     * @return
     */
    public Builder setId(String id) {
      this.id = id;
      return this;
    }

    /**
     * 上传url（not null）
     *
     * @param url
     * @return
     */
    public Builder setUrl(String url) {
      this.url = url;
      return this;
    }

    /**
     * 设置上传状态
     *
     * @param uploadStatus
     * @return
     */
    public Builder setUploadStatus(int uploadStatus) {
      this.uploadStatus = uploadStatus;
      return this;
    }

    /**
     * 第几块
     *
     * @param chunck
     * @return
     */
    public Builder setChunck(int chunck) {
      this.chunck = chunck;
      return this;
    }


    /**
     * 设置文件名
     *
     * @param fileName
     * @return
     */
    public Builder setFileName(String fileName) {
      this.fileName = fileName;
      return this;
    }

    /**
     * 设置上传回调
     *
     * @param listener
     * @return
     */
    public Builder setListener(UploadTaskListener listener) {
      this.listener = listener;
      return this;
    }

    public UploadTask build() {
      return new UploadTask(this);
    }
  }

  private void addParams(MultipartBody.Builder builder, Map params) {
    if (params != null && !params.isEmpty()) {
      for (String key : params.keySet()) {
        builder.addPart(Headers.of("Content-Disposition", "form-data; name=\"" + key + "\""),
            RequestBody.create(null, params.get(key)));
      }
    }
  }

}

UploadManager上传管理器

package com.mainaer.wjoklib.okhttp.upload;

import android.content.Context;

import android.database.sqlite.SQLiteDatabase;

 

import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

import java.util.concurrent.TimeUnit;

 

import okhttp3.OkHttpClient;

 

/**

 * 上传管理器

 *

 * @author wangjian

 * @date 2016/5/13 .

 */

public class UploadManager {

 

  private static Context mContext;

 

  private static SQLiteDatabase db;

  private OkHttpClient mClient;

 

  private int mPoolSize = 20;

  // 将执行结果保存在future变量中

  private Map mFutureMap;

  private ExecutorService mExecutor;

  private Map mCurrentTaskList;

 

  static UploadManager manager;

 

  /**

   * 方法加锁，防止多线程操作时出现多个实例

   */

  private static synchronized void init() {

    if (manager == null) {

      manager = new UploadManager();

    }

  }

 

  /**

   * 获得当前对象实例

   *

   * @return 当前实例对象

   */

  public final static UploadManager getInstance() {

    if (manager == null) {

      init();

    }

    return manager;

  }

 

  /**

   * 管理器初始化，建议在application中调用

   *

   * @param context

   */

  public static void init(Context context, SQLiteDatabase db1) {

    mContext = context;

    db = db1;

    getInstance();

  }

 

  public UploadManager() {

    initOkhttpClient();

 

    // 初始化线程池

    mExecutor = Executors.newFixedThreadPool(mPoolSize);

    mFutureMap = new HashMap<>();

    mCurrentTaskList = new HashMap<>();

  }

 

  /**

   * 初始化okhttp

   */

  private void initOkhttpClient() {

    OkHttpClient.Builder okBuilder = new OkHttpClient.Builder();

    okBuilder.connectTimeout(1000, TimeUnit.SECONDS);

    okBuilder.readTimeout(1000, TimeUnit.SECONDS);

    okBuilder.writeTimeout(1000, TimeUnit.SECONDS);

    mClient = okBuilder.build();

  }

 

  /**

   * 添加上传任务

   *

   * @param uploadTask

   */

  public void addUploadTask(UploadTask uploadTask) {

    if (uploadTask != null && !isUploading(uploadTask)) {

      uploadTask.setClient(mClient);

      uploadTask.setUploadStatus(UploadStatus.UPLOAD_STATUS_INIT);

      // 保存上传task列表

      mCurrentTaskList.put(uploadTask.getId(), uploadTask);

      Future future = mExecutor.submit(uploadTask);

      mFutureMap.put(uploadTask.getId(), future);

    }

  }

 

  private boolean isUploading(UploadTask task) {

    if (task != null) {

      if (task.getUploadStatus() == UploadStatus.UPLOAD_STATUS_UPLOADING) {

        return true;

      }

    }

    return false;

  }

 

  /**

   * 暂停上传任务

   *

   * @param id 任务id

   */

  public void pause(String id) {

    UploadTask task = getUploadTask(id);

    if (task != null) {

      task.setUploadStatus(UploadStatus.UPLOAD_STATUS_PAUSE);

    }

  }

 

  /**

   * 重新开始已经暂停的上传任务

   *

   * @param id 任务id

   */

  public void resume(String id, UploadTaskListener listener) {

    UploadTask task = getUploadTask(id);

    if (task != null) {

      addUploadTask(task);

    }

  }

 

/*  *//**

   * 取消上传任务(同时会删除已经上传的文件，和清空数据库缓存)

   *

   * @param id    任务id

   * @param listener

   *//*

  public void cancel(String id, UploadTaskListener listener) {

    UploadTask task = getUploadTask(id);

    if (task != null) {

      mCurrentTaskList.remove(id);

      mFutureMap.remove(id);

      task.setmListener(listener);

      task.cancel();

      task.setDownloadStatus(UploadStatus.DOWNLOAD_STATUS_CANCEL);

    }

  }*/

 

  /**

   * 实时更新manager中的task信息

   *

   * @param task

   */

  public void updateUploadTask(UploadTask task) {

    if (task != null) {

      UploadTask currTask = getUploadTask(task.getId());

      if (currTask != null) {

        mCurrentTaskList.put(task.getId(), task);

      }

    }

  }

 

  /**

   * 获得指定的task

   *

   * @param id task id

   * @return

   */

  public UploadTask getUploadTask(String id) {

    UploadTask currTask = mCurrentTaskList.get(id);

    if (currTask == null) {

        currTask = parseEntity2Task(new UploadTask.Builder().build());

        // 放入task list中

        mCurrentTaskList.put(id, currTask);

    }

 

    return currTask;

  }

 

 

  private UploadTask parseEntity2Task(UploadTask currTask) {

 

    UploadTask.Builder builder = new UploadTask.Builder()//

        .setUploadStatus(currTask.getUploadStatus())

        .setFileName(currTask.getFileName())//

        .setUrl(currTask.getUrl())

        .setId(currTask.getId());

 

      currTask.setBuilder(builder);

 

    return currTask;

  }

}

FileUtils文件分块类

package com.mainaer.wjoklib.okhttp.upload;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;

public class FileUtils {


  public static byte[] getBlock(long offset, File file, int blockSize) {
    byte[] result = new byte[blockSize];
    RandomAccessFile accessFile = null;
    try {
      accessFile = new RandomAccessFile(file, "r");
      accessFile.seek(offset);
      int readSize = accessFile.read(result);
      if (readSize == -1) {
        return null;
      } else if (readSize == blockSize) {
        return result;
      } else {
        byte[] tmpByte = new byte[readSize];
        System.arraycopy(result, 0, tmpByte, 0, readSize);
        return tmpByte;
      }


    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      if (accessFile != null) {
        try {
          accessFile.close();
        } catch (IOException e1) {
        }
      }
    }
    return null;
  }

}

UploadTaskListener 接口类

package com.mainaer.wjoklib.okhttp.upload; 

import com.mainaer.wjoklib.okhttp.download.DownloadStatus;

import java.io.File;

/**

 * Created by hst on 16/9/21.

 */

public interface UploadTaskListener {

  /**

   * 上传中

   *

   * @param percent

   * @param uploadTask

   */

  void onUploading(UploadTask uploadTask, String percent,int position)

 

  /**

   * 上传成功

   *

   * @param file

   * @param uploadTask

   */

  void onUploadSuccess(UploadTask uploadTask, File file);

 

  /**

   * 上传失败

   *

   * @param uploadTask

   * @param errorCode  {@link DownloadStatus}

   */

  void onError(UploadTask uploadTask, int errorCode,int position);  

 

  /**

  * 上传暂停

  *

  * @param uploadTask

  *

  */

  void onPause(UploadTask uploadTask);

 }

源码下载：okhttpUpLoader_jb51.rar

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


网页题目：android中okhttp实现断点上传示例
地址分享：http://cdiso.cn/article/pssgod.html

其他资讯

联系小谭

企业微信号
友情链接： app制作   成都气球装饰   app开发   成都网站运营维护   手机网站建设   网站设计公司   新津网站运维   成都网站建设推广   乐山网站建设   贵安服务器托管   

123ABC 成都网站建设，成都定制网站建设——全心全意建网站公司