Spring IOC工厂

Spring—前导与 IOC工厂

笔记整理自 b站孙哥说Spring5

1. 引言

Ⅰ. EJB存在的问题

EJB（Enterprise Java Bean），叫做企业级的 Java Bean。

两个问题：

运行环境苛刻
代码移植性差

总结：EJB是一个重量级的框架。

Ⅱ. 什么是Spring

Spring是一个轻量级的JavaEE解决方案，整合众多优秀的设计模式。

轻量级

➢ 对于运行环境没有额外要求

◽ 开源 => Tomcat Resion Jetty

◽️ 收费 => Weblogic Websphere

➢ 代码移植性高

◽️ 不需要实现额外接口
JaveEE的解决方案

Spring是一个在Java分层开发中的解决方案，它可以解决每一层次的问题，Spring是一个提供了更完善开发环境的一个框架。
```
SpringMVC，解决Controller层控制器问题。
Spring AOP编程，解决Service层事务控制、日志处理问题。
Spring整合Mybatis，解决Dao层数据问题。
1
2
3
```
整合设计模式

➢ 工厂

➢ 代理

➢ 模板

➢ 策略

➢ …

Spring的初衷

JAVA EE开发应该更加简单。
使用接口而不是使用类，是更好的编程习惯。Spring将使用接口的复杂度几乎降低到了零。
为 JavaBean 提供了一个更好的应用配置框架。
更多地强调面向对象的设计，而不是现行的技术如 JAVA EE。
尽量减少不必要的异常捕捉。
使应用程序更加容易测试。

Spring的目标

可以令人方便愉快的使用Spring。
应用程序代码并不依赖于Spring APIs。
Spring不和现有的解决方案竞争，而是致力于将它们融合在一起。

Spring的基本组成

最完善的轻量级核心框架。
通用的事务管理抽象层。
JDBC抽象层。
集成了Toplink，Hibernate，JDO，and iBATIS SQL Maps。
AOP功能。
灵活的 MVC Web 应用框架。

Ⅲ. 设计模式

广义概念

➢ 面向对象设计中，解决特定问题的经典代码。
狭义概念

➢ GOF4人帮定义的23种设计模式：工厂、适配器、装饰器、门面、代理、模板…

Spring框架可以说是对设计模式的高度集成，极大程度上发挥了设计模式所带来的的优势；

Spring封装的设计模式中最重要的就是：工厂设计模式（Spring IOC的核心）。

Ⅳ. 工厂设计模式

1️⃣ 什么是工厂设计模式

概念：通过工厂类，创建对象

// 普通创建对象
User user = new User();
UserDAO userDAO = new UserDAOImpl();
1
2
3

好处：解耦合

耦合：指的是代码间的强关联关系，一方的改变会影响到另一方

问题：不利于代码维护

简单理解：把接口的实现类，硬编码在程序中

// 有耦合 硬编码
UserService userService = new UserServiceImpl();
// 解耦合 将耦合放到工厂类中 解决了调用者的耦合 后续用工厂的设计来解决
UserService userService = BeanFactory.getUserService();
1
2
3
4

2️⃣ 简单工厂的设计

反射 + 配置文件

工厂类 BeanFactory

