predis

เปรดิส

ไคลเอนต์ Redis ที่ยืดหยุ่นและมีคุณสมบัติครบถ้วนสำหรับ PHP 7.2 และใหม่กว่า

รายละเอียดเพิ่มเติมเกี่ยวกับโครงการนี้สามารถพบได้ในคำถามที่พบบ่อย

คุณสมบัติหลัก

• รองรับ Redis จาก 3.0 เป็น 7.4
• รองรับการทำคลัสเตอร์โดยใช้การแบ่งส่วนฝั่งไคลเอ็นต์และผู้จัดจำหน่ายคีย์สเปซแบบเสียบได้
• รองรับคลัสเตอร์ Redis (Redis >= 3.0)
• รองรับการตั้งค่าการจำลองแบบ master-slave และ redis-sentinel
• คำนำหน้าคีย์แบบโปร่งใสโดยใช้กลยุทธ์คำนำหน้าที่ปรับแต่งได้
• สั่งไปป์ไลน์บนทั้งโหนดเดี่ยวและคลัสเตอร์ (การแบ่งส่วนฝั่งไคลเอ็นต์เท่านั้น)
• สิ่งที่เป็นนามธรรมสำหรับธุรกรรม Redis (Redis >= 2.0) และการดำเนินงาน CAS (Redis >= 2.2)
• นามธรรมสำหรับสคริปต์ Lua (Redis >= 2.6) และการสลับอัตโนมัติระหว่าง EVALSHA หรือ EVAL
• นามธรรมสำหรับ SCAN , SSCAN , ZSCAN และ HSCAN (Redis >= 2.8) ตามตัววนซ้ำ PHP
• การเชื่อมต่อถูกสร้างขึ้นอย่างเกียจคร้านโดยไคลเอนต์ตามคำสั่งแรกและสามารถคงอยู่ได้
• สามารถสร้างการเชื่อมต่อผ่าน TCP/IP (รวมถึงการเข้ารหัส TLS/SSL) หรือซ็อกเก็ตโดเมน UNIX
• รองรับคลาสการเชื่อมต่อแบบกำหนดเองสำหรับการจัดเตรียมเครือข่ายหรือแบ็กเอนด์โปรโตคอลที่แตกต่างกัน
• ระบบที่ยืดหยุ่นสำหรับการกำหนดคำสั่งแบบกำหนดเองและแทนที่คำสั่งเริ่มต้น

วิธี ติดตั้ง และใช้งาน Predis

ไลบรารีนี้สามารถพบได้บน Packagist เพื่อการจัดการการพึ่งพาโปรเจ็กต์ที่ง่ายขึ้นโดยใช้ Composer ไฟล์เก็บถาวรที่บีบอัดของแต่ละรีลีสมีอยู่ใน GitHub

composer require predis/predis

กำลังโหลดห้องสมุด

Predis อาศัยคุณสมบัติการโหลดอัตโนมัติของ PHP เพื่อโหลดไฟล์เมื่อจำเป็นและเป็นไปตามมาตรฐาน PSR-4 การโหลดอัตโนมัติจะได้รับการจัดการโดยอัตโนมัติเมื่อมีการจัดการการขึ้นต่อกันผ่าน Composer แต่ยังเป็นไปได้ที่จะใช้ประโยชน์จากตัวโหลดอัตโนมัติของตัวเองในโปรเจ็กต์หรือสคริปต์ที่ไม่มีระบบโหลดอัตโนมัติ:

 // Prepend a base path if Predis is not available in your "include_path".
require ' Predis/Autoloader.php ' ;

Predis Autoloader:: register ();

กำลังเชื่อมต่อกับ Redis

เมื่อสร้างอินสแตนซ์ไคลเอ็นต์โดยไม่ผ่านพารามิเตอร์การเชื่อมต่อใดๆ Predis จะถือว่า 127.0.0.1 และ 6379 เป็นโฮสต์และพอร์ตเริ่มต้น การหมดเวลาเริ่มต้นสำหรับการดำเนินการ connect() คือ 5 วินาที:

 $ client = new Predis  Client ();
