Interface Retorno de chamada
O ouvinte usa essencialmente o mecanismo de retorno de chamada para executar parte de nosso próprio código antes ou depois que uma ação ocorre. Na linguagem Java, as interfaces podem ser usadas.
Implementar um caso de ouvinte
Por conveniência, defina diretamente no ambiente da primavera: tome o trabalho como um exemplo para definir o ouvinte no início (ou no final) do trabalho.
1. Defina a interface para o retorno de chamada
pacote com.yawn.demo.listener;/** * @author criado por bocejo em 2018-01-21 13:53 */interface pública Listener {void OnStart (nome da string);}2. Defina a ação
pacote com.yawn.demo.service; importar com.yawn.demo.listener.workListener;/** * @author criado por bocejo em 2018-01-21 13:39 */ @ServicePublic Class MyService {@Resource Private Persenservice Persenservice; ouvinte privado de listener; public void setWorkListener (WorkListener Worklistener) {this.Listener = WorkListener; } public void trabalho (nome da string) {listener.onstart (nome); persenservice.work (); }}O trabalho de ação é um método específico. No momento apropriado do método work (), a interface definida acima é chamada. Além disso, nesta classe de definição de ação, é necessário melhorar o método de definir o ouvinte.
3. Ouça o teste
@Runwith (springrunner.class) @springboottestPublic Classe DemospringannotationApplicationTests {@Resource Private MyService myService; @Test public void test1 () {// Configurações de interface ouvinte myService.setworkListener (new WorkListener () {@Override public void OnStart (Nome da String) {System.out.println ("Inicie o trabalho para" Nome + "!");}}); System.out.println ("Inicie o trabalho para" + nome + "!")); // trabalha myService.work ("Boss"); } @Test public void test2 () {// herde a classe de implementação para definir o ouvinte myService.setworkListener (new MyWorkListener ()); // trabalha myService.work ("Boss"); } classe MyWorkListener estende o WorkListeneRadaptor {@Override public void OnStart (Nome da String) {System.out.println ("Inicie o trabalho para" + nome + "!"); }}}Usando os dois métodos acima para testar, os resultados foram obtidos:
Comece a trabalhar para o chefe! Trabalhando duro ...
Isso mostra que, antes que o trabalho de ação ocorra, o código de escuta que escrevemos na classe de teste é executado para alcançar o objetivo da escuta de classe.
Implementando o ouvinte com anotações
No código acima, chamando o método SetWorkListener (Listener Worklistener) geralmente é chamado de Setting (Register) ouvinte, que é para definir o código de escuta que você escreveu como ouvinte de ação. No entanto, toda vez que você registra um ouvinte, geralmente precisa escrever uma classe para implementar uma interface definida ou herdar a classe que implementa a interface e, em seguida, reescreva o método de definição de interface. Portanto, os programadores inteligentes queriam simplificar esse processo, então eles criaram uma maneira de usar anotações. Usando anotações, escreva o segmento de código de escuta em um método e use a anotação para marcar esse método.
De fato, o uso se tornou simples, mas a implementação não é necessariamente verdadeira.
1. Defina uma anotação
pacote com.yawn.demo.anno; @target (elementType.method) @retention (retentionpolicy.runtime) public @interface worklistener {}2. Anotações analíticas
pacote com.yawn.demo.anno; importação com.yawn.demo.service.myService; importar org.springframework.beans.beansception; importação org.springframework.bean.facty.initializingBean; import org.springFramework.Contet.Apclication.Aplication.InitializingBean; importância org.springframework.context.ApplicationContexTAWare; importar org.springframework.stereotype.component; importar javax.annotation.resource; import java.lang.annotation.annotation; importação; * @author criado por bocejo em 2018-01-21 14:46 */ @ComponentPublic Classe WorklistenerParser implementa ApplicationContexTAWe, inicializandoBean {@Resource Private MyService MyService; ApplicationContext ApplicationContext privado; @Override public void depoisPropertiESSET () lança exceção {map <string, object> luterBeans = getExpectListenerbeans (controller.class, RestController.class, Service.class, component.class); para (ouvinte de objetos: ouvintes.Values ()) {for (método método: listener.getClass (). getDecLaredMethods ()) {if (! method.isannotationPresent (worklistener.class)) {continuação; } myService.setworkListener (nome -> {try {method.invoke (ouvinte, nome);} catch (exceção e) {e.printStacktrace ();}}); }}}} / ** * Encontre feijões que sejam possíveis para usar anotações * @param anoTationTypes Tipo de anotação de nível de classe que precisa ser digitalizado * @return mapa do feijão Scanned * / private map <string, objeto> getExpectListenerBeans (classMends AnnOtation> ... anotationTypes) {getSejet> object <pinEn; para (classe <? Extende anotação> AnotationType: AnotationTypes) {map <string, object> anotatedBeansMap = ApplicationContext.getBeanswithannotation (AnnotationType); ouvintes.putall (anotatedbeansmap); } retornar ouvintes; } @Override public void setApplicationContext (ApplicationContext ApplicationContext) lança beansexception {this.applicationContext = ApplicationContext; }}Durante a análise da anotação, configure o ouvinte.
Na classe Parsing, a interface ApplicationContextAware é implementada. Para obter a referência ao ApplicationContext na classe, ele é usado para obter o feijão no contêiner do IOC; e a implementação da interface InitializingBean é implementada para executar o código de análise de anotações e definir o ouvinte em um momento adequado. Se você não fizer isso, poderá ligar para o código analisado e definido quando o CommandLinerunner for executado, e o ApplicationContext também poderá ser injetado automaticamente.
3. Teste
Depois de executar o código acima, o ouvinte já está configurado e pode ser testado.
pacote com.yawn.demo.controller; importar com.yawn.demo.anno.workListener; importar com.yawn.demo.service.myService; importar org.springframework.web.bind.annotation.getMapping; importação.springFramework.webind.bind.anotation.getMappation; importação.springFramework.web.bind.bind.notation.getMappation; javax.annotation.resource;/** * @Author criado por Yawn em 2018-01-21 13:28 */ @RestControllerPublic Classe testController {@Resource Private MyService MyService; @GetMapping ("/work") public Object Work () {myService.work ("Boss"); retornar "feito"; } @WorkListener public void Listen (nome da string) {System.out.println ("Comece a trabalhar para" + nome + "!"); }}Escreva um método de monitoramento, o tipo de parâmetro e o número são os mesmos da interface e adicione anotações personalizadas. Depois que o ambiente é iniciado, o ouvinte já está definido.
Em seguida, chame o método work () de MyService através do URL e você poderá ver o resultado:
Comece a trabalhar para o chefe! Trabalhando duro ...
O método de escuta foi chamado. No próximo desenvolvimento, você pode usar esta anotação para registrar o ouvinte.
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.