一 使用註解在編譯時將路徑的資料封裝在RouteMeta類中 並且在實現IRouteGroup類中 新增到引數atlas map中

特殊的類
@AutoService(Processor.class) 主要的作用是註解 processor類，並對其生成 META-INF 的配置資訊。
javapoet 幫助生成程式碼
IRouteGroup 生成的類實現了此介面 便於在執行時使用封裝的資料

二 初始化Arouter時 通過反射呼叫自動生成的類（繼承自IRouteGroup）的loadInto 方法把路徑和對應的類儲存到快取中

  ((IRouteRoot) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.groupsIndex);
  className ： 自動生成的類的路徑
  Warehouse.groupsIndex  ： 快取的map
 

三 Arouter跳轉

通過path路徑去快取中找到對應的類做跳轉


*為什麼要分成兩個依賴module*  

    因為annotationProcessor project(':lib')  只參與編譯

    在android中寫註解一般分兩個module,一個是專門存放的註解類比如叫apt-lib,一個是註解解釋類比如叫apt-process,後一個依賴前一個。apt-lib提供api要打入apk的,apt-process只參與編譯。 
    apt-process中的build.gradle 

    compile project(':apt-lib') 

    app中的build.gradle 

    compile project(":apt-lib") 
    annotationProcessor project(':apt-process') 
 

建立步驟

一 建立
建立註解 java module：arouter_annotaion 建立route註解 RouteMeta封裝類

建立編譯時 java module : aroter_compiler 建立AutowiredProcessor類
需要引入
implementation ‘com.google.auto.service:auto-service:1.0-rc2’ //@AutoService(Processor.class) 呼叫
implementation ‘com.squareup:javapoet:1.7.0’ //幫助自動生成java類的依賴
需要依賴 arouter_annotaion module

   processor裡面主要兩個方法
     init()  初始化一些方法
     process()  解析註解 自動生成java類

建立api呼叫 android module : arouter_appi 創建出事Arouter類 IRouteGroup介面
需要依賴 arouter_annotaion module

二 使用

在app中引用上面三種module
annotationProcessor project(':aroter_compiler')
implementation project(':arouter_annotaion')
implementation project(':arouter_appi')

在aplication中 初始化
 Arouter.getInstance().init(getApplication());
在需要的頁面新增路由
  @Route(path = "ThreeActivity")
呼叫 Arouter.getInstance().build("ThreeActivity");

專案結構

相關類
arouter_annotaion module

package com.example.aroter_compiler;

import com.example.arouter_annotaion.Route;
import com.example.arouter_annotaion.RouteMeta;
import com.google.auto.service.AutoService;
import com.squareup.javapoet.ClassName;
import com.squareup.javapoet.JavaFile;
import com.squareup.javapoet.MethodSpec;
import com.squareup.javapoet.ParameterSpec;
import com.squareup.javapoet.ParameterizedTypeName;
import com.squareup.javapoet.TypeSpec;

import java.io.IOException;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.Filer;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.Processor;
import javax.annotation.processing.RoundEnvironment;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.util.Elements;
import javax.lang.model.util.Types;

import static javax.lang.model.element.Modifier.PUBLIC;

/**
 * Created by qf on 2018/7/25
 * 描述: AutowiredProcessor
 */
@AutoService(Processor.class)
public class AutowiredProcessor extends AbstractProcessor {


    private Filer mFiler;
    private Types mTypeUtils;
    private Elements mElementUtils;
    // System interface
    public static final String ACTIVITY = "android.app.Activity";

