Apakah 'C' di MVC benar-benar diperlukan?

Saya memahami peran model dan pandangan dalam pola Model-View-Controller, tapi saya kesulitan memahami mengapa pengontrol diperlukan.

Mari kita asumsikan kita sedang membuat program catur menggunakan pendekatan MVC; kondisi permainan harus menjadi model, dan GUI harus menjadi tampilan. Apa sebenarnya controller dalam hal ini?

Apakah ini hanya kelas terpisah yang memiliki semua fungsi yang akan dipanggil ketika Anda, katakanlah, klik ubin? Mengapa tidak melakukan semua logika pada model dalam tampilan itu sendiri?

Dengan menggunakan contoh Anda, Pengontrollah yang akan memutuskan apa langkah legal atau tidak. Pengendali akan membiarkan pandangan tahu bagaimana mengatur potongan-potongan di papan saat memulai menggunakan informasi yang diterima dari Model. Ada lebih banyak hal yang dapat ditangani oleh Controller tetapi kuncinya adalah memikirkan Business Logic pada layer itu.

Ada saat-saat ketika semua Controller lakukan adalah menyampaikan informasi bolak-balik, seperti halaman pendaftaran. Lain waktu Controller adalah bagian yang sulit dari pengembangan karena ada banyak hal yang perlu dilakukan pada lapisan itu seperti menegakkan aturan atau melakukan matematika yang rumit misalnya. Jangan lupakan Controller!

Mengapa tidak melakukan semua logika pada model dalam tampilan itu sendiri?

Kontroler adalah lem yang mengikat model dan tampilan bersama, dan itu juga isolasi yang membuat mereka terpisah. Model ini seharusnya tidak tahu apa-apa tentang tampilan dan sebaliknya (setidaknya dalam versi Apple MVC). Kontroler bertindak seperti adaptor dua arah, menerjemahkan tindakan pengguna dari tampilan menjadi pesan ke model dan mengonfigurasi tampilan dengan data dari model.

Menggunakan pengontrol untuk memisahkan model dan tampilan membuat kode Anda lebih dapat digunakan kembali, lebih dapat diuji, dan lebih fleksibel. Pertimbangkan contoh catur Anda. Model tersebut tentu saja akan mencakup status permainan, tetapi mungkin juga berisi logika yang memengaruhi perubahan kondisi permainan, seperti menentukan apakah suatu langkah legal atau tidak dan memutuskan kapan game selesai. Tampilan menampilkan papan catur dan potongan-potongan dan mengirim pesan ketika sepotong bergerak, tetapi tidak tahu apa-apa tentang makna di balik potongan, bagaimana masing-masing bagian bergerak, dll. Kontroler tahu tentang model dan tampilan serta keseluruhan alur program. Ketika pengguna menekan tombol 'permainan baru', itu adalah pengontrol yang memberitahu model untuk membuat permainan dan menggunakan status permainan baru untuk mengatur papan. Jika pengguna bergerak,

Lihatlah apa yang Anda dapatkan dengan menjaga model dan melihat secara terpisah:

• Anda dapat mengubah model atau tampilan tanpa mengubah yang lain. Anda mungkin harus memperbarui controller ketika Anda mengubah salah satu, tetapi dengan cara ini merupakan bagian dari keuntungan: bagian-bagian dari program yang paling mungkin berubah terkonsentrasi di controller.

• Model dan tampilan keduanya dapat digunakan kembali. Misalnya, Anda dapat menggunakan tampilan papan catur yang sama dengan umpan RSS sebagai model untuk menggambarkan permainan terkenal. Atau, Anda bisa menggunakan model yang sama dan mengganti tampilan dengan antarmuka berbasis web.

• Sangat mudah untuk menulis tes untuk kedua model dan tampilan untuk memastikan bahwa mereka bekerja seperti seharusnya.

