Android Component Learning, 2021 octets Jumping Spring Recruitment Technology Interview Question

Mb61c1dbbb44788 2022-01-15 03:38:00 阅读数:616

android component learning octets jumping

Le soi - disant projet unique consiste à placer tous les composants sous un seul projet,Regardez d'abord le catalogue complet:

AndroidApprentissage par composantes,2021Questions d'entrevue sur les techniques de saut d'octets_Android

ps:module_ Le début représente l'élément de base,fun_ Le préfixe représente la composante de base de l'entreprise,biz_Préfixe pour les composants commerciaux,export_Le préfixe indique l'interface d'exposition des composants commerciaux.

Analyse des avantages et des inconvénients d'un seul projet:

  • Leigh.:Il suffit de compiler un module modifié,D'autres modules qui en dépendent peuvent immédiatement percevoir le changement.

  • Les inconvénients:N'a pas réussi à faire une séparation complète des tâches,Les développeurs de chaque module ont la permission de modifier d'autres modules.

Tout d'abord, gradle.properties Déclarer une variable dans le fichier:

// gradle.properties

isModule = true

Copier le Code

isModule Pour true Indique que le composant peut être utilisé comme apk En marche,false Indique que le composant ne peut être utilisé que comme library.On change cette valeur au besoin et on synchronisegradleC'est tout..

Et puis dans un module De build.gradle Cette variable est utilisée dans le fichier pour faire des jugements à trois endroits:

// build.gradle

// Différencier les applications des bibliothèques

if(isModule.toBoolean()) {

apply plugin: ‘com.android.application’

}else {

apply plugin: ‘com.android.library’

}

android {

defaultConfig {

// Si l'application doit être spécifiéeapplication

if(isModule.toBoolean()) {

applicationId “com.xxx.xxx”

}

}

sourceSets {

main {

// Applications et bibliothèquesAndroidManifestDocument Distinguishing

if(isModule.toBoolean()) {

manifest.srcFile ‘src/main/debug/AndroidManifest.xml’

}else {

manifest.srcFile ‘src/main/AndroidManifest.xml’

}

}

}

}

Parce quelibraryCe n'est pas nécessaire Application Et le démarrageActivity(En milliers de dollars des États - Unis),Donc nous devons distinguer ce fichier,ApplicationmanifestLe chemin spécifié n'est pas spécifique,N'hésitez pas à trouver un chemin pour créer.En applicationAndroidManifest.xmlOn va configurer la page de démarrage.:

<manifest xmlns:android=“ http://schemas.android.com/apk/res/android

package=“com.sun.biz_home”>

<application

android:allowBackup=“true”

android:label=“@string/home_app_name”

android:supportsRtl=“true”

android:theme=“@style/home_AppTheme”>

<activity android:name=“.debug.HomeActivity”>

<intent-filter>

<action android:name=“android.intent.action.MAIN” />

<category android:name=“android.intent.category.LAUNCHER” />

</intent-filter>

</activity>

</application>

</manifest>

library De AndroidManifest.xml Pas besoin de ça.:

<manifest xmlns:android=“ http://schemas.android.com/apk/res/android

package=“com.sun.biz_home”>

</manifest>

gradle Dépendance module Il y a deux façons principales:

  • implementation: A implementation B,B implementation C, Mais... A Impossible d'accéder C Quelque chose.

  • api:A api B,B api C,AAccèsCQuelque chose.

En général, nous avons juste besoin d'utiliser implementation C'est tout.,api Oui peut entraîner un temps de compilation plus long,Et introduit des fonctions qui ne sont pas nécessaires pour ce module,Le couplage entre les codes devient sérieux.Mais module_common Est une bibliothèque commune qui unifie les versions des composants sous - jacents,Tous les composants doivent en dépendre et avoir la capacité des composants sous - jacents,Donc, fondamentalement, chaque composante opérationnelle et composante de base opérationnelle devrait dépendre d'une bibliothèque commune:

dependencies {

implementation project(‘:module_common’)

}

Et common La composante dépendante de la composante de base devrait être utilisée pour api,Parce que la capacité de transférer la composante de base à la composante opérationnelle supérieure:

dependencies {

api project(‘:module_base’)

api project(‘:module_util’)

}

 Programme multi - ingénierie

Multi - ingénierie signifie que chaque composant est un projet,Par exemple, après avoir créé un projet app As Shell Assembly,Elle dépend biz_home Exécution,Il n'est donc pas nécessaire isModule Pour contrôler la mise en service indépendante,C'est un projet qui peut être débogué indépendamment.

Les avantages et les inconvénients de la multi - ingénierie sont l'opposé de la mono - ingénierie:

  • Leigh.:Faire en sorte que les responsabilités soient complètement séparées,D'autres projets sont plus faciles à réutiliser,Introduction directe d'une ligne de dépendance.

  • Les inconvénients:Les modifications doivent être téléchargées surmavenEntrepôt,D'autres projets sont recompilés avant que le changement ne soit perçu,Plus de temps pour télécharger et compiler.

