ViewPager懒加载

最新推荐文章于 2024-09-11 14:16:25 发布
最新推荐文章于 2024-09-11 14:16:25 发布
阅读量3.1k 收藏 3
点赞数 1
分类专栏： 安卓 文章标签： android viewpager java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lvzishen123/article/details/52382687
版权

  1. 了解懒加载和普通加载的区别

    文章开头，先让我们了解一下什么是viewpager的懒加载。下面让两个对比动图来告诉我们普通的fragment＋viewpager和使用了懒加载fragment＋viewpager的区别所在：
    普通viewpager：
    这里写图片描述
    懒加载viewpager：
    这里写图片描述
    经过上边两个动图我们可以看出使用了懒加载的viewpager只有当被划到下一个页面的时候那个页面才会加载。而普通的viewpager如果你不使用setoffscreenpagelimit(int limit)这个方法去设置默认加载数的话是会默认加载页面的左右两页的（不了解这个方法的同学请先去百度一下这个方法了解一下用法和效果），也就是说当你进入viewpager第一页的时候第二页和第一页是会被一起加载的，这样同时加载就会造成一些问题，试想我们如果设置了setoffscreenpagelimit为3的话，那么进入viewpager以后就会同时加载4个fragment，像我们平时的项目中在这些fragment中一般都是会发送网络请求的，也就是说我们有4个fragment同时发送网络请求去获取数据，这样的结果显而易见给用户的体验是不好的（如：浪费用户流量，造成卡顿等等）。

  2. 实现懒加载分析

    这样我们就需要使用viewpager的懒加载机制去让被浏览页面只有被用户可见的时候再会完成加载操作。接着来介绍一下fragment的setUserVisibleHint方法，这也是此实现最重要的一个方法，来让我们看下关于这个方法的介绍：

  * Set a hint to the system about whether this fragment's UI is currently visible
     * to the user. This hint defaults to true and is persistent across fragment instance
     * state save and restore.
     *
     * <p>An app may set this to false to indicate that the fragment's UI is
     * scrolled out of visibility or is otherwise not directly visible to the user.
     * This may be used by the system to prioritize operations such as fragment lifecycle updates
     * or loader ordering behavior.</p>
     *
     * @param isVisibleToUser true if this fragment's UI is currently visible to the user (default),
     *                        false if it is not.
     */
    public void setUserVisibleHint(boolean isVisibleToUser) {
        if (!mUserVisibleHint && isVisibleToUser && mState < STARTED
                && mFragmentManager != null && isAdded()) {
            mFragmentManager.performPendingDeferredStart(this);
        }
        mUserVisibleHint = isVisibleToUser;
        mDeferStart = mState < STARTED && !isVisibleToUser;
        ｝

可以看到该方法用于告诉系统，这个Fragment的UI是否是可见的。也就是说当Fragment被显示在屏幕时，setUserVisibleHint的isVisibleToUser参数为true，不显示时为fasle。所以我们只需要围绕这个方法即可完成fragment的懒加载。那就让我们先写一个看看。

public abstract class BasePagerFragment extends Fragment {

    protected AppCompatActivity mActivity;

    protected boolean isVisibleToUser; //页面是否可见



    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {   //page 1等会此读数据  生命周期
        super.setUserVisibleHint(isVisibleToUser);
        this.isVisibleToUser = isVisibleToUser;
        prepareFetchData();
    }



    public abstract void loadData();


    protected void prepareFetchData() {
        if (isVisibleToUser) {
            loadData();
        }
    }


}

这么写乍一看好像是没有问题，请接着往下看。
好的，让我们再来看下viewpager加载fragment时fragment的生命周期，直接上代码:

public class MainActivity extends AppCompatActivity {
    ViewPager viewPager;
    List<Fragment> fragmentList = new ArrayList<>();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        viewPager = (ViewPager) findViewById(R.id.viewpager_id);
        Fragment payOrderFragment = DemoFragment.newInstance("0", "");
        Fragment unPayOrderFragment = DemoFragment.newInstance("1", "");
        Fragment payOrderHistoryFragment = DemoFragment.newInstance("2", "");
        fragmentList.add(payOrderFragment);
        fragmentList.add(unPayOrderFragment);
        fragmentList.add(payOrderHistoryFragment);
        viewPager.setOffscreenPageLimit(2);  //fragmentList.size()-1
        MyFragmentPagerAdapter adapter = new MyFragmentPagerAdapter(getSupportFragmentManager(), (ArrayList<Fragment>) fragmentList);
        viewPager.setAdapter(adapter);
    }

    public class MyFragmentPagerAdapter extends FragmentPagerAdapter {
        ArrayList<Fragment> list;

        public MyFragmentPagerAdapter(FragmentManager fm, ArrayList<Fragment> list) {
            super(fm);
            this.list = list;

        }


        @Override
        public int getCount() {
            return list.size();
        }

        @Override
        public Fragment getItem(int arg0) {
            return list.get(arg0);
        }

        @Override
        public int getItemPosition(Object object) {
            return super.getItemPosition(object);
        }


    }
}
public abstract class BasePagerFragment extends Fragment {

