万字SpringMVC学习笔记总结(含SSM整合开发步骤)

Posted 2021-06-23 ascto

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了万字SpringMVC学习笔记总结(含SSM整合开发步骤)相关的知识，希望对你有一定的参考价值。

SpringMVC学习笔记总结

SpringMVC概述

springMVC简介

SpringMVC：是基于spring的一个框架，实际上就是spring的一个模块，专门做web开发的。

web开发底层就是一个servlet，框架是在servlet的基础之上，加入一些功能，让做web开发更加方便。

SpringMVC能够创建对象，放入到容器（SpringMVC容器），springMVC容器中放的是控制器对象。我们要做的就是使用 @Controller创建控制器对象，把对象放入到springMVC容器中，把创建的对象作为控制器使用，这个控制器对象可以接受用户输入的请求，显示处理结果，就当作一个servlet使用（但不是servlet，是一个普通的类对象）。

WEB开发底层是servlet，springMVC中有一个对象是servlet：DispatherServlet（中央调度器）,之后DispatherServlet把请求转发给我们的Controller对象，最后是Controller对象处理请求。

在这里插入图片描述

springMVC优点

1.基于MVC架构
基于MVC架构，功能分工明确。解耦合。
2.容易理解，上手快;使用简单。
可以开发一个注解的SpringMVC项目，SpringMVC也是轻量级的，jar 很小。不依赖的特定的接口和类。
3.作为Spring框架一部分，能够使用Spring的IoC和Aop。方便整合
Strtus,MyBatis,Hiberate,JPA等其他框架。
4.SpringMVC强化注解的使用，在控制器，Service, Dao 都可以使用注解。方便灵活。
使用@Controller创建处理器对象, @Service创建业务对象，@ Autowired或者@Resource在控制器类中注入Service, Service 类中注入Dao。

SpringMVC注解式开发

需求：
用户在页面发起一个请求，这个请求交给springMVC控制器对象，并显示请求的处理结果

实现步骤
1.新建maven工程
2.加入依赖
    springMVC依赖，间接的把spring的依赖都加入到项目中
    jsp依赖，servlet依赖
3.重点：在web.xml文件中去注册springMVC框架的核心对象DispatcherServlet(中央调度器、前段控制器【from controller】)
4.创建一个发起请求的页面：index.jsp
5.创建控制器类
    在类的上面加入@Controller注解，创建对象，并放入到springMVC容器中
    在类中的方法上面加入@RequestMapping注解
6.创建一个作为结果的jsp,显示请求的处理结果
7.创建springMVC的配置文件（和spring的配置器一样）
    声明组建扫描器，制定@Contorller注解所在包名
    声明视图解析器，帮助处理视图

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框架的核心对象DispatcherServlet
    需要在tomcat服务器启动后，创建DispatcherServlet对象的实例。
    为什么要创建DispatcherServlet对象的实例呢?
    因为DispatcherServlet在它的创建过程中，会同时创建springMVC容器对象，
    读取springMVC的配置文件，把这个配置文件中的对象都创建好，当用户发起请求时就可以直接使用对象了。
    -->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--在tomcat启动，创建servlet对象
       load-on-startup:表示tomcat启动后创建对象的顺序，它的值是一个整数，数值越小（>=0），tomcat创建的时间越早
        -->
        <!--自定义springMVC读取的配置文件的位置-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <!--指定自定义文件的配置-->
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <!--使用框架的时候，url-pattern可以使用两种值
    1.使用扩展名方式，语法；*.xxx
    -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <!--可以使用两种值，-->
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
</web-app>

例子

MyController类

package controller;

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

/*
*创建处理器对象
* 对象放在springMVC容器中
*
*
* 能处理请求的都是控制器（处理器）：MyController能处理请求，叫做后端控制器（back Controller）
* */
@Controller
public class MyController {

    /*处理用户提交的请求。springMVC中使用多种方法来处理请求
    * 方法是自定义的，可以有多种返回值，多种参数，方法名称自定义*/
    //准备使用dosome方法处理some.do请求，
    /*@RequestMapping：请求映射，作用是把一个请求地址和一个方法绑定在一起。一个请求处理一个方法
    * 属性：value：是一个string。表示请求的url的地址 （value的值必须是唯一）
    *使用RequestMapping修饰的方法叫做处理器方法或者控制器方法，使用@RequestMapping修饰的方法可以
    * 处理请求的，类似doGet、doPost
    * */

