SpringMVC基础(一)_控制器

Spring MVC

Spring MVC 基于模型-视图-控制器(Model-View-Controller)模式实现,它能够帮你构建灵活和松耦合的应用程序。

1、Spring MVC的请求追踪

每当用户在 Web 浏览器中点击链接或提交表单是,请求就开始工作,从离开浏览器开始到获取响应返回,请求在 Spring MVC 框架中会经过以下过程:

SpringMVC基础(一)_控制器

  1. 在请求离开浏览器时,会带有用户所请求内容的信息,至少会包含请求的 URL,然后到达前端控制器;
  2. 前端控制器会查询一个或多个处理器映射(Handler mapping)来确定访问哪个控制器;
  3. 前端控制器将请求发送给指定的控制器;
  4. 控制器将模型数据打包,并标示出用于渲染的视图名;
  5. 前端控制器使用视图解析器,根据视图名匹配特定的视图实现;
  6. 视图将使用模型数据渲染输出,并通过响应对象传递给客户端;

我们已经大概了解了 Spring MVC 的工作流程,但其间涉及到多种组件,它们的任务分别是:

  • 前端控制器:它是一个处理请求的 Spring 组件,所有的请求都会经过它。它的任务主要有:
    • 将请求发给控制器(Controller);
    • 接收控制器返回的请求、模型数据以及视图名;
    • 调用视图解析器匹配一个特定的视图实现;
    • 交付模型数据,将视图输出到浏览器;
  • 处理器映射:根据请求 URL 匹配控制器;
  • 控制器
    • 接收请求数据,完成业务逻辑处理;
    • 将模型数据(业务逻辑处理产生的信息,需要返回显示在浏览器上的信息称为模型数据)打包;
    • 返回一个要渲染的视图名;
  • 视图解析器:根据视图名,匹配对应的一个视图(JSP等)实现返回;

2、Spring MVC配置搭建

DispatcherServlet 是 Spring MVC 的核心,它负责将请求转到其他组件中。但它是一个 Servlet,按照传统方式,需要在 web.xml 文件中配置 DispatcherServlet ,借助 Servlet 3 的规范和 Spring 3.1 的功能增强,我们可以使用 Java 的方式进行配置 DispatcherServlet。

1、基于 Java 配置

package spitter.config;

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

/**
 * 该类继承了 AbstractAnnotationConfigDispatcherServletInitializer ,会自动地配置 DispatcherServlet 和 Spring 应用上下文,Spring应用上下文会位于应用程序的 Servlet 上下文之中;
 */
public class SpitterWebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

    /*
        用来装配非Web组件的bean
     */
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{RootConfig.class};
    }

    /*
    该方法指定配置类
        当 DispatcherServlet 启动时,会创建Spring应用上下文,并加载配置文件或配置类中所声明的 bean。
     */
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{WebConfig.class};
    }

    /*
    该方法会将一个或多个路径映射到 DispatcherServlet 上
       将 DispatcherServlet 映射到 “/”,表示应用的默认Servlet,会处理进入应用的所有请求
     */
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}
package spitter.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

/**
 * 该类为Spring MVC配置类,具有以下配置:
 *      1、启用Spring MVC;
 *      2、启用组件扫描;如果没有启用,Spring 只会找到显式声明在配置类中的控制器;
 *      3、配置 JSP 视图解析;如果没有配置,会默认使用 BeanNameViewResolver 解析器;
 *      4、配置静态资源的处理;
 */

@Configuration
@EnableWebMvc   //启用Spring MVC;
@ComponentScan("spitter.config")
public class WebConfig extends WebMvcConfigurerAdapter {

    /*
        配置 JSP 视图解析器
     */
    @Bean
    public ViewResolver viewResolver(){
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();

        resolver.setPrefix("/views/");
        resolver.setSuffix(".jsp");
        resolver.setExposeContextBeansAsAttributes(true);
        return resolver;
    }

    /*
        配置静态资源的处理
            该配置是将对静态资源的请求转发到Servlet容器中默认的Servlet上,
            而不是使用 DispatcherServlet 来处理此类请求
     */
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer){
        configurer.enable();
    }
}
package spitter.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;

/**
 * 用来装配非Web组件的配置;
 */
@Configuration
@ComponentScan(basePackages = {"spitter"},
                excludeFilters = {@Filter(type = FilterType.ANNOTATION,value = EnableWebMvc.class)
})
public class RootConfig {

}

2、基于 XML 配置

