Spring mvc 初探

Spring mvc：

HelloWorld：

1.在 web.xml 文档中配置 DispatcherServlet：

<!--配置 DispatcherServlet-->
    <servlet>
        <servlet-name>springDispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>


        <!--配置一个初始化参数-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>

        <!--也可以使用默认的-->
        <!--默认的配置文件为 /WEB-INF/<servlet-name>-servlet.xml-->

        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springDispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

（在 IDEA 中可以直接代码提示找 DispatcherServlet）
对于 init-param 初始化配置，可以用默认的路径：/WEB-INF/<servlet-name>-servlet.xml

url 中的 / 表示全部匹配

2.声明控制类：

@Controller
public class HelloWorld {

    /**
     * 使用 RequestMapping 注解来映射请求的 URL
     * 返回值会通过视图解析器解析为实际的物理视图，对于 InternalResourceViewResolver 视图解析器，会做如下解析：
     * 通过 perfix + returnVal + 后缀 这样的方式得到实际的物理视图，然后做转发操作
     * @return
     */
    @RequestMapping("/helloworld")
    public String Hello() {
        System.out.println("Hello world!");
        return "success";
    }

}

@RequestMapping 用来作为映射请求的 URL
（对于路径的传输匹配）
返回的 “success” 经过视图解析器解析为实际的路径：前缀(prefix) + returnVal + 后缀(suffix)
最终路径：/WEB-INF/views/success.jsp

3.写 springmvc 配置文件：

<!--配置自动扫描的包-->
    <context:component-scan base-package="com.springmvc.handlers"></context:component-scan>

    <!--配置视图解析器，如何把 Handler 方法解析为实际的物理视图-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>

自动扫描包扫描注解
视图解析器：InternalResourceViewResolver 中设置两个值：前缀和后缀

4.对于主界面的跳转：
<a href="helloworld">Hello world!</a>
helloworld 经过 @RequestMapping(“/helloworld”) 解析跳转过来执行 Hello() 方法
返回的 “success” 经过视图解析器跳转到目标路径下的 jsp 页面

RequestMapping：

Spring MVC 使用 @RequestMapping 注解为控制器指定可以处理哪些 URL 请求

在控制器类定义及方法定义处都可标注

@RequestMapping
类定义处：提供初步的请求映射信息。 相对于 WEB 应用的根目录
方法处：提供进一步的细分映射信息。 相对于类定义处的 URL。
若类定义处未标注 @RequestMapping
则方法处标记的 URL 相对于 WEB 应用的根目录

DispatcherServlet 截获请求后，就通过控制器上 @RequestMapping 提供的映射信息确定请求所对应的处理方法

修饰类：

@Controller
@RequestMapping("/springmvc")
public class HelloWorld {

    @RequestMapping("/helloworld")
    public String Hello() {
        System.out.println("Hello world!");
        return "success";
    }

}

URL：
<a href="springmvc/helloworld">Hello world!</a>

指定请求方式：

@RequestMapping 除了可以使用请求 URL 映射请求外
还可以使用请求方法、请求参数及请求头映射请求

@RequestMapping 的 value、method、params 及 heads
分别表示 请求 URL、请求方法、请求参数及请求头的映射条件
他 们之间是“与”的关系
联合使用多个条件可让请求映射更加精确化

params 和 headers 支持简单的表达式
param1: 表示请求必须包含名为 param1 请求参数
!param1: 表示请求不能包含名为 param1 请求参数
param1 != value1: 表示请求包含名为 param1 请求参数，但其值不能为 value1
{“param1=value1”, “param2”}: 请求必须包含名为 param1 和 param2 两个请求参数
且 param1 参数的值必须为 value1

Method ：

@RequestMapping(value = "/testMethod", method = RequestMethod.POST)
    public String testMethod() {
        System.out.println("testMethod");
        return "success";
    }

则必须用表单设置 method 为 post：

<form method="post" action="/springmvc/testMethod">
      <input type="submit" value="submit"/>
    </form>

params & headers：

@RequestMapping(value = "/testPH", params={"username", "age!=10"}, headers = {"Accept-Language=zh-CN,zh;q=0.8"})
    public String ParamAndHeads() {
        System.out.println("ParamAndHeads");
        return "success";
    }

params 中所指定的属性必须一致才能跳转执行：
<a href="/springmvc/testPH?username=haha&age=11">TestPH</a>
路径 + ? + 属性=value + & + 属性=value

