Android GraphQL:配置订阅管理器

我是GraphQL新手，所以我想在开始自己的项目之前测试一些东西。作为一个测试数据库，我在应用程序中使用测试数据库和服务以及库。我几乎完成了

查询

和

变异

。作为下一步，我想对

subscription

做点什么。因此，我的graphql订阅看起来像：

subscription observer {
  post {
    mutation
    node {
      id
      title
      text
      isPublished
    }
  }
}

由于Apollo Android库基于我的graphql代码生成了一些类，我尝试使用

observer

订阅，如下所示：

Interceptor interceptor = chain -> chain.proceed(chain.request());

OkHttpClient ohc = new OkHttpClient.Builder().addInterceptor(interceptor).build();

ApolloClient mApolloClient = ApolloClient.builder().serverUrl(ENDPOINT).okHttpClient(ohc).build();
mApolloClient.subscribe(ObserverSubscription.builder().build()).execute(new ApolloSubscriptionCall.Callback<ObserverSubscription.Data>() {
    @Override
    public void onResponse(@NotNull Response<ObserverSubscription.Data> response) {
        // do work here
    }

    @Override
    public void onFailure(@NotNull ApolloException e) {
        // catch exception
    }

    @Override
    public void onCompleted() {
        // some other stuff goes here
    }
});

Interceptor-Interceptor=chain->chain.procedue（chain.request（））；
OkHttpClient ohc=新建OkHttpClient.Builder（）.addInterceptor（interceptor.build（）；
ApolloClient mApolloClient=ApolloClient.builder（）.serverUrl（端点）.okHttpClient（ohc.build（）；
mApolloClient.subscribe（ObserverSubscription.builder（）.build（））.execute（new ApolloSubscriptionCall.Callback（））{
@凌驾
public void onResponse（@NotNull Response）{
//你在这里工作吗
}
@凌驾
失败时公共无效（@NotNull-e）{
//捕获异常
}
@凌驾
未完成的公共无效（）{
//这里还有其他东西
}
});

执行此代码时，引发以下异常：

java.lang.IllegalStateException:未配置订阅管理器

此消息来自，并与直接相关

---

我的问题是，有没有办法在android应用程序中使用apollo android进行订阅？

首先，很抱歉回答得太晚，我刚刚遇到了同样的问题，使用了许多网站的信息，我成功订阅了

配置客户端时，需要定义一些额外的参数：

首先是规范化缓存，对于这一个，我使用默认配置：

 NormalizedCacheFactory normalizedCacheFactory(){
        return new LruNormalizedCacheFactory(EvictionPolicy.builder().maxSizeBytes(10 * 1024).build());
    }

和cacheKeyResolver：

CacheKeyResolver cacheKeyResolver(){
        return new CacheKeyResolver() {
            @Nonnull
            @Override
            public CacheKey fromFieldRecordSet(@Nonnull ResponseField field, @Nonnull Map<String, Object> recordSet) {
                if (recordSet.containsKey("id")) {
                    String id = (String) recordSet.get("id");
                    return CacheKey.from(id);
                }
                return CacheKey.NO_KEY;
            }

            @Nonnull @Override
            public CacheKey fromFieldArguments(@Nonnull ResponseField field, @Nonnull Operation.Variables variables) {
                return CacheKey.NO_KEY;
            }
        };
    }

CacheKeyResolver CacheKeyResolver（）{
返回新的CacheKeyResolver（）{
@非空
@凌驾
来自FieldRecordset（@Nonnull ResponseField，@Nonnull映射记录集）的公共缓存密钥{
if（recordSet.containsKey（“id”））{
String id=（String）recordSet.get（“id”）；
返回CacheKey.from（id）；
}
返回CacheKey.NO_键；
}
@非空@覆盖
public CacheKey fromFieldArguments（@Nonnull ResponseField，@Nonnull Operation.Variables）{
返回CacheKey.NO_键；
}
};
}

在cacheKeyResolver上，您需要指定如何检测对象的id。在我的情况下，所有对象的名称开头都包含“id”。可以使用相同的结构添加更多参数

这两种配置都位于客户端生成器中：

Map<String, Object> connectionParams = new HashMap<>();
        return ApolloClient.builder()
                .serverUrl(urlBaseDeDatos)
                .normalizedCache(normalizedCacheFactory(),cacheKeyResolver())
                .okHttpClient(okHttpClient())
                .subscriptionConnectionParams(connectionParams)
                .subscriptionTransportFactory(new WebSocketSubscriptionTransport.Factory(urlBaseDeDatos, okHttpClient()))
                .build();

Map connectionParams=new HashMap（）；
返回client.builder（）
.serverUrl（URLBASEDEATOS）
.normalizedCache（normalizedCacheFactory（），cacheKeyResolver（））
.okHttpClient（okHttpClient（））
.subscriptionConnectionParams（connectionParams）
.subscriptionTransportFactory（新的WebSocketSubscriptionTransport.Factory（urlBaseDeDatos，okHttpClient（））
.build（）；

最后两个是重要的，因为它们控制着你的订阅（或者我认为它们控制着你的订阅），一旦我定义了这两个，我就可以订阅了。我的connectionParams是空的，因为我没有使用auth令牌或类似的东西

现在，对于订阅：

private Flowable<Response<TaskStatusChangedSubscription.Data>> subscription(){
        apolloClient.clearNormalizedCache();
        return Rx2Apollo.from(apolloClient.subscribe(TaskStatusChangedSubscription
                .builder()
                .build()));
    }

私有可流动订阅（）{
apolloClient.clearNormalizedCache（）；
返回Rx2Apollo.from（apolloClient.subscribe）（TaskStatusChangedSubscription
.builder（）
.build（））；
}

只需使用Apollo.subscribe方法和RxJava的一些帮助，在同一个函数或另一个函数上执行.subscribe（）（如一次性函数）

最后（很抱歉之前的所有解释，但这可能会帮助其他人），如果您将apollo builder更改为：

Map<String, Object> connectionParams = new HashMap<>();
ApolloClient mApolloClient = ApolloClient.builder().serverUrl(ENDPOINT).okHttpClient(ohc).subscriptionConnectionParams(connectionParams)
                .subscriptionTransportFactory(new WebSocketSubscriptionTransport.Factory(ENDPOINT, okHttpClient()))
                .build();

Map connectionParams=new HashMap（）；
ApolloClient mApolloClient=ApolloClient.builder（）.serverUrl（端点）.okHttpClient（ohc）.subscriptionConnectionParams（connectionParams）
.subscriptionTransportFactory（新的WebSocketSubscriptionTransport.Factory（端点，okHttpClient（））
.build（）；

Hi。对不起，回复太晚了。谢谢您的回答，但是

normalizedCacheFactory（）

和

cacheKeyResolver（）

方法呢？你是如何实现它们的？@mirjallatalalishinski用新信息编辑，我希望这能帮助你，我只需添加

subscriptionTransportFactory

就足以让它“起作用”