基于 Java 配置虽然新颖,但对于初学者很不友好。所以,这里也提供了在 web.xml 中装配核心控制器 DispatcherServlet

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!-- SpringMVC的核心控制器 -->
    <servlet>
        <!-- 配置Servlet的初始化参数 -->
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--读取spring mvc的配置文件,创建spring容器-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springMvcConfig.xml</param-value>
        </init-param>
        <!-- 配置servlet启动时加载对象 -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

Spring MVC配置文件:springMvcConfig.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 配置spring开启注解mvc的支持     -->
    <mvc:annotation-driven/>

    <!-- 配置spring创建容器时要扫描的包 -->
    <context:component-scan base-package="spitter.controller"/>

    <!-- 配置视图解析器 -->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/views/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

在接下来的实践中,本人是根据 XML 配置的。

3、控制器

3.1 控制器的简单实现

如何创建控制器?如何根据请求路径找到控制器?

  1. 声明控制器

    在类级别上使用注解 @Controller ,该注解与注解 @Component 作用一样,目标是辅助实现组件扫描;

  2. 定义方法

    方法内进行请求处理,返回值类型为 String,该字符串为要渲染的视图名,提供给视图解析器进行解析。当然返回值类型也可以是其它类型,稍后再讲。

  3. 使用注解 @RequestMapping 设置请求路径映射控制器;

    RequestMapping注解:指定方法要处理的请求路径,和细化所处理的HTTP方法等,注解内有以下属性:

    • name:为此 mapping 设置名称;

    • path/value:复数形式,限制请求路径匹配时调用;当请求路径与该属性内容匹配,则访问;

      可同时在类级别和方法级别标注,相当于两级路径:/类设置路径/方法设置路径

    • method:限制请求方法匹配时调用;使用 RequestMethod 枚举的属性;

    • params:限制请求参数;当请求中包含相同的参数名和相同参数值才匹配;

    • headers:限制请求头;当请求头中包含相同的请求头才匹配;

下面是一个简单的例子

package spitter.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping({"/home"})
public class HomeController {

    //访问以下方法的请求路径为:/home/homepage
    @RequestMapping(value = {"/homepage"}, 
                    method = RequestMethod.GET)
    public String home() {
        return "home";  // 被Spring MVC解读为要渲染的视图名称
    }
}

3.2 传递请求参数到控制器

当请求到控制器,如何将请求中的参数传递到控制器的方法中?Spring MVC提供了请求参数绑定机制。

  1. 参数绑定机制
    • 表单中的请求参数都是 key-value 形式的;
    • Spring MVC绑定请求参数的过程:通过表单提交请求参数,作为控制器中方法参数进行自动绑定的;
  2. 支持绑定的数据类型
    • 基本类型参数:包括基本类型和String类型;
    • POJO 类型参数:实体类,及关联的实体类;
    • 数组和集合类型参数:Array、List和Map集合;
  3. 使用要求
    • 基本类型参数:要求请求参数名称与控制器中的方法的形参名称一致(严格区分大小写);
    • POJO类型参数:要求请求参数名称与 POJO 类中的属性名称一致,而且控制器方法的参数类型是POJO类型;
      如果POJO类中关联了其它POJO对象,请求参数名使用:关联POJO对象名.属性名;
    • 集合类型参数:
      1. 要求集合类型的请求参数必须在 POJO 中。表单中请求参数名称要和POJO类中的集合属性名称相同。
        List使用下标赋值;
        Map使用键值对赋值;
      2. 接收的请求参数时 JSON 格式数。需要借助注解 @ResponseBody 实现;
  4. 在方法传入 HttpServletRequest 对象和 HttpServletResponse 对象获取请求参数和响应结果;

案例

下面是表单数据提交的 JSP 代码,例子中所使用的 POJO 类并未展示。

<a href="<c:url value="/reqParamBind/get?method=GET&num=10"/>" >GET方式</a><br/><br/>

<!--POST方式-->
<form action="reqParamBind/post?method=POST" method="post">
    用户名:<input type="text" name="userName"/><br/>
    密码:<input type="password" name="password"/><br/>
    <input type="submit" value="提交"/>
</form>

<!--POJO类型参数绑定,name属性的值必须与POJO类属性名一致-->
<form action="reqParamBind/pojoBind" method="post">
    用户名:<input type="text" name="userName"/><br>
    密码:<input type="password" name="password"/><br>
    金额:<input type="text" name="money"/><br>
    <!--POJO对象内引用另一个POJO对象-->
    真实姓名:<input type="text" name="user.realName"/><br>
    年龄:<input type="text" name="user.age"/><br>
    <input type="submit" value="提交"/>
