Typescript 如何使用inversify注射knex？

如何初始化knex并使用Inversify dependency injector将其注入

---

每一个我需要的地方？

我从未使用过

Knex

，但我是InversifyJS的作者，我会尽力帮助你

根据

Knex

可以执行以下操作：

var knex = require('knex')({
  client: 'mysql',
  connection: {
    host : '127.0.0.1',
    user : 'your_database_user',
    password : 'your_database_password',
    database : 'myapp_test'
  }
});

import * as Knex from 'knex';
import { Kernel } from "inversify";

// configuration
let configuration: Knex.Config = {
  client: 'mysql',
  connection: {
    host : '127.0.0.1',
    user : 'your_database_user',
    password : 'your_database_password',
    database : 'myapp_test'
  }
};

// instance
let knex: Knex = Knex(configuration);

let kernel = new Kernel();
kernel.bind<Knex>("Knex").toConstantValue(knex);

我还找到了TS的类型

我假设您想要注入的是

knex

实例。您可以执行以下操作：

var knex = require('knex')({
  client: 'mysql',
  connection: {
    host : '127.0.0.1',
    user : 'your_database_user',
    password : 'your_database_password',
    database : 'myapp_test'
  }
});

import * as Knex from 'knex';
import { Kernel } from "inversify";

// configuration
let configuration: Knex.Config = {
  client: 'mysql',
  connection: {
    host : '127.0.0.1',
    user : 'your_database_user',
    password : 'your_database_password',
    database : 'myapp_test'
  }
};

// instance
let knex: Knex = Knex(configuration);

let kernel = new Kernel();
kernel.bind<Knex>("Knex").toConstantValue(knex);

从“Knex”导入*作为Knex；
从“inversify”导入{Kernel}；
//配置
let配置：Knex.Config={
客户端：“mysql”，
连接：{
主持人：“127.0.0.1”，
用户：“您的数据库用户”，
密码：“您的数据库密码”，
数据库：“myapp_测试”
}
};
//实例
设knex:knex=knex（配置）；
让kernel=newkernel（）；
kernel.bind（“Knex”）.toConstantValue（Knex）；

这样，knex就成了单身汉。如果你不想成为单身汉，你需要一个工厂：

 import * as Knex from 'knex';
 import { interfaces, Kernel } from "inversify";

 kernel.bind<interfaces.Factory<Knex>>("Factory<Knex>")
       .toFactory((ctx: interfaces.Context) => {
           return Knex({
               client: 'mysql',
               connection: {
                   host : '127.0.0.1',
                   user : 'your_database_user',
                   password : 'your_database_password',
                   database : 'myapp_test'
               }
           });
       });

let knexFactory = kernel.get<interfaces.Factory<Knex>>("Factory<Knex>");
let knex = knexFactory();

let knex = kernel.get<Knex>("Knex>");

从“Knex”导入*作为Knex；
从“inversify”导入{接口，内核}；
kernel.bind（“工厂”）
.toFactory（（ctx:interfaces.Context）=>{
回程揉捏({
客户端：“mysql”，
连接：{
主持人：“127.0.0.1”，
用户：“您的数据库用户”，
密码：“您的数据库密码”，
数据库：“myapp_测试”
}
});
});

您还可以分离配置：

 import * as Knex from 'knex';
 import { interfaces, Kernel } from "inversify";

 kernel.bind<Knex.Config>("KnexConfig").toConstantValue({
     client: 'mysql',
     connection: {
         host : '127.0.0.1',
         user : 'your_database_user',
         password : 'your_database_password',
         database : 'myapp_test'
     }
 });

 kernel.bind<interfaces.Factory<Knex>>("Factory<Knex>")
       .toFactory((ctx: interfaces.Context) => {
           let config = context.kernel.get<Knex.Config>("KnexConfig");
           return Knex(config);
       });

从“Knex”导入*作为Knex；
从“inversify”导入{接口，内核}；
kernel.bind（“KnexConfig”）.toConstantValue({
客户端：“mysql”，
连接：{
主持人：“127.0.0.1”，
用户：“您的数据库用户”，
密码：“您的数据库密码”，
数据库：“myapp_测试”
}
});
kernel.bind（“工厂”）
.toFactory（（ctx:interfaces.Context）=>{
让config=context.kernel.get（“KnexConfig”）；
返回Knex（配置）；
});

这些解决方案为您提供了一个工厂：

 import * as Knex from 'knex';
 import { interfaces, Kernel } from "inversify";

 kernel.bind<interfaces.Factory<Knex>>("Factory<Knex>")
       .toFactory((ctx: interfaces.Context) => {
           return Knex({
               client: 'mysql',
               connection: {
                   host : '127.0.0.1',
                   user : 'your_database_user',
                   password : 'your_database_password',
                   database : 'myapp_test'
               }
           });
       });

let knexFactory = kernel.get<interfaces.Factory<Knex>>("Factory<Knex>");
let knex = knexFactory();

let knex = kernel.get<Knex>("Knex>");

让knexFactory=kernel.get（“工厂”）；
设knex=knexFactory（）；

工厂可以使用

@inject（“工厂”）

注释注入到其他类中

如果您不想使用单例，也不想使用工厂，则需要动态价值注入：

kernel.bind<Knex>("Knex").toDynamicValue((context: interfaces.Context) => {
    return Knex({
        client: 'mysql',
        connection: {
            host : '127.0.0.1',
            user : 'your_database_user',
            password : 'your_database_password',
            database : 'myapp_test'
        }
    });
});

kernel.bind（“Knex”）.toDynamicValue（（上下文：interfaces.context）=>{
回程揉捏({
客户端：“mysql”，
连接：{
主持人：“127.0.0.1”，
用户：“您的数据库用户”，
密码：“您的数据库密码”，
数据库：“myapp_测试”
}
});
});

动态值注入将注入一个新的knex实例。不是单身汉也不是工厂：

 import * as Knex from 'knex';
 import { interfaces, Kernel } from "inversify";

 kernel.bind<interfaces.Factory<Knex>>("Factory<Knex>")
       .toFactory((ctx: interfaces.Context) => {
           return Knex({
               client: 'mysql',
               connection: {
                   host : '127.0.0.1',
                   user : 'your_database_user',
                   password : 'your_database_password',
                   database : 'myapp_test'
               }
           });
       });

let knexFactory = kernel.get<interfaces.Factory<Knex>>("Factory<Knex>");
let knex = knexFactory();

let knex = kernel.get<Knex>("Knex>");

让knex=kernel.get（“knex>”）；

---

请注意，我还没有测试这些建议。我希望他们会引导您朝正确的方向前进。

您可以创建一个类来处理一个knex实例，然后在需要时注入它。我试图按照这篇文章创建一个工厂来初始化knex，但在inverisfy中，我不知道如何将工厂绑定到它的接口singleton是正确的方法，因为knex实例将响应连接池之类的合理资源。这个答案确实是一个惊人的指南。