official documents

自动配置、起步依赖、Actuator、命令行界面(CLI) 是Spring Boot最重要的4大核心特性

Servlet->EJB->Struts->SpringMVC->SpringBoot

New->Factory->容器

1.知识点Overview

1.1 Spring IoC容器

IoC容器是大管家，你只需要告诉它需要某个bean，它就把对应的实例（instance）扔给你，至于这个bean是否依赖其他组件，怎样完成它的初始化，根本就不需要你关心。

bean是什么？(Spring bean)

The objects that form the backbone of your application and that are managed by the Spring IoC container are called beans. A bean is an object that is instantiated, assembled, and otherwise managed by a Spring IoC container. https://www.tutorialspoint.com/spring/spring_bean_definition.htm

Spring Bean VS Java Bean:

Java Beans are simple Java classes that encapsulate objects, while Spring Beans are managed by the Spring Framework and are used for dependency injection and lifecycle management.

IoC容器想要管理各个业务对象以及它们之间的依赖关系，需要通过某种途径来记录和管理这些信息。 BeanDefinition对象就承担了这个责任：容器中的每一个bean都会有一个对应的BeanDefinition实例，该实例负责保存bean对象的所有必要信息，包括bean对象的class类型、是否是抽象类、构造方法和参数、其它属性等等。 当客户端向容器请求相应对象时，容器就会通过这些信息为客户端返回一个完整可用的bean实例； 默认是单例模式；

事先这些bean需要向大管家注册，BeanDefinitionRegistry抽象出bean的注册逻辑，BeanFactory则抽象出了bean的管理逻辑，而各个BeanFactory的实现类就具体承担了bean的注册以及管理工作 然后大管家生成bean也是通过这个工厂模式； DefaultListableBeanFactory作为一个比较通用的BeanFactory实现，它同时也实现了BeanDefinitionRegistry接口，因此它就承担了Bean的注册管理工作， 具体的beanFactory实现类就是实现了DefaultListableBeanFactory这个接口；

Spring提供了两种容器类型：BeanFactory和ApplicationContext：

Spring IoC容器的整个工作流程大致可以分为两个阶段：

• 容器启动阶段

  容器启动时，会通过某种途径加载 ConfigurationMetaData， ConfigurationMetaData可能定义在代码中，比如注解方式，也可能在在外部配置文件(XML/Properties)中， ，容器需要依赖某些工具类如BeanDefinitionReader，BeanDefinitionReader会对加载的 ConfigurationMetaData进行解析和分析，并将分析后的信息组装为相应的BeanDefinition， 最后把这些保存了bean定义的BeanDefinition，注册到相应的BeanDefinitionRegistry， 这样容器的启动工作就完成了。

• Bean的实例化阶段

  这个阶段触发是:当某个请求通过容器的getBean方法请求某个对象，或者因为依赖关系容器需要隐式的调用getBean时（如bean的注解@DependsOn 或者Autowired）; 容器会首先检查所请求的对象之前是否已经实例化完成。如果没有，则会根据注册的BeanDefinition所提供的信息实例化被请求对象，并为其注入依赖。当该对象装配完毕后，容器会立即将其返回给请求方法使用。

  Notes:Autowire vs getbean

  Injecting a Prototype Bean into a Singleton Bean Problem https://www.logicbig.com/tutorials/spring-framework/spring-core/injecting-singleton-with-prototype-bean.html

  You can then use getBean to retrieve instances of your beans. The ApplicationContext interface has a few other methods for retrieving beans, but, ideally, your application code should never use them. Indeed, your application code should have no calls to the getBean() method at all and thus have no dependency on Spring APIs at all. https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html

  BeanFactory只是Spring IoC容器的一种实现，如果没有特殊指定，它采用采用延迟初始化策略：只有当访问容器中的某个对象时，才对该对象进行初始化和依赖注入操作。 对于资源有限，并且功能要求不是很严格的场景，BeanFactory是比较合适的IoC容器选择。

  而在实际场景下，我们更多的使用另外一种类型的容器： ApplicationContext，它构建在BeanFactory之上，属于更高级的容器，除了具有BeanFactory的所有能力之外，还提供对事件监听机制以及国际化的支持等。它管理的bean，在容器启动时全部完成初始化和依赖注入操作。 ApplicationContext所管理的对象，在该类型容器启动之后，默认全部初始化并绑定完成。所以，相对于BeanFactory来说，ApplicationContext要求更多的系统资源，同时，因为在启动时就完成所有初始化，容器启动时间较之BeanFactory也会长一些。 在那些系统资源充足，并且要求更多功能的场景中，ApplicationContext类型的容器是比较合适的选择。

