转载

组件化的架构设计(二)：路由架构设计及编码实现

博客主页

组件化路由架构设计思路

上一篇中讲解了 类加载 、 全局Map记录 实现组件化模块之间的交互，慢慢衍生APT技术。

那么在组件化架构中，我们需要思考通过APT+javapoet技术生成什么样的类文件呢？

组件化的架构设计(二)：路由架构设计及编码实现

从组件化路由架构设计图需要思考，使用APT生成文件为什么需要分组？ 生成这些文件干什么用？

设计思路：在初始化只加载分组表数据，在使用的时候，如果使用A分组就去加载A分组下的所有路由信息，而不去加载B分组数据。比如：A组有100个路由信息，B组有200个路由信息，如果不分组，Map中就需要加载300个路由信息，当用户可能根本就不需要进入B分组页面，加载B分组的路由信息，会导致内存和时间的浪费。

组件化的架构设计(二)：路由架构设计及编码实现

todo_modular项目：使用路由组件化项目

  • app： 主工程（application）
  • common：基础模块（library）
  • shop：购物shop功能模块
  • personal：我的personal功能模块

路由框架

  • annotations（java library）：注解模块，自定义注解给api和compiler依赖
  • compiler：APT模块（java library）编译时生成java文件
  • api：核心模块，项目中需要引入依赖的模块，使用compiler模块生成的java类完成路由表的创建

设计Coding实现

RouteMeta路由信息封装类，路由地址，路由分组名，原始的类元素等。 

import javax.lang.model.element.Element;
public class RouteMeta {

    public enum RouteType {
        ACTIVITY
    }

    // 路由类型，支持Activity
    private RouteType type;
    // 原始的类元素
    private Element element;
    // 注解使用的类对象
    private Class<?> clazz;
    // 路由地址
    private String path;
    // 路由分组名
    private String group;
}

思考：为什么Element类节点需要存起来？

因为要在注解处理器中，循环拿到每个类节点，方便赋值和调用。Element它是javax.lang包下的，不属于Android Library。

IRouteRoot接口

Map<String, Class<? extends IRouteGroup>>
key： 组名，如：app , value：该组名下所有的路径文件名，如： ARouter$$Group$$app.class

注意：需要生成路由路径文件后 ARouter$$Group$$app.class ，才能生成路由组文件，使用接口方式容易扩展 

/**
 * 路由组加载数据接口
 */
public interface IRouteRoot {

    /**
     *  加载路由组数据
     *  如：key："app"， value: ARouter$$Group$$app.class(实现了IRouteGroup接口)
     */
    void loadInto(Map<String, Class<? extends IRouteGroup>> routes);
}

IRouteGroup接口

Map<String, RouteMeta>
key：路径名，如："/app/MainActivity"， value：该路径名下对应的路由信息

OOP思想，让单纯的targetClass变成更灵活的RouteMeta对象，接口方式容易扩展

/**
 * 路由组对应的详细Path路径加载数据接口
 * 如：app组下对应有哪些类需要加载
 */
public interface IRouteGroup {

    /**
     *  加载路由组中的Path详细数据
     *  如：key："/app/MainActivity"， value：MainActivity信息封装到RouteMeta对象中
     */
    void loadInto(Map<String, RouteMeta> atlas);
}

ARouter$$Group$$XX 与 ARouter$$Root$$XX 文件生成

下面以购物模块shop为例，生成 ARouter$$Group$$shop 和 ARouter$$Root$$shop 文件，涉及到的技术点：APT + javapoet

在使用APT + javapoet 生成我们想要的代码之前，首先要设计好我们想要的代码模版，如： ARouter$$Root$$shop 分组的模版代码 

public final class ARouter$$Root$$shop implements IRouteRoot {
  @Override
  public void loadInto(final Map<String, Class<? extends IRouteGroup>> routes) {
    routes.put("shop", ARouter$$Group$$shop.class);;
  }
}

ARouter$$Group$$shop 该分组下的所有的路由信息代码模版 