</form>

<!--集合类型-->
<form action="reqParamBind/collectionBind" method="post">
    <!--List集合,name属性的值为:集合属性名[下标].属性名-->
    用户:<input type="text" name="list[0].realName"/><br>
    年龄:<input type="text"name="list[0].age"/><br>
    用户:<input type="text" name="list[1].realName"/><br>
    年龄:<input type="text" name="list[1].age"/><br>
    
    <!--Map集合,name属性的值为:集合属性名['key'].属性名-->
    用户:<input type="text" name="map['one'].realName"/><br>
    年龄:<input type="text"name="map['one'].age"/><br>
    用户:<input type="text" name="map['two'].realName"/><br>
    年龄:<input type="text" name="map['two'].age"/><br>
    <input type="submit" value="提交"/>
</form>

表单提交数据访问的控制器代码

package spitter.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import spitter.pojo.Account;
import spitter.pojo.UserList;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.util.Date;

@Controller
@RequestMapping(value = {"/reqParamBind"})
public class ParamController {
    /**
     * get方式请求参数传递
     * @param method 请求参数
     * @param num 请求参数
     * @return 要解析的视图名称
     */
    @RequestMapping(value = {"/get"},method = RequestMethod.GET)
    public String reqParamBind(String method,int num){
        System.out.println("Method:"+method+"---num:"+num);
        return "paramAccept";
    }

    /**
     * post方式请求参数传递
     * @param method 请求参数
     * @param userName 请求参数
     * @param password 请求参数
     * @return 要解析的视图名称
     */
    @RequestMapping(value = {"/post"},method = RequestMethod.POST)
    public String reqParamBind(String method,String userName,String password){
        System.out.println("Method:"+method+"---userName:"+userName+"---密码:"+password);
        return "paramAccept";
    }

    /**
     * POJO实体类型参数绑定
     * @param account POJO类
     * @return 要解析的视图名称
     */
    @RequestMapping(value = {"/pojoBind"},method = RequestMethod.POST)
    public String pojoBind(Account account){
        System.out.println(account);
        return "paramAccept";
    }

    /**
     * List、Map等集合类型参数绑定
     * @param userList 实体类;实体类中封装了List集合和Map集合进行绑定
     * @return 要解析的视图名称
     */
    @RequestMapping(value = {"/collectionBind"},method = RequestMethod.POST)
    public String collectionBind(UserList userList,HashMap<String,>){
        System.out.println(userList);
        return "paramAccept";
    }

    /**
     * 获取Servlet的请求和响应对象
     * @param request HttpServletRequest
     * @param response HttpServletResponse
     * @return 要解析的视图名称
     */
    @RequestMapping(value = {"/getReqAndResp"},method = RequestMethod.GET)
    public String getReqAndResp(HttpServletRequest request, HttpServletResponse response){
        System.out.println(request);

        HttpSession session = request.getSession();
        System.out.println(session);

        ServletContext servletContext = request.getServletContext();
        System.out.println(servletContext);

        System.out.println(response);

        return "paramAccept";
    }
}

3.3 自定义类型转换器

正如我们所知,浏览器提交的数据都是以字符串类型传递的,而 Spring MVC 为我们封装好了常用的类型转换器。但有时,依然会有一些特殊情况。比如:日期格式转换。Spring MVC 只接受 yyyy/MM/dd 类型的日期格式;如果换成 yyyy-MM-dd 类型的日期格式就会出现异常;

这是,我们可以自定义一个转换器,请求参数会根据我们定义的格式进行转换。

定义转换器步骤

  1. 创建新类,实现 org.springframework.core.convert.converter.Converter<S,T> 接口;重写 convert 方法,方法中编写类型转换的代码;
  2. 在Spring MVC配置文件中,装配 bean 对象 org.springframework.context.support.ConversionServiceFactoryBean;再把刚创建的转换器(bean)填充到该 bean 的属性 converters(为Set集合);
  3. 最后,在开启注解支持的标签中,设置 conversion-service 属性,值为 ConversionServiceFactoryBean 的ID值;

案例

转换器类

package spitter.converter;

import org.springframework.core.convert.converter.Converter;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

public class StringToDate implements Converter<String, Date> {
    @Override
    public Date convert(String source) {
        if (source == null && "".equals(source)) {
            throw new RuntimeException("请输入数值");
        } else {
            DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
            try {
                return df.parse(source);
            } catch (Exception e) {
                throw new RuntimeException("数据类型转换错误");
            }
        }
    }
}

