Android——GT.ARouter 模块解耦神器全面解析教程

PlayfulKing

已于 2024-06-10 18:27:33 修改

阅读量973

点赞数 24

分类专栏： GT使用教程 Android 文章标签： android kotlin

于 2024-05-19 16:24:48 首次发布

本文链接：https://blog.csdn.net/qq_39799899/article/details/135116489

版权

GT使用教程同时被 2 个专栏收录

22 篇文章 8 订阅

订阅专栏

Android

22 篇文章 5 订阅

订阅专栏

前言：

用于帮助 Android项目组件化的框架 —— 支持模块间的路由、通信、解耦、为跨模块而生。

附上演示项目：

1079374315/GT_ARouter: GT路由 (github.com)https://github.com/1079374315/GT_ARouter

感谢你的阅读，感谢一直对GT库的关注！

路由操作 - 获取Notification 通知栏

路由操作 - 获取PopupWindow

路由操作 - 获取FloatingWindow 悬浮窗

路由操作 - 获取原生View 或自定义View

路由操作 - 获取 GT.BaseView

路由操作 - 获取 DialogFragment

一、功能介绍

支持直接解析标准URL进行跳转，并自动注入参数到目标页面中
支持多模块工程使用
支持添加多个拦截器，自定义拦截顺序
支持依赖注入
完全支持Kotlin以及混编
页面、拦截器、服务等组件均自动注册到框架
支持多种方式配置转场动画转场动画(常规方式)
映射关系按组分类、多级管理，按需初始化
支持生成路由文档
支持带数据跳转页面
支持跨模块获取值
支持拦截器，并支持自定义拦截器顺序
支持跳转Activity页面支持 withFlags，和设置动态启动模式
支持使用绿色通道(跳过所有的拦截器)

二、对象介绍

(说明：已下类型均支持 Bundle 和 withObject 传参，且支持 GT库内封装的类型)

支持 Activity 路由 支持带参跳转
支持 Fragment 路由 支持带参获取
支持 IProvider 路由 支持接口调用方法
支持 View 路由 支持通过构造方法传参
支持ViewModel 路由 支持跨模块获取ViewModel引用
支持 WebView 路由 支持通过构造方法传参
支持 Adapter 路由支持通过构造方法传参
支持 Notification 路由支持通过构造方法传参
支持 PopupWindow 路由支持通过构造方法传参
支持 FloatingWindow 路由
支持 DialogFragment 路由
支持拦截器路由支持直接启动拦截器，并定义拦截顺序

三、跳转参数类型

目前版本 **Bundle** 带参 **支持类型**
String、String[]
Integer、Integer[]	int
Long、Long[]	long
Float、Float[]	float
Boolean、Boolean[]	boolean
Double、Double[]	double
Shore、Shore[]	short
Parcelable、Parcelable[]
Serializable、Serializable[]
Bundle
Character、Character[]	char
Byte[]
其他类型 => 转为Json =>当String 传递

目前版本 **withObject** 带参 **支持类型**
支持Bundle所支持的所有类型
支持Java、KT大多数数据类型

两种传参区别：

Bundle传参：

优点：传参无需担心数据资源释放问题

缺点：传参局限性很大，存在类型局限性和接受者局限性

withObject传参：

优点：传参几乎没有局限性，适用传递给任何类型页面。

缺点：虽然有自带的数据资源释放，但在乱使用的情况下(如带参传递但没有接受者) 数据资源释放问题就会出现，但GT路由也提供了手动释放数据资源的API方法。

推荐：两者灵活使用。

手动释放当前页面资源:

GT.ARouter.getInstance().unregister(this);

使用GT库路由内容当然要先依赖GT库啦

四、依赖GT库

GitHub - 1079374315/GTContribute to 1079374315/GT development by creating an account on GitHub.https://github.com/1079374315/GT

注意：此功能需要添加 gt-DataBinding 依赖

五、使用教程

1.初始化 SDK（必要的）

@GT_RoutePath  //标记路由总部所在 模块
public class MyApp extends Application {

    public void onCreate() {
        super.onCreate();
        GT.ARouter.init(this); /// 尽可能早，推荐在Application中初始化
    }

