Bermula dengan Pembangunan Sambungan PHP melalui PHP-CPP

Dalam urusan anda dengan PHP, anda mungkin akan mempertimbangkan untuk menulis lanjutan PHP sendiri. Terdapat beberapa sebab yang boleh saya fikirkan yang mendorong saya untuk berbuat demikian:

untuk memperluaskan fungsi PHP untuk beberapa penggunaan yang sangat khusus (matematik, statistik, geometri, dll).
mempunyai prestasi dan kecekapan yang lebih tinggi berbanding pelaksanaan PHP tulen
untuk memanfaatkan kepelbagaian yang diperoleh daripada pengaturcaraan dalam bahasa yang lain yang sebelumnya dipegang (untuk saya, c).

Ketika memilih alat untuk membina sambungan PHP, kita melihat dua pendekatan yang berbeza:

Gunakan lebih banyak semantik pro-PHP, seperti Zephir.
Gunakan lebih banyak pro-c/c semantik, seperti PHP-CPP, yang akan ditangani dalam artikel ini.

Bagi saya, pemacu utama untuk memilih pendekatan kedua adalah mudah: Saya memulakan hobi pengaturcaraan saya dengan C/C, jadi saya masih merasa lebih selesa menulis modul tahap rendah dalam C/C. Laman rasmi PHP-CPP memberikan beberapa sebab lain untuk berbuat demikian.

Takeaways Key

PHP-CPP adalah perpustakaan untuk membangunkan sambungan PHP yang membolehkan pemaju untuk menulis sambungan PHP tanpa kerumitan bekerja secara langsung dengan API ZEND. Ia ditulis dalam C 11 dan menawarkan koleksi kelas yang didokumentasikan dengan baik dan mesra pengguna.
PHP-CPP berkembang pesat dan disyorkan untuk menggunakan Git untuk mengklon repositori untuk kemas kini terkini. Ia menyokong pemasangan PHP tunggal dan memerlukan peningkatan kepada pengkompil G ke versi 4.8.x atau ke atas untuk keserasian.
PHP-CPP menyediakan projek lanjutan rangka, yang termasuk fail main.cpp, membuat fail untuk menyusun pelanjutan, dan fail .ini untuk pemuatan lanjutan. Projek Skeleton boleh disesuaikan untuk memenuhi keperluan individu dan disusun dan dipasang dengan perintah 'Make && Sudo Make Install'.
PHP-CPP menyokong empat jenis tandatangan fungsi yang akan dipanggil dari PHP dan membolehkan parameter diluluskan oleh nilai dalam bentuk array. Ia juga membolehkan eksport/pendaftaran fungsi, spesifikasi jenis parameter fungsi, dan penciptaan sambungan berorientasikan objek.

Pemasangan dan Konfigurasi

PHP-CPP berkembang pesat. Pada masa penulisan artikel ini, ia berada dalam versi 0.9.1 (dengan 0.9.0 dikeluarkan kira -kira 2 hari sebelum ini). Menurut dokumentasinya, "Ini adalah pelepasan ciri-ciri yang disediakan untuk versi V1.0 yang akan datang", jadi kami yakin kami akan melihat 1.0 pelepasan utama tidak lama lagi.

Oleh itu, disyorkan, sekurang -kurangnya dalam tempoh interim ini, untuk menggunakan Git untuk mengklon repositori dan mendapatkan kemas kini terkini kemudian melalui Pull Git.

NOTA: Dokumentasi PHP-CPP pada pemasangan menyatakan bahawa pada masa ini, ia "hanya menyokong pemasangan PHP tunggal" kerana "secara dalaman enjin Zend menggunakan sistem yang sangat ganjil untuk memastikan keselamatan benang". Siaran masa depan boleh menyokong pemasangan PHP pelbagai threaded tetapi mari kita ingat ini untuk sekarang dan berpegang pada batasan semasa. Nasib baik, "Pemasangan PHP Single-Threaded" sepatutnya menjadi kes bagi kebanyakan pemasangan PHP di luar sana.

php-cpp ditulis dalam C 11. Oleh itu, versi lama G yang dipasang di Ubuntu 12.04 LTS saya tidak menyokongnya. Kita perlu menaik taraf pengkompil G kami ke versi 4.8.x di atas. Terdapat artikel yang memperincikan langkah -langkah untuk melakukan peningkatan. Sila ikuti arahan yang disenaraikan di sana.

