# 依赖注入

# 前置知识

# 依赖倒置 DIP

面向对象六大基本原则之一。

指一种特定的解耦形式,使得高层次的模块不依赖于低层次的模块的实现细节,依赖关系被颠倒(反转),从而使得低层次模块依赖于高层次模块的需求抽象。

该原则规定:

  • 高层次的模块不应该依赖于低层次的模块,两者都应该依赖于抽象接口。
  • 抽象接口不应该依赖于具体实现。而具体实现则应该依赖于抽象接口。

# 控制反转 IOC

控制反转是面向对象编程中的一种设计原则,用来降低计算机代码之间的耦合度。

是实现依赖倒置原则的一种代码设计思路。

其中最常见的方式叫做依赖注入,还有一种方式叫依赖查找。

# 依赖注入 DI

依赖注入是实现控制反转的一种方式。常用的依赖注入方法有 3 种:

  • 接口注入
  • 构造函数注入
  • 属性注入

# 案例

常用的后端架构可以分为 3 层:

web 层接收前端请求,处理请求参数,匹配后端路由,调用对应的 service 层处理业务。

service 层接收 web 层的参数,处理业务逻辑,如果需要读取数据,会调用 database 层。

database 层处理数据库相关的层,负责连接数据库,以及常用的增删改查方法的封装。

# 非依赖注入

非依赖注入的开发模式很符合常规逻辑,即:web 层依赖 service 层,service 层依赖 database 层。


class Database {
  select(sql) {
    const mysql = require('mysql');
    return new Promise(resolve => {
      // 连接数据库,并执行 sql 语句进行查询
      mysql.createConnection().query(sql, (error, results, fields) => {
        const success = results.length > 0 ? true : false;
        resolve(success);
      });
    });
  }
}

class Service {
  async login(username, password) {
    const db = new Database();
    const success = await db.select(
      `select * from user where username=${username} and password=${password}`
    );
    return success ? '登录成功' : '登录失败';
  }
}

class Web {
  matchRouter(path) {
    switch (path) {
      case 'login':
        const service = new Service();
        const { username, password } = path.query;
        return service.login(username, password);
    }
  }
}

// 使用 web 层
const web = new Web();
web.matchRouter('login');

非依赖注入开发模式的优缺点:

  • 代码复杂度低,逻辑清晰,使用方便,直接 new 最上层的模块就行了。
  • 不利于维护,如果底层( database 层)修改了 select 方法的传参方式,上层(service 层和 web 层)也必须同步修改调用方式。
  • 不利于测试,各个模块耦合在一起,要单独测试 web 层是不行的,因为它内部引入了 service 层和 database 层,只能当成一个整体测试。

# 依赖注入

删除内部依赖关系,将需要的依赖通过构造函数注入:
















 
 
 

 








 
 
 



 







 
 
 




class Database {
  select(sql) {
    const mysql = require('mysql');
    return new Promise(resolve => {
      // 连接数据库,并执行 sql 语句进行查询
      mysql.createConnection().query(sql, (error, results, fields) => {
        const success = results.length > 0 ? true : false;
        resolve(success);
      });
    });
  }
}

class Service {
  constructor(db) {
    this.db = db;
  }
  async login(username, password) {
    // const db = new Database();
    const success = await this.db.select(
      `select * from user where username=${username} and password=${password}`
    );
    return success ? '登录成功' : '登录失败';
  }
}

class Web {
  constructor(service) {
    this.service = service;
  }
  matchRouter(path) {
    switch (path) {
      case 'login':
        // const service = new Service();
        const { username, password } = path.query;
        return this.service.login(username, password);
    }
  }
}

// 使用 web 层之前,必须手动创建依赖,并注入
const database = new Database();
const service = new Service(database);
const web = new Web(service);
web.matchRouter('login');

依赖注入开发模式的优缺点:

  • 代码复杂度低,逻辑清晰,使用较复杂,需要手动注入依赖。
  • 便于维护,代码耦合度低,各个模块互不依赖。
  • 便于测试,不同模块之间可以单独的进行单元测试。

# 依赖注入容器

每一次使用都需要手动传入依赖,当依赖太多时,也会造成难以维护的问题。

可以在一个地方统一进行依赖注入,即在一个依赖注入容器里。

创建依赖注入容器:

// ioc.js
export default function createIoC() {
  const iocMap = new Map();
  return {
    bind(key, callback) {
      iocMap.set(key, { callback });
    },
    use(key) {
      const { callback } = iocMap.get(key);
      return callback();
    }
  };
}

在配置文件中配置依赖关系:

// ioc-config.js
import createIoC from 'ioc.js';
const ioc = createIoC();

// 绑定依赖关系
ioc.bind('Database', () => {
  return new Database();
});

ioc.bind('Service', () => {
  const database = ioc.use('Database');
  return new Service(database);
});

ioc.bind('Web', () => {
  const service = ioc.use('Service');
  return new Web(service);
});

export default ioc;

依赖注入:


import ioc from 'ioc-config.js';
// 使用 web 层
const web = ioc.use('Web');
web.matchRouter('login');

  • 代码复杂度较高,逻辑较复杂,使用方便,要什么就注入什么就行了。
  • 便于维护,只需在一个地方(ioc-config.js)定义依赖关系,这个文件可以抽离出来作为单独的配置文件,实现数据驱动。
  • 便于测试,不同模块之间可以单独的进行单元测试。

引用:

https://juejin.im/post/5d347c9f6fb9a07efe2dfa16