spring

Spring有很多优点：

IOC 和 DI 的支持：控制反转和依赖注入。
AOP 编程的支持：可以方便的实现对程序进行权限拦截、运行监控等切面功能。
声明式事务的支持：支持通过配置就来完成对事务的管理，而不需要通过硬编码的方式。
快捷测试的支持：对 Junit 提供支持，可以通过注解快捷地测试。
快速集成功能：其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz 等）的直接支持。
复杂API模板封装：JDBC、JavaMail、远程调用等）都提供了模板化的封装，这些封装 API 的提供使得应用难度大大降低。

Spring框架中有许多常用的注解

@Component： 通用的组件注解，用于标识一个类为Spring的组件，让Spring可以扫描并将其作为Bean进行管理。

@Repository： 用于标识一个类为数据访问层组件，通常用于DAO类。

@Service： 用于标识一个类为业务逻辑层组件，通常用于Service类。

@Controller： 用于标识一个类为控制器组件，通常用于Spring MVC中的Controller类。

@Configuration： 用于标识一个类为配置类，通常与@Bean注解一起使用，用于替代xml配置文件。

@Autowired： 用于自动装配Bean，可以用在字段、构造器、Setter方法上。

@Qualifier： 与@Autowired一起使用，用于指定注入的Bean的名称。

@Value： 用于注入属性值，可以用在字段、构造器、方法上。

@Bean： 用于定义Bean，通常用在@Configuration注解的类中。

@Scope： 用于定义Bean的作用域，如singleton、prototype等。

@PostConstruct： 用于指定初始化方法，在Bean初始化之后调用。

@PreDestroy： 用于指定销毁方法，在Bean销毁之前调用。

@Aspect： 用于定义切面，结合其他注解如@Before、@After等实现AOP功能。

@Transactional： 用于声明事务，通常用在Service层的方法上。

Spring 框架中广泛使用了不同类型的设计模式，下面我们来看看到底有哪些设计模式?

工厂模式 : Spring 容器本质是一个大工厂，使用工厂模式通过 BeanFactory、ApplicationContext 创建 bean 对象。
代理模式 : Spring AOP 功能功能就是通过代理模式来实现的，分为动态代理和静态代理。
单例模式 : Spring 中的 Bean 默认都是单例的，这样有利于容器对Bean的管理。
模板模式 : Spring 中 JdbcTemplate、RestTemplate 等以 Template结尾的对数据库、网络等等进行操作的模板类，就使用到了模板模式。
观察者模式: Spring 事件驱动模型就是观察者模式很经典的一个应用。
适配器模式 :Spring AOP 的增强或通知 (Advice) 使用到了适配器模式、Spring MVC 中也是用到了适配器模式适配 Controller。
策略模式：Spring中有一个Resource接口，它的不同实现类，会根据不同的策略去访问资源。

说一说什么是IOC？什么是DI?

所谓的IOC（控制反转）：就是由容器来负责控制对象的生命周期和对象间的关系。以前是我们想要什么，就自己创建什么，现在是我们需要什么，容器就给我们送来什么。

DI（依赖注入）：指的是容器在实例化对象的时候把它依赖的类注入给它。有的说法IOC和DI是一回事，有的说法是IOC是思想，DI是IOC的实现。

为什么要使用IOC呢？
最主要的是两个字解耦，硬编码会造成对象间的过度耦合，使用IOC之后，我们可以不用关心对象间的依赖，专心开发应用就行。

能简单说一下Spring IOC的实现机制吗？

配置文件
首先，我们需要在配置文件中定义Bean。Spring支持多种配置方式，包括XML配置、注解配置和Java Config配置等。其中，XML配置是最常用的一种方式。

加载配置文件
接下来，Spring IOC容器需要加载配置文件，并解析其中的Bean定义。在解析过程中，容器会根据配置信息创建相应的BeanDefinition对象，并将其保存在内存中。

