问题描述

做需求开发时，遇到RecyclerView刷新时，通常会使用notifyItemXXX方法去做局部刷新。但是刷新后，有时会遇到RecyclerView定位到我们不希望的位置，这时候就会很头疼。这周有时间深入了解了下RecyclerView的源码，大致梳理清楚刷新后位置跳动的原因了。

原因分析

先简单描述下RecyclerView在notify后的过程：

1. 根据是否是全量刷新来选择触发RecyclerView.RecyclerViewDataObserver的onChanged方法或onItemRangeXXX方法

onChanged会直接调用requestlayout来重新layuout。 onItemRangeXXX会先把刷新数据保存到mAdapterHelper中，然后再调用requestlayout

2. 进入dispatchLayout流程 这一步分为三个步骤：

• dispatchLayoutStep1：处理adapter的更新、决定哪些view执行动画、保存view的信息
• dispatchLayoutStep2：真正执行childView的layout操作
• dispatchLayoutStep3：触发动画、保存状态、清理信息

需要注意的是，在onMeasure的过程中，如果传入的measureMode不是exactly，会去调用dispatchLayoutStep1和dispatchLayoutStep2从而取得真正需要的宽高。 所以在dispatchLayout会先判断是否需要重新执行dispatchLayoutStep1和dispatchLayoutStep2

重点分析dispatchLayoutStep2这一步： 核心操作在 mLayout.onLayoutChildren(mRecycler, mState)这一行。以LinearLayoutManager为例继续往下挖：

public void onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state) {

    ...

    final View focused = getFocusedChild();

    if (!mAnchorInfo.mValid || mPendingScrollPosition != RecyclerView.NO_POSITION

                || mPendingSavedState != null) {

            mAnchorInfo.reset();

            mAnchorInfo.mLayoutFromEnd = mShouldReverseLayout ^ mStackFromEnd;

            // 关键步骤1，寻找锚点View位置

            updateAnchorInfoForLayout(recycler, state, mAnchorInfo);

            mAnchorInfo.mValid = true;

        } else if (focused != null && (mOrientationHelper.getDecoratedStart(focused)

                >= mOrientationHelper.getEndAfterPadding()

                || mOrientationHelper.getDecoratedEnd(focused)

                <= mOrientationHelper.getStartAfterPadding())) {

            mAnchorInfo.assignFromViewAndKeepVisibleRect(focused, getPosition(focused));

        }

        ...

            // fill towards end

            updateLayoutStateToFillEnd(mAnchorInfo);

            mLayoutState.mExtraFillSpace = extraForEnd;

            //关键步骤2，从锚点View位置往后填充

            fill(recycler, mLayoutState, state, false);

            endOffset = mLayoutState.mOffset;

            final int lastElement = mLayoutState.mCurrentPosition;

            if (mLayoutState.mAvailable > 0) {

            //如果锚点位置后面数据不足，无法填满剩余的空间，那把剩余空间加到顶部

                extraForStart += mLayoutState.mAvailable;

            }

            // fill towards start

            updateLayoutStateToFillStart(mAnchorInfo);

            mLayoutState.mExtraFillSpace = extraForStart;

            mLayoutState.mCurrentPosition += mLayoutState.mItemDirection;

            //关键步骤3，从锚点View位置向前填充

            fill(recycler, mLayoutState, state, false);

            startOffset = mLayoutState.mOffset;



            if (mLayoutState.mAvailable > 0) {

            //如果锚点View位置前面数据不足，那把剩余空间加到尾部再做一次尝试

                extraForEnd = mLayoutState.mAvailable;

                // start could not consume all it should. add more items towards end

                updateLayoutStateToFillEnd(lastElement, endOffset);

                mLayoutState.mExtraFillSpace = extraForEnd;

                fill(recycler, mLayoutState, state, false);

                endOffset = mLayoutState.mOffset;

            }

}

先解释一下锚点View，锚点View在一次layout过程中的位置不会发生变化，即之前在哪里显示，这次layout完还在哪，从视觉上看没有位移。

总结一下，mLayout.onLayoutChildren主要做了以下几件事：

1. 调用updateAnchorInfoForLayout方法确定锚点view位置
2. 从锚点view后面的位置开始填充，直到后面空间被填满或者已经遍历到最后一个itemView
3. 从锚点view前面的位置开始填充，直到空间被填满或者遍历到indexe为0的itemView
4. 经过第三步后仍有剩余空间，则把剩余空间加到尾部再做一次尝试

所以回到一开始的问题，RecyclerView在notify之后位置跳跃的关键在于锚点View的确定，也就是updateAnchorInfoForLayout方法，所以下面重点看下这个方法：

private void updateAnchorInfoForLayout(RecyclerView.Recycler recycler, RecyclerView.State state,

        AnchorInfo anchorInfo) {

    if (updateAnchorFromPendingData(state, anchorInfo)) {

        if (DEBUG) {

            Log.d(TAG, "updated anchor info from pending information");

        }

        return;

    }



    if (updateAnchorFromChildren(recycler, state, anchorInfo)) {

        if (DEBUG) {

            Log.d(TAG, "updated anchor info from existing children");

        }

        return;

    }

    if (DEBUG) {

        Log.d(TAG, "deciding anchor info for fresh state");

    }

    anchorInfo.assignCoordinateFromPadding();

    anchorInfo.mPosition = mStackFromEnd ? state.getItemCount() - 1 : 0;

}

这个方法比较短，所以代码全贴出来了。如果是调用了scrollToPosition后的刷新，会通过updateAnchorFromPendingData方法确定锚点View位置，否则调用updateAnchorFromChildren来计算：

private boolean updateAnchorFromChildren(RecyclerView.Recycler recycler,

        RecyclerView.State state, AnchorInfo anchorInfo) {

    if (getChildCount() == 0) {

        return false;

    }

    final View focused = getFocusedChild();

    if (focused != null && anchorInfo.isViewValidAsAnchor(focused, state)) {

        anchorInfo.assignFromViewAndKeepVisibleRect(focused, getPosition(focused));

        return true;

    }

    if (mLastStackFromEnd != mStackFromEnd) {

        return false;

    }

    View referenceChild =

            findReferenceChild(

                    recycler,

                    state,

                    anchorInfo.mLayoutFromEnd,

                    mStackFromEnd);

    if (referenceChild != null) {

        anchorInfo.assignFromView(referenceChild, getPosition(referenceChild));

        ...

        return true;

    }

    return false;

}

代码比较简单，如果有焦点View，并且焦点View没被remove，则使用焦点View作为锚点。否则调用findReferenceChild来查找：

View findReferenceChild(RecyclerView.Recycler recycler, RecyclerView.State state,

        boolean layoutFromEnd, boolean traverseChildrenInReverseOrder) {

    ensureLayoutState();



    // Determine which direction through the view children we are going iterate.

    int start = 0;

    int end = getChildCount();

    int diff = 1;

    if (traverseChildrenInReverseOrder) {

        start = getChildCount() - 1;

        end = -1;

        diff = -1;

    }



    int itemCount = state.getItemCount();



    final int boundsStart = mOrientationHelper.getStartAfterPadding();

    final int boundsEnd = mOrientationHelper.getEndAfterPadding();



    View invalidMatch = null;

    View bestFirstFind = null;

    View bestSecondFind = null;



    for (int i = start; i != end; i += diff) {

        final View view = getChildAt(i);

        final int position = getPosition(view);

        final int childStart = mOrientationHelper.getDecoratedStart(view);

        final int childEnd = mOrientationHelper.getDecoratedEnd(view);

        if (position >= 0 && position < itemCount) {

            if (((RecyclerView.LayoutParams) view.getLayoutParams()).isItemRemoved()) {

                if (invalidMatch == null) {

                    invalidMatch = view; // removed item, least preferred

                }

            } else {

                // b/148869110: usually if childStart >= boundsEnd the child is out of

                // bounds, except if the child is 0 pixels!

                boolean outOfBoundsBefore = childEnd <= boundsStart && childStart < boundsStart;

                boolean outOfBoundsAfter = childStart >= boundsEnd && childEnd > boundsEnd;

                if (outOfBoundsBefore || outOfBoundsAfter) {

                    // The item is out of bounds.

                    // We want to find the items closest to the in bounds items and because we

                    // are always going through the items linearly, the 2 items we want are the

                    // last out of bounds item on the side we start searching on, and the first

                    // out of bounds item on the side we are ending on.  The side that we are

                    // ending on ultimately takes priority because we want items later in the

                    // layout to move forward if no in bounds anchors are found.

                    if (layoutFromEnd) {

                        if (outOfBoundsAfter) {

                            bestFirstFind = view;

                        } else if (bestSecondFind == null) {

                            bestSecondFind = view;

                        }

                    } else {

                        if (outOfBoundsBefore) {

                            bestFirstFind = view;

                        } else if (bestSecondFind == null) {

                            bestSecondFind = view;

                        }

                    }

                } else {

                    // We found an in bounds item, greedily return it.

                    return view;

                }

            }

        }

    }

    // We didn't find an in bounds item so we will settle for an item in this order:

    // 1. bestSecondFind

    // 2. bestFirstFind

    // 3. invalidMatch

    return bestSecondFind != null ? bestSecondFind :

            (bestFirstFind != null ? bestFirstFind : invalidMatch);

}

解释一下，查找过程会遍历RecyclerView当前可见的所有childView，找到第一个没被notifyRemove的childView就停止查找，否则会把遍历过程中找到的第一个被notifyRemove的childView作为锚点View返回。

这里需要注意final int position = getPosition(view);这一行代码，getPosition返回的是经过校正的最终position，如果ViewHolder被notifyRemove了，这里的position会是0，所以如果可见的childView都被remove了，那最终定位的锚点View是第一个childView，锚点的position是0，偏移量offset是这个被删除的childView的top值，这就会导致后面fill操作时从位置0开始填充，先把position=0的view填充到偏移量offset的位置，再往后依次填满剩余空间，这也是导致画面上的跳动的根本原因。

作者：Ernest912
来源：juejin.cn/post/7259358063517515834

关于降本增效的事，今天在网上看到一个帖子，虽然有点搞笑，但是对于打工人（特别是技术同学）来说，可挖掘的东西也不少，特别分享给大家。

真的是好多年没听说这样的事了，记得以前总有老板让做个淘宝、做个京东，然后预算只有几千块，最多几万块。

这些故事程序员谈起来往往都是哈哈一笑，并疯狂吐槽一番。

不过笑过之后，大家是否想过如何去解决问题？或者真的去评估下可行性，探索一下可能的实现路径。

找到问题

首先我们看下老板的问题。老板的根本问题并不是想要做金蝶，为什么这么说呢？

我们看看网友的描述就知道了：经济下行，领导不想出金蝶系统的维护费，不想为新功能花大价钱。这才是根本问题，用四个字来说就是：降低成本。

然后才是老板想到能不能用更少的钱达到金蝶系统的使用效果，再之后才是自己能不能做一个类似金蝶的系统，并思考了自己可以承担的成本：一个前端、一个后端，半年时间。

最后问题被抛到了这位网友的手里。可以看得出来这位网友也不太懂，还去咨询了朋友。不知道它有没有向朋友说清楚问题，还是只说了老板想自己做一个金蝶系统，结果是朋友们都说不可行。