Les dépendances de composants Multi - ingénierie nécessitentmavenEntrepôt.Mettez chaque composantaarTéléchargé sur l'intranet de l'entreprisemavenEntrepôt,Et puis compter comme ça:

implementation ‘com.xxx.xxx:module_common:1.0.0’

Nous pouvons construire unmavenL'entrepôt etaarTélécharger sur notre propremavenEntrepôt,Voici un article ConstructionmavenEntrepôt et téléchargementaarIntroduction.Attention,Nous utilisonssnapshotLa version Snapshot ne change pas le numéro de version télécharger,Dans la publicationreleaseAjouter un numéro de version à la version officielle et télécharger.

Nous avons unifié la Bibliothèque tripartite en config.gradle Gestion interne:

ext {

dependencies = [

“glide”: “com.github.bumptech.glide:glide:4.12.0”,

“glide-compiler”: “com.github.bumptech.glide:compiler:4.12.0”,

“okhttp3”: “com.squareup.okhttp3:okhttp:4.9.0”,

“retrofit”: “com.squareup.retrofit2:retrofit:2.9.0”,

“retrofit-converter-gson” : “com.squareup.retrofit2:converter-gson:2.9.0”,

“retrofit-adapter-rxjava2” : “com.squareup.retrofit2:adapter-rxjava2:2.9.0”,

“rxjava2”: “io.reactivex.rxjava2:rxjava:2.2.21”,

“arouter”: “com.alibaba:arouter-api:1.5.1”,

“arouter-compiler”: “com.alibaba:arouter-compiler:1.5.1”,

// our lib

“module_util”: “com.sun.module:module_util:1.0.0”,

“module_common”: “com.sun.module:module_common:1.0.0”,

“module_base”: “com.sun.module:module_base:1.0.0”,

“fun_splash”: “com.sun.fun:fun_splash:1.0.0”,

“fun_share”: “com.sun.fun:fun_share:1.0.0”,

“export_biz_home”: “com.sun.export:export_biz_home:1.0.0”,

“export_biz_me”: “com.sun.export:export_biz_me:1.0.0”,

“export_biz_msg”: “com.sun.export:export_biz_msg:1.0.0”,

“biz_home”: “com.sun.biz:biz_home:1.0.0”,

“biz_me”: “com.sun.biz:biz_me:1.0.0”,

“biz_msg”: “com.sun.biz:biz_msg:1.0.0”

]

}

Cela facilite la gestion unifiée des versions, Et dans le Répertoire racine build.gradle Importation interne:

apply from: ‘config.gradle’

Enfin, les dépendances sont introduites dans les modules respectifs,Comme dans module_common Il suffit d'introduire la dépendance.

dependencies {

api rootProject.ext.dependencies[“arouter”]

kapt rootProject.ext.dependencies[“arouter-compiler”]

api rootProject.ext.dependencies[“glide”]

api rootProject.ext.dependencies[“okhttp3”]

api rootProject.ext.dependencies[“retrofit”]

api rootProject.ext.dependencies[“retrofit-converter-gson”]

api rootProject.ext.dependencies[“retrofit-adapter-rxjava2”]

api rootProject.ext.dependencies[“rxjava2”]

api rootProject.ext.dependencies[“module_util”]

api rootProject.ext.dependencies[“module_base”]

}

Je pense que le multi - ingénierie convient"C'est énorme."Le projet de,Chaque composante opérationnelle peut nécessiter un développement de groupe,Comme Taobaoapp.Mais ce n'est que pour les composantes commerciales,La fréquence des modifications apportées aux composantes de base de l'entreprise et aux composantes de base ne sera pas importante,Il est préférable que tout soit téléchargé surmavenEntrepôt à utiliser.L'exemple de cet article est pour faciliter l'écriture de tous les composants ensemble,La meilleure façon est de fun_ Et module_ Les premiers composants sont divisés en un seul projet développé indépendamment,Les composantes opérationnelles sont écrites dans un projet.

 Saut de page


Après avoir terminé l'isolement entre les composants,Le problème le plus évident est celui du saut de page et de la communication de données.En général,Les sauts de page sont tous des affichagesstartActivitySaut,Ne s'applique pas dans le cadre d'un projet modulaire,Le saut implicite peut être utilisé,Mais chaqueActivityTout doit être écrit. intent-filter C'est un peu gênant,Donc la meilleure façon est d'utiliser le cadre de routage.

En fait, il existe déjà des cadres de routage plus matures conçus spécifiquement pour la componentisation,Comme celle de meituan WMRouter,Ali's ARouterAttendez.,Utilisé dans cet exemple ARouter Cadre,Regarde ça.ARouterFonctionnement de base du saut de page.

Il faut d'abord introduire la dépendance,Par module_common IntroductionARouterExemples,build.gradle Devrait être ajouté:

android {

defaultConfig {

javaCompileOptions {

annotationProcessorOptions {

arguments = [AROUTER_MODULE_NAME: project.getName()]

}

}

}

compileOptions {

sourceCompatibility JavaVersion.VERSION_1_8

targetCompatibility JavaVersion.VERSION_1_8

}

}