创建Bean实例
当容器需要某个Bean时，它会根据对应的BeanDefinition创建该Bean的实例。这通常是通过Java的反射机制来实现的，即根据Bean的类名使用Class.forName()方法获取对应的Class对象，然后调用newInstance()方法创建实例。

依赖注入
在创建Bean实例后，容器会检查该Bean是否依赖其他Bean。如果存在依赖关系，容器会根据配置信息自动将依赖的Bean注入到目标Bean中。注入方式有多种，包括构造函数注入、Setter方法注入和字段注入。

生命周期管理
在完成依赖注入后，容器会调用Bean的初始化方法（如果有定义的话），进行必要的初始化操作。同时，容器还会监控Bean的生命周期，在容器关闭时销毁Bean实例。

说说BeanFactory和ApplicantContext?

BeanFactory是类的通用工厂，可以创建并管理各种类的对象。
ApplicationContext由BeanFactory派生而来，提供了更多面向实际应用的功能。可以这么说，使用BeanFactory就是手动档，使用ApplicationContext就是自动档。
BeanFactory是延时加载，也就是说在容器启动时不会注入bean，而是在需要使用bean的时候，才会对该bean进行加载实例化。
ApplicationContext 是在容器启动的时候，一次性创建所有的bean，所以运行的时候速度相对BeanFactory比较快

你知道Spring容器启动阶段会干什么吗？

加载配置文件：Spring启动时会加载配置文件，例如application.properties或application.yml等。这些配置文件中包含了Spring应用程序所需的各种配置信息，例如数据库连接参数、日志配置、缓存配置等。

创建并管理Bean实例：Bean是Spring的基本组件，它代表了应用程序中的各种对象。Spring启动时会根据配置信息创建并管理这些Bean实例。Spring支持多种方式创建Bean，例如通过配置文件、注解、Java代码等。

扫描和注册组件：Spring启动时会扫描指定的包路径，查找被Spring管理的组件，例如带有@Component注解的类。然后将这些组件注册到Spring上下文中，供其他组件使用。

处理依赖注入：依赖注入是Spring的核心特性之一，它可以自动将一个组件所依赖的其他组件注入到它的属性中。Spring启动时会处理组件之间的依赖关系，将依赖的组件注入到相应的属性中。

初始化和销毁Bean：在创建Bean实例后，Spring可以对其进行初始化和销毁的操作。例如，可以调用Bean的初始化方法进行初始化，或者在应用程序关闭时调用Bean的销毁方法进行清理工作。

启动应用程序：最后，Spring启动会将整个应用程序启动起来，开始处理用户的请求。Spring提供了各种方式来处理请求，例如通过控制器、AOP、事务等。

总的来说，Spring启动主要是为了加载配置文件、创建并管理Bean实例、扫描和注册组件、处理依赖注入、初始化和销毁Bean，并最终启动应用程序。 这些工作使得Spring能够方便地管理和组织应用程序的各个组件，提供灵活、可扩展的开发环境。

能说一下Spring Bean生命周期吗？

Spring IOC 中Bean的生命周期大致分为四个阶段：实例化（Instantiation）、属性赋值（Populate）、初始化（Initialization）、销毁（Destruction）。

Bean定义和依赖定义有哪些方式？
直接编码方式：我们一般接触不到直接编码的方式，但其实其它的方式最终都要通过直接编码来实现。
配置文件方式：通过xml、propreties类型的配置文件，配置相应的依赖关系，Spring读取配置文件，完成依赖关系的注入。
注解方式：注解方式应该是我们用的最多的一种方式了，在相应的地方使用注解修饰，Spring会扫描注解，完成依赖关系的注入。

