Spring工厂创建复杂对象

一时失言乱红尘 2023-09-29 10:34 8阅读 0赞

####  ####

*  1.复杂对象
 *  2.Spring工厂创建复杂对象的3种方式
 *   *  2.1FactoryBean接口
     *   *  2.1.1步骤
         *  2.1.2细节分析
         *  2.1.3 FactoryBean实现原理
         *  2.1.4FactoryBean总结
     *  2.2实例工厂
     *  2.3静态工厂
     *  2.4总结
 *  3.控制工程创建对象的次数
 *   *  3.1控制简单对象的创建次数
     *  3.2控制复杂对象的创建次数
     *  3.3控制对象创建次数的原因

## 1.复杂对象 ##

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmF2YeeahOWtpuS5oOS5i-i3rw_size_20_color_FFFFFF_t_70_g_se_x_16]

*  复杂对象：指的是不能直接通过new构造方法创建的对象
 *  比如Connection,SqlSessionFactory

## 2.Spring工厂创建复杂对象的3种方式 ##

### 2.1FactoryBean接口 ###

public class MyFactoryBean implements FactoryBean {
        
        @Override
        public Object getObject() throws Exception {
        
        把创建复杂对象的代码写在这里，并且把复杂对象作为方法的返回值返回
            return null;
        }
    
        @Override
        public Class<?> getObjectType() {
        
        返回所创建的复杂对象的Class对象
            return null;
        }
    
        @Override
        public boolean isSingleton() {
        
        如果我们只创建一个这种类型的对象，就返回true
        如果每一个都要创建新的对象，就返回false
            return true;
        }
    }

接下来，我们看看要怎么通过代码来把它实现出来

#### 2.1.1步骤 ####

*  实现FactoryBean接口

public class ConnectFactoryBean implements FactoryBean<Connection> {
        
    
    
        @Override
        public Connection getObject() throws Exception {
        
            Class.forName("com.mysql.cj.jdbc.Driver");
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode?serverTimezone=Asia/Shanghai", "root", "123456");
            return conn;
        }
    
        @Override
        public Class<?> getObjectType() {
        
            return Connection.class;
        }
    
        @Override
        public boolean isSingleton() {
        
            return true;
        }
    }

*  配置文件的配置

接下来我们讨论一下其中的一下细节  
我们先来回顾一下，之前创建简单对象的时候的情形

@Test
        public void test2() {
        
            ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
            //第一个参数是配置文件的id 第二个参数写的是我们想要创建的对象类型  这样就不用强转了
            Person person = ctx.getBean("person", Person.class);
            System.out.println(person);
    
        }

这个时候，ctx.getBean(“person”)方法获得的是Person对象  
但是如果我们创建的是复杂对象的话，那么这里就出现不一样的地方了

ctx.getBean("conn");

这个时候ctx.getBean(“conn”);获得的不是ConnectionFactoryBean这个类的对象  
FactoryBean接口的实现类:ConnectionFactoryBean  
ctx.getBean(“conn”)获得的是它所创建的复杂对象

如果Class中指定的类型是FactoryBean接口的实现类，那么通过id值获得的是这个类所创建的复杂对象
    <bean id="connection" class="com.zyh.factorybean.ConnectFactoryBean"></bean>

接下来进行测试看看结果

/**
         * 用来测试FactoryBean接口
         */
        @Test
        public void test11(){
        
            ApplicationContext ctx=new ClassPathXmlApplicationContext("/applicationContext.xml");
            Connection conn = (Connection) ctx.getBean("connection");
            System.out.println(conn);
    
        }

com.mysql.cj.jdbc.ConnectionImpl@1722011b

我们可以看出来打印出来的结果确实是Connection类型而不是ConnectFactoryBean

#### 2.1.2细节分析 ####

我们看到刚刚的测试结果，可以看到最后返回的类型是Connection类型，而不是实现FactoryBean接口的类，

*  如果我们想要获得FactoryBean类型的对象，就得通过ctx.getBean(“&connection”);这样获得的就是CounnectionFactoryBean

/**
         * 用来测试FactoryBean接口
         */
        @Test
        public void test11() {
        
            ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
            ConnectFactoryBean conn = (ConnectFactoryBean) ctx.getBean("&connection");
            System.out.println(conn);
    
        }

测试结果

com.zyh.factorybean.ConnectFactoryBean@762ef0ea

