Spring入门(2)-IOC容器中，如果使用配置文件创建对象，基本思路是什么样的？

最新推荐文章于 2022-12-06 18:15:12 发布
最新推荐文章于 2022-12-06 18:15:12 发布
阅读量289 收藏 1
点赞数
分类专栏： # Spring5 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dxsdcyy/article/details/107791579
版权

目录

1. IOC的概念

1.1什么是IOC？

在百度百科中：IOC，Inversion Of Control，控制反转，属于面向对象编程的一种原则，用来降低计算机代码之间的耦合度，最常见的方式叫做依赖注入(DI)；
目的(简单来说)：就是通过IOC，把对象创建和对象之间的调用（就比如在一个类里面调用另一个类） 过程交给Spring来进行管理，降低耦合度(程序讲究高内聚，低耦合)；

2. IOC的深层剖析

2.1 IOC用到的核心技术
  1. XML解析
  2. 设计模式中的工厂模式
  3. Java中的反射
2.2 IOC的底层实现原理(大致了解)
  • 第一步：创建一个XML配置文件，配置需要创建的对象；(这个需要你手动)
    在这里插入图片描述
      <bean id="自己设置的名字" class="类的路径"/>
  • 第二步：创建工厂类，在工厂类中返回类A的对象；(这个Spring给你完成了，你可以直接获得对象)
    public class factory {

    //就像是简单工厂模式返回一样；
    public static B getA() throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        String classvalue = "获得XML文件中的class属性值";
        //然后通过反射对那个类进行加载；classvalue就是从XML中获得的类的路径；
        Class clazz = Class.forName(classvalue);
        //创建需要的对象并返回,但是如果使用工厂模式的话，就可以直接返回这个类的接口就可以了，这样以后多态就方便了；
        //return (A) clazz.newInstance();
         /*使用下面这种方式返回，那么以后但凡是实现了接口B的都可以使用，
         但是使用上面的，就只能返回A类；也就是只有调用A类才可以使用；
         */
        return (B) clazz.newInstance();
    }
}

interface B {
}

class A implements B {
    public void test() {
        System.out.println("13");
    }
}
    下图时对上面的返回方式进行简单的解释；
2.3 IOC接口

  1. 在Spring中IOC接口的实现有两种方式：
    一种是BeanFactory接口，Spring内部的使用接口(一般不给普通开发者不用)；加载配置文件的时候，不会直接创建对象；而是在getBean()的时候才会创建对象；
    另一种是ApplicationContext接口，该接口是 BeanFactory的子接口，里面的功能更加的多，主要是给普通的开发者使用；而且只要在XML中进行了类的配置，那么加载配置文件时就会把配置文件中的对象进行创建；

  2. IOC底层是一个对象工厂(应该就是指，是一个工厂对象，专门用来生产对象的)

  3. ApplicationContext中常见的两个类，如下图：

FileSystemXmlApplicationContext这个类使用时，中间的参数主要可以理解为一个绝对路径(比如从C盘开始写)；
ClassPathXmlApplicationContext这个类创建对象时，中间的参数主要可以理解为相对的路径；

2.4 IOC的Bean管理

Bean的两个操作：

  1. Spring创建对象；
  2. Spring注入属性依赖；
    上面的两种操作同样的有两种方式来实现：一种是通过XML配置文件的方式来实现，第二种是通过注解的方式来实现；

3. 通过XML进行Bean管理

3.1 通过XML配置文件创建对象

首先要创建一个Spring的xml配置文件(Spring config)，然后在其中使用<Bean>标签对类进行配置；
对Bean标签中的属性进行简单的记录：
id属性：自己设置的名字(就类似与自己给这个对象建立一个标识，用于区分不同的Bean标签)
class属性：创建的对象的类的全路径；
name属性：和id的使用方式类似，也是用于区分bean的；

基本使用如下：(通过这中方式创建的对象，默认调用的还是无参的构造方法)

3.2 通过XML方式注入属性
  1. DI：注入属性；
  2. (在Spring中有两种注入属性的方式)：一种是使用set方法注入，一种是通过构造方法注入；

通过set注入：

  • 创建一个类，然后在类中写好基本属性和set方法；
  • 创建一个配置文件用来配置需要的属性；