package com.baizhiedu.basic;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class BeanFactory {
    private static Properties env = new Properties();

    static{
        try {
            // 第一步 获得IO输入流
            InputStream inputStream = BeanFactory.class.getResourceAsStream("/applicationContext.properties");
            // 第二步 文件内容 封装 Properties集合中 key = userService value = com.baizhixx.UserServiceImpl
            env.load(inputStream);

            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /*
        对象的创建方式：
           1. 直接调用构造方法 创建对象  UserService userService = new UserServiceImpl();
           2. 通过反射的形式 创建对象 解耦合
               Class clazz = Class.forName("com.baizhiedu.basic.UserServiceImpl");
               UserService userService = (UserService)clazz.newInstance();
     */
    public static UserService getUserService() {
        UserService userService = null;
        try {
                                         // com.baizhiedu.basic.UserServiceImpl
            Class clazz = Class.forName(env.getProperty("userService"));
            userService = (UserService) clazz.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return userService;
    }

	// 解决调用DAO类的耦合
    public static UserDAO getUserDAO(){
        UserDAO userDAO = null;
        try {
            Class clazz = Class.forName(env.getProperty("userDAO"));
            userDAO = (UserDAO) clazz.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return userDAO;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

配置文件 applicationContext.properties

# Properties 集合 存储 Properties文件的内容
# 特殊Map key=String value=String
# Properties [userService = com.baizhiedu.xxx.UserServiceImpl]
# Properties.getProperty("userService")

userService = com.baizhiedu.basic.UserServiceImpl
userDAO = com.baizhiedu.basic.UserDAOImpl
1
2
3
4
5
6
7

3️⃣ 通用工厂的设计

问题

简单工厂会存在大量的代码冗余

通用工厂的代码

// 提供一个工厂方法，可以帮我们生产一切想要的对象
public class BeanFactory{
  
    public static Object getBean(String key) {
         Object ret = null;
         try {
             Class clazz = Class.forName(env.getProperty(key));
             ret = clazz.newInstance();
         } catch (Exception e) {
            e.printStackTrace();
         }
         return ret;
     }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

4️⃣ 通用工厂的使用方式

定义类型（类）
通过配置文件的配置告知工厂(applicationContext.properties)

➢ key = value
通过工厂获得类的对象

➢ Object ret = BeanFactory.getBean("key");

Ⅴ. 总结

Spring本质：工厂 ApplicationContext (applicationContext.xml)

Spring IOC的核心的思想就是配置文件+反射工厂的模式。

2. 第一个Spring程序

Ⅰ. 环境搭建

Spring的jar包

<!-- 设置pom 依赖 -->
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.1.4.RELEASE</version>
</dependency>
1
2
3
4
5
6
7

Spring的配置文件

➢ 配置文件的放置位置：任意位置没有硬性要求

➢ 配置文件的命名：没有硬性要求建议：applicationContext.xml

➢ 思考：日后应用Spring框架时，需要进行配置文件路径的设置。

命名为applicationContext.xml

Ⅱ. Spring的核心API

ApplicationContext

➢ 作用：Spring提供的ApplicationContext这个工厂，用于对象的创建

➢ 好处：解耦合

➢ ApplicationContext接口类型

◽ 接口：屏蔽实现的差异

◽ 非web环境：ClassPathXmlApplicationContext（main junit）

◽ web环境：XmlWebApplicationContext（在spring-webmvc的依赖中）

➢ 重量级资源

◽ ApplicationContext工厂的对象占用大量内存

◽ 不会频繁的创建对象，一个应用只会创建一个工厂对象

◽ ApplicationContext工厂一定是线程安全的（多线程并发访问）

Ⅲ. 程序开发

总共3步

创建类型

配置文件的配置 applicationContext.xml

<!--
    id属性：名字（唯一）
    class属性：配置类的全限定名
-->
<bean id="person" class="com.lyc.pojo.Person"/>
1
2
3
4
5

通过工厂类，获得对象 ApplicationContext => ClassPathXmlApplicationContext

// 1.获得Spring的工厂
ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
// 2.通过工厂类 获得 对象
Person person = (Person) ctx.getBean("person");

System.out.println("person = " + person);
1
2
3
4
5
6

Ⅳ. 细节分析

名词解释

➢ Spring工厂创建的对象，叫做bean或者组件（componet）

Spring工厂的相关的方法

// 通过这种方式获得对象，就不需要强制类型转换
Person person = ctx.getBean("person", Person.class);

// 当前Spring的配置文件中 只能有一个<bean class>是Person类型
Person person = ctx.getBean(Person.class);
        
// 获取的是 Spring工厂配置文件中所有bean标签的id值 person person1
String[] beanDefinitionNames = ctx.getBeanDefinitionNames();
        
// 根据类型获得Spring配置文件中对应的id值
String[] beanNamesForType = ctx.getBeanNamesForType(Person.class);
        
// 用于判断是否存在指定id值的bean（不能判断name属性）
boolean a = applicationContext.containsBeanDefinition("a");
      
// 用于判断是否存在指定id值的bean（可以判断name属性）这个和上面的方法的区别会在后续讲解
boolean person = applicationContext.containsBean("person");

// 获取配置文件中配置的bean标签的个数
int count = applicationContext.getBeanDefinitionCount();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

配置文件中需要注意的细节

➢ 只配置class属性

<bean class="com.lyc.pojo.Person"/>
1

没配置id属性，Spring能否基于这个类创建对象呢？

答案是：可以

a) 上述这种配置，有没有id值（Spring会给我们提供吗）？

◽️ 有，Spring会为我们默认生成，例如：com.lyc.pojo.Person#0（如果有多个则"#"后面的数字依次递增）

b) 应用场景

◽️ 如果这个bean只需要使用一次，那么就可以省略id值。

◽️ 如果这个bean会使用多次，或者被其他bean引用则需要设置id值。

➢ name属性

◽️ 作用：用于在Spring的配置文件中，为bean对象定义别名（小名）

<bean id="person" name="p" class="com.lyc.pojo.Person"/>
1

name与id的相同与不同

◽️ 相同：通过getBean()方法获取对象用id或者name是等效的 ctx.getBean("id|name")-->object

◽️ 区别

1.别名可以定义多个，以逗号分隔，但是id属性只能有1个值。
  <bean id="person" name="p,p1" class="com.lyc.pojo.Person"/>
2.XML的id属性的值，命名要求：必须以字母开头→字母|数字|下划线连字符；不能以特殊字符开头：/person（以前的规定）
       name属性的值，命名没有要求，会应用在特殊命名的场景下：/person
  XML发展到了今天：id属性的限制已经不存在了：/person
3.代码
// 用于判断是否存在指定id值的bean，不能判断name属性
boolean p = applicationContext.containsBeanDefinition("p");
System.out.println(p); // false

// 用于判断是否存在指定id值的bean，可以判断name属性
boolean p = applicationContext.containsBean("p");
System.out.println(p); // true
1
2
3
4
5
6
7
8
9
10
11
12
13

Ⅴ. Spring工厂的底层实现原理 (简易版)

Spring工厂是可以调用对象私有的构造方法创建对象。

因为使用反射，所以默认会调用类的无参构造器，注意即使你是私有的照样可以获取（反射的强大之处）且对象是在工厂初始化完成时就帮我们创建的，默认就是非懒加载，我们可以使用标签的属性设置为懒加载，即我们需要对象时工厂才帮我们创建。

Ⅵ. 思考

问题：未来在开发过程中，是不是所有的对象，都会交给Spring工厂来创建呢？
回答：理论上是的，但是有特例：

实体对象（entity）不会交给Spring创建，因为我要的不仅仅是这个对象本身，还需要实体对象数据库对应的数据，它是由持久层框架进行创建（持久层框架创建对象的过程也是通过反射来实现的），比如Mybatis。

3. Spring5.x与日志框架的整合

Spring与日志框架进行整合，日志框架就可以在控制台中，输出Spring框架运行过程中的一些重要的信息。

好处：便于了解Spring框架的运行过程，利于程序的调试。

Spring如何整合日志框架

默认
  Spring1.2.3早期都是于commons-logging.jar
  Spring5.x默认整合的日志框架 logback log4j2
Spring5.x整合log4j 
  1.引入log4j jar包
  2.引入log4.properties配置文件
1
2
3
4
5
6

➢ pom

<!-- 日志门面 为了覆盖Spring默认的日志框架 使Spring5可以支持log4j -->
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-log4j12</artifactId>
  <version>1.7.25</version>
</dependency>

<dependency>
  <groupId>log4j</groupId>
  <artifactId>log4j</artifactId>
  <version>1.2.17</version>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12

➢ log4j.properties

# resources文件夹根目录下
# 配置根
log4j.rootLogger = debug,console

# 日志输出到控制台显示
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.Target=System.out
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n
1
2
3
4
5
6
7
8
9

在IDEA下了一个插件GrepConsole，控制台输出的日志颜色跟孙哥的一样了

debug是灰色字体、info是白色字体、warn会加蓝色背景、error则是红色背景，这样就很清晰了，能快速找到自己关注的日志信息

4. 注入（Injection）

Ⅰ. 什么是注入

通过Spring工厂及配置文件，为所创建对象的成员变量赋值。

1️⃣ 为什么需要注入

通过编码的方式，为成员变量进行赋值，存在耦合。

2️⃣ 如何进行注入[开发步骤]

类的成员变量提供 set get 方法

配置spring的配置文件

<bean id="person" class="com.lyc.pojo.Person">
    <property name="id">
        <value>10</value>
    </property>
    <property name="name">
        <value>haha</value>
    </property>
</bean>
1
2
3
4
5
6
7
8

赋值成功

3️⃣ 注入的好处

解耦合

Ⅱ. Spring注入的原理分析 (简易版)

Spring通过底层调用对象属性对应的set方法，完成成员变量的赋值，这种方式我们也称之为set注入。

5. Set注入详解

要求：对应的属性必须要有set方法，并且set方法名必须按照严格的规范，例如属性是name，那么方法必须是setName这种格式，并且set方法的权限必须是public
因为这里为属性赋值没有用到反射获取set方法为其赋值，是直接调用的对象的set方法为其赋值，所以必须保证有set方法并且set方法的权限必须是public
一共分为两大类的注入

➢ JDK内置类型

➢ 用户自定义类型

针对于不同类型的成员变量，在<property>标签中，需要嵌套其他标签

1个property代表1个属性的set方法

<property>
  xxxxx
</property>
1
2
3

Ⅰ. JDK内置类型

注：以下代码都需要嵌套在<property></property>标签中

1️⃣ String + 8种基本类型

<value>lyc</value>
1

2️⃣ 数组

<list>
    <value>xiaocheng_tx@163.com</value>
    <value>627519997@qq.com</value>
</list>
1
2
3
4

3️⃣ Set集合

<!-- set集合赋值无序 -->
<set>
    <value>111</value>
    <value>222</value>
    <value>333</value>
</set>

<!-- set内的标签中不一定只能是<value> 也有可能是自定义类型 还可以嵌套<set> 具体问题具体分析 -->
<set>
    <ref bean=''/> <!-- 自定义类型 后续会讲 -->
    <set></set>
    ...
</set>
1
2
3
4
5
6
7
8
9
10
11
12
13

4️⃣ List集合

<!-- 跟数组一样 都是<list>标签 list集合赋值有序 -->
<list>
    <value>111</value>
    <value>222</value>
    <value>333</value>
</list>

<!-- list内的标签 与set一样 具体问题具体分析 -->
<list>
    <ref bean=''/>
    <set></set>
    ...
</list>
1
2
3
4
5
6
7
8
9
10
11
12
13

5️⃣ Map集合

<!--
注意： map -- entry  -- key有特定的标签  <key></key>
                       值根据对应类型选择对应类型的标签
有几个键值对就有几个<entry>标签
-->
<map>
  <entry>
    <key><value>lyc</value></key>
    <value>shuaige</value>
  </entry>
  <!-- entry内的标签 具体问题具体分析 -->
  <entry>
    <key><value>haha</value></key>
    <ref bean=""/>
  </entry>
</map>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

6️⃣ Properites

<!-- 
Properties类型 特殊的Map key=String value=String
value直接写在<key>属性之间
-->
<props>
  <prop key="key1">value1</prop>
  <prop key="key2">value2</prop>
</props>
1
2
3
4
5
6
7
8

7️⃣ 复杂的JDK类型 (Date)

需要程序员自定义类型转换器，处理。

Ⅱ. 用户自定义类型

1️⃣ 第一种方式

为成员变量提供 set get 方法

配置文件中进行注入（赋值）

<bean id="userService" class="xxxx.UserServiceImpl">
    <property name="userDAO">
        <bean class="xxx.UserDAOImpl"/>
    </property>
</bean>
1
2
3
4
5

2️⃣ 第二种方式

第一种赋值方式存在的问题

➢ 配置文件代码冗余

➢ 被注入的对象 (UserDAO)，多次创建，浪费 (JVM) 内存资源
为成员变量提供 set get 方法

配置文件中进行配置

<bean id="userDAO" class="xxx.UserDAOImpl"/>

<bean id="userService" class="xxx.UserServiceImpl">
    <property name="userDAO">
        <ref bean="userDAO"/>
    </property>
</bean>
<!-- Spring4.x 废除了 <ref local=""/> 基本等效 <ref bean=""/> -->
1
2
3
4
5
6
7
8

Ⅲ. Set注入的简化写法

基于属性简化

<!-- JDK类型注入 -->
<property name="name">
    <value>lyc</value>
</property>

<property name="name" value="lyc"/>
<!-- 注意：value属性 只能简化 8种基本类型+String 注入标签 -->

<!-- 用户自定义类型 -->
<property name="userDAO">
    <ref bean="userDAO"/>
</property>

<property name="userDAO" ref="userDAO"/>
1
2
3
4
5
6
7
8
9
10
11
12
13
14

基于p命名空间简化

➢ 基本类型+String直接写 p:属性名="值"

➢ 自定义类型 p:属性名-ref="引用bean的id"

➢ p命名空间写在<bean>标签中，需要在IDEA引入（在IDEA中Alt+Enter）

<!-- JDK类型注入 -->
<bean id="person" class="xxxx.Person">
    <property name="name">
        <value>lyc</value>
    </property>
</bean>

<bean id="person" class="xxx.Person" p:name="lyc"/>
<!-- 注意：value属性 只能简化 8种基本类型+String 注入标签 -->

<!-- 用户自定义类型 -->
<bean id="userService" class="xx.UserServiceImpl">
    <property name="userDAO"> 
        <ref bean="userDAO"/>
     </property>
</bean>

<bean id="userService" class="xxx.UserServiceImpl" p:userDAO-ref="userDAO"/>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

6. 构造注入

注入：通过Spring的配置文件，为成员变量赋值。
Set注入：Spring调用Set方法，通过配置文件为成员变量赋值。
构造注入：Spring调用构造方法，通过配置文件为成员变量赋值。

Ⅰ. 开发步骤

提供有参构造方法

public class Customer implements Serializable {
    private String name;
    private int age;

    public Customer(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
1
2
3
4
5
6
7
8
9

Spring的配置文件

<bean id="customer" class="com.lyc.constructer.Customer">
    <!-- 1个<constructor-arg>标签对应1个构造方法中的参数 -->
    <constructor-arg>
        <value>lyc</value>
    </constructor-arg>
    <constructor-arg>
        <value>20</value>
    </constructor-arg>
</bean>
1
2
3
4
5
6
7
8
9

Ⅱ. 构造方法重载

参数个数不同时

➢ 通过控制<constructor-arg>标签的数量进行区分
构造参数个数相同时

➢ 通过在标签引入 type属性 进行类型的区分<constructor-arg type="">

Ⅲ. 注入的总结

未来的实战中，应用set注入还是构造注入？

答案：set注入更多

构造注入麻烦（重载）
Spring框架底层大量应用了 set注入

7. 反转控制（IOC）

反转 (转移) 控制（IOC，Inverse of Control）

Spring中的反转控制（IOC）就是一个概念。

控制：对于成员变量赋值的控制权
反转控制：把对于成员变量赋值的控制权，从代码中反转 (转移) 到Spring工厂和配置文件中完成

➢ 好处：解耦合
底层实现：工厂设计模式

8. 依赖注入（DI）

依赖注入 (DI，Dependency Injection)

注入：通过Spring的工厂及配置文件，为对象（bean，组件）的成员变量赋值
依赖注入：当一个类需要另一个类时，就意味着依赖，一旦出现依赖，就可以把另一个类作为本类的成员变量，最终通过Spring配置文件进行注入（赋值）。

➢ 好处：解耦合

9. Spring工厂创建复杂对象

Ⅰ. 什么是复杂对象

复杂对象：指的就是不能直接通过new构造方法创建的对象

➢ Connection

➢ SqlSessionFactory

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

1️⃣ FactoryBean接口

FactoryBean接口是Spring原生提供的创建复杂对象的方式，是Spring非常重要的一种机制。

开发步骤

➢ 实现FactoryBean接口

package com.lyc.factoryBean;

import org.springframework.beans.factory.FactoryBean;

import java.sql.Connection;
import java.sql.DriverManager;

public class ConnectionFactoryBean implements FactoryBean<Connection> {
    /**
     * 用于书写创建复杂对象的代码 最终返回创建的对象
     * @return Connection
     * @throws Exception
     */
    @Override
    public Connection getObject() throws Exception {
        Class.forName("com.mysql.cj.jdbc.Driver");
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/express", "root", "123456");
        return conn;
    }

    /**
     * 用于返回创建的复杂对象的类型(class)
     * @return
     */
    @Override
    public Class<?> getObjectType() {
        return Connection.class;
    }

    /**
     * 设置此对象是否是单例的 默认是true
     * @return false
     */
    @Override
    public boolean isSingleton() {
        return false;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

➢ Spring配置文件的配置

<bean id="conn" class="com.lyc.factoryBean.ConnectionFactoryBean"/>
1

注意：
这里配置的是ConnectionFactoryBean的对象，但我们获取的是ConnectionFactoryBean创建的复杂对象:Connection

创建成功

细节

➢ 如果就想获得FactoryBean类型的对象：ctx.getBean("&conn")，加上& 获得就是ConnectionFactoryBean对象。

➢ isSingleton()方法

◽ 返回true只会创建一个复杂对象

◽ 返回false每一次都会创建新的对象

◽ 问题：根据这个对象的特点，决定是返回 true (SqlSessionFactory) 还是 false (Connection)

➢ 依赖注入（DI）的体会

ConnectionFactoryBean

// 把ConnectionFactoryBean中依赖的4个字符串参数作为成员变量 通过Spring的配置文件进行注入
// 好处：解耦合
private String driverClassName;
private String url;
private String username;
private String password;

get/set...

@Override
public Connection getObject() throws Exception {
    Class.forName(driverClassName);
    Connection conn = DriverManager.getConnection(url, username, password);
    return conn;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

applicationContext.xml

<bean id="conn" class="com.lyc.factoryBean.ConnectionFactoryBean">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306/express"></property>
    <property name="username" value="root"></property>
    <property name="password" value="123456"></property>
</bean>
1
2
3
4
5
6

FactoryBean的实现原理 (简易版)

接口回调

➢ 为什么Spring规定FactoryBean接口让我们实现，并且要把创建对象的代码写到getObject()中？

➢ 为什么通过ctx.getBean("conn") 获得的是复杂对象Connection而没有获得ConnectionFactoryBean(&)

Spring内部运行流程

① 通过conn获得ConnectionFactoryBean类的对象，进而通过instanceof判断出是FactoryBean接口的实现类

② Spring按照规定getObject() => Connection

③ 返回Connection
FactoryBean总结

➢ Spring中用于创建复杂对象的一种方式，也是Spring原生提供的，后续讲解Spring整合其他框架，大量应用FactoryBean。

2️⃣ 实例工厂

作用

➢ 避免Spring框架的侵入

➢ 整合遗留系统

开发步骤

实例工厂

// 不用实现FactoryBean接口
public class ConnectionFactory {
    // 遗留代码 需要用Spring集成
    public Connection getConnection() {
        Connection conn = null;
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/express", "root", "123456");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        System.out.println("实例工厂创建连接对象");
        return conn;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

配置文件applicationContext.xml

<!-- 配置ConnectionFactory类 -->
<bean id="connFactory" class="com.lyc.factoryBean.ConnectionFactory"></bean>

<!--
factory-bean:指定这个复杂对象由哪个对象创建 这里是ConnectionFactory对象创建的，
		     所以引用上面配置的ConnectionFactory对象bean标签的id属性
factory-method:指定这个调用ConnectionFactory类的哪个方法创建这个对象
-->
<bean id="conn" factory-bean="connFactory" factory-method="getConnection"></bean>
1
2
3
4
5
6
7
8
9

创建成功

3️⃣ 静态工厂

开发步骤

➢ 跟实例工厂的代码的区别就是将获取对象的方法设置为静态方法

public class StaticConnectionFactory {
    // 遗留代码 需要用Spring集成
    public static Connection getConnection() {
        Connection conn = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/express", "root", "123456");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        System.out.println("静态工厂创建连接对象");
        return conn;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

➢ 配置文件

也有改变，不需要工厂对象，直接调用方法即可获取对象（静态方法）

<bean id="conn" class="com.lyc.factoryBean.StaticConnectionFactory" factory-method="getConnection"></bean>
1

创建成功

Ⅲ. Spring工厂创建对象的总结

10. 控制Spring工厂创建对象的次数

Spring工厂默认创建的对象都是单例

控制简单对象的创建次数

<!-- 
scope属性
sigleton:只会创建一次简单对象 默认值
prototype:每一次都会创建新的对象
-->
<bean id="account" scope="singleton" class="xxxx.Account"/>
<bean id="account" scope="prototype" class="xxxx.Account"/>
1
2
3
4
5
6
7

控制复杂对象的创建次数

FactoryBean {
	// 只会创建一次
	isSingleton() {
		return true;  
    }
    // 每一次都会创建新的
    isSingleton() { 
        return false; 
    }
}
// 如没有isSingleton方法 还是通过scope属性 进行对象创建次数的控制
1
2
3
4
5
6
7
8
9
10
11

为什么要控制对象的创建次数？

好处：节省不必要的内存浪费

➢ 什么样的对象只创建一次？
```
1. SqlSessionFactory
2. DAO
3. Service
1
2
3
```
➢ 什么样的对象每一次都要创建新的？
```
1. Connection
2. SqlSession | Session
3. Struts2 Action
1
2
3
```

相关阅读:
白盒测试之语句覆盖、判定覆盖、条件覆盖等
 基于Web的商城后台管理系统的设计与实现
 flutter多渠道打包运行
 基于Dijkstra和A*算法的机器人路径规划（Matlab代码实现）
FLOPS
计算大于2的任意正整数n以内的所有素数(质数)的和
 【面试宝典】MyBatis系列面试真题
 建模杂谈系列155 从一段程序讨论通用的任务执行方法
 Vue学习
 Redis5 持久化
原文地址：https://blog.csdn.net/weixin_53407527/article/details/125417894

Spring IOC工厂

Spring—前导 与 IOC工厂

1. 引言

Ⅰ. EJB存在的问题

Ⅱ. 什么是Spring

Ⅲ. 设计模式

Ⅳ. 工厂设计模式

1️⃣ 什么是工厂设计模式

2️⃣ 简单工厂的设计

3️⃣ 通用工厂的设计

4️⃣ 通用工厂的使用方式

Ⅴ. 总结

2. 第一个Spring程序

Ⅰ. 环境搭建

Ⅱ. Spring的核心API

Ⅲ. 程序开发

Ⅳ. 细节分析

Ⅴ. Spring工厂的底层实现原理 (简易版)

Ⅵ. 思考

3. Spring5.x与日志框架的整合

4. 注入（Injection）

Ⅰ. 什么是注入

1️⃣ 为什么需要注入

2️⃣ 如何进行注入[开发步骤]

3️⃣ 注入的好处

Ⅱ. Spring注入的原理分析 (简易版)

5. Set注入详解

Ⅰ. JDK内置类型

1️⃣ String + 8种基本类型

2️⃣ 数组

3️⃣ Set集合

4️⃣ List集合

5️⃣ Map集合

6️⃣ Properites

7️⃣ 复杂的JDK类型 (Date)

Ⅱ. 用户自定义类型

1️⃣ 第一种方式

2️⃣ 第二种方式

Ⅲ. Set注入的简化写法

6. 构造注入

Ⅰ. 开发步骤

Ⅱ. 构造方法重载

Ⅲ. 注入的总结

7. 反转控制（IOC）

8. 依赖注入（DI）

9. Spring工厂创建复杂对象

Ⅰ. 什么是复杂对象

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

1️⃣ FactoryBean接口

2️⃣ 实例工厂

3️⃣ 静态工厂

Ⅲ. Spring工厂创建对象的总结

10. 控制Spring工厂创建对象的次数

Spring—前导与 IOC工厂