Spring之BeanFactory和FactoryBean接口的区别

目录

  • 一、BeanFactory接口
  • 二、FactoryBean接口
    • 1.简单实现
    • 2.增强实现
    • 3.FactoryBean的实际使用案例
  • 三、总结

@
??Spring框架中的BeanFactory接口和FactoryBean接口因为名称相似，老是容易搞混淆，而且也是面试过程中经常会碰到的一个问题。所以本文就专门给大家整理出来。

一、BeanFactory接口

??BeanFactory接口是Spring容器的核心接口，负责：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。

??Spring为我们提供了许多易用的BeanFactory实现，XmlBeanFactory就是常用的一个，该实现将以XML方式描述组成应用的对象及对象间的依赖关系。XmlBeanFactory类将持有此XML配置元数据，并用它来构建一个完全可配置的系统或应用。

BeanFactory bf = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
Object bean =  bf.getBean(IUserService.class);
System.out.println(bean);

接口中定义的方法

public interface BeanFactory {

    String FACTORY_BEAN_PREFIX = "&";

    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;

    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;

    Class<?> getType(String name) throws NoSuchBeanDefinitionException;

    String[] getAliases(String name);
}

二、FactoryBean接口

??BeanFactory接口是Spring的核心接口。功能非常复杂，这个时候如果我们想要编写一些比较复杂点儿的逻辑就会触及到其他一些不必要的接口，不好实现。这时候使用FactoryBean就比较方便了。FactoryBean以Bean结尾是个Bean对象，不是工厂。接口中定义的方法如下:

public interface FactoryBean<T> {

    /**
     * 返回对象的实例
     */
    T getObject() throws Exception;

    /**
     * 返回对象的类型
     */
    Class<?> getObjectType();

    /**
     * 是否是单例
     */
    boolean isSingleton();
}

1.简单实现

接口和实现类

public interface IUserService {

    public void doSome();
}
public class UserServiceImpl implements IUserService {

    public UserServiceImpl(){
        System.out.println("--被实例化了--");
    }

    @Override
    public void doSome() {
        System.out.println("UserServiceImpl 。。。 被执行了");

    }

}

自定义FactoryBean

public class MyFactoryBean implements FactoryBean<IUserService>{

    @Override
    public IUserService getObject() throws Exception {
        System.out.println("--IUserService实例化之前---");
        IUserService service = new UserServiceImpl();
        System.out.println("--IUserService实例化后---");
        return service;
    }

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

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

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="myFactoryBean" class="com.dpb.factorybean.MyFactoryBean"/>
</beans>

测试--通过类型获取

@Test
public void test1() {
    BeanFactory bf = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
    Object bean =  bf.getBean(IUserService.class);
    System.out.println(bean);
}

输出结果

--IUserService实例化之前---
--被实例化了--
--IUserService实例化后---
com.dpb.service.UserServiceImpl@5315b42e

测试--通过id获取

@Test
public void test1() {
    BeanFactory bf = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
    Object bean =  bf.getBean("myFactoryBean");
    System.out.println(bean);
}

输出结果

--IUserService实例化之前---
--被实例化了--
--IUserService实例化后---
com.dpb.service.UserServiceImpl@783e6358

如果想要获取FactoryBean对象 id前加 &就可以

@Test
public void test1() {
    BeanFactory bf = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
    Object bean =  bf.getBean("&myFactoryBean");
    System.out.println(bean);
}

输出结果

com.dpb.factorybean.MyFactoryBean@3b81a1bc

2.增强实现

??通过FactoryBean创建一个代理类来增强目标类，我们来看下效果

接口和实现类

public interface IUserService {

    public void doSome();
}
public class UserServiceImpl implements IUserService {

    public UserServiceImpl(){
        System.out.println("--被实例化了--");
    }

    @Override
    public void doSome() {
        System.out.println("UserServiceImpl 。。。 被执行了");

    }

}

自定义FactoryBean

public class MyFactoryBean implements FactoryBean,InitializingBean,DisposableBean{

    private Object proxyObject;

    private Object target;

    private String interfaceName;

    @Override
    public Object getObject() throws Exception {

        return proxyObject;
    }

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

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

    /**
     * MyFactoryBean 对象销毁的回调方法
     * @throws Exception
     */
    @Override
    public void destroy() throws Exception {
        System.out.println("destroy ....");

    }

