Pemrograman & Scripting

Pengantar Doktrin ORM dan Pola Mapper Data di PHP

Pengantar Doktrin ORM dan Pola Mapper Data di PHP

Objektif

Pelajari konsep dasar ORM Doktrin, Menerapkan Pola Mapper Data dengan PHP.

Persyaratan

  • Komposer (Manajer Paket PHP)
  • Pengaturan Lampu Kerja
  • Memahami Pemrograman Berorientasi Objek Dasar dan PHP
  • Memahami Konsep Database Dasar

Konvensi

  • # - mensyaratkan perintah linux yang diberikan untuk dieksekusi dengan hak istimewa root
    langsung sebagai pengguna root atau dengan menggunakan sudo memerintah
  • $ - mensyaratkan perintah Linux yang diberikan untuk dieksekusi sebagai pengguna biasa

Perkenalan

Itu Pola Mapper Data adalah pola arsitektur dengan cara yang dimungkinkan untuk mencapai pemisahan antara lapisan persistensi data (dalam hal ini database MySQL) dan representasi data dalam memori (dalam hal ini objek PHP), sehingga kedua lapisan tersebut dapat dipisahkan dan sama sekali tidak menyadari satu sama lain, sehingga menghormati pemisahan kekhawatiran.

Dalam tutorial ini kita akan melihat bagaimana mengambil langkah pertama kami dengan doktrin, implementasi pola mapper data yang merupakan bagian dari Symfony kerangka kerja php, tetapi juga dapat digunakan sendiri.

Pembuatan database

Sebelum hal lain, kita harus membuat database yang akan kita gunakan untuk kegigihan data. Dalam tutorial ini kami akan mewakili pengguna dan postingnya di blog:

Mariadb [(tidak ada)]> Buat blog database; Mariadb [(tidak ada)]> berikan semua hak istimewa di blog.* Untuk 'testuser'@'localhost' yang diidentifikasi oleh 'testpassword'; Mariadb [(tidak ada)]> hak istimewa flush; Mariadb [(tidak ada)]> keluar;

Instal dan inisialisasi doktrin

Langkah selanjutnya dalam perjalanan kami adalah pemasangan doktrin: kami akan menggunakan komposer, Paket PHP dan Manajer Ketergantungan. Di akar proyek kami, kami membuat komposer.file json, menentukan Doktrin/ORM Sebagai ketergantungan:

"membutuhkan": "Doctrine/orm": "^2.6 "
Menyalin

Sekarang, untuk melanjutkan dengan instalasi, saat berada di direktori yang sama, buka terminal dan jalankan:

$ instalasi komposer

Komposer akan menginstal doktrin dan semua dependensinya di dalam penjual direktori yang akan dibuat. Setelah doktrin dipasang, kita perlu menginisialisasi. Simpan kode di bawah ini ke dalam file (untuk tutorial ini, kami akan menyebutnya bootstrap.PHP):

 'blog'; 'user' => 'testuser', 'password' => 'testpassword', 'host' => 'localhost', 'driver' => 'pdo_mysql']; // Dapatkan Entity Manager $ Entity_Manager = Doctrine \ Orm \ EntityManager :: Create ($ Connection_Parameters, $ configuration);
Menyalin

Pertama -tama kami membutuhkan di baris 2 file autoload komposer Autoload.php, yang menangani autoloading perpustakaan yang dibutuhkan.

Dengan menelepon CreateanNotationMetadataconfiguration metode statis dari Mempersiapkan Kelas di baris 5, kami mulai menyiapkan doktrin. Metode ini membutuhkan 5 argumen, tetapi kami hanya akan memberikan dua yang pertama, meninggalkan sisanya ke default mereka, karena kami tidak tertarik pada mereka saat ini.

Argumen pertama dalam baris 6 adalah array jalur di mana kelas entitas dapat ditemukan dalam proyek kami. Entitas adalah kelas yang mewakili baris dalam database (rapresentation dalam memori yang kami sebutkan di atas): Dalam contoh kami, kami akan menggunakan dua entitas: penulis dan posting.

