Condivisione della tecnologia

Sviluppo del backend Web: risposta alla richiesta

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Sommario

Prefazione

chiedere

parametri semplici

metodo originale

Modo primaverile

Elaborazione confusa della richiesta post

Parametri dell'entità

Parametri di entità semplici

Parametri di entità complesse

Modificare

parametri della raccolta di array

Parametri della matrice

Modificare

Parametri di raccolta

parametro della data

Modificare

Parametri Json

Modificare

Passa i dati JSON

matrice json

oggetto json (POJO)

raccolta json (POJO)

Avviso

parametri del percorso

Richiedi percorso di mappatura

@RichiestaMapping

Richiedi parametri

risposta

@CorpoRisposta

Risultati della risposta unificata

Prefazione

Richiesta: ottieni i dati della richiesta

Risposta: imposta i dati di risposta

Architettura BS Browser/Server, modalità architettura browser/server, il client necessita solo del browser e la logica e i dati dell'applicazione vengono archiviati sul server (Facile da mantenere, esperienza nella media）

Architettura CS Client/Server, modalità architettura client/server (Lo sviluppo e la manutenzione sono problematici, ma l'esperienza è buona）

chiedere

parametri semplici

metodo originale

Ottieni manualmente tramite HttpServletRequest

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

Modo primaverile

Parametri semplici:Il nome del parametro è uguale al nome della variabile del parametro formale, definire parametri formali significa ricevere parametri

  1. @RestController
  2. public class RequestController {
  3.     @RequestMapping("/SimpleParam")
  4.     public String SimpleParam(String name,Integer age){
  5.         System.out.println(name+":"+age);
  6.         return "OK";
  7.     }
  8. }

Tieni presente che gli URL del postino qui sono tuttihttp://localhost:8080/SimpleParam?name=tom&age=10

Entrambe le richieste precedenti sono di ricezione. Quando si tratta di una richiesta di posta, è sufficiente inserire l'URL in Postman.http://localhost:8080/SimpleParam

Elaborazione confusa della richiesta post

Se nel post sono presenti caratteri cinesi, sullo sfondo appariranno caratteri confusi, quindi imposta il filtro nella configurazione.

Aggiungi un filtro al contenitore web e specifica il set di caratteri. Nel pacchetto Spring-web viene fornito un filtro di caratteri dedicato

  1. public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
  2.     protected Class<?>[] getRootConfigClasses() {
  3.         return new Class[0];
  4.     }
  5. ​
  6.     protected Class<?>[] getServletConfigClasses() {
  7.         return new Class[]{SpringMvcConfig.class};
  8.     }
  9. ​
  10.     protected String[] getServletMappings() {
  11.         return new String[]{"/"};
  12.     }
  13.     //乱码处理
  14.     @Override
  15.     protected Filter[] getServletFilters() {
  16.         CharacterEncodingFilter filter = new CharacterEncodingFilter();
  17.         filter.setEncoding("UTF-8");
  18.         return new Filter[]{filter};//如果有多个过滤器，在这里用，隔开
  19.     }
  20. }

Tieni presente che questo processo è per post. Se get viene passato in cinese, verranno comunque visualizzati caratteri confusi.

Se il nome del parametro del metodo non corrisponde al nome del parametro della richiesta, puoi utilizzare @RequestParam per completare la mappatura.

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

L'attributo obbligatorio in @PequestParam è impostato su true, il che significa che il parametro della richiesta deve essere passato. Se non viene passato, verrà segnalato un errore. Se il parametro è facoltativo (ovvero, può essere passato o meno), the l'attributo obbligatorio può essere impostato su false (in questo modo non verrà segnalato alcun errore se lo passi o meno)

Parametri dell'entità

Parametri di entità semplici

Il nome del parametro di richiesta è lo stesso del nome dell'attributo del parametro formale, basta definire Pojo per riceverlo.

  1. @RestController
  2. public class SimplePojo {
  3.     @RequestMapping("/SimpleParam1")
  4.     public String SimplePojo(user user) {
  5.         System.out.println(user);
  6.         return "yes";
  7.     }
  8. }
  1. public class user {
  2.     private String name;
  3.     private Integer age;
  4. //加getter和setter方法toString
  5. }

L'URL qui èhttp://localhost:8080/SimpleParam1?name=cat&age=29

Parametri di entità complesse

Il nome del parametro di richiesta è uguale al nome dell'attributo del parametro formale., è possibile ricevere parametri di attributi pojo nidificati in base alla relazione gerarchica degli oggetti.

  1. public class user {
  2.     private String name;
  3.     private Integer age;
  4. private Address address;
  5. //加getter和setter和toString
  6. }
  1. public class Address {
  2.     private String province;
  3.     private String city;
  4. //加getter和setter还有toString
  5. }
  1. @RestController
  2. public class SimplePojo {
  3.     @RequestMapping("/ComplexParam1")
  4.     public String ComplexParam(user user) {
  5.         System.out.println(user);
  6.         return "yes";
  7.     }
  8. }

parametri della raccolta di array

Parametri della matrice