    public void onTerminate() {
        super.onTerminate();
        //释放资源
        GT.ARouter.getInstance().destroy();//释放资源路由全部资源
    }
}

路由操作 - 跳转Activity

// 在支持路由的页面上添加注解(必选)
// 这里的路径需要注意的是 整个项目中，路径名字必须唯一
// 推荐路径：模块名/类名(在相同类名时可采用 ：模块名/包名/类名)
@GT_Route(value = "/test/activity" ,extras = "路由测试Activity说明处")
public class YourActivity extend Activity {
    ...
}

发起路由操作

// 第一种用法： 应用内简单的跳转，不带参数(通过URL跳转在'进阶用法'中)
GT.ARouter.getInstance().build("/test/activity").navigation();

//如果不需要添加参数也可以这样使用
//GT.ARouter.getInstance().build("/test/activity").start();

// 第二种用法： 跳转并携带参数
Map<String,Object> map = new HashMap<>();
map.put("1",111);
ArrayList<String> list = new ArrayList<>();
list.add("list内参数");

GT.ARouter.getInstance()              //获取路由引用
  .build("/test/activity")            //指定 路由路径 跳转到对应的页面
  .putExtra("keyA1", 100)             //通过Bundle传递 Int (各类参数)
  .putExtra("keyA2", "我是KeyA2参数")  //通过Bundle传递 String (各类参数)
  .withObject("keyB1", 18)            //通过withObject 传递 Int (各类参数)
  .withObject("keyB2", new UserBean())//通过withObject 传递 实体类(各类参数)
  .withObject("keyB3", list)          //通过withObject 传递 List(各类参数)
  .withObject("mapValue", map)        //通过withObject 传递 Map(各类参数)
  .navigation();                      //启动路由

解析路由操作

// 为每一个参数声明一个字段，并使用 @GT_Autowired标注
@GT_Route(path = "/test/activity", extras = "模块1主页")
public class Test1Activity extends AppCompatActivity{
    
    @GT_Autowired(value = "keyB1", desc = "这是测试的Int参数")
    int age;

    // 支持解析自定义对象
    @GT_Autowired(value = "keyB2", desc = "这是测试的Obj参数")
    UserBean obj;     

    // 使用 withObject 传递 List 和 Map
    @GT_Autowired(value = "keyB3", desc = "这是测试的List参数")
    List<TestObj> list;
    
    //这里没有指定 value 值，代表使用默认的参数名称 mapValue作为路由参数路径
    @GT_Autowired
    Map<String, List<TestObj>> mapValue;
    
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_test);

        // ARouter会自动对上面 GT_Autowired字段进行赋值，无需主动获取
        GT.ARouter.getInstance().inject(this);//与Autowired配合使用

        //下面是通过 Bundle 传递数据所获取的方式
        Intent intent = getIntent();
        if (intent != null) {
            int keyA1 = intent.getIntExtra("keyA1", 0);
            boolean keyA2 =  intent.getStringExtra("keyA2");
            GT.logt("keyA1:" + keyA1);
            GT.logt("keyA2 :" + keyA2);
        }

    }
}

路由操作 - 获取Fragment

       //不带参数获取  
       Fragment demoFragment = GT.ARouter.getInstance()
                .build("test/fragment1")
                .navigation();

       //带参数获取
       Fragment modelFragment = GT.ARouter.getInstance()
                .build("test/fragment2")
                .withObject("name", "ModelFragment1 名字")
                .navigation();

路由操作 - 暴露服务

// 声明接口,其他组件通过接口来调用服务
public interface HelloService extends GT.ARouter.IProvider {
    String sayHello(int value);
}

// 实现接口
@Route(value = "/yourservicegroupname/hello", extras = "测试服务")
public class HelloServiceImpl implements HelloService {

    @Override
    public String sayHello(int value) {
    return "返回 sayHello:" + value;
    }

    @Override
    public void init(Context context) {

    }
}

路由操作 - 发现服务

public class Test {
    @GT_Autowired
    HelloServiceImpl helloService;

    @GT_Autowired(name = "/yourservicegroupname/hello")
    HelloServiceImpl helloService2;

