SpringMVC

SpringMVC

SpringMVC

SpringMVC是Spring内置的MVC框架，他的MVC模式(Model-View-Controller)：解决页面代码和后台代码的分离。

SpringMVC原理

在没有使用SpringMVC之前我们都是使用Servlet在做Web开发。但是使用Servlet开发在接收请求参数，数据共享，页面跳转等操作相对比较复杂。servlet是java进行web开发的标准，既然springMVC是对servlet的封装，那么很显然SpringMVC底层就是Servlet，SpringMVC就是对Servlet进行深层次的封装。

SpringMVC执行流程和原理

Handler：处理器

Handler是继DispatcherServlet前端控制器的后端控制器，在DispatcherServlet的控制下Handler对具

体的用户请求进行处理，由于Handler涉及到具体用户业务请求，所以一般情况下Handler是由我们程序

员来进行开发的。实际上Handler就是我们开发的Controller。

View：视图

一般情况下需要通过页面的标签或页面模板技术展示给客户，需要由程序员根据业务需求开发具体的页

面。就是我们写的HTML,JSP

DispatcherServlet：中央控制器

用户请求到达前端控制器，它就相当于MVC模式中的C，DispatcherServlet是整个流程控制的核心。

由它来调用其他组件处理用户的请求，DispatcherServlet的存在降低了组件之间的耦合性。

类似于门卫传达室，一个请求来的时候先去门卫，一步步来处理问题，就是个servlet。

HandlerMapping：处理器映射器

HandleMapping负责根据用户请求url找到Handler处理器，springmvc提供了不同的映射器实现不同的

映射方式，如配置文件方式，实现接口的方式，注解方式。

实际上，就是Map，放了一堆数据，key是url，value是你对应的处理器，一个请求来了，用

map.get(url)就知道是哪个类的哪个方法来处理这个请求，实际上将这个url对应的拦截器，处理器

都拿到。

HandlerAdapter：处理器适配器

通过HandlerAdapter对处理器进行执行，这里适配器模式的应用，通过扩展适配器可以对更多类型的的

处理器进行执行。

实际上，这货会调用对应的方法，生成最终的ModelAndView。

ViewResolver：视图解析器

ViewResolver负责将处理结果生成View视图，ViewResolver根据逻辑视图名解析成物理视图名即具体的

页面的地址，再生成View视图对象，最后对View进行渲染将处理结果通过页面展示给客户。

实际上就是解析ModelandView，拼接字符串，给你加个前缀，再加个后缀，让你能够找到对应的

视图地址。(很少用)

 

创建SpringMVC项目(配置版)

--用Maven创建项目，pom.xml修改打包方式为war包

<!-- 修改打包方式为war -->
    <packaging>war</packaging>

--添加spring-webmvc依赖

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.22</version>
        </dependency>
    </dependencies>

--添加servlet依赖

因为springmvc底层还是servlet，所以还必须添加serlvet依赖。

<!-- servlet -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
        </dependency>

--添加jsp

<!-- jsp -->
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>javax.servlet.jsp-api</artifactId>
    <version>2.3.3</version>
    <scope>provided</scope>
</dependency>

--web.xml配置欢迎页

<welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
        <welcome-file>login.html</welcome-file>
    </welcome-file-list>

--想用SpringMVC，需要注册dispatcherServlet

<!-- 如果想要使用SpringMVC，就必须注册dispatcherServlet -->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 加载springmvc的配置文件 -->
        <!--
            springmvc的默认配置文件的扫描路径和文件名：
            1、默认的路径：WEB-INF/
            2、默认的文件名： <servlet-name>-servlet.xml
            放在resource下
        -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:app-context.xml</param-value>
        </init-param>
        <!-- 启动web容器就加载springmvc -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

--app-context.xml

<!-- 中央适配器：DispatcherServlet -->
    <!-- 处理映射器 -->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean>
    <!-- 处理器适配器 -->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"></bean>
    <!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 前缀 -->
        <!-- WEB-INF下加密路径，请求转发 -->
        <property name="prefix" value="/WEB-INF/pages/"></property>
        <!-- 后缀 -->
        <property name="suffix" value=".jsp"></property>
    </bean>