在 Spring MVC 配置文件进行配置

<!--配置自定义类型转换器-->
<bean id="conversionService2" class="org.springframework.context.support.ConversionServiceFactoryBean">
    <property name="converters">
        <set>
            <!--装配转换器 Bean对象-->
            <bean class="spitter.converter.StringToDate"/>
        </set>
    </property>
</bean>

<!-- 配置spring开启注解mvc的支持,并装配转换器-->
<mvc:annotation-driven conversion-service="conversionService2"/>

但是:日期转换器转换 yyyy-MM-dd 类型后,再使用 yyyy/MM/dd类型会出现错误:Bad Request

3.4 数据传递到视图

控制器方法中处理后的数据信息,如何传递到视图,展示在浏览器

  1. 方法参数中使用接口:org.springframework.ui.Model,它会调用子类 BindingAwareModelMap 对象的 addAttribute(key,value) 方法传递;
  2. 也可以使用Map集合,并使用 put 方法进行数据传递;
  3. 方法参数传入 HttpServletRequest 对象和 HttpServletResponse 对象进行数据传递;
/*
    将控制器的数据传递到视图中
        需要传递一个参数:Model或 Map对象,调用对应的addAttribute方法或put方法传递;
*/
@RequestMapping(value = {"/homeParam"}, method = RequestMethod.GET)
public String home(/*Map<String,String>*/ Model model) {
    //model.put("name","Chan");
    model.addAttribute("name", "Chan");
    return "home";
}

3.5 控制器方法返回值类型

当控制器方法的返回值类型为以下类型时,实现页面跳转的方式:

  1. String类型

    Spring MVC 会根据返回的字符串进行视图名称解析,比如:jsp的视图解析后为:路径/字符串.jsp,并跳转到解析后的 JSP 页面;

  2. 返回值是void类型

    • 没有返回值时,Spring会默认到视图解析器前缀目录(配置文件中视图解析器前缀为:/views/)下,访问:控制器类路径/方法路径.jsp。
    • 没有返回值时,可以使用原生 Servlet 的请求和响应对象,进行请求转发、重定向,甚至是直接返回数据
  3. ModelAndView类型

    ModelAndView 是 SpringMVC 为我们提供的一个对象,该对象也可以用作控制器方法的返回值;

    该对象中有两个常用的方法:

    • addObject(String key,Object value):将数据以键值对的方式存储到request作用域中;底层也是使用 Model 对象进行传递数据;
    • setViewName(String viewName):跳转页面,给定视图名称,经过解析器解析;
  4. 关键字进行请求转发、重定向;返回值是String类型,字符串内容如下:
    forward:URI路径 :请求转发;/ 表示当前项目路径;
    redirect:URI路径 :重定向;不需要加项目名称;

案例

package spitter.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Controller
@RequestMapping(value = {"/returnType"})
public class ReturnTypeController {

    /**
     * 返回值为字符串
     * @return 字符串为要解析的视图名
     */
    @RequestMapping(value = "/stringType",method = RequestMethod.GET)
    public String stringType(){
        return "returnType";
    }

    /**
     * 返回值为 void
     */
    @RequestMapping(value = "/voidType",method = RequestMethod.GET)
    public void voidType(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //请求转发
        //request.getRequestDispatcher("/index.jsp").forward(request,response);

        //重定向
        //response.sendRedirect(request.getContextPath()+"/index.jsp");

        //直接返回数据
        //request.setCharacterEncoding("UTF-8");
        //response.setContentType("text/html;charset=utf-8");
        //response.getWriter().write("数据...");
    }

    /**
     * 返回值为 ModelAndView 类型
     * @return ModelAndView对象
     */
    @RequestMapping(value = "/modelAndView",method = RequestMethod.GET)
    public ModelAndView modelAndView(){
        //创建 modelAndView 对象
        ModelAndView modelAndView = new ModelAndView();
        //设置Request作用域属性
        modelAndView.addObject("name","Chan");

        //跳转页面
        modelAndView.setViewName("../index");
        return modelAndView;
    }

    @RequestMapping(value = "/forwardOrRedirect")
    public String forwardOrRedirect(){
        //请求转发
         return "forward:/views/page.jsp";
        //重定向
        //return "redirect:/index.jsp";
    }
}

