org.springframework.core.ReactiveAdapter

@Override
public boolean supports(HandlerResult result) {
    if (hasModelAnnotation(result.getReturnTypeSource())) {
        return true;
    }
    Clreplaced<?> type = result.getReturnType().toClreplaced();
    ReactiveAdapter adapter = getAdapter(result);
    if (adapter != null) {
        if (adapter.isNoValue()) {
            return true;
        }
        type = result.getReturnType().getGeneric().toClreplaced();
    }
    return (CharSequence.clreplaced.isreplacedignableFrom(type) || Rendering.clreplaced.isreplacedignableFrom(type) || Model.clreplaced.isreplacedignableFrom(type) || Map.clreplaced.isreplacedignableFrom(type) || void.clreplaced.equals(type) || View.clreplaced.isreplacedignableFrom(type) || !BeanUtils.isSimpleProperty(type));
}

/**
 * Evaluate the {@code Predicate} on the method parameter type or on
 * the generic type within a reactive type wrapper.
 */
protected boolean checkParameterType(MethodParameter parameter, Predicate<Clreplaced<?>> predicate) {
    Clreplaced<?> type = parameter.getParameterType();
    ReactiveAdapter adapter = getAdapterRegistry().getAdapter(type);
    if (adapter != null) {
        replacedertHasValues(adapter, parameter);
        type = parameter.nested().getNestedParameterType();
    }
    return predicate.test(type);
}

/**
 * Evaluate the {@code Predicate} on the method parameter type but raise an
 * {@code IllegalStateException} if the same matches the generic type
 * within a reactive type wrapper.
 */
protected boolean checkParameterTypeNoReactiveWrapper(MethodParameter parameter, Predicate<Clreplaced<?>> predicate) {
    Clreplaced<?> type = parameter.getParameterType();
    ReactiveAdapter adapter = getAdapterRegistry().getAdapter(type);
    if (adapter != null) {
        replacedertHasValues(adapter, parameter);
        type = parameter.nested().getNestedParameterType();
    }
    if (predicate.test(type)) {
        if (adapter == null) {
            return true;
        }
        throw buildReactiveWrapperException(parameter);
    }
    return false;
}

/**
 * Evaluate the {@code Predicate} on the method parameter type if it has the
 * given annotation, nesting within {@link java.util.Optional} if necessary,
 * but raise an {@code IllegalStateException} if the same matches the generic
 * type within a reactive type wrapper.
 */
protected <A extends Annotation> boolean checkAnnotatedParamNoReactiveWrapper(MethodParameter parameter, Clreplaced<A> annotationType, BiPredicate<A, Clreplaced<?>> typePredicate) {
    A annotation = parameter.getParameterAnnotation(annotationType);
    if (annotation == null) {
        return false;
    }
    parameter = parameter.nestedIfOptional();
    Clreplaced<?> type = parameter.getNestedParameterType();
    ReactiveAdapter adapter = getAdapterRegistry().getAdapter(type);
    if (adapter != null) {
        replacedertHasValues(adapter, parameter);
        parameter = parameter.nested();
        type = parameter.getNestedParameterType();
    }
    if (typePredicate.test(annotation, type)) {
        if (adapter == null) {
            return true;
        }
        throw buildReactiveWrapperException(parameter);
    }
    return false;
}

private void replacedertHasValues(ReactiveAdapter adapter, MethodParameter param) {
    if (adapter.isNoValue()) {
        throw new IllegalArgumentException("No value reactive types not supported: " + param.getGenericParameterType());
    }
}

@Override
public Mono<Object> resolveArgument(MethodParameter parameter, BindingContext context, ServerWebExchange exchange) {
    Mono<WebSession> session = exchange.getSession();
    ReactiveAdapter adapter = getAdapterRegistry().getAdapter(parameter.getParameterType());
    return (adapter != null ? Mono.just(adapter.fromPublisher(session)) : Mono.from(session));
}

@Override
protected Object resolveNamedValue(String name, MethodParameter parameter, ServerWebExchange exchange) {
    Object value = exchange.getAttribute(name);
    ReactiveAdapter toAdapter = getAdapterRegistry().getAdapter(parameter.getParameterType());
    if (toAdapter != null) {
        if (value == null) {
            replacedert.isTrue(toAdapter.supportsEmpty(), () -> "No request attribute '" + name + "' and target type " + parameter.getGenericParameterType() + " doesn't support empty values.");
            return toAdapter.fromPublisher(Mono.empty());
        }
        if (parameter.getParameterType().isreplacedignableFrom(value.getClreplaced())) {
            return value;
        }
        ReactiveAdapter fromAdapter = getAdapterRegistry().getAdapter(value.getClreplaced());
        replacedert.isTrue(fromAdapter != null, () -> getClreplaced().getSimpleName() + " doesn't support " + "reactive type wrapper: " + parameter.getGenericParameterType());
        return toAdapter.fromPublisher(fromAdapter.toPublisher(value));
    }
    return value;
}

@Override
public Mono<Object> resolveArgument(MethodParameter parameter, BindingContext context, ServerWebExchange exchange) {
    Mono<Principal> principal = exchange.getPrincipal();
    ReactiveAdapter adapter = getAdapterRegistry().getAdapter(parameter.getParameterType());
    return (adapter != null ? Mono.just(adapter.fromPublisher(principal)) : Mono.from(principal));
}

private ResolvableType getElementType(ReactiveAdapter adapter, ResolvableType genericType) {
    if (adapter.isNoValue()) {
        return ResolvableType.forClreplaced(Void.clreplaced);
    } else if (genericType != ResolvableType.NONE) {
        return genericType;
    } else {
        return ResolvableType.forClreplaced(Object.clreplaced);
    }
}

/**
 * General delegate for around-advice-based subclreplacedes, delegating to several other template
 * methods on this clreplaced. Able to handle {@link CallbackPreferringPlatformTransactionManager}
 * as well as regular {@link PlatformTransactionManager} implementations.
 * @param method the Method being invoked
 * @param targetClreplaced the target clreplaced that we're invoking the method on
 * @param invocation the callback to use for proceeding with the target invocation
 * @return the return value of the method, if any
 * @throws Throwable propagated from the target invocation
 */
@Nullable
protected Object invokeWithinTransaction(Method method, @Nullable Clreplaced<?> targetClreplaced, final InvocationCallback invocation) throws Throwable {
    if (this.reactiveAdapterRegistry != null) {
        ReactiveAdapter adapter = this.reactiveAdapterRegistry.getAdapter(method.getReturnType());
        if (adapter != null) {
            return new ReactiveTransactionSupport(adapter).invokeWithinTransaction(method, targetClreplaced, invocation);
        }
    }
    // If the transaction attribute is null, the method is non-transactional.
    // 如果transaction属性为null，则该方法是非事务性的
    TransactionAttributeSource tas = getTransactionAttributeSource();
    // 获取对应事务属性
    final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClreplaced) : null);
    // 获取事务管理器
    final PlatformTransactionManager tm = determineTransactionManager(txAttr);
    // 构造方法唯一标识（类.方法）
    final String joinpointIdentification = methodIdentification(method, targetClreplaced, txAttr);
    if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
        // 声明式事务处理
        // Standard transaction demarcation with getTransaction and commit/rollback calls.
        // 标准事务划分 : 使用 getTransaction 和 commit / rollback 调用
        TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
        Object retVal;
        try {
            // This is an around advice: Invoke the next interceptor in the chain.
            // This will normally result in a target object being invoked.
            // 传入的是回调函数对象： invocation.proceed。 执行被增强的方法
            retVal = invocation.proceedWithInvocation();
        } catch (Throwable ex) {
            // target invocation exception
            // 异常回滚
            completeTransactionAfterThrowing(txInfo, ex);
            throw ex;
        } finally {
            // 清除信息
            cleanupTransactionInfo(txInfo);
        }
        if (vavrPresent && VavrDelegate.isVavrTry(retVal)) {
            // Set rollback-only in case of Vavr failure matching our rollback rules...
            TransactionStatus status = txInfo.getTransactionStatus();
            if (status != null && txAttr != null) {
                retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
            }
        }
        // 提交事务
        commitTransactionAfterReturning(txInfo);
        return retVal;
    } else {
        // 编程式事务处理
        final ThrowableHolder throwableHolder = new ThrowableHolder();
        // It's a CallbackPreferringPlatformTransactionManager: preplaced a TransactionCallback in.
        try {
            Object result = ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr, status -> {
                TransactionInfo txInfo = prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
                try {
                    Object retVal = invocation.proceedWithInvocation();
                    if (vavrPresent && VavrDelegate.isVavrTry(retVal)) {
                        // Set rollback-only in case of Vavr failure matching our rollback rules...
                        retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
                    }
                    return retVal;
                } catch (Throwable ex) {
                    if (txAttr.rollbackOn(ex)) {
                        // A RuntimeException: will lead to a rollback.
                        if (ex instanceof RuntimeException) {
                            throw (RuntimeException) ex;
                        } else {
                            throw new ThrowableHolderException(ex);
                        }
                    } else {
                        // A normal return value: will lead to a commit.
                        throwableHolder.throwable = ex;
                        return null;
                    }
                } finally {
                    cleanupTransactionInfo(txInfo);
                }
            });
            // Check result state: It might indicate a Throwable to rethrow.
            if (throwableHolder.throwable != null) {
                throw throwableHolder.throwable;
            }
            return result;
        } catch (ThrowableHolderException ex) {
            throw ex.getCause();
        } catch (TransactionSystemException ex2) {
            if (throwableHolder.throwable != null) {
                logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
                ex2.initApplicationException(throwableHolder.throwable);
            }
            throw ex2;
        } catch (Throwable ex2) {
            if (throwableHolder.throwable != null) {
                logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
            }
            throw ex2;
        }
    }
}

