Spring源码解析之基础应用

Posted 2020-12-20 北洛

组合Java配置

在XML中，我们可以使用<import/>标签，在一个XML文件中引入另一个XML文件，在Java类中，我们同样可以在一个配置类中用@Import引入另一个配置类，被引入的配置类中的@Bean也会加载到spring容器。代码如下：

@Configuration
public class ConfigA {

    @Bean
    public A a() {
        return new A();
    }
}

@Configuration
@Import(ConfigA.class)
public class ConfigB {

    @Bean
    public B b() {
        return new B();
    }
}

　　

我们将ConfigB作为配置类传给AnnotationConfigApplicationContext进行spring容器初始化，我们不但可以从spring容器中获得A和B所对应的bean，还可以得到ConfigA和ConfigB所对应的bean：

public static void main(String[] args) {
    ApplicationContext ctx = new AnnotationConfigApplicationContext(ConfigB.class);

    A a = ctx.getBean(A.class);
    B b = ctx.getBean(B.class);
    ConfigA configA = ctx.getBean(ConfigA .class);
    ConfigB configB = ctx.getBean(ConfigB.class);
}

　　

事实上，@Import并不要求我们引入一个配置类，我们也可以引入一个普通的类，spring容器同样会帮我们把这个类初始化成一个bean：

package org.example.config;

import org.example.beans.D;
import org.springframework.context.annotation.Import;

@Import(D.class)
public class MyConfig3 {
}

package org.example.beans;

public class D {
}

　　

测试用例：

    @Test
    public void test10() {
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(MyConfig3.class);
        System.out.println(ac.getBean(D.class));
    }

　　

运行结果：

org.example.beans.D@134593bf

　　

利用@Import，我们可以把一些第三方的插件引入spring容器初始化为bean，当然，我们也可以在一个方法里返回插件的实例，方法用@Bean注解标注。不过，笔者认为，用@Import或者@Bean来引入bean还是分情况的，如果是引入一个类似DataSource的数据源的bean，我们要在方法里指定数据源的地址、用户名、密码，那么我们可以用@Bean，如果我们需要引入的第三方插件不需要设置额外的属性，则可以用@Import。

我们还可以用@Import来引入一个ImportBeanDefinitionRegistrar接口的实现，spring容器会帮我们回调ImportBeanDefinitionRegistrar接口的实现，在ImportBeanDefinitionRegistrar接口的实现内，我们可以往spring容器注册一个BeanDefinition，spring容器会根据BeanDefinition生成一个bean，BeanDefinition用来描述一个bean的class对象，比如这个bean的class是什么？作用域是单例还是原型？是否懒加载？等等。几乎可以认为，只要是存在于spring容器中的bean，都会有一个对应的BeanDefinition来描述这个bean。我们先来看下BeanDefinition接口的部分方法：

package org.springframework.beans.factory.config;
……
public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
	……
	//设置bean所对应的class
	void setBeanClassName(@Nullable String beanClassName);
	//获取bean所对应的class
	String getBeanClassName();
	//设置bean的作用域
	void setScope(@Nullable String scope);
	//获取bean的作用域
	String getScope();
	//设置bean是否懒加载
	void setLazyInit(boolean lazyInit);
	//判断bean是否懒加载
	boolean isLazyInit();
	//设置bean在初始化前需要的依赖项
	void setDependsOn(@Nullable String... dependsOn);
	//获取bean在初始化前需要的依赖项
	String[] getDependsOn();
	……
}

　　

 ImportBeanDefinitionRegistrar可以让我们重写两个方法，从方法名可以看出，注册BeanDefinition，第一个方法仅比第二个多一个参数importBeanNameGenerator，为beanName生成器。

public interface ImportBeanDefinitionRegistrar {
	default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry,
			BeanNameGenerator importBeanNameGenerator) {

		registerBeanDefinitions(importingClassMetadata, registry);
	}
	
	default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
	}
}

　　

我们在MyImportBeanDefinitionRegistrar里重写了registerBeanDefinitions，由于BeanDefinition是接口，所以我们用spring编写好的实现类GenericBeanDefinition进行注册，我们声明了一个GenericBeanDefinition后并设置其对应的属性，然后将beanName和BeanDefinition注册进registry：

package org.example.beans;

