软g目理
软g目理是ؓ了软g目能够按照预定的成本、进度、质量顺利完成，而对人员QPeopleQ、品（ProductQ、过E（ProcessQ和目(Project)q行分析和管理的zd?/font>
软g目理的根本目的是Z让Y仉目尤其是大型目的整?a target="_new" >软g生命周期Q从分析、设计、编码到试、维护全q程Q都能在理者的控制之下Q以预定成本按期Q按质的完成软g交付用户使用。而研IY仉目管理ؓ了从已有的成功或p|的案例中ȝ够指g后开发的通用原则Q方法，同时避免前h的失误?/font>
软g目理的提出是?0世纪70q代中期的美国，当时国国防部专门研I了软g开?/a>不能按时提交Q预超支和质量达不到用戯求的原因Q结果发?0%的项目是因ؓ理不善引v的，而非技术原因。于是Y件开发者开始逐渐重视赯Y件开发中的各管理。到?0世纪90q代中期QY件研发项目管理不善的问题仍然存在。据国软g工程实施现状的调查，软g研发的情况仍然很N，大约只有10Q的目能够在预定的费用和进度下交付?/font>
1995q_据统计，国共取消了810亿美元的商业软g目Q其?1Q的目未做完就被取消，53Q的软g目q度通常要g?0%的时_只有9Q的软g目能够及时交付q且费用也控制在预算之内?/font>
软g目理和其他的目理相比有相当的Ҏ性。首先，软g是纯知识产品Q其开发进度和质量很难估计?a target="_new" >度量Q生产效率也难以预测和保证。其ơ，软gpȝ的复杂性也D了开发过E中各种风险的难以预见和控制。Windowsq样?a target="_new" >操作pȝ?500万行以上的代码，同时有数千个E序员在q行开发，目l理都有上百个。这样庞大的pȝ如果没有很好的管理，其Y件质量是难以惌的?/font>
软g目理的内容主要包括如下几个方面：人员的组l与理Q?a target="_new" >软g度量Q?a target="_new" >软g目计划Q?a target="_new" >风险理Q?a target="_new" >软g质量保证Q?a target="_new" >软gq程能力评估Q?a target="_new" >软g配置理{?/font>
q几个方面都是诏Iѝ交l于整个软g开发过E中的，其中人员的组l与理把注意力集中在项目组人员的构成、优化；软g度量把关注用量化的方法评Y件开? 中的费用、生产率、进度和产品质量{要素是否符合期望|包括q程度量和品度量两个方面；软g目计划主要包括工作量、成本、开发时间的估计QƈҎ? 计值制定和调整目l的工作Q风险管理预未来可能出现的各种危害到Y件品质量的潜在因素q由此采取措施进行预Ԍ质量保证是保证品和服务充分满? 费者要求的质量而进行的有计划，有组l的zdQY件过E能力评估是对Y件开发能力的高低q行衡量QY?a target="_new" >配置理针对开发过E中人员、工L配置、用提出管理策略。因为大家对人力资源理和Y件过E能力比较有兴趣Q下面就详细的对q两斚w展开讨论?/font>
一QY仉目的计划
软g目计划是一个Y仉目进入系l实施的启动阶段,主要q行的工作包?定详细的项目实施范围、定义递交的工作成果、评估实施过E中主要的风险、制定项目实施的旉计划、成本和预算计划、h力资源计划等?/font>
软g目理q程从项目计划活动开始，而第一计划活动就是估：需要多长时间、需要多工作量、以及需要多h员。此外，我们q必M所需要的资源Q硬件及软gQ和可能涉及到的风险?/font>
Z估算软g目的工作量和完成期限，首先需要预Y件规模。度量Y件规模的常用Ҏ有直接的Ҏ——LOCQ代码行Q，间接的方法——FPQ功能点Q。这两种Ҏ各有优缺点，应该Ҏ软g目的特炚w择适用的Y件规模度量方法?/font>
Ҏ目的规模可以估出完成目所需的工作量Q我们可以用一U或多种技术进行估，q些技术主要分Z?a target="_new" >c?/a>Q分解和l验建模。分解技术需要划分出主要的Y件功能，接着估算实现每一个功能所需的程序规模或人月数。经验技术的使用是根据经验导出的公式来预工作量和时间。可以用自动工h实现某一特定的经验模型?/font>
_的项目估一般至会用到上述技术中的两U。通过比较和协调用不同技术导出的估算|我们可能得到更精的估算。Y仉目估永q不会是一门精的U学Q但良好的历史数据与系l化的技术结合v来能够提高估的_度?/font>
当对软g目l予较高期望Ӟ一般都会进行风险分析。在标识、分析和理风险上花费的旉和h力可以从多个斚w得到回报Q更加^E的目q展q程Q更高的跟踪和控刉目的能力Q由于在问题发生之前已经做了周密计划而生的信心?/font>
对于一个项目管理者，他的目标是定义所有的目dQ识别出关键dQ跟t关键Q务的q展情况Q以保证能够及时发现拖gq度的情cؓ此，目理者必d定一个够详l的q度表，以便监督目q度q控制整个项目?/font>
常用的制定进度计划的工具主要有Gantt囑֒工程|络两种。Gantt囑օ有悠久历双Ӏ直观简明、容易学习、容易绘制等优点Q但是，它不能明昑֜表示? Q务彼此间的依赖关p，也不能明昑֜表示关键路径和关键Q务，q度计划中的关键部分不明。因此，在管理大型Y仉目时Q仅用Gantt图是不够的，? 仅难于做出既节省资源又保证进度的计划Q而且q容易发生差错?/font>
工程|络不仅能描lQ务分解情况及每项作业的开始时间和l束旉Q而且q能清楚地表C各个作业彼此间的依赖关pR从工程|络图中Ҏ识别出关键\径和关键 d。因此，工程|络图是制定q度计划的强有力的工兗通常Q联合用Gantt囑֒工程|络q两U工h制定和管理进度计划，使它们互相补充、取长补 短?/font>
q度安排是Y仉目计划的首要dQ而项目计划则是Y仉目管理的首要l成部分。与估算Ҏ和风险分析相l合Q进度安排将为项目管理者徏立v一张计划图?/font>
二．软g目的控?/strong>
对于软g开发项目而言Q控制是十分重要的管理活动。下面介lY件工E控制活动中的质量保证和配置理。其实上面所提到的风险分析也可以是软g工程控制zd的一cR而进度跟t则起到q接软g目计划和控制的作用?/font>
软g质量保证Q?a target="_new" >SQAQSoftware Quality InsuranceQ是在Y件过E中的每一步都q行的“保护性活动”。SQA主要有基于非执行的测试（也称审）、基于执行的试Q即通常所说的试Q和E序正确性证明?/font>
软g评审是最为重要的SQAzd之一。它的作用是Q在发现及改正错误的成本相对较小时就及时发现q排除错误。审查和走查是进行正式技术评审的两类具体? 法。审查过E不仅步数比走审多，而且每个步骤都是正规的。由于在开发大型Y件过E中所犯的错误l大数是规格说明错误或设计错误，而正式的技术评审发现这? c错误的有效性高?5%Q因此是非常有效的Y件质量保证方法?/font>
软g配置理Q?a target="_new" >SCMQSoftware configuration managementQ是应用于整个Y件过E中的保护性活动，它是在Y件整个生命周期内理变化的一l活动?/font>
软g配置׃l相互关联的对象l成Q这些对象也UCؓ软g配置，它们是作为某些Y件工E活动的l果而生的。除了文档、程序和数据q些软g配置之外，用于开发Y件的开发环境也可置于配|控制之下?/font>
一旦一个配|对象已被开发出来ƈ且通过了评审，它就变成?a target="_new" >基线。对基线对象的修改导致徏立该对象的版本?a target="_new" >版本控制是用于管理这些对象而用的一l规E和工具?/font>
变更控制是一U规E活动，它能够在寚w|对象进行修Ҏ保证质量和一致性。配|审计是一Y件质量保证活动，它有助于保在进行修Ҏ仍然保持质量。状态报告向需要知道关于变化的信息的hQ提供有x变化的信息?/font>
三、Y仉目管理的l织模式
软g目可以是一个单独的开发项目，也可以与产品目l成一个完整的软g产品目。如果是订单开发，则成立Y仉目组卛_Q如果是产品开发，需成立软g? 目组和品项目（负责市场调研和销售）Q组成Y件品项目组。公司实行项目管理时Q首先要成立目理委员会，目理委员会下N目管理小l、项目评? 组和Y件品项目组?/font>
3.1、项目管理委员会目理委员会是公司目理的最高决{机构，一般由公司ȝ理、副ȝ理组成。主要职责如下：
Q?Q依照项目管理相兛_度管理项目；
Q?Q监督项目管理相兛_度的执行Q?br />Q?Q对目立项、项目撤消进行决{；
Q?QQ命项目管理小l组ѝ项目评审委员会MQ、项目组l长.
3.2、项目管理小l项目管理小l对目理委员会负责，一般由公司理人员l成。主要职责如下：
Q?Q草拟项目管理的各项制度Q?br />Q?Q组l项目阶D评审；
Q?Q保存项目过E中的相?a target="_new" >文g和数据；
Q?Qؓ优化目理提出?/font>
3.3、项目评审小l项目评审小l对目理委员会负责，可下讑ּ发评审小l和产品评审组Q一般由公司技术专家和市场专家l成。主要职责如下：
Q?Q对目可行性报告进行评审；
Q?Q对市场计划和阶D|告进行评审；
Q?Q对开发计划和阶段报告q行评审Q?br />Q?Q项目结束时Q对目ȝ报告q行评审?/font>
3.4、Y件品项目组软g产品目l对目理委员会负责，可下设Y仉目组和品项目组。Y仉目组和品项目组分别讑ּ发经理和产品l理。成员一? 由公司技术h员和市场人员构成。主要职责是Q根据项目管理委员会的安排具体负责项目的软g开发和市场调研及销售工作?
四、Y仉目管理的内容
从Y件工E的角度Ԍ软g开发主要分为六个阶D：需求分?/a>阶段、概要设计阶Dc详l设计阶Dc编码阶Dc测试阶Dc安装及l护阶段。不论是作坊式开发，q是团队协作开发，q六个阶D都是不可缺的。根据公司实际情况，公司在进行Y仉目管理时Q重点将软g配置理、项目跟t和控制理?a target="_new" >软g风险理及项目策划活动管理四斚w内容导入软g开发的整个阶段。在20世纪80q代初，著名软g工程专家B.W.BoehmȝZ软g开发时需遵@的七条基本原则，同样Q在q行软g目理Ӟ也应该遵循这七条原则。它们是Q?br />Q?Q用分阶D늚生命周期计划严格理Q?br />Q?Q坚持进行阶D评审；
Q?Q实行严格的产品控制Q?br />Q?Q采用现?a target="_new" >E序设计技术；
Q?Q结果应能够清楚地审查；
Q?Q开发小l地人员应该而精Q?br />Q?Q承认不断改qY件工E实늚必要性?/font>
五、编写《Y仉目计划书?/strong>
目l成立的W一件事是编写《Y仉目计划书》，在计划书中描q开发日E安排、资?a target="_new" >需?/a>、项目管理等各项情况的大体内宏V计划书主要向公司各相关人员发放Q他们大体了解该Y仉目的情况。对于计划书的每个内容，都应有相应具体实施手册，q些手册是供目l相x员用的?/font>
六、Y仉|管?/strong>
是否q行配置理与Y件的规模有关QY件的规模大Q配|管理就昑־重要。Y仉|管理简USCMQSoftware Configuration Management的羃写）Q是在团队开发中Q标识、控制和理软g变更的一U管理。配|管理的使用取决于项目规模和复杂性以及风险水q?/font>
6.1、目前Y件开发中面的问?在有限的旉、资金内Q要满不断增长的Y件品质量要求；开发的环境日益复杂Q代码共享日益困难，需跨越的^台增多；E序的规模越来越大；软g的重用性需要提高；软g的维护越来越困难?/font>
6.2、Y仉|管理应提供的功?
在ISO9000.3中，寚w|管理系l的功能作了如下描述Q唯一地标识每个Y仉的版本；标识共同构成一完整产品的特定版本的每一软g的版本Q控制由
两个或多个独立工作的人员同时对一l定软g的更新Q控制由两个或多个独立工作的人员同时对一l定软g的更新Q按要求在一个或多个位置对复杂品的更新
q行协调Q标识ƈ跟踪所有的措施和更改；q些措施和更Ҏ在从开始直到放行期_׃更改h或问题引L?/font>
6.3、版本管理Y仉|管理分为版本管理、问题跟t和建立理三个部分Q其中版本管理是基础。版本管理应完成以下主要dQ?br />
建立目Q?
重构M修订版的某一Ҏ某一文gQ?br /> 利用加锁技术防止覆盖； ?当增加一个修订版时要求输入变更描qͼ
提供比较L两个修订版的使用工具Q?br /> 采用增量存储方式Q?
提供对修订版历史和锁定状态的报告功能Q?br /> 提供归ƈ功能Q?
允许在Q何时候重构Q何版本；
权限的设|；
晋升模型的徏立；
提供各种报告?
? 人员l织与管?/strong>
软g开发中的开发h员是最大的资源。对人员的配|、调度安排诏I整个Y件过E，人员的组l管理是否得当，是媄响对软g目质量的决定性因素?/font>
首先在Y件开发的一开始，要合理的配置人员Q根据项目的工作量、所需要的专业技能，再参考各个h员的能力、性格、经验，l织一个高效、和谐的开发小l。一 般来_一个开发小lh数在5?0Z间最为合适，如果目规模很大Q可以采取层U式l构Q配|若q个q样的开发小l?/font>
在选择人员的问题上Q要l合实际情况来决定是否选入一个开发组员。ƈ不是一高水^的程序员在一起就一定可以组成一个成功的组。作察标准Q技术水 q뀁与本项目相关的技能和开发经验、以及团队工作能力都是很重要的因素。一个一天能写一万行代码但却不能与同事沟通融z的E序员，未必适合一个对l员之间 通讯要求很高的项目。还应该考虑分工的需要，合理配置各个专项的h员比例。例如一个网站开发项目，组中有面工、后台服务程序?a target="_new" >数据?/a>几个部分Q应该合理的l织各项工作的h员配比。对于一个中型农技110|站Q对数据采集量要求较高，一个h员配比方案可以是2个美工?个后台服务程序编写?个数据采集整理h员?/font>
可以用如下公式来对候选h员能力进行评分，辑ֈ一定分数的则可以考虑q入开发组Q但q个公式不包含对人员数量配比的考虑?br /> Score=∑WiCi(i=1to8)
Ci是对目lh员各能力的评估。其值含义如?
在决定一个开发组的开发h员数量时Q除了考虑候选h素质以外Q还要综合考虑目规模、工期、预、开发环境等因素的媄响，下面是一个基于规模、工期和开发环境的人员数量计算公式Q?br /> L=Ck*K1/3*td4/3
L:开发规模，以代码行LOC为度量td:开发时间KQh员数
CkQ技术常数表C开发环境的优劣
取?000Q表C开发环境差Q没有系l的开发方法，~Z文档规范化设计；
取?000Q表C开发环境较好；
取?1000Q表C开发环境优?/font>
在组建开发组Ӟq应充分估计到开发过E中的h员风险。由于工作环境、待遇、工作强度、公司的整体工作安排和其他无法预知的因素Q一个项目尤其是开发周? 较长的项目几乎无可避免的要面临h员的入出。如果不在项目初期对可能出现的h员风险进行充分的估计Q作必要的准备，一旦风险{化ؓ现实Q将有可能给? 个项目开发造成巨大的损失。以较低的代仯行及早的预防是降低这Uh员风险的基本{略。具体来说可以从以下几个斚w对h员风险进行控Ӟ
aQ保证开发组中全职h员的比例Q且目核心部分的工作应该尽量由全职人员来担任， 以减兼职h员对目lh员不E_性的影响?br /> bQ徏立良好的文档理机制Q包扩项目组q度文档、个度文档、版本控制文档、整体技术文档、个人技术文档、源代码理{。一旦出Ch员的变动Q比如某个组员因病退出，替补的组员能够根据完整的文档早接手工作?br /> cQ加强项目组内技术交，比如定期开技术交会Q或Ҏl内分工建立目l内部的开发小l，是开发小l内的成员能够相互熟悉对方的工作和进度，能够在必要的时候替Ҏ工作?br /> dQ对于项目经理，可以从一开始就指派一个副l理在项目中协同目l理理目开发工作，如果目l理退出开发组Q副l理可以很快接手。但是只在项目经理这L高度重要的岗位采用这U冗余复制的{略来预防h员风险，否则大大增加项目成本?br /> eQؓ目开发提供尽可能好的开发环境，包括工作环境、待遇、工作进度安排等{，?时一个优U的项目经理应该能够在目l内营造一U良好的人际关系和工作氛围。良好的开发环境对于稳定项目组人员以及提高生效率都有不可忽视的作用?/font>
?软gq程能力评估
软gq程能力描述了一个开发组l开发Y件开发高质量软g产品的能力。现行的国际标准主要有两个：ISO9000.3?a target="_new" >CMM?/font>
ISO9000.3是ISO9000质量体系认证中关?a target="_new" >计算Y?/a>? 量管理和质量保证标准部分。它从管理职责、质量体pR合同评审、设计控制、文件和资料控制、采购、顾客提供品的控制、品标识和可追溯性、过E控制、检 验和试验、检?量和试验设备的控制、检验和试验状态、不合格品的控制、纠正和预防措施、搬q?贮存/包装/防护和交付、质量记录的控制、内部质量审 核、培训、服务、统计系l等二十个方面对软g质量q行了要求?/font>
CMMQ?a target="_new" >能力成熟度模?/a>Q是国卡纳基梅隆大学Y件工E研I所QCMUQSEIQ于1987q提出的评估和指DY件研发项目管理的一pdҎQ用5个不断进化的层次来描qY件过E能力。现在CMM?.0版本?/font>
ISO9000和CMM的共同点是二者都了Y件品的质量。所不同的是QISO9000的是衡量的准则，但没有告诉Y件开发h员如何达到好的目 标，如何避免差错。CMM则提供了一整套完善的Y件研发项目管理的Ҏ。它可告诉Y件开发组l，如果要在原有的水q上提高一个等U，应该x哪些问题Q? q正是改qY件过E的工作?/font>
CMM描述了五个别的软gq程成熟度（初始U，可重复Q已定义U，已定量管理Q优化Q，成熟度反映了软gq程能力的大?/font>
初始U特Ҏ软g机构~Z对Y件过E的有效理QY件过E是无序的，有时甚至是qQ对q程几乎没有定义Q其软g目的成功来源于偶尔的个雄主义? 非群体行为，因此它不是可重复的；可重复的特Ҏ软g机构的项目计划和跟踪E_Q项目过E可控，目的成功是可重复的Q已定义U的特点在于软gq程已被 提升成标准化q程Q从而更加具有稳定性、可重复性和可控性；已定量管理的Y件机构中软gq程和Y件品都有定量的目标Qƈ被定量地理Q因而其软gq程 能力是可预测的，其生产的软g产品是高质量的；优化U的特点是过E的量化反馈和先q的新思想、新技术促q过E不断改q，技术和q程的改q改q被作ؓ常规? 业务zd加以计划和管理?/font>
CMM是科学评价一个Y件企业开发能力的标准Q但要达到较高的U别也非常困难，Ҏ1995q美国所做的软g产业成熟度的调查Q在国的Y件业中Q? CMM成熟度等Uؓ初始U的竟占70Q，为可重复U的?5Q，为定义的所占比例小?0Q，为管理的所占比例小?Q，Z化的所占比例小于l Q。而国内企业的水^更加堪优，到目前ؓ止，只有东Y一家达C化Q少数几家能够达到可定义U。尽快改变这U局面，U学化、规范化、高效的q行软g开 发活动，从整体提高我国Y件行业的水^Q是国内软g企业的当务之急，也是专业人员应该己制定的目标。如果有一天也能指挥一个数千h的庞大开发队伍，? 作Windowsq样巨型规模的Y仉目，q生产出高质量的产品Q才有理由宣U自q软g目理能力辑ֈ了一个“自主自”的水^?/font>
? Z么要有项目管理？
没有目理Q项目也有可能成功。但没有理的项目，很难保证目的利润空_对公司来_亏损的风险就大。所以我们要有项目管理，以保证公司在M上是盈利的，注意不是每一个项目都要盈利?/font>
另外Q有了项目管理，有了管理改q的基础Q无论刚开始的目理多么p糕Q只要有理Q就有了改进的可能性，至于能不能得到改q，以及改进的快慢，则取 决于两个因素Q一个是人，特别是各U管理者；另一个是利益。关键是"利益"Q准的说是"利益的分?Q在权责利明的前提下，人才能充分的发挥作用。还 需要指出的?利益"是多元的Q这里的多元不仅指利益的具体形式Q而且指利益的受众是多元的Q包括客h相关人员个h的利益?/font>
? Z么要有专职的目l理Q?/strong>
专业化是一个趋势，因ؓ在专业化的条件下Q可以有效降低成本，提高利润率。项目经理的工作内容归根到底只有一：识别q管理风险。这工作的目的是控刉目成本?/p>
׃目的风险是多方面的Q而且风险的表现Ş式也是多U多L。从风险范围上来_既有公司内部风险Q也有和客户交流、合作的风险Q从风险?a target="_new" >cd上来_既有理风险Q也有技术风险；从风险生的阶段来说Q包括了从业务分析到上线后维护的目周期各个阶段?/p>
我认Z个项目经理是否优UQ主要是看他/她能在多大程度上提前识别q消除风险，而不是I补和解决了多问题（风险未被及时识别或妥善处理，׃转换成问题）。当然能弥补和解决问题的目l理也是相当合格的，但还不够优秀?/p>
十一. 目l的范围界限在哪里？
目l的范围界限可以有三U划分：
1、包括客h所有参与该目的立V调研、审扏V测试和使用人员Q包括开发商市场开发、管理审扏V商务谈判、后勤保障和具体负责该项目开发的人员Q?/p>
2、包括客h目l理、业务需求提Zh和测试hQ包括开发商具体负责该项目开发的人员Q?/p>
3、仅包括开发商具体负责该项目开发的人员?/p>
大部分h在思想上可以接受范?Q而在实务中接受的是范?。而我个h认ؓ目l理Q特别是开发商斚w的项目经理应该采用的是范??/p>
寚w目组范围理解不同Q将影响目l理对工作的处理方式Q范?实际上是很虚的，在项目管理实务操作中没有太大的意义；而范?实质是把客户方和该项目有 密切关系的h与开发商具体负责该项目开发的人对立v来，也就是所谓的甲方、乙斏V在q种对立的前提下处理目的分歧和矛盾Q效果肯定要打折扣?/p>
而按范围2来理解，在项目管理实务中目l理必要让客h和该目有密切关pȝZ接受q一观点Q从而拆除双方之间的"障碍"Q达到相互信仅R相互尊 重、共同协商解决问题的良性氛_以达到降低项目外部风险的目的。当Ӟq样增大了目l理工作的难度，但对目的成功则是很重要的?/p>
十二. 怎样才能是一个成功的目Q?/strong>
?成功目"的标准解释ؓQ项目范围、项目成本、项目开发时间、客h意度四点辑ֈ要求。我认ؓ其实只有一?-利益。项目范围、客h意度主要代表? L利益Q项目成本主要代表开发商的利益，目开发时间同时媄响双方的利益。但每一个h兛_?利益"是不同的?/p>
十三. 软g目理的成功原?/strong>
1q原则
在我们讨Y仉目ؓ什么会p|时可以列Z很多的原因，{案有很多，如管理问题、技术问题、h员问题等{，但是有一个根本的思想问题是最Ҏ忽视的， 也是软gpȝ的用戗Y件开发商、销售代理商最不想正视的，那就是：需求、资源、工期、质量四个要素之间的q关系问题?
需求定? ?做什?Q定义了pȝ的范围与规模Q资源决定了目的投入（人、胦、物Q，工期定义了项目的交付日期Q质量定义了做出的系l好C么程度，q四个要? 之间是有制约q关系的。如果需求范围很大，要在较少的资源投入下Q很短的工期内，很高的质量要求来完成某个目Q那是不现实的，要么需要增加投资，要么 工程延期Q如果需求界定清楚了Q资源固定了Q对pȝ的质量要求很高，则可能需求g长工期?
对于上述四个要素之间的^衡关pLҎ犯的一个错误，是鼓吹"多快好省"四个字，"多快好省"Q多么理想的境界啊？需求越多越好，工期短好Q质量越高越好，投入少好Q这是用h常用的口受?
多：需求越多越好吗Q?
软gpȝ实施的基本原则是"全局规划Q分步实施，步步见效"Q需求可以多Q但是需求一定要分优先Q要分清企业内的主要矛盾与次要矛盾，Ҏ PARETO?0-20原则Q企业中?0%的问题可以用20%的投资来解决Q如果你要大而全Q对不vQ你?0%的次要问题是需要你p80%的投? 的！而这一Ҏ恰是很多软g用户所不能忍受的?
快：真能快v来吗Q?
"?是用戗Y件开发商都希望的。传l企业里 资金的周转情况，软g企业里强调的是h员的周{情况Q开发h员应快做完一个项目再做另外一个项目，通过快速的启动目、结束项目来承担更多的项目， 来获利。但??不是主观的拍脑袋定工期就可以完成的，工期的定义一定要Z资源的状c需求的多少与质量的需求来q行推算的。Y件毕竟需要一行代码一 行代码的写出来，他的工作量是客观的，q?quot;人有多大胆，地有多大?式的_鼓动可以短期完成的?
省：省到什么程度？
"一分钱一分货"Q这是中国的俗话Q他是符合hD律的。甲方希望少投入Q乙方希望降低自q生成本Q省C方仅能保本的时候，再省Q乙方就亏损了?
正视q四个要素之间的q关系是Y件用戗开发商、代理商成熟理智的表玎ͼ否则pȝ的成功就失去了一块最坚实的理念基?
企业实施ITpȝ的首要目标是要成功，而不是失败，企业可以容忍的成功Q但不一定容忍小的失败，所以需要真正理解上q四个要素的q关系Q确保项目的成功?
2高效原则
在需求、资源、工期、质量四个要素中Q很多的目决策者是进度放在首位的Q现在市场的竞争来激烈，"产品早上市一天，早挣一天钱Q挣的就比花? 多，所以一定要多挣"Q基于这样一个理念，软g开发越来越q求开发效率，大家从技术、工兗管理上L更多更好的解决之道?
Z高效的原则，寚w目的理需要从几个斚w来考虑Q?
要选择_英成员
目标要明，范围要清?
沟通要及时、充?
要在Ȁ励成员上下工?
3分解原则
"化繁为简Q各个击?是自古以来解军_杂问题的不二法门Q对于Y仉目来Ԍ可以将大的目划分成几个小目来做Q将周期长的目化分成几个明的阶段?
目大寚w目组的管理h员、开发h员的要求高Q参与的人员多Q需要协调沟通的渠道多Q周期越长，开发h员也Ҏ疲劳Q将大项目拆分成几个项 目，可以降低寚w目管理h员的要求Q减项目的理风险Q而且能够充分地将目理的权力下放，充分调动人员的积极性，目标会比较具体明，易于取得阶段 性的成果Q开发h员有成就感?
作者主过的一个品开发项目代号ؓSBQ该目前期投入?人做需求，旉?个多月，q入开? 阶段后，投入?5人，旉?0个月之久Q陆l进行了3ơ封闭开发，在此q程中经历了需求的裁剪、开发h员的变更、技术\U的调整Q项目组成员的压力极 大，大家疲惫不堪Q品上市时间拖期达4个月。项目完工后ȝ下来的很致命的一个教训就是应该将该项目拆?个小的项目来做，q行阶段性版本化发布Q以~? 解市Z的压力，减少目l成员的挫折感，提高大家的士气?
4实时控制原则
在一家大型的软g公司中， 有一位很有个性的目l理Q该目l理很少谈v什么管理理论，也未见其有什么明昄理措施Q但是他q箋做成多个规模很大的Y仉目，而且应用效果很好? 作者一直很奇怪他Z么能做的如此成功Q经q仔l观察，l于发现他的理可以?紧盯"2字来概括Q即每天他都要仔l检查项目组每个成员的工作，从Y件演 C到内部的处理逻辑、数据结构等Q一丝不苟，如果有问题，改不完是不能M息的。正是在他这U简单的措施下，支撑他完成了很多大的目Q当然他也是相当? 辛苦Q通常都是在凌晨才M息。我们ƈ非要推崇q种做法Q这U措施也有他的问题，但是Q这U实践却说明了一个很朴实的道理：如果你没有更好的办法Q就要辛 苦一点，实时控制目的进展，要将目的进展情况完全的实时的置于你的控制之下?
上述的方法中寚w目经理的个h能力、牺牲精要? 是很高，我们需要有一U进行实时控刉目进度的机制Q依靠一套规范的q程来保证实时监控项目的q度。如在微软的理{略中强?quot;每日构徏"Q这? 实是是一U不错的ҎQ即每天要进行一ơ系l的~译链接Q通过~译链接来检查进度、检查接口、发现进展中的问题、大家互盔R׃相监督?
实时控制保目l理能够及时发现问题、解决问题，保证目h很高的可见度Q保证项目的正常q展?
5分类理原则
对于不同的Y仉目其目目标差别很大Q项目规模也是不同的Q应用领域是不同的，采用的技术\U差别也很大Q因而，针对每个目的不同特点，其管理的? 法、管理的侧重点应该是不同的。就像古的，"因材施教"Q?对症下药"。对于小目你肯定不能象理大项目那样去做，对于产品开发类的项目，你也不可 能象理pȝ集成cȝ目那样dQ项目经理需要根据项目的特点Q制订不同的目理的方针政{。如Q下表是作者ؓ一家应用Y件公司制订的目理的方 针：
在该案例中，项目分成了订单c项目与非订单类目Q非订单c项目是指由公司Ҏ市场的需求开发一个标准品的目Q而订单类 是指针对某个具体的客户定制Y件的目Q订单类的项目根据需要协调的资源的范围有划分成了公司U、部门、个人三类Q非订单cL据估的工作量的大小? 分成了A、B、C三类Q估的工作量超q?20人天的ؓAc，过360人天的ؓBc，360人天以下的ؓCcR不同类的项目管理的侧重Ҏ不同的，从立 Ҏl的完备性、计划的严格层度、周报的完备层度、规范的严格层度、跟t的实时性、是否进行阶D|ȝ、是否核项目成本、是否严D行阶D评审等多个斚w 来考虑Q以保理的可行性?
6单有效原?
目l理在进行项目管理的q程中，往往会得到开发h员这 L抱?太麻烦了Q浪Ҏ_没有用处"Q这是很普遍的一U现象。当然这L抱怨要?个方面来分析Q一斚w从开发h员本w可能存在不理解Q或者逆反? 理的情况Q另一斚wQ项目经理也要反思：我所采取的管理措施是否简单有效？搞管理不是搞学术研究Q没有完的理Q只有有效的理Q而项目经理往往试图? 住所有的漏洞Q解x有的问题Q恰恰是q种理想Q会佉K目的理陷入一个误区，作茧自缚Q最后无法实施有效的理Q导致项目的p|?
7规模控制原则
该原则是和上面提到的其他原则盔R合用的Q即要控刉目组的规模，不要人数太多Qh数多了，q行沟通的渠道多了，理的复杂度高了，寚w目经理的要求也就高了。在微Y?a target="_new" Q这是一个基本的原则Q这和我们上面提到的高效原则、分解原则是相辅相成的?
十四. 软g目理在管理思维中的I白
I白1Qؓ效益而实施项目管?br />
Z么我们要实施目理Q是Z提高目的效益。这里所指的目的效益是一个综合性的指标Q包括低风险、高产出{。ؓ此我们不隑־出我们在实施目?
理应该掌握的度。即Q引入项目管理后所产生的效益减去项目管理的成本后必d于未引入目理时的效益。由于引入项目管理后所产生的效益与目理的复?
度（目理的成本）qU性相关的Q因此项目管理的复杂度必然存在一个最优|q就是我们应该把握的度。也怸面的说法比较抽象。一个实际行之可效的?
断项目管理的度规则就是：大家认可q且能够准确地理解和实施。拿国目理专家James P Lewis的话说就是KISS原则QKeep it
simple and stupidQ，拿物理学家爱因斯坦的话说是QKeep it simple but not too simple.
I白2Q考虑所处环?br />
Mpȝ都是建立在一个具体的pȝ环境中的Q一般情况下受上一U系l媄响最为显著，q是pȝ论的观点。项目管理是企业理的下属层ơ，因此在很大程度上
目理的成功与否常常受企业理的制度制U（比如说设备采购的批复{待会g误工期）Q这是Z么常怼出现计划不如变化来的快的原因。因为我们在制定
计划时根本就没有考虑自n和客户双方的企业理的环境，所以我们的计划在实施过E中会受C业管理环境因素的影响。我敢跟你打赌：在没有h事激励机制常?
拖欠或故意克扣员工工资但获得CMM5认证的公司开发效率不会比一个没有实施项目管理的开发团队的效率高多。因为恶劣的公司Z制度扼杀了开发h员的?
才和U极性。因此，作ؓ一个项目管理者，审视自n的项目所处的企业环境q做出准的判断是非常有必要的。缺良好的目环境Q项目管理者的心血常常白费?
q往往是我们中的一些项目经理在不同的公叔R目理表现大相径庭的原因?br />
此外Q正是基于企业环境这样一个观点，目前国
PMIQ日本ENAA{提Z目理成熟度模型（OPM3和P2MQ，改变了传lPMBOK的缺P忽略外部因素和自w的灉|性）。有兴趣的项目管理?
可以参看有关目理成熟度和企业理斚wQ徏议参看职业经理h斚wQ的资料?/p>
I白3Q合理评判Y仉目管?br />
我们L把过多的目p|归罪到项目经理的名头上。他们的角色常常是替|羊而不是领D，他们拥有的更多的是责任而绝非职权。实际上目p|q完全军_于项目管理，比如?a target="_new" >信息pȝq?
低的报h。一个项目按时在预算范围内完成了而另外一个则没有按时完成Q这不意味着W一个项目管理得比较好。因为前者可能是目旉和成本宽杄目而后?
Ҏ是不可能完成的目。前者项目管理的意义在于获得较高的项目效益而后者的意义在于避免更大的项目损失。很可惜Q充满了躁的Y件企业没有诸如此cȝ
意识Q一些项目在未开始前注定是p|的，目l理们一上手便被扣以一责Q人的镣铐。因此，目理有无具体效果Q需要合理地q行评判Q单U以出效益ؓ?
的观Ҏ必有失偏颇?/p>
I白4Q心理学的必要?br />
没有一个领域像软g目理中h的因素更为重要，在Y仉域没?
实现自动化之前，一切试囑֏代h的主要作用的机制都是收效甚微的。h的行为是心智zd的表现。开发h员的心理zd军_了其在开发的表现。合适的压力能够?
起开发h员的成功Ʋ望但是q大的压力却直接影响着目参与者的w心健康。特别是后者一直以来都未能引v软g开发界的重视。很多h曄有过不明不白的辞职经
历，在没有学习《管理心理学》之前，W者对q些人的"q激"行ؓ有时x都觉得奇怪。作Z个Y仉目管理者，不了解和掌握理心理学，很难针对复杂多变
的h的因素采取合理的应对措施Q同时自w的心理健康也未必能够得C证。ؓ此笔者徏议有条g的Y件企业，可以通过聘用心理N来处理员工的心理问题Q以?
~和׃工作压力而导致的员工之间矛盾冲突和项目坍塌?/p>
I白5Q尊重常识，pȝ性考虑问题
q个观点W者在《Y
仉目管理原则谈》已l重甌。就像不要指望h一U钟跑二十米一h望项目中有过多的奇迹出现。可惜我们中的大多项目管理者在q行目理时依然实??
跃进"。我们的理者都知道自然规律不可q抗性，但是却很有人意识到一些社会规律的不可q抗性。他们M为唯物的主观能动性能够替代实际，产生奇迹。加
班被认ؓ是解册源匮乏的唯一途径Q通过开发h?无上"的生产力来达成项目的成功。很有Z意识到加班造成的疲劳会再次使工作效率降低这一事实。这?
一U缺乏常识和pȝ性思考问题的表现。诸如此cȝ表现q有"唯工兯"?唯方法论"?br />
实际上，目理涉及各个Ҏ面面Q一x高某一斚w作用而忽略该斚w对其它方面的影响Qƈ不能提高目理的层ơ和最l出，q是制止我们的项目管理者走偏激Q极端）立场的一剂良药，希望目理者们能有所意识?/p>
I白6Q学会思?br />
目理不是拿来MQ需要项目管理者进行认真的思考。这是Z么我们项目管理者中不乏PMP和IPMP但是目却未能如愿以偿的原因。理论和实践?
差距极大地挫伤项目管理者的U极性?证书无用?所持的观点其依据也在于此。理论是一U完的抽象Q而现实是各种条g的集合。我们的目理者在实践?
往往生搬套而忽略其依存条gQ这是招聘目l理"唯经验论"的来源。一位项目管理者跟我交的时候提到无法用挣|Earned
ValueQ的概念Q原因是公司Z部和财务部不愿意出示员工的收入清单。我他将挣值换为挣ӞEarned
TimeQ，以时间替代成本。从目q度的意义上来看q两者其实是一致的Q问题马上得C解决。可惜的是我们的目理者往往未学会思考具体概늚真正?
义之前ƈ匆匆上驴Q提着长枪d风R做斗争去了（注：唐吉诃dQ?/p>
I白7Q学会计?br />
现实中我们往往用补救措施代替计划，其效果便?a target="_new" >软g~陷?
攑֤效应。在目l理的招聘中Q你听到的只是几个项目管理白痴问你项目出了什么问题应该怎样解决的提问，q些目理白痴在不断地做各U问题假设，而你?
L据假N取各U符合这些项目管理白痴口味的回答。但是，作ؓ目理的来_目理的真正意义在于事先预防各U偏项目目标的问题出现而不是在于解
决问题。古话说得好"刀不误砍柴?。你不能期望癌症?00Q的L率，但是你可以通过合理的生zM惯和ȝ来防止癌症的出现。我们在q行目理
Ӟ首先应该考虑如何防止问题的出玎ͼ虽然它不能保证所有的问题Q风险）都可以避免，但是通过计划Q你拥有更多问题（风险Q应对储备，能够在问题出现时
有备无患。一个只会在问题出现时考虑应对措施的项目经理只是一个失败的目l理。其目l果无异是把健康交给ȝ而不是自己。作为项目管理的定位来说Q项
目管理应该是"理会计"的角色而不?成本会计"的角艌Ӏ?br />
最后，以某电媄的台词来l束本文;Zؓ什么犯病？单的东西惛_?
了，复杂的东西想单了Qh׃犯病"。拿q句台词来ŞҎ们目前的目理状况一点也不ؓq。Y仉目管理是一个从"自发"走向"自觉"的过E，也是一
个从l验M走向理性主义的q程。Y仉目管理是一个主动的理Q而这一切，需要广大项目管理者的目理思维和积极实c?br />
Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1231828
]]>
Services are defined using six major elements:
- types, which provides data type definitions used to describe the messages exchanged.
- message, which represents an abstract definition of the data being transmitted. A message consists of logical parts, each of which is associated with a definition within some type system.
- portType, which is a set of abstract operations. Each operation refers to an input message and output messages.
- binding, which specifies concrete protocol and data format specifications for the operations and messages defined by a particular portType.
- port, which specifies an address for a binding, thus defining a single communication endpoint.
- service, which is used to aggregate a set of related ports.
If the values being passed are part1=1, part2=2, part3=3, the request format would be as follows for each port:
port1: GET, URL="http://example.com/o1/A1B2/3"
port2: GET, URL="http://example.com/o1?p1=1&p2=2&p3=3
port3: POST, URL="http://example.com/o1", PAYLOAD="p1=1&p2=2&p3=3"
For each port, the response is either a GIF or a JPEG image.
Example 6. GET and FORM POST returning GIF or JPG
<definitions .... >
<message name="m1">
<part name="part1" type="xsd:string"/>
<part name="part2" type="xsd:int"/>
<part name="part3" type="xsd:string"/>
</message>
<message name="m2">
<part name="image" type="xsd:binary"/>
</message>
<portType name="pt1">
<operation name="o1">
<input message="tns:m1"/>
<output message="tns:m2"/>
</operation>
</portType>
<service name="service1">
<port name="port1" binding="tns:b1">
<http:address location="http://example.com/"/>
</port>
<port name="port2" binding="tns:b2">
<http:address location="http://example.com/"/>
</port>
<port name="port3" binding="tns:b3">
<http:address location="http://example.com/"/>
</port>
</service>
<binding name="b1" type="pt1">
<http:binding verb="GET"/>
<operation name="o1">
<http:operation location="o1/A(part1)B(part2)/(part3)"/>
<input>
<http:urlReplacement/>
</input>
<output>
<mime:content type="image/gif"/>
<mime:content type="image/jpeg"/>
</output>
</operation>
</binding>
<binding name="b2" type="pt1">
<http:binding verb="GET"/>
<operation name="o1">
<http:operation location="o1"/>
<input>
<http:urlEncoded/>
</input>
<output>
<mime:content type="image/gif"/>
<mime:content type="image/jpeg"/>
</output>
</operation>
</binding>
<binding name="b3" type="pt1">
<http:binding verb="POST"/>
<operation name="o1">
<http:operation location="o1"/>
<input>
<mime:content type="application/x-www-form-urlencoded"/>
</input>
<output>
<mime:content type="image/gif"/>
<mime:content type="image/jpeg"/>
</output>
</operation>
</binding>
</definitions>
4.2 How the HTTP GET/POST Binding Extends WSDL
The HTTP GET/POST Binding extends WSDL with the following extension elements:
<definitions .... >
<binding .... >
<http:binding verb="nmtoken"/>
<operation .... >
<http:operation location="uri"/>
<input .... >
<-- mime elements -->
</input>
<output .... >
<-- mime elements -->
</output>
</operation>
</binding>
<port .... >
<http:address location="uri"/>
</port>
</definitions>
These elements are covered in the subsequent sections.
4.3 http:address
The location attribute specifies the base URI for the port. The value of the attribute is combined with the values of the location attribute of the http:operation binding element. See section 4.5 for more details.
4.4 http:binding
The http:binding element indicates that this binding uses the HTTP protocol.
<definitions .... >
<binding .... >
<http:binding verb="nmtoken"/>
</binding>
</definitions>
The value of the required verb attribute indicates the HTTP verb. Common values are GET or POST, but others may be used. Note that HTTP verbs are case sensitive.
]]>
自从XML真正形成以来(我认为是Org.W3Cl织发布XML标准时开?/span>),XML得到了很快的发展,
很多厂商都有推出了自qXML解析?/span>,?/span>Apache?/span>xalan,IBM?/span>xerces,sun?/span>JDOM{?/span>,不过q些都是?/span>
ZJAXP(java API for XML processing)?/span>,?/span>JDK 1.4.0开始的后箋j2sdk里都附加?/span>JAXP,q给开?/span>人员
带来了很大的方便,q得我们在处理一般的XML功能上的问题时不再需要去用第三方?/span>XML处理器了.
随着XML的迅速发?/span>,SAX也从1.0C现在?/span>2.0?/span>(q是能够?/span>1.0兼容),l构上有了一些较大的变化.
DOM(document object model)每次dXML节点旉要把?/span>load?/span>内存??/span>,在文档很大时,显得很慢了,SAX(simple API for XML),是一?/span>XML解析器的接口,它比DOM更低U一?/span>,它是一U基于事件和回调模式?/span>XML处理方式, 因此在解析速度?/span>DOM是没法比 ?/span>(当要解析?/span>XML文档很大的时更是如此).那么?/span>SAX中事件响?/span>(event)是什么呢 ? 我个一点和Swing,AWT中的事g义有点相似的,都有是指在触发某些特定的行ؓ时所做的处理,?/span>:mouse ?/span>click事g{到. q里则是指碰到特定的XML节点的所做的处理,如文档开?/span>(startDocument),文档l束 (endDocument),元素开?/span>(startElement){很?/span>,大家看一?/span>SAX?/span>API中的Ҏ名字q道有哪些事g?/span>,基本上可以做到见 文知义的.在只惛_?/span>XML内容(只读),要求高性能,灉|?/span> 能够定位错误信息(SAX能够定位错误的行列位|?/span>)?/span>,最好用SAX来做. 一般情况下SAX是按下面的原理去使用?/span>:
<1>讄事g处理?/span>(SAX 1.0是用一个通过l承HandlerBasecȝ实例来设|的,SAX 2.0则是l承DefaultHandler?/span>,q有?/span>XMLReader方式?/span>,在原理上没有很大的区?/span>)
<2>载入要解析的内容
<3>在需要解析的事gҎ?/span>(具体参见SAX API文档)加入自己的控刉辑.
<4>重复<3>直到解析完ؓ?/span>.
在这里我自己写了一个描q电影v报信息的XML文g(file.xml),?/span>SAX2.0写了一个很单的XML内容阅读器来解析?/span>, 和大家交一下自q心得.E序在我的机器上l过了测试的(OS: win2k Advanced Server(English version),
Intel pentium CPU, 256M RAM)
*/
import org.w3c.dom.*;
import org.xml.sax.*;
import org.xml.sax.helpers.*;
import javax.xml.parsers.*;
class MyXMLReader extends DefaultHandler
{
//Fields
private int index;
private Locator locator;
//Constructor
public MyXMLReader(){
super(); //it must be done !
}
//nain method
public static void main(String[] args){
try{
SAXParserFactory sf = SAXParserFactory.newInstance();
SAXParser sp = sf.newSAXParser();
MyXMLReader reader = new MyXMLReader();
sp.parse(new InputSource("film.xml"),reader);
}
catch(Exception e){
e.printStackTrace();
}
}
//Response the startDocument event
public void startDocument() {
System.out.println("\n********************************* (: 元旦电媄h :) ***********************************\n");
}
//Response the startElement event
public void startElement(String uri, String localName, String qName, Attributes attrs){
if( qName.equalsIgnoreCase("film") ){
index ++;
int attrCount = attrs.getLength();
for( int i = 0; i < attrCount; i ++ ){
String attrName = attrs.getQName(i);
if( attrName.equalsIgnoreCase("name") ){
System.out.println("\tW?/span>" + index + "?/span>,片名:<<" + attrs.getValue(i) + ">>");
}
if( attrName.equalsIgnoreCase("price") ){
System.out.println("\th:" + attrs.getValue(i) );
}
if( attrName.equalsIgnoreCase("station") ){
System.out.println("\t放映地点:" + attrs.getValue(i) );
}
if( attrName.equalsIgnoreCase("time") ){
System.out.println("\t放映旉:" + attrs.getValue(i) );
}
if( attrName.equalsIgnoreCase("describtion") ){
System.out.println("\tq?/span>:" + attrs.getValue(i) );
}
System.out.println();
}
}
//Response the endDocument event
public void endDocument(){
System.out.println("\t\t\t\t\t\t\t------ 共有" + index + "场电p放映");
}
//Response the endElement event
public void endElement(String uri, String localName, String qName){
//add your codes if neccessary ...
}
//Print the fata error information
public void fatalError(SAXParseException e){
System.out.println("\nFatal error information -->");
System.out.println("\t" + e.getMessage());
System.out.println("\tAt line " + locator.getLineNumber() +
",column " + locator.getColumnNumber());
}
//Print the usual error information
public void error(SAXParseException e){
System.out.println("\nUsual error information -->");
System.out.println("\t" + e.getMessage());
System.out.println("\tAt line " + locator.getLineNumber() +
",column " + locator.getColumnNumber());
}
//Print the warning information
public void warning(SAXParseException e){
System.out.println("\nWarning information -->");
System.out.println("\t" + e.getMessage());
System.out.println("\tAt line " + locator.getLineNumber() +
",column " + locator.getColumnNumber());
}
//Store the error locator object
public void setDocumentLocator(Locator lct){
locator = lct;
}
}//End class MyXMLReader
?/span>
: film.xml完全?/span>内容:
<?xml version="1.0" encoding="GB2312"?>
<!-- 2003q元?/span>1号长沙市各大影院落放映列?/span> -->
<common city="ChangSha China" date="01/01/2003">
<film name="英雄" price="30" station="田汉大剧?/span>" time="19:00"
describtion="国最新大?/span>,张艺谋导?/span>,梁朝?/span>,张曼?/span>,李连杰等众多大明星主?/span>">
</film>
<film name="无间?/span>" price="20" station="长沙市演Z?/span>" time="15:00"
describtion="韩国大片">
</film>
<film name="武士" price="20" station="湖南省电影院" time="17:00"
describtion="韩国大片,有点像英?/span>">
</film>
<film name="长排׃?/span>" price="15" station="长沙市电p?/span>A1?/span>" time="19:00"
describtion="反映对越自卫反击战时期中国军人的故事?/span>">
</film>
<film name="高山下的q" price="15" station="长沙市电p?/span>A2?/span>" time="19:00"
describtion="反映对越自卫反击战时期中国军人的故事?/span>">
</film>
<film name="q里的黎明静悄悄" price="15" station="长沙市电p?/span>A3?/span>" time="19:00"
describtion="反映对越自卫反击战时期中国军人的故事?/span>">
</film>
<film name="子夜" price="15" station="长沙市电p?/span>B1?/span>" time="19:00"
describtion="反映对越自卫反击战时期中国军人的故事?/span>">
</film>
</common>
]]>
]]>
2?span style="font-family: "Times New Roman"; font-style: normal; font-variant: normal; font-weight: normal; font-size: 7pt; line-height: normal; font-size-adjust: none; font-stretch: normal;">
Java 中所有的对象都是通过 new 来动态?/span>3?span style="font-family: "Times New Roman"; font-style: normal; font-variant: normal; font-weight: normal; font-size: 7pt; line-height: normal; font-size-adjust: none; font-stretch: normal;">
所有的容器 (collection) ?/span> Object array( 对象数组 e.g String []str=new String[10]) 内都包含都是对象?/span> reference4?span style="font-family: "Times New Roman"; font-style: normal; font-variant: normal; font-weight: normal; font-size: 7pt; line-height: normal; font-size-adjust: none; font-stretch: normal;">
?/span> java 中， java ~译器有责Q产生“将 stack 指针前后Ud“的E序代码Q所?/span> 它必能够完全掌握它所~译的的E序中“存?/span> stack 里头的所有数据的实际大小和存zL间“， 如此一来便会限制程序的Ҏ?/span> ׃q个限制Q尽我们可以将对象?/span> reference 存储?/span> stack 内，但却不能一般的 java 对象攑֜ stack ?/span>特例Q（ primitive types Q?/span>
基本型别会经常被使用Q如果?/span> new 来生此cL，极简单的变量Q会因?/span> new 对象置?/span> heap 之上?/span> 而效率不好。因此对于此cd?/span> java 采取 c/c++ 的方式，也就是不?/span> new 分配器空_而是产生一U所谓的 ”automatic “变量，存于 static ?/span>
5?span style="font-family: "Times New Roman"; font-style: normal; font-variant: normal; font-weight: normal; font-size: 7pt; line-height: normal; font-size-adjust: none; font-stretch: normal;">
当你产生某个存储对象的数l，真正产生的是个存?/span> reference 的数l。此数组建立之后Q其中的每一?/span> reference 都会被自动设为某个特D的?/span> null,6?span style="font-family: "Times New Roman"; font-style: normal; font-variant: normal; font-weight: normal; font-size: 7pt; line-height: normal; font-size-adjust: none; font-stretch: normal;">
{ String s=new String(“ddd?;} s q个 reference 会在生存I间之外消失无踪Q但是， s 先前所指的那个 String 对象仍然会l占用内?/span>7?span style="font-family: "Times New Roman"; font-style: normal; font-variant: normal; font-weight: normal; font-size: 7pt; line-height: normal; font-size-adjust: none; font-stretch: normal;">
Class 内的基本型别变量都有初|但是在函数内?/span> local variable 是没有初值的8?span style="font-family: "Times New Roman"; font-style: normal; font-variant: normal; font-weight: normal; font-size: 7pt; line-height: normal; font-size-adjust: none; font-stretch: normal;">
Java 中，所有传递的对象的场合，传递的都是对象?/span> reference.9?span style="font-family: "Times New Roman"; font-style: normal; font-variant: normal; font-weight: normal; font-size: 7pt; line-height: normal; font-size-adjust: none; font-stretch: normal;">
Return Q?/span> 说明q个函数q行l束Q返回到其调用函数?/span> Return 2 Q返回一个数 2 l调用者，同时l束本函数的q行?/span>10?span style="font-family: "Times New Roman"; font-style: normal; font-variant: normal; font-weight: normal; font-size: 7pt; line-height: normal; font-size-adjust: none; font-stretch: normal;">
Class 内的 non-static data(state) ?/span> method , 都是和特定的对象l定的，一般情况下Q你的生某个对象，再通过该对象取用其数据和函数。所?/span> non-static 数据 / 函数必须知道他们隶属于哪一个对象，才有办法q行 .static 函数内不能?/span> non-static 数据和函?/span>11?span style="font-family: "Times New Roman"; font-style: normal; font-variant: normal; font-weight: normal; font-size: 7pt; line-height: normal; font-size-adjust: none; font-stretch: normal;">
(object1= = object2 ) 两个对象?/span> reference ?/span> = = 比较得是两个对象的内存的地址。所以我们不能?/span> = = 来测试两个对象的内容是否相等。如果想试对象的内Ҏ否相{，应该使用 equal(), M一个对象都拥有q个函数。不q你自己?/span> class 需?/span> override q个函数Q否则默认的 equal() 函数是还是比较的两个对象的内存地址?/span>Java 标准E序库中的大多数 class ?/span> override ?/span> equal(), 所以他们都会比较对象的内容是否相等?/span>
12?span style="font-family: "Times New Roman"; font-style: normal; font-variant: normal; font-weight: normal; font-size: 7pt; line-height: normal; font-size-adjust: none; font-stretch: normal;">
位运符都是作用于基本正数类型。该q算W主要是针对g~程使用Q我们用得不多，Q?/span>
待箋
]]>
First of all, if you develop your application by Eclipse, it means you have had the ant tool and you need not to download the internet.
Projects
A project has three attributes:
| Attribute | Description | Required |
| name | the name of the project. | No |
| default | the default target to use when no target is supplied. | No; however, since Ant 1.6.0, every project includes an implicit target that contains any and all top-level tasks and/or types. This target will always be executed as part of the project's initialization, even when Ant is run with the -projecthelp option. |
| basedir | the base directory from which all path calculations are done. This attribute might be overridden by setting the "basedir" property beforehand. When this is done, it must be omitted in the project tag. If neither the attribute nor the property have been set, the parent directory of the buildfile will be used. | No |
Optionally, a description for the project can be provided as a top-level
description
type).
Each project defines one or more targets. A target is a set of tasks you want to be executed. When starting Ant, you can select which target(s) you want to have executed. When no target is given, the project's default is used.
Targets
A target can depend on other targets. You might have a target for compiling, for example, and a target for creating a distributable. You can only build a distributable when you have compiled first, so the distribute target depends on the compile target. Ant resolves these dependencies.
It should be noted, however, that Ant's
Suppose we want to execute target D. From its
A target also has the ability to perform its execution if (or unless) a property has been set. This allows, for example, better control on the building process depending on the state of the system (java version, OS, command-line property defines, etc.). To make a target sense this property, you should add the
In the first example, if the
If no
Important: the
The optional
It is a good practice to place your
tstamp
tasks in a so-called initialization target, on which all other targets depend. Make sure that target is always the first one in the depends list of the other targets. In this manual, most initialization targets have the name
If the depends attribute and the if/unless attribute are set, the depends attribute is executed first.
A target has the following attributes:
A target name can be any alphanumeric string valid in the encoding of the XML file. The empty string "" is in this set, as is comma "," and space " ". Please avoid using these, as they will not be supported in future Ant versions because of all the confusion they cause. IDE support of unusual target names, or any target name containing spaces, varies with the IDE.
Targets beginning with a hyphen such as
A task is a piece of code that can be executed.
A task can have multiple attributes (or arguments, if you prefer). The value of an attribute might contain references to a property. These references will be resolved before the task is executed.
Tasks have a common structure:
where name is the name of the task, attributeN is the attribute name, and valueN is the value for this attribute.
There is a set of
built-in tasks
, along with a number of
optional tasks
, but it is also very easy to
write your own
.
All tasks share a task name attribute. The value of this attribute will be used in the logging messages generated by Ant.
Tasks can be assigned an
where taskname is the name of the task, and taskID is a unique identifier for this task. You can refer to the corresponding task object in scripts or other tasks via this name. For example, in scripts you could do:
to set the
Note1: If "task1" has not been run yet, then it has not been configured (ie., no attributes have been set), and if it is going to be configured later, anything you've done to the instance may be overwritten.
Note2: Future versions of Ant will most likely not be backward-compatible with this behaviour, since there will likely be no task instances at all, only proxies.
A project can have a set of properties. These might be set in the buildfile by the
property
task, or might be set outside Ant. A property has a name and a value; the name is case-sensitive. Properties may be used in the value of task attributes. This is done by placing the property name between "
Ant provides access to all system properties as if they had been defined using a
For a list of system properties see
the Javadoc of System.getProperties
.
In addition, Ant has some built-in properties:
Notice that we are declaring properties outside any target. As of Ant 1.6 all tasks can be declared outside targets (earlier version only allowed <typedef> and <antcall>
We have given some targets descriptions; this causes the
Finally, for this target to work the source in the <javac> task for details.
A project can have a set of tokens that might be automatically expanded if found when a file is copied, when the filtering-copy behavior is selected in the tasks that support this. These might be set in the buildfile by the
filter
task.
Since this can potentially be a very harmful behavior, the tokens in the files must be of the form
Warning: If you copy binary files with filtering turned on, you can corrupt the files. This feature should be used with text files only.
You can specify
Wherever path-like values need to be specified, a nested element can be used. This takes the general form of:
The
As a shortcut, the
can be abbreviated to:
In addition,
DirSet
s,
FileSet
s, and
FileList
s can be specified via nested
This builds a path that holds the value of
A path-like structure can include a reference to another path-like structure via nested
The shortcuts previously mentioned for
can be written as:
Ant tries to execute the targets in the
<target name="A"/>
<target name="B" depends="A"/>
<target name="C" depends="B"/>
<target name="D" depends="C,B,A"/>
In a chain of dependencies stretching back from a given target such as D above, each target gets executed only once, even when more than one target depends on it. Thus, executing the D target will first result in C being called, which in turn will first call B, which in turn will first call A. After A, then B, then C have executed, execution returns to the dependency list of D, which will not call B and A, since they were already called in process of dependency resolution for C and B respectively as dependencies of D. Had no such dependencies been discovered in processing C and B, B and A would have been executed after C in processing D's dependency list.
unless) attribute with the name of the property that the target should react to. Note: Ant will only check whether the property has been set, the value doesn't matter. A property set to the empty string is still an existing property. For example:
<target name="build-module-A" if="module-A-present"/>
<target name="build-own-fake-module-A" unless="module-A-present"/>
module-A-present property is set (again, to any value), the target will not be run.
unless attribute is present, the target will always be executed.
unless attributes only enable or disable the target to which they are attached. They do not control whether or not targets that a conditional target depends upon get executed. In fact, they do not even get evaluated until the target is about to be executed, and all its predecessors have already run.
-projecthelp command-line option. Targets without such a description are deemed internal and will not be listed, unless either the -debug.
Attribute
Description
Required
name
the name of the target.
Yes
depends
a comma-separated list of names of targets on which this target depends.
No
if
the name of the property that must be set in order for this target to execute.
No
unless
the name of the property that must not be set in order for this target to execute.
No
description
a short description of this target's function.
No
are valid, and can be used to name targets that should not be called directly from the command line.
Tasks
<nameattribute1="value1" attribute2="value2" ... />
<taskname id="taskID" ... />
for example).
<script ... >
task1.setFoo("bar");
</script>
project.getReference("task1").
Properties
build/classes.
Built-in Properties
${os.name} expands to the name of the operating system.
basedir the absolute path of the project's basedir (as set
with the basedir attribute of <project>).
ant.file the absolute path of the buildfile.
ant.version the version of Ant
ant.project.name the name of the project that is currently executing;
it is set in the name attribute of <project>.
ant.java.version the JVM version Ant detected; currently it can hold
the values "1.1", "1.2", "1.3", "1.4" and "1.5".
Example Buildfile
<project name="MyProject" default="dist" basedir=".">
<description>
simple example build file
</description>
<!-- set global properties for this build -->
<property name="src" location="src"/>
<property name="build" location="build"/>
<property name="dist" location="dist"/>
<target name="init">
<!-- Create the time stamp -->
<tstamp/>
<!-- Create the build directory structure used by compile -->
<mkdir dir="${build}"/>
</target>
<target name="compile" depends="init"
description="compile the source " >
<!-- Compile the java code from ${src} into ${build} -->
<javac srcdir="${src}" destdir="${build}"/>
</target>
<target name="dist" depends="compile"
description="generate the distribution" >
<!-- Create the distribution directory -->
<mkdir dir="${dist}/lib"/>
<!-- Put everything in ${build} into the MyProject-${DSTAMP}.jar file -->
<jar jarfile="${dist}/lib/MyProject-${DSTAMP}.jar" basedir="${build}"/>
</target>
<target name="clean"
description="clean up" >
<!-- Delete the ${build} and ${dist} directory trees -->
<delete dir="${build}"/>
<delete dir="${dist}"/>
</target>
</project>
Token Filters
@, where token is the token name that is set in the
Note: If a token with the format @ is found in a file, but no filter is associated with that token, no changes take place; therefore, no escaping method is available - but as long as you choose appropriate names for your tokens, this should not cause problems.
Path-like Structures
CLASSPATH-type references using both "
<classpath>
<pathelement path="${classpath}"/>
<pathelement location="lib/helper.jar"/>
</classpath>
path attribute accepts colon- or semicolon-separated lists of locations. The location attributes should be preferred.
path and
<classpath>
<pathelement path="${classpath}"/>
</classpath>
<classpath path="${classpath}"/>
<fileset>, and
<classpath>
<pathelement path="${classpath}"/>
<fileset dir="lib">
<include name="**/*.jar"/>
</fileset>
<pathelement location="classes"/>
<dirset dir="${build.dir}">
<include name="apps/**/classes"/>
<exclude name="apps/**/*Test*"/>
</dirset>
<filelist refid="third-party_jars"/>
</classpath>
lib directory, the classes under the ${build.dir}, except those that have the text
If you want to use the same path-like structure for several tasks, you can define them with a
References
for an example.
<path id="base.path">
<pathelement path="${classpath}"/>
<fileset dir="lib">
<include name="**/*.jar"/>
</fileset>
<pathelement location="classes"/>
</path>
<path id="tests.path">
<path refid="base.path"/>
<pathelement location="testclasses"/>
</path>
<path>.For example:
<path id="base.path">
<pathelement path="${classpath}"/>
</path>
<path id="base.path" path="${classpath}"/>
generally, you need not to write your builder.xml file started from scratch. you can just modify the following
part to meet your demand.
<project name="javastep" default="deploy" basedir=".">
<!-- ===================== Property Definitions =========================== -->
<!--
All properties should be defined in this section.
Any host-specific properties should be defined
in the build.properties file.
In this app, the following properties are defined in build.properties:
o tomcat.home - the home directory of your Tomcat installation
o webapps.home - the place to copy the war file to deploy it
-->
<property file="build.properties" />
<property name="app.home" value="." />
<property name="app.name" value="javastep" />
<property name="javadoc.pkg.top" value="hello" />
<property name="src.home" value="${app.home}/src"/>
<property name="lib.home" value="${app.home}/WebRoot/WEB-INF/lib"/>
<property name="classes.home" value="${app.home}/WebRoot/WEB-INF/classes/"/>
<property name="deploy.home" value="${app.home}/deploy"/>
<property name="doc.home" value="${app.home}/doc"/>
<property name="web.home" value="${app.home}/WebRoot"/>
<property name="build.home" value="${app.home}/build"/>
<property name="build.classes" value="${build.home}/WEB-INF/classes"/>
<property name="build.lib" value="${build.home}/WEB-INF/lib"/>
<!-- ==================== Compilation Classpath =========================== -->
<!--
This section creates the classpath for compilation.
-->
<path id="compile.classpath">
<!-- The object files for this application -->
<pathelement location="${classes.home}"/>
<!-- The lib files for this application -->
<fileset dir="${lib.home}">
<include name="*.jar"/>
<include name="*.zip"/>
</fileset>
<!-- All files/jars that Tomcat makes available -->
</path>
<!-- ==================== Build Targets below here========================= -->
<!-- ==================== "help" Target =================================== -->
<!--
This is the default ant target executed if no target is specified.
This helps avoid users just typing 'ant' and running a
default target that may not do what they are anticipating...
-->
<target name="help" >
<echo message="Please specify a target! [usage: ant <targetname>]" />
<echo message="Here is a list of possible targets: "/>
<echo message=" clean-all.....Delete build dir, all .class and war files"/>
<echo message=" prepare.......Creates directories if required" />
<echo message=" compile.......Compiles source files" />
<echo message=" build.........Build war file from .class and other files"/>
<echo message=" deploy........Copy war file to the webapps directory" />
<echo message=" javadoc.......Generates javadoc for this application" />
</target>
<!-- ==================== "clean-all" Target ============================== -->
<!--
This target should clean up any traces of the application
so that if you run a new build directly after cleaning, all
files will be replaced with what's current in source control
-->
<target name="clean-all" >
<delete dir="${build.home}"/>
<delete dir="${classes.home}"/>
<delete dir="${deploy.home}"/>
<!-- can't delete directory if Tomcat is running -->
<delete dir="${webapps.home}/${app.name}" failonerror="false"/>
<!-- deleting the deployed .war file is fine even if Tomcat is running -->
<delete dir="${webapps.home}/${app.name}.war" />
<!-- delete the javadoc -->
<delete dir="${doc.home}"/>
</target>
<!-- ==================== "prepare" Target ================================ -->
<!--
This target is executed prior to any of the later targets
to make sure the directories exist. It only creates them
if they need to be created....
Other, similar, preparation steps can be placed here.
-->
<target name="prepare">
<echo message="Tomcat Home = ${tomcat.home}" />
<echo message="webapps Home = ${webapps.home}" />
<mkdir dir="${classes.home}"/>
<mkdir dir="${deploy.home}"/>
<mkdir dir="${doc.home}"/>
<mkdir dir="${doc.home}/api"/>
<mkdir dir="${build.home}"/>
<mkdir dir="${build.home}/WEB-INF" />
<mkdir dir="${build.home}/WEB-INF/classes" />
<mkdir dir="${build.home}/WEB-INF/lib" />
</target>
<!-- ==================== "compile" Target ================================ -->
<!--
This only compiles java files that are newer
than their corresponding .class files.
-->
<target name="compile" depends="prepare" >
<javac srcdir="${src.home}" destdir="${classes.home}" debug="yes" >
<classpath refid="compile.classpath"/>
</javac>
</target>
<!-- ==================== "build" Target ================================== -->
<!--
This target builds the war file for the application
by first building the directory structure of the
application in ${build.home} and then creating the
war file using the ant <war> task
-->
<target name="build" >
<!-- Copy all the webapp content (jsp's, html, tld's, xml, etc. -->
<!-- Note that this also copies the META-INF directory -->
<copy todir="${build.home}">
<fileset dir="${web.home}"/>
</copy>
<!-- Now, copy all the Java class files -->
<copy todir="${build.home}/WEB-INF/classes">
<fileset dir="${classes.home}"/>
</copy>
<!-- Now, copy all the properties files, etc that go on the classpath -->
<copy todir="${build.home}/WEB-INF/classes">
<fileset dir="${src.home}">
<include name="**/*.properties" />
<include name="**/*.prop" />
</fileset>
</copy>
<!-- Now, copy all the jar files we need -->
<copy todir="${build.home}/WEB-INF/lib">
<fileset dir="${lib.home}" />
</copy>
<!-- Create the <war> file -->
<jar jarfile="${deploy.home}/${app.name}.war"
basedir="${build.home}"/>
</target>
<!-- ==================== "deploy" Target ================================= -->
<!--
This target simply copies the war file from the deploy
directory into the Tomcat webapp directory.
-->
<target name="deploy" depends="build" >
<!-- Copy the contents of the build directory -->
<copy todir="${webapps.home}" file="${deploy.home}/${app.name}.war" />
</target>
<!-- ==================== "doc" Target ==================================== -->
<!--
This task creates javadoc. It is dependent upon only the
'compile' target so it is not executed in a normal build.
As a result, the target needs to be run on its own.
-->
<target name="javadoc" depends="compile">
<javadoc sourcepath = "${src.home}"
destdir = "${doc.home}/api"
packagenames = "${javadoc.pkg.top}.*"/>
</target>
<!-- ==================== "test" Target ================================== -->
<!--
This task runs all test cases. It invokes each test case individually.
The "test-all" target is tied back to the "struts-test" target which
actually runs the tests. This allows other test targets to be created
in this section while maintaining the ability to run each test target
individually. All individual test targets should be added to the
"depends" attribute of the "test-all" target to provide a single
target that runs all tests.
-->
<target name="test-all" depends="struts-tests" />
<target name="struts-tests" depends="build" >
<junit printsummary="yes" >
<classpath >
<pathelement location="${classes.home}"/>
<pathelement location="${build.home}"/>
<pathelement location="${build.home}/WEB-INF/classes"/>
<path refid="compile.classpath"/>
</classpath>
<formatter type="plain" />
<test name="hello.mocktest.TestHelloAction" />
<test name="hello.mocktest.TestHelloActionMultiple" />
</junit>
</target>
</project>
]]>
To be able to specify which mappers will be applied to a request, create the file [web-app]/WEB-INF/sitemesh.xml that contains the following:
<sitemesh>
<property name="decorators-file" value="/WEB-INF/decorators.xml" />
<excludes file="${decorators-file}" />
<page-parsers>
<parser content-type="text/html"
class="com.opensymphony.module.sitemesh.parser.FastPageParser" />
<parser content-type="text/html;charset=ISO-8859-1"
class="com.opensymphony.module.sitemesh.parser.FastPageParser" />
</page-parsers>
<decorator-mappers>
<mapper class="com.opensymphony.module.sitemesh.mapper.ConfigDecoratorMapper">
<param name="config" value="${decorators-file}" />
</mapper>
</decorator-mappers>
</sitemesh>
in this example, the only mapper that will be applied is the ConfigDecoratorMapper, and that will only be applied to responses of type text/html or text/html;charset=ISO-8859-1. Responses of any other content type (eg image/gif) will be ignored by Sitemesh. Additionally, any files that match a pattern specified in the excludes file (in this case '/WEB-INF/decorators.xml') will not be touched by Sitemesh.
The excludes file points to an XML file that contains an <excludes /> block similar to the following: add the following code in your decorators.xml
<decorators defaultdir="/decorators">
<excludes>
<pattern>/plainPage.jsp</pattern>
<pattern>/ewebeditor/*.*</pattern>
</excludes>
<decorator name="main" page="main.jsp">
<pattern>/*</pattern>
</decorator>
</decorators>
]]>
sitemesh-2.2.1.jar into [web-app]/WEB-INF/lib.
[web-app]/WEB-INF/decorators.xml that contains the following:
<decorators>
</decorators>[web-app]/WEB-INF/sitemesh.xml that contains the following: <sitemesh>
<property name="decorators-file" value="/WEB-INF/decorators.xml" />
<excludes file="${decorators-file}" />
<page-parsers>
<parser content-type="text/html"
class="com.opensymphony.module.sitemesh.parser.FastPageParser" />
<parser content-type="text/html;charset=ISO-8859-1"
class="com.opensymphony.module.sitemesh.parser.FastPageParser" />
</page-parsers>
<decorator-mappers>
<mapper class="com.opensymphony.module.sitemesh.mapper.ConfigDecoratorMapper">
<param name="config" value="${decorators-file}" />
</mapper>
</decorator-mappers>
</sitemesh>
[web-app]/WEB-INF/web.xml within the <web-app> tag:
<filter>
<filter-name>sitemesh</filter-name>
<filter-class>com.opensymphony.module.sitemesh.filter.PageFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>sitemesh</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
Decorators are the pages that "decorate" the original, requested page (the page that is handed to the SiteMesh filter from the web container). Most (HTML) decorators are a combination of:
- meta tags (keywords, description, author)
- stylesheet (CSS)
- header
- navigation
- footer
- copyright notice
Web Application Structure
Here is an example structure of a web application. This is not needed for SiteMesh to work.
/decorators | Directory containing all decorator files (e.g. |
/includes | Directory containing all files to be included into other files (e.g. |
/images | Directory containing all images (e.g. |
/styles | Directory containing all .CSS styles (e.g. |
/scripts | Directory containing all scripts (JavaScript, VBScript files). |
Good practices:
- Define a stylesheet to use in the entire application and include it using this script.
- Use includes in your decorators (e.g.
includes/navigation.jsp,includes/style.jsp). - Try not to refer to the absolute root ("
/") path. Use<%=request.getContextPath()%>/instead. This will make life easier when moving your web application under another context path. - Making your decorators compatible with multiple browsers (IE, Mozilla, Opera, ...) will (probably) make your entire application (all decorated pages) compatible.
- Be careful when using frames, because decorators may NOT be applied to frames (FrameSetDecoratorMapper).
My First Decorator
Basically, all you need to know is what decorator tags you can use. The title, head and body tags are most used.Here is an example of a decorator (save it as /decorators/main.jsp):
1: <%--
2: % This is the main decorator for all SOMECOMPANY INTRANET pages.
3: % It includes standard caching, style sheet, header, footer and copyright notice.
4: --%>
5: <%@ taglib uri="http://www.opensymphony.com/sitemesh/decorator" prefix="decorator" %>
6: <%@ include file="7: <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
8: <html>
9: <head>
10: <title><decorator:title default="INTRANET" /></title>
11: <decorator:head />
12: <%@ include file="
13: </head>
14: <body bgcolor="#FFFFFF" background="<%=request.getContextPath()%>/images/bg.gif">
15: <script type="text/javascript">window.status = "Loading: <decorator:title default="INTRANET" />...";</script>
16: <%@ include file="/includes/header.jsp"%>
17: <table width="100%" border="0" cellspacing="0" cellpadding="0">
18: <tr>
19: <td height="20" nowrap> </td>
20: </tr>
21: <tr>
22: <td width="1%" nowrap> </td>
23: <td width="16%" valign="top" nowrap>
23: <script type="text/javascript">window.status = "Loading: Navigation...";</script>
24: <%@ include file="/includes/navigation.jsp" %>
25: </td>
26: <td width="2%" nowrap> </td>
27: <td valign="top">
28: <br>
29: <script type="text/javascript">window.status = "Loading: Document body...";</script>
30: <div class="docBody"><decorator:body /></div>
31: </td>
32: <td width="1%" nowrap> </td>
33: </tr>
34: </table>
35: <br>
36: <%@ include file="/includes/footer.jsp" %>
37: <%@ include file="/includes/copyright.jsp" %>
38: <script type="text/javascript">window.status = "Done";</script>
39: </body>
40: </html>
- Line 1-4:
An explanation of the decorator. This way different people working on the decorator are quickly up to speed. - Line 5:
This is needed for thedecorator:tags to work (also needed on all pages that work with inline decorators (page:applyDecorator). - Line 6:
Sets the necessary response headers to let the browser cache the page. Omit this line if your application is real dynamic (changing data). - Line 10:
If the requested page doesn't have a title, the default title is used ("INTRANET"). - Line 15:
The status bar gets a message when the page is loading. - Line 30:
The entire body of the requested page has thedocBodyclass. This way the navigation and body do not have to have the same font.
Now open WEB-INF/decorators.xml with your favorite editor and let SiteMesh know there is a decorator (with a mapping):
<decorators defaultdir="/decorators">
<decorator name="main" page="main.jsp">
<pattern>/*</pattern>
</decorator>
</decorators>
Now deploy the web application, go to the welcome page, and the main decorator will be applied.
When a page has been parsed, it then has to be mapped to a decorator. This mapping is performed by a chain of DecoratorMappers (referred to as mappers from here on).
For each request, the first mapper in the chain is asked which decorator should be used. It is passed across a reference to the Page object and HttpServletRequest. It returns either a Decorator object, if it knows which decorator to be used, or null. If null is returned, the next mapper in the chain is queried. This whole process is repeated until there are no more mappers in the chain, or one of the mappers returns a valid decorator. If no mappers return a decorator, the page is not decorated at all and served in its original state.
This way the mappers are chained together and queried is known as the Chain of Responsibility design pattern.
Examples of mappers:
- Determine decorator based on path of requested page.
- Use different decorators based on time, locale or browser.
- Use simplified decorators for search-engine robots.
- Switch decorators based on a URL parameter, request attribute or meta-tag.
- Use custom decorators based on user's saved settings...
The main implementation of DecoratorMapper is ConfigDecoratorMapper which reads the decorators and mappings from /WEB-INF/decorators.xml. The appropriate decorator is then applied depending on the URL pattern.
DecoratorMappers are simple to write and the distribution includes some samples that demonstrate how to write them and how flexible they can be. These are:
| AgentDecoratorMapper | Can determine the user-agent (i.e. web-browser) requesting a page, and map to a suitable Decorator. |
| ConfigDecoratorMapper | Default implementation of DecoratorMapper. Reads decorators and mappings from the config property (default '/WEB- INF/decorators.xml'). |
| CookieDecoratorMapper | Will map a suitable decorator based on a cookie value. |
| EnvEntryDecoratorMapper | Allows the reference to a web-app environment entry for the decorator name, and falls back to ConfigDecoratorMapper's behavior if no matching environment entry is found. |
| FileDecoratorMapper | Will treat the name of the decorator as a file-name to use (in the context of the web-app). |
| FrameSetDecoratorMapper | Will use the specified decorator when the Page is an instance of HTMLPage and isFrameSet() returns true. The name of this decorator should be supplied in the decorator property - if no decorator property is supplied, no decorator is applied to frame based pages. |
| InlineDecoratorMapper | Used to determine the correct Decorator when using inline decorators. |
| LanguageDecoratorMapper | Can determine the preferred language set in the browser requesting a page, and map to a suitable Decorator (using the "Accept-Language" HTTP header). |
| PageDecoratorMapper | The actual Page determines the Decorator to be used.
The 'meta.decorator' and 'decorator' properties of the page are accessed and if any of them contain the name of a valid Decorator, that Decorator shall be applied. |
| ParameterDecoratorMapper | Will choose the decorator based on request parameters.
The ParameterDecoratorMapper is configured via three properties.
For example if You can also supply an optional 'confirmation parameter'. The decorator will only be mapped if the parameter named For example assuming parameter.name=confirm and parameter.value=true the URI myurl.jsp?decorator=mydecorator&confirm=true will map the decorator mydecorator. where as the URIs myurl.jsp?decorator=mydecorator and myurl.jsp?decorator=mydecorator&confirm=false will not return any decorator. |
| SessionDecoratorMapper |
Will look at a session attribute to find the name of an appropriate decorator to use. If the session attribute is present, the mapper will not do anything and allow the next mapper in the chain to select a decorator. By default, it will look at the 'decorator' session attribute, however this can be overriden by configuring the mapper with a 'decorator.parameter' property. |
| PrintableDecoratorMapper | Will check to see whether 'printable=true' is supplied as a request parameter and if so, use the specified decorator instead. The name of this decorator should be supplied in the decorator property. |
| RobotDecoratorMapper | Will use the specified decorator when the requester is identified as a robot (also known as spider, crawler, ferret) of a search engine. The name of this decorator should be supplied in the decorator property. |
An example of a custom DecoratorMapper could be one that displays different Decorators based on time (e.g. morning, afternoon, Christmas, etc).
Custom mapper configuration
To be able to specify which mappers will be applied to a request, create the file [web-app]/WEB-INF/sitemesh.xml that contains the following:
<sitemesh>
<property name="decorators-file" value="/WEB-INF/decorators.xml" />
<excludes file="${decorators-file}" />
<page-parsers>
<parser content-type="text/html"
class="com.opensymphony.module.sitemesh.parser.FastPageParser" />
<parser content-type="text/html;charset=ISO-8859-1"
class="com.opensymphony.module.sitemesh.parser.FastPageParser" />
</page-parsers>
<decorator-mappers>
<mapper class="com.opensymphony.module.sitemesh.mapper.ConfigDecoratorMapper">
<param name="config" value="${decorators-file}" />
</mapper>
</decorator-mappers>
</sitemesh>
In this example, the only mapper that will be applied is the ConfigDecoratorMapper, and that will only be applied to responses of type text/html or text/html;charset=ISO-8859-1. Responses of any other content type (eg image/gif) will be ignored by Sitemesh. Additionally, any files that match a pattern specified in the excludes file (in this case '/WEB-INF/decorators.xml') will not be touched by Sitemesh.
The excludes file points to an XML file that contains an <excludes /> block similar to the following:
<decorators>
<excludes>
<pattern>/plainPage.jsp</pattern>
<pattern>/plain/*.jsp</pattern>
</excludes>
</decorators>
The above example would prevent /plainPage.jsp and any JSP pages in the /plain directory from being decorated. (Note that the pattern matching follows exactly the same rules as the decorator mappings used by the ConfigDecoratorMapper.)
Typically the <excludes /> block is just added at the start of the decorators.xml file, however this is not a requirement and any other XML file can be specified instead by changing the excludes file specified in sitemesh.xml. This might be useful if for example the ConfigDecoratorMapper is not being used in your deployment.
Note that preventing pages from being decorated by adding them to the excludes list superceeds, and is a better approach than, the old method of mapping the pages to a non-existent decorator. This is because when pages were mapped to a non-existent decorator they were still buffered internally by Sitemesh. By using the exclude list Sitemesh will not let the request pass straight through to the servlet container without any buffering.
Default mapper configuration
If sitemesh.xml is not found in the WEB-INF dir, the default mapper configuration will be used. The default mapper configuration is defined in sitemesh-default.xml (packaged inside the jar) and consists of the following mappers:
- PageDecoratorMapper
- FrameSetDecoratorMapper
- PrintableDecoratorMapper
- FileDecoratorMapper
- ConfigDecoratorMapper
By default only content of type text/html will be decorated by Sitemesh.
for more detail, please refer to http://www.opensymphony.com/sitemesh/dm.html
]]>
it is very simple, you externalize some of the data in an object, so that you can pretend that you have more objects than you really do. However, this adds complexity to the interface for using such objects, because you must pass in additional information to method calls in order to tell the method how to find the externalized information.
The use of layered objects to dynamically and transparently add responsibilities to individual objects is referred to as the decorator pattern.
Used when subclassing creates too many (& inflexible) classes
All decorators that wrap around the original object must have the same basic interface
Dynamic proxy/surrogate?
This accounts for the odd inheritance structure
Tradeoff: coding is more complicated when using decorators
Basic decorator structure
Connecting different types
1.Adapter
Adapter takes one type and produces an interface to some other type. When you’ve got this,
and you need that, Adapter solves the problem. The only requirement is to produce a that,
and there are a number of ways you can accomplish this adaptation.
//: adapter:SimpleAdapter.java
// "Object Adapter" from GoF diagram
package adapter;
import junit.framework.*;
class Target {
public void request() {}
}
class Adaptee {
public void specificRequest() {
System.out.println("Adaptee: SpecificRequest");
}
}
class Adapter extends Target {
private Adaptee adaptee;
public Adapter(Adaptee a) {
adaptee = a;
}
public void request() {
adaptee.specificRequest();
}
}public class SimpleAdapter extends TestCase {
Adaptee a = new Adaptee();
Target t = new Adapter(a);
public void test() {
t.request();
}
public static void main(String args[]) {
junit.textui.TestRunner.run(SimpleAdapter.class);
}
} ///:~
2. Bridge
but the goal of Bridge is to allow you to structure your code so that you can easily add new kinds of front-end objects which are implemented with functionality in new kinds of back-end objects. Thus, both front-end and back-end can vary independently of each other.
The front-end classes can have completely different interfaces from each other, and typically do. What they have in common is that they can implement their functionality using facilities from any number of different back-end objects. The back-end objects also don’t have the same interface. The only thing the back-end objects must have in common is that they implement the same kind of functionality ?for example, a group of different ways to implement a graphics library or a set of different data-storage solutions.
Bridge is really a code-organization tool that allows you to add in any number of new frontend services that implement their operations by delegating to any number of back-end options. Using Bridge, you can accomplish this without the normal combinatorial explosion of possibilities that would otherwise occur. But keep in mind that the vector of change with Bridge is typically happening at coding time: it keeps your code organized when you are dealing with an increasing number of options for implementing functionality.
]]>