@Override
public ListenableFuture<?> toListenableFuture(Object returnValue, MethodParameter returnType) {
    ReactiveAdapter adapter = this.adapterRegistry.getAdapter(returnType.getParameterType(), returnValue);
    replacedert.state(adapter != null, () -> "No ReactiveAdapter found for " + returnType.getParameterType());
    return new MonoToListenableFutureAdapter<>(Mono.from(adapter.toPublisher(returnValue)));
}

@Override
public boolean isAsyncReturnValue(Object returnValue, MethodParameter returnType) {
    ReactiveAdapter adapter = this.adapterRegistry.getAdapter(returnType.getParameterType(), returnValue);
    return (adapter != null && !adapter.isMultiValue() && !adapter.isNoValue());
}

private boolean isAsyncVoidReturnType(MethodParameter returnType, @Nullable ReactiveAdapter reactiveAdapter) {
    if (reactiveAdapter != null && reactiveAdapter.supportsEmpty()) {
        if (reactiveAdapter.isNoValue()) {
            return true;
        }
        Type parameterType = returnType.getGenericParameterType();
        if (parameterType instanceof ParameterizedType) {
            ParameterizedType type = (ParameterizedType) parameterType;
            if (type.getActualTypeArguments().length == 1) {
                return Void.clreplaced.equals(type.getActualTypeArguments()[0]);
            }
        }
    }
    return false;
}

private ResolvableType getElementType(ReactiveAdapter adapter, ResolvableType type) {
    if (adapter.isNoValue()) {
        return VOID_RESOLVABLE_TYPE;
    } else if (type != ResolvableType.NONE) {
        return type;
    } else {
        return OBJECT_RESOLVABLE_TYPE;
    }
}

@Override
public boolean supports(HandlerResult result) {
    if (hasModelAnnotation(result.getReturnTypeSource())) {
        return true;
    }
    Clreplaced<?> type = result.getReturnType().toClreplaced();
    ReactiveAdapter adapter = getAdapter(result);
    if (adapter != null) {
        if (adapter.isNoValue()) {
            return true;
        }
        type = result.getReturnType().getGeneric().toClreplaced();
    }
    return (CharSequence.clreplaced.isreplacedignableFrom(type) || Rendering.clreplaced.isreplacedignableFrom(type) || Model.clreplaced.isreplacedignableFrom(type) || Map.clreplaced.isreplacedignableFrom(type) || View.clreplaced.isreplacedignableFrom(type) || !BeanUtils.isSimpleProperty(type));
}

/**
 * Inserter to write the given producer of value(s) which must be a {@link Publisher}
 * or another producer adaptable to a {@code Publisher} via
 * {@link ReactiveAdapterRegistry}.
 * <p>Alternatively, consider using the {@code body} shortcuts on
 * {@link org.springframework.web.reactive.function.client.WebClient WebClient} and
 * {@link org.springframework.web.reactive.function.server.ServerResponse ServerResponse}.
 * @param <T> the type of the body
 * @param producer the source of body value(s).
 * @param elementClreplaced the clreplaced of values to be produced
 * @return the inserter to write a producer
 * @since 5.2
 */
public static <T> BodyInserter<T, ReactiveHttpOutputMessage> fromProducer(T producer, Clreplaced<?> elementClreplaced) {
    replacedert.notNull(producer, "'producer' must not be null");
    replacedert.notNull(elementClreplaced, "'elementClreplaced' must not be null");
    ReactiveAdapter adapter = ReactiveAdapterRegistry.getSharedInstance().getAdapter(producer.getClreplaced());
    replacedert.notNull(adapter, "'producer' type is unknown to ReactiveAdapterRegistry");
    return (message, context) -> writeWithMessageWriters(message, context, producer, ResolvableType.forClreplaced(elementClreplaced), adapter);
}

/**
 * Inserter to write the given producer of value(s) which must be a {@link Publisher}
 * or another producer adaptable to a {@code Publisher} via
 * {@link ReactiveAdapterRegistry}.
 * <p>Alternatively, consider using the {@code body} shortcuts on
 * {@link org.springframework.web.reactive.function.client.WebClient WebClient} and
 * {@link org.springframework.web.reactive.function.server.ServerResponse ServerResponse}.
 * @param <T> the type of the body
 * @param producer the source of body value(s).
 * @param elementTypeRef the type of values to be produced
 * @return the inserter to write a producer
 * @since 5.2
 */
public static <T> BodyInserter<T, ReactiveHttpOutputMessage> fromProducer(T producer, ParameterizedTypeReference<?> elementTypeRef) {
    replacedert.notNull(producer, "'producer' must not be null");
    replacedert.notNull(elementTypeRef, "'elementTypeRef' must not be null");
    ReactiveAdapter adapter = ReactiveAdapterRegistry.getSharedInstance().getAdapter(producer.getClreplaced());
    replacedert.notNull(adapter, "'producer' type is unknown to ReactiveAdapterRegistry");
    return (message, context) -> writeWithMessageWriters(message, context, producer, ResolvableType.forType(elementTypeRef), adapter);
}

private static <M extends ReactiveHttpOutputMessage> Mono<Void> writeWithMessageWriters(M outputMessage, BodyInserter.Context context, Object body, ResolvableType bodyType, @Nullable ReactiveAdapter adapter) {
    Publisher<?> publisher;
    if (body instanceof Publisher) {
        publisher = (Publisher<?>) body;
    } else if (adapter != null) {
        publisher = adapter.toPublisher(body);
    } else {
        publisher = Mono.just(body);
    }
    MediaType mediaType = outputMessage.getHeaders().getContentType();
    return context.messageWriters().stream().filter(messageWriter -> messageWriter.canWrite(bodyType, mediaType)).findFirst().map(BodyInserters::cast).map(writer -> write(publisher, bodyType, mediaType, outputMessage, context, writer)).orElseGet(() -> Mono.error(unsupportedError(bodyType, context, mediaType)));
}

/**
 * General delegate for around-advice-based subclreplacedes, delegating to several other template
 * methods on this clreplaced. Able to handle {@link CallbackPreferringPlatformTransactionManager} as
 * well as regular {@link PlatformTransactionManager} implementations.
 * <p>
 * 带着事务执行
 *
 * @param method      the Method being invoked
 * @param targetClreplaced the target clreplaced that we're invoking the method on
 * @param invocation  the callback to use for proceeding with the target invocation
 * @return the return value of the method, if any
 * @throws Throwable propagated from the target invocation
 */
