Spring+SpringMVC复习资料（超详细）建议收藏

最新推荐文章于 2024-05-16 10:21:44 发布

叶落q

最新推荐文章于 2024-05-16 10:21:44 发布

阅读量320

点赞数

文章标签： spring java 后端

本文链接：https://blog.csdn.net/qq_53516639/article/details/126415613

版权

文章目录

初识Spring
注解
Spring整合mybatis
Spring整合junit
AOP简介
Spring事务简介
Spring

初识Spring

简介:Spring框架是一个开放源代码的J2EE应用程序框架，由[Rod Johnson](https://baike.baidu.com/item/Rod Johnson/1423612)发起，是针对bean的生命周期进行管理的轻量级容器（lightweight container）。 Spring解决了开发者在J2EE开发中遇到的许多常见的问题，提供了功能强大IOC、AOP及Web MVC等功能。Spring可以单独应用于构筑应用程序，也可以和Struts、Webwork、Tapestry等众多Web框架组合使用，并且可以与 Swing等桌面应用程序AP组合。因此， Spring不仅仅能应用于J2EE应用程序之中，也可以应用于桌面应用程序以及小应用程序之中。Spring框架主要由七部分组成，分别是 Spring Core、 Spring AOP、 Spring ORM、 Spring DAO、Spring Context、 Spring Web和 Spring Web MVC

Spring boot 是在基础上加速开发的

Spring Framework 是基础框架

Spring Cloud 分布式开发

创建Spring项目

先建立maven项目

导入坐标Spring-context 坐标

 <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>

创建applicationContext.xml 文件即ioc容器管理bean

id:相当于创建对象的名称，class是要创建对象实现类的位置
    property 配置 所要创建对象里面的属性赋值
<bean id = "BookService" class="com.itheima.service.impl.BookServiceImpl">
        <property name="bookDao" ref="bookdaoimpl"/>
    </bean>

在主程序中创建spring容器

public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
       /* BookDao bookdaoimpl = (BookDao) ctx.getBean("bookdaoimpl");
        bookdaoimpl.save();*/
        BookService bookService = (BookService) ctx.getBean("BookService");
        bookService.save();
    }

bean 属性的认识

id 是 bean的表示表示该类所对应的对象名称

class 代表你需要管理哪一个类

name 表示可以给该bean 起别名可以用空格隔开或者逗号

scop 表示bean的范围是单例还是多例，scop默认是单例的以下是单例的说明

 BookService bookService = (BookService) ctx.getBean("BookService");
        System.out.println(bookService);
        BookService bookService1 = (BookService) ctx.getBean("BookService");
        System.out.println(bookService1);

以下是多例的说明

scope="prototype"

bean实例化的方式

通过构造方法实例化bean

通过静态工厂实例化bean

需要一个参数factory-method 属性告诉bean真正造对象的方法名

通过非静态工厂实例化bean

因为不是静态方法，不能通过该类直接调用，需要通过该类的对象点方法名调用

因为方式三创建bean麻烦，所以开发者为我们写好了一个接口叫factorybean，我们直接继承这个接口就好了

//<里面表示工厂想要创建什么类型的对象>
public class BookDaoFactoryBean implements FactoryBean<BookDao> {


    @Override
    public BookDao getObject() throws Exception {
        return new BookDaoimpl();
    }

    @Override
    public Class<?> getObjectType() {
        return BookDao.class;
    }
}

bean的生命周期

销毁方式一close（）关闭，比较暴力

要想看到bean容器关闭，必须在java虚拟机退出前，关闭bean容器，close方法在主接口中没有，所以要将变量的定义修改为他的实现类

init（），destory（），都是定义在实现类里面的方法，在bean中通过属性告诉bean这是开始和销毁

销毁方式二关闭钩子registerShutdownHook();

生命周期控制的优化方案

在实现类中继承接口：InitializingBean ,DisposableBean

依赖注入方式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jhPpZJuq-1660835421955)(C:\Users\刘国庆\AppData\Roaming\Typora\typora-user-images\image-20220814170442850.png)]

setter注入标签用property

<bean id = "bookdaoimpl" class="com.itheima.dao.impl.BookDaoimpl">
    <property name="database" value="sssk"/>
    <property name="num" value="10"/>
