spring的控制反转和依赖注入讲解

最新推荐文章于 2024-02-25 08:30:00 发布
最新推荐文章于 2024-02-25 08:30:00 发布
阅读量880 收藏 7
点赞数 1
分类专栏： Spring 文章标签： spring java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/llx522/article/details/124949883
版权

1.Spring

1.1 简介

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.1.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.1.RELEASE</version>
</dependency>

1.2 优点

  • Spring是开源的免费的容器！

  • 是一个轻量级的非入侵式的框架！

  • 控制反转(IOC)，面向切面编程（AOP）

  • 支持事务的处理，对框架整合的支持！

1.3 组成

在这里插入图片描述

1.4 扩展

  • Spring Boot

    • 一个快速开发的脚手架
    • 基于SpringBoot快速开发微服务
    • 约定大于配置

  • Spring Cloud

    • Spring Cloud是基于SpringBoot实现

  • 学习SpringBoot的前提是学习Spring和SpringMVC

2、IOC理论推导

原来的写法：

1.UserDao接口

2.UserDaoImpl实现类

3.UserService业务接口

4.UserServiceImpl实现类

在之前的业务中，用户的需求会影响代码，根据用户需求修改原代码成本非常高！

我们使用一个Set接口实现，使用set注入后，程序不再具有主动性

Dao层的实现类：

public class UserDaoImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("获取用户数据");
    }
}

public class UserSqlServerImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("sqlserver 获取用户数据");
    }
}

Service层，不需要写死dao层的代码：

 private UserDao userDao;
    //利用set进行动态实现值的注入！
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void getUser() {
        userDao.getUser();
    }

测试：

public class MyTest {
    public static void main(String[] args) {
        //用户调用是业务层，dao层不需要接触
        UserServiceImpl userService = new UserServiceImpl();
        userService.setUserDao(new UserSqlServerImpl());
        userService.getUser();
    }
}

控制反转（主动权变了，程序不再具有主动性，变成被动接受对象）这种思想，从本质上解决了问题，程序员不用再去管理对象的创建了。系统的耦合性大大降低

IOC本质：

控制反转IOC（Inversion of Control）是一种设计思想，DI（依赖注入）是实现ioc的一种方法，所谓的控制反转就是：获得依赖对象的方式反转了

在这里插入图片描述

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式，在Spring中实现控制反转的是IOC容器，其实现方法是依赖注入（DI）

3、HelloSpring

public class Hello {
    private String str;
    public String getStr() {
        return str;
    }
    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }
}

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

    <!--使用spring来创建对象，在spring都称为bean
    类型 变量名 = new Hello()

    id = 变量名
    class = new 的对象
    property相当于给对象中的属性设置一个值
	ref:引用spring容器中创建好的对象
	value:具体的值
    -->
    <bean id="hello" class="com.liu.pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>

 </beans>

测试：

import com.liu.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        //获取spring的上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //对象都在spring中的管理了，直接取出来使用
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.toString());
    }
}

思考问题：

  • Hello对象是谁创建的？

    hello对象是Spring创建的

  • Hello对象的属性是怎么设置的？

    hello对象的属性由Spring容器设置的

  • 创建bean的时候就创建了对象

这个过程就叫控制反转（原来需要我们new一个对象，现在由容器生成，我们只用从容器中拿即可）

  • 控制：谁来控制对象的创建，传统应用程序的对象由程序本身控制创建的，使用spring后，对象由spring来创建

  • 反转：程序本身不创建对象，变成被动的接收对象

  • 依赖注入：利用set方法进行注入

  • IOC是一种变成思想，由主动的变成变成被动的接收，由spring创建，管理

4、IOC创建对象的方式

1.使用无参构造方法创建对象！默认实现

package com.liu.pojo;

public class User {
    private String name;
    public User(){
        System.out.println("User的无参构造！");
    }

    public String getName(){
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

<?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="user" class="com.liu.pojo.User">
        <property name="name" value="liuxiang"/>
    </bean>

</beans>

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        User user = (User) context.getBean("user");
        System.out.println(user);
    }
}

在这里插入图片描述

2.通过有参构造实现

  • 下标赋值
<!--下标赋值-->
    <bean id="user" class="com.liu.pojo.User">
       <constructor-arg index="0" value="liuxiang"/>
    </bean>
  • 类型赋值(不建议使用)
