Room flowable多次调用

Question

我的TeamDao里有这个

@Query("select * from teams where id = :teamId")
    Flowable<Team> getRivals(int teamId);

我是这样订阅的

teamRepository.getRivals(61).
                distinctUntilChanged().
                observeOn(SchedulerProvider.getInstance().ui()).

                subscribeOn(SchedulerProvider.getInstance().computation())
                .subscribe(team -> Log.d("HomeActivity", team.getName()));

每当Team表的任何行中有任何更改时，不管它是否具有id61，我都会看到我的this订阅者在调用。

我在博客上读到distinctUntilChanged()就是用来避免这种情况的。

我的团队POJO是这样的

@Entity(tableName = "teams",
        foreignKeys = {
                @ForeignKey
                        (entity = User.class,
                                parentColumns = "id",
                                childColumns = "userId",
                                onDelete = ForeignKey.CASCADE),
                @ForeignKey
                        (entity = Neighbourhood.class,
                                parentColumns = "id",
                                childColumns = "neighbourhoodId"
                        )})
public class Team {

    @PrimaryKey
    int id;
    private String name;
    private String imageUrl;

    @Embedded(prefix = "ladder_")
    Ladder ladder;



    //    USE RELATIONS WITH @Relation()
    //relations
    private int userId;
    private int neighbourhoodId;
    private int skillLevelId;

    public int getUserId() {
        return userId;
    }

    public void setUserId(int userId) {
        this.userId = userId;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getImageUrl() {
        return imageUrl;
    }

    public void setImageUrl(String imageUrl) {
        this.imageUrl = imageUrl;
    }


    public Neighbourhood getNeighbourhood() {
        return neighbourhood;
    }

    public void setNeighbourhood(Neighbourhood neighbourhood) {
        this.neighbourhood = neighbourhood;
    }

    public List<TeamMember> getTeamMemberList() {
        return teamMemberList;
    }

    public void setTeamMemberList(List<TeamMember> teamMemberList) {
        this.teamMemberList = teamMemberList;
    }


    public int getNeighbourhoodId() {
        return neighbourhoodId;
    }

    public void setNeighbourhoodId(int neighbourhoodId) {
        this.neighbourhoodId = neighbourhoodId;
    }

    public int getSkillLevelId() {
        return skillLevelId;
    }

    public void setSkillLevelId(int skillLevelId) {
        this.skillLevelId = skillLevelId;
    }

    public List<Sport> getSports() {
        return sports;
    }

    public void setSports(List<Sport> sportList) {
        this.sports = sportList;
    }

    public Ladder getLadder() {
        return ladder;
    }

    public void setLadder(Ladder ladder) {
        this.ladder = ladder;
    }

    public List<MatchRequest> getMatchRequests() {
        return matchRequests;
    }

    public void setMatchRequests(List<MatchRequest> matchRequests) {
        this.matchRequests = matchRequests;
    }
}

有什么建议吗？

Answer 1

在使用distinct或distinctUntilChanged()时，您需要在流式传输的类型中实现适当的Object.equals，因为这些运算符使用equals来比较项(因为这是Java Collections中惯用的方式)。