序言

最近浪漫心饱满，于是写了个心形控件。可以将一切内容约束成心形，并且支持两种心形，使用起来很简单，就当成FrameLayout就行了。
让一切都浪漫起来

效果

下面依次展示的是：

1. 包裹ScrollView ，形状为桃心


2. 包裹ScrollView，形状为圆心


3. 包裹WebView，形状为圆心

代码

LoveLayout

主要代码就是下面的。

package com.example.myapplication;



import android.content.Context;

import android.content.res.TypedArray;

import android.graphics.Canvas;

import android.graphics.Path;

import android.util.AttributeSet;

import android.widget.FrameLayout;



import androidx.annotation.NonNull;

import androidx.annotation.Nullable;



/**

 * <pre>

 * Created by zhuguohui

 * Date: 2023/6/6

 * Time: 10:26

 * Desc:爱心Layout

 * </pre>

 */

public class LoveLayout extends FrameLayout {



    private Path path1;

    private int heardType;



    public LoveLayout(@NonNull Context context) {

        super(context);

    }



    public LoveLayout(@NonNull Context context, @Nullable AttributeSet attrs) {

        super(context, attrs);

        TypedArray array = context.obtainStyledAttributes(attrs, R.styleable.LoveLayout);

        heardType = array.getInt(R.styleable.LoveLayout_HeardType,0);

        array.recycle();



    }



    @Override

    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {

        super.onLayout(changed, left, top, right, bottom);

        if(heardType==0) {

            getHeardPath();

        }else{

            getHeardPath2();

        }

    }



    private void getHeardPath(){



        int px = getMeasuredWidth() / 2;

        int py = getMeasuredHeight() / 2;

        path1=new Path();

        path1.moveTo(px, py);

        float rate=getMeasuredWidth()*1.0f/34;

        // 根据心形函数画图

        for (double i = 0; i < 2 * Math.PI; i += 0.001) {

            float x = (float) (16 * Math.sin(i) * Math.sin(i) * Math.sin(i));

            float y = (float) (13 * Math.cos(i) - 5 * Math.cos(2 * i) - 2 * Math.cos(3 * i) - Math.cos(4 * i));

            x *= rate;

            y *= rate;

            x = px - x;

            y = py - y;

            path1.lineTo(x, y);

        }

    }



    private void getHeardPath2(){

//        f(x)=sqrt(1-(abs(x)-1)^2)

//        h(x)=-2*sqrt(1-0.5*abs(x))

        path1=getPathByMathFunction(x -> (float) Math.sqrt(1-Math.pow((Math.abs(x)-1),2)));

        Path path2=getPathByMathFunction(x->(float) (-2* Math.sqrt(1-0.5*Math.abs(x))));

        path1.moveTo(0,getMeasuredHeight()*1.0f/2);

        path1.addPath(path2);

    }



    private interface MathFunction{

        float call(float x);

    }



    private Path getPathByMathFunction(MathFunction function){

       Path path=new Path();

        path.moveTo(0,getMeasuredHeight()*1.0f/2);

        int px = getMeasuredWidth() / 2;

        int py = getMeasuredHeight() / 2;

        float scale=getMeasuredWidth()*1.0f/4;

        for(float i=-2;i<=2;i+=0.01){

            float x=i;

            float y= function.call(x);

            x*=scale;

            y*=scale;

            x=px-x;

            y=py-y;



            path.lineTo(x,y);

        }

        return path;

    }



    @Override

    protected void dispatchDraw(Canvas canvas) {

        int save = canvas.save();

        canvas.clipPath(path1);

        super.dispatchDraw(canvas);

        canvas.restoreToCount(save);

    }

}

xml属性

<?xml version="1.0" encoding="utf-8"?>

<resources>





    <declare-styleable name="LoveLayout">



        <attr name="HeardType">

            <!-- 桃心 -->

            <enum name="PeachHeart" value="0" />

            <!-- 圆一点的心 -->

            <enum name="CircularHeart" value="1" />

        </attr>

    </declare-styleable>





</resources>

数学原理

圆心是按照以下公式实现的，桃心是网上找到的代码改的，没找到公司。

使用

很简单，当成FrameLayout包裹就行了。

笔者是一名程序员老司机，局限于笔者文笔一般，想到哪写到哪__胡乱写一通，篇幅较长

_，希望通过文章的方式简单的回顾过去、总结现在和展望未来，顺便记录一下，方便以后总结。_

回顾 

忙忙碌碌又一年，看着自己的发量在逐渐的减少，深感焦虑，今天终于有时间可以回顾自己过去一年的得与失，去年是写给35岁的自己，今年该+1了，还是随笔的方式，想到哪写到哪。

2022年1月30日的时候 ，给自己过去的工作做一次简单的总结，主要还是写给自己，就像现在的时候可以回过头去看，也收获了许多朋友的关注，回去看一年前写的文章，以及大家的留言反馈，深有感触。

回看去年的flag，首先需要检讨一下，基本上都没有完成，但是自己也朝着这个目标在做，收获也是有的：

读书

每个月一本书，一年完成至少10本书的学习计划，学以致用，而不是读完就忘。

写文章

一周完成一篇原创文章，不限类别

早睡早起

每天不晚于11:30休息

关于读书

上半年的时候，自己也是有点焦虑和迷茫，想成长想进步，所以焦虑心情自然就会出现，所以看了一些鸡汤书籍，什么《被讨厌的勇气》、《程序员的自我修养》、《情商》等等。实话说看完之后，确实能够缓解缓解内心的焦虑情绪，但是这些书籍能给到自己的，更多是一些方式和方法，对于内心的空洞和不充实带来的焦虑是没办法缓解的。

所以还需要对症下药，我自己所感受到的空洞和不充实，很多是来自自己对技术知识技能的缺乏和退步，说白了就是作为技术人，不能把技术给弄丢了 ，同样也想不断的跟上时代的步伐。

想要快速解决这种“焦虑”，我需要快速的制定一个短期、中期、长期的目标，围绕着目标去充实自己的知识体系。这里所说的目标还是比较容易制定的，毕竟是关乎自己的成长，也就是自己接下来想要成为什么样的人，什么样的知识体系能够让自己在当前以及未来几年的工作中都有帮助。从这个方面去想，首先未来还是想从事前端，所以我给自己制定的短期目标是算法成长 、中期目标是计算机图形学方面的知识掌握、长期目标是成为一名地图领域的技术专家（ps:说到这里先立个flag，我后面想写一个小册，专门关于地图领域相关的，我也是比较期待自己能写出来什么样的小册，不为别的，就是想把自己的知识沉淀下来)。