bean生命周期接口

https://www.huaweicloud.com/articles/b59be8ffdcfbd1f8a1fe28bffe848d20.html

IoC容器负责管理容器中所有bean的生命周期，而在bean生命周期的不同阶段，Spring提供了不同的扩展点来改变bean的命运，例如EnvironmentPostProcessor、BeanFactoryPostProcessor等（具体参照：第2节 SpringApplication启动流程）:

单例模式

spring boot默认bean是单例的，spring mvc默认的servlet也是单例的，当然bean @Controller也是单例的，多线程体现在httpservletrequest本身是线程间互相隔离的， 一般都是通过ThreadLocal实现， 之所以默认单例是因为，springboot本身就是ioc容器，启动过程很长，启动时会实例化加载bean（当然也有lazy模式），bean的实例化通常需要读取配置文件或者有很多其他bean的依赖， 所以每次都重建销毁性能很差，而且浪费内存； https://stackoverflow.com/questions/10096483/is-threadlocal-preferable-to-httpservletrequest-setattributekey-value

单例就是为了共享从而减少内存开销，多线程就是为了区别每个线程的上下文或者working thread context，所以线程上下文一定不能被共享， 比如ThreadLocal不能跟ExecutorService共用，就是因为ExecutorService破坏了线程间的隔离 Do Not Use ThreadLocal With ExecutorService https://www.baeldung.com/java-threadlocal https://www.cnblogs.com/MrSaver/p/11191028.html

单例模式 工厂模式 建造者模式

