Android网络编程

转自：http://blog.csdn.net/shinilaobababa/article/details/7790832

Socket连接与HTTP连接

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

1)

  Socket是一个针对TCP和UDP编程的接口，你可以借助它建立TCP连接等等。而TCP和UDP协议属于传输层 。
  而http是个应用层的协议，它实际上也建立在TCP协议之上。 

 

 (HTTP是轿车，提供了封装或者显示数据的具体形式；Socket是发动机，提供了网络通信的能力。)

 

 

2）

Socket是对TCP/IP协议的封装，Socket本身并不是协议，而是一个调用接口（API），通过Socket，我们才能使用TCP/IP协议。Socket的出现只是使得程序员更方便地使用TCP/IP协议栈而已，是对TCP/IP协议的抽象，从而形成了我们知道的一些最基本的函数接口。

 

 

下面是一些的重要的概念，特在此做摘抄和总结。

一。什么是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连接的请求，断开过程需要经过“四次握手”（过程就不细写了，就是服务器和客户端交互，最终确定断开）

二。利用Socket建立网络连接的步骤

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

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

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

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

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

三。HTTP链接的特点

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

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

四。TCP和UDP的区别

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

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

 

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

 

JAVA中三种URL连接方法

     Java的网络类可以让你通过网络或者远程连接来实现应用。而且，这个平台现在已经可以对国际互联网以及URL资源进行访问了。Java的URL类可以让访问网络资源就像是访问你本地的文件夹一样方便快捷。我们通过使用Java的URL类就可以经由URL完成读取和修改数据的操作。

     通过一个URL连接，我们就可以确定资源的位置，比如网络文件、网络页面以及网络应用程序等。其中包含了许多的语法元素。
　  从URL得到的数据可以是多种多样的，这些都需要一种统一的机制来完成对URL的读取与修改操作。Java语言在它的java.net软件包里就提供了这么一种机制。

     URL class是从URL标示符中提取出来的。它允许Java程序设计人员打开某个特定URL连接，并对里边的数据进行读写操作以及对首部信息进行读写操作。而且，它还允许程序员完成其它的一些有关URL的操作。

　　

构造

    在创建java.net URL的实例的时候，你能够利用许多公共构造器，从而让其变得更具灵活性。举个例子来说，这个class提供了一种使用完整URL信息串的构造器，一种使用把URL信息串分解成为协议、主机名以及文件和资源的构造器，还有一种把URL信息串分解成为协议、主机名、端口号以及文件的构造器。我们首先使用完整的URL来创建一个URL class的例子：

