Reactjs redux中的Api状态控制，即react redux jhipster生成的代码中的挂起、成功、失败

在下面jhipster生成的代码中，如何触发操作的挂起、成功和失败？对于我们使用的每种操作类型，它都会被附加上_PENDING或_SUCCESS或_FAILURE，我不知道它发生在哪里以及如何发生。 正如我所看到的，成功和失败状态是由reducer处理的，我不知道这些操作是在何时何地触发的

例如，在下面的代码中，第一个操作的类型为action\u TYPES.FETCH\u MEDICINE\u LIST='MEDICINE/FETCH\u MEDICINE\u LIST'

实际触发的操作有：medicine/FETCH\u medicine\u LIST\u挂起、medicine/FETCH\u medicine\u LIST\u成功、medicine/FETCH\u medicine\u LIST\u失败（当medicine/FETCH\u medicine\u LIST操作触发时）。在何处以及如何触发Api状态操作

import { ICrudGetAction, ICrudGetAllAction, ICrudPutAction, ICrudDeleteAction } from 'react-jhipster';

import { cleanEntity } from 'app/shared/util/entity-utils';
import { REQUEST, SUCCESS, FAILURE } from 'app/shared/reducers/action-type.util';

import { IMedicine, defaultValue } from 'app/shared/model/medicine.model';

export const ACTION_TYPES = {
  FETCH_MEDICINE_LIST: 'medicine/FETCH_MEDICINE_LIST',
  FETCH_MEDICINE: 'medicine/FETCH_MEDICINE',
  CREATE_MEDICINE: 'medicine/CREATE_MEDICINE',
  UPDATE_MEDICINE: 'medicine/UPDATE_MEDICINE',
  DELETE_MEDICINE: 'medicine/DELETE_MEDICINE',
  RESET: 'medicine/RESET'
};

const initialState = {
  loading: false,
  errorMessage: null,
  entities: [] as ReadonlyArray<IMedicine>,
  entity: defaultValue,
  updating: false,
  updateSuccess: false
};

export type MedicineState = Readonly<typeof initialState>;

// Reducer

export default (state: MedicineState = initialState, action): MedicineState => {
  switch (action.type) {
    case REQUEST(ACTION_TYPES.FETCH_MEDICINE_LIST):
    case REQUEST(ACTION_TYPES.FETCH_MEDICINE):
      return {
        ...state,
        errorMessage: null,
        updateSuccess: false,
        loading: true
      };
    case REQUEST(ACTION_TYPES.CREATE_MEDICINE):
    case REQUEST(ACTION_TYPES.UPDATE_MEDICINE):
    case REQUEST(ACTION_TYPES.DELETE_MEDICINE):
      return {
        ...state,
        errorMessage: null,
        updateSuccess: false,
        updating: true
      };
    case FAILURE(ACTION_TYPES.FETCH_MEDICINE_LIST):
    case FAILURE(ACTION_TYPES.FETCH_MEDICINE):
    case FAILURE(ACTION_TYPES.CREATE_MEDICINE):
    case FAILURE(ACTION_TYPES.UPDATE_MEDICINE):
    case FAILURE(ACTION_TYPES.DELETE_MEDICINE):
      return {
        ...state,
        loading: false,
        updating: false,
        updateSuccess: false,
        errorMessage: action.payload
      };
    case SUCCESS(ACTION_TYPES.FETCH_MEDICINE_LIST):
      return {
        ...state,
        loading: false,
        entities: action.payload.data
      };
    case SUCCESS(ACTION_TYPES.FETCH_MEDICINE):
      return {
        ...state,
        loading: false,
        entity: action.payload.data
      };
    case SUCCESS(ACTION_TYPES.CREATE_MEDICINE):
    case SUCCESS(ACTION_TYPES.UPDATE_MEDICINE):
      return {
        ...state,
        updating: false,
        updateSuccess: true,
        entity: action.payload.data
      };
    case SUCCESS(ACTION_TYPES.DELETE_MEDICINE):
      return {
        ...state,
        updating: false,
        updateSuccess: true,
        entity: {}
      };
    case ACTION_TYPES.RESET:
      return {
        ...initialState
      };
    default:
      return state;
  }
};

const apiUrl = 'api/medicines';

// Actions

export const getEntities: ICrudGetAllAction<IMedicine> = (page, size, sort) => ({
  type: ACTION_TYPES.FETCH_MEDICINE_LIST,
  payload: axios.get<IMedicine>(`${apiUrl}?cacheBuster=${new Date().getTime()}`)
});

export const getEntity: ICrudGetAction<IMedicine> = id => {
  const requestUrl = `${apiUrl}/${id}`;
  return {
    type: ACTION_TYPES.FETCH_MEDICINE,
    payload: axios.get<IMedicine>(requestUrl)
  };
};

export const createEntity: ICrudPutAction<IMedicine> = entity => async dispatch => {
  const result = await dispatch({
    type: ACTION_TYPES.CREATE_MEDICINE,
    payload: axios.post(apiUrl, cleanEntity(entity))
  });
  dispatch(getEntities());
  return result;
};

