学习SpringMVC

Posted 月下赶路人

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了学习SpringMVC相关的知识，希望对你有一定的参考价值。

文章目录

SpringMVC

​ 首先我们了解一下经典的MVC模式，MVC全称Model View Controller，M指业务模型和数据模型，V指用户界面，C指控制器。使用MVC的目的是将M和V的实现代码分离，从而使同一个程序可以使用不同的表现形式。Spring MVC属于SpringFrameWork的后续产品。

​ SpringMVC是Spring框架的一个模块，SpringMVC和Spring无需通过中间整合层进行统一整合，已经融合在Spring Web Flow里面。SpringMVC是一个基于MVC的web框架，方便前后端进行数据的传输。SpringMVC拥有控制器，接收外部请求，解析参数传给服务层。

​ MyBatis解决了java代码和sql语句之间的耦合，代替了数据持久层；Spring解决了业务层和其它各层之间的耦合，优化了service层；SpringMVC解决了java代码和servlet之间的耦合，代替了servlet，SpringMVC本质还是Servlet，实现了对Servlet解耦。

SpringMVC运行流程

	我们在使用Servlet来完成web项目时，我们通过Servlet来处理用户页面和数据库之间的数据交互，那时候我们所有的Servlet层代码都需要我们自己去写入，并且会有大量的“重复”代码，严重降低了我们开发的效率，使我们不能专注于业务，SpringMVC就可以很好的为我们解决这一问题。

  1. 用户向服务器发送请求，请求被Spring前端控制器DispatcherServlet捕获；

  2. 前端控制器DispatcherServlet接收到请求后，调用映射处理器HandlerMapping。处理器HandlerMapping根据请求的url找到处理该请求的处理器Handler（即Controller），将处理器Handler返回给前端控制器DispatcherServlet。

  3. DispatcherServlet根据获得的Handler，选择一个合适的HandlerAdapter（处理器适配器）。在填充Handler的入参过程中，根据配置，Spring会做出一些额外的工作：

    （1）HttpMessageConveter：将请求消息（如Json、xml等数据）转换成一个对象，将对象转换为指定的响应消息。

    （2）数据转换：对请求消息进行数据转换。如String转换为Integer、Double等。

    （3）数据格式化：对请求消息进行数据格式化。如将字符串转换为格式化数字或格式化日期等等。

    （4）数据验证：验证数据的有效性（长度、格式等），验证结果存储到BindingResult或Error中。

  4. Handler控制器执行完毕后，会向DispatcherServlet返回一个ModelAndView对象。

  5. 根据返回的ModelAndView，选择一个适合的ViewResolver视图解析器（必须是已经注册到Spring中的视图解析器）返回给DispacherServlet；

  6. ViewResolver结合Model和View来渲染视图；

  7. 将渲染后的结果响应给客户端。

SpringMVC环境搭建

进行web开发需要提前配置好Tomcat

  1. 倒入SpringMVC的相关jar
<!--SpringMVC依赖的jar包-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>

<!--加servlet-->
<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.0</version>
    <scope>provided</scope>
</dependency>

如果使用jsp的el表达式，还需要导入jstl的jar包

<!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>
  1. 配置DispatcherServlet

​ DispatcherServlet是从HttpServlet中继承而来。所以它是一个标准的Servlet，因此我们需要在web.xml文件中进行配置，使它在启动时加载Spring配置文件。

​ 在web.xml文件中配置：

	<!--配置spring核心请求分发的的DisPatcherServlet-->
    <servlet>
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <!--把Spring的配置文件交给contextConfogLocation-->
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring.xml</param-value>
        </init-param>
        <!--服务器启动时就初始化DispatcherServlet和启动 spring-->
        <load-on-startup>0</load-on-startup>
    </servlet>
    <!--
        请求映射
        所有的请求都会进入DispatcherServlet(分发器)
    -->
    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
  1. 开启SpringMVC注解
<!--开启spring注解扫描-->
<context:component-scan base-package="com.cwd.ssm"></context:component-scan>

