java – Finding the right design pattern for 2 services to communicate with loose coupling between them

I am having a small confusion in the below implementation, whether to choose the mediator or the Observer or to use event bus guava event bus.

Below is the logic

public class A {

    public D Save(D data) {

        //validate the data    
        //generate a text file for the data and push to git    
        //invoke service B to process further, like creating a job for this "data"    
        return data;

    }
//similar logic for Update
    public int Delete(int dataId) {
        //delete the data in the db
        // delete the text file
        // invoke service B to delete job created for this "dataId"
    }
}

public class B {

    public int CreateJob(D data) {

        //validate the data for creating the job
        // prepare data for creating the job
        // API call to create the job
        return jobid;
    }

    public int DeleteJob(int jobId) {

        //validate the jobid
        // prepare data for deleting the job
        // API call to delete the job
        return success or failure;
    }
}

I felt like adding a mediator or even thought of having these steps processed through handlers like logic. Also i read about google guava which supports event bus so that I can raise events as when the steps are completed so that the events are handled by the respective handlers and are processed. (This approach is very loosely coupled, and little hard to trace while debugging, but implementation has less dependencies). At a later point of time when these services get split up as microservices, the event bus approach would prove to be a good option (IMHO).

The use of mediators help but there again we have dependency to mediator and testing becomes little difficult as we have a mediator additionally to test.

Kindly suggest the right approach.