讲讲为什么要这么去规划目标，算法算是现在任何技术面试都会涉及的，但是我不是为了面试去看，而是为了提升自己在团队内部的技术影响力，《算法图解》这本书写的简单好理解，作者的思路非常清晰 ，看完之后给团队内部的同学分享，不仅能提升自己，还能带动团队一起学习，一举多得。计算机图形学知识是目前工作中会碰到的，比如渲染、大数据可视化、自动驾驶等等都会涉及，这一部分不建议大家先去看书，没有一本书能够说明白，推荐大家去搜《闫令琪》，非常厉害的大佬，上班路上每天花半个小时-1小时足够了，一个月基本上能够学完，之后再运用到工作中，融会贯通。

单独再讲讲长远目标，我之前并不是搞地图方向的，但是近期这份工作有机会接触到了这方面的工作，让我又重新燃起了工作中的那种欲望，很久没有工作中的那种成就感，这也许是10年前才会有的那种热情，所以我比较坚信未来几年自己希望能够深入投入这个方向，不一定是地图，但一定是和这个方向相关的领域，因为知识都是想通的。

关于写文章

写文章这件事情，我非常佩服一位前同事，也或许是因为我没有做到 ，但是别人坚持每天每日的在做 ，他连续两年每天都能产出一篇原创，关于各个方面的，这是值得我学习的地方，今年争取突破自己。

关于早睡

头发卡卡掉，感觉都是因为没有按时睡觉引起的，还是在能有条件的时候，尽量早睡。

工作

今年的工作可以用“黑暗”、“光明”两个词来概括。

黑暗

2022年经历疫情最严重的一年，大部分时间都是居家办公状态，这也导致和同事们的交流变得很少，很多想要推进的工作变得没那么顺利，徒增了不少压力。

2022年也是“财源滚滚”的一年，看着同事一个个离开，也有不少同事询问工作机会，也确实给自己内心带来不小的冲击，同时危机感也很明显。

在一个地方工作一段时间之后，多少都会遇到各种各样的问题，技术上是最省心的问题，解决就好。有江湖的地方就会有各种复杂到不敢想的关系网，谁是谁的小弟，谁是谁的心腹、谁是大老板招来的等等，遇到这种问题我更多的是做好自己，但我更多还是更愿意沉浸在技术的知识中，享受解决问题带来的快感。面对频繁换老板，技术人的通病，不善于抱大腿，当然我也不想在这方便再去做过多改变或者违背内心去做一些事情，保持好内心的底线，不突破我的底线则相安无事。

光明

呵护好内心的明灯

今年工作最大的动力是来自于自身能力的成长，规划的短中长目标基本上都在按照正确的方向在行进，这也是在排除各种各样的干扰后带来的好的结果，也是抱着一种积极向上的心态在努力，工作中最让人糟心的，无非就是背锅、背指标、裁员，最坏的情况也就这样了，守好内心的方向，做自己想做的事情就对了，自己左右不了的事情不去想太多，行业不景气的时候，我基本上是以这种心态在工作，人生并不是只有工作。

人情往来

工作中

今年在和外部部门的合作当中，收获了许多的认可，也建立了许多新的人脉关系，这也是人生中比较宝贵的资源。与合作方合作共赢一直都是我做事的指导方法 ，提前思考好双方的目标和边界，剩下的就是努力合作完成目标了。相信他人，他人也会给予你同样的信任。

生活中

生活中的关系会比工作中的关系更加的牢靠，当然工作中的关系发展的好的话，也可以沉淀到生活中，而不是换个工作全没了，今年工作中积累的关系，确实是可以有这方面的转换的，这也是一种收获。

技术成长

我一直都不太赞成技术人转纯管理这个方向，管好人其实可以很简单，丑话在前，用心对待，以诚相待，能做好这三点感觉都不会有太大问题，但技术丢了就很难再捡起来了，切记切记。

今年反尝试不直接带团队，更多的是以技术顾问、专家视角，甚至是一线coding的方式在工作，看似管人但又不管人，所以在技术上成长也是非常快的，少了很多其他的琐事，能够更加投入。

渲染

第一次接触这个词的时候是在2021年，公司专门配了一个渲染团队做这个事情，用前端白话讲，就是能把各种各样的图像画到canvas上，一个好的渲染引擎可以呈现任何想要呈现的物体。

为了学习渲染是做什么的，怎么做，当时把简单的数学知识重新学习了一下，看闫令琪大佬的课，看openGL、webGPU等等相关的知识，过程是比较辛苦的，但收获也是很多的。现在再看一些框架就能够理解为什么代码会这么写了，比如Threejs、deckgl等等，我们自己也用c++实现了一套底层的跨端渲染框架，虽然不全面，但内部够用同时也能提升自身技术水平。

架构

架构能力是随着工作中不断积累起来能力，当然这也需要在工作中不断的打磨和锻炼，如果一直是以完成任务的心态在工作那是很难练出来的。我所推崇的架构能力是以解决业务问题为主，提升产研的效率为辅。所以在工作中不会刻意去做架构，而是围绕着如何解决问题去架构，如何才能控制好不至于过度设计。

举个简单例子，假如我们已经有各种完善的点餐业务，需要做一个邀请大家一起喝奶茶的这么一个功能，从业务上我们先考虑两个核心逻辑：

1、用户点餐之后回到邀请页面，点完的所以人实时能看到其他人下单状态

2、队长确认所有人点完之后，下单付款，所有人的页面切换到送餐状态

如果是快速实现这个功能的话，其实是比较简单的，起一个轮询任务实时问服务端要数据，拿到数据后，根据状态决定下一步显示什么状态的页面

但是随着业务发展，会加入很多奇怪的逻辑，比如要支持修改、删除、踢人等等，这就会导致这个页面逻辑及其的复杂起来，如果不去思考的话，很容易就写出一堆面条代码，最后自己都不愿意去改。

所以针对这个功能  ，我自己会抽象成几部分去思考：

1、store该如何拆解，拆成几个，每个store对应哪个组件

2、store该如何去更新

3、与服务端如何通信，websocket、轮询都可以，看当下实际情况，保证稳定性即可

4、可以写几个js类去做这个事情，每个类的职责是什么

我觉得思考完这几个问题 ，大家对于这个页面该怎么去写应该能有一个很清晰的架构图在脑海中了吧，这里我就不过多展开了 ，有兴趣的话私聊，核心是要说架构其实也可以很简单。

总结

今年就不立flag了，目标能把去年的flag实现好，2023年是疫情结束的一年 ，我认为这是一个好的开始，努力工作是一方面，享受生活我认为也同样重要，今年更需要做好工作和生活的平衡，工作以外能有一些其他的成就。

写给36岁的自己，简单地回顾过去、总结现在、展望未来，希望当37岁的自己回过头来看的时候，能够鄙视现在的自己，写出更好的《写给37岁的自己》。

做技术是打怪兽不是养宠物，为什么要打怪兽？因为难；为什么难很重要？因为难的事情才能带来成长；为什么要成长？承认吧，因为「如何成长」是当代人，包括你我他在内焦虑的源泉。

