﻿<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:trackback="http://madskills.com/public/xml/rss/module/trackback/" xmlns:wfw="http://wellformedweb.org/CommentAPI/" xmlns:slash="http://purl.org/rss/1.0/modules/slash/"><channel><title>BlogJava--随笔分类-架构设计</title><link>http://www.blogjava.net/leekiang/category/30806.html</link><description>MDA/MDD/TDD/DDD/DDDDDDD</description><language>zh-cn</language><lastBuildDate>Sun, 11 Dec 2011 20:50:14 GMT</lastBuildDate><pubDate>Sun, 11 Dec 2011 20:50:14 GMT</pubDate><ttl>60</ttl><item><title>千万级pv高性能高并发网站架构与设计(转)</title><link>http://www.blogjava.net/leekiang/archive/2011/12/11/366106.html</link><dc:creator>leekiang</dc:creator><author>leekiang</author><pubDate>Sun, 11 Dec 2011 13:43:00 GMT</pubDate><guid>http://www.blogjava.net/leekiang/archive/2011/12/11/366106.html</guid><wfw:comment>http://www.blogjava.net/leekiang/comments/366106.html</wfw:comment><comments>http://www.blogjava.net/leekiang/archive/2011/12/11/366106.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/leekiang/comments/commentRss/366106.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/leekiang/services/trackbacks/366106.html</trackback:ping><description><![CDATA[高并发访问的核心原则其实就一句话“把所有的用户访问请求都尽量往前推”。<br /><br />
如果把来访用户比作来犯的"敌人"，我们一定要把他们挡在800里地以外，即不能让他们的请求一下打到我们的指挥部（指挥部就是数据库及分布式存储）。<br /><br />
如：能缓存在用户电脑本地的，就不要让他去访问CDN。 能缓存CDN服务器上的，就不要让CDN去访问源（静态服务器）了。能访问静态服务器的，就不要去访问动态服务器。以此类推：能不访问数据库和存储就一定不要去访问数据库和存储。<br /><br />
    
说起来很轻松，实际做起来却不容易，但只要稍加努力是可以做到的，Google的日独立IP过亿不也做到了么？我们这几千万的PV站比起Google不是
小屋见大屋了。我们还是先从我们的小屋搭起吧！哈哈！下面内容的介绍起点是千万级别的PV站，也可以支持亿级PV的网站架构。<br /><br />
高性能高并发高可扩展网站架构访问的几个层次：<br /><br />
有人会问，我们老是说把用户对业务的访问往前推，到底怎么推啊？推到哪呢？下面，老男孩就为大家一一道来。<br /><br />
第一层：首先在用户浏览器端，使用Apache的mod_deflate压缩传输，再比如：expires功能、deflate和expires功能利用的好，就会大大提升用户体验效果及减少网站带宽，减少后端服务器的压力。当然，方法还有很多，这里不一一细谈了。<br /><br />
提示：有关压缩传输及expires功能nginx/lighttpd等软件同样也有。<br /><br />
第二层：页面元素，如图片/js/css等或静态数据html，这个层面是网页缓存层,比如CDN（效果比公司自己部署squid/nginx要好，他们
更专业，价格低廉，比如快网/CC等（价格80元/M/月甚至更低）而且覆盖的城市节点更多），自己架设squid/nginx 
cache来做小型CDN是次选(超大规模的公司可能会考虑风险问题实行自建加购买服务结合)，除非是为前端的CDN提供数据源服务，以减轻后端我们的服
务器数据及存储压力，而不是直接提供cache服务给最终用户。taobao的CDN曾经因为一部分图片的次寸大而导致CDN压力大的情况，甚至对图片尺
寸大的来改小，以达到降低流量及带宽的作用。<br /><br />
提示：我们也可以自己架设一层cache层，对我们购买的CDN提供数据源服务，可用的软件有varnish/nginx/squid 等cache，以减轻第三层静态数据层的压力。在这层的前端我们也可以架设DNS服务器，来达到跨机房业务拓展及智能解析的目的。<br /><br />
    
第三层：静态服务器层一般为图片服务器，视频服务器，静态HTML服务器。这一层是前面缓存层和后面动态服务器层的连接纽带，大公司发布新闻等内容直接由
发布人员分发到各cache节点（sina,163等都是如此），这和一般公司的业务可能不一样。所以，没法直接的参考模仿，比如人人的SNS。<br /><br />
我们可以使用Q队列方式实现异步的分发访问，同时把动态发布数据（数据库中的数据）静态化存储。即放到本层访问，或通过其他办法发布到各cache节点，
而不是直接让所有用户去访问数据库，不知道大家发现了没有，qq.com门户的新闻评论多的有几十万条，如果所有用户一看新闻就加载所有评论，那数据库不
挂才怪。他们的评论需要审核（美其名约，实际是异步的方式，而且，评论可能都是静态化的或类似的静态化或内存cache的方式），这点可能就是需要
51cto.com这样站点学习的，你们打开51CTO的一篇博文，就会发现下面的评论一直都显示出来了，也可能是分页的。不过，应该都是直接读库的，一
旦访问量大，数据库压力大是必然。这里不是说51cto网站不好，所有的网站都是从类似的程序架构开始发展的。CU也可能是如此。<br /><br />
提示：我们可以在静态数据层的前端自己架设一层cache层，对我们购买的CDN提供数据源服务，可用的软件有varnish/nginx/squid 等cache。在这层的前端我们也可以架设DNS服务器，来达到跨机房业务拓展及智能解析的目的。<br /><br />
第四层：动态服务器层：php,java等，只有透过了前面3层后的访问请求才会到这个层，才可能会访问数据库及存储设备。经过前三层的访问过滤能到这层访问请求一般来说已非常少了，一般都是新发布的内容和新发布内容第一次浏览如；博文（包括微博等），BBS帖子。<br /><br />
特别提示：此层可以在程序上多做文章，比如向下访问cache层，memcache,memcachedb,tc,mysql,oracle，在程序级别
实现分布式访问，分布式读写分离，而程序级别分布式访问的每个db 
cache节点，又可以是一组业务或者一组业务拆分开来的多台服务器的负载均衡。这样的架构会为后面的数据库和存储层大大的减少压力，那么这里呢，相当于
指挥部的外层了。<br /><br />
第五层：数据库cache层，比如：memcache,memcachedb,tc等等。<br /><br />
根据不同的业务需求，选择适合具体业务的数据库。对于memcache、memcachedb ttserver及相关nosql数据库，可以在第四层通过程序来实现对本层实现分布式访问，每个分布式访问的节点都可能是一组负载均衡（数十台机器）。<br /><br />
第六层：数据库层，一般的不是超大站点都会用mysql主从结构，如：163,sina,kaixin都是如此，程序层做分布式数据库读写分离，一主（或
双主）多从的方式，访问大了，可以做级连的主从及环状的多主多从，然后，实现多组负载均衡，供前端的分布式程序调用，如果访问量在大，就需要拆业务了，比
如：我再给某企业做兼职时，发现类似的51cto的一个站点，把www服务,blog服务，bbs服务都放一个服务器上，然后做主从。这种情况，当业务访
问量大了，可以简单的把www,blog,bbs服务分别各用一组服务器拆分开，这种方式运维都会的没啥难度。当然访问量在大了，可以继续针对某一个服务
拆分如：www库拆分，每个库做一组负载均衡，还可以对库里的表拆分。需要高可用可以通过drbd等工具做成高可用方式。对于写大的，可以做主主或多主的
MYSQL REP方式，对于ORACLE来说，来几组oracle DG（1master多salve方式）就够了，11G的DG可以象mysql 
rep一样，支持读写分离了。当然可选的方案还有，mysql cluster 和oracle 的RAC，玩mysql cluster和oracle
 RAC要需要更好更多的硬件及部署后的大量维护成本，因此，要综合考虑，到这里访问量还很大，那就恭喜了，起码是几千万以上甚至上亿的PV了。<br /><br />
