我的工作是从一个网站下载server.It数据的应用程序似乎是下载数据，而无需在开始任何问​​题，但数天前，我开始接收这种异常： javax.net.ssl​​.SSLException：读取错误：SSL = 0x7a6588：系统调用过程中的I / O错误，被连接重置，我不知道是什么原因这一问题，我怎么能解决这个问题。这里是整个 LogCat中消息：

I'm working on an application which is downloading data from a web server.It seems to download data without any problems in the beginning, but a few days ago I start receiving this kind of exceptions : javax.net.ssl.SSLException: Read error: ssl=0x7a6588: I/O error during system call, Connection reset by peer and I'm not sure what cause that problem and how can I fix that. Here is the whole LogCat message :

12-12 11:43:27.950: W/System.err(22010): javax.net.ssl.SSLException: Read error: ssl=0x7a6588: I/O error during system call, Connection reset by peer
12-12 11:43:27.960: W/System.err(22010):    at org.apache.harmony.xnet.provider.jsse.NativeCrypto.SSL_read(Native Method)
12-12 11:43:27.960: W/System.err(22010):    at org.apache.harmony.xnet.provider.jsse.OpenSSLSocketImpl$SSLInputStream.read(OpenSSLSocketImpl.java:788)
12-12 11:43:27.960: W/System.err(22010):    at org.apache.harmony.luni.internal.net.www.protocol.http.ChunkedInputStream.read(ChunkedInputStream.java:50)
12-12 11:43:27.960: W/System.err(22010):    at java.io.InputStream.read(InputStream.java:157)
12-12 11:43:27.960: W/System.err(22010):    at java.util.zip.InflaterInputStream.fill(InflaterInputStream.java:225)
12-12 11:43:27.960: W/System.err(22010):    at java.util.zip.InflaterInputStream.read(InflaterInputStream.java:178)
12-12 11:43:27.960: W/System.err(22010):    at java.util.zip.GZIPInputStream.read(GZIPInputStream.java:174)
12-12 11:43:27.960: W/System.err(22010):    at java.io.BufferedInputStream.read(BufferedInputStream.java:319)
12-12 11:43:27.970: W/System.err(22010):    at java.io.FilterInputStream.read(FilterInputStream.java:133)
12-12 11:43:27.970: W/System.err(22010):    at com.stampii.stampii.synchronization.Synchronization.UseHttpsConnection(Synchronization.java:1367)
12-12 11:43:27.970: W/System.err(22010):    at com.stampii.stampii.synchronization.Synchronization$ActivateCollection.doInBackground(Synchronization.java:613)
12-12 11:43:27.970: W/System.err(22010):    at com.stampii.stampii.synchronization.Synchronization$ActivateCollection.doInBackground(Synchronization.java:1)
12-12 11:43:27.970: W/System.err(22010):    at android.os.AsyncTask$2.call(AsyncTask.java:185)
12-12 11:43:27.970: W/System.err(22010):    at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:306)
12-12 11:43:27.970: W/System.err(22010):    at java.util.concurrent.FutureTask.run(FutureTask.java:138)
12-12 11:43:27.970: W/System.err(22010):    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1088)
12-12 11:43:27.970: W/System.err(22010):    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:581)
12-12 11:43:27.970: W/System.err(22010):    at java.lang.Thread.run(Thread.java:1027)

这就是我得到了我的 UseHttpsConnection 方法：

This is what I got on my UseHttpsConnection method :

    public void UseHttpsConnection(String url, String charset, String query) {

    try {
        final TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
            @Override
            public void checkClientTrusted( final X509Certificate[] chain, final String authType ) {
            }
            @Override
            public void checkServerTrusted( final X509Certificate[] chain, final String authType ) {
            }
            @Override
            public X509Certificate[] getAcceptedIssuers() {
                return null;
            }
        } };

        // Install the all-trusting trust manager
        final SSLContext sslContext = SSLContext.getInstance( "TLS" );
        sslContext.init( null, trustAllCerts, new java.security.SecureRandom() );
        // Create an ssl socket factory with our all-trusting manager
        final SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();

        if (url.startsWith("https://")) {
            HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier(){
                public boolean verify(String hostname, SSLSession session) {
                    return true;
                }});
        }

        System.setProperty("http.keepAlive", "false");
        HttpsURLConnection connection = (HttpsURLConnection) new URL(url).openConnection();
        connection.setSSLSocketFactory( sslSocketFactory );
        connection.setDoOutput(true);
        connection.setConnectTimeout(15000 /* milliseconds */ );
        connection.setRequestMethod("POST");
        connection.setRequestProperty("Charset", charset);
        connection.setRequestProperty("Content-Type","application/x-www-form-urlencoded;charset=" + charset);
        OutputStream output = null;
        try {
            output = connection.getOutputStream();
            output.write(query.getBytes(charset));
        } catch (IOException e) {
            e.printStackTrace();
            showError2("Check your network settings!");

        } finally {
            if (output != null)
                try {
                    output.close();
                } catch (IOException logOrIgnore) {
                    logOrIgnore.printStackTrace();
                }
        }

        int status = ((HttpsURLConnection) connection).getResponseCode();
        Log.d("", "Status : " + status);

        for (Entry<String, List<String>> header : connection
                .getHeaderFields().entrySet()) {
            Log.d("Headers","Headers : " + header.getKey() + "="+ header.getValue());
        }

        InputStream response = new BufferedInputStream(connection.getInputStream());

        int bytesRead = -1;
        byte[] buffer = new byte[30 * 1024];
        while ((bytesRead = response.read(buffer)) > 0) {
            byte[] buffer2 = new byte[bytesRead];
            System.arraycopy(buffer, 0, buffer2, 0, bytesRead);
            handleDataFromSync(buffer2);
        }
        connection.disconnect();
    } catch (IOException e) {
        e.printStackTrace();
        showError2("Synchronization failed!Please try again.");

    } catch (KeyManagementException e) {
        e.printStackTrace();
        showError2("Error occured.Please try again.");

    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
        showError2("Error occured.Please try again.");
    }
}

