它比Spring、Pico、Guice更小，并且更加灵活，更加易于使用。Butterfly Container使用一种简单，灵活，类似于Java的配置语言来代替XML（这段介绍来自于各大开源网站对其介绍），他是其他几个项目的基础。

Butterfly Container和Spring、Pico、Guice一样是一个依赖注入的容器。依赖注入的核心功能就是将变量绑定在一起（wire objects together）。你能够向容器申请一个对象，容器会确保所有的依赖（方法参数，协作对象）都注入到这个对象然后将其返回给你。

如果你对依赖注入不熟悉，你可以看看这篇文章：What is Dependency Injection?

虽然 Butterfly Container只是一个轻量级的依赖注入容器，但是他还是支持了 Spring, Pico 和Guice所拥有的大多数依赖注入特性. 例如:

• 构造方法注入

• 方法注入 (静态+ 实例)

• 工厂注入

• 实例生命周期管理

• 新建 /单例

• 线程独立

• 本地，匿名工厂

Butterfly Container 也有自己的一些特性:

• 在方法返回空值的情况下支持方法链

• 能够适配自定义的工厂方法接口

• 享元

上面列出了一些Butterfly Container 的特性，但是Butterfly Container 也存在一些不便利的地方，比如：Butterfly Container使用一种简单，灵活，类似于Java的配置语言来代替XML，这就要求在熟悉Butterfly Container的同时，需要熟悉其配置语言的语法。
在看了Butterfly Container的源码结构之后，我比较喜欢其代码风格，如接口都以I开头，接口和实现分包等等。

参考资料：
Butterfly Container – Introduction：http://butterfly.jenkov.com/container/index.html

您可能也喜欢：
Java Enumeration	Java Persistence API	Java中的字符串截取	Java interface RandomAccess	Java中比较两个对象是否相等
来自无觅网络的相关文章：
java泛型详解 (@belmeng)	Java的枚举和接口 (@hui-wang)	Java正则表达式 (@belmeng)	java枚举类型 (@belmeng)	Java验证码系列(7):中文验证码 (@pihai)
无觅

静态工厂类, 当使用静态工厂方法构造bean实例时,class属性是包含了静态工厂方法的类,同时还需要属性factory-method指
明创建实例的静态工厂方法名.这个构造的实例并不一定是class属性指明的类的实例.它可以是其它类的实例.
spring在构造实例时会自动调用静态的工厂方法.

public static  Car createCar(){// 静态工厂,静态方法
return new Car();
}
<bean id=”car”   factory-method=”createCar” />
Car car=(Car) ctx.getBean(“car”);
System.out.println(car);

实例工厂: 指工厂实例化后才能使用, 这种方法和使用静态工厂方法构造实例类似，通过调用一个bean（该bean的类包含了用来创建实例的工厂方法）的工厂方法构造bean的实例。这里需要注意的是：需要被构造实例的bean类在配置文件中不需要class属
性，但是需要通过factory-bean属性指明用来创建该bean的工厂bean。并且用factory-method属性指明实例工厂方法。下面是一个例子：
public  Car createCar(){// 必须是实例方法
return new Car();
}
<bean id=”factory”  class=”ioc06.CarFactory”/>
<bean id=”car”  factory-bean=”carFactory”   factory-method=”createCar” />

总结

Spring有三种方法实例化Bean，第一种方法，通过bean的缺省构造函数创建，当各个bean的业务逻辑相互比较独立的时候或者和外界关联较少的时候可以使用。

第二种方法，利用静态factory方法创建，可以统一管理各个bean的创建，如各个bean在创建之前需要相同的初始化处理，则可用这个factory方法险进行统一的处理等等。

第三种方法，利用实例化factory方法创建，即将factory方法也作为了业务bean来控制，觉得1可用于集成其他框架的bean创建管理方法，2能够使bean和factory的角色互换。

您可能也喜欢：
Spring IOC学习笔记	Spring IOC Autowire	Spring Inversion of Control	Spring IOC的介绍	Spring Bean Lifecycle Managerment
无觅

