Code d'implémentation du chargement paresseux des données de l'interface Android

Tout le monde trouvera quelque chose en utilisant les clients d'actualités mobiles. La plupart des clients d'actualités classeront les actualités, telles que les titres, les divertissements, les sports, la technologie, etc. Comment implémenter cette interface ? C'est en fait très simple à mettre en œuvre. Il s'agit d'implémenter la commutation de plusieurs ViewPages dans un Fragment, puis de placer un TabLayout au-dessus de ViewPage, et l'effet de liaison peut être obtenu en les liant. Si vous n'êtes pas clair, je peux écrire un blog spécifiquement sur la mise à l'avenir de plusieurs ViewPages dans des fragments. Aujourd'hui, je présente principalement comment implémenter le chargement paresseux de l'interface, c'est-à-dire les fragments. Ensuite, tout le monde sera surpris puisqu’il est chargé directement sur l’interface de chargement, pourquoi utilise-t-on encore le lazy chargement ? Cela nécessite de parler des avantages du chargement paresseux. Comme mentionné ci-dessus, le principe de la plupart des clients de nouvelles pour mettre en œuvre diverses commutations de nouvelles est de stocker plusieurs ViewPages dans un seul fragment. Si les données de toutes les ViewPages sont chargées après l'entrée dans le programme, cela augmentera sans aucun doute la durée d'exécution de l'APP. , et le chargement paresseux peut réaliser que la page d'affichage dans le fragment ne précharge qu'une interface au démarrage du programme, attend qu'elle passe à l'interface suivante, puis charge les données de la page d'affichage suivante, implémente le cache de l'interface de chargement et passe à celle-ci. interface la prochaine fois. Elle ne sera plus rechargée. Bon, expliquons clairement pourquoi le chargement paresseux est utilisé, passons au sujet principal aujourd'hui.

Première étape : Personnalisez un fragment et laissez-le hériter de Fragment
1 Remplacez la méthode setUserVisibleHint
2 Définissez une méthode abstraite lazyInitData()

package com.jereh.jinritoutiao.fragmentdemo.fragment;
 
import android.support.v4.app.Fragment;
 
/**
 * Created by zhangdi on 2016/8/8.
 */
public abstract class BaseFragment extends Fragment {
protected boolean isVisible = false;
@Override
public void setUserVisibleHint(boolean isVisibleToUser) {
super.setUserVisibleHint(isVisibleToUser);
if (isVisibleToUser){
//加载数据
isVisible = true;
   lazyInitData();
  }else {
isVisible = false;
  }
 }
public abstract void lazyInitData();
}

. Étape 2 : Définissez un autre fragment pour hériter du fragment que vous venez de définir
1. Définissez d'abord une variable globale pour enregistrer l'état du fragment (cette étape est préparée pour l'interface de cache) et définissez deux variables booléennes pour indiquer la vue du fragment. fragment. Le contrôle est prêt et si le fragment actuel a chargé des données
2. Déterminez si l'état du fragment est vide, générez une nouvelle interface
3. la classe parent pour implémenter le chargement paresseux

/**
 * A simple {@link Fragment} subclass.
 */
public class NetNewsFragment extends BaseFragment {
　　//定义一个全局变量用来保存Fragment的状态
　　private View v;
　　//listview展示的数据
　　private List<NetNews> mData;
　　private PullToRefreshListView lv;
　　@Override
　　public void onCreate(Bundle savedInstanceState) {
　　　　super.onCreate(savedInstanceState);
　　　　String u= getArguments().getString("api");
　　　　if(!TextUtils.isEmpty(u)){
　　　　　　url = u;
  }
 }
 
　　@Override
　　public View onCreateView(LayoutInflater inflater, ViewGroup container,
        Bundle savedInstanceState) {
　　　　　　　　if(v==null) {
　　　　　　　　　　//将布局关联起来
　　　　　　　　　　v = inflater.inflate(R.layout.fragment_net_news, container, false);
　　　　　　　　　　//找到ViewPage
　　　　　　　　　　lv = (PullToRefreshListView) v.findViewById(R.id.lv01);
　　　　　　　　　　mData = new ArrayList<>();
　　　　　　　　　　//初始化适配器
　　　　　　　　　　adapter = new NetNewsAdapter(mData, getActivity());
　　　　　　　　　　lv.setAdapter(adapter);
　　　　　　　　　　//界面已经准备完毕
　　　　　　　　　　isPrepared = true;
   　　(new android.os.Handler()).postDelayed(new Runnable() {
　　　　　　　　　　　　@Override
　　　　　　　　　　　　public void run() {
     lazyInitData();
    　　}
   　　　　},200);
  　　　　 }
　　　　　　　　return v;
  }
 
　　/**
  * 初始化Fragment数据的方法，实现懒加载
　　　*/
　　@Override
　　public void lazyInitData() {
　　　　if (isPrepared&&isVisible&&isFirst){
　　　　　　　 lv.setRefreshing();
   VolleyUtil.get(url+"?num=20&page="+page)
    .setCallBack(new NetCallBack())
    .build()
    .addRequestHeader("apikey", Constants.API_KEY)
    .start();
　　　　isFirst = false;
  }
 }

Afin de mettre en évidence le code de chargement paresseux, j'ai omis la surveillance du style de PullToListView, et ici (nouveau android.os.Handler()).postDelayed(new Runnable()) La méthode consiste à utiliser le multi-threading pour implémenter le chargement asynchrone, de sorte que lorsque la mise en page est initialisée, il y ait le temps de générer des composants d'interface, puis de charger les données.

À ce stade, l'objectif du chargement paresseux des données d'interface (Fragment) dans Android a été atteint. Si vous souhaitez basculer entre plusieurs interfaces à l'avenir et que les données nécessitent des requêtes réseau, il est recommandé d'utiliser le chargement paresseux.

D'accord, c'est tout pour l'introduction au chargement paresseux.

Ce qui précède représente l'intégralité du contenu de cet article. J'espère qu'il sera utile à l'apprentissage de chacun. J'espère également que tout le monde soutiendra le site Web PHP chinois.

Pour plus d'articles sur le code d'implémentation du chargement paresseux des données de l'interface Android, veuillez faire attention au site Web PHP chinois !