Test for an Instance of a Class

The Java module provides a Validate type operation that tests whether an object is an instance of a class. This operation can also be configured to accept or reject subtypes of a class. If true, the operation does not modify the payload and the flow continues its execution. Otherwise, the operation throws an error, interrupting the flow, and passes control to the error handler.

Validate Type Operation

This example defines the Person class:

package com.me;

public class Person {

    private String name;
    private Integer age;

    public Person() {
        this.name = "Max Mule";
        this.age = 10;
    }

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
}

This example defines the Employee class that extends the Person class:

package com.me;

public class Employee extends Person {

    private String company;

    public Employee(String name, Integer age, String company) {
        super(name, age);
        this.company = company;
    }
}

The classes used with the Java module must be exported (unless they belong to the default package). If not, the execution fails with a JAVA:CLASS_NOT_FOUND error. See how to export resources.

To check whether an object belongs to a certain class, an instance of the object is needed. This can be done by calling the new operation to create an Employee object and place it in the jane variable:

<java:new class="com.me.Employee"
    constructor="Employee(String, Integer, String)"
    target="jane">
    <java:args>#[{
      name: 'Jane Avi',
      age: 28,
      company: MuleSoft
    }]</java:args>
</java:new>

To check if the object stored in vars.jane belongs to the Employee class, the Validate type operation can be used:

<java:validate-type class="com.me.Employee" instance="#[vars.jane]" />

In this case, the object is an instance of Employee, so the flow continues executing normally, and the payload is not modified.

Check Against Subtypes (Inheritance)

The Validate type operation has the Accept subtypes parameter, which indicates if the operation should accept all subclasses of a class. This parameter can be true, false, or an expression, and it defaults to true if omitted.

Continuing with the previous example, the object in vars.jane belongs to the Employee class which extends the Person class, that is, Employee is a subtype of Person. So executing this example resolves to true and the flow executes normally.

<java:validate-type
    class="com.me.Person"
    instance="#[vars.jane]"
    acceptSubtypes="true" />

Omitting the Accept subtypes parameter defaults its value to true.

The previous code is equivalent to:

<java:validate-type
    class="com.me.Person"
    instance="#[vars.jane]" />

However, when setting the Accept subtypes to false:

<java:validate-type
    class="com.me.Person"
    instance="#[vars.jane]"
    acceptSubtypes="false" />

During execution the operation throws an error, interrupting the flow and passing control to the error handler.

Validate Type Function in DataWeave

In this example, the Java module provides a DataWeave isInstanceOf() function that returns true or false if an object is an instance of a class. Unlike the Validate type operation, it does not throw an error when it evaluates to false.

<choice>
    <when expression="#[Java::isInstanceOf(vars.jane, com.me.Employee)]">
        <flow-ref name="routeToCompany" />
    </when>
</choice>

Test for an Instance of a Class

Validate Type Operation

Check Against Subtypes (Inheritance)

Validate Type Function in DataWeave

See Also