1
00:00:00,800 --> 00:00:03,470
接下来，我们来看这个序列图

2
00:00:04,400 --> 00:00:05,740
因为序列图比较大

3
00:00:06,180 --> 00:00:09,770
我们就不好放在幻灯片里面来看了

4
00:00:11,060 --> 00:00:12,130
下面还有很多

5
00:00:13,950 --> 00:00:18,010
我们这里逆转的是合同

6
00:00:22,180 --> 00:00:23,930
的下面，在这个地方

7
00:00:28,820 --> 00:00:34,000
这里有一个

8
00:00:37,560 --> 00:00:38,930
计算收入确认的操作

9
00:00:39,600 --> 00:00:41,900
然后操作里面的代码

10
00:00:42,570 --> 00:00:46,240
也就是说，这个序列图不是整个用例的

11
00:00:46,250 --> 00:00:49,920
而是说某一个方法后面的序列图

12
00:00:51,030 --> 00:00:54,260
你可以针对某一个方法来画序列图

13
00:00:54,730 --> 00:00:56,130
某个操作来画序列图

14
00:00:56,770 --> 00:00:59,430
这个操作被调用之后后面发生什么事情

15
00:01:00,810 --> 00:01:01,520
这个说的就是

16
00:01:03,020 --> 00:01:06,410
“计算收入确认”被调用之后发生的事情

17
00:01:08,050 --> 00:01:10,970
这个是在合同这里了

18
00:01:14,140 --> 00:01:15,530
收到以后，合同

19
00:01:15,540 --> 00:01:19,400
这里我们要注意的

20
00:01:24,120 --> 00:01:28,530
我们这里面并没有用到数据入口这个类

21
00:01:31,180 --> 00:01:35,720
记录集的组装

22
00:01:35,730 --> 00:01:37,400
就是在主程序里面组装

23
00:01:37,410 --> 00:01:39,180
这样就完成了

24
00:01:39,190 --> 00:01:41,700
跟刚才展示的Fowler书上

25
00:01:44,690 --> 00:01:46,000
有不太一样的地方

26
00:01:46,430 --> 00:01:49,140
这个是两个表模块的合作了

27
00:01:52,950 --> 00:01:59,950
它过来，这里，你看它调用了这个

28
00:02:01,770 --> 00:02:10,170
后面就是相关的数据表

29
00:02:10,180 --> 00:02:12,860
这些都是框架

30
00:02:12,870 --> 00:02:15,750
或者背后的平台定义好的

31
00:02:17,720 --> 00:02:19,330
主要我们写的代码

32
00:02:20,130 --> 00:02:22,440
我们要关注的是前面的部分

33
00:02:23,630 --> 00:02:24,660
两个表模块之间

34
00:02:24,670 --> 00:02:26,660
还有三个表模块之间

35
00:02:27,470 --> 00:02:32,890
它们之间的调用或者协作

36
00:02:34,470 --> 00:02:36,430
我们来看一下这个代码

37
00:02:41,750 --> 00:02:45,400
我们直接一边运行一边看就好了

38
00:02:53,500 --> 00:02:55,990
首先，你看它这里

39
00:02:56,000 --> 00:03:00,440
并没有像前面案例示例一样

40
00:03:02,410 --> 00:03:06,310
它用了一个SQLite的数据库

41
00:03:06,560 --> 00:03:08,950
没有，它这个就没有用实际数据库

42
00:03:09,540 --> 00:03:11,680
直接在代码里面定义表

43
00:03:12,410 --> 00:03:16,640
然后填充数据，然后直接填充记录集

44
00:03:18,940 --> 00:03:20,060
但是这个表结构

45
00:03:20,070 --> 00:03:22,520
和我们刚才幻灯片里面看的

46
00:03:22,770 --> 00:03:23,840
表结构是一样的

47
00:03:23,970 --> 00:03:27,240
也是跟之前事务脚本中

48
00:03:28,070 --> 00:03:29,050
SQLite表结构是一样的

49
00:03:30,140 --> 00:03:36,980
先定义一个数据集对象

50
00:03:39,770 --> 00:03:41,290
然后用来放置表

51
00:03:45,570 --> 00:03:48,560
然后再定义一个，新建一个表

52
00:03:50,830 --> 00:03:56,390
就按照前面幻灯片类图方案来创建了

53
00:03:57,190 --> 00:04:00,480
表，列的名称，类型

54
00:04:00,490 --> 00:04:04,670
跟我们数据库里面的设计是一样的

55
00:04:05,510 --> 00:04:07,670
完了，填充行

56
00:04:09,610 --> 00:04:12,810
表的结构有了，就往里面填数据

