weixin_34034670
weixin_34034670

Android组件化专题 - 路由框架原理

在路由框架之前，我们先了解什么是APT，并实践ButterKnife绑定findById的小功能。为什么先要讲解apt,因为路由的实现apt是核心的代码.看下面链接 APT 实践。

本文项目地址

为什么需要路由

我们知道路由就是实现页面的跳转，然而Android原生已经支持app页面间的跳转。

一般来说我们会这样写：

Intent intent = new Intent(this, MainActivity.class);
intent.putExtra("dataKey", "dataValue");
startActivity(intent);
复制代码

如果在封装一层这样写：

public class ManagerActivity extends BaseActivity {
	public static void launch(Context context, int startTab) {
		Intent i = new Intent(context, ManagerActivity.class);
		i.putExtra(INTENT_IN_INT_START_TAB, startTab);
		context.startActivity(i);
	}
}
复制代码

其实无论那种实现方式，本质上都是生成Intent，然后通过context.startActivity/context.startActivityForResult来实现页面的跳转。但是这种方法的不足是：当包含多个模块，且模块之间没有相互依赖的跳转就会变的很困难，如果知道模块对应的类名和路径，可以通过Intent.setComponent(Component)方法启动其他模块的页面。同时还要写大量重复代码，要记录每个模块的类名和路径，如果类名和路径发生改变的话。。。。。。我相信你的内心肯定是崩溃的。

存在的一些缺点：

  • 显示Intent：项目庞大以后，类依赖耦合太大，不适合组件化拆分
  • 隐式Intent：协作困难，调用时候不知道调什么参数
  • 每个注册了Scheme的Activity都可以直接打开，有安全风险
  • AndroidMainfest集中式管理比较臃肿
  • 无法动态修改路由，如果页面出错，无法动态降级
  • 无法动态拦截跳转，譬如未登录的情况下，打开登录页面，登录成功后接着打开刚才想打开的页面
  • H5、Android、iOS地址不一样，不利于统一跳转

页面路由的意义：

路由最先被应用于网络中，路由的定义可以通过互联的网络把信息从源地址传输到目的地址的过程。每个页面可以定义为一个统一的资源标示符，在网络当中能够被别人访问，也可以访问已经被定义了的页面。

路由常见的使用场景：

  • App接收到一个通知，点击通知打开App的某个页面
  • 浏览器App中点击某个链接打开App的某个页面
  • App的H5活动页面打开一个链接，可能是H5跳转，也可能是跳转到某一个native页面
  • 打开页面需要某些条件，先验证完条件，再去打开那个页面(如验证是否登录)
  • 不合法的打开App的页面被屏蔽掉
  • App内的跳转，可以减少手动构建Intent的成本，同时可以统一携带部分参数到下一个页面
  • App存在就打开页面，不存在就去下载页面下载,只有Google的App Link支持

路由框架实现思路

通过上述的路由的应用和APT开发，相信你对APT有了一定的了解，那么路由框架要如何实现呢？实现思路是怎样的？

路由设计的思路

  1. 通过注解 Activity 类，注解处理器处理注解（APT）动态生成路由信息。
  2. 收集路由：通过定义的包名，找到所有动态生成的类，将路由信息存储到本地仓库 （rootMap）.
  3. 页面跳转：根据注解的路由地址，从本地仓库中找到相关的路由信息，获取到要跳转的类，然后实现跳转。

只需要在使用路由的页面定义一个类注解@Router即可，页面路由的使用也相当简单

下面我们看下具体代码的实现思路

  1. 首先实现自定义注解，新建一个java lib 取名:primrouter-annotation
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.CLASS)
public @interface Router {
    /**
     * 设置路由地址/main/text
     * @return 地址
     */
    String path();

    /**
     * 设置路由组，若为空以路由地址的第一个来作为组名main
     * @return 路由组
     */
    String group() default "";
}
复制代码
  1. 然后我们要清楚动态生成的类，其实主要就是存储一些跳转的Activity的类信息和路由地址等，同时为了逻辑更加清晰，给不同的module的进行分组。当路由跳转的时候可以通过路由group 得到分组表，然后通过路由地址path得到分组表中存储的路由对象，来实现跳转。

如以下自动生成的类：

module 存储的分组信息

public class PrimRouter$$Root$$moudle1 implements IRouteRoot {
  @Override
  public void loadInto(Map> routers) {
    routers.put("module", PrimRouter$$Group$$module.class);
  }
}
复制代码

具体分组：

public class PrimRouter$$Group$$module implements IRouteGroup {
  @Override
  public void loadInto(Map atlas) {
    atlas.put("/module/test",RouterMeta.build(RouterMeta.Type.ACTIVITY,MainActivity.class,"/module/test","module"));
    atlas.put("/module/test2",RouterMeta.build(RouterMeta.Type.ACTIVITY,Main2Activity.class,"/module/test2","module"));
  }
}
复制代码

RouterMeta 就是存储了一些路由分组表的信息

/**
 * 存储的路由对象
 */
public class RouterMeta {

    /**
     * 路由的类型枚举
     */
    public enum Type {
        ACTIVITY, INSTANCE
    }

    /**
     * 路由的类型
     */
    private Type type;

    /**
     * 节点 activity
     */
    private Element element;

    /**
     * 注解使用的类对象
     */
    private Class destination;

    /**
     * 路由地址
     */
    private String path;

    /**
     * 路由组
     */
    private String group;

    public static RouterMeta build(Type type, Class destination, String path, String
            group) {
        return new RouterMeta(type, null, destination, path, group);
    }


