[Spring] Spring Web MVC基础理论

1. 什么是spring web mvc

spring web mvc是基于servlet api构建的原始web框架，从⼀开始就包在spring框架中。它的正式名称“spring web mvc”来自其源模块的名称(spring-webmvc)，但它通常被称为"spring mvc".
总结来说,spring web mvc是一个web框架.
想要理解什么是spring mvc我们首先先要理解什么是mvc

1.1 什么是mvc

mvc是model view controller的缩写,是软件工程中共的一种软件架构的设计模式.把软件系统分为模型,控制器,视图三个部分.

• view(视图): 指的是在应用中专门用来与浏览器交互,展示数据的资源.
• model(模型): 只应用程序的主题部分,用来处理程序中数据逻辑的部分.
• controller(控制器): 可以理解为一个分发器,用来决定对于视图发来的请求,需要哪一个模型来处理,以及处理之后需要跳回哪个视图.即用来连接视图和模型.

1.2 什么是spring mvc

mvc是一种架构模式,也是一种思想.而spring mvc是对mvc思想的具体实现.除此之外,spring mvc还是一个web框架.
总结:spring mvc是一个实现了mvc软件设计模式的web框架.
其实spring mvc在前面我们就使用过了.在我们创建spring boot项目的时候,选择spring web的时候,其实就是spring mvc框架.也就是在创建的spring boot项目中添加了spring web mvc 的相关依赖,使得该项目具有了网络通信的功能.

• 那么这时候问题又来了,spring boot和spring mvc究竟有什么关系?
  spring boot只是实现spring mvc的一种方式而已.spring boot中可以添加很多依赖,我们在spring boot项目中添加了spring mvc的框架,那么这个spring boot项目就可以实现web的功能.

不过spring mvc在实现mvc模式的时候,也结合了自身的一些特点,下面这个图更加适合描述spring mvc.

通过浏览器来向后端发送请求的时候,没有经过view,而是直接把请求传递给了controller,之后controller选择合适的模型,传递给model,model处理数据之后,把响应返回给controller,之后controller再把响应返回给view,之后view把响应返回给浏览器.

2. spring mvc深入学习

学习spring mvc,重点也就是学习用户通过浏览器与服务端交互的过程.
主要分为一下三个点:

• 建立连接:将用户(浏览器)和java程序连接起来,也就是java程序打开了大门,允许外界访问.此时访问的地址能够调用我们的spring程序.
• 传递参数:用户请求的时候会带一些参数.这些参数会传递到后端,在后端程序中要想办法获取到参数.
• 返回结果:执行了业务逻辑之后,需要把执行的结果返回给用户,也就是响应.

掌握了上面的三个功能就相当于掌握了spring mvc.

2.1 建立连接

在spring mvc中使用@requestmapping来实现url的路由映射,也就是通过这个注解来使得spring项目与浏览器建立连接.代码如下:

package com.example.demo;
import org.springframework.web.bind.annotation.*;
@restcontroller
public class democontroller {
    @requestmapping("/hello")//可以理解为资源路径
    public string hello() {
        return "hello world";
    }
}

接下来访问http://127.0.0.1:8080/hello就可以看到返回的程序了.

2.2.1 @requsetmapping注解介绍

@requestmapping是spring web mvc应用程序最常被用到的注解之一.它用来注册接口的路由映射.表示的是,服务器在接收到请求的时候,路径为/hello的请求就会调用hello这个方法的代码.

• 问题:既然@requestmapping已经达到了我们的目的,我们为什么还要加@restcontroller呢?
  @restcontroller在资源访问的过程中起着相当重要的作用,在spring项目接收到一个请求之后,spring会对所有的类进行扫描,如果家里注解@restcontroller,spring才会去看这个类里面有没有加@requestmapping这个注解,才可以通过浏览器中输入的url对应到这个类中注册的路由映射.
  如果我们把@restcontroller去掉,就访问不到了.

package com.example.demo;
import org.springframework.web.bind.annotation.*;
@requestmapping("/demo")
public class democontroller {
    @requestmapping("/hello")//可以理解为资源路径
    public string hello() {
        return "hello world";
    }
}

2.2.2 @requsetmapping的使用

不仅仅方法前面可以加上@requestmapping注解,类的前面也可以加该注解,即@requestmapping不仅仅可以修饰方法,还可以修饰类.当修饰类和方法的时候,访问的地址是类路径+方法路径