Spring IoC容器可以自动装配（autowire）相互协作bean之间的关联关系。因此，如果可能的话，可以自动让Spring通过检查BeanFactory中的内容，来替我们指定bean的协作者（其他被依赖的bean）。autowire一共有五种类型。由于autowire可以针对单个bean进行设置，因此可以让有些bean使用autowire，有些bean不采用。autowire的方便之处在减少或者消除属性或构造器参数的设置，这样可以给我们的配置文件减减肥！

在xml配置文件中，可以在<bean/>元素中使用autowire属性指定:

在bean中:
autowire=”"
<1>. byName: 匹配属性的名字与bean的id号进行匹配; 找set方法;
someBean中有一个ob的属性:
<bean id=”ob”>
<property  name=”str1″>
<value>String1</value>
</property>
</bean>
<bean id=”someBean” autowire=”byName”>
<property  name=”str1″>
<value>String1</value>
</property>
</bean>

<2>. byType:  寻找配置文件, 匹配的属性类型与bean一致; 找set方法;
上面例子改成byType 也是正确的, 并且ob可以改为别的名字;
如果在配置文件中找到符合条件的bean的个数超过一个，会报错；

<3>. constructor: 匹配构造器,看构造器的参数类型和配置文件bean的类型是否一致,
一致就成功,否则报错;匹配个数超过一个,也报错;提供一个构造器;

<4>. autodetect: 自动检测, 先构造器, 再set方法(也就是可以set方法和构造方法可以同时使用);

如果直接使用property和constructor-arg注入依赖的话，那么将总是覆盖自动装配。而且目前也不支持简单类型的自动装配，这里所说的简单类型包括基本类型、String、Class以及简单类型的数组（这一点已经被设计，将考虑作为一个功能提供）。byType和constructor自动装配模式也可用于数组和指定类型的集合。在这种情况下容器中的所有匹配的自动装配对象将被用于满足各种依赖。对于key值类型为 String的强类型Map也可以被自动装配。一个自动装配的Map的value值将由所匹配类型的bean所填充。而Map的key值则是相应的bean的名字。

自动装配还可以与依赖检查结合使用，这样依赖检查将在自动装配完成之后被执行。

理解自动装配的优缺点是很重要的。其中优点包括：

自动装配的一些缺点：

您可能也喜欢：
Spring IOC学习笔记	Spring IOC的介绍	spring 工厂方法创建bean	Spring Inversion of Control	Spring的介绍
无觅

Spring能有效地组织J2EE应用各层的对象。不管是控制层的Action对象，还是业务层的Service对象，还是持久层的DAO对象，都可在Spring的管理下有机地协调、运行。Spring将各层的对象以松耦合的方式组织在一起，Action对象无须关心Service对象的具体实现，Service对象无须关心持久层对象的具体实现，各层对象的调用完全面向接口。当系统需要重构时，代码的改写量将大大减少。
上面所说的一切都得宜于Spring的核心机制，依赖注入。依赖注入让bean与bean之间以配置文件组织在一起，而不是以硬编码的方式耦合在一起。

理解依赖注入
依赖注入(Dependency Injection)和控制反转(Inversion of Control)是同一个概念。具体含义是：当某个角色(可能是一个Java实例，调用者)需要另一个角色(另一个Java实例，被调用者)的协助时，在传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在Spring里，创建被调用者的工作不再由调用者来完成，因此称为控制反转;创建被调用者实例的工作通常由Spring容器来完成，然后注入调用者，因此也称为依赖注入。

不管是依赖注入，还是控制反转，都说明Spring采用动态、灵活的方式来管理各种对象。对象与对象之间的具体实现互相透明。
应用DI原则后，代码将更加清晰。而且当bean自己不再担心对象之间的依赖关系（甚至不知道依赖的定义指定地方和依赖的实际类）之后，实现更高层次的松耦合将易如反掌。DI主要有两种注入方式，即Setter注入和构造器注入。