Argumen kedua dalam baris 7 mengambil nilai boolean, dan mendefinisikan apakah kita bekerja dalam mode "dev" atau tidak. Ini mendefinisikan perilaku doktrin tentang objek proxy dan caching: Ketika dalam mode "dev", objek proxy akan diregenerasi pada setiap permintaan dan caching akan terjadi dalam memori, karena diasumsikan bahwa selama pengembangan, perubahan akan sangat sering terjadi. Kami akan mengaturnya ke true untuk saat ini.

Setelah itu, kita harus menentukan parameter koneksi dalam baris 11-16, dalam bentuk array asosiatif yang berisi, secara berurutan, nama database, pengguna database, kata sandi basis data, host database, dan driver yang akan digunakan untuk mengakses database. Penting untuk memperhatikan bahwa pada tingkat yang lebih rendah, penggunaan doktrin Pdo untuk berinteraksi dengan database, dan dirancang untuk menjadi basis data-agnostik.

Akhirnya kami membuat instance objek EntityManager di baris 20, menyebut metode pabrik "buat" kelas EntityManager, melewati array informasi koneksi yang baru saja kami definisikan sebagai parameter pertama, dan Konfigurasi objek sebagai yang kedua. Objek EntityManager akan memberi kita akses ke semua entitas kita, dan membuat kita dapat dengan mudah mengelola kegigihan dan siklus hidup mereka.

Menciptakan entitas kita

Saatnya membuat entitas kita. Sama seperti yang kami nyatakan dalam konfigurasi, kami akan membuat direktori 'entitas' di akar proyek kami untuk menyimpan entitas kami. Entitas pertama yang akan kita definisikan adalah Pengarang:

Menyalin

Kami mendefinisikan entitas pertama, sangat sederhana. Kami menggunakan Anotasi untuk memberikan doktrin informasi yang diperlukan untuk menanganinya. Pertama di baris 5, menggunakan, @Kesatuan Kami memberi tahu doktrin bahwa kelas harus dianggap sebagai entitas, yang akan bertahan di pengarang Tabel Basis Data. Dalam hal ini kami menggunakan anotasi @table (name = "penulis") di baris 6 untuk menentukan ini, namun dalam situasi ini redundan, dan kami bisa menghilangkannya sepenuhnya: itu opsional, dan jika tidak digunakan, entitasnya akan bertahan di meja yang dinamai setelah tidak memenuhi syarat nama kelas.

Setiap properti kelas sesuai dengan kolom dalam tabel, dan kami harus memberikan informasi tentang tipe data tabel. Itu $ id Properti, misalnya, mewakili kunci utama tabel: kami menyatakan ini dengan menggunakan @Pengenal Anotasi di baris 11.

Nilai dari pengenal kolom akan dihasilkan secara otomatis, itu sebabnya kami menggunakan @GeneratedValue Anotasi di baris 12. Itu hanya memiliki arti saat dikaitkan dengan @pengenal, Dan dengan menggunakannya, bahkan mungkin untuk menentukan strategi pembuatan untuk mengadopsi (jika tidak ada yang ditentukan, itu akan default MOBIL).

Tipe data yang digunakan untuk kunci utama kami Smallint, yang kami definisikan melalui @Column (type = "smallint") Anotasi di baris 13. Dua properti lainnya adalah $ first_name dan $ last_name, dan mereka didefinisikan dengan teknik yang sama. Mereka tipe rangkaian: Saat menggunakan mySQL, itu akan diterjemahkan ke Varchar tipe data basis data. Untuk referensi lengkap tentang asosiasi tipe data, Anda dapat berkonsultasi dengan halaman ini.

Saat menggunakan doktrin, visibilitas sifat -sifat kelas entitas bisa terlindung atau pribadi Tapi tidak publik.

Kami belum mendefinisikan getter dan setter untuk kelas. Tidak perlu melakukan itu secara manual, karena doktrin dapat melakukannya untuk kita, dan kita akan melihat bagaimana pada suatu saat, kita masih memiliki entitas lain untuk ditentukan, Pos:

Menyalin

