Spring——DI

最新推荐文章于 2022-07-07 13:08:29 发布
最新推荐文章于 2022-07-07 13:08:29 发布
阅读量212 收藏 2
点赞数
分类专栏： Spring学习 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52815442/article/details/121052652
版权

一 依赖注入

1.1 什么是依赖注入

1.2 @Bean注入

   spring IOC容器提供了依赖注入功能，可以将一个组件依赖到的对象，在使用之前注入到合适位置

  spring IOC解决依赖注入；在配置类congfig中为Bean组件初始化方法增加参数，spring IOC容器会在初始化时候自动根据类型注入Bean组件对象

案例：

 1.创建Saw

package cn.tedu.demo;

import java.io.Serializable;

/**
 * @Author Mr WeiLiang
 * @Date 2021/8/5 0005 09:22
 * @Version 1.0
 */
public class Saw implements Serializable {
    private String name="开天斧";

    @Override
    public String toString() {
        return name;
    }
}

 2.创建Worker

package cn.tedu.demo;

import java.io.Serializable;

/**
 * @Author Mr WeiLiang
 * @Date 2021/8/5 0005 09:22
 * @Version 1.0
 */
public class Worker implements Serializable {
    private String name="光头强";

    public Saw saw;

    public void work(){
        System.out.println(name + "使用" + saw +"砍树");
    }

}

 3.创建配置文件

package cn.tedu.context;

import cn.tedu.demo.Saw;
import cn.tedu.demo.Worker;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author Mr WeiLiang
 * @Date 2021/8/5 0005 09:22
 * @Version 1.0
 */
@Configuration
public class Config {
    @Bean
    public Saw saw(){
        return new Saw();
    }

    @Bean
    /**
     * spring会自动根据变量类型匹配Bean组件的类型
     * 如果匹配上，就将Bean组件注入到方法参数中*/
    public Worker worker(Saw s){
        Worker worker = new Worker();
        worker.saw=s;
        return worker;
    }
}

 4.测试案例

package cn.tedu.test;

import cn.tedu.context.Config;
import cn.tedu.demo.Worker;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @Author Mr WeiLiang
 * @Date 2021/8/5 0005 09:22
 * @Version 1.0
 */
public class TestCase {

    AnnotationConfigApplicationContext ctx;
    @Before
    public void init(){
        ctx=new AnnotationConfigApplicationContext(Config.class);
    }
    @After
    public void destroy(){
        ctx.close();
    }
    @Test
    public void testWorker(){
        Worker worker = ctx.getBean("worker", Worker.class);
        worker.work();
    }
}

 运行结果：

光头强使用开天斧砍树

   spring IOC组件注入时候组件自动匹配规则：

  1. 首先按照注入参数类型查找相应类型的Bean组件，如果没有直接报错误
  2. 如果在是spring容器中能够匹配上唯一类型的Bean组件，则进行注入成功
  3. 如果按照类型匹配到两个bean组件，则查找组件ID和变量名是否匹配，如果匹配则注入成功
  4. 如果组件类型和组件ID都不能很好匹配则报错

注入失败案例

package cn.tedu.context;

import cn.tedu.demo.Saw;
import cn.tedu.demo.Worker;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

/**
 * @Author Mr WeiLiang
 * @Date 2021/8/5 0005 09:22
 * @Version 1.0
 */
@Configuration
public class Config {
    @Bean
    public Saw saw(){
        return new Saw();
    }
    @Bean
    public Saw saw2(){
        return new Saw();
    }

    @Bean
    /**
     * spring会自动根据变量类型匹配Bean组件的类型
     * 如果匹配上，就将Bean组件注入到方法参数中*/
    public Worker worker(Saw s){
        Worker worker = new Worker();
        worker.saw=s;
        return worker;
    }
}

运行结果：

org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'worker' defined in cn.tedu.context.Config: Unsatisfied dependency expressed through method 'worker' parameter 0; nested exception is org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'cn.tedu.demo.Saw' available: expected single matching bean but found 2: saw,saw2

碰到这种问题，只需要将需要注入的类型名改为@Bean相同的类型名

1.3 @Autowired

  spring提供的组件扫描功能，在扫描时候也可以完成依赖注入，这样可以减少编码提高编程效率

案例

