Web-Backend-Entwicklung – request Response

BS-Architektur Browser/Server, Browser/Server-Architekturmodus, der Client benötigt nur den Browser und die Anwendungslogik und Daten werden auf dem Server gespeichert (Einfach zu warten, durchschnittliche Erfahrung）

CS-Architektur Client/Server, Client/Server-Architekturmodus (Entwicklung und Wartung sind mühsam, aber die Erfahrung ist gut）

fragen

einfache Parameter

ursprüngliche Methode

Manuell über HttpServletRequest abrufen


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

Frühlingsweg

Einfache Parameter:Der Parametername ist derselbe wie der formale ParametervariablennameDas Definieren formaler Parameter bedeutet das Empfangen von Parametern


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

Beachten Sie, dass die URLs des Postboten hier alle sindhttp://localhost:8080/SimpleParam?name=tom&age=10

Bei beiden oben genannten handelt es sich um Get-Anfragen. Wenn es sich um eine Post-Anfrage handelt, müssen Sie nur die URL in Postman eingeben.http://localhost:8080/SimpleParam

Verstümmelte Verarbeitung der Post-Anfrage

Wenn der Beitrag chinesische Schriftzeichen enthält, werden im Hintergrund verstümmelte Schriftzeichen angezeigt. Stellen Sie daher den Filter in der Konfiguration ein.

Fügen Sie dem Webcontainer einen Filter hinzu und geben Sie den Zeichensatz an. Im Spring-Web-Paket ist ein dedizierter Zeichenfilter enthalten


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

Beachten Sie, dass dieser Vorgang für die Post gedacht ist. Wenn get auf Chinesisch übergeben wird, werden immer noch verstümmelte Zeichen angezeigt.

Wenn der Methodenparametername nicht mit dem Anforderungsparameternamen übereinstimmt, können Sie @RequestParam verwenden, um die Zuordnung abzuschließen.


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

Das erforderliche Attribut in @PequestParam ist standardmäßig true, was bedeutet, dass der Anforderungsparameter übergeben werden muss. Wenn er nicht übergeben wird, wird ein Fehler gemeldet. Wenn der Parameter optional ist (d. h. er kann übergeben werden oder nicht). Das erforderliche Attribut kann auf „false“ gesetzt werden (auf diese Weise wird kein Fehler gemeldet, ob Sie es übergeben oder nicht)

Entitätsparameter

Einfache Entitätsparameter

Der Name des Anforderungsparameters ist derselbe wie der Name des formalen Parameterattributs. Definieren Sie einfach Pojo, um ihn zu empfangen.


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

Die URL hier isthttp://localhost:8080/SimpleParam1?name=cat&age=29

Komplexe Entitätsparameter

Der Name des Anforderungsparameters ist derselbe wie der Name des formalen Parameterattributs., können Sie verschachtelte Pojo-Attributparameter entsprechend der Objekthierarchiebeziehung empfangen.


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-Sammlungsparameter

Array-Parameter

Der Name des Anforderungsparameters ist derselbe wie der Name der formalen Parametergruppe und es gibt mehrere Anforderungen.Definieren Sie den formalen Parameter des Array-Typs zum Empfangen von Parametern


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

Sammlungsparameter

Der Name des Anforderungsparameters ist derselbe wie der Name der formalen Parametersammlung und es gibt mehrere Anforderungsparameter.，@AnforderungParamBindungsparameterbeziehung


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

Datumsparameter

Verwenden Sie die Annotation @DateTimeFormat, um die Konvertierung des Datumsparameterformats abzuschließen


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

Testen:

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

Json-Parameter

Der Name des JSON-Parameterschlüssels ist derselbe wie der Name des formalen Parameterobjekts. Sie können Parameter erhalten, indem Sie den formalen Parameter vom Typ Pojo definieren.


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

Kapseln Sie JSON über @requestbody in die Benutzerentitätsklasse

Übergeben Sie JSON-Daten

Importieren Sie zuerst die Koordinaten


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

Aktivieren Sie die Unterstützung für die automatische Konvertierung von Json-Daten


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

Wenn Sie eine Get-Anfrage stellen:


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

JSON-Sammlung (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'}";
}

Wenn Sie eine Get-Anfrage stellen:


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

Beachten

Pfadparameter

Übergeben Sie Parameter direkt über die Anforderungs-URL. Verwenden Sie {...}, um die Pfadparameter zu identifizieren. Sie müssen @PathVariable verwenden, um die Pfadparameter zu erhalten.

ein Pfadparameter


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

Die vom Postboten getestete URL lautethttp://localhost:8080/Pfad/1

Mehrere Pfadparameter


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

Die vom Postboten getestete URL lautethttp://localhost:8080/Pfad/1/cat

Zuordnungspfad anfordern

Frage: Die während der Entwicklung angeforderten Pfade sollten unterschiedlich sein, aber wenn es dieselben Pfade gibt, wird ein Fehler gemeldet. Ich weiß nicht, welcher aufgerufen werden soll ----------normalerweise durchLegen Sie den Modulnamen als Präfix für den Anforderungspfad fest

@RequestMapping

Es handelt sich um Methodenannotation und Klassenannotation

Platzieren Sie es über der Methodendefinition des SpringMVC-Controllers

Wird verwendet, um den Anforderungspfad der Controller-Methode festzulegenWenn Sie die aktuelle Controller-Methode für die Klasse festlegen, fordern Sie das Zugriffspfadpräfix an


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

Eigenschaften: Wert (Standard): Zugriffspfad anfordern.Oder Zugriffspfadpräfix

Parameter anfordern

@RequestParam ist eine formale Parameteranmerkung, die sich vor der Parameterdefinition der SpringMVC-Controller-Methode befindet und zum Binden der Beziehung zwischen Anforderungsparametern und Prozessormethodenparametern verwendet wird.

Parameter: erforderlich: ob es sich um einen erforderlichen Parameter handelt. DefaultValue: der Standardwert des Parameters

Antwort

@AntwortBody

Sind Methodenanmerkungen und Klassenanmerkungen

Befindet sich auf der Controller-Methode/-Klasse

Die Funktion istReagieren Sie direkt auf den Rückgabewert der Methode. Wenn der Rückgabewerttyp ein Entitätsobjekt/eine Entitätssammlung ist, wird er in eine Antwort im JSON-Format konvertiert.

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

Der Test wird im Briefträger eingetragenhttp://localhost:8080/listAddrDas ist es, andere ähnliche

Jede nach außen zugängliche Methode wird als funktionale Schnittstelle bezeichnet (oben gibt es beispielsweise drei Schnittstellen), und der Pfad ist ihr Zugriffspfad.

Das Problem besteht darin, dass ihre Antwortergebnisse unterschiedlich sind und die endgültige Analyse der Ergebnisse schwieriger ist, sodass die Antwortergebnisse vereinheitlicht werden müssen.

Einheitliche Antwortergebnisse


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

Technologieaustausch

Web-Backend-Entwicklung – Anfrageantwort

Vorwort