Il nome del parametro di richiesta è uguale al nome del gruppo di parametri formali e sono presenti più richieste., definire il parametro formale del tipo array per ricevere i parametri

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

Parametri di raccolta

Il nome del parametro di richiesta è uguale al nome della raccolta di parametri formali e sono presenti più parametri di richiesta.，@RichiediParamRelazione tra parametri vincolanti

  1. @RestController
  2. public class SimplePojo {
  3.     @RequestMapping("/listParam")
  4.     public String ArrayParam(@RequestParam List<String> hobby) {
  5.         System.out.println(hobby);
  6.         return "yes";
  7.     }
  8. }

parametro della data

Utilizza l'annotazione @DateTimeFormat per completare la conversione del formato del parametro della data

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

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

Ottieni il test:

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

Parametri Json

Il nome della chiave del parametro json è lo stesso del nome dell'attributo dell'oggetto del parametro formale. È possibile ricevere i parametri definendo il parametro formale del tipo Pojo. È necessario utilizzare l'identificatore @RequestBody.

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

Incapsula JSON nella classe dell'entità utente tramite @requestbody

Passa i dati JSON

Importa prima le coordinate

  1. <dependency>
  2.   <groupId>com.fasterxml.jackson.core</groupId>
  3.   <artifactId>jackson-databind</artifactId>
  4.   <version>2.9.0</version>
  5. </dependency>

Abilita il supporto per la conversione automatica dei dati JSON

  1. @Configuration
  2. @ComponentScan("com.itheima.controller")
  3. //开启json数据类型自动转换
  4. @EnableWebMvc
  5. public class SpringMvcConfig {
  6. }
matrice json
   
  1. //集合参数：json格式
  2.     //1.开启json数据格式的自动转换，在配置类中开启@EnableWebMvc
  3.     //2.使用@RequestBody注解将外部传递的json数组数据映射到形参的集合对象中作为数据
  4. //它用来将请求体所包含的数据传递给请求参数，此注解一个处理器方法只能使用一次
  5.     @RequestMapping("/listParamForJson")
  6.     @ResponseBody
  7.     public String listParamForJson(@RequestBody List<String> likes){
  8.         System.out.println("list common(json)参数传递 list ==> "+likes);
  9.         return "{'module':'list common for json param'}";
  10.     }
oggetto json (POJO)
  1. //POJO参数：json格式
  2. //1.开启json数据格式的自动转换，在配置类中开启@EnableWebMvc
  3. //2.使用@RequestBody注解将外部传递的json数据映射到形参的实体类对象中，要求属性名称一一对应
  4. @RequestMapping("/pojoParamForJson")
  5. @ResponseBody
  6. public String pojoParamForJson(@RequestBody User user){
  7.     System.out.println("pojo(json)参数传递 user ==> "+user);
  8.     return "{'module':'pojo for json param'}";
  9. }

Quando si effettua una richiesta Ottieni:

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

Quando si effettua una richiesta Ottieni:

  1. [{"name":"xixi","age":12},
  2. {"name":"haha","age":21}
  3. ]
Avviso

parametri del percorso

Passare i parametri direttamente tramite l'URL della richiesta Utilizzare {...} per identificare i parametri del percorso È necessario utilizzare @PathVariable per ottenere i parametri del percorso.

un parametro di percorso

  1. @RestController
  2. public class SimplePojo {
  3.     @RequestMapping("/path/{id}")
  4.     public String pathParam(@PathVariable Integer id) {
  5.         System.out.println(id);
  6.         return "yes";
  7.     }
  8. }

L'URL testato dal postino èhttp://localhost:8080/percorso/1

Parametri di percorso multipli

  1. @RestController
  2. public class SimplePojo {
  3.     @RequestMapping("/path/{id}/{name}")
  4.     public String pathParam(@PathVariable Integer id ,@PathVariable String name) {
  5.         System.out.println(id+":"+name);
  6.         return "yes";
  7.     }
  8. }

L'URL testato dal postino èhttp://localhost:8080/percorso/1/cat

Richiedi percorso di mappatura

Domanda: I percorsi richiesti durante lo sviluppo dovrebbero essere diversi, ma se ci sono gli stessi percorsi verrà segnalato un errore non so quale dovrebbe essere chiamato----------normalmenteImposta il nome del modulo come prefisso per il percorso della richiesta

@RichiestaMapping

È l'annotazione del metodo e l'annotazione della classe

Posizionalo sopra la definizione del metodo del controller SpringMVC

Utilizzato per impostare il percorso di richiesta del metodo del controller, se si imposta il metodo del controller corrente sulla classe, richiedere il prefisso del percorso di accesso

  1. @Controller
  2. //设置模块名作为请求路径的前缀
  3. @RequestMapping("/user")
  4. public class UserController {
  5.     //请求路径映射
  6.     @RequestMapping("/save")
  7.     @ResponseBody
  8.     public String save(){
  9.         System.out.println("user save ...");
  10.         return "{'module':'user save'}";
  11.     }
  12.     //请求路径映射
  13.     @RequestMapping("/delete")
  14.     @ResponseBody
  15.     public String delete(){
  16.         System.out.println("user delete ...");
  17.         return "{'module':'user delete'}";
  18.     }
  19. ​
  20. }