URL aURL = new URL(“http://www.mycompany.com:8080/index.html”);

在这个例子中，我们创建了一个使用完整URL的URL class，其中明确指出了使用的协议是http，主机名称是www.mycompany.com，端口号码为8080，文件/资源为index.html。如果组成URL的语法发生了错误，那么构造器就会发出MalformedURLException。

连接
　　一旦你成功的创建了一个URL class的实例，你就可以对其进行操作了。但是在你能够访问这个URL上的资源和内容之前，你必须要打开到这些资源与内容上的连接。你可以通过使用openConnection来完成这一操作。

使用openConnection并不需要参数，并且在操作成功之后，它会返回一个URLConnection class的实例。在Listing A中，向我们演示了打开一个到URL连接的过程。一旦你的连接成功，你就可以开始对这个URLConnection的输入以及输出流进行读和写的操作了。

　　从URL连接中读取数据

使用java.io stream class来从URL中读取数据是一个非常简单的过程。一旦你建立了一个成功的连接，那么你就可以获得针对这个连接的输入流并且开始进行写的操作了。很幸运的是，java.io classes可以以与对文件流或者socket流进行操作的同样方式进行对从URLConnection流返回的数据进行操作。

　　对URL进行写的操作

使用java.io stream classes对URL进行写的操作同样也是非常简单的。一旦你建立了一个成功的连接之后，你就可以得到来自此连接的输出流并且开始进行写的操作。当然，只有对于客户所希望的数据进行写的操作才是有意义的。同样的，在获得并对URLConnection流进行写的操作之前，你还需要使用setDoOutput(boolean)方式把输出（Output）属性设置为真（true）来指定可以进行写操作的那些连接。Java.io classes允许你把数据写到URLConnection流，这个操作也和你对文件流和socket流进行的写操作一样。

　　其它的操作

你可以从URL以及URLConnection对象连接中得到其它类型的信息，比如说主机名、端口、内容长度、内容编码以及内容的类型。把这些方法连同stream I/O classes一起使用可以让你建立复杂而有效的网络客户应用程序和服务。

　　对网络的便捷访问

由Java平台所提供的URL class让我们可以方便而有效的访问网络上的资源，而且可以让我们象访问本地文件一样的感到轻松愉快。我们不用为网络通讯的细节问题操心，只需要把注意力集中到制作有用的应用程序和服务上去。

 

    三种连接方法

          // 方法一 
           URL url = new URL("http://www.sina.com.cn");
           URLConnection urlcon = url.openConnection();
           InputStream is = urlcon.getInputStream();
          
            // 方法二
           URL url = new URL("http://www.yhfund.com.cn");
           HttpURLConnection urlcon = (HttpURLConnection)url.openConnection();
           InputStream is = urlcon.getInputStream();
          
           //方法三
           URL url = new URL("http://www.yhfund.com.cn");
           InputStream is = url.openStream();

    具体例子

           long begintime = System.currentTimeMillis();
          
           URL url = new URL("http://www.yhfund.com.cn");
           HttpURLConnection urlcon = (HttpURLConnection)url.openConnection();
           urlcon.connect();         //获取连接
           InputStream is = urlcon.getInputStream();
           BufferedReader buffer = new BufferedReader(new InputStreamReader(is));
           StringBuffer bs = new StringBuffer();
           String l = null;
           while((l=buffer.readLine())!=null){
               bs.append(l).append("/n");
           }
           System.out.println(bs.toString());
          
           //System.out.println(" content-encode："+urlcon.getContentEncoding());
           //System.out.println(" content-length："+urlcon.getContentLength());
           //System.out.println(" content-type："+urlcon.getContentType());
           //System.out.println(" date："+urlcon.getDate());
                
           System.out.println("总共执行时间为："+(System.currentTimeMillis()-begintime)+"毫秒");
        }catch(IOException e){
           System.out.println(e);
       }
    }
}

 

 

Java与Http协议

引言                                        

      http（超文本传输协议）是一个基于请求与响应模式的、无状态的、应用层的协议，常基于TCP的连接方式。HTTP协议的主要特点是：
     1.支持客户/服务器模式。
     2.简单快速：客户向服务器请求服务时，只需传送请求方法和路径。由于HTTP协议简单，通信速度很快。
     3.灵活：HTTP允许传输任意类型的数据对象。类型由Content-Type加以标记。
     4.无连接：即每次连接只处理一个请求，处理完客户的请求，并收到客户的应答后，即断开连接。采用这种方式可以节省传输时间。
     5.无状态：无状态是指协议对于事务处理没有记忆能力。 

     http1.0协议默认的是非持久连接， HTTP1.1默认的连接方式为持久连接。

非持久连接：每次服务器发出一个对象后，相应的TCP连接就被关闭，也就是说每个连接都没有持续到可用于传送其他对象。每个TCP连接只用于传输一个请求消息和一个响应消息。

持久连接：服务器在发出响应后让TCP连接继续打开着。同一对客户/服务器之间的后续请求和响应可以通过这个连接发送。HTTP/1.1的默认模式使用带流水线的持久连接。

 

一、HTTP协议详解之请求

 

//请求行
POST /reg.jsp HTTP/ (CRLF)       