过去几个月内我在写一系列主题为「NodeJS实战」的文章，内容来源是过去两年独自开发和运维 site2share 网站的经验，本篇文章是对这个系列的一个暂时收尾。

今天我不聊代码，聊些更重要的事情

养宠物

从两件事情开始说起

其一是在此之前，我直接或间接听到了一些来自早已离开项目同学的声音，陈旧的项目技术栈和代码是驱使他们离开的原因之一。

其二是在偶尔浏览掘金网站的内容过程中，有一类让我印象深刻的文章标题，大意诸如「教你用xx + xx + xx 打造一个开源系统」，因为我关注前端领域的关系，标题里的 xx 通常是围绕某个前端框架的时髦技术栈，从点赞和评论数来看它们颇受欢迎。

对于前者我当然理解：一方面脱离当下容易让自己丧失竞争力，不管你愿不愿意承认，简历驱动型开发是所有程序员秘而不宣的默契；另一方面陈旧代码给开发工作带来的挫败感不言而喻，我相信每个程序员面对「屎山代码」都有宁愿把它重写也不愿意修改一行的冲动。第二件事的出现也就顺理成章了：我想毫无负担地学习新技术，还能抛开白天工作中的螺丝钉角色，体验一次愉快的项目实战经历。

我把从零开始做新项目比喻为「养宠物」，因为它能给你带来无与伦比的掌控感。假设一个代码库完全是由你一手搭建的话，那么关于它的一切，例如如何启动、如何部署、它适用于什么场景又无法解决什么样的问题你都心中有数。如果你恰巧又在Thoughtworks 工作，那么Thoughtworks 工作体验更增强了这种掌控感的正当性：对于有坏味道的代码我们允许用工作时间进行重构，对于代码内不懂的知识点，只要提出问题就一定可以得到回答。

也许是我运气不够好，我的工作经验告诉我，「养宠物」般的工作机会是可遇而不可求，在大厂晋升靠造轮子而不是填坑是公理人尽皆知，但造轮子的机会屈指可数。维护遗留系统依然是我们大部分人的工作。这也就是我接下来想说的「打怪兽」，此时我们面对的系统哪怕只上线一年，源代码也可能是满目疮痍。

这里是对于下面不中听的一些话的免责声明，我不是在否定精通

React 没有价值，我也不认为简历驱动开发有什么错，只不过要小心它们让我们的眼界变得狭隘

打怪兽

真正的常态是我接下来想说的「打怪兽」。

之所以把它称为「打怪兽」，不仅仅因为你接触的代码会超出你的预期，你甚至想象不到你会遇到什么样（啼笑皆非亦或是让你无从下手）的困难：

- 这个一千行代码的文件应该从哪开始读起？
- 我如何才能让代码进入这个分支？
- 你发现项目用到的一个框架没有任何文档，在 github 上也找不到源码，原来是上一个离职的老大自己写的
- 项目的打包工具用的既不是webpack 也不是 grunt ，而是 shell 脚本
- 现在需要你优化一个超过包含上百个组件的 React 应用的性能

「怪兽」依然是一个友好的比喻，此时此刻你至少还能够把它具象化，将它和某些电影或者游戏里的角色联系在一起，这意味着它造成破坏的手段和范围是可以预知的。但工作中我们实际遇到的问题无法预测。

你一定想象不到在编写 site2share的过程中，困扰我最久的问题背后的罪魁祸首竟然是 ExpressJS 里的 trust proxy 参数，它导致 API 从来无法访问到部署在 Azure App Service 上的后端服务

为什么要打怪兽

实际的出发点正如上面所说，如果我们工作中绝大部分人、绝大部分时间面临的都是怪兽，那么逃避它就是自欺欺人。

说点不实际的，是因为打怪兽比养宠物更难——为什么「难」重要？因为难的事情才能带来成长。为什么要成长？承认吧，因为「如何成长」是当代人，包括你我他在内焦虑的源泉。

除此之外，我还想强调的是它在锻炼解决问题能力本身

随着工作的深入，越来越发现我的角色从「解决技术问题的人」变成「解决问题的人」：从 Javascript、SQL Server 到代码设计、代码规范，再到团队方向、团队培养。整个过程其实不允许你循序渐进地去适应，可能明天醒来新的问题就摆在你面前，你也永远也没有准备好的那一天。也许可以把团队管理当作一门新技术用学习编程语言的方式去学习，也许求助对的人是当务之急，也许有的问题压根可以不解决。但无论如何，思路不会有如神助般凭空出现在你脑海里，举一反三需要的是练习。问题的多样性在练习的过程中起到非常大的作用，解决新问题会带给你明确的反馈：我的经验可以移植到这个领域，亦或者我的工作模式需要调整。

或者忘掉我上面的长篇大论，通俗点说，打完怪兽以后你就是见过「地狱」的人了，还怕什么。我想起来大二时候为了制作这款软件代码被推翻了无数次，从那之后就再也不怕重构了

另一方面，养宠物的风险在于，它让我们不自觉地陷入舒适区中。

我曾经有差不多有一年的时间可以自由选择技术栈来开发各式各样前端应用。最流行的框架和搭配起来最时髦的全家桶便成了我的不二之选。在热门冷门尝试了个遍之后最终我难免会对自己产生怀疑：**我似乎永远都在被输入，我永远都在给某个工具打工，如果今天哪个框架告诉我它是业内明日之星那我就要去学它，因为 fear of missing out 是每个技术人的通病。**我似乎能做的也只有如此了，但这就真的足够了吗？

工具正在变得自动化，并且「帮助」我们专注于业务开发这件事带有迷惑性。这里的陷阱在于他能替你做很多事，会让你以为你具备同样的能力的错觉。例如虽然 Parcel 可以无须任何一行配置就把脚本打包得漂漂亮亮的，但你可能对背后的缓存策略一无所知。当每个人都在简历上强调「精通 xx 框架」的今天，我们应该问自己除了框架我还有没有更有力的竞争力？

这类陷阱还有另一种变形是，在团队内你只做业务开发。身处大型开发组中会让你以为你有独立驾驭一个相同体量项目的能力，但实际遇到的问题会非常受限，因为功能性需求和底层设计已经交给你们团队的 Tech Lead 甚至是团队前成员去做了。（公允地说这不是完全负面，而是一件需要把握平衡的事情。虽然这会给团队成员的成长带来不利，但另一方面却可以让项目风险变得可控）

「打怪兽」也是在打破你的乌托邦

打怪兽的另一层含义是经历实战

「教你用 xx 打造 xx」这类系列教程的前置条件太美好了：你有无限的业余时间投入其中，你就是你自己的产品经理。但实际工作中我们永远是戴着镣铐跳舞。例如糟糕代码不一定是个人能力的结果，考虑到当时的交付压力，团队状态和历史包袱，换做你不一定能做得更好。所以大部分技术决策其实是在恶劣环境下做出的，然而如何学习在不同环境中作出恰当的反应，我不认为这是脱离实践可以达成的。

