【精选】SpringDI依赖注入及注解实现SpringIoC

已于 2023-12-05 21:21:14 修改
阅读量1.1k 收藏 18
点赞数 34
分类专栏： Spring框架 文章标签： 数据库 开发语言 java spring
于 2023-11-28 07:28:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guojiaqi_/article/details/134658422
版权

SpringDI

请添加图片描述

什么是依赖注入

在这里插入图片描述

依赖注入（Dependency Injection，简称DI），它是Spring控制反转思想的具体实现。

控制反转将对象的创建交给了Spring，但是对象中可能会依赖其他对象。比如service类中要有dao类的属性，我们称service依赖于dao。之前需要手动注入属性值，代码如下：

public interface StudentDao {
  Student findById(int id);
}


public class StudentDaoImpl implements StudentDao{
  @Override
  public Student findById(int id) {
    // 模拟根据id查询学生
    return new Student(1,"张三","北京");
   }
}


public class StudentService {
  // service依赖dao，手动注入属性值，即手动维护依赖关系
  private StudentDao studentDao = new StudentDaoImpl();


  public Student findStudentById(int id){
    return studentDao.findById(id);
   }
}

此时，当StudentService的想要使用StudentDao的另一个实现类如StudentDaoImpl2时，则需要修改Java源码，造成代码的可维护性降低。

而使用Spring框架后，Spring管理Service对象与Dao对象，此时它能够为Service对象注入依赖的Dao属性值。这就是Spring的依赖注入。简单来说，控制反转是创建对象，依赖注入是为对象的属性赋值。

依赖注入方式

在这里插入图片描述

在之前开发中，可以通过setter方法或构造方法设置对象属性值：

// setter方法设置属性
StudentService studentService = new StudentService();
StudentDao studentDao = new StudentDao();
studentService.setStudentDao(studentDao);


// 构造方法设置属性
StudentDao studentDao = new StudentDao();
StudentService studentService = new StudentService(studentDao);

Spring可以通过调用setter方法或构造方法给属性赋值

Setter注入

  1. 被注入类编写属性的setter方法

    public class StudentService {
  private StudentDao studentDao;
  public void setStudentDao(StudentDao studentDao) {
    this.studentDao = studentDao;
   }
}

  2. 配置文件中，给需要注入属性值的<bean>中设置<property>

    <bean id="studentDao" class="com.Spring.dao.StudentDaoImpl"></bean>
<bean id="studentService" class="com.Spring.service.StudentService">
  <!--依赖注入-->
  <!--name:对象的属性名 ref:容器中对象的id值-->
  <property name="studentDao" ref="studentDao"></property>
</bean>

  3. 测试是否注入成功

    @Test
public void t2(){
  ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
  StudentService studentService = (StudentService) ac.getBean("studentService");
  System.out.println(studentService.findStudentById(1));
}
构造方法注入

  1. 被注入类编写有参的构造方法

    public class StudentService {
  private StudentDao studentDao;
  public StudentService(StudentDao studentDao) {
    this.studentDao = studentDao;
   }
}

  2. 给需要注入属性值的<bean>中设置<constructor-arg>

    <bean id="studentDao" class="com.Spring.dao.StudentDaoImpl"></bean>


<bean id="studentService" class="com.Spring.service.StudentService">
  <!-- 依赖注入 -->
  <!-- name:对象的属性名  ref：配置文件中注入对象的id值 -->
  <constructor-arg name="studentDao" ref="studentDao"></constructor-arg>
</bean>

  3. 测试是否注入成功

    @Test
public void t2(){
  ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
  StudentService studentService = (StudentService) ac.getBean("studentService");
  System.out.println(studentService.findStudentById(1));
}
自动注入

自动注入不需要在<bean>标签中添加其他标签注入属性值，而是自动从容器中找到相应的bean对象设置为属性值。

自动注入有两种配置方式：

  • 全局配置：在<beans>中设置default-autowire属性可以定义所有bean对象的自动注入策略。
  • 局部配置：在<bean>中设置autowire属性可以定义当前bean对象的自动注入策略。

