web概述-前端发展简史

前端发展简史

起源

1990 HTML 草创

1990 年，Tim Berners Lee 以超文本语言 HTML 为基础在 NeXT 电脑上发明了最原始的 Web 浏览器（“WorldWideWeb.app”）后来改名为Nexus,同时发明了第一个web服务器（“httpd“字样）。截至1990年底，第一个网页投放在开放的互联网上。

1991 HTML1.0规范发布

HTML 1.0首次亮相为SGML的混合体，其中包括“href”标签，将已经被广泛接受的文本标记语言与链接文档的能力结合起来。
•原始版本仅包含20个元素，其中13个元素仍然是HTML 4.01的一部分。

1991年8月6日，Tim Berners Lee在alt.hypertext新闻组贴出了一份关于World Wide Web的简单摘要: “WorldWideWeb（WWW）项目旨在允许在任何地方对任何信息进行全部链接。[…] WWW项目开始允许高能物理学家共享数据，新闻和文档。 我们非常有兴趣将网络传播到其他领域，并为其他数据提供网关服务器。 合作者欢迎！“
这标志了Web页面在Internet上的首次登场。最早Web主要被一帮科学家们用来共享和传递信息，全世界的Web服务器也就几十台。

与此同时，美国国家超算应用中心（National Center for Supercomputer Applications）对此表现出了浓厚的兴趣，并开发了名为 Mosaic 的浏览器，于 1993 年 4 月进行了发布。Mosaic 使得web开始流行起来，这便是曾经大名鼎鼎的Netscape Navigator的前身。

1993年 Tim Berners Lee建立了万维网联盟（World Wide Web Consortium，W3C），负责Web相关标准的制定。浏览器的普及和W3C的推动，使得Web上可以访问的资源逐渐丰富起来。这个时候Web的主要功能就是浏览器向服务器请求静态HTML信息。95年的时候马云在美国看到了互联网，更准确的说他其实看到的就是Web，阿里早先做的黄页也就是把企业信息通过进行HTML展示的Web应用。

1994 年 5 月，第一届万维网大会在日内瓦召开。

1994.7 HTML 2.0 规范发布

HTML 2.0成为HTML的第一套官方标准 – 所有浏览器的测试基础标准，直到HTML 3.2。
•在Web爆炸期间，HTML 2.0被用作基准。
•1993年发布的其他浏览器包括Cello，Arena，Lynx，tkWWW和Mosaic。
•后来更名为Netscape Communications的Mosaic Communications根据美国国家超级计算应用中心（NCSA）Mosaic浏览器发布了Netscape，该浏览器是第一款带图形界面的商业网页浏览器。
• 亮点：根据Wired的Gary Wolfe的说法，Mosaic “正在成为世界标准界面 。”

1994 年 9 月，因特网工程任务组（Internet Engineering Task Force）设立了 HTML 工作组。

1994 年 11 月，Mosaic 浏览器的开发人员创建了网景公司（Netscape Communications Corp.），并发布了 Mosaic Netscape 1.0 beta 浏览器，后改名为 Navigator。

1994 万维网联盟（World Wide Web Consortium）成立，简称 W3C

1994 年底，由Tim Berners Lee 牵头的万维网联盟（World Wide Web Consortium）成立，这标志着万维网的正式诞生。

此时的网页以 HTML 为主，是纯静态的网页，网页是“只读”的，信息流只能通过服务器到客户端单向流通，由此世界进入了 Web 1.0 时代。

1995 网景推出 JavaScript

1995 年，网景工程师 Brendan Eich 花了10天时间设计了 JavaScript 语言。起初这种脚本语言叫做 Mocha，后改名 LiveScript，后来为了借助 Java 语言创造良好的营销效果最终改名为 JavaScript。网景公司把这种脚本语言嵌入到了 Navigator 2.0 之中，使其能在浏览器中运行。

与此相对的是，1996 年，微软发布了 VBScript 和 JScript。JScript 是对 JavaScript 进行逆向工程的实现，并内置于 Internet Explorer 3 中。但是 JavaScript 与 JScript 两种语言的实现存在差别，这导致了程序员开发的网页不能同时兼容 Navigator 和 Internet Explorer 浏览器。 Internet Explorer 开始抢夺 Netscape 的市场份额，这导致了第一次浏览器战争。

1996年

•HTML现在支持表格，可以更好地控制表格信息的显示
•HTML还支持“客户端图像映射”文档元素，该元素允许单击图像的不同区域以引用不同的网络资源，如统一标识符（URI）所指定的。
•第一个CSS规范成为官方的W3C推荐标准，虽然已经完成，但是在任何Web浏览器达到接近完全规范的实现之前已经超过3年。
• 亮点： IE 3.0发布的功能等同于Netscape，它提供了脚本支持和市场上的第一个商业CSS实现。

第一次浏览器战争

1996 年 11 月，为了确保 JavaScript 的市场领导地位，网景将 JavaScript 提交到欧洲计算机制造商协会（European Computer Manufacturers Association）以便将其进行国际标准化。

1996.12 W3C 推出了 CSS 1.0 规范

1997年
•经过研究人员的激烈争论，研究人员认为文本属性（如背景颜色和纹理，字体大小和字体）正在将HTML从根部移开，以便组织而不是修饰文档以供共享; 并且在IE和Netscape之间的浏览器战争中，HTML 3.2（代码名称WILBUR）被批准。
•获得批准的让步包括Internet Explorer阵营和Netscape阵营同意杀死他们专有的<marquee>和<blink>属性，这些属性负责我们知道并讨厌的引人注目，闪烁的文本。
•这是网页中广泛过度使用帧的时间，这是互联网上最糟糕的失误之一，仅次于自动播放midi文件。
• 突出显示：已集成到Microsoft Windows中的IE 4.0版本不鼓励用户使用竞争的浏览器，因为默认情况下IE是在那里。

1997.1 HTML3.2 作为 W3C 推荐标准发布
1997.6 ECMA 以 JavaScript 语言为基础制定了 ECMAScript 1.0 标准规范

1997 年 6 月，ECMA 以 JavaScript 语言为基础制定了 ECMAScript 标准规范 ECMA-262。JavaScript 是 ECMAScript 规范最著名的实现之一，除此之外，ActionScript 和 JScript 也都是 ECMAScript 规范的实现语言。自此，浏览器厂商都开始逐步实现 ECMAScript 规范。

1998年
•Cougar是成为HTML 4.0的代码名称，在1997年底发布为推荐，最终被批准为HTML 4.01。
•此版本包含层叠样式表（CSS），这是控制表示元素（如颜色，字体和背景）的更简单方法。 (对啊，简单来说 CSS1.0 是 table td布局，CSS2.0 是div li布局，学校里压根都没有提到 )
• 亮点： Netscape在“浏览器战争”中被击败，被美国在线以42亿美元收购。

1997.12 HTML 4.0 规范发布
1998 W3C 推出了 CSS 2.0 规范
1998.6 ECMAScript 2 规范发布

1998 年 6 月，ECMAScript 2 规范发布，并通过 ISO 生成了正式的国际标准 ISO/IEC 16262 。

1999.12 ECMAScript 3 规范发布

1999 年 12 月，ECMAScript 3 规范发布，在此后的十年间，ECMAScript 规范基本没有发生变动。ECMAScript 3 成为当今主流浏览器最广泛使用和实现的语言规范基础。

第一次浏览器战争以 IE 浏览器完胜 Netscape 而结束，IE 开始统领浏览器市场，份额的最高峰达到 2002 年的 96%。随着第一轮大战的结束，浏览器的创新也随之减少。

2000
•HTML和XML联手成为XHTML，挑选严格的XML代码结构来执行更清晰的代码，但由于它不向后兼容，因此需要重写代码。
尽管XML是标准的，但大多数浏览器原谅了这一点，并且仍然允许使用潦草的代码，大写代码和不正确的封闭标签，以致难以广泛采用更严格的XML代码。
•问：为什么XHTML鸟无效？答：因为它没有正确嵌套。
• 突出显示： IE是占主导地位的浏览器，在2002年达到网络浏览器使用份额的约96％的峰值，超过Netscape的高峰。

XHTML

1999 W3C 发布 HTML 4.01 标准，同年微软推出用于异步数据传输的 ActiveX，随即各大浏览器厂商模仿实现了 XMLHttpRequest（AJAX 雏形）。
2000: W3C 采用了一个大胆的计划，把 XML 引入 HTML，XHTML1.0 作为 W3C 推荐标准发布
2001.5 W3C 推出了 CSS 3.0 规范草案
2002-2006 XHTML 2.0 最终放弃
2009 W3C 宣布 XHTML2.0 不再继续，宣告死亡

2002年
•许多人对杂乱的编码实践表（table布局）示批评，（div布局）无表设计的想法开始增长。
•术语“无表设计”意味着使用CSS而不是布局表来定位页面上的HTML元素。
•在网页中显示表格信息时，HTML表格仍然有其合法的位置。
•这也是分享和交换特别内容（如Weblogs和RSS）的新想法迅速获得采用并被命名为“Web 2.0”的时候。
• 亮点：第一次浏览器大战结束，IE浏览器没有对其市场份额进行严重的竞争 – 这为Web浏览器的快速创新带来了一段时间。

（

web1.0：网络-人（单向信息，只读，eg个人网站，大英百科全书）；
web2.0：人-人（以网络为沟通渠道进行人与人沟通，eg维基、博客）；
web3.0：人-网络-人（人工智能、关联数据和语义网络构建，形成人和网络以及网络与人的沟通，同时在SEO支持下，提高人与人沟通的便利性）

我对三者的区别在于三个时期中网络的角色——web1.0网络是信息提供者，单向性的提供和单一性理解；web2.0网络是平台，用户提供信息，通过网络，其他用户获取信息；web3.0网络成为用户需求理解者和提供者，网络对用户了如指掌，知道用户有什么、要什么以及行为习惯，进行资源筛选、智能匹配，直接给用户答案。

）

动态页面的崛起

JavaScript 诞生之后，可以用来更改前端 DOM 的样式，实现一些类似于时钟之类的小功能。那时候的JavaScript 仅限于此，大部分的前端界面还很简单，显示的都是纯静态的文本和图片。这种静态页面不能读取后台数据库中的数据，为了使得 Web 更加充满活力，以 PHP、JSP、ASP.NET 为代表的动态页面技术相继诞生。

PHP（PHP：Hypertext Preprocessor）最初是由 Rasmus Lerdorf 在 1995 年开始开发的，现在PHP 的标准由 PHP Group 维护。PHP 是一种开源的通用计算机脚本语言，尤其适用于网络开发并可嵌入 HTML 中使用。PHP 的语法借鉴吸收 C 语言、Java 和 Perl 等流行计算机语言的特点，易于一般程序员学习。PHP 的主要目标是允许网络开发人员快速编写动态页面。

JSP（JavaServer Pages）是由 Sun 公司倡导和许多公司参与共同创建的一种使软件开发者可以响应客户端请求，从而动态生成 HTML、XML 或其他格式文档的 Web 网页的技术标准。JSP 技术是以 Java 语言为基础的。1999 年，JSP 1.2 规范随着 J2EE 1.2 发布。

ASP（Active Server Pages）1.0 在 1996 年随着 IIS 3.0 而发布。2002 年，ASP.NET 发布，用于替代 ASP。