$ client -> set ( ' foo ' , ' bar ' );
$ value = $ client -> get ( ' foo ' );

พารามิเตอร์การเชื่อมต่อสามารถระบุได้ในรูปแบบของสตริง URI หรืออาร์เรย์ที่มีชื่อ วิธีหลังเป็นวิธีที่แนะนำในการจัดหาพารามิเตอร์ แต่สตริง URI อาจมีประโยชน์เมื่ออ่านพารามิเตอร์จากแหล่งที่มาที่ไม่มีโครงสร้างหรือมีโครงสร้างบางส่วน:

 // Parameters passed using a named array:
$ client = new Predis  Client ([
    ' scheme ' => ' tcp ' ,
    ' host '   => ' 10.0.0.1 ' ,
    ' port '   => 6379 ,
]);

// Same set of parameters, passed using an URI string:
$ client = new Predis  Client ( ' tcp://10.0.0.1:6379 ' );

สามารถเข้าถึงเซิร์ฟเวอร์ที่ป้องกันด้วยรหัสผ่านได้โดยการเพิ่ม password ให้กับพารามิเตอร์ที่ตั้งไว้ เมื่อเปิดใช้งาน ACL บน Redis >= 6.0 จะต้องใช้ทั้ง username และ password สำหรับการตรวจสอบสิทธิ์ผู้ใช้

นอกจากนี้ยังสามารถเชื่อมต่อกับอินสแตนซ์ Redis ภายในเครื่องได้โดยใช้ซ็อกเก็ตโดเมน UNIX ในกรณีนี้ พารามิเตอร์ต้องใช้รูปแบบ unix และระบุเส้นทางสำหรับไฟล์ซ็อกเก็ต:

 $ client = new Predis  Client ([ ' scheme ' => ' unix ' , ' path ' => ' /path/to/redis.sock ' ]);
$ client = new Predis  Client ( ' unix:/path/to/redis.sock ' );

ไคลเอนต์สามารถใช้ประโยชน์จากการเข้ารหัส TLS/SSL เพื่อเชื่อมต่อกับอินสแตนซ์ Redis ระยะไกลที่ปลอดภัย โดยไม่จำเป็นต้องกำหนดค่าพร็อกซี SSL เช่น Stunnel สิ่งนี้มีประโยชน์เมื่อเชื่อมต่อกับโหนดที่ทำงานบนผู้ให้บริการโฮสติ้งคลาวด์หลายราย คุณสามารถเปิดใช้งานการเข้ารหัสได้โดยใช้รูปแบบ tls และอาร์เรย์ของตัวเลือกที่เหมาะสมที่ส่งผ่านพารามิเตอร์ ssl :

 // Named array of connection parameters:
$ client = new Predis  Client ([
  ' scheme ' => ' tls ' ,
  ' ssl '    => [ ' cafile ' => ' private.pem ' , ' verify_peer ' => true ],
]);

// Same set of parameters, but using an URI string:
$ client = new Predis  Client ( ' tls://127.0.0.1?ssl[cafile]=private.pem&ssl[verify_peer]=1 ' );

รองรับรูปแบบการเชื่อมต่อ redis (นามแฝงของ tcp ) และ rediss (นามแฝงของ tls ) ด้วยเช่นกัน โดยมีความแตกต่างที่สตริง URI ที่มีรูปแบบเหล่านี้จะถูกแยกวิเคราะห์ตามกฎที่อธิบายไว้ในเอกสารการลงทะเบียนชั่วคราวของ IANA ที่เกี่ยวข้อง

รายการพารามิเตอร์การเชื่อมต่อที่รองรับจริงอาจแตกต่างกันไปขึ้นอยู่กับแบ็กเอนด์การเชื่อมต่อแต่ละรายการ ดังนั้นจึงขอแนะนำให้ดูเอกสารประกอบเฉพาะหรือการใช้งานเพื่อดูรายละเอียด

Predis สามารถรวมการเชื่อมต่อหลายรายการได้เมื่อจัดเตรียมอาร์เรย์ของพารามิเตอร์การเชื่อมต่อและตัวเลือกที่เหมาะสมเพื่อแนะนำไคลเอ็นต์เกี่ยวกับวิธีรวมการเชื่อมต่อเหล่านั้น (การทำคลัสเตอร์ การจำลองแบบ หรือตรรกะการรวมแบบกำหนดเอง) อาร์เรย์ที่มีชื่อและสตริง URI สามารถผสมกันได้เมื่อจัดเตรียมการกำหนดค่าสำหรับแต่ละโหนด:

 $ client = new Predis  Client ([
    ' tcp://10.0.0.1?alias=first-node ' , [ ' host ' => ' 10.0.0.2 ' , ' alias ' => ' second-node ' ],
], [
    ' cluster ' => ' predis ' ,
]);

ดูส่วนการเชื่อมต่อโดยรวมของเอกสารนี้สำหรับรายละเอียดเพิ่มเติม

การเชื่อมต่อกับ Redis นั้นขี้เกียจ หมายความว่าไคลเอนต์เชื่อมต่อกับเซิร์ฟเวอร์เฉพาะเมื่อจำเป็นเท่านั้น แม้ว่าจะมีการแนะนำให้ให้ลูกค้าทำสิ่งต่าง ๆ ของตัวเองภายใต้ประทุน แต่ก็มีบางครั้งที่ยังคงต้องการการควบคุมว่าการเชื่อมต่อจะเปิดหรือปิดเมื่อใด ซึ่งสามารถทำได้ง่าย ๆ โดยการเรียกใช้ $client->connect() และ $client->disconnect() โปรดทราบว่าผลกระทบของวิธีการเหล่านี้ต่อการเชื่อมต่อแบบรวมอาจแตกต่างกันไปขึ้นอยู่กับการใช้งานเฉพาะแต่ละอย่าง

การกำหนดค่าไคลเอ็นต์

สามารถกำหนดค่าลักษณะและพฤติกรรมหลายประการของไคลเอนต์ได้โดยการส่งตัวเลือกไคลเอนต์เฉพาะไปยังอาร์กิวเมนต์ที่สองของ PredisClient::__construct() :

 $ client = new Predis  Client ( $ parameters , [ ' prefix ' => ' sample: ' ]);

ตัวเลือกได้รับการจัดการโดยใช้คอนเทนเนอร์ขนาดเล็ก DI-alike และสามารถกำหนดค่าเริ่มต้นได้อย่างเกียจคร้านเมื่อจำเป็นเท่านั้น ตัวเลือกไคลเอนต์ที่รองรับโดยค่าเริ่มต้นใน Predis คือ:

• prefix : สตริงคำนำหน้าใช้กับทุกคีย์ที่พบในคำสั่ง
• exceptions : ไม่ว่าไคลเอ็นต์ควรโยนหรือส่งคืนการตอบกลับเมื่อมีข้อผิดพลาด Redis หรือไม่
• connections : รายการแบ็กเอนด์การเชื่อมต่อหรืออินสแตนซ์โรงงานการเชื่อมต่อ
• cluster : ระบุแบ็กเอนด์คลัสเตอร์ ( predis , redis หรือ callable)
• replication : ระบุแบ็กเอนด์การจำลอง ( predis , sentinel หรือ callable)
• aggregate : กำหนดค่าไคลเอนต์ด้วยการเชื่อมต่อรวมแบบกำหนดเอง (เรียกได้)
• parameters : รายการพารามิเตอร์การเชื่อมต่อเริ่มต้นสำหรับการเชื่อมต่อแบบรวม
• commands : ระบุอินสแตนซ์ของโรงงานคำสั่งเพื่อใช้ผ่านไลบรารี

ผู้ใช้ยังสามารถจัดเตรียมตัวเลือกแบบกำหนดเองพร้อมค่าหรืออ็อบเจ็กต์ที่สามารถเรียกได้ (สำหรับการเริ่มต้นแบบขี้เกียจ) ที่ถูกจัดเก็บไว้ในคอนเทนเนอร์ตัวเลือกเพื่อใช้ในภายหลังผ่านไลบรารี

การเชื่อมต่อแบบรวม

การเชื่อมต่อแบบรวมเป็นรากฐานที่ Predis ใช้การจัดกลุ่มและการจำลอง และใช้เพื่อจัดกลุ่มการเชื่อมต่อหลายรายการไปยังโหนด Redis เดียว และซ่อนตรรกะเฉพาะที่จำเป็นในการจัดการอย่างเหมาะสมโดยขึ้นอยู่กับบริบท การเชื่อมต่อแบบรวมมักจะต้องใช้อาร์เรย์ของพารามิเตอร์การเชื่อมต่อพร้อมกับตัวเลือกไคลเอนต์ที่เหมาะสมเมื่อสร้างอินสแตนซ์ไคลเอนต์ใหม่

กลุ่ม

Predis สามารถกำหนดค่าให้ทำงานในโหมดคลัสเตอร์ด้วยวิธีการแบ่งส่วนฝั่งไคลเอ็นต์แบบดั้งเดิมเพื่อสร้างคลัสเตอร์ของโหนดอิสระและกระจายคีย์สเปซระหว่างโหนดเหล่านั้น วิธีการนี้จำเป็นต้องมีการตรวจสอบสถานะภายนอกของโหนด และต้องการให้คีย์สเปซได้รับการปรับสมดุลด้วยตนเองเมื่อมีการเพิ่มหรือลบโหนด:

 $ parameters = [ ' tcp://10.0.0.1 ' , ' tcp://10.0.0.2 ' , ' tcp://10.0.0.3 ' ];
$ options    = [ ' cluster ' => ' predis ' ];

$ client = new Predis  Client ( $ parameters );

นอกจาก Redis 3.0 แล้ว การจัดคลัสเตอร์ประเภทใหม่ที่ได้รับการดูแลและประสานงานก็ถูกนำมาใช้ในรูปแบบของคลัสเตอร์ Redis วิธีการประเภทนี้ใช้อัลกอริธึมที่แตกต่างกันในการกระจายคีย์สเปซ โดยที่โหนด Redis ประสานงานกันเองโดยการสื่อสารผ่านโปรโตคอลซุบซิบเพื่อจัดการสถานะความสมบูรณ์ การปรับสมดุล การค้นพบโหนด และการร้องขอการเปลี่ยนเส้นทาง ในการเชื่อมต่อกับคลัสเตอร์ที่จัดการโดย Redis-cluster ไคลเอนต์จำเป็นต้องมีรายการโหนด (ไม่จำเป็นต้องเสร็จสมบูรณ์เนื่องจากจะค้นหาโหนดใหม่โดยอัตโนมัติหากจำเป็น) และตัวเลือกไคลเอนต์ cluster ที่ตั้งค่าเป็น redis :

 $ parameters = [ ' tcp://10.0.0.1 ' , ' tcp://10.0.0.2 ' , ' tcp://10.0.0.3 ' ];
$ options    = [ ' cluster ' => ' redis ' ];

$ client = new Predis  Client ( $ parameters , $ options );

การจำลองแบบ

