springMVC框架学习-1

springMVC框架学习安排

第一天

1. MVC基本概念


由图可见MVC架构和我们之前所学的spring和MyBatis可以完美衔接,也是web应用开发必不可少的一部分,springMVC是一个MVC设计模型的一个框架。
三层框架的执行流程:
controller接受浏览器的请求,调用model可以将其封装成JavaBean对象,发送给业务层处理,业务层又可以调用持久层与数据库交互,将返回结果发送给表现层,封装成JSP或者其它的视图,响应给浏览器。

1.springMVC的基本概述

1.什么是springMVC
springMVC 是一种基于Java的实现MVC设计模型的请求驱动类型的轻量级Web框架,
属于Spring FrameWork的后续产品,已经融合在Spring Web Flow里面。
Spring框架提供了构建Web应用程序的全功能MVC模块。使用Spring 可插入的MVC
架构,从而在使用Spring 进行WEB开发时,可以选择使用Spring的Spring MVC 
框架或集成其他MVC开发框架,如Struts1(现在一般不用),Struts2等。

springMVC 已经成为了主流的MVC框架之一,并且随着spring3.0的发布,
全面超越了struts2,成为了最优秀的MVC框架。
它通过一套注解,让一个简单的Java类成为处理请求的控制器,
并且无需实现任何接口,同时它还支持RESTful编程风格。
2. springMVC的优势
  1. 清晰的角色划分:
    前端控制器(DispatcherServlet)
    请求到处理器映射(HandlerMapping)
    处理器适配器(HandlerAdapter)
    视图解析器(ViewResolver)
    处理器或页面控制器(Controller)
    验证器( Validator)
    命令对象(Command 请求参数绑定到的对象就叫命令对象)
    表单对象(Form Object 提供给表单展示和提交到的对象就叫表单对象)。
  2. 分工明确,而且扩展点相当灵活,可以很容易扩展,虽然几乎不需要。
  3. 由于命令对象就是一个 POJO,无需继承框架特定 API,可以使用命令对象直接作为业务对象。
  4. 和 Spring 其他框架无缝集成,是其它 Web 框架所不具备的。
  5. 可适配,通过 HandlerAdapter 可以支持任意的类作为处理器。
  6. 可定制性,HandlerMapping、ViewResolver 等能够非常简单的定制。
  7. 功能强大的数据验证、格式化、绑定机制。
  8. 利用 Spring 提供的 Mock 对象能够非常简单的进行 Web 层单元测试。
  9. 本地化、主题的解析的支持,使我们更容易进行国际化和主题的切换。
  10. 强大的 JSP 标签库,使 JSP 编写更容易。
    ………………还有比如RESTful风格的支持、简单的文件上传、约定大于配置的契约式编程支持、基于注解的零配
    置支持等等。
3. springMVC和struts2的区别(面试问题)
共同点:
	它们都是表现层框架,都是基于 MVC 模型编写的。
	它们的底层都离不开原始 ServletAPI。
	它们处理请求的机制都是一个核心控制器。
区别:
	Spring MVC 的入口是 Servlet, 而 Struts2 是 Filter
	Spring MVC 是基于方法设计的,而 Struts2 是基于类,Struts2 每次执行都会创建一个动作类。所
	以 Spring MVC 会稍微比 Struts2 快些。
	Spring MVC 使用更加简洁,同时还支持 JSR303, 处理 ajax 的请求更方便
	(JSR303 是一套 JavaBean 参数校验的标准,它定义了很多常用的校验注解,我们可以直接将这些注
	解加在我们 JavaBean 的属性上面,就可以在需要校验的时候进行校验了。)
	Struts2 的 OGNL 表达式使页面的开发效率相比 Spring MVC 更高些,但执行效率并没有比 JSTL 提
	升,尤其是 struts2 的表单标签,远没有 html 执行效率高。