//消息报头
Accept:image/gif,image/x-xbitmap,image/jpeg,application/x-shockwave-flash,application/vnd.ms-excel,application/vnd.ms-powerpoint,application/msword,*/* (CRLF)
Accept-Language:zh-cn (CRLF)
Accept-Encoding:gzip,deflate (CRLF)
If-Modified-Since:Wed,05 Jan 2007 11:21:25 GMT (CRLF)
If-None-Match:W/"80b1a4c018f3c41:8317" (CRLF)
User-Agent:Mozilla/4.0(compatible;MSIE6.0;Windows NT 5.0) (CRLF)
Host:www.guet.edu.cn (CRLF)
Connection:Keep-Alive (CRLF)
(CRLF)

//请求正文
user=jeffrey&pwd=1234 

     以上是http请求的三部：请求行、消息报头、请求正文。

 

     请求行以一个方法符号开头，以空格分开，后面跟着请求的URI和协议的版本，格式如下：

Method Request-URI HTTP-Version CRLF  
     其中 Method表示请求方法(如POST、GET、PUT、DELETE等)；Request-URI是一个统一资源标识符；HTTP-Version表示请求的HTTP协议版本；CRLF表示回车和换行。

 

二、HTTP协议详解之响应篇

//状态行
HTTP/1.1 200 OK (CRLF)

//消息报头
Cache-Control: private, max-age=30
Content-Type: text/html; charset=utf-8
Content-Encoding: gzip
Expires: Mon, 25 May 2009 03:20:33 GMT
Last-Modified: Mon, 25 May 2009 03:20:03 GMT
Vary: Accept-Encoding
Server: Microsoft-IIS/7.0
X-AspNet-Version: 2.0.50727
X-Powered-By: ASP.NET
Date: Mon, 25 May 2009 03:20:02 GMT
Content-Length: 12173

//响应正文
略

     HTTP响应也是由三个部分组成，分别是：状态行、消息报头、响应正文

     状态行格式如下：
          HTTP-Version Status-Code Reason-Phrase CRLF
     其中，HTTP-Version表示服务器HTTP协议的版本；Status-Code表示服务器发回的响应状态代码；Reason-Phrase表示状态代码的文本描述。

常见状态代码、状态描述、说明：
200 OK      //客户端请求成功
400 Bad Request  //客户端请求有语法错误，不能被服务器所理解
401 Unauthorized //请求未经授权，这个状态代码必须和WWW-Authenticate报头域一起使用 
403 Forbidden  //服务器收到请求，但是拒绝提供服务
404 Not Found  //请求资源不存在，eg：输入了错误的URL
500 Internal Server Error //服务器发生不可预期的错误
503 Server Unavailable  //服务器当前不能处理客户端的请求，一段时间后可能恢复正常

 

三、HTTP协议详解之消息报头

        HTTP消息由客户端到服务器的请求和服务器到客户端的响应组成。请求消息和响应消息都是由开始行（对于请求消息，开始行就是请求行；对于响应消息，开始行就是状态行），消息报头（可选），空行（只有CRLF的行），消息正文（可选）组成。

        HTTP消息报头包括普通报头、请求报头、响应报头、实体报头。每一个报头域都是由名字+“：”+空格+值 组成，消息报头域的名字是大小写无关的。

1、请求报头
     请求报头允许客户端向服务器端传递请求的附加信息以及客户端自身的信息。

常用的请求报头

Accept请求报头域用于指定客户端接受哪些类型的信息。
Accept-Charset请求报头域用于指定客户端接受的字符集。
Accept-Encoding请求报头域类似于Accept，但是它是用于指定可接受的内容编码。
Accept-Language请求报头域类似于Accept，但是它是用于指定一种自然语言。
Authorization请求报头域主要用于证明客户端有权查看某个资源。

Host请求报头域主要用于指定被请求资源的Internet主机和端口号，它通常从HTTP URL中提取出来的。User-Agent请求报头域允许客户端将它的操作系统、浏览器和其它属性告诉服务器。

2、响应报头

     响应报头允许服务器传递不能放在状态行中的附加响应信息，以及关于服务器的信息和对Request-URI所标识的资源进行下一步访问的信息。

常用的响应报头
Location响应报头域用于重定向接受者到一个新的位置。Location响应报头域常用在更换域名的时候。
Server响应报头域包含了服务器用来处理请求的软件信息

3. 实体报头

请求和响应消息都可以传送一个实体。

常用的实体报头
Content-Encoding指示已经被应用到实体正文的附加内容的编码。

Content-Language实体报头域描述了资源所用的自然语言。

Content-Length实体报头域用于指明实体正文的长度，以字节方式存储的十进制数字来表示。
Content-Type实体报头域用语指明发送给接收者的实体正文的媒体类型。
Last-Modified实体报头域用于指示资源的最后修改日期和时间。
Expires实体报头域给出响应过期的日期和时间。

 

四、补充

1、HTTP协议Content Lenth限制漏洞导致拒绝服务攻击
使用POST方法时，可以设置ContentLenth来定义需要传送的数据长度，例如ContentLenth:999999999，在传送完成前，内 存不会释放，攻击者可以利用这个缺陷，连续向WEB服务器发送垃圾数据直至WEB服务器内存耗尽。这种攻击方法基本不会留下痕迹。
2、为了提高用户使用浏览器时的性能，现代浏览器还支持并发的访问方式，浏览一个网页时同时建立多个连接，以迅速获得一个网页上的多个图标，这样能更快速完成整个网页的传输。HTTP1.1中提供了这种持续连接的方式，而下一代HTTP协议：HTTP-NG更增加了有关会话控制、丰富的内容协商等方式的支持，来提供更高效率的连接。

 

五.Java利用HTTP协议实现联网和下载

Url的请求连接(Get方式)

String currentUrl=“http://www.myWeb.com/login.jsp?userName='Devin'&passWord='mypassword'”; //URL ?后面的内容为HTTP请求的正文

URL url = new URL(currentUrl);
 
HttpURLConnection httpurlconnection = url.openConnection();

//下面的设置对应HTTP请求中的消息报头
httpurlconnection.setRequestProperty("User-Agent",CommonValues.User_Agent);
httpurlconnection.setRequestProperty("Accept",CommonValues.Accept);
httpurlconnection.setRequestProperty("Accept-Charset",CommonValues.Accept_Charset);
httpurlconnection.setRequestProperty("Accept-Language",CommonValues.Accept_Language);
httpurlconnection.setRequestProperty("Connection",CommonValues.Connection);
httpurlconnection.setRequestProperty("Keep-Alive",CommonValues.Keep_Alive);
httpurlconnection.setConnectTimeout(CommonValues.ConnectionTimeOut);
httpurlconnection.setReadTimeout(CommonValues.ReadTimeOut);
             
httpurlconnection.connect();
            
int responsecode = httpurlconnection.getResponseCode();
             
if(responsecode == HttpURLConnection.HTTP_OK) //对应HTTP响应中状态行的响应码

{
　　//操作请求流，这里对应HTTP响应中的响应正文
}
             
if (httpurlconnection != null) 
{
   httpurlconnection.disconnect();
}

HTTP请求：GET与POST方法的区别

　　HTTP 定义了与服务器交互的不同方法，最基本的方法是 GET 和 POST。

　　1.Get是从服务器上获取数据，Post是向服务器传送数据。GET 用于信息获取，是安全的和幂等的。安全的意味着该操作用于获取信息而非修改信息，幂等的意味着对同一 URL 的多个请求应该返回同样的结果。完整的定义并不像看起来那样严格。

　　2.GET请求请提交的数据放置在HTTP请求协议头中，附加在url之后，以?分开与url分开；而POST提交的数据则放在实体数据中,即在HTML HEADER内提交。

　　3.GET方式提交的数据最多只能有1024字节，而POST则没有此限制。

　　4.安全性问题。使用 Get 的时候，参数会显示在地址栏上，而 Post 不会。所以，如果这些数据是中文数据而且是非敏感数据，那么使用 get；如果用户输入的数据不是中文字符而且包含敏感数据，那么还是使用 post为好。

　　5、Get是Form的默认方法。

 

 

Android网络连接之HttpURLConnection和HttpClient

1.概念      

      HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了，越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。在 JDK 的 java.net 包中已经提供了访问 HTTP 协议的基本功能：HttpURLConnection。但是对于大部分应用程序来说，JDK 库本身提供的功能还不够丰富和灵活。

      除此之外，在Android中，androidSDK中集成了Apache的HttpClient模块，用来提供高效的、最新的、功能丰富的支持 HTTP 协议工具包，并且它支持 HTTP 协议最新的版本和建议。使用HttpClient可以快速开发出功能强大的Http程序。

2.区别

HttpClient是个很不错的开源框架，封装了访问http的请求头，参数，内容体，响应等等，

HttpURLConnection是java的标准类，什么都没封装，用起来太原始，不方便，比如重访问的自定义，以及一些高级功能等。

	URLConnection	HTTPClient
Proxies and SOCKS	Full support in Netscape browser, appletviewer, and applications (SOCKS: Version 4 only); no additional limitations from security policies.	Full support (SOCKS: Version 4 and 5); limited in applets however by security policies; in Netscape can't pick up the settings from the browser.
Authorization	Full support for Basic Authorization in Netscape (can use info given by the user for normal accesses outside of the applet); no support in appletviewer or applications.	Full support everywhere; however cannot access previously given info from Netscape, thereby possibly requesting the user to enter info (s)he has already given for a previous access. Also, you can add/implement additional authentication mechanisms yourself.
Methods	Only has GET and POST.	Has HEAD, GET, POST, PUT, DELETE, TRACE and OPTIONS, plus any arbitrary method.
Headers	Currently you can only set any request headers if you are doing a POST under Netscape; for GETs and the JDK you can't set any headers.  Under Netscape 3.0 you can read headers only if the resource was returned with a Content-length header; if no Content-length header was returned, or under previous versions of Netscape, or using the JDK no headers can be read.	Allows any arbitrary headers to be sent and received.
Automatic Redirection Handling	Yes.	Yes (as allowed by the HTTP/1.1 spec).
Persistent Connections	No support currently in JDK; under Netscape uses HTTP/1.0 Keep-Alive's.	Supports HTTP/1.0 Keep-Alive's and HTTP/1.1 persistence.
Pipelining of Requests	No.	Yes.
Can handle protocols other than HTTP	Theoretically; however only http is currently implemented.	No.
Can do HTTP over SSL (https)	Under Netscape, yes. Using Appletviewer or in an application, no.	No (not yet).
Source code available	No.	Yes.

3.案例

URLConnection

    String urlAddress = "http://192.168.1.102:8080/AndroidServer/login.do";  
    URL url;  
    HttpURLConnection uRLConnection;  
    public UrlConnectionToServer(){  
  
    }  

    //向服务器发送get请求
    public String doGet(String username,String password){  
        String getUrl = urlAddress + "?username="+username+"&password="+password;  
        try {  
            url = new URL(getUrl);  
            uRLConnection = (HttpURLConnection)url.openConnection();  
            InputStream is = uRLConnection.getInputStream();  
            BufferedReader br = new BufferedReader(new InputStreamReader(is));  
            String response = "";  
            String readLine = null;  
            while((readLine =br.readLine()) != null){  
                //response = br.readLine();  
                response = response + readLine;  
            }  
            is.close();  
            br.close();  
            uRLConnection.disconnect();  
            return response;  
        } catch (MalformedURLException e) {  
            e.printStackTrace();  
            return null;  
        } catch (IOException e) {  
            e.printStackTrace();  
            return null;  
        }  
    }  
      

    //向服务器发送post请求
    public String doPost(String username,String password){  
        try {  
            url = new URL(urlAddress);  
            uRLConnection = (HttpURLConnection)url.openConnection();  
            uRLConnection.setDoInput(true);  
            uRLConnection.setDoOutput(true);  
            uRLConnection.setRequestMethod("POST");  
            uRLConnection.setUseCaches(false);  
            uRLConnection.setInstanceFollowRedirects(false);  
            uRLConnection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");  
            uRLConnection.connect();  
              
            DataOutputStream out = new DataOutputStream(uRLConnection.getOutputStream());  
            String content = "username="+username+"&password="+password;  
            out.writeBytes(content);  
            out.flush();  
            out.close();  
              
            InputStream is = uRLConnection.getInputStream();  
            BufferedReader br = new BufferedReader(new InputStreamReader(is));  
            String response = "";  
            String readLine = null;  
            while((readLine =br.readLine()) != null){  
                //response = br.readLine();  
                response = response + readLine;  
            }  
            is.close();  
            br.close();  
            uRLConnection.disconnect();  
            return response;  
        } catch (MalformedURLException e) {  
            e.printStackTrace();  
            return null;  
        } catch (IOException e) {  
            e.printStackTrace();  
            return null;  
        }  
    }  

HTTPClient

String urlAddress = "http://192.168.1.102:8080/qualityserver/login.do";  
public HttpClientServer(){  
          
 }  
      
public String doGet(String username,String password){  
    String getUrl = urlAddress + "?username="+username+"&password="+password;  
    HttpGet httpGet = new HttpGet(getUrl);  
    HttpParams hp = httpGet.getParams();  
    hp.getParameter("true");  
    //hp.  
    //httpGet.setp  
    HttpClient hc = new DefaultHttpClient();  
    try {  
        HttpResponse ht = hc.execute(httpGet);  
        if(ht.getStatusLine().getStatusCode() == HttpStatus.SC_OK){  
            HttpEntity he = ht.getEntity();  
            InputStream is = he.getContent();  
            BufferedReader br = new BufferedReader(new InputStreamReader(is));  
            String response = "";  
            String readLine = null;  
            while((readLine =br.readLine()) != null){  
                //response = br.readLine();  
                response = response + readLine;  
            }  
            is.close();  
            br.close();  
              
            //String str = EntityUtils.toString(he);  
            System.out.println("========="+response);  
            return response;  
        }else{  
            return "error";  
        }  
    } catch (ClientProtocolException e) {  
        // TODO Auto-generated catch block  
        e.printStackTrace();  
        return "exception";  
    } catch (IOException e) {  
        // TODO Auto-generated catch block  
        e.printStackTrace();  
        return "exception";  
    }      
}  
  
public String doPost(String username,String password){  
    //String getUrl = urlAddress + "?username="+username+"&password="+password;  
    HttpPost httpPost = new HttpPost(urlAddress);  
    List params = new ArrayList();  
    NameValuePair pair1 = new BasicNameValuePair("username", username);  
    NameValuePair pair2 = new BasicNameValuePair("password", password);  
    params.add(pair1);  
    params.add(pair2);  
      
    HttpEntity he;  
    try {  
        he = new UrlEncodedFormEntity(params, "gbk");  
        httpPost.setEntity(he);  
          
    } catch (UnsupportedEncodingException e1) {  
        // TODO Auto-generated catch block  
        e1.printStackTrace();  
    }   
      
    HttpClient hc = new DefaultHttpClient();  
    try {  
        HttpResponse ht = hc.execute(httpPost);  
        //连接成功  
        if(ht.getStatusLine().getStatusCode() == HttpStatus.SC_OK){  
            HttpEntity het = ht.getEntity();  
            InputStream is = het.getContent();  
            BufferedReader br = new BufferedReader(new InputStreamReader(is));  
            String response = "";  
            String readLine = null;  
            while((readLine =br.readLine()) != null){  
                //response = br.readLine();  
                response = response + readLine;  
            }  
            is.close();  
            br.close();  
              
            //String str = EntityUtils.toString(he);  
            System.out.println("=========&&"+response);  
            return response;  
        }else{  
            return "error";  
        }  
    } catch (ClientProtocolException e) {  
        // TODO Auto-generated catch block  
        e.printStackTrace();  
        return "exception";  
    } catch (IOException e) {  
        // TODO Auto-generated catch block  
        e.printStackTrace();  
        return "exception";  
    }     
}  

servlet端json转化： 

        resp.setContentType("text/json");  
        resp.setCharacterEncoding("UTF-8");  
        toDo = new ToDo();  
        List list = new ArrayList();  
        list = toDo.queryUsers(mySession);  
        String body;  

        //设定JSON  
        JSONArray array = new JSONArray();  
        for(UserBean bean : list)  
        {  
            JSONObject obj = new JSONObject();  
            try  
            {  
                 obj.put("username", bean.getUserName());  
                 obj.put("password", bean.getPassWord());  
             }catch(Exception e){}  
             array.add(obj);  
        }  
        pw.write(array.toString());  
        System.out.println(array.toString());  

android端接收：

String urlAddress = "http://192.168.1.102:8080/qualityserver/result.do";  
        String body =   
            getContent(urlAddress);  
        JSONArray array = new JSONArray(body);            
        for(int i=0;i map = new HashMap();  
            try {  
                userName = obj.getString("username");  
                passWord = obj.getString("password");  
            } catch (JSONException e) {  
                e.printStackTrace();  
            }  
            map.put("username", userName);  
            map.put("password", passWord);  
            listItem.add(map);  
              
        }  
          
        } catch (Exception e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
          
        if(sb!=null)  
        {  
            showResult.setText("用户名和密码信息：");  
            showResult.setTextSize(20);  
        } else  
            extracted();  
   
       //设置adapter   
        SimpleAdapter simple = new SimpleAdapter(this,listItem,  
                android.R.layout.simple_list_item_2,  
                new String[]{"username","password"},  
                new int[]{android.R.id.text1,android.R.id.text2});  
        listResult.setAdapter(simple);  
          
        listResult.setOnItemClickListener(new OnItemClickListener() {  
            @Override  
            public void onItemClick(AdapterView parent, View view,  
                    int position, long id) {  
                int positionId = (int) (id+1);  
                Toast.makeText(MainActivity.this, "ID："+positionId, Toast.LENGTH_LONG).show();  
              
            }  
        });  
    }  
    private void extracted() {  
        showResult.setText("没有有效的数据！");  
    }  
    //和服务器连接  
    private String getContent(String url)throws Exception{  
        StringBuilder sb = new StringBuilder();  
        HttpClient client =new DefaultHttpClient();  
        HttpParams httpParams =client.getParams();  
          
        HttpConnectionParams.setConnectionTimeout(httpParams, 3000);  
        HttpConnectionParams.setSoTimeout(httpParams, 5000);  
        HttpResponse response = client.execute(new HttpGet(url));  
        HttpEntity entity =response.getEntity();  
          
        if(entity !=null){  
            BufferedReader reader = new BufferedReader(new InputStreamReader  
                    (entity.getContent(),"UTF-8"),8192);  
            String line =null;  
            while ((line= reader.readLine())!=null){  
                sb.append(line +"\n");  
            }  
            reader.close();  
        }  
        return sb.toString();  
    }  

 

 

android之HttpURLConnection

1.HttpURLConnection连接URL
1)创建一个URL对象

URL url = new URL(http://www.baidu.com/);

2)利用HttpURLConnection对象从网络中获取网页数据

HttpURLConnection conn = (HttpURLConnection) url.openConnection();

3)设置连接超时

conn.setConnectTimeout(6*1000);

4)对响应码进行判断

if (conn.getResponseCode() != 200)    //从Internet获取网页,发送请求,将网页以流的形式读回来

throw new RuntimeException("请求url失败");

5)得到网络返回的输入流

InputStream is = conn.getInputStream();
6)String result = readData(is, "GBK"); //文件流输入出文件用outStream.write
7)conn.disconnect();

总结:
--记得设置连接超时,如果网络不好,Android系统在超过默认时间会收回资源中断操作.
--返回的响应码200,是成功.
--在Android中对文件流的操作和JAVA SE上面是一样的.
--在对大文件的操作时,要将文件写到SDCard上面,不要直接写到手机内存上.
--操作大文件是,要一遍从网络上读,一遍要往SDCard上面写,减少手机内存的使用.这点很重要,面试经常会被问到.
--对文件流操作完,要记得及时关闭.

2.向Internet发送请求参数
步骤：
1)创建URL对象:URL realUrl = new URL(requestUrl);
2)通过HttpURLConnection对象,向网络地址发送请求

HttpURLConnection conn = (HttpURLConnection) realUrl.openConnection();
3)设置容许输出:conn.setDoOutput(true);
4)设置不使用缓存:conn.setUseCaches(false);
5)设置使用POST的方式发送:conn.setRequestMethod("POST");
6)设置维持长连接:conn.setRequestProperty("Connection", "Keep-Alive");
7)设置文件字符集:conn.setRequestProperty("Charset", "UTF-8");
8)设置文件长度:conn.setRequestProperty("Content-Length", String.valueOf(data.length));
9)设置文件类型:conn.setRequestProperty("Content-Type","application/x-www-form-urlencoded");
10)以流的方式输出.
总结:
--发送POST请求必须设置允许输出
--不要使用缓存,容易出现问题.
--在开始用HttpURLConnection对象的setRequestProperty()设置,就是生成HTML文件头.

3.向Internet发送xml数据
XML格式是通信的标准语言,Android系统也可以通过发送XML文件传输数据.
1)将生成的XML文件写入到byte数组中,并设置为UTF-8:byte[] xmlbyte = xml.toString().getBytes("UTF-8");
2)创建URL对象,并指定地址和参数:URL url = new URL(http://localhost:8080/itcast/contanctmanage.do?method=readxml);
3)获得链接:HttpURLConnection conn = (HttpURLConnection) url.openConnection();
4)设置连接超时:conn.setConnectTimeout(6* 1000);
5)设置允许输出conn.setDoOutput(true);
6)设置不使用缓存:conn.setUseCaches(false);
7)设置以POST方式传输:conn.setRequestMethod("POST");           
8)维持长连接:conn.setRequestProperty("Connection", "Keep-Alive");
9)设置字符集:conn.setRequestProperty("Charset", "UTF-8");
10)设置文件的总长度:conn.setRequestProperty("Content-Length", String.valueOf(xmlbyte.length));
11)设置文件类型:conn.setRequestProperty("Content-Type", "text/xml; charset=UTF-8");
12)以文件流的方式发送xml数据:outStream.write(xmlbyte);
总结:
--我们使用的是用HTML的方式传输文件,这个方式只能传输一般在5M一下的文件.
--传输大文件不适合用HTML的方式,传输大文件我们要面向Socket编程.确保程序的稳定性
--将地址和参数存到byte数组中:byte[] data = params.toString().getBytes();