desarrollo web backend--solicitud respuesta

Arquitectura BS Navegador / Servidor, modo de arquitectura navegador / servidor, el cliente solo necesita el navegador y la lógica y los datos de la aplicación se almacenan en el servidor (Fácil de mantener, experiencia promedio.）

Arquitectura CS Cliente/Servidor, modo de arquitectura cliente/servidor (El desarrollo y el mantenimiento son problemáticos, pero la experiencia es buena.）

preguntar

parámetros simples

método original

Obtener manualmente a través de HttpServletRequest


import jakarta.servlet.http.HttpServletRequest;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class RequestController {
    @RequestMapping("/SimpleParam")
    public String SimpleParam(HttpServletRequest request){  //返回的字符串类型是String
        String name=request.getParameter("name");
        String age=request.getParameter("age");  //通过这个方法得到字符串类型的
        int age1=Integer.parseInt(age);  //将年龄进行类型转换
        System.out.println(name+":"+age1);  //设置返回格式
        return "OK";
    }
}

Camino de primavera

Parámetros simples:El nombre del parámetro es el mismo que el nombre de la variable del parámetro formal., definir parámetros formales significa recibir parámetros


@RestController
public class RequestController {
    @RequestMapping("/SimpleParam")
    public String SimpleParam(String name,Integer age){
        System.out.println(name+":"+age);
        return "OK";
    }
}

Tenga en cuenta que las URL del cartero aquí son todashttp://localhost:8080/SimpleParam?nombre=tom&edad=10

Las dos anteriores son solicitudes de obtención. Cuando se trata de una solicitud de publicación, solo necesita ingresar la URL en cartero.http://localhost:8080/ParámetroSimple

Procesamiento confuso de solicitud posterior

Si hay caracteres chinos en la publicación, aparecerán caracteres confusos en el fondo, así que configure el filtro en la configuración.

Agregue un filtro al contenedor web y especifique el juego de caracteres. Se proporciona un filtro de caracteres dedicado en el paquete Spring-web.


public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    protected Class<?>[] getRootConfigClasses() {
        return new Class[0];
    }
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
    //乱码处理
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("UTF-8");
        return new Filter[]{filter};//如果有多个过滤器，在这里用，隔开
    }
}

Tenga en cuenta que este proceso es para publicaciones. Si se pasa get en chino, seguirán apareciendo caracteres confusos.

Si el nombre del parámetro del método no coincide con el nombre del parámetro de solicitud, puede usar @RequestParam para completar la asignación.


@RestController
public class RequestController {
    @RequestMapping("/SimpleParam")
    public String SimpleParam(@RequestParam(name="name") String username, Integer age){  //引号中写的是请求参数名
        System.out.println(username+":"+age);
        return "OK";
    }
}

El atributo requerido en @PequestParam tiene el valor predeterminado verdadero, lo que significa que se debe pasar el parámetro de solicitud. Si no se pasa, se informará un error. Si el parámetro es opcional (es decir, se puede pasar o no). El atributo requerido se puede establecer en falso (de esta manera, no se informará ningún error si lo pasa o no)

Parámetros de entidad

Parámetros de entidad simples

El nombre del parámetro de solicitud es el mismo que el nombre del atributo del parámetro formal, simplemente defina Pojo para recibirlo.


@RestController
public class SimplePojo {
    @RequestMapping("/SimpleParam1")
    public String SimplePojo(user user) {
        System.out.println(user);
        return "yes";
    }
}


public class user {
    private String name;
    private Integer age;
//加getter和setter方法toString
}

La URL aquí eshttp://localhost:8080/SimpleParam1?nombre=gato&edad=29

Parámetros de entidad complejos

El nombre del parámetro de solicitud es el mismo que el nombre del atributo del parámetro formal., puede recibir parámetros de atributos pojo anidados de acuerdo con la relación de jerarquía de objetos.


public class user {
    private String name;
    private Integer age;
private Address address;
//加getter和setter和toString
}


public class Address {
    private String province;
    private String city;
//加getter和setter还有toString
}


@RestController
public class SimplePojo {
    @RequestMapping("/ComplexParam1")
    public String ComplexParam(user user) {
        System.out.println(user);
        return "yes";
    }
}

parámetros de colección de matrices

Parámetros de matriz

El nombre del parámetro de solicitud es el mismo que el nombre del grupo de parámetros formal y hay varias solicitudes., defina el parámetro formal del tipo de matriz para recibir parámetros


@RestController
public class SimplePojo {
    @RequestMapping("/arrayParam")
    public String ArrayParam(String[] hobby) {//在这里建立一个数组，然后后面的名称和传入参数相同
        System.out.println(Arrays.toString(hobby));
        return "yes";
    }
}

Parámetros de colección

El nombre del parámetro de solicitud es el mismo que el nombre de la colección de parámetros formales y existen varios parámetros de solicitud.，@RequestParamRelación de parámetros vinculantes


