ssm-springMVC

官方文档

https://docs.spring.io/spring-framework/docs/current/reference/html/web.html#spring-web

目录

• ssm-springMVC
  • 一、HelloSpringMVC
    • 1.web.xml
    • 2.springmvc-servlet.xml
    • 3.Controller.java
    • 4.hello.jsp
    • 5.执行
  • 二、springMVC执行流程
  • 三、springMVC注解实现
    • 1.配置web.xml
    • 2.配置springmvc-servlet.xml文件
    • 3.注解写Controller
    • 4.test.jsp
  • 四、注解
    • 1.@Controller
    • 2.@RequestMapping
    • 3.@ResponseBody
    • 4.@RestController
  • 五、RestFul风格
  • 六、结果跳转方式
  • 七、数据处理
    • 处理前端提交数据
    • 向前端提交数据
  • 八、页面乱码处理
    • 1.过滤器解决乱码
    • 2.springMVC提供的过滤器
    • 3.tomcat配置问题
    • 4.json传输乱码问题
• 注意

ssm-springMVC

springMVC的执行流程

mvc：model模型（dao，service），view视图（jsp），controller控制器（servlet）

MVC框架要做的事情：

1.将url映射到java类或java类的方法

2.封装用户提交的数据

3.处理请求--调用相关的业务处理--封装响应数据

4.将响应的数据进行渲染.jsp / html 等表示层数据

mvc演化->mvvm(m v vm(双向绑定))

框架优点：

1.轻量级，简单易学

2高效，基于请求响应的MVC框架

3.与Spring兼容性好，无缝结合

4.约定优于配置

5.功能强大:RESTful、数据验证、格式化、本地化、主题等

6.简洁灵活

围绕dispatcherServlet调度servlet来执行，中心控制器dispatcherServlet对所有请求进行分发到不同的处理器

一、HelloSpringMVC

1.web.xml

关于dispatcherServlet的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">
<!--&lt;!&ndash;监听器&ndash;&gt;-->
<!--        <listener>-->
<!--            <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>-->
<!--        </listener>-->

<!--        <context-param>-->
<!--            <param-name>contextConfigLocation</param-name>-->
<!--            <param-value>/WEB-INF/app-context.xml</param-value>-->
<!--        </context-param>-->
    <!--    注册dispatcherServlet-->
        <servlet>
            <servlet-name>springmvc</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--            关联一个springmvc的初始化配置文件-->
            <init-param>
                <param-name>contextConfigLocation</param-name>
                <param-value>classpath:springmvc-servlet.xml</param-value>
            </init-param>
<!--            启动级别1-->
            <load-on-startup>1</load-on-startup>
        </servlet>
