Écrire devant
Cet article est écrit au format Markdown. C'est la première fois que je écrit ceci. La disposition peut être un peu désordonnée et j'espère que vous pourrez le pardonner.
Il écrit principalement qui utilise le ruban pour faire des demandes de repos, tester l'utilisation de diverses méthodes, le code est relativement redondant, ce qui est plus adapté aux débutants, donc je me dérange de lui donner une giclée. Merci.
prémisse
Remarque: Dans l'article, vous devez mettre à niveau la version Spring-Boot-Starter-Parent à 1.5.9.9.RealEase ou au-dessus (la version 1.3.7.Release n'a pas ces annotations)
Suggestion: chaque application de microservice a son propre printemps-boot-maven-plugin et maven-compiler-plugin et spécifie que la version compilée JDK est 1.8. La méthode de spécification est la suivante: Ajoutez-le dans pom.xml
<fuild> <Glugins> <Glugin> <GroupId> org.springframework.boot </proupId> <Artifactid> printemps-boot-maven-Plugin </ artifactid> </glugin> <grannin> <proupId> org.apache.maven.plugins </prounid> <prigud> maven-compiler-plugin </ artifinere> maven-compiler-Plugin> <plifluence> maven-compiler-plugin </ artifipuration> maven-compiler-plugin </ artifinere> maven-compiler-plugin </ artifinere> maven-compiler-plugin> <pliflures <Source> 1.8 </Source> <Barget> 1.8 </ Target> </ Configuration> </ Plugin> </Glugins> </ Build>
Construction du projet de test
Centre d'enregistrement Eureka: Fournisseur de services d'établissement du centre d'enregistrement de référence: fournisseur de services d'enregistrement de référence
Consommations du ruban: découverte et consommation de services de référence
Une fois le projet construit, n'oubliez pas de suivre le fichier Hosts de configuration mentionné dans ces tutoriels.
Afin d'éviter que la mise en vedette du projet soit la même, nous supprimerons toutes les classes de contrôleur (fournisseurs de services et consommateurs). Ensuite, je résumerai chaque méthode Restful dans une classe pour que tout le monde puisse voir
Faire une demande
GetForEntity: cette méthode a trois formulaires de surcharge, à savoir:
Remarque: Cette méthode renvoie une réponse de réponse d'objet en wrapper <T> où t est le type de réponse passé en type. Si vous souhaitez obtenir le type de retour, vous devez utiliser la méthode getBody () de cet objet de wrapper.
GetForObject: Cette méthode a également trois formulaires surchargés, ce qui est le même que la méthode GetForEntity:
Remarque: le type d'objet renvoyé par cette méthode est la réponse transmise dans le type
Pour la commodité des tests, la même classe d'utilisateurs est fournie dans le fournisseur de services et le consommateur de services respectivement pour la commodité des tests
package com.cnblogs.hellxz; / ** * pojo pour les tests * / classe publique utilisateur {nom de chaîne privée; Sexe à cordes privées; téléphone de chaîne privé; Utilisateur public () {} Utilisateur public (nom de chaîne, String Sex, String Phone) {this.name = name; this.sex = sexe; this.phone = téléphone; } public String toString () {return "utilisateur: {" + "name:" + name + "," + "sexe:" + sexe + "," + "téléphone:" + téléphone + "}"; } public String getName () {Nom de retour; } public void setName (string name) {this.name = name; } public String getSEX () {return sexe; } public void setSex (String Sex) {this.sex = sexe; } public String gephone () {return téléphone; } public void setphone (String Phone) {this.phone = téléphone; }}Ci-dessous, nous créons un GetRequestController chez le fournisseur de services
package com.cnblogs.hellxz; import org.apache.log4j.logger; import org.springframework.beans.factory.annotation.autowired; import org.springframe.cloud.client.serviceinterance; import org.springframework.web.bind.annotation. *; / ** * @Author: Hellxz * @description: Provider de service * @Date: 2018/4/18 11:36 * / @ RESTControllerPublic Class GetRequestController {@Autowired Private DiscoverClient Client; // Inject Discovery Client Private Final Logger Logger = Logger.getLogger (getRequestController.class); / ** * Go Straight Test * / @getMapping (value = "/ hello") public String Hello () {// Obtenez l'instance de service, et la fonction est d'afficher l'effet de la console ultérieurement serviceInstance ServiceInstance = client.getLocalServiceInstance (); Logger.info ("/ Hello Host:" + ServiceInstance.Gethost () + "Service_id:" + ServiceInstance.getServiceId ()); retourner "bonjour"; } / ** * Test de paramètres * / @getMapping (value = "/ saluer / {dd}") public String Greall (@Pathvariable String dd) {ServiceInstance ServiceInstance = client.getLocalServiceInstance (); Logger.info ("/ Hello Host:" + ServiceInstance.Gethost () + "Service_id:" + ServiceInstance.getServiceId ()); retourner "bonjour" + dd; } / ** * Renvoie l'objet de test * / @getmapping ("/ user") Utilisateur public GetUser () {ServiceInstance ServiceInstance = client.getLocalServiceInstance (); Logger.info ("/ user" + serviceInstance.Gethost () + "Port:" + ServiceInstance.getport () + "ServiceInstanceId:" + ServiceInstance.getServiceId ()); Renvoie un nouvel utilisateur ("Hellxz", "Male", "123456789"); } / ** * Renvoie l'objet en fonction du nom, et l'opération de recherche de base de données est simulée ici * / @GetMapping ("/ user / {name}") Utilisateur public GetUserselect (@Pathvariable String Name) {ServiceInstance ServiceInstance = client.GetLocalServiceInstance (); Logger.info ("/ user" + serviceInstance.Gethost () + "Port:" + ServiceInstance.getport () + "ServiceInstanceId:" + ServiceInstance.getServiceId ()); if (name.isempty ()) {return nouvel utilisateur (); } else if (name.equals ("hellxz")) {return nouvel utilisateur ("hellxz", "mâle", "123456789"); } else {return nouvel utilisateur ("utilisateur aléatoire", "mâle", "987654321"); }}}Ensuite, nous créons un GetRequestController dans le projet de consommation de services
package com.cnblogs.hellxz; import org.apache.log4j.logger; import org.springframework.beans.factory.annotation.autowired; import org.springframework.http.annotation. org.springframework.web.client.resttemplate; import org.springframework.web.util.uricomponents; import org.springframework.web.util.uricomponentsbuilder; import java.net.uri; import java.util.hashmap; import java.util.map; * @Description: Ribbon Consumer Application Contrôleur, Get Request * @Date: 2018/4/16 15:54 * / @ RESTControllerPublic Class GetRequestController {private logger logger = logger.getLogger (getRequestController.class); @Autowired // Inject RestTemplate privé RestTemplate RestTemplate; / ** * Responsentity <T> getForENTITY (URL de chaîne, classe <T> ResponseType) * t getBody () La méthode suivante est la même chaîne publique * / @getMapping (value = "/ entité / noparam"). // return restTemplate.getForEntity ("http: // localhost: 8080 / bonjour", string.class) .getBody (); // Utilisez RestTemplate pour appeler l'interface MicroService return restTEmplate.getForEntity ("http: // hello-service / hello", string.class) .getBody (); } / ** * Responsentity <T> getForENTITY (URL de chaîne, classe <t> ResponseType, objet ... urivariables) * / @getmapping ("/ entité / type") Utilisateur public GetForentityIdentifyyPe () {// Renvoie le résultat du type spécifié sans passer le paramètre Répondify <User> ENVICE / RESTTEMPLATE.GetForentit User.class); User body = entity.getBody (); logger.info ("utilisateur:" + corps); corps de retour; // ci-dessus peut être abrégé en tant que // return restTEmplate.getForEntity ("http: // hello-service / user", user.class) .getBody (); } / ** * ResponseNtity <T> GetForEntity (URL de chaîne, classe <T> ResponseType, objet ... Urivariables) * Utilisez les lieux pour remplacer les paramètres, et utilisez la méthode String.Format en interne pour implémenter * / @getmapping (value = "/ entité") // Si le paramètre reçu est utilisé sans l'utiliser? Si c'est le cas, utilisez @pathvariable, sinon utilisez @RequestParam public String GetForENTITYBESTESTIONMarmParam (@RequestParam ("Name") Nom de la chaîne) {// Le principal tests la méthode de GetEntity, ici le test passe directement le paramètre RETOUR RESTTEMPLAY.GETFORENTITY (HTTPP: // Hello-Service / Gear } / ** * La méthode GetForentity extraire la carte en interne, et la valeur de la clé de placement est remboursé dans l'URL en tant que paramètre * Responsentity <T> GetForentity (URL de chaîne, classe <T> ResponseType, Map <String,?> Urivariables) * / @getMapping (Value = "/ Entity / Map / {Name}") // Si le paramètre reçu est utilisé, utilise @pathvar,} ") // Sinon, utilisez @RequestParam public String GetForENTITYBYMAP (@PathVariable ("Name") String Name) {// Le principal teste la méthode GetEntity, teste ici la carte du paramètre de la carte <String, String> reqmap = new HashMap (); reqmap.put ("name", nom); return restTemplate.getForentity ("http: // hello-service / salut / {name}", string.class, reqmap) .getBody (); } / ** * Responsentity <T> getForObject (URI URL, classe <T> ResponseType) * / @getMapping ("/ Entity / URI") public String GetForntityByuri () {// Utilisez URI pour passer les arguments et accéder aux uriccomponents uriccomponents = URICOMPONENTSBUILDER.FROMURISTRING ("http: // Hello-Service / Greall / {Name}") .Build (). Expand ("LaozHang") .encode (); Uri uri = uriccomponents.touri (); return restTemplate.getForentity (uri, string.class) .getBody (); } / ** * t getForObject (URL de chaîne, classe <T> ResponseType) * / @GetMapping ("/ Object") Utilisateur public GetForObjectWithnOparam () {// Par rapport à la méthode GetForENTITY, l'obtention de l'objet peut omettre CAPPORT return return.getemplate.getForObject ("http: // Hello-Service / User", user.class); } / ** * t getForObject (URL de chaîne, classe <T> ResponseType, map <string ,?> urivariables) * / @getmapping ("/ object / map") utilisateur public getForObjectBymap () {// Utiliser la carte pour passer le paramètre MAP <String, String> Parammap = new Hashmap <> (); Parammap.put ("Name", "Hellxz"); return restTemplate.getForObject ("http: // hello-service / user", user.class, parAmmap); } / ** * t getForObject (URL de chaîne, classe <T> ResponseType, objet ... Urivariables) * / @GetMapping ("/ Object / Param / {name}") Utilisateur public GetForObjectByParam (@Pathvariable String Name) {return resttemplate.getForObject ("http: //Lello-service / user / {name}", newclass); } / ** * t getForObject (URI URL, classe <T> ResponseType) * / @GetMapping ("/ Object / Uri / {name}") Utilisateur public GetForObjectByuri (@Pathvariable String Name) {Uricomponents UricOmponents = UricomponentsBuilder.FromuRistring ("http: //Lo-service /}") ")") .build (). Extend (name) .encode (); Uri uri = uriccomponents.touri (); return restTemplate.getForObject (uri, user.class); }}Commencez d'abord le centre d'enregistrement, puis testez-le en accédant à l'interface fournie par le consommateur. Ceux-ci sont tous exploités par moi, donc je n'écrirai pas de test ici.
Demande de poste
La demande publique et la demande de GET ont * les méthodes de la fance et * ForObject, où la liste des paramètres est quelque peu différente. En plus de ces deux méthodes, il existe également une méthode de post-forforlocation, où la post-forlocation soumet la ressource en tant que demande de poste et renvoie l'URI de la nouvelle ressource.
PostForntity: il existe trois formes surchargées de cette méthode, à savoir:
Remarque: Cette méthode renvoie une réponse de réponse d'objet en wrapper <T> où t est le type de réponse passé en type. Si vous souhaitez obtenir le type de retour, vous devez utiliser la méthode getBody () de cet objet de wrapper.
PostForObject: Cette méthode a également trois formulaires de surcharge, ce qui est le même que la méthode de la post-Forentity:
Remarque: le type d'objet renvoyé par cette méthode est la réponse transmise dans le type
Post-forlocation: Il existe également trois formulaires de surcharge dans cette méthode, à savoir:
Remarque: Cette méthode renvoie l'URI de la nouvelle ressource. La différence entre les méthodes GetForntity, GetForObject, PostForEntity et PostForObject est qu'il n'est pas nécessaire de spécifier le type de retour dans cette méthode, car le type de retour est l'URI. Il nécessite toujours un espace réservé pour passer des arguments via l'objet ... urivariables, map <string ,?> urivariables. Voir la partie post-Forentity du code.
De la manière précédente, nous avons créé des contrôles post-élaboration dans des projets qui fournissent respectivement les fournisseurs de services et les consommateurs.
Le code de service suivant PostReSeStController est le suivant:
package com.shunneng.springCloudHelloworld; import org.apache.log4j.logger; import org.springframework.web.bind.annotation. *; import org.springframework.web.util.uricomponents; import org.springframework.web.util.uricomponntsbuilder; java.net.uri; / ** * @author: hellxz * @description: * @date: 2018/4/18 10:21 * / @ restControllerPublic classe PostRequestController {private logger = logger.getLogger (postRequestController.class); / ** * Recevez un objet et renvoyez-le. La méthode PostForEntity / PostForObject est courante * / @postmapping ("/ utilisateur") Utilisateur public returnUserBypost (@Requestbody User utilisateur) {logger.info ("/ use interface" + utilisateur); if (user == null) renvoie un nouvel utilisateur ("Ceci est un objet vide", "", ""); RETOUR UTILISATEUR; } / ** * Testez les paramètres de la méthode PostForEntity, vous pouvez juger directement la sortie * / @postmapping ("/ user / {str}") Utilisateur public returnUserBypost (@Pathvariable String STR, @Requestbody User utilisateur) {Logger.info ("/ user / SomeParam Interface Nom:" + Str + "" + User); if (user == null) renvoie un nouvel utilisateur ("Ceci est un objet vide", "", ""); RETOUR UTILISATEUR; } / ** * RETOUR URI POUR LA MÉTHODE DE POSTFORLOCATION * / @postMapping ("/ Location") public uri returnUri (@Requestbody User utilisateur) {// Simuler une URL ici, le lieu de ressources réel peut ne pas être ici .build (). Extend (utilisateur) .Encode (); Uri touri = uriccomponents.touri (); // Je ne sais pas quel est le problème ici. Il est évidemment généré, mais il semble que Logger.info ("/ emplacement uri:" + touri); Retour au touri; }}CODE CONSUMER POSTREQUEST Controller:
package com.cnblogs.hellxz; import org.apache.log4j.logger; import org.springframework.beans.factory.annotation.autowired; import org.springframework.http.annotation.postmy org.springframework.web.bind.annotation.restController; import org.springframework.web.client.restTemplate; import org.springframework.web.util.uriConentsbuilder; : Hellxz * @Description: Ribbon Consumer Post Contrôleur * @Date: 2018/4/18 9:47 * / @ RESTControllerPublic Class PostRequestController {Private Logger Logger = Logger.getLogger (PostRequestController.Class); @Autowired Private RestTemplate RestTemplate; / ** * Responsentity <T> PostForEntity (URL de chaîne, demande d'objet, classe <T> ResponseType) * L'URL du paramètre n'est pas mentionné. Si la demande d'objet n'est pas un objet Httpentity, il sera automatiquement converti en un objet Httpentity et traité comme un corps complet; * S'il s'agit d'un objet httpentity, il sera traité directement en tant que corps et contient le contenu de l'en-tête. * Je ne parlerai pas de la méthode de réécriture ci-dessous. La méthode d'utilisation est à peu près la même que GetForentity. S'il s'agit juste d'un simple objet post, utilisez la méthode sans objet ... variables ou variables de carte. * PostForentity (URL de chaîne, demande d'objet, classe <T> ResponseType, objet ... Urivariables) * PostForEntity (URL de la chaîne, demande d'objet, classe <T> ResponseType, Map <String ,?> Urivariables) * * Ici, nous parlerons des pièges des pièges Disons, utilisez des espaces réservés pour passer les paramètres dans l'URL demandée par le poteau, et si aucun espace réservé n'est utilisé dans l'URL, ces derniers paramètres passés ne sont pas valides! * 2. Si l'objet de demande d'objet dans la méthode a le même type que le paramètre de réception du fournisseur de services, le fournisseur de services n'a besoin que d'utiliser @RequestBody pour recevoir des paramètres. * 3. Si les deux sont utilisés, c'est plus intéressant. Vous devez recevoir des paramètres dans l'URI via une annotation @pathvariable, et vous avez également besoin de @Requestbody pour recevoir des objets ou RequestParam pour recevoir des paramètres en fonction des champs! * 4. Si vous signalez une erreur, veuillez examiner de plus près les trois éléments que j'ai écrits ci-dessus et faire attention à l'utilisation des paramètres et annotations du fournisseur de services. * / @PostMapping ("/ Entity") public User PostForEntity () {User User = New User ("Hellxz1", "1", "678912345"); RéponseEntity <User> Entity = RestTemplate.PostForEntity ("http: // Hello-Service / User / {str}", user, user.class, "Test Paramètres"); User body = entity.getBody (); // All RestTemplate. * Les méthodes de fardeau sont des classes de wrapper, et le corps est le corps de retour de l'objet de type; } / ** * Passage des paramètres avec URI, les résultats du test seront affichés dans le terminal du fournisseur de service * Responsentity <T> PostForEntity (URL URL, demande d'objet, classe <T> ResponseType) * / @postmapping ("/ entité / uri") Userforentityyuri () {user = user = "Lao zhang", "1", "678912345") ")") ")") ". // Ici, nous convertissons l'URL en URI, et il n'y a pas de paramètre ajouté uriccomponents uriccomponents = uriComponentsBuilder.FromuRistring ("http: // hello-service / user") .build (). Encode (); Uri touri = uriccomponents.touri (); // Utiliser l'utilisateur pour passer le paramètre User Object = restTemplate.PostForObject (touri, user, user.class); retour objet; } / ** * Lors du test de la méthode PostForObject ici, les paramètres qui doivent être prêts attention sont tels que décrits dans la méthode ci-dessus. La différence est que vous n'avez pas besoin de getbody, donc je n'élaborerai pas ici * PostForObject (URL de chaîne, demande d'objet, classe <T> ResponseType, objet ... Urivariables) * PostForObject (URL de chaîne, demande d'objet, classe <T> ResponseType, objet ... Urivariables) * PostForObject (Url de chaîne, demande d'objet, classe <t> RéponseType, MAP @PostMapping ("/ Object") Utilisateur public PostForObject () {User User = New User ("Hellxz2", "1", "123654987"); // Ici, URL passe 1 pour appeler une interface dans le Project User ActionBody = RestTemplate.PostForObject ("http: // hello-service / user / 1", user, user.class); Retour ResponseBody; } / ** * Il existe un autre type de demande de poste: PostForLocation. Il y a aussi trois surcharges ici. En plus de ne pas spécifier le type de retour, l'utilisation est la même, et le type de retour est tout uri, donc je ne le décrirai pas * PostForLocation (URL de chaîne, demande d'objet, objet ... Urivariables) * PostForLocation (URL de chaîne, demande d'objet, Map <String Nouvel utilisateur ("Hellxz3", "1", "987654321"); Uri uri = restTEmplate.postForLocation ("http: // bonjour-service / emplacement", utilisateur); // Je ne sais pas pourquoi c'est vide. Cette méthode est pour référence uniquement. Si je sais quelle est la situation, je reviendrai pour modifier Logger.info ("/ emplacement uri:" + uri); retour uri; }}Posez la demande et supprimer la demande
La demande de put est plus simple que les méthodes GET et POST DEMANDE. Il n'est pas nécessaire de spécifier le type de retour de la demande de put, et bien sûr, il n'y a pas de valeur de retour. Il s'agit également de trois types de surcharges, qui sont fondamentalement les mêmes que celles écrites auparavant. Je ne veux pas en dire plus ici. La demande de suppression et la demande de put n'ont pas de valeur de retour. Peu importe que vous l'écrivez spécifiquement ici. Les méthodes de ces deux demandes sont répertoriées séparément. Le code est écrit dans une classe.
La méthode de la demande de put est la suivante:
La méthode de la demande de suppression est la suivante:
Ajouter putAnddeleteRequestController au projet de fournisseur, le code est le suivant
package com.cnblogs.hellxz; import org.apache.log4j.logger; import org.springframework.web.bind.annotation. *; / ** * @author: hellxz * @description: fournisseur de services put & @ resestrôler le contrôleur * @Date: 2018/4/19 14:11 * / @ reposTrollerPublic Class PutandDeterConConcestroller {private logger logger = logger.getLogger (putAndDeleTequestController.class); @Putmapping ("/ put") public void put (@Requestbody utilisateur utilisateur) {logger.info ("/ put" + utilisateur); } @Deletemapping ("/ delete / {id}") public void delete (@pathvariable long id) {logger.info ("/ delete id:" + id); }}Ajouter putAnddeleteRequestController au projet de fournisseur, le code est le suivant
Package com.cnblogs.hellxz; import org.apache.log4j.logger; import org.springframework.beans.factory.annotation.autowired; import org.springframework.web.bind.annotation. *; import org.springframework.web.client.restTemplate; / ** * @aror: @Description: demande de put, demande de suppression, paramètres surchargés sont fondamentalement les mêmes que la démo ci-dessus, et ne sera pas répertorié * @Date: 2018/4/19 13:43 * / @ restControllerPublic classe PutRequestController {private logger Logger = Logger.getLogger (PostReStController.Class); @Autowired Private RestTemplate RestTemplate; / ** * Exemple de demande de put, les demandes de put sont généralement utilisées comme modification * / @putmapping ("/ put") public void put (@Requestbody utilisateur utilisateur) {restTemplate.put ("http: // bonjour-service / put", utilisateur); } / ** * Delete de la demande Exemple * / @deletemapping ("/ del / {id}") public void delete (@pathvariable long id) {resttemplate.delete ("http: // hello-service / delete / {1}", id); }}Conclusion
Ce billet de blog est écrit en utilisant Markdown. Je ne sais pas comment ajouter les numéros de série et plier les fonctions de code au bloc de code pour la première fois. Ce n'est peut-être pas un bon article, mais j'écris ce billet de blog depuis près de deux jours. Si vous avez de bonnes suggestions, n'hésitez pas à commenter et échanger.
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.