SingalPageApp：使用Knockout和RequireJS創建高度模塊化的單頁應用引擎

2019-11-14 19:57:14

字體：大中小

來源：轉載

供稿：網友

開篇扯淡

距離上一篇文章已經有好幾個月，也不是沒有時間記錄點東西，主要是換了新的工作，在一家外資工作，目前的工作內容大多都是前端開發，新接觸的東西因為時間原因，大多還不成體系，所以這么長時間什么都沒記錄下來，也正是因為新的工作內容，才有了今天這篇文章。

這篇文章是我自己的博客項目的前端重寫，因為目前 asp.net API和單頁應用的流行，結合目前工作中用到的東西，我決定把我的博客項目的前端部分整個重寫，（以前的就是一坨…）

步入正題

背景知識

RequireJS http://www.requirejs.org/

Knockout http://knockoutjs.com/

BootStrap http://getbootstrap.com/

PubSubJS https://github.com/mroderick/PubSubJS

如果沒有接觸過的朋友請自行谷歌百度吧，就不浪費口水，額，鍵盤啦，什么，沒有jQuery，呵呵，呵呵，正如Knockout官方文檔里說的，Everyoue loves jquery。

RequireJS我用來做模塊加載器，Knockout做MVVM分離也是爽到沒朋友（誰用誰知道），Bootstrap搭建界面布局，PubSub，看著名字就知道啦。

文檔結構

Libs:放置上文中提到的各種框架和工具；

App：主要的工作目錄，articleList、catalog、articleViewer分別代表整個前端應用中的一個組件,對應的.html文件是他們自身的視圖模板;

Utilities:存放一些工具類，如檢測設備、格式化Url和字符串等；

Layout：只有一個文件，存放了整個前端應用的模板，可以通過更改這個文件，來改變各個組件的表現形式。

服務端API準備

為這個示例，我只準備了三個服務端API：

GetCatalog 得到文章類型目錄：

namespace MiaoBlog.Controllers.API
{
    public class CatalogController:ApiController
    {
        public IEnumerable<CategoryView> Get()
        {
            GetAllCategoriesResponse response = articleCatalogService.GetAllCategories();
            return response.Categories;
        }
    }
}

GetArticlesByCategory 根據類型ID和頁面編號獲取文章目錄，

GetArticle 根據文章ID獲取文章內容等信息：

namespace MiaoBlog.Controllers.API
{
    public class ArticlesController:ApiController
    {
        public IEnumerable<ArticleSummaryView> GetArticlesByCategory(int categoryId, int pageNumber)
        {
            GetArticlesByCategoryRequest request = GenerateArticlesByCategoryRequestFrom(categoryId, pageNumber-1);
            GetArticlesByCategoryResponse response = articleCatalogService.GetArticlesByCategory(request);
            return response.Articles;
        }

        public ArticleDetailPageView GetArticle(int id)
        {
            ArticleDetailPageView detailView = new ArticleDetailPageView();
            GetArticleRequest request = new GetArticleRequest() { ArticleId = id };
            GetArticleResponse response = articleCatalogService.GetArticle(request);
            ArticleView articleView = response.Article;
            detailView.Article = articleView;
            detailView.Comments = response.Comments;
            detailView.Tags = response.Tags;
            return detailView;
        }


        PRivate static GetArticlesByCategoryRequest GenerateArticlesByCategoryRequestFrom(int categoryId, int index)
        {
            GetArticlesByCategoryRequest request = new GetArticlesByCategoryRequest();
            request.NumberOfResultsPerPage = int.Parse(applicationSettingsFactory.GetApplicationSettings().NumberOfResultsPerPage);
            request.Index = index;
            request.CategoryId = categoryId;
            request.ExcerptLength = int.Parse(ApplicationSettingsFactory.GetApplicationSettings().ExcerptLength);
            return request;
        }
    }
}

Require配置與系統配置

這里我用到的Require的幾個常用插件：domReady、CSS、text.

paths配置了引用的js的別稱：

