Resumo: Recentemente, há um requisito para fornecer aos clientes algumas interfaces de API RESTful. O QA usa o Postman para teste, mas a interface de teste do Postman é semelhante, mas não é a mesma que as chamadas de Java. Então, eu quero escrever um programa para testar a interface da API RESTful sozinha. Como ele usa HTTPS, também preciso considerar o processamento de HTTPs. Como usei o Java para chamar a interface RESTful pela primeira vez, ainda preciso estudá -lo, então naturalmente consultei algumas informações.
Análise: Esse problema é diferente das chamadas entre os módulos. Por exemplo, tenho dois módulos, front-end e back end, o front-end fornece tela front-end e back-end fornece suporte a dados. Eu usei o Hession para registrar os serviços prestados pelo back -end como serviços remotos. No front -end, este serviço remoto pode ser ajustado diretamente à interface do back -end através desse tipo de serviço remoto. Mas isso não tem problema para uma empresa usar quando seu próprio projeto é altamente acoplado. No entanto, se você registrar um serviço remoto com os clientes, não parece bom e o acoplamento é muito alto. Então, considero usar o seguinte método.
1. HttpClient
Todos podem estar familiarizados com o httpclient, mas não estão familiarizados com isso. Ele está familiarizado com ele porque pode ligar remotamente, por exemplo, solicitar um URL e, em seguida, obter o status de retorno e retornar as informações da resposta. No entanto, hoje estou falando sobre isso um pouco mais complicado, porque o tópico de hoje é HTTPS, que envolve a questão dos certificados ou da autenticação do usuário.
Depois de confirmar que, usando o httpclient, procurei informações relevantes e descobri que a nova versão do HttpClient é diferente da versão antiga e é compatível com a versão antiga, mas não é mais recomendável que a versão antiga seja usada. Muitos métodos ou classes foram marcados como desatualizados. Hoje, usaremos a versão antiga 4.2 e a versão 4.5.3 mais recente para gravar o código, respectivamente.
Versão antiga 4.2
Necessidade de certificação
O uso da autenticação de certificado é selecionado durante a fase de preparação de certificação
pacote com.darren.test.https.v42; importar java.io.file; importar java.io.fileInputStream; importar java.security.keystore; importar org.apache.http.conn.ssl.sssocktFactory; classe pública HttpSCertifiedClient estende httpsclient {public httpsCertifiedClient () {} @Override public void prepareCertificate () lança exceção {// obtenha a Key Library keystore trustStore = keystore.getInstance (keystore.getDefaultTyPe (); FileInputStream input = new FileInputStream (novo File ("c: /users/zhda6001/downloads/software/xxx.keystore"); // fileInputStream input = new FileInputStream (new File ("c: /users/zhda6001/downloads/xxx.keystore")); // senha do Key Library Truststore.load (Instruam, "Senha" .ToCharArray ()); // Registre a biblioteca -chave this.socketFactory = new SSLSocketFactory (TrustStore); // Não verifique o nome do domínio SocketFactory.SethostNameVerriFier (sslsocketFactory.allow_all_hostname_verifier); }}Pule a certificação
A opção de pular a autenticação durante a fase de preparação de certificado é para
pacote com.darren.test.https.v42; importar java.security.cert.certificateException; importar java.security.cert.x509Certificate; importar javax.net.ssl.ssslContext; importar javax.net.ssl.trustmanager; importar javax.net.ssl.x509TrustManager; importar org.apache.http.conn.ssl.sssocktFactory; classe pública httpstrustclient estende httpsclient {public httpstrustclient () {} @Override public void prepareCertificate () lança exceção {// pular verificação do certificado sslContext ctx = sslContext.getinstance ("tls"); X509TrustManager tm = new X509TrustManager () {@Override public void CheckClientTrusted (Chain de X509Certificate [], String Authtype) lança certificadoException {} @Override public void checkServerTrusted (x509Certificate [] Chain, string Authtype) X509Certificate [] getAcceptEdissuers () {return null; }}; // defina para o certificado confiável ctx.init (null, new TrustManager [] {tm}, null); // coloque a fábrica de soquete SSL e defina para não verificar o nome do host. }}Resumir
Agora, verifica -se que ambas as classes herdam a mesma classe httpsclient e httpsclient herda a classe DefaultTttpClient. Pode -se descobrir que o padrão de método do modelo é usado aqui.
pacote com.darren.test.https.v42; importar org.apache.http.conn.clientConnectionManager; importar org.apache.http.conn.scheme.scheme; importar org.apache.http.conn.ssl.sssocktFactory; importar org.apache.http.impl.client.defaulthttpClient; Classe de abstração pública httpSclient estende a defaultTtpClient {protegido SSLSocketFactory SocketFactory; / ** * Inicialize httpsclient * * @return retorna a instância atual * @throws Exception */ public httpsclient init () lança exceção {this.PrepareCertificate (); this.regist (); devolver isso; } / ** * Prepare a verificação do certificado * * @THOWSOWS Exceção * / public Resumo void prepareCertificate () lança exceção; / *** Registro protocolo e porta, esse método também pode ser reescrito por subclasses*/ Protected void regist () {clientConnectionManager ccm = this.getConnectionManager (); Schemeregistry sr = ccm.getschemeregistry (); Sr.Recister (novo esquema ("https", 443, SocketFactory)); }} Abaixo está a classe de ferramentas
pacote com.darren.test.https.v42; importar java.util.arraylist; importar java.util.list; importar java.util.map; importar java.util.set; importar org.apache.http.httpentity; importar org.apache.http.httpResponse; importar org.apache.http.nameValuepair; importar org.apache.http.client.entity.urlencodedFormentity; importar org.apache.http.client.methods.httpget; importar org.apache.http.client.methods.httppost; importar org.apache.http.client.methods.httprequestBase; importar org.apache.http.message.basicnameValuepair; importar org.apache.http.util.entityutils; classe pública httpsclientutil {private static final string default_charset = "utf-8"; public static string DoPost (httpsclient httpsclient, string url, map <string, string> paramheader, map <string, string> parambody) lança a exceção {return DoPost (httpsclient, url, paramheader, parambody, default_charset); } public static string DoPost (httpsclient httpsclient, string url, map <string, string> paramheader, map <string, string> parambody, string charset) lança a exceção {string resultado = null; HttpPost httpPost = new httppost (url); setheader (httppost, paramheader); setBody (httppost, parambody, charset); Resposta HttpResponse = httpsclient.execute (httppost); if (ressentidade! = null) {httpentity ressentity = Response.getEntity (); if (ressentidade! = null) {resultado = entityutils.toString (ressentidade, charset); }} Retornar resultado; } public static string Doget (httpsclient httpsclient, string url, map <string, string> paramheader, map <string, string> parambody) lança exceção {return Doget (httpsclient, url, paramheader, parambody, default_charset); } public static string Doget (httpsclient httpsclient, string url, mapa <string, string> paramheader, map <string, string> parambody, string charset) lança a exceção {string resultado = null; Httpget httpget = new httpget (url); setheader (httpget, paramheader); Resposta HttpResponse = httpsclient.execute (httpget); if (resposta! = null) {httpentity ressentity = resposta.getEntity (); if (ressentidade! = null) {resultado = entityutils.toString (ressentidade, charset); }} Retornar resultado; } private estático void setheader (solicitação httPrequestBase, map <string, string> paramheader) {// Defina o cabeçalho if (paramHeader! = null) {set <string> keyset = paramHeader.keyset (); for (String Key: Keyset) {request.addheader (key, paramheader.get (key)); }}} private estático void setbody (httppost httppost, map <string, string> parambody, string charset) lança a exceção {// defina o parâmetro if (parambody! = null) {list <nameValuepair> list = new ArrayList <nameValuePair> (); Set <string> keyset = parambody.keyset (); para (String Key: Keyset) {list.add (new BasicNameValuepair (Key, parambody.get (key))); } if (list.size ()> 0) {urlencodedformentity entity = novo urlencodedformentity (list, charset); httppost.setentity (entidade); }}}} Depois, há a classe de teste:
pacote com.darren.test.https.v42; importar java.util.hashmap; importar java.util.map; classe pública httpsclienttest {public static void main (string [] args) lança exceção {httpsclient httpsclient = null; httpSclient = new HttpStrustClient (). Init (); // httpsclient = new httpScertifiedClient (). init (); String url = "https://1.2.6.2:8011/xxx/api/gettoken"; // string url = "https://1.2.6.2:8011/xxx/api/gethealth"; Mapa <string, string> paramheader = new hashmap <> (); //paramheader.put("Content-Type "," Application/JSON "); paramHeader.put ("aceitar", "aplicativo/xml"); Mapa <string, string> parambody = new hashmap <> (); parambody.put ("client_id", "[email protected]"); parambody.put ("client_secret", "p@ssword_1"); String resultado = httpsclientUtil.DOPOST (httpsclient, URL, paramheader, parambody); // string resultado = httpsclientUtil.Doget (httpsclient, url, null, null); System.out.println (resultado); }} Informações de retorno:
<? xml versão = "1.0" coding = "utf-8"?>
<Token> jkf8rl0sw+skkflj8rbki5hp1beqk8prcutzppbinqmykrmxy1kwcjmcft191zpp88vv1aghw8oynwjeys 0axplugax89ejcownbikcc1uvfyesxhlktcjqyUfivJevHreqxjphNClqywp+xSe5od9x8VKFKK7InntMrzqk7ybtz /e3U7GSWM/5CVAHFL6O9Req9CWPXAVZNOHYVNXSOHSZDO+BXATXXXA1XPELY/8H/UAP4N4DLZDJJ3B8T1XH+CRRIOM Opxf7c5wkhhtokeoexw+xopqkkksx5ckwwjppugiifwf/paqwg+juosvt7qgdpv8pmwj9dwewjtdxgudg == </token>
Nova versão 4.5.3
Necessidade de certificação
pacote com.darren.test.https.v45; importar java.io.file; importar java.io.fileInputStream; importar java.security.keystore; importar javax.net.ssl.ssslContext; importar org.apache.http.conn.ssl.ssslConnectionSocketFactory; importar org.apache.http.conn.ssl.ssslConnectionSocketFactory; importar org.apache.http.conn.sssl.trustes -selfSignedStrategy; importar org.apache.http.ssl.ssslContexts; classe pública HttpSCertifiedClient estende httpsclient {public httpsCertifiedClient () {} @Override public void prepareCertificate () lança exceção {// obtenha a Key Library keystore trustStore = keystore.getInstance (keystore.getDefaultTyPe (); FileInputStream Instruam = new FileInputStream (novo File ("c: /users/zhda6001/downloads/software/xxx.keystore"); // fileInputStream Instruam = new FileInputStream (novo File ("c: /users/zhda6001/downloads/xxx.keystore")); tente {// senha do Key Library TrustStore.load (Instream, "Senha" .ToCharArray ()); } finalmente {EnterStream.close (); } SslContext sslContext = sslContexts.custom (). LoadTrustMaterial (TrustStore, confidirSignedStrategy.instance) .build (); this.ConnectionSocketFactory = new SSLConnectionSocketFactory (SSLContext); }}Pule a certificação
pacote com.darren.test.https.v45; importar java.security.cert.certificateException; importar java.security.cert.x509Certificate; importar javax.net.ssl.ssslContext; importar javax.net.ssl.trustmanager; importar javax.net.ssl.x509TrustManager; importar org.apache.http.conn.ssl.ssslConnectionSocketFactory; classe pública httpstrustclient estende httpsclient {public httpstrustclient () {} @Override public void prepareCertificate () lança exceção {// pular verificação do certificado sslContext ctx = sslContext.getinstance ("tls"); X509TrustManager tm = new X509TrustManager () {@Override public void CheckClientTrusted (Chain de X509Certificate [], String Authtype) lança certificadoException {} @Override public void checkServerTrusted (x509Certificate [] Chain, string Authtype) X509Certificate [] getAcceptEdissuers () {return null; }}; // Defina como um certificado confiável ctx.init (null, new TrustManager [] {tm}, null); this.ConnectionSocketFactory = new SSLConnectionSocketFactory (CTX); }}Resumir
pacote com.darren.test.https.v45; importar org.apache.http.config.registry; importar org.apache.http.config.registryBuilder; importar org.apache.http.conn.socket.connectionSocketFactory; importar org.apache.http.conn.socket.plainConnectionSocketFactory; importar org.apache.http.impl.client.closeablehttpclient; importar org.apache.http.impl.client.httpclientbuilder; importar org.apache.http.impl.client.httpclients; importar org.apache.http.impl.conn.poolinghttpclientConnectionManager; Classe de abstração pública httpsclient estende httpclientbuilder {private closablehttpclient Client; ConnectionsocketFactory protegido ConnectionsocketFactory; / ** * Inicialize httpsclient * * @return retorna a instância atual * @throws Exception */ public CloseableHttpClient init () lança exceção {this.PreparECertificate (); this.regist (); retornar este.client; } / ** * Prepare a verificação do certificado * * @THOWSOWS Exceção * / public Resumo void prepareCertificate () lança exceção; / *** Registrar protocolo e porta, esse método também pode ser reescrito por subclasses*/ Protected void Regist () {// Defina o objeto correspondente ao protocolo http e https que lida com o soquete de link de link de fábrica <CnectionsCocketFactory> socketFactory = RegistryBuilder. PlainConnectionSocketFactory.Instance) .Register ("https", this.connectionSocketFactory) .build (); PoolingHttpClientConnectionManager ConnManager = novo PoolingHttpClientConnectionManager (SocketFactoryRegistry); Httpclients.custom (). SetConnectionManager (ConnManager); // Crie um objeto httpclient personalizado this.client = httpclients.custom (). SetConnectionManager (ConnManager) .build (); // ClienthttpClient client = httpclients.createFault (); }} Ferramentas:
pacote com.darren.test.https.v45; importar java.util.arraylist; importar java.util.list; importar java.util.map; importar java.util.set; importar org.apache.http.httpentity; importar org.apache.http.httpResponse; importar org.apache.http.nameValuepair; importar org.apache.http.client.httpclient; importar org.apache.http.client.entity.urlencodedFormentity; importar org.apache.http.client.methods.httpget; importar org.apache.http.client.methods.httppost; importar org.apache.http.client.methods.httprequestBase; importar org.apache.http.message.basicnameValuepair; importar org.apache.http.util.entityutils; classe pública httpsclientutil {private static final string default_charset = "utf-8"; public static string doPost (httpclient httpclient, string url, map <string, string> paramheader, map <string, string> parambody) lança a exceção {return DoPost (httpClient, url, paramheader, parambody, default_charset); } public static string DoPost (httpclient httpclient, string url, map <string, string> paramheader, map <string, string> parambody, string charset) lança exceção {string resultado = null; HttpPost httpPost = new httppost (url); setheader (httppost, paramheader); setBody (httppost, parambody, charset); Resposta HttpResponse = httpClient.execute (httppost); if (ressentidade! = null) {httpentity ressentity = Response.getEntity (); if (ressentidade! = null) {resultado = entityutils.toString (ressentidade, charset); }} Retornar resultado; } public static string Doget (httpclient httpclient, string url, map <string, string> paramheader, map <string, string> parambody) lança a exceção {return Doget (httpclient, url, paramheader, parambody, default_charset); } public static string Doget (httpclient httpclient, string url, map <string, string> paramheader, map <string, string> parambody, string charset) lança exceção {string resultado = null; Httpget httpget = new httpget (url); setheader (httpget, paramheader); Httproponse Response = httpclient.execute (httpget); if (resposta! = null) {httpentity ressentity = resposta.getEntity (); if (ressentidade! = null) {resultado = entityutils.toString (ressentidade, charset); }} Retornar resultado; } private estático void setheader (solicitação httPrequestBase, map <string, string> paramheader) {// Defina o cabeçalho if (paramHeader! = null) {set <string> keyset = paramHeader.keyset (); for (String Key: Keyset) {request.addheader (key, paramheader.get (key)); }}} private estático void setbody (httppost httppost, map <string, string> parambody, string charset) lança a exceção {// defina o parâmetro if (parambody! = null) {list <nameValuepair> list = new ArrayList <nameValuePair> (); Set <string> keyset = parambody.keyset (); para (String Key: Keyset) {list.add (new BasicNameValuepair (Key, parambody.get (key))); } if (list.size ()> 0) {urlencodedformentity entity = novo urlencodedformentity (list, charset); httppost.setentity (entidade); }}}}}} Classe de teste:
pacote com.darren.test.https.v45; importar java.util.hashmap; importar java.util.map; importar org.apache.http.client.httpclient; classe pública httpsclienttest {public static void main (string [] args) lança exceção {httpclient httpclient = null; // httpClient = new HttpStrustClient (). Init (); httpClient = novo httpsCertifiedClient (). init (); String url = "https://1.2.6.2:8011/xxx/api/gettoken"; // string url = "https://1.2.6.2:8011/xxx/api/gethealth"; Mapa <string, string> paramheader = new hashmap <> (); paramHeader.put ("aceitar", "aplicativo/xml"); Mapa <string, string> parambody = new hashmap <> (); parambody.put ("client_id", "[email protected]"); parambody.put ("client_secret", "p@ssword_1"); String resultado = httpsclientUtil.DOPOST (httpClient, URL, paramheader, parambody); // string resultado = httpsclientUtil.Doget (httpsclient, url, null, null); System.out.println (resultado); }} resultado:
<? xml versão = "1.0" coding = "utf-8"?>
<Token> rxitf9 // 7nxwxjs2cjijyhltvzunvmzxxeqtgn0u07sc9ysjeibpqte3hcjulskoxpeuyguveyi9jv7/wi klrzxykc3ospatsm0kcbckphu0tb2cn/nfzv9fmlueowfbdyz+n0seii9k+0gp7920dfencn17wujvmc0u2jwvm5fa JQKMILWODXZ6A0DQ+D7DQDJWVCWXBVJ2ILHYIB3PR805VPPPMI9ATXRVAKO0ODA006WEJFOFCGYG5P70WPJ5RBL85V fY9WCVKD1R7J6NVJHXGH2GNIMHKJEJORMJDXW2GKIUSIWSELI/XPSWAO7/CTWNWTNCTGK8PX2ZUB0ZFA == </Token>
2. HttpurlConnection
3. RestTemplate da primavera
Outros métodos serão complementados mais tarde
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.