Spring创建Bean的四种方式

Spring创建Bean的四种方式

Spring的重要两个核心点是DI/IOC与AOP，我们用到的是其中的DI/IOC

创建Bean可以简单理解为创建对象，java中正常的方式是在类中提供构造方法，需要对象时直接new出来。

这里我们来看看Spring框架是如何创建的

方式一

• 普通方式

先提供一个类

public class MyBean {
}

配置文件SpringTest-Context.xml中

<!--普通的方式-->
<bean id="myBean" class="cn.jjj._08createBean._01bean.MyBean">

测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class SpringTest {
    //注入该类
    @Autowired
    private MyBean myBean;
    @Test
    public void testCreateBean() throws Exception {
        System.out.println(myBean);
    }
}

输出结果：cn.jjj._08createBean._01bean.MyBean@1f1c7bf6

这里我们可以看见，MyBean类中并没有提供构造方法，但是对象正常创建出来了

方式二

• 使用FactoryBean

FactoryBean是用来生产Bean的，它主要是在集成一些框架的时候使用。

例如我们操作JPA必需要拿到它的一个核心对象EntityManagerFactory,但是EntityManagerFactory是没有公共无参的构造器的，所以我们可以用这种方式来创建

现在我们需要它的一个对象

/**
* 这个对象我们不能直接new出来(Spring可以)
* */
public class MyEntityMannagerFactory {
}

有这么一个类可以获取，但是我们不能直接这么用(模拟)

public class MyPersistence {
    /*类直接可以点出来*/
    public static MyEntityMannagerFactory createMyEntityMannagerFactory(){
        return new MyEntityMannagerFactory();
    }
}

我们自己创建个类，实现FactoryBean接口

public class MyEntityManagerFactoryBean implements FactoryBean<MyEntityMannagerFactory> {
    //这个方法返回什么对象，我们拿到的bean就是什么对象
    @Override
    public MyEntityMannagerFactory getObject() throws Exception {
        return MyPersistence.createMyEntityMannagerFactory();
    }
    //返回的对象类型
    @Override
    public Class<?> getObjectType() {
        return MyEntityMannagerFactory.class;
    }
    //这个对象是否是单例的
    @Override
    public boolean isSingleton() {
        return false;
    }
}

配置文件

<!--  spring 在创建entityManagerFactoryBean时会检测看是否实现了factoryBean接口，实现后会再创建一个Bean 也就是getObject()返回的对象 这就是我们需要的对象
     -->
<bean id="entityManagerFactoryBean" class="cn.jjj._08createBean._02factorybean.MyEntityManagerFactoryBean"/>

测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class SpringTest {
    /*
     * FactiryBean:  Spring专门用于做框架继集成的
     * */
    @Autowired
    private MyEntityMannagerFactory factory;
    @Test
    public void test() throws Exception {
        System.out.println(factory);
    }
}

结果：cn.jjj._08createBean._02factorybean.MyEntityMannagerFactory@1d548a08
成功获取到了对象

方式三

• 静态简单工厂

我们有这么一个类

public class Phone {
}

提供了一个工厂

public class PhoneFactory {
    public static Phone creatPhone(){
        return new Phone();
    }
}

配置文件

<!-- 静态工厂 -->
<bean id="myBean" class="cn.jjj._08createBean._03staticfactory.PhoneFactory" factory-method="creatPhone">

可以看见这里通过添加factory-method来调用了creatPhone()方法创建Phone对象

测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class SpringTest {
    //注入接口
    @Autowired
    private Phone phone;
    @Test
    public void test() throws Exception {
        //通过静态工厂方式获得的对象
        System.out.println(phone);
    }
}

结果：cn.jjj._08createBean._03staticfactory.Phone@e50a6f6

正常的获取到了Phone对象

方式四

• 实例简单工厂

提供一个类

public class Phone {
}

提供一个工厂类

public class PhoneFactory {
    public Phone creatPhone(){
        return new Phone();
    }
}

注意这里方法没有static修饰，和方式三中的方法有区别

配置文件：

<!-- 实例工厂方式创建 -->
<bean id="phoneFactory" class="cn.jjj._08createBean._04factory.PhoneFactory"/>
<!-- 
	注意这里是先获取到了上方phoneFactory对象，通过调用对象，使用对象中的 creatPhone方法获取到了我们想要的phone对象
-->
<bean id="phone" factory-bean="phoneFactory" factory-method="creatPhone"/>

测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class SpringTest {
    @Autowired
    private Phone phone;
    @Test
    public void test() throws Exception {
        //通过实例工厂方式获取的对象(非静态)
        System.out.println(phone);
    }
}

结果：cn.jjj._08createBean._04factory.Phone@e50a6f6

正常获取到了对象

如果有帮助到你请点个赞 谢谢