    HelloServiceImpl helloService3;

    HelloServiceImpl helloService4;

    public Test() {
        GT.ARouter.getInstance().inject(this);//与Autowired配合使用
    }

    public void testService() {
    // 1. (推荐)使用依赖注入的方式发现服务,通过注解标注字段,即可使用，无需主动获取
    // GT_Autowired注解中标注name之后，将会使用byName的方式注入对应的字段，不设置name属性，会默认使用byType的方式发现服务(当同一接口有多个实现的时候，必须使用byName的方式发现服务)
    helloService.sayHello("Vergil");
    helloService2.sayHello("Vergil");

    // 2. 使用依赖查找的方式发现服务，主动去发现服务并使用，下面两种方式分别是byName和byType
    helloService3 = GT.ARouter.getInstance().navigation(BaseService.class);
    helloService4 = (BaseService) 
    GT.ARouter.getInstance().build("/yourservicegroupname/hello").navigation();
    helloService3.sayHello("Vergil");
    helloService4.sayHello("Vergil");
    }
}

以上就是常规使用路由进行跨模块跳转、获取页面、调用方法的使用。

下面将介绍，常规路由不支持的路由获取，下面演示均用GT库内部封装的，你也可以直接用原生替代就好。

GT库的路由，支持给有参构造类进行初始化赋值，依靠 constructorParams 方法，下面有具体用法。

路由操作 - 获取WebView

定义服务

@GT_Route(value = Config.AppConfig.WEB_VIEW, extras = "web 网页")
class WebViews(context: Context, viewGroup: ViewGroup, bundle: Bundle) : 
    AnnotationWebView(context, viewGroup, bundle) {

    @GT_Autowired
    private val name: String? = null

    override fun initView(context: Context, webView: WebView) {
        super.initView(context, webView)
        setCache(true)//开启缓存
        GT.ARouter.getInstance().inject(this) //与Autowired配合使用
        "name:$name".logt()
        "arguments:$arguments".logt()
        if (arguments != null) {
            val extra = arguments!!.getString("extra")
            GT.logt("extra:$extra")
        }
    }

}

发现服务

GT.GT_WebView.BaseWebView webView = GT.ARouter.getInstance()
                        .build(Config.AppConfig.WEB_VIEW)
                        //通过 webView 的构造方法来构建对象
                        .constructorParams(
                                new Class[]{Context.class, ViewGroup.class, Bundle.class},
                                new Object[]{ModelActivity1.this, fl, bundle}
                        )
                        .withObject("name", name)
                        .navigation();
                if(webView != null){
                    webView.loadWeb("https://blog.csdn.net/qq_39799899?type=blog");
                }

路由操作 - 获取Adapter 适配器

定义服务

@GT_Route(value = Config.AppConfig.ADAPTER, extras = "适配器测试")
@GT_DataBinding(setLayout = "item_discover_left", setBindingType = GT_DataBinding.Adapter)
@GT_AnnotationAdapter(R.layout.item_discover_left)
class DemoAdapter(context: Context, private val onListener: GT.OnListener<DemoBean>) :
   DemoAdapterBinding<DemoBean>(context) {

    override fun initView(holder: DemoAdapterViewHolder?, itemView: View?, 
                          position: Int, t: DemoBean?, context: Context?) {
        super.initView(holder, itemView, position, t, context)
        holder ?: return
        t ?: return
        holder.tv_type.text = t.name
        holder.tv_type.setOnClickListener {
            onListener.onListener(t)
        }
    }

}

发现服务

GT.Adapters.BaseAdapter<DemoBean, ?> adapter = GT.ARouter.getInstance()
                        .build(Config.AppConfig.ADAPTER)
                        .constructorParams(
                                new Class[]{Context.class, GT.OnListener.class},
                                new Object[]{ModelActivity1.this, (GT.OnListener<DemoBean>) obj -> {
                                        GT.logt("回调触发了:" + obj[0]);
                                }}
                        )
                        .navigation();
                if (adapter != null) {
                    adapter.setStaggeredGridLayoutManager_V(rv, 3);
                    List<DemoBean> beanList = new ArrayList<>();
                    for (int i = 0; i < 100; i++) {
                        DemoBean demoBean = new DemoBean();
                        demoBean.name = "我的名字:" + i;
                        demoBean.age = i;
                        beanList.add(demoBean);
                    }
                    adapter.setBeanList(beanList);
                }

