Spring概述：

Spring框架是由世界著名的Java EE大师罗德·约翰逊发明的，起初是为解决经典企业级Java EE开发中的臃肿、低效和复杂性而设计的，2004年发布Spring1.0正式版，之后引发了Java EE应用的轻量化革命。

他的主要优势之一是采用分层架构，整个框架由7个定义良好的模块构成，它们统一构建于核心容器之上，分层架构允许用户选择使用任何一个模块。

组成Spring框架的每个模块都可以单独存在，也可以与其它一个或多个模块联合起来使用。各个模块的功能如下。

Spring Core：核心容器提供Spring框架的基本功能，其主要组件BeanFactory是工厂模式的实现。他通过控制反转（IOC）机制，将应用程序配置和依赖性规范与实际的程序代码分离开。
Spring Context：向Spring框架提供上下文信息，包括企业服务，如JNDI、EJB、电子邮件、国际化、校验和调度等。
Spring AOP：直接将AOP（面向方面编程）功能集成到Spring框架中，通过配置管理特性，可以很容易地使Spring框架管理的任何对象支持AOP。它为基于Spring应用程序的对象提供了事务管理服务。通过它，不依赖EJB就可以将声明性事务管理集成到应用程序中。
Spring DAO：JDBC DAO抽象层提供了有用的异常层次结构，用来管理异常处理和不同数据库供应商跑出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（如打开和关闭连接）。Spring DAO的面向JDBC的异常也符合通用的DAO异常层次结构。
Spring ORM：Spring框架插入了软肝ORM框架，提供ORM的对象关系工具，其中包括JDO、Hibernate和iBatis SQL Map，并且都遵从Spring的通用事务和DAO异常层次结构。
Spring Web：为基于Web的应用程序提供上下文。它建立在应用程序上下文模块之上，支持Jakarta Struts的集成，还简化了处理多份请求及将请求参数绑定到域对象的工作。
Spring Web MVC：一个全功能构建Web应用程序的MVC实现，通过策略接口实现高度可配置，容纳了大量视图技术，包括JSP、Velocity、Tiles、IText和POI。

什么是模块？

node.js 中所谓的程序实际上就是外部js文件
每一个js的文件往往具有一个独立的功能，也就是 一个模块

当一个外部js文件需要执行某个功能模块时,不需要重复定义程序代码，只需要导入已经定义好的 js模块程序即可
模块化开发,就是为了提高程序的执行效率,优化代码
需要实现模块化开发,就必须要读取外部文件和外部文件的内容

而且还需要写入当前文件中

为什么要进行模块化
模块化的特点

方便代码管理、项目维护
有助于分工协同开发
模块和模块之间不会出现变量"污染"，一个模块就是一个作用域。
模块化可以做到职责分离，每个模块实现一个独立的功能
面向对象编程

面向对象编程的5大原则：

开放封闭原则
里氏替换原则
依赖倒置原则
单一职责原则
接口隔离原则

在Node.js中的模块主要分为：核心模块 和 文件模块
核心模块
http、fs、path、url、net、os、readline、…

核心模块在Node.js自身源码编译时，已经编译成二进制文件

部分核心模块在Node.js进程启动的时候已经默认加载到缓存里面了
文件模块(包含独立文件模块和第三方模块)
文件模块可以是：.js 模块、.node模块、*.json模块，这些都是文件模块

无论从npm上下载的第三方模块还是我们自己编写的模块都是文件模块
module.exports 和 exports
在每个模块中module表示当前模块对象, 里面保存了当前模块对象的各种信息

module.exports 其实就是 require()加载模块时的返回值

exports 就是module.exports的一个引用

module.exports 与exports指向同一对象 ，即module.exports === exports

若exports和 module.exports在模块中同时存在，module.exports会覆盖掉exports导出的内容。

特别注意：最终暴露给require的返回值的是：module.exports, 而不是exports
先定义一个模块test.js
const a = 'heollo';
exports.c = 1;
module.exports = a;

在入口模块app.js引入，并打印module
const test = require('./test');
console.log(module);

require 加载模块时做了2件事

执行了模块中的代码

返回了模块中对外暴露的内容（可能是对象、函数等等）
module是一个对象里面有7个属性：

id：.表示当前文件，子模块的id默认为其绝对路径
exports：模块向外导出的对象
parent：父级调用的module对象，如果为null则该文件没有被调用
filename：当前文件名
loaded：是否被加载（判断该模块是否被其他模块所加载）
children：当前模块所引入的所有子模块，类型为数组，每个子模块也为一个module对象
path：node_modules 模块的查找路径，一直查到根目录

意义
require 加载模块顺序
看 require() 加载模块时传入的参数是否以 ‘./’ 或 ‘…/’ 或 ‘/’ 等等这样的路径方式开头（相对路径或绝对路径都可以）

