IoC 是什么
IoC：Inversion of Control 控制反转，也称依赖倒置（反转）
IoC 不是什么技术，而是一种设计思想。在 Java 开发中，IoC 意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。
上例子：
public static void main(String[] args) {
ServiceA serviceA = new ServiceA();
serviceA.doService();
}
上面这种就是传统的方式，在用 ServiceA 的时候再去实例化 ServiceA。是程序主动去创建依赖对象。
IoC 是有专门一个容器来创建这些对象，即由 IoC 容器来控制对象的创建。
为何是反转：有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转。
而反转则是由容器来帮忙创建及注入依赖对象；为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转。
public class ServiceA {
@Autowired
ServiceB serviceB;
public static void main(String[] args) {
serviceB.doService();
}
}
上面这个例子就是容器帮我们创建 ServiceB，我们直接使用就可以。
DI 是什么
DI—Dependency Injection，即“依赖注入”：组件之间依赖关系由容器在运行期决定，即由容器动态的将某个依赖关系注入到组件之中。就像上面的那个例子 @Autowired 一样。
依赖注入的目的是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。
简单来说，IoC 是目的，DI 是手段。IoC 是指让生成类的方式由传统方式（new）反过来，既程序员不调用 new,需要类的时候由框架注入（DI），是同一件事不同层面的解读。
Spring 中 IoC 的设计
Beanfactory，IoC 容器 Bean 工厂
Spring 中用 Bean 创建、管理实例对象，用户需要实例对象时只需要向 IOC 容器获取就行了，不用自己去创建，从而达到与具体类解耦。
bean 是什么，bean 是组件，就是类对象！
Spring 通过 Bean 工厂去管理，创建所有的 Bean，即 Beanfactory。就是 spring 的 IoC 容器。
Bean 工厂对外提供获取 Bean 的接口。
Spring 源码：
//The root interface for accessing a Spring bean container.
public interface BeanFactory {
...
//Return an instance, which may be shared or independent, of the specified bean.
Object getBean(String name) throws BeansException;
...
}
Spring 对该接口进行了扩展，比如 ListableBeanFactory 和 AutowireCapableBeanFactory 等，提供了一些其他功能。spring 工程的启动类中，ApplicationContext 也是继承了 ListableBeanFactory。可见 BeanFactory 是整个 spring 的核心。
BeanDefinitionRegistry， Bean 注册
说完 Bean 工厂，我们怎么能让 spring 容器知道我们需要哪些 Bean 呢？ 这就需要 Bean 的注册定义接口，即 BeanDefinitionRegistry。
Spring 源码：
/*Interface for registries that hold bean definitions, for example RootBeanDefinition
* and ChildBeanDefinition instances. Typically implemented by BeanFactories that
* internally work with the AbstractBeanDefinition hierarchy.*/
public interface BeanDefinitionRegistry extends AliasRegistry {
//Register a new bean definition with this registry.
void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException;
//Remove the BeanDefinition for the given name.
void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
//Return the BeanDefinition for the given bean name.
BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
//Check if this registry contains a bean definition with the given name.
boolean containsBeanDefinition(String beanName);
//Return the names of all beans defined in this registry.
String[] getBeanDefinitionNames();
//Return the number of beans defined in the registry.
int getBeanDefinitionCount();
//Determine whether the given bean name is already in use within this registry,
//whether there is a local bean or alias registered under this name.
boolean isBeanNameInUse(String beanName);
}
bean 定义 BeanDefinition 定义好了就需要告诉 IoC 容器(bean 工厂)
通过 bean 定义注册接口 BeanDefinitionRegistry 把 bean 定义 BeanDefinition 注册到 IoC 容器(bean 工厂) BeanFactory。
源码中的注释已经解释的很好了，我就不在这一一翻译了。
BeanDefinition， Bean 定义
Bean 的定义，告诉工厂该如何创建 Bean。
spring 源码：
/**
* A BeanDefinition describes a bean instance, which has property values,
* constructor argument values, and further information supplied by
* concrete implementations.
*/
public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
/**
* Scope identifier for the standard singleton scope: {@value}.
*/
String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
/**
* Scope identifier for the standard prototype scope: {@value}.
*/
String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;
...
/**
* Set the name of the parent definition of this bean definition, if any.
*/
void setParentName(@Nullable String parentName);
/**
* Return the name of the parent definition of this bean definition, if any.
*/
@Nullable
String getParentName();
/**
* Specify the bean class name of this bean definition.
*/
void setBeanClassName(@Nullable String beanClassName);
/**
* Return the current bean class name of this bean definition.
*/
@Nullable
String getBeanClassName();
/**
* Override the target scope of this bean, specifying a new scope name.
*/
void setScope(@Nullable String scope);
/**
* Return the name of the current target scope for this bean,
* or {@code null} if not known yet.
*/
@Nullable
String getScope();
/**
* Set whether this bean should be lazily initialized.
*/
void setLazyInit(boolean lazyInit);
/**
* Return whether this bean should be lazily initialized, i.e. not
* eagerly instantiated on startup. Only applicable to a singleton bean.
*/
boolean isLazyInit();
/**
* Specify the factory bean to use, if any.
* This the name of the bean to call the specified factory method on.
* @see #setFactoryMethodName
*/
void setFactoryBeanName(@Nullable String factoryBeanName);
/**
* Return the factory bean name, if any.
*/
@Nullable
String getFactoryBeanName();
/**
* Specify a factory method, if any. This method will be invoked with
* constructor arguments, or with no arguments if none are specified.
* The method will be invoked on the specified factory bean, if any,
* or otherwise as a static method on the local bean class.
*/
void setFactoryMethodName(@Nullable String factoryMethodName);
/**
* Return a factory method, if any.
*/
@Nullable
String getFactoryMethodName();
/**
* Return the constructor argument values for this bean.
*/
ConstructorArgumentValues getConstructorArgumentValues();
/**
* Return if there are constructor argument values defined for this bean.
*/
default boolean hasConstructorArgumentValues() {
return !getConstructorArgumentValues().isEmpty();
}
/**
* Return the property values to be applied to a new instance of the bean.
*/
MutablePropertyValues getPropertyValues();
/**
* Return if there are property values defined for this bean.
*/
default boolean hasPropertyValues() {
return !getPropertyValues().isEmpty();
}
/**
* Set the name of the initializer method.
*/
void setInitMethodName(@Nullable String initMethodName);
/**
* Return the name of the initializer method.
*/
@Nullable
String getInitMethodName();
/**
* Set the name of the destroy method.
*/
void setDestroyMethodName(@Nullable String destroyMethodName);
/**
* Return the name of the destroy method.
*/
@Nullable
String getDestroyMethodName();
/**
* Set a human-readable description of this bean definition.
* @since 5.1
*/
void setDescription(@Nullable String description);
/**
* Return a human-readable description of this bean definition.
*/
@Nullable
String getDescription();
/**
* Return whether this a Singleton, with a single, shared instance
*/
boolean isSingleton();
/**
* Return whether this a Prototype, with an independent instance
*/
boolean isPrototype();
...
}
我并没有把全部代码都粘上来，具体的可以去看 spring 源码 只是把大体功能粘贴上来了。
主要就是一下功能：
-配置 Bean 的 Class 全路径；
-配置/获取 Bean 是否懒加载；
-配置/获取 FactoryBean 的名字；
-配置 Bean 的初始化方法、销毁方法；
-是否为单例或者原型；
-配置/获取 Bean 的依赖对象
-配置/获取 Bean 是否是自动装配。
等等。。
由 BeanDefinition 定义 Bean，然后 BeanDefinitionRegistry 来注册 Bean，最后 BeanFactory 来创建 Bean，这样 Spring 就完成了整个 Bean 的管理和创建，也实现了 IoC 的功能，在应用中用到 Bean 的时候，Spring 在通过依赖注入（DI）的方式给到程序使用。