Implémenter l'injection de dépendances dans Remix

Il est nécessaire pour implémenter l'injection de dépendances dans Remix context. Voici un exemple simple :

Tout d'abord, créez le fichier dans le répertoire racine du projetcontext.js :

import React from 'react';

const DependenciesContext = React.createContext({
    
    });

function useDependencies() {
    
    
  return React.useContext(DependenciesContext);
}

function DependenciesProvider({
    
     dependencies, children }) {
    
    
  return (
    <DependenciesContext.Provider value={
    
    dependencies}>
      {
    
    children}
    </DependenciesContext.Provider>
  );
}

export {
    
     DependenciesProvider, useDependencies };

DependenciesContextIci, un contexte et un useDependencieshook personnalisé sont créés , ainsi qu'un DependenciesProvidercomposant nommé.

DependenciesProviderLe composant est un fournisseur de contexte, il l'utilise React.createContextpour créer un objet de contexte. Il possède également un dependenciesaccessoire appelé qui est l'objet utilisé pour transmettre toutes les dépendances.

Ensuite, dans le composant racine de votre projet (par exemple App.js), utilisezDependenciesProvider :

import React from 'react';
import {
    
     DependenciesProvider } from './context';

function App() {
    
    
  const dependencies = {
    
    
    // 将依赖项放在此处
    userService: {
    
    
      getUsers: async () => {
    
    
        const response = await fetch('https://jsonplaceholder.typicode.com/users');
        const users = await response.json();
        return users;
      },
    },
  };

  return (
    <DependenciesProvider dependencies={
    
    dependencies}>
      {
    
    /* 在此处放置你的根组件 */}
    </DependenciesProvider>
  );
}

export default App;

Ici, un objet est créé dependenciesqui contient une userServicedépendance qui définit getUsersla méthode.

DependenciesProviderLe composant enveloppe le composant racine et le transmet dependenciescomme dependenciesaccessoire. Le contexte est déjà défini et les hooks peuvent être utilisés dans les composants enfants useDependencies.

useDependenciesNous pouvons désormais utiliser des hooks dans n'importe quel composant ayant besoin d'accéder à une ou plusieurs dépendances :

import React from 'react';
import {
    
     useDependencies } from './context';

function UserList() {
    
    
  const {
    
     userService } = useDependencies();
  const [users, setUsers] = React.useState([]);

  React.useEffect(() => {
    
    
    userService.getUsers().then(setUsers);
  }, [userService]);

  return (
    <ul>
      {
    
    users.map(user => (
        <li key={
    
    user.id}>{
    
    user.name}</li>
      ))}
    </ul>
  );
}

export default UserList;

Ici, UserListle composant utilise useDependenciesun hook pour obtenir userServicela dépendance et getUsersune méthode pour obtenir la liste des utilisateurs de l'API et l'enregistrer dans l'état local. Ensuite, il affiche la liste des utilisateurs dans une liste simple.

Ce sont les bases de la mise en œuvre de l’injection de dépendances basée sur Remix.

Implémenter l'injection de dépendances dans Next.js

Next.js est un framework React qui vous permet de créer rapidement des applications React rendues par le serveur. L'injection de dépendances dans Next.js est généralement réalisée en _app.jsutilisant la méthode du fichier getInitialProps(). getInitialProps()Les dépendances peuvent être injectées puis transmises comme accessoires à n'importe quel composant.

Voici un exemple simple qui montre comment utiliser getInitialProps()la méthode d'injection de dépendances dans Next.js :

// _app.js

import React from 'react';
import App from 'next/app';
import {
    
     MyContext } from '../context';

class MyApp extends App {
    
    
    static async getInitialProps({
    
     Component, ctx }) {
    
    
        const {
    
     req } = ctx;
        const myService = new MyService(req); // 实例化一个服务
        const pageProps = Component.getInitialProps ? await Component.getInitialProps(ctx) : {
    
    };

        return {
    
     pageProps, myService }; // 注入服务作为 props
    }

    render() {
    
    
        const {
    
     Component, pageProps, myService } = this.props;

        return (
            <MyContext.Provider value={
    
    myService}>
                <Component {
    
    ...pageProps} />
            </MyContext.Provider>
        );
    }
}

export default MyApp;

Dans cet exemple, nous instancions un service et l'injectons dans getInitialProps()la valeur de retour de . Ensuite, dans _app.js, nous enveloppons le service dans un contexte et le transmettons comme accessoires à notre composant.

Ensuite, dans notre composant, nous pouvons useContext()accéder au service en utilisant un hook comme celui-ci :

// MyComponent.js

import React, {
    
     useContext } from 'react';
import {
    
     MyContext } from '../context';

function MyComponent() {
    
    
    const myService = useContext(MyContext);

    // 使用 myService 来执行业务逻辑

    return (
        // 组件的 JSX
    );
}

export default MyComponent;

Il s'agit d'un exemple simple d'injection de dépendances Next.js. Dans une application réelle, vous devrez peut-être utiliser une solution plus complexe, mais cet exemple montre comment l'utiliser getInitialProps()et le contexte pour réaliser l'injection de dépendances.

Résumé de comparaison

Remix et Next.js peuvent implémenter l'injection de dépendances, mais il existe les différences suivantes entre eux :

Les méthodes d'implémentation sont différentes : Remix utilise sa propre méthode d'injection spéciale, tandis que Next.js utilise la bibliothèque tierce awilix pour implémenter l'injection de dépendances.
Les objectifs sont différents : l'objectif principal de Remix est d'améliorer l'efficacité du développement et de réduire autant que possible le besoin de traitement manuel, tandis que l'objectif principal de Next.js est de fournir un framework simple et puissant qui permet aux développeurs de rapidement créer des applications complexes.
L'accès est différent : Remix fournit une fonction d'injection globale qui peut injecter des dépendances dans n'importe quel composant, tandis que Next.js nécessite que les dépendances soient injectées dans le constructeur de l'application.
La flexibilité est différente : Remix fournit davantage de fonctionnalités d'automatisation, telles que le partage de l'état et de la logique entre les composants, tandis que Next.js est plus flexible et peut configurer librement les dépendances selon les besoins.

En général, Remix se concentre sur la simplicité et l'automatisation, tandis que Next.js se concentre sur la flexibilité et la configurabilité. Les développeurs peuvent choisir l'une des implémentations en fonction de leurs besoins et préférences. Remix et Next.js peuvent implémenter l'injection de dépendances, mais il existe les différences suivantes entre eux :

Les méthodes d'implémentation sont différentes : Remix utilise sa propre méthode d'injection spéciale, tandis que Next.js utilise la bibliothèque tierce awilix pour implémenter l'injection de dépendances.
Les objectifs sont différents : l'objectif principal de Remix est d'améliorer l'efficacité du développement et de réduire autant que possible le besoin de traitement manuel, tandis que l'objectif principal de Next.js est de fournir un framework simple et puissant qui permet aux développeurs de rapidement créer des applications complexes.
L'accès est différent : Remix fournit une fonction d'injection globale qui peut injecter des dépendances dans n'importe quel composant, tandis que Next.js nécessite que les dépendances soient injectées dans le constructeur de l'application.
La flexibilité est différente : Remix fournit davantage de fonctionnalités d'automatisation, telles que le partage de l'état et de la logique entre les composants, tandis que Next.js est plus flexible et peut configurer librement les dépendances selon les besoins.

Injection de dépendances dans Remix et Next.js

Annuaire d'articles

Implémenter l'injection de dépendances dans Remix

Implémenter l'injection de dépendances dans Next.js

Résumé de comparaison

Je suppose que tu aimes