--创建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 UsrControllers implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        ModelAndView modelAndView = new ModelAndView();

        // 视图，页面，视图名，视图解析器
        modelAndView.setViewName("success");

        // 设置一个模型，往request作用域中添加数据,获取的话要用jsp
        modelAndView.addObject("username","admin");
        
        return modelAndView;
    }
}

--index.jsp

<h1>Hello SpringMVC!!!</h1>
<a href="user">UserController</a>
<br>
<a href="user/showUser">showUser</a>

<form action="user/login" method="post">
    <p>
        账号：<input type="text" name="username">
    </p>
    <p>
        密码：<input type="password" name="password">
    </p>
    <p>
        <input type="submit" value="提交">
    </p>
</form>

--WEB-INF下创建pages文件夹，创建success.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h1>Success Page!!!</h1>
    welcome:${requestScope.username}
<hr>
    用户名：${requestScope.user.username}
    密码：${requestScope.user.password}
<hr>
    从session中获取的用户名：${sessionScope.username}
</body>
</html>

--注册Controller

    <!-- 注册UserController -->
 <bean id="/user" class="com.jsoft.controller.UserController"></bean>

 

SpringMVC项目(注解版)

--springmvc配置文件开启文件扫描

    <!-- 开启spring注解扫描：Controller，service -->
    <context:component-scan base-package="com.jsoft"></context:component-scan>

    <!-- 开启springmvc的注解扫描 -->
    <mvc:annotation-driven></mvc:annotation-driven>

    <!-- 中央适配器：DispatcherServlet -->
    <!-- 处理映射器 -->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean>
    <!-- 处理器适配器 -->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"></bean>
    <!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 前缀 -->
        <!-- WEB-INF下加密路径，请求转发 -->
        <property name="prefix" value="/WEB-INF/pages/"></property>
        <!-- 后缀 -->
        <property name="suffix" value=".jsp"></property>
    </bean>

    <!-- 注册UserController -->
<!--    <bean id="/user" class="com.jsoft.controller.UserController"></bean>-->

 --Controller

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

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

@Controller
public class UsrControllers {

    // 设置处理那个请求,springmvc的注解
    @RequestMapping("/user")
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        ModelAndView modelAndView = new ModelAndView();

        // 视图，页面，视图名，视图解析器
        modelAndView.setViewName("success");

        // 设置一个模型，往request作用域中添加数据,获取的话要用jsp
        modelAndView.addObject("username","admin");

        return modelAndView;
    }
}

--视图和模型：不应该放在一块。
*   视图和模型都耦合给了ModelAndView对象，必须说我只想跳视图。
*
*   模型和视图分离！！！

@Controller
@RequestMapping("user")
public class UsrControllers {
@RequestMapping(value = "showUser",method = RequestMethod.GET)
    //@RequestMapping(value = "?howUser",method = RequestMethod.GET)
    //@RequestMapping(value = "*howUser",method = RequestMethod.GET)
//    @GetMapping("showUser")
    public String showUser(Model model) {

        // 操作模型，把数据添加到request作用域
        model.addAttribute("username","张三");

        // 操作视图
        return "success";

    }
}

<h1>Hello SpringMVC!!!</h1>
<a href="user">UserController</a>
<br>
<a href="user/showUser">showUser</a>

但上面的Controller都是老版本的，进行更改

@Controller
@RequestMapping("user")
public class UserController {

    /*
    *  后台给出的响应不再是视图，而是json串，给前台的ajax
    * */
    @GetMapping("get")
    @ResponseBody // 当前方法就不走视图解析器，以json串的形式给出响应
    public User getUser() {
        return new User("admin","123456");
    }

    /*
    * @RequestBody：标记传入的数据的类型是json格式
    * */
    @PostMapping("post")
    @ResponseBody
    public User saveUser(@RequestBody User user) {
        System.out.println(user);
        return user;
    }


