Spring控制反转和依赖注入超详细讲解_Java

概念

什么是 ioc

ioc（inversion of control），即控制反转，是一种设计原则，指的是将对象的创建、依赖关系的管理，从代码内部转移到外部容器（比如spring容器）中去控制，从而让开发者不再手动管理这些依赖关系。

简单来说：

原本是由程序员主动控制去创建对象和管理依赖，现在这个控制权交给了spring容器，由它来负责创建对象并注入依赖，这就是控制权的“反转”。

传统方式（没有ioc）：

public class userservice {
    // 手动创建依赖对象
    private userrepository userrepo = new userrepositoryimpl(); 
}

使用ioc方式：

applicationcontext context = new classpathxmlapplicationcontext("spring-config.xml");

hellospring hellospring = (hellospring) context.getbean("hellospring");

什么是 di

di（dependency injection），即依赖注入，是 ioc 的一种实现方式。

依赖注入是指：将对象所依赖的其他对象（依赖项），通过某种方式“注入”到该对象中，而不是由该对象自己去创建或查找这些依赖。

换句话说，di 是 ioc 的具体技术手段，是 spring 用来实现 ioc 的主要方法。

引入jar包

在pom.xml引入下面jar包

<properties>
    <spring.version>4.0.2.release</spring.version>
  </properties>

  <dependencies>
    <dependency>
      <groupid>junit</groupid>
      <artifactid>junit</artifactid>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <!-- spring框架包 -->
    <dependency>
      <groupid>org.springframework</groupid>
      <artifactid>spring-test</artifactid>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupid>org.springframework</groupid>
      <artifactid>spring-core</artifactid>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupid>org.springframework</groupid>
      <artifactid>spring-oxm</artifactid>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupid>org.springframework</groupid>
      <artifactid>spring-tx</artifactid>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupid>org.springframework</groupid>
      <artifactid>spring-jdbc</artifactid>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupid>org.springframework</groupid>
      <artifactid>spring-aop</artifactid>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupid>org.springframework</groupid>
      <artifactid>spring-context</artifactid>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupid>org.springframework</groupid>
      <artifactid>spring-context-support</artifactid>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupid>org.springframework</groupid>
      <artifactid>spring-expression</artifactid>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupid>org.springframework</groupid>
      <artifactid>spring-orm</artifactid>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupid>org.springframework</groupid>
      <artifactid>spring-web</artifactid>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupid>org.springframework</groupid>
      <artifactid>spring-webmvc</artifactid>
      <version>${spring.version}</version>
    </dependency>
    <!-- lombok 可是省去pojo类中的get和set方法 -->
    <dependency>
      <groupid>org.projectlombok</groupid>
      <artifactid>lombok</artifactid>
      <version>1.18.24</version>
    </dependency>

    <dependency>
      <groupid>javax.annotation</groupid>
      <artifactid>javax.annotation-api</artifactid>
      <version>1.2</version>
    </dependency>


  </dependencies>

引入maven后通过resources直接建立spring-config.xml文件

测试控制反转和依赖注入

在com.hz下建立hellospring类

@data //注解实现get和set方法
public class hellospring {
    private string name;

    public void sayhello(){
        system.out.println("hello spring"+ name);
    }

}

在spring-config.xml下建立相应的bean

<!-- 创建一个 com.hz.hellospring类的实例，bean 的 id 是 hellospring。-->
    <bean id="hellospring" class="com.hz.hellospring">
        <!-- 给 com.hz.hellospring类下的属性为：name的赋值，值为value：lisi-->
        <property name="name" value="lisi"></property>
    </bean>

建立测试

public class hellospringtest {

    @test
    public void sayhello() {
        //使用classpathxmlapplicationcontext读取配置文件
        applicationcontext context = new classpathxmlapplicationcontext("spring-config.xml");

        //不是hellospring hellospring = new hellospring()了
        hellospring hellospring = (hellospring) context.getbean("hellospring");

        hellospring.sayhello();
    }
}

输出hello spring lisi

测试控制反转和依赖注入2

在com.hz.dao下建立userdao接口

public interface userdao {
    public int adduser();
}

在com.hz.dao.impl下建立userdaoimpl类