Juga, kompilasi PHP-CPP akan menggunakan fail header php.h. Fail ini biasanya hilang dalam kotak Ubuntu, kecuali PHP-DEV dipasang. Kami boleh memasang fail pembangunan berkaitan PHP5 dengan mengeluarkan arahan ini:

<span>sudo apt-get install php5-dev</span>

Selepas menaik taraf G dan memasang fail header yang diperlukan, kami boleh mengeluarkan arahan berikut untuk menyusun dan memasang fail perpustakaan php-cpp (libphpcpp.so):

<span>make && sudo make install</span>

Penyusunan akan agak cepat. Selepas pemasangan, fail libphpcpp.so akan disalin ke/usr/lib, dan semua fail header php-cpp akan disalin ke/usr/termasuk dan/usr/termasuk/phpcpp folder.

Pemasangan php-cpp lib kini selesai. Ia agak mudah dan kini kita boleh beralih ke bahagian pengaturcaraan.

Sebelum kita berbuat demikian, kita akan membincangkan beberapa konsep dan terminologi penting yang digunakan dalam PHP-CPP. Dokumentasi penuh boleh didapati di laman web rasminya, dan semua orang digalakkan untuk membacanya sebelum melakukan pengaturcaraan sebenar.

fail projek lanjutan (kosong)

php-cpp menyediakan projek lanjutan rangka, yang mengandungi 3 fail berikut:

main.cpp: Fail CPP utama yang mengandungi fungsi get_module (akan dibincangkan dengan lebih terperinci kemudian)
makefile: sampel membuat fail untuk menyusun lanjutan
yourextension.ini: mengandungi hanya satu baris untuk memuatkan lanjutan

Makefile

Jika anda sudah biasa dengan perkembangan *nix, anda sudah biasa dengan makefile ini. Beberapa perubahan sedikit akan dibuat untuk menyesuaikan fail ini agar sesuai dengan keperluan kita:

Tukar nama = YourExtension ke yang lebih bermakna, seperti Name = Skeleton.
Tukar ini_dir = /etc/php5/conf.d untuk memadankan konfigurasi sistem anda. Dalam kes saya, ia adalah ini_dir = /etc/php5/cli/conf.d. Saya mengubahsuai laluan INI untuk membolehkan lanjutan untuk persekitaran CLI PHP terlebih dahulu.

Ini adalah semua perubahan yang telah saya buat. Selebihnya Makefile boleh disimpan seperti itu.

yourextension.ini

saya menamakan semula fail ini ke skeleton.ini dan menukar satu -satunya baris dalam fail seperti ini:

<span>sudo apt-get install php5-dev</span>

main.cpp

Dalam projek kosong yang disediakan oleh PHP-CPP, fail ini hanya mengandungi satu fungsi: get_module (), yang dikutip di bawah:

<span>make && sudo make install</span>

Buat masa ini, mari kita ubah garis ini untuk memadankan nama lanjutan yang kami ingin buat:

<span>extension=skeleton.so</span>

get_module () dipanggil oleh PHP apabila yang terakhir cuba memuatkan perpustakaan yang diperlukan. Ia dianggap titik masuk untuk lib. Ia diisytiharkan menggunakan pengubahsuaian Extern "C" untuk mematuhi keperluan PHP LIB untuk fungsi get_module (). Ia juga menggunakan makro phpcpp_export yang memastikan bahawa get_module () dieksport secara terbuka, dan dengan itu boleh dipanggil oleh php.

Setakat ini, kami telah membuat beberapa perubahan kepada projek kosong untuk memenuhi keperluan kami. Kami kini boleh menyusun dan memasang projek ini dan memasang pelanjutan:

<span><span>#include <phpcpp.h></span>
</span>
<span>/**
</span><span> *  tell the compiler that the get_module is a pure C function
</span><span> */
</span><span>extern "C" {
</span>
    <span>/**
</span><span>     *  Function that is called by PHP right after the PHP process
</span><span>     *  has started, and that returns an address of an internal PHP
</span><span>     *  strucure with all the details and features of your extension
</span><span>     *
</span><span>     *  @return void*   a pointer to an address that is understood by PHP
</span><span>     */
</span>    PHPCPP_EXPORT <span>void *get_module() 
</span>    <span>{
</span>        <span>// static(!) Php::Extension object that should stay in memory
</span>        <span>// for the entire duration of the process (that's why it's static)
</span>        <span>static Php::Extension extension("yourextension", "1.0");
</span>
        <span>// @todo    add your own functions, classes, namespaces to the extension
</span>
        <span>// return the extension
</span>        <span>return extension;
</span>    <span>}
</span><span>}  </span>

