Android有关HTTPS请求传输xml数据

public String login(String userName, String password) {
		Document doc=DocumentHelper.createDocument();
		Element  root=doc.addElement(Constants.ACTION_LOGIN);
		root.addElement("userName").setText(userName);
		root.addElement("password").setText(password);
		String xmlStr = doc.asXML();
		//Configuration.getProperty(Configuration.LOGIN_URL)
		Element element = HttpUtil.postRequest(Configuration.getProperty(Configuration.HOST_URL)
				+ Constants.ACTION_LOGIN, xmlStr);
		List<Element> eleList = element.elements();
		List<Element> eleList2 = eleList.get(0).elements();
		Map<String, String> map = new HashMap<String, String>();
		for(Element e : eleList2)
			map.put(e.getName(), e.getText());
		UserModel m=new UserModel();
		map.put("s",m.toString());
		return map.toString();
	}

/**
	 * HTTP POST请求 
	 * @param url 请求地址
	 * @param xmlStr 请求参数
	 * @return
	 *        请求成功，返回请求结果；
	 *        请求失败，返回statusCode_ + 状态码，如statusCode_404
	 */
	public static Element postRequest(String url, String xmlStr) {
	    try {
		 HttpParams httpParameters = new BasicHttpParams();
	        HttpConnectionParams.setConnectionTimeout(httpParameters, 15000);
	        HttpConnectionParams.setSoTimeout(httpParameters, 15000);
	        HttpProtocolParams.setVersion(httpParameters, HttpVersion.HTTP_1_1);
	        HttpProtocolParams.setContentCharset(httpParameters, HTTP.UTF_8);
	        HttpClient hc = getNewHttpClient();
	        HttpPost post = new HttpPost(url);
	        post.addHeader("Content-Type", "text/xml");
	        post.setEntity(new StringEntity(xmlStr, "UTF-8"));
	        post.setParams(httpParameters);
	        HttpResponse response = null;
	            response = hc.execute(post);
		        int sCode = response.getStatusLine().getStatusCode();
		        if (sCode == HttpStatus.SC_OK) {
		        	return  parseXml(response.getEntity().getContent());
		        } 
	        } catch (Exception e) {
				e.printStackTrace();
			}
		return null;
	}

/**
	 * 获取 HttpClient
	 * 
	 * @return
	 * 		  HttpClient
	 */
	private static HttpClient getNewHttpClient() {
		try {
			KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
			trustStore.load(null, null);

			HttpParams params = new BasicHttpParams();
			HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
			HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);
			HttpConnectionParams.setConnectionTimeout(params, REQUEST_TIMEOUT);
			HttpConnectionParams.setSoTimeout(params, SO_TIMEOUT);

			SchemeRegistry registry = new SchemeRegistry();
			registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
			registry.register(new Scheme("https", SSLTrustAllSocketFactory.getSocketFactory(), 443));

			ClientConnectionManager ccm = new ThreadSafeClientConnManager(params, registry);
			return new DefaultHttpClient(ccm, params);
		} catch (Exception e) {
			return new DefaultHttpClient();
		}
	}

public static  Element parseXml(InputStream inputStream) throws Exception {  
	    // 将解析结果存储在HashMap中  
	    Map<String, String> map = new HashMap<String, String>();  
	    // 读取输入流  
	    SAXReader reader = new SAXReader();  
	    Document document = reader.read(inputStream);  
	    // 得到xml根元素  
	    Element root = document.getRootElement();  
	    // 得到根元素的所有子节点  
	    List<Element> elementResponse = root.elements();  //response
	    Element elementResult = elementResponse.get(0);
	  
	    // 释放资源  
	    inputStream.close();  
	    inputStream = null;  
	  
	    return elementResult;  
	}

public class SSLTrustAllSocketFactory extends SSLSocketFactory { 
	private static final String TAG = "SSLTrustAllSocketFactory";  
	private SSLContext mCtx;  

	public class SSLTrustAllManager implements X509TrustManager {  

		@Override  
		public void checkClientTrusted(X509Certificate[] arg0, String arg1)  
				throws CertificateException {  
		}  

		@Override  
		public void checkServerTrusted(X509Certificate[] arg0, String arg1)  
				throws CertificateException {  
		}  

		@Override  
		public X509Certificate[] getAcceptedIssuers() {  
			return null;  
		}  

	}  

	public SSLTrustAllSocketFactory(KeyStore truststore)  
			throws Throwable {  
		super(truststore);  
		try {  
			mCtx = SSLContext.getInstance("TLS");  
			mCtx.init(null, new TrustManager[] { new SSLTrustAllManager() },  
					null);  
			setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);  
		} catch (Exception ex) {  
		}  
	}  

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

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

	public static SSLSocketFactory getSocketFactory() {  
		try {  
			KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());  
			trustStore.load(null, null);  
			SSLSocketFactory factory = new SSLTrustAllSocketFactory(trustStore);  
			return factory;  
		} catch (Throwable e) {  
			Log.d(TAG, e.getMessage());  
			e.printStackTrace();  
		}  
		return null;  
	}  
}