构造器注入
基于构造器的DI通过调用带参数的构造器来实现，每个参数代表着一个依赖。此外，还可通过给stattic工厂方法传参数来构造bean。

public class SimpleMovieLister {
// the SimpleMovieLister has a dependency on a MovieFinder
private MovieFinder movieFinder;
// a constructor so that the Spring container can ‘inject’ a MovieFinder
public SimpleMovieLister(MovieFinder movieFinder) {
this.movieFinder = movieFinder;
}
// business logic that actually ‘uses’ the injected MovieFinder is omitted…
}

*为了解决参数类型匹配问题，可以通过使用’type’属性来显式指定那些简单类型的构造参数的类型，我们还可以通过index属性来显式指定构造参数的索引。
比如：
<bean id=”exampleBean”>
<constructor-arg type=”int” value=”7500000″/>
<constructor-arg type=”java.lang.String” value=”42″/>
</bean>
<bean id=”exampleBean”>
<constructor-arg index=”0″ value=”7500000″/>
<constructor-arg index=”1″ value=”42″/>
</bean>

Setter注入
通过调用无参构造器或无参static工厂方法实例化bean之后，调用该bean的setter方法，即可实现基于setter的DI。

BeanFactory对于它所管理的bean提供两种注入依赖方式（实际上它也支持同时使用构造器注入和Setter方式注入依赖）。需要注入的依赖将保存在BeanDefinition中，它能根据指定的PropertyEditor实现将属性从一种格式转换成另外一种格式。然而，大部份的Spring用户并不需要直接以编程的方式处理这些类，而是采用XML的方式来进行定义，在内部这些定义将被转换成相应类的实例，并最终得到一个Spring IoC容器实例。

处理bean依赖关系通常按以下步骤进行：

根据定义bean的配置（文件）创建并初始化BeanFactory实例（大部份的Spring用户使用支持XML格式配置文件的BeanFactory或ApplicationContext实现）。

每个bean的依赖将以属性、构造器参数、或静态工厂方法参数的形式出现。当这些bean被实际创建时，这些依赖也将会提供给该bean。

每个属性或构造器参数既可以是一个实际的值，也可以是对该容器中另一个bean的引用。

每个指定的属性或构造器参数值必须能够被转换成特定的格式或构造参数所需的类型。默认情况下，Spring会以String类型提供值转换成各种内置类型，比如int、long、String、boolean等。

Spring会在容器被创建时验证容器中每个bean的配置，包括验证那些bean所引用的属性是否指向一个有效的bean（即被引用的bean也在容器中被定义）。然而，在bean被实际创建之前，bean的属性并不会被设置。对于那些singleton类型和被设置为提前实例化的bean（比如ApplicationContext中的singleton bean）而言，bean实例将与容器同时被创建。而另外一些bean则会在需要的时候被创建，伴随着bean被实际创建，作为该bean的依赖bean以及依赖bean的依赖bean（依此类推）也将被创建和分配。

通常情况下，你可以信赖Spring，它会在容器加载时发现配置错误（比如对无效bean的引用以及循环依赖）。Spring会在bean创建时才去设置属性和依赖关系（只在需要时创建所依赖的其他对象）。这意味着即使Spring容器被正确加载，当获取一个bean实例时，如果在创建bean或者设置依赖时出现问题，仍然会抛出一个异常。因缺少或设置了一个无效属性而导致抛出一个异常的情况的确是存在的。因为一些配置问题而导致潜在的可见性被延迟，所以在默认情况下，ApplicationContext实现中的bean采用提前实例化的singleton模式。在实际需要之前创建这些bean将带来时间与内存的开销。而这样做的好处就是ApplicationContext被加载的时候可以尽早的发现一些配置的问题。不过用户也可以根据需要采用延迟实例化来替代默认的singleton模式。