2. springMVC的入门

  1. 入门案例需求分析

  2. 编写代码

    1. 创建maven工程,选择webapp项目
    2. pom.xml
    <?xml version="1.0" encoding="UTF-8"?>
    
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
    
      <groupId>com.liuzeyu</groupId>
      <artifactId>day03_springMVC01_start</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>war</packaging>
    
      <name>day03_springMVC01_start Maven Webapp</name>
      <!-- FIXME change it to the project's website -->
      <url>http://www.example.com</url>
    
      <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <!--spring版本绑定-->
        <spring.version>5.0.2.RELEASE</spring.version>
      </properties>
    
      <dependencies>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>${spring.version}</version>
        </dependency>
    
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-web</artifactId>
          <version>${spring.version}</version>
        </dependency>
    
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-webmvc</artifactId>
          <version>${spring.version}</version>
        </dependency>
        <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>servlet-api</artifactId>
          <version>2.5</version>
        </dependency>
        <dependency>
          <groupId>javax.servlet.jsp</groupId>
          <artifactId>jsp-api</artifactId>
          <version>2.0</version>
          <scope>provided</scope>
        </dependency>
    
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.12</version>
          <scope>test</scope>
        </dependency>
      </dependencies>
    
      <build>
        <finalName>day03_springMVC01_start</finalName>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
          <plugins>
            <plugin>
              <artifactId>maven-clean-plugin</artifactId>
              <version>3.1.0</version>
            </plugin>
            <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
            <plugin>
              <artifactId>maven-resources-plugin</artifactId>
              <version>3.0.2</version>
            </plugin>
            <plugin>
              <artifactId>maven-compiler-plugin</artifactId>
              <version>3.8.0</version>
            </plugin>
            <plugin>
              <artifactId>maven-surefire-plugin</artifactId>
              <version>2.22.1</version>
            </plugin>
            <plugin>
              <artifactId>maven-war-plugin</artifactId>
              <version>3.2.2</version>
            </plugin>
            <plugin>
              <artifactId>maven-install-plugin</artifactId>
              <version>2.5.2</version>
            </plugin>
            <plugin>
              <artifactId>maven-deploy-plugin</artifactId>
              <version>2.8.2</version>
            </plugin>
          </plugins>
        </pluginManagement>
      </build>
    </project>
    
    
    1. controller控制器处理

      添加Java和resource文件完善maven项目的目录结构
      @RequestMapping注解的作用是用于建立请求URL处理请求方法之间的对应关系。
    2. spring配置文件
    <?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:mvc="http://www.springframework.org/schema/mvc"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/mvc
           http://www.springframework.org/schema/mvc/spring-mvc.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd">
    
        <!--配置创建springIOC容器时要扫描的包-->
        <context:component-scan base-package="com.liuzeyu"></context:component-scan>
    
        <!--配置视图解析器-->
        <bean id="viewResolver"
              class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/pages/"></property>
            <property name="suffix" value=".jsp"></property>
        </bean>
    
        <!--配置spring开启注解mvc的支持-->
        <mvc:annotation-driven></mvc:annotation-driven>
    
    </beans>
    
    1. 配置servlet
    <!DOCTYPE web-app PUBLIC
     "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
     "http://java.sun.com/dtd/web-app_2_3.dtd" >
    
    <web-app>
      <display-name>Archetype Created Web Application</display-name>
    
      <!--配置servlet-->
      <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    
        <!--servlet启动后需要加载的spring配置文件-->
        <init-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
      </servlet>
      <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
      </servlet-mapping>
    </web-app>
    
    1. index.jsp与success.jsp
    <%@page contentType="text/html; charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>springmvc入门</title>
    </head>
    <body>
    
    <h3>入门程序</h3>
    <a href="hello">请求</a>
    </body>
    </html>
    
    <%@page contentType="text/html; charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>入门成功</title>
    </head>
    <body>
    
    <h2>springmvc入门成功</h2>
    </body>
    </html>
    
    1. springMVC执行流程

      注意:@RequestMapping的path属性和方法执行的return 可以不以 / 开头,内部已经对其进行配置。
      springMVC内部执行的详细信息

    服务器一经启动,DisPatcherServlet对象(前端控制器)被创建,springMVC.xml被加载,HelloMVC对象也被创建。
    当我们点击a标签后,带有uri = /hello的请求被发到了前端控制器,它会带引这个请求去寻找处理器映射器,找到要执行的方法sayHello并返回(等下才要执行),当然前端控制器是不会执行这个方法,它会再次将这个结果发送到处理器适配器。
    处理器适配器会适配controller下任何的方法,处理器适配器又会发送到处理器这个组件进行方法的执行与返回,执行后返回ModelAndView给处理器适配器,处理器适配器又会将其返回到前端控制器,前端控制器将这个结果发送到视图解析器ViewResolver。
    视图解析器解析完之后又会将结果返回View前端控制器,前端控制器将View发送给View视图组件解析,视图将其解析成浏览器可以识别的出来的文件进行展示。

