一切福田，不離方寸，從心而覓，感無不通。

现代 PHP 新特性系列（二） —— 善用接口

接口不是现代PHP的新特性，但是非常重要，学会使用接口，可以极大提升我们的编程能力，所以在日常开发中应该尽可能多地使用接口。

接口是两个PHP对象之间的契约（Contract），Laravel底层就直接将接口放在Contracts目录中：

modern-php-interface

接口将我们的代码和依赖解耦了，而且允许我们的代码依赖任何实现了预期接口的第三方代码，我们不管第三方代码是如何实现接口的，只关心第三方代码是否实现了指定的接口。

如果我们编写的代码需要处理指定类的对象，那么代码的功用就完全被限定了，因为始终只能使用那个类的对象，可是，如果编写的代码处理的是接口，那么代码立即就能知道如何处理实现这一接口的任何对象，我们不关心接口是如何实现的，只关心是否实现了指定的接口。

我们以上述Laravel底层提供的CacheStore（Store接口）为例，这个接口的作用是封装缓存存储器的通用方法，包括get、put、flush等：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
<?php
 
namespace Illuminate\Contracts\Cache;
 
interface Store
{
    /**
     * Retrieve an item from the cache by key.
     *
     * @param  string|array  $key
     * @return mixed
     */
    public function get($key);
 
    /**
     * Retrieve multiple items from the cache by key.
     *
     * Items not found in the cache will have a null value.
     *
     * @param  array  $keys
     * @return array
     */
    public function many(array $keys);
 
    /**
     * Store an item in the cache for a given number of minutes.
     *
     * @param  string  $key
     * @param  mixed   $value
     * @param  int     $minutes
     * @return void
     */
    public function put($key, $value, $minutes);
 
    /**
     * Store multiple items in the cache for a given number of minutes.
     *
     * @param  array  $values
     * @param  int  $minutes
     * @return void
     */
    public function putMany(array $values, $minutes);
 
    /**
     * Increment the value of an item in the cache.
     *
     * @param  string  $key
     * @param  mixed   $value
     * @return int|bool
     */
    public function increment($key, $value = 1);
 
    /**
     * Decrement the value of an item in the cache.
     *
     * @param  string  $key
     * @param  mixed   $value
     * @return int|bool
     */
    public function decrement($key, $value = 1);
 
    /**
     * Store an item in the cache indefinitely.
     *
     * @param  string  $key
     * @param  mixed   $value
     * @return void
     */
    public function forever($key, $value);
 
    /**
     * Remove an item from the cache.
     *
     * @param  string  $key
     * @return bool
     */
    public function forget($key);
 
    /**
     * Remove all items from the cache.
     *
     * @return void
     */
    public function flush();
 
    /**
     * Get the cache key prefix.
     *
     * @return string
     */
    public function getPrefix();
}

这么做的好处是可以分开定义具体的缓存实现方式，比如Laravel支持数组（Array）、数据库（Database）、文件（File）、Apc、Memcache、Redis等缓存存储器，方便我们在代码中使用相应的方式对数据进行缓存。我们以Memcached驱动为例，其对应实现类是MemcachedStore：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
<?php
 
namespace Illuminate\Cache;
 
use Memcached;
use Illuminate\Contracts\Cache\Store;
 
class MemcachedStore extends TaggableStore implements Store
{
    /**
     * The Memcached instance.
     *
     * @var \Memcached
     */
    protected $memcached;
 
    /**
     * A string that should be prepended to keys.
     *
     * @var string
     */
    protected $prefix;
 
    /**
     * Create a new Memcached store.
     *
     * @param  \Memcached  $memcached
     * @param  string      $prefix
     * @return void
     */
    public function __construct($memcached, $prefix = '')
    {
        $this->setPrefix($prefix);
        $this->memcached = $memcached;
    }
 
    /**
     * Retrieve an item from the cache by key.
     *
     * @param  string|array  $key
     * @return mixed
     */
    public function get($key)
    {
        $value = $this->memcached->get($this->prefix.$key);
 
        if ($this->memcached->getResultCode() == 0) {
            return $value;
        }
    }
 
    /**
     * Retrieve multiple items from the cache by key.
     *
     * Items not found in the cache will have a null value.
     *
     * @param  array  $keys
     * @return array
     */
    public function many(array $keys)
    {
        $prefixedKeys = array_map(function ($key) {
            return $this->prefix.$key;
        }, $keys);
 
        $values = $this->memcached->getMulti($prefixedKeys, null, Memcached::GET_PRESERVE_ORDER);
 
        if ($this->memcached->getResultCode() != 0) {
            return array_fill_keys($keys, null);
        }
 
        return array_combine($keys, $values);
    }
 