    @RequestMapping(value = "/some.do")
    public ModelAndView doSome(){
        /*ModelAndView（处理结果）
        *Model 数据，请求处理完成后，要显示给用户的数据   view：视图，比如jsp等
        * */
        //添加数据，框架在请求的最后把数据放入到request作用域
        //request.setAttribute("msg","欢迎使用springMVC做web开发")
        ModelAndView mv=new ModelAndView();
        mv.addObject("msg","欢迎使用springMVC做web开发");
        mv.addObject("fun","执行的是doSome方法");
        //指定视图.指定视图的完整路径
        //框架对视图执行的是forward操作，request.getRequestDispatcher("/show.jsp".forward(..))
        mv.setViewName("/show.jsp");
        return mv;

    }
}

j
转发后页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h3>show.jsp</h3><br/>
<h3>msg:${msg}</h3>
<h3>fun:${fun}</h3>
</body>
</html>

springmvc请求的处理流程

发起some.do
tomcat(web.xml–url–pattern)知道 *.do的请求给DispatcherServlet()
DispatcherServlet(根据springmvc.xml配置知道some.do----doSome()方法)
DispatcherServlet把some.do转发到doSome()方法
框架执行doSome()把得到ModelAndView进行处理，转发到show.jsp

在这里插入图片描述

防止用户直接输入地址，开发一般将显示界面设置为用户不可以见，即放到WEB-INF中。并且需要将 mv.setViewName("/show.jsp");改为 mv.setViewName("/WEB-INF/view/show.jsp");

视图解析器

前面说的添加name方法不好，当需要添加多个时，重复工作太多。这个时候我们可以用视图解析器，让框架帮我们拼接字符串地址

<!--视图解析器，帮助开发人员设置视图文件的路径-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!--前缀：视图文件路径-->
    <property name="prefix" value="/WEB-INF/view/"/>
    <!--后缀:视图文件的扩展名-->
    <property name="suffix" value=".jsp"/>
</bean>

//        mv.setViewName("/WEB-INF/view/show.jsp");
//框架会使用视图解析器的前缀+逻辑名称+后缀 组成完整路径，这里就是字符串连接操作
        mv.setViewName("show");
        return mv;

制定模块名称和对提交方式的定义

package controller;

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

/*
* @RequestMapping
* value:所有请求地址的公共部分，叫做模版名称
* 位置：放在类的上面
* */
@Controller
@RequestMapping("/test")
public class MyController {

    /*
    * 请求映射
    * 属性：method，表示请求的方法。它的值为RequestMethod类枚举值
    *               例如表示get请求方式，RequestMethod.GET
    *                       post         RequestMethod.POST
    * */

    @RequestMapping(value = "/some.do",method = RequestMethod.GET)
    public ModelAndView doSome(){

        ModelAndView mv=new ModelAndView();
        mv.addObject("msg","欢迎使用springMVC做web开发");
        mv.addObject("fun","执行的是doSome方法");

        mv.setViewName("show");
        return mv;

    }
}

处理器方法的参数

处理器方法可以包含以下四类参数，这些参数会在系统调用时由系统自动赋值，即程序员可在方法内直接使用。

接收请求的参数，使用的处理器方法的形参
1.HttpServletRequest
2.HttpServletResponse
3.HttpSession
4.用户提交的数据
接收用户提交的数据
1.逐个接收
2.对象接收

package controller;

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


@Controller
@RequestMapping("/test")
public class MyController {

    /*逐个接收请求参数：
    * 要求：处理器方法的形参名和请求参数名必须一致
    * */
    @RequestMapping(value = "/some.do")
    public ModelAndView doSome(String name,Integer age){

        ModelAndView mv=new ModelAndView();
        mv.addObject("myname",name);
        mv.addObject("myage",age);

        mv.setViewName("show");
        return mv;

    }
}

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <p>提交参数给Controller</p>
    <p>第一个springMVC项目</p>
    <form action="test/some.do" method="get">
        姓名：<input type="text" name="name">
        年龄：<input type="text" name="age">
        <input type="submit" value="提交">
    </form>
</body>
</html>

注意：在提交请求时，get请求方式中文没有乱码。

使用post请求方式中文有乱码。

需要使用过滤器处理乱码问题，过滤器可以自定义，也可以使用框架提供的过滤器CharacterEncodingFilter

在web.xml中声明

<!--注册声明过滤器，解决乱码问题-->
<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>
    <!--强制请求对象(HttpServletRequest)使用encoding编码的值-->
    <init-param>
        <param-name>forceRequestEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
    <!--强制应答对象(HttpServletResponse)使用encoding编码的值-->
    <init-param>
        <param-name>forceResponseEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <!--表示强制所有的请求先通过过滤器处理-->
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

