android网络编程 c pdf 深入理解android网络编程 pdf

 深入理解Android网络编程（一）

一、首先介绍一下我们可能一直以来疑惑的问题，就是TCP,IP,HTTP,SOCKET区别和联系？

网络由下往上分为:  

             物理层--                      

             数据链路层--

             网络层--              IP协议

             传输层--              TCP协议

             会话层--

             表现成--

             应用层--             HTTP协议

         2、socket则是对TCP/IP协议的封装和应用（也可说是TCP/IP层上的一个抽象接口体统程序员使用TCP/IP协议）。socket一旦建立连接双方都可以自由通信

             TPC/IP协议是传输层协议，主要解决数据 如何在网络中传输。

             而HTTP是应用层协议，主要解决如何包装数据。每次只能一问一答得方式去交流，不能联系

             

关于TCP/IP和HTTP协议的关系，网络有一段比较容易理解的介绍：

我们在传输数据时，可以只使用（传输层）TCP/IP协议，但是那样的话，如 果没有应用层，便无法识别数据内容，如果想要使传输的数据有意义，则必须使用到应用层协议，应用层协议有很多，比如HTTP、FTP、TELNET等，也 可以自己定义应用层协议。WEB使用HTTP协议作应用层协议，以封装HTTP文本信息，然后使用TCP/IP做传输层协议将它发到网络上。”

Socket本身并不是协议，而是一个调用接口（API），通过Socket，我们才能使用TCP/IP协议。 实际上，Socket跟TCP/IP协议没有必然的联系。Socket编程接口在设计的时候，就希望也能适应其他的网络协议。所以说，Socket的出现 只是使得程序员更方便地使用TCP/IP协议栈而已，是对TCP/IP协议的抽象，从而形成了我们知道的一些最基本的函数接口，比如create、 listen、connect、accept、send、read和write等等。网络有一段关于socket和TCP/IP协议关系的说法

        3、什么是TCP连接的三次握手

第一次握手：客户端发送syn包(syn=j)到服务器，并进入SYN_SEND状态，等待服务器确认； 
第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态； 
第三次握手：客户端收到服务器的SYN＋ACK包，向服务器发送确认包ACK(ack=k+1)，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。 
  握手过程中传送的包里不包含数据，三次握手完毕后，客户端与服务器才正式开始传送数据。理想状态下，TCP连接一旦建立，在通信双方中的任何一方主动关闭 连接之前，TCP 连接都将被一直保持下去。断开连接时服务器和客户端均可以主动发起断开TCP连接的请求，断开过程需要经过“四次握手”（过程就不细写了，就是服务器和客 户端交互，最终确定断开）

       4、利用Socket建立网络连接的步骤

建立Socket连接至少需要一对套接字，其中一个运行于客户端，称为ClientSocket ，另一个运行于服务器端，称为ServerSocket 。

套接字之间的连接过程分为三个步骤：服务器监听，客户端请求，连接确认。

1。服务器监听：服务器端套接字并不定位具体的客户端套接字，而是处于等待连接的状态，实时监控网络状态，等待客户端的连接请求。

2。客户端请求：指客户端的套接字提出连接请求，要连接的目标是服务器端的套接字。为此，客户端的套接字必须首先描述它要连接的服务器的套接字，指出服务器端套接字的地址和端口号，然后就向服务器端套接字提出连接请求。

3。连接确认：当服 务器端套接字监听到或者说接收到客户端套接字的连接请求时，就响应客户端套接字的请求，建立一个新的线程，把服务器端套接字的描述发给客户端，一旦客户端 确认了此描述，双方就正式建立连接。而服务器端套接字继续处于监听状态，继续接收其他客户端套接字的连接请求。

       5、HTTP链接的特点

HTTP协议即超文本传送协议(Hypertext Transfer Protocol )，是Web联网的基础，也是手机联网常用的协议之一，HTTP协议是建立在TCP协议之上的一种应用。

HTTP连接最显著的特点是客户端发送的每次请求都需要服务器回送响应，在请求结束后，会主动释放连接。从建立连接到关闭连接的过程称为“一次连接”。

       6、TCP和UDP的区别

1。TCP是面向链 接的，虽然说网络的不安全不稳定特性决定了多少次握手都不能保证连接的可靠性，但TCP的三次握手在最低限度上（实际上也很大程度上保证了）保证了连接的 可靠性；而UDP不是面向连接的，UDP传送数据前并不与对方建立连接，对接收到的数据也不发送确认信号，发送端不知道数据是否会正确接收，当然也不用重 发，所以说UDP是无连接的、不可靠的一种数据传输协议。