<!--开启SpringMVC注解功能-->
<mvc:annotation-driven></mvc:annotation-driven>

  1. 配置视图解析器

    在Spring.xml文件中配置视图解析器

<!--配置视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"></property>
    <!--控制器返回的所有视图界面的prefix（前缀）都要为value-->
    <property name="prefix" value="/WEB-INF/pages/"></property>
    <!--控制器返回的所有视图界面的suffix（后缀）都要为value-->
    <property name="suffix" value=".jsp"></property>
</bean>
  1. 控制器类的搭建

​ 我们使用@Controller注解标签标记SpringMVC的Controller对象，即控制器类。同时，我们也要使用RequestMapping注解来标记请求地址映射，可用在类或方法上。

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;


@Controller//扫描到这个类后交给IOC管理,用于创建对象,默认是单例的,多线程情况下线程不安全
@RequestMapping(path = "/user")//指定一个映射的地址,属性为value或path都一样,可以指定多个,
public class UserController 

    @RequestMapping(path = "/toLogin")//指定请求方式
    public ModelAndView toLogin() 
        System.out.println("toLogin");
        ModelAndView mv = new ModelAndView("login");;
        return mv;

这时当我们要访问toLogin（）方法是的路径就是/user/toLogin

SpringMVC的使用

请求转发

​ SpringMVC默认响应时使用请求转发方式，返回值可以是ModelAndView，控制器处理方法的返回值如果为ModelAndView，则其即包含视图信息，也包含模型数据信息。如果返回String，可以将数据封装到一个Model对象中，直接返回字符串格式的视图名即可。

​ 返回值为ModelAndView时，相应数据设置：

​ （1）添加模型数据：addObject（String attributeName，Object attributeValue）

​ （2）设置视图：void setViewName（String viewName）

//返回ModelAndView 
@GetMapping(path = "/toAddUser")
 public ModelAndView toAddUser(HttpSession session) 
     TUser user = (TUser) session.getAttribute("user");
     Integer communityId = user.getId();
     ModelAndView mv = new ModelAndView("userManage/addUser");
     List<TDept> depts = deptService.toDeptList(communityId);
     mv.addObject("depts", depts);
     return mv;
 

//返回String
@GetMapping(path = "/toUpdate")
public String toUpdateUser(HttpServletRequest request, String id) 
    User user = userService.toUpdateUser(id);
    request.setAttribute("user", user);
    List<Role> roles = userService.findRoles();
    request.setAttribute("roles", roles);
    return "updateUser";
视图解析

​ 我们在controller里面经常这样return一个ModelAndView，DisPatcherServlet靠视图解析器把viewName解析为/jsp/viewname.jsp 常用的视图解析器：InternalResourceViewResolver，其实InternalResourceViewResolver的工作很简单：在视图逻辑名前加上prefix（前缀），后面加上suffix（后缀）；前端控制器最终转发到/jsp/viewname.jsp。
​ 配置视图解析器

<!--视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"></property>
    <property name="prefix" value="/jsp/"></property>
    <property name="suffix" value=".jsp"></property>
</bean>
接收请求

@Controller

​ Spring配置中指定了自动扫描的basepackage后，Spring会扫描这些包以及子包中的使用了@Controller标识的类，然后将类加入到Spring IOC容器中，注入依赖。需要注意的是这个bean在Spring IOC容器中是单例的，每次请求到来的时候，使用的都是同一个bean对象。

@RequestMapping

​ 这个标签的作用就是与请求匹配，如果匹配上了，所修饰的方法才会被执行。这里需要注意两个属性，一是value/path，一是method。value是path的别名，都指请求的路径，类型是一个String[]，也就是说它可以匹配多个请求路径。method指的是请求的方法，如GET、POST。

​ 只有当前请求与@RequestMapping上指定的属性都匹配的时候，才会执行它标注的方法。假定应用的上下文路径为"http://localhost:9090/"，那么@RequestMapping（path = “/user”）请求的路径就是"http://localhost:9090/user"，请求方式没有限制，既可以是GET，也可以是POST。

