Spring 控制反转和依赖注入的具体使用

目录
  • 控制反转的类型
    • 1.依赖查找
      • 1.1依赖拉取
      • 1.2上下文依赖查找
    • 2.依赖注入
      • 2.1构造函数注入
      • 2.2setter函数注入
  • Spring中的控制反转
    • 1.Bean和BeanFactory
    • 2.设置Spring配置
      • 2.1XML配置
      • 2.2注解配置
      • 2.3Java配置
    • 3.setter注入
    • 4.构造函数注入

控制反转的类型

控制反转(IOC)旨在提供一种更简单的机制,来设置组件的依赖项,并在整个生命周期管理这些依赖项。通常,控制反转可以分成两种子类型:依赖注入(DI)和依赖查找(DL),这些子类型各自又可以被进一步分解为 IOC 服务的具体实现

1. 依赖查找

1.1 依赖拉取

依赖拉取(Dependency Pull),即根据需要,从注册表中提取依赖项,以下代码显示了基于 Spring 的依赖拉取

public class DependencyPull {

    public static void main(String[] args) {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("spring/app-context.xml");
        ctx.getBean("renderer", MessageRenderer.class);
    }
}

1.2 上下文依赖查找

上下文依赖查找(contextualized dependency lookup,CDL),同样属于依赖查找的子类型,和依赖拉取有点类似,但在 CDL 中,查找是针对管理资源的容器执行的,这个容器通常由应用程序服务器或框架(Tomcat、JBoss、Spring)提供,比如以下代码显示了一个提供依赖查找服务的容器接口

public interface Container {
    // 根据key获取相应的依赖项
    Object getDependency(String key);
}

CDL 通过让组件实现以下代码接口来进行工作

public interface ManagedComponent {
    void performLookup(Container container);
}

组件需要实现该接口,当容器准备好将依赖项传递给组件时,会依次调用每个组件的 performLookup() 方法,然后组件就可以使用 Container 接口查找所需的依赖项

public class ContextualizedDependencyLookup implements ManagedComponent {

    private Dependency dependency;

    @Override
    public void performLookup(Container container) {
        this.dependency = (Dependency) container.getDependency("myDependency");
    }

    @Override
    public String toString() {
        return dependency.toString();
    }
}

2. 依赖注入

2.1 构造函数注入

当在组件的构造函数中提供依赖项时,就会发生构造函数依赖注入

public class ConstructorInjection {

    private Dependency dependency;

    public ConstructorInjection(Dependency dependency) {
        this.dependency = dependency;
    }

    @Override
    public String toString() {
        return dependency.toString();
    }
}

2.2 setter 函数注入

Ioc 容器通过 JavaBean 样式的 setter 方法注入组件的依赖项

public class SetterInjection {

    private Dependency dependency;

    public void setDependency(Dependency dependency) {
        this.dependency = dependency;
    }

    @Override
    public String toString() {
        return dependency.toString();
    }
}

在 Spring 中,还支持另一种被称为字段注入(field injection)的注入类型,在后面学习使用 @Autowire 注解进行自动装配时将介绍该注入类型

Spring 中的控制反转

1. Bean 和 BeanFactory

Spring 的依赖注入容器的核心是 BeanFactory,它负责管理组件,包括依赖项以及它们的生命周期。如果我们想获得一个组件(Bean),就必须创建一个实现了 BeanFactory 接口的实例,并对其进行配置

虽然 BeanFactory 可以通过编程方式配置,但更常见的做法是使用某种配置文件在外部对其进行配置。Bean 配置可以由实现 BeanDefinition 接口的类的实例来表示,对于任何实现了 BeanDefinitionReader 接口的 BeanFactory 实现类来说,都可以使用 PropertiesBeanDefinitionReader 或 XmlBeanDefinitionReader 从配置文件读取 BeanDefinition 数据

定义一组接口:

public interface Oracle {
    String output();
}

public class OracleImpl implements Oracle {

    @Override
    public String output() {
        return "hello world";
    }
}

接下来我们来看一看,Spring 的 BeanFactory 如何被初始化并用于获取 Bean 实例

public class XmlConfigWithBeanFactory {

    public static void main(String[] args) {
        // DefaultListableBeanFactory是Spring提供的两个主要BeanFactory实现之一
        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
        XmlBeanDefinitionReader rdr = new XmlBeanDefinitionReader(factory);
        // 使用XmlBeanDefinitionReader从XML文件读取BeanDefinition信息
        rdr.loadBeanDefinitions(new ClassPathResource("spring/xml-bean-factory-config.xml"));
        // 使用在XML配置文件中配置的名称oracle来获取bean
        Oracle oracle = (Oracle) factory.getBean("oracle");
        System.out.println(oracle.getInfo());
    }
}
<?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="oracle" name="oracle" class="com.example.OracleImpl"/>

</beans>

