高仿糗事百科学习(三)NET

高仿糗事百科，是一个典型的cs模式，所以我们获取数据就要通过net，今天我就开始书写关于网络连接方面的书写。

在安卓中，我们将联网请求往往是放在次线程中，如果放在主线程中，将会导致主线程要处理事件太多导致崩溃，而放在次线程中，那么将出现管理线程的问题，于是我们就可以使用一个线程池辅助类ThreadPoolUtils

/**
* 线程池辅助类，整个应用程序就只有一个线程池去管理线程。
* 可以设置核心线程数、最大线程数、额外线程空状态生存时间，阻塞队列长度来优化线程池
*/
public class ThreadPoolUtils {
private ThreadPoolUtils() {
}

// 定义核心线程数，并行线程数
private static int CORE_POOL_SIZE = 3;

// 线程池最大线程数：除了正在运行的线程额外保存多少个线程
private static int MAX_POOL_SIZE = 200;

// 额外线程空闲状态生存时间
private static int KEEP_ALIVE_TIME = 5000;

// 阻塞队列。当核心线程队列满了放入的
// 初始化一个大小为10的泛型为Runnable的队列
private static BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<Runnable>(10);
// 线程工厂,把传递进来的runnable对象生成一个Thread
private static ThreadFactory threadFactory = new ThreadFactory() {
// 原子型的integer变量生成的integer值不会重复
private final AtomicInteger ineger = new AtomicInteger();
@Override
public Thread newThread(Runnable arg0) {
return new Thread(arg0, "MyThreadPool thread:"
+ ineger.getAndIncrement());
}
};
// 当线程池发生异常的时候回调进入
private static RejectedExecutionHandler handler = new RejectedExecutionHandler() {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
// 进行重启操作
}

};
// 线程池ThreadPoolExecutor java自带的线程池
private static ThreadPoolExecutor threadpool;
// 静态代码块，在类被加载的时候进入
static {
threadpool = new ThreadPoolExecutor(CORE_POOL_SIZE, MAX_POOL_SIZE,
KEEP_ALIVE_TIME, TimeUnit.SECONDS, workQueue, threadFactory,
handler);
}

public static void execute(Runnable runnable) {
threadpool.execute(runnable);
}
}

有了ThreadPoolUtils我们就可以管理线程

下面开始书写第一个关于网络get请求的请求线程:

public class HttpGetThread implements Runnable {
private Handler hand;
private String url;
private MyGet myGet=new MyGet();
public HttpGetThread(Handler hand, String endParamerse) {
this.hand = hand;
// 拼接访问服务器完整的地址
url = Model.HTTPURL + endParamerse;
}

@Override
public void run() {
// 获取我们回调主ui的message
Message msg = hand.obtainMessage();
msg = hand.obtainMessage();
Log.e("liuxiaowei", url);
try {
String result = myGet.doGet(url);
msg.what = 200;
msg.obj = result;
} catch (ClientProtocolException e) {
msg.what = 404;
} catch (IOException e) {
msg.what = 100;
}
hand.sendMessage(msg);
}
}

在这个线程中我们主要做了两件事:

一个是通过String result = myGet.doGet(url);这段代码在NET工具类中通过url获取所需要的数据

第二件事是通过handler的message将下载进程与主ui进程进行交互用来更新ui中的数据.

下面就进入myGet工具类:

public String doGet(String url) throws ClientProtocolException, IOException {
String result = null;// 我们的网络交互返回值
HttpGet myGet = new HttpGet(url);//網絡請求url
HttpClient httpClient = new DefaultHttpClient();
httpClient.getParams().setIntParameter(
//设置连接超时
HttpConnectionParams.CONNECTION_TIMEOUT, 5 * 1000);
//设置socket连接超时
httpClient.getParams().setIntParameter(HttpConnectionParams.SO_TIMEOUT,
30 * 1000);
HttpResponse httpResponse = httpClient.execute(myGet);
if (httpResponse.getStatusLine().getStatusCode() == 200) {
result = EntityUtils.toString(httpResponse.getEntity(), "utf-8");
}
return result;
}