​ @RequestMapping（path = “/user”，method = RequestMethod.GET）请求的路径就是"http://localhost:9090/user"，请求方式只能是GET。它等价于GETMapping（path = “/user”）。同理@RequestMapping（path = “/user”，method = RequestMethod.POST）也等价于POSTMapping（path = “/user”）。

​ 获取请求数据
​ 我们编写处理器方法的目的，就是为了处理客户端提交的数据，而客户端的提交时按照HTTP协议报文格式来提交的，下面我们看一下常见的HTTP POST提交的报文来理解报文的各个部分与处理器方法参数的对应关系：

​ （1）请求方法：对应到@ReuqestMapping中的method。

​ （2）请求URI：前部分是项目根路径，后面部分对应@RequestMapping中的value/path。

​ （3）请求头：比如获取User-Agent中的值则使用@RequestHeader（“User-Agent”）。

​ （4）请求参数：比如获取name参数的值，使用@RequestParam（“name”）来获取。

@Controller 
@RequestMapping("/students")
public class StudentController  					
	@RequestMapping(value="/create",method=RequestMethod.POST) 
	public String create( @RequestParam("name") String name, 
						  @RequestParam("age") Integer age, 
						  @RequestHeader("User-Agent") String userAgent) 
		return null;

​ 按照上面代码的方式就可以获取到参数值，但是如果请求参数的名称与处理器中参数名相同时，那我们可以选择省略@RequestParam绑定，如：

@Controller 
@RequestMapping("/students")
public class StudentController  					
	@RequestMapping(value="/create",method=RequestMethod.POST) 
	public String create( String name, Integer age, 
						  @RequestHeader("User-Agent") String userAgent) 
		return null;

​ 参数列表中还可以直接内置HttpServletRequest，HttpSession，HttpServletResponse等对象。

重定向

​ 控制器方法返回字符串类型的值会被当成逻辑视图名处理，如果返回的字符串中带redirect：前缀时，SpringMVC会对它们进行特殊处理：将redirect：当成指示符，其余字符串作为URL处理。如return “redirect:/page/student/update.jsp”；

过滤静态资源文件

<!--放行过滤静态资源文件请求-->
<mvc:default-servlet-handler/>

​ 当DispatcherServlet的url配置为/时，我们需要在Spring.xml文件中加入此配置，可以访问静态资源。例如.jpg、.js、.css带有后缀名的文件。如果不加此配置，我们的网页就不能引入静态文件资源，会导致网页元素缺失。配置了之后就会在SpringMVC上下文中定义一个org.springframework.web.servlet.resource.DefaultServletHttpRequestHander，它能够对进入DispacherServlet中的URL进行筛查。如果是静态资源请求，就将请求转由Web应用服务器默认的Servlet处理，如果不是静态资源请求，才会由DispacherServlet继续处理。

中文乱码处理

​ 我们在提交请求的时候，如果输入的是中文就会产生乱码。解决的方法是添加一个过滤器，为request对象设置编码集。SpringMVC中为我们提供了这个过滤器，只需要在web.xml中配置好即可：

<!--springMVC编码过滤器-->
<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>
</filter>
<filter-mapping>
    <filter-name>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

Ajax返回json

​ @responseBody注解的作用是将controller的方法返回的对象通过适当的转换器转换为指定的格式后，写入到response对象的body去，通常用来向异步请求返回JSON数据。需要注意的是，在使用此注解之后不会再走视图处理器，而是直接向数据写入到输入流中，它的效果等同于通过response对象输出指定格式的数据。

添加jackson的jar包

<!--添加json相关jar包 jackson 将java对象转为json格式-->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.1</version>
</dependency>

 @ResponseBody
 @RequestMapping(path = "/checkAccount")
 public Integer checkAccount(String account) 
     User user = userService.checkAccount(account);
     if (user != null) 
     	return 1;
      else 
     	return 0;
     
 
 //也可以直接返回对象或对象集合,jackson会自动转换为JSON格式

文件上传

  1. 首先我们要导入文件上传下载所需的jar文件
<!--上传/下载文件时必须依赖apache提供的jar包-->
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.1</version>
</dependency>
  1. 配置文件解析器, 在springMVC.xml文件中
