public interface BeanFactory {
	/**
	 * 區(qū)分FactoryBean實例，例如，如果bean命名為myJndiObject是一個FactoryBean，通過&myJndiObject將返回工廠，而不是由工廠返回的實例
	 */
	String FACTORY_BEAN_PREFIX = "&";
	/**
	 * 返回指定bean的實例
	 */
	Object getBean(String name) throws BeansException;
	/**
	 * 返回指定bean的實例，并指定返回類型
	 */
	<T> T getBean(String name, Class<T> requiredType) throws BeansException;
	/**
	 * 返回指定bean的實例，并指定創(chuàng)建bean實例時使用的參數(shù)
	 */
	Object getBean(String name, Object... args) throws BeansException;
	/**
	 * 返回的bean實例唯一匹配給定的對象類型
	 */
	<T> T getBean(Class<T> requiredType) throws BeansException;
	/**
	 * 返回的bean實例唯一匹配給定的對象類型，并指定創(chuàng)建bean實例時使用的參數(shù)
	 */
	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
	/**
	 * 返回一個指定bean提供者
	 */
	<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
	/**
	 * 返回一個指定bean提供者
	 */
	<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);
	/**
	 * 判斷工廠中是否包含給定名稱的bean定義，若有則返回true
	 */
	boolean containsBean(String name);
	/**
	 * 判斷bean的作用域是否是singleton：單例模式
	 */
	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
	/**
	 * 判斷bena的作用域是否是prototype：多例模式
	 */
	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
	/**
	 * 檢查具有指定名稱的bean是否與指定的類型匹配
	 */
	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
	/**
	 * 檢查具有指定名稱的bean是否與指定的類型匹配
	 */
	boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
	/**
	 * 用給定的名稱確定bean的類型
	 */
	@Nullable
	Class<?> getType(String name) throws NoSuchBeanDefinitionException;
	/**
	 * 用給定的名稱確定bean的類型
	 */
	@Nullable
	Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;
	/**
	 * 返回給定bean名稱的所有別名 
	 */
	String[] getAliases(String name);
}

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring-config.xml");
User user = (User) applicationContext.getBean("user");
user.hello();

public interface FactoryBean<T> {
	String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";
	/**
	 * 返回需要創(chuàng)建的Bean
	 */
	@Nullable
	T getObject() throws Exception;
	/**
	 * 返回FactoryBean創(chuàng)建的Bean類型
	 */
	@Nullable
	Class<?> getObjectType();
	/**
	 * 是否單例Bean，默認是單例的，存入Spring容器中單例緩存池
	 */
	default boolean isSingleton() {
		return true;
	}
}

public class Student implements Serializable {
    private String id;
    private String name;
    private int age;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
@Component
public class MyFactoryBean implements FactoryBean<Student> {
    @Override
    public Student getObject() throws Exception {
        Student student = new Student();
        student.setId(UUID.randomUUID().toString());
        student.setName("張三");
        student.setAge(20);
        return student;
    }
    @Override
    public Class<?> getObjectType() {
        return Student.class;
    }
    @Override
    public boolean isSingleton() {
        return true;
    }
}

public void test2() {
        System.out.println("========返回工廠中的實例========");
        //返回工廠中的實例，調用FactoryBean.getObject()創(chuàng)建實例
        Student student1 = (Student) applicationContext.getBean("myFactoryBean");
        System.out.println(student1);
        System.out.println("========返回工廠本身========");
        //返回工廠本身，通過構造方法初始化實例
        Object bean = applicationContext.getBean("&myFactoryBean");
        System.out.println(bean);
    }