创建电锯类Saw

package cn.tedu.demo;

import org.springframework.stereotype.Component;

import java.io.Serializable;

/**
 * @Author Mr WeiLiang
 * @Date 2021/8/5 0005 09:22
 * @Version 1.0
 */
@Component
public class Saw implements Serializable {
    private String name="开天斧";

    @Override
    public String toString() {
        return name;
    }
}

创建工人类Worker

package cn.tedu.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.Serializable;

/**
 * @Author Mr WeiLiang
 * @Date 2021/8/5 0005 09:22
 * @Version 1.0
 */
@Component
public class Worker implements Serializable {
    private String name="光头强";

    @Autowired
    public Saw saw;

    public void work(){
        System.out.println(name + "使用" + saw +"砍树");
    }

}

创建配置类

package cn.tedu.context;

import cn.tedu.demo.Saw;
import cn.tedu.demo.Worker;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * @Author Mr WeiLiang
 * @Date 2021/8/5 0005 09:22
 * @Version 1.0
 */
@Configuration
@ComponentScan(basePackages = "cn.tedu.demo")
public class Config {
    
}

测试案例

package cn.tedu.test;

import cn.tedu.context.Config;
import cn.tedu.demo.Worker;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @Author Mr WeiLiang
 * @Date 2021/8/5 0005 09:22
 * @Version 1.0
 */
public class TestCase {

    AnnotationConfigApplicationContext ctx;
    @Before
    public void init(){
        ctx=new AnnotationConfigApplicationContext(Config.class);
    }
    @After
    public void destroy(){
        ctx.close();
    }
    @Test
    public void testWorker(){
        Worker worker = ctx.getBean("worker", Worker.class);
        worker.work();
    }
}

测试结果

光头强使用开天斧砍树

1.4 set方法注入

 测试案例：

 

二 IOC/DI解耦

2.1 利用接口解耦

   利用spring IOC容器提供的DI可以将工具对象注入给工人对象，继而解决之间的依赖关系，并且由于依赖于接口，所以利用spring IOC就可以控制组件的组合关系，实现松耦合

案例：利用spring实现解耦

声明工具接口

package cn.tedu.demo2;

/**
 * @Author Mr WeiLiang
 * @Date 2021/8/5 0005 09:22
 * @Version 1.0
 */
/**
 * 抽象的工具类型
 * */
public interface Tool {
}

声明工人类

package cn.tedu.demo2;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.Serializable;

/**
 * @Author Mr WeiLiang
 * @Date 2021/8/5 0005 09:22
 * @Version 1.0
 */
@Component
public class Worker implements Serializable {
    private String name="光头强";

    @Autowired
    private Tool tool;

    public void work(){
        System.out.println(name + "使用" + tool +"砍树");
    }
}

声明电锯类

package cn.tedu.demo2;

/**
 * @Author Mr WeiLiang
 * @Date 2021/8/5 0005 09:22
 * @Version 1.0
 */
public class Saw implements Tool{
    private String name="小锯子";

    @Override
    public String toString() {
        return name;
    }
}

声明斧子类

package cn.tedu.demo2;

import org.springframework.stereotype.Component;

import java.io.Serializable;

/**
 * @Author Mr WeiLiang
 * @Date 2021/8/5 0005 09:22
 * @Version 1.0
 */
@Component
public class Axe implements Serializable,Tool{
    private String name="开天斧";

    @Override
    public String toString() {
        return name;
    }
}

配置类

package cn.tedu.context2;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * @Author Mr WeiLiang
 * @Date 2021/8/5 0005 09:22
 * @Version 1.0
 */
@Configuration
@ComponentScan(basePackages = "cn.tedu.demo2")
public class Config {
}

测试类

package cn.tedu.test;

import cn.tedu.context2.Config;
import cn.tedu.demo2.Worker;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @Author Mr WeiLiang
 * @Date 2021/8/5 0005 09:22
 * @Version 1.0
 */
public class TestCase2 {
    AnnotationConfigApplicationContext ctx;

    @Before
    public void init(){
        ctx=new AnnotationConfigApplicationContext(Config.class);
    }
    @After
    public void destroy(){
        ctx.close();
    }
    @Test
    public void testWorker(){
        Worker worker = ctx.getBean("worker", Worker.class);
        worker.work();
    }
}