Kami memperkenalkan dua tipe data baru. Yang pertama adalah teks Dalam baris 23 yang akan memetakan dan mengonversi data string tanpa panjang maksimum: Saat menggunakan mySQL, itu akan dikonversi ke LongText tipe data. Yang kedua adalah tanggal Waktu di baris 28, untuk kami $ tanggal Properti. Itu akan diterjemahkan ke dalam jenis yang sama untuk mysql, dan dalam contoh php Tanggal Waktu obyek.

Sekarang kita dapat menghasilkan getter dan setter kita tetapi sebelum kita melakukannya kita harus membuat CLI-Config.php skrip dalam akar proyek kami: diperlukan untuk menggunakan doktrin dari baris perintah:

Menyalin

Sekarang, buka shell terminal di direktori root proyek, dan jalankan perintah Linux berikut:

$ php vendor/bin/doktrin ORM: menghasilkan-entitas .

Perintah di atas akan menghasilkan getter dan setter untuk entitas yang ditemukan, dan akan menempatkannya di dalam direktori yang ditentukan. Sekarang, jika kita melihat Pengarang Entitas kita dapat melihat bahwa getters dan setter telah dihasilkan:

pengenal;  /*** Set FirstName. * * @param String $ firstName * * @return Author */ Fungsi publik setFirstName ($ firstName) $ this-> first_name = $ firstName; mengembalikan $ ini;  /*** Dapatkan nama depan. * * @return string */ fungsi publik getFirstName () return $ this-> first_name;  /*** Setel LastName. * * @param string $ lastName * * @return penulis */ fungsi publik setLastName ($ lastName) $ this-> last_name = $ lastName; mengembalikan $ ini;  /*** Dapatkan LastName. * * @return string */ fungsi publik getLastName () return $ this-> last_name;
Menyalin

Hal yang sama telah terjadi untuk Pos kesatuan:

pengenal;  /*** Tetapkan judul. * * @param string $ title * * @return Post */ Public Function Settitle ($ title) $ this-> title = $ title; mengembalikan $ ini;  /*** Dapatkan judul. * * @return string */ fungsi publik getTitle () return $ this-> title;  /*** Setel teks. * * @param string $ text * * @return Post */ Public Function Settext ($ text) $ this-> text = $ text; mengembalikan $ ini;  /*** Dapatkan teks. * * @return string */ fungsi publik getText () return $ this-> text;  /** * Atur tanggal. * * @param \ datetime $ date * * @return post */ setDate fungsi publik ($ date) $ this-> date = $ date; mengembalikan $ ini;  /*** Dapatkan tanggal. * * @return \ datetime */ fungsi publik getDate () return $ this-> date;
Menyalin

Mendefinisikan hubungan antara entitas

Sebagai contoh kami, kami ingin mendefinisikan a dua arah satu untuk banyak Hubungan antara entitas kita, di mana dua arah berarti bahwa setiap entitas memegang referensi ke yang lain. Hubungan antara penulis dan postingnya, banyak satu-ke-satu (seorang penulis dapat menulis banyak posting dan banyak posting dapat menjadi milik satu penulis). Menggunakan doktrin, mendefinisikan asosiasi seperti itu sangat sederhana:

Menyalin

Kami menambahkan satu properti baru di setiap entitas. Di penulis, itu $ posting di baris 16, dan di entitas pos, $ penulis dalam baris 36. Jenis data jenis apa yang akan dipegang oleh variabel -variabel tersebut? Yang pertama, $ posting akan menjadi contoh doktrin ArrayColletion Objek: Ini adalah kelas khusus yang digunakan untuk mengelola pengumpulan entitas dengan lebih baik.

Yang kedua, $ penulis, di dalam Pos.php, akan menjadi contoh entitas penulis, mewakili penulis pos: seperti yang dikatakan sebelumnya, masing -masing entitas memegang referensi ke yang lain.

Demikian pula dengan apa yang kami lakukan untuk properti lain, kami mendefinisikan hubungan dengan menggunakan anotasi. Dalam kasus kami, karena kami berurusan dengan hubungan satu-ke-banyak dua arah, kami menggunakan @Onetomany Anotasi di baris 13, di entitas penulis, dan @Manytoone di baris 32 di pos.

