Spring框架入门之IoC

这篇博文只是作者对spring框架的简单介绍、入门和使用

spring框架入门系列涉及到的源码请查看：gitee.com/realpluto/d…

一、spring简介

1.1.1 Spring是什么

Spring是分层的 Java SE/EE应用full- stack轻量级开源框架，以IoC(Inversion of Control:反转控制）和AOP( Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 Spring MVC和持久层 Spring JDBC以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的 Java EE企业应用开源框架。

1.1.2Spring开发优势

• 方便解耦，简化开发 通过 Spring提供的IoC容器，可以将对象间的依赖关系交由 Spring进行控制，避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。
• AOP编程的支持 通过 Spring的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松实现。声明式事务的支持 可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务的管理，提高开发效率和质量。
• 方便程序的测试 可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。
• 方便集成各种优秀框架 Spring可以降低各种框架的使用难度，提供了对各种优秀框架（ Struts、Hibernate、Hessian、 Quartz 等）的直接支持。
• 降低 JAVAEE API的使用难度 Spring对 javsEE API（如JDBC、 JavaMail、远程调用等）进行了薄薄的封装层，使这些API的使用难度大为降低。
• Java源码是经典学习范例 Spring 的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诸。它的源代码是Java技术的最佳实践的范例。

1.1.3Spring的体系结构

Spring的核心是IoC容器，其它的主要功能是在IoC的基础上发展出来的。

二、程序间的耦合

1. 耦合的概念

耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差( 降低耦合性，可以提高其独立性)。耦合性存在于各个领域，而非软件设计中独有的，但是我们只讨论软件工程中的耦合。

在软件工程中，耦合指的就是就是对象之间的依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个准则就是高内聚低耦合。

它有如下分类：

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

总结：

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

内聚与耦合

内聚标志一个模块内各个元素彼此结合的紧密程度，它是信息隐蔽和局部化概念的自然扩展。内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事。它描述的是模块内的功能联系。耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据。 程序讲究的是低耦合，高内聚。就是同一个模块内的各个元素之间要高度紧密，但是各个模块之间的相互依存度却要不那么紧密。

内聚和耦合是密切相关的，同其他模块存在高耦合的模块意味着低内聚，而高内聚的模块意味着该模块同其他模块之间是低耦合。在进行软件设计时，应力争做到高内聚，低耦合。

2. 怎样解决耦合问题

2.1 通过反射的方式

使用反射找到全限定类名的方式进行对象的创建，不再依赖具体的实现类（不在编译时依赖而是在运行时依赖），但是全限定类名仍是固定的字符串，切换起来不够灵活。可以将全限定类名书写成配置文件，通过配置文件读取全限定类名，可以解决切换不灵活的问题。

步骤：

1. 在配置文件中书写全限定类名（key = value）
2. 通过读取配置文件获取全限定类名，通过反射创建对象

2.2 通过工厂模式

创建Bean对象工厂来解决耦合问题

Bean: 可重用组件 JavaBean > 实体类

步骤：

1. 在配置文件中书写全限定类名（key = value）
2. 通过读取配置文件获取全限定类名，通过反射创建对象
3. 所有的对象创建均通过FactoryBean进行创建（可以通过单例模式每次只生成一个对象）

public class BeanFactory {

    // 定义properties类
    private static Properties props;

    // 定义一个Map，用于存放对象，可以称之为容器
    private static Map<String, Object> beans;
    // 使用静态代码块为Properties对象赋值
    static {
        try {
            // 实例化对象
            props = new Properties();
            // 获取properties文件对象流
            InputStream inputStream = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            props.load(inputStream);
            // 实例化容器
            beans = new HashMap<String, Object>();
            // 取出配置文件中的Key
            Enumeration keys = props.keys();
            // 遍历枚举
            while (keys.hasMoreElements()){
                // 取出每个key值
                String key = keys.nextElement().toString();
                // 根据key获取value值
                String beanPath = props.getProperty(key);
                // 反射创建对象
                Object value = Class.forName(beanPath).newInstance();
                // 将key和value放到容器中
                beans.put(key, value);
            }
        } catch (Exception e) {
            throw new ExceptionInInitializerError("初始化失败");
        }
    }

    /**
     * 根据bean的name获取bean对象
     * @param beanName
     * @return
     */
    public static Object getBean(String beanName){
        return beans.get(beanName);
    }

}

三、IOC和DI

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

IoC的作用：解决程序间的耦合（解除代码中的依赖关系）

spring的核心容器相当于一个Map，存放了IoC管理的对象

1. 关于ApplicationContext

ApplicationContext是spring提供的一个创建核心容器的接口，可以通过此接口可以创建IoC核心容器对象，并通过此对象进行IoC容器内对象的管理。

1.1 ApplicationContext的三个常用实现类

• ClassPathXmlApplicationContext：它可以加载类路径下的配置文件，要求配置文件必须在类路径下。不在的话，加载不了。(更常用)
• FileSystemXmlApplicationContext：它可以加载磁盘任意路径下的配置文件(必须有访问权限）
• AnnotationConfigApplicationContext：它是用于读取注解创建容器的。

// 1.获取核心容器对象
// 1.1 通过相对目录的方式胡哦去核心容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
// 1.2 通过绝对路径的方式获取核心容器对象
ApplicationContext ac = new FileSystemXmlApplicationContext("E:\\workspace\\workspace_idea03\\demo-spring\\day02_03spring\\src\\main\\resources\\beans.xml");
// 2.根据id获取Bean对象，可以传入class对象不再进行强转
AccountService as = (AccountService) ac.getBean("accountService");
AccountDao ad = ac.getBean("accountDao", AccountDao.class);

1.2 ApplicationContext与BeanFactory

• ApplicationContext: 单例对象适用

  它在构建核心容器时，创建对象采取的策略是采用立即加载的方式。也就是说，只要一读取完配置文件马上就创建配置文件中配置的对象。

• BeanFactory: 多例对象使用

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

说明：ApplicationContext可以根据对象是单例还是多例选择创建的时机，实际开发中更多的是使用此接口。

// 通过BeanFactory创建对象
Resource resource = new ClassPathResource("beans.xml");
BeanFactory factory = new XmlBeanFactory(resource);
AccountService as = (AccountService) factory.getBean("accountService");
System.out.println(as);

1.3 spring中bean的细节

1.3.1 创建bean的三种方式

• 第一种方式：使用默认构造函数创建。

  在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时。采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则对象无法创建。

<bean id="accountService" class="cn.bruce.service.impl.AccountServiceImpl"></bean>

• 第二种方式： 使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并存入spring容器）
  • 指定工厂对象id和全路径名
  • 指定要创建的对象、工厂对象、工厂对象方法

<bean id="initFactory" class="cn.bruce.factory.InitFactory"></bean>
<bean id="accountService" factory-bean="initFactory" factory-method="getAccountService"></bean>

• 第三种方式：使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并存入spring容器)
  • 直接通过静态工厂方法获取对象

<bean id="staticFactory" class="cn.bruce.factory.StaticFactory" factory-method="getAccountService"></bean>

第二种和第三种方式适合于调用jar包中的方法，如果希望spring容器管理jar包中的对象可以采用这两种方法

1.3.2 bean对象的作用范围

spring默认创建的bean对象是单例的，可以通过scope属性进行调整。

bean标签的scope属性：

• 作用：用于指定bean的作用范围
• 取值： 常用的就是单例的和多例的
• singleton：单例的（默认值）
• prototype：多例的
• request：作用于web应用的请求范围
• session：作用于web应用的会话范围
• global-session：作用于集群环境的会话范围（全局会话范围），当不是集群环境时，它就是session

<bean id="accountService" class="cn.bruce.service.impl.AccountServiceImpl" scope="prototype"></bean>

关于集群环境的说明：

集群简单理解就是很多台对外提供服务的服务器，通过负载均衡技术实现对多台服务器的管理，使得每台服务器的负载适中，确保各个服务器不会出现过于忙碌或者过于空闲的状态。

1.3.3 bean对象的生命周期

单例对象

• 创建：当容器创建时对象出生
• 存活：只要容器还在，对象一直活着
• 销毁：容器销毁，对象消亡
• 总结：单例对象的生命周期和容器相同

多例对象

• 创建：当我们使用对象时spring框架为我们创建
• 存活：对象只要是在使用过程中就一直活着。
• 销毁：当对象长时间不用，且没有别的对象引用时，由Java的垃圾回收器回收

1.4 spring的依赖注入DI（Dependency Injection）

IOC的作用： 降低程序间的耦合（依赖关系）

解决方式：依赖关系的管理都交给spring来维护，在当前类需要用到其他类的对象，由spring为我们提供，我们只需要在配置文件中说明，依赖关系的维护就称之为依赖注入。

• 能注入的数据：有三类
  • 基本类型和String
  • 其他bean类型（在配置文件中或者注解配置过的bean）
  • 复杂类型/集合类型
• 注入的方式：有三种
  • 第一种：使用构造函数提供
  • 第二种：使用set方法提供
  • 第三种：使用注解提供

依赖注入适合不常用的对象间的数据添加，经常变化的数据不适用依赖注入。

1.4.1 构造函数注入

使用的标签:constructor-arg

标签出现的位置：bean标签的内部

标签中的属性：

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

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

• name：用于指定给构造函数中指定名称的参数赋值 （开发中更常用）

• value：用于提供基本类型和String类型的数据。

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

好处：在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功。

坏处：改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供。

<bean id="accountService" class="cn.bruce.service.impl.AccountServiceImpl">
    <constructor-arg type="java.lang.String" value="Bruce"></constructor-arg>
    <constructor-arg index="1" value="20"></constructor-arg>
    <!--        <constructor-arg name="birthday" value="2020-02-03"></constructor-arg>-->
    <constructor-arg name="birthday" ref="currentTime"></constructor-arg>
</bean>
<!-- 实例化时间对象 -->
<!-- 由于XML中的字符均为String格式，不能进行时间格式的解析转化，因此需要借助Java中的Date对象 -->
<bean id="currentTime" class="java.util.Date"></bean>

xml中书写的均为String，包装类型可以被转换成基本数据类型，但不能指定其他的特定的类型。

1.4.2 set方法注入

使用的标签：property

出现的位置：bean标签的内部

标签的属性：

• name：用于指定注入时所调用的set方法名称
• value：用于提供基本类型和String类型的数据
• ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象

优势：创建对象时没有明确的限制，可以直接使用默认构造函数。

弊端：如果有某个成员必须有值，则获取对象是有可能set方法没有执行。

<bean id="accountService1" class="cn.bruce.service.impl.AccountServiceImpl1">
    <property name="nnnname" value="Bruce"></property>
    <property name="age" value="12"></property>
    <property name="birthday" ref="currentTime"></property>
</bean>

使用property的name属性必须和set方法保持一致（去掉set首字母小写）

相比于构造函数注入，set方法注入更为常用

1.4.3 注入集合数据

使用的标签：property

• 用于给List结构集合注入的标签：

  list array set

• 用于个Map结构集合注入的标签:

  map props

• 结构相同，标签可以互换

<bean id="accountService2" class="cn.bruce.service.impl.AccountServiceImpl2">
    <property name="strs">
        <array>
            <value>A</value>
            <value>A</value>
            <value>B</value>
            <value>C</value>
        </array>
    </property>

    <property name="list">
        <list>
            <value>A</value>
            <value>A</value>
            <value>B</value>
            <value>C</value>
        </list>
    </property>

    <property name="set">
        <set>
            <value>A</value>
            <value>B</value>
            <value>C</value>
        </set>
    </property>

    <property name="map">
        <props>
            <prop key="name">lex</prop>
            <prop key="age">123</prop>
            <prop key="sex">female</prop>
        </props>

    </property>

    <property name="properties">
        <map>
            <entry key="name" value="Bruce"></entry>
            <entry key="age" value="22"></entry>
            <entry key="sex" value="male"></entry>
        </map>
    </property>
</bean>