*****
**封裝網絡框架**
[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交互
- 第十九單元 項目案例
- 項目概述
- 第二十單元 項目答辯
- 周考
- 第一周周考
- 第二周周考
- 第三種周考
- 月考
- 接口文檔