对于 headers ，和网页有关，若指定，则必须跟网页的 headers 一样才能跳转

（二者应用均不多，作了解）

路径简化：

Ant 风格资源地址支持 3 种匹配符：
? ：匹配文件名中的一个字符
* ：匹配文件名中的任意字符
** ：匹配多层路径

@RequestMapping 还支持 Ant 风格的 URL：
/user/*/createUser : 匹配
/user/aaa/createUser、/user/bbb/createUser 等 URL

/user/**/createUser : 匹配
/user/createUser、/user/aaa/bbb/createUser 等 URL

/user/createUser?? : 匹配
/user/createUseraa、/user/createUserbb 等 URL

如：
@RequestMapping("/helloworld/*/hahaha")
则超链接中路径可写成：
<a href="/helloworld/sdsfesfdsfdsf/hahaha">helloworld</a>

PathVariable：

（可以来映射 URL 中的占位符到目标方法的参数中）

带占位符的 URL 是 Spring3.0 新增的功能
该功能在 SpringMVC 向 REST 目标挺进发展过程中具有里程碑的意义

通过 @PathVariable 可以将 URL 中占位符参数绑定到控制器处理方法的入参中 ：
URL 中的 {xxx} 占位符可以通过 @PathVariable(“xxx”) 绑定到操作方法的入参中

如：

@RequestMapping("/testPathVariable/{id}")
    public String testPathVariable(@PathVariable("id") Integer id){
        System.out.println("testPathVariable : " + id);
        return "success";
    }

{id} 表示 URL 中的 Integer 类型的数字
在传参中声明 @PathVariable(“id”) Integer id ，即可使用 URL 中的占位符（1）：
<a href="/testPathVariable/1">hhh</a>

Rest：

REST：即 Representational State Transfer。（资源）表现层状态转化。是目前
最流行的一种互联网软件架构。它结构清晰、符合标准、易于理解、扩展方便，
所以正得到越来越多网站的采用

资源（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 用来删除资源

在 web.xml 中用 <filter> 去配置 HiddenHttpMethodFilter ，配置方法与 servlet 类似：

<filter>
        <filter-name>HiddenHttpMethodFilter</filter-name>
        <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>HiddenHttpMethodFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