    /**
     * MyFactoryBean 对象实例化的方法
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("---afterPropertiesSet---");
        proxyObject = Proxy.newProxyInstance(
                    this.getClass().getClassLoader()
                    , new Class[]{Class.forName(interfaceName)}
                    , new InvocationHandler() {

                        @Override
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                            System.out.println("----代理方法执行开始----");
                            Object obj = method.invoke(target, args);
                            System.out.println("----代理方法执行结束----");
                            return obj;
                        }
                    });
    }

    public String getInterfaceName() {
        return interfaceName;
    }

    public void setInterfaceName(String interfaceName) {
        this.interfaceName = interfaceName;
    }

    public Object getTarget() {
        return target;
    }

    public void setTarget(Object target) {
        this.target = target;
    }
}

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 注册目标对象 -->
    <bean class="com.dpb.service.UserServiceImpl" id="userServiceImpl"/>
    <!-- 注册FactoryBean对象 -->
    <bean id="myFactoryBean" class="com.dpb.factorybean.MyFactoryBean">
        <property name="interfaceName" value="com.dpb.service.IUserService"/>
         <property name="target" ref="userServiceImpl"/>
    </bean>
</beans>

测试

@Test
public void test1() {
    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
    IUserService bean =   (IUserService) ac.getBean("myFactoryBean");
    System.out.println("****************");
    bean.doSome();
    System.out.println();
}

输出结果：

--被实例化了--
---afterPropertiesSet---
****************
----代理方法执行开始----
UserServiceImpl 。。。 被执行了
----代理方法执行结束----

小结：通过输出结果我们可以看到通过FactoryBean接口我们也可以实现BeanFactory中某些接口提供的功能，而且会更加的灵活一些。

3.FactoryBean的实际使用案例

??Spring在整合mybatis框架的时候提供的SqlSessionFactoryBean就是FactoryBean的很好的实现。

<!-- 整合mybatis -->
<bean class="org.mybatis.spring.SqlSessionFactoryBean"
id="sqlSessionFactoryBean" >
    <!-- 关联数据源 -->
    <property name="dataSource" ref="dataSource"/>
    <!-- 关联mybatis的配置文件 -->
    <property name="configLocation" value="classpath:mybatis-cfg.xml"/>
    <!-- 添加别名设置 -->
    <property name="typeAliasesPackage" value="com.sxt.model"/>
    <!-- 映射文件和接口文件不在同一个目录下的时候，需要单独指定映射文件的路径 -->
    <property name="mapperLocations" value="classpath:mapper/*.xml"/>
</bean>

??Spring会调用SqlSessionFactoryBean这个实现了FactoryBean的工厂Bean 同时加载dataSource,Mapper文件的路径,对sqlSessionFactory进行初始化。

源代码比较多就不一一贴出来。到了这儿可以自行跟踪下源代码。
核心方法

@Override
  public void afterPropertiesSet() throws Exception {
    // 省略
    this.sqlSessionFactory = buildSqlSessionFactory();
  }

  protected SqlSessionFactory buildSqlSessionFactory() throws IOException {

    Configuration configuration;

    XMLConfigBuilder xmlConfigBuilder = null;
    // 省略
    return this.sqlSessionFactoryBuilder.build(configuration);
  }
/**
  * {@inheritDoc}
  */
 @Override
 public SqlSessionFactory getObject() throws Exception {
   if (this.sqlSessionFactory == null) {
     afterPropertiesSet();
   }

   return this.sqlSessionFactory;
 }

 /**
  * {@inheritDoc}
  */
 @Override
 public Class<? extends SqlSessionFactory> getObjectType() {
   return this.sqlSessionFactory == null ? SqlSessionFactory.class : this.sqlSessionFactory.getClass();
 }

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

maven坐标：

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.2</version>
</dependency>

三、总结

