dubbo之@Reference注解作用说明

public class ReferenceAnnotationBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter
        implements MergedBeanDefinitionPostProcessor, PriorityOrdered, ApplicationContextAware, BeanClassLoaderAware,
        DisposableBean {
    // 缓存加了@Referece注解的元数据信息，key是bean的名称或者类名，value是加了@Reference的属性和方法
    private final ConcurrentMap<String, ReferenceInjectionMetadata> injectionMetadataCache =
            new ConcurrentHashMap<String, ReferenceInjectionMetadata>(256);
	// 缓存new过的ReferenceBean，相同的key，只会产生一个ReferenceBean
    private final ConcurrentMap<String, ReferenceBean<?>> referenceBeansCache =
            new ConcurrentHashMap<String, ReferenceBean<?>>();

	// spring设置属性到bean之前调用该方法
    @Override
    public PropertyValues postProcessPropertyValues(
            PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeanCreationException {
		// 根据bean的类型，获取需要注入的元数据信息
        InjectionMetadata metadata = findReferenceMetadata(beanName, bean.getClass(), pvs);
        try {
            // 注入对象
            metadata.inject(bean, beanName, pvs);
        } catch (BeanCreationException ex) {
            throw ex;
        } catch (Throwable ex) {
            throw new BeanCreationException(beanName, "Injection of @Reference dependencies failed", ex);
        }
        return pvs;
    }

  private InjectionMetadata findReferenceMetadata(String beanName, Class<?> clazz, PropertyValues pvs) {
        // 如果是自定义的消费者，没有beanName，退化成使用类名作为缓存key
        String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
        // 双重检查，判断是否需要刷新注入信息
        ReferenceInjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
        // 判断是否需要刷新
        if (InjectionMetadata.needsRefresh(metadata, clazz)) {
        	// 第一次判断为需要刷新，则锁住injectionMetadataCache对象
            synchronized (this.injectionMetadataCache) {
            	// 再次判断是否需要刷新
                metadata = this.injectionMetadataCache.get(cacheKey);
                if (InjectionMetadata.needsRefresh(metadata, clazz)) {
                	// 需要刷新，而且原来缓存的信息不为空，清除缓存信息
                    if (metadata != null) {
                        metadata.clear(pvs);
                    }
                    try {
                    	// 生成新的元数据信息
                        metadata = buildReferenceMetadata(clazz);
                        // 放入缓存
                        this.injectionMetadataCache.put(cacheKey, metadata);
                    } catch (NoClassDefFoundError err) {
                        throw new IllegalStateException("Failed to introspect bean class [" + clazz.getName() +
                                "] for reference metadata: could not find class that it depends on", err);
                    }
                }
            }
        }
        return metadata;
    }

    private ReferenceInjectionMetadata buildReferenceMetadata(final Class<?> beanClass) {
    	// 查找加了@Reference注解的属性
        Collection<ReferenceFieldElement> fieldElements = findFieldReferenceMetadata(beanClass);
        // 查找加了@Reference注解的属性
        // !!!!@Reference还能加到方法上!!!还真没试过
        // 不过这个不关心，只关注属性的
        Collection<ReferenceMethodElement> methodElements = findMethodReferenceMetadata(beanClass);
        return new ReferenceInjectionMetadata(beanClass, fieldElements, methodElements);
    }

    private List<ReferenceFieldElement> findFieldReferenceMetadata(final Class<?> beanClass) {
		
		// 保存加了@Reference注解的属性列表
        final List<ReferenceFieldElement> elements = new LinkedList<ReferenceFieldElement>();

        ReflectionUtils.doWithFields(beanClass, new ReflectionUtils.FieldCallback() {
            @Override
            public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
				// 获取属性上的@Reference注解
                Reference reference = getAnnotation(field, Reference.class);
				// 如果存在@Reference注解
                if (reference != null) {
					// 不支持静态属性的注入
                    if (Modifier.isStatic(field.getModifiers())) {
                        if (logger.isWarnEnabled()) {
                            logger.warn("@Reference annotation is not supported on static fields: " + field);
                        }
                        return;
                    }
					// 添加到队列里
                    elements.add(new ReferenceFieldElement(field, reference));
                }

            }
        });

        return elements;

    }

public class InjectionMetadata {

	private static final Log logger = LogFactory.getLog(InjectionMetadata.class);

	private final Class<?> targetClass;

	private final Collection<InjectedElement> injectedElements;

	@Nullable
	private volatile Set<InjectedElement> checkedElements;


	public InjectionMetadata(Class<?> targetClass, Collection<InjectedElement> elements) {
		// 构造函数接收两个参数，类型，注入的元素
		this.targetClass = targetClass;
		this.injectedElements = elements;
	}
    ......
    ......
    ......
	public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
		Collection<InjectedElement> checkedElements = this.checkedElements;
		// 优先使用checkedElements来注入，如果checkedElements为空，则直接使用injectedElements（没有调用checkConfigMembers方法，checkedElements会空）
		Collection<InjectedElement> elementsToIterate =
				(checkedElements != null ? checkedElements : this.injectedElements);
		if (!elementsToIterate.isEmpty()) {
		    // 循环遍历所有待注入的元素
			for (InjectedElement element : elementsToIterate) {
				if (logger.isTraceEnabled()) {
					logger.trace("Processing injected element of bean '" + beanName + "': " + element);
				}
				// 调用注入方法
				element.inject(target, beanName, pvs);
			}
		}
	}

 private static class ReferenceInjectionMetadata extends InjectionMetadata {

        private final Collection<ReferenceFieldElement> fieldElements;

        private final Collection<ReferenceMethodElement> methodElements;


        public ReferenceInjectionMetadata(Class<?> targetClass, Collection<ReferenceFieldElement> fieldElements,
                                          Collection<ReferenceMethodElement> methodElements) {
            // 构造函数接收3个参数，类型，待注入的属性元素，待注入的方法元素
            // 把fieldElements和methodElements的内容合并，作为InjectionMetadata的injectedElements
            super(targetClass, combine(fieldElements, methodElements));
            this.fieldElements = fieldElements;
            this.methodElements = methodElements;
        }

        private static <T> Collection<T> combine(Collection<? extends T>... elements) {
            List<T> allElements = new ArrayList<T>();
            for (Collection<? extends T> e : elements) {
                allElements.addAll(e);
            }
            return allElements;
        }

        public Collection<ReferenceFieldElement> getFieldElements() {
            return fieldElements;
        }

        public Collection<ReferenceMethodElement> getMethodElements() {
            return methodElements;
        }
    }

 private class ReferenceFieldElement extends InjectionMetadata.InjectedElement {

        private final Field field;

        private final Reference reference;

        private volatile ReferenceBean<?> referenceBean;

        // 构造函数会传入要设置的Field对象，Reference注解对象
        protected ReferenceFieldElement(Field field, Reference reference) {
            super(field, null);
            this.field = field;
            this.reference = reference;
        }

        @Override
        protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {

            Class<?> referenceClass = field.getType();
			// 构建ReferenceBean对象
            referenceBean = buildReferenceBean(reference, referenceClass);
			// 将属性设置为可访问的
            ReflectionUtils.makeAccessible(field);
			// 给Field对象设置属性
            field.set(bean, referenceBean.getObject());

        }

    }

private class ReferenceMethodElement extends InjectionMetadata.InjectedElement {

        private final Method method;

        private final Reference reference;

        private volatile ReferenceBean<?> referenceBean;

        protected ReferenceMethodElement(Method method, PropertyDescriptor pd, Reference reference) {
            super(method, pd);
            this.method = method;
            this.reference = reference;
        }

        @Override
        protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {
			// 获取类型
            Class<?> referenceClass = pd.getPropertyType();
			// 构建ReferenceBean对象
            referenceBean = buildReferenceBean(reference, referenceClass);
			// 将方法设置为可访问
            ReflectionUtils.makeAccessible(method);
			// 把referenceBean生成的对象作为入参，调用bean对象的method方法
			// 看到这里，就能明白，@Reference也可以加在那些setXXX方法上
			// 例如有个userService属性，有个setUserService方法，可以在setUserService方法上加@Reference注解
            method.invoke(bean, referenceBean.getObject());

        }

    }

   private ReferenceBean<?> buildReferenceBean(Reference reference, Class<?> referenceClass) throws Exception {

        String referenceBeanCacheKey = generateReferenceBeanCacheKey(reference, referenceClass);

        ReferenceBean<?> referenceBean = referenceBeansCache.get(referenceBeanCacheKey);

        if (referenceBean == null) {

            ReferenceBeanBuilder beanBuilder = ReferenceBeanBuilder
                    .create(reference, classLoader, applicationContext)
                    .interfaceClass(referenceClass);
			// 这里报错
            referenceBean = beanBuilder.build();

            referenceBeansCache.putIfAbsent(referenceBeanCacheKey, referenceBean);

        }

        return referenceBean;

    }

 public final B build() throws Exception {

        checkDependencies();
		
        B bean = doBuild();

        configureBean(bean);
        
        if (logger.isInfoEnabled()) {
        	// 这里报错
            logger.info(bean + " has been built.");
        }

        return bean;

    }

    @Override
    protected ReferenceBean doBuild() {
        return new ReferenceBean<Object>();
    }

 @Override
    public String toString() {
        try {
            StringBuilder buf = new StringBuilder();
            buf.append("<dubbo:");
            buf.append(getTagName(getClass()));
            Method[] methods = getClass().getMethods();
            // 拿到当前类的所有方法
            for (Method method : methods) {
                try {
                    String name = method.getName();
                    // 过滤剩下get和is开头的方法，但不包括getClass、get和is
                    if ((name.startsWith("get") || name.startsWith("is"))
                            && !"getClass".equals(name) && !"get".equals(name) && !"is".equals(name)
                            && Modifier.isPublic(method.getModifiers())
                            && method.getParameterTypes().length == 0
                            && isPrimitive(method.getReturnType())) {
                        int i = name.startsWith("get") ? 3 : 2;
                        String key = name.substring(i, i + 1).toLowerCase() + name.substring(i + 1);
                        // 反射获取方法返回值，拼接字符串
                        // 就是这里报空指针
                        Object value = method.invoke(this, new Object[0]);
                        if (value != null) {
                            buf.append(" ");
                            buf.append(key);
                            buf.append("=\"");
                            buf.append(value);
                            buf.append("\"");
                        }
                    }
                } catch (Exception e) {
                    logger.warn(e.getMessage(), e);
                }
            }
            buf.append(" />");
            return buf.toString();
        } catch (Throwable t) {
            logger.warn(t.getMessage(), t);
            return super.toString();
        }
    }

public class ReferenceBean<T> extends ReferenceConfig<T> implements FactoryBean, ApplicationContextAware, InitializingBean, DisposableBean {
    @Override
    public Object getObject() throws Exception {
        return get();
    }
    
    public synchronized T get() {
        if (destroyed) {
            throw new IllegalStateException("Already destroyed!");
        }
        if (ref == null) {
            init();
        }
        return ref;
    }

    private void init() {
        if (initialized) {
            return;
        }
        initialized = true;
        ......
        ......
        ref = createProxy(map);
        ConsumerModel consumerModel = new ConsumerModel(getUniqueServiceName(), this, ref, interfaceClass.getMethods());
        ApplicationModel.initConsumerModel(getUniqueServiceName(), consumerModel);
    }

    private T createProxy(Map<String, String> map) {
        ......
		......
        Boolean c = check;
        if (c == null && consumer != null) {
            c = consumer.isCheck();
        }
        if (c == null) {
            c = true; // default true
        }
        if (c && !invoker.isAvailable()) {
            throw new IllegalStateException("Failed to check the status of the service " + interfaceName + ". No provider available for the service " + (group == null ? "" : group + "/") + interfaceName + (version == null ? "" : ":" + version) + " from the url " + invoker.getUrl() + " to the consumer " + NetUtils.getLocalHost() + " use dubbo version " + Version.getVersion());
        }
        if (logger.isInfoEnabled()) {
            logger.info("Refer dubbo service " + interfaceClass.getName() + " from url " + invoker.getUrl());
        }
        // create service proxy
        return (T) proxyFactory.getProxy(invoker);
    }

 @Override
        protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {

            Class<?> referenceClass = field.getType();
			// 构建ReferenceBean对象
            referenceBean = buildReferenceBean(reference, referenceClass);
			// 将属性设置为可访问的
            ReflectionUtils.makeAccessible(field);
			// 给Field对象设置属性
            field.set(bean, referenceBean.getObject());

        }