    /**
     * Store an item in the cache for a given number of minutes.
     *
     * @param  string  $key
     * @param  mixed   $value
     * @param  int     $minutes
     * @return void
     */
    public function put($key, $value, $minutes)
    {
        $this->memcached->set($this->prefix.$key, $value, $minutes * 60);
    }
 
    /**
     * Store multiple items in the cache for a given number of minutes.
     *
     * @param  array  $values
     * @param  int  $minutes
     * @return void
     */
    public function putMany(array $values, $minutes)
    {
        $prefixedValues = [];
 
        foreach ($values as $key => $value) {
           $prefixedValues[$this->prefix.$key] = $value;
        }
 
        $this->memcached->setMulti($prefixedValues, $minutes * 60);
    }
 
    /**
     * Store an item in the cache if the key doesn't exist.
     *
     * @param  string  $key
     * @param  mixed   $value
     * @param  int     $minutes
     * @return bool
     */
    public function add($key, $value, $minutes)
    {
        return $this->memcached->add($this->prefix.$key, $value, $minutes * 60);
    }
 
    /**
     * Increment the value of an item in the cache.
     *
     * @param  string  $key
     * @param  mixed   $value
     * @return int|bool
     */
    public function increment($key, $value = 1)
    {
        return $this->memcached->increment($this->prefix.$key, $value);
    }
 
    /**
     * Decrement the value of an item in the cache.
     *
     * @param  string  $key
     * @param  mixed   $value
     * @return int|bool
     */
    public function decrement($key, $value = 1)
    {
        return $this->memcached->decrement($this->prefix.$key, $value);
    }
 
    /**
     * Store an item in the cache indefinitely.
     *
     * @param  string  $key
     * @param  mixed   $value
     * @return void
     */
    public function forever($key, $value)
    {
        $this->put($key, $value, 0);
    }
 
    /**
     * Remove an item from the cache.
     *
     * @param  string  $key
     * @return bool
     */
    public function forget($key)
    {
        return $this->memcached->delete($this->prefix.$key);
    }
 
    /**
     * Remove all items from the cache.
     *
     * @return void
     */
    public function flush()
    {
        $this->memcached->flush();
    }
 
    /**
     * Get the underlying Memcached connection.
     *
     * @return \Memcached
     */
    public function getMemcached()
    {
        return $this->memcached;
    }
 
    /**
     * Get the cache key prefix.
     *
     * @return string
     */
    public function getPrefix()
    {
        return $this->prefix;
    }
 
    /**
     * Set the cache key prefix.
     *
     * @param  string  $prefix
     * @return void
     */
    public function setPrefix($prefix)
    {
        $this->prefix = ! empty($prefix) ? $prefix.':' : '';
    }
}

可以看到我们在构造函数中传入了Memcached实例，然后在此实例基础上具体实现接口所定义的方法，其他的实现类也是类似，这样通过Store接口，我们就将缓存代码和具体依赖解耦，方便后续扩展以及供其他人使用。比如这里我们定义一个CacheStore类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
<?php
namespace App\Tests;
 
use Illuminate\Contracts\Cache\Store;
 
class CacheStore
{
    protected $store;
 
    public function __construct(Store $store)
    {
        $this->store = $store;
    }
 
    public function get($key)
    {
        return $this->store->get($key);
    }
 
    public function put($key, $value, $minutes=1)  
    {
        $this->store->put($key, $value, $minutes);
    }
 
    public function forget($key)
    {
        $this->store->forever($key);
    }
 
    public function flush()
    {
        $this->store->flush();
    }
}

然后我们可以在配置文件中配置使用的默认缓存驱动，比如Memcached，然后在代码中调用时这样使用：

1
2
3
4
5
6
$memcached = new \Memcached();
$memcached->addServer('localhost',11211);
$memcachedCache = new MemcachedStore($memcached);
$cacheStore = new CacheStore($memcachedCache);
$cacheStore-&gt;put('site','<a href="http://laravelacademy.org/">http://LaravelAcademy.org</a>');
dd($cacheStore-&gt;get('site'));

注：这里只是做简单演示，不要真的这么去使用Laravel提供的缓存功能，实际上Laravel底层对缓存处理要比我这里的演示代码优雅的多。

总之，使用接口编写的代码更灵活，能委托别人实现细节，使用接口后会有越来越多的人使用你的代码，因为他们只需要知道如何实现接口，就可以无缝地使用你的代码。实际上，我们在使用服务提供者和依赖注入时也是以这种面向接口编程为基础进行了更复杂的扩展而已。

 

from:http://laravelacademy.org/post/4246.html

Copyright © 2024 Longsheng All rights reserved.