以后面试别再说你只会用@Autowired实例化Bean了

简介: 以后面试别再说你只会用@Autowired实例化Bean了

闲谈

Hello,大家好,我是Java小面今天我主管通过腾讯会议远程面试别人,小面是一边旁听一边学习,其中有一位的面试让我最印象深刻,因为他简历写对源码有所理解,所以主管问他知道几种实例化Bean的方式,他说只会用@Autowired。只懂得依赖于IOC的便利,对于底层是怎么实例化Bean是一无所知,听着屏幕对方支支吾吾的回答,真是让旁人看着都着急啊。

一般面试可以回答以下的几种Bean实例化(Instantiation)方式

  • 常规方式
  • 通过构造器(配置元信息:使用XML设置、通过Java注解设置和 调用Java API配置)
  • 通过静态工厂方法(配置元信息:使用XML设置Java API配置
  • 通过Bean工厂方法(配置元信息:使用XML设置
  • 通过FactoryBean (配置元信息:使用XML设置通过Java注解设置Java API配置
  • 特殊方式
  • 通过继承ServiceLoaderFactoryBean
  • 通过调用AutowireCapableBeanFactory的createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck)方法
  • 通过调用BeanDefinitionRegistryregisterBeanDefinition(String beanName, BeanDefinition beanDefinition)方法

接下来详细讲一下这几种实例化方法

一、通过构造器实例化Bean

public static void main(String[] args)
    {
        ClassPathXmlApplicationContext beanFactory = new ClassPathXmlApplicationContext("classpath:/META-INF/bean-definition-create.xml");
        Object user = beanFactory.getBean("user");
        System.out.println(user);
    }
<?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="user" class="org.example.pojo.User" >
        <property name="id" value="1" />
        <property name="name" value="Java面试教程" />
    </bean>
</beans>

通过构造器实例化是最简单的,在xml里配置个bean,设置好属性就可以通过beanFactory.getBean(String)获取出来了。

二、通过静态方法实例化Bean

bean-definition-create.xml

<?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 -->
    <bean id="user-java" class="org.example.pojo.User" factory-method="createUser" />
</beans>

在xml中定义一个Bean,id叫user-java,对应的实体是User,创建的方式是使用静态方法来创建Bean对象,该方法必须是静态的且存在与User实体类中。

User.java

package org.example.pojo;
/**
 * @author Java面试教程
 * @date 2022-11-22 21:16
 */
@Data
public class User {
    private Integer id;
    private String name;
    //静态方法
    public static User createUser(){
        return new User(1,"Java面试教程");
    }
    @Override
    public String toString()
    {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
    public User(Integer id, String name)
    {
        this.id = id;
        this.name = name;
    }
}

在User中创建静态方法createUser,返回类型为User。

然后就可以初始化Bean了。

BeanDefinitionDemo.java

package org.example.bean;
import org.example.pojo.User;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * @author Java面试教程
 * @date 2022-11-22 20:43
 */
public class BeanDefinitionDemo {
    public static void main(String[] args)
    {
        // 配置 XML 配置文件
        // 启动 Spring 应用上下文
        ClassPathXmlApplicationContext beanFactory = new ClassPathXmlApplicationContext("classpath:/META-INF/bean-definition-create.xml");
  //获取bean
        User bean = beanFactory.getBean("user-java", User.class);
        //打印
        System.out.println(bean.toString());
    }
}

三、通过实例工厂方法实例化Bean

bean-definition-create.xml

<?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 -->
    <bean id="user-java" class="org.example.pojo.User" factory-method="createUser" />
    <!-- 实例方法实例化 Bean -->
    <bean id="user-by-instance" factory-bean="userFactory" factory-method="createUser" />
    <bean id="userFactory" class="org.example.factory.DefaultUserFactory" />
</beans>

在原先的基础中新增实例方法实例化。

BeanDefinitionDemo.java

package org.example.definition;
import org.example.pojo.User;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * @author Java面试教程
 * @date 2022-11-22 20:43
 */
public class BeanDefinitionDemo {
    public static void main(String[] args)
    {
        // 配置 XML 配置文件
        // 启动 Spring 应用上下文
        ClassPathXmlApplicationContext beanFactory = new ClassPathXmlApplicationContext("classpath:/META-INF/bean-definition-create.xml");
        //获取bean
        User bean = beanFactory.getBean("user-java", User.class);
        User userByInstance = beanFactory.getBean("user-by-instance", User.class);
        //打印
        System.out.println(bean.toString());
        System.out.println(userByInstance.toString());
        //是否相等
        System.out.println(bean==userByInstance);
    }
}

由于在xml中,这是两个不同的id,所以它们并不相等,是不同的两个bean。

静态方法和实例方法其实没有什么太大的区别,通常很少有人会这么去实现。

四、通过FactoryBean实例化Bean

创建一个class,实现FactoryBean类

public interface FactoryBean<T> {
     String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";
     @Nullable
     T getObject() throws Exception;
     @Nullable
     Class<?> getObjectType();
     default boolean isSingleton() {
        return true;
     }
}

由于Spring5之后是用Java8,所以这个时候的FactoryBean里的isSingleton方法有了default来修饰,默认是单例的,所以我们只需要重新实现getObject和getObjectType方法即可。

package org.example.factory;
import org.springframework.beans.factory.FactoryBean;
/**
 * @author Java面试教程
 * @date 2022-11-22 21:54
 */
public class UserFactoryBean implements FactoryBean {
    @Override
    public Object getObject() throws Exception
    {
        return User.createUser();
    }
    @Override
    public Class<?> getObjectType()
    {
        return User.class;
    }
}

意味着我的实例方法、静态方法以及FactoryBean的实现都是用createUser这个静态方法来实现。

bean-definition-create.xml

<bean id="user-by-factory-bean"  class="org.example.factory.UserFactoryBean" />

这个时候xml只需要加这么一句即可,不是直接定义User对象,而是直接会定一个FactoryBean。

之后只需要通过id来获取这个bean就可以了

//获取bean
User beanFactoryBean = beanFactory.getBean("user-by-factory-bean", User.class);
//打印
System.out.println(beanFactoryBean.toString());

五、通过ServiceLoaderFactoryBean实现Bean

点开ServiceLoaderFactoryBean源码,我们会发现这么一个类ServiceLoader,ServiceLoader是java1.6之后就有的。

public class ServiceLoaderFactoryBean extends AbstractServiceLoaderBasedFactoryBean implements BeanClassLoaderAware {
   @Override
   protected Object getObjectToExpose(ServiceLoader<?> serviceLoader) {
      return serviceLoader;
   }
   @Override
   public Class<?> getObjectType() {
      return ServiceLoader.class;
   }
}

我们再点开ServiceLoader源码,第一眼看到的就是META-INF/services/一个路径

public final class ServiceLoader<S>
    implements Iterable<S>
{
    private static final String PREFIX = "META-INF/services/";
    ......
}

它这个是用来配置实现类的。

首先我们需要再META-INF下创建services文件夹,复制UserFactory的全路径,创建一个名为UserFactory的全路径,没有文件后缀的文件。将作为UserFactory的实现类DefalutUserFactory的全路径放到里面去。

然后我们再回过去看ServiceLoaderFactoryBean,既然是实例化就避不开create或者Instance方法,仔细找了一下,方法在继承的AbstractServiceLoaderBasedFactoryBean中,名为createInstance

public abstract class AbstractServiceLoaderBasedFactoryBean extends AbstractFactoryBean<Object>
      implements BeanClassLoaderAware {
   @Nullable
   private Class<?> serviceType;
   @Nullable
   private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();
   /**
    * Specify the desired service type (typically the service's public API).
    */
   public void setServiceType(@Nullable Class<?> serviceType) {
      this.serviceType = serviceType;
   }
   /**
    * Return the desired service type.
    */
   @Nullable
   public Class<?> getServiceType() {
      return this.serviceType;
   }
   @Override
   public void setBeanClassLoader(@Nullable ClassLoader beanClassLoader) {
      this.beanClassLoader = beanClassLoader;
   }
   /**
    * Delegates to {@link #getObjectToExpose(java.util.ServiceLoader)}.
    * @return the object to expose
    */
   @Override
   protected Object createInstance() {
      Assert.notNull(getServiceType(), "Property 'serviceType' is required");
      return getObjectToExpose(ServiceLoader.load(getServiceType(), this.beanClassLoader));
   }
   /**
    * Determine the actual object to expose for the given ServiceLoader.
    * <p>Left to concrete subclasses.
    * @param serviceLoader the ServiceLoader for the configured service class
    * @return the object to expose
    */
   protected abstract Object getObjectToExpose(ServiceLoader<?> serviceLoader);
}

getObjectToExpose(ServiceLoader.load(getServiceType(), this.beanClassLoader))中不难发现,实例化的对象来自于getServiceType,那么serviceType的值从哪里来的呢?

答案是:从xml配置里来

<bean id="userFactoryServiceLoader" class="org.springframework.beans.factory.serviceloader.ServiceLoaderFactoryBean" >
    <property name="serviceType" value="org.example.factory.UserFactory"  />
</bean>

ServiceLoaderFactoryBean使用的是ServiceLoader,ServiceLoader默认读取的是/META-INF/services/下的文件,而value="org.example.factory.UserFactory"刚好就是文件名,从而serviceType获取到的是文件内存储的UserFactory的所有实现类全路径,通过ServiceLoader.load(getServiceType(), this.beanClassLoader)方法加载得到了bean对象。

public static void main(String[] args)
    {
        // 配置 XML 配置文件
        // 启动 Spring 应用上下文
        ClassPathXmlApplicationContext beanFactory = new ClassPathXmlApplicationContext("classpath:/META-INF/bean-service-loader-create.xml");
      //获取ServiceLoader对象
        ServiceLoader serviceLoader = beanFactory.getBean("userFactoryServiceLoader", ServiceLoader.class);
        Iterator<UserFactory> iterator = serviceLoader.iterator();
        while (iterator.hasNext()) {
            //遍历对象
            UserFactory userFactory = iterator.next();
            System.out.println(userFactory.createUser().toString());
        }
    }

六、通过AutowireCapableBeanFactory实例化Bean

public static void main(String[] args)
    {
        // 配置 XML 配置文件
        // 启动 Spring 应用上下文
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:/META-INF/bean-service-loader-create.xml");
        //通过 AutowireCapableBeanFactory 创建 AutowireCapableBeanFactory 对象
        AutowireCapableBeanFactory beanFactory = applicationContext.getAutowireCapableBeanFactory();
        // 创建 UserFactory 对象,通过 AutowireCapableBeanFactory 进行依赖注入
        UserFactory bean = beanFactory.createBean(DefaultUserFactory.class);
        System.out.println(bean.createUser());
    }

这里要注意的是:

UserFactory bean = beanFactory.createBean(DefaultUserFactory.class);

需要直接创建的是实例对象DefaultUserFactory.class,而不是UserFactory.class接口对象,否则会报BeanInstantiationException异常

七、通过BeanDefinitionRegistry实例化Bean

DefaultListableBeanFactory是BeanDefinitionRegistry的一个实现类,这里我们使用DefaultListableBeanFactory这个实现类来实例化Bean。

public static void main(String[] args)
{
    //创建一个BeanFactory容器
    DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
    //设置Bean中的参数
    MutablePropertyValues values=new MutablePropertyValues();
    values.add("id",1);
    values.add("name","my name is Java面试教程 ");
    //BeanDefinition定义了 定义bean所需要的基本属性
    BeanDefinition definition=new RootBeanDefinition(User.class,null,values);
 //把参数设置进去
    factory.registerBeanDefinition("user",definition);
    User user=(User)factory.getBean("user");
    System.out.print(user.toString());
}

结束语

几种Bean的实例化分享就到此结束了,虽然SpringBoot的便利已经让开发不再需要自己去实例化Bean了,但是身为程序员,若想在这条路上越走越远,那么底层的实现方法就有去了解的必要,否则一旦脱离了框架,自身的价值便一文不值了。

相关文章
|
5月前
|
Java 程序员 Spring
Spring中bean类的生命周期|面试必问如何回答
Spring中bean类的生命周期|面试必问如何回答
|
6月前
|
Java Spring
面试了才知道初始化Bean不仅只有new那么简单
面试了才知道初始化Bean不仅只有new那么简单
39 0
|
10月前
|
消息中间件 JavaScript 小程序
阿里云面试:Spring 中 Bean 的生命周期是怎样的?
阿里云面试:Spring 中 Bean 的生命周期是怎样的?
|
XML Java 数据库连接
看了这一篇Spring容器Bean的生命周期,面试再也不用怕了
上一篇我们介绍了Spring IOC容器的启动过程以及bean的实例化过程,这一篇我们接着来学习另外一个知识点,就是Bean的生命周期,我们知道直接通过(new XX())来创建的实例,当这个实例没有被引用时就会被垃圾回收机制回收,但是通过IOC容器实例化的Bean的生命周期又是如何呢?
212 0
看了这一篇Spring容器Bean的生命周期,面试再也不用怕了
|
XML Java API
Java 面试必备的 Spring Bean 生命周期总结
前言 Spring 作为 IOC 容器,管理的对象称之为 bean,Java 对象在 ClassLoader 中有自己的创建和清理过程,那么 Spring Bean 在容器中也有自己的生命周期。
278 0
Java 面试必备的 Spring Bean 生命周期总结
|
Java Spring
面试常见问题-Bean的生命周期?
面试常见问题-Bean的生命周期?
64 0
|
XML Java 数据格式
面试常见问题-Spring Bean是如何创建的?
面试常见问题-Spring Bean是如何创建的?
102 0
|
Java Spring 容器
面试突击80:说一下 Spring 中 Bean 的生命周期?
面试突击80:说一下 Spring 中 Bean 的生命周期?
1787 0
|
前端开发 Java 关系型数据库
面试突击79:Bean 作用域是啥?它有几种类型?
面试突击79:Bean 作用域是啥?它有几种类型?
181 0
|
XML 设计模式 缓存
面试官:说说 Spring Bean 的实例化过程?面试必问的
面试官:说说 Spring Bean 的实例化过程?面试必问的
135 0
面试官:说说 Spring Bean 的实例化过程?面试必问的

相关产品

  • 云迁移中心