象百度等巨型公司除了会采用常规的mysql及oracle数据库库外，会在性能要求更高的领域，大量的使用nosql数据库，然后前端在加DNS，负载均衡，分布式的读写分离，最后依然是拆业务，拆库，。。。逐步细化，然后每个点又可以是一组或多组机器。<br /><br />
特别提示：数据库层的硬件好坏也会决定访问量的多少，尤其是要考虑磁盘IO的问题，大公司往往在性价比上做文章，比如核心业务采用硬件
netapp/emc及san光纤架构，对于资源数据存储，如图片视频，会采用sas或固态ssd盘，如果数据超大，可以采取热点分取分存的方法：如：最
常访问的10-20%使用ssd存储，中间的20-30%采用sas盘，最后的40-50%可以采用廉价的sata。<br /><br />
第七层：千万级PV的站如果设计的合理一些，1，2个NFS 
SERVER就足够了。我所维护（兼职）或经历过的上千万PV的用NFS及普通服务器做存储的还有大把，多一些磁盘，如SAS 
15K*6的，或者用dell6850，搞几组 NFS存储，中小网站足够了。当然可以做成drbd+heartbeat+nfs+a/a的方式。<br /><br />
如果能达到本文设计要求的，中等规模网站，后端的数据库及存储压力会非常小了。 象门户网站级别，如sina等， 
会采用硬件netapp/emc等等硬件存储设备或是san光纤同道，甚至在性价比上做文章，比如核心业务采用硬件netapp/emc及san光纤架
构，对于资源数据存储，如图片视频，会采用sas或固态ssd盘，如果数据超到，可以采取热点分取分存的方法：如：最常访问的10-20%使用ssd存
储，中间的20-30%采用sas盘，最后的40-50%可以采用廉价的sata。<br /><br />
象百度等巨型公司会采用hadoop等分布式的存储架构，前端在加上多层CACHE及多及的负载均衡，同样会根据业务进行拆分，比如爬虫层存储，索引层存储，服务层存储。。。可以更细更细。。。为了应付压力，什么手段都用上了。<br /><br />
    特殊业务，如人人，开心网，包括门户网站的评论，微博，大多都是异步的写入方式，即无论读写，并发访问数据库都是非常少量的。<br /><br />
    以上1-7层，如果都搭好了，这样漏网到第四层动态服务器层的访问，就不多了。一般的中等站点，绝对不会对数据库造成太大的压力。程序层的分布式访问是从千万及PV向亿级PV的发展，当然特殊的业务 还需要特殊架构，来合理利用数据库和存储。<br /><br />转自：http://bbs.chinaunix.net/thread-3626937-1-1.html<br /><img src ="http://www.blogjava.net/leekiang/aggbug/366106.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/leekiang/" target="_blank">leekiang</a> 2011-12-11 21:43 <a href="http://www.blogjava.net/leekiang/archive/2011/12/11/366106.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>Case1-分库分表-传统关系数据库(转)</title><link>http://www.blogjava.net/leekiang/archive/2011/07/10/354012.html</link><dc:creator>leekiang</dc:creator><author>leekiang</author><pubDate>Sat, 09 Jul 2011 16:24:00 GMT</pubDate><guid>http://www.blogjava.net/leekiang/archive/2011/07/10/354012.html</guid><wfw:comment>http://www.blogjava.net/leekiang/comments/354012.html</wfw:comment><comments>http://www.blogjava.net/leekiang/archive/2011/07/10/354012.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/leekiang/comments/commentRss/354012.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/leekiang/services/trackbacks/354012.html</trackback:ping><description><![CDATA[firebody 写道：<br />java 代码<br /> <br /><br />   1. 以前用hibernate主要是做一些表的映射、关联，更深层的应用就没有了，所以也没什么经验，拿个具体的情况来分析一下吧。   <br />   2.   <br />   3. 目前主要数据库是mysql，由于数据库存储限制：   <br />   4. 1、通常会把用户名和密码放一个库(负载相对较少，但也要依赖cache)。   <br />   5. 2、用户基本资料拆开多台DB按用户名或ID hash，用户扩展信息也拆开多台。   <br />   6. 3、用户积分因为太敏感，甚至使用了oracle来保证效率和稳定性(事实证明它比mysql慢。。它的C++绑定也更不稳定)。   <br />   7. 4、用户发帖是保存在文件的，数据库只保存文件链接发帖人等简单信息。   <br />   8. 5、用户之间的消息是放数据库的，当然也是按用户名hash到多台，这时候要查询我给别人的消息和别人给我的消息，就得从2个表里面查，因为你给别人的消息是按别人的用户名hash到某一台上，别人给你的是按你的用户名hash的，所以增加一条消息就得往2个库各写一条。   <br />   9.   <br />  10. 以上列举了一部分应用，当然由于库拆得比较散，基本上每个库都会有冗余字段。   <br />  11.   <br />  12. 上面这种情况下，能不能分析一下hibernate和ActiveRecord用得比较舒服的部分？   <br />  13.   <br />  14. 我在用rails的时候，ActiveRecord对于多数据库支持并不好，即使是有这样的方案也是非方的技巧。分表情况下表之间的关联基本上没法做，如果没有关联，ActiveRecord的意义只是帮我们生成SQL？   <br />  15.   <br />  16. 多级目录不是最大的问题，也不是阻碍性能的问题，俺只想找个最后的理由把RoR不适用这个项目说得更充分些。。。  <br /><br /> <br /><br />谢谢你能够提供更多的信息来参与讨论， 针对你提到的2），这样的情况下，按照我的理解，现有的java的orm框架无法针对不同库的表作映射。 activeRecord应该也没有考虑到这种情况。<br /><br />不知道你们作出的分库的依据是什么，我觉得更合理的分库依据应该根据负载压力和模块独立性来分离，比如你提到的消息发送应该是统一的模块，按照用户名hash到不同的库的话，对于业务层开发带来一定的复杂度。<br /><br />分表的话，java的orm有些策略可以绕着解决，比如用继承策略来解决。但是也是比较别扭。 不过，我更想了解的是你们作出的分表的依据是什么？<br /><br />这样的情况下，模型的关联映射在现有的orm框架下确实太牵强了，即使用了，收到的效果也是很小的，模型也会随之退化到单实体+基本类型外键的维护上来，如果让我选择的话，基本上也是选择spring的jdbcTemplate了。<br /><br />如果觉得java orm是促进开发效率的一个基本前提的话，那么在系统架构选择上，特别是数据库架构设计上，可能还要更慎重一些，因为不同于数据库底层开发，orm对于数据库的要求会有一些苛刻。为了最大化获得模型映射的效果，有一些建议不知道是否合理：<br /><br />*  在考虑访问压力的情况下，尽量按照耦合紧密的原则分库，使得某一个库的表关联能够作充分的模型映射，而对于少数的外库关联仍然需要做手工的维护，不过已经简化到最小。<br /><br />*  因为数据量大而分表的话，可以采用多态映射关联来做和多表的关联。<br /><br /><br />基本上分库主要原因都是和容量或性能有关，上亿用户，每个用户只保存一个用户名和密码，也有好几G的数据。<br /><br />为了登录部分效率考虑，用户名和密码拆到一个库中，因为这部分读取并不是特别频繁，所以目前用主备方式，备的目的是主挂掉至少不会让用户无法登录，顶多无法注册而已。<br /><br />用户的基本资料字段是固定的，但容量有些大，访问也比较频繁。之前用户没有中间层，所以拆库来提高效率。现在有中间层，拆库的意义也变了，领导不希望任何一台机器故障影响到所有用户，影响部分用户还是勉强可接受的。实际上随着用户的不断增加，即便是使用中间层也会有压力，毕竟中间层只是帮数据库挡了读取的压力，而读写比例通常情况下是10:1左右。<br /><br />用户扩展信息，这个是一对多的，一个用户可自定义不同的字段，通常是用户有修改时更新一下，读取压力并不大，同样是因为中间把把读取压力都挡掉了，但容量非常大。<br /><br />当然也考虑过如果有中间层，是不是数据库不用拆得这么细，目前也做过一些合并工作，不过意义并不大，因为所有数据库容量加起来以T计，不管是备份还是扩容甚至修复硬件故障都会影响用户很长时间，现在拆得这么细，通常一个点的故障只会影响一部分用户的一部分功能。目前硬件故障还是会经常有的，比如某国外品牌的服务器故障率非常高。扩容也是经常会有的，文件每天上传量就超过2T，每月都增加存储。数据库差不多每3月-6月都要重新拆分一次，因为容量。<br /><br /><br />分库分表最佳实践大总结<br />一、随着企业业务的增长，访问量和用户等数据的增加，传统的关系数据库已经不能满足需求 
<br /><br />分表分库就成了节省成本、和良好扩展性的必然选择 
<br /><br />网上也有很多开源的分表分库的软件,也公司自己开发实现 
<br /><br />而终其原理和步骤都无外乎三步: 
<br /><br />  即<strong>首先sql解析路由，再根据路由确定分片，然后结果集合并</strong><br /><br />  所遇到的分表分库的<strong>难点</strong>大都是对<strong>分布式事务的支持</strong>，<strong>分片后的分页
<br /><br />和排序</strong>等 
<br /><br />二、实现方式大都在两个层面： 
<br /><br />即在应用层 代表有<strong>hibernate shards,ibatis shards</strong>,<strong>guzz </strong>等 
<br /><br />和 在jdbc之下 对应用层完全透明的 如<strong>amoeba </strong><br /><br /><br />三、那么企业在分表分库的实践中该如何选择呢？ 
<br /><br />假如您是一开始就想全新的分表分库 公司没打算做自己的分表分库框架，那么推荐用guzz, 
<br /><br />这个类似于hibernate 和 ibatis的框架,很多网站都在用,缺点是技术团队需要重新学习一套框架 
<br /><br />跟旧的系统很难兼容； 
<br /><br /><br />假如您的系统很乱，分表分库规则很简单，并且数据库是mysql 
<br /><br />推荐用amoeba ，虽然有oracle版本，但目前不是很成熟； 
<br /><br /><br />假如您的技术团队一直用hibernate ,或企业现在的很多项目现在都用hibernate做的 
<br /><br />那么推荐用<strong>hibernate shards</strong>，这个类似hibernate，学习成本低，能跟
<br /><br />hibernate兼容 
<br /><br />目前国内有在hibernate  shards上封装的成功案例, 
<br /><br />缺点是list查询时遍历所有数据片，而不是根据sql规则确定的数据片。
<br /><br />这个bug及在hibernate shards上如何扩展问题我已解决,附件是解决的架构图，
<br /><br />需要源代码的或详细可以联系我； 
<br /><br /><br /><strong>ibatis shards</strong>跟<strong>hibernate shards</strong>类似，也可借鉴本人所设计的架构
<br /><br />思想 欢迎有志之士详聊
<br /><br /><br />附: 
<br />一、hibernate shards 
<br />优点： 
<br />1、实现跟其他成熟框架的集成如spring 
<br />等 
<br />2、能利用公司现有的hibernate的技术优势 
<br />3、目前国内有成功案例在hibernate  shards上封装 
<br />的商业软件 
<br />4、能够快速开发 
<br />缺点: 
<br />1、暂不支持垂直分区 
<br />2、list查询遍历所有表分片 
<br /><br /><img src ="http://www.blogjava.net/leekiang/aggbug/354012.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/leekiang/" target="_blank">leekiang</a> 2011-07-10 00:24 <a href="http://www.blogjava.net/leekiang/archive/2011/07/10/354012.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>可扩展性与可伸缩性</title><link>http://www.blogjava.net/leekiang/archive/2011/03/23/346895.html</link><dc:creator>leekiang</dc:creator><author>leekiang</author><pubDate>Wed, 23 Mar 2011 15:11:00 GMT</pubDate><guid>http://www.blogjava.net/leekiang/archive/2011/03/23/346895.html</guid><wfw:comment>http://www.blogjava.net/leekiang/comments/346895.html</wfw:comment><comments>http://www.blogjava.net/leekiang/archive/2011/03/23/346895.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/leekiang/comments/commentRss/346895.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/leekiang/services/trackbacks/346895.html</trackback:ping><description><![CDATA[我的理解：<br />可伸缩性是指系统通过增加或减少硬件水平从而提升或降低系统性能的难易程度。可伸缩性分为scale up和scale out。scale up是指提高单台服务器的硬件水平来提高系统的整体处理能力，可以调整的有CPU，存储，内存等；scale out是指通过增加系统的处理节点的方式来提高系统的整体处理能力。<br />可扩展性是软件系统应对需求增加或需求变化的能力。<br /><br />参考：<br /><a target="_blank" href="http://blog.csdn.net/chuan122345/archive/2010/01/24/5250741.aspx">软件系统的可伸缩性（scalability）设计总结</a><br /><img src ="http://www.blogjava.net/leekiang/aggbug/346895.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/leekiang/" target="_blank">leekiang</a> 2011-03-23 23:11 <a href="http://www.blogjava.net/leekiang/archive/2011/03/23/346895.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>数据库拆分</title><link>http://www.blogjava.net/leekiang/archive/2010/12/12/340379.html</link><dc:creator>leekiang</dc:creator><author>leekiang</author><pubDate>Sat, 11 Dec 2010 16:55:00 GMT</pubDate><guid>http://www.blogjava.net/leekiang/archive/2010/12/12/340379.html</guid><wfw:comment>http://www.blogjava.net/leekiang/comments/340379.html</wfw:comment><comments>http://www.blogjava.net/leekiang/archive/2010/12/12/340379.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/leekiang/comments/commentRss/340379.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/leekiang/services/trackbacks/340379.html</trackback:ping><description><![CDATA[
		<strong>
		</strong>在前面“应用拆分”主题中，我们提到了一个大型互联网应用需要进行良好的拆分，而那里我们仅仅说了”应用级别”的拆分，其实我们的互联网应用除了应
