Jotaiを使ったReactフォームの効率的な状態管理方法を徹底解説

Reactを使用して複雑なフォームを構築する際、状態管理は開発の中心的な課題の一つです。フォームの入力値、バリデーション、エラー状態、非同期処理など、管理すべき要素が多岐にわたるため、コードが煩雑になりがちです。そんな課題を解決するために、軽量かつ柔軟な状態管理ライブラリであるJotaiを活用する方法があります。本記事では、Jotaiの基本的な使い方から始め、複雑なフォームを効率的に管理する具体的な方法までをわかりやすく解説していきます。

Jotaiとは何か
1. Jotaiの基本コンセプト
2. 他の状態管理ライブラリとの違い
フォーム状態管理の課題
Jotaiを使ったフォーム状態管理の基本設定
非同期処理を伴うフォーム状態管理
Jotaiのファミリーアトムを活用した状態分割
エラー処理とバリデーションの実装方法
大規模フォームへの応用と最適化
Jotaiと他ライブラリの連携例
まとめ

Jotaiとは何か

Jotaiは、React用の軽量な状態管理ライブラリです。その名前は日本語の「単一の（独立した）粒子」を意味する「素粒子」から取られています。このライブラリは、「アトム」と呼ばれる単一の状態単位を活用して、状態を明確かつ柔軟に管理できる点が特徴です。

Jotaiの基本コンセプト

Jotaiでは、状態をシンプルなアトムとして定義し、それをコンポーネントで直接使用できます。これにより、グローバルな状態管理に伴う煩雑さを軽減しつつ、ローカルな状態管理のような直感的な操作が可能です。

他の状態管理ライブラリとの違い

Jotaiは、ReduxやMobXなどの重量級ライブラリと比べて以下のような利点があります：

簡潔さ：状態管理が簡単で、学習コストが低い。
軽量性：ライブラリ自体が非常に軽量で、高速な動作を実現。
コンポーザビリティ：アトムを組み合わせて複雑な状態を構築可能。

一方、Reactの標準機能であるContextやuseStateとも比較されますが、Jotaiは状態の再利用性と構造化に優れているため、大規模なアプリケーション開発でも有利です。

Jotaiは、その直感的な設計と柔軟性から、多くのReact開発者に支持される状態管理ライブラリとして注目されています。

フォーム状態管理の課題

Reactでフォームを管理する際、状態管理にはいくつかの典型的な課題が伴います。これらの課題を理解し、それを解決する手法を採用することで、効率的なフォーム構築が可能となります。

課題1: 状態の煩雑化

フォームの状態には、入力値、バリデーション結果、エラー状態、送信状況など多くの要素が含まれます。これらを一つのコンポーネントで管理すると、コードが肥大化し、可読性が低下します。

課題2: パフォーマンスの低下

フォーム全体で状態を一元管理すると、小さな変更でもフォーム全体の再レンダリングが発生し、アプリケーションのパフォーマンスに悪影響を与える可能性があります。

課題3: 非同期処理の管理

APIとの連携が必要なフォームでは、送信ボタンの状態制御や非同期リクエスト中のフィードバック提供など、状態の管理がさらに複雑になります。

課題4: バリデーションとエラー処理

入力値の妥当性をチェックし、ユーザーに適切なエラーを表示するための仕組みを設計するのは、特に複雑なフォームでは困難です。

課題5: スケーラビリティの確保

フォームのフィールド数が増加すると、状態管理が煩雑になり、再利用可能なコード設計が求められます。

課題へのアプローチ

これらの課題を解決するために、Jotaiのような柔軟で効率的な状態管理ライブラリを導入することで、フォームの管理をシンプルかつ直感的に行うことができます。本記事では、この課題をJotaiを用いてどのように解決するかを具体的に解説していきます。

Jotaiを使ったフォーム状態管理の基本設定

Jotaiを用いると、Reactのフォーム状態を簡潔かつ効率的に管理できます。このセクションでは、基本的な設定手順を具体的なコード例とともに解説します。

1. Jotaiのインストール

まず、Jotaiをプロジェクトに追加します。以下のコマンドを実行してください：

npm install jotai

2. アトム（Atom）の定義

Jotaiでは、アトムを使ってフォームの状態を定義します。以下の例では、名前入力フォーム用の状態を作成します。

