Spring MVC 请求参数处理全解析

2.4 请求

访问不同的路径，就是发送不同的请求。在发送请求时，可能会带一些参数，所以学习 spring 的请求，主要是学习如何传递参数到后端以及后端如何接收.传递参数，咱们主要是使用浏览器和 postman 来模拟

后端开发人员无需过度关注如何传递参数，了解即可，实际开发中以 postman 测试为主.比如餐厅的厨师，不关注用户是在店里下单，还是外卖平台下单，或者小程序下单，只需要知道如何接收订单，根据订单做出对应的菜肴就可以了.

2.4.1 传递单个参数

接收单个参数，在 spring mvc 中直接用方法中的参数就可以，比如以下代码:

import org.springframework.web.bind.annotation.requestmapping;
import org.springframework.web.bind.annotation.restcontroller;
@restcontroller
@requestmapping("/param")
public class paramcontroller {
    @requestmapping("m1")
    public string method1(string name){
        return "接收到参数name:"+ name;
    }
}

咱们使用浏览器发送请求并传参http://127.0.0.1:8080/param/m1?name=spring

可以看到,后端程序正确拿到了name参数的值

 spring mvc会根据方法的参数名,找到对应的参数,赋值给方法

如果参数不⼀致,是获取不到参数的.

比如请求url:http://127.0.0.1:8080/param/m1?name1=spring 响应结果

那postman中测试的结果

注意事项 ：

使用基本类型来接收参数时,参数必须传(除boolean类型),否则会报500错误

类型不匹配时,会报400错误.

特殊情况：

1.不传参数：报了一个500的状态码，我们看后端日志

通过fiddler观察请求和响应,http响应状态码为500

⼀般看日志堆栈信息的首行,报错信息显示: int类型的参数'age'，虽然为可选的,但由于被声明为基本类型而不能转换为空值.考虑将其声明为对应基本类型的包装类型.

按照错误信息解决错误即可 最开始学习时,会遇到各种各样的问题,我们要养成看错误⽇志的习惯,根据错误⽇志来解决问题

2.传递参数类型不匹配：状态码400

通过fiddler观察请求和响应, http响应状态码为400

注意：对于包装类型,如果不传对应参数，spring接收到的数据则为null 所以企业开发中，对于参数可能为空的数据，建议使⽤包装类型

我们还可以用format进行代码的格式化

@requestmapping("/r4")
public string r3(string name, integer age){
    return string.format("接受到参数：姓名[%s], age[%d]", name, age);
}

作用是接收前端传递的name和age两个参数，并将接收到的参数拼接成字符串返回给前端。

spring mvc 识别接口的核心是「请求路径 + 请求方式（可选）」，而非方法名。

1. spring mvc 的映射核心：spring mvc 会将@requestmapping的路径、请求方式、请求参数、请求头等信息组合成一个唯一的请求映射标识，只要这个标识不重复，即使方法名相同，也能被正确识别和调用。
2. java 方法的重载规则：上述示例中同名的r3方法，参数列表不同（如(string, integer)和(string)），这本身符合 java 的方法重载规则（方法名相同，参数列表不同），因此编译器也不会报错。

import org.springframework.web.bind.annotation.requestmapping;
import org.springframework.web.bind.annotation.restcontroller;
@restcontroller
@requestmapping("/param")
public class paramcontroller {
    // 路径1：/param/r4，方法名r3
    @requestmapping("/r4")
    public string r3(string name, integer age) {
        return string.format("接受到参数：姓名[%s], age[%d]", name, age);
    }
    // 路径2：/param/r5，方法名同样是r3（同名）
    @requestmapping("/r5")
    public string r3(string address) {
        return "接收到参数：地址[" + address + "]";
    }
    // 甚至可以路径相同，但请求方式不同（如get/post），方法名也能相同
    @requestmapping(value = "/r6", method = requestmethod.get)
    public string r3(string email) {
        return "get请求：邮箱[" + email + "]";
    }
    @requestmapping(value = "/r6", method = requestmethod.post)
    public string r3(string phone) {
        return "post请求：手机号[" + phone + "]";
    }
}