用级别的拆分以外，还有另外一个很重要的层面就是存储如何拆分的。因此这个主题主要涉及到如何对存储系统，通常就是所说的RDBMS进行拆分。<p>确定了这个小节的主题之后，我们回顾一下，一个互联网应用从小变大的过程中遇到的一些问题，通过遇到的问题来引出我们拆分RDBMS的重要性。</p><p>系统刚开始的时候，因为系统刚上线，用户不多，那个时候，所有的数据都放在了同一个数据库中，这个时候因为用户少压力小，一个数据库完全可以应付的
了，但是随着运营那些哥们辛苦的呐喊和拼命的推广以后，突然有一天发现，oh,god,用户数量突然变多了起来，随之而来的就是数据库这哥们受不了，它终
于在某一天大家都和惬意的时候挂掉啦。此时，咱们搞技术的哥们，就去看看究竟是啥原因，我们查了查以后，发现原来是数据库读取压力太大了，此时咱们都清楚
是到了读写分离的时候，这个时候我们会配置一个server为master节点，然后配几个salve节点，这样以来通过读写分离，使得读取数据的压力分
摊到了不同的salve节点上面，系统终于又恢复了正常，开始正常运行了。但是好景还是不长，有一天我们发现master这哥们撑不住了，它负载老高了，
汗流浃背，随时都有翘掉的风险，这个时候就需要咱们垂直分区啦（也就是所谓的分库），比如将商品信息，用户信息，交易信息分别存储到不同的数据库中，同时
还可以针对商品信息的库采用master，salve模式，OK，通过分库以后，各个按照功能拆分的数据库写压力被分担到了不同的server上面，这样
数据库的压力终于有恢复到正常状态。但是是不是这样，我们就可以高枕无忧了呢？NO,这个NO，不是我说的，是前辈们通过经验总结出来的，随着用户量的不
断增加，你会发现系统中的某些表会变的异常庞大，比如好友关系表，店铺的参数配置表等，这个时候无论是写入还是读取这些表的数据，对数据库来说都是一个很
耗费精力的事情，因此此时就需要我们进行“水平分区”了（这就是俗话说的分表，或者说sharding）。</p><p>上面说了很多，无非就是告诉大家一个事实“数据库是系统中最不容易scale out的一层”，一个大型的互联网应用必然会经过一个从单一DB 
server,到Master/salve,再到垂直分区（分库），然后再到水平分区（分表，sharding）的过程，而在这个过程中，Master
/salve 
以及垂直分区相对比较容易，对应用的影响也不是很大，但是分表会引起一些棘手的问题，比如不能跨越多个分区join查询数据，如何平衡各个shards的
负载等等，这个时候就需要一个通用的DAL框架来屏蔽底层数据存储对应用逻辑的影响，使得底层数据的访问对应用透明化。</p><p>出处:<a target="_blank" href="http://developer.51cto.com/art/201007/212944.htm">大型B2C网站高性能可伸缩架构技术探秘</a></p><a href="http://www.infoq.com/cn/articles/yupoo-partition-database" rel="permalink">又拍网架构中的分库设计</a><img src ="http://www.blogjava.net/leekiang/aggbug/340379.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/leekiang/" target="_blank">leekiang</a> 2010-12-12 00:55 <a href="http://www.blogjava.net/leekiang/archive/2010/12/12/340379.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>如何成为优秀的系统分析员</title><link>http://www.blogjava.net/leekiang/archive/2009/11/26/303829.html</link><dc:creator>leekiang</dc:creator><author>leekiang</author><pubDate>Thu, 26 Nov 2009 15:59:00 GMT</pubDate><guid>http://www.blogjava.net/leekiang/archive/2009/11/26/303829.html</guid><wfw:comment>http://www.blogjava.net/leekiang/comments/303829.html</wfw:comment><comments>http://www.blogjava.net/leekiang/archive/2009/11/26/303829.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/leekiang/comments/commentRss/303829.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/leekiang/services/trackbacks/303829.html</trackback:ping><description><![CDATA[
		<font size="2">NetReptile推荐 [2005-2-1]</font>
		<br />
		<font size="2">出处：来自网上</font>
		<br />
		<font size="2">作者：truely,bylsfboy等</font>
		<br />
		<font size="2"> <font><br /><br /></font></font>
		<p>
		</p>
		<p>
				<font size="2">
						<font>truely眼中的设计定义：设计的过程就是将事务处理抽象成计算机模型的过程。 <br />1. 首先要明白设计远比编程重要。 <br />2. 平时注重训练自己的思维严谨性和从全局考虑问题的能力。建立冷静思考问题的处事态度。 <br />3. 设计时（尤其是数据库设计时）不要完全被规矩约束，设计好比作诗，懂得韵律是对的，但完全被韵 律所束缚，就作不出好诗了。 <br />4. 多做设计，经常总结自己的不足之处和成功之处，向他人请教。 <br />5. 专门去找别人设计的漏洞和不足，也是提高自己设计水平的重要手段。 <br />（记住：这个好方法不要顺便外传，自己知道就行了，嘻嘻-:） <br />6. 经验是重要的，但如果观念老化而不善于总结提高，所谓的经验就成为束缚自己进步的枷锁。 <br />7. 学好数学特别是理论数学如数学分析、运筹学、数学模型等。多玩策略性经营游戏也是有益的。推荐 《帝国时代》和《模拟首都3000》以及《大富翁4》。（但不要沉陷在里面） <br />8. 根据项目情况和开发平台工具的特点确定最佳的设计方法。模块化设计方法和面向对象设计。两种设 计方法的结合使用。 <br />9. 将复杂无序的过程用模块化的方法进行分解，但要注重事务间的联系，并且用开放的眼光去设计。 <br />10. 设计时对严谨性、灵活性、开发效率、客户要求四个方面做衡量取舍。 <br />11. 设计时还要根据整个工程的进度安排和客户对软件的要求而决定是否设计得足够灵活和严谨。 <br />12. 复杂而无条理是最糟的设计，简单实用并不一定是最好的，但一定不是最坏的。（不要说我偷懒哟） <br />13. 训练自己良好的表达能力，能用清晰明确而且简单的描述表达出自己的基本思路。 <br />14. 在一个项目中建立统一的系统分析模式和文档模板，同时，一个项目中必须至少有一个人对整个系统 设计进行检查和进行全局的考虑。 </font>
				</font>
		</p>
		<p>
				<font size="2">
						<font>
								<br />再谈如何成为一个好的系统分析员？ <br /><br />bylsfboy <br /><br />系统分析员基本功： <br /><br />好的系统分析员都是从优秀的程序员中产生的，坚实的编程功底、丰富的经验是今后做系统分析的基础。 <br />没有对系统本身进行过透彻剖析过，很难领会到其中一些难以言述的精华。但并不等于好的程序员就能够 成为好的系统分析员。 <br /><br />合