57
00:04:13,530 --> 00:04:14,350
数据就是一行

58
00:04:14,640 --> 00:04:20,820
列、表是结构本身，行就是数据

59
00:04:22,190 --> 00:04:23,460
这个是产品了

60
00:04:24,090 --> 00:04:26,900
合同也是一样，如法炮制，合同

61
00:04:28,360 --> 00:04:29,470
然后，填数据

62
00:04:31,170 --> 00:04:35,170
然后，收入确认表，填数据

63
00:04:35,670 --> 00:04:36,840
这几个表有了

64
00:04:37,050 --> 00:04:38,960
然后它就把这几个表

65
00:04:39,730 --> 00:04:44,490
添加到数据集的Tables集合里面

66
00:04:44,620 --> 00:04:47,530
表集合里面，它的属性的名称

67
00:04:48,040 --> 00:04:49,610
Tables，实际上也就是对应

68
00:04:49,620 --> 00:04:50,690
我们前面类图里面

69
00:04:50,700 --> 00:04:52,720
那个角色上面

70
00:04:53,250 --> 00:04:55,830
角色上面有个Tables

71
00:04:57,670 --> 00:05:02,270
就这个地方，添加这个，数据集弄好了

72
00:05:03,330 --> 00:05:08,150
数据集在这里

73
00:05:08,710 --> 00:05:12,290
然后就用这个数据集

74
00:05:12,300 --> 00:05:15,430
作为参数来创建表模块了

75
00:05:15,560 --> 00:05:19,660
首先创建的，合同这个表模块

76
00:05:26,560 --> 00:05:29,090
创建，这是合同表模块的定义了

77
00:05:29,220 --> 00:05:32,490
跳转到合同表模块的定义

78
00:05:32,500 --> 00:05:37,020
你看，它继承了这个表模块的超类

79
00:05:41,570 --> 00:05:46,980
然后参数就是一个数据集

80
00:05:48,000 --> 00:05:49,930
数据集怎么组装

81
00:05:49,940 --> 00:05:51,820
是在另外一个地方了

82
00:05:51,830 --> 00:05:53,710
它这里是不管组装的

83
00:05:53,720 --> 00:05:56,170
就是刚才你看，放在主程序那里

84
00:05:56,700 --> 00:06:02,300
由主程序调用数据入口来创建

85
00:06:02,310 --> 00:06:04,460
因为刚才比较简单

86
00:06:04,470 --> 00:06:07,940
它在代码里面硬编码了，实际上应该是什么

87
00:06:08,300 --> 00:06:09,980
像刚才那个序列图一样

88
00:06:10,310 --> 00:06:11,920
通过入口也好

89
00:06:11,930 --> 00:06:13,440
你直接去查询也好

90
00:06:14,510 --> 00:06:15,670
返回一个数据集

91
00:06:15,880 --> 00:06:17,260
然后来组装

92
00:06:20,060 --> 00:06:24,740
然后，调用了超类的构造器

93
00:06:25,330 --> 00:06:30,680
然后把数据集放进去

94
00:06:30,690 --> 00:06:32,720
因为构造器有两个参数

95
00:06:32,890 --> 00:06:34,360
所以这里要加一个参数

96
00:06:34,370 --> 00:06:36,590
这是一个表名

97
00:06:37,060 --> 00:06:40,330
就是合同的表名

98
00:06:43,220 --> 00:06:48,110
也就是说，我这个表模块绑定的

99
00:06:48,120 --> 00:06:50,150
或者说，对应的是这个表

100
00:06:56,210 --> 00:06:59,380
然后你看，它调用超类的构造器

101
00:06:59,720 --> 00:07:01,340
在这里，刚才讲了

102
00:07:02,620 --> 00:07:05,050
构造器里面做了什么，只做了一件事情

103
00:07:05,060 --> 00:07:10,860
就是把这个表

104
00:07:12,100 --> 00:07:12,880
指定为

105
00:07:15,740 --> 00:07:18,470
这个记录集里面的某个表

106
00:07:19,420 --> 00:07:21,050
记录集有很多个表

107
00:07:21,660 --> 00:07:23,750
我就指定

108
00:07:24,080 --> 00:07:26,850
Table指定为哪个表

109
00:07:34,540 --> 00:07:39,740
创建新的表模块的对象，这个就有了

110
00:07:40,950 --> 00:07:44,980
有了之后，就调用它的

111
00:07:46,330 --> 00:07:48,030
或者执行它操作了

112
00:07:49,140 --> 00:07:52,010
计算收入确认的操作

113
00:07:52,020 --> 00:07:57,440
参数是1，就是合同的ID