สามารถกำหนดค่าไคลเอนต์ให้ทำงานในการตั้งค่าหลักเดียว/หลายทาส เพื่อให้บริการที่ดีขึ้น เมื่อใช้การจำลองแบบ Predis จะจดจำคำสั่งแบบอ่านอย่างเดียวและส่งคำสั่งเหล่านั้นไปยังทาสแบบสุ่มเพื่อให้มีการปรับสมดุลโหลดและสลับไปที่คำสั่งหลักทันทีที่ตรวจพบคำสั่งที่ดำเนินการใด ๆ ที่จะจบลงด้วยการแก้ไข คีย์สเปซหรือค่าของคีย์ แทนที่จะทำให้เกิดข้อผิดพลาดในการเชื่อมต่อเมื่อทาสล้มเหลว ไคลเอนต์พยายามที่จะถอยกลับไปเป็นทาสอื่นจากที่ระบุไว้ในการกำหนดค่า

การกำหนดค่าพื้นฐานที่จำเป็นในการใช้ไคลเอนต์ในโหมดการจำลองต้องมีเซิร์ฟเวอร์ Redis หนึ่งตัวที่ต้องระบุเป็นเซิร์ฟเวอร์หลัก (ซึ่งสามารถทำได้ผ่านพารามิเตอร์การเชื่อมต่อโดยการตั้งค่าพารามิเตอร์ role เป็น master ) และทาสหนึ่งตัวขึ้นไป (ในกรณีนี้ การตั้ง role เป็น slave สำหรับทาสเป็นทางเลือก):

 $ parameters = [ ' tcp://10.0.0.1?role=master ' , ' tcp://10.0.0.2 ' , ' tcp://10.0.0.3 ' ];
$ options    = [ ' replication ' => ' predis ' ];

$ client = new Predis  Client ( $ parameters , $ options );

การกำหนดค่าข้างต้นมีรายการเซิร์ฟเวอร์แบบคงที่และอาศัยตรรกะของไคลเอ็นต์ทั้งหมด แต่ก็เป็นไปได้ที่จะพึ่งพา redis-sentinel สำหรับสภาพแวดล้อม HA ที่แข็งแกร่งยิ่งขึ้น โดยมีเซิร์ฟเวอร์ Sentinel ทำหน้าที่เป็นแหล่งที่มาของสิทธิ์สำหรับไคลเอ็นต์ในการค้นพบบริการ การกำหนดค่าขั้นต่ำที่ไคลเอ็นต์ต้องการเพื่อทำงานกับ Redis-Sentinel คือรายการพารามิเตอร์การเชื่อมต่อที่ชี้ไปยังอินสแตนซ์ Sentinel จำนวนมาก ตัวเลือก replication ที่ตั้งค่าเป็น sentinel และตัวเลือก service ที่ตั้งค่าเป็นชื่อของบริการ:

 $ sentinels = [ ' tcp://10.0.0.1 ' , ' tcp://10.0.0.2 ' , ' tcp://10.0.0.3 ' ];
$ options   = [ ' replication ' => ' sentinel ' , ' service ' => ' mymaster ' ];

$ client = new Predis  Client ( $ sentinels , $ options );

หากโหนดหลักและโหนดรองได้รับการกำหนดค่าให้ต้องมีการตรวจสอบสิทธิ์จากไคลเอ็นต์ จะต้องระบุรหัสผ่านผ่านตัวเลือกไคลเอ็นต์ parameters ส่วนกลาง ตัวเลือกนี้ยังสามารถใช้เพื่อระบุดัชนีฐานข้อมูลอื่นได้อีกด้วย อาร์เรย์ตัวเลือกไคลเอนต์จะมีลักษณะดังนี้:

 $ options = [
    ' replication ' => ' sentinel ' ,
    ' service ' => ' mymaster ' ,
    ' parameters ' => [
        ' password ' => $ secretpassword ,
        ' database ' => 10 ,
    ],
];

