Couteau à beurre et à poignard contre Android Annotations
J'évalue les cadres d'injection de dépendance (DI) pour un Android app. Les principaux candidats sont: Dagger (avec Butter Knife) et Android Annotations. Je comprends que Dagger et ButterKnife proviennent de la même source et se complètent. Voici les matrices clés que je recherche:
- Facilité d'utilisation (notre version est basée sur Gradle et nous utilisons Android Studio IDE)
- Assistance aux tests (nous utilisons Robotium pour les tests fonctionnels et RoboLectric pour les tests unitaires)
- Performance (les frameworks DI utilisent la réflexion, lequel est le plus rapide?)
AndroidAnnotations
utilise le traitement des annotations lors de la compilation. Il génère une sous-classe avec un trait de soulignement ajouté au nom d'origine (MyActivity_ Généré à partir de MyActivity). Donc, pour que cela fonctionne, vous devez toujours utiliser la classe générée pour les références au lieu de votre classe d'origine.
Il possède un ensemble de fonctionnalités très riche, voir le liste des annotations disponibles .
Butterknife
utilise également le traitement des annotations de compilation, mais génère des classes du Finder utilisées par une classe centrale (ButterKnife). Cela signifie que vous pouvez utiliser votre classe d'origine pour le référencement, mais vous devez appeler l'injection manuellement. Une copie de l'introduction de ButterKnife:
@Override public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.simple_activity);
ButterKnife.inject(this);
// TODO Use "injected" views...
}
ButterKnife prend en charge l’injection de vues (l’équivalent pour AndroidAnnotations serait @ViewById Et @ViewsById) Et certaines liaisons d’événements (pour une liste complète, voir le répertoire des espaces de noms ici , il suffit de compter les annotations d'événement OnXXX).
Dague
est une implémentation de DI pour Android, similaire à Guice. Il utilise également le traitement des annotations à la compilation et génère des graphiques d'objet que vous utilisez pour l'injection manuelle. Vous faites la distinction entre un graphe d'objet d'application et un graphe d'objet délimité pour l'injection par exemple. dans les activités. Vous voyez ici un exemple Application.onCreate:
@Override public void onCreate() {
super.onCreate();
objectGraph = ObjectGraph.create(getModules().toArray());
objectGraph.inject(this);
// use injected classes
}
J'ai trouvé qu'il est plus difficile de commencer avec une dague, mais ce n'est peut-être que mon expérience. Cependant, regardez quelques vidéos ici pour un meilleur départ: 1 , 2
Du point de vue des fonctionnalités, je dirais que Dagger implémente des fonctionnalités qui pourraient être comparées aux fonctionnalités @EBean Et @Bean D'AndroidAnnotation.
Résumé
Si vous comparez la facilité d'utilisation, le support technique et les performances, je ne trouve pas la différence entre utiliser AndroidAnnotation et ButterKnife + Dagger. Les différences se trouvent dans le modèle de programmation (utilisez les classes avec _ Au lieu d'utiliser celles d'origine et appelez l'injection manuellement) et dans le jeu de fonctions.
AndroidAnnotation vous donne une liste complète de fonctionnalités, mais vous lie à certaines bibliothèques. Par exemple, si vous utilisez son api de repos, vous devez utiliser Spring Android. Vous avez également des annotations pour des fonctionnalités comme OrmLite (@OrmLiteDao), Que vous utilisiez OrmLite ou non.
À la fin, c'est une question de goût, du moins à mon avis.
Voici l'article de Nice dans blog Dzone .
Nous devons comparer les caractéristiques de chacun, telles que:
- Bocaux minimum requis
- Compatibilité ActionBarSherlock
- Injection pour les auditeurs de clic
- Injection de POJO
- Performance
Il ne manque que Pojo Injection dans butterknife! On dirait que Butterknife est le gagnant!
Google demande spécifiquement de ne pas utiliser l'injection de dépendance.
Mais en lisant leur demande, ils semblent faire davantage référence aux bibliothèques DI Guice et à réflexion. Des bibliothèques telles que Android les annotations n’utilisent pas de réflexion mais utilisent du code généré par la compilation, tandis que butterknife et dagger utilisent une petite quantité de réflexion optimisée pour Android mais sont censés être légèrement plus puissants que Android annotation. Cela dépend vraiment du projet et du niveau de performance que vous êtes prêt à accepter. À mon avis, le simple fait d'utiliser butterknife suffit à accélérer le développement du code. Si vous avez besoin d’un peu plus d’utilisation, Android annotation et enfin si vous êtes prêt à subir un léger impact sur les performances en raison de la réflexion, la meilleure option sans détruire absolument les performances avec une réflexion basée sur la puissance Guice utilise dagger + butterknife.
Vous devriez essayer à cure-dent .
Le cure-dent est (selon le fichier README):
- java pur
- rapide, il n'utilise pas de réflexion mais de traitement d'annotation
- simple, flexible, extensible et puissant, robuste et testé
- fil sécuritaire
- documenté & Open Source
- scope safe: il applique des applications sans fuites
- orienté test: cela facilite les tests
- cela fonctionne très bien avec Android ou tout autre framework basé sur le contexte (comme les conteneurs web)
Cela peut même être plus rapide que Dagger 2 dans la plupart des cas, et c'est beaucoup plus simple.
Note: Oui, je suis l'un des auteurs.
Utilisez Android Annotations ou Butterknife pour faciliter votre codage. Mais n’allez pas pour Roboguice! Roboguice force vos activités, des fragments à s’étendre à des classes de roboguice. Ce n’est pas amusant du tout!
Dague 2 est une bien meilleure option. Vous pouvez l'utiliser avec Android Annotations si vous le souhaitez. Je voudrais simplement utiliser Android Annotations pour une application simple, mais ces jours-ci sont bons au travail plus avec Dague.
Le reddit-thread mentionné par @ChrLipp a quelqu'un qui a utilisé tous les trois sur le même projet , parle hautement de dagger + butterknife mais donne également à AndroidAnnotations sa place:
Butterknife est utilisé pour les vues, Dagger est recommandé pour tous les objets et est vivement recommandé. Android Annotations crée davantage de cadre de développement Android à la place d’injecter des objets dans vos classes afin que chaque bibliothèque soit assez différente. Dagger équivaut à Guice mais est beaucoup plus rapide. Dagger est plus puissant que ButterKnife et Android Annotations car il injecte tous les objets plutôt que ButterKnife et Android Annotations qui n'injectent qu'un certain ensemble d'objets.
La dague peut être difficile à installer et à configurer, mais en vaut la peine une fois que vous l’avez terminée. Mais là encore, comme ils sont tous très différents les uns des autres, tout dépend de vos besoins pour le projet.
De plus, en parlant de chacun d’eux très différents, dans votre projet, vous pouvez utiliser ButterKnife, Android Annotations et Dagger, tous dans le même projet, si vous le souhaitez vraiment. Ils ont tous la même idée mais quelque chose de différent pour que vous puissiez tous les utiliser.
On dirait que Google choisit poignard, comme ils le développent conjointement avec Square , qui l'a créé.
En ce qui concerne Butterknife et Dagger eux-mêmes, il existe la SO question différence entre Dagger-et-butterknife-Android ) qui précise comment ils se complètent.
Finalement, si vous utilisez l'un des trois, vous aurez du mal à passer à la liaison de données d'Android. C'est ce qui est le plus rapide si vous devez prendre en compte les performances:
Je pense que le meilleur entre (en termes de performance) ButterKnife et AndroidAnnotation est le second. ButterKnife utilise l'annotation au moment de la compilation (RetentionPolicy.CLASS), mais injecte du code au moment de l'exécution, d'où un effort de temps plus important. Au lieu de cela, AndroidAnnotations, traite toutes les annotations au moment de la compilation.