Spring 源码分析（一）之 Spring IOC 容器基础介

作者: 挂机的啊洋zzZ | 来源:发表于2019-02-14 23:30 被阅读0次

spring.png

Spring 源码分析（一）之 Spring IOC 容器基础介绍

Spring IOC 容器在项目中的作用

将对象的构建统一解决
并自动维护对象的依赖关系，从而降低实现成本
...

spring-1.jpg

IOC(Inversion of Control) 控制反转

是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。

系统中通过引入实现了IoC模式的IoC容器，即可由IoC容器来管理对象的生命周期、依赖关系等，从而使得应用程序的配置和依赖性规范与实际的应用程序代码分离。其中一个特点就是通过文本的配置文件进行应用程序组件间相互关系的配置，而不用重新修改并编译具体的代码。

在我们开发中，经常会A类引用B类、C类、D类...，如果全部交给我们自己来维护这些类的依赖关系，工作量比较大而且很容易出错，而IOC容器的出现，正式为解决这一问题，其可以将对象的构建方法进行统一，并自动维护对象的依赖关系，从而降低系统的实现成本。实现方式：提前对目标对象基于XML进行声明，或使用注解进行声明。

具体demo如下。

pom.xml

    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.demo.spring</groupId>
    <artifactId>spring-test</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <spring.version>4.3.8.RELEASE</spring.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>
    </dependencies>
</project>

实现实体Bean的构建

基于ClassName的构建
基于构造方法的构建
静态工厂的方法创建
FactoryBean创建

spring.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 class="com.demo.spring.HelloSpring"></bean>
    
        <!-- 指定构造函数构建 基于反射构建-->
        <bean class="com.demo.spring.HelloSpring">
            <constructor-arg index="0" value="zyy"/>
            <constructor-arg name="age" value="18"/>
        </bean>
    
        <!-- 静态工厂方法构建-->
        <bean id="helloSpring" class="com.demo.spring.HelloSpring" factory-method="buid">
            <constructor-arg name="type" value="A"></constructor-arg>
        </bean>
    
        <!-- FactoryBean创建 自定义创建bean-->
        <bean id="driver" class="com.demo.spring.DriverFactoryBean" >
           <property name="jdbcUrl" value="jdbc:mysql://192.168.5.104:3306"></property>
        </bean>
    </beans>