import { atom } from 'jotai';

const nameAtom = atom('');
const emailAtom = atom('');

3. アトムの利用

定義したアトムをReactコンポーネントで利用します。useAtomフックを使って状態を取得・更新できます。

import React from 'react';
import { useAtom } from 'jotai';
import { nameAtom, emailAtom } from './atoms';

const Form = () => {
  const [name, setName] = useAtom(nameAtom);
  const [email, setEmail] = useAtom(emailAtom);

  return (
    <form>
      <div>
        <label>Name:</label>
        <input 
          type="text" 
          value={name} 
          onChange={(e) => setName(e.target.value)} 
        />
      </div>
      <div>
        <label>Email:</label>
        <input 
          type="email" 
          value={email} 
          onChange={(e) => setEmail(e.target.value)} 
        />
      </div>
    </form>
  );
};

export default Form;

4. 状態の分離による再レンダリングの最適化

Jotaiの特長として、アトムごとに状態を分離管理するため、特定の状態が変更された際に関連するコンポーネントのみが再レンダリングされます。これにより、フォーム全体のパフォーマンスを向上させることが可能です。

5. フォームの初期値設定

アトムには初期値を設定できます。これにより、デフォルト値を用いたフォームの作成も簡単です。

const nameAtom = atom('John Doe');

以上の手順で、Jotaiを用いたフォーム状態管理の基本的なセットアップが完了します。このシンプルさがJotaiの大きな魅力です。次のセクションでは、非同期処理を伴うフォーム管理についてさらに詳しく掘り下げます。

非同期処理を伴うフォーム状態管理

フォーム管理では、サーバーとの通信や非同期データ処理が必要となる場面が多々あります。Jotaiを使用すると、非同期処理を効率的に扱えるため、状態管理の複雑さを軽減できます。このセクションでは、APIリクエストや非同期処理を含むフォームの構築方法を解説します。

1. 非同期アトムの作成

Jotaiには非同期データを管理するためのアトム（atomWithAsyncなど）を作成する仕組みがあります。以下はAPIからデータを取得するアトムの例です：

import { atom } from 'jotai';

const submitFormAtom = atom(null);

const apiCallAtom = atom(async (get) => {
  const formData = get(submitFormAtom);
  const response = await fetch('/api/submit', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(formData),
  });
  return response.json();
});

2. 非同期アトムの活用

非同期アトムを利用して、フォームデータを送信します。この際、フォーム送信中の状態やエラー処理を管理することが重要です。

import React, { useState } from 'react';
import { useAtom } from 'jotai';
import { submitFormAtom, apiCallAtom } from './atoms';

const AsyncForm = () => {
  const [formData, setFormData] = useAtom(submitFormAtom);
  const [apiResponse, setApiResponse] = useAtom(apiCallAtom);
  const [isSubmitting, setIsSubmitting] = useState(false);

  const handleSubmit = async (e) => {
    e.preventDefault();
    setIsSubmitting(true);
    try {
      const response = await setApiResponse(formData);
      console.log('Form submitted successfully:', response);
    } catch (error) {
      console.error('Error submitting form:', error);
    } finally {
      setIsSubmitting(false);
    }
  };

  return (
    <form onSubmit={handleSubmit}>
      <div>
        <label>Name:</label>
        <input
          type="text"
          onChange={(e) =>
            setFormData((prev) => ({ ...prev, name: e.target.value }))
          }
        />
      </div>
      <div>
        <label>Email:</label>
        <input
          type="email"
          onChange={(e) =>
            setFormData((prev) => ({ ...prev, email: e.target.value }))
          }
        />
      </div>
      <button type="submit" disabled={isSubmitting}>
        {isSubmitting ? 'Submitting...' : 'Submit'}
      </button>
    </form>
  );
};

export default AsyncForm;

3. 状態の可視化とエラーハンドリング

非同期処理では、現在の処理状況をユーザーにわかりやすく伝えることが重要です。また、エラーが発生した場合には、適切なメッセージを表示する仕組みを導入します。

if (isSubmitting) {
  return <p>Submitting your data...</p>;
}

if (apiResponse?.error) {
  return <p>Error: {apiResponse.error}</p>;
}

4. 非同期処理を分離するメリット

