Utilisez httpclient pour appeler l'adresse URL https sans certificat et transmettre le flux d'octets.
Copiez le code comme suit :
paquet com.paic.hmreport.metaQ ;
importer java.io.BufferedInputStream ;
importer java.io.BufferedReader ;
importer java.io.ByteArrayInputStream ;
importer java.io.FileOutputStream ;
importer java.io.IOException ;
importer java.io.InputStream ;
importer java.io.InputStreamReader ;
importer java.io.OutputStream ;
importer java.net.URL ;
importer java.security.KeyManagementException ;
importer java.security.KeyStore ;
importer java.security.NoSuchAlgorithmException ;
importer javax.net.ssl.HostnameVerifier ;
importer javax.net.ssl.HttpsURLConnection ;
importer javax.net.ssl.KeyManagerFactory ;
importer javax.net.ssl.SSLContext ;
importer javax.net.ssl.SSLSession ;
importer javax.net.ssl.TrustManagerFactory ;
importer java.security.cert.CertificateException ;
importer java.security.cert.X509Certificate ;
importer javax.net.ssl.TrustManager ;
importer javax.net.ssl.X509TrustManager ;
importer org.apache.http.HttpEntity ;
importer org.apache.http.HttpResponse ;
importer org.apache.http.client.ClientProtocolException ;
importer org.apache.http.client.methods.HttpPost ;
importer org.apache.http.conn.scheme.Scheme ;
importer org.apache.http.conn.ssl.SSLSocketFactory ;
importer org.apache.http.entity.BufferedHttpEntity ;
importer org.apache.http.entity.InputStreamEntity ;
importer org.apache.http.entity.StringEntity ;
importer org.apache.http.impl.client.DefaultHttpClient ;
importer org.apache.commons.logging.Log ;
importer org.apache.commons.logging.LogFactory ;
classe publique HttpsClient {
journal de journal statique public = LogFactory.getLog (HttpsClient.class);
/* pour Windows */
/* pour Linux */
/*
* Chaîne statique privée CLIENT_CERT_PWD="123456" ;
* TRUST_CERT_PATH=
* "/wls/bis_emulator/apps/emulator/config/cert/BIS_FRONT_SERVER_STG_BY_ZXC.jks"
* ; Chaîne statique privée TRUST_CERT_PWD="123456" ;
* client_cert_path=
* "/wls/bis_emulator/apps/emulator/config/cert/EXV_GROUP_EAI_B2B_ZUCHE_100.jks"
* ;
*/
/**
* @param arguments
* @throwsIOException
* @throws ClientProtocolException
* @throws NoSuchAlgorithmException
* @throws KeyManagementException
*/
public static void main (String[] args) lance KeyManagementException,
NoSuchAlgorithmException, ClientProtocolException, IOException {
// sendMsgOfCert("https://10.25.32.13:8007", "bonjour tout le monde", "123456",
// "kserver.jks", "123456", "tclient.jks");
envoyer(
"https://127.0.0.1/hmreport/messageChannel.ac?sign=TEZrSHZJdDNrRFNIb0M0QnJrc3VIdDBJWDRYTTVXZGJYZHlLUkpxQlp6anQyYUJITEpSVWQzOWh4b0RvOW96TGVvN2Z hWEJ3SkZvN0JIZVhhOFRuaWZLY3VwbDExSjg2cjZFMFFvNHV4YktJd3E0T2RvTmVhQzV6NV hNTzJLN1NaNWpoUUhTVTR0NTNEdWFOVHpuZjh1ajA0VUhqaFBWRTJvM0s2dnEyTFVnPQ==",
"Bonjour le monde!");
}
chaîne statique publique sendMsgOfCert (String urlString, String requestData,
Chaîne CLIENT_CERT_PWD, Chaîne CLIENT_CERT_PATH,
Chaîne TRUST_CERT_PWD, Chaîne TRUST_CERT_PATH) {
StringBuffer sb = nul ;
essayer {
log.info("Commencez à initialiser le client 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(merci);
sslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
HostnameVerifier hostnameVerifier = new HostnameVerifier() {
vérification booléenne publique (String arg0, SSLSession arg1) {
renvoie vrai ;
}
} ;
HttpsURLConnection.setDefaultHostnameVerifier(hostnameVerifier);
// URL url = nouvelle URL("https://172.40.1.83:8007");
URL url = nouvelle URL (urlString);
HttpsURLConnection urlCon = URL (HttpsURLConnection)
.openConnection();
urlCon.setDoOutput(true);
urlCon.setDoInput(true);
urlCon.setRequestMethod("POST");
urlCon.setRequestProperty("Type de contenu",
"text/xml;charset=GB18030");
urlCon.setSSLSocketFactory(sslContext.getSocketFactory());
OutputStream os = urlCon.getOutputStream();
InputStream fis = nouveau ByteArrayInputStream (requestData
.getBytes("GB18030"));
BufferedInputStream bis = new BufferedInputStream(fis);
octet[] octets = nouvel octet[1024];
int len = -1;
while ((len = bis.read(bytes)) != -1) {
os.write(octets, 0, len);
}
os.flush();
bis.close();
fis.close();
os.close();
InputStream est = urlCon.getInputStream();
BufferedReader br = nouveau BufferedReader(nouveau InputStreamReader(est,
"GB18030"));
// DataInputStream indata = new DataInputStream(is);
// Chaîne ret = "" ;
// Chaîne str_return = "" ;
// while (ret != null) {
// ret = indata.readLine();
// if (ret != null && !ret.trim().equals("")) {
// str_retour = str_retour
// + 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 = nouveau StringBuffer();
Ligne de ficelle ;
while ((line = br.readLine()) != null) {
sb.append(ligne);
}
System.out.println("sb:" + sb);
br.close();
est.close();
urlCon.disconnect();
} attraper (Exception e) {
e.fillInStackTrace();
log.info("Échec de l'appel client : " + e.getMessage());
throw new RuntimeException("Échec de l'appel https!");
}
renvoie null ;
}
envoi public statique vide (String requsetString, String requestData)
lance NoSuchAlgorithmException, KeyManagementException,
ClientProtocolException, IOException {
// Créez d'abord un gestionnaire de confiance qui s'en fiche.
X509TrustManager trustManager = nouveau X509TrustManager() {
public void checkClientTrusted (chaîne X509Certificate[],
String authType) lance CertificateException {
// Ne fais rien.
}
public void checkServerTrusted (chaîne X509Certificate[],
String authType) lance CertificateException {
// Ne fais rien.
}
public X509Certificate[] getAcceptedIssuers() {
// Ne fais rien.
renvoie null ;
}
} ;
// Placez maintenant le gestionnaire de confiance dans un SSLContext.
SSLContext sslcontext = SSLContext.getInstance("SSL");
sslcontext.init(null, nouveau TrustManager[] { trustManager }, null);
// Utilisez le SSLContext ci-dessus pour créer votre fabrique de sockets
// (J'ai trouvé qu'essayer d'étendre l'usine était un peu difficile à cause d'un
// appel à createSocket sans argument, une méthode qui ne le fait pas
// existe partout où je peux trouver, mais bon).
SSLSocketFactory sf = new SSLSocketFactory(sslcontext);
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
DefaultHttpClient httpclient = new DefaultHttpClient();
httpclient.getConnectionManager().getSchemeRegistry().register(
nouveau schéma("https", sf, 443));
// Chaîne requset = "https://180.168.35.140/api/vm.list" ;
HttpPost httpPost = new HttpPost(requsetString);
Résultat de la chaîne = "" ;
//Exécuter la requête HTTP
httpPost.setHeader("Autorisation", "de base "
+ "dGNsb3VkYWRtaW46dGNsb3VkMTIz");
httpPost.setHeader("Type de contenu", "application/xml");
StringEntity reqEntity ;
// Encapsuler les paramètres de la requête dans HttpEntity
reqEntity = nouveau StringEntity(requestData);
BufferedHttpEntity bhe = new BufferedHttpEntity(reqEntity);
httpPost.setEntity(bhe);
Réponse HttpResponse = httpclient.execute(httpPost);
HttpEntity resEntity = réponse.getEntity();
Lecteur InputStreamReader = new InputStreamReader(resEntity.getContent());
char[] buff = nouveau char[1024];
longueur entière = 0 ;
while ((length = reader.read(buff)) != -1) {
résultat += new String(buff, 0, length);
}
httpclient.getConnectionManager().shutdown();
System.out.println(">>>:" + résultat);
}
test de vide statique public() {
Mots de chaîne = "bonjour" ;
essayer {
FileOutputStream out = new FileOutputStream("D:/file.txt");
out.write(words.getBytes());
out.flush();
out.close();
} attraper (Exception e) {
// TODO Bloc catch généré automatiquement
e.printStackTrace();
}
}
}