🎨Node.js с несколькими шаблонами проектирования

Мы используем шаблоны проектирования в Node.js, потому что они предоставляют набор проверенных решений распространенных проблем или проблем при разработке программного обеспечения.

Вот несколько причин, по которым мы используем шаблоны проектирования в Node.js:

• Повторное использование. Шаблоны проектирования позволяют нам инкапсулировать сложную логику и функциональные возможности повторно используемым и модульным способом, что может сэкономить нам время и усилия при создании приложений.
• Масштабируемость. Шаблоны проектирования обеспечивают структуру и организацию нашего кода, которые упрощают масштабирование и поддержку по мере роста и развития наших приложений.
• Удобство сопровождения. Шаблоны проектирования помогают нам писать более удобный для сопровождения код за счет разделения задач и обязанностей, уменьшения дублирования кода и обеспечения согласованности.
• Гибкость. Шаблоны проектирования позволяют нам заменять или модифицировать различные компоненты или модули в наших приложениях, не влияя на общую функциональность, что может сделать наш код более гибким и адаптируемым к изменяющимся требованиям.
• Качество кода. Шаблоны проектирования поддерживают передовые методы и принципы кодирования, такие как абстракция, инкапсуляция и разделение ответственности, которые могут привести к более высокому качеству и надежности кода.

Шаблоны проектирования могут помочь нам написать лучший код, который будет более пригодным для повторного использования, масштабируемым, удобным в сопровождении, гибким и более качественным, что в конечном итоге может привести к созданию более успешных и надежных приложений.

💡 Именно такой подход позволяет использовать Бит. Применяя компонуемый, модульный дизайн для ваших компонентов и независимое хранение, тестирование и документирование компонентов вместо целых приложений одновременно, ваше приложение лучше масштабируется и становится намного более удобным в сопровождении. Это руководство покажет вам, как это сделать.

Теперь давайте рассмотрим каждый шаблон проектирования с кодом в ситуации логики службы «Вход».

Синглтон шаблон

Мы можем использовать шаблон Singleton, чтобы убедиться, что только один экземпляр службы аутентификации создается и используется в приложении. Это может быть полезно для управления общими ресурсами, такими как секретный ключ JWT или подключение к пользовательской базе данных.

class AuthenticationService {
  constructor() {
    this.jwtSecret = 'secret'; // initialize the JWT secret key
    this.userDb = new DatabaseConnection('mongodb://localhost/users'); // initialize the user database connection
  }

  static getInstance() {
    if (!AuthenticationService.instance) {
      AuthenticationService.instance = new AuthenticationService();
    }

    return AuthenticationService.instance;
  }

  // authentication logic
  async authenticate(username, password) {
    const user = await this.userDb.findUserByUsername(username);
    if (user && user.password === password) {
      const token = jwt.sign({ username: user.username }, this.jwtSecret);
      return { token };
    } else {
      throw new Error('Invalid username or password');
    }
  }
}

// Usage:
const authService = AuthenticationService.getInstance();

В этом примере мы создаем класс Singleton с именем AuthenticationService, который управляет секретным ключом JWT и подключением к пользовательской базе данных. Метод authenticate() выполняет логику аутентификации и возвращает токен JWT, если имя пользователя и пароль верны.

Заводской узор

Мы можем использовать шаблон Factory для создания различных типов стратегий аутентификации на основе типа аутентификации. Например, мы можем создать различные стратегии для локальной аутентификации, аутентификации в социальных сетях или многофакторной аутентификации.

class AuthenticationStrategyFactory {
  static createStrategy(type) {
    if (type === 'local') {
      return new LocalAuthenticationStrategy();
    } else if (type === 'social') {
      return new SocialMediaAuthenticationStrategy();
    } else if (type === 'multi-factor') {
      return new MultiFactorAuthenticationStrategy();
    } else {
      throw new Error(`Unsupported authentication type: ${type}`);
    }
  }
}

// Usage:
const strategy = AuthenticationStrategyFactory.createStrategy('local');