Jotaiでは、非同期処理をアトムに分離することで、UIとロジックを明確に分けることができます。これにより、コードの再利用性が向上し、メンテナンスが容易になります。

5. 拡張性のある設計

非同期アトムを使うことで、複数の非同期処理を効率的に管理することが可能です。たとえば、フォーム送信後に追加のデータ取得を行う場合も容易に対応できます。

以上の方法を利用すれば、Jotaiを用いた非同期処理を伴うフォーム管理を効率的に行うことができます。次のセクションでは、Jotaiのファミリーアトムを活用して状態を分割する方法について解説します。

Jotaiのファミリーアトムを活用した状態分割

Jotaiでは、複数のアトムを活用して状態を細かく分割し、それぞれの役割を持たせることで効率的な状態管理が可能です。このセクションでは、フォーム状態の分割方法と、その利点について解説します。

1. ファミリーアトムの概念

ファミリーアトムとは、同じ形式のデータを複数のインスタンスで管理するために使用する手法です。特に、複数の入力フィールドを持つフォームでは、各フィールドの状態を個別に管理することで、再レンダリングの最小化やコードの整理が可能になります。

2. 動的に生成されるアトム

フォームの各フィールドに対して、動的にアトムを生成します。以下の例では、フィールドのIDをキーとしてアトムを管理します：

import { atom } from 'jotai';

const formFieldAtomFamily = (fieldId) =>
  atom({ value: '', error: null });

const fieldIdsAtom = atom(['name', 'email']);

3. フィールドごとの状態管理

動的に生成されるアトムを利用して、個別のフィールドの状態を管理します。

import React from 'react';
import { useAtom } from 'jotai';
import { formFieldAtomFamily, fieldIdsAtom } from './atoms';

const Field = ({ fieldId }) => {
  const [field, setField] = useAtom(formFieldAtomFamily(fieldId));

  return (
    <div>
      <label>{fieldId}:</label>
      <input
        type="text"
        value={field.value}
        onChange={(e) =>
          setField((prev) => ({ ...prev, value: e.target.value }))
        }
      />
      {field.error && <p style={{ color: 'red' }}>{field.error}</p>}
    </div>
  );
};

const Form = () => {
  const [fieldIds] = useAtom(fieldIdsAtom);

  return (
    <form>
      {fieldIds.map((fieldId) => (
        <Field key={fieldId} fieldId={fieldId} />
      ))}
    </form>
  );
};

export default Form;

4. 状態分割の利点

再レンダリングの最小化：各フィールドが独立しているため、一部の状態変更が他のフィールドに影響を与えません。
コードのモジュール化：フィールドごとに状態を分離することで、コードが整理され、再利用性が向上します。
柔軟性の向上：新しいフィールドを動的に追加する場合にも、既存の構造を変更せずに対応可能です。

5. 応用例: 動的フィールドの追加

ユーザーの操作によってフィールドを追加できるフォームを作成する場合も、この仕組みを利用できます。

const addFieldAtom = atom((get, set) => {
  const currentFields = get(fieldIdsAtom);
  const newFieldId = `field${currentFields.length + 1}`;
  set(fieldIdsAtom, [...currentFields, newFieldId]);
});

以上のように、Jotaiのファミリーアトムを活用することで、フォームの各フィールドの状態を柔軟に分割管理でき、スケーラブルな設計が可能となります。次のセクションでは、エラー処理とバリデーションの実装方法について説明します。

エラー処理とバリデーションの実装方法

フォーム管理において、ユーザーの入力値を検証し、適切なエラーメッセージを表示することは重要です。Jotaiを使用すれば、状態を効率的に管理しつつ、バリデーションロジックを簡潔に実装できます。このセクションでは、エラー処理とバリデーションのベストプラクティスを解説します。

1. バリデーション用アトムの作成

各フィールドのエラー状態を管理するためのアトムを作成します。以下の例では、エラーメッセージを管理するための仕組みを導入します。

import { atom } from 'jotai';

const formFieldAtomFamily = (fieldId) =>
  atom({ value: '', error: null });

const validateFieldAtom = (fieldId, validator) =>
  atom(
    (get) => {
      const field = get(formFieldAtomFamily(fieldId));
      return validator(field.value);
    },
    (get, set) => {
      const field = get(formFieldAtomFamily(fieldId));
      const error = validator(field.value);
      set(formFieldAtomFamily(fieldId), { ...field, error });
    }
  );