Spring提供了哪几种自动装配类型？
byName：根据名称进行自动匹配，假设Boss又一个名为car的属性，如果容器中刚好有一个名为car的bean，Spring就会自动将其装配给Boss的car属性
byType：根据类型进行自动匹配，假设Boss有一个Car类型的属性，如果容器中刚好有一个Car类型的Bean，Spring就会自动将其装配给Boss这个属性
constructor：与 byType类似， 只不过它是针对构造函数注入而言的。如果Boss有一个构造函数，构造函数包含一个Car类型的入参，如果容器中有一个Car类型的Bean，则Spring将自动把这个Bean作为Boss构造函数的入参；如果容器中没有找到和构造函数入参匹配类型的Bean，则Spring将抛出异常。
autodetect：根据Bean的自省机制决定采用byType还是constructor进行自动装配，如果Bean提供了默认的构造函数，则采用byType，否则采用constructor。

Spring 中的 Bean 的作用域有哪些?

singleton : 在Spring容器仅存在一个Bean实例，Bean以单实例的方式存在，是Bean默认的作用域。
prototype : 每次从容器重调用Bean时，都会返回一个新的实例。
以下三个作用域于只在Web应用中适用：

request : 每一次HTTP请求都会产生一个新的Bean，该Bean仅在当前HTTP Request内有效。
session : 同一个HTTP Session共享一个Bean，不同的HTTP Session使用不同的Bean。
globalSession：同一个全局Session共享一个Bean，只用于基于Protlet的Web应用，Spring5中已经不存在了。

Spring 中的单例 Bean 会存在线程安全问题吗？

Spring中的单例Bean不是线程安全的。因为单例Bean，是全局只有一个Bean，所有线程共享。 如果说单例Bean，是一个无状态的，也就是线程中的操作不会对Bean中的成员变量执行查询以外的操作，那么这个单例Bean是线程安全的。比如Spring mvc 的 Controller、Service、Dao等，这些Bean大多是无状态的，只关注于方法本身。

假如这个Bean是有状态的，也就是会对Bean中的成员变量进行写操作，那么可能就存在线程安全的问题。

单例Bean线程安全问题怎么解决呢？

将Bean定义为多例
这样每一个线程请求过来都会创建一个新的Bean，但是这样容器就不好管理Bean，不能这么办。

将Bean中的成员变量保存在ThreadLocal中⭐
我们知道ThredLoca能保证多线程下变量的隔离，可以在类中定义一个ThreadLocal成员变量，将需要的可变成员变量保存在ThreadLocal里，这是推荐的一种方式。

说说循环依赖?

简单说就是自己依赖自己，或者和别的Bean相互依赖。只有单例的Bean才存在循环依赖的情况，原型(Prototype)情况下，Spring会直接抛出异常。 原因很简单，AB循环依赖，A实例化的时候，发现依赖B，创建B实例，创建B的时候发现需要A，创建A1实例……无限套娃，直接把系统干垮。

Spring可以解决哪些情况的循环依赖？

当循环依赖的实例都采用setter方法注入的时候，Spring可以支持，都采用构造器注入的时候，不支持

那Spring怎么解决循环依赖的呢？

Spring 通过三级缓存解决了循环依赖：

一级缓存 : Map<String,Object> singletonObjects，单例池，用于保存实例化、属性赋值（注入）、初始化完成的 bean 实例
二级缓存 : Map<String,Object> earlySingletonObjects，早期曝光对象，用于保存实例化完成的 bean 实例
三级缓存 : Map<String,ObjectFactory<?>> singletonFactories，早期曝光对象工厂，用于保存 bean 创建工厂，以便于后面扩展有机会创建代理对象。

A实例的初始化过程：

创建A实例，实例化的时候把A对象⼯⼚放⼊三级缓存，表示A开始实例化了，虽然我这个对象还不完整，但是先曝光出来让大家知道
A注⼊属性时，发现依赖B，此时B还没有被创建出来，所以去实例化B同样，B注⼊属性时发现依赖A，它就会从缓存里找A对象。依次从⼀级到三级缓存查询A，从三级缓存通过对象⼯⼚拿到A，发现A虽然不太完善，但是存在，把A放⼊⼆级缓存，同时删除三级缓存中的A，此时，B已经实例化并且初始化完成，把B放入⼀级缓存。接着A继续属性赋值，顺利从⼀级缓存拿到实例化且初始化完成的B对象，A对象创建也完成，删除⼆级缓存中的A，同时把A放⼊⼀级缓存