• Baik model dan tampilan sering dapat memanfaatkan bagian standar: array, peta, set, string, dan wadah data lainnya untuk model; tombol, kontrol, bidang teks, tampilan gambar, tabel, dan lainnya untuk tampilan.

Ada banyak, banyak cara berbeda dalam menerapkan pola desain umum ini, tetapi ide dasarnya adalah untuk memisahkan berbagai masalah yang diperlukan. MVC adalah abstraksi yang bagus dalam arti bahwa:

Model : Mewakili data itu, apa pun yang mungkin berarti
Lihat : Merupakan antarmuka pengguna, apa pun artinya
Pengontrol : Merupakan lem yang menyebabkan model dan tampilan berinteraksi, apa pun artinya

Ini sangat fleksibel karena tidak menentukan banyak. Banyak orang membuang banyak bandwidth berdebat tentang apa arti setiap elemen, nama apa yang harus digunakan, dan apakah benar-benar ada 3 atau 2 atau 4 atau 5 komponen, tapi itu tidak ada gunanya tingkat tertentu.

Idenya adalah untuk memisahkan "potongan" logika yang berbeda sehingga mereka tidak tumpang tindih. Menyatukan materi presentasi Anda, menyatukan data Anda, menyatukan hal-hal logika Anda, menyatukan hal-hal komunikasi Anda. Dan seterusnya. Sampai batas tertentu, semakin sedikit bidang-bidang yang saling tumpang tindih ini, semakin mudah melakukan hal-hal menarik dengannya.

Hanya itu yang harus Anda khawatirkan.

Semua jawaban bagus sejauh ini. Dua sen saya adalah bahwa saya suka menganggap pengontrol terutama dibangun dengan pertanyaan seperti Apa dan di mana?

• Saya ditanya apakah bidak catur (tampilan) dapat dipindahkan ke x. Apakah
  diizinkan? Saya tidak yakin tapi saya tahu di mana dan siapa yang harus ditanya (model).
• Sesuatu telah meminta saya untuk menyimpan data saya. Bagaimana cara saya melakukan itu? Saya tahu di mana harus bertanya! Bagaimana kami menyimpan data, atau ke mana data itu disimpan, saya tidak tahu, tetapi kelas Repositori itu harus tahu. Saya akan meneruskannya dan membiarkannya menghadapinya.
• Saya harus menunjukkan posisi bidak catur saat ini kepada pengguna yang modelnya pindahkan. tidak yakin apakah saya ingin memperlihatkan karya itu hijau atau kuning? Bah, siapa yang peduli, saya tahu ada pandangan yang bisa menangani ini sehingga saya akan memberikan data dan mereka dapat memutuskan bagaimana itu akan ditampilkan.

Cuplikan kecil ini adalah contoh bagaimana saya mencoba mengingat abstraksi dan konsep yang ingin disampaikan oleh MVC. Apa, Di mana, dan Bagaimana tiga proses pemikiran utama saya.

Apa dan di mana => Pengontrol Bagaimana dan kapan => Model dan tampilan

Intinya tindakan pengontrol saya cenderung kecil dan kompak dan ketika membacanya terkadang terlihat seperti buang-buang waktu. Dalam pemeriksaan lebih dekat mereka bertindak sebagai petugas sinyal lalu lintas, menyalurkan berbagai permintaan kepada pekerja yang tepat tetapi tidak melakukan pekerjaan aktual apa pun sendiri.

Pengontrol dapat membantu mengabstraksi antarmuka Tampilan dan Model sehingga mereka tidak harus saling mengenal secara langsung. Semakin sedikit objek yang harus diketahui, semakin portabel dan unit yang bisa diuji.

Misalnya Model dapat memainkan instance lain dari dirinya sendiri melalui satu Controller. Atau Kontroler jaringan dapat menghubungkan dua objek Tampilan pemain secara bersamaan. Atau mungkin tes Turing di mana tidak ada yang tahu yang mana.

