ioc 订阅
国际奥林匹克委员会,简称为国际奥委会,是一个国际性的、非政府的、非赢利的组织。是奥林匹克运动的领导机构,它于1981年9月17日得到瑞士联邦议会的承认,确认其为无限期存在的具有法人资格的国际机构。总部位于瑞士洛桑。由法国人皮埃尔·德·顾拜旦建立,首任主席是泽麦特里乌斯·维凯拉斯。据2017年01月16日《人民日报》(海外版)第06版介绍,国际奥委会有100个委员和32个荣誉委员。 [1]  1894年6月23日,国际奥委会在巴黎召开的国际体育代表大会上成立,发起人是法国的教育家皮埃尔·德·顾拜旦男爵。成立之初总部设在巴黎,1914年第一次世界大战爆发,为避战火,1915年4月10日迁入有“国际文化城”之称的瑞士洛桑。国际奥委会根据现代奥林匹克运动创始人顾拜旦的理想,恢复奥林匹克运动的目的,在于增强各国运动员之间的友谊与团结,促进世界和平以及各国人民之间的相互了解,发展世界体育运动。《奥林匹克宪章》明文规定,国际奥委会的宗旨是:鼓励组织和发展体育运动和组织竞赛;在奥林匹克理想指导下,鼓舞和领导体育运动,从而促进和加强各国运动员之间的友谊。国际奥委会组织举办奥林匹克运动会、青年奥林匹克运动会、冬季奥林匹克运动会、残疾人奥林匹克运动会。它组织的首届夏季奥运会于1896年于希腊雅典举行,首届冬奥会于1924年在法国霞慕尼举行。在2018世界品牌500强排行榜中,国际奥林匹克委员会排名第125位。 [2] 展开全文
国际奥林匹克委员会,简称为国际奥委会,是一个国际性的、非政府的、非赢利的组织。是奥林匹克运动的领导机构,它于1981年9月17日得到瑞士联邦议会的承认,确认其为无限期存在的具有法人资格的国际机构。总部位于瑞士洛桑。由法国人皮埃尔·德·顾拜旦建立,首任主席是泽麦特里乌斯·维凯拉斯。据2017年01月16日《人民日报》(海外版)第06版介绍,国际奥委会有100个委员和32个荣誉委员。 [1]  1894年6月23日,国际奥委会在巴黎召开的国际体育代表大会上成立,发起人是法国的教育家皮埃尔·德·顾拜旦男爵。成立之初总部设在巴黎,1914年第一次世界大战爆发,为避战火,1915年4月10日迁入有“国际文化城”之称的瑞士洛桑。国际奥委会根据现代奥林匹克运动创始人顾拜旦的理想,恢复奥林匹克运动的目的,在于增强各国运动员之间的友谊与团结,促进世界和平以及各国人民之间的相互了解,发展世界体育运动。《奥林匹克宪章》明文规定,国际奥委会的宗旨是:鼓励组织和发展体育运动和组织竞赛;在奥林匹克理想指导下,鼓舞和领导体育运动,从而促进和加强各国运动员之间的友谊。国际奥委会组织举办奥林匹克运动会、青年奥林匹克运动会、冬季奥林匹克运动会、残疾人奥林匹克运动会。它组织的首届夏季奥运会于1896年于希腊雅典举行,首届冬奥会于1924年在法国霞慕尼举行。在2018世界品牌500强排行榜中,国际奥林匹克委员会排名第125位。 [2]
信息
创建者
皮埃尔·德·顾拜旦(法国人)
外文名
International Olympic Committee(英),Comité international olympique (法)
简    称
国际奥委会(IOC)
成    员
206国家和地区
总    部
瑞士洛桑(Lausanne)
中文名
国际奥林匹克委员会
官    网
http://www.olympic.org/
成立时间
1894年6月23日
现任主席
托马斯·巴赫
官方语言
英语、法语
国际奥林匹克委员会发展历程
1894年6月16日-24日,根据世界著名的国际体育活动家,法国人皮埃尔·德·顾拜旦的建议,来自法国、英国、希腊、瑞典、意大利、俄国(俄罗斯)、比利时、捷克斯洛伐克、新西兰、美国、阿根廷、匈牙利12个国家的49个体育组织的代表,在巴黎索邦神学院举行国际体育运动代表大会。在开幕式上,法国著名古希腊文化专家切奥多尔·莱拉赫发表演说,巴黎国家歌剧院合唱团为大会演唱了阿波罗颂歌,唤起了与会者对古奥运会的神往。 [3]  会议期间,又先后有21个国家致函,向大会表示支持和祝贺。这次会议通过了成立国际奥委会(成立时间1894年6月23日,成立时的名称是“奥林匹克运动会国际委员会”)的决议,并从79名正式代表中选出15人任第1届国际奥委会委员。大会还决定由奥运会举办国的国际奥委会委员担任国际奥委会主席。由于首届奥运会定于1896年在希腊首都雅典举行,因此希腊委员泽麦特里乌斯·维凯拉斯当选国际奥委会第一任主席,顾拜旦为秘书长。会议规定法语(现为英、法两种语言)为国际奥委会法定语言。大会还决定沿袭古奥运会传统,每四年举行一次运动会,还规定奥运会的比赛项目为田径、水上运动(包括帆船、划船、游泳)、击剑、摔跤、拳击、马术、射击、体操、球类运动等。第一届奥运会原定于1900年于巴黎举行,后来考虑希腊为古代奥运会发源地,在希腊举行比在巴黎意义更重大些,顾拜旦尊重了大家的意见。大会决定把第一届会期改在1896年,鉴于古代奥运会遗址奥林匹亚已成了一片废墟,会址改设在希腊首都雅典。奥运会最早始于古希腊的奥林匹亚由古代希腊人民为祭神和崇拜英雄而举行的一些竞赛活动逐渐发展形成的。举行的地点就在古希腊雅典城西南方向360公里外的奥林匹亚村举行,因此而得名。第一届古代奥运会于公元前776年举行,共举行过293次。后来罗马帝国的入侵古希腊后,由于罗马皇帝狄奥多西信奉基督教,禁止一切关于异教的活动,因此运动会在公元393年被罗马皇帝狄奥多西废除。 [1]  1889年,法国的顾拜旦男爵提出恢复奥林匹克运动的建议。第一届近代奥运会于1896年在希腊举行。以后每四年举行一次。即使其间因故不能举行,届数仍然依次照算(第6、12、13届未举行。第6届由于第一次世界大战的爆发未能举行,第12,13届则因为第二次世界大战的爆发未能举行)。至2016年,已经举行过31次奥运会,最近的一次是在巴西的里约热内卢举行的奥运会。1897年一家法文报纸首次称之为“国际奥林匹克委员会”,1901年正式改用现名。1914年第一次世界大战爆发,为避免战火洗劫,1915年4月10日总部从巴黎迁到瑞士洛桑。早在1922年,中国奥委会就得到了国际奥委会的承认。 [4]  中国曾派运动员参加了1932年、1936年和1948年的三次奥运会。新中国首次派队参加了1952年在赫尔辛基的第15届奥运会。但不久,当时的时任国际奥委会主席布伦戴奇把台湾列入了国际奥委会所承认的各国奥委会名单之中,企图制造“两个中国”。中国多次抗议交涉无效,于1958年声明中断与国际奥委会的关系。从1946年起,国际奥委会执委会分别与冬、夏季国际单项体育联合会之间不定期举行联席会议;从1952年起,国际奥委会执委会与国家奥委会之间也不定期举行联席会议。1975年,中国奥委会要求国际奥委会恢复在奥林匹克运动中的合法代表权。1979年10月,国际奥委会通过《名古屋决议》,恢复了中国奥委会在国际奥委会的权利,确认中国为“中国奥委会”,使用中华人民共和国国旗和国歌;同时规定设在台北的奥委会为“中华台北奥委会”,使用“不同于其使用的旗、徽和歌”。会址设在台北的奥委会改名为“CHINESE TAIPEI OLYMPIC COMMITTEE”。大陆方面自此将“CHINESE TAIPEI”翻译为“中国台北”。何振梁于1981年和1985年当选为国际奥委会委员和执委会委员。1985年,国际奥委会启动奥林匹克全球伙伴计划(TOP计划),四年一期,实施TOP营销计划实施以来,这项收入不断攀升,并逼近电视转播权收入。1986年,国际奥委会授予中国奥委会奥林匹克杯,以表彰中国对发展中国家,特别是对非洲国家体育援助作出的巨大贡献。1989年8月,何振梁当选为国际奥委会副主席,这是中国人首次担任这个职务。 [5]  1993年,中国奥委会曾向国际奥委会提出了北京举办2000年奥运会的申请,但最后以2票之差而落选。1993年6月20日,国际奥委会执委会决定暂时承认马其顿为其成员。同年9月,巴勒斯坦被接受为临时委员。1993年9月,布隆迪、佛得角、科摩罗群岛、圣多美和普林西比、多米尼加等被接纳为新成员。1994年6月,瑙鲁加入国际奥委会。1994年8月29日至9月3日,第12届奥林匹克代表大会在巴黎召开,它也是现代奥林匹克运动恢复100周年的庆祝活动的一部分。参加本届大会的代表共有3427人,其中:国际奥委会委员和名誉委员101人;来自 48个国际单项体联的代表132人;来自191个国家或地区奥委会的代表407人;运动员代表67人;记者代表738人。在大会上发言的共达439人次。1995年7月,柬埔寨、几内亚比绍加入国际奥委会。1996年,国际奥委会与联合国粮农组织(FAO)签署了合作协议,双方愿采取积极具体措施为全球农村地区的人口谋取福利。国际奥委会与奔驰汽车公司就在6个非洲国家体育发展签订了一项耗资600万马克的“非洲奥林匹克计划”。1997年和1998年间,国际奥委会曾通过中国奥委会的协助,两次向朝鲜民主主义人民共和国体育界提供了食品援助。另外,国际奥委会还向巴塞罗那市签署合同,帮助重建萨拉热窝的扎特拉体育设施。1997年3月5日,国际奥委会同美国广播公司(NBC)签署了价值23亿美元电视转播权合同。根据协议,国际奥委会授予NBC在美国境内转播2004年奥运会、2006年冬奥会和2008年奥运会的权利,5月,国际奥委会和悉尼奥运会组委会共同与欧洲广播公司(EBU)签署了价值3.5亿美元的合同。另外,国际奥委会还制定了一项“奥林匹克计划”(TDP),利用五环标志和各国奥委会的会徽和名称进行市场销售。这一计划的实施,使得各国奥委会、尤其是发展中国家奥委会均能从中受益。 [6]  1997年7月3日,国际奥委会主席萨马兰奇宣布香港将以"中国香港"的名义参加奥运会。1998年12月,帕劳、厄立特里亚加入国际奥委会。1999年1月6日,中国奥委会全会在北京召开,决定由北京再次代表中国申办2008年第29届奥运会。1999年2月,国际奥委会在洛桑召开了世界反兴奋剂大会。大会通过了《洛桑宣言》,决定成立一个世界性的、独立的世界反兴奋剂组织(WADA)。国际奥委会承诺向该机构提供2500万美元的资金。1999年10月,在雅典召开的国际奥委会执委会决定:每四年在奥运会的发祥地举办一届世界青年节。2000年3月6日,国际奥委会在巴黎授予中国女子足球队“妇女和体育奖”。2001年7月,在第112届国际奥委会全会上,北京赢得了2008年奥运会主办权。在国际奥委会的倡议之下,2001年第56届联合国代表大会通过了一项由世界上170多个国家提出的题为“通过体育和奥林匹克理想来建立一个和平和更加美好的世界”的决议,呼吁在2002年盐湖城冬季奥运会期间实现“奥林匹克休战”。2003年7月,第115届国际奥委会全会于在布拉格召开,经过两轮投票,温哥华最后以56票胜出成为2010年第21届冬季奥运会举办城市。2004年,印度尼西亚的国际奥委会委员哈桑因涉嫌在一起建设工程中进行非法活动被判刑。同年8月他被赶出了国际奥委会。2005年,前国际奥委会副主席、韩国人金云龙被迫辞职。起因是他已经由于涉嫌韩国的体育-金钱腐败案件而被停职。为了避免被奥委会驱逐他不得不选择辞职。2004年,保加利亚国际奥委会委员伊万·斯拉夫科夫涉嫌腐败活动,被赶出了国际奥委会。2005年12月,国际奥委会委员,法国前体育部长和1976年蒙特利尔奥运会110米栏金牌得主德鲁特因为腐败案件被停职。 [7]  2006年15日,韩国籍国际奥委会委员朴永圣因为涉嫌挪用公款,已经被暂时剥夺了委员资格。国际奥委会在一份声明中说,在国际奥委会道德委员会对朴永圣调查期间,朴永圣“一切与国际奥委会委员资格有关的权利都将被暂时剥夺”。2011年7月8日,鉴于荷属安的列斯群岛已于2010年10月10日正式解散,国际奥委会第123次全会据此取消荷属安的列斯群岛的国家奥委会资格,同时批准了一系列相应措施,以尽可能保护该国运动员的利益,尤其是参与2012年伦敦奥运会的相关权益。 [8]  2013年9月9日,国际奥委会第125次全会在阿根廷首都布宜诺斯艾利斯投票选出了新一任的国际奥委会主席。最终来自德国的托马斯·巴赫从6名候选人中胜出,成为第九任国际奥委会主席,任期8年。上一任主席雅克·罗格退休。同时经过两轮投票,东京获得2020年夏季奥运会主办权。这是东京在1964年首次举办夏季奥运会后再获举办权。 [9]  2013年12月7日,国际奥委会主席巴赫表示,如果印度不能遵守奥林匹克反腐败规定将面临被开除会籍的下场。 [10]  2014年5月9日,国际奥委会发布公告,美国全国广播公司(NBC)与其签署了一份价值75亿美元的协议,获得了从2021到2032年间奥运会的独家转播权。协议还要求,NBC需另外支付1亿美元,用于2015至2020年间多项体育运动的推广。进入21世纪,NBC便一直独享奥运会转播权,其在2011年签署的一份文件就以44亿美元取得了从2014到2020年间历届奥运会的转播权。 [11]  2015年12月,国国际奥委会在官方网站正式宣布了反腐监督热线——这在历史上是前所未有的。决定将从2016年开始,对各国际体育组织实施财政和管理审计,审计将在第三方独立组织的主持下进行,包括国际奥委会和奥林匹克运动会组织委员会也包括在内。 [12]  2014年12月8日,在摩纳哥国际奥委会第127次全会表决了这一名为《奥林匹克2020议程》的改革提案,获全票通过(104名国际奥委会委员96人与会、8人缺席)。国际奥委会的奥运改革拉开序幕。全会同时投票,正式接纳科索沃奥委会成为其成员。 [13]  新的申办体系下,国际奥委会将变“申办”为“邀请”,申办城市可于邀请阶段与国际奥委会进行探讨,并需将承办奥运会融入其自身的发展规划中,而不是反向为之,国际奥委会甚至允许跨城、跨境联合申办,只不过巴赫称那须得是“特殊情况下的特事特办”。在新的奥运设项规则下,国际奥委会变大项基础制为小项基础制,不再将设项局限于28个大项,而是通过规定运动员、官员和小项的总数上限来实现规模控制,其中夏季奥运会的“帽”是10500名运动员、310个小项,冬奥会则为2900名运动员和100个小项。东道主将在增项议题上拥有更多主动权。 [14-15]  2015年7月31日,国际奥委会第128次全会在吉隆坡举行,经过85位国际奥委会委员的投票,国际奥委会主席巴赫宣布,北京获得2022年冬季奥运会举办权。北京成为首个同时主办夏季奥运会和冬季奥运会的城市,瑞士西南部城市洛桑则获得了2020年青冬奥会的举办权。 [16]  2015年8月2日,通过由国际奥委会所有协会成员参与的投票决定,南苏丹得到国际奥委会的最终认可,成为奥林匹克大家庭的最新成员,也就是第206名成员国。 [17]  2016年6月3日,国际奥委会发表公报宣布组成难民奥林匹克运动队,以迎接即将到来的里约奥运会。这支难民奥林匹克运动队由10名运动员组成,其中包括5名南苏丹难民、2名叙利亚难民、2名刚果(金)难民和1名埃塞俄比亚难民。他们将参加里约奥运会田径、游泳和柔道等项目的比赛。 [18]  全会同时表决通过了空手道、滑板、竞技攀岩、冲浪和棒垒球这5大项运动进入2020年东京奥运会的竞赛项目。 [19]  2017年7月11日,国际奥委会130届全会举行投票,一致决定2024年和2028年夏季奥运会的承办城市将同时产生,唯一的悬念是两个申办城市洛杉矶和巴黎谁先举办。 [20]  2019年6月23日,国际奥委会在瑞士洛桑举行国际奥委会新总部的揭幕。 [21] 
收起全文
精华内容
参与话题
问答
  • IOC的相关理解总结

    万次阅读 多人点赞 2020-04-20 13:54:07
    一、对IOC和DI的基本认识 (一)理解IoC,即“控制反转” (二)IoC具体做什么? (三)理解IoC和DI的关系 二、对IOC容器初始化的理解 四、对DI依赖注入的理解(主要是) 参考书籍、文献和资料 一、对IOC和DI...

    目录

    当前没有去添加对应的源码,只是自己的一些总结,可能理解有错误或不到位,还请指出。

    一、对IOC和DI的基本认识

    (一)理解IoC,即“控制反转”

    (二)IoC具体做什么?

    (三)理解IoC和DI的关系

    二、对IOC容器初始化的理解

    三、对DI依赖注入的理解

    参考书籍、文献和资料


    当前没有去添加对应的源码,只是自己的一些总结,可能理解有错误或不到位,还请指出。

    一、对IOC和DI的基本认识

    (一)理解IoC,即“控制反转”

    在Java开发中,Ioc意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制。理解好Ioc的关键是要明确“谁控制谁,控制什么,为何是反转(有反转就应该有正转了),哪些方面反转了”,那我们来深入分析一下:

    谁控制谁,控制什么:传统Java SE程序设计,我们直接在对象内部通过new进行创建对象,是程序主动去创建依赖对象;而IoC是有专门一个容器来创建这些对象,即由Ioc容器来控制对象的创建以及外部资源获取(不只是对象包括比如文件等)

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

    (二)IoC具体做什么?

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

    • 传统应用程序都是由我们在类内部主动创建依赖对象,从而导致类与类之间高耦合,难于测试;
    • 有了IoC容器后,把创建和查找依赖对象的控制权交给了容器,由容器进行注入组合对象,所以对象与对象之间是松散耦合,这样也方便测试,利于功能复用,更重要的是使得程序的整个体系结构变得非常灵活。
    • IoC对编程实现由IoC容器帮对象找相应的依赖对象并注入,而不是由对象主动去找

    (三)理解IoC和DI的关系

    DI—Dependency Injection,即“依赖注入”:是组件之间依赖关系由容器在运行期决定,形象的说,即由容器动态的将某个依赖关系注入到组件之中。通过依赖注入机制,我们只需要通过简单的配置,而无需任何代码就可指定目标需要的资源,完成自身的业务逻辑,而不需要关心具体的资源来自何处,由谁实现。

    理解DI的关键是:“谁依赖谁,为什么需要依赖,谁注入谁,注入了什么”,那我们来深入分析一下:

    谁依赖于谁:当然是应用程序依赖于IoC容器;

    为什么需要依赖:应用程序需要IoC容器来提供对象需要的外部资源;

    谁注入谁:很明显是IoC容器注入应用程序某个对象,应用程序依赖的对象;

    ●注入了什么:就是注入某个对象所需要的外部资源(包括对象、资源、常量数据)。

    IoC和DI由什么关系呢?其实它们是同一个概念的不同角度描述,由于控制反转概念比较含糊(可能只是理解为容器控制对象这一个层面,很难让人想到谁来维护对象关系),所以2004年大师级人物Martin Fowler又给出了一个新的名字:“依赖注入”,相对IoC 而言,依赖注入”明确描述了“被注入对象依赖IoC容器配置依赖对象”

    二、对IOC容器初始化的理解

    IOC容器初始化的基本步骤主要是两个方面:

    • 初始化的入口由容器实现中的refresh()方法调用来完成。
    • 对Bean定义载入IOC容器使用的方法是loadBeanDefinition()。

    大致过程如下:

    • 通过ReasourceLoader来完成资源文件的定位,DefaultResourceLoader是默认的实现,同时上下文本身就给出了ResourceLoader的实现,可以通过类路径、文件系统、URL等方式来定位资源
    • 如果XmlBeanFactory作为IOC容器,那么需要为它指定Bean定义的资源,也就是说Bean定义文件是通过抽象成Resource来被IOC容器处理,容器通过BeanDefinitionReader来完成定义信息的解析和Bean信息的注册,往往使用XmlBeanDefinitionReader来解析Bean的XML定义文件---实际的处理过程是委托给BeanDefinitionParserDelegate来完成的,从而得到Bean的定义信息,这些信息在Spring中使用BeanDefinition来表示(这个名字可以让我们想到loadBeanDefinition()、registerBeanDefinition()这些相关的方法,他们都是为处理BeanDefinition服务的)。
    • 解析得到BeanDefinition以后,需要在IOC容器中注册,这由IOC实现BeanDefinitionRegister接口来实现,注册过程就是在IOC容器内容维护一个HashMap来保存得到的BeanDefinition的过程,这个HashMap是IOC容器持有Bean信息的场所,以后Bean的操作都是围绕这个HashMap来实现
    • 之后我们通过BeanFactory和ApplicationContext来享受Spring IOC的服务了,在使用IOC容器的时候我们注意到,除了少量粘合代码,绝大多数以正确IOC风格编写的应用程序代码完全不关心如何到达工厂,因为容器将把这些对象与容器管理的其他对象钩在了一起,基本的策略是把工厂放到已知的地方,最好放在对预期使用的上下文有意义的地方,以及代码要实际访问工厂的地方。
    • Spring本身提供了对声明式载入Web应用程序用法的应用程序上下文,并将其存储在ServletContext的框架实现中

    三、对DI依赖注入的理解

    当Spring IOC容器完成了Bean定义资源的定位、载入和解析注册,IOC容器就可以管理Bean定义的相关数据了,但是此时IOC容器还没有对所管理的Bean进行依赖注入,依赖注入 在以下两种情况下发生:

    • 用户第一次调用getBean()方法时,IOC容器触发依赖注入。
    • 当用户在配置文件中将<bean>元素配置了lazy-init=false属性时,即让容器在解析注册Bean定义时进行预实例化,触发依赖注入。

    Beanfactory接口定义了Spring IOC容器的基本功能规范,是Spring IOC容器所应遵守的最低层和最基本的编程规范。BeanFactory接口中定义了几个getBean()方法,用于用户向IOC容器索取被管理的Bean的方法,通过分析其子类的具体实现来理解Spring IOC容器在用户索取Bean时如何完成依赖注入

    • getBean方法肯定不陌生,必经之路,然后调用doGetBean,进来以后首先会执行transformedBeanName找别名,看你的Bean上面是否起了别名。然后进行很重要的一步,getSingleton,这段代码就是从你的单例缓存池中获取Bean的实例。那么你第一次进来肯定是没有的,缓存里肯定是拿不到的。也就是一级缓存里是没有的。那么它怎么办呢?他会尝试去二级缓存中去拿,但是去二级缓存中拿并不是无条件的,首先要判断isSingletonCurrentlyInCreation(beanName)他要看你这个对象是否正在创建当中,如果不是直接就退出该方法,如果是的话,他就会去二级缓存earlySingletonObjects里面取,如果没拿到,它还接着判断allowEarlyReference这个东西是否为true。它的意思是说,是否允许让你从单例工厂对象缓存中去拿对象。默认为true。好了,此时如果进来那么就会通过singletonFactory.getObject()去单例工厂缓存中去拿。然后将缓存级别提升至二级缓存也就早期暴露的缓存。
    • getSingleton执行完以后会走dependsOn方法,判断是否有dependsOn标记的循环引用,有的话直接卡死,抛出异常。比如说A依赖于B,B依赖于A 通过dependsOn注解去指定。此时执行到这里就会抛出异常。这里所指并非是构造函数的循环依赖。
    • beforeSingletonCreation在这里方法里,就把你的对象标记为了早期暴露的对象,提前暴露对象用于创建Bean的实例
    • 紧接着就走创建Bean的流程开始。在创建Bean之前执行了一下resolveBeforeInstantiation。它的意思是说,代理AOPBean定义注册信息但是这里并不是实际去代理你的对象,因为对象还没有被创建。只是代理了Bean定义信息,还没有被实例化把Bean定义信息放进缓存,以便我想代理真正的目标对象的时候,直接去缓存里去拿。
    • 接下来就真正的走创建Bean流程,首先走进真正做事儿的方法doCreateBean然后找到createBeanInstance这个方法,在这里面它将为你创建你的Bean实例信息(Bean的实例)。如果说创建成功了,那么就把你的对象放入缓存中去(将创建好的提前曝光的对象放入singletonFactories三级缓存中)将对象从二级缓存中移除因为它已经不是提前暴露的对象了。但是。如果说在createBeanInstance这个方法中在创建Bean的时候它会去检测你的依赖关系,会去检测你的构造器。然后,如果说它在创建A对象的时候,发现了构造器里依赖了B,然后它又会重新走getBean的这个流程,当在走到这里的时候,又发现依赖了A此时就会抛出异常。为什么会抛出异常,因为,走getBean的时候他会去从你的单例缓存池中去拿,因为你这里的Bean还没有被创建好。自然不会被放进缓存中,所以它是在缓存中拿不到B对象的。反过来也是拿不到A对象的。造成了死循环故此直接抛异常。这就是为什么Spring IOC不能解决构造器循环依赖的原因因为你还没来的急放入缓存你的对象是不存在的。所以不能创建。同理@Bean标注的循环依赖方法也是不能解决的,跟这个同理。那么多例就更不能解决了。为什么?因为在走createBeanInstance的时候,会判断是否是单例的Bean定义信息mbd.isSingleton();如果是才会进来。所以多例的Bean压根就不会走进来,而是走了另一段逻辑,这里不做介绍。至此,构造器循环依赖和@Bean的循环依赖还有多例Bean的循环依赖为什么不能解决已经解释清楚。然后如果说,Bean创建成功了。那么会走后面的逻辑。
    • 将创建好的Bean放入缓存,addSingletonFactory方法就是将你创建好的Bean放入三级缓存中,并且移除早期暴露的对象。
    • 通过populateBean给属性赋值,我们知道,创建好的对象,并不是一个完整的对象,里面的属性还没有被赋值。所以这个方法就是为创建好的Bean为它的属性赋值。并且调用了我们实现的的XXXAware接口进行回调初始化,然后调用我们实现的Bean的后置处理器,给我们最后一次机会去修改Bean的属性

    参考书籍、文献和资料

    1.https://www.iteye.com/blog/jinnianshilongnian-1413846

    2.《Sring 5 核心原理与30个类手写实战》,谭勇徳,中国公信出版社,2019.

    展开全文
  • 谈谈对Spring IOC的理解

    万次阅读 多人点赞 2016-09-21 13:42:59
    学习过Spring框架的人一定都会听过Spring的IoC(控制反转) 、DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IoC 、DI这两个概念是模糊不清的,是很难理解的,今天和大家分享网上的一些技术大牛们对Spring...

    学习过Spring框架的人一定都会听过Spring的IoC(控制反转) 、DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IoC 、DI这两个概念是模糊不清的,是很难理解的,今天和大家分享网上的一些技术大牛们对Spring框架的IOC的理解以及谈谈我对Spring Ioc的理解。

    一、分享Iteye的开涛对Ioc的精彩讲解

      首先要分享的是Iteye的开涛这位技术牛人对Spring框架的IOC的理解,写得非常通俗易懂,以下内容全部来自原文,原文地址:http://jinnianshilongnian.iteye.com/blog/1413846

    1.1、IoC是什么

      Ioc—Inversion of Control,即“控制反转”,不是什么技术,而是一种设计思想。在Java开发中,Ioc意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制。如何理解好Ioc呢?理解好Ioc的关键是要明确“谁控制谁,控制什么,为何是反转(有反转就应该有正转了),哪些方面反转了”,那我们来深入分析一下:

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

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

      用图例说明一下,传统程序设计如图2-1,都是主动去创建相关对象然后再组合起来:

    图1-1 传统应用程序示意图

      当有了IoC/DI的容器后,在客户端类中不再主动去创建这些对象了,如图2-2所示:

    图1-2有IoC/DI容器后程序结构示意图

    1.2、IoC能做什么

      IoC 不是一种技术,只是一种思想,一个重要的面向对象编程的法则,它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象,从而导致类与类之间高耦合,难于测试;有了IoC容器后,把创建和查找依赖对象的控制权交给了容器,由容器进行注入组合对象,所以对象与对象之间是 松散耦合,这样也方便测试,利于功能复用,更重要的是使得程序的整个体系结构变得非常灵活。

      其实IoC对编程带来的最大改变不是从代码上,而是从思想上,发生了“主从换位”的变化。应用程序原本是老大,要获取什么资源都是主动出击,但是在IoC/DI思想中,应用程序就变成被动的了,被动的等待IoC容器来创建并注入它所需要的资源了。

      IoC很好的体现了面向对象设计法则之一—— 好莱坞法则:“别找我们,我们找你”;即由IoC容器帮对象找相应的依赖对象并注入,而不是由对象主动去找。

    1.3、IoC和DI

      DI—Dependency Injection,即“依赖注入”组件之间依赖关系由容器在运行期决定,形象的说,即由容器动态的将某个依赖关系注入到组件之中依赖注入的目的并非为软件系统带来更多功能,而是为了提升组件重用的频率,并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制,我们只需要通过简单的配置,而无需任何代码就可指定目标需要的资源,完成自身的业务逻辑,而不需要关心具体的资源来自何处,由谁实现。

      理解DI的关键是:“谁依赖谁,为什么需要依赖,谁注入谁,注入了什么”,那我们来深入分析一下:

      ●谁依赖于谁:当然是应用程序依赖于IoC容器

      ●为什么需要依赖:应用程序需要IoC容器来提供对象需要的外部资源

      ●谁注入谁:很明显是IoC容器注入应用程序某个对象,应用程序依赖的对象

      ●注入了什么:就是注入某个对象所需要的外部资源(包括对象、资源、常量数据)

      IoC和DI由什么关系呢?其实它们是同一个概念的不同角度描述,由于控制反转概念比较含糊(可能只是理解为容器控制对象这一个层面,很难让人想到谁来维护对象关系),所以2004年大师级人物Martin Fowler又给出了一个新的名字:“依赖注入”,相对IoC 而言,“依赖注入”明确描述了“被注入对象依赖IoC容器配置依赖对象”

      看过很多对Spring的Ioc理解的文章,好多人对Ioc和DI的解释都晦涩难懂,反正就是一种说不清,道不明的感觉,读完之后依然是一头雾水,感觉就是开涛这位技术牛人写得特别通俗易懂,他清楚地解释了IoC(控制反转) 和DI(依赖注入)中的每一个字,读完之后给人一种豁然开朗的感觉。我相信对于初学Spring框架的人对Ioc的理解应该是有很大帮助的。

    二、分享Bromon的blog上对IoC与DI浅显易懂的讲解

    2.1、IoC(控制反转)

      首先想说说IoC(Inversion of Control,控制反转)。这是spring的核心,贯穿始终。所谓IoC,对于spring框架来说,就是由spring来负责控制对象的生命周期和对象间的关系。这是什么意思呢,举个简单的例子,我们是如何找女朋友的?常见的情况是,我们到处去看哪里有长得漂亮身材又好的mm,然后打听她们的兴趣爱好、qq号、电话号、ip号、iq号………,想办法认识她们,投其所好送其所要,然后嘿嘿……这个过程是复杂深奥的,我们必须自己设计和面对每个环节。传统的程序开发也是如此,在一个对象中,如果要使用另外的对象,就必须得到它(自己new一个,或者从JNDI中查询一个),使用完之后还要将对象销毁(比如Connection等),对象始终会和其他的接口或类藕合起来。

      那么IoC是如何做的呢?有点像通过婚介找女朋友,在我和女朋友之间引入了一个第三者:婚姻介绍所。婚介管理了很多男男女女的资料,我可以向婚介提出一个列表,告诉它我想找个什么样的女朋友,比如长得像李嘉欣,身材像林熙雷,唱歌像周杰伦,速度像卡洛斯,技术像齐达内之类的,然后婚介就会按照我们的要求,提供一个mm,我们只需要去和她谈恋爱、结婚就行了。简单明了,如果婚介给我们的人选不符合要求,我们就会抛出异常。整个过程不再由我自己控制,而是有婚介这样一个类似容器的机构来控制。Spring所倡导的开发方式就是如此,所有的类都会在spring容器中登记,告诉spring你是个什么东西,你需要什么东西,然后spring会在系统运行到适当的时候,把你要的东西主动给你,同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制,也就是说控制对象生存周期的不再是引用它的对象,而是spring。对于某个具体的对象而言,以前是它控制其他对象,现在是所有对象都被spring控制,所以这叫控制反转。

    2.2、DI(依赖注入)

      IoC的一个重点是在系统运行中,动态的向某个对象提供它所需要的其他对象。这一点是通过DI(Dependency Injection,依赖注入)来实现的。比如对象A需要操作数据库,以前我们总是要在A中自己编写代码来获得一个Connection对象,有了 spring我们就只需要告诉spring,A中需要一个Connection,至于这个Connection怎么构造,何时构造,A不需要知道。在系统运行时,spring会在适当的时候制造一个Connection,然后像打针一样,注射到A当中,这样就完成了对各个对象之间关系的控制。A需要依赖 Connection才能正常运行,而这个Connection是由spring注入到A中的,依赖注入的名字就这么来的。那么DI是如何实现的呢? Java 1.3之后一个重要特征是反射(reflection),它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性,spring就是通过反射来实现注入的。

      理解了IoC和DI的概念后,一切都将变得简单明了,剩下的工作只是在spring的框架中堆积木而已。

    三、我对IoC(控制反转)和DI(依赖注入)的理解

      在平时的java应用开发中,我们要实现某一个功能或者说是完成某个业务逻辑时至少需要两个或以上的对象来协作完成,在没有使用Spring的时候,每个对象在需要使用他的合作对象时,自己均要使用像new object() 这样的语法来将合作对象创建出来,这个合作对象是由自己主动创建出来的,创建合作对象的主动权在自己手上,自己需要哪个合作对象,就主动去创建,创建合作对象的主动权和创建时机是由自己把控的,而这样就会使得对象间的耦合度高了,A对象需要使用合作对象B来共同完成一件事,A要使用B,那么A就对B产生了依赖,也就是A和B之间存在一种耦合关系,并且是紧密耦合在一起,而使用了Spring之后就不一样了,创建合作对象B的工作是由Spring来做的,Spring创建好B对象,然后存储到一个容器里面,当A对象需要使用B对象时,Spring就从存放对象的那个容器里面取出A要使用的那个B对象,然后交给A对象使用,至于Spring是如何创建那个对象,以及什么时候创建好对象的,A对象不需要关心这些细节问题(你是什么时候生的,怎么生出来的我可不关心,能帮我干活就行),A得到Spring给我们的对象之后,两个人一起协作完成要完成的工作即可。

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

      这是我对Spring的IoC(控制反转)的理解。DI(依赖注入)其实就是IOC的另外一种说法,DI是由Martin Fowler 在2004年初的一篇论文中首次提出的。他总结:控制的什么被反转了?就是:获得依赖对象的方式反转了。

    四、小结

      对于Spring Ioc这个核心概念,我相信每一个学习Spring的人都会有自己的理解。这种概念上的理解没有绝对的标准答案,仁者见仁智者见智。如果有理解不到位或者理解错的地方,欢迎广大园友指正!

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

    引述:IoC(控制反转:Inverse of Control)是Spring容器的内核,AOP、声明式事务等功能在此基础上开花结果。但是IoC这个重要的概念却比较晦涩隐讳,不容易让人望文生义,这不能不说是一大遗憾。不过IoC确实包括很多内涵,它涉及代码解耦、设计模式、代码优化等问题的考量,我们打算通过一个小例子来说明这个概念。

    通过实例理解IoC的概念 

        贺岁大片在中国已经形成了一个传统,每到年底总有多部贺岁大片纷至沓来让人应接不暇。在所有贺岁大片中,张之亮的《墨攻》算是比较出彩的一部。该片讲述了战国时期墨家人革离帮助梁国反抗赵国侵略的个人英雄主义故事,恢宏壮阔、浑雄凝重的历史场面相当震撼。其中有一个场景:当刘德华所饰演的墨者革离到达梁国都城下,城上梁国守军问到:“来者何人?”刘德华回答:“墨者革离!”我们不妨通过一个Java类为这个“城门叩问”的场景进行编剧,并借此理解IoC的概念: 
    代码清单3-1  MoAttack:通过演员安排剧本 

    Java代码  收藏代码
    1. public class MoAttack {  
    2.    public void cityGateAsk(){  
    3.         //①演员直接侵入剧本  
    4.        LiuDeHua ldh = new LiuDeHua();  
    5.        ldh.responseAsk("墨者革离!");  
    6.    }  
    7. }  

       我们会发现以上剧本在①处,作为具体角色饰演者的刘德华直接侵入到剧本中,使剧本和演员直接耦合在一起(图3-1)。 

       一个明智的编剧在剧情创作时应围绕故事的角色进行,而不应考虑角色的具体饰演者,这样才可能在剧本投拍时自由地遴选任何适合的演员,而非绑定在刘德华一人身上。通过以上的分析,我们知道需要为该剧本主人公革离定义一个接口: 
    代码清单3-2  MoAttack:引入剧本角色 
    Java代码  收藏代码
    1. public class MoAttack {  
    2.    public void cityGateAsk()  
    3.    {  
    4.         //①引入革离角色接口  
    5.        GeLi geli = new LiuDeHua();   
    6.          
    7.         //②通过接口开展剧情  
    8.        geli.responseAsk("墨者革离!");    
    9.    }  
    10. }  

       在①处引入了剧本的角色——革离,剧本的情节通过角色展开,在拍摄时角色由演员饰演,如②处所示。因此墨攻、革离、刘德华三者的类图关系如图 3 2所示: 
     
       可是,从图3 2中,我们可以看出MoAttack同时依赖于GeLi接口和LiuDeHua类,并没有达到我们所期望的剧本仅依赖于角色的目的。但是角色最终必须通过具体的演员才能完成拍摄,如何让LiuDeHua和剧本无关而又能完成GeLi的具体动作呢?当然是在影片投拍时,导演将LiuDeHua安排在GeLi的角色上,导演将剧本、角色、饰演者装配起来(图3-3)。 
     
    通过引入导演,使剧本和具体饰演者解耦了。对应到软件中,导演像是一个装配器,安排演员表演具体的角色。 
       现在我们可以反过来讲解IoC的概念了。IoC(Inverse of Control)的字面意思是控制反转,它包括两个内容: 
    • 其一是控制
    • 其二是反转

      那到底是什么东西的“控制”被“反转”了呢?对应到前面的例子,“控制”是指选择GeLi角色扮演者的控制权;“反转”是指这种控制权从《墨攻》剧本中移除,转交到导演的手中。对于软件来说,即是某一接口具体实现类的选择控制权从调用类中移除,转交给第三方决定。 
       因为IoC确实不够开门见山,因此业界曾进行了广泛的讨论,最终软件界的泰斗级人物Martin Fowler提出了DI(依赖注入:Dependency Injection)的概念用以代替IoC,即让调用类对某一接口实现类的依赖关系由第三方(容器或协作类)注入,以移除调用类对某一接口实现类的依赖。“依赖注入”这个名词显然比“控制反转”直接明了、易于理解。 

    IoC的类型 

      从注入方法上看,主要可以划分为三种类型:构造函数注入、属性注入和接口注入。Spring支持构造函数注入和属性注入。下面我们继续使用以上的例子说明这三种注入方法的区别。 

    构造函数注入 

    在构造函数注入中,我们通过调用类的构造函数,将接口实现类通过构造函数变量传入,如代码清单3-3所示: 
    代码清单3-3  MoAttack:通过构造函数注入革离扮演者 
    Java代码  收藏代码
    1. public class MoAttack {  
    2.    private GeLi geli;  
    3.    //①注入革离的具体扮演者  
    4.    public MoAttack(GeLi geli){   
    5.        this.geli = geli;  
    6.    }  
    7.     public void cityGateAsk(){  
    8.        geli.responseAsk("墨者革离!");  
    9.    }  
    10. }  

        MoAttack的构造函数不关心具体是谁扮演革离这个角色,只要在①处传入的扮演者按剧本要求完成相应的表演即可。角色的具体扮演者由导演来安排,如代码清单3-4所示: 
    代码清单3-4  Director:通过构造函数注入革离扮演者 
    Java代码  收藏代码
    1. public class Director {  
    2.    public void direct(){  
    3.         //①指定角色的扮演者  
    4.        GeLi geli = new LiuDeHua();    
    5.   
    6.         //②注入具体扮演者到剧本中  
    7.        MoAttack moAttack = new MoAttack(geli);   
    8.        moAttack.cityGateAsk();  
    9.    }  
    10. }  

       在①处,导演安排刘德华饰演革离的角色,并在②处,将刘德华“注入”到墨攻的剧本中,然后开始“城门叩问”剧情的演出工作。 

    属性注入 

       有时,导演会发现,虽然革离是影片《墨攻》的第一主角,但并非每个场景都需要革离的出现,在这种情况下通过构造函数注入相当于每时每刻都在革离的饰演者在场,可见并不妥当,这时可以考虑使用属性注入。属性注入可以有选择地通过Setter方法完成调用类所需依赖的注入,更加灵活方便: 
    代码清单3-5  MoAttack:通过Setter方法注入革离扮演者 
    Java代码  收藏代码
    1. public class MoAttack {  
    2.     private GeLi geli;  
    3.      //①属性注入方法  
    4.     public void setGeli(GeLi geli) {    
    5.         this.geli = geli;  
    6.     }  
    7.     public void cityGateAsk() {  
    8.         geli.responseAsk("墨者革离");  
    9.     }  
    10. }  

       MoAttack在①处为geli属性提供一个Setter方法,以便让导演在需要时注入geli的具体扮演者。 
    代码清单3-6  Director:通过Setter方法注入革离扮演者 
    Java代码  收藏代码
    1. public class Director {  
    2.    public void direct(){  
    3.        GeLi geli = new LiuDeHua();  
    4.        MoAttack moAttack = new MoAttack();  
    5.   
    6.         //①调用属性Setter方法注入  
    7.        moAttack.setGeli(geli);   
    8.        moAttack.cityGateAsk();  
    9.    }  
    10. }  

       和通过构造函数注入革离扮演者不同,在实例化MoAttack剧本时,并未指定任何扮演者,而是在实例化MoAttack后,在需要革离出场时,才调用其setGeli()方法注入扮演者。按照类似的方式,我们还可以分别为剧本中其他诸如梁王、巷淹中等角色提供注入的Setter方法,这样,导演就可以根据所拍剧段的不同,注入相应的角色了。 

    接口注入 

       将调用类所有依赖注入的方法抽取到一个接口中,调用类通过实现该接口提供相应的注入方法。为了采取接口注入的方式,必须先声明一个ActorArrangable接口: 
    Java代码  收藏代码
    1. public interface ActorArrangable {  
    2.    void injectGeli(GeLi geli);  
    3. }  

       然后,MoAttack实现ActorArrangable接口提供具体的实现: 
    代码清单3-7  MoAttack:通过接口方法注入革离扮演者 
    Java代码  收藏代码
    1. public class MoAttack implements ActorArrangable {  
    2.     private GeLi geli;  
    3.      //①实现接口方法  
    4.     public void injectGeli (GeLi geli) {    
    5.         this.geli = geli;         
    6.     }  
    7.     public void cityGateAsk() {  
    8.         geli.responseAsk("墨者革离");  
    9.     }  
    10. }  

         Director通过ActorArrangable的injectGeli()方法完成扮演者的注入工作。 
    代码清单3-8  Director:通过接口方法注入革离扮演者 
    Java代码  收藏代码
    1. public class Director {  
    2.    public void direct(){  
    3.        GeLi geli = new LiuDeHua();  
    4.        MoAttack moAttack = new MoAttack();  
    5.        moAttack. injectGeli (geli);  
    6.        moAttack.cityGateAsk();  
    7.    }  
    8. }  

        由于通过接口注入需要额外声明一个接口,增加了类的数目,而且它的效果和属性注入并无本质区别,因此我们不提倡采用这种方式。 

    通过容器完成依赖关系的注入 

       虽然MoAttack和LiuDeHua实现了解耦,MoAttack无须关注角色实现类的实例化工作,但这些工作在代码中依然存在,只是转移到Director类中而已。假设某一制片人想改变这一局面,在选择某个剧本后,希望通过一个“海选”或者第三中介机构来选择导演、演员,让他们各司其职,那剧本、导演、演员就都实现解耦了。 
       所谓媒体“海选”和第三方中介机构在程序领域即是一个第三方的容器,它帮助完成类的初始化与装配工作,让开发者从这些底层实现类的实例化、依赖关系装配等工作中脱离出来,专注于更有意义的业务逻辑开发工作。这无疑是一件令人向往的事情,Spring就是这样的一个容器,它通过配置文件或注解描述类和类之间的依赖关系,自动完成类的初始化和依赖注入的工作。下面是Spring配置文件的对以上实例进行配置的配置文件片断: 
    Xml代码  收藏代码
    1. <?xml version="1.0" encoding="UTF-8" ?>  
    2. <beans xmlns="http://www.springframework.org/schema/beans"  
    3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    4.     xmlns:p="http://www.springframework.org/schema/p"  
    5.     xsi:schemaLocation="http://www.springframework.org/schema/beans   
    6.        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">  
    7.         <!--①实现类实例化-->  
    8.    <bean id="geli" class="LiuDeHua"/>  
    9.    <bean id="moAttack" class="com.baobaotao.ioc.MoAttack"   
    10.          p:geli-ref="geli"/><!--②通过geli-ref建立依赖关系-->  
    11. </beans>  

       通过new XmlBeanFactory(“beans.xml”)等方式即可启动容器。在容器启动时,Spring根据配置文件的描述信息,自动实例化Bean并完成依赖关系的装配,从容器中即可返回准备就绪的Bean实例,后续可直接使用之。 
       Spring为什么会有这种“神奇”的力量,仅凭一个简单的配置文件,就能魔法般地实例化并装配好程序所用的Bean呢?这种“神奇”的力量归功于Java语言本身的类反射功能。 

    展开全文
  • Spring的IOC原理(通俗易懂)

    万次阅读 多人点赞 2018-04-06 19:52:46
    1. IoC理论的背景 我们都知道,在采用面向对象方法设计的软件系统中,它的底层实现都是由Ñ个对象组成的,所有的对象通过彼此的合作,最终实现系统的业务逻辑。 如果我们打开机械式手表的后盖,就会看到与...

    1. IoC理论的背景

           我们都知道,在采用面向对象方法设计的软件系统中,它的底层实现都是由Ñ个对象组成的,所有的对象通过彼此的合作,最终实现系统的业务逻辑。

                     

     

                如果我们打开机械式手表的后盖,就会看到与上面类似的情形,各个齿轮分别带动时针,分针和秒针顺时针旋转,从而在表盘上产生正确的时间。图1中描述的就是这样的一个齿轮组,它拥有多个独立的齿轮,这些齿轮相互啮合在一起,协同工作,共同完成某项任务。我们可以看到,在这样的齿轮组中,如果有一个齿轮出了问题,就可能会影响到整个齿轮组的正常运转。

            齿轮组中齿轮之间的啮合关系,与软件系统中对象之间的耦合关系非常相似。对象之间的耦合关系是无法避免的,也是必要的,这是协同工作的基础。现在,伴随着工业级应用的规模越来越庞大,对象之间的依赖关系也越来越复杂,经常会出现对象之间的多重依赖性关系,因此,架构师和设计师对于系统的分析和设计,将面临更大的挑战。对象之间耦合度过高的系统,必然会出现牵一发而动全身的情形。

     

     

                            

     

     

             耦合关系不仅会出现在对象与对象之间,也会出现在软件系统的各模块之间,以及软件系统和硬件系统之间。如何降低系统之间,模块之间和对象之间的耦合度,是软件工程永远追求的目标之一。为了解决对象之间的耦合度过高的问题,软件专家Michael Mattson提出了IOC理论,用来实现对象之间的“解耦”,目前这个理论已经被成功地应用到实践当中,很多的J2EE项目均采用了国际奥委会框架产品 Spring。

    2.什么是控制反转(IoC)
            IOC是Inversion of Control的缩写,多数书籍翻译成“控制反转”,还有些书籍翻译成为“控制反向”或者“控制倒置”。
            1996年,Michael Mattson在一篇有关探讨面向对象框架的文章中,首先提出了IOC这个概念。对于面向对象设计及编程的基本思想,前面我们已经讲了很多了,不再赘述,简单来说就是把复杂系统分解成相互作用合作的对象,这些对象类通过封装以后,内部实现对外部是透明的,从而降低了解决问题的复杂度,而且可以灵活地被重用和扩展.IOC理论提出的观点大体是这样的:借助于“第三方”实现具有依赖关系的对象之间的,如下图:

     

                          

     

     

            大家看到了吧,由于引进了中间位置的“第三方”,也就是IOC容器,使得A,B,C,d这4个对象没有了耦合关系,齿轮之间的传动全部依靠“第三方”了,全部对象的控制权全部上缴给“第三方” IOC容器,所以,IOC容器成了整个系统的关键核心,它起到了一种类似“粘合剂”的作用,把系统中的所有对象粘合在一起发挥作用,如果没有这个“粘合剂”,对象与对象之间会彼此失去联系,这就是有人把IOC容器比喻成“粘合剂”的由来。

     

                        我们再来做个试验:把上图中间的IOC容器拿掉,然后再来看看这套系统:

     

                                

     

     

     

     

            我们现在看到的画面,就是我们要实现整个系统所需要完成的全部内容。这时候,A,B,C,d这4个对象之间已经没有了耦合关系,彼此毫无联系,这样的话,当你在实现阿的时候,根本无须再去考虑B,C和d了,对象之间的依赖关系已经降低到了最低程度。所以,如果真能实现IOC容器,对于系统开发而言,这将是一件多么美好的事情,参与开发的每一成员只要实现自己的类就可以了,跟别人没有任何关系!

     

    我们再来看看,控制反转(IOC)到底为什么要起这么个名字我们来对比一下?

     

           软件系统在没有引入IOC容器之前,如图1所示,对象甲依赖于对象B,那么对象阿在初始化或者运行到某一点的时候,自己必须主动去创建对象乙或者使用已经创建的对象B.无论是创建还是使用对象B,控制权都在自己手上。
    软件系统在引入IOC容器之后,这种情形就完全改变了,如图3所示,由于IOC容器的加入,对象甲与对象乙之间失去了直接联系,所以,当对象甲运行到需要对象乙的时候,IOC容器会主动创建一个对象乙注入到对象甲需要的地方。

     

     

     

            通过前后的对比,我们不难看出来:对象甲获得依赖对象乙的过程,由主动行为变为了被动行为,控制权颠倒过来了,这就是“控制反转”这个名称的由来。

    3. IOC的别名:依赖注入(DI)
            2004年,Martin Fowler探讨了同一个问题,既然IOC是控制反转,那么到底是“哪些方面的控制被反转了呢?”,经过详细地分析和论证后,他得出了答案:“获得依赖对象的过程被反转了”控制被反转之后,获得依赖对象的过程由自身管理IOC容器主动注入于是,他给“控制反转“取了一个更合适的名字叫做”依赖注入(Dependency Injection)“。他的这个答案,实际上给出了实现IOC的方法:注入。所谓依赖注入,就是由IOC容器在运行期间,动态地将某种依赖关系注入到对象之中。

     

            所以,依赖注入(DI)和控制反转(IOC)是从不同的角度的描述的同一件事情,指就是通过引入IOC容器,利用依赖关系注入的方式,实现对象之间的解耦

     

            我们举一个生活中的例子,来帮助理解依赖注入的过程。大家对USB接口和USB设备应该都很熟悉吧,USB为我们使用电脑提供了很大的方便,现在有很多的外部设备都支持USB接口。

     

                                

     

     

     

     

     

     

    现在,我们利用电脑主机和USB接口来实现一个任务:从外部USB设备读取一个文件。

     

            电脑主机读取文件的时候,它一点也不会关心USB接口上连接的是什么外部设备,而且它确实也无须知道。它的任务就是读取USB接口,挂接的外部设备只要符合USB接口标准即可。所以,如果我给电脑主机连接上一个U盘,那么主机就从U盘上读取文件;如果我给电脑主机连接上一个外置硬盘,那么电脑主机就从外置硬盘上读取文件。挂接外部设备的权力由我作主,即控制权归我,至于USB接口挂接的是什么设备,电脑主机是决定不了,它只能被动的接受。电脑主机需要外部设备的时候,根本不用它告诉我,我就会主动帮它挂上它想要的外部设备,你看我的服务是多么的到位。这就是我们生活中常见的一个依赖注入的例子。在这个过程中,我就起到了IOC容器的作用

            

            通过这个例子,依赖注入的思路已经非常清楚:当电脑主机读取文件的时候,我就把它所要依赖的外部设备,帮他挂接上。整个外部设备注入的过程和一个被依赖的对象在系统运行时被注入另外一个对象内部的过程完全一样。

    我们把依赖注入应用到软件系统中,再来描述一下这个过程:

     

            对象A依赖于对象B,当对象 A需要用到对象B的时候,IOC容器就会立即创建一个对象B送给对象A。IOC容器就是一个对象制造工厂,你需要什么,它会给你送去,你直接使用就行了,而再也不用去关心你所用的东西是如何制成的,也不用关心最后是怎么被销毁的,这一切全部由IOC容器包办。

            

            在传统的实现中,由程序内部代码来控制组件之间的关系。我们经常使用new关键字来实现两个组件之间关系的组合,这种实现方式会造成组件之间耦合。IOC很好地解决了该问题,它将实现组件间关系从程序内部提到外部容器,也就是说由容器在运行期将组件间的某种依赖关系动态注入组件中。

     

    4.  IOC为我们带来了什么好处

    我们还是从USB的例子说起,使用USB外部设备比使用内置硬盘,到底带来什么好处?
    第一、USB设备作为电脑主机的外部设备,在插入主机之前,与电脑主机没有任何的关系,只有被我们连接在一起之后,两者才发生联系,具有相关性。所以,无论两者中的任何一方出现什么的问题,都不会影响另一方的运行。这种特性体现在软件工程中,就是可维护性比较好,非常便于进行单元测试,便于调试程序和诊断故障。代码中的每一个Class都可以单独测试,彼此之间互不影响,只要保证自身的功能无误即可,这就是组件之间低耦合或者无耦合带来的好处。
    第二、USB设备和电脑主机的之间无关性,还带来了另外一个好处,生产USB设备的厂商和生产电脑主机的厂商完全可以是互不相干的人,各干各事,他们之间唯一需要遵守的就是USB接口标准。这种特性体现在软件开发过程中,好处可是太大了。每个开发团队的成员都只需要关心实现自身的业务逻辑,完全不用去关心其它的人工作进展,因为你的任务跟别人没有任何关系,你的任务可以单独测试,你的任务也不用依赖于别人的组件,再也不用扯不清责任了。所以,在一个大中型项目中,团队成员分工明确、责任明晰,很容易将一个大的任务划分为细小的任务,开发效率和产品质量必将得到大幅度的提高。
    第三、同一个USB外部设备可以插接到任何支持USB的设备,可以插接到电脑主机,也可以插接到DV机,USB外部设备可以被反复利用。在软件工程中,这种特性就是可复用性好,我们可以把具有普遍性的常用组件独立出来,反复利用到项目中的其它部分,或者是其它项目,当然这也是面向对象的基本特征。显然,IOC不仅更好地贯彻了这个原则,提高了模块的可复用性。符合接口标准的实现,都可以插接到支持此标准的模块中。
    第四、同USB外部设备一样,模块具有热插拔特性。IOC生成对象的方式转为外置方式,也就是把对象生成放在配置文件里进行定义,这样,当我们更换一个实现子类将会变得很简单,只要修改配置文件就可以了,完全具有热插拨的特性。
    以上几点好处,难道还不足以打动我们,让我们在项目开发过程中使用IOC框架吗?

     

     

    5.  IOC容器的技术剖析

            IOC中最基本的技术就是“反射(Reflection)”编程,目前.Net C#、Java和PHP5等语言均支持,其中PHP5的技术书籍中,有时候也被翻译成“映射”。有关反射的概念和用法,大家应该都很清楚,通俗来讲就是根据给出的类名(字符串方式)来动态地生成对象。这种编程方式可以让对象在生成时才决定到底是哪一种对象。反射的应用是很广泛的,很多的成熟的框架,比如象Java中的Hibernate、Spring框架,.Net中 NHibernate、Spring.Net框架都是把“反射”做为最基本的技术手段。

    反射技术其实很早就出现了,但一直被忽略,没有被进一步的利用。当时的反射编程方式相对于正常的对象生成方式要慢至少得10倍。现在的反射技术经过改良优化,已经非常成熟,反射方式生成对象和通常对象生成方式,速度已经相差不大了,大约为1-2倍的差距。

     

            我们可以把IOC容器的工作模式看做是工厂模式的升华,可以把IOC容器看作是一个工厂,这个工厂里要生产的对象都在配置文件中给出定义,然后利用编程语言的的反射编程,根据配置文件中给出的类名生成相应的对象。从实现来看,IOC是把以前在工厂方法里写死的对象生成代码,改变为由配置文件来定义,也就是把工厂和对象生成这两者独立分隔开来,目的就是提高灵活性和可维护性。

     

     

     

    6.  IOC容器的一些产品

    Sun ONE技术体系下的IOC容器有:轻量级的有Spring、Guice、Pico Container、Avalon、HiveMind;重量级的有EJB;不轻不重的有JBoss,Jdon等等。Spring框架作为Java开发中SSH(Struts、Spring、Hibernate)三剑客之一,大中小项目中都有使用,非常成熟,应用广泛,EJB在关键性的工业级项目中也被使用,比如某些电信业务。
    .Net技术体系下的IOC容器有:Spring.Net、Castle等等。Spring.Net是从Java的Spring移植过来的IOC容器,Castle的IOC容器就是Windsor部分。它们均是轻量级的框架,比较成熟,其中Spring.Net已经被逐渐应用于各种项目中。

     

    7. 使用IOC框架应该注意什么

    使用IOC框架产品能够给我们的开发过程带来很大的好处,但是也要充分认识引入IOC框架的缺点,做到心中有数,杜绝滥用框架。
    第一、软件系统中由于引入了第三方IOC容器,生成对象的步骤变得有些复杂,本来是两者之间的事情,又凭空多出一道手续,所以,我们在刚开始使用IOC框架的时候,会感觉系统变得不太直观。所以,引入了一个全新的框架,就会增加团队成员学习和认识的培训成本,并且在以后的运行维护中,还得让新加入者具备同样的知识体系。
    第二、由于IOC容器生成对象是通过反射方式,在运行效率上有一定的损耗。如果你要追求运行效率的话,就必须对此进行权衡。
    第三、具体到IOC框架产品(比如:Spring)来讲,需要进行大量的配制工作,比较繁琐,对于一些小的项目而言,客观上也可能加大一些工作成本。
    第四、IOC框架产品本身的成熟度需要进行评估,如果引入一个不成熟的IOC框架产品,那么会影响到整个项目,所以这也是一个隐性的风险。
    我们大体可以得出这样的结论:一些工作量不大的项目或者产品,不太适合使用IOC框架产品。另外,如果团队成员的知识能力欠缺,对于IOC框架产品缺乏深入的理解,也不要贸然引入。最后,特别强调运行效率的项目或者产品,也不太适合引入IOC框架产品,象WEB2.0网站就是这种情况。

     

    开始编写简单易懂的java思维导图啦,有兴趣的,可以关注我

    跳转地址:java知识点--通俗易懂(思维导图)

     

    展开全文
  • 什么是IOC(控制反转)、DI(依赖注入)

    万次阅读 多人点赞 2018-08-22 21:29:13
    学习过Spring框架的人一定都会听过Spring的IoC(控制反转) 、DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IoC 、DI这两个概念是模糊不清的,是很难理解的,今天和大家分享网上的一些技术大牛们对Spring...

    原文地址(摘要了部分内容):https://blog.csdn.net/qq_22654611/article/details/52606960/

    学习过Spring框架的人一定都会听过Spring的IoC(控制反转) 、DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IoC 、DI这两个概念是模糊不清的,是很难理解的,今天和大家分享网上的一些技术大牛们对Spring框架的IOC的理解以及谈谈我对Spring Ioc的理解。

    一、分享Iteye的开涛对Ioc的精彩讲解

      首先要分享的是Iteye的开涛这位技术牛人对Spring框架的IOC的理解,写得非常通俗易懂,以下内容全部来自原文,原文地址:http://jinnianshilongnian.iteye.com/blog/1413846

    1.1、IoC是什么

      Ioc—Inversion of Control,即“控制反转”,不是什么技术,而是一种设计思想。在Java开发中,Ioc意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制。如何理解好Ioc呢?理解好Ioc的关键是要明确“谁控制谁,控制什么,为何是反转(有反转就应该有正转了),哪些方面反转了”,那我们来深入分析一下:

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

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

      用图例说明一下,传统程序设计如图2-1,都是主动去创建相关对象然后再组合起来:

    图1-1 传统应用程序示意图

      当有了IoC/DI的容器后,在客户端类中不再主动去创建这些对象了,如图2-2所示:

    图1-2有IoC/DI容器后程序结构示意图

    1.2、IoC能做什么

      IoC 不是一种技术,只是一种思想,一个重要的面向对象编程的法则,它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象,从而导致类与类之间高耦合,难于测试;有了IoC容器后,把创建和查找依赖对象的控制权交给了容器,由容器进行注入组合对象,所以对象与对象之间是 松散耦合,这样也方便测试,利于功能复用,更重要的是使得程序的整个体系结构变得非常灵活。

      其实IoC对编程带来的最大改变不是从代码上,而是从思想上,发生了“主从换位”的变化。应用程序原本是老大,要获取什么资源都是主动出击,但是在IoC/DI思想中,应用程序就变成被动的了,被动的等待IoC容器来创建并注入它所需要的资源了。

      IoC很好的体现了面向对象设计法则之一—— 好莱坞法则:“别找我们,我们找你”;即由IoC容器帮对象找相应的依赖对象并注入,而不是由对象主动去找。

    1.3、IoC和DI

      DI—Dependency Injection,即“依赖注入”组件之间依赖关系由容器在运行期决定,形象的说,即由容器动态的将某个依赖关系注入到组件之中依赖注入的目的并非为软件系统带来更多功能,而是为了提升组件重用的频率,并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制,我们只需要通过简单的配置,而无需任何代码就可指定目标需要的资源,完成自身的业务逻辑,而不需要关心具体的资源来自何处,由谁实现。

      理解DI的关键是:“谁依赖谁,为什么需要依赖,谁注入谁,注入了什么”,那我们来深入分析一下:

      ●谁依赖于谁:当然是应用程序依赖于IoC容器

      ●为什么需要依赖:应用程序需要IoC容器来提供对象需要的外部资源

      ●谁注入谁:很明显是IoC容器注入应用程序某个对象,应用程序依赖的对象

      ●注入了什么:就是注入某个对象所需要的外部资源(包括对象、资源、常量数据)

      IoC和DI由什么关系呢?其实它们是同一个概念的不同角度描述,由于控制反转概念比较含糊(可能只是理解为容器控制对象这一个层面,很难让人想到谁来维护对象关系),所以2004年大师级人物Martin Fowler又给出了一个新的名字:“依赖注入”,相对IoC 而言,依赖注入”明确描述了“被注入对象依赖IoC容器配置依赖对象”。

      看过很多对Spring的Ioc理解的文章,好多人对Ioc和DI的解释都晦涩难懂,反正就是一种说不清,道不明的感觉,读完之后依然是一头雾水,感觉就是开涛这位技术牛人写得特别通俗易懂,他清楚地解释了IoC(控制反转) 和DI(依赖注入)中的每一个字,读完之后给人一种豁然开朗的感觉。我相信对于初学Spring框架的人对Ioc的理解应该是有很大帮助的。

    二、分享Bromon的blog上对IoC与DI浅显易懂的讲解

    2.1、IoC(控制反转)

      首先想说说IoC(Inversion of Control,控制反转)。这是spring的核心,贯穿始终。所谓IoC,对于spring框架来说,就是由spring来负责控制对象的生命周期和对象间的关系。这是什么意思呢,举个简单的例子,我们是如何找女朋友的?常见的情况是,我们到处去看哪里有长得漂亮身材又好的mm,然后打听她们的兴趣爱好、qq号、电话号、ip号、iq号………,想办法认识她们,投其所好送其所要,然后嘿嘿……这个过程是复杂深奥的,我们必须自己设计和面对每个环节。传统的程序开发也是如此,在一个对象中,如果要使用另外的对象,就必须得到它(自己new一个,或者从JNDI中查询一个),使用完之后还要将对象销毁(比如Connection等),对象始终会和其他的接口或类藕合起来。

      那么IoC是如何做的呢?有点像通过婚介找女朋友,在我和女朋友之间引入了一个第三者:婚姻介绍所。婚介管理了很多男男女女的资料,我可以向婚介提出一个列表,告诉它我想找个什么样的女朋友,比如长得像李嘉欣,身材像林熙雷,唱歌像周杰伦,速度像卡洛斯,技术像齐达内之类的,然后婚介就会按照我们的要求,提供一个mm,我们只需要去和她谈恋爱、结婚就行了。简单明了,如果婚介给我们的人选不符合要求,我们就会抛出异常。整个过程不再由我自己控制,而是有婚介这样一个类似容器的机构来控制。Spring所倡导的开发方式就是如此,所有的类都会在spring容器中登记,告诉spring你是个什么东西,你需要什么东西,然后spring会在系统运行到适当的时候,把你要的东西主动给你,同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制,也就是说控制对象生存周期的不再是引用它的对象,而是spring。对于某个具体的对象而言,以前是它控制其他对象,现在是所有对象都被spring控制,所以这叫控制反转。

    2.2、DI(依赖注入)

      IoC的一个重点是在系统运行中,动态的向某个对象提供它所需要的其他对象。这一点是通过DI(Dependency Injection,依赖注入)来实现的。比如对象A需要操作数据库,以前我们总是要在A中自己编写代码来获得一个Connection对象,有了 spring我们就只需要告诉spring,A中需要一个Connection,至于这个Connection怎么构造,何时构造,A不需要知道。在系统运行时,spring会在适当的时候制造一个Connection,然后像打针一样,注射到A当中,这样就完成了对各个对象之间关系的控制。A需要依赖 Connection才能正常运行,而这个Connection是由spring注入到A中的,依赖注入的名字就这么来的。那么DI是如何实现的呢? Java 1.3之后一个重要特征是反射(reflection),它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性,spring就是通过反射来实现注入的。

      理解了IoC和DI的概念后,一切都将变得简单明了,剩下的工作只是在spring的框架中堆积木而已。

     

    展开全文
  • 什么是IOC

    千次阅读 2019-07-17 15:38:49
    IoC,Inversion of Control(控制反转)。 是一种设计思想,在Java开发中,将你设计好的对象交给容器控制,而不是显示地用代码进行对象的创建。 把创建和查找依赖对象的控制权交给 IoC 容器,由 IoC 容器进行注入、...
  • IOC框架---什么是IOC

    千次阅读 2019-05-09 17:21:11
    1IoC理论的背景 我们都知道,在采用面向对象方法设计的软件系统中,它的底层实现都是由N个对象组成的,所有的对象通过彼此的合作,最终实现系统的业务逻辑。 ...
  • 浅谈 IOC 什么是 IOC

    万次阅读 多人点赞 2019-05-27 14:19:26
    本文以文字为主题,并没有代码案例,仅限于记录自己对于 IOC 的理解,文中也啥特别高深的东西,大牛和大佬可以忽略本文,以免浪费您宝贵的时间 什么是 IOCIOC (Inversion Of Control,控制倒转),是spring...
  • 第二章 IoC控制反转

    2020-11-03 11:25:35
    IoC的概念: IoC(Inversion of Control):控制反转,是一个理论,一个概念,一种思想,把原来的开发人员管理、创建对象的权限转移给代码之外的容器实现,由容器代替开发人员给属性赋值 IoC的技术实现: DI...
  • IOC模式 c#经典例子

    热门讨论 2011-01-26 09:31:07
    IOC模式 c#经典例子 IOC 例子 IOC模式 c#经典例子 IOC 例子 IOC模式 c#经典例子 IOC 例子
  • IOC概念的详解

    千次阅读 2018-12-04 10:47:12
    1.1.IOC是什么?  Ioc—Inversion of Control,即“控制反转”,不是什么技术,而是一种设计思想。在Java开发中,Ioc意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制。 ●谁控制谁,...
  • 浅谈IOC--说清楚IOC是什么

    万次阅读 多人点赞 2018-03-29 16:22:44
    什么是IOC3.IOC也叫依赖注入(DI)4.IOC的优缺点5.IOC容器的技术剖析6.IOC容器的一些产品7.参考博文本文旨在用语言(非代码)说清楚IOC到底是什么,没有什么高深的技术,园中的老牛、大虾们看到这里可以绕行了,以免浪费...
  • 1.希望不要照搬网上的答案,有自己的认知与总结 2.最好简洁明了但是要说的稍微深入些,因为是在口头说话,太简单会觉得在敷衍 3.最好举例子说到用在什么地方的,能一听就知道作用
  • SpringIoc 实现原理

    万次阅读 多人点赞 2019-04-20 16:44:33
    什么是SpringIOC spring ioc指的是控制反转,IOC容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。交由Spring容器统一进行管理,从而实现松耦合 “控制反转”,不是什么技术,而是一种设计思想...
  • J2EE进阶(十四)超详细的Java后台开发面试题之Spring IOC与AOP前言  搜狐畅游笔试题中有一道问答题涉及到回答谈谈对Spring IOC与AOP的理解。特将相关内容进行整理。  IOC和AOP是Spring中的两个核心的概念,下面...
  • 关于Spring IOC (DI-依赖注入)你需要知道的一切

    万次阅读 多人点赞 2017-01-19 16:46:27
    【版权申明】未经博主同意,不允许转载!...《Spring入门经典》这本无论对于初学者或者有经验的工程师还是很值一看的,最近花了点时间回顾了Spring的内容,在此顺带记录一下,本篇主要与spring IOC ,这篇博文
  • spring ioc原理(看完后大家可以自己写一个spring

    万次阅读 多人点赞 2009-08-02 20:33:00
    控制反转/依赖注入 最近,买了本Spring入门书:spring In Action 。大致浏览了下感觉还不错。...又一次接受了IOC 、DI、AOP等Spring核心概念。 先就IOC和DI谈一点我的看法。IOC(DI):其实这个Spring架构核心的
  • Spring IOC原理

    2018-09-29 09:44:00
    Spring IOC原理,类的继承关系,依赖注入和控制反转等关系
  • Spring IOC与工厂模式

    千次阅读 2020-05-06 14:04:51
    Spring IOC与工厂模式 PS:本文内容较为硬核,需要对java的面向对象、反射、类加载器、泛型、properties、XML等基础知识有较深理解。 (一)简单介绍 在讲Spring IOC之前,有必要先来聊一下工厂模式(Factory ...
  • Spring IoC容器

    千次阅读 2019-05-31 11:40:01
    Spring框架的IoC容器的全面的处理是与Spring的面向切面编程(AOP)的彻底实现紧密相关的。Spring框架拥有他自己的AOP框架,该技术在概念上是很容器理解的,并且成功的解决了在Java企业编程中的AOP需求的80%的点。 该框...
  • 什么是SpringIOC?如何理解SpringIOC

    千次阅读 2019-04-27 17:04:14
    深入理解Spring IOC
  • spring ioc

    2019-03-06 01:28:58
    博文链接:https://roserouge.iteye.com/blog/195705
  • 【死磕 Spring】----- IOC 之深入理解 Spring IoC

    万次阅读 多人点赞 2018-09-03 08:14:17
    在一开始学习 Spring 的时候,我们就接触 IoC 了,作为 Spring 第一个最核心的概念,我们在解读它源码之前一定需要对其有深入的认识,本篇为【死磕 Spring】系列博客的第一篇博文,主要介绍 IoC 基本概念和各个组件...
  • Spring IoC是什么

    万次阅读 多人点赞 2018-04-17 11:49:53
    IoC是什么Ioc—Inversion of Control,即“控制反转”,不是什么技术,而是一种设计思想。在Java开发中,Ioc意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制。如何理解好Ioc呢?理解好Ioc...
  • springIoc实现原理

    2019-04-20 16:48:27
    spring ioc指的是控制反转,IOC容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。交由Spring容器统一进行管理,从而实现松耦合
  • Spring IOC详细配置与使用

    万次阅读 多人点赞 2018-06-08 16:47:20
    SpringIoc: 按照我个人的理解来说,SpringIOC(Inversion of Control)控制反转:指就是说原先在对象中要使用另一个对象就必须要显式的去创建另一个对象的实例,例如通过构造方法或者是调用工厂方法(工厂方法最终...
  • Spring IoC有什么好处

    万次阅读 多人点赞 2018-01-27 17:00:38
    笔记: DI和IOC其实是一个思想,她们的的好处是:如果依赖的类修改了,...spring IOC的好处是,对象的构建如果依赖非常多的对象,且层次很深,外层在构造对象时很麻烦且不一定知道如何构建这么多层次的对象。 IO
  • 浅谈对Spring IOC以及DI的理解

    万次阅读 多人点赞 2017-05-17 19:40:22
    浅谈对Spring IOC以及DI的理解
  • Spring IoC概述

    千次阅读 2018-08-03 15:16:35
    一、什么是IoC IoC,Inversion of Control,控制反转。控制反转是一种通过描述(在java中可以使XML或者注解)并通过第三方去获取特定对象的方式。简单地说就是将对象由虚拟机主动创建...二、Spring IoC容器的设计 ...
  • Spring IOC 源码解析

    千次阅读 2019-06-14 21:51:14
    Spring IOC 源码解析 控制反转(IoC) 控制反转(IoC)原理的Spring Framework实现。IoC也称为依赖注入(DI)。这是一个过程,通过这个过程,对象只能通过构造函数参数,工厂方法的参数或在构造或从工厂方法返回后在...
  • Spring IoC注解详解

    千次阅读 2018-04-05 22:35:52
    这篇文章记录Spring IoC通过注解注入属性的方法。一、注解注入属性一个简单的案例1)Spring配置文件引入context约束&lt;beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="...

空空如也

1 2 3 4 5 ... 20
收藏数 225,782
精华内容 90,312
关键字:

ioc