Spring框架使用DI实现Ioc

已于 2022-09-01 08:51:47 修改
阅读量206 收藏
点赞数
分类专栏： spring 文章标签： spring java mybatis
于 2022-08-31 18:47:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxx200008/article/details/126545710
版权

目录

1.Spring框架使用DI实现IoC

2.Spring的配置问文件

3.Spring创建非自定义对象

4.Spring创建没有接口的对象

5.DI：给属性赋值

简单类型set注入(使用value)：spring调用类的set方法，通过set方法完成属性赋值

非自定义类属性赋值

引用类型set注入：

 (2)构造注入

 使用name属性

使用index属性

省略index属性

 创建file对象

(3)引用类型的自动注入

byName(按名称注入)

byType(按类型注入)

1.Spring框架使用DI实现IoC

通过spring框架，只需要提供要使用的对象名词就可以了。从容器中获取名称对应的对象。

Spring底层使用的 反射机制，通过反射创建对象给属性。

tomcat也是容器：管理的是servlet，listener,filter等对象

 

 

2.Spring的配置问文件

Spring标准的配置文件：

(1)根标签是beans

(2)beans后面是约束文件说明

(3)beans里面是bean声明

(4)什么是bean？bean就是java对象，spring容器管理的java对象，叫做bean

bean中声明对象

<bean id ="" class=" "/>

id 为对象的名称，唯一值（可以没有，Spring提供默认的名称）

class 类的全限定名称

Spring根据id、class创建对象，把对象放入spring的一个map对象，map.put(id,对象)

 我们之前创建对象用的是无参构造，现在Spring默认调用无参构造方法，如果定义了有参数构造，应该再定义无参数构造方法。

Spring在什么时候创建对象？

创建spring容器对象的时候，会读取配置文件，创建文件中声明的java对象。

优点：获取对象速度快，因为对象已经创建好了

缺点：比较占用内存

Spring创建对象一次创建几个？

在创建容器（ApplicationContext）对象时，对把配置文件中的所有对象创建出来(Spring的默认规则)

获取bean对象个数，以及对象名字，可以通过方法来获得

3.Spring创建非自定义对象

非自定义对象，也就是不是我写的类

<bean id="mydate" class="java.util.Data"/>

4.Spring创建没有接口的对象

 <bean id="myStudent" class="com.wangqi.ioc2.项目.ba02.Student">
        <property name="name" value="王淇"/>
<!--        setName("王淇")-->
        <property name="age" value="18" />
<!--        setAge(22)-->
    </bean>

5.DI：给属性赋值

spring调用类的无参构造，创建对象，对象创建后给属性赋值

给属性赋值可以使用：(1)xml配置文件中的标签和属性 （2）使用注解

DI分类：1.set注入  2.构造注入

3.1基于xml的DI

在xml配置文件中使用标签和属性，完成对象的创建，属性赋值

3.2set注入,也叫做设值注入

spring调用类中的set方法，在set方法中完成属性赋值，推荐使用

简单类型set注入(使用value)：spring调用类的set方法，通过set方法完成属性赋值

简单类型为java中的基本数据类型

语法：<bean id="XXX" class="yyy">

                        <property name="属性名" value="简单属性类型值"/>

.                        .......

                </bean>

不管属性是什么，都要加""

Spring要给属性赋值，必须有对应的set方法

给属性赋值看的是有没有set方法，与有没有属性无关，与属性名无关


   <bean id="myStudent" class="com.wangqi.ioc2.项目.Student">
        <property name="name" value="王淇"/>
        <property name="age" value="18" />
    </bean>