</bean>

构造器注标签用constructor-arg

<bean id = "bookDao" class="com.itheima.dao.impl.BookDaoimpl">
   <constructor-arg name="database" value="sdfs"/>
    <constructor-arg name="num" value="10"/>
</bean>

自己开发一般使用setter注入

依赖自动装配

对依赖注入的优化

通过bean的属性autowire来指定方式匹配

一般使用按类型装配

集合注入

Spring加载外部配置文件

现在ioc容器中开辟一个命名空间
然后通过命名空间占位符属性来加载

开辟命名空间

如果配置文件的命名为username=1；

在spring中加载的时候得到的并不是这个

因为变量名称和系统变量名称冲突了，也就是说在系统变量中有一个变量叫username 系统变量的优先级高于配置文件

要想加载自己的变量，就得配一个属性了

方式一:加载多个配置文件，只需在第一个配置文件后面加个，再加另一个配置文件的名称
方式二：*.properties 加载所有配置文件
标准格式 classpath* 不光加载当前目录下的配置文件，还加载所依赖的所有jar包中的配置文件

容器

创建容器的两种方式

一是由类路径加载

二是通过文件来加载（写配置文件的绝对路径）

获取bin的三种方式

核心容器总结

注解

注解开发定义bean

先再spring容器中开辟命名空间
使用@Component 定义bean
核心配置文件中扫描bean

纯注解开发模式

将配置文件用类来替换下来

注解开发bean的作用范围与生命周期

注解开发依赖注入

引用依赖注入

使用注解注入的时候不需要在写setter方法了，也不用类提供入口了，只需在要注入的变量上面添加注解@Autowired 根据类型自动装配

简单类型注入

通过注解加载配置文件

先在配置类里面加上配置

第三方bean管理

第三方bean注入

Spring整合mybatis

两个框架的整合

1.首先导入对应的坐标

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.2.8</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.27</version>
    </dependency>

    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.5</version>
    </dependency>

    //spring操作数据库专用的包
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>
    
    //mybatis和spring整合，spring提供接口
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>1.3.0</version>
    </dependency>

</dependencies>

Spring整合junit

需要导入的坐标



<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>

AOP简介

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

aop是一种编程思想，在不惊动原有设计的基础上为其进行功能的增强的

aop开发流程

导入aop坐标

<dependencies>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.4</version>
    </dependency>
</dependencies>

说明spring-context里面包含spring-aop

定义接口与实现类
定义通知类，制作通知
定义切入点
绑定切入点与通知的关系
定义通知类受Spring容器管理，并定义当前类为切面类 @Component ,@Aspect
在spring核心配置里面开启spring对aop注解驱动的支持
@EnableAspectJAutoProxy

如果出现配置文件找不到的情况，就是target目录里面没有加载，在pom文件夹里将打包方式改为jar

AOP切入点表达式

对于环绕通知around （）要给一个参数ProceedingJoinPoint获取要环绕的方法，并且方法的返回值可以prossed的方法返回出来。

返回后通知 AfterReturning

抛出异常后通知 AfterThrowing

aop通知获取数据

Spring事务简介

在业务接口上添加spring事务管理@Transactional(英语意思：事务)

  2. 设置事务管理器

3.开启注解式事务驱动

spring事务角色

事务角色
- 事务管理员：发起事务，在Spring中通常指代业务层开启事务的方法
- 事务协调员：加入事务方，在Spring中通常指代数据层方法，也可以是业务层方法

spring事务属性

事务属性使用案例

事务传播行为：事务协调员对事务管理员所携带事务的处理态度（日志）

Spring

SpringMvc简介

Spring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块。使用 Spring 可插入的 MVC 架构，从而在使用Spring进行WEB开发时，可以选择使用Spring的Spring MVC框架或集成其他MVC开发框架，如Struts1(现在一般不用)，Struts 2(一般老项目使用)等等。

Springmvc入门案例

导入坐标

 <!--1.导入坐标spring 和servlet-->
<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>javax.servlet-api</artifactId>
  <version>3.1.0</version>
  <!--<scope>provided</scope>   servlet和tomcat发生冲突所以加个范围-->
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>5.2.10.RELEASE</version>
</dependency>

