使用Mock.js进行独立于后端的前端开发

解决的问题

开发时,后端还没完成数据输出,前端只好写静态模拟数据。

  • 数据太长了,将数据写在js文件里,完成后挨个改url。

  • 某些逻辑复杂的代码,加入或去除模拟数据时得小心翼翼。

  • 想要尽可能还原真实的数据,要么编写更多代码,要么手动修改模拟数据。

  • 特殊的格式,例如IP,随机数,图片,地址,需要去收集。

  • 超烂的破网速…

以上都不再是问题

接下来体验 拦截ajax请求并返回模拟数据。

概述

Mock.js实现的功能

  1. 基于 数据模板 生成数据

  2. 基于 HTML模板 生成数据

  3. 拦截并模拟 Ajax请求

用法

浏览器:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<!-- (必选)加载 Mock -->

<script src="http://mockjs.com/dist/mock.js"></script>

<script>

// 使用 Mock

var data = Mock.mock({

    'list|1-10': [{

        'id|+1': 1

    }]

});

$('<pre>').text(JSON.stringify(data, null, 4))

.appendTo('body')

</script>

_

_

返回值:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
{

"list": [

    {

        "id": 1

    },

    {

        "id": 2

    },

    {

        "id": 3

    }

    ]

}

JQuery:

配置模拟数据:

1
2
3
4
5
6
7
8
9
Mock.mock('http://g.cn', {

    'name'     : '@name',

    'age|1-100': 100,

    'color'    : '@color'

});

发送Ajax请求:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
$.ajax({

    url: 'http://g.cn',

    dataType:'json'

    }).done(function(data, status, xhr){

    console.log(

    JSON.stringify(data, null, 4)

    )

});

** **

返回数据:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 结果1

{

"name": "Elizabeth Hall",

"age": 91,

"color": "#0e64ea"

}

// 结果2

{

"name": "Michael Taylor",

"age": 61,

"color": "#081086"

}

_ _


Node.js:

// 安装

npm install mockjs
// 使用

1
2
3
4
5
6
7
8
9
10
11
12
13
var Mock = require('mockjs');

var data = Mock.mock({

    'list|1-10': [{

        'id|+1': 1

    }]

});

console.log(JSON.stringify(data, null, 4))

_ _


Angular.js:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
<!-- 引用 -->

<script src="http://mockjs.com/dist/mock-min.js"></script>

<script
src="http://cdn.staticfile.org/angular.js/1.3.0-beta.13/angular.min.js"></script>

<!-- 兼容angular (mock.js默认不兼容angular,需额外引用兼容包)-->

<script src="./src/mock.angular.js"></script>

<!-- 模拟数据 -->

<script src="./mockData.js"></script>

<!-- 使用 -->

<script>

(function() {

    (function() {

        var app;

        app = angular.module('app', []);

        //使用mockjax方法覆盖Ajax请求

        Mock.mockjax(app);

        return app.controller('appCtrl', function($scope, $http) {

            var box;

            box = $scope.box = [];

            $scope.get = function() {

                $http({

                    url: 'http://www.baidu.com',

                    method: 'POST',

                    params: {a: 1},

                    data  : {b:1}

                }).success(function(data) {

                return box.push(data);

            });

            $http({

                url: 'http://baidu.com'

                }).success(function(data) {

                console.log(data);

                });

            };

        return $scope.get();

        });

    })();

}).call(this);

</script>

_ _

mock数据mockData.js:

1
2
3
4
5
6
7
8
9
Mock.mock('http://www.baidu.com', {

    'name': '@name()',

    'age|1-100': 100,

    'color': '@color'

});

** **


语法

Mock.js 的语法规范包括两部分:

  1. 数据模板定义(Data Temaplte Definition,DTD)

  2. 数据占位符定义(Data Placeholder Definition,DPD)

数据模板定义 DTD

数据模板中的每个属性由 3 部分构成:属性名、生成规则、属性值:

// 属性名 name

// 生成规则 rule

// 属性值 value

‘name|rule’: value

注意:

  • 属性名 和 生成规则 之间用 | 分隔。

  • 生成规则 是可选的。

  • 生成规则 有 7 种格式:

    1. ‘name|min-max’: value

    2. ‘name|count’: value

    3. ‘name|min-max.dmin-dmax’: value

    4. ‘name|min-max.dcount’: value

    5. ‘name|count.dmin-dmax’: value

    6. ‘name|count.dcount’: value

    7. ‘name|+step’: value

  • 生成规则 的 含义 需要依赖 属性值 才能确定。

  • 属性值 中可以含有 @占位符。

  • 属性值 还指定了最终值的初始值和类型。

生成规则和示例:

1. 属性值是字符串 String
  1. ‘name|min-max’: ‘value’ 通过重复 ‘value’ 生成一个字符串,重复次数大于等于 min,小于等于 max。

  2. ‘name|count’: ‘value’ 通过重复 ‘value’ 生成一个字符串,重复次数等于 count。

2. 属性值是数字 Number
  1. ‘name|+1’: 100 属性值自动加 1,初始值为 100

  2. ‘name|1-100’: 100 生成一个大于等于 1、小于等于 100 的整数,属性值 100 只用来确定类型。

  3. ‘name|1-100.1-10’: 100 生成一个浮点数,整数部分大于等于 1、小于等于 100,小数部分保留 1 到 10 位。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
{

'number1|1-100.1-10': 1,

'number2|123.1-10': 1,

'number3|123.3': 1,

'number4|123.10': 1.123

}

// =>

{

"number1": 12.92,

"number2": 123.51,

"number3": 123.777,

"number4": 123.1231091814

}
3. 属性值是布尔型 Boolean
  1. ‘name|1’: value 随机生成一个布尔值,值为 true 的概率是 1/2,值为 false 的概率是 1/2。

  2. ‘name|min-max’: value 随机生成一个布尔值,值为 value 的概率是 min / (min + max),值为 !value 的概率是 max / (min + max)。

4. 属性值是对象 Object
  1. ‘name|min-max’: {} 从属性值 {} 中随机选取 min 到 max 个属性。

  2. ‘name|count’: {} 从属性值 {} 中随机选取 count 个属性。

5. 属性值是数组 Array
  1. ‘name|1’: [{}, {} …] 从属性值 [{}, {} …] 中随机选取 1 个元素,作为最终值。

  2. ‘name|min-max’: [{}, {} …] 通过重复属性值 [{}, {} …] 生成一个新数组,重复次数大于等于 min,小于等于 max。

  3. ‘name|count’: [{}, {} …] 通过重复属性值 [{}, {} …] 生成一个新数组,重复次数为 count。

6. 属性值是数组 Function

‘name’: function(){} 执行函数 function(){},取其返回值作为最终的属性值,上下文为 ‘name’ 所在的对象。

数据占位符定义 DPD

占位符 只是在属性值字符串中占个位置,并不出现在最终的属性值中。占位符 的格式为:

@占位符

@占位符(参数 [, 参数])

注意:

  1. 用 @ 来标识其后的字符串是 占位符。

  2. 占位符 引用的是 Mock.Random 中的方法。

  3. 通过 Mock.Random.extend() 来扩展自定义占位符。

  4. 占位符 也可以引用 数据模板 中的属性。

  5. 占位符 会优先引用 数据模板 中的属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
{

name: {

first: '@FIRST',

middle: '@FIRST',

last: '@LAST',

full: '@first @middle @last'

}

}

// =>

{

"name": {

"first": "Charles",

"middle": "Brenda",

"last": "Lopez",

"full": "Charles Brenda Lopez"

}

}

常用方法

Mock.mock( rurl?, rtype?, template|function(options) )

根据数据模板生成模拟数据。

参数的含义和默认值如下所示:
  • 参数 rurl:可选。表示需要拦截的 URL,可以是 URL 字符串或 URL 正则。例如 //domain/list.json/、’/domian/list.json’。

  • 参数 rtype:可选。表示需要拦截的 Ajax 请求类型。例如 GET、POST、PUT、DELETE 等。

  • 参数 template:可选。表示数据模板,可以是对象或字符串。例如 { ‘data|1-10’:[{}] }、‘@EMAIL’。

  • 参数 function(options):可选。表示用于生成响应数据的函数。

  • 参数 options:指向本次请求的 Ajax 选项集。

Mock.mockjax(library)

覆盖(拦截) Ajax 请求,目前内置支持 jQuery、Zepto、KISSY。

Mock.Random

Mock.Random 是一个工具类,用于生成各种随机数据。Mock.Random 的方法在数据模板中称为“占位符”,引用格式为 @占位符(参数 [, 参数]) 。

Mock.tpl(input, options, helpers, partials)

基于 Handlebars、Mustache 的 HTML 模板生成模拟数据。

方法使用详情请参考mock.js文档


参考

演示: mock-demo

演示: mock-angular-demo

参考: mock.js

源码: mock-angular

DB主从一致性架构优化4种方法

需求缘起

大部分互联网的业务都是“读多写少”的场景,数据库层面,读性能往往成为瓶颈。如下图:业界通常采用“一主多从,读写分离,冗余多个读库”的数据库架构来提升数据库的读性能。

这种架构的一个潜在缺点是,业务方有可能读取到并不是最新的旧数据:

(1)系统先对DB-master进行了一个写操作,写主库

