Pengaturcaraan & skrip

Pengenalan kepada ORM Doktrin dan Corak Mapper Data dalam PHP

Pengenalan kepada ORM Doktrin dan Corak Mapper Data dalam PHP

Objektif

Ketahui konsep asas doktrin Orm, melaksanakan corak pemetaan data dengan PHP.

Keperluan

  • Komposer (Pengurus Pakej PHP)
  • Persediaan lampu kerja
  • Memahami pengaturcaraan berorientasikan objek asas dan PHP
  • Memahami konsep pangkalan data asas

Konvensyen

  • # - Memerlukan arahan Linux yang diberikan dengan keistimewaan akar sama ada
    secara langsung sebagai pengguna akar atau dengan menggunakan sudo perintah
  • $ - Memerlukan arahan Linux yang diberikan sebagai pengguna yang tidak layak

Pengenalan

The Corak Mapper Data adalah corak seni bina dengan cara yang mungkin untuk mencapai pemisahan antara lapisan ketekunan data (dalam hal ini pangkalan data MySQL) dan perwakilan data dalam memori (dalam hal ini objek PHP), supaya kedua-dua lapisan dapat dipisahkan dan sama sekali tidak menyedari antara satu sama lain, dengan itu menghormati pemisahan kebimbangan.

Dalam tutorial ini, kita akan melihat bagaimana untuk mengambil langkah pertama kami dengan doktrin, pelaksanaan corak pemetaan data yang merupakan sebahagian daripada Symfony Rangka Kerja PHP, tetapi juga boleh digunakan sendiri.

Penciptaan pangkalan data

Sebelum apa -apa lagi, kita harus membuat pangkalan data yang akan kita gunakan untuk ketekunan data. Dalam tutorial ini, kami akan mewakili pengguna dan jawatannya dalam blog:

MariaDB [(Tiada)]> Buat Blog Pangkalan Data; Mariadb [(Tiada)]> Geran Semua Keistimewaan di Blog.* Kepada 'testuser'@'localhost' yang dikenal pasti oleh 'testpassword'; Mariadb [(tidak)]> Keistimewaan Flush; MariaDB [(tiada)]> keluar;

Memasang dan memulakan doktrin

Langkah seterusnya dalam perjalanan kami akan menjadi pemasangan doktrin: kami akan menggunakan komposer, Pakej PHP dan Pengurus Ketergantungan. Dalam akar projek kami, kami membuat komposer.fail json, menentukan Doktrin/Orm sebagai kebergantungan:

"memerlukan": "Doctrine/Orm": "^2.6 "
Salinan

Sekarang, untuk meneruskan pemasangan, sementara dalam direktori yang sama, buka terminal dan lari:

$ Pemasangan komposer

Komposer akan memasang doktrin dan semua kebergantungannya di dalam vendor direktori yang akan dibuatnya. Sebaik sahaja doktrin dipasang, kita perlu memulakannya. Simpan kod di bawah ke dalam fail (untuk tutorial ini, kami akan memanggilnya bootstrap.php):

 'Blog'; 'user' => 'testuser', 'password' => 'testpassword', 'host' => 'localhost', 'driver' => 'pdo_mysql']; // Dapatkan Pengurus Entiti $ entity_Manager = Doctrine \ Orm \ EntityManager :: create ($ connection_parameters, $ configuration);
Salinan

Pertama sekali yang kami perlukan dalam baris 2 fail autoload komposer Autoload.php, yang menjaga autoloading perpustakaan yang diperlukan.

Dengan memanggil createannotationmetadataconfiguration Kaedah statik Persediaan kelas dalam baris 5, kami mula menyiapkan doktrin. Kaedah ini mengambil 5 argumen, tetapi kami hanya akan memberikan dua yang pertama, meninggalkan selebihnya kepada mungkir mereka, kerana kami tidak berminat dengan mereka pada masa ini.

Hujah pertama dalam baris 6 adalah pelbagai laluan di mana kelas entiti dapat dijumpai dalam projek kami. Entiti adalah kelas yang mewakili baris dalam pangkalan data (rapresentasi dalam memori yang kita nyatakan di atas): Dalam contoh kami, kami akan menggunakan dua entiti: pengarang dan pos.