测试结果

光头强使用开天斧砍树

2.2 @Autowired注入规则

  

 

 案例：将斧子类和电锯类都加上@Component注解

1.在斧子类上设置自定义BeanID

package cn.tedu.demo2;

import org.springframework.stereotype.Component;

import java.io.Serializable;

/**
 * @Author Mr WeiLiang
 * @Date 2021/8/5 0005 09:22
 * @Version 1.0
 */
@Component("tool")
public class Axe implements Serializable,Tool{
    private String name="开天斧";

    @Override
    public String toString() {
        return name;
    }
}

测试结果：

光头强使用开天斧砍树

2.重构Worker类，设定@Qualifier("saw")

package cn.tedu.demo2;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

import java.io.Serializable;

/**
 * @Author Mr WeiLiang
 * @Date 2021/8/5 0005 09:22
 * @Version 1.0
 */
@Component
public class Worker implements Serializable {
    private String name="光头强";

    @Autowired
    @Qualifier("saw")
    private Tool tool;

    public void work(){
        System.out.println(name + "使用" + tool +"砍树");
    }
}

测试结果：

光头强使用小锯子砍树

2.3 同时使用@Bean @Component

  

1.利用@Bean在配置类Config中声明组件

package cn.tedu.context2;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

import java.util.Date;

/**
 * @Author Mr WeiLiang
 * @Date 2021/8/5 0005 09:22
 * @Version 1.0
 */
@Configuration
@ComponentScan(basePackages = "cn.tedu.demo2")
public class Config {
    @Bean
    public Date date(){
        return new Date();
    }
}

 2.利用@Component声明组件，注入Date类型组件

package cn.tedu.demo2;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * @Author Mr WeiLiang
 * @Date 2021/8/5 0005 09:22
 * @Version 1.0
 */
@Component
public class Employee {
    private String name="傻狍子";

    @Autowired
    private Date date;

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

3.测试案例

@Test
    public void testEmployee(){
        Employee employee = ctx.getBean("employee", Employee.class);
        System.out.println(employee);
    }

测试结果：输出当前系统时间，表示Date注入成功

Employee{name='傻狍子', date=Sat Oct 30 21:32:46 CST 2021}

案例：@Component 声明的组件注入到@Bean声明的组件

1.声明Bean类型

package cn.tedu.demo2;

/**
 * @Author Mr WeiLiang
 * @Date 2021/8/5 0005 09:22
 * @Version 1.0
 */
public class Dept {
    private String name="小良哥";
    private Employee manager;

    public void setManager(Employee manager){
        this.manager=manager;
    }

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

2.在配置类Config中利用@Bean声明Bean组件

@Bean
    public Dept dept(Employee employee){
        Dept dept = new Dept();
        dept.setManager(employee);
        return dept;
    }

3.测试案例

@Test
    public void testDept(){
        Dept dept = ctx.getBean("dept", Dept.class);
        System.out.println(dept);
    }

测试结果

ept{name='小良哥', manager=Employee{name='傻狍子', date=Sat Oct 30 21:47:32 CST 2021}}

3 使用Properties文件

3.1 Druld 连接池

案例：

1. 导入连接池

 

2.配置Config.java

 

 测试

测试结果

 

3.2 @PropertlesSource 和 Envlronment

   案例：

 

 

 3.3 @Value

