SpringMVC

丘桔

已于 2022-12-11 10:37:21 修改

阅读量317

点赞数 1

于 2022-12-03 15:36:42 首次发布

本文链接：https://blog.csdn.net/qq_55137734/article/details/121873702

版权

SpringMVC官方文档：Web on Servlet Stack

MVC架构：

什么是MVC？

Model View Controller 模型视图解析器，是一种架构模式。

Model模型：dao、service

职责：获取表单数据、调用业务逻辑、转向指定的页面

View视图：jsp

职责：业务逻辑、保存数据的状态

Controller控制器：servlet

职责：显示页面

回顾Servlet：

先创建一个父工程，并导入依赖：

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.9</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp.jstl</groupId>
            <artifactId>jstl-api</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>

然后创建一个子模块，并把它变成一个web项目：

然后编写一个前端页面：

    <form action="/hello" method="post">
        <input type="text" name="method">
        <input type="submit">
    </form>

然后编写一个Servlet，用来处理用户请求：

package com.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class HelloServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //1.获取前端参数
        String method = req.getParameter("method");
        if(method.equals("add")){
            req.getSession().setAttribute("msg","执行了add方法");
        }else if(method.equals("delete")){
            req.getSession().setAttribute("msg","执行了delete方法");
        }
        //2.调用业务层
        //3.视图转发或者重定向
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req,resp);
    }
}

然后编写一个给用户返回消息的页面：

<body>
    ${msg}
</body>

MVC框架要做哪些事情？

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

2、封装用户提交的数据

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

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

Spring的web框架围绕DispatcherServlet设计。DispatcherServlet的作用是将请求分发到不同的处理器。

SpringMVC原理

当发起请求时被前置的控制器拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器，控制器使用模型与视图渲染视图结果，将结果返回给中心控制器，再将结果返回给请求者

SpringMVC原理图完整版：

其中，实线表示SpringMVC框架提供的技术，不需要开发者实现，虚线表示需要开发者实现。

执行流程：

深入学习SpringMVC：

