Spring IOC工厂

最新推荐文章于 2024-05-14 09:51:10 发布

小成同学_

最新推荐文章于 2024-05-14 09:51:10 发布

阅读量297

点赞数 2

分类专栏： Spring 文章标签： spring IOC 设计模式 java 后端

本文链接：https://blog.csdn.net/weixin_53407527/article/details/125417894

版权

Spring 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

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层数据问题。
```
整合设计模式

➢ 工厂

➢ 代理

➢ 模板

➢ 策略

➢ …

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();

好处：解耦合

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

问题：不利于代码维护

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

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

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;
    }
}

配置文件 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

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;
     }
}

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>

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"/>

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

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

System.out.println("person = " + person);

Ⅳ. 细节分析

名词解释

➢ 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();

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

➢ 只配置class属性

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

没配置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"/>

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

Ⅴ. 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配置文件

➢ 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>

➢ 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

在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>

赋值成功

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>

Ⅰ. JDK内置类型

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

1️⃣ String + 8种基本类型

<value>lyc</value>

2️⃣ 数组

<list>
    <value>xiaocheng_tx@163.com</value>
    <value>627519997@qq.com</value>
</list>

3️⃣ Set集合

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

<!-- set内的标签中不一定只能是<value> 也有可能是自定义类型 还可以嵌套<set> 具体问题具体分析 -->
<set>
    <ref bean=''/> <!-- 自定义类型 后续会讲 -->
    <set></set>
    ...
</set>

4️⃣ List集合

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

<!-- list内的标签 与set一样 具体问题具体分析 -->
<list>
    <ref bean=''/>
    <set></set>
    ...
</list>

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>

6️⃣ Properites

<!-- 
Properties类型 特殊的Map key=String value=String
value直接写在<key>属性之间
-->
<props>
  <prop key="key1">value1</prop>
  <prop key="key2">value2</prop>
</props>

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

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

Ⅱ. 用户自定义类型

1️⃣ 第一种方式

为成员变量提供 set get 方法

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

<bean id="userService" class="xxxx.UserServiceImpl">
    <property name="userDAO">
        <bean class="xxx.UserDAOImpl"/>
    </property>
</bean>

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=""/> -->

Ⅲ. 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"/>

基于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"/>

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;
    }
}

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>

Ⅱ. 构造方法重载

参数个数不同时

➢ 通过控制<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;
    }
}

➢ Spring配置文件的配置

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

注意：
这里配置的是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;
}

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>

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;
    }
}

配置文件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>

创建成功

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;
    }
}

➢ 配置文件

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

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

创建成功

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

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

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

控制简单对象的创建次数

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

控制复杂对象的创建次数

FactoryBean {
	// 只会创建一次
	isSingleton() {
		return true;  
    }
    // 每一次都会创建新的
    isSingleton() { 
        return false; 
    }
}
// 如没有isSingleton方法 还是通过scope属性 进行对象创建次数的控制

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

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

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

小成同学_

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Spring IOC工厂

EJB（Enterprise Java Bean），叫做企业级的 Java Bean。两个问题：运行环境苛刻代码移植性差总结：EJB是一个重量级的框架。是一个轻量级的JavaEE解决方案，整合众多优秀的设计模式。轻量级➢ 对于运行环境没有额外要求 ◽ 开源 => Tomcat Resion Jetty ◽️ 收费 => Weblogic Websphere➢ 代码移植性高 ◽️ 不需要实现额外接口JaveEE的解决方案Spring是一个在Java分层开发中的解决方案，它可以解决每一层次的问题，Spri
复制链接

扫一扫