autowire的取值如下：

  • no：不会进行自动注入。
  • default：全局配置default相当于no，局部配置default表示使用全局配置
  • byName：在Spring容器中查找id与属性名相同的bean，并进行注入。需要提供set方法。
  • byType：在Spring容器中查找类型与属性类型相同的bean，并进行注入。需要提供set方法。
  • constructor：在Spring容器中查找id与属性名相同的bean，并进行注入。需要提供构造方法。

测试自动注入：

  1. 为依赖的对象提供setter和构造方法：

    public class StudentService {
  // 依赖
  private StudentDao studentDao;
    
  // 构造方法
  public StudentService() {
   }
    
  public StudentService(StudentDao studentDao) {
    this.studentDao = studentDao;
   }
    
  // setter方法
  public void setStudentDao(StudentDao studentDao) {
    this.studentDao = studentDao;
   }
    
  // 调用依赖的方法
  public Student findStudentById(int id) {
    return studentDao.findById(id);
   }
}

  2. 配置自动注入：

    <!-- 根据beanId等于属性名自动注入 -->
<bean id="studentDao" class="com.Spring.dao.StudentDaoImpl"></bean>
<bean id="studentService" class="com.Spring.service.StudentService" autowire="byName"></bean>


    <!-- 根据bean类型等于属性类型自动注入 -->
<bean id="studentDao" class="com.Spring.dao.StudentDaoImpl"></bean>
<bean id="studentService" class="com.Spring.service.StudentService" autowire="byType"></bean>


    <!-- 利用构造方法自动注入 -->
<bean id="studentDao" class="com.Spring.dao.StudentDaoImpl"></bean>
<bean id="studentService" class="com.Spring.service.StudentService" autowire="constructor"></bean>

    <!-- 配置全局自动注入 -->
<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"
    default-autowire="constructor">

依赖注入类型

DI支持注入bean类型、基本数据类型和字符串、List集合、Set集合、Map集合、Properties对象类型等，他们的写法如下：

  1. 准备注入属性的类

    public class StudentService {
  private StudentDao studentDao; // bean属性
  private String name; //字符串类型
  private int count; //基本数据类型
  private List<String> names; // 字符串类型List集合
  private List<Student> students1; // 对象类型List集合
  private Set<Student> students2; // 对象类型Set集合
  private Map<String,String> names2; // 字符串类型Map集合
  private Map<String,Student> students3; // 对象类型Map集合
  private Properties properties; //Properties类型
  
  // 省略getter/setter/toString
}

  2. 准备测试方法

    @Test
public void t3(){
  ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
  StudentService studentService = (StudentService) ac.getBean("studentService");
  System.out.println(studentService);
}
注入bean类型

写法一：

<bean id="studentDao" class="com.Spring.dao.StudentDaoImpl"></bean>


<bean id="studentService" class="com.Spring.service.StudentService">
  <property name="studentDao" ref="studentDao"></property>
</bean>

写法二：

<bean id="studentDao" class="com.Spring.dao.StudentDaoImpl"></bean>


<bean id="studentService" class="com.Spring.service.StudentService">
  <property name="studentDao" >
    <ref bean="studentDao"></ref>
  </property>
</bean>
注入基本数据类型和字符串类型
<bean id="studentService" class="com.Spring.service.StudentService">
  <!--  写法一 name：属性名  value：属性值-->
  <property name="name" value="李四"></property>


  <!--  写法二 name：属性名  value：属性值-->
  <property name="count">
    <value>10</value>
  </property>
</bean>
注入List集合
<bean id="studentService" class="com.Spring.service.StudentService">
  <!-- 简单数据类型List集合 name：属性名 -->
  <property name="names">
    <list>
      <value>Spring</value>
      <value>张三</value>
    </list>
  </property>


  <!-- 对象类型List集合 name：属性名 -->
  <property name="students1">
    <list>
      <bean class="com.Spring.domain.Student">
        <property name="id" value="1"/>
        <property name="name" value="Spring"/>
        <property name="address" value="北京"/>
      </bean>
      <bean class="com.Spring.domain.Student">
        <property name="id" value="2"/>
        <property name="name" value="李四"/>
        <property name="address" value="北京"/>
      </bean>
    </list>
  </property>