  利用@Value可以读取当前系统环境Environment中的信息，注入到变量中，这个方式更加灵活方便

 

 

卿魚仮面ライダー
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringIOC详解自动注入与自动装配
qq_46993700的博客
06-01 5304
文章目录一、Spring介绍二、IOC（一）什么是IOC（二）实现的两种方式（三）使用案例（四）Bean注入方式（重点）（五）Bean的作用域（六）Bean的自动装配（重点）（七）bean的使用方式（重点） 一、Spring介绍 Spring：春天---->给软件行业带来了春天！ Spring是一个开源的轻量级 Java 开发应用框架，其目的是用于简化企业级应用程序开发 Spring框架即以interface21框架为基础，经过重新设计，并不断丰富内涵，于2004年3月24日，发布了1.0正式版。
狂神说Spring04：自动装配
热门推荐
狂神说
04-19 1万+
狂神说Spring系列连载课程，通俗易懂，基于Spring最新版本，欢迎各位狂粉转发关注学习。禁止随意转载，转载记住贴出B站视频链接及公众号链接！Bean的自动装配自动装配说明自动装配是...
02 Spring-DI
蟑螂恶霸的博客
01-03 641
1 依赖注入 1.1 什么是依赖注入 依赖注入（dependency injection）的意思为，给予调用方它所需要的事物。“依赖”是指可被方法调用的事物。依赖注入形式下，调用方不再直接指使用“依赖”，取而代之是“注入”。"注入”是指将“依赖”传递给调用方的过程。 要想搞清楚这个“依赖注入”就必须理解什么是“依赖”，依赖就是指一个业务功能执行期间所需要的前提，比如：做米饭以米为前提，则做米饭功能依赖为米，汽车需要汽油才能跑起来，则汽车跑依赖于汽油，再比如光头强砍树需要用到电锯，则光头强砍树依赖于电锯。 注
6.spring的各种IOC注入方式3——自动注入
weixin_44137201的博客
08-24 328
实体类Teacher public class Teacher { private long id; private String name; private Student student; public Teacher() {} public Teacher(Student student) { this.student = student; } public long getId() { return id; } public void setId(long id) {
spring IOC的注入方式总结_学习笔记
滨海之君的博客
12-10 467
学习资源来自博客园 springIoC容器注入方式有set注入，构造器注入，注解注入。 一、set方式注入 1.set方式注入之对象的注入 　<!-- 基于set方法的注入 --> <bean name="stu" class="com.cnblogs.bean.Student"> <property name="sNo" value="1001"></property> <property name="name" va
Spring(一) IOC原理 以及注入
qq_44630167的博客
07-09 634
1、Spring 框架概述 1、Spring 是轻量级的开源的 JavaEE 框架 2、Spring 可以解决企业应用开发的复杂性 3、Spring 有两个核心部分：IOC 和 Aop （1）IOC：控制反转，把创建对象过程交给 Spring 进行管理 （2）Aop：面向切面，不修改源代码进行功能增强 4、Spring 特点 （1）方便解耦，简化开发 （2）Aop 编程支持 （3）方便程序测试 （4）方便和其他框架进行整合 （5）方便进行事务操作 （6）降低 API 开发难度 2、IOC 容器 （1.
spring 认证--2--Spring DI--依赖注入/IOC-DI解耦
weixin_58580280的博客
09-06 805
目录 一 依赖注入 1 什么是依赖注入 2 @Bean注入 2.1 测试@Bean组件注入的作用: 2.2 Spring IOC组件注入时组件自动匹配通过类型和Bean Id匹配 3 @Autowired 自动装配(布线) 4 set方法注入(Bean属性注入) 一 依赖注入 1 什么是依赖注入 2 @Bean注入 Spring IOC容器提供了依赖注入功能,可以将一个组件依赖的对象,在使用之前注入到合适位置.比如,如下关系模拟了光头强砍树时依赖电锯. Sp...
springIoC容器注入方式
weixin_45363671的博客
04-26 553
** springIoC容器注入方式有set注入，构造器注入，注解注入。 ** 一：set方式注入 1.先准备几个bean类，一个普通的学生类，以及一个A类，A类组合了学生类对象。 Student.java 复制代码 package com.cnblogs.bean; public class Student { // 学号 private String sNo; private String name; private int age; // 性别 private String sex; //年级 pri
容器中的组件注入（多种方式）
Serendipity的博客
09-13 412
@Configuration+@Bean 前置 创建User和Pet类 public class User { private String name; private Integer age; public User(){ } public User(String name, Integer age) { this.name = name; this.age = age; } public String getN
Spring入门（二）快速入门 - IOC/DI
weixin_46030002的博客
07-07 404
超基础，超详细的 Spring IOC/DI 快速入门 值得拥有
Spring IOC介绍与4种注入方式
聚沙成塔
10-16 837
Spring IOC介绍 spring的核心思想是IOC和AOP，IOC-控制反转，是一个重要的面向对象编程的法则来消减计算机程序的耦合问题，控制反转一般分为两种类型，依赖注入和依赖查找，依赖什么？为什么需要依赖？注入什么？控制什么？依赖注入和控制反转是一样的概念吗？接触新的知识，今天主要来简单的介绍一下在spring IOC中依赖注入的方法。 依赖注入和控制反转，目的是为了使类与类之间解耦合...
spring IoC之组件注入
justisme的博客
02-28 181
spring IoC组件注入方法，基于XML、基于外部文件、基于注解的Bean注入。
Spring IOC 自动注入
理想主义的花终将盛开在浪漫主义的土壤里，我的热情永远不会熄灭在现实的平凡之中，我们终将上岸，阳光万里。
11-02 383
Spring IOC 自动注入 注解方式注入Bean 对于bean的注入，除了使用xml配置以外，可以使用注解配置。注解的配置，可以简化配置文件，提高开发的速度，使程序看上去更简洁。 对于注解的解释，Spring对于注解有专门的解释器，对于定义的注解进行解析，实现对应bean对象的注入。通过反射技术实现。 准备环境 1.修改配置文件 2.开启自动化注入 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.sprin
Spring-DI依赖注入
Silly011的博客
04-10 614
DI依赖注入 1.构造器注入 Ioc创建对象方式已经用过构造器注入了 2. Set方式注入【重点】 依赖注入：Set注入！ 依赖 bean对象的创建依赖于容器 注入 bean对象中的所有属性，由容器来注入 【环境搭建】 1.复杂类型 2.真实测试对象 1.新建Module——spring-04-DI 2.新建Address类 package com.kuang.pojo; public class Address { private String address;
02-SpringIOC配置详解
Yh360311的博客
06-24 629
大家好，我是徐庶老师，专注java，想要学习java的同学可以欢迎关注我。结合视频观看效果更佳哦：2022最新Spring5入门到源码【完整资料+源码】_哔哩哔哩_bilibili目录IOC配置详解1.2. 容器概述1.2.1. 配置元数据1.2.2. 容器的实例化1.2.3. 容器的使用1.3. bean的概述1.3.1. 命名bean1.4. 依赖1.4.1. 依赖注入1.4.2. 依赖和配置的细节1.4.3. 使用 depends-on属性1.4.4. 懒加载bean1.4.5. 自动注入1.5. B
Spring IOC容器和Bean的配置
菜鸟清风http://www.hphblog.cn/
03-02 5994
Spring IOC容器 和Bean的配置 ： IOC和DIIOC(Inversion of Control)：反转控制在应用程序中的组件需要获取资源时，传统的方式是组件主动的从容器中获取所需要的资源，在这样的模式下开发人员往往需要知道在具体容器中特定资源的获取方式，增加了学习成本，同时降低了开发效率。 反转控制的思想完全颠覆了应用程序...
Spring IOC注入（三）自动注入
重心开始，重新开始
07-16 2985
前俩篇讲了一下IOC注入的set方式注入和基于构造器的注入，现在就来讲讲自动注入~ 自动注入：容器依照一些规则去装配bean中的一个属性 注意:自动装配只对[对象类型]起作用,对基本类型不起作用. 自动注入有俩种方式： 第一种： 在beans标签中配置装载方式:defadefault-autowire="byType"或defult-autowire="byName"        
Spring声明式事务、使用注解开发、IOC注入、自动装配
baolingye的博客
07-31 257
Spring声明式事务 一、事务 事务就是将一组SQL语句放在同一批次内去执行，如果一个SQL语句出错，则此内所有SQL语句都将被取消执行，即执行要么都成功，要么都不成功 事务的四大特性：原子性、一致性、隔离性、持久性 二、为什么需要事务 在这里用个案例说明，定义一个方法，查询user表中所有数据，在查询前先插入一条数据再删除一条数据，数据库如下图所示 pojo实体类 package org.w...
Spring IOC的自动注入
weixin_44121790的博客
03-18 206
Spring IOC 的自动注入 Spring IOC 的自动注入 在 bean 标签上使用autowire属性设置自动注入规则 <?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:schemaLocat
Spring框架深度解析——官方指南
1. **依赖注入(Dependency Injection, DI)**：Spring的核心特性之一，它允许开发者在运行时通过容器来管理和注入对象的依赖关系，而不是在代码中硬编码依赖。这样可以提高代码的灵活性和可测试性。 2. **控制反转...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值