public class ARouter$$Group$$shop implements IRouteGroup {
  @Override
  public void loadInto(Map<String, RouteMeta> atlas) {
    atlas.put("/shop/ShopActivity", RouteMeta.build(RouteMeta.RouteType.ACTIVITY, ShopActivity.class, "/shop/ShopActivity", "shop"));;
    atlas.put("/shop/ShopDetailActivity", RouteMeta.build(RouteMeta.RouteType.ACTIVITY, ShopDetailActivity.class, "/shop/ShopDetailActivity", "shop"));;
  }
}

为了生成上面的模版代码，首先第一个@Router注解。实现Activity跳转，就要用到该注解标记Activity，通过注解处理器处理这些注解，然后在编译器生成代码：

@Target(ElementType.TYPE) // 该注解作用在类之上
@Retention(RetentionPolicy.CLASS) // 要在编译时进行一些预处理操作。注解会在class文件中存在
public @interface Router {

    // 详细路由路径（必填），如："app/MainActivity"
    String path();

    // 路由组名（选填，如果不填写，可以从path中截取）
    String group() default "";
}

然后创建路由注解处理器，类名为ARouterProcessor，该类继承AbstractProcessor。注解处理器需要注册，借助AutoService可以帮助我们自动注册到META-INF中。同时还需要指定注解处理器支持的注解类型、JDK编译的版本、注解处理器接收的参数等。

// 允许/支持的注解类型，让注解处理器处理（新增annotation module）
@SupportedAnnotationTypes({"com.example.modular.annotations.Router"})
// 指定JDK编译版本
@SupportedSourceVersion(SourceVersion.RELEASE_7)
// 注解处理器接收的参数
@SupportedOptions({"moduleName"})
// AutoService则是固定的写法，加个注解即可
// 通过auto-service中的@AutoService可以自动生成AutoService注解处理器，用来注册
// 用来生成 META-INF/services/javax.annotation.processing.Processor 文件
@AutoService(Processor.class)
public class ARouterProcessor extends AbstractProcessor { }

接下来实现process抽象方法，该方法相当于main方法，注解处理器的入口方法，用来处理被@Router标记的元素。

/**
 * 相当于main函数，开始处理注解
 * 注解处理器的核心方法，处理具体的注解，生成Java文件
 *
 * @param set              支持注释类型的集合，如：@ARouter注解
 * @param roundEnvironment 当前或是之前的运行环境,可以通过该对象查找找到的注解
 * @return true 表示后续处理器不会再处理（已经处理完成）
 */
@Override
public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
    // set集合，就是支持的注解集合，如：ARouter注解
    if (set.isEmpty()) return false;

    // 获取所有被@ARouter注解注释的元素
    Set<? extends Element> elementsAnnotatedWithARouter = roundEnvironment.getElementsAnnotatedWith(Router.class);

    if (elementsAnnotatedWithARouter != null && !elementsAnnotatedWithARouter.isEmpty()) {

        try {
            parseElements(elementsAnnotatedWithARouter);
        } catch (IOException e) {
            messager.printMessage(Diagnostic.Kind.NOTE, "异常发生：" + e.getMessage());
        }
    }
    return true;
}

在处理被@Router注解标记的元素之前，需要初始化一些工具，重写AbstractProcessor类的init方法，通过processingEnvironment获取辅助工具，如：打印Log的工具、 文件生成工具等。

// 操作Element的工具类（如：类、函数、属性都是Element）
private Elements elementUtils;

// Messager用来报告错误，警告和其他提示信息
private Messager messager;

// type(类信息)工具类，包含用于操作TypeMirror的工具方法
private Types typeUtils;

// 文件生成器，类/资源，Filter用来创建新的源文件，class文件以及辅助文件
private Filer filer;

// 模块名，通过getOptions获取build.gradle传过来
private String moduleName;

// 缓存路由信息，key：组名 value：该组名下的所有路由信息
private Map<String, List<RouteMeta>> cacheRouteMetaMap = new HashMap<>();

// 缓存分组的信息，key：组名 value：该组名下对应的路由类名，如：Router$$Group$$shop
private Map<String, String> cacheGroupMap = new HashMap<>();

/**
 * 该方法主要用于一些初始化工作，通过该方法的processingEnvironment参数可以获取一些工具
 */
