精华内容
参与话题
问答
  • 什么IOC?打个比方,我们要做一个系统,为客户提供股票新闻。通常我们需要从不同的新闻社订阅新闻来源,然后通过批处理程序定时到指定的新闻服务器抓取最新的股票新闻,接着保存数据库,最后在前端显示。代码如下...

    一、IoC的基本概念

    IoC全称Inversion of Control,即控制反转。它的核心技术是DI (Dependency Injection),即依赖注入。
    什么是IOC?打个比方,我们要做一个系统,为客户提供股票新闻。通常我们需要从不同的新闻社订阅新闻来源,然后通过批处理程序定时到指定的新闻服务器抓取最新的股票新闻,接着保存数据库,最后在前端显示。代码如下:

    public class FXNewsProvider
    {
    	private IFXNewsListener newsListener;
    	private IFXNewsPersister newPersistener;
    	public void getAndPersistNews()
    	{
    		String[] newsIds = newsListener.getAvailableNewsIds();
    		if(ArrayUtils.isEmpty(newsIds))
    			{
    			return;
    			}
    				for(String newsId : newsIds)
    				{
    				FXNewsBean newsBean = newsListener.getNewsByPK(newsId);
    				newPersistener.persistNews(newsBean);
    				newsListener.postProcessIfNecessary(newsId);	
    			}
    	}
    }
    

    其中, FXNewsProvider 需要依赖 IFXNewsListener 来帮助抓取新闻内容,并依赖 IFXNews-
    Persister 存储抓取的新闻。
    假设默认使用道琼斯(Dow Jones)新闻社的新闻,那么我们相应地提供了 DowJonesNewsLis-
    tener 和 DowJonesNewsPersister 两个实现。通常情况下,需要在构造函数中构造 IFXNewsProvider
    依赖的这两个类:

    public FXNewsProvider() {
            this.newsListener = new DowJonesNewsListener();
            this.newPersistener = new DowJonesNewsPersister();
        }
    

    以往,如果我们依赖于某个类或服务,最简单而有效的方式就是直接在类的构造函数中新建相应的依赖类。我们都是自己主动地去获取依赖的对象!
    IoC则是在我们需要时将某个依赖对象送过来,它的反转,就反转在让你从原来的事必躬亲,转变为现在的享受服务。

    二、依赖注入

    被注入对象又是通过哪些什么来通知IoC为其提供适当服务的呢?其实就是依赖注入!依赖注入主要有两种方式:1、构造方法注入;2、setter方法注入

    2.1 构造方法注入

    顾名思义,构造方法注入,就是被注入对象可以通过在其构造方法中声明依赖对象的参数列表,让IoC容器知道它需要哪些依赖对象。对于前面例子中的 FXNewsProvider 来说,只要声明如下构造方法即可支持构造方法注入。

    public FXNewsProvider(IFXNewsListener newsListner,IFXNewsPersister newsPersister)
    {
    	this.newsListener = newsListner;
    	this.newPersistener = newsPersister;
    }
    

    IoC会检查被注入对象的构造方法,取得它所需要的依赖对象列表,进而为其注入相应的对象。同一个对象是不可能被构造两次的,因此,被注入对象的构造乃至其整个生命周期,应该是由IoC来管理的。构造方法注入方式比较直观,对象被构造完成后,即进入就绪状态,可以马上使用。

    2.2 setter 方法注入

    当前对象只要为其依赖对象所对应的属性添加setter方法,就可以通过setter方法将相应的依赖对象设置到被注入对象中。以 FXNewsProvider 为例,添加setter方法后如下所示。

    public class FXNewsProvider
    {
    	private IFXNewsListener newsListener;
    	private IFXNewsPersister newPersistener;
    	public IFXNewsListener getNewsListener() {
    		return newsListener;
    	}
    	public void setNewsListener(IFXNewsListener newsListener) {
    		this.newsListener = newsListener;
    	}
    	public IFXNewsPersister getNewPersistener() {
    		return newPersistener;
    	}
    	public void setNewPersistener(IFXNewsPersister newPersistener) {
    		this.newPersistener = newPersistener;
    	}
    }
    

    这样,外界就可以通过调用 setNewsListener 和 setNewPersistener 方法为 FXNewsProvider 对象注入所依赖的对象了。
    setter方法注入虽不像构造方法注入那样,让对象构造完成后即可使用,但相对来说更宽松一些,可以在对象构造完成后再注入。

    2.3 两种注入方式的比较

    构造方法注入的优点就是,对象在构造完成之后,即已进入就绪状态,可以马上使用。缺点就是,当依赖对象比较多的时候,构造方法的参数列表会比较长。而通过反射构造对象的时候,对相同类型的参数的处理会比较困难,维护和使用上也比较麻烦。而且在Java中,构造方法无法被继承,无法设置默认值。对于非必须的依赖处理,可能需要引入多个构造方法,而参数数量的变动可能造成维护上的不便。

    setter方法注入因为方法可以命名, 所以setter方法注入在描述性上要比构造方法注入好一些。
    另外,setter方法可以被继承,允许设置默认值,而且有良好的IDE支持。缺点当然就是对象无
    法在构造完成后马上进入就绪状态。

    三、IOC的优点

    不使用IOC看上去照样可以实现功能,但是如果需求发生变化了,比如需求追加了处理另一家新闻社的新闻来源时,问题就来了。因为我们之前没有用IoC,所以,现在的对象跟 DowJonesNewsListener 是绑定
    的,我们无法重用这个类了。
    而使用IoC后,我们却完全可以不做任何改动,因为不管是DowJones还是MarketWin24,对于我们的系统来说,处理逻辑实际上应该是一样的。因此,我们只要根据MarketWin24的新闻服务接口,为MarketWin24的 FXNewsProvider 提供相应的 MarketWin24NewsListener 注入就可以了,见以下代码:

    FXNewsProvider dowJonesNewsProvider =new FXNewsProvider(new DowJonesNewsListener(),new DowJonesNewsPersister());
    ...
    FXNewsPrivider marketWin24NewsProvider =new FXNewsProvider(new MarketWin24NewsListener(),new DowJonesNewsPersister());
    ...
    

    IoC是一种可以帮助我们解耦各业务对象间依赖关系的对象绑定方式!

    展开全文
  • IoC也称为控制反转,是一种思考方式,其主要关注点在于Java对象的创建与管理的问题。传统的方式相比,当我们需要一个对象的时候,不需要直接new一个,而是去Spring容器中拿一个即可,此时我们失去了对对象的控制权...

    IoC也称为控制反转,是一种思考方式,其主要关注点在于Java对象的创建与管理的问题。和传统的方式相比,当我们需要一个对象的时候,不需要直接new一个,而是去Spring容器中拿一个即可,此时我们失去了对对象的控制权,仅保有使用权。但这样也可以无需关注对象的管理。

    所谓控制,指的是管理对象的权利;

    所谓反转,指的是由Spring管理而不是开发者管理

    IoC的其中一个目的是为了解耦合,当将一个对象交给第三方容器管理后,那么对象之间的耦合相较于传统new方式会降低。同时Spring IoC也可以降低对象的管理成本,比如实现单例模式(默认即是单例)等等。

    要注意的是,IoC和DI的关系并不是一个,类似于接口和实现类的区别,IoC是一种设计思想,DI是IoC的一种实现,DI也称为依赖注入,在Spring中可以通过@Autowired注解将Spring容器中的对象注入到指定的位置。

    展开全文
  • IOCDI的理解

    万次阅读 多人点赞 2018-05-12 14:31:48
    首先要分享的是Iteye的开涛这位技术牛人对Spring框架的IOC的理解,写得非常通俗易懂,以下内容全部来自原文,原文地址:http://jinnianshilongnian.iteye.com/blog/14138461.1、IoC什么 Ioc—Inversion of ...

      首先要分享的是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年初的一篇论文中首次提出的。他总结:控制的什么被反转了?就是:获得依赖对象的方式反转了。

    展开全文
  • 依赖注入(DI)控制反转(IOC)是从不同的角度的描述的同一件事情,就是指通过引入IOC容器,利用依赖关系注入的方式,实现对象之间的解耦。  ioc 控制反转,指将对象的创建权,反转到Spring容器 , DI 依赖注

    IOC,即控制反转。是指将原来程序中自己创建实现类对象的控制权反转到IOC容器中。 微笑

              IOC的别名:依赖注入(DI),DIIOC的实现方式:注入。

    依赖注入(DI)和控制反转(IOC)是从不同的角度的描述的同一件事情,就是指通过引入IOC容器,利用依赖关系注入的方式,实现对象之间的解耦。
     ioc 控制反转,指将对象的创建权,反转到Spring容器  DI 依赖注入,指Spring创建对象的过程中,将对象依赖属性通过配置进行注入 .
    例: 害羞
    一.注解方式

    CustomerServiceImpl.java

     import java.util.List;
     import org.hibernate.criterion.DetachedCriteria;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.stereotype.Service;
     import org.springframework.transaction.annotation.Transactional;
     import cn.itcast.dao.CustomerDao;
     import cn.itcast.domain.Customer;
     import cn.itcast.service.CustomerService;
    @Service  //交给spring管理
    @Transactional
    public class CustomerServiceImpl implements CustomerService {
    @Autowired 
    //自动注入它的实现类
    private CustomerDao customerDao;
    @Override
    public void save(Customer customer) {
    System.out.println("22222222");
    customerDao.save(customer);
    }
    }

    二.配置方式

    applicationContext.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"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

     //将service  dao  交给  是spring来管理 
    <bean id="CustomerDao" class="cn.itcast.dao.CustomerDaoImp"></bean>
    <bean id="CustomerService" class="cn.itcast.service.CustomerServiceImp">
     //注入CustomerDao
     <property name="CustomerDao" ref="CustomerDao"></property>
    </bean>
    </beans>


    CustomerServiceImpl.java

     import java.util.List;
     import cn.itcast.dao.ICustomerDao;
     import cn.itcast.domain.Customer;

    public class CustomerServiceImp implements ICustomerService {
    ICustomerDao customerDao;
    public void setCustomerDao(ICustomerDao customerDao) {
    this.customerDao = customerDao;
    }
    public ICustomerDao getCustomerDao(){
    return customerDao;
    }

    @Override
    public List<Customer> findAllCustomers() {
    System.out.println("查询所有的客户....");
    customerDao.findAllCustomers();
    return null;
    }
    }

    再见再见再见再见再见再见


    展开全文
  • IOC和DI的区别详解

    千次阅读 2018-07-08 15:38:12
    IOC &nbsp; inversion of control &nbsp;控制反转 DI &nbsp; Dependency Injection &nbsp;依赖注入 要理解这两个概念,首先要搞清楚以下几个问题: 参与者都有谁?依赖:谁依赖于谁?为什么需要...
  • 什么IOC和DIDI是如何实现的?

    千次阅读 2018-10-26 10:15:21
    什么IOC和DIDI是如何实现的? IOC(Inversion of Control)叫控制反转, DI(Dependency Injection)叫依赖注入,是对IOC更简单的诠释。 IOC 控制反转是把传统上由程序代码直接操控的对象的调用权交给容器,通过...
  • IoC叫控制反转,是Inversion of Control的缩写,DI(Dependency Injection)叫依赖注入,是对IoC更简单的诠释。 控制反转是把传统上由程序代码直接操控的对象的调用权交给容器,通过容器来实现对象组件的装配管理...
  • 什么IOC(控制反转)、DI(依赖注入)

    万次阅读 多人点赞 2018-08-22 21:29:13
    学习过Spring框架的人一定都会听过Spring的IoC(控制反转) 、DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IoCDI这两个概念是模糊不清的,是很难理解的,今天大家分享网上的一些技术大牛们对Spring...
  • IoC叫控制反转,是Inversion of Control的缩写,DI(Dependency Injection)叫依赖注入,是对IoC更简单的诠释。控制反转是把传统上由程序代码直接操控的对象的调用权交给容器,通过容器来实现对象组件的装配管理。...
  • IoC叫控制反转,是Inversion of Control的缩写,DI(Dependency Injection)叫依赖注入,是对IoC更简单的诠释。控制反转是把传统上由程序代码直接操控的对象的调用权交给容器,通过容器来实现对象组件的装配管理。...
  • IOC和DI到底是什么?  在学习Spring框架的时候,我们总是能见到IOC这个单词,也时常听到DI这个词,那么他们分别是什么意思呢?接下来就讲讲个人对于这两个概念的理解  一、IOC和DI概念  IOC(控制反转):全称...
  • IoC和DI的理解

    2018-11-17 10:18:24
    在之前的学习中,一直认为IOC和DI是一个概念,很多文章只是提到ioc和di是在从不同的角度来描述。而实际上两者根本不是同一个东西,下面一句话点题 控制反转就是依赖倒置原则的一种代码设计的思路。具体采用的方法...
  • 学习过spring框架的人一定都会听过Spring的IoC(控制反转) 、DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IoCDI这两个概念是模糊不清的,是很难理解的,今天大家分享网上的一些技术大牛们对Spring...
  • IOC和DI的通俗理解

    万次阅读 多人点赞 2017-02-19 10:41:56
    学习过spring框架的人一定都会听过Spring的IoC(控制反转) 、DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IoCDI这两个概念是模糊不清的,是很难理解的,今天大家分享网上的一些技术大牛们对Spring...
  • 什么IOC容器? IOC全名:Inversion Of Control,翻译过来就是控制反转。 什么是控制反转? 这个是面向对象的一种设计原则,可以用来减低计算机代码之间的耦合度(模块及模块之间信息或参数依赖的程度)其中最...
  • 什么是Spring IOC 和DI(最好的讲解)

    万次阅读 多人点赞 2018-03-14 17:10:29
    一、分享Iteye的开涛对Ioc的精彩讲解 首先要分享的是Iteye的开涛这位技术牛人对Spring框架的IOC的理解,写得...1.1、IoC什么 Ioc—Inversion of Control,即“控制反转”,不是什么技术,而是一种设计思想。在Ja
  • 啥是IOC ?啥是DI

    2018-03-16 11:07:38
     IOC (inverse of controll)控制反转:所谓控制反转就是把创建对象(bean),维护对象(bean)的关系的权利从程序中转移到spring的容器(applicationContext.xml)2、DI什么? Di(dependency injection)依赖注入...
  • IOC和DI什么区别

    千次阅读 2020-05-16 15:42:59
    没有区别,IOC=DI 因为,IOC是控制反转,2004年大神Martin Fowler说,控制反转?控制的什么被反转了?想了半天明白了,原来就是获得依赖对象的方式反转了。于是IOC的另一种说法就出来了,就是DI(依赖注入) ...
  • ioc和di的关系

    千次阅读 2018-06-28 21:53:28
    有的人说这两个是一个,有的说diioc的实现,我就说说我的理解。  从gettersetter开始  从开始学习mvc设计模式,或者是jsp异或是框架,必然会有JavaBean或者其他类似的概念出现。gettersetter就是JavaBean...
  • 依赖注入的概念就是将对象交给spring容器托管,要用的时候由spring容器注入到类中去用,spring是容器通过XML来声明对象,另外,spring中的DAO(数据访问对象(接口))DAO.impl(impl是implementation,DAO接口的具体...

空空如也

1 2 3 4 5 ... 20
收藏数 45,164
精华内容 18,065
关键字:

什么是ioc和di