路由操作 - 获取ViewModel

定义服务

@GT_Route(value = Config.AppConfig.VIEW_MODEL, extras = "ViewModel 测试")
class NullViewModelAll<T : ViewModelFeedback?> : GT_BindingViewModel<T, BaseViewModel<*>>(), NullViewModelAllL {

    private val getAppDataValue by lazy { MutableLiveData<DemoBean>() }

    override fun getAppData(): MutableLiveData<DemoBean> {
        runJava {
            delay(3000)
            runAndroid {
                val demoBean = DemoBean()
                demoBean.name = "viewmodel Name"
                demoBean.age = 1079
                getAppDataValue.postValue(demoBean)
            }
        }
        return getAppDataValue;
    }

}

发现服务

NullViewModelAllL viewModel = GT.ARouter.getInstance()
                        .build(Config.AppConfig.VIEW_MODEL)
                        .navigation();
                if(viewModel != null){
                    viewModel.getAppData().observe(ModelActivity1.this, 
                            new Observer<DemoBean>() {
                        @Override
                        public void onChanged(DemoBean demoBean) {
                            GT.logt("ViewModel:" + demoBean);
                        }
                    });
                }

路由操作 - 获取Notification 通知栏

定义服务

@GT_Route(value = Config.AppConfig.NOTIFICATION, extras = "通知栏")
//加载 折叠通知栏 与 展开通知栏
@GT.Annotations.GT_Notification(
        value = R.layout.item_notification, 
        value2 = R.layout.item_notification2)
public class NotificationDemo extends GT.GT_Notification.AnnotationNotification {

    @GT_Autowired
    private String name;

    public NotificationDemo(Context context, Bundle bundle) {
        super(context, bundle);
    }

    @Override
    protected void initView(Context context) {
        super.initView(context);

        GT.ARouter.getInstance().inject(this); //与Autowired配合使用
        GT.logt("name:" + name);

        Bundle arguments = getArguments();
        GT.logt("arguments:" + arguments);
        if(arguments != null){
            String extra = arguments.getString("extra");
            GT.logt("extra:" + extra);

        }

        //初始化通知栏 必要属性
        setInitData(
                R.mipmap.ic_launcher, //设置通知图标
                true,//单击是否取消通知
                true,//锁屏是否显示
                false,//是否用户不可取消通知
                null,//单击意图
                -1,//发送通知时间
                false//是否悬浮式弹出
                ,222);//通知栏编号Id



    }

}

发现服务

GT.GT_Notification.BaseNotification notification = GT.ARouter.getInstance()
                        .build(Config.AppConfig.NOTIFICATION)
                        .constructorParams(
                                new Class[]{Context.class,  Bundle.class},
                                new Object[]{ModelActivity1.this, bundle}
                        )
                        .withObject("name", name)
                        .navigation(ModelActivity1.this);
                if (notification != null) {
                    notification.commit();
                }

路由操作 - 获取PopupWindow

定义服务

@GT_DataBinding(setLayout = "popup_window_scan_qr_code", setBindingType = GT_DataBinding.PopupWindow)
@GT_Route(value = Config.AppConfig.POPUP_WINDOW, extras = "长安 更多内容")
@GT_AnnotationPopupWindow(R.layout.popup_window_scan_qr_code)
class ScanQRCodesPopupWindow(context: Context, bundle: Bundle) : 
    ScanQRCodesPopupWindowBinding<NullViewModelAll<*>>(context, bundle) {

    @GT_Autowired
    private val name: String? = null

    override fun initView(view: View?, popWindow: PopupWindow?) {
        super.initView(view, popWindow)
        GT.ARouter.getInstance().inject(this) //与Autowired配合使用
        "name:$name".logt()
        "arguments:$arguments".logt()
        val bundle = arguments ?: return
        val extra = bundle.getString("extra")
        "传递过来的 extra：$extra".logt()
    }

    @GT_Click(R.id.ll_scan_qr_codes)
    fun onClick(view: View) {
        when (view.id) {
            R.id.ll_scan_qr_codes -> {//扫一扫
                //调佣公共的 扫码窗口 获取扫码数据
                "arguments:$arguments".logt()
                val bundle = arguments
                val extra = bundle?.getString("extra")
                "传递过来的 extra：$extra".logt()
                finish()
            }

        }
    }

}