</bean>
注入Set集合
<bean id="studentService" class="com.Spring.service.StudentService">
  <!-- Set集合 -->
  <property name="students2">
    <set>
      <bean class="com.Spring.domain.Student">
        <property name="id" value="1"/>
        <property name="name" value="Spring"/>
        <property name="address" value="北京"/>
      </bean>
      <bean class="com.Spring.domain.Student">
        <property name="id" value="2"/>
        <property name="name" value="李四"/>
        <property name="address" value="北京"/>
      </bean>
    </set>
  </property>
</bean>
注入Map集合

简单数据类型Map集合：

<bean id="studentService" class="com.Spring.service.StudentService">
  <property name="names2">
    <map>
      <entry key="student1" value="李四"/>
      <entry key="student2" value="张三"/>
    </map>
  </property>
</bean>

对象类型Map集合：

<bean id="studentService" class="com.Spring.service.StudentService">
  <property name="students3">
    <map>
      <entry key="student1" value-ref="s1"/>
      <entry key="student2" value-ref="s2"/>
    </map>
  </property>
</bean>


<bean id="s1" class="com.Spring.domain.Student">
  <property name="id" value="1"/>
  <property name="name" value="Spring"/>
  <property name="address" value="北京"/>
</bean>
<bean id="s2" class="com.Spring.domain.Student">
  <property name="id" value="2"/>
  <property name="name" value="李四"/>
  <property name="address" value="北京"/>
</bean>
注入Properties对象
<bean id="studentService" class="com.Spring.service.StudentService">
  <property name="properties">
    <props>
      <prop key="配置1">值1</prop>
      <prop key="配置2">值2</prop>
    </props>
  </property>
</bean>

注解实现IOC

准备工作

注解配置和xml配置对于Spring的IOC要实现的功能都是一样的，只是配置的形式不一样。

准备工作

  1. 创建一个新的Spring项目。

  2. 编写pojo，dao，service类。

  3. 编写空的配置文件，如果想让该文件支持注解，需要添加新的约束：

    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    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
              http://www.springframework.org/schema/context
              http://www.springframework.org/schema/context/spring-context.xsd">


</beans>

@Component

作用：用于创建对象，放入Spring容器，相当于<bean id="" class="">

位置：类上方

注意：

  • 要在配置文件中配置扫描的包，扫描到该注解才能生效。

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

  • @Component注解配置bean的默认id是首字母小写的类名。也可以手动设置bean的id值。

    // 此时bean的id为studentDaoImpl
@Component
public class StudentDaoImpl implements StudentDao{
  public Student findById(int id) {
    // 模拟根据id查询学生
    return new Student(1,"张三","北京");
   }
}

    // 此时bean的id为studentDao
    @Component(“studentDao”)
    public class StudentDaoImpl implements StudentDao{
    public Student findById(int id) {
    // 模拟根据id查询学生
    return new Student(1,“张三”,“北京”);
    }
    }

@Repository、@Service、@Controller

作用：这三个注解和@Component的作用一样，使用它们是为了区分该类属于什么层。

位置：

  • @Repository用于Dao层
  • @Service用于Service层
  • @Controller用于Controller层
@Repository
public class StudentDaoImpl implements StudentDao{}


@Service
public class StudentService {}

@Scope

作用：指定bean的创建策略

位置：类上方

取值：singleton prototype request session globalsession

@Service
@Scope("singleton")
public class StudentService {}

@Autowired

作用：从容器中查找符合属性类型的对象自动注入属性中。用于代替<bean>中的依赖注入配置。

位置：属性上方、setter方法上方、构造方法上方。

注意：

  1. @Autowired写在属性上方进行依赖注入时，可以省略setter方法。

    @Component
public class StudentService {
  @Autowired
  private StudentDao studentDao;
  public Student findStudentById(int id){
    return studentDao.findById(id);
   }
}


@Test
public void t2(){
  ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
  StudentService studentService = (StudentService) ac.getBean("studentService");
  System.out.println(studentService.findStudentById(1));
}

  2. 容器中没有对应类型的对象会报错

    // 如果StudentDaoImpl没有放到容器中会报错
//@Component("studentDao")
public class StudentDaoImpl implements StudentDao{
  public Student findById(int id) {
    // 模拟根据id查询学生
    return new Student(1,"张三","北京");
   }
}

  3. 容器中有多个对象匹配类型时，会找beanId等于属性名的对象，找不到会报错。

    // 如果容器中都多个同类型对象，会根据id值等于属性名找对象