HelloSpring,java

    package com.demo.spring;

    /**
     * com.demo.spring
     *
     * @author Zyy
     * @date 2019/2/12 15:50
     */
    public class HelloSpring {
        private String name;
        private int age;
    
        public HelloSpring() {
        }
    
        public HelloSpring(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        //静态工厂以及AB测试
        public static HelloSpring buid(String type) {
            if ("A".equals(type)) {
                return new HelloSpring("zyy",18);
            } else if ("B".equals(type)) {
                return new HelloSpring("xxx",20);
            } else {
               throw new IllegalArgumentException("argument must A or B");
            }
    
        }
    }

DriverFactoryBean.java

package com.demo.spring;

import org.springframework.beans.factory.FactoryBean;

import java.sql.Driver;
import java.sql.DriverManager;

/**
 * com.demo.spring
 *
 * @author Zyy
 * @date 2019/2/12 16:13
 */
public class DriverFactoryBean implements FactoryBean {
    private String jdbcUrl;

    public Object getObject() throws Exception {
        return DriverManager.getDriver(jdbcUrl);
    }

    public Class<?> getObjectType() {
        return Driver.class;
    }

    public boolean isSingleton() {
        return true;
    }

    public String getJdbcUrl() {
        return jdbcUrl;
    }

    public void setJdbcUrl(String jdbcUrl) {
        this.jdbcUrl = jdbcUrl;
    }
}

bean的基本特性

作用范围
生命周期
装载机制

作用范围

bean很多是无状态的，对于无状态的对象可以采取单例，而有状态的对象则必须用是多例模式进行创建，通过scope可以进行设置

scope="prototype"
scope="singleton"

例如

<bean id="di" class="com.demo.spring.DI" scope="singleton"/>

如果一个bean设置成prototype 则可以通过可以BeanFactoryAware 获取BeanFactory对象，即可每次获取都是新对象。

生命周期

Bean对象的创建、初始化、销毁即是Bean的生命周期。通过init-method、destroy-method属性可以分别指定构建方法和初始方法。

<bean id="di" class="com.demo.spring.DI" scope="singleton" init-method="init" destroy-method="destroy"/>

或者可以让Bean去实现initializingBean.afterPropertiesSet()、DisposableBean.destroy()方法。分别对应初始方法和销毁方法。

加载机制

指定Bean在何时进行加载。设置lazy-init。
当为true：懒加载，用到的时候才创建对象
当为false：容器启动时，就创建对象

<bean id="di" lazy-init="true" class="com.demo.spring.DI" scope="singleton" init-method="init" destroy-method="destroy"/>

什么时候使用懒加载？

懒加载会使容器启动更快，而非懒加载可以让容器启动时更快的发现程序中的错误，一般我们选择非懒加载。

spring依赖注入

一个bean依赖其他的bean由springIOC容器统一的管理进行注入，无需自己外部传入，内部创建进行处理。

依赖注入的几种方式

set方法注入
构造方法注入
自动注入（byName，byType）
依赖方法注入（lookup-method）

自动注入（byName，byType）

DI.java

 package com.demo.spring;

/**
 * com.demo.spring
 *
 * @author Zyy
 * @date 2019/2/12 16:35
 */
public class DI {
}

HelloSpring.java

package com.demo.spring;

/**
 * com.demo.spring
 *
 * @author Zyy
 * @date 2019/2/12 15:50
 */
public class HelloSpring {
    private String name;
    private int age;
    private DI di;

    public HelloSpring() {
    }

    public HelloSpring(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public DI getDi() {
        return di;
    }

    public void setDi(DI di) {
        this.di = di;
    }

    //静态工厂以及AB测试
    public static HelloSpring buid(String type) {
        if ("A".equals(type)) {
            return new HelloSpring("zyy",18);
        } else if ("B".equals(type)) {
            return new HelloSpring("xxx",20);
        } else {
           throw new IllegalArgumentException("argument must A or B");
        }

    }
}

spring.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 class="com.demo.spring.HelloSpring"></bean>

    <!-- 指定构造函数构建 基于反射构建-->
    <bean id="helloByName" class="com.demo.spring.HelloSpring" autowire="byName">
        <constructor-arg index="0" value="zyy"/>
        <constructor-arg name="age" value="18"/>
    </bean>
    <!-- byName-->
    <bean id="di" class="com.demo.spring.DI"/>

    <!-- byType时，如果bean相同 可以指定primary为true 来选择要注入哪一个-->
    <bean class="com.demo.spring.DI" primary="true"/>
    <bean class="com.demo.spring.DI"/>

    <!-- 静态工厂方法构建-->
    <bean id="helloSpring" class="com.demo.spring.HelloSpring" factory-method="buid">
        <constructor-arg name="type" value="A"></constructor-arg>
    </bean>

    <!-- FactoryBean创建 自定义创建bean-->
    <bean id="driver" class="com.demo.spring.DriverFactoryBean" >
       <property name="jdbcUrl" value="jdbc:mysql://192.168.5.104:3306"></property>
    </bean>
</beans>

依赖方法注入（lookup-method）

一个单例的bean依赖了一个多例的bean，为了每次获取多例的bean是不同的

DI.java

package com.demo.spring;

/**
 * com.demo.spring
 *
 * @author Zyy
 * @date 2019/2/12 16:35
 */
public class DI {

    public void inject() {
        System.out.println(" inject ");
    }

    public void init() {

    }

    public void destroy () {

    }
}

LookUpTest.java

package com.demo.spring;

/**
 * com.demo.spring
 *
 * @author Zyy
 * @date 2019/2/12 18:20
 */
public abstract class LookUpTest {

    public void create() {
        getDi().inject();
    }

    //这个抽象方法由spring采用cglib（动态字节码）进行实现
    public abstract DI getDi();
}

spring.xml

<bean class="com.demo.spring.LookUpTest" >
    <lookup-method name="getDi"/>
</bean>

该操作的原理是基于动态代理技术，重新生成一个类继承目标类（cglib），然后重写抽象方法达到注入目的。

对于单例bean依赖多例bean这种情也可以通过实现ApplicationContextAware、BeanFactoryAware接口获取BeanFactory实例，从而调用geBean()方法获取新的实例，推荐使用这种方法，比lookup-method逻辑清晰。

DI.java

package com.demo.spring;

/**
 * com.demo.spring
 *
 * @author Zyy
 * @date 2019/2/12 16:35
 */
public class DI {

    public void inject() {
        System.out.println(" inject ");
    }

    public void init() {

    }

    public void destroy () {

    }
}

BeanFactoryAwareTest.java

package com.demo.spring;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;

/**
 * com.demo.spring
 *
 * @author Zyy
 * @date 2019/2/12 22:24
 */
public class BeanFactoryAwareTest implements BeanFactoryAware {

    private BeanFactory beanFactory;

    public void create() {
        beanFactory.getBean(DI.class).inject();
    }

    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
    }
}

测试

import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * PACKAGE_NAME
 *
 * @author Zyy
 * @date 2019/2/12 16:02
 */
public class SpringIOCTest {

    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        //context.getBean("helloSpring");
        //context.getBean("driver");
        context.getBean("helloByName");
    }
}

如有问题，欢迎留言：）

Spring 源码分析（一）之 Spring IOC 容器基础介

Spring 源码分析（一）之 Spring IOC 容器基础介绍

bean的基本特性

作用范围

生命周期

加载机制

spring依赖注入

依赖方法注入（lookup-method）

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

源代码

Spring