最后，⼀级缓存中保存着实例化、初始化都完成的A、B对象

为什么要三级缓存？⼆级不⾏吗？

不行，主要是为了⽣成代理对象。如果是没有代理的情况下，使用二级缓存解决循环依赖也是OK的。但是如果存在代理，三级没有问题，二级就不行了。

因为三级缓存中放的是⽣成具体对象的匿名内部类，获取Object的时候，它可以⽣成代理对象，也可以返回普通对象。使⽤三级缓存主要是为了保证不管什么时候使⽤的都是⼀个对象。

假设只有⼆级缓存的情况，往⼆级缓存中放的显示⼀个普通的Bean对象，Bean初始化过程中，通过 BeanPostProcessor 去⽣成代理对象之后，覆盖掉⼆级缓存中的普通Bean对象，那么可能就导致取到的Bean对象不一致了。

AOP

AOP 的核心其实就是动态代理，如果是实现了接口的话就会使用 JDK 动态代理，否则使用 CGLIB 代理，主要应用于处理一些具有横切性质的系统级服务，如日志收集、事务管理、安全检查、缓存、对象池管理等。

AOP有哪些核心概念？

切面（Aspect）：类是对物体特征的抽象，切面就是对横切关注点的抽象

连接点（Joinpoint）：被拦截到的点，因为 Spring 只支持方法类型的连接点，所以在 Spring中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器

切点（Pointcut）：对连接点进行拦截的定位

通知（Advice）：所谓通知指的就是指拦截到连接点之后要执行的代码，也可以称作增强

目标对象 （Target）：代理的目标对象

织入（Weabing）：织入是将增强添加到目标类的具体连接点上的过程。

AOP有哪些环绕方式？

AOP 一般有 5 种环绕方式：

前置通知 (@Before)
返回通知 (@AfterReturning)
异常通知 (@AfterThrowing)
后置通知 (@After)
环绕通知 (@Around)
多个切面的情况下，可以通过 @Order 指定先后顺序，数字越小，优先级越高。

说说JDK 动态代理和 CGLIB 代理 ？

Spring的AOP是通过动态代理来实现的，动态代理主要有两种方式JDK动态代理和Cglib动态代理，这两种动态代理的使用和原理有些不同。

说说Spring AOP 和 AspectJ AOP 区别?

Spring AOP 属于运行时增强，主要具有如下特点：

基于动态代理来实现，默认如果使用接口的，用 JDK 提供的动态代理实现，如果是方法则使用 CGLIB 实现

Spring AOP 需要依赖 IOC 容器来管理，并且只能作用于 Spring 容器，使用纯 Java 代码实现
在性能上，由于 Spring AOP 是基于动态代理来实现的，在容器启动时需要生成代理实例，在方法调用上也会增加栈的深度，使得 Spring AOP 的性能不如 AspectJ 的那么好。

Spring AOP 致力于解决企业级开发中最普遍的 AOP(方法织入)。

AspectJ 是一个易用的功能强大的 AOP 框架，属于编译时增强， 可以单独使用，也可以整合到其它框架中，是 AOP 编程的完全解决方案。AspectJ 需要用到单独的编译器 ajc。

AspectJ 属于静态织入，通过修改代码来实现，在实际运行之前就完成了织入，所以说它生成的类是没有额外运行时开销的，一般有如下几个织入的时机：

编译期织入（Compile-time weaving）：如类 A 使用 AspectJ 添加了一个属性，类 B 引用了它，这个场景就需要编译期的时候就进行织入，否则没法编译类 B。

编译后织入（Post-compile weaving）：也就是已经生成了 .class 文件，或已经打成 jar 包了，这种情况我们需要增强处理的话，就要用到编译后织入。

类加载后织入（Load-time weaving）：指的是在加载类的时候进行织入，要实现这个时期的织入，有几种常见的方法

