在20世纪60年代后期引入的面向对象技术引起了一场革命。到20世纪80年代后，面向对象的技术已经成为了行业的主流，其原因多种多样：面向对象不仅简化了界面的开发，而且也提供了一种更加灵活、简单数据处理方法，这种方法从根本上改变了应用程序的构建方法。不再像关系型数据库一样用死板的二维表格来表示数据，对象技术使用类对数据进行描述。一个对象是一个类的实例，就像一颗特定的橡树是橡树类的实例一样。

对象技术使用继承方案，使得类是按等级设计的。“橡树”类能够从更加普遍的类“树”继承数据结构和数据行为。

对象技术能够更好地描述我们所见的世界，面向对象的语言已经被证实在大多数编程领域更加通用。他们使得编程语言更加接近自然语言和多数软件开发领域的主流思想。面向对象是一个新的典范，它的影响将持久而深远。

面向对象的特性很快被添加到各种成熟的语言中，并因此成就了一些语言，如C++。新的面向对象的开发环境出现了，包括Visual Basic，Visual C++，PowerBuilder，Delphi，以及Caché。尽管面向对象的技术在高级开发环境下受到了广泛支持，它还是需要花一定的时间形成正规的课程。而且还需要花更长的时间来构建一个真正的基于对象的世界——我们目前还没有到达这样一个阶段。

万维网上对象技术的发展

随着万维网（World Wide Web）转变为交换各种信息的手段，面向对象的编程语言Java成为Web开发者的最爱。基于C++，Java能够用来创建可以在浏览器执行的小程序（Java applets）。

Sun为了促进Java的发展免费提供Java环境。在短短几年内，成百上万的Java环境被复制下载，Java渗透到世界的每一个角落。同时Java引发了更多的面向对象语言，如JavaScript，C＃以及Jscript。Internet的发展也培育了一些新的面向对象语言像Perl和PHP。现在的开发者使用面向对象的技术已经是理所当然的了。

对象的崛起

对象技术影响了软件开发的各个方面。对象建模已经占领了应用建模的市场，标准UML建模方法独占鳌头。

20世纪90年代，面向对象中间件产品的出现为面向对象的应用提供了安全交流服务。当1998年JMS（Java Messaging Serivce）的出现，使得中间件市场向前跨越了一大步。JMS定义了一整套消息传递的应用编程接口（APIs），使得经认证的J2EE应用必须引入JMS服务器。这进一步强化了标准化进程，大大降低了中间件的费用，提供了编写企业范围基于对象的应用程序平台。

XML和Web服务

1998年，HTML，专门用于网页设计的标识语言，经过进一步发展并标准化，创造出了XML（扩展的标识语言）。XML提供了一整套语法，能够用于创建与存储在数据库中定义相似的自定义数据格式，可以。有了XML，程序能够把定义附加在数据上，能够交换数据和数据含义。XML能够使得有特定标准的数据模型（如发票或者购买订单）的定义能够在公司内部或者公司之间进行数据交换。XML引发了Web服务的兴起——在不需要客户定制的情况下，程序能够与其他程序立即交互。现在出现了两种Web服务环境——J2EE和.NET。像SQL一样，XML为程序员提供了获取数据的标准，但XML同时还提供了一种在对象层定义数据的标准语言。XML和对象技术一样迅速成长。结果，数据对象的新标准和基于XML的新的开发产品出现了。

对象数据库——缺失的一环
与软件开发各个环节中对象技术的快速应用形成鲜明对比，对象数据库直到现在才开始逐渐被人们所接受。对象数据的迟缓行动原因有很多。

早期的对象语言没有考虑数据存储。程序在内存数据上工作，数据作为文件存储，当程序下次运行时数据也作为文件被读取。这种方法使得应用程序之间不可能共享数据，数据的恢复、管理、扩展几乎不可能。

目前在市场上已经有大量的面向对象数据库产品：Versant，Objectivity，ObjectStore，GemStone等等。他们为面向对象的开发环境提供了相应的数据存储。这些产品满足了最初的热情，甚至这些产品被期望能够打造一个新的数据库市场——甚至可能成为市场的领袖。

但不幸的是，这些对象数据库出现时，关系型数据库供应商已经积聚了巨大的动力，并占领了大量市场份额。在标准的SQL接口下，访问关系型数据库的面向对象程序很容易写。相反，多数早期的对象数据完全不提供SQL接口，不适合任何查询应用程序。结果，对象数据库在商业上没有建立坚实的基础。他们在应用领域只创建了一个小市场来管理和存储复杂对象如CAD/CAM，电信业、多媒体、人工智能，模拟金融设备、病人诊治跟踪系统以及科学应用。

数据库市场从未特别关注过对象数据库，直到对象定义语言XML出现，这种情况才有所改变，促进了对象数据库的再次呈现，因为他们管理XML定义的数据是最合适的。使用XML，必然会提高存储复杂数据的需求，将进一步引发对象数据库的复苏。

03年9月份InfoWorld公布了一项开发员调查，其中有一个惊奇的结果，89.2％的被调查者说他们使用关系型数据库，52％的被调查者说他们使用面向对象或者XML数据库。当问及有关存储数据的类型时，40.2％的人说他们存储持久的对象，58.9％的人说他们存储XML数据，89％的人说他们存储关系型数据。Baroudi Bloor相信对象数据库比我们想象的用的更加广泛，随着需求的激增，将进一步扩大市场份额。

InfoWorld的调查还显示了面向对象的语言是新应用开发的主流选择。我们相信这些统计数字反映了当今开发员面临的困境。他们需要与他们一直使用的面向对象语言有更好协调性的数据库，但他们有需要关系型数据库所提供的查询能力。

关系型数据库——另一半是如何存在的
只要有程序，就会有数据。IT行业最早具有商业价值之一的就是数据管理。自动的数据管理意味着业务能够扩展、具有竞争力，没有它就不可能。所以毫无疑问机智的商业技术员很早把目光聚集在数据管理市场。在对象数据库产生之前的20年，E.F Codd博士提出的关系型理论找到了出路，开发出商业的关系型数据库产品。在80年中期，在IT领域有一个宗教式的信仰，认为数据的所有理论问题都已经解决，实践的问题也会随之解决。然而，很明显，事实并不是这样。

关系型数据库把数据存储在简单的两维表中，这是一种表达大量数据的有效方法，而且程序员也易于理解。关系型数据库使用SQL建立了一种标准的数据访问语言。关系型数据库有一个逻辑和物理形式清楚的结构，这种结构使得应用程序对数据结构是透明的，而且在很多商业应用程序中工作的很好。

然而，关系理论的基础之一是数据和使用数据的程序能够而且应该是相互独立的。这与对象技术的整个理念是不一致的。对象技术鼓励设计者使用对象而不是表来思考数据。对象和使用对象的方法是不可能彼此分开的。

如果把汽车作为一个复杂的对象来考虑。当你使用汽车时，你使用一辆完整的汽车，作为一个东西——一个对象来使用。与汽车相联系的有很多动作（也就是面向对象术语中的方法）。你驾驶汽车，进行换档，发信号，开车灯，等等。如果汽车是一个对象，这些动作就是对象的方法，他们对汽车而言是基础性的。这些动作独立于汽车的想法是荒唐的。当你把你的车停在车库，你把它作为一个东西来存储。而不是分别在车库中的某些地方存放方向盘，转换器，信号器，车灯。数据和它相对应的处理过程也不能而且也不应该被隔离开来。在对象数据库中他们是不分开的。

事实上，这两种观点各有优缺点。有些处理过程确实是独立于数据的。尤其是访问大量数据的查询操作。简单的查询就是根据一些标准来选取数据，而不关心数据是什么，也不用关心数据是如何被组织的，只要它能快速的被取出就可以了。查询是独立于数据的，但对象方法则不是。

关系型数据库的局限性

关系型数据库有比我们想的更多的局限性。存储和表示一些相当普通的数据结构也是非常困难的。试想一条公交线路——简单，有序的一组站点。关系型数据库以无序的方式存放表，只有创建一个特殊的索引，才能提取有序的数据。对象数据库就没有这个问题，它有有序的数组，不需要索引——这种索引是因为关系数据结构的局限性而要求创建的人工索引。

另一个简单的例子是产品用料单——在制造系统中记录一个产品和它的组件。组件自身也许还有组件，组件的组件还有组件，以此类推。一个关系型数据表不能表达这种部件与部件的部件之间的关系。而这些关系却是重要的数据。查询一个产品数据库，它的所有组件应该是一目了然的。关系型数据库结构使得开发员花费很多的工作来回答这种简单的查询，非常的复杂、困难。与这个例子类似的例子：地图和它的路、河、路标；网站和它的页面、链接以及图像。实际上，搜集的信息越复杂，等级层次和交叉层次就越多，在简单二维表的关系型数据库就越不可能表达清楚。对象数据库没有这样的限制，事实上，他们就是为了解决这个问题而设计的。

虽然关系型数据库发展成熟，在这十年中发展也非常迅猛，但我们还听到一些项目因为所使用的关系数据的性能不是很好而导致失败。通常，是因为关系型数据库物理上存储数据的方法导致的。对开发员而言，为了集合他们所需的数据，他们常常不得不进行这个表与另一个表联接，再与另外的表联接，然后再与另一个表联接。为了提取数据，数据库运行优化程序来判断提取数据的最好方法，然后再提取数据。这样的处理常常要花费很长的时间，结果就大大影响了性能。尽管关系型数据库优化器已经改善了运行时间，但他们还需要比对象数据库更多的处理时间。

关系型数据库和“阻抗不匹配”障碍

关系型数据的一个问题是他们所使用的基本数据结构是一种二维形式的表。在关系理论中，数据应该被组织成规范的表——也就是数据应该按唯一的方式组织，使得程序员能够消除冗余，确保数据变化的一致性。这种设计技术的引入确保了关系表中的数据是一组独立的、通过键相关的数据。这种技术来自集合论的数学理论，但问题是集合论不能表达数据之间所有的关系和结构。

以规范的方式存储数据常常要求程序员在存入数据库之前分解对象，并且重新组织数据，但要使用它是，在使用SQL查询（多重连接）。就像在车库中存储车时，你把它的门、椅子、轮子等等分别卸下来存放。这是非常耗时的，而是也是没有任何意义的。

但面向对象的语言占主导地位时，问题就越发明显了。这个问题通常被称为对象－关系不匹配障碍。这个问题是由于面向对象语言和关系型数据库使用语言的方法不同导致的，结果这个问题只能有程序员自己来解决。事实上，大多数关系型数据库在使用的时候并不是完全规范的，但即使是这样，不匹配问题还是发生，对编程人员的工作造成了很大的困难。我们可以估计使用关系型数据库的面向对象开发员25％到40％的时间用于编写代码来解决对象与关系表的匹配问题。

也许这个根本性困难产生了对对象数据的强烈需求，但多数对象数据库也有一个很大的问题：他们对SQL的支持很少。而许多软件工具需要SQL接口，尤其是商业智能应用。甚至有SQL接口的对象数据库也不能创建用于管理商业智能应用所产生的这类查询机制。

对象－关系数据库

关系型数据库的供应商并没有忽视对象的出现。显然，规范复杂数据是没有意义的。举个极端的例子，如果你要规范一个位图形式的图像——是一系列的象素表示的——你最终要得出一个表，这个表的行是象素，并且主键的属性反映他们的顺序。很明显最好是把这个数据作为一个对象来存储。

他们提出了“对象－关系”数据库的创意，这个创意中保留了关系型数据库的结构，但允许关系表中的列含有一个复杂的对象。这些对象能够捆绑处理复杂数据的处理过程（一种存储过程）。并且SQL能够允许调用与关系型等同的“对象方法”。

这种方法是对数据关系理论的一种嘲弄，事实上，它完全忽略了这个理论，但又允许复杂数据（地图，矢量图，图表，甚至整个表格）被定义为一个项目存放在关系结构中。因此，这些功能被实现并商品化。Informix称它的嵌入过程为DateBlades，Oracle称之为Cartridges。

对象－关系数据库成为存储数据时对象数据库的一种替代方案，但根本的问题它并没有解决。对象－关系数据库还是受不匹配障碍的困扰。

对象数据库与关系型数据库
实践中，对象数据库相对于关系数据库有显著的优势。

他们能更快的运行事务处理程序
他们能够更有效的处理对象
他们能够提供更好的开发效率
他们能够管理更容易
在一些例子中，因为是性能方面的原因，用对象数据库能够替代关系型数据库。在不能存储复杂对象的大规模的业务处理程序中确实是这样的——也许有些人会认为这个必然是关系型数据库的领地。

对象数据库最大的性能优势是他们不必像关系型数据库一样在数据使用之前先连接数据。他们就以使用数据的方式存储数据，这就大大提高了性能。对象数据库能够使用缓存技术，这样就使得在请求数据时数据就已经存放在内存中了。对象数据库在抽取数据时几乎不需要进行优化。

但开发一个新的系统，处理复杂数据如文档、复杂图表、网页、多媒体等的需求不断增长时，这些需求对象数据库可以很好的满足。

当今面向对象的前景
在软件开发的各个方面使用对象技术的人群都在不停地增长。甚至在最后一个领域——数据库——尽管对象数据库还没有取代关系型数据库，这种增长也是十分显著的。InfoWorld报告说52%的开发员在使用对象数据库或者XML数据库（通常也是一种对象数据库）。还有一些选择混合形式的数据库，这种数据库能比较容易地使用对象结构。随着新应用程序开发过程中Web接口成为一个必不可少地部分，Web服务成为应用系统交互地一种可行的机制，构建一个面向对象的世界似乎是当今的现实。

03年9月的InfoWorld调查也显示了使用面向对象语言的程序员几乎无处不在。事实上，尽管有些人宣称使用C语言，但是面向对象的语言还是成为当今90％的程序员的选择。调查也显示了程序员比较喜欢基于Web的应用，易用的对象编程和脚本语言。随着越来越多的有着正规培训的软件工程师进入市场，面向对象技术将成为新应用开发的唯一选择。

结论
也许关系型数据库将继续领导数据库市场，而对象数据库在市场上只占有一席之地。也许对象数据库将进一步提升市场份额，因为他们能够处理当今使用的复杂的数据。然而，我们认为还有其他的可能：数据库技术可能发展出一种真正的混合型产品，这种产品能提供关系接口和对象接口双重优势。我们知道这是有可能的。事实上，至少有一种产品，来自InterSystems的Caché，就是这样一个产品。（Caché数据库，描述他自己时，既不是说是关系型的，也不是说是对象的，而是后关系型数据库）。数据库供应商——不管他们的产品是属于关系型还是对象型——都会朝着这个方向前进的。

这种混合产品的方法包括给数据库提供一个映射层，程序员通过映射层访问数据库。映射层应该基于开发的标准以解决不匹配障碍问题。数据库的调用能够用SQL完成，也可以直接请求对象类或者类的集合。映射层能够把这些调用转换为对数据库的物理数据请求以抽取数据。这种方法将消除不匹配的障碍。

改变任何一种数据类型都是非常大的挑战。对象数据库需要快速索引能力，以从庞大的数据集中抽取数据。在这方面做得比较好的关系型数据库使用位图索引技术，但数据一旦更新，这些索引就需要重新建立。因为这个原因，很少有对象数据有这个功能。对关系数据库而言，他们需要提供更加灵活的物理数据结构。在发展过程中，关系型数据库倾向于在物理层使用表。他们需要放弃这种不灵活的限制，允许存储多种数据结构。数据库使用者将获得最大的收益。试想把对象数据库的优势和关系型数据库的优势整合在一起：

好的处理性能
复杂数据管理
管理简便
快速开发
灵活的查询功能
标准的数据访问接口
更好地适用于商业智能应用
这种混合产品使使用一个数据库引擎成为可能，并且所有应用只有一个数据定义集。Baroudi Bloor相信企业界需要混合式的数据库产品。供应商们必须放弃他们对关系数据库宗教式的倾向，转向更具优势的混合式的数据库，否则的话他们将陷于COBOL以及打孔卡片的深渊而不能自拨。

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

由于把大多数数据都放在内存中进行操作，使得内存数据库有着比磁盘数据库高得多的性能表现，这一特点非常契合电信企业运营支撑系统对实时性的要求。

电信业的竞争正在全方位地展开，这种竞争必然带来新的价值链模式以及新的计费方式，这些变化对目前的电信运营支撑系统是一个挑战。比如，多种业务的计费环节将不再是单一的按照时长或通信距离收取费用，而可能是根据时长、内容、使用量等多种参数的组合计费。为了应对这些挑战，电信企业先后引入了内存数据库，以提高后台数据管理的实时性、精确性和灵活性。

内存数据库

内存数据库，顾名思义就是将数据放在内存中直接操作的数据库。相对于磁盘，内存的数据读写速度要高出几个数量级，将数据保存在内存中相比从磁盘上访问能够极大地提高应用的性能。同时，内存数据库抛弃了磁盘数据管理的传统方式，基于全部数据都在内存中重新设计了体系结构，并且在数据缓存、快速算法、并行操作方面也进行了相应的改进，所以数据处理速度比传统数据库的数据处理速度要快很多，一般都在10倍以上。内存数据库的最大特点是其“主拷贝”或“工作版本”常驻内存，即活动事务只与实时内存数据库的内存拷贝打交道。显然，它要求较大的内存量，但并非任何时刻整个数据库都存放在内存，即内存数据库系统还是要处理I/O。

尽管内存数据库已不是传统磁盘数据库的概念，但是内存数据库本质上还是数据库，它也具有一般数据库的基本功能:

■ 永久数据的管理，包括数据库的定义、存储、维护等;

■ 完成各种数据操作，如查询处理、存取、完整性检查;

■ 事务管理，包括调度与并发控制等;

■ 对存取的控制和安全性检验;

■ 具有数据库的可靠性恢复机制。

相对于利用程序开发手段调用内存处理来说，内存数据库自有其优势。首先，内存数据库是产品化的数据库管理软件，极大缩短了开发周期; 其次，内存数据库有着开放的平台和接口，程序开发和移植更加灵活便捷，也便于维护和二次开发; 第三，可以通过使用统一的SQL语言方便地查询内存中的数据; 最后，能在数据库中保障数据的安全性和完整性。这些优势，对于快速部署和简化维护都是有利的。

但内存数据库也有其不可避免的缺点，比如: 不容易恢复，内存数据库中的数据不总是永久的，为了保证实时，也不一定是一致和绝对正确的，有的是短暂的，有的是暂时不一致或非绝对正确的。

电信企业一直是内存数据库的主要用户，近几年来，随着计算机硬件技术的飞速发展、内存容量的提高、价格下跌以及计算机进入64位时代操作系统后可以支持更大的地址，为内存数据库的实现提供了可能。目前内存数据库在电信行业的应用也日趋成熟，已有超过90G的电信系统案例，能自动扩展内存空间，不需要重启数据库，提供ESOL自定义存储过程，支持多线程，开发效率高，程序移植容易等等。下面以两个例子来介绍内存数据库的应用。

电信计费数据的加载

电信的二次批价和实时累账是计费系统中的两个必备功能。所谓二次批价是相对于一次批价来说的。一次批价是按照国家标准资费来进行价格计算，比如: 全球通每分钟本地通话为0.4元，在一次批价完成后，会根据这个用户的套餐进行再一次的计算。以北京全球通用户接听4分钟的电话为例，一次批价完成后，这条话单的价格是1.6元，如果这个用户参加了10元包月接听套餐，那么在二次批价后，这次通话的费用就为0元。一次批价是用于各大运营商之间结算的，而二次批价是针对用户个人的。

实时累账是将用户从每月1号到目前为止的所有费用累加起来，也就是用户目前可以通过10086查到截止到前一天的实时话费。累账值可以帮助用户控制高额话费或是供用户即时查询消费信息。

二次批价和实时累账过程涉及用户资料、用户套餐等与用户相关的信息，电信支撑系统在开始批价时必须加载这些数据。稍大一点的省级运营商的这些数据就会超过1000万条，计费处理模型也由于套餐的组合、产品的组合以及不同的优惠规则变得相当复杂，加载这部分数据对系统而言是一笔不小的开销，这就使得现在的计费处理速度比较慢，而且很难做到对数据的实时更新。内存数据库的引入在一定程度上解决了这个问题。

在计费二次批价过程中数据量最大的是详单数据，这部分数据不用放在内存数据库中，每处理完一个话单文件或达到设定的提交记录数时直接操作磁盘数据库，不会影响系统性能。最急切的是将用户资料、套餐、营业套餐和计费套餐对应关系数据、计费套餐模型数据及用户累计数据放到内存数据库中，这部分数据查询操作远比数据新增和更新操作要频繁。除了这些数据外，当然还有应用需要的其他数据也都可以加载到内存数据库。

在采用内存数据库后，用户通过营业部或客户查询实时话费的时候完全可以做到实时，比目前只能提供查询到前一天的实时话费在业务上有了质的飞跃。因为系统在处理这部分数据时查询流程和以前的完全一样，但系统省去了以往内存中的数据和磁盘数据库数据同步的环节，所以就能做到了实时查询。对于信控来说也同样，以往系统在累完账后要按照一定周期刷新信控数据，这就存在一个时间差，不能够完全做到实时。

而采用内存数据库后，信控可以直接取得内存数据库中的实时话费累计表中的数据，完全实现实时预警、停机。二次批价和累账中采用内存数据库后，对防欺诈、收入保障系统也有相当大的好处，这样能够充分保证运营商的切身利益。

另外，在采用内存数据库后，整体提高了系统批价、累账的处理速度，大大缓解访问磁盘数据库的压力，提高数据查询、修改、删除的效率，也为后付费和预付费的融合提供了可能。

电信计费数据的同步

电信营业数据和计费系统中的数据总是在不断的变化中，这就涉及内存数据库中的数据和磁盘数据库数据的同步问题（为了描述清楚，这里的磁盘数据库以Oracle DB为例来说明）。数据同步包括两部分: 从内存数据库到Oracle DB数据同步和从Oracle DB到内存数据库的同步。

1. Oracle DB到内存数据库同步

这部分数据同步采用增量表的方式，营业系统或CRM新增或更新的数据将生成到Oracle的增量表中，计费后台程序先到这些增量表中查询数据。如果能在这些增量表中查到数据就把这些数据更新到内存数据库对应表中，如果查不到，就直接从内存数据库中直接查询，从而保证了数据的完整性和实时性。由于增量表的数据量一般会很小，所以这部分操作不会影响系统的性能。

2. 内存数据库到Oracle DB同步

由于Oracle的计费后台批价、累账数据几乎都加载到了内存数据库中，所以Oracle数据库对应的数据表将主要用于对内存数据库的数据备份。

用户最新的实时话费等信息都保存在内存数据库中，实时话费查询将直接连接到内存数据库中查询，保证用户得到最新的费用信息。信控也直接从内存数据库查询数据，因此对Oracle中的这部分数据已经没有实时性的要求。这时内存数据库到Oracle的同步可以由应用程序生成文件，定时地往Oracle数据库中同步备份，或者采用Oracle 存储过程在系统相对空闲时间段进行数据导入就可以了。

总体而言，由于市场与技术的快速发展，电信业务在不断扩充，其运营和管理不断优化，传统的一些支撑系统的架构已经逐渐不能满足日益增长的业务要求和客户需求，引入一些新的技术来解决我们生产中遇到的问题是必然的。比如采用内存数据库来代替以前的共享内存技术，使得原来在内存中不标准的东西，包括接口、格式和管理都标准化了。

内存数据库只是多种新技术中有代表性的一种而已，只要解放思想、选用得当，完全可以在投入不大的情况下克服系统中的瓶颈，以最小的代价获得最大回报。

二次批价内存数据操作流程图

链接一:内存数据库与传统数据库的异同

传统的数据库系统是关系型数据库，开发这种数据库的目的，是处理永久、稳定的数据。关系数据库强调维护数据的完整性、一致性，但很难顾及有关数据及其处理的定时限制，不能满足工业生产管理实时应用的需要，因为实时事务要求系统能较准确地预报事务的运行时间。

对磁盘数据库而言，由于磁盘存取、内外存的数据传递、缓冲区管理、排队等待及锁的延迟等使得事务实际平均执行时间与估算的最坏情况执行时间相差很大，如果将整个数据库或其主要的“工作”部分放入内存，使每个事务在执行过程中没有I/O，则为系统较准确估算和安排事务的运行时间，使之具有较好的动态可预报性提供了有力的支持，同时也为实现事务的定时限制打下了基础。这就是内存数据库出现的主要原因。

内存数据库所处理的数据通常是“短暂”的，即有一定的有效时间，过时则有新的数据产生，而当前的决策推导变成无效。所以，实际应用中采用内存数据库来处理实时性强的业务逻辑处理数据。而传统数据库旨在处理永久、稳定的数据，其性能目标是高的系统吞吐量和低的代价，处理数据的实时性就要考虑的相对少一些。实际应用中利用传统数据库这一特性存放相对实时性要求不高的数据。

在实际应用中这两种数据库常常结合使用，而不是以内存数据库替代传统数据库。

链接二:几款内存数据库产品

■ Oracle TimesTen

Oracle TimesTen是Oracle从TimesTen公司收购的一个内存优化的关系数据库，它为应用程序提供了实时企业和行业（例如电信、资本市场和国防）所需的即时响应性和非常高的吞吐量。Oracle TimesTen可作为高速缓存或嵌入式数据库被部署在应用程序层中，它利用标准的 SQL 接口对完全位于物理内存中的数据存储区进行操作。

■ Altibase

Altibase是一个在事务优先的环境中提供高性能和高可用性的软件解决方案。它提供高性能、容错能力和事务管理能力，特别适合通信、网上银行、证券交易、实时应用和嵌入式系统领域。Altibase能够最大限度地发挥数据库服务系统的潜力，增强数据服务器的处理能力。Altibase支持客户端/服务器架构或嵌入式架构。其中客户端/服务器架构非常适合一般的应用。而嵌入式架构将应用程序嵌入到数据库服务器，适合于有高时效要求的实时系统。

■ eXtremeDB

eXtremeDB实时数据库是McObject公司的一款特别为实时与嵌入式系统数据管理而设计的数据库，只有50K到130K的开销，速度达到微秒级。eXtremeDB完全驻留在主内存中，不使用文件系统（包括内存盘）。eXtremeDB采用了新的磁盘融合技术，将内存拓展到磁盘，将磁盘当做虚拟内存来用，实时性能保持微秒级的同时，数据管理量在32BIT下能达到20G。

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

Hibernate是面向对象应用和关系数据库间的桥梁，这种作用将随着对象数据库的广泛应用而消失。

不可忽视Hibernate在一定程度上起到了换存数据的作用，类似内存数据库的作用。

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
<script type="text/javascript">
/*People Class*/
var People=function(height,weight){
 this.height=height;
 this.weight=weight;
};
People.prototype.say=function(){
 return "Hi,My Height "+this.height+"cm & Weight "+this.weight+"kg.";
};
/*Man Class*/
var Man=function(height,weight){
 this.height=height;
 this.weight=weight;
};
Man.prototype.say=People.prototype.say;
Man.prototype.manSay=function(){
 return "I am Man!"+"  "+this.say();
};
/*Test*/
var p=new People(170,160);
alert(p.say());
var man=new Man(175,165);
alert(man.say());
alert(man.manSay());

</script>
</head>
<body>

</body>
</html>

可能说这是JavaScript继承不太准确，但本人认为这种方式可以实现继承类似的功能。

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

        Webservice 作为一项新的技术出现在我们面前，它的出世是用于解决在不同的平台下的应用的协同的。目前几乎每家厂商都要去开发Webservice 应用，然而如果缺乏对Webservice更深的了解，不能很好的在设计阶段处理好一些重要的问题，那么最终完成的系统必然是效率低下，没有可靠性的产品。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

<beans>
   <description>
       Spring Bean Configuration Sample
  </description>
  <bean
   id="TheAction" 
   class="net.xiaxin.spring.qs.UpperAction"
   singleton="true" 
   init-method="init" 
   destroy-method="cleanup" 
   depends-on="ActionManager">

   <property name="message">
      <value>HeLLo</value> 
   </property>  

<property name="desc">
      <null/>
   </property>

   <property name="dataSource">
       <ref local="dataSource"/> 
   </property>
  </bean>
  <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="jndiName">
        <value>java:comp/env/jdbc/sample</value>
    </property>
  </bean>
</beans>

1、 id
Java Bean在BeanFactory中的唯一标识，代码中通过BeanFactory获取JavaBean实例时需以此作为索引名称。

2、 class
Java Bean 类名

3、 singleton
  指定此Java Bean是否采用单例（Singleton）模式，如果设为“true”，则在BeanFactory作用范围内，只维护此Java Bean的一个实例，代码通过BeanFactory获得此Java Bean实例的引用。反之，如果设为“false”，则通过BeanFactory获取此Java Bean实例时，BeanFactory每次都将创建一个新的实例返回。

4、init-method
   初始化方法，此方法将在BeanFactory创建JavaBean实例之后，在向应用层返回引用之前执行。一般用于一些资源的初始化工作。

5、destroy-method
   销毁方法。此方法将在BeanFactory销毁的时候执行，一般用于资源释放。

6、 depends-on
   Bean依赖关系。一般情况下无需设定。Spring会根据情况组织各个依赖关系的构建工作（这里示例中的depends-on属性非必须）。只有某些特殊情况下，如JavaBean中的某些静态变量需要进行初始化（这是一种BadSmell，应该在设计上应该避免）。通过depends-on指定其依赖关系可保证在此Bean加载之前，首先对depends-on所指定的资源进行加载。

7、 <value>
   通过<value/>节点可指定属性值。BeanFactory将自动根据Java Bean对应的属性类型加以匹配。下面的”desc”属性提供了一个null值的设定示例。注意<value></value>代表一个空字符串，如果需要将属性值设定为null，必须使用<null/>节点。

8、 <ref>
  指定了属性对BeanFactory中其他Bean的引用关系。示例中，TheAction的dataSource属性引用了id为dataSource的Bean。BeanFactory将在运行期创建dataSource bean实例，并将其引用传入TheAction Bean的dataSource属性。

下面的代码演示了如何通过BeanFactory获取Bean实例：
   InputStream is = new FileInputStream("bean.xml");
   XmlBeanFactory factory = new XmlBeanFactory(is);
   Action action = (Action) factory.getBean("TheAction");

此时我们获得的Action实例，由BeanFactory进行加载，并根据配置文件进行了初始化和属性设定。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

有一段时间没写日记啦，本来是想把这些框框架架都写个例子总结一下....

然而，这个东西越想越没什么可写的...

我们需要自己的东西，而不是简单照搬！

尽管我曾经为这些欣喜若狂，感染我的是它的思想，它的文化，它的气质...

而不是因为我会用了这些东西，可以自豪了，可以骄傲了...

我们需要自己的东西，自己的架构，API是我们写的标准中文的  架构...

我们需要自己的东西.....

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

缓存类型 Types in [MEMORY、LRU、FIFO、OSCACHE]

Ibatis中实现com.ibatis.sqlmap.engine.cache. CacheController  [inteface]

public void flush(CacheModel cacheModel);/*Flush*/

public Object getObject(CacheModel cacheModel, Object key);/*Get*/

public Object removeObject(CacheModel cacheModel, Object key);/*Remove*/

public void putObject(CacheModel cacheModel, Object key, Object object);/*Add */

public void configure(Properties props);/*Set*/

如果Ibatis自带的缓存策略不适合你的具体应用，可以实现CacheController  Interface来实现自己的方法

一：MEMORY  内存缓存，和Java内存管理机制类似分为[SOFT、WEAK、STRONG]

 <property name="reference-type"  value="SOFT|WEAK|STRONG"/>

SOFT:

只有当目前内存不足的情况下，JVM 在垃圾回收时才会收回其包含的引用（JVM 并不是只有当内存不足时才启动垃圾回收机制，何时进行垃圾回收取决于各版本JVM 的垃圾回收策略。如某这垃圾回收策略为：当系统目前较为空闲，且无效对象达到一定比 率时启动垃圾回收机制，此时的空余内存倒可能还比较充裕）

WEAK:

WeakReference 比SoftReference 在引用的维持性上来看更加微弱。无需等到内存不足的情况，只要JVM 启动了垃圾回收机制，那么WeakReference 所对应的对象就将被JVM 回收。相对SoftReference 而言，WeakReference 被JVM 回收的概率更大。

STRONG:

所引用的对象几乎无法被回收重用。它指向的对象实际上已经被JVM 销毁（finalize 方法已经被执行），只是暂时还没被垃圾回收器收回而已。PhantomReference 主要用于辅助对象的销毁过程，在实际应用层研发中，几乎不会涉及。

其控制器com.ibatis.sqlmap.engine.cache.memory.MemoryCacheController

private MemoryCacheLevel cacheLevel = MemoryCacheLevel.WEAK;

private Map cache = Collections.synchronizedMap(new HashMap());/*Map 存储结构*/

二：LRU 最近最少使用算法

<property name="size" value="Number"/>

其控制器com.ibatis.sqlmap.engine.cache.lru.LruCacheController

private Map cache<Collections.synchronizedMap(new HashMap())>;
private List keyList<Collections.synchronizedList(new LinkedList())>;

Put算法

  public void putObject(CacheModel cacheModel, Object key, Object value) {
    cache.put(key, value);
    keyList.add(key);
    if (keyList.size() > cacheSize) {
      try {
        Object oldestKey = keyList.remove(0);
        cache.remove(oldestKey);
      } catch (IndexOutOfBoundsException e) {
        //ignore
      }
    }
  }

Get算法

  public Object getObject(CacheModel cacheModel, Object key) {
    Object result = cache.get(key);
    keyList.remove(key);
    if (result != null) {
      keyList.add(key);
    }
    return result;
  }

使用[沉淀]技巧把最近最少使用的沉淀到最前面

FIFO：

<property name="size" value="Number"/>

其控制器com.ibatis.sqlmap.engine.cache.fifo.FifoCacheController

  public void putObject(CacheModel cacheModel, Object key, Object value) {
    cache.put(key, value);
    keyList.add(key);
    if (keyList.size() > cacheSize) {
      try {
        Object oldestKey = keyList.remove(0);
        cache.remove(oldestKey);
      } catch (IndexOutOfBoundsException e) {
        //ignore
      }
    }
  }

public Object getObject(CacheModel cacheModel, Object key) {
    return cache.get(key);
  }

OSCACHE：使用oscache自带的配置文件oscache.properties

# CACHE IN MEMORY
#
# If you want to disable memory caching, just uncomment this line.
#
 cache.memory=false  /*是否缓存到内存中，一般为true，这里为测试缓存到磁盘*/

# CACHE KEY
#
# This is the key that will be used to store the cache in the application
# and session scope.
#
# If you want to set the cache key to anything other than the default
# uncomment this line and change the cache.key
#
 cache.key=__oscache_cache

# USE HOST DOMAIN NAME IN KEY
#
# Servers for multiple host domains may wish to add host name info to
# the generation of the key.  If this is true, then uncomment the
# following line.
#
# cache.use.host.domain.in.key=true

# CACHE LISTENERS
#
# These hook OSCache events and perform various actions such as logging
# cache hits and misses, or broadcasting to other cache instances across a cluster.
# See the documentation for further information.
#
# cache.event.listeners=com.opensymphony.oscache.plugins.clustersupport.JMSBroadcastingListener,
#                       com.opensymphony.oscache.extra.CacheEntryEventListenerImpl,
#                       com.opensymphony.oscache.extra.CacheMapAccessEventListenerImpl,
#                       com.opensymphony.oscache.extra.ScopeEventListenerImpl

# CACHE PERSISTENCE CLASS
#
# Specify the class to use for persistence. If you use the supplied DiskPersistenceListener,
# don't forget to supply the cache.path property to specify the location of the cache
# directory.
#
# If a persistence class is not specified, OSCache will use memory caching only.
#
cache.persistence.class=com.opensymphony.oscache.plugins.diskpersistence.DiskPersistenceListener

# CACHE OVERFLOW PERSISTENCE
# Use persistent cache in overflow or not. The default value is false, which means
# the persistent cache will be used at all times for every entry.  true is the recommended setting.
#
# cache.persistence.overflow.only=true

# CACHE DIRECTORY
#
# This is the directory on disk where caches will be stored by the DiskPersistenceListener.
# it will be created if it doesn't already exist. Remember that OSCache must have
# write permission to this directory.
#
# Note: for Windows machines, this needs \ to be escaped
# ie Windows:
cache.path=c:\\myapp\\cache
# or *ix:
# cache.path=/opt/myapp/cache
#
# cache.path=c:\\app\\cache

# CACHE ALGORITHM
#
# Default cache algorithm to use. Note that in order to use an algorithm
# the cache size must also be specified. If the cache size is not specified,
# the cache algorithm will be Unlimited cache.
#

cache.algorithm=com.opensymphony.oscache.base.algorithm.LRUCache/*缓存淘汰算法*/

# cache.algorithm=com.opensymphony.oscache.base.algorithm.FIFOCache
# cache.algorithm=com.opensymphony.oscache.base.algorithm.UnlimitedCache

# THREAD BLOCKING BEHAVIOR
#
# When a request is made for a stale cache entry, it is possible that another thread is already
# in the process of rebuilding that entry. This setting specifies how OSCache handles the
# subsequent 'non-building' threads. The default behaviour (cache.blocking=false) is to serve
# the old content to subsequent threads until the cache entry has been updated. This provides
# the best performance (at the cost of serving slightly stale data). When blocking is enabled,
# threads will instead block until the new cache entry is ready to be served. Once the new entry
# is put in the cache the blocked threads will be restarted and given the new entry.
# Note that even if blocking is disabled, when there is no stale data available to be served
# threads will block until the data is added to the cache by the thread that is responsible
# for building the data.
#
# cache.blocking=false

# CACHE SIZE
#
# Default cache size in number of items. If a size is specified but not
# an algorithm, the cache algorithm used will be LRUCache.
#
cache.capacity=1000 /*Size*/

# CACHE UNLIMITED DISK
# Use unlimited disk cache or not. The default value is false, which means
# the disk cache will be limited in size to the value specified by cache.capacity.
#
# cache.unlimited.disk=false

# JMS CLUSTER PROPERTIES
#
# Configuration properties for JMS clustering. See the clustering documentation
# for more information on these settings.
#
#cache.cluster.jms.topic.factory=java:comp/env/jms/TopicConnectionFactory
#cache.cluster.jms.topic.name=java:comp/env/jms/OSCacheTopic
#cache.cluster.jms.node.name=node1

一般推荐使用OSCACHE这个[专业]缓存插件

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

一：网上http://www.apache.org/上下载Ibatis包

和Ibatis关联的几个包

commons-dbcp.jar

log4j.jar

cglib.jar

oscache.jar

commons-logging.jar

有时候可能各个版本不同会产生错误

二：配置Ibatis主配置文件

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE sqlMapConfig     
    PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN"     
    "http://ibatis.apache.org/dtd/sql-map-config-2.dtd">

<sqlMapConfig>

  <settings cacheModelsEnabled="true"<!--使用缓存-->
     enhancementEnabled="true"
     lazyLoadingEnabled="true"
     maxRequests="32"
     maxSessions="10"
     maxTransactions="10"
     useStatementNamespaces="false"
  />
  <transactionManager type="JDBC" commitRequired="false"><!--使用连接池-->
    <dataSource type="JNDI">
      <property name="DataSource" value="ibatis"/>
    </dataSource>

<!--
    <dataSource type="SIMPLE">
      <property name="JDBC.Driver" value="org.hsqldb.jdbcDriver"/>
      <property name="JDBC.ConnectionURL" value="jdbc:hsqldb:."/>
      <property name="JDBC.Username" value="sa"/>
      <property name="JDBC.Password" value="sa"/>
    </dataSource>
     -->

  </transactionManager>

  <sqlMap resource="com/myspackage/***.xml"/><!--SQL映射配置文件-->

</sqlMapConfig>

此主配置文件可以放到class下的任何位置，只要在得到此配置文件时候的标明URI即可。

com/myspackage/***.xml 格式如下

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE sqlMap     
    PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN"     
    "http://ibatis.apache.org/dtd/sql-map-2.dtd">

<sqlMap namespace="Account">

  <typeAlias alias="Account" type="com.mydomain.domain.Account"/>

   <resultMap id="MapResult" class="HashMap">
    <result property="id" column="ACC_ID"/>
    <result property="firstName" column="ACC_FIRST_NAME"/>
    <result property="lastName" column="ACC_LAST_NAME"/>
    <result property="emailAddress" column="ACC_EMAIL"/>
  </resultMap>
  <cacheModel id="CacheID" type="OSCACHE"><!--[OSCACHE,MEMORY,LRU,FIFO]-->
     <flushInterval hours="24"/>
  <property name="size" value="1000" />
  </cacheModel>

  <select id="selectId" parameterClass="int" resultClass="Map"><!--返回一个Map类型的VO-->
    select
      *    from SomeTable
    where SomeTable_id = #id#
  </select>

  <insert id="insertAccount" parameterClass="Account"><!--使用AccoutVO作为in parameter,也可以使用Map-->
    insert into ACCOUNT (
      ACC_ID,
      ACC_FIRST_NAME,
      ACC_LAST_NAME,
      ACC_EMAIL
    values (
      #id#, #firstName#, #lastName#, #emailAddress#
    )
  </insert>

  <update id="updateAccount" parameterClass="Account">
    update ACCOUNT set
      ACC_FIRST_NAME = #firstName#,
      ACC_LAST_NAME = #lastName#,
      ACC_EMAIL = #emailAddress#
    where
      ACC_ID = #id#
  </update>

  <delete id="deleteAccountById" parameterClass="int">
    delete from ACCOUNT where ACC_ID = #id#
  </delete>

</sqlMap>

三：DAO

import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import com.ibatis.common.resources.Resources;
import com.mydomain.domain.Account;

import java.io.Reader;
import java.io.IOException;
import java.util.List;
import java.sql.SQLException;

public class SimpleExample {

  private static SqlMapClient sqlMapper;

  static {
    try {
      Reader reader = Resources.getResourceAsReader("SqlMapConfig.xml");
      sqlMapper = SqlMapClientBuilder.buildSqlMapClient(reader);
      reader.close();
    } catch (IOException e) {
      throw new RuntimeException("Something bad happened while building the SqlMapClient instance." + e, e);
    }
  }

  public static List selectAllAccounts (java.util.Map map) throws SQLException {
   List list=(List)sqlMapper.queryForObject("selectAllAccounts", map);
    return list;
  }

  public static Account selectAccountById  (int id) throws SQLException {
    return (Account) sqlMapper.queryForObject("selectAccountById", new Integer(id));
  }

  public static void insertAccount (Account account) throws SQLException {
    sqlMapper.insert("insertAccount", account);
  }

  public static void updateAccount (Account account) throws SQLException {
    sqlMapper.update("updateAccount", account);
  }

  public static void deleteAccount (int id) throws SQLException {
    sqlMapper.delete("deleteAccount", new Integer(id));
  }

}

四：使用此DAO

Map map=new HashMap();
map.put("id",request.getParameter("id"));
List list=SimpleExample .queryForList("selectAllAccounts",map);

追加几个包

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

    营销有4P（产品Product、价格Price、地点Place、促销Promotion），至于后来的4C和4R等都是概念的演绎，对企业最有用的还是那4个P。而如何组合这4P是重要的，所以我们把营销研究从4P的要素研究，发展到组合的研究。如何组合4P？国内对这方面的探讨非常少，倒是《孙子兵法》颇有论述。其实三十六计本身并不重要，重要的是它们之间的动态组合和使用条件，而使用的原则就是模式。[br]

    我认为：营销有且只有四种模式。以前是把4P看成是在一个平面上的四个点，现在我们把它变成锥体：其中一个P是战略性的，其它3P围绕这一个P来组合。这种超静力结构就非常有力。由此，我们就可以把营销模式分为分别以产品、渠道、价格和促销为核心的模式，其它林林总总的营销招术，比如：服务营销、娱乐营销等，都可以归到这里面来。

一、以产品为核心的营销模式

    以产品为核心进行营销策略的组合。典型的如：IT行业和医药行业。在IT行业，没有分销的概念，只有代理商的概念，渠道扁平、混乱、无管理而且扎堆，但只要能满足市场的变化就行。因为IT行业遵循摩尔定律，产品更新非常快，要求渠道快速响应。随着新品推出，旧货马上跟进降价。企业十之七八的营销费用是用于新产品推广，而不是投入渠道和包装等。

    在这种模式下，营销组织以产品经理为主，营销的策源地也来自产品经理。

    摩托罗拉在进中国之前12个月才研发一个新品，现在在中国是4个月研发一个新品。由于其技术能力强，所以营销以产品为核心，渠道很简单，全国有几个大的代理商就可以了，不用深度分销。摩托罗拉的这种模式会对竞争对手造成致命的杀伤力，但这种模式中国大部分企业做不了，因为中国企业大都没有核心技术，所以做不到以产品为核心。

    三星手机采用的也是以产品为核心的营销模式，针对竞争对手诺基亚、摩托罗拉在中国市场产品更新速度相对较慢的特点，不断推出手机新品，与中国消费者物质生活水平同步，获得消费者的热切关注。三星每年要开发几百种新产品，平均每隔3个月，就会推出针对不同目标客户定位的新产品，这使三星的品牌保持了旺盛的生命力，不断巩固在消费者心中的形象。

    反观2001～2003年，TCL等国内手机厂家也是类似三星手机的做法，目标客户也基本一致，但具体运作上只是“形似神不似”。最大的问题就是在产品技术上、个性化的外观设计上不能做出实质上的推陈出新，而且产品不合格率太高，也严重地损害了品牌形象。

    所以，企业要根据自己能力的不同，选择不同的模式。我们都知道“设计的三星”和“技术的索尼”，而相同行业的企业所选的营销模式之所以不同，正因为各自所掌握的能力和资源不一样。

二、以价格为核心的营销模式

    以价格为核心进行营销策略的组合，产品、渠道和促销策略都以价格战为核心。典型的企业比如：格兰仕。过去一台微波炉3000元一台，现在卖300元还送很多东西。格兰仕发动了一波又一波的价格战，每波的降价幅度都在30%以上。但是其新产品的技术差异并不大，大都是功能的重新组合，是人为制造差异化，为的是配合价格战。而它的渠道也是扁平化，直接控制终端。广告也是围绕价格展开的，这是典型的以价格为核心的模式。

     这种模式对资源和能力有如下要求：要有大规模的生产能力，行业要有规模经济性，规模曲线非常明显。格兰仕是从国外搬来的生产线，同时也拿来订单，通过扩大生产规模来降成本，实现双赢，提高了整个产业的效率。

    以价格为核心的模式本身有合理性，但不可用过了头。

    采用以价格为核心的营销模式，其营销组织的管理重心较高，营销权力在总部，下面人执行好就行了。销售队伍不大，渠道结构扁平。目标市场明确，通过价格张力扩大市场份额，比如：价格降5%，市场份额能扩大10%，企业就赢了。

    由于中国企业的能力就是依靠廉价人力进行低成本制造，还没有能力建营销组织和渠道，也没有能力进行大规模的促销，销售队伍能力也不足，所以许多中小企业和行业挑战者经常采用这种模式。

三、以促销为核心的营销模式

    以促销为核心进行营销策略的组合，其余3P围绕促销展开。在这种模式下，营销组织和营销的核心动力来自于产品推广。大部分保健品和部分药品，以及一些化妆品采用这种模式。比如：安利就是以市场推广为核心展开产品市场策略的组合，广告不多，渠道也看不见。

    应用这种模式要求企业的企划能力和品牌传播能力比较强，有管理能力和激励能力。产品虽然有一定差异性，但并不需要许多原创的差异，有组合差异和功能差异性就行。一般情况下，这种模式需要产品的目标人群比较精准，比如：脑白金定位中老年，安利定位于职业白领等。

    这种模式下，营销组织模式有多样性，营销重心比较高。需要统一企划，策划重心高，执行重心却比较低，走两极，营销组织非常简单，人力资源质量要求高，组织管控体系要求也高。

    例如：脑白金的营销就是采用了以促销为核心的模式。脑白金作为单一品种的保健品，以极短的时间迅速启动市场，在2－3年内创造了十几亿元的销售奇迹。首先是因为其目标人群和形象的精准定位。针对中老年消费者，脑白金诉求的概念就是“年轻态”、“健康品”。诉求原理是脑白金使人体进入年轻态，年轻态可以解决衰老导致皮肤老化、老人斑、心脏病、高血压、免疫力下降、性能力下降等。定位问题确定后，脑白金以软性文章和宣传册为主要手段，利用媒体和终端，有节奏地进行“空中”和“地面”有效协同的立体整合传播，同时，“脑白金”作为商标，也阻止了竞争对手进入。

    虽然很多人对脑白金铺天盖地的电视广告轰炸、随处可见的软文宣传冲击，以及“收礼只收脑白金”的喧嚣褒贬不一，但是从商业运作和营销管理角度来说，脑白金还是提供了很多好的经验和做法。

四、以渠道为核心的营销模式

    以渠道为核心进行营销策略的组合，典型的就是和君创业倡导的深度营销。深度营销相当于有协同性的兵团来打那些散兵。

    这是中国大部分企业采用的模式，因为：第一，中国大部分企业没有产品竞争力；第二，产品低成本程度相似；第三，高空传播对资源的要求高，大部分企业没完成原始积累，高举高打的传播方式做不了，而人员推广的方式需要产品可以高加价，这种方式中国企业也做不了。

    随着消费者不断理性，这个模式会慢慢失效。中国市场大而且多元化、城乡差异也大，流通发展滞后于上游产业，渠道发育弱，这使得渠道发力能取得很好的竞争力。在中国现在情况下，既有传统渠道，又有现代渠道，多渠道混杂并存，你能在复杂情况之下，构建渠道协同就能取得优势，典型的如：家电业的创维、TCL等。它们很早开始做三四级市场，农民富了，它们就成长起来了。

    应用这种模式的企业需要对营销本土化有非常深刻的理解，对渠道结构、消费者特性都非常了解，也需要有很好的组织管理能力，有清晰的战略，组织管控能力比较强。从制造来讲，要有快速研、产、销一体化响应能力。因为产品没有差异性，靠渠道取胜，所以营销组织重心低，遵循就近和对等原则：谁代表市场谁拥有权力，谁配置资源谁承担责任。区域市场瞬息万变，所以要有具备洞察力和执行力的队伍。这个队伍要求部分精英与大量地方武装，又需要指挥者比较精明。

    应用这种模式的娃哈哈的品牌玩不过可口可乐，价格也不便宜，却做成了中国第一，靠的就是渠道能力。再比如山东六合的饲料，靠的就是渠道贴近养殖户。这种案例非常多，短期内也最厉害。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

FormPanelTest.html

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN" dir="ltr">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
<title>FormTest</title>
<link rel="stylesheet" type="text/css" href="../../resources/css/ext-all.css"/>
<script type="text/javascript" src="../../adapter/ext/ext-base.js"></script>
<script type="text/javascript" src="../../ext-all.js"></script>

<script language="javascript" type="text/javascript">

Ext.onReady(function(){
 function checkNameFn(v,o){/*这个validation方法是修改后的，Ext2.0中不支持参数o*/
  function successFn(v,p){
   if(!eval(v.responseText)){
    o.markInvalid();
   };
   
  };
  function failureFn(v,p){
   o.markInvalid();
  };

  Ext.Ajax.request({
     url: 'http://127.0.0.1:8080/CsssWeb/checker.jsp',
     success: successFn,
     failure: failureFn,
     params: { checkValue: v }
  });
  return true;
 }
 
 var nameField = new Ext.form.NumberField({
  fieldLabel : 'ID',
  name: 'numField',
  width : 120,
  value : 0,
  validationEvent : 'onblur',
  allowBlank : false
 });
 var nameField1 = new Ext.form.TextField({
  fieldLabel : '名称',
  name: 'nameField',
  width : 120,
  allowBlank : false,
  validationEvent : 'onblur',
  validator : checkNameFn
 });
 
 var formPanel=new Ext.form.FormPanel({
        labelWidth: 75, // label settings here cascade unless overridden
        frame:true,
        title: 'Simple Form',
        bodyStyle:'padding:10px 10px 10px',
  labelAlign : 'right',
        width: 350,
        defaults: {width: 230},
  items : [
   nameField,
   nameField1
  ],
  buttonAlign : 'center',
  buttons: [
   {
    text : '提交',
    listeners : {
     click : function(){formPanel.getForm().doAction('submit',{
         url:'http://127.0.0.1:7001/CsssWeb/jsonData.jsp',
         waitMsg:'Saving Data...',
         clientValidation : false
        });
       }
    }
   },
   {
    text : '重填',
    listeners : {
     click : function(){formPanel.getForm().getEl().dom.reset();}
    }
   }
  ]

 });
 formPanel.render(Ext.getBody());
 
});

</script>
</head>

<body>

</body>

</html>

checker.jsp

<%=true|false%>

可以在此Jsp中加入判断逻辑最后返回 true|false。

JsonData.jsp

返回Json数据，数据格式如下

{
 success : false|false,
 errors  : {
  nameField: "Client not found",
  numField: "Client not found"
 }|null
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

第一个阶段：直接Html页面交换，直接执行CGI返回已经格式化好的HTML页面供浏览器解析展示。

                  由于这种基于请求响应返回整体HTML格式数据方式虽简单但很笨重不灵活，出现了很多替代的方法

                  内嵌<ifream width="0" height="0"></ifream>用JavaScript控制请求指定数据，

                  使用<script language="javaScript" src="" id="">用JavaScript控制Src属性请求指定数据(这种方法其实在Ext中的ScriptTagProxy中使用)

第二个阶段：随着Ajax的发展，Xml成了数据交换及转换的中间工具，但XMl的生成和解析都属重量级的(本人认为)特别是在客户端是用JavaScript解析在性能和速度上有些欠缺。

                  中间方法，把XML中间格式话的东西都去掉剩下ROOT结点和中间JavaScript的Text，可以减少解析时间以及减少网络流量.

第三阶段：JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式，是依据过渡方法把根结点的东西也去掉，Client在收到数据对象时 直接调用eval函数来转换成JavaScript对象

               这种方式减少了网络流量提高了Client的解析效率和减低了解析复杂度，但仍需要Server端对数据进行Json的转换输出，尽管目前有些免费的Java组件可以完成这些操作，但效率还是比较低特别是在类结构未知的情况下....

第四阶段（推测）：Java对象直接序列化即实现Serializable接口，把Java对象写到Client，由JavaScript对其解析实现对象复活

以上观点仅仅是个人观点和看法

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

<html>
<head>
<link rel="stylesheet" type="text/css" href="../../resources/css/ext-all.css" />
<script type="text/javascript" src="../../adapter/ext/ext-base.js"></script>
<script type="text/javascript" src="../../ext-all.js"></script>
<script language="javascript" type="text/javascript">

Ext.onReady(function(){

 var action = new Ext.Action({
  text: 'Click Me',
  handler: function(){
   Ext.Msg.alert('ClickTitle', 'You Clicked me.');
  }
 });
 var btn = new Ext.CycleButton({
  showText: true,
  prependText: 'View as ',
  items: [{
   text:'text only',
   checked:true
  },{
   text:'HTML'
  }],
  changeHandler:function(btn, item){
   Ext.Msg.alert('Change View', item.text);
  }
 });
 var panel = new Ext.Panel({
  title: 'Actions',
  width:500,
  height:300,
  tbar: [
   action,
   {
    text: 'Action Menu',
    menu: [action]
   }
  ],
  items : [btn],
  renderTo : Ext.getBody()
 });

 
})
</script>
</head>

<body>

</html>

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

TreePanelTest.html

<html>
<head>
<link rel="stylesheet" type="text/css" href="../../resources/css/ext-all.css" />
<script type="text/javascript" src="../../adapter/ext/ext-base.js"></script>
<script type="text/javascript" src="../../ext-all.js"></script>
<script language="javascript" type="text/javascript">

Ext.onReady(function(){
 var tree = new Ext.tree.TreePanel({
    animate : true,
    autoScroll : true,
    loader : new Ext.tree.TreeLoader({
      baseParams : {
       myName : "Dangzhao"
      },
      clearOnLoad : false ,
      dataUrl : "http://127.0.0.1:8080/CommonWeb/jsonData.jsp" ,
      listeners : {
       beforeload : function(){alert("beforeLoad")},
       load : function(){alert("load")},
       loadexception : function(){alert("loadexception")}
      },
      preloadChildren : false,
      requestMethod : "POST"
     }),
    el : 'tr',
    enableDD:true
   });
 var root = new Ext.tree.AsyncTreeNode({
     text: 'Tree Root',
     draggable:false,
     id:'0'
    });
 tree.setRootNode(root);
 tree.render();
})

</script>
</head>

<body>
<div id="tr" style="width:300;height:400;top:40;left:120;position:absolute "></div>

</body>
</html>

jsonData.jsp

<%@page import="java.util.*" %>
[{
 id: 1,
 text: 'A Folder Node',
 leaf: false
},{
 id: 2,
 text: 'A leaf Node',
 leaf: true
}]
<%
Enumeration enm=request.getHeaderNames();
while(enm.hasMoreElements()){
    String key=(String)enm.nextElement();
    System.out.println(key+":"+request.getHeader(key));
}
Map p=request.getParameterMap();
Iterator it=p.keySet().iterator();
while(it.hasNext()){
    String key=(String)it.next();
    System.out.println(key+":"+((String[])p.get(key))[0]);
}
%>

System.out Information

Accept:*/*
Accept-Language:zh-cn
Referer:file://E:\ext-2.0.2\ext-2.0.2\examples\grid\TreePanelTest.html
x-requested-with:XMLHttpRequest
Content-Type:application/x-www-form-urlencoded
Accept-Encoding:gzip, deflate
User-Agent:Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727)
Host:127.0.0.1:7001
Content-Length:22
Connection:Keep-Alive
Cache-Control:no-cache
Cookie:2=1; 74=1; JSESSIONID=LvpgLBNZ!-832179795
node:0
myName:Dangzhao

Show 一下Ext Tree的魅力

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

<html>
<head>
<link rel="stylesheet" type="text/css" href="../../resources/css/ext-all.css" />
<script type="text/javascript" src="../../adapter/ext/ext-base.js"></script>
<script type="text/javascript" src="../../ext-all.js"></script>
<script language="javascript" type="text/javascript">

var myData=[
  [0,"MysTitle_0","Dangzhao_0"],
  [1,"MysTitle_1","Dangzhao_1"],
  [2,"MysTitle_2","Dangzhao_2"],
  [3,"MysTitle_3","Dangzhao_3"],
  [4,"MysTitle_4","Dangzhao_4"]
 ];

var store = new Ext.data.SimpleStore({
  autoLoad : true,
  baseParams : {
   "Action" : "Select",
   "Id" : "0"
  },
  data : myData,
  fields : [
   { name : "id" , mapping : 0},
   { name : "name" , mapping : 2},
   { name : "title" , mapping : 1}
  ],
  id : 0,
  listeners : {
   beforeload : function(){alert("beforedload")},
   load : function(){alert("load")},
   loadexception : function(){alert("loadexception")}
   //And all SimpleStore's Event
  },
  pruneModifiedRecords : false,
  remoteSort : false//because use client data so this property must false,
 });

var colum = new Ext.grid.ColumnModel([
   {id : "id" ,header : "id" , width: 160 ,sortable: true, dataIndex : 'id'},
   {header : "name" , width: 160 , editor : new Ext.form.TextField({allowBlank: false}) ,sortable: true, dataIndex : 'name'},
   {header : "title" , width: 160 ,sortable: true, dataIndex : 'title'}
 ]);

colum.setEditable(1,true);

function modify(value){
 return "<span style=\"color:red;\">" +value +"</span>";
}

var grid = new Ext.grid.EditorGridPanel({
  store : store,
  title:'Mys GridPanel',
  height:360,
        width:600,
  collapsible : true,
  animCollapse : true,
  allowDomMove : true,
  colModel : colum ,
  clicksToEdit : 2
 });

grid.on({
 afteredit : function(e){alert(e.field+" "+e.row+"  "+e.column+"  "+e.originalValue+"  "+e.value)}
});

Ext.onReady(init);
function init(){
 grid.render("gridDiv");
 
}

function checkData(){
 var xData = grid.getStore();
 var modR = xData.getModifiedRecords();
 for(i=0;i<modR.length;i++){
  var map=modR[i].modified;
  alert(map["name"]);
 }
 
}
</script>
</head>

<body>
<input type="button" onClick="checkData()" value="Check Changed Data">

<div style="position:absolute;top:40px;left:40px;width:600px;height=360px" id="gridDiv">

</div>
</body>
</html>

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

GridPanelTest.html

<html>
<head>
<link rel="stylesheet" type="text/css" href="../../resources/css/ext-all.css" />
<script type="text/javascript" src="../../adapter/ext/ext-base.js"></script>
<script type="text/javascript" src="../../ext-all.js"></script>
<script language="javascript" type="text/javascript">

var myData=[
  [0,"MysTitle_0","Dangzhao_0"],
  [1,"MysTitle_1","Dangzhao_1"],
  [2,"MysTitle_2","Dangzhao_2"],
  [3,"MysTitle_3","Dangzhao_3"],
  [4,"MysTitle_4","Dangzhao_4"]
 ];

var store = new Ext.data.SimpleStore({
  autoLoad : true,
  baseParams : {
   "Action" : "Select",
   "Id" : "0"
  },
  data : myData,
  fields : [
   { name : "id" , mapping : 0},
   { name : "name" , mapping : 2},
   { name : "title" , mapping : 1}
  ],
  id : 0,
  listeners : {
   beforeload : function(){alert("beforedload")},
   load : function(){alert("load")},
   loadexception : function(){alert("loadexception")}
   //And all SimpleStore's Event
  },
  pruneModifiedRecords : false,
  remoteSort : false//because use client data so this property must false,
 });

var grid = new Ext.grid.GridPanel({
  store : store,
  title:'Mys GridPanel',
  height:360,
        width:600,
  collapsible : true,
  animCollapse : true,
  allowDomMove : true,
  columns : [
   {id : "id" ,header : "id" ,