1. 涉及到组件

1. DispatcherServlet:前端控制器

用户的请求到达前端控制器器后,DispatcherServlet对象它就相当于mvc模式执行流程的控制中心,它调用其它组件处理用户的请求,前端控制器的存在降低了组件之间的耦合性。

2. HandlerMapping:处理器映射器

HandlerMapping负责根据用户请求找到Handler,即处理器,springMVC提供了不同的映射器实现不同的映射方式。例如配置文件方式,实现接口方式,注解方式等。

3. Handler:处理器

处理器是我们开发中要编写的具体业务控制器,由前端控制器把用户请求发送到处理器,由处理器将用户的请求进行业务处理。

4. HandlAdapter:处理器适配器

通过处理器适配器对处理器进行执行,这是适配器模式的应用,通过扩展适配器可以对更多类型的处理器进行执行

上图是电脑外接显示器的适配器,可以实现电脑连接不同的显示屏。

5. View Resolver:视图解析器

View Resolver解析器将处理结果生成视图View,View Resolver首先根据逻辑视图名解析成物理视图名,即具体的页面地址,再生成view视图对象,最后对view进行渲染将处理结果以页面展示给前端

6. View视图器

作用就是将页面标签或模型数据通过页面展示给前端,SpringMVC 框架提供了很多的 View 视图类型的支持,包括:jstlView、freemarkerView、pdfView等。我们最常用的视图就是 jsp。

2.< mvc:annotation-driven>说明

在springMVC的各个组件中,处理器映射器,处理器适配器,视图解析器被称为springMVC的三大组件。
当在spring的配置文件中添加

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

即默认开启使 用RequestMappingHandlerMapping (处理映射器) 和
RequestMappingHandlerAdapter ( 处 理 适 配 器 )。

3.RequestMapping注解

查看源码:

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Mapping
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 {};
}

作用:用于建立请求 URL 和处理请求方法之间的对应关系。
作用的位置:方法上,类上。

  1. path或value属性拥有相同的作用
    通常在实际开发中我们是类上和方法上配合使用,将xxx类模块话,方法是细分的小模块,赋值为path或value属性
    如:
    • 账户模块:
      /account/add
      /account/update
      /account/delete
    • 订单模块:
      /order/add
      /order/update
      /order/delete
      红色的部分就是把 RequsetMappding 写在类上,使我们的 URL 更加精细。
      方法上:
      请求 URL 的第二级访问目录。

示例:

@Controller
@RequestMapping("/user")
public class HelloMVC { 

    @RequestMapping(path = "hello")
    public String sayHello(){ 
        System.out.println("helloMVC........");
        return "success";
    }

    @RequestMapping(path = "/good")
    public String sayGood(){ 
        System.out.println("goodMVC........");
        return "success";
    }
}

请求的url

<a href="user/hello">请求hello</a>
<a href="user/good">请求good</a>

经测试,在 @RequestMapping不管作用在哪里,它的path路径,都可以不用写 / ,但是又时候为了阅读方便会写上。

  1. method:用于指定请求的方式