package com.example.demo;
import org.springframework.web.bind.annotation.*;
@restcontroller
@requestmapping("/demo")
public class democontroller {
    @requestmapping("/hello")//可以理解为资源路径
    public string hello() {
        return "hello world";
    }
}

那么在访问hello这个方法的时候,路径就会变为/demo/hello.

注: 注解中的/hello和"demo"虽然不加/也可以正确响应,但是为了编程的规范,还是建议加上.

2.2.3 @requsetmapping支持哪些方法类型的请求

首先给出结论,@requsetmapping支持所有方法类型的请求.下面我们来通过postman构造请求来实验一下.

get方法支持

post方法支持
剩下的方法都是同样的道理,显示的结果都是hello world,这里不再一一展示.

• 那么如何使@requsetmapping只接受指定的几种方法的请求呢?
  我们就需要再注解中加上另外的一个参数,method键值对

@requestmapping(value = "/hello1",method = requestmethod.get)
public string hello1() {
    return "hello world 1";
}

我们看到/hello1对应的路由映射只支持get方法.
现在我们去看看method键值对截取的部分源码

public @interface requestmapping {
    string name() default "";

    @aliasfor("path")
    string[] value() default {};

    @aliasfor("value")
    string[] path() default {};

    requestmethod[] method() default {};//method返回的是一个requestmethod类型的数组

    string[] params() default {};

    string[] headers() default {};

    string[] consumes() default {};

    string[] produces() default {};
}

在源码中,我们可以看到,method返回的是一个requestmethod类型的数组.那么这个requestmethod中都有什么,我们再去查看截取的部分源码.

public enum requestmethod {
    get,
    head,
    post,
    put,
    patch,
    delete,
    options,
    trace;
}

这里我们可以看到requestmethod是一个枚举类型,这里面存放的都是请求中的方法.
由于method那里接收的是一个关于requestmethod枚举类型的数组,所以我们在注解后的键值对的值上传入的也是枚举类型的数组,比如我们想支持get和post两种方法:

@requestmapping(value = "/hello1",method = {requestmethod.get, requestmethod.post})
public string hello1() {
    return "hello world 1";
}

当然当元素只有一个的时候,大括号是可以省略的.就比如上面那个只有get方法的例子.

• 如果指定的方法只有一种,我们也可以采用其他注解来解决
  比如只支持get方法,我们就可以使用@getmapping注解来解决.

@getmapping("/hello3")
public string hello3() {
    return "hello world 3";
}

在比如只支持post方法,可以使用@postmapping来解决

@postmapping("/hello4")
public string hello4() {
    return "hello world 4";
}

2.3 请求

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

2.3.1 传递单个参数

在前面,我们的方法都是没有参数存在的,如果给我们的方法加上参数之后会怎么样呢?

@requestmapping("/name1")
public string name1(string name) {
    system.out.println("接收到了" + name);
    return "接收到了" + name;
}

我们在请求的url中加上查询字符串,即参数:http://127.0.0.1:8080/demo/name1?name=zhangsan(?后面的是参数)
在url中加上的参数传入到后端之后,spring mvc会根据方法的参数名,找到对应的参数,赋值给方法.之后拿到传入的参数在方法中进行一系列操作之后返回给前端.比如我们将这个请求通过postman发送给spring项目.

我们发现成功返回了响应,并且返回了正确的响应.
如果参数不一致,则获取不到参数.

• 注意事项:参数类型是包装类型和基本类型的区别
  • 当参数类型是包装类型和基本类型的时候,传入的参数spring进行隐式转换之后发现参数类型不一致均会报400错误.

  @requestmapping("/age1")
  public string age1(int age) {
      system.out.println("接收到了" + age);
      return "接收到了" + age;
  }
  @requestmapping("/age2")
  public string age2(integer age) {
      return "接收到了" + age;
  }
  

  
  
  • 但是如果我们不传递任何参数的时候,这时候基本类型和包装类型就会有所区别,基本类型会直接抛出500错误,而包装类型会输出默认的空值null.
    
    
    所以,我们在企业开发中,对于参数可能为空的数据,我们建议使用包装类型.

2.3.2 传递多个参数

和接收单个参数⼀样,直接使用方法的参数接收即可.使用多个形参.

@requestmapping("/person1")
public string person1(string name,integer age) {
    return "接收到了name" + name + "接收到了age" + age;
}

注:

