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. 完全注解方式(配置类+注解)是现在主流配置方式

思维导图总结

在这里插入图片描述

  • 9
    点赞
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值