// 这样配置后通过a标签发送的get请求的将不能执行到该方法
    @RequestMapping(path = "hello",method = { RequestMethod.POST})
    public String sayHello(){ 
        System.out.println("helloMVC........");
        return "success";
    }
  1. params:用于指定限制请求参数的条件。它支持简单的表达式。要求请求参数的 key 和 value 必须和配置的一模一样。
    @RequestMapping(path = "/good",params = { "username=liuzeyu"})
    public String sayGood(){ 
        System.out.println("goodMVC........");
        return "success";
    }
<a href="user/good?username=liuzeyu">请求good</a>

a标签必须配置相应的key value的请求参数和请求值,方法才可以被执行。

  1. header:用于指定限制请求消息头的条件,浏览器消息头的请求参数必须和配置一样方法才可以被执行。

问题:为什么注解属性只传一个时,属性名可以不写

- 如果注解只有一个属性,那么肯定是赋值给该属性。
- 如果注解有多个属性,而且前提是这多个属性都有默认值,那么你不写注解名赋值,会赋值给名字为“value”这属性。
- 如果注解有多个属性,其中有没有设置默认值的属性,那么当你不写属性名答进行赋值的时候,是会报错的。

3. 请求参数的绑定

1. 请求参数绑定入门

  1. 新建控制器
@Controller
@RequestMapping("/params")
public class ParamsMVC { 

    /** * 请求参数绑定入门 * @return */
    @RequestMapping("basic")
    public String basic(String username,String password){ 
        System.out.println("basic..."+username+"---" +password);
        return "success";
    }
}
  1. 请求链接
<a href="params/basic?username=liuzeyu&password=123">请求参数绑定入门</a>

注意:请求参数一定要和方法的参数一致。

  1. 访问127.0.0.1:8080/params/basic测试输出

2. 请求参数绑定实体类型

  1. 准备实体类
public class Account { 

    private Integer id;
    private String name;
    private Double money;

    private User user;


    public Integer getId() { 
        return id;
    }

    public void setId(Integer id) { 
        this.id = id;
    }

    public String getName() { 
        return name;
    }

    public void setName(String name) { 
        this.name = name;
    }

    public Double getMoney() { 
        return money;
    }

    public void setMoney(Double money) { 
        this.money = money;
    }

    public User getUser() { 
        return user;
    }

    public void setUser(User user) { 
        this.user = user;
    }

    @Override
    public String toString() { 
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                ", user=" + user +
                '}';
    }
}

public class User { 
    private String uname;
    private Integer age;

    public String getUname() { 
        return uname;
    }

    public void setUname(String uname) { 
        this.uname = uname;
    }

    public Integer getAge() { 
        return age;
    }

    public void setAge(Integer age) { 
        this.age = age;
    }

    @Override
    public String toString() { 
        return "User{" +
                "uname='" + uname + '\'' +
                ", age=" + age +
                '}';
    }
}

  1. 编写controller
@Controller
@RequestMapping("/params")
public class ParamsMVC { 

    /** * 请求参数绑定实体类 * @return */
    @RequestMapping("domain")
    public String domain(Account account){ 
        System.out.println(account);
        return "success";
    }
}
  1. jsp请求页面
<form action="/params/domain" method="post">
    账户id:<input type="text" name="id"><br>
    账户公司:<input type="text" name="name"><br>
    账户金额:<input type="text" name="money"><br>
    用户名:<input type="text" name="user.uname"><br>
    年龄:<input type="text" name="user.age"><br>
    <input type="submit" value="提交">
</form>
  1. 测试发现post方式存在参数值的中文问题

3. 请求参数中文问题

上述的中文问题可以通过配置拦截器来解决编码问题,在web.xml中配置

 <!--处理post请求的中文乱码问题-->
  <filter>
    <filter-name>characterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern> </filter-mapping> 

就可以解决post请求的中文问题。