2.4.2 传递多个参数

如何接收多个参数呢? 和接收单个参数⼀样,直接使用⽅法的参数接收即可.使用多个形参

@requestmapping("/m2")
public object method2(string name, string password) {
return "接收到参数name:" + name + ", password:" + password;
}

使用浏览器发送请求并传参:http://127.0.0.1:8080/param/m2?name=zhangsan&password=123456

当有多个参数时，前后端进⾏参数匹配时，是以参数的名称进⾏匹配的，因此参数的位置是不影响后端获取参数的结果.

比如访问:http://127.0.0.1:8080/param/m2?password=123456&name=zhangsan 同样可以拿到正 确的结果

可以看到,后端程序正确拿到了name和password参数的值

底层的逻辑是，先用这个特殊符号&进行分割，然后再从你的方法中看用到了啥，然后找到并且使用，所以这个顺序是可以不一样的但是名字必须是一样的

详细解释：

一、先明确：参数传递的 “载体” 与分割符&的作用

当前端通过url 参数（如/param/r4?name=张三&age=20）或表单提交传递参数时，参数的格式是key=value的键值对，多个参数之间用&分隔，&的核心作用就是分割不同的键值对参数，这是 http 协议规定的参数传递格式，和 spring mvc 无关，但却是 spring 处理参数的前提。

举个例子：name=张三&age=20 被&分割后，会得到两个独立的键值对：

• name=张三（键：name，值：张三）
• age=20（键：age，值：20）

二、spring mvc 处理参数的核心步骤

spring mvc 接收到分割后的键值对后，会按照以下逻辑匹配方法参数，这也是参数名必须一致、顺序可以任意的根本原因：

步骤 1：解析请求参数，生成 “参数键值对映射表”

spring 会先把所有请求参数（不管是 url 里的、表单里的）解析成一个 **map<string, string>结构的映射表 **（键是参数名，值是参数值）。比如上面的例子，映射表就是：

{
  "name": "张三",
  "age": "20"
}

步骤 2：根据方法的参数名，从映射表中 “按名取值”

spring mvc 会获取后端方法的参数名（如r3(string name, integer age)中的name和age），然后根据参数名去映射表中查找对应的值，找到后再进行类型转换（比如把字符串"20"转成integer类型），最后把值传递给方法参数。

三、为什么 “顺序可以不一样，名字必须一样”？

1. 顺序可以不一样：因为参数是 “键值对”，不是 “位置依赖”

http 参数是键值对结构，核心是key（参数名），而非参数在 url 中的顺序。比如：

• /param/r4?name=张三&age=20
• /param/r4?age=20&name=张三

这两个请求的参数顺序不同，但解析后的映射表完全一样，spring mvc 按名取值的结果也完全一样，所以方法接收的参数值不会受影响。

2. 名字必须一样：因为 spring 是 “按名匹配”，不是 “按位置匹配”

如果前端传递的参数名和方法参数名不一致，spring mvc 在映射表中找不到对应的键，参数值就会变成null（除非用@requestparam指定别名）。比如：前端请求：/param/r4?username=张三&age=20（参数名是username，不是name）后端方法：public string r3(string name, integer age)此时name参数会是null，因为映射表中只有username，没有name这个键。

四、补充：如果想让参数名不一致怎么办？用@requestparam指定别名

如果前端传递的参数名和后端方法参数名不一样，可以通过@requestparam注解显式指定参数名的映射关系，这是实际开发中很常用的技巧：

@requestmapping("/r4")
public string r3(
    @requestparam("username") string name, // 前端传username，后端用name接收
    integer age
) {
    return string.format("接受到参数：姓名[%s], age[%d]", name, age);
}