В этом примере мы создаем класс Factory с именем AuthenticationStrategyFactory, который может создавать различные типы стратегий аутентификации в зависимости от типа. Мы создаем три разные стратегии, LocalAuthenticationStrategy, SocialMediaAuthenticationStrategy и MultiFactorAuthenticationStrategy, и возвращаем соответствующую стратегию в зависимости от типа.

Шаблон ПО промежуточного слоя

Мы можем использовать шаблон промежуточного программного обеспечения, чтобы определить цепочку обработчиков, которые можно использовать для модульной обработки запроса аутентификации. Это может быть полезно для реализации сред на основе промежуточного программного обеспечения, таких как Express.js.

class AuthenticationMiddleware extends Middleware {
  constructor(strategy) {
    super();
    this.strategy = strategy;
  }

  async _handle(req, res, next) {
    try {
      const result = await this.strategy.authenticate(req.body.username, req.body.password);
      req.user = result;
      next();
    } catch (error) {
      res.status(401).json({ error: error.message });
    }
  }
}

// Usage:
const strategy = AuthenticationStrategyFactory.createStrategy('local');
const middleware = new AuthenticationMiddleware(strategy);
app.post('/login', middleware.handle.bind(middleware), (req, res) => {
  res.json({ token: req.user.token });
});

В этом примере мы создаем класс промежуточного ПО с именем AuthenticationMiddleware, который обрабатывает логику проверки подлинности с использованием указанной стратегии. Метод handle() используется для обработки запроса аутентификации через цепочку ПО промежуточного слоя, а функция next() используется для передачи запроса следующему ПО промежуточного слоя в цепочке. Если аутентификация не удалась, клиенту возвращается сообщение об ошибке.

Шаблон наблюдателя

Мы можем использовать шаблон Observer для уведомления других объектов или служб, когда пользователь входит в систему или выходит из нее. Например, мы можем уведомить службу регистрации или службу аналитики, когда пользователь входит в систему или выходит из нее.

class LoginService {
  constructor() {
    this.observers = [];
  }

  addObserver(observer) {
    this.observers.push(observer);
  }

  removeObserver(observer) {
    this.observers = this.observers.filter((o) => o !== observer);
  }

  async login(username, password) {
    const authService = AuthenticationService.getInstance();
    const result = await authService.authenticate(username, password);

    // notify the observers
    this.notifyObservers({ username });

    return result;
  }

  async logout(token) {
    // revoke the token
    const authService = AuthenticationService.getInstance();
    const user = jwt.verify(token, authService.jwtSecret);
    const tokenRevoked = await this.revokeToken(user.username, token);

    // notify the observers
    this.notifyObservers({ username: user.username });

    return tokenRevoked;
  }

  notifyObservers(data) {
    this.observers.forEach((observer) => observer.update(data));
  }
}

// Usage:
const loginService = new LoginService();
loginService.addObserver(new LoggingService());
loginService.addObserver(new AnalyticsService());

В этом примере мы создаем класс LoginService, за которым могут наблюдать другие объекты или службы. Метод login() выполняет логику аутентификации и возвращает токен JWT, если имя пользователя и пароль верны. Метод logout() отзывает токен и уведомляет наблюдателей, когда пользователь выходит из системы. Методы addObserver() и removeObserver() можно использовать для управления наблюдателями, а метод notifyObservers() используется для уведомления всех наблюдателей, когда пользователь входит или выходит из системы.

Паттерн стратегии

Мы можем использовать шаблон стратегии для определения различных стратегий аутентификации для разных типов пользователей или сценариев. Например, мы можем создать разные стратегии для пользователей с правами администратора, премиум-пользователей или пользователей API.

class AdminAuthenticationStrategy extends LocalAuthenticationStrategy {
  async authenticate(username, password) {
    const user = await this.authService.userDb.findUserByUsername(username);
    if (user && user.password === password && user.role === 'admin') {
      const token = jwt.sign({ username: user.username }, this.authService.jwtSecret);
      return { token };
    } else {
      throw new Error('Invalid username or password');
    }
  }
}

