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

朱雀 2023-10-09 15:10 41阅读 0赞

#### 手动实现一个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，可以方便地管理和配置这些框架的对象，简化了框架之间的集成工作。

### 5.2 总结 ###

本文给出了SpringBean的基本实现，有利于我们理解SpringBean容器的内部原理，更好的使用Spring框架。