flowable/flowable-engine · error · FlowableException

Field type ' ' with more than one parameter is not supported

Error message

Field type '%s' with more than one parameter is not supported: %S

What it means

During WSDL import in the flowable-cxf module, the generated JAXB class's field type is a generic JClass with more than one type parameter (e.g. Map<K,V>). The importer only knows how to unwrap a single type parameter into fieldParameterClass, so it aborts. This is a deliberate unsupported-feature guard in _importFields.

Solutions

1. Change the WSDL/XSD schema so the field is not a two-parameter generic (e.g. avoid xsd:key/value or map-style types); use a list of key-value complexTypes instead.
2. Adjust JAXB binding customizations (jaxb:bindings) so the field maps to a parameterless or single-parameter type.
3. If you need Map support, patch _importFields to handle multiple parameters (e.g. use the erasure type and skip fieldParameterClass).

Example fix

// before (XSD producing Map<String,String>)
<xsd:element name="attributes"><xsd:complexType><xsd:sequence>...</xsd:sequence></xsd:complexType></xsd:element>
// after
<xsd:element name="attributes" type="tns:attributeList"/>
<xsd:complexType name="attributeList"><xsd:sequence><xsd:element name="entry" type="tns:entry" maxOccurs="unbounded"/></xsd:sequence></xsd:complexType>

// Before importing, check WSDL types don't map to multi-parameter generics (e.g. avoid xsd:key/xsd:any with Map mappings)
JClass fieldType = ...; // as resolved during import
if (fieldType != null && fieldType.getTypeParameters().size() > 1) {
    throw new IllegalArgumentException("Unsupported field type (2+ type params): " + fieldType.name());
}

try { importer.importFields(); } catch (FlowableException e) { if (e.getMessage().contains("more than one parameter")) { /* fix schema */ } else { throw e; } }

When it happens

Trigger: Importing a WSDL whose complexType contains a field that resolves to a Java generic type with two type parameters (e.g. java.util.Map), via CxfWSDLImporter.importFields / _importFields.

Common situations: WSDL schemas using xsd elements mapped to Map-like JAXB types, custom JAXB bindings producing generics with two parameters, or migrating legacy Apache ODE/CXF WSDL imports to Flowable.

Understand the failure class

Background: UnsupportedOperationException and "is not supported" errors: when a library deliberately refuses a call — this error's family across 30 libraries.

Related errors

• Field type ' ' with more than one parameter is not supported
• An error occurs creating a web-service client for WSDL '" +…
• Could not find importer class for type " +…
• Error importing ' ' as
• Error importing ' ' as ' ' (import location, import type)

AI-assisted analysis of flowable/flowable-engine@d6d39ce1c6 (2026-09-11). Data as JSON: /api/errors/13488d08d23fa1e3. Report an issue: GitHub.

Appendix: source

Thrown at modules/flowable-cxf/src/main/java/org/flowable/engine/impl/webservice/CxfWSDLImporter.java:234

            _importFields((JDefinedClass) parentClass, index, structure);
        }
        for (Entry<String, JFieldVar> entry : theClass.fields().entrySet()) {

            String fieldName = entry.getKey();
            if (fieldName.startsWith("_")) {
                if (!JJavaName.isJavaIdentifier(fieldName.substring(1))) {
                    fieldName = fieldName.substring(1); // it was prefixed with '_' so we should use the original name.
                }
            }

            final JType fieldType = entry.getValue().type();
            final Class<?> fieldClass = ReflectUtil.loadClass(fieldType.boxify().erasure().fullName());
            final Class<?> fieldParameterClass;
            if (fieldType instanceof JClass) {
                final JClass fieldClassType = (JClass) fieldType;
                final List<JClass> fieldTypeParameters = fieldClassType.getTypeParameters();
                if (fieldTypeParameters.size() > 1) {
                    throw new FlowableException(
                            String.format("Field type '%s' with more than one parameter is not supported: %S",
                                    fieldClassType, fieldTypeParameters));
                } else if (fieldTypeParameters.isEmpty()) {
                    fieldParameterClass = null;
                } else {
                    final JClass fieldParameterType = fieldTypeParameters.get(0);

                    // Hack because JClass.fullname() doesn't return the right class fullname for a nested class to be
                    // loaded from classloader. It should be contain "$" instead of "." as separator
                    boolean isFieldParameterTypeNeestedClass = false;
                    final Iterator<JDefinedClass> theClassNeestedClassIt = theClass.classes();
                    while (theClassNeestedClassIt.hasNext() && !isFieldParameterTypeNeestedClass) {
                        final JDefinedClass neestedType = theClassNeestedClassIt.next();
                        if (neestedType.name().equals(fieldParameterType.name())) {
                            isFieldParameterTypeNeestedClass = true;
                        }
                    }
                    if (isFieldParameterTypeNeestedClass) {

View on GitHub (pinned to d6d39ce1c6)