Redis

Redis操作提高多种灵活方式，全局函数和对象操作方式，同时也支持延迟收包。

全局函数

通过全局函数操作缓存

  1. /**
  2.  * @Controller(prefix="/redis")
  3.  */
  4. class RedisController
  5. {
  7.     public function testFunc()
  8.     {
  9.         $result = cache()->set('nameFunc', 'stelin3');
  10.         $name   = cache()->get('nameFunc');
  12.         return [$result, $name];
  13.     }
  15.     public function testFunc2()
  16.     {
  17.         $result = cache()->set('nameFunc2', 'stelin3');
  18.         $name   = cache('nameFunc2');
  19.         $name2   = cache('nameFunc3', 'value3');
  21.         return [$result, $name, $name2];
  22.     } 
  23. }
  • cache(string $key = null, $default = null) 如果参数都为默认值，会返回Cache对象，提供缓存操作。如果传入key参数，返回get缓存值，如果key不存在，返回default参数值

对象方式

通过注入Cache和Redis(驱动对象)，都可以操作缓存，唯一不同的是，Cache方式注入的对象，是使用配置的默认驱动。

  1. /**
  2.  * @Controller(prefix="/redis")
  3.  */
  4. class RedisController
  5. {
  6.     /**
  7.      * @Inject("cache")
  8.      * @var Cache
  9.      */
  10.     private $cache;
  12.     /**
  13.      * @Inject()
  14.      * @var \Swoft\Redis\Redis
  15.      */
  16.     private $redis;
  18.     public function testCache()
  19.     {
  20.         $result = $this->cache->set('name', 'stelin');
  21.         $name   = $this->cache->get('name');
  23.         $this->redis->incr("count");
  25.         $this->redis->incrBy("count2", 2);
  27.         return [$result, $name, $this->redis->get('count'), $this->redis->get('count2')];
  28.     }
  29. }
  • Cache和Redis(驱动对象)对象，操作方式都一样，里面提供了一系列的缓存操作函数。

延迟收包

延迟收包可以实现多IO并发执行，不仅仅是多个缓存IO，也可以mysql/rpc/http混合并发请求，有效的提升执行性能。

  1. /**
  2.  * @Controller(prefix="/redis")
  3.  */
  4. class RedisController
  5. {
  6.     public function testDefer()
  7.     {
  8.         $ret1 = $this->redis->deferCall('set', ['name1', 'stelin1']);
  9.         $ret2 = $this->redis->deferCall('set', ['name2', 'stelin2']);
  11.         $r1 = $ret1->getResult();
  12.         $r2 = $ret2->getResult();
  14.         $ary = $this->redis->getMultiple(['name1', 'name2']);
  16.         return [$r1, $r2, $ary];
  17.     }
  18. }
  • 暂时只能提供一个统一的函数deferCall，实现延迟收包操作，接下来会新增deferXxx函数，实现对应延迟收包操作函数。

多实例Redis

配置一个Redis实例，需要新增一个实例连接池和连接池配置，然后通过bean，配置新增的redis实例

新增连接池和配置

连接池配置

继承默认RedisPoolConfig，可以配置部分或全部信息，重新父类配置信息属性。

  1. /**
  2.  * DemoRedisPoolConfig
  3.  *
  4.  * @Bean()
  5.  */
  6. class DemoRedisPoolConfig extends RedisPoolConfig
  7. {
  8.     /**
  9.      * @Value(name="${config.cache.demoRedis.db}", env="${REDIS_DEMO_REDIS_DB}")
  10.      * @var int
  11.      */
  12.     protected $db = 0;
  14.     /**
  15.      * @Value(name="${config.cache.demoRedis.prefix}", env="${REDIS_DEMO_REDIS_PREFIX}")
  16.      * @var string
  17.      */
  18.     protected $prefix = '';
  19. }

连接池

继承RedisPool，重新注入配置信息

  1. /**
  2.  * DemoRedisPool
  3.  *
  4.  * @Pool("demoRedis")
  5.  */
  6. class DemoRedisPool extends RedisPool
  7. {
  8.     /**
  9.      * @Inject()
  10.      * @var DemoRedisPoolConfig
  11.      */
  12.     public $poolConfig;
  13. }

配置Bean

bean文件里面新增一个redis实例bean名称，app/config/beans/base.php

  1. return [
  2.     // ......
  3.     'demoRedis' => [
  4.         'class' => \Swoft\Redis\Redis::class,
  5.         'poolName' => 'demoRedis'
  6.     ]
  7.     // ......
  8. ];

使用新实例

使用@Inject，注入配置的redis实例，使用没有任何区别，只是配置信息发生了变化

  2. class Demo
  3. {
  4.     /**
  5.      * @Inject("demoRedis")
  6.      * @var \Swoft\Redis\Redis
  7.      */
  8.     private $demoRedis;
  10.     public function testDemoRedis()
  11.     {
  12.         $result = $this->demoRedis->set('name', 'swoft');
  13.         $name   = $this->demoRedis->get('name');
  15.         $this->demoRedis->incr('count');
  16.         $this->demoRedis->incrBy('count2', 2);
  18.         return [$result, $name, $this->demoRedis->get('count'), $this->demoRedis->get('count2'), '3'];
  19.     }
  20. }