ในขณะที่ Predis สามารถแยกแยะคำสั่งที่ดำเนินการเขียนและอ่านอย่างเดียวได้ EVAL และ EVALSHA เป็นตัวแทนของกรณีมุมที่ไคลเอนต์สลับไปที่โหนดหลักเนื่องจากไม่สามารถบอกได้ว่าสคริปต์ Lua ปลอดภัยที่จะดำเนินการบนทาสเมื่อใด แม้ว่านี่จะเป็นพฤติกรรมเริ่มต้นก็ตาม เมื่อสคริปต์ Lua บางตัวไม่ได้ดำเนินการเขียน คุณสามารถให้คำแนะนำเพื่อบอกไคลเอ็นต์ให้ยึดติดกับทาสในการดำเนินการได้:

 $ parameters = [ ' tcp://10.0.0.1?role=master ' , ' tcp://10.0.0.2 ' , ' tcp://10.0.0.3 ' ];
$ options    = [ ' replication ' => function () {
    // Set scripts that won't trigger a switch from a slave to the master node.
    $ strategy = new Predis  Replication  ReplicationStrategy ();
    $ strategy -> setScriptReadOnly ( $ LUA_SCRIPT );

    return new Predis  Connection  Replication  MasterSlaveReplication ( $ strategy );
}];

$ client = new Predis  Client ( $ parameters , $ options );
$ client -> eval ( $ LUA_SCRIPT , 0 );             // Sticks to slave using `eval`...
$ client -> evalsha ( sha1 ( $ LUA_SCRIPT ), 0 );    // ... and `evalsha`, too.

ไดเร็กทอรี examples ประกอบด้วยสคริปต์บางส่วนที่สาธิตวิธีกำหนดค่าและใช้งานไคลเอ็นต์เพื่อใช้ประโยชน์จากการจำลองแบบในสถานการณ์พื้นฐานและซับซ้อน

ไปป์ไลน์คำสั่ง

Pipelining สามารถช่วยในเรื่องประสิทธิภาพเมื่อจำเป็นต้องส่งคำสั่งจำนวนมากไปยังเซิร์ฟเวอร์ โดยการลดเวลาแฝงที่เกิดจากกำหนดเวลาไปกลับของเครือข่าย การวางท่อยังทำงานร่วมกับการเชื่อมต่อแบบรวมอีกด้วย ไคลเอนต์สามารถดำเนินการไปป์ไลน์ภายในบล็อกที่เรียกได้หรือส่งคืนอินสแตนซ์ไปป์ไลน์ด้วยความสามารถในการเชื่อมโยงคำสั่งด้วยอินเทอร์เฟซที่คล่องแคล่ว:

 // Executes a pipeline inside the given callable block:
$ responses = $ client -> pipeline ( function ( $ pipe ) {
    for ( $ i = 0 ; $ i < 1000 ; $ i ++) {
        $ pipe -> set ( " key: $ i " , str_pad ( $ i , 4 , ' 0 ' , 0 ));
        $ pipe -> get ( " key: $ i " );
    }
});

// Returns a pipeline that can be chained thanks to its fluent interface:
$ responses = $ client -> pipeline ()-> set ( ' foo ' , ' bar ' )-> get ( ' foo ' )-> execute ();

การทำธุรกรรม

ไคลเอนต์จัดเตรียมสิ่งที่เป็นนามธรรมสำหรับธุรกรรม Redis ที่ใช้ MULTI และ EXEC พร้อมด้วยอินเทอร์เฟซที่คล้ายกันกับไปป์ไลน์คำสั่ง:

 // Executes a transaction inside the given callable block:
$ responses = $ client -> transaction ( function ( $ tx ) {
    $ tx -> set ( ' foo ' , ' bar ' );
    $ tx -> get ( ' foo ' );
});

// Returns a transaction that can be chained thanks to its fluent interface:
$ responses = $ client -> transaction ()-> set ( ' foo ' , ' bar ' )-> get ( ' foo ' )-> execute ();

