规格模式是组合模式的一种扩展，在框架性开发中使用较多（项目级开发很少使用），通过本文给大家介绍PHP 设计模式系列之 specification规格模式，对specification模式相关知识感兴趣的朋友一起学习吧。

1、模式定义

规格模式是组合模式的一种扩展，在框架性开发中使用较多（项目级开发很少使用），这里做一个简单的介绍。

规格模式（Specification）可以认为是组合模式的一种扩展。有时项目中某些条件决定了业务逻辑，这些条件就可以抽离出来以某种关系（与、或、非）进行组合，从而灵活地对业务逻辑进行定制。另外，在查询、过滤等应用场合中，通过预定义多个条件，然后使用这些条件的组合来处理查询或过滤，而不是使用逻辑判断语句来处理，可以简化整个实现逻辑。

这里的每个条件就是一个规格，多个规格/条件通过串联的方式以某种逻辑关系形成一个组合式的规格。

2、UML类图

3、示例代码

Item.php

1. <?php 
2. namespace DesignPatterns\Behavioral\Specification; 
3. class Item 
4. { 
5. protected $price; 
6.  
7. /** 
8. * An item must have a price 
9. * 
10. * @param int $price 
11. */ 
12. public function __construct($price) 
13. { 
14. $this->price = $price; 
15. } 
16. /** 
17. * Get the items price 
18. * 
19. * @return int 
20. */ 
21. public function getPrice() 
22. { 
23. return $this->price; 
24. } 
25. } 

SpecificationInterface.php

1. <?php 
2. namespace DesignPatterns\Behavioral\Specification; 
3. /** 
4. * 规格接口 
5. */ 
6. interface SpecificationInterface 
7. { 
8. /** 
9. * 判断对象是否满足规格 
10. * 
11. * @param Item $item 
12. * 
13. * @return bool 
14. */ 
15. public function isSatisfiedBy(Item $item); 
16.  
17. /** 
18. * 创建一个逻辑与规格（AND） 
19. * 
20. * @param SpecificationInterface $spec 
21. */ 
22. public function plus(SpecificationInterface $spec); 
23. /** 
24. * 创建一个逻辑或规格（OR） 
25. * 
26. * @param SpecificationInterface $spec 
27. */ 
28. public function either(SpecificationInterface $spec); 
29.  
30. /** 
31. * 创建一个逻辑非规格（NOT） 
32. */ 
33. public function not(); 
34. } 

AbstractSpecification.php

1. <?php 
2. namespace DesignPatterns\Behavioral\Specification; 
3.  
4. /** 
5. * 规格抽象类 
6. */ 
7. abstract class AbstractSpecification implements SpecificationInterface 
8. { 
9. /** 
10. * 检查给定Item是否满足所有规则 
11. * 
12. * @param Item $item 
13. * 
14. * @return bool 
15. */ 
16. abstract public function isSatisfiedBy(Item $item); 
17. /** 
18. * 创建一个新的逻辑与规格（AND） 
19. * 
20. * @param SpecificationInterface $spec 
21. * 
22. * @return SpecificationInterface 
23. */ 
24. public function plus(SpecificationInterface $spec) 
25. { 
26. return new Plus($this, $spec); 
27. } 
28. /** 
29. * 创建一个新的逻辑或组合规格（OR） 
30. * 
31. * @param SpecificationInterface $spec 
32. * 
33. * @return SpecificationInterface 
34. */ 
35. public function either(SpecificationInterface $spec) 
36. { 
37. return new Either($this, $spec); 
38. } 
39. /** 
40. * 创建一个新的逻辑非规格（NOT） 
41. * 
42. * @return SpecificationInterface 
43. */ 
44. public function not() 
45. { 
46. return new Not($this); 
47. } 
48. } 

Plus.php

1. <?php 
2. namespace DesignPatterns\Behavioral\Specification; 
3. /** 
4. * 逻辑与规格（AND） 
5. */ 
6. class Plus extends AbstractSpecification 
7. { 
8. protected $left; 
9. protected $right; 
10.  
11. /** 
12. * 在构造函数中传入两种规格 
13. * 
14. * @param SpecificationInterface $left 
15. * @param SpecificationInterface $right 
16. */ 
17. public function __construct(SpecificationInterface $left, SpecificationInterface $right) 
18. { 
19. $this->left = $left; 
20. $this->right = $right; 
21. } 
22. /** 
23. * 返回两种规格的逻辑与评估 
24. * 
25. * @param Item $item 
26. * 
27. * @return bool 
28. */ 
29. public function isSatisfiedBy(Item $item) 
30. { 
31. return $this->left->isSatisfiedBy($item) && $this->right->isSatisfiedBy($item); 
32. } 
33. } 

Either.php

1. <?php 
2. namespace DesignPatterns\Behavioral\Specification; 
3.  
4. /** 
5. * 逻辑或规格 
6. */ 
7. class Either extends AbstractSpecification 
8. { 
9.  
10. protected $left; 
11. protected $right; 
12. /** 
13. * 两种规格的组合 
14. * 
15. * @param SpecificationInterface $left 
16. * @param SpecificationInterface $right 
17. */ 
18. public function __construct(SpecificationInterface $left, SpecificationInterface $right) 
19. { 
20. $this->left = $left; 
21. $this->right = $right; 
22. } 
23. /** 
24. * 返回两种规格的逻辑或评估 
25. * 
26. * @param Item $item 
27. * 
28. * @return bool 
29. */ 
30. public function isSatisfiedBy(Item $item) 
31. { 
32. return $this->left->isSatisfiedBy($item) || $this->right->isSatisfiedBy($item); 
33. } 
34. } 

Not.php