@Override
public synchronized void init(ProcessingEnvironment processingEnvironment) {
    super.init(processingEnvironment);

    elementUtils = processingEnvironment.getElementUtils();
    messager = processingEnvironment.getMessager();
    typeUtils = processingEnvironment.getTypeUtils();
    filer = processingEnvironment.getFiler();

    messager.printMessage(Diagnostic.Kind.NOTE, "<<<<< ARouterProcessor::init >>>>>");

    Map<String, String> options = processingEnvironment.getOptions();
    if (options != null && !options.isEmpty()) {
        moduleName = options.get("moduleName");
        messager.printMessage(Diagnostic.Kind.NOTE, "moduleName=" + moduleName);
    }

    if (Utils.isEmpty(moduleName)) {
        throw new RuntimeException("ARouter注解处理器传入moduleName参数不能为空，清查看build.gradle配置文件配置是否正确");
    }
}

解析所有被@Router注解标记的元素，将满足条件元素中路由信息封装到RouteMeta并缓存起来。用于生成分组文件和该组下的路由文件。

private void parseElements(Set<? extends Element> elements) throws IOException {

    TypeElement activityElement = elementUtils.getTypeElement("android.app.Activity");
    TypeMirror activityMirror = activityElement.asType();

    for (Element element : elements) {
        TypeMirror elementMirror = element.asType();
        messager.printMessage(Diagnostic.Kind.NOTE, "遍历元素信息：" + elementMirror.toString());
        // 遍历元素信息：com.example.modular.shop.ShopActivity

        // 通过类节点获取包节点，（全路径名，如：com.example.modular.shop）
        String packageName = elementUtils.getPackageOf(element).getQualifiedName().toString();

        // 获取被@ARouter注解的简单类名
        String simpleName = element.getSimpleName().toString();

        // 注: 包名：com.example.modular.shop 被注解的类名：ShopActivity
        messager.printMessage(Diagnostic.Kind.NOTE, "包名：" + packageName + " 被注解的类名：" + simpleName);


        Router aRouter = element.getAnnotation(Router.class);

        RouteMeta routeMeta = new RouteMeta(element, aRouter.group(), aRouter.path());

        // 判断第一类型是否是第二类型的子类型，如果是返回true
        if (typeUtils.isSubtype(elementMirror, activityMirror)) {
            // 满足条件：被@ARouter注解的元素是Activity的子类型
            routeMeta.setType(RouteMeta.RouteType.ACTIVITY);
        } else {
            throw new RuntimeException("@ARouter注解目前只能应用与Activity类上");
        }

        fillMapWithRouteMeta(routeMeta);

    }

    createGroupFile();

    createRootFile();
}

fillMapWithRouteMeta方法用于缓存路由信息

// 缓存分组的信息，key：组名 value：该组名下对应的路由类名，如：Router$$Group$$shop
private Map<String, String> cacheGroupMap = new HashMap<>();

private void fillMapWithRouteMeta(RouteMeta routeMeta) {
    if (checkRouterPath(routeMeta)) {
        messager.printMessage(Diagnostic.Kind.NOTE, "routeMeta>>>> " + routeMeta.toString());

        List<RouteMeta> routeMetas = cacheRouteMetaMap.get(routeMeta.getGroup());

        if (routeMetas == null) {
            routeMetas = new ArrayList<>();
            cacheRouteMetaMap.put(routeMeta.getGroup(), routeMetas);
        }
        routeMetas.add(routeMeta);
    } else {
        messager.printMessage(Diagnostic.Kind.NOTE, "routeMeta检查失败，不满足规范");
    }
}

先创建路由文件，createGroupFile具体实现如下：

