Spring 基础及 IOC 控制反转

发表于 2021-09-26 更新于 2023-09-01 分类于 Java 阅读次数：本文字数： 3.5k 阅读时长 ≈ 13 分钟

初识 Spring

Spring 优势

方便解耦，简化开发
Spring 就是一个容器，可以将所有对象创建和关系维护交给 Spring 管理
什么是耦合度？对象之间的关系，通常说当一个模块 (对象) 更改时也需要更改其他模块 (对象)，这就昰耦合，耦合度过高会使代码的维护成本增加。要尽量解耦。
AOP 编程的支持
Spring 提供面向切面编程，方便实现程序进行权限拦截，运行监控等功能。
声明式事务的支持
通过配置完成事务的管理，无需手动编程。
方便测试，降低 JavaEE API 的使用
Spring 对 Junit4 支持，可以使用注解测试。
方便集成各种优秀框架
不排除各种优秀的开源框架，内提供了对各种优秀框架的直接支持。
Spring 体系结构

IOC 控制反转

初识 oc

** 控制反转 (Inverse Of Control)** 不是什么技术，而是一种设计思想。它的目的是指导我们设计出更加松耦合的程序。

控制：在 Java 中指的是对象的控制权限 (创建、销毁)
反转：指的是对象控制权由原来由开发者在类中手动控制反转到由 Spring 容器控制

举个栗子

传统方式
之前我们需要一个 userDao 实例，需要开发者自己手动创建 new UserDao ();
IOC 方式
现在我们需要一个 userDao 实例，直接从 Spring 的 IOC 容器获得，对象的创建权交给了 Spring 控制。

Spring 快速入门

介绍

需求：借助 Spring 的 IOC 实现 service 层与 dao 层代码解耦合。

步骤分析

创建 java 项目，导入 spring 开发基本坐标
编写 Dao 接口和实现类
创建 spring 核心配置文件
在 spring 配置文件中配置 UserDaoImpl
使用 spring 相关 API 获得 Bean 实例

实现

创建 java 项目，导入 Spring 开发依赖坐标

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.10</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
    <scope>test</scope>
</dependency>

编写 Dao 接口及实现类

接口

package com.orginly.dao;

public interface IUserDao {
    public void save();
}

实现类

package com.orginly.dao.impl;

import com.orginly.dao.IUserDao;

public class UserDaoImpl implements IUserDao {

    @Override
    public void save() {
        System.out.println("dao 被调用...");
    }
}

配置 Spring 核心配置文件

一般命名为 applicationContext.xml

beans 约束文件地址：https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#xsd-schemas-beans

<?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 https://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <!-- 配置 UserDaoImpl
     id：唯一标识
     class：类全路径
     -->
    <bean id="userDao" class="com.orginly.dao.impl.UserDaoImpl" />
 
</beans>

使用 Spring 相关 api 获取 Bean 实例

@Test
public void test() {
    // 获取到 spring 上下文对象，借助上下文对象可以获取到 IOC 容器中的 bean 对象
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    // 使用上下文对象从容器中获取到 bean 对象
    IUserDao userDao = (IUserDao) applicationContext.getBean("userDao");

    userDao.save();
}

Spring 常用 Api

API 继承体系介绍

Spring 的 API 体系异常庞大，我们现在只关注两个 BeanFactory 和 ApplicationContext

ApplicationContext

1. ClassPathXmlApplicationContext
	它是从类的根路径下加载配置文件推荐使用这种。
2. FileSystemXmlApplicationContext
	它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
3. AnnotationConfigApplicationContext
	当使用注解配置容器对象时，需要使用此类来创建 spring容器。它用来读取注解。

1
2
3

 // 获取到 spring 上下文对象，借助上下文对象可以获取到 IOC 容器中的 bean 对象
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

Spring Bean 配置文件

Bean 标签基本配置

<bean id="" class="" />
用于配置对象交由 Spring 来创建。

基本属性：
	id：Bean实例在 Spring容器中的唯一标识
	c1ass：Bean的全限定

默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功。

Bean 标签范围配置

1	<bean id="" class="" scope="" />

当 scope 的取值为 singleton 时
Bean 的实例化个数：1 个
Bean 的实例化时机：当 Spring 核心文件被加载时，实例化配置的 Bean 实例。
Bean 的生命周期：

 对象创建：当应用加载，创建容器时，对象就被创建
 对象运行：只要容器在，对象一直活看
 对象销毀：当应用卸戟，销毁容器时，对象就被销毀了

当 scope 的取值为 prototype
Bean 的实例化个数：多个
Bean 的实例化时机：当调用 getBean () 方法时实例化 Bean
Bean 的生命周期：

 对象创建：当使用对象时，创建新的对象实例
 对象运行：只要对象在使用中，就一直活着
 对象销毀：当对象长时间不用时，被Java的垃圾回收器回收了