export const updateEntity: ICrudPutAction<IMedicine> = entity => async dispatch => {
  const result = await dispatch({
    type: ACTION_TYPES.UPDATE_MEDICINE,
    payload: axios.put(apiUrl, cleanEntity(entity))
  });
  dispatch(getEntities());
  return result;
};

export const deleteEntity: ICrudDeleteAction<IMedicine> = id => async dispatch => {
  const requestUrl = `${apiUrl}/${id}`;
  const result = await dispatch({
    type: ACTION_TYPES.DELETE_MEDICINE,
    payload: axios.delete(requestUrl)
  });
  dispatch(getEntities());
  return result;
};

export const reset = () => ({
  type: ACTION_TYPES.RESET
});

从'react jhipster'导入{ICrudGetAction，icrudgetalaction，ICrudPutAction，icruddeaction}；
从'app/shared/util/entity utils'导入{cleanEntity}；
从“app/shared/reducers/action type.util”导入{REQUEST，SUCCESS，FAILURE}；
从'app/shared/model/medicine.model'导入{IMedicine，defaultValue}；
导出常量操作类型={
取药清单：“取药/取药清单”，
取药：“取药”，
创建药物：“药物/创建药物”，
更新医学：“医学/更新医学”，
删除药物：“药物/删除药物”，
重置：“药物/重置”
};
常量初始状态={
加载：false，
errorMessage:null，
实体：[]作为只读阵列，
实体：defaultValue，
更新：false，
updateSuccess:false
};
导出类型MedicineState=只读；
//减速器
导出默认值（状态：MedicineState=initialState，操作）：MedicineState=>{
开关（动作类型）{
案例请求（行动类型。获取药物列表）：
病例请求（行动类型。取药）：
返回{
……国家，
errorMessage:null，
updateSuccess:false，
加载：正确
};
病例请求（行动类型。创建药物）：
病例请求（行动类型。更新药物）：
病例请求（行动类型。删除药物）：
返回{
……国家，
errorMessage:null，
updateSuccess:false，
更新：正确
};
案例失败（操作类型。获取药物列表）：
案例失败（操作类型。取药）：
案例失败（行动类型。创建药物）：
案例失败（行动类型。更新药物）：
案例失败（操作类型。删除药物）：
返回{
……国家，
加载：false，
更新：false，
updateSuccess:false，
错误消息：action.payload
};
案例成功（操作类型。获取药物列表）：
返回{
……国家，
加载：false，
实体：action.payload.data
};
案例成功（行动类型：取药）：
返回{
……国家，
加载：false，
实体：action.payload.data
};
案例成功（行动类型。创建药物）：
案例成功（行动类型。更新药物）：
返回{
……国家，
更新：false，
updateSuccess:true，
实体：action.payload.data
};
案例成功（行动类型。删除药物）：
返回{
……国家，
更新：false，
updateSuccess:true，
实体：{}
};
案例操作_type.RESET：
返回{
…初始状态
};
违约：
返回状态；
}
};
const-apiUrl='api/medicines'；
//行动
导出常量getEntities:icrudgetalAction=（页面、大小、排序）=>({
类型：操作类型。获取药物列表，
有效负载：axios.get（`${apirl}？cacheBuster=${new Date（）.getTime（）}`）
});
export const getEntity:ICrudGetAction=id=>{
const requestUrl=`${apirl}/${id}`；
返回{
类型：动作类型。取药，
有效负载：axios.get（requestUrl）
};
};
export const createEntity:ICrudPutAction=entity=>async dispatch=>{
const result=等待调度({
类型：行动类型。创建药物，
有效负载：axios.post（apiUrl，cleanEntity（entity））
});
调度（getEntities（））；
返回结果；
};
导出常量更新属性：ICrudPutAction=entity=>async dispatch=>{
const result=等待调度({
类型：行动类型。更新药物，
有效负载：axios.put（apirl，cleanEntity（entity））
});
调度（getEntities（））；
返回结果；
};
导出常量deleteEntity:ICrudDeleteAction=id=>async dispatch=>{
const requestUrl=`${apirl}/${id}`；
const result=等待调度({
类型：动作类型。删除药物，
有效负载：axios.delete（requestUrl）
});
调度（getEntities（））；
返回结果；
};
导出常量重置=（）=>({
类型：操作类型。重置
});

操作由触发

对于具有异步负载的操作

FOO

，redux promise中间件将调度3个操作：

• FOO_挂起

  ，立即
• 一旦承诺达成，就履行了

• FOO_拒绝

  ，如果承诺被拒绝

请求、成功和失败仅仅是Jhister中的3个简单函数，以便于使用redux promise中间件

export const REQUEST = actionType => `${actionType}_PENDING`;
export const SUCCESS = actionType => `${actionType}_FULFILLED`;
export const FAILURE = actionType => `${actionType}_REJECTED`;

---

是的，那有什么帮助？我对问题进行了编辑，使其更容易理解。对不起，我的英语不好。谢谢，这就是我一直在等待的！