发现服务

GT.GT_PopupWindow.BasePopupWindow popupWindow = GT.ARouter.getInstance()
                        .build(Config.AppConfig.POPUP_WINDOW)
                        .constructorParams(
                                new Class[]{Context.class,  Bundle.class},
                                new Object[]{ModelActivity1.this, bundle}
                        )
                        .withObject("name", name)
                        .navigation(ModelActivity1.this);
                if (popupWindow != null) {
                    popupWindow.startPopupWindowAbsolute(v, -100);
                }

路由操作 - 获取FloatingWindow 悬浮窗

定义服务

@GT_DataBinding(setLayout = "popup_window_scan_qr_code", setBindingType = GT_DataBinding.PopupWindow)
@GT_Route(value = Config.AppConfig.POPUP_WINDOW, extras = "长安 更多内容")
@GT_AnnotationPopupWindow(R.layout.popup_window_scan_qr_code)
class ScanQRCodesPopupWindow(context: Context, bundle: Bundle) : 
    ScanQRCodesPopupWindowBinding<NullViewModelAll<*>>(context, bundle) {

    @GT_Autowired
    private val name: String? = null

    override fun initView(view: View?, popWindow: PopupWindow?) {
        super.initView(view, popWindow)
        GT.ARouter.getInstance().inject(this) //与Autowired配合使用
        "name:$name".logt()
        "arguments:$arguments".logt()
        val bundle = arguments ?: return
        val extra = bundle.getString("extra")
        "传递过来的 extra：$extra".logt()
    }

    @GT_Click(R.id.ll_scan_qr_codes)
    fun onClick(view: View) {
        when (view.id) {
            R.id.ll_scan_qr_codes -> {//扫一扫
                //调佣公共的 扫码窗口 获取扫码数据
                "arguments:$arguments".logt()
                val bundle = arguments
                val extra = bundle?.getString("extra")
                "传递过来的 extra：$extra".logt()
                finish()
            }

        }
    }

}

发现服务

GT.GT_FloatingWindow.BaseFloatingWindow floatingWindow = GT.ARouter.getInstance()
                        .build(Config.AppConfig.FLOATING)
                        .putExtra("extra", "我的 extra 参数")
                        .withObject("name", name)
                        .navigation();
                if (floatingWindow != null) {
                    GT.GT_FloatingWindow.BaseFloatingWindow.setType_screenType(
                            GT.GT_FloatingWindow.BaseFloatingWindow.TYPE_DEFAULT);
                    startFloatingWindow(ModelActivity1.this, floatingWindow);
                }

路由操作 - 获取原生View 或自定义View

定义服务

@GT_Route(value = Config.AppConfig.VIEW, extras = "View 模块")
public class CircleView extends View {

    @GT_Autowired
    private String name;

    public CircleView(Context context) {
        super(context);
    }

    //接受传递过来的 Bundle 值
    public CircleView(Context context, Bundle bundle) {
        super(context);
        GT.ARouter.getInstance().inject(this); //与Autowired配合使用
        GT.logt("name:" + name);
        String extra = bundle.getString("extra");
        GT.logt("extra:" + extra);
    }

}

发现服务

View view = GT.ARouter.getInstance()
                                .build(Config.AppConfig.VIEW)
                                .constructorParams(
                                        new Class[]{Context.class,  Bundle.class},
                                        new Object[]{ModelActivity1.this, bundle}
                                )
                                .withObject("name", name)
                                .navigation();
                GT.logt("view:" + view);
                if(view != null){
                    fl.addView(view);
                }

路由操作 - 获取 GT.BaseView

定义服务