另一个问题是它缺少对方案的闭环验证：我不确定有多少此类项目投入到真实的商业运营中，如果没有，很遗憾它的代码就不一定是有效的。例如它设计有异常捕获功能，异常捕获的目的之一是帮助我们在实际运营过程中排查问题，那当异常发生时它可以提供什么样的信息帮助我们定位到错误代码？通常在捕获异常之后紧接着要把信息作为日志输出，有相当一部分公司其实购买的第三方日志系统，那集成难度如何？如果只有零星的用户上报了此类问题，我们可否在实际生产环境下，在每秒上千条日志增速的日志海洋里甄别到他们？

退一步说，即使方案完美无缺，我们还需要关注它的成本如何。再一次强调，实际工作中人力、时间都是有限的，假使我们能做到满分条件也不会允许。当你把方案拍到老板面前，但是他告诉你预算只有三成时，选择留下哪三分之一的功能，或者说如何用三成的预算做出来一个及格的功能比纯粹的编码更棘手。老板更多关心的是风险，说实话「时髦」技术表达的并不一定都是褒义，它意味着技术的关注度仍在持续提升中，意味着它还可能没有被大规模地应用，也意味着我们其实有更成熟的方案可供选择。决策者都厌恶风险，因此在推广新方案时风险可控也是因素之一。除此之外代码的学习曲线如何？代码库毕竟在依赖团队维护，你应当考虑到团队下限对于新技术的接受程度。

安卓埋点

在企业级安卓项目中，埋点是一项重要的技术，用于收集用户行为数据以进行分析和改进产品。以下是一个常见的安卓企业级项目开发中使用的埋点方案：

1. 
   

   定义埋点事件：首先，确定需要埋点的关键事件，如页面访问、按钮点击、数据提交等。为每个事件定义唯一的标识符或名称。

   
   


2. 
   

   埋点代码插入：在关键事件的代码位置插入埋点代码，以便在事件发生时触发埋点记录。可以通过在代码中手动插入埋点代码或使用 AOP（面向切面编程）等技术自动插入埋点代码。

   
   


3. 
   

   数据收集和存储：在埋点代码中，收集相关的事件数据，如事件类型、时间戳、页面名称、按钮名称等。将这些数据存储到本地数据库或发送到服务器进行存储。

   
   


4. 
   

   数据上传和分析：定期将本地存储的埋点数据上传到服务器端进行分析。可以使用网络请求库发送数据到服务器，并在服务器端使用数据分析工具进行处理和分析。

   
   


5. 
   

   数据展示和可视化：通过数据分析工具，将埋点数据进行可视化展示，生成报表、图表等形式的数据分析结果，以便开发团队或业务团队进行数据分析和决策。

   
   


6. 
   

   隐私和合规性：在进行埋点时，要确保遵守隐私保护和数据合规性的相关法规和政策。确保用户数据的安全和保密，并进行必要的用户授权和通知。

   
   


7. 
   

   埋点策略优化：根据实际业务需求和数据分析结果，优化埋点策略，增加或调整关键事件的埋点，提高数据的准确性和有用性。

   
   

需要注意的是，具体的埋点方案可能因项目需求、技术架构和团队实际情况而有所不同。因此，在实施埋点方案时，应根据项目的具体情况进行定制化开发，并考虑到性能、稳定性、安全性和用户体验等因素。

埋点数据和上传埋点数据代码示例

定义埋点事件的工具类，包含事件的标识符、名称、属性等信息

public class TrackEventUtils {

    public static final String EVENT_PAGE_VIEW = "page_view";

    public static final String EVENT_BUTTON_CLICK = "button_click";

    // 其他事件定义...



    // 获取页面访问事件

    public static TrackEvent getPageViewEvent(String pageName) {

        TrackEvent event = new TrackEvent(EVENT_PAGE_VIEW);

        event.addProperty("page_name", pageName);

        // 其他属性...

        return event;

    }



    // 获取按钮点击事件

    public static TrackEvent getButtonClickEvent(String buttonName) {

        TrackEvent event = new TrackEvent(EVENT_BUTTON_CLICK);

        event.addProperty("button_name", buttonName);

        // 其他属性...

        return event;

    }



    // 其他事件获取方法...

}

定义埋点事件的实体类，包含事件类型、属性等信息

public class TrackEvent {

    private String eventType;

    private Map<String, Object> properties;



    public TrackEvent(String eventType) {

        this.eventType = eventType;

        this.properties = new HashMap<>();

    }



    public String getEventType() {

        return eventType;

    }



    public void addProperty(String key, Object value) {

        properties.put(key, value);

    }



    public Map<String, Object> getProperties() {

        return properties;

    }

}

使用Retrofit框架上传埋点数据到对应路径

1.添加 Retrofit 依赖到项目的 build.gradle 文件中：

implementation 'com.squareup.retrofit2:retrofit:2.x.x'

implementation 'com.squareup.retrofit2:converter-gson:2.x.x' // 如果要使用 Gson 解析器

2.创建 Retrofit 实例并定义 API 接口：

public interface TrackApiService {

    @POST("/track")

    Call<Void> sendTrackEvent(@Body TrackEvent event);

}

3.修改 TrackManager 类，使用 Retrofit 发送网络请求：

public class TrackManager {

    private static final String API_ENDPOINT = "https://your-api-endpoint.com";

    private static TrackManager instance;

    private Context context;

    private TrackApiService apiService;



    private TrackManager(Context context) {

        this.context = context.getApplicationContext();



        // 创建 Retrofit 实例

        Retrofit retrofit = new Retrofit.Builder()

                .baseUrl(API_ENDPOINT)

                .addConverterFactory(GsonConverterFactory.create()) // 使用 Gson 解析器

                .build();



        // 创建 API Service

        apiService = retrofit.create(TrackApiService.class);

    }



    public static synchronized TrackManager getInstance(Context context) {

        if (instance == null) {

            instance = new TrackManager(context);

        }

        return instance;

    }



    public void trackEvent(TrackEvent event) {

        // 发送网络请求

        Call<Void> call = apiService.sendTrackEvent(event);

        call.enqueue(new Callback<Void>() {

            @Override

            public void onResponse(Call<Void> call, Response<Void> response) {

                // 处理服务器响应...

            }



            @Override

            public void onFailure(Call<Void> call, Throwable t) {

                // 处理请求失败...

            }

        });

    }

}

4.解释下上面的代码中有关Retrofit中的注解和上面我们定义的接口TrackApiService
在 Retrofit 中，TrackApiService 是一个接口，用于定义网络请求的方法。@POST("/track") 是一个注解，表示发送 POST 请求到指定的路径 "/track"。