Ini benar-benar berperan ketika Anda berhadapan dengan penangan acara, tetapi Anda masih membutuhkan pengontrol untuk menangani interaksi antara tampilan dan model. Idealnya Anda tidak ingin pandangan tahu apa-apa tentang model. Pikirkan tentang hal ini, apakah Anda ingin jsp membuat semua panggilan basis data secara langsung? (Kecuali jika itu seperti pencarian login.) Anda ingin tampilan membuat data dan tidak memiliki logika bisnis, kecuali jika itu menampilkan logika rendering, tetapi bukan logika bisnis perse.

Di GWT, Anda mendapatkan pemisahan yang lebih bersih dengan MVP. Tidak ada logika bisnis apa pun (jika dilakukan dengan benar) dalam tampilan. Presenter bertindak sebagai pengontrol dan pandangan tidak memiliki pengetahuan tentang model. Data model hanya diteruskan ke tampilan.

Document-View (yaitu tampilan model) adalah model standar untuk sebagian besar aplikasi Windows yang ditulis dalam MFC sehingga harus berfungsi untuk banyak kasus.

Saya memahami peran model dan pandangan dalam pola Model-View-Controller, tapi saya kesulitan memahami mengapa pengontrol diperlukan.

Apakah Anda yakin tentang hal itu? (Setidaknya seperti yang dijelaskan sebelumnya) Maksud dari model ini adalah menjadi model domain. Tampilan seharusnya menampilkan model domain kepada pengguna. Pengontrol seharusnya memetakan input level rendah ke model level tinggi. Sejauh yang saya tahu alasannya adalah sesuatu di sepanjang baris: A) penggunaan SRP tingkat tinggi. B) Model itu dianggap sebagai bagian penting dari aplikasi jadi jauhkan barang yang tidak penting dan lebih cepat diganti. C) logika bisnis yang mudah diuji (dan skrip).

Bayangkan saja jika Anda ingin membuat program Catur Anda dapat digunakan oleh orang buta, tukar tampilan untuk versi yang terdengar, dan pengontrol yang bekerja dengan keyboard. Katakanlah Anda ingin menambahkan game melalui surat, tambahkan controller yang menerima teks. Versi bersih dari game? Kontroler yang menerima perintah dari soket akan melakukan pekerjaan itu. Tambahkan render 3d yang bagus untuk itu, tampilan baru yang keren. Nol perubahan model yang diperlukan Catur masih catur.

Jika Anda mencampur input dengan representasi model maka Anda kehilangan kemampuan itu. Tiba-tiba Catur bukan Catur, melainkan Catur dengan mouse yang berbeda dari Catur dengan koneksi keyboard atau jaringan.

Saya pikir MVC bodoh, mungkin di area tertentu itu berfungsi dengan baik tetapi secara pribadi bahkan situs web yang saya tulis tidak cocok untuk MVC. Ada alasan mengapa Anda mendengar frontend, backend, dan tidak pernah database-end atau sesuatu-end-lain

IMO harus ada API (backend) dan aplikasi yang menggunakan API (frontend). Saya kira Anda bisa memanggil permintaan GET controller (yang hanya memanggil api backend) dan html tampilan tetapi saya biasanya tidak mendengar orang berbicara tentang tampilan sebagai html murni atau model menjadi API backend.

IMO semuanya harus menjadi API yang solid. Sebenarnya mereka tidak perlu solid (seperti dalam clean and well built) tetapi internalnya harus tetap pribadi dan aplikasi / frontend / di luar api tidak boleh mengatakan koneksi database atau membuat permintaan mentah.

Sekarang jika kode / desain Anda melibatkan lem dengan baik. Jika dalam permainan catur Anda ada beberapa markup yang dapat Anda edit untuk menguliti GUI, gui mengumpulkan coords / input dan memanggil MovePiece (srcPosition, dstPostion) (yang dapat mengembalikan bool atau enum untuk mengatakan apakah itu langkah yang valid atau tidak ) dan ok Anda dengan semua logika yang ada dalam model maka yakin menyebutnya MVC. Namun saya masih mengatur berbagai hal berdasarkan kelas dan API dan memastikan tidak ada kelas kitchen-sink yang menyentuh segalanya (atau API apa pun yang harus tahu tentang segala hal).