1. 也可以通过构造form表单来发送请求,这时候在url中就没有了参数的存在,参数跑到了请求中的正文内容.
2. 如果在项目运行的过程中,我们要对方法的参数进行修改,我们不建议在原来的方法上直接进行修改,而是另起一个方法重新写.

2.3.3 传递对象

如果需要传递的参数比较多的时候,我们不妨把这些参数封装成一个对象.

@requestmapping("/person3")
public string person3(person person) {
    return person.getname()+person.getage()+person.getsex();
}
package com.example.demo;

public class person {
    public string name;
    public int age;
    public string sex;

    public string getname() {
        return name;
    }
    public void setname(string name) {
        this.name = name;
    }
    public int getage() {
        return age;
    }
    public void setage(int age) {
        this.age = age;
    }
    public string getsex() {
        return sex;
    }
    public void setsex(string sex) {
        this.sex = sex;
    }
}

之后我们使用postman进行请求发送.http://127.0.0.1:8080/demo/person3?name=zhangsan&age=20&sex=男

注意:

1. 如果某个基本类型的参数未传递,如果这个基本类型参数是一个类中的成员变量,如果这个参数未传递,那么这个参数会有默认的初始值,这一点是和上面直接把基本参数类型的参数写在方法的参数列表中是不一样的.比如我没有传入age参数.
   
   我们可以看到age的初始值被默认赋值为了0.
2. 如果我们针对参数是对象的使用form表单进行参数传递,在get和post两种方法中,只有post方法会返回正确的结果,而get方法会返回默认的空值.
   
   

2.3.4 后端参数重命名

在一些特殊的情况下,前端传递的参数key和我们后端接收的key可能不⼀致,比如我们传递了一个name给后端,但是后端需要接收的参数是name,这时候就需要用到@requestparam(翻译:请求参数)来对后端的参数进行重命名.

@requestmapping("/person2")
public string person2(@requestparam("name") string name,integer age) {
    return "接收到name" + name + "接收到age" + age;
}

上面这段代码,其中name就是前端要传递的参数,而name是后端使用的参数,此时spring可以正确的把请求传递的参数name绑定到后端参数name参数上.
我们使用http://127.0.0.1:8080/demo/person2?name=zhangsan&age=20来进行请求传递

如果我们把name改成name,就无法进行正确的参数传递了.

[注意事项]
在使用@requestparam对参数进行重命名的时候,参数就变成了必传参数.

那么造成上面这种情况的原因是什么呢,又该如何让他变成一个非必传参数呢?现在我们来查看@requestparam的源码:

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("/person2")
public string person2(@requestparam(value = "name",required = false) string name,integer age) {
    return "接收到name" + name + "接收到age" + age;
}

此时name为传递的时候,会有默认的初始值null来返回.

2.3.5 传递数组

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

@requestmapping("/param1")
public string param1(string[] arrayparam) {
    return arrays.tostring(arrayparam);
}

使用postman进行传参:

• 请求参数名与形参数组名称相同且请求参数为多个,后端的方法形式参数中即可自动接收传输过来的参数.
  
• 把所要传递的参数合并在一起传递,中间用逗号隔开.
  
  可以看到以上两种方法均返回了正确的响应.
• 我们如果使用from表单进行发送的话,这时候请求get和post就只有post返回的是正确的结果,而get返回的是null.
  

2.3.6 传递集合

集合参数: 和数组传递参数的方法类似,可以是相同的参数名多个参数,也可以把参数写到一起,但是在后端那里,需要加上@requestparam来绑定参数关系.
默认的情况下,请求中的参数名相同的多个值,封装的时候是一个数组,而如果要封装集合的话,就需要在参数前面加上@requestparam来绑定参数关系,表示传过来的是一个数组,需要转换成集合.

@requestmapping("/param2")
public string param2(@requestparam("arrayparam") list<string> arrayparam) {
    return arrays.tostring(arrayparam.toarray());
}

如果不加注解后面的参数的话,在前端传递参数的时候默认就和后端的方法参数是一样的.

2.3.7 传递json数据

• 什么是json
  json就是⼀种数据格式,有自己的格式和语法,使用文本表示一个对象或数组的信息,因此json本质是字符串.主要负责在不同的语言中数据传递和交换.
• json的语法
  json是一个字符串,其格式非常类似于python中的字典和javascript对象字面量的格式.
  1. 数据存储在键值对(key/value)中,key和value之间用:分割.
  2. 键值对之间由,分割.
  3. 对象用{ }表示
  4. 数组用[ ]表示
  5. 值可以为对象,数组,字符串等等.
