异步完成创建的Java对象 - 对象在构造函数完成后的某个时间准备就绪

Question

I have to wrap an proprietary java api into something more useful. The central class is a "client" object The signature is something like this:

public class ProprietaryClient {

    private final IEvents eventHandler;
    private Object one;
    private Object two;

    public ProprietaryClient(ProprietaryClient.IEvents eventHandler){
        this.eventHandler = eventHandler;
    }

    //returns immediately
    public void connect(String url){
        //doing nasty stuff that triigers
        //on success
        //will be called from somewhere at anytime
        // eventHandler.onStateChange( State.CONNECTED );
    }

    //returns immediately
    public void login(String user, String password){
        //doing nasty stuff that sets fields one and two
        //will be called from somewhere at anytime
        //eventHandler.onStateChange( State.LOGGED_IN );
        //eventHandler.onLogin( one, two );
    }

    public interface IEvents {

        void onStateChange(State state);

        void onLogin(Object one, Object two);
    }

    public enum State{
        CONNECTED,
        LOGGED_IN,
        UNKNOWN;
    }
}

This Object is only useful in state "LOGGED_IN" but there is no getter for this field. The only way to know if the object is usable is:

1. call connect
2. wait for state change to CONNECT
3. call login
4. wait for state change to LOGGED_IN (or call of onLogin)

I want to wrap this into a class that does connecting and login in constructor and tells the user if it is ready. My idea is to have a method that returns a CompletableFuture or Future: This is what i have so far. the stuff with the events is working this way. The implementation of IEvents wraps all evants into messages that are identified by user (this part is working). But how to create and maintain the CompletableFuture based on arriving events (parts with ///????) Is there a way to create my own future that gets ready if events arrived or correct condition is met?

public class MyClient implements Client, MessageHandler {


    private final String password;
    private final IEvents eventHandler;
    private final SubscribableChannel eventBus;
    private final String user;
    private final ProprietaryClient propClient;

    public SikomClient( String user, String password, IEvents eventHandler, SubscribableChannel eventBus) {
        this.eventHandler = checkNotNull( eventHandler );
        this.eventBus = checkNotNull( eventBus );
        eventBus.subscribe( this );
        this.password = password;
        this.user = user;
        propClient = new ProprietaryClient(eventHandler);
        ///????
        propClient.connect("url");
        //have to wait until message received and state is "CONNECT"
        propClient.login(user, password);

    }

    public CompletableFuture<Boolean> amIready(){
        //???
    }

    @Override
    public void handleMessage( Message<?> message ) throws MessagingException {
        if( message instanceof OnClientStateMessage && belongsToMe( message )){
            // ????
        } else if( message instanceof OnLoginMessage && belongsToMe( message )) {
            // ????
            //complete CompletableFuture with true
        }
    }

    private boolean belongsToMe(Message<?> message){
        return ((AbstractStringJsonMessage) message).getUserId().equals( user );
    }
}

Or is there a better way to solve this without "Future". I want to give the caller the responsibility how long to wait but my Class should maintain the state and know about it.

Answer 1

The solution is rather simple. Now i understand "CompletableFuture" better.

i added a login method, a field with Completable future an a getter for it:

private CompletableFuture<ReturnCode> loggedIn = new CompletableFuture<>();
...
private void login() {
    //as per sikom settings each user gets a fixed workplace identified by user name
    if( loggedIn.isDone() ) {
        loggedIn = new CompletableFuture<>();
    }
    propClient.login( user, user, password, 0 );
}

public CompletableFuture<ReturnCode> loggedIn() {
    return loggedIn;
}

My handleMessage does this:

public void handleMessage( Message<?> message ) throws MessagingException {
    if( message instanceof OnClientStateMessage && belongsToMe( message ) ) {
        state = ( (OnClientStateMessage) message ).getState();
        if( state.equals( ClientState.CONNECT ) ) {
            login();
        }
    } else if( message instanceof OnLoginMessage && belongsToMe( message ) ) {
        ReturnCode rc = ( (OnLoginMessage) message ).getRc();
        loggedIn.complete( rc );
    }
}

I just manually complete the future manually if the message arrives (since it has no task attached get would never return).

A user of this class will instantiate it and could instantly call loggedIn. The calle can decide how long to wait for loggedIn.get().

Don't know if its a good idea: The class it self could extend CompletableFuture and could complete itself?!