Spring项目bean实例化

阳光穿透心脏的1/2处 2024-04-03 13:05 46阅读 0赞

对象已经能交给`Spring`的`IOC`容器来创建了，但是容器是如何来创建对象的呢？  
就需要研究下`bean的实例化过程`，在这块内容中主要解决两部分内容，分别是

*  bean是如何创建的
 *  实例化bean的三种方式，`构造方法`,`静态工厂`和`实例工厂`

在介绍这三种创建方式之前，我们需要先确认一件事：  
`bean`本质上就是对象，对象在`new`的时候会使用构造方法完成，那创建`bean`也是使用构造方法完成的。  
基于这点出发，我们来验证`spring`中`bean`的三种创建方式。

## 1. 环境准备 ##

为了方便阅读代码，重新准备个开发环境，

*  创建一个`Maven`项目
 *  `pom.xml`添加依赖
 *  `resources`下添加spring的配置文件`applicationContext.xml`

项目的结构如下：

![在这里插入图片描述][ca133a103f5a49629afbfded7dcf3ebb.png_pic_center]

## 2. 构造方法实例化 ##

在上述的环境下，我们来研究下`Spring`中的第一种`bean`的创建方式`构造方法实例化`：

### 步骤1：准备需要被创建的类 ###

准备一个`UserDao`和`UserDaoImpl`类

public interface UserDao {
        
        public void save();
    }
    public class UserDaoImpl implements UserDao {
        
        public void save() {
        
            System.out.println("User Dao save, running ......");
        }
    }

### 步骤2：将类配置到Spring容器 ###

<?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="userDao" class="com.dcxuexi.dao.impl.UserDaoImpl" />
    
    </beans>

### 步骤3：编写运行程序 ###

public class SpringBeaInstance {
        
        public static void main(String[] args) {
        
            ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            UserDao userDao = (UserDao) context.getBean("userDao");
            userDao.save();
    
        }
    }

### 步骤4：类中提供构造函数测试 ###

在`UserDaoImpl`类中添加一个无参构造函数，并打印一句话，方便观察结果。

public class UserDaoImpl implements UserDao {
        
        public void save() {
        
            System.out.println("User Dao save, running ......");
        }
        //无参构造函数
        public UserDaoImpl(){
        
            System.out.println("User Dao Impl constructor is running ......");
        }
    }

运行程序，如果控制台有打印构造函数中的输出，说明`Spring`容器在创建对象的时候也走的是构造函数  
![在这里插入图片描述][89864f4e73a14e37b1ed6daaeccaf960.png_pic_center]

### 步骤5：将构造函数改成private测试 ###

public class UserDaoImpl implements UserDao {
        
        public void save() {
        
            System.out.println("User Dao save, running ......");
        }
        //无参构造函数
        private UserDaoImpl(){
        
            System.out.println("User Dao Impl constructor is running ......");
        }
    }

运行程序，能执行成功，说明内部走的依然是构造函数，能访问到类中的私有构造方法，显而易见`Spring`底层用的是反射

![在这里插入图片描述][9e239a8935d144448a0c7becb732191c.png_pic_center]

### 步骤6：构造函数中添加一个参数测试 ###

public class UserDaoImpl implements UserDao {
        
        public void save() {
        
            System.out.println("User Dao save, running ......");
        }
        //无参构造函数
        private UserDaoImpl(String name){
        
            System.out.println("User Dao Impl constructor is running ......");
        }
    }

运行程序，  
程序会报错，说明`Spring`底层使用的是类的无参构造方法。  
![在这里插入图片描述][2fb65328ba74457eb9add504fd3112f6.png_pic_center]

## 3. 分析Spring的错误信息 ##

接下来，我们主要研究下`Spring`的报错信息来学一学如阅读。

*  错误信息从下往上依次查看，因为上面的错误大都是对下面错误的一个包装，最核心错误是在最下面
 *  `Caused by: java.lang.NoSuchMethodException: com.dcxuexi.dao.impl.UserDaoImpl.<init>()`
    
     *  `Caused by` 翻译为`引起`，即出现错误的原因
     *  `java.lang.NoSuchMethodException`:抛出的异常为`没有这样的方法异常`
     *  `com.dcxuexi.dao.impl.UserDaoImpl.<init>()`:哪个类的哪个方法没有被找到导致的异常，`<init>`()指定是类的构造方法，即该类的无参构造方法

