查看原文：http://blog.csdn.net/sinat_29912455/article/details/51122286

1、客户端连接服务器实现内部的原理:

分析上图，步骤如下：

第一步：在浏览器客户端中得到用户输入的内容。

第二步：浏览器得到这个网址之后，内部会将这个域名发送到DNS上，进行域名解析。得到它的IP之后就会链接到指定的服务器上，假如服务器的地址是：221.104.13.32:80，从浏览器到服务器端口它使用到最底层的TCP/IP协议。

第三步：实现TCP/IP协议用Socket来完成，使用了Socket的套接字。

第四步：服务器端的80端口监听客户端的链接，这样客户端到服务器就链接上了。
服务器接收到这些内容之后，并按照这些请求的路径找到对应的页面，进一步找到对应的网页内容，返回给客户端。

通俗一点讲，用户在浏览器输入网址，通过http协议发出去，网址经过DNS域名解析，解析成指定的ip地址，并在80端口上监听用户的请求。服务器监听到请求之后，会以三种方式返回给客户端：HTML、XML、JASON。

GET方式和POST方式的差别：

GET是从服务器上获取数据，POST是向服务器传送数据。
在客户端，GET方式在通过URL提交数据，数据在URL中可以看到；POST方式，数据放在HTML HEADER内提交。
对于GET方式，服务器端用Request.QueryString获取变量的值，对于POST方式，服务器用Request.Form获取提交的数据。
GET方式提交的数据不能大于2KB（主要是URL长度限制），而POST则没有此限制。
安全性问题。正如2中提到，使用GET的时候，参数会显示在地址栏上，而POST不会。所以，如果这些数据是中文数据而且是非敏感数据，那么使用GET；如果用户输入的数据不是中文字符而且包含敏感数据，那么还是使用POST为好。

HTTP返回请求数据的三种方式:

1、以HTML代码内容返回。

2、以XML字符串的形式返回，在以后的android开发中这种形式返回数据比较多。

3、以JSON对象形式返回，在网络流量上考虑JSON要比XML方式要好一些，便于解析。

在Android当中，一般使用xml和Json数据解析。

2、使用HTTP协议访问网络：

Android中的WebView控件已经在后台帮我们处理好了发送HTTP请求、接收服务响应、解析返回数据，以及最终的页面展示这几步工作，不
过由于它封装得太好了，反而不能直观地看出HTTP协议是如何工作的。因此接下来我们通过手动发送HTTP请求的方式，来更加深入的了解这一过程。

在Android上发送HTTP请求的方式一般有两种：HttpURLConnection和HttpCient。我们先来学习HttpCient。

3、HttpCient：

HttpClient是Apache开源组织提供的HTTP网络访问接口（一个开源的项目），从名字上就可以看出，它是一个简单的HTTP客户端
（并不是浏览器），可以发送HTTP请求，接受HTTP响应。但是不会缓存服务器的响应，不能执行HTTP页面中签入嵌入的JS代码，自然也不会对页面内
容进行任何解析、处理，这些都是需要开发人员来完成的。

现在Android已经成功集成了HttpClient，所以开发人员在Android项目中可以直接使用HttpClient来想Web站点提交
请求以及接受响应，如果使用其他的Java项目，需要引入进相应的Jar包。HttpClient可以在官网上下载。官网链接：http://hc.apache.org/downloads.cgi

HttpClient其实是一个interface类型，HttpClient封装了对象需要执行的Http请求、身份验证、连接管理和其它特性。既然HttpClient是一个接口，因此无法创建它的实例。从文档上看，HttpClient有三个已知的实现类分别是：AbstractHttpClient, AndroidHttpClient, DefaultHttpClient，会发现有一个专门为Android应用准备的实现类AndroidHttpClient，当然使用常规的DefaultHttpClient也可以实现功能。