Proprietà: valore (predefinito): Richiedi percorso di accesso.Oppure accedere al prefisso del percorso

Richiedi parametri

@RequestParam è un'annotazione di parametro formale, situata davanti alla definizione del parametro del metodo del controller SpringMVC, utilizzata per associare la relazione tra i parametri della richiesta e i parametri del metodo del processore.

Parametri: obbligatorio: se si tratta di un parametro obbligatorio. DefaultValue: il valore predefinito del parametro

risposta

@CorpoRisposta

Sono annotazioni di metodo e annotazioni di classe

Situato nel metodo/classe del controller

La funzione èRispondere direttamente al valore restituito dal metodo. Se il tipo di valore restituito è un oggetto/raccolta di entità, verrà convertito in una risposta in formato JSON.

@RestController=@Controller+@ResponseBody

  1. @RestController
  2. public class ResponseController {
  3.     @RequestMapping("/hello")
  4.     public String hello(){
  5.         System.out.println("hello world");
  6.         return "hello world~";
  7.     }
  8.     @RequestMapping("/getAddr")
  9.     public Address getAddr(){
  10.         Address addr=new Address();
  11.         addr.setProvince("山西");
  12.         addr.setCity("太原");
  13.         return addr;
  14.     }
  15.     @RequestMapping("/listAddr")
  16.     public List<Address> ListAddr(){
  17.         List<Address> list=new ArrayList<>();
  18.         Address addr=new Address();
  19.         addr.setProvince("山西");
  20.         addr.setCity("太原");
  21.         Address addr2=new Address();
  22.         addr2.setProvince("山");
  23.         addr2.setCity("太");
  24.         list.add(addr);
  25.         list.add(addr2);
  26.         return list;
  27.     }
  28. }

Il test è inserito nel postinohttp://localhost:8080/listAddrQuesto è tutto, altri simili

Ogni metodo esposto all'esterno è chiamato interfaccia funzionale (ad esempio, ci sono tre interfacce sopra) e il percorso è il percorso di accesso.

Il problema affrontato è che i risultati delle risposte sono diversi e l’analisi finale dei risultati è più problematica, quindi i risultati delle risposte devono essere unificati.

Risultati della risposta unificata

  1. public class Result {
  2.     private Integer code;
  3.     private String msg;
  4.     private Object data;
  5. public Result(){
  6.  
  7. }
  8. public Result(Integer code,String msg,Object data){
  9.     this.code=code;
  10.     this.msg=msg;
  11.     this.data=data;
  12.  
  13. }
  14.     public Integer getCode() {
  15.         return code;
  16.     }
  17.  
  18.     public void setCode(Integer code) {
  19.         this.code = code;
  20.     }
  21.  
  22.     public String getMsg() {
  23.         return msg;
  24.     }
  25.  
  26.     public void setMsg(String msg) {
  27.         this.msg = msg;
  28.     }
  29.  
  30.     public Object getData() {
  31.         return data;
  32.     }
  33.  
  34.     public void setData(Object data) {
  35.         this.data = data;
  36.     }
  37.     public static Result success(Object data){
  38.     return new Result(1,"success",data);
  39.     }
  40.     public static Result success(){
  41.         return new Result(1,"success",null);
  42.     }
  43.     public static Result error(String msg){
  44.         return new Result(0,msg,null);
  45.     }
  46.     @Override
  47.     public String toString() {
  48.         return "Result{" +
  49.                 "code=" + code +
  50.                 ", msg='" + msg + ''' +
  51.                 ", data=" + data +
  52.                 '}';
  53.     }
  54. }
  1. @RestController
  2. public class ResponseController {
  3.     @RequestMapping("/hello")
  4.     public Result hello(){
  5.         System.out.println("hello world");
  6.         //return new Result(1,"success","hello world");
  7.         return Result.success("hello world~");//需要给前端传送数据
  8.     }
  9.     @RequestMapping("/getAddr")
  10.     public Result getAddr(){
  11.         Address addr=new Address();
  12.         addr.setProvince("山西");
  13.         addr.setCity("太原");
  14.         return Result.success(addr);
  15.     }
  16.     @RequestMapping("/listAddr")
  17.     public Result ListAddr(){
  18.         List<Address> list=new ArrayList<>();
  19.         Address addr=new Address();
  20.         addr.setProvince("山西");
  21.         addr.setCity("太原");
  22.         Address addr2=new Address();
  23.         addr2.setProvince("山");
  24.         addr2.setCity("太");
  25.         list.add(addr);
  26.         list.add(addr2);
  27.         return Result.success(list);
  28.     }
  29. }

Profilo personale

Si dedica alla ricerca tecnologica da più di 30 anni ed è esperto in vari linguaggi come Java, Linux, Javascript, php, css, ecc. Ha dato numerosi contributi nel campo dell'open source stazione di documentazione per gli sviluppatori per condividere alcuni problemi nello sviluppo della tecnologia per riferimento futuro

le mie informazioni di contatto

Posta