2. バリデーションロジックの実装

各フィールドに対して、必要なバリデーション関数を用意します。たとえば、名前とメールアドレスの簡単な検証を行います。

const nameValidator = (value) =>
  value.trim() === '' ? '名前を入力してください' : null;

const emailValidator = (value) =>
  /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value) ? null : '有効なメールアドレスを入力してください';

3. フォームコンポーネントでの使用

バリデーションロジックをフォーム内で使用します。値が変更されるたびに検証し、エラーメッセージを表示します。

import React from 'react';
import { useAtom } from 'jotai';
import { formFieldAtomFamily, validateFieldAtom } from './atoms';

const Field = ({ fieldId, validator }) => {
  const [field, setField] = useAtom(formFieldAtomFamily(fieldId));
  const [, validate] = useAtom(validateFieldAtom(fieldId, validator));

  const handleBlur = () => validate();

  return (
    <div>
      <label>{fieldId}:</label>
      <input
        type="text"
        value={field.value}
        onChange={(e) =>
          setField((prev) => ({ ...prev, value: e.target.value }))
        }
        onBlur={handleBlur}
      />
      {field.error && <p style={{ color: 'red' }}>{field.error}</p>}
    </div>
  );
};

const Form = () => (
  <form>
    <Field fieldId="name" validator={nameValidator} />
    <Field fieldId="email" validator={emailValidator} />
    <button type="submit">送信</button>
  </form>
);

export default Form;

4. フォーム全体のバリデーション

全てのフィールドを一度に検証する仕組みを追加します。送信ボタンを押した際にバリデーションを実行します。

const validateAllFields = (fieldIds) =>
  atom(
    null,
    (get, set) => {
      fieldIds.forEach((fieldId) => {
        const validator = // 対応するバリデーション関数;
        set(validateFieldAtom(fieldId, validator));
      });
    }
  );

5. エラーの集約表示

複数のエラーを集約し、フォーム全体のステータスとして表示します。エラーが存在する場合には送信をブロックします。

const hasErrorsAtom = atom((get) =>
  fieldIds.some((fieldId) => get(formFieldAtomFamily(fieldId)).error !== null)
);

6. 最適なユーザー体験のための工夫

リアルタイム検証: 入力中にフィードバックを提供して、ユーザーの手間を減らします。
インラインエラーメッセージ: フィールドごとに適切なエラーメッセージを即座に表示します。
アクセシビリティ対応: エラー状態を明確にし、スクリーンリーダーでも問題を理解できるようにします。

これらの手法を組み合わせることで、エラー処理とバリデーションを効率的に実装し、ユーザーにとってストレスの少ないフォームを構築できます。次のセクションでは、大規模フォームへの応用と最適化について解説します。

大規模フォームへの応用と最適化

複雑な業務アプリケーションや多数のフィールドを持つフォームでは、効率的でスケーラブルな状態管理が求められます。このセクションでは、Jotaiを活用して大規模フォームを最適化する方法について解説します。

1. 状態管理の分割によるスケーラビリティ

大規模フォームでは、全てのフィールドを単一のアトムで管理すると、状態の追跡や変更が難しくなります。Jotaiのファミリーアトムを活用し、フィールドごとに独立した状態を保持することで、コードの整理とパフォーマンスの向上を図ります。

const largeFormAtomFamily = (fieldId) =>
  atom({ value: '', error: null, touched: false });

これにより、各フィールドは独立した状態を持つため、一部の変更が他の部分に影響を与えません。

2. フォームセクションの分割

フィールド数が多い場合、フォームを複数のセクションに分割し、それぞれ独立したコンポーネントとして管理します。

const FormSection = ({ fieldIds }) => {
  return (
    <div>
      {fieldIds.map((fieldId) => (
        <Field key={fieldId} fieldId={fieldId} />
      ))}
    </div>
  );
};

セクションごとに状態を分離することで、再レンダリングの負荷を軽減します。

3. 動的フィールドの追加と削除

大規模フォームでは、ユーザーの操作に応じてフィールドを動的に追加・削除するケースがあります。以下のように、フィールドの動的管理が可能です。

const dynamicFieldsAtom = atom([]);

