typeorm依赖项注入和单例

Question

我有一个项目，我正在尝试使用typedir和typeorm应用依赖项注入 然后我尝试将单例模式应用于我的控制器和服务，但是我不知道在这种依赖注入的情况下单例的应用是正确的还是会阻碍任何事情 在这种情况下是否有必要应用单例？

如何获取控制器和服务：

 private getControllers() {
    let rootDir: string =
      process.env.NODE_ENV === 'development' ? 'src' : 'build/src';
    let pattern: string = rootDir + '/modules/**/controllers/*.{js,ts}';
    glob.sync(pattern).forEach(file => {
      let value = require(resolve(file)).default;
      var controller: IController = value.getInstance();
      this.app.use('/', controller.getRouter());
    });
  }
  private getServices() {
    let rootDir: string =
      process.env.NODE_ENV === 'development' ? 'src' : 'build/src';
    let pattern: string = rootDir + '/modules/**/services/index.{js,ts}';
    glob.sync(pattern).forEach(file => {
      let tempService = require(resolve(file)).default;
      var service = tempService.getInstance();
      Container.set(service.constructor.name, service)
    });
  }

控制器：

export default class DepartamentController implements IController {
  private path: string;
  private router: Router;
  private readonly services: DepartamentsServices
  private static _instance: DepartamentController;
  private constructor() {
    this.path = '/departament';
    this.router = Router();
    this.initializeRoutes();
    this.services = DepartamentsServices.getInstance()
  }
  getPath(): string {
    return this.path;
  }
  getRouter(): Router {
    return this.router;
  }

  public static getInstance(): DepartamentController {
    if (!DepartamentController._instance) {
      DepartamentController._instance = new DepartamentController();
    }

    return DepartamentController._instance;
  }

  private initializeRoutes() {
    this.router.post(`${this.path}/create`, this.createDepartament);
  }

  private createDepartament = async (
    request: Request,
    response: Response,
    next: NextFunction,
  ) => {
    const dtos = new CreateDepDTO();
    console.log(dtos)
  };
}

服务：

@Service()
export default class DepartamentsServices implements IServices {

  private static instance: DepartamentsServices;
  private departamentRepository: Repository<Departament>;
  private readonly employeeServices: EmployeesServices;
  private constructor() {
    this.employeeServices = EmployeesServices.getInstance();
    this.departamentRepository = getConnection().getRepository(Departament);
  }

  public static getInstance(): DepartamentsServices {
    if (!DepartamentsServices.instance) {
      DepartamentsServices.instance = new DepartamentsServices();
    }

    return DepartamentsServices.instance;
  }

  readAll(): Promise<Departament> {
    throw new Error("Method not implemented.");
  }
  readOneById(id: string): Promise<Departament | undefined> {
    throw new Error("Method not implemented.");
  }
  async create(data: CreateDTO): Promise<Departament | string> {
    //verify if exists departament on database
    const hasDepartament = await this.departamentRepository.findOne({
      departament_name: data.departament_name,
    });
    if (hasDepartament) {
      return `O departamento ${data.departament_name} já existe`;
    }
    //verify if exists manager of departament on table employee.
    if (data.manager.id) {
      let manager = this.employeeServices.findOneEmployee(data.manager.id);
      if (!manager) {
        return `O funcionario para gerenciar o departament ${data.departament_name} não existe`
      }
    }
    //creating departament
    const newDepartament = this.departamentRepository.create({
      manager_id: data.manager.id,
      departament_name: data.departament_name
    });
    const departament = await this.departamentRepository.save(newDepartament);
    return departament;
  }

}