移动架构33_网络访问框架与数据库框架实现断点下载

Demo地址：https://gitee.com/YuBaoZi/AndroidWenJianDuanDianXiaZai/blob/master/Download.rar
断点下载；
下载任务有优先级；
下载有回调；
网络自封装（fastjson和HttpClient）
数据库存储下载信息；
拓展性好，可以针对不同用户；

要点：
掌握网络框架的搭建
掌握数据库框架的封装
掌握数据的下载
网络框架和数据库框架的联合封装使用
数据库作用：记录文件下载记录、文件总长度、文件是否已经下载，可以不用实时更改当前文件的下载进度，利用File的长度，作为下载文件的起始值

一、实现数据库底层框架

具体详解：移动架构29_面向对象式手写数据库架构设计一

1、定义注解

实现业务类属性与数据库表中列名的兼容（翻译以及防止出现关键字）

@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)public @interface DbTable {    String value();}

@Target(ElementType.FIELD)@Retention(RetentionPolicy.RUNTIME)public @interface DbFiled {    String value();}

2、定义操作数据的接口和抽象类

封装表创建、增删改查的行为；业务生成sql语句、查询结果生成业务结果的逻辑是一致的，将其封装。

public interface IBaseDao<T> {    /**     * 插入数据     * @param entity     * @return     */    Long insert(T entity);    /**     *     * @param entity     * @param where     * @return     */    int  update(T entity, T where);    /**     * 删除数据     * @param where     * @return     */    int  delete(T where);    /**     * 查询数据     */    List<T> query(T where);    List<T> query(T where, String orderBy, Integer startIndex, Integer limit);    List<T> query(String sql);}