遇到问题时，我们得把这个问题完完整整的捋一遍，找到最根本的问题，然后再说怎么解决问题，否则只是停留在表面，就可能事倍功半。在这个上下文中，根本的问题就是：降低成本。

解决问题

明确了老板的根本问题，我们就可以琢磨方案了。既然是降低财务系统的成本，可行的方案应该还是有几个的。

使用替代产品

假如公司只使用产品的部分功能，是不是可以选择金蝶的低版本？是不是可以降低一些人头费？

金蝶的服务贵，是不是可以选择一些小厂的产品？国内做财务系统的应该挺多的，小厂也更容易妥协。

或者选择SaaS服务，虽然SaaS用久了成本也不低，但是可以先撑过这几年，降低当前的支出。

当然替换财务系统也是有成本的，需要仔细评估。不过既然都想自己做了，这个成本应该能hold住。

找第三方维护

金蝶的服务贵，是不是可以找其它三方或者个人来维护修改？根据我之前的了解，金蝶这种公司有很多的实施工作是外包出去的，或者通过代理商来为客户服务，能不能找这些服务商来代替金蝶呢？或者去某些副业平台上应该也能找到熟悉金蝶系统的人。

当然这个还要看系统能不能顺利交接，金蝶有没有什么软硬件限制，第三方能不能接过来。

另外最重要的必须考虑系统和数据的安全性，不能因小失大。

自己开发

虽然自己开发的困难和成本都很高，但我仍旧认为这可能也是一个合适的解决方案。理由有下面两点。

• 功能简单：如果公司的业务比较简单，使用的流程也简单，比如不使用涉及复杂的财务处理，那么捋一捋，能给开发人员讲清楚，也是有可能在短时间内完成的。


• 迭代渐进：长城不是一天建成的，系统也都是逐渐迭代完善的。自己开发可以先从部分模块或者功能开始，然后逐步替换，比如前边的流程先在新系统中做，最后再导入金蝶。即使不能做到逐步替换，也可以控制系统的风险，发现搞不定时，及时止损。相信老板也能明白这个道理，如果不明白或者不接受，那确实搞不了。

当然我们也肯定不能忽视这其中的困难。我之前做过和金蝶系统的对接，订单的收付款在业务系统完成，然后业务系统生成凭证导入到金蝶K3。依稀记得业务也不算复杂，但是需求分析做了好几遍，我的代码也是改了又改，上线之后遇到各种问题，继续改，最终花了几个月才稳定下来。

事后分析原因，大概有这么几点：

• 产品或者需求分析人员没接触过类似的业务，即使他对财务系统有一些经验，也不能准确的将客户的业务处理方式转换到产品设计中；


• 财务人员说不明白，虽然他会使用金蝶系统，但是他不能一次性的把所有规则都讲出来，讲出来也很难让程序员在短时间内理解；


• 程序员没做过财务系统，没接触过类似的业务，系统的设计可能要反复调整，比如业务模块的划分逻辑，金额用Long还是用BigDecimal，数据保留几位小数，这都会大幅延长开发周期，如果不及时调整就可能写成一锅粥，后期维护更困难。

这还只是和金蝶系统做一个简单的对接，如果要替代它，还要实现更多的功能，总结下，企业可能会面对下面这些困难：

业务复杂：财务规则一般都比较复杂，涉及到各种运算，各种数字、报表能把人搞晕。如果公司的业务也很复杂，比如有很多分支或者特殊情况，软件开发的难度也会很大，这种难度的变化不是线性增加的，很可能是指数级增长的，一个工作流的设计可能就把人搞死了。

懂业务的人：系统过于复杂时，可能没有一个人能把系统前前后后、左左右右的整明白。而要完成这样一个复杂的系统，必须有人能从高层次的抽象，到具体数字运算的细枝末节，完完全全的整理出来，逻辑自洽，不重不漏，并形成文档，还要能把程序员讲明白。

懂架构的人：这里说的是要有一个经验丰富的程序员，不能是普通的码农，最好是有财务系统开发经验的架构师。没走过的路，总是要踩坑的。有经验的开发人员可以少走很多弯路，极大降低系统的风险。这样的人才如果公司没有，外招的难度比较大，即使能找到，成本也不低。

灵活性问题：开发固定业务流程的系统一般不会太考虑灵活性的问题，如果业务需要调整，可能需要对系统进行大幅修改，甚至推倒重来。如果要让系统灵活些，必然对业务和技术人员都提出了更高的要求，也代表着更强的工作能力和更多的工作量。

和其它系统的对接：要不要和税务系统对接？要不要和客户管理系统对接？要不要和公司的OA对接？每一次对接都要反复调试，工作量肯定下不来。

总之，稍微涉及到财务处理的系统，都不是一个前端和一个后端能在短时间内完全搞出来的。

对程序开发的启示

搞清楚需求

日常开发过程中，大家应该都遇到过不少此类问题。领导说这里要加个功能，然后产品和开发就去吭哧吭哧做了，做完了给领导一看，不是想要的，然后返工反复修改。或者说用户提了一个需求，产品感觉自己懂了，然后就让开发这么做那样改，最后给用户一看，什么破玩意。这都是没有搞清楚真正的需求，没有触达那个根本问题。

虽然开发人员可以把这些问题全部甩给产品，自己只管实现，但这毕竟实实在在的消耗了程序员的时间，大量的时间成本和机会成本，去干点有意义的事情不好吗？所以为了不浪费时间，开发也要完整的了解用户需求。在一个团队中，至少影响产品落地的关键开发人员要搞懂用户的需求。

那么遇到这种问题，程序员是不是可以直接跑路呢？

也是一个选择， 不过对于一个有追求的程序员，肯定也是想把程序设计好、架构好的，能解决实际问题的，这也需要对用户需求的良好把控能力，比如我们要识别出哪些是系统的核心模块，哪些是可扩展能力，就像设计冯诺依曼计算机，你设计的时候会怎么处理CPU和输入输出设备之间的关系呢？

对于用户需求，产品想的是怎么从流程设计上去解决，开发需要考虑的是怎么从技术实现上去满足，两者相向而行，才能把系统做好。

当然准确把握用户的需求，很多时候并不是我说的这么容易，因为用户可能也说不清楚，我们可能需要不断的追问才能得到一些关键信息。比如这位网友去咨询朋友时，可能需求就变成了：我们要做一个财务系统，朋友如果不多问，也只能拿到这个需求，说不定这位朋友也有二次开发的能力，错失了一次挣钱的好机会。还有这位老板上边可能还有更大的老板，这位老板降低成本的需求也可能是想在大老板面前表现一下，那是不是还有其它降本增效的方法呢？比如简化流程、裁掉几个不关键的岗位（这个要得罪人了）。

我们要让程序始终保持在良好的状态，就要准确的把握用户需求，要搞懂用户需求，就需要保持谦逊求知的心态，充分理解用户的问题，这种能力不是朝夕之间就可以掌握的，是需要修炼的。

动起来

任何没有被满足的需求都是一次机会。

我经常会在技术社区看到一些同学分享自己业余时间做的独立产品，有做进销存的、客户管理的、在线客服的，还有解决问题的各种小工具，而且有的同学还挣到了钱。

我并不是想说让大家都去搞钱，而是说要善于发现问题、找到机会，然后动起来、去实践，实践的过程中我们可以发现更多的问题，然后持续解决问题，必然能让自己变得越来越强。在经济不太好的情况下，我们才有更强的生存能力。

啰里八嗦一大堆，希望能对你有所启发。

大家好，我是杨成功。

自从《前端开发实战派》出版以后，好多买过的小伙伴都联系我，问我有没有电子书？纸质书在公司看不方便，一些现成的代码没办法复制。

确实没有电子版，我也听大家的建议上微信读书，结果那边审核没通过。我想不行我自己搞一个电子书呗，给买了纸书的朋友免费阅读，方便他们随时查阅。

经过一番调研，VitePress 的 UI 我最喜欢，扩展性也非常好，所以就用它来搭建。

新建项目

在一个空文件夹下，使用命令生成项目：

$ npx vitepress init

全部使用默认选项，生成结构如下：

图中的 .vitepress/config.mts 就是 VitePress 的配置文件。另外三个 .md 文件是 Markdown 内容，VitePress 会根据文件名自动生成路由，并将文件内容转换为 HTML 页面。

为了代码更优雅，一般会把 Markdown 文件放在 docs 目录下。只需要添加一个配置：

// config.mts

export default defineConfig({

  srcDir: 'docs',

});

改造后的目录结构是这样：

安装依赖并运行项目：

$ yarn add vitepress vue

$ yarn run docs:dev

前期设计的难点

电子书的内容不完全对外开放，只有买过纸书的人才能阅读。和掘金小册差不多，只能看部分内容，登录或购买后才能解锁全部章节。

而 VitePress 是一个静态站点生成器，默认只解析 Markdown。要想实现上述的功能，必须用到纯 Vue 组件，这需要通过扩展默认主题来实现。

扩展默认主题，也就是扩展 VitePress 的原始 Vue 组件，达到自定义的效果。

遵循这个思路，我们需要扩展的内容如下：

• 添加登录页面，允许用户登录。


• 添加用户中心页面，展示用户信息、退出登录。


• 修改头部组件，展示登录入口。


• 页面根组件，获取当前用户状态。


• 修改内容组件，无权限时不展示内容。

当然了还需要接入几个接口：

• 登录/注册接口。


• 获取当前用户信息接口。


• 验证当前用户权限的接口。

扩展默认主题

扩展默认主题，首先要创建一个 .vitepress/theme 文件夹，用来存放主题的组件、样式等代码。该文件夹下新建 index.ts 表示主题入口文件。

入口文件导出主题配置：

// index.ts

import Layout from './Layout.vue';



export default {

  Layout,

  enhanceApp({ app, router, siteData }) {

    // ...

  },

};

上面代码导入了一个 Layout.vue，这个组件是自定义布局组件：

<!-- Layout.vue -->

<script setup>

import DefaultTheme from 'vitepress/theme';



const { Layout } = DefaultTheme;

</script>



<template>

  <Layout>

    <template #nav-bar-content-after>

      <button>登录</button>

    </template>

  </Layout>

</template>

为啥需要这个组件呢？因为该组件是项目根组件，可以从两个方面扩展：

（1）使用自定义插槽。

Layout 组件提供了许多插槽，允许我们在页面的多处位置插入内容。比如上面代码中的 nav-bar-content-after 插槽，会在头部组件右侧插入登录按钮。

具体有哪些插槽，详见这里。

（2）做全局初始化。

当刷新页面时，需要做一些初始化操作，比如调用接口、监听某些状态等。

这个时候可以使用 Vue 的各种钩子函数，比如 onMounted：

// Layout.vue

<script setup>

import { onMounted } from 'vue';

onMounted(() => {

  console.log('初始化、请求接口');

});

</script>

如何定制内容组件？

VitePress 的内容组件，会把所有 Markdown 内容渲染出来。但是如果用户没有登录，我们不允许展示内容，而是提示用户登录，就像掘金小册这样：

定制内容组件，核心是在内容渲染的区域加一个判断：如果用户登录且验证通过，渲染内容即可；否则，展示类似上图的提示登录界面。

接下来我翻了 VitePress 的源码，找到了这个名为 VPDoc.vue 的组件：

github.com/vuejs/vitep…

在上方组件大概 46 行，我找到了内容渲染区域：

就在这个位置，添加一个判断，就达到我们想要的效果了：

