NodeJS中Repository模式实现遭遇循环引用问题求助

一、先搞定你遇到的TypeError问题 #

你碰到的TypeError: personRepository.getById is not a function，核心原因是模块循环引用导致的加载顺序bug：

1. Node.js加载personRepository.js时，会先去加载./person模块；
2. 加载person.js时，又会反向加载./personRepository——但此时personRepository还没完成实例化（它还在等Person模块加载完）；
3. 所以在Person.init里拿到的personRepository是个未完全初始化的空对象，自然找不到getById方法。

两种可行的修复方案 #

方案1：调整模块导出方式，避免加载阶段创建实例

把personRepository.js的导出从实例改为类，在需要的地方再手动实例化：

// personRepository.js
const PersonModel = require('./model');
const Person = require('./person');

class PersonRepository {
  constructor() {
    this._persons = new Set();
  }
  // 你的getAll、getById等原有方法
}

// 导出类而非实例
module.exports = PersonRepository;

然后在person.js里延迟加载Repository，避开循环引用的时机：

// person.js
const PersonModel = require('./model');

class Person {
  constructor(personId, first, last, email, birthday) {
    // 原有构造逻辑不变
    this._id = personId ? personId : undefined;
    this._firstName = first ? first : undefined;
    this._lastName = last ? last : undefined;
    this._email = email ? email : undefined;
    this._birthday = birthday ? new Date(birthday) : undefined;
    this._relations = new Map();
  }

  init() {
    // 延迟加载，等模块都初始化完成再获取Repository实例
    const PersonRepository = require('./personRepository');
    const personRepository = new PersonRepository();
    personRepository.getById(this._id)
      .then(console.log)
      .catch(console.error);
  }
}

module.exports = Person;

测试文件里也要同步改为实例化Repository：

// tests.js
const PersonRepository = require('./personRepository');
const Person = require('./person');

const personRepository = new PersonRepository();

console.log("--- GET ALL : results--- ");
personRepository.getAll( (persons) => {
  // 原有测试逻辑不变
});

方案2：彻底解开耦合（更推荐）

你的getAll方法里直接把数据库Model转换成Person实例，这让Repository和Domain Model耦合太紧了。可以把转换逻辑移到Person类的静态方法里：

// person.js
class Person {
  // 原有构造和方法不变

  // 新增静态方法：从数据库Model创建Person实例
  static fromModel(modelInstance) {
    return new Person(
      modelInstance._id.toString(),
      modelInstance.firstName,
      modelInstance.lastName,
      modelInstance.email,
      modelInstance.birthday
    );
  }
}

然后修改personRepository.js，不再直接依赖Person类：

// personRepository.js
const PersonModel = require('./model');

class PersonRepository {
  constructor() {
    this._persons = new Set();
  }

  getAll(cb) {
    PersonModel.find({}, 'firstName lastName', (err, people) => {
      if (err) {
        console.error(err);
      }
      // 只返回数据库原始Model，转换逻辑交给外部
      this._persons = new Set(people);
      if (cb) cb(this._persons);
    });
  }
  // 其他方法不变
}

module.exports = new PersonRepository();

测试时再手动转换为Person实例：

// tests.js
personRepository.getAll( (personModels) => {
  for (let model of personModels) {
    let person = Person.fromModel(model);
    person.init()
      .then(() => { console.log(person); })
      .catch((e) => { console.log(e); });
  }
});

这种方式彻底消除了循环引用，同时更符合Repository模式的单一职责——Repository只负责数据持久化，Domain Model负责自身的实例化和业务逻辑。

二、关于你的Repository模式设计评价 #

整体思路是对的，但有几个可以优化的点：

• 统一异步操作风格：getAll用回调，getById用Promise，建议统一成Promise风格，避免回调地狱：

  getAll() {
    return PersonModel.find({}, 'firstName lastName')
      .then(people => new Set(people))
      .catch(err => {
        console.error(err);
        throw err;
      });
  }
  

• 移除内存中的数据集合：this._persons这个Set完全没必要，每次查询都应该从数据库获取最新数据，内存集合容易导致数据不一致。
• Model避免直接依赖Repository：Person.init直接调用Repository的方法，会让Model和Repository耦合。更好的做法是加一层Service层，由Service处理数据加载逻辑，Model只负责自身的业务状态和行为。

比如新增一个PersonService：

// personService.js
const personRepository = require('./personRepository');
const Person = require('./person');

class PersonService {
  async getPersonById(id) {
    const model = await personRepository.getById(id);
    const person = Person.fromModel(model);
    // 这里处理加载关联关系等逻辑
    person._relations = await this.loadRelations(id);
    return person;
  }

  async loadRelations(personId) {
    // 从数据库加载关联数据的逻辑
  }
}

这样Model就不需要知道Repository的存在，职责划分更清晰。

内容的提问来源于stack exchange，提问作者b_it_s