SpringMVC 温习笔记(二)springMVC框架-CSDN博客

本文链接：https://blog.csdn.net/xueshanfeitian/article/details/113444007

什么是springMVC

springMVC是一款基于java实现的MVC设计模式的请求驱动类型的轻量级web框架，属于SpringFrameWork的后续产品，已经融合在SpringWebFlow中。SpringMVC是目前最为流行的前端框架之一，在Spring3.0发布之后，全面超越了Struct2框架，成为最优秀的MVC框架。他让一个简单的java类成为处理请求的控制器，而无需实现任何借口，同时还支持RESTful编程风格的请求。

图解springMVC执行原理

springMVC框架基本思想

springMVC开发步骤图解
此处值得一提的是springMVC框架他工作要点在于抽取的baseServlet这个模块，而struts2则工作在filter模块中，上述图片是直接采用传智播客老师讲义上的图片，仅供学习讨论。

springMVC使用要点

首先需要导入dependency，导入的jar包需要参考上一小结案例，保持一致即可。
依赖

  <dependency>
       <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
       <version>5.1.32</version>
   </dependency>
   <dependency>
       <groupId>c3p0</groupId>
       <artifactId>c3p0</artifactId>
       <version>0.9.1.2</version>
   </dependency>
   <dependency>
       <groupId>com.alibaba</groupId>
       <artifactId>druid</artifactId>
       <version>1.1.10</version>
   </dependency>
   <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>4.12</version>
       <scope>test</scope>
   </dependency>
   <dependency>
       <groupId>commons-fileupload</groupId>
       <artifactId>commons-fileupload</artifactId>
       <version>1.3.3</version>
   </dependency>

   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-context</artifactId>
       <version>5.0.5.RELEASE</version>
   </dependency>
   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-test</artifactId>
       <version>5.0.5.RELEASE</version>
   </dependency>
   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-web</artifactId>
       <version>5.0.5.RELEASE</version>
   </dependency>
   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-webmvc</artifactId>
       <version>5.0.5.RELEASE</version>
   </dependency>
   <dependency>
       <groupId>javax.servlet</groupId>
       <artifactId>javax.servlet-api</artifactId>
       <version>3.0.1</version>
       <scope>provided</scope>
   </dependency>
   <dependency>
       <groupId>javax.servlet.jsp</groupId>
       <artifactId>javax.servlet.jsp-api</artifactId>
       <version>2.2.1</version>
       <scope>provided</scope>
   </dependency>

web.xml配置文件。

<!--配置springMVC的前端控制器-->
    <servlet>
        <servlet-name>DispatcherServlet</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>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

notes:
(1)此处的dispatcherServlet就相当于上一小结的ContextLoaderListener类的效用相似。
(2)此外的init-param标签相当于上一小结中context-param，该参数用来设置springMVC配置文件的参数。
springMVC配置文件

<?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"
       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">
    <!--扫描controller-->
    <context:component-scan base-package="com.feitian.component.web.controller"/>

</beans>

在配置文件中只需要注明扫描controller包，并将其纳入容器中即可。
controller 包。
如果只想扫描web包，还有一种写法如下所示:

<context:component-scan base-package="com.feitian">
    <!--表示扫描包含controller注解的服务-->
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

UserController类:

@Controller
/*@RequestMapping("/userController")*/
public class UserController {
    @RequestMapping("/save")
    public String save(){
        System.out.println("controller save are running");
        return "success.jsp";
    }
}

springMVC框架执行流程

在这里插入图片描述
上图是tomcat中springMVC执行的简要流程，接下来看看springMVC详细步骤。

在项目中也可对内部资源视图解析器进行手动配置：
springMVC配置文件

    <!--扫描controller-->
    <!--<context:component-scan base-package="com.feitian.component.web.controller"/>-->
    <context:component-scan base-package="com.feitian">
        <!--表示扫描包含controller注解的服务-->
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

controller写法

@Controller
@RequestMapping("/userController")
public class UserController {
    @RequestMapping("/save")
    public String save(){
        System.out.println("controller save are running");
        //return "/jsp/success";
        return  "success";
    }
}

notes: 在手动修改InternalResourceViewResolver时，suffix 和prefix 的配置使得我们在返回视图时省略了".jsp"和"/jsp/"。

springMVC 回写数据

页面跳转方式

字符串返回方式

转发过程:
在这里插入图片描述
在转真个转发过程中配置了viewResolver后，就对配置的各个环境组装，组装后将完整的解析器返回给前端控制器。
重定向过程:

return  "redirect:/jsp/success.jsp";

重定向过程及是一个重新请求的过程。

ModelAndView返回方式

    //1.以新建ModelAndView 变量的方式返回
    @RequestMapping("/save02")
    public ModelAndView save02(){
        System.out.println("Controller save02 is running");
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("username","feitian");
        modelAndView.setViewName("success");
        return modelAndView;
    }

    //2.以ModelAndView参数的方式返回
    @RequestMapping("/save03")
    public ModelAndView save03(ModelAndView modelAndView){
        System.out.println("Controller save03 is running");
        modelAndView.addObject("username","xueshanfeitian");
        modelAndView.setViewName("success");
        return modelAndView;
    }

    //3.用拆分的方式返回ModelAndView
    @RequestMapping("/save04")
    public String save04(Model model){
        System.out.println("Controller save04 is running");
        model.addAttribute("username","xueshanfeitian");
        return "success";
    }

  //4.以设置request参数的方式返回ModelAndView
    @RequestMapping("/save05")
    public String save05(HttpServletRequest request){
        System.out.println("Controller save05 is running");
        request.setAttribute("username","xueshanfeitian");
        return "success";
    }

回写数据

直接返回字符串

采用response注入对象回写数据

    //1.采用response回写数据
    @RequestMapping("/save06")
    public void save06(HttpServletResponse response)
            throws IOException {
        System.out.println("Controller save06 is running");
        response.getWriter().println("hello feitian");
    }

此处需要说明的是ResponseBody注解，该注解是告诉springMVC框架，本返回数据不是去跳转页面，而是要以字符串的形式直接回写数据。
采用注解@ResponseBody注解，直接返回字符串。

//2.采用responseBody注解的方式,不进行视图跳转
    @RequestMapping("/save07")
    @ResponseBody
    public String save07() {
        System.out.println("Controller save07 is running");
        return "{\"username\":\"我是张君的老祖！！！\",\"age\":\"3000\"}";
    }

返回对象或数据

期望将对象或者集合转成jackson对象返回。
首先需要导入jackson依赖

   <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-core</artifactId>
       <version>2.9.0</version>
   </dependency>
   <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-databind</artifactId>
       <version>2.9.0</version>
   </dependency>
   <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-annotations</artifactId>
       <version>2.9.0</version>
   </dependency>

手动转换成jackson对象返回，其本质是与返回字符串是一样的
采用jackson转换工具转换后，发挥jackson字符串。

@RequestMapping("/save08")
    @ResponseBody
    public String save08() throws JsonProcessingException {
        System.out.println("Controller save08 is running");
        User user = new User();
        user.setRelation("我是张君的老祖");
        user.setAge(3000);
        ObjectMapper mapper = new ObjectMapper();
        String json = mapper.writeValueAsString(user);
        return  json;
    }

采用修改springMVC配置文件的方式

这种方式本质上是将json转换器配置直接注入到RequestMappingHandlerAdapter即处理器适配器，换种思路就是将RequestMappingHandlerAdapter对象的成员变量messageConverters赋值为MappingJackson2HttpMessageConverter。
在springMVC中需要加入处理器映射器的配置如下:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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">
    <!--扫描controller-->
    <!--<context:component-scan base-package="com.feitian.component.web.controller"/>-->
    <context:component-scan base-package="com.feitian">
        <!--表示扫描包含controller注解的服务-->
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
    <!--配置资源解析器-->
    <bean id="viewResolver" class=
            "org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--配置处理器映射器-->
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
        <property name="messageConverters">
            <list>
                <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
            </list>
        </property>
    </bean>
</beans>

测试方法

@RequestMapping("/save09")
    @ResponseBody
    //期望springMVC自动将User转换成json格式的字符串
    public User save09() throws JsonProcessingException {
        System.out.println("Controller save09 is running");
        User user = new User();
        user.setRelation("我是张君的老祖");
        user.setAge(3000);
        return  user;
    }

采用注册注解驱动方式

<?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">
    <!--扫描controller-->
    <!--<context:component-scan base-package="com.feitian.component.web.controller"/>-->
    <context:component-scan base-package="com.feitian">
        <!--表示扫描包含controller注解的服务-->
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
    <!--配置资源解析器-->
    <bean id="viewResolver" class=
            "org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--配置处理器映射器-->
    <!--<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
        <property name="messageConverters">
            <list>
                <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
            </list>
        </property>
    </bean>-->
    <!--注册注解驱动-->
    <mvc:annotation-driven/>
