Spring源码解读---底层核心概念解析
Posted *King*
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Spring源码解读---底层核心概念解析相关的知识,希望对你有一定的参考价值。
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源码解读---底层核心概念解析的主要内容,如果未能解决你的问题,请参考以下文章