Spring 事务的本质其实就是数据库对事务的支持，没有数据库的事务支持，Spring 是无法提供事务功能的。 Spring 只提供统一事务管理接口，具体实现都是由各数据库自己实现，数据库事务的提交和回滚是通过数据库自己的事务机制实现。

Spring 事务的种类？

Spring 支持编程式事务管理和声明式事务管理两种方式：

编程式事务管理使用 TransactionTemplate，需要显式执行事务。
声明式事务管理建立在 AOP 之上的。 其本质是通过 AOP 功能，对方法前后进行拦截，将事务处理的功能编织到拦截的方法中，也就是在目标方法开始之前启动一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务

优点是不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明或通过 @Transactional 注解的方式，便可以将事务规则应用到业务逻辑中，减少业务代码的污染。 唯一不足地方是，最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。

Spring 的事务隔离级别？

Spring的接口TransactionDefinition中定义了表示隔离级别的常量，当然其实主要还是对应数据库的事务隔离级别：

ISOLATION_DEFAULT：使用后端数据库默认的隔离级别，MySQL 默认可重复读，Oracle 默认读已提交。
ISOLATION_READ_UNCOMMITTED：读未提交
ISOLATION_READ_COMMITTED：读已提交
ISOLATION_REPEATABLE_READ：可重复读
ISOLATION_SERIALIZABLE：串行化

Spring 的事务传播机制？

REQUIRED这是默认的传播机制，我们最常用的一种，也是@Transactional默认的一种。如果当前没有事务，则自己新建一个事务，如果当前存在事务，则加入这个事务

声明式事务在哪些情况下会失效？

@Transactional 应用在非 public 修饰的方法上
@Transactional 注解属性 propagation 设置错误
@Transactional 注解属性 rollbackFor 设置错误
同一个类中方法调用，导致@Transactional失效

Spring MVC 的工作流程？

SpringMVC Restful风格的接口的流程是什么样的呢？

我们都知道Restful接口，响应格式是json，这就用到了一个常用注解：@ResponseBody

介绍一下SpringBoot，有哪些优点？

Spring Boot 以约定大于配置核心思想开展工作，相比Spring具有如下优势：
Spring Boot 可以快速创建独立的Spring应用程序。
Spring Boot 内嵌了如Tomcat，Jetty和Undertow这样的容器，也就是说可以直接跑起来，用不着再做部署工作了。
Spring Boot 无需再像Spring一样使用一堆繁琐的xml文件配置。
Spring Boot 可以自动配置(核心)Spring。SpringBoot将原有的XML配置改为Java配置，将bean注入改为使用注解注入的方式(@Autowire)，并将多个xml、properties配置浓缩在一个appliaction.yml配置文件中。
Spring Boot 提供了一些现有的功能，如量度工具，表单数据验证以及一些外部配置这样的一些第三方功能。
Spring Boot 可以快速整合常用依赖（开发库，例如spring-webmvc、jackson-json、validation-api和tomcat等），提供的POM可以简化Maven的配置。当我们引入核心依赖时，SpringBoot会自引入其他依赖。

SpringBoot自动配置原理了解吗？

SpringBoot开启自动配置的注解是 @EnableAutoConfiguration ，启动类上的注解@SpringBootApplication是一个复合注解，包含了@EnableAutoConfiguration：

Springboot 启动原理？

SpringApplication 这个类主要做了以下四件事情：

推断应用的类型是普通的项目还是 Web 项目
查找并加载所有可用初始化器 ， 设置到 initializers 属性中
找出所有的应用程序监听器，设置到 listeners 属性中
推断并设置 main 方法的定义类，找到运行的主类

aop实现方式

方式一 使用SpringAPI接口:如果接口记不住或者接口找不到就没办法实现
方式二 自定义类实现：需要在ApplicationContext.xml中注册AOP
方式三 注解实现AOP：注解实现其实就是用注解来替代之前的xml配置。 即可以用@Aspect来标注类，表示该类为一个切面，用@Before标注类中方法，表示该方法为前置方法，注解中的参数即为切入点的位置。

