Escreva na frente
Este artigo foi escrito em formato de Markdown. É a primeira vez que escrevi isso. O layout pode ser um pouco confuso, e espero que você possa perdoá -lo.
Ele escreve principalmente que usa fita para fazer solicitações de repouso, testar o uso de vários métodos, o código é relativamente redundante, o que é mais adequado para iniciantes, então eu me importo em dar um esguicho. Obrigado.
premissa
NOTA: No artigo, você precisa atualizar a versão parente-iniciante da primavera para 1.5.9..
Sugestão: Cada aplicativo de microsserviço possui seu próprio Spring-Boot-Maven-Plugin e Maven-Compiler-Plugin e especifica que a versão compilada do JDK é 1.8. O método de especificação é o seguinte: adicione -o em pom.xml
<FUBRIDO> <lugins> <flugin> <puperid> org.springframework.boot </frugiD> <ArtifactId> Spring-boot-maven-plugin </stutifactId> </flugin> <tlugin> <purtId> orgache.maven.Pluguns </GroupId> <stiftId> skorn> snavenpache.maven.Plugum </GroupId> <stiftIm> senhorid> snaven-seng.apache. <OrceM> 1.8 </sourder> <voget> 1.8 </garet> </frifiguration> </plugin> </plugins> </fuild>
Construção do projeto de teste
Centro de Registro de Eureka: Provedor de Serviços de Estabelecimento do Centro de Referência: Provedor de Serviço de Referência de Referência Provedor de Serviço
Consumidores de fita: descoberta e consumo de serviço de referência
Depois que o projeto for construído, lembre -se de seguir o arquivo de hosts de configuração mencionado nesses tutoriais.
Para impedir que o pedido de solicitação no projeto seja o mesmo, excluiremos todas as classes de controlador (provedores de serviços e consumidores). Em seguida, encapsularei cada método repousante em uma aula para que todos visam
Obtenha solicitação
GetForentity: Este método possui três formulários de sobrecarga, a saber:
NOTA: Este método retorna um objeto de wrapper ResponseEntity <T> onde t é o responsável pela responsabilidade passada no tipo. Se você deseja obter o tipo de retorno, precisará usar o método getBody () deste objeto Wrapper.
GetForObject: Este método também possui três formulários sobrecarregados, o mesmo que o método GetForentity:
Nota: o tipo de objeto retornado por este método é o responsável pelo tipo passado no tipo
Para a conveniência dos testes, a mesma classe de usuário é fornecida no provedor de serviços e no consumidor de serviço, respectivamente, por conveniência dos testes
pacote com.cnblogs.hellxz;/** * POJO para teste */public class User {private string Name; sexo privado de cordas; telefone de corda privada; public user () {} public user (nome da string, sexo de string, string telefon) {this.name = name; this.sex = sexo; this.phone = telefone; } public string tostring () {return "user: {" + "nome:" + nome + "," + "sexo:" + sexo + "," + "telefone:" + telefone + "}"; } public string getName () {return name; } public void setName (nome da string) {this.name = name; } public string getSex () {return Sex; } public void SetSex (sexo de string) {this.sex = sexo; } public string getphone () {return telefone; } public void setPhone (string telefone) {this.phone = telefone; }}Abaixo, criamos um getRequestController no provedor de serviços
pacote com.cnblogs.hellxz; importar org.apache.log4j.logger; importar org.springframework.beans.factory.annotation.autowired; importação org.springframework.cllient.client.serviceInstance; importar org.springframework.cloud.client.client.client.ServiceInstance; importação; org.springframework.web.bind.annotation.*;/*** @Author: Hellxz* @Description: provedor de serviços* @Date: 2018/4/18 11:36*/ @RestControllerpublic Class getRequestController {@autowired private DiscoverClient; // Injetar o cliente Discovery Private Final Logger = Logger.getLogger (getRequestController.class); /** * Vá Straight Test */@getMapp (value = "/hello") public string hello () {// obtenha a instância de serviço, e a função é exibir o efeito do console posterior serviçoInstance ServiceInstance = client.getLocalServiceInstance (); logger.info ("/hello host:"+serviceInstance.gethost ()+"service_id:"+serviceInstance.getServiceId ()); retornar "Olá"; }/** * Teste de parâmetro */@getMapping (value = "/greet/{dd}") public string greet (@Pathvariable string dd) {serviceInstance ServiceInstance = client.getLocalServiceInstance (); logger.info ("/hello host:"+serviceInstance.gethost ()+"service_id:"+serviceInstance.getServiceId ()); retornar "Hello"+DD; }/*** Retorne o objeto de teste*/@getMapping ("/user") public user getUser () {ServiceInstance ServiceInstance = clientLocalServiceInstance (); logger.info ("/user"+serviceInstance.gethost ()+"porta:"+serviceInstance.getport ()+"ServiceInstanceId:"+ServiceInstance.getServiceId ()); retornar novo usuário ("Hellxz", "masculino", "123456789"); }/*** Retorne o objeto de acordo com o nome, e a operação de pesquisa de banco de dados é simulada aqui*/@getMapping ("/user/{name}") public user getUserSerselect (@pathvariable string nome) {serviceInstance ServiceInstance = clientLocalServiceInstance (); logger.info ("/user"+serviceInstance.gethost ()+"porta:"+serviceInstance.getport ()+"ServiceInstanceId:"+ServiceInstance.getServiceId ()); if (name.isempty ()) {return new user (); } else if (name.equals ("hellxz")) {return novo usuário ("hellxz", "masculino", "123456789"); } else {return novo usuário ("usuário aleatório", "masculino", "987654321"); }}}Em seguida, criamos um GetRequestController no Projeto de Consumidor de Serviço
pacote com.cnblogs.hellxz; importar org.apache.log4j.logger; importar org.springframework.beans.factory.annotation.autowired; importar org.springframework.http.Responseentity; importação. org.springframework.web.client.resttemplate; importar org.springframework.web.util.uricomponents; importar org.springframework.web.util.uricomentsbuilder; imporjAvA.net.uri; import.util.hashmmap; Hellxz * @Description: Ribbon Consumer Application Controller, Get Request * @Date: 2018/4/16 15:54 */ @RestControllerPublic Classe getRequestController {private Logger = Logger.getLogger (getRequestController.class); @AUTOWIRED // injetar RestTemplate privado RestTemplate Resttemplate; /** * ResponseEntity<T> getForEntity(String url, Class<T> responseType) * T getBody() The following method is the same */ @GetMapping(value="/entity/noparam") public String noParamGetForEntity(){ //Commented here because I took it out of this way because I used the interface of the straight-chain access service provider, so that the result will not be returned, and an error will be reported // Return RestTemplate.getForentity ("http: // localhost: 8080/hello", string.class) .getbody (); // Use Resttemplate para chamar a interface do microsserviço Retornar RestTemplate.getForentity ("http: // hello-service/hello", string.class) .getbody (); }/** * Responsabilidade <T> GetForentity (URL da String, classe <T> ResponseType, Object ... Urivariables) */@getMapping ("/entity/type") public user getForEntityByByTyPe () {// Retornar o resultado do tipo especificado sem a resposta do parâmetro (UserTyTerity = Restrent = Restement. User.class); Corpo do usuário = entity.getbody (); Logger.info ("Usuário:"+corpo); corpo de retorno; // O acima pode ser abreviado como // Return RestTemplate.getForentity ("http: // hello -service/user", user.class) .getbody (); }/** * Responsabilidade <T> GetForEntity (URL da String, classe <T> ResponseType, Object ... urivariable) * Use espaços espanhóis para substituir os parâmetros e usar o método String.Format Internamente para implementar */@getMapping (value = "/entidade") // O parâmetro recebido é usado sem o uso? Se sim, use @pathvariable, caso contrário, use @RequestParam public String getForEntityByQuestionMarkParam (@RequestParam ("Name") Nome da String) {// O principal teste do método getentity, aqui, o String. (htttPert.TeSts). }/*** O método GetForEntity extrairá o mapa internamente, e o valor da chave de espaço reservado é o preenchimento no URL como um parâmetro* ResponseEntity <T> getForentity (string url, classe <t> ResponseType, map <string,? Use @RequestParam public String getForEntityByMap (@PathVariable ("Name") Nome da String) {// Os principais testes o método getentity, aqui testa o mapa mapa de parâmetros <string, string> reqmap = new hashmap (); reqmap.put ("nome", nome); Return RestTemplate.getForentity ("http: // hello -service/greet/{name}", string.class, reqmap) .getbody (); }/** * ResponseEntity <T> getForObject (URI URL, classe <T> ResponseType) */@getMapping ("/entity/uri") public string getForEntityByuri () {// Use URI para passar argumentos e acessar os uricompponentes = os uricompponentes = URICOMPONENTSBUILDER.Fromuristring ("http: // hello-service/greet/{name}") .build (). Expand ("laozhang") .encode (); Uri uri = uricomponents.Touri (); Return RestTemplate.getForEntity (URI, String.class) .getBody (); }/** * t GetForObject (String url, classe <T> ResponseType) */@getMapping ("/object") User public GetForObjectWithNoparam () {// comparado com o método getForEntity, obtendo o objeto omitia chamando getBody RESTTemplate.getObject ("htttp: // hello-hellog. }/** * t GetForObject (URL da String, classe <T> ResponseType, map <String ,?> urivariable) */@getMapping ("/object/map") public user getForObjectbyMap () {// use mapa para passar o mapa do parâmetro <string, string> parammap = new Hashmap <> (); parammap.put ("nome", "hellxz"); Return RestTemplate.getForObject ("http: // hello -service/user", user.class, parammap); }/** * t GetForObject (String url, classe <T> ResponseType, objeto ... urivariables) */@getMapping ("/object/param/{name}") public user getForObjectByParam (@PathVariable String Name) {Return RestTemplate.GetObject ("HttP: // hello-strert. }/** * t GetForObject (URI URL, classe <T> ResponseType) */@getMapping ("/object/uri/{name}") public user getForObjectByuri (@PathVariable String Name) {URICOMONENTs HTTPENENTS) .Build (). Expand (nome) .Encode (); Uri uri = uricomponents.Touri (); Return RestTemplate.getForObject (URI, User.class); }}Inicie o Centro de Registro e teste -o acessando a interface fornecida pelo consumidor. Tudo isso é realmente operado por mim, então não vou escrever um teste aqui.
Solicitação de postagem
Ambas as solicitações de postagem e a solicitação de get têm os métodos *Forentity e *forObject, onde a lista de parâmetros é um pouco diferente. Além desses dois métodos, há também um método de pós -formação, onde o pós -formação envia o recurso como uma solicitação de postagem e retorna o URI do novo recurso.
Pós -forentidade: Existem três formas sobrecarregadas desse método, a saber:
NOTA: Este método retorna um objeto de wrapper ResponseEntity <T> onde t é o responsável pela responsabilidade passada no tipo. Se você deseja obter o tipo de retorno, precisará usar o método getBody () deste objeto Wrapper.
PostForObject: Este método também possui três formulários de sobrecarga, que é o mesmo que o método pós -forentidade:
Nota: o tipo de objeto retornado por este método é o responsável pelo tipo passado no tipo
pós -conforto: Existem também três formulários de sobrecarga neste método, a saber:
Nota: Este método retorna o URI do novo recurso. A diferença entre métodos GetForEntity, GetForObject, Postforentity e PostForObject é que não há necessidade de especificar o tipo de retorno neste método, porque o tipo de retorno é o URI. Ainda exige que um espaço reservado passe argumentos através do objeto ... urivariáveis, mapa <string ,?> urivariáveis. Consulte a parte pós -forentidade do código.
De maneira anterior, criamos o PostReCeStControllers em projetos que fornecem prestadores de serviços e consumidores, respectivamente.
O seguinte código de serviço postrequestcontroller é o seguinte:
pacote com.shunneng.springcloudhelloworld; importar org.apache.log4j.logger; importar org.springframework.web.bind.annotation.*; import org.springframework.web.uticompponents; importar.springframework.web.utilil.uricomponents; importação.springframework.web.web.uticompponents; importação.springframework.web.web.uticompponents; java.net.uri;/** * @Author: Hellxz * @Description: * @Date: 2018/4/18 10:21 */ @RestControllerpublic Classe postrechestController {private logger = Logger.getLogger (postReCerestControlller.cliS; /*** Receba um objeto e devolva -o de volta. O método PostForEntity/PostForObject é comum*/@PostMapping ("/Usuário") Public User ReturnUserByPost (Usuário @RequestBody User) {Logger.info ("/Use Interface"+User); if (user == null) retorna novo usuário ("Este é um objeto vazio", "" "" "); devolver usuário; }/** * Teste os parâmetros do método PostForentity, você pode julgar diretamente a saída */@PostMapping ("/user/{str}") public user ReturnUserByPost (@PathVariable String str, @RequestBody User User) {Logger.info ("/User/algum parâmetro de paraméter:" if (user == null) retorna novo usuário ("Este é um objeto vazio", "" "" "); devolver usuário; }/** * Retorne Uri para o método pós-conforto */@PostMapping ("/location") public Uri Returnuri (usuário do @RequestBody User) {// simular um URL aqui, o local de recursos real pode não estar aqui) uricompponnts:/uricoments = URICOMENTSBUILDER.FromUristring ("httoming httPons: //roicoments = URICOMONTSBUILDER.Fromuristring (" htTer. .Build (). Expand (usuário) .Encode (); URI TURI = URICOMPONENTS.TOURI (); // Não sei qual é o problema aqui. Obviamente, é gerado, mas parece que Logger.info ("/Location Uri:"+Touri); devolver o Tourri; }}Consumidor Código PostReCeStController:
package com.cnblogs.hellxz;import org.apache.log4j.Logger;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.http.ResponseEntity;import org.springframework.web.bind.annotation.PostMapping;import org.springframework.web.bind.annotation.RestController;import org.springframework.web.client.RestTemplate;import org.springframework.web.util.UriComponents;import org.springframework.web.util.UriComponentsBuilder;import java.net.URI;/** * @Author: Hellxz * @Description: Ribbon Consumer Post Solicle Controller * @Date: 2018/4/18 9:47 */ @RestControllerPublic Class postrecheStController {private logger Logger = Logger.getLogger (PosTreCeSController.Class); @Autowired Private Resttemplate Resttemplate; /** * ResponseEntity <T> PostForentity (URL da String, Solicitação de Objeto, Classe <T> ResponseType) * O URL do parâmetro não é mencionado. Se a solicitação de objeto não for um objeto httpentity, ele será automaticamente convertido em um objeto httpentity e tratado como um corpo completo; * Se for um objeto httpentity, ele será processado diretamente como um corpo e contém o conteúdo do cabeçalho. * Não vou falar sobre o método de reescrita abaixo. O método de uso é aproximadamente o mesmo que Getforentity. Se for apenas um objeto de postagem simples, use o método sem objeto ... variáveis ou variáveis de mapa. * postForEntity(String url, Object request, Class<T> responseType, Object... uriVariables) * postForEntity(String url, Object request, Class<T> responseType, Map<String, ?> uriVariables) * * Here we will talk about the pitfalls I encountered in detail: * 1. The Object...variables and Map variables on the last edge of several other overloaded methods both operate on the previous url, * That is Para dizer, use os espaços reservados para passar os parâmetros no URL solicitado pelo Post e, se nenhum espaço reservado for usado no URL, esses parâmetros passados passados são inválidos! * 2. Se o objeto de solicitação de objeto no método tiver o mesmo tipo que o parâmetro de recebimento do provedor de serviços, o provedor de serviços precisará usar apenas @Requestbody para receber parâmetros. * 3. Se ambos forem usados, isso é mais interessante. Você precisa receber parâmetros no URI através da anotação @PathVariable e também precisa de @Requestbody para receber objetos ou solicitarparam para receber parâmetros de acordo com os campos! * 4. Se você relatar um erro, observe cuidadosamente os três itens que escrevi acima e preste atenção ao uso dos parâmetros e anotações do provedor de serviços. */ @PostMapping ("/ entity") public User PostForEntity () {Usuário Usuário = novo Usuário ("Hellxz1", "1", "678912345"); ResponseEntity <suser> entity = RestTemplate.PostForentity ("http: // hello -service/user/{str}", usuário, user.class, "parâmetros de teste"); Corpo do usuário = entity.getbody (); // TODOS O RESTTEMPLATE.*Os métodos da conclusão são classes de invólucro, e o corpo é o corpo de retorno do tipo de retorno; }/*** Passando parâmetros com URI, os resultados dos testes serão exibidos no terminal do provedor de serviços* ResponseEntity <T> Pós -forentidade (URI URL, solicitação de objeto, classe <T> ResponseType)*/@PostMapp ("ENTITY/URI") public User PostityByByURI () {User = User = User = User = User = User = User = User = User = User = User = User = Novo (ENTITY/URI ") public User", ", () 1; // Aqui, apenas convertemos o URL em um URI, e não há parâmetro adicionado uricomponents uricomponents = uricomponentsbuilder.fromuristring ("http: // hello -ervice/user") .build (). Encode (); URI TURI = URICOMPONENTS.TOURI (); // Use o usuário para passar o objeto de usuário do parâmetro = RestTemplate.PostForObject (Tourri, User, User.class); objeto de retorno; } /*** Ao testar o método PostForObject aqui, os parâmetros que precisam receber atenção são os descritos no método acima. A diferença é que você não precisa de getbody, então não vou elaborar aqui * PostForObject (URL da String, solicitação de objeto, classe <T> ResponseType, Object ... Urivariables) * PostForObject (String URL, Solicitação de Objeto, Classe <T> Responsety, Objeto ... Urivariables) * PostObject (string), Object, Classy, Classy, Classy, Responset, Responset, Responset, @PostMapping ("/Object") public User PostForObject () {Usuário Usuário = novo Usuário ("Hellxz2", "1", "123654987"); // aqui o URL passa 1 para chamar uma interface no projeto do servidor ResponseBody = RestTemplate.PostForObject ("http: // hello -service/user/1", usuário, usuário.class); resposta de resposta; } /*** Existe outro tipo de solicitação de postagem: pós -conforto. Há também três sobrecargas aqui. Além de não especificar o tipo de retorno, o uso é o mesmo, e o tipo de retorno é todo Uri, então não o descrevei * pós -formação (URL da String, solicitação de objeto, objeto ... urivariables) * PostForLocation (String url, solicitação de objeto, mapa <string,?> Urivariables) * PostLocation (Uri URL, Objeto Solicitação) */ Principation)/ @Pration (@Pration) (Url) (Url), solicitação de objeto, Map <String,? novo usuário ("hellxz3", "1", "987654321"); URI URI = RestTemplate.PostForLocation ("http: // hello-ervice/location", usuário); // Não sei por que está vazio. Este método é apenas para referência. Se eu souber qual é a situação, voltarei a alterar o Logger.info ("/Location URI:"+URI); retornar URI; }}Coloque solicitação e excluir solicitação
A solicitação de put é mais simples que os métodos GET e POST SOITOR. Não há necessidade de especificar o tipo de retorno da solicitação de put e, é claro, não há valor de retorno. São também três tipos de sobrecarga, que são basicamente os mesmos que antes. Não quero dizer mais aqui. A solicitação de exclusão e a solicitação de put não têm valor de retorno. Não importa se você o escreve especificamente aqui. Os métodos dessas duas solicitações estão listados separadamente. O código está escrito em uma classe.
O método de solicitação de put é o seguinte:
O método de solicitação de exclusão é o seguinte:
Adicione PutanddeleteRequestController ao projeto do fornecedor, o código é o seguinte
pacote com.cnblogs.hellxz; importar org.apache.log4j.logger; importar org.springframework.web.bind.annotation. *;/** * @author: hellxz * @description: provedor de serviços put & delete Controller * PUTANDDELETEREQUESTCONTROLLER {Private Logger Logger = Logger.getLogger (PUTANDDELETEREQUESTCONTROLLER.CLASS); @PutMapping ("/put") public void put (usuário do usuário @RequestBody) {Logger.info ("/put"+usuário); } @DeleTemapping ("/Delete/{id}") public void Delete (@PathVariable Long Id) {Logger.info ("/Delete ID:"+ID); }}Adicione PutanddeleteRequestController ao projeto do fornecedor, o código é o seguinte
pacote com.cnblogs.hellxz; importar org.apache.log4j.logger; importar org.springframework.beans.factory.annotation.autowired; import org.springframework.web.bind.annotation. @Description: Cut Request, Excluir solicitação, parâmetros sobrecarregados são basicamente os mesmos da demonstração acima e não serão listados * @date: 2018/4/19 13:43 */ @RestControllerPublic class (POSTREQUESTCONTROLLER {private Logger = Logger.GetLogger (PosTreCestControllRoller {private Logger = Logger.GetLogger (PosTequestControllTroller {private Logger = Logger.GetLogger (PosTequestControllTroller. @Autowired Private Resttemplate Resttemplate; /*** CUSTO OURMO DE SOLDA, geralmente as solicitações de colocar são usadas principalmente como modificação*/@putMapping ("/put") public void put (usuário do usuário do @RequestBody) {RestTemplate.put ("http: // hello-service/put", usuário); }/*** Exemplo de exclusão de solicitação*/@DeleTemapping ("/del/{id}") public void Delete (@PathVariable Long Id) {Resttemplate.Delete ("http: // hello-seerce/delete/{1}", id); }}Conclusão
Esta postagem do blog foi escrita usando o Markdown. Não sei como adicionar números de série e dobrar as funções de código ao bloco de código pela primeira vez. Pode não ser um bom artigo, mas escrevo esta postagem no blog há quase dois dias. Se você tiver boas sugestões, sinta -se à vontade para comentar e trocar.
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.