@RestController
public class SimplePojo {
    @RequestMapping("/listParam")
    public String ArrayParam(@RequestParam List<String> hobby) {
        System.out.println(hobby);
        return "yes";
    }
}

parámetro de fecha

Utilice la anotación @DateTimeFormat para completar la conversión del formato del parámetro de fecha


@RestController
public class SimplePojo {
    @RequestMapping("/dateParam")
    public String dateParam(@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")LocalDateTime updateTime) {
        System.out.println(updateTime);
        return "yes";
    }
}


//日期参数    
//使用@DateTimeFormat注解设置日期类型数据格式，默认格式yyyy/MM/dd   @RequestMapping("/dataParam")    
@ResponseBody    
public String dataParam(Date date,@DateTimeFormat(pattern="yyyy-MM-dd") Date date1, @DateTimeFormat(pattern="yyyy/MM/dd HH:mm:ss") Date date2){        
System.out.println("参数传递 date ==> "+date);        
System.out.println("参数传递 date1(yyyy-MM-dd) ==> "+date1);        
System.out.println("参数传递 date2(yyyy/MM/dd HH:mm:ss) ==> "+date2);        
return "{'module':'data param'}";    }
}
//@DateTimeFormat是形参注解，用在SpringMVC控制器方法形参前面，用于设定日期时间型数据格式//属性：pattern：日期时间格式字符串

Hazte la prueba:

http://localhost:8080/springmvc_04_request_param/dataParam?date=2088/08/08&date1=2088-08-18&date2=2088/08/28 8:08:08

Parámetros json

El nombre de la clave del parámetro json es el mismo que el nombre del atributo del objeto del parámetro formal. Puede recibir parámetros definiendo el parámetro formal de tipo Pojo. Debe utilizar el identificador @RequestBody.


@RestController
public class SimplePojo {
    @RequestMapping("/jsonParam")
    public String jsonParam(@RequestBody user user) {
        System.out.println(user);
        return "yes";
    }
}
//user这和前面的复杂实体参数一样

Encapsule json en la clase de entidad de usuario a través de @requestbody

Pasar datos json

Importar coordenadas primero


<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.9.0</version>
</dependency>

Habilite el soporte para la conversión automática de datos Json


@Configuration
@ComponentScan("com.itheima.controller")
//开启json数据类型自动转换
@EnableWebMvc
public class SpringMvcConfig {
}

matriz json


//集合参数：json格式
    //1.开启json数据格式的自动转换，在配置类中开启@EnableWebMvc
    //2.使用@RequestBody注解将外部传递的json数组数据映射到形参的集合对象中作为数据
//它用来将请求体所包含的数据传递给请求参数，此注解一个处理器方法只能使用一次
    @RequestMapping("/listParamForJson")
    @ResponseBody
    public String listParamForJson(@RequestBody List<String> likes){
        System.out.println("list common(json)参数传递 list ==> "+likes);
        return "{'module':'list common for json param'}";
    }

objeto json (POJO)


//POJO参数：json格式
//1.开启json数据格式的自动转换，在配置类中开启@EnableWebMvc
//2.使用@RequestBody注解将外部传递的json数据映射到形参的实体类对象中，要求属性名称一一对应
@RequestMapping("/pojoParamForJson")
@ResponseBody
public String pojoParamForJson(@RequestBody User user){
    System.out.println("pojo(json)参数传递 user ==> "+user);
    return "{'module':'pojo for json param'}";
}

Al realizar una solicitud Obtener:


{
    "name":"xixi",
    "age":21,
    "address":{
        "provice":"taiyuan",
        "city":"taiyuan"
    }
}

colección json (POJO)


//集合参数：json格式
//1.开启json数据格式的自动转换，在配置类中开启@EnableWebMvc
//2.使用@RequestBody注解将外部传递的json数组数据映射到形参的保存实体类对象的集合对象中，要求属性名称一一对应
@RequestMapping("/listPojoParamForJson")
@ResponseBody
public String listPojoParamForJson(@RequestBody List<User> list){
    System.out.println("list pojo(json)参数传递 list ==> "+list);
    return "{'module':'list pojo for json param'}";
}

Al realizar una solicitud Obtener:


[{"name":"xixi","age":12},
{"name":"haha","age":21}
]

Aviso

parámetros de ruta

Pase los parámetros directamente a través de la URL de solicitud. Utilice {...} para identificar los parámetros de la ruta. Debe utilizar @PathVariable para obtener los parámetros de la ruta.

un parámetro de ruta


@RestController
public class SimplePojo {
    @RequestMapping("/path/{id}")
    public String pathParam(@PathVariable Integer id) {
        System.out.println(id);
        return "yes";
    }
}

La URL probada por el cartero eshttp://localhost:8080/ruta/1

Múltiples parámetros de ruta


@RestController
public class SimplePojo {
    @RequestMapping("/path/{id}/{name}")
    public String pathParam(@PathVariable Integer id ,@PathVariable String name) {
        System.out.println(id+":"+name);
        return "yes";
    }
}

