【Spring】 03 - Spring IOC

2020-09-13 本文已影响0人 itlu

1. 程序的耦合

1.1 什么是程序的耦合？

耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差( 降低耦合性，可以提高其独立性)。耦合性存在于各个领域，而非软件设计中独有的，但是我们只讨论软件工程中的耦合。
在软件工程中，耦合指的就是就是对象之间的依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个准则就是高内聚低耦合。

1.2 耦合的分类

内容耦合。当一个模块直接修改或操作另一个模块的数据时，或一个模块不通过正常入口而转入另一个模块时，这样的耦合被称为内容耦合。内容耦合是最高程度的耦合，应该避免使用之。
公共耦合。两个或两个以上的模块共同引用一个全局数据项，这种耦合被称为公共耦合。在具有大量公共耦合的结构中，确定究竟是哪个模块给全局变量赋了一个特定的值是十分困难的。
外部耦合 。一组模块都访问同一全局简单变量而不是同一全局数据结构，而且不是通过参数表传递该全局变量的信息，则称之为外部耦合。
控制耦合 。一个模块通过接口向另一个模块传递一个控制信号，接受信号的模块根据信号值而进行适当的动作，这种耦合被称为控制耦合。
标记耦合。若一个模块 A 通过接口向两个模块 B 和 C 传递一个公共参数，那么称模块 B 和 C 之间存在一个标记耦合。
数据耦合。模块之间通过参数来传递数据，那么被称为数据耦合。数据耦合是最低的一种耦合形式，系统中一般都存在这种类型的耦合，因为为了完成一些有意义的功能，往往需要将某些模块的输出数据作为另一些模块的输入数据。
非直接耦合 。两个模块之间没有直接关系，它们之间的联系完全是通过主模块的控制和调用来实现的。

总结：耦合是影响软件复杂程度和设计质量的一个重要因素，在设计上我们应采用以下原则：如果模块间必须存在耦合，就尽量使用数据耦合，少用控制耦合，限制公共耦合的范围，尽量避免使用内容耦合。

1.3 内聚和耦合

内聚标志一个模块内各个元素彼此结合的紧密程度，它是信息隐蔽和局部化概念的自然扩展。内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事。它描述的是模块内的功能联系。耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据。程序讲究的是低耦合，高内聚。就是同一个模块内的各个元素之间要高度紧密，但是各个模块之间的相互依存度却要不那么紧密。
内聚和耦合是密切相关的，同其他模块存在高耦合的模块意味着低内聚，而高内聚的模块意味着该模块同其他模块之间是低耦合。在进行软件设计时，应力争做到高内聚，低耦合。
我们在开发中，有些依赖关系是必须的，有些依赖关系可以通过优化代码来解除的。

public class AccountServiceImpl implements IAccountService {
    private IAccountDao accountDao = new AccountDaoImpl();
}

上面的代码表示：业务层调用持久层，并且此时业务层在依赖持久层的接口和实现类。如果此时没有持久层实现类，编译将不能通过。这种编译期依赖关系，应该在我们开发中杜绝。我们需要优化代码解决。
再比如： 早期我们的 JDBC 操作，注册驱动时，我们为什么不使用 DriverManager 的 register 方法，而是采用 Class.forName 的方式？

public class JdbcDemo1 {
    public static void main(String[] args) throws Exception {
      //1.注册驱动
      //DriverManager.registerDriver(new com.mysql.jdbc.Driver());
      Class.forName("com.mysql.jdbc.Driver");
      //2.获取连接
      //3.获取预处理 sql 语句对象
      //4.获取结果集
      //5.遍历结果集
    }
}

原因就是：我们的类依赖了数据库的具体驱动类（MySQL），如果这时候更换了数据库品牌（比如 Oracle），需要修改源码来重新数据库驱动。这显然不是我们想要的。

1.4 解决程序耦合的思路

当是我们使用 jdbc 时，是通过反射来注册驱动的，代码如下：

Class.forName("com.mysql.jdbc.Driver");//此处只是一个字符串

此时的好处是，我们的类中不再依赖具体的驱动类，此时就算删除 mysql 的驱动 jar 包，依然可以编译（运行就不要想了，没有驱动不可能运行成功的）。
同时，也产生了一个新的问题， mysql 驱动的全限定类名字符串是在 java 类中写死的，一旦要改还是要修改源码。
解决这个问题也很简单，使用配置文件配置。

1.5 工厂模式解耦

在实际开发中我们可以把三层的对象都使用配置文件配置起来，当启动服务器应用加载的时候，让一个类中的方法通过读取配置文件，把这些对象创建出来并存起来。在接下来的使用的时候，直接拿过来用就好了。那么，这个读取配置文件，创建和获取三层对象的类就是工厂。

2. 控制反转-Inversion Of Control

存哪去？

分析：由于我们是很多对象，肯定要找个集合来存。这时候有 Map 和 List 供选择。

到底选 Map 还是 List 就看我们有没有查找需求。有查找需求，选 Map。

所以我们的答案就是

在应用加载时，创建一个 Map，用于存放三层对象。

我们把这个 map 称之为容器。

主动寻找资源

还是没解释什么是工厂？

工厂就是负责给我们从容器中获取指定对象的类。这时候我们获取对象的方式发生了改变。

原来：我们在获取对象时，都是采用 new 的方式。是主动的。

现在：我们获取对象时，同时跟工厂要，有工厂为我们查找或者创建对象。是被动的。

这种被动接收的方式获取对象的思想就是控制反转，它是 spring 框架的核心之一。

被动寻找资源

3.控制反转：控制反转是将创建对象的权利交给框架，，是框架的重要特征。并非面向对象编程的专业术语。它包含依赖注入（DI）和依赖查找。

控制反转（IOC）的作用：削减计算机程序的耦合(解除我们代码中的依赖关系)。

2. 使用Spring的IOC解决程序耦合

2.1 事例前期准备

本章我们使用的案例是，账户的业务层和持久层的依赖关系解决。在开始 spring 的配置之前，我们要先准备一下环境。由于我们是使用 spring 解决依赖关系，并不是真正的要做增删改查操作，所以此时我们没必要写实体类。并且我们在此处使用的是 java 工程，不是 java web 工程。

2.1.1 准备Spring的开发包

官网: spring官网
Spring下载地址: Spring下载地址
Spring 源码目录结构：

docs ： API和开发文档

libs：jar包和源码

schma：约束

Spring开发包目录

2.1.2 创建项目

创建一个Maven项目，不使用骨架。
在pom.xml文件中导入依赖:

    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
    </dependencies>

创建账户持久层接口及实现类。

/**
 * 账户持久层接口 
 * @author lyp
 */
public interface AccountDao {
    /**
     * 保存账户信息
     */
    void saveAccount();
}

public class AccountDaoImpl implements AccountDao {
    public void saveAccount() {
        System.out.println("保存账户.....");
    }
}

创建业务层接口及实现类：

/**
 * 账户业务层就接口
 * @author lyp
 */
public interface AccountService {
    /**
     * 保存账户信息
     */
    void saveAccount();
    
}

/**
 * 账户业务层实现类
 */
public class AccountServiceImpl implements AccountService {
    private AccountDao ac = new AccountDaoImpl();
    /**
     * 保存账户信息
     */
    public void saveAccount() {
        ac.saveAccount();
    }
}

在resources目录下创建一个 bean.xml 文件，并导入相关约束，在 Spring文档中搜索xmlns找到第一个约束就是:

<?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="accountDao" class="com.lyp.dao.impl.AccountDaoImpl"/>
    <bean id="accountService" class="com.lyp.service.impl.AccountServiceImpl"/>
</beans>

在测试类中获取 IOC容器和，根据id获取对象:

public class Client {

    /**
     * 获取IOC容器对象
     *
     * @param args
     */
    public static void main(String[] args) {
        // 1. 获取IOC容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        // 2. 根据id获取对象
        AccountDao ad = ac.getBean("accountDao", AccountDao.class);
        AccountService as = (AccountService) ac.getBean("accountService");
        System.out.println(ad);
        System.out.println(as);
    }
}

运行结果

2.1.3 查看ApplicationContext的三个实现类

查看一个类实现关系

查看一个类的实现类

ApplicationContext的三个常用实现类 :

ClassPathXmlApplicationContext ：它可以加载类路径下的配置文件，要求配置文件必须在类路径下。

FileSystemXmlApplicationContext：可以加载磁盘任意路径下的配置文件。但是必须有访问权限。

AnnotationConfigApplicationContext：它是用于读取注解创建容器的。

使用ApplicationContext的方式

        // 1. 获取IOC容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

使用FileSystemXmlApplicationContext的方式:

  ApplicationContext ac = new FileSystemXmlApplicationContext("D:\\work\\idea-core\\2020_09_12_spring\\spring_ioc_demo03\\src\\main\\resources\\bean.xml");

2.1.4 核心容器的两个接口引发出的问题

两个接口： BeanFactory 和 ApplicationContext ；
ApplicationContextt: 它在构建核心容器时，创建对象的策略是采用立即加载的方式。也就是说只要已读取完配置文件，马上就创建配置文件中配置的对象。单例对象适用。


// 测试何时创建
// 在AccountService实现类中 添加实现类的构造方法
   public AccountServiceImpl() {
        System.out.println("对象创建了....");
    }

根据断点可知ApplicationContext在解析完配置文件之后完成对象的创建

BeanFactory 在构建核心容器时，创建对象采用的策略是采用延迟加载的方式，也就是说什么时候根据id获取对象，什么时候才真正创建对象。 多例对象适用。

        // 适用BeanFactory 创建对象使用断点测试何时创建对象
        Resource rs = new ClassPathResource("bean.xml");
        BeanFactory ac = new XmlBeanFactory(rs);
        // 2. 根据id获取对象
        AccountDao ad = ac.getBean("accountDao", AccountDao.class);
        AccountService as = (AccountService) ac.getBean("accountService");
        System.out.println(ad);
        System.out.println(as);

使用断点查看BeanFactory创建对象的时机：在根据id获取对象时创建对象

2.1.5 Demo地址

Demo码云地址:Spring IOC 中 ApplicationContext 和 BeanFactory创建对象的区别

2.2 Spring中Bean的细节

2.2.1 初始化一个项目

创建一个新的Maven项目，其中Service层和测试代码使用上一个Demo。进行适当的删减。

导入依赖:

    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
    </dependencies>

创建Service业务层接口接实现类:

public interface AccountService {
    /**
     * 保存账户的方法
     */
    void saveAccount();
}

public class AccountServiceImpl implements AccountService {

    /**
     * 保存账户方法
     */
    public void saveAccount() {
        System.out.println("service saveAccount method executed ... ");
    }
}

4.在resources目录下创建bean.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">
        
        <!--spring对bean的管理细节-->
        <bean id="accountService" class="com.lyp.service.impl.AccountServiceImpl"/>
</beans>

获取IOC容器，并根据id获取对象:

public class Client {
    /**
     * 获取IOC容器并根据id获取对象
     * @param args
     */
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        AccountService as = ac.getBean("accountService", AccountService.class);
        as.saveAccount();
    }
}

2.2.2 创建Bean的三种方式

第一种方式：使用默认构造函数创建。在Spring的配置文件中使用bean标签，配以id和class属性之后，并且没有其他属性和标签时。采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则对象无法创建。当使用这种方式时，如果该类是存在与jar包中，我们无法修改原来的方式来提供默认的构造函数。该如何创建对象？？？

<bean id="accountService" class="com.lyp.service.impl.AccountServiceImpl"/>

第二种方式：使用普通工厂中的方法创建对象（使用某个类中的方法创建对象并存入Spring容器）。

  public class InstanceFactory {
    /**
     * 通过方法返回一个AccountService对象
     * @return
     */
    public AccountService getAccountService() {
        return new AccountServiceImpl();
    }
}

     <!--第二种创建方式：使用工厂方法中的方法创建对象并返回-->
    <bean id="instanceFactory" class="com.lyp.factory.InstanceFactory"/>
    <bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"/>

第三种方式：使用静态工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并存入到容器中中）。

public class StaticFactory {

    /**
     * 使用静态工厂中的静态方法创建对象并返回
     * @return
     */
    public static AccountService getAccountService() {
        return new AccountServiceImpl();
    }
}

      <!--第三种方式：使用静态工厂中的静态方法创建对象并返回-->
    <bean id="accountService" class="com.lyp.factory.StaticFactory" factory-method="getAccountService"/>

2.2.3 Bean对象的作用范围

Spring的Bean对象默认情况下是单例的。

Spring的Bean对象默认是单例的

bean标签的scope属性

作用：用于指定bean的作用范围；
取值：

singleton：单例（默认值）。

prototype：多例。

request：作用于web应用的请求范围。

session：作用于web应用的会话范围。

global-session：作用于集群环境的会话范围（全局会话范围），当不是集群是它就是session。

<bean id="accountService" class="com.lyp.service.impl.AccountServiceImpl" scope="prototype"/>

Global-Session的含义

2.2.4 Bean对象的生命周期

单例对象

出生：当容器创建时对象出生。解析完配置文件。

public class AccountServiceImpl implements AccountService {

    private AccountDao ac = new AccountDaoImpl();

    public AccountServiceImpl() {
        System.out.println("对象创建了....");
    }

    /**
     * 保存账户信息
     */
    public void saveAccount() {
        ac.saveAccount();
    }

    public void init() {
        System.out.println("对象初始化了....");
    }

    public void destroy() {
        System.out.println("对象销毁了....");
    }
}

<bean id="accountService" class="com.lyp.service.impl.AccountServiceImpl" scope="singleton" init-method="init" destroy-method="destroy"/>

单例对象生命周期

活着：只要容器还在，对象就一直活着。
死亡：容器销毁，对象消亡。
总结：单例对象的生命周期和容器相同。

多例对象

出生：当使用对象时Spring框架为我们创建。
活着：对象只要在使用过程中就一直活着。
死亡：当对象长时间不用且没有别的对象引用时，有Java的垃圾回收器回收。

多例对象生命周期

2.3 Spring的依赖注入

依赖注入（Dependency Injection）；
IOC的作用：降低程序之间的耦合（依赖关系）；
依赖关系的管理：以后都交给了Spring来维护。
依赖关系：当前类中需要用到其他类的对象，由Spring为我们提供，我们只需要在配置文件中说明。
依赖关系的维护：被称为依赖注入；
可以注入的数据类型（三类类型）：基本数据类型 + String + 其他bean类型（在配置文件中或者注解配置过的bean）；
注入的方式（三种方式）：使用构造方法 + 使用set方法 +使用注解；

2.3.1 初始化一个新项目

创建一个项目；
导入依赖：

  <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
    </dependencies>

创建业务层接口和实现类：

public interface AccountService {
    /**
     * 保存账户信息
     */
    void saveAccount();
}

public class AccountServiceImpl implements AccountService {
    /**
     * 保存账户信息
     */
    public void saveAccount() {
        System.out.println("saveAccount method executed ... ");
    }
}

创建测试类:

public class Client {

    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        AccountService as = ac.getBean("accountService", AccountService.class);
        as.saveAccount();
    }
}

编写bean.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="accountService" class="com.lyp.service.impl.AccountServiceImpl"/>
</beans>

2.3.2 构造函数注入

首先在类中定义一些可注入的变量：

  public class AccountServiceImpl implements AccountService {

    private Integer age;
    private String name;
    private Date birthday;

    public AccountServiceImpl(Integer age, String name, Date birthday) {
        this.age = age;
        this.name = name;
        this.birthday = birthday;
    }

    /**
     * 保存账户信息
     */
    public void saveAccount() {
        System.out.println("saveAccount method executed ... " + " name : " + name + "age:" + age + "birthday" + birthday);
    }
}

需要使用的标签：constructor-arg ,标签出现的位置bean标签内部。

type ：用于指定需要注入数据的数据类型。该数据类型也是构造函数中某个或某些参数的类型。

index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引位置是从0开始。

name：用于指定给构造函数中指定名称的参数赋值。

value：用于给基本类型和String类型赋值。

ref：用于指定其他的bean类型数据。其他的bean类型指的就是在spring IOC核心容器中出现过的bean对象。

  <bean id="accountService" class="com.lyp.service.impl.AccountServiceImpl">
        <constructor-arg name="name" value="张三"/>
        <constructor-arg name="age" value="23"/>
        <constructor-arg name="birthday" ref="now"/>
    </bean>

    <!--获取Date的bean对象-->
    <bean id="now" class="java.util.Date"/>

特点（优势）：在获取bean对象时，注入数据时必须的操作，否则对象无法创建成功!
弊端：改变了bean对象的实例化方式，是我们在创建对象时，如果用不到这些数据时也必须提供。

2.3.3 Setter方法注入（常用）

使用的标签 property ，标签出现的位置是在 bean 标签内部。


    // 生成对应的setter方法
   public void setAge(Integer age) {
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

 <!--依赖注入方式二 ： set方法注入-->
    <bean id="accountService" class="com.lyp.service.impl.AccountServiceImpl">
        <property name="name" value="王五"/>
        <property name="age" value="25"/>
        <property name="birthday" ref="now"/>
    </bean>

    <!--获取Date的bean对象-->
    <bean id="now" class="java.util.Date"/>

标签的属性:

name: 用于指定注入时所调用的set方法名称。

value : 用于给基本类型和String类型赋值。

ref: 用于指定其他的bean类型数据。其他的bean类型指的就是在spring IOC核心容器中出现过的bean对象。

优势：创建对象时没有明确的限制，可以直接使用默认构造函数。
弊端：如果有某个成员必须有值，则获取对象时有可能set方法没有执行。

2.3.4 复杂数据类型的注入（集合）

创建一个类用于配置复杂类型注入。

public class DependencyInjectionSet {

    private String[] arrays;
    private List ls;
    private Set ss;
    private Map<String,String> ms;
    private Properties props;
    // 省略setter方法 
    public void print() {
        System.out.println(Arrays.toString(arrays));
        System.out.println(ls);
        System.out.println(ss);
        System.out.println(ms);
        System.out.println(props);
    }
}

注入操作：

 <!--依赖注入：注入复杂数据类型-->
    <bean id="set" class="com.lyp.di.DependencyInjectionSet">

        <!--注入数组-->
        <property name="arrays">
            <array>
                <value>AAA</value>
                <value>CCC</value>
                <value>BBB</value>
            </array>
        </property>

        <!--注入动态数组 List-->
        <property name="ls">
            <list>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </list>
        </property>

        <!--注入set集合-->
        <property name="ss">
            <set>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </set>
        </property>

        <!--注入Map-->
        <property name="ms">
            <map>
                <entry key="A" value="B"/>
                <entry key="C">
                    <value>D</value>
                </entry>
            </map>
        </property>

        <!--注入properties-->
        <property name="props">
            <props>
                <prop key="A">AAA</prop>
                <prop key="B">BBB</prop>
                <prop key="C">CCC</prop>
            </props>
        </property>
    </bean>

用于给List结构集合注入的标签有 list array set 。用于给Map结构集合注入的标签 map props 。结构相同标签可以互换。

【Spring】 03 - Spring IOC

1. 程序的耦合

1.1 什么是程序的耦合？

1.2 耦合的分类

1.3 内聚和耦合

1.4 解决程序耦合的思路

1.5 工厂模式解耦

2. 控制反转-Inversion Of Control

2. 使用Spring的IOC解决程序耦合

2.1 事例前期准备

2.1.1 准备Spring的开发包

2.1.2 创建项目

2.1.3 查看ApplicationContext的三个实现类

2.1.4 核心容器的两个接口引发出的问题

2.1.5 Demo地址

2.2 Spring中Bean的细节

2.2.1 初始化一个项目

2.2.2 创建Bean的三种方式

2.2.3 Bean对象的作用范围

bean标签的scope属性

2.2.4 Bean对象的生命周期

单例对象

多例对象

2.3 Spring的依赖注入

2.3.1 初始化一个新项目

2.3.2 构造函数注入

2.3.3 Setter方法注入（常用）

2.3.4 复杂数据类型的注入（集合）

猜你喜欢

热点阅读

【Spring】 03 - Spring IOC

1. 程序的耦合

1.1 什么是程序的耦合 ？

1.2 耦合的分类

1.3 内聚和耦合

1.4 解决程序耦合的思路

1.5 工厂模式解耦

2. 控制反转-Inversion Of Control

2. 使用Spring的IOC解决程序耦合

2.1 事例前期准备

2.1.1 准备Spring的开发包

2.1.2 创建项目

2.1.3 查看ApplicationContext的三个实现类

2.1.4 核心容器的两个接口引发出的问题

2.1.5 Demo地址

2.2 Spring中Bean的细节

2.2.1 初始化一个项目

2.2.2 创建Bean的三种方式

2.2.3 Bean对象的作用范围

bean标签的scope属性

2.2.4 Bean对象的生命周期

单例对象

多例对象

2.3 Spring的依赖注入

2.3.1 初始化一个新项目

2.3.2 构造函数注入

2.3.3 Setter方法注入 （常用）

2.3.4 复杂数据类型的注入（集合）

猜你喜欢

热点阅读

1.1 什么是程序的耦合？

2.3.3 Setter方法注入（常用）