@Body TrackEvent event 是另一个注解，用于指定请求体的内容。它告诉 Retrofit 将 TrackEvent 对象作为请求体发送给服务器。

具体解释如下：

• 
  

  @POST("/track")：表示将使用 POST 方法发送请求到路径 "/track"。这个路径是你的 API 后端定义的接收埋点事件的路径。

  
  


• 
  

  Call<Void>：表示 Retrofit 将返回一个 Call 对象，用于异步执行网络请求并处理响应。Void 表示响应的主体内容为空。

  
  


• 
  

  sendTrackEvent(@Body TrackEvent event)：这是一个方法定义，用于发送埋点事件。@Body 注解表示将 TrackEvent 对象作为请求体发送。TrackEvent 是你定义的类，包含了发送给服务器的埋点事件数据。

  
  

综合起来，TrackApiService 接口中的 sendTrackEvent 方法定义了一个发送埋点事件的请求，通过 POST 方法发送到指定路径，并将 TrackEvent 对象作为请求体发送给服务器。

你可以根据实际需求修改这个接口，添加其他请求方法和参数，以适应你的埋点需求。

在 Retrofit 中，@Body 注解用于将对象作为请求体发送给服务器。这意味着你可以将任何 Java 类的实例作为请求体发送出去，不限于特定的类或数据类型。

当你使用 @Body 注解时，Retrofit 将会自动将指定的对象序列化为请求体的格式，例如 JSON 或者其他格式。然后，它将使用适当的请求头信息将请求发送到服务器。

因此，你可以创建自己的 Java 类，用于表示需要发送的数据，并将其作为请求体发送给服务器。这样，你可以根据实际需求定义和发送不同类型的数据。

请确保在使用 @Body 注解时，服务器能够正确地解析和处理请求体的格式。通常，你需要在服务器端进行相应的处理和解析，以确保能够正确地接收和处理你发送的 Java 对象。

注：，Retrofit 会动态地创建接口的实现类，你无需手动编写实现类。当你使用 Retrofit 创建接口的实例时，它会在运行时生成一个代理类来处理实际的网络请求。因此，你不需要手动实现 TrackApiService 接口中的方法。

使用异步或者同步请求

使用 enqueue 方法是一种常见的异步执行网络请求的方式，它会在后台线程执行网络请求，并在请求完成后回调相应的方法。

Retrofit 支持同步和异步的网络请求方式。如果你希望使用同步请求，可以使用 execute 方法来执行请求，但需要注意的是，在 Android 主线程上执行网络请求会导致阻塞，可能会引起 ANR（Application Not Responding）错误，因此建议在后台线程中执行同步请求。

关于接口是异步还是同步的，一般情况下是由接口的定义和服务端的实现决定的。通常，网络请求都会以异步方式执行，以避免阻塞主线程。在 Retrofit 中，默认情况下，接口的方法会被当作异步请求进行处理，需要使用 enqueue 方法来执行异步请求。

如果你想要执行同步请求，可以在 Retrofit 创建时设置合适的执行器（Executor），以控制请求的执行方式。例如，可以使用 OkHttp 客户端来创建 Retrofit 实例，并设置自定义的执行器来执行同步请求。

// 创建 OkHttpClient 实例

OkHttpClient okHttpClient = new OkHttpClient.Builder()

    .build();



// 创建 Retrofit 实例，并指定 OkHttp 客户端

Retrofit retrofit = new Retrofit.Builder()

    .baseUrl("https://api.example.com")

    .addConverterFactory(GsonConverterFactory.create())

    .client(okHttpClient) // 设置自定义的 OkHttpClient

    .build();



// 创建 TrackApiService 实例

TrackApiService trackApiService = retrofit.create(TrackApiService.class);



// 创建同步请求执行器

ExecutorService executor = Executors.newSingleThreadExecutor();



// 执行同步请求

try {

    Response<Void> response = executor.submit(() -> trackApiService.sendTrackEvent(event)).get();

    // 请求成功的处理逻辑

} catch (ExecutionException | InterruptedException e) {

    // 请求失败的处理逻辑

}



// 关闭执行器

executor.shutdown();

在这个示例中，我们使用 OkHttp 客户端创建了一个自定义的 OkHttpClient 实例，并将其传递给 Retrofit 的构建器。然后，我们创建了一个 ExecutorService 实例，并使用 submit 方法执行网络请求。通过调用 get 方法获取 Response 对象，我们可以同步地获取请求的结果。

需要注意的是，同步请求仍然需要在合适的线程中执行，以避免阻塞主线程。在这个示例中，我们使用了单线程的执行器来执行同步请求，并在请求完成后关闭执行器。

综上所述，Retrofit 提供了异步和同步两种方式来执行网络请求，具体使用哪种方式取决于你的需求和服务器端的实现。一般来说，推荐使用异步请求以避免阻塞主线程，除非你确切地知道需要执行同步请求，并且在合适的线程上执行它们。
如果使用的是同步请求，即使使用了execute方法，也要手动开启子线程来调用execute方法，若是异步请求，则使用Retrofit的enqueue方法即可，无需自己手动开启子线程。

服务器如何决定接口是异步请求或是同步请求

1.在服务端，决定接口是同步请求还是异步请求是由服务端的实现逻辑来决定的。
通常情况下，服务端会为每个接口定义好其执行方式，包括是同步还是异步。这通常是通过服务端框架或编程语言提供的特定机制来实现的。
例如，在某些服务器框架中，可以使用异步处理机制（如基于回调的异步编程、Future/Promise、协程等）来处理异步请求。而对于同步请求，则可能直接在请求处理方法中执行阻塞操作。
因此，具体接口是同步还是异步请求，你需要参考服务端接口文档或与服务端开发人员进行沟通，了解其设计和实现细节。根据服务端的要求，你可以相应地选择使用 Retrofit 的 enqueue 方法或 execute 方法来发送请求。

2.在服务端的代码中，决定接口是同步还是异步的方式取决于所使用的服务器框架和编程语言。以下是一些常见的示例代码，展示了如何在不同的环境中定义同步和异步接口：

a.Node.js（使用 Express 框架）：

// 异步接口

app.get('/async', (req, res) => {

  someAsyncOperation((data) => {

    res.send(data);

  });

});



// 同步接口

app.get('/sync', (req, res) => {

  const result = someSyncOperation();

  res.send(result);

});

b.Java（使用 Spring 框架）：

// 异步接口

@GetMapping("/async")

public CompletableFuture<String> asyncEndpoint() {

    return CompletableFuture.supplyAsync(() -> {

        // 异步操作

        return "Async response";

    });

}



// 同步接口

@GetMapping("/sync")

public String syncEndpoint() {

    // 同步操作

    return "Sync response";

}

这些示例只是简单的展示了如何在不同环境中定义同步和异步接口。实际上，具体的实现方式取决于所使用的服务器框架和编程语言的特性和机制。因此，你需要根据你所使用的具体服务器框架和编程语言的文档，了解如何定义和处理同步和异步接口。

