SpringBoot原理

一、bean创建方式

  1. xml+<bean/>
  2. xml:context+注解(@Component+4个@Bean)
  3. 配置类+扫描+注解(@Component+4个@Bean)
    -@Bean定义FactoryBean接口
    -@ImportResource
    -@Configuration注解的proxyBeanMethods属性
  4. @Import导入bean的类
    -@Import导入配置类
  5. AnnotationConfigApplicationContext调用register方法
  6. @Import导入ImportSelector接口
  7. @Import导入ImportBeanDefinitionRegistrar接口
  8. @Import导入BeanDefinitionRegistryPostProcessor接口

1. XML方式声明bean

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--声明自定义bean-->
    <bean id="bookService"
          class="com.heyj.service.impl.BookServiceImpl"
          scope="singleton"/>

    <!--声明第三方开发bean-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"/>
</beans>

2. XML+注解方式声明bean

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.heyj"/>
</beans>
  • 使用@Component及其衍生注解@Controller 、@Service、@Repository定义bean
@Service
public class BookServiceImpl implements BookService {
}
  • 使用@Bean定义第三方bean，并将所在类定义为配置类或Bean
@Component
public class DbConfig {
    @Bean
    public DruidDataSource getDataSource() {
        DruidDataSource ds = new DruidDataSource();
        return ds;
    }
}

3. 配置类+扫描+注解

  • 注解方式声明配置类
@Configuration
@ComponentScan("com.heyj")
public class SpringConfig {
    @Bean
    public DruidDataSource getDataSource() {
        DruidDataSource ds = new DruidDataSource();
        return ds;
    }
}

3.1 实现FactoryBean接口的类方式

public class BookFactoryBean implements FactoryBean<Book> {
    public Book getObject() throws Exception {
        Book book = new Book();
        // 进行book对象相关的初始化工作 
        return book;
    }

    public Class<?> getObjectType() {
        return Book.class;
    }
}

public class SpringConfig8 {
    @Bean
    public BookFactoryBean book() { // 创建的Book类型的bean
        return new BookFactoryBean();
    }
}

3.2 配置类+配置文件(系统迁移)

@Configuration
@ComponentScan("com.itheima") 
@ImportResource("applicationContext-config.xml") 
public class SpringConfig2 {
}

3.3 使用proxyBeanMethods

表示是否代理配置类中标有@bean的方法，默认是true

  • proxyBeanMethods=true 是代理，从容器中获取bean
  • proxyBeanMethods=false 不代理，配置类中的@bean方法如同普通方法，每条用一次创建一个bean对象。
@Configuration(proxyBeanMethods = false)
public class SpringConfig3 {
    @Bean
    public Book book() {
        System.out.println("book init ..."); // 每调用一次book()方法都会创建一个Book
        return new Book();
    }
}

4. 使用@Import导入要注入的bean

  • 使用@Import注解导入要注入的bean对应的字节码
@Import(Dog.class)
public class SpringConfig5 { 
}
  • 被导入的bean无需使用注解声明为bean
public class Dog {
}

此形式可以有效的降低源代码与Spring技术的耦合度

那么，可以
使用@Import注解导入配置类：

@Import(DbConfig.class) 
public class SpringConfig { 
}

5. 容器注册bean

  • 使用上下文对象在容器初始化完毕后注入bean
public class AppImport {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx =
                new AnnotationConfigApplicationContext(SpringConfig5.class);
        ctx.register(Cat.class);
        String[] names = ctx.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
    }
}

6. 导入实现了ImportSelector接口的类

public class MyImportSelector implements ImportSelector {
    public String[] selectImports(AnnotationMetadata metadata) {
        boolean flag = metadata.hasAnnotation("org.springframework.context.annotation.Import");
        if (flag) {
            return new String[]{"com.heyj.domain.Dog"};
        }
        return new String[]{"com.heyj.domain.Cat"};
    }
}

然后在配置类上@import上面的MyImportSelector.class

