spring中bean实例化的三种方式 -- Spring入门（二）

╰+哭是因爲堅強的太久メ 2023-10-13 20:47 74阅读 0赞

### 文章目录 ###

*  前言
 *   *  1.Bean实例化简介
     *  2.bean的实例化 -- 构造方法
     *  3.bean的实例化 -- 静态工厂实例化
     *  4.bean实例化 -- 实例工厂和FactoryBean
     *  5.三种bean实例化方式的区别
 *  总结

--------------------

# 前言 #

为了巩固所学的知识，作者尝试着开始发布一些学习笔记类的博客，方便日后回顾。当然，如果能帮到一些萌新进行新技术的学习那也是极好的。作者菜菜一枚，文章中如果有记录错误，欢迎读者朋友们批评指正。  
（博客的参考源码以及可以在我主页的资源里找到，如果在学习的过程中有什么疑问欢迎大家在评论区向我提出）

## 1.Bean实例化简介 ##

> 1.  面向对象的程序中，想要使用某个对象，就需要先实例化对象。同样，在Spring中，要想使用容器中的Bean，也需要实例化Bean。
> 2.  实例化Bean的方式有三种，分别是构造器实例化、静态工厂实例化和实例工厂实例化（其中最常用的是构造器实例化）。接下来演示一下三种实例化方法

## 2.bean的实例化 – 构造方法 ##

**1. 创建新的maven模块respr\_newbean，并在pom.xml添加spring的坐标**

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

<dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.3.22</version>
                <scope>compile</scope>
            </dependency>

**2. 创建核心配置文件applicationContext.xml文件、dao接口及其实现类以及相关的类（先写标记部分）**

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

**3. 编写dao接口及其实现类**

*  BookDao接口

public interface BookDao {
        
        public void save();
    }

*  BookDaoImpl实现类

public class BookDaoImpl implements BookDao {
        
        //无参构造
        public BookDaoImpl() {
        
            System.out.println("book dao constructor is running ....");
        }
    
        public void save() {
        
            System.out.println("book dao save ...");
        }
    
    }

*  进行测试的类 AppForInstanceBook

public class AppForInstanceBook {
        
        public static void main(String[] args) {
        
    
            ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    
            BookDao bookDao = (BookDao) ctx.getBean("bookDao");
    
            bookDao.save();
    
        }
    }

*  applicationContext.xml

*  AppForInstanceBook运行结果

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

*  结论

> spring构造方法实例化bean使用了无参构造器，可以省略无参构造器的书写。实例化bean就是用构造方法来实例化对象。

## 3.bean的实例化 – 静态工厂实例化 ##

**1. 创建dao接口及其实现类以及相关的类（先写标记部分）**

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

**2. 编写dao接口及其实现类以及相关的类**

*  OrderDao接口

package org.example.dao;
    
    public interface OrderDao {
        
        public void save();
    }

*  OrderDaoImpl实现类

在这里插入代码片package org.example.dao.impl;
    
    import org.example.dao.OrderDao;
    
    public class OrderDaoImpl implements OrderDao {
        
    
        public void save() {
        
            System.out.println("order dao save ...");
        }
    }

*  工厂类OrderDaoFactory（**静态**工厂类代理生成对象）

package org.example.factory;
    
    import org.example.dao.OrderDao;
    import org.example.dao.impl.OrderDaoImpl;
    //静态工厂创建对象
    public class OrderDaoFactory {
        
        public static OrderDao getOrderDao(){
        
            System.out.println("factory setup....");
            return new OrderDaoImpl();
        }
    }

*  AppForInstanceOrder模拟测试类编写（纯JAVA开发，此处还没有Spring）

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

*  模拟测试类的运行结果

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

*  简要分析

> 将 OrderDaoImpl 创建对象的 工作交给 **静态工厂** OrderDaoFactory 类来完成，如果用spring代理这种工厂模式的开发，写法如下

*  spring 代理静态工厂实例化对象

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

*  applicationContext.xml文件配置静态工厂 OrderDaoFactory bean (注意factory-method属性)

*  运行结果

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

## 4.bean实例化 – 实例工厂和FactoryBean ##

**1. 创建dao接口及其实现类以及相关的类（标记部分）**

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

**2. 编写dao接口及其实现类以及相关的类**

*  UserDao接口

public interface UserDao {
        
        public void save();
    }

*  UserDaoImpl实现类

public class UserDaoImpl implements UserDao {
        
    
        public void save() {
        
            System.out.println("user dao save ...");
        }
    }

*  UserDaoFactoryBean**实例**工厂类

//实例工厂创建对象
    public class UserDaoFactory {
        
        public UserDao getUserDao(){
        
            return new UserDaoImpl();
        }
    }

*  AppForInstanceUser模拟测试类（纯JAVA开发）

public class AppForInstanceUser {
        
        public static void main(String[] args) {
        
    //        //创建实例工厂对象
            UserDaoFactory userDaoFactory = new UserDaoFactory();
    //        //通过实例工厂对象创建对象
            UserDao userDao = userDaoFactory.getUserDao();
            userDao.save();
    
        }
    }

**3. 运行结果**

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

**4. 简要分析**

> 此时与静态工厂的区别是模拟测试类中多了创建工厂对象的步骤