@Nullable
protected Object invokeWithinTransaction(Method method, @Nullable Clreplaced<?> targetClreplaced, final InvocationCallback invocation) throws Throwable {
    // If the transaction attribute is null, the method is non-transactional.
    // 获取事务属性
    TransactionAttributeSource tas = getTransactionAttributeSource();
    final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClreplaced) : null);
    // 确定事物管理器
    final TransactionManager tm = determineTransactionManager(txAttr);
    if (this.reactiveAdapterRegistry != null && tm instanceof ReactiveTransactionManager) {
        ReactiveTransactionSupport txSupport = this.transactionSupportCache.computeIfAbsent(method, key -> {
            if (KotlinDetector.isKotlinType(method.getDeclaringClreplaced()) && KotlinDelegate.isSuspend(method)) {
                throw new TransactionUsageException("Unsupported annotated transaction on suspending function detected: " + method + ". Use TransactionalOperator.transactional extensions instead.");
            }
            ReactiveAdapter adapter = this.reactiveAdapterRegistry.getAdapter(method.getReturnType());
            if (adapter == null) {
                throw new IllegalStateException("Cannot apply reactive transaction to non-reactive return type: " + method.getReturnType());
            }
            return new ReactiveTransactionSupport(adapter);
        });
        return txSupport.invokeWithinTransaction(method, targetClreplaced, invocation, txAttr, (ReactiveTransactionManager) tm);
    }
    // 类型转换
    PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
    // 切点
    final String joinpointIdentification = methodIdentification(method, targetClreplaced, txAttr);
    if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
        // Standard transaction demarcation with getTransaction and commit/rollback calls.
        // 创建一个新的事务根据事务传播性
        TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
        Object retVal;
        try {
            // This is an around advice: Invoke the next interceptor in the chain.
            // This will normally result in a target object being invoked.
            // 回调方法
            retVal = invocation.proceedWithInvocation();
        } catch (Throwable ex) {
            // target invocation exception
            // 回滚异常
            completeTransactionAfterThrowing(txInfo, ex);
            throw ex;
        } finally {
            // 消息清理
            cleanupTransactionInfo(txInfo);
        }
        if (vavrPresent && VavrDelegate.isVavrTry(retVal)) {
            // Set rollback-only in case of Vavr failure matching our rollback rules...
            TransactionStatus status = txInfo.getTransactionStatus();
            if (status != null && txAttr != null) {
                retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
            }
        }
        // 提交事务的后置操作
        commitTransactionAfterReturning(txInfo);
        return retVal;
    } else {
        final ThrowableHolder throwableHolder = new ThrowableHolder();
        // It's a CallbackPreferringPlatformTransactionManager: preplaced a TransactionCallback in.
        try {
            Object result = ((CallbackPreferringPlatformTransactionManager) ptm).execute(txAttr, status -> {
                TransactionInfo txInfo = prepareTransactionInfo(ptm, txAttr, joinpointIdentification, status);
                try {
                    Object retVal = invocation.proceedWithInvocation();
                    if (vavrPresent && VavrDelegate.isVavrTry(retVal)) {
                        // Set rollback-only in case of Vavr failure matching our rollback rules...
                        retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
                    }
                    return retVal;
                } catch (Throwable ex) {
                    if (txAttr.rollbackOn(ex)) {
                        // A RuntimeException: will lead to a rollback.
                        if (ex instanceof RuntimeException) {
                            throw (RuntimeException) ex;
                        } else {
                            throw new ThrowableHolderException(ex);
                        }
                    } else {
                        // A normal return value: will lead to a commit.
                        throwableHolder.throwable = ex;
                        return null;
                    }
                } finally {
                    cleanupTransactionInfo(txInfo);
                }
            });
            // Check result state: It might indicate a Throwable to rethrow.
            if (throwableHolder.throwable != null) {
                throw throwableHolder.throwable;
            }
            return result;
        } catch (ThrowableHolderException ex) {
            throw ex.getCause();
        } catch (TransactionSystemException ex2) {
            if (throwableHolder.throwable != null) {
                logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
                ex2.initApplicationException(throwableHolder.throwable);
            }
            throw ex2;
        } catch (Throwable ex2) {
            if (throwableHolder.throwable != null) {
                logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
            }
            throw ex2;
        }
    }
}

private Mono<Payload> getSetupPayload(MimeType dataMimeType, MimeType metaMimeType, RSocketStrategies strategies) {
    Object data = this.setupData;
    boolean hasMetadata = (this.setupRoute != null || !CollectionUtils.isEmpty(this.setupMetadata));
    if (!hasMetadata && data == null) {
        return Mono.empty();
    }
    Mono<DataBuffer> dataMono = Mono.empty();
    if (data != null) {
        ReactiveAdapter adapter = strategies.reactiveAdapterRegistry().getAdapter(data.getClreplaced());
        replacedert.isTrue(adapter == null || !adapter.isMultiValue(), "Expected single value: " + data);
        Mono<?> mono = (adapter != null ? Mono.from(adapter.toPublisher(data)) : Mono.just(data));
        dataMono = mono.map(value -> {
            ResolvableType type = ResolvableType.forClreplaced(value.getClreplaced());
            Encoder<Object> encoder = strategies.encoder(type, dataMimeType);
            replacedert.notNull(encoder, () -> "No encoder for " + dataMimeType + ", " + type);
            return encoder.encodeValue(value, strategies.dataBufferFactory(), type, dataMimeType, HINTS);
        });
    }
    Mono<DataBuffer> metaMono = Mono.empty();
    if (hasMetadata) {
        metaMono = new MetadataEncoder(metaMimeType, strategies).metadataAndOrRoute(this.setupMetadata, this.setupRoute, this.setupRouteVars).encode();
    }
    Mono<DataBuffer> emptyBuffer = Mono.fromCallable(() -> strategies.dataBufferFactory().wrap(EMPTY_BYTE_ARRAY));
    dataMono = dataMono.switchIfEmpty(emptyBuffer);
    metaMono = metaMono.switchIfEmpty(emptyBuffer);
    return Mono.zip(dataMono, metaMono).map(tuple -> PayloadUtils.createPayload(tuple.getT1(), tuple.getT2())).doOnDiscard(DataBuffer.clreplaced, DataBufferUtils::release).doOnDiscard(Payload.clreplaced, Payload::release);
}

@Override
public ListenableFuture<?> toListenableFuture(Object returnValue, MethodParameter returnType) {
    ReactiveAdapter adapter = this.adapterRegistry.getAdapter(returnType.getParameterType(), returnValue);
    if (adapter != null) {
        return new MonoToListenableFutureAdapter<>(Mono.from(adapter.toPublisher(returnValue)));
    }
    return null;
}

/**
 * General delegate for around-advice-based subclreplacedes, delegating to several other template
 * methods on this clreplaced. Able to handle {@link CallbackPreferringPlatformTransactionManager}
 * as well as regular {@link PlatformTransactionManager} implementations.
 * @param method the Method being invoked
 * @param targetClreplaced the target clreplaced that we're invoking the method on
 * @param invocation the callback to use for proceeding with the target invocation
 * @return the return value of the method, if any
 * @throws Throwable propagated from the target invocation
 */
@Nullable
protected Object invokeWithinTransaction(Method method, @Nullable Clreplaced<?> targetClreplaced, final InvocationCallback invocation) throws Throwable {
    // If the transaction attribute is null, the method is non-transactional.
    TransactionAttributeSource tas = getTransactionAttributeSource();
    final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClreplaced) : null);
    final TransactionManager tm = determineTransactionManager(txAttr);
    if (this.reactiveAdapterRegistry != null && tm instanceof ReactiveTransactionManager) {
        ReactiveTransactionSupport txSupport = this.transactionSupportCache.computeIfAbsent(method, key -> {
            if (KotlinDetector.isKotlinType(method.getDeclaringClreplaced()) && KotlinDelegate.isSuspend(method)) {
                throw new TransactionUsageException("Unsupported annotated transaction on suspending function detected: " + method + ". Use TransactionalOperator.transactional extensions instead.");
            }
            ReactiveAdapter adapter = this.reactiveAdapterRegistry.getAdapter(method.getReturnType());
            if (adapter == null) {
                throw new IllegalStateException("Cannot apply reactive transaction to non-reactive return type: " + method.getReturnType());
            }
            return new ReactiveTransactionSupport(adapter);
        });
        return txSupport.invokeWithinTransaction(method, targetClreplaced, invocation, txAttr, (ReactiveTransactionManager) tm);
    }
    PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
    final String joinpointIdentification = methodIdentification(method, targetClreplaced, txAttr);
    if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
        // Standard transaction demarcation with getTransaction and commit/rollback calls.
        TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
        Object retVal;
        try {
            // This is an around advice: Invoke the next interceptor in the chain.
            // This will normally result in a target object being invoked.
            retVal = invocation.proceedWithInvocation();
        } catch (Throwable ex) {
            // target invocation exception
            completeTransactionAfterThrowing(txInfo, ex);
            throw ex;
        } finally {
            cleanupTransactionInfo(txInfo);
        }
        if (vavrPresent && VavrDelegate.isVavrTry(retVal)) {
            // Set rollback-only in case of Vavr failure matching our rollback rules...
            TransactionStatus status = txInfo.getTransactionStatus();
            if (status != null && txAttr != null) {
                retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
            }
        }
        commitTransactionAfterReturning(txInfo);
        return retVal;
    } else {
        final ThrowableHolder throwableHolder = new ThrowableHolder();
        // It's a CallbackPreferringPlatformTransactionManager: preplaced a TransactionCallback in.
        try {
            Object result = ((CallbackPreferringPlatformTransactionManager) ptm).execute(txAttr, status -> {
                TransactionInfo txInfo = prepareTransactionInfo(ptm, txAttr, joinpointIdentification, status);
                try {
                    Object retVal = invocation.proceedWithInvocation();
                    if (vavrPresent && VavrDelegate.isVavrTry(retVal)) {
                        // Set rollback-only in case of Vavr failure matching our rollback rules...
                        retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
                    }
                    return retVal;
                } catch (Throwable ex) {
                    if (txAttr.rollbackOn(ex)) {
                        // A RuntimeException: will lead to a rollback.
                        if (ex instanceof RuntimeException) {
                            throw (RuntimeException) ex;
                        } else {
                            throw new ThrowableHolderException(ex);
                        }
                    } else {
                        // A normal return value: will lead to a commit.
                        throwableHolder.throwable = ex;
                        return null;
                    }
                } finally {
                    cleanupTransactionInfo(txInfo);
                }
            });
            // Check result state: It might indicate a Throwable to rethrow.
            if (throwableHolder.throwable != null) {
                throw throwableHolder.throwable;
            }
            return result;
        } catch (ThrowableHolderException ex) {
            throw ex.getCause();
        } catch (TransactionSystemException ex2) {
            if (throwableHolder.throwable != null) {
                logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
                ex2.initApplicationException(throwableHolder.throwable);
            }
            throw ex2;
        } catch (Throwable ex2) {
            if (throwableHolder.throwable != null) {
                logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
            }
            throw ex2;
        }
    }
}

