工厂方法获取对象。同时也是 @Bean 注解的处理。

代码示例

  1. if (mbd.getFactoryMethodName() != null) {
  2.     return instantiateUsingFactoryMethod(beanName, mbd, args);
  3. }

工厂模式创建实例中，工厂主要有两种：

  • 静态工厂（无需工厂的实例对象）
  • 实例工厂（需要创建工厂的实例对象）

测试bean

  1. package cn.lichenghao.entity;
  3. public class Dog {
  4.     private String name;
  5.     private Integer age;
  7.     public Dog() {
  8.         System.out.println("Dog init!!");
  9.     }
  11.     public Dog(String name, Integer age) {
  12.         System.out.println("Dog init!!");
  13.         this.name = name;
  14.         this.age = age;
  15.     }
  17.     public void say(){
  18.         System.out.println("wwwwwwwww");
  19.     }
  21.     public String getName() {
  22.         return name;
  23.     }
  25.     public void setName(String name) {
  26.         this.name = name;
  27.     }
  29.     public Integer getAge() {
  30.         return age;
  31.     }
  33.     public void setAge(Integer age) {
  34.         this.age = age;
  35.     }
  36. }
  1. package cn.lichenghao.entity;
  3. public class Cat extends Animal {
  5.     private String name;
  6.     private Integer age;
  8.     public Cat() {
  9.     }
  11.     public Cat(String name, Integer age) {
  12.         super();
  13.         this.name = name;
  14.         this.age = age;
  15.     }
  17.     public String getName() {
  18.         return name;
  19.     }
  21.     public void setName(String name) {
  22.         this.name = name;
  23.     }
  25.     public Integer getAge() {
  26.         return age;
  27.     }
  29.     public void setAge(Integer age) {
  30.         this.age = age;
  31.     }
  32. }

工厂

  1. public class CatInstanceFactory {
  2.     public Cat getCat(String name, int age) {
  3.         Cat cat = new Cat();
  4.         cat.setName(name);
  5.         cat.setAge(age);
  6.         return cat;
  7.     }
  8. }
  1. public class DogStaticFactory {
  2.     public static Dog getDog(String name, int age) {
  3.         Dog dog = new Dog();
  4.         dog.setName(name);
  5.         dog.setAge(age);
  6.         return dog;
  7.     }
  8. }

加入 IOC 容器

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans
  3.         xmlns="http://www.springframework.org/schema/beans"
  4.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5.         xsi:schemaLocation="http://www.springframework.org/schema/beans 
  6.   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
  8.     <bean id="catA" class="cn.lichenghao.entity.Cat" factory-bean="catInstanceFactory" factory-method="getCat">
  9.         <constructor-arg name="name" value="11"></constructor-arg>
  10.         <constructor-arg name="age" value="11"></constructor-arg>
  11.     </bean>
  13.     <bean id="catInstanceFactory" class="cn.lichenghao.factory.CatInstanceFactory"/>
  14.     <bean id="dogA" class="cn.lichenghao.factory.DogStaticFactory" factory-method="getDog">
  15.         <constructor-arg name="name" value="22"></constructor-arg>
  16.         <constructor-arg name="age" value="22"></constructor-arg>
  17.     </bean>
  18. </beans>

测试

  1. @DisplayName("测试factoryMethod")
  2. @Test
  3. public void factoryMethodTest() {
  4.     ClassPathXmlApplicationContext classPathXmlApplicationContext
  5.             = new ClassPathXmlApplicationContext("factory-method.xml");
  6.     Cat cat = classPathXmlApplicationContext.getBean(Cat.class);
  7.     System.out.println(cat);
  8.     Dog dog = classPathXmlApplicationContext.getBean(Dog.class);
  9.     System.out.println(dog);
  10. }

有了工厂后，就会进入方法

  1. protected BeanWrapper instantiateUsingFactoryMethod(
  2.         String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
  4.     return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
  5. }