(2)很短的时间内并发进行了一个读操作,读从库,此时主从同步没有完成,故读取到了一个旧数据

(3)主从同步完成

有没有办法解决或者缓解这类“由于主从延时导致读取到旧数据”的问题呢,这是本文要集中讨论的问题。

方案一(半同步复制)

不一致是因为写完成后,主从同步有一个时间差,假设是500ms,这个时间差有读请求落到从库上产生的。有没有办法做到,等主从同步完成之后,主库上的写请求再返回呢?答案是肯定的,就是大家常说的“半同步复制
”semi-sync:

(1)系统先对DB-master进行了一个写操作,写主库

(2)等主从同步完成,写主库的请求才返回

(3)读从库,读到最新的数据(如果读请求先完成,写请求后完成,读取到的是“当时”最新的数据)

方案优点:利用数据库原生功能,比较简单

方案缺点:主库的写请求时延会增长,吞吐量会降低

方案二(强制读主库)

如果不使用“增加从库”的方式来增加提升系统的读性能,完全可以读写都落到主库,这样就不会出现不一致了:

方案优点:“一致性”上不需要进行系统改造

方案缺点:只能通过cache来提升系统的读性能,这里要进行系统改造

方案三(数据库中间件)

如果有了数据库中间件,所有的数据库请求都走中间件,这个主从不一致的问题可以这么解决:

(1)所有的读写都走数据库中间件,通常情况下,写请求路由到主库,读请求路由到从库

(2)记录所有路由到写库的key,在经验主从同步时间窗口内(假设是500ms),如果有读请求访问中间件,此时有可能从库还是旧数据,就把这个key上的读请求路由到主库

(3)经验主从同步时间过完后,对应key的读请求继续路由到从库

方案优点:能保证绝对一致

方案缺点:数据库中间件的成本比较高

方案四(缓存记录写key法)

既然数据库中间件的成本比较高,有没有更低成本的方案来记录某一个库的某一个key上发生了写请求呢?很容易想到使用缓存,当写请求发生的时候:

(1)将某个库上的某个key要发生写操作,记录在cache里,并设置“经验主从同步时间”的cache超时时间,例如500ms

(2)修改数据库

而读请求发生的时候:

(1)先到cache里查看,对应库的对应key有没有相关数据

(2)如果cache hit,有相关数据,说明这个key上刚发生过写操作,此时需要将请求路由到主库读最新的数据

(3)如果cache miss,说明这个key上近期没有发生过写操作,此时将请求路由到从库,继续读写分离

方案优点:相对数据库中间件,成本较低

方案缺点:为了保证“一致性”,引入了一个cache组件,并且读写数据库时都多了一步cache操作

总结

为了解决主从数据库读取旧数据的问题,常用的方案有四种:

(1)半同步复制

(2)强制读主

(3)数据库中间件

(4)缓存记录写key

前3个方案在今年数据库大会(DTCC2016)上share过,相关的材料在网上能下载到。第4个方案是大会现场有其他同学share的一个好方法,感谢这位同学。

MySQL 常用30种SQL查询语句优化方法

1、应尽量避免在 where 子句中使用!=或<>操作符,否则将引擎放弃使用索引而进行全表扫描。

2、对查询进行优化,应尽量避免全表扫描,首先应考虑在 where 及 order by 涉及的列上建立索引。

3、应尽量避免在 where 子句中对字段进行 null 值判断,否则将导致引擎放弃使用索引而进行全表扫描。如:

select id from t where num is null

可以在num上设置默认值0,确保表中num列没有null值,然后这样查询:

select id from t where num=0

4、尽量避免在 where 子句中使用 or 来连接条件,否则将导致引擎放弃使用索引而进行全表扫描,如:

select id from t where num=10 or num=20

可以这样查询:

select id from t where num=10

union all

select id from t where num=20

5、下面的查询也将导致全表扫描:(不能前置百分号)

select id from t where name like ‘%c%’

下面走索引

select id from t where name like ‘c%’

若要提高效率,可以考虑全文检索。

6、in 和 not in 也要慎用,否则会导致全表扫描,如:

select id from t where num in(1,2,3)

对于连续的数值,能用 between 就不要用 in 了:

select id from t where num between 1 and 3

7、如果在 where
子句中使用参数,也会导致全表扫描。因为SQL只有在运行时才会解析局部变量,但优化程序不能将访问计划的选择推迟到运行时;它必须在编译时进行选择。然
而,如果在编译时建立访问计划,变量的值还是未知的,因而无法作为索引选择的输入项。如下面语句将进行全表扫描:

select id from t where num=@num

可以改为强制查询使用索引:

select id from t with(index(索引名)) where num=@num

8、应尽量避免在 where 子句中对字段进行表达式操作,这将导致引擎放弃使用索引而进行全表扫描。如:

select id from t where num/2=100

应改为:

select id from t where num=100*2

9、应尽量避免在where子句中对字段进行函数操作,这将导致引擎放弃使用索引而进行全表扫描。如:

select id from t where substring(name,1,3)=’abc’ –name以abc开头的id

select id from t where datediff(day,createdate,’2005-11-30′)=0
–’2005-11-30′生成的id

应改为:

select id from t where name like ‘abc%’

select id from t where createdate>=’2005-11-30′ and createdate<’2005-12-1′

10、不要在 where 子句中的“=”左边进行函数、算术运算或其他表达式运算,否则系统将可能无法正确使用索引。

11、在使用索引字段作为条件时,如果该索引是复合索引,那么必须使用到该索引中的第一个字段作为条件时才能保证系统使用该索引,否则该索引将不会被使
用,并且应尽可能的让字段顺序与索引顺序相一致。

12、不要写一些没有意义的查询,如需要生成一个空表结构:

select col1,col2 into #t from t where 1=0

这类代码不会返回任何结果集,但是会消耗系统资源的,应改成这样:

create table #t(…)

13、很多时候用 exists 代替 in 是一个好的选择:

select num from a where num in(select num from b)

用下面的语句替换:

select num from a where exists(select 1 from b where num=a.num)

14、并不是所有索引对查询都有效,SQL是根据表中数据来进行查询优化的,当索引列有大量数据重复时,SQL查询可能不会去利用索引,如一表中有字段
sex,male、female几乎各一半,那么即使在sex上建了索引也对查询效率起不了作用。

15、索引并不是越多越好,索引固然可以提高相应的 select 的效率,但同时也降低了 insert 及 update 的效率,因为 insert 或
update
时有可能会重建索引,所以怎样建索引需要慎重考虑,视具体情况而定。一个表的索引数较好不要超过6个,若太多则应考虑一些不常使用到的列上建的索引是否有 必要。

16.应尽可能的避免更新 clustered 索引数据列,因为 clustered
索引数据列的顺序就是表记录的物理存储顺序,一旦该列值改变将导致整个表记录的顺序的调整,会耗费相当大的资源。若应用系统需要频繁更新 clustered
索引数据列,那么需要考虑是否应将该索引建为 clustered 索引。

17、尽量使用数字型字段,若只含数值信息的字段尽量不要设计为字符型,这会降低查询和连接的性能,并会增加存储开销。这是因为引擎在处理查询和连接时会
逐个比较字符串中每一个字符,而对于数字型而言只需要比较一次就够了。

18、尽可能的使用 varchar/nvarchar 代替 char/nchar
,因为首先变长字段存储空间小,可以节省存储空间,其次对于查询来说,在一个相对较小的字段内搜索效率显然要高些。

19、任何地方都不要使用 select * from t ,用具体的字段列表代替“*”,不要返回用不到的任何字段。

20、尽量使用表变量来代替临时表。如果表变量包含大量数据,请注意索引非常有限(只有主键索引)。

21、避免频繁创建和删除临时表,以减少系统表资源的消耗。

22、临时表并不是不可使用,适当地使用它们可以使某些例程更有效,例如,当需要重复引用大型表或常用表中的某个数据集时。但是,对于一次性事件,较好使 用导出表。

23、在新建临时表时,如果一次性插入数据量很大,那么可以使用 select into 代替 create table,避免造成大量 log
,以提高速度;如果数据量不大,为了缓和系统表的资源,应先create table,然后insert。

24、如果使用到了临时表,在存储过程的最后务必将所有的临时表显式删除,先 truncate table ,然后 drop table
,这样可以避免系统表的较长时间锁定。

25、尽量避免使用游标,因为游标的效率较差,如果游标操作的数据超过1万行,那么就应该考虑改写。

26、使用基于游标的方法或临时表方法之前,应先寻找基于集的解决方案来解决问题,基于集的方法通常更有效。

27、与临时表一样,游标并不是不可使用。对小型数据集使用 FAST_FORWARD
游标通常要优于其他逐行处理方法,尤其是在必须引用几个表才能获得所需的数据时。在结果集中包括“合计”的例程通常要比使用游标执行的速度快。如果开发时
间允许,基于游标的方法和基于集的方法都可以尝试一下,看哪一种方法的效果更好。

28、在所有的存储过程和触发器的开始处设置 SET NOCOUNT ON ,在结束时设置 SET NOCOUNT OFF
。无需在执行存储过程和触发器的每个语句后向客户端发送 DONEINPROC 消息。

29、尽量避免向客户端返回大数据量,若数据量过大,应该考虑相应需求是否合理。

30、尽量避免大事务操作,提高系统并发能力。

Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×