No design da interface REST, o uso de Resttemplate para teste de interface é um método comum, mas durante o uso, devido aos inúmeros métodos e parâmetros, muitos alunos confundiram as diferenças entre os métodos de envio de formulários e carga de carga. Além disso, o design da interface é diferente dos métodos de envio usados pelos navegadores tradicionais. Vários erros geralmente ocorrem, como 405 erros, ou os dados enviados não podem ser obtidos. As amostras de erro são as seguintes:
Exceção no thread "main" org.springframework.web.client.httpclientarexception: 405 Método não permitido
em org.springframework.web.client.defaultraSponsoErrorHandler.HandleError (DefaulTroSponseerrorHandler.java:63)
em org.springframework.web.client.resttemplate.HandleSponse (Resttemplate.java:700)
em org.springframework.web.client.resttemplate.doexecute (Resttemplate.java:653)
em org.springframework.web.client.resttemplate.execute (Resttemplate.java:613)
em org.springframework.web.client.resttemplate.exchange (Resttemplate.java:531)
1. Envie usando o método de troca
A troca pode executar os dois métodos de postagem e recebe, por isso é o mais amplamente utilizado e o uso é o seguinte:
String url = "http: // localhost/mirana-ee/app/login"; Resttemplate client = new Resttemplate (); httpheaders headers = new httpheaders (); // por favor, não altere este método de envio facilmente. Na maioria dos casos, o método de envio é o formulário de submissão. "username");params.add("password", "123456");HttpEntity<MultiValueMap<String, String>> requestEntity = new HttpEntity<MultiValueMap<String, String>>(params, headers);// Execute HTTP request ResponseEntity<String> response = client.exchange(url, HttpMethod.POST, requestEntity, String.class); // Resultado de saída System.out.println (Response.getBody ());2. Envie com pós -forentidade
A pós -forentidade é uma simplificação da troca e requer apenas a redução do parâmetro httpmethod.post, como segue:
// O código acima é exatamente o mesmo // você só precisa substituir o método de troca ResponseIntity <string> Response = client.postforentity (url, requestentity, string.class);
3. Sobre a diferença entre o envio do formulário e a carga útil
Nos parâmetros do método do controlador, se você alterar "@modelattribute" para "@requestbody" anotação, o método de envio no momento é o método de carga útil. O exemplo do código é o seguinte:
// Observe que @RequestBody AnoTation @RequestMapping (value = "/login", método = requestMethod.post, consumts = "Application/json") // nunca adicione @modelattribute @ModelAttribute será responsável), como a seguir, a seguinte // publicCount ( @requestbody @ModelAttribute) a conta). Data()); Conta de retorno;}
Mais uma vez, não adicione "@modelattribute" novamente, porque sua prioridade é relativamente alta, o sistema usará o formulário para analisar o conteúdo enviado.
Para o método da carga útil, o conteúdo enviado deve ser string e o cabeçalho deve ser definido como "Application/JSON". O exemplo é o seguinte:
// Solicitar endereço string url = "http: // localhost/mirana-ee/app/login"; Resttemplate client = new Resttemplate (); // Certifique-se de definir cabeçalhos mais stractos/stractty/strings/theattyTtpyTfen_Utfen_UtferftFeader8; ObjectMapperBjectMapper Mapper através da injeção do feijão = new ObjectMapper (); map <string, string> params = maps.newhashmap (); params.put ("nome de usuário", "inter"); params.put ("senha", "123456"); string = string.WriteValueastring (senha "; Httpentity <string> (value, cabeçalhos); // Execute a solicitação http ResponseIntity <Scrition> Response = client.postForentity (url, requestentity, string.class); System.out.println (Response.getBody ());Se o conteúdo não for enviado no modo String, o seguinte erro será definitivamente:
Exceção no thread "main" org.springframework.web.client.httpclientarexception: 400 Bad Solicy
em org.springframework.web.client.defaultraSponsoErrorHandler.HandleError (DefaulTroSponseerrorHandler.java:63)
em org.springframework.web.client.resttemplate.HandleSponse (Resttemplate.java:700)
em org.springframework.web.client.resttemplate.doexecute (Resttemplate.java:653)
em org.springframework.web.client.resttemplate.execute (Resttemplate.java:613)
em org.springframework.web.client.resttemplate.postforentity (Resttemplate.java:407)
Finalmente, deve -se enfatizar que os parâmetros de solicitação não podem ser obtidos através do @Requestbody. Se o código no servidor acima for alterado para o seguinte formato, você definitivamente não receberá os dados, mas o oposto será verdadeiro para o envio do formulário.
@RequestMapping (value = "/login", consumers = "Application/json", Method = requestMethod.post) Conta public GetAccount (conta @RequestBody Conta, httpServletRequest Request) {// você não deve obter o parameter value system.out.println (request.getParameter ("username);); conta.SetVersion (new Date ()); Conta de retorno;}4. Estrutura de httpentity
Httpentity é um encapsulamento de solicitações HTTP, que contém duas partes, cabeçalho e corpo. O cabeçalho é usado para definir o cabeçalho da solicitação e o corpo é usado para definir o corpo da solicitação, para que seu construtor seja o seguinte:
// valor é o corpo de solicitação // cabeçalho é o cabeçalho da solicitação httpentity <string> requestentity = new httpentity <string> (valor, cabeçalhos);
5. Httpentity e urivariáveis
No uso do Resttemplate, a httpentity é usada para passar valores específicos de parâmetros, enquanto os urivariáveis são usados para formatar o endereço HTTP em vez dos parâmetros de endereço. O uso correto é o seguinte:
// Adicione parâmetros de formatação Pathstring url = "http: // localhost/mirana-ee/app/{path}"; // Preparar parâmetros de formatação mapa <string, string> varparams = maps.newhashmap (); varparams.put ("path", "login"); client.postforentity (url, requestentity, string.class, varparams);6. Notas sobre httpmessageConverter
Em muitos exemplos on -line, descobri que muitas pessoas adicionaram httpmessageConverter para lidar com envios de carga útil, como segue:
// Não há necessidade de client.getMessageConverters (). Add (novo Mappingjackson2httpMessageConverter ()); client.getMessageConverters (). Add (novo StringhttpMessAgeconverter ());
Depois de verificar o código-fonte e depurar, descobri que o Resttemplate possui 7 tipos de httpmessageConverters, como segue:
1. Org.springframework.http.converter.bytearrayhttpmessageConverter
2. Org.springframework.http.converter.stringhttpmessageConverter
3. Org.springframework.http.converter.resourcehttpmessageConverter
4. Org.springframework.http.converter.xml.sourcehttpmessageConverter
5. Org.springframework.http.converter.support.allencompassingFormHttpMessAgeconverter
6. org.springframework.http.converter.xml.jaxb2rootelementhttpmessageConverter
7. org.springframework.http.converter.json.mappingjackson2httpmessageConverter
"`
para concluir
O RestTemplate pode simplificar bastante a dificuldade de enviar dados de formulário e vem com a função de converter dados JSON automaticamente. No entanto, somente entendendo a estrutura de composição da httpentity (cabeçalho e corpo) e entendendo as diferenças com os urivariáveis, podemos realmente entender seu uso.
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.