关于windows:spring-Boot-工作原理

Spring Boot 概述

    Spring boot 是一个脚手架:
           能够很快很不便整合其余的内部框架
    提供了主动配置性能
    可实现其开箱即用个性

springBoot 主动配置原理:

启动类的注解 (@SpringBootApplication) 上有 EnableAutoConfiguration 这个注解, 这个注解实现了主动配置性能

EnableAutoConfiguration 下面有 @Import 注解
引入了 AutoConfigurationImportSelector.class
这个类, 这个类外面都是 springboot 整合内部框架的配置

实现主动扫描：
启动类的注解 (@SpringBootApplication) 上有 @ComponentScan
主动扫描并加载符合条件的 Bean 到容器中, 默认扫描启动类所在的包开始扫描

Spring Boot 罕用注解:

    @SpringBootApplication 启动类注解
    @Component,@Controller,@Service: 将类给 
    Spring 框架中的 BeanFactory 工厂接口的实现类
    对象
    @SpringBootTest: 测试类交给 spring 治理。@Autowired: 形容通知 spring 框架要为此属性注入一个值
    
    

spring 入门案例

创立一个 DefaultCache 类而后交给 spring 治理。

@Component
public class DefaultCache {}

// 第二步
@SpringBootTest
public class DefaultCacheTests {
 @Autowired
 private DefaultCache defaultCache;

 @Test
 public void testCache() {System.out.println(defaultCache);
 }
}

程序执行流程解析：

1. 程序首先会找到启动类（@SpringBootApplication）
2. 启动类下面有两个注解：@EnableAutoConfiguration+@ComponentScan
@EnableAutoConfiguration 会去加载一些程序运行所须要的配置，@ComponentScan 会从启动类所在的包下开始扫描整个包构造，会将带有特定的注解的类扫描到 spring 容器中，
3. 通过扫描之后 spring 容器里就存在了 DefaultCacheTests 对象
4.SpringBootTest 这个注解的类就表明是一个测试类，程序到 @Autowired, 此时它就会到 spring 容器中 DefaultCache 这个对象，或者是他的子类对象

spring 对象作用域 + 提早加载 + 生命周期办法

Spring Bean 中的作用域有五个singleton，prototype，request,session,globalsession

案例：

package com.cy.pj.common.cache;
@Component
@Scope("singleton")
@Lazy
public class DefaultCache {public DefaultCache() {System.out.println("cache()");
 }

 @PostConstruct
 public void init() {System.out.println("init()");
 }
 @PreDestroy
 public void destory() {System.out.println("destory");
 }
}

1.@Component 会被扫描进 spring 容器
2.@Scope(“singleton”) 指定存储的域为 singleton
singleton 外面存储的是单例的只有一份
3.@Lazy 通知 spring 框架此类反对提早加载，在程序中
DefaultCache 被扫描到 spring 容器，带 @Lazy 此时 bean 工厂对象不会马上创立他的实例，什么时候用才会去加载他的实例
4.@PostConstruct 注解用于形容 bean 对象生命周期办法中 的初始化办法
5.@PreDestroy 注解用于形容 Bean 对象生命周期办法中的销毁办法
程序在加载时，首先回去加载静态方法 => 构造方法 => 初始化办法 => 销毁办法
6. 如果作用域 prototype, 这个作用域不是单例的(每次获取都会创立新实例), 也不会交个 spring 去治理，spring 能够对它初始化，因为 spring 不论他，所以要手动的去销毁

spring 增强练习

package com.cy.pj.common.cache;
public interface Cache {}

// 接口子类 1
package com.cy.pj.common.cache;
import org.springframework.stereotype.Component;
@Component
public class WeakCache implements Cache{
}
// 接口子类 2
package com.cy.pj.common.cache;
@Component
public class DefaultCache implements Cache{
}

// 测试类
@SpringBootTest
public class CacheTests {
 @Autowired
 @Qualifier("defaultCache")
 private Cache cache;
 @Test
 public void testCache() {System.out.println(cache);
 }
}

1. 通过扫描，会将子类 1 + 子类 2 扫描到 spring 容器中
2. @Autowired 注入容器时是父类的接口，而 spring 容器中有两个子类的对象，此时就无奈实现注入
   
   此时就须要加 @Qualifier(“defaultCache”)为注入指定一个对象，指定的是子类 2，此时取到的对象就是子类 2 的对象

小结

1.Spring boot 是什么? (脚手架而非框架)能够很容易的去整合内部框架

2.Spring boot 外围劣势？(启动依赖, 主动配置 - 开箱即用, 健康检查 - 系统监控）
整合时只须要退出绝对于的依赖，不须要写繁琐的配置，就能够间接应用

3.Spring boot 我的项目启动时，Bean 的初始化过程是怎么的？(查找，加载，读和存储配置，创立和存储实例对象)
查找：类上指定的注解 加载：加载到 spring 容器

4.Spring boot 我的项目启动时，Bean 对象的依赖注入过程是怎么的？(标记，查找，注入)