<bean id="user" class="com.liu.pojo.User">
    <constructor-arg type="java.lang.String" value="liuxiang"/>
</bean>
  • 通过参数名
<bean id="user" class="com.liu.pojo.User">
    <constructor-arg name="name" value="刘想"/>
</bean>

5、Spring配置

5.1 别名

<alias name="user" alias="llx"/>

5.2 Bean的配置

id：bean的唯一标识符，相当于对象名

class：bean对象所对应的全限定名（包名+类型）

name：别名，更高级，可以取多个别名（空格，逗号，分号都可以分隔）

5.3 import

一般用于团队开发，可以将多个配置文件导入合并为一个

applicationContext.xml总的配置文件：

<import resource="beans.xml"/>
<import resource="beans2.xml"/>
<import resource="beans3.xml"/>

6、依赖注入

6.1 构造器注入

无参有参构造器注入：

 <bean id="user" class="com.liu.pojo.User">
        <property name="name" value="liuxiang"/>
    </bean>

<bean id="user" class="com.liu.pojo.User">
    <constructor-arg name="name" value="刘想"/>
</bean>

<bean id="user" class="com.liu.pojo.User">
    <constructor-arg type="java.lang.String" value="liuxiang"/>
</bean>

6.2 set注入（重点）

依赖注入：set注入

  • 依赖：bean对象的创建依赖于容器
  • 注入：bean对象中的所有属性由容器来注入

环境搭建：

  • 复杂类型
public class Address {
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
    @Override
    public String toString() {
        return "Address{" +
                "address='" + address + '\'' +
                '}';
    }
}
  • 真实测试
private String name;
private Address address;
private String[] books;
private List<String> hobbys;
private Map<String,String> card;
private Set<String> games;
private Properties info;
  • beans.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">


    <bean id="address" class="com.liu.pojo.Address">
        <property name="address" value="深圳"/>
    </bean>

    <bean id="student" class="com.liu.pojo.Student">
        <!--第一种，普通的value值-->
        <property name="name" value="刘想"/>
        <!--第二种，bean注入-->
        <property name="address" ref="address"/>
        <!--数组注入-->
        <property name="books">
            <array>
                <value>Java核心</value>
                <value>Go语言</value>
                <value>黑客技术</value>
                <value>JVM</value>
            </array>
        </property>
        <!--List-->
        <property name="hobbys">
            <list>
                <value>听歌</value>
                <value>游戏</value>
                <value>音乐</value>
            </list>
        </property>
        <!--map-->
        <property name="card">
            <map>
                <entry key="身份证" value="421023111111112222"/>
                <entry key="手机号" value="17777776666"/>
            </map>
        </property>
        <!--set-->
        <property name="games">
            <set>
                <value>lol</value>
                <value>吃鸡</value>
                <value>王者</value>
            </set>
        </property>
        <!--Properties-->
        <property name="info">
            <props>
                <prop key="driver">com.mysql.driver</prop>
                <prop key="url">jdbc//mysql:3306</prop>
                <prop key="username">root</prop>
                <prop key="password">123456</prop>
            </props>
        </property>
    </bean>

</beans>
  • 测试类
public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        Student student = (Student) context.getBean("student");
        System.out.println(student);
    }
}
  • 结果

Student{name='刘想',
address=Address{address='深圳'},
books=[Java核心, Go语言, 黑客技术, JVM],
hobbys=[听歌, 游戏, 音乐],
card={身份证=421023111111112222, 手机号=17777776666},
games=[lol, 吃鸡, 王者],
info={password=123456,
     url=jdbc//mysql:3306,
     driver=com.mysql.driver,
     username=root}}

6.3 扩展方式注入

  • P命名注入（就是property）

导入头文件约束：

<beans
xmlns:p="http://www.springframework.org/schema/p"
</beans>

可以注入属性的值！

  • c命名空间

就是构造器注入！

导入头文件约束：

<beans
xmlns:p="http://www.springframework.org/schema/c"
</beans>

7、Bean作用域

在这里插入图片描述

单例模式（Spring默认机制）：全局共享唯一，创建的对象都是一样的

<bean id="user2" class="com.liu.pojo.User" c:age="18" c:name="刘想" scope="singleton"/>

原型模式：创建的对象不一样，每次从容器get的时候都会产生新对象！

<bean id="user2" class="com.liu.pojo.User" c:age="18" c:name="刘想" scope="prototype"/>

