Spring源码解读（3）---底层核心概念解析

本文主要是介绍Spring源码解读（3）---底层核心概念解析，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

1、BeanDefinition

BeanDefinition表示Bean定义，BeanDefinition中存在很多属性用来描述一个Bean的特点。比如：

class：表示Bean类型
scope：表示Bean作用域，单例或原型
lazyInit：表示Bean是否是懒加载
initMethodName：表示Bean初始化时要执行的方法
destroyMethodName：表示Bean销毁时要执行的方法
等。。。

Spring中经常会用到的申明式定义Bean的方式：、@Bean、@Component(@Service，@Controller)

当然也可以用编辑式定义Bean，那就是直接通过BeanDefiniton，如：

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
        beanDefinition.setBeanClass(User.class);
        beanDefinition.setScope("prototype"); // 设置作用域
        beanDefinition.setInitMethodName("init"); // 设置初始化方法
        beanDefinition.setLazyInit(true); // 设置懒加载
        context.registerBeanDefinition("user",beanDefinition);
        System.out.println(context.getBean("user"));

申明式事务、编辑式事务所定义的Bean，都会被Spring解析为对应的BeanDefinition对象，并放入Spring容器中。

2、BeanDefinitionReader（BeanDefinition读取器）

AnnotatedBeanDefinitionReader

可以直接把某个类转换为BeanDefinition，并且会解析该类上的注解

它能解析的注解是：@Conditional，@Scope、@Lazy、@Primary、@DependsOn、 @Role、@Description

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        AnnotatedBeanDefinitionReader annotatedBeanDefinitionReader = new AnnotatedBeanDefinitionReader(context);
        //将User.class解析为BeanDefinition
        annotatedBeanDefinitionReader.register(User.class);
        System.out.println(context.getBean("user"));

XmlBeanDefinitionReader

它能解析标签

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        XmlBeanDefinitionReader xmlBeanDefinitionReader = new XmlBeanDefinitionReader(context);
        int i = xmlBeanDefinitionReader.loadBeanDefinitions("spring.xml");
        System.out.println(context.getBean("user"));

ClassPathBeanDefinitionScanner

ClassPathBeanDefinitionScanner是扫描器，但它的作用和BeanDefinitionReader类似，它可以进行扫描，扫描某个包路径，对扫描的类进行解析，如扫描到的类上存在@Component注解，那么就会把这个类解析为一个BeanDefinition。

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(context);
        scanner.scan("com.example");
        System.out.println(context.getBean("user"));

3、BeanFactory

BeanFactory表示Bean工厂，会负责创建Bean，并提供获取Bean的API。

而ApplicationContext是BeanFactory的一种，Spring源码中是这样定义的：
在这里插入图片描述

ApplicationContext继承了ListableBeanFactory, HierarchicalBeanFactory，而ListableBeanFactory, HierarchicalBeanFactory都继承至BeanFactory。所以我们可认为ApplicationContext继承了BeanFactory，拥有BeanFactory支持的所有功能，还拥有其他功能，比如MessageSource表示国际化， ApplicationEventPublisher表示事件发布，EnvironmentCapable表示获取环境变量，等等。

在Spring源码中，当我们new一个ApplicationContext时，其底层会new一个BeanFactory出来，当使用ApplicationContext中的某些方法如getBean()，底层调用的是BeanFactory的getBean方法。

BeanFactory接口的一个非常重要的实现类是：DefaultListableBeanFactory

DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
        beanDefinition.setBeanClass(User.class);
        beanFactory.registerBeanDefinition("user",beanDefinition);
        System.out.println(beanFactory.getBean("user"));

DefaultListableBeanFactory的类继承实现结构
在这里插入图片描述
DefaultListableBeanFactory拥有很多功能：