public class userdaoimpl implements userdao {
    @override
    public int adduser() {
        system.out.println("userdaoimpl的adduser方法");
        return 0;
    }
}

在com.hz.service下建立userservice接口

public interface userservice {
    public int adduser();

}

在com.hz.service.impl下建立userserviceimpl类

@data
public class userserviceimpl implements userservice {
    private userdao userdao;

    public int adduser() {
        return userdao.adduser();
    }
}

项目结构：

在spring-config.xml下建立相应的bean

<!--    spring 会实例化一个 userdaoimpl对象，并把它管理起来，你可以用 id "userdao"来引用它。-->
    <bean id="userdao" class="com.hz.dao.impl.userdaoimpl"></bean>

    <bean id="userservice" class="com.hz.service.impl.userserviceimpl">
<!--        表示要给这个 userserviceimpl对象中的名为 userdao的属性（通常是成员变量）注入一个值。
            注入的方式是通过 调用 setuserdao(...)方法（也就是 javabean 规范的 setter 方法），把一个引用类型的值传进去
      其中 name="userdao"→ 指的是目标 bean 中的属性名（一般对应成员变量 private userdao userdao;的字段名，且要求有对应的 setter 方法：setuserdao(...)）
      其中 ref="userdao"→ 表示要注入的是另一个 bean，这个 bean 的 id 是 "userdao"（也就是你在上面或别处定义的 com.hz.dao.impl.userdaoimpl对象）
                     -->
        <property name="userdao" ref="userdao"></property>
    </bean>

建立测试

public class userserviceimpltest {

    @test
    public void adduser() {
        //使用classpathxmlapplicationcontext读取配置文件
        applicationcontext context = new classpathxmlapplicationcontext("spring-config.xml");

        userservice userservice = (userservice) context.getbean("userservice");


        userservice.adduser();
    }
}

使用注解实现ioc和依赖注入

之前在spring-config.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
       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.hz.dao,com.hz.service"/>

注解：

spring ioc常用注解

@component：实现bean组件的定义

@repository([实例化名称]) ：用于标注dao类

@service([实例化名称]) ：用于标注业务类

@autowired+@qualifier("userdao")等价于@resource(name = "userdao")

component和repository与service的作用相同，主要是为了区分dao包和service包

以示例2开启讲解

在原用的基础上改造com.hz.dao.impl下的userdaoimpl类

@repository
public class userdaoimpl implements userdao {
    @override
    public int adduser() {
        system.out.println("userdaoimpl的adduser方法");
        return 0;
    }
}

@repository（"userdao"）相当于：<bean id="userdao" class="com.hz.dao.impl.userdaoimpl"></bean>

@repository值是系统默认赋值，值为当前类的类名，首字母小写即userdaoimpl

在原用的基础上改造com.hz.service.impl下的userserviceimpl类

@service
@data
public class userserviceimpl implements userservice {
    @autowired
    private userdao userdao;

    @override
    public int adduser() {
        return userdao.adduser();
    }
}

@service和@repository效果相同

@autowired相当于

<bean id="userdao" class="com.hz.dao.impl.userdaoimpl"></bean>

<bean id="userservice" class="com.hz.service.impl.userserviceimpl">
<property name="userdao" ref="userdao"></property>
</bean>

下的<property name="userdao" ref="userdao"></property>,系统会自动赋值

建立测试

public class userserviceimpltest {

    @test
    public void adduser() {
        //使用classpathxmlapplicationcontext读取配置文件
        applicationcontext context = new classpathxmlapplicationcontext("spring-config.xml");
        userservice userservice = (userservice) context.getbean("userserviceimpl");
        userservice.adduser();
    }
}

输出：userdaoimpl的adduser方法

总结

到此这篇关于spring控制反转和依赖注入的文章就介绍到这了,更多相关spring控制反转和依赖注入内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

Spring控制反转和依赖注入超详细讲解

2025年10月20日 • Java •我要评论

概念

什么是 ioc

什么是 di

引入jar包

测试控制反转和依赖注入

测试控制反转和依赖注入2

使用注解实现ioc和依赖注入

总结

相关文章:

Java 通配符详解：?、? extends、? super 一篇搞懂

Spring配置文件和mybatis详解

Java异常报错: java.io.IOException: Broken pipe解决方案

发表评论


验证码：