1引言

在标题的取名上，不敢说颇费心机，也算得上花费了一点功夫的。首先想到的是“架构设计过程”，又觉得是不是太大了，因为例子比较局部，不是很完整。叫做“结构变化过程”可能更好点。但是又怕名字取的小气了，进来的人少，参与讨论的就更少了，最终还是取了这个有点忽悠人的标题“架构演进”。

今天的这个架构演进，使用系统中一个局部的实例进行推导和演进，一起来观察一下，架构是如何不满足需求的？架构如何演进？更好的架构应该具备哪些条件？有没有更好的呢？

业务场景

图1 业务场景图

从上图可以看出，就是一个电子商务网站常见的支付、支付的后续处理，这样一个业务场景。支持多种支付方式，目前包括银联、支付宝，还有平台账户。平台账户就是注册用户将资金存储在平台为用户建立并维护的一个账户里，购买平台的产品，可以使用平台账户中的资金进行支付。

2业务流程

首先用户选择商品。

下单，进行支付。

选择支付方式。

使用相应支付方式进行支付。第三方支付，会跳转到第三方的支付页面进行支付。

平台进行支付的后续处理，包括成功之后的修改状态等，还包括失败之后的记录标记等。

第三方的支付，在打开第三方支付界面的时候，会告诉它一个平台的回调地址，支付之后，通过回调地址接收第三方支付的结果，然后进行后续处理。使用平台账户支付，就直接进行后续处理就可以了。

当然，这其中还会有一些细节，不在我们的讨论范围。例如：使用平台账户进行支付，判断账户金额是否充足。使用第三方支付，是否记录第三方支付的完整过程，以及完整的支付流程。等等具体的业务细节均不在今天的讨论范围。

3初级架构-用存储过程搞定它

回调地址接收两个参数，一个是订单编号，一个是标志。标志说明是成功还是失败，或者是更加详细的信息。

1. CREATE PROCEDURE Proc_PaymentHandle  
2.     @OrderSeqNo VARCHAR(36),    --订单编号  
3.     @ReturnCode VARCHAR(10),    --返回状态码  
4.     @PaymentManner CHAR(1)     --支付方式：1银联，2支付宝，3平台账户  
5. AS  
6. BEGIN  
7.     IF(@PaymentManner='1')  
8.     BEGIN  
9.         --更新订单状态  
10.         --更新银联支付信息  
11.         RETURN;  
12.     END  
13.     ELSE IF(@PaymentManner='2')  
14.     BEGIN  
15.         --更新订单状态  
16.         --更新支付宝支付信息  
17.         RETURN;  
18.     END  
19.     ELSE IF(@PaymentManner='3')  
20.     BEGIN  
21.         --更新定的状态  
22.         --更新平台账户支付信息  
23.         RETURN;  
24.     END  
25. END  

配合一段C#代码，判断一下支付方式，然后给存储过程传递参数。这样写的话，上面的这个存储过程很容易就超过1k行了，相信大家也写过1k行以上的存储过程，也维护过这样的存储过程，知道个中的酸甜苦辣。

如果说那一天我们增加了一种支付方式，需要修改的地方包括哪些呢？

界面要修改，存储过程要打开修改，调用的C#代码要修改。真是有点麻烦，最主要的是容易改错了，误改了不应该动的地方才是最要命的。好吧，我们简单分离一下。每种支付方式一个存储过程，把对于支付方式的判断放在代码中，每种支付对应一个代码中的方法。这样需要增加一种的话，只要改改支付方式判断的代码，然后重新写一个存储过程，重新写一个方法调用一下新的存储过程就可以了。可是还有一个问题，更新订单状态好像大家都在做，如果哪一些还需要加一些大家都需要做的事情呢？或者说修改一些大家都需要做的事情的细节？又或者说某两个支付方式需要增加一个处理流程呢？打开存储过程，狂修改吧！！！！

存储过程有几个不便利的地方：

• 调试不方便
• 测试不方便
• 代码不能折叠，多了之后要拖动滚动条才能找得到
• 逻辑运算、大规模计算是存储过程的弱项

存储过程的优势至少也有一个，就是修改之后，马上可以见到效果。不用编译。

4中级架构-在代码中分离对每种信息的更新

之前的架构代码中有很多的重复地方，例如：对于订单信息的更新。如何把重复降低呢？降低重复也就集中了代码，集中了将来也好维护。而且把它分离出来，独立出来，好像更好点，在需要的地方调用就可以了。如果需要变更订单的更新细节，只要修改一下更新细节就可以了，不需要动支付的代码。减小犯错误的概率。

