要解决Apache NIFI执行流处理器不会将flowfiles发送到其后续的执行流处理器的问题，您可以检查以下几个方面：

1. 确保连接的关系正确设置：首先，确保在两个执行流处理器之间存在连接，并且连接的关系设置正确。例如，如果您希望一个执行流处理器的输出作为另一个执行流处理器的输入，确保正确地将输出连接到输入。

2. 确保执行流处理器已启用：确保执行流处理器已经启用。您可以通过在NIFI界面上选择执行流处理器并检查其状态来确认它是否已启用。如果执行流处理器未启用，它将不会处理任何flowfile。

3. 检查执行流处理器的配置：检查执行流处理器的配置，确保配置正确设置。某些执行流处理器可能需要配置一些属性，例如目标地址或端口等。确保这些配置正确设置。

4. 检查执行流处理器的逻辑：检查执行流处理器的逻辑，确保它按预期工作。可能有一些条件或逻辑错误导致flowfiles未发送到后续的执行流处理器。

以下是一个示例代码，展示了如何使用Apache NIFI执行流处理器的Java API创建一个简单的流处理器，并将flowfiles发送到其后续的执行流处理器：

import org.apache.nifi.processor.ProcessContext;
import org.apache.nifi.processor.ProcessSession;
import org.apache.nifi.processor.Relationship;
import org.apache.nifi.processor.exception.ProcessException;
import org.apache.nifi.processor.AbstractProcessor;
import org.apache.nifi.processor.util.StandardValidators;
import org.apache.nifi.annotation.behavior.InputRequirement;
import org.apache.nifi.annotation.behavior.InputRequirement.Requirement;
import org.apache.nifi.annotation.behavior.WritesAttributes;
import org.apache.nifi.annotation.behavior.WritesAttribute;
import org.apache.nifi.annotation.documentation.CapabilityDescription;
import org.apache.nifi.annotation.documentation.Tags;
import org.apache.nifi.components.PropertyDescriptor;
import org.apache.nifi.flowfile.FlowFile;
import org.apache.nifi.flowfile.attributes.CoreAttributes;

import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

@Tags({"example"})
@CapabilityDescription("A simple example processor that sends flowfiles to its downstream processors")
@InputRequirement(Requirement.INPUT_REQUIRED)
@WritesAttributes({
    @WritesAttribute(attribute = "example.attribute", description = "Example attribute added by the processor")
})
public class ExampleProcessor extends AbstractProcessor {

    public static final PropertyDescriptor EXAMPLE_PROPERTY = new PropertyDescriptor
        .Builder().name("Example Property")
        .description("Example property for the processor")
        .required(true)
        .addValidator(StandardValidators.NON_EMPTY_VALIDATOR)
        .build();

    public static final Relationship SUCCESS = new Relationship.Builder()
        .name("success")
        .description("Success relationship")
        .build();

    public static final Relationship FAILURE = new Relationship.Builder()
        .name("failure")
        .description("Failure relationship")
        .build();

    private List descriptors;

    private Set relationships;

    @Override
    protected void init(final ProcessorInitializationContext context) {
        final List descriptors = Arrays.asList(EXAMPLE_PROPERTY);
        this.descriptors = Collections.unmodifiableList(descriptors);

        final Set relationships = new HashSet<>();
        relationships.add(SUCCESS);
        relationships.add(FAILURE);
        this.relationships = Collections.unmodifiableSet(relationships);
    }

    @Override
    public Set getRelationships() {
        return this.relationships;
    }

    @Override
    public final List getSupportedPropertyDescriptors() {
        return descriptors;
    }

    @Override
    public void onTrigger(final ProcessContext context, final ProcessSession session) throws ProcessException {
        FlowFile flowFile = session.get();
        if (flowFile == null) {
            return;
        }

        try {
            // Do some processing on the flowfile
            // Add an attribute to the flowfile
            flowFile = session.putAttribute(flowFile, "example.attribute", "example value");

            // Send flowfile to success relationship
            session.transfer(flowFile, SUCCESS);
            session.commit();
        } catch (Exception e) {
            getLogger().error("Failed to process flowfile", e);
            session.transfer(flowFile, FAILURE);
            session.commit();
        }
    }
}