此时前端请求/param/r4?username=张三&age=20，就能正确接收到name=张三了。

2.4.3 传递对象

如果参数比较多时,方法声明就需要有很多形参.并且后续每次新增⼀个参数,也需要修改方法声明. 我们不妨把这些参数封装为⼀个对象. spring mvc也可以自动实现对象参数的赋值，比如person对象

如果参数比较多时,方法声明就需要有很多形参.并且后续每次新增⼀个参数,也需要修改方法声明. 我们不妨把这些参数封装为⼀个对象.

spring mvc也可以⾃动实现对象参数的赋值，比如person对象

public class person {
    private int id;
    private string name;
    private string password;
    public int getid() {
        return id;
    }
    public void setid(int id) {
        this.id = id;
    }
    public string getname() {
        return name;
    }
    public void setname(string name) {
        this.name = name;
    }
    public string getpassword() {
        return password;
    }
    public void setpassword(string password) {
        this.password = password;
    }
    @override
    public string tostring() {
        return "person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

传递对象代码实现:

    @requestmapping("/m3")
    public object method3(person p){
        return p.tostring();
    }

 使用浏览器发送请求并传参:http://127.0.0.1:8080/param/m3?id=5&name=zhangsan&password=123456

spring 会根据参数名称自动绑定到对象的各个属性上,如果某个属性未传递,则赋值为null(基本类型则 赋值为默认初识值,比如int类型的属性,会被赋值为0)

2.4.4 后端参数重命名（后端参数映射）

某些特殊的情况下，前端传递的参数 key 和我们后端接收的 key 可以不一致，比如前端传递了一个 time 给后端，而后端是使用 createtime 字段来接收的，这样就会出现参数接收不到的情况，如果出现这种情况，我们就可以使用 @requestparam 来重命名前后端的参数值。

具体示例如下，后端实现代码：

@requestmapping("/r6")
public string r5(@requestparam("sa") string name){
    return "接受到参数: " + name;
}

可以看到，spring 可以正确的把浏览器传递的参数 time 绑定到了后端参数name 参数上此时，如果浏览器使用 name 进行参数传递呢？访问 url:

fildder的使用查看

可以得出结论:

1. 使用@requestparam进行参数重命名时，请求参数只能和@requestparam声明的名称一致，才能进行参数绑定和赋值.
2. 使用@requestparam进行参数重命名时，参数就变成了必传参数.

非必传参数设置如果我们的实际业务前端的参数是一个非必传的参数，针对上述问题，如何解决呢？先来了解下参数必传的原因，我们查看@requestparam注解的实现细节就可以发现端倪，注解实现如下:

@target({elementtype.parameter})
@retention(retentionpolicy.runtime)
@documented
public @interface requestparam {
    @aliasfor("name")
    string value() default "";
    @aliasfor("value")
    string name() default "";
    boolean required() default true;
    string defaultvalue() default "\n\t\t\n\t\t\n\ue000\ue001\ue002\n\t\t\t\t\n";
}

可以看到required的默认值为 true, 表示含义就是：该注解修饰的参数默认为必传既然如此，我们可以通过设置@requestparam中的 required=false 来避免不传递时报错，具体实现如下:

@requestmapping("/m4")
public object method4(@requestparam(value = "time", required = false) string createtime) {
    return "接收到参数createtime:" + createtime;
}

可以看到，添加 required=false 之后，time 前面也加了 key, 变成了 value = "time"注解属性赋值时，没有指明 key 的话，默认为 value 属性.如果需要有多个属性进行赋值时，需要写上 key

2.4.5 传递数组

spring mvc可以⾃动绑定数组参数的赋值

后端实现代码:

 @requestmapping("/m5")
        public string method5(string[] arrayparam) {
            return "返回的数组：" + arrays.tostring(arrayparam);
        }

使用浏览器发送请求并传参:数组参数：请求参数名与形参数组名称相同且请求参数为多个，后端定义数组类型形参即可接收参数

http://127.0.0.1:8080/param/m5?arrayparam=zhangsan&arrayparam=lisi&arrayparam=wangwu或者使用或者使用 http://127.0.0.1:8080/param/m5?arrayparam=zhangsan,lisi,wangwu浏览器响应结果:

可以看到后端对数组参数进行了正确的接收和响应.

或者使⽤postman来发送请求

2.4.6 传递集合

2.4.6 传递集合集合参数：和数组类似，同一个请求参数名有多个，且需要使用 @requestparam 绑定参数关系默认情况下，请求中参数名相同的多个值，是封装到数组。如果要封装到集合，要使用@requestparam 绑定参数关系请求方式和数组类似:

浏览器传参:

方式一: http://127.0.0.1:8080/param/m6?listparam=zhangsan&listparam=lisi&listparam=wangwu

方式二::http://127.0.0.1:8080/param/m6?listparam=zhangsan%2clisi%2cwangwu

%2c 是逗号的转义编码，解码后的 url 为: http://127.0.0.1:8080/param/m6listparam=zhangsan,lisi,wangwu

后端接收代码:

 @requestmapping ("/m6")
 public string method6 (@requestparam list<string> listparam){
 return "size:"+listparam.size() + ",listparam:"+listparam;
 }

2.4.7 传递 json 数据

json 概念

json: javascript object notation【javascript 对象表示法】json 是一种轻量级的数据交互格式。它基于 ecmascript (欧洲计算机协会制定的 js 规范) 的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据。-- 百度百科简单来说: json 就是一种数据格式，有自己的格式和语法，使用文本表示一个对象或数组的信息，因此json 本质是字符串。主要负责在不同的语言中数据传递和交换.

类似于:・国际通用语言 - 英语・中国 56 个民族不同地区的通用语言 - 普通话有自己的语法，其他语言也认识.

json 与 javascript 的关系

没有关系，只是语法相似，js 开发者能更快的上手而已，但是他的语法本身比较简单，所以也很好学

json 语法

json 是一个字符串，其格式非常类似于 javascript 对象字面量的格式

我们先来看一段 json 数据

{
  "squadname": "super hero squad",
  "hometown": "metro city",
  "formed": 2016,
  "secretbase": "super tower",
  "active": true,
  "members": [
    {
      "name": "molecule man",
      "age": 29,
      "secretidentity": "dan jukes",
      "powers": ["radiation resistance", "turning tiny", "radiation blast"]
    },
    {
      "name": "madame uppercut",
      "age": 39,
      "secretidentity": "jane wilson",
      "powers": ["million tonne punch", "damage resistance", "superhuman reflexes"]
    },
    {
      "name": "eternal flame",
      "age": 1000000,
      "secretidentity": "unknown",
      "powers": ["immortality", "heat immunity", "inferno", "teleportation", "interdimensional travel"]
    }
  ]
}

• 小队基础信息
  • "squadname": "super hero squad"：小队名称（超级英雄小队）
  • "hometown": "metro city"：家乡（大都会城）
  • "formed": 2016：成立年份（2016 年）
  • "secretbase": "super tower"：秘密基地（超级塔楼）
  • "active": true：是否活跃（是）
• 成员列表（"members"是数组）数组里包含 3 个英雄对象，每个对象描述一个英雄的信息：
• 第一个英雄（molecule man）
  • "name": "molecule man"：姓名
  • "age": 29：年龄
  • "secretidentity": "dan jukes"：秘密身份
  • "powers": [...]：超能力（抗辐射、变小、辐射爆炸）
• 第二个英雄（madame uppercut）
  • "name": "madame uppercut"：姓名
  • "age": 39：年龄
  • "secretidentity": "jane wilson"：秘密身份
  • "powers": [...]：超能力（百万吨拳、抗伤害、超人反应）
• 第三个英雄（eternal flame）
  • "name": "eternal flame"：姓名
  • "age": 1000000：年龄（100 万岁）
  • "secretidentity": "unknown"：秘密身份（未知）
  • "powers": [...]：超能力（永生、耐热、地狱火、 teleportation、跨维度旅行）

可以压缩表示

{"squadname":"super hero squad","hometown":"metro city","formed":2016,"secretbase":"super tower","active":true,"members":[{"name":"molecule man","age":29,"secretidentity":"dan jukes","powers":["radiation resistance","turning tiny","radiation blast"]},{"name":"madame uppercut","age":39,"secretidentity":"jane wilson","powers":["million tonne punch","damage resistance","superhuman reflexes"]},{"name":"eternal flame","age":1000000,"secretidentity":"unknown","powers":["immortality","heat immunity","inferno","teleportation","interdimensional travel"]}]}

json 的语法:

1. 数据在 键值对 (key/value) 中
2. 数据由逗号 , 分隔
3. 对象用 {} 表示
4. 数组用 [] 表示
5. 值可以为对象，也可以为数组，数组中可以包含多个对象

json 的两种结构

1. 对象：大括号 {} 保存的对象是一个无序的 键值对 集合。一个对象以左括号 { 开始，右括号 } 结束。每个 "键" 后跟一个冒号 :，键值对使用逗号 , 分隔
2. 数组：中括号 [] 保存的数组是值（value）的有序集合。一个数组以左中括号 [ 开始，右中括号 ] 结束，值之间使用逗号 , 分隔。

可 以使⽤在线json格式化⼯具来进⾏校验和书写:在线json校验格式化⼯具（bejson）

json 字符串和 java 对象互转

json 本质上是一个字符串，通过文本来存储和描述数据

spring mvc 框架也集成了 json 的转换工具，我们可以直接使用，来完成 json 字符串和 java 对象的互转本质上是 jackson-databind 提供的功能，spring mvc 框架中已经把该工具包引入了进来，咱们直接使用即可，如果脱离 spring mvc 使用，需要引入相关依赖

<dependency>
    <groupid>com.fasterxml.jackson.core</groupid>
    <artifactid>jackson-databind</artifactid>
    <version>2.13.5</version>
</dependency>

json 的转换工具包有很多，jackson-databind 只是其中的一种. 

public class jsonutils {
    private static objectmapper objectmapper = new objectmapper();
    public static void main(string[] args) throws jsonprocessingexception {
        person person = new person();
        person.setid(5);
        person.setname("zhangsan");
        person.setpassword("123456");
        //对象转为json字符串
        string jsonstr = objectmapper.writevalueasstring(person);
        system.out.println("json字符串为:"+jsonstr);
        //json字符串转为对象
        person p = objectmapper.readvalue(jsonstr,person.class);
        system.out.println("转换的对象 id:"+p.getid()+",name:"+p.getname()+",password:"+p.getpassword());
    }
}

使用 objectmapper 对象提供的两个方法，可以完成对象和 json 字符串的互转

• writevalueasstring: 把对象转为 json 字符串
• readvalue: 把字符串转为对象

json 优点

1. 简单易用：语法简单，易于理解和编写，可以快速地进行数据交换
2. 跨平台支持: json 可以被多种编程语言解析和生成，可以在不同的平台和语言之间进行数据交换和传输
3. 轻量级：相较于 xml 格式，json 数据格式更加轻量级，传输数据时占用带宽较小，可以提高数据传输速度
4. 易于扩展: json 的数据结构灵活，支持嵌套对象和数组等复杂的数据结构，便于扩展和使用
5. 安全性: json 数据格式是一种纯文本格式，不包含可执行代码，不会执行恶意代码，因此具有较高的安全性

基于以上特点，json 在 web 应用程序中被广泛使用，如前后端数据交互、api 接口数据传输等.

传递 json 对象

接收 json 对象，需要使用 @requestbody 注解

requestbody: 请求正文，意思是这个注解作用在请求正文的数据绑定，请求参数必须在写在请求正文中

后端实现:

@requestmapping(value = "/m7")
public object method7(@requestbody person person) {
    return person.tostring();
}

使用 postman 来发送 json 请求参数:

可以看到,后端正确接收了 通过fiddler观察⼀下请求参数

尝试去除掉 @requestbody 试试

@requestmapping(value = "/m7")
public object method7(person person) {
return person.tostring();
}

请求响应结果如下

后端未能成功给person对象赋值.

2.4.8 获取 url 中参数 @pathvariable

path variable: 路径变量和字面表达的意思一样，这个注解主要作用在请求 url 路径上的数据绑定默认传递参数写在 url 上，springmvc 就可以获取到

后端实现代码:

@requestmapping("/m8/{id}/{name}")
public string method8(@pathvariable integer id, @pathvariable("name") string username){
    return "解析参数id:"+id+",name:"+username;
}

使用浏览器发送请求: http://127.0.0.1:8080/param/m8/5/zhangsan或者使用 postman 发送请求

• @requestmapping("/m8/{id}/{name}")
  • 这是 url 路径的占位符写法：{id}和{name}是路径中的动态参数（占位符），表示访问/m8/xxx/xxx时，xxx会被解析为对应的参数值。
• 示例请求 url：http://127.0.0.1:8080/m8/100/spring（此时id=100，name=spring）。
• public string method8(@pathvariable integer id, @pathvariable("name") string username)
• @pathvariable：spring mvc 的注解，用于绑定 url 路径中的占位符参数到方法参数。
  • 第一个参数@pathvariable integer id：路径中{id}的参数值会直接绑定到id（因为参数名和占位符名称一致）。
  • 第二个参数@pathvariable("name") string username：路径中{name}的参数值，通过("name")指定占位符名称，绑定到方法参数username（参数名和占位符名称不一致时，必须显式指定）。
• return "解析参数id:"+id+",name:"+username;
• 将接收到的id和username拼接成字符串返回，作为响应结果。

url 传参方式的验证思路说明：

那我们看他是不是用了url进行传参，就是把你给查询字符串(？后面的东西删除)

看看页面还正常使用么，如果可以就是使用了

2.4.9 上传文件 @requestpart

后端代码实现:

@requestmapping("/m9")
public string getfile(@requestpart("file") multipartfile file) throws ioexception {
    //获取文件名称
    string filename = file.getoriginalfilename();
    //文件上传到指定路径
    file.transferto(new file("d:/temp/" + file.getoriginalfilename()));
    return "接收到文件名称为: "+filename;
}

使用 postman 发送请求:

postman   form-data

• 含义：多部分表单数据（对应 http 的multipart/form-data格式）。
• 用途：
  • 同时传文件和普通参数（比如上传文件 + 传字符串参数）；
  • 支持复杂数据结构（键值对、文件）。
• 典型场景：文件上传接口（比如你之前的@requestpart接口）。

使用 postman 发送请求:

2.4.10 获取 cookie/session

回顾 cookiehttp 协议

自身是属于 "无状态" 协议."无状态" 的含义指的是:

默认情况下 http 协议的客户端和服务器之间的这次通信，和下次通信之间没有直接的联系.

但是实际开发中，我们很多时候是需要知道请求之间的关联关系的.

例如登陆网站成功后，第二次访问的时候服务器就能知道该请求是否是已经登陆过了.

上述图中的 “令牌” 通常就存储在 cookie 字段中.比如去医院挂号

1. 看病之前先挂号。挂号时候需要提供身份证号，同时得到了一张 "就诊卡", 这个就诊卡就相当于患者的 "令牌".
2. 后续去各个科室进行检查，诊断，开药等操作，都不必再出示身份证了，只要凭就诊卡即可识别出当前患者的身份.
3. 看完病了之后，不想要就诊卡了，就可以注销这个卡。此时患者的身份和就诊卡的关联就销毁了.(类似于网站的注销操作)
4. 又来看病，可以办一张新的就诊卡，此时就得到了一个新的 "令牌"

此时在服务器这边就需要记录 "令牌" 信息，以及令牌对应的用户信息，这个就是 session 机制所做的工作.

理解 session

我们先来了解一下什么是会话.会话：对话的意思

在计算机领域，会话是一个客户与服务器之间的不中断的请求响应。对客户的每个请求，服务器能够识别出请求来自于同一个客户。当一个未知的客户向 web 应用程序发送第一个请求时就开始了一个会话。当客户明确结束会话或服务器在一个时限内没有接受到客户的任何请求时，会话就结束了.

比如我们打客服

电话每次打客服电话，是一个会话。

挂断电话，会话就结束了下次再打客服电话，又是一个新的会话.

如果我们长时间不说话，没有新的请求，会话也会结束.

服务器同一时刻收到的请求是很多的。服务器需要清楚的区分每个请求是属于哪个用户，也就是属于哪个会话，就需要在服务器这边记录每个会话以及与用户的信息的对应关系.

session 是服务器为了保存用户信息而创建的一个特殊的对象.

session的本质就是⼀个"哈希表",存储了⼀些键值对结构.key就是sessionid,value就是⽤⼾信息(⽤ ⼾信息可以根据需求灵活设计).

sessionid 是由服务器生成的一个 "唯一性字符串", 从 session 机制的角度来看，这个唯一性字符串称为 "sessionid". 但是站在整个登录流程中看待，也可以把这个唯一性字符串称为 "token".上述例子中的令牌 id, 就可以看做是 sessionid, 只不过令牌除了 id 之外，还会带一些其他信息，比如时间，签名等.

1. 当用户登陆的时候，服务器在 session 中新增一个新记录，并把 sessionid 返回给客户端.(通过 http 响应中的 set-cookie 字段返回).
2. 客户端后续再给服务器发送请求的时候，需要在请求中带上 sessionid.(通过 http 请求中的 cookie 字段带上).
3. 服务器收到请求之后，根据请求中的 sessionid 在 session 信息中获取到对应的用户信息，再进行后续操作。找不到则重新创建 session, 并把 sessionid 返回

session 默认是保存在内存中的.如果重启服务器则session数据就会丢失

cookie 和 session 的区别

• cookie 是客户端保存用户信息的一种机制. session 是服务端保存用户信息的一种机制.
• cookie 和 session 之间主要是通过 sessionid 关联起来的，sessionid 是 cookie 和 session 之间的桥梁
• cookie 和 session 经常会在一起配合使用。但是不是必须配合.
  • 完全可以用 cookie 来保存一些数据在客户端。这些数据不一定是用户身份信息，也不一定是 sessionid
  • session 中的 sessionid 也不需要非得通过 cookie/set-cookie 传递，比如通过 url 传递.

获取cookie

传统获取cookie

   @requestmapping("/getcookie")
    public string getcookie (httpservletrequest request ，httpservletresponse){
            cookie[] cookies =  request.getcookies();
            stringbuilder stringbuilder = new stringbuilder();
if(cookies != null){
       for ( cookie cookie :cookies) {
          stringbuilder.append("这个cookie 的名字是").append(cookie.getname()).append(cookie.getvalue()).append("/n");
       }
       }else {
           stringbuilder.append("这个cookies 里面没有任何值  ");
       }
         return stringbuilder.tostring();
   }

f12开发者工具也很好用

补充说明

spring mvc 是基于 servlet api 构建的原始 web 框架，也是在 servlet 的基础上实现的

httpservletrequest , httpservletresponse 是 servlet 提供的两个类，是 spring mvc 方法的内置对象，需要时直接在方法中添加声明即可.

httpservletrequest 对象代表客户端的请求，当客户端通过 http 协议访问服务器时，http 请求头中的所有信息都封装在这个对象中，通过这个对象提供的方法，可以获得客户端请求的所有信息.

httpservletresponse 对象代表服务器的响应.http 响应的信息都在这个对象中，比如向客户端发送的数据，响应头，状态码等。通过这个对象提供的方法，可以获得服务器响应的所有内容

spring mvc 在这两个对象的基础上进行了封装，给我们提供更加简单的使用方法.

使用注解的传递单个cookie

//使用注解传递的值
    @requestmapping("/gettworequest")
    public string getcookie(@cookievalue("name") string cookie){
        return " 这个值是 " + cookie;
    }

获取 session

session 存储和获取

session 是服务器端的机制，我们需要先存储，才能再获取session 也是基于 httpservletrequest 来存储和获取的

session 存储

@requestmapping("/setsess")
public string setsess(httpservletrequest request) {
    // 获取session对象
    httpsession session = request.getsession();
    if (session != null) {
        session.setattribute("username", "java");
    }
    return "session 存储成功";
}

获取 session 有两种方式

httpsession getsession(boolean create);
httpsession getsession();

• httpsession getsession(boolean create)：参数如果为 true，则当不存在会话时新建会话；参数如果为 false，则当不存在会话时返回 null
• httpsession getsession()：和getsession(true)含义一样，默认值为true。
• void setattribute(string name, object value)：使用指定的名称绑定一个对象到该 session 会话

session 读取

读取 session 可以使用 httpservletrequest

@requestmapping("/getsess")
public string sess(httpservletrequest request) {
    // 如果 session 不存在，不会自动创建
    httpsession session = request.getsession(false);
    string username = null;
    if (session != null && session.getattribute("username") != null) {
        username = (string) session.getattribute("username");
    }
    return "username: " + username;
}

• object getattribute(string name)：返回在该 session 会话中具有指定名称的对象，如果没有指定名称的对象，则返回 null。

运行

先设置 session: http://127.0.0.1:8080/param/setsess

先设置session:http://127.0.0.1:8080/param/setsess

通过fiddler观察http请求和响应

可以看到,http响应中,通过set-cookie告知客⼾端,把sessionid存储在cookie中 通过浏览器,可以观察到运⾏结果:

可以看到,http请求时,把sessionid通过cookie传递到了服务器.

通过springmvc内置对象httpsession来获

@requestmapping("/getsess2")
public string sess2(@sessionattribute(value = "username",required = false)
string username) {
    return "username: "+username;
}

运行结果（getsess2）

地址：http://127.0.0.1:8080/param/getsess2页面显示：username: java

简洁获取 session (2)

通过 spring mvc 内置对象 httpsession 来获取

代码 2

@requestmapping("/getsess3")
public string sess3(httpsession session) {
    string username = (string)session.getattribute("username");
    return "username: "+username;
}

补充说明

httpsession session = request.getsession();session 不存在的话，会自动进行创建

运行结果（getsess3）

地址：http://127.0.0.1:8080/param/getsess3页面显示：username: java

2.4.11 获取 header

传统获取 header

获取 header 也是从 httpservletrequest 中获取

@requestmapping("/param10")
public string param10(httpservletrequest request, httpservletresponse response)
{
    string useragent = request.getheader("user-agent");
    return name + ":" + useragent;
}

• 使用 httpservletrequest 提供的 getheader 方法来获取，参数对应 http 请求报头的 "key"

运行结果:

补充说明

通过 fiddler 观察，获取的 user-agent 是否正确

简洁获取 header

@requestmapping("/header")
public string header(@requestheader("user-agent") string useragent) {
    return "useragent: " + useragent;
}

• @requestheader注解的参数值为 http 请求报头中的 "key"

运行结果

地址：http://127.0.0.1:8080/param/getheader2

到此这篇关于spring mvc 请求参数处理全解析的文章就介绍到这了,更多相关spring mvc请求参数内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！