Управлявана от събития архитектура е подход към дизайна и архитектурата на софтуера, който набляга на използването на събития за задействане и комуникация между различни компоненти на система.

В тази архитектура компонентите в системата са отделени и комуникират чрез асинхронни събития, а не чрез извиквания на синхронни методи. Когато възникне събитие, то се публикува на автобус за събития или брокер, който след това доставя събитието на всички заинтересовани слушатели или абонати.

Основните компоненти на управляваната от събития архитектура са:

  1. Източник на събитие/издател: Компонентът, който генерира събитието.
  2. Събитие: Съобщението, което представлява събитието.
  3. Event Bus/Broker: Механизмът, който получава събития и ги доставя на заинтересовани слушатели или абонати.
  4. Слушател на събития/Абонат: Компонентът, който получава и обработва събитието.

Основното предимство на управляваната от събития архитектура е, че тя позволява на компонентите да бъдат слабо свързани, което означава, че те могат да бъдат разработени, внедрени и мащабирани независимо. В допълнение, той осигурява по-гъвкава и устойчива система, тъй като компонентите могат да реагират на промените в околната среда чрез обработка на събитията, които получават.

Нека разберем това като използваме пример:

Да кажем, че имаме система, в която получаваме данни от външно приложение, трябва да вземем тези данни, да ги анализираме и съхраним в db, също така данните идват постоянно. Това е чудесен случай, когато тази архитектура може да бъде много полезна.

Тук ще използвам micronaut java framework (много подобен на spring boot за показване на кода)

  1. Дефиниране на класа на събитието Първата стъпка е да се определи класът на събитието, който ще съдържа входящите данни. В този случай можете да дефинирате прост клас събития, наречен DataReceivedEvent:
public class DataReceivedEvent {
    private final String data;
    public DataReceivedEvent(String data) {
        this.data = data;
    }
    public String getData() {
        return data;
    }
}
  1. Дефинирайте издателя на събития След това трябва да дефинирате издателя на събития, който ще изпрати DataReceivedEvent към шината на събитията. В този случай можете да създадете нов клас, наречен DataReceiver, който ще прочете входящите данни като низ, ще създаде нов DataReceivedEvent с данните и ще го публикува в шината на събитията:
import io.micronaut.context.event.ApplicationEventPublisher;
import javax.inject.Inject;
import javax.inject.Singleton;

@Singleton
public class DataReceiver {
    @Inject
    private ApplicationEventPublisher eventPublisher;
    public void receiveData(String data) {
        DataReceivedEvent event = new DataReceivedEvent(data);
        eventPublisher.publishEvent(event);
    }
}

В примера по-горе ние инжектираме ApplicationEventPublisher и създаваме нов DataReceivedEvent с входящите данни. След това използваме метода publishEvent, за да изпратим събитието към шината за събития.

  1. Дефиниране на слушателя на събития След това трябва да дефинирате слушателя на събития, който ще получи DataReceivedEvent и ще анализира данните. За да направите това, създайте нов клас и използвайте анотацията @EventListener:
import io.micronaut.context.event.ApplicationEventListener;
import javax.inject.Singleton;

@Singleton
public class DataReceivedEventListener implements ApplicationEventListener<DataReceivedEvent> {
    @Override
    public void onApplicationEvent(DataReceivedEvent event) {
        // Parse the data and store it into the database
        String data = event.getData();
        // Do your parsing and database storing logic here
    }
}J

В примера по-горе внедряваме интерфейса ApplicationEventListener и посочваме типа на събитието като DataReceivedEvent. След това прилагаме метода onApplicationEvent и анализираме входящите данни и ги съхраняваме в базата данни.

В заключение, управляваната от събития архитектура е мощен подход за изграждане на мащабируеми, устойчиви и реактивни системи, които могат да обработват данни в реално време и да позволят бизнес гъвкавост и иновации. Чрез отделяне на производителите и потребителите на събития чрез шина за събития, приложенията могат да бъдат проектирани да обработват голям обем от събития, като същевременно поддържат слабо свързване, асинхронна комуникация и толерантност към грешки. Архитектурата, управлявана от събития, не е универсално решение, но може да предложи значителни предимства пред традиционните архитектури заявка-отговор, особено в области като IoT, стрийминг анализи, електронна търговия и финансови услуги. Тъй като управляваната от събития архитектура продължава да се развива, се появяват нови инструменти и рамки за опростяване на нейното внедряване и управление, което я прави по-достъпна за разработчици и фирми от всякакъв мащаб. За да останете конкурентоспособни в днешната забързана дигитална икономика, от съществено значение е да разгледате управляваната от събития архитектура като основен принцип на проектиране за вашия следващ проект.