Java SE
- Java beans
- Java ServiceLoader SPI
- JNDI (Java Naming and Directory Interface)
Java EE
- EJB (Enterprise Java Beans)
- Servlet
开源
- Apache Avalon
- PicoContainer
- Google Guice
- Spring Framework

传统IoC容器的实现

Java Beans 作为IoC容器。
特性: 依赖查找,生命周期管理,配置元信息,事件,自定义,资源管理,持久化

package spring;

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.util.stream.Stream;

public class JavaBean {
    /**
     *  set 和get 方法被称为可写和可读方法
     */
    public  class Person {
        // 属性在java bean中称为property
        String name;
        Integer age;

        public String getName() {
            return name;
        }

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

        public Integer getAge() {
            return age;
        }

        public void setAge(Integer age) {
            this.age = age;
        }
    }

    public static void main(String[] args) throws Exception{
        BeanInfo beanInfo = Introspector.getBeanInfo(Person.class);
        Stream.of(beanInfo.getPropertyDescriptors()).forEach(propertyDescriptor -> {
            System.out.println(propertyDescriptor);
        });
    }
}

输出如下

java.beans.PropertyDescriptor[name=age; propertyType=class java.lang.Integer; readMethod=public java.lang.Integer spring.JavaBean$Person.getAge(); writeMethod=public void spring.JavaBean$Person.setAge(java.lang.Integer)]
java.beans.PropertyDescriptor[name=class; propertyType=class java.lang.Class; readMethod=public final native java.lang.Class java.lang.Object.getClass()]
java.beans.PropertyDescriptor[name=name; propertyType=class java.lang.String; readMethod=public java.lang.String spring.JavaBean$Person.getName(); writeMethod=public void spring.JavaBean$Person.setName(java.lang.String)]

BeanInfo beanInfo = Introspector.getBeanInfo(Person.class,Object.class); 加了后面Object.class传参数后就会返回两个属性了。

// PropertyEditor 进行类型的转换
public static void main(String[] args) throws Exception{
    BeanInfo beanInfo = Introspector.getBeanInfo(Person.class,Object.class);
    Stream.of(beanInfo.getPropertyDescriptors()).forEach(propertyDescriptor -> {
        System.out.println(propertyDescriptor);
        // 允许添加属性编辑器
        // GUI --> text(String) --> PropertyType
        Class<?> propertyType = propertyDescriptor.getPropertyType();
        String propertyName = propertyDescriptor.getName();
        if("age".equals(propertyName)){
            propertyDescriptor.setPropertyEditorClass(String2Integer.class);
        }
    });
}
static class String2Integer extends PropertyEditorSupport {
    @Override
    public void setAsText(String text) throws java.lang.IllegalArgumentException {
        setValue(Integer.valueOf(text));
    }
}

轻量级IoC容器

一个可以管理应用程序代码的容器。即容器可以管理代码的运行，如：控制代码的启停
一个可以快速启动的容器，当然也要根据具体实现来，如果依赖的资源比较多，或者所需功能较为强大，对应的性能、速度方面也会有所下降
一个不需要任何特殊部署步骤即可在其中部署对象的容器。即容器不需要特殊的配置来进行操作。例如EJB在容器部署的时候需要大量的XML配置文件以及相关的资源进行配合，而Spring Framework则相对较轻。
一个具有如此轻巧的占地面积和最小的Api的容器可以在各种环境中运行的依赖项。即容器能够达到一些比较轻量级的内存占用以及最小化的API的依赖
一个容器，它为添加被管理对象设置了标准，使其在部署工作量和性能开销方面特别低，以至于可以部署和管理细粒度对象以及粗粒度对象粒状组件。即容器需要有一些可以管控的渠道，这些渠道可以能帮助我们部署和管理一些细粒度的对象甚至是粗粒度的一些组件，主要是为了达到部署上的效率和相关性能的开销

轻量级容器的好处

逃避整体式容器，即释放一些所谓的聚式或者单体这样的容器
最大化代码可重用性，即容器/实现能够进行最大程度的复用
更大程度面向对象
更大的产品化
可测试性更高

依赖注入和依赖查找

构造器注入 VS Setter注入

The Spring team generally advocates constructor injection, as it lets you implement application components as immutable objects and ensures that required dependencies are not null.
这里spring团队以一个讨论的口吻来说的, 建议一般使用构造器注入, 保证注入的对象是一个immutable, 不变的对象, 确保依赖的对象不为空. 这个讲法忽略了一个细节, 其实如果依赖的对象为空或者不存在的话, 可以用另外的方式, 也可以通过构造器方式进行注入, 使用 ObjectProvider 类, 它是一种类型安全的方式, 如果你的依赖注入或依赖查找的方式需要的是一个单一类型的依赖, 这时可以调用它的 getIfAvailable() ,来进行示范性的返回, 等于空的时候就会返回空, 这种方式在springBoot的场景中经常被用到.

Furthermore, constructor-injected components are always returned to the client (calling) code in a fully initialized state. As a side note, a large number of constructor arguments is a bad code smell, implying that the class likely has too many responsibilities and should be refactored to better address proper separation of concerns.

构造器注入的组件通常返回给客户端代码的时候, 是一个完整的初始化状态. 不过呢, 如果构造器的参数过多, 代码看起来就不是十分的良好, 意味着类包含了太多的职责, 不能有太多的输入, 最好进行一下重构(refactored)
Setter注入应该主要仅用于我们的可选性的注入, 另一方面, 如果代码中有用到相关的依赖, 非空检查就是必须的, 我们都知道@Autowired注解是有非空检查的参数的, 而默认可以注入空的对象过来.当然Setter注入可以让依赖进行延迟注入, 让对象变得更可配, 这是一个优点。