如果撇开循环依赖不谈，当协作bean被注入到依赖bean时，协作bean必须在依赖bean之前完全配置好。例如bean A对bean B存在依赖关系，那么Spring IoC容器在调用bean A的setter方法之前，bean B必须被完全配置，这里所谓完全配置的意思就是bean将被实例化（如果不是采用提前实例化的singleton模式），相关的依赖也将被设置好，而且所有相关的lifecycle方法（如IntializingBean的init方法以及callback方法）也将被调用。

依赖配置详解
1.在spring的XML配置中使用<property/>和<constructor-arg/>元素定义。
2.idref元素用来将容器内其它bean的id传给<constructor-arg/> 或 <property/>元素，同时提供错误验证功能。

<bean id=”theTargetBean”/>
<bean id=”theClientBean”>
<property name=”targetName”>
<idref bean=”theTargetBean” />
</property>
</bean>
3.在<constructor-arg/>或<property/>元素内部还可以使用ref元素。该元素用来将bean中指定属性的值设置为对容器中的另外一个bean的引用。

内部bean
所谓的内部bean（inner bean）是指在一个bean的<property/>或 <constructor-arg/>元素中使用<bean/>元素定义的bean。内部bean定义不需要有id或name属性，即使指定id 或 name属性值也将会被容器忽略。

<bean id=”outer”>
<!– instead of using a reference to a target bean, simply define the target bean inline –>
<property name=”target”>
<bean> <!– this is the inner bean –>
<property name=”name” value=”Fiona Apple”/>
<property name=”age” value=”25″/>
</bean>
</property>
</bean>

集合
通过<list/>、<set/>、<map/>及<props/>元素可以定义和设置与Java Collection类型对应List、Set、Map及Properties的值。

List:  可重复的,有序
可以存放字符串,对象, 以及集合;
<property name=”list”>
<list>
<value>String1</value>
<value>String2</value>
</list>
</property>

Set: 不重复, 无序
可以存放字符串,对象, 以及集合;
<property name=”set”>
<set>
<value>String1</value>
<value>String1</value>
</set>
</property>

Map:Key(只能用String), value  键值对;
<property name=”map”>
<map>
<entry key=”key1″><!– 用key来存放key的值，用value来存放value值 –>
<value>value1</value>
</entry>
<entry key=”key2″>
<value>value2</value>
</entry>
</map>
</property>

Properties: key(String),value(String) 键值对

<property name=”properties”>
<props>
<prop key=”key11″>value11</prop>
<prop key=”key22″>value22</prop>
</props>
</property>

组合属性名称
当设置bean的组合属性时，除了最后一个属性外，只要其他属性值不为null，组合或嵌套属性名是完全合法的。

使用depends-on
多数情况下，一个bean对另一个bean的依赖最简单的做法就是将一个bean设置为另外一个bean的属性。
“depends-on”属性不仅用来指定初始化时的依赖，同时也用来指定相应的销毁时的依赖（该依赖只针对singletonbean）。depends-on属性中指定的依赖bean会在相关bean销毁之前被销毁，从而可以让用户控制销毁顺序。

继承关系:
<bean id=”abstractBean” abstract=”true”>
<property name=”str1″>
<value>string1</value>
</property>
<property name=”num”>
<value>20</value>
</property>
</bean>
<!– 继承关系 –>
<bean id=”someBean” parent=”abstractBean”>
<property name=”num”>
<value>30</value>
</property>
</bean>

得到的bean不想用单例时, 在bean标签上加 Scope=singleton/prototype

您可能也喜欢：
Spring IOC学习笔记	Spring IOC的介绍	Spring IOC Autowire	spring 工厂方法创建bean	Spring Bean Lifecycle Managerment
来自无觅网络的相关文章：
祝2012新春快乐！ (@netsh)	Spring is arriving (@tumutanzi)	2011年春节联欢晚会.. (@wx)	联通高层：iPhone4S春节前上市 (@belmeng)	GOMPlayer (@yongpc)
无觅

在Spring中，那些组成应用的主体(backbone)及由Spring IoC容器所管理的对象被称之为bean。简单地讲，bean就是由Spring容器初始化、装配及被管理的对象，除此之外，bean就没有特别之处了(与应用中的其他对象没有什么区别)。而bean定义以及bean相互间的依赖关系将通过配置元数据来描述。

