介绍

mongo-context是团队根据自身产品定位定制的一个操作mongodb的插件模块，提供支持连接多个数据库、数据模型基类（SuperModel）、自动收集数据模型（@TypegooseModel装饰器）

连接数据库

一般来说,连接数据库是在生命周期中服务启动时要做的。为了满足服务端可以连接多个数据库，所以就没有做自动连接数据库的功能，而是手动在服务启动的时候提供多个数据库连接配置，连接数据库

  1. ## 安装mongo-context模块,因为typegoose的原因,mongoose最高支持5.10.18
  2. npm install @lzy-plugin/mongo-context @typegoose/typegoose mongoose@5.10.18
  1. //src/configuration.ts
  2. import { IMongoConfig, MongoContext } from '@lzy-plugin/mongo-context';
  3. import * as mongoContext from '@lzy-plugin/mongo-context';
  4. @Configuration({
  5.   imports: [mongoContext], // 不可缺少,需要引入mongo-context模块中所有实例对象
  6.   importConfigs: [join(__dirname, 'config')]
  7. })
  8. export class AutoConfiguration {
  9.   async onReady(container: IMidwayContainer) {
  10.     const array = new Array<IMongoConfig>();
  11.     array.push({
  12.       key: 'admin',
  13.       user: 'lzy',
  14.       pass: 'lzy123456',
  15.       host: '',
  16.       port: '',
  17.       replicaSet: {
  18.         name: 'mgset-17098013',
  19.         members: [
  20.           {
  21.             host: '127.0.0.1',
  22.             port: 3717
  23.           },
  24.           {
  25.             host: '127.0.0.1',
  26.             port: 3717
  27.           }
  28.         ]
  29.       },
  30.       db: 'test-admin'
  31.         })
  33.     array.push({
  34.       key: 'one',
  35.       user: 'lzy',
  36.       pass: 'lzy123456',
  37.       host: '',
  38.       port: '',
  39.       replicaSet: {
  40.         name: 'mgset-17098013',
  41.         members: [
  42.           {
  43.             host: '127.0.0.1',
  44.             port: 3717
  45.           },
  46.           {
  47.             host: '127.0.0.1',
  48.             port: 3717
  49.           }
  50.         ]
  51.       },
  52.       db: 'test-one'
  53.         })
  55.     for(const item of array){
  56.         const connection = await MongoContext.createConnection(item);
  57.       connection.on('connected', () => {
  58.           console.log(`${item.key}数据库连接成功!`)
  59.          });
  60.     }
  61.   }
  62. }

定义Model

  1. // src/models/user.ts
  2. import { prop } from '@typegoose/typegoose';
  3. import { SuperModel, TypegooseModel } from '@lzy-plugin/mongo-context';
  4. import { Expose } from 'class-transformer';
  5. @TypegooseModel({modelName:'User',collectionName:'users'}) //不可缺少,声明为数据模型,入参可以定义模型名称和表名
  6. export class UserModel extends SuperModel {//不可缺少,必须继承SuperModel
  7.   @prop() //不可缺少,声明为数据模型中的列
  8.   @Expose()
  9.   username: string;
  10.   @prop()
  11.   @Expose()
  12.   password: string;
  13. }

CRUD示例

  1. // src/service/test.ts
  2. // 获取mongoContxt示例
  3. import { Init, Inject, Provide, Scope, ScopeEnum } from '@midwayjs/decorator';
  4. import { MongoContext, MongoManager } from '@lzy-plugin/mongo-context';
  5. import { UserModel } from '../models/user';
  7. @Provide()
  8. @Scope(ScopeEnum.Singleton)
  9. export class TestService {
  10.   @Inject()
  11.   mongoManager: MongoManager;
  12.   context: MongoContext;
  14.   @Init()
  15.   async init(): Promise<void> {
  16.     this.context = await this.mongoManager.getContext('admin'); 获取admin数据库连接实例对象下的mongo上下文
  17.   }
  19.   //新增用户
  20.   async createUser(username: string, password: string): Promise<void> {
  21.     const user = new UserModel();
  22.     user.password = password;
  23.     user.username = username;
  24.     await this.context.switchModel(UserModel).save(user); //支持传递Model类
  25.     // await this.context.switchModel('User').save(user); //支持传递ModelName
  26.     console.log('新增用户成功');
  27.   }
  29.   //修改用户
  30.   async editUser(_id:string,username: string, password: string): Promise<void> {
  31.     const user = await this.context.findById(_id);
  32.     user.password = password;
  33.     user.username = username;
  34.     await this.context.switchModel(UserModel).save(user);
  35.     console.log('新增用户成功');
  36.   }
  38.   //批量查询用户
  39.   async listUser(): Promise<void> {
  40.     const result = await this.context.switchModel(UserModel).find({});
  41.     console.log(result);
  42.   }
  44.   //查询单个用户
  45.   async listUser(): Promise<void> {
  46.     const result = await this.context.switchModel(UserModel).findOne({});
  47.     console.log(result);
  48.   }
  50.   //移除指定用户
  51.   async removeUser(_id:string): Promise<void> {
  52.     const result = await this.context.switchModel(UserModel).remove({_id:_id});
  53.     console.log(result);
  54.   }
  55. }