public clreplaced MaybeReactiveAdapterTest {

    final ReactiveAdapter maybeAdapter = new MaybeReactiveAdapter();

    @Test
    public void convertFromMaybeToPublisherTest() {
        replacedertions.replacedertThat(maybeAdapter.toPublisher(Maybe.just(1))).isInstanceOf(Publisher.clreplaced);
    }

    @Test
    public void convertFromPublisherToMaybeTest() {
        replacedertions.replacedertThat(maybeAdapter.fromPublisher(Mono.just(1))).isInstanceOf(Maybe.clreplaced);
    }
}

/**
 * Process the given reactive return value and decide whether to adapt it
 * to a {@link ResponseBodyEmitter} or a {@link DeferredResult}.
 * @return an emitter for streaming, or {@code null} if handled internally
 * with a {@link DeferredResult}
 */
@Nullable
public ResponseBodyEmitter handleValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mav, NativeWebRequest request) throws Exception {
    replacedert.notNull(returnValue, "Expected return value");
    ReactiveAdapter adapter = this.adapterRegistry.getAdapter(returnValue.getClreplaced());
    replacedert.state(adapter != null, () -> "Unexpected return value: " + returnValue);
    ResolvableType elementType = ResolvableType.forMethodParameter(returnType).getGeneric();
    Clreplaced<?> elementClreplaced = elementType.toClreplaced();
    Collection<MediaType> mediaTypes = getMediaTypes(request);
    Optional<MediaType> mediaType = mediaTypes.stream().filter(MimeType::isConcrete).findFirst();
    if (adapter.isMultiValue()) {
        if (mediaTypes.stream().anyMatch(MediaType.TEXT_EVENT_STREAM::includes) || ServerSentEvent.clreplaced.isreplacedignableFrom(elementClreplaced)) {
            logExecutorWarning(returnType);
            SseEmitter emitter = new SseEmitter(STREAMING_TIMEOUT_VALUE);
            new SseEmitterSubscriber(emitter, this.taskExecutor).connect(adapter, returnValue);
            return emitter;
        }
        if (CharSequence.clreplaced.isreplacedignableFrom(elementClreplaced)) {
            logExecutorWarning(returnType);
            ResponseBodyEmitter emitter = getEmitter(mediaType.orElse(MediaType.TEXT_PLAIN));
            new TextEmitterSubscriber(emitter, this.taskExecutor).connect(adapter, returnValue);
            return emitter;
        }
        if (mediaTypes.stream().anyMatch(MediaType.APPLICATION_STREAM_JSON::includes)) {
            logExecutorWarning(returnType);
            ResponseBodyEmitter emitter = getEmitter(MediaType.APPLICATION_STREAM_JSON);
            new JsonEmitterSubscriber(emitter, this.taskExecutor).connect(adapter, returnValue);
            return emitter;
        }
    }
    // Not streaming...
    DeferredResult<Object> result = new DeferredResult<>();
    new DeferredResultSubscriber(result, adapter, elementType).connect(adapter, returnValue);
    WebAsyncUtils.getAsyncManager(request).startDeferredResultProcessing(result, mav);
    return null;
}

@Override
public boolean supports(HandlerResult result) {
    Clreplaced<?> valueType = resolveReturnValueType(result);
    if (isSupportedType(valueType)) {
        return true;
    }
    ReactiveAdapter adapter = getAdapter(result);
    return adapter != null && !adapter.isNoValue() && isSupportedType(result.getReturnType().getGeneric().toClreplaced());
}

@Override
public Mono<Object> resolveArgument(MethodParameter parameter, BindingContext bindingContext, ServerWebExchange exchange) {
    RequestPart requestPart = parameter.getParameterAnnotation(RequestPart.clreplaced);
    boolean isRequired = (requestPart == null || requestPart.required());
    String name = getPartName(parameter, requestPart);
    Flux<Part> parts = exchange.getMultipartData().flatMapIterable(map -> {
        List<Part> list = map.get(name);
        if (CollectionUtils.isEmpty(list)) {
            if (isRequired) {
                throw getMissingPartException(name, parameter);
            }
            return Collections.emptyList();
        }
        return list;
    });
    if (Part.clreplaced.isreplacedignableFrom(parameter.getParameterType())) {
        return parts.next().cast(Object.clreplaced);
    }
    if (List.clreplaced.isreplacedignableFrom(parameter.getParameterType())) {
        MethodParameter elementType = parameter.nested();
        if (Part.clreplaced.isreplacedignableFrom(elementType.getNestedParameterType())) {
            return parts.collectList().cast(Object.clreplaced);
        } else {
            return decodePartValues(parts, elementType, bindingContext, exchange, isRequired).collectList().cast(Object.clreplaced);
        }
    }
    ReactiveAdapter adapter = getAdapterRegistry().getAdapter(parameter.getParameterType());
    if (adapter != null) {
        // Mono<Part> or Flux<Part>
        MethodParameter elementType = parameter.nested();
        if (Part.clreplaced.isreplacedignableFrom(elementType.getNestedParameterType())) {
            parts = (adapter.isMultiValue() ? parts : parts.take(1));
            return Mono.just(adapter.fromPublisher(parts));
        }
        // We have to decode the content for each part, one at a time
        if (adapter.isMultiValue()) {
            return Mono.just(decodePartValues(parts, elementType, bindingContext, exchange, isRequired));
        }
    }
    // <T> or Mono<T>
    return decodePartValues(parts, parameter, bindingContext, exchange, isRequired).next().cast(Object.clreplaced);
}

private boolean isAsyncVoidType(ResolvableType type, @Nullable ReactiveAdapter adapter) {
    return (adapter != null && (adapter.isNoValue() || type.resolveGeneric() == Void.clreplaced));
}

private Object getErrors(MethodParameter parameter, BindingContext context) {
    replacedert.isTrue(parameter.getParameterIndex() > 0, "Errors argument must be declared immediately after a model attribute argument");
    int index = parameter.getParameterIndex() - 1;
    MethodParameter attributeParam = MethodParameter.forExecutable(parameter.getExecutable(), index);
    ReactiveAdapter adapter = getAdapterRegistry().getAdapter(attributeParam.getParameterType());
    replacedert.state(adapter == null, "An @ModelAttribute and an Errors/BindingResult argument " + "cannot both be declared with an async type wrapper. " + "Either declare the @ModelAttribute without an async wrapper type or " + "handle a WebExchangeBindException error signal through the async type.");
    ModelAttribute ann = parameter.getParameterAnnotation(ModelAttribute.clreplaced);
    String name = (ann != null && StringUtils.hasText(ann.value()) ? ann.value() : Conventions.getVariableNameForParameter(attributeParam));
    Object errors = context.getModel().asMap().get(BindingResult.MODEL_KEY_PREFIX + name);
    replacedert.state(errors != null, () -> "An Errors/BindingResult argument is expected " + "immediately after the @ModelAttribute argument to which it applies. " + "For @RequestBody and @RequestPart arguments, please declare them with a reactive " + "type wrapper and use its onError operators to handle WebExchangeBindException: " + parameter.getMethod());
    return errors;
}

/**
 * Write a given body to the response with {@link HttpMessageWriter}.
 * @param body the object to write
 * @param bodyParameter the {@link MethodParameter} of the body to write
 * @param actualParam the actual return type of the method that returned the value;
 * could be different from {@code bodyParameter} when processing {@code HttpEnreplacedy}
 * for example
 * @param exchange the current exchange
 * @return indicates completion or error
 * @since 5.0.2
 */
