@Override public Object resolveDependency(DependencyDescriptor descriptor, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException { descriptor.initParameterNameDiscovery(getParameterNameDiscoverer()); if (descriptor.getDependencyType().equals(ObjectFactory.class)) { return new DependencyObjectFactory(descriptor, beanName); } else if (descriptor.getDependencyType().equals(javaxInjectProviderClass)) { return new DependencyProviderFactory().createDependencyProvider(descriptor, beanName); } else { Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, beanName); if (result == null) { result = doResolveDependency(descriptor, beanName, autowiredBeanNames, typeConverter); } return result; } }
@Override public Object resolveDependency(DependencyDescriptor descriptor, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException { descriptor.initParameterNameDiscovery(getParameterNameDiscoverer()); if (descriptor.getDependencyType().equals(javaUtilOptionalClass)) { return new OptionalDependencyFactory().createOptionalDependency(descriptor, beanName); } else if (ObjectFactory.class == descriptor.getDependencyType()) { return new DependencyObjectFactory(descriptor, beanName); } else if (javaxInjectProviderClass == descriptor.getDependencyType()) { return new DependencyProviderFactory().createDependencyProvider(descriptor, beanName); } else { Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, beanName); if (result == null) { result = doResolveDependency(descriptor, beanName, autowiredBeanNames, typeConverter); } return result; } }
@Override public Object resolveDependency(DependencyDescriptor descriptor, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException { if (descriptor == null || descriptor.getField() == null || !descriptor.getField().getType().equals(Ignite.class)) return super.resolveDependency(descriptor, beanName, autowiredBeanNames, typeConverter); else { if (configuration == null) configuration = new IgniteSpringBootConfiguration( createBean(DefaultIgniteProperties.class)); return configuration.getIgnite( descriptor.getField().getAnnotationsByType(IgniteResource.class)); } }
@Override public Object resolveDependency(DependencyDescriptor descriptor, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException { descriptor.initParameterNameDiscovery(getParameterNameDiscoverer()); if (descriptor.getDependencyType().equals(javaUtilOptionalClass)) { return new OptionalDependencyFactory().createOptionalDependency(descriptor, beanName); } else if (ObjectFactory.class == descriptor.getDependencyType() || ObjectProvider.class == descriptor.getDependencyType()) { return new DependencyObjectProvider(descriptor, beanName); } else if (javaxInjectProviderClass == descriptor.getDependencyType()) { return new Jsr330ProviderFactory().createDependencyProvider(descriptor, beanName); } else { Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, beanName); if (result == null) { result = doResolveDependency(descriptor, beanName, autowiredBeanNames, typeConverter); // 解析依赖 } return result; } }
@Override public Object resolveDependency(DependencyDescriptor descriptor, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException { Field field = descriptor.getField(); if (field != null && Logger.class == descriptor.getDependencyType()) { return LoggerFactory.getLogger(getDeclaringClass(descriptor)); } if (field != null && Config.class.isAssignableFrom(field.getType())) { return getConfig(field.getType()); } MethodParameter methodParam = descriptor.getMethodParameter(); if (methodParam != null && Config.class.isAssignableFrom(methodParam.getParameterType())) { return getConfig(methodParam.getParameterType()); } return super.resolveDependency(descriptor, beanName, autowiredBeanNames, typeConverter); }
private Object resolveValue(Method method) { Value val = AnnotationUtils.findAnnotation(method, Value.class); if (val != null) { if (LOG.isDebugEnabled()) { LOG.debug(String.format("Resolving @Value annotation on %s with key %s", method.getName(), val.value())); } ConfigurableBeanFactory beanFactory = (ConfigurableBeanFactory) getBeanFactory(); String strValue = beanFactory.resolveEmbeddedValue(val.value()); BeanExpressionResolver resolver = beanFactory.getBeanExpressionResolver(); Object unconvertedResult = resolver.evaluate(strValue, new BeanExpressionContext(beanFactory, null)); TypeConverter converter = beanFactory.getTypeConverter(); return converter.convertIfNecessary(unconvertedResult, method.getReturnType()); } String message = "Method %s on interface %s must be annotated with @Value for auto-properties to work!"; throw new AutoPropertiesException(String.format(message, method.getName(), method.getDeclaringClass().getName())); }
private TypeConverter getConverter() { if (typeConverter == null) { SimpleTypeConverter simpleConverter = new SimpleTypeConverter(); beanFactory.copyRegisteredEditorsTo(simpleConverter); simpleConverter.setConversionService(beanFactory.getConversionService()); typeConverter = simpleConverter; } return typeConverter; }
/** * Return the underlying TypeConverter of this binder's BindingResult. */ protected TypeConverter getTypeConverter() { if (getTarget() != null) { return getInternalBindingResult().getPropertyAccessor(); } else { return getSimpleTypeConverter(); } }
/** * Look up the JNDI object and store it. */ @Override public void afterPropertiesSet() throws IllegalArgumentException, NamingException { super.afterPropertiesSet(); if (this.proxyInterfaces != null || !this.lookupOnStartup || !this.cache || this.exposeAccessContext) { // We need to create a proxy for this... if (this.defaultObject != null) { throw new IllegalArgumentException( "'defaultObject' is not supported in combination with 'proxyInterface'"); } // We need a proxy and a JndiObjectTargetSource. this.jndiObject = JndiObjectProxyFactory.createJndiObjectProxy(this); } else { if (this.defaultObject != null && getExpectedType() != null && !getExpectedType().isInstance(this.defaultObject)) { TypeConverter converter = (this.beanFactory != null ? this.beanFactory.getTypeConverter() : new SimpleTypeConverter()); try { this.defaultObject = converter.convertIfNecessary(this.defaultObject, getExpectedType()); } catch (TypeMismatchException ex) { throw new IllegalArgumentException("Default object [" + this.defaultObject + "] of type [" + this.defaultObject.getClass().getName() + "] is not of expected type [" + getExpectedType().getName() + "] and cannot be converted either", ex); } } // Locate specified JNDI object. this.jndiObject = lookupWithFallback(); } }
/** * Resolve the prepared arguments stored in the given bean definition. */ private Object[] resolvePreparedArguments( String beanName, RootBeanDefinition mbd, BeanWrapper bw, Member methodOrCtor, Object[] argsToResolve) { Class<?>[] paramTypes = (methodOrCtor instanceof Method ? ((Method) methodOrCtor).getParameterTypes() : ((Constructor<?>) methodOrCtor).getParameterTypes()); TypeConverter converter = (this.beanFactory.getCustomTypeConverter() != null ? this.beanFactory.getCustomTypeConverter() : bw); BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this.beanFactory, beanName, mbd, converter); Object[] resolvedArgs = new Object[argsToResolve.length]; for (int argIndex = 0; argIndex < argsToResolve.length; argIndex++) { Object argValue = argsToResolve[argIndex]; MethodParameter methodParam = MethodParameter.forMethodOrConstructor(methodOrCtor, argIndex); GenericTypeResolver.resolveParameterType(methodParam, methodOrCtor.getDeclaringClass()); if (argValue instanceof AutowiredArgumentMarker) { argValue = resolveAutowiredArgument(methodParam, beanName, null, converter); } else if (argValue instanceof BeanMetadataElement) { argValue = valueResolver.resolveValueIfNecessary("constructor argument", argValue); } else if (argValue instanceof String) { argValue = this.beanFactory.evaluateBeanDefinitionString((String) argValue, mbd); } Class<?> paramType = paramTypes[argIndex]; try { resolvedArgs[argIndex] = converter.convertIfNecessary(argValue, paramType, methodParam); } catch (TypeMismatchException ex) { String methodType = (methodOrCtor instanceof Constructor ? "constructor" : "factory method"); throw new UnsatisfiedDependencyException( mbd.getResourceDescription(), beanName, argIndex, paramType, "Could not convert " + methodType + " argument value of type [" + ObjectUtils.nullSafeClassName(argValue) + "] to required type [" + paramType.getName() + "]: " + ex.getMessage()); } } return resolvedArgs; }
/** * Template method for resolving the specified argument which is supposed to be autowired. */ protected Object resolveAutowiredArgument( MethodParameter param, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter) { return this.beanFactory.resolveDependency( new DependencyDescriptor(param, true), beanName, autowiredBeanNames, typeConverter); }
@Override public TypeConverter getTypeConverter() { TypeConverter customConverter = getCustomTypeConverter(); if (customConverter != null) { return customConverter; } else { // Build default TypeConverter, registering custom editors. SimpleTypeConverter typeConverter = new SimpleTypeConverter(); typeConverter.setConversionService(getConversionService()); registerCustomEditors(typeConverter); return typeConverter; } }
/** * Abstract method defining "autowire by type" (bean properties by type) behavior. * <p>This is like PicoContainer default, in which there must be exactly one bean * of the property type in the bean factory. This makes bean factories simple to * configure for small namespaces, but doesn't work as well as standard Spring * behavior for bigger applications. * @param beanName the name of the bean to autowire by type * @param mbd the merged bean definition to update through autowiring * @param bw BeanWrapper from which we can obtain information about the bean * @param pvs the PropertyValues to register wired objects with */ protected void autowireByType( String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) { TypeConverter converter = getCustomTypeConverter(); if (converter == null) { converter = bw; } Set<String> autowiredBeanNames = new LinkedHashSet<String>(4); String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw); for (String propertyName : propertyNames) { try { PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName); // Don't try autowiring by type for type Object: never makes sense, // even if it technically is a unsatisfied, non-simple property. if (!Object.class.equals(pd.getPropertyType())) { MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd); // Do not allow eager init for type matching in case of a prioritized post-processor. boolean eager = !PriorityOrdered.class.isAssignableFrom(bw.getWrappedClass()); DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager); Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter); if (autowiredArgument != null) { pvs.add(propertyName, autowiredArgument); } for (String autowiredBeanName : autowiredBeanNames) { registerDependentBean(autowiredBeanName, beanName); if (logger.isDebugEnabled()) { logger.debug("Autowiring by type from bean name '" + beanName + "' via property '" + propertyName + "' to bean named '" + autowiredBeanName + "'"); } } autowiredBeanNames.clear(); } } catch (BeansException ex) { throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex); } } }
/** * Convert the given value for the specified target property. */ private Object convertForProperty(Object value, String propertyName, BeanWrapper bw, TypeConverter converter) { if (converter instanceof BeanWrapperImpl) { return ((BeanWrapperImpl) converter).convertForProperty(value, propertyName); } else { PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName); MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd); return converter.convertIfNecessary(value, pd.getPropertyType(), methodParam); } }
/** * Create a BeanDefinitionValueResolver for the given BeanFactory and BeanDefinition. * @param beanFactory the BeanFactory to resolve against * @param beanName the name of the bean that we work on * @param beanDefinition the BeanDefinition of the bean that we work on * @param typeConverter the TypeConverter to use for resolving TypedStringValues */ public BeanDefinitionValueResolver( AbstractBeanFactory beanFactory, String beanName, BeanDefinition beanDefinition, TypeConverter typeConverter) { this.beanFactory = beanFactory; this.beanName = beanName; this.beanDefinition = beanDefinition; this.typeConverter = typeConverter; }
@Override @SuppressWarnings("unchecked") protected List<Object> createInstance() { if (this.sourceList == null) { throw new IllegalArgumentException("'sourceList' is required"); } List<Object> result = null; if (this.targetListClass != null) { result = BeanUtils.instantiateClass(this.targetListClass); } else { result = new ArrayList<Object>(this.sourceList.size()); } Class<?> valueType = null; if (this.targetListClass != null) { valueType = GenericCollectionTypeResolver.getCollectionType(this.targetListClass); } if (valueType != null) { TypeConverter converter = getBeanTypeConverter(); for (Object elem : this.sourceList) { result.add(converter.convertIfNecessary(elem, valueType)); } } else { result.addAll(this.sourceList); } return result; }
/** * Obtain a bean type converter from the BeanFactory that this bean * runs in. This is typically a fresh instance for each call, * since TypeConverters are usually <i>not</i> thread-safe. * <p>Falls back to a SimpleTypeConverter when not running in a BeanFactory. * @see ConfigurableBeanFactory#getTypeConverter() * @see org.springframework.beans.SimpleTypeConverter */ protected TypeConverter getBeanTypeConverter() { BeanFactory beanFactory = getBeanFactory(); if (beanFactory instanceof ConfigurableBeanFactory) { return ((ConfigurableBeanFactory) beanFactory).getTypeConverter(); } else { return new SimpleTypeConverter(); } }
@Override @SuppressWarnings("unchecked") protected Set<Object> createInstance() { if (this.sourceSet == null) { throw new IllegalArgumentException("'sourceSet' is required"); } Set<Object> result = null; if (this.targetSetClass != null) { result = BeanUtils.instantiateClass(this.targetSetClass); } else { result = new LinkedHashSet<Object>(this.sourceSet.size()); } Class<?> valueType = null; if (this.targetSetClass != null) { valueType = GenericCollectionTypeResolver.getCollectionType(this.targetSetClass); } if (valueType != null) { TypeConverter converter = getBeanTypeConverter(); for (Object elem : this.sourceSet) { result.add(converter.convertIfNecessary(elem, valueType)); } } else { result.addAll(this.sourceSet); } return result; }
@Override @SuppressWarnings("unchecked") protected Map<Object, Object> createInstance() { if (this.sourceMap == null) { throw new IllegalArgumentException("'sourceMap' is required"); } Map<Object, Object> result = null; if (this.targetMapClass != null) { result = BeanUtils.instantiateClass(this.targetMapClass); } else { result = new LinkedHashMap<Object, Object>(this.sourceMap.size()); } Class<?> keyType = null; Class<?> valueType = null; if (this.targetMapClass != null) { keyType = GenericCollectionTypeResolver.getMapKeyType(this.targetMapClass); valueType = GenericCollectionTypeResolver.getMapValueType(this.targetMapClass); } if (keyType != null || valueType != null) { TypeConverter converter = getBeanTypeConverter(); for (Map.Entry<?, ?> entry : this.sourceMap.entrySet()) { Object convertedKey = converter.convertIfNecessary(entry.getKey(), keyType); Object convertedValue = converter.convertIfNecessary(entry.getValue(), valueType); result.put(convertedKey, convertedValue); } } else { result.putAll(this.sourceMap); } return result; }
/** * Obtain the TypeConverter from the BeanFactory that this bean runs in, * if possible. * @see ConfigurableBeanFactory#getTypeConverter() */ @Override protected TypeConverter getDefaultTypeConverter() { if (this.beanFactory != null) { return this.beanFactory.getTypeConverter(); } else { return super.getDefaultTypeConverter(); } }
@Bean public TypeConverter typeConverter() { SimpleTypeConverter tc = new SimpleTypeConverter(); tc.registerCustomEditor(LocalDateTime.class, new LocalDateTimePropertyEditor("yyyyMMdd_HHmmss")); tc.registerCustomEditor(LocalDate.class, new LocalDatePropertyEditor("yyyyMMdd")); return tc; }
public DelegatingQuartzJob(ListableBeanFactory listableBeanFactory, TypeConverter typeConverter, ArgumentResolver argumentResolver) { this.typeConverter = typeConverter; this.listableBeanFactory = listableBeanFactory; this.argumentResolver = argumentResolver; }
/** * Abstract method defining "autowire by type" (bean properties by type) behavior. * <p>This is like PicoContainer default, in which there must be exactly one bean * of the property type in the bean factory. This makes bean factories simple to * configure for small namespaces, but doesn't work as well as standard Spring * behavior for bigger applications. * @param beanName the name of the bean to autowire by type * @param mbd the merged bean definition to update through autowiring * @param bw BeanWrapper from which we can obtain information about the bean * @param pvs the PropertyValues to register wired objects with */ protected void autowireByType( String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) { TypeConverter converter = getCustomTypeConverter(); if (converter == null) { converter = bw; } Set<String> autowiredBeanNames = new LinkedHashSet<String>(4); String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw); for (String propertyName : propertyNames) { try { PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName); // Don't try autowiring by type for type Object: never makes sense, // even if it technically is a unsatisfied, non-simple property. if (Object.class != pd.getPropertyType()) { MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd); // Do not allow eager init for type matching in case of a prioritized post-processor. boolean eager = !PriorityOrdered.class.isAssignableFrom(bw.getWrappedClass()); DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager); Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter); if (autowiredArgument != null) { pvs.add(propertyName, autowiredArgument); } for (String autowiredBeanName : autowiredBeanNames) { registerDependentBean(autowiredBeanName, beanName); if (logger.isDebugEnabled()) { logger.debug("Autowiring by type from bean name '" + beanName + "' via property '" + propertyName + "' to bean named '" + autowiredBeanName + "'"); } } autowiredBeanNames.clear(); } } catch (BeansException ex) { throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex); } } }
@Override public Object doResolveDependency(DependencyDescriptor descriptor, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException { Map<String, Object> tmp = new HashMap<String,Object>(); tmp.put("descriptor", descriptor); tmp.put("beanName", beanName); DependencyDescriptorHolder.setDependencyDescriptor(tmp); try{ return super.doResolveDependency(descriptor,beanName,autowiredBeanNames,typeConverter); }finally{ DependencyDescriptorHolder.setDependencyDescriptor(null); } }