Example usage for org.springframework.beans.factory.config DependencyDescriptor getDependencyType

Introduction

In this page you can find the example usage for org.springframework.beans.factory.config DependencyDescriptor getDependencyType.

Prototype

public Class<?> getDependencyType() 

Source Link

Document

Determine the declared (non-generic) type of the wrapped parameter/field.

Usage

From source file:org.loginject.SpringLogInjectionService.java

@Override
public BeanFactoryPostProcessor getBindings(LogInject<_Logger_> logInject) {
    return new BeanFactoryPostProcessor() {
        ThreadLocal<Object> injectee = new ThreadLocal<>();

        @Override//from   w ww . j a  va  2  s.c  o  m
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
            DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory) beanFactory;
            AutowireCandidateResolver resolver = new ContextAnnotationAutowireCandidateResolver() {
                @Override
                public Object getSuggestedValue(DependencyDescriptor descriptor) {
                    if (descriptor.getDependencyType().equals(logInject.getLoggerClass())) {
                        return logInject.createLogger(injectee.get().getClass());
                    }
                    return null;
                }
            };
            AutowiredAnnotationBeanPostProcessor beanPostProcessor = new AutowiredAnnotationBeanPostProcessor() {
                @Override
                public PropertyValues postProcessPropertyValues(PropertyValues values,
                        PropertyDescriptor[] descriptors, Object bean, String beanName) throws BeansException {
                    injectee.set(bean);
                    return super.postProcessPropertyValues(values, descriptors, bean, beanName);
                }
            };
            beanPostProcessor.setBeanFactory(defaultListableBeanFactory);
            defaultListableBeanFactory.addBeanPostProcessor(beanPostProcessor);
            defaultListableBeanFactory.setAutowireCandidateResolver(resolver);
        }
    };
}

---

From source file:com.payu.ratel.client.RemoteAutowireCandidateResolver.java

@Override
protected Object buildLazyResolutionProxy(DependencyDescriptor descriptor, String beanName) {

    Collection<String> annotationsType = getAnnotationsTypes(descriptor);
    if (annotationsType.contains(Discover.class.getName())) {
        if (descriptor.getDependencyType().equals(EventCannon.class)) {
            return produceEventCannonProxy();
        } else {//from www .ja  v a2  s . c o m
            RetryPolicyConfig retryPolicy = null;
            Optional<Annotation> retryPolicyAnn = getAnnotationWithType(descriptor, RetryPolicy.class);
            if (retryPolicyAnn.isPresent()) {
                retryPolicy = RetryPolicyConfig.fromRetryPolicy((RetryPolicy) retryPolicyAnn.get());
            }
            TimeoutConfig timeout = null;
            Optional<Annotation> timeoutAnn = getAnnotationWithType(descriptor, Timeout.class);
            if (timeoutAnn.isPresent()) {
                timeout = TimeoutConfig.fromTimeout((Timeout) timeoutAnn.get());
            }

            boolean useCache = annotationsType.contains(Cachable.class.getName());

            return ratelClientProducer.produceServiceProxy(descriptor.getDependencyType(), useCache,
                    retryPolicy, timeout);
        }
    }

    return super.buildLazyResolutionProxy(descriptor, beanName);
}

---

From source file:com.geodevv.testing.irmina.IrminaListableBeanFactory.java

