springMvc 接收参数、cookie、header

文章目录

• • pom.xml
  • [配置类 和 springMvc初始化类](#配置类 和 springMvc初始化类)
  • • [配置类 MvcConfig](#配置类 MvcConfig)
    • 初始化类
  • 接收param参数
  • • 直接接收
    • 注解指定
    • 特殊值
    • 使用实体类接值
  • 接收path参数
  • 接收json参数（要用postman测试）
  • • 接收参数的实体类
    • [`需要用到一个 json 的依赖`，并且，在 MvcConfig.java 的配置类上使用](#需要用到一个 json 的依赖，并且，在 MvcConfig.java 的配置类上使用)
    • [MvcConfig 配置类](#MvcConfig 配置类)
  • [存、取 cookie](#存、取 cookie)
  • [取 header](#取 header)

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.cool</groupId>
    <artifactId>ssm-springmvc-part</artifactId>
    <version>1.0-SNAPSHOT</version>

    <packaging>pom</packaging>
    <modules>
        <module>springmvc-base-quick</module>
        <module>springmvc-study-one</module>
    </modules>

    <properties>
        <spring.version>6.0.6</spring.version>
        <servlet.api>9.1.0</servlet.api>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <!-- springwebmvc
            web - servlet
            ioc - spring-context
            mvc - spring-webmvc
     -->

    <dependencies>
        <!-- springioc相关依赖  -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- web相关依赖  -->
        <!-- 在 pom.xml 中引入 Jakarta EE Web API 的依赖 -->
        <!--
            在 Spring Web MVC 6 中，Servlet API 迁移到了 Jakarta EE API，因此在配置 DispatcherServlet 时需要使用
             Jakarta EE 提供的相应类库和命名空间。错误信息 "'org.springframework.web.servlet.DispatcherServlet'
             is not assignable to 'javax.servlet.Servlet,jakarta.servlet.Servlet'" 表明你使用了旧版本的
             Servlet API，没有更新到 Jakarta EE 规范。
        -->
        <dependency>
            <groupId>jakarta.platform</groupId>
            <artifactId>jakarta.jakartaee-web-api</artifactId>
            <version>${servlet.api}</version>
            <scope>provided</scope>
        </dependency>

        <!-- springwebmvc相关依赖  -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- lombok插件：
                    可以使用 @Data 给 实体类自动添加setter、getter、toString方法 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.28</version>
        </dependency>

        <!--  post请求，接收json格式的参数，的时候
                会报一个 415的错误，因为，java原生api识别不了json，只支持 param、path参数
              解决办法：
                这个依赖 + 在配置类上使用@EnableWebMvc（给springmvc的handlerAdpater配置json转化器）
         -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.15.0</version>
        </dependency>
    </dependencies>

</project>

配置类 和 springMvc初始化类

配置类 MvcConfig

package com.cool.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

/**
 * 要做2件事
 *      1、controller 配置ioc容器
 *      2、handlerMapping、handlerAdapter 加入到ioc容器
 */

@EnableWebMvc // 给springmvc的handlerAdpater配置json转化器
              // 加了这个注解，下面两个方法，就可以注掉了，
              // 因为，这个注解，会自动创建handlerMapping、handlerAdapter
@Configuration
@ComponentScan("com.cool.path")
public class MvcConfig {
    // @Bean
    // public RequestMappingHandlerMapping handlerMapping(){
    //     return new RequestMappingHandlerMapping();
    // }

    // @Bean
    // public RequestMappingHandlerAdapter requestMappingHandlerAdapter(){
    //     return new RequestMappingHandlerAdapter();
    // }
}

初始化类

package com.cool.config;

import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

/**
 * 可以被 web项目加载，会初始化ioc容器，会设置 dispatcherServlet的地址
 */
public class SpringMvcInit extends AbstractAnnotationConfigDispatcherServletInitializer {

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[0];
    }

    // 设置配置类
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{MvcConfig.class};
    }

    // 配置springmvc内部自带servlet的访问地址
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}

接收param参数

直接接收

package com.cool.param;

import com.cool.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.List;

@Controller
@RequestMapping("param")
public class ParamController {
    // 直接接收：
    //      路径是这种：/param/data?name=root&age=18
    //      要求：路径上的参数名 和 方法的形参参数名 相同
    //      声明了2个参数，你可以不传，不会报错，获取的就是null
    @RequestMapping("data")
    @ResponseBody
    public String data(String name, int age){
        System.out.println("name= " +name +",age= "+age);
        return "name="+name+",age="+age;
    }
}

---

---

注解指定

package com.cool.param;

import com.cool.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.List;

@Controller
@RequestMapping("param")
public class ParamController {
	// 2、注解指定
    //      要求，必须传递：@RequestParam(value = "account") String userName
    //      要求，不必须传递，但是得给默认值：@RequestParam(required = false, defaultValue = "1") int page
    // 请求路径就是：/param/data1?account=root&page=1
    //            这时候，必须传递account，因为你指定了account，userName已经不生效了
    //            而，page参数，请求路径上可以不传递，方法这里会有默认值
    @GetMapping("data1")
    @ResponseBody
    public String data1(@RequestParam(value = "account") String userName,
                        @RequestParam(required = false, defaultValue = "1") int page){
        System.out.println("userName= " +userName +",page= "+page);
        return "userName="+userName+",page= "+page;
    }
}

---

---

特殊值

package com.cool.param;

import com.cool.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.List;

@Controller
@RequestMapping("param")
public class ParamController {
	// 3、特殊值
    // 一名多值：key=1&k=2，这时候使用 集合 接值
    // param/data2?hbs=吃&hbs=喝&hbs=玩
    //      这时候必须使用 @RequestParam List<String> hbs，必须加上@RequestParam
    //      如果不加@RequestParam，经理会将集合 add加入对应的字符串
    @GetMapping("data2")
    @ResponseBody
    public String data3(@RequestParam List<String> hbs){
        System.out.println("hbs= "+hbs); // hbs= [吃, 喝, 玩]
        return "okok";
    }
}

---

---

使用实体类接值

定义一个用于，接收参数的实体类：

package com.cool.pojo;
import lombok.Data;

@Data
public class User {
	// 使用实体类接值，属性名 必须等于 请求路径上的参数名
    private String name;
    // 实体类这里给属性赋的值，就是请求路径上的参数的默认值
    private Integer age = 18; 
}

package com.cool.param;

import com.cool.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.List;

@Controller
@RequestMapping("param")
public class ParamController {
	// 4、使用实体对象接收参数
    //      /param/data3?name=haha
    //      这样就能，将请求参数 name 和 age 映射到实体类的属性上，
    //      要求：实体类的属性名 必须等于 请求路径上的参数名，否则无法映射！
    @GetMapping("data3")
    @ResponseBody
    public String data3(User user){
        System.out.println("user= "+user.toString());
        return user.toString();
    }
}

---

---

接收path参数

package com.cool.path;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

"路径参数演示，就是这种：/path/账号/密码"

@Controller
@RequestMapping("path")
@ResponseBody
public class PathController {

    /* 动态路径：path/账号/密码
             必须使用 @PathVariable 注解
             @PathVariable(value = "account", required = true)
                value：指定用什么接值，
                required：是否必传
             所以，这个请求路径就是：/path/account/pwd 这种形式的
    */
    @GetMapping("{account}/{pwd}")
    public String login(
    	@PathVariable(value = "account", required = true) String userName, 
    	@PathVariable String pwd){
    	
        System.out.println("userName=" + userName + "pwd=" + pwd); // userName=rootpwd=password
        return "userName=" + userName + "pwd=" + pwd;
    }
}

---

---

接收json参数（要用postman测试）

接收参数的实体类

package com.cool.pojo;
import lombok.Data;

@Data
public class Person {
    private String name;
    private int age;
    private String gender;
}

package com.cool.json;

import com.cool.pojo.Person;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.ArrayList;
import java.util.List;

@Controller
@RequestMapping("json")
@ResponseBody
public class JsonController {

    // post请求，接收 json格式的参数，必须使用 @RequestBody修饰方法的参数
    @PostMapping("data")
    public String data(@RequestBody Person person) {
        System.out.println("person:" + person);
        return person.toString();
    }

    @PostMapping("data1")
    public Person data1(@RequestBody Person person) {
        System.out.println("person:" + person);

        Person person1 = new Person();
        person1.setName(person.getName());
        person1.setAge(person.getAge());
        person1.setGender(person.getGender());

        // 返回的对象，会使用 jackson 的序列化工具，转成json返回给前端
        return person1;
    }

    @PostMapping("data2")
    public List<Person> data2(@RequestBody Person person) {
        Person person1 = new Person();
        person1.setName(person.getName());
        person1.setAge(person.getAge());
        person1.setGender(person.getGender());

        List<Person> list = new ArrayList<>();
        list.add(person1);
        return list;
    }
}

需要用到一个 json 的依赖，并且，在 MvcConfig.java 的配置类上使用

<!--  
post请求，接收json格式的参数，的时候
	会报一个 415的错误，因为，java原生api识别不了json，只支持 param、path参数
解决办法：
	这个依赖 + 在配置类上使用@EnableWebMvc（给springmvc的handlerAdpater配置json转化器）
-->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.0</version>
</dependency>

MvcConfig 配置类

package com.cool.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

/**
 * 要做2件事
 *      1、controller 配置ioc容器
 *      2、handlerMapping、handlerAdapter 加入到ioc容器
 */

@EnableWebMvc // 给springmvc的handlerAdpater配置json转化器
              // 加了这个注解，下面两个方法，就可以注掉了，
              // 因为，这个注解，会自动创建handlerMapping、handlerAdapter
@Configuration
@ComponentScan("com.cool.path")
public class MvcConfig {
//    @Bean
//    public RequestMappingHandlerMapping handlerMapping(){
//        return new RequestMappingHandlerMapping();
//    }
//
//    @Bean
//    public RequestMappingHandlerAdapter requestMappingHandlerAdapter(){
//        return new RequestMappingHandlerAdapter();
//    }
}

---

---

存、取 cookie

package com.cool.cook;

import jakarta.servlet.http.Cookie;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@RequestMapping("cookie")
@ResponseBody
public class CookieController {

    // 取 cookie
    @RequestMapping("data")
    public String data(@CookieValue("cookieName") String value){
        System.out.println("value:"+value);
        return value;
    }

    // 存 cookie
    @GetMapping("save")
    public String save(HttpServletResponse response){
        Cookie cookie = new Cookie("cookieName","root");
        response.addCookie(cookie);
        return "ok";
    }
}

先存一个

再获取

---

---

取 header

请考虑以下带有标头的请求：

Host                    localhost:8080
Accept                  text/html,application/xhtml+xml,application/xml;q=0.9
Accept-Language         fr,en-gb;q=0.7,en;q=0.3
Accept-Encoding         gzip,deflate
Accept-Charset          ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive              300

package com.cool.header;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@RequestMapping("header")
@Controller
@ResponseBody
public class headerController {

    @RequestMapping("data")
    public String data(@RequestHeader("Host") String host, @RequestHeader("Accept-Encoding") String encoding){
        System.out.println("host:"+host + ",encoding:"+encoding);
        return "host= " + host + ",encoding = " + encoding;
    }
}