什么是注解配置？
1.通過BeanConfig 我們自己往容器里面注入配置 一般我們都是像2那樣config配置用配置文件配置 跳轉
2.通過注解實現我們的服務發布和訂閱
注:此篇只會將 ServiceBean初始化 和注解實現訂閱原理. 服務發布過程和服務訂閱內部過程后面篇幅講
demo
跟前面二的demo一致 鏈接
DubboComponentScan
@EnableDubbo注解有一個DubboComponentScan 我們前面說了EnableDubbo只是一個組合注解 方便使用 在類上面打很多注解 我們也可以單獨使用
@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Import(DubboComponentScanRegistrar.class)//@Import 注解方式服務發布和訂閱切入點<1> public @interface DubboComponentScan { /** * 配置 掃描的包 * Alias for the {@link #basePackages()} attribute. Allows for more concise annotation * declarations e.g.: {@code @DubboComponentScan("org.my.pkg")} instead of * {@code @DubboComponentScan(basePackages="org.my.pkg")}. * * @return the base packages to scan */ String[] value() default {}; /** * 配置要掃描包數組 * Base packages to scan for annotated @Service classes. {@link #value()} is an * alias for (and mutually exclusive with) this attribute. * <p> * Use {@link #basePackageClasses()} for a type-safe alternative to String-based * package names. * * @return the base packages to scan */ String[] basePackages() default {}; /** * 配置要掃描的類的數組 * Type-safe alternative to {@link #basePackages()} for specifying the packages to * scan for annotated @Service classes. The package of each class specified will be * scanned. * * @return classes from the base packages to scan */ Class<?>[] basePackageClasses() default {}; }
DubboComponentScanRegistrar
<1>registerBeanDefinitions
com.alibaba.dubbo.config.spring.context.annotation.DubboComponentScanRegistrar#registerBeanDefinitions
@Override public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { //<2>獲取掃描的包集合 Set<String> packagesToScan = getPackagesToScan(importingClassMetadata); // <3>創建 ServiceAnnotationBeanPostProcessor Bean 對象，后續掃描 `@Service` 注解的類，創建對應的 Service Bean 對象 registerServiceAnnotationBeanPostProcessor(packagesToScan, registry); //<4>創建ReferenceAnnotationBeanPostProcessor bean對象 后續掃描 @Reference 的類 創建對應的 Reference Bean 對象 registerReferenceAnnotationBeanPostProcessor(registry); }
<2>getPackagesToScan
com.alibaba.dubbo.config.spring.context.annotation.DubboComponentScanRegistrar#registerBeanDefinitions
->
com.alibaba.dubbo.config.spring.context.annotation.DubboComponentScanRegistrar#getPackagesToScan
private Set<String> getPackagesToScan(AnnotationMetadata metadata) { //// 獲得 @DubboComponentScan 注解 AnnotationAttributes attributes = AnnotationAttributes.fromMap( metadata.getAnnotationAttributes(DubboComponentScan.class.getName())); //獲取配置的basePackages值 String[] basePackages = attributes.getStringArray("basePackages"); //獲取注解配置的basePackageClasses Class<?>[] basePackageClasses = attributes.getClassArray("basePackageClasses"); //獲取注解配置的value值 String[] value = attributes.getStringArray("value"); //將配置的value添加到 packagesToScan 集合中 Set<String> packagesToScan = new LinkedHashSet<String>(Arrays.asList(value)); //將配置的basePackages加到集合 packagesToScan.addAll(Arrays.asList(basePackages)); //將配置的class加到 集合中 for (Class<?> basePackageClass : basePackageClasses) { packagesToScan.add(ClassUtils.getPackageName(basePackageClass)); } //如果沒有配置 if (packagesToScan.isEmpty()) { //則默認獲取注解類所在包 return Collections.singleton(ClassUtils.getPackageName(metadata.getClassName())); } return packagesToScan; }
<3>registerServiceAnnotationBeanPostProcessor
/* * 創建掃描@Service的Processor 並注入容器 * * @param packagesToScan packages to scan without resolving placeholders * @param registry {@link BeanDefinitionRegistry} * @since 2.5.8 */ private void registerServiceAnnotationBeanPostProcessor(Set<String> packagesToScan, BeanDefinitionRegistry registry) { //建造者模式,生成ServiceAnnotationBeanPostProcessor BeanDefinition的builder BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(ServiceAnnotationBeanPostProcessor.class); //構造函數設置掃毛包 builder.addConstructorArgValue(packagesToScan); builder.setRole(2); //構建具體ServiceAnnotationBeanPostProcessor BeanDefinition 對象 AbstractBeanDefinition beanDefinition = builder.getBeanDefinition(); //后續由spring生命周期調度 具體可看<5>注入register 通過自定義BeanFactoryPostProcessor利用spring 生命周期實現擴展 具體可參考:https://www.cnblogs.com/LQBlog/p/13954302.html#autoid-5-0-0 BeanDefinitionReaderUtils.registerWithGeneratedName(beanDefinition, registry); }
<4>registerReferenceAnnotationBeanPostProcessor
com.alibaba.dubbo.config.spring.context.annotation.DubboComponentScanRegistrar#registerBeanDefinitions
->
com.alibaba.dubbo.config.spring.context.annotation.DubboComponentScanRegistrar#registerReferenceAnnotationBeanPostProcessor
/** * 注冊處理@Reference的處理器 * * @param registry {@link BeanDefinitionRegistry} */ private void registerReferenceAnnotationBeanPostProcessor(BeanDefinitionRegistry registry) { // ReferenceAnnotationBeanPostProcessor // 這個間接實現了MergedBeanDefinitionPostProcessor 實現打了@Refrence屬性的注入 具體參考spring生命周期https://www.cnblogs.com/LQBlog/p/13954302.html#autoid-13-1-0 //后續調度由spring 調度 請看<11> //spring在創建 注冊 因為他間接實現了上面的接口 所以在spring初始化過程中 我們可以做一些事情 BeanRegistrar.registerInfrastructureBean(registry, ReferenceAnnotationBeanPostProcessor.BEAN_NAME, ReferenceAnnotationBeanPostProcessor.class); }
ServiceAnnotationBeanPostProcessor
<5>postProcessBeanDefinitionRegistry
由spring調度因為實現了BeanDefinitionRegistryPostProcessor
com.alibaba.dubbo.config.spring.beans.factory.annotation.ServiceAnnotationBeanPostProcessor#postProcessBeanDefinitionRegistry
@Override public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException { //<6>避免掃描包配置的占位符 轉換一次 如:${} Set<String> resolvedPackagesToScan = resolvePackagesToScan(packagesToScan); if (!CollectionUtils.isEmpty(resolvedPackagesToScan)) { //<7>掃描包 registerServiceBeans(resolvedPackagesToScan, registry); } else { if (logger.isWarnEnabled()) { logger.warn("packagesToScan is empty , ServiceBean registry will be ignored!"); } } }
<6>postProcessBeanDefinitionRegistry
com.alibaba.dubbo.config.spring.beans.factory.annotation.ServiceAnnotationBeanPostProcessor#postProcessBeanDefinitionRegistry
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ServiceAnnotationBeanPostProcessor#resolvePackagesToScan
private Set<String> resolvePackagesToScan(Set<String> packagesToScan) { Set<String> resolvedPackagesToScan = new LinkedHashSet<String>(packagesToScan.size()); //遍歷 for (String packageToScan : packagesToScan) { if (StringUtils.hasText(packageToScan)) { // environment.resolvePlaceholders的作用是避免我們傳的是占位符${packageToscan} String resolvedPackageToScan = environment.resolvePlaceholders(packageToScan.trim()); resolvedPackagesToScan.add(resolvedPackageToScan); } } return resolvedPackagesToScan; }
<7>registerServiceBeans
com.alibaba.dubbo.config.spring.beans.factory.annotation.ServiceAnnotationBeanPostProcessor#postProcessBeanDefinitionRegistry
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ServiceAnnotationBeanPostProcessor#registerServiceBeans
private void registerServiceBeans(Set<String> packagesToScan, BeanDefinitionRegistry registry) { //繼承ClassPathBeanDefinitionScanner //實現了EnvironmentAware, // ResourceLoaderAware, BeanClassLoaderAware接口 注入的environment,resourceLoader DubboClassPathBeanDefinitionScanner scanner = new DubboClassPathBeanDefinitionScanner(registry, environment, resourceLoader); //<8>獲得 BeanNameGenerator 對象，並設置 beanNameGenerator 到 scanner 中 返回的是AnotationBeanNameGeenerator BeanNameGenerator beanNameGenerator = resolveBeanNameGenerator(registry); //設置BeanNameGenerator到scanner scanner.setBeanNameGenerator(beanNameGenerator); //要掃描的注解類 scanner.addIncludeFilter(new AnnotationTypeFilter(Service.class)); //循環咋配置的掃描包里面掃描 for (String packageToScan : packagesToScan) { // 執行掃描 scanner.scan(packageToScan); // 獲取掃描到的bean definition定義 Set<BeanDefinitionHolder> beanDefinitionHolders = findServiceBeanDefinitionHolders(scanner, packageToScan, registry, beanNameGenerator); if (!CollectionUtils.isEmpty(beanDefinitionHolders)) { for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) { //<9>遍歷注冊 beanDefinitionHolders就是掃描到的打了dubbo Service的類 registerServiceBean(beanDefinitionHolder, registry, scanner); } if (logger.isInfoEnabled()) { logger.info(beanDefinitionHolders.size() + " annotated Dubbo's @Service Components { " + beanDefinitionHolders + " } were scanned under package[" + packageToScan + "]"); } } else { if (logger.isWarnEnabled()) { logger.warn("No Spring Bean annotating Dubbo's @Service was found under package[" + packageToScan + "]"); } } } }
<8>resolveBeanNameGenerator
com.alibaba.dubbo.config.spring.beans.factory.annotation.ServiceAnnotationBeanPostProcessor#postProcessBeanDefinitionRegistry
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ServiceAnnotationBeanPostProcessor#registerServiceBeans
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ServiceAnnotationBeanPostProcessor#resolveBeanNameGenerator
private BeanNameGenerator resolveBeanNameGenerator(BeanDefinitionRegistry registry) { BeanNameGenerator beanNameGenerator = null; //不知道干嘛的 我打斷點默認會進來 但是獲取的beanNameGenerator是空 if (registry instanceof SingletonBeanRegistry) { SingletonBeanRegistry singletonBeanRegistry = SingletonBeanRegistry.class.cast(registry); beanNameGenerator = (BeanNameGenerator) singletonBeanRegistry.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR); } if (beanNameGenerator == null) { if (logger.isInfoEnabled()) { logger.info("BeanNameGenerator bean can't be found in BeanFactory with name [" + CONFIGURATION_BEAN_NAME_GENERATOR + "]"); logger.info("BeanNameGenerator will be a instance of " + AnnotationBeanNameGenerator.class.getName() + " , it maybe a potential problem on bean name generation."); } //最終返回的是介個 beanNameGenerator = new AnnotationBeanNameGenerator(); } return beanNameGenerator; }
<9>registerServiceBean
com.alibaba.dubbo.config.spring.beans.factory.annotation.ServiceAnnotationBeanPostProcessor#postProcessBeanDefinitionRegistry
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ServiceAnnotationBeanPostProcessor#registerServiceBeans
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ServiceAnnotationBeanPostProcessor#registerServiceBean
private void registerServiceBean(BeanDefinitionHolder beanDefinitionHolder, BeanDefinitionRegistry registry, DubboClassPathBeanDefinitionScanner scanner) { //獲得對應 service class對象 Class<?> beanClass = resolveClass(beanDefinitionHolder); //獲得class對象上的注解對象 Service service = findAnnotation(beanClass, Service.class); //獲得class對象的結果class Class<?> interfaceClass = resolveServiceInterfaceClass(beanClass, service); //獲得beanName String annotatedServiceBeanName = beanDefinitionHolder.getBeanName(); //<10>獲得serviceBean的 定義 AbstractBeanDefinition serviceBeanDefinition = buildServiceBeanDefinition(service, interfaceClass, annotatedServiceBeanName); // 為ServiceBean生成beanName 如:ServiceBean:com.alibaba.dubbo.demo.DemoService String beanName = generateServiceBeanName(service, interfaceClass, annotatedServiceBeanName); //檢查名字是否重復 如果沒有存在 則進行注冊 至此 我們的ServiceBean就注冊到spring 容器了 通過ServiceBean實現的spring生命周期的InitialinzingBean實現服務發布 讓我們回到<1> 看<4>@Refrence的初始化 if (scanner.checkCandidate(beanName, serviceBeanDefinition)) { // check duplicated candidate bean registry.registerBeanDefinition(beanName, serviceBeanDefinition); if (logger.isInfoEnabled()) { logger.info("The BeanDefinition[" + serviceBeanDefinition + "] of ServiceBean has been registered with name : " + beanName); } } else { if (logger.isWarnEnabled()) { logger.warn("The Duplicated BeanDefinition[" + serviceBeanDefinition + "] of ServiceBean[ bean name : " + beanName + "] was be found , Did @DubboComponentScan scan to same package in many times?"); } } }
<10>buildServiceBeanDefinition
com.alibaba.dubbo.config.spring.beans.factory.annotation.ServiceAnnotationBeanPostProcessor#postProcessBeanDefinitionRegistry
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ServiceAnnotationBeanPostProcessor#registerServiceBeans
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ServiceAnnotationBeanPostProcessor#registerServiceBean
private AbstractBeanDefinition buildServiceBeanDefinition(Service service, Class<?> interfaceClass, String annotatedServiceBeanName) { BeanDefinitionBuilder builder = rootBeanDefinition(ServiceBean.class); AbstractBeanDefinition beanDefinition = builder.getBeanDefinition(); //通過他后續可以向對象屬性注入值 MutablePropertyValues propertyValues = beanDefinition.getPropertyValues(); //service的屬性 也是@Service的可配置項目 String[] ignoreAttributeNames = of("provider", "monitor", "application", "module", "registry", "protocol", "interface", "interfaceName"); propertyValues.addPropertyValues(new AnnotationPropertyValuesAdapter(service, environment, ignoreAttributeNames)); //設置ServiceBean 的ref屬性值為 @Service 注解所打bean的名字 如 demoServiceImpl addPropertyReference(builder, "ref", annotatedServiceBeanName); // 設置serviceBean 的interface屬性 為@Seervice所打bean的接口全名稱 如：com.alibaba.dubbo.demo.DemoService builder.addPropertyValue("interface", interfaceClass.getName()); /** * 獲取@service注解配置的 provider設置到ServiceBean * addPropertyReference 所以配置的beanName注入的是容器里面對應的bean */ String providerConfigBeanName = service.provider(); if (StringUtils.hasText(providerConfigBeanName)) { addPropertyReference(builder, "provider", providerConfigBeanName); } /** * 獲取@service注解配置的 monitor設置到ServiceBean * addPropertyReference 所以配置的beanName注入的是容器里面對應的bean */ String monitorConfigBeanName = service.monitor(); if (StringUtils.hasText(monitorConfigBeanName)) { addPropertyReference(builder, "monitor", monitorConfigBeanName); } /** * 獲取@service注解配置的application設置到ServiceBean * addPropertyReference 所以配置的beanName注入的是容器里面對應的bean */ String applicationConfigBeanName = service.application(); if (StringUtils.hasText(applicationConfigBeanName)) { addPropertyReference(builder, "application", applicationConfigBeanName); } /** * 獲取@service注解配置的module設置到ServiceBean * addPropertyReference 所以配置的beanName注入的是容器里面對應的bean */ String moduleConfigBeanName = service.module(); if (StringUtils.hasText(moduleConfigBeanName)) { addPropertyReference(builder, "module", moduleConfigBeanName); } /** * 獲取@service注解配置的module設置到ServiceBean * 因為可以配置數組 */ String[] registryConfigBeanNames = service.registry(); List<RuntimeBeanReference> registryRuntimeBeanReferences = toRuntimeBeanReferences(registryConfigBeanNames); if (!registryRuntimeBeanReferences.isEmpty()) { builder.addPropertyValue("registries", registryRuntimeBeanReferences); } /** * 獲取@service注解配置的protocol設置到ServiceBean * 因為可以配置數組 */ String[] protocolConfigBeanNames = service.protocol(); List<RuntimeBeanReference> protocolRuntimeBeanReferences = toRuntimeBeanReferences(protocolConfigBeanNames); if (!protocolRuntimeBeanReferences.isEmpty()) { builder.addPropertyValue("protocols", protocolRuntimeBeanReferences); } /** * 獲取@service注解配置的methods設置到ServiceBean * 因為可以配置數組 */ Method[] methods = service.methods(); //將method對象轉換成methodConfig List<MethodConfig> methodConfigs = MethodConfig.constructMethodConfig(methods); if (!methodConfigs.isEmpty()) { builder.addPropertyValue("methods", methodConfigs); } /** * 返回 這個時候definition定義好了 告訴spring 如何創建ServiceBean 並初始化我們注解配置的屬性 我們回到<9> */ return builder.getBeanDefinition(); }
ReferenceAnnotationBeanPostProcessor
類圖
BeanProcess5大對象調用時機與作用可以參考:鏈接
雖然繼承了InstantiationAwareBeanPostProcessorAdapter 但是並沒有做特殊處理我們直接看SmartInstantiationAwareBeanPostProcessor的實現
類源碼
public class ReferenceAnnotationBeanPostProcessor extends AnnotationInjectedBeanPostProcessor<Reference> implements ApplicationContextAware, ApplicationListener { /** } }
<11>構造AnnotationInjectedBeanPostProcessor()
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#AnnotationInjectedBeanPostProcessor
public AnnotationInjectedBeanPostProcessor() { //<12>獲取到泛型參數的值 extends AnnotationInjectedBeanPostProcessor<Reference> 就是Reference.class 可以看上面類圖和類結構 //初始化后我們接着看<13> 此方法由spring調度 可以在創建實例后 進行調用我們可以改變屬性 this.annotationType = resolveGenericType(getClass()); }
<12>resolveGenericType
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#AnnotationInjectedBeanPostProcessor
->
com.alibaba.dubbo.config.spring.util.ClassUtils#resolveGenericType
public static <T> Class<T> resolveGenericType(Class<?> declaredClass) { ParameterizedType parameterizedType = (ParameterizedType) declaredClass.getGenericSuperclass(); Type[] actualTypeArguments = parameterizedType.getActualTypeArguments(); return (Class<T>) actualTypeArguments[0]; }
<13>postProcessMergedBeanDefinition
此方法為MergedBeanDefinitionPostProcessor實現BeanProcess5大對象調用時機與作用可以參考:鏈接
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#postProcessMergedBeanDefinition
/** * MergedBeanDefinitionPostProcessor接口的實現 根據 * 作用在bean實例化完畢后調用 可以用來修改merged BeanDefinition的一些properties 或者用來給后續回調中緩存一些meta信息使用 * 這個算是將merged BeanDefinition暴露出來的一個回調 * 在bean實例化之前初始化之前調用 主要用來改變打了@refrece的的屬性的值 * @param beanDefinition * @param beanType * @param beanName */ @Override public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) { if (beanType != null) { //<14>反射獲得指定bean 打了@Refrence的filed和method元數據封裝到InjectionMetadata //注:這里返回的是AnnotationInjectedBeanPostProcessor.AnnotatedInjectionMetadata InjectionMetadata metadata = findInjectionMetadata(beanName, beanType, null); // 將注入元數據信息保存到 RootBeanDefinition#externallyManagedConfigMembers 屬性中 //這里將類里面打了@Refrence的filed和method元素都拿到了 我們繼續看<18> metadata.checkConfigMembers(beanDefinition); } }
<14>findInjectionMetadata
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#postProcessMergedBeanDefinition
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#findInjectionMetadata
public InjectionMetadata findInjectionMetadata(String beanName, Class<?> clazz, PropertyValues pvs) { // 獲得緩存key 這里獲取的是beanName比如studentServiceImpl 如果沒有則獲取className String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName()); // 判斷緩存是否存在避免每次重復加載 AnnotationInjectedBeanPostProcessor.AnnotatedInjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey); if (InjectionMetadata.needsRefresh(metadata, clazz)) { synchronized (this.injectionMetadataCache) { //避免緩存穿透 metadata = this.injectionMetadataCache.get(cacheKey); if (InjectionMetadata.needsRefresh(metadata, clazz)) { //pvs是null前面寫的傳null if (metadata != null) { metadata.clear(pvs); } try { //<15>主要是反射獲取打了@Refrence的filed和method並封裝到metaData 返回的AnnotationInjectedBeanPostProcessor.AnnotatedInjectionMetadata繼承InjectionMetadata metadata = buildAnnotatedMetadata(clazz); this.injectionMetadataCache.put(cacheKey, metadata); } catch (NoClassDefFoundError err) { throw new IllegalStateException("Failed to introspect object class [" + clazz.getName() + "] for annotation metadata: could not find class that it depends on", err); } } } } return metadata; }
<15>buildAnnotatedMetadata
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#postProcessMergedBeanDefinition
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#findInjectionMetadata
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.AnnotatedInjectionMetadata
private AnnotationInjectedBeanPostProcessor.AnnotatedInjectionMetadata buildAnnotatedMetadata(final Class<?> beanClass) { //<16>反射獲得所有Filed 只會查找打了@Refrence注解的filed beaClass在<11>處就被初始化了 Collection<AnnotationInjectedBeanPostProcessor.AnnotatedFieldElement> fieldElements = findFieldAnnotationMetadata(beanClass); //<17>反射獲得所有method 只會查找打了@Reefrence注解的public beaClass在<11>處就被初始化了 Collection<AnnotationInjectedBeanPostProcessor.AnnotatedMethodElement> methodElements = findAnnotatedMethodMetadata(beanClass); //通過內部類封裝 AnnotationInjectedBeanPostProcessor.AnnotatedInjectionMetadata return new AnnotationInjectedBeanPostProcessor.AnnotatedInjectionMetadata(beanClass, fieldElements, methodElements); }
<16>findFieldAnnotationMetadata
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#postProcessMergedBeanDefinition
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#findInjectionMetadata
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.AnnotatedInjectionMetadata
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#findFieldAnnotationMetadata
private List<AnnotationInjectedBeanPostProcessor.AnnotatedFieldElement> findFieldAnnotationMetadata(final Class<?> beanClass) { final List<AnnotationInjectedBeanPostProcessor.AnnotatedFieldElement> elements = new LinkedList<AnnotationInjectedBeanPostProcessor.AnnotatedFieldElement>(); //反射找到打上了指定出的filed ReflectionUtils.doWithFields(beanClass, new ReflectionUtils.FieldCallback() { @Override public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException { //getAnnotationType <11>處初始化 A annotation = getAnnotation(field, getAnnotationType()); if (annotation != null) { if (Modifier.isStatic(field.getModifiers())) { if (logger.isWarnEnabled()) { logger.warn("@" + getAnnotationType().getName() + " is not supported on static fields: " + field); } return; } elements.add(new AnnotationInjectedBeanPostProcessor.AnnotatedFieldElement(field, annotation)); } } }); return elements; }
<17>findAnnotatedMethodMetadata
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#postProcessMergedBeanDefinition
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#findInjectionMetadata
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.AnnotatedInjectionMetadata
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#findAnnotatedMethodMetadata
private List<AnnotationInjectedBeanPostProcessor.AnnotatedMethodElement> findAnnotatedMethodMetadata(final Class<?> beanClass) { final List<AnnotationInjectedBeanPostProcessor.AnnotatedMethodElement> elements = new LinkedList<AnnotationInjectedBeanPostProcessor.AnnotatedMethodElement>(); //反射處理打上了getAnnotationType 的set方法 ReflectionUtils.doWithMethods(beanClass, new ReflectionUtils.MethodCallback() { @Override public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException { Method bridgedMethod = findBridgedMethod(method); if (!isVisibilityBridgeMethodPair(method, bridgedMethod)) { return; } A annotation = findAnnotation(bridgedMethod, getAnnotationType()); if (annotation != null && method.equals(ClassUtils.getMostSpecificMethod(method, beanClass))) { if (Modifier.isStatic(method.getModifiers())) { if (logger.isWarnEnabled()) { logger.warn("@" + getAnnotationType().getSimpleName() + " annotation is not supported on static methods: " + method); } return; } if (method.getParameterTypes().length == 0) { if (logger.isWarnEnabled()) { logger.warn("@" + getAnnotationType().getSimpleName() + " annotation should only be used on methods with parameters: " + method); } } PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, beanClass); elements.add(new AnnotationInjectedBeanPostProcessor.AnnotatedMethodElement(method, pd, annotation)); } } }); return elements; }
<18>postProcessPropertyValues
因為實現了 InstantiationAwareBeanPostProcessor 由spring調度
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#postProcessPropertyValues
/** * 這里是在spring處理完默認的成員屬性，應用到指定的bean之前進行回調，可以用來檢查和修改屬性，最終返回的PropertyValues會應用到bean中 * @Autowired、@Resource等就是根據這個回調來實現最終注入依賴的屬性的。 * 重寫的 InstantiationAwareBeanPostProcessor接口 在 MergedBeanDefinitionPostProcessor 后調用 * 已經初始化了打上了@Refrence 的屬性到metaData * @param pvs * @param pds * @param bean * @param beanName * @return * @throws BeanCreationException */ @Override public PropertyValues postProcessPropertyValues( PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeanCreationException { /** * <14>這里是讀取緩存 也就是讀取到打上了@Refrece的filed和method元數據信息 * 返回的AnnotationInjectedBeanPostProcessor.AnnotatedInjectionMetadata繼承InjectionMetadata */ InjectionMetadata metadata = findInjectionMetadata(beanName, bean.getClass(), pvs); try { //<19>代理類生成 並設置到PropertyValues完成注入 metadata.inject(bean, beanName, pvs); } catch (BeanCreationException ex) { throw ex; } catch (Throwable ex) { throw new BeanCreationException(beanName, "Injection of @" + getAnnotationType().getName() + " dependencies is failed", ex); } return pvs; }
<22>getInjectedObject
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.AnnotatedMethodElement#inject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.Annotated(Filed|Method)Element#inject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#getInjectedObject
protected Object getInjectedObject(A annotation, Object bean, String beanName, Class<?> injectedType, InjectionMetadata.InjectedElement injectedElement) throws Exception { //生成緩存key 如:ServiceBean:com.alibaba.dubbo.demo.DemoService#source=com.alibaba.dubbo.demo.DemoService consumer.StudentServiceImpl.demoService#attributes={} String cacheKey = buildInjectedObjectCacheKey(annotation, bean, beanName, injectedType, injectedElement); //嘗試從緩存獲取 默認沒有 //是為了我們多個類都@Refrece同一個對象 而不用重新構建代理對象 Object injectedObject = injectedObjectsCache.get(cacheKey); if (injectedObject == null) { //<23>獲得代理對象 被子類重寫 com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor.doGetInjectedBean injectedObject = doGetInjectedBean(annotation, bean, beanName, injectedType, injectedElement); // Customized inject-object if necessary injectedObjectsCache.putIfAbsent(cacheKey, injectedObject); } //返回代理對象 return injectedObject; }
AnnotatedInjectionMetadata
此類為AnnotationInjectedBeanPostProcessor 內部類
<19>inject
因為繼承InjectionMetadata 並沒有重寫inject 所以調用的是InjectionMetadata 的
org.springframework.beans.factory.annotation.InjectionMetadata#inject
public void inject(Object target, String beanName, PropertyValues pvs) throws Throwable { Collection<InjectionMetadata.InjectedElement> elementsToIterate = this.checkedElements != null ? this.checkedElements : this.injectedElements; if (!((Collection)elementsToIterate).isEmpty()) { boolean debug = logger.isDebugEnabled(); InjectionMetadata.InjectedElement element; /** * 注意看<15>處 這里是多態 分別調用的是 * AnnotationInjectedBeanPostProcessor.AnnotatedFieldElement<20> * AnnotationInjectedBeanPostProcessor.AnnotatedMethodElement<21> * 的inject<20> */ for(Iterator var6 = ((Collection)elementsToIterate).iterator(); var6.hasNext(); element.inject(target, beanName, pvs)) { element = (InjectionMetadata.InjectedElement)var6.next(); if (debug) { logger.debug("Processing injected element of bean '" + beanName + "': " + element); } } } }
AnnotatedFieldElement
<20>inject
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.AnnotatedMethodElement#inject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.AnnotatedFieldElement#inject
@Override protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable { //獲取filed的元素聚 Class<?> injectedType = field.getType(); //傳入注解 bean和beanName注入類型信息 //com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.getInjectedObject //<22>獲得代理對象 injectedBean = getInjectedObject(annotation, bean, beanName, injectedType, this); ReflectionUtils.makeAccessible(field); //注入 field.set(bean, injectedBean); }
AnnotatedMethodElement
<21>inject
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.AnnotatedMethodElement#inject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.AnnotatedMethodElement#inject
@Override protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable { //獲取注入類的類型 Class<?> injectedType = pd.getPropertyType(); //<22>此類為內部類 這類調用的是:com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.getInjectedObject injectedBean = getInjectedObject(annotation, bean, beanName, injectedType, this); ReflectionUtils.makeAccessible(method); //注入代理對象 method.invoke(bean, injectedBean); }
ReferenceAnnotationBeanPostProcessor
<23>doGetInjectedBean
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.AnnotatedMethodElement#inject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.Annotated(Filed|Method)Element#inject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#getInjectedObject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor#doGetInjectedBean
@Override protected Object doGetInjectedBean(Reference reference, Object bean, String beanName, Class<?> injectedType, InjectionMetadata.InjectedElement injectedElement) throws Exception { //獲得beanName引用的baan的如:ServiceBean:com.alibaba.dubbo.demo.DemoService String referencedBeanName = buildReferencedBeanName(reference, injectedType); //<233>構建RefrenceBean的實例 ReferenceBean referenceBean = buildReferenceBeanIfAbsent(referencedBeanName, reference, injectedType, getClassLoader()); //加入到緩存 供后續使用 cacheInjectedReferenceBean(referenceBean, injectedElement); //<29>構建代理對象 Object proxy = buildProxy(referencedBeanName, referenceBean, injectedType); return proxy; }
<29>buildProxy
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.AnnotatedMethodElement#inject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.Annotated(Filed|Method)Element#inject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#getInjectedObject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor#doGetInjectedBean
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor#buildProxy
private Object buildProxy(String referencedBeanName, ReferenceBean referenceBean, Class<?> injectedType) { //<30>創建jdk動態代理的Handler 這里創建的ReferenceBeanInvocationHandler 實現了InvocationHandler InvocationHandler handler = buildInvocationHandler(referencedBeanName, referenceBean); //jdk動態代理 Object proxy = Proxy.newProxyInstance(getClassLoader(), new Class[]{injectedType}, handler); return proxy; }
<30>buildProxy
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.AnnotatedMethodElement#inject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.Annotated(Filed|Method)Element#inject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#getInjectedObject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor#doGetInjectedBean
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor#buildProxy
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor#buildInvocationHandler
private InvocationHandler buildInvocationHandler(String referencedBeanName, ReferenceBean referenceBean) { //從緩存獲取 避免多次訂閱耗時 ReferenceBeanInvocationHandler handler = localReferenceBeanInvocationHandlerCache.get(referencedBeanName); if (handler == null) { handler = new ReferenceBeanInvocationHandler(referenceBean); } //判斷容器是否有這個bean if (applicationContext.containsBean(referencedBeanName)) { // Is local @Service Bean or not ? // ReferenceBeanInvocationHandler's initialization has to wait for current local @Service Bean has been exported. localReferenceBeanInvocationHandlerCache.put(referencedBeanName, handler); } else { //<31>實現服務訂閱 handler.init(); } //返回handlerAnnotationInjectedBeanPostProcessor return handler; }
<31>init
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.AnnotatedMethodElement#inject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.Annotated(Filed|Method)Element#inject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#getInjectedObject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor#doGetInjectedBean
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor#buildProxy
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor#buildInvocationHandler
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor.ReferenceBeanInvocationHandler#init
private void init() { this.bean = referenceBean.get(); }
回到第一篇可以看到 做了這么多 最終只是替代了我們api配置 簡介了配置
<233>buildReferenceBeanIfAbsent
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.AnnotatedMethodElement#inject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.Annotated(Filed|Method)Element#inject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#getInjectedObject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor#doGetInjectedBean
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor#buildReferenceBeanIfAbsent
private ReferenceBean buildReferenceBeanIfAbsent(String referencedBeanName, Reference reference, Class<?> referencedType, ClassLoader classLoader) throws Exception { //從緩存獲取 ReferenceBean key：ServiceBean:com.alibaba.dubbo.demo.DemoService ReferenceBean<?> referenceBean = referenceBeanCache.get(referencedBeanName); if (referenceBean == null) { //創建一個構件RefenceBean的Builder 建造者模式 ReferenceBeanBuilder beanBuilder = ReferenceBeanBuilder .create(reference, classLoader, applicationContext) .interfaceClass(referencedType); //<24>RefenceBean referenceBean = beanBuilder.build(); //加入到緩存 referenceBeanCache.put(referencedBeanName, referenceBean); } return referenceBean; }
<24>build
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.AnnotatedMethodElement#inject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.Annotated(Filed|Method)Element#inject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#getInjectedObject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor#doGetInjectedBean
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor#buildReferenceBeanIfAbsent
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AbstractAnnotationConfigBeanBuilder#build
public final B build() throws Exception { //空實現 checkDependencies(); //<25>被子類重寫 反射創建一個空的ReferenceBean B bean = doBuild(); //<26>設置配置信息 configureBean(bean); if (logger.isInfoEnabled()) { logger.info("The bean[type:" + bean.getClass().getSimpleName() + "] has been built."); } return bean; }
<25>doBuild
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.AnnotatedMethodElement#inject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.Annotated(Filed|Method)Element#inject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#getInjectedObject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor#doGetInjectedBean
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor#buildReferenceBeanIfAbsent
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AbstractAnnotationConfigBeanBuilder#build
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceBeanBuilder#doBuild
protected ReferenceBean doBuild() { return new ReferenceBean<Object>(); }
<26>configureBean
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.AnnotatedMethodElement#inject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.Annotated(Filed|Method)Element#inject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#getInjectedObject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor#doGetInjectedBean
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor#buildReferenceBeanIfAbsent
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AbstractAnnotationConfigBeanBuilder#build
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AbstractAnnotationConfigBeanBuilder#configureBean
protected void configureBean(B bean) throws Exception { //<27>前置配置 被子類重寫com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceBeanBuilder.preConfigureBean //暫時不造干嘛的 preConfigureBean(annotation, bean); //初始化RegistryConfigs 將注解上配置的RegistryConfigs 設置到RefrenceBean configureRegistryConfigs(bean); //初始化MonitorConfig 將注解上配置的MonitorConfig 設置到RefrenceBean configureMonitorConfig(bean); //初始化ApplicationConfig 將注解上配置的ApplicationConfig 設置到RefrenceBean configureApplicationConfig(bean); //初始化ModuleConfig 將注解上配置的ModuleConfig 設置到RefrenceBean configureModuleConfig(bean); //<28>后置配置 被子類重寫 postConfigureBean(annotation, bean); }
<27>preConfigureBean
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.AnnotatedMethodElement#inject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.Annotated(Filed|Method)Element#inject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#getInjectedObject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor#doGetInjectedBean
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor#buildReferenceBeanIfAbsent
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AbstractAnnotationConfigBeanBuilder#build
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AbstractAnnotationConfigBeanBuilder#configureBean
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceBeanBuilder#preConfigureBean
protected void preConfigureBean(Reference reference, ReferenceBean referenceBean) { Assert.notNull(interfaceClass, "The interface class must set first!"); DataBinder dataBinder = new DataBinder(referenceBean); // Register CustomEditors for special fields dataBinder.registerCustomEditor(String.class, "filter", new StringTrimmerEditor(true)); dataBinder.registerCustomEditor(String.class, "listener", new StringTrimmerEditor(true)); dataBinder.registerCustomEditor(Map.class, "parameters", new PropertyEditorSupport() { public void setAsText(String text) throws java.lang.IllegalArgumentException { // Trim all whitespace String content = StringUtils.trimAllWhitespace(text); if (!StringUtils.hasText(content)) { // No content , ignore directly return; } // replace "=" to "," content = StringUtils.replace(content, "=", ","); // replace ":" to "," content = StringUtils.replace(content, ":", ","); // String[] to Map Map<String, String> parameters = CollectionUtils.toStringMap(commaDelimitedListToStringArray(content)); setValue(parameters); } }); // Bind annotation attributes dataBinder.bind(new AnnotationPropertyValuesAdapter(reference, applicationContext.getEnvironment(), IGNORE_FIELD_NAMES)); }
<28>postConfigureBean
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.AnnotatedMethodElement#inject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor.Annotated(Filed|Method)Element#inject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AnnotationInjectedBeanPostProcessor#getInjectedObject
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor#doGetInjectedBean
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor#buildReferenceBeanIfAbsent
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AbstractAnnotationConfigBeanBuilder#build
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.AbstractAnnotationConfigBeanBuilder#configureBean
->
com.alibaba.dubbo.config.spring.beans.factory.annotation.ReferenceBeanBuilder#postConfigureBean
@Override protected void postConfigureBean(Reference annotation, ReferenceBean bean) throws Exception { bean.setApplicationContext(applicationContext); //@Refrence設置注解配置的Interface configureInterface(annotation, bean); //設置@Refrence設置的consumer配置 configureConsumerConfig(annotation, bean); //設置@Refrence設置的methods配置 到RefrenceBean configureMethodConfig(annotation, bean); //調用RefreceBean的afterPropertiesSet方法 至此RefrenceBean就初始化完了 現在回到<23> 繼續看<29> bean.afterPropertiesSet(); }
總結
@ServcieBean初始化
1.通過打上@DubboComponentScan注解配置掃描信息
2.此注解打了@Import注解以DubboComponentScanRegistrar作為切入點
3.通過DubboClassPathBeanDefinitionScanner繼承了ClassPathBeanDefinitionScanner 對指定包@Service注解掃描獲得beanDefinition
3.然后通過從@Service注解上的配置 加載容器里面的各個config做初始化動作
@Refrence
1.通過打上@DubboComponentScan注解配置掃描信息
2.此注解打了@Import注解以DubboComponentScanRegistrar作為切入點
3.通過注冊實現了spring MergedBeanDefinitionPostProcessor 可以在bean創建之后初始化之前做一些處理
4.內部活動bean的所有 打上了@Refrece的filed和method元數據
5.3步驟bean還實現了InstantiationAwareBeanPostProcessor接口 可以在spring bean初始化后改變屬性值
6.通過4的元數據反射初始化RefrenceBean的實例並通過get方法獲取代理對象 然后再通過@Refrence接口通過jdk動態代理再生成一層代理 內部調用RefrenceBean生成的代理對象