2。也正由于1所说的特点，使得UDP的开销更小数据传输速率更高，因为不必进行收发数据的确认，所以UDP的实时性更好。

知道了TCP和 UDP的区别，就不难理解为何采用TCP传输协议的MSN比采用UDP的QQ传输文件慢了，但并不能说QQ的通信是不安全的，因为程序员可以手动对UDP 的数据收发进行验证，比如发送方对每个数据包进行编号然后由接收方进行验证啊什么的，即使是这样，UDP因为在底层协议的封装上没有采用类似TCP的“三次握手”而实现了TCP所无法达到的传输效率。

二、下面介绍我们Android中如何通过http通信的几种方法？

  1、使用java的 java.net下提供了API访问HTTP服务。

创建URL以及URLConnection/HttpURLConnection对象，设置连接参数 ，连接到服务器 ，向服务器写数据 ，从服务器读取数据

                使用Java.net.* 例子：

                 

import java.net.*;
public class javaNetTest{
       public static void main(String args[]){
           try {
			//定义地址
			URL url=new URL("http://www.baidu.com");
			//打开连接
			HttpURLConnection http=(HttpURLConnection)url.openConnection();
			//得到连接状态
			int RC=http.getResponseCode();
			if(RC==HttpURLConnection.HTTP_OK)
			{
				//取得数据
				InputStream is = http.getInputStream();
				//处理数据
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
        }|
}

             2、Android SDK附带了Apache的HttpClient API

                       例子：

                      在XML中加入单元测试类库

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.example.test"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <!-- 配置测试要使用的类库 -->
        <uses-library android:name="android.test.runner"/>
    </application>
    <!-- 配置测试设备的主类和目标包 -->
    <instrumentation android:name="android.test.InstrumentationTestRunner"
					 android:targetPackage="com.scott.http"/>
	<!-- 访问HTTP服务所需的网络权限 -->
	<uses-permission android:name="android.permission.INTERNET"/>
	<uses-sdk android:minSdkVersion="8" />
</manifest>

           在Android项目中我们就可以不用创建一个Activity，创建一个TestHttpClient.java就可以

           

package com.scot.http.test;

import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

import junit.framework.Assert;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.mime.MultipartEntity;
import org.apache.http.entity.mime.content.InputStreamBody;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;

import android.test.AndroidTestCase;

public class HttpTest extends AndroidTestCase {
	
	private static final String PATH = "http://192.168.1.57:8080/web";
	
	public void testGet() throws Exception {
		HttpClient client = new DefaultHttpClient();
    	HttpGet get = new HttpGet(PATH + "/TestServlet?id=1001&name=john&age=60");
    	HttpResponse response = client.execute(get);
    	if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
        	InputStream is = response.getEntity().getContent();
        	String result = inStream2String(is);
        	Assert.assertEquals(result, "GET_SUCCESS");
    	}
	}
	
	public void testPost() throws Exception {
		HttpClient client = new DefaultHttpClient();
		HttpPost post = new HttpPost(PATH + "/TestServlet");
		List<NameValuePair> params = new ArrayList<NameValuePair>();
		params.add(new BasicNameValuePair("id", "1001"));
		params.add(new BasicNameValuePair("name", "john"));
		params.add(new BasicNameValuePair("age", "60"));
		HttpEntity formEntity = new UrlEncodedFormEntity(params);
		post.setEntity(formEntity);
		HttpResponse response = client.execute(post);
		if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
        	InputStream is = response.getEntity().getContent();
        	String result = inStream2String(is);
        	Assert.assertEquals(result, "POST_SUCCESS");
    	}
	}
	
	public void testUpload() throws Exception {
		InputStream is = getContext().getAssets().open("books.xml");
		HttpClient client = new DefaultHttpClient();
		HttpPost post = new HttpPost(PATH + "/UploadServlet");
		InputStreamBody isb = new InputStreamBody(is, "books.xml");
		MultipartEntity multipartEntity = new MultipartEntity();
		multipartEntity.addPart("file", isb);
		multipartEntity.addPart("desc", new StringBody("this is description."));
		post.setEntity(multipartEntity);
		HttpResponse response = client.execute(post);
		if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
        	is = response.getEntity().getContent();
        	String result = inStream2String(is);
        	Assert.assertEquals(result, "UPLOAD_SUCCESS");
    	}
	}
	
	//将输入流转换成字符串
	private String inStream2String(InputStream is) throws Exception {
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		byte[] buf = new byte[1024];
		int len = -1;
		while ((len = is.read(buf)) != -1) {
			baos.write(buf, 0, len);
		}
		return new String(baos.toByteArray());
	}
}

            服务端代码

             

