一：什么是spring中的bean？

在 Spring 中，构成应用程序主干并由 Spring IoC 容器管理的对象称为 bean。bean 是由 Spring IoC 容器实例化、组装和管理的对象。通俗的来说，就是由spring的IOC容器管理的所有的对象都叫做bean。

二：什么是IOC？什么是DI

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，其中最常见的方式叫做依赖注入（Dependency Injection，简称DI。DI是控制反转实现的具体方式。
那么控制反转是什么意思呢？哪些方面的控制被反转了呢？我的答案是依赖的对象的获得被反转了。我们来看下面一段代码：

1.应用场景

假设我们现在有有两个类，其中类A有普通类型的aMethod方法，类B有普通类型的bMethod方法，现在我们想要在A类中使用B类的bMethod方法，请你分别写出，普通写法和控制反转的写法。

2.具体实现

如果我们使用普通的方式，进行使用，一般是显示的在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对象放到配置文件中，让二者的耦合放到配置文件中决定，并可以随时更改。

三：什么是IOC容器

上文我们说道，控制反转的实现，说的是一个B类对象的注入，如果多了呢？假设我们有成千上万个类，并且这写类可能还作为另一些类的属性，我们该如何进行管理呢？这时候就引出了IOC容器的概念。
IOC容器是负责实例化、配置和组装 bean。容器通过读取配置元数据来获取关于要实例化、配置和组装哪些对象的指令。

四：如何手动实现一个IOC容器

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进行管理。