Hujah kedua dalam baris 7 mengambil nilai boolean, dan mentakrifkan sama ada kita bekerja dalam mod "dev" atau tidak. Ini mentakrifkan tingkah laku doktrin mengenai objek proksi dan caching: Apabila dalam mod "dev", objek proksi akan diperbaharui pada setiap permintaan dan caching akan berlaku dalam ingatan, kerana diandaikan bahawa semasa pembangunan, perubahan akan berlaku dengan kerap. Kami akan menetapkannya buat masa ini.

Selepas itu, kita mesti menentukan parameter sambungan dalam baris 11-16, dalam bentuk array bersekutu yang mengandungi, mengikut nama pangkalan data, pengguna pangkalan data, kata laluan pangkalan data, hos pangkalan data, dan pemacu untuk digunakan untuk mengakses pangkalan data. Penting untuk melihat bahawa pada tahap yang lebih rendah, penggunaan doktrin PDO untuk berinteraksi dengan pangkalan data, dan ia direka untuk menjadi pangkalan data-agnostik.

Akhirnya kami mencipta contoh objek EntityManager dalam baris 20, memanggil kaedah kilang "mencipta" kelas entitiManager, lulus pelbagai maklumat sambungan yang kami tentukan sebagai parameter pertama, dan Konfigurasi objek sebagai yang kedua. Objek EntityManager akan memberi kami akses kepada semua entiti kami, dan membuat kami dapat menguruskan kegigihan dan kitaran hayat mereka dengan mudah.

Mewujudkan entiti kami

Sudah tiba masanya untuk mencipta entiti kita. Sama seperti yang kami nyatakan dalam konfigurasi, kami akan membuat direktori 'entiti' dalam akar projek kami untuk menyimpan entiti kami. Entiti pertama yang akan kita tentukan adalah Pengarang:

Salinan

Kami menentukan entiti pertama, sangat mudah, kami. Kami menggunakan Anotasi untuk memberi doktrin maklumat yang diperlukan untuk mengatasinya. Pertama dalam baris 5, menggunakan, @Entiti Kami memberitahu doktrin bahawa kelas mesti dianggap sebagai entiti, yang akan berterusan di pengarang Jadual pangkalan data. Dalam kes ini, kami menggunakan anotasi @Table (name = "pengarang") dalam baris 6 untuk menentukan ini, namun dalam keadaan ini ia berlebihan, dan kita boleh meninggalkannya sepenuhnya: ia adalah pilihan, dan jika tidak digunakan, entiti akan berterusan dalam jadual yang dinamakan sempena tidak layak nama kelas.

Setiap harta kelas sepadan dengan lajur dalam jadual, dan kami mesti memberikan maklumat mengenai jenis data jadual. The $ id Harta, sebagai contoh, mewakili kunci utama jadual: kami nyatakan ini dengan menggunakan @ID Anotasi dalam Baris 11.

Nilai ID lajur akan dihasilkan secara automatik, itulah sebabnya kami menggunakan @GeneratedValue Anotasi dalam Baris 12. Ia hanya masuk akal apabila dikaitkan dengan @ID, Dan dengan menggunakannya, ia juga mungkin untuk menentukan strategi penjanaan untuk mengadopsi (jika tidak ada yang ditentukan, ia akan menjadi lalai Auto).

Datatype yang digunakan untuk kunci utama kami, akan Kecil, yang kami tentukan melalui @Column (type = "smallint") Anotasi dalam Baris 13. Dua sifat lain adalah $ first_name dan $ last_name, dan mereka ditakrifkan dengan teknik yang sama. Mereka jenis tali: Apabila menggunakan mysql, ia akan diterjemahkan ke Varchar Jenis data pangkalan data. Untuk rujukan lengkap mengenai persatuan jenis data, anda boleh berunding dengan halaman ini.

Apabila menggunakan doktrin, penglihatan sifat -sifat kelas entiti boleh sama ada dilindungi atau persendirian tetapi tidak awam.

Kami belum mendefinisikan getters dan setter untuk kelas. Tidak perlu melakukannya secara manual, kerana doktrin dapat melakukannya untuk kita, dan kita akan melihat bagaimana seketika, kita masih mempunyai entiti lain untuk menentukan, Jawatan:

Salinan