//2.定义controller
//2.1 使用@Controller定义bean
@Controller
public class UserController {
    //2.2  设置当前操作的访问路径
    @RequestMapping("/save")
    //2.3设置当前操作的返回值类型
    @ResponseBody
    public String save(){
        System.out.println("user save...");
        return "{'module':'springmvc'}";
    }
}

//3 创建springmvc的配置文件，加载controller对应的bean
@Configuration
@ComponentScan("com.itheima.controller")
public class SpringMvcConfig {
}

//4.定义一个servlet容器启动的配置类，在里面加载spring的配置
public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    //加载springmvc容器配置
    @Override
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(SpringMvcConfig.class);
        return ctx;
    }
    //设置那些请求归属springmvc处理
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
    //加载spring容器配置
    @Override
    protected WebApplicationContext createRootApplicationContext() {
        return null;
    }
}

注意点

web.xml 不要了，删除，用配置类实现
添加tomcat插件的坐标

<build>
<plugins>
  <plugin>
    <groupId>org.apache.tomcat.maven</groupId>
    <artifactId>tomcat7-maven-plugin</artifactId>
    <version>2.1</version>
  </plugin>
</plugins>
  </build>

springmvc的工作流程

SpringMVC bean的加载控制

问题：因为功能不同如何避免Spring错误的加载到SpringMVC的bean？

答：加载Spring控制的bean的时候排除掉SpringMVC控制的bean

方法一

配置你想加载的包

@ComponentScan({"com.itheima.dao","com.itheima.service"})

方法二

@ComponentScan(value="com.itheima",
   excludeFilters = @ComponentScan.Filter(
   type = FilterType.ANNOTATION,
   classes = Controller.class   
   )
)

mybatis自动代理的方式来创建的实现对象，扫描对应dao后为其生成bean并注入到spring容器中

简化开发

AbstractAnnotationConfigDispatcherServletInitializer

PostMan工具介绍

Postman是一款功能强大的网页调试与发送网页HTTP请求的Chrome插件
作用:常用于进行接口测试

下载地址:https://app.getpostman.com/app/download/win64

请求

请求路径的设置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ghbt83x1-1660835421974)(C:\Users\刘国庆\AppData\Roaming\Typora\typora-user-images\image-20220816191859411.png)]

请求参数

get请求

post请求

乱码处理在servletContainersInitConfig中写一个过滤器：里面引用springmvc写好的filter

五种类型的传参

json数据传递参数

json数组
json对象（pojo）
json数组（pojo

第一步导入json坐标

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.9.9</version>
</dependency>

第二步在springmvcConfig上配置注解@EnableMvc

第三步在参数前面加上@RequestBody

日期类型传递参数

响应

响应页面
响应数据
- 文本数据
- json数据

转换为响应体的具体实现

REST风格简介

入门案例

REST快速开发

案例

SSM整合

1.整合配置

包的基础结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sUCiiGJH-1660835421989)(C:\Users\刘国庆\AppData\Roaming\Typora\typora-user-images\image-20220817071259135.png)]

坐标一共10个依赖坐标

<dependencies>
 <!--1.连接数据库需要的mysql驱动-->
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.27</version>
  </dependency>

 <!--2.mybatis框架-->


  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.5</version>
  </dependency>
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.2</version>
  </dependency>

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

  <!--3.导入第三方数据池-->
  <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.8</version>
  </dependency>
  <!--4.导入单元测试类-->
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
  </dependency>
  <!--5.导入sprin相关坐标-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>

  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.10.RELEASE</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.10.RELEASE</version>
  </dependency>

   <!--导入json依赖-->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.9.9</version>
    </dependency>
</dependencies>



<!--6.导入tomacat驱动-->

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.tomcat.maven</groupId>
      <artifactId>tomcat7-maven-plugin</artifactId>
      <version>2.1</version>
    </plugin>
  </plugins>
</build>

特别注意导入servlet的时候加入scope

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

一定要注意：@PropertySource(“classPath:jdbc.properties”)//加载数据配置时一定要加上classPath

2.功能模块开发

BookDao接口

public interface BookDao {

