Android 自定义 ImageLoader

最新推荐文章于 2024-11-01 13:05:04 发布
原创 最新推荐文章于 2024-11-01 13:05:04 发布 · 1.2k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细阐述了一种高效的网络图片加载策略，包括缓存管理、本地存储优化以及并发加载机制，旨在提升用户体验并减少服务器负载。通过实现自定义的图片加载器，实现在不同设备和网络环境下快速、高效地加载和显示图片资源。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Hashtable;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.LinkedBlockingQueue;

import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;


import android.app.ProgressDialog;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.MessageQueue;
import android.support.v4.util.LruCache;
import android.test.UiThreadTest;
import android.text.TextUtils;
import android.widget.ImageView;

/**
 * 网络图片加载
 * 
 * @author 
 *
 */
public class ImageNetLoader {

	private static final int TIMEOUT = 30 * 1000;
	// protected final HashMap<String, SoftReference<Bitmap>> bitmapMap;
	Context mContext;
	BitmapFactory.Options opts = null;
	@SuppressWarnings("rawtypes")
	LruCache mMemoryCache = null;
	private static ImageNetLoader imageNetLoader;
	
	private BlockingQueue<FutureTask<Bitmap>> blockingqeque = new LinkedBlockingQueue<FutureTask<Bitmap>>();
	private Thread loadThread = new Thread(){
		public void run() {
			while(true){
				FutureTask<Bitmap> task;
				try {
					task = blockingqeque.take();
					if(task.isCancelled() ||task.isDone() )
						continue;
					task.run();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
				
					
			}
		};
	};
	
	public interface LocalFileNameBuilder {
		public String getName(String url, String localDir);
	}

	private ImageNetLoader(Context mContext) {
		this.mContext = mContext;
		int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
		// 使用最大可用内存值的1/8作为缓存的大小。
		int cacheSize = maxMemory / 8;
		mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {
			@Override
			protected int sizeOf(String key, Bitmap bitmap) {
				// 重写此方法来衡量每张图片的大小，默认返回图片数量。
				return bitmap.getByteCount() / 1024;
			}
		};
		
	}

	public static ImageNetLoader instance(Context context) {
		if (imageNetLoader == null) {
			synchronized (ImageNetLoader.class) {
				if (imageNetLoader == null) {
					imageNetLoader = new ImageNetLoader(context);
					imageNetLoader.loadThread.setPriority(Thread.MIN_PRIORITY);
					imageNetLoader.loadThread.start();
				}
			}
		}

		return imageNetLoader;
	}
	@SuppressWarnings("unchecked")
	public void addBitmapToMemoryCache(String key, Bitmap bitmap) {
		if (getBitmapFromMemCache(key) == null) {
			mMemoryCache.put(key, bitmap);
		}
	}

	@SuppressWarnings("unchecked")
	public Bitmap getBitmapFromMemCache(String key) {
		return (Bitmap) mMemoryCache.get(key);
	}

	@SuppressWarnings("unchecked")
	public void removeFromCache(String key) {
		if (mMemoryCache.get(key) != null) {
			mMemoryCache.remove(key);
		}
	}

	/**
	 * 获取URL 并且保存到本地
	 * 
	 * @param urlString
	 * @param localDir
	 * @return
	 * @throws ClientProtocolException
	 * @throws IOException
	 */
	public InputStream getInputStream(String urlString, String localDir,
			LocalFileNameBuilder builder) throws ClientProtocolException,
			IOException {

		HttpParams params = new BasicHttpParams();
		// add the timeout
		HttpConnectionParams.setConnectionTimeout(params, TIMEOUT);
		HttpConnectionParams.setSoTimeout(params, TIMEOUT);

		DefaultHttpClient httpClient = new DefaultHttpClient(params);
		HttpGet request = new HttpGet(urlString);
		HttpResponse response = httpClient.execute(request);

		if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
			request.abort();
			return null;
		}
		InputStream in = response.getEntity().getContent();

		String localPath = getLocalPath(urlString, localDir, builder);
		// 保存到本地

		File f = new File(localPath);
		if (f.createNewFile()) {
			FileOutputStream fo = new FileOutputStream(f);

			BufferedInputStream bi = new BufferedInputStream(in);
			byte[] buffer = new byte[1024 * 10];
			int len = 0;
			while ((len = bi.read(buffer)) > 0) {
				fo.write(buffer, 0, len);
				fo.flush();
			}

			bi.close();
			fo.close();
			return new FileInputStream(f);
		}
		return in;

	}

