*****
**封装网络框架**
[TOC=6]
# 1. 常见设计模式
1. 单例模式
****
基本概念：保证一个类仅有一个实例，并提供一个访问它的全局访问点
**懒汉式**
~~~
public class Singleton {
/* 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 */
private static Singleton instance = null;
/* 私有构造方法，防止被实例化 */
private Singleton() {}
/* 1:懒汉式，静态工程方法，创建实例 */
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
~~~
**饿汉式**
~~~
public class Singleton {
private final static Singleton INSTANCE = new Singleton();
private Singleton(){}
public static Singleton getInstance(){
return INSTANCE;
}
}
~~~
2. 工厂模式
基本概念：为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。
3. 建造(Builder)模式
基本概念：是一种对象构建的设计模式，它可以将复杂对象的建造过程抽象出来（抽象类别），使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象。
4. 观察者模式
基本概念：观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。观察者模式又叫发布-订阅(Publish/Subscribe)模式。
5. 适配器(Adapter)模式
基本概念：适配器模式把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。
# 2. 线程池的使用
****
好处 ： 线程是稀缺资源，如果被无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，合理的使用线程池对线程进行统一分配、调优和监控，有以下好处：
1、降低资源消耗；
2、提高响应速度；
3、提高线程的可管理性。
Java1.5中引入的Executor框架把任务的提交和执行进行解耦，只需要定义好任务，然后提交给线程池，而不用关心该任务是如何执行、被哪个线程执行，以及什么时候执行。
****
newSingleThreadExecutor:产生一个ExecutorService对象，这个对象只有一个线程可用来执行任务，若任务多于一个，任务将按先后顺序执行。
newCachedThreadPool():产生一个ExecutorService对象，这个对象带有一个线程池，线程池的大小会根据需要调整，线程执行完任务后返回线程池，供执行下一次任务使用。
newFixedThreadPool(int poolSize)：产生一个ExecutorService对象，这个对象带有一个大小为poolSize的线程池，若任务数量大于poolSize，任务会被放在一个queue里顺序执行。
newSingleThreadScheduledExecutor：产生一个ScheduledExecutorService对象，这个对象的线程池大小为1，若任务多于一个，任务将按先后顺序执行。
newScheduledThreadPool(int poolSize):产生一个ScheduledExecutorService对象，这个对象的线程池大小为poolSize，若任务数量大于poolSize，任务会在一个queue里等待执行。
# 3. 使用单例模式封装网络框架
~~~
public class HttpUtils {
//线程池
private static ExecutorService executor;
private static Handler mHandler;
static {
executor = Executors.newFixedThreadPool(5);
mHandler = new Handler();
}
/**
* 执行网络请求操作,返回数据会解析成字符串String
*
* @param method 请求方式(需要传入String类型的参数:"GET","POST")
* @param url 请求的url
* @param params 请求的参数
*/
public static String doHttpReqeust(final String method, final String url,
final Map<String, String> params, final StringCallback callback) {
executor.execute(new Runnable() {
@Override
public void run() {
HttpURLConnection connection = null;
OutputStream outputStream = null;
try {
URL u = new URL(url);
connection = (HttpURLConnection) u.openConnection();
// 设置输入可用
connection.setDoInput(true);
// 设置输出可用
connection.setDoOutput(true);
// 设置请求方式
connection.setRequestMethod(method);
// 设置连接超时
connection.setConnectTimeout(5000);
// 设置读取超时
connection.setReadTimeout(5000);
// 设置缓存不可用
connection.setUseCaches(false);
// 开始连接
connection.connect();
// 只有当POST请求时才会执行此代码段
if (params != null) {
// 获取输出流,connection.getOutputStream已经包含了connect方法的调用
outputStream = connection.getOutputStream();
StringBuilder sb = new StringBuilder();
Set<Map.Entry<String, String>> sets = params.entrySet();
// 将Hashmap转换为string
for (Map.Entry<String, String> entry : sets) {
sb.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
}
String param = sb.substring(0, sb.length() - 1);
// 使用输出流将string类型的参数写到服务器
outputStream.write(param.getBytes());
outputStream.flush();
}
int responseCode = connection.getResponseCode();
if (responseCode == 200) {
InputStream inputStream = connection.getInputStream();
String result = inputStream2String(inputStream);
if (result != null && callback != null) {
postSuccessString(callback, result);
}
} else {
if (callback != null) {
postFailed(callback, responseCode, new Exception("请求数据失败：" + responseCode));
}
}
} catch (final Exception e) {
e.printStackTrace();
if (callback != null) {
postFailed(callback, 0, e);
}
} finally {
if (connection != null) {
connection.disconnect();
}
if (outputStream != null) {
try {
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
});
return null;
}
/**
* 执行网络请求操作,返回数据是Bitmap
*
* @param method 请求方式(需要传入String类型的参数:"GET","POST")
* @param url 请求的url
* @param params 请求的参数
*/
public static String doHttpReqeust(final String method, final String url,
final Map<String, String> params, final BitmapCallback callback) {
executor.execute(new Runnable() {
@Override
public void run() {
HttpURLConnection connection = null;
OutputStream outputStream = null;
InputStream inputStream = null;
try {
URL u = new URL(url);
connection = (HttpURLConnection) u.openConnection();
// 设置输入可用
connection.setDoInput(true);
// 设置输出可用
connection.setDoOutput(true);
// 设置请求方式
connection.setRequestMethod(method);
// 设置连接超时
connection.setConnectTimeout(5000);
// 设置读取超时
connection.setReadTimeout(5000);
// 设置缓存不可用
connection.setUseCaches(false);
// 开始连接
connection.connect();
// 只有当POST请求时才会执行此代码段
if (params != null) {
// 获取输出流,connection.getOutputStream已经包含了connect方法的调用
outputStream = connection.getOutputStream();
StringBuilder sb = new StringBuilder();
Set<Map.Entry<String, String>> sets = params.entrySet();
// 将Hashmap转换为string
for (Map.Entry<String, String> entry : sets) {
sb.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
}
String param = sb.substring(0, sb.length() - 1);
// 使用输出流将string类型的参数写到服务器
outputStream.write(param.getBytes());
outputStream.flush();
}
int responseCode = connection.getResponseCode();
if (responseCode == 200) {
inputStream = connection.getInputStream();
Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
if (bitmap != null && callback != null) {
postSuccessBitmap(callback, bitmap);
}
} else {
if (callback != null) {
postFailed(callback, responseCode, new Exception("请求图片失败：" + responseCode));
}
}
} catch (final Exception e) {
e.printStackTrace();
if (callback != null) {
postFailed(callback, 0, e);
}
} finally {
if (connection != null) {
connection.disconnect();
}
if (outputStream != null) {
try {
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
});
return null;
}
/**
* 执行网络请求操作,返回数据是byte[]
*
* @param method 请求方式(需要传入String类型的参数:"GET","POST")
* @param url 请求的url
* @param params 请求的参数
*/
public static String doHttpReqeust(final String method, final String url,
final Map<String, String> params, final ByteArrayCallback callback) {
executor.execute(new Runnable() {
@Override
public void run() {
HttpURLConnection connection = null;
OutputStream outputStream = null;
try {
URL u = new URL(url);
connection = (HttpURLConnection) u.openConnection();
// 设置输入可用
connection.setDoInput(true);
// 设置输出可用
connection.setDoOutput(true);
// 设置请求方式
connection.setRequestMethod(method);
// 设置连接超时
connection.setConnectTimeout(5000);
// 设置读取超时
connection.setReadTimeout(5000);
// 设置缓存不可用
connection.setUseCaches(false);
// 开始连接
connection.connect();
// 只有当POST请求时才会执行此代码段
if (params != null) {
// 获取输出流,connection.getOutputStream已经包含了connect方法的调用
outputStream = connection.getOutputStream();
StringBuilder sb = new StringBuilder();
Set<Map.Entry<String, String>> sets = params.entrySet();
// 将Hashmap转换为string
for (Map.Entry<String, String> entry : sets) {
sb.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
}
String param = sb.substring(0, sb.length() - 1);
// 使用输出流将string类型的参数写到服务器
outputStream.write(param.getBytes());
outputStream.flush();
}
int responseCode = connection.getResponseCode();
if (responseCode == 200) {
InputStream inputStream = connection.getInputStream();
byte[] bytes = inputStream2ByteArray(inputStream);
if (bytes != null && callback != null) {
postSuccessByte(callback, bytes);
}
} else {
if (callback != null) {
postFailed(callback, responseCode, new Exception("请求图片失败：" + responseCode));
}
}
} catch (final Exception e) {
e.printStackTrace();
if (callback != null) {
postFailed(callback, 0, e);
}
} finally {
if (connection != null) {
connection.disconnect();
}
if (outputStream != null) {
try {
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
});
return null;
}
/**
* 执行网络请求操作,返回数据是对象
*
* @param method 请求方式(需要传入String类型的参数:"GET","POST")
* @param url 请求的url
* @param params 请求的参数
*/
public static <T> void doHttpReqeust(final String method, final String url,
final Map<String, String> params, final Class<T> cls, final ObjectCallback callback) {
executor.execute(new Runnable() {
@Override
public void run() {
HttpURLConnection connection = null;
OutputStream outputStream = null;
try {
URL u = new URL(url);
connection = (HttpURLConnection) u.openConnection();
// 设置输入可用
connection.setDoInput(true);
// 设置输出可用
connection.setDoOutput(true);
// 设置请求方式
connection.setRequestMethod(method);
// 设置连接超时
connection.setConnectTimeout(5000);
// 设置读取超时
connection.setReadTimeout(5000);
// 设置缓存不可用
connection.setUseCaches(false);
// 开始连接
connection.connect();
// 只有当POST请求时才会执行此代码段
if (params != null) {
// 获取输出流,connection.getOutputStream已经包含了connect方法的调用
outputStream = connection.getOutputStream();
StringBuilder sb = new StringBuilder();
Set<Map.Entry<String, String>> sets = params.entrySet();
// 将Hashmap转换为string
for (Map.Entry<String, String> entry : sets) {
sb.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
}
String param = sb.substring(0, sb.length() - 1);
// 使用输出流将string类型的参数写到服务器
outputStream.write(param.getBytes());
outputStream.flush();
}
int responseCode = connection.getResponseCode();
if (responseCode == 200) {
InputStream inputStream = connection.getInputStream();
String result = inputStream2String(inputStream);
if (result != null && callback != null) {
postSuccessObject(callback, new Gson().fromJson(result, cls));
}
} else {
if (callback != null) {
postFailed(callback, responseCode, new Exception("请求数据失败：" + responseCode));
}
}
} catch (final Exception e) {
e.printStackTrace();
if (callback != null) {
postFailed(callback, 0, e);
}
} finally {
if (connection != null) {
connection.disconnect();
}
if (outputStream != null) {
try {
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
});
}
private static void postSuccessString(final StringCallback callback, final String result) {
mHandler.post(new Runnable() {
@Override
public void run() {
callback.onSuccess(result);
}
});
}
private static void postSuccessBitmap(final Callback callback, final Bitmap bitmap) {
mHandler.post(new Runnable() {
@Override
public void run() {
BitmapCallback bitmapCallback = (BitmapCallback) callback;
bitmapCallback.onSuccess(bitmap);
}
});
}
private static void postSuccessByte(final Callback callback, final byte[] bytes) {
mHandler.post(new Runnable() {
@Override
public void run() {
ByteArrayCallback byteArrayCallback = (ByteArrayCallback) callback;
byteArrayCallback.onSuccess(bytes);
}
});
}
private static <T> void postSuccessObject(final ObjectCallback callback, final T t) {
mHandler.post(new Runnable() {
@Override
public void run() {
ObjectCallback objectCallback = (ObjectCallback) callback;
objectCallback.onSuccess(t);
}
});
}
private static void postFailed(final Callback callback, final int code, final Exception e) {
mHandler.post(new Runnable() {
@Override
public void run() {
callback.onFaileure(code, e);
}
});
}
/**
* 字节流转换成字符串
*
* @param inputStream
* @return
*/
private static String inputStream2String(InputStream inputStream) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] bytes = new byte[1024];
int len = 0;
try {
while ((len = inputStream.read(bytes)) != -1) {
baos.write(bytes, 0, len);
}
return new String(baos.toByteArray());
} catch (IOException e) {
e.printStackTrace();
} finally {
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (baos != null) {
try {
baos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return null;
}
/**
* 字节流转换成字节数组
*
* @param inputStream 输入流
* @return
*/
public static byte[] inputStream2ByteArray(InputStream inputStream) {
byte[] result = null;
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
// 缓冲区
byte[] bytes = new byte[1024];
int len = -1;
try {
// 使用字节数据输出流来保存数据
while ((len = inputStream.read(bytes)) != -1) {
outputStream.write(bytes, 0, len);
}
result = outputStream.toByteArray();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
inputStream.close();
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return result;
}
/**
* 判断是否联网
*
* @param context
* @return
*/
public static boolean isNetWorkConnected(Context context) {
ConnectivityManager manager = (ConnectivityManager)
context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo networkInfo = manager.getActiveNetworkInfo();
if (networkInfo != null) {
return networkInfo.isAvailable();
}
return false;
}
public interface Callback {
void onFaileure(int code, Exception e);
}
public interface StringCallback extends Callback {
void onSuccess(String result);
}
public interface BitmapCallback extends Callback {
void onSuccess(Bitmap bitmap);
}
public interface ByteArrayCallback extends Callback {
void onSuccess(byte[] bytes);
}
public interface ObjectCallback<T> extends Callback {
void onSuccess(T t);
}
}
~~~
- 咨询项目实战
- 第一单元 HTTP协议
- 1.1 OSI七层模型
- 1.2 HTTP协议（重点）
- 1.3 HTTPS协议（了解）
- 1.4 TCP/IP协议扩展
- 1.5 WebService简介及实战（无接口）
- 1.6 课后练习
- 第二单元 HTTPURLConnection
- 2.1 ANR
- 2.2 网络判断
- 2.3 HTTPURLConnection
- 2.4 课后练习
- 第三单元 AsyncTask
- 3.1 AsyncTask概述
- 3.2 AsyncTask基本使用
- 3.3 课后练习
- 第四单元 图片异步加载
- 4.1 图片异步加载概述
- 4.2 LruCache
- 4.3 DiskLRUCache
- 4.4 图片三级缓存概述
- 4.5 封装图片加载缓存框架
- 第五单元 ListView多条目
- 5.1 ListView多条目概述
- 5.2 ListView多条目的使用
- 第六单元 ListView实现下拉刷新上拉加载
- 6.1 下拉刷新和上拉加载更多
- 6.2 XListView概述
- 6.3 XListView的使用
- 第七单元 封装网络框
- 7.1 封装网络框架概述
- 7.2 网络框架的封装
- 第八单元 项目介绍
- 8.1 公司项目团队架构简介
- 8.2 项目文档及项目流程介绍
- 8.3 项目管理
- 8.4 项目开发
- 第九单元 项目框架搭建
- 9.1 基类封装概述
- 9.2 Application中初始化配置
- 9.3 项目中的工具类
- 9.4 封装网络请求框架
- 9.5 封装图片异步缓存框架
- 第十单元 搭建UI框架1
- 10.1 侧滑菜单概述
- 10.2 主界面框架搭建
- 第十一单元 搭建UI框架2
- 11.1 TabLayout的概述
- 11.2 TabLayout的使用
- 第十二单元 图片上传
- 12.1 图片上传概述
- 12.2 图片上传的实现
- 第十三单元 PullToRefresh
- 13.1 PullToRefresh概述
- 13.2 PullToRefresh的使用
- 13.3 缓存业务实现思路
- 第十四单元 事件分发及滑动冲突
- 14.1 事件分发概述
- 14.2 事件分发流程
- 14.3 事件分发的使用
- 第十五单元 传感器的基本使用
- 15.1 传感器概述
- 15.2 传感器的使用
- 第十六单元 HTML与CSS复习
- 16.1 HTML
- 16.2 CSS
- 第十七单元 js复习
- 17.1 js基础语法
- 17.2 js数组和内置对象
- 17.3 js常用事件
- 17.4 js对象模型
- 17.5 js 正则表达式
- 第十八单元 WebView
- 18.1 WebView 概述
- 18.2 WebView的使用
- 18.3 WebView与js交互
- 第十九单元 项目案例
- 项目概述
- 第二十单元 项目答辩
- 周考
- 第一周周考
- 第二周周考
- 第三种周考
- 月考
- 接口文档