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

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");
    }
}

如有问题，欢迎留言：）

最后编辑于：2019.02.14 23:36:38

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 214,377评论 6赞 496
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 91,390评论 3赞 389
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 159,967评论 0赞 349
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 57,344评论 1赞 288
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 66,441评论 6赞 386
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 50,492评论 1赞 292
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 39,497评论 3赞 412
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 38,274评论 0赞 269
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 44,732评论 1赞 307
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 37,008评论 2赞 328
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 39,184评论 1赞 342
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 34,837评论 4赞 337
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 40,520评论 3赞 322
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 31,156评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,407评论 1赞 268
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 47,056评论 2赞 365
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 44,074评论 2赞 352

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