Android学习过程（52）
&&&&& Http个人理解为是基于请求、响应，无状态，应用层的超文本传输协议。其特点有：支持客户端与服务器之间交互模式；简单快捷；灵活；无连接；无状态。
&&&&& 引用具体介绍：（想要更深入的了解可以参考下面的网站：）
&&&&& Http介绍：HTTP是一个属于应用层的面向对象的协议，由于其简捷、快速的方式，适用于分布式超媒体信息系统。它于1990年提出，经过几年的使用与发展，得到不断地完善和扩展。目前在WWW中使用的是HTTP/1.0的第六版，HTTP/1.1的规范化工作正在进行之中，而且HTTP-NG(Next Generation of HTTP)的建议已经提出。
HTTP协议的主要特点可概括如下：
&&&&&&&&&&& 1.支持客户/服务器模式。
&&&&&&&&&&&&2.简单快速：客户向服务器请求服务时，只需传送请求方法和路径。请求方法常用的有GET、HEAD、POST。每种方法规定了客户与服务器联系的类型不同。由于HTTP协议简单，使得HTTP服务器的程序规模小，因而通信速度很快。
&&&&&&&&&&& 3.灵活：HTTP允许传输任意类型的数据对象。正在传输的类型由Content-Type加以标记。
&&&&&&&&&&& 4.无连接：无连接的含义是限制每次连接只处理一个请求。服务器处理完客户的请求，并收到客户的应答后，即断开连接。采用这种方式可以节省传输时间。
&&&&&&&&&&& 5.无状态：HTTP协议是无状态协议。无状态是指协议对于事务处理没有记忆能力。缺少状态意味着如果后续处理需要前面的信息，则它必须重传，这样可能导致每次连接传送的数据量增大。另一方面，在服务器不需要先前信息时它的应答就较快。
&&&&&& 在使用网络连接前我们要在AndroidManifest.xml中注册相应的权限，将其放在application和manifest之间，也就是说和application是并列的权限，其代码如下所示：
&span style=&font-size:18&&&uses-permission android:name=&android.permission.INTERNET& /&
&uses-permission android:name=&android.permission.ACCESS_NETWORK_STATE& /&
&&&&&&&& 在实际连网之前要先检查当前的网络环境是否可用，其代码如下所示：
&span style=&font-size:18&&ConnectivityManager connMgr = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo networkInfo = connMgr.getActiveNetworkInfo();
if (networkInfo != null && networkInfo.isConnected()) {
//网络连接可用
//网络连接不可用!
&&&&&&& 网络操作会遇到不可预期的延迟。显然为了避免一个不好的用户体验，总是在UI Thread之外去执行网络操作。AsyncTask 类提供了一种简单的方式来处理这个问题
doInBackground()) 执行 downloadUrl()方法。Web URL作为参数，方法downloadUrl() 获取并处理网页返回的数据，执行完毕后，传递结果到onPostExecute()。参数类型为String.onPostExecute()) 获取到返回数据并显示到UI上。其相关代码如下所示：
&span style=&font-size:18&&private class DownloadWebpageText extends AsyncTask&String, Void, String& {
protected String doInBackground(String... urls) {
// 参数从execute()方法传入, params[0]表示url.
//获取url资源数据并返回
// onPostExecute方法中处理AsyncTask返回的结果
protected void onPostExecute(String result) {
&&&&&& 下面为实例的代码，在xml布局中只放置了两个Button分别用于不同的连接获取方式和一个TextView用于显示获取到的内容，此处获取到的图片资源暂时没有解析显示，其具体的代码如下所示：
&span style=&font-size:18&&package com.sc.android.
* 由于此处没有学习图片的解析，所以图片的内容没有显示出来
import java.io.BufferedR
import java.io.BufferedW
import java.io.IOE
import java.io.InputS
import java.io.InputStreamR
import java.io.OutputS
import java.net.HttpURLC
import java.net.URL;
import org.apache.http.HttpR
import org.apache.http.client.ClientProtocolE
import org.apache.http.client.HttpC
import org.apache.http.client.methods.HttpG
import org.apache.http.impl.client.DefaultHttpC
import android.app.A
import android.os.AsyncT
import android.os.B
import android.view.V
import android.view.View.OnClickL
import android.webkit.WebV
import android.widget.B
import com.sc.android.R;
import com.sc.android.util.L
public class HttpActivity extends Activity {
private Button mHttpContentBtn, mHttpUrlB
private WebView mHttpWebV//用于显示读取到的Url连接内容
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_http_layout);
mHttpContentBtn = (Button) findViewById(R.id.http_client_btn);
mHttpUrlBtn = (Button) findViewById(R.id.http_url_btn);
mHttpWebView = (WebView) findViewById(R.id.http_webview);
mHttpContentBtn.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
//htmlUrl是Tomcat服务器中自己写的html布局信息
String htmlUrl = &http://192.168.1.153:8080/html/login.html&;
new AsyncTask&String, Void, String&() {
protected String doInBackground(String... params) {
String url = params[0];
return getHttpClient(url);
protected void onPostExecute(String result) {
if (result != null) {
Logs.v(&服务端返回的信息是
:& + result);
mHttpWebView.loadData(result,
&text/ charset=UTF-8&, null);
}.execute(htmlUrl);
mHttpUrlBtn.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
String htmlUrl = &&;
new AsyncTask&String, Void, String&() {
protected String doInBackground(String... params) {
String url = params[0];
return getDataByHttpUrlConnection(url);
protected void onPostExecute(String result) {
if (result != null) {
Logs.v(&服务端返回的信息是
:& + result);
mHttpWebView.loadData(result,
&text/ charset=UTF-8&, null);
}.execute(htmlUrl);
public String getHttpClient(String httpUrl) {
HttpClient httpClient = new DefaultHttpClient();
HttpGet httpGet = new HttpGet(httpUrl);
HttpResponse response = httpClient.execute(httpGet);
int statusCode = response.getStatusLine().getStatusCode();
//HttpURLConnection.HTTP_OK即200响应码
if (statusCode == HttpURLConnection.HTTP_OK) {
InputStream ins = response.getEntity().getContent();
//将读取到的信息转换成utf-8编码
BufferedReader br = new BufferedReader(new InputStreamReader(
ins, &utf-8&));
StringBuilder sb = new StringBuilder();
String line =
while ((line = br.readLine()) != null) {
sb.append(line);
return sb.toString();
} catch (ClientProtocolException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
* 从网络获取数据通过HttpURLConnection方式实现 Get
private String getDataByHttpUrlConnection(String url1) {
StringBuffer sb =
InputStream is =
BufferedReader br =
HttpURLConnection conn =
OutputStream os =
BufferedWriter bw =
// 封装访问服务器的地址
URL url = new URL(url1);
// 打开对服务器的连接
conn = (HttpURLConnection) url.openConnection();
// 设置输入输出流
// conn.setDoOutput(true);
conn.setDoInput(true);
conn.setRequestMethod(&GET&);
// 连接服务器
conn.connect();
/** 读入服务器数据的过程 **/
// 得到输入流
is = conn.getInputStream();
// 创建包装流
br = new BufferedReader(new InputStreamReader(is, &utf-8&));
// 定义String类型用于储存单行数据
String line =
// 创建StringBuffer对象用于存储所有数据
sb = new StringBuffer();
while ((line = br.readLine()) != null) {
sb.append(line);
} catch (IOException e) {
e.printStackTrace();
} finally {
conn.disconnect();
if (bw != null) {
bw.close();
if (os != null) {
os.close();
if (br != null) {
br.close();
if (is != null) {
is.close();
} catch (IOException e) {
e.printStackTrace();
return sb.toString();
&&&&&& 其效果显示如下：
&&& 用getHttpClient方式获取网络资源是有可能会解析出错或解析不出来的情况。由于刚接触，有错的地方请见谅。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：20977次
排名：千里之外
原创：63篇
转载：23篇
(1)(1)(1)(4)(3)(3)(5)(3)(2)(3)(5)(23)(22)(8)(1)android（78）
文章转载：
网址：http://blog.csdn.net/anye_anye/article/details/
Android 中判断网络连接是否可用
一、判断网络连接是否可用
public static boolean isNetworkAvailable(Context context) {
ConnectivityManager cm = (ConnectivityManager) context
.getSystemService(Context.CONNECTIVITY_SERVICE);
if (cm == null) {
　　　　　　　//如果仅仅是用来判断网络连接
　　　　　　
//则可以使用 cm.getActiveNetworkInfo().isAvailable();
NetworkInfo[] info = cm.getAllNetworkInfo();
if (info != null) {
for (int i = 0; i & info. i++) {
if (info[i].getState() == NetworkInfo.State.CONNECTED) {
二、判断GPS是否打开
public static boolean isGpsEnabled(Context context) {
LocationManager lm = ((LocationManager) context
.getSystemService(Context.LOCATION_SERVICE));
List&String& accessibleProviders = lm.getProviders(true);
return accessibleProviders != null && accessibleProviders.size() & 0;
三、判断WIFI是否打开
public static boolean isWifiEnabled(Context context) {
ConnectivityManager mgrConn = (ConnectivityManager) context
.getSystemService(Context.CONNECTIVITY_SERVICE);
TelephonyManager mgrTel = (TelephonyManager) context
.getSystemService(Context.TELEPHONY_SERVICE);
return ((mgrConn.getActiveNetworkInfo() != null && mgrConn
.getActiveNetworkInfo().getState() == NetworkInfo.State.CONNECTED) || mgrTel
.getNetworkType() == TelephonyManager.NETWORK_TYPE_UMTS);
四、判断是否是3G网络
public static boolean is3rd(Context context) {
ConnectivityManager cm = (ConnectivityManager) context
.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo networkINfo = cm.getActiveNetworkInfo();
if (networkINfo != null
&& networkINfo.getType() == ConnectivityManager.TYPE_MOBILE) {
五、判断是wifi还是3g网络,用户的体现性在这里了，wifi就可以建议下载或者在线播放。
public static boolean isWifi(Context context) {
ConnectivityManager cm = (ConnectivityManager) context
.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo networkINfo = cm.getActiveNetworkInfo();
if (networkINfo != null
&& networkINfo.getType() == ConnectivityManager.TYPE_WIFI) {
Android开发请求网络方式详解
　　现在就简单的介绍一下Android常用的联网方式，包括JDK支持的HttpUrlConnection，Apache支持的HttpClient，以及开源的一些联网框架（譬如AsyncHttpClient）的介绍。本篇博客只讲实现过程和方式，不讲解原理，否则原理用文字很难以讲清，其实我们知道怎么去用，就可以解决一些基本开发需要了。&
　　绝大多数的Android应用联网都是基于Http协议的，也有很少是基于Socket的，我们这里主要讲解基于Http协议的联网方式。讲解实例是建立在一个模拟的登录小模块中进行，登录请求数据仅仅只有username和password两个简单字段。
HttpUrlConnection
HttpUrlConnection是JDK里提供的联网API，我们知道Android SDK是基于Java的，所以当然优先考虑HttpUrlConnection这种最原始最基本的API，其实大多数开源的联网框架基本上也是基于JDK的HttpUrlConnection进行的封装罢了，掌握HttpUrlConnection需要以下几个步骤：
1、将访问的路径转换成URL。
URL url = new URL(path);
2、通过URL获取连接。
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
3、设置请求方式。
conn.setRequestMethod(GET);
4、设置连接超时时间。
conn.setConnectTimeout(5000);
5、设置请求头的信息。
conn.setRequestProperty(User-Agent, Mozilla/5.0 ( MSIE 9.0; Windows NT 6.1; Trident/5.0));
6、获取响应码
int code = conn.getResponseCode();
7、针对不同的响应码，做不同的操作
7.1、请求码200，表明请求成功，获取返回内容的输入流
InputStream is = conn.getInputStream();
7.2、将输入流转换成字符串信息
public class StreamTools {
* 将输入流转换成字符串
* @param is
从网络获取的输入流
public static String streamToString(InputStream is) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int len = 0;
while ((len = is.read(buffer)) != -1) {
baos.write(buffer, 0, len);
baos.close();
is.close();
byte[] byteArray = baos.toByteArray();
return new String(byteArray);
} catch (Exception e) {
Log.e(tag, e.toString());
7.3、若返回&#，则是返回网络异常，做出响应的处理。
HttpUrlConnection发送GET请求
* 通过HttpUrlConnection发送GET请求
* @param username
* @param password
public static String loginByGet(String username, String password) {
String path = http://192.168.0.107:8080/WebTest/LoginServerlet?username= + username + &password= +
URL url = new URL(path);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setConnectTimeout(5000);
conn.setRequestMethod(GET);
int code = conn.getResponseCode();
if (code == 200) {
InputStream is = conn.getInputStream(); // 字节流转换成字符串
return StreamTools.streamToString(is);
return 网络访问失败;
} catch (Exception e) {
e.printStackTrace();
return 网络访问失败;
HttpUrlConnection发送POST请求
* 通过HttpUrlConnection发送POST请求
* @param username
* @param password
public static String loginByPost(String username, String password) {
String path = http://192.168.0.107:8080/WebTest/LoginS
URL url = new URL(path);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setConnectTimeout(5000);
conn.setRequestMethod(POST);
conn.setRequestProperty(Content-Type, application/x-www-form-urlencoded);
String data = username= + username + &password= +
conn.setRequestProperty(Content-Length, data.length() + );
// POST方式，其实就是浏览器把数据写给服务器
conn.setDoOutput(true); // 设置可输出流
OutputStream os = conn.getOutputStream(); // 获取输出流
os.write(data.getBytes()); // 将数据写给服务器
int code = conn.getResponseCode();
if (code == 200) {
InputStream is = conn.getInputStream();
return StreamTools.streamToString(is);
return 网络访问失败;
} catch (Exception e) {
e.printStackTrace();
return 网络访问失败;
HttpClient
　　HttpClient是开源组织Apache提供的Java请求网络框架，其最早是为了方便Java服务器开发而诞生的，是对JDK中的HttpUrlConnection各API进行了封装和简化，提高了性能并且降低了调用API的繁琐。&
　　Android因此也引进了这个联网框架，我们再不需要导入任何jar或者类库就可以直接使用，值得注意的是Android官方已经宣布不建议使用HttpClient了，我们再开发的时候尽量少用吧，但是用了也无妨！
HttpClient发送GET请求
1， 创建HttpClient对象
2，创建HttpGet对象，指定请求地址（带参数）
3，使用HttpClient的execute(),方法执行HttpGet请求，得到HttpResponse对象
4，调用HttpResponse的getStatusLine().getStatusCode()方法得到响应码
5，调用的HttpResponse的getEntity().getContent()得到输入流，获取服务端写回的数据
* 通过HttpClient发送GET请求
* @param username
* @param password
public static String loginByHttpClientGet(String username, String password) {
String path = http://192.168.0.107:8080/WebTest/LoginServerlet?username=
+ username + &password= +
HttpClient client = new DefaultHttpClient(); // 开启网络访问客户端
HttpGet httpGet = new HttpGet(path); // 包装一个GET请求
HttpResponse response = client.execute(httpGet); // 客户端执行请求
int code = response.getStatusLine().getStatusCode(); // 获取响应码
if (code == 200) {
InputStream is = response.getEntity().getContent(); // 获取实体内容
String result = StreamTools.streamToString(is); // 字节流转字符串
return 网络访问失败;
} catch (Exception e) {
e.printStackTrace();
return 网络访问失败;
HttpClient发送POST请求
1，创建HttpClient对象
2，创建HttpPost对象，指定请求地址
3，创建List，用来装载参数
4，调用HttpPost对象的setEntity()方法，装入一个UrlEncodedFormEntity对象，携带之前封装好的参数
5，使用HttpClient的execute()方法执行HttpPost请求，得到HttpResponse对象
6， 调用HttpResponse的getStatusLine().getStatusCode()方法得到响应码
7， 调用的HttpResponse的getEntity().getContent()得到输入流，获取服务端写回的数据
* 通过HttpClient发送POST请求
* @param username
* @param password
public static String loginByHttpClientPOST(String username, String password) {
String path = http://192.168.0.107:8080/WebTest/LoginS
HttpClient client = new DefaultHttpClient(); // 建立一个客户端
HttpPost httpPost = new HttpPost(path); // 包装POST请求
// 设置发送的实体参数
List&namevaluepair& parameters = new ArrayList&namevaluepair&();
parameters.add(new BasicNameValuePair(username, username));
parameters.add(new BasicNameValuePair(password, password));
httpPost.setEntity(new UrlEncodedFormEntity(parameters, UTF-8));
HttpResponse response = client.execute(httpPost); // 执行POST请求
int code = response.getStatusLine().getStatusCode();
if (code == 200) {
InputStream is = response.getEntity().getContent();
String result = StreamTools.streamToString(is);
return 网络访问失败;
} catch (Exception e) {
e.printStackTrace();
return 访问网络失败;
开源联网框架
1、AsyncHttpClient
除了上述Android官方推荐的联网框架以外，在开源世界里关于联网框架真是太多太多了，例如afinal，xutils等等，都是一些开源大牛自己封装的联网框架，并且在GitHub开源社区中可以下载到，其实类似的开源联网框架基本上也是基于HttpUrlConnection的进一步封装，大大提高了性能，同时更加简化了使用方法，这里先介绍AsyncHttpClient的一些使用方法。 AsyncHttpClient是一个非常优秀的联网框架，不仅支持所有Http请求的方式，而且还支持文件的上传和下载，要知道用HttpUrlConnection写一个文件上传和下载健全功能是很需要花费一定时间和精力的，因为请求头实在是太多了，稍有不慎就会写错。但是AsyncHttpClient已经封装好了这些“麻烦”，我们只需要下载到AsyncHttpClient的jar包或者源码导入项目中，Http，上传，下载等等，只需要几个简单的api即可搞定。
AsyncHttpClient的GitHub主页：
AsyncHttpClient发送GET请求
1，将下载好的源码拷贝到src目录下
2，创建一个AsyncHttpClient的对象
3，调用该类的get方法发送GET请求，传入请求资源地址URL，创建AsyncHttpResponseHandler对象
4，重写AsyncHttpResponseHandler下的两个方法，onSuccess和onFailure方法
* 通过AsyncHttpClient发送GET请求
public void loginByAsyncHttpGet() {
String path = http://192.168.0.107:8080/WebTest/LoginServerlet?username=zhangsan&password=123;
AsyncHttpClient client = new AsyncHttpClient();
client.get(path, new AsyncHttpResponseHandler() {
public void onFailure(int arg0, Header[] arg1, byte[] arg2,
Throwable arg3) {
// TODO Auto-generated method stub
Log.i(TAG, 请求失败： + new String(arg2));
public void onSuccess(int arg0, Header[] arg1, byte[] arg2) {
// TODO Auto-generated method stub
Log.i(TAG, 请求成功： + new String(arg2));
AsyncHttpClient发送POST请求
1，将下载好的源码拷贝到src目录下
2，创建一个AsyncHttpClient的对象
3，创建请求参数，RequestParams对象
4，调用该类的post方法发POST，传入请求资源地址URL，请求参数RequestParams，创建AsyncHttpResponseHandler对象
5，重写AsyncHttpResponseHandler下的两个方法，onSuccess和onFailure方法
* 通过AsyncHttpClient发送POST请求
public void loginByAsyncHttpPost() {
String path = http://192.168.0.107:8080/WebTest/LoginS
AsyncHttpClient client = new AsyncHttpClient();
RequestParams params = new RequestParams();
params.put(username, zhangsan);
params.put(password, 123);
client.post(path, params, new AsyncHttpResponseHandler() {
public void onFailure(int arg0, Header[] arg1, byte[] arg2,
Throwable arg3) {
// TODO Auto-generated method stub
Log.i(TAG, 请求失败： + new String(arg2));
public void onSuccess(int arg0, Header[] arg1, byte[] arg2) {
// TODO Auto-generated method stub
Log.i(TAG, 请求成功： + new String(arg2));
AsyncHttpClient上传文件
1，将下载好的源码拷贝到src目录下
2，创建一个AsyncHttpClient的对象
3，创建请求参数，RequestParams对象，请求参数仅仅包含文件对象即可，例如：
params.put(profile_picture, new File(/sdcard/pictures/pic.jpg));
4，调用该类的post方法发POST，传入请求资源地址URL，请求参数RequestParams，创建AsyncHttpResponseHandler对象
5，重写AsyncHttpResponseHandler下的两个方法，onSuccess和onFailure方法
2、Android Volley框架使用详解
　　Volley是一个由Google官方推出的网络通信库，它使得Android进行网络请求时更加方便、快速、健壮，同时对网络图片加载也提供了良好的支持。
1、获取volley源码
　　将编译得到的jar包引入到我们的项目中；可以通过网络搜索下载，也可以在此下载&
2、使用实例
　　使用Volley必须在AndroidManifest.xml中添加 android.permission.INTERNET权限，使用Volley时Google建议创建volley单例工具类
public class VolleySingleton {
private static VolleySingleton volleyS
private RequestQueue mRequestQ
private ImageLoader mImageL
private Context mC
public VolleySingleton(Context context) {
this.mContext =
mRequestQueue = getRequestQueue();
mImageLoader = new ImageLoader(mRequestQueue,
new ImageLoader.ImageCache(){
private final LruCache&String,Bitmap& cache = new LruCache&String ,Bitmap&(20);
public Bitmap getBitmap(String url){
return cache.get(url);
public void putBitmap(String url,Bitmap bitmap){
cache.put(url,bitmap);
public static synchronized VolleySingleton getVolleySingleton(Context context){
if(volleySingleton == null){
volleySingleton = new VolleySingleton(context);
return volleyS
public RequestQueue getRequestQueue(){
if(mRequestQueue == null){
mRequestQueue = Volley.newRequestQueue(mContext.getApplicationContext());
return mRequestQ
public &T& void addToRequestQueue(Request&T& req){
getRequestQueue().add(req);
public ImageLoader getImageLoader() {
return mImageL
　　首先使用 Volley.newRequestQueue获取 RequestQueue对象
RequestQueue mRequestQueue = VolleySingleton.getVolleySingleton(this.getApplicationContext()).getRequestQueue();
　　RequestQueue是请求队列对象，它可以缓存所有的HTTP网络请求，然后按照其内部算法并发的发送这些网络请求，它能够很好的支撑高并发请求，不要每个请求都创建RequestQueue对象，创建多个RequestQueue会耗费资源
　　发送StringRequest请求
StringRequest stringRequest = new StringRequest(Request.Method.GET,&&,new Listener&String&(){
public void onResponse(String s) {
//打印请求返回结果
Log.e(&volley&,s);
},new ErrorListener(){
public void onErrorResponse(VolleyError volleyError) {
Log.e(&volleyerror&,&erro2&);
//将StringRequest对象添加进RequestQueue请求队列中
VolleySingleton.getVolleySingleton(this.getApplicationContext()).addToRequestQueue(stringRequest);
　　到此已经完成了StringRequest请求。StringRequest提供了两个构造方法
public StringRequest(java.lang.String url, com.android.volley.Response.Listener&java.lang.String& listener, com.android.volley.Response.ErrorListener errorListener);
public StringRequest(int method, java.lang.String url, com.android.volley.Response.Listener&java.lang.String& listener, com.android.volley.Response.ErrorListener errorListener);
　　参数method是HTTP的请求类型，通常有GET和POST两种；参数url是请求地址；参数listener是服务器响应成功的回调，参数errorListener是服务器响应失败的回调。如果想通过POST方式请求并携带参数，遗憾的是StringRequest并没有提供带参数请求，但是当发送POST请求时，Volley会调用StringRequest的父类Request的getParams()方法来获取POST参数，所以我们只要使用StringRequest匿名类重写getParams()方法将参数传递进去就可以实现带参数的StringRequest请求。
StringRequest stringRequest = new StringRequest(Method.POST, url,
listener, errorListener) {
protected Map&String, String& getParams() throws AuthFailureError {
Map&String, String& map = new HashMap&String, String&();
map.put(&params1&, &value1&);
map.put(&params2&, &value2&);
发送JsonObjectRequest请求
JsonObjectRequest jr = new JsonObjectRequest(Request.Method.GET,url,null,new Response.Listener&JSONObject&(){
public void onResponse(JSONObject jsonObject) {
Log.e(&volley&,jsonObject.toString());
},new ErrorListener(){
public void onErrorResponse(VolleyError volleyError) {
Log.e(&volleyerror&,&erro&);
VolleySingleton.getVolleySingleton(this.getApplicationContext()).addToRequestQueue(jr);
JsonObjectRequest的构造方法参数和StringRequest一致，不在此累赘。
使用ImageRequest加载图片
ImageView mImageV
String url = &/7spzG.png&;
mImageView = (ImageView) findViewById(R.id.myImage);
ImageRequest request = new ImageRequest(url,
new Response.Listener&Bitmap&() {
public void onResponse(Bitmap bitmap) {
mImageView.setImageBitmap(bitmap);
}, 0, 0, Config.RGB_565,
new Response.ErrorListener() {
public void onErrorResponse(VolleyError error) {
mImageView.setImageResource(R.drawable.image_load_error);
VolleySingleton.getVolleySingleton(this.getApplicationContext()).addToRequestQueue(request);
ImageRequest的构造函数
public ImageRequest(java.lang.String url, com.android.volley.Response.Listener&android.graphics.Bitmap& listener, int maxWidth, int maxHeight, android.graphics.Bitmap.Config decodeConfig, com.android.volley.Response.ErrorListener errorListener) { /* compiled code */ }
　　参数url是图片地址，参数listener是请求响应成功回调，参数maxWidth是图片最大宽度，参数maxHeight是图片最大高度，如果指定的网络图片的宽度或高度大于这里的最大值，则会对图片进行压缩，指定成0的话就表示不管图片有多大，都不会进行压缩。参数decodeConfig是图片的颜色属性，其值是Bitmap.Config类的几个常量，参数errorListener是请求响应失败回调
使用 ImageLoader 加载图片
ImageLoader mImageL
ImageView mImageV
private static final String IMAGE_URL =
&/images/training/system-ui.png&;
mImageView = (ImageView) findViewById(R.id.regularImageView);
mImageLoader = VolleySingleton.getVolleySingleton(this.getApplicationContext()).getImageLoader();
//IMAGE_URL是图片网络地址
//mImageView是ImageView实例
//R.drawable.def_image默认图片id
//R.drawable.err_image加载图片错误时的图片
mImageLoader.get(IMAGE_URL, ImageLoader.getImageListener(mImageView,
R.drawable.def_image, R.drawable.err_image));
使用NetworkImageView加载图片
XML布局文件
&com.android.volley.toolbox.NetworkImageView
android:id=&@+id/networkImageView&
android:layout_width=&150dp&
android:layout_height=&170dp&
android:layout_centerHorizontal=&true& /&
ImageLoader mImageL
NetworkImageView mNetworkImageV
private static final String IMAGE_URL =
&/images/training/system-ui.png&;
mNetworkImageView = (NetworkImageView) findViewById(R.id.networkImageView);
mImageLoader = VolleySingleton.getVolleySingleton(this.getApplicationContext()).getImageLoader();
mNetworkImageView.setImageUrl(IMAGE_URL, mImageLoader);
　　我们可以调用它的setDefaultImageResId()方法、setErrorImageResId()方法和setImageUrl()方法来分别设置加载中显示的图片，加载失败时显示的图片
取消网络请求
　　Volley还提供了取消网络请求的方法并且可以联动Activity的生命周期，比如在Activity的onStop()方法中调用cance()方法取消网络请求。
public static final String TAG = &MyTag&;
StringRequest stringR // Assume this exists.
RequestQueue mRequestQ
// Assume this exists.
// Set the tag on the request.
stringRequest.setTag(TAG);
// Add the request to the RequestQueue.
mRequestQueue.add(stringRequest);
Activity的onStop()方法
protected void onStop () {
super.onStop();
if (mRequestQueue != null) {
mRequestQueue.cancelAll(TAG);
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：25099次
积分：1258
积分：1258
排名：千里之外
原创：92篇
转载：21篇
评论：15条
(1)(13)(27)(28)(41)(9)(1)