在BDD中，可以使用各种工具和技术来捕获系统交互，包括持久化、API调用、通知等。以下是一个示例解决方案，使用Cucumber和Mockito来模拟系统交互。

首先，我们需要定义一个Cucumber特性文件，描述系统的行为和交互。例如，我们可以创建一个名为“system_interaction.feature”的文件，内容如下：

Feature: System Interaction
  Scenario: Persist data to database
    Given a user with name "John"
    When the user is saved to the database
    Then the user should be persisted in the database

  Scenario: Call external API
    Given a user with name "John"
    When the user is sent to the API
    Then the API should be called with the user data

  Scenario: Send notification
    Given a user with name "John"
    When a notification is sent to the user
    Then the user should receive the notification

接下来，我们可以创建一个名为“SystemInteractionSteps”的Cucumber步骤定义类，用于实现步骤中的操作。在这个类中，我们可以使用Mockito来模拟系统交互。

import cucumber.api.java.en.Given;
import cucumber.api.java.en.Then;
import cucumber.api.java.en.When;
import org.mockito.Mockito;

public class SystemInteractionSteps {
    private UserRepository userRepository;
    private ExternalApi externalApi;
    private NotificationService notificationService;
    private User user;

    @Given("^a user with name \"([^\"]*)\"$")
    public void createUser(String name) {
        user = new User(name);
    }

    @When("^the user is saved to the database$")
    public void saveUserToDatabase() {
        userRepository = Mockito.mock(UserRepository.class);
        userRepository.save(user);
    }

    @Then("^the user should be persisted in the database$")
    public void verifyUserPersisted() {
        Mockito.verify(userRepository).save(user);
    }

    @When("^the user is sent to the API$")
    public void sendUserToApi() {
        externalApi = Mockito.mock(ExternalApi.class);
        externalApi.sendUser(user);
    }

    @Then("^the API should be called with the user data$")
    public void verifyApiCalledWithUserData() {
        Mockito.verify(externalApi).sendUser(user);
    }

    @When("^a notification is sent to the user$")
    public void sendNotificationToUser() {
        notificationService = Mockito.mock(NotificationService.class);
        notificationService.sendNotification(user);
    }

    @Then("^the user should receive the notification$")
    public void verifyUserReceivedNotification() {
        Mockito.verify(notificationService).sendNotification(user);
    }
}

在上面的代码中，我们使用了Mockito来创建模拟对象，并使用该对象来验证交互是否发生。

最后，我们需要实现UserRepository、ExternalApi和NotificationService接口的具体实现。这些实现可以是真实的，也可以是其他的模拟对象，具体取决于您的需求。

public interface UserRepository {
    void save(User user);
}

public interface ExternalApi {
    void sendUser(User user);
}

public interface NotificationService {
    void sendNotification(User user);
}

通过上述步骤，我们就可以使用BDD和模拟对象来捕捉系统交互，包括持久化、API调用、通知等。这样可以帮助我们更好地理解和验证系统的行为。