4. 请求参数为集合类型

  1. 为Account添加集合属性,并生成getXXX和setXXX方法
    private List<User> list;
    private Map<String,User> map;
  1. jsp文件
<form action="/params/domain" method="post">
    账户id:<input type="text" name="id"><br>
    账户公司:<input type="text" name="name"><br>
    账户金额:<input type="text" name="money"><br>
    用户名:<input type="text" name="list[0].uname"><br>
    年龄:<input type="text" name="list[0].age"><br>
    <br>
    用户名:<input type="text" name="map['one'].uname"><br>
    年龄:<input type="text" name="map['one'].age"><br>
    <input type="submit" value="提交">
</form>

重点注意name属性的写法。

  1. 测试
    @RequestMapping("collections")
    public String collections(Account account){ 
        System.out.println(account);
        return "success";
    }

5. 自定义类型转换器

  1. 为User类添加Date birthday属性
    private Date birthday;

    public Date getBirthday() { 
        return birthday;
    }

    public void setBirthday(Date birthday) { 
        this.birthday = birthday;
    }
  1. jsp文件
<form action="/params/date" method="post">
    用户名:<input type="text" name="uname"><br>
    年龄:<input type="text" name="age"><br>
    生日:<input type="text" name="birthday"><br>
    <input type="submit" value="提交">
</form>
  1. controller层代码
    @RequestMapping("date")
    public String stringTodata(User user){ 
        System.out.println(user);
        return "success";
    }
  1. 测试发现如果输入生日格式为2020/4/27即可以将字符串封装成Date对象,如果输入字符串格式为2017-4-27,则封装失败

解决方案
通过自定义类型转换器来解决

  1. 实现spring框架核心包为我们提供的接口converter并且编写工具类

    /** * Created by liuzeyu on 2020/4/27. * 实现字符串转日期格式工具类 */
    public class StringToDate implements Converter<String,Date>{ 
        @Override
        public Date convert(String s) { 
            if(s == null || s.length() == 0){ 
                throw new RuntimeException("字符串不能为空...");
            }
            DateFormat df = new SimpleDateFormat("yyyy-mm-dd");
            try { 
                Date date = df.parse(s);
                return date;
            } catch (ParseException e) { 
                throw new RuntimeException("日期转换失败...");
            }
    
        }
    }
    
    
  2. spring配置文件中配置,为核心包中添加一个工具类

     <!--配置自定义类型转换器-->
        <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
            <property name="converters">
                <set>
                    <bean class="com.liuzeyu.utils.StringToDate"></bean>
                </set>
            </property>
        </bean>
    
    
        <!--配置spring开启注解mvc的支持-->
        <mvc:annotation-driven conversion-service="conversionService"></mvc:annotation-driven>
    
    1. 重新测试日期格式为2020-4-27

6. web层使用原生的servlet-api对象

  1. jsp文件
<form action="/params/servlet" method="post">
    用户名:<input type="text" name="username"><br>
    密码:<input type="text" name="password"><br>
    <input type="submit" value="提交">
</form>
  1. 编写controller代码,只需要在参数中定义请求和响应的对象即可
    /** * 测试使用原生的servlet对象 * @return */
    @RequestMapping("servlet")
    public String servlet(HttpServletRequest request, HttpServletResponse response){ 
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        System.out.println(username +":"+password);
        return "success";
    }
  1. 测试结果

4. springMVC常用的注解

1. @RequestParam

作用:把请求中的指定参数名称给控制器参数赋值
属性

  1. value:请求参数名称
  2. required:请求参数中是否提供该参数,默认是true表示必须提供,如果不提供将报错。

使用实例:

<a href="anno/requestParam?username=liuzeyu">注解@RequestParam</a>
    @RequestMapping("requestParam")
    public String testRequestParam(@RequestParam(value = "username") String name,
                                   @RequestParam(value = "age",required = false) Integer age){ 
        System.out.println(name);
        return "success";
    }

其中age参数,发送请求时可以不用发送age,但必须发送?username=xxx

2. @RequestBody

