spring Ioc、DI

---

前言

spring Ioc以及DI配置

---

一、Spring Ioc容器

1、概念

Spring IoC 容器，负责实例化、配置和组装 bean（组件）。容器通过读取配置元数据来获取有关要实例化、配置和组装组件的指令。

IoC（控制反转） 主要是针对对象的创建和调用控制而言的。不再是应用程序直接创建该对象，而是由 IoC 容器来创建和管理，即控制权由应用程序转移到 IoC 容器中。

DI（依赖注入）在组件之间传递依赖关系的过程中，将依赖关系在容器内部进行处理，实现了对象之间的解耦合。通过 XML 配置文件或注解的方式实现的。它提供了三种形式的依赖注入：构造函数注入、Setter 方法注入和接口注入。

2、具体接口和实现类

二、实现步骤

1、配置元数据，编写交给SpringIoC容器管理组件的信息。（三种配置方式）
2、实例化Ioc容器
3、获取Bean（组件）

配置方式

XML配置方式:
通过在XML文件中定义Bean及其依赖关系、Bean的作用域等信息
注解方式:
通过在Bean类上使用注解来代替XML配置文件中的配置信息。通过在Bean类上加上相应的注解（如@Component, @Service, @Autowired等）
Java配置类方式:
通过Java类来定义Bean、Bean之间的依赖关系和配置信息，从而代替XML配置文件的方式。通过@Configuration、@Bean等注解来实现Bean和依赖关系的配置

1、基于xml配置

（1）准备spring项目和组件

导入依赖pom.xml

<dependencies>
    <!--spring context依赖-->
    <!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>6.0.6</version>
    </dependency>
</dependencies>

实例化对象

基于无参数构造函数
a.准备组件类

package com.atguigu.ioc;
public class HappyComponent {
    //默认包含无参数构造函数
    public void doWork() {
        System.out.println("HappyComponent.doWork");
    }
}

b.xml配置文件编写

<!-- [重要]创建bean -->
<bean id="happyComponent" class="com.atguigu.ioc.HappyComponent"/>
- bean标签：通过配置bean标签告诉IOC容器需要创建对象的组件信息
- id属性：bean的唯一标识,方便后期获取Bean！
- class属性：组件类的全限定符！

基于静态工厂方法实例化
a.准备组件类

public class ClientService {
private static ClientService clientService = new ClientService();
  private ClientService() {}
  public static ClientService createInstance() {
    return clientService;
  }
}

b.xml配置文件编写

<bean id="clientService" class="examples.ClientService"
  factory-method="createInstance"/>
-class属性：指定工厂类的全限定符！
-factory-method: 指定静态工厂方法，注意，该方法必须是static方法。

基于实例工厂方法实例化
a.准备组件类

public class DefaultServiceLocator {
  private static ClientServiceImplclientService = new ClientServiceImpl();
  public ClientService createClientServiceInstance() {
    return clientService;
  }
}

b.xml配置文件编写

<!-- 将工厂类进行ioc配置 -->
<bean id="serviceLocator" class="examples.DefaultServiceLocator"></bean>
<!-- 根据工厂对象的实例工厂方法进行实例化组件对象 -->
<bean id="clientService"
  factory-bean="serviceLocator"
  factory-method="createClientServiceInstance"/>
- factory-bean属性：指定当前容器中工厂Bean 的名称。
- factory-method:  指定实例工厂方法名。注意，实例方法必须是非static的！

（2）组件Bean注入依赖（DI）

基于构造函数的依赖注入
a.组件类

public class UserDao {}
public class UserService {
    private UserDao userDao;
    //单个构造参数
    public UserService(UserDao userDao) {
        this.userDao = userDao;
    }
    //多构造参数解析
     public UserService(int age , String name ,UserDao userDao) {
        this.userDao = userDao;
        this.age = age;
        this.name = name;
    }
}

b.编写配置文件

<beans>
  <!-- 引用类bean声明 -->
  <bean id="userService" class="x.y.UserService">
    <!--多构造函数加入值-->
    <!-- value直接注入基本类型值 -->
    <constructor-arg  value="18"/>
    <constructor-arg  value="赵伟风"/>
    
   <!-- 构造函数引用 -->
    <constructor-arg ref="userDao"/>
  </bean>
  <!-- 被引用类bean声明 -->
  <bean id="userDao" class="x.y.UserDao"/>
</beans>
constructor-arg标签：可以引用构造参数 ref引用其他bean的标识。

基于setter方法依赖注入
a.组件类

public Class MovieFinder{}
public class SimpleMovieLister {
  private MovieFinder movieFinder; 
  private String movieName;
  public void setMovieFinder(MovieFinder movieFinder) {
    this.movieFinder = movieFinder;
  }
  public void setMovieName(String movieName){
    this.movieName = movieName;}
}

b.编写配置文件

