Pemula pasti banyak kebingungan tentang pola desain. Hari ini adalah akhir pekan, jadi saya meluangkan waktu untuk menulis artikel tentang mode satu bagian yang dikombinasikan dengan mode rantai perintah untuk membuat inti sistem artikelnya terlalu sederhana, ini tutorial untuk pemula, karena waktu mepet (saya harus belanja bersama istri, haha), ada kejanggalan desain, ketidakteraturan penulisan kode, bug, dan lain-lain. pahlawan dapat menunjukkannya untuk kenyamanan. Mari kita membuat kemajuan bersama. Level saya terbatas.^_^
Saya yakin semua orang telah membaca banyak buku atau artikel tentang penerapan pola desain di PHP, tetapi hanya sedikit dari mereka yang langsung memberikan contoh bingung setelah membacanya. Saya merasa tanpa latihan proyek, sulit untuk mengetahui bagian pola desain.
Untuk menghindari kode yang terlalu rumit, penanganan pengecualian dan konten lainnya tidak ditambahkan.
Untuk pengetahuan dasar singleton mode dan command chain mode bisa googling sendiri, saya tidak akan panjang lebar langsung saja lihat contohnya:
<?php
/*
*@penulis:Tidak Ada Malaikat
*@waktu: 30 Agustus 2008
*/
antarmukaIRunAction{
//Dapatkan metode yang ditentukan di kelas yang dapat dijalankan di APP
fungsi statis LoadActions();
//Fungsi entri di kelas digunakan untuk memanggil fungsi lain di kelas
fungsi runAction($aksi, $args);
}
/*
*Bagian inti dari sistem APP
*/
kelasAPP{
pribadi statis $__instance = null;
pribadi statis $__commands = array();
pribadi statis $__flag = 1;
fungsi pribadi __construct(){}
//Desain mode satu bagian memperoleh satu-satunya instance dari kelas ini
fungsi statis Beban(){
if(self::$__instance == null) self::$__instance = APLIKASI baru;
kembalikan diri::$__instance;
}
//Tambahkan penamaan ke $__instance APP. Setiap kali Anda menambahkan perintah baru, periksa apakah instance kelas ini telah ditambahkan sebelumnya.
//Jika ada, abaikan operasi tersebut. Jika tidak, tambahkan.
fungsi publik addCommand($cmdName){
foreach(self::$__perintah sebagai $cmd){
if(strtolower(get_class($cmd)) == strtolower(get_class($cmdName))){
diri::$__bendera = 0;
merusak;
}
}
if(self::$__flag == 1) self::$__commands[] = $cmdName;
diri::$__bendera = 1;
}
//Bagian inti dari desain mode rantai perintah memanggil fungsi entri dari instance
//Pertama periksa apakah pemanggilan operasi ini diperbolehkan di kelas. Jika tidak, ini akan menampilkan operasi yang tidak ditentukan dan keluar.
fungsi publik runCommand($action, $args){
diri::$__bendera = 0;
foreach(self::$__perintah sebagai $cmd){
if(in_array($aksi, $cmd->LoadActions())){
diri::$__bendera = 1;
$cmd->runAction($aksi, $args);
}
}
jika(diri::$__bendera == 0){
diri::$__bendera = 1;
exit("tindakan demi tindakan tidak terdefinisi : $aksi");
}
}
//Untuk menghapus sebuah instance dari suatu kelas, cukup tentukan nama kelasnya.
fungsi publik deleteCommand($className){
foreach(self::$__perintah sebagai $key=>$cmd){
if(strtolower(get_class($cmd)) == strtolower($className)){
tidak disetel(diri::$__perintah[$kunci]);
}
}
}
//Untuk pengujian semua orang untuk melihat apakah penambahan dan penghapusan berhasil
fungsi publik viewCommands(){
echo(hitungan(diri::$__perintah));
}
}
//Pengguna Kelas mengimplementasikan antarmuka IRunAction
kelas Pengguna mengimplementasikan IRunAction{
//Tentukan operasi yang dapat dipanggil
pribadi statis $__actions = array('addUser', 'modifyUser', 'removeUser');
//Dapatkan operasi yang dapat dipanggil. Dalam proses sebenarnya, jangan hanya mencintaimu secara langsung. $__actions dirancang sebagai panggilan publik.
//Anda harus mendesain fungsi LoadActions untuk mendapatkan nilai $__actions
fungsi publik statis LoadActions(){
kembalikan diri::$__tindakan;
}
//Jalankan fungsi yang ditentukan
fungsi publik runAction($action, $args){
//Jika Anda tidak memahami cara menggunakan fungsi ini, silakan merujuk ke manual.
call_user_func(array($ini,$aksi), $args);
}
//Hanya fungsi pengujian
fungsi yang dilindungi addUser($nama){
echo($nama);
}
}
//Pengguna seperti Tes
kelas Tes mengimplementasikan IRunAction{
pribadi statis $__actions = array('addTest', 'modifyTest', 'removeTest');
fungsi publik statis LoadActions(){
kembalikan diri::$__tindakan;
}
fungsi publik runAction($action, $args){
call_user_func(array($ini,$aksi), $args);
}
fungsi yang dilindungi addTest($nama){
echo($nama);
}
}
//Berikut ini adalah kode pengujiannya
APLIKASI::Muat()->addCommand(Pengguna baru);
APLIKASI::Muat()->addCommand(Pengguna baru);
APLIKASI::Muat()->addCommand(Pengguna baru);
APLIKASI::Muat()->addCommand(Pengguna baru);
APLIKASI::Muat()->runCommand('addUser', 'NoAngels');
APP::Load()->addCommand(Tes baru);
APP::Load()->runCommand('addTest', null);
Kelas APP dirancang dalam mode tunggal, yang merupakan bagian inti dari sistem untuk memuat instance kelas APP, yang setara dengan Metode statis getInstance di beberapa buku memiliki tiga metode publik: addCommand, runCommand, dan deleteCommand. runCommand adalah bagian inti. Ini juga merupakan program startup inti dari mode rantai perintah lihat kode sumber untuk implementasi spesifik. Kode ini ditulis dengan sangat jelas di sini.
Kelas Pengguna dan Tes mengimplementasikan antarmuka IRunAction. Kedua kelas mendefinisikan variabel pribadi statis $__actions, yang merupakan array yang berisi operasi yang dapat dipanggil oleh fungsi runCommand dari APP.
Berikut ini adalah proses yang berjalan dari sistem:
startup APP
-------addCommand, tambahkan kelas tempat operasi yang akan dijalankan milik APP. Jika kelas yang ditambahkan dirancang menggunakan mode tunggal, Anda dapat menambahkan addCommand(SingletonClass::Load()) sebagai berikut. Jika tidak, Anda dapat menambahkannya sebagai berikut. Panggil
addCommand(new someClass)
-------runCommand. Jalankan operasi. Misalnya, ada operasi addUser di kelas Pengguna. Saya dapat langsung mengaktifkan runCommand($acttion, $args). adalah instance dari salah satu kelas. Jika Anda memiliki operasi ini, panggil fungsi runAction dari instance tersebut. Jika Anda tidak menambahkan instance kelas tertentu menggunakan addCommand, Anda akan diminta untuk melakukan operasi yang tidak ditentukan dan keluar.
RunAction di kelas User dan kelas Test memanggil call_user_func, fungsi yang sangat umum digunakan. Fungsi terkait di kelas ini disebut.
Tip: Ini adalah akhir dari penjelasan dan contohnya. Lihat saja Ini pemahaman Anda sendiri bahwa Anda harus melakukan semuanya sendiri (ps: Ini dapat dibuat menjadi satu file entri dalam kerangka kerja. Apakah akan mengimplementasikan MVC atau tidak tergantung pada apa yang Anda pikirkan.)