    protected AppCompatActivity mActivity;


}
public class DemoFragment extends BasePagerFragment {
    // TODO: Rename parameter arguments, choose names that match
    // the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
    private static final String ARG_PARAM1 = "param1";
    private static final String ARG_PARAM2 = "param2";
    private  String TAG="";

    // TODO: Rename and change types of parameters
    private String mParam1;
    private String mParam2;

    ImageView imageview;

    public DemoFragment() {
        // Required empty public constructor
    }

    /**
     * Use this factory method to create a new instance of
     * this fragment using the provided parameters.
     *
     * @param param1 Parameter 1.
     * @param param2 Parameter 2.
     * @return A new instance of fragment DemoFragment.
     */
    // TODO: Rename and change types and number of parameters
    public static DemoFragment newInstance(String param1, String param2) {
        DemoFragment fragment = new DemoFragment();
        Bundle args = new Bundle();
        args.putString(ARG_PARAM1, param1);
        args.putString(ARG_PARAM2, param2);
        fragment.setArguments(args);
        return fragment;
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.e(TAG,"onCreate");
    }
    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        if (getArguments() != null) {
            mParam1 = getArguments().getString(ARG_PARAM1);
            mParam2 = getArguments().getString(ARG_PARAM2);
        }
        if(mParam1.equals("0")){
            TAG="0";
        }else if(mParam1.equals("1")){
            TAG="1";
        }else {
            TAG="2";
        }
        Log.e(TAG,"isVisibleToUser"+isVisibleToUser);
        super.setUserVisibleHint(isVisibleToUser);
    }

//    @Override
//    protected void prepareFetchData(boolean forceUpdate) {
//        super.prepareFetchData(true);
//    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        Log.e(TAG,"onCreateView");
        View view = inflater.inflate(R.layout.fragment_demo, container, false);
        imageview = (ImageView) view.findViewById(R.id.imageview);
        imageview.setImageResource(R.mipmap.ic_launcher);
        return view;
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        Log.e(TAG,"onActivityCreated");
    }



    @Override
    public void onAttach(Context context) {
        super.onAttach(context);
        if (getArguments() != null) {
            mParam1 = getArguments().getString(ARG_PARAM1);
            mParam2 = getArguments().getString(ARG_PARAM2);
        }
        if(mParam1.equals("0")){
            TAG="0";
        }else if(mParam1.equals("1")){
            TAG="1";
        }else {
            TAG="2";
        }
        mActivity = (AppCompatActivity) context;
        Log.e(TAG,"onAttach");
    }


    @Override
    public void onStart() {
        super.onStart();
        Log.e(TAG,"onStart");
    }

    @Override
    public void onStop() {
        super.onStop();
        Log.e(TAG,"onStop");
    }

    @Override
    public void onDestroyView() {
        super.onDestroyView();
        Log.e(TAG,"onDestroyView");
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.e(TAG,"onDestroy");
    }

    @Override
    public void onDetach() {
        super.onDetach();
        Log.e(TAG,"onDetach");
    }

    @Override
    public void onResume() {
        super.onResume();
        Log.e(TAG,"onResume");
    }

    @Override
    public void onPause() {
        super.onPause();
        Log.e(TAG,"onPause");
    }
}