@Override
public Object resolveDependency(DependencyDescriptor descriptor, String beanName,
        Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {

    InjectionPointDefinition injectionPointDefinition = new InjectionPointDefinition(
            descriptor.getAnnotations(), descriptor.getDependencyType());

    Object mockedBean = mockedInjectionPointsRegister.findBy(injectionPointDefinition);

    if (mockedBean != null) {
        return mockedBean;
    }//from w w  w.  ja  v  a  2  s.c  o m

    Object spiedBean = spiedInjectionPointsRegister.findBy(injectionPointDefinition);

    if (spiedBean != null) {
        return spiedBean;
    }

    try {

        Object resolvedBean = super.resolveDependency(descriptor, beanName, autowiredBeanNames, typeConverter);

        if (spiedInjectionPointsRegister.hasDefinition(injectionPointDefinition)) {
            LOGGER.warn("[SPYING DEPENDENCY] " + injectionPointDefinition + " in " + beanName);
            return spiedInjectionPointsRegister.registerSpy(injectionPointDefinition, resolvedBean);
        } else {
            return resolvedBean;
        }

    } catch (NoSuchBeanDefinitionException e) {

        LOGGER.warn("[MOCKING DEPENDENCY] " + injectionPointDefinition + " in " + beanName);
        return mockedInjectionPointsRegister.registerMock(injectionPointDefinition);
    }

}

---

From source file:com.payu.ratel.client.ContextAnnotationAutowireCandidateResolver.java

protected Object buildLazyResolutionProxy(final DependencyDescriptor descriptor, final String beanName) {
    Assert.state(getBeanFactory() instanceof DefaultListableBeanFactory,
            "BeanFactory needs to be a DefaultListableBeanFactory");
    final DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) getBeanFactory();
    TargetSource ts = new TargetSource() {
        @Override//from  w w  w  .  j  a  v  a  2 s  .  com
        public Class<?> getTargetClass() {
            return descriptor.getDependencyType();
        }

        @Override
        public boolean isStatic() {
            return false;
        }

        @Override
        public Object getTarget() {
            return beanFactory.doResolveDependency(descriptor, beanName, null, null);
        }

        @Override
        public void releaseTarget(Object target) {
        }
    };
    ProxyFactory pf = new ProxyFactory();
    pf.setTargetSource(ts);
    Class<?> dependencyType = descriptor.getDependencyType();
    if (dependencyType.isInterface()) {
        pf.addInterface(dependencyType);
    }
    return pf.getProxy(beanFactory.getBeanClassLoader());
}

---

From source file:org.constretto.spring.internal.ConstrettoAutowireCandidateResolver.java

@SuppressWarnings("unchecked")
public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
    if (bdHolder.getBeanDefinition()
            .getAttribute(EnvironmentAnnotationConfigurer.INCLUDE_IN_COLLECTIONS) != null
            && descriptor.getCollectionType() != null) {
        Class[] interfaces = (Class[]) bdHolder.getBeanDefinition()
                .getAttribute(EnvironmentAnnotationConfigurer.INCLUDE_IN_COLLECTIONS);
        for (Class anInterface : interfaces) {
            if (descriptor.getCollectionType().isAssignableFrom(anInterface)) {
                return true;
            }//from ww w . j  a  v a 2 s . co m
        }
    }

    if (descriptor.getDependencyType().isInterface()) {
        return super.isAutowireCandidate(bdHolder, descriptor);
    } else {
        return findEnvironmentAnnotation(descriptor.getDependencyType()) == null
                || super.isAutowireCandidate(bdHolder, descriptor);
    }

}

---

From source file:fr.mby.utils.spring.beans.factory.support.BasicProxywiredFactory.java

@Override
@SuppressWarnings("unchecked")
public IManageableProxywired proxy(final DependencyDescriptor descriptor,
        final IProxywiredIdentifier identifier, final Object target) {
    Assert.notNull(descriptor, "No DependencyDescriptor provided !");
    Assert.notNull(descriptor, "No IProxywiredIdentifier provided !");
    Assert.notNull(descriptor, "No Target to proxy provided !");

    final IManageableProxywired result;

    final Class<?> dependencyType = descriptor.getDependencyType();

    if (Map.class.isAssignableFrom(dependencyType) && dependencyType.isInterface()) {
        result = this.proxyDependencyMap(identifier, (Map<String, Object>) target);

    } else if (List.class.isAssignableFrom(dependencyType) && dependencyType.isInterface()) {
        result = this.proxyDependencyList(identifier, (List<Object>) target);

    } else if (Collection.class.isAssignableFrom(dependencyType) && dependencyType.isInterface()) {
        result = this.proxyDependencyCollection(identifier, (Collection<Object>) target, dependencyType);

    } else if (dependencyType.isArray()) {
        // We can't do anything
        throw new IllegalStateException("You cannot use Proxywired annotation on an Array !");

    } else if (dependencyType.isInterface()) {

        result = this.proxySingleDependency(identifier, target, dependencyType);
    } else {//  w  ww.j  a v  a  2  s  .c  om

        throw new IllegalStateException("Dependency type not supported by this factory !");
    }

    return result;
}