理的知识结构。语言能力、文字表达能力、技术的全面性等是对系统分析员的基本要求。比如说c/s和3
层开发，如果仅仅对netscape公司的产品熟悉还不够，还需要了解比如微软等产品，并且要了解他们中产
生历史,发展思路，技术优劣，以应付各种穷追猛打的提问。但更重要的是，这是你为应用定制技术要求 的前提。 <br /><br />系统分析员思想： <br /><br />全
局观念是系统分析员必须具备的观念。如果系统分析员设计时太注重细节，往往会陷入在某个问题上纠
缠不清的泥潭。（93年，我论文指导老师的一席话影响了我随后几年对软件开发的理解----今后计算机会
越来越快，多写几行代码少写代码无关紧要，最重要的是整体；一开始就错了，某个部份编得再好，也是 没有用的） <br /><br />任务难度的预测能力 <br /><br />系
统分析员要具备快速的任务难度预测能力以及具备快速确定开发小组人员构成和任务划分的能力。（我
将这条归为思想，而不是能力）昆虫自然会长出翅膀，而思想却需要长期的浸润。要做到这点，需要大量
的思考、学习。设计远比编程重要。当今软件业的发展，各种开发工具的出现，编程已经不是什么问题，
程序员的工作某种程度上讲是将别人现成的东西拼凑堆砌起来。系统分析员要清楚的认识到，现在大多数
程序员没有学会怎么去整体的了解一个系统，有些甚至不了解编程（这不是说他们不会写代码）。可视化
的开发工具加五花八门的控件，程序员可以偷点懒了。（这可不是夸大，我好几年的管理工作，接触过大
量的程序员）基于技术，跳出框架。基于现有技术结合用户需求思考问题，设计时跳出框架。 <br /><br />系统分析员思想： <br /><br />系统分析
员要有面向用户的思想。系统分析员应当有能力将自己扮演成用户，来了解要交付的项目看起来
想什么样式，感觉想什么，从而了解用户的想法并挑选出合理部份去开发。从这个意义上说，系统分析员
才能获得有意义的见解去引导他的开发组成员。系统分析员头脑中要对项目结局有一个清楚的认识，并保
证项目不偏离方向。系统分析员要有根植于技术，高于技术思考问题的思想。纯粹的程序员通常对最终结
果考虑的不是很多，当一种新的技术在市场上出现时，他们对能否按时交付的考虑就比较少，而强烈希望
他们的计划能够建立在新的技术之上。因此，系统分析员的想法和行动要象一个用户，又要能够站在技术 的高度，成为真正的用户、程序员之间的代言人。 <br /><br />系统分析员的关键 <br /><br />获得信任。系统分析员最重要的素质是获得信任，这是成为优秀系统分析员的关键。成熟最为关键。成熟 可以为整个项目组提供正确的支持,能够理解技术怎样才能解决用户的需求。 <br /><br />系统分析员的准备工作 <br /><br />统
一的各种文档模式，这其中包括今后软件变量、字段命名规则。我推荐用pb制定的规则做基础，通过改
造成为适合自身实用的标准。统一的文档管理。统一的分析软件。比如说rose（uml太规范，国内的软件
管理水平根本用不上，只不过尽量应用，你自己对系统分析的理解有好处）
方法是思想的放映，在具体方法上就不多说了。我托人从u$a弄到几本书，用于面向对象系统开发的使
用》、《面向对象的分析》、《项目管理》等都是很不错的，推荐大家看看。 <br /><br />我在拙作"在中国没有人懂计算机"里发了点牢骚，听说挨了部份人（习惯性的）骂。其实，bbs本来就是 发泄的地方，在这里从来就罕有有内容的文章。 <br /><br />自
从"维纳斯"登陆深圳后，大家更着眼于从宏观看中国的it业了。中国it这棵小树，说实在的，长到今天
实在是不容易。一些人提出了"反对微软霸权"的口号，不少人呼唤中国"硅谷"的出现。微软的成功不是技
术的成功，更多的是商业运作的成功。中国it这棵树能长多高，取决于他所植根于的土壤。而现在的事实是，这片土壤实在是太贫瘠了！如果按我们现在的思路和
搞法，是长不成大树，更别指望能结出"微 软"，"硅谷"这样丰硕的果实。如果说，我们的软件技术落后美国十年，我们的硬件制造技术则落后美国
二十年，我们的管理水平落后美国至少三十年。而最终决定发展速率的恰恰是我们的死穴──低劣的管理
水平。低劣的管理水平的形成的原因有着深厚的背景和多方面的原因。 <br /><br />系统分析工作是解决一个问题的工作,目标是将一个对计算机应用系统的需求转化成实际的物理实现,其中 复杂就复杂在实际的面太多.在系统分析过程之中注意问以下的问题,可能会所进行的系统分析设计工作有 帮助. <br /><br />1)您所完成的系统目的是什么?注意不是功能要求,而是目的.也就是为什么要建设、为什么要现代建设。 <br /><br />2）您所完成的系统有哪些方面参与，各方面的初衷是什么？那些人可能在系统建设中起重要作用，他们 会采取什么样的态度？你对他们有多少影响力？ <br /><br />3）您的系统是否有一个明确的评价标准？最好从参与的各方面都进行考虑。 <br /><br />4）你的系统设计思想是什么？是否能够得到各方面的认可。 <br /><br />5）你对参与系统设计开发的人员了解吗？他们的特长在哪里，是否愿意与你合作，为什么？你对他们有 足够的影响力吗？ <br /><br />6）你的系统开发计划是否完善？你的计划表有明确的阶段吗？任何一阶段都应该怎样完成？如何对这一 阶段完成的情况进行评价？ <br /><br />7）你对所采用的系统开发方法以及工具是否熟悉？你的夥伴是否熟悉？ <br /><br />8）你所完成的系统是否有原型？计算机的或者物理的。 <br /><br />以上的几个问题都是在系统分析以及系统规划时涉及到的，供各位参考。 <br /><br />系统分析工作是解决一个问题的工作,目标是将一个对计算机应用系统的需求转化成实际的物理实现,其中 复杂就复杂在实际的面太多.在系统分析过程之中注意问以下的问题,可能会所进行的系统分析设计工作有帮助 <br /><br />1)您所完成的系统目的是什么?注意不是功能要求,而是目的.也就是为什么要建设、为什么要现代建设。在考虑系统目的时，我更多的侧重于系统的最终目标考虑，因为一个系统不可能一下子完美，为系统留些 余地。 <br /><br />2）
您所完成的系统有哪些方面参与，各方面的初衷是什么？那些人可能在系统建设中起重要作用，他们
会采取什么样的态度？你对他们有多少影响力？中国it行业的失败之一就是人"太年轻"，一定要有领导的
支持，否则完蛋。不要认为自己对他们会有多少影响力，即便有，也要尽可能的认为是决策者再影响他
们。在中国，一个技术员，你算老几？说到这里我很悲哀。哪些人在系统中起重要作用并弄清楚他们的态 度，这点十分关键。 <br /><br />3）您的系统是否有一个明确的评价标准？最好从参与的各方面都进行考虑。不知道这样说对不对，在系 统建设之前，对你的程序员、对你的领导要有至少不同的两种评价。 <br /><br />4）你的系统设计思想是什么？是否能够得到各方面的认可。如果高明，对领导、对程序员都采用引导， 得到认可的最好办法，就是让他们认可他们自己的想法。（我力图这样做，但做得不好，系统分析员有一 点要学会韬光养晦，忍） <br /><br />5）你对参与系统设计开发的人员了解吗？他们的特长在哪里，是否愿意与你合作，为什么？你对他们有 足够的影响力吗？软件发展到一定的程度，不是编程，不是数学，而是管理。 <br /><br />6）你的系统开发计划是否完善？你的计划表有明确的阶段吗？任何一阶段都应该怎样完成？如何对这一 阶段完成的情况进行评价？ <br /><br />7）
你对所采用的系统开发方法以及工具是否熟悉？你的夥伴是否熟悉？事实上，不是每种好的工具都要
使用，也并不一定都要他们熟练掌握。提醒诸位一句，当你将方案做得可以不依赖某个程序员，你在程序
员面前就无信任可言，因为从此程序员将受到更大的生存压力。我坚决不在公司使用rose。 <br /><br />8）你所完成的系统是否有原型？计算机的或者物理的。 <br /><br />以上的几个问题都是在系统分析以及系统规划时涉及到的，供各位参考。 <br /><br />这文章很好，我的话是："需求分析实际应该是问题分析"。含义是系统要解决的是问题。而不是用户提出 的需求。经常发现系统完成后，客户说"我的问题还没有解决"。可是，需求分析稿上的目标都搞定了。 <br /><br />既然是问题分析，所以，熟悉目标系统的知识就是必要的。甚至，可以说，一个好的系统分析员也应该是 好的业务专家。 <br /><br />我
很高兴在这里遇到许多分析高手，可以交流分析中的问题。我赞同从来的观点。在中国作分析重要的是
人气，因为中国的企业级信息系统的建设在很大程度上可以说并非确有需求，而是迫于某种压力。用户在
很多时候考虑的不是系统的长远发展，而只是短期的成果，要求开发单位在很短的时间内完成一个很大的
系统的开发，没有时间对系统进行周密的分析，在这种情况下，很多开发商就会粗分析，粗设计，尽快进
入编码阶段，这样的系统的生命周期肯定不会很长。说了这么多，只是想说，系统分析员确实应是业务和
管理专家，并且需要有很好的语言组织能力，他需要根据问题域中存在的问题去尽力说服用户，引导用户
需求，毕竟，我们是专家，如果让用户牵着鼻子走，系统不会是成功的系统。（当然了，这要建立在用户 是可引导的前提下）本人拙见。 <br /><br />在理解和分析用户的需求时，应说服用户明白：建立计算机应用系统并不是简单地用计算机代替手工劳 <br />作，它更应该是管理思想的一次革命，是现用户模式的一次升华和提高。如果系统不能高于现实，开发的系统将长期陷入需求的反复修改，其软件的生命周期也短了。 <br /><br />针对我对您的问题的理解,试着作如下一般性/理论性的回复: <br /><br />需求分析(您可以采用usecasedriven的方法进行需求分析)在明确需求分析的基础上,确定需要采用的系统分析方法(结构化/面向对象/构件式)应用您的开发团队所确定采用的分析/设计方法,进行系统分析.根据您所采用的分析方法,依次或反复进行系统设计/建模.</font>
				</font>
		</p>
		<p>
				<font size="2">
						<font>http://www.sawin.cn/doc/SA/SATech/NetReptile14.htm<br /></font>
				</font>
		</p>