如上图所示代码很简单，就是3个fragment加载到viewpager中，fragment通过tag区分不用的fragment对象方便我们观察生命周期log，当我们运行代码后的生命周期为：
这里写图片描述

可以看到首先第一个首先运行的是第一个fragment的setUserVisibleHint方法，因为第一个fragment的值可见，所以参数为true，但是我们会发现这个方法是在第一个fragment被加载前被调用的，如果你只在按照我们初识那么写的话，当它走到loaddata（）中的时候控件view并没有初始化，这样肯定会造成空指针问题。既然如此我们让它控件加载后再读取数据即可，控件初识化一般在oncreateview方法中，所以我们在fragment的onActivityCreated方法中再去加载即可，改造后如下：

public abstract class BasePagerFragment extends Fragment {

    protected AppCompatActivity mActivity;
    protected boolean isViewInitiated; //控件是否初始化完成
    protected boolean isVisibleToUser; //页面是否可见



    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {   //page 1等会此读数据  生命周期
        super.setUserVisibleHint(isVisibleToUser);
        this.isVisibleToUser = isVisibleToUser;
        prepareFetchData();
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {   //page 0进入再此读数据
        super.onActivityCreated(savedInstanceState);
        isViewInitiated = true;
        prepareFetchData();
    }

    public abstract void loadData();


    protected void prepareFetchData() {
        if (isVisibleToUser && isViewInitiated ) {
            loadData();
        }
    }


}

好的，这样我们遍完成了viewpager的懒加载，这时又会出现一个问题，加入当我们翻到第二页的时候，setUserVisibleHint便又会被置为true，如图最下方：
这里写图片描述
这也就会造成已经加载过的页面又被加载一次的局面，这时我们就可以声明一个标志位来告诉改界面是否已经加载过数据，如下：

public abstract class BasePagerFragment extends Fragment {

