手动实现一个Spring 框架IOC容器-蒲公英云

手动实现一个Spring 框架IOC容器

一：什么是spring中的bean？
二：什么是IOC？什么是DI
- 2.1 应用场景
- 2.2具体实现
三：什么是IOC容器
四：如何手动实现一个IOC容器
五：总结&提升
- 5.1 SpringBean的好处Spring Bean有以下几个好处：
- 5.2 总结

一：什么是spring中的bean？

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

二：什么是IOC？什么是DI

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

2.1 应用场景

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

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

五：总结&提升

5.1 SpringBean的好处Spring Bean有以下几个好处：

依赖注入（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，可以方便地管理和配置这些框架的对象，简化了框架之间的集成工作。