Setter injection should primarily only be used for optional dependencies that can be assigned reasonable default values within the class. Otherwise, not-null checks must be performed everywhere the code uses the dependency. One benefit of setter injection is that setter methods make objects of that class amenable to reconfiguration or re-injection later. Management through JMX MBeans is therefore a compelling use case for setter injection.

Setter注入应该主要仅用于我们的可选性的注入, 另一方面, 如果代码中有用到相关的依赖, 非空检查就是必须的, 我们都知道@Autowired注解是有非空检查的参数的, 而默认可以注入空的对象过来.当然 Setter 注入可以让依赖进行延迟注入, 让对象变得更可配, 这是一个优点。

《Expert One-on-One™ J2EE™ Development without EJB™》认为Setter 注入的优点

来自“Chapter 6. Lightweight Containers and Inversion of Control” 节选

Advantages of Setter Injection include:

JavaBean properties are well supported in IDEs. JavaBean的属性在IDE方面支持良好, 前面讲过, 在GUI方面是有用的.
JavaBean properties are self-documenting. JavaBean的属性是自文档的方式, 通常不需要过多文档说明
JavaBean properties are inherited by subclasses without the need for any code. JavaBean的属性通过继承的方式呢, 通常不需要任何的修改,但是这个通常不应该是个优点,只是作为面向对象的一个特点
It’s possible to use the standard JavaBeans property-editor machinery for type conversions if necessary. 因为有propertyEditor这个机制, setter中可以进行一些类型转换
Many existing JavaBeans can be used within a JavaBean-oriented IoC container without modification. 大量存在的JavaBeans可以在JavaBean原生的IoC容器中使用, 不需要做太大的修改. 这里就是指的原生的 BeanContext 这个容器, 这个上下文其实和 spring的 ApplicationContext 有异曲同工之处.
If there is a corresponding getter for each setter (making the property readable, as well as writable), it is possible to ask the component for its current configuration state. This is particularly useful if we want to persist that state: for example, in an XML form or in a database. With Constructor Injection, there’s no way to find the current state. 如果每一个Setter方法都有对应的Getter方法的情况下,可以比较方便的在任何时候获取到组件的当前状态.这个特点在我们需要保存这个状态的时候特别有用, 而构造器注入就做不到这点. 这样就容易对Bean进行一个管理.
Setter Injection works well for objects that have default values, meaning that not all properties need to be supplied at runtime. Setter方法可以为属性设置一个默认值, 并不是所有的属性都需要在运行时才进行设值.

《Expert One-on-One™ J2EE™ Development without EJB™》认为Setter 注入的缺点

Disadvantages include: \

The order in which setters are called is not expressed in any contract. Thus, we sometimes need to invoke a method after the last setter has been called to initialize the component. Spring provides the org.springframework.beans.factory.InitializingBean interface for this; it also provides the ability to invoke an arbitrary init method. However, this contract must be documented to ensure correct use outside a container. setter的顺序无法保证, 而构造器注入因为构造器方法的参数顺序是一定的, 天然决定了设值的顺序是有序的, 不会因为外部调用的顺序而出现问题. 这里提到了一个spring的接口 InitializingBean ,这个接口能够帮助我们实现一个特性就是当我的属性已经设置好了之后, 我们再做相应的操作. 但是这个接口并不会强制的保证正确性, 只是一个鼓励.
Not all the necessary setters may have been called before use. The object can thus be left partially configured.” 在调用前并不是每一个Setter方法都需要被调用的.

《Expert One-on-One™ J2EE™ Development without EJB™》认为构造器注入的优点

Advantages of Constructor Injection include:

Each managed object is guaranteed to be in a consistent state—fully configured—before it can be invoked in any business methods. This is the primary motivation of Constructor Injection. (However, it is possible to achieve the same result with JavaBeans via dependency checking, as Spring can optionally perform.) There’s no need for initialization methods. 能够确保每个被管理的对象有一致的状态,完全配置好的, 且一旦初始化完成就不再进行变更的. 正如前面所说, 也因此组件对应的对象通常也被声明为 final 的.
There may be slightly less code than results from the use of multiple JavaBean methods, although will be no difference in complexity.” 减少过多的Setter和Getter方法的代码量. 这个因为现在有建造模式, 似乎也没啥必要.

《Expert One-on-One™ J2EE™ Development without EJB™》认为构造器注入的缺点

Disadvantages include:

Although also a Java-language feature, multi-argument constructors are probably less common in existing code than use of JavaBean properties. 虽然也是Java语言的特性，但多参数构造函数在现有代码中可能不如使用JavaBean属性常见。
Java constructor arguments don’t have names visible by introspection. Java构造函数参数没有自省可见的名称。
Constructor argument lists are less well supported by IDEs than JavaBean setter methods. IDE的支持不如Setter方法的好
Long constructor argument lists and large constructor bodies can become unwieldy.
长的构造函数参数列表和大的构造函数体可能会变得笨拙
Concrete inheritance can become problematic.
Poor support for optional properties, compared to JavaBeans
Unit testing can be slightly more difficult
When collaborators are passed in on object construction, it becomes impossible to change the reference held in the object. ”

IoC的实现