org.springframework.beans.factory.BeanFactory是Spring IoC容器的实际代表者，IoC容器负责容纳此前所描述的bean，并对bean进行管理。

在Spring中，BeanFactory是IoC容器的核心接口。它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。

Spring为我们提供了许多易用的BeanFactory实现，如：ClassPathResource、XmlBeanFactory、ClassPathXmlApplicationContext，XmlBeanFactory就是最常用的一个。该实现将以XML方式描述组成应用的对象以及对象间的依赖关系。XmlBeanFactory类将持有此XML配置元数据，并用它来构建一个完全可配置的系统或应用。
实现方式分别如下：
Resource resource = new FileSystemResource(“beans.xml”);
BeanFactory factory = new XmlBeanFactory(resource);
… 或…

ClassPathResource resource = new ClassPathResource(“beans.xml”);
BeanFactory factory = new XmlBeanFactory(resource);
… 或…

InputStream is = new FileInputStream(“beans.xml”);
BeanFactory factory = new XmlBeanFactory(is);
… 或…

ApplicationContext context = new ClassPathXmlApplicationContext(
new String[] {“applicationContext.xml”, “applicationContext-part2.xml”});
// of course, an ApplicationContext is just a BeanFactory
BeanFactory factory = (BeanFactory) context;

Spring IoC容器将读取配置元数据；并通过它对应用中各个对象进行实例化、配置以及组装。通常情况下我们使用简单直观的XML来作为配置元数据的描述格式。在XML配置元数据中我们可以对那些我们希望通过Spring IoC容器管理的bean进行定义。

Spring支持三种配置元数据格式：XML格式、Java属性文件格式或使用Spring公共API编程实现。

基于XML配置元数据

为了加载多个XML文件生成一个ApplicationContext实例，可以将文件路径作为字符串数组传给ApplicationContext构造器。而bean factory将通过调用bean defintion reader从多个文件中读取bean定义。
另外一种方法是使用一个或多个的<import/>元素来从另外一个或多个文件加载bean定义。所有的<import/>元素必须放在<bean/>元素之前以完成bean定义的导入。
根据Spring XML配置文件的Schema(或DTD)，被导入文件必须是完全有效的XML bean定义文件，且根节点必须为<beans/> 元素。

多种bean
诚如此前所言，Spring IoC容器将管理一个或多个bean，这些bean将通过配置文件中的bean定义被创建(在XML格式中为<bean/>元素)。

在容器内部，这些bean定义由BeanDefinition 对象来表示，该定义将包含以下信息：

全限定类名：这通常就是已定义bean的实际实现类。如果通过调用static factory方法来实例化bean，而不是使用常规的构造器，那么类名称实际上就是工厂类的类名。
bean行为的定义，即创建模式（prototype还是singleton）、自动装配模式、依赖检查模式、初始化以及销毁方法。这些定义将决定bean在容器中的行为用于创建bean实例的构造器参数及属性值。比如使用bean来定义连接池，可以通过属性或者构造参数指定连接数，以及连接池大小限制等。
bean之间的关系，即协作 (或者称依赖)。

bean定义包括：
class
name
scope
constructor arguments
properties
autowiring mode
dependency checking mode
lazy-initialization mode
initialization method
destruction method

除了通过bean定义来描述要创建的指定bean的属性之外，某些BeanFactory的实现也允许将那些非BeanFactory创建的、已有的用户对象注册到容器中，比如使用DefaultListableBeanFactory的registerSingleton(..) 方法。不过大多数应用还是采用元数据定义为主。

命名bean
bean命名约定
bean的命名采用标准的Java命名约定，即小写字母开头，首字母大写间隔的命名方式。如accountManager、 accountService、userDao及loginController，等等。

