Component learning (2) arouter principle learning

1.Arouter principle

（1） One sentence summary ARouter Principle ：

Like the overall situation mentioned in the last article Map equally , It has a routing table generated at compile time . Although there is no horizontal dependency between modules , however When information is transmitted , You can find the routing table , Find the module that needs communication class object , To communicate . in other words ARouter The core of Routing table

（2）ARouter Is a compile time framework

Since there is a watch , Then there are the elements in the table register and get.register The timing of , It's very important . If it's at run time register, Then the user may feel Caton . therefore ,ARouter Selected at compile time register. In this way, even if you compile for dozens of minutes , Users don't feel , Experience will go up .

（3） In one sentence, summarize the characteristics of compile time framework ：

Add specific annotations to the classes that need to be processed , These annotated classes can be used at compile time , Do some specific operations . These operations , It's done at compile time , Rather than running .

ARouter Namely , First, the classes that need communication, such as Activity add Path annotation , At compile time , These classes will be registered in the routing table , So as to realize communication

Other compiler frameworks ：Eventbus,Dagger2,Room,Butterknife,DataBinding

2.APT： A tool that can work in the compiler

APT All the way through Annotation Processing Tool, Annotation processor . It is a tool for processing annotations .

（1）APT How does it work

At compile time ,APT Will conduct a comprehensive inspection of the source code files , And find out what meets the requirements Annotation（ annotation ）, According to these Annotation, Automatic code generation .

As mentioned above （Eventbus,Dagger2,Room,Butterknife,DataBinding） These compile time frameworks , In especial ARouter, It's all about using APT technology

（2）APT The way we work

APT The way of working is How to generate code
① The traditional way ： Such as EventBus. That is, write code line by line , Write... In order . This is very readable , But it's easy to make mistakes , Without using object-oriented thinking .
Pictured here EventBus Source code fragment

②JavaPoet The way （ The mainstream of compile time framework APT The way ）
ButterKnife,ARouter etc. , The advantage is that it uses object-oriented thinking , And there is no need to guide the package manually , The disadvantage is that the readability is not strong

（3） introduce JavaPoet

It's also a framework , But the difference between it and the traditional way is ：JavaPoet We don't need to guide the package manually , And most importantly ,JavaPoet Using object-oriented thinking , It provides a complete set of api To generate files , Instead of writing it all in code . For example

The traditional way may go like this new
Class clazz = new Class();
and JavaPoet Go this way new
createObject("Class").name("clazz")
I'm just making an analogy ,JavaPoet The grammar of is not like this , But ideas like this

But its big disadvantage is that it is not readable , Contrary to habit . If the generated code is complex , I'm very angry .

The traditional way is the pilot package , Create class after , Create method ,EventBus this is it
however JavaPoet Just the opposite , First write the method , Post write class , Finally, write the package . It's just the opposite of our habits , It's in reverse order . This is also the embodiment of object-oriented thinking .

In other words, its process is like this
① Write a method first a
② Create a class TestClass, Put the method a Throw it in , like this ：TestClass(a)
③ Create a package TestPackage, Ba class TestClass Throw it in the bag , like this ：TestPackage（TestClass）

stay github On ,JavaPoet The official attached a template . For example, I want to generate the following code

The corresponding JavaPoet The grammar is like this

（4）ARouter How to use APT Of ？

If there are A Module and Main modular .A The module should be consistent with Main A class in the module communicates . So it can be Main Add... To the corresponding class of the module ARouter annotation , At compile time ,APT This annotation will be detected , And make use of JavaPoet Generate Main Module is the routing class of this specific class .A The module wants to communicate with Main Module communication , You can first pass the routing class generated during this compilation period , Then carry out the corresponding operation . Pictured

Generally speaking , According to the notes , utilize JavaPoet, The generated simple routing class is like this （ If MainActivity2 yes Main The class in the module that needs to be communicated ）

The parameters inside path It was sent by the user . When you need to communicate, such as when you jump to a page , You can compile , The method of the class generated according to the annotation through the target class , Get the name of the target class Class object , You can complete the jump
Pictured

This is it. ARouter The basic principle of jump

3.github On ARouter General view of

The core , I think there are only three modules . I am here , Very simple abstraction of the functions inside
arouter-annotation It's all kinds of notes , such as ARouter Medium Path ah Group Ah, etc. .
arouter-compiler It's the annotation processor , Also is to use JavaPoet Where the code is written . It's a service , As long as compilation happens , This service starts working , That is to find the corresponding annotation , And generate code .
arouter-api There are some ways , such as ARouterGroup Interface , and ARouterPath Interface

Group It's the group , such as app Group ,common Group, etc .Path It's a group of younger brothers in the group . such as app/MainActivity1,app/MainActivity2. these two items. Activity Belong to app Group , But it's different Path

Next article , Will introduce in detail ARouter Of Path and Group annotation , And how they work