Kami memperkenalkan dua jenis data baru. Yang pertama adalah teks dalam baris 23 yang akan memetakan dan menukar data rentetan tanpa panjang maksimum: Apabila menggunakan MySQL, ia akan ditukar ke Longtext jenis data. Yang kedua adalah masa tarikh dalam baris 28, untuk kami $ tarikh harta. Ia akan diterjemahkan ke dalam jenis yang sama untuk MySQL, dan dalam contoh PHP Masa tarikh objek.

Sekarang kita dapat menjana getters dan setters kita tetapi sebelum kita melakukannya, kita mesti membuat Cli-Config.php Skrip dalam akar projek kami: Ia diperlukan untuk menggunakan doktrin dari baris arahan:

Salinan

Sekarang, buka shell terminal dalam direktori akar projek, dan laksanakan arahan Linux berikut:

$ php vendor/bin/doktrin orm: menjana entiti .

Perintah di atas akan menjana getters dan setters untuk entiti yang dijumpai, dan akan meletakkannya di dalam direktori yang ditentukan. Sekarang, jika kita melihat Pengarang Entiti kita dapat melihat bahawa mendapatkan dan penetus telah dihasilkan:

ID;  /*** Tetapkan nama pertama. * * @param String $ firstName * * @return pengarang */ fungsi awam setFirstName ($ firstName) $ this-> first_name = $ firstName; kembali $ ini;  /*** Dapatkan nama pertama. * * @return string */ fungsi awam getFirstName () return $ this-> first_name;  /*** tetapkan nama terakhir. * * @param String $ lastName * * @return pengarang */ fungsi awam setLastName ($ lastName) $ this-> last_name = $ lastName; kembali $ ini;  /*** Dapatkan nama terakhir. * * @return string */ fungsi awam getLastName () return $ this-> last_name;
Salinan

Perkara yang sama berlaku untuk Jawatan entiti:

ID;  /*** tetapkan tajuk. * * @param String $ title * * @return post */ public function settitle ($ title) $ this-> title = $ title; kembali $ ini;  /*** Dapatkan tajuk. * * @return string */ fungsi awam getTitle () return $ this-> title;  /*** Tetapkan teks. * * @param string $ text * * @return post */ public function settext ($ text) $ this-> text = $ text; kembali $ ini;  /*** Dapatkan teks. * * @return String */ public function getText () return $ this-> text;  /*** Tetapkan tarikh. * * @param \ datetime $ date * * @return post */ public function setDate ($ date) $ this-> date = $ date; kembali $ ini;  /*** Dapatkan tarikh. * * @return \ datetime */ fungsi awam getDate () return $ this-> date;
Salinan

Menentukan hubungan antara entiti

Untuk contoh kami, kami ingin menentukan a dua arah kepada banyak Hubungan antara entiti kita, di mana bidirectional bermaksud setiap entiti memegang rujukan kepada yang lain. Hubungan antara penulis dan jawatannya, banyak-ke-satu (penulis boleh menulis banyak jawatan dan banyak jawatan boleh dimiliki oleh satu pengarang). Menggunakan doktrin, menentukan persatuan sedemikian sangat mudah:

Salinan

Kami menambah satu harta baru di setiap entiti. Dalam pengarang, ia $ siaran dalam baris 16, dan di entiti pos, $ pengarang dalam baris 36. Jenis jenis data yang akan dipegang oleh pembolehubah tersebut? Yang pertama, $ siaran akan menjadi contoh doktrin Arraycolletion Objek: Ini adalah kelas khas yang digunakan untuk mengurus pengumpulan entiti yang lebih baik.

Yang kedua, $ pengarang, dalam Jawatan.php, akan menjadi contoh entiti pengarang, yang mewakili pengarang jawatan: seperti yang dikatakan sebelum ini, setiap entiti memegang rujukan kepada yang lain.

Begitu juga dengan apa yang kami lakukan untuk sifat -sifat lain, kami menentukan hubungan dengan menggunakan anotasi. Dalam kes kita, kerana kita berhadapan dengan hubungan satu arah dua arah, kita menggunakan @Onetomany Anotasi dalam baris 13, dalam entiti pengarang, dan @Manytoone dalam baris 32 dalam jawatan.

