angularjs backbone 集成requirejs 模块化

首先认识requirejs

requirejs是个包加载器，核心功能是模块化管理，可以实现按需加载。 重点是明白 模块化不是按需加载。

模块化的意义： 是通过代码逻辑表明模块之间的依赖关系和执行顺序，按照模块逻辑来分解代码，起到配合mvc框架架构项目的作用。

按需加载：顾名思义 根据需要 通过模块依赖  event事件  加载所需的模块。

因为做的本地混合应用，在我项目中的主要的作用是模块化，我使用requirejs的原因是模块化管理，不是按需加载。

backbone 配合 requirejs 架构前端方案     https://github.com/breakfriday/backboneMvc-requirejs

backbone是非常经典的前端mvc框架 除了mvc几乎没有其他功能。

如果用backbone这一类框架 架构项目   流程：

aaarticlea/png;base64,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" alt="" width="884" height="542" />

上图 可以看到

backbone一类框架的流程    路由驱动控制器（此处增加backboneMvc插件  backbone本身没有控制其逻辑）  控制器驱动action  action完成对应的视图模块与model模块的调用，保证多个视图模块与model之间的通信

模块结构 入口文件调用module a，module a调用module  b，依次 module b 调用 c ,e , f ...   完成模板的编译  事件的绑定  viewMode的组装 ..... 最后生成视图对象  render。

ctrl1 通过require（[],function(){}）可以实现按需加载

define(function (require) {
    BackboneMVC = require("BackboneMVC")
    $ = require("jquery")
    _ = require("underscore")

    return function(){
        BackboneMVC.namespace('MyApp.Controllers');
        MyApp.Controllers.ToyController = BackboneMVC.Controller.extend({
            name: 'ct1', /* the only mandatory field */
            index: function () {
              alert("ct1")
            },

            test1: function () {
                require(['model/model'],function(model){

                    model.init().done(function () {
                        $(".pages").append("<div style='color: red'>test0 done  " + model.name+"</div>")
                    }).fail(function () {
                        alert("not ok")
                    })
                    this.model=undefined
                }.bind(this))

            },

            test2: function () {
                require(["model/model2", "view/view2"], function (model, view1) {
                    var model = this.model = this.model || new  model
                    model.init().done(function () {
                        view1.sucess(model.name)
                        this.test2()

                    }.bind(this)).fail(function () {
                        view1.fail()

                    }).progress(function () {
                        view1.progess()
                    })

                }.bind(this))
            }

        });
    }

});

或者 对比ctrl2流程逻辑与ctrl1相同，ctr2l使用commonjs的写法require（）  其实是标注模块的依赖性，进define头，一次性加载。  requirejs 支持commonjs的语法 但是使用的是amd的协议

define(function (require) {
    BackboneMVC = require("BackboneMVC")
    $ = require("jquery")
    _ = require("underscore")

    return function(){
        BackboneMVC.namespace('MyApp.Controllers');
        MyApp.Controllers.ToyController = BackboneMVC.Controller.extend({
            name: 'ct2', /* the only mandatory field */
            index: function () {
                 alert("this is ct2")
            },

            test1: function () {
                var model=require('model/model')

                model.init().done(function () {
                    $(".pages").append("<div style='color: red'>test0 done  " + model.name+"</div>")
                }).fail(function () {
                    alert("not ok")
                })
                this.model=undefined
            },

            test2: function () {
                var model=require("model/model2")
                var view1=require("view/view2")

                var model = this.model = this.model || new  model
                model.init().done(function () {
                    view1.sucess(model.name)
                    if (model.name > 1) {
                        this.test2()
                    }
                }.bind(this)).fail(function () {
                    view1.fail()
                }).progress(function () {
                    view1.progess()
                })
            }

        });
    }

});

这是我 requirejs + backbone 架构项目的结构。

用angular已经做了两个项目了，这里总结下

angular 框架执行流程：  前端方案  https://github.com/breakfriday/my-angularMvc

郁闷的是经常有人说 angular 已经有module了还需requirejs吗， angular的module 是命令的容器 与模块化意思不同。

angualr的模块化只是解决了 代码逻辑的耦合性的问题，没有通过原型链 class这一种方法来实现，而是通过依赖注入代替class，优点是耦合性很散可以很方便的拆分组合。

但是requirejs另一部功能，控制模块文件的加载，控制模块文件的分割，控制模块文件的依赖关系  这一部分逻辑是angular没做的。

angular使用requirejs

1.打包方便， 使用requrejs 模块化 ，编辑代码的过程就定义了模块之间的依赖关系，打包时候，不需要一个一个文件对照，用不到没有依赖关系的文件不会被打包，也不会漏掉文件。