@SuppressWarnings({ "unchecked", "rawtypes", "ConstantConditions" })
protected Mono<Void> writeBody(@Nullable Object body, MethodParameter bodyParameter, @Nullable MethodParameter actualParam, ServerWebExchange exchange) {
    ResolvableType bodyType = ResolvableType.forMethodParameter(bodyParameter);
    ResolvableType actualType = (actualParam != null ? ResolvableType.forMethodParameter(actualParam) : bodyType);
    ReactiveAdapter adapter = getAdapterRegistry().getAdapter(bodyType.resolve(), body);
    Publisher<?> publisher;
    ResolvableType elementType;
    ResolvableType actualElementType;
    if (adapter != null) {
        publisher = adapter.toPublisher(body);
        boolean isUnwrapped = KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(bodyParameter.getContainingClreplaced()) && KotlinDelegate.isSuspend(bodyParameter.getMethod()) && !COROUTINES_FLOW_CLreplaced_NAME.equals(bodyType.toClreplaced().getName());
        ResolvableType genericType = isUnwrapped ? bodyType : bodyType.getGeneric();
        elementType = getElementType(adapter, genericType);
        actualElementType = elementType;
    } else {
        publisher = Mono.justOrEmpty(body);
        actualElementType = body != null ? ResolvableType.forInstance(body) : bodyType;
        elementType = (bodyType.toClreplaced() == Object.clreplaced && body != null ? actualElementType : bodyType);
    }
    if (elementType.resolve() == void.clreplaced || elementType.resolve() == Void.clreplaced) {
        return Mono.from((Publisher<Void>) publisher);
    }
    MediaType bestMediaType = selectMediaType(exchange, () -> getMediaTypesFor(elementType));
    if (bestMediaType != null) {
        String logPrefix = exchange.getLogPrefix();
        if (logger.isDebugEnabled()) {
            logger.debug(logPrefix + (publisher instanceof Mono ? "0..1" : "0..N") + " [" + elementType + "]");
        }
        for (HttpMessageWriter<?> writer : getMessageWriters()) {
            if (writer.canWrite(actualElementType, bestMediaType)) {
                return writer.write((Publisher) publisher, actualType, elementType, bestMediaType, exchange.getRequest(), exchange.getResponse(), Hints.from(Hints.LOG_PREFIX_HINT, logPrefix));
            }
        }
    }
    List<MediaType> mediaTypes = getMediaTypesFor(elementType);
    if (bestMediaType == null && mediaTypes.isEmpty()) {
        return Mono.error(new IllegalStateException("No HttpMessageWriter for " + elementType));
    }
    return Mono.error(new NotAcceptableStatusException(mediaTypes));
}

/**
 * Invoke the method for the given exchange.
 * @param message the current message
 * @param providedArgs optional list of argument values to match by type
 * @return a Mono with the result from the invocation
 */
@SuppressWarnings("KotlinInternalInJava")
public Mono<Object> invoke(Message<?> message, Object... providedArgs) {
    return getMethodArgumentValues(message, providedArgs).flatMap(args -> {
        Object value;
        try {
            Method method = getBridgedMethod();
            ReflectionUtils.makeAccessible(method);
            if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(method.getDeclaringClreplaced())) {
                value = CoroutinesUtils.invokeHandlerMethod(method, getBean(), args);
            } else {
                value = method.invoke(getBean(), args);
            }
        } catch (IllegalArgumentException ex) {
            replacedertTargetBean(getBridgedMethod(), getBean(), args);
            String text = (ex.getMessage() != null ? ex.getMessage() : "Illegal argument");
            return Mono.error(new IllegalStateException(formatInvokeError(text, args), ex));
        } catch (InvocationTargetException ex) {
            return Mono.error(ex.getTargetException());
        } catch (Throwable ex) {
            // Unlikely to ever get here, but it must be handled...
            return Mono.error(new IllegalStateException(formatInvokeError("Invocation failure", args), ex));
        }
        MethodParameter returnType = getReturnType();
        ReactiveAdapter adapter = this.reactiveAdapterRegistry.getAdapter(returnType.getParameterType());
        return (isAsyncVoidReturnType(returnType, adapter) ? Mono.from(adapter.toPublisher(value)) : Mono.justOrEmpty(value));
    });
}

@Override
public Mono<Object> resolveArgument(MethodParameter parameter, BindingContext bindingContext, ServerWebExchange exchange) {
    RequestPart requestPart = parameter.getParameterAnnotation(RequestPart.clreplaced);
    boolean isRequired = (requestPart == null || requestPart.required());
    String name = getPartName(parameter, requestPart);
    Flux<Part> parts = exchange.getMultipartData().flatMapIterable(map -> {
        List<Part> list = map.get(name);
        if (CollectionUtils.isEmpty(list)) {
            if (isRequired) {
                throw getMissingPartException(name, parameter);
            }
            return Collections.emptyList();
        }
        return list;
    });
    if (Part.clreplaced.isreplacedignableFrom(parameter.getParameterType())) {
        return parts.next().cast(Object.clreplaced);
    }
    if (List.clreplaced.isreplacedignableFrom(parameter.getParameterType())) {
        MethodParameter elementType = parameter.nested();
        if (Part.clreplaced.isreplacedignableFrom(elementType.getNestedParameterType())) {
            return parts.collectList().cast(Object.clreplaced);
        } else {
            return decodePartValues(parts, elementType, bindingContext, exchange, isRequired).collectList().cast(Object.clreplaced);
        }
    }
    ReactiveAdapter adapter = getAdapterRegistry().getAdapter(parameter.getParameterType());
    if (adapter != null) {
        MethodParameter elementType = parameter.nested();
        return Mono.just(adapter.fromPublisher(Part.clreplaced.isreplacedignableFrom(elementType.getNestedParameterType()) ? parts : decodePartValues(parts, elementType, bindingContext, exchange, isRequired)));
    }
    return decodePartValues(parts, parameter, bindingContext, exchange, isRequired).next().cast(Object.clreplaced);
}

/**
 * Invoke the method for the given exchange.
 * @param message the current message
 * @param providedArgs optional list of argument values to match by type
 * @return a Mono with the result from the invocation
 */
@SuppressWarnings("KotlinInternalInJava")
public Mono<Object> invoke(Message<?> message, Object... providedArgs) {
    return getMethodArgumentValues(message, providedArgs).flatMap(args -> {
        Object value;
        boolean isSuspendingFunction = false;
        try {
            Method method = getBridgedMethod();
            ReflectionUtils.makeAccessible(method);
            if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(method.getDeclaringClreplaced()) && CoroutinesUtils.isSuspendingFunction(method)) {
                isSuspendingFunction = true;
                value = CoroutinesUtils.invokeSuspendingFunction(method, getBean(), args);
            } else {
                value = method.invoke(getBean(), args);
            }
        } catch (IllegalArgumentException ex) {
            replacedertTargetBean(getBridgedMethod(), getBean(), args);
            String text = (ex.getMessage() != null ? ex.getMessage() : "Illegal argument");
            return Mono.error(new IllegalStateException(formatInvokeError(text, args), ex));
        } catch (InvocationTargetException ex) {
            return Mono.error(ex.getTargetException());
        } catch (Throwable ex) {
            // Unlikely to ever get here, but it must be handled...
            return Mono.error(new IllegalStateException(formatInvokeError("Invocation failure", args), ex));
        }
        MethodParameter returnType = getReturnType();
        Clreplaced<?> reactiveType = (isSuspendingFunction ? value.getClreplaced() : returnType.getParameterType());
        ReactiveAdapter adapter = this.reactiveAdapterRegistry.getAdapter(reactiveType);
        return (isAsyncVoidReturnType(returnType, adapter) ? Mono.from(adapter.toPublisher(value)) : Mono.justOrEmpty(value));
    });
}

/**
 * Process the given reactive return value and decide whether to adapt it
 * to a {@link ResponseBodyEmitter} or a {@link DeferredResult}.
 * @return an emitter for streaming, or {@code null} if handled internally
 * with a {@link DeferredResult}
 */
@Nullable
public ResponseBodyEmitter handleValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mav, NativeWebRequest request) throws Exception {
    replacedert.notNull(returnValue, "Expected return value");
    ReactiveAdapter adapter = this.reactiveRegistry.getAdapter(returnValue.getClreplaced());
    replacedert.state(adapter != null, () -> "Unexpected return value: " + returnValue);
    ResolvableType elementType = ResolvableType.forMethodParameter(returnType).getGeneric();
    Clreplaced<?> elementClreplaced = elementType.toClreplaced();
    Collection<MediaType> mediaTypes = getMediaTypes(request);
    Optional<MediaType> mediaType = mediaTypes.stream().filter(MimeType::isConcrete).findFirst();
    if (adapter.isMultiValue()) {
        if (mediaTypes.stream().anyMatch(MediaType.TEXT_EVENT_STREAM::includes) || ServerSentEvent.clreplaced.isreplacedignableFrom(elementClreplaced)) {
            logExecutorWarning(returnType);
            SseEmitter emitter = new SseEmitter(STREAMING_TIMEOUT_VALUE);
            new SseEmitterSubscriber(emitter, this.taskExecutor).connect(adapter, returnValue);
            return emitter;
        }
        if (CharSequence.clreplaced.isreplacedignableFrom(elementClreplaced)) {
            logExecutorWarning(returnType);
            ResponseBodyEmitter emitter = getEmitter(mediaType.orElse(MediaType.TEXT_PLAIN));
            new TextEmitterSubscriber(emitter, this.taskExecutor).connect(adapter, returnValue);
            return emitter;
        }
        if (mediaTypes.stream().anyMatch(MediaType.APPLICATION_STREAM_JSON::includes)) {
            logExecutorWarning(returnType);
            ResponseBodyEmitter emitter = getEmitter(MediaType.APPLICATION_STREAM_JSON);
            new JsonEmitterSubscriber(emitter, this.taskExecutor).connect(adapter, returnValue);
            return emitter;
        }
    }
    // Not streaming...
    DeferredResult<Object> result = new DeferredResult<>();
    new DeferredResultSubscriber(result, adapter, elementType).connect(adapter, returnValue);
    WebAsyncUtils.getAsyncManager(request).startDeferredResultProcessing(result, mav);
    return null;
}