สิ่งที่เป็นนามธรรมนี้สามารถทำการตรวจสอบและตั้งค่าได้ด้วย WATCH และ UNWATCH และให้การลองธุรกรรมอีกครั้งโดยอัตโนมัติที่ถูกยกเลิกโดย Redis เมื่อแตะคีย์ WATCH ed สำหรับตัวอย่างธุรกรรมโดยใช้ CAS คุณสามารถดูตัวอย่างต่อไปนี้

การเพิ่มคำสั่งใหม่

แม้ว่าเราพยายามอัปเดต Predis เพื่อให้ทันกับคำสั่งทั้งหมดที่มีอยู่ใน Redis แต่คุณอาจต้องการใช้ไลบรารีเวอร์ชันเก่าหรือจัดเตรียมวิธีอื่นในการกรองอาร์กิวเมนต์หรือแยกวิเคราะห์การตอบสนองสำหรับคำสั่งเฉพาะ เพื่อให้บรรลุเป้าหมายดังกล่าว Predis มอบความสามารถในการใช้คลาสคำสั่งใหม่เพื่อกำหนดหรือแทนที่คำสั่งในแฟกทอรีคำสั่งเริ่มต้นที่ไคลเอนต์ใช้:

 // Define a new command by extending PredisCommandCommand:
class BrandNewRedisCommand extends Predis  Command Command
{
    public function getId ()
    {
        return ' NEWCMD ' ;
    }
}

// Inject your command in the current command factory:
$ client = new Predis  Client ( $ parameters , [
    ' commands ' => [
        ' newcmd ' => ' BrandNewRedisCommand ' ,
    ],
]);

$ response = $ client -> newcmd ();

นอกจากนี้ยังมีวิธีการส่งคำสั่งดิบโดยไม่ต้องกรองอาร์กิวเมนต์หรือแยกวิเคราะห์คำตอบ ผู้ใช้จะต้องจัดเตรียมรายการอาร์กิวเมนต์สำหรับคำสั่งเป็นอาร์เรย์ ตามลายเซ็นที่กำหนดโดยเอกสาร Redis สำหรับคำสั่ง:

 $ response = $ client -> executeRaw ([ ' SET ' , ' foo ' , ' bar ' ]);

คำสั่งสคริปต์

แม้ว่าเป็นไปได้ที่จะใช้ประโยชน์จากสคริปต์ Lua บน Redis 2.6+ โดยใช้ EVAL และ EVALSHA โดยตรง แต่ Predis ก็เสนอคำสั่งสคริปต์ซึ่งเป็นนามธรรมระดับที่สูงกว่าที่สร้างขึ้นเพื่อทำให้สิ่งต่าง ๆ ง่ายขึ้น คำสั่งสคริปต์สามารถลงทะเบียนในโรงงานคำสั่งที่ไคลเอ็นต์ใช้ และสามารถเข้าถึงได้เหมือนกับว่าเป็นคำสั่ง Redis ธรรมดา แต่จะกำหนดสคริปต์ Lua ที่ถูกส่งไปยังเซิร์ฟเวอร์สำหรับการดำเนินการจากระยะไกล ภายในพวกเขาใช้ EVALSHA ตามค่าเริ่มต้นและระบุสคริปต์ด้วยแฮช SHA1 เพื่อประหยัดแบนด์วิดท์ แต่ EVAL จะถูกใช้เป็นทางเลือกสำรองเมื่อจำเป็น:

 // Define a new script command by extending PredisCommandScriptCommand:
class ListPushRandomValue extends Predis  Command ScriptCommand
{
    public function getKeysCount ()
    {
        return 1 ;
    }

    public function getScript ()
    {
        return <<<LUA
math.randomseed(ARGV[1])
local rnd = tostring(math.random())
redis.call('lpush', KEYS[1], rnd)
return rnd
LUA ;
    }
}

// Inject the script command in the current command factory:
$ client = new Predis  Client ( $ parameters , [
    ' commands ' => [
        ' lpushrand ' => ' ListPushRandomValue ' ,
    ],
]);

$ response = $ client -> lpushrand ( ' random_values ' , $ seed = mt_rand ());