@GT_Route(value = Config.AppConfig.BASE_VIEW, extras = "GTView 模块")
@GT_AnnotationView(R.layout.view_age)
class AgeView: GT.GT_View.AnnotationView() {

    @GT_Autowired
    private val name: String? = null

    override fun initView(view: View?) {
        super.initView(view)
        GT.ARouter.getInstance().inject(this) //与Autowired配合使用

        val arguments = arguments
        val extra = arguments?.getString("extra")
        "extra:$extra".logt()
        "name:$name".logt()
    }

}

发现服务

GT.GT_View.BaseView gtView = GT.ARouter.getInstance()
                                .build(Config.AppConfig.BASE_VIEW)
                                .putExtra("extra","我的 extra")
                                .withObject("name", name)
                                .navigation();
                GT.logt("gtView:" + gtView);
                if(gtView != null){
                    gtView.init(ModelActivity1.this, fl);
                }

路由操作 - 获取 DialogFragment

定义服务

@GT_Route(value = Config.AppConfig.DIALOG, extras = "对话框测试")
@GT.Annotations.GT_AnnotationDialogFragment(R.layout.demo_dialog_fragment)
public class DemoDialogFragment extends GT.GT_Dialog.AnnotationDialogFragment {
    
    @GT_Autowired
    private String name;

    @Override
    protected void initView(View view, @Nullable Bundle savedInstanceState) {
        super.initView(view, savedInstanceState);
        GT.ARouter.getInstance().inject(this); //与Autowired配合使用
        setHideBackground();//隐藏背景(GT内置提供的功能方法)
        setClickExternalNoHideDialog();//设置点击外部无效(GT内置提供的功能方法)
        Bundle bundle = getArguments();
        if (bundle != null) {
            String extra = bundle.getString("extra");
        }

    }

}

发现服务

DialogFragment dialogFragment =
                        GT.ARouter.getInstance()
                                .build(Config.AppConfig.DIALOG)
                                .putExtra("extra", "我的 extra")
                                .withObject("name", name)
                                .navigation();
                GT.logt("dialogFragment:" + dialogFragment);
                if(dialogFragment != null){
                    startDialogFragment(dialogFragment);
                }

路由操作 - 获取拦截器

定义服务

@GT_Route(value = Config.TestInterceptor.MAIN, extras = "测试TestInterceptor拦截")
public class TestInterceptor implements GT.ARouter.Interceptor {

    @GT_Autowired
    private String name;

    @Override
    public void init(Context context, String injectObject) {
        GT.ARouter.getInstance().inject(this, injectObject);//与Autowired配合使用
    }

    @Override
    public boolean process(Intent intent, GT.ARouter.InterceptorCallback callback) {
        if(intent == null) return callback.onAbort(null);
        //需要的拦截器参数
        String extra = intent.getStringExtra("extra");
        GT.logt("extra:" + extra);
        GT.logt("name:" + name);

        //拦截器其他逻辑

        GT.logt("拦截通过");
        return callback.onContinue(intent);//拦截通过
//        return callback.onAbort(intent);//驳回不通过
    }
}

发现服务

GT.ARouter.getInstance()
                        .build(Config.TestInterceptor.MAIN)
                        .putExtra("extra","我的 extra")
                        .withObject("name", name)
                        .navigation(new GT.ARouter.InterceptorCallback() {
                            @Override
                            public boolean onContinue(Intent intent) {
                                GT.logt("继续执行了");
                                //开始当前其他逻辑
                                return super.onContinue(intent);
                            }

                            @Override
                            public boolean onAbort(Intent intent) {
                                GT.logt("跳转被拦截");
                                //开始当前其他被拦截逻辑
                                return super.onAbort(intent);
                            }
                        });

上面就是GT库所有路由类型的使用了，接下来我们来看看拦截器的知识

六、拦截器介绍

支持拦截器路由到多模块
支持单独启动拦截器，并将结果返回给调用者
支持拦截器顺序定义
支持多重拦截器拦截
支持拦截器重构传参，并返回给调用者
支持拦截器 Bundle 和 GT_Autowired 传参
支持指定过滤拦截器
支持绿色通道，过滤所有拦截器

比较经典的应用就是在跳转过程中处理登录事件，这样就不需要在目标页重复做登录检查

