应项目要求修改网络问题，为了让项目更加健壮，使用Volley框架，这个android 推荐使用的网络框架，整体来说请求的方式网上都可以查的到，这里就不说，现在就说说添加头部验证，因为我们的项目在请求每一个链接的时候都会验证，所以添加头部是一个十分必要的情况。网上说让在请求里边添加getHeaders（）方法，方法是确实能用，但是是有前提的。

主要是使用不同的队列的问题：

    (1)Volley.newRequestQueue(this）

        如果是调用这个方法的话，那么在执行StringRequest方法的时候调用的HttpClientStack  这个类中的访问网络的方法：

/*

 * Copyright (C) 2011 The Android Open Source Project  *  * Licensed under the Apache License, Version 2.0 (the "License");  * you may not use this file except in compliance with the License.  * You may obtain a copy of the License at  *  *      http://www.apache.org/licenses/LICENSE-2.0  *  * Unless required by applicable law or agreed to in writing, software  * distributed under the License is distributed on an "AS IS" BASIS,  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  * See the License for the specific language governing permissions and  * limitations under the License.  */ package com.android.volley.toolbox; import com.android.volley.AuthFailureError; import com.android.volley.Request; import com.android.volley.Request.Method; import org.apache.http.HttpEntity; import org.apache.http.HttpResponse; import org.apache.http.NameValuePair; import org.apache.http.client.HttpClient; import org.apache.http.client.methods.HttpDelete; import org.apache.http.client.methods.HttpEntityEnclosingRequestBase; import org.apache.http.client.methods.HttpGet; import org.apache.http.client.methods.HttpPost; import org.apache.http.client.methods.HttpPut; import org.apache.http.client.methods.HttpUriRequest; import org.apache.http.entity.ByteArrayEntity; import org.apache.http.message.BasicNameValuePair; import org.apache.http.params.HttpConnectionParams; import org.apache.http.params.HttpParams; import java.io.IOException; import java.util.ArrayList; import java.util.List; import java.util.Map; /**  * An HttpStack that performs request over an {@link HttpClient}.  */ public class HttpClientStack implements HttpStack {     protected final HttpClient mClient;     private final static String HEADER_CONTENT_TYPE = "Content-Type";     public HttpClientStack(HttpClient client) {         mClient = client;     }     private static void addHeaders(HttpUriRequest httpRequest, Map<String, String> headers) {         for (String key : headers.keySet()) {             httpRequest.setHeader(key, headers.get(key));         }     }     @SuppressWarnings("unused")     private static List<NameValuePair> getPostParameterPairs(Map<String, String> postParams) {         List<NameValuePair> result = new ArrayList<NameValuePair>(postParams.size());         for (String key : postParams.keySet()) {             result.add(new BasicNameValuePair(key, postParams.get(key)));         }         return result;     }     @Override     public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)             throws IOException, AuthFailureError {         HttpUriRequest httpRequest = createHttpRequest(request, additionalHeaders);         addHeaders(httpRequest, additionalHeaders);         addHeaders(httpRequest, request.getHeaders());         onPrepareRequest(httpRequest);         HttpParams httpParams = httpRequest.getParams();         int timeoutMs = request.getTimeoutMs();         // TODO: Reevaluate this connection timeout based on more wide-scale         // data collection and possibly different for wifi vs. 3G.         HttpConnectionParams.setConnectionTimeout(httpParams, 5000);         HttpConnectionParams.setSoTimeout(httpParams, timeoutMs);         return mClient.execute(httpRequest);     }     /**      * Creates the appropriate subclass of HttpUriRequest for passed in request.      */     @SuppressWarnings("deprecation")     /* protected */ static HttpUriRequest createHttpRequest(Request<?> request,             Map<String, String> additionalHeaders) throws AuthFailureError {         switch (request.getMethod()) {             case Method.DEPRECATED_GET_OR_POST: {                 // This is the deprecated way that needs to be handled for backwards compatibility.                 // If the request's post body is null, then the assumption is that the request is                 // GET.  Otherwise, it is assumed that the request is a POST.                 byte[] postBody = request.getPostBody();                 if (postBody != null) {                     HttpPost postRequest = new HttpPost(request.getUrl());                     postRequest.addHeader(HEADER_CONTENT_TYPE, request.getPostBodyContentType());                     postRequest.setHeader("Authorization","Basic YW5vbnltb3VzOjEyMzQ1Ng==");                     HttpEntity entity;                     entity = new ByteArrayEntity(postBody);                     postRequest.setEntity(entity);                     return postRequest;                 } else {                     return new HttpGet(request.getUrl());                 }             }             case Method.GET:             HttpGet  httpGet  =new HttpGet(request.getUrl()); //             httpGet.setHeader("Authorization","Basic YW5vbnltb3VzOjEyMzQ1Ng==");                 return httpGet;             case Method.DELETE:             HttpDelete  httpDelete =new HttpDelete(request.getUrl());                 return new HttpDelete(request.getUrl());             case Method.POST: {                 HttpPost postRequest = new HttpPost(request.getUrl());                 postRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());                 setEntityIfNonEmptyBody(postRequest, request);                 return postRequest;             }             case Method.PUT: {                 HttpPut putRequest = new HttpPut(request.getUrl());                 putRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());                 setEntityIfNonEmptyBody(putRequest, request);                 return putRequest;             }             default:                 throw new IllegalStateException("Unknown request method.");         }     }     private static void setEntityIfNonEmptyBody(HttpEntityEnclosingRequestBase httpRequest,             Request<?> request) throws AuthFailureError {         byte[] body = request.getBody();         if (body != null) {             HttpEntity entity = new ByteArrayEntity(body);             httpRequest.setEntity(entity);         }     }     /**      * Called before the request is executed using the underlying HttpClient.      *      * <p>Overwrite in subclasses to augment the request.</p>      */     protected void onPrepareRequest(HttpUriRequest request) throws IOException {         // Nothing.     } }

可以看到，这个里边是使用了HttpClient    来进行访问网络，但是再他设置访问方式的时候没有调用getHeaders这个方法

@Override

public Map<String, String> getHeaders() throws AuthFailureError { Map<String, String> headers = new HashMap<String, String>(); // headers.put("Charset", "UTF-8"); // headers.put("Content-Type", "application/x-javascript"); // headers.put("Accept-Encoding", "gzip,deflate");headers.put("Authorization", "Basic YW5vbnltb3VzOjEyMzQ1Ng==");return headers;} //设置超时public RetryPolicy getRetryPolicy() { RetryPolicy retryPolicy = new DefaultRetryPolicy(1000,DefaultRetryPolicy.DEFAULT_MAX_RETRIES,DefaultRetryPolicy.DEFAULT_BACKOFF_MULT);return retryPolicy;}

     也就不会添加你设置的头部，那么访问肯定通不过。

所以你可以再里边给添加你的头部，或是，在里边调用getHeaders方法，把头部添加到相应的请求里。

（2） Volley.newRequestQueue(this,new HurlStack())

       这个创建的队列他在执行的时候调用的是HttpUrlConnition   这种访问网络的方式，

/*  * Copyright (C) 2011 The Android Open Source Project  *  * Licensed under the Apache License, Version 2.0 (the "License");  * you may not use this file except in compliance with the License.  * You may obtain a copy of the License at  *  *      http://www.apache.org/licenses/LICENSE-2.0  *  * Unless required by applicable law or agreed to in writing, software  * distributed under the License is distributed on an "AS IS" BASIS,  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  * See the License for the specific language governing permissions and  * limitations under the License.  */ package com.android.volley.toolbox; import com.android.volley.AuthFailureError; import com.android.volley.Request; import com.android.volley.Request.Method; import org.apache.http.Header; import org.apache.http.HttpEntity; import org.apache.http.HttpResponse; import org.apache.http.ProtocolVersion; import org.apache.http.StatusLine; import org.apache.http.entity.BasicHttpEntity; import org.apache.http.message.BasicHeader; import org.apache.http.message.BasicHttpResponse; import org.apache.http.message.BasicStatusLine; import java.io.DataOutputStream; import java.io.IOException; import java.io.InputStream; import java.net.HttpURLConnection; import java.net.URL; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Map.Entry; import javax.net.ssl.HttpsURLConnection; import javax.net.ssl.SSLSocketFactory; /**  * An {@link HttpStack} based on {@link HttpURLConnection}.  */ public class HurlStack implements HttpStack {     private static final String HEADER_CONTENT_TYPE = "Content-Type";     /**      * An interface for transforming URLs before use.      */     public interface UrlRewriter {         /**          * Returns a URL to use instead of the provided one, or null to indicate          * this URL should not be used at all.          */         public String rewriteUrl(String originalUrl);     }     private final UrlRewriter mUrlRewriter;     private final SSLSocketFactory mSslSocketFactory;     public HurlStack() {         this(null);     }     /**      * @param urlRewriter Rewriter to use for request URLs      */     public HurlStack(UrlRewriter urlRewriter) {         this(urlRewriter, null);     }     /**      * @param urlRewriter Rewriter to use for request URLs      * @param sslSocketFactory SSL factory to use for HTTPS connections      */     public HurlStack(UrlRewriter urlRewriter, SSLSocketFactory sslSocketFactory) {         mUrlRewriter = urlRewriter;         mSslSocketFactory = sslSocketFactory;     }     @Override     public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)             throws IOException, AuthFailureError {         String url = request.getUrl();         HashMap<String, String> map = new HashMap<String, String>();         map.putAll(request.getHeaders());         map.putAll(additionalHeaders);         if (mUrlRewriter != null) {             String rewritten = mUrlRewriter.rewriteUrl(url);             if (rewritten == null) {                 throw new IOException("URL blocked by rewriter: " + url);             }             url = rewritten;         }         URL parsedUrl = new URL(url);         HttpURLConnection connection = openConnection(parsedUrl, request);         for (String headerName : map.keySet()) {             connection.addRequestProperty(headerName, map.get(headerName));         }         setConnectionParametersForRequest(connection, request);         // Initialize HttpResponse with data from the HttpURLConnection.         ProtocolVersion protocolVersion = new ProtocolVersion("HTTP", 1, 1);         int responseCode = connection.getResponseCode();         if (responseCode == -1) {             // -1 is returned by getResponseCode() if the response code could not be retrieved.             // Signal to the caller that something was wrong with the connection.             throw new IOException("Could not retrieve response code from HttpUrlConnection.");         }         StatusLine responseStatus = new BasicStatusLine(protocolVersion,                 connection.getResponseCode(), connection.getResponseMessage());         BasicHttpResponse response = new BasicHttpResponse(responseStatus);         response.setEntity(entityFromConnection(connection));         for (Entry<String, List<String>> header : connection.getHeaderFields().entrySet()) {             if (header.getKey() != null) {                 Header h = new BasicHeader(header.getKey(), header.getValue().get(0));                 response.addHeader(h);             }         }         return response;     }     /**      * Initializes an {@link HttpEntity} from the given {@link HttpURLConnection}.      * @param connection      * @return an HttpEntity populated with data from <code>connection</code>.      */     private static HttpEntity entityFromConnection(HttpURLConnection connection) {         BasicHttpEntity entity = new BasicHttpEntity();         InputStream inputStream;         try {             inputStream = connection.getInputStream();         } catch (IOException ioe) {             inputStream = connection.getErrorStream();         }         entity.setContent(inputStream);         entity.setContentLength(connection.getContentLength());         entity.setContentEncoding(connection.getContentEncoding());         entity.setContentType(connection.getContentType());         return entity;     }     /**      * Create an {@link HttpURLConnection} for the specified {@code url}.      */     protected HttpURLConnection createConnection(URL url) throws IOException {         return (HttpURLConnection) url.openConnection();     }     /**      * Opens an {@link HttpURLConnection} with parameters.      * @param url      * @return an open connection      * @throws IOException      */     private HttpURLConnection openConnection(URL url, Request<?> request) throws IOException {         HttpURLConnection connection = createConnection(url);         int timeoutMs = request.getTimeoutMs();         connection.setConnectTimeout(timeoutMs);         connection.setReadTimeout(timeoutMs);         connection.setUseCaches(false);         connection.setDoInput(true);         // use caller-provided custom SslSocketFactory, if any, for HTTPS         if ("https".equals(url.getProtocol()) && mSslSocketFactory != null) {             ((HttpsURLConnection)connection).setSSLSocketFactory(mSslSocketFactory);         }         return connection;     }     @SuppressWarnings("deprecation")     /* package */ static void setConnectionParametersForRequest(HttpURLConnection connection,             Request<?> request) throws IOException, AuthFailureError {         switch (request.getMethod()) {             case Method.DEPRECATED_GET_OR_POST:                 // This is the deprecated way that needs to be handled for backwards compatibility.                 // If the request's post body is null, then the assumption is that the request is                 // GET.  Otherwise, it is assumed that the request is a POST.                 byte[] postBody = request.getPostBody();                 if (postBody != null) {                     // Prepare output. There is no need to set Content-Length explicitly,                     // since this is handled by HttpURLConnection using the size of the prepared                     // output stream.                     connection.setDoOutput(true);                     connection.setRequestMethod("POST");                     connection.addRequestProperty(HEADER_CONTENT_TYPE,                             request.getPostBodyContentType());                     DataOutputStream out = new DataOutputStream(connection.getOutputStream());                     out.write(postBody);                     out.close();                 }                 break;             case Method.GET:                 // Not necessary to set the request method because connection defaults to GET but                 // being explicit here.                 connection.setRequestMethod("GET");                 break;             case Method.DELETE:                 connection.setRequestMethod("DELETE");                 break;             case Method.POST:                 connection.setRequestMethod("POST");                 addBodyIfExists(connection, request);                 break;             case Method.PUT:                 connection.setRequestMethod("PUT");                 addBodyIfExists(connection, request);                 break;             default:                 throw new IllegalStateException("Unknown method type.");         }     }     private static void addBodyIfExists(HttpURLConnection connection, Request<?> request)             throws IOException, AuthFailureError {         byte[] body = request.getBody();         if (body != null) {             connection.setDoOutput(true);             connection.addRequestProperty(HEADER_CONTENT_TYPE, request.getBodyContentType());             DataOutputStream out = new DataOutputStream(connection.getOutputStream());             out.write(body);             out.close();         }     } }

从这个代码中可以看到，

 

         可以看到这里边他调用了getHeaders这个方法，会给你添加相应的头部，所以，也可以使用这个。