    /*
     *   使用RequestParam注解来标记参数，前台传输过来的数据的key是username的，
     *       值直接注入到参数中
     *
     *   如果前台传过来的参数的key和方法的形参的参数名如果是匹配的则，可以省略RequestParam注解，
     *       可以直接注入给形参
     *
     *  如果前台传过来的参数的key和User对象里的属性名相同，并且User类有对应的getset方法，则可以直接封装对象
     *
     *  我们可以这么说，在SpringMVC的处理器的方法参数列表中
     *      用什么，就直接写什么就可以。
     *
     *  params = "username" 请求的参数列表中必须有username
     * */
    @RequestMapping(value= "login",method = RequestMethod.POST,
            params = "username=zhangsan")
//    public String login(String username,String password){
    public String login(User user, HttpSession session, Model model) {

        session.setAttribute("username",user.getUsername());

        System.out.println("username:" + user.getUsername() + ",password:" + user.getPassword());

        model.addAttribute("user",user);

        return "success";

    }

    /*
    *   重定向的方式：只能发起get请求
    * */
    @GetMapping("addUser")
    public String addUser(Model model,HttpServletRequest request) {
//        model.addAttribute("username","hhhhhhh");

        request.setAttribute("username","gggggggg");
        // 带参重定向
        return "redirect:/user/login?username=kkkkkkkk&password=9999999";
    }

    @RequestMapping(value = "showUser",method = RequestMethod.GET)
//    @GetMapping("showUser")
    public String showUser(Model model) {

        // 操作模型，把数据添加到request作用域
        model.addAttribute("username","张三");

        // 操作视图
        return "success";

    }

    @RequestMapping("/user")
    public ModelAndView showUser(HttpServletRequest request, HttpServletResponse response) throws Exception {
        ModelAndView modelAndView = new ModelAndView();

        // 视图，页面，视图名，视图解析器
        modelAndView.setViewName("success");

        // 设置一个模型，往request作用域中添加数据
        modelAndView.addObject("username","admin");

        return modelAndView;
    }
}

 --发送JSON串 

    方式一：fastjson，比较麻烦；需要在pom.xml引入fastjson

    app-context.xml 

<!--    <mvc:annotation-driven>-->
<!--        <mvc:message-converters>-->
<!--            <bean id="fastjson" class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">-->
<!--                <property name="supportedMediaTypes">-->
<!--                    <list>-->
<!--                        <value>text/html;charset=UTF-8</value>-->
<!--                        <value>application/json;charset=UTF-8</value>-->
<!--                    </list>-->
<!--                </property>-->
<!--            </bean>-->
<!--        </mvc:message-converters>-->
<!--    </mvc:annotation-driven>-->

    方式二：jackson，需要引入三个依赖

        <!--jackson依赖-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.11.4</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.11.4</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.11.4</version>
        </dependency>

  可以直接转换成JSON

    /*
    *  后台给出的响应不再是视图，而是json串，给前台的ajax
    * */
    @GetMapping("get")
    @ResponseBody // 当前方法就不走视图解析器，以json串的形式给出响应
    public User getUser() {
        return new User("admin","123456");
    }

--配置字符集

<!-- 注册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>

 

IDEA自带的前端调试工具

新建测试，创建http包，创建HTTP Request文件，也可以调试

发送JSON串需要在参数加入@RequestBody

    /*
    * @RequestBody：标记传入的数据的类型是json格式
    * */
    @PostMapping("post")
    @ResponseBody
    public User saveUser(@RequestBody User user) {
        System.out.println(user);
        return user;
    }

 

Spring经典设计模式

• 简单工厂
• 工厂模式
• 适配器模式
• 装饰器模式
• 代理模式
• 观察者模式
• 策略模式
• 模板方法模式

 

自定义异常

--定义工具类，在枚举类中列出自定义的异常

import lombok.Getter;

/*
* 异常信息的枚举类
* */
@Getter
public enum ResultCode {

    SUCCESS(200,"success"),
    UNKNOWN_ERROR(10001,"unknown error"),
    USERNAME_ERROR(10002,"username error or dose not exist"),
    PASSWORD_ERROR(10003,"password error"),
    USERNAME_EXISTS(10004,"username is exists"),
    USERNAME_EMPTY(10005,"username is empty");

    private Integer code;
    private String msg;

    ResultCode(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }
}

 --定义结果的工具类

@AllArgsConstructor
@NoArgsConstructor
@Data
public class ResultUtil {

    private Integer code;
    private String msg;

    public static ResultUtil of(ResultCode resultCode) {
        return new ResultUtil(resultCode.getCode(),resultCode.getMsg());
    }

}

--定义类继承 RuntimeException

@Getter
public class MyException extends RuntimeException {