对bean采用统一的命名约定将会使配置更加简单易懂。而且在使用Spring AOP时，如果要发通知(advice)给与一组名称相关的bean时，这种简单的命名方式将会令你受益匪浅。
每个bean都有一个或多个id(或称之为标识符或名称，在术语上可以理解成一回事)。这些id在当前IoC容器中必须唯一。如果一个bean有多个id，那么其他的id在本质上将被认为是别名。

当使用基于XML的配置元数据时，将通过id或name属性来指定bean标识符。id属性具有唯一性，而且是一个真正的XML ID属性，因此其他xml元素在引用该id时，可以利用XML解析器的验证功能。通常情况下最好为bean指定一个id。尽管XML规范规定了XML ID命名的有效字符，但是bean标识符的定义不受该限制，因为除了使用指定的XML字符来作为id，还可以为bean指定别名，要实现这一点可以在name属性中使用逗号、冒号或者空格将多个id分隔。

值得注意的是，为一个bean提供一个name并不是必须的，如果没有指定，那么容器将为其生成一个惟一的name。对于不指定name属性的原因我们会在后面介绍(比如内部bean就不需要)。

在XML配置文件中，可用单独的<alias/> 元素来完成bean别名的定义。如：
<alias name=”fromName” alias=”toName”/>

实例化bean
用构造器来实例化
当采用构造器来创建bean实例时，Spring对class并没有特殊的要求，我们通常使用的class都适用。也就是说，被创建的类并不需要实现任何特定的接口，或以特定的方式编码，只要指定bean的class属性即可。不过根据所采用的IoC类型，class可能需要一个默认的空构造器。

使用 静态工厂方法实例化
当采用静态工厂方法创建bean时，除了需要指定class属性外，还需要通过factory-method属性来指定创建bean实例的工厂方法。Spring将调用此方法(其可选参数接下来介绍)返回实例对象，就此而言，跟通过普通构造器创建类实例没什么两样。

下面的bean定义展示了如何通过工厂方法来创建bean实例。注意，此定义并未指定返回对象的类型，仅指定该类包含的工厂方法。在此例中， createInstance()必须是一个static方法。

<bean id=”exampleBean” factory-method=”createInstance”/>

使用实例工厂方法实例化
用来进行实例化的实例工厂方法位于另外一个已有的bean中，容器将调用该bean的工厂方法来创建一个新的bean实例。
为使用此机制，class属性必须为空，而factory-bean属性必须指定为当前(或其祖先)容器中包含工厂方法的bean的名称，而该工厂bean的工厂方法本身必须通过factory-method属性来设定。

使用容器
从本质上讲，BeanFactory仅仅只是一个维护bean定义以及相互依赖关系的高级工厂接口。通过BeanFactory我们可以访问bean定义。
BeanFactory提供的方法极其简单。它仅提供了六种方法供客户代码调用：
boolean containsBean(String)：如果BeanFactory包含给定名称的bean定义(或bean实例)，则返回true

Object getBean(String)：返回以给定名字注册的bean实例。根据bean的配置情况，如果为singleton模式将返回一个共享的实例，否则将返回一个新建的实例。如果没有找到指定的bean，该方法可能会抛出BeansException异常(实际上将抛出NoSuchBeanDefinitionException异常)，在对bean进行实例化和预处理时也可能抛出异常

Object getBean(String, Class)：返回以给定名称注册的bean实例，并转换为给定class类型的实例，如果转换失败，相应的异常

(BeanNotOfRequiredTypeException)将被抛出。上面的getBean(String)方法也适用该规则。

Class getType(String name)：返回给定名称的bean的Class。如果没有找到指定的bean实例，则抛出NoSuchBeanDefinitionException异常。

boolean isSingleton(String)：判断给定名称的bean定义(或bean实例)是否为singleton模式(singleton将在bean的作用域中讨论)，如果bean没找到，则抛出NoSuchBeanDefinitionException异常。

String[] getAliases(String)：返回给定bean名称的所有别名。

您可能也喜欢：
Spring IOC Autowire	spring 工厂方法创建bean	Spring IOC的介绍	Spring Inversion of Control	Spring Bean Lifecycle Managerment
无觅