解决参数名和处理器方法的形参名不一样

加一个 @RequestParam:解决请求中参数名形参名不一样的问题

属性：1.value 请求中的参数名称 2.required 是一个boolean，默认是true ，表示请求中必须包含此参数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qoI8t3tQ-1622858239837)(C:\\Users\\刘畅\\Pictures\\springMVC\\RequestParam.png)]

假如有多个参数，上述方法其实不方便。下面介绍一种新的方式：对象接受参数

/*
* 处理器方法形参是Java对象，这个对象的属性名和请求中参数名一样
* 框架会创建形参的Java对象，给属性赋值。请求中的参数是name，框架会调用setName();
* */
@RequestMapping(value = "/receiveObject.do")
public ModelAndView doSome2(Student student){

    ModelAndView mv=new ModelAndView();
    mv.addObject("myname",student.getName());
    mv.addObject("myage",student.getAge());

    mv.setViewName("show");
    return mv;

}

```jsp
<p>提交参数给Controller</p>
<p>第一个springMVC项目</p>
<form action="test/receiveObject.do" method="get">
    姓名：<input type="text" name="name">
    年龄：<input type="text" name="age">
    <input type="submit" value="提交">
</form>

返回值setViewName

使用@Controller注解的处理器的处理器方法，其返回值常用的有四种类型

ModelAndView
String
无返回值void
返回自定义类型对象

ModelAndView

若处理器方法处理完后，需要跳转到其它资源，且又要在跳转的资源间传递数据，此时处理器方法返回ModelAndView比较好。当然，若要返回ModelAndView，则处理器方法中需要定义ModelAndView对象。在使用时，若该处理器方法只是进行跳转而不传递数据，或只是传递数据而并不向任何资源跳转(如对页面的Ajax异步响应)，此时若返回ModelAndView,则将总是有一部分多余:要么Model多余，要么View多余。即此时返回ModelAndView将不合适。

返回String

处理器方法返回的字符串可以指定逻辑视图名，通过视图解析器解析可以将其转换为物理视图地址。

/*
* 处理器方法返回string--表示逻辑视图名称，需要配置视图解析器
* */
@RequestMapping(value = "/return.do")
public String doReturnView(String name,Integer age){
    System.out.println("321231321231");
    //show:逻辑视图名称，项目中配置了视图解析器
    return "show";
}

返回空void

void不可以表示数据也不可以表示视图。在处理ajax时，可以使用void返回值。通过httpServletResponse输出数据，相应ajax请求。

返回Object

处理器也可以返回object对象，这个object可以是Integer，string，自定义对象，Map，List等。但返回的对象不是作为逻辑视图出现的，而是作为直接在页面显示的数据出现的。返回对象，需要使用@ResponseBody注解，将转换后的JSON数据放入到相应体中。

可以使用对象表示的数据，响应ajax请求。现在做ajax，主要使用json格式，实现步骤：

加入处理json的工具库的依赖，springMVC默认使用jackson
.在springMVC配置文件之间加入 <mvc:annotation-driven>注解驱动
在处理器方法的上面加入@ResponseBody注解

springMVC处理器方法返回Object，可以转为json输出到浏览器，响应ajax的内部原理
<mvc:annotation-driven> 注解驱动实现的功能是：完成Java对象到json,xml,text,二进制等数据格式的转换
HttpMessageConventer接口：消息转换器功能：定义了Java对象转为json等的方法。

@ResponseBody注解：放在处理器方法的上面，通过HttpServletResponse输出数据，响应ajax请求的。

加依赖-设置某种配置-加注解

/*
* 处理器方法返回一个Student。通过框架转为json，响应ajax请求
* @ResponseBody
* 作用：把处理器方法返回对象转为json后，通过HttpServletResponse输出给浏览器
* */
@RequestMapping(value = "/ajaxJson.do")
@ResponseBody
public Student doStudentJsonAjax(String name,Integer age){
    //调用service,获取请求结果的数据，student对象表示结果数据
    Student student=new Student();
    student.setAge(14);
    student.setName("lc");
    return student;//会被转换为json
}

返回一个List

返回String，表示数据不是视图

如何区分string表示的是数据还是视图：看有没有@ResponseBody这个注解

如果有@ResponseBody，返回的是数据，反则返回的是视图。

tomcat本身能处理静态资源的访问，像HTML，图片，js文件都是静态资源

tomcat的web.xml文件有一个servlet名称为default。在服务器启动时创建的，这个default servlet的作用：

1.处理静态资源 2.能处理未映射到其他servlet的请求

<url-pattern>/</url-pattern>表示静态资源和未映射的请求都用这个default处理

当你的项目中使用了 / ，他会替代tomcat中的default。导致所有的静态资源都给DispatcherServlet处理，默认情况下，DispatcherServlet没有处理静态资源的能力，没有控制器对象能够处理静态资源的访问。所以，静态资源都是404。

/的好处是不用写.do了，是什么地址直接写什么地址就行了。

怎么能访问到静态资源?

<!--第一种处理静态资源的方式：
	需要在springMVC配置文件中加入：<mvc:default-servlet-handler>
	原理是：加入这个标签后，框架会创建一个控制器对象DefaultServletHttpRequestHandler
	这个对象可以把接受的请求转发给tomcat的default这个servlet。
	-->
	<mvc:default-servlet-handler/>
<!--第二种静态资源处理方式：
    使用<mvc:resources>后，框架会创建一个ResourceHttpRequestHandler这个处理器对象，让
    这个对象处理静态资源访问，不依赖tomcat的default。
    mapping：访问静态资源的url地址，使用通配符 **
    location：指定静态资源在项目中的目录位置

    images/**:表示  images/p1.png images/p2.png 等
static     
-->
    <mvc:resources mapping="/static/**" location="/static/"/>

关于路径问题

在这里插入图片描述

另一种解决方案就是在Javaweb那块提到的：加入一个base标签，是HTML语言中的标签。表示当前页面中访问地址的基地址。你的页面中所有没有 ‘/’ 开头的地址，都以base标签中的地址为参考地址，使用base中的地址+ user/some.do组成访问地址。

SSM整合开发

SSM编程，即SpringMVC+Spring+Mybatis整合，是当前最为流行的JavaEE开发技术架构。其实SSM整合的实质，仅仅就是mybatis整合入spring，因为springMVC本来就是spring的一部分，不需要专门的整合。

SSM整合的实现方式可以分为两种：基于XML配置方式，基于注解方式。

整合开发思路

ssm整合开发步骤
springMVC：界面（视图）层：负责接受请求，显示处理结果的
spring：业务层：管理service，dao，工具类对象的
mybatis：持久层，访问数据库的

用户发起请求—springMVC接收—spring中的service对象—mybatis处理数据

SSM整合中有容器。
1.springMVC容器：管理controller控制器对象
2.spring容器：管理service，dao，工具类对象
我们要做的是把使用的对象交给合适的容器创建，管理。
即把controller还有web开发的相关对象交给springMVC容器，这些web用的对象写在springMVC配置文件中
service、dao对象定义在spring的配置文件中，让spring管理这些对象。

springMVC容器和spring容器是有关系的，已经确定好了，springMVC容器是spring容器的子容器，类似继承

实现步骤：
1.新建maven
2.加入依赖
springMVC spring mybatis Jackson mysql驱动 druid连接池 jsp servlet
3.写web.xml
1.注册DispatcherServlet(目的：创建springmvc容器对象，才可以创建controller类对象，创建的是servlet,才可以接收用户请求)
2.注册spring的监听器：ContextLoaderListener(创建spring容器，才能创建service,dao等对象)
3.注册字符集过滤器，解决post请求乱码问题
4.创建包，controller包，service，dao包，实体类包
5.写springmvc，spring,mytatis配制文件
1.springMVC配置文件
2.spring配置文件
3.mybatis主配置文件
4.数据库的属性配制文件
6.写代码。dao接口和mapper文件、service和对应实现类、controller、实体类
7.写jsp页面

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>cqutLc</groupId>
  <artifactId>05-ssm</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>
    
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>13</maven.compiler.source>
    <maven.compiler.target>13</maven.compiler.target>
  </properties>
    
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <!--servlet依赖-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
    <!--jsp依赖-->
    <dependency><以上是关于万字SpringMVC学习笔记总结(含SSM整合开发步骤)的主要内容，如果未能解决你的问题，请参考以下文章 
 springMVC学习笔记SSM整合
 SpringMVC-狂神（5.整合SSM框架）学习笔记
 SpringMVC-整合SSM框架（狂神学习笔记）2021-10-03
 学习笔记——SSM整合（思路步骤）
 SSM框架整合时ajax请求返回406
 Spring MVC 框架学习---- SSM 框架整合