class DelegatingMethodParameter extends MethodParameter {

	/**
	 * The constant LOGGER.
	 */
	private static final Logger LOGGER = LoggerFactory.getLogger(DelegatingMethodParameter.class);

	/**
	 * The Delegate.
	 */
	private final MethodParameter delegate;

	/**
	 * The Additional parameter annotations.
	 */
	private final Annotation[] additionalParameterAnnotations;

	/**
	 * The Parameter name.
	 */
	private final String parameterName;

	/**
	 * The Is parameter object.
	 */
	private final boolean isParameterObject;

	/**
	 * The Is not required.
	 */
	private boolean isNotRequired;

	/**
	 * Instantiates a new Delegating method parameter.
	 *
	 * @param delegate the delegate
	 * @param parameterName the parameter name
	 * @param additionalParameterAnnotations the additional parameter annotations
	 * @param isParameterObject the is parameter object
	 * @param isNotRequired the is required
	 */
	DelegatingMethodParameter(MethodParameter delegate, String parameterName, Annotation[] additionalParameterAnnotations, boolean isParameterObject, boolean isNotRequired) {
		super(delegate);
		this.delegate = delegate;
		this.additionalParameterAnnotations = additionalParameterAnnotations;
		this.parameterName = parameterName;
		this.isParameterObject = isParameterObject;
		this.isNotRequired = isNotRequired;
	}

	/**
	 * Customize method parameter [ ].
	 *
	 * @param pNames the p names
	 * @param parameters the parameters
	 * @param optionalDelegatingMethodParameterCustomizer the optional delegating method parameter customizer
	 * @param defaultFlatParamObject the default flat param object
	 * @return the method parameter [ ]
	 */
	public static MethodParameter[] customize(String[] pNames, MethodParameter[] parameters,
			Optional<DelegatingMethodParameterCustomizer> optionalDelegatingMethodParameterCustomizer, boolean defaultFlatParamObject) {<FILL_FUNCTION_BODY>}

	/**
	 * Return a variant of this {@code MethodParameter} which refers to the
	 * given containing class.
	 * @param methodParameter the method parameter
	 * @param containingClass a specific containing class (potentially a subclass of the declaring class, e.g. substituting a type variable) A copy of spring withContainingClass, to keep compatibility with older spring versions
	 * @return the method parameter
	 * @see #getParameterType() #getParameterType()
	 */
	public static MethodParameter changeContainingClass(MethodParameter methodParameter, @Nullable Class<?> containingClass) {
		MethodParameter result = methodParameter.clone();
		try {
			Field containingClassField = FieldUtils.getDeclaredField(result.getClass(), "containingClass", true);
			containingClassField.set(result, containingClass);
			Field parameterTypeField = FieldUtils.getDeclaredField(result.getClass(), "parameterType", true);
			parameterTypeField.set(result, null);
		}
		catch (IllegalAccessException e) {
			LOGGER.warn(e.getMessage());
		}
		return result;
	}

	@Override
	@NonNull
	public Annotation[] getParameterAnnotations() {
		return ArrayUtils.addAll(delegate.getParameterAnnotations(), additionalParameterAnnotations);
	}

	@Override
	public String getParameterName() {
		return parameterName;
	}

	@Override
	public Method getMethod() {
		return delegate.getMethod();
	}

	@Override
	public Constructor<?> getConstructor() {
		return delegate.getConstructor();
	}

	@Override
	public Class<?> getDeclaringClass() {
		return delegate.getDeclaringClass();
	}

	@Override
	public Member getMember() {
		return delegate.getMember();
	}

	@Override
	public AnnotatedElement getAnnotatedElement() {
		return delegate.getAnnotatedElement();
	}

	@Override
	public Executable getExecutable() {
		return delegate.getExecutable();
	}

	@Override
	public MethodParameter withContainingClass(Class<?> containingClass) {
		return delegate.withContainingClass(containingClass);
	}

	@Override
	public Class<?> getContainingClass() {
		return delegate.getContainingClass();
	}

	@Override
	public Class<?> getParameterType() {
		return delegate.getParameterType();
	}

	@Override
	public Type getGenericParameterType() {
		return delegate.getGenericParameterType();
	}

	@Override
	public Class<?> getNestedParameterType() {
		return delegate.getNestedParameterType();
	}

	@Override
	public Type getNestedGenericParameterType() {
		return delegate.getNestedGenericParameterType();
	}

	@Override
	public void initParameterNameDiscovery(ParameterNameDiscoverer parameterNameDiscoverer) {
		delegate.initParameterNameDiscovery(parameterNameDiscoverer);
	}

	/**
	 * Is not required boolean.
	 *
	 * @return the boolean
	 */
	public boolean isNotRequired() {
		return isNotRequired;
	}

	/**
	 * Sets not required.
	 *
	 * @param notRequired the not required
	 */
	public void setNotRequired(boolean notRequired) {
		isNotRequired = notRequired;
	}

	@Override
	public boolean equals(Object o) {
		if (this == o) return true;
		if (o == null || getClass() != o.getClass()) return false;
		if (!super.equals(o)) return false;
		DelegatingMethodParameter that = (DelegatingMethodParameter) o;
		return Objects.equals(delegate, that.delegate) &&
				Arrays.equals(additionalParameterAnnotations, that.additionalParameterAnnotations) &&
				Objects.equals(parameterName, that.parameterName);
	}