如果是，那么会按照传入的路径直接去查询对应的模块。

判断传入的是否为具体的文件名

require(’./test.js’) 是具体的文件名

直接根据给定的路径去加载模块，找到了加载成功，找不到加载失败

require(’./test’); 不是具体的文件名、

第一步：根据给定的路径，依次添加文件后缀 .js、.json、.node进行匹配，如果找不到匹配执行第二步
第二步：查找是否有 test 目录（尝试找 test 包）

找不到：加载失败

找到了：依次在 test 目录下查找 package.json 文件（找到该文件后尝试找 main 字段中的入口文件）、index.js、index.json、index.node，找不到则加载失败

如果不是，那么就认为传入的是 “模块名称”（比如：require(‘http’)、require(‘mime’)）

是核心模块：直接加载核心模块

不是核心模块

依次递归查找 node_modules 目录中是否有相应的包

从当前目录开始，依次递归查找所有父目录下的 node_modules 目录中是否包含相应的包

如果查找完毕磁盘根目录依然没有则加载失败

打印输入 module.paths 查看
// require('http')
// require('mime')
// 情况一：require() 的参数是一个路径
require('./index2.js')
// index2.js
// index2.json
// index2.node
// index2 文件夹 -> package.json -> main(入口文件 app.js -> index.js/index.json/index.node) -> 加载失败
require('ndex2')
// 情况二： require() 的参数不是路径，直接就是一个模块名称
// 1. 先在核心模块中查找，是否有和给定的名字一样的模块。如果有，则直接加载该核心模块。
// require('http')
// 2. 如果核心模块中没有该模块那么就会认为这个模块是一个第三方模块（自定义模块）
// 先会去当前js文件所在的目录下去找是否一个一个 node_modules 文件夹
// require('mime')

require 加载模块注意点

所有模块第一次加载完毕后都会有 缓存，二次加载直接读取缓存，避免了二次开销	

因为有 缓存，所以模块中的代码只在第一次加载的时候执行一次
每次加载模块的时候都优先从缓存中加载，缓存中没有的情况下才会按照 node.js 加载模块的规则去查找
核心模块在 Node.js 源码编译的时候，都已经编译为二进制执行文件，所以加载速度较快（核心模块加载的优先级仅次于 缓存加载）
核心模块都保存在 lib 目录下
试图加载一个和 核心模块 同名的 自定义模块（第三方模块）是不会成功的

自定义模块要么名字不要与核心模块同名
要么使用路径的方式加载


核心模块 只能通过 模块名称 来加载（错误示例：require(’./http’); 这样是无法加载 核心模块 http的 ）
require() 加载模块使用 ./ 相对路径时，相对路径是相对当前模块，不受执行 node 命令的路径影响
建议加载文件模块的时候始终添加文件后缀名，不要省略

模块化



什么是模块？

每个.js文件就是一个模块
从npm上下载的一个包（可能是由多个文件组成的一个实现特定功能的包）也是一个模块
任何文件或目录只要可以被Node.js通过require()函数加载的都是模块
每个模块就是一个独立的作用域，模块和模块之间不会互相”污染”
- 我们可以通过编程的方式，指定某个模块要对外暴露的内容（其实就是指定require的返回值，通过require的返回值对外暴露指定内容）。这个对外暴露内容的过程也叫”导出” module.exports



什么是包？

通过package.json描述的一个文件或目录（可以理解成一个实现某个功能的1个文件或多个文件，通过package.json组织起来）
包不一定能被Node.js通过require()来加载，那么就不就叫模块。比如有些包中没有设置启动文件（package.json中的main字段），就不是模块。
参考链接：https://docs.npmjs.com/how-npm-works/packages



在Node.js中模主要分为：核心模块 和 文件模块



核心模块

http、fs、path、url、net、os、readline、……
核心模块在Node.js自身源码编译时，已经编译成二进制文件
部分核心模块在Node.js进程启动的时候已经默认加载到缓存里面了
文件模块

文件模块可以是：.js 模块、.node模块、*.json模块，这些都是文件模块
无论从npm上下载的第三方模块还是我们自己编写的模块都是文件模块
模块化的好处

模块和模块之间不会出现变量”污染”，一个模块就是一个作用域。
模块化开发效率高、可维护性好
模块化可以做到职责分离，每个模块实现一个独立的功能
模块加载



无论是核心模块还是文件模块加载都是采用require('标识符')来



核心模块的加载速度是最快的



无论是 核心模块 还是 文件模块，加载过一次后都会缓存起来，第二次加载（第二次require）的时候直接从缓存中读取即可。所以模块中的代码只在第一次加载的时候执行一次，这点要注意。



核心模块只能通过 “模块名称” 来加载，例如：require('模块名称')



文件模块可以通过 require 指定路径的方式来加载（路径可以是文件路径 或 目录）