AliasRegistry：支持别名功能，一个名字可以对应多个别名
BeanDefinitionRegistry：可以注册、保存、移除、获取某个BeanDefinition
BeanFactory：Bean工厂，可以根据某个bean的名字、或类型、或别名获取某个Bean对象
SingletonBeanRegistry：可以直接注册、获取某个单例Bean
SimpleAliasRegistry：它是一个类，实现了AliasRegistry接口中所定义的功能，支持别名功能
ListableBeanFactory：在BeanFactory的基础上，增加了其他功能，可以获取所有BeanDefinition的beanNames，可以根据某个类型获取对应的beanNames，可以根据某个类型获取{类型：对应的Bean}的映射关系
HierarchicalBeanFactory：在BeanFactory的基础上，添加了获取父BeanFactory的功能
DefaultSingletonBeanRegistry：它是一个类，实现了SingletonBeanRegistry接口，拥有了直接注册、获取某个单例Bean的功能
ConfigurableBeanFactory：在HierarchicalBeanFactory和SingletonBeanRegistry的基础上，添加了设置父BeanFactory、类加载器（表示可以指定某个类加载器进行类的加载）、设置 Spring EL表达式解析器（表示该BeanFactory可以解析EL表达式）、设置类型转化服务（表示该BeanFactory可以进行类型转化）、可以添加BeanPostProcessor（表示该BeanFactory支持 Bean的后置处理器），可以合并BeanDefinition，可以销毁某个Bean等等功能
FactoryBeanRegistrySupport：支持了FactoryBean的功能
. AutowireCapableBeanFactory：是直接继承了BeanFactory，在BeanFactory的基础上，支持在创建Bean的过程中能对Bean进行自动装配
AbstractBeanFactory：实现了ConfigurableBeanFactory接口，继承了 FactoryBeanRegistrySupport，这个BeanFactory的功能已经很全面了，但是不能自动装配和获取beanNames
ConfigurableListableBeanFactory：继承了ListableBeanFactory、 AutowireCapableBeanFactory、ConfigurableBeanFactory
AbstractAutowireCapableBeanFactory：继承了AbstractBeanFactory，实现了 AutowireCapableBeanFactory，拥有了自动装配的功能
DefaultListableBeanFactory：继承了AbstractAutowireCapableBeanFactory，实现了 ConfigurableListableBeanFactory接口和BeanDefinitionRegistry接口，所以 DefaultListableBeanFactory的功能很强大

4、ApplicationContext

在这里插入图片描述

HierarchicalBeanFactory：拥有获取父BeanFactory的功能
ListableBeanFactory：拥有获取beanNames的功能
ResourcePatternResolver：资源加载器，可以一次性获取多个资源（文件资源等等）
EnvironmentCapable：可以获取运行时环境（没有设置运行时环境功能）
ApplicationEventPublisher：拥有广播事件的功能（没有添加事件监听器的功能）
MessageSource：拥有国际化功能

ApplicationContext两个比较重要的实现类：AnnotationConfigApplicationContext、ClassPathXmlApplicationContext

AnnotationConfigApplicationContext
在这里插入图片描述

ClassPathXmlApplicationContext
在这里插入图片描述
国际化

ApplicationContext拥有国际化的功能

    @Bean
    public MessageSource messageSource(){
        ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
        messageSource.setBasename("message");
        return messageSource;
    }

有了这个Bean，你可以在你任意想要进行国际化的地方使用该MessageSource。同时，因为 ApplicationContext也拥有国家化的功能，所以可以直接用

