创建一个SpringMVC项目

用maven创建好模块后，改成Web框架支持

1. 导入依赖

  1.     <dependencies>
  2.         <dependency>
  3.             <groupId>org.springframework</groupId>
  4.             <artifactId>spring-webmvc</artifactId>
  5.             <version>5.2.0.RELEASE</version>
  6.         </dependency>
  8.         <dependency>
  9.             <groupId>junit</groupId>
  10.             <artifactId>junit</artifactId>
  11.             <version>4.12</version>
  12.             <scope>test</scope>
  13.         </dependency>
  15.         <dependency>
  16.             <groupId>org.aspectj</groupId>
  17.             <artifactId>aspectjweaver</artifactId>
  18.             <version>1.9.1</version>
  19.         </dependency>
  20.         <dependency>
  21.             <groupId>javax.servlet</groupId>
  22.             <artifactId>javax.servlet-api</artifactId>
  23.             <version>3.1.0</version>
  24.         </dependency>
  25.     </dependencies>

2. 项目目录

image.png

3. 配置web.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
  5.          version="4.0">
  7.     <!--配置DispatchServlet：这个是SpringMVC的核心，请求分发器，前端控制器-->
  8.     <servlet>
  9.         <servlet-name>springmvc</servlet-name>
  10.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  11.         <!--DispatcherServlet要绑定Spring的配置文件-->
  12.         <init-param>
  13.             <param-name>contextConfigLocation</param-name>
  14.             <param-value>classpath:springmvc-servlet.xml</param-value>
  15.         </init-param>
  16.         <!--启动级别：1.服务器一启动它就自己启动-->
  17.         <load-on-startup>1</load-on-startup>
  18.     </servlet>
  20.     <!--
  21.     所有的请求都会去走上面的servlet
  22.     在SpringMVC中 /和/*的区别
  23.         /:只会匹配所有的请求，不会去匹配jsp页面
  24.         /*:匹配所有的请求，包括jsp
  25.         本来访问的是hello请求，springmvc会主动追加前缀和后缀，比如变成index/hello.jsp,
  26.         如果设置了/*,在 访问请求hello.jsp，然后又要被springmvc追加一个前后缀，hello.jsp.jsp
  27.     -->
  28.     <servlet-mapping>
  29.         <servlet-name>springmvc</servlet-name>
  30.         <url-pattern>/</url-pattern>
  31.     </servlet-mapping>
  32. </web-app>

4. 配置Spring配置文件springmvc-servlet.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:aop="http://www.springframework.org/schema/aop"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.         https://www.springframework.org/schema/beans/spring-beans.xsd
  7.         http://www.springframework.org/schema/aop
  8.         https://www.springframework.org/schema/aop/spring-aop.xsd">
  10.     <!--处理器映射器-->
  11.     <bean class ="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
  12.     <!--处理器适配器-->
  13.     <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
  14.     <!--视图解析器-->
  15.     <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
  16.         <!--加上前后缀，就只用访问名字就行了，会主动拼接上前后缀的-->
  17.         <!--前缀-->
  18.         <property name="prefix" value="/WEB-INF/jsp/"/>
  19.         <!--后缀-->
  20.         <property name="suffix" value=".jsp"/>
  21.     </bean>
  23.     <!--
  24.     下面的就是自己配置的映射路径了
  25.     当访问/hello时，就去找HelloController控制器
  26.     -->
  27.     <bean id="/hello" class="com.lyd.controller.HelloController"/>
  29. </beans>

5. 创建控制器Controller

  1. package com.lyd.controller;
  4. import org.springframework.web.servlet.ModelAndView;
  5. import org.springframework.web.servlet.mvc.Controller;
  7. import javax.servlet.http.HttpServletRequest;
  8. import javax.servlet.http.HttpServletResponse;
  11. //需要实现Controller接口，实现了接口，它就是控制器了
  12. public class HelloController implements Controller {
  13.     @Override
  14.     public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
  15.         ModelAndView mv =new ModelAndView();
  16.         //业务代码
  17.         String result ="HelloSpringMVC";
  18.         mv.addObject("msg",result);
  19.         //视图跳转
  20.         mv.setViewName("test");
  21.         return mv;
  22.     }
  23. }

6. 启动tomcat运行项目

看这里
Tomcat
在浏览器上，就能访问到结果了。jsp里面我只写了一个显示msg值
image.png

7. 可能发生404错误

有可能访问/hello出现404，有种可能是没有生成对应的lib，自己手动去添加
打开项目结构
image.png
右键lib目录，最后全选加进去
image.png

使用注解开发SpringMVC

和上面创建步骤差不多，不同的就是spring配置文件

目录结构

image.png

升级springmvc-servlet.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xmlns:mvc="http://www.springframework.org/schema/mvc"
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  7.         https://www.springframework.org/schema/beans/spring-beans.xsd
  8.         http://www.springframework.org/schema/context
  9.         https://www.springframework.org/schema/context/spring-context.xsd
  10.         http://www.springframework.org/schema/mvc
  11.         https://www.springframework.org/schema/mvc/spring-mvc.xsd">
  13.     <!--自动扫描包，让指定包下的注解生效，由IOC容器统一管理-->
  14.     <context:component-scan base-package="com.lyd.controller"/>
  15.     <!--让SpringMVC不处理静态资源 .css .js .html .mp3 .mp4等-->
  16.     <mvc:default-servlet-handler/>
  17.     <!--
  18.     支持mvc注解驱动
  19.     在spring中一般采用@RequestMapping注解来完成映射关系
  20.     要想使@RequestMapping注解生效
  21.     必须向上下文中注册DefaultAnnotationHandlerMapping
  22.     和一个AnnotationMethodHandlerAdapter实例
  23.     这两个实例分别在类级别和方法级别处理
  24.     而annotation-driven配置帮助我们自动完成上述两个实例的注入
  25.     -->
  26.     <mvc:annotation-driven/>
  28.     <!--视图解析器-->
  29.     <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
  30.         <!--加上前后缀，就只用访问名字就行了，会主动拼接上前后缀的-->
  31.         <!--前缀-->
  32.         <property name="prefix" value="/WEB-INF/jsp/"/>
  33.         <!--后缀-->
  34.         <property name="suffix" value=".jsp"/>
  35.     </bean>
  38. </beans>

升级Controller注解写法

  1. package com.lyd.controller;
  3. import org.springframework.stereotype.Controller;
  4. import org.springframework.ui.Model;
  5. import org.springframework.web.bind.annotation.RequestMapping;
  7. //用注解就是把他变成了一个控制器了，这个是之前Spring文章里面讲到的衍生组件
  8. //被这个注解的类中的所有方法，如果返回值是String，并且有具体的页面可以跳转，那么就会被视图解析器解析
  9. @Controller
  10. //@RequestMapping可以写在类上面，也可以写在方法上
  11. //写在类上表示通过这个路径就能映射到这个控制器,就不用向之前那样在spring配置文件里面一直加bean映射
  12. @RequestMapping("hello")
  13. public class HelloController {
  15.     //方法上的RequestMapping直接通过子路径返回到对应的视图
  16.     //这里的访问路径是   localhost:8080/hello/h1
  17.     //不写类上面的RequestMapping,这里的访问路径是localhost:8080/h1
  18.     @RequestMapping("/h1")
  19.     public String hello(Model model){
  20.         //封装数据
  21.         model.addAttribute("msg","这是用注解实现的SpringMVC");
  23.         //这个return的结果会被视图解析器处理
  24.         return "hello";
  25.     }
  26.     //路径 /hello/index
  27.     @RequestMapping("index")
  28.     public String index(Model model){
  29.         model.addAttribute("msg","这个是index.jsp页面");
  30.         return "index";
  31.     }
  32. }

运行tomcat，在浏览器输入地址就能看到了
image.pngimage.png

传参

普通传参

QueryString和Form Data方式都可以

默认传参

写一个控制器，test.jsp页面就显示这个msg参数

  1. @Controller
  2. public class RestFulController {
  4.     @RequestMapping("/add/test1")
  5.     public String test1(int a,int b , Model model){
  6.         int res=a+b;
  7.         model.addAttribute("msg","结果为"+res);
  8.         return "test";
  9.     }
  10. }

test1()方法的参数a，b就是请求要传的参数，前端参数名字不能错，要和java代码里面的参数一样。
image.png

@RequestParam

在参数前指定@RequestParam，取个名字，前段就用这个取得名字进行传参，前端传值最好都要加上这个，约定好习惯

  1. @Controller
  2. public class RestFulController {
  4.     @GetMapping("/add/test1")
  5.     public String test1(@RequestParam("a") int a, @RequestParam("a") int b , Model model){
  6.         int res=a+b;
  7.         model.addAttribute("msg","结果为"+res);
  8.         return "test";
  9.     }
  10. }

传参是一个对象

前端的参数名要和对象的属性名一致，如果不一致，要用@RequestParam

  1. package com.lyd.pojo;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  7. @Data
  8. @AllArgsConstructor
  9. @NoArgsConstructor
  10. public class User {
  11.     private int id;
  12.     private String name;
  13.     private int age;
  14. }
  1. @Controller
  2. public class RestFulController {
  4.     @GetMapping("/add/test1")
  5.     public String test1(User user){
  6.         System.out.println(user);
  7.         return "test";
  8.     }
  9. }

image.png
image.png

RESTful风格传参

  1. @Controller
  2. public class RestFulController {
  4.     //用PathVariable注解放在参数前面，作为路径变量
  5.     //这样就可以通过URL路径传参了，要在RequestMapping里面的路径上用{参数名}，用/隔开参数与路径
  6.     @RequestMapping("/add/test1/{a}/{b}")
  7.     public String test1(@PathVariable int a, @PathVariable int b , Model model){
  8.         int res=a+b;
  9.         model.addAttribute("msg","结果为"+res);
  10.         return "test";
  11.     }
  12. }

这时候访问之前的地址就找不到了
image.png
用RESTful风格访问
image.png

请求方法Get，Post……

  1. @Controller
  2. public class RestFulController {
  3.     //RequestMapping注解有多个参数，method参数可以指定求情方法
  4.     @RequestMapping(name="/add/test1/{a}/{b}",method = RequestMethod.POST)
  5.     public String test1(@PathVariable int a, @PathVariable int b , Model model){
  6.         int res=a+b;
  7.         model.addAttribute("msg","结果为"+res);
  8.         return "test";
  9.     }
  10. }

简便方式

  1. @Controller
  2. public class RestFulController {
  4.     //@RequestMapping(name="/add/test1/{a}/{b}",method = RequestMethod.POST)
  5.     //可以用下面这种拓展注解进行不同方法的请求
  6.     @GetMapping("/add/test1/{a}/{b}")
  7.     //@PostMapping("/add/test1/{a}/{b}")
  8.     //@DeleteMapping("/add/test1/{a}/{b}")
  9.     //每个请求方式都有一个对应的Mapping
  10.     public String test1(@PathVariable int a, @PathVariable int b , Model model){
  11.         int res=a+b;
  12.         model.addAttribute("msg","结果为"+res);
  13.         return "test";
  14.     }
  15. }

返回参数给前端

如上代码，在方法形参加上一个参数，用这个参数就能携带东西到前端了，有如下三种类型可以选择

  • Model：精简版本，只有几个方法适合用于存储数据
  • ModelMap：继承了LinkedMap，除了实现自身的一些方法，同样的继承了LinkedMap的方法和特性
  • ModelAndView：可以在存储数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转

    Json传参

    接收json

    RequestBody注解常用来处理content-type不是默认的application/x-www-form-urlcoded编码的内容。
    RequestBody的作用是将前端传来的json格式的数据转为自己定义好的javabean对象，需要注意的是传入数据的属性名称要和后端javabean中定义的一致。大小写都要一致
    1.   @RequestMapping("/addbook")
    2.   //加上@RequestBody注解表示，前端传过来的json值映射成这个对象，json值得键要和对象的属性名一致，大小写都要一致
    3.   public int add(@RequestBody BookList booklist){
    4.       return bookserv.addBook(booklist);
    5.   }

    Jackson

    导依赖 ```xml com.fasterxml.jackson.core jackson-databind 2.13.1 
  1. ```java
  2. package com.lyd.controller;
  5. import com.fasterxml.jackson.core.JsonProcessingException;
  6. import com.fasterxml.jackson.databind.ObjectMapper;
  7. import com.lyd.pojo.User;
  8. import org.springframework.stereotype.Controller;
  9. import org.springframework.web.bind.annotation.RequestMapping;
  10. import org.springframework.web.bind.annotation.ResponseBody;
  11. import org.springframework.web.bind.annotation.RestController;
  13. @RestController //这个注解表示这个类里面的所有方法都不走视图解析器，会全部返回字符串
  14. //@Controller
  15. @RequestMapping("/user")
  16. public class UserController {
  18.     @RequestMapping("/ujson")
  19.     //@ResponseBody //加了这个注解，这个方法就不会走视图解析器，会直接返回一个字符串
  20.     public String json1() throws JsonProcessingException {
  21.         User user =new User(1,"张三",34);
  23.         //使用Jackson里面的方法把Java对象转换成json字符串
  24.         ObjectMapper objm =new ObjectMapper();
  25.         String jsonstr = objm.writeValueAsString(user);
  26.         return jsonstr;
  27.     }
  28. }

Fastjson

导依赖

  1. <dependency>
  2.     <groupId>com.alibaba</groupId>
  3.     <artifactId>fastjson</artifactId>
  4.     <version>1.2.80</version>
  5. </dependency>
  1. @RestController //这个注解表示这个类里面的所有方法藕不走视图解析器，会全部返回一个字符串
  2. @RequestMapping("/user")
  3. public class UserController {
  5.     @RequestMapping("/ujson")
  6.     public String json1() throws JsonProcessingException {
  7.         User user =new User(1,"张三",34);
  8.         //JSON.parseXxxxx 此类方法就是把前段发过来的东西解析成xxx的
  9.         return JSON.toJSONString(user);
  10.     }
  11. }

Json乱码问题

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xmlns:mvc="http://www.springframework.org/schema/mvc"
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  7.         https://www.springframework.org/schema/beans/spring-beans.xsd
  8.         http://www.springframework.org/schema/context
  9.         https://www.springframework.org/schema/context/spring-context.xsd
  10.         http://www.springframework.org/schema/mvc
  11.         https://www.springframework.org/schema/mvc/spring-mvc.xsd">
  13.     <!--自动扫描包，让指定包下的注解生效，由IOC容器统一管理-->
  14.     <context:component-scan base-package="com.lyd.controller"/>
  15.     <!--让SpringMVC不处理静态资源 .css .js .html .mp3 .mp4等-->
  16.     <mvc:default-servlet-handler/>
  17.     <!--
  18.     支持mvc注解驱动
  19.     在spring中一般采用@RequestMapping注解来完成映射关系
  20.     要想使@RequestMapping注解生效
  21.     必须向上下文中注册DefaultAnnotationHandlerMapping
  22.     和一个AnnotationMethodHandlerAdapter实例
  23.     这两个实例分别在类级别和方法级别处理
  24.     而annotation-driven配置帮助我们自动完成上述两个实例的注入
  25.     -->
  26.     <!--配置JSON乱码问题-->
  27.     <mvc:annotation-driven>
  28.         <mvc:message-converters>
  29.             <bean class="org.springframework.http.converter.StringHttpMessageConverter">
  30.                 <constructor-arg value="UTF-8"/>
  31.             </bean>
  32.             <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
  33.                 <property name="objectMapper">
  34.                     <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
  35.                         <property name="failOnEmptyBeans" value="false"/>
  36.                     </bean>
  37.                 </property>
  38.             </bean>
  39.         </mvc:message-converters>
  40.     </mvc:annotation-driven>
  42.     <!--视图解析器-->
  43.     <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
  44.         <!--加上前后缀，就只用访问名字就行了，会主动拼接上前后缀的-->
  45.         <!--前缀-->
  46.         <property name="prefix" value="/WEB-INF/jsp/"/>
  47.         <!--后缀-->
  48.         <property name="suffix" value=".jsp"/>
  49.     </bean>
  52. </beans>

上传文件

用MultipartFile类型接收文件，前端传的文件名要和file对应，当然也可以写@RequestParam

  1. @RestController
  2. @RequestMapping("/upload")
  3. public class UploadController {
  5.     @Autowired
  6.     private UploadService uploadService;
  8.     @PostMapping("")
  9.     public ResponseResult upload(MultipartFile file){
  10.         return uploadService.upload(file);
  11.     }
  12. }

这个文件对象里面可以转换成流和字节数组等，方便操作。
image.png
前端上传请求头里面得包含
Content-Type：multipart/form-data;

重定向和转发

  1. @Controller
  2. public class RestFulController {
  4.     @GetMapping("/add/test1/{a}/{b}")
  5.     public String test1(@PathVariable int a, @PathVariable int b , Model model){
  6.         int res=a+b;
  7.         model.addAttribute("msg","结果为"+res);
  8.         //默认转发
  9.         //return "test";
  11.         //重定向
  12.         return "redirect:/index.jsp";
  13.     }
  14. }

乱码问题

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
  5.          version="4.0">
  7.     <!--配置DispatchServlet：这个是SpringMVC的核心，请求分发器，前端控制器-->
  8.     <servlet>
  9.         <servlet-name>springmvc</servlet-name>
  10.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  11.         <!--DispatcherServlet要绑定Spring的配置文件-->
  12.         <init-param>
  13.             <param-name>contextConfigLocation</param-name>
  14.             <param-value>classpath:springmvc-servlet.xml</param-value>
  15.         </init-param>
  16.         <!--启动级别：1.服务器一启动它就自己启动-->
  17.         <load-on-startup>1</load-on-startup>
  18.     </servlet>
  20.     <!--
  21.     所有的请求都会去走上面的servlet
  22.     在SpringMVC中 /和/*的区别
  23.         /:只会匹配所有的请求，不会去匹配jsp页面
  24.         /*:匹配所有的请求，包括jsp
  25.         本来访问的是hello请求，springmvc会主动追加前缀和后缀，比如变成index/hello.jsp,
  26.         如果设置了/*,在 访问请求hello.jsp，然后又要被springmvc追加一个前后缀，hello.jsp.jsp
  27.     -->
  28.     <servlet-mapping>
  29.         <servlet-name>springmvc</servlet-name>
  30.         <url-pattern>/</url-pattern>
  31.     </servlet-mapping>
  33.     <!--配置SpingMVC的乱码过滤器-->
  34.     <filter>
  35.         <filter-name>encoding</filter-name>
  36.         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  37.         <init-param>
  38.             <param-name>encoding</param-name>
  39.             <param-value>utf-8</param-value>
  40.         </init-param>
  41.     </filter>
  42.     <filter-mapping>
  43.         <filter-name>encoding</filter-name>
  44.         <url-pattern>/*</url-pattern>
  45.     </filter-mapping>
  46. </web-app>

拦截器

拦截请求，当请求一个xxx地址时，如果配置了拦截器，请求会先被拦截器拦截，拦截器判断这个请求要不要通过，不通过的话，请求都到不了控制器。拦截器通过了才会到控制器。
新建一个java文件作为拦截器。
拦截器有HttpServletRequest和HttpServletResponse，可以做的事很多，比如登陆，在拦截器里面发现没有sessionid，就通过HttpServletResponse重定向到登陆页面

  1. package com.lyd.config;
  4. import org.springframework.lang.Nullable;
  5. import org.springframework.web.servlet.HandlerInterceptor;
  6. import org.springframework.web.servlet.ModelAndView;
  8. import javax.servlet.http.HttpServletRequest;
  9. import javax.servlet.http.HttpServletResponse;
  11. //需要实现HandlerInterceptor接口
  12. public class MyInterceptor implements HandlerInterceptor {
  14.     //return true；执行下一个拦截器，放行
  15.     //return false；不执行下一个拦截器
  16.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  17.         System.out.println("==============拦截前============");
  18.         return true;
  19.     }
  21.     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
  22.         System.out.println("==============拦截后============");
  23.     }
  25.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
  26.         System.out.println("==============清理============");
  27.     }
  28. }

配置spring配置里面的mvc拦截器

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:mvc="http://www.springframework.org/schema/mvc"
  5.        xmlns:context="http://www.springframework.org/schema/context"
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  7.         https://www.springframework.org/schema/beans/spring-beans.xsd
  8.         http://www.springframework.org/schema/mvc
  9.         http://www.springframework.org/schema/mvc/spring-mvc.xsd
  10.         http://www.springframework.org/schema/context
  11.         https://www.springframework.org/schema/context/spring-context.xsd">
  13.     <!--1.注解驱动，配置JSON乱码问题-->
  14.     <mvc:annotation-driven>
  15.         <mvc:message-converters>
  16.             <bean class="org.springframework.http.converter.StringHttpMessageConverter">
  17.                 <constructor-arg value="UTF-8"/>
  18.             </bean>
  19.             <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
  20.                 <property name="objectMapper">
  21.                     <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
  22.                         <property name="failOnEmptyBeans" value="false"/>
  23.                     </bean>
  24.                 </property>
  25.             </bean>
  26.         </mvc:message-converters>
  27.     </mvc:annotation-driven>
  28.     <!--2.静态资源过滤-->
  29.     <mvc:default-servlet-handler/>
  30.     <!--3.扫描包-->
  31.     <context:component-scan base-package="com.lyd.*"/>
  32.     <!--4.视图解析器-->
  33.     <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
  34.         <!--加上前后缀，就只用访问名字就行了，会主动拼接上前后缀的-->
  35.         <!--前缀-->
  36.         <property name="prefix" value="/WEB-INF/jsp/"/>
  37.         <!--后缀-->
  38.         <property name="suffix" value=".jsp"/>
  39.     </bean>
  40.     <!--5.拦截器配置-->
  41.     <mvc:interceptors>
  42.         <mvc:interceptor>
  43.             <!--包括这个请求下面的所有的请求-->
  44.             <mvc:mapping path="/**"/>
  45.             <!--配置写的拦截器-->
  46.             <bean class="com.lyd.config.MyInterceptor"/>
  47.         </mvc:interceptor>
  48.     </mvc:interceptors>
  49. </beans>