SpringMVC 入门

web开发其实万变不离其宗，就是使用servlet的使用

SpringMVC(也就是 Spring Web MVC)就是一个Spring。

Spring是容器，

ioc能够管理对象，使用 <bean>, @Compoent, @Repository, @Service, @Controller

SpringMVC能够创建对象, 放入容器中(Spring容器) SpringMVC容器中放的是控制器对象

SpringMVC中有一个对象Servlet: DispatchServlet (中央调度器)

SpringMVC流程

index.jsp --> DispatchServlet --> Controller

一. 创建SpringMVC项目

1. 创建一个空工程项目
2. 新建Module
3. 选择Maven
4. 勾选 Create from archetype
5. 选择maven-archetype-webapp
6. 确定 groupId 和 artifactId
7. 创建结束

二. 运行SpringMVC项目

1. 加入Spring-webmvc的maven依赖

   其中会间接地把Spring依赖都加入项目中

2. 加入 jsp, servlet依赖

3. 在 web.xml中注册SpringMVC核心对象DispatchServlet

4. 创建一个发送请求的页面, 例如 index.jsp

5. 创建控制类

   1. 在类上加入@Controller注解, 创建对象,并放入到SpringMVC容器中
   2. 在类中的方法上加入 @RequestMapping注解

6. 创建一个作为结果的页面, 例如 result.jsp

7. 创建一个SpringMVC的配置文件

   1. 声明组件扫描器, 指定@Controller注解所在的包名
   2. 声明视图扫描器, 帮助处理视图

2.1 操作过程

在main文件夹子级中创建 Java文件夹和resources文件夹

将Java文件夹 右键 make director as --> sources root

在 pom.xml文件中写入:

<!-- servlet 依赖 -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
</dependency>
<!-- 加入SpringMVC 依赖 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>4.2.4.RELEASE</version>
</dependency>

因为 默认生成的 web.xml文件版本较老, 需要更新一个

打开 项目结构, 选择 module 选择 web, 删除默认的文件, 再追加新的文件 (注: 新加时可能需要先改下web.xml的名字, 生成成功之后再改回来)

在web.xml中编辑配置 servlet:

<servlet>
    <!-- springMVC 创建容器对象时，读取的默认配置是 /WEB-INF/<servlet-name>-servlet.xml -->
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

    <!-- 自定义spring MVC读取的配置文件的位置 -->
    <init-param>
        <!-- springmvc的配置文件的位置属性 -->
        <param-name>contextConfigLocation</param-name>
        <!-- 指定自定义配置的位置 -->
        <!-- classpath --> 指的是 项目中的resources路径 -->
        <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    <!-- 在 tomcat启动之后， 创建Servlet对象
        load-on-startup 表示 tomcat启动之后创建对象的顺序。它的值是一个整数， 数值越小，
                        tomcat创建对象的时间就越早
        -->
    <load-on-startup>1</load-on-startup>
</servlet>

同时配置路由映射:

<servlet-mapping>
    <!-- 指定映射接管的servlet配置名 -->
    <servlet-name>springmvc</servlet-name>
    <!-- 在使用框架的过程中， url-pattern 有两个值可以使用
            1. 使用扩展名方式， 语法 *.xxx, xxxxx是自定义扩展名。 常见的方式 *.do, *.action
            2.  / 斜杠
         -->
    <url-pattern>*.do</url-pattern>
</servlet-mapping>

在 Controller中处理路由映射的内容

@Controller
public class MyController {
    // 使用方法来处理用户的请求
    /**
     * 准备使用 doSome方法处理 some.do请求
     * @RequestMapping  请求映射， 作用是把一个请求地址和一个方法绑定在一起
     *                  一个请求指定一个方法处理
     *                  属性：
     *
     * @return
     */
    // 接受前往 /some.do的路径请求
    @RequestMapping(value = "some.do")
    public ModelAndView doSome() {
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg", "hello");
        ArrayList<String> stars = new ArrayList<>();
        stars.add("wang");
        stars.add("er");
        stars.add("ma");
        stars.add("zi");
        mv.addObject("stars",stars);

        // 指定视图
        mv.setViewName("/show.jsp");

        // 返回视图层
        return mv;
    }
}

配置 SpringMVC自动扫描 Controller处理器 (springmvc.xml)

<!-- 声明组件扫描器 -->
<context:component-scan base-package="io.wang.github.controller" />

2.2 SpringMVC请求流程

1. a链接发起请求
2. 经过tomcat服务器
3. 通过 web.xml 中的 url-pattern 获取相应的 DispatchServlet
4. DispatchServlet(根据springmvc.xml配置获悉相应请求路径对应的Controller方法)
5. DispatchServlet把请求路径转发给对应的Controller方法
6. springmvc执行Controller方法把ModeAndView进行处理, 返回到页面中

