问题来源开始重视这个问题,源自一次阿里巴巴的二面面试题:说说你对Spring中BeanFactory的理解,它和FactoryBean有什么区别呢? 直接区别直面意思:Bean工厂、工厂Bean BeanFactory,以Factory结尾,表示它是一个工厂类(接口),用于管理Bean的一个工厂。在Spring中,BeanFactory是IOC容器的核心接口,它的职责包括:实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。 FactoryBean以Bean结尾,表示它是一个Bean,不同于普通Bean的是:它是实现了FactoryBean<T>接口的Bean,根据该Bean的ID从BeanFactory中获取的实际上是FactoryBean的getObject()返回的对象,而不是FactoryBean本身,如果要获取FactoryBean对象,请在id前面加一个&符号来获取。 BeanFacotryBeanFactory定义了IOC容器的最基本形式,并提供了IOC容器应遵守的的最基本的接口,也就是Spring IOC所遵守的最底层和最基本的编程规范。 Spring代码中,BeanFactory只是个接口,并不是IOC容器的具体实现,但是Spring容器给出了很多种实现,如 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); } 在Spring中,所有的Bean都是由BeanFactory(也就是IOC容器)来进行管理的。但对FactoryBean而言,这个Bean不是简单的Bean,而是一个能生产或者修饰对象生成的工厂Bean,它的实现与设计模式中的工厂模式和修饰器模式类似 BeanFacotry是spring中比较原始的Factory。如XMLBeanFactory就是一种典型的BeanFactory。原始的BeanFactory无法支持spring的许多插件,如AOP功能、Web应用等。ApplicationContext接口,它由BeanFactory接口派生而来,
ApplicationContext以一种更向面向框架的方式工作以及对上下文进行分层和实现继承,ApplicationContext包还提供了以下的功能:
常见的初始化例子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; 分析了从BeanFactory到ConfigurableListableBeanFactory接口的概要功能:
FactoryBean
一般情况下,Spring通过反射机制利用<bean>的class属性指定实现类实例化Bean,在某些情况下,实例化Bean过程比较复杂,如果按照传统的方式,则需要在<bean>中提供大量的配置信息。 配置方式的灵活性是受限的,这时采用编码的方式可能会得到一个简单的方案。Spring为此提供了一个org.springframework.bean.factory.FactoryBean的工厂类接口,用户可以通过实现该接口定制实例化Bean的逻辑。 FactoryBean接口对于Spring框架来说占用重要的地位,Spring自身就提供了70多个FactoryBean的实现。
当然,我们也可以自己手动来实现一个FactoryBean,用来代理一个对象。从而可以很方便的在对象前后都做出对应的操作,比如输出一句日志: /** * 自己实现一个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; } } 有了这个工厂Bean,我们出去的Bean都将是代理Bean。 main方法单元测试: 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 ObjectFactory通过接口内容来看,两者都是属于工厂模式用来创建对象使用的。 啥都不说,先看个例子吧: @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"; } 从上面的现象打印值的不同,可以看出
|
|
来自: liang1234_ > 《spring ioc》