<?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和class属性都已经介绍了，现在介绍以下property中使用到的属性；
    name 是你自己设置的属性名；
    value 是你注入的属性值，类似于默认属性值；
    -->
    <bean id="book" class="com.company.BookTest">
        <property name="bname" value="数理化"/>
    </bean>
</beans>

测试类：

public class cTest {
    @Test
    public void test() {
        ApplicationContext context = new ClassPathXmlApplicationContext("/cn/dxs/XML/TestBook.xml");
        //第一个参数是之前在XML文件里面配置的id，后面是规定类型；
        BookTest book = context.getBean("book", BookTest.class);
       //通过上面的对象直接调用set方法，并进行赋值；
        book.setBname("dd");
        System.out.println(book.toString());
    }
}

输出：

总结：多个属性的注入也是按照这种格式，唯一的不同点可能就是多在bean标签中多写几个property

通过构造方法的方式进行属性的注入

  • 创建一个类，这个类里面有带参的构造方法；
public class BookTest {

    private String Bname;

    public BookTest(String bname) {
        Bname = bname;
    }

    @Override
    public String toString() {
        return "BookTest{" +
                "Bname='" + Bname + '\'' +
                '}';
    }
}
  • 在Spring的配置文件中进行配置
<?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">

    <!--
    constructor-arg 这个标签是用来标明构造方法中的参数的；
    name 构造方法中的参数名
    value 是你注入的属性值,类似于默认属性值；
    -->
    <bean id="book" class="com.company.BookTest">
        <constructor-arg name="bname" value="天才在左，疯子在右"/>
    </bean>
</beans>

测试类：

public class cTest {
    @Test
    public void test() {
        ApplicationContext context = new ClassPathXmlApplicationContext("/cn/dxs/XML/TestBook.xml");
        //第一个参数是之前在XML文件里面配置的id，后面是规定类型；
        BookTest book = context.getBean("book", BookTest.class);
        System.out.println(book.toString());
    }
}

运行结果：

前面介绍的都是指，所有放进去的属性开始设置就不是空值的情况，那么如果是空值(null)，该怎么设置?
其它的步骤都是一样的，唯一的不同点就是空值的属性中，在配置文件配置的时候是这样的；

<!--这就表示这个属性是空值了；-->
        <property name="bname">
            <null/>
        </property>

还有一个就是说如果属性是一个类的引用，该怎么编写property标签；(一般就是只外部类在另一个类中调用)

        <property name="bname" ref="填写另一个类的id" />  
        <!--解释如下：-->
        <!--class user{}类；class Myclass{private user use}类-->        
        <!--有一个类叫user,它在配置文件中的配置；-->
        <bean id="user" class="a.b.d"></bean>
        <!--这是在一个类Myclass中将user作为它的属性；-->
        <bean id="myclass" class="a.b.c">
        <!--里面的name是属性设置时的名字；里面的ref是那个类的Bean中的id值-->
		<property name="use" ref="user">
		</property>
		</bean> 
		  <!--代替这里的整个xml配置文件，还有一种方式
		 <bean id="myclass" class="a.b.c">
		<property name="use" >
		<bean id="user" class="a.b.d">
		<property name="user" value="jjj"/>
		</bean>
		</property>
		</bean> 
		-->

接下来考虑一下，如果放进去的值带有特殊符号的时候该怎么设置，如果只是单纯什么都不做，肯定会报错的；
第一个想到的肯定是进行转移符号；(可以直接百度，一般都有，当然记得最好)
第二个就是使用<![CDATA[放入带特殊符号的值]]>就可以了；

   <property name="bname">
            <value>
                <![CDATA[小王子]]>   <!-- 目前没想写特殊符号，单纯记录吧-->
            </value>
        </property>

外部级联复制；

这是BookTest类；

Mian类

TestBook.xml文件

4. P名称空间注入(还是以set注入为基础)

  1. 在配置文件里面添加P名称空间

  2. 进行属性注入即可，这时就不需要再次使用property属性了；

  3. 运行结果：

5. IOC注入集合属性

5.1注入数组,List,Map,Set类型的属性

一：创建一个类CollectionTest作为需要创建对象的类；

public class CollectionTest {
    //定义一个数组属性
    private String[] arr;
    //定义一个list集合属性；
    private List<String> list;
    //定义一个Map集合属性；
    private Map<String,String> map;
    //定义一个Set集合属性；
    private Set<String> set;
    //创建所需要的setter方法,getter 先不创建；
    public void setArr(String[] arr) {
        this.arr = arr;
    }
    public void setList(List<String> list) {
        this.list = list;
    }
    public void setMap(Map<String, String> map) {
        this.map = map;
    }
    public void setSet(Set<String> set) {
        this.set = set;
    }
       @Override
    public String toString() {
        return "CollectionTest{" +
                "arr=" + Arrays.toString(arr) +
                ", list=" + list +
                ", map=" + map +
                ", set=" + set +
                '}';
    }
}

二：在配置文件中进行设置；

<?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标签创建类的对象-->
    <bean id="collectiontest" class="cn.dxs.Collection.CollectionTest">
        <!--下面是对数组属性进行配置-->
        <property name="arr">
            <array>
                <value>语文</value>
                <value>数学</value>
            </array>
        </property>
        <!--下面是对List属性进行配置-->
        <property name="list">
            <list>
                <value>物理</value>
                <value>化学</value>
            </list>
        </property>
        <!--下面是对Map属性进行配置-->
        <property name="map">
            <map>
                <entry key="English" value="英语"/>
            </map>
        </property>
        <!--下面是对Set属性进行配置-->
        <property name="set">
            <set>
                <value>历史</value>
            </set>
        </property>
    </bean>
</beans>

三.测试类Test

	public class Testdemo1 {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        CollectionTest collectiontest = context.getBean("collectiontest", CollectionTest.class);
        System.out.println(collectiontest);
    }
}

测试结果：

5.2 当需要往List中插入对象时，该如何做？

第一步：我们先创建一个类Book和类Library

//Book类
public class Book {
    //在这个类里面创建一个简单属性；
    String Bname;

    public void setBname(String bname) {
        Bname = bname;
    }
       @Override
    public String toString() {
        return "Book{" +
                "Bname='" + Bname + '\'' +
                '}';
    }
}

Library类：

public class Libarary {
    public List<Book> list;
    //创建一个Set方法；
    public void setList(List<Book> list) {
        this.list = list;
    }
    @Override
    public String toString() {
        return "Libarary{" +
                "list=" + list +
                '}';
    }
}

第二步：创建一个配置文件

<?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标签其实就是在创建一个对象，这里先创建一个book1的对象-->
    <bean id="book1" class="cn.dxs.OnCollection.Book">
        <property name="bname" value="巴黎圣母院"/>
    </bean>
    <!--再次创建应该对象book2-->
    <bean id="book2" class="cn.dxs.OnCollection.Book">
        <property name="bname" value="八仙过海"/>
    </bean>

    <!--创建一个Library类的对象-->
    <bean id="library" class="cn.dxs.OnCollection.Libarary">
        <property name="list">
            <list>
                <ref bean="book1"/>
                <!--<ref bean="book2"/>-->
                <!--再次创建应该对象book2-->
                <bean id="book2" class="cn.dxs.OnCollection.Book">
                    <property name="bname" value="八仙过海"/>
                </bean>
            </list>
        </property>
    </bean>
</beans>

测试类：

public class TestLibrary {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("cn/dxs/xml/Bookconfig.xml");
        Libarary library = context.getBean("library", Libarary.class);
        System.out.println(library);
    }
}

运行结果：

5.3 引入名称空间，将List注入简化使用

配置文件这样写：

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

    <util:list id="book">
        <value>八仙过海</value>
        <value>巴黎圣母院</value>
    </util:list>
    <!--创建一个Library类的对象-->
    <bean id="library" class="cn.dxs.OnCollection.Libarary">
       <property name="list" ref="book"/>
    </bean>
</beans>

在这之中最重要的就是插入xmlns:util="http://www.springframework.org/schema/util
和最后的 http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
这样才能使用util为主的标签；