其余的request、session、application这些只能在web开发中使用！

牛牛的Java学习之旅
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
实例讲解Java的Spring框架中的控制反转和依赖注入
09-02
主要介绍了Java的Spring框架中的控制反转和依赖注入,Spring是Java的SSH三大web开发框架之一,需要的朋友可以参考下
java面试Spring.pdf
01-25
IOC，Inversion of Control，控制反转 AOP(Aspect-OrientedProgramming)，面向切面编程 Spring AOP里面常用名词的概念： Spring容器的启动流程 Spring Bean的生命周期？ Spring中bean的作用域 说一下Spring基于xml...
详解Spring框架----控制反转与依赖注入
qq_44227032的博客
06-24 1049
Spring是一个轻量级的框架，它的主要特点是控制反转IOC（Inversion Of Control）和面向切面AOP。好处：可以降低程序的耦合，便于编码。
[javaweb]——spring框架之控制反转(IOC)与依赖注入(DI)
Panci_的博客
10-28 2222
spring框架的两大核心思想：控制反转，面向切面编程。控制反转：简称IOC，对象的创建控制权由程序自身转移到外部（容器），这种思想称为控制反转依赖注入：简称DI，容器为程序提供运行时所依赖的资料，称为依赖注入。Bean对象：IOC容器中创建、管理的对象叫bean对象最后缕一缕：1.由于代码的高内聚(多功能混一块了)，我们设计了出三层架构模式，Controller Service Dao，2.但是代码的耦合问题(一个模块对另一模块有依赖)没有解决，于是就有了控制反转与依赖注入，这两步合起来就是分层解耦。
Spring 控制反转与依赖注入
莫等闲 白了少年头 空悲切
02-25 1765
控制反转（IoC）强调的是控制权的转移，而依赖注入（DI）则强调的是依赖关系的注入。在Spring框架中，我们使用IoC容器来管理对象的生命周期，并通过依赖注入的方式来实现对象之间的解耦和管理依赖关系。
Spring框架的控制反转和依赖注入
qq_63437335的博客
04-18 572
依赖注入的基本思想是：明确地定义组件接口，独立开发各个组件，然后根据组件的依赖关系组装运行。在使用依赖注入时，如果注入的是 Bean 对象，那么要求注入的 Bean 对象与被注入的 Bean 对象都需要 Spring IOC 容器来实例化。配置信息后，会通过反射方式调用实例的构造方法，如果是有参构造方法，可以在构造方法中传入所需的参数值，最后创建类对象。最主流的注入方法，这种注入方法简单、直观，它是在被注入的类中声明一个。被依赖的实例，构造方法可以是有参的或者是无参的。依赖注入通常有两种实现方式，一种是。
Java学习---Spring依赖注入和控制反转
weixin_63108463的博客
08-08 488
Java学习
Spring依赖注入、控制反转、面向切面编程三大特性详解（含示例代码）
一叶知秋
06-16 1174
Spring 框架是一个开源的企业级应用程序开发框架，它提供了许多功能和特性，但主要包括以下三大核心特性：依赖注入（Dependency Injection，DI）： 依赖注入是 Spring 的核心特性之一。它通过控制反转（Inversion of Control，IOC）实现对象之间的解耦。在传统的编程模型中，对象自己负责创建和管理它所依赖的对象，而在 Spring 中，容器负责创建对象，并将依赖关系注入到对象中。这样可以提高代码的可维护性、可测试性和松耦合性。
Spring Security、Spring Social 、Spring Security OAuth
09-04
它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring IoC，DI（控制反转Inversion of Control ,DI:Dependency Injection 依赖注入）和AOP（面向切面编程）功能，为应用系统提供声明式的安全访问控制...
Spring框架进阶：成为Java技术大牛的秘密.zip
最新发布
03-08
文章涵盖了Spring框架的模块化设计、控制反转（IoC）、依赖注入（DI）、面向切面编程（AOP）、Spring MVC和Web开发、Spring Data和数据访问等内容。此外，文中还提供了实践项目开发的建议，帮助读者将所学知识运用到...
Spring重要概念 AOP DI 讲解
12-31
Spring重要概念 AOP DI 讲解,20来页课件,讲解最关键的两个特性 控制反转/依赖注入 和 面向切面编程.
Spring：IoC（控制反转、依赖注入、循环依赖）
燕双嘤
01-21 1503
1，IoC（Spring的核心和基础） 1.1，IoC原理 纵观所有的Java应用（从基于Applet的小应用到多层结构的企业级应用），这些应用中大量存在A对象调用B对象方法的情况，者请情况被Spring称为依赖，即A对象依赖B对象。对于Java应用而言，它们总是由一些相互调用的对象构成的，Spring把这种相互调用的关系称为依赖关系。假如A组件调用了B组件的方法，即可称A组件依赖B组件。 Spring框架的核心功能有两个： Spring容器作为超级大工厂，负责创建、管理所有的Java对象，这些J
十道Spring选择题及解析。
bhegi_seg的博客
08-28 5141
解析：ApplicationContext是BeanFactory的子接口，ApplicationContext对象里面包含了BeanFactory的所有功能，并提供了一些扩展，比如更容易同SpringAOP特性整合，资源文件的处理，Spring为ApplicationContext提供的3种实现分别为：ClassPathXmlApplicationContext，FileSystemXmlApplicationContext和XmlWebApplicationContext。（AOP的好处，可背）...
Spring依赖注入与控制反转
Bugxiu_fu的博客
08-16 342
spring容器的依赖注入，与案例实现
Spring依赖注入与反转控制到底是个啥？
Cheney的博客
02-14 299
依赖注入是反转控制的一种实现方法，我个人认为依赖外置比依赖注入更好理解，当然我可能理解的不太深刻有错误。因为原来的程序是直接在A里面实例化B，如果B变了那将导致很多业务代码需要改，这种依赖关系又是无法消除的，只能减弱这种依赖。那么，可以考虑将依赖写到配置文件中，需要的时候注入即可，这里将依赖写到配置文件可以说是依赖外置，但是Spring在运行时是实例化对象然后通过Set或者构造方法将其注入到A类中，因此，这是一个相对的说法。从A类角度出发是外置，从Spring角度是注入。以上内容有错误希望指正！
Spring学习总结【二】---IoC(控制反转)
weixin_42190209的博客
03-02 479
文章目录IoC理论推导IoC本质工作原理IoC创建对象的方式 IoC理论推导 在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改原代码，如果程序代码量十分大，修改一次的成本代价十分昂贵! 之前，程序是主动创建对象，控制权在程序猿手上。 使用了set注入后，程序不再具有主动性，而是变成了被动的接受对象。 这种思想，从本质上解决了问题，我们程序猿不用再去管理对象的创建了。系统的耦合性大大降低，可以更加专注的在业务的实现上！ 这是IOC的原型！ IoC本质 控制反转IoC(
spring控制反转与依赖注入
qq_51700372的博客
05-20 1153
1）什么是控制反转 传统的编程思路是，当我需要某个对象时，我便自己去实例化调用它 。而控制反转则是，当我需要某个对象时，自然有人帮我们实例化它 。简单的来说，这是一种衣来张口，饭来伸手式的控制模式，这也符合spring最根本的使命--简化java开发 。 2）什么是依赖注入 依赖注入，即是SpringIOC的一种实现方式，在我们完成业务开发的过程中，需要引入的依赖，都由交由spring容器管理注入 。简单的说，就是由spring容器替我们实例化对象 。 3）依赖注入解决了什么问题 在传统的业务实现
Spring框架：控制反转以及依赖注入
mr_xioabai的博客
03-30 151
在传统的 Java 应用中，一个类想要调用另一个类中的属性或方法，通常会先在其代码中通过 new Object() 的方式将后者的对象创建出来，然后才能实现属性或方法的调用。为了方便理解和描述，我们可以将前者称为“调用者”，将后者称为“被调用者”。也就是说，调用者掌握着被调用者对象创建的控制权。但在 Spring 应用中，Java 对象创建的控制权是掌握在 IoC 容器手里的，其大致步骤如下。
Spring的控制反转与依赖注入
qq_43418737的博客
01-18 770
Spring的控制反转(Ioc)和依赖注入(DI)理解
spring中控制反转和依赖注入的关系
06-01
Spring中控制反转（IoC）和依赖注入（DI）是密不可分的概念。控制反转是一种设计模式，它将对象的创建和管理交给了...在Spring中，控制反转和依赖注入是紧密相关的，它们共同构成了Spring框架的核心思想和实现方式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值