继而进入方法
org.springframework.beans.factory.support.ConstructorResolver#instantiateUsingFactoryMethod

  1. public BeanWrapper instantiateUsingFactoryMethod(
  2.         String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
  4.     BeanWrapperImpl bw = new BeanWrapperImpl();
  5.     this.beanFactory.initBeanWrapper(bw);
  7.     Object factoryBean;
  8.     Class<?> factoryClass;
  9.     boolean isStatic;
  11.     String factoryBeanName = mbd.getFactoryBeanName();
  12.     if (factoryBeanName != null) {
  13.         if (factoryBeanName.equals(beanName)) {
  14.             throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
  15.                     "factory-bean reference points back to the same bean definition");
  16.         }
  17.         factoryBean = this.beanFactory.getBean(factoryBeanName);
  18.         if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
  19.             throw new ImplicitlyAppearedSingletonException();
  20.         }
  21.         this.beanFactory.registerDependentBean(factoryBeanName, beanName);
  22.         factoryClass = factoryBean.getClass();
  23.         isStatic = false;
  24.     }
  25.     else {
  26.         // It's a static factory method on the bean class.
  27.         if (!mbd.hasBeanClass()) {
  28.             throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
  29.                     "bean definition declares neither a bean class nor a factory-bean reference");
  30.         }
  31.         factoryBean = null;
  32.         factoryClass = mbd.getBeanClass();
  33.         isStatic = true;
  34.     }
  36.     Method factoryMethodToUse = null;
  37.     ArgumentsHolder argsHolderToUse = null;
  38.     Object[] argsToUse = null;
  40.     if (explicitArgs != null) {
  41.         argsToUse = explicitArgs;
  42.     }
  43.     else {
  44.         Object[] argsToResolve = null;
  45.         synchronized (mbd.constructorArgumentLock) {
  46.             factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;
  47.             if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) {
  48.                 // Found a cached factory method...
  49.                 argsToUse = mbd.resolvedConstructorArguments;
  50.                 if (argsToUse == null) {
  51.                     argsToResolve = mbd.preparedConstructorArguments;
  52.                 }
  53.             }
  54.         }
  55.         if (argsToResolve != null) {
  56.             argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve);
  57.         }
  58.     }
  60.     if (factoryMethodToUse == null || argsToUse == null) {
  61.         // Need to determine the factory method...
  62.         // Try all methods with this name to see if they match the given arguments.
  63.         factoryClass = ClassUtils.getUserClass(factoryClass);
  65.         List<Method> candidates = null;
  66.         if (mbd.isFactoryMethodUnique) {
  67.             if (factoryMethodToUse == null) {
  68.                 factoryMethodToUse = mbd.getResolvedFactoryMethod();
  69.             }
  70.             if (factoryMethodToUse != null) {
  71.                 candidates = Collections.singletonList(factoryMethodToUse);
  72.             }
  73.         }
  74.         if (candidates == null) {
  75.             candidates = new ArrayList<>();
  76.             Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
  77.             for (Method candidate : rawCandidates) {
  78.                 if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
  79.                     candidates.add(candidate);
  80.                 }
  81.             }
  82.         }
  84.         if (candidates.size() == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
  85.             Method uniqueCandidate = candidates.get(0);
  86.             if (uniqueCandidate.getParameterCount() == 0) {
  87.                 mbd.factoryMethodToIntrospect = uniqueCandidate;
  88.                 synchronized (mbd.constructorArgumentLock) {
  89.                     mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
  90.                     mbd.constructorArgumentsResolved = true;
  91.                     mbd.resolvedConstructorArguments = EMPTY_ARGS;
  92.                 }
  93.                 bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, uniqueCandidate, EMPTY_ARGS));
  94.                 return bw;
  95.             }
  96.         }
  98.         if (candidates.size() > 1) {  // explicitly skip immutable singletonList
  99.             candidates.sort(AutowireUtils.EXECUTABLE_COMPARATOR);
  100.         }
  102.         ConstructorArgumentValues resolvedValues = null;
  103.         boolean autowiring = (mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
  104.         int minTypeDiffWeight = Integer.MAX_VALUE;
  105.         Set<Method> ambiguousFactoryMethods = null;
  107.         int minNrOfArgs;
  108.         if (explicitArgs != null) {
  109.             minNrOfArgs = explicitArgs.length;
  110.         }
  111.         else {
  112.             // We don't have arguments passed in programmatically, so we need to resolve the
  113.             // arguments specified in the constructor arguments held in the bean definition.
  114.             if (mbd.hasConstructorArgumentValues()) {
  115.                 ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
  116.                 resolvedValues = new ConstructorArgumentValues();
  117.                 minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
  118.             }
  119.             else {
  120.                 minNrOfArgs = 0;
  121.             }
  122.         }
  124.         LinkedList<UnsatisfiedDependencyException> causes = null;
  126.         for (Method candidate : candidates) {
  127.             int parameterCount = candidate.getParameterCount();
  129.             if (parameterCount >= minNrOfArgs) {
  130.                 ArgumentsHolder argsHolder;
  132.                 Class<?>[] paramTypes = candidate.getParameterTypes();
  133.                 if (explicitArgs != null) {
  134.                     // Explicit arguments given -> arguments length must match exactly.
  135.                     if (paramTypes.length != explicitArgs.length) {
  136.                         continue;
  137.                     }
  138.                     argsHolder = new ArgumentsHolder(explicitArgs);
  139.                 }
  140.                 else {
  141.                     // Resolved constructor arguments: type conversion and/or autowiring necessary.
  142.                     try {
  143.                         String[] paramNames = null;
  144.                         ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
  145.                         if (pnd != null) {
  146.                             paramNames = pnd.getParameterNames(candidate);
  147.                         }
  148.                         argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw,
  149.                                 paramTypes, paramNames, candidate, autowiring, candidates.size() == 1);
  150.                     }
  151.                     catch (UnsatisfiedDependencyException ex) {
  152.                         if (logger.isTraceEnabled()) {
  153.                             logger.trace("Ignoring factory method [" + candidate + "] of bean '" + beanName + "': " + ex);
  154.                         }
  155.                         // Swallow and try next overloaded factory method.
  156.                         if (causes == null) {
  157.                             causes = new LinkedList<>();
  158.                         }
  159.                         causes.add(ex);
  160.                         continue;
  161.                     }
  162.                 }
  164.                 int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
  165.                         argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
  166.                 // Choose this factory method if it represents the closest match.
  167.                 if (typeDiffWeight < minTypeDiffWeight) {
  168.                     factoryMethodToUse = candidate;
  169.                     argsHolderToUse = argsHolder;
  170.                     argsToUse = argsHolder.arguments;
  171.                     minTypeDiffWeight = typeDiffWeight;
  172.                     ambiguousFactoryMethods = null;
  173.                 }
  174.                 // Find out about ambiguity: In case of the same type difference weight
  175.                 // for methods with the same number of parameters, collect such candidates
  176.                 // and eventually raise an ambiguity exception.
  177.                 // However, only perform that check in non-lenient constructor resolution mode,
  178.                 // and explicitly ignore overridden methods (with the same parameter signature).
  179.                 else if (factoryMethodToUse != null && typeDiffWeight == minTypeDiffWeight &&
  180.                         !mbd.isLenientConstructorResolution() &&
  181.                         paramTypes.length == factoryMethodToUse.getParameterCount() &&
  182.                         !Arrays.equals(paramTypes, factoryMethodToUse.getParameterTypes())) {
  183.                     if (ambiguousFactoryMethods == null) {
  184.                         ambiguousFactoryMethods = new LinkedHashSet<>();
  185.                         ambiguousFactoryMethods.add(factoryMethodToUse);
  186.                     }
  187.                     ambiguousFactoryMethods.add(candidate);
  188.                 }
  189.             }
  190.         }
  192.         if (factoryMethodToUse == null || argsToUse == null) {
  193.             if (causes != null) {
  194.                 UnsatisfiedDependencyException ex = causes.removeLast();
  195.                 for (Exception cause : causes) {
  196.                     this.beanFactory.onSuppressedException(cause);
  197.                 }
  198.                 throw ex;
  199.             }
  200.             List<String> argTypes = new ArrayList<>(minNrOfArgs);
  201.             if (explicitArgs != null) {
  202.                 for (Object arg : explicitArgs) {
  203.                     argTypes.add(arg != null ? arg.getClass().getSimpleName() : "null");
  204.                 }
  205.             }
  206.             else if (resolvedValues != null) {
  207.                 Set<ValueHolder> valueHolders = new LinkedHashSet<>(resolvedValues.getArgumentCount());
  208.                 valueHolders.addAll(resolvedValues.getIndexedArgumentValues().values());
  209.                 valueHolders.addAll(resolvedValues.getGenericArgumentValues());
  210.                 for (ValueHolder value : valueHolders) {
  211.                     String argType = (value.getType() != null ? ClassUtils.getShortName(value.getType()) :
  212.                             (value.getValue() != null ? value.getValue().getClass().getSimpleName() : "null"));
  213.                     argTypes.add(argType);
  214.                 }
  215.             }
  216.             String argDesc = StringUtils.collectionToCommaDelimitedString(argTypes);
  217.             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  218.                     "No matching factory method found on class [" + factoryClass.getName() + "]: " +
  219.                     (mbd.getFactoryBeanName() != null ?
  220.                         "factory bean '" + mbd.getFactoryBeanName() + "'; " : "") +
  221.                     "factory method '" + mbd.getFactoryMethodName() + "(" + argDesc + ")'. " +
  222.                     "Check that a method with the specified name " +
  223.                     (minNrOfArgs > 0 ? "and arguments " : "") +
  224.                     "exists and that it is " +
  225.                     (isStatic ? "static" : "non-static") + ".");
  226.         }
  227.         else if (void.class == factoryMethodToUse.getReturnType()) {
  228.             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  229.                     "Invalid factory method '" + mbd.getFactoryMethodName() + "' on class [" +
  230.                     factoryClass.getName() + "]: needs to have a non-void return type!");
  231.         }
  232.         else if (ambiguousFactoryMethods != null) {
  233.             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  234.                     "Ambiguous factory method matches found on class [" + factoryClass.getName() + "] " +
  235.                     "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
  236.                     ambiguousFactoryMethods);
  237.         }
  239.         if (explicitArgs == null && argsHolderToUse != null) {
  240.             mbd.factoryMethodToIntrospect = factoryMethodToUse;
  241.             argsHolderToUse.storeCache(mbd, factoryMethodToUse);
  242.         }
  243.     }
  245.     bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, factoryMethodToUse, argsToUse));
  246.     return bw;
  247. }

方法执行流程图

instantiateUsingFactoryMethod.xmind
instantiateUsingFactoryMethod.svg