    @Override
    public synchronized void init(ProcessingEnvironment processingEnvironment) {
        super.init(processingEnvironment);
        //初始化一些工具類
        mTypeUtils = processingEnv.getTypeUtils();
        mElementUtils = processingEnv.getElementUtils();
        mFiler = processingEnv.getFiler();
    }

    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        System.out.println("ele====activity_");
        if (null != roundEnvironment) {
            Set<? extends Element> elementsAnnotatedWith = roundEnvironment.getElementsAnnotatedWith(Route.class);
            doElements(elementsAnnotatedWith);
            return true;
        }
        return false;
    }

    @Override
    public Set<String> getSupportedAnnotationTypes() {
        Set<String> annotations = new LinkedHashSet<>();
        annotations.add(Route.class.getCanonicalName());
        return annotations;
    }


    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.latestSupported();
    }

    private void doElements(Set<? extends Element> elementsAnnotatedWith) {
        TypeMirror activityMirror = mElementUtils.getTypeElement(ACTIVITY).asType();


        //定義引數
        ParameterizedTypeName inputMapTypeOfGroup = ParameterizedTypeName.get(
                ClassName.get(Map.class),
                ClassName.get(String.class),
                ClassName.get(RouteMeta.class)
        );
        ParameterSpec groupParamSpec = ParameterSpec.builder(inputMapTypeOfGroup, "atlas").build();


        //定義方法
        MethodSpec.Builder loadIntoMethodOfGroupBuilder = MethodSpec.methodBuilder("loadInto")
                .addAnnotation(Override.class)
                .addModifiers(PUBLIC)
                .addParameter(groupParamSpec);

        ClassName routeMetaCn = ClassName.get(RouteMeta.class);


        for (Element ele : elementsAnnotatedWith) {

            if (mTypeUtils.isSubtype(ele.asType(), activityMirror)) {
                System.out.println("ele====activity_" + ele.getSimpleName());
                Route annotation = ele.getAnnotation(Route.class);
                String path = annotation.path();
                ClassName className = ClassName.get((TypeElement) ele);


                /**
                 * atlas.put("/test/activity1", RouteMeta.build(RouteType.ACTIVITY, Test1Activity.class, "/test/activity1", "test", new java.util.HashMap<String, Integer>(){{put("pac", 9); put("ch", 5); put("fl", 6); put("obj", 10); put("name", 8); put("dou", 7); put("boy", 0); put("objList", 10); put("map", 10); put("age", 3); put("url", 8); put("height", 3); }}, -1, -2147483648));
                 */
                loadIntoMethodOfGroupBuilder.addStatement(
                        "atlas.put($S, $T.build($T.class))",
                        path,
                        routeMetaCn,
                        className);
            }
            System.out.println("ele====" + ele.getSimpleName());
        }

        System.out.println("ele====over====");
        try {
            JavaFile.builder(
                    "com.qf.routes2",
                    TypeSpec.classBuilder("creteBySelf")
                            // doc
                            //.addJavadoc(WARNING_TIPS)
                            .addSuperinterface(ClassName.get(mElementUtils.getTypeElement("com.example.arouter_appi.IRouteGroup")))
                            .addModifiers(PUBLIC)
                            .addMethod(loadIntoMethodOfGroupBuilder.build())
                            .build()
            ).build().writeTo(mFiler);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}

arouter_annotaion module

package com.example.arouter_annotaion;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Created by qf on 2018/7/25
 * 描述: Route
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.CLASS)
public @interface Route {
    String path();
}

package com.example.arouter_annotaion;



/**
 * It contains basic route information.
 *
 * @author Alex <a href="mailto:[email protected]">Contact me.</a>
 * @version 1.0
 * @since 16/8/24 09:45
 */
public class RouteMeta {

    private Class<?> destination;   // Destination
    private String path;            // Path of route


    public RouteMeta(Class<?> cla) {
        this.destination = cla;
    }

    public RouteMeta(){}


    public Class<?> getDestination() {
        return destination;
    }

    public void setDestination(Class<?> destination) {
        this.destination = destination;
    }

    public String getPath() {
        return path;
    }

    public void setPath(String path) {
        this.path = path;
    }

    public static RouteMeta build(Class<?> destination) {
        return new RouteMeta(destination);
    }

}

arouter_appi module

package com.example.arouter_appi;

import android.app.Application;
import android.content.Intent;
import android.widget.Toast;

import com.example.arouter_annotaion.RouteMeta;

import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;

/**
 * Created by qf on 2018/7/25
 * 描述: Arouter
 */
public class Arouter {

    private static Arouter arouter;

    public static Map<String, RouteMeta> arouters = new HashMap<>();

    private static Application mContext;

//    ARouter.getInstance().build("/simple/simple1Activity").navigation();

    private Arouter(){}

    public static Arouter  getInstance() {
        if (null == arouter) {
            arouter = new Arouter();
        }
        return arouter;
    }


    public void init(Application context) {
        mContext = context;
        try {
            ((IRouteGroup) (Class.forName("com.qf.routes2.creteBySelf").getConstructor().newInstance())).loadInto(arouters);

            Toast.makeText(mContext, arouters.size() + "", Toast.LENGTH_SHORT).show();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }



    public void build(String path) {
        RouteMeta routeMeta = arouters.get(path);
        if (null == routeMeta) return;

        Class<?> destination = routeMeta.getDestination();
        if (null != destination) {
            Intent intent = new Intent(mContext, destination);
            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            mContext.startActivity(intent);
        }
    }


}

package com.example.arouter_appi;

import com.example.arouter_annotaion.RouteMeta;

import java.util.Map;

/**
 * Created by qf on 2018/7/25
 * 描述: IRouteGroup
 */
public interface IRouteGroup {
    /**
     * Fill the atlas with routes in group.
     */
    void loadInto(Map<String, RouteMeta> atlas);
}