    @Insert("insert into tbl_book values(null,#{type},#{name},#{description})")
    public void save(Book book);
    @Update("update tbl_book set type=#{type},name=#{name},description = #{description} where id=#{id}")
    public void update(Book book);
    @Delete("delete from tbl_book where id = #{id}")
    public void delete(Integer id);
    @Select("select * from tbl_book where id = #{id}")
    public Book selectById(Integer id);
    @Select("select * from tbl_book")
    public List<Book> selectAll();
}

BookService接口

@Transactional
public interface BookService {
    /**
     * 保存业务
     * @param book
     * @return
     */

    public boolean save(Book book);

    /**
     * 更新业务
     * @param book
     * @return
     */

    public boolean update(Book book);

    /**
     * 删除业务
     * @param id
     * @return
     */

    public boolean delete(Integer id);

    /**
     * 根据id查询业务
     * @param id
     * @return
     */

    public  Book selectById(Integer id);

    /**
     * 查询所有数据
     * @return
     */
    public List<Book> selectAll();
}

BookServiceImpl 实现类

package com.itheima.service;

import com.itheima.dao.BookDao;
import com.itheima.domain.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
@Service
public class BookServiceImpl implements BookService {
    @Autowired
    private BookDao bookDao;
    @Override
    public boolean save(Book book) {
        bookDao.save(book);
        return true;
    }

    @Override
    public boolean update(Book book) {
        bookDao.update(book);
        return true;
    }

    @Override
    public boolean delete(Integer id) {
        bookDao.delete(id);
        return true;
    }

    @Override
    public Book selectById(Integer id) {
       return bookDao.selectById(id);

    }

    @Override
    public List<Book> selectAll() {
        return bookDao.selectAll();
    }
}

实体Book

public class Book {
    private Integer id;
    private String type;
    private String name;
    private String description;

    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", type='" + type + '\'' +
                ", name='" + name + '\'' +
                ", description='" + description + '\'' +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}

BookController

@RestController  //说明该类是一个控制器
@RequestMapping("books")  //设置请求的访问路径
public class BookController {

    @Autowired
    private BookService bookService;

    @PostMapping
    public boolean save(@RequestBody Book book){
           return bookService.save(book);
    }

    @PutMapping
    public boolean update(@RequestBody Book  book){
        return bookService.update(book);
    }

    @DeleteMapping("/{id}")
    public boolean delete(@PathVariable Integer id){
        return bookService.delete(id);
    }

    @GetMapping("/{id}")
    public Book getById(@PathVariable Integer id){
        return bookService.selectById(id);
    }
    @GetMapping
    public List<Book> selectAll(){
        return bookService.selectAll();
    }

}

3.接口测试

4.前后端结合

表现层数据封装统一格式步骤：