/**
 * Invoke the method for the given exchange.
 * @param exchange the current exchange
 * @param bindingContext the binding context to use
 * @param providedArgs optional list of argument values to match by type
 * @return a Mono with a {@link HandlerResult}.
 */
public Mono<HandlerResult> invoke(ServerWebExchange exchange, BindingContext bindingContext, Object... providedArgs) {
    return getMethodArgumentValues(exchange, bindingContext, providedArgs).flatMap(args -> {
        Object value;
        try {
            ReflectionUtils.makeAccessible(getBridgedMethod());
            value = getBridgedMethod().invoke(getBean(), args);
        } catch (IllegalArgumentException ex) {
            replacedertTargetBean(getBridgedMethod(), getBean(), args);
            String text = (ex.getMessage() != null ? ex.getMessage() : "Illegal argument");
            return Mono.error(new IllegalStateException(formatInvokeError(text, args), ex));
        } catch (InvocationTargetException ex) {
            return Mono.error(ex.getTargetException());
        } catch (Throwable ex) {
            // Unlikely to ever get here, but it must be handled...
            return Mono.error(new IllegalStateException(formatInvokeError("Invocation failure", args), ex));
        }
        HttpStatus status = getResponseStatus();
        if (status != null) {
            exchange.getResponse().setStatusCode(status);
        }
        MethodParameter returnType = getReturnType();
        ReactiveAdapter adapter = this.reactiveAdapterRegistry.getAdapter(returnType.getParameterType());
        boolean asyncVoid = isAsyncVoidReturnType(returnType, adapter);
        if ((value == null || asyncVoid) && isResponseHandled(args, exchange)) {
            return (asyncVoid ? Mono.from(adapter.toPublisher(value)) : Mono.empty());
        }
        HandlerResult result = new HandlerResult(this, value, returnType, bindingContext);
        return Mono.just(result);
    });
}

@Override
public Mono<Object> resolveArgument(MethodParameter parameter, BindingContext bindingContext, ServerWebExchange exchange) {
    RequestPart requestPart = parameter.getParameterAnnotation(RequestPart.clreplaced);
    boolean isRequired = (requestPart == null || requestPart.required());
    String name = getPartName(parameter, requestPart);
    Flux<Part> parts = exchange.getMultipartData().flatMapMany(map -> {
        List<Part> list = map.get(name);
        if (CollectionUtils.isEmpty(list)) {
            return (isRequired ? Flux.error(getMissingPartException(name, parameter)) : Flux.empty());
        }
        return Flux.fromIterable(list);
    });
    if (Part.clreplaced.isreplacedignableFrom(parameter.getParameterType())) {
        return parts.next().cast(Object.clreplaced);
    }
    if (List.clreplaced.isreplacedignableFrom(parameter.getParameterType())) {
        MethodParameter elementType = parameter.nested();
        if (Part.clreplaced.isreplacedignableFrom(elementType.getNestedParameterType())) {
            return parts.collectList().cast(Object.clreplaced);
        } else {
            return decodePartValues(parts, elementType, bindingContext, exchange, isRequired).collectList().cast(Object.clreplaced);
        }
    }
    ReactiveAdapter adapter = getAdapterRegistry().getAdapter(parameter.getParameterType());
    if (adapter != null) {
        // Mono<Part> or Flux<Part>
        MethodParameter elementType = parameter.nested();
        if (Part.clreplaced.isreplacedignableFrom(elementType.getNestedParameterType())) {
            parts = (adapter.isMultiValue() ? parts : parts.take(1));
            return Mono.just(adapter.fromPublisher(parts));
        }
        // We have to decode the content for each part, one at a time
        if (adapter.isMultiValue()) {
            return Mono.just(decodePartValues(parts, elementType, bindingContext, exchange, isRequired));
        }
    }
    // <T> or Mono<T>
    return decodePartValues(parts, parameter, bindingContext, exchange, isRequired).next().cast(Object.clreplaced);
}

private static boolean isAsyncVoidReturnType(MethodParameter returnType, @Nullable ReactiveAdapter adapter) {
    if (adapter != null && adapter.supportsEmpty()) {
        if (adapter.isNoValue()) {
            return true;
        }
        Type parameterType = returnType.getGenericParameterType();
        if (parameterType instanceof ParameterizedType) {
            ParameterizedType type = (ParameterizedType) parameterType;
            if (type.getActualTypeArguments().length == 1) {
                return Void.clreplaced.equals(type.getActualTypeArguments()[0]);
            }
        }
    }
    return false;
}

@Nullable
private Object findAndRemoveReactiveAttribute(Model model, String attributeName) {
    return model.asMap().entrySet().stream().filter(entry -> {
        if (!entry.getKey().startsWith(attributeName)) {
            return false;
        }
        ReactiveAdapter adapter = getAdapterRegistry().getAdapter(null, entry.getValue());
        if (adapter == null) {
            return false;
        }
        String name = attributeName + ClreplacedUtils.getShortName(adapter.getReactiveType());
        return entry.getKey().equals(name);
    }).findFirst().map(entry -> {
        // Remove since we will be re-inserting the resolved attribute value
        model.asMap().remove(entry.getKey());
        return entry.getValue();
    }).orElse(null);
}

@SuppressWarnings("unchecked")
private Flux<DataBuffer> encodeContent(@Nullable Object content, MethodParameter returnType, DataBufferFactory bufferFactory, @Nullable MimeType mimeType, Map<String, Object> hints) {
    ResolvableType returnValueType = ResolvableType.forMethodParameter(returnType);
    ReactiveAdapter adapter = getAdapterRegistry().getAdapter(returnValueType.resolve(), content);
    Publisher<?> publisher;
    ResolvableType elementType;
    if (adapter != null) {
        publisher = adapter.toPublisher(content);
        boolean isUnwrapped = KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(returnType.getContainingClreplaced()) && KotlinDelegate.isSuspend(returnType.getMethod()) && !COROUTINES_FLOW_CLreplaced_NAME.equals(returnValueType.toClreplaced().getName());
        ResolvableType genericType = isUnwrapped ? returnValueType : returnValueType.getGeneric();
        elementType = getElementType(adapter, genericType);
    } else {
        publisher = Mono.justOrEmpty(content);
        elementType = (returnValueType.toClreplaced() == Object.clreplaced && content != null ? ResolvableType.forInstance(content) : returnValueType);
    }
    if (elementType.resolve() == void.clreplaced || elementType.resolve() == Void.clreplaced) {
        return Flux.from(publisher).cast(DataBuffer.clreplaced);
    }
    Encoder<?> encoder = getEncoder(elementType, mimeType);
    return Flux.from((Publisher) publisher).map(value -> encodeValue(value, elementType, encoder, bufferFactory, mimeType, hints));
}

private int getCardinality(MethodParameter parameter) {
    Clreplaced<?> clazz = parameter.getParameterType();
    ReactiveAdapter adapter = getReactiveAdapterRegistry().getAdapter(clazz);
    if (adapter == null) {
        return clazz.equals(void.clreplaced) ? 0 : 1;
    } else if (parameter.nested().getNestedParameterType().equals(Void.clreplaced)) {
        return 0;
    } else {
        return adapter.isMultiValue() ? 2 : 1;
    }
}