<img src ="http://www.blogjava.net/leekiang/aggbug/303829.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/leekiang/" target="_blank">leekiang</a> 2009-11-26 23:59 <a href="http://www.blogjava.net/leekiang/archive/2009/11/26/303829.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>程序员与系统分析师</title><link>http://www.blogjava.net/leekiang/archive/2009/11/26/303828.html</link><dc:creator>leekiang</dc:creator><author>leekiang</author><pubDate>Thu, 26 Nov 2009 15:56:00 GMT</pubDate><guid>http://www.blogjava.net/leekiang/archive/2009/11/26/303828.html</guid><wfw:comment>http://www.blogjava.net/leekiang/comments/303828.html</wfw:comment><comments>http://www.blogjava.net/leekiang/archive/2009/11/26/303828.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/leekiang/comments/commentRss/303828.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/leekiang/services/trackbacks/303828.html</trackback:ping><description><![CDATA[作者:一详<br />
来源：http://go5.163.com/ <br /><br />
    软件开发需要综合考虑系统模型,环境因素,软件工程,网络连接,用户界面,数据流和网络。 <br /><br />
   开发即为写程序且写到非常熟练吗?程序设计也许是永远的基本技能和高度艺术,但今后决不是开发者的主业。 <br /><br />
真正需要的乃是搭积木式的系统构筑和维护,故必须对各个积木块进行深入了解。作为一个程序员不算是最辛苦,最辛苦的是系统分析员。最辛苦的不是设计和搭出
多少个系统,而是登山不止的知识获取和吸收。学习和研究已成为当今开发人员最为坚苦的一项工作, 系统的概念也已深如人心! <br /><br /> 
   这世界变化得真快,当我还在埋头查阅 NT4.0巨大的文档时,身旁有人很是令我心惊地说了一句," 别折腾了,留点儿体力给  
NT5.0 吧 !"<br /><br />  
   老实说,每当面对这样的现实,我总是有一种气喘吁吁的感觉。自从我开始接触计算机,仿佛每一天都在不停地奔跑,都在卖力地追赶。但结果总是会落后,在我还没有完全从?? 找回感觉时,我在网上又发现了??的踪迹,顿时,我感觉自己没希望了。 <br /><br />
开发是一种思路,利用别人的成果才是最高的境界,在设计时应尽量多找一些已有的核心代码。在开发中积累的应该是对问题之分析能力,对出错情况之诊断能力,
对结构之设计能力, 而不仅仅是编写代码的能力。
打好基础，计算机课程设置的都是基础课。学习其他技术的基础没有过时不过时之说，现在一些新技术往往华而不实,不能告诉你本质的东西,对大家不会有质的提
高。 <br /><br /> 
   一味讲用工具,顶多叫程序员,IT许多行业需要理解和融会贯通的理论及技术。开发工具只是辅助性的,掌握开发的思想和理论精华才是一名程序员向高层次发展的真正任务,否则只有一辈子当代码工人了! 说系统分析员编程弱恐怕有失偏颇。&gt; <br /><br />
可以说大多数好的系统分析员都是从优秀的程序成长起来的。很难想象一个对编程不甚了解的人可以划分好模块,更不要说较准确的估计出工作量和工作进度的了,
可以说系统分析是建立在程序编写上的一种学问。也
可以说是一种宏编程。我想我们不应该把做软工和做程序员对立起来。任何事物在不同的阶段都有它的表现形式。同样一个人,开始工作的一年他是程序员,一年后
他就是系统分析员了。干的活其实差别不大,只是把注意力和精力从细节转移到宏观上罢了。
我老是有一种比较天真的想法，那就是:软件工程是需要创造性思维的。 <br /><br /> 换句话说,好的软件绝不仅仅是漂亮的代码。不论从纯计算机技术角度来说,
还是其他的角度也好,没有过人的想法都是不行的。写程序不应该只考虑到: 一段代码如何。思路宽广 是一个相当重要的素质。
但是,编程编得多了,往往会自己闭塞自己的思路,把自己限制在一个比较狭小的范围内。系统分析员也许写代码根本就很弱,但是思路宽广,统筹全局的能力一定
要有,一定要看到很多程序员考虑不到的地方。因为,用户在意的往往不是某些程序员孜孜以求的东西。比如,某个Button放的位置不好,
经常比较缓慢的执行速度等等会更令用户不满。<br />http://www.sawin.cn/doc/SA/SATech/sp2sa.htm<br /><img src ="http://www.blogjava.net/leekiang/aggbug/303828.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/leekiang/" target="_blank">leekiang</a> 2009-11-26 23:56 <a href="http://www.blogjava.net/leekiang/archive/2009/11/26/303828.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>系统分析、设计——你合格吗？</title><link>http://www.blogjava.net/leekiang/archive/2009/11/26/303827.html</link><dc:creator>leekiang</dc:creator><author>leekiang</author><pubDate>Thu, 26 Nov 2009 15:52:00 GMT</pubDate><guid>http://www.blogjava.net/leekiang/archive/2009/11/26/303827.html</guid><wfw:comment>http://www.blogjava.net/leekiang/comments/303827.html</wfw:comment><comments>http://www.blogjava.net/leekiang/archive/2009/11/26/303827.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/leekiang/comments/commentRss/303827.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/leekiang/services/trackbacks/303827.html</trackback:ping><description><![CDATA[
		<span style="font-size: 10.5pt;">出处：Java夜无眠</span>
		<br />
		<span style="font-size: 10.5pt;">作者：蔡学镛</span>
		<span style="font-size: 10.5pt;">
				<font>
						<br />
				</font>
				<p style="font-size: 9pt;">
						<font>
								<strong>1、系统分析是什么？</strong>
						</font>
				</p>
				<p>
						<font>　　系统分析工作是解决一个问题的工作,目标是将一个对计算机应用系统的需求转化成实际的物理实现,其中复杂就复杂在实际的面太多.在系统分析过程之中注意问以下的问题,可能会所进行的系统分析设计工作有帮助。<br />　　<br />　　1）您所完成的系统目的是什么?注意不是功能要求,而是目的.也就是为什么要建设、为什么要现代建设。 </font>
				</p>
				<p>
						<font>　　2）您所完成的系统有哪些方面参与，各方面的初衷是什么？那些人可能在系统建设中起重要作用，他们会采取什么样的态度？你对他们有多少影响力？ </font>
				</p>
				<p>
						<font>　　3）您的系统是否有一个明确的评价标准？最好从参与的各方面都进行考虑。 </font>
				</p>
				<p>
						<font>　　4）你的系统设计思想是什么？是否能够得到各方面的认可。 </font>
				</p>
				<p>
						<font>　　5）你对参与系统设计开发的人员了解吗？他们的特长在哪里，是否愿意与你合作，为什么？你对他们有足够的影响力吗？ </font>
				</p>
				<p>
						<font>　　6）你的系统开发计划是否完善？你的计划表有明确的阶段吗？任何一阶段都应该怎样完成？如何对这一阶段完成的情况进行评价？ </font>
				</p>
				<p>
						<font>　　7）你对所采用的系统开发方法以及工具是否熟悉？你的伙伴是否熟悉？ </font>
				</p>
				<p>
						<font>　　8）你所完成的系统是否有原型？计算机的或者物理的。 </font>
				</p>
				<p>
						<font>　　以上的几个问题都是在系统分析以及系统规划时涉及到的，供各位参考。</font>
				</p>
				<p>
						<font>　　“需求分析实际应该是问题分析”。我们的软件系统要解决的是问题。而不是用户提出的需求。经常发现系统完成后，客户说“我的问题还没有解决“。可是，需求分析稿上的目标都搞定了。 </font>
				</p>
				<p>
						<font>　　既然是问题分析，所以，熟悉目标系统的知识就是必要的。甚至，可以说，一个好的系统分析员也应该是好的业务专家。 </font>
				</p>
				<p>
						<font>　　在中国作分析重要的是人气，因为中国的企业级信息系统的建设在很大程度上可以说并非确有需求，而是迫于某种压力。用户在很多时候考
虑的不是系统的长远发展，而只是短期的成果，要求开发单位在很短的时间内完成一个很大的系统的开发，没有时间对系统进行周密的分析，在这种情况下，很多开
发商就会粗分析，粗设计，尽快进入编码阶段，这样的系统的生命周期肯定不会很长。说了这么多，只是想说，系统分析员确实应是业务和管理专家，并且需要有很
好的语言组织能力，他需要根据问题域中存在的问题去尽力说服用户，引导用户需求，毕竟，我们是专家，如果让用户牵着鼻子走，系统不会是成功的系统。（当然
了，这要建立在用户是可引导的前提下） </font>
				</p>
				<p>
						<font>　<strong>2、基本素质</strong></font>
				</p>
				<p>
						<font>　　<font color="#0033ff">a、系统分析员基本功</font></font>
				</p>
				<p>
						<font>　　好的系统分析员都是从优秀的程序员中产生的，坚实的编程功底、丰富的经验是今后做系统分析的基础。 </font>
				</p>
				<p>
						<font>　　没有对系统本身进行过透彻剖析过，很难领会到其中一些难以言述的精华。但并不等于好的程序员就能够成为好的系统分析员。 </font>
				</p>
				<p>
						<font>　　合理的知识结构。语言能力、文字表达能力、技术的全面性等是对系统分析员的基本要求。比如说c/s和3层开发，如果仅仅对
netscape公司的产品熟悉还不够，还需要了解比如微软等产品，并且要了解他们中产生历史,发展思路，技术优劣，以应付各种穷追猛打的提问。但更重要
的是，这是你为应用定制技术要求的前提。 <br /> <br />　　<font color="#0033ff">b、任务难度的预测能力</font></font>
				</p>
				<p>
						<font>　　系统分析员要具备快速的任务难度预测能力以及具备快速确定开发小组人员构成和任务划分的能力。（我将这条归为思想，而不是能力）昆
