package com.xinyi.bean;
public class Role {
}
复制代码

@Test
  public void test4() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig1.class);
    String[] names = applicationContext.getBeanDefinitionNames();
    for(String name:names) {
      System.out.println(name);
    }
  }
复制代码

@Import(Role.class)
复制代码

@Configuration
@Import(Role.class)
public class MyConfig1 {
  @Bean("Lin Sin")
  @Lazy
  public Person person() {
    return new Person("李青",18);
  }
  @Bean("Yasuo")
  public Person person1() {
    return new Person("亚索",23);
  }
  @Bean("Zed")
  public Person person2() {
    return new Person("劫",32);
  }
}
复制代码

public @interface Import {
  /**
   * {@link Configuration @Configuration}, {@link ImportSelector},
   * {@link ImportBeanDefinitionRegistrar}, or regular component classes to import.
   */
   //数组
  Class<?>[] value();
}
复制代码

@Import(Role1.class，Role2.class,......)
复制代码

//自定义导入选择器，返回需要注册的组件
public class MyImportSelector implements ImportSelector {
  //返回值就是匹配的要注册的组件（全类名）
  //AnnotationMetadata:当前标注@import注解的类的所有注解信息
  public String[] selectImports(AnnotationMetadata importingClassMetadata) {
    return new String[]{"com.xinyi.bean.Role1","com.xinyi.bean.Role2"};
  }
}
复制代码

public interface ImportSelector {
  /**
   * Select and return the names of which class(es) should be imported based on
   * the {@link AnnotationMetadata} of the importing @{@link Configuration} class.
   */
  String[] selectImports(AnnotationMetadata importingClassMetadata);
}
复制代码

@Import(Role.class，MyImportSelector.class)
复制代码

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar{
  /**
   * AnnotationMetadata：当前类的注解信息
   * BeanDefinitionRegistry：bean定义的注册类信息
   * 需要注册到容器中的bean调用BeanDefinitionRegistry.registryBeanDefinition
   */
  public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    //设置注入条件：containsBeanDefinition的参数是组件的全类名
    boolean flag = registry.containsBeanDefinition("com.xinyi.bean.Role");
    //如果容器中包含Role组件，则将Role3注入进IOC容器
    if(flag) {
      RootBeanDefinition beanDefinition = new RootBeanDefinition(Role3.class);
      registry.registerBeanDefinition("自定注入的Bean名称", beanDefinition);
    }
  }
}
复制代码

@Import({Role.class,MyImportSelector.class,MyImportBeanDefinitionRegistrar.class})
复制代码

//创建spring定义的FactoryBean类
public class RoleBean implements FactoryBean<Role> {
  //返回一个role对象并添加到容器中
  public Role getObject() throws Exception {
    // TODO Auto-generated method stub
    return new Role();
  }
  public Class<?> getObjectType() {
    // TODO Auto-generated method stub
    return Role.class;
  }
}
复制代码

public interface FactoryBean<T> {
  /**
   * Return an instance (possibly shared or independent) of the object
   * managed by this factory.
   * <p>As with a {@link BeanFactory}, this allows support for both the
   * Singleton and Prototype design pattern.
   * <p>If this FactoryBean is not fully initialized yet at the time of
   * the call (for example because it is involved in a circular reference),
   * throw a corresponding {@link FactoryBeanNotInitializedException}.
   * <p>As of Spring 2.0, FactoryBeans are allowed to return {@code null}
   * objects. The factory will consider this as normal value to be used; it
   * will not throw a FactoryBeanNotInitializedException in this case anymore.
   * FactoryBean implementations are encouraged to throw
   * FactoryBeanNotInitializedException themselves now, as appropriate.
   * @return an instance of the bean (can be {@code null})
   * @throws Exception in case of creation errors
   * @see FactoryBeanNotInitializedException
   */
  @Nullable
  T getObject() throws Exception;
  /**
   * Return the type of object that this FactoryBean creates,
   * or {@code null} if not known in advance.
   * <p>This allows one to check for specific types of beans without
   * instantiating objects, for example on autowiring.
   * <p>In the case of implementations that are creating a singleton object,
   * this method should try to avoid singleton creation as far as possible;
   * it should rather estimate the type in advance.
   * For prototypes, returning a meaningful type here is advisable too.
   * <p>This method can be called <i>before</i> this FactoryBean has
   * been fully initialized. It must not rely on state created during
   * initialization; of course, it can still use such state if available.
   * <p><b>NOTE:</b> Autowiring will simply ignore FactoryBeans that return
   * {@code null} here. Therefore it is highly recommended to implement
   * this method properly, using the current state of the FactoryBean.
   * @return the type of object that this FactoryBean creates,
   * or {@code null} if not known at the time of the call
   * @see ListableBeanFactory#getBeansOfType
   */
  @Nullable
  Class<?> getObjectType();
  /**
   * Is the object managed by this factory a singleton? That is,
   * will {@link #getObject()} always return the same object
   * (a reference that can be cached)?
   * <p><b>NOTE:</b> If a FactoryBean indicates to hold a singleton object,
   * the object returned from {@code getObject()} might get cached
   * by the owning BeanFactory. Hence, do not return {@code true}
   * unless the FactoryBean always exposes the same reference.
   * <p>The singleton status of the FactoryBean itself will generally
   * be provided by the owning BeanFactory; usually, it has to be
   * defined as singleton there.
   * <p><b>NOTE:</b> This method returning {@code false} does not
   * necessarily indicate that returned objects are independent instances.
   * An implementation of the extended {@link SmartFactoryBean} interface
   * may explicitly indicate independent instances through its
   * {@link SmartFactoryBean#isPrototype()} method. Plain {@link FactoryBean}
   * implementations which do not implement this extended interface are
   * simply assumed to always return independent instances if the
   * {@code isSingleton()} implementation returns {@code false}.
   * <p>The default implementation returns {@code true}, since a
   * {@code FactoryBean} typically manages a singleton instance.
   * @return whether the exposed object is a singleton
   * @see #getObject()
   * @see SmartFactoryBean#isPrototype()
   */
   //默认是true：Bean是单例，在容器中保存一份
   //当为false：多实例，每次创建都会获取一个新的bean
  default boolean isSingleton() {
    return true;
  }
复制代码

@Bean
  public RoleBean roleBean() {
    return new RoleBean();
  }
复制代码

Object beanObject = applicationContext.getBean("roleBean");
    System.out.println("roleBean的类型是："+beanObject.getClass());
复制代码

public interface BeanFactory {
  /**
   * Used to dereference a {@link FactoryBean} instance and distinguish it from
   * beans <i>created</i> by the FactoryBean. For example, if the bean named
   * {@code myJndiObject} is a FactoryBean, getting {@code &myJndiObject}
   * will return the factory, not the instance returned by the factory.
   */
   //factorybean前缀符：返回的是工厂类，而不是调用getObject方法产生的对象
  String FACTORY_BEAN_PREFIX = "&";
复制代码

Object beanObject1 = applicationContext.getBean("&roleBean");
System.out.println("获取roleBean本身："+beanObject1.getClass());
复制代码