context.getMessage("test", null, new Locale("en_CN")

资源加载

ApplicationContext还拥有资源加载的功能，可以直接得上用ApplicationContext获取某个文件的内容

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        Resource resource = context.getResource("file://D:\\testaa001.txt");
        System.out.println(resource.contentLength());
        System.out.println(resource.getFilename());

        Resource resource1 = context.getResource("https://www.baidu.com");
        System.out.println(resource1.contentLength());
        System.out.println(resource1.getURL());

        Resource resource2 = context.getResource("classpath:com/example/spring/Test.class");
        System.out.println(resource2.contentLength());
        System.out.println(resource2.getURL());

        Resource[] resources = context.getResources("classpath:com/example/spring/*.class");
        for (Resource resource3 : resources) {
            System.out.println(resource3.contentLength());
            System.out.println(resource3.getFilename());
        }

运行结果：
在这里插入图片描述

获取运行时环境

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        Map<String,Object> systemEnvironment = context.getEnvironment().getSystemEnvironment();
        System.out.println(systemEnvironment);

        Map<String,Object> systemProperties = context.getEnvironment().getSystemProperties();
        System.out.println(systemProperties);

        MutablePropertySources propertySources = context.getEnvironment().getPropertySources();
        System.out.println(propertySources);

        System.out.println("---------------------");
        System.out.println(context.getEnvironment().getProperty("NO_PROXY"));
        System.out.println(context.getEnvironment().getProperty("sun.jnu.encoding"));
        System.out.println(context.getEnvironment().getProperty("spring"));

可以通过@PropertySource(“classpath:spring.properties”)来使得某个properties文件中的参数添加到运行时环境中。

事件发布

定义一个事件监听器

@Bean
    public ApplicationListener applicationListener(){
        return new ApplicationListener() {
            @Override
            public void onApplicationEvent(ApplicationEvent event) {
                System.out.println("接收到了一个事件");
            }
        };
    }

然后再发布一个事件

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        context.publishEvent("aaa");

类型转化

1、JDK中提供的类型转化工具：PropertyEditor

public class StringToUser extends PropertyEditorSupport implements PropertyEditor {

    @Override
    public void setAsText(String text) throws IllegalArgumentException {
        User user = new User();
        user.setName(text);
        this.setValue(user);
    }
}

StringToUser stringToUser = new StringToUser();
stringToUser.setAsText("小明");
User user = (User) stringToUser.getValue();
System.out.println(user);

向Spring中注册propertyEditor

    @Bean
    public CustomEditorConfigurer customEditorConfigurer() {
        CustomEditorConfigurer customEditorConfigurer = new CustomEditorConfigurer();
        Map<Class<?>, Class<? extends PropertyEditor>> propertyEditorMap = new HashMap<>();
        // 表示StringToUserPropertyEditor可以将String转化成User类型，在Spring源码中，如果发现当前
        //对象是String，而需要的类型是User，就会使用该PropertyEditor来做类型转化
        propertyEditorMap.put(User.class, StringToUser.class);
        customEditorConfigurer.setCustomEditors(propertyEditorMap);
        return customEditorConfigurer;
    }

假设有如下的Bean

@Component
public class UserService {

    @Value("小ming")
    private User user;

    public void test(){
        System.out.println(user.getName());
    }
}

在这里插入图片描述
2、Spring中提供的类型转化服务ConversionService，它比PropertyEditor更强大

写一个类实现ConditionalGenericConverter，重写里面的方法

public class StringToUserConverter implements ConditionalGenericConverter {
    @Override
    public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
        return sourceType.getType().equals(String.class) && targetType.getType().equals(User.class);
    }

    @Override
    public Set<ConvertiblePair> getConvertibleTypes() {
        return Collections.singleton(new ConvertiblePair(String.class,User.class));
    }

    @Override
    public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
        User user = new User();
        user.setName((String) source);
        return user;
    }
}

DefaultConversionService conversionService = new DefaultConversionService();
        conversionService.addConverter(new StringToUserConverter());
        User user = conversionService.convert("小明",User.class);
        System.out.println(user.getName());

在这里插入图片描述
向Spring中注册ConversionService

@Bean
    public ConversionServiceFactoryBean conversionService(){
        ConversionServiceFactoryBean conversionServiceFactoryBean = new ConversionServiceFactoryBean();
        conversionServiceFactoryBean.setConverters(Collections.singleton(new StringToUserConverter()));
        return conversionServiceFactoryBean;
    }

3、TypeConverter整合了PropertyEditor和ConversionService的功能，是Spring内部用的

SimpleTypeConverter typeConverter = new SimpleTypeConverter();
typeConverter.registerCustomEditor(User.class,new StringToUser());
User user = typeConverter.convertIfNecessary("小明明",User.class);
System.out.println(user.getName());

在这里插入图片描述
OrderComparator

OrderComparator是Spring提供的一种比较器，可以用来根据@Order注解或实现Ordered接口来执行值进行比较，从而可以进行排序。

public class A implements Ordered {
    @Override
    public int getOrder() {
        return 3;
    }

    @Override
    public String toString() {
        return this.getClass().getSimpleName();
    }
}

public class B implements Ordered {
    @Override
    public int getOrder() {
        return 2;
    }

    @Override
    public String toString() {
        return this.getClass().getSimpleName();
    }
}

 A a = new A();
 B b = new B();
 OrderComparator comparator = new OrderComparator();
 System.out.println(comparator.compare(a,b));

List list = new ArrayList<>();
list.add(a);
list.add(b);
list.sort(comparator);
System.out.println(list);

在这里插入图片描述
Spring中还提供了一个OrderComparator的子类：AnnotationAwareOrderComparator，它支持用@Order来指定order值。

@Order(3)
public class A {