2.将script 脚本从模板页面（针对mvc框架）抽离出来，通过js当前模块加载需要依赖的js模块。模板页面只是模板。

3.可以实现 按需加载

angular  使用命令式编程的一个框架,所以在耦合性上采用了依赖注入  ，流程与backbone一类 框架不一样 ，流程执行不是通过controller model view模块之间的调用，而是通过模板中的命令驱动。

首先认识 angular

app.js  angular启动文件

define([
    'angular',
    "controller/controllers",
    "directive/directives",
    "filter/filters",
    "angularRoute"

], function (angular,controllers,directives,filiters) {
var webApp=angular.module('ccmsApp', ["ngRoute",controllers.name,directives.name,filiters.name])

    })

main.js requirejs配置文件  手动启动angular

require([ 'angular', 'script/app',"jquery"], function (angular, app) {

    angular.element().ready(function () {

        angular.resumeBootstrap([app['name']]);
    });
})

模块的注入方式分为    1. 按需加载    2.预加载     两种方案

在我的项目中，

　　　　directive service使用预加载，优点可以合并压缩成一个文件 减少http请求。且我的directive service 文件比较多很多是小文件，且各个视图都会用到，不太好从视图的逻辑来分割加载模块文件。

　　　　controller 是按需加载, 优点按需加载，因为controller 处理的就是viewModel  所以控制器文件与视图关系是多对一，可以从视图的逻辑来分割加载模块文件。缺点是因为是异步模块，所以不进amd 依赖关系不会被打包，

　　需要再写个built1.js  负责压缩整个异步模块的目录

service预加载：

define(function(require){
    var angular=require("angular")
    var accountService=require("service/script/accountService")
    var ngCustomListService=require("service/script/ngCustomListService")
    var ngCustomService=require("service/script/ngCustomService")
    var saveService=require("service/script/saveService")
    var getListService=require("service/script/getListService")
    var deleteService=require("service/script/deleteService")
    var RFMTreeService=require("service/script/RFMTreeService")
    var queryConfigService=require("service/script/queryConfigService")
    var dataTableConfigService=require("service/script/dataTableConfigService")
    var dataFilterConfigService=require("service/script/dataFilterConfigService")
    var ngRedAndBlackCustomService=require("service/script/ngRedAndBlackCustomService")
    var productLabelService=require("service/script/productLabelService")
    var ngDataImportService=require("service/script/ngDataImportService")

    var dataService=angular.module('dataServices', [])

    dataService.factory({
        "ngCustomListService":ngCustomListService ,
        "ngCustomService":ngCustomService,
        "saveService":saveService,
        "getListService":getListService,
        "deleteService":deleteService,
        "accountService":accountService,
        "queryConfigService":queryConfigService,
        "dataTableConfigService":dataTableConfigService,
        "dataFilterConfigService":dataFilterConfigService,
        "RFMTreeService":RFMTreeService,
        "ngRedAndBlackCustomService":ngRedAndBlackCustomService,
        "productLabelService":productLabelService,
        "ngDataImportService":ngDataImportService
    })

    return dataService;
})

　　

　　

按需加载：

使用angular 路由的resolve api，在路由启动时，require 对应的ngView视图模板页面中所需的controller  directive模块。

通过$controllerProvider.register 　　 $compileProvider.directive  　　$filterProvider.register　　  $provide.provider创建controller directive  filter service 依赖模块。

resolve阻塞，保证对应视图中的命令（controller，directive，filiter） 注入完成后再run

function config(templateUrl, controllerName, directives) {
        if (!$controllerProvider) {
            throw new Error("$controllerProvider is not set!");
        }

        var defer,
            html,
            routeDefinition = {};

        routeDefinition.templateUrl =templateUrl

        routeDefinition.controller = controllerName;

        routeDefinition.resolve = {
            delay:function ($q, $rootScope) {
                defer = $q.defer();

                    var dependencies = [controllerName];
                    if (directives) {
                        dependencies = dependencies.concat(directives);
                    }
                    require(dependencies, function () {    //按需加载 所需的控制器 directives 模块  ，
                                                          //  通过$controllerProvider.register    $compileProvider.directive创建
                        var controller = arguments[0],
                            template = "";

                        for (var i = 2; i < arguments.length; i++) {
                            lazyDirectives.register(arguments[i]);
                        }

                        $controllerProvider.register(controllerName, controller);  /*创建控制器*/
                        html = template;
                        defer.resolve();   /*加载完 返回resolve状态*/
                        $rootScope.$apply()
                    })

                return defer.promise;
            }
        }

        return routeDefinition;
    }

       $routeProvider.when('/view2', routeConfig.config('./partials/view2.html', 'controllers/second', ['directives/version']));