SpringMVC_入门案例&基础配置&请求&响应
01-SpringMVC概述
三层架构
MVC:
SpringMVC简介
- SpringMVC 是一种基于Java实现 MVC模型的轻量级 Web框架
SpringMVC有点
1. 使用简单
2.性能突出
3.灵活性强
02-SpringMVC_入门案例
入门案例-步骤1-导入坐标
在pop.xml文件中导入
<properties>
<project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
<maven.compiler.source>1.8maven.compiler.source>
<maven.compiler.target>1.8maven.compiler.target>
properties>
<dependencies>
<dependency>
<groupId>javax.servletgroupId>
<artifactId>javax.servlet-apiartifactId>
<version>3.1.0version>
<scope>providedscope>
dependency>
<dependency>
<groupId>javax.servlet.jspgroupId>
<artifactId>jsp-apiartifactId>
<version>2.1version>
<scope>providedscope>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-contextartifactId>
<version>5.1.9.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-webartifactId>
<version>5.1.9.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-webmvcartifactId>
<version>5.1.9.RELEASEversion>
dependency>
dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.tomcat.mavengroupId>
<artifactId>tomcat7-maven-pluginartifactId>
<version>2.1version>
<configuration>
<port>80port>
<path>/path>
configuration>
plugin>
plugins>
build>
入门案例-步骤2-中央控制器的配置
- web.xml中配置 SpringMVC核心控制器 用于将请求转发到对应的具体业务处理器 Controller
<servlet>
<servlet-name>DispatcherServletservlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
<init-param>
<param-name>contextConfigLocationparam-name>
<param-value>classpath*:spring_mvc.xmlparam-value>
init-param>
servlet>
<servlet-mapping>
<servlet-name>DispatcherServletservlet-name>
<url-pattern>/url-pattern>
servlet-mapping>
入门案例-步骤3-创建spring容器
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
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">
<context:component-scan base-package="com.itheima"/>
<mvc:default-servlet-handler/>
beans>
入门案例-步骤4-编写Controller（servlet）
@Controller
public class UserController {
//设定当前方法的访问映射地址
@RequestMapping("/abc")
//设置当前方法返回值类型为String，用于指定请求完成后跳转的页面
public String save(){
System.out.println("user mvc controller is running ...");
//设定具体跳转的页面
return "success.jsp";
}
@RequestMapping("/hello")
public String hello(String param) {
System.out.println(param);
return "success.jsp";
}
}
小结
服务器启动:
tomcat启动加载web.xml
1. 加载web.xml中的DispatcherServlet
2. 读取spring xml中的配置,加载所有com.itheima包中所有标记为bean 的类
3.读取bean中方法上标注@RequestMapping的内容
处理请求:
1.DispatcherServlet 配置拦截所有请求 /
2.使用请求路径与所有加载的@RequestMapping的内容进行对比
3.执行对应的方法
4.根据方法法的返回值在webapp目录查找对应的页面并展示
SpringMVC技术架构图
说明:
乱码解决一 在web.xml中配置过滤器
<filter>
<filter-name>characterEncodingFilterfilter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
<init-param>
<param-name>encodingparam-name>
<param-value>UTF-8param-value>
init-param>
filter>
<filter-mapping>
<filter-name>characterEncodingFilterfilter-name>
<url-pattern>/url-pattern>
filter-mapping>
乱码解决二 在tomcat插件uri编码配置
<build>
<plugins>
<plugin>
<groupId>org.apache.tomcat.mavengroupId>
<artifactId>tomcat7-maven-pluginartifactId>
<version>2.1version>
<configuration>
<port>80port>
<path>/path>
<uriEncoding>UTF-8uriEncoding>
configuration>
plugin>
plugins>
build>
03-SpringMVC_基础配置
Controller加载控制
- SpringMVC的处理器对应的bean必须按照规范格式开发,为避免加入无效的bean可通过bean加载器进行包含设定或排除设定,表现层bean标注通常设定为@Controller
- 在SpringMvc的xml中配置加载控制
<context:component-scan base-package="com.itheima">
<context:include-filter expression="org.springframework.stereotype.Controller"/>
context:component-scan>
- 在配置类中配置加载控制
@Configuration //标明这是一个配置类
@ComponentScan(value = "com.itheima", //里选择包含模式,排除模式,需要排除的选项太多
includeFilters =@ComponentScan.Filter(type=FilterType.ANNOTATION,
classes = {Controller.class})
)
public class SpringMVCConfiguration implements WebMvcConfigurer{ }
bean加载控制说明
业务层与数据层bean加载由Spring控制,
表现层bean加载由SpringMVC单独控制
1.表现层处理器bean使用注解@Controller声明
2.bean加载控制使用包含性过滤器
3.过滤器类型为通过注解进行过滤
4.过滤的注解名称为Controller
静态资源加载
- 核心控制器拦截的是所有请求,需要对静态资源进行放行
通过配置放行静态资源
<mvc:resources mapping="/img/**" location="/img/"/>
<mvc:resources mapping="/js/**" location="/js/"/>
<mvc:default-servlet-handler/>
注解驱动
- 使用注解形式转化SpringMVC核心配置文件为配置类
配置类
@Configuration
@ComponentScan(value = "com.itheima",includeFilters =
@ComponentScan.Filter(type=FilterType.ANNOTATION,classes = {Controller.class})
)
public class SpringMVCConfiguration implements WebMvcConfigurer{
/*覆盖原有的默认功能
注解配置放行指定资源格式
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/img/**").addResourceLocations("/img/");
registry.addResourceHandler("/js/**").addResourceLocations("/js/");
registry.addResourceHandler("/css/**").addResourceLocations("/css/");
} */
//注解配置通用放行资源的格式
@Override
public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
configurer.enable();
}
}
- 自定义Servlet容器初始化配置类,加载核心配置类
自定义Servlet容器
public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
//创建Servlet容器时，使用注解的方式加载SPRINGMVC配置类中的信息，并加载成WEB专用的ApplicationContext对象
//该对象放入了ServletContext范围，后期在整个WEB容器中可以随时获取调用
@Override
protected WebApplicationContext createServletApplicationContext() {
AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
ctx.register(SpringMVCConfiguration.class);
return ctx;
/* 代替web.xml中的下面注释配置 加载springmvc核心配置类
DispatcherServlet
org.springframework.web.servlet.DispatcherServlet
contextConfigLocation
classpath*:spring-mvc.xml
*/
}
//注解配置映射地址方式，服务于SpringMVC的核心控制器DispatcherServlet
@Override
protected String[] getServletMappings() {
return new String[]{"/"};
}
@Override
protected WebApplicationContext createRootApplicationContext() {
return null;
}
//乱码处理作为过滤器，在servlet容器启动时进行配置，相关内容参看Servlet零配置
@Override
public void onStartup(ServletContext servletContext) throws ServletException {
// 调用父类的 onStartu
super.onStartup(servletContext);
//1. 创建字符集过滤器对象
CharacterEncodingFilter cef = new CharacterEncodingFilter();
//2. 设置使用的字符集
cef.setEncoding("UTF-8");
//3. 添加到容器（它不是 ioc 容器，而是 ServletContainer ）
FilterRegistration.Dynamic registration = servletContext.addFilter("characterEncodingFilter", cef);
//4. 添加映射
registration.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST,DispatcherType.FORWARD,DispatcherType.INCLUDE),false,"/*");
}
}
- 配置完成后需要删除web.xml和Springmvc.xml配置
04-请求_request
请求参数
- SpringMVC将传递的参数封装到处理器的形参中,达到快速访问参数的目的
请求参数类型
普通类型参数
POJO类型参数
数组类型参数
集合类型参数
普通类型参数
//方法传递普通类型参数，数量任意，类型必须匹配 参数名与处理器方法形参名保持一致
//http://localhost/requestParam1?name=itheima
//http://localhost/requestParam1?name=itheima&age=14
@RequestMapping("/requestParam1")
public String requestParam1(String name,int age){
System.out.println(name+","+age);
return "page.jsp";
}
参数设定
名称:@RequestParam
类型:形参注解
位置:处理器类中的方法形参前方
作用:绑定请求参数与对应处理方法形参间的关系
//方法传递普通类型参数，使用@RequestParam参数匹配URL传参中的参数名称与方法形参名称
//http://localhost/requestParam2?userName=Jock //访问路径
@RequestMapping("/requestParam2")
public String requestParam2(@RequestParam(value = "userName",
// required=true表示必须带有参数 否则无法访问报错
required = true) String name){
System.out.println(name);
return "page.jsp";
}
POJO类型参数
POJO类型参数
- 当POJO中使用简单类型属性时,参数名称与POJO类属性名保持一致
//方法传递POJO类型参数，URL地址中的参数作为POJO的属性直接传入对象
//http://localhost/requestParam3?name=Jock&age=39
@RequestMapping("/requestParam3")
public String requestParam3(User user){
System.out.println(user);
return "page.jsp";
}
参数冲突
- 当POJO类型属性与其他形参出现同名问题时,将被同时赋值
- 建议使用@RequestParam注解进行区分
//当方法参数中具有POJO类型参数与普通类型参数嘶，URL地址传入的参数不仅给POJO对象属性赋值，也给方法的普通类型参数赋值
//http://localhost/requestParam4?name=Jock&age=39
@RequestMapping("/requestParam4")
public String requestParam4(User user,int age){
System.out.println("user="+user+",age="+age);
return "page.jsp";
}
复杂POJO类型参数-01
- 当POJO中出现对象属性时,参数名称与对象名称层次结构名称保持一致
//使用对象属性名.属性名的对象层次结构可以为POJO中的POJO类型参数属性赋值
//http://localhost/requestParam5?address.city=beijing
@RequestMapping("/requestParam5")
public String requestParam5(User user){
System.out.println(user.getAddress().getCity());
return "page.jsp";
}
复杂POJO类型参数-02
- 当POJO中出现集合,保存简单数据,使用多个相同名称的参数为其进行赋值
//通过URL地址中同名参数，可以为POJO中的集合属性进行赋值，集合属性要求保存简单数据
//http://localhost/requestParam6?nick=Jock1&nick=Jockme&nick=zahc
@RequestMapping("/requestParam6")
public String requestParam6(User user){
System.out.println(user);
return "page.jsp";
}
复杂POJO类型参数-03
- 当POJO中出现List,保存对象数据,参数名称与对象层次结果名称保持一致,使用数组格式描述集合中对象的位置
//POJO中List对象保存POJO的对象属性赋值，使用[数字]的格式指定为集合中第几个对象的属性赋值
//http://localhost/requestParam7?addresses[0].city=beijing&addresses[1].province=hebei
@RequestMapping("/requestParam7")
public String requestParam7(User user){
System.out.println(user.getAddresses());
return "page.jsp";
}
复杂POJO类型参数-04
- 当POJO中出现Map,保存对象数据,参数名称与对象层次结果名称保持一致,使用映射格式描述集合中对象的位置
//POJO中Map对象保存POJO的对象属性赋值，使用[key]的格式指定为Map中的对象属性赋值
//http://localhost/requestParam8?addressMap['job'].city=beijing&addressMap['home'].province=henan
@RequestMapping("/requestParam8")
public String requestParam8(User user){
System.out.println(user.getAddressMap());
return "page.jsp";
}
数组类型参数
- 请求参数名与处理器方法形参名保持一致,且请求参数数量>1
//方法传递普通类型的数组参数，URL地址中使用同名变量为数组赋值
//http://localhost/requestParam9?nick=Jockme&nick=zahc
@RequestMapping("/requestParam9")
public String requestParam9(String[] nick){
System.out.println(nick[0]+","+nick[1]);
return "page.jsp";
}
集合类型参数
- 保存简单数据类型,请求参数名与处理器方法形参名保持一致,且请求参数数量>1
//方法传递保存普通类型的List集合时，无法直接为其赋值，需要使用@RequestParam参数对参数名称进行转换
//http://localhost/requestParam10?nick=Jockme&nick=zahc
@RequestMapping("/requestParam10")
public String requestParam10(@RequestParam("nick") List<String> nick){
System.out.println(nick);
return "page.jsp";
}
类型转换器
- SpringMVC对接受的数据进行自动类型转换,该工作通过Converter接口实现
- 标量转换器
- 集合 `数组相关转换器
- 默认转换器
日期类型格式转换
- 声明自定义的转换格式并覆盖系统转换格式
在xml配置文件中配置
<mvc:annotation-driven conversion-service="conversionService"/>
<bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
<property name="formatters">
<set>
<bean class="org.springframework.format.datetime.DateFormatter">
<property name="pattern" value="yyyy-MM-dd"/>
bean>
set>
property>
bean>
使用注解简化配置
@DateTimeFormat
类型:形参注解,成员变量注解
位置:形参前面 或 成员变量 上方
示例1
public String requestParam12(@DateTimeFormat(pattern = "yyyy-MM-dd") Date date){
System.out.println("date="+date);
return "page.jsp";
}
示例2
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date birthday;
注意:依赖注解驱动支持
<mvc:annotation-driven/>
//数据类型转换，使用自定义格式化器或@DateTimeFormat注解设定日期格式
//两种方式都依赖springmvc的注解启动才能运行
//http://localhost/requestParam11?date=1999-09-09
@RequestMapping("/requestParam11")
public String requestParam11(@DateTimeFormat(pattern = "yyyy-MM-dd") Date date){
System.out.println(date);
return "page.jsp";
}
自定义类型转换器
- 自定义类型转换器,实现Converter接口,并制定转换前后的类型
//自定义类型转换器，实现Converter接口，接口中指定的泛型即为最终作用的条件
//本例中的泛型填写的是String，Date，最终出现字符串转日期时，该类型转换器生效
public class MyDateConverter implements Converter<String, Date> {
//重写接口的抽象方法，参数由泛型决定
public Date convert(String source) {
DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
Date date = null;
//类型转换器无法预计使用过程中出现的异常，因此必须在类型转换器内部捕获，不允许抛出，框架无法预计此类异常如何处理
try {
date = df.parse(source);
} catch (ParseException e) {
e.printStackTrace();
}
return date;
}
}
spring.xml配置中注册自定义转换器
<mvc:annotation-driven conversion-service="conversionService"/>
<bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
<property name="converters">
<set>
<bean class="com.itheima.converter.MyDateConverter"/>
set>
property>
bean>
请求映射
方法注解 @RequestMapping
位置: 处理器类中的方法定义上方
作用: 绑定请求地址与对应处理方法间的关系
@RequestMapping("/requestURL1")
public String requestURL1() {
return "page.jsp";
}
类注解 @RequestMapping
位置: 处理器类定义上方
作用: 绑定请求地址与对应处理方法间的关系
@Controller
@RequestMapping("/user")
public class UserController {
@RequestMapping("/requestURL2")
public String requestURL2() {
return "page.jsp";
}
}
访问路径/user/requestURL1
- 请求返回的页面地址默认为当前路径
- 当设置了公共的访问前缀后,当前路径发生了变化,需要根据变化修改地址或访问页面的路径
//带有类映射地址访问格式，需要将类映射地址作为前缀添加在实际映射地址的前面
//最终返回的页面如果未设定绝对访问路径，将从类映射地址所在目录中查找
//http://localhost/user/requestURL2 （注意：要配合类上定义的路径使用）
@RequestMapping("/requestURL2")
public String requestURL2(){
return "/page.jsp";
}
@RequestMappings属性
// target代表你能写在那些地方
// type代表类型， 能写在类上
// METHOD 方法上
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Mapping
public @interface RequestMapping {
String name() default "";
//路径
//Alias别名
@AliasFor("path")
String[] value() default {};
//路径
@AliasFor("value")
String[] path() default {};
// method, 指定请求方式（GET,POST）
RequestMethod[] method() default {};
//参数
String[] params() default {};
//请求头信息指定
String[] headers() default {};
//接收的媒体类型
String[] consumes() default {};
//响应的媒体类型
String[] produces() default {};
}
05-响应_response
响应方式
页面跳转设定
- 当处理器的返回值类型为String类型,即可通过具体的返回值设置访问的页面
public class UserController {
@RequestMapping("/showPage")
public String showPage() {
System.out.println("user mvc controller is running ...");
return "page.jsp";
}
}
页面跳转方式
- 直接返回值是页面路径
没有配置视图解析器
- 直接返回值是页面路径
@RequestMapping("/showPage")
public String showPage() {
System.out.println("user mvc controller is running ...");
//返回值直接为webapp下的路径
return "/system/userlist.jsp";
}
@RequestMapping("/showPage")
public String showPage() {
System.out.println("user mvc controller is running ...");
//返回值直接为webapp下的路径
return "/WEB-INF/page/page.jsp";
}
@RequestMapping("/showPage2")
public String showPage2() {
System.out.println("user mvc controller is running ...");
// forward 转发
// redirect 重定向
return "redirect:/WEB-INF/page/page.jsp";
}
配置有视图解析器
<context:component-scan base-package="com.itheima"/>
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/page/"/>
<property name="suffix" value=".jsp"/>
bean>
<mvc:annotation-driven/>
<mvc:default-servlet-handler/>
- 在返回值中直接写上/WEB-INF/page/的静态页面名称即可
@RequestMapping("/showPage3")
public String showPage3() {
System.out.println("user mvc controller is running ...");
return "page";
}
- 转发(默认方式)
//forward:page.jsp转发访问，支持访问WEB-INF下的页面
@RequestMapping("/showPage1")
public String showPage1() {
System.out.println("user mvc controller is running ...");
return "forward:/WEB-INF/page/page.jsp";
}
- 重定向
//redirect:page.jsp重定向访问，不支持访问WEB-INF下的页面
@RequestMapping("/showPage2")
public String showPage2() {
System.out.println("user mvc controller is running ...");
return "redirect:/WEB-INF/page/page.jsp";
}
页面访问快捷设定
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/page/"/>
<property name="suffix" value=".jsp"/>
bean>
//页面简化配置格式，使用前缀+页面名称+后缀的形式进行，类似于字符串拼接
@RequestMapping("/showPage3")
public String showPage3() {
System.out.println("user mvc controller is running ...");
return "page";
}
页面访问快捷设定缺省页面
//最简页面配置方式，使用访问路径作为页面名称，省略返回值
@RequestMapping("/showPage5")
public void showPage5() {
System.out.println("user mvc controller is running ...");
}
相当于
@RequestMapping("/showPage5")
public String showPage5() {
return "showPage5";
}
携带数据页面跳转设定
方式一:使用HttpServletRequest类型
- 仅封装跳转页面的基本信息 底层由ModelAndView实现
//使用原生request对象传递参数
@RequestMapping("/showPageAndData1")
public String showPageAndData1(HttpServletRequest request) {
request.setAttribute("name","itheima");
return "page";
}
方式二:使用Model类型形参进行数据传递
- 仅封装数据
/使用Model形参传递参数
@RequestMapping("/showPageAndData2")
public String showPageAndData2(Model model) {
//添加数据的方式，key对value
model.addAttribute("name","Jock");
Book book = new Book();
book.setName("SpringMVC入门案例");
book.setPrice(66.66d);
//添加数据的方式，key对value
model.addAttribute("book",book);
return "page";
}
方式三:使用modelAndView形参传递数据,
- 该对象作为返回值传递给调用者
- 封装数据并封装视图,包含Model和View两个对象
//使用ModelAndView形参传递参数，该对象还封装了页面信息
@RequestMapping("/showPageAndData3")
public ModelAndView showPageAndData3(ModelAndView modelAndView) {
//ModelAndView mav = new ModelAndView(); 替换形参中的参数
Book book = new Book();
book.setName("SpringMVC入门案例");
book.setPrice(66.66d);
//添加数据的方式，key对value
modelAndView.addObject("book",book);
//添加数据的方式，key对value
modelAndView.addObject("name","Jockme");
//设置页面的方式，该方法最后一次执行的结果生效
modelAndView.setViewName("page");
//返回值设定成ModelAndView对象
return modelAndView;
}
返回数据
返回数据
方式一:使用response对象完成数据返回
@RequestMapping("/showData1")
public void showData1(HttpServletResponse response) throws IOException {
response.getWriter().print("message");
}
方式二:简化格式
@RequestMapping("/showData2")
@ResponseBody
public String showData2(){
return "message";
}
返回JSON数据
基于response返回数据的简化格式,返回json数据
//使用jackson进行json数据格式转化
@RequestMapping("/showData3")
@ResponseBody
public String showData3() throws JsonProcessingException {
Book book = new Book();
book.setName("SpringMVC入门案例");
book.setPrice(66.66d);
ObjectMapper om = new ObjectMapper();
return om.writeValueAsString(book);
}
返回JSON数据(对象)
- 使用SpringMVC提供的消息类型转换器将对象与几何数据自动转换为json数据
//使用SpringMVC注解驱动，对标注@ResponseBody注解的控制器方法进行结果转换，由于返回值为引用类型，自动调用jackson提供的类型转换器进行格式转换
@RequestMapping("/showData4")
@ResponseBody
public Book showData4() {
Book book = new Book();
book.setName("SpringMVC入门案例");
book.setPrice(66.66d);
return book;
}
响应JSON数据(常用)
1.0 导包
<dependency>
<groupId>com.fasterxml.jackson.coregroupId>
<artifactId>jackson-coreartifactId>
<version>2.9.0version>
dependency>
<dependency>
<groupId>com.fasterxml.jackson.coregroupId>
<artifactId>jackson-databindartifactId>
<version>2.9.0version>
dependency>
<dependency>
<groupId>com.fasterxml.jackson.coregroupId>
<artifactId>jackson-annotationsartifactId>
<version>2.9.0version>
dependency>
2.0 spring-mvc配置文件添加注解支持
<mvc:annotation-driven/>
3.0 使用
@RequestMapping("/mapdata")
@ResponseBody
public Map<String, Object> mapdata() {
Map map = new HashMap();
map.put("name", "zhangsan");
map.put("age", 12);
return map;
}
06-Servlet相关接口
- SpringMVC提供访问原始Servlet接口API的功能,通过形参声明即可
//获取request,response,session对象的原生接口
@RequestMapping("/servletApi")
public String servletApi(HttpServletRequest request, HttpServletResponse response, HttpSession session){
System.out.println(request);
System.out.println(response);
System.out.println(session);
return "page";
}
Head数据获取
@RequestHeader
形参注解
处理器类中的方法形参前方
作用:绑定请求头数据与对应方法形参间的关系
//获取head数据的快捷操作方式
@RequestMapping("/headApi")
public String headApi(@RequestHeader("Accept-Encoding") String headMsg){
System.out.println(headMsg);
return "page";
}
Cookie数据获取
@CookieValue
形参注解
处理器类中的方法形参前方
作用:绑定请求cookie数据与对应处理方法形参间的关系
//获取cookie数据的快捷操作方式
@RequestMapping("/cookieApi")
public String cookieApi(@CookieValue("JSESSIONID") String jsessionid){
System.out.println(jsessionid);
return "page";
}
Session数据获取
@SessionAttribute
形参注解
处理器类中的方法形参前方
作用:绑定请求Session数据与对应处理方法形参间的关系
//测试用方法，为下面的试验服务，用于在session中放入数据
@RequestMapping("/setSessionData")
public String setSessionData(HttpSession session){
session.setAttribute("name","itheima");
return "page";
}
//获取session数据的快捷操作方式
@RequestMapping("/sessionApi")
public String sessionApi(@SessionAttribute("name") String name,
@SessionAttribute("age") int age,
@SessionAttribute("gender") String gender){
System.out.println(name);
System.out.println(age);
System.out.println(gender);
return "page";
}
Session数据设置
@SessionAttributes
形参注解
处理器类中的方法形参前方
作用:声明放入Session范围的变量名称,适用于Model类型数据传参
@Controller
//设定当前类中名称为age和gender的变量放入session范围，不常用，了解即可
@SessionAttributes(names = {"age","gender"})
public class UserController {
//配合@SessionAttributes(names = {"age","gender"})使用
//将数据放入session存储范围，通过Model对象实现数据set，通过@SessionAttributes注解实现范围设定
@RequestMapping("/setSessionData2")
public String setSessionDate2(Model model) {
model.addAttribute("age",39);
model.addAttribute("gender","男");
return "page";
}
}