Spring单例Bean与单例模式的区别在于它们关联的环境不一样，单例模式是指在一个JVM进程中仅有一个实例，而Spring单例是指一个Spring Bean容器(ApplicationContext)中仅有一个实例。 首先看单例模式，在一个JVM进程中（理论上，一个运行的JAVA程序就必定有自己一个独立的JVM）仅有一个实例，于是无论在程序中的何处获取实例，始终都返回同一个对象，以Java内置的Runtime为例（现在枚举是单例模式的最佳实践），无论何时何处获取，下面的判断始终为真： Runtime.getRuntime() == Runtime.getRuntime() 与此相比，Spring的单例Bean是与其容器（ApplicationContext）密切相关的，所以在一个JVM进程中，如果有多个Spring容器，即使是单例bean，也一定会创建多个实例，代码示例如下： ``` // 第一个Spring Bean容器 ApplicationContext context_1 = new FileSystemXmlApplicationContext(“classpath:/ApplicationContext.xml”); Person yiifaa_1 = context_1.getBean(“yiifaa”, Person.class); // 第二个Spring Bean容器 ApplicationContext context_2 = new FileSystemXmlApplicationContext(“classpath:/ApplicationContext.xml”); Person yiifaa_2 = context_2.getBean(“yiifaa”, Person.class); // 这里绝对不会相等，因为创建了多个实例 System.out.println(yiifaa_1 == yiifaa_2);

> https://blog.csdn.net/yiifaa/java/article/details/74852425



@bean方法调用的特殊性：

https://www.racecoder.com/archives/787/

https://stackoverflow.com/questions/27990060/calling-a-bean-annotated-method-in-spring-java-configuration



[Spring Boot 2.0 ：深入分析Spring Boot原理](https://blog.csdn.net/TheLudlows/article/details/81360067)

spring boot之自动装配（spring-boot-autoconfigure） https://blog.csdn.net/wangjie5540/article/details/99542777

原创 | 我被面试官给虐懵了，竟然是因为我不懂Spring中的@Configuration
https://juejin.im/post/5d005860f265da1b7f297630

#### Spring装配bean的三种方法：

The interface `org.springframework.context.ApplicationContext` represents the Spring IoC container and is responsible for instantiating, configuring, and assembling the aforementioned beans. The container gets its instructions on what objects to instantiate, configure, and assemble by reading configuration metadata. The configuration metadata is represented in：

XML, Java annotations, or Java code:

https://docs.spring.io/spring-framework/docs/3.2.x/spring-framework-reference/html/beans.html

- [Annotation-based configuration](https://docs.spring.io/spring-framework/docs/3.2.x/spring-framework-reference/html/beans.html#beans-annotation-config) 使用注解Annotation定义Bean

  Spring 2.5 introduced support for annotation-based configuration metadata.

  spring从两个角度实现自动化装配：组件扫描和自动装配

  1) 创建可被发现的bean

  ```java
  @Component
  这个简单的注解表明该类会作为组件类,并告知Spring要为这个类创建bean
  
  ----------------------------------------------------------------------------------------
  --- 命名 bean id
  ---------------------------------------------------------------------------------------- 
  如果没有个bean设置ID,Spring会根据类名为其指定一个ID,默认名字就是把类名的第一个字母变为小写.
  @Component("lonelyHeartsClub") //设置期望的ID
  	public class SgtPeppers implements CompactDisc{
  }
  另外还一种为bean命名的方式,使用Java依赖注入规范中所提供的@Named注解来为bean设置ID
  @Named("lonelyHeartsClub")
  public class SgtPeppers implements CompactDisc{
  }
  
  ----------------------------------------------------------------------------------------
  --- 设置组件扫描的基础包
  ----------------------------------------------------------------------------------------
  当对一个类标注@Component注解时，表明该类会作为组件类，spring将为这个类创建bean。当在应用文中引用这个bean，spring会自动扫描事先指定的包查找这个  bean。但spring默认是不启用组件扫描的，可以在XML中配置加上。还有一种方法：在新建一个配置类，类中可以什么不用写，在配置类上加上@ComponentScan注解，spring会自动扫描改配置类所在的包。
  //直接在value属性中指明包的名称
  @Configuration
  @ComponentScan("soundsystem")
  public class CDPlayerConfig{}
  
  //通过basePackages属性配置
  @Configuration
  @ComponentScan(basePackages="soundsystem")
  public class CDPlayerConfig{}
  
  //设置多个基础包,用数组表示
  @Configuration
  @ComponentScan(basePackages={"soundsystem","video"})
  public class CDPlayerConfig{}
  
  //基础包以String类型表示是不安全的,如果重构代码的话,指定的基础包可能会出现错误,用指定为包中所包含的类或接口的方法
  @Configuration
  @ComponentScan(basePackageClasses={CDPlayer.class,DVDPlayer.class})
  public class CDPlayerConfig{}
  
  ----------------------------------------------------------------------------------------
  --- 添加注解自动装配Autowired
  @Autowired可以换成@Inject,@Inject注解来源于Java依赖注入规范,该规范同时还为我们定义了@Named注解.
  尽管@Inject和@Autowierd有细微的差别,但大多数场景下,它们都可以互换.
  ----------------------------------------------------------------------------------------
  @Autowired注解构造器：
  @Component
  public class CDPlayer implements MediaPlayer{
    private CompactDisc cd;
  
    @Autowired//这表明当Spring创建CDPlayer bean的时候,会通过这个构造器来进行实例化并且会传入一个可设置给CompactDisc类型的bean.
    public CDPlayer(CompactDisc cd){//构造器
      this.cd = cd;
    }
  
    public void paly(){
      cd.paly();
    }
  }
  
  @Autowired注解属性的Setter方法：
  @Autowired
  public void setCompactDisc(CompactDisc cd){
    this.cd = cd;
  }
  
  如果没有匹配的bean,那么在应用上下文创建的时候,Spring会抛出一个异常,为了避免异常的出现,你可以将@Autowired的requied属性设置为false
  @Autowired(required=false)
  public void setCompactDisc(CompactDisc cd){
    this.cd = cd;
  }
  
  如果有多个bean都能满足依赖关系的话,Spring将会抛出一个异常,表明没有明确指定要选择哪个bean进行自动装配, 一般在组件类上添加注解@Qualifier()括号写这个bean的id，在注入时也加上@Qualifier(),写上bean的id
  @Component
  @Qualifier("postdao")
  public interface Postdao{
  . . . .
  }
  
  @Component
  @Qualifier("userdao")
  public interface Userdao{
  . . . .
  }
  
  @Autowired
  @Qualifier("usedao")
  public void setUserdao(Userdao userdao)
  {. . .
  }
  
  @Autowired
  @Qualifier("postdao")
  public void setUserdao(Postdao postdao)
  {. . .
  }