*  isSingleton方法
    
     *  返回true，则只会创建一个复杂对象
     *  返回false，则每一次都会创建新对象
     *  我们要根据这个对象的特定来决定方法返回的是true(SqlSessionFactory)或false(Connection)
     *  对于连接对象，它不可以共用每次都应该创建新对象
 *  依赖注入问题
    
     *  我们之前分析过，如果存在依赖问题，我们就可以把被依赖的设置成为成员变量，然后通过注入来赋值，我们刚刚写的程序里面，要和数据库进行连接，用户名，密码等都是重要信息，没有它们，我们就无法连接数据库，所以，我们可以把它们设置成为成员变量

package com.zyh.factorybean;
    
    import org.springframework.beans.factory.FactoryBean;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    
    /**
     * @author zengyihong
     * @create 2022--04--17 0:24
     */
    public class ConnectFactoryBean implements FactoryBean<Connection> {
        
        private String driver;
        private String url;
        private String username;
        private String password;
    
        public String getDriver() {
        
            return driver;
        }
    
        public void setDriver(String driver) {
        
            this.driver = driver;
        }
    
        public String getUrl() {
        
            return url;
        }
    
        public void setUrl(String url) {
        
            this.url = url;
        }
    
        public String getUsername() {
        
            return username;
        }
    
        public void setUsername(String username) {
        
            this.username = username;
        }
    
        public String getPassword() {
        
            return password;
        }
    
        public void setPassword(String password) {
        
            this.password = password;
        }
    
        @Override
        public Connection getObject() throws Exception {
        
            Class.forName(driver);
            Connection conn = DriverManager.getConnection(url,username,password );
            return conn;
        }
    
        @Override
        public Class<?> getObjectType() {
        
            return Connection.class;
        }
    
        @Override
        public boolean isSingleton() {
        
            return true;
        }
    }

然后我们可以通过Spring注入来为它们赋值  
我们因为提供了set方法  
所以我们可以用set注入

#### 2.1.3 FactoryBean实现原理 ####

我们可能有这样的疑惑

*  为什么Spring规定FactoryBean接口实现，并且把实现复杂对象的创建写在getObject()方法里面
 *  为什么通过ctx.getBean(“connection”)方法获得的是复杂对象Connection,而不是获得FactoryBean接口的实现类ConnectionFactoryBean
 *  Spring内部运行过程
    
     *  通过connection获得 ConnectionFactoryBean类的对象，然后通过instanceof 判断出是FactoryBean接口的实现类
     *  SSpring按照规定调用 getObject方法，获得Connection对象
     *  然后返回Connection对象  
        ![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmF2YeeahOWtpuS5oOS5i-i3rw_size_20_color_FFFFFF_t_70_g_se_x_16 1]

#### 2.1.4FactoryBean总结 ####

Spring中用来创建复杂对象的一种方式，也是Spring原生提供的

### 2.2实例工厂 ###

使用实例过程来创建复杂对象主要是为了解决下面的几个问题

*  避免Spring框架的侵入，我们使用FactoryBean的方法来创建复杂对象时，必须实现这个接口，如果Spring框架不再提供了，那我们之前的操作就全部白费了
 *  为了整合遗留系统，我们去一家公司后，项目可能已经搭建好了基本模型，里面可能已经提供了具体方法来获得这个复杂对象，这个时候，就得通过实例工厂的方法来获得这个复杂对象，我们就得去解决配置文件的问题

public class ConnectionFactory {
        
        private Connection conn=null;
        public Connection getConnection(){
        
            try {
        
                Class.forName("com.mysql.cj.jdbc.Driver");
                conn= DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode?serverTimezone=Asia/Shanghai","root","123456");
            } catch (ClassNotFoundException | SQLException e) {
        
                e.printStackTrace();
            }
            return conn;
    
        }
    }

我们要想获得Connection对象的话，应该先把ConnectionFactory对象创建出来，这样调用这个对象的getConnection方法就可以获得Connection对象了

<bean id="connFactory" class="com.zyh.factorybean.ConnectionFactory"></bean>
        
        <bean id="conn" factory-bean="connFactory" factory-method="getConnection"></bean>

/**
         * 测试实例工厂
         */
        @Test
        public void test12(){
        
            ApplicationContext ctx=new ClassPathXmlApplicationContext("/applicationContext.xml");
            Connection conn = (Connection)ctx.getBean("conn");
            System.out.println(conn);
        }

测试结果

com.mysql.cj.jdbc.ConnectionImpl@1722011b

### 2.3静态工厂 ###