require('./a/b.js') 通过指定相对路径来加载模块
require('/a/b.js') 或 require('c:\a\b.js') 通过指定绝对路径来加载
注意：require('')加载模块的时候，相对路径永远相对于当前模块，不受node命令执行的路径影响。
通过路径的方式加载文件模块时，文件的后缀可有可无

省略后缀名后，Node.js默认会以：.js、.node、.json的顺序来加载（依次拼接不同的后缀，查找并尝试加载）。
建议：始终加上后缀。
npm下载的第三方模块加载



也是通过 require(‘模块名称’) 来加载的



第三方模块名称绝对不能与 核心模块重名，否则永远加载的都是核心模块



require(‘模块名称’) 加载非核心模块的过程

通过 console.log(module.paths); 来查看
require 加载模块时做了2件事

执行了模块中的代码
返回了模块中对外暴露的内容（可能是对象、函数等等）
module.exports 和 exports



在每个模块中module表示当前模块对象, 里面保存了当前模块对象的各种信息



module.exports 其实就是 require()加载模块时的返回值



exports 就是module.exports的一个引用



exports = module.exports;



特别注意：最终暴露给require的返回值的是：module.exports, 而不是exports

“`javascript 

  // To illustrate（说明） the behavior, imagine this hypothetical implementation of require(), which is quite similar to what is actually done by require():

function require(…) { 

  var module = { exports: {} };

((module, exports) => { 

    // Your module code here. In this example, define a function. 

    function some_func() {}; 

    exports = some_func; 

    // At this point, exports is no longer a shortcut to module.exports, and 

    // this module will still export an empty default object. 

    module.exports = some_func; 

    // At this point, the module will now export some_func, instead of the 

    // default object. 

  })(module, module.exports);

return module.exports; 

} 

  “`



下载Node.js源码，打开看下



JavaScript 的严格模式—— "use strict"; 或 'use strict';

参考链接： 
http://www.ruanyifeng.com/blog/2013/01/javascript_strict_mode.html
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Strict_mode

什么是模块？

每个.js文件就是一个模块
从npm上下载的一个包（可能是由多个文件组成的一个实现特定功能的包）也是一个模块
任何文件或目录只要可以被Node.js通过require()函数加载的都是模块
每个模块就是一个独立的作用域，模块和模块之间不会互相"污染"
我们可以通过编程的方式，指定某个模块要对外暴露的内容（其实就是指定require的返回值，通过require的返回值对外暴露指定内容）。这个对外暴露内容的过程也叫"导出" module.exports

为什么要进行模块化

方便代码管理、项目维护
有助于分工协同开发
模块和模块之间不会出现变量"污染"，一个模块就是一个作用域。
模块化可以做到职责分离，每个模块实现一个独立的功能

补充：面向对象编程的5（6）大原则：

开放封闭原则
里氏替换原则
依赖倒置原则
单一职责原则
接口隔离原则

什么是包？

通过package.json描述的一个文件或目录（可以理解成一个实现某个功能的1个文件或多个文件，通过package.json组织起来）
包不一定能被Node.js通过require()来加载，那么就不就叫模块。比如有些包中没有设置启动文件（package.json中的main字段），就不是模块。
package 和 module 参考链接

在Node.js中模主要分为：核心模块 和 文件模块
核心模块

http、fs、path、url、net、os、readline、…
核心模块在Node.js自身源码编译时，已经编译成二进制文件
部分核心模块在Node.js进程启动的时候已经默认加载到缓存里面了

文件模块(包含独立文件模块和第三方模块)

文件模块可以是：.js 模块、.node模块、*.json模块，这些都是文件模块
无论从npm上下载的第三方模块还是我们自己编写的模块都是文件模块

module.exports 和 exports
在每个模块中module表示当前模块对象, 里面保存了当前模块对象的各种信息
module.exports 其实就是 require()加载模块时的返回值
exports 就是module.exports的一个引用
exports = module.exports;

特别注意：最终暴露给require的返回值的是：module.exports, 而不是exports
 // To illustrate（说明） the behavior, imagine this hypothetical implementation of require(), which is quite similar to what is actually done by require():

 function require(...) {
 var module = { exports: {} };


 ((module, exports) => {
   // Your module code here. In this example, define a function.
   function some_func() {};
   exports = some_func;
   // At this point, exports is no longer a shortcut to module.exports, and
   // this module will still export an empty default object.
   module.exports = some_func;
   // At this point, the module will now export some_func, instead of the
   // default object.
 })(module, module.exports);

 
 return module.exports;
}

require 加载模块时做了2件事

执行了模块中的代码
返回了模块中对外暴露的内容（可能是对象、函数等等）

下载Node.js源码，打开看下
JavaScript 的严格模式—— "use strict"; 或 'use strict';

参考链接：

http://www.ruanyifeng.com/blog/2013/01/javascript_strict_mode.html
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Strict_mode