springmvc简介及参数传递

雨点打透心脏的1/2处 2021-12-20 07:09 300阅读 0赞

### 文章目录 ###

*  简介
 *  快速上手
 *   *  搭建环境
     *   *  引入依赖
         *  注册DispatcherServlet
         *  配置SpringMVC
     *  前后台业务代码
 *  常用知识点
 *   *  定义Controller
     *  处理请求
     *  获取请求参数
     *   *  示例
         *   *  获取请求中的普通参数(GET、POST)
     *  获取URI中的变量，通常用于RESTFull服务
     *  请求参数自动绑定到对象中
     *   *  示例
     *  获取请求头参数
     *   *  示例
     *  获取Session作用域数据
     *   *  示例
     *  获取Cookie数据
     *   *  示例
     *  使用提前初始化的数据
     *   *  初始化数据、参数
         *  使用初始化的数据
         *  示例
     *  视图控制器实现无逻辑页面跳转

# 简介 #

springmvc全称是spring web mvc，是spring框架一部分，是一个mvc的框架，和struts2一样是一个表现层框架。  
Spring框架概览图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pYWV85MjY0X0FORw_size_16_color_FFFFFF_t_70]  
springmvc处理流程图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pYWV85MjY0X0FORw_size_16_color_FFFFFF_t_70 1]

1.  用户发起请求到前端控制器（DispatcherServlet），该控制器会过滤出哪些请求可以访问Servlet、哪些不能访问。就是url-pattern的作用，并且会加载springmvc.xml配置文件。
2.  前端控制器会找到处理器映射器（HandlerMapping），通过HandlerMapping完成url到controller映射的组件，简单来说，就是将在springmvc.xml中配置的或者注解的url与对应的处理类找到并进行存储，用map<url,handler>这样的方式来存储。
3.  HandlerMapping有了映射关系，并且找到url对应的处理器，HandlerMapping就会将其处理器（Handler）返回，在返回前，会加上很多拦截器。
4.  DispatcherServlet拿到Handler后，找到HandlerAdapter（处理器适配器），通过它来访问处理器，并执行处理器。
5.  执行处理器
6.  处理器会返回一个ModelAndView对象给HandlerAdapter
7.  通过HandlerAdapter将ModelAndView对象返回给前端控制器(DispatcherServlet)
8.  前端控制器请求视图解析器(ViewResolver)去进行视图解析，根据逻辑视图名解析成真正的视图(jsp)，其实就是将ModelAndView对象中存放视图的名称进行查找，找到对应的页面形成视图对象
9.  返回视图对象到前端控制器。
10. 视图渲染，就是将ModelAndView对象中的数据放到request域中，用来让页面加载数据的。
11. 通过第8步，通过名称找到了对应的页面，通过第10步，request域中有了所需要的数据，那么就能够进行视图渲染了。最后将其返回即可。

# 快速上手 #

## 搭建环境 ##

### 引入依赖 ###

<dependency>
    	<groupId>org.springframework</groupId>
    	<artifactId>spring-webmvc</artifactId>
    	<version>5.1.5.RELEASE</version>
    </dependency>
    <dependency>
    	<groupId>javax.servlet</groupId>
    	<artifactId>javax.servlet-api</artifactId>
    	<version>3.1.0</version>
    </dependency>

### 注册DispatcherServlet ###

web.xml配置

<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_3_1.xsd"
             version="3.1">
      <display-name>Archetype Created Web Application</display-name>
    
      <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        
        
        <init-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>WEB-INF/dispatcher-servlet.xml</param-value>
        </init-param>
        
        <load-on-startup>1</load-on-startup>
      </servlet>
    
      <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
      </servlet-mapping>
    
      <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
      </welcome-file-list>
    </web-app>

