浅谈springboot自动装配原理

一、SpringBootApplication

@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 {

@Target(ElementType.TYPE)

设置当前注解可以标记在哪里,而SpringBootApplication只能用在类上面
还有一些其他的设置

public enum ElementType {
    /** Class, interface (including annotation type), or enum declaration */
    TYPE,

    /** Field declaration (includes enum constants) */
    FIELD,

    /** Method declaration */
    METHOD,

    /** Formal parameter declaration */
    PARAMETER,

    /** Constructor declaration */
    CONSTRUCTOR,

    /** Local variable declaration */
    LOCAL_VARIABLE,

    /** Annotation type declaration */
    ANNOTATION_TYPE,

    /** Package declaration */
    PACKAGE,

    /**
     * Type parameter declaration
     *
     * @since 1.8
     */
    TYPE_PARAMETER,

    /**
     * Use of a type
     *
     * @since 1.8
     */
    TYPE_USE,

    /**
     * Module declaration.
     *
     * @since 9
     */
    MODULE
}

@Retention(RetentionPolicy.RUNTIME)

public enum RetentionPolicy {
    /**
     * Annotations are to be discarded by the compiler.
     */
    SOURCE,

    /**
     * Annotations are to be recorded in the class file by the compiler
     * but need not be retained by the VM at run time.  This is the default
     * behavior.
     */
    CLASS,

    /**
     * Annotations are to be recorded in the class file by the compiler and
     * retained by the VM at run time, so they may be read reflectively.
     *
     * @see java.lang.reflect.AnnotatedElement
     */
    RUNTIME
}

SOURCE 当编译时,注解将不会出现在class源文件中

CLASS 注解将会保留在class源文件中,但是不会被jvm加载,也就意味着不能通过反射去找到该注解,因为没有加载到java虚拟机中

RUNTIME是既会保留在源文件中,也会被虚拟机加载

@Documented

java doc 会生成注解信息

@Inherited

是否会被继承,就是如果一个子类继承了使用了该注解的类,那么子类也能继承该注解

@SpringBootConfiguration

标注在某个类上,表示这是一个Spring Boot的配置类,本质上也是使用了@Configuration注解

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {

@EnableAutoConfiguration

@EnableAutoConfiguration告诉SpringBoot开启自动配置,会帮我们自动去加载 自动配置类

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

@AutoConfigurationPackage

将当前配置类所在包保存在BasePackages的Bean中。供Spring内部使用

@Import({AutoConfigurationImportSelector.class})来加载配置类

配置文件的位置:META-INF/spring.factories,该配置文件中定义了大量的配置类,当springboot启动时,会自动加载这些配置类,初始化Bean

并不是所有Bean都会被初始化,在配置类中使用Condition来加载满足条件的Bean

二、案例

自定义redis-starter,要求当导入redis坐标时,spirngboot自动创建jedis的Bean

步骤

1.创建redis-spring-boot-autoconfigure模块
2.创建redis-spring-boot-starter模块,依赖redis-spring-boot-autoconfigure的模块
3.在redis-spring-boot-autoconfigure模块中初始化jedis的bean,并定义META-INF/spring.factories文件
4.在测试模块中引入自定义的redis-starter依赖,测试获取jedis的bean,操作redis

1.首先新建两个模块


删除一些没有用的东西,和启动类否则会报错

2.redis-spring-boot-starter模块的pom.xml里面引入redis-spring-boot-autoconfigure的模块的坐标

3.RedisAutoConfiguration配置类

package com.blb;

import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.Jedis;

@Configuration
@EnableConfigurationProperties(RedisProperties.class)
public class RedisAutoConfiguration {
//  提供Jedis的bean
    @Bean
    public Jedis jedis(RedisProperties redisProperties){
        return new Jedis(redisProperties.getHost(),redisProperties.getPort());
    }
}

RedisProperties

package com.blb;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "redis")
public class RedisProperties {
    private String host="localhost";
    private int port=6379;

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }
}

@ComponentScan

扫描包 相当于在spring.xml 配置中context:comonent-scan 但是并没有指定basepackage,如果没有指定spring底层会自动扫描当前配置类所有在的包

排除的类型

public enum FilterType {

	/**
	 * Filter candidates marked with a given annotation.
	 * @see org.springframework.core.type.filter.AnnotationTypeFilter
	 */
	ANNOTATION,

	/**
	 * Filter candidates assignable to a given type.
	 * @see org.springframework.core.type.filter.AssignableTypeFilter
	 */
	ASSIGNABLE_TYPE,

	/**
	 * Filter candidates matching a given AspectJ type pattern expression.
	 * @see org.springframework.core.type.filter.AspectJTypeFilter
	 */
	ASPECTJ,