如果最后一行错误获取不到错误信息，接下来查看第二层：  
`Caused by: org.springframework.beans.BeanInstantiationException: Failed to instantiate [com.dcxuexi.dao.impl.UserDaoImpl]: No default constructor found; nested exception is java.lang.NoSuchMethodException: com.dcxuexi.dao.impl.UserDaoImpl.<init>()`

*  `nested`:嵌套的意思，后面的异常内容和最底层的异常是一致的
 *  `Caused by: org.springframework.beans.BeanInstantiationException: Failed to instantiate [com.dcxuexi.dao.impl.UserDaoImpl]: No default constructor found;`
    
     *  `Caused by`: `引发`
     *  `BeanInstantiationException`:翻译为`bean实例化异常`
     *  `No default constructor found`:没有一个默认的构造函数被发现

看到这其实错误已经比较明显。  
`Exception in thread "main" org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'userDao' defined in class path resource [applicationContext.xml]: Instantiation of bean failed; nested exception is org.springframework.beans.BeanInstantiationException: Failed to instantiate [com.dcxuexi.dao.impl.UserDaoImpl]: No default constructor found; nested exception is java.lang.NoSuchMethodException: com.dcxuexi.dao.impl.UserDaoImpl.<init>()`

至此，关于`Spring`的构造方法实例化就已经学习完了，因为每一个类默认都会提供一个无参构造函数，所以其实真正在使用这种方式的时候，我们什么也不需要做。这也是我们以后比较常用的一种方式。

## 4. 静态工厂实例化 ##

接下来研究`Spring`中的第二种`bean`的创建方式`静态工厂实例化`：

### 4.1 工厂方式创建bean ###

先回顾一个知识点是使用工厂来创建对象的方式：  
(1)准备一个`RegionDao`和`RegionDaoImpl`类

public interface RegionDao {
        
        public void select();
    }
    public class RegionDaoImpl implements RegionDao {
        
        public void select() {
        
            System.out.println("Region Dao running ......");
        }
    }

(2)创建一个工厂类`RegionDaoFactory`并提供一个静态方法

//静态工厂创建对象
    public class RegionDaoFactory {
        
        public static RegionDao getRegionDao(){
        
            return new RegionDaoImpl();
        }
    }

(3)编写`AppForInstanceRegion`运行类，在类中通过工厂获取对象

public class AppForInstanceRegion {
        
        public static void main(String[] args) {
        
            // 通过静态工厂创建对象
            RegionDao regionDao = RegionDaoFactory.getRegionDao();
            regionDao.select();
        }
    }

(4)运行后，可以查看到结果  
![在这里插入图片描述][59ff7d18724842f99050ba01506d1b68.png_pic_center]

如果代码中对象是通过上面的这种方式来创建的，如何将其交给`Spring`来管理呢？

### 4.2 静态工厂实例化 ###

这就要用到`Spring`中的静态工厂实例化的知识了，具体实现步骤为：  
(1)在`spring`的配置文件`application.properties`中添加以下内容：

`class`:工厂类的类全名  
`factory-mehod`:具体工厂类中创建对象的方法名  
对应关系如下图：

![在这里插入图片描述][edb98bdf4f414485bde8dbb622cb4bd8.png_pic_center]

(2)在`AppForInstanceRegion`运行类，使用从`IOC`容器中获取`bean`的方法进行运行测试

public class AppForInstanceRegion {
        
        public static void main(String[] args) {
        
            // 通过静态工厂创建对象
            //RegionDao regionDao = RegionDaoFactory.getRegionDao();
            //regionDao.select();
    
            ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            RegionDao regionDao = (RegionDao) context.getBean("regionDao");
            regionDao.select();
        }
    }

(3)运行后，可以查看到结果  
![在这里插入图片描述][08b7511e3af84aa6a5df768eaee9460c.png_pic_center]