关于DispatcherServlet拦截路径：  
1、*.do 代表拦截所有以.do结尾的请求，例如：/user/add.do，弊端：所有的url都要以.do结尾。不会影响访问静态文件。  
2、/app/* 代表拦截/app/下面的任何路径、文件，例如：/app/user/add、/app/user/add.jsp，弊端：请求的url都要包含/app  
3、/ 代表将此Servlet设置为默认Servlet，它将拦截所有其他Servlet都无法拦截的请求，例如：/user/add、/user/test/aa.js，弊端：对jpg,js,css静态文件的访问也被拦截不能正常显示(因为它覆盖了Tomcat给我们提供的专门用于处理静态资源的Servlet)。后面有解决办法。  
4、/\* 拦截所有请求(包括\*.jsp)，可以走到Action中，但转发到jsp时再次被拦截，不能访问到jsp。

> 注：
> 
>  *  我们一般选择将DispatcherServlet的拦截路径配置成/或者指定后缀(如：\*.action)。
>  *  我们配置拦截路径是/时，为什么jsp页面不会被拦截，因为Tomcat中有专门处理\*.jsp的Servlet
>  *  Servlet拦截路径的优先级是：完全路径匹配(/TestServlet) > 目录匹配(/aa/) > 扩展名匹配（.do） > /(默认Servlet)

### 配置SpringMVC ###

dispatcher-servlet.xml代码

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           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
            http://www.springframework.org/schema/mvc
           	http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    
        
        <context:component-scan base-package="com.lanou3g.springmvc" />
    
        
        <mvc:view-resolvers>
            <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
                <property name="prefix" value="/" />
                <property name="suffix" value=".jsp" />
            </bean>
        </mvc:view-resolvers>
    </beans>

## 前后台业务代码 ##

index.jsp开始页面

<body>
        <pre>
    	    <a href="test/hello">SpringMVC测试</a>
    	
    	    <a href="nihao/apple">SpringMVC apple测试</a>
    	
    	    <a href="hello/google">SpringMVC google测试</a>
    	
    	    <a href="sihuoge">测试ResponseBody</a>
        </pre>
    </body>

HelloAction.java 后台java代码

/**
     * 通过@Controller标注的类会被SpringIOC容器扫描和管理
     */
    @Controller
    public class HelloAction {
        
    
        /**
         * 定义一个Handler， 可以处理http://localhost:8080/springmvc/test/hello这个请求
         * @return
         */
        @RequestMapping("/test/hello")
        public String hello() {
        
            System.out.println("进入HelloAction.hello()方法");
            return "hello";
        }
    
        /**
         * 处理请求，并携带数据跳转到页面
         * @param mv
         * @return
         */
        @RequestMapping("/nihao/apple")
        public ModelAndView hello1(ModelAndView mv) {
        
            System.out.println("进入HelloAction.hello1()方法");
            mv.setViewName("hello");
            mv.addObject("key", "apple");
            return mv;
        }
    
        @RequestMapping("/hello/google")
        public String hello2() {
        
            System.out.println("进入HelloAction.hello2()方法");
            return "hello";
        }
    
        /**
         * 通过@ResponseBody注解标注的方法， 不会被解析成视图， 而是直接将返回的内容本身输出给调用方(浏览器、其他服务、抓包工具)
         * @return
         */
        @ResponseBody
        @RequestMapping("/sihuoge")
        public String test() {
        
            return "sihuo";
        }
    }

hello.jsp 响应请求展示页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>Hello</title>
    </head>
    <body>
        欢迎来到SpringMVC......<br/>
        <a href="abc">abc</a>
    </body>
    </html>

# 常用知识点 #

## 定义Controller ##

@Controller
    public class OwnerController {
        
    }

## 处理请求 ##

在Controller的方法上添加@RequestMapping注解

@RequestMapping("/hello")
    public String hello() {
        
        return "hello";
    }

## 获取请求参数 ##

请求参数可以直接定义到方法参数里，并通过@RequestParam(“key”)注解修饰参数，这样SpringMVC会自动解析请求中的参数给你填充到方法参数中。

注意：此注解修饰的参数默认是必传的，如果请求中没有此参数会直接报错，可以通过设置此注解的required属性为false解决

@RequestMapping("/login")
    public String test(int age, String name, @RequestParam(value = "nickname", required = false) String nickName, Model model) {
        
        System.out.println("login, age: " + age+", name: " + name+", nickName: " + nickName);
        model.addAttribute("msg", age);
        return "main";
    }

JDK1.8以后我们也可以通过添加编译参数-parameters参数告诉编译器在编译时保留方法参数名，这样如果请求中参数名与方法定义的参数名对应时，可以不用显示添加@RequestParam注解

