développement du backend Web --request réponse

Architecture BS Navigateur/Serveur, mode architecture navigateur/serveur, le client n'a besoin que du navigateur, et la logique et les données de l'application sont stockées sur le serveur (Facile à entretenir, expérience moyenne）

Architecture CS Client/Serveur, mode architecture client/serveur (Le développement et la maintenance sont difficiles, mais l'expérience est bonne）

demander

paramètres simples

méthode originale

Obtenir manuellement via 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";
    }
}

Chemin du printemps

Paramètres simples :Le nom du paramètre est le même que le nom de la variable du paramètre formel, définir des paramètres formels signifie recevoir des paramètres


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

Notez que les URL du facteur ici sont touteshttp://localhost:8080/SimpleParam?name=tom&age=10

Les deux éléments ci-dessus sont des demandes d'obtention. Lorsqu'il s'agit d'une demande de publication, il vous suffit de saisir l'URL dans Postman.http://localhost:8080/SimpleParam

Traitement tronqué de la demande de publication

S'il y a des caractères chinois dans la publication, des caractères tronqués apparaîtront en arrière-plan, alors définissez le filtre dans la configuration.

Ajoutez un filtre au conteneur Web et spécifiez le jeu de caractères. Un filtre de caractères dédié est fourni dans le package 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};//如果有多个过滤器，在这里用，隔开
    }
}

Notez que ce processus est destiné à la publication. Si get est transmis en chinois, des caractères tronqués apparaîtront toujours.

Si le nom du paramètre de méthode ne correspond pas au nom du paramètre de demande, vous pouvez utiliser @RequestParam pour terminer le mappage.


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

L'attribut obligatoire dans @PequestParam est défini par défaut sur true, ce qui signifie que le paramètre de requête doit être transmis. S'il n'est pas transmis, une erreur sera signalée. Si le paramètre est facultatif (c'est-à-dire qu'il peut être transmis ou non), le L'attribut obligatoire peut être défini sur false (de cette façon, aucune erreur ne sera signalée si vous le transmettez ou non)

Paramètres d'entité

Paramètres d'entité simples

Le nom du paramètre de requête est le même que le nom de l'attribut du paramètre formel, définissez simplement Pojo pour le recevoir.


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

L'url ici esthttp://localhost:8080/SimpleParam1?name=cat&age=29

Paramètres d'entité complexe

Le nom du paramètre de demande est le même que le nom de l'attribut du paramètre formel., vous pouvez recevoir des paramètres d'attribut pojo imbriqués en fonction de la relation hiérarchique des objets.


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

paramètres de collection de tableaux

Paramètres du tableau

Le nom du paramètre de requête est le même que le nom du groupe de paramètres formel et il existe plusieurs requêtes., définissez le paramètre formel du type de tableau pour recevoir les paramètres


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

Paramètres de collecte

Le nom du paramètre de requête est le même que le nom de la collection de paramètres formels et il existe plusieurs paramètres de requête.，@RequestParamRelation des paramètres de liaison


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

paramètre de date

Utilisez l'annotation @DateTimeFormat pour terminer la conversion du format des paramètres de date


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

Obtenez un test :

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

Paramètres Json

Le nom de la clé du paramètre json est le même que le nom de l'attribut de l'objet du paramètre formel. Vous pouvez recevoir des paramètres en définissant le paramètre formel de type Pojo. Vous devez utiliser l'identifiant @RequestBody.


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

Encapsulez json dans la classe d'entité utilisateur via @requestbody

Transmettre les données json

Importer d'abord les coordonnées


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

Activer la prise en charge de la conversion automatique des données Json


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

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

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

Lorsque vous effectuez une requête Get :


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

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

Lorsque vous effectuez une requête Get :


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

Avis

paramètres de chemin

Transmettez les paramètres directement via l'URL de la requête. Utilisez {...} pour identifier les paramètres de chemin. Vous devez utiliser @PathVariable pour obtenir les paramètres de chemin.

un paramètre de chemin


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

L'url testée par le facteur esthttp://localhost:8080/path/1

Paramètres de chemin multiples


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

L'url testée par le facteur esthttp://localhost:8080/path/1/cat

Chemin de mappage de la demande

Question : Les chemins demandés lors du développement doivent être différents, mais s'il y a les mêmes chemins, une erreur sera signalée. Je ne sais pas lequel doit être appelé ----------généralement via.Définir le nom du module comme préfixe du chemin de la requête

@RequestMapping

C'est une annotation de méthode et une annotation de classe

Placez-le au-dessus de la définition de la méthode du contrôleur SpringMVC

Utilisé pour définir le chemin de requête de la méthode du contrôleur, si vous définissez la méthode de contrôleur actuelle sur la classe, demandez le préfixe du chemin d'accès


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

Propriétés : valeur (par défaut) : Chemin d'accès de la demande.Ou préfixe du chemin d'accès

Paramètres de la demande

@RequestParam est une annotation formelle de paramètre, située devant la définition des paramètres de la méthode du contrôleur SpringMVC, utilisée pour lier la relation entre les paramètres de la requête et les paramètres de la méthode du processeur.

Paramètres : obligatoire : s'il s'agit d'un paramètre obligatoire. DefaultValue : la valeur par défaut du paramètre

réponse

@ResponseBody

Sont des annotations de méthode et des annotations de classe

Situé sur la méthode/classe du contrôleur

La fonction estRépondez directement à la valeur de retour de la méthode. Si le type de valeur de retour est un objet/collection d'entité, il sera converti en réponse au format JSON.

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

Le test est entré dans le facteurhttp://localhost:8080/listAddrVoilà, d'autres similaires

Chaque méthode exposée à l'extérieur est appelée une interface fonctionnelle (par exemple, il y a trois interfaces ci-dessus), et le chemin est leur chemin d'accès.

Le problème rencontré est que les résultats de leurs réponses sont différents et que l'analyse finale des résultats est plus difficile, les résultats de la réponse doivent donc être unifiés.

Résultats de réponse unifiés


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

Partage de technologie

Développement du backend Web – demande de réponse

Préface