/* 表示全部匹配

之后在表单中用 <input type="hidden" name="_method" value="PUT"> 等来更改方式：

<form action="/springmvc/testRest" method="post">
    <input type="submit" value="TestRest Post"/>
</form>

  <a href="/springmvc/testRest/1">TestRest Get</a>

  <form action="/springmvc/testRest/1" method="post">
    <input type="hidden" name="_method" value="DELETE"/>
    <input type="submit" value="TestRest Delete"/>
  </form>

  <form action="/springmvc/testRest/1" method="post">
    <input type="hidden" name="_method" value="PUT"/>
    <input type="submit" value="TestRest Put"/>
  </form>

value 后是想改的发送方式
POST 是新增所以不需要参数
方法的 RequestMapping 的 method 的属性中声明即可

传参处理（@RequestParams）：

Spring MVC 通过分析处理方法的签名，将 HTTP 请求信息绑定到处理方法的相应入参中。

Spring MVC 对控制器处理方法签名的限制是很宽松的，几乎可以按喜欢的任何方式对方法进行签名。

必要时可以对方法及方法入参标注相应的注解（@PathVariable、@RequestParam、@RequestHeader 等）
SpringMVC 框架会将 HTTP 请求的信息绑定到相应的方法入参中
并根据方法的返回值类型做出相应的后续处理。

传参：
<a href="/springmvc/testRequestParams?username=hahaha&age=10">TRP</a>

调用参数：

@RequestMapping("/testRequestParams")
    public String testRequestParams(@RequestParam(value = "username") String username, @RequestParam(value="age",required = false, defaultValue = "0") int age) {
        System.out.println(username + age);
        return "success";
    }

利用 @RequestParams 注释，用 value 属性值来获得 URL 中的参数
参数最好用类型表示，如 Integer 等
（如果用 int 的话，URL 没有此参数，则会报错，而 Integer 则显示为 null）
required 默认为 true，设置为 false 表示这个参数可以没有（不传进来）
defaultValue 表示设置参数默认值

请求头（@RequestHeader）：

请求头包含了若干个属性
服务器可据此获知客户端的信息
通过 @RequestHeader 即可将请求头中的属性值绑定到处理方法的入参中

用超链接直接跳转：
<a href="/springmvc/testRequestHeader">TRH</a>

在传参中设置请求头，可以将其显示出来：

@RequestMapping("/testRequestHeader")
    public String testRequestHeader(@RequestHeader(value = "Accept-Language") String al) {
        System.out.println("testRequestHeader : " + al);
        return "success";
    }

打印效果：
testRequestHeader : zh-CN,zh;q=0.9

@CookieValue：

可让入参绑定某个 Cookie 值：

@RequestMapping("/testCookieValue")
    public String testCookieValue(@CookieValue("JSESSIONID") String cookieValue)  {
        System.out.println("testCookieValue : " + cookieValue);
        return "success";
    }

JSESSIONID：

（也可以自己创建，这里是直接拿网站上原有的 Cookie 来用）

使用 POJO 对象绑定请求参数值：

Spring MVC 会按请求参数名和 POJO 属性名进行自动匹配
自动为该对象填充属性值。支持级联属性。
如：dept.deptId、dept.address.tel 等

用表单传参，name 要和属性名一致：

<form action="/springmvc/testPojo" method="post">
    username:<input type="text" name="username"/>
    <br/>
    password:<input type="password" name="password"/>
    <br/>
    email:<input type="text" name="email"/>
    <br/>
    age:<input type="text" name="age"/>
    <br/>
    city:<input type="text" name="address.city"/>
    <br/>
    province:<input type="text" name="address.province"/>
    <input type="submit" value="Submit"/>
  </form>

支持级联属性：address.city

新建一个类，这个类包含表单中的属性
（级联属性可包含另一个类 Address，Address 中有 city 和 province）

直接将目标类传入，即可自动进行属性名和 name 的匹配：

@RequestMapping("/testPojo")
    public String testPojo(User user) {
        System.out.println("testPojo : " + user);
        return "success";
    }

（目标类中必须有相应的 get 和 set 方法）

使用 Servlet API 作为入参：

方法可以接受以下参数：
• HttpServletRequest
• HttpServletResponse
• HttpSession
• java.security.Principal
• Locale
• InputStream
• OutputStream
• Reader
• Writer

如：

@RequestMapping("/testServletAPI")
    public void testServletAPI(HttpServletRequest request, HttpServletResponse response , Writer out) throws IOException {
        System.out.println("testServletAPI : " + request + " , " + response);

        out.write("hello springmvc");

        /*return "success";*/
    }

out.write 直接在页面上打印一句话

处理模型数据：

• Spring MVC 提供了以下几种途径输出模型数据：
– ModelAndView:
处理方法返回值类型为 ModelAndView时
方法体即可通过该对象添加模型数据

– Map 及 Model:
入参为 org.springframework.ui.Model、org.springframework.ui.ModelMap 或 java.uti.Map 时
处理方法返回时，Map中的数据会自动添加到模型中。

– @SessionAttributes:
将模型中的某个属性暂存到 HttpSession 中
以便多个请求之间可以共享这个属性

– @ModelAttribute:
方法入参标注该注解后, 入参的对象就会放到数据模型中

ModelAndView：

• 控制器处理方法的返回值如果为 ModelAndView, 则其既包含视图信息，也包含模型数据信息。