### 示例 ###

#### 获取请求中的普通参数(GET、POST) ####

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>请求参数自动绑定到对象中</title>
    </head>
    <body>
        <a href="test/param?sname=张三&age=23">请求参数自动绑定到对象中</a>
    </body>
    </html>

TestController.java

@Slf4j
    @Controller
    @RequestMapping("/test")
    public class TestController {
        
        /**
         * 获取请求中的普通参数(GET、POST)
         * @param sname
         * @param age
         * @param gender
         * @param model
         * @return
         */
        @RequestMapping("/param")
        public String testRequestParam(@RequestParam("sname") String sname,@RequestParam(value = "age",required = false) Integer age, Integer gender, Model model){
        
            model.addAttribute("sname",sname);
            model.addAttribute("age",age);
            log.debug("sname:" + sname + ",age:" + age + ",gender:" + gender);
            return "hello";
        }
    }

hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>Hello</title>
    </head>
    <body>
        参数:sname:${sname},age:${age}
    </body>
    </html>

## 获取URI中的变量，通常用于RESTFull服务 ##

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>请求参数自动绑定到对象中</title>
    </head>
    <body>
    	<%-- 此处参数不能传中文 --%>
        <a href="test/path_var/zhangsan/34">请求参数自动绑定到对象中</a>
    </body>
    </html>

TestController .java

@Slf4j
    @Controller
    @RequestMapping("/test")
    public class TestController {
        
        /**
         * 获取URI中的变量，通常用于RESTFull服务
         * @param sname
         * @param age
         * @param model
         * @return
         */
        @RequestMapping("/path_var/{sname}/{age}")
        public String testPathVar(@PathVariable("sname") String sname,@PathVariable Integer age, Model model){
        
            model.addAttribute("sname",sname);
            model.addAttribute("age",age);
            log.debug("sname:" + sname + ",age:" + age);
            return "hello";
        }
    }

hello.jsp

## 请求参数自动绑定到对象中 ##

如果RequestMapping方法的参数中是一个自定义的对象，Spring会调用DataBinder自动将请求中的参数注入到对象的同名属性中。  
使用示例：

@RequestMapping("/test/bind_obj")
    public String testBindObject(Student student, Model model) {
        
        System.out.println("testBindObject, student: " + student);
        model.addAttribute("msg", student);
        return "main";
    }

访问地址：

http://localhost:8080/test/bind_obj?sname=张三&age=34&id=2

### 示例 ###

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>请求参数自动绑定到对象中</title>
    </head>
    <body>
        <a href="get_stu?sname=张三&age=23">请求参数自动绑定到对象中</a>
    </body>
    </html>

StudentController.java

@Controller
    public class StudentController {
        
        @RequestMapping("/get_stu")
        public String getStudent(Student student, Model model){
        
            model.addAttribute("student",student);
            return "student";
        }
    }

student.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>student</title>
    </head>
    <body>
        student对象：${student}<br>
        sname: ${student.sname}
    </body>
    </html>

## 获取请求头参数 ##

使用@RequestHeader注解

### 示例 ###

TestController .java

@Slf4j
    @Controller
    @RequestMapping("/test")
    public class TestController {
        
        /**
         * 获取请求头参数
         * @param sname
         * @param model
         * @return
         */
        @RequestMapping("/header")
        public String testReqHeader(@RequestHeader("sname") String sname, Model model){
        
            model.addAttribute("sname",sname);
            log.debug("sname:" + sname);
            return "hello";
        }
    }

hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>Hello</title>
    </head>
    <body>
        参数:sname:${sname}
    </body>
    </html>

## 获取Session作用域数据 ##

使用@SessionAttribute和@SessionAttributes注解

### 示例 ###

TestController .java

@Slf4j
    @Controller
    @RequestMapping("/test")
    public class TestController {
        
        /**
         * 获取作用域参数
         * @param sname
         * @param model
         * @return
         */
        @RequestMapping("/attr")
        public String testAttr(@SessionAttribute(value = "sname",required = false) String sname,Model model){
        
            model.addAttribute("sname",sname);
            log.debug("sname:" + sname);
            return "hello";
        }
    }

hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>Hello</title>
    </head>
    <body>
        参数:sname:${sname}
    </body>
    </html>

## 获取Cookie数据 ##

使用@CookieValue注解

### 示例 ###

TestController .java

@Slf4j
    @Controller
    @RequestMapping("/test")
    public class TestController {
        
        /**
         * 获取Cookie参数
         * @param sname
         * @param model
         * @return
         */
        @RequestMapping("/cookie")
        public String testCookie(@CookieValue("sname") String sname,Model model){
        
            model.addAttribute("sname",sname);
            log.debug("sname:" + sname);
            return "hello";
        }
    }

hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>Hello</title>
    </head>
    <body>
        参数:sname:${sname}
    </body>
    </html>

## 使用提前初始化的数据 ##

### 初始化数据、参数 ###

在方法上添加@ModelAttribute注解

/**
     * 提前初识化一些数据，在RequestMapping方法中，可以通过给方法参* 数添加@ModelAttribute来使用
     * @return
     */
    @ModelAttribute
    public Map<String, String> prepareData() {
        
        Map<String, String> data = new HashMap<>();
        data.put("sname", "张四丰");
        return data;
    }

### 使用初始化的数据 ###

在方法参数上添加@ModelAttribute注解  
使用当前Controller中通过@ModelAttribute注解预初始化的数据

/**
     * 测试@ModelAttribute作用
     * @return
     */
    @RequestMapping("/model_attr")
    public String testModelAttr(@ModelAttribute Map<String, String> data, Model model) {
        
        log.debug("model key: sname ->" + data.get("sname"));
        model.addAttribute("sname", data.get("sname"));
        return "hello";
    }

### 示例 ###

TestController .java

@Slf4j
    @Controller
    @RequestMapping("/test")
    public class TestController {
        
        /**
         * 提前初识化一些数据，在RequestMapping方法中，可以通过给方法参数添加@ModelAttribute来使用
         * @return
         */
        @ModelAttribute
        public Map<String, String> prepareData() {
        
            Map<String, String> data = new HashMap<>();
            data.put("sname", "张三");
            return data;
        }
        /**
         * 测试@ModelAttribute作用
         * @return
         */
        @RequestMapping("/model_attr")
        public String testModelAttr(@ModelAttribute Map<String, String> data, Model model) {
        
            log.debug("model key: sname ->" + data.get("sname"));
            model.addAttribute("sname", data.get("sname"));
            return "hello";
        }
    }

hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>Hello</title>
    </head>
    <body>
        参数:sname:${sname}
    </body>
    </html>

## 视图控制器实现无逻辑页面跳转 ##

当我们的前端页面在私有文件夹里时(此时浏览器无法直接访问这些页面)如图所示。  
![在这里插入图片描述][20190702194159947.png]  
如果我们有些请求只是想跳转页面，不需要来后台处理什么逻辑，我们无需在Controller中写一个空方法来跳转，直接在dispatcher-servlet.xml中配置一个如下的视图跳转控制器(view-controller)即可(不经过Controller，直接跳转页面)

<mvc:view-controller path="/index" view-name="index" />

> 如果配置了上面的view-controller，那默认用于处理@RequestMapping注解的RequestMappingHandlerMapping就会被覆盖掉，导致我们在Controller中写的@RequestMapping方法无法处理请求。  
> 解决办法：添加如下一行，重新启用RequestMappingHandlerMapping
> 
>     <mvc:annotation-driven />

同时试图解析器的配置也需要更改

<mvc:view-resolvers>
            <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
                <property name="prefix" value="/WEB-INF/views/" />
                <property name="suffix" value=".jsp" />
            </bean>
        </mvc:view-resolvers>

此时浏览器就可直接访问index.jsp了

http://localhost:8080/xxxxxx/index

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pYWV85MjY0X0FORw_size_16_color_FFFFFF_t_70]: /images/20211220/34cf417426be49838c4204e468583cf4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pYWV85MjY0X0FORw_size_16_color_FFFFFF_t_70 1]: /images/20211220/0d3a7a9a8ce54840b4bca82d9479cecd.png
[20190702194159947.png]: /images/20211220/e0b6c4e9592346b98d84b44bb9b12772.png