Pikirkan browser yang menampilkan halaman web statis. Modelnya adalah HTML. Tampilan adalah hasil aktual di layar.

Sekarang tambahkan beberapa JavaScript. Itu adalah Controller. Ketika pengguna mengklik tombol atau menyeret sesuatu Acara dikirim ke JavaScript, ia memutuskan apa yang harus dilakukan dan mengubah HTML (Model) yang mendasarinya dan browser / renderer menampilkan perubahan-perubahan itu di layar (Lihat).

Mungkin tombol lain diklik, acara dikirim ke pengendali (pengendali), dan mungkin menyebabkan permintaan untuk data lebih lanjut dikirim ke layanan web. Hasilnya kemudian ditambahkan ke HTML (Model).

Pengontrol merespons peristiwa dan mengontrol apa yang ada dalam Model dan karenanya apa yang ada di layar / Tampilan.

Melangkah mundur sedikit, Anda dapat menganggap seluruh browser sebagai Tampilan dan server sebagai Pengontrol dan data sebagai Model. Ketika pengguna mengklik sebuah tombol di browser kejadian yang dikirim ke server (Pengendali), ia mengumpulkan sumber daya bersama-sama sebagai halaman HTML (Model) dan mengirimkan kembali ke browser untuk ditampilkan (Lihat)

Turun di server apakah itu asp, php, atau java 'kode' (Pengendali) menerima acara klik dan meminta database atau repositori dokumen (Model) dan membuat HTML. Dari sudut pandang server, hasil dari semua tindakannya adalah Tampilan (HTML) dari datastore yang mendasarinya (Model). Tetapi dari sudut pandang klien, hasil dari permintaannya ke server adalah Modelnya (HTML)

Bahkan jika Anda mengacaukan JavaScript dalam HTML atau PHP Anda dalam HTML, Model, View, Controller masih ada. Bahkan jika Anda memikirkan permintaan Anda ke server dan respons balik dari server sebagai jalan dua arah yang sederhana, masih ada Model, View, dan Controller.

Dalam pengalaman saya, dalam program desktop tradisional mvc gui, controller akhirnya terperangkap dalam tampilan. Sebagian besar orang tidak meluangkan waktu untuk mempertimbangkan kelas pengontrol.

buku gang-of-four mengatakan:

Pola Desain di Smalltalk MVC

Triad Model / View / Controller (MVC) kelas [KP88] digunakan untuk membangun antarmuka pengguna di Smalltalk-80. Melihat pola desain di dalam MVC akan membantu Anda melihat apa yang kami maksud dengan istilah "pola."

MVC terdiri dari tiga jenis objek. Model adalah objek aplikasi, tampilan adalah presentasi layarnya, dan Pengontrol menentukan cara antarmuka pengguna bereaksi terhadap input pengguna. Sebelum MVC, desain antarmuka pengguna cenderung menyatukan objek-objek ini. MVC memisahkan mereka untuk meningkatkan fleksibilitas dan penggunaan kembali.

MVC memisahkan pandangan dan model dengan membuat protokol berlangganan / memberitahukan di antara mereka. Pandangan harus memastikan bahwa penampilannya mencerminkan keadaan model. Setiap kali data model berubah, model memberitahukan tampilan yang bergantung padanya. Sebagai tanggapan, setiap tampilan mendapat kesempatan untuk memperbarui sendiri. Pendekatan ini memungkinkan Anda melampirkan banyak tampilan ke model untuk memberikan presentasi yang berbeda. Anda juga dapat membuat tampilan baru untuk model tanpa menulis ulang.

