三种配置文件的配置优先级
结论:优先级: 命令行参数 (程序实参)> 系统属性参数(VM选项) > properties参数 > yml参数 > yaml参数
前面说到SpringBoot项目当中支持的三类配置文件:application.properties、application.yml、application.yaml。
配置一个属性,可以通过这三种方式当中的任意一种来配置,如果项目中同时存在这三种配置文件,且都配置了同一个属性,如:Tomcat端口号,到底哪一份配置文件生效呢?
配置文件优先级排名(从高到低):
- properties配置文件
- yml配置文件
- yaml配置文件
项目开发时,推荐统一使用一种格式的配置。(yml是主流)
SpringBoot为了增强程序的扩展性,除了支持配置文件的配置方式以外,还支持另外两种常见的配置方式:
- Java系统属性配置 (格式: -Dkey=value)
-Dserver.port=9000
- 命令行参数 (格式:–key=value)
--server.port=10010
idea中指定Java系统属性和命令行参数:
编辑启动程序的配置信息
新版idea被隐藏了需要手动添加窗口:
VM选项即存放系统属性参数,程序实参存放命令行参数。
重启服务,同时配置Tomcat端口(三种配置文件、系统属性、命令行参数)
优先级: 命令行参数 (程序实参)> 系统属性参数(VM选项) > properties参数 > yml参数 > yaml参数
思考:如果项目已经打包上线了,这个时候我们又如何来设置Java系统属性和命令行参数呢?
java -Dserver.port=9000 -jar XXXXX.jar --server.port=10010
项目打包:
运行jar程序,同时设置Java系统属性和命令行参数:
Springboot项目进行打包时,需要引入插件 spring-boot-maven-plugin (基于官网骨架创建项目,会自动添加该插件)
打包后生成俩个jar包一个是.jar 一个是.jar.original
.jar.original 是普通jar包,不包含依赖,如果是给别的项目用,就用这个
.jar 是可执行jar包,包含了pom中的所有依赖,可以直接用java -jar 命令执行,如果是部署,就用.jar
Bean管理 (掌握)
Bean的获取 ApplicationContext.getBean
默认情况下,SpringBoot项目在启动的时候会自动的创建IOC容器(也称为Spring容器),并且在启动的过程当中会自动的将bean对象都创建好,存放在IOC容器当中。应用程序在运行时需要依赖什么bean对象,就直接进行依赖注入就可以了。
而在Spring容器中提供了一些方法,可以主动从IOC容器中获取到bean对象,下面介绍3种常用方式:
-
根据name获取bean
Object getBean(String name)
-
根据类型获取bean
<T> T getBean(Class<T> requiredType)
-
根据name获取bean(带类型转换)
<T> T getBean(String name, Class<T> requiredType)
- 要从IOC容器当中来获取到bean对象,需要先拿到IOC容器对象,而想获取到IOC容器,直接将IOC容器对象注入进来就可以了。
@SpringBootTest
class SpringbootWebConfig2ApplicationTests {
@Autowired
private ApplicationContext applicationContext; //注入IOC容器对象
//获取bean对象
@Test
public void testGetBean(){
//根据bean的名称获取
DeptController bean1 = (DeptController) applicationContext.getBean("deptController");//这里需要强转 另外注意bean的名字默认是类名首字母小写
System.out.println(bean1);
//根据bean的类型获取
DeptController bean2 = applicationContext.getBean(DeptController.class);
System.out.println(bean2);
//根据bean的名称 及 类型获取
DeptController bean3 = applicationContext.getBean("deptController", DeptController.class);
System.out.println(bean3);
}
}
运行:
输出的bean对象地址值是一样的,因为默认情况下,IOC中的bean对象是单例,实际开发当中,绝大部分的Bean是单例的,也可以将bean对象设置为非单例的,下面在bean作用域中讲解,且上述所说的 【Spring项目启动时,会把其中的bean都创建好】还会受到作用域及延迟初始化影响,这里主要针对于默认的单例非延迟加载的bean而言。
Bean的作用域 @Scope(“prototype”) @Lazy
如何设置bean对象为非单例呢?需要设置bean的作用域。在Spring中支持五种作用域,后三种在web环境才生效:
作用域 | 说明 |
---|---|
singleton | 容器内同名称的bean只有一个实例(单例)(默认) |
prototype | 每次使用该bean时会创建新的实例(非单例) |
request | 每个请求范围内会创建新的实例(web环境中,了解) |
session | 每个会话范围内会创建新的实例(web环境中,了解) |
application | 每个应用范围内会创建新的实例(web环境中,了解) |
下面进行演示,可以借助Spring中的@Scope
注解来进行配置作用域
- 控制器
//@Scope("prototype") //此时bean作用域为非单例
//默认bean的作用域为:singleton (单例)
@Lazy //延迟加载(第一次使用bean对象时,才会创建bean对象并交给ioc容器管理)
@RestController
@RequestMapping("/depts")
public class DeptController {
@Autowired
private DeptService deptService;
public DeptController(){
System.out.println("DeptController constructor ....");
}
//省略其他代码...
}
- 测试类
@SpringBootTest
class SpringbootWebConfig2ApplicationTests {
@Autowired
private ApplicationContext applicationContext; //IOC容器对象
//bean的作用域
@Test
public void testScope(){
for (int i = 0; i < 10; i++) {
DeptController deptController = applicationContext.getBean(DeptController.class);
System.out.println(deptController);
}
}
}
- 默认singleton(单例)的bean,在容器启动时被创建,可以使用
@Lazy
注解来延迟初始化(延迟到第一次使用时)
修改控制器DeptController代码:@Scope(“prototype”) //bean作用域为非单例
第三方Bean @Bean @Configuration
之前我们所配置的bean,像controller、service,dao三层体系下编写的类,这些类都是我们在项目当中自己定义的类(自定义类)。要声明这些bean我们只需要在类上加上@Component以及它的这三个衍生注解(@Controller、@Service、@Repository(被@Mapper替代)),就可以来声明这个bean对象了。
但是如果是第三方的类呢?比如dom4j中的SAXReader类,按照我们之前的做法,需要在SAXReader类上添加一个注解@Component(将当前类交给IOC容器管理),但第三方提供的类是只读的。无法在第三方类上添加@Component注解或衍生注解。
- 如果要管理的bean对象来自于第三方(不是自定义的),是无法用@Component 及衍生注解声明bean的,就需要用到@Bean注解。
解决方案1:在启动类上添加@Bean标识的方法
@SpringBootApplication
public class SpringbootWebConfig2Application {
public static void main(String[] args) {
SpringApplication.run(SpringbootWebConfig2Application.class, args);
}
//声明第三方bean
@Bean //将当前方法的返回值对象交给IOC容器管理, 成为IOC容器bean
public SAXReader saxReader(){
return new SAXReader();
}
}
@SpringBootTest
class SpringbootWebConfig2ApplicationTests {
@Autowired
private SAXReader saxReader;
...
说明:以上在启动类中声明第三方Bean的作法,不建议使用(项目中要保证启动类的纯粹性)
解决方案2:在配置类中定义@Bean标识的方法(推荐)
如果需要定义第三方Bean时, 通常会单独定义一个配置类
package com.itheima.config
@Configuration //配置类 (在配置类当中对第三方bean进行集中的配置管理)
public class CommonConfig {
//声明第三方bean
@Bean //将当前方法的返回值对象交给IOC容器管理, 成为IOC容器bean
//通过@Bean注解的name/value属性指定bean名称, 如果未指定, 默认是方法名
public SAXReader reader(DeptService deptService){
System.out.println(deptService);
return new SAXReader();
}
}
在方法上加上一个@Bean注解,Spring 容器在启动的时候,它会自动的调用这个方法,并将方法的返回值声明为Spring容器当中的Bean对象。
如果第三方bean需要依赖其它bean对象,直接在bean定义方法中设置形参即可,容器会根据类型自动装配。
Bean的生命周期(面试高频)及常用自定义方法
简单来说分为五步:
- 1.实例化:当容器需要初始化一个尚未初始化的Bean,或者初始化Bean时需要注入另一个尚未初始化的依赖时,容器会调用doCreateBean()方法进行实例化。实际上,这是通过反射的方式创建出一个Bean对象。
- 2.属性赋值:Bean实例创建完成后,接下来是为这个Bean对象进行属性填充,也就是注入这个Bean依赖的其他Bean对象。
- 3.初始化 :在属性填充完成后,进行Bean的初始化操作。初始化阶段包括以下几个步骤:
-
- 3.1.执行Aware接口的方法:Spring会检测该对象是否实现了xxx Aware接口,通过Aware类型的接口,可以让我们获取Spring容器的一些资源。例如,实现BeanNameAware接口可以获取到Bean的名称,实现BeanFactoryAware接口可以获取到工厂对象BeanFactory等。
-
- 3.2.判断Bean是否实现了InitializingBean接口,如果实现了,将会执行InitializingBean的afterPropertiesSet()初始化方法。
-
- 3.3.执行用户自定义的初始化方法(如果有指定的话),如init-method等。
-
- 3.4.执行BeanPostProcessor的后置处理方法postProcessAfterInitialization()。
- 4.使用:初始化完成后,Bean就成功创建了,之后就可以使用这个Bean。
- 5.销毁:当Bean不再需要时,会进行销毁操作。销毁阶段包括以下步骤:
-
- 5.1.判断Bean是否实现了DestructionAwareBeanPostProcessor接口,如果实现了,则会执行DestructionAwareBeanPostProcessor后置处理器的销毁回调方法。
-
- 5.2.判断Bean是否实现了DisposableBean接口,如果实现了,将会调用其实现的destroy()方法。
-
- 5.3后判断这个Bean是否配置了destroy-method等自定义的销毁方法,如果有配置,则会自动调用其配置的销毁方法。
如果详细一点介绍的话可以分为五个阶段:
创建前准备:Bean在开始加载之前要从上下文和一些配置中去解析并且查找Bean有关扩展的实现,比如像init-method
,容器在初始化Bean的时候或调用的一个方法,destroy-method
,容器在销毁Bean的时候会调用的一些方法,以及BeanFactoryPostProcessor
这一类的Bean加载过程中的一些前置和后置的一些处理扩展实现,这些类和配置其实是Springr提供给开发者用来去实现Bean加载过程中的一些扩展,在很多和Spring集成的中间件也比较常见,比如Dubbo,这样一些中间件。
创建实例化:这个阶段主要作用是通过反射去创建Bean的实例对象,并且会扫描和解析Bean声明的一些属性
依赖注入:如果被实例化的Bean存在依赖其他Bean对象的一些情况,则需要对这些依赖的Bean进行对象注入,比如常见的@Autowired,以及setter注入等这样一些配置形式,同时在这个阶段会触发一些扩展的调用,比如说常见的扩展类BeanPOSTProcessors
用来去实现Bean初始化前后的扩展回调,以及像BeanFactoryAware
等等。另外这个阶段有可能存在一个循环依赖的问题,但是Spring通过三级缓存来解决这个问题。
容器缓存:主要是把Bean保存到容器以及Spring缓存中,到这个阶段的Bean就可以被开发者使用了,这个阶段涉及到的操作像init-method
这个属性配置一些方法或者这个阶段会被调用,以及像BeanPOSTProcessors
的后置处理器方法也会在这个阶段被触发
销毁实例:当Spring的应用上下文被关闭的时候,那么这个上下文中所有的Bean会被销毁,如果存在了Bean存在了DisposableBean
接口或者配置了destroy-method
属性的一些方法会在这个阶段被调用
Spring Bean的生命周期是一个复杂的过程,开发者可以在这个过程中自定义很多方法来满足特定的需求。下面是一些常见的自定义方法:
1. @PostConstruct注解
@PostConstruct
注解用于在依赖注入完成后执行一些初始化的操作。这个注解的方法会在Bean的所有属性被自动装配之后,且在Bean的初始化方法(如afterPropertiesSet或者自定义的init-method)之前被调用。
@Component
public class MyBean {
@PostConstruct
public void init() {
System.out.println("Bean is going through init.");
}
}
2. BeanPostProcessor接口
实现BeanPostProcessor接口可以在Bean初始化前后进行一些操作。postProcessBeforeInitialization方法会在Bean初始化之前调用,postProcessAfterInitialization方法会在Bean初始化之后调用。
@Component
public class CustomBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("Before Initialization : " + beanName);
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("After Initialization : " + beanName);
return bean;
}
}
3. InitializingBean和DisposableBean接口
InitializingBean接口提供了afterPropertiesSet方法,可以在Bean的所有属性被自动装配后执行。DisposableBean接口提供了destroy方法,可以在Bean销毁前执行。
@Component
public class MyBean implements InitializingBean, DisposableBean {
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("Bean is going through afterPropertiesSet.");
}
@Override
public void destroy() throws Exception {
System.out.println("Bean will destroy now.");
}
}
4. 自定义init-method和destroy-method
除了上述的方法,我们还可以在XML配置文件中,通过init-method和destroy-method属性来指定初始化和销毁方法。
<bean id="myBean" class="com.example.MyBean" init-method="init" destroy-method="cleanup" />
public class MyBean {
public void init() {
System.out.println("Bean is going through init.");
}
public void cleanup() {
System.out.println("Bean will destroy now.");
}
}
不仅可以通过在XML配置文件中指定init-method属性,还可以在Java配置中使用@Bean(initMethod=“init”)注解来指定自定义的初始化方法。
@Bean(initMethod="init")
public MyBean myBean() {
return new MyBean();
}
public class MyBean {
public void init() {
System.out.println("Bean is going through custom init.");
}
}
5.@PreDestroy注解
@PreDestroy注解用于在Bean销毁前执行一些清理操作。
@Component
public class MyBean {
@PreDestroy
public void destroy() {
System.out.println("Bean will destroy now.");
}
}
给所有的自定义方法的执行排个序:
实例化阶段(Instantiation):
- 如果Bean使用构造函数方式实例化,首先会调用构造函数来创建Bean的实例。
Bean属性设置(Properties Set):
- 在Bean实例化后,Spring容器将会设置Bean的属性(依赖注入),包括通过构造函数注入或者通过Setter方法注入。
BeanPostProcessor的前置处理方法(BeanPostProcessor Pre-Processing):
- BeanPostProcessor接口的postProcessBeforeInitialization方法:在调用Bean的初始化方法之前,BeanPostProcessor的前置处理方法会被调用,允许开发者在Bean初始化之前进行一些自定义的操作。
Bean初始化方法(Initialization):
- InitializingBean接口的afterPropertiesSet方法:实现InitializingBean接口并覆盖afterPropertiesSet方法的Bean会在所有属性被设置后调用该方法。
- @PostConstruct注解标注的方法:使用@PostConstruct注解标注的方法会在依赖注入完成后、在Bean生命周期的最后阶段调用。
- 自定义初始化方法:在初始化阶段,开发者也可以通过XML配置文件或者@Bean注解的initMethod属性指定自定义的初始化方法。
BeanPostProcessor的后置处理方法(BeanPostProcessor Post-Processing):
- BeanPostProcessor接口的postProcessAfterInitialization方法:在Bean的初始化方法被调用后,BeanPostProcessor的后置处理方法会被调用,允许开发者在Bean初始化完成后进行一些自定义的操作。
Bean销毁阶段(Destruction):
- DisposableBean接口的destroy方法:实现DisposableBean接口并覆盖destroy方法的Bean会在容器关闭时调用该方法进行销毁。
- @PreDestroy注解标注的方法:使用@PreDestroy注解标注的方法会在容器关闭时调用,用于释放资源或执行其他清理操作。
- 自定义销毁方法:可以通过XML配置文件或者@Bean注解的destroyMethod属性指定自定义的销毁方法。
Spring MVC的控制器(bean)是不是单例模式(是不是线程安全)?存在什么问题?如何解决?
这个题目其实相当于问 Spring MVC的控制器是不是线程安全的,如果不是怎么解决。回答思路都是一样的,因为控制器说白了也是一个bean,bean在没有设置作用域的情况下默认就是单例的,那么单例对象存在什么问题呢?
单例对象如果在它的类中声明了成员变量时(有状态),那么存在一个并发读写该成员变量的线程安全问题。
那么1、可以设置Bean的作用域设置为原型,这样每次从容器中获取该Bean时,都会创建一个新的实例,避兔了多线程共享同一个对象实例的问题,但是会带来额外的性能开销
2、就是把类中的成员变量给声明在方法的级别中,即存放在方法里,那么它就会变成无状态的了,它在该方法的栈空间中,会随着每个方法的调用而分别进行分配和释放,也就不存在线程安全问题。但是在需要维护状态的场景下,可能需要其他方式存储状态(例如会话、请求或数据库)。
那么必须在类中声明成员变量时该如何解决线程安全问题呢?
3、可以使用ThreadLocal,把该属性绑定在本地线程中。
4、还有一种方式是使用同步锁,但是属于是下下策,会影响服务器性能,因为它会使并行变成串行。或者使用线程安全的数据结构,但是适用性不大,且增加代码复杂性。
如果Autowired的是像HttpServletRequest、HttpSession和Servlet三大作用域对象(request,session,ServletContext)时都可以直接自动注入进来,因为Spring MVC底层已经把这些对象放到ThreadLocal里面去了,所以这些成员变量可以大胆的在类里面去声明而不会造成线程安全问题。
SpringBoot底层原理 起步依赖与自动配置(无需手撸但面试高频知识点)
SpringBoot使我们能够集中精力地去关注业务功能的开发,而不用过多地关注框架本身的配置使用。SpringBoot是基于SpringFramework的(也就是Spring框架),若基于Spring框架进行项目的开发,会比较繁琐。
繁琐主要体现在两个地方:
- 在pom.xml中依赖配置比较繁琐,在项目开发时,需要自己去找到对应的依赖,还需要找到依赖它所配套的依赖以及对应版本,否则就会出现版本冲突问题。
- 在使用Spring框架进行项目开发时,需要在Spring的配置文件中做大量的配置,这就造成Spring框架入门难度较大,学习成本较高。
SpringBoot框架之所以使用起来更简单更快捷,是因为SpringBoot框架底层提供了两个非常重要的功能:一个是起步依赖,一个是自动配置。
通过SpringBoot所提供的起步依赖,就可以大大的简化pom文件当中依赖的配置。
通过自动配置的功能就可以大大的简化框架在使用时bean的声明以及bean的配置。我们只需要引入程序开发时所需要的起步依赖,项目开发时所用到常见的配置都已经有了,我们直接使用就可以了。
下面先来学习SpringBoot当中起步依赖的原理。
假如我们没有使用SpringBoot,用的是Spring框架进行web程序的开发,需要引入:spring-webmvc依赖:这是Spring框架进行web程序开发所需要的依赖、servlet-api依赖:Servlet基础依赖、jackson-databind依赖:JSON处理工具包,如果要使用AOP,还需要引入aop依赖、aspect依赖,项目中所引入的这些依赖,还需要保证版本匹配。
如果我们使用了SpringBoot只需要引入一个依赖就可以了,那就是web开发的起步依赖:springboot-starter-web。
因为Maven的依赖传递,我们只需要引入一个web开发的起步依赖,web开发所需要的所有的依赖就都有了。在SpringBoot给我们提供的这些起步依赖当中,已提供了当前程序开发所需要的所有的常见依赖。
结论:起步依赖的原理就是Maven的依赖传递。
自动配置
SpringBoot的自动配置就是当Spring容器启动后,一些配置类、bean对象就自动存入到了IOC容器中,不需要我们手动去声明,从而简化了开发,省去了繁琐的配置操作。
看下自动配置的效果,运行SpringBoot启动类:
大家会看到有两个CommonConfig,在第一个CommonConfig类中定义了一个bean对象,bean对象的名字叫reader。
在第二个CommonConfig中它的bean名字叫commonConfig,为什么还会有这样一个bean对象呢?原因是在CommonConfig配置类上添加了一个注解@Configuration,而@Configuration底层就是@Component(配置类最终也是SpringIOC容器当中的一个bean对象):
在IOC容器中除了我们自己定义的bean以外,还有很多配置类,这些配置类都是SpringBoot在启动的时候加载进来的配置类。这些配置类加载进来之后,它也会生成很多的bean对象,com.google.gson.Gson是谷歌包中提供的用来处理JSON格式数据的:
当我们想要使用这些配置类中生成的bean对象时,可以使用@Autowired就自动注入了:
@Autowired
private Gson gson;
这个bean对象怎么来的?当前项目中我们并没有声明谷歌提供的Gson这么一个bean对象。答案:SpringBoot项目在启动时通过自动配置完成了bean对象的创建。
我们知道了什么是自动配置之后,接下来我们就要来剖析自动配置的原理。
引入第三方依赖常见方案
下面通过案例,模拟在 SpringBoot项目当中,我们引入对应的依赖之后,SpringBoot是如何自动将依赖jar包当中所提供的bean以及配置类直接加载到当前项目的SpringIOC容器当中的(即自动配置的过程)。
1、在SpringBoot项目 spring-boot-web-config2 工程中,通过坐标引入itheima-utils依赖
itheima-utils:
@Component
public class TokenParser {
public void parse(){
System.out.println("TokenParser ... parse ...");
}
}
2、spring-boot-web-config2 项目的测试类中,添加测试方法
@Autowired
private ApplicationContext applicationContext;
@Test
public void testTokenParse(){
System.out.println(applicationContext.getBean(TokenParser.class));
}
3、执行测试方法
在Spring容器中没有找到com.example.TokenParse类型的bean对象
原因在我们之前讲解IOC的时候有提到过,SpringBoot项目中的@SpringBootApplication注解,具有包扫描的作用,但是它只会扫描启动类所在的当前包以及子包。当前包:com.itheima, 第三方依赖中提供的包:com.example(扫描不到)
那么如何解决以上问题?
方案1:@ComponentScan 组件扫描
修改启动类,重新执行测试方法
@SpringBootApplication
@ComponentScan({"com.itheima", "com.example"}) //指定要扫描的包
public class SpringbootWebConfig2Application {
public static void main(String[] args) {
SpringApplication.run(SpringbootWebConfig2Application.class, args);
}
}
缺点:当需要引入大量的第三方的依赖,会很繁琐,大面积的扫描性能也比较低。
结论:SpringBoot中并没有采用以上这种方案
方案2:@Import 导入
使用@Import导入的类会被Spring加载到IOC容器中,导入形式主要有以下几种:
1.导入普通类、2. 导入配置类、3. 导入ImportSelector接口实现类
1. 使用@Import导入普通类
启动类:
@Import(TokenParser.class) //导入的类会被Spring加载到IOC容器中
@SpringBootApplication
public class SpringbootWebConfig2Application {
public static void main(String[] args) {
SpringApplication.run(SpringbootWebConfig2Application.class,args);
}
}
2. 使用@Import导入配置类
itheima-utils自己准备的配置类:
@Configuration
public class HeaderConfig {
@Bean
public HeaderParser headerParser(){
return new HeaderParser();
}
@Bean
public HeaderGenerator headerGenerator(){
return new HeaderGenerator();
}
}
启动类:
@Import(HeaderConfig.class) //导入配置类
@SpringBootApplication
public class SpringbootWebConfig2Application {
public static void main(String[] args) {
SpringApplication.run(SpringbootWebConfig2Application.class, args);
}
}
3. 使用@Import导入ImportSelector接口实现类
itheima-utils自己准备的ImportSelector接口实现类:
public class MyImportSelector implements ImportSelector {
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
//返回值字符串数组(数组中封装了全限定名称的配置类)
return new String[]{"com.example.HeaderConfig"};
}
}
启动类:
@Import(MyImportSelector.class) //导入ImportSelector接口实现类
@SpringBootApplication
public class SpringbootWebConfig2Application {
public static void main(String[] args) {
SpringApplication.run(SpringbootWebConfig2Application.class, args);
}
}
上面这三种使用@Import注解的方式都可以导入第三方依赖中所提供的bean或者是配置类。
缺点:当要引入一个第三方依赖时,还要知道第三方依赖中有哪些配置类和哪些Bean对象。
结论:SpringBoot也没有使用上述三种方式,而是使用第三方依赖提供的@EnableXxxxx注解,因为依赖中到底有哪些bean和配置类第三方依赖自身最清楚,所以让第三方依赖它自己来指定要导入哪些bean对象和配置类。
方案3:使用第三方依赖提供的@EnableXxxxx注解(底层采用这个)
怎么让第三方依赖自己指定bean对象和配置类?比较常见的方案就是第三方依赖给我们提供一个注解,这个注解一般都以@EnableXxxx开头的注解,注解中封装的就是@Import注解。
itheima-utils自己准备的@EnableXxxxx注解:
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Import(MyImportSelector.class)//指定要导入哪些bean对象或配置类
public @interface EnableHeaderConfig {
}
在使用时只需在启动类上加上@EnableXxxxx注解即可
@EnableHeaderConfig //使用第三方依赖提供的Enable开头的注解
@SpringBootApplication
public class SpringbootWebConfig2Application {
public static void main(String[] args) {
SpringApplication.run(SpringbootWebConfig2Application.class, args);
}
}
@SpringBootApplication源码跟踪分析原理
下面通过源码跟踪的形式来剖析下SpringBoot底层到底是如何完成自动配置的。
在跟踪框架源码的时候,一定要抓住关键点,找到核心流程。一定不要从头到尾一行代码去看,一个方法的去研究,有精力再去研究其中的细节。
要搞清楚SpringBoot的自动配置原理,要从SpringBoot启动类上使用的核心注解@SpringBootApplication开始分析,按住ctrl进入其源码:
1.先来看第一个注解:@SpringBootConfiguration
@SpringBootConfiguration注解上使用了@Configuration,表明SpringBoot启动类就是一个配置类。
@Indexed注解,是用来加速应用启动的(不用关心)
2.再看@ComponentScan注解
@ComponentScan注解是用来进行组件扫描的,扫描启动类所在的包及其子包下所有被@Component及其衍生注解声明的类。
SpringBoot启动类,之所以具备扫描包功能,就是因为包含了@ComponentScan注解。
3.最后看@EnableAutoConfiguration注解(自动配置核心注解):
使用@Import注解,导入了实现ImportSelector接口的实现类。AutoConfigurationImportSelector类是ImportSelector接口的实现类。
AutoConfigurationImportSelector类中重写了ImportSelector接口的selectImports()方法:
selectImports()方法底层调用getAutoConfigurationEntry()方法,获取可自动配置的配置类信息集合
getAutoConfigurationEntry()方法通过调用getCandidateConfigurations(annotationMetadata, attributes)方法获取在配置文件中配置的所有自动配置类的集合
getCandidateConfigurations方法的功能:
获取所有基于METAINF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件、META-INF/spring.factories文件中配置类的集合
METAINF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件和META-INF/spring.factories文件这两个文件在哪里呢?
通常在引入的起步依赖中,都有包含以上两个文件:
在前面在给大家演示自动配置的时候,我们直接在测试类当中注入了一个叫gson的bean对象,我们没有配置bean对象,但是我们是可以直接注入使用的。原因就是因为在自动配置类当中做了自动配置。到底是在哪个自动配置类当中做的自动配置呢?我们通过搜索来查询一下。
在METAINF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports配置文件中指定了第三方依赖Gson的配置类:GsonAutoConfiguration
在GsonAutoConfiguration类上,添加了注解@AutoConfiguration,通过查看源码,可以明确:GsonAutoConfiguration类是一个配置。
综上,自动配置的原理就是在配置类中定义一个@Bean标识的方法,而Spring会自动调用配置类中使用@Bean标识的方法,并把方法的返回值注册到IOC容器中。
自动配置源码小结
自动配置原理源码入口就是@SpringBootApplication注解,在这个注解中封装了3个注解,分别是:
- @SpringBootConfiguration
- 声明当前类是一个配置类
- @ComponentScan
- 进行组件扫描(SpringBoot中默认扫描的是启动类所在的当前包及其子包)
@EnableAutoConfiguration
(就是我们上面学习的@EnableXxxxx)- 启用 Spring Boot 的自动配置机制
- 封装了
@Import
注解(Import注解中指定了一个ImportSelector接口的实现类)- 在实现类重写的selectImports()方法,读取当前项目下所有依赖jar包中META-INF/spring.factories、META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports两个文件里面定义的配置类(配置类中定义了@Bean注解标识的方法)。
当SpringBoot程序启动时,就会加载配置文件当中所定义的配置类,并将这些配置类信息(类的全限定名)封装到String类型的数组中,最终通过@Import注解将这些配置类全部加载到Spring的IOC容器中,交给IOC容器管理。
文件中定义的配置类非常多,而且每个配置类中又可以定义很多的bean,那这些bean都会注册到Spring的IOC容器中吗?
并不是。 在声明bean对象时,上面还经常有加一个以@Conditional
开头的注解,这种注解的作用就是按照条件进行装配,只有满足条件之后,才会将bean注册到Spring的IOC容器中。
@Conditional
- 作用:按照一定的条件进行判断,在满足给定条件后才会注册对应的bean对象到Spring的IOC容
器中。 - 位置:方法、类
- @Conditional本身是一个父注解,派生出大量的子注解:
- @ConditionalOnClass:判断环境中有对应字节码文件,才注册bean到IOC容 器。
- @ConditionalOnMissingBean:判断环境中没有对应的bean(类型或名称),才注册bean到IOC容器。
- @ConditionalOnProperty:判断配置文件中有对应属性和值,才注册bean到IOC容器。
常见@Conditional子注解的使用
下面通过代码来演示下Conditional注解的使用。
- @ConditionalOnClass注解
@Configuration
public class HeaderConfig {
@Bean
@ConditionalOnClass(name="io.jsonwebtoken.Jwts")//环境中存在指定的这个类,才会将该bean加入IOC容器
public HeaderParser headerParser(){
return new HeaderParser();
}
//省略其他代码...
}
- pom.xml
<!--JWT令牌-->
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.1</version>
</dependency>
- 测试类
@SpringBootTest
public class AutoConfigurationTests {
@Autowired
private ApplicationContext applicationContext;
@Test
public void testHeaderParser(){
System.out.println(applicationContext.getBean(HeaderParser.class));
}
//省略其他代码...
}
无报错通过testHeaderParser()测试方法,因为io.jsonwebtoken.Jwts字节码文件在启动SpringBoot程序时已存在,所以创建HeaderParser对象并注册到IOC容器中。
- @ConditionalOnMissingBean注解
@Configuration
public class HeaderConfig {
@Bean
@ConditionalOnMissingBean //不存在该类型的bean,才会将该bean加入IOC容器
public HeaderParser headerParser(){
return new HeaderParser();
}
//省略其他代码...
}
通过了testHeaderParser()测试方法: SpringBoot在调用@Bean标识的headerParser()前,IOC容器中是没有HeaderParser类型的bean,所以HeaderParser对象正常创建,并注册到IOC容器中。
再次修改@ConditionalOnMissingBean注解:
@Configuration
public class HeaderConfig {
@Bean
@ConditionalOnMissingBean(name="deptController2")//不存在指定名称的bean,才会将该bean加入IOC容器
public HeaderParser headerParser(){
return new HeaderParser();
}
//省略其他代码...
}
执行通过了testHeaderParser()测试方法:因为在SpringBoot环境中不存在名字叫deptController2的bean对象,所以创建HeaderParser对象并注册到IOC容器中。
再次修改@ConditionalOnMissingBean注解:
@Configuration
public class HeaderConfig {
@Bean
@ConditionalOnMissingBean(HeaderConfig.class)//不存在指定类型的bean,才会将bean加入IOC容器
public HeaderParser headerParser(){
return new HeaderParser();
}
//省略其他代码...
}
执行不通过testHeaderParser()测试方法: 因为HeaderConfig类中添加@Configuration注解,而@Configuration注解中包含了@Component,所以SpringBoot启动时会创建HeaderConfig类对象,并注册到IOC容器中。通过getBean(HeaderParser.class)方法获取bean对象时,引发异常:NoSuchBeanDefinitionException
- @ConditionalOnProperty注解(这个注解和配置文件当中配置的属性有关系)
先在application.yml配置文件中添加如下的键值对:
name: itheima
在声明bean的时候就可以指定一个条件@ConditionalOnProperty
@Configuration
public class HeaderConfig {
@Bean
@ConditionalOnProperty(name ="name",havingValue = "itheima")//配置文件中存在指定属性名与值,才会将bean加入IOC容器
public HeaderParser headerParser(){
return new HeaderParser();
}
执行通过testHeaderParser()测试方法,修改@ConditionalOnProperty注解: havingValue的值修改为"itheima2",再次执行不通过。
自定义装配条件
观察@Conditional其源码发现,其可以接受一个或多个实现了Condition接口的类,而观察Condition接口的定义可以发现它提供了一个返回值为boolean的matches方法,用来实现Bean是否能够被装载的判断逻辑。在Bean上去增加@Conditional注解,然后重写Condition接口的matches方法去自定义Bean的装载条件。
下面举例说明,比如下面这样的一个使用方法,当Spring解析这个配置类的时候,HelloService这个Bean是否能够被装载到IOC容器取决于CustomizeCondition里面的matches方法的一个返回值,返回true才可以被装载,这就给Bean的装载过程增加了很多的灵活性。
自动配置案例——阿里云starter
所谓starter指的就是SpringBoot当中的起步依赖。在SpringBoot当中已经给我们提供了很多的起步依赖了,在实际的项目开发当中,可能会用到很多第三方的技术,并不是所有的第三方的技术官方都给我们提供了与SpringBoot整合的starter起步依赖,但是这些技术又非常的通用,在很多项目组当中都在使用。
前面案例中使用了阿里云OSS对象存储服务,现在阿里云的官方是没有给我们提供对应的起步依赖的,这个时候使用起来就会比较繁琐,所以这个时候我们就可以自定义一些公共组件,在其中提前把需要配置的bean都提前配置好。将来在项目当中,想使用这个技术,直接将组件对应的坐标直接引入进来,就已经自动配置好了,可以直接使用了。
在SpringBoot项目中,一般都会将这些公共组件封装为SpringBoot当中的starter,也就是我们所说的起步依赖,starter在引用对应的autoconfigure包,在这个包中完成自动配置操作,那么将来在项目中进行项目对应功能开发只需要引入对应的starter就行了,因为它会将autoconfigure自动配置的依赖传递下来。
SpringBoot官方starter命名: spring-boot-starter-xxxx
第三方组织提供的starter命名: xxxx-spring-boot-starter
在自定义一个起步依赖starter的时候,按照规范需要定义两个模块:
- starter模块(进行依赖管理[把程序开发所需要的依赖都定义在starter起步依赖中])
- autoconfigure模块(自动配置)
案例需求:自定义aliyun-oss-spring-boot-starter,完成阿里云OSS操作工具类AliyunOSSUtils的自动配置。
目标:引入起步依赖引入之后,要想使用阿里云OSS,注入AliyunOSSUtils直接使用即可。
之前阿里云OSS的使用:
- 配置文件
#配置阿里云OSS参数
aliyun:
oss:
endpoint: https://oss-cn-shanghai.aliyuncs.com
accessKeyId: #密钥省略
accessKeySecret: #省略
bucketName: web-framework01
#这个是老版本的用法,最新版本accessKeyId和accessKeySecret已经无需以明文的方式放在代码中,而是存放在环境变量中,这里为了演示案例继续用老版本的代码
- AliOSSProperties类
@Data
@Component
@ConfigurationProperties(prefix = "aliyun.oss")
public class AliOSSProperties {
//区域
private String endpoint;
//身份ID
private String accessKeyId ;
//身份密钥
private String accessKeySecret ;
//存储空间
private String bucketName;
}
- AliOSSUtils工具类
@Component //当前类对象由Spring创建和管理
public class AliOSSUtils {
@Autowired
private AliOSSProperties aliOSSProperties;
/**
* 实现上传图片到OSS
*/
public String upload(MultipartFile multipartFile) throws IOException {
// 获取上传的文件的输入流
InputStream inputStream = multipartFile.getInputStream();
// 避免文件覆盖
String originalFilename = multipartFile.getOriginalFilename();
String fileName = UUID.randomUUID().toString() + originalFilename.substring(originalFilename.lastIndexOf("."));
//上传文件到 OSS
OSS ossClient = new OSSClientBuilder().build(aliOSSProperties.getEndpoint(),
aliOSSProperties.getAccessKeyId(), aliOSSProperties.getAccessKeySecret());
ossClient.putObject(aliOSSProperties.getBucketName(), fileName, inputStream);
//文件访问路径
String url =aliOSSProperties.getEndpoint().split("//")[0] + "//" + aliOSSProperties.getBucketName() + "." + aliOSSProperties.getEndpoint().split("//")[1] + "/" + fileName;
// 关闭ossClient
ossClient.shutdown();
return url;// 把上传到oss的路径返回
}
}
需求明确了,接下来我们再来分析一下具体的实现步骤:
- 第1步:创建自定义starter模块(进行依赖管理)
- 把阿里云OSS所有的依赖统一管理起来
- 第2步:创建autoconfigure模块
- 在starter中引入autoconfigure (我们使用时只需要引入starter起步依赖即可)
- 第3步:在autoconfigure中完成自动配置
- 定义一个自动配置类,在自动配置类中将所要配置的bean都提前配置好
- 定义配置文件,把自动配置类的全类名定义在配置文件中
首先我们先来创建两个Maven模块:
1). aliyun-oss-spring-boot-starter模块
创建完starter模块后,删除多余的文件,最终保留内容如下:
删除pom.xml文件中多余的内容后:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.7.5</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.aliyun.oss</groupId>
<artifactId>aliyun-oss-spring-boot-starter</artifactId>
<version>0.0.1-SNAPSHOT</version>
<properties>
<java.version>11</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
</dependencies>
</project>
2). aliyun-oss-spring-boot-autoconfigure模块
创建完starter模块后,删除多余的文件,最终保留内容如下:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.7.5</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.aliyun.oss</groupId>
<artifactId>aliyun-oss-spring-boot-autoconfigure</artifactId>
<version>0.0.1-SNAPSHOT</version>
<properties>
<java.version>11</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
</dependencies>
</project>
按照我们之前的分析,是需要在starter模块中来引入autoconfigure这个模块的。打开starter模块中的pom文件:
<!--引入autoconfigure模块-->
<dependency>
<groupId>com.aliyun.oss</groupId>
<artifactId>aliyun-oss-spring-boot-autoconfigure</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
前两步已经完成了,接下来是最关键的就是第三步,在autoconfigure模块当中来完成自动配置操作。我们将之前案例中所使用的阿里云OSS部分的代码直接拷贝到autoconfigure模块下,然后进行改造就行了。
拷贝过来后,还缺失一些相关的依赖,需要把相关依赖也拷贝过来:
<!--引入web起步依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--Lombok-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<!--阿里云OSS-->
<dependency>
<groupId>com.aliyun.oss</groupId>
<artifactId>aliyun-sdk-oss</artifactId>
<version>3.15.1</version>
</dependency>
<dependency>
<groupId>javax.xml.bind</groupId>
<artifactId>jaxb-api</artifactId>
<version>2.3.1</version>
</dependency>
<dependency>
<groupId>javax.activation</groupId>
<artifactId>activation</artifactId>
<version>1.1.1</version>
</dependency>
<!-- no more than 2.3.3-->
<dependency>
<groupId>org.glassfish.jaxb</groupId>
<artifactId>jaxb-runtime</artifactId>
<version>2.3.3</version>
</dependency>
因为在SpringBoot项目中,并不会去扫描com.aliyun.oss这个包,不扫描这个包那
类上的注解也就失去了作用,所以删除两个类中的@Component注解、@Autowired注解。
下面我们就要定义一个自动配置类了,在自动配置类当中来声明AliOSSUtils的bean对象。
AliOSSAutoConfiguration类:
@Configuration//当前类为Spring配置类
@EnableConfigurationProperties(AliOSSProperties.class)//直接导入AliOSSProperties类,并交给SpringIOC管理,因为AliOSSProperties现在没有@Component了,但是我们这里又需要用到AliOSSProperties对象
//这个注解只能用在配置类上或者声明Bean的方法上 底层封装的也还是@import
public class AliOSSAutoConfiguration {
//创建AliOSSUtils对象,并交给SpringIOC容器
@Bean
public AliOSSUtils aliOSSUtils(AliOSSProperties aliOSSProperties){
AliOSSUtils aliOSSUtils = new AliOSSUtils();
aliOSSUtils.setAliOSSProperties(aliOSSProperties);
return aliOSSUtils;
}
}
AliOSSProperties类:
/*阿里云OSS相关配置*/
@Data
@ConfigurationProperties(prefix = "aliyun.oss")
public class AliOSSProperties {
//区域
private String endpoint;
//身份ID
private String accessKeyId ;
//身份密钥
private String accessKeySecret ;
//存储空间
private String bucketName;
}
AliOSSUtils类:
@Data
public class AliOSSUtils {
private AliOSSProperties aliOSSProperties;
/**
* 实现上传图片到OSS
*/
public String upload(MultipartFile multipartFile) throws IOException {
// 获取上传的文件的输入流
InputStream inputStream = multipartFile.getInputStream();
// 避免文件覆盖
String originalFilename = multipartFile.getOriginalFilename();
String fileName = UUID.randomUUID().toString() + originalFilename.substring(originalFilename.lastIndexOf("."));
//上传文件到 OSS
OSS ossClient = new OSSClientBuilder().build(aliOSSProperties.getEndpoint(),
aliOSSProperties.getAccessKeyId(), aliOSSProperties.getAccessKeySecret());
ossClient.putObject(aliOSSProperties.getBucketName(), fileName, inputStream);
//文件访问路径
String url =aliOSSProperties.getEndpoint().split("//")[0] + "//" + aliOSSProperties.getBucketName() + "." + aliOSSProperties.getEndpoint().split("//")[1] + "/" + fileName;
// 关闭ossClient
ossClient.shutdown();
return url;// 把上传到oss的路径返回
}
}
最后在aliyun-oss-spring-boot-autoconfigure模块中的resources下,新建自动配置文件:
- META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
com.aliyun.oss.AliOSSAutoConfiguration
至此阿里云起步依赖配置完毕,可以新建一个test工程,在工程里引用阿里云starter依赖,通过依赖传递,会把autoconfigure依赖也引入了。
<!--引入阿里云OSS起步依赖-->
<dependency>
<groupId>com.aliyun.oss</groupId>
<artifactId>aliyun-oss-spring-boot-starter</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
在test工程中的application.yml文件中,配置阿里云OSS配置参数信息(从以前的工程中拷贝即可)
#配置阿里云OSS参数
aliyun:
oss:
endpoint: https://oss-cn-shanghai.aliyuncs.com
accessKeyId: #密钥省略
accessKeySecret: #省略
bucketName: web-framework01
在test工程中的UploadController类编写测试代码
@RestController
public class UploadController {
@Autowired
private AliOSSUtils aliOSSUtils;
@PostMapping("/upload")
public String upload(MultipartFile image) throws Exception {
//上传文件到阿里云 OSS
String url = aliOSSUtils.upload(image);
return url;
}
}
随着SpringBoot项目启动,自动配置会把AliOSSUtils的bean对象装配到IOC容器中
postman测试上传图片:
到此基于SpringBoot进行web后端开发的相关知识我们已经学习完毕了。
Web后端开发总结(概念八股)
回顾一下关于web后端开发,我们都学习了哪些内容,以及每一块知识,具体是属于哪个框架的。
web后端开发现在基本上都是基于标准的三层架构进行开发的,Controller控制器
层负责接收请求响应数据,Service业务层负责具体的业务逻辑处理,而Dao数据访问层也叫持久层,就是用来处理数据访问操作的,来完成数据库当中数据的增删改查操作。
如果我们在执行具体的业务处理之前,需要去做一些通用的业务处理,比如:我们要进行统一的登录校验,我们要进行统一的字符编码等这些操作时,我们就可以借助于Javaweb当中三大组件之一的过滤器Filter或者是Spring当中提供的拦截器Interceptor来实现。
而为了实现三层架构层与层之间的解耦,我们学习了Spring框架当中的第一大核心:IOC控制反转(将对象创建的控制权由应用程序自身交给外部IOC容器)与DI依赖注入(容器为程序提供运行时所需要的资源)。
除了IOC与DI我们还讲到了AOP面向切面编程,还有Spring中的事务管理、全局异常处理器,以及传递会话技术Cookie、Session以及新的会话跟踪解决方案JWT令牌,阿里云OSS对象存储服务,以及通过Mybatis持久层架构操作数据库等技术。
Filter过滤器、Cookie、 Session这些都是传统的JavaWeb提供的技术。
JWT令牌、阿里云OSS对象存储服务,是现在企业项目中常见的一些解决方案。
IOC控制反转、DI依赖注入、AOP面向切面编程、事务管理、全局异常处理、拦截器等,这些技术都是 Spring Framework框架当中提供的核心功能。
Mybatis就是一个持久层的框架,是用来操作数据库的。
在Spring框架的生态中,对web程序开发提供了很好的支持,如:全局异常处理器、拦截器这些都是Spring框架中web开发模块所提供的功能,而Spring框架的web开发模块,我们也称为:SpringMVC
SpringMVC不是一个单独的框架,它是Spring框架的一部分,是Spring框架中的web开发模块,是用来简化原始的Servlet程序开发的。
外界俗称的SSM,就是由:SpringMVC、Spring Framework、Mybatis三块组成。基于传统的SSM框架进行整合开发项目会比较繁琐,而且效率也比较低,所以在现在的企业项目开发当中,基本上都是直接基于SpringBoot整合SSM进行项目开发的。
Spring MVC是什么,核心是什么,以及它的执行流程?
Spring MVC呢是属于Spring Framwork生态里面的个模块,它是在Servlet的基础上构建并且使用了MVC模式设计的一个Web框架,它的主要目的是为了去简化传统的Servlet+JSP模式下的Web开发方式。其次啊Spring MVC的整个架构设计呢是对Java Web里面的MVC框架模式做了一些增强和扩展,所以Spring MVC天生就是为了MVC模式而设计的,因此啊在开发MVC应用的时候会更加方便和灵活。
增强和扩展主要体现的几个方面:
1、把传统MVC框架里面的Controller控制器做了拆分,分成了前端控制器
DispatcherServlet和后端控制器Controller
2.把Model模型拆分成业务层Service和数据访问层Repository
3.在视图层,可以支持不同的视图,比如Freemark、velocity、JSP等等
Spring MVC的核心啊是DispatcherServlet,它是整个流程控制的核心,负责把用户的请求分发到不同的处理器进行处理,Spring MVC的执行流程呢大致可以分为几个步骤。
一、用户发送请求到前端控制器DispatcherServlet
二、DispatcherServlet收到请求以后,利用HandlerMapping来查询一个或者多个HandlerExecutionChain
三、DispatcherServlet把请求发送到HandlerAdapter处理器适配器,这个处理器适配器会按照特定的规则去执行Handler处理器
四、Handler执行完成以后会返回一个ModlelAndView对象
五、HandlerAdapter把Handler执行的结果ModelAndView返回给DispatcherServlet
六、DispatcherServlet把ModelAndView传给ViewReslover视图解析器进行解析
最后DispatcherServlet把返回值返回给请求者。以上呢就是Spring MVC的核心以及它的执行流程,在实际的项目中我们会根据自己的需求去编写Controller、Model和View
@Autowird 与 @Resource的区别
@Autowired 是spring框架提供的注解,而@Resource是JDK提供的注解
@Autowired 默认是按照类型注入,IOC容器中有多个相同类型的bean实例会报错,可以通过上面的@Primary或者@Qualifier解决。@Autowired里面还有一个required属性,默认是true表示强制要求bean注入,应用启动时如果ioc容器中没有对应类型bean就会报错,设置false就不会。
@Resource它有两个属性name和type,可以指定通过bean的类型或者名称两种方式来注入,都没有指定则优先按照bean实例名称注入,都没匹配到就会报错。
过滤器与拦截器的区别
过滤器:
- Filter表示过滤器,是 JavaWeb三大组件(Servlet、Filter、Listener)之一。
- 过滤器可以把对资源的请求拦截下来,从而实现一些特殊的功能
-
- 使用了过滤器之后,要想访问web服务器上的资源,必须先经过滤器处理完毕之后,才可以访问对应资源。
- 过滤器一般完成一些通用的操作,比如:登录校验、统一编码处理、敏感字符处理等。
拦截器
- 是一种动态拦截方法调用的机制,类似于过滤器。拦截器是Spring框架中提供的,用来动态拦截控制器方法的执行。
整个流程如上图所示。
当浏览器来访问部署在web服务器当中的web应用时,定义的过滤器会拦截到这次请求。拦截后,先执行放行前逻辑,然后再执行放行操作。而由于我们当前是基于springboot开发的,所以放行之后是进入到了spring的环境当中,也就是要来访问我们所定义的controller当中的接口方法。
Tomcat并不识别所编写的Controller程序,但是它识别Servlet程序,所以在Spring的Web环境中提供了一个非常核心的Servlet:DispatcherServlet(前端控制器),所有请求都会先行到DispatcherServlet,再将请求转给Controller。
在controller当中的方法执行完毕之后,再回过来执行postHandle() 这个方法以及afterCompletion() 方法,然后再返回给DispatcherServlet,最终再来执行过滤器当中放行后的这一部分逻辑的逻辑。执行完毕之后,最终给浏览器响应数据。
所以区别主要是两点:
接口规范不同:过滤器需要实现Filter接口,而拦截器需要实现HandlerInterceptor接口。
拦截范围不同:过滤器Filter会拦截所有的资源,而Interceptor只会拦截Spring环境中的资源。