通过调用MyGet工具类获取服务器中的信息，其中谷歌公司对HttpGet进行了屏蔽，我们需要去apache官网去下载httpcilent和httpcore两个jar包进行方法的导入

有了以上的下载线程已经get获取工具，我们还需要在Fragment中进行进程的启动，在HotFragment中我们是在createListModel()方法中进行数据的加载，根据干货、嫩草、文字我们进行url的切换从而访问不同的数据，最后 ThreadPoolUtils.execute(new HttpGetThread(hand, url));通过进程管理工具进行网络进程的使用，其中的hand正是主ui线程的handler.

在handler中我们通过对msg传输的值进行判断是否传输成功，并且通过json解析器进行解析，将消息存进AshamedInfo list中最后通过Adapter的notifychanged通知listView进行数据的更新

上面我们将数据传输写完了，下面我们做图片加载的书写：

/**
* 控制图片的加载类
* 列表在滑动过程时,没有图片会进行下载,并保存到sdcard与 imageCaches 当中去,使用软引用进行封装，如果内存不够时
* 我们的imageCaches 当中的Bitmap对象会被清理掉,图片被释放掉 再次需要加载的时候，先从1级缓存当中获取，如果没有的话，去
* 本地获取，本地也获取不到的话，去网络下载。 一级缓存作用：对于listview当中刚刚滑动过的item显示的图片进行保存
* 二级缓存作用：对于listview当中很久前查看的图片或已经被释放掉图片 进行保存
*/
public class LoadImage {
//下载图片最大并行线程数
private static int MAX = 5;
//图片的一级缓存
private Map<String, SoftReference<Bitmap>> imageCaches = null;
// 查看本地缓存工具类
private FileUtiles fileUtiles;
// android 提供给我们的一个线程池,使用方便
private ExecutorService threadPools = null;

// 初始化上面的相关的变量
public LoadImage(Context ctx) {
imageCaches = new HashMap<String, SoftReference<Bitmap>>();
fileUtiles = new FileUtiles(ctx);
}

// 加载图片时，入口
public Bitmap loadImage(final ImageView imageView, final String imageUrl,
final ImageDownloadCallBack imageDownloadCallBack) {
// imageUrl 由于其唯一型，把他作为我们map当中的key
// 获取图片名称
final String filename = imageUrl.substring(
imageUrl.lastIndexOf("/") + 1, imageUrl.length());
// 图片保存到本地时的地址
String filepath = fileUtiles.getAbsolutePath() + "/" + filename;
// 查找一级缓存，看看是否有这张图片
// 如果map当中有这个key返回一个true
if (imageCaches.containsKey(imageUrl)) {
// 找到对应图片软引用的封装
SoftReference<Bitmap> soft = imageCaches.get(imageUrl);
// 从软引用当中获取图片
Bitmap bit = soft.get();
if (bit != null)
return bit;
// 从我们的一级缓存（程序内部获取图片）
}
//从二级缓存中获取图片
if (fileUtiles.isBitmap(filename)) {
Bitmap bit = BitmapFactory.decodeFile(filepath);
// 在二级缓存读取的时候直接添加到一级缓存当中
imageCaches.put(imageUrl, new SoftReference<Bitmap>(bit));
return bit;
}
// 一级缓存，二级缓存都不存在，直接到网络加载
if (imageUrl != null && !imageUrl.equals("")) {
if (threadPools == null) {
// 实例化我们的线程池
threadPools = Executors.newFixedThreadPool(MAX);
}
// 下载回图片回调Handler
final Handler hand = new Handler() {
@Override
public void handleMessage(Message msg) {
// 如果图片下载成功，并且回调对象不为空时
if (msg.what == 111 && imageDownloadCallBack != null) {
Bitmap bit = (Bitmap) msg.obj;
// 调用回调自定义适配器的接口方法传递数据
imageDownloadCallBack.onImageDownload(imageView, bit);
}
super.handleMessage(msg);
}
};

// 下载图片线程
Thread thread = new Thread() {
Bitmap bit = null;

public void run() {
// 网络下载时的字节流
InputStream inputStream = DownBitmap.getInstance()
.getInputStream(imageUrl);
//图片压缩到原来一般
BitmapFactory.Options op=new BitmapFactory.Options();
op.inSampleSize=6;
if(Model.IMGFLAG)
op.inSampleSize = 1;
Bitmap bit = BitmapFactory.decodeStream(inputStream, null,
op);
if (bit != null) {
// 添加到一级缓存当中
imageCaches.put(imageUrl,
new SoftReference<Bitmap>(bit));
// 添加到二级缓存
fileUtiles.saveBitmap(filename, bit);
// 传递给Handler
Message msg = hand.obtainMessage();
msg.what = 111;
msg.obj = bit;
hand.sendMessage(msg);
}
}
};

threadPools.execute(thread);
}
return null;
}

// 通过回调机制设置图片时的接口(类似于Button的Onclick)
public interface ImageDownloadCallBack {
// ImageView 你所想要设定的imageview Bitmap 想要设定的图片
void onImageDownload(ImageView imageView, Bitmap bitmap);
}

从内存和本地加载都十分的容易理解，但是在下载中却出现了一个回调我们可以着重观察下

// 下载回图片回调Handler
final Handler hand = new Handler() {
@Override
public void handleMessage(Message msg) {
// 如果图片下载成功，并且回调对象不为空时
if (msg.what == 111 && imageDownloadCallBack != null) {
Bitmap bit = (Bitmap) msg.obj;
// 调用回调自定义适配器的接口方法传递数据
imageDownloadCallBack.onImageDownload(imageView, bit);
}
super.handleMessage(msg);
}
};

// 下载图片线程
Thread thread = new Thread() {
Bitmap bit = null;
public void run() {
// 网络下载时的字节流
InputStream inputStream = DownBitmap.getInstance()
.getInputStream(imageUrl);
//图片压缩到原来一般
BitmapFactory.Options op=new BitmapFactory.Options();
op.inSampleSize=6;
if(Model.IMGFLAG)
op.inSampleSize = 1;
Bitmap bit = BitmapFactory.decodeStream(inputStream, null,
op);
if (bit != null) {
// 添加到一级缓存当中
imageCaches.put(imageUrl,
new SoftReference<Bitmap>(bit));
// 添加到二级缓存
fileUtiles.saveBitmap(filename, bit);
// 传递给Handler
Message msg = hand.obtainMessage();
msg.what = 111;
msg.obj = bit;
hand.sendMessage(msg);
}
}
};
threadPools.execute(thread);
}