7. 导入实现了ImportBeanDefinitionRegistrar接口的类

  • 导入实现了ImportBeanDefinitionRegistrar接口的类，通过BeanDefinition的注册器注册实名bean，实现对 容器中bean的裁定，例如对现有bean的覆盖，进而达成不修改源代码的情况下更换实现的效果
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
                                        BeanDefinitionRegistry registry) {
        BeanDefinition beanDefinition = BeanDefinitionBuilder
                .rootBeanDefinition(BookServiceImpl2.class)
                .getBeanDefinition();
        registry.registerBeanDefinition("bookService", beanDefinition);
    }
}

8. 导入实现了BeanDefinitionRegistryPostProcessor接口的类

  • 导入实现了BeanDefinitionRegistryPostProcessor接口的类，通过BeanDefinition的注册器注册实名bean， 实现对容器中bean的最终裁定
public class MyPostProcessor implements BeanDefinitionRegistryPostProcessor {
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
        BeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(BookServiceImpl4.class)
                .getBeanDefinition();
        registry.registerBeanDefinition("bookService", beanDefinition);
    }
}

二、bean创建之控制

1. 根据任意条件确认是否加载bean

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        try {
            Class<?> clazz = Class.forName("com.itheima.ebean.Mouse");
            if (clazz != null) {
                return new String[]{"com.itheima.bean.Cat"};
            }
        } catch (ClassNotFoundException e) {
            return new String[0];
        }
        return null;
    }
}

2. 使用@Conditional注解的派生注解设置各种组合条件控制bean的加载

  • 匹配指定类
public class SpringConfig {
    @Bean
    @ConditionalOnClass(Mouse.class)
    public Cat tom() {
        return new Cat();
    }
}
  • 未匹配指定类
public class SpringConfig {
    @Bean
    @ConditionalOnClass(Mouse.class)
    @ConditionalOnMissingClass("com.heyj.bean.Wolf")
    public Cat tom() {
        return new Cat();
    }
}
  • 匹配指定类型的bean
@Import(Mouse.class)
public class SpringConfig {
    @Bean
    @ConditionalOnBean(Mouse.class)
    public Cat tom() {
        return new Cat();
    }
}
  • 匹配指定名称的bean
@Import(Mouse.class)
public class SpringConfig {
    @Bean
    @ConditionalOnBean(name = "com.heyj.bean.Mouse")
    public Cat tom() {
        return new Cat();
    }
}

@Import(Mouse.class)
public class SpringConfig {
    @Bean
    @ConditionalOnBean(name = "jerry")
    public Cat tom() {
        return new Cat();
    }
}
  • 匹配指定环境
public class SpringConfig {
    @Bean
    @ConditionalOnClass(name = "com.mysql.jdbc.Driver")
    public DruidDataSource dataSource() {
        DruidDataSource ds = new DruidDataSource();
        return ds;
    }
}

三、自动配置原理

Springboot遵循“约定优于配置”的原则，使用注解对一些常规的配置项做默认配置，减少或不使用xml配置，让你的项目快速运行起来。Springboot还为大量的开发常用框架封装了starter，如今引入框架只要引入一个starter，你就可以使用这个框架，只需少量的配置甚至是不需要任何配置。

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {SpringApplication.run(MyApplication .class, args);}
}

我们看到，MyApplication作为入口类，入口类中有一个main方法，这个方法其实就是一个标准的Java应用的入口方法，一般在main方法中使用SpringApplication.run()来启动整个应用。值得注意的是，这个入口类要使用@SpringBootApplication注解声明，它是SpringBoot的核心注解。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
        @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
    // 略
}

从上面看是由3个注解合成的：

  • @SpringBootConfiguration 其实就是@Configuration--》@Component
  • @EnableAutoConfiguration
  • @ComponentScan 一般是解析需要扫描的目录

所以，这个注解里面，最主要的就是@EnableAutoConfiguration，这么直白的名字，一看就知道它要开启自动配置，SpringBoot要开始了，于是默默进去@EnableAutoConfiguration的源码。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(EnableAutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
    // 略
}