ApplicationContext 接口是 BeanFactory 的一个扩展,除了 DI 服务外,还提供其他如事务和 AOP 等服务。在开发基于 Spring 的应用程序时,建议通过 ApplicationContext 接口与 Spring 交互

2. 设置 Spring 配置

2.1 XML 配置

对于 XML 配置,需要声明应用程序需要的由 Spring 提供的名称空间基础信息,下面所示配置仅声明用于定义 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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="provider" class="com.example.HelloWorldMessageProvider"/>

    <bean id="render" class="com.example.StandardOutMessageRender"
          p:messageProvider-ref="provider"/>

</beans>

2.2 注解配置

要想在应用程序使用 Spring 的注解支持,需要在 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
            http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.example" />

</beans>

<context:component-scan> 标记告诉 Spring 扫描代码,从而找到 @Component 等注解注入的 bean,以及支持在指定包(及其所有子包)下使用 @Autowire 等注解的 bean

2.3 Java 配置

配置类使用 @Configuration 注解,并包含用 @Bean 注解的方法,这些方法由 IOC 容器直接调用来实例化 bean,bean 名称与用于创建它的方法的名称相同

@Configuration
public class HelloWorldConfiguration {

    @Bean
    public MessageProvider provider() {
        return new HelloWorldMessageProvider();
    }

    @Bean
    public MessageRender render() {
        StandardOutMessageRender render = new StandardOutMessageRender();
        render.setMessageProvider(provider());
        return render;
    }
}

如果想从该类中读取配置信息,需要一个不同的 ApplicationContext 实现

public class HelloWorldSpringAnnotated {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx
                = new AnnotationConfigApplicationContext(HelloWorldConfiguration.class);
        MessageRender render = ctx.getBean("render", MessageRender.class);
        render.render();
    }
}

3. setter 注入

使用 XML 配置来配置 setter 注入,需要在 <bean> 标记下指定 <property> 标记,为其注入一个依赖项

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="provider" class="com.example.HelloWorldMessageProvider"/>

    <bean id="render" class="com.example.StandardOutMessageRender">
        <property name="messageProvider" ref="provider"/>
    </bean>

</beans>

如果使用注解,只需要向 setter 方法添加一个 @Autowired 注解

@Service("render")
public class StandardOutMessageRender implements MessageRender {

	...

    @Override
    @Autowired
    public void setMessageProvider(MessageProvider messageProvider) {
        this.messageProvider = messageProvider;
    }
}

4. 构造函数注入

public class ConfigurableMessageProvider implements MessageProvider {

    private String message;

    public ConfigurableMessageProvider(String message) {
        this.message = message;
    }

    @Override
    public String getMessage() {
        return null;
    }
}

使用 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:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="oracle" name="oracle" class="com.example.OracleImpl"/>

    <!-- 使用 <constructor-arg> 标记 -->
    <bean id="messageProvider" class="com.example.ConfigurableMessageProvider">
        <constructor-arg value="hello world" />
    </bean>

    <!-- 使用c名称空间 -->
    <bean id="provider" class="com.example.ConfigurableMessageProvider"
            c:message="hello world"/>

</beans>

使用注解方式

@Service
public class ConfigurableMessageProvider implements MessageProvider {

    private String message;

    @Autowired
    public ConfigurableMessageProvider(
            @Value("hello world") String message) {
        this.message = message;
    }

    @Override
    public String getMessage() {
        return null;
    }
}

