Spring第二篇：Spring容器的基本使用及原理

一、Spring的IOC容器

　　Spring的IOC容器是具有依赖注入功能的容器，负责对象的实例化、对象的初始化，对象和对象之间依赖关系配置、对象的销毁、对外提供对象的查找等操作，对象的整个生命周期都是由容器来控制。我们需要使用的对象都由ioc容器进行管理，不需要我们再去手动通过new的方式去创建对象，由ioc容器直接帮我们组装好，当我们需要使用的时候直接从ioc容器中直接获取就可以了。

　　IOC容器通过解析xml的配置文件和解读java的注解来获取需要管理的清单，安排配置文件和注解指定的对象创建方式构建对象，并将对象按照依赖关系组装好供外部调用。

二、Bean概念

　　Spring的IOC容器管理的对象就是Bean对象，Bean对象就是普通的Java，只不过现在对象的创建和管理需要Spring来完成。我们需要在配置文件中告诉Spring如何创建和管理该对象，我们把配置文件中这些定义bean对象的创建方式、对象间依赖关系和管理对象的配置信息称之为，配置元数据信息。Spring容器通过bean的配置元数据信息来创建和组装我们需要的bean对象。

三、Spring容器的基本使用

　　1、创建maven项目

　　2、引入spring的maven相关依赖

　　3、增加bean的xml配置元数据信息，定义spring容器管理的bean对象

　　4、创建Spring容器，并指定加载的bean配置文件。启动Spring容器，加载指定的bean配置文件，创建配置文件中定义好的bean对象，bean对象存放在容器中供外部使用。

　　5、获取spring容器中的对象，并使用。

四、Spring的容器对象

　　1、BeanFactory接口

　　org.springframework.beans.factory.BeanFactory接口是Spring容器的顶层接口，提供了容器最基本的使用方法。

　　常用的方法：

//按bean的id或者别名查找容器中的bean
Object getBean(String name) throws BeansException

//这个是一个泛型方法，按照bean的id或者别名查找指定类型的bean，返回指定类型的bean对象
<T> T getBean(String name, Class<T> requiredType) throws BeansException;

//返回容器中指定类型的bean对象
<T> T getBean(Class<T> requiredType) throws BeansException;

//获取指定类型bean对象的获取器，这个方法比较特别，以后会专门来讲
<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);

　　2、ApplicationContext接口

　　org.springframework.context.ApplicationContext接口继承了BeanFactory接口的所有功能，并在其基础上增加了AOP、事件支持、国际化等功能。

　　3、ClassPathXmlApplicationContext接口

　　org.springframework.context.support.ClassPathXmlApplicationContext接口继承了ApplicationContext接口，这个接口可以从classPath接口中加载xml文件，并根据xml文件的配置元数据信息创建bean对象。

　　4、AnnotationConfigApplicationContext接口

　　org.springframework.context.annotation.AnnotationConfigApplicationContext接口也继承了ApplicationContext接口，上面的ClassPathXmlApplicationContext接口支持从xml的配置文件中创建并管理bean对象，而AnnotationConfigApplicationContext接口则支持从注解解析中创建和管理bean对象。

　　使用注解的方式比使用xml文件配置的方式要更加方便。

五、Spring的IOC容器简单使用

　　1、创建maven

　　创建spring-series的聚合工程，并添加相应的依赖管理

<groupId>lin.java.spring</groupId>
    <artifactId>spring-series</artifactId>
    <packaging>pom</packaging>
<version>1.0-SNAPSHOT</version>

　　pom.xml文件信息

<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!-- 配置maven编译的时候采用的编译器版本 -->
        <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
        <!-- 指定源代码是什么版本的，如果源码和这个版本不符将报错，maven中执行编译的时候会用到这个配置，默认是1.5，这个相当于javac命令后面的-source参数 -->
        <maven.compiler.source>1.8</maven.compiler.source>
        <!-- 该命令用于指定生成的class文件将保证和哪个版本的虚拟机进行兼容，maven中执行编译的时候会用到这个配置，默认是1.5，这个相当于javac命令后面的-target参数 -->
        <maven.compiler.target>1.8</maven.compiler.target>
        <!--spring版本控制-->
        <spring.version>5.2.3.RELEASE</spring.version>
        <!--junit版本控制-->
        <junit.version>4.13-beta-3</junit.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
                <version>${spring.version}</version>
            </dependency>

            <!--junit-->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

　　选中spring-series，进行module创建，相应的pom.xml中增加依赖配置

<!--加入spring依赖-->
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

　　2、在项目中创建相应的类

　　在项目重创建测试用的实体类

package com.java.spring01.demo1;

public class HelloSpring {

    public void say(String str){
        System.out.println("hello spring IOC First demo " + str);
    }
}

　　3、在resources文件中创建bean.xml文件，用于指定Bean的配置元数据信息

<?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-4.3.xsd">

    <!--
    定义一个bean
    id：bean的唯一标识，可以通过这个标识从容器中获取这个bean对象
    clss：bean的类型，完整类名称
    -->
    <bean id="helloSpring" class="com.java.spring01.demo1.HelloSpring"/>

</beans>

　　3、创建test方法并运行

package com.java.spring01.demo1;

import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class HelloSpringTest {

    @Test
    public void testSay(){
        //1、配置xml文件路径
        String beanXml = "classpath:/spring01/demo1/bean.xml";
        //2、获取IOC容器，加载配置文件到容器中
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(beanXml);
        //3、获取bean对象
        HelloSpring bean = context.getBean("helloSpring", HelloSpring.class);
        //4、运行bean方法
        bean.say("测试");
    }
}

　　运行结果：

Spring第二篇：Spring容器的基本使用及原理

猜你喜欢