3.6 控制器中常用注解

  1. @RequestParam():将指定的请求参数赋给控制器中的参数;
    用于请求参数名称与控制器方法形参名称不一致时,标注在控制器方法的形参前;

    • value属性:请求参数的名称;
    • required属性:请求参数中是否必须提供此参数。默认值:true。表示必须提供,如果不提供将报错;
    /**
    * RequestParam注解匹配请求参数名和控制器方法形参名不一致
    * @param userName 控制器方法形参名
    * @param model 数据传递对象,把数据传递到视图层
    * @return 要解析的视图名称
    */
    @RequestMapping(value = "/requestParam",method = RequestMethod.GET)
    public String requestParam(@RequestParam(value = "uname") String userName, Model model){
    
    }
  2. @RequestBody()

    读取 Request 请求的 body 部分数据,直接使用得到是 key=value&key=value... 结构的数据;get 请求方式不适用;

    • required属性:是否必须有请求体。默认值是:true。当取值为 true 时,get 请求方式会报错。如果取值为 false,get 请求得到是 null;
    • 会使用默认配置的 HttpMessageConverter 解析数据,然后把相应的数据绑定到对象上;
  3. @ResponseBody()

    Controller 的方法返回的对象,通过适当的HttpMessageConverter 转换为指定格式后,写入到Response对象的body 数据区;

    @RequestBody()@ResponseBody() 可以接收和响应 JSON 数据。例如:Ajax 请求中,能够接收 JSON 数据封装到对象中,也可以将对象解析为 JSON 数据传送。

    @RequestMapping(value = "/ajaxRequest")
    public @ResponseBody User ajaxRequest(@RequestBody User user){
    
        user.setRealName("xiaoyao");
        user.setAge(30);
    
        return user;
    }
  4. @PathVariable():用于从 url 中获取数据

    请求 url 中使用占位符标记要获取的数据,例如: /delete/{id},这个 {} 就是 url 占位符;url 支持占位符是 spring3.0 之后加入的;是 spring mvc 支持 rest 风格 URL 的一个重要标志。

    • value属性:用于指定 url 占位符中名称;
    • required属性:是否必须提供占位符;
  5. @RequestHeader():用于获取请求消息头;

    • value属性:提供消息头名称;
    • required属性:是否必须有此消息;
  6. @CookieValue():用于把指定 cookie 名称的值传入控制器方法参数;

    • value属性:指定 cookie 的名称;
    • required属性:是否必须有此 cookie;
  7. @ModelAttribute():可以用于修饰方法和参数;

    也就是 Model 对象中 Attribute 操作。

    • 出现在方法上,表示当前方法会在控制器方法执行之前,先执行。方法有返回值则把返回值放到 Model中;

    • 出现在参数上,获取指定的数据赋给方法参数;如果存在表单提交的数据,会优先绑定请求参数

      value属性:获取 Model 中数据的 key 。key 可以是POJO的属性名称,也可以是map结构的 key;

    案例:当表单提交的数据不是完整的实体类数据时,为了保证没有提交数据的字段使用数据库对象原来的数据,有数据的字段是不允许修改的,即使用set方法赋值;

  8. @SessionAttribute():用于多次执行控制器方法间的参数共享;

    只能作用在类级别上;将数据存储在Session作用域;

    • value属性:用于指定存入的属性名称;
    • type属性:用于指定存入的数据类型;
    package spitter.controller;
    
    import org.springframework.stereotype.Controller;
    import org.springframework.ui.ExtendedModelMap;
    import org.springframework.ui.Model;
    import org.springframework.web.bind.annotation.*;
    import org.springframework.web.bind.support.SessionStatus;
    import spitter.pojo.User;
    
    import java.io.UnsupportedEncodingException;
    
    @Controller
    @RequestMapping(value = {"/anno"})
    //(1)将控制器方法中添加到 Model 中的数据存储到Session域。value中指定数据的 key
    @SessionAttributes(value = {"session"})  
    public class AnnoController {
    
        //(2)
        @RequestMapping(value = "/setSessionAttr")
        public String setSessionAttr(Model model){
            model.addAttribute("session","控制器类使用 @SessionAttribute 存储数据");
            return "paramAccept";
        }
    
        @RequestMapping(value = "/getSessionAttr")
        public String getSessionAttr(ExtendedModelMap model){
            //(3)获取Session作用域属性
            String session = (String) model.get("session");
            System.out.println(session);
            return "paramAccept";
        }
    
        @RequestMapping(value = "/delSessionAttr")
        public String delSessionAttr(SessionStatus status){
            //(4)清空session域
            status.setComplete();
            return "paramAccept";
        }
    }

想更清楚了解注解,可查阅该文章

相关推荐