Devolución de llamada de interfaz
El oyente esencialmente usa el mecanismo de devolución de llamada para ejecutar parte de nuestro propio código antes o después de una acción. En el lenguaje Java, se pueden usar interfaces.
Implementar un caso de oyente
Por conveniencia, defina directamente en el entorno de primavera: tome el trabajo como ejemplo para definir al oyente al principio (o al final) del trabajo.
1. Defina la interfaz para la devolución de llamada
paquete com.yawn.demo.listener;/** * @author creado por Yawn en 2018-01-21 13:53 */Public Interface Worklistener {void onStart (nombre de cadena);}2. Defina la acción
paquete com.yawn.demo.service; import com.yawn.demo.listener.worklistener;/** * @author creado por Yawn en 2018-01-21 13:39 */ @ServicePublic Class myService {@Resource PERSONES PERSONSERVICE PERSONSERVICE; oyente de listas de trabajo privadas; public void setworkListener (Worklistener Worklistener) {this.listener = Worklistener; } Public void Work (name de cadena) {oyente.onstart (nombre); Personservice.work (); }}El trabajo de acción es un método específico. En el momento apropiado del método Work (), se llama a la interfaz definida anteriormente. Además, en esta clase de definición de acción, es necesario mejorar el método para configurar el oyente.
3. Escuche la prueba
@Runwith (springrunner.class) @springboottestpublic clase demospringannotationApplicationTests {@Resource MyService MyService myService; @Test public void test1 () {// Interface Configuración del oyente myService.SetWorkListener (new Worklistener () {@Override public void onStart (name de cadena) {System.Println ("Inicie el trabajo para" + nombre + ");}}}); // // Lambda Expression Subfision Listensings // MySecert. System.out.println ("Comience a trabajar para" + nombre + "!")); // trabajar myservice.work ("jefe"); } @Test public void test2 () {// heredar la clase de implementación para establecer el oyente myService.setworkListener (new MyWorkListener ()); // trabajar myservice.work ("jefe"); } clase MyWorkListener extiende WorklistenerAdaptor {@Override public void onStart (name de cadena) {System.out.println ("Comience a trabajar para" + nombre + "); }}}Usando los dos métodos anteriores para probar, se obtuvieron los resultados:
¡Empiece a trabajar para el jefe! Trabajando duro ...
Esto muestra que antes de que ocurra el trabajo de acción, el código de escucha que escribimos en la clase de prueba se ejecuta para lograr el propósito de la escucha de clase.
Implementación del oyente con anotaciones
En el código anterior, llamar al método SetWorkListener (Worklistener Listener) Generalmente se llama al oyente de configuración (Registro), que es establecer el código de escucha que escribió como un oyente de Action. Sin embargo, cada vez que registra un oyente, generalmente necesita escribir una clase para implementar una interfaz definida o heredar la clase que implementa la interfaz y luego reescribir el método de definición de interfaz. Por lo tanto, los programadores inteligentes querían simplificar este proceso, por lo que se les ocurrió una forma de usar anotaciones. Usando anotaciones, escriba el segmento de código de escucha en un método y use anotación para marcar este método.
De hecho, el uso se ha vuelto simple, pero la implementación no es necesariamente cierta.
1. Defina una anotación
paquete com.yawn.demo.anno; @Target (elementType.method) @Retention (retentionPolicy.runtime) public @Interface Worklistener {}2. Anotaciones analíticas
paquete com.yawn.demo.anno; import com.yawn.demo.service.myservice; import org.springframework.beans.beansexception; import org.springframework.beans.factory.inicializingbean; import org.springframwork.context.applicationcontext; import org. java.util.map;/** * @author creado por Yawn en 2018-01-21 14:46 */ @ComponentPublic LISTENERPARSER IMMILIMENTS AplicationContextAware, inicializando {@Resource Private MyService MyService myService; application privateContext ApplicationContext; @Override public void AfterPropertIesset () lanza la excepción {MAP <String, Object> LOYERBeans = getExpectListenerBeans (Controller.class, RestController.class, Service.class, Component.class); para (oyente de objetos: oyeurBeanss.values ()) {for (método método: oyente.getClass (). getDeclaredMethods ()) {if (! Method.isannotationPresent (Worklistener.class)) {continuar; } myService.SetWorkListener (name -> {try {método.invoke (oyente, name);} catch (Exception e) {E.PrintStackTrace ();}}); }}} Ial Linkedhashmap <> (); para (class <? Extiende Annotation> AnnotationType: AnnotationTypes) {MAP <String, Object> AnnotatedBeAnsMap = ApplicationContext.getBeAnswithAnnotation (AnnotationType); LOYERBeans.putall (AnnotatedBeAnsMap); } return listyerBeans; } @Override public void setApplicationContext (ApplicationContext ApplicationContext) lanza Beansexception {this.ApplicationContext = ApplicationContext; }}Durante el análisis de la anotación, configure el oyente.
En la clase de análisis, se implementa la interfaz ApplicationContextAware. Para obtener la referencia a ApplicationContext en la clase, se usa para obtener el frijol en el contenedor IOC; y la implementación de la interfaz InicializingBean se implementa para ejecutar el código de anotaciones de análisis y establecer al oyente en un momento adecuado. Si no hace esto, puede llamar al código analizado y establecer cuando se ejecuta CandenLinerUnner, y el ApplicationContext también se puede inyectar automáticamente.
3. Prueba
Después de ejecutar el código anterior, el oyente ya está configurado y puede ser probado.
paquete com.yawn.demo.controller; import com.yawn.demo.anno.worklistener; import com.yawn.demo.service.myservice; import org.springframework.web.bind.annotation.getmapping; import og.ssspingframework.web.bind.annotation javax.annotation.resource;/** * @author creado por Yawn en 2018-01-21 13:28 */ @RestControllerPublic TestController {@Resource Private MyService myService; @GetMapping ("/Work") Public Object Work () {MyService.Work ("Boss"); regresar "hecho"; } @WorkListener public void escuchar (nombre de cadena) {System.out.println ("Comience a trabajar para" + nombre + "!"); }}Escriba un método de monitoreo, el tipo de parámetro y el número son los mismos que la interfaz y luego agregan anotaciones personalizadas. Una vez que se inicia el medio ambiente, el oyente ya está configurado.
Luego llame al método Work () de MyService a través de URL y puede ver el resultado:
¡Empiece a trabajar para el jefe! Trabajando duro ...
Se ha llamado al método de escucha. En el próximo desarrollo, puede usar esta anotación para registrar el oyente.
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.