import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.GenericBeanDefinition;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
        beanDefinition.setBeanClass(D.class);
        registry.registerBeanDefinition("d", beanDefinition);
    }
}

package org.example.beans;

public class D {
}

　　

 我们在MyConfig4中@Import进MyImportBeanDefinitionRegistrar，并在后面的测试用例中把MyConfig4传入应用上下文进行初始化。

package org.example.config;

import org.example.beans.MyImportBeanDefinitionRegistrar;
import org.springframework.context.annotation.Import;

@Import(MyImportBeanDefinitionRegistrar.class)
public class MyConfig4 {
}

　　

测试用例中我们根据在MyImportBeanDefinitionRegistrar注册的beanName获取bean，从运行结果可以看到，spring会根据我们传入的BeanDefinition创建bean。

    @Test
    public void test11() {
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(MyConfig4.class);
        System.out.println(ac.getBean("d"));
    }

　　

运行结果：

org.example.beans.D@4b53f538

　　

关于上面说的BeanDefinition如果看不懂的话可以先略过，后面还会再详讲BeanDefinition。

 

@DependsOn

有时候我们存在这样的需求：AService初始化之前，BService必须先初始化，AService不通过属性或构造函数参数显式依赖于BService。比如：AService负责产出消息，BService负责消费消息，最理想的做法是BService必须先AService初始化，让消息能及时消费掉，而spring创建bean的顺序是不固定的，所以我们可以使用@DependsOn来要求在初始化AService之前必须先初始化BService。

package org.example.beans;

import org.springframework.context.annotation.DependsOn;
import org.springframework.stereotype.Component;

@Component
@DependsOn({"c"})
public class B {
    public B() {
        System.out.println("B construct...");
    }
}

package org.example.beans;

import org.springframework.stereotype.Component;

@Component
public class C {

    public C() {
        System.out.println("C construct...");
    }
}

package org.example.config;

import org.springframework.context.annotation.ComponentScan;

@ComponentScan("org.example.beans")
public class MyConfig5 {
}

　　

测试用例：

    @Test
    public void test12() {
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(MyConfig5.class);
    }

　　

运行结果：

C construct...
B construct...

　　

我们在B类声明对C类的依赖，所以spring在创建bean的先创建C再创建B，大家也可以尝试下，把B类上的@DependsOn去掉，spring会先创建B再创建C。

FactoryBean

当创建一个bean的逻辑十分复杂，不适合以@Bean来标注方法返回时，我们可以创建一个类并实现FactoryBean接口，然后在FactoryBean的实现中编写复杂的创建逻辑。我们来看下FactoryBean接口：

public interface FactoryBean<T> {
	//返回工厂所创建的实例，实例可被共享，取决于这个实例是单例还是原型
	T getObject() throws Exception;
	//返回bean的class对象
	Class<?> getObjectType();
	//返回bean是否单例
	default boolean isSingleton() {
		return true;
	}
}

　　

我们编写一个机器人FactoryBean（RobotFactoryBean）用来产生机器人（Robot）对象：

package org.example.beans;

import org.springframework.beans.factory.FactoryBean;
import org.springframework.stereotype.Component;

@Component
public class RobotFactoryBean implements FactoryBean<Robot> {
    @Override
    public Robot getObject() throws Exception {
        return new Robot();
    }

    @Override
    public Class<?> getObjectType() {
        return Robot.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }
}


package org.example.beans;

public class Robot {
}

　　

一般我们通过beanName来获取bean时，都是通过类名来获取，但FactoryBean有点特殊，如果我们要获取Robot这个bean，需要传入它的工厂名称robotFactoryBean，如果我们需要获取工厂对象本身，则在robotFactoryBean前面加一个‘&‘符号。

    @Test
    public void test13() {
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(MyConfig5.class);
        Object robot = ac.getBean("robotFactoryBean");
        System.out.println(robot);
        System.out.println(robot.getClass());
        Object factoryBean = ac.getBean("&robotFactoryBean");
        System.out.println(factoryBean);
        System.out.println(factoryBean.getClass());
    }

　　

运行结果：

org.example.beans.Robot@6b1274d2
class org.example.beans.Robot
org.example.beans.RobotFactoryBean@7bc1a03d
class org.example.beans.RobotFactoryBean