安卓HTTPS操作工具类

最新推荐文章于 2021-05-25 15:51:20 发布
最新推荐文章于 2021-05-25 15:51:20 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： 工具类 文章标签： android HTTPS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28708411/article/details/50594485
版权 
</pre><pre name="code" class="java"><span style="font-size: 24px;">可直接拷下来使用，注意：需要更改证书资源路径</span>
<span style="font-size:24px;">帮助类1</span>
import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;


import org.apache.http.conn.ssl.SSLSocketFactory;


import com.example.kashuopos.R;


import android.content.Context;


public class TrustCertainHostNameFactory extends SSLSocketFactory {


	private static TrustCertainHostNameFactory mInstance;


	public TrustCertainHostNameFactory(KeyStore truststore) throws NoSuchAlgorithmException,
			KeyManagementException, KeyStoreException, UnrecoverableKeyException {
		super(truststore);
	}


	public static TrustCertainHostNameFactory getDefault(Context context) {
		KeyStore keystore = null;
		try {
			CertificateFactory cf = CertificateFactory.getInstance("X.509");
			InputStream in;
			in = context.getResources().openRawResource(R.raw.kashuo_server_59_53_92_173);
			Certificate ca = cf.generateCertificate(in);


			keystore = KeyStore.getInstance(KeyStore.getDefaultType());
			keystore.load(null, null);
			keystore.setCertificateEntry("ca", ca);


			if (null == mInstance) {
				mInstance = new TrustCertainHostNameFactory(keystore);
			}
		} catch (Exception e) {


		}
		return mInstance;
	}


	@Override
	public Socket createSocket() throws IOException {
		return super.createSocket();
	}


	@Override
	public Socket createSocket(Socket socket, String host, int port, boolean autoClose)
			throws IOException, UnknownHostException {
		return super.createSocket(socket, host, port, autoClose);
	}


}
</pre><pre name="code" class="java"><span style="font-size:24px;">帮助类2</span>
<pre name="code" class="java"><pre name="code" class="java">import java.io.IOException;
import java.lang.reflect.Field;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;


import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;


import org.apache.http.conn.scheme.SocketFactory;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.conn.ssl.X509HostnameVerifier;


import android.os.Build;


public class TrustAllSSLSocketFactory extends SSLSocketFactory {
	private javax.net.ssl.SSLSocketFactory factory;
	private static TrustAllSSLSocketFactory instance;


	private TrustAllSSLSocketFactory() throws KeyManagementException, UnrecoverableKeyException,
			NoSuchAlgorithmException, KeyStoreException {
		super(null);


		SSLContext context = SSLContext.getInstance("TLS");
		context.init(null, new TrustManager[] { new TrustAllManager() }, null);
		factory = context.getSocketFactory();
		setHostnameVerifier(new X509HostnameVerifier() {


			@Override
			public void verify(String host, String[] cns, String[] subjectAlts) throws SSLException {
				// TODO Auto-generated method stub


			}


			@Override
			public void verify(String host, X509Certificate cert) throws SSLException {
				// TODO Auto-generated method stub


			}


			@Override
			public void verify(String host, SSLSocket ssl) throws IOException {
				// TODO Auto-generated method stub


			}


			@Override
			public boolean verify(String host, SSLSession session) {
				// TODO Auto-generated method stub
				return true;
			}
		});
	}


