澳门新葡亰娱乐网站-www.142net-欢迎您

澳门新葡亰娱乐网站是因为你还没有找到一条正确的致富之路,www.142net是将所有的游戏都汇集在一起的官方平台,因为澳门新葡亰娱乐网站这个网站当中有着大量的游戏攻略,托IP定位技术,传达终端直接到达的精准传播方式。

自己实现简单Spring,Ioc容器的实现

来源:http://www.bhtsgq.com 作者:计算机知识 人气:176 发布时间:2019-05-30
摘要:IoC则是一种 软件设计格局,轻巧的话 Spring 因此工厂 反射来落到实处IoC。 上篇我们讲过,Ioc有二种选择方法,壹种是利用BeanFactory,另①种是ApplicationContext。那篇小说,大家不怕来讲第

IoC则是一种 软件设计格局,轻巧的话Spring因此工厂 反射来落到实处IoC。

上篇我们讲过,Ioc有二种选择方法,壹种是利用BeanFactory,另①种是ApplicationContext。那篇小说,大家不怕来讲第一种的落到实处。ApplicationContext比较前边一种方法进行了广大功力,实际使用中大家任重先生而道远也是选拔这种措施。

什么是Ioc?

规律简单表达:
其实就是通过深入分析xml文件,通过反射创设出我们所急需的bean,再将那几个bean挨个放到集结中,然后对外提供1个getBean()方法,以便大家收获那bean。
自己实现简单Spring,Ioc容器的实现。浅显来说仿佛同婚介所,只要求报告它找个什么的女对象,然后婚介就能够服从大家的供给,提供二个mm,若是婚介给我们的职员不符合必要,大家就能抛出特别。

Example

public class ApplicationContextIoc {

    public static void main(String[] args) {

        GenericApplicationContext context = new GenericApplicationContext();

        PropertyValue pv = new PropertyValue("name","Cat");
        MutablePropertyValues mpvs = new MutablePropertyValues();
        mpvs.addPropertyValue(pv);

        GenericBeanDefinition bd = new GenericBeanDefinition();
        bd.setBeanClass(Animal.class);
        bd.setPropertyValues(mpvs);

        context.registerBeanDefinition("animal",bd);

        context.refresh();//整个流程主要多了这个方法

        Animal animal = context.getBean(Animal.class);
        animal.say();

    }

    public static class Animal {

        private String name;

        public Animal() {
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public void say(){
            System.out.println("Hello "   name);
        }
    }
}

这段代码大要上跟后边1篇看似,只是多出了三个refresh()方法。那么ApplicationContext和BeanFactory的异议在哪儿?

调控反转((Inversion of Control,英文缩写为IoC)把创设对象的任务交给框架,是框架的第叁特色,并非面向对象编制程序的专项使用术语。它归纳借助注入(Dependency Injection,简称DI和依赖查找(Dependency Lookup)。

说得轻松一点正是大家在写Java代码的时候大家的指标不须要本人来创设,而是经过容器来扶助我们调换。用大家生活中的例子来讲,打个比如,我们想要一辆汽车,我们不容许去自身造一辆小车,而是去买一辆。

总结完结:

GenericApplicationContext结构

先来看下GenericApplicationContext的组织。

public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {

    private final DefaultListableBeanFactory beanFactory;

    @Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
            throws BeanDefinitionStoreException {

        this.beanFactory.registerBeanDefinition(beanName, beanDefinition);
    }

}

很明朗,调用registerBeanDefinition()时其实如故由DefaultListableBeanFactory去贯彻,此处GenericApplicationContext它只是作为二个代理类存在而已。一样的getBean()方法也是由BeanFactory内部去达成的。

全体的类都会在spring容器中注册,告诉spring你是个什么东西,你须要怎么着事物,然后spring会在系统运转到合适的时候,把您要的事物主动给你,相同的时间也把你提交其余急需您的东西。全部的类的开创、销毁都由 spring来决定,也便是说调控目的生活周期的不再是援引它的对象,而是spring。对于有个别具体的指标来讲,在此以前是它调整别的对象,今后是兼备目标都被spring调整,所以那叫调整反转。

refresh()方法

来根本看下refresh()的逻辑,它是在父类AbstractApplicationContext定义,里面共有拾1个点子,在此间大约把那些办法的流水生产线走一回。

    AbstractApplicationContext.class

    @Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);

                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                initMessageSource();

                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                onRefresh();

                // Check for listener beans and register them.
                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons.
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                finishRefresh();
            }

            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - "  
                            "cancelling refresh attempt: "   ex);
                }

                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();

                // Reset 'active' flag.
                cancelRefresh(ex);

                // Propagate exception to caller.
                throw ex;
            }

            finally {
                // Reset common introspection caches in Spring's core, since we
                // might not ever need metadata for singleton beans anymore...
                resetCommonCaches();
            }
        }
    }