La URL probada por el cartero eshttp://localhost:8080/ruta/1/gato

Solicitar ruta de mapeo

Pregunta: Las rutas solicitadas durante el desarrollo deben ser diferentes, pero si hay las mismas rutas, se informará un error. No sé cuál debería llamarse, generalmente a través de.Establezca el nombre del módulo como prefijo de la ruta de solicitud

@RequestMapping

Es anotación de método y anotación de clase.

Colóquelo encima de la definición del método del controlador SpringMVC.

Se utiliza para configurar la ruta de solicitud del método del controlador., si configura el método del controlador actual en la clase, solicite el prefijo de la ruta de acceso


@Controller
//设置模块名作为请求路径的前缀
@RequestMapping("/user")
public class UserController {
    //请求路径映射
    @RequestMapping("/save")
    @ResponseBody
    public String save(){
        System.out.println("user save ...");
        return "{'module':'user save'}";
    }
    //请求路径映射
    @RequestMapping("/delete")
    @ResponseBody
    public String delete(){
        System.out.println("user delete ...");
        return "{'module':'user delete'}";
    }
}

Propiedades: valor (predeterminado): Solicitar ruta de acceso.O prefijo de ruta de acceso

Solicitar parámetros

@RequestParam es una anotación de parámetro formal, ubicada frente a la definición de parámetro del método del controlador SpringMVC, que se utiliza para vincular la relación entre los parámetros de solicitud y los parámetros del método del procesador.

Parámetros: requerido: si es un parámetro requerido DefaultValue: el valor predeterminado del parámetro

respuesta

@CuerpoDeRespuesta

¿Son anotaciones de métodos y anotaciones de clases?

Ubicado en el método/clase del controlador

La función esResponda directamente al valor de retorno del método. Si el tipo de valor de retorno es un objeto/colección de entidad, se convertirá en una respuesta en formato JSON.

@RestController=@Controlador+@CuerpoDeRespuesta


@RestController
public class ResponseController {
    @RequestMapping("/hello")
    public String hello(){
        System.out.println("hello world");
        return "hello world~";
    }
    @RequestMapping("/getAddr")
    public Address getAddr(){
        Address addr=new Address();
        addr.setProvince("山西");
        addr.setCity("太原");
        return addr;
    }
    @RequestMapping("/listAddr")
    public List<Address> ListAddr(){
        List<Address> list=new ArrayList<>();
        Address addr=new Address();
        addr.setProvince("山西");
        addr.setCity("太原");
        Address addr2=new Address();
        addr2.setProvince("山");
        addr2.setCity("太");
        list.add(addr);
        list.add(addr2);
        return list;
    }
}

La prueba se ingresa en cartero.http://localhost:8080/direccióndelistaEso es todo, otros similares.

Cada método expuesto al exterior se denomina interfaz funcional (por ejemplo, hay tres interfaces arriba) y la ruta es su ruta de acceso.

El problema que enfrentan es que los resultados de sus respuestas son diferentes y el análisis final de los resultados es más problemático, por lo que los resultados de las respuestas deben estar unificados.

Resultados de respuesta unificada


public class Result {
    private Integer code;
    private String msg;
    private Object data;
public Result(){
 
}
public Result(Integer code,String msg,Object data){
    this.code=code;
    this.msg=msg;
    this.data=data;
 
}
    public Integer getCode() {
        return code;
    }
 
    public void setCode(Integer code) {
        this.code = code;
    }
 
    public String getMsg() {
        return msg;
    }
 
    public void setMsg(String msg) {
        this.msg = msg;
    }
 
    public Object getData() {
        return data;
    }
 
    public void setData(Object data) {
        this.data = data;
    }
    public static Result success(Object data){
    return new Result(1,"success",data);
    }
    public static Result success(){
        return new Result(1,"success",null);
    }
    public static Result error(String msg){
        return new Result(0,msg,null);
    }
    @Override
    public String toString() {
        return "Result{" +
                "code=" + code +
                ", msg='" + msg + ''' +
                ", data=" + data +
                '}';
    }
}


@RestController
public class ResponseController {
    @RequestMapping("/hello")
    public Result hello(){
        System.out.println("hello world");
        //return new Result(1,"success","hello world");
        return Result.success("hello world~");//需要给前端传送数据
    }
    @RequestMapping("/getAddr")
    public Result getAddr(){
        Address addr=new Address();
        addr.setProvince("山西");
        addr.setCity("太原");
        return Result.success(addr);
    }
    @RequestMapping("/listAddr")
    public Result ListAddr(){
        List<Address> list=new ArrayList<>();
        Address addr=new Address();
        addr.setProvince("山西");
        addr.setCity("太原");
        Address addr2=new Address();
        addr2.setProvince("山");
        addr2.setCity("太");
        list.add(addr);
        list.add(addr2);
        return Result.success(list);
    }
}

Compartir tecnología

Desarrollo web backend: solicitud de respuesta

Prefacio