前言
在单页应用中，view与view之间的通信机制一直是一个重点，因为单页应用的所有操作以及状态管理全部发生在一个页面上
没有很好的组织的话很容易就乱了，就算表面上看起来没有问题，事实上会有各种隐忧，各种坑等着你去跳
最初就没有一定理论上的支撑，极有可能是这么一种情况：
① 需求下来了，搞一个demo做交待
② 发现基本满足很满意，于是直接在demo中做调整
上面的做法本身没有什么问题，问题发生在后期
③ 在demo调整后应用到了实际业务中，发现很多地方有问题，于是见一个坑解决一个坑
④ 到最后感觉整个框架零零散散，有很多if代码，有很多代码不太懂意思，但是一旦移除就报错
这个时候我们就想到了重构，重构过程中就会发现最初的设计，或者说整个框架的基础有问题，于是就提出推翻重来
若是时间上允许，还可以，但是往往重构过程中，会多一些不按套路出牌的同学，将API接口给换了，这一换所有的业务系统全部崩溃
所以说，新的框架会对业务线造成压力，会提高测试与编码成本，于是就回到了我们上篇博客的问题
【UI插件】简单的日历插件（下）—— 学习MVC思想
一些同学认为，以这种方式写UI组件过于麻烦，但是我们实际的场景是这样的
我们所有的UI 组件可能会由一个UIAbstractView继承而来，这样的继承的好处是：
① 我们每个UI组件都会遵循一个事件的流程做编写，比如：
onCreate->preShow->show->afterShow->onHide->destroy （简单说明即可）
于是我们想在每一个组件显示前做一点操作的话，我们可以统一写到AbstractView中去（事实上我们应该写到businessView中）
② 在AbstractView中我们可以维护一个共用的闭包环境，这个闭包环境被各个UI组件共享，于是UI与UI之间的通信就变成了实例的操作而不是dom操作
当然，事实上通过DOM的操作，选择器，id的什么方式可能一样可以实现相同的功能，但是正如上面所言，这种方式会有隐忧
事实上是对UI组件编写的一种约束，没有约束的组件做起来当然简单
但是有了约束的组件的状态处理才能被统一化，因为
单页应用的内存清理、状态管理才是真正的难点
PS：此文仅代表个人浅薄想法，有问题请指出
消息通信机制
其实所谓消息通信，不过是一种发布订阅的关系，又名观察者；观察者有着一对多的关系
多个对象观察同一个主体对象，若是主体对象发生变化便会通知所有观察者变化，事实上观察者本身又可以变成主体对象，所以多对多的关系偶尔不可避免
还有一些时候观察者也可能变成自己，自己的某些状态会被观察
其实前面扯那么多有的没的不如来一个代码，在Backbone中有一段代码简单实现了这个逻辑
var Events = Backbone.Events = {
on: function (name, callback, context) {
if (!eventsApi(this, 'on', name, [callback, context]) || !callback) return this;
this._events || (this._events = {});
var events = this._events[name] || (this._events[name] = []);
events.push({ callback: callback, context: context, ctx: context || this });
return this;
},
off: function (name, callback, context) {
var retain, ev, events, names, i, l, j, k;
if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return this;
if (!name && !callback && !context) {
this._events = {};
return this;
}
names = name ? [name] : _.keys(this._events);
for (i = 0, l = names.length; i < l; i++) {
name = names[i];
if (events = this._events[name]) {
this._events[name] = retain = [];
if (callback || context) {
for (j = 0, k = events.length; j < k; j++) {
ev = events[j];
if ((callback && callback !== ev.callback && callback !== ev.callback._callback) ||
(context && context !== ev.context)) {
retain.push(ev);
}
}
}
if (!retain.length) delete this._events[name];
}
}
return this;
},
trigger: function (name) {
if (!this._events) return this;
var args = slice.call(arguments, 1);
if (!eventsApi(this, 'trigger', name, args)) return this;
var events = this._events[name];
var allEvents = this._events.all;
if (events) triggerEvents(events, args);
if (allEvents) triggerEvents(allEvents, arguments);
return this;
},
};
这是一段简单的逻辑，也许他的主干还不全，我们这里若是做一个简单的实现的话就会变成这个样子：
var Events = {};
Events.__events__ = {};
Events.addEvent = function (type, handler) {
if (!type || !handler) {
throw "addEvent Parameter is not complete!";
}
var handlers = Events.__events__[type] || [];
handlers.push(handler);
Events.__events__[type] = handlers;
};
Events.removeEvent = function (type, handler) {
if (!type) {
throw "removeEvent parameters must be at least specify the type!";
}
var handlers = Events.__events__[type], index;
if (!handlers) return;
if (handler) {
for (var i = Math.max(handlers.length - 1, 0); i >= 0; i--) {
if (handlers[i] === handler) handlers.splice(i, 1);
}
} else {
delete handlers[type];
}
};
Events.trigger = function (type, args, scope) {
var handlers = Events.__events__[type];
if (handlers) for (var i = 0, len = handlers.length; i < len; i++) {
typeof handlers[i] === 'function' && handlers[i].apply(scope || this, args);
}
};
整个程序逻辑如下：
① 创建一个events对象作为消息存放点
② 使用on放events中存放一个个事件句柄
③ 在满足一定条件的情况下，触发相关的事件集合
IScroll中的消息机制
简单而言，以IScroll为例，他在构造函数中定义了默认的属性：
this._events = {};
然后提供了最简单的注册、触发接口
on: function (type, fn) {
if (!this._events[type]) {
this._events[type] = [];
}
this._events[type].push(fn);
},
_execEvent: function (type) {
if (!this._events[type]) {
return;
}
var i = 0,
l = this._events[type].length;
if (!l) {
return;
}
for (; i < l; i++) {
this._events[type][i].call(this);
}
},
因为IScroll中涉及到了自身与滚动条之间的通信，所以是个很好的例子，我们看看IScroll的使用：
他对自身展开了监听，若是发生以下事件便会触发响应方法
_initIndicator: function () {
//滚动条
var el = createDefaultScrollbar();
this.wrapper.appendChild(el);
this.indicator = new Indicator(this, { el: el });
this.on('scrollEnd', function () {
this.indicator.fade();
});
var scope = this;
this.on('scrollCancel', function () {
scope.indicator.fade();
});
this.on('scrollStart', function () {
scope.indicator.fade(1);
});
this.on('beforeScrollStart', function () {
scope.indicator.fade(1, true);
});
this.on('refresh', function () {
scope.indicator.refresh();
});
},
比如在每次拖动结束的时候，皆会抛一个事件出来
that._execEvent('scrollEnd');
他只负责抛出事件，然后具体执行的逻辑其实早就写好了，他不必关注起做了什么，因为那个不是他需要关注的
再说回头，IScroll的事件还可以被用户注册，于是用户便可以在各个事件点封装自己想要的逻辑
比如IScroll每次移动的结果都会是一个步长，便可以在scrollEnd触发自己的逻辑，但是由于iScroll最后的移动值为一个局部变量，所以这里可能需要将其中的newY定制于this上
实现消息中心
如IScroll的消息机制只会用于自身，如Backbone的Model、View层各自维护着自己的消息中心，在一个单页框架中，此消息枢纽事实上可以只有一个
比如页面标签的View可以是一个消息群组
UI组件可以是一个消息群组
Model层也可以是一个消息群组
......
所以这个统一的消息中心，事实上我们一个框架可以提供一个单例，让各个系统去使用
Dalmatian = {};
Dalmatian.MessageCenter = _.inherit({
initialize: function () {
//框架所有的消息皆存于此
/*
{
view: {key1: [], key2: []},
ui: {key1: [], key2: []},
model: {key1: [], key2: []}
other: {......}
}
*/
this.msgGroup = {};
},
_verify: function (options) {
if (!_.property('namespace')(options)) throw Error('必须知道该消息的命名空间');
if (!_.property('id')(options)) throw Error('该消息必须具备key值');
if (!_.property('handler')(options) && _.isFunction(options.handler)) throw Error('该消息必须具备事件句柄');
},
//注册时需要提供namespace、key、事件句柄
//这里可以考虑提供一个message类
register: function (namespace, id, handler) {
var message = {};
if (_.isObject(namespace)) {
message = namespace;
} else {
message.namespace = namespace;
message.id = id;
message.handler = handler;
}
this._verify(message);
if (!this.msgGroup[message.namespace]) this.msgGroup[message.namespace] = {};
if (!this.msgGroup[message.namespace][message.id]) this.msgGroup[message.namespace][message.id] = [];
this.msgGroup[message.namespace][message.id].push(message.handler);
},
//取消时候有所不同
//0 清理所有
//1 清理整个命名空间的事件
//2 清理一个命名空间中的一个
//3 清理到具体实例上
unregister: function (namespace, id, handler) {
var removeArr = [
'clearMessageGroup',
'clearNamespace',
'clearObservers',
'removeObserver'
];
var removeFn = removeArr[arguments.length];
if (_.isFunction(removeFn)) removeFn.call(this, arguments);
},
clearMessageGroup: function () {
this.msgGroup = {};
},
clearNamespace: function (namespace) {
if (this.msgGroup[namespace]) this.msgGroup[namespace] = {};
},
clearObservers: function (namespace, id) {
if (!this.msgGroup[namespace]) return;
if (!this.msgGroup[namespace][id]) return;
this.msgGroup[namespace][id] = [];
},
//没有具体事件句柄便不能被移除
removeObserver: function (namespace, id, handler) {
var i, len, _arr;
if (!this.msgGroup[namespace]) return;
if (!this.msgGroup[namespace][id]) return;
_arr = this.msgGroup[namespace][id];
for (i = 0, len = _arr.length; i < len; i++) {
if (_arr[i] === handler) _arr[id].splice(i, 1);
}
},
//触发各个事件，事件句柄所处作用域需传入时自己处理
dispatch: function (namespace, id, data, scope) {
var i, len, _arr;
if (!(namespace && id)) return;
if (!this.msgGroup[namespace]) return;
if (!this.msgGroup[namespace][id]) return;
_arr = this.msgGroup[namespace][id];
for (i = 0, len = _arr.length; i < len; i++) {
if (_.isFunction(_arr[i])) _arr[i].call(scope || this, data);
}
}
});
Dalmatian.MessageCenter.getInstance = function () {
if (!this.instance) {
this.instance = new Dalmatian.MessageCenter();
}
return this.instance;
};
Dalmatian.MSG = Dalmatian.MESSAGECENTER = Dalmatian.MessageCenter.getInstance();
完了这块我们怎么使用了，这里回到我们的alert与日历框，让我们实现他们之间的通信
alert与calendar之间的通信
我们实现这样的效果，点击alert框时，显示一个时间，并且日历上将此日期标红
PS：每次一到这个时间久累了，代码未做整理
① 我们在calendar实例化的时候便做事件注册（订阅）
//事件注册点，应该单独封装
Dalmatian.MSG.register('ui', 'alertShow', $.proxy(function (data) { var s = ''; }, this));
② 在每次设置message内容时候便抛出事件
set: function (options) {
_.extend(this.adapter.datamodel, options);
// this.adapter.datamodel.content = options.content;
this.adapter.notifyDataChanged();
if (options.content) {
Dalmatian.MSG.dispatch('ui', 'alertShow', options.content);
}
},
于是便有了这样的效果，每次设置值的时候，我这里都会被触发
而且这里的this指向的是calendar，所以我们这里可以做处理，由于时间原因，我这里便乱干了
可以看到，每次操作后，calendar得到了更新，但是由于我这里是直接操作的dom未做datamodel操作，所以没有做状态保存，第二次实际上是该刷新的
这里我们暂时不管
<!doctype html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>ToDoList</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="stylesheet" type="text/css" href="http://designmodo.github.io/Flat-UI/bootstrap/css/bootstrap.css">
<link rel="stylesheet" type="text/css" href="http://designmodo.github.io/Flat-UI/css/flat-ui.css">
<link href="../style/main.css" rel="stylesheet" type="text/css" />
<style type="text/css">
.cui-alert { width: auto; position: static; }
.txt { border: #cfcfcf 1px solid; margin: 10px 0; width: 80%; }
ul, li { padding: 0; margin: 0; }
.cui_calendar, .cui_week { list-style: none; }
.cui_calendar li, .cui_week li { float: left; width: 14%; overflow: hidden; padding: 4px 0; text-align: center; }
</style>
</head>
<body>
<article class="containerCalendar">
</article>
<div style="border: 1px solid black; margin: 10px; padding: 10px; clear: both;">
华丽的分割</div>
<article class="containerAlert">
</article>
<input type="text" id="addmsg" class="txt">
<button id="addbtn" class="btn">
show message</button>
<script type="text/underscore-template" id="template-alert">
<div class=" cui-alert" >
<div class="cui-pop-box">
<div class="cui-bd">
<p class="cui-error-tips"><%=content%></p>
<div class="cui-roller-btns">
<div class="cui-flexbd cui-btns-cancel"><%=cancel%></div>
<div class="cui-flexbd cui-btns-sure"><%=confirm%></div>
</div>
</div>
</div>
</div>
</script>
<script type="text/template" id="template-calendar">
<ul class="cui_week">
<% var i = 0, day = 0; %>
<%for(day = 0; day < 7; day++) { %>
<li>
<%=weekDayItemTmpt[day] %></li>
<%} %>
</ul> <ul class="cui_calendar">
<% for(i = 0; i < beginWeek; i++) { %>
<li class="cui_invalid"></li>
<% } %>
<% for(i = 0; i < days; i++) { %>
<% day = i + 1; %>
<% if (compaign && compaign.days && compaign.sign && _.contains(compaign.days, day)) { day = compaign.sign } %>
<li class="cui_calendar_item" data-date="<%=year%>-<%=month + 1%>-<%=day%>"><%=day %></li>
<% } %>
</ul>
</script>
<script type="text/javascript" src="../../vendor/underscore-min.js"></script>
<script type="text/javascript" src="../../vendor/zepto.min.js"></script>
<script src="../../src/underscore.extend.js" type="text/javascript"></script>
<script src="../../src/util.js" type="text/javascript"></script>
<script src="../../src/message-center-wl.js" type="text/javascript"></script>
<script src="../../src/mvc.js" type="text/javascript"></script>
<script type="text/javascript"> (function () {
var htmltemplate = $('#template-alert').html(); var AlertView = _.inherit(Dalmatian.View, {
templateSet: {
0: htmltemplate
}, statusSet: {
STATUS_INIT: 0
}
}); var Adapter = _.inherit(Dalmatian.Adapter, {
parse: function (data) {
return data;
}
}); var Controller = _.inherit(Dalmatian.ViewController, {
//设置默认信息
_initialize: function () {
this.origindata = {
content: '',
confirm: '确定',
cancel: '取消'
}
}, initialize: function ($super, opts) {
this._initialize();
$super(opts);
this._init();
}, //基础数据处理
_init: function () {
this.adapter.format(this.origindata);
this.adapter.registerObserver(this);
this.viewstatus = this.view.statusSet.STATUS_INIT;
}, render: function () {
var data = this.adapter.viewmodel;
this.view.render(this.viewstatus, data);
}, set: function (options) {
_.extend(this.adapter.datamodel, options);
// this.adapter.datamodel.content = options.content;
this.adapter.notifyDataChanged(); //*****************************
//淳敏看这样是否合理
//*****************************
if (options.content) {
Dalmatian.MSG.dispatch('ui', 'alertShow', options.content);
} }, events: {
"click .cui-btns-cancel": "cancelaction"
}, cancelaction: function () {
this.onCancelBtnClick();
}
}); var view = new AlertView()
var adapter = new Adapter(); var controller = new Controller({
view: view,
adapter: adapter,
container: '.containerAlert',
onCancelBtnClick: function () {
alert('cancel 2')
}
}); $('#addbtn').on('click', function (e) {
var content = $('#addmsg').val();
// adapter.datamodel.content = content;
// adapter.notifyDataChanged();
controller.set({ content: content, confirm: '确定1' });
controller.show();
}); })(); (function () { var tmpt = $('#template-calendar').html(); var CalendarView = _.inherit(Dalmatian.View, {
templateSet: {
0: tmpt
}, statusSet: {
STATUS_INIT: 0
}
}); var CalendarAdapter = _.inherit(Dalmatian.Adapter, {
_initialize: function ($super) {
$super(); //默认显示方案，可以根据参数修改
//任意一个model发生改变皆会引起update
this.weekDayItemTmpt = ['日', '一', '二', '三', '四', '五', '六'];
}, //该次重新，viewmodel的数据完全来源与parse中多定义
parse: function (data) {
return _.extend({
weekDayItemTmpt: this.weekDayItemTmpt
}, data);
}
}); var CalendarController = _.inherit(Dalmatian.ViewController, { _initialize: function () {
this.view = new CalendarView();
this.adapter = new CalendarAdapter(); //默认业务数据
this.dateObj = new Date();
this.container = '.containerCalendar'; var s = '';
}, initialize: function ($super, opts) {
this._initialize();
$super(opts); //事件注册点，应该单独封装
Dalmatian.MSG.register('ui', 'alertShow', $.proxy(function (data) {
var date = new Date(data);
this.handleDay(date, function (el) {
//*****************
//此处该做datamodel操作，暂时不予处理
//*****************
el.css('color', 'red');
}); var s = ''; }, this)); }, onViewBeforeCreate: function () { //使用adpter之前必须注册监听以及格式化viewModel，此操作应该封装起来
this.adapter.registerObserver(this);
this.adapter.format(this._getMonthData(this.dateObj.getFullYear(), this.dateObj.getMonth())); //view显示之前必定会给予状态，此应该封装
this.viewstatus = this.view.statusSet.STATUS_INIT; var s = '';
}, render: function () { //该操作可封装
var data = this.adapter.viewmodel; console.log(data) this.view.render(this.viewstatus, data);
}, //根据传入年月，返回该月相关数据
_getMonthData: function (year, month) {
this.date = new Date(year, month);
var d = new Date(year, month);
//description 获取天数
var days = dateUtil.getDaysOfMonth(d);
//description 获取那个月第一天时星期几
var _beginWeek = dateUtil.getBeginDayOfMouth(d);
return {
year: d.getFullYear(),
month: d.getMonth(),
beginWeek: _beginWeek,
days: days,
compaign: null
};
}, handleDay: function (dateStr, fn) {
if (dateUtil.isDate(dateStr)) dateStr = dateUtil.format(dateStr, 'Y-m-d');
var el = this.viewcontent.find('[data-date="' + dateStr + '"]'); if (typeof fn == 'function') fn(el, dateUtil.parse(dateStr, 'y-m-d'), this); } }); var calendar = new CalendarController();
calendar.show(); calendar.handleDay(new Date(), function (el, date, calendar) {
el.html('今天');
}); })(); </script>
</body>
</html>
结语
今天暂时到此，我们下次继续，本人技术有限，若是文中有任何不足以及问题，请提出
这里命名空间以及id皆有可能像滚雪球似的越滚越多，所以这里需要框架本身做出约定，具体看后期实践吧......
