精华内容
下载资源
问答
  • 这里是修真院后端小课堂,每...【Spring中的IOC什么意思 】 【修真院java小课堂】Spring中的IOC什么意思 大家好,我是IT修真院武汉分院第17期的学员汪天驰,一枚正直纯洁善良的java程序员,今天给大家分享一...

    这里是修真院后端小课堂,每篇分享文从

    【背景介绍】【知识剖析】【常见问题】【解决方案】【编码实战】【扩展思考】【更多讨论】【参考文献】

    八个方面深度解析后端知识/技能。

    大家好,我是IT修真院武汉分院的汪天驰,一枚正直纯洁善良的java程序员。

    今天给大家分享一下,修真院官网java任务1,深度思考中的知识点——Spring中的IOC是什么意思

    (1)背景介绍:

    Spring是一个开源的轻量级Java SE(Java 标准版本)/Java EE(Java 企业版本)开发应用框架,其目的是用于简化企业级应用程序开发。

    应用程序是由一组相互协作的对象组成。

    Spring框架除了帮我们管理对象及其依赖关系,还提供像通用日志记录、性能统计、安全控制、异常处理等面向切面的能力,

    还能帮我管理最头疼的数据库事务,本身提供了一套简单的JDBC访问实现,提供与第三方数据访问框架集成(如Hibernate、JPA),与各种Java EE技术整合(如Java Mail、任务调度等等),提供一套自己的web层框架Spring MVC、而且还能非常简单的与第三方web框架集成。

    从这里我们可以认为Spring是一个超级粘合平台,除了自己提供功能外,还提供粘合其他技术和框架的能力,从而使我们可以更自由的选择到底使用什么技术进行开发。

    Spring IOC

    SpringIOC-Iversion of Control

    即“控制反转”,不是什么技术,而是一种设计思想。

    在Java开发中,Ioc意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制。

    如何理解好Ioc呢?理解好Ioc的关键是要明确“谁控制谁,控制什么,为何是反转(有反转就应该有正转了),哪些方面反转了”,那我们来深入分析一下:

    谁控制谁,控制什么:

    传统Java SE程序设计,我们直接在对象内部通过new进行创建对象,是程序主动去创建依赖对象;

    而IoC是有专门一个容器来创建这些对象,即由Ioc容器来控制对 象的创建;

    谁控制谁?

    当然是IoC 容器控制了对象;

    控制什么?

    那就是主要控制了外部资源获取(不只是对象包括比如文件等)。

    为何是反转,哪些方面反转了:

    有反转就有正转,传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象,也就是正转;

    而反转则是由容器来帮忙创建及注入依赖对象;

    为何是反转?

    因为由容器帮我们查找及注入依赖对象,对象只是被动的接受依赖对象,所以是反转;

    哪些方面反转了?

    依赖对象的获取被反转了。

    (2)知识剖析:

     

    IOC的作用:

     1 IoC 是一种思想,一个重要的面向对象编程的法则,它能指导我们如何设计出松耦合、更优良的程序。

    传统应用程序都是由我们在类内部主动创建依赖对象,从而导致类与类之间高耦合,难于测试;

    有了IoC容器后,把创建和查找依赖对象的控制权交给了容器,由容器进行注入组合对象,

    所以对象与对象之间是 松散耦合,这样也方便测试,利于功能复用,更重要的是使得程序的整个体系结构变得非常灵活。

     

    IOC容器也是具有依赖注入功能的容器,IOC容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。

     应用程序无需直接在代码中new相关的对象,应用程序由IOC容器进行组装。在Spring中BeanFactory是IOC容器的实际代表者。

    Spring IOC容器如何知道哪些是它管理的对象呢?

    这就需要配置文件,Spring IOC容器通过读取配置文件中的配置元数据,通过元数据对应用中的各个对象进行实例化及装配。

    一般使用基于xml配置文件进行配置元数据,而且Spring与配置文件完全解耦的,可以使用其他任何可能的方式进行配置元数据,比如注解、基于java文件的、基于属性文件的配置都可以。

    DI:依赖注入  

    依赖注入(DI)是一种实现IOC的技术手段。

    理解DI的关键:谁依赖谁,为什么需要依赖,谁注入谁,注入了什么?

    ①.谁依赖谁?应用程序依赖于IoC容器。

    让spring创建sqlsession bean。也就是通过SqlSessionFactory创建SqlSession

    ②.为什么需要依赖?应用程序需要IoC容器来提供对象需要的外部资源(包括对象,文件等)。

    ③.谁注入谁?IoC容器注入应用程序某个对象,应用程序依赖的对象。

    ④.注入了什么?注入某个对象所需要的外部资源(包括对象、资源、变量数据)

     

    (3)常见问题:

    1 spring中的BeanFactory与ApplicationContext的作用和区别? 

    BeanFactory负责读取bean配置文档,管理bean的加载,实例化,维护bean之间的依赖关系,负责bean的声明周期。

    2. ApplicationContext除了提供上述BeanFactory所能提供的功能之外,还提供了更完整的框架功能:

    比如资源访问,事件传递,通过ApplicationContext扩展了ResourceLoader(资源加载器)接口。 

     3. ApplicationContext的初始化和BeanFactory有一个重大的区别:BeanFactory在初始化容器时,并未实例化Bean,直到第一次访问某个Bean时才实例目标Bean;

    而ApplicationContext则在初始化应用上下文时就实例化所有的单实例的Bean。

     因此ApplicationContext的初始化时间会比BeanFactory稍长一些. .Spring容器能够自动装配相互合作的bean,

     这意味着容器不需要construor-arg和property配置,能通过Bean工厂自动处理bean之间的协作 

    2 什么是自动装配 .

    Spring容器能够自动装配相互合作的bean,这意味着容器不需要construor-arg和property配置,能通过Bean工厂自动处理bean之间的协作

    (4)编码实战:

    (5)拓展思考:

    IOC的优点

     

    IOC 或 依赖注入把应用的代码量降到最低。它使应用容易测试,单元测试不再需要单例和JNDI查找机制。

    最小的代价和最小的侵入性使松散耦合得以实现。IOC容器支持加载服务时的饿汉式初始化和懒加载。 

    (6)参考文献:

     http://www.cnblogs.com/chenssy/p/9576769.html

    (7)更多讨论:

    Q1:IOC有哪些缺点?

    A1:

    1,创建对象的步骤变复杂了

    2,通过反射来创建对象会造成效率上的损耗

    3,缺少IDE重构支持,如果修改了类名还需要到XML文件中手动修改

    Q2:By Type和 By Name的区别?

    A2:byName 通过参数名 自动装配,如果一个bean的name 和另外一个bean的 property 相同,就自动装配。
         byType 通过参数的数据类型自动自动装配,如果一个bean的数据类型和另外一个bean的property属性的数据类型兼容,  就自动装配。

    Q3:getBean(“someBean”)时做了什么? 

    A3:如果bean是单例,而且对象没有实例化,则按照上面写的流程利用反射new一个出来,然后放到Map里面。如果已经实例化,则直接从Map里面取出来直接返回。 如果是多例,每次都new一个返回。

    PPT链接 视频链接

    今天的分享就到这里啦,欢迎大家点赞、转发、留言、拍砖~

    ------------------------------------------------------------------------------------------------------------

    “我们相信人人都可以成为一个工程师,现在开始,找个师兄,带你入门,学习的路上不再迷茫。”

    技能树.IT修真院

    展开全文
  • 【Spring中的IOC什么意思,为什么要用IOC而不是New来创建实例? 】 Spring中的IOC什么意思,为什么要用IOC而不是New来创建实例? 一.背景介绍 Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java ...

    这里是修真院后端小课堂,每篇分享文从

    八个方面深度解析后端知识/技能,本篇分享的是:

    【Spring中的IOC是什么意思,为什么要用IOC而不是New来创建实例? 】

    Spring中的IOC是什么意思,为什么要用IOC而不是New来创建实例?

    一.背景介绍

    Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构,分层架构允许使用者选择使用哪一个组件,同时为 J2EE 应用程序开发提供集成的框架。Spring的核心是控制反转(IoC)和面向切面(AOP)。

    二.知识剖析

    什么是反转控制(IOC)?

    是一种是面向对象编程中的一种设计原则,用来减低计算机代码之间的耦合度。其基本思想是:借助于“

    第三方”实现具有依赖关系的对象之间的解耦。

    通过控制反转客户端不需要再主动创建对象,只需要通过IOC,由IOC去创建就可以了

    由应用程序创建对象转变为由IOC容器来创建,用于控制创建对象的主体发生了改变,这是控制反转

    应用程序需要的对象信息由IOC容器创建后注入,也就是说依赖于容器来注入,这是依赖注入

    表达的是一个东西,只是描述的角度不同。

    IOC,从容器的角度出发,容器反向控制应用程序对象的创建。

    DI,从应用程序的角度出发,应用程序需要依赖容器注入对象。

    三.常见问题

    理解好IoC的关键是:谁控制谁,控制什么了,为何是反转,在哪些方面反转了。

    谁控制谁,控制什么了

    传统JavaSE程序设计,我们在对象内部直接通过new进行创建对象,是程序主动去创建依赖对象,而IoC有一个专门的容器来创建这些对象,即由IoC容器来创建这些对象的创建。谁控制谁?当然是由IoC容器控制了对象;控制了什么?那就主要是控制了外部资源获取(包括对象、文件等)。

    为何是反转,在哪些方面反转了

    有反转就有正转。传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象,也就是正转。而反转则是由容器来帮忙创建及注入依赖对象。为何是反转?因为容器帮我们查找和注入依赖对象,对象只是被动的接受依赖对象,所以是反转。哪些方面反转了?依赖对象的获取反转了。

    理解DI的关键:谁依赖谁,为什么需要依赖,谁注入谁,注入了什么

    1.谁依赖谁?当然是应用程序依赖于IoC容器。

    2.为什么需要依赖?应用程序需要IoC容器来提供对象需要的外部资源(包括对象,文件等)。

    3.谁注入谁?很明显是IoC容器注入应用程序某个对象,应用程序依赖的对象。

    4.注入了什么?就是注入某个对象所需要的外部资源(包括对象、资源、变量数据)

    四.扩展和思考

    spring中Bean的五个作用域

    当通过spring容器创建一个Bean实例时,不仅可以完成Bean实例的实例化,还可以为Bean指定特定的作用域。Spring支持如下5种作用域:

    singleton:单例模式,在整个Spring IoC容器中,使用singleton定义的Bean将只有一个实例

    prototype:原型模式,每次通过容器的getBean方法获取prototype定义的Bean时,都将产生一个新的Bean实例

    request:对于每次HTTP请求,使用request定义的Bean都将产生一个新实例,即每次HTTP请求将会产生不同的Bean实例。只有在Web应用中使用Spring时,该作用域才有效

    session:对于每次HTTP Session,使用session定义的Bean都将产生一个新实例。同样只有在Web应用中使用Spring时,该作用域才有效

    globalsession:每个全局的HTTP Session,使用session定义的Bean都将产生一个新实例。典型情况下,仅在使用portlet context的时候有效。同样只有在Web应用中使用Spring时,该作用域才有效

    其中比较常用的是singleton和prototype两种作用域。对于singleton作用域的Bean,每次请求该Bean都将获得相同的实例。容器负责跟踪Bean实例的状态,负责维护Bean实例的生命周期行为;如果一个Bean被设置成prototype作用域,程序每次请求该id的Bean,Spring都会新建一个Bean实例,然后返回给程序。在这种情况下,Spring容器仅仅使用new 关键字创建Bean实例,一旦创建成功,容器不在跟踪实例,也不会维护Bean实例的状态。

    如果不指定Bean的作用域,Spring默认使用singleton作用域。Java在创建Java实例时,需要进行内存申请;销毁实例时,需要完成垃圾回收,这些工作都会导致系统开销的增加。因此,prototype作用域Bean的创建、销毁代价比较大。而singleton作用域的Bean实例一旦创建成功,可以重复使用。因此,除非必要,否则尽量避免将Bean被设置成prototype作用域。

    globalsession:每个全局的HTTP Session,使用session定义的Bean都将产生一个新实例。典型情况下,仅在使用portlet context的时候有效。同样只有在Web应用中使用Spring时,该作用域才有效

    五.参考文献

    https://www.cnblogs.com/goody9807/p/7472127.html

    https://blog.csdn.net/weixin_41776493/article/details/80035932

    展开全文
  • IoC控制反转是什么意思

    万次阅读 多人点赞 2018-06-28 20:58:36
    Spring最大的特点,相信大家在网上看了许多,都知道是控制反转(IOC),或者叫依赖注入(DI),那么究竟什么是控制反转,什么是依赖注入呢?IOC(inversion of control)控制反转模式;控制反转是将组件间的依赖关系...

    最近由于日本项目的需要,开始学习Spring框架的东西。虽然框架被日方公司进行了一定的修改,但Spring大体原理是不变的。Spring最大的特点,相信大家在网上看了许多,都知道是控制反转(IOC),或者叫依赖注入(DI),那么究竟什么是控制反转,什么是依赖注入呢?

    IOC(inversion of control)控制反转模式;控制反转是将组件间的依赖关系从程序内部提到外部来管理; 

    DI(dependency injection)依赖注入模式;依赖注入是指将组件的依赖通过外部以参数或其他形式注入;

    看起来很绕是不是,这样,先把这个问题搁置在这里,咱们先谈一些别的东西。我先提一个东西:程序的耦合。看下面这个例子

    class A {
      AInterFace a;
      A(){};
      Amethod() {
         a = new AInterfaceImpl();
      }
    }

    Class A中我先声明了一个借口a,然后构造了A(只不过什么都没写),定义了一个方法,在这个方法里面实例化AInterfaceImpl这个类出来,那么Class A和AInterfaceImpl就存在了耦合的关系,也可以说Class A依赖于AInterfaceImpl,没有AInterfaceImpl,Class A就创建不出来。

    这只是简单举个例子,只是一种耦合关键,相信大家在实际写代码的时候肯定遇到过这样的情况,一个类里面要new好几个其他类,程序运行是全部new的,但实际运行的时候未必用得上,这样就造成了一定的运算和存储的浪费。

    控制反转,就是把这种依赖关系剥离开(需要在class A中new的类,现在不用了,从其他地方获得),把里面对象的创建,依赖的代码,交给容器来实现(是的,Spring就是个容器),将原有的依赖关系(Class A和AInterfaceImpl依赖,而不是BInterfaceImpl)交给xml、properties这样的文件去描述。


    这样做有什么好处?由于把对象生成放在了XML里定义,所以当我们需要换一个实现子类将会变成很简单(一般这样的对象都是实现于某种接口的),只要修改XML就可以了。当然这种方式对于刚刚新接触的朋友来说可能不太习惯,经常忘记修改xml导致莫名其妙的错误也是家常便饭(别问我怎么知道的)。

    所以控制反转IOC是说创建对象的控制权进行转移,以前创建对象的主动权和创建时机是由自己把控的,而现在这种权力转移到第三方,比如转移交给了IOC容器,它就是一个专门用来创建对象的工厂(BeanFactory),你要什么对象,它就给你什么对象,有了 IOC容器,依赖关系就变了,原先的依赖关系就没了,它们都依赖IOC容器了,通过IOC容器来建立它们之间的关系。

    展开全文
  • IoC什么 Ioc—Inversion of Control,即“控制反转”,不是什么技术,而是一种设计思想。在Java开发中,Ioc意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制 通过控制反转客户端不需要...

    大家好,我是IT修真院西安分院第4期的JAVA学员,一枚正直纯洁善良的JAVA程序员。今天给大家分享一下,修真院官网Java任务1,深度思考中的知识点JDBC连接池原理
    一、.背景介绍
    在没用使用Spring的时候——也就是没有依赖注入的时候,java应用程序的类与类之间要实现相互的功能协作是比较费劲的,某个类(A)要实现它的功能如果需要依赖另一个类(B)的协作的话,就需要在A类中主动创建出B类的对象,才能使用B类的方法完成功能(这里看官就不要去纠结静态方法之类的情况了)。这等于是A类需要负责B类对象整个生命周期的管理。在极度简单的情况下,在一个类中new出另一个类的对象似乎并没有什么问题,但是复杂的应用程序类与类的协作关系往往是多边的,我们并不知道一个类功能的实现会依赖多少个另类对象来协作,所以在类中自行创建对象并且管理对象的整个生命周期,会造成代码的高度耦合以及不可想象的复杂度。那么,试想,如果我们能将对象的生命周期交给第三方组件来管理,当某个类需要另外的对象时第三方组件就直接创建出来交给它,这样,类就可以只专注于自己功能的实现,而不用去管理其他类对象的生命周期,这样类的功能就单纯了很多。是的,你一定已经明白了,Spring(容器)就是这个第三方组件。
    我们只需要告诉Spring(容器)有哪些对象需要管理就行了,不用去关心Spring框架是如何创建对象的。这样,当某个类A需要类B对象时,如果类B已经声明交给了Sping容器管理,那么在程序运行到类A需要类B时,Spring容器就通过依赖注入的方式,将类B对象注入到类A中协助完成业务功能。通过第三方组件的依赖注入,对象无需再自行的创建和管理类与类之间的依赖关系了。对象的创建依赖注入的方式也有多种,譬如接口注入,构造方法注入,setter方法注入等等。说到这里,你对依赖注入应该有比较直白的认知了。至于为什么要依赖注入,上文已经说得很明白了,就是为了减少代码中组件之间的耦合度,我们还是先通过简单示例来直观感受下依赖注入比自己管理对象的好处吧
    二、知识剖析
    IoC是什么

    Ioc—Inversion of Control,即“控制反转”,不是什么技术,而是一种设计思想。在Java开发中,Ioc意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制
    通过控制反转客户端不需要再主动创建对象,只需要通过IOC,由IOC去创建就可以了 由应用程序创建对象转变为由IOC容器来创建,用于控制创建对象的主体发生了改变,这是控制反转 应用程序需要的对象信息由IOC容器创建后注入,也就是说依赖于容器来注入,这是依赖注入 表达的是一个东西,只是描述的角度不同。 IOC,从容器的角度出发,容器反向控制应用程序对象的创建;
     
    DI(Dependency Injection),依赖注入;

    DI,从应用程序的角度出发,应用程序需要依赖容器注入对象;

    Spring是从哪里把对象给你的?

    Spring的容器为我们创建对象。容器的概念在java中你最熟悉的莫过于Tomcat了,它正是一个运行Servlet的web容器,而Spring要想实现依赖注入功能,就离不开对象生产的容器——如果没有容器负责对象的创建管理,你的程序代码只是喊要对象了,Spring也无处给你啊。实际上,容器是Spring框架实现功能的核心。

    实际上,容器里面什么都没有,决定容器里面放什么对象的是我们自己,决定对象之间的依赖关系的,也是我们自己,容器只是给我们提供一个管理对象的空间而已。

    我们怎么向容器中放入我们需要容器代为管理的对象呢?

    这就涉及到Spring的应用上下文了。什么是应用上下文呢,你可以简单的理解成就是将你需要Spring帮你管理的对象放入容器的那么一种。一种容器对象——是的,应用上下文即是Spring容器抽象的一种实现;而我们常见的ApplicationContext本质上说就是一个维护Bean定义以及对象之间协作关系的高级接口。

    听起来是不是很抽象拗口?那你再读一遍呢。。。这里,我们必须明确,Spring的核心是容器,而容器并不唯一,框架本身就提供了很多个容器的实现,大概分为两种类型:一种是不常用的BeanFactory,这是最简单的容器,只能提供基本的DI功能;还有一种就是继承了BeanFactory后派生而来的应用上下文,其抽象接口也就是我们上面提到的的ApplicationContext,它能提供更多企业级的服务,例如解析配置文本信息等等,这也是应用上下文实例对象最常见的应用场景。有了上下文对象,我们就能向容器注册需要Spring管理的对象了。
    spring中bean配置和bean注入
    Bean基本配置
    1 基于xml配置Bean
    对于基于XML的配置,Spring 2.0以后使用Schema的格式,使得不同类型的配置拥有了自己的命名空间,是配置文件更具扩展性
    2 使用注解定义Bean
    Spring容器成功启动的三大要件分别是:Bean定义信息、Bean实现类以及Spring本身。如果采用基于XML的配置,Bean定义信息和Bean实现类本身是分离的,而采用基于注解的配置方式时,Bean定义信息即通过在Bean实现类上标注注解实现。
    下面是使用注解定义一个DAO的Bean:ng本身。
    package com.baobaotao.anno; import org.springframework.stereotype.Component; import org.springframework.stereotype.Repository; //①通过Repository定义一个DAO的Bean @Component(“userDao”) public class UserDao { }。
    在①处,我们使用@Component注解在UserDao类声明处对类进行标注,它可以被Spring容器识别,Spring容器自动将POJO转换为容器管理的Bean。 它和以下的XML配置是等效的:
    3 基于java类提供Bean定义信息
    三、常见问题
    1 spring中的BeanFactory与ApplicationContext的作用和区别?
    2 什么是自动装配
    四、解决方案解决方案
    1 spring中的BeanFactory与ApplicationContext的作用和区别
    . BeanFactory负责读取bean配置文档,管理bean的加载,实例化,维护bean之间的依赖关系,负责bean的声明周期。 2. ApplicationContext除了提供上述BeanFactory所能提供的功能之外,还提供了更完整的框架功能: 比如资源访问,事件传递,通过ApplicationContext扩展了ResourceLoader(资源加载器)接口。 3. ApplicationContext的初始化和BeanFactory有一个重大的区别:BeanFactory在初始化容器时,并未实例化Bean,直到第一次访问某个Bean时才实例目标Bean;而ApplicationContext则在初始化应用上下文时就实例化所有的单实例的Bean。因此ApplicationContext的初始化时间会比BeanFactory稍长一些.
    .Spring容器能够自动装配相互合作的bean,这意味着容器不需要construor-arg和property配置,能通过Bean工厂自动处理bean之间的协作
    2 什么是自动装配
    .Spring容器能够自动装配相互合作的bean,这意味着容器不需要construor-arg和property配置,能通过Bean工厂自动处理bean之间的协作/p>
    五、编码实战

    public class Man implements Human { 
    	private QQCar car; public Man() { 
    	this.car = new QQCar(); } 
    	@Override public void xiabibi() { } 
    	public void driveCar(){ car.drive(); } }
    

    接口Car暂有两个实现:奔驰车和QQ车,在以上Man类和QQCar类高度耦合的代码中,老司机通过构造器只创建了QQ车对象,所以只能开QQ车,那么老司机想开奔驰怎么办呢,你让他重新创建奔驰车的对象吗?这样高度耦合的代码似乎是毫无办法的,那么,我们通过注入对象的方式对上述代码做一番改进:

    public class Man implements Human {
    	 private Car car; public Man(Car car) { this.car = car; }
    	  @Override public void xiabibi() { } public void driveCar() { car.drive(); }
    	   }
    

    以上代码根据多态特性,通过构造器接口注入的方式屏蔽掉了具体的对象实现,这样,老司机就能想开什么车就开什么车了。这就是依赖注入带来的好处。
    六、扩展思考
    6.1 Spring为我们提供了哪些类型的容器实现,供我们在什么样样的应用场景选择
    6.2 在xml文件中配置依赖注入都有哪几种方式
    七、参考文献
    https://www.cnblogs.com/chenbenbuyi/p/8166304.html
    https://www.cnblogs.com/wuchanming/p/5426746.html
    https://www.cnblogs.com/liwendeboke/p/6229564.html
    八、更多讨论
    1、 spring容器启动时做了什么?
    通过ApplicationContext context = new ClassPathXmlApplicationContext(“beans.xml”);这行代码的beans.xml来说吧。
    这个bean.xml文件里一般写的是这些内容
    bean标签定义了这个bean的唯一id,其实bean标签里也可以使用name=“someBean”,不过这样会导致如果有多个name名称相同,则前面定义的bean会被覆盖掉,所以一般为了防止这种情况出现,推荐使用id属性。
    spring容器在创建的时候会使用XmlBeanDefinitionReader这个类去解析这个xml文件,解析完成一个bean后把这个bean标签的信息放到一个叫BeanDefinition的对象里面。BeanDefinition是Spring IOC所识别的数据结构。有多少个bean标签,就有多少个BeanDefinition对象,最后把BeanDefinition对象放到Map里面。
    2、getBean(“someBean”)时做了什么?
    如果bean是单例,而且对象没有实例化,则按照上面写的流程利用反射new一个出来,然后放到Map里面。如果已经实例化,则直接从Map里面取出来直接返回。 如果是多例,每次都new一个返回。
    3、 IOC的优点是什么?
    IOC 或 依赖注入把应用的代码量降到最低。它使应用容易测试,单元测试不再需要单例和JNDI查找机制。最小的代价和最小的侵入性使松散耦合得以实现。IOC容器支持加载服务时的饿汉式初始化和懒加载。

    技能树.IT修真院“我们相信人人都可以成为一个工程师,现在开始,找个师兄,带你入门,掌控自己学习的节奏,学习的路上不再迷茫”。
    这里是技能树.IT修真院,成千上万的师兄在这里找到了自己的学习路线,学习透明化,成长可见化,师兄1对1免费指导。快来与我一起学习吧~我的邀请码:28769611,或者你可以直接点击此链接:http://www.jnshu.com/login/1/28769611

    视频链接
    PP链接

    展开全文
  • 今天给大家分享一下,修真院官网JAVA任务一,扩展思考中的知识点——SPRING中的IOC什么意思,为什么要用IOC而不是NEW来创建实例? 一、背景介绍 spring是一种多层的J2EE应用程序框架,是以Rod Johson编写的...
  • 在spring中什么ioc IoC就是Inversion of Control,控制反转。在Java开发中,IoC意味着将你设计好的类交给系统去控制,而不是在你的类内部控制。这称为控制反转。 下面我们以几个例子来说明什么IoC 假设我们要...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 665
精华内容 266
关键字:

ioc什么意思