	/**
	 * Filter candidates matching a given regex pattern.
	 * @see org.springframework.core.type.filter.RegexPatternTypeFilter
	 */
	REGEX,

	/** Filter candidates using a given custom
	 * {@link org.springframework.core.type.filter.TypeFilter} implementation.
	 */
	CUSTOM

}

ANNOTATION 默认根据注解的完整限定名设置排除
ASSIGNABLE_TYPE 根据类的完整限定名排除
ASPECTJ 根据切面表达式设置排除
REGEX 根据正则表达式设置排除
CUSTOM 自定义设置排除

@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })

按照自定义的方式来排除需要指定一个类,要实现TypeFilter接口,重写match方法

public class TypeExcludeFilter implements TypeFilter, BeanFactoryAware {

public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
        if (this.beanFactory instanceof ListableBeanFactory && this.getClass() == TypeExcludeFilter.class) {
            Iterator var3 = this.getDelegates().iterator();

            while(var3.hasNext()) {
                TypeExcludeFilter delegate = (TypeExcludeFilter)var3.next();
                if (delegate.match(metadataReader, metadataReaderFactory)) {
                    return true;
                }
            }
        }

        return false;
    }
}

TypeExcludeFilter :springboot对外提供的扩展类, 可以供我们去按照我们的方式进行排除

AutoConfigurationExcludeFilter :排除所有配置类并且是自动配置类中里面的其中一个
示例

package com.blb.springbootyuanli.config;

import org.springframework.boot.context.TypeExcludeFilter;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;

import java.io.IOException;

public class MyTypeExcludeFilter extends TypeExcludeFilter {
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
        if(metadataReader.getClassMetadata().getClass()==UserConfig.class){
            return true;
        }
        return false;
    }
}

三、Condition

@Conditional是Spring4新提供的注解,它的作用是按照一定的条件进行判断,满足条件给容器注册bean,实现选择性的创建bean的操作,该注解为条件装配注解

源码

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Conditional {

	/**
	 * All {@link Condition} classes that must {@linkplain Condition#matches match}
	 * in order for the component to be registered.
	 */
	Class<? extends Condition>[] value();

}
@FunctionalInterface
public interface Condition {

	/**
	 * Determine if the condition matches.
	 * @param context the condition context
	 * @param metadata the metadata of the {@link org.springframework.core.type.AnnotationMetadata class}
	 * or {@link org.springframework.core.type.MethodMetadata method} being checked
	 * @return {@code true} if the condition matches and the component can be registered,
	 * or {@code false} to veto the annotated component's registration
	 */
	boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);

}

重写matches方法如果返回true spring则会帮你创建该对象,否则则不会

springboot提供的常用条件注解

@ConditionalOnProperty:判断文件中是否有对应属性和值才实例化Bean
@ConditionalOnClass 检查类在加载器中是否存在对应的类,如果有则被注解修饰的类就有资格被 Spring 容器所注册,否则会被跳过。
@ConditionalOnBean 仅仅在当前上下文中存在某个对象时,才会实例化一个 Bean
@ConditionalOnClass 某个 CLASS 位于类路径上,才会实例化一个 Bean
@ConditionalOnExpression 当表达式为 true 的时候,才会实例化一个 Bean
@ConditionalOnMissingBean 仅仅在当前上下文中不存在某个对象时,才会实例化一个 Bean
@ConditionalOnMissingClass 某个 CLASS 类路径上不存在的时候,才会实例化一个 Bean

案例

在springIOC容器中有一个User的bean,现要求:
引入jedis坐标后,加载该bean,没导入则不加载

实体类

package com.blb.springbootyuanli.entity;

public class User {
    private String name;
    private int age;

	get/set

UserConfig

配置类

package com.blb.springbootyuanli.config;

import com.blb.springbootyuanli.condition.UserCondition;
import com.blb.springbootyuanli.entity.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;

@Configuration
public class UserConfig {
    @Bean
    @Conditional(UserCondition.class)
    public User user(){
        return new User();
    }
}

UserCondition

实现Condition接口,重写matches方法

package com.blb.springbootyuanli.condition;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

public class UserCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //思路判断jedis的class文件是否存在
        boolean flag=true;
        try {

            Class<?> aClass = Class.forName("redis.clients.jedis.Jedis");

        } catch (ClassNotFoundException e) {
            flag=false;
        }
        return flag;
    }
}

启动类

package com.blb.springbootyuanli;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class SpringbootYuanliApplication {

    public static void main(String[] args) {

        ConfigurableApplicationContext app = SpringApplication.run(SpringbootYuanliApplication.class, args);
        Object user = app.getBean("user");
        System.out.println(user);

    }

}