</beans>

此处需要注意的是加入mvc命名空间。 采用注册注解驱动的这种配置方式，其本质上是将json转换器配置注入到处理器适配器的过程直接在底层实现，及<mvc:annotation-driven/>节省了我们以前繁琐的json转换器配置注入过程。
测试方法可以保持与上面一致save08保持一致

@RequestMapping("/save09")
    @ResponseBody
    //期望springMVC自动将User转换成json格式的字符串
    public User save09() throws JsonProcessingException {
        System.out.println("Controller save09 is running");
        User user = new User();
        user.setRelation("我是张君的老祖");
        user.setAge(3000);
        return  user;
    }

测试方法可以与上面保持一致。

springMVC处理请求数据

当请求controller时, 则请求参数一般会自动映射
如本例中小猿的请求如下:
在这里插入图片描述
controller自动将请求参数映射

    @RequestMapping("/save10")
    @ResponseBody
    //期望springMVC自动将User转换成json格式的字符串
    public void save10(String relation,int age) throws JsonProcessingException {
        System.out.println("Controller save10 is running");
        System.out.println(relation+": 修炼年份"+age);
    }

controller自动将请求参数映射并封装成实体类
请求地址;
在这里插入图片描述

请求方法如下所示:

    @RequestMapping("/save11")
    @ResponseBody
    //期望springMVC自动将User转换成json格式的字符串
    public void save11(User user) throws JsonProcessingException {
        System.out.println("Controller save11 is running");
        System.out.println(user.getRelation()+": 修炼年份"+user.getAge());
    }

controller自动将请求参数映射并封装成数组
请求参数
在这里插入图片描述
请求方法如下所示:

    @RequestMapping("/save12")
    @ResponseBody
    public void save12(String  arr []) throws JsonProcessingException {
        System.out.println("Controller save12 is running");
        System.out.println(Arrays.asList(arr));
    }

采用将集合封装在一个对象的操作方式

请求数据采用表单提交的方式:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <form action="${pageContext.request.contextPath}/userController/save13" method="post">
        <%--表明是第几个user对象的username--%>
        <input type="text" name="userList[0].relation"/><br/>
        <input type="text" name="userList[0].age"/><br/>
        <input type="text" name="userList[1].relation"/><br/>
        <input type="text" name="userList[1].age"/><br/>
        <input type="text" name="userList[2].relation"/><br/>
        <input type="text" name="userList[2].age"/><br/>
        <input type="text" name="userList[3].relation"/><br/>
        <input type="text" name="userList[3].age"/><br/>
        <input type="submit" value="提交">
    </form>

</body>
</html>

访问jsp页面:
在这里插入图片描述
挨个填写表单，然后提交即可在控制台看到请求后的数据封装。
测试类:

@RequestMapping("/save13")
    @ResponseBody
    public void save13(Pojo pojo) throws JsonProcessingException {
        System.out.println("Controller save13 is running");
        System.out.println(pojo);
    }

其中pojo中有user对象

public class Pojo {
    private List<User> userList;
    ......
}

在请求过程中我们会看到控制台答应乱码，我们需要对编码进行处理。
在这里插入图片描述
解决乱码问题需要在web.xml中需要配置filter。

filter的两种实现方法

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

    <!--配置springMVC的前端控制器-->
    <servlet>
        <servlet-name>DispatcherServlet</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>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    
    <!--将applicationContext.xml放入ServletContext，方便自定义监听类初始化该文件。-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    
    <!--监听器启动时要加载定义监听类-->
    <listener>
        <listener-class>com.feitian.component.web.listener.ContextLoaderListener</listener-class>
    </listener>
    
    <!--将UserServlet加载到web容器中-->
    <servlet>
        <servlet-name>UserServlet</servlet-name>
        <servlet-class>com.feitian.component.web.servlet.UserServlet</servlet-class>
    </servlet>
    
    <!--映射UserServlet为userServlet-->
    <servlet-mapping>
        <servlet-name>UserServlet</servlet-name>
        <url-pattern>/userServlet</url-pattern>
    </servlet-mapping>
    
    <!--配置过滤器相关文件-->
    <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>
</web-app>

filter接口实现

通过以上过滤器的配置就可以防止乱码，本质上web.xml配置方式与实现Filter接口的效用是一致的，filter实现结果如下:

@WebFilter("/*")
public class CharacterFilter implements Filter {
    public void destroy() {
    }
    //采用过滤器实现utf-8编码过滤
    public void doFilter(ServletRequest req, ServletResponse resp,
                         FilterChain chain) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest)req;
        HttpServletResponse response = (HttpServletResponse)resp;
        String method = request.getMethod();
        if(method.equalsIgnoreCase("post")){
            request.setCharacterEncoding("utf-8");
        }
        response.setContentType("text/html;charset=utf-8");
        chain.doFilter(request, response);
    }
    public void init(FilterConfig config) throws ServletException {
    }
}

上述代码执行效果
在这里插入图片描述
另外一种请求参数封装方式，采用@RequestBody注解，xml配置方式大体内容与save14保持一致，需要添加关一些开发资源的配置。
两种方式都可以。

<!--<mvc:resources mapping="/js/**"  location="/js/"/>-->
    <mvc:default-servlet-handler/>

上述注解是让各位大猿在开发时，让静态资源轻松躲过拦截的一种配置，相当于在服务器内部让静态资源有了自有行走的通信证。
注意查看下面图片，注意两种配置的区别:
在这里插入图片描述
请求方式

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <script src="${pageContext.request.contextPath}/js/jquery-3.3.1.js"></script>
    <script>
        var userList = new Array();
        userList.push({relation:"tom是张君老祖",age:3000});
        userList.push({relation:"lucy是张君老祖",age:3000});
        userList.push({relation:"jack是张君老祖",age:3000});
        userList.push({relation:"hack是张君老祖",age:3000});
        userList.push({relation:"鹏爷是张君老祖",age:3000});
        $.ajax({
            type:"POST",
            url:"${pageContext.request.contextPath}/userController/save14",
            data:JSON.stringify(userList),
            contentType:"application/json;charset=utf-8"
        })
    </script>
</head>
<body>
<h4>ajax</h4>
</body>
</html>

测试案例

    @RequestMapping("/save14")
    @ResponseBody
    public void save14(@RequestBody List<User> userList) throws JsonProcessingException {
        System.out.println("Controller save13 is running");
        System.out.println(userList);
    }

当请求参数名与Controller方法接收参数名不一致的情况下，我们可以采用@RequestParam

    @RequestMapping("/save15")
    @ResponseBody
    public void save15(@RequestParam("name") String username) throws JsonProcessingException {
        System.out.println("Controller save15 is running");
        System.out.println(username);
    }

Restful风格

Restful是一种软件架构风格、设计风格，它不是标准，本质上只是一组设计原则和约束条件，他主要用于客户端和服务器交互的软件。

@RequestMapping("/save16/{name}")
    @ResponseBody
    //建立restful分割
    public void save16(@PathVariable(value = "name",required = false) String username) throws JsonProcessingException {
        System.out.println("Controller save16 is running");
        System.out.println(username);
}

访问：

自定义格式转换器

为了防止有些参数请求报错，需要自定义转换器，自定义转换器要实现以下几个要点:

实现Converter接口

//访问方式:http://localhost:8080/springmvc/userController/save16/feitian
public class DateConverter implements Converter<String,Date> {
    public Date convert(String dateStr) {
        Date date = null;
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        try {
             date = simpleDateFormat.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}

在springMVC中声明转换器

......
<!--声明转换器-->
    <bean  id="conversionService"  class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <list>
                <bean class="com.feitian.component.converter.DateConverter"/>
            </list>
        </property>
    </bean>
......

在annotation-driven 中引用转换器

......
<!--声明转换器-->
<mvc:annotation-driven conversion-service="conversionService" />
......

访问

http://localhost:8080/springmvc/userController/save17/2019-10-28

测试方法成功运行
在这里插入图片描述

获得请求头

有些情况下我们需要获取请求头信息：获取方法所如下

    @RequestMapping("/save18")
    @ResponseBody
    //建立restful分割
    public void getContent18(@RequestHeader(value = "User-Agent",required = false)
                               String contentHeader) throws JsonProcessingException {
        System.out.println("Controller save17 is running");
        System.out.println(contentHeader);
    }

    @RequestMapping("/save19")
    @ResponseBody
    //获取jsessionID
    public void getContent19(@CookieValue(value = "JSESSIONID",required = false)
                                     String JSID) throws JsonProcessingException {
        System.out.println("Controller save17 is running");
        System.out.println(JSID);
    }