Dalam kedua -dua kes, dengan Sasaran Kami menentukan entiti apa yang ditunjuk oleh harta benda. Contohnya dalam kes pengarang $ siaran harta, entiti sasaran adalah pos. Seperti yang anda lihat, kami menggunakan masing -masing Inversedby dan dipetakan Anotasi. Anotasi ini digunakan untuk memberitahu doktrin apa harta, di sisi lain hubungan, merujuk kepada objek: Inversedby mesti digunakan di sisi yang memiliki KUNCI ASING, (Dalam hal ini entiti pos).

Seperti yang anda lihat, dalam pengarang, kami menggunakan dipetakan, menyatakan bahawa di entiti sasaran Siaran, harta yang sepadan adalah $ pengarang. Kami juga memperkenalkan parameter baru, Cascade, menetapkannya kepada "semua". Ini bermakna bahawa dengan berterusan atau mengeluarkan entiti dari pangkalan data, semua jawatannya juga akan dipengaruhi: contohnya, memadamkan pengguna juga akan menyebabkan penghapusan semua jawatannya. Adalah apa yang kita tentukan melalui Pada padam Cascade Dalam kod SQL.

Sebaliknya, dalam entiti pos, yang memegang kunci asing dalam pangkalan data, kami menggunakan Inversedby, memberitahu doktrin bahawa dalam pengarang entiti sasaran, harta yang merujuk kepada objek itu adalah Catatan. Kami juga telah menggunakan @Joincolumn Anotasi dalam baris 33, menyatakan lajur yang terlibat dalam SQL Join, menetapkan kunci asing sebagai tidak boleh dibatalkan (Tidak batal).

Sebaik sahaja hubungan antara kedua -dua entiti ditakrifkan, kita mesti mengemas kini kaedah yang diperlukan untuk menguruskan sifat tambahan. Sekali lagi kita hanya berlari:

$ php vendor/bin/doktrin orm: menjana entiti .

Menjana skema pangkalan data

Dalam contoh kami, kami mempunyai data yang mencukupi untuk dapat menjana skema pangkalan data kami. Sekali lagi, doktrin dapat membantu kami, secara automatik menghasilkannya berdasarkan anotasi kami. Apa yang perlu kita lakukan, jalankan arahan Linux berikut:

$ php vendor/bin/doktrin orm: skema-tool: update --force

Sekiranya semuanya berjalan lancar, jadual pangkalan data akan dihasilkan, mari sahkannya:

Mariadb [(Tiada)]> Huraikan blog.pengarang; +------------+--------------+------+-----+-------- -+ ----------------+ | Bidang | Jenis | NULL | Kunci | Lalai | Tambahan | +------------+--------------+------+-----+-------- -+ ----------------+ | id | Smallint (6) | Tidak | Pri | NULL | AUTO_INCREMENT | | First_name | Varchar (255) | Tidak | | NULL | | | last_name | Varchar (255) | Tidak | | NULL | | +------------+--------------+------+-----+-------- -+ ----------------+ MariaDB [(Tiada)]> Huraikan blog.jawatan; +-----------+--------------+------+-----+--------- + ----------------+ | Bidang | Jenis | NULL | Kunci | Lalai | Tambahan | +-----------+--------------+------+-----+--------- + ----------------+ | id | Smallint (6) | Tidak | Pri | NULL | AUTO_INCREMENT | | pengarang_id | Smallint (6) | Tidak | Mul | NULL | | | Tajuk | Varchar (255) | Tidak | | NULL | | | Teks | Longtext | Tidak | | NULL | | | Tarikh | DateTime | Tidak | | NULL | | +-----------+--------------+------+-----+---------+----------------+
Salinan

Seperti yang dijangkakan jadual yang sepadan dengan entiti kami telah dihasilkan, dan mencerminkan anotasi yang kami tentukan. Kod SQL digunakan untuk menjana mereka masing -masing:

Mariadb [(Tiada)]> Tunjukkan blog Buat meja.pengarang; Jadual: Pengarang Buat Jadual: Buat Jadual 'Pengarang' ('ID' Smallint (6) Tidak NULL AUTO_INCREMENT, 'First_name' VARCHAR (255) Collate UTF8_UNICODE_CI TIDAK NULL, 'LAST_NAME' VARCHAR (255) 'id')) enjin = innodb auto_increment = 2 charset lalai = utf8 collate = utf8_unicode_ci Mariadb [(none)]> tunjukkan blog membuat meja.jawatan; Jadual: Post Buat Jadual: Buat Jadual 'Pos' ('ID' Smallint (6) Tidak Null Auto_increment, 'ARTOR_ID' SMALLINT (6) Tidak NULL, 'Tajuk' VARCHAR (255) UTF8_UNICODE_CI TIDAK NULL, 'tarikh' datetime tidak null, kunci utama ('id'), kunci 'idx_5a8a6c8df675f31b' ('author_id'), kekangan ' Enjin = innoDB auto_increment = 2 charset lalai = UTF8 collate = utf8_unicode_ci
Salinan

Menggunakan Pengurus Entiti

Sekarang sudah tiba masanya untuk menggunakannya Pengurus Entiti:

setFirstName ("John") -> setLastName ("Smith"); $ entity_manager-> berterusan ($ pengarang); // Buat post baru $ post = (entiti baru \ post ()) -> setTitle ("hello wold") -> settext ("ini adalah ujian pos") -> setAuthor ($ pengarang) -> setDate (baru Masa tarikh()); // Tambahkan siaran ke senarai jawatan pengarang. Oleh kerana kami menggunakan cascade = "semua", kami // tidak perlu meneruskan jawatan secara berasingan: ia akan berterusan apabila berterusan // pengarang $ pengarang-> addPost ($ pos); // Akhirnya siram dan laksanakan urus niaga pangkalan data $ entity_manager-> flush ();
Salinan

Melaksanakan kod ini yang kami buat penulis dan jawatan pertamanya, maka kami menambah jawatan itu ke koleksi pos pengarang dan akhirnya kami terus menerus ke pangkalan data. Dengan berterusan () Kaedah Kami memberitahu doktrin untuk menguruskan entiti, sementara transaksi pangkalan data sebenar hanya berlaku semasa memanggil Flush (). Sekiranya kita sekarang melihat pengarang dan jawatan Jadual, kita dapat melihat bahawa rekod baru wujud dalam kedua -duanya:

Mariadb [(tidak ada)]> pilih * dari blog.pengarang; +----+------------+-----------+| id | First_name | last_name | +----+------------+-----------+| 1 | John | Smith | +----+------------+-----------+MariaDB [(none)]> pilih * dari blog.jawatan; +----+-----------+------------+------------------- -+ ---------------------+ | id | pengarang_id | Tajuk | Teks | Tarikh | +----+-----------+------------+------------------- -+ ---------------------+ | 1 | 1 | Hello Wold | Ini adalah jawatan ujian | 2018-04-17 08:37:44 | +----+-----------+------------+---------------------+---------------------+
Salinan

Kami juga boleh menggunakan Pengurus Entiti untuk mendapatkan entiti yang sedia ada, sebagai contoh:

// Ambil penulis dengan nama belakangnya $ pengarang = $ entity_Manager-> getRepository ('entiti \ pengarang')-> findoneby (['last_name' => 'smith']);
Salinan

Kesimpulan

Tujuan tutorial ini adalah untuk memperkenalkan anda kepada corak pemetaan data dalam PHP menggunakan doktrin: Kami melihat bagaimana untuk mengkonfigurasi dan mendapatkan pengurus entiti, bagaimana untuk menentukan dua entiti asas dan menentukan hubungan yang sama di antara mereka melalui anotasi.

Doktrin adalah perpustakaan yang sangat kuat: anda boleh menggunakan dokumentasi projek untuk mula menguasainya, semoga ini dapat menjadi titik permulaan yang minimum.

Tutorial Linux Berkaitan:

  • Perkara yang hendak dipasang di Ubuntu 20.04
  • Pemasangan ampache raspberry pi
  • Cara membuat timbunan lampu berasaskan Docker menggunakan Docker pada ..
  • Cara memasang timbunan lampu pada almalinux
  • Perkara yang perlu dilakukan setelah memasang ubuntu 20.04 Focal Fossa Linux
  • Pengenalan kepada Automasi, Alat dan Teknik Linux
  • Ubuntu 20.04 Trik dan Perkara yang Anda Tidak Tahu
  • Mint 20: Lebih baik daripada Ubuntu dan Microsoft Windows?
  • Manipulasi data besar untuk keseronokan dan keuntungan bahagian 1
  • Ubuntu 20.04 WordPress dengan pemasangan Apache