    @Override
    public String toString() {
        return this.getClass().getSimpleName();
    }
}

@Order(2)
public class B{

    @Override
    public String toString() {
        return this.getClass().getSimpleName();
    }
}

A a = new A();
B b = new B();
AnnotationAwareOrderComparator comparator = new AnnotationAwareOrderComparator();
System.out.println(comparator.compare(a,b));

List list = new ArrayList<>();
list.add(a);
list.add(b);
list.sort(comparator);
System.out.println(list);

在这里插入图片描述

5、BeanPostProcessor

BeanPostProcess表示Bena的后置处理器，我们可以定义一个或多个BeanPostProcessor

@Component
public class WlBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if("userService".equals(beanName)){
            System.out.println("初始化前");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if("userService".equals(beanName)){
            System.out.println("初始化后");
        }
        return bean;
    }
}

在这里插入图片描述
一个BeanPostProcessor可以在任意一个Bean的初始化之前以及初始化之后去额外的做一些用户自定义的逻辑。我们可以通过判断beanName来进行针对性处理（针对某个Bean或某部门Bean），我们可以通过定义BeanPostProcessor来干涉Spring创建Bean的过程。

6、BeanFactoryPostProcessor

BeanFactoryPostProcessor表示Bean工厂的后置处理器，其实和BeanPostProcessor类似。

BeanPostProcessor是干涉Bean的创建过程，BeanFactoryPostProcessor是干涉BeanFactory的创建过程。

@Component
public class WlBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("加工beanFactory");
    }
}

7、FactoryBean

通过FactoryBean我们可以自己创建一个Bean

@Component
public class WlFactoryBean implements FactoryBean {
    @Override
    public Object getObject() throws Exception {
        UserService userService = new UserService();
        return userService;
    }

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

通过上面的代码我们创建了一个UserService对象，它也是个Bean，但通过这种方式创建出来的UserService的Bean，只会经过初始化后，其他Spring的生命周期步骤是不会经过的，比如依赖注入。与@Bean生成的对象作为Bean的区别是：@Bean定义的Bean是会经过完整的Bean生命周期的。

8、ExcludeFilter和IncludeFilter

这两个Filter是Spring扫描过程中用来过滤的，ExcludeFilter表示排除过滤器，IncludeFilter表示包含过滤器

以下配置，表示扫描com.example包下所有类时排除UserService类，就算它上面有@Component注解也不会成为Bean

@ComponentScan(value = "com.example",
        excludeFilters = {@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,
                classes = UserService.class)})
@Configuration
public class AppConfig {
}

以下配置就算UserService类上没有@Component注解，它也会被扫描成为一个Bean

@ComponentScan(value = "com.example",
        includeFilters = {@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,
                classes = UserService.class)})
@Configuration
public class AppConfig {
}

FilterType分为：

ANNOTATION：表示是否包含某个注解
ASSIGNABLE_TYPE：表示是否是某个类
ASPECTJ：表示否是符合某个Aspectj表达式
REGEX：表示是否符合某个正则表达式
CUSTOM：自定义

在Spring的扫描逻辑中，会默认添加一个AnnotationTypeFilter给includeFilters，表示默认情况下Spring扫描过程中会认为类上有@Component注解的就是Bean。

9、MetadataReader、ClassMetadata、 AnnotationMetadata

在Spring中需要去解析类的信息，比如类名，类中的方法，类上的注解，这些都可以称之为类的元数据，所以Spring中对类的元数据做了抽象，并提供了一些工具类。

MetadataReader表示类的元数据读取器，默认实现类为SimpleMetadataReader。SimpleMetadataReader去解析类时，使用的ASM技术。

SimpleMetadataReaderFactory simpleMetadataReaderFactory = new SimpleMetadataReaderFactory();
        //构造一个MetadataReader
        MetadataReader metadataReader = simpleMetadataReaderFactory.getMetadataReader("com.example.spring.UserService");
        //得到一个ClassMetadata，并获取了类名
        ClassMetadata classMetadata = metadataReader.getClassMetadata();
        System.out.println(classMetadata.getClassName());
        //获取一个AnnotationMetadata，并获取类上的注解信息
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
        for (String annotationType : annotationMetadata.getAnnotationTypes()) {
            System.out.println(annotationType);
        }

在这里插入图片描述

这篇关于Spring源码解读（3）---底层核心概念解析的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程