const addField = atom(null, (get, set) => {
  const fields = get(dynamicFieldsAtom);
  const newFieldId = `field${fields.length + 1}`;
  set(dynamicFieldsAtom, [...fields, newFieldId]);
});

ボタンをクリックするだけで新しいフィールドを追加できます。

<button onClick={() => set(addField)}>フィールドを追加</button>

4. バリデーションの一括管理

多数のフィールドを持つフォームでは、全フィールドのバリデーションを一括で実行する仕組みが便利です。以下のように、すべてのフィールドのエラーを確認できます。

const validateAllFieldsAtom = atom(
  null,
  (get, set) => {
    const fieldIds = get(dynamicFieldsAtom);
    fieldIds.forEach((fieldId) => {
      const validator = // 対応するバリデーション関数;
      set(validateFieldAtom(fieldId, validator));
    });
  }
);

5. データの遅延読み込み

初期データが大量にある場合、必要なセクションだけを遅延読み込みすることで、初期レンダリングの負荷を軽減できます。

const sectionVisibilityAtom = atom({ section1: true, section2: false });

const LazyLoadSection = ({ sectionId, children }) => {
  const [isVisible, setVisibility] = useAtom(sectionVisibilityAtom(sectionId));

  if (!isVisible) return null;
  return <div>{children}</div>;
};

6. パフォーマンスの最適化

大規模フォームでは、以下の方法でパフォーマンスを向上させます。

非同期処理のバッチ化: 変更を一括して処理し、レンダリング回数を減少。
メモ化されたコンポーネント: React.memoを活用して不要な再レンダリングを防止。
仮想化の利用: react-windowやreact-virtualizedを使用して、膨大な数のフィールドを効率的にレンダリング。

7. 大規模フォームの応用例

以下のようなシナリオでJotaiを活用した大規模フォームが特に役立ちます。

Eコマースのチェックアウトフォーム
多段階の登録フォーム
複雑な業務アプリケーションの入力画面

8. 実装上の注意点

大規模フォームを設計する際には以下に注意してください。

状態の分離と整理: アトムの数が多くなるため、命名規則や管理方針を明確にする。
開発ツールの活用: Jotai Devtoolsを使って、状態の可視化とデバッグを効率化。

これらのアプローチにより、大規模フォームの設計と実装を効率化し、ユーザーにとっても開発者にとってもストレスの少ないソリューションを提供できます。次のセクションでは、Jotaiと他ライブラリの連携例について解説します。

Jotaiと他ライブラリの連携例

Jotaiは軽量で柔軟な状態管理ライブラリとして、他のReactエコシステムのライブラリとも簡単に統合できます。このセクションでは、Jotaiを他のツールやライブラリと組み合わせることで、フォーム管理をさらに効率化する方法を紹介します。

1. JotaiとReact Hook Formの連携

React Hook Formは、パフォーマンスに優れたフォーム管理ライブラリです。Jotaiと組み合わせることで、状態管理の柔軟性を高められます。

import React from 'react';
import { useForm } from 'react-hook-form';
import { atom, useAtom } from 'jotai';

const formDataAtom = atom({});

const MyForm = () => {
  const { register, handleSubmit } = useForm();
  const [, setFormData] = useAtom(formDataAtom);

  const onSubmit = (data) => {
    setFormData(data);
  };

  return (
    <form onSubmit={handleSubmit(onSubmit)}>
      <input {...register('name')} placeholder="Name" />
      <input {...register('email')} placeholder="Email" />
      <button type="submit">Submit</button>
    </form>
  );
};

export default MyForm;

この方法では、React Hook Formが提供する簡潔なフォーム操作を利用しつつ、Jotaiでグローバルに状態を管理できます。

2. JotaiとFormikの統合

Formikは、フォームバリデーションを簡単に構築できるライブラリです。Jotaiを利用することで、Formikの内部状態を他のコンポーネントと共有可能です。

import React from 'react';
import { Formik, Form, Field } from 'formik';
import { atom, useAtom } from 'jotai';

const formValuesAtom = atom({});

const FormWithFormik = () => {
  const [, setFormValues] = useAtom(formValuesAtom);

  return (
    <Formik
      initialValues={{ name: '', email: '' }}
      onSubmit={(values) => setFormValues(values)}
    >
      {() => (
        <Form>
          <Field name="name" placeholder="Name" />
          <Field name="email" placeholder="Email" />
          <button type="submit">Submit</button>
        </Form>
      )}
    </Formik>
  );
};