public abstract class BaseDao<T> implements IBaseDao<T> {    private boolean isInit = false;    protected SQLiteDatabase sqLiteDatabase;    private Class<T> entityClass;    private String tableName;    private Map<String, Field> cacheMap;    public String getTableName() {        return tableName;    }    @Override    public Long insert(T entity) {        ContentValues contentValues = getContentValues(entity);        long result = sqLiteDatabase.insert(tableName, null, contentValues);        return result;    }    private ContentValues getContentValues(T entity) {        ContentValues contentValues = new ContentValues();        try {            for (Map.Entry<String,Field> me:cacheMap.entrySet()){                if(me.getValue().get(entity)==null){                    continue;                }                contentValues.put(me.getKey(),me.getValue().get(entity).toString());            }        } catch (IllegalAccessException e) {            e.printStackTrace();        }        return contentValues;    }    @Override    public int update(T entity, T where) {        ContentValues contentValues = getContentValues(entity);        Condition condition = new Condition(getContentValues(where));        int update = sqLiteDatabase.update(tableName, contentValues, condition.whereClause, condition.whereArgs);        return update;    }    @Override    public int delete(T where) {        Condition condition = new Condition(getContentValues(where));        int delete = sqLiteDatabase.delete(tableName, condition.whereClause, condition.whereArgs);        return delete;    }    @Override    public List<T> query(T where) {        return query(where,null,null,null);    }    @Override    public List<T> query(T where, String orderBy, Integer startIndex, Integer limit) {        String limitString = null;        if(startIndex!=null && limit!=null){            limitString = startIndex+","+limit;        }        Condition condition = new Condition(getContentValues(where));        Cursor cursor = null;        List<T> result =new ArrayList<>();        try        {            cursor = sqLiteDatabase.query(tableName, null,condition.getWhereClause(),condition.whereArgs,null,null,orderBy,limitString);            result=getResult(cursor,where);        }catch (Exception e){            e.printStackTrace();        }finally {            if(cursor!=null){                cursor.close();            }        }        return result;    }    protected List<T> getResult(Cursor cursor, T where) {        ArrayList list = new ArrayList();        Object item;        while(cursor.moveToNext()){            try {                item = where.getClass().newInstance();                Iterator<Map.Entry<String, Field>> iterator = cacheMap.entrySet().iterator();                while(iterator.hasNext()){                    Map.Entry<String, Field> entry = iterator.next();                    String colmunName = entry.getKey();                    Field field = entry.getValue();                    int columnIndex = cursor.getColumnIndex(colmunName);                    Class type = field.getType();                    if(columnIndex!=-1){                        if(type==String.class){                            field.set(item,cursor.getString(columnIndex));                        }else if(type==Double.class){                            field.set(item,cursor.getDouble(columnIndex));                        }else if(type== Integer.class){                            field.set(item,cursor.getInt(columnIndex));                        }else if(type == Long.class){                            field.set(item,cursor.getLong(columnIndex));                        }else if(type == byte[].class){                            field.set(item,cursor.getBlob(columnIndex));                        }else{                            /**                             * 不支持的类型                             */                            continue;                        }                    }                }                list.add(item);            } catch (InstantiationException e) {                e.printStackTrace();            } catch (IllegalAccessException e) {                e.printStackTrace();            }        }        return list;    }    protected synchronized boolean init(Class<T> entity, SQLiteDatabase sqLiteDatabase) {        if (!isInit) {            this.sqLiteDatabase = sqLiteDatabase;            this.entityClass = entity;            if (entity.getAnnotation(DbTable.class) == null) {                tableName = entity.getClass().getSimpleName();            } else {                tableName = entity.getAnnotation(DbTable.class).value();            }            if (!sqLiteDatabase.isOpen()) {                return false;            }            if (!TextUtils.isEmpty(createTable())) {                sqLiteDatabase.execSQL(createTable());            }            cacheMap = new HashMap<>();            initCatchMap();            isInit = true;        }        return isInit;    }    /**     * 维护映射关系     */    private void initCatchMap() {        String sql = "select * from " + this.tableName + " limit 1,0";        Cursor cursor = null;        try {            cursor = sqLiteDatabase.rawQuery(sql, null);            /**             * 表的列名数组             */            String[] columnNames = cursor.getColumnNames();            /**             * 拿到Filed数组             */            Field[] columnFields = entityClass.getFields();            for (Field filed : columnFields) {                filed.setAccessible(true);                Field columnFiled = null;                String colmunName = null;                /**                 * 开始找对应关系                 */                for (String cn : columnNames) {                    String filedName = null;                    if(filed.getAnnotation(DbFiled.class)!=null){                        filedName = filed.getAnnotation(DbFiled.class).value();                    }else {                        filedName = filed.getName();                    }                    if(cn.equals(filedName)){                        columnFiled = filed;                        colmunName = cn;                        break;                    }                }                //找到了对应关系                if(columnFiled!=null){                    cacheMap.put(colmunName,columnFiled);                }            }        } catch (Exception e) {            e.printStackTrace();        } finally {            cursor.close();        }    }    public abstract String createTable();    class Condition{        /**         * 查询条件         * name=? && password =?         */        private String whereClause;        private  String[] whereArgs;        public Condition(ContentValues whereClause) {            ArrayList list=new ArrayList();            StringBuilder stringBuilder=new StringBuilder();            stringBuilder.append(" 1=1 ");            Set keys=whereClause.keySet();            Iterator iterator=keys.iterator();            while (iterator.hasNext())            {                String key= (String) iterator.next();                String value= (String) whereClause.get(key);                if (value!=null)                {                    /*                    拼接条件查询语句                    1=1 and name =? and password=?                     */                    stringBuilder.append(" and "+key+" =?");                    /**                     * ？----》value                     */                    list.add(value);                }            }            this.whereClause=stringBuilder.toString();            this.whereArgs= (String[]) list.toArray(new String[list.size()]);        }        public String[] getWhereArgs() {            return whereArgs;        }        public String getWhereClause() {            return whereClause;        }    }}

3、定义提供操作数据库类的工厂类

校验数据库创建、根据类型提供操作表的操作类

public class BaseDaoFactory {    private String sqlitDatabasePath;    private SQLiteDatabase sqLiteDatabase;    private static BaseDaoFactory instance = new BaseDaoFactory();    private BaseDaoFactory() {        sqlitDatabasePath = Environment.getExternalStorageDirectory().getAbsolutePath() + "/teacher.db";        openDatabase();    }    public synchronized <T extends BaseDao<M>, M> T getDataHelper(Class<T> clazz, Class<M> entityClass) {        T baseDao = null;        try {            baseDao = clazz.newInstance();            baseDao.init(entityClass, sqLiteDatabase);        } catch (InstantiationException e) {            e.printStackTrace();        } catch (IllegalAccessException e) {            e.printStackTrace();        }        return baseDao;    }    private void openDatabase() {        sqLiteDatabase = SQLiteDatabase.openOrCreateDatabase(sqlitDatabasePath, null);    }    public static BaseDaoFactory getInstance() {        return instance;    }}

二、定义网络框架

具体详解：移动架构32_自定义网络访问框架开发

1、定义网络请求的接口

public interface IHttpListener {    /**     * 网络访问     * 处理结果  回调     * @param httpEntity     */    void onSuccess(HttpEntity httpEntity);    void onFail();    void addHttpHeader(Map<String,String> headerMap);}

public interface IHttpService {    /**     * 设置url     * @param url     */    void setUrl(String url);    /**     * 执行获取网络     */    void excute();    /**     * 设置处理接口     * @param httpListener     */    void setHttpListener(IHttpListener httpListener);    /**     * 设置请求参数     * String  1     * byte[]  2     *     */    void setRequestData(byte[] requestData);    void pause();    /**     *     * 以下的方法是 额外添加的     * 获取请求头的map     * @return     */     Map<String,String> getHttpHeadMap();     boolean cancle();     boolean isCancle();     boolean isPause();}

2、请求与回调封装到一个类中

public class RequestHodler<T> {    /**     * 执行下载类     */    private IHttpService httpService;    /**     * 获取数据  回调结果的类     */    private IHttpListener httpListener;    /**     * 请求参数对应的实体     */    private T requestInfo;    private String url;    public IHttpService getHttpService() {        return httpService;    }    public void setHttpService(IHttpService httpService) {        this.httpService = httpService;    }    public IHttpListener getHttpListener() {        return httpListener;    }    public void setHttpListener(IHttpListener httpListener) {        this.httpListener = httpListener;    }    public T getRequestInfo() {        return requestInfo;    }    public void setRequestInfo(T requestInfo) {        this.requestInfo = requestInfo;    }    public String getUrl() {        return url;    }    public void setUrl(String url) {        this.url = url;    }}

3、定义管理网络请求的线程池

public class ThreadPoolManager {    private static final String TAG ="ThreadPoolManager" ;    private static  ThreadPoolManager instance=new ThreadPoolManager();    private LinkedBlockingQueue<Future<?>> taskQuene=new LinkedBlockingQueue<>();    private ThreadPoolExecutor threadPoolExecutor;    public static ThreadPoolManager getInstance() {        return instance;    }    private ThreadPoolManager()    {        threadPoolExecutor=new ThreadPoolExecutor(4,10,10, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(4), handler);        threadPoolExecutor.execute(runable);    }    public <T> boolean removeTask(FutureTask futureTask)    {        boolean result=false;        /**         * 阻塞式队列是否含有线程         */        if(taskQuene.contains(futureTask))        {            taskQuene.remove(futureTask);        }else        {            result=threadPoolExecutor.remove(futureTask);        }        return  result;    }    private Runnable runable =new Runnable() {        @Override        public void run() {            while (true)            {                FutureTask futrueTask=null;                try {                    /**                     * 阻塞式函数                     */                    Log.i(TAG,"等待队列     "+taskQuene.size());                    futrueTask= (FutureTask) taskQuene.take();                } catch (InterruptedException e) {                    e.printStackTrace();                }                if(futrueTask!=null)                {                    threadPoolExecutor.execute(futrueTask);                }                Log.i(TAG,"线程池大小      "+threadPoolExecutor.getPoolSize());            }        }    };    public <T> void execte(FutureTask<T> futureTask) throws InterruptedException {        taskQuene.put(futureTask);    }    private RejectedExecutionHandler handler=new RejectedExecutionHandler() {        @Override        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {            try {                taskQuene.put(new FutureTask<Object>(r,null) {                });            } catch (InterruptedException e) {                e.printStackTrace();            }        }    };}

4、定义异步操作作为网络请求实现的平台

public class HttpTask<T> implements Runnable {    private IHttpService httpService;    private FutureTask futureTask;    public HttpTask(RequestHodler<T> requestHodler)    {        httpService=requestHodler.getHttpService();        httpService.setHttpListener(requestHodler.getHttpListener());        httpService.setUrl(requestHodler.getUrl());        //增加方法        IHttpListener httpListener=requestHodler.getHttpListener();        httpListener.addHttpHeader(httpService.getHttpHeadMap());        try {            T request=requestHodler.getRequestInfo();            if(request!=null)            {                String requestInfo= JSON.toJSONString(request);                httpService.setRequestData(requestInfo.getBytes("UTF-8"));            }        } catch (Exception e) {            e.printStackTrace();        }    }    @Override    public void run() {        httpService.excute();    }    /**     * 新增方法     */    public void start()    {        futureTask=new FutureTask(this,null);        try {            ThreadPoolManager.getInstance().execte(futureTask);        } catch (InterruptedException e) {            e.printStackTrace();        }    }    /**     * 新增方法     */    public  void pause()    {        httpService.pause();        if(futureTask!=null)        {            ThreadPoolManager.getInstance().removeTask(futureTask);        }    }}

三、在网络与数据库框架的基础上再次封装

1、定义下载状态、优先级、停止模式

public enum  DownloadStatus {    waitting(0),    starting(1),    downloading(2),    pause(3),    finish(4),    failed(5)    ;    private int value;    private   DownloadStatus(int value)    {        this.value=value;    }    public int getValue() {        return value;    }    public void setValue(int value) {        this.value = value;    }}

public enum Priority{    /**     * 手动下载的优先级     */    low(0),    /**     * 主动推送资源的手动恢复的优先级     */    middle(1),    /**     * 主动推送资源的优先级     */    high(2);    Priority(int value)    {        this.value = value;    }    private int value;    public int getValue()    {        return value;    }    public void setValue(int value)    {        this.value = value;    }    public static Priority getInstance(int value)    {        for (Priority priority : Priority.values())        {            if (priority.getValue() == value)            {                return priority;            }        }        return Priority.middle;    }}

public enum DownloadStopMode{    /**     * 后台根据下载优先级调度自动停止下载任务     */    auto(0),    /**     * 手动停止下载任务     */    hand(1);    DownloadStopMode(Integer value)    {        this.value = value;    }    /**     * 值     */    private Integer value;    public Integer getValue()    {        return value;    }    public void setValue(Integer value)    {        this.value = value;    }    public static DownloadStopMode getInstance(int value)    {        for (DownloadStopMode mode : DownloadStopMode.values())        {            if (mode.getValue() == value)            {                return mode;            }        }        return DownloadStopMode.auto;    }}

2、定义业务Bean及其基类

public class BaseEntity<T> implements Serializable{        private static final long serialVersionUID = 1L;    public BaseEntity() {    }    public T copy() {        ByteArrayOutputStream byteArrayOutputStream = null;        ObjectOutputStream objectOutputStream = null;        try {            byteArrayOutputStream = new ByteArrayOutputStream();            objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);            objectOutputStream.writeObject(this);            ByteArrayInputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());            ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);            Object result = objectInputStream.readObject();            return (T) result;        } catch (IOException io) {            io.printStackTrace();        } catch (ClassNotFoundException classNot) {            classNot.printStackTrace();        } finally {            if(byteArrayOutputStream != null) {                try {                    byteArrayOutputStream.close();                } catch (IOException io) {                    io.printStackTrace();                }            }            if(objectOutputStream != null) {                try {                    objectOutputStream.close();                } catch (IOException io) {                    io.printStackTrace();                }            }        }        return null;    }}

@DbTable("t_downloadInfo")public class DownloadItemInfo extends  BaseEntity<DownloadItemInfo>  {    public long currentLength;    public long totalLength;    public  transient  HttpTask httpTask;    /**     * 下载id     */    public Integer id;    /**     * 下载url     */    public String url;    /**     * 下载存储的文件路径     */    public String filePath;    /**     * 下载文件显示名     */    public String displayName;    /**     * 下载文件总大小     */    public Long totalLen;    /**     * 下载文件当前大小     */    public Long currentLen;    /**     * 下载开始时间     */    public String startTime;    /**     * 下载结束时间     */    public String finishTime;    /**     * 用户id     */    public String userId;    /**     * 下载任务类型     */    public String httpTaskType;    /**     * 下载优先级     */    public Integer priority;    /**     * 下载停止模式     */    public Integer stopMode;    //下载的状态    public Integer status;    public Integer getId() {        return id;    }    public void setId(Integer id) {        this.id = id;    }    public String getDisplayName() {        return displayName;    }    public void setDisplayName(String displayName) {        this.displayName = displayName;    }    public Long getTotalLen() {        return totalLen;    }    public void setTotalLen(Long totalLen) {        this.totalLen = totalLen;    }    public Long getCurrentLen() {        return currentLen;    }    public void setCurrentLen(Long currentLen) {        this.currentLen = currentLen;    }    public void setFinishTime(String finishTime) {        this.finishTime = finishTime;    }    public String getUserId() {        return userId;    }    public void setUserId(String userId) {        this.userId = userId;    }    public String getHttpTaskType() {        return httpTaskType;    }    public void setHttpTaskType(String httpTaskType) {        this.httpTaskType = httpTaskType;    }    public Integer getPriority() {        return priority;    }    public void setPriority(Integer priority) {        this.priority = priority;    }    public Integer getStopMode() {        return stopMode;    }    public void setStopMode(Integer stopMode) {        this.stopMode = stopMode;    }    public DownloadItemInfo(String url, String filePath) {        this.url = url;        this.filePath = filePath;    }    public DownloadItemInfo( ) {    }    public Integer getStatus() {        return status;    }    public void setStatus(Integer status) {        this.status = status;    }    public long getCurrentLength() {        return currentLength;    }    public void setCurrentLength(long currentLength) {        this.currentLength = currentLength;    }    public long getTotalLength() {        return totalLength;    }    public void setTotalLength(long totalLength) {        this.totalLength = totalLength;    }    public String getUrl() {        return url;    }    public void setUrl(String url) {        this.url = url;    }    public String getFilePath() {        return filePath;    }    public void setFilePath(String filePath) {        this.filePath = filePath;    }    public HttpTask getHttpTask() {        return httpTask;    }    public void setHttpTask(HttpTask httpTask) {        this.httpTask = httpTask;    }    public void setStartTime(String startTime) {        this.startTime = startTime;    }}

3、定义下载的接口

public interface IDownLitener  extends IHttpListener{    void setHttpServive(IHttpService  httpServive);    void  setCancleCalle();    void  setPuaseCallble();}

/** * 断点续传监听接口 */public interface IDownloadCallable{    /**     * 新增下载任务的监听     *     * @param downloadId     *            下载id     */    void onDownloadInfoAdd(int downloadId);    /**     * 删除下载任务的监听     *     * @param downloadId     *            下载id     */    void onDownloadInfoRemove(int downloadId);    /**     * 下载状态变化     *     * @param downloadId     *            下载id     * @param status     *            下载状态     */    void onDownloadStatusChanged(int downloadId, DownloadStatus status);    /**     * 获取了下载文件总的长度     *     * @param downloadId     *            下载id     * @param totalLength     *            下载文件总的长度     */    void onTotalLengthReceived(int downloadId, long totalLength);    /**     * 下载进度     *     * @param downloadId     *            下载id     * @param downloadpercent     *            下载的百分比     * @param speed     *            下载速度     */    void onCurrentSizeChanged(int downloadId, double downloadpercent, long speed);    /**     * 下载成功     *     * @param downloadId     *            下载id     */    void onDownloadSuccess(int downloadId);    /**     * 下载失败监听     *     * @param downloadId     *            下载id     * @param errorCode     *            下载错误码     * @param errorMsg     *            下载错误信息     */    void onDownloadError(int downloadId, int errorCode, String errorMsg);}

public interface IDownloadServiceCallable {    void onDownloadStatusChanged(DownloadItemInfo downloadItemInfo);    void onTotalLengthReceived(DownloadItemInfo downloadItemInfo);    void onCurrentSizeChanged(DownloadItemInfo downloadItemInfo, double downLenth, long speed);    void onDownloadSuccess(DownloadItemInfo downloadItemInfo);    void onDownloadPause(DownloadItemInfo downloadItemInfo);    void onDownloadError(DownloadItemInfo downloadItemInfo, int var2, String var3);}

4、实现数据具体操作

public class DownLoadDao extends BaseDao<DownloadItemInfo> {    /**     * 保存应该下载的集合     * 不包括已经下载成功的     */    private List<DownloadItemInfo> downloadItemInfoList=            Collections.synchronizedList(new ArrayList<DownloadItemInfo>());    private DownloadInfoComparator downloadInfoComparator=new DownloadInfoComparator();    @Override    public String createTable() {        return "create table if not exists  t_downloadInfo(" + "id Integer primary key, " + "url TEXT not null," + "filePath TEXT not null, " + "displayName TEXT, " + "status Integer, " + "totalLen Long, " + "currentLen Long," + "startTime TEXT," + "finishTime TEXT," + "userId TEXT, " + "httpTaskType TEXT," + "priority  Integer," + "stopMode Integer," + "downloadMaxSizeKey TEXT," + "unique(filePath))";    }    @Override    public List<DownloadItemInfo> query(String sql) {        return null;    }    /**     * id     */    /**     * 生成下载id     *     * @return 返回下载id     */    private Integer generateRecordId()    {        int maxId = 0;        String sql = "select max(id)  from " +getTableName() ;        synchronized (DownLoadDao.class)        {            Cursor cursor = this.sqLiteDatabase.rawQuery(sql,null);            if(cursor.moveToNext())            {                String[] colmName=cursor.getColumnNames();                int index=cursor.getColumnIndex("max(id)");                if(index!=-1)                {                    Object value =cursor.getInt(index);                    if (value != null)                    {                        maxId = Integer.parseInt(String.valueOf(value));                    }                }            }        }        return maxId + 1;    }    /**     * 根据下载地址和下载文件路径查找下载记录     *     * @param url     *            下载地址     * @param filePath     *            下载文件路径     * @return     */    public DownloadItemInfo findRecord(String url, String filePath)    {        synchronized (DownLoadDao.class)        {            for (DownloadItemInfo record : downloadItemInfoList)            {                if (record.getUrl().equals(url) && record.getFilePath().equals(filePath))                {                    return record;                }            }            /**             * 内存集合找不到             * 就从数据库中查找             */            DownloadItemInfo where = new DownloadItemInfo();            where.setUrl(url);            where.setFilePath(filePath);            List<DownloadItemInfo> resultList = super.query(where);            if (resultList.size() > 0)            {                return resultList.get(0);            }            return null;        }    }    /**     * 根据 下载文件路径查找下载记录     *     *            下载地址     * @param filePath     *            下载文件路径     * @return     */    public List<DownloadItemInfo> findRecord(String filePath)    {        synchronized (DownLoadDao.class)        {            DownloadItemInfo where = new DownloadItemInfo();            where.setFilePath(filePath);            List<DownloadItemInfo> resultList = super.query(where);            return resultList;        }    }    /**     * 添加下载记录     *     * @param url     *            下载地址     * @param filePath     *            下载文件路径     * @param displayName     *            文件显示名     * @param priority     *            小组优先级     *            TODO     * @return 下载id     */    public int addRecrod(String url, String filePath, String displayName , int priority)    {        synchronized (DownLoadDao.class)        {            DownloadItemInfo existDownloadInfo = findRecord(url, filePath);            if (existDownloadInfo == null)            {                DownloadItemInfo record = new DownloadItemInfo();                record.setId(generateRecordId());                record.setUrl(url);                record.setFilePath(filePath);                record.setDisplayName(displayName);                record.setStatus(DownloadStatus.waitting.getValue());                record.setTotalLen(0L);                record.setCurrentLen(0L);                java.text.SimpleDateFormat dateFormat = new java.text.SimpleDateFormat("yyyy-MM-dd-HH-mm-ss");                record.setStartTime(dateFormat.format(new Date()));                record.setFinishTime("0");                record.setPriority(priority);                super.insert(record);                downloadItemInfoList.add(record);                return record.getId();            }            return -1;        }    }    /**     * 更新下载记录     *     * @param record     *            下载记录     * @return     */    public int updateRecord(DownloadItemInfo record)    {        DownloadItemInfo where = new DownloadItemInfo();        where.setId(record.getId());        int result = 0;        synchronized (DownLoadDao.class)        {            try            {                result = super.update(record, where);            }            catch (Throwable e)            {            }            if (result > 0)            {                for (int i = 0; i < downloadItemInfoList.size(); i++)                {                    if (downloadItemInfoList.get(i).getId().intValue() == record.getId())                    {                        downloadItemInfoList.set(i, record);                        break;                    }                }            }        }        return result;    }    /**     * 根据下载地址和下载文件路径查找下载记录     *     *            下载地址     * @param filePath     *            下载文件路径     * @return     */    public DownloadItemInfo findSigleRecord(String filePath)    {        List<DownloadItemInfo> downloadInfoList = findRecord(filePath);        if(downloadInfoList.isEmpty())        {            return null;        }        return downloadInfoList.get(0);    }    /**     * 根据id查找下载记录对象     *     * @param recordId     * @return     */    public DownloadItemInfo findRecordById(int recordId)    {        synchronized (DownLoadDao.class)        {            for (DownloadItemInfo record :downloadItemInfoList)            {                if (record.getId() == recordId)                {                    return record;                }            }            DownloadItemInfo where = new DownloadItemInfo();            where.setId(recordId);            List<DownloadItemInfo> resultList = super.query(where);            if (resultList.size() > 0)            {                return resultList.get(0);            }            return null;        }    }    /**     * 根据id从内存中移除下载记录     *     * @param id     *            下载id     * @return true标示删除成功，否则false     */    public boolean removeRecordFromMemery(int id)    {        synchronized (DownloadItemInfo.class)        {            for (int i = 0; i < downloadItemInfoList.size(); i++)            {                if (downloadItemInfoList.get(i).getId() == id)                {                    downloadItemInfoList.remove(i);                    break;                }            }            return true;        }    }    /**     * 比较器     */    class DownloadInfoComparator implements Comparator<DownloadItemInfo>    {        @Override        public int compare(DownloadItemInfo lhs, DownloadItemInfo rhs)        {            return rhs.getId() - lhs.getId();        }    }}

5、实现下载和回调的接口

public class DownLoadLitener  implements IDownLitener{    private  DownloadItemInfo downloadItemInfo;    private File file;    protected  String url;    private long breakPoint;    private IDownloadServiceCallable downloadServiceCallable;    private IHttpService httpService;    /**     * 得到主线程     */    private Handler handler=new Handler(Looper.getMainLooper());    public DownLoadLitener(DownloadItemInfo downloadItemInfo,                           IDownloadServiceCallable downloadServiceCallable,                           IHttpService httpService) {        this.downloadItemInfo = downloadItemInfo;        this.downloadServiceCallable = downloadServiceCallable;        this.httpService = httpService;        this.file=new File(downloadItemInfo.getFilePath());        /**         * 得到已经下载的长度         */        this.breakPoint=file.length();    }    /**     * 2     * @param headerMap     */    public void addHttpHeader(Map<String,String> headerMap)    {        long length=getFile().length();        if(length>0L)        {            headerMap.put("RANGE","bytes="+length+"-");        }    }    public DownLoadLitener(DownloadItemInfo downloadItemInfo) {        this.downloadItemInfo = downloadItemInfo;    }    @Override    public void setHttpServive(IHttpService httpServive) {        this.httpService=httpServive;    }    /**     * 设置取消接口     */    @Override    public void setCancleCalle() {    }    @Override    public void setPuaseCallble() {    }    @Override    public void onSuccess(HttpEntity httpEntity) {        InputStream inputStream = null;        try {            inputStream = httpEntity.getContent();        } catch (IOException e) {            e.printStackTrace();        }        long startTime = System.currentTimeMillis();        //用于计算每秒多少k        long speed = 0L;        //花费时间        long useTime = 0L;        //下载的长度        long getLen = 0L;        //接受的长度        long receiveLen = 0L;        boolean bufferLen = false;        //得到下载的长度        long dataLength = httpEntity.getContentLength();        //单位时间下载的字节数        long calcSpeedLen = 0L;        //总数        long totalLength = this.breakPoint + dataLength;        //更新数量        this.receviceTotalLength(totalLength);        //更新状态        this.downloadStatusChange(DownloadStatus.downloading);        byte[] buffer = new byte[512];        int count = 0;        long currentTime = System.currentTimeMillis();        BufferedOutputStream bos = null;        FileOutputStream fos = null;        try {            if (!makeDir(this.getFile().getParentFile())) {                downloadServiceCallable.onDownloadError(downloadItemInfo,1,"创建文件夹失败");            } else {                fos = new FileOutputStream(this.getFile(), true);                bos = new BufferedOutputStream(fos);                int length = 1;                while ((length = inputStream.read(buffer)) != -1) {                    if (this.getHttpService().isCancle()) {                        downloadServiceCallable.onDownloadError(downloadItemInfo, 1, "用户取消了");                        return;                    }                    if (this.getHttpService().isPause()) {                        downloadServiceCallable.onDownloadError(downloadItemInfo, 2, "用户暂停了");                        return;                    }                    bos.write(buffer, 0, length);                    getLen += (long) length;                    receiveLen += (long) length;                    calcSpeedLen += (long) length;                    ++count;                    if (receiveLen * 10L / totalLength >= 1L || count >= 5000) {                        currentTime = System.currentTimeMillis();                        useTime = currentTime - startTime;                        startTime = currentTime;                        speed = 1000L * calcSpeedLen / useTime;                        count = 0;                        calcSpeedLen = 0L;                        receiveLen = 0L;                        //应该保存数据库                        this.downloadLengthChange(this.breakPoint + getLen, totalLength, speed);                    }                }                bos.close();                inputStream.close();                if (dataLength != getLen) {                    downloadServiceCallable.onDownloadError(downloadItemInfo, 3, "下载长度不相等");                } else {                    this.downloadLengthChange(this.breakPoint + getLen, totalLength, speed);                    this.downloadServiceCallable.onDownloadSuccess(downloadItemInfo.copy());                }            }        } catch (IOException ioException) {            if (this.getHttpService() != null) {//                this.getHttpService().abortRequest();            }            return;        } catch (Exception e) {            if (this.getHttpService() != null) {//                this.getHttpService().abortRequest();            }        } finally {            try {                if (bos != null) {                    bos.close();                }                if (httpEntity != null) {                    inputStream.close();                }            } catch (IOException e) {                e.printStackTrace();            }        }    }    /**     * 创建文件夹的操作     * @param parentFile     * @return     */    private boolean makeDir(File parentFile) {        return parentFile.exists()&&!parentFile.isFile()                ?parentFile.exists()&&parentFile.isDirectory():                parentFile.mkdirs();    }    private void downloadLengthChange(final long downlength, final long totalLength, final long speed) {        downloadItemInfo.setCurrentLength(downlength);        if(downloadServiceCallable!=null)        {            DownloadItemInfo copyDownItenIfo=downloadItemInfo.copy();            synchronized (this.downloadServiceCallable)            {                handler.post(new Runnable() {                    @Override                    public void run() {                        downloadServiceCallable.onCurrentSizeChanged(downloadItemInfo,(double) downlength/(double)totalLength,speed);                    }                });            }        }    }    /**     * 更改下载时的状态     * @param downloading     */    private void downloadStatusChange(DownloadStatus downloading) {        downloadItemInfo.setStatus(downloading.getValue());        final DownloadItemInfo copyDownloadItemInfo=downloadItemInfo.copy();        if(downloadServiceCallable!=null)        {            synchronized (this.downloadServiceCallable)            {                handler.post(new Runnable() {                    @Override                    public void run() {                        downloadServiceCallable.onDownloadStatusChanged(copyDownloadItemInfo);                    }                });            }        }    }    /**     * 回调  长度的变化     * @param totalLength     */    private void receviceTotalLength(long totalLength) {        downloadItemInfo.setCurrentLength(totalLength);        final DownloadItemInfo copyDownloadItemInfo=downloadItemInfo.copy();        if(downloadServiceCallable!=null)        {            synchronized (this.downloadServiceCallable)            {                handler.post(new Runnable() {                    @Override                    public void run() {                        downloadServiceCallable.onTotalLengthReceived(copyDownloadItemInfo);                    }                });            }        }    }    @Override    public void onFail() {    }    public IHttpService getHttpService() {        return httpService;    }    public File getFile() {        return file;    }}

public class FileDownHttpService implements IHttpService {    private static final String TAG = "FileDownHttpService";    /**     * 即将添加到请求头的信息     */    private Map<String ,String> headerMap= Collections.synchronizedMap(new HashMap<String ,String>());    /**     * 含有请求处理的 接口     */    private IHttpListener httpListener;    private HttpClient httpClient=new DefaultHttpClient();    private HttpGet httpPost;    private String url;    private byte[] requestDate;    /**     * httpClient获取网络的回调     */    private  HttpRespnceHandler httpRespnceHandler=new HttpRespnceHandler();    /**     * 增加方法     */    private AtomicBoolean pause=new AtomicBoolean(false);    @Override    public void setUrl(String url) {        this.url=url;    }    @Override    public void excute() {        httpPost=new HttpGet(url);        constrcutHeader();//        ByteArrayEntity byteArrayEntity=new ByteArrayEntity(requestDate);//        httpPost.setEntity(byteArrayEntity);        try {            httpClient.execute(httpPost,httpRespnceHandler);        } catch (IOException e) {            httpListener.onFail();        }    }    /**     * 1     */    private void constrcutHeader() {        Iterator iterator=headerMap.keySet().iterator();        while (iterator.hasNext())        {            String key= (String) iterator.next();            String value=headerMap.get(key);            Log.i(TAG," 请求头信息  "+key+"  value "+value);            httpPost.addHeader(key,value);        }    }    public Map<String, String> getHeaderMap() {        return headerMap;    }    @Override    public void setHttpListener(IHttpListener httpListener) {        this.httpListener=httpListener;    }    @Override    public void setRequestData(byte[] requestData) {        this.requestDate=requestData;    }    @Override    public void pause() {        pause.compareAndSet(false,true);    }    @Override    public Map<String, String> getHttpHeadMap() {        return headerMap;    }    @Override    public boolean cancle() {        return false;    }    @Override    public boolean isCancle() {        return false;    }    @Override    public boolean isPause() {        return pause.get();    }    private class HttpRespnceHandler extends BasicResponseHandler    {        @Override        public String handleResponse(HttpResponse response) throws ClientProtocolException {            //响应吗            int code=response.getStatusLine().getStatusCode();            if(code==200||206==code)            {                httpListener.onSuccess(response.getEntity());            }else            {                ListView list;                httpListener.onFail();            }            return null;        }    }}

6、将整个逻辑进行封装、链接、启动，形成调用工具类

public class DownFileManager implements IDownloadServiceCallable {    private static final String TAG ="DownFileManager " ;    //    private  static    private byte[] lock=new byte[0];    DownLoadDao downLoadDao= BaseDaoFactory.getInstance().            getDataHelper(DownLoadDao.class,DownloadItemInfo.class);    java.text.SimpleDateFormat dateFormat = new java.text.SimpleDateFormat("yyyy-MM-dd-HH-mm-ss");    /**     * 观察者模式     */    private final List<IDownloadCallable> applisteners = new CopyOnWriteArrayList<IDownloadCallable>();    /**     * 正在下载的所有任务     */    private static List<DownloadItemInfo> downloadFileTaskList = new CopyOnWriteArrayList();    Handler handler=new Handler(Looper.getMainLooper());    public int download(String url)    {        String[] preFix=url.split("/");        return this.download(url,Environment.getExternalStorageDirectory().getAbsolutePath()+"/"+preFix[preFix.length-1]);    }    public int download(String url, String filePath )    {        String[] preFix=url.split("/");        String displayName=preFix[preFix.length-1];        return this.download(url,filePath,displayName);    }    public int download(String url, String filePath, String displayName)    {        return this.download(url,filePath,displayName,Priority.middle);    }    public int download(String url, String filePath,                        String displayName , Priority priority ) {        if(priority==null)        {            priority=Priority.low;        }        File file=new File(filePath);        DownloadItemInfo downloadItemInfo=null;        downloadItemInfo=downLoadDao.findRecord(url,filePath);        //没下载        if(downloadItemInfo==null)        {            /**             * 根据文件路径查找             */            List<DownloadItemInfo> samesFile=downLoadDao.findRecord(filePath);            /**             * 大于0  表示下载             */            if(samesFile.size()>0)            {                DownloadItemInfo sameDown=samesFile.get(0);                if(sameDown.getCurrentLen()==sameDown.getTotalLen())                {                    synchronized (applisteners)                    {                        for (IDownloadCallable downloadCallable:applisteners)                        {                            downloadCallable.onDownloadError(sameDown.getId(),2,"文件已经下载了");                        }                    }                }            }            /**---------------------------------------------             * 插入数据库             * 可能插入失败             * 因为filePath  和id是独一无二的  在数据库建表时已经确定了             */           int recrodId=downLoadDao.addRecrod(url,filePath,displayName,priority.getValue());            if(recrodId!=-1)            {                synchronized (applisteners)                {                    for (IDownloadCallable downloadCallable:applisteners)                    {                        //通知应用层  数据库被添加了                        downloadCallable.onDownloadInfoAdd(downloadItemInfo.getId());                    }                }            }            //插入失败时，再次进行查找，确保能查得到            else            {                //插入                downloadItemInfo=downLoadDao.findRecord(url,filePath);            }        }        /**-----------------------------------------------         * 括号写错了  放在外面         *         * 是否正在下载`         */        if(isDowning(file.getAbsolutePath()))        {            synchronized (applisteners)            {                for (IDownloadCallable downloadCallable:applisteners)                {                    downloadCallable.onDownloadError(downloadItemInfo.getId(),4,"正在下载，请不要重复添加");                }            }            return downloadItemInfo.getId();        }        if(downloadItemInfo!=null)        {            downloadItemInfo.setPriority(priority.getValue());            //添加----------------------------------------------------            downloadItemInfo.setStopMode(DownloadStopMode.auto.getValue());            //判断数据库存的 状态是否是完成            if(downloadItemInfo.getStatus()!= DownloadStatus.finish.getValue())            {                if(downloadItemInfo.getTotalLen()==0L||file.length()==0L)                {                    Log.i(TAG,"还未开始下载");                    //----------------------删除--------------------                    downloadItemInfo.setStatus(DownloadStatus.failed.getValue());                }                //判断数据库中 总长度是否等于文件长度                if(downloadItemInfo.getTotalLen()==file.length()&&downloadItemInfo.getTotalLen()!=0)                {                    downloadItemInfo.setStatus(DownloadStatus.finish.getValue());                    synchronized (applisteners)                    {                        for (IDownloadCallable downloadCallable:applisteners)                        {                            try {                                downloadCallable.onDownloadError(downloadItemInfo.getId(),4,"已经下载了");                            }catch (Exception e)                            {                            }                        }                    }                }            }            //------------------添加--------            else            {                if(!file.exists()||(downloadItemInfo.getTotalLen()!=downloadItemInfo.getCurrentLen()))                {                    downloadItemInfo.setStatus(DownloadStatus.failed.getValue());                }            }            /**             *             * 更新             */            downLoadDao.updateRecord(downloadItemInfo);            //移到括号里面来----------------------------------------------------            /**             * 判断是否已经下载完成             */            if(downloadItemInfo.getStatus()==DownloadStatus.finish.getValue())            {                Log.i(TAG,"已经下载完成  回调应用层");                final int downId=downloadItemInfo.getId();                synchronized (applisteners)                {                    handler.post(new Runnable() {                        @Override                        public void run() {                            for (IDownloadCallable downloadCallable:applisteners)                            {                                downloadCallable.onDownloadStatusChanged(downId,DownloadStatus.finish);                            }                        }                    });                }                downLoadDao.removeRecordFromMemery(downId);                return downloadItemInfo.getId();            }//之前的下载 状态为暂停状态            List<DownloadItemInfo> allDowning=downloadFileTaskList;            //当前下载不是最高级  则先退出下载            if(priority!=Priority.high)            {                for(DownloadItemInfo downling:allDowning)                {                    //从下载表中  获取到全部正在下载的任务                    downling=downLoadDao.findSigleRecord(downling.getFilePath());                    if(downling!=null&&downling.getPriority()==Priority.high.getValue())                    {                        /**                         *     更改---------                         *     当前下载级别不是最高级 传进来的是middle    但是在数据库中查到路径一模一样 的记录   所以他也是最高级------------------------------                         *     比如 第一次下载是用最高级下载，app闪退后，没有下载完成，第二次传的是默认级别，这样就应该是最高级别下载                         */                        if (downling.getFilePath().equals(downloadItemInfo.getFilePath()))                        {                            break;                        }                        else                        {                            return downloadItemInfo.getId();                        }//                        if(downloadItemInfo.getFilePath().equals(downling.getFilePath()))//                        {//                            return downloadItemInfo.getId();//                        }                    }                }            }            //            reallyDown(downloadItemInfo);            if(priority==Priority.high||priority== Priority.middle)            {                synchronized (allDowning)                {                    for (DownloadItemInfo downloadItemInfo1:allDowning)                    {                        if(!downloadItemInfo.getFilePath().equals(downloadItemInfo1.getFilePath()))                        {                            DownloadItemInfo downingInfo=downLoadDao.findSigleRecord(downloadItemInfo1.getFilePath());                            if(downingInfo!=null)                            {                                pause(downloadItemInfo.getId(),DownloadStopMode.auto);                            }                        }                    }                }                return downloadItemInfo.getId();            }        }      return  -1;    }    /**     * 停止     * @param downloadId     * @param mode     */    public void pause(int downloadId, DownloadStopMode mode)    {        if (mode == null)        {            mode = DownloadStopMode.auto;        }        final DownloadItemInfo downloadInfo =downLoadDao.findRecordById(downloadId);        if (downloadInfo != null)        {            // 更新停止状态            if (downloadInfo != null)            {                downloadInfo.setStopMode(mode.getValue());                downloadInfo.setStatus(DownloadStatus.pause.getValue());                downLoadDao.updateRecord(downloadInfo);            }            for (DownloadItemInfo downing:downloadFileTaskList)            {                if(downloadId==downing.getId())                {                    downing.getHttpTask().pause();                }            }        }    }    /**     * 判断当前是否正在下载     *     * @param absolutePath     * @return     */    private boolean isDowning(String absolutePath) {        for (DownloadItemInfo downloadItemInfo:downloadFileTaskList)        {            if(downloadItemInfo.getFilePath().equals(absolutePath))            {                return true;            }        }        return false;    }    /**     * 添加观察者     * @param downloadCallable     */    public void setDownCallable(IDownloadCallable downloadCallable)    {        synchronized (applisteners)        {             applisteners.add(downloadCallable);        }    }    /**     * 下载     */    public DownloadItemInfo reallyDown(DownloadItemInfo downloadItemInfo)    {        synchronized (lock)        {            //实例化DownloadItem            RequestHodler requestHodler=new RequestHodler();            //设置请求下载的策略            IHttpService httpService=new FileDownHttpService();            //得到请求头的参数 map            Map<String,String> map=httpService.getHttpHeadMap();            /**             * 处理结果的策略             */            IHttpListener httpListener=new DownLoadLitener(downloadItemInfo,this,httpService);            requestHodler.setHttpListener(httpListener);            requestHodler.setHttpService(httpService);            /**             *  bug  url             */            requestHodler.setUrl(downloadItemInfo.getUrl());            HttpTask httpTask=new HttpTask(requestHodler);            downloadItemInfo.setHttpTask(httpTask);            /**             * 添加             */            downloadFileTaskList.add(downloadItemInfo);            httpTask.start();        }        return downloadItemInfo;    }    @Override    public void onDownloadStatusChanged(DownloadItemInfo downloadItemInfo) {    }    @Override    public void onTotalLengthReceived(DownloadItemInfo downloadItemInfo) {    }    @Override    public void onCurrentSizeChanged(DownloadItemInfo downloadItemInfo, double downLenth, long speed) {        Log.i(TAG,"下载速度："+ speed/1000 +"k/s");        Log.i(TAG,"-----路径  "+ downloadItemInfo.getFilePath()+"  下载长度  "+downLenth+"   速度  "+speed);    }    @Override    public void onDownloadSuccess(DownloadItemInfo downloadItemInfo) {        Log.i(TAG,"下载成功    路劲  "+ downloadItemInfo.getFilePath()+"  url "+ downloadItemInfo.getUrl());    }    @Override    public void onDownloadPause(DownloadItemInfo downloadItemInfo) {  }    @Override    public void onDownloadError(DownloadItemInfo downloadItemInfo, int var2, String var3) {    }}

四、调用

DownFileManager downFileService=new DownFileManager();     downFileService.download("http://gdown.baidu.com/data/wisegame/8be18d2c0dc8a9c9/WPSOffice_177.apk");