public class Student {
    private String name;
    private  int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
    @Test
    public void test04(){
        String config="spring-config.xml";
        ApplicationContext ctx =new ClassPathXmlApplicationContext(config);
        Student student =(Student)ctx.getBean("myStudent");
        System.out.println("student="+student);
    }

非自定义类属性赋值

找到这个类的set方法

<bean id="date" class="java.util.Date">
        <property name="time" value="295349276"/>
        <!--对应Date类的settime-->
    </bean>
 Date date=(Date)ctx.getBean("date");
        System.out.println(date);

引用类型set注入：

语法格式：<bean id="XXX" class="yyy">

                        <property name="属性名" ref="bean的id"/>

                        .........

                </bean>

 <bean id="myStudent" class="com.wangqi.ioc2.项目.ba02.Student">
        <property name="name" value="王淇"/>

        <property name="age" value="18" />
        <!--引用类型的数据赋值     -->
        <property name="school" ref="mySchool"/><!--setSchool(mySchool)-->
    </bean>
        <!--声明School    -->
    <bean id="mySchool" class="com.wangqi.ioc2.项目.ba02.School">
        <property name="name" value="北京大学"/>
    </bean>
public class School {
    private String name;
    private String address;

    public void setName(String name) {

        this.name = name;
    }



    public void setAddress(String address) {
        this.address = address;
    }

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

}
public class Student {
    private String name;
    private  int age;
    //声明一个引用类型
    private School school;
    public void setName(String name) {
        this.name = name;
    }


    public void setAge(int age) {
        this.age = age;
    }

    public void setSchool(School school) {
        System.out.println("school="+school);
        this.school = school;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", school=" + school +
                '}';
    }
}

 @Test
    public void test05(){
        String config= "ba02/applicationContext.xml";
        ApplicationContext ctx =new ClassPathXmlApplicationContext(config);
        //myStudent区分大小写
        Student student =(Student)ctx.getBean("myStudent");
        System.out.println("student="+student);
    }

 (2)构造注入

构造注入：spring调用类中的有参数构造方法，在创建对象的同时，给属性赋值

语法：<bean id="XXX" class="yyy">

                <constructor-arg:表示一个构造方法的形参

                标签有属性：name：构造方法形参名

                                     index：构造方法的参数位置

                                     value：简单类型的形参值

                                     ref：引用类型的形参值

           </bean>

 使用name属性

 <!--构造注入使用name属性    -->
    <bean id="myStudent" class="com.wangqi.ioc2.项目.ba03.Student">
        <!-- 对应的是形参名，不是属性名-->
        <constructor-arg name="myname" value="李四"/>
        <constructor-arg name="myage" value="20"/>
        <constructor-arg name="mySchool" ref="mySchool"/>
    </bean>
<!--声明School    -->
    <bean id="mySchool" class="com.wangqi.ioc2.项目.ba03.School">
        <property name="name" value="北京大学"/>
        <property name="address" value="北京的海淀区"/>
    </bean>

使用index属性

省略index属性

 也可以没有问题

 创建file对象

 <!--声明File对象-->
    <bean id="myFile" class="java.io.File">
        <constructor-arg name="parent" value="D:\\1"/>
        <constructor-arg name="child" value="message.txt"/>
    </bean>
//获取file对象
        File file=(File)ctx.getBean("myFile");
        System.out.println("file="+file);

(3)引用类型的自动注入

spring可以根据某些规则给引用类型完成赋值。只对引用类型有效

常用的两个规则：byName、byType

byName(按名称注入)

java类中引用类型属性名称和spring容器中的bean的id是一样的，且数据类型也是一样的，这些bean能够赋值给引用类型。

语法格式：

<bean id="XXX" class="yy" autowire="byName">

        简单类型属性赋值

        </bean>

 <!--byName 自动注入-->
    <bean id="myStudent" class="com.wangqi.ioc2.项目.ba04.Student" autowire="byName">
        <property name="name" value="王淇"/>
        <property name="age" value="18" />
        <!--引用类型的数据赋值     -->
<!--        <property name="school" ref="mySchool"/>&lt;!&ndash;setSchool(mySchool)&ndash;&gt;-->
    </bean>

