Escribir en frente
Este artículo está escrito en formato de Markdown. Es la primera vez que escribí esto. El diseño puede ser un poco desordenado, y espero que puedas perdonarlo.
Principalmente escribe que usa cinta para realizar solicitudes de descanso, pruebe el uso de varios métodos, el código es relativamente redundante, lo que es más adecuado para principiantes, por lo que me importa darle un chorros. Gracias.
premisa
Nota: En el artículo, debe actualizar la versión de primavera-starter-starter-starter a 1.5.9.Realease o superior (la versión 1.3.7. Release no tiene estas anotaciones)
Sugerencia: cada aplicación de microservicio tiene su propio plugin de boot-boot-boot-boot-plugin y maven-compiler-plugin y especifica que la versión compilada de JDK es 1.8. El método de especificación es el siguiente: agrégalo en pom.xml
<DIARD> <GULTINS> <LEGLEMIN> <MOUMPROUD> org.springframework.boot </groupId> <artifactID> spring-boot-maven-plugin </artifactid> </plugin> <glugin> <grupoD> org.apache.maven.plugins </groupId> <artifactid> maven-compiler-plugin </artatheriM <Veed> 1.8 </fuente> <arget> 1.8 </target> </figuration> </glugin> </glugins> </build>
Construcción del proyecto de prueba
Centro de registro de Eureka: Proveedor de servicios de establecimiento del Centro de Registro de referencia: proveedor de servicios de registro de referencia
Consumidores de la cinta: descubrimiento y consumo del servicio de referencia
Una vez creado el proyecto, recuerde seguir el archivo de hosts de configuración mencionado en estos tutoriales.
Para evitar que la solicitud de solicitud en el proyecto sea el mismo, eliminaremos todas las clases de controladores (proveedores de servicios y consumidores). A continuación, encapsularé cada método de descanso en una clase para que todos lo vean
Obtener solicitud
GetForEntity: este método tiene tres formularios de sobrecarga, a saber:
NOTA: Este método devuelve un objeto de envoltura de respuesta al objeto <T> donde t es el tipo de respuesta aprobado en el tipo. Si desea obtener el tipo de retorno, debe usar el método getBody () de este objeto Wrapper.
GetForObject: este método también tiene tres formularios sobrecargados, que es el mismo que el método GetForEntity:
Nota: El tipo de objeto devuelto por este método es el tipo de respuesta que se pasa en el tipo
Para la conveniencia de las pruebas, se proporciona la misma clase de usuario en el proveedor de servicios y el consumidor de servicios respectivamente para la conveniencia de las pruebas
paquete com.cnblogs.hellxz;/** * POJO para probar */Public Class User {private String Name; sexo de cuerda privada; Teléfono de cadena privada; Public User () {} Public User (nombre de cadena, sexo de cadena, teléfono de cadena) {this.name = name; this.sex = sexo; this.phone = teléfono; } public String toString () {return "user: {" + "nombre:" + nombre + "," + "sexo:" + sexy + "," + "teléfono:" + teléfono + "}"; } public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = name; } public String getsex () {return sex; } public void setsex (sexo de cadena) {this.sex = sex; } public String getPhone () {return Phone; } public void setphone (teléfono de cadena) {this.phone = phone; }}A continuación creamos un GetRequestController en el proveedor de servicios
paquete com.cnblogs.hellxz; import org.apache.log4j.logger; import org.springframework.beans.factory.annotation.aUtowired; import org.springframework.cloud.client.serviceInstance; import og.spreingframework.cloud.cloud.discovery.discoverlient; org.springframework.web.bind.annotation.*;/*** @author: hellxz* @Description: Provider de servicios* @date: 2018/4/18 11:36*/ @RestControllerPublic Class GetRequestController {@Autowired Private DiscoverClient Client; // Inyect Discovery Client private final logger logger = logger.getLogger (getRequestController.class); /** * GO Test Right */@getMapping (value = "/Hello") public String Hello () {// Obtenga la instancia de servicio, y la función es para mostrar el efecto de la consola más tarde ServiceInstance ServiceInstance = Client.getLocalServiceInstance (); logger.info ("/Hello Host:"+ServiceInstance.gethost ()+"Service_id:"+ServiceInstance.getServiceId ()); devolver "hola"; }/** * prueba de parámetro */@getmapping (valor = "/salud/{dd}") public string greet (@PathVariable String dd) {ServiceInstance ServiceInstance = Client.getLocalServiceInstance (); logger.info ("/Hello Host:"+ServiceInstance.gethost ()+"Service_id:"+ServiceInstance.getServiceId ()); devolver "hola"+dd; }/*** Devuelve el objeto de prueba*/@getMapping ("/user") Public User getUser () {ServiceInStance ServiceInstance = Client.GetLocalServiceInstance (); logger.info ("/user"+ServiceInstance.gethost ()+"puerto:"+ServiceInstance.getPort ()+"ServiceInstanceId:"+ServiceInstance.getServiceId ()); devolver nuevo usuario ("Hellxz", "masculino", "123456789"); }/*** Devuelva el objeto de acuerdo con el nombre, y la operación de búsqueda de la base de datos se simula aquí*/@getmapping ("/user/{name}") Public User GetUsersElect (@PathVariable String Name) {ServiceInStance ServiceInstance = Client.getLocalServiceInstance (); logger.info ("/user"+ServiceInstance.gethost ()+"puerto:"+ServiceInstance.getPort ()+"ServiceInstanceId:"+ServiceInstance.getServiceId ()); if (name.isEmpty ()) {return new User (); } else if (name.equals ("hellxz")) {return new user ("hellxz", "masculino", "123456789"); } else {return nuevo usuario ("usuario aleatorio", "masculino", "987654321"); }}}A continuación, creamos un GetRequestController en el proyecto de consumo de servicio
paquete com.cnblogs.hellxz; importar org.apache.log4j.logger; import org.springframework.beans.factory.annotation.aUtowired; import org.springframework.http.esponseSentity; import og.springframework.web.bind.annotation.*; importación org.springframework.web.client.resttemplate; import org.springframework.web.util.uriComponents; import org.springframework.web.util.uricponentsBuilder; import java.net.uri; import java.util.hashmap; import java.util.map;/@author; * @Description: Ribbon Controlador de aplicaciones de consumo, obtenga solicitud * @Date: 2018/4/16 15:54 */ @RestControllerPublic GetRequestController {private logger logger = logger.getLogger (getRequestController.class); @AUtowired // inyect RestTemplate private RESTTEMPLATE RESTTemplate; /** * ResponseEntity <T> getForEntity (string url, class <t> ResponseType) * t getBody () El siguiente método es el mismo */@getMapping (valor = "/entidad/noparam") cadena pública noParAmgetForEntity () {// comenté aquí. // return RestTemplate.getForEntity ("http: // localhost: 8080/hello", string.class) .getBody (); // Use RestTemplate para llamar a la interfaz de microservicio return return ResttEmplate.getForSentity ("http: // hello-service/hello", string.class) .getBody (); }/** * ResponseEntity <T> getForEntity (String URL, class <T> ResponseType, Object ... urivariables) */@getmapping ("/entidad/type") Usuario público getForEntityIdentifyByType () {// Devuelve el resultado del tipo especificado sin aprobar la respuesta de parámetros <serement> entity = = = RestTemplate.getForEntity ("http: // hello-service/user", user.class); User Body = entity.getBody (); logger.info ("User:"+Body); cuerpo de regreso; // lo anterior se puede abreviar como // devuelve ResttEmplate.getForSentity ("http: // hello-service/user", user.class) .getBody (); }/** * ResponseEntity <T> getForEntity (String url, class <t> ResponseType, Object ... urivariables) * Use marcadores de posición para reemplazar los parámetros y use el método String.Format internamente para implementar */@getmapping (valor = "/entidad") // si el parámetro recibido se usa sin usarlo? Si es así, use @PathVariable, de lo contrario use @RequestParam public String getForentityByQuestionionMarkParam (@RequestParam ("Nombre") Nombre de cadena) {// El método principal de prueba el método getentity, aquí la prueba directamente pasa el parámetro de retorno de retorno.getForEntity ("http: // hello-service/gree/gree }/*** El método GetForEntity extraerá el mapa internamente, y el valor de la clave del marcador de posición se reflace en la URL como un parámetro* RespuestaSentity <T> getForEntity (String Url, class <T> ResponseType, map <String,?> Urivariables)*/@getMapping (valor = "/entidad/map/{name}") Use @RequestParam public String getForentityByMap (@PathVariable ("Nombre") Nombre de cadena) {// El principal prueba el método GetEntity, aquí prueba el mapa del parámetro del mapa <string, string> reqmap = new Hashmap (); reqmap.put ("nombre", nombre); return RestTemplate.getForEntity ("http: // hello-service/greet/{name}", string.class, reqmap) .getBody (); }/** * ResponseEntity <T> getForObject (uri url, class <t> ResponseType) */@getMapping ("/entidad/uri") cadena pública getForentityByuri () {// Use URI para pasar argumentos y acceder a Uricomponents uRicOponds = 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, class <t> ResponseType) */@getMapping ("/object") User público getForObjectWitHNopARAM () {// en comparación con el método getForEntity, obtener el objeto puede omitir llamar a getBody returnTEmplate.getForObject ("http: // hello service/user", clásico); }/** * t getForObject (string url, class <t> ResponseType, map <string,?> Urivariables) */@getmapping ("/objeto/map") usuario público getForObjectByMap () {// use mapa para pasar el mapa de parámetros <string> parammap = new hachmap <> (); parammap.put ("nombre", "hellxz"); return RestTemplate.getForObject ("http: // hello-service/user", user.class, parammap); }/** * t getForObject (string url, class <t> ResponseType, Object ... urivariables) */@getmapping ("/objeto/param/{name}") Public User getForObjectByParam (@PathVariable String Name) {return RESTMate.getForObject ("http: // hello-service/user/{name {name}, nombre, nombre); }/** * t getForObject (uri url, class <t> ResponseType) */@getMapping ("/objeto/uri/{name}") Usuario público getForObjectByuri (@PathVariable String name) {Uricpons Uricpons = UricRonentsBuDerilder.fromurURistring ("http: // hello-service/user/user/user}") .Build (). Expand (nombre) .Encode (); Uri uri = uRicomponents.touri (); return RestTemplate.getForObject (URI, user.class); }}Primero inicie el centro de registro y luego pruebe accediendo a la interfaz proporcionada por el consumidor. Todos estos son realmente operados por mí, por lo que no escribiré una prueba aquí.
Solicitud postal
Tanto la solicitud posterior como la solicitud GET tienen *Forentity y *ForObject Methods, donde la lista de parámetros es algo diferente. Además de estos dos métodos, también hay un método posterior a la Forforlocation, donde PostforLocation presenta el recurso como una solicitud posterior y devuelve el URI del nuevo recurso.
PostforEntity: hay tres formas sobrecargadas de este método, a saber:
NOTA: Este método devuelve un objeto de envoltura de respuesta al objeto <T> donde t es el tipo de respuesta aprobado en el tipo. Si desea obtener el tipo de retorno, debe usar el método getBody () de este objeto Wrapper.
PostforObject: este método también tiene tres formularios de sobrecarga, que es lo mismo que el método posterior a la de la ForforEntidad:
Nota: El tipo de objeto devuelto por este método es el tipo de respuesta que se pasa en el tipo
Postforlocation: también hay tres formularios de sobrecarga en este método, a saber:
Nota: Este método devuelve el URI del nuevo recurso. La diferencia entre GetForEntity, GetForObject, PostforEntity y los métodos posteriores al objeto es que no es necesario especificar el tipo de retorno en este método, porque el tipo de retorno es el URI. Todavía requiere que un marcador de posición pase los argumentos a través del objeto ... urivariables, mapa <cadena,?> Urivariables. Vea la parte posterior a la Forforentity del Código.
De la manera anterior, creamos postequestControllers en proyectos que proporcionan proveedores de servicios y consumidores respectivamente.
El siguiente código de servicio PostrequestController es el siguiente:
paquete com.shunneng.springcloudhelloworld; import org.apache.log4j.logger; import org.springframework.web.bind.annotation.*; importar org.springframework.web.util.uricomponents; import org.springframework.web.utilil.uricomponsbuilder; java.net.uri;/** * @author: hellxz * @Description: * @date: 2018/4/18 10:21 */ @RestControllerPublic Class postequestController {private logger logger = logger.getLogger (postrequestController.class); /*** Recibe un objeto y devuélvalo de vuelta. El método PostforEntity/PostforObject es común*/@PostMapping ("/User") Public User ReturnUserByPost (@RequestBody User User) {logger.info ("/use interfaz"+user); if (user == null) return New User ("Este es un objeto vacío", "", ""); devolver el usuario; }/** * Pruebe los parámetros del método PostforEntity, puede juzgar directamente la salida */@PostMapping ("/user/{str}") Public User ReturnUserByPost (@PathVariable String STR, @RequestBody User User) {Logger.info ("/User/SomeParam Interface Parameter Name:"+STR+""+Usuario); if (user == null) return New User ("Este es un objeto vacío", "", ""); devolver el usuario; }/** * Return URI para el método PostforLocation */@PostMapping ("/ubicación") URI public returnuri (@RequestBody User User) {// Simule una URL aquí, la ubicación de recursos real no puede estar aquí Uricomponentents Uricomponents = URicOponentsBuilder.FromURistring ("Http: // Hello-Service/ubicación") "))) .Build (). Expand (usuario) .Encode (); Uri touri = uRicomponents.touri (); // No sé cuál es el problema aquí. Obviamente se genera, pero parece que logger.info ("/Uri Uri:"+Touri); Touri de regreso; }}Código de consumo postrequestController:
paquete com.cnblogs.hellxz; import org.apache.log4j.logger; import org.springframework.beans.factory.annotation.aUtowired; importar org.springframework.http.ResponseSentity; import og.springframework.web.bind.annotation.postmapping; import org.springframework.web.bind.annotation.restController; import org.springframework.web.client.resttemplate; import org.springframework.web.util.uricponds; import org.springfframework.web.util.uricomponentsbuilder; import java.net; : Hellxz * @Description: controlador de solicitud de publicación de consumidor de cinta * @date: 2018/4/18 9:47 */ @RestControllerPublic Class postequestController {private logger logger = logger.getLogger (postequestcontroller.class); @AUtoWired private RestTemplate RestTTemplate; /** * ResponseEntity <T> PostforEntity (URL de cadena, solicitud de objeto, clase <T> ResponseType) * No se menciona la URL del parámetro. Si la solicitud del objeto no es un objeto HttpEntity, se convertirá automáticamente en un objeto HttpEntity y se tratará como un cuerpo completo; * Si se trata de un objeto HTTPentity, se procesará directamente como un cuerpo y contiene el contenido del encabezado. * No hablaré sobre el método de reescritura a continuación. El método de uso es aproximadamente el mismo que GetForentity. Si es solo un objeto de publicación simple, use el método sin objeto ... variables o variables de mapa. * PostforEntity (String Url, Solicitud de objeto, clase <T> ResponseType, Object ... urivariables) * PostforEntity (String Url, solicitud de objeto, clase <t> ResponseType, Map <String,?> Urivariables) * * Aquí hablaremos sobre los Métodos de Operado de Operate de Operate de Operate. Para decir que use marcadores de posición para aprobar parámetros en la URL solicitado por el puesto, y si no se usan marcadores de posición en la URL, ¡estos últimos parámetros aprobados no son válidos! * 2. Si el objeto de solicitud de objeto en el método tiene el mismo tipo que el parámetro receptor del proveedor de servicios, el proveedor de servicios solo necesita usar @RequestBody para recibir parámetros. * 3. Si ambos se usan, esto es más interesante. ¡Debe recibir parámetros en el URI a través de @PathVariable Annotation, y también necesita @RequestBody para recibir objetos o requestparam para recibir parámetros de acuerdo con los campos! * 4. Si informa un error, eche un vistazo más de cerca a los tres elementos que escribí anteriormente y preste atención al uso de los parámetros y anotaciones del proveedor de servicios. */ @Postmapping ("/ entidad") Publicado usuario postforStorEntity () {user user = new User ("Hellxz1", "1", "678912345"); ResponseEntity <Serem> Entity = RestTemplate.PostForEntity ("http: // hello-service/user/{str}", user, user.class, "parámetros de prueba"); User Body = entity.getBody (); // Todos los modificadores de restauración.*Los métodos de foredad son clases de envoltura, y el cuerpo es el cuerpo de retorno del objeto de tipo de retorno; }/*** Pasando los parámetros con URI, los resultados de la prueba se mostrarán en el terminal del proveedor* ResponseEntity <T> PostforEntity (URI URL, Solicitud de objeto, clase <T> ResponseType)*/@PostMapping ("/Entity/URI") PostforEntityByUriUri () {Usuario de usuario = "LAO ZHANG", "1", "" "67891249124124912014); // Aquí solo convirtimos la URL en URI, y no hay ningún parámetro agregado URICONMONENTES URICONPONENTS = URICONMONENTSBUILDER.FROMURISTRING ("http: // hello-service/user") .Build (). Encode (); Uri touri = uRicomponents.touri (); // use el usuario para pasar el objeto de usuario del parámetro = Resttemplate.postforObject (touri, user, user.class); Objeto de retorno; } /*** Al probar el método PostforObject aquí, los parámetros a los que deben prestarse la atención son como se describe en el método anterior. 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"); // Aquí la URL pasa 1 para llamar a una interfaz en el proyecto del servidor ResponseBody = RestTemplate.PostforObject ("http: // hello-service/user/1", user, user.class); RETURN RESPONDBODY; } /*** Hay otro tipo de solicitud de publicación: postforlocation. También hay tres sobrecargas aquí. Además de no especificar el tipo de retorno, el uso es el mismo, y el tipo de retorno es todo URI, por lo que no lo describiré * PostforLocation (String Url, Solicitud de objeto, Object ... UrivarIbles) * PostforLocation (String URL, Solicitud de Object, Map <String,?> UrivariBles) * PostforLocation (URI URL, solicitud de objeto) */ @@PostMapping ("/ Usation") Public ") Public") nuevo usuario ("Hellxz3", "1", "987654321"); URI uri = Resttemplate.postforLocation ("http: // hello-service/ubicación", usuario); // No sé por qué está vacío. Este método es solo para referencia. Si sé cuál es la situación, volveré a cambiar logger.info ("/ubicación uri:"+uri); regresar uri; }}Poner solicitud && eliminar la solicitud
La solicitud PUT es más simple que los métodos de solicitud GET y POST. No es necesario especificar el tipo de retorno de la solicitud de PUT y, por supuesto, no hay valor de retorno. También son tres tipos de sobrecargas, que son básicamente los mismos que los escritos antes. No quiero decir más aquí. Tanto la solicitud de eliminación como la solicitud de puesta no tienen valor de devolución. No importa si lo escribes específicamente aquí. Los métodos de estas dos solicitudes se enumeran por separado. El código está escrito en una clase.
El método de solicitud de put es el siguiente:
El método de solicitud de eliminación es el siguiente:
Agregar PutandDelTeLequestController al proyecto del proveedor, el código es el siguiente
paquete com.cnblogs.hellxz; importar org.apache.log4j.logger; import org.springframework.web.bind.annotation. *;/** * @author: hellxz * @Description: proveedor de servicios Put & delete Solicador * @Date: 2018/4/19 14:11 */ @RestcontrollerPoLElTERELETLERPOQUELEROQUEREQUES {private logger logger = logger.getLogger (PutandDelTeLequestController.class); @PutMapping ("/put") public void put (@RequestBody User User) {logger.info ("/put"+user); } @DeletEmapping ("/delete/{id}") public void delete (@PathVariable Long ID) {logger.info ("/delete id:"+id); }}Agregar PutandDelTeLequestController al proyecto del proveedor, el código es el siguiente
paquete com.cnblogs.hellxz; import org.apache.log4j.logger; import org.springframework.beans.factory.annotation.aUtowired; import org.springframework.web.bind.annotation.*; import og.springfringframe.web.client.resttemplate;/*** @author: @Description: Pon Solicitud, Elimine Solicitud, los parámetros sobrecargados son básicamente los mismos que la demostración anterior, y no se enumerarán * @Date: 2018/4/19 13:43 */ @RESTCONTROLLERPUBREC Public PutRequestController {private logger = logger.getLogger (postrecuTController.class); @AUtoWired private RestTemplate RestTTemplate; /*** Poner el ejemplo de la solicitud, generalmente las solicitudes de PUT se usan principalmente como modificación*/@putmapping ("/put") public void put (@RequestBody User User) {RestTemplate.put ("http: // hello-service/put", user); }/*** Eliminar el ejemplo de solicitud*/@DeletEmapping ("/del/{id}") public void delete (@PathVariable Long Id) {RestTemplate.delete ("http: // hello-service/delete/{1}", id); }}Conclusión
Esta publicación de blog está escrita usando Markdown. No sé cómo agregar números de serie y pliegue las funciones de código al bloque de código por primera vez. Puede que este no sea un buen artículo, pero he estado escribiendo esta publicación de blog durante casi dos días. Si tiene buenas sugerencias, no dude en comentar e intercambiar.
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.