Rx java RxJava在其他人完成后返回观察器

我是RxJava新手，我正在尝试创建一个函数，该函数返回从AMQP队列接收消息的观察者，我需要确保有到服务器的连接，并且创建了队列，这就是我所拥有的：

    public Observable<String> consume(String queueName) {
        Observable<String> consume = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> sub) {
                try {
                    Consumer consumer = new DefaultConsumer(channel) {
                        @Override
                        public void handleDelivery(String consumerTag, Envelope envelope,
                                AMQP.BasicProperties properties, byte[] body) throws IOException {
                            String message = new String(body, "UTF-8");
                            sub.onNext(message);
                            // sub.onCompleted();
                        }
                    };
                    channel.basicConsume(queueName, true, consumer);
                } catch (IOException e) {
                    sub.onError(e);
                }

            }
        });
        return Observable.zip(connect(), queueDeclare(queueName), consume, (conn, queue, consumer) -> {
            return consumer;
        });
    }
}

server.consume(QUEUE_NAME).subscribe(c -> {
        System.out.println("Received " + c);
    }

但是我想有更好的方法，特别是因为我想创建一个函数来实现这一点

提前谢谢

编辑：

这也有效，而且更干净：

public Observable<String> consume(String queueName) {
    return connect().flatMap(conn -> {
        return queueDeclare(queueName);
    }).flatMap(queue -> {
        return Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> sub) {
                try {
                    Consumer consumer = new DefaultConsumer(channel) {
                        @Override
                        public void handleDelivery(String consumerTag, Envelope envelope,
                                AMQP.BasicProperties properties, byte[] body) throws IOException {
                            String message = new String(body, "UTF-8");
                            sub.onNext(message);
                            // sub.onCompleted();
                        }
                    };
                    channel.basicConsume(queueName, true, consumer);
                } catch (IOException e) {
                    sub.onError(e);
                }
            }
        });
    });
}
}

公共可观察消费（字符串queueName）{
返回connect（）.flatMap（连接->{
返回queueDeclare（queueName）；
}).flatMap（队列->{
返回Observable.create（newobservable.OnSubscribe（）{
@凌驾
public void call（subscriber）如果您返回一个可观察的，您需要能够处理多个订阅（然后会发生什么，您是否将每个传入消息多播到所有订阅服务器？）和取消订阅（您是否保持连接打开？您是否关闭它并在下一次订阅时重新打开它？）。连接应始终保持打开状态，因为它应侦听传入的消息，至于多个订阅，我不知道，
public Observable<String> consume(String queueName) {
    return connect().flatMap(conn -> {
        return queueDeclare(queueName);
    }).flatMap(queue -> {
        return Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> sub) {
                try {
                    Consumer consumer = new DefaultConsumer(channel) {
                        @Override
                        public void handleDelivery(String consumerTag, Envelope envelope,
                                AMQP.BasicProperties properties, byte[] body) throws IOException {
                            String message = new String(body, "UTF-8");
                            sub.onNext(message);
                            // sub.onCompleted();
                        }
                    };
                    channel.basicConsume(queueName, true, consumer);
                } catch (IOException e) {
                    sub.onError(e);
                }
            }
        });
    });
}
}