Seterusnya, kita perlu menyalin fail yang diperlukan ke dalam folder yang sesuai:

<span>static Php::Extension extension("skeleton", "1.0"); // To be humble, we can change the version number to 0.0.1</span>

kita hanya perlu memastikan bahawa skeleton.so lib disalin ke lokasi yang betul dari sambungan PHP (dalam persediaan Ubuntu saya, ia harus/usr/lib/php5/20121212 seperti yang ditunjukkan di atas).

kita boleh mengesahkan pelanjutan dimuatkan dalam CLI oleh php -i | rangka grep, dan terminal akan memaparkan sesuatu seperti ini:

(ingat bahawa skeleton.ini adalah fail yang kami diubahsuai di atas, yang mengandungi lanjutan = skeleton.so line.)

kami telah menyusun dan memasang pelanjutan PHP pertama kami menggunakan PHP-CPP. Sudah tentu, lanjutan ini tidak dilakukan. Kami kini akan mewujudkan beberapa fungsi pertama kami untuk lebih memahami proses membina sambungan PHP.

fungsi "hello, taylor"

Fungsi pertama yang kami buat akan menjadi versi "Hello, World" yang sedikit diubahsuai. Mari lihat kod penuh Main.cpp terlebih dahulu:

<span>make && sudo make install</span>

Menurut dokumentasi PHP-CPP pada "Daftar Fungsi Native", ia menyokong empat jenis tandatangan fungsi yang akan dipanggil dari PHP:

<span>cp -f skeleton.so /usr/lib/php5/20121212
</span><span>cp -f skeleton.ini /etc/php5/cli/conf.d</span>

Dalam kes ini, saya menggunakan tandatangan kedua dan parameter diluluskan oleh nilai dalam bentuk array (ciri PHP).

Walau bagaimanapun, di Helloworld, kami telah menggunakan jenis C Jenis STD :: String untuk merebut parameter pertama. Kami juga telah menggunakan C STD LIB untuk mengeluarkan mesej yang mengalu -alukan.

Dalam fungsi get_module (), selepas mengisytiharkan pemboleh ubah lanjutan, kami menambah fungsi yang kami ingin mengeksport (HelloWorld ()) dan memberikan nama yang dapat dilihat pada skrip PHP (HelloWorld).

Sekarang mari kita menyusun dan memasang pelanjutan. Jika semuanya berjalan lancar, fail skeleton baru akan disalin ke direktori lanjutan.

kita boleh menulis skrip mudah untuk menguji fungsi yang baru dibuat:

sila luangkan sedikit masa untuk melihat output:

<span><span>#include <phpcpp.h></span>
</span><span><span>#include <iostream></span>
</span>
<span>void helloWorld (Php::Parameters &params)
</span><span>{
</span>    std<span>::string name=params[0];
</span>    std<span>::cout<<"Hello "<<name<<"!"<<std::endl;
</span>
<span>}
</span>
<span>extern "C" {
</span>
    PHPCPP_EXPORT <span>void *get_module() 
</span>    <span>{
</span>        <span>static Php::Extension extension("skeleton", "1.0");
</span>        extension<span>.add("helloWorld", helloWorld);
</span>
        <span>return extension;
</span>    <span>}
</span><span>}</span>

kita akan kembali kepada apa yang telah kita perhatikan di sini kemudian.

Parameter fungsi dengan rujukan

Seterusnya, kita akan melihat fungsi lain yang melewati parameter dengan rujukan, fungsi swap (). Dalam fungsi ini, kami juga akan cuba menentukan bilangan parameter dan jenis mereka.

Di main.cpp, kami menambah satu lagi fungsi swap ():

<span>sudo apt-get install php5-dev</span>

dan juga mengeksport fungsi dengan menentukan bilangan parameter dan jenis mereka:

<span>make && sudo make install</span>

kita secara eksplisit mengatakan bahawa:

• Akan ada dua parameter (a dan b);
• mereka harus diluluskan dengan rujukan (bukan dengan nilai);
• mereka harus jenis angka.