    public RouterMeta() {
    }

    public RouterMeta(Type type, Router router, Element element) {
        this(type, element, null, router.path(), router.group());
    }

    public RouterMeta(Type type, Element element, Class destination, String path, String group) {
        this.type = type;
        this.destination = destination;
        this.element = element;
        this.path = path;
        this.group = group;
    }

    public void setType(Type type) {
        this.type = type;
    }

    public void setElement(Element element) {
        this.element = element;
    }

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

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

    public void setGroup(String group) {
        this.group = group;
    }

    public Type getType() {
        return type;
    }

    public Element getElement() {
        return element;
    }

    public Class getDestination() {
        return destination;
    }

    public String getPath() {
        return path;
    }

    public String getGroup() {
        return group;
    }
}

复制代码
  1. 动态生成Java class类，新建一个 java lib 取名：prim_compiler 这一步通过APT来实现。这一步其实很简单分析完要生成的类，然后通过javaopt 来动态生成，如果还不懂APT 可以看这一篇文章APT 实践。

gradle 配置：

apply plugin: 'java-library'

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'com.google.auto.service:auto-service:1.0-rc4'
    implementation 'com.squareup:javapoet:1.11.1'
    implementation project(':primrouter-annotation')
}

sourceCompatibility = "1.7"
targetCompatibility = "1.7"
复制代码

新建一个processor类

//AnnotationProcessor register
@AutoService(Processor.class)

/**
 * compiled java version {@link AbstractProcessor#getSupportedSourceVersion()}
 */
@SupportedSourceVersion(RELEASE_7)

/**
 * Allow AnnotationProcessor process annotation，{@link AbstractProcessor#getSupportedAnnotationTypes()}
 */
@SupportedAnnotationTypes({"com.prim.router.primrouter_annotation.Router"})

/**
 * 注解处理器接收的参数 {@link AbstractProcessor#getSupportedOptions()}
 */
@SupportedOptions({Consts.ARGUMENTS_NAME})

/**
 * Router 注解处理器
 */
public class RouterProcessor extends AbstractProcessor {

    private Messager messager;

    /**
     * 文件生成器 类/资源
     */
    private Filer filer;

    /**
     *
     */
    private Locale locale;

    /**
     * 获取传递的参数
     */
    private Map options;

    /**
     * compiled java version
     */
    private SourceVersion sourceVersion;

    /**
     * 类型工具类
     */
    private Types typeUtils;

    /**
     * 节点工具类
     */
    private Elements elementUtils;

    /**
     * 模块的名称
     */
    private String moduleName;

    /**
     * key 组名  value 类名
     */
    private Map rootMap = new TreeMap<>();

    /**
     * 分组 key 组名  value 对应组的路由信息
     */
    private Map> groupMap = new HashMap<>();

    private Log log;

    /**
     * init process environment utils
     *
     * @param processingEnvironment
     */
    @Override
    public synchronized void init(ProcessingEnvironment processingEnvironment) {
        super.init(processingEnvironment);
        messager = processingEnvironment.getMessager();
        log = Log.newLog(messager);
        filer = processingEnvironment.getFiler();
        locale = processingEnvironment.getLocale();
        options = processingEnvironment.getOptions();
        sourceVersion = processingEnvironment.getSourceVersion();
        typeUtils = processingEnvironment.getTypeUtils();
        elementUtils = processingEnvironment.getElementUtils();

        // 获取传递的参数
        if (!options.isEmpty()) {
            moduleName = options.get(Consts.ARGUMENTS_NAME);
            log.i("module:" + moduleName);
        }

        if (Utils.isEmpty(moduleName)) {
            throw new NullPointerException("Not set Processor Parmaters.");
        }

    }

    /**
     * process annotation
     *
     * @param set              The set of nodes that support processing annotations
     * @param roundEnvironment Current or previous operating environment，annotation that can be found by this object
     * @return true already processed ，follow-up will not be dealt with
     */
    @Override
    public boolean process(Set set, RoundEnvironment roundEnvironment) {
        if (!set.isEmpty()) {
            //Set nodes annotated by Router
            Set annotatedWith = roundEnvironment.getElementsAnnotatedWith(Router.class);
            if (annotatedWith != null) {
                processRouter(annotatedWith);
            }
            return true;
        }
        return false;
    }

    /**
     * 处理被注解的节点集合
     *
     * @param annotatedWith
     */
    private void processRouter(Set annotatedWith) {
        RouterMeta routerMeta = null;
        //获得Activity类的节点信息
        TypeElement activity = elementUtils.getTypeElement(Consts.Activity);
        //单个的节点
        for (Element element : annotatedWith) {
            // 获取类信息 如Activity类
            TypeMirror typeMirror = element.asType();
            // 获取节点的注解信息
            Router annotation = element.getAnnotation(Router.class);
            //只能指定的类上面使用
            if (typeUtils.isSubtype(typeMirror, activity.asType())) {
                //存储路由相关的信息
                routerMeta = new RouterMeta(RouterMeta.Type.ACTIVITY, annotation, element);
            } else if (typeUtils.isSubtype(typeMirror, activity.asType())) {

            } else {
                throw new RuntimeException("Just Support Activity Router!");
            }

            //检查是否配置group如果没有配置 则从path中截取组名
            checkRouterGroup(routerMeta);
        }

        //获取 primrouter-core IRouterGroup 类节点
        TypeElement routeGroupElement = elementUtils.getTypeElement(Consts.ROUTEGROUP);
        //获取 primrouter-core IRouterRoot 类节点
        TypeElement routeRootElement = elementUtils.getTypeElement(Consts.ROUTEROOT);

        //生成 $$Group$$ 记录分组表
        generatedGroupTable(routeGroupElement);

        //生成 $$Root$$ 记录路由表
        generatedRootTable(routeRootElement, routeGroupElement);
    }

   
}
复制代码

