多级缓存的实现---责任链模式

多级缓存责任链模式。
* client提交给 hander，hander发现责任链上能处理该任务的函数，处理；可以归纳为：用一系列类(classes)试图处理一个请求request,这些类之间是一个松散的耦合, 唯一共同点是在他们之间传递request. 也就是说，来了一个请求，A类先处理，如果没有处理，就传递到B类处理，如果没有处理，就传递到C类处理，就这样象一个链条(chain)一样传递下去。

2. /**
3. * \责任链模式，其目的是组织一个对象链处理一个如方法调用的请求。
4. *
5. * 最著名的责任链示例：多级缓存。
6. * client提交给 hander，hander发现责任链上能处理该任务的函数，处理；
7. * 可以归纳为：用一系列类(classes)试图处理一个请求request,这些类之间是一个松散的耦合,
8. * 唯一共同点是在他们之间传递request. 也就是说，来了一个请求，A类先处理，如果没有处理，
9. * 就传递到B类处理，如果没有处理，就传递到C类处理，就这样象一个链条(chain)一样传递下去。
10. */
13. /**
14. * The Handler abstraction. Objects that want to be a part of the
15. * ChainOfResponsibility must implement this interface directly or via
16. * inheritance from an AbstractHandler.
17. * 处理抽象类，对象如果想成为责任链的一部分必须直接实现这个接口或
18. * 继承一个抽象的处理类
19. */
20. interface KeyValueStore{
21. /**
22. * Obtain a value.
23. * @param string $key
24. * @return mixed
25. */
26. public function get($key);
27. }
28. /**
29. * Basic no-op implementation which ConcreteHandlers not interested in
30. * caching or in interfering with the retrieval inherit from.
31. * 接收一个请求，设法满足它，如果不成功就委派给下一个处理程序。
32. */
33. abstract class AbstractKeyValueStore implements KeyValueStore{
34. protected $_nextHandler;
35. public function get($key){
36. return $this->_nextHandler->get($key);
37. }
38. }
39. /**
40. * Ideally the last ConcreteHandler in the chain. At least, if inserted in
41. * a Chain it will be the last node to be called.
42. * 理想情况下，责任链上最后的具体处理类，加入链上，将是最后被调用的节点。
43. */
44. class SlowStore implements KeyValueStore{
45. /**
46. * This could be a somewhat slow store: a database or a flat file.
47. */
48. protected $_values;
49. public function __construct(array $values = array()){
50. $this->_values = $values;
51. }
52. public function get($key){
53. return $this->_values[$key];
54. }
55. }
56. /**
57. * A ConcreteHandler that handles the request for a key by looking for it in
58. * its own cache. Forwards to the next handler in case of cache miss.
59. * 在缓存没命中的情况下，转发到下一个处理对象
60. */
61. class InMemoryKeyValueStore implements KeyValueStore{
62. protected $_nextHandler;
63. protected $_cached = array();
64. public function __construct(KeyValueStore $nextHandler){
65. $this->_nextHandler = $nextHandler;
66. }
67. protected function _load($key){
68. if (!isset($this->_cached[$key])) {
69. $this->_cached[$key] = $this->_nextHandler->get($key);
70. }
71. }
72. public function get($key){
73. $this->_load($key);
74. return $this->_cached[$key];
75. }
76. }
77. /**
78. * A ConcreteHandler that delegates the request without trying to
79. * understand it at all. It may be easier to use in the user interface
80. * because it can specialize itself by defining methods that generates
81. * html, or by addressing similar user interface concerns.
82. * Some Clients see this object only as an instance of KeyValueStore
83. * and do not care how it satisfy their requests, while other ones
84. * may use it in its entirety (similar to a class-based adapter).
85. * No client knows that a chain of Handlers exists.
86. * 不用关心调用的具体实现的外部具体具体处理程序；背后是责任链。
87. */
88. class FrontEnd extends AbstractKeyValueStore{
89. public function __construct(KeyValueStore $nextHandler){
90. $this->_nextHandler = $nextHandler;
91. }
92. public function getEscaped($key){
93. return htmlentities($this->get($key), ENT_NOQUOTES, 'UTF-8');
94. }
95. }
96. // Client code
97. $store = new SlowStore(
98. array(
99. 'pd' => 'Philip K. Dick',
100. 'ia' => 'Isaac Asimov',
101. 'ac' => 'Arthur C. Clarke',
102. 'hh' => 'Helmut Hei.enbttel'
103. )
104. );
105. // in development, we skip cache and pass $store directly to FrontEnd
106. $cache = new InMemoryKeyValueStore($store);
107. $frontEnd = new FrontEnd($cache);
108. echo $frontEnd->get('ia'). "\n";
109. echo $frontEnd->getEscaped('hh'). "\n";
111. /**
112. * expect: ...
113. * Isaac Asimov
114. * Helmut Hei.enbttel
115. *
116. * 参与者：
118. ◆Client（客户端）：向Handler（处理程序）提交一个请求；
119. ◆Handler（处理程序）抽象：接收一个请求，以某种方式满足它；
120. ◆ConcreteHandlers（具体的处理程序）：接收一个请求，设法满足它，如果不成功就委派给下一个处理程序。
121. */

复制代码