【小家Spring】一文读懂Spring中的BeanFactory和FactoryBean（以及它和ObjectFactory的区别）的区别

public interface BeanFactory {
	// 该常量用来区分是获取FactoryBean还是FactoryBean的createBean创建的实例.如果&开始则获取FactoryBean;否则获取createBean创建的实例.
	// 备注，此常量课时定义在BeanFactory里面的哟，因为它属于Bean工厂的处理机制~~~
	String FACTORY_BEAN_PREFIX = "&";
	
	//==========获取bean,这边可以实现单例,原型
	Object getBean(String name) throws BeansException;
	<T> T getBean(String name, Class<T> requiredType) throws BeansException;
	Object getBean(String name, Object... args) throws BeansException;
	<T> T getBean(Class<T> requiredType) throws BeansException;
	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

	// ======== 
	<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
	<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);

	//判断是否包含Bean。此处有个陷阱：这边不管类是否抽象类,懒加载,是否在容器范围内,只要符合都返回true,所以这边true,**不一定能从getBean获取实例**
	boolean containsBean(String name);

   // =============是否是单例 类型匹配的一些判断
	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
	boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
	
	// 获取Bean的类型、别名等等
	@Nullable
	Class<?> getType(String name) throws NoSuchBeanDefinitionException;
	String[] getAliases(String name);

}

Resource resource = new FileSystemResource("beans.xml");
BeanFactory factory = new XmlBeanFactory(resource);

ClassPathResource resource = new ClassPathResource("beans.xml");
BeanFactory factory = new XmlBeanFactory(resource);

ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"applicationContext.xml", "applicationContext-part2.xml"});
BeanFactory factory = (BeanFactory) context;

/**
 * 自己实现一个FactoryBean 生产出来的对象的前后都输出一个日志
 * <p>
 * InitializingBean：初始化完成后执行操作
 * DisposableBean：销毁后做出对应操作
 *
 * @author fangshixiang
 * @description //
 * @date 2018/12/18 15:19
 */
public class MyFactoryBean implements FactoryBean<Object> {

       private static final Logger logger = LoggerFactory.getLogger(MyFactoryBean.class);
    private Class<?> interfaceClazz; //实现的接口的全类名
    private Object target; //该接口的实现类
    private Object proxyObj;

    public MyFactoryBean(Class<?> interfaceClazz, Object target) {
        this.interfaceClazz = interfaceClazz;
        this.target = target;
        this.proxyObj = Proxy.newProxyInstance(
                this.getClass().getClassLoader(),
                new Class[]{interfaceClazz}, //默认必须实现这个接口
                (proxy, method, args) -> {
                    logger.debug("invoke method......" + method.getName());
                    logger.debug("invoke method before......" + System.currentTimeMillis());
                    Object result = method.invoke(target, args);
                    logger.debug("invoke method after......" + System.currentTimeMillis());

                    return result;
                });
    }

    @Override
    public Object getObject() {
        return proxyObj; //返回这个代理对象 而不是new直接new出来的对象
    }

    @Override
    public Class<?> getObjectType() {
        return proxyObj == null ? Object.class : proxyObj.getClass();
    }

    @Override
    public boolean isSingleton() {
        return true;
    }
}

     public static void main(String[] args) {
        MyFactoryBean factoryBean = new MyFactoryBean(UserService.class, new UserServiceImpl());

        UserService userService = (UserService) factoryBean.getObject();
        System.out.println(userService.sayHello());
    }

    private interface UserService {
        String sayHello();
    }

    private static class UserServiceImpl implements MyFactoryBean.UserService {

        @Override
        public String sayHello() {
            return "hello world";
        }
    }

16:17:05.330 [main] DEBUG com.fsx.single.temp.MyFactoryBean - invoke method......sayHello
16:17:05.334 [main] DEBUG com.fsx.single.temp.MyFactoryBean - invoke method before......1545121025334
16:17:05.334 [main] DEBUG com.fsx.single.temp.MyFactoryBean - invoke method after......1545121025334
hello world

@Configuration
public class RootConfig {

    @Bean
    public FactoryBean myFactoryBean() {
        return new MyFactoryBean();
    }

    @Bean
    public ObjectFactory myObjectFactory() {
        return new MyObjectFactory();
    }

    public static class MyFactoryBean implements FactoryBean<Daughter> {

        @Override
        public Daughter getObject() throws Exception {
            return new Daughter();
        }

        @Override
        public Class<?> getObjectType() {
            return Daughter.class;
        }
    }

    public static class MyObjectFactory implements ObjectFactory<Son> {

        @Override
        public Son getObject() throws BeansException {
            return new Son();
        }
    }

}


    @Autowired
    private ApplicationContext applicationContext;
    @Autowired
    private RootConfig.MyFactoryBean myFactoryBean;
    @Autowired
    private RootConfig.MyObjectFactory myObjectFactory;
    @Autowired
    private Daughter daughter;
    //@Autowired //这里son不能直接注入，但是上面的daughter可以，因为它是FactoryBean，Spring在Bean初始化时会对其进行支持处理
    //private Son son;

    @ResponseBody
    @GetMapping("/hello")
    public String helloGet() throws Exception {
        // 这里注意一下：ApplicationContext是可以直接注入的，可谓非常的方便（至于原因：原理的博文里有说）
        System.out.println(applicationContext); //WebApplicationContext for namespace 'dispatcher-servlet': s ...
        System.out.println(applicationContext.getParent()); //Root WebApplicationContext: startup date [Tue Mar 05

        //========================================
        System.out.println(myFactoryBean); //com.fsx.config.RootConfig$MyFactoryBean@1f8bccbb
        // 这样子，我们是能拿到一个对象的。但需要注意：每get一次，就是new了一个新的
        System.out.println(myObjectFactory.getObject()); //com.fsx.bean.Son@309e3495
        System.out.println(daughter); //com.fsx.bean.Daughter@6cb10346

        // 需要注意的是：单独自己去get的话，出来的都是不同的对象（因此此工厂Bean，Spring又没有增强，所以铁定会执行方法体）
        System.out.println(myFactoryBean.getObject() == myFactoryBean.getObject()); //false
        System.out.println(myObjectFactory.getObject() == myObjectFactory.getObject()); //false
        return "hello...Get";
    }