到此这篇关于Spring 控制反转和依赖注入的具体使用的文章就介绍到这了,更多相关Spring 控制反转和依赖注入内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • 实例讲解Java的Spring框架中的控制反转和依赖注入

    近来总是接触到 IoC(Inversion of Control,控制反转).DI(Dependency Injection,依赖注入)等编程原则或者模式,而这些是著名 Java 框架 Spring.Struts 等的核心所在.针对此查了 Wikipedia 中各个条目,并从图书馆借来相关书籍,阅读后有些理解,现结合书中的讲解以及自己的加工整理如下: eg1 问题描述: 开发一个能够按照不同要求生成Excel或 PDF 格式的报表的系统,例如日报表.月报表等等.   解决方案: 根据"面向接口编

  • 理解Spring中的依赖注入和控制反转

    学习过Spring框架的人一定都会听过Spring的IoC(控制反转) .DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IoC .DI这两个概念是模糊不清的,是很难理解的,今天和大家分享网上的一些技术大牛们对Spring框架的IOC的理解以及谈谈我对Spring Ioc的理解. IoC是什么 Ioc-InversionofControl,即"控制反转",不是什么技术,而是一种设计思想.在Java开发中,Ioc意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内

  • Spring 控制反转和依赖注入的具体使用

    目录 控制反转的类型 1.依赖查找 1.1依赖拉取 1.2上下文依赖查找 2.依赖注入 2.1构造函数注入 2.2setter函数注入 Spring中的控制反转 1.Bean和BeanFactory 2.设置Spring配置 2.1XML配置 2.2注解配置 2.3Java配置 3.setter注入 4.构造函数注入 控制反转的类型 控制反转(IOC)旨在提供一种更简单的机制,来设置组件的依赖项,并在整个生命周期管理这些依赖项.通常,控制反转可以分成两种子类型:依赖注入(DI)和依赖查找(DL)

  • C++设计模式中控制反转与依赖注入浅析

    目录 控制反转 依赖注入(DI) 依赖注入框架(DI Framework) 依赖反转原则(DIP) 控制反转 “控制”指的是对程序执行流程的控制,而“反转”指的是在没有使用框架之前,程序员自己控制整个程序的执行.在使用框架之后,整个程序的执行流程可以通过框架来控制.流程的控制权从程序员“反转”到了框架. 大白话说,就是原先直接用main函数中的代码流程,转移到了框架中去. #include <iostream> #include <list> using namespace std

  • 详解Spring的核心机制依赖注入

    详解Spring的核心机制依赖注入 对于一般的Java项目,他们都或多或少有一种依赖型的关系,也就是由一些互相协作的对象构成的.Spring把这种互相协作的关系称为依赖关系.如A组件调用B组件的方法,可称A组件依赖于B组件,依赖注入让Spring的Bean以配置文件组织在一起,而不是以硬编码的方式耦合在一起 一.理解依赖注入 依赖注入(Dependency Injection) = 控制反转(Inversion ofControl,IoC):当某个Java实例(调用者)需另一个Java实例(被调

  • 深入了解Spring控制反转IOC原理

    目录 一.什么是Spring IOC容器 二.IOC有哪些优点 三.控制反转(IOC)有什么作用 四.IoC和DI有什么区别 五.Spring IoC的实现机制 六.IoC支持哪些功能 七.BeanFactory和ApplicationContext有什么区别 八.ApplicationContext通常的实现是什么 九.依赖注入的方式,构造器依赖注入和 Setter方法注入的区别 十.依赖注入的基本原则和优点 一.什么是Spring IOC容器 Spring是包含众多工具的IoC容器,控制反转

  • 浅谈Spring IoC容器的依赖注入原理

    本文介绍了浅谈Spring IoC容器的依赖注入原理,分享给大家,具体如下: IoC容器初始化的过程,主要完成的工作是在IoC容器中建立 BeanDefinition 数据映射,并没有看到IoC容器对Bean依赖关系进行注入, 假设当前IoC容器已经载入用户定义的Bean信息,依赖注入主要发生在两个阶段 正常情况下,由用户第一次向IoC容器索要Bean时触发 但我们可以在 BeanDefinition 信息中通过控制 lazy-init 属性来让容器完成对Bean的预实例化,即在初始化的过程中就

  • Spring入门基础之依赖注入

    目录 一.构造器注入 二.set注入 三.其他方式注入 (1)导入约束 (2)p命名注入 (3)c命名注入 一.构造器注入 在前几节已经做过了详细的说明讲解,我们先跳过 二.set注入 依赖注入 依赖: bean对象的创建以及管理都依赖于Spring IOC容器 注入: bean对象中的所有属性,都有容器进行注入 在前面我们已经见识过了 普通类型注入和 bean注入的方式,那么对于复杂类型List.数组类型.Map.Set属性等怎么进行注入呢? 我们先提供一个包含各种类型的实体类 Student

  • Java Spring 控制反转(IOC)容器详解

    目录 什么是容器? 无侵入容器 IOC控制反转 IOC理论推导 传统应用程序开发的弊端 "注入"机制 小结 IOC本质 DI(依赖注入) 总结 IoC 容器是 Spring 的核心,也可以称为 Spring 容器.Spring 通过 IoC 容器来管理对象的实例化和初始化,以及对象从创建到销毁的整个生命周期. Spring 中使用的对象都由 IoC 容器管理,不需要我们手动使用 new 运算符创建对象.由 IoC 容器管理的对象称为 Spring Bean,Spring Bean 就是

  • Spring bean为什么需要依赖注入

    目录 具体步骤: 样例1: 样例2: Spring单例模式和原型模式 一.单例模式 二.原型模式 思考 为什么需要依赖注入 总结 具体步骤: 1.创建一个maven项目 spring-day1-constructor 2.导入依赖 <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <!--这里是java 版本号--> <maven.compil

  • Spring使用Setter完成依赖注入方式

    目录 对依赖注入的理解 使用Setter完成不同类型属性的注入 整体配置文件 Spring解决setter方式的循环依赖的原理 对依赖注入的理解 依赖:实体间的所有依赖由容器创建 注入:容器负责完成实体间依赖互相注入的任务 使用Setter完成不同类型属性的注入 实体类Student package indi.stitch.pojo; import java.util.*; public class Student { private String name; private Address a

随机推荐