每天一点儿时间学习Spring框架系列—IOC(2)_loc容器接口application context实现类-CSDN博客

本文链接：https://blog.csdn.net/server643/article/details/120114518

每天一点儿时间学习Spring框架——Ioc(2)

前篇简单入门了Spring的结构，这次就来开始讨论其中的控制反转的思想和自己的一些编写实例分享。（编写不一定能够完美的实现，建议大家了解其中的基本步骤结合自身学习即可。谢谢大家！！）

1、 `Ioc`控制反转

1.1 控制反转的概念

在我们一般写java代码时，都会使用new一个对象出来。比如说要进行算术就要new一个math出来。这些都是由调用者自己操作控制的。

而控制反转的意思在于这些控制权由程序代码转移到了Spring容器中，控制权发生了反转。这就是Spring Ioc的思想。

我们可以打个比方。在我们自己使用java web时，通常需要使用servlet。但是我们在使用idea只要直接extends后选择doget和doPost方法即可。按理来说我们一般写代码都需要以对象.方法的格式进行使用，但是我们在使用doget或者dopost时，我们配置的tomcat可以直接通过方法返回到对象中去，知道程序员要使用的是servlet。此时我们可以把tomcat在这里当成是一种容器。

2、Spring容器使用示例

2.1 创建一个Maven项目

在这里插入图片描述

如上图所示，代码的编辑器目录展示。

2.2 添加依赖和插件

<dependencies>

        <!--单元依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!--spring依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.13.RELEASE</version>
        </dependency>
    </dependencies>

    <!--编译插件-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

首先添加了junit单元的用于编译依赖，创建了Spring依赖还有插件的配置编译。

2.3 创建实体类

在创建完如上的配置后，进行实体类的创建以感受控制反转的概念，即IOC概念。

这里文章来编写一个实体类出来。

package com.jpg;
public class project {
    private String id;
    private String name;
    private String location;
    public project(){
        System.out.println("我的默认构造方法被调用！！"+",id="+id+",name"+name+",location="+location);
    }
}

2.4 创建Spring的配置文件`application.xml`

在这里插入图片描述

2.5 在`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">

</beans>

在xml中的语句中，如果我们要配置时可以进行如下创建。

spring的配置文件：

beans: 根标签，spring中java的对象成为bean
spring-beans.xsd 是约束文件（约束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="project1" class="com.jpg.project"></bean>
</beans>

在beans下创建一个bean标签，写下之前创建实体类的路径并设置id。如上代码块表示即可。

2.6 获取Spring容器

Spring中提供了两种LoC容器：BeanFactory和Application。

2.6.1 `BeanFactory`

BeanFactory是基础类型的LoC容器，它就是管理Bean的工厂。它的任务就是负责初始化各种Bean并调用它们的生命周期方法。

其中介绍BeanFactory接口，它有多个实现类。其中最常见的是：

org.Springframework.beans.factory.xml.XmlBeanFactory：它根据 XML 配置文件中的定义装配 Bean 。

BeanFactory beanFactory = new XmlBeanFactory(new FileSystemResource(Spring配置文件的名称));

2.6.2 `ApplicationContext`

ApplicationContext是BeanFactory的子接口，也被称为应用上下文。它除了提供BeanFactory的所有功能，还添加了i18n国际化、资源访问、事件传播等方面的良好支持。

其中，ApplicationContext接口有两种常用的实现类：

2.6.2.1 `ClassPathXmlApplicationContext`——常用

该类从类路径ClassPath中寻找指定的XML配置文件，找到并装载完成ApplicationContext的实例化工作。

ApplicationContext applicationContext=new ClassPathXmlApplicationContext(Spring配置文件的名称);

2.6.2.2 `FileSystemXmlApplicationContext`

ApplicationContext applicationContext = new FileSystemXmlApplicationContext(String configLocation);

它与 ClassPathXmlApplicationContext 的区别是：在读取 Spring 的配置文件时， FileSystemXmlApplicationContext 不再从类路径中读取配置文件，而是通过参数指定配置文件的位置。它可以获取类路径之外的资源，如“D:\application.xml”。

总结：一般而言使用的第一种，即ClassPathXmlApplicationContext最常用。因为从类路径中获取通常对于大部分人的学习都比较方便；当然其他的类调用都可以使用，大家日后学习工作主要根据自己习惯即可。

2.7 通过上下文对象获取容器中的对象

根据如上自定义创建一个测试类，调用如上方法之一并使用之前创建好的xml文件。调试运行。

package com.jpg.test;
import com.jpg.project;
import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import org.springframework.core.io.FileSystemResource;
import java.util.Date;
public class Test1 {
@Test
public void test01(){
//使用spring容器创建对象
    //1、指定spring配置文件的名称
    String springConfig="application.xml";
    //2、创建spring容器的对象：
    //applicationContext--常用
    ApplicationContext applicationContext=new ClassPathXmlApplicationContext(springConfig);//这里执行完毕容器中的对象都已经创建完成
    //3、获取容器中的对象
    project pro= (project) applicationContext.getBean("project1");
    //4、容器其他api
    int beanDefinitionCount = applicationContext.getBeanDefinitionCount();
    System.out.println("spring容器中对象的个数："+beanDefinitionCount);
    String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
    System.out.println("spring容器中所有对象的名称：");
    for (String name : beanDefinitionNames) {
    System.out.println(name);
    }
    }
}

在上面步骤完成后编写测试类，测试类上步骤如下：

指定配置xml文件
根据自身创建spring容器
获取容器中的对象
容器中其他API的搭配使用

这样子以上的Spring的容器使用就大功告成了。

3、创建非自定义实例

pox.xml文件中补充
<!--创建非自定义的对象-->
<bean id="date" class="java.util.Date"></bean>

如上面步骤所示，创建测试类如下表示

Date date1= (Date) applicationContext.getBean("date1");
System.out.println("日期："+date1);

此时能够看出，在创建非自定义时候较自定义的简洁。

4、bean标签的属性

在上面我们使用了id属性和class属性，这一次我们来介绍其他的属性标签。

属性	说明
`class`	指定`bean`对应类的路径
`name`	`name`是`bean`对应对象的标识
`scope`	执行bean对象创建模式和生命周期
`id`	id是bean对象的唯一标识
`lazy-init`	是否延时加载默认值:false。
`init-method`	只需要加载配置文件即可对象初始化方法
`destroy-method`	对象销毁方法