从两个类包所有在位置就可以看出区别，AndroidHttpClient定义在
android.net.http.AndroidHttpClient包下，属于Android原生的http访问，而
DefaultHttpClient定义在org.apache.http.impl.client.DefaultHttpClient包下，属于对
apche项目的支持。而AndroidHttpClient没有公开的构造函数，只能通过静态方法newInstance()方法来获得
AndroidHttpClient对象。

简单来说，用HttpClient发送请求、接收响应都很简单，只需要五大步骤即可：（要牢记）

1、创建代表客户端的HttpClient对象。

2、创建代表请求的对象，如果需要发送GET请求，则创建HttpGet对象，如果需要发送POST请求，则创建HttpPost对象。注：对于发
送请求的参数，GET和POST使用的方式不同，GET方式可以使用拼接字符串的方式，把参数拼接在URL结尾；POST方式需要使用
setEntity(HttpEntity entity)方法来设置请求参数。

3、调用HttpClient对象的execute（HttpUriRequest
request）发送请求，执行该方法后，将获得服务器返回的HttpResponse对象。服务器发还给我们的数据就在这个HttpResponse相
应当中。调用HttpResponse的对应方法获取服务器的响应头、响应内容等。

4、检查相应状态是否正常。服务器发给客户端的相应，有一个相应码：相应码为200，正常；相应码为404，客户端错误；相应码为505，服务器端错误。

5、获得相应对象当中的数据

4、DefaultHttpClient：

GET方式

布局文件，activity_main.xml

  1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  2.     xmlns:tools="http://schemas.android.com/tools"
  3.     android:layout_width="match_parent"
  4.     android:layout_height="match_parent"
  5.     android:orientation="vertical"
  6.     tools:context=".MainActivity" >
  8.     <Button
  9.         android:id="@+id/button1"
  10.         android:layout_width="match_parent"
  11.         android:layout_height="wrap_content"
  12.         android:text="Send Request" />
  14.     <ScrollView
  15.         android:layout_width="match_parent"
  16.         android:layout_height="match_parent" >
  18.         <TextView
  19.             android:id="@+id/TextView1"
  20.             android:layout_width="match_parent"
  21.             android:layout_height="wrap_content"
  22.             android:text="@string/hello_world" />
  23.     </ScrollView>
  25. </LinearLayout>

布局文件中，我们用一个ScrollView来包裹TextView。借助ScrollView控件的话，就可以允许我们一滚动的形式查看屏幕外i的那部分内容。