dependencies {

api rootProject.ext.dependencies[“arouter”]

kapt rootProject.ext.dependencies[“arouter-compiler”]

}

kaptLes dépendances d'annotation ne peuvent pas être transmises,Il est donc inévitable que nous devions déclarer ces configurations dans chaque module,Sauf que api rootProject.ext.dependencies["arouter"] Ça marche..Ensuite, un enregistrement global est nécessaire ARouter,Je suis là. module_common Enregistrement uniforme.

class AppCommon: BaseApp{

override fun onCreate(application: Application) {

MLog.d(TAG, “BaseApp AppCommon init”)

initARouter(application)

}

private fun initARouter(application: Application) {

if(BuildConfig.DEBUG) {

ARouter.openLog()

ARouter.openDebug()

}

ARouter.init(application)

}

}

Et puis nous sommes module_common Une table de routage est déclarée dans le module comme chemin de gestion unifié.

// RouterPath.kt

class RouterPath {

companion object {

const val APP_MAIN = “/app/MainActivity”

const val HOME_FRAGMENT = “/home/HomeFragment”

const val MSG_FRAGMENT = “/msg/MsgFragment”

const val ME_FRAGMENT = “/me/MeFragment”

const val MSG_PROVIDER = “/msg/MsgProviderImpl”

}

}

Et aprèsMainActivityAnnotation sur le fichier de classe:

@Route(path = RouterPath.APP_MAIN)

class MainActivity : AppCompatActivity() {

}

N'importe quel module n'a besoin que d'appeler ARouter.getInstance().build(RouterPath.APP_MAIN).navigation() Vous pouvez sauter.Si nous voulons ajouter le transfert de données est également pratique:

ARouter.getInstance().build(RouterPath.APP_MAIN)

.withString(“key”, “value”)

.withObject(“key1”, obj)

.navigation()

Et aprèsMainActivityAccepter les données en utilisant l'injection dépendante:

class MainActivity : AppCompatActivity() {

@Autowired

@JvmField

var key: String = “”

}

ARouter Essentiellement capable de répondre à tous les besoins de saut.

 Communication entre les composants


Il a déjà été mentionné que la communication des composants passe par”Dépendance indirecte“Découplé,C'est - à - dire qu'un troisième"Components"En tant qu'intergiciel.Si vous lisez cet article dans l'ordre,Vous verrez qu'il y a quelque chose dans le répertoire des projets export_ Module préfixé,Ce module expose en fait l'interface externe du composant,Comme le module page d'accueilbiz_homeCorrespondant"Interface de naufrage"Le module est export_biz_home,L'extérieur veut accéder à biz_home La fonctionnalité dépend uniquement de export_biz_home.Chacun de ces composants correspond à un"Interface de naufrage"Les composants semblent un peu redondants,Mais si le projet est important,C'est plus clair.Bien sûr, si le projet est plus petit,On pourrait envisager de regrouper toutes les interfaces exposées en une seule”Interface de naufrage“Components,C'est l'exemple de cet article module_base,Et puismodule_commonDépendancemodule_base,De cette façon, chaque module peut utiliser la fonction exposée de n'importe quel module,Si vous avez l'impression qu'il y a trop d'interfaces de naufrage ou si vous avez besoin de définir strictement chaque composant,Ce n'est donc pas recommandé.

Nous supposons maintenant que tout estexport_Déclaration de l'interface d'exposition externe,Le scénario est:Envoyer des valeurs du module Home au module message,Mon module peut obtenir des valeurs du module message.Voici deux façons de communiquer.

 ArouterProgramme

In export_biz_msg Déclaration sous composante IMsgProvider,Cette interface doit être implémentée IProvider Interface:

interface IMsgProvider: IProvider {

fun onCountFromHome(count: Int = 1)

}

Et après biz_msg Implémenter cette interface dans le composant:

@Route(path = RouterPath.MSG_PROVIDER)

class MsgProviderImpl: IMsgProvider {

override fun onCountFromHome(count: Int) {

// C'est juste une distribution de données,Les objets qui ont des comptes d'écoute recevront

MsgCount.instance.addCount(count)

}

override fun init(context: Context?) {

// Appelé lorsque l'objet est initialisé
《960Le plus complet du réseauAndroidNotes de développement》

AndroidApprentissage par composantes,2021Questions d'entrevue sur les techniques de saut d'octets_Développement mobile_02

《379(En milliers de dollars des États - Unis)AndroidDévelopper un dictionnaire d'entrevue》

AndroidApprentissage par composantes,2021Questions d'entrevue sur les techniques de saut d'octets_Programmeur_03

《507(En milliers de dollars des États - Unis)AndroidAnalyse des sources liées au développement》

AndroidApprentissage par composantes,2021Questions d'entrevue sur les techniques de saut d'octets_Développement mobile_04

Parce qu'il y a trop de fichiers,Toute la présentation affectera l'espace,Pour l'instant, énumérez ces captures d'écran partielles,Tout le monde peut** Cliquez ici**Prenez - le vous - même.

版权声明:本文为[Mb61c1dbbb44788]所创,转载请带上原文链接,感谢。 https://javamana.com/2022/01/202201150337588755.html