@Component("studentDao")
public class StudentDaoImpl implements StudentDao{
  public Student findById(int id) {
    // 模拟根据id查询学生
    return new Student(1,"张三","北京");
   }
}


@Component
public class StudentDaoImpl2 implements StudentDao{
  public Student findById(int id) {
    // 模拟根据id查询学生
    return new Student(1,"张三","北京");
   }
}

@Qualifier

作用：在按照类型注入对象的基础上，再按照bean的id注入。

位置：属性上方

注意：@Qualifier必须和@Autowired一起使用。

@Component
public class StudentService {
  @Autowired
  @Qualifier("studentDaoImpl2")
  private StudentDao studentDao;
  public Student findStudentById(int id){
    return studentDao.findById(id);
   }
}

@Value

作用：注入String类型和基本数据类型的属性值。

位置：属性上方

用法：

  1. 直接设置固定的属性值

    @Service
public class StudentService {
  @Value("1")
  private int count;


  @Value("hello")
  private String str;
}

  2. 获取配置文件中的属性值：

    1. 编写配置文件db.properties

      jdbc.username=root
jdbc.password=123456

    2. spring核心配置文件扫描配置文件

      <context:property-placeholder location="db.properties"></context:property-placeholder>

    3. 注入配置文件中的属性值

      @Value("${jdbc.username}")
private String username;


@Value("${jdbc.password}")
private String password;

@Configuration

此时基于注解的IOC配置已经完成，但是我们依然离不开Spring的xml配置文件。接下来我们脱离bean.xml，使用纯注解实现IOC。

在真实开发中，我们一般还是会保留xml配置文件，很多情况下使用配置文件更加方便。

纯注解实现IOC需要一个==Java类代替xml文件。==这个Java类上方需要添加@Configuration，表示该类是一个配置类，作用是代替配置文件。

@Configuration
public class SpringConfig {  
}

@ComponentScan

作用：指定spring在初始化容器时扫描的包。

位置：配置类上方

@Configuration
@ComponentScan("com.Spring")
public class SpringConfig {
}

@PropertySource

作用：代替配置文件中的<context:property-placeholder>扫描配置文件

位置：配置类上方

注意：配置文件位置前要加关键字classpath

@Configuration
@PropertySource("classpath:db.properties")
public class JdbcConfig {
  @Value("${jdbc.username}")
  private String username;


  @Value("${jdbc.password}")
  private String password;

}

@Bean

作用：将方法的返回值对象放入Spring容器中。如果想将第三方类的对象放入容器，可以使用@Bean

位置：配置类的==方法==上方。

属性：name：给bean对象设置id

注意：@Bean修饰的方法如果有参数，spring会根据参数类型从容器中查找可用对象。

举例：如果想将jdbc连接对象放入Spring容器，我们无法修改Connection源码添加@Component，此时就需要使用将@Bean该对象放入Spring容器

  1. 添加驱动依赖

    <dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>8.0.27</version>
</dependency>

  2. 将Connection对象放入Spring容器

    @Bean(name = "connection")
public Connection getConnection(){
  try {
    Class.forName("com.mysql.cj.jdbc.Driver");
    return DriverManager.getConnection("jdbc:mysql:///mysql", "root", "root");
   } catch (Exception exception) {
    return null;
   }
}

  3. 测试

    @Test
public void t5(){
  ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfig.class);
  Connection connection = (Connection) ac.getBean("connection");
  System.out.println(connection);
}

@Import

作用：如果配置过多，会有多个配置类，该注解可以为主配置类导入其他配置类

位置：主配置类上方

// Jdbc配置类
@Configuration
public class JdbcConfig {
  @Bean(name = "connection")
  public Connection getConnection(){
    try {
      Class.forName("com.mysql.cj.jdbc.Driver");
      return DriverManager.getConnection("jdbc:mysql:///mysql", "root", "root");
     } catch (Exception exception) {
      return null;
     }
   }
}

// 主配置类
@Configuration
@ComponentScan("com.Spring")
@Import(JdbcConfig.class)
public class SpringConfig {
}