	/**
	 * 初始化 Bitmap参数
	 */
	private void initOptions() {
		if (opts == null) {
			opts = new BitmapFactory.Options();
			opts.inPreferredConfig = Bitmap.Config.RGB_565;
			opts.inSampleSize = 1;
		}
	}

	/**
	 * 
	 * @param urlString
	 *            网路路径
	 * @param localDir
	 *            本地存储路径 如果不为null就保存到相应目录 否则保存到 temp目录
	 * 
	 * @return
	 */
	public Bitmap getBitmapByUrl(String urlString, String localDir,
			LocalFileNameBuilder builder) {
		if (TextUtils.isEmpty(urlString)) {
			return null;
		}

		Log.v("ImageLoader", "ImageLoader load for:"+ urlString );
		try {
			return getBitmapFromUrl(urlString, localDir, builder);
		} catch (OutOfMemoryError e) {
			e.printStackTrace();
		} catch (Exception e) {
			Log.v(this.getClass().getSimpleName(),
					"Network Exception fetchDrawable failed 1st time" + e);
			try {
				return getBitmapFromUrl(urlString, localDir, builder);
			} catch (OutOfMemoryError es) {
				es.printStackTrace();
			} catch (Exception ex) {
				ex.printStackTrace();
				Log.v(this.getClass().getSimpleName(),
						"Network Exception fetchDrawable failed 2nd time" + ex);
			}
		}
		return null;
	}