流程图：

代码演示：

定义拦截器内部拦截逻辑

@GT_Route(value = Config.TestInterceptor.MAIN, extras = "测试TestInterceptor拦截")
public class TestInterceptor implements GT.ARouter.Interceptor {

    @GT_Autowired
    private String name;

    @Override
    public void init(Context context, String injectObject) {
        GT.ARouter.getInstance().inject(this, injectObject);//与Autowired配合使用
    }

    @Override
    public boolean process(Intent intent, GT.ARouter.InterceptorCallback callback) {
        if(intent == null) return callback.onAbort(null);
        //需要的拦截器参数
        String extra = intent.getStringExtra("extra");
        GT.logt("extra:" + extra);
        GT.logt("name:" + name);
        //根据调用者提供的数据 判断登录状态

        //拦截器其他逻辑
        GT.logt("拦截通过");
        return callback.onContinue(intent);//已登录的 拦截通过
//        return callback.onAbort(intent);//未登录的 驳回不通过
    }
}

这是拦截器内部逻辑，我们可以把这个拦截器，挂在要判断登录页面才跳转的页面上，这样就只有等拦截器里拦截通过才会真正跳转到指定页面

//为 ModelActivity2 页面 挂上 TestInterceptor 拦截器，
// 只有该拦截器满足条件 才会打开 ModelActivity2 页面
@GT_Route(value = Config.Model2Config.MAIN,
        interceptors = {Config.TestInterceptor.MAIN}, extras = "模块2主页")
public class ModelActivity2 extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_model2);

    }

}

拦截器调用者：

GT.ARouter.getInstance()
                        .build(Config.Model2Config.MAIN)
                        .putExtra("extra", "我的 extra")
                        .withObject("name", name)
                        .navigation();

就是简单的调用路由发送就会调用到拦截器，如果你需要获取到拦截器的详情可以这样做：

GT.ARouter.getInstance()
                        .build(Config.Model2Config.MAIN)
                        .putExtra("extra", "我的 extra")
                        .withObject("name", name)
                        .navigation(ModelActivity1.this,
                                new GT.ARouter.InterceptorCallback() {
                            @Override
                            public boolean onContinue(Intent intent) {
                                GT.logt("继续执行了");
                                return super.onContinue(intent);
                            }

                            @Override
                            public boolean onAbort(Intent intent) {
                                GT.logt("跳转被拦截");
                                return super.onAbort(intent);
                            }
                        });

如果你想这个页面 挂多个拦截器也是支持的，并且 挂拦截器的顺序就是拦截器执行顺序：

@GT_Route(value = Config.Model2Config.MAIN,
        interceptors = {Config.TestInterceptor.MAIN, 
                Config.TestInterceptor2.MAIN}, extras = "模块2主页")

但需要注意的是，如果挂多个拦截器，只要其中有任意拦截器被拦截，该页面到不会跳转，并且被拦截器后面的拦截器到不会再执行到。

当然如果你在特殊条件下，需要让这个挂了两个拦截器的页面，暂时不进行拦截检查，你也可以这样写：

GT.ARouter.getInstance()
                        .build(Config.Model2Config.MAIN)
                        .putExtra("extra", "我的 extra")
                        .withObject("name", name)
                        .greenChannal()//绿色通过所有拦截器
                        .navigation();

如果你只想过滤掉其中一个或多个拦截器，也是支持的：

GT.ARouter.getInstance()
                        .build(Config.Model2Config.MAIN)
                        .putExtra("extra", "我的 extra")
                        .withObject("name", name)
                        .greenChannal(
                                Config.TestInterceptor.MAIN, //指定拦截其中拦截器
                                Config.TestInterceptor2.MAIN)//绿色通过所有拦截器
                        .navigation();

有感受到拦截器的魅力了吗，使用起来也是非常简单方便的。

好了以上就是 GT库目前带来的所有路由操作，今后有更新会在这篇文章中继续补充。

最后附上演示项目：

1079374315/GT_ARouter: GT路由 (github.com)https://github.com/1079374315/GT_ARouter

感谢你的阅读，感谢一直对GT库的关注！