    <!--声明School    -->
    <bean id="school" class="com.wangqi.ioc2.项目.ba04.School">
        <property name="name" value="清华大学"/>
        <property name="address" value="北京的海淀区"/>
    </bean>

public class Student {
    private String name;
    private  int age;
    //声明一个引用类型
    private School school;
    public Student(){
        System.out.println("Student类的无参构造方法");

    }
    public Student(String myname, int myage, School mySchool){
        System.out.println("Student类的有参构造方法");
        //给属性赋值
        this.name=myname;
        this.age=myage;
        this.school=mySchool;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", school=" + school +
                '}';
    }

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

    public void setAge(int age) {
        this.age = age;
    }

    public void setSchool(School school) {
        this.school = school;
    }
}

byType(按类型注入)

java类中引用数据类型和spring容器中bean的class值是同源关系，这样的bean赋值给引用类型。

同源类型：

1.java中引用类型的数据类型和bean的class值是一样的

2.java中引用类型的数据类型和bean的class值是父子类关系的

3.java中引用类型的数据类型和bean是接口和实现类的关系

语法格式：

<bean id="XXX" class="yy" autowire="byType">

        简单类型属性赋值

        </bean>

在xml配置文件中，符合条件的对象，只能有一个，多余的一个是报错的

 <!--byType 自动注入-->
    <bean id="myStudent" class="com.wangqi.ioc2.项目.ba05.Student" autowire="byType">
        <property name="name" value="张三"/>
        <property name="age" value="26" />
    </bean>

    <!--声明School    -->
<!--    <bean id="school2" class="com.wangqi.ioc2.项目.ba05.School">-->
<!--        <property name="name" value="航空大学"/>-->
<!--        <property name="address" value="北京的海淀区"/>-->
<!--    </bean>-->
    <bean id="primary" class="com.wangqi.ioc2.项目.ba05.PrimarySchool">
        <property name="name" value="北京大兴小学"/>
        <property name="address" value="北京大兴区"/>
    </bean>

6.项目中Spring多个配置文件

分多个配置文件：

(1)按功能模块分，一个模块一个配置文件

(2)按类的功能分，数据库操作相关的类在一个文件，service在一个配置文件，配置redis，事务等等一个配置文件。

spring管理多个配置文件：常用的是包含关系的配置文件，项目中有一个总的文件，里面是有import标签包含其他的多个配置文件。

语法：

总的文件(xml)

<import resourse="其他的文件的路径1"/>

<import resourse="其他的文件的路径2"/>

关键字"classpath":表示类路径，也就是类文件(class文件)所在的目录。spring到类路径中加载文件。

什么时候使用classpath：在一个文件中使用其他的文件，需要classpath。

多配置文件的应用

下面是两个配置文件：学生模块一个配置文件，学校模块一个配置文件

方法一：

 <!-- 当前是总的配置文件，目的是包含其他的多个配置文件，一般不声明bean
        语法：
        <import resource="classpath:"其他文件的路径"/>
        classpath:表示类路径。类所在的目录，spring通过类路径加载配置文件
        -->
        <import resource="classpath:ba07/spring-school.xml"/>
        <import resource="classpath:ba07/spring-student.xml"/>

方法二：使用通配符