paths:{
        'lib/jquery': './Libs/jquery-1.11.1',
        'lib/underscore': './Libs/underscore',
        'lib/unserscore/string': './Libs/underscore.min',
        'lib/backbone':'./Libs/backbone',
        'lib/backbone/eproxy':'./Libs/backbone.eproxy',
        'lib/backbone/super': './Libs/backbone.super',
        'lib/pubsub': './Libs/pubsub',
        'r/css': './Libs/css',
        'r/less': './Libs/less',
        'r/text': './Libs/text',
        'r/domReady': './Libs/domReady',
        'r/normailize': './Libs/normalize',
        'pubsub': './Libs/pubsub',
        'lib/ko': './Libs/knockout-3.2.0',
        'utility': './Utilities/utility',
        'util/matrix2d': './Utilities/matrix2d',
        'util/meld':'./Utilities/meld',
        'lib/bootstrap': './Libs/bootstrap-3.2.0/dist/js/bootstrap',
        'lib/bootstrap/css': './Libs/bootstrap-3.2.0/dist/css/'
    },

shim的配置略過；

然后就是require的調用入口了，從這里啟動整個前端應用：

require(['lib/jquery', 'r/domReady', 'lib/underscore', 'config', 'r/text!Layout/template.html', 'r/css!lib/bootstrap/css/bootstrap.css', 'lib/bootstrap', ], function ($, domReady, _, config, template) {
    domReady(function () {
        var rootContainer = $("body").find("[data-container='root']");
        var oTemplate=$(template);
        var modules = $("[data-module]",oTemplate);
        _.each(modules, function (module, index) {
            require(["App/" + $(module).attr("data-module")], function (ModuleClass) {
                var combineConfig = _.defaults(config[$(module).attr("data-module")], config.application);
                var oModule = new ModuleClass(combineConfig);
                oModule.load();
                oModule.render(modules[index]);
            });
        });
        rootContainer.append(oTemplate);
    });
});

這里看到了template.html通過r/text引入，上文中提到過，它就是整個應用程序的模板文件，先看一下它的結構我再接著解釋代碼內容：

<div class="container">
    <div class="row">
        <div class="col-lg-3" data-module="catalog"></div>
        <div class="col-lg-9" data-module="articleList"></div>
    </div>
    <div data-module="articleViewer"></div>
</div>

這樣看起來，代碼的意圖就明晰多了，在頁面中查到了data-container為root的節點，將它作為整個前端應用的根節點，然后再讀取上面的模板文檔，根據模板中標簽的data-module屬性，獲得模塊名稱，然后動態的加載模塊。

在這里我使用了Underscore的_.defaults方法，給各個模塊取得了各自的配置內容和公用配置內容，Underscore是js的一個工具類，自行百度，不多介紹，還有個個人推薦的Underscore.string，它提供了很多js處理字符串的方法，比較方便好用。

上文所提及的應用配置文件如下：

define(function () {
    return {
        application: {
            Events: {
                SWITCH_CATEGORY:"Miaoblog_Switch_Category",
                OPEN_ARTICLE:"Miaoblog_Open_Article"
            }
        },

        catalog: {
            APIs: {
                GetCatalog: {
                    Url: "http://localhost:15482/api/Catalog"
                }
            }
        },
        articleList: {
            APIs: {
                GetArticleList: {
                    Url: "http://localhost:15482/api/Articles",
                    ParamsFormat: "categoryId={0}&pageNumber={1}"
                }
            }
        },
        articleViewer: {
            APIs: {
                GetArticle: {
                    Url:"http://localhost:15482/api/Articles/{0}"
                }
            }
        }
    };
});

結合上文中的代碼，可以明確的知道一點，各個組件模塊最終只會得到關于它自己的配置項目和公用的，也就是application級別的配置內容，在application對象中的Events對象在下文中將會做詳細的介紹。

模塊中的工作

就已catalog模塊為例，先貼上代碼，再做解釋：

/// <reference path="../Libs/require.js" />
define(['lib/jquery', 'lib/ko', 'lib/underscore','pubsub', 'r/text!App/catalogList.html'],
    function ($, ko,_, hub,template) {
        var app = function (config) {
            this.catalogList = null;
            this.oTemplate = $(template);
            this.config = config;
        }

        _.extend(app.prototype, {
            load: function () {
                var self = this;
                $.Ajax({
                    type: "GET",
                    async: false,
                    url: self.config.APIs.GetCatalog.Url,
                    dataType: "json",
                    success: function (data) {
                        self.catalogList = data;
                    },
                    error: function (jqXHR, textStatus, error) {
                        console.log(error);
                    }
                });
            },
            render: function (container) {
                var self = this;
                var oContainer = $(container);
           
                var list = {
                    categories: ko.observableArray(),
                    switchCategory: function (selected) {
                        //alert("Hello world"+selected.Id);
                        hub.publish(self.config.Events.SWITCH_CATEGORY, selected.Id);
                    }
                };
                list.categories(self.catalogList);
                oContainer.append(this.oTemplate);
                ko.applyBindings(list, this.oTemplate.get(0));
            }
        });

        return app;
});