1.在controller包下定义模型类

 public Result() {
    }

    public Result(Object data, Integer code) {
        this.data = data;
        this.code = code;
    }

    public Result(Object data, Integer code, String msg) {
        this.data = data;
        this.code = code;
        this.msg = msg;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

2.定义code类里面的数据

public class Code {
    public static final Integer SAVE_OK = 20011;
    public static final Integer DELETE_OK = 20021;
    public static final Integer UPDATE_OK = 20031;
    public static final Integer GET_OK = 20041;



    public static final Integer SAVE_ERR = 20010;
    public static final Integer DELETE_ERR = 20020;
    public static final Integer UPDATE_ERR = 20030;
    public static final Integer GET_ERR = 20040;


}

3修改cotroller里面的数据

@PostMapping
public Result save(@RequestBody Book book){
    boolean flag = bookService.save(book);
    return new Result(flag ? Code.SAVE_OK:Code.SAVE_ERR,flag);

}

@PutMapping
public Result update(@RequestBody Book  book){
    boolean flag = bookService.update(book);
    return new Result(flag ? Code.UPDATE_OK:Code.UPDATE_ERR,flag);
}

@DeleteMapping("/{id}")
public Result delete(@PathVariable Integer id){
    boolean flag = bookService.delete(id);
    return new Result(flag ? Code.DELETE_OK:Code.DELETE_ERR,flag);
}

@GetMapping("/{id}")
public Result getById(@PathVariable Integer id){
    Book book = bookService.selectById(id);
    Integer code = book !=null ? Code.GET_OK:Code.GET_ERR;
    String msg = book != null ? "" :"数据查询失败，请重试";
    return new Result(code,book,msg);
}
@GetMapping
public Result selectAll(){
    List<Book> books = bookService.selectAll();
    Integer code = books !=null ? Code.GET_OK:Code.GET_ERR;
    String msg = books != null ? "" :"数据查询失败，请重试";
    return new Result(code,books,msg);
}

异常处理器

1.在controller包下创建一个类，声明成异常处理@Rest ControllerAdvice

在方法上声明要处理什么类型的异常@ExceptionHandler

@RestControllerAdvice
public class ProjectExceptionAdvice {
    @ExceptionHandler(Exception.class)
    public Result doException(Exception ex){
        return new Result(666,null,"出异常啦");
    }
}

异常的分类

项目异常处理方案

1.首先创建两个异常类

//这是我们自定义的一个异常类，继承RuntimeException的目的是出现异常不处理自动向上一级抛
public class BusinessException extends RuntimeException {

    private Integer code;

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public BusinessException(String message, Integer code) {
        super(message);
        this.code = code;
    }

    public BusinessException(String message, Throwable cause, Integer code) {
        super(message, cause);
        this.code = code;
    }

}

2.自己创建抛两个异常

if(id == 1){
    throw new BusinessException("请不要使用你的技术来挑战我的耐性！", Code.BUINESS_ERR);
}

     try{
         int i = 1/0;
     }
     catch (Exception e){
         throw new SystemException("服务器访问超时，请重试",Code.SYSTEM_TIMEOUT_ERR);
     }

       return bookDao.selectById(id);

    }

3.在异常处理器里面管理这两个异常

@ExceptionHandler(BusinessException.class)
public Result doBusinessException(BusinessException ex){

    return new Result(ex.getCode(),null,ex.getMessage());
}

@ExceptionHandler(SystemException.class)
public Result doSystemException(SystemException ex){
    //记录日志
    //发送消息给运维
    //发送邮件给开发人员

    return new Result(ex.getCode(),null,ex.getMessage());
}

//其他异常
@ExceptionHandler(Exception.class)
public Result doException(Exception ex){
    //记录日志
    //发送消息给运维
    //发送邮件给开发人员
    return new Result(Code.SYSTEM_UNKNOW_ERR,null,"系统繁忙，请稍后再试");
}

4.在Code里面定义异常的类型编码

public static final Integer SYSTEM_ERR = 50001;
public static final Integer SYSTEM_TIMEOUT_ERR = 50002;
public static final Integer SYSTEM_UNKNOW_ERR = 59999;


public static final Integer BUINESS_ERR = 60002;

完成！

前后台协议联调-----静态界面放行

添加前端代码
SpringMVC将前端代码的静态页面放行

@Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
          registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
          registry.addResourceHandler("/css/**").addResourceLocations("/css/");
          registry.addResourceHandler("/js/**").addResourceLocations("/js/");
          registry.addResourceHandler("/plugins/**").addResourceLocations("/plugins/");
    }
}

3.将配置加载到Springmvc的核心配置里面

@ComponentScan({"com.itheima.controller","com.itheima.config"})

拦截器

浏览器发出请求到达tomcat服务器，然后拦截所有请求，资源划分为静态资源和动态资源，对于静态资源（html，css，js，图片，声音）tomcat直接给你，动态资源会直接进入到servlet或者说是controller中吗？不是，在进入之前会有一个过滤器（可以多层）直到访问到你的控制器上在spring中有一个中央控制器，根究你的请求路径，访问具体的controller

需求：在访问具体的contoller之前要确定你的（权限）这就出现了拦截器（访问前后都对数据做处理）

拦截器和过滤器的区别

开发步骤：

先写拦截类
配置拦截器作用于哪个controller
配置是何种请求才会触发拦截器

执行流程

多拦截器

C将前端代码的静态页面放行

[外链图片转存中…(img-rDRTrKLd-1660835421994)]

@Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
          registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
          registry.addResourceHandler("/css/**").addResourceLocations("/css/");
          registry.addResourceHandler("/js/**").addResourceLocations("/js/");
          registry.addResourceHandler("/plugins/**").addResourceLocations("/plugins/");
    }
}