	public static SocketFactory getDefault() {
		if (instance == null) {
			try {
				instance = new TrustAllSSLSocketFactory();
			} catch (KeyManagementException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (UnrecoverableKeyException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (NoSuchAlgorithmException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (KeyStoreException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		return instance;
	}


	@Override
	public Socket createSocket() throws IOException {
		return factory.createSocket();
	}


	@Override
	public Socket createSocket(Socket socket, String host, int port, boolean autoClose)
			throws IOException, UnknownHostException {
		if (Build.VERSION.SDK_INT < 11) { // 3.0
			injectHostname(socket, host);
		}


		return factory.createSocket(socket, host, port, autoClose);
	}


	private void injectHostname(Socket socket, String host) {
		try {
			Field field = InetAddress.class.getDeclaredField("hostName");
			field.setAccessible(true);
			field.set(socket.getInetAddress(), host);
		} catch (Exception ignored) {
		}
	}


	public class TrustAllManager implements X509TrustManager {


		@Override
		public void checkClientTrusted(X509Certificate[] arg0, String arg1)
				throws CertificateException {
			// TODO Auto-generated method stub


		}


		@Override
		public void checkServerTrusted(X509Certificate[] arg0, String arg1)
				throws CertificateException {
			// TODO Auto-generated method stub


		}


		@Override
		public X509Certificate[] getAcceptedIssuers() {
			// TODO Auto-generated method stub
			return null;
		}
	}


}


 

</pre><pre name="code" class="java"><span style="font-size:24px;">回调接口类</span>
 

<span style="font-size:24px;"></span><pre name="code" class="java">/**
 * 回调接口
 */
public interface InfoRequestCallback {
    public void onSuccess(String result);
    public void onFail(String result);
}

 



 

</pre><pre name="code" class="java"><span style="font-size:24px;">HTTPS帮助类</span>
 

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509TrustManager;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;

import com.example.kashuopos.R;
import com.kashuo.httputil.InfoRequestCallback;

import android.content.Context;
import android.os.Handler;
import android.os.Message;
import android.util.Log;

public class HttpsUtil {
	static String requestStr;
	static Context context;
	static String requestUrl;

	@SuppressWarnings("static-access")
	public HttpsUtil(Context context) {
		this.context = context;
	}

	public static void doPost(final String uri, final String jsonparms, final InfoRequestCallback callback) {
		requestUrl = uri;
		requestStr = jsonparms;
		@SuppressWarnings("unused")
		final Handler hanler = new Handler() {
			@Override
			public void handleMessage(Message msg) {
				// TODO Auto-generated method stub
				int i = msg.arg1;
				if (i == 1) {
					callback.onSuccess((String) msg.obj);
				} else {
					callback.onFail((String) msg.obj);
				}
			}
		};
		new Thread(new Runnable() {

			@Override
			public void run() {
				try {
					Message mes = Message.obtain();
					mes.arg1 = 1;
					mes.obj = initSSLCertainWithHttpClient();
					hanler.sendMessage(mes);
				} catch (Exception e) {
					Log.e("HTTPS TEST", e.getMessage());
				}
			}
		}).start();

	}

	public static void doPost1(final String uri, final String jsonparms, final InfoRequestCallback callback) {
		requestUrl = uri;
		requestStr = jsonparms;
		@SuppressWarnings("unused")
		final Handler hanler = new Handler() {
			@Override
			public void handleMessage(Message msg) {
				// TODO Auto-generated method stub
				int i = msg.arg1;
				if (i == 1) {
					callback.onSuccess((String) msg.obj);
				} else {
					callback.onFail((String) msg.obj);
				}
			}
		};
		new Thread(new Runnable() {

			@Override
			public void run() {
				try {
					Message mes = Message.obtain();
					mes.arg1 = 1;
					mes.obj=initSSLAllWithHttpClient();
					hanler.sendMessage(mes);
				} catch (Exception e) {
					Log.e("HTTPS TEST", e.getMessage());
				}
			}
		}).start();

	}
	/**
	 * HttpUrlConnection 方式，支持指定load-der.crt证书验证，此种方式Android官方建议
	 * 
	 * @throws CertificateException
	 * @throws IOException
	 * @throws KeyStoreException
	 * @throws NoSuchAlgorithmException
	 * @throws KeyManagementException
	 */
	public void initSSL() throws CertificateException, IOException, KeyStoreException, NoSuchAlgorithmException, KeyManagementException {
		CertificateFactory cf = CertificateFactory.getInstance("X.509");
		InputStream in = context.getResources().openRawResource(R.raw.kashuo_server_59_53_92_173);
		Certificate ca = cf.generateCertificate(in);

		KeyStore keystore = KeyStore.getInstance(KeyStore.getDefaultType());
		keystore.load(null, null);
		keystore.setCertificateEntry("ca", ca);

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

		// Create an SSLContext that uses our TrustManager
		SSLContext context = SSLContext.getInstance("TLS");
		context.init(null, tmf.getTrustManagers(), null);
		URL url = new URL("https://certs.cac.washington.edu/CAtest/");
		HttpsURLConnection urlConnection = (HttpsURLConnection) url.openConnection();
		urlConnection.setSSLSocketFactory(context.getSocketFactory());
		InputStream input = urlConnection.getInputStream();

		BufferedReader reader = new BufferedReader(new InputStreamReader(input, "UTF-8"));
		StringBuffer result = new StringBuffer();
		String line = "";
		while ((line = reader.readLine()) != null) {
			result.append(line);
		}
		Log.e("TTTT", result.toString());
	}

	/**
	 * HttpUrlConnection支持所有Https免验证，不建议使用
	 * 
	 * @throws KeyManagementException
	 * @throws NoSuchAlgorithmException
	 * @throws IOException
	 */
	public void initSSLALL() throws KeyManagementException, NoSuchAlgorithmException, IOException {
		URL url = new URL(requestUrl);
		SSLContext context = SSLContext.getInstance("TLS");
		context.init(null, new TrustManager[] { new TrustAllManager() }, null);
		HttpsURLConnection.setDefaultSSLSocketFactory(context.getSocketFactory());
		HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() {

			@Override
			public boolean verify(String arg0, SSLSession arg1) {
				return true;
			}
		});
		HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
		connection.setDoInput(true);
		connection.setDoOutput(false);
		connection.setRequestMethod("POST");
		connection.connect();
		InputStream in = connection.getInputStream();
		BufferedReader reader = new BufferedReader(new InputStreamReader(in));
		String line = "";
		StringBuffer result = new StringBuffer();
		while ((line = reader.readLine()) != null) {
			result.append(line);
		}
		Log.e("TTTT", result.toString());
	}

	/**
	 * HttpClient方式实现，支持所有Https免验证方式链接
	 * 
	 * @throws ClientProtocolException
	 * @throws IOException
	 */
	public static String initSSLAllWithHttpClient() throws ClientProtocolException, IOException {
		int timeOut = 30 * 1000;
 		HttpParams param = new BasicHttpParams();
		HttpConnectionParams.setConnectionTimeout(param, timeOut);
		HttpConnectionParams.setSoTimeout(param, timeOut);
		HttpConnectionParams.setTcpNoDelay(param, true);

		SchemeRegistry registry = new SchemeRegistry();
		registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
		registry.register(new Scheme("https", TrustAllSSLSocketFactory.getDefault(), 443));
		ClientConnectionManager manager = new ThreadSafeClientConnManager(param, registry);
		DefaultHttpClient client = new DefaultHttpClient(manager, param);
        //GET请求
//		HttpGet request = new HttpGet("https://certs.cac.washington.edu/CAtest/");
//		// HttpGet request = new HttpGet("https://www.alipay.com/");
//		HttpResponse response = client.execute(request);
//		HttpEntity entity = response.getEntity();
//		BufferedReader reader = new BufferedReader(new InputStreamReader(entity.getContent()));
//		StringBuilder result = new StringBuilder();
//		String line = "";
//		while ((line = reader.readLine()) != null) {
//			result.append(line);
//		}
//		Log.e("HTTPS TEST", result.toString());
       //POST请求
		//HttpPost request = new HttpPost(requestUrl);
		HttpPost request = new HttpPost(requestUrl);  
		// 发送数据类型
		//request.addHeader("Content-Type", "application/json;charset=utf-8");
		request.addHeader("Content-Type", "application/x-www-form-urlencoded");
		// 接受数据类型
		request.addHeader("Accept", "application/json");
		// 请求报文
		StringEntity requestEntity = new StringEntity(requestStr, "UTF-8");
		request.setEntity(requestEntity);
		HttpResponse response = client.execute(request);
		HttpEntity entity = response.getEntity();
		BufferedReader reader = new BufferedReader(new InputStreamReader(entity.getContent()));
		StringBuilder result = new StringBuilder();
		String line = "";
		while ((line = reader.readLine()) != null) {
			result.append(line);
		}
		return result.toString();
	}
	
	/**
	 * HttpClient方式实现，支持验证指定证书
	 * 
	 * @throws ClientProtocolException
	 * @throws IOException
	 */
	public static String initSSLCertainWithHttpClient() throws ClientProtocolException, IOException {
		int timeOut = 30 * 1000;
		HttpParams param = new BasicHttpParams();
		HttpConnectionParams.setConnectionTimeout(param, timeOut);
		HttpConnectionParams.setSoTimeout(param, timeOut);
		HttpConnectionParams.setTcpNoDelay(param, true);

		SchemeRegistry registry = new SchemeRegistry();
		registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
		registry.register(new Scheme("https", TrustCertainHostNameFactory.getDefault(context), 443));
		ClientConnectionManager manager = new ThreadSafeClientConnManager(param, registry);
		DefaultHttpClient client = new DefaultHttpClient(manager, param);

		HttpPost request = new HttpPost(requestUrl);
		// 发送数据类型
		request.addHeader("Content-Type", "application/json;charset=utf-8");
		//request.addHeader("Content-Type", "application/x-www-form-urlencoded");
		// 接受数据类型
		request.addHeader("Accept", "application/json");
		// 请求报文
		StringEntity requestEntity = new StringEntity(requestStr, "UTF-8");
		request.setEntity(requestEntity);
		HttpResponse response = client.execute(request);
		HttpEntity entity = response.getEntity();
		BufferedReader reader = new BufferedReader(new InputStreamReader(entity.getContent()));
		StringBuilder result = new StringBuilder();
		String line = "";
		while ((line = reader.readLine()) != null) {
			result.append(line);
		}
		return result.toString();
	}

	public class TrustAllManager implements X509TrustManager {

		@Override
		public void checkClientTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {
			// TODO Auto-generated method stub

		}

		@Override
		public void checkServerTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {
			// TODO Auto-generated method stub

		}

		@Override
		public X509Certificate[] getAcceptedIssuers() {
			// TODO Auto-generated method stub
			return null;
		}
		
	
	}

}
 



 



 
调用测试类 

 

<pre name="code" class="java">public class HttpsTestActivity extends Activity {
	Button btn;
	String requestStr;
	
    @Override
	protected void onCreate(Bundle savedInstanceState) {
		// TODO Auto-generated method stub
		super.onCreate(savedInstanceState);
		setContentView(R.layout.test);
		btn=(Button) findViewById(R.id.test_btn);
		long time=System.currentTimeMillis();
		SimpleDateFormat format=new SimpleDateFormat("yyyymmddHHmmss");
		Date d=new Date(time);
		String s=format.format(d);
		JSONObject obj=new JSONObject();
		try {
			obj.put("device_sn","LE777777");
			obj.put("trans_no","20160125021103000023");
			obj.put("terminal_trans_no","D800_88888888_20161125141113");
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		requestStr="app_id=9bf199cf-4520-4b29-bdd1-80ffa0febfb2&biz_content="+obj.toString()+"&charset=utf-8&method=payment_cancel&sign_type=MD5×tamp="+s+"&version=1.0&sign=81406B6F2AB3E0FE6AFF706865BF11C3";
		btn.setOnClickListener(new OnClickListener() {
			@SuppressWarnings("static-access")
			@Override
			public void onClick(View v) {
				// TODO Auto-generated method stub
			
			    HttpsUtil https=new HttpsUtil(HttpsTestActivity.this);
			    https.doPost1("服务器地址",requestStr,new InfoRequestCallback() {
					
					@Override
					public void onSuccess(String result) {
						// TODO Auto-generated method stub
						//成功
					}
					
					@Override
					public void onFail(String result) {
						// TODO Auto-generated method stub
						//失败
					}
				});
			}
		});
	}
    
}
 

 

 

 

 

 

 

 


                

        

        

    

  


    

      

        

            

              
                
                  蒙奇·D·如
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
okhttp关于https封装的几个工具类

				
			

			

				

					12-28
				

			

		

		

			
				
工具lib类库是根据鸿杨项目修改的eclipse的lib类库，以及其中没有包含的OkHttpClientManager类

			
		

	



                

              
                



	

		

			

				
					
android https 工具类,Android的Http请求工具类

				
			

			

				

					weixin_42629815的博客
				

				

					05-25
					
					150
					
				

			

		

		

			
				
下面是编程之家 jb51.cc 通过网络收集整理的代码片段。编程之家小编现在分享给大家，也给大家做个参考。import java.io.BufferedReader;import java.io.ByteArrayOutputStream;import java.io.IOException;import java.io.InputStream;import java.io.InputStream...

			
		

	



                


  
              

                


	

		

			

				
					
[Android]一个通过Https的SSL验证的工具类

				
			

			

				

					woaily1346的博客
				

				

					09-02
					
					183
					
				

			

		

		

			
				
在家休息了一个星期了，总结总结以前写过的代码，整理成工具，说不定以后用得上。

 废话不多说，直接上代码：


import android.content.Context;

import java.io.InputStream;
import java.security.KeyManagementException;
import java.security.Ke...

			
		

	





	

		

			

				
					
android https 工具类,Android封装的http请求实用工具类

				
			

			

				

					weixin_29716207的博客
				

				

					05-25
					
					115
					
				

			

		

		

			
				
import java.io.BufferedReader;import java.io.InputStreamReader;import java.net.URLEncoder;import java.security.KeyStore;import java.util.Iterator;import java.util.List;import java.util.Map;import java...

			
		

	



		

			
		



	

		

			

				
					
Android-HttpsURLConnectionHelp工具类

				
			

			

				

					刘德利CSDN博客
				

				

					09-15
					
					333
					
				

			

		

		

			
				
Java版(HttpURLConnection)Https请求工具类

public class HttpsURLConnectionHelp {

    /**
     * 加密协议
     */
    public static TrustManager truseAllManager = new X509TrustManager() {

        public void ch...

			
		

	





	

		

			

				
					
安卓日志工具类android日志工具类xlog工具类xlog.rar

				
			

			

				

					06-02
				

			

		

		

			
				
在Android开发中，日志工具类是不可或缺的一部分，它们帮助开发者记录应用运行时的状态和调试信息。本资源提供了一个名为“xlog”的日志工具类，它为Android开发者提供了更高效、灵活的日志管理功能。下面我们将详细...

			
		

	





	

		

			

				
					
安卓开发框架工具类相关-Android项目开发框架目前主流的app样式.rar

				
			

			

				

					07-29
				

			

		

		

			
				
"安卓开发框架工具类相关-Android项目开发框架目前主流的app样式.rar"这个压缩包可能包含了一些当前流行的Android开发框架和实用工具类的示例。下面将详细讨论Android开发框架以及常用工具类的重要性、选择和应用。 ...

			
		

	





	

		

			

				
					
android 基本框架+常用工具类

				
			

			

				

					05-07
				

			

		

		

			
				
9. **ViewUtils**：视图操作工具类，可以帮助开发者更便捷地设置和操作Android的View组件。  在Android开发中，掌握这些基本框架和工具类的使用至关重要。通过合理运用，可以有效提升代码质量，减少重复工作，使得...

			
		

	





	

		

			

				
					
Android真实项目所需要的所有工具类集合

				
			

			

				

					04-21
				

			

		

		

			
				
5. **文件操作工具类**：提供了文件的读写、复制、删除等操作，简化了文件管理的工作。  6. **网络工具类**：支持HTTP/HTTPS请求，可以进行数据的上传和下载，同时提供了异步处理机制，避免阻塞主线程。  7. **图片...

			
		

	





	

		

			

				
					
安卓开发框架工具类相关-实用安卓工具库(2016)。常用工具库包含一些实用工具.zip

				
			

			

				

					07-29
				

			

		

		

			
				
本资源包“安卓开发框架工具类相关-实用安卓工具库(2016)”主要关注的是2016年的一些流行和实用的工具库，虽然年代稍远，但其中许多基础工具类仍然对今天的开发有参考价值。  1. **JavaApk源码说明.txt**  这个文件...

			
		

	





	

		

			

				
					
简单的HTTP请求工具AndroidHttpTools.zip

				
			

			

				

					07-19
				

			

		

		

			
				
AndroidHttpTools 是简单的 HTTP 请求工具，支持 get，post，post 文件。
	//------------------------简单示例------------------------//String url = "http://www.baidu.com/";

private void requestData() {
    ConnectionHelper conn = ConnectionHelper.obtainInstance();
    long requstHandler = conn.httpGet(url, 0, rr);
    // support cancel
    // conn.cancleRequest(requstHandler);
}

private void reqeustData2() {
    ConnectionHelper.obtainInstance().execute(
            RequestEntity.obtain().url(url).method(RequestMethod.GET)
                    .receiver(rr));
}

private RequestReceiver rr = new RequestReceiver() {

    @Override
    public void onResult(int resultCode, int reqId, Object tag, String resp) {
        if (resultCode == RESULT_STATE_OK) {
            // reqeustion ok
        } else {
            // reqeust error
        }
    }

    @Override
    public void onRequestCanceled(int reqId, Object tag) {
        // on canceled
    }
};

			
		

	





	

		

			

				
					
简单的android访问https

				
			

			

				

					01-26
				

			

		

		

			
				
简单的android访问https

			
		

	





	

		

			

				
					
android https 工具类,Android 封装http请求的工具类

				
			

			

				

					weixin_32466167的博客
				

				

					05-25
					
					205
					
				

			

		

		

			
				
importjava.io.BufferedReader;importjava.io.InputStreamReader;importjava.net.URLEncoder;importjava.security.KeyStore;importjava.util.Iterator;importjava.util.List;importjava.util.Map;importjava...

			
		

	





	

		

			

				
					
android https 工具类,android Http连接工具类，结合HttpClient辅助类使用

				
			

			

				

					weixin_34773479的博客
				

				

					05-25
					
					161
					
				

			

		

		

			
				
package com.wos.web.util;import java.io.ByteArrayOutputStream;import java.io.IOException;import java.io.InputStream;import java.net.HttpURLConnection;import java.net.MalformedURLException;import java....

			
		

	





	

		

			

				
					
Android Https请求详细demo

				
			

			

				

					 飞翔的熊blabla
				

				

					07-28
					
					1345
					
				

			

		

		

			
				
转载于:http://gjican.iteye.com/blog/2153177




 Android Https详细请求全方案实现，包括HttpUrlConnection及HttpClient方式实现指定证书及信任所有的实现，不多说了，以下代码都经过详细测试，可以直接使用。

    


Java代码  



package com.example.https

			
		

	





	

		

			

				
					
java out对象_JSP out对象详解

				
			

			

				

					weixin_39539733的博客
				

				

					02-15
					
					1549
					
				

			

		

		

			
				
JSP out对象详解out对象就是在Web应用开发过程中使用最多的一个对象，其功能就是动态的向JSP页面输出字符流，从而把动态的内容转化成HTML形式来展示，这个对象在任何JSP页面中都可以任意访问。out对象是javax.servlet.jsp.JspWriter类的实例化对象，可以通过调用pageContext.getOut()方法可以获取out对象，主要功能就是完成页面的输出操作，使用pr...

			
		

	





	

		

			

				
					
Android中进行https请求信任证书问题（效率解决，小白适用）

					
热门推荐

				
			

			

				

					我鱼的博客
				

				

					01-19
					
					1万+
					
				

			

		

		

			
				
前言
Volley 框架信任所有https证书
基于Okhttpclient信任https所有证书
前言    在Android开发项目中难免要进行https请求，如果你也遇到这样的问题，那么我想这片博客能对你有些帮助。
java.security.cert.CertPathValidatorException: Trust anchor for certification path not fou

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值