和这里是我的AsyncTask我正在使用的连接和下载数据：

And here is my AsyncTask which I'm using to connect and download the data :

    public class DeactivateCollection extends AsyncTask <Context, Integer, Void> {
    @Override
    protected Void doInBackground(Context... arrContext) {
        try {
            String charset = "UTF-8";
            hash = getAuthHash();
            SharedPreferences lastUser = PreferenceManager
                    .getDefaultSharedPreferences(Synchronization.this);
            int userId = lastUser.getInt("lastUser", 1);

            systemDbHelper = new SystemDatabaseHelper(Synchronization.this, null, 1);
            systemDbHelper.initialize(Synchronization.this);
            String sql = "SELECT dbTimestamp FROM users WHERE objectId=" + userId;
            Cursor cursor = systemDbHelper.executeSQLQuery(sql);
            if (cursor.getCount() < 0) {
                cursor.close();
            } else if (cursor.getCount() > 0) {
                cursor.moveToFirst();
                timeStamp = cursor.getString(cursor.getColumnIndex("dbTimestamp"));
                Log.d("", "timeStamp : " + timeStamp);
            }

            String query = String.format("debug_data=%s&"
                    + "client_auth_hash=%s&" + "timestamp=%s&"
                    + "deactivate_collections=%s&" + "client_api_ver=%s&"
                    + "set_locale=%s&" + "device_os_type=%s&"
                    + "device_sync_type=%s&"
                    + "device_identification_string=%s&"
                    + "device_identificator=%s&" + "device_resolution=%s",
                    URLEncoder.encode("1", charset),
                    URLEncoder.encode(hash, charset),
                    URLEncoder.encode(timeStamp, charset),
                    URLEncoder.encode(Integer.toString(deac), charset),
                    URLEncoder.encode(clientApiVersion, charset),
                    URLEncoder.encode(locale, charset),
                    URLEncoder.encode(version, charset),
                    URLEncoder.encode("14", charset),
                    URLEncoder.encode(version, charset),
                    URLEncoder.encode(deviceId, charset),
                    URLEncoder.encode(resolution, charset));

            Log.e("","hash : "+hash);
            Log.e("","deactivate : "+Integer.toString(deac));

            SharedPreferences useSSLConnection = PreferenceManager.getDefaultSharedPreferences(Synchronization.this);
            boolean useSSl = useSSLConnection.getBoolean("UseSSl", true);
            if (useSSl) {
                UseHttpsConnection(url, charset, query);
            } else {
                UseHttpConnection(url, charset, query);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    protected void onProgressUpdate(Integer... progress) {
        Log.d("","ON PROGRESS UPDATE");

    }
    @Override
    protected void onCancelled() {
        Log.d("","ON CANCELLED");

    } 
    @Override
    protected void onPreExecute() 
    {
        Log.d("","ON PRE EXECUTE");
    }
    @Override
    protected void onPostExecute(Void v) {
        Log.d("","ON POST EXECUTE");

    }
  }

因此，任何人有一个想法如何处理异常，所以我可以下载整个数据没有任何异常。或者，我怎么能解决这个问题，如果这是不可能的。

在此先感谢！

推荐答案

其实有两个选择，你可以在这种情况下做的。 您可以同时下载数据通过网络捕获该异常，并创建一个函数，它会从那里再次停止启动连接。所以，你必须找到一种方法来保存进度，同时下载数据，因为如果你下载的数据的大尺寸的它不是重新开始的过程是一个好主意。

Actually there are two options that you can do in this situation. You can catch that exception while downloading data over internet and create a function which will start the connection again from where it stops. So you have to find a way to save your progress while downloading the data,because if you're downloading big size of data it's not a good idea to start the process again.

这是你可以做的另一件事是建立一个对​​话框，将通知用户有同时同步的错误，让他选择，如果他想试操作或取消它。如果用户选择重试的选择，我认为这将是一个更好的选择，从那里再次停止重新开始连接。所以，你必须保存进度两种方式。我认为这是更加人性化。

Another thing that you can do is to create a dialog, which will inform the user that there is error while synchronizing and let him to choose if he want to retry the operation or cancel it.If user select Retry option I think it will be a better option to start the connection again from the where it stops again. So you have to save your progress in both ways. I think that's more user friendly.