Diagram berikut menunjukkan model dan tiga tampilan. (Kami telah meninggalkan pengontrol untuk kesederhanaan.) Model ini berisi beberapa nilai data, dan pandangan yang mendefinisikan spreadsheet, histogram, dan diagram lingkaran menampilkan data ini dengan berbagai cara. Model berkomunikasi dengan pandangannya ketika nilainya berubah, dan pandangan berkomunikasi dengan model untuk mengakses nilai-nilai ini.

Diambil pada nilai nominal, contoh ini mencerminkan desain yang memisahkan pandangan dari model. Tetapi desain ini berlaku untuk masalah yang lebih umum: memisahkan objek sehingga perubahan ke satu dapat mempengaruhi sejumlah orang lain tanpa memerlukan objek yang diubah untuk mengetahui detail yang lain. Desain yang lebih umum ini dijelaskan oleh pola desain Pengamat (halaman 293).

Fitur lain dari MVC adalah bahwa pandangan dapat disarangkan. Misalnya, panel kontrol tombol dapat diimplementasikan sebagai tampilan kompleks yang berisi tampilan tombol bersarang. Antarmuka pengguna untuk pemeriksa objek dapat terdiri dari tampilan bersarang yang dapat digunakan kembali dalam debugger. MVC mendukung tampilan bersarang dengan kelas CompositeView, subkelas View. Objek CompositeView bertindak seperti objek Lihat; tampilan komposit dapat digunakan di mana pun tampilan dapat digunakan, tetapi juga berisi dan mengelola tampilan bersarang.

Sekali lagi, kita dapat menganggap ini sebagai desain yang memungkinkan kita memperlakukan tampilan komposit seperti halnya kita memperlakukan salah satu komponennya. Tetapi desain ini berlaku untuk masalah yang lebih umum, yang terjadi kapan pun kita ingin mengelompokkan objek dan memperlakukan grup seperti objek individual. Desain yang lebih umum ini dijelaskan oleh pola desain Composite (163). Ini memungkinkan Anda membuat hierarki kelas di mana beberapa subclass mendefinisikan objek primitif (misalnya, Tombol) dan kelas lainnya mendefinisikan objek komposit (CompositeView) yang merakit primitif menjadi objek yang lebih kompleks.

MVC juga memungkinkan Anda mengubah cara tampilan merespons input pengguna tanpa mengubah presentasi visualnya. Anda mungkin ingin mengubah cara merespons keyboard, misalnya, atau menggunakan menu pop-up sebagai ganti kunci perintah. MVC merangkum mekanisme respons dalam objek Controller. Ada hirarki kelas pengontrol, sehingga mudah untuk membuat pengontrol baru sebagai variasi dari yang sudah ada.

Pandangan menggunakan turunan dari subkelas Pengendali untuk menerapkan strategi respons tertentu; untuk menerapkan strategi yang berbeda, cukup ganti instance dengan jenis pengontrol yang berbeda. Bahkan mungkin untuk mengubah pengontrol tampilan pada saat run-time untuk membiarkan tampilan mengubah cara responsnya terhadap input pengguna. Misalnya, tampilan dapat dinonaktifkan sehingga tidak menerima input hanya dengan memberinya pengontrol yang mengabaikan peristiwa input.

Hubungan View-Controller adalah contoh pola desain Strategi (315). Strategi adalah objek yang mewakili algoritma. Ini berguna ketika Anda ingin mengganti algoritma baik secara statis maupun dinamis, ketika Anda memiliki banyak varian algoritma, atau ketika algoritma memiliki struktur data yang kompleks yang ingin Anda enkapsulasi.

MVC menggunakan pola desain lain, seperti Metode Pabrik (107) untuk menentukan kelas pengontrol default untuk tampilan dan Penghias (175) untuk menambahkan gulir ke tampilan. Tetapi hubungan utama dalam MVC diberikan oleh Observer, Composite, dan pola desain Strategi.