	/**
	 * 保存网络文件到本地
	 * 
	 * @param urlString
	 * @param localDir
	 * @param builder
	 */
	public void loadUrlTolocal(String urlString, String localDir,
			LocalFileNameBuilder builder) {
		String localfile = getLocalPath(urlString, localDir, builder);
		File f = new File(localfile);
		if (f.exists() && f.canRead()) {
			return;
		}

		try {
			InputStream in = getInputStream(urlString, localDir, builder);
			in.close();
		} catch (ClientProtocolException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	/**
	 * 获取本地保存路径
	 * 
	 * @param urlString
	 * @param localDir
	 * @return
	 */
	private String getLocalPath(String urlString, String localDir,
			LocalFileNameBuilder builder) {
		String localPath;
		// 获取本地路径
		if (localDir != null) {
			

			if (builder == null) {
				String fileName = MD5.md5Lower(urlString.substring(
						urlString.lastIndexOf('/'), urlString.length())
						+ "."
						+ urlString.substring(urlString.lastIndexOf('.'),
								urlString.length()));
				localPath = localDir + "/" + fileName;
			} else {
				localPath = localDir + "/"
						+ builder.getName(urlString, localDir);
			}

		} else {
			localPath = Config.EXTERNAL_PATH + "/temp/" + MD5.md5Lower(urlString);
		}
		return localPath;

	}

	/**
	 * 从IN中获取bitmap
	 * 
	 * @param in
	 * @return
	 */
	private Bitmap getBitmapFromInputStream(InputStream in) {
		Bitmap bitmap = null;
		try {
			initOptions();
			bitmap = BitmapFactory.decodeStream(in, null, opts);
			try {
				in.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} catch (OutOfMemoryError e) {
			return null;
		}
		return bitmap;
	}

	/**
	 * get Bitmap from the input stream
	 * 
	 * @throws IOException
	 * @throws ClientProtocolException
	 */
	private Bitmap getBitmapFromUrl(String urlString, String localDir,
			LocalFileNameBuilder builder) throws ClientProtocolException,
			IOException {
		return getBitmapFromInputStream(getInputStream(urlString, localDir,
				builder));
	}

	/**
	 * 获取网络图片 不永久保存图片
	 * 
	 * @param urlString
	 * @param defaultres
	 * @param progressDialog
	 * @param imageView1
	 */
	public void loadBitmapOnThread(final String urlString,
			final int defaultres, final ProgressDialog progressDialog,
			final ImageView imageView1) {
		loadBitmapOnThread(urlString, defaultres, progressDialog, imageView1,
				null);

	}

	/**
	 * 加载图片 文件名使用默认规则 默认加入到缓存中
	 * 
	 * @param urlString
	 * @param defaultres
	 * @param progressDialog
	 * @param imageView1
	 * @param localDir
	 */
	public void loadBitmapOnThread(final String urlString,
			final int defaultres, final ProgressDialog progressDialog,
			final ImageView imageView1, final String localDir) {

		loadBitmapOnThread(urlString, defaultres, progressDialog, imageView1,
				localDir, null);
	}

	/**
	 * 加载图片 默认加入到缓存中
	 * 
	 * @param urlString
	 * @param defaultres
	 * @param progressDialog
	 * @param imageView1
	 * @param localDir
	 * @param builder
	 *            本地文件名生成规则
	 */

	public void loadBitmapOnThread(final String urlString,
			final int defaultres, final ProgressDialog progressDialog,
			final ImageView imageView1, final String localDir,
			final LocalFileNameBuilder builder) {

		loadBitmapOnThread(urlString, defaultres, progressDialog, imageView1,
				localDir, builder, true);
	}

	/**
	 * 
	 * @author popo
	 */

	class IRunnable implements Callable<Bitmap> {

		String url;
		String localDir;
		LocalFileNameBuilder localFileNameBuilder;
		boolean saveToCache;
		ImageView imageView;
		ProgressDialog progressDialog;
		int defaultres;

		public IRunnable(String url, String localDir,
				LocalFileNameBuilder localFileNameBuilder, boolean saveToCache,
				ImageView imageView, ProgressDialog progressDialog,
				int defaultres) {
			this.url = url;
			this.localDir = localDir;
			this.localFileNameBuilder = localFileNameBuilder;
			this.saveToCache = saveToCache;
			this.imageView = imageView;
			this.progressDialog = progressDialog;
			this.defaultres = defaultres;
		}

		@Override
		public Bitmap call() throws Exception {
			Bitmap drawable = null;
			drawable = getBitmapByUrl(url, localDir, localFileNameBuilder);

			if (drawable != null) {
				Object[] obj = new Object[] { drawable, imageView, url,
						defaultres, saveToCache, progressDialog };
				Message message = handler.obtainMessage(1, obj);
				handler.sendMessage(message);
			}
			if (progressDialog != null) {
				progressDialog.dismiss();
			}
			taskMaps.remove(url);
			return drawable;

		}

	}

	class Node {
		public IRunnable runnable;
		public FutureTask<Bitmap> task;
	}

	/**
	 * ConcurrentHashMap or HashTable
	 */
	Hashtable<String, Node> taskMaps = new Hashtable<String, Node>();

	/**
	 * 加载图片
	 * 
	 * @param urlString
	 * @param defaultres
	 * @param progressDialog
	 * @param imageView1
	 * @param localDir
	 *            本地缓存目录
	 * @param builder
	 *            本地文件名生成规则
	 * @param saveToCache
	 *            是否 加入到缓存
	 */
	public void loadBitmapOnThread(final String urlString,
			final int defaultres, final ProgressDialog progressDialog,
			final ImageView imageView1, final String localDir,
			final LocalFileNameBuilder builder, final boolean saveToCache) {
		if(imageView1 == null)
			return ;
		Log.v("ImageLoader"," image load for:"+urlString);
		
		// 获取以前的Tag
		String tag = (String) imageView1.getTag(R.id.img_tag);

		imageView1.setTag(R.id.img_tag, urlString);
		if (urlString == null || urlString.trim().equals("")) {
			if (imageView1.getTag(R.id.img_tag).equals(urlString))
				imageView1.setImageResource(defaultres);

			if (progressDialog != null) {
				progressDialog.dismiss();
			}
			
			//取消图片之前的任务
			cancelTask(tag);

			return;
		}

		// 从缓存读取
		try {
			Bitmap bm = getBitmapFromMemCache(urlString);
			if (bm != null && !bm.isRecycled()
					&& imageView1.getTag(R.id.img_tag).equals(urlString)) {
				Log.v("from cache", "url:" + urlString + ",imageView:"
						+ imageView1.toString());
				imageView1.setImageBitmap(bm);
				if (progressDialog != null) {
					progressDialog.dismiss();
				}
				//取消图片之前的任务
				cancelTask(tag);
				return;
			} else {
				removeFromCache(urlString);
				if (defaultres > 0)
					imageView1.setImageResource(defaultres);
				
			}
		} catch (OutOfMemoryError e) {
			e.printStackTrace();
		}
		final String localPath = getLocalPath(urlString, localDir, builder);
		if (localPath != null) {
			imageView1.setTag(R.id.localimg_tag, localPath);
		}
		File f = new File(localPath);
		if (f.exists() && f.canRead()) {
			try {
				FileInputStream fi = new FileInputStream(f);
				Bitmap b = getBitmapFromInputStream(fi);
				if (b != null
						&& imageView1.getTag(R.id.localimg_tag).equals(
								localPath)) {
					Log.v("from file", "url:" + urlString + ",localPath"
							+ localPath);
					if (saveToCache) {
						if (!b.isRecycled())
							addBitmapToMemoryCache(urlString, b);
					}
					imageView1.setImageBitmap(b);
					//取消图片之前的任务
					cancelTask(tag);
					return;
				}
			} catch (FileNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (OutOfMemoryError e) {
				e.printStackTrace();
			}

		}

		if (progressDialog != null)
			progressDialog.show();

		//那连个地址一样怎么办捏
		//同一个变相同地址 就不做任何处理了等着吧
		
		if(tag != null && tag.equals(urlString)){
			
		}else{
			//不一样取消之前的任务
			cancelTask(tag);
			final Node node = taskMaps.get(urlString);
			//之前已经有图片在下载
			if(node != null ){
				
				
				FutureTask<Bitmap> task = new FutureTask<Bitmap>(new Callable<Bitmap>() {

					@Override
					public Bitmap call() throws Exception {
						try {
							Bitmap drawable = node.task.get();
							if (drawable != null) {
								Object[] obj = new Object[] { drawable, imageView1, urlString,
										defaultres, saveToCache, progressDialog };
								Message message = handler.obtainMessage(1, obj);
								handler.sendMessage(message);
							}

						} catch (InterruptedException e) {
							e.printStackTrace();
						} catch (ExecutionException e) {
							e.printStackTrace();
						}
						return null;
					}
				});
				
				blockingqeque.offer(task);
				
			}else{
				IRunnable runnable = new IRunnable(urlString, localDir, builder, saveToCache, imageView1, progressDialog, defaultres);
				FutureTask<Bitmap> task =  new FutureTask<Bitmap>(runnable);
				blockingqeque.offer(task);
				Node n = new Node();
				n.runnable = runnable;
				n.task = task;
				taskMaps.put(urlString, n);
			}
		}
	}
	
	/**
	 * 取消图片任务
	 * @param tag
	 */
	private void cancelTask(String tag) {
		// 现在图片已经不需要新下载的图片了 那么取消掉吧
		if(tag == null)
			return;
		Node node = taskMaps.get(tag);
		if (node != null) {
			boolean canceled = node.task.cancel(false);
			if (canceled && node.task.isCancelled()) {
				taskMaps.remove(tag);
			}

		}
	}

	final Handler handler = new Handler(Looper.getMainLooper()) {
		@Override
		public void handleMessage(Message message) {

			ImageView imageView = (ImageView) ((Object[]) message.obj)[1];
			String imgpath = (String) ((Object[]) message.obj)[2];
			int defaultres = (Integer) ((Object[]) message.obj)[3];
			boolean saveToCache = (Boolean) ((Object[]) message.obj)[4];
			if (((Object[]) message.obj)[5] != null) {
				ProgressDialog pd = (ProgressDialog) ((Object[]) message.obj)[5];
				if (pd != null) {
					pd.dismiss();
				}
			}

			Log.v("NETIMAGE", "url:" + imgpath + ",imageView:" + imageView);
			switch (message.what) {
			case 1:
				try {
					Bitmap bm = null;
					if (null == message.obj) {
						if (defaultres > 0)
							imageView.setImageResource(defaultres);
					} else {
						bm = (Bitmap) ((Object[]) message.obj)[0];

						if (!bm.isRecycled()) {
							if (imageView != null
									&& imageView.getTag(R.id.img_tag) != null
									&& imageView.getTag(R.id.img_tag).equals(
											imgpath))

								imageView.setImageBitmap(bm);
							removeFromCache(imgpath);
							addBitmapToMemoryCache(imgpath, bm);
						} else {
							if (imageView != null && defaultres > 0)
								imageView.setImageResource(defaultres);
						}
					}
				} catch (OutOfMemoryError e) {
					e.printStackTrace();
				} catch (Exception e) {
					e.printStackTrace();
				}

				break;
			}
		}

	};

}


自定义ImageLoader
itbird的专栏
04-20 2209
近期看了一些设计模式相关的书籍，突然有了一个想法，借助所学，去实现一个图片加载框架。 #1.UML设计 从图中可以看到面向对象的几大设计原则 1）依赖倒置原则：高层模块（ImageLoader）只依赖于接口or抽象类（ImageCache），不依赖具体的实现类（DiskImageCache、MemoryImageCache等具体的实现类） 2）单一职责原则：加载业务、不同的缓存业务相分离，实现了解耦、分离 3）开闭原则：修改不同的缓存策略、用户不同的自定义缓存策略，都可以通过继承ImageCache.
Android-XImageLoader这是一个Android的自定义图片加载库。
08-13
XImageLoader 这是一个Android的自定义图片加载库。
Android——自定义简化版ImageLoader
AkaiC的博客
10-20 940
在上一篇我们已经先后介绍了 Bitmap 的高效加载方式、LruCache 以及 DiskLruCache，那么我们就动手来写一个简化版的 ImageLoader 吧！！！一般来说，一个优秀的 ImageLoader 应该具备如下功能： 图片的同步加载 图片的异步加载 图片的压缩 内存缓存 磁盘缓存 网络拉取 声明一下，这里实现的 ImageLoader 并不是为了写一个框架，而是纯粹的加深下三级缓
自定义ImageLoader类
听海的博客
03-19 574
初级时在ListView或是GridView中需要处理大量图片时，创建的一个单独类。ImageLoader类，来实现ListView或是GridView双缓存(一级,二级)异步(AsyncTask相当于新线程) 异步：AsyncTask来实现。 双缓存： 一级缓存LinkedHashMap(LRU（Least RecentlyUsed）策略,即当内存使用不足时，把最近最少使用的...
自定义ImageLoader实现GridView加载图片
安东尼的博客
03-10 935
本项目github地址： SimpleImageLoader github地址 首先思考一下，一个ImageLoader应当实现一下的功能： 1 内存缓存，磁盘缓存，网络加载的结合。 2 利用采样率对图片进行一定的压缩，高效加载bitmap。 3 图片的加载策略（同步加载和异步加载）。 4 缓存策略（LRU） 其次在GridView中加载图片，应当解决下面的这些问题： 5 图片错位
Android自定义相册
04-05
作者pengjianbo，源码GalleryFinal，Android自定义相册，实现了拍照、图片选择（单选/多选）、 裁剪（单/多裁剪）、旋转、ImageLoader无绑定任由开发者选 择、功能可配置、主题样式可配置。GalleryFinal为你定制相册...
Android-ImageLoader具有某些新特性的图片加载框架
08-13
ImageLoader是一款针对Android平台设计的高效、易用的图片加载库，它旨在解决图片加载过程中可能出现的内存管理问题、图片重用以及用户体验优化等问题。在"Android-ImageLoader具有某些新特性的图片加载框架"这个...
Android Universal ImageLoader 缓存图片
09-02
4. **自定义配置**：开发者可以根据需求调整ImageLoader的行为，比如设置线程池大小、内存缓存策略、磁盘缓存策略等。 5. **图片裁剪与缩放**：根据ImageView的大小自动调整Bitmap的尺寸，减少内存消耗。 6. **...
自定义简单版ImageLoader实现三级缓存
10-20
自定义简单版ImageLoader 实现三级缓存，主要用到了 LruCache 以及 DiskLruCache 和线程池
Android自定义简单的图片加载器（ImageLoader）
菜鸡互啄
11-26 483
Android自定义简单的图片加载器（ImageLoader）这是我第一篇博客可能有些啰嗦，不过也希望大家能耐着性子看下去。关于为什么要写博客相信每个人都有不同的看法，在我看来写博客有一下几点好处：再思考，再总结和分享。开源不也是Java语言最迷人之处么？在这里分享一个自己的故事哈。在上高中那会，我的数学成绩很好，我同桌经常会问我一些数学上问题，有些题我能懂但是在跟他讲的时候他就怎么也听不懂，因为每
imageLoader自定义配置
ztz的博客
09-13 305
package com.example.viewpager_lunbo; import android.content.Context; import com.nostra13.universalimageloader.cache.disc.impl.UnlimitedDiskCache; import com.nostra13.universalimageloader.cache.disc.
ImageLoader: Android图像加载优化工具
weixin_29476595的博客
08-30 1637
本文还有配套的精品资源，点击获取 简介：在Android应用开发中，ImageLoader是一个优化图像加载的工具，旨在解决内存溢出和提升用户体验。它通过异步加载、内存和磁盘缓存等机制，使得处理大量图片或网络图片时更加高效。文章详细介绍了ImageLoader的功能特性、实现原理以及如何在Android应用中集成和使用，包含示例代码，以帮助开发者深入理解并应用于实际开发。 ...
打造高效Android ImageLoader自封装项目
最新发布
weixin_34471637的博客
11-01 753
本文还有配套的精品资源，点击获取 简介：在Android开发中，图片加载是常见需求，尤其是处理大量图片时。本文介绍的"自己封装的ImageLoader"项目，提供了一个自定义的图片加载解决方案，注重性能优化和内存管理。我们将详细探讨此项目的关键技术组件，如BitmapUtils、MusicAdapter、XmlParser、HttpUtils和UrlFactory，它们共同...
android自定义图片加载,Android自定义简单的图片加载器（ImageLoader）
weixin_36212212的博客
05-25 240
废话不多述，首先来说明下 为什么要用图片加载器 呢，就是为了避免图片重复从网络加载。也就是在第一次从网络加载之后就把图片缓存在本地，下次用的时候直接从本地查找，有的话就直接用，没有再从网络加载。加载方式的话又有2种，一种是加载在手机内存中，另一种是缓存到SD卡中。一般Android应用的内存很有限，所以用内存缓存的话当应用重启时缓存在内存中的就会丢失，但是缓存在内存中比缓存在SD卡中读取的时候更快...
Android-Universal-Image-Loader 图片异步加载类库的使用（超详细配置）
xumingrencai
04-09 573
这个图片异步加载并缓存的类已经被很多开发者所使用，是最常用的几个开源库之一，主流的应用，随便反编译几个火的项目，都可以见到它的身影。 可是有的人并不知道如何去使用这库如何进行配置，网上查到的信息对于刚接触的人来说可能太少了，下面我就把我使用过程中所知道的写了下来，希望可以帮助自己和别人更深入了解这个库的使用和配置。 GITHUB上的下载路径为：https://github....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值