Use httpclient para chamar o endereço URL https sem certificado e transmitir fluxo de bytes.
Copie o código do código da seguinte forma:
pacote com.paic.hmreport.metaQ;
importar java.io.BufferedInputStream;
importar java.io.BufferedReader;
importar java.io.ByteArrayInputStream;
importar java.io.FileOutputStream;
importar java.io.IOException;
importar java.io.InputStream;
importar java.io.InputStreamReader;
importar java.io.OutputStream;
importar java.net.URL;
importar java.security.KeyManagementException;
importar java.security.KeyStore;
importar java.security.NoSuchAlgorithmException;
importar javax.net.ssl.HostnameVerifier;
importar javax.net.ssl.HttpsURLConnection;
importar javax.net.ssl.KeyManagerFactory;
importar javax.net.ssl.SSLContext;
importar javax.net.ssl.SSLSession;
importar javax.net.ssl.TrustManagerFactory;
importar java.security.cert.CertificateException;
importar java.security.cert.X509Certificate;
importar javax.net.ssl.TrustManager;
importar javax.net.ssl.X509TrustManager;
importar org.apache.http.HttpEntity;
importar org.apache.http.HttpResponse;
importar org.apache.http.client.ClientProtocolException;
importar org.apache.http.client.methods.HttpPost;
importar org.apache.http.conn.scheme.Scheme;
importar org.apache.http.conn.ssl.SSLSocketFactory;
importar org.apache.http.entity.BufferedHttpEntity;
importar org.apache.http.entity.InputStreamEntity;
importar org.apache.http.entity.StringEntity;
importar org.apache.http.impl.client.DefaultHttpClient;
importar org.apache.commons.logging.Log;
importar org.apache.commons.logging.LogFactory;
classe pública HttpsClient {
log de log estático público = LogFactory.getLog (HttpsClient.class);
/* para janelas */
/* para Linux */
/*
* String estática privada CLIENT_CERT_PWD="123456";
* TRUST_CERT_PATH=
* "/wls/bis_emulator/apps/emulator/config/cert/BIS_FRONT_SERVER_STG_BY_ZXC.jks"
* ; String estática privada TRUST_CERT_PWD="123456";
*client_cert_path=
* "/wls/bis_emulator/apps/emulator/config/cert/EXV_GROUP_EAI_B2B_ZUCHE_100.jks"
*;
*/
/**
* @param argumentos
* @throwsIOException
* @throws ClientProtocolException
* @throws NoSuchAlgorithmException
* @throws KeyManagementException
*/
public static void main(String[] args) lança KeyManagementException,
NoSuchAlgorithmException, ClientProtocolException, IOException {
// sendMsgOfCert("https://10.25.32.13:8007", "olá mundo", "123456",
// "kserver.jks", "123456", "tclient.jks");
enviar(
"https://127.0.0.1/hmreport/messageChannel.ac?sign=TEZrSHZJdDNrRFNIb0M0QnJrc3VIdDBJWDRYTTVXZGJYZHlLUkpxQlp6anQyYUJITEpSVWQzOWh4b0RvOW96TGVvN2Z hWEJ3SkZvN0JIZVhhOFRuaWZLY3VwbDExSjg2cjZFMFFvNHV4YktJd3E0T2RvTmVhQzV6NV hNTzJLN1NaNWpoUUhTVTR0NTNEdWFOVHpuZjh1ajA0VUhqaFBWRTJvM0s2dnEyTFVnPQ==",
"Olá mundo!");
}
String estática pública sendMsgOfCert (String urlString, String requestData,
Sequência CLIENT_CERT_PWD, Sequência CLIENT_CERT_PATH,
String TRUST_CERT_PWD, String TRUST_CERT_PATH) {
StringBuffer sb = null;
tentar {
log.info("Iniciar inicialização do cliente https!");
SSLContext sslContext = SSLContext.getInstance("SSL");
KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
TrustManagerFactory tmf = TrustManagerFactory
.getInstance("SunX509");
KeyStore ks = KeyStore.getInstance("JKS");
ks.load(ClassLoader.getSystemResourceAsStream(CLIENT_CERT_PATH),
CLIENT_CERT_PWD.toCharArray());
kmf.init(ks, CLIENT_CERT_PWD.toCharArray());
KeyStore tks = KeyStore.getInstance("JKS");
tks.load(ClassLoader.getSystemResourceAsStream(TRUST_CERT_PATH),
TRUST_CERT_PWD.toCharArray());
tmf.init(tks);
sslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
HostnameVerifier hostnameVerifier = new HostnameVerifier() {
verificação booleana pública (String arg0, SSLSession arg1) {
retornar verdadeiro;
}
};
HttpsURLConnection.setDefaultHostnameVerifier(hostnameVerifier);
// URL url = nova URL("https://172.40.1.83:8007");
URL url = nova URL(urlString);
HttpsURLConnection urlCon = (HttpsURLConnection) url
.openConnection();
urlCon.setDoOutput(true);
urlCon.setDoInput(true);
urlCon.setRequestMethod("POST");
urlCon.setRequestProperty("Tipo de conteúdo",
"texto/xml;charset=GB18030");
urlCon.setSSLSocketFactory(sslContext.getSocketFactory());
OutputStream os = urlCon.getOutputStream();
InputStream fis = new ByteArrayInputStream(requestData
.getBytes("GB18030"));
BufferedInputStream bis = new BufferedInputStream(fis);
byte[] bytes = novo byte[1024];
int len = -1;
while ((len = bis.read(bytes)) != -1) {
os.write(bytes, 0, len);
}
os.flush();
bis.close();
fis.close();
os.close();
InputStream é = urlCon.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(é,
"GB18030"));
//DataInputStream indata = new DataInputStream(is);
//String ret = "";
//String str_return = "";
// enquanto (ret! = nulo) {
//ret = indata.readLine();
// if (ret != null && !ret.trim().equals("")) {
//str_return = str_return
// + new String(ret.getBytes("ISO-8859-1"), "GBK");
// }
// }
// System.out.println("str_return:" + str_return);
//System.out.println("br.readLine():"+new
//String(br.readLine().getBytes("GBK"), "GBK"));
sb = new StringBuffer();
Linha de corda;
while ((linha = br.readLine()) != null) {
sb.append(linha);
}
System.out.println("sb:" +sb);
close();
é.close();
urlCon.disconnect();
} catch (Exceção e) {
e.fillInStackTrace();
log.info("Falha na chamada do cliente: " + e.getMessage());
throw new RuntimeException("falha na chamada https!");
}
retornar nulo;
}
envio estático público vazio (String requsetString, String requestData)
lança NoSuchAlgorithmException, KeyManagementException,
ClientProtocolException, IOException {
// Primeiro crie um gerenciador de confiança que não se importe.
X509TrustManager trustManager = novo X509TrustManager() {
public void checkClientTrusted(X509Certificate[] cadeia,
String authType) lança CertificateException {
// Não faça nada.
}
public void checkServerTrusted(X509Certificate[] cadeia,
String authType) lança CertificateException {
// Não faça nada.
}
public X509Certificate[] getAcceptedIssuers() {
// Não faça nada.
retornar nulo;
}
};
// Agora coloque o gerenciador de confiança em um SSLContext.
SSLContext sslcontext = SSLContext.getInstance("SSL");
sslcontext.init(null, new TrustManager[] { trustManager }, null);
// Use o SSLContext acima para criar sua fábrica de soquetes
// (Achei um pouco difícil tentar estender a fábrica devido a uma
//chama para createSocket sem argumentos, um método que não
// existe em qualquer lugar que eu possa encontrar, mas ei).
SSLSocketFactory sf = novo SSLSocketFactory(sslcontext);
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
DefaultHttpClient httpclient = new DefaultHttpClient();
httpclient.getConnectionManager().getSchemeRegistry().register(
novo esquema("https", sf, 443));
// String requset = "https://180.168.35.140/api/vm.list";
HttpPost httpPost = new HttpPost(requsetString);
Resultado da string = "";
//Executa solicitação HTTP
httpPost.setHeader("Autorização", "básico"
+ "dGNsb3VkYWRtaW46dGNsb3VkMTIz");
httpPost.setHeader("Tipo de conteúdo", "aplicativo/xml");
StringEntity reqEntity;
// Encapsula os parâmetros da solicitação em HttpEntity
reqEntity = new StringEntity(requestData);
BufferedHttpEntity bhe = new BufferedHttpEntity(reqEntity);
httpPost.setEntity(bhe);
Resposta HttpResponse = httpclient.execute(httpPost);
HttpEntity resEntity = resposta.getEntity();
Leitor InputStreamReader = new InputStreamReader(resEntity.getContent());
char[] buff = novo char[1024];
comprimento interno = 0;
while ((comprimento = leitor.read(buff)) != -1) {
resultado += new String(buff, 0, comprimento);
}
httpclient.getConnectionManager().shutdown();
System.out.println(">>>:" + resultado);
}
teste de void estático público() {
String palavras = "olá";
tentar {
FileOutputStream out = new FileOutputStream("D:/file.txt");
out.write(palavras.getBytes());
fora.flush();
out.close();
} catch (Exceção e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}
}
}