【Spring】bean的实例化

1. 构造方法

实例化bean默认调用无参的构造方法
这种方法只需要在Spring config文件中配置（以bookDao为例）：

<bean id="bookDao" name="dao" class="com.example.demo231116.dao.impl.BookDaoImpl" />
1

2. 静态工厂

工厂类实现：

package com.example.demo231116.factory;

import com.example.demo231116.dao.BookDao;
import com.example.demo231116.dao.impl.BookDaoImpl;

public class BookDaoFactory {
    public static BookDao getBookDao(){
        System.out.println("Factory method....");
        return new BookDaoImpl();
    }
1
2
3
4
5
6
7
8
9
10

想要让bean调用工厂类，如下配置：

<bean id="bookDaoFactory" class="com.example.demo231116.factory.BookDaoFactory" factory-method="getBookDao" />
1

id为从配置中调用的名称，class是调用到的类，我们想要返回的不是这个工厂类，而是这个工厂类中具体的getBookDao方法里返回的对象，那么就要进一步定义factory-method，指定为具体的方法名称。
然后使用bean调用的时候：

public class Demo231116Application2 {
    public static void main(String[] args) {
        // 获取IoC容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 获取bean
        BookDao bookDao2 = (BookDao) ctx.getBean("bookDaoFactory");
        System.out.println(bookDao2);
    }
}
1
2
3
4
5
6
7
8
9

3. 实例工厂

在做这个之前复习一下静态方法的构造方式和非静态方法的构造方式：
建立三个类：
StaticClass.java

package com.example.demo231116;

public class StaticClass {
    public static void staticMethodClass(){
        System.out.println("静态方法构造");
    }
}

1
2
3
4
5
6
7
8

UnStaticClass.java

package com.example.demo231116;

public class UnStaticClass {
    public void unStaticClassMethod(){
        System.out.println("非静态方法");
    }
}

1
2
3
4
5
6
7
8

主方法test.java

package com.example.demo231116;

public class test {

    public static void main(String[] args) {
//        静态方法可以直接调用
        StaticClass.staticMethodClass();

//        非静态方法是不能够直接调用的，需要先创建对象，才能够进行调用
//        UnStaticClass.unStaticMethodClass();
        UnStaticClass mc = new UnStaticClass();
        mc.unStaticClassMethod();

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

这里要注意的是，静态方法能够在不创建类的情况下直接调用，但非静态方法必须要在创建类之后再进行调用，这里bean也是同理，对于实例工厂，其方法不是静态的，我们要先创建工厂，才能够调用工厂下的方法，举例子如下：
工厂类中包含了一个实例方法，非静态

public class BookDaoFactory {
    public static BookDao getBookDao(){
        System.out.println("Factory method....");
        return new BookDaoImpl();
    }
    
    public BookDao getBookDaoUnstatic(){
        System.out.println("实例工厂方法...");
        return new BookDaoImpl();
    }
}
1
2
3
4
5
6
7
8
9
10
11

在Spring config文件中如下写：

<bean id="bookDaoFactory2" class="com.example.demo231116.factory.BookDaoFactory" />
<bean id="bd" factory-method="getBookDaoUnstatic" factory-bean="bookDaoFactory2"  />
1
2

也就是先创建出这个工厂类，指定id和具体的工厂类class
然后再指定其中具体的工厂方法factory-method，指明这个工厂方法所属的父类factory-bean
调用就直接调用这个bd就可以了

BookDao bookDao3 = (BookDao) ctx.getBean("bd");
System.out.println(bookDao3);
1
2

##########################################
实际上，上面的方法有个没有意义的地方在于，config文件中id为bookDaoFactory2的bean没什么意义，只是为了配合id为bd的bean

为了简化这种两步的配置，有一种最实用的方法，也就是4

4. FactoryBean(实用)

直接写一个工厂方法，implement 一下FactoryBean，发现这个FactoryBean是一个泛型方法，指定其中的类型，实现其方法：
其中第一个getObject()返回具体地对象
第二个返回对象的类型

package com.example.demo231116.factory;

import com.example.demo231116.dao.BookDao;
import com.example.demo231116.dao.impl.BookDaoImpl;
import org.springframework.beans.factory.FactoryBean;

public class BookDaoFactoryBean implements FactoryBean<BookDao>{
    @Override
    public BookDao getObject() throws Exception {
        return new BookDaoImpl();
    }

    @Override
    public Class<?> getObjectType() {
        return BookDao.class;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

如此，我们在Spring config中只需要配置一个bean：

<bean id="bookDaoFactoryMethod" class="com.example.demo231116.factory.BookDaoFactoryBean" />
1

在实际过程中直接调用：

BookDao bookDao4 = (BookDao) ctx.getBean("bookDaoFactoryMethod");
System.out.println(bookDao4);
1
2

如果我们写两行使用bookDaoFactoryMethod创建BookDao的方法，再打印两个创建的对象，会发现它们是相同的对象，那么如何创建不同的对象呢？
只需要再补充BookDaoFactoryBean中的这个方法：

@Override
    public boolean isSingleton() {
        return true;
    }
1
2
3
4

当这个方法设置为True时，就是用单例模式创建的对象，如果这个方法返回为False，就不会使用单例模式，每一次构造都会创建出新的对象