在 Spring 中，构成应用程序主干并由 Spring IoC 容器管理的对象称为 bean。bean 是由 Spring IoC 容器实例化、组装和管理的对象。通俗的来说，就是由spring的IOC容器管理的所有的对象都叫做bean。
控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，其中最常见的方式叫做依赖注入（Dependency Injection，简称DI。DI是控制反转实现的具体方式。
那么控制反转是什么意思呢？哪些方面的控制被反转了呢？我的答案是依赖的对象的获得被反转了。我们来看下面一段代码：
假设我们现在有有两个类，其中类A有普通类型的aMethod方法，类B有普通类型的bMethod方法，现在我们想要在A类中使用B类的bMethod方法，请你分别写出，普通写法和控制反转的写法。
如果我们使用普通的方式，进行使用，一般是显示的在A类直接new一个B类的对象(方法内或者类内方法外)，如果是在方法内，A类依赖B类，如果在方法外，类内，A类关联B类。
//依赖使用
public class A{
public void aMethod(){
System.out.println("我是A类的aMethod方法");
B b = new B();
//调用B类的方法
B.bMethod();
}
}
//关联使用
public class A{
B b = new B();
public void aMethod(){
System.out.println("我是A类的aMethod方法");
//调用B类的方法
B.bMethod();
}
}
现在获得依赖的对象的方式，是正向的，从A类之中，直接创建一个B类对象，他们之间是紧耦合的。整个获取的过程是正向的。
使用依赖注入实现控制反转：
那么控制反转的写法该如何实现呢？
//依赖注入 构造传递
public class A{
private B b ;
public B(B b) {
this.b = B;
}
public void aMethod(){
System.out.println("我是A类的aMethod方法");
//调用B类的方法
B.bMethod();
}
}
//依赖注入 Setter传递
public class A{
private B b ;
public void setB(B b) {
this.b = B;
}
public void aMethod(){
System.out.println("我是A类的aMethod方法");
//调用B类的方法
B.bMethod();
}
}
这时候，A类在未被Set进B类的对象的时候，A类和B类其实是没有关系的，因为在Set对象之前，B类的对象是一个null值。A类获取B类对象的方式变了，从主动进行获取变成了被动注入。A类和B类的耦合关系，就拿出来了。接下来我们还可以根据自己的需要，将setB获取B对象放到配置文件中，让二者的耦合放到配置文件中决定，并可以随时更改。
上文我们说道，控制反转的实现，说的是一个B类对象的注入，如果多了呢？假设我们有成千上万个类，并且这写类可能还作为另一些类的属性，我们该如何进行管理呢？这时候就引出了IOC容器的概念。
IOC容器是负责实例化、配置和组装 bean。容器通过读取配置元数据来获取关于要实例化、配置和组装哪些对象的指令。
BeanFactory工厂
public class BeanFactory {
//定义一个properties对象
private static Properties props;
//定义一个Map,用于存放我们创建的对象（单例，当类加载之后就有了对象，之后从Map中获取）
private static Map<String,Object> beans = new HashMap<>();
//容器
static {
try {
props=new Properties();
//将bean.properties放在了resources路径下
InputStream is=BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
props.load(is);
//实例化容器
//从配置文件中获取所有key值
Enumeration<Object> keys = props.keys();
while (keys.hasMoreElements()){
//取出每一个key
String key = keys.nextElement().toString();
//根据key获取value
String path = props.getProperty(key);
//此处使用反射，获取类对象
Object value=Class.forName(path).newInstance();
//放入容器中
beans.put(key,value);
}
}catch (Exception e){
e.printStackTrace();
}
}
//提供一个访问Map容器的入口
public static Object getInstance(String name){
return beans.get(name);
}
}
配置文件
Chassis=Chassis
Tyre=Tyre
CarBody=CarBody
Car=Car
Client方法
public class Client {
public static void main(String[] args) {
//车轱辘
Tyre tyre = (Tyre)BeanFactory.getInstance("Tyre");
//车底盘
Chassis chassis= (Chassis)BeanFactory.getInstance("Chassis");
//将车轮注入到车底盘
chassis.setTyre(tyre);
//车身
CarBody carBody = (CarBody) BeanFactory.getInstance("CarBody");
//将底盘注入到车身
carBody.setChassis(chassis);
//车
Car car = (Car) BeanFactory.getInstance("Car");
//将车身注入到车中
car.setCarBody(carBody);
car.run();
}
}
注入的类
//轮子类
public class Tyre {
public void tyre(){
System.out.println("车轮一个");
}
}
//底盘类
public class Chassis {
private Tyre tyre;
public void setTyre(Tyre tyre) {
this.tyre = tyre;
}
public void chassis(){
System.out.println("底盘");
}
}
//车身类
public class CarBody {
private Chassis chassis;
public void setChassis(Chassis chassis) {
this.chassis = chassis;
}
public void carBody(Chassis chassis){
System.out.println("车身");
}
}
//车类
public class Car {
private CarBody carBody;
public void setCarBody(CarBody carBody) {
this.carBody = carBody;
}
public void run(){
System.out.println("车跑了");
}
}
BeanFactory模拟的就是spring的IOC容器，使用容器来管理一个又一个的bean对象，在配置文件中，将这些类交由BeanFactory进行管理。
依赖注入（Dependency Injection）：Spring Bean通过依赖注入的方式管理对象之间的依赖关系。这使得代码更加松耦合，易于维护和测试。通过依赖注入，可以将对象的创建和配置与它们的使用分离开来，提高了代码的可扩展性和可重用性。
面向切面编程（Aspect-Oriented Programming）：Spring Bean可以通过面向切面编程的方式实现横切关注点（Cross-cutting Concerns）的管理，例如日志记录、事务管理等。这种方式使得关注点的代码与核心业务逻辑分离，提高了代码的模块化和可维护性。
生命周期管理：Spring Bean提供了丰富的生命周期管理机制。可以通过配置和回调方法来管理Bean的创建、初始化、销毁等过程。这使得开发人员能够在Bean的不同生命周期阶段执行自定义操作，例如资源的加载和释放等。
配置灵活性：Spring Bean的配置方式非常灵活，可以通过XML、注解或Java配置类来定义和配置Bean。这使得开发人员能够根据具体需求选择合适的配置方式，并方便地切换和管理不同环境下的配置。
AOP支持：Spring Bean对面向切面编程提供了原生支持。通过配置切面和切点，可以在不修改原始代码的情况下，实现横切关注点的功能。这种方式可以提高代码的重用性和可维护性，减少代码冗余。
整合其他框架：Spring Bean可以与其他框架无缝集成，例如Hibernate、MyBatis、JPA等。通过Spring Bean，可以方便地管理和配置这些框架的对象，简化了框架之间的集成工作。
本文给出了SpringBean的基本实现，有利于我们理解SpringBean容器的内部原理，更好的使用Spring框架。