<bean id="simpleMovieLister" class="examples.SimpleMovieLister">
  <!-- setter方法，注入movieFinder对象的标识id
       name = 属性名  ref = 引用bean的id值-->
  <property name="movieFinder" ref="movieFinder" />
 <!-- setter方法，注入基本数据类型movieName
       name = 属性名 value= 基本类型值-->
  <property name="movieName" value="消失的她"/>
</bean>
<bean id="movieFinder"class="examples.MovieFinder"/>

（3）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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 配置自动扫描的包 -->
    <!-- 1.包要精准,提高性能!
         2.会扫描指定的包和子包内容
         3.多个包可以使用,分割 例如: com.atguigu.controller,com.atguigu.service等-->
    <context:component-scan base-package="com.atguigu.components"/>
</beans>

指定排除组件

<context:component-scan base-package="com.atguigu.components">
    <!-- context:exclude-filter标签：指定排除规则 -->
    <!-- type属性：指定根据什么来进行排除，annotation取值表示根据注解来排除 -->
    <!-- expression属性：指定排除规则的表达式，对于注解来说指定全类名即可 -->
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

指定扫描组件

<!-- 仅扫描 = 关闭默认规则 + 追加规则 -->
<!-- use-default-filters属性：取值false表示关闭默认扫描规则 -->
<context:component-scan base-package="com.atguigu.ioc.components" use-default-filters="false">
    <!-- context:include-filter标签：指定在原有扫描规则的基础上追加的规则 -->
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

（4）Ioc容器创建和使用

a.容器实例化

//方式1:实例化并且指定配置文件
//参数：String...locations 传入一个或者多个配置文件
ApplicationContext context = 
           new ClassPathXmlApplicationContext("services.xml", "daos.xml");        
//方式2:先实例化，再指定配置文件，最后刷新容器触发Bean实例化动作 [springmvc源码和contextLoadListener源码方式]  
ApplicationContext context = 
           new ClassPathXmlApplicationContext();   
//设置配置配置文件,方法参数为可变参数,可以设置一个或者多个配置
iocContainer1.setConfigLocations("services.xml", "daos.xml");
//后配置的文件,需要调用refresh方法,触发刷新配置
iocContainer1.refresh();           

b.Bean对象读取

//方式1: 根据id获取
//没有指定类型,返回为Object,需要类型转化!
HappyComponent happyComponent = 
        (HappyComponent) iocContainer.getBean("bean的id标识");
//使用组件对象        
happyComponent.doWork();
//方式2: 根据类型获取
//根据类型获取,但是要求,同类型(当前类,或者之类,或者接口的实现类)只能有一个对象交给IoC容器管理
//配置两个或者以上出现: org.springframework.beans.factory.NoUniqueBeanDefinitionException 问题
HappyComponent happyComponent = iocContainer.getBean(HappyComponent.class);
happyComponent.doWork();
//方式3: 根据id和类型获取
HappyComponent happyComponent = iocContainer.getBean("bean的id标识", HappyComponent.class);
happyComponent.doWork();
/*根据类型来获取bean时，在满足bean唯一性的前提下，其实只是看：『对象 instanceof 指定的类型』的返回结果，
只要返回的是true就可以认定为和类型匹配，能够获取到。*/

FactoryBean

2、基于注解方式

和XML 配置文件一样，注解本身并不能执行，注解本身仅仅只是做一个标记。（步骤同上）
配置总结
a. 注解方式IoC只是标记哪些类要被Spring管理
b. 最终，我们还需要XML方式或者后面讲解Java配置类方式指定注解生效的包

（1）组件添加标记注解

注解直接添加在java类上 (代码如上)

准备组件类

/* description: 普通的组件*/
@Component
public class CommonComponent {}
/*description: controller类型组件*/
@Controller
public class XxxController {}
/* description: service类型组件*/
@Service
public class XxxService {}
/* description: dao类型组件*/
@Repository
public class XxxDao {}

组件BeanName问题
类名首字母小写就是 bean 的 id。例如：SoldierController 类对应的 bean 的 id 就是 soldierController。

使用value属性指定：

@Controller(value = "tianDog")
public class SoldierController {
}
//当注解中只设置一个属性时，value属性的属性名可以省略：
@Controller("tianDog")
### （1）组件周期方法注解
我们可以在组件类中定义方法，然后当IoC容器实例化和销毁组件对象的时候进行调用！这两个方法我们成为生命周期方法！类似于Servlet的init/destroy方法,我们可以在周期方法完成初始化和释放资源等工作。