private void createGroupFile() throws IOException {
    if (cacheRouteMetaMap.isEmpty()) return;

    TypeElement routeGroupElement = elementUtils.getTypeElement("com.example.modular.api.IRouteGroup");

    for (Map.Entry<String, List<RouteMeta>> entry : cacheRouteMetaMap.entrySet()) {

        ParameterizedTypeName parameterizedTypeName = ParameterizedTypeName.get(
                ClassName.get(Map.class),
                ClassName.get(String.class),
                ClassName.get(RouteMeta.class)
        );

        // Map<String, RouteMeta> atlas
        ParameterSpec atlasParameter = ParameterSpec.builder(parameterizedTypeName, "atlas").build();

        // public void loadInto(Map<String, RouteMeta> atlas)
        MethodSpec.Builder loadIntoMethodBuilder = MethodSpec.methodBuilder("loadInto")
                .addAnnotation(Override.class)
                .addParameter(atlasParameter)
                .addModifiers(Modifier.PUBLIC);


        List<RouteMeta> routeMetas = entry.getValue();
        for (RouteMeta routeMeta : routeMetas) {
            // atlas.put("/shop/ShopActivity", RouteMeta.build(RouteMeta.RouteType.ACTIVITY, ShopActivity.class, "/shop/ShopActivity", "shop"));
            loadIntoMethodBuilder.addStatement(
                    "$N.put($S, $T.build($T.$L, $T.class, $S, $S));",
                    "atlas",
                    routeMeta.getPath(),
                    ClassName.get(RouteMeta.class),
                    ClassName.get(RouteMeta.RouteType.class),
                    routeMeta.getType(),
                    ClassName.get((TypeElement) routeMeta.getElement()),
                    routeMeta.getPath(),
                    routeMeta.getGroup()
            );
        }

        MethodSpec loadIntoMethod = loadIntoMethodBuilder.build();

        String groupName = entry.getKey();

        String packageName = "com.example.android.arouter.routers";
        String finalClassName = "ARouter$$Group$$" + groupName;
        messager.printMessage(Diagnostic.Kind.NOTE, "最终生成的路径的文件名：" + packageName + "." + finalClassName);

        // public class Router$$Group$$shop implements IRouteGroup
        TypeSpec finalClass = TypeSpec.classBuilder(finalClassName)
                .addMethod(loadIntoMethod)
                .addModifiers(Modifier.PUBLIC)
                .addSuperinterface(ClassName.get(routeGroupElement))
                .build();

        // 利用文件生成器生成文件
        JavaFile.builder(packageName, finalClass).build().writeTo(filer);

        cacheGroupMap.put(groupName, finalClassName);
    }
}

再创建分组文件，createRootFile方法具体实现如下：

private void createRootFile() throws IOException {
    if (cacheGroupMap.isEmpty()) return;

    TypeElement routeRootElement = elementUtils.getTypeElement("com.example.modular.api.IRouteRoot");
    TypeElement routeGroupElement = elementUtils.getTypeElement("com.example.modular.api.IRouteGroup");

    // Map<String, Class<? extends IRouteGroup>>
    ParameterizedTypeName parameterizedTypeName = ParameterizedTypeName.get(
            ClassName.get(Map.class),
            ClassName.get(String.class),
            ParameterizedTypeName.get(ClassName.get(Class.class), WildcardTypeName.subtypeOf(ClassName.get(routeGroupElement)))
    );

    // Map<String, Class<? extends IRouteGroup>> routes
    ParameterSpec routesParameter = ParameterSpec.builder(parameterizedTypeName, "routes", Modifier.FINAL).build();

    // public void loadInto(Map<String, Class<? extends IRouteGroup>> routes)
    MethodSpec.Builder loadIntoMethodBuilder = MethodSpec.methodBuilder("loadInto")
            .addModifiers(Modifier.PUBLIC)
            .addAnnotation(Override.class)
            .addParameter(routesParameter);

    String packageName = "com.example.android.arouter.routers";

    for (Map.Entry<String, String> entry : cacheGroupMap.entrySet()) {

        // 如：shop
        String groupName = entry.getKey();
        // 如：Router$$Group$$shop
        String finalGroupClassName = entry.getValue();

        // routes.put("shop", Router$$Group$$shop.class);
        loadIntoMethodBuilder.addStatement(
                "$N.put($S, $T.class);",
                "routes",
                groupName,
                ClassName.get(packageName, finalGroupClassName)
        );
    }

    MethodSpec loadIntoMethod = loadIntoMethodBuilder.build();

    String finalClassName = "ARouter$$Root$$" + moduleName;
    messager.printMessage(Diagnostic.Kind.NOTE, "最终生成的组文件名：" + packageName + "." +finalClassName);

    // public final class Router$$Root$$shop implements IRouteRoot
    TypeSpec finalClass = TypeSpec.classBuilder(finalClassName)
            .addMethod(loadIntoMethod)
            .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
            .addSuperinterface(ClassName.get(routeRootElement)).build();

    JavaFile.builder(packageName, finalClass).build().writeTo(filer);
}