虫自然会长出翅膀，而思想却需要长期的浸润。要做到这点，需要大量的思考、学习。设计远比编程重要。当今软件业的发展，各种开发工具的出现，编程已经不是
什么问题， </font>
				</p>
				<p>
						<font>　　程序员的工作某种程度上讲是将别人现成的东西拼凑堆砌起来。系统分析员要清楚的认识到，现在大多数程序员没有学会怎么去整体的了解
一个系统，有些甚至不了解编程（这不是说他们不会写代码）。可视化的开发工具加五花八门的控件，程序员可以偷点懒了。（这可不是夸大，我好几年的管理工
作，接触过大量的程序员）基于技术，跳出框架。基于现有技术结合用户需求思考问题，设计时跳出框架。  </font>
				</p>
				<p>
						<font>　　<font color="#0033ff">c、系统分析员思想</font></font>
				</p>
				<p>
						<font>　　系统分析员要有面向用户的思想。系统分析员应当有能力将自己扮演成用户，来了解要交付的项目看起来想什么样式，感觉想什么，从而了
解用户的想法并挑选出合理部份去开发。从这个意义上说，系统分析员才能获得有意义的见解去引导他的开发组成员。系统分析员头脑中要对项目结局有一个清楚的
认识，并保证项目不偏离方向。系统分析员要有根植于技术，高于技术思考问题的思想。纯粹的程序员通常对最终结果考虑的不是很多，当一种新的技术在市场上出
现时，他们对能否按时交付的考虑就比较少，而强烈希望他们的计划能够建立在新的技术之上。因此，系统分析员的想法和行动要象一个用户，又要能够站在技术的
高度，成为真正的用户、程序员之间的代言人。<br />   <br />　　<font color="#0033ff">d、系统分析员的关键</font></font>
				</p>
				<p>
						<font>　　获得信任。系统分析员最重要的素质是获得信任，这是成为优秀系统分析员的关键。成熟最为关键。成熟可以为整个项目组提供正确的支持,能够理解技术怎样才能解决用户的需求。</font>
				</p>
				<p>
						<font>3、葵花宝典 </font>
				</p>
				<p>
						<font>　　<strong>设计的过程就是将事务处理抽象成计算机模型的过程</strong><br /><br />　　1. 首先要明白设计远比编程重要。 </font>
				</p>
				<p>
						<font>　　2. 平时注重训练自己的思维严谨性和从全局考虑问题的能力。建立冷静思考问题的处事态度。 </font>
				</p>
				<p>
						<font>　　3. 设计时（尤其是数据库设计时）不要完全被规矩约束，设计好比作诗，懂得韵律是对的，但完全被韵律所束缚，就作不出好诗了。 </font>
				</p>
				<p>
						<font>　　4. 多做设计，经常总结自己的不足之处和成功之处，向他人请教。 </font>
				</p>
				<p>
						<font>　　5. 专门去找别人设计的漏洞和不足，也是提高自己设计水平的重要手段。</font>
				</p>
				<p>
						<font>　　6. 经验是重要的，但如果观念老化而不善于总结提高，所谓的经验就成为束缚自己进步的枷锁。 </font>
				</p>
				<p>
						<font>　　7. 学好数学特别是理论数学如数学分析、运筹学、数学模型等。多玩策略性经营游戏也是有益的。推荐《帝国时代》和《模拟首都3000》以及《大富翁》。（但不要沉陷在里面） </font>
				</p>
				<p>
						<font>　　8. 根据项目情况和开发平台工具的特点确定最佳的设计方法。模块化设计方法和面向对象设计。两种设计方法的结合使用。 </font>
				</p>
				<p>
						<font>　　9. 将复杂无序的过程用模块化的方法进行分解，但要注重事务间的联系，并且用开放的眼光去设计。 </font>
				</p>
				<p>
						<font>　　10. 设计时对严谨性、灵活性、开发效率、客户要求四个方面做衡量取舍。 </font>
				</p>
				<p>
						<font>　　11. 设计时还要根据整个工程的进度安排和客户对软件的要求而决定是否设计得足够灵活和严谨。 </font>
				</p>
				<p>
						<font>　　12. 复杂而无条理是最糟的设计，简单实用并不一定是最好的，但一定不是最坏的。 </font>
				</p>
				<p>
						<font>　　13. 训练自己良好的表达能力，能用清晰明确而且简单的描述表达出自己的基本思路。 </font>
				</p>
				<p>
						<font>　　14. 在一个项目中建立统一的系统分析模式和文档模板，这其中包括今后软件变量、字段命名规则等。同时，一个项目中必须至少有一个人对整个系统设计进行检查和进行全局的考虑。</font>
				</p>
				<p>
						<font>http://www.sawin.cn/doc/SA/SATech/blueski1178.htm<br /></font>
				</p>
		</span>
<img src ="http://www.blogjava.net/leekiang/aggbug/303827.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/leekiang/" target="_blank">leekiang</a> 2009-11-26 23:52 <a href="http://www.blogjava.net/leekiang/archive/2009/11/26/303827.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>软件开发论点摘抄</title><link>http://www.blogjava.net/leekiang/archive/2009/09/30/296965.html</link><dc:creator>leekiang</dc:creator><author>leekiang</author><pubDate>Wed, 30 Sep 2009 00:22:00 GMT</pubDate><guid>http://www.blogjava.net/leekiang/archive/2009/09/30/296965.html</guid><wfw:comment>http://www.blogjava.net/leekiang/comments/296965.html</wfw:comment><comments>http://www.blogjava.net/leekiang/archive/2009/09/30/296965.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/leekiang/comments/commentRss/296965.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/leekiang/services/trackbacks/296965.html</trackback:ping><description><![CDATA[1,迭代不是敏捷独有的, 这说明迭代也是一种一般性的方法<br />2,需求分析比设计更为重要。<br />3,现实世界--&gt;业务模型--&gt;分析模型--&gt;设计模型<br />  其中业务模型体现了需求，就是用例。<br />  分析模型与具体语言的实现无关<br />  设计模型以及与语言相关。<br /><img src ="http://www.blogjava.net/leekiang/aggbug/296965.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/leekiang/" target="_blank">leekiang</a> 2009-09-30 08:22 <a href="http://www.blogjava.net/leekiang/archive/2009/09/30/296965.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>契约式设计Design by Contract</title><link>http://www.blogjava.net/leekiang/archive/2009/09/03/293802.html</link><dc:creator>leekiang</dc:creator><author>leekiang</author><pubDate>Thu, 03 Sep 2009 15:42:00 GMT</pubDate><guid>http://www.blogjava.net/leekiang/archive/2009/09/03/293802.html</guid><wfw:comment>http://www.blogjava.net/leekiang/comments/293802.html</wfw:comment><comments>http://www.blogjava.net/leekiang/archive/2009/09/03/293802.html#Feedback</comments><slash:comments>1</slash:comments><wfw:commentRss>http://www.blogjava.net/leekiang/comments/commentRss/293802.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/leekiang/services/trackbacks/293802.html</trackback:ping><description><![CDATA[契约式设计的本意很简单，就是在设计和编码阶段向面向对象程序中加入断言（assertion）。而所谓断言，实际就是必须为真的假设，只有这些假设为
真，程序才可能做到正确无误。契约式设计的主要断言包括先验条件(precondition)、后验条件(postcondition)以及不变式
(invariant)：<br />●  先验条件针对方法(method)1，它规定了在调用该方法之前必须为真的条件。<br />●  后验条件也是针对方法，它规定了方法顺利执行完毕之后必须为真的条件。<br />●  不变式针对整个类，它规定了该类任何实例调用任何方法时都必须为真的条件。<br />断言应使用某种编程语言写在代码里（而不是仅仅通过文档加以声明）,只有这样：<br />1)对于程序员而言,它们才有意义,同时能够提供优质的.有用的文档.<br />2)能够在运行时对它们进行检测,更好地支持测试和调试工作.<br /><br />charon的建议。如果你对断言/防错程序不怎么熟悉，而且也搞不到那本"编程精粹"。买《Design by Contract by Example》这本书看看。如果已经熟悉了，到书店看个半小时到一小时就够了(例子只要挑个一个看，多了也没用)，权当扩充知识面了。使用的话，就当断言了，设立若干前置条件后置条件就够了，这样足以有效提高对程序的置信度；什么不动点，Frame Rules，那是理论上的东西，吃力不讨好，有闲工夫的才时候可以用用（得到的效果和付出的努力不成比例）。<br /><br />我的总结：开始看了名字以为是按约定进行设计的意思，后来大概看了看，了解了一点点，但决定不再在上面花时间了，测试驱动开发明显要更为成熟和实用。<br /><img src ="http://www.blogjava.net/leekiang/aggbug/293802.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/leekiang/" target="_blank">leekiang</a> 2009-09-03 23:42 <a href="http://www.blogjava.net/leekiang/archive/2009/09/03/293802.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>系统分析员、系统架构师、项目经理的区别(转)</title><link>http://www.blogjava.net/leekiang/archive/2009/08/17/291400.html</link><dc:creator>leekiang</dc:creator><author>leekiang</author><pubDate>Sun, 16 Aug 2009 19:34:00 GMT</pubDate><guid>http://www.blogjava.net/leekiang/archive/2009/08/17/291400.html</guid><wfw:comment>http://www.blogjava.net/leekiang/comments/291400.html</wfw:comment><comments>http://www.blogjava.net/leekiang/archive/2009/08/17/291400.html#Feedback</comments><slash:comments>1</slash:comments><wfw:commentRss>http://www.blogjava.net/leekiang/comments/commentRss/291400.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/leekiang/services/trackbacks/291400.html</trackback:ping><description><![CDATA[http://topic.csdn.net/u/20080921/13/87e0922d-2f61-442c-b9ae-d5680f6bec87.html<br />上周从开发部转来一个刚毕业的小伙子，要我面试一下看看是否适合质量部的相关工作。交谈中，小伙子说大学里已经考过了系统分析员，于是我便问他：“系统分
析员主要做什么？”
小伙子想了一会说道：“系统分析员主要就是组织、管理和规划系统”。于是我接着问道：“如果负责组织、管理、规划的话，那和项目经理的区别是什么？”小伙
子想了半天，终于摇着头说：“不知道。” <br />        问这个问题倒不是为了为难小伙子，主要是希望他能够明白，<span style="color: rgb(255, 0, 0);">书
本上学来的东西必须和实践联系起来，在开发也好在质量部也好，都离不开自己的主动学习和思考，没有思考的学习只是在收集知识而已，是不能够化为己用的。在
离开学校的头两年里，大部分人是无法找到自己真正的兴趣所在，我也是一样，所以刚开始无论在哪个岗位都必须主动学习和思考，包括对自己现有岗位的知识的学
习，以及由于不满而对岗位之外的知识的学习（当然这是在工作之外），而不满正是思考的起点。不过，正是因为无法找到真正的兴趣所在，就需要坚守岗位，一方
面也许它就是自己的兴趣所在，一方面也为了寻找真正的爱好而积蓄力量。</span> 　　 <br />        额外的话说了不少，还是回来看看，到底“系统分析员、架构师、项目经理”之间有着什么样的差别？下面按自己的理解粗略的整理了一下，也许并不全面，绿色部分代表每一个角色主要需要参与考虑的活动（注：下面所说的系统分析员混合了设计的职责）：  <br />
      首先看一下架构师和系统分析员的区别：
