Qu'est-ce que «l'événement» du printemps?

Spring Framework peut générer des «événements» au milieu du service. En utilisant cela, le traitement peut être rendu "faiblement couplé", de sorte que le traitement du service peut être divisé en morceaux.

Cela fonctionne simplement en le prenant en sandwich entre les services, il semble donc être efficace pour la sortie de journal et les tendances du cache. Puisqu'il a une configuration indépendante, il est efficace lorsque vous souhaitez éviter que le traitement du service ne devienne long, ou lorsque vous souhaitez que quelqu'un d'autre crée certaines des fonctions.

Cette fois, au lieu d'implémenter les annotations implémentées à partir de Spring 4.3, nous allons le créer en implémentant l'interface et gorigori.

Débit jusqu'à ce que l'événement soit émis.

Créez votre propre événement
Créez un écouteur d'événements
Mettre en œuvre le service
Enregistrer les écouteurs d'événements et les services dans DI
Démarrez le service avec servlet!

1. Créez un événement.

Tout d'abord, créez une classe d'événements qui hérite de ** ApplicationEvent **. ** MyBeanEvent () ** dans ceci est exécuté.

`MyBeanEvent.java`


public class MyBeanEvent extends ApplicationEvent {

	public MyBeanEvent(Object source) {
		super(source);
		//Stub de constructeur généré automatiquement TODO
		System.out.println("Create MyBeanEvent");
	}

}

2. Créez un écouteur d'événements

Ensuite, créez un écouteur d'événements Tout ce que vous avez à faire est d'implémenter une interface appelée ** ApplicationListner **.

`MyBeanEventListener.java`


public class MyBeanEventListener implements ApplicationListener<MyBeanEvent> {

	@Override
	public void onApplicationEvent(MyBeanEvent event) {
		//TODO talon de méthode généré automatiquement
		System.out.println("Event Has Finished!!");
	}

}

Cet écouteur d'événements est toujours appelé après la fin de l'événement. Il peut être bon d'écrire un journal de fin

3. Créez un service.

Créez ensuite un ** service ** qui exécute l'événement. (Je vais omettre l'endroit pour enregistrer le bean dans DI!)

`MyBeanEventService.java`



public class MyBeanEventService implements ApplicationEventPublisherAware{

	@Autowired
	private MyBeanEve beanEve;
	private ApplicationEventPublisher publisher;
	
	@Override
	public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
		//TODO talon de méthode généré automatiquement
		this.publisher = applicationEventPublisher;
		System.out.println("publisher set!!");
		
	}
	
	public void doService(String message) {
		System.out.println("Service Started!");
		beanEve.addMessage(message);
		publisher.publishEvent(new MyBeanEvent(this));
	}

}

Ici, le traitement qui fonctionne réellement est la partie doService. Par ** setApplicationEventListenerPublisher ** Publiera un événement. publisher est une classe pratique qui publie des événements. Vous exécutez maintenant le traitement des événements.

4. Enregistrer les écouteurs d'événements et les services dans DI

Enfin, enregistrez l'écouteur d'événements et le service dans Java Config. Le Spring Framework est maintenant prêt à publier l'événement. (* ^ - ^ *)

`MyBeanEveConfig.java`


@Configuration
@ComponentScan(basePackages = "com.TsugaruInfo.bean")
public class MyBeanEveConfig {
	
	@Bean
	MyBeanEve myBean2() {
		return new MyBeanEve();
	}
	
	@Bean
	public MySampleApplicationListener addListener() {
		return new MySampleApplicationListener();
	}
	
	@Bean
	public MyBeanEventListener mybeanListener() {
		return new MyBeanEventListener();
	}
	
	@Bean
	public MyBeanEventService mybeanService() {
		return new MyBeanEventService();
	}
}

5. Démarrez le service avec servlet!

Enfin, exécutez le service sur le servlet ou le contrôleur. Cette fois, il est exécuté par une servlet. Cela peut ne pas fonctionner car je l'ai un peu changé (/ _;)

`MySampleServlet.java`


@WebServlet("/sample")
public class MySampleServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
	
	ApplicationContext app;
		
	@Autowired
	private MyBeanEventService myService;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public void init() throws ServletException{
        super.init();
        SpringBeanAutowiringSupport
        	.processInjectionBasedOnCurrentContext(this);
    }
    
	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		String message = request.getParameter("message");
		myService.doService(message);
		response.sendRedirect("sample");
	}

Courir

Intégrons ce servlet et démarrons le serveur.

Vous devriez voir les caractères ** jeu de l'éditeur !! ** imprimés sur la console. (Laisser les autres personnages C'est la preuve que le service est correctement enregistré dans DI.

Accédons-y un instant et déplaçons la méthode.

Des lettres sur la console ** Service → Événement → Écouteur d'événements ** Vous pouvez voir que cela fonctionne dans l'ordre de.

Résumé

Si vous l'utilisez correctement, vous pouvez effectuer le traitement que vous souhaitez utiliser avant le service, ce qui est une fonction pratique. Cependant, à cette fin, la conception du processus à diviser est très importante. ~~ Il vaut mieux informer l'équipe de la relation entre le service et l'événement (ry ~~

Pensez à votre design et faites une programmation Spring intelligente!

Ouvrage de référence Spring Framework 5 Introduction à la programmation https://www.amazon.co.jp/Spring-Framework-%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9%E3%83%9F%E3%83%B3%E3%82%B0%E5%85%A5%E9%96%80-%E6%8E%8C%E7%94%B0-%E6%B4%A5%E8%80%B6%E4%B9%83/dp/4798053740

[JAVA] Le traitement des événements est effectué au printemps.