@SuppressWarnings("unchecked")
private Flux<DataBuffer> encodeContent(@Nullable Object content, MethodParameter returnType, DataBufferFactory bufferFactory, @Nullable MimeType mimeType, Map<String, Object> hints) {
    ResolvableType returnValueType = ResolvableType.forMethodParameter(returnType);
    ReactiveAdapter adapter = getAdapterRegistry().getAdapter(returnValueType.resolve(), content);
    Publisher<?> publisher;
    ResolvableType elementType;
    if (adapter != null) {
        publisher = adapter.toPublisher(content);
        boolean isUnwrapped = KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(returnType.getContainingClreplaced()) && KotlinDelegate.isSuspend(returnType.getMethod()) && !COROUTINES_FLOW_CLreplaced_NAME.equals(returnValueType.toClreplaced().getName());
        ResolvableType genericType = isUnwrapped ? returnValueType : returnValueType.getGeneric();
        elementType = getElementType(adapter, genericType);
    } else {
        publisher = Mono.justOrEmpty(content);
        elementType = (returnValueType.toClreplaced() == Object.clreplaced && content != null ? ResolvableType.forInstance(content) : returnValueType);
    }
    if (elementType.resolve() == void.clreplaced || elementType.resolve() == Void.clreplaced) {
        return Flux.from(publisher).cast(DataBuffer.clreplaced);
    }
    Encoder<?> encoder = getEncoder(elementType, mimeType);
    return Flux.from(publisher).map(value -> encodeValue(value, elementType, encoder, bufferFactory, mimeType, hints));
}

/**
 * Add a metadata entry. If called more than once or in addition to route,
 * composite metadata must be in use.
 */
public MetadataEncoder metadata(Object metadata, @Nullable MimeType mimeType) {
    if (this.isComposite) {
        replacedert.notNull(mimeType, "MimeType is required for composite metadata entries.");
    } else if (mimeType == null) {
        mimeType = this.metadataMimeType;
    } else if (!this.metadataMimeType.equals(mimeType)) {
        throw new IllegalArgumentException("Mime type is optional when not using composite metadata, but it was provided " + "and does not match the connection metadata mime type '" + this.metadataMimeType + "'.");
    }
    ReactiveAdapter adapter = this.strategies.reactiveAdapterRegistry().getAdapter(metadata.getClreplaced());
    if (adapter != null) {
        replacedert.isTrue(!adapter.isMultiValue(), "Expected single value: " + metadata);
        metadata = Mono.from(adapter.toPublisher(metadata)).defaultIfEmpty(NO_VALUE);
        this.hasAsyncValues = true;
    }
    this.metadataEntries.add(new MetadataEntry(metadata, mimeType));
    replacedertMetadataEntryCount();
    return this;
}

private Mono<Void> handleResult(HandlerResult handlerResult, BindingContext bindingContext) {
    Object value = handlerResult.getReturnValue();
    if (value != null) {
        ResolvableType type = handlerResult.getReturnType();
        ReactiveAdapter adapter = this.adapterRegistry.getAdapter(type.resolve(), value);
        if (isAsyncVoidType(type, adapter)) {
            return Mono.from(adapter.toPublisher(value));
        }
        String name = getAttributeName(handlerResult.getReturnTypeSource());
        bindingContext.getModel().asMap().putIfAbsent(name, value);
    }
    return Mono.empty();
}

/**
 * Use the configured {@link ReactiveAdapterRegistry} to adapt asynchronous
 * attributes to {@code Mono<T>} or {@code Mono<List<T>>} and then wait to
 * resolve them into actual values. When the returned {@code Mono<Void>}
 * completes, the asynchronous attributes in the model will have been
 * replaced with their corresponding resolved values.
 * @return result a {@code Mono} that completes when the model is ready
 * @since 5.1.8
 */
protected Mono<Void> resolveAsyncAttributes(Map<String, Object> model, ServerWebExchange exchange) {
    List<Mono<?>> asyncAttributes = null;
    for (Map.Entry<String, ?> entry : model.entrySet()) {
        Object value = entry.getValue();
        if (value == null) {
            continue;
        }
        ReactiveAdapter adapter = this.adapterRegistry.getAdapter(null, value);
        if (adapter != null) {
            if (asyncAttributes == null) {
                asyncAttributes = new ArrayList<>();
            }
            String name = entry.getKey();
            if (adapter.isMultiValue()) {
                asyncAttributes.add(Flux.from(adapter.toPublisher(value)).collectList().doOnSuccess(result -> model.put(name, result)));
            } else {
                asyncAttributes.add(Mono.from(adapter.toPublisher(value)).doOnSuccess(result -> {
                    if (result != null) {
                        model.put(name, result);
                        addBindingResult(name, result, model, exchange);
                    } else {
                        model.remove(name);
                    }
                }));
            }
        }
    }
    return asyncAttributes != null ? Mono.when(asyncAttributes) : Mono.empty();
}

/**
 * By default, resolve async attributes supported by the
 * {@link ReactiveAdapterRegistry} to their blocking counterparts.
 * <p>View implementations capable of taking advantage of reactive types
 * can override this method if needed.
 * @return {@code Mono} for the completion of async attributes resolution
 */
protected Mono<Void> resolveAsyncAttributes(Map<String, Object> model) {
    List<String> names = new ArrayList<>();
    List<Mono<?>> valueMonos = new ArrayList<>();
    for (Map.Entry<String, ?> entry : model.entrySet()) {
        Object value = entry.getValue();
        if (value == null) {
            continue;
        }
        ReactiveAdapter adapter = this.adapterRegistry.getAdapter(null, value);
        if (adapter != null) {
            names.add(entry.getKey());
            if (adapter.isMultiValue()) {
                Flux<Object> fluxValue = Flux.from(adapter.toPublisher(value));
                valueMonos.add(fluxValue.collectList().defaultIfEmpty(Collections.emptyList()));
            } else {
                Mono<Object> monoValue = Mono.from(adapter.toPublisher(value));
                valueMonos.add(monoValue.defaultIfEmpty(NO_VALUE));
            }
        }
    }
    if (names.isEmpty()) {
        return Mono.empty();
    }
    return Mono.zip(valueMonos, values -> {
        for (int i = 0; i < values.length; i++) {
            if (values[i] != NO_VALUE) {
                model.put(names.get(i), values[i]);
            } else {
                model.remove(names.get(i));
            }
        }
        return NO_VALUE;
    }).then();
}

private Mono<?> prepareAttributeMono(String attributeName, ResolvableType attributeType, BindingContext context, ServerWebExchange exchange) {
    Object attribute = context.getModel().asMap().get(attributeName);
    if (attribute == null) {
        attribute = findAndRemoveReactiveAttribute(context.getModel(), attributeName);
    }
    if (attribute == null) {
        return createAttribute(attributeName, attributeType.toClreplaced(), context, exchange);
    }
    ReactiveAdapter adapter = getAdapterRegistry().getAdapter(null, attribute);
    if (adapter != null) {
        replacedert.isTrue(!adapter.isMultiValue(), "Data binding only supports single-value async types");
        return Mono.from(adapter.toPublisher(attribute));
    } else {
        return Mono.justOrEmpty(attribute);
    }
}

/**
 * By default, resolve async attributes supported by the
 * {@link ReactiveAdapterRegistry} to their blocking counterparts.
 * <p>View implementations capable of taking advantage of reactive types
 * can override this method if needed.
 * @return {@code Mono} for the completion of async attributes resolution
 */
protected Mono<Void> resolveAsyncAttributes(Map<String, Object> model) {
    List<String> names = new ArrayList<>();
    List<Mono<?>> valueMonos = new ArrayList<>();
    for (Map.Entry<String, ?> entry : model.entrySet()) {
        Object value = entry.getValue();
        if (value == null) {
            continue;
        }
        ReactiveAdapter adapter = this.reactiveAdapterRegistry.getAdapter(null, value);
        if (adapter != null) {
            names.add(entry.getKey());
            if (adapter.isMultiValue()) {
                Flux<Object> fluxValue = Flux.from(adapter.toPublisher(value));
                valueMonos.add(fluxValue.collectList().defaultIfEmpty(Collections.emptyList()));
            } else {
                Mono<Object> monoValue = Mono.from(adapter.toPublisher(value));
                valueMonos.add(monoValue.defaultIfEmpty(NO_VALUE));
            }
        }
    }
    if (names.isEmpty()) {
        return Mono.empty();
    }
    return Mono.zip(valueMonos, values -> {
        for (int i = 0; i < values.length; i++) {
            if (values[i] != NO_VALUE) {
                model.put(names.get(i), values[i]);
            } else {
                model.remove(names.get(i));
            }
        }
        return NO_VALUE;
    }).then();
}

private Mono<?> prepareAttributeMono(String attributeName, ResolvableType attributeType, BindingContext context, ServerWebExchange exchange) {
    Object attribute = context.getModel().asMap().get(attributeName);
    if (attribute == null) {
        attribute = findAndRemoveReactiveAttribute(context.getModel(), attributeName);
    }
    if (attribute == null) {
        return createAttribute(attributeName, attributeType.toClreplaced(), context, exchange);
    }
    ReactiveAdapter adapterFrom = getAdapterRegistry().getAdapter(null, attribute);
    if (adapterFrom != null) {
        replacedert.isTrue(!adapterFrom.isMultiValue(), "Data binding only supports single-value async types");
        return Mono.from(adapterFrom.toPublisher(attribute));
    } else {
        return Mono.justOrEmpty(attribute);
    }
}