随着这些动态服务器页面技术的出现，页面不再是静止的，页面可以获取服务器数据信息并不断更新。以 Google 为代表的搜索引擎以及各种论坛相继出现，使得 Web 充满了活力。

随着动态页面技术的不断发展，后台代码变得庞大臃肿，后端逻辑也越来越复杂，逐渐难以维护。此时，后端的各种 MVC 框架逐渐发展起来，以 JSP 为例，Struct、Spring 等框架层出不穷。

从 Web 诞生至 2005 年，一直处于后端重、前端轻的状态。

2005年
•Ajax是一种可追溯到IE 4的iFrame的技术，它使网页更快地请求和更新动态页面内容，以响应像桌面应用程序，如Rackspace Email和Gmail等云应用程序以及社交媒体网站Digg，Facebook和Twitter; 和在线内容管理系统（CMS），如WordPress。
•2005年，Adaptive Path使用Ajax作为与客户谈论Asynchronous JavaScript + CSS + DOM + XMLHttpRequest的更简单方法
• 突出显示：浏览器大战再次启动，Mozilla在2004年发布Firefox 1.0; 从那以后，Firefox继续获得越来越多的浏览器市场份额。

AJAX 的流行

在 Web 最初发展的阶段，前端页面要想获取后台信息需要刷新整个页面，这是很糟糕的用户体验。

Google 分别在 2004 年和 2005 年先后发布了两款重量级的 Web 产品：Gmail 和 Google Map。这两款 Web 产品都大量使用了 AJAX 技术，不需要刷新页面就可以使得前端与服务器进行网络通信，这虽然在当今看来是理所应当的，但是在十几年前AJAX却是一项革命性的技术，颠覆了用户体验。

随着 AJAX 的流行，越来越多的网站使用 AJAX 动态获取数据，这使得动态网页内容变成可能，像 Facebook 这样的社交网络开始变得繁荣起来，前端一时间呈现出了欣欣向荣的局面。

AJAX 使得浏览器客户端可以更方便地向服务器发送数据信息，这促进了 Web 2.0 的发展。

Google Trend: AJAX 从 2005 年开始得到开发人员的广泛关注。

2006 XMLHttpRequest 被 W3C 正式纳入标准。

第二次浏览器大战

前端兼容性框架的出现

IE 在第一次浏览器大战中击败 Netscape 赢得胜利，垄断了浏览器市场。作为独裁者，IE 并不遵循 W3C 的标准，IE 成了事实标准。

Netscape 于 1998 年被 AOL 收购前创建了 Mozilla 社区，Firefox 于 2004 年 11 月首次发布，并且 9 个月内下载量超过 6000 万，获取了巨大的成功，IE 的主导地位首次受到了挑战， Firefox 被认为是 Netscape 的精神续作。

之后 Firefox 浏览器一路奋起直追，逐渐蚕食 IE 市场份额，这引发了第二次浏览器战争。在 2008 年底时，Firefox 的市场份额达到了 25% 以上，IE 则跌至 65% 以下。

第二次浏览器战争中，随着以 Firefox 和 Opera 为首的 W3C 阵营与 IE 对抗程度的加剧，浏览器碎片化问题越来越严重，不同的浏览器执行不同的标准，对于开发人员来说这是一个恶梦。

为了解决浏览器兼容性问题，Dojo、jQuery、YUI、ExtJS、MooTools 等前端 Framework 相继诞生。前端开发人员用这些 Framework 频繁发送 AJAX 请求到后台，在得到数据后，再用这些 Framework 更新 DOM 树。

其中，jQuery 独领风骚，几乎成了所有网站的标配。Dojo、YUI、ExtJS 等提供了很多组件，这使得开发复杂的企业级 Web 应用成为可能。

Google Trend: 蓝色 jQuery，红色 Dojo，绿色 YUI，紫色 ExtJS，黄色 MooTools

HTML 5

1999年，W3C发布了 HTML 4.01 版本，在之后的几年，没有再发布更新的 Web 标准。随着Web的迅猛发展，旧的Web标准已不能满足 Web 应用的快速增长。

2004 年 6 月，Mozilla 基金会和 Opera 软件公司在万维网联盟（W3C）所主办的研讨会上提出了一份联合建议书，其中包括 Web Forms 2.0 的初步规范草案。建议举行一次投票，以表决 W3C 是否应该扩展 HTML 和 DOM，从而满足 Web 应用中的新需求。研讨会最后以 8 票赞成，14 票反对否决此建议，这引起一些人的不满，不久后，部分浏览器厂商宣布成立网页超文本技术工作小组（WHATWG），以继续推动该规范的开发工作，该组织再度提出 Web Applications 1.0 规范草案，后来这两种规范合并形成 HTML5。2007 年，获得 W3C 接纳，并成立了新的 HTML 工作团队。2008 年 1 月 22 日，第一份正式草案发布。

2008年
•由于缺乏对XHTML中丰富Web应用程序的关注，Web超文本应用技术（WHAT）工作组于2004年与Apple，Mozilla和Opera成员形成了这个协议，并在四年后发布了第一份HTML5草案。
•到2009年，XHTML开发团队进行反汇编，加入HTML5阵营。
•至少2022年前，HTML5不会成为标准，但Firefox和IE9已经支持其某些功能。与大多数新版本的HTML一样，它的优势只会与其开发者和浏览器支持一样强大。
• 突出显示： Google发布适用于Windows的Chrome浏览器。 Chrome在09年10月份获得了3.6％的使用份额，并在Mac OS X和Linux测试版发布后迅速增长。

2008.12 Chrome 发布，JavaScript 引擎 V8

HTML5 草案发布不久，Google 在 2008 年 12 月发布了 Chrome 浏览器，加入了第二次浏览器大战当中。Chrome 使用了 Safari 开源的 WebKit 作为布局引擎，并且研发了高效的 JavaScript 引擎 V8。

尽管 HTML5 在网络开发人员中非常出名了，但是它成为主流媒体的一个话题是在 2010 年的 4 月，当时苹果公司的 CEO 乔布斯发表一篇题为“对 Flash 的思考”的文章，指出随着 HTML5 的发展，观看视频或其它内容时，Adobe Flash 将不再是必须的。这引发了开发人员间的争论，包括 HTML5 虽然提供了加强的功能，但开发人员必须考虑到不同浏览器对标准不同部分的支持程度的不同，以及 HTML5 和 Flash 间的功能差异。

2010
•2010年，史蒂夫乔布斯宣布苹果产品将不再支持Flash，原因包括其专有的代码和安全漏洞，并推动HTML5的音频和视频播放功能的发展成为众人关注的焦点。
•将Flash和HTML5结合为人们分享用户生成的视频提供了一个免费空间的YouTube在2005年推出后每天提供约20亿视频。
• 突出显示： StatCounter报告说，在统计单个浏览器版本时，Firefox 3.5是最流行的浏览器，IE 7和8其次。

在第二次浏览器大战中，各个浏览器厂商都以提升 JavaScript 运行效率和支持 HTML5 各种新特性为主要目标，促进了浏览器的良性竞争。在这一场战争中，Chrome 攻城略地，抢夺 IE 市场份额。2013 年，Chrome 超过 IE，成为市场份额最高的浏览器。2016 年，Chrome 占据了浏览器市场的半壁江山。

全球浏览器市场份额（2009-2017）

自 2008 年以来，浏览器中不断支持的 HTML5 新特性让开发者激动不已：WebWorker 可以让 JavaScript 运行在多线程中，WebSocket 可以实现前端与后台的双工通信，WebGL 可以创建 Web3D 网页游戏……

桌面浏览器对 HTML5 支持程度（2009-2017）

2009.12 ECMAScript 5.0 规范发布
2011.6 ECMAScript 5.1 规范发布
2012.10 微软发布 TypeScript 公开版

TypeScript 是一种由微软开发的自由和开源的编程语言。它是 JavaScript 的一个超集，而且本质上向这个语言添加了可选的静态类型和基于类的面向对象编程。

TypeScript 扩展了 JavaScript 的语法，所以任何现有的 JavaScript 程序可以不加改变的在 TypeScript 下工作。TypeScript 是为大型应用之开发而设计，而编译时它产生 JavaScript 以确保兼容性。

2013.6.19 TypeScript 0.9 正式版
2014.10.28 W3C 正式发布 HTML 5.0 推荐标准

2014 年 10 月 28 日，W3C 正式发布 HTML 5.0 推荐标准。

Node.js 的爆发

早在 1994 年，Netspace 就公布了其 Netspace Enterprise Server 中的一种服务器脚本实现，叫做 LiveWire，是最早的服务器端 JavaScript，甚至早于浏览器中的 JavaScript。对于这门图灵完备的语言，Netspace 很早就开始尝试将它用在后端。

微软在 1996 年发布的 IE 3.0 中内嵌了自己的 JScript语言，其兼容 JavaScript 语法。1997 年年初，微软在它的服务器 IIS 3.0 中也包含了 JScript，这就是我们在 ASP 中能使用的脚本语言。

1997 年，Netspace 为了用 Java 实现 JavaScript 而创建了 Rhino 项目，最终 Rhino 演变成一个基于 Java 实现的 JavaScript 引擎，由 Mozilla 维护并开源。Rhino 可以为 Java 应用程序提供脚本能力。2006 年 12 月，J2SE 6 将 Rhino 作为 Java 默认的脚本引擎。

SpiderMonkey 是 Mozilla 用 C/C++ 语言实现的一个 JavaScript 引擎，从 Firefox 3.5 开始作为 JavaScript 编译引擎，并被 CouchDB 等项目作为服务端脚本语言使用。

可以看到，JavaScript 最开始就能同时运行在前后端，但时在前后端的待遇却不尽相同。随着 Java、PHP、.Net 等服务器端技术的风靡，与前端浏览器中的 JavaScript 越来越流行相比，服务端 JavaScript 逐渐式微。

2008 年 Chrome 发布，其 JavaScript 引擎 V8 的高效执行引起了 Ryan Dahl 的注意。2009 年，Ryan 利用 Chrome 的 V8 引擎打造了基于事件循环的异步 I/O 框架 —— Node.js 诞生。

Node.js 具有以下特点：

基于事件循环的异步 I/O 框架，能够提高 I/O 吞吐量
单线程运行，能够避免了多线程变量同步的问题
使得 JavaScript 可以编写后台代码，前后端编程语言统一。

Node.js 的出现吸引了很多前端开发人员开始用 JavaScript 开发服务器代码，其异步编程风格也深受开发人员的喜爱。Node.js 的伟大不仅在于拓展了 JavaScript 在服务器端的无限可能，更重要的是它构建了一个庞大的生态系统。

2010 年 1 月，NPM 作为 Node.js 的包管理系统首次发布。开发人员可以按照 CommonJS 的规范编写 Node.js 模块，然后将其发布到 NPM 上面供其他开发人员使用。目前 NPM 具有 40 万左右的模块，是世界上最大的包模块管理系统。

2016 年常见包管理系统模块数量，NPM 高居榜首

Node.js 也催生了 node-webkit 等项目，用 JavaScript 开发跨平台的桌面软件也成为可能。Node.js 给开发人员带来了无穷的想象，JavaScript 大有一统天下的趋势。

前端 MV* 架构

随着 HTML5 的流行，前端不再是人们眼中的小玩意，以前在 C/S 中实现的桌面软件的功能逐步迁移到了前端，前端的代码逻辑逐渐变得复杂起来。

