Utilice httpclient para llamar a la dirección URL https sin certificado y transmitir un flujo de bytes.
Copie el código de código de la siguiente manera:
paquete 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;
clase pública HttpsClient {
Registro público estático = LogFactory.getLog(HttpsClient.class);
/* para ventanas */
/* para Linux */
/*
* Cadena estática privada CLIENT_CERT_PWD="123456";
* TRUST_CERT_PATH=
* "/wls/bis_emulator/apps/emulator/config/cert/BIS_FRONT_SERVER_STG_BY_ZXC.jks"
* ; Cadena estática privada TRUST_CERT_PWD="123456";
* ruta_certificado_cliente=
* "/wls/bis_emulator/apps/emulator/config/cert/EXV_GROUP_EAI_B2B_ZUCHE_100.jks"
* ;
*/
/**
* argumentos @param
* @throwsIOException
* @throws ClientProtocolException
* @throws NoSuchAlgorithmException
* @throws KeyManagementException
*/
public static void main (String[] args) lanza KeyManagementException,
NoSuchAlgorithmException, ClientProtocolException, IOException {
// sendMsgOfCert("https://10.25.32.13:8007", "hola mundo", "123456",
// "kserver.jks", "123456", "tclient.jks");
enviar(
"https://127.0.0.1/hmreport/messageChannel.ac?sign=TEZrSHZJdDNrRFNIb0M0QnJrc3VIdDBJWDRYTTVXZGJYZHlLUkpxQlp6anQyYUJITEpSVWQzOWh4b0RvOW96TGVvN2Z hWEJ3SkZvN0JIZVhhOFRuaWZLY3VwbDExSjg2cjZFMFFvNHV4YktJd3E0T2RvTmVhQzV6NV hNTzJLN1NaNWpoUUhTVTR0NTNEdWFOVHpuZjh1ajA0VUhqaFBWRTJvM0s2dnEyTFVnPQ==",
"¡Hola Mundo!");
}
Cadena estática pública sendMsgOfCert (String urlString, String requestData,
Cadena CLIENT_CERT_PWD, Cadena CLIENT_CERT_PATH,
Cadena TRUST_CERT_PWD, Cadena TRUST_CERT_PATH) {
StringBuffer sb = nulo;
intentar {
log.info("¡Comience a inicializar el 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(), nulo);
HostnameVerifier hostnameVerifier = nuevo HostnameVerifier() {
verificación booleana pública (Cadena arg0, SSLSession arg1) {
devolver verdadero;
}
};
HttpsURLConnection.setDefaultHostnameVerifier(hostnameVerifier);
// URL URL = nueva URL("https://172.40.1.83:8007");
URL URL = nueva URL (urlString);
HttpsURLConnection urlCon = (HttpsURLConnection) URL
.openConnection();
urlCon.setDoOutput(verdadero);
urlCon.setDoInput(verdadero);
urlCon.setRequestMethod("POST");
urlCon.setRequestProperty("Tipo de contenido",
"texto/xml;charset=GB18030");
urlCon.setSSLSocketFactory(sslContext.getSocketFactory());
Sistema operativo OutputStream = urlCon.getOutputStream();
InputStream fis = nuevo ByteArrayInputStream(requestData
.getBytes("GB18030"));
BufferedInputStream bis = nuevo BufferedInputStream(fis);
byte[] bytes = nuevo byte[1024];
int longitud = -1;
mientras ((len = bis.read(bytes)) != -1) {
os.write(bytes, 0, len);
}
os.flush();
bis.cerrar();
fis.cerrar();
os.cerrar();
InputStream es = urlCon.getInputStream();
BufferedReader br = nuevo BufferedReader(nuevo InputStreamReader(es,
"GB18030"));
// DataInputStream indata = new DataInputStream(es);
// Cadena ret = "";
// Cadena str_return = "";
// mientras (ret != nulo) {
// ret = indata.readLine();
// si (ret != nulo && !ret.trim().equals("")) {
// str_return = str_return
// + nueva cadena(ret.getBytes("ISO-8859-1"), "GBK");
// }
// }
// System.out.println("str_return:" + str_return);
// System.out.println("br.readLine():"+nuevo
// String(br.readLine().getBytes("GBK"), "GBK"));
sb = nuevo StringBuffer();
Línea de cuerda;
mientras ((línea = br.readLine()) != nulo) {
sb.append(línea);
}
System.out.println("sb:" + sb);
br.cerrar();
es.close();
urlCon.desconectar();
} captura (Excepción e) {
e.fillInStackTrace();
log.info("Error en la llamada del cliente: " + e.getMessage());
lanzar una nueva RuntimeException ("¡la llamada https falló!");
}
devolver nulo;
}
Envío vacío estático público (String requsetString, String requestData)
lanza NoSuchAlgorithmException, KeyManagementException,
ClientProtocolException, IOException {
// Primero crea un administrador de confianza al que no le importe.
X509TrustManager trustManager = nuevo X509TrustManager() {
checkClientTrusted público vacío (cadena X509Certificate[],
String authType) arroja CertificateException {
// No hagas nada.
}
checkServerTrusted público vacío (cadena X509Certificate[],
String authType) arroja CertificateException {
// No hagas nada.
}
Certificado público X509[] getAcceptedIssuers() {
// No hagas nada.
devolver nulo;
}
};
// Ahora coloque el administrador de confianza en SSLContext.
SSLContext sslcontext = SSLContext.getInstance("SSL");
sslcontext.init(nulo, nuevo TrustManager[] {trustManager}, nulo);
// Utilice el SSLContext anterior para crear su fábrica de sockets
// (Me resultó un poco difícil intentar ampliar la fábrica debido a un
// llama a createSocket sin argumentos, un método que no
// existe en cualquier lugar que pueda encontrar, pero hey-ho).
SSLSocketFactory sf = nuevo SSLSocketFactory(sslcontext);
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
DefaultHttpClient httpclient = nuevo DefaultHttpClient();
httpclient.getConnectionManager().getSchemeRegistry().register(
nuevo esquema("https", sf, 443));
// Solicitud de cadena = "https://180.168.35.140/api/vm.list";
HttpPost httpPost = nuevo HttpPost(requsetString);
Resultado de cadena = "";
//Ejecutar solicitud HTTP
httpPost.setHeader("Autorización", "básico"
+ "dGNsb3VkYWRtaW46dGNsb3VkMTIz");
httpPost.setHeader("Tipo de contenido", "aplicación/xml");
CadenaEntidadreqEntity;
// Encapsula los parámetros de la solicitud en HttpEntity
reqEntity = nueva StringEntity(requestData);
BufferedHttpEntity bhe = nueva BufferedHttpEntity(reqEntity);
httpPost.setEntity(bhe);
Respuesta HttpResponse = httpclient.execute(httpPost);
HttpEntity resEntity = respuesta.getEntity();
Lector InputStreamReader = nuevo InputStreamReader(resEntity.getContent());
char[] buff = nuevo char[1024];
longitud entera = 0;
mientras ((longitud = lector.leer(buff)) != -1) {
resultado += nueva cadena (buff, 0, longitud);
}
httpclient.getConnectionManager().shutdown();
System.out.println(">>>:" + resultado);
}
prueba de vacío estático público() {
Palabras de cadena = "hola";
intentar {
FileOutputStream fuera = nuevo FileOutputStream("D:/file.txt");
out.write(palabras.getBytes());
salida.flush();
fuera.cerrar();
} captura (Excepción e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}
}
}