    protected AppCompatActivity mActivity;
    protected boolean isViewInitiated; //控件是否初始化完成
    protected boolean isVisibleToUser; //页面是否可见
    protected boolean isDataInitiated; //数据是否加载


    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {   //page 1等会此读数据  生命周期
        super.setUserVisibleHint(isVisibleToUser);
        this.isVisibleToUser = isVisibleToUser;
        prepareFetchData(false);
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {   //page 0进入再此读数据
        super.onActivityCreated(savedInstanceState);
        isViewInitiated = true;
        prepareFetchData(false);
    }

    public abstract void loadData();


    protected void prepareFetchData(boolean forceUpdate) {
        if (isVisibleToUser && isViewInitiated && (!isDataInitiated || forceUpdate)) {
            loadData();
            isDataInitiated = true;
        }
    }


}

可以看到我们加标志位的同时加入了一个forceUpdate参数，这个参数是由我们控制的，默认为false，我们可以复写这个方法将它改为true，当我们改为true之后每次重新划到该页面的时候便会重新加载一遍数据以便满足实时更新等需求。
如下：

@Override
    protected void prepareFetchData(boolean forceUpdate) {
        super.prepareFetchData(true);
    }

最后如有不足请小伙伴们提出，感谢大家的观看，完整代码我已经放到github上了，如有需要请下载，谢谢大家！！
https://github.com/lvzishen/ViewPagerLazyLoad/tree/master

lvzishen123
关注
专栏目录
ViewPager的懒加载
04-22
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/happiness365/article/detail
实现ViewPager懒加载的三种方法
热门推荐
如琢如磨
03-28 2万+
在项目中ViewPager和Fragment接口框架已经是处处可见，但是在使用中，我们肯定不希望用户在当前页面时就在前后页面的数据，加入数据量很大，而用户又不愿意左右滑动浏览，那么这时候ViewPager中本来充满善意的预加载就有点令人不爽了。我们能做的就是屏蔽掉ViewPager的预加载机制。虽然ViewPager中提供的有 setOffscreenPageLimit()来控制其预加载的数
前端性能优化——懒加载
最新发布
qq_51846847的博客
09-11 1298
前端性能优化——懒加载
viewpager懒加载
hzqaqz的博客
04-08 752
实现懒加载的方法 构造pagerAdapter时设置mBehavior。 FragmentPagerAdapter fragmentPagerAdapter = new FragmentPagerAdapter( getSupportFragmentManager(), FragmentPagerAdapter.BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT ) 在fragment的onResume中加载数据。 设置BEHAVI
ViewPager实现懒加载
Heijinbaitu的博客
12-31 611
日常开发中很多场景会用到ViewPager+Fragment，一般情况下，我们是通过setOffscreenPageLimit(int limit)方法控制页面的预加载数量。但是有时候，我们又会有这样的需求，当用户滑动到相关页面的时候，才加载相关页面的数据，从而节省用户流量。那么，设置setOffscreenPageLimit(int limit)是否可以达到这样的目的呢，答案是肯定的：不能！ 为...
android实现ViewPager懒加载的三种方法
08-31
Android 实现 ViewPager 懒加载的三种方法 ViewPager 是 Android 中一个非常常用的控件，特别是在Fragment接口框架中。但是，ViewPager 的预加载机制有时会带来一些问题，例如在数据量很大的情况下，预加载会导致...
Fragment+viewpager懒加载方案
08-25
在这个“Fragment+ViewPager懒加载方案”中，我们将深入探讨如何将这一策略应用于Fragment与ViewPager的结合使用，以实现更高效的资源管理。 首先，让我们理解Fragment和ViewPager的基本概念。Fragment是Android中...
Fragment结合ViewPager之懒加载 1
09的专栏
08-25 430
什么是懒加载？为什么要用懒加载？ 1、什么是懒加载 懒加载就是当ViewPager和Fragment结合在一起使用时，Fragment呈现在用户面前时才加载数据，当其从未被呈现在用户面前时，不会执行加载数据的代码。这就是我所理解的懒加载。 2、为什么要用懒加载 ViewPager默认会预加载下一页，对于某些重量级的Fragment来说无疑会造成很大的开销，当然了，如果对于你来说这些开销是必
ViewPager 懒加载 lazyload
ttlan的博客
07-08 313
ViewPager 懒加载 lazyload 嵌套fragment
懒加载LazyViewPager
蛮吉的博客
09-18 224
需求只希望一次滑动加载一个Fragment，这个就能满足需求。 /* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * * you may not use this file except...
Android优化之ViewPager的懒加载
态度决定高度A=X+Y+Z
09-09 3578
转载本博客请注明出处： 出于对用户小号流量的考虑，有必要对viewpage做懒加载。对于什么是懒加载，首先应该理解什么是预加载： 对于ViewPage默认是加载三个pages，即用户选择当前界面的时候，该page两边的pages都已经初始化完毕（数据、界面、网络等）。这就是预加载机制。对于ViewPage的使用详解，请看之前的博客，地址：点击打开链接  http://blog.csdn.n
ViewPager+Fragment实现懒加载（lazy-loading）
jianesrq0724的博客
05-19 1万+
什么是lazy-loading呢？顾名思义就是在必要的时候才加载，否则不进行View的绘制和数据的加载。原因是Viewpager一次只会显示一个页卡，那么刚开始的时候，只需加载第一张Fragment页卡，其他的不加载，当用户向右滑动切换再进行加载。因为其他Fragment对于用户来说是不可见的，如果一开始就把全部Fragment一起加载，可能造成启动时卡顿的问题，更重要的是可能白白耗费用户的流量，
Fragemnt+ViewPager懒加载
yeyuyyy
10-07 672
什么叫懒加载就是当你需要的时候才去加载为什么要用懒加载fragment放在viewPager里面，viewpager会帮我们预先加载一个，但是当我们要看fragment里面的内容时，我们也许只会去看第一个，不会去看第二个，如果这时候不去实现fragment的懒加载的话，就会多余的去加载一些数据，造成用户多消耗流量。两种思路 viewpager不去预先加载另一个（不修改源码不能实现，未去实现） 当fr
ViewPager延时加载（懒加载）
hlglinglong的专栏
05-29 2183
使用viewpager默认会加载至少一个view，项目中有的页面中的大图比较多
Android微信风格ViewPager懒加载技术详解与实现
这种做法被称为懒加载，因为它只有在实际需要时才会激活相关的数据和视图。 首先，理解lazy-loading的关键在于理解`ViewPager`的工作原理。`ViewPager`是一个用于展示多个可滑动页面的控件，通常配合`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值