Dalam kedua kasus, dengan Target Kami mendefinisikan entitas apa yang ditunjuk oleh properti. Misalnya dalam kasus penulis $ posting properti, entitas target adalah pos. Seperti yang Anda lihat, kami menggunakan masing -masing terbalik Dan Mappedby Anotasi. Anotasi ini digunakan untuk memberi tahu doktrin properti apa, di sisi lain hubungan, mengacu pada objek: terbalik harus digunakan di sisi yang memiliki KUNCI ASING, (Dalam hal ini entitas pos).

Seperti yang Anda lihat, di penulis, kami gunakan Mappedby, Menentukan itu di entitas target Posting, properti yang sesuai $ penulis. Kami juga memperkenalkan parameter baru, riam, mengaturnya ke "semua". Ini berarti bahwa dengan bertahan atau menghapus entitas dari database, semua postingnya juga akan dipengaruhi: misalnya, menghapus pengguna juga akan menyebabkan penghapusan semua postingnya. Adalah apa yang kita definisikan melalui Di Hapus Cascade dalam kode SQL.

Sebaliknya, di entitas pasca, yang memegang kunci asing dalam database, kami gunakan terbalik, Memberitahu doktrin bahwa dalam penulis entitas target, properti yang mengacu pada objek adalah Posting. Kami juga telah menggunakan @Joincolumn Anotasi di baris 33, menentukan kolom yang terlibat dalam SQL Join, mengatur kunci asing sebagai tidak dapat dibatalkan (Bukan nol).

Setelah hubungan antara kedua entitas didefinisikan, kita harus memperbarui metode yang diperlukan untuk mengelola properti yang ditambahkan. Sekali lagi kami hanya menjalankan:

$ php vendor/bin/doktrin ORM: menghasilkan-entitas .

Menghasilkan skema basis data

Dalam contoh kami, kami memiliki cukup data untuk dapat menghasilkan skema basis data kami. Sekali lagi, doktrin dapat membantu kami, dengan secara otomatis menghasilkannya berdasarkan anotasi kami. Yang perlu kita lakukan, adalah menjalankan perintah Linux berikut:

$ php vendor/bin/doktrin ORM: schema-tool: update-force

Jika semuanya berjalan dengan baik, tabel basis data akan dihasilkan, mari kita verifikasi:

Mariadb [(tidak ada)]> Jelaskan blog.pengarang; +------------+--------------+------+-----+-------- -+ ----------------+ | Bidang | Ketik | Null | Kunci | Default | Ekstra | +------------+--------------+------+-----+-------- -+ ----------------+ | ID | Smallint (6) | Tidak | Pri | Null | auto_increment | | first_name | Varchar (255) | Tidak | | Null | | | last_name | Varchar (255) | Tidak | | Null | | +------------+--------------+------+-----+-------- -+ ----------------+ mariadb [(tidak ada)]> Jelaskan blog.pos; +-----------+--------------+------+-----+--------- + ----------------+ | Bidang | Ketik | Null | Kunci | Default | Ekstra | +-----------+--------------+------+-----+--------- + ----------------+ | ID | Smallint (6) | Tidak | Pri | Null | auto_increment | | Author_id | Smallint (6) | Tidak | Mul | Null | | | Judul | Varchar (255) | Tidak | | Null | | | teks | LongText | Tidak | | Null | | | Tanggal | Datetime | Tidak | | Null | | +-----------+--------------+------+-----+---------+----------------+
Menyalin

Seperti yang diharapkan tabel yang sesuai dengan entitas kami telah dihasilkan, dan mencerminkan anotasi yang kami tentukan. Kode SQL yang digunakan untuk menghasilkannya masing -masing:

Mariadb [(tidak ada)]> tampilkan blog tabel create tabel.pengarang; Tabel: Penulis Buat Tabel: Buat tabel 'penulis' ('id' smallint (6) bukan null auto_increment, 'first_name' varchar (255) rekan dengan utf8_unicode_ci not null, 'last_name' varchar (255) rekan dengan utf8_unicode_ci bukan null, kunci primer (primaryy (255) 'id')) engine = innodb auto_increment = 2 charset default = utf8 rekan = utf8_unicode_ci mariadb [(tidak ada)]> tampilkan membuat tabel blog.pos; Tabel: Posting Buat Tabel: Buat tabel 'pos' ('id' smallint (6) bukan null auto_increment, 'author_id' smallint (6) not null, 'title' varchar (255) rekan dengan utf8_unicode_ci bukan nol, 'teks' longtext rekan utf8_unicode_ci NOT NULL, 'date' datetime NOT NULL, PRIMARY KEY ('id'), KEY 'IDX_5A8A6C8DF675F31B' ('author_id'), CONSTRAINT 'FK_5A8A6C8DF675F31B' FOREIGN KEY ('author_id') REFERENCES 'author' ('id') ) Engine = innodb auto_increment = 2 charset default = utf8 collate = utf8_unicode_ci
Menyalin

