Rappel d'interface
L'auditeur utilise essentiellement le mécanisme de rappel pour exécuter une partie de notre propre code avant ou après une action. En langue java, les interfaces peuvent être utilisées.
Mettre en œuvre un cas auditeur
Pour plus de commodité, définissez directement dans l'environnement du printemps: prenez le travail comme exemple pour définir l'auditeur au début (ou à la fin) de l'œuvre.
1. Définissez l'interface du rappel
Package com.yawn.demo.Listener; / ** * @author créé par Yawn le 2018-01-21 13:53 * / interface publique WorkListener {void OnStart (nom de chaîne);}2. Définissez l'action
package com.yawn.demo.service; import com.yawn.demo.listener.workListener; / ** * @author créé par Yawn le 2018-01-21 13:39 * / @ ServicePublic Class MyService {@Resource Private PersonService PersonService; Écouteur privé de WorkListener; public void setworkListener (workListener workListener) {this.Listener = workListener; } public void work (String name) {auditer.onstart (name); PersonService.Work (); }}Le travail d'action est une méthode spécifique. Au moment approprié de la méthode Work (), l'interface définie ci-dessus est appelée. De plus, dans cette classe de définition d'action, il est nécessaire d'améliorer la méthode de définition de l'auditeur.
3. Écoutez le test
@Runwith (springrunner.class) @springboottestpublic class DemospringannotationApplicationTests {@Resource private myService myService; @Test public void test1 () {// Paramètres d'interface Écouteur MyService.SetWorkListener (new WorkListener () {@Override public void onStart (String Name) {System.out.println ("Démarrer le travail pour" + nom + "!");}}); // // name System.out.println ("Démarrer le travail pour" + name + "!")); // fonctionne MyService.Work ("Boss"); } @Test public void test2 () {// Hériter de la classe d'implémentation pour définir l'écouteur myService.SetWorkListener (new MyWorkListener ()); // fonctionne MyService.Work ("Boss"); } classe MyWorkListener étend WorkListenerAdaptor {@Override public void onStart (String name) {System.out.println ("Démarrer le travail pour" + name + "!"); }}}En utilisant les deux méthodes ci-dessus pour tester, les résultats ont été obtenus:
Commencez à travailler pour Boss! Travailler dur ...
Cela montre qu'avant le travail d'action, le code d'écoute que nous avons écrit dans la classe de test est exécuté pour atteindre l'objectif de l'écoute des cours.
Implémentation de l'auditeur avec des annotations
Dans le code ci-dessus, l'appel de la méthode SetWorkListener (WorkListener Assember) est généralement appelé écouteur paramètres (registre), qui est de définir le code d'écoute que vous avez écrit en tant qu'auditeur d'action. Cependant, chaque fois que vous enregistrez un auditeur, vous devez généralement écrire une classe pour implémenter une interface définie ou hériter de la classe qui implémente l'interface, puis réécrire la méthode de définition de l'interface. Par conséquent, les programmeurs intelligents voulaient simplifier ce processus, ils ont donc trouvé un moyen d'utiliser des annotations. En utilisant des annotations, écrivez le segment de code d'écoute dans une méthode et utilisez l'annotation pour marquer cette méthode.
En effet, l'utilisation est devenue simple, mais la mise en œuvre n'est pas nécessairement vraie.
1. Définir une annotation
Package com.yawn.demo.anno; @target (elementType.Method) @retention (retenderPolicy.runtime) public @Interface WorkListener {}2. Annotations analytiques
package com.yawn.demo.anno; import com.yawn.demo.service.myservice; import org.springframework.beans.beansexception; import org.springframework.context.applicationContext; importation; importation; org.springframework.context.applicationContextAware; import org.springframework.sterreotype. @Author Créé par YAWN le 2018-01-21 14:46 * / @ ComponentPublic Class WorkListeLenerParser implémente ApplicationContextAware, InitializingBean {@Resource Private MyService MyService; application application privée applicationContext; @Override public void AfterProperTiESSET () lève une exception {map <string, object> edinerBeans = getExpectListenerBeans (Controller.class, restController.class, service.class, composant.class); for (objet écouteur: auditerbeans.values ()) {for (méthode Method: everner.getClass (). getDeclaredMethods ()) {if (! Method.isannotationPresent (workListener.class)) {continué; } myService.SetWorkListener (name -> {try {méthode.invoke (écouteur, nom);} catch (exception e) {e.printStackTrace ();}}); }}}} / ** * Trouvez des fèves qui sont possibles d'utiliser des annotations * @param annotationTypes type de classe de classe qui doit être numérisé * @return carte des beans * / carte privée <String, objet> getExpectlistlenerBeans (class <? Extende annotation> ... annotationtypes) {map <string, objet, un ouwnotation> Newsfor LinkedHashMap <> (); for (class <? étend annotation> annotationType: annotationTypes) {map <string, object> annotatedBeansMap = applicationContext.getBeanSwithannotation (annotationType); auditerbeans.putall (AnnotedBeansMap); } return audinerBeans; } @Override public void setApplicationContext (ApplicationContext ApplicationContext) lève BeanSException {this.ApplicationContext = applicationContext; }}Pendant l'analyse de l'annotation, créez l'auditeur.
Dans la classe d'analyse, l'interface applicationContextAware est implémentée. Afin d'obtenir la référence à ApplicationContext dans la classe, il est utilisé pour obtenir le bean dans le conteneur IOC; et l'implémentation de l'interface InitializingBean est implémentée pour exécuter le code d'annotations d'analyse et la définition de l'auditeur à un moment approprié. Si vous ne faites pas cela, vous pouvez appeler le code analysé et définir le code CommandLinerUnner, et l'applicationContext peut également être automatiquement injecté.
3. Test
Après avoir exécuté le code ci-dessus, l'auditeur est déjà configuré et peut être testé.
package com.yawn.demo.controller; import com.yawn.demo.anno.workListener; import com.yawn.demo.service.myservice; import org.springframework.web.bind.annotation.gestmapt javax.annotation.resource; / ** * @author créé par Yawn le 2018-01-21 13:28 * / @ RESTControllerPublic Class TestController {@Resource Private MyService MyService; @Getmapping ("/ work") public objet work () {myService.work ("boss"); retourner "fait"; } @WorkListener public void écouter (nom de chaîne) {System.out.println ("Démarrer le travail pour" + name + "!"); }}Écrivez une méthode de surveillance, le type et le nombre de paramètres sont les mêmes que l'interface, puis ajoutez des annotations personnalisées. Une fois l'environnement démarré, l'auditeur est déjà défini.
Ensuite, appelez la méthode Work () de MyService via URL et vous pouvez voir le résultat:
Commencez à travailler pour Boss! Travailler dur ...
La méthode d'écoute a été appelée. Dans le développement suivant, vous pouvez utiliser cette annotation pour enregistrer l'auditeur.
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.