XX$$ARouter$$Parameter

比如Activity跳转，需要携带了参数，我们需要通过Activity.getIntent()获取参数。这些模版代码也可以注解处理器帮我们生成。

public final class ShopActivity$$ARouter$$Parameter implements IParameter {
  @Override
  public void inject(final Object object) {
    ShopActivity target = (ShopActivity) object;;
    target.name = target.getIntent().getStringExtra("name");;
    target.age = target.getIntent().getIntExtra("shopAge", target.age);;
    target.isOpen = target.getIntent().getBooleanExtra("isOpen", target.isOpen);;
  }
}

创建ParameterProcessor注解处理器，用来生成获取参数的模板代码，该类同样继承AbstractProcessor

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.CLASS)
public @interface Parameter {
    String name() default "";
}

// 允许/支持的注解类型，让注解处理器处理（新增annotation module）
@SupportedAnnotationTypes({"com.example.modular.annotations.Parameter"})
// 指定JDK编译版本
@SupportedSourceVersion(SourceVersion.RELEASE_7)
// 注解处理器接收的参数
@SupportedOptions({"moduleName"})
// AutoService则是固定的写法，加个注解即可
// 通过auto-service中的@AutoService可以自动生成AutoService注解处理器，用来注册
// 用来生成 META-INF/services/javax.annotation.processing.Processor 文件
@AutoService(Processor.class)
public class ParameterProcessor extends AbstractProcessor {}

实现process方法，处理被@Parameter标记的元素。

@Override
public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
    if (set.isEmpty()) return false;

    Set<? extends Element> elementsAnnotatedWithParameter = roundEnvironment.getElementsAnnotatedWith(Parameter.class);

    if (elementsAnnotatedWithParameter != null && !elementsAnnotatedWithParameter.isEmpty()) {

        fillMapWithElement(elementsAnnotatedWithParameter);
        try {
            createParameterFile();
        } catch (IOException e) {
            messager.printMessage(Diagnostic.Kind.NOTE,
                    "ParameterProcessor发生异常：" + e.getMessage());
        }

        return true;
    }
    return false;
}

其中fillMapWithElement用于缓存所有满足条件的元素

private final Map<TypeElement, List<Element>> cacheMap = new HashMap<>();

private void fillMapWithElement(Set<? extends Element> elementsAnnotatedWithParameter) {
    for (Element element : elementsAnnotatedWithParameter) {
        // @Parameter注解作用在字段上，获取字段的父元素
        TypeElement enclosingElement = (TypeElement) element.getEnclosingElement();
        messager.printMessage(Diagnostic.Kind.NOTE,
                "@Parameter遍历父元素信息：" + enclosingElement.getSimpleName() + " && 遍历元素信息: " + element.getSimpleName());

        List<Element> elements = cacheMap.get(enclosingElement);
        if (elements == null) {
            List<Element> fields = new ArrayList<>();
            fields.add(element);
            cacheMap.put(enclosingElement, fields);
        } else {
            elements.add(element);
        }
    }
}

接下来用于创建生成文件