• json的两种结构
  1. 对象: 大括号{}保存的对象是⼀个无序的键值对集合.⼀个对象以左括号{ 开始，右括号}结束。每个"键"后跟⼀个冒号: ,键值对使用逗号,分隔
  2. 数组: 中括号[]保存的数组是值（value）的有序集合.⼀个数组以左中括号[开始，右中括号]结束，值之间使用逗号, 分隔,数组中可以存放多个对象,对象和对象之间用,分割.

下面我们展示一段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,"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在线工具来校验json的书写,如https://www.json.cn/.

• json字符串和java对象的互转
  spring mvc框架集成了json的转换工具,我们可以直接拿来使用.我们可以使用objectmapper中的一系列方法来对json和java对象两者之间进行转换.

package com.example.demo;
import com.fasterxml.jackson.core.jsonprocessingexception;
import com.fasterxml.jackson.databind.objectmapper;
public class json {
    private static objectmapper objectmapper = new objectmapper();
    public static void main(string[] args) throws jsonprocessingexception {
        person person = new person();
        person.setname("zhangsan");
        person.setage(18);
        person.setsex("男");
        string json = objectmapper.writevalueasstring(person);
        system.out.println(json);
        person person2 = objectmapper.readvalue(json, person.class);//传入一个json字符串和一个类的类对象
        system.out.println(person2.tostring());
    }
}

package com.example.demo;
public class person {
    public string name;
    public int age;
    public string sex;