<!--    /匹配所有请求：不包括jsp-->
<!--    /*匹配所有请求：包括jsp-->
        <servlet-mapping>
            <servlet-name>springmvc</servlet-name>
            <url-pattern>/</url-pattern>
        </servlet-mapping>
</web-app>

2.springmvc-servlet.xml

配置web.xml加载的DispatcherServlet的初始化配置文件springmvc-servlet.xml---spring配置文件

实现HelloController后，在此配置

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

<!--    bean名字url处理器映射-->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
<!--    简单控制器处理器适配器-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

<!--    视图解析器:dispatcherServlet给它的ModelAndView
        1.获得ModelAndView的数据
        2.获得ModelAndView的视图名（页面名字）
        3.找到对应的视图
        4.将数据渲染到视图
-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>

<!--    Controller-->
    <bean id="/hello" class="com.kuang.controller.HelloController"></bean>
</beans>

3.Controller.java

实现org.springframework.web.servlet.mvc.Controller接口

package com.kuang.controller;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //模型和视图
        ModelAndView modelAndView=new ModelAndView();

        //封装对象，放在ModelAndView中
        modelAndView.addObject("msg","HelloSpringMVC and you");

        //封装要跳转的视图，
        modelAndView.setViewName("hello");//：/WEB-INF/jsp/hello.jsp

        return modelAndView;

    }
}

4.hello.jsp

建立/WEB-INF/jsp/hello.jsp文件

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2021/7/19
  Time: 8:56
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
${msg}
</body>
</html>

5.执行

注意：配置tomcat中的项目lib

二、springMVC执行流程

1. 用户端发送请求
2. DispatcherServlet收到请求
3. DispatcherServlet调用处理器映射HandlerMapping找到请求对应的处理器Controller，并将结果返回到DispatcherServlet
4. DispatcherServlet调用处理器适配器HandlerAdapter去执行对应的Controller
5. Controller调用业务层获得执行结果，得到执行信息（ModelAndView）返回给HandlerAdapter
6. HandlerAdapter将执行信息返回给DispatcherServlet
7. DispatcherServlet调用视图解析器ViewResolver
8. ViewResolver解析完成后返回结果到DispatcherServlet
9. DispatcherServlet响应请求

springmvc-servlet.xml中配置的

HandlerMapping： org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping

HandlerAdapter：org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter

ViewResolver：org.springframework.web.servlet.view.InternalResourceViewResolve

三、springMVC注解实现

1.配置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">
<!--&lt;!&ndash;监听器&ndash;&gt;-->
<!--        <listener>-->
<!--            <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>-->
<!--        </listener>-->

<!--        <context-param>-->
<!--            <param-name>contextConfigLocation</param-name>-->
<!--            <param-value>/WEB-INF/app-context.xml</param-value>-->
<!--        </context-param>-->
    <!--    注册dispatcherServlet-->
        <servlet>
            <servlet-name>springmvc</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--            关联一个springmvc的初始化配置文件-->
            <init-param>
                <param-name>contextConfigLocation</param-name>
                <param-value>classpath:springmvc-servlet.xml</param-value>
            </init-param>
<!--            启动级别1-->
            <load-on-startup>1</load-on-startup>
        </servlet>
<!--    /匹配所有请求：不包括jsp-->
<!--    /*匹配所有请求：包括jsp-->
        <servlet-mapping>
            <servlet-name>springmvc</servlet-name>
            <url-pattern>/</url-pattern>
        </servlet-mapping>
</web-app>

2.配置springmvc-servlet.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">

<!--    扫描包下注解，让注解生效，交由IOC容器统一管理-->
    <context:component-scan base-package="com.kuang.controller"/>
<!--    过滤，使mvc不处理静态资源-->
    <mvc:default-servlet-handler/>
<!--    支持mvc注解驱动
在spring中一般使用@RequestMapping注解完成隐射关系
要使@RequestMapping生效，必须向上下文中注册
DefaultAnnotationHandlerMapping（handler映射器）
AnnotationMethodHandlerAdapter（handler适配器）
两个实例。
这两个实例分别在类级别和方法级别处理
annotation-driven这个注解可以自动完成这两个实例的配置
注：handler等同于controller-->
    <mvc:annotation-driven/>

    <!--    视图解析器:dispatcherServlet给它的ModelAndView-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>

</beans>

3.注解写Controller

package com.kuang.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

//注解实现
@Controller
//指定访问路径
@RequestMapping("/testController")
public class testController {

    //localhost:8080/xxx(项目名称)/testController/test
    @RequestMapping("/test")
    public String test(Model model){
        //封装数据
        model.addAttribute("msg","test and hello");
        //返回的是页面名字--通过拼接查找到
        return "test";
    }

}

4.test.jsp

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2021/7/19
  Time: 10:11
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
${msg}
</body>
</html>

四、注解

1.@Controller

控制器复杂提供访问应用程序的行为通常通过接口定义或注解定义两种方法实现。

控制器负责解析用户的请求并将其转换为一个模型。（controller->model）

在Spring MVC中一个控制器类可以包含多个方法

在Spring MVC中，对于Controller的配置方式有很多种

@component 组件--父注解，下面三个功能一致，均为注册，为了区分使用不同的注解

• @service service层
• @contro1ler contro1ler层
• @Repository dao层

2.@RequestMapping

可以使用在类和方法上，用于映射请求，相当于servlet在web.xml中进行配置

注解：

@RequestMapping(
    "/test",
    method={RequestMethod.POST,RequestMethod.GET},
    params={"username=kolbe","password=123456"}
)

method代表:只接受get方式的请求，如果不是则错误提示。

method可以存多个数值,表示接收多种方式的请求

params代表限定请求数据---请求参数必须为....

3.@ResponseBody

将这个注解设置到Controller的方法上就可以使这个方法不使用视图解析器，会直接返回一个字符串--（配合json数据返回使用）

4.@RestController

这个Controller下的所有方法都只返回字符串，而不使用视图解析器

五、RestFul风格

资源定位及资源操作风格。基于这个风格设计的软件可以更简洁，更有层次感，更易于实现缓存等机制，同时也安全（不暴露提交参数）

资源操作：

• POST 添加
• DETELE 删除
• PUT 修改
• GET 查询

以前的方式：通过传不同参数来实现，方式只有POST和GET

RestFul风格：通过不同的请求方式来区分操作，请求连接一致

实现区别：

以前的风格：

@RequestMapping("/test1")
    public String test1(int a,int b,Model model){
        model.addAttribute("msg",a+b);
        return "test";
    }

请求链接：

在连接上用？a=1&b=2的方式传递

RestFul风格：

@RequestMapping("/test2/{a}/{b}",method={RequestMethod.POST,RequestMethod.GET})
public String test2(@PathVariable int a,@PathVariable int b, Model model){
    model.addAttribute("msg",a+b);
    return "test";
}

@PathVariable路径值注解：获取请求上/{}中的值，可以得到ab数据

通过RequestMapping注解的指定请求方式method，可以做到RestFul风格的不同请求方式执行不同操作（给不同的方法设置一样路径但请求方式不同的注解）

每一个操作都有对应的Mapping：(简化RequestMapping)

@GetMapping("/test2/{a}/{b}")
@PostMapping("/test2/{a}/{b}")
@DeleteMaping("/test2/{a}/{b}")
@PutMapping("/test2/{a}/{b}")

@PatchMapping()
//Patch方式是对put方式的一种补充;
//put方式是可以更新.但是更新的是整体.patch是对局部更新;

六、结果跳转方式

ServletAPI：

1. 通过HttpServletResponse进行输出
2. 通过HttpServletResponse实现重定向
3. 通过HttpServletResponse实现转发

//HttpservletRequest req，HttpservletResponse rsp是请求中带有的一部分
@RequestMapping(" / result/t1")
public void test1(HttpservletRequest req，HttpservletResponse rsp) throws
//直接输出
rsp.getWriter( ).println("Hello, spring BY servlet API");
//重定向-直接跳转
rsp.sendRedirect("/index.jsp");
//转发-携带数据-url不变
rea.setAttribute("msg","/result/t3");
req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,rsp);

SpringMVC的跳转：

1.注释掉视图解析器---return 要使用全部路径/WEB-INF/jsp/hello.jsp

2.实现:相当于使用原生态的ServletAPI

    @RequestMapping("/test1")
    public String test1(){
        //转发
        return "/test.jsp";
        return "forward:/test.jsp";
        //重定向
        return "redirect:/test.jsp"
    }

七、数据处理

处理前端提交数据

1. 当提交数据名与Controller接收数据名一致时:可以直接获取到

2. 当提交数据名与Controller接收数据名不一致时：在参数前使用@RequestParam

@RequestParam("提交的名字") String name

3. 提交一个对象时：提交数据为对象中数据对应的属性User(id,name,password)

   内部执行流程：

   1. 接收前端用户传递的参数
   2. 假设名字直接在方法上，可以直接使用
   3. 假设传递一个对象User，匹配User属性名：一致接收到一个对象，否则匹配不到

向前端提交数据

1. 通过ModelAndView--最开始用的方式。ModelAndView可以存入ViewName，作用于视图跳转
2. 通过Model--注解实现时使用的方式--大部分情况使用Model
3. 通过ModelMap--使用方法与Model一致，但是Model是简化版，只有几个方法存储数据，而ModelMap继承LinkedMap，功能多
4. 向前端提交json数据：方法上设置注解@ResponseBody，使方法不通过视图解析器，直接返回一个json字符串--返回到请求的页面

八、页面乱码处理

1.过滤器解决乱码

package com.kuang.filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;

@WebFilter(urlPatterns="/*")
public class EncodingFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse,             FilterChain filterChain) throws IOException, ServletException {
        servletRequest.setCharacterEncoding("utf-8");
        servletResponse.setCharacterEncoding("utf-8");
        filterChain.doFilter(servletRequest,servletResponse);
    }

    @Override
    public void destroy() {

    }
}

2.springMVC提供的过滤器

在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>
    <init-param>
        <param-name>forceEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

3.tomcat配置问题

tomcat 的conf下的server文件内的

<Connector port="8080" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443"
URIEncoding="UTF-8"/>

4.json传输乱码问题

在RequestMapping中配置produces = "application/json;charset=utf- 8"解决乱码问题

produces ：设置返回值的具体类型

可以通过spring.xml的配置解决全部json乱码问题：

 <!--解决json 乱码配置-->
    <mvc:annotation-driven>
        <mvc:message-converters register-defaults="true">
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
               <constructor-arg value="UTF-8"/>
            </bean>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                <property name="objectMapper">
                    <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                        <property name="failOnEmptyBeans" value="false"/>
                    </bean>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

注意

1.404的一种情况：

项目中存在包，但是tomcat中没lib文件夹和各种包，导致404

解决办法：在structure中设置