首先，将各种更新信息独立出来。

1. public class OrderRepository2  
2.     {  
3.         public void UpdateState()  
4.         { throw new System.Exception(); }  
5.     }  
6.     public class PlatformAccountRepository2  
7.     {  
8.         public void Update()  
9.         { throw new System.Exception(); }  
10.     }  
11.   
12.     public class ZhifubaoRepository2  
13.     {  
14.         public void Update()  
15.         { throw new System.Exception(); }  
16.     }  
17.     public class YinlianRepository2  
18.     {  
19.         public void Update()  
20.         { throw new System.Exception(); }  
21.     }  

使用下面的方法进行支付的后续处理。

1. public void HandlePaymentResult(PaymentManner2 paymentManner, string orderSeqNo)  
2.         {  
3.             switch (paymentManner)  
4.             {  
5.                 case PaymentManner2.PlatformAccount :  
6.                     var platformService = new PlatformAccountPaymentResultHandleService2();  
7.                     platformService.Handle(orderSeqNo);  
8.                     break;  
9.                 case PaymentManner2.Yinlian :  
10.                     var yinlianService = new YinlianPaymentResultHandleService2();  
11.                     yinlianService.Handle(orderSeqNo);  
12.                     break;  
13.                 case PaymentManner2.Zhifubao :  
14.                     var zhifubaoService = new ZhifubaoPaymentResultHandleService2();  
15.                     zhifubaoService.Handle(orderSeqNo);  
16.                     break;  
17.   
18.             }  
19.         }  

1. public enum PaymentManner2  
2.     {  
3.         Zhifubao,  
4.         Yinlian,  
5.         PlatformAccount  
6.     }  
7.     public class ZhifubaoPaymentResultHandleService2   
8.     {  
9.         private OrderRepository2 _orderManagement;  
10.         private ZhifubaoRepository2 _zhifubaoManagement;  
11.   
12.         public void Handle(string orderSeqNo)  
13.         {  
14.             using (TransactionScope scope = new TransactionScope())  
15.             {  
16.                 _orderManagement.UpdateState();  
17.                 this._zhifubaoManagement.Update();  
18.   
19.                 scope.Complete();  
20.             }  
21.         }  
22.   
23.     }  
24.     public class YinlianPaymentResultHandleService2   
25.     {  
26.         private OrderRepository2 _orderManagement;  
27.         private YinlianRepository2 _yinlianManagement;  
28.   
29.         public void Handle(string orderSeqNo)  
30.         {  
31.             using (TransactionScope scope = new TransactionScope())  
32.             {  
33.                 this._orderManagement.UpdateState();  
34.                 this._yinlianManagement.Update();  
35.   
36.                 scope.Complete();  
37.             }  
38.         }  
39.     }  
40.     public class PlatformAccountPaymentResultHandleService2   
41.     {  
42.         private OrderRepository2 _orderManagement;  
43.         private PlatformAccountRepository2 _platformAccountManagement;  
44.   
45.         public void Handle(string orderSeqNo)  
46.         {  
47.             using (TransactionScope scope = new TransactionScope())  
48.             {  
49.                 this._orderManagement.UpdateState();  
50.                 this._platformAccountManagement.Update();  
51.   
52.                 scope.Complete();  
53.             }  
54.         }  
55.   
56.     }  

增加支付方式的话，新建一个HandleService类，写一些处理代码，然后在public void HandlePaymentResult(PaymentManner2 paymentManner, string orderSeqNo)方法的switch中增加一个case就可以了。

但是页面的可选支付方式还是写死了，没有动态的变化，支付方式是否可以动态配置呢？而且可以方便的测试呢？例如：虽然我还没有银联的接口，但是我想测试一些，银联支付之后平台的处理是否正确，该更新的信息是否都更新了呢？没有银联的接口，是不是就不能做了呢？有没有办法解决呢？

答案是：有。

还有就是上面的switch。。。case，好像会很长，也很丑，这个地方能否改进呢？很多人在学习了重构之后，会提出很多的方法来解决这个问题，我们再后面也一块来解决一下。

5高级架构-少用存储过程处理业务的灵活架构

我们的高级架构有几个目标

减少存储过程中的业务逻辑，让存储过程更加纯粹的做事，做它擅长的事情。

