Web backend development - request response

BS architecture Browser/Server, browser/server architecture mode, the client only needs a browser, and the application logic and data are stored on the server (Easy maintenance, average experience）

CS architecture Client/Server, client/server architecture mode (Development and maintenance is troublesome, but the experience is good）

ask

Simple parameters

Original method

Manually obtain through 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";
    }
}

Spring way

Simple parameters:The parameter name is the same as the formal parameter variable name, define the formal parameter, that is, receive the parameter


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

Note that the postman URLs here arehttp://localhost:8080/SimpleParam?name=tom&age=10

The above two are get requests. When it is a post request, you only need to enter the URL in postman.http://localhost:8080/SimpleParam

Post request garbled code processing

If there are Chinese characters in the post, garbled characters will appear in the background, so set the filter in the configuration

Add filters to the web container and specify character sets. The Spring-web package provides dedicated character filters.


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};//如果有多个过滤器，在这里用，隔开
    }
}

Note that this is for post. If Chinese characters are passed in by get, garbled characters will still appear.

If the method parameter name does not match the request parameter name, you can use @RequestParam to complete the mapping


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

The required attribute in @RequestParam defaults to true, which means that the request parameter must be passed. If it is not passed, an error will be reported. If the parameter is optional (that is, it can be passed or not), you can set the required attribute to false (so that you will not get an error whether you pass it or not)

Entity parameters

Simple Entity Parameters

The request parameter name is the same as the formal parameter attribute name, just define the Pojo to receive it


@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
}

The url here ishttp://localhost:8080/SimpleParam1?name=cat&age=29

Complex Entity Parameters

The request parameter name is the same as the formal parameter attribute name, nested pojo attribute parameters can be received according to the object hierarchy relationship


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";
    }
}

Array collection parameters

Array Parameters

The request parameter name is the same as the parameter group name and the request contains multiple, define array type parameters to receive parameters


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

Collection Parameters

The request parameter name is the same as the parameter collection name and there are multiple request parameters，@RequestParamBinding parameter relationships


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

Date parameters

Use @DateTimeFormat annotation to complete date parameter format conversion


@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：日期时间格式字符串

Get Test:

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

Json parameters

The json parameter key name is the same as the parameter object attribute name. You can define a Pojo type parameter to receive the parameter. You need to use the @RequestBody identifier.


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

Encapsulate json into the user entity class through @requestbody

Passing json data

Import the coordinates first


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

Enable support for automatic conversion of Json data


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

json array


//集合参数：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'}";
    }

json object (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'}";
}

When getting a request:


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

json collection (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'}";
}

When getting a request:


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

Notice

Path parameters

Pass parameters directly through the request URL, use {...} to identify the path parameter, and use @PathVariable to obtain the path parameter

A path parameter


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

The url of the postman test ishttp://localhost:8080/path/1

Multiple path parameters


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

The url of the postman test ishttp://localhost:8080/path/1/cat

Request Mapping Path

Problem: The requested paths should be different during development, but if there are identical paths, an error will be reported. I don't know which one should be called. Usually throughSet the module name as the prefix of the request path

@RequestMapping

It is a method annotation and a class annotation.

Place it above the SpringMVC controller method definition

Used to set the controller method request pathIf the current controller method is set on the class, the request access path prefix


@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'}";
    }
}

Attribute: value (default): request access path. Or access path prefix

Request Parameters

@RequestParam is a parameter annotation, which is located before the SpringMVC controller method parameter definition and is used to bind the relationship between the request parameters and the processor method parameters.

Parameters: required: whether it is a required parameter DefaultValue: the default value of the parameter

response

@ResponseBody

It is method annotation and class annotation

Located on the controller method/class

The function isDirectly respond to the method return value. If the return value type is an entity object/collection, it will be converted to JSON format response

@RestController=@Controller+@ResponseBody


@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;
    }
}

The test is entered in postmanhttp://localhost:8080/listAddrOther similar

Each method exposed to the outside world is called a functional interface (for example, there are three interfaces above), and the path is their access path.

The problem is that their response results are different, and the final analysis result is more troublesome, so the response results need to be unified

Unified response results


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);
    }
}

Technology Sharing