  <!--包含关系的配置文件，可使用通配符* ：表示任意字符-->
        <import resource="classpath:ba07/spring-*.xml"/>

注意：总的文件名称，不能包含在通配符范围内(application.xml)不能叫做spring-applicationContext.xml

妖风吹不倒小熊栽的树
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
写一个自己的Spring框架——简单实现IoC容器功能
u010994169的博客
05-04 1万+
学习过Spring的同学都知道，Spring框架的核心就是IoC和AOP。Spring可以理解为一个工厂，负责对象的创建和对象间关系的维护。IoC即控制反转，简单点说就是原来的对象是在要使用之前通过在代码里通过new 的方式创建出来的而IOC的思想则是由spring容器创建同一创建(配置文件中注册bean对象)，在程序要使用到该对象的时候，自动注入。（spring默认在web容器启动的时候就创建了
Spring IOC ：Spring通过DI（依赖注入）实现IOC（控制反转）
Michaeles的博客
01-01 1003
一、DI依赖注入 1.谁依赖谁，为什么需要依赖，谁注入谁，注入了什么？ 应用程序依赖IOC容器、需要IOC容器提供对象、IOC注入对象、注入了外部对象 2.常用的3种注入方式？注解注入、setter注入、构造方法注入 二、Ioc控制反转 1.将对象和依赖对象的创建交给Spring容器去管理。由spring来负责控制对象的生命周期和对象间的关系。 2.谁控制谁，控制什么、为何是反转、哪些...
Spring注解实现IOC（DI）
it白白的博客
01-25 249
1.注解 所谓注解就是给程序看的提示信息，很多时候都用来作为轻量级配置的方式，注解本身不起什么作用，起作用的是在加载class文件时根据注解实现相应的功能。 2.Spring中的注解： Spring除了默认的使用xml配置文件的方式实现配置之外，也支持使用注解方式实现配置，这种方式效率更高，配置信息清晰，修改更方便，推荐使用。 使用类注解： 所谓类注解，指的是spring中在类上加上注解...
SpringIoC与DI
Answer0902的博客
04-25 214
Spring IoC与DI简介： IoC不是一种技术而是一种设计思想，将原本在程序中手动创建对象的控制权交给Spring框架管理； 正控:若要使用某个对象，需要自己手动的去负责对象的创建； 反控:若要使用某个对象，只需从Spring框架中获取使用的对象，而不用去想它是怎么创建的，即将创建对象的控制权反转给了Spring框架； DI是IoC的一种实现方式，即Spring创建对象的过程中，...
Spring框架DI(依赖注入)学习
m0_57697501的博客
07-18 262
DI的学习
Spring框架控制反转IOC和依赖注入DI详解
01-20
IOC和DI五.Spring框架使用（IoC）六.注入类型的三种方式 一.入门程序和IOC简介 依赖注入或控制反转的定义中，调用者不负责被调用者的实例创建工作，该工作由Spring框架中的容器来负责，它通过开发者的配置来判断...
笔记28-JAVAEE之Spring IoC&DI
01-25
Spring IoC(Inversion of Control，即控制反转)是Spring框架的核心机制之一，它提供了一种解耦合的方式，使得应用程序的各个组件之间能够松散耦合，提高了系统的灵活性和可维护性。 在传统的编程模式中，我们通常...
Spring IOC的快速入门案例
01-08
Spring IOC的快速入门案例 >下载Spring的开发包 ...目录结构： docs : API文档和开发规范 libs : 开发需要的jar包、源...>在程序中读取Spring配置文件，通过Spring框架获得Bean，完成相应操作 Spring 4.x的目录结构  
二,Spring IOC以及整合
01-13
二,Spring IOC以及整合对应源代码 Spring IOC,DI,spring整合mybatis,spring整合servlet
02-01-07-用30个类高仿真提炼纯手写Spring框架V2.0之IOC与DI1
08-04
02-01-07-用30个类高仿真提炼纯手写Spring框架V2.0之IOC与DI1
SpringBoot 将类加入ioc容器所有方式大全
pengweismile的专栏
07-06 1222
下面的注解都是用在主配置类中，也就是加了@Configuration的类里面 ①:通过@CompentScan + @Controller @Service @Respository @component，适用场景: 针对我们自己写的组件可以通过该方式来进行加载到容器中。 详细请查看下面文章，1.31 https://blog.csdn.net/pengweismile/article/de...
Spring到底是如何来实现IOC和DI？案例解析入门篇
黑马程序员官方博客
05-26 868
Spring 🍭SSM框架01：Spring的IoC和DI，以及手把手带你创建Spring核心配置文件 🍭SSM框架02：从0-1学习Spring配置文件 🍭为什么要学Spring？学什么？怎么学？ 一、入门案例 介绍完Spring的核心概念后，接下来我们得思考一个问题就是，Spring到底是如何来实现IOC和DI的，那接下来就通过一些简单的入门案例，来演示下具体实现过程: 1.1 IOC入门案例 对于入门案例，我们得先分析思路然后再代码实现， 1.1.1 入门案例思路分析 (1)Spring是使用容器来管
Spring框架的IOC/DI的自己实现
Learning
11-15 1621
今天咱们就一起探索spring是怎么完成IOC/DI工作的，也自己做一个简单Spring框架！ Spring中Bean的定义 作用：在spring中使用的bean，都有某些公共属性，此类就是对公共属性的定义 [java] view plain copy  print? public class BeanDefine {
IOC和DI到底是什么？
weixin_30839881的博客
02-13 656
　　在学习Spring框架的时候，我们总是能见到IOC这个单词，也时常听到DI这个词，那么他们分别是什么意思呢？接下来就讲讲个人对于这两个概念的理解 　　一、IOC和DI概念 　　IOC（控制反转）：全称为：InverseofControl。从字面上理解就是控制反转了，将对在自身对象中的一个内置对象的控制反转，反转后不再由自己本身的对象进行控制这个内置对象的创建，而是由第三方系统去控制...
什么是IOC和DI？DI是如何实现的？
li_ya_kun的博客
10-26 6256
什么是IOC和DI？DI是如何实现的？ IOC(Inversion of Control)叫控制反转， DI（Dependency Injection）叫依赖注入，是对IOC更简单的诠释。 IOC 控制反转是把传统上由程序代码直接操控的对象的调用权交给容器，通过容器来实现对象组件的装配和管理。所谓的"控制反转"就是对组件对象控制权的转移，从程序代码本身转移到了外部容器，由容器来创建对象并管理对象...
浅谈对Spring IOC以及DI的理解
热门推荐
luoyepiaoxue2014的博客
05-17 3万+
浅谈对Spring IOC以及DI的理解
Spring之DI
coderidea
08-26 1747
Spring是一个开源框架，Spring是为了解决企业级应用开发的复杂性而创建的，使用Spring可以让简单的JavaBean实现只有EJB才能完成的简单性。简单来说Spring最根本的使命：简化Java开发。Spring的目标是致力于全方位的简化Java开发。那么Spring是如何简化Java开发的呢？ 1. 基于POJO的轻量级和最小侵入性编程 2.通过依赖注入（DI）和面向接口实现松耦合......
【Spring】Spring DI的三种实现方式
AydenBryan的博客
07-31 4045
DI（Dependency Injection）是AOP中一个重要的概念，作用是给Spring容器管理的对象进行属性值的注入。 注入有三种实现方式： （1）带参构造方法注入 （2）参数对应setter方法注入 （3）参数直接注入（修改访问权限） 1，2是利用配置xml文件进行注入的主要实现方式，3是利用配置注解进行注入的主要实现方式。 注意： （1）如果注入的属性是一个对象，那么还可以配置xml文件或者注解实现对象属性的自动注入。 （2）本文只说明DI的配置方式，不涉及其应用环境。 带参构造方法注入 App
6、Spring之Bean生命周期~创建Bean（2）
最新发布
sproutBoy的博客
06-10 693
【代码】6、Spring之Bean生命周期~创建Bean（2）
Spring 框架 IOC和 DI 区别
07-11
在Spring框架中，IOC（Inversion of Control）和DI（Dependency Injection）是两个核心概念，它们有以下区别： 1. IOC（控制反转）：IOC是一种设计原则，它将对象的创建和依赖关系的管理从应用程序代码中解耦出来。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值