Programowanie sterowane zdarzeniami

Programowanie sterowane zdarzeniami jest metodologią tworzenia programów, określającą sposób przekazywania sterowania między podszczególnymi modułami tej samej aplikacji (bądź między różnymi aplikacjami). Rozwiązanie to stosuje się w środowiskach wieloprocesowych i pseudowieloprocesowych i ma ma ono zapewnić możliwość jednoczesnej pracy wielu programów w jednej instancji systemu operacyjnego. Polega na przechodzeniu do wykonywania poszczególnych bloków asynchronicznie (niezależnie od czasu jaki upłynął od zakończenia pracy poprzedniego modułu). Ten sposób tworzenia programów jest silnie powiązany z graficznymi środowiskami systemów operacyjnych i z programowaniem obiektowym. Naturalne jest więc to, że Java udostępnia ten mechanizm. Moja książka poświęca temu problemowi cały rozdział, z którego fragmentem możesz się zapoznać.

Książka: Programowanie sterowane zdarzeniami.

Marek Wierzbicki

Rozdział 4

W jednoprocesowych środowiskach programowania (na przykład takich jak stary, poczciwy DOS) w jednej chwili w komputerze mógł pracować tylko jeden program. Sterowanie działaniem takiego programu odbywało się bądź poprzez jawne zadeklarowanie kolejności działania (w programie jednoprzebiegowym), bądź poprzez pętlę obsługi wyboru opcji (w programie interaktywnym). Na listingu 4.1 pokazuję przykładowy fragment decyzyjny (zapisany w pseudokodzie), który realizuje ten drugi sposób sterowania programem poprzez przemieszczanie się po prostym menu i wybór jego opcji z użyciem klawisza Enter.

Listing 4.1. Sterowanie programem według starego stylu zapisanego w pseudokodzie

PoczątekProgramu
WyświetlMenu(
  "1.Faktura",
  "2.Dodaj klienta",
  "3.Indeksacja bazy",
  "4.Koniec pracy")
AktywnaOpcja=1
PowtarzajPętlę:
  PodświetlMenu(AktywnaOpcja)
  PobierzDaneZKlawiatury(Znak)
  Jeżeli (Znak=Enter)
  wtedy WybierzAkcję(AktywnaOpcja):
    1: WystawFakturę
    2: DodajNowegoKlienta
    3: IndeksujBazęDanych
    4: PrzerwijPętlę
  KoniecWyboruAkcji
  Jeżeli (Znak=(Strzałka, Home, End, PgUp, PgDn)) 
  wtedy ZmieńAktywnąOpcję(AktywnaOpcja, Znak)
KoniecPętli
KoniecProgramu

Pętla z listingu 4.1 była powtarzana tak długo, aż użytkownik wybrał opcję zakończenia programu. Wyjście z pętli było równoznaczne z końcem pracy.

4.1. Zarys nowej idei

W miarę rozwoju środowisk pseudowieloprocesowych, a następnie prawdziwych wieloprocesowych, stary sposób obsługi interaktywności przestał się sprawdzać. W jednej chwili w systemie mogło pracować wiele różnych programów bądź procesów. Twórcy systemów nie mogli sobie pozwolić na całkowite przejęcie kontroli nad systemem w taki sposób, by inne programy nic nie mogły robić. W związku z tym zaczęły pojawiać się pomysły na zdarzeniowe sterowanie programami. Idea tego rozwiązania była zupełnie inna od dotychczas stosowanej. Pętla odbierająca zdarzenia od klawiatury i myszy (które pozwalały użytkownikowi komunikować się z programem) była tworzona tylko w jednym egzemplarzu dla całego systemu operacyjnego. Obsługą tej pętli też zajmował się system. Wszystkie procedury reakcji na zdarzenia nie były już od tej chwili wywoływane jawnie w każdym programie. Zamiast tego tworzone były w nim delegacje do obsługi odpowiednich zdarzeń. Przykładowo program z listingu 4.1 w pseudokodzie można by zapisać w sposób pokazany na listingu 4.2.

Listing 4.2. Sterowanie programem według nowego stylu zapisanego w pseudokodzie

PoczątekProgramu
ZaładujProceduryObsługiZdarzeńDoPamięci(
  WystawFakturę,
  DodajNowegoKlienta,
  IndeksujBazęDanych)
DodajDoSystemuMenu(
  "1.Faktura",
  "2.Dodaj klienta",
  "3.Indeksacja bazy",
  "4.Koniec pracy")
ZdefiniujPrzypisanieZdarzeńDoProcedur(
  NaZdarzenie WybranoOpcjęFaktura reaguj:

  WystawFakturę
  NaZdarzenie WybranoOpcjęDodajKlienta reaguj:
  DodajNowegoKlienta
  NaZdarzenie WybranoOpcjęReindeksacja reaguj:
  IndeksujBazęDanych
  NaZdarzenie WybranoOpcjęKoniecPracy reaguj:

  (UsuńZPamięciProceduryObsługiZdarzeń,
  UsuńDefinicjePrzypisaniaObsługiZdarzeńTegoProgramu,
  PrzekażSterowanieSystemowiOperacyjnemu)
)
PrzekażSterowanieSystemowiOperacyjnemu
KoniecProgramu

Analiza listingu 4.2 ujawnia kilka znaczących różnic między "starą" pętlą obsługi zdarzeń a programowaniem sterowanym zdarzeniowo, oto one:

• Nie występuje (w sposób jawny) pętla obsługi zdarzeń.
• Rozdział zdarzeń scedowano na system operacyjny.
• Konwersja zdarzeń z poziomu sprzętu (pochodzących od urządzeń zewnętrznych takich jak klawiatura, mysz czy ekran dotykowy) na zdarzenia typu znaczeniowego (na przykład "wybrano opcję menu", "naciśnięto przycisk ekranowy" itd.).
• Obsługa menu (zmiana wyglądu i przejście między jego opcjami) jest wykonywana przez system operacyjny (również niejawnie).

Programowanie obiektowe zaczęło być popularne wraz z rozpowszechnieniem się środowisk graficznych (które miały charakter obiektowy, mimo iż często powstawały jeszcze w językach strukturalnych). Jednocześnie ze względu na możliwości środowiska próbowały one implementować wieloprocesowość. Nic więc dziwnego, że obie te metody tworzenia programów scaliły się ze sobą. Było to o tyle naturalne, że połączenie programowania obiektowego i sterowanego zdarzeniami znacznie podniosło walory obu tych technik. Zamiast uruchamiać jakieś procedury na podstawie zdarzenia, lepiej przesyłać go do konkretnego obiektu - niech on obsłuży je sobie na własnym podwórku. System zyskiwał na tym większą swobodę działania. Nie musiał decydować o tym, jaką procedurę wykonać po naciśnięciu przycisku ekranowego 1, a jaką po 2. Odsyłał do obiektu - okna zdarzenie "naciśnięto przycisk ekranowy (numer przycisku)" i był wolny. Programowanie obiektowe zyskiwało hermetyzację i bezpieczeństwo. System nie wtrącał się do tego, co obiekt robi z tym zdarzeniem. Obecnie nikt już nie wyobraża sobie innego sposobu sterowania programem obiektowym niż za pomocą zdarzeń. Nie należy się więc dziwić, że w języku Java, która jest nowoczesnym obiektowym językiem programowania, również wykorzystano takie rozwiązanie.