• Java-based configuration 基于java类提供Bean定义信息

  所谓java based 我的理解是这里是说不需要依赖于spring，普通的java项目也可以用

  Starting with Spring 3.0, many features provided by the Spring JavaConfig project became part of the core Spring Framework. Thus you can define beans external to your application classes by using Java rather than XML files. To use these new features, see the @Configuration, @Bean, @Import and @DependsOn annotations.

  有些情况下,比如说,要将第三方库的组件装配到你的应用中,就不能使用前面的自动化装配方法 到第三方库中去给类加@Component和@Autowired注解, 在这种情况下,就需要采用显示装配的方式.在进行显示配置有Java和XML两种方案显示装配bean.

  使用java代码，先新建一个配置类JavaConfig，里面都是配置所需的bean，不应该有业务逻辑代码，所以单独建一个类。

  @Configuration
  public class AppConfig {
    @Bean
    public MyService myService() {
        return new MyServiceImpl();
    }
  }
  public static void main(String[] args) {
    ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
    MyService myService = ctx.getBean(MyService.class);
    myService.doStuff();
  }
    
  public static void main(String[] args) {
    AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
    ctx.register(AppConfig.class, OtherConfig.class);
    ctx.register(AdditionalConfig.class);
    ctx.refresh();
    MyService myService = ctx.getBean(MyService.class);
    myService.doStuff();
  }
    
  //创建JavaConfig类的关键在于为其添加@Configruation注解,表明这是一个配置类
  @Configuration
  public class CDPlayerConfig{
      @Bean
      public CompactDisc sgtPeppers(){
        return new SgtPeppers();
      }
      //@Bean注解会告诉Spring这个方法将会返回一个对象,该对象要注册为Spring应用上下文的bean,默认情况下,
      bean的ID于带有@Bean注解的方法名一样,也可以重命名
    
      @Bean(name="lonelyHeartsClubBand")
      public CompactDisc sgtPeppers(){
        return new SgtPeppers();
      }
    	
      声明CompactDisc bean是非常简单,它自身没有其他依赖,但现在,我们需要声明CDPlayer bean,它依赖于CompactDisc,在JavaConfig中,如何将他们装配在一起呢?
      @Bean
      public CDPlayer cdPlayer(){
        return new CDPlayer(sgtPeppers()); //因为sgtPeppers()方法上添加了@Bean注解,Spring将会拦截所有对它的调用,
      //并确保直接返回该方法创建的bean,而不是每次都对其进行实际的调用.
      }
      等价于下面这种方式
            
      @Bean
      public CDPlayer cdPlayer(CompactDisc compactDisc){//在这里,cdPlayer()方法请求一个CompactDisc作为参数,当Springs调用cdPlayer()创建CDPlayer bean的时候,
  //它会自动装配一个CompactDisc到配置方法之中,然后方法体按照合适的方法来使用它.
        return new CDPlayer(compactDisc);
      }
  	@Bean(name="lonelyHeartsClubBandPlayer")
      public CDPlayer cdPlayer(CompactDisc lonelyHeartsClubBand){
  		return new CDPlayer(compactDisc);
      }
  }
    
  More example：
    
  @Configuration
  @ContextConfiguration(locations = {"classpath:spring/spring-dao.xml","classpath:scan.xml"}）
  public class bbsConfig{
  　　private Postdao postdao;
  　　private Userdao userdao;
  　　@Bean(name="postservice")
     public PostService getPost()
  　　{
  　　return new PostserviceImpl(postdao,userdao);
  　　}
  }
    
  在对PostService的bean注入时，同时又依赖了两个bean，postdao和userdao。直接引用beanID就可以，spring会自动地从容器中获取这些bean，只要他们的配置是正确的就行。这个例子中userdao、postdao是Mybatis配置自动扫描将dao接口生成代理注入到spring的，其实也算是xml装配bean
  这里如果再声明一个bean，返回的仍是postserviceImpl对象，和之前的那个bean完全一样，是同一个实例。一般spring @bean如果是同一个beanID，默认返回的是一个单例bean，注入的是同一个实例。如果修改其中一个会都改变的。
  不过在这里要注意进行测试时，由于spring的单元测试和springIoc容器是完全独立的，postdao和userdao注入检测时是使用locations加载xml文件，而postservice使用classes加载config类的，但是两个不能同时混用在@ContextConfiguration中。所以非要都测试的话，就分开测试吧。
  

• 基于xml配置Bean

  Configuration metadata is traditionally supplied in a simple and intuitive XML format

  https://docs.spring.io/spring-framework/docs/3.2.x/spring-framework-reference/html/beans.html

  ```java //XML装配bean的缺点 //1.当Spring发现这个元素时,它将会调用SgtPeppers的默认构造器来创建bean.在XML配置中,bean的创建显得更加被动 //2.不如JavaConfig强大,在JavaConfig配置中,可以通过任何想象到的方法来创建bean实例(构造器,set方法等) //3.在简单的声明中,将bean的类型以字符串的形式设置在了class属性中,不能保证设置给class属性的值是真正的类 //4.重命名了类,也会引起麻烦

—基本 ————————————————————————————– <?xml version=”1.0” encoding=”UTF-8”> <beans xmlns=”http://……..” xmlns:xsi=”http://…..’’> //这里声明一个很简单的bean,因为没有明确给定ID,所以这个bean将会根据全限定类名来进行命名, //这里的bean的ID将会是”soundsystem.SgtPeppers#0”.其中,”#0”是一个计数的形式,来区分相同类型的bean.

  //一个ID为compactDisc的bean引用传递到CDPlayer的构造器中.
  <bean id="cdPlayer" class="soundsystem.CDPlayer">
    <constructor-arg ref="compactDisc">
  </bean>

</beans>

作为替代方案,也可以使用Spring的c-命名空间（Spring3.0所引入的c-命名空间） <?xml version=”1.0” encoding=”UTF-8”> <beans xmlns=”http://……..” xmlns:c=”http://www.springframework.org/schema/c” xmlns:xsi=”http://…..’’> //"c:" 命名空间的前缀 //"cd" 构造器参数名 //"-ref"注入bean引用 //"compactDisc" 要注入bean 的ID

  如果在优化构建的过程,将调试标志移除掉,那么这种方式可能无法正常执行.代替方案：
  	<bean id="cdPlayer" class="soundsystem.CDPlayer"
 c:_0-ref="compactDisc">
  	//把参数名换成"0",也就是参数的索引,但XML中不允许数字作为属性的第一个字符,因此添加下划线"_"

</beans> ————————————————————————————– — 字面量string注入 ————————————————————————————– public class BlankDisc implements CompactDisc{ private String title; private String artist;

public BlandDisc(String title,String artist){
  this.title = title;
  this.artist = artist;
}
  
public void paly(){
  System.out.println("Playing"+title+"by"+artist);
}

}

等价

private String title;
private String artist;
private List<String> tracks;
  
 public void setTitel(String title){
  this.title = title;
  }
  
  public void setArtist(String artist){
    this.artist= artist;
  }
 public void setTracks(List<String> tracks){
  this.tracks= tracks;
  }
  
  public void play(){
    ....
  }   }