关于控制反转的一些想法

/**
*  B中代码的实现是依赖A的，两者之间的耦合度非常高，当两者之间的业务逻辑复杂程度增加的情况下
*  维护成本与代码的可读性都会随着增加，并且很难再多引入额外的模块进行功能扩展
*/
 
class A {
    name: string
    constructor(name:string){
        this.name = name;
    }
}
 
class B {
    age: number
    entity: A
    constructor (age: number) {
        this.age = age;
        this.entity = new A ('test');
    }
}
 
const c = new B(18);
 
console.log(c.entity.name);
 

// 通过中间件方式来收集依赖，实现解耦，减少维护成本
 
 
class A {
    name: string
    constructor(name: string){
        this.name = name;
    }
}
 
class C {
    name: string
    constructor(name: string){
        this.name = name;
    }
}
 
// 中间件用于解耦
class Container {
    modules: any
    constructor () {
        this.modules = {};
    }
    
    provide(key: string, modules: any){
        this.modules[key] = modules;
    }
    
    get(key:string){
        return this.modules[key];
    }
}
 
// 实例化中间件类，依赖注入
const mo = new Container();
mo.provide('a', new A('test1'));
mo.provide('c', new C('test2'));
 
class B {
    a: any
    c:any
    constructor(container: Container){
        this.a = container.get('a');
        this.c = container.get('c');
    }
}
 
const b = new B(mo);
 
console.log(b.a.name);
console.log(b.c.name);