Bean 生命周期配置

<bean id="" class="" scope="" init-method="" destroy-method="" />

init-method：指定类中的初始化方法名称
destroy-method：指定类中销方法名称

Bean 实例化三种方式

无参构造方法实例化
工厂静态方法实例化
工厂普通方法实例化
无参构造方法实例化
它会根据默认无参构造方法来创建类对象，如果 bean 中没有默认无参构造函数，将会创建失败。
1
<bean id="userDao" class="com.orginly.UserDaoImp1"/>

工厂静态方法实例化

应用场景
依赖的 jar 包中有个 A 类，A 类中有个静态方法 m1，m1 方法的返回值是一个 B 对象。如果我们频繁使用 B 对象，此时我们可以将 B 对象的创建交给 spring 的 IOC 容器，以后我们在使用 B 对象时，无需调用 A 类中的 m1 方法，直接从 IOC 容器获得。

public class StaticFactoryBean {
    public static IUserDao createUserDao() {
        return new UserDaoImpl();
    }
}

1	<bean id="userDao" class="com.orginly.factory.StaticFactoryBean" factory-method="createUserDao"/>

工厂普通方法实例化

应用场景
依赖的 jar 包中有个 A 类，A 类中有个普通方法 m1，m1 方法的返回值是一个 B 对象。如果我们频繁使用 B 对象，此时我们可以将 B 对象的创建权交给 spring 的 IOC 容器，以后我们在使用 B 对象时，无需调用 A 类中的 m1 方法，直接从 IOC 容器获得。

public class DynamicFactoryBean {
    public IUserDao createUserDao() {
        return new UserDaoImpl();
    }
}

1
2
3

<!-- 工厂普通方法实例化 -->
<bean id="dynamicFactoryBean" class="com.orginly.factory.DynamicFactoryBean"  />
<bean id="userDao" factory-bean="dynamicFactoryBean" factory-method="createUserDao"/>

Bean 依赖注入概述

** 依赖注入 Dl (Dependency Injection)**：它是 Spring 框架核心 IOC 的具体实现。

在编写程序时，通过控制反转，把对象的创建交给了 Spring，但是代码中不可能出现没有依赖的情况。IOC 解耦只是降低他们的依赖关系，但不会消除。例如业务层仍会调用持久层的方法。

那这种业务层和持久层的依赖关系，在使用 Sping 之后，就让 Spring 来维护了。简单的说，就是通过框架把持久层对象传入业务层，而不用我们自己去获取。

Bean 依赖注入方式

构造方法

service 实现类

public class UserServiceImpl implements IUserService {

    // 存储注入对象
    private IUserDao userDao;

    /**
     * 有参构造用于有参构造依赖注入
     * @param userDao
     */
    public UserServiceImpl(IUserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void save() {
        userDao.save();
    }
}

<bean id="userDao" class="com.orginly.dao.impl.UserDaoImpl"/>
<!-- 配置 userService -->
<bean id="userService" class="com.orginly.service.impl.UserServiceImpl">
    <!-- 有参构造完成依赖注入
     index：参数的位置
     type：类型
     ref：对应的bean标签
     -->
    <!-- <constructor-arg index="0" type="com.orginly.dao.IUserDao" ref="userDao"/>-->
    <!-- 简化写法
     name：构造方法的参数名称
     ref：对应的bean标签
     -->
    <constructor-arg name="userDao" ref="userDao"/>
</bean>

Setter 方法完成注入

实现类

public class UserServiceImpl implements IUserService {

    // 存储注入对象
    private IUserDao userDao;

    public void setUserDao(IUserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void save() {
        userDao.save();
    }
}

<bean id="userDao" class="com.orginly.dao.impl.UserDaoImpl"/>
<!-- 配置 userService -->
<bean id="userService" class="com.orginly.service.impl.UserServiceImpl">
    <!-- setter 完成方法注入-->
    <property name="userDao" ref="userDao"/>
</bean>

Bean 依赖注入的数据类型

依赖注入普通数据类型

上面操作，都是注入 Bean 对象，除了对象的可以注入，普通数据类型和集合都可以在容器中进行注入。

注入数据的三种数据类型

普通数据类型
引用数据类型
集合数据类型其中引用数据类型，此处就不再述了，之前的操作都是对 UserDao 对象的引用进行注入的。下面将以 Setter 方法注入为例，演示普通数据类型和集合数据类型的注入。

实现类

public class UserServiceImpl implements IUserService {

    private String name;
    private int age;

    @Override
    public void save() {
        userDao.save();
        System.out.printf("name = %s,age = %d\n",name,age);
    }

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