public class StaticConnectionFactory {
        
    
        public static Connection getConnection(){
        
            Connection conn=null;
            try {
        
                Class.forName("com.mysql.cj.jdbc.Driver");
                  conn= DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode?serverTimezone=Asia/Shanghai","root","123456");
            } catch (ClassNotFoundException | SQLException e) {
        
                e.printStackTrace();
            }
            return conn;
    
        }
    }

静态工厂和实例工厂的区别就是，当我们用静态工厂来调用方法的时候，不需要再创建对象来调用方法，可以直接用类.静态方法来定调用

@Test
        public void test13(){
        
            ApplicationContext ctx=new ClassPathXmlApplicationContext("/applicationContext.xml");
            Connection conn = (Connection)ctx.getBean("connStatic");
            System.out.println(conn);
        }

测试结果

com.mysql.cj.jdbc.ConnectionImpl@5b3f61ff

### 2.4总结 ###

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmF2YeeahOWtpuS5oOS5i-i3rw_size_20_color_FFFFFF_t_70_g_se_x_16 2]

## 3.控制工程创建对象的次数 ##

### 3.1控制简单对象的创建次数 ###

我们刚刚演示了创建Spring复杂对象，通过isSingleton方法，我们可以控制复杂对象的创建次数，但是，简单对象我们要怎么控制它的创建次数呢  
我们可以使用score属性来控制创建次数

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmF2YeeahOWtpuS5oOS5i-i3rw_size_20_color_FFFFFF_t_70_g_se_x_16 3]

<table> 
 <tbody> 
  <tr> 
   <th>作用域</th> 
   <th>描述</th> 
  </tr> 
  <tr> 
   <td>singleton</td> 
   <td> <p>在spring&nbsp;IoC容器仅存在一个Bean实例，Bean以单例方式存在，默认值</p> </td> 
  </tr> 
  <tr> 
   <td>prototype</td> 
   <td>每次从容器中调用Bean时，都返回一个新的实例，即每次调用getBean()时，相当于执行newXxxBean() <br> </td> 
  </tr> 
  <tr> 
   <td>request</td> 
   <td>每次HTTP请求都会创建一个新的Bean，该作用域仅适用于WebApplicationContext环境</td> 
  </tr> 
  <tr> 
   <td>session</td> 
   <td>同一个HTTP Session共享一个Bean，不同Session使用不同的Bean，仅适用于WebApplicationContext环境</td> 
  </tr> 
  <tr> 
   <td>global-session</td> 
   <td>一般用于Portlet应用环境，该作用域仅适用于WebApplicationContext环境</td> 
  </tr> 
 </tbody> 
</table>

### 3.2控制复杂对象的创建次数 ###

实现FacaoryBean接口，并且实现里面的方法  
其中，isSingleton()方法中，返回true，则只创建一次对象，返回false，则每次都会创建新对象  
如果没有实现isSingleton方法，那么还是通过scope属性来进行对象创建次数的控制

### 3.3控制对象创建次数的原因 ###

优点：节省不必要的内存浪费  
有的对象只需要创建一次，我们就不希望它每次都创建新对象，所以应该进行控制

*  什么样的对象只被创建一次
    
     *  SqlSessionFactory
     *  DAO
     *  Service
 *  什么样的对象每次都要创建新对象
    
     *  Connection
     *  SqlSession
     *  Session
    
    其实就是说，如果这个对象是大家共用的，线程安全的，我们就可以让它只创建一次，如果是线程不安全的，那么每一次都要创建新对象

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmF2YeeahOWtpuS5oOS5i-i3rw_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/22f8667d3f6e4967a35b9be122235949.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBASmF2YeeahOWtpuS5oOS5i-i3rw==,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmF2YeeahOWtpuS5oOS5i-i3rw_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/b2fbf736f6dc48f5b89b595784291a9a.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBASmF2YeeahOWtpuS5oOS5i-i3rw==,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmF2YeeahOWtpuS5oOS5i-i3rw_size_20_color_FFFFFF_t_70_g_se_x_16 2]: https://img-blog.csdnimg.cn/c41b13242e394e73991b0b211b1668ba.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBASmF2YeeahOWtpuS5oOS5i-i3rw==,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmF2YeeahOWtpuS5oOS5i-i3rw_size_20_color_FFFFFF_t_70_g_se_x_16 3]: https://img-blog.csdnimg.cn/3f38e900472e46eb8595ae2f6d25e4fc.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBASmF2YeeahOWtpuS5oOS5i-i3rw==,size_20,color_FFFFFF,t_70,g_se,x_16