**作用:**获取请求体的内容,直接使用得到的时key=xxx&value=yyy。get请求方式不适用
属性:
required:是否必须有请求体,默认为true,当为true时,get请求会报错。当请求为false时,get获取到的为null
使用实例:

<form action="anno/requestBody" method="post">
    用户名:<input type="text" name="username"><br>
    密码:<input type="text" name="password"><br>
    <input type="submit" value="提交">
</form>
<br>
<%--@RequestBody不适用于get请求--%>
<a href="anno/requestBody?username=liuzeyu&&password=80">注解@RequestBody</a>
    @RequestMapping("requestBody")
    public String testRequestBody(@RequestBody String body){ 
        System.out.println(body);
        return "success";
    }
3. @PathVariable

引出REST编码风格

什么是 rest:
REST(英文:Representational State Transfer,简称 REST)描述了一个架构样式的网络系统,
比如 web 应用程序。它首次出现在 2000 年 Roy Fielding 的博士论文中,他是 HTTP 规范的主要编写者之
一。在目前主流的三种 Web 服务交互方案中,REST 相比于 SOAP(Simple Object Access protocol,简单
对象访问协议)以及 XML-RPC 更加简单明了,无论是对 URL 的处理还是对 Payload 的编码,REST 都倾向于用更
加简单轻量的方法设计和实现。值得注意的是 REST 并没有一个明确的标准,而更像是一种设计的风格。
它本身并没有什么实用性,其核心价值在于如何设计出符合 REST 风格的网络接口。
restful 的优点
它结构清晰、符合标准、易于理解、扩展方便,所以正得到越来越多网站的采用。
restful 的特性:
资源(Resources):网络上的一个实体,或者说是网络上的一个具体信息。
它可以是一段文本、一张图片、一首歌曲、一种服务,总之就是一个具体的存在。可以用一个 URI(统一
资源定位符)指向它,每种资源对应一个特定的 URI 。要
获取这个资源,访问它的 URI 就可以,因此 URI 即为每一个资源的独一无二的识别符。
表现层(Representation):把资源具体呈现出来的形式,叫做它的表现层 (Representation)。
比如,文本可以用 txt 格式表现,也可以用 HTML 格式、XML 格式、JSON 格式表现,甚至可以采用二
进制格式。
状态转化(State Transfer):每 发出一个请求,就代表了客户端和服务器的一次交互过程。
HTTP 协议,是一个无状态协议,即所有的状态都保存在服务器端。因此,如果客户端想要操作服务器,
必须通过某种手段,让服务器端发生“状态转化”(State Transfer)。而这种转化是建立在表现层之上的,所以
就是 “表现层状态转化”。具体说,就是 HTTP 协议里面,四个表示操作方式的动词:GET 、POST 、PUT、
DELETE。它们分别对应四种基本操作:GET 用来获取资源,POST 用来新建资源,PUT 用来更新资源,DELETE 用来
删除资源。
restful 的示例:
/account/1 HTTP GET : 得到 id = 1 的 account
/account/1 HTTP DELETE: 删除 id = 1 的 account
/account/1 HTTP PUT: 更新 id = 1 的 account 
/account HTTP POST: 新增 account


作用:用于绑定url中的占位符,例如url中的/delete/{id},这个{id}就是占位符
属性

  1. value:用于指定url的占位符名称
  2. required:是否必须提供占位符

使用示例:

<a href="anno/pathVariable/10">注解@PathVariable</a>
    @RequestMapping("pathVariable/{id}")
    public String testPathVariable(@PathVariable Integer id){ 
        System.out.println(id);   //10
        return "success";
    }

4. @RequestHeader

作用:用户获取请求消息头
属性

  1. value:提供消息头名称
  2. required:是否必须有此消息头

:实际开发中并不常用。

示例:

<a href="anno/requestHeader">注解@RequestHeader</a>
    @RequestMapping("requestHeader")
    public String testRequestHeader(@RequestHeader(value = "User-Agent") String header,
                                    @RequestHeader(value = "date",required = false) String date){ 
        System.out.println(header);
        System.out.println(date);
        return "success";
    }

