SpringMVC基础(一)_控制器

其他 2020-02-13 23:34:11 阅读次数: 0

Spring MVC

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

1、Spring MVC的请求追踪

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

Spring MVC请求路径

  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方法赋值；

    ModelAttribute使用

  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";
    }
}

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

猜你喜欢

转载自www.cnblogs.com/Brilliance-Chan/p/12305788.html
今日推荐
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
周排行
Metasploit文件目录与入侵基本概念
跨域(CORS)请求问题[No 'Access-Control-Allow-Origin' header is present on the requested resource]常见解决方案
CodeIgniter 源码解读之 CodeIgniter.php（二）
SAS入门之（四）改变数据类型
初识元组
[数学建模]数学建模算法和模型（B站视频）（二）
Nginx 服务器源码安装配置流程
C#实现语音视频录制 【基于MCapture + MFile】
开发进度4
下载安装vue的方法网址
每日归档
更多
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022