Naudojimo atvejų modelio taikymas su "Rails

Logika dažnai būna patalpinta valdikliuose, modeliuose arba, jei pasiseka, paslaugos objekte. Taigi, jei turime paslaugų objektus, kam mums reikalingi naudojimo atvejai?

Sekite mane šiame straipsnyje, kad sužinotumėte šio modelio privalumus.

Naudojimo atvejis

Apibrėžimas

Naudojimo atvejis - tai veiksmų ar įvykių etapų sąrašas, kuriame paprastai apibrėžiama vaidmens ir sistemos sąveika siekiant tikslo.

Verta paminėti, kad šis modelis taikomas įvairiais būdais ir turi alternatyvius pavadinimus. Jį galime rasti kaip Sąveikautojai, Operatoriai arba Komandos, bet Ruby bendruomenė, kurios mes laikomės Naudojimo atvejis. Kiekviena realizacija yra skirtinga, tačiau jos tikslas yra tas pats - tarnauti naudotojo naudojimosi sistema atvejui.

Net jei mūsų projektas mes neapibrėžiame reikalavimų naudodami Naudojimo atvejiss ir UML, šis modelis vis dar naudingas norint praktiškai struktūrizuoti verslo logiką.

Taisyklės

Mūsų Naudojimo atvejai turi būti:

• Nepriklausoma nuo sistemos
• Duomenų bazių agnostikas
• Atsakingas tik už vieną dalyką (apibrėžti naudotojo tikslo pasiekimo veiksmus)

Privalumai

• Įskaitomumas: Lengva skaityti ir suprasti, nes žingsniai aiškiai apibrėžti.
• Atskyrimas: Perkelkite logiką iš valdiklių ir modelių ir sukurkite naują abstrakcijos lygį.
• Matomumas: Kodų bazė atskleidžia sistemoje esančias funkcijas.

Į praktiką

Paimkime pavyzdį, kai naudotojas nori ką nors įsigyti mūsų sistemoje.

modulis UseCases
  modulis Pirkėjas
    klasė Pirkimas
      def initialize(buyer:, cart:)
        @buyer = buyer
        @cart = cart
      end
      def call
        return nebent check_stock
        return nebent create_purchase
pranešti end
privatus
      attr_reader :buyer, :cart
      def check_stock
        Services::CheckStock.call(cart: cart)
end
      def create_purchase
        Services::CreatePurchase.call(buyer: buyer, cart: cart).call
      end
      def pranešti

         Services::NotifyBuyer.call(buyer: buyer)
       end
     end
   end
 end

Kaip matote šiame kodas sukūrėme naują Naudojimo atvejis vadinamas pirkimu. Apibrėžėme tik vieną viešąjį metodą skambinkite. Skambučio metodo viduje randame gana paprastus pirkimo atlikimo veiksmus, kurie apibrėžti kaip privatūs metodai. Kiekviename žingsnyje kviečiamas paslaugos objektas, todėl mūsų Naudojimo atvejis apibrėžiami tik pirkimo etapai, o ne pati logika. Tai suteikia mus aiškų vaizdą, ką galima padaryti mūsų sistemoje (atlikti pirkimą), ir žingsnius, kaip tai padaryti.

Dabar esame pasirengę iškviesti pirmąjį Naudojimo atvejis iš valdiklio.

klasė Controller
  def pirkti
    UseCases::Buyer::Purchase.new(
      buyer: purchase_params[:buyer],
      cart: purchase_params[:cart]
    ).call

    ...
  pabaiga

  ...
pabaiga

Šiuo požiūriu Naudojimo atvejis atrodo panašiai kaip paslaugos objektas, tačiau jo paskirtis yra kitokia. Paslaugos objektas atlieka žemo lygio užduotį ir sąveikauja su įvairiomis sistemos dalimis, pvz. Naudojimo atvejis sukuria naują aukšto lygio abstrakciją ir apibrėžia loginius veiksmus.

Patobulinimai

Mūsų pirmasis Naudojimo atvejis veikia, bet galėtų būti geresnis. Kaip galėtume jį patobulinti? Pasinaudokime sausas brangakmeniai. Šiuo atveju naudosime sausasis sandoris.

Pirmiausia apibrėžkime savo bazinę klasę.

klasė UseCase
  įtraukti Dry::Transaction

  klasė << self
    def call(**args)
      new.call(**args)
    pabaiga
  pabaiga
end

Tai padės mums perduoti atributus į "UseCase" sandorį ir juos naudoti. Tada galėsime iš naujo apibrėžti savo Pirkimo naudojimo atvejį.

modulis UseCases
  modulis Pirkėjas
    klasė Pirkimas
      def initialize(buyer:, cart:)
        @buyer = buyer
        @cart = cart
      end

      def call
        return nebent check_stock
        return nebent create_purchase
        pranešti
      end

      privatus

      attr_reader :buyer, :cart

      def check_stock
        Services::CheckStock.call(cart: cart)
      end

      def create_purchase
        Services::CreatePurchase.call(buyer: buyer, cart: cart).call
      end

      def pranešti
        Services::NotifyBuyer.call(buyer: buyer)
      end
    end
   end
 end

Atlikę naujus pakeitimus, galime aiškiai matyti, kaip apibrėžiami mūsų žingsniai, ir galime valdyti kiekvieno žingsnio rezultatus naudodami sėkmės() ir nesėkmės() funkcijas.

Esame pasiruošę iškviesti naująjį naudojimo atvejį valdiklyje ir parengti atsakymą, priklausomai nuo galutinio rezultato.

klasė Controller
  def pirkti
    UseCases::Buyer::Purchase.new.call(
      buyer: purchase_params[:buyer],
      cart: purchase_params[:cart]
    ) do |rezultatas|
      result.success do
        ...
      end
      result.failure do
        ...
      end
    end

    ...
  pabaiga

  ...
pabaiga

Šį pavyzdį būtų galima dar labiau patobulinti naudojant patvirtinimus, tačiau to pakanka, kad būtų parodyta šio modelio galia.

Išvados

Būkime sąžiningi, kad Naudojimo atvejo modelis yra gana paprastas ir labai panašus į paslaugos objektą, tačiau toks abstrakcijos lygis gali labai pakeisti jūsų programą.

Įsivaizduokite naują kūrėjas prisijungęs prie projekto ir atidaręs aplanką use_cases, jis pirmiausia pamatys visų sistemoje esančių funkcijų sąrašą, o atsidaręs vieną naudojimo atvejį pamatys visus būtinus tos funkcijos veiksmus, nesigilindamas į logiką. Šis tvarkos ir kontrolės jausmas yra pagrindinis šio modelio privalumas.

Įsidėkite tai į savo įrankių dėžutę ir galbūt ateityje tuo pasinaudosite.