神秘的天
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring Boot入门(01)：探索Spring Boot的学习历程、发展历程与成功之路
**My Coding Family**
03-09 3万+
Spring Boot是目前最流行的Java开发框架之一，它带来了前所未有的便利性和开发效率，同时也是Spring框架的一个重要组成部分。Spring Boot的出现不仅仅是为了简化Spring应用程序的开发过程，更是为了解决Spring框架中的一些问题，比如依赖管理、配置管理等，从而使Spring应用程序更容易上手，更易于维护。通过这篇文章，你将了解到Spring Boot的历史背景、设计理念、特性和优点，以及如何使用它来快速开发高效的Java应用程序。
Spring_01---spring入门、ioc配置创建对象、属性注入等
一万年行不行的博客
11-08 247
一、Spring概念 1 spring是开源的轻量级框架 2 spring核心主要两部分： 1）aop：面向切面编程，实现扩展功能时不修改源代码 2）ioc：控制反转--通过配置spring的方式创建类对象，而不是new ioc好处：当类的路径发生变化时，只需修改配置文件，不需要修改代码。 3 spring是一站式框架 1）spring在javaee三层结构中，每一层都提供不...
Spring通过配置文件来实例化类的对象原理（一）
ClareQi的博客
08-09 1159
上一篇博文中将了 Spring配置文件，本文主要讲述 Spring如何通过配置文件来实例化类的对象的。这其中的原理还是比较复杂的，需要的知识涉及到Java的类加载机制 和 Java反射的知识。 所以本文主要讲 Java的类加载机制 和 反射机制。 Java类加载机制： 我们编写的程序是.java的后缀文件，首先要通过编译器 编译成 .class的二进制文件。 Java类加载的说的就是读取...
Spring：基于配置文件的创建对象的各种方式
03-28 117
在Spring3.0之前，Spring主要创建对象的方法是基于配置文件的，即在配置文件中为对象进行注册，并且可以在配置文件当中为对象的字段或者称之为属性值进行赋值，接下来首先介绍基于配置文件的创建对象的方式。 1.1 基于配置文件的无参数构造函数的对象创建 package bjtu.wellhold.testSpring; //当类当中没有任何构造函数的时候，默认就是...
Spring之IOC容器创建bean对象的XML配置总结
jeannia的博客
04-02 674
spring的bean配置总结1. 通过\标签赋值2.通过\标签赋值3.通过p名称空间给属性赋值4.为其他属性赋值5.bean之间的继承与依赖6.创建单例和多实例bean      ---默认是单例7.工厂方法创建bean8.在bean生命周期内特定时间点执行任务9.引用外部属性文件 ---常用于连接池实例10.基于xml的自动装配 ---仅限于对自定义类型的属性有效，对于string等类型无...
Spring——Spring容器创建对象的方式
莫得感情得码农
07-29 1408
1.Spring容器创建对象的特点 1.ApplicationContext 用于加载 Spring 的配置文件，在程序中充当“容器”的角色。通过ApplicationContext对象获取要使用的其他Java对象。其实现类有两个。 2.spring默认的是调用类的无参构造方法，创建对象。 3.spring读取配置文件，一次创建好所有的Java对象，都放到map中。 ApplicationContext 容器，会在容器对象初始化时，将其中的所有对象一次性全部装配好。以后代码中若要使用到这些对象，只需从内
05-IoC入门案例-入门案例制作
04-25
也就是我的Spring容器(也就是IoC容器，以下我们都称为Spring容器)要管的东西是什么？那肯定是对应的Bean。也就是你原来造对象的那些类，是不是我要管完以后把它放到我们的Spring容器中变成Bean。所以说我们就知道管...
Spring入门（二）快速入门 - IOC/DI
weixin_68893669的博客
12-06 107
spring入门
spring-boot使用指南
12-01
Spring Boot 应用程序可以通过多种方式运行，包括在 IDE 中直接运行、构建并运行可执行 JAR 文件、使用 Maven 或 Gradle 插件等。 #### Hot Swap Hot Swap 功能允许开发者在不重启应用程序的情况下修改代码并立即...
Spring是什么？一文带你快速入门Spring
一条会编程的鱼
04-05 9801
文章目录前言Spring是啥？它有啥好处Spring体系结构详解Spring目录结构和基础JAR包介绍Spring IOC容器：BeanFactory和ApplicationContextBeanFactoryApplicationContext第一个Spring程序 前言 从今天开始，怀着无比急切（操蛋）的心情开始学习Spring。我看了网上很多的大佬说，SpringBoot上手舒服一些，说Sp...
Spring - Spring配置文件详解-Bean对象细节剖析
qq_39123467的博客
04-04 1104
Spring配置文件详解-Bean对象细节剖析
Spring——SpringIOC创建对象的方式、Spring配置文件简单介绍、Bean作用域及自动装配
qq_43411550的博客
08-08 207
Spring——SpringIOC创建对象的方式、Spring配置文件简单介绍 一、SpringIOC创建对象的方式 我们平时在创建对象的时候会使用无参构造、有参构造的方式创建。那么我们来看看Spring中怎么处理这两种情况。 创建实体类，并在实体类构造和set方法内部输出测试 package com.muhan.pojo; public class User { private int...
Spring学习三：IOC创建对象的两种方式，Spring配置文件
weixin_43306403的博客
08-05 200
3.1. IOC创建对象的方式 我们平时创建对象的方式： 有参构造 、无参构造 我们来看看在Spring中怎么处理这两种情况 创建实体类 package com.westos.pojo; public class User { private String name; private String sex; private int age; public Us...
Spring学习二创建对象，Spring的配置，Bean注入方式
qq_39379958的博客
07-20 148
1、Spring Ioc创建对象的方式 构造方法创建对象： 1、使用无参构造创建对象，是默认实现； 2、若使用有参构造创建对象，则： 使用下标赋值，index赋值0，代表构造方法第一个参数 <bean id="user" class="com.hua.pojo.User"> <constructor-arg index="0" value="张三"></constructor-arg> </bean> 使用类型赋值，但是
Spring Bean实例化的三种方式（在spring里面通过配置文件创建对象）
qq_18119793的博客
08-01 1986
第一种  使用类的无参构造 &lt;bean  id="user" class="com.qianchen.bean.User"&gt;&lt;/bean&gt; 如果类中没有无参构造会出现异常 nosuchmethod public class Testioc { @Test public void testUser(){ //加载spring配置文件  创建对象 Applicat...
java反射案例——通过配置文件来创建对象
Ez4Sterben的博客
03-11 1155
首先建立一个新的项目，在src下新建一个reflect包并在src下新建配置文件pro.properties（否则会找不到），在reflect包下新建任意两个类和一个测试类，项目结构如下： 测试类代码如下： import java.io.InputStream; import java.lang.reflect.Method; import java.util.Properties; public class Demo3 { public static void main(String[] args
Spring系列第4篇:Spring容器创建Bean对象的四种方式和细节
qq_29445811的博客
11-17 1333
文章目录一、Spring容器创建Bean对象的四种方式1.通过反射调用构造方法创建bean对象2.通过实例工厂方法创建bean对象3.通过静态实例工厂方法创建bean对象4.通过FactoryBean接口来创建bean对象二、bean对象的作用范围三、bean对象的生命周期 一、Spring容器创建Bean对象的四种方式 1.通过反射调用构造方法创建bean对象 <!--第一种方式：使用默认构造函数创建对象 在spring的配置文件中，使用bean标签，配以id和class属性，没有其他属性和标签时，
Spring框架（二）IOC创建对象的细节
qq_23691697的博客
03-30 2567
SpringIOC——控制反转中创建对象的细节    在刚开始使用Java的时候，创建对象的方式多半是使用 new+对应的构造方法，为了进一步提高对象的安全性和降低耦合，开始使用工厂模式和单例模式，通过调用工厂里的方法获取对象，再后来通过反射加配置文件的方式，在创建对象的过程中进一步降低耦合。    那么SpringIOC里创建对象的过程是怎样的呢？具体来说：SpringIOC是什么时候创建对象的...
如何通过配置文件动态创建对象
程序人生的专栏
01-14 2220
如果你要创建的对象依赖于某个文件，那么可以将信息写到配置文件中。 现在配置文件config.properties中有一个名称值对，如何加载它？通过InputStream对象和Properties对象即可轻松办到。 通常分为5步 第一步：得到文件的流对象。第一种方法直接new对象，后面两种都是通过类加载器加载 InputStream is = new FileInputStream("c
Spring框架中如果要对某个类的对象创建并纳入到IOC容器管理，可以使用什么注解
最新发布
05-04
可以使用 `@Component`、`@Service`、`@Repository`、`@Controller` 等注解，它们都是 `@Component` 的派生注解。其中，`@Component` 适用于一般的组件类，`@Service` 适用于业务逻辑层，`@Repository` 适用于数据访问层，`@Controller` 适用于表现层（Spring MVC）等。使用这些注解后，Spring 会自动扫描带有这些注解的类，并将其实例化并纳入到IOC容器中管理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

神秘的天

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值