---

From source file:fr.mby.utils.spring.beans.factory.BasicProxywiredManager.java

/**
 * Find Bean Type to inject (not the generic type like Collection or Set).
 * /*from   w w w  .  j  a  v  a2s. c  om*/
 * @param descriptor
 * @param autowiredBeanNames
 * @return
 */
protected Class<?> getBeanType(final DependencyDescriptor descriptor, final Set<String> autowiredBeanNames) {
    final Class<?> result;

    Type fieldType = null;

    final Field field = descriptor.getField();
    if (field == null) {
        // Annotation on the method
        final MethodParameter methodParameter = descriptor.getMethodParameter();
        if (methodParameter != null) {
            fieldType = methodParameter.getGenericParameterType();
        }
    } else {
        fieldType = field.getGenericType();
    }

    if (fieldType != null) {
        final Class<?> type = descriptor.getDependencyType();
        if (Collection.class.isAssignableFrom(type)) {
            final ParameterizedType parameterizedType = (ParameterizedType) fieldType;
            result = (Class<?>) parameterizedType.getActualTypeArguments()[0];
        } else if (Map.class.isAssignableFrom(type)) {
            final ParameterizedType parameterizedType = (ParameterizedType) fieldType;
            result = (Class<?>) parameterizedType.getActualTypeArguments()[1];
        } else if (type.isArray()) {
            // We can't do anything
            throw new IllegalStateException("You cannot use Proxywired annotation on an Array !");
        } else {
            result = type;
        }
    } else {
        throw new IllegalStateException("Unable to find the Bean type !");
    }

    return result;
}

---

From source file:org.openvpms.web.component.im.table.IMObjectTableModelFactory.java

/**
 * Helper to create a new table model.//  w  w w .  jav a2  s. c  om
 *
 * @param handler    the archetype handler
 * @param shortNames the archetype short names. May be {@code null}
 * @param query      the query. May be {@code null}
 * @param parent     the parent object
 * @param context    the layout context
 * @return a new table model, or {@code null} if there is no valid constructor
 */
@SuppressWarnings("unchecked")
private static <T extends IMObject> IMObjectTableModel<T> construct(
        ArchetypeHandler<IMObjectTableModel<T>> handler, final String[] shortNames, Query<T> query,
        final IMObject parent, LayoutContext context) {
    Class type = handler.getType();
    DefaultListableBeanFactory factory = new DefaultListableBeanFactory();

    // Spring doesn't automatically autowire the shortNames array when it is registered as a singleton, so need to
    // register the following to handle it explicitly
    factory.setAutowireCandidateResolver(new SimpleAutowireCandidateResolver() {
        @Override
        public Object getSuggestedValue(DependencyDescriptor descriptor) {
            if (String[].class.equals(descriptor.getDependencyType())) {
                return shortNames;
            }
            return super.getSuggestedValue(descriptor);
        }
    });
    if (query != null) {
        factory.registerSingleton("query", query);
    }
    if (parent != null) {
        factory.registerSingleton("parent", parent);
    }
    if (context != null) {
        factory.registerSingleton("context", context);
    }
    try {
        IMObjectTableModel<T> result = (IMObjectTableModel<T>) factory.createBean(type,
                AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR, false);
        handler.initialise(result);
        return result;
    } catch (Throwable exception) {
        log.error(exception, exception);
    }
    return null;
}

---