Spring学习笔记（二）IoC

最新推荐文章于 2024-10-05 11:27:00 发布

QHLD13

最新推荐文章于 2024-10-05 11:27:00 发布

阅读量64

点赞数

分类专栏： Spring学习记录文章标签： spring 容器 java

本文链接：https://blog.csdn.net/QHLD13/article/details/121358938

版权

Spring学习记录专栏收录该内容

7 篇文章 0 订阅

订阅专栏

一、IOC本质：

IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。
控制反转IoC(Inversion of Control)，IoC 也称为依赖性注射（DI），是一种设计思想，是一种过程。
在没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

ApplicationContext 这个接口就代表IoC容器，它负责实例化、配置和组装bean。容器通过读取配置文件的元数据来获取要实例化、配置和组装哪些对象的指令。配置文件支持xml,Java注解和纯Java代码。它允许您表达组成应用程序的对象以及这些对象之间丰富的相互依赖关系。

这个描述就是说对象的实例化，分配和管理由容器来负责，你只需要将这些信息用xml配置文件或注解或Java代码配置即可

二、所谓的控制反转和依赖注入：

在运行期间，由外部容器动态地将依赖对象注入到组件中。当spring容器启动后，spring容器初始化，创建并管理bean对象，以及销毁它。所以我们只需从容器直接获取Bean对象就行，而不用编写一句代码来创建bean对象。这种现象就称作控制反转，即应用本身不负责依赖对象的创建及维护，依赖对象的创建及维护是由外部容器负责的。这样控制权就由应用转移到了外部容器，控制权的转移就是所谓反转。

控制：

谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的.

反转 :

程序本身不创建对象 , 而变成被动的接收对象。

依赖注入：

例子演示：

例子来源 ———— B站Up主遇见狂神说 【狂神说Java】Spring5最新完整教程IDEA版通俗易懂_哔哩哔哩_bilibili

Spring容器在初始化时先读取配置文件（.xml），根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。

1. 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就是java对象 , 由Spring创建和管理-->
    <bean id="hello" class="com.kuang.pojo.Hello">
        <property name="name" value="Spring"/>
    </bean>
</beans>

2. 导入依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.1.10.RELEASE</version>
</dependency>

3. Hello实体类

public class Hello {
    private String name;
    public String getName() {
        return name;
    }
   public void setName(String name) {
        this.name = name;
    }
   public void show(){
        System.out.println("Hello,"+ name );
    }
   public toString(){}

}

4. Test测试类

@Test
public void test(){
    //解析beans.xml文件 , 生成管理相应的Bean对象
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    //getBean : 参数即为spring配置文件中bean的id .
    Hello hello = (Hello) context.getBean("hello");
    System.out.println(hello.toString());
}

5. 结果：输出为 Spring

6. 总结

传统方式下我们创建对象的方式是

类型 变量名  =  new  类型（）； 
Hello hello =  new Hello（）；

而利用Spring创建对象，在Spring中这些都称为：bean

<bean id="hello" class="com.kuang.pojo.Hello">
        <property name="name" value="Spring"/>
    </bean>

其中：

id = 变量名 ;

class = new 的对象的路径 ;

property相当于给对象的属性设置一个值" Spring " ;

三、IOC 创建对象的方法

1. 通过无参构造创建对象

public class User {
   private String name;
   public User() {
       System.out.println("user无参构造方法");
  }
   public void setName(String name) {
       this.name = name;
  }
   public void show(){
       System.out.println("name="+ name );
  }
}

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

@Test
public void test(){
   ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
   //在执行getBean的时候, user已经创建好了 , 通过无参构造
   User user = (User) context.getBean("user");
   //调用对象的方法 .
   user.show();
}

结果：user无参构造方法

说明了：在调用show方法之前，User对象已经通过无参构造初始化了！

2. 通过有参构造创建对象

public class UserT {
   private String name;
   public UserT(String name) {
       this.name = name;
  }
   public void setName(String name) {
       this.name = name;
  }
   public void show(){
       System.out.println("name="+ name );
  }
}

配置文件有一下三种方式书写：

（1）下标赋值

<bean id="exampleBean" class="examples.ExampleBean">
    <constructor-arg index="0" value="7500000"/>
    <constructor-arg index="1" value="42"/>
</bean>

（2）构造参数类型（不建议使用，当有多个相同类型的参数时会出错）

   <bean id="exampleBean" class="examples.ExampleBean">
       <constructor-arg type="int" value="7500000"/>
       <constructor-arg type="java.lang.String" value="42"/>
   </bean>

（3）构造参数名

<bean id="exampleBean" class="examples.ExampleBean">
    <constructor-arg name="years" value="7500000"/>
    <constructor-arg name="ultimateAnswer" value="42"/>
</bean>

@Test
public void testT(){
   ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
   UserT user = (UserT) context.getBean("userT");
   user.show();
}