首先定义的handler，通过这个handler我们可以与下载图片线程进行交互从而获取图片，然后通过回调接口，将图片传入到listViewadapter中进行图片的加载。在下载线程中我们通过DownBitmap获取了图片的输入流再通过图片工厂进行图片的绘制。

下面将DownBitmap进行书写:

/**
* 下载服务器网络图片
* */
public class DownBitmap {
private DownBitmap() {
}
//单例设计模式
private static DownBitmap my=null;
public static synchronized DownBitmap getInstance() {
if (my == null)
my = new DownBitmap();
return my;
}
// 获取网络图片下载时返回的流
public InputStream getInputStream(String Biturl){
//使用Get获取图片资源
HttpGet get=new HttpGet(Biturl);
HttpParams httpParams = new BasicHttpParams();
//连接超时时间
HttpConnectionParams.setConnectionTimeout(httpParams, 5 * 1000);
//设置socket超时时间
HttpConnectionParams.setSoTimeout(httpParams, 30 * 1000);
HttpClient httpClient = new DefaultHttpClient(httpParams);
try {
HttpResponse hr = httpClient.execute(get);
if (hr.getStatusLine().getStatusCode() == 200) {
return hr.getEntity().getContent();// 得到服务器返回的输入流
}
} catch (ClientProtocolException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}// 建立response连接从而方便获取状态吗
return null;
}
}

因为获取图片的数据流只需要这一个类，因此我们可以通过单例模式只存在一个DownBitmap 类通过传入不同的url就可以获取不同的图片资源。