输出:(date并不包含在请求头中)

5. @CookieValue

作用:用于把指定的cookie名称值传入控制器的方法参数
属性

  1. value:提供指定的cookie名称
  2. required:是否必须有此cookie
<a href="anno/cookieValue">注解@CookieValue</a>
    @RequestMapping("cookieValue")
    public String testCookieValue(@CookieValue(value = "JSESSIONID",required = false) String cookieValue){ 
        System.out.println(cookieValue);
        return "success";
    }

输出:

6. @ModelAttribute

作用:该注解是springMVC 4.3之后加入的,它可以用于修饰方法和参数
属性
value:用于获取数据的key,key可以是POJO的属性名称,也可以是map结构的key。
应用场景:当表单提交数据不是完整的实体类数据时,保证没有提交的数据可以使用数据库原来的数据。
例如:
我们在更新一个用户的数据时,用户有一个字段是不允许被修改的,我们提交表单也没有该字段。该字段从数据库中获取的,于是我们可以先从数据库中获取到,之后更新到新增的到用户。
示例1:ModelAttribute 修饰方法不带返回值

<form action="anno/modelAttribute2" method="post">
    用户名:<input type="text" name="uname"><br>
    密码:<input type="text" name="age"><br>
    <input type="submit" value="提交">
</form>
    @RequestMapping("modelAttribute2")
    public String testModelAttribute2(User user){ 
        System.out.println("testModelAttribute2.....");
        System.out.println(user);
        return "success";
    }
    @ModelAttribute
    public User showUser2(String username){ 
        System.out.println("showUser2.....");
        User user = new User();
        user.setUname(username);
        user.setAge(99999);
        user.setBirthday(new Date());
        return user;
    }


输出:

示例2:ModelAttribute 修饰方法带返回值
基于Map

<form action="anno/modelAttribute1" method="post">
    用户名:<input type="text" name="uname"><br>
    密码:<input type="text" name="age"><br>
    <input type="submit" value="提交">
</form>
  /** * 注解@ModelAttribute:基于map * @param user * @return */
    @RequestMapping("modelAttribute1")
    public String testModelAttribute1(@ModelAttribute(value = "one") User user){ 
        System.out.println("testModelAttribute1.....");
        System.out.println(user);
        return "success";
    }
    //会比testModelAttribute先执行
    @ModelAttribute
    public void showUser1(String username,Map<String,User> map){ 
        System.out.println("showUser1.....");
        User user = new User();
        user.setUname(username);
        user.setAge(9999);
        user.setBirthday(new Date());
        map.put("one",user);
    }


输出:

7. @SessionAttribute

作用:用于多次执行控制方法间的参数共享
属性

  1. value:用于指定存入session的属性名称
  2. type:用于指定存入session的属性数据类型

示例

<a href="anno/sessionAttribute">sessionAttribute</a>  //存入session
<a href="anno/getSession">getSession</a>//获取session
<a href="anno/delSession">delSession</a>//删除session

加上注解@SessionAttribute可以将session共享到控制类的所有方法

 /** * Session域对象共享数据 * @param model * @return */
    @RequestMapping("sessionAttribute")
    public String testSessionAttribute(Model model){ 
        System.out.println("testSessionAttribute.....");
        model.addAttribute("msg","你好 model");
        return "success";
    }


    @RequestMapping("getSession")
    public String getSessionAttribute(ModelMap modelMap){ 
        System.out.println("getSession.....");
        String msg = (String)modelMap.get("msg");
        System.out.println(msg);
        return "success";
    }

    @RequestMapping("delSession")
    public String delSessionAttribute(SessionStatus status){ 
        System.out.println("delSession.....");
        status.setComplete();   //删除session
        return "success";
    }

输出:

如果要想在前端页面展示,则可以开启EL表达式

页面下部广告