var code = "815f618f-3e13-4a85-a895-d264e6ba4547"
OldGj_
关注
  • 34
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring中基于注解的DI依赖注入
m0_53698336的博客
10-10 353
使用Spring的IoC容器，实际上就是通过类似XML这样的配置文件，把我们自己的Bean的依赖关系描述出来，然后让容器来创建并装配Bean。一旦容器初始化完毕，我们就直接从容器中获取Bean使用它们。 使用XML配置的优点是所有的Bean都能一目了然地列出来，并通过配置注入能直观地看到每个Bean的依赖。它的缺点是写起来非常繁琐，每增加一个组件，就必须把新的Bean配置到XML中。 有没有其他更简单的配置方式呢？ Bean 的装配可以理解为依赖关系注入，Bean 的装配方式也就是 Bean 的依赖注入方式
基于注解的DI依赖注入
木兮兮
09-28 402
基于注解的DI注入是目前项目中最常使用到的，使用起来也是最方便的 ，大大降低了我们开发人员对象的管理难度， 对于做javaEE开发的web项目而言，效果非常的明显 context:component-scan 标签是扫描包结构的，容器启动会扫描指定包和其子包下的的注解，这个包的可以具体指定，也可以指定一个范围比较大的顶级包，但是不建议指定范围太大的包，这样大大降低spring管理对象的性能， 需...
SpringDI--依赖注入（注解方式）
10-05 210
Spring中提供一些作用在类上： @Component　　　//每个层都可以，作用在类上 @Controller //作用在web层 @Service //作用在业务层 @Repository //作用在持久层 这三个注解都放在每层的类上面，会创建对应的对象，Component可以每层类上但建议使用其他三个注解增强 属性注解： ...
Spring DI(依赖注入)注解篇
程序员小奎的博客
01-24 719
1 课程内容介绍 我之前写的的一篇博客Spring核心功能IOC之DI(依赖注入)主要介绍了如何通过配置xml的方式来实现依赖注入，今天我们来介绍如何通过注解方式完成我们的依赖注入操作。 2 注入基本类型 创建用户类为其添加name和age的成员属性并为其提供get set方法 在User上声明@Component标签将其声明为Spirng的bean 通过@Value标签为name和age注入具...
DI以及依赖注入详解
Dream_it_possible！的博客
05-28 569
一、DI是什么？ 在应用间通常会有两个或者多个类组成，然后他们互相协作共同完成一个特定的业务逻辑，每个对象负责管理与自己相互协作的对象的引用。这将会导致高耦合难以测试的代码。 简单的说DI是能够将组件的依赖关系进行松耦合一种编程方式,让组件之间复杂的依赖关系简单化，下面演示DI的好处: package com.example.spring.DI; import lombok.extern.slf4j.Slf4j; /** * 演示在demo01里初始化d...
Spring Ioc 注解 依赖注入
05-26
### Spring IoC与注解依赖注入详解 #### 一、Spring框架简介 Spring框架是由Rod Johnson创建的一个开源项目，最初是为了解决企业级应用开发中的复杂性问题而诞生的。Spring框架的核心特性包括IoC（Inversion of ...
Spring——DI和通过注解实现IOC和DI
12-21
【Spring——DI和通过注解实现IOC和DI】 在软件设计中，依赖注入（Dependency Injection，简称DI）是一种设计模式，用于减少代码间的耦合，提高应用的可测试性和可维护性。DI的核心思想是，组件之间的依赖关系不再...
“IOC容器与DI依赖注入示例”文章提及
04-16
在Java世界中，Spring框架是应用最广泛的轻量级企业级开发框架，它的一大核心特性就是Inversion of Control（控制反转，简称IOC）和Dependency Injection（依赖注入，简称DI）。这两者是紧密相关的概念，有助于简化...
Spring与IoC系列四：基于注解的依赖注入.rar
07-26
本系列文章聚焦于Spring与IoC（Inversion of Control，控制反转）容器，特别是第四部分，我们将深入探讨基于注解的依赖注入。 传统的Spring DI是通过XML配置文件来定义Bean及其依赖关系的。然而，随着Spring的发展...
Spring依赖注入DI.zip
08-08
Spring框架的依赖注入（Dependency Injection，简称DI）是其核心特性之一，它使得应用程序的组件之间可以松散耦合，增强了代码的可测试性和可维护性。在Spring框架中，DI通过控制反转（Inversion of Control，IoC）...
DI：依赖注入
好好学习，天天向上
11-30 256
DI：依赖注入 DI版HelloWorld <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://m.
spring框架学习-依赖注入DI（注解方式）
weixin_38170065的博客
07-21 163
需要用到的注解有 1.用于创建对象的 * 他们的作用就和在XML配置文件中编写一个<bean>标签实现的功能是一样的 * @Component: * 作用：用于把当前类对象存入spring容器中 * 属性： * value：用于指定bean的id。当我们不写时，它的默认值...
Spring框架-----＞(3) 基于注解的DI（依赖注入）
hcz666的博客
01-28 636
一、基于注解的依赖注入 基于注解的di ：通过注解完成java对象创建，属性赋值 使用注解的步骤： （1）加入maven的依赖 spring-context ，在你加入spring-context的同时， 间接加入spring-aop的依赖，使用注解必须使用spring-aop依赖 （2）在类中加入spring的注解（多个不同功能的注解） （3）在spring的配置文件中，加入一个组件扫描器的标签，说明注解在你的项目中的位置 声明组件扫描器 : component-scan,组件就是对象
DI注入解析
zz1399的博客
06-01 373
DI-依赖注入。spring两大核心，IOC和DI，IOC是控制反转，是一种设计模式，简单来讲就是将我们的实体类交给spring来管理，一般现在常用的是注解@Component，然后在applicationContext.xml中配置包扫描。而DI是IOC的另一种理解方式，现在更着重体现在注入方面，用于解决主键之间的装配问题。我们现在常用的@Autowired注解就是DI的一个具体使用，是基于注解的依赖注入的核心注解。
Spring 依赖注入（DI）详解 [Spring][依赖注入的 6 种实现方式][setter注入][构造器注入][注解注入][自动装配注入][静态工厂注入][实例工厂注入]
码农阿杰的博客
05-14 3213
依赖注入，英文叫做 `Dependency Injection`，简称 `DI`。 DI 和 IoC （[《Spring IoC 容器详解》](https://blog.csdn.net/manongajie/article/details/105943336)）含义相同，它们是从两个角度描述的同一个概念、做同一件事情。
16-注解开发依赖注入
最新发布
记录java学习日常~
06-20 181
常见的配置文件格式包括 .properties 和 .xml 两种。而 .xml 则是一种更加复杂、结构化的格式，适合用于保存一些对象或者复杂类型的配置项。例如：
Spring官方文档解读（二）之DI依赖注入详解，通俗易懂，小白也可轻松get
xjx666666的博客
12-11 1044
为什么会有依赖注入？典型的企业应用程序不包含单个对象(这里就是指Spring中的 bean)。即使是最简单的应用程序，也有一些对象可以协同工作（属性依赖的形式），以呈现最终用户视为一体的应用程序。在Spring中所有对象的控制权利我们都交由IoC容器了，所以这里我们无法手动为这些对象再进行操作，那么就需要IoC容器来帮助我们完成这一操作。
Spring依赖注入(DI)之注解形式
旭日的芬芳
09-22 1188
目录 1.前言 2.使用注解实现IOC 3. IOC相关的注解 3.1 为什么会需要使用这些注解？ 3.2 相关的注解 3.2.1 类的定义注解 3.2.2 注入相关的注解 4. 源码分析 4.1 初始化过程 4.2 Bean的获取 4.3 Autowired的工作原理 4.4 如果确保被自动装配的对象在装配时已经完成初始化？ 1.前言 上一篇文章中《Spring 控制反转(IOC)及依赖注入(DI)》https://blog.csdn.net/luofen521/article
Java依赖注入(DI)实例详解
热门推荐
青山师
05-09 1万+
Java依赖注入模式允许我们摆脱硬编码，使我们的应用更加松耦合、增强扩展性以及可维护性。通过依赖注入我们可以降低从编译到运行时的依赖性。 Java依赖注入 Java的依赖注入仅仅通过理论是很难解明白的，所以我们通过几个简单的示例来描述它，怎样利用依赖注入模式降低我们应用之间的耦合性和增强可扩展性。 假设我们的应用需要通过 EmailService 去发送email，通常情况下，我们是这样实
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值