    public string getname() {
        return name;
    }
    public void setname(string name) {
        this.name = name;
    }
    public int getage() {
        return age;
    }
    public void setage(int age) {
        this.age = age;
    }
    public string getsex() {
        return sex;
    }
    public void setsex(string sex) {
        this.sex = sex;
    }
    @override
    public string tostring() {
        return "person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}

• 如何传递json对象
  接收json对象,需要使用@requestbody注解,这个注解翻译过来就是请求正文的意思,意思是这个注解起到的作用是从请求中的正文部分获取数据.请求的参数必须写在正文中.而我们的json字符串就写在请求的正文中.
  后端是这样实现的:

@requestmapping("/param3")
public string param3(@requestbody person person) {
    return person.tostring();
}

接下来我们使用postman构造请求,把json字符串写入请求的正文中:

{
    "name":"zhangsan",
    "age":18,
    "sex":"male"
}

响应结果如下:

如果去掉注解@requestbody,那么后端就无法正确接收json数据,前端返回的响应也不正确.

由于后端没有接收到关于person对象传递的任何信息,所以都默认都赋值为了初始值.

2.3.8 获取url中的参数@pathvariable

pathvariable翻译过来之后,是"路径可变"的意思,意思是我们要通过url获取路径作为传递过来的参数,而这个路径是不固定的.
这个注解主要的作用就是在请求url路径上的数据绑定.之前我们通过http请求传递参数都是在?后面的查询字符串中.而现在我们要通过url中的资源路径来传递参数.
后端代码实现如下:
在@requestmapping的参数中在加上一些路径的标识,每个参数外面使用{ }括起来.

@requestmapping("/param4/{name}/{age}")
public string param4(@pathvariable string name,@pathvariable integer age){
    return name+age;
}

我们通过postman来构造请求http://127.0.0.1:8080/demo/param4/zhangsan/18

我们看到前端返回了正确的响应.
[注意事项]
如果方法参数名称和需要绑定的url中的变量名称不⼀致时,需要@pathvariable的属性value赋值.

@requestmapping("/param4/{name}/{age}")
public string param4(@pathvariable("name") string name,@pathvariable("age") integer age){
    return name+age;
}

前端还是会返回正确的响应.

2.3.9 上传文件@requestpart

后端代码实现:

@requestmapping("/param5")
public string param5(@requestpart("file") multipartfile file) throws ioexception {
    file.transferto(new file("d:/personal/" + file.getoriginalfilename()));
    //上传文件,前面写的是存储文件的路径,后面加上原文件的名字
    return "已经获取到" + file.getoriginalfilename();
}

使用postman向指定位置发送文件.

指定位置接收到了文件.

2.3.10 获取cookie/session

• 回顾cookie和session
  cookie中的内容和url中的query string内容类似,都是键值对内容,它们都是程序员自定义的.每个键值对之间用";“隔开,键和值之间用”="隔开.
  

  • cookie是浏览器本地存储的一种机制,cookie本质上可以在客户端的硬盘上持久化保存的.是浏览器给网页的一种能够持久化存储数据的机制.
  • 有的网站,需要在客户端这边存储一些必要的信息,希望可以持久化存储,于是浏览器就给网页提供了cookie,是浏览器对于硬盘的操作做了一些特殊的封装,相当于提供了一个或者一组特殊的文件,并且内容只能是键值对.
  • 那么cookie是具体如何保存的呢?
    浏览器会针对不同的域名,每个网站都有自己的cookie文件保存在硬盘中.
  • cookie从哪里来?
    cookie中的数据,来自于服务器(服务器返回给浏览器的数据),访问网站的时候,网站的服务器会返回http响应,在http响应中,会包含set-cookie这样的header,它就会把一些键值对保存到浏览器的cookie中.cookie保存到浏览器之后,后续浏览器访问该网站的时候,就会在请求的header中,把之前保存的键值对都带入进去,在返回给服务器.
  • 那么问题又来了,为什么还要返回给服务器?
    这是因为cookie可以使客户端存储一些必要的"配置信息",从而让服务器对于用户提供的服务更加"个性化".

和上面剪头发是相同的道理,客户端也不止有一个,每个客户端都会有自己的偏好,此时就需要让每个客户端保存这样的数据,之后就可以通过cookie随时把这样的信息返回给服务器.例如:浏览器的夜间模式和白日模式,一次设置好了之后,下次再打开服务器的时候,浏览器的颜色模式不会改变.

• cookie自动登录
  cookie中虽然有很多的键值对都是程序员自定义的,但是往往会有一个特殊的键值对,用来标识用户的身份信息.
  
  • 首先在获取登录页面与返回登录登录页面的html的过程中不包含任何的cookie.
  • 在用户输入用户名和密码之后,这时候用户名和密码就会交给服务器,验证它们的正确性,在确认正确之后,就会创建会话(session),(会话可以理解为一个类,其中类中具体包含什么,要看业务逻辑,但是其中一定有sessionid,也就是令牌)并把sessionid返回给浏览器,这个sessionid存在于响应报文header中的set-cookie中,我们也可以把他叫做"令牌",令牌中存储的是一个字符串,类似于"身份标识",不会存储太多的信息,在浏览器收到sessionid之后,就会把id存储在硬盘中,即创建了cookie.
  • 在之后客户端要访问该域名下的其他页面的时候,就可以把sessionid交给服务器,服务器获取到sessionid之后,就可以根据这个值,知道用户的详细信息.也就是直接通过之前创建的sessionid的cookie就可以访问到,无需再次登录.

• 使用spring获取cookie
  • 传统获取cookie

    @requestmapping("/param6")
    public string param6(httpservletrequest request, httpservletresponse response) throws ioexception  {
        cookie[] cookies = request.getcookies();
        for (cookie cookie : cookies) {
            system.out.print(cookie.getname()+":"+cookie.getvalue());
        }
        return "已经获取到cookie";
    }
    

    之后我们通过浏览器伪造cookie,来向后端传递请求.http://127.0.0.1:8080/demo/param6
    
    我们看到了后端已经成功拿到了cookie中的数据.
    
    spring mvc是spring基于servlet实现的.其中上面一段代码中的httpservletrequest和httpservletresponse是servlet提供的两个类.这两个类在每一个接口中均默认存在,需要的时候写出来就可以.
    httpservletrequest 对象代表客户端的请求.请求中的所有信息均可以通过这个类拿到.
    httpservletresponse对象代表服务器的响应.响应中的所有信息均可以通过这个类拿到.
  • 获取cookie中的某一个键值对
    方法一: 使用equals()方法

    @requestmapping("/param7")
    public string param7(httpservletrequest request) {
        cookie[] cookies = request.getcookies();
        for (cookie cookie : cookies) {
            if ("bite".equals(cookie.getname())) {
                return cookie.getvalue();
            }
        }
        return "为获取到指定的cookie";
    }
    

    通过浏览器构造cookie,我们看到了前端返回了正确的响应.
    
    后端打印了相应的日志:
    
    方法二:通过@cookievalue注解获取.

        @requestmapping("/param8")
        public string param8(@cookievalue("bite") string bite) {
            system.out.println("获取到了" + bite);
            return bite;
        }
    

    前端与后端响应均正确:
    
    
• session的存储和获取
  session是服务器端的机制,它需要先存储,才能获取到.
  • session的存储

    @requestmapping("/param9")
    public string param9(httpservletrequest request){
        //获取session对象,如果不存在session对象,getsession之后不加或参数为true会自动创建
        httpsession session = request.getsession();
        if (session != null) {//确保session成功创建
            session.setattribute("bite", "888");
        }
        return "session存储成功";
    }
    

    方法解释:
    getsession(boolean create): 如果参数为true的时候,就会在session不存在的时候,自动创建session,如果参数为false,就不会创建.
    getsession():和上一种方法参数为true的时候效果相同.
    setattribute(string s,string o):设置session中的参数.
  • session的读取
    读取session依然使用httpservletrequest

    @requestmapping("/param10")
    public string param10(httpservletrequest request){
        httpsession session = request.getsession(false);
        if (session != null){
            string s = (string) session.getattribute("bite");
            system.out.println("获取到了session");
            return s;
        }
        return "未获取到session";
    }
    

  • 运行
    [注意事项] 在重启服务器之后,上一次存在内存中的session数据会被清空,需要重新设置session之后才可以获取到.
    
    我们可以看到,存储了session之后,浏览器把sessionid存储在了cookie中.
    
    之后我们可以使用浏览器存储的令牌获取session.
    
  • 简洁获取session
    上面获取session的方法比较传统,我们下面展示两种简洁的方法.
    方法一:使用@sessionattribute注解

    @requestmapping("/param11")
    public string param11(@sessionattribute(value = "bite",required = false)
                          string bite){
        return bite;
    }
    

    运行结果如下:
    @sessionattribute的后面两个注解表示的意思和前面@requestparam注解后面的两个参数的作用非常像.第一个作用是参数绑定的作用,第二个参数如果为true或者不写,表示这个参数是必传参数,如果为false,就是非必传参数,如果session传递未成功,就返回null.
    方法二:直接使用httpsession作为参数

    @requestmapping("/param12")
    public string param12(httpsession session){
        string string = (string) session.getattribute("bite");
        system.out.println("成功获取到了session");
        return string;
    }
    

    httpsession作为参数的时候,效果和getsession()方法一样,在没有session的时候,会自动创建session.
    运行结果如下:
    

2.3.11 获取header

• 传统获取方法
  传统的方法依然是从httpservletrequst中获取.

@requestmapping("/param13")
public string param13(httpservletrequest request){
    return request.getheader("user-agent");
}

我们使用getheader方法来获取header.在后面的参数是header中的"key".
运行测试:

下面是我们通过抓包软件抓取的网络通行信息.我们发现header中的user-agent一栏与浏览器上的一致.

• 简洁获取方法
  通过@requestheader注解来获取,在注解后面加上需要获取header中的"key".

@requestmapping("/param14")
public string param14(@requestheader("sec-ch-ua-platform") string string){
    return string;
}

运行结果:

与抓包工具中的结果一致:

2.4 响应

在我们前面代码的例子中,每次浏览器都会返回响应的响应,而前面的响应都是数据响应,响应还可以是页面,状态码,header等.

2.4.1 返回静态页面

首先我们需要穿件一个前端页面index.html.创建的文件放在static目录下.

<!doctype html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>title</title>
</head>
<body>
<h1>我是index文件</h1>
</body>
</html>

[注意] 在写完前端文件之后,不要通过idea右上角的浏览器小图标的方式打开,我们需要通过后端返回页面的方式打开.

下面我们展示一种后端代码的写法:

@requestmapping("/demo2")
@restcontroller
public class democontroller2 {
    @requestmapping("/param1")
    public object param1(){
        return "/index.html";
    }
}

我们看到,浏览器并没有返回对应的html页面,而是直接返回了一串字符串数据.那么怎么解决呢.我们需要把@restcontroller注解变成@controller注解.

@requestmapping("/demo2")
@controller
public class democontroller2 {
    @requestmapping("/param1")
    public object param1(){
        return "/index.html";
    }
}

我们看到这次浏览器返回了对应的html页面.

• 那么@restcontroller和@controller有什么区别呢?
  @restcontroller一般用来返回数据,这些数据的响应报头中的content-type都是text/html格式的,@controller一般用来返回视图.这个视图一般是用前端的代码写好的文件.就是前面我们在mvc设计模式中提到过的视图(view).
  @restcontroller == @controller + @responsebody.其中@controller表示的是我们前面我们mvc模式中的控制器.而@responsebody表示的是响应正文,定义返回的数据为非视图模式.
  @restcontroller的源码如下,我们也可以看到这个注解上面也标有@controller + @responsebody两个注解:

@target({elementtype.type})
@retention(retentionpolicy.runtime)
@documented
@controller
@responsebody
public @interface restcontroller {
    @aliasfor(
        annotation = controller.class
    )
    string value() default "";
}

2.4.2 返回数据@responsebody

上面我们提到了@responsebody注解表示的是返回数据,也就是以text/html的格式返回
@responsebody即是类注解又是方法注解.给类加上该注解之后,就表示类中所有的方法返回的都是数据,给方法加上之后,表示的是只有这个方法返回的是数据.

如果一个类中即有页面要返回,也有数据要返回,就在需要返回数据的方法上面加上@responsebody.类的控制器使用@controller.

@requestmapping("/demo2")
@controller
public class democontroller2 {
    @requestmapping("/param1")
    public object param1(){
        return "/index.html";
    }
    @requestmapping("param2")
    @responsebody
    public object param2(){
        return "string";
    }
}

浏览器返回的视图与数据如下:

2.4.3 返回html代码片段

    @requestmapping("/param3")
    @responsebody
    public string param3(){
        return "<h1>我是html~</h1>";
    }

2.4.4 返回json

后端返回json的方法是使用对象返回.可以使用hashmap返回,也可以另外创建一个对象,按属性返回.
方法一:创建hashmap

@requestmapping("/param4")
@responsebody
public hashmap<string,integer> param4(){
    hashmap<string, integer> map = new hashmap<>();
    map.put("aa",1);
    map.put("bb",2);
    map.put("cc",3);
    return map;
}

浏览器返回响应,是json格式的数据:

方法二:通过类中的属性

@requestmapping("/param5")
@responsebody
public person param5(){
    person person = new person();
    person.setname("zhangsan");
    person.setage(19);
    person.setsex("male");
    return person;
}

浏览器返回响应,依然是json格式的数据,返回的是对象中属性的值:

2.4.5 设置状态码

springmvc也为程序员提供了自定义状态码的功能,可以让程序员手动指定状态码.
使用httpservletresponse+setstatus方法访问到响应中的状态码.

@requestmapping("/param6")
@responsebody
public string param6(httpservletresponse response){
    response.setstatus(400);
    return "设置状态码为400";
}

浏览器返回响应,需要注意的是,我们自定义的错误状态码返回的不一定是浏览器报错的一大坨信息,状态码并不影响页面的显示.

我们通过抓包工具发现,响应的状态码被设置为了400.图标也变为了红色.

2.4.6 设置header

http响应报头也会向客户端传递一些附加信息,如:content-type,local等.这些信息就是通过@requestmapping来实现的.先来看一看@requestmapping的源码:

@target({elementtype.type, elementtype.method})
@retention(retentionpolicy.runtime)
@documented
@mapping
@reflective({controllermappingreflectiveprocessor.class})
public @interface requestmapping {
    string name() default "";

    @aliasfor("path")
    string[] value() default {};

    @aliasfor("value")
    string[] path() default {};

    requestmethod[] method() default {};

    string[] params() default {};

    string[] headers() default {};

    string[] consumes() default {};

    string[] produces() default {};
}

1. value(),path():指定映射的url.
2. method():指定请求的方法.如get,post等.
3. consumes():指定处理的请求的提交内容类型(content-type),例如:application/json, text/html等.
4. produces():指定返回的内容类型,也就是浏览器上响应之后显示的内容类型.和上面的consumes()一样.

• 设置content-type
  我们通过设置produces的值,设置响应报头的content-type.

//返回的响应是json格式
@requestmapping(value = "/param7",produces = "application/json")
@responsebody
public string param7(){
    return "{\"success\":true}";
}

我们看到浏览器返回的响应数据是json格式的数据.

• 设置其他的header
  设置其他header,需要使用spring中提供的httpservletresponse提供的方法来设置.

@requestmapping("/param8")
@responsebody
public string param8(httpservletresponse response){
    response.setheader("myheader","value");
    return "设置header成功";
}

我们通过fiddler抓包可以看到,报头中自定义的header已经被加入进去了.