@Override
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		System.out.println("doGet method is called.");
		String id = request.getParameter("id");
		String name = request.getParameter("name");
		String age = request.getParameter("age");
		System.out.println("id:" + id + ", name:" + name + ", age:" + age);
		response.getWriter().write("GET_SUCCESS");
	}

@Override
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		System.out.println("doPost method is called.");
		String id = request.getParameter("id");
		String name = request.getParameter("name");
		String age = request.getParameter("age");
		System.out.println("id:" + id + ", name:" + name + ", age:" + age);
		response.getWriter().write("POST_SUCCESS");
	}

上面两个是最基本的GET请求和POST请求，参数都是文本数据类型，能满足普通的需求，不过在有的场合例如我们要用到上传文件的时候，就不能使用基本的GET请求和POST请求了，我们要使用多部件的POST请求。下面介绍一下如何使用多部件POST操作上传一个文件到服务端。

由于Android附带的HttpClient版本暂不支持多部件POST请求，所以我们需要用到一个HttpMime开源项目，该组件是专门处理与MIME类型有关的操作。因为HttpMime是包含在HttpComponents 项目中的，所以我们需要去apache官方网站下载HttpComponents，然后把其中的HttpMime.jar包放到项目中去

我们用HttpMime提供的InputStreamBody处理文件流参数，用StringBody处理普通文本参数，最后把所有类型参数都加入到一个MultipartEntity的实例中，并将这个multipartEntity设置为此次POST请求的参数实体，然后执行POST请求。服务端Servlet代码如下：

                服务端代码  ：

package com.scott.web.servlet;

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileItemFactory;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;

@SuppressWarnings("serial")
public class UploadServlet extends HttpServlet {
	
	@Override
	@SuppressWarnings("rawtypes")
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		boolean isMultipart = ServletFileUpload.isMultipartContent(request);
		if (isMultipart) {
			FileItemFactory factory = new DiskFileItemFactory();
			ServletFileUpload upload = new ServletFileUpload(factory);
			try {
				List items = upload.parseRequest(request);
				Iterator iter = items.iterator();
				while (iter.hasNext()) {
				    FileItem item = (FileItem) iter.next();
				    if (item.isFormField()) {
				    	//普通文本信息处理
				    	String paramName = item.getFieldName();
				        String paramValue = item.getString();
				        System.out.println(paramName + ":" + paramValue);
				    } else {
				    	//上传文件信息处理
				        String fileName = item.getName();
				        byte[] data = item.get();
				        String filePath = getServletContext().getRealPath("/files") + "/" + fileName;
				        FileOutputStream fos = new FileOutputStream(filePath);
				        fos.write(data);
				        fos.close();
				    }
				}
			} catch (FileUploadException e) {
				e.printStackTrace();
			}
		}
		response.getWriter().write("UPLOAD_SUCCESS");
	}
}

服务端使用apache开源项目FileUpload进行处理，所以我们需要commons-fileupload和commons-io这两个项目的jar包

我们需要考虑一个问题，在实际应用中，我们不能每次都新建HttpClient，而是应该只为整个应用创建一个HttpClient，并将其用于所有HTTP通信。此外，还应该注意在通过一个HttpClient同时发出多个请求时可能发生的多线程问题。针对这两个问题，我们需要改进一下我们的项目：

1.扩展系统默认的Application，并应用在项目中。

2.使用HttpClient类库提供的ThreadSafeClientManager来创建和管理HttpClient。

package com.scott.http;

import org.apache.http.HttpVersion;
import org.apache.http.client.HttpClient;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
import org.apache.http.protocol.HTTP;

import android.app.Application;

public class MyApplication extends Application {

	private HttpClient httpClient;
	
	@Override
	public void onCreate() {
		super.onCreate();
		httpClient = this.createHttpClient();
	}
	
	@Override
	public void onLowMemory() {
		super.onLowMemory();
		this.shutdownHttpClient();
	}
	
	@Override
	public void onTerminate() {
		super.onTerminate();
		this.shutdownHttpClient();
	}
	