可以看到，在@EnableAutoConfiguration注解内使用到了@import注解来完成导入配置的功能，而EnableAutoConfigurationImportSelector内部则是使用了SpringFactoriesLoader.loadFactoryNames方法进行扫描具有META-INF/spring.factories文件的jar包。下面是1.5.8.RELEASE实现源码：

 @Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
        return NO_IMPORTS;
    }
    try {
          AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
                    .loadMetadata(this.beanClassLoader);
          AnnotationAttributes attributes = getAttributes(annotationMetadata);
          //扫描具有META-INF/spring.factories文件的jar包
          List<String> configurations = getCandidateConfigurations(annotationMetadata,
                    attributes);
          //去重
          configurations = removeDuplicates(configurations);
          //排序
          configurations = sort(configurations, autoConfigurationMetadata);
           //删除需要排除的类
         Set<String> exclusions = getExclusions(annotationMetadata, attributes);
         checkExcludedClasses(configurations, exclusions);
         configurations.removeAll(exclusions);
         configurations = filter(configurations, autoConfigurationMetadata);
         fireAutoConfigurationImportEvents(configurations, exclusions);
         return configurations.toArray(new String[configurations.size()]);
    }
    catch (IOException ex) {
        throw new IllegalStateException(ex);
    }
}

//加载spring.factories实现
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata,
        AnnotationAttributes attributes) {
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
            getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
    Assert.notEmpty(configurations,
            "No auto configuration classes found in META-INF/spring.factories. If you "
                      + "are using a custom packaging, make sure that file is correct.");
    return configurations;
}

任何一个springboot应用，都会引入spring-boot-autoconfigure，而spring.factories文件就在该包下面。spring.factories文件是Key=Value形式，多个Value时使用,隔开，该文件中定义了关于初始化，监听器等信息，而真正使自动配置生效的key是org.springframework.boot.autoconfigure.EnableAutoConfiguration，如下所示：

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
//省略

上面的EnableAutoConfiguration配置了多个类，这些都是Spring Boot中的自动配置相关类；在启动过程中会解析对应类配置信息。每个Configuation类都定义了相关bean的实例化配置。都说明了哪些bean可以被自动配置，什么条件下可以自动配置，并把这些bean实例化出来。如果我们自定义了一个starter的话，也要在该starter的jar包中提供 spring.factories文件，并且为其配置org.springframework.boot.autoconfigure.EnableAutoConfiguration对应的配置类。所有框架的自动配置流程基本都是一样的，判断是否引入框架，获取配置参数，根据配置参数初始化框架相应组件。下面的redis相关的自动配置的部分源码：

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(RedisOperations.class) //自动配置必须要有RedisOperations类在classpath里。
@EnableConfigurationProperties(RedisProperties.class) //去加载默认配置信息
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })//导入相应客户端
public class RedisAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean(name = "redisTemplate")//如果容器中没有名字叫redisTemplate才去创建该bean
    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        return new StringRedisTemplate(redisConnectionFactory);
    }
}

我们可以看到自动化配置代码中有很多我们之前没有用到的注解配置：

@Configuration：这个配置就不用多做解释了，我们一直在使用
@EnableConfigurationProperties：这是一个开启使用配置参数的注解，value值就是我们配置实体参数映射的ClassType，将配置实体作为配置来源。

以下为SpringBoot内置条件注解：
@ConditionalOnBean：当SpringIoc容器内存在指定Bean的条件
@ConditionalOnClass：当SpringIoc容器内存在指定Class的条件
@ConditionalOnExpression：基于SpEL表达式作为判断条件
@ConditionalOnJava：基于JVM版本作为判断条件
@ConditionalOnJndi：在JNDI存在时查找指定的位置
@ConditionalOnMissingBean：当SpringIoc容器内不存在指定Bean的条件
@ConditionalOnMissingClass：当SpringIoc容器内不存在指定Class的条件
@ConditionalOnNotWebApplication：当前项目不是Web项目的条件
@ConditionalOnProperty：指定的属性是否有指定的值
@ConditionalOnResource：类路径是否有指定的值
@ConditionalOnSingleCandidate：当指定Bean在SpringIoc容器内只有一个，或者虽然有多个但是指定首选的Bean
@ConditionalOnWebApplication：当前项目是Web项目的条件

以上注解都是元注解@Conditional演变而来的，根据不用的条件对应创建以上的具体条件注解。

