Java Reference类代码示例

import com.alibaba.dubbo.config.annotation.Reference; //导入依赖的package包/类
private static String resolveInterfaceName(Reference reference, Class<?> beanClass)
        throws IllegalStateException {

    String interfaceName;
    if (!"".equals(reference.interfaceName())) {
        interfaceName = reference.interfaceName();
    } else if (!void.class.equals(reference.interfaceClass())) {
        interfaceName = reference.interfaceClass().getName();
    } else if (beanClass.isInterface()) {
        interfaceName = beanClass.getName();
    } else {
        throw new IllegalStateException(
                "The @Reference undefined interfaceClass or interfaceName, and the property type "
                        + beanClass.getName() + " is not a interface.");
    }

    return interfaceName;

}
 

import com.alibaba.dubbo.config.annotation.Reference; //导入依赖的package包/类
public ReferenceBean configAndBuild(Reference reference, Class<?> interfaceClass) throws Exception {
    ReferenceBean referenceBean = new ReferenceBean(reference);

    referenceBean.setApplication(findBean(reference.application(), ApplicationConfig.class));
    referenceBean.setRegistries(findBean(reference.registry(), RegistryConfig.class));
    referenceBean.setModule(findBean(reference.module(), ModuleConfig.class));
    referenceBean.setApplicationContext(applicationContext);
    referenceBean.setInterface(interfaceClass);
    referenceBean.afterPropertiesSet();

    return referenceBean;
}
 

import com.alibaba.dubbo.config.annotation.Reference; //导入依赖的package包/类
@Override
protected void inject(final MethodInvocation invocation, final Method method, final Class<?> returnType) throws Throwable {
    final Reference reference = method.getAnnotation(Reference.class);
    final ReferenceConfig<?> refer = new ReferenceConfig<>(reference);
    refer.setCheck(reference.check());
    refer.setInterface(returnType);
    final Object newInstance = ReferenceConfigCache.getCache().get(refer);
    setInstance(invocation.getThis(), method, returnType, newInstance);
}
 

import com.alibaba.dubbo.config.annotation.Reference; //导入依赖的package包/类
@Override
public void injectMembers(final T instance) {
    try {
        final Reference reference = field.getAnnotation(Reference.class);
        final ReferenceConfig<?> refer = new ReferenceConfig<>(reference);
        refer.setCheck(reference.check());
        refer.setInterface(field.getType());
        final Object newInstance = ReferenceConfigCache.getCache().get(refer);
        field.set(instance, newInstance);
    } catch (final IllegalAccessException e) {
        throw (Error) new IllegalAccessError(e.getMessage()).initCause(e);
    }
}
 

import com.alibaba.dubbo.config.annotation.Reference; //导入依赖的package包/类
/**
 * Finds {@link InjectionMetadata.InjectedElement} Metadata from annotated {@link Reference @Reference} fields
 *
 * @param beanClass The {@link Class} of Bean
 * @return non-null {@link List}
 */
private List<InjectionMetadata.InjectedElement> findFieldReferenceMetadata(final Class<?> beanClass) {

    final List<InjectionMetadata.InjectedElement> elements = new LinkedList<InjectionMetadata.InjectedElement>();

    ReflectionUtils.doWithFields(beanClass, new ReflectionUtils.FieldCallback() {
        @Override
        public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {

            Reference reference = findReferenceAnnotation(field);

            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;

}
 

import com.alibaba.dubbo.config.annotation.Reference; //导入依赖的package包/类
/**
 * Finds {@link InjectionMetadata.InjectedElement} Metadata from annotated {@link Reference @Reference} methods
 *
 * @param beanClass The {@link Class} of Bean
 * @return non-null {@link List}
 */
private List<InjectionMetadata.InjectedElement> findMethodReferenceMetadata(final Class<?> beanClass) {

    final List<InjectionMetadata.InjectedElement> elements = new LinkedList<InjectionMetadata.InjectedElement>();

    ReflectionUtils.doWithMethods(beanClass, new ReflectionUtils.MethodCallback() {
        @Override
        public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {

            Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);

            if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
                return;
            }

            Reference reference = findReferenceAnnotation(bridgedMethod);

            if (reference != null && method.equals(ClassUtils.getMostSpecificMethod(method, beanClass))) {
                if (Modifier.isStatic(method.getModifiers())) {
                    if (logger.isWarnEnabled()) {
                        logger.warn("@Reference annotation is not supported on static methods: " + method);
                    }
                    return;
                }
                if (method.getParameterTypes().length == 0) {
                    if (logger.isWarnEnabled()) {
                        logger.warn("@Reference  annotation should only be used on methods with parameters: " +
                                method);
                    }
                }
                PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, beanClass);
                elements.add(new ReferenceMethodElement(method, pd, reference));
            }
        }
    });

    return elements;

}
 

import com.alibaba.dubbo.config.annotation.Reference; //导入依赖的package包/类
public ReferenceBean(Reference reference) {
    super(reference);
}
 

import com.alibaba.dubbo.config.annotation.Reference; //导入依赖的package包/类
public ReferenceConfig(Reference reference) {
    appendAnnotation(Reference.class, reference);
}
 

import com.alibaba.dubbo.config.annotation.Reference; //导入依赖的package包/类
protected ReferenceInjectedElement(Member member, PropertyDescriptor pd, Reference reference) {
    super(member, pd);
    this.reference = reference;
}
 

import com.alibaba.dubbo.config.annotation.Reference; //导入依赖的package包/类
@Override
public void configure(final Binder binder) {
    binder.bindInterceptor(Matchers.any(), Matchers.annotatedWith(Reference.class), new DubboReferenceInterceptor());
}
 

import com.alibaba.dubbo.config.annotation.Reference; //导入依赖的package包/类
@Inject
@Reference(check = false, url = "dubbo://" + SERVER + "/org.nanoframework.extension.dubbo.service.HelloWorldService")
public HelloWorldService getHelloWorldService() {
    return helloWorldService;
}
 

import com.alibaba.dubbo.config.annotation.Reference; //导入依赖的package包/类
@Inject
@Reference(check = false, url = "dubbo://" + SERVER + "/org.nanoframework.extension.dubbo.service.HelloWorld2Service")
public HelloWorld2Service getHelloWorld2Service() {
    return helloWorld2Service;
}