可能有人会问了，你这种方式在工厂类中不也是直接`new`对象的，和我自己直接`new`没什么太大的区别，而且静态工厂的方式反而更复杂，这种方式的意义是什么?  
主要的原因是：

*  在工厂的静态方法中，我们除了`new`对象还可以做其他的一些业务操作，这些操作必不可少，如：

//静态工厂创建对象
    public class RegionDaoFactory {
        
        public static RegionDao getRegionDao(){
        
            System.out.println("factory setup....");//模拟必要的业务操作
            return new RegionDaoImpl();
        }
    }

之前`new`对象的方式就无法添加其他的业务内容，重新运行，查看结果：

![在这里插入图片描述][c1cd3708eadf49efbedbf40fd9170c3f.png_pic_center]

介绍完静态工厂实例化后，这种方式一般是用来兼容早期的一些老系统，所以了解为主。

## 5. 实例工厂与FactoryBean ##

接下来继续来研究`Spring`的第三种`bean`的创建方式`实例工厂实例化`：

### 5.1 环境准备 ###

(1)准备一个`OrderDao`和`OrderDaoImpl`类

public interface OrderDao {
        
        public void save();
    }
    public class OrderDaoImpl implements OrderDao {
        
        public void save() {
        
            System.out.println("Order Dao save, running ......");
        }
    }

(2)创建一个工厂类`OrderDaoFactory`并提供一个普通方法，注意此处和静态工厂的工厂类不一样的地方是方法不是静态方法

public class OrderDaoFactory {
        
        public OrderDao getOrderDao(){
        
            return new OrderDaoImpl();
        }
    }

(3)编写`AppForInstanceOrder`运行类，在类中通过工厂获取对象

public class AppForInstanceOrder {
        
        public static void main(String[] args) {
        
            //创建实例工厂对象
            OrderDaoFactory orderDaoFactory = new OrderDaoFactory();
            //通过实例工厂对象创建对象
            OrderDao orderDao = orderDaoFactory.getOrderDao();
            orderDao.save();
        }
    }

(4)运行后，可以查看到结果

![在这里插入图片描述][2961771374494df9a9bdb2ea06746e8b.png_pic_center]

对于上面这种实例工厂的方式如何交给`Spring`管理呢?

### 5.2 实例工厂实例化 ###

具体实现步骤为：  
(1)在`spring`的配置文件中添加以下内容：

实例化工厂运行的顺序是:

*  创建实例化工厂对象,对应的是第一行配置
 *  调用对象中的方法来创建`bean`，对应的是第二行配置
    
     *  `factory-bean`:工厂的实例对象
     *  `factory-method`:工厂对象中的具体创建对象的方法名,对应关系如下:

![在这里插入图片描述][4a862840c712427aa67076e7893344cc.png_pic_center]

`factory-mehod`:具体工厂类中创建对象的方法名  
(2)在`AppForInstanceOrder`运行类，使用从`IOC`容器中获取`bean`的方法进行运行测试

public class AppForInstanceOrder {
        
        public static void main(String[] args) {
        
            //创建实例工厂对象
            //OrderDaoFactory orderDaoFactory = new OrderDaoFactory();
            //通过实例工厂对象创建对象
            //OrderDao orderDao = orderDaoFactory.getOrderDao();
            //orderDao.save();
    
            ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            OrderDao orderDao = (OrderDao) context.getBean("orderDao");
            orderDao.save();
        }
    }

(3)运行后，可以查看到结果  
![在这里插入图片描述][c26a6e4f68c34239989d31e23028362e.png_pic_center]

实例工厂实例化的方式就已经介绍完了，配置的过程还是比较复杂，所以`Spring`为了简化这种配置方式就提供了一种叫`FactoryBean`的方式来简化开发。

### 5.3 FactoryBean的使用 ###

具体的使用步骤为：  
(1)创建一个`UserDaoFactoryBean`的类，实现`FactoryBean`接口，重写接口的方法

public class UserDaoFactoryBean implements FactoryBean<UserDao> {
        
        //代替原始实例工厂中的创建对象的方法
        public UserDao getObject() throws Exception {
        
            return new UserDaoImpl();
        }
    
