List of usage examples for org.springframework.beans.factory.config ConstructorArgumentValues getGenericArgumentValues
public List<ValueHolder> getGenericArgumentValues()
From source file:uk.org.ponder.rsac.support.BeanDefUtil.java
static RSACBeanInfo convertBeanDef(BeanDefinition origdef, String beanname, ConfigurableListableBeanFactory factory, MethodAnalyser abdAnalyser, BeanDefConverter converter) { RSACBeanInfo rbi = new RSACBeanInfo(); AbstractBeanDefinition def = getMergedBeanDefinition(factory, beanname, origdef); MutablePropertyValues pvs = def.getPropertyValues(); PropertyValue[] values = pvs.getPropertyValues(); for (int j = 0; j < values.length; ++j) { PropertyValue thispv = values[j]; Object beannames = BeanDefUtil.propertyValueToBeanName(thispv.getValue(), converter); boolean skip = false; // skip recording the dependency if it was unresolvable (some // unrecognised // type) or was a single-valued type referring to a static dependency. // NB - we now record ALL dependencies - bean-copying strategy // discontinued. if (beannames == null // || beannames instanceof String // && !blankcontext.containsBean((String) beannames) ) {// www.j av a 2s . com skip = true; } if (!skip) { rbi.recordDependency(thispv.getName(), beannames); } } // NB - illegal cast here is unavoidable. // Bit of a problem here with Spring flow - apparently the bean class // will NOT be set for a "factory-method" bean UNTIL it has been // instantiated // via the logic in AbstractAutowireCapableBeanFactory l.376: // protected BeanWrapper instantiateUsingFactoryMethod( AbstractBeanDefinition abd = def; rbi.factorybean = abd.getFactoryBeanName(); rbi.factorymethod = abd.getFactoryMethodName(); rbi.initmethod = abd.getInitMethodName(); rbi.destroymethod = abd.getDestroyMethodName(); rbi.islazyinit = abd.isLazyInit(); rbi.dependson = abd.getDependsOn(); rbi.issingleton = abd.isSingleton(); rbi.isabstract = abd.isAbstract(); rbi.aliases = factory.containsBeanDefinition(beanname) ? factory.getAliases(beanname) : StringArrayParser.EMPTY_STRINGL; if (abd.hasConstructorArgumentValues()) { ConstructorArgumentValues cav = abd.getConstructorArgumentValues(); boolean hasgeneric = !cav.getGenericArgumentValues().isEmpty(); boolean hasindexed = !cav.getIndexedArgumentValues().isEmpty(); if (hasgeneric && hasindexed) { throw new UnsupportedOperationException("RSAC Bean " + beanname + " has both indexed and generic constructor arguments, which is not supported"); } if (hasgeneric) { List cvalues = cav.getGenericArgumentValues(); rbi.constructorargvals = new ConstructorArgumentValues.ValueHolder[cvalues.size()]; for (int i = 0; i < cvalues.size(); ++i) { rbi.constructorargvals[i] = (ConstructorArgumentValues.ValueHolder) cvalues.get(i); } } else if (hasindexed) { Map cvalues = cav.getIndexedArgumentValues(); rbi.constructorargvals = new ConstructorArgumentValues.ValueHolder[cvalues.size()]; for (int i = 0; i < cvalues.size(); ++i) { rbi.constructorargvals[i] = (ConstructorArgumentValues.ValueHolder) cvalues.get(new Integer(i)); } } } if (rbi.factorymethod == null) { // Core Spring change at 2.0M5 - ALL bean classes are now irrevocably // lazy!! // Package org.springframework.beans // introduced lazy loading (and lazy validation) of bean classes in // standard bean factories and bean definition readers AccessMethod bcnaccess = abdAnalyser.getAccessMethod("beanClassName"); if (bcnaccess != null) { String bcn = (String) bcnaccess.getChildObject(abd); if (bcn != null) { rbi.beanclass = ClassGetter.forName(bcn); if (rbi.beanclass == null) { throw new IllegalArgumentException("Class name " + bcn + " for bean definition with name " + beanname + " cannot be resolved"); } } } else { // all right then BE like that! We'll work out the class later. // NB - beandef.getBeanClass() was eliminated around 1.2, we must // use the downcast even earlier now. rbi.beanclass = abd.getBeanClass(); } } return rbi; }
From source file:org.solmix.runtime.support.spring.ContainerPostProcessor.java
private void insertConstructorArg(ConstructorArgumentValues constructorArgs, Object valueToInsert) { List<ValueHolder> genericArgs = new ArrayList<ValueHolder>((constructorArgs.getGenericArgumentValues())); Map<Integer, ValueHolder> indexedArgs = new HashMap<Integer, ValueHolder>( constructorArgs.getIndexedArgumentValues()); constructorArgs.clear();// w w w .j av a 2 s . c o m for (ValueHolder genericValue : genericArgs) { constructorArgs.addGenericArgumentValue(genericValue); } for (Map.Entry<Integer, ValueHolder> entry : indexedArgs.entrySet()) { constructorArgs.addIndexedArgumentValue(entry.getKey() + 1, entry.getValue()); } constructorArgs.addIndexedArgumentValue(0, valueToInsert); }
From source file:org.brekka.stillingar.spring.pc.ConstructorArgDefChangeListener.java
@Override protected void onChange(String newValue) { ConfigurableListableBeanFactory beanFactory = beanFactoryRef.get(); if (beanFactory == null) { return;/*from w ww . ja va 2 s. com*/ } BeanDefinition beanDef = beanFactory.getMergedBeanDefinition(beanName); ConstructorArgumentValues mutableConstructorValues = beanDef.getConstructorArgumentValues(); ValueHolder valueHolder = null; List<ValueHolder> genericArgumentValues = mutableConstructorValues.getGenericArgumentValues(); if (constructorArgIndex != null) { valueHolder = mutableConstructorValues.getIndexedArgumentValues().get(constructorArgIndex); if (valueHolder == null) { throw new IllegalStateException( String.format("Failed to find constructor arg at index %d", constructorArgIndex)); } } else if (genericArgumentValues.size() == 1) { valueHolder = genericArgumentValues.get(0); } else { for (ValueHolder vh : genericArgumentValues) { if (vh.getType().equals(constructorArgType)) { valueHolder = vh; } } if (valueHolder == null) { throw new IllegalStateException( String.format("Failed to find constructor arg with type '%s'", constructorArgType)); } } if (!ObjectUtils.nullSafeEquals(newValue, valueHolder.getValue())) { valueHolder.setValue(newValue); try { /* * Spring implements caching of constructor values, which can be reset by clearing the package-private * field 'resolvedConstructorOrFactoryMethod' on RootBeanDefinition. Naturally this will fail if a * security manager is present but there doesn't seem to be any other way to do it. Make sure to warn * about this in the documentation! */ Field field = beanDef.getClass().getDeclaredField("resolvedConstructorOrFactoryMethod"); field.setAccessible(true); field.set(beanDef, null); } catch (Exception e) { throw new ConfigurationException(String.format( "Unable to update value for constructor argument '%s'. " + "Failed to reset the cached constructor state for bean '%s'", (constructorArgIndex != null ? constructorArgIndex.toString() : constructorArgType), beanName), e); } } }
From source file:org.eclipse.gemini.blueprint.blueprint.config.internal.BlueprintParser.java
private void parseConstructorArgElement(Element ele, AbstractBeanDefinition beanDefinition) { String indexAttr = ele.getAttribute(BeanDefinitionParserDelegate.INDEX_ATTRIBUTE); String typeAttr = ele.getAttribute(BeanDefinitionParserDelegate.TYPE_ATTRIBUTE); boolean hasIndex = false; int index = -1; if (StringUtils.hasLength(indexAttr)) { hasIndex = true;/*from w ww .j a va 2 s .c om*/ try { index = Integer.parseInt(indexAttr); } catch (NumberFormatException ex) { error("Attribute 'index' of tag 'constructor-arg' must be an integer", ele); } if (index < 0) { error("'index' cannot be lower than 0", ele); } } try { this.parseState.push(hasIndex ? new ConstructorArgumentEntry(index) : new ConstructorArgumentEntry()); ConstructorArgumentValues values = beanDefinition.getConstructorArgumentValues(); // Blueprint failure (index duplication) Integer indexInt = Integer.valueOf(index); if (values.getIndexedArgumentValues().containsKey(indexInt)) { error("duplicate 'index' with value=[" + index + "] specified", ele); } Object value = parsePropertyValue(ele, beanDefinition, null); ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value); if (StringUtils.hasLength(typeAttr)) { valueHolder.setType(typeAttr); } valueHolder.setSource(extractSource(ele)); if (hasIndex) { values.addIndexedArgumentValue(index, valueHolder); } else { values.addGenericArgumentValue(valueHolder); } // Blueprint failure (mixed index/non-indexed arguments) if (!values.getGenericArgumentValues().isEmpty() && !values.getIndexedArgumentValues().isEmpty()) { error("indexed and non-indexed constructor arguments are not supported by Blueprint; " + "consider using the Spring namespace instead", ele); } } finally { this.parseState.pop(); } }
From source file:org.eclipse.gemini.blueprint.blueprint.container.support.internal.config.CycleOrderingProcessor.java
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { boolean trace = log.isTraceEnabled(); String[] names = beanFactory.getBeanDefinitionNames(); for (String name : names) { BeanDefinition definition = beanFactory.getBeanDefinition(name); if (definition.hasAttribute(ParsingUtils.BLUEPRINT_MARKER_NAME)) { ConstructorArgumentValues cArgs = definition.getConstructorArgumentValues(); if (trace) log.trace("Inspecting cycles for (blueprint) bean " + name); tag(cArgs.getGenericArgumentValues(), name, definition); tag(cArgs.getIndexedArgumentValues().values(), name, definition); }//from w w w . java 2s .co m } }
From source file:org.springframework.beans.factory.support.ConstructorResolver.java
/** * Instantiate the bean using a named factory method. The method may be static, if the * bean definition parameter specifies a class, rather than a "factory-bean", or * an instance variable on a factory object itself configured using Dependency Injection. * <p>Implementation requires iterating over the static or instance methods with the * name specified in the RootBeanDefinition (the method may be overloaded) and trying * to match with the parameters. We don't have the types attached to constructor args, * so trial and error is the only way to go here. The explicitArgs array may contain * argument values passed in programmatically via the corresponding getBean method. * @param beanName the name of the bean//ww w . ja v a 2 s. c o m * @param mbd the merged bean definition for the bean * @param explicitArgs argument values passed in programmatically via the getBean * method, or {@code null} if none (-> use constructor argument values from bean definition) * @return a BeanWrapper for the new instance */ public BeanWrapper instantiateUsingFactoryMethod(final String beanName, final RootBeanDefinition mbd, @Nullable final Object[] explicitArgs) { BeanWrapperImpl bw = new BeanWrapperImpl(); this.beanFactory.initBeanWrapper(bw); Object factoryBean; Class<?> factoryClass; boolean isStatic; String factoryBeanName = mbd.getFactoryBeanName(); if (factoryBeanName != null) { if (factoryBeanName.equals(beanName)) { throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName, "factory-bean reference points back to the same bean definition"); } factoryBean = this.beanFactory.getBean(factoryBeanName); if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) { throw new ImplicitlyAppearedSingletonException(); } factoryClass = factoryBean.getClass(); isStatic = false; } else { // It's a static factory method on the bean class. if (!mbd.hasBeanClass()) { throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName, "bean definition declares neither a bean class nor a factory-bean reference"); } factoryBean = null; factoryClass = mbd.getBeanClass(); isStatic = true; } Method factoryMethodToUse = null; ArgumentsHolder argsHolderToUse = null; Object[] argsToUse = null; if (explicitArgs != null) { argsToUse = explicitArgs; } else { Object[] argsToResolve = null; synchronized (mbd.constructorArgumentLock) { factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod; if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) { // Found a cached factory method... argsToUse = mbd.resolvedConstructorArguments; if (argsToUse == null) { argsToResolve = mbd.preparedConstructorArguments; } } } if (argsToResolve != null) { argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve, true); } } if (factoryMethodToUse == null || argsToUse == null) { // Need to determine the factory method... // Try all methods with this name to see if they match the given arguments. factoryClass = ClassUtils.getUserClass(factoryClass); Method[] rawCandidates = getCandidateMethods(factoryClass, mbd); List<Method> candidateSet = new ArrayList<>(); for (Method candidate : rawCandidates) { if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) { candidateSet.add(candidate); } } Method[] candidates = candidateSet.toArray(new Method[0]); AutowireUtils.sortFactoryMethods(candidates); ConstructorArgumentValues resolvedValues = null; boolean autowiring = (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR); int minTypeDiffWeight = Integer.MAX_VALUE; Set<Method> ambiguousFactoryMethods = null; int minNrOfArgs; if (explicitArgs != null) { minNrOfArgs = explicitArgs.length; } else { // We don't have arguments passed in programmatically, so we need to resolve the // arguments specified in the constructor arguments held in the bean definition. if (mbd.hasConstructorArgumentValues()) { ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues(); resolvedValues = new ConstructorArgumentValues(); minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues); } else { minNrOfArgs = 0; } } LinkedList<UnsatisfiedDependencyException> causes = null; for (Method candidate : candidates) { Class<?>[] paramTypes = candidate.getParameterTypes(); if (paramTypes.length >= minNrOfArgs) { ArgumentsHolder argsHolder; if (explicitArgs != null) { // Explicit arguments given -> arguments length must match exactly. if (paramTypes.length != explicitArgs.length) { continue; } argsHolder = new ArgumentsHolder(explicitArgs); } else { // Resolved constructor arguments: type conversion and/or autowiring necessary. try { String[] paramNames = null; ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer(); if (pnd != null) { paramNames = pnd.getParameterNames(candidate); } argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames, candidate, autowiring, candidates.length == 1); } catch (UnsatisfiedDependencyException ex) { if (logger.isTraceEnabled()) { logger.trace("Ignoring factory method [" + candidate + "] of bean '" + beanName + "': " + ex); } // Swallow and try next overloaded factory method. if (causes == null) { causes = new LinkedList<>(); } causes.add(ex); continue; } } int typeDiffWeight = (mbd.isLenientConstructorResolution() ? argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes)); // Choose this factory method if it represents the closest match. if (typeDiffWeight < minTypeDiffWeight) { factoryMethodToUse = candidate; argsHolderToUse = argsHolder; argsToUse = argsHolder.arguments; minTypeDiffWeight = typeDiffWeight; ambiguousFactoryMethods = null; } // Find out about ambiguity: In case of the same type difference weight // for methods with the same number of parameters, collect such candidates // and eventually raise an ambiguity exception. // However, only perform that check in non-lenient constructor resolution mode, // and explicitly ignore overridden methods (with the same parameter signature). else if (factoryMethodToUse != null && typeDiffWeight == minTypeDiffWeight && !mbd.isLenientConstructorResolution() && paramTypes.length == factoryMethodToUse.getParameterCount() && !Arrays.equals(paramTypes, factoryMethodToUse.getParameterTypes())) { if (ambiguousFactoryMethods == null) { ambiguousFactoryMethods = new LinkedHashSet<>(); ambiguousFactoryMethods.add(factoryMethodToUse); } ambiguousFactoryMethods.add(candidate); } } } if (factoryMethodToUse == null) { if (causes != null) { UnsatisfiedDependencyException ex = causes.removeLast(); for (Exception cause : causes) { this.beanFactory.onSuppressedException(cause); } throw ex; } List<String> argTypes = new ArrayList<>(minNrOfArgs); if (explicitArgs != null) { for (Object arg : explicitArgs) { argTypes.add(arg != null ? arg.getClass().getSimpleName() : "null"); } } else if (resolvedValues != null) { Set<ValueHolder> valueHolders = new LinkedHashSet<>(resolvedValues.getArgumentCount()); valueHolders.addAll(resolvedValues.getIndexedArgumentValues().values()); valueHolders.addAll(resolvedValues.getGenericArgumentValues()); for (ValueHolder value : valueHolders) { String argType = (value.getType() != null ? ClassUtils.getShortName(value.getType()) : (value.getValue() != null ? value.getValue().getClass().getSimpleName() : "null")); argTypes.add(argType); } } String argDesc = StringUtils.collectionToCommaDelimitedString(argTypes); throw new BeanCreationException(mbd.getResourceDescription(), beanName, "No matching factory method found: " + (mbd.getFactoryBeanName() != null ? "factory bean '" + mbd.getFactoryBeanName() + "'; " : "") + "factory method '" + mbd.getFactoryMethodName() + "(" + argDesc + ")'. " + "Check that a method with the specified name " + (minNrOfArgs > 0 ? "and arguments " : "") + "exists and that it is " + (isStatic ? "static" : "non-static") + "."); } else if (void.class == factoryMethodToUse.getReturnType()) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid factory method '" + mbd.getFactoryMethodName() + "': needs to have a non-void return type!"); } else if (ambiguousFactoryMethods != null) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Ambiguous factory method matches found in bean '" + beanName + "' " + "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " + ambiguousFactoryMethods); } if (explicitArgs == null && argsHolderToUse != null) { argsHolderToUse.storeCache(mbd, factoryMethodToUse); } } try { Object beanInstance; if (System.getSecurityManager() != null) { final Object fb = factoryBean; final Method factoryMethod = factoryMethodToUse; final Object[] args = argsToUse; beanInstance = AccessController.doPrivileged( (PrivilegedAction<Object>) () -> this.beanFactory.getInstantiationStrategy() .instantiate(mbd, beanName, this.beanFactory, fb, factoryMethod, args), this.beanFactory.getAccessControlContext()); } else { beanInstance = this.beanFactory.getInstantiationStrategy().instantiate(mbd, beanName, this.beanFactory, factoryBean, factoryMethodToUse, argsToUse); } bw.setBeanInstance(beanInstance); return bw; } catch (Throwable ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean instantiation via factory method failed", ex); } }
From source file:org.springframework.beans.factory.support.ConstructorResolver.java
/** * Resolve the constructor arguments for this bean into the resolvedValues object. * This may involve looking up other beans. * <p>This method is also used for handling invocations of static factory methods. *///from ww w .ja v a 2s . co m private int resolveConstructorArguments(String beanName, RootBeanDefinition mbd, BeanWrapper bw, ConstructorArgumentValues cargs, ConstructorArgumentValues resolvedValues) { TypeConverter customConverter = this.beanFactory.getCustomTypeConverter(); TypeConverter converter = (customConverter != null ? customConverter : bw); BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this.beanFactory, beanName, mbd, converter); int minNrOfArgs = cargs.getArgumentCount(); for (Map.Entry<Integer, ConstructorArgumentValues.ValueHolder> entry : cargs.getIndexedArgumentValues() .entrySet()) { int index = entry.getKey(); if (index < 0) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid constructor argument index: " + index); } if (index > minNrOfArgs) { minNrOfArgs = index + 1; } ConstructorArgumentValues.ValueHolder valueHolder = entry.getValue(); if (valueHolder.isConverted()) { resolvedValues.addIndexedArgumentValue(index, valueHolder); } else { Object resolvedValue = valueResolver.resolveValueIfNecessary("constructor argument", valueHolder.getValue()); ConstructorArgumentValues.ValueHolder resolvedValueHolder = new ConstructorArgumentValues.ValueHolder( resolvedValue, valueHolder.getType(), valueHolder.getName()); resolvedValueHolder.setSource(valueHolder); resolvedValues.addIndexedArgumentValue(index, resolvedValueHolder); } } for (ConstructorArgumentValues.ValueHolder valueHolder : cargs.getGenericArgumentValues()) { if (valueHolder.isConverted()) { resolvedValues.addGenericArgumentValue(valueHolder); } else { Object resolvedValue = valueResolver.resolveValueIfNecessary("constructor argument", valueHolder.getValue()); ConstructorArgumentValues.ValueHolder resolvedValueHolder = new ConstructorArgumentValues.ValueHolder( resolvedValue, valueHolder.getType(), valueHolder.getName()); resolvedValueHolder.setSource(valueHolder); resolvedValues.addGenericArgumentValue(resolvedValueHolder); } } return minNrOfArgs; }