*  spring代理下的实例工厂bean实例化模拟测试类

public class AppForInstanceUser {
        
        public static void main(String[] args) {
        
    //        //创建实例工厂对象
    //        UserDaoFactory userDaoFactory = new UserDaoFactory();
    //        //通过实例工厂对象创建对象
    //        UserDao userDao = userDaoFactory.getUserDao();
    //        userDao.save();
    
    
            ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    
            UserDao userDao = (UserDao) ctx.getBean("userDao");
    
            userDao.save();
            
        }
    }

**5. applicationContext.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 id="userFactory" class="org.example.factory.UserDaoFactory"/>
    
            <bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>
    
    </beans>

**6. 模拟测试类运行结果**

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

**7. spring代理实例工厂bean实例化简要分析 --> 改进为BeanFactory bean实例化**

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

**8. 创建并编写BeanFactory工厂类UserDaoFactoryBean**

//FactoryBean创建对象
    //实现接口，创建什么对象写什么泛型
    public class UserDaoFactoryBean implements FactoryBean<UserDao> {
        
        //实现抽象方法
    
        //代替原始实例工厂中创建对象的方法,以后方法名不用指定，就用getObject
        public UserDao getObject() throws Exception {
        
            return new UserDaoImpl();
        }
    
        //配置的类是什么类型
        public Class<?> getObjectType() {
        
            return UserDao.class;
        }
    
    }

**9. 配置applicationContext.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 id="userDao" class="org.example.factory.UserDaoFactoryBean"/>
    
    </beans>

**10. 模拟测试类运行结果**

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

## 5.三种bean实例化方式的区别 ##

**1. 构造器实例化**

> 通过无参构造的方法实例化Bean，其实质是将Bean对应的类交给Spring自带的工厂（BeanFactory）管理，由Spring自带的工厂模式帮我们创建和维护这个类

**2. 静态工厂方式实例化**

> 1.  通过静态工厂创建并返回Bean。其实质是将Bean对应的类交给我们自己的静态工厂管理。Spring只是帮我们调用了静态工厂创建实例的方法。
> 2.  运用：很多时候我们在使用第三方jar包提供给我们的类时，由于这个类没有构造方法，是通过第三方包提供的静态工厂创建的，如果我们想把第三方jar包里面的这个类交由Spring来管理的话，就可以使用Spring提供的静态工厂创建实例的配置。

**3. 实例工厂方式实例化**

> 1.  通过实例工厂创建并返回Bean，其实质就是把创建实例的工厂类和调用工厂类的方法创建实例的方法的过程也交由Spring管理，创建实例的这个过程也是由我们自己配置的实例工厂内部实现的。
> 2.  运用：如Spring整合Hibernate就是通过这种方式实现的。但对于没有与Spring整合过的工厂类，我们一般都是自己用代码来管理的。

**4. 小结**

> 1.  三种方法最常用的就是构造器实例化，
> 2.  静态工厂类与非静态工厂类的区别是，前者不需要创建对象，直接可以调用静态方法创建bean；后者则要先创建对象，然后再通过对象调用其方法创建bean

# 总结 #

[b3a3be5cb0974c148bc03c6ecf2b63f3.png_pic_center]: https://img-blog.csdnimg.cn/b3a3be5cb0974c148bc03c6ecf2b63f3.png#pic_center
[6ddbae9ed7f7487baedef4d4286e3aa9.png_pic_center]: https://img-blog.csdnimg.cn/6ddbae9ed7f7487baedef4d4286e3aa9.png#pic_center
[2031dcb2011843fda713172e7988f309.png_pic_center]: https://img-blog.csdnimg.cn/2031dcb2011843fda713172e7988f309.png#pic_center
[c9438d10dc6e4e408590ff97661bcd05.png_pic_center]: https://img-blog.csdnimg.cn/c9438d10dc6e4e408590ff97661bcd05.png#pic_center
[6f5783bf308a438093fdeed8bf90c8c8.png_pic_center]: https://img-blog.csdnimg.cn/6f5783bf308a438093fdeed8bf90c8c8.png#pic_center
[9f5fb7ac53e94097bbb4f14ee46029d6.png_pic_center]: https://img-blog.csdnimg.cn/9f5fb7ac53e94097bbb4f14ee46029d6.png#pic_center
[5d3fed0355f047b0b48585f056de0c28.png_pic_center]: https://img-blog.csdnimg.cn/5d3fed0355f047b0b48585f056de0c28.png#pic_center
[f2b3f5eeb9bd44a28ec83563fe829f8e.png_pic_center]: https://img-blog.csdnimg.cn/f2b3f5eeb9bd44a28ec83563fe829f8e.png#pic_center
[33f1cbb12eff4618a572cc1188c68efd.png_pic_center]: https://img-blog.csdnimg.cn/33f1cbb12eff4618a572cc1188c68efd.png#pic_center
[696befb7787b4a0caf014e12e82d57d7.png_pic_center]: https://img-blog.csdnimg.cn/696befb7787b4a0caf014e12e82d57d7.png#pic_center
[fdaae9d36d97450ca35c5c8ffb808fe5.png_pic_center]: https://img-blog.csdnimg.cn/fdaae9d36d97450ca35c5c8ffb808fe5.png#pic_center