目录
// 1. HierarchicalBeanFactory：拥有获取父BeanFactory的功能
// 2. ListableBeanFactory：拥有获取beanNames的功能
// 3. ResourcePatternResolver：资源加载器，可以一次性获取多个资源（文件资源等等）
// 4. EnvironmentCapable：可以获取运行时环境
// 5. ApplicationEventPublisher：拥有广播事件的功能（没有添加事件监听器的功能）
// 6. MessageSource：拥有国际化功能 （不常用）
ClassPathBeanDefinitionScanner
GenericBeanDefinition（Spring内部最常用的）
AnnotatedGenericBeanDefinition 注解，通过AnnotatedBeanDefinitionReader注册的
ScannedGenericBeanDefinition 扫描时的BeanDefinition
基于JDK的类型转换 PropertyEditorSupport
通过@Bean 和BeanFactory 存入的对象 有什么区别
Application 具备的功能
Application 实现的六个接口
// 1. HierarchicalBeanFactory：拥有获取父BeanFactory的功能
A 工厂 B工厂
当去getBean时 如果A工厂获取不到 ， 就会去 B父级工厂获取
// 2. ListableBeanFactory：拥有获取beanNames的功能
展示功能
// 3. ResourcePatternResolver：资源加载器，可以一次性获取多个资源（文件资源等等）
磁盘资源 或者 网络资源
// 4. EnvironmentCapable：可以获取运行时环境
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(KangConfig.class);
ConfigurableEnvironment environment = context.getEnvironment();
Map<String, Object> systemEnvironment = environment.getSystemEnvironment();
System.out.println(systemEnvironment);
Map<String, Object> systemProperties = environment.getSystemProperties();
System.out.println(systemProperties);
上面的变量统一可以使用 environment.getProperty(key) 来获得
可以使用注解 自己 加载一些变量
@PropertySource("classpath:spring.properties")
spring.properties中写的ak47=xxx
// 5. ApplicationEventPublisher：拥有广播事件的功能（没有添加事件监听器的功能）
可以参考这个大佬的
// 6. MessageSource：拥有国际化功能 （不常用）
BeanFactory 接口
DefaultListableBeanFactory
AliasRegistry （实现了 可以设置 别名的 功能）
SingletonBeanRegistry（实现了 单例Bean的功能）
......
ioc内部的一些工具类
ClassPathBeanDefinitionScanner
ClassPathBeanDefinitionScanner classPathBeanDefinitionScanner = new ClassPathBeanDefinitionScanner(context);
classPathBeanDefinitionScanner.scan("com.kang.service");AnnotatedBeanDefinitionReader
AnnotatedBeanDefinitionReader annotatedBeanDefinitionReader = new AnnotatedBeanDefinitionReader(context);
// 会自动 扫描类上的注解
annotatedBeanDefinitionReader.registerBean(OrderService.class);XmlBeanDefinitionReader
// 基于xml的读取
XmlBeanDefinitionReader xmlBeanDefinitionReader = new XmlBeanDefinitionReader(context);
xmlBeanDefinitionReader.loadBeanDefinitions("spring.xml");BeanDefinition（接口）重要的实现类
GenericBeanDefinition（Spring内部最常用的）
AnnotatedGenericBeanDefinition 注解，通过AnnotatedBeanDefinitionReader注册的
private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
@Nullable BeanDefinitionCustomizer[] customizers) {
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);ScannedGenericBeanDefinition 扫描时的BeanDefinition
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<>();
try {
// 获取basePackage下所有的文件资源
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
resolveBasePackage(basePackage) + '/' + this.resourcePattern;
Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
boolean traceEnabled = logger.isTraceEnabled();
boolean debugEnabled = logger.isDebugEnabled();
for (Resource resource : resources) {
if (traceEnabled) {
logger.trace("Scanning " + resource);
}
if (resource.isReadable()) {
try {
// MetadataReader 类的元数据读取器
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
// excludeFilters、includeFilters判断 这个类是不是一个bean
if (isCandidateComponent(metadataReader)) { // @Component-->includeFilters判断
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);RootBeanDefinition 和合并有关系
类型转换
基于JDK的类型转换 PropertyEditorSupport
PropertyEditor（接口）
public class StringToUserProperty extends PropertyEditorSupport {
@Override
public void setAsText(String text) throws IllegalArgumentException {
User user = new User();
user.setName(text);
this.setValue(user);
}
}
StringToUserProperty stringToUserProperty = new StringToUserProperty();
stringToUserProperty.setAsText("kang");
User value = (User)stringToUserProperty.getValue();基于Spring的ConversionService
两个都支持的TypeConverter
排序Order注解 和 Ordered接口
通过 OrderComparator 或者 AnnotationAwareOrderComparator 来比较
OrderComparator orderComparator = new OrderComparator();
int compare = orderComparator.compare(new UserService(), new OrderService());
// 两个order的差值
System.out.println(compare);
// 当作 比较器 来排序
List<Object> objects = new ArrayList<Object>();
objects.add(new UserService());
objects.add(new OrderService());
objects.sort(orderComparator);
System.out.println(objects);
有小到大排序
数据（类）解析器 反射plus
ASM技术
直接解析 字节码 文件
这个不需要 将 类加载到 内存 就可以 获得这个类的所有信息
符合Spring的 用到哪个类时 再加载
方便获得 类的注解 接口 实现的方法 。。。。
MetadataReader
public interface ClassMetadata {
String getClassName();
boolean isInterface();
boolean isAnnotation();
boolean isAbstract();
default boolean isConcrete() {
return !(isInterface() || isAbstract());
}
boolean isFinal();
boolean isIndependent();
default boolean hasEnclosingClass() {
return (getEnclosingClassName() != null);
}
@Nullable
String getEnclosingClassName();
default boolean hasSuperClass() {
return (getSuperClassName() != null);
}
@Nullable
String getSuperClassName();
String[] getInterfaceNames();
String[] getMemberClassNames();
}
AnnotationMetadata 可以很方便的获得 注解的值 以及 像关于 注解的各种信息
public interface AnnotationMetadata extends ClassMetadata, AnnotatedTypeMetadata {
default Set<String> getAnnotationTypes() {
return getAnnotations().stream()
.filter(MergedAnnotation::isDirectlyPresent)
.map(annotation -> annotation.getType().getName())
.collect(Collectors.toCollection(LinkedHashSet::new));
}
default Set<String> getMetaAnnotationTypes(String annotationName) {
MergedAnnotation<?> annotation = getAnnotations().get(annotationName, MergedAnnotation::isDirectlyPresent);
if (!annotation.isPresent()) {
return Collections.emptySet();
}
return MergedAnnotations.from(annotation.getType(), SearchStrategy.INHERITED_ANNOTATIONS).stream()
.map(mergedAnnotation -> mergedAnnotation.getType().getName())
.collect(Collectors.toCollection(LinkedHashSet::new));
}
// 判断 有没有 这个注解
default boolean hasAnnotation(String annotationName) {
return getAnnotations().isDirectlyPresent(annotationName);
}
default boolean hasMetaAnnotation(String metaAnnotationName) {
return getAnnotations().get(metaAnnotationName,
MergedAnnotation::isMetaPresent).isPresent();
}
// 判断 这个类 内部 有没有 这个 注解标明的方法
default boolean hasAnnotatedMethods(String annotationName) {
return !getAnnotatedMethods(annotationName).isEmpty();
}
// 获得这个类 内部 注解标明的方法
Set<MethodMetadata> getAnnotatedMethods(String annotationName);
static AnnotationMetadata introspect(Class<?> type) {
return StandardAnnotationMetadata.from(type);
}
} AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(KangConfig.class);
Resource[] resources = annotationConfigApplicationContext.getResources("classpath:**/*.class");
SimpleMetadataReaderFactory simpleMetadataReaderFactory = new SimpleMetadataReaderFactory();
for (Resource resource : resources) {
MetadataReader metadataReader = simpleMetadataReaderFactory.getMetadataReader(resource);
// 有关类的信息
ClassMetadata classMetadata = metadataReader.getClassMetadata();
String className = classMetadata.getClassName();
//有关注解的信息
AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
Set<String> annotationTypes = annotationMetadata.getAnnotationTypes();
annotationMetadata.getAnnotationAttributes("Order");
for (String annotationType : annotationMetadata.getAnnotationTypes()) {
System.out.println(annotationType);
}
}
//这个是直接判断 有就是有 没有就是没有 @Service 是 false
annotationMetadata.hasAnnotation(Component.class.getName());
// 这个会往上 再次判断 @Service 是 true
annotationMetadata.hasAnnotatedMethods(Component.class.getName());ExcludeFilter 和IncludeFilter
扫描时用到的 排除过滤器 和 包含过滤器
多种 FilterType （ 类的 注解的 切面的 正则的 等等）
@ComponentScan(basePackages = "com.kang.service",
excludeFilters = {
@ComponentScan.Filter(
type = FilterType.ASSIGNABLE_TYPE,
classes = UserService.class
)
})包含的比较重要
@ComponentScan(basePackages = "com.kang.service",
includeFilters = {
@ComponentScan.Filter(
type = FilterType.ASSIGNABLE_TYPE,
classes = UserService.class
)
})创建 ApplicationContext 时 默认加入 includeFilters
过滤器类型 为 注解 只要类标注了这个注解 ，就能成为bean
和 Component注解 有关系
当我 扫描 到一个类 都会 经过 我 ComponentScan的过滤器
如果是排除的 就算有 Component 也不会成为bean
如果是包含 就算没有Component 也会成为bean
FactoryBean（特殊的Bean）
@Component
public class TestFactoryBean implements FactoryBean<User> {
/*
单例池 确实 存的是这个
* testFactoryBean => TestFactoryBean
*
在 getBean的时候 会判断 它是不是一个 FactoryBean 然后就调用getObject得到了一个User
让后把这个对象 存入 factoryBeanObjectCache缓存中
之后再获取这个对象 ， 就直接去 缓存拿
* testFactoryBean => User
如果想要获得TestFactoryBean
就要 &testFactoryBean
*
* */
@Override
public User getObject() throws Exception {
return new User();
}
@Override
public Class<?> getObjectType() {
return User.class ;
}
}
通过@Bean 和BeanFactory 存入的对象 有什么区别
@Bean 的User 经过了 Bean的所有生命周期
实现 BeanFactory 的bean 经过了所有生命周期
但是 里面 的bean（User） 没有经过所有的生命周期
@Component
public class KangBeanPostProcess implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if(bean.getClass().equals(User.class)){
System.out.println("初始化前");
}
return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if(bean.getClass().equals(User.class)){
System.out.println("初始化后");
}
return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
}
}
@Bean的结果
BeanFactory的User
只要有 初始化后 ===》 就支持AOP
131
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