  1. BeanFactory是Spring中IOC容器最核心的接口，遵循了IOC容器中所需的基本接口。例如我们很常见的：ApplicationContext，XmlBeanFactory 等等都使用了BeanFactory这个接口。
  2. FactoryBean是工厂类接口，当你只是想简单的去构造Bean，不希望实现原有大量的方法。它是一个Bean，不过这个Bean能够做为工厂去创建Bean，同时还能修饰对象的生成。
  3. FactoryBean比BeanFactory在生产Bean的时候灵活，还能修饰对象，带有工厂模式和装饰模式的意思在里面，不过它的存在还是以Bean的形式存在。

原文地址：https://www.cnblogs.com/dengpengbo/p/10493782.html

时间： 2024-10-09 22:51:32

Spring之BeanFactory和FactoryBean接口的区别的相关文章

Spring中BeanFactory与FactoryBean的区别

在Spring中有BeanFactory和FactoryBean这2个接口,从名字来看很相似,比较容易搞混. 一.BeanFactory BeanFactory是一个接口,它是Spring中工厂的顶层规范,是SpringIoc容器的核心接口,它定义了getBean().containsBean()等管理Bean的通用方法.Spring的容器都是它的具体实现如: DefaultListableBeanFactory XmlBeanFactory ApplicationContext 这些实现类又从

Spring中的BeanFactory和FactoryBean的区别

一句话介绍 BeanFactory接口用来生产Bean,它处理生产bean的接口体系的最顶层,getBean方法可以获取bean.FactoryBean接口用来定制Bean的生产过程,getObject方法中可以实现自定义过程. 源码 BeanFactory源码 public interface BeanFactory { String FACTORY_BEAN_PREFIX = "&"; Object getBean(String var1) throws BeansExce

BeanFactory与FactoryBean的区别

有很多常用的FactoryBean类: 1.org.springframework.scheduling.quartz.SchedulerFactoryBean 2.org.springframework.scheduling.quartz.CronTriggerFactoryBean 3.org.springframework.scheduling.quartz.SimpleTriggerFactoryBean 4.org.springframework.scheduling.quartz.J

Spring源码分析——BeanFactory体系之接口详细分析

Spring的BeanFactory的继承体系堪称经典.这是众所周知的!作为Java程序员,不能错过! 前面的博文分析了Spring的Resource资源类Resouce.今天开始分析Spring的IOC部分.众所周知,IOC是Spring框架最迷人的地方.它最重要的接口,就是BeanFactory了.BeanFactory有着庞大的继承.实现体系,有众多的子接口.实现类.本博文的目标就是抽丝剥茧,从源代码入手,分析Spring的实现和架构,从中进步. 在阅读的过程中,可以参照Spring文档来

Spring之BeanFactory与ApplicationConText区别

使用BeanFactory从xml配置文件加载bean: import org.springframework.beans.factory.xml.XmlBeanFactory; import org.springframework.core.io.FileSystemResource; public class XmlConfigWithBeanFactory {     public static void main(String[] args) { XmlBeanFactory facto

[spring源码学习]六、IOC源码-BeanFactory和factory-bean

一.代码实例 在我们分析spring的IOC源码的时候,发现除了配置标准的bean,并且通过getBean(beanName)的方法获取到一个bean的实例外,似乎还有这不少其他获取的方法,例如在第四节,我们发现得到bean实例后,在第26节,会判断是否继承了FactoryBean,然后调用它的方法获取真实的bean,在配置文件中我们发现一个factory-bean方法,这些都说明,我们应该可以使用一个beanFactory获取一个bean,此节重点讨论这部分的实现. 代码如下: 1.car类

BeanFactory与FactoryBean

1. BeanFactory BeanFactory定义了 IOC 容器的最基本形式,并提供了 IOC 容器应遵守的的最基本的接口,也就是Spring IOC 所遵守的最底层和最基本的编程规范.在  Spring 代码中, BeanFactory 只是个接口,并不是 IOC容器的具体实现,但是 Spring 容器给出了很多种实现,如 DefaultListableBeanFactory . XmlBeanFactory .ApplicationContext 等,都是附加了某种功能的实现. 以下

BeanFactory VS FactoryBean

1. BeanFactory BeanFactory定义了 IOC 容器的最基本形式,并提供了 IOC 容器应遵守的的最基本的接口,也就是Spring IOC 所遵守的最底层和最基本的编程规范.在  Spring 代码中, BeanFactory 只是个接口,并不是 IOC容器的具体实现,但是 Spring 容器给出了很多种实现,如 DefaultListableBeanFactory . XmlBeanFactory .ApplicationContext 等,都是附加了某种功能的实现. Ja

spring singleton scope与singleton pattern的区别

单态定义:     Singleton模式主要作用是保证在Java应用程序中,一个类Class只有一个实例存在. 在很多操作中,比如建立目录 数据库连接都需要这样的单线程操作. 还有, singleton能够被状态化; 这样,多个单态类在一起就可以作为一个状态仓库一样向外提供服务,比如,你要论坛中的帖子计数器,每次浏览一次需要计数,单态类能否保持住这个计数,并且 能synchronize的安全自动加1,如果你要把这个数字永久保存到数据库,你可以在不修改单态接口的情况下方便的做到. 另外方面,Si