Vorne schreiben
Dieser Artikel ist im Markdown -Format geschrieben. Es ist das erste Mal, dass ich das schrieb. Das Layout kann ein bisschen chaotisch sein, und ich hoffe, Sie können es vergeben.
Es schreibt hauptsächlich, die ein Band verwenden, um erholsame Anfragen zu stellen, die Verwendung verschiedener Methoden zu testen. Der Code ist relativ überflüssig, was für Anfänger besser geeignet ist. Danke schön.
Prämisse
Hinweis: In dem Artikel müssen Sie die Spring-Boot-Starter-Eltern-Version auf 1.5.9.Realase oder höher aktualisieren (die Version 1.3.7.Release hat diese Annotationen nicht)
Vorschlag: Jede Microservice-Anwendung hat einen eigenen Spring-Boot-Maven-Plugin- und Maven-Compiler-Plugin und gibt an, dass die JDK-kompilierte Version 1,8 ist. Die Spezifikationsmethode lautet wie folgt: Fügen Sie sie in pom.xml hinzu
<build> <plugins> <plugin> <gruppeId> org.springFramework <quelle> 1.8 </source> <target> 1.8 </target> </configuration> </plugin> </plugins> </build>
Bauprojektkonstruktion
Eureka Registrierungszentrum: Referenzregistrierungszentrum Betriebsdienstleister: Referenzregistrierungsdienstleister
Bandverbraucher: Entdeckung und Konsum von Referenzdienstleistungen
Denken Sie nach dem Erstellen des Projekts daran, der in diesen Tutorials genannten Konfigurationshostdatei zu folgen.
Um zu verhindern, dass das RequestMapping im Projekt gleich ist, löschen wir alle Controller -Klassen (Dienstleister und Verbraucher). Als nächstes werde ich jede erholsame Methode in eine Klasse zusammenfassen, damit jeder es sich zeigt
Anfrage erhalten
GetForentity: Diese Methode hat drei Überlastformulare, nämlich:
HINWEIS: Diese Methode gibt ein Wrapper -Objekt -Antwortabschluss <T> zurück, wobei t der an Typ übergebene ResponseType ist. Wenn Sie den Rückgabetyp erhalten möchten, müssen Sie die Methode Getbody () dieses Wrapper -Objekts verwenden.
GetForObject: Diese Methode hat auch drei überlastete Formulare, was der GetForentity -Methode entspricht:
HINWEIS: Der nach dieser Methode zurückgegebene Objekttyp ist der ResponseType, der in Typ übergeben wurde
Für die Bequemlichkeit des Tests wird dieselbe Benutzerklasse im Dienstanbieter bzw. im Serviceverbraucher für die Bequemlichkeit des Tests bereitgestellt
Paket com.cnblogs.hellxz;/** * pojo zum testen */public class user {private Zeichenfolge Name; privater String Sex; privates String -Telefon; public user () {} public user (String -Name, String Sex, String -Telefon) {this.name = name; this.sex = sex; this.phone = Telefon; } public String toString () {return "user: {" + "name:" + name + "," + "sex:" + sex + "," + telefon: " + telefon +"} "; } public String getName () {return name; } public void setName (String -Name) {this.name = name; } public String getSex () {Return Sex; } public void setsex (String sex) {this.sex = sex; } public String getphone () {return telefon; } public void setPhone (String -Telefon) {this.phone = Telefon; }}Im Folgenden erstellen wir einen GetRequestController beim Dienstanbieter
Paket com.cnblogs.hellxz; import org.apache.log4j.logger; import org.springframework.bean.factory.Annotation.autowired; org.springframework.web.bind.annotation. // Inject Discovery Client Private Final Logger Logger = logger.getLogger (getRequestController.class) injizieren; /** * Gehen Sie gerade testen */@getmapping (value = "/hello") public String hello () {// Erhalten Sie die Serviceinstanz, und die Funktion besteht darin, die Wirkung der Konsolen später für serviceIntance zu zeigen. logger.info ("/hello host:"+serviceInstance.gethost ()+"service_id:"+serviceInstance.getServiceid ()); zurück "Hallo"; }/** * Parametertest */@getmapping (value = "/greet/{dd}") public String Greet (@PathVariable String dd) {serviceInstance serviceInstance = client.getLocalServiceInstance (); logger.info ("/hello host:"+serviceInstance.gethost ()+"service_id:"+serviceInstance.getServiceid ()); zurück "Hallo"+DD; }/*** das Testobjekt zurückgeben*/@getmapping ("/user") public user getUser () {serviceInstance serviceInstance = client.getLocalserviceInstance (); logger.info ("/user"+serviceInstance.gethost ()+"port:"+serviceInstance.getport ()+"serviceInstance:"+serviceInstance.getServiceid ()); Neuen Benutzer zurückgeben ("Hellxz", "männlich", "123456789"); }/*** Geben Sie das Objekt gemäß dem Namen zurück, und die Datenbanksuchoperation wird hier simuliert*/@getmapping ("/user/{name}") public user getUserSelect (@PathVariable String name) {serviceInstance serviceInstance = client.getlocalserviceInstance (); logger.info ("/user"+serviceInstance.gethost ()+"port:"+serviceInstance.getport ()+"serviceInstance:"+serviceInstance.getServiceid ()); if (name.isempty ()) {neuer Benutzer zurückgeben (); } else if (name.equals ("hellxz") {return New User ("HellXz", "männlich", "123456789"); } else {neuer Benutzer zurückgeben ("zufälliger Benutzer", "männlich", "987654321"); }}}Als nächstes erstellen wir einen GetRequestController im Service Consumer Project
Paket com.cnblogs.hellxz; import org.apache.log4j.logger; import org.springframework.beans.factory.Annotation.autowired; org.springframework.web.client.resttemplate; import org.springframework Hellxz * @Description: Ribbon Consumer Application Controller, Get Request * @Date: 2018/4/16 15:54 */ @rastControllerPublic -Klasse getRequestController {private logger logger = logger.getLogger (getRequestController.class); @Autowired // rastTemplate private rastTemplate rastTemplate inject; /** * Responseentity <T> GetForentity (String-URL, Klasse <T> Antworttyp) * T getBody () Die folgende Methode ist die gleiche */@getmapping (value = "/entity/noparam") Public String Noparamget-Verfassungszusatz () {// kommentierte hier, weil ich es hier verwendet habe. gemeldet // retemplate zurückgeben.getForentity ("http: // localhost: 8080/hello", string.class) .getBody (); // RastTemplate verwenden, um die MicroService-Schnittstelle zurückzurufen, retaReTemplate.GetForentity ("http: // hello-service/hello", string.class) .getBody (); }/** * Responseentity <T> GetForentity (String -URL, Klasse <T> Antworttyp, Objekt ... Urivariables) */@getmaping ("/entity/type") öffentlicher Benutzer getForentityIdentifyByType () {// das Ergebnis des angegebenen Typs zurückgeben, ohne die Parameter -Antwort zu übergeben <Benutzer> usw. restTemplate.getForentity ("http: // hello-service/user", user.class); User body = entity.getBody (); logger.info ("Benutzer:"+body); Rückkehrkörper; // Das obige kann als // restTemplate.getForentity zurückgegeben werden ("http: // hello-service/user", user.class) .getBody (); }/** * Responseentity <T> GetForentity (String -URL, Klasse <T> Antworttyp, Objekt ... Urivariablen) * Verwenden Sie Platzhalter, um die Parameter zu ersetzen, und verwenden Sie die String.Format -Methode intern, um */@getMapping (value = "/entity") // zu verwenden, wenn der empfangene Parameter ohne IT verwendet wird? Wenn ja, verwenden Sie @PathVariable, ansonsten verwenden Sie @RequestParam public String getForentityByQuestionmarkparam (@RequestParam ("Name") String-Name) {// Die Haupttests Die GetEntity-Methode, hier übergibt der Test direkt den Parameter retastemplate.getCorentity ("http: // Haer-service/{1 {1 {1 {1 {1 {1}",. }/*** Die GetForentity -Methode extrahiert die Karte intern, und der Wert des Platzhalterschlüssels wird in die URL als Parameter* Responseentity <T> GetForentity (String -URL, Klasse <T> reagieren, map <String,?> Urivariables)*/@getmaping (Value). Verwenden Sie @RequestParam public String getForentityByMap (@PathVariable ("Name") String -Name) {// Die Haupttests Die GetEntity -Methode, hier testet die MAP -Parameterkarte <String, String> reqmap = new Hashmap (); reqmap.put ("name", name); restTemplate.getForentity zurückgeben ("http: // hello-service/greet/{name}", string.class, reqmap) .getBody (); }/** * Responseentity <T> getForObject (URI -URL, Klasse <T> Antworttyp) */@getmapping ("/entity/uri") public String getForentityByURI () {// Verwenden Sie URI, um Argumente zu übergeben und zugreifen zu VIRICOMPONENTS URICOMPONENTS = URicomponentsBuilder.fromuristing ("http: // hello-serd/greet/{name}") .build (). Expt ("laozhang") .encode (); URI URI = Uricomponents.touri (); retRestTemplate.getForentity (URI, String.Class) .getBody (); }/** * T getForObject (String-URL, Klasse <T> Reaktions-Reaktions-Type) */@getmapping ("/Objekt") öffentlicher Benutzer getForObjectWithnoparam () {// im Vergleich zur GetForentity-Methode, das Objekt kann das Ret-Body-Ret-Retemplate abrufen. }/** * T getForObject (String -URL, Klasse <T> Antworttyp, Karte <String,?> Urivariables) */@getmaping ("/Object/map") öffentlicher Benutzer getForObjectByMap () {// MAP verwenden, um die Parameterkarte <String, String> Parammap = new Hashmap <> () zu übergeben; parammap.put ("name", "hellxz"); restTemplate.getForObject zurückgeben ("http: // hello-service/user", user.class, parammap); }/** * T getForObject (String-URL, Klasse <T> Antworttyp, Objekt ... Urivariablen) */@getmapping ("/Object/Param/{Name}") public user getForObjectByparam (@PathVariable-Name) {return restTemplate.getFector. "http. }/** * T getForObject (URI-URL, Klasse <T> Antworttyp) */@getmapping ("/Object/Uri/{Name}") public User getForObjectByUri (@patpathvariable String name) {Uricomponents uRicomponents = Uricomponentbuilder.Fromuristring ("http: // // Hello-Sieben-Sieben-Sieben-Sieben-Sieben-Sieben-Sieben-Sieben-Sieben-Sieben-Sieben-Sieben-Sieben-Sieben-Sieben-Sieben-Sieben-Sieben-Sieben-Sieben-Sieben-Sieben-Sieben-Sieben-Sieben-Sieben-Sieben-Siebenwechsel (" Http. .build (). expand (name) .eCode (); URI URI = Uricomponents.touri (); restTemplate.getForObject (URI, user.class) zurückgeben; }}Starten Sie zunächst das Registrierungszentrum und testen Sie es, indem Sie auf die vom Verbraucher bereitgestellte Schnittstelle zugreifen. Diese werden alle tatsächlich von mir betrieben, daher werde ich hier keinen Test schreiben.
Postanfrage
Sowohl die Postanforderung als auch die GET -Anforderung haben die Methoden für FORENTITY- und *Forobject, wobei die Parameterliste etwas unterschiedlich ist. Zusätzlich zu diesen beiden Methoden gibt es auch eine Postforlocationsmethode, bei der Postforlocation die Ressource als Postanforderung einreicht und die URI der neuen Ressource zurückgibt.
Postdorentity: Es gibt drei überlastete Formen dieser Methode, nämlich:
HINWEIS: Diese Methode gibt ein Wrapper -Objekt -Antwortabschluss <T> zurück, wobei t der an Typ übergebene ResponseType ist. Wenn Sie den Rückgabetyp erhalten möchten, müssen Sie die Methode Getbody () dieses Wrapper -Objekts verwenden.
postForObject: Diese Methode hat auch drei Überlastformulare, was der Postforentity -Methode entspricht:
HINWEIS: Der nach dieser Methode zurückgegebene Objekttyp ist der ResponseType, der in Typ übergeben wurde
PostForLocation: In dieser Methode gibt es auch drei Überlastformulare, nämlich:
Hinweis: Diese Methode gibt den URI der neuen Ressource zurück. Der Unterschied zwischen GetForentity, GetForObject, Postforentity und PostForObject -Methoden besteht darin, dass der Rückgabetyp in dieser Methode nicht angeben muss, da der Rückgabetyp der URI ist. Es ist immer noch erforderlich, dass ein Platzhalter Argumente durch Objekt übergeben ... Urivariablen, Karte <String,?> Urivariablen. Siehe den Teil des Codes.
In der vorherigen Weise haben wir postrequestController in Projekten erstellt, die Serviceanbietern und Verbrauchern anbieten.
Der folgende Service -PostrequestController -Code lautet wie folgt:
Paket com.shunneng.springcloudHelloworld; import org.apache.log4j.logger; import org.springframework.web.bind.Annotation. java.net.uri;/** * @Author: hellxz * @Description: * @Date: 2018/4/18 10:21 */ @rastControllerPublic class postrequestController {private logger logger = logger.getLogger (postrequestController.class); /*** Empfangen Sie ein Objekt und geben Sie es zurück. Die Methode postforentity/postForObject ist üblich*/@PostMapping ("//user") public user returnUserBypost (@RequestBody -Benutzer) {logger.info ("/verwenden Sie die Schnittstelle"+Benutzer); if (user == null) geben einen neuen Benutzer zurück ("Dies ist ein leeres Objekt", "", ""); Benutzer zurückgeben; }/** * Testen Sie die Parameter der Postforentity -Methode, Sie können die Ausgabe direkt beurteilen */@postmapping ("/user/{str}") öffentlicher Benutzer returnUserBypost (@PathVariable String String Str, @RequestBody User) {logger.info ("/user/sonparam Interface Interface -Parametername:"+st+user). if (user == null) geben einen neuen Benutzer zurück ("Dies ist ein leeres Objekt", "", ""); Benutzer zurückgeben; }/** * URI für die PostForLocations-Methode zurückgeben */@Postmapping ("/location") public uri returnuri (@RequestBody-Benutzer) {// Simulieren Sie hier eine URL. .build (). Expand (Benutzer) .Codode (); URI touri = Haricomponents.touri (); // Ich weiß nicht, was das Problem hier ist. Es ist offensichtlich generiert, aber es scheint, dass logger.info ("/location uri:"+touri); Return Touri; }}Consumer postrequestController -Code:
Paket com.cnblogs.hellxz; import org.apache.log4j.logger; import org.springframework.bean.factory.Annotation.autowired; org.springframework.web.bind.annotation.restcontroller; import org.springframework @Author: hellxz * @Description: Ribbon Consumer Post Request Controller * @Date: 2018/4/18 9:47 */ @rastControllerPublic Class postrequestController {private logger logger = logger.getLogger (postrequestController.class); @Autowired Private rastTemplate rastTemplate; /** * Antwortentzündung <T> Postforentity (String -URL, Objektanforderung, Klasse <T> Antworttyp) * Die Parameter -URL wird nicht erwähnt. Wenn die Objektanforderung kein HTTPentity -Objekt ist, wird es automatisch in ein HTTPentity -Objekt umgewandelt und als vollständiger Körper behandelt. * Wenn es sich um ein Httpentity -Objekt handelt, wird es direkt als Körper verarbeitet und enthält den Headerinhalt. * Ich werde unten nicht über die Umschreiben -Methode sprechen. Die Verwendungsmethode entspricht ungefähr der GetForentity. Wenn es sich nur um ein einfaches Postobjekt handelt, verwenden Sie die Methode ohne Objekt ... Variablen oder Kartenvariablen. * Postforentity (String -URL, Objektanforderung, Klasse <T> Reaktionsbewegung, Objekt ... Urivariablen) * Postforentität (String -URL, Objektanforderung, Klasse <T> Reaktionsyp, Karte <string? Verwenden Sie Platzhalter, um Parameter in der von der Post angeforderten URL zu übergeben. Wenn in der URL keine Platzhalter verwendet werden, sind diese zuletzt bestandenen Parameter ungültig! * 2. Wenn das Objektanforderungsobjekt in der Methode den gleichen Typ wie der Empfangsparameter des Dienstanbieters hat, muss der Dienstanbieter nur @RequestBody verwenden, um Parameter zu empfangen. * 3. Wenn beide verwendet werden, ist dies interessanter. Sie müssen Parameter im URI über @PathVariable Annotation empfangen, und Sie müssen auch @RequestBody empfangen, um Objekte oder RequestParam zu empfangen, um Parameter entsprechend den Feldern zu empfangen! * 4. Wenn Sie einen Fehler melden, sehen Sie sich bitte die drei oben geschriebenen Elemente genauer an und achten Sie auf die Verwendung der Parameter und Anmerkungen des Dienstanbieters. */ @Postmapping ("/ entity") public user postforentity () {user user = new user ("hellxz1", "1", "678912345"); ResponseEntity <Bener> Entity = restTemplate.postForentity ("http: // hello-service/user/{str}", user, user.class, "Testparameter"); User body = entity.getBody (); // Alle RastTemplate.*Forentity -Methoden sind Wrapper -Klassen, und der Körper ist der Retyp -Objekt -Rückgabekörper; }/*** Parameter mit URI übergeben, werden die Testergebnisse im Terminal des Dienstanbieters angezeigt. Zhang "," 1 "," 678912345 "); // Hier konvertieren wir die URL einfach in einen URI, und es gibt keinen Parameter-Uricomponenten-Uricomponents = UricomponentsBuilder.FromUristring ("http: // hello-service/user") .build (). Encode (); URI touri = Haricomponents.touri (); // Benutzer verwenden, um das Parameter User Object = rastTemplate.postforObject (touri, user, user.class) zu übergeben. Objekt zurückgeben; } /*** Beim Testen der PostforObject -Methode sind die Parameter, auf die geachtet werden müssen, wie in der obigen Methode beschrieben. The difference is that you do not need getBody, so I will not elaborate here* postForObject(String url, Object request, Class<T> responseType, Object... uriVariables) * postForObject(String url, Object request, Class<T> responseType, Object... uriVariables) * postForObject(String url, Object request, Class<T> responseType, Map<String, ?> uriVariables) */ @Postmapping ("/Object") public user postforObject () {user user = new user ("hellxz2", "1", "123654987"); // Hier übergibt die URL 1, um eine Schnittstelle im Serverprojekt-Benutzer responsebody = rastTemplate.postforObject ("http: // hello-serd/user/1", user, user.class) aufzurufen. Return ResponseBody; } /*** Es gibt eine andere Art der Postanforderung: Postforlocation. Hier gibt es auch drei Überladungen. Zusätzlich zur Angabe des Rückgabetyps ist die Verwendung gleich, und der Rückgabetyp ist auch alles URI. Ich beschreibe ihn also nicht * postForLocation (String -URL, Objektanforderung, Objekt ... Urivariablen) * Postforlocation (String -URL, Objektanforderung, Map <String,?> Urivariables) * postForLocation (URI -URI -URI -URI, Objektanforderung) */ @posting). = neuer Benutzer ("Hellxz3", "1", "987654321"); URI URI = rastTemplate.postforLocation ("http: // hello-service/location", user); // Ich weiß nicht, warum es leer ist. Diese Methode dient nur als Referenz. Wenn ich weiß, wie die Situation ist, werde ich zurückkommen, um Logger zu ändern. Uri zurückgeben; }}Anfrage stellen und Anfrage löschen
Die Put -Anfrage ist einfacher als die Methoden zur Get and Post -Anfrage. Es ist nicht erforderlich, den Rückgabetyp der Put -Anforderung anzugeben, und natürlich gibt es keinen Rückgabewert. Es sind auch drei Arten von Überlastungen, die im Grunde genommen die gleichen sind wie die zuvor geschriebenen. Ich möchte hier nicht mehr sagen. Sowohl die Anforderung löschen als auch die Put -Anforderung haben keinen Rückgabewert. Es spielt keine Rolle, ob Sie es speziell hier schreiben. Die Methoden dieser beiden Anfragen werden separat aufgeführt. Der Code ist in einer Klasse geschrieben.
Die Put -Anforderungsmethode lautet wie folgt:
Die Anforderungsmethode löscht wie folgt:
Fügen Sie PutandDeletRequestController zum Provider -Projekt hinzu, der Code ist wie folgt
Paket com.cnblogs.hellxz; import org.apache.log4j.logger; import org.springframework.web.bind.annotation. PutandDeletRequestController {private logger logger = logger.getLogger (putandDeletRequestController.class); @Putmapping ("/put") public void put (@RequestBody -Benutzer) {logger.info ("/put"+user); } @DeletMapping ("/delete/{id}") public void delete (@PathVariable Long id) {logger.info ("/delete id:"+id); }}Fügen Sie PutandDeletRequestController zum Provider -Projekt hinzu, der Code ist wie folgt
Paket com.cnblogs.hellxz; import org.apache.log4j.logger; import org.springframework.beans.factory.Annotation.autowired; @Description: Stellen Sie die Anforderung an, löschen Sie die Anforderung, überladene Parameter sind im Grunde genommen die gleichen wie die oben genannte Demo und werden nicht aufgeführt. @Autowired Private rastTemplate rastTemplate; /*** PRAPT-Beispiel für Anforderung. In der Regel werden die Anforderungen meist als Änderung verwendet*/@putmapping ("/put") public void put (@RequestBody-Benutzer) {restTemplate.put ("http: // hello-service/put", Benutzer); }/*** Anforderungsbeispiel löschen*/@deletemapping ("/del/{id}") public void delete (@PathVariable Long id) {restTemplate.delete ("http: // hello-service/delete/{1}", id); }}Abschluss
Dieser Blog -Beitrag wird mit Markdown geschrieben. Ich weiß nicht, wie ich zum ersten Mal Seriennummern und Faltungscode -Funktionen zum Codeblock hinzufügen kann. Dies ist vielleicht kein guter Artikel, aber ich schreibe diesen Blog -Beitrag seit fast zwei Tagen. Wenn Sie gute Vorschläge haben, können Sie sich gerne kommentieren und austauschen.
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.