Menggunakan Manajer Entitas

Sekarang saatnya menunjukkan cara menggunakan Manajer Entitas:

setFirstName ("John") -> setLastName ("Smith"); $ Entity_Manager-> Sygn ($ author); // Buat posting baru $ post = (entitas baru \ post ()) -> setTitle ("Hello Wold") -> Settext ("Ini adalah Posting Uji") -> SetAuthor ($ OUTHOR) -> SETDATE (BARU Tanggal Waktu()); // Tambahkan posting ke daftar posting penulis. Karena kami menggunakan cascade = "all", kami // tidak perlu bertahan secara terpisah: itu akan bertahan ketika bertahan // penulis $ author-> addPost ($ post); // akhirnya menyiram dan menjalankan transaksi basis data $ entity_manager-> flush ();
Menyalin

Mengeksekusi kode ini kami membuat penulis dan posting pertamanya, lalu kami menambahkan posting ke koleksi posting penulis dan akhirnya kami tetap menggunakannya ke database. Dengan bertahan () metode kami memberi tahu doktrin untuk mengelola entitas, sedangkan transaksi basis data yang sebenarnya hanya terjadi saat menelepon menyiram(). Jika sekarang kita melihat pengarang Dan pos Tabel, kita dapat melihat bahwa ada catatan baru di keduanya:

Mariadb [(tidak ada)]> pilih * dari blog.pengarang; +----+------------+-----------+| ID | first_name | last_name | +----+------------+-----------+| 1 | John | Smith | +----+------------+-----------+mariadb [(tidak ada)]> Pilih * dari blog.pos; +----+-----------+------------+------------------- -+ ---------------------+ | ID | Author_id | Judul | teks | Tanggal | +----+-----------+------------+------------------- -+ ---------------------+ | 1 | 1 | Halo Wold | Ini adalah tes Post | 2018-04-17 08:37:44 | +----+-----------+------------+---------------------+---------------------+
Menyalin

Kami juga dapat menggunakan Entity Manager untuk mengambil entitas yang ada, misalnya:

// Ambil penulis dengan nama belakangnya $ author = $ entity_manager-> getRepository ('entitas \ penulis')-> findOneBy (['last_name' => 'smith']);
Menyalin

Kesimpulan

Tujuan dari tutorial ini adalah untuk memperkenalkan Anda pada pola data mapper dalam php menggunakan doktrin: kami melihat cara mengkonfigurasi dan mendapatkan manajer entitas, cara mendefinisikan dua entitas dasar dan mendefinisikan hubungan umum di antara mereka melalui anotasi.

Doktrin adalah perpustakaan yang sangat kuat: Anda dapat menggunakan dokumentasi proyek untuk mulai menguasainya, semoga ini bisa menjadi titik awal minimal.

Tutorial Linux Terkait:

  • Hal -hal yang harus diinstal pada ubuntu 20.04
  • Instalasi ampache raspberry pi
  • Cara membuat tumpukan lampu berbasis Docker menggunakan Docker di…
  • Cara memasang tumpukan lampu di almalinux
  • Hal -hal yang harus dilakukan setelah menginstal ubuntu 20.04 FOSSA FOSSA Linux
  • Pengantar Otomatisasi Linux, Alat dan Teknik
  • Ubuntu 20.04 trik dan hal -hal yang mungkin tidak Anda ketahui
  • Mint 20: Lebih baik dari Ubuntu dan Microsoft Windows?
  • Manipulasi data besar untuk kesenangan dan keuntungan bagian 1
  • Ubuntu 20.04 WordPress dengan Instalasi Apache