EDA365电子论坛网
标题:
什么是数据驱动编程
[打印本页]
作者:
thinkfunny
时间:
2020-1-14 11:11
标题:
什么是数据驱动编程
( g- j( ]4 N' }9 y0 Q9 o
前言:
3 f- m6 G$ t) J& T3 z- Z
: s' X& W2 C7 V# j& E
最近在学习《Unix编程艺术》。以前粗略的翻过,以为是介绍unix工具的。现在认真的看了下,原来是介绍设计原则的。它的核心就是第一章介绍的unix的哲学以及17个设计原则,而后面的内容就是围绕它来展开的。以前说过,要学习适合自己的资料,而判断是否适合的一个方法就是看你是否能够读得下去。我对这本书有一种相见恨晚的感觉。推荐有4~6年工作经验的朋友可以读一下。
0 i( J i$ G6 X% c# y
$ d, g* B+ O3 N. W7 ~' |
正题:
+ M! n0 J6 \ l3 _9 X6 o% G8 p3 y
$ O' h+ s( ?+ O4 n0 o
作者在介绍Unix设计原则时,其中有一条为“表示原则:把知识叠入数据以求逻辑质朴而健壮”。结合之前自己的一些经验,我对这个原则很有共鸣,所以先学习了数据驱动编程相关的内容,这里和大家分享出来和大家一起讨论。
% b3 @1 x9 u' g2 n' H
( P2 j) j& R4 s3 u, }
数据驱动编程的核心
! H" [* o1 T$ c: ~% C; l
( U/ r* m1 f( i- o& G
数据驱动编程的核心出发点是相对于程序逻辑,人类更擅长于处理数据。数据比程序逻辑更容易驾驭,所以我们应该尽可能的将设计的复杂度从程序代码转移至数据。
* c* u) ~) a: R) Q
$ D6 y2 V# {) m+ j* b& d4 c
真的是这样吗?让我们来看一个示例。
- m4 u" G+ w- J5 R& @0 b$ G" i
3 Z( s/ v, A$ q- ~$ L) @- F
假设有一个程序,需要处理其他程序发送的消息,消息类型是字符串,每个消息都需要一个函数进行处理。第一印象,我们可能会这样处理:
0 L: |9 H% t7 s
void msg_proc(const char *msg_type, const char *msg_buf)
+ u/ e5 r% ` w; r' B4 F7 Y
{
# r- k1 i6 a$ W3 E3 J% k
if (0 == strcmp(msg_type, "inivite"))
( X4 ^: q0 P; M& S/ y
{
* ^! F! ~& @) c% K x+ y
inivite_fun(msg_buf);
. k0 ~' W0 M6 r8 K; l' p K; C+ I/ C
}
) w# r5 D+ Z8 D4 `% T C
else if (0 == strcmp(msg_type, "tring_100"))
/ \. T, }, }6 f
{
$ _2 e$ w% p; G p& W3 ]
tring_fun(msg_buf);
6 m! |+ W' F& Z' T( l9 S4 ]
}
, A! j5 M9 x; A! `; I0 s
else if (0 == strcmp(msg_type, "ring_180"))
# g1 N' U1 M3 C
{
5 S0 a; t" ]$ b* U) u; r. G
ring_180_fun(msg_buf);
# t4 _2 \. B) M: G
}
; Q: V3 [" c& J7 o: c" i
else if (0 == strcmp(msg_type, "ring_181"))
; p9 G/ x0 v* h9 F! v
{
( B5 N$ E5 N5 O; H/ M7 e0 ~# J+ E9 O
ring_181_fun(msg_buf);
5 a& m( d) Z+ R; X, s; V+ I* \- ?
}
+ R F# B# p4 v, K' @
else if (0 == strcmp(msg_type, "ring_182"))
1 F/ M& m( k! d% x& Q2 Z+ i% b
{
, r/ {7 m+ K5 a, n- M# b/ r4 n0 G
ring_182_fun(msg_buf);
7 ]3 t9 s, [0 U# O5 x/ @
}
0 B7 S& `1 K" u
else if (0 == strcmp(msg_type, "ring_183"))
) K. r$ W5 D# N" w3 D+ p
{
# E& B' n/ C# U, \% b$ b+ I4 x
ring_183_fun(msg_buf);
# q8 _7 Y* E3 ~/ X; w# f6 w& f. a6 s7 I
}
! q S$ ]; E D/ c+ C
else if (0 == strcmp(msg_type, "ok_200"))
4 f) u' U6 O/ T2 F
{
1 Y4 E2 p! y9 T1 y6 b1 j1 n
ok_200_fun(msg_buf);
3 c, s% v& q( a) H! F
}
/ Z' W) f* p' A0 }3 }/ s4 [( r
8 g: @. u* ~% w& ?
。。。。。。
2 S" Q: |. S, F4 T: h4 Q! \
else if (0 == strcmp(msg_type, "fail_486"))
7 L* S# M% A, A% H7 I
{
$ t) g3 `: ~8 H* d6 x
fail_486_fun(msg_buf);
4 _$ z# \/ q* v& D1 j
}
4 |# Z5 [ @2 `2 E$ P3 a
else
' z6 J" I d( t4 `
{
: N! X* Y4 ^( r5 [, L* Y4 z/ }
log("未识别的消息类型%s\n", msg_type);
* j" Z7 r" Z- J% t( }! T) I
}
: b2 q/ [ h% E! B P4 i
}
- {1 z' f" _" O3 W0 s
上面的消息类型取自sip协议(不完全相同,sip协议借鉴了http协议),消息类型可能还会增加。看着常常的流程可能有点累,检测一下中间某个消息有没有处理也比较费劲,而且,没增加一个消息,就要增加一个流程分支。
' i) q$ A3 R1 }: g1 ^' F5 J
9 L4 ^0 V) d1 g# v# s
按照数据驱动编程的思路,可能会这样设计:
/ E9 ` m+ i+ H( z7 J* m$ H
typedef void (*SIP_MSG_FUN)(const char *);
2 q# D$ \) y6 p7 W/ {2 ?" P
" S' C$ M/ L6 V) G: |* N
typedef struct __msg_fun_st
! h* w- S* g, ?7 u" J% o0 F
{
$ w, h. G- C. T* Y; M$ L! W/ U
const char *msg_type;//消息类型
1 I! S' n6 | V7 l8 I, Y
SIP_MSG_FUN fun_ptr;//函数指针
/ |" x# t0 K" k
}msg_fun_st;
' P B/ O5 e" T# C9 E0 l# Q# d9 P$ [
4 y9 T7 X) o3 n
msg_fun_st msg_flow[] =
/ c& p- y" F4 Z* v: m2 f3 K
{
9 ^$ _+ G. T: H. _( P0 I7 T
{"inivite", inivite_fun},
; y6 I( F- B2 w4 X6 e8 u" U2 B/ ?
{"tring_100", tring_fun},
4 l4 \: m8 d, K# b
{"ring_180", ring_180_fun},
) v% z6 l. u) o0 o% ?: y9 x
{"ring_181", ring_181_fun},
# Z0 z) \9 u4 f# t) O2 E
{"ring_182", ring_182_fun},
1 b! {9 B: |# O
{"ring_183", ring_183_fun},
% S: I9 F: Y( ~* C
{"ok_200", ok_200_fun},
, S1 e ]# e( `3 U' C
- {- H& I( m! ]. [% k* V' O! E$ Z
。。。。。。
# }; y- j3 Y# y% K4 A2 [3 n
{"fail_486", fail_486_fun}
9 E) F: v+ {3 m0 z/ i. J
};
. _% o; p# k' ]. A1 Q
$ s5 A3 E7 Q6 Z) _0 L
void msg_proc(const char *msg_type, const char *msg_buf)
) _8 O( T8 |8 [1 D/ U2 p( t
{
" @6 y% |1 h# d. x5 }0 N& D
int type_num = sizeof(msg_flow) / sizeof(msg_fun_st);
. i6 m: E4 V) s
int i = 0;
# y$ h+ O( @7 [/ z: k" g7 k4 N
& m4 T# a* P- q* n
for (i = 0; i < type_num; i++)
6 @0 C/ f3 E6 D
{
5 c5 U7 m7 ]2 Z9 @, A
if (0 == strcmp(msg_flow.msg_type, msg_type))
6 d2 O2 l* d) h* P- \
{
" ]' u' S, a% Z# S' B- G0 j
msg_flow.fun_ptr(msg_buf);
' j/ v4 f* G' ?( O# F
return ;
# T, D" M6 T( R$ N; O' U
}
6 X; N1 X% t+ g: f$ A2 f
}
6 Y6 M7 x% `( B' \* Z1 K1 q2 T% i
log("未识别的消息类型%s\n", msg_type);
4 j M& x4 e" L, [
}
- w3 v) u: m5 L. O' ]8 |
! @% H0 `: B5 t- m# d" d; E- L
下面这种思路的优势:
- \( H% i8 ^) b2 g: E" U
9 W9 A, x, J/ }0 c
1、可读性更强,消息处理流程一目了然。
1 ^, G/ i5 B i: p1 F; N3 w
1 T4 F: c0 E6 \9 V, F+ }3 ]" Z& T) ~( q
2、更容易修改,要增加新的消息,只要修改数据即可,不需要修改流程。
8 z6 j" H1 X2 D$ z% T
7 |/ E- g7 D; ]- g
3、重用,第一种方案的很多的else if其实只是消息类型和处理函数不同,但是逻辑是一样的。下面的这种方案就是将这种相同的逻辑提取出来,而把容易发生变化的部分提到外面。
" c+ [5 k9 y' h( V
* ]# D. }: H$ H5 {
隐含在背后的思想:
& j+ [0 ?! U2 u6 Z& N
9 R/ V% H2 ]* D" O" B- o" l
很多设计思路背后的原理其实都是相通的,隐含在数据驱动编程背后的实现思想包括:
, Z9 t; a- z7 v! j4 p9 X
+ @6 N" U+ ?" v4 b, z. U
1、控制复杂度。通过把程序逻辑的复杂度转移到人类更容易处理的数据中来,从而达到控制复杂度的目标。
& |6 o) K. O8 S1 q
# N% a6 k6 G: l4 }2 H( N$ o
2、隔离变化。像上面的例子,每个消息处理的逻辑是不变的,但是消息可能是变化的,那就把容易变化的消息和不容易变化的逻辑分离。
4 H+ ~0 ^7 o: `. s* p3 P
2 r: h; m, M* o# F+ t5 ^& i
3、机制和策略的分离。和第二点很像,本书中很多地方提到了机制和策略。上例中,我的理解,机制就是消息的处理逻辑,策略就是不同的消息处理(后面想专门写一篇文章介绍下机制和策略)。
9 Z0 a% \) T# K
% V6 |) M6 f' {! Z$ J5 f" q& z
数据驱动编程可以用来做什么:
2 i: l2 v% {9 T$ X9 V- ^& A' x1 B) X
, x& v, l5 @# _8 e9 H
如上例所示,它可以应用在函数级的设计中。
; D& g7 z1 O7 v0 o
3 h5 E" v( ^5 m
同时,它也可以应用在程序级的设计中,典型的比如用表驱动法实现一个状态机(后面写篇文章专门介绍)。
1 _ x) v' e6 w% l- E/ f7 A
. j3 [5 B. x) h. ]+ p1 G/ q
也可以用在系统级的设计中,比如DSL(这方面我经验有些欠缺,目前不是非常确定)。
, `2 r+ w. y+ c) [. Y$ J# ~$ G
2 |; Y5 a/ V8 f |" c3 K( C
它不是什么:
9 J: r; V1 ~5 {" D2 d" J- e! ]% W
0 _; ?% g- D& V. I4 R# h0 f
1、 它不是一个全新的编程模型:它只是一种设计思路,而且历史悠久,在unix/linux社区应用很多;
' Q8 M. j7 j7 h! U2 S3 z
* {) O. x. U! ?8 S: I
2、它不同于面向对象设计中的数据:“数据驱动编程中,数据不但表示了某个对象的状态,实际上还定义了程序的流程;OO看重的是封装,而数据驱动编程看重的是编写尽可能少的代码。”
, f G, R4 k$ Q9 h
7 |( @ Y1 B. M% r
书中的值得思考的话:
1 k E6 w& y0 R& u
! ` X1 D% A' _- U0 m' o& i* ~8 g( `
数据压倒一切。如果选择了正确的数据结构并把一切组织的井井有条,正确的算法就不言自明。编程的核心是数据结构,而不是算法。——Rob Pike
( U. a% g/ k4 p$ Y
1 Z% K |: t6 S" g* ]
程序员束手无策。。。。。只有跳脱代码,直起腰,仔细思考数据才是最好的行动。表达式编程的精髓。——Fred Brooks
e" C: U u: T; O
) b; D4 e. f% s8 I
数据比程序逻辑更易驾驭。尽可能把设计的复杂度从代码转移至数据是个好实践。——《unix编程艺术》作者。
作者:
ExxNEN
时间:
2020-1-14 20:01
数据驱动编程
欢迎光临 EDA365电子论坛网 (https://bbs.eda365.com/)
Powered by Discuz! X3.2