    private Integer code;
    private String msg;

    public MyException(ResultCode resultCode) {
        this.code = resultCode.getCode();
        this.msg = resultCode.getMsg();
    }
}

--定义全局的异常处理器，控制器

@ControllerAdvice
public class GlobalExceptionHandler {

    /*
    *   当我的程序中出现了MyException异常
    *   就返回一个枚举的信息
    *
    *   约定：程序中如果用户名错误，我就抛MyException
    *
    * */
    @ExceptionHandler(MyException.class)
    @ResponseBody
    public ResultUtil myExceptionHandler(MyException e) {
        System.out.println(e.getMsg() + "来自于全局异常处理类...");
        return ResultUtil.of(ResultCode.USERNAME_ERROR);

    }

    @ExceptionHandler(Exception.class)
    @ResponseBody
    public ResultUtil exceptionHandler() {
        // 记日志
        return ResultUtil.of(ResultCode.UNKNOWN_ERROR);
    }

}

--测试

@Controller
@RequestMapping("user")
public class UserController {

    @RequestMapping("get")
    @ResponseBody
    public User getUser(@RequestBody User user) {
        if(Objects.equals("",user.getUsername())){
            throw new MyException(ResultCode.USERNAME_EMPTY);
        }
        return user;
    }
}

 

日期格式的接收

 Controller

@Controller
@RequestMapping("user")
public class UserController {

    /**
     *
     * 方法的一些说明
     *
     * @param user 封装user对象
     * @param br 绑定JSR303数据校验结果
     * @return 响应给前台的user对象的json串
     *
     *
     */
    @RequestMapping("get")
    @ResponseBody
    public User getUser(@RequestBody @Validated User user, BindingResult br) {

        List<ObjectError> allErrors = br.getAllErrors();
        if(allErrors.size() > 0){
            allErrors.stream().forEach(a -> {
                String code = a.getCode();
                String message = a.getDefaultMessage();
                System.out.println("code->" + code + ",message->" + message);
            });
        }

        return user;
    }
}

Converter