mari kita menyusun dan memasang pelanjutan yang dikemas kini sekali lagi dan tulis beberapa coretan kod untuk melihat bagaimana fungsi baru ini berfungsi:

<span>extension=skeleton.so</span>

swap ($ a) akan gagal. Ini dijangka dan tidak dijangka. Bahagian yang diharapkan ialah kita memerlukan dua parameter dan hanya satu yang diberikan. Tetapi, tidakkah kesilapan itu ditangkap oleh PHP apabila memanggil swap fungsi dan mendorong kita sesuatu seperti parameter yang tidak mencukupi?

Panggilan pertama (swap ($ a, $ b)) menunjukkan hasil yang diharapkan: 20 | 10. Fungsi bertukar dua nombor yang diluluskan.

Panggilan kedua entah bagaimana tidak dijangka: Kami telah memberitahu PHP bahawa kita harus menukar dua nombor! Tetapi ia hanya mengabaikan hakikat bahawa parameter ke -2 yang diluluskan adalah rentetan dan melakukan pertukaran pula!

Nah, dengan cara, ia masih dijangka. PHP tidak benar -benar membezakan jenis nombor dan jenis rentetan. Tingkah laku ini mematuhi piawaian PHP. Juga disebabkan oleh tingkah laku ini, kami tidak dan tidak boleh menggunakan jenis dalaman C untuk pembolehubah sementara yang digunakan dalam fungsi (temp) tetapi menggunakan Php :: nilai sebagai jenis pembolehubah.

Panggilan ketiga akan berfungsi. VAR_DUMP pertama akan menunjukkan objek DateTime dan yang kedua akan menunjukkan integer. Ini entah bagaimana sangat tidak dijangka (sekurang -kurangnya kepada saya). Lagipun, objek agak berbeza dari nombor/rentetan. Tetapi selepas mempertimbangkan bahawa tingkah laku "swap" ini juga boleh dilakukan di PHP, ia sesuai dengan keanehan PHP.

Jadi, adakah ia bermakna spesifikasi "jenis" tidak akan memberi kesan? Tidak betul -betul. Untuk menerangkan lagi ini, kami membuat fungsi ketiga:

<span><span>#include <phpcpp.h></span>
</span>
<span>/**
</span><span> *  tell the compiler that the get_module is a pure C function
</span><span> */
</span><span>extern "C" {
</span>
    <span>/**
</span><span>     *  Function that is called by PHP right after the PHP process
</span><span>     *  has started, and that returns an address of an internal PHP
</span><span>     *  strucure with all the details and features of your extension
</span><span>     *
</span><span>     *  @return void*   a pointer to an address that is understood by PHP
</span><span>     */
</span>    PHPCPP_EXPORT <span>void *get_module() 
</span>    <span>{
</span>        <span>// static(!) Php::Extension object that should stay in memory
</span>        <span>// for the entire duration of the process (that's why it's static)
</span>        <span>static Php::Extension extension("yourextension", "1.0");
</span>
        <span>// @todo    add your own functions, classes, namespaces to the extension
</span>
        <span>// return the extension
</span>        <span>return extension;
</span>    <span>}
</span><span>}  </span>

dan kami mendaftarkan fungsi ini seperti ini:

<span>static Php::Extension extension("skeleton", "1.0"); // To be humble, we can change the version number to 0.0.1</span>

kod ujian akan seperti ini:

<span>make && sudo make install</span>

Panggilan pertama ke SwapObject () akan berfungsi seperti yang kita lalui dalam jenis kelas yang betul (SampleClass). Yang kedua akan gagal, memaparkan "PHP Ralat Fatal yang Boleh Ditangkap: Argumen 1 Lulus ke SwapObject () mestilah contoh SampleClass, contoh lain yang diberikan ...".

Segmen kod di atas menggambarkan satu aspek penting pada sekatan jenis: Pengisytiharan jenis skalar tidak benar -benar dilaksanakan. PHP dan oleh itu PHP-CPP hanya menguatkuasakan pengisytiharan jenis objek. Juga, bilangan parameter tidak dikuatkuasakan di sisi PHP.

Kesimpulan

Dalam artikel ini, kami menggambarkan langkah-langkah untuk menyediakan PHP-CPP untuk bekerja untuk persekitaran PHP kami. Kami juga membincangkan beberapa langkah asas untuk membuat lanjutan PHP menggunakan PHP-CPP (dan C semantik).