<main class="main">

  <Content

    class="vp-doc"

    v-if="isLogin"

    :class="[

      pageName,

      theme.externalLinkIcon && 'external-link-icon-enabled'

    ]"

  />

  <div v-else>

    <h4>登录后阅读全文</h4>

    <button>去登录</button>

  </div>

</main>

那怎么让这个修改生效呢？

VitePress 提供了一个 重写内部组件 的方案。将 VPDoc.vue 组件拷贝到本地，按照上述方法修改，重命名为 CusVPDoc.vue。

在配置文件 .vitepress/config.ts 中添加重写逻辑：

// config.ts

export default defineConfig({

  vite: {

    resolve: {

      alias: [

        {

          find: /^.*\/VPDoc\.vue$/,

          replacement: fileURLToPath(new URL('./components/CusVPDoc.vue', import.meta.url)),

        },

      ],

    },

  },

});

这样便实现了自定义内容组件，电子书截图如下：

添加自定义页面

添加自定义页面，首先要创建一个自定义组件。

以登录页面为例，创建一个自定义组件 CusLogin.vue，编写登录页面和逻辑，然后将其注册为一个全局组件。在 Markdown 页面文件中，直接使用这个组件。

注册全局组件的方法，是在主题入口文件中添加以下配置：

// .vitepress/theme/index.ts

import CusLogin from './components/CusLogin.vue'



export default {

  ...

  enhanceApp({ app}) {

    app.component("CusLogin", CusLogin); // 注册全局组件

    // ...

  },

} satisfies Theme;

最后，新建 Markdown 文件 login.md，写入内容如下：

---

layout: page

---



<CusLogin />

现在访问路由 “/login” 就可以看到自定义登录页面了。

全局状态管理

涉及到用户登录，那么必然会涉及在多个组件中共享登录信息。

如果要做完全的状态管理，不用说，安装 Pinia 并经过一系列配置，可以实现。但是我们的需求只是共享登录信息，完全没必要再装一套 Pinia，使用 组合式函数 就可以了。

具体怎么实现，在另一篇文章 Vue3 新项目，没必要再用 Pinia 了！ 中有详细介绍。

接入 Bootstrap

自定义页面，总是需要一个 UI 框架。上面的登录页面中，我使用了 Bootstrap。

Vitepress 使用 UI 框架有一个限制：必须兼容 SSR。因为 Vitepress 本质上使用了 Vue 的服务端渲染功能，在构建期间生成多个 HTML 页面，并不是常见的单页面应用。

这意味着，Vue 组件只有在 beforeMount 或 mounted 钩子中才能访问 DOM API。

而 Bootstrap 不需要打包构建就可以使用 UI，非常适合 Vitepress。

首先安装 Bootstrap：

$ yarn add bootstrap

然后在主题入口文件中引入 Sass 和 JS 文件：

import 'bootstrap/scss/bootstrap-cus.scss';

import 'bootstrap/dist/js/bootstrap.bundle.min.js';

按常理说，这样就可以了，但是实际运行会报错：找不到某个 DOM API。

还记得那个限制吗？必须兼容 SSR！因此不能直接引入 JS 文件。

解决方法是在自定义布局组件 Layout.vue 中通过异步的方式引入：

// .vitepress/theme/Layout.vue

onMounted(() => {

  import('bootstrap/dist/js/bootstrap.bundle.min.js');

});

这样就大功告成了，你可以使用 Bootstrap 中丰富的 UI。

最终的电子书效果：《前端开发实战派》，欢迎点评。

最后留一个思考题：Vitepress 支持主题切换，Bootstrap 也分浅色和深色主题；切换 Vitepress 主题时，如何同步更改 Bootstrap 的主题呢？

公众号：程序员成功

作者微信：杨成功

null 何错之有？

对于 Java 程序员而言，NullPointerException 是最令我们头疼的异常，没有之一 ，大明哥相信到这篇文章为止一定还有不少人在写下面这段代码：

if (obj != null) {

   //...

}

NullPointerException 是 Java 1.0 版本引入的，引入它的主要目的是为了提供一种机制来处理 Java 程序中的空引用错误。空引用（Null Reference）是一个与空指针类似的概念，是一个已宣告但其并未引用到一个有效对象的变量。它是伟大的计算机科学家Tony Hoare 早在1965年发明的，最初作为编程语言ALGOL W的一部分。嗯，就是这位老爷子

1965年，老爷子 Tony Hoare 在设计ALGOL W语言时，为了简化ALGOL W 的设计，引入空引用的概念，他认为空引用可以方便地表示“无值”或“未知值”，其设计初衷就是要“通过编译器的自动检测机制，确保所有使用引用的地方都是绝对安全的”。但是在2009年，很多年后，他开始为自己曾经做过这样的决定而后悔不已，把它称为“一个价值十亿美元的错误”。实际上，Hoare的这段话低估了过去五十年来数百万程序员为修复空引用所耗费的代价。因为在ALGOL W之后出现的大多数现代程序设计语言，包括Java，都采用了同样的设计方式，其原因是为了与更老的语言保持兼容，或者就像Hoare曾经陈述的那样，“仅仅是因为这样实现起来更加容易”。

在 Java 中，null 会带来各种问题（摘自：《Java 8 实战》）：

• 它是错误之源。 NullPointerException 是目前Java程序开发中最典型的异常。它会使你的代码膨胀。


• 它让你的代码充斥着深度嵌套的null检查，代码的可读性糟糕透顶。


• 它自身是毫无意义的。 null自身没有任何的语义，尤其是是它代表的是在静态类型语言中以一种错误的方式对缺失变量值的建模。


• 它破坏了Java的哲学。 Java一直试图避免让程序员意识到指针的存在，唯一的例外是：null指针。


• 它在Java的类型系统上开了个口子。 null并不属于任何类型，这意味着它可以被赋值给任意引用类型的变量。这会导致问题， 原因是当这个变量被传递到系统中的另一个部分后，你将无法获知这个null变量最初赋值到底是什么类型。

Java 做了哪些努力？

Java 为了处理 NullPointerException 一直在努力着。

• Java 8 引入 Optional：减少 null而引发的NullPointerException异常


• Java 14 引入 Helpful NullPointerExceptions：帮助我们更好地排查 NullPointerException。

Java 8 的 Optional

Optional 是什么

Optional 是 Java 8 提供了一个类库。被设计出来的目的是为了减少因为null而引发的NullPointerException异常，并提供更安全和优雅的处理方式。

Java 中臭名昭著的 NullPointerException 是导致 Java 应用程序失败最常见的原因，没有之一，大明哥认为没有一个 Java 开发程序员没有遇到这个异常。为了解决 NullPointerException，Google Guava 引入了 Optional 类，它提供了一种在处理可能为null值时更灵活和优雅的方式，受 Google Guava 的影响，Java 8 引入 Optional 来处理 null 值。

在 Javadoc 中是这样描述它的：一个可以为 null 的容器对象。所以 java.util.Optional 是一个容器类，它可以保存类型为 T 的值，T 可以是实际 Java 对象，也可以是 null。

Optional API 介绍

我们先看 Optional 的定义：

public final class Optional {



    /**

     * 如果非空，则为该值；如果为空，则表示没有值存在。

     */

    private final T value;

    

    //...

 }

从这里可以看出，Optional 的本质就是内部存储了一个真实的值 T，如果 T 非空，就为该值，如果为空，则表示该值不存在。

构造 Optional 对象

Optional 的构造函数是 private 权限的，它对外提供了三个方法用于构造 Optional 对象。

Optional.of(T value)

    public static  Optional<T> of(T value) {

        return new Optional<>(value);

    }

    

    private Optional(T value) {

        this.value = Objects.requireNonNull(value);

    }

所以 Optional.of(T value) 是创建一个包含非null值的 Optional 对象。如果传入的值为null，将抛出NullPointerException 异常信息。

Optional.ofNullable(T value)

    public static  Optional ofNullable(T value) {

        return value == null ? empty() : of(value);

    }

创建一个包含可能为null值的Optional对象。如果传入的值为null，则会创建一个空的Optional对象。

Optional.empty()

    public static<T> Optional<T> empty() {

        @SuppressWarnings("unchecked")

        Optional<T> t = (Optional<T>) EMPTY;

        return t;

    }

    

    private static final Optional EMPTY = new Optional<>();

创建一个空的Optional对象，表示没有值。

检查是否有值

Optional 提供了两个方法用来检查是否有值。

isPresent()

isPresent() 用于检查Optional对象是否包含一个非null值，源码如下：

    public boolean isPresent() {

        return value != null;

    }

示例如下：

User user = null;

Optional optional = Optional.ofNullable(user);

System.out.println(optional.isPresent());

// 结果......

false

ifPresent(Consumer action)

该方法用来执行一个操作，该操作只有在 Optional 包含非null值时才会执行。源码如下：

    public void ifPresent(Consumersuper T> consumer) {

        if (value != null)

            consumer.accept(value);

    }

需要注意的是，这是 Consumer，是没有返回值的。

示例如下：

User user = new User("xiaoming");

Optional.ofNullable(user).ifPresent(value-> System.out.println("名字是:" + value.getName()));

获取值

获取值是 Optional 中的核心 API，Optional 为该功能提供了四个方法。

get()

get() 用来获取 Optional 对象中的值。如果 Optional 对象的值为空，会抛出NoSuchElementException异常。源码如下：

    public T get() {

        if (value == null) {

            throw new NoSuchElementException("No value present");

        }

        return value;

    }

orElse(T other)

orElse() 用来获取 Optional 对象中的值，如果值为空，则返回指定的默认值。源码如下：

    public T orElse(T other) {

        return value != null ? value : other;

    }

示例如下：

User user = null;

user = Optional.ofNullable(user).orElse(new User("xiaohong"));

System.out.println(user);

// 结果......

User(name=xiaohong, address=null)

orElseGet(Supplier other)

orElseGet()用来获取 Optional 对象中的值，如果值为空，则通过 Supplier 提供的逻辑来生成默认值。源码如下：

    public T orElseGet(Supplierextends T> other) {

        return value != null ? value : other.get();

    }

示例如下：

User user = null;

user = Optional.ofNullable(user).orElseGet(() -> {

  Address address = new Address("湖南省","长沙市","岳麓区");

  return new User("xiaohong",address);

});

System.out.println(user);

// 结果......

User(name=xiaohong, address=Address(province=湖南省, city=长沙市, area=岳麓区))

orElseGet() 和 orElse()的区别是：当 T 不为 null 的时候，orElse() 依然执行 other 的部分代码，而 orElseGet() 不会，验证如下：

public class OptionalTest {



    public static void main(String[] args) {

        User user = new User("xiaoming");

        User user1 = Optional.ofNullable(user).orElse(createUser());

        System.out.println(user);



        System.out.println("=========================");



        User user2 = Optional.ofNullable(user).orElseGet(() -> createUser());

        System.out.println(user2);

    }



    public static User createUser() {

        System.out.println("执行了 createUser() 方法");

        Address address = new Address("湖南省","长沙市","岳麓区");

        return new User("xiaohong",address);

    }

}

执行结果如下：

是不是 orElse() 执行了 createUser() ，而 orElseGet() 没有执行？一般而言，orElseGet() 比 orElse() 会更加灵活些。

orElseThrow(Supplier exceptionSupplier)

orElseThrow() 用来获取 Optional 对象中的值，如果值为空，则通过 Supplier 提供的逻辑抛出异常。源码如下：

    public extends Throwable> T orElseThrow(Supplier exceptionSupplier) throws X {

        if (value != null) {

            return value;

        } else {

            throw exceptionSupplier.get();

        }

    }

示例如下：

User user = null;

user = Optional.ofNullable(user).orElseThrow(() -> new RuntimeException("用户不存在"));

类型转换

Optional 提供 map() 和 flatMap() 用来进行类型转换。

map(Function mapper)

map() 允许我们对 Optional 对象中的值进行转换，并将结果包装在一个新的 Optional 对象中。该方法接受一个 Function 函数，该函数将当前 Optional 对象中的值映射成另一种类型的值，并返回一个新的 Optional 对应，这个新的 Optional 对象中的值就是映射后的值。如果当前 Optional 对象的值为空，则返回一个空的 Optional 对象，且 Function 不会执行，源码如下：

    public Optional map(Functionsuper T, ? extends U> mapper) {

        Objects.requireNonNull(mapper);

        if (!isPresent())

            return empty();

        else {

            return Optional.ofNullable(mapper.apply(value));

        }

    }

User user = new User("xiaolan");

String name = Optional.ofNullable(user).map(value -> value.getName()).get();

System.out.println(name);

// 结果......

xiaolan

    public<U> Optional<U> flatMap(Functionsuper T, Optional<U>> mapper) {

        Objects.requireNonNull(mapper);

        if (!isPresent())

            return empty();

        else {

            return Objects.requireNonNull(mapper.apply(value));

        }

    }

String name = Optional.ofNullable(user).flatMap(value -> Optional.ofNullable(value.getName())).get();

    public Optional filter(Predicatesuper T> predicate) {

        Objects.requireNonNull(predicate);

        if (!isPresent())

            return this;

        else

            return predicate.test(value) ? this : empty();

    }

    public static String getUserCity(User user) {

        if (user != null) {

            Address address = user.getAddress();

            if (address != null) {

                return address.getCity();

            }

        }

        return null;

    }

    public static String getUserCity(User user) {

        Optional userOptional = Optional.of(user);

        return Optional.of(userOptional.get().getAddress()).get().getCity();

    }

    public static String getUserCity(User user) {

        return Optional.ofNullable(user)

                .map(User::getAddress)

                .map(Address::getCity)

                .orElseThrow(() -> new RuntimeException("值不存在"));

    }

    public static String getUserCity(User user) {

        if (user != null && user.getName() != null) {

            if (user.getName().endsWith("ming")) {

                Address address = user.getAddress();

                if (address != null) {

                    return address.getCity();

                } else {

                    return "深圳市";

                }

            } else {

                return "深圳市";

            }

        }



        return "深圳市";

    }

    public static String getUserCity2(User user) {

        return Optional.ofNullable(user)

                .filter(u -> u.getName().endsWith("ming"))

                .map(User::getAddress)

                .map(Address::getCity)

                .orElse("深圳市1");

    }

Exception in thread "main" java.lang.NullPointerException

  at com.skjava.java.feature.Test.main(Test.java:6)

public class Test {

    public static void main(String[] args) {

        User user = new User();

        System.out.println(user.getAddress().getProvince().length());

    }

}

Exception in thread "main" java.lang.NullPointerException: Cannot invoke "*****.Address.getProvince()" because the return value of "*****.User.getAddress()" is null

  at com.skjava.java.feature.Test.main(Test.java:6)

前端功能问题系列文章，点击上方合集↑

序言

大家好，我是大澈！

本文约2100+字，整篇阅读大约需要3分钟。

本文主要内容分三部分，如果您只需要解决问题，请阅读第一、二部分即可。如果您有更多时间，进一步学习问题相关知识点，请阅读至第三部分。

感谢关注微信公众号：“程序员大澈”，然后加入问答群，从此让解决问题的你不再孤单！

1. 需求分析

为了提高用户对页面链接分享的体验，需要对分享链接做一些处理。

以 Telegram(国外某一通讯软件) 为例，当在 Telegram 上分享已做过处理的链接时，它会自动尝试获取链接的预览信息，包括标题、描述和图片。

如此当接收者看到时，可以立即获取到分享链接的一些重要信息。这有助于接收者更好地了解链接的内容，决定是否点击查看详细内容。

2. 实现步骤

2.1 实现前的说明

对于URL分享预览这个功能问题，在项目中挺常用的，只不过今天我们是以一些框架分享API的底层原理角度来讲的。

实现这种功能的关键，是在分享的链接中嵌入适当的元数据信息，应用软件会自动解析，请求分享链接的预览信息，并根据返回的元数据生成预览卡片。

对于国内的应用软件，目前我试过抖音，它可以实现分享和复制粘贴都自动解析，而微信、QQ等只能实现分享的自动解析。

对于国外的应用软件，我只实验过Telegram，它可以实现分享和复制粘贴都自动解析，但我想Facebook、Twitter、Instagram这些应用应该也都是可以的。

2.2 实现代码

实现URL链接的分享预览，你可以使用 Open Graph协议或 Twitter Cards，然后在 HTML 的 标签中，添加以下 meta 标签来定义链接预览的信息。

使用时，将所有meta全部复制过去，然后根据需求进行自定义即可。

还要注意两点，确保你页面的服务器正确配置了 SSL 证书，以及确保链接的URL有效（即：服务器没有做白名单限制）。

<head>

  

  <meta property="og:title" content="预览标题">

  <meta property="og:description" content="预览描述">

  <meta property="og:image:width" content="图片宽度">

  <meta property="og:image:height" content="图片高度">

  <meta property="og:image" content="预览图片的URL">

  <meta property="og:url" content="链接的URL">

  

  

  <meta name="twitter:card" content="summary">

  <meta name="twitter:title" content="预览标题">

  <meta name="twitter:description" content="预览描述">

  <meta property="twitter:image:width" content="图片宽度">

  <meta property="twitter:image:height" content="图片高度">

  <meta name="twitter:image" content="预览图片的URL">

  <meta name="twitter:url" content="链接的URL">

head>

下面我们做一些概念的整理、总结和学习。

3. 问题详解

3.1 什么是Open Graph协议？

Open Graph协议是一种用于在社交媒体平台上定义和传递网页元数据的协议。它由 Facebook 提出，并得到了其他社交媒体平台的支持和采纳。Open Graph 协议旨在标准化网页上的元数据，使网页在社交媒体上的分享和预览更加一致和可控。

通过在网页的 HTML  标签中添加特定的 meta 标签，使用 Open Graph 协议可以定义和传递与网页相关的元数据信息，如标题、描述、图片等。这些元数据信息可以被社交媒体平台解析和使用，用于生成链接预览、分享内容和提供更丰富的社交图谱。

使用 Open Graph 协议，网页的所有者可以控制链接在社交媒体上的预览内容，确保链接在分享时显示的标题、描述和图片等信息准确、有吸引力，并能够准确传达链接的主题和内容。这有助于提高链接的点击率、转化率和用户体验。

Open Graph 协议定义了一组标准的 meta 标签属性，如 og:title、og:description、og:image 等，用于提供链接预览所需的元数据信息。通过在网页中添加这些 meta 标签并设置相应的属性值，可以实现链接预览在社交媒体平台上的一致展示。

需要注意的是，Open Graph 协议是一种开放的标准，并不限于 Facebook 平台。其他社交媒体平台，如 Twitter、LinkedIn 等，也支持使用 Open Graph 协议定义和传递网页元数据，以实现链接预览的一致性。

3.2 什么是Twitter Cards？

Twitter Cards 是一种由 Twitter 推出的功能，它允许网站所有者在他们的网页上定义和传递特定的元数据，以便在 Twitter 上分享链接时生成更丰富和吸引人的预览卡片。通过使用 Twitter Cards，网页链接在 Twitter 上的分享可以展示标题、描述、图片、链接和其他相关信息，以提供更具吸引力和信息丰富的链接预览。

Twitter Cards 提供了多种类型的卡片，以适应不同类型的内容和需求。以下是 Twitter Cards 的一些常见类型：

• Summary Card：Summary Card 类型的卡片包含一个标题、描述和可选的图片。它适用于分享文章、博客帖子等内容。


• Summary Card with Large Image：Summary Card with Large Image 类型的卡片与 Summary Card 类型类似，但图片尺寸更大，更突出地展示在卡片上。


• App Card：App Card 类型的卡片用于分享移动应用程序的信息。它包含应用的名称、图标、描述和下载按钮，以便用户可以直接从预览卡片中下载应用。


• Player Card：Player Card 类型的卡片用于分享包含媒体播放器的内容，如音频文件、视频等。它允许在预览卡片上直接播放媒体内容。

通过在网页的 HTML  标签中添加特定的 meta 标签，使用 Twitter Cards 可以定义和传递与链接预览相关的元数据信息，如标题、描述、图片、链接等。这些元数据信息将被 Twitter 解析和使用，用于生成链接预览卡片。

使用 Twitter Cards 可以使链接在 Twitter 上的分享更加吸引人和信息丰富，提高链接的点击率和用户参与度。它为网站所有者提供了更多控制链接在 Twitter 上展示的能力，并提供了一种更好的方式来呈现他们的内容。

结语

建立这个平台的初衷：

• 打造一个仅包含前端问题的问答平台，让大家高效搜索处理同样问题。


• 通过不断积累问题，一起练习逻辑思维，并顺便学习相关的知识点。


• 遇到难题，遇到有共鸣的问题，一起讨论，一起沉淀，一起成长。

在移动应用开发中，应用内版本更新是一项重要的功能。它允许开发者轻松地向用户提供新的应用版本，以修复错误、改进性能，或者引入新功能。这篇文章将介绍如何使用 BasicUI 库，一个Android库，来实现应用内版本更新的功能。我们将演示如何从远程服务器下载APK文件并进行安装。

BasicUI库简介

BasicUI 是一个功能强大且易于使用的Android库，用于实现各种常见UI和网络操作，其中包括文件下载和更新功能。这个库提供了一些便捷的方法来简化Android应用开发中的一些常见任务，包括版本更新。

要开始使用BasicUI库，你需要在你的项目中添加相应的依赖，可以在官方GitHub仓库中找到详细的文档和示例。

GitHub库链接: BasicUI

应用内部升级弹窗的流程图

代码实现应用内版本更新

下面是一个简单的代码示例，演示了如何使用BasicUI库来实现应用内版本更新。这段代码将从远程服务器下载APK文件，并在下载完成后进行安装。请确保你已经添加了BasicUI库的依赖。

val file = File(cacheDir, "update.apk")

if (file.exists()) {

    file.delete()

}

mDialog.apply {

    setOnCancelListener {

        HttpUtils.cancel()

    }

}.show()

with(this@OkHttpActivity)

    .url("http://example.com/your_update.apk") // 替换成实际的APK下载链接

    .downloadSingle()

    .file(file)

    .exectureDownload(object : DownloadCallback {

        override fun onFailure(e: Exception?) {

            LogUtils.e(e!!.message)

            mDialog.dismiss()

        }



        override fun onSucceed(file: File?) {

            ToastUtils.showShort("文件下载完成")

            LogUtils.e("文件保存的位置:" + file!!.absolutePath)

            mProgressBar!!.visibility = View.GONE

            mProgressBar!!.progress = 0

            installApk(file)

            mDialog.dismiss()

        }



        override fun onProgress(progress: Int) {

            LogUtils.e("单线程下载APK的进度:$progress")

            mProgressBar!!.progress = progress

            mProgressBar!!.visibility = View.VISIBLE

        }

    })

上述代码的主要步骤包括：

请注意，你需要将示例代码中的下载链接替换为实际的APK下载链接。这段代码提供了一个简单而有效的方式来执行应用内版本更新，但你还可以根据你的需求进行进一步的定制化。

结语

在本文中，我们演示了如何使用BasicUI库来实现Android应用内版本更新的功能。这是一个快速、方便的解决方案，可以帮助你轻松地向用户提供最新版本的应用程序。请记住，版本更新是确保用户始终使用最新、最稳定版本的应用的关键步骤。

为了更好地满足你的需求，你可以根据实际情况进一步定制版本更新流程，例如添加灰度发布、自动检测新版本等功能。希望这篇文章对你有所帮助，使你能够更好地满足用户的需求和提供卓越的应用体验。

这篇文章演示了如何使用 BasicUI 库来实现应用内版本更新的功能。你可以根据自己的需求进一步定制这个流程，以满足特定的应用程序要求。希望这篇文章对你有所帮助！

需求

个人或个体户，如何免费使用微信小程序授权，快速登录进系统内部？

微信授权登录好处：

可能有的人会问，为何不用微信公众号授权登录？原因很简单，因为一年要300元，小公司得省钱啊！

实现步骤说明

所有的步骤里包含四个对象，分别是本地后台、本地微信小程序、本地网页、以及第三方微信后台

注意点：

1. 上面三个微信接口/cgi-bin/token、/getwxacodeunlimit、/jscode2session必须由本地后台调用，微信小程序那边做了前端限制；


2. 本地网页如何得知本地微信小程序已扫码呢？

本地微信小程序将code，通过A接口，将值传给后台，后台拿到openid后，再将成功结果返回给本地微信小程序；同时，本地网页不断地轮询A接口，等待后台拿到openid后，便显示登录成功页面。

微信小程序核心代码

Page({

  data: {

    theme: wx.getSystemInfoSync().theme,

    scene: "",

    jsCode: "",

    isLogin: false,

    loginSuccess: false,

    isChecked: false,

  },

  onLoad(options) {

    const that = this;

    wx.onThemeChange((result) => {

      that.setData({

        theme: result.theme,

      });

    });

    if (options !== undefined) {

      if (options.scene) {

        wx.login({

          success(res) {

            if (res.code) {

              that.setData({

                scene: decodeURIComponent(options.scene),

                jsCode: res.code,

              });

            }

          },

        });

      }

    }



  },

  handleChange(e) {

    this.setData({

      isChecked: Boolean(e.detail.value[0]),

    });

  },

  formitForm() {

    const that = this;

    if (!this.data.jsCode) {

      wx.showToast({

        icon: "none",

        title: "尚未微信登录",

      });

      return;

    }

    if (!this.data.isChecked) {

      wx.showToast({

        icon: "none",

        title: "请先勾选同意用户协议",

      });

      return;

    }

    wx.showLoading({

      title: "正在加载",

    });

    let currentTimestamp = Date.now();

    let nonce = randomString();

    wx.request({

      url: `A接口?scene=${that.data.scene}&js_code=${that.data.jsCode}`,

      header: {},

      method: "POST",

      success(res) {

        wx.hideLoading();

        that.setData({

          isLogin: true,

        });

        if (res.statusCode == 200) {

          that.setData({

            loginSuccess: true,

          });

        } else {

          if (res.statusCode == 400) {

            wx.showToast({

              icon: "none",

              title: "无效请求",

            });

          } else if (res.statusCode == 500) {

            wx.showToast({

              icon: "none",

              title: "服务内部错误",

            });

          }

          that.setData({

            loginSuccess: false,

          });

        }

      },

      fail: function (e) {

        wx.hideLoading();

        wx.showToast({

          icon: "none",

          title: e,

        });

      },

    });

  },

});

scene为随机生成的8位数字

本地网页核心代码

    let isInit = true

    function loginWx() {

        isInit = false

        refreshQrcode()

    }

    function refreshQrcode() {

        showQrLoading = true

        showInfo = false

        api.get('/qrcode').then(qRes => {

            if (qRes.status == 200) {

                imgSrc = `${BASE_URL}${qRes.data}`

                pollingCount = 0

                startPolling()

            } else {

                showToast = true

                toastMsg = '二维码获取失败，请点击刷新重试'

                showInfo = true

            }

        }).finally(() => {

            showQrLoading = false

        })

    }



    // 开始轮询

    // 1000毫秒轮询一次

    function startPolling() {

        pollingInterval = setInterval(function () {

		pollDatabase()

        }, 1000)

    }

    function pollDatabase() {

        if (pollingCount >= maxPollingCount) {

            clearInterval(pollingInterval)

            showToast = true

            toastMsg = '二维码已失效，请刷新'

            showInfo = true

            return

        }

        pollingCount++

        api.get('/result').then(res => {

            if (res.status == 200) {

                clearInterval(pollingInterval)

                navigate('/os', { replace: true })

            } else if (res.status == 408) {

                clearInterval(pollingInterval)

                showToast = true

                toastMsg = '二维码已失效，请刷新'

                showInfo = true

            }

        })

    }

    

    