检查路由地址是否配置正确，这一步可以自己定义相关的路由地址规则

 /**
     * 检查设置路由组
     *
     * @param routerMeta
     */
    private void checkRouterGroup(RouterMeta routerMeta) {
        if (routerVerify(routerMeta)) {
            List routerMetas = groupMap.get(routerMeta.getGroup());
            if (Utils.isEmpty(routerMetas)) {
                routerMetas = new ArrayList<>();
                routerMetas.add(routerMeta);
                groupMap.put(routerMeta.getGroup(), routerMetas);
            } else {
                routerMetas.add(routerMeta);
            }
        } else {
            log.i("router path no verify,please check");
        }
    }

    /**
     * 验证路由地址配置是否正确合法性
     *
     * @param routerMeta 存储的路由bean对象
     * @return true 路由地址配置正确  false 路由地址配置不正确
     */
    private boolean routerVerify(RouterMeta routerMeta) {
        String path = routerMeta.getPath();
        if (Utils.isEmpty(path)) {
            throw new NullPointerException("@Router path not to be null or to length() == 0");
        }
        if (!path.startsWith("/")) {//路由地址必须以/开头
            throw new IllegalArgumentException("@Router path must / first");
        }
        String group = routerMeta.getGroup();
        if (Utils.isEmpty(group)) {
            String defaultGroup = path.substring(1, path.indexOf("/", 1));
            //截取的还是为空
            if (Utils.isEmpty(defaultGroup)) {
                return false;
            }
            //设置group
            routerMeta.setGroup(defaultGroup);
        }
        return true;
    }
复制代码

生成分组表class 类

    /**
     * 生成分组表class 类
     *
     * @param routeGroupElement primrouter-core IRouterGroup 类节点
     */
    private void generatedGroupTable(TypeElement routeGroupElement) {
        //创建参数类型 Map
        ParameterizedTypeName atlas = ParameterizedTypeName.get(ClassName.get(Map.class),
                ClassName.get(String.class),
                ClassName.get(RouterMeta.class));

        //创建参数 Map atlas
        ParameterSpec altlas = ParameterSpec
                .builder(atlas, Consts.GROUP_PARAM_NAME)//参数名
                .build();//创建参数

        //遍历分组 每一个分组 创建一个 $$Group$$类
        for (Map.Entry> entry : groupMap.entrySet()) {
            MethodSpec.Builder builder = MethodSpec.methodBuilder(Consts.GROUP_METHOD_NAME)//函数名
                    .addModifiers(PUBLIC)//作用域
                    .addAnnotation(Override.class)//添加一个注解
                    .addParameter(altlas);//添加参数

            //Group组中
            List groupData = entry.getValue();

            //遍历 生成函数体
            for (RouterMeta meta : groupData) {
                //$S = String
                //$T = class
                //添加函数体
                builder.addStatement(Consts.GROUP_PARAM_NAME+".put($S,$T.build($T.$L,$T.class,$S,$S))",
                        meta.getPath(),
                        ClassName.get(RouterMeta.class),
                        ClassName.get(RouterMeta.Type.class),
                        meta.getType(),
                        ClassName.get((TypeElement) meta.getElement()),
                        meta.getPath(),
                        meta.getGroup());
            }

            MethodSpec loadInto = builder.build();//函数创建完成loadInto();

            String groupClassName = Consts.GROUP_CLASS_NAME + entry.getKey();

            TypeSpec typeSpec = TypeSpec.classBuilder(groupClassName)//类名
                    .addSuperinterface(ClassName.get(routeGroupElement))//实现接口IRouteGroup
                    .addModifiers(PUBLIC)//作用域
                    .addMethod(loadInto)//添加方法
                    .build();//类创建完成

            //生成Java文件
            JavaFile javaFile = JavaFile
                    .builder(Consts.PAGENAME, typeSpec)//包名和类
                    .build();
            try {
                javaFile.writeTo(filer);
            } catch (IOException e) {
                e.printStackTrace();
            }
            rootMap.put(entry.getKey(), groupClassName);
        }

    }
复制代码