• 添加模型数据:
– MoelAndView addObject(String attributeName, Object
attributeValue)
– ModelAndView addAllObject(Map

@RequestMapping("/testModelAndView")
    public ModelAndView testModelAndView() {
        String viewName = "success";
        ModelAndView modelAndView = new ModelAndView(viewName);

        modelAndView.addObject("time", new Date());

        return modelAndView;
    }

返回一个 ModelAndView ，可以传参（String）指定其页面
可以用 addObject 方法设置 键值对
在跳转页面中用 ${requestScope.time} 即可调用显示其 time 的值

（易错点：
应该引入 import org.springframework.web.servlet.ModelAndView;
而不是 import org.springframework.web.portlet.ModelAndView;
若引入后者，则返回跳转会跳转到 URL 的路径
）

关于 ${requestScope.time} ：
requestscope主要用于数据的展示，从request隐藏对象中取出对象或者变量来显示。而request中的对象或变量是通过request.setAttribute方法放入request对象中的。
ModelAndView.addObject 类似于 request.setAttribute

Map 及 Model：

Spring MVC 在内部使用了一个 org.springframework.ui.Model 接口存
储模型数据

• 具体步骤
– Spring MVC 在调用方法前会创建一个隐含的模型对象作为模型数据的存储容器。
– 如果方法的入参为 Map 或 Model 类型，Spring MVC 会将隐含模型的引用传递给这些入参。在方法体内，开发者可以通过这个入参对象访问到模型中的所有数据，也可以向模型中添加新的属性数据

@RequestMapping("/testMap")
    public String testMap(Map<String, Object> map) {
        map.put("names", Arrays.asList("Tom", "Jerry", "Mike"));
        return "success";
    }

直接传进去一个 Map<String, Object> ，put 一个键值对进去
在页面中就可以直接 ${requestScope.names} 来显示这个键对应的值
（也可以是 Model 或者 ModelMap，但是用的少，Map 用的多）

@SessionAttributes：

• 若希望在多个请求之间共用某个模型属性数据，则可以在控制器类上标注一个 @SessionAttributes,
Spring MVC 将在模型中对应的属性暂存到 HttpSession 中。

• @SessionAttributes 除了可以通过属性名指定需要放到会话中的属性外
还可以通过模型属性的对象类型指定哪些模型属性需要放到会话中
– @SessionAttributes(types=User.class) 会将隐含模型中所有类型
为 User.class 的属性添加到会话中。
– @SessionAttributes(value={“user1”, “user2”})
– @SessionAttributes(types={User.class, Dept.class})
– @SessionAttributes(value={“user1”, “user2”},types={Dept.class})

@RequestMapping("/testSessionAttributes")
    public String testSessionAttributes(Map<String, Object> map) {
        User user = new User("Tom", "123456", "[email protected]", 10);
        map.put("user", user);
        map.put("school", "daxue");

        return "success";
    }

map 储存的是 request，但是如果在类头标明：
@SessionAttributes(value = {"user"}, types = {String.class})
value 相对于 map 的键，types 相对于 map 的值的类型
类头加入 @SessionAttributes 注解，则可以将 map 所存储的数值复制一份到 session 中

在页面中直接调用：${sessionScope.user}

@ModelAttribute：

• 在方法定义上使用 @ModelAttribute 注解：
Spring MVC在调用目标处理方法前，会先逐个调用在方法级上标注了 @ModelAttribute 的方法。

• 在方法的入参前使用 @ModelAttribute 注解：
– 可以从隐含对象中获取隐含的模型数据中获取对象，再将请求参数绑定到对象中，再传入入参
– 将方法入参对象添加到模型中

/**
     * 用 @ModelAttribute 标记的方法，会在每个目标方法执行之前被 Spring mvc 调用！
     */
    @ModelAttribute
    public void getUser(@RequestParam(value="id", required = false) Integer id, Map<String, Object> map) {
        if(id != null) {
            // 模拟从数据库中获取一个对象
            User user = new User(1, "Tom", "123456", "[email protected]", 12);
            System.out.println("从数据库中获取一个对象 ：" + user);

            map.put("user", user);
        }
    }

获取数据库对象之后，再在页面上对其进行修改：

<form action="/springmvc/testModelAttribute" method="post">
    <input type="hidden" name="id" value="1"/>
    username:<input type="text" name="username" value="Tom"/><br/>
    email:<input type="text" name="email" value="[email protected]"/><br/>
    age:<input type="text" name="age" value="12"/><br/>
    <input type="submit" value="Submit"/>
  </form>

注意：在 @ModelAttribute 修饰的方法中，map 的 键名 要和入参的类型名的第一个字母小写的字符串一致！（只能是 user ， 不能是 user1）

但是可以用 @ModelAttribute 来修饰，使 value 等于 map 的键名，如：
map.put("abc", user)

则传参为：
public String testModelAttribute(@ModelAttribute("abc") User user){}

关于 @SessionAttributes 引发的异常：

可以用传参 @ModelAttribute(“abc”) 标识与 SessionAttributes 不同的 value 名
或者无 MA 标识，那么必须要有前置的 MA 方法

视图和视图解析器：

• 请求处理方法执行完成后，最终返回一个 ModelAndView对象。
对于那些返回 String，View 或 ModeMap 等类型的处理方法，Spring MVC 也会在内部将它们装配成一个 ModelAndView 对象，它包含了逻辑名和模型对象的视图

• Spring MVC 借助视图解析器（ViewResolver）得到最终的视图对象（View）
最终的视图可以是 JSP ，也可能是 Excel、JFreeChart 等各种表现形式的视图

• 对于最终究竟采取何种视图对象对模型数据进行渲染，处理器并不关心
处理器工作重点聚焦在生产模型数据的工作上，从而实现 MVC 的充分解耦

JSTL：

• 若项目中使用了 JSTL，则 SpringMVC 会自动把视图由 InternalResourceView 转为 JstlView
（引入 JSTL 文件）
• 若使用 JSTL 的 fmt 标签则需要在 SpringMVC 的配置文件中配置国际化资源文件

• 若希望直接响应通过 SpringMVC 渲染的页面，可以使用 mvc:view-controller 标签实现

1.加入 jar 包依赖：jakarta-taglibs-standard-1.1.2

2.配置资源文件 i18n.properties ：

i18n.username=Username
i18n.password=Password

这里可以将 i18n 复制两份
一份用英文，与原 i18n 相同，名字为：i18n_en_US
一份用中文，名字为：i18n_zh_CN，内容为：

i18n.username=\u7528\u6237\u540D
i18n.password=\u5BC6\u7801

（这里的 \u 是中文转换的 u 编码 ，其意义分别为：用户名，密码）

3.配置 springmvc.xml：

<!--配置国际化资源文件-->
    <bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
        <property name="basename" value="i18n"></property>
    </bean>

因为 JSTL 代替了 InternalResource，在引入 jar 包的一刻 JSTL 已经完成替代
所以这里引入的 bean 为 ResourceBundleMessageSource
配置 basename 为 i18n

4.使用 JSTL 视图：
首先在目标页面中引入 JSTL：

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

之后在目标页面使用 fmt 标签显示：

<fmt:message key="i18n.username"></fmt:message>
<fmt:message key="i18n.password"></fmt:message>

JSTL 直接转发到目标页面：

可以用 mvc:view-controller 使其不经过 handle 直接转发到目标页面：

<!--配置直接转发的页面-->
<mvc:view-controller path="/success" view-name="success" />

path 是路径，view-name 是目标文件名

（进入 Tomcat 后在地址栏直接输入 /success ，就可以进入目标界面）

问题：以前的 handle 转发到 success 页面失效
解决：加入 mvc:annotation-driven 标签：

<!--实际开发中通常都需配置 mvc:annotation-driven 标签-->
<mvc:annotation-driven></mvc:annotation-driven>

这样两种方法就都可行了

BeanNameViewResolver 视图解析器：

除了 InternalResourceViewResolver 视图解析器外（路径）
还可以用 BeanNameViewResolver 视图解析器直接靠名字建立页面视图

配置：

<!--配置视图 BeanNameViewResolver 解析器 : 使用视图的名字来解析视图-->
<!--可以用 order 属性配置优先级-->
<bean class="org.springframework.web.servlet.view.BeanNameViewResolver">
    <property name="order" value="1"></property>
</bean>

order 表明视图解析器的优先级

只要有一个实现 View 接口的方法：

@Component
public class HelloView implements View {

    @Override
    public String getContentType() {
        return "text/html";
    }

    @Override
    public void render(Map<String, ?> map, HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        httpServletResponse.getWriter().print("hello view, time : " + new Date());
    }

}

重写 render 方法使其在页面上直接显示内容
在 springmvc 方法中建立返回值为其小名的方法（helloView）
之后超链接可直接调用，只要返回的小名与目标类一致，则根据 BeanName 直接转到目标类
（相应的还可以自定义其他视图，只要实现 View 接口）

关于重定向：

• 一般情况下，控制器方法返回字符串类型的值会被当成逻辑视图名处理

• 如果返回的字符串中带 forward: 或 redirect: 前缀时
SpringMVC 会对他们进行特殊处理：将 forward: 和redirect:
当成指示符，其后的字符串作为 URL 来处理
– redirect:success.jsp：会完成一个到 success.jsp 的重定向的操作
– forward:success.jsp：会完成一个到 success.jsp 的转发操作

@RequestMapping("/testRedirect")
    public String testRedirect() {
        System.out.println("testRedirect");
        return "redirect:/index.jsp";
    }

将请求重定向到 index.jsp
（视图解析器都是转发的）