简化为:

url --> DispatchServlet --> Controller

2.3 配置视图解析器

为了避免用户直接访问服务器中对应的jsp造成数据渲染的异常

可以将对应的jsp文件放置到 WEB-INF 中, 因为放置在这个文件夹里面的内容是不对用户开放的

在 springmvc.xml 中配置

<!-- 视图解析器 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!-- 前缀 视图文件的路径 (从根路径开始算) -->
    <property name="prefix" value="/WEB-INF/views/" />

    <!-- 后缀 视图文件的扩展名 -->
    <property name="suffix" value=".jsp" />
</bean>

在Controller中使用

@Controller
public class MyController {
    @RequestMapping(value = "some.do")
    // @RequestMapping(value = {"some.do", "other.do"}) 多个请求访问同一方法
    public ModelAndView doSome() {
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg", "hello");
        // 指定视图
        //    mv.setViewName("/WEB-INF/views/show.jsp");
        // 使用视图解析器之后
        mv.setViewName("show");
        return mv;
    }
}

2.4 请求方法/请求参数

设置路径的请求方法

在 Controller 中:

@RequestMapping(value = "/get.do", method = RequestMethod.GET)
public ModelAndView doGet() {
    ModelAndView mv = new ModelAndView();
    mv.addObject("msg", "hello");
    mv.setViewName("show");
    return mv;
}

@RequestMapping(value = "/post.do", method = RequestMethod.POST)
public ModelAndView doPost() {
    ModelAndView mv = new ModelAndView();
    mv.addObject("msg", "hello");
    mv.setViewName("show");
    return mv;
}

获取请求参数

处理器方法包含以下四种方法:

• HttpServletRequest request
• HttpResponse response
• HttpSession session
• 请求中所携带的参数

继续在 Controller 中:

@RequestMapping(value = "/post.do", method = RequestMethod.POST)
public ModelAndView doPost(HttpServletRequest request) {
    ModelAndView mv = new ModelAndView();
    mv.addObject("name", request.getParameter("name"));
    mv.addObject("age", request.getParameter("age"));
    mv.addObject("msg", "hello");
    mv.setViewName("show");
    return mv;
}

注意: 在默认的情况下, post方法传递中文, 在接受时会出现乱码的行为

此时就是需要引入过滤器, 进行统一编码格式

在 web.xml 中进行配置

<!-- 注册声明过滤器, 解决post方法中, 中文乱码的问题 -->
<filter>
    <filter-name>encodingFilter</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>
    <!-- 强制请求对象(HttpServlet)使用encoding编码方式 -->
    <init-param>
        <param-name>forceRequestEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
    <!-- 设置响应对象使用encoding编码方式 -->
    <init-param>
        <param-name>forceResponseEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
    <init-param>
        <param-name>forceEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>

<!-- 配置过滤器的映射路径 -->
<filter-mapping>
    <filter-name>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

对象接受参数方法:

@RequestMapping(value = "/get.do")
public ModelAndView doGet(User user) {
    ModelAndView mv = new ModelAndView();
    mv.addObject("name", user.getName());
    mv.addObject("age", user.getAge());
    mv.addObject("msg", "hello");
    mv.setViewName("show");
    return mv;
}

2.5 请求相应对象

JSON操作需要引入 Jackson依赖

传统方法:

@RequestMapping(value = "/returnAjax.do")
public void returnAjax(HttpServletResponse response, User user) throws IOException {
    System.out.println("===return Ajax ====, name=" + user.getName() + "age" + user.getAge());
    // 处理 Ajax, 使用 json做数据结构
    // service 调用完成, 使用User表示处理结果
    String jsonStr = "";
    if (user != null) {
        ObjectMapper om = new ObjectMapper();
        jsonStr = om.writeValueAsString(user);
        System.out.println("User 类转换成 jsonString=====" + jsonStr);
    }
    // 输出数据响应 Ajax的请求
    response.setContentType("application/json;charset=utf-8");
    PrintWriter writer = response.getWriter();
    // 写入响应内容
    writer.println(jsonStr);
    // 重新刷新数据
    writer.flush();
    // 关闭资源, 释放内存
    writer.close();
}

使用框架的方法

在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="io.wang.github.controller" />

    <!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 前缀 视图文件的路径 (从根路径开始算) -->
        <property name="prefix" value="/WEB-INF/views/" />

        <!-- 后缀 视图文件的扩展名 -->
        <property name="suffix" value=".jsp" />
    </bean>

    <!-- 加入注解驱动 -->
    <mvc:annotation-driven />
</beans>

在 Controller中使用注解:

@RequestMapping(value = "/returnAjaxObject.do")
@ResponseBody
public User returnAjaxObject (User user) {
    return user;
}