可以灵活的增加或者减少支付方式。达到在增加或者减少支付方式的时候，尽量少的修改代码，尽量减少依赖。减少支付对于支付方式的依赖，支付方式对于后续处理的依赖。

代码结构更加清晰。

为了达到上面的几个目标，计划独立几个部分。

支付方式的管理。

每一种支付方式的处理过程。这个在中级架构里面已经做的差不多了，这里会做的更好一点，抽象这个支付处理过程。

还有就是要隐藏支付方式和具体的支付方式处理过程映射代码。具体的支付方式指的是：银联或者是支付宝这种具体的一种支付方式。目的就是让对于支付订单的处理独立化，固定化，支持变化。

5.1支付方式的管理

1. public enum PaymentManner1  
2.     {  
3.         Zhifubao,  
4.         Yinlian,  
5.         PlatformAccount  
6.     }  
7.   
8.     public class PaymentMannerParams  
9.     {  
10.         /// <summary>  
11.         /// 地址还是内部方法  
12.         /// </summary>  
13.         public UriOrFunction UriOrFunction { get; set; }  
14.        /// <summary>  
15.        /// 地址  
16.        /// </summary>  
17.         public string Uri { get; set; }  
18.         /// <summary>  
19.         /// 方法名  
20.         /// </summary>  
21.         public string FunctionName { get; set; }  
22.   
23.   
24.         enum UriOrFunction  
25.         {  
26.             Uri,  
27.             Function  
28.         }  
29.     }  
30.   
31.     public class PaymentMannerManagement1  
32.     {  
33.         public Dictionary<PaymentManner1, PaymentMannerParams > FindAvailableManner(decimal moneyOfPay)  
34.         {  
35.             throw new System.Exception();  
36.               
37.         }  
38.     }  

通过FindAvailableManner方法获取支付方式。每种支付方式PaymentManner，都带有一个参数实体PaymentMannerParams，里面的UriOrFunction来决定是通过网页还是内部方法来支付，Uri就跳转到Uri就可以了，Function就调用FunctionName中的方法就可以了。支付的时候用下面的Pay先获取支付方式信息，然后根据每种支付方式的参数来决定具体的支付。

1. public class OrderManagement1  
2.    {  
3.        public void  Pay(decimal money)  
4.        {  
5.            var manner= new PaymentMannerManagement1().FindAvailableManner(money);  
6.            //后续支付  
7.        }  
8.    }  

之前说的，如果银联还没有接口，或者接口暂时不能用了，想测试一下后续的处理，就可以将银联这种Manner的UriOrFunction设置为Function，现用内部的方法来测试后续的处理是否正确。等可以用的时候，在变更为Uri就可以了。

5.2支付过程的抽象

通过建立支付处理的接口，将支付处理的代码抽象成下面的样子。

1. public class Service1  
2.     {  
3.         public void HandlePaymentResult(PaymentManner1 paymentManner,string orderSeqNo)  
4.         {  
5.             IPaymentResultHandleService1 handleService = PaymentResultHandleServiceFactory1.GetService(paymentManner);  
6.             handleService.Handle(orderSeqNo);  
7.         }  
8.     }  

这个处理的代码，原则来说以后都不需要修改了。后面要做的就是定义一种新的支付方式枚举量，然后实现IPaymentResultHandleService1 接口，写一些处理的代码就可以了。