<!--
    文件解析器
    maxUploadSize:编码最大的上传的数量
-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <property name="defaultEncoding" value="utf-8"></property>
    <property name="maxUploadSize" value="10485760"></property>
</bean>
  1. 设置文件上传的表单属性

（1）method=“post”

（2）enctype=“multipart/form-data” 以二进制形式提交文件数据时，在控制器中不能正常接收，spring框架可以结合apache的文件上传组件，对二进制的数据进行封装，我们就可以在控制器中接收到想要的数据。

（3）accept=".jpg,.png" 限制选择文件时的后缀。

<form action="upLoad" method="post" enctype="multipart/form-data" target="_top">
    <table>
    	<tr>
            <td>描述&nbsp;&nbsp;&nbsp;&nbsp;</td>
            <td>
                <input type="text" name="desc" value="">
            </td>
        </tr>
        <tr>
            <td>头像&nbsp;&nbsp;&nbsp;&nbsp;</td>
            <td>
                <input type="file" name="fileName" accept=".jpg,.png" value="">
            </td>
        </tr>
        <tr align="center">
            <td colspan="2">
                <input type="submit" value="上传">
            </td>
        </tr>
    </table>
</form>
  1. 设置控制器类标签
/*
    上传文件(图像)
    CommonsMultipartFile接收客户端传输的二进制文件,由SpringMVC和apache的文件上传组件解析后的流
*/
@PostMapping(path = "/upLoad")
public String upLoad(@RequestParam("fileName") CommonsMultipartFile file,
String desc,
HttpSession session) 
    try 
        User user = (User) session.getAttribute("user");
        file.getName();//前端设置的文件name 如fileName
        //获取文件原始名 如libai.jpg
        String OriginalFilename = file.getOriginalFilename();
        //获取文件类型
        String FileType = file.getContentType();
        //获取输入流对象
        InputStream FileStream = file.getInputStream();
     catch (Exception e) 
        e.printStackTrace();
        return null;

拦截器

​ SpringMVC定义了拦截器接口HandlerInterceptor，该接口定义了三个方法，这三个方法的调用时在SpringMVC框架内部完成的，调用这三个方法的时候，其参数值也是从框架内部传递进来的。拦截器主要是针对要进入Controller的请求。

  1. boolean preHandle

​ 预处理方法，实现处理器方法的预处理，就是在处理器方法执行之前这个方法会被执行，相当于拦截了处理器方法，框架会传递请求和响应对象给该方法，第三个参数被拦截的处理器方法。如果preHandle方法返回true表示继续流程，返回flase表示流程中断，不会继续调用其它的拦截器或处理器方法，此时需要通过response来响应。

  1. void postHandle

​ 后处理方法，实现处理器方法的后处理，就是在处理器方法调用完成，但在渲染视图之前，该方法被调用，此时我们可以通过modelAndView（模型和视图对象）对模型数据进行处理或对视图进行处理。

  1. afterCompletion

​ 整个请求处理完毕，在视图渲染完毕时该方法被执行。

public class TestInterceptor implements HandlerInterceptor 
    /*
        当请求到达控制器前被执行 
    */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception 
        System.out.println("之前执行");
        return false;
    

    /*
        控制器方法执行之后执行 
    */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception 
        System.out.println("控制器方法执行之后执行");
    

    /*
        整个请求结束后执行 
    */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception 
        System.out.println("请求结束后执行");

在Spring.xml中注册拦截器

<!--配置拦截器-->
<mvc:interceptors>
    <mvc:interceptor>
        <!--进入拦截器的方法-->
        <mvc:mapping path="/**"/>
        <!--不包含  放行的地址-->
        <mvc:exclude-mapping path="/user/toLogin"/>
        mybatis学习 -每天一记(驼峰命名匹配)


 Id  class 变量 的赋值规范  大驼峰和小驼峰  代码的格式和注释的类型


 SpringMVC上传文件的 4 种方式，你都会么？


 React.js学习笔记之事件系统


 农民工看完都会了！java简历包装医疗项目


 IOS学习随笔