แบ็กเอนด์การเชื่อมต่อที่ปรับแต่งได้

Predis สามารถใช้แบ็กเอนด์การเชื่อมต่อที่แตกต่างกันเพื่อเชื่อมต่อกับ Redis การผสานรวม Relay ในตัวใช้ประโยชน์จากส่วนขยาย Relay สำหรับ PHP เพื่อเพิ่มประสิทธิภาพการทำงานที่สำคัญ โดยการแคชแบบจำลองบางส่วนของชุดข้อมูล Redis ในหน่วยความจำรันไทม์ที่ใช้ร่วมกันของ PHP

 $ client = new Predis  Client ( ' tcp://127.0.0.1 ' , [
    ' connections ' => ' relay ' ,
]);

นักพัฒนาสามารถสร้างคลาสการเชื่อมต่อของตนเองเพื่อรองรับแบ็กเอนด์เครือข่ายใหม่ทั้งหมด ขยายคลาสที่มีอยู่ หรือจัดเตรียมการใช้งานที่แตกต่างไปจากเดิมอย่างสิ้นเชิง คลาสการเชื่อมต่อต้องใช้ PredisConnectionNodeConnectionInterface หรือขยาย PredisConnectionAbstractConnection :

 class MyConnectionClass implements Predis  Connection NodeConnectionInterface
{
    // Implementation goes here...
}

// Use MyConnectionClass to handle connections for the `tcp` scheme:
$ client = new Predis  Client ( ' tcp://127.0.0.1 ' , [
    ' connections ' => [ ' tcp ' => ' MyConnectionClass ' ],
]);

สำหรับข้อมูลเชิงลึกเพิ่มเติมเกี่ยวกับวิธีสร้างแบ็กเอนด์การเชื่อมต่อใหม่ คุณสามารถดูการใช้งานจริงของคลาสการเชื่อมต่อมาตรฐานที่มีอยู่ในเนมสเปซ PredisConnection

การพัฒนา

รายงานข้อบกพร่องและรหัสที่มีส่วนร่วม

การมีส่วนร่วมใน Predis นั้นได้รับการชื่นชมอย่างมากทั้งในรูปแบบของคำขอดึงคุณสมบัติใหม่ การแก้ไขข้อบกพร่อง หรือเพียงรายงานข้อบกพร่อง เราขอให้คุณปฏิบัติตามปัญหาและดึงเทมเพลตคำขอเท่านั้น

ชุดทดสอบ

ความสนใจ : อย่ารันชุดทดสอบที่มาพร้อมกับ Predis กับอินสแตนซ์ของ Redis ที่ทำงานในสภาพแวดล้อมการผลิตหรือมีข้อมูลที่คุณสนใจ!

Predis มีชุดทดสอบที่ครอบคลุมครอบคลุมทุกแง่มุมของไลบรารีและสามารถเลือกทำการทดสอบการรวมกับอินสแตนซ์ที่กำลังทำงานอยู่ของ Redis ได้ (จำเป็น >= 2.4.0 เพื่อตรวจสอบพฤติกรรมที่ถูกต้องของการนำแต่ละคำสั่งไปใช้) การทดสอบการรวมสำหรับที่ไม่รองรับ คำสั่ง Redis จะถูกข้ามโดยอัตโนมัติ หากคุณไม่ได้เปิดใช้งาน Redis คุณสามารถปิดใช้งานการทดสอบการรวมได้ ดูการทดสอบ README สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับการทดสอบไลบรารีนี้

Predis ใช้ GitHub Actions เพื่อการบูรณาการอย่างต่อเนื่อง และสามารถดูประวัติของบิลด์ในอดีตและปัจจุบันได้ในหน้าการดำเนินการ

ใบอนุญาต

รหัสสำหรับ Predis ได้รับการเผยแพร่ภายใต้เงื่อนไขของใบอนุญาต MIT (ดูใบอนุญาต)