MainActivity.java的代码如下：

  1. package com.example.m04_http01;
  3. import org.apache.http.HttpEntity;
  4. import org.apache.http.HttpResponse;
  5. import org.apache.http.client.HttpClient;
  6. import org.apache.http.client.methods.HttpGet;
  7. import org.apache.http.impl.client.DefaultHttpClient;
  8. import org.apache.http.util.EntityUtils;
  9. import android.app.Activity;
  10. import android.os.Bundle;
  11. import android.os.Handler;
  12. import android.os.Message;
  13. import android.view.View;
  14. import android.view.View.OnClickListener;
  15. import android.widget.Button;
  16. import android.widget.TextView;
  18. public class MainActivity extends Activity {
  20.     public static final int SHOW_RESPONSE = 0;
  22.     private Button button_sendRequest;
  23.     private TextView textView_response;
  25.     //新建Handler的对象，在这里接收Message，然后更新TextView控件的内容
  26.     private Handler handler = new Handler() {
  28.         @Override
  29.         public void handleMessage(Message msg) {
  30.             super.handleMessage(msg);
  31.             switch (msg.what) {
  32.             case SHOW_RESPONSE:
  33.                 String response = (String) msg.obj;
  34.                 textView_response.setText(response);
  35.                 break;
  37.             default:
  38.                 break;
  39.             }
  40.         }
  42.     };
  44.     @Override
  45.     protected void onCreate(Bundle savedInstanceState) {
  46.         super.onCreate(savedInstanceState);
  47.         setContentView(R.layout.activity_main);
  48.         textView_response = (TextView)findViewById(R.id.TextView1);
  49.         button_sendRequest = (Button)findViewById(R.id.button1);
  51.         button_sendRequest.setOnClickListener(new OnClickListener() {
  53.             //点击按钮时，执行sendRequestWithHttpClient()方法里面的线程
  54.             @Override
  55.             public void onClick(View v) {
  56.                 // TODO Auto-generated method stub
  57.                 sendRequestWithHttpClient();
  58.             }
  59.         });
  60.     }
  62.     //方法：发送网络请求，获取百度首页的数据。在里面开启线程
  63.     private void sendRequestWithHttpClient() {
  64.         new Thread(new Runnable() {
  66.             @Override
  67.             public void run() {
  68.                 //用HttpClient发送请求，分为五步
  69.                 //第一步：创建HttpClient对象
  70.                 HttpClient httpCient = new DefaultHttpClient();
  71.                 //第二步：创建代表请求的对象,参数是访问的服务器地址
  72.                 HttpGet httpGet = new HttpGet("http://www.baidu.com");
  74.                 try {
  75.                     //第三步：执行请求，获取服务器发还的相应对象
  76.                     HttpResponse httpResponse = httpCient.execute(httpGet);
  77.                     //第四步：检查相应的状态是否正常：检查状态码的值是200表示正常
  78.                     if (httpResponse.getStatusLine().getStatusCode() == 200) {
  79.                         //第五步：从相应对象当中取出数据，放到entity当中
  80.                         HttpEntity entity = httpResponse.getEntity();
  81.                         String response = EntityUtils.toString(entity,"utf-8");//将entity当中的数据转换为字符串
  83.                         //在子线程中将Message对象发出去
  84.                         Message message = new Message();
  85.                         message.what = SHOW_RESPONSE;
  86.                         message.obj = response.toString();
  87.                         handler.sendMessage(message);
  88.                     }
  90.                 } catch (Exception e) {
  91.                     // TODO Auto-generated catch block
  92.                     e.printStackTrace();
  93.                 }
  95.             }
  96.         }).start();//这个start()方法不要忘记了        
  98.     }

最后要记得在清单文件中声明访问网络的权限：

  1. <uses-sdk
  3. android:minSdkVersion="8"
  5. android:targetSdkVersion="16" />
  7. <uses-permission android:name="android.permission.INTERNET"/>

POST方式

POST提交数据的步骤：

  1. 构造请求对象；
  2. 将需要传递给服务器端的数据放置在键值对对象当中；
  3. 将准备好的键值对放置在List当中；
  4. 生成代表请求体的对象；
  5. 将存有请求键值对的List对象放置在请求题对象当中；
  6. 将请求体对象放置到请求对象当中；
  7. 发送请求对象
    后面的步骤（即处理请求对象）和GET方法是一致的。
  1. package com.example.m04_http02;
  3. import java.io.BufferedReader;
  4. import java.io.InputStreamReader;
  5. import java.util.ArrayList;
  7. import org.apache.http.HttpEntity;
  8. import org.apache.http.HttpResponse;
  9. import org.apache.http.NameValuePair;
  10. import org.apache.http.client.HttpClient;
  11. import org.apache.http.client.entity.UrlEncodedFormEntity;
  12. import org.apache.http.client.methods.HttpGet;
  13. import org.apache.http.client.methods.HttpPost;
  14. import org.apache.http.impl.client.DefaultHttpClient;
  15. import org.apache.http.message.BasicNameValuePair;
  17. import android.app.Activity;
  18. import android.os.Bundle;
  19. import android.util.Log;
  20. import android.view.View;
  21. import android.view.View.OnClickListener;
  22. import android.widget.Button;
  23. import android.widget.EditText;
  25. public class MainActivity extends Activity {
  27.     private EditText nameText;
  28.     private EditText pwdText;
  29.     private Button button;
  31.     @Override
  32.     protected void onCreate(Bundle savedInstanceState) {
  33.         super.onCreate(savedInstanceState);
  34.         setContentView(R.layout.activity_main);
  35.         nameText = (EditText) findViewById(R.id.nameText);
  36.         pwdText = (EditText) findViewById(R.id.pwdText);
  37.         button = (Button) findViewById(R.id.button1);
  39.         button.setOnClickListener(new OnClickListener() {
  41.             @Override
  42.             public void onClick(View v) {
  43.                 // TODO Auto-generated method stub
  44.                 // 用户输入用户名密码， 然后通过Get方法发送给本地服务器
  45.                 String name = nameText.getText().toString();
  46.                 String pwd = pwdText.getText().toString();
  48.                 // 使用GET方法向本地服务器发送数据
  49.                 //GetThread getThread = new GetThread(name, pwd);
  50.                 //getThread.start();                
  52.                 //使用POST方法向服务器发送数据
  53.                 PostThread postThread = new PostThread(name, pwd);
  54.                 postThread.start();
  55.             }
  56.         });
  57.     }
  59.     //子线程：通过GET方法向服务器发送用户名、密码的信息
  60.     class GetThread extends Thread {
  62.         String name;
  63.         String pwd;
  65.         public GetThread(String name, String pwd) {
  66.             this.name = name;
  67.             this.pwd = pwd;
  68.         }
  70.         @Override
  71.         public void run() {
  72.             //用HttpClient发送请求，分为五步
  73.             //第一步：创建HttpClient对象
  74.             HttpClient httpClient = new DefaultHttpClient();
  75.             //注意，下面这一行中，我之前把链接中的"test"误写成了"text"，导致调BUG调了半天没弄出来，真是浪费时间啊
  76.             String url = "http://192.168.1.112:8080/test.jsp?name=" + name+ "&password=" + pwd;
  77.             //第二步：创建代表请求的对象,参数是访问的服务器地址
  78.             HttpGet httpGet = new HttpGet(url);
  79.             try {
  80.                 //第三步：执行请求，获取服务器发还的相应对象
  81.                 HttpResponse response = httpClient.execute(httpGet);
  82.                 //第四步：检查相应的状态是否正常：检查状态码的值是200表示正常
  83.                 if (response.getStatusLine().getStatusCode() == 200) {
  84.                     //第五步：从相应对象当中取出数据，放到entity当中
  85.                     HttpEntity entity = response.getEntity();
  86.                     BufferedReader reader = new BufferedReader(
  87.                             new InputStreamReader(entity.getContent()));
  88.                     String result = reader.readLine();
  89.                     Log.d("HTTP", "GET:" + result);
  90.                 }
  91.             } catch (Exception e) {
  92.                 e.printStackTrace();
  93.             }
  95.         }
  96.     }    
  98.     //子线程：使用POST方法向服务器发送用户名、密码等数据
  99.     class PostThread extends Thread {
  101.         String name;
  102.         String pwd;
  104.         public PostThread(String name, String pwd) {
  105.             this.name = name;
  106.             this.pwd = pwd;
  107.         }
  109.         @Override
  110.         public void run() {
  111.             HttpClient httpClient = new DefaultHttpClient();
  112.             String url = "http://192.168.1.112:8080/test.jsp";
  113.             //第二步：生成使用POST方法的请求对象
  114.             HttpPost httpPost = new HttpPost(url);
  115.             //NameValuePair对象代表了一个需要发往服务器的键值对
  116.             NameValuePair pair1 = new BasicNameValuePair("name", name);
  117.             NameValuePair pair2 = new BasicNameValuePair("password", pwd);
  118.             //将准备好的键值对对象放置在一个List当中
  119.             ArrayList<NameValuePair> pairs = new ArrayList<NameValuePair>();
  120.             pairs.add(pair1);
  121.             pairs.add(pair2);
  122.             try {
  123.                 //创建代表请求体的对象（注意，是请求体）
  124.                 HttpEntity requestEntity = new UrlEncodedFormEntity(pairs);
  125.                 //将请求体放置在请求对象当中
  126.                 httpPost.setEntity(requestEntity);
  127.                 //执行请求对象
  128.                 try {
  129.                     //第三步：执行请求对象，获取服务器发还的相应对象
  130.                     HttpResponse response = httpClient.execute(httpPost);
  131.                     //第四步：检查相应的状态是否正常：检查状态码的值是200表示正常
  132.                     if (response.getStatusLine().getStatusCode() == 200) {
  133.                         //第五步：从相应对象当中取出数据，放到entity当中
  134.                         HttpEntity entity = response.getEntity();
  135.                         BufferedReader reader = new BufferedReader(
  136.                                 new InputStreamReader(entity.getContent()));
  137.                         String result = reader.readLine();
  138.                         Log.d("HTTP", "POST:" + result);
  139.                     }
  140.                 } catch (Exception e) {
  141.                     e.printStackTrace();
  142.                 }
  143.             } catch (Exception e) {
  144.                 e.printStackTrace();
  145.             }
  146.         }
  147.     }
  149. }

5、Java中使用HTTP——HttpURLConnection

HttpURLConnection继承了URLConnection，所以在URLConnection的基础上进一步改进，增加了一些用于操作 HTTP资源的便捷方法。Java中HttpURLConnection对象通过URL.openConnection()方法来获得，需要进行强制转 换。先来介绍几个HttpURLConnection的常用方法：

  • void setConnectTimeout(int timeout)：设置连接超时时长，如果超过timeout时长，则放弃连接，单位以毫秒计算。

  • void setDoInput(boolean newValue) ：标志是否允许输入。

  • void setDoOutput(boolean newValue)：标志是否允许输出。

  • String getRequestMethod():获取发送请求的方法。

  • int getResponseCode():获取服务器的响应码。

  • void setRequestMethod(String method)：设置发送请求的方法。

  • void setRequestProperty(String field,String newValue)：设置请求报文头，并且只对当前HttpURLConnection有效。

GET方式

这个例子通过GET方式从服务端获取一张图片的信息，并把其保存在本地磁盘中。服务器为本机上的IIS，一张静态图片，直接通过URL访问。

  1. package com.http.get;
  3. import java.io.FileOutputStream;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.net.HttpURLConnection;
  7. import java.net.MalformedURLException;
  8. import java.net.URL;
  10. public class HttpUtils {
  11.     private static String URL_PATH = "http://192.168.1.106:8080/green.jpg";
  12.     /**
  13.      * @param args
  14.      */
  15.     public static void main(String[] args) {
  16.         // 调用方法获取图片并保存
  17.         saveImageToDisk();
  18.     }
  19.     /**
  20.      * 通过URL_PATH的地址访问图片并保存到本地
  21.      */
  22.     public static void saveImageToDisk()
  23.     {
  24.         InputStream inputStream= getInputStream();
  25.         byte[] data=new byte[1024];
  26.         int len=0;
  27.         FileOutputStream fileOutputStream=null;
  28.         try {
  29.             //把图片文件保存在本地F盘下
  30.             fileOutputStream=new FileOutputStream("F:\\test.png");
  31.             while((len=inputStream.read(data))!=-1)
  32.             {
  33.                 //向本地文件中写入图片流
  34.                 fileOutputStream.write(data,0,len);
  35.             }
  36.         } catch (IOException e) {
  37.             e.printStackTrace();
  38.         }
  39.         finally
  40.         {
  41.             //最后关闭流
  42.             if(inputStream!=null)
  43.             {
  44.                 try {
  45.                     inputStream.close();
  46.                 } catch (IOException e) {
  47.                     e.printStackTrace();
  48.                 }
  49.             }
  50.             if(fileOutputStream!=null)
  51.             {
  52.                 try {
  53.                     fileOutputStream.close();
  54.                 } catch (IOException e) {
  55.                     e.printStackTrace();
  56.                 }
  57.             }
  58.         }
  59.     }
  60.     /**
  61.      * 通过URL获取图片
  62.      * @return URL地址图片的输入流。
  63.      */
  64.     public static InputStream getInputStream() {
  65.         InputStream inputStream = null;
  66.         HttpURLConnection httpURLConnection = null;
  68.         try {
  69.             //根据URL地址实例化一个URL对象，用于创建HttpURLConnection对象。
  70.             URL url = new URL(URL_PATH);
  72.             if (url != null) {
  73.                 //openConnection获得当前URL的连接
  74.                 httpURLConnection = (HttpURLConnection) url.openConnection();
  75.                 //设置3秒的响应超时
  76.                 httpURLConnection.setConnectTimeout(3000);
  77.                 //设置允许输入
  78.                 httpURLConnection.setDoInput(true);
  79.                 //设置为GET方式请求数据
  80.                 httpURLConnection.setRequestMethod("GET");
  81.                 //获取连接响应码，200为成功，如果为其他，均表示有问题
  82.                 int responseCode=httpURLConnection.getResponseCode();
  83.                 if(responseCode==200)
  84.                 {
  85.                     //getInputStream获取服务端返回的数据流。
  86.                     inputStream=httpURLConnection.getInputStream();
  87.                 }
  88.             }
  90.         } catch (MalformedURLException e) {
  91.             e.printStackTrace();
  92.         } catch (IOException e) {
  93.             e.printStackTrace();
  94.         }
  95.         return inputStream;
  96.     }
  98. }

POST方式

　这个例子通过POST方式访问一个登陆页面，需要输入用户名（username）和密码（password）。虽然这里使用的Java在讲解问 题，但是服务端是使用.Net的框架，一个很简单的HTML页面加一个表单传送的一般处理程序，输入为admin+123为登陆成功，这里不累述了。
　

  1. package com.http.post;
  3. import java.io.ByteArrayOutputStream;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.io.OutputStream;
  7. import java.io.UnsupportedEncodingException;
  8. import java.net.HttpURLConnection;
  9. import java.net.URL;
  10. import java.net.URLEncoder;
  11. import java.util.HashMap;
  12. import java.util.Map;
  14. public class postUtils {
  16.     private static String PATH = "http://192.168.222.1:1231/loginas.ashx";
  17.     private static URL url;
  19.     public postUtils() {
  20.     }
  21.     static {
  22.         try {
  23.             url = new URL(PATH);
  24.         } catch (Exception e) {
  25.             e.printStackTrace();
  26.         }
  27.     }
  29.     /**
  30.      * 通过给定的请求参数和编码格式，获取服务器返回的数据
  31.      * @param params 请求参数
  32.      * @param encode 编码格式
  33.      * @return 获得的字符串
  34.      */
  35.     public static String sendPostMessage(Map<String, String> params,
  36.             String encode) {
  37.         StringBuffer buffer = new StringBuffer();
  38.         if (params != null && !params.isEmpty()) {
  39.             for (Map.Entry<String, String> entry : params.entrySet()) {
  40.                 try {
  41.                     buffer.append(entry.getKey())
  42.                             .append("=")
  43.                             .append(URLEncoder.encode(entry.getValue(), encode))
  44.                             .append("&");//请求的参数之间使用&分割。
  45.                 } catch (UnsupportedEncodingException e) {
  46.                     e.printStackTrace();
  47.                 }
  49.             }
  50.             buffer.deleteCharAt(buffer.length() - 1);
  51.             System.out.println(buffer.toString());
  52.             try {
  53.                 HttpURLConnection urlConnection = (HttpURLConnection) url
  54.                         .openConnection();
  55.                 urlConnection.setConnectTimeout(3000);
  56.                 //设置允许输入输出
  57.                 urlConnection.setDoInput(true);
  58.                 urlConnection.setDoOutput(true);
  59.                 byte[] mydata = buffer.toString().getBytes();
  60.                 //设置请求报文头，设定请求数据类型
  61.                 urlConnection.setRequestProperty("Content-Type",
  62.                         "application/x-www-form-urlencoded");
  63.                 //设置请求数据长度
  64.                 urlConnection.setRequestProperty("Content-Length",
  65.                         String.valueOf(mydata.length));
  66.                 //设置POST方式请求数据
  67.                 urlConnection.setRequestMethod("POST");
  68.                 OutputStream outputStream = urlConnection.getOutputStream();
  69.                 outputStream.write(mydata);
  70.                 int responseCode = urlConnection.getResponseCode();
  71.                 if (responseCode == 200) {
  72.                     return changeInputStream(urlConnection.getInputStream(),
  73.                             encode);
  74.                 }
  75.             } catch (IOException e) {
  76.                 e.printStackTrace();
  77.             }
  78.         }
  79.         return "";
  80.     }
  82.     /**
  83.      * 把服务端返回的输入流转换成字符串格式
  84.      * @param inputStream 服务器返回的输入流
  85.      * @param encode 编码格式
  86.      * @return 解析后的字符串
  87.      */
  88.     private static String changeInputStream(InputStream inputStream,
  89.             String encode) {
  90.         ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
  91.         byte[] data = new byte[1024];
  92.         int len = 0;
  93.         String result="";
  94.         if (inputStream != null) {
  95.             try {
  96.                 while ((len = inputStream.read(data)) != -1) {
  97.                     outputStream.write(data,0,len);
  98.                 }
  99.                 result=new String(outputStream.toByteArray(),encode);
  101.             } catch (IOException e) {
  102.                 e.printStackTrace();
  103.             }
  104.         }
  105.         return result;
  106.     }
  108.     /**
  109.      * @param args
  110.      */
  111.     public static void main(String[] args) {
  112.         //通过Map设置请求字符串。
  113.         Map<String, String> params = new HashMap<String, String>();
  114.         params.put("username", "admin");
  115.         params.put("password", "123");
  116.         String result=sendPostMessage(params, "utf-8");
  117.         System.out.println(result);
  118.     }
  120. }

HTTP基础与Android之（安卓与服务器通信）——使用HttpClient和HttpURLConnection的更多相关文章

  1. 客户端(android,ios)与服务器通信

    android,ios客户端与服务器通信为了便于理解,直接用PHP作为服务器端语言 其实就是一个 http请求响应的过程序,先从 B/S模式说起浏览器发起http请求,服务器响应请求,并把数据返回给浏 ...

  2. Android操作HTTP实现与服务器通信（转）

    Android操作HTTP实现与服务器通信   本示例以Servlet为例,演示Android与Servlet的通信. 众所周知,Android与服务器通信通常采用HTTP通信方式和Socket通信方 ...

  3. Android操作HTTP实现和服务器通信

    众所周知,Android与服务器通信通常采用HTTP通信方式和Socket通信方式,而HTTP通信方式又分get和post两种方式.至于Socket通信会在以后的博文中介绍. HTTP协议简介: HT ...

  4. Android通过手机搭建服务器，WIFI建立热点实现C/S聊天室通信功能

    应用效果图:                                                客户端                                            ...

  5. Android Studio安卓导出aar包与Unity 3D交互

    Unity与安卓aar 包交互 本文提供全流程,中文翻译. Chinar 坚持将简单的生活方式,带给世人!(拥有更好的阅读体验 -- 高分辨率用户请根据需求调整网页缩放比例) Chinar -- 心分 ...

  6. Unity 3D与Android Studio安卓交互之-导出jar包

    u3d与安卓 jar 包交互 本文提供全流程,中文翻译. Chinar 坚持将简单的生活方式,带给世人!(拥有更好的阅读体验 -- 高分辨率用户请根据需求调整网页缩放比例) Chinar -- 心分享 ...

  7. Android操作HTTP实现与服务器通信

    (转自http://www.cnblogs.com/hanyonglu/archive/2012/02/19/2357842.html) 本示例以Servlet为例,演示Android与Servlet ...

  8. 【Android】安卓四大组件之Activity（二）

    [Android]安卓四大组件之Activity(二) 前言 在这篇文章之前,我已经写过了一篇有关Activity的内容,是关于activity之间的页面跳转和数据传递,而这篇文章着重强调的是Acti ...

  9. 【Android】安卓中的存储

    [Android]安卓中的存储 1.存储在App内部 最简单的一种.在尝试过程中发现,手机中很多文件夹都没有权限读写.我们可以将我们需要写的文件存放到App中的files文件夹中,当然我们有权限在整个 ...

随机推荐

  1. java连接zookeeper服务器出现“KeeperErrorCode = ConnectionLoss for ...”

    错误信息如下: Exception in thread "main" org.apache.zookeeper.KeeperException$ConnectionLossExce ...

  2. Markdown图片存储解决方法-利用阿里云OSS

    我们在用markdown写一些博客或者文章的时候,常常需要引用一些图片,一般都是找一个免费的图床上传,然后复制图片链接在我们的markdown文章中.类似像这样: 存在的隐患 一般的免费图片托管网站有 ...

  3. Weblogic读不到Word文件

    之前遇到一导出word文件的需求,我的做法是把对应导出内容放到一个word文件中,把其中变化的内容作为变量,然后把该word文件放在WEB-INF目录下用来作为模板.在导出时通过ServletCont ...

  4. 【LGP5176】公约数

    题目 老年选手啥都不想推只能搞个杜教筛了 这个式子长得好吓人啊,所以我们唯一分解之后来考虑这道题 设\(i,j,k\)分别是\(p^a,p^b,p^c\),至于到底谁是谁并不重要,我们不妨假设\(a\ ...

  5. SpringMVC 常用applicationContext.xml、web.xml、servlet-mvc.xml简单配置

    在进行学习配置文件之前,为了加深对框架的认识,简单的做了SSM框架的简单实验.然后画出listAll查询方法的整个过程的思维导图. 整个过程中的web.xml.SpringMVC.xml.applic ...

  6. win10搭建ftp服务器的操作方法【图文教程】

    我们知道FTP是TCP/IP网络上两台计算机传送文件的协议,使得主机间可以共享文件.对于win10版本的ftp服务器搭建方法可能有部分用户还不是很清楚,下面这篇文章就是关于win10搭建ftp服务器的 ...

  7. Spark DataSet 、DataFrame 一些使用示例

    以前使用过DS和DF,最近使用Spark ML跑实验,再次用到简单复习一下. //案例数据 1,2,3 4,5,6 7,8,9 10,11,12 13,14,15 1,2,3 4,5,6 7,8,9 ...

  8. 621. Task Scheduler

    https://www.cnblogs.com/grandyang/p/7098764.html 将个数出现最多的那个字符作为分隔的标准,一定是最小的.所以这个时候只需要计算还需要添加多少个idel就 ...

  9. SpringMVC异常处理方式

    一.描述 在J2EE项目的开发中,不管是对底层的数据库操作过程,还是业务层的处理过程,还是控制层的处理过程,都不可避免会遇到各种可预知的.不可预知的异常需要处理.每个过程都单独处理异常,系统的代码耦合 ...

  10. linux中断源码分析 - 概述(一)

    本文为原创,转载请注明:http://www.cnblogs.com/tolimit/ 关于中断和异常 一般在书中都会把中断和异常一起说明,因为它们具有相同的特点,同时也有不同的地方.在CPU里,中断 ...