springMVC常用知识点简介

sringMVC框架结构

架构流程

1. 用户发送请求至前端控制器DispatcherServlet。
2. DispatcherServlet收到请求调用HandlerMapping处理器映射器。
3. 处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。
4. DispatcherServlet通过HandlerAdapter处理器适配器调用处理器。
5. HandlerAdapter执行处理器(handler，也叫后端控制器)。
6. Controller执行完成返回ModelAndView。
7. HandlerAdapter将handler执行结果ModelAndView返回给DispatcherServlet。
8. DispatcherServlet将ModelAndView传给ViewReslover视图解析器
9. ViewReslover解析后返回具体View对象。
10. DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）。
11. DispatcherServlet响应用户

springMVC项目简单示例

项目结构图

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>org.example</groupId>
    <artifactId>springMVC</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <dependencies>

        <!-- springIOC的依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.3.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.3.1</version>
        </dependency>

        <!-- aspectJ的依赖包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.3.1</version>
        </dependency>
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>

        <!-- springMVC依赖包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.2.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>4.2.2.RELEASE</version>
        </dependency>

        <!--jsp文件中用的依赖包 -->
        <dependency>
            <groupId>javax.servlet.jsp.jstl</groupId>
            <artifactId>jstl-api</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.taglibs</groupId>
            <artifactId>taglibs-standard-impl</artifactId>
            <version>1.2.5</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <!--<plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <path>/springmvc</path>
                    <port>8080</port>
                </configuration>
            </plugin>-->
            <plugin>
                <groupId>org.eclipse.jetty</groupId>
                <artifactId>jetty-maven-plugin</artifactId>
                <version>9.4.5.v20170502</version>
                <configuration>
<!--                    <webXml>web/WEB-INF/web.xml</webXml>-->
                    <!--自动扫描文件改变并进行热部署的时间间隔，单位为秒。默认值为0，这代表着禁用扫描并热部署，只有一个大于0的配置可以使它生效。-->
                    <scanIntervalSeconds>10</scanIntervalSeconds>
                    <!--可选择的配置，如果没有设置，Jetty将创建ServerConnector实例来监听8080端口。-->
                    <httpConnector>
                        <!--port：连接监听的端口，默认8080；-->
                        <port>8080</port>
                    </httpConnector>
                    <webApp>
                        <!--你web应用的根路径(访问路径)。默认设置为“/”，如果你可以设置一个路径在“/”下面，例如/mycontext-->
                        <contextPath>/springmvc</contextPath>
                    </webApp>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

web.xml文件：

<?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">

    <!-- 配置前端控制器 -->
    <servlet>
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 设置spring配置文件路径 -->
        <!-- 读取了spring配置文件后，就有了spring父子容器的说法 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <!-- 指定初始化时机，设置为2，表示Tomcat启动时，DispatcherServlet会跟随着初始化 -->
        <!-- 指定不初始化时机，DispatcherServlet就会在第一次被请求的时候，才会初始化，而且之后被初始化一次 -->
        <load-on-startup>2</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

在web.xml文件中加载的springmvc.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: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/mvc
                           http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <context:component-scan base-package="com.czy.controller" />
    <!-- annotation-driven标签会在spring容器中注册很多bean，其中就包括三大组件中的控制器映射器和控制器适配器 -->
<!--    <mvc:annotation-driven />-->

<!-- 试图解析器 -->
<!--<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <!-- 该视图解析器，默认的视图类就是JstlView，可以不写 -->
	<!--	<property name="viewClass"
			value="org.springframework.web.servlet.view.JstlView" />
		<property name="prefix" value="/WEB-INF/jsp/" />
		<property name="suffix" value=".jsp" />
	</bean> -->

</beans>

控制器内容：

package com.czy.controller;


import com.czy.po.Item;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import java.util.ArrayList;
import java.util.List;

@Controller
@RequestMapping("item")
public class ItemController {


    @RequestMapping("queryItem")
    public ModelAndView queryItem(){
        ModelAndView mv = new ModelAndView();

        // 查询数据库，用静态数据模拟
        List<Item> itemList = new ArrayList<Item>();

        // 商品列表
        Item item_1 = new Item();
        item_1.setName("联想笔记本_3");
        item_1.setPrice(6000f);
        item_1.setDetail("ThinkPad T430 联想笔记本电脑！");

        Item item_2 = new Item();
        item_2.setName("苹果手机");
        item_2.setPrice(5000f);
        item_2.setDetail("iphone6苹果手机！");

        itemList.add(item_1);
        itemList.add(item_2);

        mv.addObject("itemList", itemList);
        // 未配置视图解析器时，先写成这样
        mv.setViewName("/WEB-INF/jsp/item/item-list.jsp");

        return mv;
    }

    // 请求方式：http://localhost:8080/springmvc/item/addItem?id=1&name=computer&price=10000&detail=zzzz
    @RequestMapping(value = "addItem")
    public Object addItem(Item item) {
        System.out.println(item.toString());

        List itemList = new ArrayList();
        itemList.add(item);
        ModelAndView mv = new ModelAndView();
        mv.addObject("itemList", itemList);
        mv.setViewName("/WEB-INF/jsp/item/item-list.jsp");
        return mv;
    }

    // 请求方式：http://localhost:8080/springmvc/item/queryItemVo?name=vo&item.id=1&item.name=computer&item.price=10000&item.detail=zzzz
    @RequestMapping(value = "queryItemVo")
    @ResponseBody    // 返回Json串：{"name":"vo","item":{"id":1,"name":"computer","price":10000.0,"pic":null,"createtime":null,"detail":"zzzz"}}
    public ItemVo queryItemVo(ItemVo itemVo) {
        System.out.println(itemVo.toString());
        return itemVo;
    }
    
    // get方式URL请求：http://localhost:8080/springmvc/item/2
    /* restful风格 */
    @RequestMapping(value = "{id}", method = RequestMethod.GET)
    @ResponseBody
    public Item queryItemById(@PathVariable("id") Integer id) {
        Item item = itemService.queryItemById(id);
        return item;
    }

    // post请求的url：http://localhost:8080/springmvc/item
    /* restful风格处理post请求 */
    @ResponseBody
    @PostMapping
    public Item updateItem(Item item){
        //商品修改
        itemService.updateItem(item);

        return item;
    }
}

参数绑定可以是普通的Java类型，也可以是Pojo类型，甚至还可是包装的Pojo类型(自定义的Java类中的属性中包括自定义的Java类)。

package com.czy.vo;

import com.czy.po.Item;

public class ItemVo {

    private String name;

    private Item item;

    public String getName() {
        return name;
    }

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

    public Item getItem() {
        return item;
    }

    public void setItem(Item item) {
        this.item = item;
    }

    @Override
    public String toString() {
        return "[ name = " + name + ",item = " + item.toString() + "]";
    }
}

前端文件就省略了。。。