**a、周期方法声明**
```java
public class BeanOne {
  //周期方法要求： 方法命名随意，但是要求方法必须是 public void 无形参列表
  @PostConstruct  //注解制指定初始化方法
  public void init() {// 初始化逻辑}
}
public class BeanTwo {
  @PreDestroy //注解指定销毁方法
  public void cleanup() {// 释放资源逻辑}
}

（2）组件作用域配置

Bean作用域概念
<bean 标签声明Bean，只是将Bean的信息配置给SpringIoC容器！标签对应的信息转成Spring内部 BeanDefinition 对象(包含id，class，属性等等)
作用域可选值

@Scope(scopeName = ConfigurableBeanFactory.SCOPE_SINGLETON) //单例,默认值
@Scope(scopeName = ConfigurableBeanFactory.SCOPE_PROTOTYPE) //多例  二选一
public class BeanOne {
  @PostConstruct  //注解制指定初始化方法
  public void init() {// 初始化逻辑 }
}

（3）引用类型自动装配（DI）

场景

• SoldierController 需要 SoldierService
• SoldierService 需要 SoldierDao
• 同时在各个组件中声明要调用的方法。

自动装配实现
前提：参与自动装配的组件（需要装配、被装配）全部都必须在IoC容器中。
@Autowired注解
不需要提供setXxx()方法
标记位置：成员变量、构造方法、setXXX()方法
例子：

@Controller(value = "tianDog")
public class SoldierController {  
    @Autowired
    private SoldierService soldierService;
    public void getMessage() {
        soldierService.getMessage();
    }
}

（4）基本类型属性赋值

@Value 通常用于注入外部化属性
步骤
1、声明外部配置 application.properties

catalog.name=MovieCatalog

2、xml引入外部配置

<!-- 引入外部配置文件-->
<context:property-placeholder location="application.properties" />

3、@Value注解读取配置

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public class CommonComponent {
    /**
     * 情况1: ${key} 取外部配置key对应的值!
     * 情况2: ${key:defaultValue} 没有key,可以给与默认值
     */
    @Value("${catalog:hahaha}")
    private String name;
}

注解+XML IoC方式问题

a、 自定义类可以使用注解方式，但是第三方依赖的类依然使用XML方式！
b、XML格式解析效率低！

3、基于配置类方式

完全注解配置（通过 Java配置类代码来配置 Spring 应用程序，使用注解来替代原本在 XML 配置文件中的配置）

（1）配置类和扫描注解

xml+注解方式

//1、配置文件application.xml
//2、创建IoC容器
  // xml方式配置文件使用ClassPathXmlApplicationContext容器读取
 ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("application.xml");

配置类+注解方式（完全注解方式）
（a) 配置类
使用 @Configuration 注解将一个普通的类标记为 Spring 的配置类。

//标注当前类是配置类，替代application.xml    
@Configuration
//使用注解读取外部配置，替代 <context:property-placeholder标签
@PropertySource("classpath:application.properties")
//使用@ComponentScan注解,可以配置扫描包,替代<context:component-scan标签
@ComponentScan(basePackages = {"com.atguigu.components"})
public class MyConfiguration {}

（b）测试创建IoC容器

// AnnotationConfigApplicationContext 根据配置类创建 IOC 容器对象
ApplicationContext iocContainerAnnotation = 
new AnnotationConfigApplicationContext(MyConfiguration.class);

（2）@Bean组件

场景需求：将Druid连接池对象存储到IoC容器
需求分析：第三方jar包的类，添加到ioc容器，无法使用@Component等相关注解！因为源码jar包内容为只读模式！
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"
xmlns:context="http://www.springframework.org/schema/context"  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 引入外部属性文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!-- 实验六 [重要]给bean的属性赋值：引入外部属性文件 -->
    <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${jdbc.url}"/>
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="username" value="${jdbc.user}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
</beans>

配置类方式实现
@Bean（<bean） 注释用于指示方法实例化、配置和初始化要由 Spring IoC 容器管理的新对象。

//标注当前类是配置类，替代application.xml    
@Configuration
//引入jdbc.properties文件
@PropertySource({"classpath:application.properties","classpath:jdbc.properties"})
@ComponentScan(basePackages = {"com.atguigu.components"})
public class MyConfiguration {
    //如果第三方类进行IoC管理,无法直接使用@Component相关注解
    //解决方案: xml方式可以使用<bean标签
    //解决方案: 配置类方式,可以使用方法返回值+@Bean注解
    @Bean
    public DataSource createDataSource(@Value("${jdbc.user}") String username,
                                       @Value("${jdbc.password}")String password,
                                       @Value("${jdbc.url}")String url,
                                       @Value("${jdbc.driver}")String driverClassName){
        //使用Java代码实例化
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        dataSource.setUrl(url);
        dataSource.setDriverClassName(driverClassName);
        //返回结果即可
        return dataSource;
    }
}

注解+配置类 IoC方式总结

1. 完全摒弃了XML配置文件
2. 自定义类使用IoC和DI注解标记
3. 第三方类使用配置类声明方法+@Bean方式处理
4. 完全注解方式（配置类+注解）是现在主流配置方式

思维导图总结