1、系统分析员必须考虑自己所设计系统的方方面面，他是系统实现的原始作者，也对系统能否满足客户的技术要求以及产品成本是否可接受起着最直接的作用。
2、架构师一般在软件组织内仅仅是少数人，他们主要负责对产品的架构进行评估以及子系统之间的接口批准上，评估的主要方面集中在系统级的质量属性和成本
上，包括：当前架构是否满足可靠性要求、系统架构的可扩展性、可重用性、性能以及基础的公共功能等等。他们必须对系统分析员设计出来的系统进行最初的把
关，所以责任重大，也需要经验非常丰富的人来承担。在公司其他部门和Ivar
Jacobson的交流中，Jacobson明确的指出，架构委员会不是常设组织，通常都来源于团队的系统分析员，唯一常设的职位通常只有一个主席，其他
的成员必须临时来源于系统开发的一线，只有他们最了解系统开发的基本思想。
3、系统成本是架构师和系统分析员最容易忽略的事情，而这个也是他们最基本的职责之一。 <br />      
接下来看看系统分析员和项目经理的差别：
1、一个不合理的计划往往被归咎于项目经理，但这并不是事实。计划的制定严重依赖于系统分析员所设计系统的部件完成工序，而唯一能对这个作出准确判断的只
有系统分析员。所以，计划的最初版本是来源于系统分析员而不是项目经理。项目经理在这方面的主要作用是协助系统分析员制定计划，帮助考虑人员、资源方面的
投入情况，并在项目的执行过程中严格监控项目的进度情况。
2、质量目标的制定和计划一样，来源于系统分析员，尤其是性能、可靠性等关键技术指标，而这些的第一跟踪主体也是系统分析员。项目经理在其中的角色，只是
协助系统分析员安排各种资源，完成这些目标的测试、跟踪等活动。
3、成本是唯一的需要架构师、系统分析员以及项目经理共同关注并且严格控制的因素，原因很简单，这是大家靠着吃饭的来源。
4、项目其他的非技术方面的因素，则基本都是由项目经理负责搞定，包括合同、人员沟通、采购等等。 <br /><br /><div style="text-align: center;"><img style="width: 452px; height: 325px;" src="http://images.cnblogs.com/cnblogs_com/gisdev/image001.gif" alt="" /><br /><br />我不认同,这样搞失败的几率很大. <br /><br /> 你说的: 项目经理,系统分析员,系统架构师 <br /> 可以用: 项目经理,系统分析设计师 来取代,另外新增由 首席业务分析师带队的业务支持组(纯粹的业务人员). <br /><br /> 不管是大项目还是小项目,不管项目规模多大多小,我的观点和实践如下: <br /><br /> 1: 项目经理 必须对项目的范围(需求),包括要实现的功能和序列 要有比任何人都清晰的认识. <br /><br /> 2: 项目经理 要有广泛的技术背景,广度和深度的技术眼光 至少要能支撑对要实现那些功能的定义(实际上就是承诺). <br /><br /> 3: 项目经理全局把控 系统的 WBS, 局部的细节 WBS 可以让其他人员分担, 但并不代表自己对细节无法把握. <br /><br />
4:
一个项目的成功实施后,虽然项目经理不用自己写代码,甚至不用自己亲自写文档.但自己对整个项目的技术包括细节都了不指掌,并且又比项目组其他人员更高度
的认识.而且能够以总结的眼光找出不足的地方,能够想到新的改进的方案
在新的项目中去实施.对系统的功能和业务以及流程进行总结分析,有意识的无形中提升自己理解问题的能力. <br /><br /> 5: 一个项目结束后,项目经理 对团队建设和管理以及考评, 项目计划以及执行, 各种变更以及突发或必须经历的事件 的处理能力都会有一个新的台阶的提升.并且能以总结的眼光有更高度的认识. 也就是管理能力的提升. <br /><br /> 6:...... <br /><br /> 7: 更关键的一点 就是建立发展跟客户的关系,增强客户的信任度,树立自己的个人品牌,进一步维护团队和公司的品质和品牌.客户对公司的认可,是建立在公司执行具体任务的团队的基础上,对团队的认可是建立在对项目的满意度和项目经理的认可上. <br /><br /><br /> 系统分析设计师,是对业务有一定基础(最好很熟悉),理解问题和解决问题能力特别突出的,技术广度和深度都非常优秀的人员承担.承担副项目经理的职责. <br /> 主要负责进行系统业务的分析和功能定义,接口定义,技术体系的制定,为项目量身定做的技术架构 等职责. <br /><br /> 系统分析设计师 领导 设计组组长 和 开发组组长, 完成不同阶段的任务. <br /><br /> 项目经理直接领导 系统分析设计师, 测试组, 配置管理组. <br /><br />http://zhidao.baidu.com/question/108354211.html?fr=relateQuestion<br /><br />系统架构设计师和系统分析师的区别与联系<br /><pre>区别：<br />系分比架构更贴近用户一点，主要是需求分析，业务分析。<br />架构比系分更贴近技术一点，是技术专家、资深技术人员。<br /><br />联系：<br />都是高级抽象级别，同作为软件高级职称资格，是程序员和软件设计师的领导者和技术顾问。两个联系多于区别，一般系统分析师组和架构师组合作，共同制定一个基础技术框架。 </pre><span id="reply_content_354112880"><pre>系统架构偏向于技术方面,包括设计<br /><br />系统分析偏向业务,包括需求分析<br /><br />它们也有共同之处和联系,两个职位要相互配合的. </pre></span></div><img src ="http://www.blogjava.net/leekiang/aggbug/291400.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/leekiang/" target="_blank">leekiang</a> 2009-08-17 03:34 <a href="http://www.blogjava.net/leekiang/archive/2009/08/17/291400.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>网站架构</title><link>http://www.blogjava.net/leekiang/archive/2009/01/30/252726.html</link><dc:creator>leekiang</dc:creator><author>leekiang</author><pubDate>Thu, 29 Jan 2009 18:58:00 GMT</pubDate><guid>http://www.blogjava.net/leekiang/archive/2009/01/30/252726.html</guid><wfw:comment>http://www.blogjava.net/leekiang/comments/252726.html</wfw:comment><comments>http://www.blogjava.net/leekiang/archive/2009/01/30/252726.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/leekiang/comments/commentRss/252726.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/leekiang/services/trackbacks/252726.html</trackback:ping><description><![CDATA[1，从LiveJournal后台发展看大规模网站性能优化方法[zz]<br />http://blog.zhangjianfeng.com/article/743<br /><br />2，大型网站架构演变和知识体系<br />http://www.blogjava.net/BlueDavy/archive/2008/09/03/226749.html<br /><br />3，构建架构的思考<br />http://www.esbzone.net/2008/08/15/think-architect/<br /><img src ="http://www.blogjava.net/leekiang/aggbug/252726.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/leekiang/" target="_blank">leekiang</a> 2009-01-30 02:58 <a href="http://www.blogjava.net/leekiang/archive/2009/01/30/252726.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>关于架构师</title><link>http://www.blogjava.net/leekiang/archive/2008/12/29/249012.html</link><dc:creator>leekiang</dc:creator><author>leekiang</author><pubDate>Mon, 29 Dec 2008 14:57:00 GMT</pubDate><guid>http://www.blogjava.net/leekiang/archive/2008/12/29/249012.html</guid><wfw:comment>http://www.blogjava.net/leekiang/comments/249012.html</wfw:comment><comments>http://www.blogjava.net/leekiang/archive/2008/12/29/249012.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/leekiang/comments/commentRss/249012.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/leekiang/services/trackbacks/249012.html</trackback:ping><description><![CDATA[1,<a href="http://blog.csdn.net/aking8736/archive/2008/05/30/2496707.aspx">做人、做事，做架构师——架构师能力模型解析</a><br /><br />2，<a href="http://wakan.blog.51cto.com/59583/7231">剑法三套，程序员也能挣大钱<br /></a><br /><img src ="http://www.blogjava.net/leekiang/aggbug/249012.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/leekiang/" target="_blank">leekiang</a> 2008-12-29 22:57 <a href="http://www.blogjava.net/leekiang/archive/2008/12/29/249012.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>UML笔记</title><link>http://www.blogjava.net/leekiang/archive/2008/10/30/237698.html</link><dc:creator>leekiang</dc:creator><author>leekiang</author><pubDate>Thu, 30 Oct 2008 13:51:00 GMT</pubDate><guid>http://www.blogjava.net/leekiang/archive/2008/10/30/237698.html</guid><wfw:comment>http://www.blogjava.net/leekiang/comments/237698.html</wfw:comment><comments>http://www.blogjava.net/leekiang/archive/2008/10/30/237698.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/leekiang/comments/commentRss/237698.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/leekiang/services/trackbacks/237698.html</trackback:ping><description><![CDATA[1,我觉得UML里最有用的是序列图.<br />   序列图按照时间次序，描述对象之间如何交互，以及交互时的消息。序列图是用例的精细化表达。一个用例可以细化为一个或多个序列图。<br />   用例有粒度之分，序列图也分粗细。<br /><br /><br /><br />参考资料:<br />(1)用netbeans创建序列图的教程<br />   http://hi.baidu.com/woxxf/blog/item/6ba2f6efed129b12fdfa3c15.html<br />(2)http://hi.baidu.com/haoyan665/blog/item/61717e3f9b21d5ee54e723c6.html<br />(3)http://ieagle.javaeye.com/blog/104956<br />(4)<a target="_blank" href="http://www.javaeye.com/topic/164">UML 中各种图形的重要性排行 </a><br />(5)在线画时序图:http://www.websequencediagrams.com。玩具。<br /><img src ="http://www.blogjava.net/leekiang/aggbug/237698.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/leekiang/" target="_blank">leekiang</a> 2008-10-30 21:51 <a href="http://www.blogjava.net/leekiang/archive/2008/10/30/237698.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>架构设计方面的笔记</title><link>http://www.blogjava.net/leekiang/archive/2008/06/21/209737.html</link><dc:creator>leekiang</dc:creator><author>leekiang</author><pubDate>Sat, 21 Jun 2008 15:24:00 GMT</pubDate><guid>http://www.blogjava.net/leekiang/archive/2008/06/21/209737.html</guid><wfw:comment>http://www.blogjava.net/leekiang/comments/209737.html</wfw:comment><comments>http://www.blogjava.net/leekiang/archive/2008/06/21/209737.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/leekiang/comments/commentRss/209737.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/leekiang/services/trackbacks/209737.html</trackback:ping><description><![CDATA[
		<a target="_blank" href="http://www.infoq.com/cn/articles/ebay-scalability-best-practices">可伸缩性最佳实践：来自eBay的经验</a>
		<br />
		<br />为什么对客户需求的理解经常变动？那是因为没有抓住问题的本质，没有分析出需求对应的领域模型<br />http://www.javaeye.com/topic/214489?page=2<br /><img src ="http://www.blogjava.net/leekiang/aggbug/209737.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/leekiang/" target="_blank">leekiang</a> 2008-06-21 23:24 <a href="http://www.blogjava.net/leekiang/archive/2008/06/21/209737.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>数据库设计摘录</title><link>http://www.blogjava.net/leekiang/archive/2008/05/06/198790.html</link><dc:creator>leekiang</dc:creator><author>leekiang</author><pubDate>Tue, 06 May 2008 12:24:00 GMT</pubDate><guid>http://www.blogjava.net/leekiang/archive/2008/05/06/198790.html</guid><wfw:comment>http://www.blogjava.net/leekiang/comments/198790.html</wfw:comment><comments>http://www.blogjava.net/leekiang/archive/2008/05/06/198790.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/leekiang/comments/commentRss/198790.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/leekiang/services/trackbacks/198790.html</trackback:ping><description><![CDATA[1,  <a href="http://www.javaeye.com/post/423268">http://www.javaeye.com/post/423268</a><br />把一个表分成N张相同的表是为了加速查询速度吧. <br />1,用数据库级的表分区, 把数据分在不同 的PV上. 增加IO性能. (Oracle, DB2都有实现) <br />2,如果是DB2还有另一种方案, 做数据库的Partition, 把数据散列到不同的单独节点供查询使用. 但这种方法只适合OLAP(虽然OLTP也有相应解决方案,但效果不佳). <br />3,楼上说的, 做视图, 但这种方法把动态表合在一起性能也是一件很郁闷的事情. <br />4,做物化视图, 比动态视图访问数据的能力强些, 但数据冗余量又太大. <br /><br />还有, 您什么样的应用会一下查询那么多的数据量? 一定是个OLAP业务吧, 如果是, 尽量把它当做数据中心, 在它之上做个数据准备区保障时间维度一制性, 按业务做不同业务的数据集市供业务访问. 那样各个数据集市的数据压力会小些. 数据查询统计的压力全部移到数据准备区中.
<p><span class="t18"></span> </p><img src ="http://www.blogjava.net/leekiang/aggbug/198790.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/leekiang/" target="_blank">leekiang</a> 2008-05-06 20:24 <a href="http://www.blogjava.net/leekiang/archive/2008/05/06/198790.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>是否应该建外键的讨论</title><link>http://www.blogjava.net/leekiang/archive/2008/04/14/192910.html</link><dc:creator>leekiang</dc:creator><author>leekiang</author><pubDate>Mon, 14 Apr 2008 12:44:00 GMT</pubDate><guid>http://www.blogjava.net/leekiang/archive/2008/04/14/192910.html</guid><wfw:comment>http://www.blogjava.net/leekiang/comments/192910.html</wfw:comment><comments>http://www.blogjava.net/leekiang/archive/2008/04/14/192910.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/leekiang/comments/commentRss/192910.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/leekiang/services/trackbacks/192910.html</trackback:ping><description><![CDATA[
		<u>
				<font color="#800080">
						<a href="http://www.javaeye.com/topic/124612">http://www.javaeye.com/topic/124612</a>
						<br />
						<a href="http://www.javaeye.com/topic/2832">http://www.javaeye.com/topic/2832</a>
						<br />
						<a href="http://www.javaeye.com/topic/8283">http://www.javaeye.com/topic/8283</a>
						<br />
						<a href="http://www.javaeye.com/topic/151187">http://www.javaeye.com/topic/151187</a>
						<br />
						<a href="http://www.javaeye.com/topic/124612">
						</a>
						<a href="http://www.javaeye.com/topic/2312">http://www.javaeye.com/topic/2312</a>
						<br />
						<br />http://www.itpub.net/viewthread.php?tid=510215&amp;extra=&amp;page=1<br /><br />以下摘几个我自己认同的观点:<br />1,</font>
		</u>其实有一段时间我们的开发人员也有这种想法，以为程序可以控制好<br />
后来发现没有外键的表里经常有垃圾数据（找不到父亲的孩子），然后又把外键一一加上去，后面测试才发现是应用的BUG，在特定情况下才会发生的BUG。<br />
如果没有外键那数据库就不会报错，也就是说垃圾数据不能阻止。<br />2,在复杂的业务逻辑下，程序来保证这个是极不可靠的，只有交给数据库从底层来保证才能避免出错。<br />
当然，如果是稳定的程序中把外键去掉会怎么样，这又是另一回事了。<br />
外键的存在对数据库的维护来说是有一些不方便的地方。<br />3,我们以前做开发的时候，在开发、测试阶段，是所有业务逻辑需要的外键都加上的。数据量小，并发少，也无所谓什么性能什么的。等测试和试运行一段时间后，再将外键去掉，以提高性能。<br />4,怎么这么多人不用外键的，外键可是逻辑的约束啊！说外键影响性能，可以denormalize外键表啊，但是插入更新必须要符合约束啊，我觉得这是不可替代的啊<br />
对数据的约束最好尽可能放到db里，集中管理清晰准确，以前吃过应用管理约束的亏，不过好好看看oracle sap这些范式做的都还不错啊，他们都这样做我想多少能说明点问题吧<br />5,你看看oracle系统数据表的设计,再看看大型数据库表的设计,<br />
你就明白,外键约束无处不在.<br />6,该用的地方，就一定要用！前几天我们的应用程序发现一个bug，后来我仔细一查，就是由于没有使用外建，数据不匹配导致的。教训深刻！<br />7,如果现在要我来选择，我决定是要用的一定要用，这是系统设计的严谨性的要求，不然产生一堆垃圾数据，这是在一个好的系统中是不允许的。<br />8,呵呵，做过开发的ＤＢＡ应该都会有这样的体会<br />
当统计报表中的数据不对的时候就知道什么叫问题严重了，要一点点数据去核查。<br />9,最好还是使用数据库外键这个最直观的功能吧<br />
至于性能不知有没有什么测试数据，究竟能慢到什么程度，不要听说会慢就不用吧（呵呵，从ＴＯＭ的书里学到的）<br />10,这要看是建立那中类型的数据库了<br />
如果是操作类型的数据库 OLTP 面向应用的<br />
数据的规范化是很有必要的.. 该用外键的情况一定要用.<br />
如果是面向部门 用于OLAP或建立数据仓库.<br />
这种时候 往往需要反规范化 存取效率是首要因素<br /><br />我自己的结论:<font color="#ff6600">如果是做企业级的OLTP应用，并且数据量不是非常大的话，一定要建外键。毕竟对于企业来说，保证数据的正确性是最重要的。但如果经过长时间的运行证明代码可靠、并且数据量已经很大，这时也可以去掉外键以提高运行速度。</font><br /><a href=""></a><img src ="http://www.blogjava.net/leekiang/aggbug/192910.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/leekiang/" target="_blank">leekiang</a> 2008-04-14 20:44 <a href="http://www.blogjava.net/leekiang/archive/2008/04/14/192910.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item></channel></rss>