Ioc容器的先河化

图片 1

image.png

一.亟需引用maven重视:

prepareRefresh()

安装容器的激活、关闭状态以及做一些校验动作,假设未将容器状态设置为已激活就去猎取bean则会抛出多个未激活的丰硕。

IoC容器初始化进度紧要透过以下多少个等第:
 <dependency>
            <groupId>org.jdom</groupId>
            <artifactId>jdom</artifactId>
            <version>1.1.3</version>
        </dependency>

obtainFreshBeanFactory()

上边我们讲到过ApplicationContext只是3个代理类而已,它对bean的一部分管制依旧由BeanFactory去达成的,此处便是去赢得BeanFactory。获取BeanFactory时是由此getBeanFactory()去操作的,那是多个虚幻方法,具体的逻辑是由子类GenericApplicationContext去落成。代码如下:

AbstractApplicationContext.class
@Override
public abstract ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException;


GenericApplicationContext.class
@Override
public final ConfigurableListableBeanFactory getBeanFactory() {
    return this.beanFactory;
}

能够看出来,其实BeanFactory是因此子类去成立,就算急需其他差别的BeanFactory只供给在子类中开创合适的BeanFactory就能够,而已无需修改那有些的代码,符合了“开放-闭合原则”。此处的BeanFactory是GenericApplicationContext的构造方法成立的。

一.解析阶段:Spring会分析Bean的XML配置文件,将XML成分进行抽象,抽象成Resource对象。

2.beans.xml

prepareBeanFactory(beanFactory)

对BeanFactory做连锁的配置,为承袭BeanFactory的局地操作做计划。

二.转变阶段:通过Resource对象将布署文件举办抽象后调换到Spring能够掌握的BeanDefinition结构。
<?xml version="1.0" encoding="UTF-8"?>
<beans>
    <bean id="user" class="com.example.domain.User" />
    <bean id="userDAO" class="com.example.dao.impl.UserDAOImpl" />
    <bean id="userService" class="com.example.service.UserService">
        <property name="userDAO" bean="userDAO" />
    </bean>
</beans>

postProcessBeanFactory(beanFactory)

安夸口eanFactory的继续管理,该方法用protected修饰,且默许达成为空,近来spring重写该措施的子类跟web情形有关,一般用来开始展览web情状。

三.挂号阶段:Spring IoC容器的落实,平素自上是beanfactory,但真正能够看作三个能够独立行使的ioc容器依旧DefaultListableBeanFactory。

3.BeanFactory

invokeBeanFactoryPostProcessors(beanFactory)

调用BeanFactory的后计算机,它运转的机会是在bean定义全部加载到容器事后,bean的成立以前。那个第贰用于修改容器的bean定义。与它相关的多个接口如下:

public interface BeanFactoryPostProcessor {
    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
    void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
}

那八个接口其实是二个接二连三关系,四个落到实处的效果是相似的,前者通过BeanFactory去修改bean定义,而后者直接通过BeanDefinitionRegistry去修改而已。

DefaultListableBeanFactory直接完成了BeanFactory接口,是全部bean加载的主导部分,是Spring注册及加载bean的私下认可完结,大家得以了然为Spring bean工厂的引擎。

本文由澳门新葡亰发布于计算机知识,转载请注明出处:自己实现简单Spring,Ioc容器的实现

关键词: 日记本 程序员 Spring学习笔记

上一篇:没有了

下一篇:没有了

最火资讯