Java 截击下载给出错误：意外响应代码200

我正试图从我的服务器下载一个文件。如果我通过浏览器发出此请求，我会得到所需的文件，但当我使用volley时，我首先得到com.android.volley.TimeoutError，然后使用setRetryPolicy，我得到

BasicNetwork.performRequest: Unexpected response code 200

以下是我的课程，下载内容如下：

public class DefexConnection implements Response.Listener<byte[]>, Response.ErrorListener {
private Context ctx;
private DefexDownload download;
public DefexConnection(Context ctx){
    this.ctx = ctx;
}


public void download(String link, final HashMap<String, String> params){
    DefexDownload req = new DefexDownload(Request.Method.GET, link, DefexConnection.this, DefexConnection.this, params);
    req.setRetryPolicy(new DefaultRetryPolicy( 500000, DefaultRetryPolicy.DEFAULT_MAX_RETRIES, DefaultRetryPolicy.DEFAULT_BACKOFF_MULT));
    RequestQueue queue = Volley.newRequestQueue(this.ctx, new HurlStack(null, getSocketFactory()));
    queue.add(req);
}




private SSLSocketFactory getSocketFactory() {

    CertificateFactory cf = null;
    try {
        cf = CertificateFactory.getInstance("X.509");
        InputStream caInput = ctx.getResources().openRawResource(R.raw.comodoroca);
        Certificate ca;
        try {
            ca = cf.generateCertificate(caInput);
            Log.e("CERT", "ca=" + ((X509Certificate) ca).getSubjectDN());
        } finally {
            caInput.close();
        }


        String keyStoreType = KeyStore.getDefaultType();
        KeyStore keyStore = KeyStore.getInstance(keyStoreType);
        keyStore.load(null, null);
        keyStore.setCertificateEntry("ca", ca);


        String tmfAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
        TrustManagerFactory tmf = TrustManagerFactory.getInstance(tmfAlgorithm);
        tmf.init(keyStore);


        HostnameVerifier hostnameVerifier = new HostnameVerifier() {
            @Override
            public boolean verify(String hostname, SSLSession session) {

                Log.d("CipherUsed", session.getCipherSuite());
                return hostname.compareTo("www.defexsecurity.com")==0; 

            }
        };


        HttpsURLConnection.setDefaultHostnameVerifier(hostnameVerifier);
        SSLContext context = null;
        context = SSLContext.getInstance("TLS");

        context.init(null, tmf.getTrustManagers(), null);
        HttpsURLConnection.setDefaultSSLSocketFactory(context.getSocketFactory());

        SSLSocketFactory sf = context.getSocketFactory();


        return sf;

    } catch (CertificateException e) {
        e.printStackTrace();
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
    } catch (KeyStoreException e) {
        e.printStackTrace();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (KeyManagementException e) {
        e.printStackTrace();
    }

    return  null;
}


@Override
public void onResponse(byte[] response) {
    HashMap<String, Object> map = new HashMap<String, Object>();
    int count;
    if (response!=null) {
        String content = download.responseHeaders.get("Content-Disposition").toString();
        StringTokenizer st = new StringTokenizer(content, "=");
        String[] arrTag = st.toArray();

        String filename = arrTag[1];
        filename = filename.replace(":", ".");
        Log.d("DEBUG::RESUME FILE NAME", filename);
        try{
            long lenghtOfFile = response.length;

            //covert reponse to input stream
            InputStream input = new ByteArrayInputStream(response);
            File path = Environment.getExternalStorageDirectory();
            File file = new File(path, filename);
            map.put("resume_path", file.toString());
            BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(file));
            byte data[] = new byte[1024];

            long total = 0;

            while ((count = input.read(data)) != -1) {
                total += count;
                output.write(data, 0, count);
            }

            output.flush();

            output.close();
            input.close();
            Log.e("DEFEX","file saved to "+file.getAbsolutePath());
        }catch(IOException e){
            e.printStackTrace();

        }
    }
}

@Override
public void onErrorResponse(VolleyError error) {
    Log.e("DEFEX", "UNABLE TO DOWNLOAD FILE. ERROR:: "+error.toString());
}

public类DefexConnection实现Response.Listener，Response.ErrorListener{
私有上下文ctx；
私有DefexDownload；
公共断开连接（上下文ctx）{
this.ctx=ctx；
}
公共void下载（字符串链接，最终HashMap参数）{
DefexDownload req=新的DefexDownload（Request.Method.GET，link，DefexConnection.this，DefexConnection.this，params）；
请求setRetryPolicy（新的DefaultRetryPolicy（500000，DefaultRetryPolicy.DEFAULT\u MAX\u重试次数，DefaultRetryPolicy.DEFAULT\u回退次数））；
RequestQueue=Volley.newRequestQueue（this.ctx，new-hurstack（null，getSocketFactory（））；
队列添加（req）；
}
私有SSLSocketFactory getSocketFactory（）{
CertificateFactory cf=null；
试一试{
cf=CertificateFactory.getInstance（“X.509”）；
InputStream caInput=ctx.getResources（）.openRawResource（R.raw.comodoroca）；
证书ca；
试一试{
ca=cf.generateCertificate（caInput）；
Log.e（“CERT”、“ca=“+（（X509Certificate）ca）.getSubjectDN（））；
}最后{
caInput.close（）；
}
字符串keyStoreType=KeyStore.getDefaultType（）；
KeyStore KeyStore=KeyStore.getInstance（keyStoreType）；
load（null，null）；
密钥库设置认证尝试（“ca”，ca）；
字符串tmfAlgorithm=TrustManagerFactory.getDefaultAlgorithm（）；
TrustManagerFactory tmf=TrustManagerFactory.getInstance（tmfAlgorithm）；
tmf.init（密钥库）；
HostnameVerifier HostnameVerifier=新的HostnameVerifier（）{
@凌驾
公共布尔验证（字符串主机名、SSLSession会话）{
Log.d（“CipherUsed”，session.getCipherSuite（））；
返回hostname.compareTo（“www.defexsecurity.com”）==0；
}
};
HttpsURLConnection.setDefaultHostnameVerifier（hostnameVerifier）；
SSLContext context=null；
context=SSLContext.getInstance（“TLS”）；
context.init（null，tmf.getTrustManagers（），null）；
HttpsURLConnection.setDefaultSSLSocketFactory（context.getSocketFactory（））；
SSLSocketFactory sf=context.getSocketFactory（）；
返回sf；
}捕获（证书例外e）{
e、 printStackTrace（）；
}捕获（无算法异常）{
e、 printStackTrace（）；
}捕获（KeyStoreException e）{
e、 printStackTrace（）；
}catch（filenotfounde异常）{
e、 printStackTrace（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}捕获（密钥管理异常e）{
e、 printStackTrace（）；
}
返回null；
}
@凌驾
公共void onResponse（字节[]响应）{
HashMap=newHashMap（）；
整数计数；
if（响应！=null）{
String content=download.responseHeaders.get（“内容处置”）.toString（）；
StringTokenizer st=新的StringTokenizer（内容“=”）；
字符串[]arrTag=st.toArray（）；
字符串文件名=arrTag[1]；
filename=filename.replace（“：”，“）；
Log.d（“调试：：恢复文件名”，文件名）；
试一试{
long lenghtOfFile=响应长度；
//对输入流的隐蔽响应
InputStream输入=新的ByteArrayInputStream（响应）；
文件路径=Environment.getExternalStorageDirectory（）；
文件=新文件（路径、文件名）；
map.put（“resume_path”，file.toString（））；
BufferedOutputStream输出=新的BufferedOutputStream（新文件输出流（文件））；
字节数据[]=新字节[1024]；
长总计=0；
而（（计数=输入。读取（数据））！=-1）{
总数+=计数；
输出.写入（数据，0，计数）；
}
output.flush（）；
output.close（）；
input.close（）；
Log.e（“DEFEX”，“文件保存到”+file.getAbsolutePath（））；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
}
@凌驾
公共无效onErrorResponse（截击错误）{
Log.e（“DEFEX”，“无法下载文件。错误：：”+ERROR.toString（））；
}

}

这是我的类DefexDownload（它扩展了请求）：

class DefexDownload扩展请求{
私人最终回应。监听器；
私人地图；
公共地图负责人；
DefexDownload（int-post、字符串mUrl、Response.Listener、Response.ErrorListener-ErrorListener、HashMap参数）{
超级（post、mUrl、errorListener）；
setShouldCache（false）；
mListener=监听器；
mParams=参数；
}
@凌驾
受保护的映射getParams（）抛出com.android.volley.AuthFailureError{
返回内存；
}
@凌驾
受保护的void deliverResponse（字节[]响应）{
mListener.onResponse（response）；
}
@凌驾
受保护的响应parseNetworkResponse（NetworkResponse响应）{
//使用收到的响应标头初始化本地响应标头映射
responseHeaders=response.headers；
//将响应数据传递到此处
返回Response.success（Response.data，HttpHeaderParser.parseCacheHeaders（Response））；
}
}

我不知道这里会出什么问题，任何帮助都将不胜感激

编辑：我在这里找到的每一个其他答案似乎都是代理或设备模拟器的问题，但我在真实设备上运行我的应用程序，根据Github上的这一点，它没有使用任何代理。

。

所以

hurstack

或多或少只是一个薄薄的包装 .

EOFException

可能来自于此 当尝试建立连接时。我想不会

class DefexDownload extends Request<byte[]>{

    private final Response.Listener<byte[]> mListener;
    private Map<String, String> mParams;
    public Map<String, String> responseHeaders ;


    DefexDownload(int post, String mUrl, Response.Listener<byte[]> listener, Response.ErrorListener errorListener, HashMap<String, String> params){
        super(post, mUrl, errorListener);
        setShouldCache(false);
        mListener = listener;
        mParams=params;
    }

    @Override
    protected Map<String, String> getParams() throws com.android.volley.AuthFailureError {
        return mParams;
    }

    @Override
    protected void deliverResponse(byte[] response) {
        mListener.onResponse(response);
    }

    @Override
    protected Response<byte[]> parseNetworkResponse(NetworkResponse response) {
        //Initialise local responseHeaders map with response headers received
        responseHeaders = response.headers;

        //Pass the response data here
        return Response.success(response.data, HttpHeaderParser.parseCacheHeaders(response));
    }

}