5.3完整代码

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5. using System.Transactions;  
6.   
7. namespace ConsoleApplication1  
8. {  
9.   
10.     public class Service1  
11.     {  
12.         public void HandlePaymentResult(PaymentManner1 paymentManner,string orderSeqNo)  
13.         {  
14.             IPaymentResultHandleService1 handleService = PaymentResultHandleServiceFactory1.GetService(paymentManner);  
15.             handleService.Handle(orderSeqNo);  
16.         }  
17.     }  
18.   
19.   
20.     public class OrderManagement1  
21.     {  
22.         public void  Pay(decimal money)  
23.         {  
24.             var manner= new PaymentMannerManagement1().FindAvailableManner(money);  
25.             //后续支付  
26.         }  
27.     }  
28.   
29.   
30.   
31.     public enum PaymentManner1  
32.     {  
33.         Zhifubao,  
34.         Yinlian,  
35.         PlatformAccount  
36.     }  
37.   
38.     public class PaymentMannerParams  
39.     {  
40.         /// <summary>  
41.         /// 地址还是内部方法  
42.         /// </summary>  
43.         public UriOrFunction UriOrFunction { get; set; }  
44.        /// <summary>  
45.        /// 地址  
46.        /// </summary>  
47.         public string Uri { get; set; }  
48.         /// <summary>  
49.         /// 方法名  
50.         /// </summary>  
51.         public string FunctionName { get; set; }  
52.   
53.   
54.         enum UriOrFunction  
55.         {  
56.             Uri,  
57.             Function  
58.         }  
59.     }  
60.   
61.     public class PaymentMannerManagement1  
62.     {  
63.         public Dictionary<PaymentManner1, PaymentMannerParams > FindAvailableManner(decimal moneyOfPay)  
64.         {  
65.             throw new System.Exception();  
66.               
67.         }  
68.     }  
69.   
70.     public class PaymentResultHandleServiceFactory1  
71.     {  
72.         private static  PaymentResultHandleServiceFactory1()  
73.         {  
74.             _serviceMap = new Dictionary<PaymentManner1, IPaymentResultHandleService1>();  
75.             _serviceMap.Add(PaymentManner1.PlatformAccount, new PlatformAccountPaymentResultHandleService1());  
76.             _serviceMap.Add(PaymentManner1.Yinlian, new YinlianPaymentResultHandleService1());  
77.             _serviceMap.Add(PaymentManner1.Zhifubao,new ZhifubaoPaymentResultHandleService1());  
78.         }  
79.   
80.         private static  Dictionary<PaymentManner1 , IPaymentResultHandleService1> _serviceMap;  
81.   
82.   
83.   
84.         public static IPaymentResultHandleService1 GetService(PaymentManner1 paymentManner )  
85.         {  
86.             return _serviceMap[paymentManner];  
87.         }  
88.   
89.     }  
90.   
91.     public interface IPaymentResultHandleService1  
92.     {  
93.         void Handle(string orderSeqNo);  
94.     }  
95.   
96.   
97.   
98.     public class ZhifubaoPaymentResultHandleService1:IPaymentResultHandleService1  
99.     {  
100.         private OrderRepository1 _orderManagement;  
101.         private ZhifubaoRepository1 _zhifubaoManagement;  
102.   
103.         public void Handle(string orderSeqNo)  
104.         {  
105.             using (TransactionScope scope = new TransactionScope())  
106.             {  
107.                 _orderManagement.UpdateState();  
108.                 this._zhifubaoManagement.Update();  
109.   
110.                 scope.Complete();  
111.             }  
112.         }  
113.   
114.     }  
115.     public class YinlianPaymentResultHandleService1 : IPaymentResultHandleService1  
116.     {  
117.         private OrderRepository1 _orderManagement;  
118.         private YinlianRepository1 _yinlianManagement;  
119.   
120.         public void Handle(string orderSeqNo)  
121.         {  
122.             using (TransactionScope scope = new TransactionScope())  
123.             {  
124.                 this._orderManagement.UpdateState();  
125.                 this._yinlianManagement.Update();   
126.                   
127.                 scope.Complete();  
128.             }  
129.         }  
130.     }  
131.     public class PlatformAccountPaymentResultHandleService1:IPaymentResultHandleService1   
132.     {  
133.         private OrderRepository1 _orderManagement;  
134.         private PlatformAccountRepository1 _platformAccountManagement;  
135.   
136.         public void Handle(string orderSeqNo)  
137.         {  
138.             using (TransactionScope scope = new TransactionScope())  
139.             {  
140.                 this._orderManagement.UpdateState();  
141.                 this._platformAccountManagement.Update();  
142.   
143.                 scope.Complete();  
144.             }  
145.         }  
146.   
147.     }  
148.     public class OrderRepository1  
149.     {  
150.         public void UpdateState()  
151.         { throw new System.Exception(); }  
152.     }  
153.     public class PlatformAccountRepository1  
154.     {  
155.         public void Update()  
156.         { throw new System.Exception(); }  
157.     }  
158.   
159.     public class ZhifubaoRepository1  
160.     {  
161.         public void Update()  
162.         { throw new System.Exception(); }  
163.     }  
164.     public class YinlianRepository1  
165.     {  
166.         public void Update()  
167.         { throw new System.Exception(); }  
168.     }  
169.   
170. }  

6总结

类的依赖最好使用抽象，避免具体类的直接引用。

尽量不要再存储过程中处理业务，随着系统越做越大，你会越来越赞同我的说法。原因至少两点：1维护累死人，2数据库不擅长数值计算和处理。

职责单一，功能独立，代码分离。