private void createParameterFile() throws IOException {
    if (cacheMap.isEmpty()) return;

    TypeElement activityElement = elementUtils.getTypeElement("android.app.Activity");

    ParameterSpec objectParameter = ParameterSpec.builder(TypeName.OBJECT, "object", Modifier.FINAL).build();

    TypeElement parameterType = elementUtils.getTypeElement("com.example.modular.api.IParameter");

    for (Map.Entry<TypeElement, List<Element>> entry : cacheMap.entrySet()) {

        TypeElement typeElement = entry.getKey();

        if (!typeUtils.isSubtype(typeElement.asType(), activityElement.asType())) {
            throw new RuntimeException("@Parameter注解目前只能应用于Activity上");
        }

        ClassName className = ClassName.get(typeElement);

        // public void inject(Object object)
        MethodSpec.Builder injectMethodBuilder = MethodSpec.methodBuilder("inject")
                .addAnnotation(Override.class)
                .addModifiers(Modifier.PUBLIC)
                .addParameter(objectParameter);

        // MainActivity target = (MainActivity) object;
        injectMethodBuilder.addStatement(
                "$T target = ($T) $N;",
                className,
                className,
                "object"
        );

        List<Element> elements = entry.getValue();
        for (Element element : elements) {
            TypeMirror typeMirror = element.asType();

            int type = typeMirror.getKind().ordinal();

            String fieldName = element.getSimpleName().toString();

            // 获取注解中定义的字段名
            String name = element.getAnnotation(Parameter.class).name();

            // 如果注解中没有定义，则使用默认的字段名
            String finalName = Utils.isEmpty(name) ? fieldName : name;

            String finalValue = "target." + fieldName;

            String format = finalValue + " = target.getIntent().";

            if (type == TypeKind.INT.ordinal()) {
                // target.age = target.getIntent().getIntExtra("appAge", target.age);
                format += "getIntExtra($S, " + finalValue + ");";
            } else if (type == TypeKind.BOOLEAN.ordinal()) {
                // target.isOpen = target.getIntent().getBooleanExtra("isOpen", target.isOpen);
                format += "getBooleanExtra($S, " + finalValue + ");";
            } else {

                if (typeMirror.toString().equals("java.lang.String")) {
                    // target.name = target.getIntent().getStringExtra("name");
                    format += "getStringExtra($S);";
                }
            }

            if (format.endsWith(";")) {
                // target.name = target.getIntent().getStringExtra("name");
                injectMethodBuilder.addStatement(format, finalName);
            } else {
                messager.printMessage(Diagnostic.Kind.ERROR, "目前仅仅支持String int Boolean类型参数");
            }
        }

        MethodSpec injectMethod = injectMethodBuilder.build();

        String finalClassName = typeElement.getSimpleName() + "$$ARouter$$Parameter";
        messager.printMessage(Diagnostic.Kind.NOTE,
                "最终生产的参数类文件：" + className.packageName() + "." + finalClassName);

        // public final class MainActivity$$Router$$Parameter implements IParameter
        TypeSpec finalClass = TypeSpec.classBuilder(finalClassName)
                .addMethod(injectMethod)
                .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
                .addSuperinterface(ClassName.get(parameterType))
                .build();

        JavaFile.builder(className.packageName(), finalClass).build().writeTo(filer);
    }
}

如果我的文章对您有帮助，不妨点个赞鼓励一下(^_^)

原文  https://segmentfault.com/a/1190000021282958
正文到此结束
所属分类： 编程技术 软件架构

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
springboot-demo Java入门教程 bootstrap3 CSS Apache基础教程 php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 MongoDB教程 Struts2教程 Redis教程 Spring教程 Git教程 Jenkins进阶系列 openfire参考指南 Java设计模式 HBase教程 Maven教程 hibernate教程 Docker 教程 memcached教程 Quartz指南 Hive教程 Ant教程 ANTLR教程 SpringCloud java实例教程 springcloud-demo XStream教程 Hazelcast教程 Elastic-Job-Lite 深入浅出MyBatis SVN教程 ibaties教程 rabittmq教程 solr教程 Hadoop教程 WebService CXF学习 JPA教程 ActiveMQ中文指南 java-demo Java内存模型 dubbo教程 python3-demo Linux入门视频教程
近期评论
  1. 1 Spring Cloud Consul实现选举机制
  2. 2 Spring Boot集成ShedLock实现分布式定时任务
  3. 3 利用oss进行数据库和网站图片备份
  4. 4 Spring Cloud Stream实现数据流处理
  5. 5 Python3访问MySQL数据库快速入门Demo
  6. 6 Github开源项目作者可以免费申请 JetBrains 全家桶
  7. 7 Spring Cloud Vault快速入门Demo
  8. 8 Spring Cloud Gateway快速入门Demo
  9. 9 Spring Cloud Contract快速入门Demo
  10. 10 Spring Cloud Consul快速入门Demo
网站信息
  • 文章总数：82,714 篇
  • 文件总数：284,287 个
  • 标签总数：2,393 个
  • 分类总数：85 个
  • 留言数量：2,560 条
  • 在线人数：662 人
  • 运行天数：4,409天
  • 最后更新：2024年11月22日01点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG