APIS币项目目标是什么具体解答和API是什么币细致分析

最近有很多小伙伴咨询关于APIS币项目目标是什么的问题，小编结合多年的经验整理出来一些API是什么币对应的资料，分享给大家。

创业项目该如何选择技术?

这些年，许多人问过我下面相同的问题： 我开始了一个新项目，你认为我该使用什么技术呢？ 通常，这些人属于下面两类中的一类： 已经做出决定的技术人员 需要鼓励支持的非技术人员 在一天结束的时候，我怀疑这些人是否真正关心我的答案。或许他们只是想知道我们是否面对相同的问题或只是需要鼓励支持。 坦白的说，作为一名工程师，我信奉这个说法：伟大的想法可由几乎任何技术构建。它们都有自己的优点和缺点。无论你选择什么技术，你都要为它带来的风险买单。但真的，你项目的成功与否更多的取决于愿景、领导团队、执行和市场，而并非技术的选择。 现在，我是一个负责人，我每天做技术上的决断。当我选择了一个特定技术时，我要能够证明这个决定，向我自己、我的合合伙人/员工和潜在的投资者。我根据项目及公司愿景做技术选择。 项目要成功你必须有一个坚定的愿景。如果你能将你的愿景转化成一组衡量你每个决定的值，你的前进道路会更清晰，也更容易找到合适的加入你的人。 除了愿景，许多初创公司专注于文化。人们都说文化是由创始人、最初的几个员工及产品本身确立的，然而，技术抉择对公司文化有直接影响这个说法却没怎么被提到。 你的项目初创可能基于J2EE、Oracle、Perl、PHP、Rails、Node.js或.NET，随之而来你的团队工程师将有不同的期望，不同的价值观，和不同的关注点。这些技术没有本质上是坏的。伟大的事情都有各自不凡的所在。它们伴随而来的是一种文化。 几年前，我遇到一位负责人选择使用Node.js来搭建自己的应用。出于好奇，我问他为什么选择Node。他的回答很简单：基础的工程师对Node.js很兴奋，所以我可以更容易招募到愿意免费贡献的人，因为他们希望积累相关经验。 这个决定显式地定义了工程师文化和团队成员——那些能够在这个项目中工作或感兴趣这个项目上工作的人。 问一个不一样的问题 那么我们不应该问什么技术是我们需要使用的， 我们应该问我们自己： 这个技术符合我们公司的核心价值观吗？ 这显然是个更为之困然的问题，因为你需要切切实实地了解你公司的核心价值观。这将是创建一个成功项目的关键。 你不能盲目地套用技术就像你不用套用别人的商业计划那样。这是公司身份的一部分，你的核心价值观，你的目标，你的团队，你的期望都是跟别人不一样的。 关于“这技术在某某公司用得适合啊”这样的论据是很少有效的。例如Facebook使用PHP，它“在Facebook公司用得很适合”，但是这意味着我们选都应该使用PHP吗？ 技术文化联盟 要具体描述这些技术社区的特性是很困难的,但我会个你分享我在不同选择上的观点与看法。请自由在评论里分享自己的看法，也可以包括关于其他技术社区的。 古典学校： 这里有些是“经典“的语言：他们已经被使用很长的一段时间，并且被证明他们的价值。他们的使用范围已经很广泛，但却引不起别人更大的激情。 注意：我在这没有提及Perl，因为我并不知道有哪个创业项目是以Perl作为核心技术来创建的（6？）。 PHP 理念: 功能都实现出来，这非常重要 就像互联网的基础一般 只要有一个方法去实现它，那么就不会被破坏 只要它运行起来并且速度很快，那么其他东西都是没有意义的 不要太理论化了，我们的语言是非常通熟易懂的，任何人一眨眼的功夫就能上手了。你可以用Java做同样的事情看看！ 面向对象是种落后的想法 常见的使用例子: (在2013年中期) 你的第一个web app Wordpress/Drupal的扩展 个人观点: PHP拥有它光荣的日子。它真的让web开发更加简单，容易上手. 但是, 大概因为大量新的程序员开始使用PHP并且它拥有个不是那么地坚持自己观点的社区，所以只有少数人能写出漂亮的PHP代码。 良好的拥有规范的代码例子是很难找到的，并且我甚至不敢肯定PHP拥有自身的规范。这导致了PHP社区以糟糕的代码质量，缺乏测试，安全问题如同梦魇和像在2000年代初期般的落后品味而著名。 拥有良好规范约定，开发流程和指南的强大的PHP团队，是可以完成伟大的事情的，但这样团队很稀少。 Java 理念: 可移植性 像C/C 般的能力和表现，但却能够自动管理内存 更多地关注面向对象 IDE是必须有得 我们要消耗所有的内存，因为它们是一文不值的 线程处理是个好方法！ 不要提起Java applets 看看我可爱的JVM！ 开源（但拥有者为Oracle） 缓慢但更为安全的开发流程 个人观点： Java是非常有趣的。在几年前很多开发者已经厌倦了Java，他们找到了其他新大陆。他们开始转向一些脚本语言，像PHP，Pyhton，Ruby或者一些更加难懂小众的语言像Erlang。 尽管如此，Google通过Android展示了Java并不像我们脑海里的那么糟糕（只要你并不是使用J2EE或者Swing）。现在有一种”赶时髦“的趋势视乎暗示着Java再次变得酷起来了。这些大多建立在两件事情上: JVM 让人难以置信高质量的代码库 即便如此，对于我们来说，花一整天来编写Java程序看起来并不是一件吸引人的事。如果你打算依靠Java的堆栈，那么有一系列的其他JVM语言供你选择，他们成熟而且兼容Java扩展的库（例如：Scala, Groovy, JRuby, Clojure），你总是可以混搭使用它们。 自从大量毕业生学习Java后，聘请Java程序员并非一件难事，但是要找那些前期创业公司，高水准的工程师并且对写Java程序感兴趣是一件极具挑战性的事情。 另外注意：如果你的目标是Android，那么不用想得太复杂，即使你认为其他JVM语言更好，你也要坚持使用官方的堆栈。 我们仍然有许多的原因在你的创业项目里使用Java技术，但你可能会想同时使用一些的”更快，更灵活“的解决方案（Ruby, Python, Node…）。对于公司跟工程师来说，一个多语言环境带来了大量的价值，这就是为什么Java社区看起来节奏很慢，但却肯定是活跃的。 Java绝大部分是吸引了那些受到了传统的训练的工程师，他们向往舒适，有重复性，总所周知的编程模式。他们习惯关于使用这种语言，这种工具，这种自然的节奏。或许他们并不是最具有求知欲的开发者，但是他们却是很可靠的（当然，你要挑选了正确的人）。 C#/.NET 理念: 是更加好的Java 最初是为了桌面与嵌入式软件设计的 我们比开发Java的小伙伴们拥有更好的IDE 虽然是企业级般的重量了，但是我们提供了大部分Rails很酷的特性 我们有矛盾的开源版本 缓慢但更为安全的开发流程 个人观点: 当我回顾C#在发布C#5的时候，我不得不惊叹，我真的对该语言新的特性留下了深刻的印象。单从纯粹的语言设计角度来看，C#是有一丁点的领先于Java。在Visual Studio里写Javascript时的欣悦感让我感到很惊喜（自从我用VS主要为了C 后，我真的再也没有期待过什么了）。 另一件让我印象很深的是：C#可利用的文档的质量非常显著！但是C#并不是开源的，和Visual Studio MSDN 非常昂贵，并且整个环境都因为licenses跟内存损耗而变得很糟糕，这些事实多少让这个好印象打折扣了。 微软正在慢慢地往开源发展，所以有了更多像Azure的开源方案。但是作为一个社区，.NET仍然是微软开发的中心。作为创业者，你应该考虑下你对开源与拥有企业支持的文化之间对比的看法。 C#大部分吸引了Java群体中的变向者：这些工程师们寻求稳定性和有保障的合同远胜于追求开源。还有他们可以容忍IIS！ 明确的可替代品 在过去的这些年，有两个动态语言对于新的创业项目来说变得十分受宠：Python and Ruby。这两个语言实际上有非常多相似的地方。现在Python因为后台apps而著名（因为NLP, biotech, APIs, SOA的因素 ）而另一方方面，Ruby因为面向用户的apps而著名。尽管这两个语言都受到了一样的限制（主要是性能跟并发性），但是他们的核心价值和社区有着不一样的专注点。 Python 理念: 只有一种显而易见的做事方法 代码要漂亮简洁和明确 文档是关键 有较强的语言设计引导 个人观点: 作为一个更喜欢ruby的人来说，我常常嫉妒python项目文档的质量。同时python设计的初衷——给你一个正确的编程方式却又让我又爱又恨。通常这一初衷对于团队来说很好，但某些时候可能令人抓狂。 在某些领域python有很多优秀的库，并且这些库和你想解决的问题有关，这种情况下python可能是最好的选择。python开发者知道怎样去讨论交流他们的代码。他们用文档记录所做的事情并且用面向过程来描述他们务实的方法。 但是python在互联网流行前就已经存在，如果你关注的是并发和高吞吐量，那么这个并发性很差的动态解释语言可能不是一个很好的选择。 python主要吸引的是那些想要一个现代但通过充分验证的语言的更加务实和经验丰富的全栈开发者。 Ruby/Ruby on Rails 理念: 为人而不是机器而设计的Designed for humans, not machines 极端的灵活性：如果陷入困境的话，是你的原因，那是你 一切力求简单、优雅并充满乐趣 DSL至上，尽DSL 测试非常重要 事情变化很快，保持学习 激情活力的社区 个人意见: 就我而言，Ruby是我几年来的首选语言。你会发现令人难以置信的、大量的Ruby开源代码。Rails实在是一个了不起的Web框架，如果你知道如何使用工具的话它让使大多数的Web项目容易实现。 但灵活性和过快的开发周期也有缺点。随时准备在你的代码上投入大量时间以保持其更新以及分离废弃老的库。如果不能依靠缓存，一个成功应用的吞吐量往往被缺乏良好的并发支持限制。 Ruby开发者主要是用Rails开发，所以与框架特性相比基本不会去深入核心语言本身的特性。他们往往是充满好奇心且机会主义的（以一个很好的方式），有些实用主义，关心代码质量/结构和测试覆盖率。Rails开发者早期采用它的典型原因是由于该框架本身默认使用的一些新技术（coffeescript、turbolinks、CSS预处理器……）。 Ruby和Rails主要吸引了那些想把事情做得快而优雅的开发者。相比于底层计算细节，这些开发者往往是以产品导向的，他们更关心的目的和客户价值的实现。 新成员 这是些让人们兴奋的语言/技术。他们代表了运行在“云端”的编程语言的设计新浪潮。 Node.js (Javascript) Node.js不是一门编程语言，但它是使JS在服务器端运行最流行的方法。和我对Ruby的大部分评论是关于Rails一样，相比JS我更关注Node。 理念: 为实时驱动的应用程序而设计，高吞吐量、低延迟 DIY 小的内核，剩余的内容由社区维护 低耦合 借鉴Ruby/Python 个人意见: 我觉得Node.js很有趣。在技术上Node没有太多新内容。Python有Tornado/Twisted，Ruby有EventMachine，C有 libevent。 事件驱动的框架已经使用了一段时间，但Node具有两大优势：*大多数JS库是非阻塞*大多数Web开发者不管怎样都要写一些JS。 在前端和后端使用相同编程语言的想法吸引了不少人，但值得与否还有待验证。 Node提供了巨大的吞吐量（只要你坚持IO操作），它很容易上手，而且写起来很有趣。 由于其本身具有事件驱动性，调试及测试面临挑战，回调处理是可维护性的地狱。我希望Node能够提供一种官方的今后或承诺的解决方案。略显凌乱的文档使在现有项目里跳转时有些困难。 Node的开发者大都是它的早期的接受者，他们更喜欢自定义而不是按惯例创建结构/模式，这样使他们觉得更舒服。它吸引开发者使用已知的语言（JS）去处理高层的并发。Node作为一个框架处理的水平比经典的MVC更底层一些。Node开发者们也真的喜欢这个在服务器和客户端使用相同语言的想法。 Clojure 理念: 实用且符合现代人使用的Lisp 一切皆是数据 并发性，并发性，并发性 让那该死的可变状态见鬼吧 能够很好地与Java协作 稍微靠近科研路线，但并不影响他的实用性 个人观点: 我最喜欢Clojure的一点是它的lisp精神。一旦你攻克了它的圆括号和操作符/参数顺序，那么Clojure将很可能让你重新思考你构建代码的方式。对于处理数据跟强迫你保持代码简短这两方面来说，它真的很棒并且高效。 让我头疼的是我并非拥有足够的聪明去更多地编写Clojure。当我尝试去追踪那些数据时，我的大脑会出现栈溢出。对于该语言来说异常通常是没意义的，假如你尝试解决别人代码的bug，这将会是机具挑战的事情因为Clojure本身是复杂的语言，并且可以用宏来拓展。最后，Clojure社区并不是真的面向web开发，Clojure完成的大多数作品都是以数据作为中心的。 Clojure主要吸引了那些处于边缘，对编程语言有求知欲，面相数据的程序员。如果你寻找有编程语言怪癖的数据处理专家，那么Clojure将会是吸引他们的好方法。 Scala 哲学: 同时具有面向对象与函数编程世界的最佳优点 让编译器为你做一些工作 并发事务 比Java少一些规范，但是目标在于相同或更好的性能 与Java生态系统和谐共存 个人意见: 当目标是JVM时，Scala目前是我所选择的语言。它的学习曲线陡峭。 知道何时使用 FP 与 OOP是非常复杂的，而且在应对该语言语法本身时也是如此。 那就是说，获得使用FP的好处，同时又在需要的时候仍然保持OOP，是非常有用的。一旦你“掌握”了该语言的风格，写Scala实际上是令人愉快的，而且它的社区也非常友好。 Play框架确实很好，它提供了一个很好的替代Rails的选择，特别是对API开发来说。Twitter的工程师团队为此提供了许多资源与开源代码。 目前使用Scala是一个非常安全的选择。Java开发者会有舒适感并会尝试这种更加“现代的”语言。动态语言开发者不会感觉太陌生，并且获得了Java生态环境，性能提升，并发性和永恒性。如果编译时间不会使你感到沮丧的话，现有工具以及惯例使得在一个成长的团队中使用Scala非常不错。 不过就像Ruby，Scala社区的文档不是很丰富。我真的希望 API文档 可以重新编写得更直观，总的说来就是更有用。但是公平的说，已经有许多非常好的资源了，比如Martin Odersky (Scala的创造者)提供的Twitter的 Scala学校和Coursera的Scala 课堂之 FP 。 Scala主要是吸引了好奇的Java开发者，他们想要一些更现代的东西，就像Ruby/Python开发者想要他们语言的一个更具伸缩性的版本。对于吸引那些想拓展它们现存开发环境的伟大的开发者，以及那些可以充分利用该语言二元性的开发者来说，Scala是一个好方法。 Go 更强大的C 你可以自己管理内存，前提是你不能粗心大意 直观的代码更好 丰富的代码库 效率很快..对于任何一个部分来说（从编译到执行） 存在并行编程模式，并且简单使用 文档很关键 个人观点: 我真的很喜欢Go（亦称Golang）。在我使用它几年之后，我选择使用它来开发我自己新项目的API。Go或许对于一些人来说有些无聊，但它的简洁与效率是真材实料的。 Go强迫你更多地去思考你的代码的结构，你的数据/代码行为，因为你不能总是坚持面向对象的编程模式。我发现我的代码总算变得容易调试，结构更简洁，但有时会重复性比较大（例如：错误处理）。 没有比Go更加方便地开发并发业务的语言了。一旦需要编译，你的代码编译加上运行的时间会比Rails服务器启动的时间还快。Go支持一些鸭子类型（duck typing,动态类型的一种风格），这造就了从Ruby（举个例子）转换过来显得颇为简单。对比起一些脚本语言，它所编写产品的性能实在让人觉得惊叹，并且它占用的内存很小。 Go被设计为一个人或是一个大团队都可以为同一代码库工作的语言，而且它的身旁有很多很棒的工具值得你使用。 然而，它不是完美的语言。有时第三方依赖库很让人头疼。当你在高水平编程中运用了Go会让你觉得它的水平太低了。有些语言设计时的决策有时会引起困惑(例子：交互式接口和结构化设计)。 初创公司里，Go看起来在性能和并发事务方面变得越来越流行。我见过很多初创公司用Go替代了Node，而且另一些公司添加了Go应用作为扩展程序。 Go社区里看起来混合了一些老的C/C 学校黑客和一些喜欢低水平语言的年轻人。Go语言和社区的领导者固执的相信让人们理解他们的想法是很容易的。同时他们也允许你能快速的评估你接受他们哲学后是有多么的舒适，而且可以发现是否能达到你的预期效果。 Go主要吸引着面向性能和结构体系的开发者。他们想要轻易的实现并发，要达到C的执行速度，也要达到Python/Ruby的开发速度。他们不想在找一个新的有趣的语言，他们需要一个坚定的妥协。 技术驱动理念 技术的选择会受到理念的影响。你需要清楚而谨慎地权衡你选用的技术是否与企业的价值观一致。做出正确的决定有助于你从技术细节的纠缠中摆脱出来，拥有更多投入商务运作的时间。

虚拟币？XID钻石数字货币是什么？

BitGem资产管理股份有限公司（BAM）及其总公司Precious投资有限公司将为其首个由钻石做储备的加密货币PinkCoin推出crowdsale项目，确切的说，PinkCoin是由固定颜色的钻石资产池作为储备并以以太坊为基础进行开发的加密货币。Crowdsale项目将于2016年1月18日上午九时正式启动。而第三方钻石投保则由伦敦劳埃德集团逐个估价。

一个PinkCoin代币最初将代表钻石池固定估价中的一分。这一分又代表着最初固定估价的一美元。

两家公司称钻石池将会被定时估价。

PinkCoin可根据crowdsale项目条款所描述的钻石池的现有估价被兑换成比特币或私有宝石。最初，资产池被估价为500万美元，因而crowdsale项目会包含500万PinkCoin代币。BAM公司未来可以非摊薄的方式发行9500万个PinkCoin新代币。

PinkCoin的持有人可在BitGem零售市场将其兑换成其他财产或是由资产池做储备的代币。零售市场将会在2016年的第二季度开放使用。

用户可以和兑换供应商或是支持代币交易的钱包进行PinkCoin交易，并需遵守包括以太坊客户协议在内的以太坊标准合约APIs。

但实际上也许并没有他规划的那么高大上，国内的福源币也是如此，最近却好像遇到了一些问题。脚踏实地，才是王道。比特币、瑞泰币、微盟币这些币种虽然发展缓慢，但是走的稳。

web前端开发实训内容

web前端开发实训有以下内容：

1、熟练掌握html基本知识，包括每个标签的用法等。这个建议网上找个视频看看，因为也不会太长的，这个是前端开发的信息结构。

2、熟练掌握div css基本知识，这个东西基本就是前端的基础了，它可以将你写的东西直观的展示出效果给你看，所以须熟练掌握。而且个人由于js的不行，格外的喜欢div css，因为不管你做了什么，瞬间就可以看到效果，对调试、修改有很大的帮助，这个就是前端开发的显示效果。

3、至少掌握一个后台的内容管理系统，比如现在流行的phpcms v9、dede、帝国等都是比较好用的，比如：phpcms v9、dede，毕竟技多不压身。这个也会了，你就基本可以在本地建站了玩了，就可以用来熟悉你前面学到的html和div css，让自己熟练的掌握这些，并且你会发现这样比枯燥的学习更有乐趣。知道以上这几点，基本就可以开始玩了，将自己的想法加入到自己的程序中，将以前学的东西更加深刻的掌握，并且熟练的运用。

4、学习javascript编程，深入学习，包括jquery等框架。这个部分比较重要，也有些难度，需要花费一定的时间和精力，但是这块学明白了，基本上前端的大多数问题也就学会了。

5、学习一门简单的后台编程语言，比如asp或者php，推荐php，不需要学的太深入，主要为了培养编程思想。

想要了解更多有关web前端的相关信息，推荐咨询千锋教育。千锋教育成立教研学科中心，推出贴近企业需求的线下技能培训课程。采用全程面授高品质、高体验培养模式，学科大纲紧跟企业需求，拥有国内一体化教学管理及学员服务，在职业教育发展道路上不断探索前行。

代码重构的概述

重构（），通过调整程序代码改善软件的质量、性能，使其程序的设计模式和架构更趋合理，提高软件的扩展性和维护性。　也许有人会问，为什么不在项目开始时多花些时间把设计做好，而要以后花时间来重构呢？要知道一个完美得可以预见未来任何变化的设计，或一个灵活得可以容纳任何扩展的设计是不存在的。系统设计人员对即将着手的项目往往只能从大方向予以把控，而无法知道每个细枝末节，其次永远不变的就是变化，提出需求的用户往往要在软件成型后，才开始品头论足，系统设计人员毕竟不是先知先觉的神仙，功能的变化导致设计的调整再所难免。所以测试为先，持续重构作为良好开发习惯被越来越多的人所采纳，测试和重构像黄河的护堤，成为保证软件质量的法宝。 在不改变系统功能的情况下，改变系统的实现方式。为什么要这么做？投入精力不用来满足客户关心的需求，而是仅仅改变了软件的实现方式，这是否是在浪费客户的投资呢？

重构的重要性要从软件的生命周期说起。软件不同与普通的产品，他是一种智力产品，没有具体的物理形态。一个软件不可能发生物理损耗，界面上的按钮永远不会因为按动次数太多而发生接触不良。那么为什么一个软件制造出来以后，却不能永远使用下去呢？

对软件的生命造成威胁的因素只有一个：需求的变更。一个软件总是为解决某种特定的需求而产生，时代在发展，客户的业务也在发生变化。有的需求相对稳定一些，有的需求变化的比较剧烈，还有的需求已经消失了，或者转化成了别的需求。在这种情况下，软件必须相应的改变。

考虑到成本和时间等因素，当然不是所有的需求变化都要在软件系统中实现。但是总的说来，软件要适应需求的变化，以保持自己的生命力。

这就产生了一种糟糕的现象：软件产品最初制造出来，是经过精心的设计，具有良好架构的。但是随着时间的发展、需求的变化，必须不断的修改原有的功能、追加新的功能，还免不了有一些缺陷需要修改。为了实现变更，不可避免的要违反最初的设计构架。经过一段时间以后，软件的架构就千疮百孔了。bug越来越多，越来越难维护，新的需求越来越难实现，软件的构架对新的需求渐渐的失去支持能力，而是成为一种制约。最后新需求的开发成本会超过开发一个新的软件的成本，这就是这个软件系统的生命走到尽头的时候。

重构就能够最大限度的避免这样一种现象。系统发展到一定阶段后，使用重构的方式，不改变系统的外部功能，只对内部的结构进行重新的整理。通过重构，不断的调整系统的结构，使系统对于需求的变更始终具有较强的适应能力。

通过重构可以达到以下的目标：

·持续纠偏和改进软件设计

重构和设计是相辅相成的，它和设计彼此互补。有了重构，你仍然必须做预先的设计，但是不必是最优的设计，只需要一个合理的解决方案就够了，如果没有重构、程序设计会逐渐腐败变质，愈来愈像断线的风筝，脱缰的野马无法控制。重构其实就是整理代码，让所有带着发散倾向的代码回归本位。

·

Martin Flower在《重构》中有一句经典的话：任何一个傻瓜都能写出计算机可以理解的程序，只有写出人类容易理解的程序才是优秀的程序员。对此，笔者感触很深，有些程序员总是能够快速编写出可运行的代码，但代码中晦涩的命名使人晕眩得需要紧握坐椅扶手，试想一个新兵到来接手这样的代码他会不会想当逃兵呢？

软件的生命周期往往需要多批程序员来维护，我们往往忽略了这些后来人。为了使代码容易被他人理解，需要在实现软件功能时做许多额外的事件，如清晰的排版布局，简明扼要的注释，其中命名也是一个重要的方面。一个很好的办法就是采用暗喻命名，即以对象实现的功能的依据，用形象化或拟人化的手法进行命名，一个很好的态度就是将每个代码元素像新生儿一样命名，也许笔者有点命名偏执狂的倾向，如能荣此雅号，将深以此为幸。

对于那些让人充满迷茫感甚至误导性的命名，需要果决地、大刀阔斧地整容，永远不要手下留情！

·帮助发现隐藏的代码缺陷

孔子说过：温故而知新。重构代码时逼迫你加深理解原先所写的代码。笔者常有写下程序后，却发生对自己的程序逻辑不甚理解的情景，曾为此惊悚过，后来发现这种症状居然是许多程序员常患的感冒。当你也发生这样的情形时，通过重构代码可以加深对原设计的理解，发现其中的问题和隐患，构建出更好的代码。

·从长远来看，有助于提高编程效率

当你发现解决一个问题变得异常复杂时，往往不是问题本身造成的，而是你用错了方法，拙劣的设计往往导致臃肿的编码。

改善设计、提高可读性、减少缺陷都是为了稳住阵脚。良好的设计是成功的一半，停下来通过重构改进设计，或许会在当前减缓速度，但它带来的后发优势却是不可低估的。 新官上任三把火，开始一个全新??、脚不停蹄、加班加点，一支声势浩大的千军万码夹裹着程序员激情和扣击键盘的鸣金奋力前行，势如破竹，攻城掠地，直指黄龙府。

开发经理是这支浩浩汤汤代码队伍的统帅，他负责这支队伍的命运，当齐桓公站在山顶上看到管仲训练的队伍整齐划一地前进时，他感叹说我有这样一支军队哪里还怕没有胜利呢？。但很遗憾，你手中的这支队伍原本只是散兵游勇，在前进中招兵买马，不断壮大，所以队伍变形在所难免。当开发经理发觉队伍变形时，也许就是克制住攻克前方山头的诱惑，停下脚步整顿队伍的时候了。

Kent Beck提出了代码坏味道的说法，和我们所提出的队伍变形是同样的意思，队伍变形的信号是什么呢？以下列述的代码症状就是队伍变形的强烈信号：

·代码中存在重复的代码

中国有118 家整车生产企业，数量几乎等于美、日、欧所有汽车厂家数之和，但是全国的年产量却不及一个外国大汽车公司的产量。重复建设只会导致效率的低效和资源的浪费。

程序代码更是不能搞重复建设，如果同一个类中有相同的代码块，请把它提炼成类的一个独立方法，如果不同类中具有相同的代码，请把它提炼成一个新类，永远不要重复代码。

·过大的类和过长的方法

过大的类往往是类抽象不合理的结果，类抽象不合理将降低了代码的复用率。方法是类王国中的诸侯国，诸侯国太大势必动摇中央集权。过长的方法由于包含的逻辑过于复杂，错误机率将直线上升，而可读性则直线下降，类的健壮性很容易被打破。当看到一个过长的方法时，需要想办法将其划分为多个小方法，以便于分而治之。

·牵一毛而需要动全身的修改

当你发现修改一个小功能，或增加一个小功能时，就引发一次代码地震，也许是你的设计抽象度不够理想，功能代码太过分散所引起的。

·类之间需要过多的通讯

A类需要调用B类的过多方法访问B的内部数据，在关系上这两个类显得有点狎昵，可能这两个类本应该在一起，而不应该分家。

·过度耦合的信息链

计算机是这样一门科学，它相信可以通过添加一个中间层解决任何问题，所以往往中间层会被过多地追加到程序中。如果你在代码中看到需要获取一个信息，需要一个类的方法调用另一个类的方法，层层挂接，就象输油管一样节节相连。这往往是因为衔接层太多造成的，需要查看就否有可移除的中间层，或是否可以提供更直接的调用方法。

·各立山头干革命

如果你发现有两个类或两个方法虽然命名不同但却拥有相似或相同的功能，你会发现往往是因为开发团队协调不够造成的。笔者曾经写了一个颇好用的字符串处理类，但因为没有及时通告团队其他人员，后来发现项目中居然有三个字符串处理类。革命资源是珍贵的，我们不应各立山头干革命。

·不完美的设计

在笔者刚完成的一个比对报警项目中，曾安排阿朱开发报警模块，即通过Socket向指定的短信平台、语音平台及客户端报警器插件发送报警报文信息，阿朱出色地完成了这项任务。后来用户又提出了实时比对的需求，即要求第三方系统以报文形式向比对报警系统发送请求，比对报警系统接收并响应这个请求。这又需要用到Socket报文通讯，由于原来的设计没有将报文通讯模块独立出来，所以无法复用阿朱开发的代码。后来我及时调整了这个设计，新增了一个报文收发模块，使系统所有的对外通讯都复用这个模块，系统的整体设计也显得更加合理。

每个系统都或多或少存在不完美的设计，刚开始可能注意不到，到后来才会慢慢凸显出来，此时唯有勇于更改才是最好的出路。

·缺少必要的注释

虽然许多软件工程的书籍常提醒程序员需要防止过多注释，但这个担心好象并没有什么必要。往往程序员更感兴趣的是功能实现而非代码注释，因为前者更能带来成就感，所以代码注释往往不是过多而是过少，过于简单。人的记忆曲线下降的坡度是陡得吓人的，当过了一段时间后再回头补注释时，很容易发生提笔忘字，愈言且止的情形。

曾在网上看到过微软的代码注释，其详尽程度让人叹为观止，也从中体悟到了微软成功的一个经验。 学习一种可以大幅提高生产力的新技术时，你总是难以察觉其不适用的场合。通常你在一个特定场景中学习它，这个场景往往是个项目。这种情况下你很难看出什么会造成这种新技术成效不彰或甚至形成危害。十年前，对象技术（object tech.）的情况也是如此。那时如果有人问我「何时不要使用对象」，我很难回答。并非我认为对象十全十美、没有局限性 — 我最反对这种盲目态度，而是尽管我知道它的好处，但确实不知道其局限性在哪儿。

现在，重构的处境也是如此。我们知道重构的好处，我们知道重构可以给我们的工作带来垂手可得的改变。但是我们还没有获得足够的经验，我们还看不到它的局限性。

这一小节比我希望的要短。暂且如此吧。随着更多人学会重构技巧，我们也将对??你应该尝试一下重构，获得它所提供的利益，但在此同时，你也应该时时监控其过程，注意寻找重构可能引入的问题。请让我们知道你所遭遇的问题。随着对重构的了解日益增多，我们将找出更多解决办法，并清楚知道哪些问题是真正难以解决的。

·数据库（Databases）

「重构」经常出问题的一个领域就是数据库。绝大多数商用程序都与它们背后的database schema（数据库表格结构）紧密耦合（coupled）在一起，这也是database schema如此难以修改的原因之一。另一个原因是数据迁移（migration）。就算你非常小心地将系统分层（layered），将database schema和对象模型（object model）间的依赖降至最低，但database schema的改变还是让你不得不迁移所有数据，这可能是件漫长而烦琐的工作。

在「非对象数据库」（nonobject databases）中，解决这个问题的办法之一就是：在对象模型（object model）和数据库模型（database model）之间插入一个分隔层（separate layer），这就可以隔离两个模型各自的变化。升级某一模型时无需同时升级另一模型，只需升级上述的分隔层即可。这样的分隔层会增加系统复杂度，但可以给你很大的灵活度。如果你同时拥有多个数据库，或如果数据库模型较为复杂使你难以控制，那么即使不进行重构，这分隔层也是很重要的。

你无需一开始就插入分隔层，可以在发现对象模型变得不稳定时再产生它。这样你就可以为你的改变找到最好的杠杆效应。

对开发者而言，对象数据库既有帮助也有妨碍。某些面向对象数据库提供不同版本的对象之间的自动迁移功能，这减少了数据迁移时的工作量，但还是会损失一定时间。如果各数据库之间的数据迁移并非自动进行，你就必须自行完成迁移工作，这个工作量可是很大的。这种情况下你必须更加留神classes内的数据结构变化。你仍然可以放心将classes的行为转移过去，但转移值域（field）时就必须格外小心。数据尚未被转移前你就得先运用访问函数（accessors）造成「数据已经转移」的假象。一旦你确定知道「数据应该在何处」时，就可以一次性地将数据迁移过去。这时惟一需要修改的只有访问函数（accessors），这也降低了错误风险。

·修改接口（Changing Interfaces）

关于对象，另一件重要事情是：它们允许你分开修改软件模块的实现（implementation）和接口（interface）。你可以安全地修改某对象内部而不影响他人，但对于接口要特别谨慎 — 如果接口被修改了，任何事情都有可能发生。

一直对重构带来困扰的一件事就是：许多重构手法的确会修改接口。像Rename Method（273）这么简单的重构手法所做的一切就是修改接口。这对极为珍贵的封装概念会带来什么影响呢？

如果某个函数的所有调用动作都在你的控制之下，那么即使修改函数名称也不会有任何问题。哪怕面对一个public函数，只要能取得并修改其所有调用者，你也可以安心地将这个函数易名。只有当需要修改的接口系被那些「找不到，即使找到也不能修改」的代码使用时，接口的修改才会成为问题。如果情况真是如此，我就会说：这个接口是个「已发布接口」（published interface）— 比公开接口（public interface）更进一步。接口一旦发行，你就再也无法仅仅修改调用者而能够安全地修改接口了。你需要一个略为复杂的程序。

这个想法改变了我们的问题。如今的问题是：该如何面对那些必须修改「已发布接口」的重构手法？

简言之，如果重构手法改变了已发布接口（published interface），你必须同时维护新旧两个接口，直到你的所有用户都有时间对这个变化做出反应。幸运的是这不太困难。你通常都有办法把事情组织好，让旧接口继续工作。请尽量这么做：让旧接口调用新接口。当你要修改某个函数名称时，请留下旧函数，让它调用新函数。千万不要拷贝函数实现码，那会让你陷入「重复代码」（duplicated code）的泥淖中难以自拔。你还应该使用Java提供的 deprecation（反对）设施，将旧接口标记为 deprecated。这么一来你的调用者就会注意到它了。

这个过程的一个好例子就是Java容器类（collection classes）。Java 2的新容器取代了原先一些容器。当Java 2容器发布时，JavaSoft花了很大力气来为开发者提供一条顺利迁徙之路。

「保留旧接口」的办法通常可行，但很烦人。起码在一段时间里你必须建造（build）并维护一些额外的函数。它们会使接口变得复杂，使接口难以使用。还好我们有另一个选择：不要发布（publish）接口。当然我不是说要完全禁止，因为很明显你必得发布一些接口。如果你正在建造供外部使用的APIs，像Sun所做的那样，肯定你必得发布接口。我之所以说尽量不要发布，是因为我常常看到一些开发团队公开了太多接口。我曾经看到一支三人团队这么工作：每个人都向另外两人公开发布接口。这使他们不得不经常来回维护接口，而其实他们原本可以直接进入程序库，径行修改自己管理的那一部分，那会轻松许多。过度强调「代码拥有权」的团队常常会犯这种错误。发布接口很有用，但也有代价。所以除非真有必要，别发布接口。这可能意味需要改变你的代码拥有权观念，让每个人都可以修改别人的代码，以运应接口的改动。以搭档（成对）编程（Pair Programming）完成这一切通常是个好主意。

不要过早发布（published）接口。请修改你的代码拥有权政策，使重构更顺畅。

Java之中还有一个特别关于「修改接口」的问题：在throws子句中增加一个异常。这并不是对签名式（signature）的修改，所以你无法以delegation（委托手法）隐藏它。但如果用户代码不作出相应修改，编译器不会让它通过。这个问题很难解决。你可以为这个函数选择一个新名tion（可控式异常）转换成一个unchecked exception（不可控异常）。你也可以抛出一个unchecked异常，不过这样你就会失去检验能力。如果你那么做，你可以警告调用者：这个unchecked异常日后会变成一个checked异常。这样他们就有时间在自己的代码中加上对此异常的处理。出于这个原因，我总是喜欢为整个package定义一个superclass异常（就像java.sql的SQLException），并确保所有public函数只在自己的throws子句中声明这个异常。这样我就可以随心所欲地定义subclass异常，不会影响调用者，因为调用者永远只知道那个更具一般性的superclass异常。

·难以通过重构手法完成的设计改动

通过重构，可以排除所有设计错误吗？是否存在某些核心设计决策，无法以重构手法修改？在这个领域里，我们的统计数据尚不完整。当然某些情况下我们可以很有效地重构，这常常令我们倍感惊讶，但的确也有难以重构的地方。比如说在一个项目中，我们很难（但还是有可能）将「无安全需求（no security requirements）情况下构造起来的系统」重构为「安全性良好的（good security）系统」。

这种情况下我的办法就是「先想象重构的情况」。考虑候选设计方案时，我会问自己：将某个设计重构为另一个设计的难度有多大？如果看上去很简单，我就不必太担心选择是否得当，于是我就会选最简单的设计，哪怕它不能覆盖所有潜在需求也没关系。但如果预先看不到简单的重构办法，我就会在设计上投入更多力气。不过我发现，这种情况很少出现。

·何时不该重构？

有时候你根本不应该重构 — 例如当你应该重新编写所有代码的时候。有时候既有代码实在太混乱，重构它还不如从新写一个来得简单。作出这种决定很困难，我承认我也没有什么好准则可以判断何时应该放弃重构。

重写（而非重构）的一个清楚讯号就是：现有代码根本不能正常运作。你可能只是试着做点测试，然后就发现代码中满是错误，根本无法稳定运作。记住，重构之前，代码必须起码能够在大部分情况下正常运作。

一个折衷办法就是：将「大块头软件」重构为「封装良好的小型组件」。然后你就可以逐一对组件作出「重构或重建」的决定。这是一个颇具希望的办法，但我还没有足够数据，所以也无法写出优秀的指导原则。对于一个重要的古老系统，这肯定会是一个很好的方向。

另外，如果项目已近最后期限，你也应该避免重构。在此时机，从重构过程赢得的生产力只有在最后期限过后才能体现出来，而那个时候已经时不我予。Ward Cunningham对此有一个很好的看法。他把未完成的重构工作形容为「债务」。很多公司都需要借债来使自己更有效地运转。但是借债就得付利息，过于复杂的代码所造成的「维护和扩展的额外开销」就是利息。你可以承受一定程度的利息，但如果利息太高你就会被压垮。把债务管理好是很重要的，你应该随时通过重构来偿还一部分债务。

如果项目已经非常接近最后期限，你不应该再分心于重构，因为已经没有时间了。不过多个项目经验显示：重构的确能够提高生产力。如果最后你没有足够时间，通常就表示你其实早该进行重构。 「重构」肩负一项特别任务：它和设计彼此互补。初学编程的时候，我埋头就写程序，浑浑噩噩地进行开发。然而很快我便发现，「事先设计」（upfront design）可以助我节省回头工的高昂成本。于是我很快加强这种「预先设计」风格。许多人都把设计看作软件开发的关键环节，而把编程（programming）看作只是机械式的低级劳动。他们认为设计就像画工程图而编码就像施工。但是你要知道，软件和真实器械有着很大的差异。软件的可塑性更强，而且完全是思想产品。正如Alistair Cockburn所说：『有了设计，我可以思考更快，但是其中充满小漏洞。』

有一种观点认为：重构可以成为「预先设计」的替代品。这意思是你根本不必做任何设计，只管按照最初想法开始编码，让代码有效运作，然后再将它重构成型。事实上这种办法真的可行。我的确看过有人这么做，最后获得设计良好的软件。极限编程（Extreme Programming）【Beck, XP】 的支持者极力提倡这种办法。

尽管如上所言，只运用重构也能收到效果，但这并不是最有效的途径。是的，即使极限编程（Extreme Programming）爱好者也会进行预先设计。他们会使用CRC卡或类似的东西来检验各种不同想法，然后才得到第一个可被接受的解决方案，然后才能开始编码，然后才能重构。关键在于：重构改变了「预先设计」的角色。如果没有重构，你就必须保证「预先设计」正确无误，这个压力太大了。这意味如果将来需要对原始设计做任何修改，代价都将非常高昂。因此你需要把更多时间和精力放在预先设计上，以避免日后修改。

如果你选择重构，问题的重点就转变了。你仍然做预先设计，但是不必一定找出正确的解决方案。此刻的你只需要得到一个足够合理的解决方案就够了。你很肯定地知道，在实现这个初始解决方案的时候，你对问题的理解也会逐渐加深，你可能会察觉最佳解决方案和你当初设想的有些不同。只要有重构这项武器在手，就不成问题，因为重构让日后的修改成本不再高昂。

这种转变导致一个重要结果：软件设计朝向简化前进了一大步。过去未曾运用重构时，我总是力求得到灵活的解决方案。任何一个需求都让我提心吊胆地猜疑：在系统寿命期间，这个需求会导致怎样的变化？由于变更设计的代价非常高昂，所以我希望建造一个足够灵活、足够强固的解决方案，希望它能承受我所能预见的所有需求变化。问题在于：要建造一个灵活的解决方案，所需的成本难以估算。灵活的解决方案比简单的解决方案复杂许多，所以最终得到的软件通常也会更难维护 — 虽然它在我预先设想的??方向上，你也必须理解如何修改设计。如果变化只出现在一两个地方，那不算大问题。然而变化其实可能出现在系统各处。如果在所有可能的变化出现地点都建立起灵活性，整个系统的复杂度和维护难度都会大大提高。当然，如果最后发现所有这些灵活性都毫无必要，这才是最大的失败。你知道，这其中肯定有些灵活性的确派不上用场，但你却无法预测到底是哪些派不上用场。为了获得自己想要的灵活性，你不得不加入比实际需要更多的灵活性。

有了重构，你就可以通过一条不同的途径来应付变化带来的风险。你仍旧需要思考潜在的变化，仍旧需要考虑灵活的解决方案。但是你不必再逐一实现这些解决方案，而是应该问问自己：『把一个简单的解决方案重构成这个灵活的方案有多大难度？』如果答案是「相当容易」（大多数时候都如此），那么你就只需实现目前的简单方案就行了。

重构可以带来更简单的设计，同时又不损失灵活性，这也降低了设计过程的难度，减轻了设计压力。一旦对重构带来的简单性有更多感受，你甚至可以不必再预先思考前述所谓的灵活方案 — 一旦需要它，你总有足够的信心去重构。是的，当下只管建造可运行的最简化系统，至于灵活而复杂的设计，唔，多数时候你都不会需要它。

劳而无获— Ron Jeffries

Chrysler Comprehensive Compensation（克莱斯勒综合薪资系统）的支付过程太慢了。虽然我们的开发还没结束，这个问题却已经开始困扰我们，因为它已经拖累了测试速度。

Kent Beck、Martin Fowler和我决定解决这个问题。等待大伙儿会合的时间里，凭着我对这个系统的全盘了解，我开始推测：到底是什么让系统变慢了？我想到数种可能，然后和伙伴们谈了几种可能的修改方案。最后，关于「如何让这个系统运行更快」，我们提出了一些真正的好点子。

然后，我们拿Kent的量测工具度量了系统性能。我一开始所想的可能性竟然全都不是问题肇因。我们发现：系统把一半时间用来创建「日期」实体（instance）。更有趣的是，所有这些实体都有相同的值。

于是我们观察日期的创建逻辑，发现有机会将它优化。日期原本是由字符串转换而生，即使无外部输入也是如此。之所以使用字符串转换方式，完全是为了方便键盘输入。好，也许我们可以将它优化。

于是我们观察日期怎样被这个程序运用。我们发现，很多日期对象都被用来产生「日期区间」实体（instance）。「日期区间」是个对象，由一个起始日期和一个结束日期组成。仔细追踪下去，我们发现绝大多数日期区间是空的！

处理日期区间时我们遵循这样一个规则：如果结束日期在起始日期之前，这个日期区间就该是空的。这是一条很好的规则，完全符合这个class的需要。采用此一规则后不久，我们意识到，创建一个「起始日期在结束日期之后」的日期区间，仍然不算是清晰的代码，于是我们把这个行为提炼到一个factory method（译注：一个著名的设计模式，见《Design Patterns》），由它专门创建「空的日期区间」。

我们做了上述修改，使代码更加清晰，却意外得到了一个惊喜。我们创建一个固定不变的「空日期区间」对象，并让上述调整后的factory method每次都返回该对象，而不再每次都创建新对象。这一修改把系统速度提升了几乎一倍，足以让测试速度达到可接受程度。这只花了我们大约五分钟。

我和团队成员（Kent和Martin谢绝参加）认真推测过：我们了若指掌的这个程序中可能有什么错误？我们甚至凭空做了些改进设计，却没有先对系统的真实情况进行量测。

我们完全错了。除了一场很有趣的交谈，我们什么好事都没做。

教训：哪怕你完全了解系统，也请实际量测它的性能，不要臆测。臆测会让你学到一些东西，但十有八九你是错的。

spring是什么，有什么作用，主要用在什么地方，好不好学，对社会有什么作用？

Spring Framework，今年夏天你可能已经听见很多的议论。在本文中,我将试图解释Spring能完成什么，和我怎么会认为它能帮助你开发J2EE应用程序。 另一framework？ 你可能正在想“不过是另外一个的framework”。当已经有许多开放源代码(和专有) J2EE framework时，为什么你应该费心读这篇文章,或下载Spring Framework？ 我相信Spring是独特的,因为若干个原因: . 它定位的领域是许多其他流行的framework没有的。Spring关注提供一种方法管理你的业务对象。 . Spring是全面的和模块化的。Spring有分层的体系结构,这意味着你能选择使用它孤立的任何部分,它的架构仍然是内在稳定的。因此从你的学习中，你可得到最大的价值。例如,你可能选择仅仅使用Spring来简单化JDBC的使用,或用来管理所有的业务对象。 . 它的设计从底部帮助你编写易于测试的代码。Spring是用于测试驱动工程的理想的framework。 Spring对你的工程来说，它不需要一个以上的framework。Spring是潜在地一站式解决方案,定位于与典型应用相关的大部分基础结构。它也涉及到其他framework没有考虑到的内容。 尽管它仅仅是一个从2003年2月才开始的开源工程，但Spring有较长的历史根基。这个开源工程是起源自我在2002年后期出版的《Expert One-on-One J2EE设计与开发》书中的基础代码。这本书展示了Spring背后的基础架构。然而,这个基础架构的概念要追溯到2000年的早些时候,并且反映了我为一系列成功的商业工程开发基础结构的经验。 从2003年1月，Spring已经落户于SourceForge上。现在有10个开发人员,其中6是高度投入的积极分子。 Spring的架构性的好处 在我们进入细节以前，让我们看一下Spring可以给一个工程带来的一些好处: . Spring能有效地组织你的中间层对象,无论你是否选择使用了EJB。如果你仅仅使用了Struts或其他的包含了J2EE特有APIs的framework，你会发现Spring关注了遗留下的问题，。 . Spring能消除在许多工程上对Singleton的过多使用。根据我的经验，这是一个主要的问题，它减少了系统的可测试性和面向对象特性。 . Spring能消除使用各种各样格式的属性定制文件的需要,在整个应用和工程中，可通过一种一致的方法来进行配置。曾经感到迷惑，一个特定类要查找迷幻般的属性关键字或系统属性,为此不得不读Javadoc乃至源编码吗？有了Spring，你可很简单地看到类的JavaBean属性。倒置控制的使用(在下面讨论)帮助完成这种简化。 . Spring能通过接口而不是类促进好的编程习惯，减少编程代价到几乎为零。 . Spring被设计为让使用它创建的应用尽可能少的依赖于他的APIs。在Spring应用中的大多数业务对象没有依赖于Spring。 . 使用Spring构建的应用程序易于单元测试。 . Spring能使EJB的使用成为一个实现选择,而不是应用架构的必然选择。你能选择用POJOs或local EJBs来实现业务接口，却不会影响调用代码。 . Spring帮助你解决许多问题而无需使用EJB。Spring能提供一种EJB的替换物，它们适于许多web应用。例如,Spring能使用AOP提供声明性事务而不通过使用EJB容器，如果你仅仅需要与单个的数据库打交道，甚至不需要JTA实现。 . Spring为数据存取提供了一致的框架,不论是使用JDBC或O/R mapping产品（如Hibernate）。 Spring确实使你能通过最简单可行的解决办法解决你的问题。这些特性是有很大价值的。 Spring能做什么？ Spring提供许多功能,在此我将快速地依次展示其各个主要方面。 任务描述： 首先,让我们明确Spring范围。尽管Spring覆盖了许多方面，但我们已经有清楚的概念，它什么应该涉及和什么不应该涉及。 Spring的主要目的是使J2EE易用和促进好编程习惯。 Spring不重新开发已有的东西。因此，在Spring中你将发现没有日志记录的包,没有连接池,没有分布事务调度。这些均有开源项目提供(例如Commons Logging 用来做所有的日志输出，或Commons DBCP用来作数据连接池),或由你的应用程序服务器提供。因为同样的的原因，我们没有提供O/R mapping层，对此，已有有好的解决办法如Hibernate和JDO。 Spring的目标是使已存在的技术更加易用。例如,尽管我们没有底层事务协调处理，但我们提供了一个抽象层覆盖了JTA或任何其他的事务策略。 Spring没有直接和其他的开源项目竞争，除非我们感到我们能提供新的一些东西。例如，象许多开发人员，我们从来没有为Struts高兴过，并且感到在MVC web framework中还有改进的余地。在某些领域，例如轻量级的IoC容器和AOP框架，Spring有直接的竞争，但是在这些领域还没有已经较为流行的解决方案。(Spring在这些区域是开路先锋。) Spring也得益于内在的一致性。 所有的开发者都在唱同样的的赞歌,基础想法依然是Expert One-on-One J2EE设计与开发的那些。 并且我们已经能够使用一些主要的概念,例如倒置控制，来处理多个领域。 Spring在应用服务器之间是可移植的。 当然保证可移植性总是一次挑战，但是我们避免任何特定平台或非标准化,并且支持在WebLogic，Tomcat，Resin，JBoss，WebSphere和其他的应用服务器上的用户。 倒置控制容器 Spring的设计核心是 org.springframework.beans 包, 为与JavaBeans一起工作而设计。 这个包一般不直接被用户使用, 但作为基础为更多的其他功能服务. 下一个较高层面的抽象是"Bean Factory"。 Spring bean factory 是一个普通的Factory，它使对象能够按名称获取，并且能管理对象之间的关系。 Bean factories 支持两种对象模式: . Singleton：在此模式中，有一个具有特定名称的共享对象实例，它在查找时被获取。这是默认的，而且是最为经常使用的。它对于无状态对象是一种理想的模式。 .Prototype：在此模式中，每次获取将创建一个独立的对象。例如，这可以被用于允许用户拥有他们自己的对象。 由于 org.springframwork.beans.factory.BeanFactory是一个简单的接口，它能被为了底层存储方法而实现。你能够方便地实现你自己的BeanFactory，尽管很少用户需要。最为常用的定义是： .XmlBeanFactory： 可解析简单直观的定义类和命名对象属性的XML结构。 我们提供了一个DTD来使编写更容易。 .ListableBeanFactoryImpl：可提供解析存放在属性文件中的bean定义，和可通过编程创建BeanFactories。 每个bean定义可能是一个POJO(通过类名和JavaBean初始属性定义)，或是一个FactoryBean。FactoryBean接口添加了一个间接层。通常，这用于使用AOP或其他方法来创建代理对象：例如，添加了声明性事务管理的代理。(这在概念上和EJB侦听相似，但在实践中实现更简单。) BeanFactories能在一个层次结构中可选择性的参与，根据来自祖先的继承定义。这使在整个应用中公共配置的共享成为可能，虽然个别资源，如controller servlets，也拥有他们自己的独立的对象集合。 这种使用JavaBeans的动机在的第四章中有描述，在TheServerSide网站上的有免费的PDF(). 通过BeanFactory概念，Spring成为一个倒置控制的容器。(我非常不喜欢container这个术语，因为它使人联想到重量级容器，如EJB容器。Spring的BeanFactory是一个可通过一行代码创建的容器，并且不需要特殊的部署步骤。) 位于倒置控制背后的概念是在Hollywood原则中经常表述："Don’t call me, I’ll call you." IoC将控制职责搬进了框架中，并脱离应用代码。涉及到配置的地方，意思是说在传统的容器体系结构中，如EJB，一个组件可以调用容器并问“我需要它给我做工作的对象X在哪里?”；使用IoC容器则只需指出组件需要X对象，在运行时容器会提供给它。容器基于方法名作出这种说明，或可能根据配置数据如XML。 倒置控制的几个重要好处。如： . 因为组件不需要在运行时间寻找合作者，所以他们可以更简单的编写和维护。在Spring的IoC版本里，组件通过暴露JavaBean的setter方法表达他们依赖的其他组件。这相当于EJB通过JNDI来查找，EJB查找需要开发人员编写代码。 . 同样原因，应用代码更容易测试。JavaBean属性是简单的，Java核心的，并且容易测试：仅编写一个包含自身的Junit测试方法用来创建对象和设置相关属性即可。 . 一个好的IoC实现隐藏了强类型。如果你使用一个普通的factory来寻找合作者，你必须通过类型转换将返回结果转变为想要的类型。这不是一个主要问题，但是不雅观。使用IoC，你在你的代码中表达强类型依赖，框架将负责类型转换。这意味着在框架配置应用时，类型不匹配将导致错误；在你的代码中，你无需担心类型转换异常。 . 大部分业务对象不依赖于IoC容器的APIs。这使得很容易使用遗留下来的代码，且很容易的使用对象无论在容器内或不在容器内。例如，Spring用户经常配置Jakarta Commons DBCP数据源为一个Spring bean：不需要些任何定制代码去做这件事。我们说一个IoC容器不是侵入性的：使用它并不会使你的代码依赖于它的APIs。任何JavaBena在Spring bean factory中都能成为一个组件。 最后应该强调的是，IoC 不同于传统的容器的体系结构( 如EJB), 应用代码最小程度的依靠于容器。这意味着你的业务对象可以潜在的被运行在不同的IoC 框架上-或者在任何框架之外-不需要任何代码改。 以我的经验和作为Spring用户，过分强调IoC给应用代码带来的好处是不容易的。 IoC不是一个新概念，但是它在J2EE团体里面刚刚到达黄金时间。 有一些可供选择的IoC 容器: notably, Apache Avalon, PicoContainer 和 HiveMind. Avalon 不会成为特别流行的，尽管它很强大而且有很长的历史。Avalon是相当的重量级和复杂的，并且看起来比新的IoC解决方案更具侵入性。 PicoContainer是一个轻量级而且更强调通过构造器表达依赖性而不是JavaBean 属性。

Html5 工程师需要学什么？

HTML5属于前端开发，相对来说比较简单，更加适合没有计算机基础或者是偏向于设计爱好的同学来学习，但是需要学习什么，需要掌握哪些技能，作为准备踏入HTML5前端工程师的你，知道几点?

需要的技能：H5前端工程师主要具备的技术能力包括Web UI(网站设计)设计能力、网页编写和网页动态效果能力和基本编程的能力，企业需要既懂网页设计，又具备编程能力的技术人员，只要具备以上三方面的能力，就能够基本满足企业对H5前端工程师的招聘需求。

具备的能力：1.追究问题发生的根源，很多人只知道埋头苦写CSS和Java，但如果问他们为什么要添加某些标签或是删掉某些标签，他们往往答不上来，只知道一删掉就会导致页面乱套。所以应该多花一些时间来找出原因，看似这样的工作方式会比较费时费力，但前期保障做足，保证会节省你更多的未来时间。2. 学会预见浏览器发展趋势，前端相对来讲不那么在你的掌控当中，不同用户的平台或者是设备都是前端永恒的话题，你的代码需要掌握这一切。3.阅读文档规范，当同一份代码在两个或者是更多的浏览器的渲染效果不同时，你应该花更多的时间来确定哪个效果是正确的，并应该以此来作为标准写代码，解决方案当然也是友好的。

当然看到这里，也许你对HTML5前端工程师有了一定的了解，看到这里也许你的方向会更加明确，也许会更加惧怕，但只要确定好方向，一定可以成功转变为一名合格的HTML5前端工程师。

关于APIS币项目目标是什么和API是什么币的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。