1、在web.xml中注册DispatcherServlet，并且关联一个springmvc的配置文件

    <!--配置DispatcherServlet：这个是SpringMVC的核心：请求分发器，或者叫前端控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--DispatcherServlet要绑定Spring（SpringMVC也属于Spring）的配置文件-->
        <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>
    <!--
        在SpringMVC中， / 和 /* 是有区别的
        /  只匹配所有的请求，不会去匹配jsp页面
        /* 会匹配所有的请求，包括jsp页面
    -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

2、在关联的springmvc的配置文件中，配置前缀后缀和Handler

<?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 class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    <!--处理器适配器-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
    <!--BeanNameUrlHandlerMapping要做的事-->
    <bean id="/hello" class="com.controller.HelloController"/>
</beans>

3、编写Controller

package com.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 {
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView modelAndView = new ModelAndView();
        //业务代码
        String result = "Hello SpringMVC";
        //把数据放在ModelAndView中
        modelAndView.addObject("msg",result);
        //视图跳转
        modelAndView.setViewName("hello2");

        return modelAndView;
    }
}

4、将ModelAndView中存的数据，返回给用户

<body>
    这是hello2<br>
    ${msg}
</body>

SpringMVC的执行顺序：

使用注解开发SpringMVC：

1、创建一个Maven子模块

2、Maven可能存在资源过滤问题，我们将配置完善

3、在pom.xml中引入Spring框架核心库、Spring MVC、servlet、JSTL等依赖。因为在父工程里面已经引入过了，所以我们不需要再引入

4、配置web.xml

    <!--配置DispatcherServlet：这个是SpringMVC的核心：请求分发器，或者叫前端控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--DispatcherServlet要绑定Spring（SpringMVC也属于Spring）的配置文件-->
        <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>
    <!--
        在SpringMVC中， / 和 /* 是有区别的
        /  只匹配所有的请求，不会去匹配jsp页面
        /* 会匹配所有的请求，包括jsp页面
    -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

5、配置springmvc-servlet.xml

<?xml version="1.0" encoding="gbk"?>    <!--配置文件里面有中文注释，encoding要改成gbk-->
<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 https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!--自动扫描包，让指定包下的注解生效，由IOC容易统一管理-->
    <context:component-scan base-package="com.controller"/>

    <!--让SpringMVC不处理静态资源-->
    <mvc:default-servlet-handler/>

    <!--
        支持mvc注解驱动
            在Spring中采用@RequestMapping注解来完成映射关系
            要想使@RequestMapping注解生效
            必须向上下文中注册DefaultAnnotationHandlerMapping
            和一个AnnotationMethodHandlerAdapter实例
            这两个实例分别在类级别和方法级别处理
            而annotation-driven配置帮助我们自动完成上述两个实例的注入
    -->
    <mvc:annotation-driven/>

    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

6、创建Controller

package com.controller;

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

@Controller
public class HelloController {
    @RequestMapping("/hello")
    public String hello(Model model){
        //封装数据
        model.addAttribute("msg","hello,SpringMVC Annotation");
        return "hello2";
    }
}

Controller配置：

方法一：实现Controller接口。

缺点：一个控制器只有一个方法。如果要多个方法，就需要定义多个Controller。定义的方式比较麻烦。

package com.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 ControllerTest1 implements Controller {
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView modelAndView = new ModelAndView();

        modelAndView.addObject("msg","ControllerTest1");
        modelAndView.setViewName("test1111");

        return modelAndView;
    }
}

<?xml version="1.0" encoding="gbk"?>    <!--配置文件里面有中文注释，encoding要改成gbk-->
<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 https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
    <bean id="/test1" class="com.controller.ControllerTest1"/>
</beans>

方法二：使用注解@Controller

package com.controller;

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

@Controller     //代表这个类，会被Spring接管
//被 @Controller 注解的类中的所有方法，如果返回值是String，并且有具体页面可以跳转，那么就会被视图解析器解析
public class ControllerTest2{
    @RequestMapping("test2")
    public String test2(Model model){
        model.addAttribute("msg","ControllerTest2");
        return "test2222";
    }

    @RequestMapping("test22")
    public String test22(Model model){
        model.addAttribute("msg","test22");
        return "test2222";
    }
}

<?xml version="1.0" encoding="gbk"?>    <!--配置文件里面有中文注释，encoding要改成gbk-->
<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 https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!--自动扫描包，让指定包下的注解生效，由IOC容易统一管理-->
    <context:component-scan base-package="com.controller"/>

    <!--让SpringMVC不处理静态资源-->
    <mvc:default-servlet-handler/>

    <!--
        支持mvc注解驱动
            在Spring中采用@RequestMapping注解来完成映射关系
            要想使@RequestMapping注解生效
            必须向上下文中注册DefaultAnnotationHandlerMapping
            和一个AnnotationMethodHandlerAdapter实例
            这两个实例分别在类级别和方法级别处理
            而annotation-driven配置帮助我们自动完成上述两个实例的注入
    -->
    <mvc:annotation-driven/>
    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

可以发现，我们的2个请求（test2和test22），都可以指向同一个视图（test2222），但是页面显示的结果不一样，从这里可以看出，视图是可以被复用的。

RequestMapping说明：

RequestMapping可以注解到方法上，也可以注解到类上

①注解到方法上：

package com.controller;

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

@Controller
public class ControllerTest3 {
    @RequestMapping("/test3")
    public String test3(Model model){
        model.addAttribute("msg","333333333333");
        return "test3333";
    }
}

访问路径：http://localhost:8080/项目名/test3

②注解到类上：

package com.controller;

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

@Controller
@RequestMapping("/t3")
public class ControllerTest3 {
    @RequestMapping("/test3")
    public String test3(Model model){
        model.addAttribute("msg","333333333333");
        return "test3333";
    }
}

访问路径：http://localhost:8080/项目名/t3/test3

RestFul风格：

参考我之前写的文章：RestFul风格_丘桔的博客-CSDN博客

通过SpringMVC来实现转发和重定向：

1、不用视图解析器

@Controller
public class ModelTest1 {
    @RequestMapping("/m1/t1")
    public String test1(){
        //转发的方式一：
        return "/index.jsp";
    }

    @RequestMapping("/m1/t2")
    public String test2(){
        //转发的方式二：
        return "forward:/index.jsp";
    }

    @RequestMapping("/m1/t3")
    public String test3(){
        //重定向：
        return "redirect:/index.jsp";
    }
}

2、用视图解析器

@Controller
public class ModelTest2 {
    @RequestMapping("/m2/t1")
    public String test1(){
        //转发
        return "../../index";
    }

    @RequestMapping("/m2/t2")
    public String test2(){
        //重定向
        return "redirect:/index.jsp";
    }
}

处理提交数据：

1.提交的域名称和处理方法的参数名一致

提交数据：http://localhost:8080/hello3?name=zhangsan

    @RequestMapping("/hello3")
    public String hello3(String name, Model model){
        //1.接收前端参数
        System.out.println("接收到前端的参数为：" + name);
        //2.将返回的结果传递给前端
        model.addAttribute("msg",name);
        //视图跳转
        return "test";
    }

2.提交的域名称和处理方法的参数名不一样

提交数据：http://localhost:8080/hello4?username=zhangsan

    @RequestMapping("/hello4")
    public String hello4(@RequestParam("username") String name){
        System.out.println(name);
        return "test";
    }

3.提交的是一个对象

要求提交的表单域和对象的属性名一致，参数使用对象即可

①实体类

public class User{
    private int id;
    private String name;
    private int age;

    //构造
    //get/set
    //toString()
}

②提交数据：

http://localhost:8080/user?name=zhangsan&id=1&age=15

处理方法：

    @RequestMapping("/user")
    public String user(User user){
        System.out.println(user);
        return "test";
    }

输出结果：

User(id=1, name=zhangsan, age=15)

当前端传递的参数名和对象不一致的时候，为null

提交数据：

http://localhost:8080/user?username=zhangsan&id=1&age=15

输出结果：

User(id=1, name=null, age=15)

数据显示到前端：

第一种方式：通过ModelAndView

public class ControllerTest1 implements Controller {
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView modelAndView = new ModelAndView();

        modelAndView.addObject("msg","ControllerTest1");
        modelAndView.setViewName("test1111");

        return modelAndView;
    }
}

第二种方式：通过ModelMap

    @RequestMapping("/hello7")
    public String hello(@RequestParam("username") String name, ModelMap modelMap){
        //封装要显示到视图中的数据
        //相当于req.setAttribute("name",name);
        modelMap.addAttribute("name",name);
        System.out.println(name);
        return "test";
    }

第三种方式：通过Model

    @RequestMapping("/hello6")
    public String hello(@RequestParam("username") String name, Model model){
        //封装要显示到视图中的数据
        //相当于req.setAttribute("name",name)
        model.addAttribute("name",name);
        System.out.println(name);
        return "test";
    }

区别：

Model：精简版，只适合存储数据

ModelMap：继承了LinkedMap，除了实现了自身的一些方法，还继承了LinkedMap的全部方法和特性

ModelAndView：可以存储数据，设置返回的逻辑视图，控制展示层的跳转

乱码问题

前端页面：

    <form action="/encoding1" method="get">
        <input type="text" name="name">
        <input type="submit">
    </form>

Controller：

@Controller
public class EncodingController {
    //过滤器解决乱码
    @GetMapping("/encoding1")
    public String encoding1(@RequestParam("name") String name, Model model) {
        model.addAttribute("msg",name);
        return "test";
    }
}

我自己写的过滤器：


public class EncodingFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        request.setCharacterEncoding("utf-8");
        response.setCharacterEncoding("utf-8");
        chain.doFilter(request,response);
    }

    @Override
    public void destroy() {

    }
}

在web.xml中注册过滤器：

    <filter>
        <filter-name>encoding</filter-name>
        <filter-class>Filter.EncodingFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>encoding</filter-name>
        <url-pattern>/*</url-pattern>    //注意：这里要用 /* 才能过滤.jsp页面 不能用 / 
    </filter-mapping>

SpringMVC给我们提供了一个过滤器，直接在web.xml中配置即可（修改了xml文件，需要重启tomcat）

    <filter>
        <filter-name>encoding</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>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

处理方法：

1.修改tomcat配置文件：设置编码

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

2.自定义过滤器


import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;

/**
 * 解决get和post请求 全部乱码的过滤器
 */