	//创建HttpClient实例
	private HttpClient createHttpClient() {
		HttpParams params = new BasicHttpParams();
		HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
		HttpProtocolParams.setContentCharset(params, HTTP.DEFAULT_CONTENT_CHARSET);
		HttpProtocolParams.setUseExpectContinue(params, true);
		
		SchemeRegistry schReg = new SchemeRegistry();
		schReg.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
		schReg.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
		
		ClientConnectionManager connMgr = new ThreadSafeClientConnManager(params, schReg);
		
		return new DefaultHttpClient(connMgr, params);
	}
	
	//关闭连接管理器并释放资源
	private void shutdownHttpClient() {
		if (httpClient != null && httpClient.getConnectionManager() != null) {
			httpClient.getConnectionManager().shutdown();
		}
	}
	
	//对外提供HttpClient实例
	public HttpClient getHttpClient() {
		return httpClient;
	}
}

我们重写了onCreate()方法，在系统启动时就创建一个HttpClient；重写了onLowMemory()和onTerminate()方法，在内存不足和应用结束时关闭连接，释放资源。需要注意的是，当实例化DefaultHttpClient时，传入一个由ThreadSafeClientConnManager创建的一个ClientConnectionManager实例，负责管理HttpClient的HTTP连接。

然后，想要让我们这个加强版的“Application”生效，需要在AndroidManifest.xml中做如下配置：

<application  android:name=".MyApplication" ...>
...
</application>

如果我们没有配置，系统默认会使用android.app.Application，我们添加了配置，系统就会使用我们的com.scott.http.MyApplication，然后就可以在context中调用getApplication()来获取MyApplication实例。
有了上面的配置，我们就可以在活动中应用了，HttpActivity.java代码如下

package com.scott.http;

import java.io.ByteArrayOutputStream;
import java.io.InputStream;

import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

public class HttpActivity extends Activity {
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		Button btn = (Button) findViewById(R.id.btn);
		btn.setOnClickListener(new View.OnClickListener() {
			@Override
			public void onClick(View v) {
				execute();
			}
		});
		
	}
	
	private void execute() {
		try {
			MyApplication app = (MyApplication) this.getApplication();	//获取MyApplication实例
			HttpClient client = app.getHttpClient();	//获取HttpClient实例
			HttpGet get = new HttpGet("http://192.168.1.57:8080/web/TestServlet?id=1001&name=john&age=60");
			HttpResponse response = client.execute(get);
			if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
	        	InputStream is = response.getEntity().getContent();
	        	String result = inStream2String(is);
	        	Toast.makeText(this, result, Toast.LENGTH_LONG).show();
	    	}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	//将输入流转换成字符串
	private String inStream2String(InputStream is) throws Exception {
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		byte[] buf = new byte[1024];
		int len = -1;
		while ((len = is.read(buf)) != -1) {
			baos.write(buf, 0, len);
		}
		return new String(baos.toByteArray());
	}
}

 总结一下：

           Android通过http实现网络通信有两种方式

一 、 通过 java.net.*API

                     ①先创建一个URL url=new URl("http://www.baidu.com");对象

                     ②创建httpURLConnection http = (HttpURLConnection)url.openConnection();打开连接

                        http.getResponseCode获取请求码，

                     ③ 获取InputStream is =  http.getInputStream()

二、通过Apache 的HttpClient客户端，默认Android中SDK就附带

                      

                         ①HttpClient httpclient = new DefaultHttpClient();              

                         ②

                                  1）如何是Get方式创建HttpCet get = new HttpGet(PATH+ "/TestServlet?id=1001&name=john");

                                  2）如果是POST方式创建HttpPost post = new HttpPost(PATH+"/TestSevlet");

                                           POST方式要创建一个表单实体对象封装数据，

                                                先创建一个参数列表，用到了NameValuePair对象

                                            List<NameValuePair> params = new ArrayList<NameValuePair>();

                                            HttpEntity formEntity = new UrlEncodedFormEntity(params);

                                            post.setEntity(formEntity);     

                          ③httpClient.execute(get)或httpClient.execute(post);  返回一个HttpResponse对象

                          ④通过HttpResponse对象获取服务端返回来的数据流

                                                    InputStream is =response.getEntity().getContent();

                                                    如何传来的是字符串，我们将流转化会字符串，

                                                    String result = inStream2String(is);
                            

HttpMime.jar来实现文件类型上传

                         而针对Android程序我只用一个HttpClient对象发送多个请求是，会出现多线程问题，这里用ThreadSafeClientConnManager实现