Kami meliputi fail projek lanjutan, tandatangan fungsi, eksport/pendaftaran fungsi, dan jenis parameter fungsi.

Dalam artikel seterusnya, kami akan menerangkan beberapa ciri utama dalam PHP-CPP dan menyediakan kes penggunaan dunia nyata yang menunjukkan penggunaan kelas C dan pelaksanaan ruang nama menggunakan PHP-CPP.

Soalan Lazim (Soalan Lazim) mengenai Pembangunan Sambungan PHP

Apakah php-cpp dan bagaimana ia berbeza dari php?

php-cpp adalah perpustakaan untuk membangunkan sambungan PHP. Ia menawarkan koleksi kelas yang didokumentasikan dengan baik dan mesra pengguna, yang membolehkan pemaju C menulis sambungan PHP tanpa kerumitan bekerja secara langsung dengan API Zend. Tidak seperti PHP, yang merupakan bahasa yang ditafsirkan, PHP-CPP membolehkan anda menulis kod dalam C, bahasa yang disusun. Ini boleh mengakibatkan penambahbaikan prestasi, seperti kod yang disusun secara amnya berjalan lebih cepat daripada kod yang ditafsirkan.

Bagaimana saya memasang php-cpp pada sistem saya? Perlu mengklonkan repositori PHP-CPP dari GitHub. Selepas pengklonan, navigasi ke direktori dan laksanakan perintah 'membuat'. Sebaik sahaja proses binaan selesai, pasang perpustakaan menggunakan arahan 'Make Install'. Ingat, anda perlu mempunyai keistimewaan root untuk memasang perpustakaan.

Bagaimana saya membuat lanjutan PHP asas menggunakan php-cpp?

Membuat lanjutan PHP menggunakan PHP-CPP melibatkan beberapa langkah. Pertama, anda perlu membuat direktori untuk lanjutan anda dan menavigasi ke dalamnya. Kemudian, buat 'makefile' dan fail sumber C untuk pelanjutan anda. 'Makefile' akan mengandungi arahan untuk membina pelanjutan anda, manakala fail sumber C akan mengandungi kod sebenar untuk pelanjutan anda. Selepas menulis kod anda, anda boleh membina pelanjutan anda menggunakan perintah 'Make'. RE berurusan dengan bahasa yang disusun. Walau bagaimanapun, anda boleh menggunakan alat seperti GDB (GNU Debugger) untuk debug pelanjutan anda. GDB membolehkan anda menetapkan titik putus, melangkah melalui kod anda, dan memeriksa pembolehubah, yang boleh sangat membantu apabila cuba mengesan pepijat.

Ya, PHP-CPP serasi dengan Php 7. Namun, anda perlu memastikan bahawa anda menggunakan versi terkini PHP-CPP, kerana versi terdahulu mungkin tidak menyokong Php 7.

Bagaimana saya boleh mengendalikan pengecualian dalam php-cpp?

php-cpp Menyediakan kelas yang dipanggil php :: pengecualian, yang boleh anda gunakan untuk membuang pengecualian dari kod C anda. Pengecualian ini kemudiannya boleh ditangkap dan dikendalikan dalam kod PHP anda, sama seperti pengecualian PHP yang lain.

Bolehkah saya menggunakan php-cpp untuk membuat sambungan berorientasikan objek? Anda boleh menentukan kelas dalam kod C anda, dan kelas ini kemudiannya boleh digunakan dalam kod PHP anda. Ini membolehkan anda menulis kod modular yang bersih dan mudah dipelihara. Anda boleh gunakan untuk memanggil fungsi PHP dari kod C anda. Ini membolehkan anda memanfaatkan kuasa fungsi terbina dalam PHP dalam lanjutan anda. CPP untuk membuat sambungan yang berinteraksi dengan pangkalan data. Walau bagaimanapun, anda perlu menggunakan perpustakaan pangkalan data C, kerana PHP-CPP tidak menyediakan sebarang fungsi pangkalan data terbina dalam. VE membina sambungan PHP anda, anda boleh mengedarkannya dengan membungkusnya sebagai pakej PECL. PECL adalah repositori untuk sambungan PHP, dan ia menyediakan cara standard untuk mengedarkan dan memasang sambungan.

Atas ialah kandungan terperinci Bermula dengan Pembangunan Sambungan PHP melalui PHP-CPP. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!