public class GenericEncodingFilter implements Filter {

    @Override
    public void destroy() {
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        //处理response的字符编码
        HttpServletResponse myResponse=(HttpServletResponse) response;
        myResponse.setContentType("text/html;charset=UTF-8");

        // 转型为与协议相关对象
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        // 对request包装增强
        HttpServletRequest myrequest = new MyRequest(httpServletRequest);
        chain.doFilter(myrequest, response);
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }

}

//自定义request对象，HttpServletRequest的包装类
class MyRequest extends HttpServletRequestWrapper {

    private HttpServletRequest request;
    //是否编码的标记
    private boolean hasEncode;

    //定义一个可以传入HttpServletRequest对象的构造函数，以便对其进行装饰
    public MyRequest(HttpServletRequest request) {
        super(request);// super必须写
        this.request = request;
    }

    // 对需要增强方法 进行覆盖
    @Override
    public Map getParameterMap() {
        // 先获得请求方式
        String method = request.getMethod();
        if (method.equalsIgnoreCase("post")) {
            // post请求
            try {
                // 处理post乱码
                request.setCharacterEncoding("utf-8");
                return request.getParameterMap();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        } else if (method.equalsIgnoreCase("get")) {
            // get请求
            Map<String, String[]> parameterMap = request.getParameterMap();
            if (!hasEncode) { // 确保get手动编码逻辑只运行一次
                for (String parameterName : parameterMap.keySet()) {
                    String[] values = parameterMap.get(parameterName);
                    if (values != null) {
                        for (int i = 0; i < values.length; i++) {
                            try {
                                // 处理get乱码
                                values[i] = new String(values[i]
                                        .getBytes("ISO-8859-1"), "utf-8");
                            } catch (UnsupportedEncodingException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
                hasEncode = true;
            }
            return parameterMap;
        }
        return super.getParameterMap();
    }

    //取一个值
    @Override
    public String getParameter(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        if (values == null) {
            return null;
        }
        return values[0]; // 取回参数的第一个值
    }

    //取所有值
    @Override
    public String[] getParameterValues(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        return values;
    }
}

拦截器

过滤器和拦截器的区别：拦截器是AOP思想的具体应用

过滤器：

①servlet规范中的一部分，在任何java web工程都可以使用

②在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截

拦截器：

①拦截器是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能使用

②拦截器只会拦截访问的控制器方法，如果访问的是jsp/html/css/image/js是不会进行拦截的

自定义拦截器（核心：实现 HandlerInterceptor 接口）：

1、新建一个Model，添加web支持

2、配置web.xml和springmvc-servlet.xml

3、编写一个拦截器

public class MyInterceptor implements HandlerInterceptor {
    //return true;  放行，执行下一个拦截器
    //return false; 不执行下一个拦截器
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("============执行前==================");
        return true;
    }

    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("============执行后===================");
    }

    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("============清理======================");
    }
}

4、在springmvc-servlet.xml中配置拦截器

    <!--拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
            <!--包括这个请求下面的所有请求-->
            <mvc:mapping path="/**"/>
            <bean class="com.controller.MyInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

5、编写一个Controller接收请求

@RestController
public class TestController {
    @GetMapping("/t1")
    public String test(){
        System.out.println("TestController===>test()执行了");
        return "ok";
    }
}

6、启动tomcat测试

丘桔

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
SpringMVC

SpringMVC官方文档：Web on Servlet StackMVC架构：什么是MVC？Model View Controller 模型视图解析器，是一种架构模式。Model模型：dao、service职责：获取表单数据、调用业务逻辑、转向指定的页面View视图：jsp职责：业务逻辑、保存数据的状态Controller控制器：servlet职责：显示页面回顾Servlet：先创建一个父工程，并导入依赖：然后创建一个子模块，并把它变成一个we...
复制链接

扫一扫