@Bean一般搭配哪些注解使用

@Bean可以与 @Configuration和@Component 注解一起使用(@Configuration和@Component是方法级别的注解)。在默认情况下@Bean注解所产生的Bean是单例模式的，此外，@Bean还可以与@Scope,@Lazy,@DependOn和@Primary注解一起使用。

@Transactional 注解

超时时间 ( @Transactional ( timeout = 30 ) ): 定义一个事务执行过程多久算超时，以便超时后回滚。可以防止长期运行的事务占用资源.对应注解中的属性 timeout （注意点：这个超时时间在数据库事务超时的范畴内的）

是否只读 ( @Transactional ( readOnly = true ) )：表示这个事务只读取数据但不更新数据

回滚机制（ @Transactional ( rollbackFor = Exception.class ）：定义遇到异常时回滚策略

传播机制（ @Transactional ( propagation = Propagation.REQUIRED ）: 对事务的传播特性进行定义，共有 7 种类型 （一个事务内调用另外一个事务）

常见的 @Transactional 注解 事务没生效的场景

1、访问权限问题 (只有 public 方法会生效)：如果我们自定义的事务方法（即目标方法），它的访问权限不是 public，而是 private、 default 或 protected 的话， Spring 则不会提供事务功能

2、方法用 final 修饰，不会生效：Spring 事务底层使用了 AOP，也就是通过 JDK 动态代理或者 CGLIB，帮我们生成了代理类，在代理类中实现的事务功能。但如果某个方法用 final 修饰了，那么在它的代理类中，就无法重写该方法，而添加事务功能。

注意：如果某个方法是 static 修饰的，同样无法通过动态代理，变成事务方法。

3、同一个方法内直接调用，会造成事务失效：我们看到在事务方法 add 中，直接调用事务方法 updateStatus。从前面介绍的内容可以知道， updateStatus 方法拥有事务的能力是因为 Spring AOP 生成代理了对象，但是这种方法直接调用了 this 对象的方法，并不会从 IOC 拿到加上 AOP 事务相关方法的动态代理对象 所以 updateStatus 方法不会生成事务

4、(类本身) 未被 Spring 管理：使用 Spring 事务的前提是：对象要被 Spring IOC 管理，需要创建 bean 实例

5、多线程调用
6、错误的传播特性
7、自己吞了异常
8、抛出的异常，事务管理器处理不了，则不会回滚

9、数据库引擎不支持事务
比如 Mysql 中的 MyISAM 引擎是不支持事务操作的， InnoDB 才是支持事务的引擎

BeanFactory与FactoryBean的区别

BeanFactory：管理Bean的工厂
BeanFactory是Spring框架中的一个核心接口，用于管理和维护Bean的定义、创建和生命周期。 它是Spring IoC（控制反转）容器的基础，负责从配置文件或者注解中读取Bean的定义信息，并根据需要创建相应的Bean实例。BeanFactory的主要职责包括：

解析配置文件，读取Bean的定义信息。
实例化Bean，处理依赖注入。
管理Bean的作用域和生命周期。

FactoryBean：定制化的Bean创建
与BeanFactory不同，FactoryBean是一个接口，允许开发者创建定制化的Bean创建逻辑。通过实现FactoryBean接口，开发者可以控制Bean的创建过程，从而实现更加灵活和复杂的Bean实例化。FactoryBean的主要特点包括：

定制化：通过FactoryBean，可以创建复杂的Bean实例，实现更加灵活的初始化逻辑。
实现接口：FactoryBean接口包含两个主要方法：getObject()用于返回Bean实例，getObjectType()用于返回Bean的类型。

BeanFactory与FactoryBean的区别
虽然BeanFactory和FactoryBean都与Bean的创建和管理有关，但它们在功能和使用上存在显著的区别：

功能不同：BeanFactory负责管理和创建Bean，而FactoryBean是一个接口，允许开发者实现定制化的Bean创建逻辑。
角色不同：BeanFactory是Spring框架的核心，负责整个Bean的管理；而FactoryBean是Bean的创建方式之一，用于定制化的Bean实例化。
使用方式不同：BeanFactory通常通过配置文件或者注解来实现Bean的管理和创建；而FactoryBean需要开发者实现自定义的工厂类，提供定制化的Bean创建逻辑。

总结:
通过本文的深入解析，我们了解了BeanFactory和FactoryBean在Spring框架中的作用和区别。BeanFactory负责整个Bean的管理和创建，而FactoryBean允许开发者实现定制化的Bean创建逻辑，从而实现更加灵活和复杂的Bean实例化。

两个实现类冲突用@Autowired如何解决

解决方法呢就是给这几个bean起个名字，然后@Autowired配合@Qualifier引用名字即可解决问题。

Spring Boot 的核心注解是哪个？它主要由哪几个注解组成的？

一、@SpringBootApplication
@SpringBootApplication是Spring Boot框架的核心注解之一，它用于标识一个主配置类，通常是项目的入口类。 该注解可以将Spring Boot应用程序自动配置和启动的相关注解整合在一起，简化了Spring Boot应用的开发。

@SpringBootApplication解包含了以下三个注解的功能：

@Configuration：标注该类是一个配置类，可以使用@Bean注解来定义Bean。

@EnableAutoConfiguration：启用Spring Boot的自动配置机制，让Spring Boot自动根据项目的依赖和配置来决定应用程序的配置。

. @ComponentScan：启用组件扫描，自动扫描并加载符合条件的组件，包括@Controller、@Service、@Repository等。

使用@SpringBootApplication注解，可以简化Spring Boot应用的配置，避免了繁琐的XML配置文件。 通常情况下，我们只需要在项目的入类上添加@SpringBootApplication注解即可。

Spring钩子接口汇总

1、Aware 系列接口
以下是几种常用的 Aware 接口：

BeanFactoryAware：获取 BeanFactory 对象，它是基础的容器接口。
BeanNameAware：获取 Bean 的名称。
EnvironmentAware：获取 Environment 对象，它表示整个的运行时环境，可以设置和获取配置属性。
ApplicationEventPublisherAware：获取 ApplicationEventPublisher 对象，它是用来发布事件的。
ResourceLoaderAware：获取 ResourceLoader 对象，它是获取资源的工具。

2、InitializingBean
3、BeanPostProcessor
4、BeanFactoryPostProcessor
BeanFactoryPostProcessor 是 Bean 工厂的后置处理器，一般用来修改上下文中的 BeanDefinition，修改 Bean 的属性值。
5、FactoryBean
FactoryBean 也是一种 Bean，不同于普通的 Bean，它是用来创建 Bean 实例的，属于工厂 Bean，不过它和普通的创建不同，它提供了更为灵活的方式，其实现有点类似于设计模式中的工厂模式和修饰器模式。
6、ApplicationListener
Spring 容器启动过程中，会在相应的阶段通过 ApplicationContext 发布 ApplicationEvent 事件，之后所有的 ApplicationListener 会被回调，根据事件类型，执行不同的操作。

SpringMVC 注解详解

核心注解
@Controller：用于标识是一个控制器。
@RestController：组合注解，等同于 @Controller + @ResponseBody，用于标识 RESTful Web Services。
@RequestMapping：用于将 HTTP 请求映射到对应的方法上。
2.2 数据绑定注解
@RequestParam：用于将请求参数与控制器方法的参数进行绑定。
@PathVariable：用于将 URI 模板变量与控制器方法的参数进行绑定。
@RequestBody：用于读取 Http 请求的正文，将其绑定到相应的 bean 上。
@ResponseBody：表示该方法的返回结果直接作为 Web 响应正文返回，用于异步请求处理。
2.3 其他注解
@ModelAttribute：用于将请求参数与模型对象进行绑定。
@CookieValue：用于将 Cookie 与控制器方法的参数进行绑定。
@RequestHeader：用于将 Http 请求头与控制器方法的参数进行绑定。