	@Override
	public int hashCode() {
		int result = Objects.hash(super.hashCode(), delegate, parameterName);
		result = 31 * result + Arrays.hashCode(additionalParameterAnnotations);
		return result;
	}

	/**
	 * Is parameter object boolean.
	 *
	 * @return the boolean
	 */
	public boolean isParameterObject() {
		return isParameterObject;
	}

}

		List<MethodParameter> explodedParameters = new ArrayList<>();
		for (int i = 0; i < parameters.length; ++i) {
			MethodParameter p = parameters[i];
			Class<?> paramClass = AdditionalModelsConverter.getParameterObjectReplacement(p.getParameterType());

			boolean hasFlatAnnotation = p.hasParameterAnnotation(ParameterObject.class) || AnnotatedElementUtils.isAnnotated(paramClass, ParameterObject.class);
			boolean hasNotFlatAnnotation = Arrays.stream(p.getParameterAnnotations())
					.anyMatch(annotation -> Arrays.asList(RequestBody.class, RequestPart.class).contains(annotation.annotationType()));
			if (!MethodParameterPojoExtractor.isSimpleType(paramClass)
				&& (hasFlatAnnotation || (defaultFlatParamObject && !hasNotFlatAnnotation && !AbstractRequestService.isRequestTypeToIgnore(paramClass)))) {
				MethodParameterPojoExtractor.extractFrom(paramClass).forEach(methodParameter -> {
					optionalDelegatingMethodParameterCustomizer.ifPresent(customizer -> customizer.customize(p, methodParameter));
					explodedParameters.add(methodParameter);
				});
			}
			else {
				String name = pNames != null ? pNames[i] : p.getParameterName();
				explodedParameters.add(new DelegatingMethodParameter(p, name, null, false, false));
			}
		}
		return explodedParameters.toArray(new MethodParameter[0]);
	
<methods>public void <init>(org.springframework.core.MethodParameter) ,public void <init>(java.lang.reflect.Method, int) ,public void <init>(Constructor<?>, int) ,public void <init>(java.lang.reflect.Method, int, int) ,public void <init>(Constructor<?>, int, int) ,public org.springframework.core.MethodParameter clone() ,public void decreaseNestingLevel() ,public boolean equals(java.lang.Object) ,public static org.springframework.core.MethodParameter forExecutable(java.lang.reflect.Executable, int) ,public static org.springframework.core.MethodParameter forFieldAwareConstructor(Constructor<?>, int, java.lang.String) ,public static org.springframework.core.MethodParameter forMethodOrConstructor(java.lang.Object, int) ,public static org.springframework.core.MethodParameter forParameter(java.lang.reflect.Parameter) ,public java.lang.reflect.AnnotatedElement getAnnotatedElement() ,public Constructor<?> getConstructor() ,public Class<?> getContainingClass() ,public Class<?> getDeclaringClass() ,public java.lang.reflect.Executable getExecutable() ,public java.lang.reflect.Type getGenericParameterType() ,public java.lang.reflect.Member getMember() ,public java.lang.reflect.Method getMethod() ,public A getMethodAnnotation(Class<A>) ,public java.lang.annotation.Annotation[] getMethodAnnotations() ,public java.lang.reflect.Type getNestedGenericParameterType() ,public Class<?> getNestedParameterType() ,public int getNestingLevel() ,public java.lang.reflect.Parameter getParameter() ,public A getParameterAnnotation(Class<A>) ,public java.lang.annotation.Annotation[] getParameterAnnotations() ,public int getParameterIndex() ,public java.lang.String getParameterName() ,public Class<?> getParameterType() ,public java.lang.Integer getTypeIndexForCurrentLevel() ,public java.lang.Integer getTypeIndexForLevel(int) ,public boolean hasMethodAnnotation(Class<A>) ,public boolean hasParameterAnnotation(Class<A>) ,public boolean hasParameterAnnotations() ,public int hashCode() ,public void increaseNestingLevel() ,public void initParameterNameDiscovery(org.springframework.core.ParameterNameDiscoverer) ,public boolean isOptional() ,public org.springframework.core.MethodParameter nested() ,public org.springframework.core.MethodParameter nested(java.lang.Integer) ,public org.springframework.core.MethodParameter nestedIfOptional() ,public void setTypeIndexForCurrentLevel(int) ,public java.lang.String toString() ,public org.springframework.core.MethodParameter withContainingClass(Class<?>) ,public org.springframework.core.MethodParameter withTypeIndex(int) <variables>private static final java.lang.annotation.Annotation[] EMPTY_ANNOTATION_ARRAY,private volatile Class<?> containingClass,private final java.lang.reflect.Executable executable,private volatile java.lang.reflect.Type genericParameterType,private volatile org.springframework.core.MethodParameter nestedMethodParameter,private int nestingLevel,private volatile java.lang.reflect.Parameter parameter,private volatile java.lang.annotation.Annotation[] parameterAnnotations,private final int parameterIndex,volatile java.lang.String parameterName,private volatile org.springframework.core.ParameterNameDiscoverer parameterNameDiscoverer,private volatile Class<?> parameterType,Map<java.lang.Integer,java.lang.Integer> typeIndexesPerLevel