Gweithredu'r Patrwm Gwyliwr yn Ruby

Mae'r patrwm gwyliwr (Observer Pattern) yn un o'r patrwmau dylunio mwyaf poblogaidd yn y byd datblygu meddalwedd. Mae'n caniatáu i unedau (neu 'gwyliwr') dderbyn gwybodaeth am newidiadau yn uned arall (neu 'gweithredwr') heb orfod cysylltu'n uniongyrchol â hi. Mae hyn yn creu cysylltiad rhydd rhwng y ddwy uned, gan ei gwneud yn haws i gynnal a datblygu'r cod. Yn yr erthygl hon, byddwn yn archwilio sut i weithredu'r patrwm gwyliwr yn Ruby, gan ddefnyddio enghreifftiau cod a chymhwysiadau ymarferol.

Beth yw'r Patrwm Gwyliwr?

Mae'r patrwm gwyliwr yn caniatáu i unedau (gwyliwr) dderbyn hysbysiadau pan fydd uned arall (gweithredwr) yn newid ei statws. Mae hyn yn arbennig o ddefnyddiol mewn achosion lle mae angen i sawl elfen o'r system ymateb i newidiadau yn uned benodol. Mae'r patrwm hwn yn cynnwys tri chydran bennaf:

Gweithredwr (Subject): Mae'n cynnal rhestr o'r gwyliwr a'i hysbysu pan fydd newid yn digwydd.
Gwyliwr (Observer): Mae'n cofrestru i dderbyn hysbysiadau gan y gweithredwr.
Hysbysiad (Notification): Mae'r gweithredwr yn hysbysu'r gwyliwr am newidiadau.

Camau i weithredu'r Patrwm Gwyliwr yn Ruby

Yn y rhan hon, byddwn yn edrych ar sut i greu gweithredwr a gwyliwr yn Ruby. Byddwn yn dechrau gyda'r gweithredwr, yna creu'r gwyliwr, a'r diwedd, byddwn yn dangos sut i gysylltu'r ddau.

Creu'r Gweithredwr

Yn gyntaf, gadewch i ni greu'r dosbarth gweithredwr. Mae'r dosbarth hwn yn cynnal rhestr o'r gwyliwr a'i hysbysu pan fydd newid yn digwydd.

class Subject
  def initialize
    @observers = []
  end

  def register_observer(observer)
    @observers << observer
  end

  def remove_observer(observer)
    @observers.delete(observer)
  end

  def notify_observers
    @observers.each { |observer| observer.update(self) }
  end

  def state=(value)
    @state = value
    notify_observers
  end

  def state
    @state
  end
end

Yn y cod uchod, rydym wedi creu dosbarth o'r enw Subject sy'n cynnal rhestr o'r gwyliwr. Mae gennym ddau ddull pwysig: register_observer i gofrestru gwyliwr, a notify_observers i hysbysu'r gwyliwr pan fydd y statws yn newid.

Creu'r Gwyliwr

Nawr, gadewch i ni greu'r dosbarth gwyliwr. Mae'r dosbarth hwn yn ymateb i'r hysbysiadau a dderbyniwyd gan y gweithredwr.

class Observer
  def update(subject)
    puts "The state has changed to: #{subject.state}"
  end
end

Yn y cod uchod, rydym wedi creu dosbarth o'r enw Observer sy'n cynnwys dull update. Mae'r dull hwn yn derbyn y gweithredwr fel paramedr a'i ddefnyddio i ddangos y statws newydd.

Cysylltu'r Gweithredwr a'r Gwyliwr

Nawr, gadewch i ni gysylltu'r gweithredwr a'r gwyliwr. Byddwn yn creu enghraifft o'r ddau ddosbarth yn gweithio gyda'i gilydd.

subject = Subject.new
observer = Observer.new

subject.register_observer(observer)

subject.state = "New State 1"
subject.state = "New State 2"

Yn y cod uchod, rydym wedi creu enghraifft o'r dosbarth Subject a'r dosbarth Observer. Rydym yn cofrestru'r gwyliwr gyda'r gweithredwr, ac yna newidwn y statws. Bydd y gwyliwr yn derbyn hysbysiad am y newidiadau.

Defnyddiau a Buddion y Patrwm Gwyliwr

Mae'r patrwm gwyliwr yn cynnig nifer o fanteision:

Rhyddhad o gysylltiadau: Mae'r gwyliwr a'r gweithredwr yn gysylltiedig yn rhydd, sy'n golygu y gallant gael eu datblygu a'u cynnal yn annibynnol.
Hysbysiadau cyflym: Mae'r gwyliwr yn derbyn hysbysiadau yn syth pan fydd newid yn digwydd, gan sicrhau bod y wybodaeth yn gyfredol.
Hawdd i ehangu: Gallwch ychwanegu gwyliwr newydd heb newid y gweithredwr, gan wneud y system yn hawdd i ehangu.

Enghreifftiau Ymarferol o'r Patrwm Gwyliwr

Mae'r patrwm gwyliwr yn cael ei ddefnyddio mewn sawl cyd-destun, gan gynnwys:

Gwefannau: Gall gwefannau ddefnyddio'r patrwm hwn i hysbysu defnyddwyr am newidiadau yn y cynnwys.
Apiau symudol: Mae apiau symudol yn gallu defnyddio'r patrwm hwn i hysbysu defnyddwyr am ddiweddariadau yn y data.
Systemau rheoli: Gall systemau rheoli ddefnyddio'r patrwm hwn i hysbysu aelodau am newidiadau yn y broses.

Casgliad

Mae'r patrwm gwyliwr yn ddull pwerus a defnyddiol ar gyfer rheoli newidiadau yn y cod. Mae'n cynnig rhyddhad o gysylltiadau rhwng elfenau, gan ei gwneud yn haws i gynnal a datblygu systemau cymhleth. Trwy ddefnyddio Ruby, gallwn weithredu'r patrwm hwn yn hawdd, gan greu gweithredwyr a gwyliwyr sy'n gweithio gyda'i gilydd yn effeithiol.

Gobeithio bod yr erthygl hon wedi rhoi gwybodaeth fanwl i chi am weithredu'r patrwm gwyliwr yn Ruby. Peidiwch ag oedi i archwilio a defnyddio'r patrwm hwn yn eich prosiectau eich hun!