生成路由表class 类

    /**
     * 生成路由表class 类
     *
     * @param routeRootElement
     */
    private void generatedRootTable(TypeElement routeRootElement, TypeElement routeGroupElement) {
        类型 Map> routes>
        ParameterizedTypeName atlas = ParameterizedTypeName.get(ClassName.get(Map.class),
                ClassName.get(String.class),
                ParameterizedTypeName.get(
                        ClassName.get(Class.class),
                        WildcardTypeName.subtypeOf(ClassName.get(routeGroupElement))));

        //创建参数  Map>> routes
        ParameterSpec altlas = ParameterSpec
                .builder(atlas, Consts.ROOT_PARAM_NAME)//参数名
                .build();//创建参数

        //public void loadInfo(Map> routes> routes)
        //函数 public void loadInfo(Map> routes> routes)
        MethodSpec.Builder loadIntoMethodOfRootBuilder = MethodSpec.methodBuilder
                (Consts.ROOT_METHOD_NAME)
                .addAnnotation(Override.class)
                .addModifiers(PUBLIC)
                .addParameter(altlas);

        //函数体
        for (Map.Entry entry : rootMap.entrySet()) {
            loadIntoMethodOfRootBuilder.addStatement(Consts.ROOT_PARAM_NAME + ".put($S, $T.class)", entry
                    .getKey(), ClassName.get(Consts.PAGENAME, entry.getValue
                    ()));
        }
        //生成 $Root$类
        String rootClassName = Consts.ROOT_CLASS_NAME + moduleName;
        try {
            JavaFile.builder(Consts.PAGENAME,
                    TypeSpec.classBuilder(rootClassName)
                            .addSuperinterface(ClassName.get(routeRootElement))
                            .addModifiers(PUBLIC)
                            .addMethod(loadIntoMethodOfRootBuilder.build())
                            .build()
            ).build().writeTo(filer);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
复制代码
  1. 检查动态生成的类是否正确

在app的gradle 中配置：

annotationProcessor project(':primrouter-compiler')

implementation project(':primrouter-annotation')
复制代码

在MainActivity中添加注解

@Router(path = "/app/main")
public class MainActivity extends AppCompatActivity {
}
复制代码

会生成以下两个类：

则说明动态生成类正确。

  1. 最核心的部分，编写核心代码库：primrouter-core 首先我们需要在Application中初始化 路由表，也就是说将生成的路由表存到本地的仓库HashMap 中

如何收集路由表？我们可以根据生成路由表的类的包名来找到路由表的类名，因为生成类的包名是我们自己定制的，那么我们完全可以找到这个包下面的所有的类。 代码如下：

    public static final String PAGENAME = "com.prim.router.generated";

    public static final String GROUP_CLASS_NAME = "PrimRouter$$Group$$";

    public static final String ROOT_CLASS_NAME = "PrimRouter$$Root$$";
复制代码
/**
     * 根据包名 找到包下的类
     *
     * @param application
     * @param pageName
     * @return
     */
    public static Set getFileNameByPackageName(Application application, final String pageName) throws InterruptedException {
        final Set classNams = new HashSet<>();
        List sourcePath = getSourcePath(application);//apk 的资源路径
        //使用同步计数器判断均处理完成
        final CountDownLatch countDownLatch = new CountDownLatch(sourcePath.size());
        ThreadPoolExecutor threadPoolExecutor = DefaultPoolExecutor.newDefaultPoolExecutor(sourcePath.size());
        for (final String path : sourcePath) {
            threadPoolExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    DexFile dexFile = null;
                    try {
                        //加载apk中的dex遍历 获得所有包名为pageName的类
                        dexFile = new DexFile(path);
                        Enumeration entries = dexFile.entries();
                        while (entries.hasMoreElements()) {
                            String className = entries.nextElement();
                            if (className.startsWith(pageName)) {
                                classNams.add(className);
                            }
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    } finally {
                        if (null != dexFile) {
                            try {
                                dexFile.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                        //释放1个
                        countDownLatch.countDown();
                    }
                }
            });
        }
        //等待执行完成
        countDownLatch.await();
        return classNams;
    }
复制代码

找到类之后，我们就可以收集路由来存储到本地仓库了

/**
     * 初始化-收集路由表，必须在Application中初始化
     *
     * @param application
     */
    public void initRouter(Application application) {
        this.application = application;
        try {
            loadRouteTable();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    /**
     * 收集加载路由表
     */
    private void loadRouteTable() throws InterruptedException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        if (application == null) {
            throw new IllegalArgumentException("initRouter(Application application) must Application init");
        }
        //获取所有APT 生成的路由类的全类名
        Set routerMap = Utils.getFileNameByPackageName(application, PAGENAME);
        for (String className : routerMap) {
            //获取root中注册的路由分组信息，存储到本地仓库中。
            if (className.startsWith(PAGENAME + "." + ROOT_CLASS_NAME)) {
                Object instance = Class.forName(className).getConstructor().newInstance();
                if (instance instanceof IRouteRoot) {
                    IRouteRoot routeRoot = (IRouteRoot) instance;
                    routeRoot.loadInto(Depository.rootMap);
                }
            }

            Log.e(TAG, "路由表分组信息 「");
            for (Map.Entry> entry : Depository.rootMap.entrySet()) {
                Log.e(TAG, "【key --> " + entry.getKey() + ": value --> " + entry.getValue() + "]");
            }
            Log.e(TAG, " 」");
        }
    }
复制代码
  1. 路由的跳转实现，这一步同样也很简单，既然路由的信息我们都存储起来了，那么就可以根据路由地址来找到相关的Activity全类名，然后就可以跳转了，核心逻辑如下：
public JumpCard jump(String path) {
        if (TextUtils.isEmpty(path)) {
            throw new RuntimeException("路由地址无效");
        } else {
            return new JumpCard(path, getGroupName(path));
        }
    }

    public JumpCard jump(String path, String group) {
        if (TextUtils.isEmpty(path) || TextUtils.isEmpty(group)) {
            throw new RuntimeException("路由地址无效");
        } else {
            return new JumpCard(path, group);
        }
    }

    public JumpCard jump(String path, String group, Bundle bundle) {
        if (TextUtils.isEmpty(path) || TextUtils.isEmpty(group)) {
            throw new RuntimeException("路由地址无效");
        } else {
            return new JumpCard(path, group, bundle);
        }
    }


    public Object navigation(final Context context, final JumpCard jumpCard, final int requestCode, Object o1) {
        if (context == null) {
            return null;
        }
        produceJumpCard(jumpCard);
        switch (jumpCard.getType()) {
            case ACTIVITY:
                final Intent intent = new Intent(context, jumpCard.getDestination());
                intent.putExtras(jumpCard.getExtras());
                if (jumpCard.getFlags() != -1) {
                    intent.setFlags(jumpCard.getFlags());
                } else if (!(context instanceof Activity)) {
                    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                }
                mHandler.post(new Runnable() {//在主线程中跳转
                    @Override
                    public void run() {
                        //可能需要返回码
                        if (requestCode > 0) {
                            ActivityCompat.startActivityForResult((Activity) context, intent,
                                    requestCode, jumpCard.getOptionsBundle());
                        } else {
                            ActivityCompat.startActivity(context, intent, jumpCard
                                    .getOptionsBundle());
                        }

                        if ((0 != jumpCard.getEnterAnim() || 0 != jumpCard.getExitAnim()) &&
                                context instanceof Activity) {
                            //老版本
                            ((Activity) context).overridePendingTransition(jumpCard
                                            .getEnterAnim()
                                    , jumpCard.getExitAnim());
                        }
                        //跳转完成
//                        if (null != callback) {
//                            callback.onArrival(postcard);
//                        }
                    }
                });
                break;
        }
        return null;
    }

    /**
     * 准备跳卡
     */
    private void produceJumpCard(JumpCard card) {
        //获取仓库中存储的 具体每个组的信息
        RouterMeta routerMeta = Depository.groupMap.get(card.getPath());
        if (routerMeta == null) {//没有记录在仓库中，从路由表的分组信息中查找
            Class groupClass = Depository.rootMap.get(card.getGroup());
            if (groupClass == null) {
                throw new RuntimeException("没有找到对应的路由表信息：" + card.getGroup() + ":" + card.getPath());
            }
            IRouteGroup routeGroup = null;
            try {
                routeGroup = groupClass.getConstructor().newInstance();
            } catch (Exception e) {
                throw new RuntimeException("路由映射表信息记录失败");
            }
            routeGroup.loadInto(Depository.groupMap);
            produceJumpCard(card);//再次进入
        } else {
            //设置要跳转的类
            card.setDestination(routerMeta.getDestination());
            //设置要跳转的类型
            card.setType(routerMeta.getType());
        }

    }

    /**
     * 通过路由地址获取分组名
     *
     * @param path
     * @return
     */
    private String getGroupName(String path) {
        if (!path.startsWith("/")) {
            throw new RuntimeException(path + ": 不能有效的提取group");
        }
        try {
            String group = path.substring(1, path.indexOf("/", 1));
            if (TextUtils.isEmpty(group)) {
                throw new RuntimeException("不能有效的提取group");
            }
            return group;
        } catch (Exception e) {
            return null;
        }
    }
复制代码
  1. 核心代码基本写完那么我们来测试以下：

app 跳转到一个到module Activity,和 module 之间的跳转。

@Router(path = "/app/main")
public class MainActivity extends AppCompatActivity {

    private Button appToModule;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        appToModule = findViewById(R.id.appToModule);
        appToModule.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                module1();
            }
        });
    }

    public void module1() {
        PrimRouter.getInstance().jump("/module/test2").navigation(this);
    }
}
复制代码