今天的内容大致如下：

1、最终实现效果及简单分析

2、设置属性，制定可扩展效果

3、部分源码剖析

4、开源地址及使用总结

一、最终实现效果及简单分析

以上就是本篇文章最终要实现的效果，和省份简称键盘不同的是，数据源上和边距有所差别之外，其他的实现方式均是一样的，采用外部垂直LinearLayout，内部多个横向的LinearLayout的搭配方式。

需要注意的是，英文和数字键盘，默认状态下，顶部的数字是禁止的，也就是输入完地区代码之后，数字的禁止状态才会释放；由于距离左右的边距不同，其在数据源的判断上也会有不同，这个也是需要注意的。

二、设置属性，制定可扩展效果

其相关属性和上篇的省份键盘基本上没有太大的出入，主要就是动态化设置，设置一些，文字的背景，大小，颜色以及格子之间的编辑等，大概罗列了以下属性：

设置回调函数

三、部分源码剖析

这里只贴出部分的关键性代码，整体的代码，大家滑到底部查看源码地址即可。

定义字母和数字数组

   private val mEnglishList = arrayListOf(

        "1", "2", "3", "4", "5", "6", "7", "8", "9", "0",

        "Q", "W", "E", "R", "T", "Y", "U", "O", "P",

        "A", "S", "D", "F", "G", "H", "J", "K", "L",

        "Z", "X", "C", "V", "B", "N", "M"

    )

定义遍历数字和字母

由于在数据源上使用的是同一个，那么需要做截取分别进行遍历，便于控制左右的边距和本身的格子大小。

 //遍历数字

        eachData(mEnglishList.subList(0, 10), mLength, true)

        //遍历字母

        eachData(mEnglishList.subList(10, mEnglishList.size), mLength - 1, false)

        //追加最后一个删除按钮View,动态计算宽度

        addEndView(mLineLayout)

遍历数据

遍历数据的逻辑和上篇保持一致，当和定义的长度取模为0时，就需要换行，换行就是重新创建一个水平的LinearLayout,添加至垂直的LinearLayout之中，需要做判断的是，左右的边距。

/**

     * AUTHOR:AbnerMing

     * INTRODUCE:遍历数据

     */

    private fun eachData(

        list: List,

        len: Int,

        isNumber: Boolean = false

    ) {

        list.forEachIndexed { index, s ->

            if (index % len == 0) {

                //重新创建，并添加View

                mLineLayout = createLinearLayout()

                mLineLayout?.weightSum = len.toFloat()

                addView(mLineLayout)

                val params = mLineLayout?.layoutParams as LayoutParams

                params.apply {

                    topMargin = mRectMarginTop.toInt()

                    height = mRectHeight.toInt()

                    if (isNumber) {

                        //是数字

                        leftMargin = mMarginLeftRight.toInt()

                        rightMargin = mMarginLeftRight.toInt() - mSpacing.toInt()

                    } else {

                        //是字母

                        leftMargin = mOtherLinesMargin.toInt()

                        rightMargin = mOtherLinesMargin.toInt() - mSpacing.toInt()

                    }

                    mLineLayout?.layoutParams = this

                }

            }



            //创建文字视图

            val textView = TextView(context).apply {

                text = s

                //设置文字的属性

                textSize = px2sp(mRectTextSize)

                //禁止

                if (isNumber) {

                    //是数字

                    if (mNumProhibit) {

                        setTextColor(mRectTextColor)

                    } else {

                        setTextColor(mNumProhibitColor)

                    }

                } else {

                    setTextColor(mRectTextColor)

                }

                setBackgroundResource(mRectBackGround)

                gravity = Gravity.CENTER

                setOnClickListener {

                    //每个格子的点击事件

                    if (isNumber && !mNumProhibit) {

                        //如果是数字，根据规则暂时不触发点击

                        return@setOnClickListener

                    }

                    changeTextViewState(this)

                }

            }

            //是数字

            if (isNumber) {

                mTempTextViewList.add(textView)

            }

            addRectView(textView, mLineLayout, 1f)

        }

    }

添加视图

设置每个格子的宽高和权重。

 /**

     * AUTHOR:AbnerMing

     * INTRODUCE:追加视图

     */

    private fun addRectView(view: View, layout: LinearLayout?, w: Float) {

        layout?.addView(view)

        val textParams = view.layoutParams as LayoutParams

        textParams.apply {

            weight = w

            width = 0

            height = LayoutParams.MATCH_PARENT

            //每行的最后一个

            rightMargin = mSpacing.toInt()

            view.layoutParams = this

        }



    }

至于最后一个删除按钮，也需要动态的计算其本身的宽高，基本上和上篇一致，就不过多赘述了。

四、开源地址及使用总结

开源地址：github.com/AbnerMing88…

关于如何使用，有两种方式，一种是下载源码，直接把源码复制出来，二是可以使用以下的远程Maven依赖方式。

Maven具体调用

1、在你的根项目下的build.gradle文件下，引入maven。

allprojects {

    repositories {

        maven { url "https://gitee.com/AbnerAndroid/almighty/raw/master" }

    }

}

2、在你需要使用的Module中build.gradle文件下，引入依赖。

dependencies {

    implementation 'com.vip:board:1.0.0'

}

代码使用

        android:layout_width="match_parent"

        android:layout_height="wrap_content" />

总结

属性配置了有很多，可以实现多种自定义的相关效果，大家可以查找第二项中的属性介绍，进行自定义配置，还是那句话，本身的实现方式有很多种，本篇只是其中的一个简单的案例，仅供大家作为一个参考。

自定义英文和数字键盘，大家有没有发现了少了一个字母，为什么会没有这个字母呢？你知道原因吗？

前言

最近的一个新项目使用了Clean Architecture+模块化+MVVM架构，将首页每个tab对应的功能都放到单独的模块且不相互依赖，这时就有了模块间页面跳转的问题，经过一番研究选择了滴滴的DRouter，因为其出色的性能、灵活的组件拆分，更重要的是生成路由表时支持插件增量编译、多线程扫描，运行时异步加载路由表，支持回调式ActivityResult，比ARouter好太多。本着用一个新框架，只会用还不够的原则，我决定去了解一下框架的原理，并给自己制定了以下几个问题：

1、框架的设计分层是什么样的？

2、它是如何生成路由表的？

3、它是如何加载路由表的？

4、相比于ARouter如何提高了性能？

阅读官方文档

相比于直接一头扎进源码，先阅读官方的文档总是没错的，官方给了一篇介绍的文章，写得非常好，基本回答了我以上的所有问题。

滴滴开源DRouter：一款高效的Android路由框架

首先在介绍DRouter的亮点部分得到了问题2、3、4的答案。

路由表在编译期通过插件动态生成。插件会启动多线程同时异步处理所有的组件；增量扫描功能可以帮助开发者在第二次编译时，只对修改过的代码进行处理，极大地缩短路由表生成的时间。

在编译器使用gradle插件配合transform扫描所有的类，生成路由表，并且支持增量扫描，回答了问题2。

另外框架初始化的时候启动子线程去加载路由表，不阻塞主线程的执行，尽其所能提高效率。

回答了问题3。

加载路由表、实例化路由、以及跨进程命令到达服务端后的分发这些常规应该使用反射的场景，使用预占位或动态生成代码来替换成java的new创建和显式方式执行，最大限度的去避免反射执行，提高性能。

回答了问题4，通过减少使用反射提升了性能。

在原理和架构章节处给了一张架构的设计图：

整体架构分三层，自下而上是数据流层、组件层、开放接口层。

数据流层是DRouter最重要的核心模块，这里承载着插件生成的路由表、路由元素、动态注册、以及跨进程功能相关的序列化数据流。所有的路由流转都会从这里取得对应的数据，进而流向正确的目标。

RouterPlugin和MetaLoader负责生成路由表，路由元素指的是RouterMeta，存放scheme/host/path等信息。

组件层，核心的路由分发、拦截器、生命周期、异步暂存和监控、ServiceLoader、多维过滤、Fragment路由，以及跨进程命令打包等。

开放接口层则是使用时接触到的一些类，API设计得也很简单易用，DRouter类和Request类分别只有75和121行代码。

问题1得到解答，到此处也对整个框架有了一个整体的认识。

阅读源码

1.初始化流程

调用DRouter.init(app)后的时序图如下：

默认是在子线程实现路由表加载，不影响主线程。

    public static void checkAndLoad(final String app, boolean async) {

        if (!loadRecord.contains(app)) {

            // 双重校验锁

            synchronized (RouterStore.class) {

                if (!loadRecord.contains(app)) {

                    loadRecord.add(app);

                    if (!async) {

                        Log.d(RouterLogger.CORE_TAG, "DRouter start load router table sync");

                        load(app);

                    } else {

                        new Thread("drouter-table-thread") {

                            @Override

                            public void run() {

                                Log.d(RouterLogger.CORE_TAG, "DRouter start load router table in drouter-table-thread");

                                load(app);

                            }

                        }.start();

                    }

                }

            }

        }

    }

最终走到了RouterLoader的load方法来加载路由表到一个map中，仔细看它的引入路径是com.didi.drouter.loader.host.RouterLoader，是不存在于源码中的，因为它是编译的时候生成的，位置位于app/build/intermediates/transforms/DRouter/dev/debug/../com/didi/drouter/loader/host/RouterLoader。

public class RouterLoader extends MetaLoader {

    @Override

    public void load(Map var1) {

        var1.put("@@$$/browse/BrowseActivity", RouterMeta.build(RouterMeta.ACTIVITY).assembleRouter("", "", "/browse/BrowseActivity", "com.example.demo.browse.BrowseActivity", (IRouterProxy)null, (Class[])null, (String[])null, 0, 0, false));

    }



    public RouterLoader() {

    }

}



public abstract class MetaLoader {



    public abstract void load(Map<?, ?> data);



    // for regex router

    protected void put(String uri, RouterMeta meta, Map<String, Map<String, RouterMeta>> data) {

        Map<String, RouterMeta> map = data.get(RouterStore.REGEX_ROUTER);

        if (map == null) {

            map = new ConcurrentHashMap<>();

            data.put(RouterStore.REGEX_ROUTER, map);

        }

        map.put(uri, meta);

    }



    // for service

    protected void put(Class<?> clz, RouterMeta meta, Map<Class<?>, Set<RouterMeta>> data) {

        Set<RouterMeta> set = data.get(clz);

        if (set == null) {

            set = Collections.newSetFromMap(new ConcurrentHashMap<RouterMeta, Boolean>());

            data.put(clz, set);

        }

        set.add(meta);

    }

}

不难猜出其是在编译期加了一个transform，生成RouterLoader类时加入了load方法的具体实现，具体来说是javaassit API+Gradle Transform，所以去看看drouter-plugin在编译期做了什么。

2.编译期transform

直接看时序图。

创建了一个RouterPlugin，并且注册了一个Gradle Transform。

class RouterPlugin implements Plugin<Project> {



    @Override

    void apply(Project project) {

        ...

        project.android.registerTransform(new TransformProxy(project))

    }

}



class TransformProxy extends Transform {

        @Override

    void transform(TransformInvocation invocation) throws TransformException, InterruptedException, IOException {

        String pluginVersion = ProxyUtil.getPluginVersion(invocation)

        if (pluginVersion != null) {

            ...



            if (pluginJar.exists()) {

                URLClassLoader newLoader = new URLClassLoader([pluginJar.toURI().toURL()] as URL[], getClass().classLoader)

                Class<?> transformClass = newLoader.loadClass("com.didi.drouter.plugin.RouterTransform")

                ClassLoader threadLoader = Thread.currentThread().getContextClassLoader()

                // 1.设置URLClassLoader

                Thread.currentThread().setContextClassLoader(newLoader)

                Constructor constructor = transformClass.getConstructor(Project.class)

                // 2.反射创建一个RouterTransform

                Transform transform = (Transform) constructor.newInstance(project)

                transform.transform(invocation)

                Thread.currentThread().setContextClassLoader(threadLoader)

                return

            } else {

                ProxyUtil.Logger.e("Error: there is no drouter-plugin jar")

            }

        }

    }

}

注释2处反射创建一个com.didi.drouter.plugin.RouterTransform对象，并执行其transform方法，此处真正处理transform逻辑，它的位置位于drouter-plugin模块。

class RouterTransform extends Transform {

    @Override

    void transform(TransformInvocation invocation) throws TransformException, InterruptedException, IOException {

        ...

        // 1.创建一个DRouterTable目录

        File dest = invocation.outputProvider.getContentLocation("DRouterTable", TransformManager.CONTENT_CLASS,

                ImmutableSet.of(QualifiedContent.Scope.PROJECT), Format.DIRECTORY)

        // 2.执行RouterTask

        (new RouterTask(project, compilePath, cachePathSet, useCache, dest, tmpDir, setting, isWindow)).run()

        FileUtils.writeLines(cacheFile, cachePathSet)

        Logger.v("Link: https://github.com/didi/DRouter")

        Logger.v("DRouterTask done, time used: " + (System.currentTimeMillis() - timeStart) / 1000f  + "s")

    }

}

注释2处new了一个RouterTask对象，并执行其run方法，之后的log输出就是平时编译能看到的信息，表示transform的耗时。

public class RouterTask {

    void run() {

        StoreUtil.clear();

        JarUtils.printVersion(project, compileClassPath);

        pool = new ClassPool();

        // 1.创建ClassClassify

        classClassify = new ClassClassify(pool, setting);

        startExecute();

    }