114
00:07:57,770 --> 00:07:59,920
在这里，跳转到它的定义

115
00:08:00,090 --> 00:08:01,160
合同ID在这里

116
00:08:03,430 --> 00:08:05,110
所以你看它，这个表模块

117
00:08:05,120 --> 00:08:06,310
它并不是真的是

118
00:08:07,560 --> 00:08:10,380
像我们实体类的对象一样

119
00:08:10,390 --> 00:08:11,660
如果是真的是面向对象

120
00:08:12,390 --> 00:08:13,670
还什么ID

121
00:08:13,680 --> 00:08:16,030
我自己怎么不知道自己ID 

122
00:08:16,040 --> 00:08:19,810
你只要说直接调用

123
00:08:21,340 --> 00:08:25,740
对象.计算收入确认，就完了

124
00:08:27,640 --> 00:08:29,870
不用后面加ID

125
00:08:29,880 --> 00:08:31,470
所以这是假的

126
00:08:31,480 --> 00:08:35,720
因为它一个表里面有很多个对象

127
00:08:36,250 --> 00:08:37,170
你必须要指出ID

128
00:08:37,180 --> 00:08:41,800
是针对哪个ID的数据来执行

129
00:08:44,860 --> 00:08:46,860
我们看，它怎么做的

1
00:00:00,480 --> 00:00:02,840
首先，它这里，这一步

2
00:00:03,630 --> 00:00:07,180
它定义了一个数据行的对象

3
00:00:08,160 --> 00:00:10,600
然后根据ID来获取合同

4
00:00:11,420 --> 00:00:12,820
一行相当于一个对象

5
00:00:17,700 --> 00:00:24,930
继续，然后定义了一个变量

6
00:00:25,220 --> 00:00:28,880
来获取这行里面的字段

7
00:00:28,970 --> 00:00:31,230
因为一行里面有几个

8
00:00:31,860 --> 00:00:33,370
相当于一个对象有几个属性

9
00:00:33,500 --> 00:00:34,690
一行有几个字段

10
00:00:37,100 --> 00:00:40,670
收入字段的值，给放到这个里面

11
00:00:44,790 --> 00:00:48,470
然后

12
00:00:48,910 --> 00:00:50,570
在这里面

13
00:00:50,580 --> 00:00:57,230
创建了一个收入确认的表模块的对象

14
00:00:57,910 --> 00:01:02,840
这个跟我们前面主程序里面

15
00:01:02,850 --> 00:01:08,130
创建合同的表模块对象是一样的

16
00:01:08,140 --> 00:01:10,490
但是这个表模块对象是在这里创建的

17
00:01:11,270 --> 00:01:17,560
是在这个合同这个类代码里面创建的

18
00:01:19,690 --> 00:01:25,050
同样，数据集，一样的

19
00:01:27,140 --> 00:01:34,040
然后，创建，跟刚才一样

20
00:01:34,920 --> 00:01:37,630
但是收入确认这个表模块

21
00:01:39,030 --> 00:01:41,430
它这里有一个，继承表模块超类

22
00:01:41,440 --> 00:01:42,710
这个一样

23
00:01:45,190 --> 00:01:48,630
这里有一个，定义了一个

24
00:01:48,800 --> 00:01:51,100
静态的整型的变量

25
00:01:51,410 --> 00:01:52,600
来放置标识

26
00:01:54,510 --> 00:01:58,700
后面它有一个自己生成标识的

27
00:01:59,330 --> 00:02:01,700
也就是说，它这里要把这个标识

28
00:02:03,540 --> 00:02:05,350
由它这个代码这里来管的

29
00:02:06,140 --> 00:02:07,340
当然你也可以说

1
00:00:01,150 --> 00:00:04,380
另外一个方法，就是更好的

2
00:00:04,910 --> 00:00:11,340
比如说，用递增的标识

3
00:00:12,020 --> 00:00:13,580
由系统来管这个事情

4
00:00:15,150 --> 00:00:17,130
比如说，整数的递增

5
00:00:18,180 --> 00:00:23,250
或者是GUID，由平台来生成

6
00:00:26,260 --> 00:00:31,820
类似这样，GUID，有的gu-yi-de

7
00:00:31,830 --> 00:00:35,870
有的就念guid，包括老外怎么念的都有

8
00:00:36,620 --> 00:00:38,260
好像就叫guid就可以了

9
00:00:38,720 --> 00:00:40,040
不知道大家平时怎么念的

10
00:00:41,280 --> 00:00:41,680
都可以

11
00:00:44,970 --> 00:00:47,310
这个是一样的，生成

12
00:00:49,090 --> 00:00:51,350
然后表名也是跟刚才一样了

