Introduction à cette section :
C'est un autre piège profond, les débutants doivent être prudents... Cette section passera du téléchargement monothread ordinaire -> au téléchargement multithread ordinaire -> -> et à un exemple très pratique : utiliser DownloadManager d'Android pour mettre à jour l'APK et l'installer par écrasement ! Bon, vu comme ça, cette section est assez intéressante. Commençons cette section ! PS : Nous mettrons le téléchargement multithread complet avec reprise dans la section suivante !
1. Téléchargement de fichier monothread normal :
Utilisez directement URLConnection.openStream() pour ouvrir le flux d'entrée réseau, puis écrivez le flux dans un fichier !
Méthode principale：
public static void downLoad(String path,Context context)throws Exception
{
URL url = new URL(path);
InputStream is = url.openStream();
//截取最后的文件名
String end = path.substring(path.lastIndexOf("."));
//打开手机对应的输出流,输出到文件中
OutputStream os = context.openFileOutput("Cache_"+System.currentTimeMillis()+end, Context.MODE_PRIVATE);
byte[] buffer = new byte[1024];
int len = 0;
//从输入六中读取数据,读到缓冲区中
while((len = is.read(buffer)) > 0)
{
os.write(buffer,0,len);
}
//关闭输入输出流
is.close();
os.close();
}
Résultat de l'exécution：
2. Téléchargement multithread normal :
Nous savons tous que l'utilisation du multithreading pour télécharger des fichiers peut permettre de terminer le téléchargement plus rapidement, mais pourquoi ?
Réponse : parce qu'il s'empare de davantage de ressources du serveur. Supposons que le serveur puisse servir jusqu'à 100 utilisateurs, et qu'un thread dans le serveur corresponde à un utilisateur. 100 threads s'exécutent simultanément sur l'ordinateur, le CPU divisant les tranches de temps et les exécutant à tour de rôle. Si 'a' a 99 threads qui téléchargent des fichiers, cela équivaut à occuper 99 ressources utilisateur, donc naturellement la vitesse de téléchargement est plus rapide.
PS: Bien sûr, plus de threads n'est pas nécessairement mieux. Si trop de threads sont démarrés, l'application doit maintenir et synchroniser la surcharge de chaque thread. Ces surcharges peuvent au contraire entraîner une diminution de la vitesse de téléchargement. Cela dépend aussi de la vitesse de votre réseau !
Processus de téléchargement multithread：
- Obtenir la connexion réseau
- Créer un fichier vide de la même taille sur le disque local
- Calculer depuis quelle partie du fichier chaque thread doit commencer le téléchargement, et où il se termine
- Créer et démarrer plusieurs threads en séquence pour télécharger les parties spécifiées de la ressource réseau
PS : il suffit de créer un projet Java ici, puis d'exécuter la méthode spécifiée dans JUnit.
Le code principal est le suivant：
public class Downloader {
//添加@Test标记是表示该方法是Junit测试的方法,就可以直接运行该方法了
@Test
public void download() throws Exception
{
//设置URL的地址和下载后的文件名
String filename = "meitu.exe";
String path = "http://10.13.20.32:8080/Test/XiuXiu_Green.exe";
URL url = new URL(path);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setConnectTimeout(5000);
conn.setRequestMethod("GET");
//获得需要下载的文件的长度(大小)
int filelength = conn.getContentLength();
System.out.println("要下载的文件长度"+filelength);
//生成一个大小相同的本地文件
RandomAccessFile file = new RandomAccessFile(filename, "rwd");
file.setLength(filelength);
file.close();
conn.disconnect();
//设置有多少条线程下载
int threadsize = 3;
//计算每个线程下载的量
int threadlength = filelength % 3 == 0 ? filelength/3:filelength+1;
for(int i = 0;i < threadsize;i++)
{
//设置每条线程从哪个位置开始下载
int startposition = i * threadlength;
//从文件的什么位置开始写入数据
RandomAccessFile threadfile = new RandomAccessFile(filename, "rwd");
threadfile.seek(startposition);
//启动三条线程分别从startposition位置开始下载文件
new DownLoadThread(i,startposition,threadfile,threadlength,path).start();
}
int quit = System.in.read();
while('q' != quit)
{
Thread.sleep(2000);
}
}
private class DownLoadThread extends Thread {
private int threadid;
private int startposition;
private RandomAccessFile threadfile;
private int threadlength;
private String path;
public DownLoadThread(int threadid, int startposition,
RandomAccessFile threadfile, int threadlength, String path) {
this.threadid = threadid;
this.startposition = startposition;
this.threadfile = threadfile;
this.threadlength = threadlength;
this.path = path;
}
public DownLoadThread() {}
@Override
public void run() {
try
{
URL url = new URL(path);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setConnectTimeout(5000);
conn.setRequestMethod("GET");
//指定从什么位置开始下载
conn.setRequestProperty("Range", "bytes="+startposition+"-");
//System.out.println(conn.getResponseCode());
if(conn.getResponseCode() == 206)
{
InputStream is = conn.getInputStream();
byte[] buffer = new byte[1024];
int len = -1;
int length = 0;
while(length < threadlength && (len = is.read(buffer)) != -1)
{
threadfile.write(buffer,0,len);
//计算累计下载的长度
length += len;
}
threadfile.close();
is.close();
System.out.println("线程"+(threadid+1) + "已下载完成");
}
}catch(Exception ex){System.out.println("线程"+(threadid+1) + "下载出错"+ ex);}
}
}
}
Capture d'écran de l'exécution :
Comme le montre la figure, le multithreading est utilisé pour terminer le téléchargement du fichier ! Double-cliquez sur le fichier exe pour l'exécuter, ce qui indique que le fichier n'est pas corrompu !
Notes :
- int filelength = conn.getContentLength(); //Obtenir la longueur (taille) du fichier téléchargé
- RandomAccessFile file = new RandomAccessFile(filename, "rwd"); //Cette classe permet la lecture et l'écriture dans le fichier, et est au cœur du téléchargement multithread
- int threadlength = filelength % 3 == 0 ? filelength/3:filelength+1; //Calculer la quantité que chaque thread doit télécharger
- conn.setRequestProperty("Range", "bytes="+startposition+"-"); //Spécifier où commencer la lecture et l'écriture. C'est une méthode fournie par URLConnection
- //System.out.println(conn.getResponseCode()); //Ce code commenté sert à vérifier le code de réponse de conn. Nous utilisions 200 auparavant, mais pour le multithreading, il s'agit généralement de 206. Si nécessaire, nous pouvons appeler cette méthode pour vérifier le code de réponse !
- int quit = System.in.read();while('q' != quit){Thread.sleep(2000);} //Ce code sert aux opérations de temporisation. Comme nous utilisons un téléchargement local, la méthode peut avoir fini de s'exécuter alors que nos threads n'ont pas encore démarré, ce qui provoquerait une exception. Ici, laissez l'utilisateur saisir un caractère ; s'il s'agit de 'q', alors quittez
3. Utilisation de DownloadManager pour mettre à jour l'application et installer par écrasement :
Le code suivant peut être utilisé directement. Après l'avoir ajouté au projet, n'oubliez pas d'enregistrer un filtre pour cette diffusion interne :
AndroidManifest.xml
：
import android.app.DownloadManager;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.database.Cursor;
import android.net.Uri;
import android.os.Bundle;
import android.os.Environment;
import android.support.v7.app.AppCompatActivity;
/**
* Created by Jay on 2015/9/9 0009.
*/
public class UpdateAct extends AppCompatActivity {
//这个更新的APK的版本部分，我们是这样命名的:xxx_v1.0.0_xxxxxxxxx.apk
//这里我们用的是git提交版本的前九位作为表示
private static final String FILE_NAME = "ABCDEFGHI";
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
String endpoint = "";
try {
//这部分是获取AndroidManifest.xml里的配置信息的，包名，以及Meta_data里保存的东西
ApplicationInfo info = getPackageManager().getApplicationInfo(
getPackageName(), PackageManager.GET_META_DATA);
//我们在meta_data保存了xxx.xxx这样一个数据，是https开头的一个链接，这里替换成http
endpoint = info.metaData.getString("xxxx.xxxx").replace("https",
"http");
} catch (PackageManager.NameNotFoundException e) {
e.printStackTrace();
}
//下面的都是拼接apk更新下载url的，path是保存的文件夹路径
final String _Path = this.getIntent().getStringExtra("path");
final String _Url = endpoint + _Path;
final DownloadManager _DownloadManager = (DownloadManager) getSystemService(DOWNLOAD_SERVICE);
DownloadManager.Request _Request = new DownloadManager.Request(
Uri.parse(_Url));
_Request.setDestinationInExternalPublicDir(
Environment.DIRECTORY_DOWNLOADS, FILE_NAME + ".apk");
_Request.setTitle(this.getString(R.string.app_name));
//是否显示下载对话框
_Request.setShowRunningNotification(true);
_Request.setMimeType("application/com.trinea.download.file");
//将下载请求放入队列
_DownloadManager.enqueue(_Request);
this.finish();
}
//注册一个广播接收器，当下载完毕后会收到一个android.intent.action.DOWNLOAD_COMPLETE
//的广播,在这里取出队列里下载任务，进行安装
public static class Receiver extends BroadcastReceiver {
public void onReceive(Context context, Intent intent) {
final DownloadManager _DownloadManager = (DownloadManager) context
.getSystemService(Context.DOWNLOAD_SERVICE);
final long _DownloadId = intent.getLongExtra(
DownloadManager.EXTRA_DOWNLOAD_ID, 0);
final DownloadManager.Query _Query = new DownloadManager.Query();
_Query.setFilterById(_DownloadId);
final Cursor _Cursor = _DownloadManager.query(_Query);
if (_Cursor.moveToFirst()) {
final int _Status = _Cursor.getInt(_Cursor
.getColumnIndexOrThrow(DownloadManager.COLUMN_STATUS));
final String _Name = _Cursor.getString(_Cursor
.getColumnIndexOrThrow("local_filename"));
if (_Status == DownloadManager.STATUS_SUCCESSFUL
&& _Name.indexOf(FILE_NAME) != 0) {
Intent _Intent = new Intent(Intent.ACTION_VIEW);
_Intent.setDataAndType(
Uri.parse(_Cursor.getString(_Cursor
.getColumnIndexOrThrow(DownloadManager.COLUMN_LOCAL_URI))),
"application/vnd.android.package-archive");
_Intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(_Intent);
}
}
_Cursor.close();
}
}
}
4. Téléchargement du code de référence :
Téléchargement de fichier normal en mono-thread :DownLoadDemo1.zipTéléchargement de fichier normal en multi-thread :J2SEMulDownLoader.zip
Résumé de cette section :
Très bien, cette section a présenté les téléchargements de fichiers normaux en mono-thread et multi-thread, ainsi que l'utilisation du DownloadManager intégré à Android pour télécharger et mettre à jour des APK, puis installer par écrasement ! Je pense que cela apportera de la commodité au développement concret de chacun. Très bien, c'est tout pour le moment, merci~