export default FormWithFormik;

この組み合わせにより、フォームの状態を効率的に管理し、他のコンポーネントでも容易に利用できます。

3. JotaiとYupを用いたバリデーション

Yupは、スキーマベースのバリデーションライブラリです。Jotaiでフォームの状態を管理しながら、Yupを活用して強力なバリデーションロジックを構築できます。

import * as Yup from 'yup';
import { atom, useAtom } from 'jotai';

const validationSchema = Yup.object().shape({
  name: Yup.string().required('Name is required'),
  email: Yup.string().email('Invalid email').required('Email is required'),
});

const formAtom = atom({ name: '', email: '' });
const errorAtom = atom({});

const validateForm = (values) => {
  try {
    validationSchema.validateSync(values, { abortEarly: false });
    return {};
  } catch (errors) {
    return errors.inner.reduce((acc, error) => {
      acc[error.path] = error.message;
      return acc;
    }, {});
  }
};

4. JotaiとRecoilの併用

場合によっては、JotaiとRecoilを併用して異なる部分の状態管理を組み合わせることもできます。

import { useRecoilState } from 'recoil';
import { atom as recoilAtom } from 'recoil';
import { atom, useAtom } from 'jotai';

const recoilState = recoilAtom({ key: 'recoilState', default: {} });
const jotaiState = atom({});

const CombinedComponent = () => {
  const [recoilValue, setRecoilValue] = useRecoilState(recoilState);
  const [jotaiValue, setJotaiValue] = useAtom(jotaiState);

  return (
    <div>
      <input
        value={jotaiValue.name || ''}
        onChange={(e) => setJotaiValue({ ...jotaiValue, name: e.target.value })}
      />
      <input
        value={recoilValue.email || ''}
        onChange={(e) => setRecoilValue({ ...recoilValue, email: e.target.value })}
      />
    </div>
  );
};

5. Jotaiとデザインシステムの統合

例えば、Material-UIやChakra UIなどのデザインライブラリと統合して、統一されたUIを提供するフォームを作成できます。

import { TextField, Button } from '@mui/material';
import { atom, useAtom } from 'jotai';

const formFieldAtom = atom({ name: '', email: '' });

const MaterialForm = () => {
  const [formFields, setFormFields] = useAtom(formFieldAtom);

  const handleChange = (field, value) => {
    setFormFields((prev) => ({ ...prev, [field]: value }));
  };

  return (
    <form>
      <TextField
        label="Name"
        value={formFields.name}
        onChange={(e) => handleChange('name', e.target.value)}
      />
      <TextField
        label="Email"
        value={formFields.email}
        onChange={(e) => handleChange('email', e.target.value)}
      />
      <Button variant="contained" type="submit">
        Submit
      </Button>
    </form>
  );
};

export default MaterialForm;

6. 他の状態管理ライブラリとの役割分担

Jotaiを他の状態管理ライブラリ（Redux、Zustandなど）と連携し、用途に応じて役割を分担することも可能です。例えば、Jotaiでローカルなフォーム状態を管理し、Reduxでグローバルなアプリケーション状態を保持する方法があります。

これらの連携例を活用することで、Jotaiの柔軟性を最大限に引き出し、開発の効率をさらに高めることができます。次のセクションでは、本記事の内容をまとめます。

まとめ

本記事では、Jotaiを用いたReactフォームの効率的な状態管理方法について詳しく解説しました。Jotaiの基本的な使い方から始まり、複雑なフォームの状態分割や非同期処理、バリデーション、大規模フォームへの応用、そして他のライブラリとの連携例までを紹介しました。

Jotaiを活用することで、フォーム状態管理の煩雑さを大幅に軽減し、コードの可読性と再利用性を高めることができます。特に、動的に生成されるアトムや柔軟な拡張性は、規模の大小を問わず様々なプロジェクトに適しています。

適切なツールの組み合わせによって、ユーザーにとって使いやすいフォームを提供し、開発者自身もストレスの少ない開発プロセスを実現できるでしょう。ぜひ、あなたのプロジェクトにもJotaiを取り入れて、その効果を体感してみてください。