当我们在pom.xml引入jedis的坐标时,就可以打印user对象,当删除jedis的坐标时,运行就会报错 No bean named ‘user' available

四、案例升级

将类的判断定义为动态的,判断那个字节码文件可以动态指定

自定义一个注解

添加上元注解

package com.blb.springbootyuanli.condition;

import org.springframework.context.annotation.Conditional;

import java.lang.annotation.*;

@Target({ElementType.TYPE, ElementType.METHOD}) //该注解的添加范围
@Retention(RetentionPolicy.RUNTIME) //该注解的生效时机
@Documented //生成javadoc的文档

@Conditional(UserCondition.class)
public @interface UserClassCondition {
    String[] value();
}

UserConfig

package com.blb.springbootyuanli.config;

import com.blb.springbootyuanli.condition.UserClassCondition;
import com.blb.springbootyuanli.entity.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class UserConfig {
    @Bean
    //@Conditional(UserCondition.class)
    @UserClassCondition("redis.clients.jedis.Jedis")
    public User user(){
        return new User();
    }
}
package com.blb.springbootyuanli.condition;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

import java.util.Map;

public class UserCondition implements Condition {
    /**
     *
     * @param context 上下文对象,用于获取环境,ioc容器,classloader对象
     * @param metadata 注解元对象。可以获取注解定义的属性值
     * @return
     */
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //思路判断指定属性的class文件是否存在

        //获取注解属性值 value
        Map<String,Object> map=metadata.getAnnotationAttributes(UserClassCondition.class.getName());
        String[] values= (String[])map.get("value");

        boolean flag=true;
        try {
            for(String classname:values){
                Class<?> aClass = Class.forName(classname);
            }

        } catch (ClassNotFoundException e) {
            flag=false;
        }
        return flag;
    }
}

测试自带的注解

package com.blb.springbootyuanli.config;

import com.blb.springbootyuanli.entity.User;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class UserConfig {
    @Bean
    //@Conditional(UserCondition.class)

    //@UserClassCondition("redis.clients.jedis.Jedis")
    @ConditionalOnProperty(name="age",havingValue = "18")
    //只有在配置文件中有age并且值为18spring在能注册该bean
    public User user(){
        return new User();
    }
}

五、小结

自定义条件:

1.定义条件类:自定义类实现Condition接口,重写重写matches方法,在matches方法中进行逻辑判断,返回boolean值

2.matches方法的两个参数:
context:上下文对象,可以获取属性值,获取类加载器,获取BeanFactory
metadata:元数据对象,用于获取注解属性

3.判断条件:在初始化Bean时,使用@Conditional(条件类.class) 注解

