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() {
//        httpRequestBase=new HttpPost(url);
//        //传递参数
//        ByteArrayEntity byteArrayEntity=new ByteArrayEntity(requestData);
//        ((HttpPost)httpRequestBase).setEntity(byteArrayEntity);
//
//        try {
//            //执行网络请求
//            this.httpClient.execute(httpRequestBase);
//        } catch (IOException e) {
//            e.printStackTrace();
//        }

        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