        //返回所创建类的class对象
        public Class<?> getObjectType() {
        
            return UserDao.class;
        }
    }

(2)在`Spring`的配置文件中进行配置

(3)`AppForInstanceUser`运行类，直接运行  
![在这里插入图片描述][feeb0e763b4a4ac6b6c15e8e59dd0fd5.png_pic_center]

这种方式在`Spring`去整合其他框架的时候会被用到，所以这种方式需要大家理解掌握。  
查看源码会发现，`FactoryBean`接口其实会有三个方法，分别是：

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

**方法一**：`getObject()`，被重写后，在方法中进行对象的创建并返回  
**方法二**：`getObjectType()`,被重写后，主要返回的是被创建类的Class对象  
**方法三**：没有被重写，因为它已经给了默认值，从方法名中可以看出其作用是设置对象是否为单例，默认`true`，从意思上来看，我们猜想默认应该是单例，如何来验证呢?

思路很简单，就是从容器中获取该对象的多个值，打印到控制台，查看是否为同一个对象。

public class AppForInstanceUser {
        
        public static void main(String[] args) {
        
            ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            UserDao userDao = (UserDao) context.getBean("userDao");
            UserDao userDao2 = (UserDao) context.getBean("userDao");
            userDao.save();
            userDao2.save();
            System.out.println(userDao);
            System.out.println(userDao2);
    
        }
    }

打印结果，如下：

![在这里插入图片描述][0f8db3a3a166468bae7befa40b4a2a14.png_pic_center]

从结果中可以看出现在已经是非单例了，但是一般情况下我们都会采用单例，也就是采用默认即可。所以`isSingleton()`方法一般不需要进行重写。

## 6. bean实例化小结 ##

(1)`bean`是如何创建的呢?

构造方法

(2)`Spring`的`IOC`实例化对象的三种方式分别是:

*  构造方法(常用)
 *  静态工厂(了解)
 *  实例工厂(了解)
    
     *  FactoryBean(实用)

这些方式中，重点掌握`构造方法`和`FactoryBean`即可。  
需要注意的一点是，构造方法在类中默认会提供，但是如果重写了构造方法，默认的就会消失，在使用的过程中需要注意，如果需要重写构造方法，最好把默认的构造方法也重写下。

## 项目代码 ##

*  [gitee 项目代码下载][gitee]
 *  [github 项目代码下载][github]

[ca133a103f5a49629afbfded7dcf3ebb.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/4be96a2b891a4b7eb68ccaf749e4d557.png
[89864f4e73a14e37b1ed6daaeccaf960.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/f1571e188fdd41a68e067ba7f522869d.png
[9e239a8935d144448a0c7becb732191c.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/5fe59bf7bf224d4487df6365ae53fe1c.png
[2fb65328ba74457eb9add504fd3112f6.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/7d894663fb05469293a423b0a94de7a4.png
[59ff7d18724842f99050ba01506d1b68.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/7a5f8598afcc4a5f8523edf99c7bea8a.png
[edb98bdf4f414485bde8dbb622cb4bd8.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/ebd322cda0074378a88dfec7d1102659.png
[08b7511e3af84aa6a5df768eaee9460c.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/bacb2ce9334f46c1a4a3f125a5341ec2.png
[c1cd3708eadf49efbedbf40fd9170c3f.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/fead76636d8a426382fab8fd4b088efd.png
[2961771374494df9a9bdb2ea06746e8b.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/b979e8ac544d427e86988ebd7c73ba1a.png
[4a862840c712427aa67076e7893344cc.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/90f6836651ea417c8e43e1574cb04b54.png
[c26a6e4f68c34239989d31e23028362e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/3cb488660c2e443aa6a7f58422bdddef.png
[feeb0e763b4a4ac6b6c15e8e59dd0fd5.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/4d85cb7d98d5427c8a7988f5f2f9b62c.png
[0f8db3a3a166468bae7befa40b4a2a14.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/7db98c89d96b4f888f7397d8caddbfbd.png
[gitee]: https://gitee.com/DchuangDB/sping-projeck
[github]: https://github.com/dcbut/spring