import org.springframework.core.convert.converter.Converter;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class StringToDateConverter implements Converter<String, Date> {

    @Override
    public Date convert(String source) {

        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");

        try {
            return simpleDateFormat.parse(source);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }
}

Entity.User

import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.hibernate.validator.constraints.Length;
import org.springframework.format.annotation.DateTimeFormat;

import javax.validation.constraints.Email;
import javax.validation.constraints.Max;
import java.util.Date;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {

    @Length(min = 2,max = 6,message = "您的用户名长度不合法")
    private String username;
    private String password;

    @Max(200)
    private Integer age;

    @Email
    private String email;

//    @DateTimeFormat(pattern = "yyyy年MM月dd日")
    @JsonFormat(pattern = "yyyy年MM月dd日 HH:mm:ss",timezone = "GMT-8")
    private Date birthday;

}

app-context.xml配置格式转换器

    <!-- 配置格式转换器 -->
    <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean id="stringToDateConverter" class="com.jsoft.converter.StringToDateConverter"></bean>
            </set>
        </property>
    </bean>

 

配置静态资源

把静态资源交给默认的servlet处理

默认的servelt：tomcat

在 app-context.xml配置

    <!-- 放行静态资源 -->
    <!--
        /page/*：localhost:8080/springMVC/page/user/login.html
        /css/**：localhost:8080/springMVC/css/user.css
    -->
<!--    <mvc:resources mapping="/page/**" location="/page/"></mvc:resources>-->
<!--    <mvc:resources mapping="/js/**" location="/static/js/"></mvc:resources>-->

    <!-- 把静态资源交给默认的servlet处理 -->
    <!-- 默认的servlet：tomcat -->
    <mvc:default-servlet-handler />

 

Rest风格

REST风格的资源URL不希望带.html，.do等后缀

在web.xml配置DispatcherServlet

在web.xml配置DispatcherServlet，通过url-pattern的配置，所有URL请求都将被Spring MVC的DispatcherServlet截获

<!-- 配置SpringMVC的Servlet -->
<servlet>
<servlet-name>mvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<!-- 服务器启动就完成该Servlet的加载、初始化创建-->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>mvc</servlet-name>
<!-- 拦截逻辑性请求，不拦截jsp请求-->
<!-- 拦截除了jsp以外的所有请求-->
<url-pattern>/</url-pattern>
</servlet-mapping>

解决方案

采用<mvc:default-servlet-handler />

  app-context.xml配置

<!--静态资源放行-->
<!-- 把静态资源交给默认的servlet处理 -->
<!-- 默认的servlet：tomcat -->
<mvc:default-servlet-handler/>

    <!-- 放行静态资源 -->
    <!--
        /page/*：localhost:8080/springMVC/page/user/login.html
        /css/**：localhost:8080/springMVC/css/user.css
    -->
<!--    <mvc:resources mapping="/page/**" location="/page/"></mvc:resources>-->
<!--    <mvc:resources mapping="/js/**" location="/static/js/"></mvc:resources>-->

请求url	请求方式	操作
/user/1	get	获取id为1的user对象(查询)
/user/1	post	删除id为1的对象(删除)
/user	put	更新user对象(修改)
/user	post	新增一个user对象(新增)

 

SpringMVC对Restful提供了一些支持：

• @RequestMapping，可以指定Method
• @GetMapping，@PostMapping，@PutMapping，@DeleteMapping
• @PathVariable将url请求路径中的值标记为某一个属性名
• Ajax直接支持PUT、DELETE请求。

@GetMapping("/user/{id}")
@DeleteMapping("/user/{id}")
@PostMapping("/user/")
@PutMapping("/user/")

 

发送请求

import com.jsoft.entity.User;
import com.jsoft.exception.MyException;
import com.jsoft.util.ResultCode;
import com.jsoft.util.ResultUtil;
import org.springframework.stereotype.Controller;

import org.springframework.validation.BindingResult;
import org.springframework.validation.ObjectError;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Objects;


@Controller
@ResponseBody
public class UserController {

    @GetMapping("user/login")
    public String login() {
        return "login";
    }

    @GetMapping("user/register")
    public String register() {
        return "register";
    }

    /*
    *   这个方法能够处理的请求就是/user/1
    * */
    @GetMapping("/user/{id}")
    public User getUserById(@PathVariable("id") Integer id) {

        return new User(id,null,null);
    }

    @DeleteMapping("/user/{id}")
    public ResultUtil deleteUserById(@PathVariable("id") Integer id) {
        // 去数据库中删除...
        System.out.println(id);
        return ResultUtil.of(ResultCode.SUCCESS);
    }

    @PostMapping("user")
    public ResultUtil addUser(@RequestBody User user){
        // 去数据库中新增...
        System.out.println(user);
        return ResultUtil.of(ResultCode.SUCCESS);
    }

    @PutMapping("user")
    public ResultUtil updateUserById(@RequestBody User user) {
        // 去数据库中修改...
        System.out.println(user);
        return ResultUtil.of(ResultCode.SUCCESS);
    }

}

 

 

SpringMVC拦截器

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

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

/*
* SpringMVC的拦截器
* */
public class LoginInterceptor implements HandlerInterceptor {

    /*
    *  在方法进入中央处理器之后，对应的处理器方法执行之前进行拦截
    * */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle...");
        // 拦住，true放行
        return false;
    }

    /*
    *   对应的目标方法执行之后，执行的操作
    * */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle...");
    }

}

app-context.xml注册拦截器

<!-- 注册拦截器 -->
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <mvc:exclude-mapping path="/index.html"/>
            <mvc:exclude-mapping path="/static/**"/>
            <mvc:exclude-mapping path="/user/login"/>
            <mvc:exclude-mapping path="/user/register"/>
            <!--
                bean：对应的拦截器的全类名，把拦截器放进容器
                bean必须在最下面
                还需要让静态资源能成功加载
            -->
            <bean id="loginInterceptor" class="com.jsoft.interceptor.LoginInterceptor"></bean>
        </mvc:interceptor>
    </mvc:interceptors>

面试题

servlet的过滤器和springMVC的拦截器异同？

1. 相同点：对请求进行过滤拦截。

2. 不同点：过滤器是servlet技术，拦截器是springmvc技术，如果过滤器想要生效，直接在web.xml中配置的。拦截器想要生效，首先得先进入到SpringMVC的中央控制器DispatcherServlet。

3. 不同点：过滤器比拦截器的层级要高。