    private void startExecute() {

        try {

            ...

            // 2.执行ClassClassify的generatorRouter

            classClassify.generatorRouter(routerDir);

            Logger.d("generator router table used: " + (System.currentTimeMillis() - timeStart) + "ms");

            Logger.v("scan class size: " + count.get() + " | router class size: " + cachePathSet.size());

        } catch (Exception e) {

            JarUtils.check(e);

            throw new GradleException("Could not generate d_router table\n" + e.getMessage(), e);

        } finally {

            executor.shutdown();

            FileUtils.deleteQuietly(wTmpDir);

        }

    }

}

重点在于ClassClassify这个类，其generatorRouter方法便是最终处理生成路由表的逻辑。

public class ClassClassify {

    private List<AbsRouterCollect> classifies = new ArrayList<>();



    public ClassClassify(ClassPool pool, RouterSetting.Parse setting) {

        classifies.add(new RouterCollect(pool, setting));

        classifies.add(new ServiceCollect(pool, setting));

        classifies.add(new InterceptorCollect(pool, setting));

    }



    public void generatorRouter(File routerDir) throws Exception {

        for (int i = 0; i < classifies.size(); i++) {

            AbsRouterCollect cf = classifies.get(i);

            cf.generate(routerDir);

        }

    }

}

构造函数处添加了RouterCollect/ServiceCollect/InterceptorCollect，最终执行的是他们的generate方法，分别处理路由表、service、拦截器，我们只看路由表的。

class RouterCollect extends AbsRouterCollect {

    @Override

    public void generate(File routerDir) throws Exception {

        // 1.创建RouterLoader类

        CtClass ctClass = pool.makeClass(getPackageName() + ".RouterLoader");

        CtClass superClass = pool.get("com.didi.drouter.store.MetaLoader");

        ctClass.setSuperclass(superClass);



        StringBuilder builder = new StringBuilder();

        builder.append("public void load(java.util.Map data) {\n");

        for (CtClass routerCc : routerClass.values()) {

            try {

                // 处理注解、class类型等逻辑

                ...

                StringBuilder metaBuilder = new StringBuilder();

                metaBuilder.append("com.didi.drouter.store.RouterMeta.build(");

                metaBuilder.append(type);

                metaBuilder.append(").assembleRouter(");

                metaBuilder.append("\"").append(schemeValue).append("\"");

                metaBuilder.append(",");

                metaBuilder.append("\"").append(hostValue).append("\"");

                metaBuilder.append(",");

                metaBuilder.append("\"").append(pathValue).append("\"");

                metaBuilder.append(",");

                if ("com.didi.drouter.store.RouterMeta.ACTIVITY".equals(type)) {

                    if (!setting.isUseActivityRouterClass()) {

                        metaBuilder.append("\"").append(routerCc.getName()).append("\"");

                    } else {

                        metaBuilder.append(routerCc.getName()).append(".class");

                    }

                } else {

                    metaBuilder.append(routerCc.getName()).append(".class");

                }

                metaBuilder.append(", ");

                ...

                metaBuilder.append(proxyCc != null ? "new " + proxyCc.getName() + "()" : "null");

                metaBuilder.append(", ");

                metaBuilder.append(interceptorClass != null ? interceptorClass.toString() : "null");

                metaBuilder.append(", ");

                metaBuilder.append(interceptorName != null ? interceptorName.toString() : "null");

                metaBuilder.append(", ");

                metaBuilder.append(thread);

                metaBuilder.append(", ");

                metaBuilder.append(priority);

                metaBuilder.append(", ");

                metaBuilder.append(hold);

                metaBuilder.append(")");

                ...

                if (isAnyRegex) {

                    // 2. 插入路由表

                    items.add("    put(\"" + uri + "\", " + metaBuilder + ", data); \n");

                    //builder.append("    put(\"").append(uri).append("\", ").append(metaBuilder).append(", data); \n");

                } else {

                    items.add("    data.put(\"" + uri + "\", " + metaBuilder + "); \n");

                    //builder.append("    data.put(\"").append(uri).append("\", ").append(metaBuilder).append("); \n");

                }

            } catch (Exception e) {

                e.printStackTrace();

            }

            Collections.sort(items);

            for (String item : items) {

                builder.append(item);

            }

            builder.append("}");



            Logger.d("\nclass RouterLoader" + "\n" + builder.toString());

            // 3.生成代码

            generatorClass(routerDir, ctClass, builder.toString());

        }

    }

}

此处逻辑比较多，但总体是清晰的，处理完注解和类型的判断，获取路由的信息，构造将要插入的代码，最后统一在父类AbsRouterCollect的generatorClass处理load方法的生成，此时编译器的工作就完成了。

ARouter也提供了arouter-register插件，同是在编译期生成路由表，不同的是在生成代码时，ARouter使用的是ASM，DRouter使用Javassist，查了一下资料，ASM性能比Javassist更好，但更难上手，需要懂字节码知识，Javassist在复杂的字节码级操作上提供了更高级别的抽象层，因此实现起来更容易、更快，只需要懂很少的字节码知识，它使用反射机制。

3.运行期加载路由表

重新贴一下加载路由表的load方法。

public class RouterLoader extends MetaLoader {

    @Override

    public void load(Map var1) {

        var1.put("@@$$/browse/BrowseActivity", RouterMeta.build(RouterMeta.ACTIVITY).assembleRouter("", "", "/browse/BrowseActivity", "com.example.demo.browse.BrowseActivity", (IRouterProxy)null, (Class[])null, (String[])null, 0, 0, false));

    }



    public RouterLoader() {

    }

}

看下RouteMeta的build方法。

public static RouterMeta build(int routerType) {

    return new RouterMeta(routerType);

}

可见是直接new的一个路由类，这与ARouter直接通过反射创建路由类不同，性能更好。

private static void register(String className) {

    if (!TextUtils.isEmpty(className)) {

        try {

            // 1.反射创建路由类

            Class<?> clazz = Class.forName(className);

            Object obj = clazz.getConstructor().newInstance();

            if (obj instanceof IRouteRoot) {

                registerRouteRoot((IRouteRoot) obj);

            } else if (obj instanceof IProviderGroup) {

                registerProvider((IProviderGroup) obj);

            } else if (obj instanceof IInterceptorGroup) {

                registerInterceptor((IInterceptorGroup) obj);

            } else {

                logger.info(TAG, "register failed, class name: " + className

                        + " should implements one of IRouteRoot/IProviderGroup/IInterceptorGroup.");

            }

        } catch (Exception e) {

            logger.error(TAG,"register class error:" + className, e);

        }

    }

}

4.总结

本文分析了DRouter路由部分的原理，其在编译器使用Gradle Transform和Javassist生成路由表，运行时new路由类，异步初始化加载路由表，实现了高性能。