Połączenia Chwilowe Retrofit za pomocą RxJava i zwracanie głównego obiektu

Question

Próbuję użyć retrofitu + rxjava, aby zagnieżdżać wywołania api. Zasadniczo muszę zbudować listę obiektów biblioteki. Każdy obiekt biblioteki ma listę autorów, a każdy obiekt autora ma listę książek. Tak jest skonstruowany mój json.

json biblioteka -

{ 
title: "Library", 
items: [ 
     { 
     title: "Library1" 
     image: "http://example.com/image/101/image_lib1.png" 
     url: "http://example.com/api/1" 
     }, 
     { 
     title:"Library2" 
     image: "http://example.com/image/101/image_lib2.png" 
     url: "http://example.com/api/2" 
     }, 
     { 
     title:"Library3" 
     image: "http://example.com/image/101/image_lib3.png" 
     url: "http://example.com/api/3" 
     } 
    ] 
} 

i autorów json-

{ 
title: "Authors", 
items: [ 
     { 
     title: "J.K Rowling" 
     image: "http://example.com/image/101/image_author1.png" 
     url: "http://example.com/api/101" 
     }, 
     { 
     title:"Mark Twain" 
     image: "http://example.com/image/101/image_author2.png" 
     url: "http://example.com/api/201" 
     }, 
     { 
     title:"Charles Dickens" 
     image: "http://example.com/image/101/image_author3.png" 
     url: "http://example.com/api/301" 
     } 
    ] 
} 

i książki json-

{ 
description: Books, 
imageurl: "http://example.com/image/101/image_101.png", 
items: [ 
    { 
    id: 101, 
    title: "Oliver Twist ", 
    description: "some description" 
    }, 
    { 
    id: 1011, 
    title: "Hard times", 
    description: "some more description." 
    } 
} 
] 
} 

Mój interfejs API jest podane poniżej.

@GET("/api/") 
    Observable<LibraryResponse> getLibraryList(); 

    @GET("/api/{feedId}") 
    Observable<AuthorResponse> getAuthorList(@Path("feedId") String feedId); 

    @GET("/api/{feedId}") 
    Observable<BooksResponsee> getBooksList(@Path("feedId") String feedId); 




Observable<List<Library>> observable = myRestInterface 
    .getLibraryList() 
    .map(a -> a.getItems()) 
    .flatMapIterable(b -> b)     
    .flatMap(h -> myRestInterface                 
        .getAuthorList(h.getUrl().substring(h.getUrl().lastIndexOf("/") + 1))          
        .map(x -> x.getItems()) 
        .flatMapIterable(l -> l) 
        .flatMap(e -> myRestInterface 
           .getBooksList(e.getUrl().substring(e.getUrl().lastIndexOf("/") + 1)) 
           .map(d -> d.getItems()) 
           .flatMapIterable(c -> c))) 

    .collect(// ? into list of main object) 
    .doOnNext(mainObjectList -> new ViewupdateMethod(mainObjectList)); 
    .subscribe(...); 

Próbuję skonstruować jeden obiekt Librarylist, którego mogę użyć do aktualizacji mojego interfejsu użytkownika. Trochę utknąłem tutaj. Po wykonaniu wielu połączeń, w jaki sposób zapisać wyniki i zebrać wszystko do listy obiektów biblioteki?

Answer 1

Observable<List<Library>> observable = myRestInterface 
      .getLibraryList() 
      .flatMapIterable(response -> response.getItems()) 
      .doOnNext(library -> myRestInterface 
        .getAuthorList(library.getUrl().substring(library.getUrl().lastIndexOf("/") + 1)) 
        .flatMapIterable(response -> response.getItems()) 
        .doOnNext(author -> library.getAuthors().add(author)) 
        .doOnNext(
          author -> myRestInterface 
            .getBooksList(author.getUrl().substring(author.getUrl().lastIndexOf("/") + 1)) 
            .flatMapIterable(response -> response.getItems()) 
            .doOnNext(book -> author.getBooks().add(book)) 
            .subscribe() 
        ) 
        .subscribe() 
      ) 

      .doOnNext(mainObjectList -> new ViewupdateMethod(mainObjectList)) 
      .subscribe(); 

Notatka .subscribe() połączenia. Służą do rozpoczęcia realizacji całego łańcucha. RxObservable nie robi nic, dopóki nie pojawi się subskrybent.