LiveData多次加载数据问题

楼主遇到一个情况，就是第一次进入页面监听livedata更新数据正常，返回重新进入页面后会更新两次数据，第一次更新的数据是上一次缓存的数据，第二次才是自己需要的数据，这样就会造成页面重复刷新的问题以及浪费资源，解决方法如下

就是使用一个谷歌大神实现的一个复写类 SingleLiveEvent代替livadata，其中的机制是用一个原子 AtomicBoolean记录一次setValue。在发送一次后在将AtomicBoolean设置为false，阻止后续前台重新触发时的数据发送。

1.  
   /*
2.  
   * Copyright 2017 Google Inc.
3.  
   *
4.  
   * Licensed under the Apache License, Version 2.0 (the "License");
5.  
   * you may not use this file except in compliance with the License.
6.  
   * You may obtain a copy of the License at
7.  
   *
8.  
   * http://www.apache.org/licenses/LICENSE-2.0
9.  
   *
10.  
    * Unless required by applicable law or agreed to in writing, software
11.  
    * distributed under the License is distributed on an "AS IS" BASIS,
12.  
    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13.  
    * See the License for the specific language governing permissions and
14.  
    * limitations under the License.
15.  
    */
16.  
     
17.  
    package com.dhc.jmpos.bus.event;
18.  
     
19.  
    import android.util.Log;
20.  
     
21.  
    import java.util.concurrent.atomic.AtomicBoolean;
22.  
     
23.  
    import androidx.annotation.MainThread;
24.  
    import androidx.annotation.Nullable;
25.  
    import androidx.lifecycle.LifecycleOwner;
26.  
    import androidx.lifecycle.MutableLiveData;
27.  
    import androidx.lifecycle.Observer;
28.  
     
29.  
    /**
30.  
    * A lifecycle-aware observable that sends only new updates after subscription, used for events like
31.  
    * navigation and Snackbar messages.
32.  
    * <p>
33.  
    * This avoids a common problem with events: on configuration change (like rotation) an update
34.  
    * can be emitted if the observer is active. This LiveData only calls the observable if there's an
35.  
    * explicit call to setValue() or call().
36.  
    * <p>
37.  
    * Note that only one observer is going to be notified of changes.
38.  
    */
39.  
    public class SingleLiveEvent<T> extends MutableLiveData<T> {
40.  
     
41.  
    private static final String TAG = "SingleLiveEvent";
42.  
     
43.  
    private final AtomicBoolean mPending = new AtomicBoolean(false);
44.  
     
45.  
    @MainThread
46.  
    public void observe(LifecycleOwner owner, final Observer<? super T> observer) {
47.  
     
48.  
    if (hasActiveObservers()) {
49.  
    Log.w(TAG, "Multiple observers registered but only one will be notified of changes.");
50.  
    }
51.  
     
52.  
    // Observe the internal MutableLiveData
53.  
    super.observe(owner, new Observer<T>() {
54.  
    @Override
55.  
    public void onChanged(@Nullable T t) {
56.  
    if (mPending.compareAndSet(true, false)) {
57.  
    observer.onChanged(t);
58.  
    }
59.  
    }
60.  
    });
61.  
    }
62.  
     
63.  
    @MainThread
64.  
    public void setValue(@Nullable T t) {
65.  
    mPending.set(true);
66.  
    super.setValue(t);
67.  
    }
68.  
     
69.  
    /**
70.  
    * Used for cases where T is Void, to make calls cleaner.
71.  
    */
72.  
    @MainThread
73.  
    public void call() {
74.  
    setValue(null);
75.  
    }
76.  
    }

这篇好文章是转载于：学新通技术网