数据关联&&自动填充

  1. // src/models/cart-item.ts
  2. import { prop } from '@typegoose/typegoose';
  3. import { SuperModel, TypegooseModel } from '@lzy-plugin/mongo-context';
  4. import { Expose } from 'class-transformer';
  5. @TypegooseModel({modelName:'CartItem',collectionName:'cart-item'})
  6. export class CartItem extends SuperModel {
  7.   @prop() //不可缺少,声明为数据模型中的列
  8.   @Expose()
  9.   goodsName: string;
  10.   @prop()
  11.   @Expose()
  12.   price: number;
  13.     @prop()
  14.   @Expose()
  15.   count: number;
  17.   constructor(goodsName:string,price:number,count:number){
  18.       this.goodsName = goodsName;
  19.     this.price = price;
  20.     this.count = count;
  21.   }
  22. }
  24. // src/models/cart.ts
  25. import { prop } from '@typegoose/typegoose';
  26. import { SuperModel, TypegooseModel } from '@lzy-plugin/mongo-context';
  27. import { Expose } from 'class-transformer';
  28. import { CartItem } from './cart-item';
  29. @TypegooseModel({modelName:'CartItem',collectionName:'cart-item'})
  30. export class Cart extends SuperModel {
  31.   @prop() //不可缺少,声明为数据模型中的列
  32.   @Expose()
  33.   userId: string;
  35.   @prop({ autopopulate: true,ref: 'CartItem' })
  36.   @Expose()
  37.   @Type(() => CartItem)
  38.   public items?: Ref<CartItem>[];
  39. }
  41. // src/service/test.ts
  42. // src/service/test.ts
  43. // 获取mongoContxt示例
  44. import { Init, Inject, Provide, Scope, ScopeEnum } from '@midwayjs/decorator';
  45. import { MongoContext, MongoManager } from '@lzy-plugin/mongo-context';
  46. import { Cart } from '../models/cart';
  47. import { CartItem } from '../models/cart-item';
  49. @Provide()
  50. @Scope(ScopeEnum.Singleton)
  51. export class TestService {
  52.   @Inject()
  53.   mongoManager: MongoManager;
  54.   context: MongoContext;
  56.   @Init()
  57.   async init(): Promise<void> {
  58.     this.context = await this.mongoManager.getContext('admin'); 获取admin数据库连接实例对象下的mongo上下文
  59.   }
  61.   async addCartItem(){
  62.       const cart = new Cart();
  63.     cart.userId = '1234';
  64.     cart.items = new Array<CartItem>();
  65.        cart.items.push(new CartItem('可口可乐',3,1));
  66.     cart.items.push(new CartItem('百事可乐',3,10));
  67.        await this.context.switchModel(Cart).save(cart);
  68.     for(const item of cart.items){
  69.         await this.context.switchModel(CartItem).save(item)
  70.     }
  71.     //cart数据的items只保存CartItem数据的_id;
  72.   }
  74.   async getCart(){
  75.       const result = await this.context.findOne({});
  76.     console.log(result);
  77.     //result.items 自动根据_id查询cart-item表的数据,填充到其中
  78.   }
  79. }

事务处理

以上更新中存在多条执行写入语句，如果有一条写入失败，整个操作都得回滚。
mongodb 4.0以上的版本提供了多文档的事务,那我们来看封装mongo-context模块如何处理事务

  1. async addCartItem(){
  2.     const db: Connection = MongoContext.getConnection('admin');
  3.     if (!db) {
  4.       throw new Error('获取数据库连接对象失败');
  5.     }
  6.     const session = await db.startSession();
  7.       session.startTransaction();
  8.       try{
  9.       const cart = new Cart();
  10.       cart.userId = '1234';
  11.       cart.items = new Array<CartItem>();
  12.       cart.items.push(new CartItem('可口可乐',3,1));
  13.       cart.items.push(new CartItem('百事可乐',3,10));
  14.       await this.context.switchModel(Cart).save(cart,{session});
  15.       for(const item of cart.items){
  16.         await this.context.switchModel(CartItem).save(item,{session})
  17.       }
  18.       await session.commitTransaction();
  19.     }catch(e){
  20.       await session.abortTransaction();
  21.     }finally{
  22.       session.endSession();
  23.     }
  24. }