class PremiumAuthenticationStrategy extends LocalAuthenticationStrategy {
  async authenticate(username, password) {
    const user = await this.authService.userDb.findUserByUsername(username);
    if (user && user.password === password && user.subscription === 'premium') {
      const token = jwt.sign({ username: user.username }, this.authService.jwtSecret);
      return { token };
    } else {
      throw new Error('Invalid username or password');
    }
  }
}

// Usage:
const authService = AuthenticationService.getInstance();
const localStrategy = new LocalAuthenticationStrategy(authService);
const adminStrategy = new AdminAuthenticationStrategy(authService);
const premiumStrategy = new PremiumAuthenticationStrategy(authService);

В этом примере мы создаем разные стратегии аутентификации для пользователей с правами администратора и премиум-пользователей, которые наследуются от LocalAuthenticationStrategy. Метод authenticate() в каждой стратегии проверяет роль или подписку пользователя перед возвратом токена JWT.

Сравнение

Синглтон шаблон

• Элементы: класс Singleton, конструктор, статический метод getInstance(), переменная общего экземпляра, закрытый конструктор.
• Цель: Убедитесь, что только один экземпляр класса создается и используется в приложении.
• Преимущества: позволяет избежать создания нескольких экземпляров одного и того же объекта, обеспечивает согласованность и централизованный контроль над общими ресурсами.

Заводской узор

• Элементы: класс фабрики, метод(ы) создания, класс(ы) продукта, логика создания продукта, абстрактный класс продукта (необязательно).
• Цель: создавать объекты, не раскрывая логику создания клиенту, обеспечивать гибкость и настройку создания объектов.
• Преимущества: Инкапсулирует процесс создания объекта, уменьшает связь между клиентским кодом и логикой создания объекта, упрощает создание экземпляра объекта.

Шаблон ПО промежуточного слоя

• Элементы: класс промежуточного программного обеспечения, метод handle(), функция next() или цепочка промежуточного программного обеспечения, объекты запроса и ответа.
• Цель: определить цепочку обработчиков, которые можно использовать для модульной обработки запросов или данных.
• Преимущества: способствует модульности и масштабируемости, уменьшает дублирование кода, упрощает реализацию сложной логики обработки, обеспечивает гибкость и настройку логики обработки.

Шаблон наблюдателя

• Элементы: класс субъекта, класс(ы) наблюдателя, методы registerObserver() и removeObserver(), метод notifyObservers(), метод update() в наблюдателях.
• Цель: определить зависимость «один ко многим» между объектами, чтобы при изменении состояния одного объекта все его зависимые объекты уведомлялись и обновлялись автоматически.
• Преимущества: способствует отделению объектов, улучшает масштабируемость и модульность, позволяет динамически компоновать объекты и поведение.

Паттерн стратегии

• Элементы: класс контекста, интерфейс или класс стратегии, конкретные классы стратегии, методы setStrategy() и executeStrategy().
• Цель: определить семейство алгоритмов, инкапсулировать каждый из них и сделать их взаимозаменяемыми в зависимости от контекста или среды.
• Преимущества: инкапсулирует алгоритм или логику поведения, обеспечивает гибкость и настройку поведения, упрощает обслуживание и тестирование кода.

Заключение

Каждый шаблон проектирования имеет свой уникальный набор элементов, целей и преимуществ. Понимая и применяя эти шаблоны, мы можем улучшить качество, масштабируемость, ремонтопригодность и гибкость их кода и, в конечном счете, создавать более успешные и надежные приложения.

Создавайте приложения с повторно используемыми компонентами, как Lego

Инструмент с открытым исходным кодом Bit помогает более чем 250 000 разработчиков создавать приложения с компонентами.

Превратите любой пользовательский интерфейс, функцию или страницу в компонент многократного использования — и поделитесь им со своими приложениями. Легче сотрудничать и строить быстрее.

→ Подробнее

Разделите приложения на компоненты, чтобы упростить разработку приложений, и наслаждайтесь наилучшими возможностями для рабочих процессов, которые вы хотите:

→ Микро-интерфейсы

→ Система дизайна

→ Совместное использование кода и повторное использование

→ Монорепо

Узнать больше