Android自定义的http网络框架
Android自定义的http网络框架
为什么要自定义网络框架：
Android项目中，40%以上会涉及到与后台的http网络。通常的项目都会
用第三方的网络框架。第三方的网络框架存在扩展性低，兼容性等问题。
自定义http网络框架的优点：高性能、高扩展、兼容性好。
下面要实现的网络框架的特点：
1、调用层傻瓜式调用网络请求，用户只需要传入Url,请求参数，所需要请求的类型
2、支持json、图片、音频请求，可根据业务场景需要进行扩展
3、回调的结果发生在主线程
4、高性能，支持高并发，请求队列依次获取，可以设置最大并发数
实现思路：
http网络请求流程：应用层（Activty）持有IrosonseListeren调用Volley层，Volley根据不同的请求类型（json、图片、音频）生产不同的Httptask,Httptask根据请求类型切换到子线程调用不同的IhttpService,IhttpService持有Ihttplistener进行网络请求和获取inputStream,Ihttplistener解析inputSteam后，切换到主线程，让应用层Activity回调IrosonseListeren获取网络请求返回的值。
1、应用了生成者消费者模式，应用层（Activity）生成任务，放入请求队列，
供线程池（threadPool）调用。
2、应用了策略模式，使得不同的请求实现IhttpService ，选择执行
json、图片、音频等网络请求和处理，保证了功能的扩展性。
3、使用了装饰器模式，将请求类型的选择处理逻辑放在了Volley层，使得
应用层可以傻瓜式调用。
实现思路图：
代码实现：
public class MainActivity extends AppCompatActivity {
private String url="http://114.55.30.161/nms3/mmsWebDeviceThree/getDeviceByOrgans.do";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
public void volleynet(View view){
TaskParams tp=new TaskParams(url,
// new String[]{"home_id", ""},
new String[]{"organId", "15"}
);
//json请求
Volley.sendjsonRequest(tp.getEncodeParams(), tp.getUrl(), new IJsonListener() {
@Override
public void onSuccess(String response) {
Log.e("jjjjjj","userResponse---->"+response.toString());
Toast.makeText(getApplicationContext(),response.toString(),Toast.LENGTH_SHORT).show();
}
@Override
public void onError() {
}
});
//图片请求扩展
// Volley.sendImgRequest(tp.getEncodeParams(), tp.getUrl(), new IImagListener() {
//
// @Override
// public void onSuccess(String response) {
//
// }
//
// @Override
// public void onError() {
//
// }
// });
//获取音频扩展
}
}
public class TaskParams {
//http://192.168.1.50:4501/IF/SIM/sim_task.aspx?CELL_WIDTH=800&CELL_HEIGHT=480&BOX_SIGNATURE=070457c801902417668&number=2&task_type=0
private static String CELL_WIDTH="CELL_WIDTH";
private static String CELL_HEIGHT="CELL_HEIGHT";
private static String BOX_SIGNATURE="BOX_SIGNATURE";
private String url;
private static String NUM = "number";
private static String TYPE = "task_type";
private static String USER_ID = "user_id";
private Map<String, String> params;
private TaskParams() {
}
public TaskParams(String url, int cell_width, int cell_heith, String box_signature, int num, int type) throws ParamsInvaliedException {
params = new HashMap<String, String>();
if (url == null) {
throw new ParamsInvaliedException("task count is invalied");
} else {
this.url = url;
}
params.put(CELL_WIDTH, String.valueOf(cell_width));
params.put(CELL_HEIGHT, String.valueOf(cell_heith));
params.put(BOX_SIGNATURE, box_signature);
params.put(NUM, String.valueOf(num));
//params.put(TYPE, String.valueOf(type));
// params.put(USER_ID, Common.USER_Id);
}
public TaskParams(String url, String[]... para){
params = new HashMap<String, String>();
this.url = url;
if(para != null){
for(int i = 0; i < para.length; i++){
String[] p = para[i];
if(p.length != 2){
continue;
}
this.params.put(p[0], p[1]);
}
}
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getEncodeParams() {
try {
StringBuilder encodedString = new StringBuilder();
boolean first = true;
for (String key : params.keySet()) {
String value = params.get(key);
if (value.equals(""))
continue;
if (first)
first = false;
else
encodedString.append("&");
encodedString.append(URLEncoder.encode(key, "UTF-8")).append("=")
.append(URLEncoder.encode(value, "UTF-8"));
}
return encodedString.toString();
} catch (UnsupportedEncodingException e) {
return null;
}
}
public static class ParamsInvaliedException extends Exception {
private static final long serialVersionUID = 1L;
public ParamsInvaliedException(String s) {
super(s);
}
}
}
public class Volley {
//供调用层调用
public static void sendjsonRequest(String params,
String url,IJsonListener httpCallable){
//回调
IHttpListener httpListener=
new JSONDealListener(httpCallable);
//实例化http网络请求线程线程
HttpTask httpTask=new HttpTask(params,url,httpListener,new JSONHttpSercice());
ThreadPoolManager.getInstance().execute(new FutureTask<Object>(httpTask,null));
}
//图片访问 供扩展用
// public static void sendImgRequest(String params,
// String url,IImagListener httpCallable){
// //回调
// IHttpListener httpListener=
// new ImageDealListener(httpCallable);
//
// //实例化http网络请求线程线程
// HttpTask httpTask=new HttpTask(params,url,httpListener);
//
// ThreadPoolManager.getInstance().execute(new FutureTask<Object>(httpTask,null));
//
//
// }
}
public class HttpTask implements Runnable{
private IHttpService httpService;
public HttpTask(String params,
String url,IHttpListener iHttpListener,IHttpService httpService){
this.httpService=httpService;
httpService.setUrl(url);
httpService.setHttpCallBack(iHttpListener);
params = params.replace("%40", "@");
try {
this.httpService.setRestquestDate(params.getBytes());
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void run() {
//执行网络请求
this.httpService.excute();
}
}
//处理请求后的回调，是否请求
// 成功、失败后的操作
public interface IHttpListener {
void onSuccess(InputStream inputStream);
void onError();
}
//处理网络请求的接口
public interface IHttpService {
//请求url
void setUrl(String url);
//执行请求，专门处理inputStream
void excute();
//设置回调接口
void setHttpCallBack(IHttpListener iHttpListener);
//设置请求参数
void setRestquestDate(byte[] restquestDate);
}
//提供调用层使用
public interface IJsonListener{
void onSuccess(String response);
void onError();
}
//处理JSON相应请求
public class JSONDealListener implements IHttpListener {
//请求返回解析后的回调
private IJsonListener jsonListener;
//切换到主线程
Handler handler=new Handler(Looper.getMainLooper());
public JSONDealListener(IJsonListener jsonListener) {
this.jsonListener = jsonListener;
}
@Override
public void onSuccess(InputStream inputStream) {
//解析网络请求的响应流
final String content=getContent(inputStream);
//切换到主线程
handler.post(new Runnable() {
@Override
public void run() {
if(jsonListener!=null){
//主线程调用
jsonListener.onSuccess(content);
}
}
});
}
//解析响应流
private String getContent(InputStream inputStream) {
String content=null;
try {
BufferedReader reader=
new BufferedReader(new InputStreamReader(inputStream));
StringBuilder sb=new StringBuilder();
String line=null;
while((line=reader.readLine())!=null){
sb.append(line+"\n");
}
return sb.toString();
}catch (Exception e){
System.out.println("Error="+e.toString());
}finally {
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return content;
}
@Override
public void onError() {
}
}
public class JSONHttpSercice implements IHttpService {
IHttpListener httpListener;
String url;
private byte[] requestData;
@Override
public void setUrl(String url) {
this.url = url;
}
@Override
public void setRestquestDate(byte[] restquestDate) {
this.requestData=restquestDate;
}
@Override
public void excute() {
HttpURLConnection conn = null;
OutputStream out = null;
InputStream in = null;
try {
conn = (HttpURLConnection) new URL(url).openConnection();
conn.setRequestMethod("POST");
conn.setConnectTimeout(3000);
conn.setReadTimeout(3000);
conn.setDoOutput(true);
out = conn.getOutputStream();
out.write(requestData);
out.flush();
out.close();
int code = conn.getResponseCode();
if (code != HttpURLConnection.HTTP_OK) {
// return null;
}
in = conn.getInputStream();
httpListener.onSuccess(in);
// String resstr = HttpUtils.changeInputStream2(in);
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void setHttpCallBack(IHttpListener iHttpListener) {
this.httpListener=iHttpListener;
}
}
//线程池管理
public class ThreadPoolManager {
private static ThreadPoolManager
instance=new ThreadPoolManager();
public static ThreadPoolManager getInstance() {
return instance;
}
private ThreadPoolExecutor threadPoolExecutor;
private LinkedTransferQueue<Future<?>> service=new LinkedTransferQueue<>();
private ThreadPoolManager(){
threadPoolExecutor=new ThreadPoolExecutor(4,10,10, TimeUnit.SECONDS,
new ArrayBlockingQueue<Runnable>(4),handler);
threadPoolExecutor.execute(runnable);
}
private Runnable runnable =new Runnable() {
@Override
public void run() {
FutureTask futureTask=null;
while (true){
try {
futureTask= (FutureTask) service.take();
} catch (InterruptedException e) {
e.printStackTrace();
}
if(futureTask!=null){
threadPoolExecutor.execute(futureTask);
}
}
}
};
public <T> void execute(FutureTask<T> futureTask){
if(futureTask!=null){
try {
service.put(futureTask);
}catch (Exception e){
e.printStackTrace();
}
}
}
private RejectedExecutionHandler handler=new RejectedExecutionHandler() {
@Override
public void rejectedExecution(Runnable runnable, ThreadPoolExecutor threadPoolExecutor) {
service.put(new FutureTask<Object>(runnable,null));
}
};
}
Github地址：https://git.oschina.net/qpww/myVolley.git