html的部分代码如下所示

     <button class="btn" on:click={loginWx}>微信登录</button>

     <div id="qrcode" class="relative mt-10">

        {#if imgSrc}

        <img src={imgSrc} alt="二维码图片"/>

        {/if}

        {#if showQrLoading}

        <div class="mask absolute top-0 left-0 w-full h-full z-10">

            <Loading height="12" width="12"/>

        </div>

        {/if}

    </div>

尾声

若需要完整代码，或想知道如何申请微信小程序，欢迎大家关注或私信我哦~~

前言

恶意软件为了不让我们很容易反编译一个apk，会对androidmanifest文件进行魔改加固，本文探索androidmanifest加固的常见手法以及对抗方法。这里提供一个恶意样本的androidmanifest.xml文件，我们学完之后可以动手实践。

1、Androidmanifest文件组成

这里贴一张经典图，主要描述了androidmanifest的组成

​

androidmanifest文件头部仅仅占了8个字节，紧跟其后的是StringPoolType字符串常量池

（为了方便我们观察分析，可以先安装一下010editor的模板，详细见2、010editor模板）

Magic Number

这个值作为头部，是经常会被魔改的，需要重点关注

​

StylesStart

该值一般为0，也是经常会发现魔改

StringPool

​

寻找一个字符串，如何计算？

1、获得字符串存放开放位置：0xac（172），此时的0xac是不带开头的8个字节

所以需要我们加上8，最终字符串在文件中的开始位置是：0xb4

2、获取第一个字符串的偏移，可以看到，偏移为0

​

3、计算字符串最终存储的地方： 0xb4 = 0xb4 + 0

读取字符串，以字节00结束

​

读取到的字符为：theme

帮助网安学习，全套资料S信领取：

① 网安学习成长路径思维导图

② 60+网安经典常用工具包

③ 100+SRC漏洞分析报告

④ 150+网安攻防实战技术电子书

⑤ 最权威CISSP 认证考试指南+题库

⑥ 超1800页CTF实战技巧手册

⑦ 最新网安大厂面试题合集（含答案）

⑧ APP客户端安全检测指南（安卓+IOS）

总结：

stringpool是紧跟在文件头后面的一块区域，用于存储文件所有用到的字符串

这个地方呢，也是经常发生魔改加固的，比如：将StringCount修改为0xFFFFFF无穷大

在经过我们的手动计算和分析后，我们对该区域有了更深的了解。

2、010editor模板

使用010editor工具打开，安装模板库

​

搜索：androidmanifest.bt

​

安装完成且运行之后：

​

会发现完整的结构，帮助我们分析

3、使用AXMLPrinter2进行的排错和修复

用法十分简单：

java -jar AXMLPrinter2.jar AndroidManifest_origin.xml

会有一系列的报错，但是不要慌张，根据这些报错来对原androidmanifest.xml进行修复

​​

意思是：出乎意料的0x80003（正常读取的数据），此时却读取到：0x80000

按照小端序，正常的数据应该是： 03 00 08

使用 010editor 打开

​

将其修复

​

保存，再次尝试运行AXMLPrinter2

​

好家伙还有错误，这个-71304363，不方便我们分析，将其转换为python的hex数据

NegativeArraySizeException 表示在创建数组的时候，数组的大小出现了负数。

androidmanifest加固后文件与正常的androidmanifest文件对比之后就可以发现魔改的地方。

​

将其修改回去

运行仍然报错，是个新错误：

​

再次去分析：

​

stringoffsets如此离谱，并且数组的大小变为了0xff

​

​

根据报错的信息，尝试把FF修改为24

​

​

再次运行

​

成功拿到反编译后的androidmanifest.xml文件

总结：

这个例子有三个魔改点经常出现在androidmanifest.xml加固

恶意软件通过修改这些魔改点来对抗反编译

华为云生成obs链接时，可以做配置。

一般我们播放本地视频都是使用vedio标签，但是vedio标签只支持三种视频格式：MP4、WebM、Ogg，对于在线视频直接使用vedio不支持播放。
故，上述 2 中的视频，在vedio中不支持播放，浏览器访问链接，直接就下载了。

先介绍几个概念：

流协议: 流协议就是在两个通信系统之间传输多媒体文件的一套规则，它定义了视频文件将如何分解为小数据包以及它们在互联网上传输的顺序，RTMP与 RTSP 是比较常见的流媒体协议。

HLS： HLS (HTTP Live Streaming)是Apple的动态码率自适应技术。主要用于PC和Apple终端的音视频服务。包括一个m3u(8)的索引文件，TS媒体分片文件和key加密串文件。参考:HLS。简单来说，HLS是一种协议，如果你的视频源是http://xxxx.m3u8这种，就选择这种协议，.m3u8是个文本文件，直播时，他的内容实时变更，内部指向一个或多个.ts文件。

HTTP-FLV: HTTP-FLV 是将音视频数据以 FLV 文件格式进行封装，再将 FLV 格式数据封装在 HTTP 协议中进行传输的一种流媒体传输方式。HTTP-FLV 的实现原理： HTTP-FLV 利用 HTTP/1.1 分块传输机制发送 FLV 数据。虽然直播服务器无法知道直播流的长度，但是 HTTP/1.1 分块传输机制可以不填写 conten-length 字段而是携带 Transfer-Encoding: chunked 字段，这样客户端就会一直接受数据。参考：FLV 和 HTTP-FLV。

简单来说就是你的视频源是直播且是xxxx.flv，就选择这种协议播放。还有个websocket-flv，是基于websocket的。

RTMP与RTSP： 什么是RTMP 和 RTSP？它们之间有什么区别？

H264(AVC)与H265(HEVC)： 都是视频编码，是视频压缩格式，由于视频本身的码流太大，所以需要经过压缩然后再通过网络进行传输，其中H265是H264的升级版，很多播放器无法播放H265视频。

xgplayer

vue2的系统，本来用xgplayer 版本：2.32.5。无奈本地可以展示，测试环境不能用，报错不明显，粗略看了一下是插件底层，内部报错，故放弃xgpalyer插件。

ps.我在vue3的系统中，用过xgpalyer插件，挺好用的

优点如下：

• 官网教程非常简单清晰，上手快


• 使用起来体验感很好


• 支持直播点播，支持hls、http+flv、dash、WebRTC直播，还有音乐播放器 。


• 提供在线可调试demo

dpplayer

然后，我就换了 dppalyer插件来展示。点击查看中文文档

这个插件，我去github查了一下，15k星星，用的人还是挺多，但是，个人感觉不如 xgplayer好用。

安装npm install dplayer --save

在页面中引用

import DPlayer from 'dplayer';



const dp = new DPlayer(options);

dpplayer实现是通过生成iframe页面，将视频嵌套到其中。

刚开始给容器写了样式，宽100% 高100%，结果它不能自适应屏幕，很难受。后面我强行定宽420px。高度自动获取当前容器高度，定了一个最大高度。

但其实没有用，它会根据宽度，自己按比例缩放高度。
所以我在视频渲染出来后，自动调了一下全屏功能dpPlayer.fullScreen.request('web');
勉强解决了这个问题。

贴一下我的完整代码

<template>

  <div class="vedio-wrapper" :style="{'max-height': winH}">

    <el-empty v-if="!player" description="暂无数据"></el-empty>

    <div :id="id" allowfullscreen="allowfullscreen" />

  </div>

</template>





<script>

import DPlayer from 'dplayer';



import { getParam } from '@/utils/utils'

import {

  getBucketObsFileUrl

} from '@/api/common'



export default {

  name: 'previewMedia',

  components:{},

  data() {

    return {

      winH: '300px',

      id: 'dpPlayerDom',

      player: null

    }



  },

  created() {

    const winH = window.innerHeight

    this.winH = winH + 'px'

  },

  mounted() {

    this.getFileUrl()

  },

  methods: {



    async getFileUrl() {

      try {

        const filePath = getParam('filePath')

        const type = getParam('type') ? parseInt(getParam('type')) : 1

        if (!filePath) return

        const params = {

          objectKey: filePath,

          type

        }

        const data = await getBucketObsFileUrl(params);

        this.setVedioplayerConfig(data)

      } catch (e) {

        console.error(e)

      }

    },



    setVedioplayerConfig(url) {

      if (!url) return



      const tmpConfig = {

        container: document.getElementById('dplayer'),

        screenshot: false,

        video: {

          url: url,

          thumbnails: 'thumbnails.jpg',

        },

        contextmenu: []



      }



      this.$nextTick(() => {

        tmpConfig.container = document.getElementById(this.id)

        const dpPlayer = new DPlayer(tmpConfig);

        this.player = dpPlayer



        dpPlayer.fullScreen.request('web');

      })



    }

  }

}

</script>

<style scoped lang="scss">

  .vedio-wrapper {

    width: 400px;

    height: 100%;

    margin: 0 auto;

  }

</style>

一、整体逻辑

为何直接对RecyclerView进行扩展而不使用ViewPager/ViewPager2？原因如下：

实现逻辑：三种滑动模式都在RecyclerView地基础上更改其滑动行为，横向滑动需要修改子View层级，仿真翻页需要再覆盖一层仿真动画

二、横向覆盖滑动（Slide Mode）

Slide Mode 最适合直接使用 ViewPager，不过我们还是以 RecyclerView 为基础来实现，让三种模式统一实现方式。实现思路：先实现跨页吸附，再实现覆盖翻页效果

1、跨页吸附

实现跨页吸附，需要在手指离开屏幕时对 RecyclerView 进行复位吸附操作，有两种情况：

（1）Scroll Idle

拖拽发生后，RecyclerView 滑动状态变为 SCROLL_STATE_IDLE 时，需要进行复位吸附操作

// OrientationHelper为系统提供的辅助类，LayoutManager的包装类

// 可以让我们方便的计算出RecyclerView相关的各种宽高，计算结果和LayoutManager方向相关

open fun snapToTargetExistingView(helper: OrientationHelper): Pair<Int, Int>? {

    val lm = mRecyclerView.layoutManager ?: return null

    val childCount = lm.childCount // 可见数量

    if (childCount < 1) return null



    var closestChild: View? = null

    var absClosest = Int.MAX_VALUE

    var scrollDistance = 0

    // RecyclerView中心点，LayoutManager为竖向则是Y轴坐标，为横向则是X轴坐标

    val containerCenter = helper.startAfterPadding + helper.totalSpace / 2



    // 从可见Item中找到距RecyclerView离中心最近的View

    for (i in 0 until childCount) {

        val child = lm.getChildAt(i) ?: continue

        if (consumeSnap(i, child)) return null // consumeSnap 默认返回false，竖直滑动模式才使用

        val childCenter = (helper.getDecoratedStart(child)

                + helper.getDecoratedMeasurement(child) / 2)

        val absDistance = abs(childCenter - containerCenter)

        if (absDistance < absClosest) {

            absClosest = absDistance

            closestChild = child

            scrollDistance = childCenter - containerCenter

        }

    }

    closestChild ?: return null



    // 滑动

    when (orientation) {

        VERTICAL -> mRecyclerView.smoothScrollBy(0, scrollDistance)

        HORIZONTAL -> mRecyclerView.smoothScrollBy(scrollDistance, 0)

    }

    return Pair(scrollDistance, lm.getPosition(closestChild))

}

（2）Fling

可以通过 RecyclerView 提供的OnFlingListener消费掉Fling，将其转化为 SmoothScroll ，滑动到指定位置

①、找到吸附目标的位置（adapter position）

open fun findTargetSnapPosition(

    lm: RecyclerView.LayoutManager,

    velocity: Int,

    helper: OrientationHelper

): Int {

    val itemCount: Int = lm.itemCount

    if (itemCount == 0) return RecyclerView.NO_POSITION

    

    // 中心点以前距离最近的View

    var closestChildBeforeCenter: View? = null

    var distanceBefore = Int.MIN_VALUE	// 中心点以前，距离为负数

    // 中心点以后距离最近的View

    var closestChildAfterCenter: View? = null

    var distanceAfter = Int.MAX_VALUE	// 中心点以后，距离为正数

    val containerCenter = helper.startAfterPadding + helper.totalSpace / 2



    val childCount: Int = lm.childCount

    for (i in 0 until childCount) {

        val child = lm.getChildAt(i) ?: continue

        if (consumeSnap(i, child)) return RecyclerView.NO_POSITION // consumeSnap 默认返回false，竖直滑动模式才使用

        

        val childCenter = (helper.getDecoratedStart(child)

                + helper.getDecoratedMeasurement(child) / 2)

        val distance = childCenter - containerCenter



        // Fling需要考虑方向，先获取两个方向最近的View

        if (distance in (distanceBefore + 1)..0) {

            distanceBefore = distance

            closestChildBeforeCenter = child

        }

        if (distance in 0 until distanceAfter) {

            distanceAfter = distance

            closestChildAfterCenter = child

        }

    }

	

    // 根据方向选择Fling到哪个View

    val forwardDirection = velocity > 0

    if (forwardDirection && closestChildAfterCenter != null) {

        return lm.getPosition(closestChildAfterCenter)

    } else if (!forwardDirection && closestChildBeforeCenter != null) {

        return lm.getPosition(closestChildBeforeCenter)

    }



    // 边界情况处理

    val visibleView =

        (if (forwardDirection) closestChildBeforeCenter else closestChildAfterCenter)

            ?: return RecyclerView.NO_POSITION

    val visiblePosition: Int = lm.getPosition(visibleView)

    val snapToPosition = (visiblePosition - 1)



    return if (snapToPosition < 0 || snapToPosition >= itemCount) {

        RecyclerView.NO_POSITION

    } else snapToPosition

}

②、使用RecyclerView的「LinearSmoothScroller」完成吸附动画

private fun createScroller(

    oh: OrientationHelper

): LinearSmoothScroller {

    return object : LinearSmoothScroller(mRecyclerView.context) {

        override fun onTargetFound(

            targetView: View,

            state: RecyclerView.State,

            action: Action

        ) {

            val d = distanceToCenter(targetView, oh)

            val time = calculateTimeForDeceleration(abs(d))

            if (time > 0) {

                when (orientation) {

                    VERTICAL -> action.update(0, d, time, mDecelerateInterpolator)

                    HORIZONTAL -> action.update(d, 0, time, mDecelerateInterpolator)

                }

            }

        }



        override fun calculateSpeedPerPixel(displayMetrics: DisplayMetrics) =

            100f / displayMetrics.densityDpi



        override fun calculateTimeForScrolling(dx: Int) =

            100.coerceAtMost(super.calculateTimeForScrolling(dx))

    }

}



protected fun distanceToCenter(targetView: View, helper: OrientationHelper): Int {

    val childCenter = (helper.getDecoratedStart(targetView)

            + helper.getDecoratedMeasurement(targetView) / 2)

    val containerCenter = helper.startAfterPadding + helper.totalSpace / 2

    return childCenter - containerCenter

}

完整操作：

protected fun snapFromFling(

    lm: RecyclerView.LayoutManager,

    velocity: Int,

    helper: OrientationHelper

): Pair<Boolean, Int> {

    val targetPosition = findTargetSnapPosition(lm, velocity, helper)

    if (targetPosition == RecyclerView.NO_POSITION) return Pair(false, 0)

    val smoothScroller = createScroller(helper)

    smoothScroller.targetPosition = targetPosition

    lm.startSmoothScroll(smoothScroller)

    return Pair(true, targetPosition) // 消费fling

}

2、覆盖效果实现

（1）如果使用PageTransform实现

如果使用ViewPager的PageTransform，是可以实现覆盖动画的，实现思路：使可见View的第二个View跟随屏幕滑动

假设上图蓝色透明矩形为屏幕，其他为ItemView，图片上半部分正常滑动的状态，下半部分为 translate view 之后的状态。可以看到，在横向滑动过程中，最多可见2个View（蓝色透明方框最多覆盖2个View），此时将第二个View跟随屏幕，其他View保持跟随画布滑动，即可达到效果。在OnPageScroll回调中实现这个逻辑：

for (i in 0 until layoutManager.childCount) {

    layoutManager.getChildAt(i)?.also { view ->

        if (i == 1) {

            // view.left是个负数，offsetPx（=-view.left）是个正数

            view.translationX = offsetPx.toFloat() - view.width // 需要translate的距离（向前移需要负数）

        } else {

            // 恢复其余位置的translate

            view.translationX = 0f

        }

    }

}

（2）扩展RecyclerView实现覆盖翻页

知道如何通过 PageTransfrom 实现后，我们来看看直接使用 RecyclerView 如何实现。观看ViewPager2源码可知PageTransfrom的实现方式

故我们直接copy代码，在OnScrollListener中自行实现onPageScrolled回调即可实现覆盖翻页效果。

但是此时还有一个问题，就是子View的层级问题，你会发现上面的滑动示意图中，绿色View会在黄色View之上，如何解决这个问题呢？我们需要控制View的绘制顺序，前面的View后绘制，保证前面地View在后面的View的绘制层级之上。

观看源码会发现，RecyclerView其实提供了一个回调ChildDrawingOrderCallback，可以很方便地实现这个效果：

override fun attach() {

    super.attach()

    mRecyclerView.setChildDrawingOrderCallback(this)

}



override fun onGetChildDrawingOrder(childCount: Int, i: Int) = childCount - i - 1 // 反向绘制

三、竖直滑动（Scroll Mode）

竖直滑动需要滑动到跨章的位置时才吸附（自动回滚到指定位置），需要实现两个效果：跨章吸附、跨章Fling阻断。我们可以在横向覆盖滑动（Slide Mode）的基础上做一个减法，首先将LayoutManager改为竖向的，然后实现上述两个效果。

1、跨章吸附

实现跨章吸附，我们先在 RecyclerView 的 Adapter 中对每个View进行一个标记：

companion object {

    const val TYPE_NONE = 100	  // 其他

    const val TYPE_FIRST_PAGE = 101  // 首页

    const val TYPE_LAST_PAGE = 102   // 末页

}





fun bind() { // onBindViewHolder 时调用

	itemView.tag = when {

    	textPage.isLastPage -> TYPE_LAST_PAGE

    	textPage.isFirstPage -> TYPE_FIRST_PAGE

    	else -> TYPE_NONE

	}

	......

}

其次我们实现横向覆盖滑动（Slide Mode）中的一段代码（做一个减法）：

// 如果不是章节的最后一页，则消费Snap（不进行吸附操作）

override fun consumeSnap(index: Int, child: View) =

    index == 0 && child.tag != ReadBookAdapter.TYPE_LAST_PAGE

这样就可以实现不是跨越章节的翻页不进行吸附，而跨越章节的滑动会自动吸附。

2、跨章Fling阻断

在滑动过程中，基于可见View只有两个的情况：

• 如果向上滑动，判断第一个可见View是否「末页」，如果是，smoothScroll到第二个可见View


• 如果向下滑动，判断第二个可见View是否「首页」，如果是，smoothScroll到第一个可见View

private var inFling = false     // 正在fling，在OnFlingListener中设置为true

private var inBlocking = false  // 阻断fling





override val mScrollListener = object : RecyclerView.OnScrollListener() {

    var mScrolled = false



    override fun onScrollStateChanged(recyclerView: RecyclerView, newState: Int) {

        when (newState) {

            RecyclerView.SCROLL_STATE_DRAGGING -> {

                inFling = false // 重置inFling

            }

            RecyclerView.SCROLL_STATE_IDLE -> {

                inFling = false // 重置inFling

                if (inBlocking) {

                    inBlocking = false  // 忽略阻断造成的IDLE

                } else if (mScrolled) {

                    mScrolled = false

                    snapToTargetExistingView(orientationHelper.value)

                }

            }

        }

    }



    override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {

        if (dy != 0) {

            if (!mScrolled) {

                this@VSnapHelper.mCallback.onScrollBegin()

                mScrolled = true

            }

            val lm = mRecyclerView.layoutManager ?: return

            // fling阻断

            if (inFling && !inBlocking) {

                val child: View?

                val type: Int

                if (dy > 0) { // 向上滑动

                    child = lm.getChildAt(0)

                    type = ReadBookAdapter.TYPE_LAST_PAGE

                } else {

                    child = lm.getChildAt(lm.childCount - 1)

                    type = ReadBookAdapter.TYPE_FIRST_PAGE

                }

                child?.let {

                    if (it.tag == type) {

                        inBlocking = true

                        val d = distanceToCenter(it, orientationHelper.value)

                        mRecyclerView.smoothScrollBy(0, d)

                    }

                }

            }

        }

    }

}

四、仿真页（Flip Mode）

仿真页在横向覆盖滑动（Slide Mode）基础之上实现，我们还需要实现：

1、确认手指滑动方向

滑动方向不能直接在 onTouch、dispatchTouchEvent 这些方法中直接判断，
因为极微小的滑动都会决定方向，这样会造成轻微触碰就判定了方向，导致页面内容闪动、抖动等问题。
我们需要在滑动了一定距离后确定方向，最好的选择就是在 onPageScroll 中进行判断，系统为我们保证了ScrollState已变为DRAGGING，此时用户100%已经在滑动。可以看下源码真正触发「onPageScroll」的条件有哪些

我们实现的判断方向的代码：

// 在onScrolled中调用

// mCurrentItem：onPageSelected中赋值，代表当前Item

// position：第一个可见View的位置

// offsetPx：第一个可见View的left取负

// mForward：方向，true为画布向左滑动（向尾部滑动），false画布向右滑动（向头部滑动）

private fun dispatchScrolled(position: Int, offsetPx: Int) {

    if (mScrollState == RecyclerView.SCROLL_STATE_DRAGGING) {

        mForward = mCurrentItem == position

    }

    mCallback.onPageScrolled(position, mCurrentItem, offsetPx, mForward)

}

不过这个规则在超快速滑动时会判断错误，即settling直接变dragging的时候，所以会对滑动做一点限制

override fun dispatchTouchEvent(e: MotionEvent): Boolean {

    if (snapHelper.mScrollState == RecyclerView.SCROLL_STATE_SETTLING) {

        return true // sellting过程中禁止滑动

    }

    delegate.onTouch(e)

    return super.dispatchTouchEvent(e)

}

2、遮盖效果

所有可见View都跟随屏幕，横向覆盖滑动（Slide Mode）的增强版，因为给 RecyclerView设置了 offScreenLimit=1 的效果，所以 LayoutManager 的 child 数量最多会有4个
（参照 ViewPager2 # LinearLayoutManagerImpl 实现，这里设置是为了滑动时可以第一时间生成目标页的截图）

// onPageScrolled中调用

private fun transform(offsetPx: Int, firstVisible: Int) {

    val count = layoutManager.childCount

    if (count == 2 || (count == 3 && offsetPx == 0)) {

		// 可见View只有一个的时候，全部复位

        for (i in 0 until count) {

            layoutManager.getChildAt(i)?.also { view ->

                view.translationX = 0f

            }

        }

    } else {

        var target = 1

        if (count == 3 && firstVisible == 0) target-- // 首位适配，currentItem=0且存在滑动的时候

        for (i in 0 until layoutManager.childCount) {

            layoutManager.getChildAt(i)?.also { view ->

                when (i) {

                    target -> view.translationX = offsetPx.toFloat()

                    target + 1 -> view.translationX = offsetPx.toFloat() - view.width

                    else -> view.translationX = 0f

                }

            }

        }

    }

}

3、绘制次序根据拖拽方向改变

保证目标页在当前页之上，防止绘制的仿真页消失时出现闪屏（瞬间显示了不正确的页）

// 画布左移则反向绘制，右移则正想绘制

override fun getDrawingOrder(childCount: Int, i: Int) =

    if (snapHelper.mForward) childCount - i - 1 else i

4、绘制仿真页

我们在 RecyclerView 的父View上直接覆盖绘制一层仿真页Bitmap

（1）生成截图

如上面所说，实现了 offScreenLimit=1 的效果，我们在首次获取到方向时生成截图：

// 生成截图方法

fun View.screenshot(): Bitmap? {

    return runCatching {

        val screenshot = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565)

        val c = Canvas(screenshot)

        c.translate(-scrollX.toFloat(), -scrollY.toFloat())

        draw(c)

        screenshot

    }.getOrNull()

}

private var isBeginDrag = false



override fun onPageStateChange(state: Int) {

    when (state) {

        RecyclerView.SCROLL_STATE_DRAGGING -> {

            isBeginDrag = true

        }

    }

}



override fun onPageScrolled(firstVisible: Int, current: Int, offsetPx: Int, forward: Boolean) {

    if (isBeginDrag) {

        isBeginDrag = false

        delegate.apply {

            if (forward) {

                nextBitmap?.recycle()

                nextBitmap = layoutManager.findViewByPosition(current + 1)?.screenshot()

                curBitmap?.recycle()

                curBitmap = layoutManager.findViewByPosition(current)?.screenshot()

            } else {

                prevBitmap?.recycle()

                prevBitmap = layoutManager.findViewByPosition(current - 1)?.screenshot()

                curBitmap?.recycle()

                curBitmap = layoutManager.findViewByPosition(current)?.screenshot()

            }

            setDirection(if (forward) AnimDirection.NEXT else AnimDirection.PREV)

        }

        invalidate()

    }

}

（2）绘制仿真页

绘制仿真页参考 gedoor/legado 的 SimulationPageDelegate

• 基础知识：三角函数、Android的矩阵、贝塞尔曲线、canvas.clipPath的 XOR & INTERSECT 模式


• 绘制方法：Android仿真翻页：cnblogs.com


• 计算方法：使用手指触摸点和触摸点对应的角位置（比如触摸点靠近右下角，角位置就是右下角），这两个点可以算出所有参数

确认方向后，我们只用通过修改手指触碰点的参数即可控制整个动画（根据点击位置实时计算即可）

5、动画控制

手指抬起后的翻页动画通过 Scroller+invalidate实现

override fun computeScroll() {

    if (scroller.computeScrollOffset()) {

        setTouchPoint(scroller.currX.toFloat(), scroller.currY.toFloat())

    } else if (isStarted) {

        stopScroll()

    }

}

对于Fling和Scroll Idle产生的吸附效果，我们需要各自回调方向：

// 选中时开始动画，此时position改变

override fun onPageSelected(position: Int) {

    val page = adapter.data[position]

    ReadBook.onPageChange(page)

    if (canDraw) {

        delegate.onAnimStart(300, false)

    }

}



// position未改变的情况

override fun onSnap(isFling: Boolean, forward: Boolean, changePosition: Boolean) {

    if (!changePosition) {

        delegate.onAnimStart(

            300,

            true,

            // 未改变方向，向前则播放向后动画

            if (forward) AnimDirection.PREV else AnimDirection.NEXT

        )

    }

}

Scroll Idle通过 SmoothScroll 所需要滑动的距离正负判断方向：

// Scroll

override fun snapToTargetExistingView(helper: OrientationHelper): Pair<Int, Int>? {

    mSnapping = true

    super.snapToTargetExistingView(helper)?.also {

        // first为滑动距离，second为目标Item的position

        mCallback.onSnap(false, it.first > 0, mCurrentItem != it.second)

        return it

    }

    return null

}



// Fling

override val mFlingListener = object : RecyclerView.OnFlingListener() {

    override fun onFling(velocityX: Int, velocityY: Int): Boolean {

        val lm = mRecyclerView.layoutManager ?: return false

        mRecyclerView.adapter ?: return false

        val minFlingVelocity = mRecyclerView.minFlingVelocity

        val result = snapFromFling(

            lm,

            velocityX,

            orientationHelper.value

        )

        val consume = abs(velocityX) > minFlingVelocity && result.first

        if (consume) {

            mSnapping = true

            // second为目标Item的position，这里直接通过速度正负来判断方向

            mCallback.onSnap(true, velocityX > 0, result.second != mCurrentItem)

        }

        return consume

    }

}

(以上为所有关键点，只截取了部分代码，提供一个思路)

前言

可能对不少人来说，Lambda显得陌生又复杂，觉得Lambda会导致代码可读性下降，诟病Lambda语法，甚至排斥。

其实所有的这些问题，在尝试并熟悉后，可能都不是问题。

对Lambda持怀疑态度的人，也许可以采取渐进式使用Lambda的策略。在一些简单和低风险的场景下先尝试使用Lambda，逐渐增加Lambda表达式的使用频率和范围。

毕竟2023年了，JDK都出了那么多新版本，是时候试试Lambda了！

耐心看完，你一定有所收获。

正文

1. 对集合进行遍历和筛选：

使用Lambda表达式结合Stream API可以在更少的代码量下实现集合的遍历和筛选，更加简洁和易读。

原来的写法：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

for (Integer num : numbers) {

    if (num % 2 == 0) {

        System.out.println(num);

    }

}

优化的Lambda写法：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

numbers.stream()

       .filter(num -> num % 2 == 0)

       .forEach(System.out::println);

2. 对集合元素进行排序：

使用Lambda表达式可以将排序逻辑以更紧凑的形式传递给sort方法，使代码更加简洁。

原来的写法：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

Collections.sort(names, new Comparator<String>() {

    public int compare(String name1, String name2) {

        return name1.compareTo(name2);

    }

});

优化的Lambda写法：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

names.sort((name1, name2) -> name1.compareTo(name2));

3. 集合的聚合操作：

Lambda表达式结合Stream API可以更优雅地实现对集合元素的聚合操作，例如求和、求平均值等。

原来的写法：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

int sum = 0;

for (Integer num : numbers) {

    sum += num;

}

优化的Lambda写法：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

int sum = numbers.stream()

                 .reduce(0, Integer::sum);

4. 条件过滤和默认值设置：

使用Lambda的Optional类可以更加优雅地处理条件过滤和默认值设置的逻辑。

原来的写法：

String name = "Alice";

if (name != null && name.length() > 0) {

    System.out.println("Hello, " + name);

} else {

    System.out.println("Hello, Stranger");

}

Lambda写法：

String name = "Alice";

name = Optional.ofNullable(name)

               .filter(n -> n.length() > 0)

               .orElse("Stranger");

System.out.println("Hello, " + name);

5. 简化匿名内部类：

可以简化代码，同时提高代码可读性。

举个创建Thread的例子，传统方式使用匿名内部类来实现线程，语法较为冗长，而Lambda表达式可以以更简洁的方式达到相同的效果。

原来的写法：

new Thread(new Runnable() {

    public void run() {

        System.out.println("Thread is running.");

    }

}).start();

Lambda写法：

new Thread(() -> System.out.println("Thread is running.")).start();



new Thread(() -> {

    // 做点什么

}).start();

这种写法也常用于简化回调函数，再举个例子：

假设我们有一个简单的接口叫做Calculator，它定义了一个单一的方法calculate(int a, int b)来执行数学运算：

// @FunctionalInterface: 标识接口是函数式接口，只包含一个抽象方法，从而能够使用Lambda表达式来实现接口的实例化

@FunctionalInterface 

interface Calculator {

    int calculate(int a, int b);

}

现在，让我们创建一个名为CallbackExample的类。该类有一个名为operate的方法，它接受两个整数和一个Calculator接口作为参数。该方法将使用提供的Calculator接口执行计算并返回结果：

public class CallbackExample {



    public static int operate(int a, int b, Calculator calculator) {

        return calculator.calculate(a, b);

    }



    public static void main(String[] args) {

        int num1 = 10;

        int num2 = 5;



        // 使用Lambda作为回调

        int sum = operate(num1, num2, (x, y) -> x + y);

        int difference = operate(num1, num2, (x, y) -> x - y);

        int product = operate(num1, num2, (x, y) -> x * y);

        int division = operate(num1, num2, (x, y) -> x / y);



        System.out.println("Sum: " + sum);

        System.out.println("Difference: " + difference);

        System.out.println("Product: " + product);

        System.out.println("Division: " + division);

    }

}

通过在方法调用中直接定义计算的行为，我们不再需要为每个运算创建多个实现Calculator接口的类，使得代码更加简洁和易读

6. 集合元素的转换：

使用Lambda的map方法可以更优雅地对集合元素进行转换，提高代码的可读性

原来的写法：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

List<String> uppercaseNames = new ArrayList<>();

for (String name : names) {

    uppercaseNames.add(name.toUpperCase());

}

Lambda写法：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

List<String> uppercaseNames = names.stream()

                                   .map(String::toUpperCase)

                                   .collect(Collectors.toList());

7. 对集合进行分组和统计：

以更紧凑的形式传递分组和统计的逻辑，避免了繁琐的匿名内部类的声明和实现。

通过groupingBy、counting、summingInt等方法，使得代码更加流畅、直观且优雅。

传统写法：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Amy", "Diana");



// 对名字长度进行分组

Map<Integer, List<String>> namesByLength = new HashMap<>();

for (String name : names) {

    int length = name.length();

    if (!namesByLength.containsKey(length)) {

        namesByLength.put(length, new ArrayList<>());

    }

    namesByLength.get(length).add(name);

}

System.out.println("Names grouped by length: " + namesByLength);



// 统计名字中包含字母'A'的个数

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Amy", "Diana");

int namesWithA = 0;

for (String name : names) {

    if (name.contains("A")) {

        namesWithA++;

    }

}

System.out.println("Number of names containing 'A': " + namesWithA);

Lambda写法：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Amy", "Diana");



// 使用Lambda表达式对名字长度进行分组

Map<Integer, List<String>> namesByLength = names.stream()

        .collect(Collectors.groupingBy(String::length));

System.out.println("Names grouped by length: " + namesByLength);



// 使用Lambda表达式统计名字中包含字母'A'的个数

long namesWithA = names.stream()

        .filter(name -> name.contains("A"))

        .count();

System.out.println("Number of names containing 'A': " + namesWithA);

8. 对大数据量集合的并行处理

当集合的数据量很大时，通过Lambda结合Stream API可以方便地进行并行处理，充分利用多核处理器的优势，提高程序的执行效率。

假设我们有一个包含一百万个整数的列表，我们想要计算这些整数的平均值：

import java.util.ArrayList;

import java.util.List;

import java.util.concurrent.ThreadLocalRandom;



public class ParallelStreamExample {

    public static void main(String[] args) {

        // 创建一个包含一百万个随机整数的列表

        List<Integer> numbers = new ArrayList<>();

        for (int i = 0; i < 1000000; i++) {

            numbers.add(ThreadLocalRandom.current().nextInt(100));

        }



        // 顺序流的处理

        long startTimeSeq = System.currentTimeMillis();

        double averageSequential = numbers.stream()

                                         .mapToInt(Integer::intValue)

                                         .average()

                                         .getAsDouble();

        long endTimeSeq = System.currentTimeMillis();

        System.out.println("Sequential Average: " + averageSequential);

        System.out.println("Time taken (Sequential): " + (endTimeSeq - startTimeSeq) + "ms");



        // 并行流的处理

        long startTimePar = System.currentTimeMillis();

        double averageParallel = numbers.parallelStream()

                                       .mapToInt(Integer::intValue)

                                       .average()

                                       .getAsDouble();

        long endTimePar = System.currentTimeMillis();

        System.out.println("Parallel Average: " + averageParallel);

        System.out.println("Time taken (Parallel): " + (endTimePar - startTimePar) + "ms");

    }

}

分别使用顺序流和并行流来计算列表中整数的平均值：

• 顺序流：通过stream()方法获取流，使用mapToInt将Integer转换为int，然后使用average()方法计算平均值


• 并行流：使用parallelStream()方法获取并行流，其他步骤与顺序流相同

查看输出结果：

Sequential Average: 49.517461

Time taken (Sequential): 10ms

Parallel Average: 49.517461

Time taken (Parallel): 3ms

可以看出，顺序流和并行流得到了相同的平均值，但并行流的处理时间明显少于顺序流。因为并行流能够将任务拆分成多个小任务，并在多个处理器核心上同时执行这些任务。

当然并行流也有缺点：

• 对于较小的数据集，可能并行流更慢


• 数据处理本身的开销较大，比如复杂计算、大量IO操作、网络通信等，可能并行流更慢


• 可能引发线程安全问题

收尾

Lambda的使用场景远不止这些，在多线程、文件操作等场景中也都能灵活运用，一旦熟悉后可以让代码更简洁，实现精准而优雅的编程。

写代码时，改变偏见需要我们勇于尝试和付诸行动。有时候，我们可能会对某种编程语言、框架或设计模式持有偏见，认为它们不适合或不好用。但是，只有尝试去了解和实践，我们才能真正知道它们的优点和缺点。

当我们愿意打破旧有的观念，敢于尝试新的技术和方法时，我们就有机会发现新的可能性和解决问题的新途径。不要害怕失败或犯错，因为每一次尝试都是我们成长和进步的机会。

只要我们保持开放的心态，不断学习和尝试，我们就能够超越偏见，创造出更优秀的代码和解决方案。

所以，让我们在编程的路上，积极地去挑战和改变偏见。用行动去证明，只有不断地尝试，我们才能取得更大的进步和成功。让我们敢于迈出第一步，勇往直前，一同创造出更美好的编程世界！

前言

目前大多数库api设计都是Log.d("tag", "msg")这种风格，而且支持自定义日志存储的比较少，
所以作者想自己造一个轮子。

这种api风格有什么不好呢？

首先，它的tag是一个字符串，需要开发人员严格管理tag，要不然可能各种硬编码的tag满天飞。

另外，它也可能导致性能陷阱，假设有这么一段代码：

// 打印一个List

Log.d("tag", list.joinToString())

此处使用Debug打印日志，生产模式下调高日志等级，不打印这一行日志，但是list.joinToString()这一行代码仍然会被执行，有可能导致性能问题。

下文会分析作者期望的api是什么样的，本文演示代码都是用kotlin，库中好用的api也是基于kotlin特性来实现的。

作者写库有个习惯，对外开放的类或者全局方法都会加一个前缀f，一个是为了避免命名冲突，另一个是为了方便代码检索，以下文章中会出现，这里做一下解释。

期望

什么样的api才能解决上面的问题呢？我们看一下方法的签名和打印方式

inline fun <reified T : FLogger> flogD(block: () -> Any)

interface AppLogger : FLogger

flogD {

    list.joinToString { it }

}

flogD方法打印Debug日志，传一个Flogger的子类AppLogger作为日志标识，同时传一个block来返回要打印的日志内容。

日志标识是一个类或者接口，所以管理方式比较简单不会造成tag混乱的问题，默认tag是日志标识类的短类名。生产模式下调高日志等级后，block就不会被执行了，避免了可能的性能问题。

实现分析

日志库的完整实现已经写好了，放在这里xlog

• 支持限制日志大小，例如限制每天只能写入10MB的日志


• 支持自定义日志格式


• 支持自定义日志存储，即如何持久化日志

这一节主要分析一下实现过程中遇到的问题。

问题：如果App运行期间日志文件被意外删除了，怎么处理？

在Android中，用java.io的api对一个文件进行写入，如果文件被删除，继续写入的话不会抛异常，这样会导致日志丢失，该如何解决？

有同学说，在写入之前先检查文件是否存在，如果存在就继续写入，不存在就创建后写入。

检查一个文件是否存在通常是调用java.io.File.exist()方法，但是它比较耗性能，我们来做一个测试：

measureTime {

    repeat(1_0000) {

        file.exists()

    }

}.let {

    Log.i("MainActivity", "time:${it.inWholeMilliseconds}")

}

14:50:33.536 MainActivity            com.sd.demo.xlog                I  time:39

14:50:35.872 MainActivity            com.sd.demo.xlog                I  time:54

14:50:38.200 MainActivity            com.sd.demo.xlog                I  time:43

14:50:40.028 MainActivity            com.sd.demo.xlog                I  time:53

14:50:41.693 MainActivity            com.sd.demo.xlog                I  time:58