四、启动流程

  1. 初始化各种属性
    -环境属性(Environment)
    -系统配置(spring.factories)
    -参数(Arguments、application.properties)
  2. 创建Spring容器对象ApplicationContext，加载各种配置。

五、事件监听机制

事件的定义：继承ApplicationEvent类即可。

事件监听器的两种方式：

  1. 实现 ApplicationListener 接口
    • 根据接口泛型确定事件类型
  2. @EventListener 标注监听方法
    • 根据监听器方法参数确定事件类型
    • 解析时机：在 SmartInitializingSingleton（所有单例初始化完成后），解析每个单例 bean

实现 ApplicationListener 接口的方式

// 定义事件
class MyEvent extends ApplicationEvent { // 事件类需继承ApplicationEvent
    public MyEvent(Object source) {
        super(source);
    }
}

@Component
class MyService {
    private static final Logger log = LoggerFactory.getLogger(MyService.class);
    @Autowired
    private ApplicationEventPublisher publisher; // 就是applicationContext
    public void doBusiness() {
        log.debug("主线业务");
        // 主线业务完成后需要做一些支线业务（发布事件）
        // 通过bean容器发布
        publisher.publishEvent(new MyEvent("MyService.doBusiness()"));
    }
}

// 监听器
@Component
class SmsApplicationListener implements ApplicationListener<MyEvent> { //实现ApplicationListener<T>，T是事件类型
    private static final Logger log = LoggerFactory.getLogger(SmsApplicationListener.class);
    
    // 主线业务发布事件时，监听器会收到事件，此方法会被触发调用
    @Override
    public void onApplicationEvent(MyEvent event) {
        log.debug("发送短信");
    }
}

@Component
class EmailApplicationListener implements ApplicationListener<MyEvent> {
    private static final Logger log = LoggerFactory.getLogger(EmailApplicationListener.class);
    @Override
    public void onApplicationEvent(MyEvent event) {
        log.debug("发送邮件");
    }
}

使用@EventListener注解标注监听器

// 定义事件
class MyEvent extends ApplicationEvent { // 事件类需继承ApplicationEvent
    public MyEvent(Object source) {
        super(source);
    }
}

@Component
class MyService {
    private static final Logger log = LoggerFactory.getLogger(MyService.class);
    @Autowired
    private ApplicationEventPublisher publisher; // 就是applicationContext
    public void doBusiness() {
        log.debug("主线业务");
        // 主线业务完成后需要做一些支线业务（发布事件）
        // 通过bean容器发布
        publisher.publishEvent(new MyEvent("MyService.doBusiness()"));
    }
}

@Component
class SmsService {
    private static final Logger log = LoggerFactory.getLogger(SmsService.class);
    
    // 监听器
    @EventListener
    public void listener(MyEvent myEvent) {
        log.debug("发送短信");
    }
}

@Component
class EmailService {
    private static final Logger log = LoggerFactory.getLogger(EmailService.class);
    @EventListener
    public void listener(MyEvent myEvent) {
        log.debug("发送邮件");
    }
}

异步处理

// 把监听器交给线程池去执行
@Bean
public ThreadPoolTaskExecutor executor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(3);
    executor.setMaxPoolSize(10);
    executor.setQueueCapacity(100);
    return executor;
}

@Bean
public SimpleApplicationEventMulticaster applicationEventMulticaster(ThreadPoolTaskExecutor executor) {
    SimpleApplicationEventMulticaster multicaster = new SimpleApplicationEventMulticaster();
    multicaster.setTaskExecutor(executor);
    return multicaster;
}
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 218,682评论 6赞 507
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 93,277评论 3赞 395
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 165,083评论 0赞 355
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 58,763评论 1赞 295
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 67,785评论 6赞 392
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 51,624评论 1赞 305
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 40,358评论 3赞 418
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 39,261评论 0赞 276
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,722评论 1赞 315
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,900评论 3赞 336
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 40,030评论 1赞 350
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,737评论 5赞 346
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 41,360评论 3赞 330
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,941评论 0赞 22
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 33,057评论 1赞 270
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 48,237评论 3赞 371
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,976评论 2赞 355

推荐阅读更多精彩内容