@Override
@SuppressWarnings("unchecked")
public Mono<Void> handleResult(ServerWebExchange exchange, HandlerResult result) {
    Mono<Object> valueMono;
    ResolvableType valueType;
    ReactiveAdapter adapter = getAdapter(result);
    if (adapter != null) {
        if (adapter.isMultiValue()) {
            throw new IllegalArgumentException("Multi-value reactive types not supported in view resolution: " + result.getReturnType());
        }
        valueMono = (result.getReturnValue() != null ? Mono.from(adapter.toPublisher(result.getReturnValue())) : Mono.empty());
        valueType = (adapter.isNoValue() ? ResolvableType.forClreplaced(Void.clreplaced) : result.getReturnType().getGeneric());
    } else {
        valueMono = Mono.justOrEmpty(result.getReturnValue());
        valueType = result.getReturnType();
    }
    return valueMono.switchIfEmpty(exchange.isNotModified() ? Mono.empty() : NO_VALUE_MONO).flatMap(returnValue -> {
        Mono<List<View>> viewsMono;
        Model model = result.getModel();
        MethodParameter parameter = result.getReturnTypeSource();
        Locale locale = LocaleContextHolder.getLocale(exchange.getLocaleContext());
        Clreplaced<?> clazz = valueType.toClreplaced();
        if (clazz == Object.clreplaced) {
            clazz = returnValue.getClreplaced();
        }
        if (returnValue == NO_VALUE || clazz == void.clreplaced || clazz == Void.clreplaced) {
            viewsMono = resolveViews(getDefaultViewName(exchange), locale);
        } else if (CharSequence.clreplaced.isreplacedignableFrom(clazz) && !hasModelAnnotation(parameter)) {
            viewsMono = resolveViews(returnValue.toString(), locale);
        } else if (Rendering.clreplaced.isreplacedignableFrom(clazz)) {
            Rendering render = (Rendering) returnValue;
            HttpStatus status = render.status();
            if (status != null) {
                exchange.getResponse().setStatusCode(status);
            }
            exchange.getResponse().getHeaders().putAll(render.headers());
            model.addAllAttributes(render.modelAttributes());
            Object view = render.view();
            if (view == null) {
                view = getDefaultViewName(exchange);
            }
            viewsMono = (view instanceof String ? resolveViews((String) view, locale) : Mono.just(Collections.singletonList((View) view)));
        } else if (Model.clreplaced.isreplacedignableFrom(clazz)) {
            model.addAllAttributes(((Model) returnValue).asMap());
            viewsMono = resolveViews(getDefaultViewName(exchange), locale);
        } else if (Map.clreplaced.isreplacedignableFrom(clazz) && !hasModelAnnotation(parameter)) {
            model.addAllAttributes((Map<String, ?>) returnValue);
            viewsMono = resolveViews(getDefaultViewName(exchange), locale);
        } else if (View.clreplaced.isreplacedignableFrom(clazz)) {
            viewsMono = Mono.just(Collections.singletonList((View) returnValue));
        } else {
            String name = getNameForReturnValue(parameter);
            model.addAttribute(name, returnValue);
            viewsMono = resolveViews(getDefaultViewName(exchange), locale);
        }
        updateBindingContext(result.getBindingContext(), exchange);
        return viewsMono.flatMap(views -> render(views, model.asMap(), exchange));
    });
}

@Override
@SuppressWarnings("unchecked")
public Mono<Void> handleResult(ServerWebExchange exchange, HandlerResult result) {
    Mono<Object> valueMono;
    ResolvableType valueType;
    ReactiveAdapter adapter = getAdapter(result);
    if (adapter != null) {
        if (adapter.isMultiValue()) {
            throw new IllegalArgumentException("Multi-value reactive types not supported in view resolution: " + result.getReturnType());
        }
        valueMono = (result.getReturnValue() != null ? Mono.from(adapter.toPublisher(result.getReturnValue())) : Mono.empty());
        valueType = (adapter.isNoValue() ? ResolvableType.forClreplaced(Void.clreplaced) : result.getReturnType().getGeneric());
    } else {
        valueMono = Mono.justOrEmpty(result.getReturnValue());
        valueType = result.getReturnType();
    }
    return valueMono.switchIfEmpty(exchange.isNotModified() ? Mono.empty() : NO_VALUE_MONO).flatMap(returnValue -> {
        Mono<List<View>> viewsMono;
        Model model = result.getModel();
        MethodParameter parameter = result.getReturnTypeSource();
        Locale locale = LocaleContextHolder.getLocale(exchange.getLocaleContext());
        Clreplaced<?> clazz = valueType.toClreplaced();
        if (clazz == Object.clreplaced) {
            clazz = returnValue.getClreplaced();
        }
        if (returnValue == NO_VALUE || clazz == void.clreplaced || clazz == Void.clreplaced) {
            viewsMono = resolveViews(getDefaultViewName(exchange), locale);
        } else if (CharSequence.clreplaced.isreplacedignableFrom(clazz) && !hasModelAnnotation(parameter)) {
            viewsMono = resolveViews(returnValue.toString(), locale);
        } else if (Rendering.clreplaced.isreplacedignableFrom(clazz)) {
            Rendering render = (Rendering) returnValue;
            HttpStatus status = render.status();
            if (status != null) {
                exchange.getResponse().setStatusCode(status);
            }
            exchange.getResponse().getHeaders().putAll(render.headers());
            model.addAllAttributes(render.modelAttributes());
            Object view = render.view();
            if (view == null) {
                view = getDefaultViewName(exchange);
            }
            viewsMono = (view instanceof String ? resolveViews((String) view, locale) : Mono.just(Collections.singletonList((View) view)));
        } else if (Model.clreplaced.isreplacedignableFrom(clazz)) {
            model.addAllAttributes(((Model) returnValue).asMap());
            viewsMono = resolveViews(getDefaultViewName(exchange), locale);
        } else if (Map.clreplaced.isreplacedignableFrom(clazz) && !hasModelAnnotation(parameter)) {
            model.addAllAttributes((Map<String, ?>) returnValue);
            viewsMono = resolveViews(getDefaultViewName(exchange), locale);
        } else if (View.clreplaced.isreplacedignableFrom(clazz)) {
            viewsMono = Mono.just(Collections.singletonList((View) returnValue));
        } else {
            String name = getNameForReturnValue(parameter);
            model.addAttribute(name, returnValue);
            viewsMono = resolveViews(getDefaultViewName(exchange), locale);
        }
        BindingContext bindingContext = result.getBindingContext();
        updateBindingResult(bindingContext, exchange);
        return viewsMono.flatMap(views -> render(views, model.asMap(), bindingContext, exchange));
    });
}

/**
 * Invoke the method for the given exchange.
 * @param exchange the current exchange
 * @param bindingContext the binding context to use
 * @param providedArgs optional list of argument values to match by type
 * @return a Mono with a {@link HandlerResult}
 */
@SuppressWarnings("KotlinInternalInJava")
public Mono<HandlerResult> invoke(ServerWebExchange exchange, BindingContext bindingContext, Object... providedArgs) {
    return getMethodArgumentValues(exchange, bindingContext, providedArgs).flatMap(args -> {
        Object value;
        try {
            ReflectionUtils.makeAccessible(getBridgedMethod());
            Method method = getBridgedMethod();
            if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(method.getDeclaringClreplaced())) {
                value = CoroutinesUtils.invokeHandlerMethod(method, getBean(), args);
            } else {
                value = method.invoke(getBean(), args);
            }
        } catch (IllegalArgumentException ex) {
            replacedertTargetBean(getBridgedMethod(), getBean(), args);
            String text = (ex.getMessage() != null ? ex.getMessage() : "Illegal argument");
            return Mono.error(new IllegalStateException(formatInvokeError(text, args), ex));
        } catch (InvocationTargetException ex) {
            return Mono.error(ex.getTargetException());
        } catch (Throwable ex) {
            // Unlikely to ever get here, but it must be handled...
            return Mono.error(new IllegalStateException(formatInvokeError("Invocation failure", args), ex));
        }
        HttpStatus status = getResponseStatus();
        if (status != null) {
            exchange.getResponse().setStatusCode(status);
        }
        MethodParameter returnType = getReturnType();
        ReactiveAdapter adapter = this.reactiveAdapterRegistry.getAdapter(returnType.getParameterType());
        boolean asyncVoid = isAsyncVoidReturnType(returnType, adapter);
        if ((value == null || asyncVoid) && isResponseHandled(args, exchange)) {
            return (asyncVoid ? Mono.from(adapter.toPublisher(value)) : Mono.empty());
        }
        HandlerResult result = new HandlerResult(this, value, returnType, bindingContext);
        return Mono.just(result);
    });
}

See More Examples