1. <?php 
2. namespace DesignPatterns\Behavioral\Specification; 
3.  
4. /** 
5. * 逻辑非规格 
6. */ 
7. class Not extends AbstractSpecification 
8. { 
9. protected $spec; 
10. /** 
11. * 在构造函数中传入指定规格 
12. * 
13. * @param SpecificationInterface $spec 
14. */ 
15. public function __construct(SpecificationInterface $spec) 
16. { 
17. $this->spec = $spec; 
18. } 
19. /** 
20. * 返回规格的相反结果 
21. * 
22. * @param Item $item 
23. * 
24. * @return bool 
25. */ 
26. public function isSatisfiedBy(Item $item) 
27. { 
28. return !$this->spec->isSatisfiedBy($item); 
29. } 
30. } 

PriceSpecification.php

1. <?php 
2. namespace DesignPatterns\Behavioral\Specification; 
3.  
4. /** 
5. * 判断给定Item的价格是否介于最小值和最大值之间的规格 
6. */ 
7. class PriceSpecification extends AbstractSpecification 
8. { 
9. protected $maxPrice; 
10. protected $minPrice; 
11. /** 
12. * 设置最大值 
13. * 
14. * @param int $maxPrice 
15. */ 
16. public function setMaxPrice($maxPrice) 
17. { 
18. $this->maxPrice = $maxPrice; 
19. } 
20. /** 
21. * 设置最小值 
22. * 
23. * @param int $minPrice 
24. */ 
25. public function setMinPrice($minPrice) 
26. { 
27. $this->minPrice = $minPrice; 
28. } 
29. /** 
30. * 判断给定Item的定价是否在最小值和最大值之间 
31. * 
32. * @param Item $item 
33. * 
34. * @return bool 
35. */ 
36. public function isSatisfiedBy(Item $item) 
37. { 
38. if (!emptyempty($this->maxPrice) && $item->getPrice() > $this->maxPrice) { 
39. return false; 
40. } 
41. if (!emptyempty($this->minPrice) && $item->getPrice() < $this->minPrice) { 
42. return false; 
43. } 
44. return true; 
45. } 
46. } 

4、测试代码

Tests/SpecificationTest.php

1. <?php 
2. namespace DesignPatterns\Behavioral\Specification\Tests; 
3. use DesignPatterns\Behavioral\Specification\PriceSpecification; 
4. use DesignPatterns\Behavioral\Specification\Item; 
5. /** 
6. * SpecificationTest 用于测试规格模式 
7. */ 
8. class SpecificationTest extends \PHPUnit_Framework_TestCase 
9. { 
10. public function testSimpleSpecification() 
11. { 
12. $item = new Item(100); 
13. $spec = new PriceSpecification(); 
14. $this->assertTrue($spec->isSatisfiedBy($item)); 
15. $spec->setMaxPrice(50); 
16. $this->assertFalse($spec->isSatisfiedBy($item)); 
17. $spec->setMaxPrice(150); 
18. $this->assertTrue($spec->isSatisfiedBy($item)); 
19. $spec->setMinPrice(101); 
20. $this->assertFalse($spec->isSatisfiedBy($item)); 
21. $spec->setMinPrice(100); 
22. $this->assertTrue($spec->isSatisfiedBy($item)); 
23. } 
24. public function testNotSpecification() 
25. { 
26. $item = new Item(100); 
27. $spec = new PriceSpecification(); 
28. $not = $spec->not(); 
29. $this->assertFalse($not->isSatisfiedBy($item)); 
30. $spec->setMaxPrice(50); 
31. $this->assertTrue($not->isSatisfiedBy($item)); 
32. $spec->setMaxPrice(150); 
33. $this->assertFalse($not->isSatisfiedBy($item)); 
34. $spec->setMinPrice(101); 
35. $this->assertTrue($not->isSatisfiedBy($item)); 
36. $spec->setMinPrice(100); 
37. $this->assertFalse($not->isSatisfiedBy($item)); 
38. } 
39. public function testPlusSpecification() 
40. { 
41. $spec1 = new PriceSpecification(); 
42. $spec2 = new PriceSpecification(); 
43. $plus = $spec1->plus($spec2); 
44. $item = new Item(100); 
45. $this->assertTrue($plus->isSatisfiedBy($item)); 
46. $spec1->setMaxPrice(150); 
47. $spec2->setMinPrice(50); 
48. $this->assertTrue($plus->isSatisfiedBy($item)); 
49. $spec1->setMaxPrice(150); 
50. $spec2->setMinPrice(101); 
51. $this->assertFalse($plus->isSatisfiedBy($item)); 
52. $spec1->setMaxPrice(99); 
53. $spec2->setMinPrice(50); 
54. $this->assertFalse($plus->isSatisfiedBy($item)); 
55. } 
56. public function testEitherSpecification() 
57. { 
58. $spec1 = new PriceSpecification(); 
59. $spec2 = new PriceSpecification(); 
60. $either = $spec1->either($spec2); 
61. $item = new Item(100); 
62. $this->assertTrue($either->isSatisfiedBy($item)); 
63. $spec1->setMaxPrice(150); 
64. $spec2->setMaxPrice(150); 
65. $this->assertTrue($either->isSatisfiedBy($item)); 
66. $spec1->setMaxPrice(150); 
67. $spec2->setMaxPrice(0); 
68. $this->assertTrue($either->isSatisfiedBy($item)); 
69. $spec1->setMaxPrice(0); 
70. $spec2->setMaxPrice(150); 
71. $this->assertTrue($either->isSatisfiedBy($item)); 
72. $spec1->setMaxPrice(99); 
73. $spec2->setMaxPrice(99); 
74. $this->assertFalse($either->isSatisfiedBy($item)); 
75. } 
76. }

Tags: PHP设计模式 specification

分享到：