13
00:00:51,730 --> 00:00:52,780

14
00:00:53,900 --> 00:00:54,580

15
00:01:02,060 --> 00:01:04,570
把它的记录集放进去

16
00:01:05,040 --> 00:01:09,730
这个也是一样

17
00:01:10,440 --> 00:01:13,870
这个也是，另外一个表模块，这个一样的

18
00:01:15,100 --> 00:01:23,840
也就是说，在合同

19
00:01:23,850 --> 00:01:25,160
这里面

20
00:01:26,150 --> 00:01:28,360
它就另外又生成了

21
00:01:29,130 --> 00:01:30,690
两个表模块的对象

22
00:01:30,700 --> 00:01:32,010
来供它调用

23
00:01:33,080 --> 00:01:38,000
这个严格来说不是那么合理的

24
00:01:39,000 --> 00:01:40,750
因为这三个是平等的

25
00:01:40,760 --> 00:01:45,390
应该是由外面的一个调用者来调用才对

26
00:01:46,560 --> 00:01:49,820
外面由应用服务类来调用才对

27
00:01:50,120 --> 00:01:52,350
这里面，一个表模块里面

28
00:01:52,360 --> 00:01:55,710
然后又有另外几个表模块

29
00:01:56,400 --> 00:01:59,290
它们之间实际上静态上没有什么关系，实际上

30
00:01:59,300 --> 00:02:01,550
因为它是表模块

31
00:02:02,180 --> 00:02:02,510

32
00:02:02,520 --> 00:02:05,450
又不是对象，订单、订单项

33
00:02:05,940 --> 00:02:07,840
商品，让你这样调用

34
00:02:08,480 --> 00:02:09,240
这可以

35
00:02:09,250 --> 00:02:10,540
因为我们有静态关系

36
00:02:11,070 --> 00:02:13,600
我们三个实际上是独立的类

37
00:02:14,160 --> 00:02:15,580
类上面来说，实际上是独立的

38
00:02:19,220 --> 00:02:20,780
它本身并没有静态关系

39
00:02:21,910 --> 00:02:25,600
这样当然是可以的

40
00:02:25,610 --> 00:02:26,940
但这样的话

41
00:02:26,950 --> 00:02:28,180
就相当于，本来是跟它

42
00:02:28,510 --> 00:02:30,060
没有静态关系的几个东西

43
00:02:30,880 --> 00:02:33,450
它就建立了动态关系了

44
00:02:34,120 --> 00:02:35,900
不是不可以

45
00:02:36,030 --> 00:02:37,260
尽量要避免

46
00:02:39,030 --> 00:02:42,740
比如说，我们可以由外面一个类

47
00:02:44,370 --> 00:02:46,010
比如应用服务类来做这个事情

48
00:02:46,480 --> 00:02:49,570
这里比较简单的演示，就不管了

49
00:02:51,110 --> 00:02:59,270
然后把，这里有一个

50
00:03:00,760 --> 00:03:03,690
获取这个产品ID，根据合同ID

51
00:03:03,700 --> 00:03:06,320
获取产品ID的这样一个操作

52
00:03:06,410 --> 00:03:08,120
也就是说，类里面的操作

53
00:03:08,990 --> 00:03:09,870
操作在这里

54
00:03:11,850 --> 00:03:12,870
刚才在这里

55
00:03:13,370 --> 00:03:18,360
这个地方

56
00:03:18,720 --> 00:03:21,160
也就是说，把怎样

57
00:03:21,170 --> 00:03:22,400
从合同ID

58
00:03:22,410 --> 00:03:23,560
获取产品ID

59
00:03:24,760 --> 00:03:25,820
把它封装起来

60
00:03:26,150 --> 00:03:30,160
封装起来，这个地方

61
00:03:32,700 --> 00:03:40,850
然后，这个一样的

62
00:03:40,860 --> 00:03:42,210
你看，这是一个ID

63
00:03:44,020 --> 00:03:45,460
合同ID获得产品ID

64
00:03:45,630 --> 00:03:46,340
这个也是一样

65
00:03:46,350 --> 00:03:51,140
根据产品ID获得产品类型

66
00:03:53,260 --> 00:03:55,520
这时候它就调用了这个了

67
00:03:55,530 --> 00:04:01,060
产品表模块的操作

68
00:04:01,070 --> 00:04:02,660
就是获取产品类型的操作

69
00:04:04,950 --> 00:04:08,640
我们来看，操作在这里

70
00:04:09,110 --> 00:04:10,630
产品那个表模块在这里

71
00:04:11,440 --> 00:04:14,310
操作在这里，根据ID来查找产品类型