到此这篇关于浅谈springboot自动装配原理的文章就介绍到这了,更多相关springboot自动装配内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Springboot自动装配实现过程代码实例

    创建一个简单的项目: <?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/PO

  • 深入浅析SpringBoot中的自动装配

    SpringBoot的自动装配是拆箱即用的基础,也是微服务化的前提.这次主要的议题是,来看看它是怎么样实现的,我们透过源代码来把握自动装配的来龙去脉. 一.自动装配过程分析 1.1.关于@SpringBootApplication 我们在编写SpringBoot项目时,@SpringBootApplication是最常见的注解了,我们可以看一下源代码: /* * Copyright 2012-2017 the original author or authors. * * Licensed un

  • SpringBoot自动装配原理详解

    首先对于一个SpringBoot工程来说,最明显的标志的就是 @SpringBootApplication它标记了这是一个SpringBoot工程,所以今天的 SpringBoot自动装配原理也就是从它开始说起. 自动装配流程 首先我们来看下@SpringBootApplication 这个注解的背后又有什么玄机呢,我们按下 ctrl + 鼠标左键,轻轻的点一下,此时见证奇迹的时刻.. 我们看到如下优雅的代码: 这其中有两个比较容易引起我们注意的地方,一个是@SpringBootConfigur

  • SpringBoot自动配置原理,你真的懂吗?(简单易懂)

    概述 上面博文(SpringBoot简介与快速搭建)我们简单的介绍了什么是SpringBoot,以及如何使用SpringBoot,但是我们对于SpringBoot的基本原理并没有介绍,这篇博文我们重点介绍SpringBoot是如何实现的自动配置. 依赖管理 在我们的pom文件中最核心的依赖就一个: <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-star

  • springboot自动装配原理初识

    运行原理 为了研究,我们正常从父项目的pom.xml开始进行研究. pom.xml 父依赖 spring-boot-starter-parent主要用来管理项目的资源过滤和插件 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.2.5.RELEASE<

  • springboot自动配置原理解析

    前言 小伙伴们都知道,现在市面上最流行的web开发框架就是springboot了,在springboot开始流行之前,我们都用的是strust2或者是springmvc框架来开发web应用,但是这两个框架都有一个特点就是配置非常的繁琐,要写一大堆的配置文件,spring在支持了注解开发之后稍微有些改观但有的时候还是会觉得比较麻烦,这个时候springboot就体现出了它的优势,springboot只需要一个properties或者yml文件就可以简化springmvc中在xml中需要配置的一大堆

  • springboot如何实现自动装配源码解读

    Spring Boot 自动装配 最重要的注解@SpringBootApplication @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @SpringBootConfiguration @EnableAutoConfiguration @ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, c

  • SpringBoot启动及自动装配原理过程详解

    一.servlet2(老spring-mvc) 配置文件: web.xml:主要配置项目启动项 application-context.xml:主要配置项目包扫描.各种bean.事务管理 springMVC.xml:主要配置controller包扫描.视图解析器.参数解析器 启动过程: 每一个spring项目启动时都需要初始化spring-context,对于非web项目可以在程序main方法中触发这个context的初始化过程. 由于web项目的启动入口在容器,所以开发者不能直接触发sprin

  • 浅谈springboot自动装配原理

    一.SpringBootApplication @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @SpringBootConfiguration @EnableAutoConfiguration @ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFi

  • 浅谈springboot自动配置原理

    从main函数说起 一切的开始要从SpringbootApplication注解说起. @SpringBootApplication public class MyBootApplication { public static void main(String[] args) { SpringApplication.run(MyBootApplication.class); } } @SpringBootConfiguration @EnableAutoConfiguration @Compon

  • SpringBoot自动装配原理小结

    约定优于配置(Convention Over Configuration)是一种软件设计范式,目的在于减少配置的数量或者降低理解难度,从而提升开发效率. 先总结一下结论: springboot通过spring.factories能把main方法所在类路径以外的bean自动加载,其目的就是为了帮助自动配置bean,减轻配置量 springboot autoconfig的一些实验 一个springboot工程,springbootautoconfig.test.config这个包和启动类的包不再同一

  • Java SpringBoot自动装配原理详解及源码注释

    目录 一.pom.xml文件 1.父依赖 2.启动器: 二.主程序: 剖析源码注解: 三.结论: 一.pom.xml文件 1.父依赖 主要是依赖一个父项目,管理项目的资源过滤以及插件! 资源过滤已经配置好了,无需再自己配置 在pom.xml中有个父依赖:spring-boot-dependencies是SpringBoot的版本控制中心! 因为有这些版本仓库,我们在写或者引入一些springboot依赖的时候,不需要指定版本! 2.启动器: 启动器也就是Springboot的启动场景; 比如sp

  • 深入了解Java SpringBoot自动装配原理

    目录 自动装配原理 SpringBootApplication EnableAutoConfiguration AutoConfigurationImportSelector 总结 在使用springboot时,很多配置我们都没有做,都是springboot在帮我们完成,这很大一部分归功于springboot自动装配,那springboot的自动装配的原理是怎么实现的呢? 自动装配原理 springboot 版本:2.4.3 SpringBootApplication springboot启动类

  • Java Springboot自动装配原理详解

    目录 Debug路线图 让我们从run说起 归属 小结 run 再说说注解 总结 Debug路线图 说多都是泪,大家看图. 让我们从run说起 用了这么多年的的Springboot,这个 run() 方法到底做了些什么事呢? @SpringBootApplication public class SpringbootDemoApplication { public static void main(String[] args) { SpringApplication.run(Springboot

  • 最新springboot中必须要了解的自动装配原理

    目录 1.pom.xml 2.启动器 3.主程序 3.1注解 3.2 spring.factories 4. 结论 1.pom.xml 父 依 赖 \textcolor{orange}{父依赖} 父依赖 spring-boot-dependencies:核心依赖都在父工程中 这里ctrl+左键,点击之后我们可以看到父依赖 这个里面主要是管理项目的资源过滤及插件,我们发现他还有一个父依赖 看看下面这个,熟悉吗? 再点进去,我们发现有很多的依赖.这就是SpringBoot的版本控制中心. 这个地方才

  • SpringBoot详细分析自动装配原理并实现starter

    目录 约定优于配置 自动装配 手写一个starter组件 约定优于配置 SpringBoot的预定优于配置主要体现在以下几个方面: maven的目录结构: 配置文件默认存放在resources目录下 项目编译后的文件存放在target目录下 项目默认打包成jar格式 配置文件默认为application.yml或application.yaml或application.properties 默认通过 spring.profiles.active 属性来决定运行环境时的配置文件. 自动装配 相对于

随机推荐