這里唯一新的內容就是大殺器knockout終于出場了。

從上一節內容可以看到，主模塊將會一次調用子模塊的load和render方法，在這個子模塊catalog中，load階段，通過對服務端的api調用得到了文章目錄，API的地址是通過config文件的解析傳遞過來的，的數據結構是這樣的：

而在render階段，傳入的參數為僅供給當前組件的占位，組件自身可以決定怎樣去布局這個占位，這就涉及到了它自身的模板文件了：

<ul class="nav nav-pills nav-stacked" data-bind="foreach:categories">
    <li>
        <a href="#" data-bind="attr:{categoryId:Id},click:$parent.switchCategory">
            <!--ko text: Name--><!--/ko-->
            <span class="badge pull-right" data-bind="text:ArticlesCount"></span>
        </a>
    </li>
</ul>

在數據和視圖兩者間，我使用了Knockout進行綁定，它的優勢在文檔中有詳細的描述，如果您想了解的話，就在文章開始找鏈接吧；

接著分析代碼，在視圖中，使用了Bootstrap的樣式創建了一個目錄樣式，并且banding了一個switchCategory方法到viewModel中，當我們點擊每一個類型鏈接時候，系統會通過上文中提到的Pubsub工具發布一個SWITCH_CATEGORY的事件出去，并且攜帶了所點擊類型的ID，這個常量字符串也是在上一節中的config文件中配置的。

模塊間的工作

上一節中提到了Pubsub發布了一個事件出去，意圖是希望文章列表或者其他什么關心這個事件的組件去做它自己的工作，在這個示例中當然就只有articleList這個組件了，來看一下這個組件的代碼：

/// <reference path="../Libs/require.js" />
define(['lib/jquery', 'lib/ko', 'lib/underscore', 'utility', 'pubsub', 'r/text!App/articleList.html','r/css!App/CommonStyle/style.css'],
    function ($, ko, _, utility,hub,layout) {
        var app = function (config) {
            this.config = config;
            this.oTemplate = $(layout);
            this.currentPageArticles = null;
            this.currentCategoryId = null;
            this.currentPageNumber = null;
            this.articleListViewModel = null;
        }

        _.extend(app.prototype, {
            initialize:function(){
                
            },

            load: function () {
                var self = this;
                hub.subscribe(this.config.Events.SWITCH_CATEGORY, function (msg, data) {
                    self.switchCategory(data);
                });
            },

            render: function (container) {
                var self = this;
                var oContainer = $(container);
                this.articleListViewModel = {
                    articles: ko.observableArray(),
                    openArticle: function (selected) {
                        hub.publish(self.config.Events.OPEN_ARTICLE, selected.Id);
                    }
                };
                oContainer.append(this.oTemplate);
                ko.applyBindings(this.articleListViewModel, this.oTemplate.get(0));
            },

            switchCategory: function (categoryId) {
                var self = this;
                self.currentCategoryId = categoryId;
                self.currentPageNumber = 1;
                $.ajax({
                    type: "GET",
                    async: true,
                    url: utility.FormatUrl(false,self.config.APIs.GetArticleList,categoryId,self.currentPageNumber),
                    dataType: "json",
                    success: function (data) {
                        self.articleListViewModel.articles(data);
                    }
                });
            },
            turnPage: function (pageNumber) {

            }
        });

        return app;
    }
);

這里主要看以下兩個點：

1.在Load階段，組件監聽了SWITH_CATEGORY這個事件，在事件觸發后，將調用switchCategory方法；因為這個SWITCH_CATEGORY這個常量是配置在application對象中，所以它在各個組件間是公用的；

2.在switchCategory中，傳入的即使上一節中提到的類型ID，然后同樣通過上一節的方法，調用服務端API，獲得數據，然后使用knockout進行數據綁定，在ViewModel中，可以看到一個openArticle方法，同樣發布了一個事件，在這個示例中，是右articleViewer監聽的，由于原理相近，就不多做解釋了，僅有破圖了代碼送上。