以前只用于后台的 MV* 等架构在前端逐渐使用起来，以下列举了部分常用的 MV* 框架。

随着这些 MV* 框架的出现，网页逐渐由 Web Site 演变成了 Web App，最终导致了复杂的单页应用（ Single Page Application）的出现。

移动 Web 和 Hybrid App

随着 iOS 和 Android 等智能手机的广泛使用，移动浏览器也逐步加强了对 HTML5 特性的支持力度。

移动浏览器对 HTML5 支持程度（2009-2017）

移动浏览器的发展，导致了流量入口逐渐从 PC 分流到移动平台，这是 Web 发展的新机遇。移动 Web 面临着更大的碎片化和兼容性问题，jQuery Mobile、Sencha Touch、Framework7、Ionic 等移动 Web 框架也随之出现。

相比于 Native App，移动 Web 开发成本低、跨平台、发布周期短的优势愈发明显，但是 Native App的性能和 UI 体验要远胜于移动 Web。移动 Web 与 Native App 孰优孰劣的争论愈演愈烈，在无数开发者的实践中，人们发现两者不是替代关系，而是应该将两者结合起来，取长补短，Hybrid 技术逐渐得到认同。

Hybrid 技术指的是利用 Web 开发技术，调用 Native 相关 API，实现移动与 Web 二者的有机结合，既能体现 Web 开发周期短的优势，又能为用户提供 Native 体验。

根据实现原理，Hybrid 技术可以分为两大类：

将 HTML 5 的代码放到 Native App 的 WebView 控件中运行，WebView 为 Web 提供宿主环境，JavaScript 代码通过 WebView 调用 Native API。典型代表有 PhoneGap(Cordova) 以及国内的 AppCan 等。
将 HTML 5 代码针对不同平台编译成不同的原生应用，实现了 Web 开发，Native 部署。这一类的典型代表有 Titanium 和 NativeScript。

Hybrid 一系列技术中很难找出一种方案适应所有应用场景，我们需要根据自身需求对不同技术进行筛选与整合。

ECMAScript 6

JavaScript 语言是 ECMAScript 标准的一种实现，截止 2017 年 2 月，ECMAScript 一共发布了 7 个版本。

1997 年 6 月， ECMAScript 1.0 标准发布。

1998 年 6 月，ECMAScript 2.0 发布。

1999 年 12 月，ECMAScript 3.0 发布。

2007 年 10 月，Mozilla 主张的 ECMAScript 4.0 版草案发布，对 3.0 版做了大幅升级，该草案遭到了以 Yahoo、Microsoft、Google 为首的大公司的强烈反对，JavaScript 语言的创造者 Brendan Eich 和 IE 架构师 Chris Wilson 甚至在博客上就ES4向后兼容性问题打起了口水仗，最后由于各方分歧太大，ECMA 开会决定废弃中止 ECMAScript 4.0 草案。经各方妥协，在保证向下兼容的情况下，将部分增强的功能放到 ECMAScript 3.1 标准中，将原有 ECMAScript 4.0 草案中激进的功能放到以后的标准中。不久，ECMAScript 3.1 就改名为 ECMAScript 5。

2009 年 12 月，本着’Don’t break the web’原则，ECMAScript 5 发布。新增了 strict 模式、属性 getter 和 setter 等。

2011 年 6 月，ECMAScript 5.1 发布。

2015 年 6 月，ECMAScript 6.0 发布。该版本增加了许多新的语法，包括支持 let、const、Arrow function、Class、Module、Promise、Iterator、Generator、Set、Map、async、Symbol、Proxy、Reflect、Decorator 等。TC39 委员会计划以后每年都发布一个新版本的 ECMAScript，所以 ECMAScript 6.0 改名为 ECMAScript 2015。

2016 年 6 月，在 ECMAScript 2015 的基础上进行了部分增强，发布了 ECMAScript 2016。

在 ECMAScript 的各个版本中，ECMAScript 6.0 无疑最受人瞩目的，它增加了许多新特性，极大拓展了 JavaScript 语法和能力，以至于许多浏览器都只能支持部分 ES6 中的新特性。随之，Babel 和 TypeScript 逐渐流行起来，编写 ES6 代码，然后用 Babel 或 TypeScript 将其编译为 ES5 等浏览器支持的 JavaScript。

ECMAScript 以后每年将会发布一个新版本，这无疑将持续促使浏览器厂商不断为 JavaScript 注入新的功能与特性，JavaScript走上了快速发展的正轨。

参考资料

java学习路线图(2)-java成神之路

针对本文，博主最近在写《成神之路系列文章》，分章分节介绍所有知识点。欢迎关注。

主要版本	更新时间	备注
v1.0	2015-08-01	首次发布
v1.1	2018-03-12	增加新技术知识、完善知识体系

一、基础篇

JVM

JVM内存结构

堆、栈、方法区、直接内存、堆和栈区别

Java内存模型

内存可见性、重排序、顺序一致性、volatile、锁、final

垃圾回收

内存分配策略、垃圾收集器（G1）、GC算法、GC参数、对象存活的判定

JVM参数及调优

Java对象模型

oop-klass、对象头

HotSpot

即时编译器、编译优化

类加载机制

classLoader、类加载过程、双亲委派（破坏双亲委派）、模块化（jboss modules、osgi、jigsaw）

虚拟机性能监控与故障处理工具

jps, jstack, jmap、jstat, jconsole, jinfo, jhat, javap, btrace、TProfiler

编译与反编译

javac 、javap 、jad 、CRF

Java基础知识

阅读源代码

String、Integer、Long、Enum、BigDecimal、ThreadLocal、ClassLoader & URLClassLoader、ArrayList & LinkedList、 HashMap & LinkedHashMap & TreeMap & CouncurrentHashMap、HashSet & LinkedHashSet & TreeSet

Java中各种变量类型

熟悉Java String的使用，熟悉String的各种函数

JDK 6和JDK 7中substring的原理及区别、

replaceFirst、replaceAll、replace区别、

String对“+”的重载、

String.valueOf和Integer.toString的区别、

字符串的不可变性

自动拆装箱

Integer的缓存机制

熟悉Java中各种关键字

transient、instanceof、volatile、synchronized、final、static、const 原理及用法。

集合类

常用集合类的使用、ArrayList和LinkedList和Vector的区别、SynchronizedList和Vector的区别、HashMap、HashTable、ConcurrentHashMap区别、Java 8中stream相关用法、apache集合处理工具类的使用、不同版本的JDK中HashMap的实现的区别以及原因

枚举

枚举的用法、枚举与单例、Enum类

Java IO&Java NIO，并学会使用

bio、nio和aio的区别、三种IO的用法与原理、netty

Java反射与javassist

反射与工厂模式、 java.lang.reflect.*

Java序列化

什么是序列化与反序列化、为什么序列化、序列化底层原理、序列化与单例模式、protobuf、为什么说序列化并不安全

注解

元注解、自定义注解、Java中常用注解使用、注解与反射的结合

JMS

什么是Java消息服务、JMS消息传送模型

JMX

java.lang.management.*、 javax.management.*

泛型

泛型与继承、类型擦除、泛型中K T V E ？ object等的含义、泛型各种用法

单元测试

junit、mock、mockito、内存数据库（h2）

正则表达式

java.lang.util.regex.*

常用的Java工具库

commons.lang, commons.*... guava-libraries netty

什么是API&SPI

异常

异常类型、正确处理异常、自定义异常

时间处理

时区、时令、Java中时间API

编码方式

解决乱码问题、常用编码方式

语法糖

Java中语法糖原理、解语法糖

Java并发编程

什么是线程，与进程的区别

阅读源代码，并学会使用

Thread、Runnable、Callable、ReentrantLock、ReentrantReadWriteLock、Atomic*、Semaphore、CountDownLatch、、ConcurrentHashMap、Executors

线程池

自己设计线程池、submit() 和 execute()

线程安全

死锁、死锁如何排查、Java线程调度、线程安全和内存模型的关系

锁

CAS、乐观锁与悲观锁、数据库相关锁机制、分布式锁、偏向锁、轻量级锁、重量级锁、monitor、锁优化、锁消除、锁粗化、自旋锁、可重入锁、阻塞锁、死锁

死锁

volatile

happens-before、编译器指令重排和CPU指令重

synchronized

synchronized是如何实现的？synchronized和lock之间关系、不使用synchronized如何实现一个线程安全的单例

sleep 和 wait

wait 和 notify

notify 和 notifyAll

ThreadLocal

写一个死锁的程序

写代码来解决生产者消费者问题

守护线程

守护线程和非守护线程的区别以及用法

二、进阶篇

Java底层知识

字节码、class文件格式

CPU缓存，L1，L2，L3和伪共享

尾递归

位运算

用位运算实现加、减、乘、除、取余

设计模式

了解23种设计模式

会使用常用设计模式

单例、策略、工厂、适配器、责任链。

实现AOP

实现IOC

不用synchronized和lock，实现线程安全的单例模式

nio和reactor设计模式

网络编程知识

tcp、udp、http、https等常用协议

三次握手与四次关闭、流量控制和拥塞控制、OSI七层模型、tcp粘包与拆包

http/1.0 http/1.1 http/2之前的区别

Java RMI，Socket，HttpClient

cookie 与 session

cookie被禁用，如何实现session

用Java写一个简单的静态文件的HTTP服务器

实现客户端缓存功能，支持返回304 实现可并发下载一个文件使用线程池处理客户端请求使用nio处理客户端请求支持简单的rewrite规则上述功能在实现的时候需要满足“开闭原则”

了解nginx和apache服务器的特性并搭建一个对应的服务器

用Java实现FTP、SMTP协议

进程间通讯的方式

什么是CDN？如果实现？

什么是DNS？

反向代理

框架知识

Servlet线程安全问题

Servlet中的filter和listener

Hibernate的缓存机制

Hiberate的懒加载

Spring Bean的初始化

Spring的AOP原理

自己实现Spring的IOC

Spring MVC

Spring Boot2.0

Spring Boot的starter原理，自己实现一个starter

Spring Security

应用服务器知识

JBoss

tomcat

jetty

Weblogic

工具

git & svn

maven & gradle

三、高级篇

新技术

Java 8

lambda表达式、Stream API、

Java 9

Jigsaw、Jshell、Reactive Streams

Java 10

局部变量类型推断、G1的并行Full GC、ThreadLocal握手机制

Spring 5

响应式编程

Spring Boot 2.0

性能优化

使用单例、使用Future模式、使用线程池、选择就绪、减少上下文切换、减少锁粒度、数据压缩、结果缓存

线上问题分析

dump获取

线程Dump、内存Dump、gc情况

dump分析

分析死锁、分析内存泄露

自己编写各种outofmemory，stackoverflow程序

HeapOutOfMemory、 Young OutOfMemory、MethodArea OutOfMemory、ConstantPool OutOfMemory、DirectMemory OutOfMemory、Stack OutOfMemory Stack OverFlow

常见问题解决思路

内存溢出、线程死锁、类加载冲突

使用工具尝试解决以下问题，并写下总结

当一个Java程序响应很慢时如何查找问题、

当一个Java程序频繁FullGC时如何解决问题、

如何查看垃圾回收日志、

当一个Java应用发生OutOfMemory时该如何解决、

如何判断是否出现死锁、

如何判断是否存在内存泄露

编译原理知识

编译与反编译

Java代码的编译与反编译

Java的反编译工具

词法分析，语法分析（LL算法，递归下降算法，LR算法），语义分析，运行时环境，中间代码，代码生成，代码优化

操作系统知识

Linux的常用命令

进程同步

缓冲区溢出

分段和分页

虚拟内存与主存

数据库知识

MySql 执行引擎

MySQL 执行计划

如何查看执行计划，如何根据执行计划进行SQL优化

SQL优化

事务

事务的隔离级别、事务能不能实现锁的功能

数据库锁

行锁、表锁、使用数据库锁实现乐观锁、

数据库主备搭建

binlog

内存数据库

常用的nosql数据库

redis、memcached

分别使用数据库锁、NoSql实现分布式锁

性能调优

数据结构与算法知识

简单的数据结构

栈、队列、链表、数组、哈希表、

树

二叉树、字典树、平衡树、排序树、B树、B+树、R树、多路树、红黑树

排序算法

各种排序算法和时间复杂度深度优先和广度优先搜索全排列、贪心算法、KMP算法、hash算法、海量数据处理

大数据知识

Zookeeper

基本概念、常见用法

Solr，Lucene，ElasticSearch

在linux上部署solr，solrcloud，，新增、删除、查询索引

Storm，流式计算，了解Spark，S4

在linux上部署storm，用zookeeper做协调，运行storm hello world，local和remote模式运行调试storm topology。

Hadoop，离线计算

HDFS、MapReduce

分布式日志收集flume，kafka，logstash

数据挖掘，mahout

网络安全知识

什么是XSS

XSS的防御

什么是CSRF

什么是注入攻击

SQL注入、XML注入、CRLF注入

什么是文件上传漏洞

加密与解密

MD5，SHA1、DES、AES、RSA、DSA

什么是DOS攻击和DDOS攻击

memcached为什么可以导致DDos攻击、什么是反射型DDoS

SSL、TLS，HTTPS

如何通过Hash碰撞进行DOS攻击

用openssl签一个证书部署到apache或nginx

四、架构篇

分布式

数据一致性、服务治理、服务降级

分布式事务

2PC、3PC、CAP、BASE、可靠消息最终一致性、最大努力通知、TCC

Dubbo

服务注册、服务发现，服务治理

分布式数据库

怎样打造一个分布式数据库、什么时候需要分布式数据库、mycat、otter、HBase

分布式文件系统

mfs、fastdfs

分布式缓存

缓存一致性、缓存命中率、缓存冗余

微服务

SOA、康威定律

ServiceMesh

Docker & Kubernets

Spring Boot

Spring Cloud

高并发

分库分表

CDN技术

消息队列

ActiveMQ

监控

监控什么

CPU、内存、磁盘I/O、网络I/O等

监控手段

进程监控、语义监控、机器资源监控、数据波动

监控数据采集

日志、埋点

Dapper

负载均衡

tomcat负载均衡、Nginx负载均衡

DNS

DNS原理、DNS的设计

CDN

数据一致性

五、扩展篇

云计算

IaaS、SaaS、PaaS、虚拟化技术、openstack、Serverlsess

搜索引擎

Solr、Lucene、Nutch、Elasticsearch

权限管理

Shiro

区块链

哈希算法、Merkle树、公钥密码算法、共识算法、Raft协议、Paxos 算法与 Raft 算法、拜占庭问题与算法、消息认证码与数字签名

比特币

挖矿、共识机制、闪电网络、侧链、热点问题、分叉

以太坊

超级账本

人工智能

数学基础、机器学习、人工神经网络、深度学习、应用场景。

常用框架

TensorFlow、DeepLearning4J

其他语言

Groovy、Python、Go、NodeJs、Swift、Rust

六、推荐书籍

《深入理解Java虚拟机》《Effective Java》《深入分析Java Web技术内幕》《大型网站技术架构》《代码整洁之道》《Head First设计模式》《maven实战》《区块链原理、设计与应用》《Java并发编程实战》《鸟哥的Linux私房菜》《从Paxos到Zookeeper》《架构即未来》

来自：http://www.hollischuang.com/archives/489

java学习路线图(3)-常见面试题涉及领域

一、Java基础

实例方法和静态方法有什么不一样？
Java中的异常有哪几类？分别怎么使用？
常用的集合类有哪些？比如List如何排序？
ArrayList和LinkedList内部的实现大致是怎样的？他们之间的区别和各自适应的场景是什么？
内存溢出是怎么回事？
ClassLoader有什么用？
==和equals的区别？
hashCode方法的作用？
Object类中有哪些方法？列举3个以上。
NIO是什么？适用于何种场景？
HashMap数据结构、扩展策略，Hash冲突攻击如何防范，如何实现线程安全的HashMap？
JVM内存结构，GC算法，CMS、G1的原理
NIO模型，select/epoll的区别，多路复用的原理
Java中一个字符占多少个字节，扩展再问int, long, double占多少字节
创建一个类的实例都有哪些办法？
final/finally/finalize的区别？
LinkingBlockingQueue与ArrayBlockingQueue的区别，他们的适用场景？
Session/Cookie的区别？
String/StringBuffer/StringBuilder的区别，扩展再问他们的实现？
Servlet的生命周期？
如何用Java分配一段连续的1G的内存空间？需要注意些什么？
Java有自己的内存回收机制，但为什么还存在内存泄露的问题呢？
Java里面用对象作为Key需要注意些什么？如何实现hashcode？

二、JVM

JVM堆的基本结构。
JVM的垃圾算法有哪几种？CMS收集算法的流程？
JVM有哪些常用启动参数可以调整？
如何查看JVM的内存使用情况？
Java程序是否会内存溢出？
你常用的JVM配置和调优参数都有哪些？分别什么作用？
Java内存分代模型，GC算法，JVM常见的启动参数；
CMS算法的过程，CMS回收过程中JVM是否需要暂停（这块回答较好，也可以只是看毕玄的Java分布式开发或网上文章的学习，可以结合JVM启动参数常见配置，jstat等命令，看下动手能力，意愿；以及实际线上问题排查）
什么情况下会出现OOM（堆内存，永久区，堆外区，方法栈）
Java内存结构（堆结构，新生代[S0/S1/Elden]，年老代，持久代）
常用的GC策略，什么时候会触发YGC，什么时候触发FGC

三、数据结构与算法基础

说一下几种常见的排序算法和分别的复杂度。
什么是跳表？
如何确认一个链表有环？进一步，确认环的位置。
如何遍历一棵二叉树？
倒排一个LinkedList。
HashSet的实现方式

四、多线程/并发

Java中常见的锁，互斥锁，读写锁，信号量
原子Atomic类，如何保证原子性，CAS硬件指令
volatile，可见性问题的原因，硬件架构，L3 Cache，QPI，乐观锁
如何实现一个线程安全的数据结构
如何避免死锁
如何解决ABA问题
Synchronized关键字的作用？
Volatile关键字的作用？
Java内存模型是怎样的？
HashMap在多线程环境下使用需要注意什么？为什么？
Java程序中启动一个线程是用run()还是start()？
什么是守护线程？有什么用？
什么是死锁？如何避免
线程和进程的差别是什么？
Java里面的Threadlocal是怎样实现的？
ConcurrentHashMap的实现原理是？
sleep和wait区别
notify和notifyAll区别
volatile关键字的作用
ThreadLocal的作用与实现
两个线程如何串行执行
上下文切换是什么含义
可以运行时kill掉一个线程吗？
什么是条件锁、读写锁、自旋锁、可重入锁？
什么是协程（用户态线程，减少数据拷贝，降低CPU开销，无callback函数）？
线程池ThreadPoolExecutor的实现原理？
J.U.C下的常见类的使用。lock, synchronized， ThreadPool的深入考察； BlockingQueue的使用。（take，poll的区别，put，offer的区别）；原子类的实现。
各种常见锁使用如果上面这些掌握很好，还可以看看更深一点的 False Sharing，Cache Line，可见性与原子性等；

五、Linux使用与问题分析排查

硬链接和软链接的区别？
inode是什么？
Linux常用命令有哪些？
怎么看一个Java线程的资源耗用？
Load过高的可能性有哪些？
/etc/hosts文件什么做用？
/etc/resolv.conf文件什么作用？
如何快速的将一个文本中所有“abc”替换为“xyz”？
你常用的Linux下用来进行网络和磁盘IO分析的工具有哪些？
你常用的Linux下用来进行内存和CPU分析的工具有哪些？
发现磁盘空间不够，如何快速找出占用空间最大的文件？
Java服务端问题排查（OOM，CPU高，Load高，类冲突）
Java常用问题排查工具及用法（top, iostat, vmstat, sar, tcpdump, jvisualvm, jmap, jconsole）
Thread dump文件如何分析（Runnable，锁，代码栈，操作系统线程ID关联）
grep，awk，sed；是否自己写过shell脚本；
常见的cpu load过高，us过高，一般是什么问题。引申出是否用过top，jstat，jstack等。
常见的内存问题一般有哪些。引申出是否用过free，top， jmap等。

六、框架使用

Spring中Bean的生命周期。
SpringMVC或Struts处理请求的流程。
Spring AOP解决了什么问题？怎么实现的？aop与cglib，与asm的关系。
Spring事务的传播属性是怎么回事？它会影响什么？
Spring中BeanFactory和FactoryBean有什么区别？
Spring框架中IOC的原理是什么？
spring的依赖注入有哪几种方式
struts工作流程
用Spring如何实现一个切面？
Spring 如何实现数据库事务？
Hibernate和Ibatis这类ORM框架的区别？什么是ORM，解决的痛点是什么？
spriong ioc的生命周期，（init-method，intilizingbean接口方法afterPropertiesSet的先后顺序）等。
Hibernate对一二级缓存的使用，Lazy-Load的理解；
Spring IoC AOP自己用代码如何实现
RPC的负载均衡、服务发现怎么做的
几种推送模型的区别，long polling，websocket

七、数据库相关

MySQL InnoDB的特点？
乐观锁和悲观锁的区别？
数据库隔离级别是什么？有什么作用？
MySQL主备同步的基本原理。
如何从一张表中查出name字段包含“XYZ”的所有行？
索引数据结构（字典+BitTree）
如何优化数据库性能（索引、分库分表、批量操作、分页算法、升级硬盘SSD、业务优化、主从部署）
SQL什么情况下不会使用索引（不包含，不等于，函数）
一般在什么字段上建索引（过滤数据最多的字段）
如何从一张表中查出name字段不包含“XYZ”的所有行？
MySQL，B+索引实现，行锁实现，SQL优化
Redis，RDB和AOF，如何做高可用、集群
如何解决高并发减库存问题
mysql存储引擎中索引的实现机制；
数据库事务的几种粒度；
行锁，表锁；乐观锁，悲观锁

八、网络协议和网络编程

TCP建立连接的过程。
TCP断开连接的过程。
浏览器发生302跳转背后的逻辑？
HTTP协议的交互流程。HTTP和HTTPS的差异，SSL的交互流程？
Rest和Http什么关系？大家都说Rest很轻量，你对Rest风格如何理解？
TCP的滑动窗口协议有什么用？讲讲原理。
HTTP协议都有哪些方法？
交换机和路由器的区别？
什么是VLAN，有什么作用?
什么是VXLAN，有什么作用？
http协议（报文结构，断点续传，多线程下载，什么是长连接）
tcp协议（建连过程，慢启动，滑动窗口，七层模型）
webservice协议（wsdl/soap格式，与rest协议的区别）
spdy/http2.0协议是否有了解
NIO的好处，Netty线程模型，什么是零拷贝

九、Redis等缓存系统/中间件/NoSQL/一致性Hash等

列举一个常用的Redis客户端的并发模型。
HBase如何实现模糊查询？
列举一个常用的消息中间件，如果消息要保序如何实现？
如何实现一个Hashtable？你的设计如何考虑Hash冲突？如何优化？
分布式缓存，一致性hash
LRU算法，slab分配，如何减少内存碎片
如何解决缓存单机热点问题
什么是布隆过滤器，其实现原理是？ False positive指的是？
memcache与redis的区别
zookeeper有什么功能，选举算法如何进行
map/reduce过程，如何用map/reduce实现两个数据源的联合统计

十、设计模式与重构

你在设计一个工厂的包的时候会遵循哪些原则？
你能列举一个使用了Visitor/Decorator模式的开源项目/库吗？
你在编码时最常用的设计模式有哪些？在什么场景下用？
如何实现一个单例？
代理模式（动态代理）
单例模式（懒汉模式，恶汉模式，并发初始化如何解决，volatile与lock的使用）
JDK源码里面都有些什么让你印象深刻的设计模式使用，举例看看？
Reactor模式

十一、学习与进取心

平时会关注哪些技术？
会看那些技术博客和网站？
技术上有没有偶像？
看过哪些技术书籍？
你平常都看些什么书？你去年和今年看的书中印象最深的基本技术书籍和非技术书籍是？
（如果不看书）你平常都上哪些技术论坛？最喜欢哪个？为什么？
项目或产品中用到了什么新技术或框架
最近研究过什么业界流行的技术或框架
对现在所做的项目或产品的缺陷是否了解，有何规划
是否有带过项目，如何管理项目
是否有带过团队，团队管理最大的挑战点是什么

十二、抗压能力及抗压意愿

刚才你说的XXX实现跟那个开源的YYY很像，是不是抄来的？
对加班怎么看？
平台是否有加班，是主动还是被动，是否非常抗拒
是否有负责多件事情，多件事情如何并行处理
你对你最近负责项目中最自豪的点是什么？

十三、开放性问题

一个大文件4G，里面一行行的数字，这时内存只有256M，如果做排序？
如果你部署的应用所在机器硬盘坏了，会发生什么？你的程序要如何处理这种异常？（分布式系统中故障是一种常态，设计要避免单点故障，能容错，保证系统高可用）
实现一个消息队列系统
如何设计一个高可用的架构
多次Hash来解决URL重复访问问题。
全局唯一ID问题。
秒杀如何设计。
如何进行性能优化。
发现CPU 100%，如何排查？
实现一个分布式打点系统。
taobao.com和tmall.com的互相登录的问题。
如何快速对一个2亿数据的List进行排序？

来自：https://www.jianshu.com/p/ba0fdee47cb4

java学习路线图(4)-七年成为架构师

前言：我用了七年的时间，一步一步走到了现在，中途也有了解过其他的技术，也想过要转其他的语言，但是最后还是坚持下来走Java这条路，希望我的经历可以帮助到后来的人，要是觉得对你有帮助的话，可以点赞关注一下。

导读

1、架构师应不应该写代码

2、为什么别人的系统总是那么烂

3、成为架构师最困难的门槛是什么？

4、如何更高效的学习？

1.架构师应不应该写代码

合格的程序员对于明确分配的任务会完成的很好，但是大部分情况下“架构”这个词意味着架构师并不会涉及太多细节，架构图和代码实现之间总还是有些距离，你无法保证所有人都会正确的理解你的设计，或者是程序员写代码时遇到障碍时会立刻想出足够优雅的解决方案。

在我看来，写代码的架构师更像是在做后勤保障的工作：在代码中第一时间发现可能存在的问题，向其他人提出警告，或是给予其他人改进的意见，必要的时候或是给其他人演示一下正确的姿势。

大部分情况下我作为架构师并不需要揽下“核心模块”开发这种工作，毕竟我能调配的时间太零散了，效率难以保证，很多人在专注的情况下比我做的好很多，我只需要保持大局观需要适度参与就可以了。

总的来说，架构师和程序员在某些方面上有点像产品经理和用户的关系，大部分程序员并不会主动告诉你他们想要什么、哪里需要优化，甚至自己也不知道这些。想要做出好的产品，捷径之一就是跟用户做同样的事情。

2.为什么别人的系统总是那么烂

很多程序员解决问题的能力很强，说要解决一个什么问题，下午就能写出几百行代码把功能实现了。但是做出来的东西有种少考虑了什么东西的感觉。大部分程序都能实现功能，但是如果把“时间”这个也作为一个考虑的维度的话，就会意识到一个合格的项目需要考虑更多的东西：更通用的使用方式、易于理解的文档、简单而易于扩展的设计，等等。

很多公司应该都会有一些遗留系统，它们庞大、笨重、难用、几乎无法维护，所有人都在抱怨这些系统，并且每天都在想方设法换掉那些遗留系统。但是一段时间过去之后，又会发现身边的新人又开始吐槽当时替代遗留系统的那个系统了。

“大多数系统当初都很好使，功能当时够用，扩展性看起来也可以，但是这些系统都是开发的人离职之后变坏的。”

3.成为架构师最困难的门槛是什么？

很多人自称架构师的人跟你讲一个架构时简直滔滔不绝，各种技术名词像是说相声一样从他嘴里说出来，三句话不离高并发大数据，但是稍微追问一下，就会发现很多基本概念的缺失，例如自称精通高并发的人说不清楚他所谓的高并发系统的瓶颈在哪里，自称精通架构设计的人说不明白他的系统怎么保证高可用，自称超大数据量的系统实际上只有不到100万条数据，等等。

架构师虽然听起来很高大上，但本质上仍然是工程师，不是科学家，也不是忽悠人的江湖骗子。学习再多，也需要实践落地。设计架构方案更多的是在做一些抽象和权衡：把复杂的需求抽象成简单的模型，从功能、性能、可用性、研发成本等等方面规划如何构建一个系统，这些内容需要更多的实践练习。

4.如何更高效的学习？

大多数人每天能留给自己学习的时间有限，这个阶段如何提升学习效率就成了要解决的重点。

说说自己提升学习效率的心得，其实非常简单：体系化的学习。

在重复了几次痛苦的学习-梳理过程后，再去看一些独立的文章或者资料往往会事半功倍，因为能在体系内找到相对应的知识，甚至有时候一本书里一页只需要看一句话，点破那层窗户纸，就可以掌握新的知识。

跟很多人一样，刚毕业时我觉得作为程序员，只要努力，加上少许天赋便可以获得一些成绩。

工作一段时间后，对自己和其他人的认识也越来越清晰，逐渐的发现程序员之间的差距或许比人和猴子之间的差距还大，接受这个事实这让我郁闷了很久。

再过一段时间，发现自己已经能够客观的评价自己的能力，也意识到了距离并不是那么重要，只要想办法跑的更快，就足够了。

5.快速成为架构师的学习路线

以下五大知识体系是我从业多年总结出来的经验，都是当前最主流的技术。想学习这些技术的朋友可以加群：650385180。群里会分享这些技术知识点供大家学习免费下载。希望能够帮助大家全面、科学地建立自己的技术体系和技术认知！

分布式学习路线

微服务学习路线

性能优化学习路线

经典设计模式与源码分析

开发必备工具

动手实践项目

总结：

以上就是我总结出来的这些年的知识路线，中途也有了解过其他的技术，但是最后还是坚持下来走Java这条路，想要学习提升的，可以加上面的群，希望这些知识点可以帮助在这个行业发展的朋友和伙伴们，在论坛博客等地方少花些时间找资料，把有限的时间，真正放在学习和前进上。

来自：https://blog.csdn.net/person_limit/article/details/79992772

java学习路线图(1)

section 1

1.Core Java，就是Java基础、JDK的类库，很多童鞋都会说，JDK我懂，但是懂还不足够，知其然还要知其所以然，JDK的源代码写的非常好，要经常查看，对使用频繁的类，比如String，集合类（List，Map，Set）等数据结构要知道它们的实现，不同的集合类有什么区别，然后才能知道在一个具体的场合下使用哪个集合类更适合、更高效，这些内容直接看源代码就OK了

2.多线程并发编程，现在并发几乎是写服务端程序必须的技术，那对Java中的多线程就要有足够的熟悉，包括对象锁机制、synchronized关键字，concurrent包都要非常熟悉，这部分推荐你看看《Java并发编程实践》这本书，讲解的很详细

3.I/O，Socket编程，首先要熟悉Java中Socket编程，以及I/O包，再深入下去就是Java NIO,再深入下去是操作系统底层的Socket实现,了解Windows和Linux中是怎么实现socket的

4.JVM的一些知识，不需要熟悉，但是需要了解，这是Java的本质，可以说是Java的母体, 了解之后眼界会更宽阔，比如Java内存模型（会对理解Java锁、多线程有帮助）、字节码、JVM的模型、各种垃圾收集器以及选择、JVM的执行参数（优化JVM）等等,这些知识在《深入Java虚拟机》这本书中都有详尽的解释,或者去oracle网站上查看具体版本的JVM规范.

5.一些常用的设计模式，比如单例、模板方法、代理、适配器等等，以及在Core Java和一些Java框架里的具体场景的实现，这个可能需要慢慢积累，先了解有哪些使用场景，见得多了，自己就自然而然会去用。

6.常用数据库（Oracle、MySQL等）、SQL语句以及一般的优化

7.JavaWeb开发的框架，比如Spring、iBatis等框架，同样他们的原理才是最重要的，至少要知道他们的大致原理。

8.其他一些有名的用的比较多的开源框架和包，Netty网络框架，Apache common的N多包，Google的Guava等等，也可以经常去Github上找一些代码看看。

section 2

每逢长假都会有很多程序员跳槽，十一、过年是跳槽黄金时刻，尤其是过年。过年的时候年终奖到手，没有了多少牵挂，年终同学同事聚会比较多，沟通的就多，各种工作机会的消息也相应会多，所以跳槽的机会也就会多。跳槽就必不可少的要经过面试，那么作为一个Java程序员需要准备哪些面试知识呢？下面就给大家说说。

1、集合框架：

从上图可以看到主要是Collection和Map的继承类和Iterator的实现类，重点掌握ArrayList、LinkedList、Vector、Stack、PriorityQueue、HashSet、LinkedHashSet、TreeSet、HashMap、LinkedHashMap、TreeMap、WeakHashMap、EnumMap、TreeMap、HashTable的特点和实现原理，还有多线程使用场景和插入多还是删除多的时候使用什么样的集合类效率会更高。

2、IO框架：

主要掌握Reader、Writer、InputStream、OutputStream的继承类，重点掌握字节流(FileInputStream、FileOutputSteam、BufferedInputStream、BufferedOutputStream、DataInputStream、DataOutputStream)和字符流(FileReader、FileWriter、BufferedReader、BufferedWriter、InputStreamReader、OutputStreamWriter)，并熟练运用。还有就是NIO的工作原理要知道。

3、String先关：

主要考察对String的处理，顺带考察多线程和算法，大公司就是喜欢考察字符串的算法，主要是字符串查找或者剔除，多线程打印字符串，超大字符串处理。

4、异常处理：

掌握Throwable继承类，理解Error和Exception的区别，理解运行时异常和编译异常的区别，掌握异常的处理方法，掌握try、catch、finally、throw、throws关键字的意义，掌握try-catch-finally语句的执行顺序，掌握异常的工作原理，知道常见的异常有哪些。

5、多线程：

如何创建和启动一个线程，有哪些方法？多线程如何交互，线程之间的调度、让步、合并，如何同步？生产和消费者模型。还有就是掌握线程安全、线程池，死锁。

6、JVM知识：

掌握常见的垃圾回收机制，掌握程序计数器、堆、栈、方法区的作用，掌握类的加载机制。掌握内存分代模型和工作原理。掌握JVM启动参数常见配置，了解JVM调优。

7、数据结构与算法：

掌握常见查找和排序算法实现及其时间、空间复杂度。掌握常见数据结构如链表、队列、栈的基本原理和实现。

section 3

经常主持对高级工程师和中基层Tech Leader的面试，一年下来总有百八十场，我给大家分享一下我对于高级工程师的定位吧，虽然我主要负责.Net团队，但是对于其他语言应该也是适用的。

一理论基础：高级工程师必须有较好的理论基础，既包含一些基础的学科知识，也要包含个人专攻方向的前沿理论。我遇到过形形色色的求职者，有人自称精通领域模式，却不明白什么是聚合根（领域根）。甚至有人无法列举常用的非线性结构，更别提伪码实现和应用场景分析了。这些人普遍振振有词地说，我有丰富的开发经验，项目需要实现的功能我都能做出来，我只是没有去记那些术语名词。抱歉，你不是没有记术语名词，你是根本没有潜心看技术文章的心态，你所谓的学习就是看一些诸如《21天精通Java》，《7天，从菜鸟到专家》之类的垃圾书，或者看点视频。那么你这个高工，比别人高在哪里呢？当单位需要你代表团队和合作机构沟通，甚至发表专栏的时候，你是不是也准备跟大家讲”这个东西我不知道该怎么讲，大家可以看一下我的代码“。只有代码可秀的人是码农，不是高工，所以我给这类求职者的综评是中+封顶。

二工作经验：高级工程师必须有过在项目中担心核心模块开发或者整体架构设计的经验，并且项目越高大上越好，比如你在互联网企业搞过读写分离的实现，你在电商搞过秒杀算法，你在电信行业做过网络层，我必定会高看一眼。如果你就仅仅只是一个人全栈搞过几个小网站，啪啪啪一大堆成熟框架用得倍溜，那么你只是一个装配工。我给这类求职者的综评是中+封顶。

三培养潜力：高级工程师必须有全局思维，如果在你过往的工作历程中，你对你兄弟团队或者部门的工作情形一问三不知，甚至于一个项目中，你只懂自己的模块，其他同事负责的模块你就只会call个API，那么你就是一个很难再进一步的人。对于企业来说，有你不多，无你不少，所以我给这类求职者的综评是中+封顶。

四沟通能力：高级工程师在技术团队中是绝对的核心人中，小项目中你就是负责人，大项目中你也要负责带新人，那么良好的沟通能力必不可少，如果你仅仅是自己一个人心里亮堂，你对企业的价值就要大打折扣。这类求职者，我也有录用过不少，因为程序员木讷可以说是一种共性，在这方面没法太挑剔，但是我给他们的综评是高-封顶。

section 4

如果要应聘高级开发工程师职务，仅仅懂得Java的基础知识是远远不够的，还必须懂得常用数据结构、算法、网 络、操作系统等知识。因此本文不会讲解具体的技术，笔者综合自己应聘各大公司的经历，整理了一份大公司对Java高级开发工程师职位的考核纲要，希望可以帮助到需要的人。

1 Java基础

1.1 Collection和Map

(1)掌握Collection和Map的继承体系。

(2)掌握ArrayList、LinkedList、Vector、Stack、PriorityQueue、HashSet、 LinkedHashSet、TreeSet、HashMap、LinkedHashMap、TreeMap、WeakHashMap、EnumMap、 TreeMap、HashTable的特点和实现原理。

(3)掌握CopyOnWriteArrayList、CopyOnWriteArraySet、ConcurrentHashMap的实现原理和适用场景。

1.2 IO

(1)掌握InputStream、OutputStream、Reader、Writer的继承体系。

(2)掌握字节流(FileInputStream、DataInputStream、BufferedInputStream、 FileOutputSteam、DataOutputStream、BufferedOutputStream)和字符流 (BufferedReader、InputStreamReader、FileReader、BufferedWriter、 OutputStreamWriter、PrintWriter、FileWriter)，并熟练运用。

(3)掌握NIO实现原理及使用方法。

1.3 异常

(1)掌握Throwable继承体系。

(2)掌握异常工作原理。

(3)了解常见受检异常(比如FileNotFoundException)、非受检异常(比如NullPointerException)和错误(比如IOError)。

1.4 多线程

(1)掌握Executors可以创建的三种(JAVA8增加了一种，共四种)线程池的特点及适用范围。

(2)掌握多线程同步机制，并熟练运用。

1.5 Socket

(1)掌握Socket通信原理。

(2)熟练使用多线程结合Socket进行编程。

2 Java虚拟机

2.1 JVM内存区域划分

(1)掌握程序计数器、堆、虚拟机栈、本地方法栈、方法区（JAVA8已移除）、元空间（JAVA8新增）的作用及基本原理。

(2)掌握堆的划分：新生代（Eden、Survivor1、Survivor2）和老年代的作用及工作原理。

(3)掌握JVM内存参数设置及调优。

2.2 类加载

(1)掌握类的加载阶段：加载、链接（验证、准备、解析）、初始化、使用、卸载。

(2)掌握类加载器分类及其应用：启动类加载器、扩展类加载器、应用程序类加载器、自定义加载器。

3 J2EE

(1) 掌握JSP内置对象、动作及相关特点和工作原理。

(2) 掌握Servlet的特点和工作原理。

(3) 掌握Spring框架的IOC和AOP实现原理（反射和动态代理）。

(4) 至少掌握一个MVC框架（Spring MVC，Struts等）的工作原理，并熟练运用。

(5) 至少掌握一个ORM框架(Hibernate，MyBatis等)的工作原理，并熟练运用。

4 数据结构与算法

(1)掌握线性表和树的特点并熟练运用。

(2)掌握常用排序和查找算法：插入排序(直接插入排序、希尔排序)、选择排序(直接选择排序、堆排序)、交换排序(冒泡排序、快速排序)、归并排序，顺序查找、二分查找、哈希查找。

(3) 熟练运用常见排序和查找算法思想解决编程问题。

(4)了解几大基本算法：贪心算法、分治策略、动态规划。

5 计算机网络

(1)掌握网络的分层结构，及每层的功能特点。

(2)掌握TCP/IP的通信原理(三次握手、四次挥手)

6 数据库

(1)掌握复杂的SQL语句编写。

(2)掌握数据库的优化（SQL层面和表设计层面）。

(3)至少掌握一款数据库产品。

(4)熟悉高并发、大数据情况下的数据库开发。

7 Web技术

(1)掌握AJAX的工作原理。

(2)至少熟悉一款JS框架(比如JQuery)。

8 设计模式

(1)熟悉常见的设计模式。

(2)会将设计模式理论应用到实际开发中。

9 Linux

(1)熟练运用Linux常见命令。

(2)熟悉Linux操作系统基本概念及特点。

(3)熟悉Shell脚本。

10 操作系统

(1)掌握操作系统的进程管理。

(2)了解操作系统的I/O。

11 正则表达式

(1)掌握常见正则表达式符号。

(2)熟练运用正则表达式解决实际问题(比如匹配电话号码、邮箱、域名等)。

Section 5

h5edu 的源码
pure–响应式css框架
Hadoop大数据
ERP系统开发
linux
freemarker
weblogic/jobss
webwhpere
webservice http://www.iteye.com/topic/1135747
bootstrap
HTML5
android
css/jslever
spring aop ssh ssm 徒手搭建
jquery源码分析融汇
缓存 echacge
并发
页面静态化
UML
shell
pathy
github
网络编程
ExtJS
网络爬虫
设计模式
多线程与并发
第三方支付/登录http://wiki.connect.qq.com/%E7%BD%91%E7%AB%99%E6%8E%A5%E5%85%A5%E6%B5%81%E7%A8%8B

=========================高级工程========================
找一些高级题目去做
借鉴理解源码http://www.java1234.com/a/kaiyuan/javaWeb/
=========================================================
1.Core Java部分
这是最基础的,对于一个java高级开发/设计人员,你需要对这一部分达到精通的水平,重点内容如下:
a.面向对象编程思想(封装继承多态接口)
b.字符串处理
c.java.lang包,java.util包等常用包
4.java异常处理
2.Java高级部分

a.Java I/O流
b.Java多线程技术
c.Java网络编程
d.Java Swing
后两项可以了解即可,如果项目需要可以深入研究

3.前端基本技能
* HTML + CSS网页开发
* JavaScript
* Jquery
* 浏览器兼容性 CSS hack(了解)
4.熟练使用JSP + Servlet进行开发

5.MVC设计模式,原理,以及相关框架,如Struts

6.SSH框架

7.缓存技术 session & cookie

8.熟练使用一种以上Java开发工具
Eclipse/MyEclipse/Jbuilder/Jcreator

9.熟练使用XML
JDOM w3c.dom SAX

10.Java设计模式
工厂模式,单例模式 ==

11.Java反射机制
反射的各种用法

12.了解或熟悉 C, C++, .NET

13.熟悉JDK的配置,环境变量

14.数据库oracle必学,其他最好了解一种以上(mysql,sql server,access==)
oracle:视图,索引,存储过程,触发器,游标,包,常用函数 ==

15.数据库原理
事务的原理,锁机制,表连接,复杂查询语句(工作经验),性能调优,锁表以及解决方案==

16.JDBC,连接池

17.Ajax,反向Ajax

18.HTTP协议,request 和 response的原理,HTTP status(了解常用的),Https原理

19.熟悉Linux基本命令,使用过Linux/Unix系统,可以编写shell脚本,可以在Linux上部署项目

20.了解windows系统批处理脚本bat

21.了解HTML5,最好学习过

22.熟悉一种JS框架,如Prototype

23.J2EE原理熟悉一种以上web容器如Tomcat,JBoss,websphere,weblogic==

24.熟悉ant或maven

25.熟悉一门脚本语言,如python ,ruby

26.了解php/ asp

27.了解ftp协议及原理

28.熟练使用Junit测试,熟悉Mockito等测试工具

29,熟悉javac,javadoc,native,native2ascii等常用命令

30.熟悉常用的排序算法,如冒泡排序,快速排序等,最好自己研究过一些的算法,下面的这个就是我曾经研究过的一个:
http wenku baidu com /view/391db3f0941ea76e58fa04e9点html
http://wenku.baidu.com/view.391db3f0941ea76e58fa04e9.html

31.了解Flex(不学也没关系)

32.了解敏捷开发模式

33.工作流workflow至少用过一种,如OSworkflow,了解原理

34.使用过VPN了解其原理

35.熟悉jstl表达式和el表达式

36.熟悉webservice,WSDL,SOAP

37.图片处理,如图片上传,预览,限制大小等,下面共享一(垃圾勿喷):
http wenku baidu com/view/05337bfc770bf78a6529541b点html

38.版本控制工具,CVS VSS SVN

39,JSON技术,JSON+AJAX

40.分页技术,最好自己实现过不仅仅是用过要知道原理

41.Java Mail

42.Java读写txt,excel
JXL技术

43.JVM原理,JVM内存管理,GC,Java堆栈池

44.熟练使用下面的工具:
office办公软件,word,excel,ppt等
plsql,sqldevelop 数据库开发工具
outlook大公司都用
ue编辑器
浏览器控制台,调试
SHH/PUTTY 远程
45.UML建模工具 Rational Rose等

46.使用log4j

47.使用过开放API如百度地图,腾讯街景,新浪微博等

48.页面静态化技术(伪静态页面)UrlRwriter

49.报表技术,使用过报表制作工具,如水晶易表

50.定时任务,如Spring batch,学会自定义batch任务(不适用第三方工具)

51.了解uuid

52.B/s 和 C/s架构

53.正则表达式

54.了解JNDI JMS

55. ERP

56.unicode编码,乱码的解决

57.开源网络编辑器,如ckEditor

58.二进制原理

59,使用过,了解开源论坛框架,如discuzz

60, GWT ,Closure框架

61.了解大数据,云计算

62.搜索引擎搜索技术

63.软件工程,项目管理

来自：https://blog.csdn.net/zhibuguonicuo/article/details/60345715

java基础-编译和运行-命令行模式下

先看一下命令行帮助：

javac -help
Usage: javac <options> <source files>
where possible options include:
  -g                         Generate all debugging info
  -g:none                    Generate no debugging info
  -g:{lines,vars,source}     Generate only some debugging info
  -nowarn                    Generate no warnings
  -verbose                   Output messages about what the compiler is doing
  -deprecation               Output source locations where deprecated APIs are used
  -classpath <path>          Specify where to find user class files and annotation processors
  -cp <path>                 Specify where to find user class files and annotation processors
  -sourcepath <path>         Specify where to find input source files
  -bootclasspath <path>      Override location of bootstrap class files
  -extdirs <dirs>            Override location of installed extensions
  -endorseddirs <dirs>       Override location of endorsed standards path
  -proc:{none,only}          Control whether annotation processing and/or compilation is done.
  -processor <class1>[,<class2>,<class3>...] Names of the annotation processors to run; bypasses default discovery process
  -processorpath <path>      Specify where to find annotation processors
  -d <directory>             Specify where to place generated class files
  -s <directory>             Specify where to place generated source files
  -implicit:{none,class}     Specify whether or not to generate class files for implicitly referenced files
  -encoding <encoding>       Specify character encoding used by source files
  -source <release>          Provide source compatibility with specified release
  -target <release>          Generate class files for specific VM version
  -version                   Version information
  -help                      Print a synopsis of standard options
  -Akey[=value]              Options to pass to annotation processors
  -X                         Print a synopsis of nonstandard options
  -J<flag>                   Pass <flag> directly to the runtime system
  -Werror                    Terminate compilation if warnings occur
  @<filename>                Read options and filenames from file

从上面可以看出，-cp 和 -classpath 效果是一样的，估计是简写了。
注意，在Windows系统中多个路径用;来连接，在Unix系统中用:来连接。至于.表示当前路径

一、命令行编译 javac

案例一：

cooldeMacBook-Pro:~ cool$ javac -d /Users/cool/Desktop  /Users/cool/Documents/test/*.java
#或者 因为当前 操作路径 为 Users/cool/Desktop
javac -d /Users/cool/Desktop  Documents/test/*.java

编译java文件时，必须要指定清楚源文件,且需要后缀名.java （*.java 指全部编译）
-d 代表编译好的class文件存放位置（如果java源文件,里面有包名，生成的目标class文件也会带有指定的包名）

案例二：

javac -classpath .;../previousRecord.properties;../lib/jtds-1.2.5.jar;com/cjb/properities/jdbc.properties com/cjb/jdbc/*.java com/cjb/client/*.java -encoding UTF-8

上面命令，表示：编译com/cjb/jdbc下所有java类和com/cjb/client下所有java类，这些类用到了previousRecord.properties文件（它的路径是相对的）和jtds-1.2.5.jar的文件jar包（它的路径也是相对的），同时用的编码是UTF-8。

案例三：
-classpath，设定要搜索类的路径，可以是目录，jar文件，zip文件（里面都是class文件），会覆盖掉所有在CLASSPATH里面的设定。
-sourcepath，设定要搜索编译所需java 文件的路径，可以是目录，jar文件，zip文件（里面都是java文件）。
所以一个完整的javac命令行应该是这样的，
假设abc.java在路径c:\src里面，在任何的目录的都可以执行以下命令来编译。

javac -classpath c:\classes;c:\jar\abc.jar;c:\zip\abc.zip -sourcepath c:\source\project1\src;c:\source\project2 \lib\src.jar;c:\source\project3\lib\src.zip c:\src\abc.java

表示编译需要c:\classed下面的class文件，c:\jar\abc.jar里面的class文件，c:\zip\abc.zip里面的class文件
还需要c:\source\project1\src下面的源文件，c:\source\project2 \lib\src.jar里面的源文件，c:\source\project3\lib\src.zip里面的源文件，
注意：jar，zip里面的源文件不会有什么改动，目录下的源文件，有可能会被重新编译。

二、命令行运行 java

案例一：

cooldeMacBook-Pro:~ cool$ java -classpath /Users/cool/Desktop/  test.Test

运行test.Test 表示包名为test 的 Test.class文件。因为这个目标文件无法指定路径。只能靠搜索路径找到。所以 -classpath /Users/cool/Desktop/ 必须要包括目标执行文件的路径。

案例二：

java -Xms64m -Xmx512m -cp .;../previousRecord.properties;../lib/jtds-1.2.5.jar;com/cjb/properities/jdbc.properties com/cjb/client/MailDispatcherOperation

上面命令，表示：执行com/cjb/client下的MailDispatcherOperation.class(它里面有Main函数)。

案例三：
-classpath，设定要搜索的类的路径，可以是目录，jar文件，zip文件（里面都是class文件），会覆盖掉所有的CLASSPATH的设定。
由于所要执行的类也是要搜索的类的一部分，所以一定要把这个类的路径也放到-classpath的设置里面。
表现在，在要执行的类的路径里面执行java时，一定要添加上点号（.）标示本目录也要搜索。

假设abc.class在路径c:\src里面
可以在任何路径下执行以下命令
java -classpath c:\classes;c:\jar\abc.jar;c:\zip\abc.zip;c:\src abc

问题：如果main.class属于c:\jar\abc.jar，并且在com.cnblogs.jeffchen这个包里，那么执行java -classpath c:\classes;c:\jar\abc.jar;c:\zip\abc.zip;com.cnblogs.jeffchen.main即可，但是如果classpath中包含多个jar包呢？并且其他jar包中也有com.cnblogs.jeffchen会发生什么情况？错误？

三、不同系统，表示路径的区别

在windows下，
文件路径的分割符为反斜杠 \
类或者java文件列表的分割符为分号 ;

在linux下
文件路径的分隔符位斜杠 /
类或者java文件列表的分隔符为冒号 :

一个linux下编译和运行的例子

/usr/local/java/bin/javac -classpath /tmp/javatest/lib/mail-1.3.3.jar -d /tmp/javatest/bin/ /tmp/javatest/src/jp/co/realseed/Capability.java

/usr/local/java/bin/java -classpath /tmp/javatest/lib/mail-1.3.3.jar:/tmp/javatest/bin/ jp.co.realseed.Capability

四、关于-classpath 的细节

google了一下，发现在java6以及后续的版本中，提供了对通配符的支持。

如果您的jdk还是老版本，那么就没法用通配符了，就只能一个一个写了，或者如果是在unix系统中，可以用shell的功能把路径下的所有jar文件拼接起来，
比如 java -classpath $(echo libs/*.jar | tr ‘ ‘ ‘:’) Test

那么java6以后的通配符怎么用呢？
我们看看这个例子
java -classpath “./libs/*” Test
这里的*是指libs目录里的所有jar文件，不能这么写 java -classpath “./libs/*.jar” Test

如果libs目录中既有jar文件又有class文件，我们都想引用，那么就需要这么写
java -classpath “./libs/*;./libs/” Test
注意：windows系统里的分隔符是; Unix系统的分隔符是:

另外需要注意的就是 libs/* 不包含libs目录下的子目录里的 jar文件，比如 libs/folder1/A.jar
如果想包含子目录，那就需要都明确指出，比如
java -cp “./libs/*;./libs/folder1/*” Test

maven中打包依赖的路径配置
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>2.6</version>
    <configuration>
        <excludes>
            <exclude>*.properties</exclude>
            <exclude>*.xml</exclude>
            <exclude>*.sh</exclude>
        </excludes>
        <archive>
            <manifest>
                <addClasspath>true</addClasspath>
                <classpathPrefix>lib</classpathPrefix>
                <mainClass>com.hhht.riskcontrol.thirdparty.tongdun.LoginServer</mainClass>
            </manifest>
            <manifestEntries>
                <Class-Path>conf/</Class-Path>
            </manifestEntries>
        </archive>
    </configuration>
</plugin>
<classpathPrefix>系统会将这个路径下所有的jar包加入到classpath路径中，
<Class-Path>系统会将这个路径加入到classpath中，主要是用于加载配置文件。

参考自：
http://www.cnblogs.com/JeffChen/archive/2008/01/15/1039708.html
https://zhidao.baidu.com/question/371769855407478484.html

java安装配置-配置环境变量

初学java的时候，最害怕的就是下载JDK后要配置环境变量了，关键是当时不理解，所以战战兢兢地照着书籍上或者是网络上的介绍进行操作。然后下次再弄的时候，又忘记了而且是必忘。当时，心里的想法很气愤的，想着是–这东西一点也不人性化，为什么非要自己配置环境变量呢？太不照顾菜鸟和新手了，很多菜鸟就是因为卡在环境变量的配置上，遭受了太多的挫败感。

一、Window平台
配置环境变量主要有3个：JAVA_HOME、PATH、CLASSPATH。

1、JAVA_HOME
指的是你JDK安装的位置，一般默认安装在C盘，如
C:\Program Files\Java\jdk1.8.0_91

2、PATH
将程序路径包含在PATH当中后，在命令行窗口就可以直接键入它的名字了，而不再需要键入它的全路径,比如上面代码中我用的到javac和java两个命令。
一般的PATH=%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;%PATH%;
也就是在原来的PATH路径上添加JDK目录下的bin目录和jre目录的bin.

3、CLASSPATH（其实现在已经不需要配置了）
CLASSPATH=.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar
一看就是指向jar包路径。
需要注意的是前面的.;，.代表当前目录。

如果用命令行进行编译运行时：
说明：网上有人说配置java开发环境时没必要在classpath添加dt.jar和tool.jar，编译时可以找到。classpath中只需放一些第三方或自己编写的jar包路径。classpath 变量的含义是告诉jvm要使用或执行的class放在什么路径上，便于JVM加载class文件。

环境变量的设置与查看
设置可以右击我的电脑，然后点击属性，再点击高级，然后点击环境变量，具体不明白的自行查阅文档。
查看的话可以打开命令行窗口

echo %JAVA_HOME%
echo %PATH%
echo %CLASSPATH%

二、mac平台：
mac 系统默认自带了 jdk。
查看的话可以打开命令行窗口。好像没有看到 CLASSPATH 环境变量。
echo $CLASSPATH 输出是空白

echo $JAVA_HOME
#结果显示 /Library/Java/JavaVirtualMachines/jdk1.7.0_80.jdk/Contents/Home
echo $PATH
# 结果显示 /usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Users/toy/Documents/maven/apache-maven-3.5.3/bin:/Library/Tomcat/my_script_diy:/Library/Tomcat/home/bin:/usr/local/mysql/bin:/Users/cool/Library/Android/sdk/platform-tools

查看java是否安装：

java -version
java version "1.7.0_80"
Java(TM) SE Runtime Environment (build 1.7.0_80-b15)
Java HotSpot(TM) 64-Bit Server VM (build 24.80-b11, mixed mode)

java安装配置-安装版本选择

java 下载时，经常会看到有两个版本：
比如
http://www.oracle.com/technetwork/cn/java/javase/downloads/jdk8-downloads-2133151-zhs.html

Java SE Development Kit 8u171
Java SE Development Kit 8u172

那我们究竟应该下载哪个版本比较好呢。

简单来说，奇数版本是修复了之前的严重错误的版本。经过了很多测试。
下一代奇数版本，将包括上一代偶数版本所修复的全部bug。

偶数版本，修复了之前严重错误和额外错误的版本。仍需要机构再多测试。

查看网站讨论链接：https://www.reddit.com/r/java/comments/8d3i9e/jdk_8u171_vs_jdk_8u172/?st=jhk8n1q9&sh=49328aa6

官方说明链接:
http://www.oracle.com/technetwork/java/javase/cpu-psu-explained-2331472.html

Java CPU and PSU Releases Explained

October 14, 2014

Starting with the release of Java SE 7 Update 71 (Java SE 7u71) in October 2014, Oracle will release a Critical Patch Update (CPU) at the same time as a corresponding Patch Set Update (PSU) for Java SE 7.

Which Java version should I choose: the CPU or the PSU?

Oracle strongly recommends that all Java SE users upgrade to the latest CPU release available for a release family. Most users should choose the CPU release.

Users should only use the corresponding PSU release if they are being impacted by one of the additional bugs fixed in that version as noted in the release notes.

The subsequent CPU release will contain all of the fixes from the current PSU. For this reason, organizations should test the current PSU in their environment in anticipation of these fixes being included in the next CPU.

What is the difference between a Java CPU and PSU release?

Java SE Critical Patch Updates (CPU) contain fixes to security vulnerabilities and critical bug fixes. Oracle strongly recommends that all Java SE users upgrade to the latest CPU releases as they are made available. Java SE CPU releases are odd numbered versions (i.e. 7u71, 7u65 – see more on Java SE version numbering schemes here).

Java SE Patch Set Updates (PSU) contain all of fixes in the corresponding CPU, as well as additional non-critical fixes. Java PSU releases should only be used if you are being impacted by one of the additional bugs fixed in that version. The release notes call out the additional fixes available in Java SE PSU releases.

Is the cadence of CPU releases changing?

As before, Java SE CPU releases are scheduled for release on the Tuesday closest to the 17th day of January, April, July and October under the normal Oracle Critical Patch Update schedule.

Starting in October 2014 with the release of Java SE 7u71 (CPU) and Java SE 7u72 (PSU), Oracle plans to additionally release a corresponding PSU release along with each CPU release for Java SE 7. PSU releases provide organizations and developers with access to non-critical fixes in addition to the critical fixes contained in the corresponding CPU.

Resources and Additional Information:

发布说明：release note
http://www.oracle.com/technetwork/java/javase/8u-relnotes-2225394.html

This page lists all the release notes for public releases and Bundled Patch Release (BPR) builds of JDK 8.

BPR builds are available only as commercial offerings to Oracle customers.

For a complete listing of release notes for all JDK 8 update releases in a single page, see Release Notes for JDK 8 and JDK 8 Update Releases. This page compiles information for many releases (loading this page through slow connections will take longer than loading release notes for individual releases).

eclipse-注释模板自动填充注释

开发时，经常看到别人的代码注释是很规范。
一开始我觉得人家很认真啊，每一个方法的注释都是自己一行一行敲出来的啊。
后来，我觉悟到，注释可以自动生成的啊。。。

设置注释模板的入口：Window->Preference->Java->Code Style->Code Template 然后展开Comments节点就是所有需设置注释的元素。本文现就每一个元素逐一给大家介绍一下。
文件(Files)注释标签：

/**
* @Title: ${file_name}
* @Package ${package_name}
* @Description: ${todo}(用一句话描述该文件做什么)
* @author ${user}
* @date ${date}
* @version V1.0
*/

类型(Types)注释标签（类的注释）：

/**
* @ClassName: ${type_name}
* @Description: ${todo}(这里用一句话描述这个类的作用)
* @author ${user}
* @date ${date}
*
* ${tags}
*/

字段(Fields)注释标签：

/**
* @Fields field:field:{todo}(用一句话描述这个变量表示什么)
*/

构造函数(Constructor)标签：

/**
* 创建一个新的实例 ${enclosing_type}.
*
* ${tags}
*/

方法(Methods)标签：

/**
* @Title: ${enclosing_method}
* @Description: ${todo}(这里用一句话描述这个方法的作用)
* @param ${tags}    参数
* @return ${return_type}    返回类型
* @throws
*/

覆盖方法(Overriding Methods)标签：

/* (非 Javadoc)
* <p>Title: ${enclosing_method}</p>
* <p>Description: </p>
* ${tags}
* ${see_to_overridden}
*/

代理方法(Delegate Methods)标签：

/**
* ${tags}
* ${see_to_target}
*/

getter方法标签：

/**
* @return ${bare_field_name}
*/

setter方法标签：

/**
* @param paramtheparamthe{bare_field_name} to set
*/

要实现上面的注释模板，这需要将下面的配置文件导入就可以了：

<?xml version="1.0" encoding="UTF-8"?>
<templates>
    <template
                autoinsert="false"
                context="filecomment_context"
                deleted="false"
                description="Comment for created Java files"
                enabled="true"
                id="org.eclipse.jdt.ui.text.codetemplates.filecomment"
                name="filecomment">
    /**  
    * @Title: ${file_name}
    * @Package ${package_name}
    * @Description: ${todo}(用一句话描述该文件做什么)
    * @author ${user}
    * @date ${date}
    * @version V1.0  
    */
    </template>
    <template
                autoinsert="false"
                context="typecomment_context"
                deleted="false"
                description="Comment for created types"
                enabled="true"
                id="org.eclipse.jdt.ui.text.codetemplates.typecomment"
                name="typecomment">
    /**
    * @ClassName: ${type_name}
    * @Description: ${todo}(这里用一句话描述这个类的作用)
    * @author ${user}
    * @date ${date}
    *
    * ${tags}
    */
    </template>
    <template
                autoinsert="false"
                context="fieldcomment_context"
                deleted="false"
                description="Comment for fields"
                enabled="true"
                id="org.eclipse.jdt.ui.text.codetemplates.fieldcomment"
                name="fieldcomment">
    /**
    * @Fields field:field:{todo}(用一句话描述这个变量表示什么)
    */
    </template>
    <template
                autoinsert="false"
                  context="constructorcomment_context"
                deleted="false"
                description="Comment for created constructors"
                enabled="true"
                id="org.eclipse.jdt.ui.text.codetemplates.constructorcomment"
                name="constructorcomment">
    /**
     * 创建一个新的实例 ${enclosing_type}.
     *
     * ${tags}
     */
    </template>
        <template
                autoinsert="false"
                context="methodcomment_context"
                deleted="false"
                description="Comment for non-overriding methods"
                enabled="true"
                id="org.eclipse.jdt.ui.text.codetemplates.methodcomment"
                name="methodcomment">
    /**
    * @Title: ${enclosing_method}
    * @Description: ${todo}(这里用一句话描述这个方法的作用)
    * @param ${tags}    参数
    * @return ${return_type}    返回类型
    * @throws
    */
    </template>
    <template
                autoinsert="true"
                context="overridecomment_context"
                deleted="false"
                description="Comment for overriding methods"
                enabled="true"
                id="org.eclipse.jdt.ui.text.codetemplates.overridecomment"
                name="overridecomment">
    /* (非 Javadoc)
    * <p>Title: ${enclosing_method}</p>
    * <p>Description: </p>
    * ${tags}
    * ${see_to_overridden}
    */
    </template>
        <template
                autoinsert="true"
                context="delegatecomment_context"
                deleted="false"
                description="Comment for delegate methods"
                enabled="true"
                id="org.eclipse.jdt.ui.text.codetemplates.delegatecomment"
                name="delegatecomment">
    /**
     * ${tags}
     * ${see_to_target}
     */
    </template>
    <template
                autoinsert="false"
                context="gettercomment_context"
                deleted="false"
                description="Comment for getter method"
                enabled="true"
                id="org.eclipse.jdt.ui.text.codetemplates.gettercomment"
                name="gettercomment">
    /**
    * @return ${bare_field_name}
    */
    </template>
    <template
                autoinsert="true"
                context="settercomment_context"
                deleted="false"
                description="Comment for setter method"
                enabled="true"
                id="org.eclipse.jdt.ui.text.codetemplates.settercomment"
                name="settercomment">
    /**
     * @param paramtheparamthe{bare_field_name} to set
     */
    </template>
</templates>

参考：https://blog.csdn.net/paul342/article/details/52982585

在实际开发过程中，新建一个类以后，通过输入/**，然后回车即自动按照刚才定义的注释模板格式补齐注释内容，也可以按shift+alt+j快捷键完成该动作

springmvc概述-视频教程和笔记

笔记内容均来自尚硅谷佟刚老师的视频，例子是在学习中照着敲的

https://blog.csdn.net/u011870547/article/details/50475831

前端发展简史

起源

第一次浏览器战争

XHTML

（

动态页面的崛起

第二次浏览器大战

HTML 5

Node.js 的爆发

前端 MV* 架构

移动 Web 和 Hybrid App

ECMAScript 6

参考资料

更多文章

一、基础篇

JVM

JVM内存结构

Java内存模型

垃圾回收

JVM参数及调优

Java对象模型

HotSpot

类加载机制

虚拟机性能监控与故障处理工具

编译与反编译

Java基础知识

阅读源代码

Java中各种变量类型

熟悉Java String的使用，熟悉String的各种函数

自动拆装箱

熟悉Java中各种关键字

集合类

枚举

Java IO&Java NIO，并学会使用

Java反射与javassist

Java序列化

注解

JMS

JMX

泛型

单元测试

正则表达式

常用的Java工具库

什么是API&SPI

异常

时间处理

编码方式

语法糖

Java并发编程

什么是线程，与进程的区别

阅读源代码，并学会使用

线程池

线程安全

锁

死锁

volatile

synchronized

sleep 和 wait

wait 和 notify

notify 和 notifyAll

ThreadLocal

写一个死锁的程序

写代码来解决生产者消费者问题

守护线程

二、 进阶篇

Java底层知识

字节码、class文件格式

CPU缓存，L1，L2，L3和伪共享

尾递归

位运算

设计模式

了解23种设计模式

会使用常用设计模式

实现AOP

实现IOC

不用synchronized和lock，实现线程安全的单例模式

nio和reactor设计模式

网络编程知识

tcp、udp、http、https等常用协议

http/1.0 http/1.1 http/2之前的区别

二、进阶篇

三、高级篇