下面有关spring的依赖注入，说法错误的是？

注入方式：

接口注入

属性注入[属性的SET/GET]

构造注入[构造方法注入]

使用构造函数依赖注入时，Spring保证所有一个对象所有依赖的对象先实例化后，才实例化这个对象。使用set方法依赖注入时，Spring首先实例化对象，然后才实例化所有依赖的对象。

当设值注入与构造注入同时存在时，先执行设置注入，在执行构造注入。

public BeanWrapper autowireConstructor(
 final String beanName, final RootBeanDefinition mbd, Constructor<?>[] chosenCtors, final Object[] explicitArgs) {

 BeanWrapperImpl bw = new BeanWrapperImpl();
 this.beanFactory.initBeanWrapper(bw);

 Constructor<?> constructorToUse = null;
 ArgumentsHolder argsHolderToUse = null;
 Object[] argsToUse = null;

 if (explicitArgs != null) {
 argsToUse = explicitArgs;
 }
 else {
 Object[] argsToResolve = null;
 synchronized (mbd.constructorArgumentLock) {
 constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
 if (constructorToUse != null && mbd.constructorArgumentsResolved) {
 // Found a ***d constructor...
 argsToUse = mbd.resolvedConstructorArguments;
 if (argsToUse == null) {
 argsToResolve = mbd.preparedConstructorArguments;
 }
 }
 }
 if (argsToResolve != null) {
 argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve);
 }
 }

 if (constructorToUse == null) {
 // Need to resolve the constructor.
 boolean autowiring = (chosenCtors != null ||
 mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);
 ConstructorArgumentValues resolvedValues = null;

 int minNrOfArgs;
 if (explicitArgs != null) {
 minNrOfArgs = explicitArgs.length;
 }
 else {
 ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
 resolvedValues = new ConstructorArgumentValues();
 minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
 }

 // Take specified constructors, if any.
 Constructor<?>[] candidates = chosenCtors;
 if (candidates == null) {
 Class<?> beanClass = mbd.getBeanClass();
 try {
 candidates = (mbd.isNonPublicAccessAllowed() ?
 beanClass.getDeclaredConstructors() : beanClass.getConstructors());
 }
 catch (Throwable ex) {
 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
 "Resolution of declared constructors on bean Class [" + beanClass.getName() +
 "] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
 }
 }
 AutowireUtils.sortConstructors(candidates);
 int minTypeDiffWeight = Integer.MAX_VALUE;
 Set<Constructor<?>> ambiguousConstructors = null;
 List<Exception> causes = null;

 for (int i = 0; i < candidates.length; i++) {
 Constructor<?> candidate = candidates[i];
 Class<?>[] paramTypes = candidate.getParameterTypes();

 if (constructorToUse != null && argsToUse.length > paramTypes.length) {
 // Already found greedy constructor that can be satisfied ->
 // do not look any further, there are only less greedy constructors left.
 break;
 }
 if (paramTypes.length < minNrOfArgs) {
 continue;
 }

 ArgumentsHolder argsHolder;
 if (resolvedValues != null) {
 try {
 String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, paramTypes.length);
 if (paramNames == null) {
 ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
 if (pnd != null) {
 paramNames = pnd.getParameterNames(candidate);
 }
 }
 argsHolder = createArgumentArray(
 beanName, mbd, resolvedValues, bw, paramTypes, paramNames, candidate, autowiring);
 }
 catch (UnsatisfiedDependencyException ex) {
 if (this.beanFactory.logger.isTraceEnabled()) {
 this.beanFactory.logger.trace(
 "Ignoring constructor [" + candidate + "] of bean '" + beanName + "': " + ex);
 }
 if (i == candidates.length - 1 && constructorToUse == null) {
 if (causes != null) {
 for (Exception cause : causes) {
 this.beanFactory.onSuppressedException(cause);
 }
 }
 throw ex;
 }
 else {
 // Swallow and try next constructor.
 if (causes == null) {
 causes = new LinkedList<Exception>();
 }
 causes.add(ex);
 continue;
 }
 }
 }
 else {
 // Explicit arguments given -> arguments length must match exactly.
 if (paramTypes.length != explicitArgs.length) {
 continue;
 }
 argsHolder = new ArgumentsHolder(explicitArgs);
 }

 int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
 argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
 // Choose this constructor if it represents the closest match.
 if (typeDiffWeight < minTypeDiffWeight) {
 constructorToUse = candidate;
 argsHolderToUse = argsHolder;
 argsToUse = argsHolder.arguments;
 minTypeDiffWeight = typeDiffWeight;
 ambiguousConstructors = null;
 }
 else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
 if (ambiguousConstructors == null) {
 ambiguousConstructors = new LinkedHashSet<Constructor<?>>();
 ambiguousConstructors.add(constructorToUse);
 }
 ambiguousConstructors.add(candidate);
 }
 }

 if (constructorToUse == null) {
 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
 "Could not resolve matching constructor " +
 "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
 }
 else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) {
 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
 "Ambiguous constructor matches found in bean '" + beanName + "' " +
 "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
 ambiguousConstructors);
 }

 if (explicitArgs == null) {
 argsHolderToUse.storeCache(mbd, constructorToUse);
 }
 }

 try {
 Object beanInstance;

 if (System.getSecurityManager() != null) {
 final Constructor<?> ctorToUse = constructorToUse;
 final Object[] argumentsToUse = argsToUse;
 beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
 @Override
 public Object run() {
 return beanFactory.getInstantiationStrategy().instantiate(
 mbd, beanName, beanFactory, ctorToUse, argumentsToUse);
 }
 }, beanFactory.getAccessControlContext());
 }
 else {
 beanInstance = this.beanFactory.getInstantiationStrategy().instantiate(
 mbd, beanName, this.beanFactory, constructorToUse, argsToUse);
 }

 bw.setWrappedInstance(beanInstance);
 return bw;
 }
 catch (Throwable ex) {
 throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
 }
 }

 public class TestBean {
    private String name;
    private int age;
    public TestBean()
    {
        System.out.println("TestBean - -- -no Param");
    }
    public TestBean(String name)
    {
        System.out.println("=================" + name + "=================");
        this.name = name;
    }
    public void setAge(int age) {
        System.out.println("设置age");
        this.age = age;
    }
}  <bean id="testBean" class="TestBean">
        <constructor-arg name="name" value="adea"></constructor-arg>
        <property name="age" value="12"></property>
    </bean> 

有设值注入和构造注入同时存在时，设值注入有效