模块化 订阅
模块化是指解决一个复杂问题时自顶向下逐层把系统划分成若干模块的过程,有多种属性,分别反映其内部特性。 展开全文
模块化是指解决一个复杂问题时自顶向下逐层把系统划分成若干模块的过程,有多种属性,分别反映其内部特性。
信息
外文名
Module
基本属性
接口、功能、逻辑、状态
定    义
可管理模块的方式
中文名
模块化
运行模式
独立的工作运行模式
模块化定义
模块化是一种处理复杂系统分解为更好的可管理模块的方式。 [1] 
收起全文
精华内容
参与话题
问答
  • 模块化

    千次阅读 2012-07-19 05:47:18
    在编写软件的时候,非常提倡模块化的做法,不管是当初的面向过程的编程方式,还是现在面向对象的编程方式,模块化都很重要。而过程和函数更是模块化的产物,至于OSGi中的bundle,更是把模块化提升到新的高度。模块化...

    在编写软件的时候,非常提倡模块化的做法,不管是当初的面向过程的编程方式,还是现在面向对象的编程方式,模块化都很重要。而过程和函数更是模块化的产物,至于OSGi中的bundle,更是把模块化提升到新的高度。

    模块化应该是一个借鉴的结果,最早的模块化从何而来,已经无从考证,但是看看其他学科中,模块化的存在已经有一段时间了。

    比方说建筑学,活动房或者一些新的建筑方式中就体现了模块化的思想,先制造出一些可以直接利用的组件,然后在建筑工地上直接组合,就可以造出一片房子来。

    再比方在电子领域,体现的更为突出,集成电路把很多电阻、电容等等小部件组合在一起,这样在制造电器的时候并不需要从头做起,而是直接拿过来使用就好。

    模块化的思想基于划分的思想,或者说是分类的思想,就是要把类似的、相互关联的内容放在一起管理,从而从总体上简化过程。而每个模块的内部可能比较复杂,但暴露给外部的接口会比较简单,那样使用的时候,就不用考虑内部的复杂性,从而简化问题。

    模块的好处更多在于能够批量生产和重复利用,软件领域有句话说“不要重复制造轮子”,轮子其实就是汽车制造行业中的一个大模块,汽车制造厂更多的是在组装轮子,而不是制造轮子。而软件开发领域同样不需要什么内容都从头开始编写,如果有现成的程序库,大可以拿过来直接使用,那样不仅能够提高效率,还可以降低出错的几率。

    生活有时同样可以模块化,比方说对时间的管理,我们可以按照番茄工作法,把时间划分为小的时间段,然后在每个时间段内分配类似的工作或者事情,从而更好地集中精力来做好这件事。再比方,在做各种事情的经验上,其实也是在头脑中形成了不同的模块来放置,并进行了归类。在解决新的问题时,就会把经验从大脑的各个存储领域取出来,组合出一套新的解决方案来。

    分解和组合是对模块使用的重要方式,分解可以让我们了解内部的细节,在模块出现问题的时候,可以知道如何解决。而组合可以把小的模块形成大的模块,再把大的模块组合成更大的模块,直到形成我们想要的事物。

    模块化体现的哲学思想,有“一生二,两仪生四象,四象生八卦”的思想,也有分而治之的思想,也有大事化小,小事化了的思想,总之这几种都有异曲同工之妙。

    展开全文
  • 前端模块化,AMD与CMD的区别

    万次阅读 多人点赞 2016-08-03 17:15:51
    AMD和CMD的区别,require和seajs的用法,CommonJS的规范...

    最近在研究cmd和amd,在网上看到一篇不错的文章,整理下看看。
    在JavaScript发展初期就是为了实现简单的页面交互逻辑,寥寥数语即可;如今CPU、浏览器性能得到了极大的提升,很多页面逻辑迁移到了客户端(表单验证等),随着web2.0时代的到来,Ajax技术得到广泛应用,jQuery等前端库层出不穷,前端代码日益膨胀

    这时候JavaScript作为嵌入式的脚本语言的定位动摇了,JavaScript却没有为组织代码提供任何明显帮助,甚至没有类的概念,更不用说模块(module)了,JavaScript极其简单的代码组织规范不足以驾驭如此庞大规模的代码

    模块

    既然JavaScript不能handle如此大规模的代码,我们可以借鉴一下其它语言是怎么处理大规模程序设计的,在Java中有一个重要带概念——package,逻辑上相关的代码组织到同一个包内,包内是一个相对独立的王国,不用担心命名冲突什么的,那么外部如果使用呢?直接import对应的package即可

    import java.util.ArrayList;
    遗憾的是JavaScript在设计时定位原因,没有提供类似的功能,开发者需要模拟出类似的功能,来隔离、组织复杂的JavaScript代码,我们称为模块化。

    一个模块就是实现特定功能的文件,有了模块,我们就可以更方便地使用别人的代码,想要什么功能,就加载什么模块。模块开发需要遵循一定的规范,各行其是就都乱套了

    规范形成的过程是痛苦的,前端的先驱在刀耕火种、茹毛饮血的阶段开始,发展到现在初具规模,简单了解一下这段不凡的历程

    函数封装

    我们在讲函数的时候提到,函数一个功能就是实现特定逻辑的一组语句打包,而且JavaScript的作用域就是基于函数的,所以把函数作为模块化的第一步是很自然的事情,在一个文件里面编写几个相关函数就是最开始的模块了

    function fn1(){
        statement
    }
    
    function fn2(){
        statement
    }
    

    这样在需要的以后夹在函数所在文件,调用函数就可以了

    这种做法的缺点很明显:污染了全局变量,无法保证不与其他模块发生变量名冲突,而且模块成员之间没什么关系。

    对象

    为了解决上面问题,对象的写法应运而生,可以把所有的模块成员封装在一个对象中

    var myModule = {
        var1: 1,
    
        var2: 2,
    
        fn1: function(){
    
        },
    
        fn2: function(){
    
        }
    }
    

    这样我们在希望调用模块的时候引用对应文件,然后

    myModule.fn2();
    这样避免了变量污染,只要保证模块名唯一即可,同时同一模块内的成员也有了关系

    看似不错的解决方案,但是也有缺陷,外部可以随意修改内部成员

    myModel.var1 = 100;
    这样就会产生意外的安全问题

    立即执行函数

    可以通过立即执行函数,来达到隐藏细节的目的

    var myModule = (function(){
        var var1 = 1;
        var var2 = 2;
    
        function fn1(){
    
        }
    
        function fn2(){
    
        }
    
        return {
            fn1: fn1,
            fn2: fn2
        };
    })();
    

    这样在模块外部无法修改我们没有暴露出来的变量、函数

    上述做法就是我们模块化的基础,目前,通行的JavaScript模块规范主要有两种:CommonJS和AMD

    CommonJS

    我们先从CommonJS谈起,因为在网页端没有模块化编程只是页面JavaScript逻辑复杂,但也可以工作下去,在服务器端却一定要有模块,所以虽然JavaScript在web端发展这么多年,第一个流行的模块化规范却由服务器端的JavaScript应用带来,CommonJS规范是由NodeJS发扬光大,这标志着JavaScript模块化编程正式登上舞台。

    1、定义模块
    根据CommonJS规范,一个单独的文件就是一个模块。每一个模块都是一个单独的作用域,也就是说,在该模块内部定义的变量,无法被其他模块读取,除非定义为global对象的属性

    2、模块输出:
    模块只有一个出口,module.exports对象,我们需要把模块希望输出的内容放入该对象

    3、加载模块:
    加载模块使用require方法,该方法读取一个文件并执行,返回文件内部的module.exports对象

    看个例子

    //模块定义 myModel.js
    
    var name = 'Byron';
    
    function printName(){
        console.log(name);
    }
    
    function printFullName(firstName){
        console.log(firstName + name);
    }
    
    module.exports = {
        printName: printName,
        printFullName: printFullName
    }
    
    //加载模块
    
    var nameModule = require('./myModel.js');
    
    nameModule.printName();
    

    不同的实现对require时的路径有不同要求,一般情况可以省略js拓展名,可以使用相对路径,也可以使用绝对路径,甚至可以省略路径直接使用模块名(前提是该模块是系统内置模块)

    尴尬的浏览器

    仔细看上面的代码,会发现require是同步的。模块系统需要同步读取模块文件内容,并编译执行以得到模块接口。

    这在服务器端实现很简单,也很自然,然而, 想在浏览器端实现问题却很多。

    浏览器端,加载JavaScript最佳、最容易的方式是在document中插入script 标签。但脚本标签天生异步,传统CommonJS模块在浏览器环境中无法正常加载。

    解决思路之一是,开发一个服务器端组件,对模块代码作静态分析,将模块与它的依赖列表一起返回给浏览器端。 这很好使,但需要服务器安装额外的组件,并因此要调整一系列底层架构。

    另一种解决思路是,用一套标准模板来封装模块定义,但是对于模块应该怎么定义和怎么加载,又产生的分歧:

    AMD

    AMD 即Asynchronous Module Definition,中文名是异步模块定义的意思。它是一个在浏览器端模块化开发的规范

    由于不是JavaScript原生支持,使用AMD规范进行页面开发需要用到对应的库函数,也就是大名鼎鼎RequireJS,实际上AMD 是 RequireJS 在推广过程中对模块定义的规范化的产出

    requireJS主要解决两个问题

    1、多个js文件可能有依赖关系,被依赖的文件需要早于依赖它的文件加载到浏览器
    2、js加载的时候浏览器会停止页面渲染,加载文件越多,页面失去响应时间越长
    看一个使用requireJS的例子

    // 定义模块 myModule.js
    define(['dependency'], function(){
        var name = 'Byron';
        function printName(){
            console.log(name);
        }
    
        return {
            printName: printName
        };
    });
    
    // 加载模块
    require(['myModule'], function (my){
      my.printName();
    });
    

    语法

    requireJS定义了一个函数 define,它是全局变量,用来定义模块

    define(id?, dependencies?, factory);

    1. id:可选参数,用来定义模块的标识,如果没有提供该参数,脚本文件名(去掉拓展名)
    2. dependencies:是一个当前模块依赖的模块名称数组
    3. factory:工厂方法,模块初始化要执行的函数或对象。如果为函数,它应该只被执行一次。如果是对象,此对象应该为模块的输出值
      在页面上使用require函数加载模块

    require([dependencies], function(){});
    require()函数接受两个参数

    1. 第一个参数是一个数组,表示所依赖的模块
    2. 第二个参数是一个回调函数,当前面指定的模块都加载成功后,它将被调用。加载的模块会以参数形式传入该函数,从而在回调函数内部就可以使用这些模块

    require()函数在加载依赖的函数的时候是异步加载的,这样浏览器不会失去响应,它指定的回调函数,只有前面的模块都加载成功后,才会运行,解决了依赖性的问题。

    CMD

    CMD 即Common Module Definition通用模块定义,CMD规范是国内发展出来的,就像AMD有个requireJS,CMD有个浏览器的实现SeaJS,SeaJS要解决的问题和requireJS一样,只不过在模块定义方式和模块加载(可以说运行、解析)时机上有所不同
    语法
    Sea.js 推崇一个模块一个文件,遵循统一的写法
    define(id?, deps?, factory)
    因为CMD推崇

    1. 一个文件一个模块,所以经常就用文件名作为模块id
    2. CMD推崇依赖就近,所以一般不在define的参数中写依赖,在factory中写

    factory是一个函数,有三个参数,function(require, exports, module)

    1. require 是一个方法,接受 模块标识 作为唯一参数,用来获取其他模块提供的接口:require(id)
    2. exports 是一个对象,用来向外提供模块接口
    3. module 是一个对象,上面存储了与当前模块相关联的一些属性和方法

    看个例子:

    // 定义模块  myModule.js
    define(function(require, exports, module) {
      var $ = require('jquery.js')
      $('div').addClass('active');
    });
    
    // 加载模块
    seajs.use(['myModule.js'], function(my){
    
    });
    

    AMD与CMD区别

    关于这两个的区别网上可以搜出一堆文章,简单总结一下

    最明显的区别就是在模块定义时对依赖的处理不同

    1、AMD推崇依赖前置,在定义模块的时候就要声明其依赖的模块
    2、CMD推崇就近依赖,只有在用到某个模块的时候再去require
    这种区别各有优劣,只是语法上的差距,而且requireJS和SeaJS都支持对方的写法

    AMD和CMD最大的区别是对依赖模块的执行时机处理不同,注意不是加载的时机或者方式不同

    很多人说requireJS是异步加载模块,SeaJS是同步加载模块,这么理解实际上是不准确的,其实加载模块都是异步的,只不过AMD依赖前置,js可以方便知道依赖模块是谁,立即加载,而CMD就近依赖,需要使用把模块变为字符串解析一遍才知道依赖了那些模块,这也是很多人诟病CMD的一点,牺牲性能来带来开发的便利性,实际上解析模块用的时间短到可以忽略

    为什么我们说两个的区别是依赖模块执行时机不同,为什么很多人认为ADM是异步的,CMD是同步的(除了名字的原因。。。)

    同样都是异步加载模块,AMD在加载模块完成后就会执行改模块,所有模块都加载执行完后会进入require的回调函数,执行主逻辑,这样的效果就是依赖模块的执行顺序和书写顺序不一定一致,看网络速度,哪个先下载下来,哪个先执行,但是主逻辑一定在所有依赖加载完成后才执行

    CMD加载完某个依赖模块后并不执行,只是下载而已,在所有依赖模块加载完成后进入主逻辑,遇到require语句的时候才执行对应的模块,这样模块的执行顺序和书写顺序是完全一致的

    这也是很多人说AMD用户体验好,因为没有延迟,依赖模块提前执行了,CMD性能好,因为只有用户需要的时候才执行的原因

    展开全文
  • C语言模块化

    千次阅读 2008-02-19 10:25:00
    在C语言的应用领域,如通讯领域和嵌入式系统领域,一个的软件项目通常包含很多复杂的功能,实现这个项目不是一个程序员单枪匹马可以胜任的,往往需要一个团队的有效合作,另外,在一个以C代码为主的完整的项目中,...
     在C语言的应用领域,如通讯领域和嵌入式系统领域,一个的软件项目通常包含很多复杂的功能,实现这个项目不是一个程序员单枪匹马可以胜任的,往往需要一个团队的有效合作,另外,在一个以C代码为主的完整的项目中,经常也需要加入一些其他语言的代码,例如,C代码和汇编代码的混合使用,C文件和C++的同时使用。这些都增加了一个软件项目的复杂程度,为了提高软件质量,合理组织的各种代码和文件是非常重要的。       
           
        组织代码和文件的目的是为了使团队合作更加有效,使软件项目有良好的可扩展性、可维护性、可移植性、可裁减、可测试性,防止错误发生,提高软件的稳定性。通常情况下,软件项目采用层次化结构和模块化开发的方法,例如,一个嵌入式软件项目可能有驱动层,操作系统层,功能层,应用程序层,每一个层使用它的下层提供的接口,并为它的上层提供调用接口,模块则是每一个层中完成一个功能的单元,例如驱动层的每一个设备的驱动就是一个模块,应用层的每个应用程序就是一个模块,模块使用下层提供的接口和同层其他模块提供的接口,完成特定功能,为上层和同层的其他模块提供调用接口。      
           
        这里的接口是指一个功能模块暴露出来的,提供给其他模块的访问具体功能的方法。根据C语言的特点,使用*.c文件实现模块的功能,使用*.h文件暴露单元的接口,在*.h文件里声明外部其他模块可能是用的函数,数据类型,全局变量,类型定义,宏定义和常量定义.外部模块只需包含*.h文件就可以使用相应的功能.当然,模块可以在细化为子模块.虽然我们这里说的接口和COM(通用组件模型)里定义的接口不同,但是,根据COM里对接口的讨论,为了使软件在修改时,一个模块的修改不会影响到其他模块的一个模块的修改不会导致其他模块也需要修改,所以,接口第一次发布后,修改*.h文件不能导致使用这个接口的其他模块需要重新编写.      
           
        根据C语言的特点,并借鉴一些成熟软件项目代码,总结C项目中代码文件组织的基本建议:      
        1,使用层次化和模块化的软件开发模型.每一个模块只能使用所在层和下一层模块提供的接口.      
        2,每个模块的文件包存在独立的一个文件夹中.通常情况下,实现一个模块的文件不止一个,这些相关的文件应该保存在一个文件夹中.      
        3,用于模块裁减的条件编译宏保存在一个独立的文件里,便于软件裁减.      
        4,硬件相关代码和操作系统相关代码与纯C代码相对独立保存,以便于软件移植.      
        5,声明和定义分开,使用*.h文件暴露模块需要提供给外部的函数,宏,类型,常量,全局变量,尽量做到模块对外部透明,用户在使用模块功能时不需要了解具体的实现,文件一旦发布,要修改一定要很慎重,      
        6,文件夹和文件命名要能够反映出模块的功能.      
        7,正式版本和测试版本使用统一文件,使用宏控制是否产生测试输出。      
        8,必要的注释不可缺少。      
           
        理想的情况下,一个可执行的模块提供一个公开的接口,即使用一个*.h文件暴露接口,但是,有时候,一个模块需要提供不止一个接口,这时,就要为每个定义的接口提供一个公开的接口。在C语言的里,每个C文件是一个模块,头文件为使用这个模块的用户提供接口,用户只要包含相应的头文件就可以使用在这个头文件中暴露的接口。所有的头文件都建议参考以下的规则:      
           
        1,   头文件中不能有可执行代码,也不能有数据的定义,只能有宏、类型(typedef,struct,union,menu),数据和函数的声明。例如以下的代码可以包含在头文件里:      
        #define       NAMESTRING       “name”      
        typedef       unsign       long       word;      
        menu{      
        flag1;      
        flag2;      
        };      
        typedef       struct{      
        int       x;      
        int       y;      
        }       Piont;      
        extent       Fun(void);      
        extent       int       a;      
        全局变量和函数的定义不能出现在*.h文件里。例如下面的代码不能包含在头文件:      
        int       a;      
        void       Fun1(void)      
        {      
                        a++;      
        }      
           
        2,头文件中不能包本地数据(模块自己使用的数据或函数,不被其他模块使用)。这一点相当于面向对象程序设计里的私有成员,即只有模块自己使用的函数,数据,不要用extent在头文件里声明,只有模块自己使用的宏,常量,类型也不要在头文件里声明,应该在自己的*.c文件里声明。      
        3,含一些需要使用的声明。在头文件里声明外部需要使用的数据,函数,宏,类型。      
        4,防止被重复包含。使用下面的宏防止一个头文件被重复包含。      
        #ifndef       MY_INCLUDE_H      
        #define       MY_INCLUDE_H      
        <头文件内容 >      
        #endif      
        5,包含extern       "C",使的程序可以在C++编译器被编译      
        #ifdef       __cplusplus      
                        extern       "C"{      
        #endif      
        <函数声明 >      
        #ifdef       __cplusplus      
                        }      
        #enfif      
          被extern       "C"修饰的变量和函数是按照C语言方式编译和连接的;未加extern       “C”声明时的编译方式,作为一种面向对象的语言,C++支持函数重载,而过程式语言C则不支持。函数被C++编译后在符号库中的名字与C语言的不同。例如,假设某个函数的原型为:          
        void       foo(       int       x,       int       y       );该函数被C编译器编译后在符号库中的名字为_foo,而C++编译器则会产生像_foo_int_int之类的名字(不同的编译器可能生成的名字不同,但是都采用了相同的机制,生成的新名字称为“mangled       name”)。_foo_int_int这样的名字包含了函数名、函数参数数量及类型信息,C++就是靠这种机制来实现函数重载的。例如,在C++中,函数void       foo(       int       x,       int       y       )与void       foo(       int       x,       float       y       )编译生成的符号是不相同的,后者为_foo_int_float。 同样地,C++中的变量除支持局部变量外,还支持类成员变量和全局变量。用户所编写程序的类成员变量可能与全局变量同名,我们以"."来区分。而本质上,编译器在进行编译时,与函数的处理相似,也为类中的变量取了一个独一无二的名字,这个名字与用户程序中同名的全局变量名字不同。加extern       "C"声明后的编译和连接,强制C++连接器按照C编译器产生的符号_foo链接。      
        6,保证在使用这个头文件时,用户不用再包含使用此头文件的其他前提头文件,即要使用的头文件已经包含在此头文件里。例如:area.h头文件包含了面积相关的操作,要使用这个头文件不需同时包含了关于点操作的头文件piont.h。用户在使用area.h时不需要手动包含piont.h,因为我们已经在area.h中用#include       “point.h”包含了这个头文件。      
           
        有一些头文件是为用户提供调用接口,这种头文件中声明了模块中需要给其他模块使用的函数和数据,鉴于软件质量上的考虑,处理参考以上的规则,用来暴露接口的头文件还需要参考更多的规则:      
        1,一个模块一个接口,不能几个模块用一个接口。      
        2,文件名为和实现模块的c文件相同。abc.c--abc.h      
        3,尽量不要使用extern来声明一些共享的数据。因为这种做法是不安全的,外部其他模块的用户可能不能完全理解这些变量的含义,最好提供函数访问这些变量。      
        4,尽量避免包含其他的头文件,除非这些头文件是独立存在的。这一点的意思是,在作为接口的头文件中,尽量不要包含其他模块的那些暴露*.C文件中内容的头文件,但是可以包好一些不是用来暴露接口的头文件。      
        5,不要包含那些只有在可执行文件中才使用的头文件,这些头文件应该在*.c文件中包含。这一点如同上一点,为了提高接口的独立性和透明度。      
        6,接口文件要有面向用户的充足的注释。从应用角度描述个暴露的内容。      
        7,接口文件在发布后尽量避免修改,即使修改也要保证不影响用户程序。      
           
        多个代码文件使用一个接口文件:这种头文件用于那些认为一个模块使用一个文件太大的情况。对于这种情况对于这种情况在参考上述建议后,也要参考以下建议。      
        1,多个代码文件组成的一个模块只有一个接口文件。因为这些文件完成的是一个模块。      
        2,使用模块下文件命名 <系统名 > <模块名命名 >      
        3,不要滥用这种文件。      
        4,有时候也会出现几个*.c文件用于共向数据的*.h文件,这种文件的特点是在一个*.c文件里定义全局变量,而在其他*.c文件里使用,要将这种文件和用于暴露模块接口的文件区别。      
        5,一个模块如果有几个子模块,可以用一个*.h文件暴露接口,在这个文件里用#include包含每个子模块的接口文件。      
           
        还有一种头文件,说明性头文件,这种头文件不需要有一个对应的代码文件,在这种文件里大多包含了大量的宏定义,没有暴露的数据变量和函数。这些文件给出以下建议:      
        1,包含一些需要的概念性的东西.      
        2,命名方式,定义的功能.h      
        3,不包含任何其他的头文件.      
        4,不定义任何类型.      
        5,不包含任何数据和函数声明.      
           
        上面介绍了C头文件的一些建议,下面介绍C代码文件*.c文件的一些建议,*.c文件是C语言中生成汇编代码和机器码的内容,要注意以下建议:      
        1.命名方式       模块名.c      
        2,用static修饰本地的数据和函数。      
        3,不要使用external。这是在*.h中使用的,可以被包含进来。      
        4,无论什么时候定义内部的对象,确保独立与其他执行文件。      
        5,这个文件里必须包含相应功能函数。      
           
        上面介绍了一些C文件组织的建议,用于提高C语言项目的质量,在以后的C项目组织中,学习面向对象和COM的思想,将这些思想加入到C程序中,能够写出更高质量的代码。上面的建议在具体的项目里应该灵活运用,附录里有*.h头文件和*.c代码文件的模版,在工程中可以作为参考。另外,C工程中经常有一些汇编代码文件,这些文件也要使有*.h头文件暴露其中的数据和函数,以便其他*.c文件包含使用。 <script src="http://pagead2.googlesyndication.com/pagead/show_ads.js" type="text/javascript"> </script>
    展开全文
  • 模块化开发

    千次阅读 2015-03-30 22:23:57
    什么是模块化模块化是个一般概念,这一概念也适用于软件开发,可以让软件按模块单独开发,各模块通常都用一个标准化的接口来进行通信。实际上,除了规模大小有区别外,面向对象语言中对象之间的关注点分离与模块...

    什么是模块化?

    模块化是个一般概念,这一概念也适用于软件开发,可以让软件按模块单独开发,各模块通常都用一个标准化的接口来进行通信。实际上,除了规模大小有区别外,面向对象语言中对象之间的关注点分离与模块化的概念基本一致。通常,把系统划分外多个模块有助于将耦合减至最低,让代码维护更加简单。

    类是模块

    类库毫无疑问也是模块。对于类库来讲,可能没有一个单一接口与之通信,但往往却有‘public’ API(可能被用到)和‘private’package(文档中说明了其用途)。此外,它们也有自己依赖的类库(比如JMX或JMS)。这将引起自动依赖管理器引入许多并非必须的类库:以Log4J-1.2.15为例,引入了超过10个依赖类库(包括javax.mailjavax.jms),尽管这些类库中有不少对于使用Log4J的程序来说根本不需要。

    某些情况下,一个模块的依赖可以是可选的;换句话说,该模块可能有一个功能子集缺少依赖。在上面的例子中,如果JMS没有出现在运行时 classpath中,那么通过JMS记录日志的功能将不可用,但是其他功能还是可以使用的。(Java通过使用延迟链接——deferred linking来达到这一目的:直到要访问一个类时才需要其出现,缺少的依赖可以通过ClassNotFoundException来处理。其他一些平台的弱链接——weak linking概念也是做类似的运行时检查。)

    通常,模块都附带一个版本号。许多开源项目生成的发行版都是以类似log4j-1.2.15.jar的方式命名的。这样开发者就可以在运行时通过手动方式来检测特定开源类库的版本。可是,程序编译的时候可能使用了另一个不同版本的类库:假定编译时用log4j-1.2.3.jar而运行时用log4j-1.2.15.jar,程序在行为上依然能够保持兼容。即使升级到下一个小版本,仍然是兼容的。所有这些都是基于惯例而非运行时已知约束。

    模块化怎么用?

    作为一般概念,模块化有助于将应用分解为不同的部件,各个部件可以单独测试(和开发)。正如上面所提到的,大多数类库都是模块。那么,对于那些生产类库提 供给别人使用的人来说,模块化是一个非常重要的概念。通常,依赖信息是在构建工具(maven pom ivy-module)里进行编码并被明确记录在类库使用文档中的。另外,高层类库开发过程中需要修改较低层级类库bug,以提供更好支持的情况并不少 见,即便低层类库的最新版本已经对bug进行了修正。

    如果一个类库是提供给他人使用的,那么它就已经是一个模块了。但是世上鲜有“Hello World”这样的类库,也鲜有“Hello World”这样的模块。只有当应用足够大时(或者是用一个模块化构建系统进行构建时),把应用划分为不同部件的概念就派上用场了。

    模块化的好处之一是便于测试。一个小模块(具有定义良好的API)通常比应用整体更好测试

    模块化的另一个好处是便于进化。尽管系统整体有一个版本号,但实际上,其下有多个模块及相应版本(不论开源与否,总有一些类库——甚至是Java版本—— 是系统所依赖的)。这样,每个模块都可以自己的方式自由地进化。某些模块进化得快些,另一些则会长期保持稳定(例如,Eclipse 3.5 org.eclipse.core.boot20082月以来一直没有改变过)。

    模块化也可给项目管理带来方便。如果一个模块公布的API可供其他模块预先使用,那么各个模块就可以由不同的团队分别开发。这在大型项目中必定会发生,各个项目子团队可以负责不同模块的交付。

    最后,将一个应用程序模块化,可以帮助识别正在使用依赖类库的哪个版本,以便协调大型项目中的类库依赖。

    展开全文
  • Python模块化编程

    千次阅读 2018-11-01 16:59:11
    模块化 自定义模块 模块的内置属性 导入模块 安装第三方模块 查看模块的属性和方法 模块化 在Python中,一个.py文件就称之为一个模块(Module),为了避免模块名冲突,Python又引入了按目录来组织模块的方法,...
  • 使用阿里ARouter路由实现组件化(模块化)开发流程

    万次阅读 多人点赞 2017-12-08 17:05:20
    Android平台中对页面、服务提供路由功能的中间件,我...模块化的要解决的问题 模块间页面跳转(路由); 模块间事件通信; 模块间服务调用; 模块的独立运行; 模块间页面跳转路由拦截(登录) 其他注意事项; ...
  • Javascript模块化编程系列一: 模块化的驱动  在前一篇介绍了为什么要进行Javascript模块化编程。至于如何实现模块化,不同的开发组织和个人具体的实现方式肯定是不一样。如何统一一个规范呢? CommonJS 就在做的...
  • Android 开发:由模块化到组件化(一)

    万次阅读 多人点赞 2016-12-15 01:43:15
    当你看到这的时候,想必心理一阵恶寒:模块化?组件化?到底是什么鬼?有啥区别. 有这种感觉才是对的,模块化和组件化本质思想是一样的,都是"大化小",两者的目的都是为了重用和解耦,只是叫法不一样.如果非要说区别,那么...
  • 面试介绍模块化

    千次阅读 2018-09-20 11:25:44
    面试介绍模块化 1.名字介绍 2.工作年份介绍 3.工作过的公司介绍 4.工作内容介绍 5.技术介绍 6.前段搭建过得框架 7.前段精通框架和技术 8.服务端精通语言和常用语言 9.服务端搭建过得架构 10.应用架构搭建 接口...
  • 模块设计之“模块”与“模块化

    千次阅读 2009-03-20 15:11:00
    模块设计之“模块”与“模块化” 模块泛指软件系统的功能部件。在软件的体系结构设计完成之际,我们就已经确定了所有模块的功能,并且把模块安放在体系结构的恰当位置上。 每个模块都具有特定的、明确的功能(否则...
  • CommonJS 的模块化规范描述在Modules/1.1.1 中 目前实现此规格的包有: Yabble,CouchDB,Narwhal (0.2), Wakanda, TeaJS (formerly v8cgi), CommonScript, PINF JS Loader, SeaJS, ArangoDB,
  • WebKit模块化分析

    万次阅读 热门讨论 2013-01-03 22:51:17
    模块化  软件的首要技术使命是管理复杂度(Complexity)。这是>中的一个标题。软件本质性困难的根源都在于复杂性。Dijkstra指出没有谁的大脑能容得下一计算机程序。正如社会进步催生社会分工一样,软件行业也...
  • java开发web怎么把每个功能模块化? 以前做项目 比如一个页面的数据都是在后台 一个查询函数 把数据查询出来发送到前台 然后前台显示, 但是最近做一个网站 情况是这样的 最初版 和以前一样 一个查询 把 主页很多...
  • 模块化与组件化–多模块区分编译 示例地址:https://github.com/JackyAndroid/Android-Architecture-Fairy/tree/master/multi-variants-library Android-Architecture-Fairy开源项目重点分析主流技术与架构设计,...
  • Javascript前端模块化

    千次阅读 2016-06-30 08:15:36
    随着网站逐渐变成"互联网应用程序",嵌入网页的Javascript代码越来越...Javascript模块化编程,已经成为一个迫切的需求。理想情况下,开发者只需要实现核心的业务逻辑,其他都可以加载别人已经写好的模块。 但是,Ja
  • WebPack模块化开发

    千次阅读 2016-10-10 18:16:46
    p.jsmodule.exports.print = function(){ console.log("print in p.js"); } module.exports.test = function(args0){ console.log("agrs0 = " + args0); return args0 + 1; ...module.exports.print = fu
  • CSS模块化开发

    千次阅读 2011-06-15 07:27:00
    模块化开发,对于程序员来说已经是个恨熟悉的概念了,在php、jsp、c#等语言中,对于模块化开发都是相当的熟悉了,然而css模块化开发想必很多人还是第一次听到,不错,在如今复杂的web项目中,css是不可缺少的部分,...
  • OSGi模块化框架详解

    万次阅读 2018-04-20 09:54:23
    OSGi模块化框架是很早就出来的一个插件化框架,最早Eclipse用它而出名,但这些年也没有大热虽然OSGi已经发布了版本1到版本5。现在用的最多的,也是本文讲述基于的是Equinox的OSGi实现,同时也是Eclipse核心,Spring ...
  • 转自:http://blog.novanet.no/4-strategies-for-passing-parameters-to-requirejs-modules/转自:http://javascript.ruanyifeng.com/tool/requirejs.html入口:main1.jsrequire.config({ baseUrl : 'js', paths : {...
  • 前端模块化

    千次阅读 2019-12-12 16:23:14
    前端模块化 JavaScript**原始功能** 1. 在网页开发的早期,js制作作为一种脚本语言,做一些简单的表单验证或动画实现等,那个时候代码还是很少的 那个时候的代码是怎么写的呢?直接将代码写在<script>标签...
  • iOS应用组件化/模块化探究

    千次阅读 2019-01-09 14:48:35
    组件是近几年流行起的概念,它是当代码扩张到一定程度时,所采取的一种代码组织架构策略。淘宝、蘑菇街等大厂也在近几年陆续完成了其代码组件的过程。 提到组件,给人的感觉似乎很高大上,很神秘的感觉。但是...
  • 什么是模块化模块化的好处是

    千次阅读 2019-07-15 20:25:43
    什么是模块化模块化的好处是? 模块化是一种处理复杂系统分解为更好的可管理模块的方式。 所谓的模块化开发就是封装细节,提供使用接口,彼此之间互不影响,每个模块都是实现某一特定的功能。模块化开发的基础...
  • 什么是模块化模块化的好处

    千次阅读 2019-07-15 21:16:37
    什么是模块化 简单地说,模块化就是有组织地把一个大文件拆成独立并互相依赖的多个小模块。 模块内部有许多私有属性,只向外暴露一部分公开的接口(如可以修改私有属性的方法等) 模块化是一种处理复杂系统分解为更好...
  • 移动App模块化设计

    千次阅读 2018-12-18 17:02:13
    一般按照界面划分模块后,同属该模块的业务层和UI层都放在同一目录下(还可以有子目录)。一个模块不会被层次限死,最多三层都可以跨越。 基础层 这层的目录命名有叫base或foundation的,如果设计得好,这部分东西是...
  • 模块化系统开发 一

    千次阅读 热门讨论 2013-10-05 11:44:02
    系统做灵活,必须“分而治之”,划分常用的模块,或者可以做灵活的模块,各个击破。只要模块都做灵活了,再用某些方式把这些灵活的模块进行组装,就可以实现系统的灵活配置,后整理成架构,有助于快速开发。
  • CSS模块化(六) 模块化设计

    千次阅读 2014-03-25 10:49:54
    6. 模块化设计 6.1 样式的作用域──页面重构中的模块化设计(一) 模块化设计我已经提过很多了,都是跟模块化相关的,不过之前一直没有讲到具体实现方面的内容,只是一些思维。这次重点讲一下实现方面的内容,权...
  • 很多编程能力比较强的人在编程过程中都会用到模块化编程的思想,但我每次编程的时候总是想到哪编到哪,不懂得如何进行模块化编程,程序如果思路比较简单还好,当程序比较复杂的时候就不知道怎么编写了,编着编着就会...
  • Servlet3.0模块化支持

    千次阅读 2017-06-27 12:29:39
    le示例支持Servlet3.0模块化支持 Servlet3.0现在已经支持各Web组件的模块化了。也就是说现在我们可以把各Web组件单独拿出来进行开发,之后把它们打成对应的jar包放到主项目中就可以了,而不必像之前那样——所有的...
  • 快速理解 JS 模块化

    千次阅读 2018-05-30 23:30:02
    JS 模块化是一个集特殊功能的 JS 文件,将所有的数据和功能封装在一个函数内部(私有的),只向外暴露一个包含 N 个方法的对象或函数,模块使用者,只需要通过模块暴露的对象调用方法来实现对应的功能。 参与本话题...
  • 测试用例的模块化

    千次阅读 2011-01-07 23:48:00
    所以今天就想起了测试用例模块化的问题,是不是真的就可以尝试使用测试用例的模块化划分呢?我觉得这个其实是可行的,尤其是在产品线脚多的公司,各个小组之间可能平常很少去沟通和讨论测试用例的具体设计细节部分,...

空空如也

1 2 3 4 5 ... 20
收藏数 123,587
精华内容 49,434
关键字:

模块化