本文用到的编程语言为C#，具体思路不限制编程语言。

刚才正在浏览http://ruby-china.org/topics/7384的时候，看到5楼的回复，突然有一种想法，不知道优劣，请大家帮忙评判一下，或者给出一些更好的实现方案。

我们先来上一段代码，就是常见的一种代码。

1. Order getOrder(string orderNo)
2. {
3. order = repo.getOrder(orderNo);
4. if(order.condition1)
5. {
6. ...
7. }
8. if(order.condition2)
9. {
10. ...
11. }
12. if(order.condition3)
13. {
14. ...
15. }
16. .
17. .
18. .
19. }

上面是一段伪代码，实现的就是一个根据订单号，获取订单，然后根据订单的一些条件进行一些处理。

order是获取出来的订单，condition1、condition2、condition3是一些条件。随着业务的复杂，condition3后面还可能更多的condition，就需要添加更多的if，进行更多的判断，然后这个方法越来越长，越来越难以读懂，越来越难以维护，越来越。。。

我想是不是可以换个角度，不是订单来判断条件，然后执行一些代码。而是订单进入一个处理流程，然后处理流程中有很多的闸门，每个闸门代表一个特征条件处理器，然后由这个处理器来判断流经自己的订单是否符合条件，符合就处理，不符合就掠过。

这样有几个好处：

1. 上面代码中的获取订单方法，不会越来越长，这样阅读起来就很好理解，在后面进行维护的时候，就很容易来做了。
2. 添加一个新的条件处理分支也很容易，只要把这种条件处理看做是一个闸门，在处理流水线中加入新闸门就可以了，其他的都不需要变化。
3. 调整原来的条件处理，也只需要修改闸门内部的处理代码即可，不用担心是否影响其他处理分支。
4. 分支独立之后，还可以针对每个分支做单元测试。

其实扩展开来想，这个流程不仅可以处理订单，任何针对一个对象进行流程化处理的场景，都可以套用上面的代码结构，都可以得到上面的好处。

我画了一个示意图。

图 1.1 对象处理流水线

放出一段示例代码。

1. public interface IRepo
2. {
3. string getOrder(string orderNo);
4. }
5. public class Repo : IRepo
6. {
7. public string getOrder(string orderNo)
8. {
9. return string.Empty;
10. }
11. }
12. public class Client
13. {
14. public void getOrder(string orderNo)
15. {
16. var order = new Repo().getOrder(orderNo);
17. var pipeline = new Pipeline();
18. var handle1 = new condition1_Handle();
19. var handle2 = new condition2_Handle();
20. pipeline.add_order(order);
21. pipeline.add_handle(handle1);
22. pipeline.add_handle(handle2);
23. pipeline.processOrder();
24. }
25. }
26. class Pipeline
27. {
28. private List<IHandle> _handles;
29. private string _order;
30. public Pipeline()
31. { _handles = new List<IHandle>(); }
32. internal void add_order(string order)
33. {
34. this._order = order;
35. }
36. internal void add_handle(IHandle handle1)
37. {
38. _handles.Add(handle1);
39. }
40. internal void processOrder()
41. {
42. foreach (var h in _handles)
43. {
44. h.process(_order);
45. }
46. }
47. }
48. public interface IHandle
49. {
50. void process(string order);
51. }
52. public class condition1_Handle : IHandle
53. {
54. public  void process(string _order)
55. {
56. throw new NotImplementedException();
57. }
58. }
59. public class condition2_Handle : IHandle
60. {
61. public void process(string _order)
62. {
63. throw new NotImplementedException();
64. }
65. }

感觉有点像是策略模式，但是感觉又不太像。

上面的代码还有优化的空间，大家有没有更好的方案呢，欢迎大家一起讨论！

稍加改进，引入泛型，就可以支持任意类型的对象处理。

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
5. namespace ConsoleClient.Pipeline
6. {
7. public interface IRepo
8. {
9. Purchase getOrder(string orderNo);
10. Product getProduct(int id);
11. }
12. public class Repo : IRepo
13. {
14. public Purchase getOrder(string orderNo)
15. {
16. return new Purchase();
17. }
18. public Product getProduct(int id)
19. {
20. return new Product();
21. }
22. }
23. public class Client
24. {
25. public Purchase getOrder(string orderNo)
26. {
27. var order = new Repo().getOrder(orderNo);
28. var pipeline = new Pipeline<Purchase>();
29. var handle1 = new condition1_orderHandle();
30. var handle2 = new condition2_orderHandle();
31. pipeline.add_order(order);
32. pipeline.add_handle(handle1);
33. pipeline.add_handle(handle2);
34. pipeline.processOrder();
35. return order;
36. }
37. public Product getProduct(int id)
38. {
39. var product = new Repo().getProduct(id);
40. var pipeline = new Pipeline<Product>();
41. var handle1 = new condition1_productHandle();
42. var handle2 = new condition2_productHandle();
43. pipeline.add_order(product);
44. pipeline.add_handle(handle1);
45. pipeline.add_handle(handle2);
46. pipeline.processOrder();
47. return product;
48. }
49. }
50. public class Pipeline<T>
51. {
52. private List<IHandle<T>> _handles;
53. private T _order;
54. public Pipeline()
55. { _handles = new List<IHandle<T>>(); }
56. public void add_order(T order)
57. {
58. this._order = order;
59. }
60. public void add_handle(IHandle<T> handle1)
61. {
62. _handles.Add(handle1);
63. }
64. public void processOrder()
65. {
66. foreach (var h in _handles)
67. {
68. h.process(_order);
69. }
70. }
71. }
72. public class Purchase
73. {
74. public bool IsPay { get; set; }
75. }
76. public class Product
77. {
78. public bool IsExpired { get; set; }
79. }
80. public interface IHandle<T>
81. {
82. void process(T order);
83. }
84. public class condition1_orderHandle : IHandle<Purchase>
85. {
86. public void process(Purchase order)
87. {
88. if (order.IsPay == false )
89. {
90. Console.WriteLine("you don't pay money");
91. }
92. }
93. }
94. public class condition2_orderHandle : IHandle<Purchase>
95. {
96. public void process(Purchase order)
97. {
98. }
99. }
100. public class condition1_productHandle : IHandle<Product>
101. {
102. public void process(Product product)
103. {
104. }
105. }
106. public class condition2_productHandle : IHandle<Product>
107. {
108. public void process(Product product)
109. {
110. }
111. }
112. }

本文转自 virusswb 51CTO博客，原文链接：http://blog.51cto.com/virusswb/1081790，如需转载请自行联系原作者