module

@Router(path = "/module/test2")
public class Main2Activity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main2);
    }
}
复制代码

比较稳定的路由框架，有好多这里就不一一例举了：

ActivityRouter

阿里的ARouter

Android的组件化专题： 组件化配置

APT实战

路由框架原理

模块间的业务通信

你可能感兴趣的:(Android组件化专题 - 路由框架原理)

  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • 扫地机类清洁产品之直流无刷电机控制 悟空胆好小 清洁服务机器人单片机人工智能
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 基于社交网络算法优化的二维最大熵图像分割 智能算法研学社（Jack旭） 智能优化算法应用图像分割算法php开发语言
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • 利用LangChain的StackExchange组件实现智能问答系统 nseejrukjhad langchainmicrosoft数据库python
    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • git - Webhook让部署自动化 大猪大猪
    我们现在有一个需求，将项目打包上传到gitlab或者github后，程序能自动部署，不用手动地去服务器中进行项目更新并运行，如何做到？这里我们可以使用gitlab与github的挂钩，挂钩的原理就是，每当我们有请求到gitlab与github服务器时，这时他俩会根据我们配置的挂钩地扯进行访问，webhook挂钩程序会一直监听着某个端口请求，一但收到他们发过来的请求，这时就知道用户有请求提交了，这时
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • 自我意识 徐立华
    ----读帕克.帕尔默《教学勇气》（P18----19）5.铸造我们的学科帕克.帕尔默说学科知识对我们的自身认同和外部世界有启发意义。学科会铸造我们。“在我们与学科的命题概念和学科的生活框架相遇之前，自我意识知识处于潜伏状态，通过回想学科是怎样唤醒自我意识，我们就可以找回教学心灵。”《教学勇气》（P18）我们的自我意识像冰山表面下无限延伸的冰层，常常处于潜伏状态。但是在我们对所教授的学科进行深入思
  • ARM驱动学习之基础小知识 JT灬新一 ARM嵌入式arm开发学习
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
  • 基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python开发语言
    基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
  • Faiss：高效相似性搜索与聚类的利器 网络·魚 大数据faiss
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞 文章永久免费只为良心 oracle数据库
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
  • insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
  • ES聚合分析原理与代码实例讲解 光剑书架上的书 大厂Offer收割机面试题简历程序员读书硅基计算碳基计算认知计算生物计算深度学习神经网络大数据AIGCAGILLMJavaPython架构设计Agent程序员实现财富自由
    ES聚合分析原理与代码实例讲解1.背景介绍1.1问题的由来在大规模数据分析场景中，特别是在使用Elasticsearch（ES）进行数据存储和检索时，聚合分析成为了一个至关重要的功能。聚合分析允许用户对数据集进行细分和分组，以便深入探索数据的结构和模式。这在诸如实时监控、日志分析、业务洞察等领域具有广泛的应用。1.2研究现状目前，ES聚合分析已经成为现代大数据平台的核心组件之一。它支持多种类型的聚
  • 2022-08-28 蔚蓝一片晴
    初三暑假培训收获点滴从8月25至8月27日三天两晚的培训结束了，回到家中，该静下心来整理一下触动心灵的收获，成为成长的积淀。1.在优秀团队中快速成长与提升，做一名反思成长型教师一名专业型教师的教学指导包括了教学原理知识、案例知识、策略知识。面对教学中的遇到的有趣的情形、问题会去研究其理，寻找更好的教法学法对策。从新手到成熟型教师，再走向专业型教师，需要的是觉醒与反思，多进行案例研究，从案例中观察、
  • STM32中的计时与延时 lupinjia STM32stm32单片机
    前言在裸机开发中，延时作为一种规定循环周期的方式经常被使用，其中尤以HAL库官方提供的HAL_Delay为甚。刚入门的小白可能会觉得既然有官方提供的延时函数，而且精度也还挺好，为什么不用呢？实际上HAL_Delay中有不少坑，而这些也只是HAL库中无数坑的其中一些。想从坑里跳出来还是得加强外设原理的学习和理解，切不可只依赖HAL库。除了延时之外，我们在开发中有时也会想要确定某段程序的耗时，这就需要
  • 2.2.6 通知类控件 Toast、Menu 常思行
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
  • 第1步win10宿主机与虚拟机通过NAT共享上网互通 学习3人组 大数据大数据
    VM的CentOS采用NAT共用宿主机网卡宿主机器无法连接到虚拟CentOS要实现宿主机与虚拟机通信，原理就是给宿主机的网卡配置一个与虚拟机网关相同网段的IP地址，实现可以互通。1、查看虚拟机的IP地址2、编辑虚拟机的虚拟网络的NAT和DHCP的配置，设置虚拟机的网卡选择NAT共享模式3、宿主机的IP配置，确保vnet8的IPV4属性与虚拟机在同一网段4、ping测试连通性[root@localh
  • FPGA复位专题---（3）上电复位？ FPGA系统设计指南针 FPGA系统设计(内训)fpga开发
    （3）上电复位？1目录（a）FPGA简介（b）Verilog简介（c）复位简介（d）上电复位？（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • 5分钟说透AppStore审核原理，让你拥有上架新思路！ Q仔本人噢
    在AppStore上架是越来越难了!相信非常多公司的技术人员都为此困扰，然而外包团队水平又层次不齐，容易遇坑，实在是内忧外患。是什么原因导致审核机制频繁调整？又是什么原因使得审核变得越发严格？那么接下来听小Q分解，马上给各位带来解答!首先看一下近一年的上下架的情况：近一年上架情况近一年下架情况通过数据我们发现越是马甲包产量权重高的分类里被下架的app数量越多，苹果此举可谓是上有政策，下有对策。通过
  • Java：爬虫框架 dingcho Javajava爬虫
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
  • 2019-03-24 李飞720
    姓名：李飞企业名称：临沂鑫道食品有限公司组别373期利他1组日精进打卡第338天】【知~学习】1、阿米巴经营一段2、活用人才1段3、活法、一段【行~实践】一、修身：读书、抽烟减量、俯卧撑个跑步3公里二、齐家、劝说老爸与姑姑和好三、建功、业务洽谈【经典名句分享】1、依据原理原则追求事物的本质，以“作为人，何谓正确”进行判断2、经营者必须为员工物质和精神两方面的幸福殚精竭虑，倾尽全力，必须超脱私心，让
  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）... weixin_39762838 mac备份android手机通讯录导入iphone
    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
  • android 更改窗口的层次,浮窗开发之窗口层级 Ms.Bu android更改窗口的层次
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
  • 计算机木马详细编写思路 小熊同学哦 php开发语言木马木马思路
    导语：计算机木马（ComputerTrojan）是一种恶意软件，通过欺骗用户从而获取系统控制权限，给黑客打开系统后门的一种手段。虽然木马的存在给用户和系统带来严重的安全风险，但是了解它的工作原理与编写思路，对于我们提高防范意识、构建更健壮的网络安全体系具有重要意义。本篇博客将深入剖析计算机木马的详细编写思路，以及如何复杂化挑战，以期提高读者对计算机木马的认识和对抗能力。计算机木马的基本原理计算机木
  • 关于旗正规则引擎中的MD5加密问题 何必如此 jspMD5规则加密
    一般情况下，为了防止个人隐私的泄露，我们都会对用户登录密码进行加密，使数据库相应字段保存的是加密后的字符串，而非原始密码。 在旗正规则引擎中，通过外部调用，可以实现MD5的加密，具体步骤如下： 1.在对象库中选择外部调用，选择“com.flagleader.util.MD5”，在子选项中选择“com.flagleader.util.MD5.getMD5ofStr({arg1})”； 2.在规
  • 【Spark101】Scala Promise/Future在Spark中的应用 bit1129 Promise
    Promise和Future是Scala用于异步调用并实现结果汇集的并发原语，Scala的Future同JUC里面的Future接口含义相同，Promise理解起来就有些绕。等有时间了再仔细的研究下Promise和Future的语义以及应用场景，具体参见Scala在线文档：http://docs.scala-lang.org/sips/completed/futures-promises.html
  • spark sql 访问hive数据的配置详解 daizj spark sqlhivethriftserver
    spark sql 能够通过thriftserver 访问hive数据，默认spark编译的版本是不支持访问hive，因为hive依赖比较多，因此打的包中不包含hive和thriftserver,因此需要自己下载源码进行编译，将hive，thriftserver打包进去才能够访问，详细配置步骤如下：   1、下载源码   2、下载Maven,并配置 此配置简单，就略过
  • HTTP 协议通信 周凡杨 javahttpclienthttp通信
                            一：简介  HTTPCLIENT，通过JAVA基于HTTP协议进行点与点间的通信！     二： 代码举例      测试类： import java
  • java unix时间戳转换 g21121 java
    把java时间戳转换成unix时间戳： Timestamp appointTime=Timestamp.valueOf(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())) SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:m
  • web报表工具FineReport常用函数的用法总结（报表函数） 老A不折腾 web报表finereport总结
    说明：本次总结中，凡是以tableName或viewName作为参数因子的。函数在调用的时候均按照先从私有数据源中查找，然后再从公有数据源中查找的顺序。   CLASS CLASS(object):返回object对象的所属的类。   CNMONEY CNMONEY(number,unit)返回人民币大写。 number:需要转换的数值型的数。 unit:单位，
  • java jni调用c++ 代码 报错 墙头上一根草 javaC++jni
    # # A fatal error has been detected by the Java Runtime Environment: # #  EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x00000000777c3290, pid=5632, tid=6656 # # JRE version: Java(TM) SE Ru
  • Spring中事件处理de小技巧 aijuans springSpring 教程Spring 实例Spring 入门Spring3
    Spring 中提供一些Aware相关de接口，BeanFactoryAware、 ApplicationContextAware、ResourceLoaderAware、ServletContextAware等等，其中最常用到de匙ApplicationContextAware.实现ApplicationContextAwaredeBean，在Bean被初始后，将会被注入 Applicati
  • linux shell ls脚本样例 annan211 linuxlinux ls源码linux 源码
    #! /bin/sh - #查找输入文件的路径 #在查找路径下寻找一个或多个原始文件或文件模式 # 查找路径由特定的环境变量所定义 #标准输出所产生的结果 通常是查找路径下找到的每个文件的第一个实体的完整路径 # 或是filename :not found 的标准错误输出。 #如果文件没有找到 则退出码为0 #否则 即为找不到的文件个数 #语法 pathfind [--
  • List,Set,Map遍历方式 (收集的资源,值得看一下) 百合不是茶 listsetMap遍历方式
    List特点：元素有放入顺序，元素可重复 Map特点：元素按键值对存储，无放入顺序 Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的） List接口有三个实现类：LinkedList，ArrayList，Vector LinkedList：底层基于链表实现，链表内存是散乱的，每一个元素存储本身
  • 解决SimpleDateFormat的线程不安全问题的方法 bijian1013 javathread线程安全
    在Java项目中，我们通常会自己写一个DateUtil类，处理日期和字符串的转换，如下所示： public class DateUtil01 { private SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); public void format(Date d
  • http请求测试实例（采用fastjson解析） bijian1013 http测试
            在实际开发中，我们经常会去做http请求的开发，下面则是如何请求的单元测试小实例，仅供参考。 import java.util.HashMap; import java.util.Map; import org.apache.commons.httpclient.HttpClient; import
  • 【RPC框架Hessian三】Hessian 异常处理 bit1129 hessian
    RPC异常处理概述   RPC异常处理指是，当客户端调用远端的服务，如果服务执行过程中发生异常，这个异常能否序列到客户端？   如果服务在执行过程中可能发生异常，那么在服务接口的声明中，就该声明该接口可能抛出的异常。   在Hessian中，服务器端发生异常，可以将异常信息从服务器端序列化到客户端，因为Exception本身是实现了Serializable的
  • 【日志分析】日志分析工具 bit1129 日志分析
    1. 网站日志实时分析工具 GoAccess http://www.vpsee.com/2014/02/a-real-time-web-log-analyzer-goaccess/ 2. 通过日志监控并收集 Java 应用程序性能数据(Perf4J) http://www.ibm.com/developerworks/cn/java/j-lo-logforperf/ 3.log.io 和
  • nginx优化加强战斗力及遇到的坑解决 ronin47 nginx 优化
    　　　先说遇到个坑，第一个是负载问题，这个问题与架构有关，由于我设计架构多了两层，结果导致会话负载只转向一个。解决这样的问题思路有两个：一是改变负载策略，二是更改架构设计。 　　　由于采用动静分离部署，而nginx又设计了静态，结果客户端去读nginx静态，访问量上来，页面加载很慢。解决：二者留其一。最好是保留apache服务器。   　　　来以下优化：   　　　
  • java-50-输入两棵二叉树A和B，判断树B是不是A的子结构 bylijinnan java
    思路来自： http://zhedahht.blog.163.com/blog/static/25411174201011445550396/ import ljn.help.*; public class HasSubtree { /**Q50. * 输入两棵二叉树A和B，判断树B是不是A的子结构。 例如，下图中的两棵树A和B，由于A中有一部分子树的结构和B是一
  • mongoDB 备份与恢复 开窍的石头 mongDB备份与恢复
    Mongodb导出与导入 1: 导入/导出可以操作的是本地的mongodb服务器,也可以是远程的. 所以,都有如下通用选项: -h host   主机 --port port    端口 -u username 用户名 -p passwd   密码 2: mongoexport 导出json格式的文件
  • [网络与通讯]椭圆轨道计算的一些问题 comsci 网络
         如果按照中国古代农历的历法，现在应该是某个季节的开始，但是由于农历历法是3000年前的天文观测数据，如果按照现在的天文学记录来进行修正的话，这个季节已经过去一段时间了。。。。。       也就是说，还要再等3000年。才有机会了，太阳系的行星的椭圆轨道受到外来天体的干扰，轨道次序发生了变
  • 软件专利如何申请 cuiyadll 软件专利申请
    软件技术可以申请软件著作权以保护软件源代码，也可以申请发明专利以保护软件流程中的步骤执行方式。专利保护的是软件解决问题的思想，而软件著作权保护的是软件代码（即软件思想的表达形式）。例如，离线传送文件，那发明专利保护是如何实现离线传送文件。基于相同的软件思想，但实现离线传送的程序代码有千千万万种，每种代码都可以享有各自的软件著作权。申请一个软件发明专利的代理费大概需要5000-8000申请发明专利可
  • Android学习笔记 darrenzhu android
    1.启动一个AVD 2.命令行运行adb shell可连接到AVD,这也就是命令行客户端 3.如何启动一个程序   am start -n package name/.activityName   am start -n com.example.helloworld/.MainActivity 启动Android设置工具的命令如下所示： # am start -
  • apache虚拟机配置，本地多域名访问本地网站 dcj3sjt126com apache
    现在假定你有两个目录，一个存在于 /htdocs/a，另一个存在于 /htdocs/b 。 现在你想要在本地测试的时候访问 www.freeman.com 对应的目录是 /xampp/htdocs/freeman ,访问 www.duchengjiu.com 对应的目录是 /htdocs/duchengjiu。 1、首先修改C盘WINDOWS\system32\drivers\etc目录下的
  • yii2 restful web服务[速率限制] dcj3sjt126com PHPyii2
    速率限制 为防止滥用，你应该考虑增加速率限制到您的API。 例如，您可以限制每个用户的API的使用是在10分钟内最多100次的API调用。 如果一个用户同一个时间段内太多的请求被接收， 将返回响应状态代码 429 (这意味着过多的请求)。 要启用速率限制, [[yii\web\User::identityClass|user identity class]] 应该实现 [[yii\filter
  • Hadoop2.5.2安装——单机模式 eksliang hadoophadoop单机部署
    转载请出自出处：http://eksliang.iteye.com/blog/2185414 一、概述        Hadoop有三种模式 单机模式、伪分布模式和完全分布模式，这里先简单介绍单机模式 ，默认情况下，Hadoop被配置成一个非分布式模式，独立运行JAVA进程，适合开始做调试工作。   二、下载地址 Hadoop 网址http:
  • LoadMoreListView+SwipeRefreshLayout（分页下拉）基本结构 gundumw100 android
    一切为了快速迭代 import java.util.ArrayList; import org.json.JSONObject; import android.animation.ObjectAnimator; import android.os.Bundle; import android.support.v4.widget.SwipeRefreshLayo
  • 三道简单的前端HTML/CSS题目 ini htmlWeb前端css题目
    使用CSS为多个网页进行相同风格的布局和外观设置时，为了方便对这些网页进行修改，最好使用（ ）。http://hovertree.com/shortanswer/bjae/7bd72acca3206862.htm   在HTML中加入<table style=”color:red; font-size:10pt”>，此为（ ）。http://hovertree.com/s
  • overrided方法编译错误 kane_xie override
    问题描述： 在实现类中的某一或某几个Override方法发生编译错误如下： Name clash: The method put(String) of type XXXServiceImpl has the same erasure as put(String) of type XXXService but does not override it   当去掉@Over
  • Java中使用代理IP获取网址内容（防IP被封，做数据爬虫） mcj8089 免费代理IP代理IP数据爬虫JAVA设置代理IP爬虫封IP
    推荐两个代理IP网站：   1. 全网代理IP：http://proxy.goubanjia.com/   2. 敲代码免费IP：http://ip.qiaodm.com/   Java语言有两种方式使用代理IP访问网址并获取内容，   方式一，设置System系统属性   // 设置代理IP System.getProper
  • Nodejs Express 报错之 listen EADDRINUSE qiaolevip 每天进步一点点学习永无止境nodejs纵观千象
    当你启动 nodejs服务报错： >node app Express server listening on port 80 events.js:85 throw er; // Unhandled 'error' event ^ Error: listen EADDRINUSE at exports._errnoException (
  • C++中三种new的用法 _荆棘鸟_ C++new
    转载自：http://news.ccidnet.com/art/32855/20100713/2114025_1.html 作者: mt 其一是new operator，也叫new表达式；其二是operator new，也叫new操作符。这两个英文名称起的也太绝了，很容易搞混，那就记中文名称吧。new表达式比较常见，也最常用，例如： string* ps = new string("
  • Ruby深入研究笔记1 wudixiaotie Ruby
    module是可以定义private方法的 module MTest def aaa puts "aaa" private_method end private def private_method puts "this is private_method" end end
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他