    public void setAge(int age) {
        this.age = age;
    }

}

<!-- 配置 userService -->
<bean id="userService" class="com.orginly.service.impl.UserServiceImpl">
    <!-- setter 完成方法注入-->
    <!-- ref：用于注入引用类型，value：用于注入普通数据类型 -->
    <property name="name" value="feng"/>
    <property name="age" value="18"/>
</bean>

依赖注入集合数据类型

List 集合

<bean id="userService" class="com.orginly.service.impl.UserServiceImpl">
    <!-- 进行 List 集合进行依赖注入 -->
    
    <property name="list">
        <list value-type="java.lang.String">
            <value>feng</value>
            <value>li</value>
            <!-- 可以用 ref 进行对象的引用 -->
        </list>
    </property>
</bean>

Set 集合

<bean id="userService" class="com.orginly.service.impl.UserServiceImpl">
    <!-- 进行 Set 集合进行依赖注入 -->
    <property name="map">
        <set>
            <value>feng</value>
            <value>li</value>
        </set>
    </property>
</bean

Array 集合

<bean id="userService" class="com.orginly.service.impl.UserServiceImpl">
    <!-- 进行 Set 集合进行依赖注入 -->
    <property name="arr">
        <array>
            <value>feng</value>
            <value>li</value>
        </array>
    </property>
</bean>

Map 集合

<bean id="userService" class="com.orginly.service.impl.UserServiceImpl">
    <!-- 进行 Set 集合进行依赖注入 -->
    <property name="map">
        <map>
           <entry key="feng" value="18" />
           <entry key="li" value="18" />
        </map>
    </property>
</bean>

Properties 配置注入

public class UserServiceImpl implements IUserService {

    private Properties properties;

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    @Override
    public void save() {
        System.out.println(properties.toString());
    }
}

<bean id="userService" class="com.orginly.service.impl.UserServiceImpl">
    <property name="properties">
        <props>
            <prop key="k1">v1</prop>
            <prop key="k2">v2</prop>
        </props>
    </property>
</bean>

spring 配置文件模块化

实际开发中， Spring 的配置内容非常多，这就导致 Spring 配置很繁杂且体积很大，所以，可以将部分配置拆解到其他配置文件中，也就是所调的配置文件模块化。

并列的多个配置文件

1	Applicationcontext act = new ClassPathXml Applicationcontext("beans1.xml","beans2.xml","...")

主从配置文件

PS：开发环境中如果配置后运行找不到文件，那么需要重新 IDEA 让编辑器重新编译

1
2
3

<import resource="classpath:applicationContext-dao.xml"/>
<import resource="classpath:applicationContext-service.xml"/>
<import resource="classpath:applicationContext-user.xml"/>

注意

同一个 XML 中不能出现相同名称的 bean 如果出现会报错
多个 XML 如果出现相同名称的 bean，不会报错，但是后加载的会盖前加载的 bean

Spring 注解开发

Spring 是轻代码而重配置的框架，配置比较繁重，影响开发效率，所以注解开发是一种趋势，注解代替 xm 配置文件可以简化配置，提高开发效率。

Spring 常用注解

@Component @Controller @Service @Repository
相当于配置 <bean> 生成类实例对象到 IOC 容器中
@Autowired @Qualifier @Resource @value
相当与配置了 <property>, 进行依赖注入

PS：JDK11 以后完全移除了 javax 扩展导致不能使用 @resource 注解
如果要使用 @resource 需要引入 Mevan 依赖

<dependency>
    <groupId>javax.annotation</groupId>
    <artifactId>javax.annotation-api</artifactId>
    <version>1.3.2</version>
</dependency>

注意
使用注解进行开发时，需要在 applicationContext.xml 中配置组件扫描，作用是指定哪个包及其子包下的 Bean 需要进行扫描以便识别使用注解配置的类、字段和方法


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
	
	<!--注解的组件扫描-->
    <context:component-scan base-package="com.orginly"/>
</beans>

Spring 新注解

使用上面的注解还不能全部替代 xml 配置文件，还需要使用注解替代的配置如下

非自定义的 Bean 的配置（如外部引入的 Jar 包）：<bean>
加载 properties 文件的配置：<context:property-placeholder>
组件扫描的配置：<context:component-scan>

引入其他文件:<import>

注解	说明
@Configuration	用于指定当前类是一个 Spring 配置类，当创建容器时会从该类上加载注解
@Bean	使用在方法上，标注将该方法的返回值存储到 Spring 容器中
@PropertySource	加载 properties 文件中的配置
ComponentScan	用于指定 Spring 在初始化容器时要扫描的包
@Import	用于导入其他配置类